Add gestures initial functionality

Sources/TokamakCore/CoordinateSpace/CoordinateSpace.swift

@@ -0,0 +1,48 @@
+// Copyright 2020 Tokamak contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//  Created by Szymon on 18/8/2023.
+//
+
+import Foundation
+
+public enum CoordinateSpace {
+    case global
+    case local
+    case named(AnyHashable)
+}
+
+extension CoordinateSpace: Equatable, Hashable {
+    // Equatable and Hashable conformance
+}
+
+extension CoordinateSpace {
+    public var isGlobal: Bool {
+        switch self {
+        case .global:
+            return true
+        default:
+            return false
+        }
+    }
+
+    public var isLocal: Bool {
+        switch self {
+        case .local:
+            return true
+        default:
+            return false
+        }
+    }
+}

Sources/TokamakCore/CoordinateSpace/CoordinateSpaceEnviroment.swift

@@ -0,0 +1,45 @@
+// Copyright 2020 Tokamak contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//  Created by Szymon on 19/8/2023.
+//
+
+import Foundation
+
+private struct CoordinateSpaceEnvironmentKey: EnvironmentKey {
+    static let defaultValue: CoordinateSpaceContext = CoordinateSpaceContext()
+}
+
+extension EnvironmentValues {
+    var _coordinateSpace: CoordinateSpaceContext {
+        get { self[CoordinateSpaceEnvironmentKey.self] }
+        set { self[CoordinateSpaceEnvironmentKey.self] = newValue }
+    }
+}
+
+class CoordinateSpaceContext {
+    /// Stores currently active CoordinateSpace against it's origin point in global coordinates
+    var activeCoordinateSpace: [CoordinateSpace: CGPoint] = [:]
+}
+
+extension CoordinateSpace {
+    static func convertGlobalSpaceCoordinates(rect: CGRect, toNamedOrigin namedOrigin: CGPoint) -> CGRect {
+        let translatedOrigin = convert(rect.origin, toNamedOrigin: namedOrigin)
+        return CGRect(origin: translatedOrigin, size: rect.size)
+    }
+
+    static func convert(_ point: CGPoint, toNamedOrigin namedOrigin: CGPoint) -> CGPoint {
+        return CGPoint(x: point.x - namedOrigin.x, y: point.y - namedOrigin.y)
+    }
+}

Sources/TokamakCore/Gestures/Composing/ExclusiveGesture.swift

@@ -0,0 +1,39 @@
+// Copyright 2020 Tokamak contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//  Created by Szymon on 16/7/2023.
+//
+
+@frozen
+/// The ExclusiveGesture gives precedence to its first gesture.
+public struct ExclusiveGesture<First, Second> where First : Gesture, Second : Gesture {
+    /// The value of an exclusive gesture that indicates which of two gestures succeeded.
+    public typealias Value = ExclusiveGesture.ExclusiveValue
+
+    public struct ExclusiveValue {
+        public var first: First.Value
+        public var second: First.Value
+    }
+
+    /// The first of two gestures.
+    public var first: First
+    /// The second of two gestures.
+    public var second: Second
+
+    /// Creates a gesture from two gestures where only one of them succeeds.
+    init(first: First, second: Second) {
+        self.first = first
+        self.second = second
+    }
+}

Sources/TokamakCore/Gestures/Composing/SequenceGesture.swift

@@ -0,0 +1,38 @@
+// Copyright 2020 Tokamak contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//  Created by Szymon on 16/7/2023.
+//
+
+@frozen
+public struct SequenceGesture<First, Second> where First : Gesture, Second : Gesture {
+    /// The value of a sequence gesture that helps to detect whether the first gesture succeeded, so the second gesture can start.
+    public typealias Value = SequenceGesture.SequenceValue
+
+    public struct SequenceValue {
+        public var first: First.Value
+        public var second: First.Value
+    }
+
+    /// The first gesture in a sequence of two gestures.
+    public var first: First
+    /// The second gesture in a sequence of two gestures.
+    public var second: Second
+
+    /// Creates a sequence gesture with two gestures.
+    init(first: First, second: Second) {
+        self.first = first
+        self.second = second
+    }
+}

Sources/TokamakCore/Gestures/Composing/SimultaneousGesture.swift

@@ -0,0 +1,37 @@
+// Copyright 2020 Tokamak contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//  Created by Szymon on 16/7/2023.
+//
+
+@frozen
+public struct SimultaneousGesture<First, Second> where First : Gesture, Second : Gesture {
+    public typealias Value = SimultaneousGesture.SimultaneousValue
+
+    public struct SimultaneousValue {
+        public let first: First.Value?
+        public let second: First.Value?
+    }
+
+    /// The first of two gestures that can happen simultaneously.
+    public let first: First
+    /// The second of two gestures that can happen simultaneously.
+    public let second: Second
+
+    /// Creates a gesture with two gestures that can receive updates or succeed independently of each other.
+    init(first: First, second: Second) {
+        self.first = first
+        self.second = second
+    }
+}

