waterui-ffi 0.3.0

FFI bindings for the WaterUI cross-platform UI framework
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! FFI bindings for gesture types.

use crate::IntoFFI;
use crate::action::WuiAction;
use alloc::boxed::Box;
use waterui::gesture::{Gesture, GestureObserver};

/// FFI-safe representation of a gesture type.
#[repr(C)]
#[derive(Debug)]
pub enum WuiGesture {
    /// A tap gesture requiring a specific number of taps.
    Tap {
        /// Number of taps required to recognize the gesture.
        count: u32,
    },
    /// A long-press gesture requiring a minimum duration.
    LongPress {
        /// Minimum press duration in milliseconds before the gesture fires.
        duration: u32,
    },
    /// A drag gesture with minimum distance threshold.
    Drag {
        /// Minimum drag distance (in points) before the gesture fires.
        min_distance: f32,
    },
    /// A magnification (pinch) gesture with initial scale.
    Magnification {
        /// Scale factor the gesture starts recognizing from.
        initial_scale: f32,
    },
    /// A rotation gesture with initial angle.
    Rotation {
        /// Angle (in radians) the gesture starts recognizing from.
        initial_angle: f32,
    },
    /// A sequential composition of two gestures.
    Then {
        /// The first gesture that must complete.
        first: *mut Self,
        /// The gesture that runs after the first completes.
        then: *mut Self,
    },
    /// A parallel composition of two gestures.
    Simultaneous {
        /// The first gesture in the composition.
        first: *mut Self,
        /// The second gesture in the composition.
        second: *mut Self,
    },
    /// An exclusive composition where first has priority over second.
    Exclusive {
        /// The primary gesture.
        first: *mut Self,
        /// The fallback gesture.
        second: *mut Self,
    },
}

impl IntoFFI for Gesture {
    type FFI = WuiGesture;
    fn into_ffi(self) -> Self::FFI {
        match self {
            Self::Tap(tap) => WuiGesture::Tap { count: tap.count },
            Self::LongPress(lp) => WuiGesture::LongPress {
                duration: lp.duration,
            },
            Self::Drag(drag) => WuiGesture::Drag {
                min_distance: drag.min_distance,
            },
            Self::Magnification(mag) => WuiGesture::Magnification {
                initial_scale: mag.initial_scale,
            },
            Self::Rotation(rot) => WuiGesture::Rotation {
                initial_angle: rot.initial_angle,
            },
            Self::Then(then) => {
                let first = Box::into_raw(Box::new(then.first().clone().into_ffi()));
                let then_gesture = Box::into_raw(Box::new(then.then().clone().into_ffi()));
                WuiGesture::Then {
                    first,
                    then: then_gesture,
                }
            }
            Self::Simultaneous(pair) => {
                let first = Box::into_raw(Box::new(pair.first().clone().into_ffi()));
                let second = Box::into_raw(Box::new(pair.second().clone().into_ffi()));
                WuiGesture::Simultaneous { first, second }
            }
            Self::Exclusive(pair) => {
                let first = Box::into_raw(Box::new(pair.first().clone().into_ffi()));
                let second = Box::into_raw(Box::new(pair.second().clone().into_ffi()));
                WuiGesture::Exclusive { first, second }
            }
            _ => panic!("Unsupported Gesture variant for FFI conversion"),
        }
    }
}

/// Drops a `WuiGesture`, recursively freeing any composite variants.
///
/// # Safety
///
/// The gesture pointer must be valid and properly initialized.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn waterui_drop_gesture(gesture: *mut WuiGesture) {
    // SAFETY: the caller contract makes `gesture` an owning pointer from the matching
    // constructor, reclaimed once here.
    unsafe {
        let gesture = Box::from_raw(gesture);
        match *gesture {
            WuiGesture::Then { first, then } => {
                waterui_drop_gesture(first);
                waterui_drop_gesture(then);
            }
            WuiGesture::Simultaneous { first, second }
            | WuiGesture::Exclusive { first, second } => {
                waterui_drop_gesture(first);
                waterui_drop_gesture(second);
            }
            WuiGesture::Tap { .. }
            | WuiGesture::LongPress { .. }
            | WuiGesture::Drag { .. }
            | WuiGesture::Magnification { .. }
            | WuiGesture::Rotation { .. } => {}
        }
    }
}

/// FFI-safe representation of a gesture observer.
#[repr(C)]
#[derive(Debug)]
pub struct WuiGestureObserver {
    /// The gesture type to observe.
    pub gesture: WuiGesture,
    /// Pointer to the action handler.
    pub action: *mut WuiAction,
}

impl IntoFFI for GestureObserver {
    type FFI = WuiGestureObserver;
    fn into_ffi(self) -> Self::FFI {
        WuiGestureObserver {
            gesture: self.gesture.into_ffi(),
            action: self.action.into_ffi(),
        }
    }
}