initial

Pods/SwiftEntryKit/Source/Model/EntryAttributes/EKAttributes+BackgroundStyle.swift

@@ -0,0 +1,138 @@
+//
+//  EKAttributes+BackgroundStyle.swift
+//  SwiftEntryKit
+//
+//  Created by Daniel Huri on 4/21/18.
+//  Copyright (c) 2018 huri000@gmail.com. All rights reserved.
+//
+
+import UIKit
+
+public extension EKAttributes {
+    
+    /** The background style property */
+    enum BackgroundStyle: Equatable {
+        
+        /** Blur style for light and dark modes */
+        public struct BlurStyle: Equatable {
+            
+            public static var extra: BlurStyle {
+                return BlurStyle(light: .extraLight, dark: .dark)
+            }
+            
+            public static var standard: BlurStyle {
+                return BlurStyle(light: .light, dark: .dark)
+            }
+            
+            @available(iOS 10.0, *)
+            public static var prominent: BlurStyle {
+                return BlurStyle(light: .prominent, dark: .prominent)
+            }
+            
+            public static var dark: BlurStyle {
+                return BlurStyle(light: .dark, dark: .dark)
+            }
+            
+            let light: UIBlurEffect.Style
+            let dark: UIBlurEffect.Style
+            
+            public init(style: UIBlurEffect.Style) {
+                self.light = style
+                self.dark = style
+            }
+            
+            public init(light: UIBlurEffect.Style, dark: UIBlurEffect.Style) {
+                self.light = light
+                self.dark = dark
+            }
+            
+            /** Computes a proper `UIBlurEffect.Style` instance */
+            public func blurStyle(for traits: UITraitCollection,
+                                  mode: EKAttributes.DisplayMode) -> UIBlurEffect.Style {
+                switch mode {
+                case .inferred:
+                    if #available(iOS 13, *) {
+                        switch traits.userInterfaceStyle {
+                        case .light, .unspecified:
+                            return light
+                        case .dark:
+                            return dark
+                        @unknown default:
+                            return light
+                        }
+                    } else {
+                        return light
+                    }
+                case .light:
+                    return light
+                case .dark:
+                    return dark
+                }
+            }
+            
+            public func blurEffect(for traits: UITraitCollection,
+                                   mode: EKAttributes.DisplayMode) -> UIBlurEffect {
+                return UIBlurEffect(style: blurStyle(for: traits, mode: mode))
+            }
+        }
+        
+        /** Gradient background style */
+        public struct Gradient {
+            public var colors: [EKColor]
+            public var startPoint: CGPoint
+            public var endPoint: CGPoint
+            
+            public init(colors: [EKColor],
+                        startPoint: CGPoint,
+                        endPoint: CGPoint) {
+                self.colors = colors
+                self.startPoint = startPoint
+                self.endPoint = endPoint
+            }
+        }
+        
+        /** Visual Effect (Blurred) background style */
+        case visualEffect(style: BlurStyle)
+        
+        /** Color background style */
+        case color(color: EKColor)
+        
+        /** Gradient background style */
+        case gradient(gradient: Gradient)
+        
+        /** Image background style */
+        case image(image: UIImage)
+        
+        /** Clear background style */
+        case clear
+        
+        /** == operator overload */
+        public static func == (lhs: EKAttributes.BackgroundStyle,
+                               rhs: EKAttributes.BackgroundStyle) -> Bool {
+            switch (lhs, rhs) {
+            case (visualEffect(style: let leftStyle),
+                  visualEffect(style: let rightStyle)):
+                return leftStyle == rightStyle
+            case (color(color: let leftColor),
+                  color(color: let rightColor)):
+                return leftColor == rightColor
+            case (image(image: let leftImage),
+                  image(image: let rightImage)):
+                return leftImage == rightImage
+            case (gradient(gradient: let leftGradient),
+                  gradient(gradient: let rightGradient)):
+                for (leftColor, rightColor) in zip(leftGradient.colors, rightGradient.colors) {
+                    guard leftColor == rightColor else {
+                        return false
+                    }
+                }
+                return leftGradient.startPoint == rightGradient.startPoint &&
+                       leftGradient.endPoint == rightGradient.endPoint
+            case (clear, clear):
+                return true
+            default:
+                return false
+            }
+        }
+    }
+}