mbrucedogs/vds_ios
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

updated color config

Browse Source 
Signed-off-by: Matt Bruce <matt.bruce@verizon.com>
This commit is contained in:
Matt Bruce 2022-10-10 16:22:28 -05:00
parent eac9eaf751
commit d0001f8af7
10 changed files with 260 additions and 252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
VDS/Classes/ColorConfiguration.swift
View File

@ -8,15 +8,7 @@
import Foundation import Foundation
import UIKit import UIKit
public protocol BinaryColorable{ public typealias ObjectColorable = Colorable & Initable & ObjectWithable
var userTrueColor: Bool { get }
}
extension BinaryColorable where Self: Selectable {
public var userTrueColor: Bool { return selected }
}
public typealias ClassColorable = Colorable & Initable & ObjectWithable
/// Meant to be used in a Object that implements the following interfaces for 2 possible color combinations /// Meant to be used in a Object that implements the following interfaces for 2 possible color combinations
/// - Surfaceable (var surface: Surface) /// - Surfaceable (var surface: Surface)
@ -30,16 +22,31 @@ public typealias ClassColorable = Colorable & Initable & ObjectWithable
/// config.darkColor = .white /// config.darkColor = .white
/// ///
/// let textColor = config.getColor(model) //returns .black /// let textColor = config.getColor(model) //returns .black
open class SurfaceColorConfiguration<ModelType:Surfaceable>: ClassColorable { final public class SurfaceColorConfiguration: ObjectColorable {
public typealias ModelType = Surfaceable
public var lightColor: UIColor = .clear public var lightColor: UIColor = .clear
public var darkColor: UIColor = .clear public var darkColor: UIColor = .clear
required public init(){} required public init(){}
public func getColor(_ viewModel: ModelType) -> UIColor { public func getColor(_ viewModel: any ModelType) -> UIColor {
return viewModel.surface == .light ? lightColor : darkColor return viewModel.surface == .light ? lightColor : darkColor
} }
} }
///-------------------------------------------------------------------
///MARK -- DisabledSurfaceColorable
///-------------------------------------------------------------------
public protocol DisabledSurfaceColorable: ObjectColorable {
var disabled: SurfaceColorConfiguration { get set }
var enabled: SurfaceColorConfiguration { get set }
}
extension DisabledSurfaceColorable {
public func getDisabledColor<M: Surfaceable & Disabling> (_ viewModel: M) -> UIColor {
viewModel.disabled ? disabled.getColor(viewModel) : enabled.getColor(viewModel)
}
}
/// Meant to be used in a Object that implements the following interfaces for 4 possible color combinations /// Meant to be used in a Object that implements the following interfaces for 4 possible color combinations
/// - Disabling (var disabled: Bool) /// - Disabling (var disabled: Bool)
/// - Surfaceable (var surface: Surface) /// - Surfaceable (var surface: Surface)
@ -48,7 +55,7 @@ open class SurfaceColorConfiguration<ModelType:Surfaceable>: ClassColorable {
/// model.surface = .dark /// model.surface = .dark
/// model.disabled = false /// model.disabled = false
/// ///
/// let config = DisabledSurfaceColorConfiguration<TestModel>() /// let config = DisabledSurfaceColorConfiguration()
/// ///
/// //disabled == false /// //disabled == false
/// config.enabled.lightColor = .black /// config.enabled.lightColor = .black
@ -61,14 +68,40 @@ open class SurfaceColorConfiguration<ModelType:Surfaceable>: ClassColorable {
/// let textColor = config.getColor(model) //returns .white /// let textColor = config.getColor(model) //returns .white
/// ///
/// ///
open class DisabledSurfaceColorConfiguration<ModelType:Disabling & Surfaceable>: ClassColorable { final public class DisabledSurfaceColorConfiguration: DisabledSurfaceColorable {
public var disabled = SurfaceColorConfiguration<ModelType>() public typealias ModelType = Surfaceable & Disabling
public var enabled = SurfaceColorConfiguration<ModelType>() public var disabled = SurfaceColorConfiguration()
public var enabled = SurfaceColorConfiguration()
required public init(){} required public init(){}
public func getColor(_ viewModel: ModelType) -> UIColor { public func getColor(_ viewModel: any ModelType) -> UIColor {
return viewModel.disabled ? disabled.getColor(viewModel) : enabled.getColor(viewModel) getDisabledColor(viewModel)
}
}
///-------------------------------------------------------------------
///MARK -- BinaryColorable
///-------------------------------------------------------------------
public protocol BinaryColorable{
var userTrueColor: Bool { get }
}
extension BinaryColorable where Self: Selectable {
public var userTrueColor: Bool { return selected }
}
///-------------------------------------------------------------------
///MARK -- BinarySurfaceColorable
///-------------------------------------------------------------------
public protocol BinarySurfaceColorable: ObjectColorable {
var forTrue: SurfaceColorConfiguration { get set }
var forFalse: SurfaceColorConfiguration { get set }
}
extension BinarySurfaceColorable {
public func getBinaryColor<M: Surfaceable & BinaryColorable>(_ viewModel: M) -> UIColor {
viewModel.userTrueColor ? forTrue.getColor(viewModel) : forFalse.getColor(viewModel)
} }
} }
@ -79,7 +112,7 @@ open class DisabledSurfaceColorConfiguration<ModelType:Disabling & Surfaceable>:
/// let model = TestModel() /// let model = TestModel()
/// model.surface = .dark /// model.surface = .dark
/// model.on = true //this is read in the extension var userTrueColor /// model.on = true //this is read in the extension var userTrueColor
/// let config = BinarySurfaceColorConfiguration<TestModel>() /// let config = BinarySurfaceColorConfiguration()
/// ///
/// //True from BinaryColorable.userTrueColor /// //True from BinaryColorable.userTrueColor
/// config.forTrue.lightColor = .black /// config.forTrue.lightColor = .black
@ -92,14 +125,30 @@ open class DisabledSurfaceColorConfiguration<ModelType:Disabling & Surfaceable>:
/// let textColor = config.getColor(model) //returns .white /// let textColor = config.getColor(model) //returns .white
/// ///
/// ///
open class BinarySurfaceColorConfiguration<ModelType:Surfaceable & BinaryColorable>: ClassColorable { final public class BinarySurfaceColorConfiguration: BinarySurfaceColorable {
public var forTrue = SurfaceColorConfiguration<ModelType>() public typealias ModelType = Surfaceable & BinaryColorable
public var forFalse = SurfaceColorConfiguration<ModelType>() public var forTrue = SurfaceColorConfiguration()
public var forFalse = SurfaceColorConfiguration()
required public init(){} required public init(){}
public func getColor(_ viewModel: ModelType) -> UIColor { public func getColor(_ viewModel: any ModelType) -> UIColor {
return viewModel.userTrueColor ? forTrue.getColor(viewModel) : forFalse.getColor(viewModel) getBinaryColor(viewModel)
}
}
///-------------------------------------------------------------------
///MARK -- BinaryDisabledSurfaceColorable
///-------------------------------------------------------------------
public protocol BinaryDisabledSurfaceColorable: ObjectColorable {
var forTrue: DisabledSurfaceColorConfiguration { get set }
var forFalse: DisabledSurfaceColorConfiguration { get set }
}
extension BinaryDisabledSurfaceColorable {
public func getBinaryColor<M: Disabling & Surfaceable & BinaryColorable>(_ viewModel: M) -> UIColor {
viewModel.userTrueColor ? forTrue.getColor(viewModel) : forFalse.getColor(viewModel)
} }
} }
@ -112,7 +161,7 @@ open class BinarySurfaceColorConfiguration<ModelType:Surfaceable & BinaryColorab
/// model.on = false /// model.on = false
/// model.disabled = false /// model.disabled = false
/// model.surface = .light /// model.surface = .light
/// let config = BinaryDisabledSurfaceColorConfiguration<TestModel>() /// let config = BinaryDisabledSurfaceColorConfiguration()
/// ///
/// //True /// //True
/// config.forTrue.enabled.lightColor = .black /// config.forTrue.enabled.lightColor = .black
@ -129,13 +178,14 @@ open class BinarySurfaceColorConfiguration<ModelType:Surfaceable & BinaryColorab
/// let textColor = config.getColor(model) /// let textColor = config.getColor(model)
/// ///
/// ///
open class BinaryDisabledSurfaceColorConfiguration<ModelType:Disabling & Surfaceable & BinaryColorable>: ClassColorable { final public class BinaryDisabledSurfaceColorConfiguration: BinaryDisabledSurfaceColorable {
public var forTrue = DisabledSurfaceColorConfiguration<ModelType>() public typealias ModelType = Disabling & Surfaceable & BinaryColorable
public var forFalse = DisabledSurfaceColorConfiguration<ModelType>() public var forTrue = DisabledSurfaceColorConfiguration()
public var forFalse = DisabledSurfaceColorConfiguration()
required public init(){} required public init(){}
public func getColor(_ viewModel: ModelType) -> UIColor { public func getColor(_ viewModel: any ModelType) -> UIColor {
return viewModel.userTrueColor ? forTrue.getColor(viewModel) : forFalse.getColor(viewModel) getBinaryColor(viewModel)
} }
} }

22
VDS/Components/Badge/Badge.swift
View File

@ -91,40 +91,40 @@ open class BadgeBase<ModelType: BadgeModel>: View<ModelType> {
// MARK: - Configuration // MARK: - Configuration
//-------------------------------------------------- //--------------------------------------------------
public func backgroundColor(for fillColor: BadgeFillColor) -> UIColor { public func backgroundColor(for fillColor: BadgeFillColor) -> UIColor {
var config: SurfaceColorConfiguration<ModelType> var config: SurfaceColorConfiguration
switch model.fillColor { switch model.fillColor {
case .red: case .red:
config = SurfaceColorConfiguration<ModelType>().with { config = SurfaceColorConfiguration().with {
$0.lightColor = VDSColor.backgroundBrandhighlight $0.lightColor = VDSColor.backgroundBrandhighlight
$0.darkColor = VDSColor.backgroundBrandhighlight $0.darkColor = VDSColor.backgroundBrandhighlight
} }
case .yellow: case .yellow:
config = SurfaceColorConfiguration<ModelType>().with { config = SurfaceColorConfiguration().with {
$0.lightColor = VDSColor.paletteYellow62 $0.lightColor = VDSColor.paletteYellow62
$0.darkColor = VDSColor.paletteYellow62 $0.darkColor = VDSColor.paletteYellow62
} }
case .green: case .green:
config = SurfaceColorConfiguration<ModelType>().with { config = SurfaceColorConfiguration().with {
$0.lightColor = VDSColor.paletteGreen26 $0.lightColor = VDSColor.paletteGreen26
$0.darkColor = VDSColor.paletteGreen34 $0.darkColor = VDSColor.paletteGreen34
} }
case .orange: case .orange:
config = SurfaceColorConfiguration<ModelType>().with { config = SurfaceColorConfiguration().with {
$0.lightColor = VDSColor.paletteOrange39 $0.lightColor = VDSColor.paletteOrange39
$0.darkColor = VDSColor.paletteOrange46 $0.darkColor = VDSColor.paletteOrange46
} }
case .blue: case .blue:
config = SurfaceColorConfiguration<ModelType>().with { config = SurfaceColorConfiguration().with {
$0.lightColor = VDSColor.paletteBlue35 $0.lightColor = VDSColor.paletteBlue35
$0.darkColor = VDSColor.paletteBlue45 $0.darkColor = VDSColor.paletteBlue45
} }
case .black: case .black:
config = SurfaceColorConfiguration<ModelType>().with { config = SurfaceColorConfiguration().with {
$0.lightColor = VDSColor.paletteBlack $0.lightColor = VDSColor.paletteBlack
$0.darkColor = VDSColor.paletteBlack $0.darkColor = VDSColor.paletteBlack
} }
case .white: case .white:
config = SurfaceColorConfiguration<ModelType>().with { config = SurfaceColorConfiguration().with {
$0.lightColor = VDSColor.paletteWhite $0.lightColor = VDSColor.paletteWhite
$0.darkColor = VDSColor.paletteWhite $0.darkColor = VDSColor.paletteWhite
} }
@ -138,21 +138,21 @@ open class BadgeBase<ModelType: BadgeModel>: View<ModelType> {
switch fillColor { switch fillColor {
case .red, .black: case .red, .black:
return DisabledSurfaceColorConfiguration<ModelType>().with { return DisabledSurfaceColorConfiguration().with {
$0.disabled.lightColor = VDSColor.elementsPrimaryOndark $0.disabled.lightColor = VDSColor.elementsPrimaryOndark
$0.disabled.darkColor = VDSColor.elementsPrimaryOndark $0.disabled.darkColor = VDSColor.elementsPrimaryOndark
$0.enabled.lightColor = VDSColor.elementsPrimaryOndark $0.enabled.lightColor = VDSColor.elementsPrimaryOndark
$0.enabled.darkColor = VDSColor.elementsPrimaryOndark $0.enabled.darkColor = VDSColor.elementsPrimaryOndark
}.eraseToAnyColorable() }.eraseToAnyColorable()
case .yellow, .white: case .yellow, .white:
return DisabledSurfaceColorConfiguration<ModelType>().with { return DisabledSurfaceColorConfiguration().with {
$0.disabled.lightColor = VDSColor.elementsPrimaryOnlight $0.disabled.lightColor = VDSColor.elementsPrimaryOnlight
$0.disabled.darkColor = VDSColor.elementsPrimaryOnlight $0.disabled.darkColor = VDSColor.elementsPrimaryOnlight
$0.enabled.lightColor = VDSColor.elementsPrimaryOnlight $0.enabled.lightColor = VDSColor.elementsPrimaryOnlight
$0.enabled.darkColor = VDSColor.elementsPrimaryOnlight $0.enabled.darkColor = VDSColor.elementsPrimaryOnlight
}.eraseToAnyColorable() }.eraseToAnyColorable()
case .orange, .green, .blue: case .orange, .green, .blue:
return DisabledSurfaceColorConfiguration<ModelType>().with { return DisabledSurfaceColorConfiguration().with {
$0.disabled.lightColor = VDSColor.elementsPrimaryOndark $0.disabled.lightColor = VDSColor.elementsPrimaryOndark
$0.disabled.darkColor = VDSColor.elementsPrimaryOnlight $0.disabled.darkColor = VDSColor.elementsPrimaryOnlight
$0.enabled.lightColor = VDSColor.elementsPrimaryOndark $0.enabled.lightColor = VDSColor.elementsPrimaryOndark

81
VDS/Components/Button/Button.swift
View File

@ -65,51 +65,45 @@ open class ButtonBase<ModelType: ButtonModel>: UIButton, ModelHandlerable, ViewP
isUserInteractionEnabled = isEnabled isUserInteractionEnabled = isEnabled
} }
} }
//-------------------------------------------------- //--------------------------------------------------
// MARK: - Configuration Properties // MARK: - Configuration Properties
//-------------------------------------------------- //--------------------------------------------------
private var buttonBackgroundColorConfiguration: UseableColorConfiguration<ModelType> = { private var buttonBackgroundColorConfiguration = UseableColorConfiguration().with {
return UseableColorConfiguration<ModelType>().with { $0.primary.enabled.lightColor = VDSColor.backgroundPrimaryDark
$0.primary.enabled.lightColor = VDSColor.backgroundPrimaryDark $0.primary.enabled.darkColor = VDSColor.backgroundPrimaryLight
$0.primary.enabled.darkColor = VDSColor.backgroundPrimaryLight $0.primary.disabled.lightColor = VDSColor.interactiveDisabledOnlight
$0.primary.disabled.lightColor = VDSColor.interactiveDisabledOnlight $0.primary.disabled.darkColor = VDSColor.interactiveDisabledOndark
$0.primary.disabled.darkColor = VDSColor.interactiveDisabledOndark
$0.secondary.enabled.lightColor = UIColor.clear
$0.secondary.enabled.lightColor = UIColor.clear $0.secondary.enabled.darkColor = UIColor.clear
$0.secondary.enabled.darkColor = UIColor.clear $0.secondary.disabled.lightColor = UIColor.clear
$0.secondary.disabled.lightColor = UIColor.clear $0.secondary.disabled.darkColor = UIColor.clear
$0.secondary.disabled.darkColor = UIColor.clear }
}
}()
private var buttonBorderColorConfiguration: UseableColorConfiguration<ModelType> = { private var buttonBorderColorConfiguration = UseableColorConfiguration().with {
return UseableColorConfiguration<ModelType>().with { $0.primary.enabled.lightColor = VDSColor.elementsPrimaryOndark
$0.primary.enabled.lightColor = VDSColor.elementsPrimaryOndark $0.primary.enabled.darkColor = VDSColor.elementsPrimaryOnlight
$0.primary.enabled.darkColor = VDSColor.elementsPrimaryOnlight $0.primary.disabled.lightColor = VDSColor.interactiveDisabledOnlight
$0.primary.disabled.lightColor = VDSColor.interactiveDisabledOnlight $0.primary.disabled.darkColor = VDSColor.interactiveDisabledOndark
$0.primary.disabled.darkColor = VDSColor.interactiveDisabledOndark
$0.secondary.enabled.lightColor = VDSColor.elementsPrimaryOnlight
$0.secondary.enabled.lightColor = VDSColor.elementsPrimaryOnlight $0.secondary.enabled.darkColor = VDSColor.elementsPrimaryOndark
$0.secondary.enabled.darkColor = VDSColor.elementsPrimaryOndark $0.secondary.disabled.lightColor = VDSColor.interactiveDisabledOnlight
$0.secondary.disabled.lightColor = VDSColor.interactiveDisabledOnlight $0.secondary.disabled.darkColor = VDSColor.interactiveDisabledOndark
$0.secondary.disabled.darkColor = VDSColor.interactiveDisabledOndark }
}
}()
private var buttonTitleColorConfiguration: UseableColorConfiguration<ModelType> = { private var buttonTitleColorConfiguration = UseableColorConfiguration().with {
return UseableColorConfiguration<ModelType>().with { $0.primary.enabled.lightColor = VDSColor.elementsPrimaryOndark
$0.primary.enabled.lightColor = VDSColor.elementsPrimaryOndark $0.primary.enabled.darkColor = VDSColor.elementsPrimaryOnlight
$0.primary.enabled.darkColor = VDSColor.elementsPrimaryOnlight $0.primary.disabled.lightColor = VDSColor.elementsPrimaryOndark
$0.primary.disabled.lightColor = VDSColor.elementsPrimaryOndark $0.primary.disabled.darkColor = VDSColor.elementsPrimaryOnlight
$0.primary.disabled.darkColor = VDSColor.elementsPrimaryOnlight
$0.secondary.enabled.lightColor = VDSColor.elementsPrimaryOnlight
$0.secondary.enabled.lightColor = VDSColor.elementsPrimaryOnlight $0.secondary.enabled.darkColor = VDSColor.elementsPrimaryOndark
$0.secondary.enabled.darkColor = VDSColor.elementsPrimaryOndark $0.secondary.disabled.lightColor = VDSColor.interactiveDisabledOnlight
$0.secondary.disabled.lightColor = VDSColor.interactiveDisabledOnlight $0.secondary.disabled.darkColor = VDSColor.interactiveDisabledOndark
$0.secondary.disabled.darkColor = VDSColor.interactiveDisabledOndark }
}
}()
//-------------------------------------------------- //--------------------------------------------------
// MARK: - Initializers // MARK: - Initializers
@ -213,9 +207,10 @@ open class ButtonBase<ModelType: ButtonModel>: UIButton, ModelHandlerable, ViewP
// MARK: - PRIVATE // MARK: - PRIVATE
//-------------------------------------------------- //--------------------------------------------------
private class UseableColorConfiguration<ModelType:Disabling & Surfaceable & Useable> : ClassColorable { private class UseableColorConfiguration: ObjectColorable {
public var primary = DisabledSurfaceColorConfiguration<ModelType>() typealias ModelType = Disabling & Surfaceable & Useable
public var secondary = DisabledSurfaceColorConfiguration<ModelType>() public var primary = DisabledSurfaceColorConfiguration()
public var secondary = DisabledSurfaceColorConfiguration()
required public init(){} required public init(){}

55
VDS/Components/Checkbox/Checkbox.swift
View File

@ -230,8 +230,6 @@ open class CheckboxBase<ModelType: CheckboxModel>: Control<ModelType> {
// MARK: - State // MARK: - State
//-------------------------------------------------- //--------------------------------------------------
open override func updateView(viewModel: ModelType) { open override func updateView(viewModel: ModelType) {
let enabled = !viewModel.disabled
updateLabels(viewModel) updateLabels(viewModel)
updateSelector(viewModel) updateSelector(viewModel)
setAccessibilityHint() setAccessibilityHint()
@ -247,8 +245,8 @@ open class CheckboxBase<ModelType: CheckboxModel>: Control<ModelType> {
//-------------------------------------------------- //--------------------------------------------------
public let checkboxSize = CGSize(width: 20, height: 20) public let checkboxSize = CGSize(width: 20, height: 20)
private var checkboxBackgroundColorConfiguration: CheckboxErrorColorConfiguration = { private var checkboxBackgroundColorConfiguration: ErrorBinaryDisabledSurfaceColorConfiguration = {
return CheckboxErrorColorConfiguration().with { return ErrorBinaryDisabledSurfaceColorConfiguration().with {
$0.forTrue.enabled.lightColor = VDSColor.elementsPrimaryOnlight $0.forTrue.enabled.lightColor = VDSColor.elementsPrimaryOnlight
$0.forTrue.enabled.darkColor = VDSColor.elementsPrimaryOndark $0.forTrue.enabled.darkColor = VDSColor.elementsPrimaryOndark
$0.forTrue.disabled.lightColor = VDSColor.interactiveDisabledOnlight $0.forTrue.disabled.lightColor = VDSColor.interactiveDisabledOnlight
@ -261,8 +259,8 @@ open class CheckboxBase<ModelType: CheckboxModel>: Control<ModelType> {
} }
}() }()
private var checkboxBorderColorConfiguration: CheckboxErrorColorConfiguration = { private var checkboxBorderColorConfiguration: ErrorBinaryDisabledSurfaceColorConfiguration = {
return CheckboxErrorColorConfiguration().with { return ErrorBinaryDisabledSurfaceColorConfiguration().with {
$0.forTrue.enabled.lightColor = VDSColor.elementsPrimaryOnlight $0.forTrue.enabled.lightColor = VDSColor.elementsPrimaryOnlight
$0.forTrue.enabled.darkColor = VDSColor.elementsPrimaryOndark $0.forTrue.enabled.darkColor = VDSColor.elementsPrimaryOndark
$0.forFalse.enabled.lightColor = VDSFormControlsColor.borderOnlight $0.forFalse.enabled.lightColor = VDSFormControlsColor.borderOnlight
@ -279,8 +277,8 @@ open class CheckboxBase<ModelType: CheckboxModel>: Control<ModelType> {
} }
}() }()
private var checkboxCheckColorConfiguration: BinarySurfaceColorConfiguration<ModelType> = { private var checkboxCheckColorConfiguration: BinarySurfaceColorConfiguration = {
return BinarySurfaceColorConfiguration<ModelType>().with { return BinarySurfaceColorConfiguration().with {
$0.forTrue.lightColor = VDSColor.elementsPrimaryOndark $0.forTrue.lightColor = VDSColor.elementsPrimaryOndark
$0.forTrue.darkColor = VDSColor.elementsPrimaryOnlight $0.forTrue.darkColor = VDSColor.elementsPrimaryOnlight
} }
@ -346,23 +344,28 @@ open class CheckboxBase<ModelType: CheckboxModel>: Control<ModelType> {
} }
} }
} }
}
//--------------------------------------------------
// MARK: - Color Class Configurations //--------------------------------------------------
//-------------------------------------------------- // MARK: - Color Class Configurations
private class CheckboxErrorColorConfiguration: BinaryDisabledSurfaceColorConfiguration<ModelType> { //--------------------------------------------------
public let error = BinarySurfaceColorConfiguration<ModelType>() internal class ErrorBinaryDisabledSurfaceColorConfiguration: BinaryDisabledSurfaceColorable {
override func getColor(_ viewModel: ModelType) -> UIColor { typealias ModelType = Errorable & Disabling & Surfaceable & BinaryColorable
//only show error is enabled and showError == true var error = BinarySurfaceColorConfiguration()
let showErrorColor = !viewModel.disabled && viewModel.showError var forTrue = DisabledSurfaceColorConfiguration()
var forFalse = DisabledSurfaceColorConfiguration()
if showErrorColor {
return error.getColor(viewModel) required init() {}
} else {
return super.getColor(viewModel) func getColor(_ viewModel: ModelType) -> UIColor {
} //only show error is enabled and showError == true
} let showErrorColor = !viewModel.disabled && viewModel.showError
}
if showErrorColor {
return error.getColor(viewModel)
} else {
return getBinaryColor(viewModel)
}
}
} }

2
VDS/Components/Label/Label.swift
View File

@ -67,7 +67,7 @@ open class LabelBase<ModelType: LabelModel>: UILabel, ModelHandlerable, ViewProt
//-------------------------------------------------- //--------------------------------------------------
// MARK: - Configuration Properties // MARK: - Configuration Properties
//-------------------------------------------------- //--------------------------------------------------
public var textColorConfiguration: AnyColorable = DisabledSurfaceColorConfiguration<ModelType>().with { public var textColorConfiguration: AnyColorable = DisabledSurfaceColorConfiguration().with {
$0.disabled.lightColor = VDSColor.elementsSecondaryOnlight $0.disabled.lightColor = VDSColor.elementsSecondaryOnlight
$0.disabled.darkColor = VDSColor.elementsSecondaryOndark $0.disabled.darkColor = VDSColor.elementsSecondaryOndark
$0.enabled.lightColor = VDSColor.elementsPrimaryOnlight $0.enabled.lightColor = VDSColor.elementsPrimaryOnlight

52
VDS/Components/RadioBox/RadioBox.swift
View File

@ -207,8 +207,6 @@ open class RadioBoxBase<ModelType: RadioBoxModel>: Control<ModelType> {
// MARK: - State // MARK: - State
//-------------------------------------------------- //--------------------------------------------------
open override func updateView(viewModel: ModelType) { open override func updateView(viewModel: ModelType) {
let enabled = !viewModel.disabled
updateLabels(viewModel) updateLabels(viewModel)
updateSelector(viewModel) updateSelector(viewModel)
setAccessibilityHint() setAccessibilityHint()
@ -227,34 +225,30 @@ open class RadioBoxBase<ModelType: RadioBoxModel>: Control<ModelType> {
private var selectorBorderWidthSelected: CGFloat = 2.0 private var selectorBorderWidthSelected: CGFloat = 2.0
private var selectorBorderWidth: CGFloat = 1.0 private var selectorBorderWidth: CGFloat = 1.0
private var radioBoxBackgroundColorConfiguration: BinaryDisabledSurfaceColorConfiguration<ModelType> = { private var radioBoxBackgroundColorConfiguration = BinaryDisabledSurfaceColorConfiguration().with {
return BinaryDisabledSurfaceColorConfiguration<ModelType>().with { $0.forFalse.enabled.lightColor = VDSFormControlsColor.backgroundOnlight
$0.forFalse.enabled.lightColor = VDSFormControlsColor.backgroundOnlight $0.forFalse.enabled.darkColor = VDSFormControlsColor.backgroundOndark
$0.forFalse.enabled.darkColor = VDSFormControlsColor.backgroundOndark $0.forFalse.disabled.lightColor = VDSFormControlsColor.backgroundOnlight
$0.forFalse.disabled.lightColor = VDSFormControlsColor.backgroundOnlight $0.forFalse.disabled.darkColor = VDSFormControlsColor.backgroundOndark
$0.forFalse.disabled.darkColor = VDSFormControlsColor.backgroundOndark
$0.forTrue.enabled.lightColor = VDSFormControlsColor.backgroundOnlight
$0.forTrue.enabled.lightColor = VDSFormControlsColor.backgroundOnlight $0.forTrue.enabled.darkColor = VDSFormControlsColor.backgroundOndark
$0.forTrue.enabled.darkColor = VDSFormControlsColor.backgroundOndark $0.forTrue.disabled.lightColor = VDSFormControlsColor.backgroundOnlight
$0.forTrue.disabled.lightColor = VDSFormControlsColor.backgroundOnlight $0.forTrue.disabled.darkColor = VDSFormControlsColor.backgroundOndark
$0.forTrue.disabled.darkColor = VDSFormControlsColor.backgroundOndark }
}
}() private var radioBoxBorderColorConfiguration = BinaryDisabledSurfaceColorConfiguration().with {
$0.forTrue.enabled.lightColor = VDSColor.elementsPrimaryOnlight
$0.forTrue.enabled.darkColor = VDSColor.elementsPrimaryOndark
$0.forFalse.enabled.lightColor = VDSFormControlsColor.borderOnlight
$0.forFalse.enabled.darkColor = VDSFormControlsColor.borderOndark
$0.forTrue.disabled.lightColor = VDSColor.interactiveDisabledOnlight
$0.forTrue.disabled.darkColor = VDSColor.interactiveDisabledOndark
$0.forFalse.disabled.lightColor = VDSColor.interactiveDisabledOnlight
$0.forFalse.disabled.darkColor = VDSColor.interactiveDisabledOndark
}
private var radioBoxBorderColorConfiguration: BinaryDisabledSurfaceColorConfiguration<ModelType> = {
return BinaryDisabledSurfaceColorConfiguration<ModelType>().with {
$0.forTrue.enabled.lightColor = VDSColor.elementsPrimaryOnlight
$0.forTrue.enabled.darkColor = VDSColor.elementsPrimaryOndark
$0.forFalse.enabled.lightColor = VDSFormControlsColor.borderOnlight
$0.forFalse.enabled.darkColor = VDSFormControlsColor.borderOndark
$0.forTrue.disabled.lightColor = VDSColor.interactiveDisabledOnlight
$0.forTrue.disabled.darkColor = VDSColor.interactiveDisabledOndark
$0.forFalse.disabled.lightColor = VDSColor.interactiveDisabledOnlight
$0.forFalse.disabled.darkColor = VDSColor.interactiveDisabledOndark
}
}()
//-------------------------------------------------- //--------------------------------------------------
// MARK: - RadioBox View Updates // MARK: - RadioBox View Updates
//-------------------------------------------------- //--------------------------------------------------

86
VDS/Components/RadioButton/RadioButton.swift
View File

@ -240,8 +240,6 @@ open class RadioButtonBase<ModelType: RadioButtonModel>: Control<ModelType> {
// MARK: - State // MARK: - State
//-------------------------------------------------- //--------------------------------------------------
open override func updateView(viewModel: ModelType) { open override func updateView(viewModel: ModelType) {
let enabled = !viewModel.disabled
updateLabels(viewModel) updateLabels(viewModel)
updateSelector(viewModel) updateSelector(viewModel)
setAccessibilityHint() setAccessibilityHint()
@ -256,43 +254,37 @@ open class RadioButtonBase<ModelType: RadioButtonModel>: Control<ModelType> {
//-------------------------------------------------- //--------------------------------------------------
public let radioButtonSize = CGSize(width: 20, height: 20) public let radioButtonSize = CGSize(width: 20, height: 20)
public let radioButtonSelectedSize = CGSize(width: 10, height: 10) public let radioButtonSelectedSize = CGSize(width: 10, height: 10)
private var radioButtonBackgroundColorConfiguration: RadioButtonErrorColorConfiguration = {
return RadioButtonErrorColorConfiguration().with {
//error doesn't care enabled/disable
$0.error.forTrue.lightColor = VDSColor.elementsPrimaryOnlight
$0.error.forTrue.darkColor = VDSColor.elementsPrimaryOndark
$0.error.forFalse.lightColor = VDSColor.feedbackErrorBackgroundOnlight
$0.error.forFalse.darkColor = VDSColor.feedbackErrorBackgroundOndark
}
}()
private var radioButtonBorderColorConfiguration: RadioButtonErrorColorConfiguration = { private var radioButtonBackgroundColorConfiguration = ErrorBinaryDisabledSurfaceColorConfiguration().with {
return RadioButtonErrorColorConfiguration().with { //error doesn't care enabled/disable
$0.forTrue.enabled.lightColor = VDSColor.elementsPrimaryOnlight $0.error.forTrue.lightColor = VDSColor.elementsPrimaryOnlight
$0.forTrue.enabled.darkColor = VDSColor.elementsPrimaryOndark $0.error.forTrue.darkColor = VDSColor.elementsPrimaryOndark
$0.forFalse.enabled.lightColor = VDSFormControlsColor.borderOnlight $0.error.forFalse.lightColor = VDSColor.feedbackErrorBackgroundOnlight
$0.forFalse.enabled.darkColor = VDSFormControlsColor.borderOndark $0.error.forFalse.darkColor = VDSColor.feedbackErrorBackgroundOndark
$0.forTrue.disabled.lightColor = VDSColor.interactiveDisabledOnlight }
$0.forTrue.disabled.darkColor = VDSColor.interactiveDisabledOndark
$0.forFalse.disabled.lightColor = VDSColor.interactiveDisabledOnlight private var radioButtonBorderColorConfiguration = ErrorBinaryDisabledSurfaceColorConfiguration().with {
$0.forFalse.disabled.darkColor = VDSColor.interactiveDisabledOndark $0.forTrue.enabled.lightColor = VDSColor.elementsPrimaryOnlight
//error doesn't care enabled/disable $0.forTrue.enabled.darkColor = VDSColor.elementsPrimaryOndark
$0.error.forTrue.lightColor = VDSColor.elementsPrimaryOnlight $0.forFalse.enabled.lightColor = VDSFormControlsColor.borderOnlight
$0.error.forTrue.darkColor = VDSColor.elementsPrimaryOndark $0.forFalse.enabled.darkColor = VDSFormControlsColor.borderOndark
$0.error.forFalse.lightColor = VDSColor.feedbackErrorOnlight $0.forTrue.disabled.lightColor = VDSColor.interactiveDisabledOnlight
$0.error.forFalse.darkColor = VDSColor.feedbackErrorOndark $0.forTrue.disabled.darkColor = VDSColor.interactiveDisabledOndark
} $0.forFalse.disabled.lightColor = VDSColor.interactiveDisabledOnlight
}() $0.forFalse.disabled.darkColor = VDSColor.interactiveDisabledOndark
//error doesn't care enabled/disable
private var radioButtonCheckColorConfiguration: BinaryDisabledSurfaceColorConfiguration<ModelType> = { $0.error.forTrue.lightColor = VDSColor.elementsPrimaryOnlight
return BinaryDisabledSurfaceColorConfiguration<ModelType>().with { $0.error.forTrue.darkColor = VDSColor.elementsPrimaryOndark
$0.forTrue.enabled.lightColor = VDSColor.elementsPrimaryOnlight $0.error.forFalse.lightColor = VDSColor.feedbackErrorOnlight
$0.forTrue.enabled.darkColor = VDSColor.elementsPrimaryOndark $0.error.forFalse.darkColor = VDSColor.feedbackErrorOndark
$0.forTrue.disabled.lightColor = VDSColor.interactiveDisabledOnlight }
$0.forTrue.disabled.darkColor = VDSColor.interactiveDisabledOndark
} private var radioButtonCheckColorConfiguration = BinaryDisabledSurfaceColorConfiguration().with {
}() $0.forTrue.enabled.lightColor = VDSColor.elementsPrimaryOnlight
$0.forTrue.enabled.darkColor = VDSColor.elementsPrimaryOndark
$0.forTrue.disabled.lightColor = VDSColor.interactiveDisabledOnlight
$0.forTrue.disabled.darkColor = VDSColor.interactiveDisabledOndark
}
//-------------------------------------------------- //--------------------------------------------------
// MARK: - RadioButton View // MARK: - RadioButton View
@ -338,23 +330,5 @@ open class RadioButtonBase<ModelType: RadioButtonModel>: Control<ModelType> {
shapeLayer.path = bezierPath.cgPath shapeLayer.path = bezierPath.cgPath
} }
} }
//--------------------------------------------------
// MARK: - Color Class Configurations
//--------------------------------------------------
private class RadioButtonErrorColorConfiguration: BinaryDisabledSurfaceColorConfiguration<ModelType> {
public let error = BinarySurfaceColorConfiguration<ModelType>()
override func getColor(_ viewModel: ModelType) -> UIColor {
//only show error is enabled and showError == true
let showErrorColor = !viewModel.disabled && viewModel.showError
if showErrorColor {
return error.getColor(viewModel)
} else {
return super.getColor(viewModel)
}
}
}
} }

61
VDS/Components/RadioSwatch/RadioSwatch.swift
View File

@ -159,41 +159,36 @@ open class RadioSwatchBase<ModelType: RadioSwatchModel>: Control<ModelType> {
public let swatchSize = CGSize(width: 48, height: 48) public let swatchSize = CGSize(width: 48, height: 48)
public let fillSize = CGSize(width: 36, height: 36) public let fillSize = CGSize(width: 36, height: 36)
public let disabledAlpha = 0.5 public let disabledAlpha = 0.5
private var radioSwatchBackgroundColorConfiguration: BinaryDisabledSurfaceColorConfiguration<ModelType> = {
return BinaryDisabledSurfaceColorConfiguration<ModelType>().with {
$0.forFalse.enabled.lightColor = VDSFormControlsColor.backgroundOnlight
$0.forFalse.enabled.darkColor = VDSFormControlsColor.backgroundOndark
$0.forFalse.disabled.lightColor = VDSFormControlsColor.backgroundOnlight
$0.forFalse.disabled.darkColor = VDSFormControlsColor.backgroundOndark
$0.forTrue.enabled.lightColor = VDSFormControlsColor.backgroundOnlight
$0.forTrue.enabled.darkColor = VDSFormControlsColor.backgroundOndark
$0.forTrue.disabled.lightColor = VDSFormControlsColor.backgroundOnlight
$0.forTrue.disabled.darkColor = VDSFormControlsColor.backgroundOndark
}
}()
private var radioSwatchBorderColorConfiguration: BinaryDisabledSurfaceColorConfiguration<ModelType> = { private var radioSwatchBackgroundColorConfiguration = BinaryDisabledSurfaceColorConfiguration().with {
return BinaryDisabledSurfaceColorConfiguration<ModelType>().with { $0.forFalse.enabled.lightColor = VDSFormControlsColor.backgroundOnlight
$0.forTrue.enabled.lightColor = VDSColor.elementsPrimaryOnlight $0.forFalse.enabled.darkColor = VDSFormControlsColor.backgroundOndark
$0.forTrue.enabled.darkColor = VDSColor.elementsPrimaryOndark $0.forFalse.disabled.lightColor = VDSFormControlsColor.backgroundOnlight
$0.forFalse.enabled.lightColor = VDSFormControlsColor.borderOnlight $0.forFalse.disabled.darkColor = VDSFormControlsColor.backgroundOndark
$0.forFalse.enabled.darkColor = VDSFormControlsColor.borderOndark $0.forTrue.enabled.lightColor = VDSFormControlsColor.backgroundOnlight
$0.forTrue.disabled.lightColor = VDSColor.interactiveDisabledOnlight $0.forTrue.enabled.darkColor = VDSFormControlsColor.backgroundOndark
$0.forTrue.disabled.darkColor = VDSColor.interactiveDisabledOndark $0.forTrue.disabled.lightColor = VDSFormControlsColor.backgroundOnlight
$0.forFalse.disabled.lightColor = VDSColor.interactiveDisabledOnlight $0.forTrue.disabled.darkColor = VDSFormControlsColor.backgroundOndark
$0.forFalse.disabled.darkColor = VDSColor.interactiveDisabledOndark }
}
}() private var radioSwatchBorderColorConfiguration = BinaryDisabledSurfaceColorConfiguration().with {
$0.forTrue.enabled.lightColor = VDSColor.elementsPrimaryOnlight
$0.forTrue.enabled.darkColor = VDSColor.elementsPrimaryOndark
$0.forFalse.enabled.lightColor = VDSFormControlsColor.borderOnlight
$0.forFalse.enabled.darkColor = VDSFormControlsColor.borderOndark
$0.forTrue.disabled.lightColor = VDSColor.interactiveDisabledOnlight
$0.forTrue.disabled.darkColor = VDSColor.interactiveDisabledOndark
$0.forFalse.disabled.lightColor = VDSColor.interactiveDisabledOnlight
$0.forFalse.disabled.darkColor = VDSColor.interactiveDisabledOndark
}
private var radioSwatchFillBorderColorConfiguration = DisabledSurfaceColorConfiguration().with {
$0.enabled.lightColor = VDSColor.elementsPrimaryOnlight
$0.enabled.darkColor = VDSColor.elementsPrimaryOndark
$0.disabled.lightColor = VDSColor.interactiveDisabledOnlight
$0.disabled.darkColor = VDSColor.interactiveDisabledOndark
}
private var radioSwatchFillBorderColorConfiguration: DisabledSurfaceColorConfiguration<ModelType> = {
return DisabledSurfaceColorConfiguration<ModelType>().with {
$0.enabled.lightColor = VDSColor.elementsPrimaryOnlight
$0.enabled.darkColor = VDSColor.elementsPrimaryOndark
$0.disabled.lightColor = VDSColor.interactiveDisabledOnlight
$0.disabled.darkColor = VDSColor.interactiveDisabledOndark
}
}()
//-------------------------------------------------- //--------------------------------------------------
// MARK: - RadioBox View Updates // MARK: - RadioBox View Updates
//-------------------------------------------------- //--------------------------------------------------

44
VDS/Components/Toggle/Toggle.swift
View File

@ -64,31 +64,27 @@ open class ToggleBase<ModelType: ToggleModel>: Control<ModelType> {
public let toggleContainerSize = CGSize(width: 52, height: 44) public let toggleContainerSize = CGSize(width: 52, height: 44)
public let knobSize = CGSize(width: 20, height: 20) public let knobSize = CGSize(width: 20, height: 20)
private var toggleColorConfiguration: BinaryDisabledSurfaceColorConfiguration<ModelType> = { private var toggleColorConfiguration = BinaryDisabledSurfaceColorConfiguration().with {
return BinaryDisabledSurfaceColorConfiguration<ModelType>().with { $0.forTrue.enabled.lightColor = VDSColor.paletteGreen26
$0.forTrue.enabled.lightColor = VDSColor.paletteGreen26 $0.forTrue.enabled.darkColor = VDSColor.paletteGreen34
$0.forTrue.enabled.darkColor = VDSColor.paletteGreen34 $0.forTrue.disabled.lightColor = VDSColor.interactiveDisabledOnlight
$0.forTrue.disabled.lightColor = VDSColor.interactiveDisabledOnlight $0.forTrue.disabled.darkColor = VDSColor.interactiveDisabledOndark
$0.forTrue.disabled.darkColor = VDSColor.interactiveDisabledOndark $0.forFalse.enabled.lightColor = VDSColor.elementsSecondaryOnlight
$0.forFalse.enabled.lightColor = VDSColor.elementsSecondaryOnlight $0.forFalse.enabled.darkColor = VDSColor.paletteGray44
$0.forFalse.enabled.darkColor = VDSColor.paletteGray44 $0.forFalse.disabled.lightColor = VDSColor.interactiveDisabledOnlight
$0.forFalse.disabled.lightColor = VDSColor.interactiveDisabledOnlight $0.forFalse.disabled.darkColor = VDSColor.interactiveDisabledOndark
$0.forFalse.disabled.darkColor = VDSColor.interactiveDisabledOndark }
}
} ()
private var knobColorConfiguration: BinaryDisabledSurfaceColorConfiguration<ModelType> = { private var knobColorConfiguration = BinaryDisabledSurfaceColorConfiguration().with {
return BinaryDisabledSurfaceColorConfiguration<ModelType>().with { $0.forTrue.enabled.lightColor = VDSColor.elementsPrimaryOndark
$0.forTrue.enabled.lightColor = VDSColor.elementsPrimaryOndark $0.forTrue.enabled.darkColor = VDSColor.elementsPrimaryOndark
$0.forTrue.enabled.darkColor = VDSColor.elementsPrimaryOndark $0.forTrue.disabled.lightColor = VDSColor.paletteGray95
$0.forTrue.disabled.lightColor = VDSColor.paletteGray95 $0.forTrue.disabled.darkColor = VDSColor.paletteGray44
$0.forTrue.disabled.darkColor = VDSColor.paletteGray44 $0.forFalse.enabled.lightColor = VDSColor.elementsPrimaryOndark
$0.forFalse.enabled.lightColor = VDSColor.elementsPrimaryOndark $0.forFalse.enabled.darkColor = VDSColor.elementsPrimaryOndark
$0.forFalse.enabled.darkColor = VDSColor.elementsPrimaryOndark $0.forFalse.disabled.lightColor = VDSColor.paletteGray95
$0.forFalse.disabled.lightColor = VDSColor.paletteGray95 $0.forFalse.disabled.darkColor = VDSColor.paletteGray44
$0.forFalse.disabled.darkColor = VDSColor.paletteGray44 }
}
} ()
//-------------------------------------------------- //--------------------------------------------------
// MARK: - Public Properties // MARK: - Public Properties

1
VDS/Protocols/Withable.swift
View File

@ -48,3 +48,4 @@ public extension Withable {
return copy return copy
} }
} }