437 lines
11 KiB
Swift
437 lines
11 KiB
Swift
|
|
// Reusable "none" constant
|
|
public let DIALECT_CONTEXT_RECENT_FIELD_NONE = "none"
|
|
|
|
// Base protocol for each component's state
|
|
public protocol DialectContext {
|
|
var recentField: String { get set }
|
|
|
|
func field<T>(_ name: String) -> T
|
|
func fieldAny(_ name: String) -> Any
|
|
mutating func setField(_ name: String, _ value: Any)
|
|
}
|
|
|
|
// Default implementation of `fieldAny` method for the protocol
|
|
public extension DialectContext {
|
|
func fieldAny(_ name: String) -> Any {
|
|
return field(name)
|
|
}
|
|
}
|
|
|
|
// The engine of the dialect components
|
|
public class DialectController {
|
|
var callbacks = [(DialectContext) -> Void]()
|
|
var context: DialectContext
|
|
var functions = [(DialectContext) -> DialectContext]()
|
|
var isProcessingQueue = false
|
|
var queue = [DialectContext]()
|
|
|
|
public init(_ context: DialectContext) {
|
|
self.context = context
|
|
}
|
|
|
|
func executeFunctions() {
|
|
let c = queue.removeFirst()
|
|
// Keep SSOT: Only allow single field change per should-function
|
|
context.recentField = c.recentField
|
|
context.setField(c.recentField, c.fieldAny(c.recentField))
|
|
|
|
for f in functions {
|
|
let ctx = f(context)
|
|
if ctx.recentField != DIALECT_CONTEXT_RECENT_FIELD_NONE {
|
|
queue.append(ctx)
|
|
}
|
|
}
|
|
|
|
reportContext()
|
|
}
|
|
|
|
func processQueue() {
|
|
// Prevent recursion.
|
|
if isProcessingQueue {
|
|
return
|
|
}
|
|
|
|
isProcessingQueue = true
|
|
|
|
while (queue.count > 0) {
|
|
executeFunctions()
|
|
}
|
|
|
|
isProcessingQueue = false
|
|
}
|
|
|
|
public func registerCallback(_ cb: @escaping (DialectContext) -> Void) {
|
|
callbacks.append(cb)
|
|
}
|
|
|
|
public func registerFieldCallback(
|
|
_ fieldName: String,
|
|
_ cb: @escaping (DialectContext) -> Void
|
|
) {
|
|
callbacks.append({ c in
|
|
if c.recentField == fieldName {
|
|
cb(c)
|
|
}
|
|
})
|
|
}
|
|
|
|
public func registerFunction(_ f: @escaping (DialectContext) -> DialectContext) {
|
|
functions.append(f)
|
|
}
|
|
|
|
func reportContext() {
|
|
for cb in callbacks {
|
|
cb(context)
|
|
}
|
|
}
|
|
|
|
public func set(
|
|
_ fieldName: String,
|
|
_ value: Any
|
|
) {
|
|
var c = context
|
|
c.setField(fieldName, value)
|
|
c.recentField = fieldName
|
|
queue.append(c)
|
|
processQueue()
|
|
}
|
|
}
|
|
|
|
// Register several oneliner callbacks to a controller
|
|
func registerOneliners<T>(
|
|
_ ctrl: DialectController,
|
|
_ items: [Any]
|
|
) -> T? {
|
|
let halfCount = items.count / 2
|
|
for i in 0..<halfCount {
|
|
let field = items[i * 2] as! String
|
|
let callback = items[i * 2 + 1] as! (T) -> Void
|
|
ctrl.registerFieldCallback(field) { cc in
|
|
let c = cc as! T
|
|
callback(c)
|
|
}
|
|
}
|
|
|
|
// A hack for generics to operate
|
|
return nil
|
|
}
|
|
|
|
// Context field names for static type check
|
|
public struct F {
|
|
public static let backingPixelSize = "backingPixelSize"
|
|
public static let count = "count"
|
|
public static let countText = "countText"
|
|
public static let didClickIncrement = "didClickIncrement"
|
|
public static let didLaunch = "didLaunch"
|
|
public static let didPrepareGL = "didPrepareGL"
|
|
public static let didSetup = "didSetup"
|
|
public static let pixelSize = "pixelSize"
|
|
public static let reshapePixelSize = "reshapePixelSize"
|
|
public static let willDeinit = "willDeinit"
|
|
|
|
}
|
|
public struct RenderContext: DialectContext {
|
|
public var backingPixelSize = [Int32]()
|
|
public var didClickIncrement = Bool()
|
|
public var didLaunch = Bool()
|
|
public var didPrepareGL = Bool()
|
|
public var didSetup = Bool()
|
|
public var pixelSize = [Int32]()
|
|
public var reshapePixelSize = [Int32]()
|
|
public var willDeinit = Bool()
|
|
|
|
public var recentField = ""
|
|
|
|
public func field<T>(_ name: String) -> T {
|
|
if (name == "backingPixelSize") {
|
|
return backingPixelSize as! T
|
|
}
|
|
else if (name == "didClickIncrement") {
|
|
return didClickIncrement as! T
|
|
}
|
|
else if (name == "didLaunch") {
|
|
return didLaunch as! T
|
|
}
|
|
else if (name == "didPrepareGL") {
|
|
return didPrepareGL as! T
|
|
}
|
|
else if (name == "didSetup") {
|
|
return didSetup as! T
|
|
}
|
|
else if (name == "pixelSize") {
|
|
return pixelSize as! T
|
|
}
|
|
else if (name == "reshapePixelSize") {
|
|
return reshapePixelSize as! T
|
|
}
|
|
else if (name == "willDeinit") {
|
|
return willDeinit as! T
|
|
}
|
|
|
|
return "unknown-field-name" as! T
|
|
}
|
|
|
|
public mutating func setField(
|
|
_ name: String,
|
|
_ value: Any
|
|
) {
|
|
if (name == "backingPixelSize") {
|
|
backingPixelSize = value as! [Int32]
|
|
}
|
|
else if (name == "didClickIncrement") {
|
|
didClickIncrement = value as! Bool
|
|
}
|
|
else if (name == "didLaunch") {
|
|
didLaunch = value as! Bool
|
|
}
|
|
else if (name == "didPrepareGL") {
|
|
didPrepareGL = value as! Bool
|
|
}
|
|
else if (name == "didSetup") {
|
|
didSetup = value as! Bool
|
|
}
|
|
else if (name == "pixelSize") {
|
|
pixelSize = value as! [Int32]
|
|
}
|
|
else if (name == "reshapePixelSize") {
|
|
reshapePixelSize = value as! [Int32]
|
|
}
|
|
else if (name == "willDeinit") {
|
|
willDeinit = value as! Bool
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
public struct RootContext: DialectContext {
|
|
public var count = Int()
|
|
public var countText = String()
|
|
public var didClickIncrement = Bool()
|
|
public var didLaunch = Bool()
|
|
public var didSetup = Bool()
|
|
|
|
public var recentField = ""
|
|
|
|
public func field<T>(_ name: String) -> T {
|
|
if (name == "count") {
|
|
return count as! T
|
|
}
|
|
else if (name == "countText") {
|
|
return countText as! T
|
|
}
|
|
else if (name == "didClickIncrement") {
|
|
return didClickIncrement as! T
|
|
}
|
|
else if (name == "didLaunch") {
|
|
return didLaunch as! T
|
|
}
|
|
else if (name == "didSetup") {
|
|
return didSetup as! T
|
|
}
|
|
|
|
return "unknown-field-name" as! T
|
|
}
|
|
|
|
public mutating func setField(
|
|
_ name: String,
|
|
_ value: Any
|
|
) {
|
|
if (name == "count") {
|
|
count = value as! Int
|
|
}
|
|
else if (name == "countText") {
|
|
countText = value as! String
|
|
}
|
|
else if (name == "didClickIncrement") {
|
|
didClickIncrement = value as! Bool
|
|
}
|
|
else if (name == "didLaunch") {
|
|
didLaunch = value as! Bool
|
|
}
|
|
else if (name == "didSetup") {
|
|
didSetup = value as! Bool
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
public func renderSet(
|
|
_ key: String,
|
|
_ value: Any
|
|
) {
|
|
RenderComponent.singleton!.ctrl.set(key, value)
|
|
}
|
|
|
|
public func rootSet(
|
|
_ key: String,
|
|
_ value: Any
|
|
) {
|
|
RootComponent.singleton!.ctrl.set(key, value)
|
|
}
|
|
|
|
func renderShouldResetDidLaunch(_ c: RenderContext) -> RenderContext {
|
|
var c = c
|
|
|
|
/* 1. Only once during the first setup */
|
|
if
|
|
c.recentField == F.didSetup &&
|
|
c.didLaunch == false
|
|
{
|
|
c.didLaunch = true
|
|
c.recentField = F.didLaunch
|
|
return c
|
|
}
|
|
|
|
|
|
c.recentField = DIALECT_CONTEXT_RECENT_FIELD_NONE
|
|
return c
|
|
}
|
|
|
|
func renderShouldResetPixelSize(_ c: RenderContext) -> RenderContext {
|
|
var c = c
|
|
|
|
/* 1. Upon launch */
|
|
if
|
|
c.recentField == F.didLaunch
|
|
{
|
|
c.pixelSize = [1, 1]
|
|
c.recentField = F.pixelSize
|
|
return c
|
|
}
|
|
|
|
/* 2. Upon resize */
|
|
if
|
|
c.recentField == F.reshapePixelSize
|
|
{
|
|
c.pixelSize = c.reshapePixelSize
|
|
c.recentField = F.pixelSize
|
|
return c
|
|
}
|
|
|
|
/* 3. Upon DPI change */
|
|
if
|
|
c.recentField == F.backingPixelSize
|
|
{
|
|
c.pixelSize = c.backingPixelSize
|
|
c.recentField = F.pixelSize
|
|
return c
|
|
}
|
|
|
|
|
|
c.recentField = DIALECT_CONTEXT_RECENT_FIELD_NONE
|
|
return c
|
|
}
|
|
|
|
func rootShouldResetCount(_ c: RootContext) -> RootContext {
|
|
var c = c
|
|
|
|
/* 1. Upon hitting 10 the first time */
|
|
if
|
|
c.recentField == F.didClickIncrement &&
|
|
c.count == 7
|
|
{
|
|
c.count += 10
|
|
c.recentField = F.count
|
|
return c
|
|
}
|
|
|
|
/* 2. Upon each button click */
|
|
if
|
|
c.recentField == F.didClickIncrement
|
|
{
|
|
c.count += 1
|
|
c.recentField = F.count
|
|
return c
|
|
}
|
|
|
|
|
|
c.recentField = DIALECT_CONTEXT_RECENT_FIELD_NONE
|
|
return c
|
|
}
|
|
|
|
func rootShouldResetCountText(_ c: RootContext) -> RootContext {
|
|
var c = c
|
|
|
|
/* 1. Upon each count change */
|
|
if
|
|
c.recentField == F.count
|
|
{
|
|
c.countText = "Count: '\(c.count)'"
|
|
c.recentField = F.countText
|
|
return c
|
|
}
|
|
|
|
/* 2. Upon launch */
|
|
if
|
|
c.recentField == F.didLaunch
|
|
{
|
|
c.countText = "Press the button to count"
|
|
c.recentField = F.countText
|
|
return c
|
|
}
|
|
|
|
|
|
c.recentField = DIALECT_CONTEXT_RECENT_FIELD_NONE
|
|
return c
|
|
}
|
|
|
|
func rootShouldResetDidLaunch(_ c: RootContext) -> RootContext {
|
|
var c = c
|
|
|
|
/* 1. Only once during the first setup */
|
|
if
|
|
c.recentField == F.didSetup &&
|
|
c.didLaunch == false
|
|
{
|
|
c.didLaunch = true
|
|
c.recentField = F.didLaunch
|
|
return c
|
|
}
|
|
|
|
|
|
c.recentField = DIALECT_CONTEXT_RECENT_FIELD_NONE
|
|
return c
|
|
}
|
|
|
|
func renderRegisterShoulds(_ ctrl: DialectController) {
|
|
[
|
|
renderShouldResetDidLaunch,
|
|
renderShouldResetPixelSize,
|
|
|
|
].forEach { f in
|
|
ctrl.registerFunction { c in f(c as! RenderContext) }
|
|
}
|
|
}
|
|
|
|
func rootRegisterShoulds(_ ctrl: DialectController) {
|
|
[
|
|
rootShouldResetCount,
|
|
rootShouldResetCountText,
|
|
rootShouldResetDidLaunch,
|
|
|
|
].forEach { f in
|
|
ctrl.registerFunction { c in f(c as! RootContext) }
|
|
}
|
|
}
|
|
|
|
func renderRegisterEffects(_ ctrl: DialectController) {
|
|
let _: RenderContext? = registerOneliners(ctrl, [
|
|
F.didClickIncrement, { (c: RenderContext) in renderLoadCubeModel(RenderVM.shared!) },
|
|
F.didPrepareGL, { (c: RenderContext) in renderInit(RenderVM.shared!) },
|
|
F.didPrepareGL, { (c: RenderContext) in RenderVM.shared!.didPrepareGL = true },
|
|
F.didPrepareGL, { (c: RenderContext) in renderStartTimer(RenderVM.shared!) },
|
|
F.pixelSize, { (c: RenderContext) in RenderVM.shared!.pixelSize = c.pixelSize },
|
|
F.willDeinit, { (c: RenderContext) in renderDeinit(RenderVM.shared!) },
|
|
|
|
])
|
|
}
|
|
|
|
func rootRegisterEffects(_ ctrl: DialectController) {
|
|
let _: RootContext? = registerOneliners(ctrl, [
|
|
F.countText, { (c: RootContext) in RootVM.shared!.countText = c.countText },
|
|
F.didClickIncrement, { (c: RootContext) in renderSet(F.didClickIncrement, true) },
|
|
|
|
])
|
|
}
|