From 83b9d5c682b21d88133f24da0f94dd56bd79e687 Mon Sep 17 00:00:00 2001
From: 单军华
Date: Thu, 19 Jul 2018 13:38:55 +0800
Subject: [PATCH] change
---
screendisplay/Pods/YYCategories/YYCategories/Quartz/YYCGUtilities.h | 330 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 330 insertions(+), 0 deletions(-)
diff --git a/screendisplay/Pods/YYCategories/YYCategories/Quartz/YYCGUtilities.h b/screendisplay/Pods/YYCategories/YYCategories/Quartz/YYCGUtilities.h
new file mode 100755
index 0000000..96cc451
--- /dev/null
+++ b/screendisplay/Pods/YYCategories/YYCategories/Quartz/YYCGUtilities.h
@@ -0,0 +1,330 @@
+//
+// YYCGUtilities.h
+// YYCategories <https://github.com/ibireme/YYCategories>
+//
+// Created by ibireme on 15/2/28.
+// Copyright (c) 2015 ibireme.
+//
+// This source code is licensed under the MIT-style license found in the
+// LICENSE file in the root directory of this source tree.
+//
+
+#import <UIKit/UIKit.h>
+#import <QuartzCore/QuartzCore.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Create an `ARGB` Bitmap context. Returns NULL if an error occurs.
+///
+/// @discussion The function is same as UIGraphicsBeginImageContextWithOptions(),
+/// but it doesn't push the context to UIGraphic, so you can retain the context for reuse.
+CGContextRef _Nullable YYCGContextCreateARGBBitmapContext(CGSize size, BOOL opaque, CGFloat scale);
+
+/// Create a `DeviceGray` Bitmap context. Returns NULL if an error occurs.
+CGContextRef _Nullable YYCGContextCreateGrayBitmapContext(CGSize size, CGFloat scale);
+
+
+
+/// Get main screen's scale.
+CGFloat YYScreenScale();
+
+/// Get main screen's size. Height is always larger than width.
+CGSize YYScreenSize();
+
+
+
+/// Convert degrees to radians.
+static inline CGFloat DegreesToRadians(CGFloat degrees) {
+ return degrees * M_PI / 180;
+}
+
+/// Convert radians to degrees.
+static inline CGFloat RadiansToDegrees(CGFloat radians) {
+ return radians * 180 / M_PI;
+}
+
+
+
+/// Get the transform rotation.
+/// @return the rotation in radians [-PI,PI] ([-180��,180��])
+static inline CGFloat CGAffineTransformGetRotation(CGAffineTransform transform) {
+ return atan2(transform.b, transform.a);
+}
+
+/// Get the transform's scale.x
+static inline CGFloat CGAffineTransformGetScaleX(CGAffineTransform transform) {
+ return sqrt(transform.a * transform.a + transform.c * transform.c);
+}
+
+/// Get the transform's scale.y
+static inline CGFloat CGAffineTransformGetScaleY(CGAffineTransform transform) {
+ return sqrt(transform.b * transform.b + transform.d * transform.d);
+}
+
+/// Get the transform's translate.x
+static inline CGFloat CGAffineTransformGetTranslateX(CGAffineTransform transform) {
+ return transform.tx;
+}
+
+/// Get the transform's translate.y
+static inline CGFloat CGAffineTransformGetTranslateY(CGAffineTransform transform) {
+ return transform.ty;
+}
+
+/**
+ If you have 3 pair of points transformed by a same CGAffineTransform:
+ p1 (transform->) q1
+ p2 (transform->) q2
+ p3 (transform->) q3
+ This method returns the original transform matrix from these 3 pair of points.
+
+ @see http://stackoverflow.com/questions/13291796/calculate-values-for-a-cgaffinetransform-from-three-points-in-each-of-two-uiview
+ */
+CGAffineTransform YYCGAffineTransformGetFromPoints(CGPoint before[3], CGPoint after[3]);
+
+/// Get the transform which can converts a point from the coordinate system of a given view to another.
+CGAffineTransform YYCGAffineTransformGetFromViews(UIView *from, UIView *to);
+
+/// Create a skew transform.
+static inline CGAffineTransform CGAffineTransformMakeSkew(CGFloat x, CGFloat y){
+ CGAffineTransform transform = CGAffineTransformIdentity;
+ transform.c = -x;
+ transform.b = y;
+ return transform;
+}
+
+/// Negates/inverts a UIEdgeInsets.
+static inline UIEdgeInsets UIEdgeInsetsInvert(UIEdgeInsets insets) {
+ return UIEdgeInsetsMake(-insets.top, -insets.left, -insets.bottom, -insets.right);
+}
+
+/// Convert CALayer's gravity string to UIViewContentMode.
+UIViewContentMode YYCAGravityToUIViewContentMode(NSString *gravity);
+
+/// Convert UIViewContentMode to CALayer's gravity string.
+NSString *YYUIViewContentModeToCAGravity(UIViewContentMode contentMode);
+
+
+
+/**
+ Returns a rectangle to fit the @param rect with specified content mode.
+
+ @param rect The constrant rect
+ @param size The content size
+ @param mode The content mode
+ @return A rectangle for the given content mode.
+ @discussion UIViewContentModeRedraw is same as UIViewContentModeScaleToFill.
+ */
+CGRect YYCGRectFitWithContentMode(CGRect rect, CGSize size, UIViewContentMode mode);
+
+/// Returns the center for the rectangle.
+static inline CGPoint CGRectGetCenter(CGRect rect) {
+ return CGPointMake(CGRectGetMidX(rect), CGRectGetMidY(rect));
+}
+
+/// Returns the area of the rectangle.
+static inline CGFloat CGRectGetArea(CGRect rect) {
+ if (CGRectIsNull(rect)) return 0;
+ rect = CGRectStandardize(rect);
+ return rect.size.width * rect.size.height;
+}
+
+/// Returns the distance between two points.
+static inline CGFloat CGPointGetDistanceToPoint(CGPoint p1, CGPoint p2) {
+ return sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
+}
+
+/// Returns the minmium distance between a point to a rectangle.
+static inline CGFloat CGPointGetDistanceToRect(CGPoint p, CGRect r) {
+ r = CGRectStandardize(r);
+ if (CGRectContainsPoint(r, p)) return 0;
+ CGFloat distV, distH;
+ if (CGRectGetMinY(r) <= p.y && p.y <= CGRectGetMaxY(r)) {
+ distV = 0;
+ } else {
+ distV = p.y < CGRectGetMinY(r) ? CGRectGetMinY(r) - p.y : p.y - CGRectGetMaxY(r);
+ }
+ if (CGRectGetMinX(r) <= p.x && p.x <= CGRectGetMaxX(r)) {
+ distH = 0;
+ } else {
+ distH = p.x < CGRectGetMinX(r) ? CGRectGetMinX(r) - p.x : p.x - CGRectGetMaxX(r);
+ }
+ return MAX(distV, distH);
+}
+
+
+
+/// Convert point to pixel.
+static inline CGFloat CGFloatToPixel(CGFloat value) {
+ return value * YYScreenScale();
+}
+
+/// Convert pixel to point.
+static inline CGFloat CGFloatFromPixel(CGFloat value) {
+ return value / YYScreenScale();
+}
+
+
+
+/// floor point value for pixel-aligned
+static inline CGFloat CGFloatPixelFloor(CGFloat value) {
+ CGFloat scale = YYScreenScale();
+ return floor(value * scale) / scale;
+}
+
+/// round point value for pixel-aligned
+static inline CGFloat CGFloatPixelRound(CGFloat value) {
+ CGFloat scale = YYScreenScale();
+ return round(value * scale) / scale;
+}
+
+/// ceil point value for pixel-aligned
+static inline CGFloat CGFloatPixelCeil(CGFloat value) {
+ CGFloat scale = YYScreenScale();
+ return ceil(value * scale) / scale;
+}
+
+/// round point value to .5 pixel for path stroke (odd pixel line width pixel-aligned)
+static inline CGFloat CGFloatPixelHalf(CGFloat value) {
+ CGFloat scale = YYScreenScale();
+ return (floor(value * scale) + 0.5) / scale;
+}
+
+
+
+/// floor point value for pixel-aligned
+static inline CGPoint CGPointPixelFloor(CGPoint point) {
+ CGFloat scale = YYScreenScale();
+ return CGPointMake(floor(point.x * scale) / scale,
+ floor(point.y * scale) / scale);
+}
+
+/// round point value for pixel-aligned
+static inline CGPoint CGPointPixelRound(CGPoint point) {
+ CGFloat scale = YYScreenScale();
+ return CGPointMake(round(point.x * scale) / scale,
+ round(point.y * scale) / scale);
+}
+
+/// ceil point value for pixel-aligned
+static inline CGPoint CGPointPixelCeil(CGPoint point) {
+ CGFloat scale = YYScreenScale();
+ return CGPointMake(ceil(point.x * scale) / scale,
+ ceil(point.y * scale) / scale);
+}
+
+/// round point value to .5 pixel for path stroke (odd pixel line width pixel-aligned)
+static inline CGPoint CGPointPixelHalf(CGPoint point) {
+ CGFloat scale = YYScreenScale();
+ return CGPointMake((floor(point.x * scale) + 0.5) / scale,
+ (floor(point.y * scale) + 0.5) / scale);
+}
+
+
+
+/// floor point value for pixel-aligned
+static inline CGSize CGSizePixelFloor(CGSize size) {
+ CGFloat scale = YYScreenScale();
+ return CGSizeMake(floor(size.width * scale) / scale,
+ floor(size.height * scale) / scale);
+}
+
+/// round point value for pixel-aligned
+static inline CGSize CGSizePixelRound(CGSize size) {
+ CGFloat scale = YYScreenScale();
+ return CGSizeMake(round(size.width * scale) / scale,
+ round(size.height * scale) / scale);
+}
+
+/// ceil point value for pixel-aligned
+static inline CGSize CGSizePixelCeil(CGSize size) {
+ CGFloat scale = YYScreenScale();
+ return CGSizeMake(ceil(size.width * scale) / scale,
+ ceil(size.height * scale) / scale);
+}
+
+/// round point value to .5 pixel for path stroke (odd pixel line width pixel-aligned)
+static inline CGSize CGSizePixelHalf(CGSize size) {
+ CGFloat scale = YYScreenScale();
+ return CGSizeMake((floor(size.width * scale) + 0.5) / scale,
+ (floor(size.height * scale) + 0.5) / scale);
+}
+
+
+
+/// floor point value for pixel-aligned
+static inline CGRect CGRectPixelFloor(CGRect rect) {
+ CGPoint origin = CGPointPixelCeil(rect.origin);
+ CGPoint corner = CGPointPixelFloor(CGPointMake(rect.origin.x + rect.size.width,
+ rect.origin.y + rect.size.height));
+ CGRect ret = CGRectMake(origin.x, origin.y, corner.x - origin.x, corner.y - origin.y);
+ if (ret.size.width < 0) ret.size.width = 0;
+ if (ret.size.height < 0) ret.size.height = 0;
+ return ret;
+}
+
+/// round point value for pixel-aligned
+static inline CGRect CGRectPixelRound(CGRect rect) {
+ CGPoint origin = CGPointPixelRound(rect.origin);
+ CGPoint corner = CGPointPixelRound(CGPointMake(rect.origin.x + rect.size.width,
+ rect.origin.y + rect.size.height));
+ return CGRectMake(origin.x, origin.y, corner.x - origin.x, corner.y - origin.y);
+}
+
+/// ceil point value for pixel-aligned
+static inline CGRect CGRectPixelCeil(CGRect rect) {
+ CGPoint origin = CGPointPixelFloor(rect.origin);
+ CGPoint corner = CGPointPixelCeil(CGPointMake(rect.origin.x + rect.size.width,
+ rect.origin.y + rect.size.height));
+ return CGRectMake(origin.x, origin.y, corner.x - origin.x, corner.y - origin.y);
+}
+
+/// round point value to .5 pixel for path stroke (odd pixel line width pixel-aligned)
+static inline CGRect CGRectPixelHalf(CGRect rect) {
+ CGPoint origin = CGPointPixelHalf(rect.origin);
+ CGPoint corner = CGPointPixelHalf(CGPointMake(rect.origin.x + rect.size.width,
+ rect.origin.y + rect.size.height));
+ return CGRectMake(origin.x, origin.y, corner.x - origin.x, corner.y - origin.y);
+}
+
+
+
+/// floor UIEdgeInset for pixel-aligned
+static inline UIEdgeInsets UIEdgeInsetPixelFloor(UIEdgeInsets insets) {
+ insets.top = CGFloatPixelFloor(insets.top);
+ insets.left = CGFloatPixelFloor(insets.left);
+ insets.bottom = CGFloatPixelFloor(insets.bottom);
+ insets.right = CGFloatPixelFloor(insets.right);
+ return insets;
+}
+
+/// ceil UIEdgeInset for pixel-aligned
+static inline UIEdgeInsets UIEdgeInsetPixelCeil(UIEdgeInsets insets) {
+ insets.top = CGFloatPixelCeil(insets.top);
+ insets.left = CGFloatPixelCeil(insets.left);
+ insets.bottom = CGFloatPixelCeil(insets.bottom);
+ insets.right = CGFloatPixelCeil(insets.right);
+ return insets;
+}
+
+// main screen's scale
+#ifndef kScreenScale
+#define kScreenScale YYScreenScale()
+#endif
+
+// main screen's size (portrait)
+#ifndef kScreenSize
+#define kScreenSize YYScreenSize()
+#endif
+
+// main screen's width (portrait)
+#ifndef kScreenWidth
+#define kScreenWidth YYScreenSize().width
+#endif
+
+// main screen's height (portrait)
+#ifndef kScreenHeight
+#define kScreenHeight YYScreenSize().height
+#endif
+
+NS_ASSUME_NONNULL_END
--
Gitblit v1.8.0