Sources/TokamakCore/Gestures/Gesture.swift

@@ -0,0 +1,130 @@
+// Copyright 2020 Tokamak contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//  Created by Szymon on 16/7/2023.
+//
+
+import Foundation
+
+public protocol Gesture {
+    // MARK: Required
+
+    /// The type representing the gesture’s value.
+    associatedtype Value
+
+    /// The type of gesture representing the body of Self.
+    associatedtype Body: Gesture
+
+    /// The content and behavior of the gesture.
+    var body: Self.Body { get }
+
+    /// Adds an action to perform when the gesture’s phase changes.
+    /// - Parameter phase: Gesture new phase
+    /// - Returns: Returns `true` if the  gesture is recognized, false otherwise.
+    mutating func _onPhaseChange(_ phase: _GesturePhase) -> Bool
+    /// Adds an action to perform when the gesture’s value changes.
+    func _onChanged(perform action: @escaping (Value) -> Void) -> Self
+    /// Adds an action to perform when the gesture ends.
+    func _onEnded(perform action: @escaping (Value) -> Void) -> Self
+}
+
+// MARK: Performing the gesture
+
+extension Gesture {
+    /// Adds an action to perform when the gesture ends.
+    public func onEnded(_ action: @escaping (Self.Value) -> Void) -> _EndedGesture<Self> {
+        _EndedGesture(self, onEnded: action)
+    }
+
+    /// Updates the provided gesture value property as the gesture’s value changes.
+    public func updating<State>(
+            _ state: GestureState<State>,
+            body: @escaping (Self.Value, inout State, inout Transaction) -> Void
+        ) -> GestureStateGesture<Self, State> {
+            GestureStateGesture(base: self, state: state, updatingBody: body)
+        }
+}
+
+// MARK: Performing the gesture
+
+extension Gesture where Value: Equatable {
+    /// Adds an action to perform when the gesture’s value changes.
+    /// Available when Value conforms to Equatable.
+    public func onChanged(_ action: @escaping (Self.Value) -> Void) -> _ChangedGesture<Self> {
+        _ChangedGesture(self, onChanged: action)
+    }
+}
+
+// MARK: Composing gestures
+
+extension Gesture {
+    /// Combines a gesture with another gesture to create a new gesture that recognizes both gestures at the same time.
+    public func simultaneously<Other>(with gesture: Other) -> SimultaneousGesture<Self, Other> {
+        SimultaneousGesture(first: self, second: gesture)
+    }
+
+    /// Sequences a gesture with another one to create a new gesture, which results in the second gesture only receiving events after the first gesture succeeds.
+    public func sequenced<Other>(before gesture: Other) -> SequenceGesture<Self, Other> {
+        SequenceGesture(first: self, second: gesture)
+    }
+
+    /// Combines two gestures exclusively to create a new gesture where only one gesture succeeds, giving precedence to the first gesture.
+    public func exclusively<Other>(before gesture: Other) -> ExclusiveGesture<Self, Other> {
+        ExclusiveGesture(first: self, second: gesture)
+    }
+}
+
+// MARK: Transforming a gesture
+
+extension Gesture {}
+
+// MARK: Private Helpers
+
+extension Gesture {
+    func calculateDistance(xOffset: Double, yOffset: Double) -> Double {
+        let xSquared = pow(xOffset, 2)
+        let ySquared = pow(yOffset, 2)
+        let sumOfSquares = xSquared + ySquared
+        let distance = sqrt(sumOfSquares)
+        return distance
+    }
+
+    func calculateTranslation(from pointA: CGPoint, to pointB: CGPoint) -> CGSize {
+        let dx = pointB.x - pointA.x
+        let dy = pointB.y - pointA.y
+        return CGSize(width: dx, height: dy)
+    }
+
+    func calculateVelocity(from translation: CGSize, timeElapsed: Double) -> CGSize {
+        guard timeElapsed > .zero else { return .zero }
+        let velocityX = translation.width / timeElapsed
+        let velocityY = translation.height / timeElapsed
+
+        return CGSize(width: velocityX, height: velocityY)
+    }
+
+    func calculatePredictedEndLocation(from location: CGPoint, velocity: CGSize) -> CGPoint {
+        let predictedX = location.x + velocity.width
+        let predictedY = location.y + velocity.height
+
+        return CGPoint(x: predictedX, y: predictedY)
+    }
+
+    func calculatePredictedEndTranslation(from translation: CGSize, velocity: CGSize) -> CGSize {
+        let predictedWidth = translation.width + velocity.width
+        let predictedHeight = translation.height + velocity.height
+
+        return CGSize(width: predictedWidth, height: predictedHeight)
+    }
+}