Clarify and fix various sink behaviors

Signed-off-by: Andrew Opalach <andrew@akon.city>

2 files changed, 72 insertions, 26 deletions

diff --git a/src/screen/screen.c b/src/screen/screen.c
index bb11757..09fbe64 100644
--- a/src/screen/screen.c
+++ b/src/screen/screen.c
@@ -9,6 +9,7 @@
 #define SCREEN_MOD1(scr) ((scr)->flags & CAMU_SCREEN_MOD_CONTROL)
 #define SCREEN_MOD2(scr) ((scr)->flags & CAMU_SCREEN_MOD_SHIFT)
 #define SCREEN_IS_DRAGGING(scr) ((scr)->flags & CAMU_SCREEN_DRAGGING)
+#define SCREEN_IS_ZOOMING(scr) ((scr)->flags & CAMU_SCREEN_ZOOMING)
 #define SCREEN_ZOOM_MODE(scr, mode) ((scr)->flags & mode)
 #define SCREEN_INVALID_TS ((u64)-1)
 #define SCREEN_LAST_CLICK_WITHIN(ns) \
@@ -29,15 +30,6 @@ static void render_callback(void *userdata)
     }
 }
 
-static void refresh_callback(void *userdata)
-{
-    struct camu_screen *scr = (struct camu_screen *)userdata;
-    if (scr->renderer) {
-        // The thread-safety of this is questionable.
-        scr->renderer->render(scr->renderer, scr, true);
-    }
-}
-
 static void do_resize(struct camu_screen *scr, u32 width, u32 height)
 {
     if (scr->renderer) {
@@ -76,7 +68,6 @@ static struct camu_view *get_view_from_mouse_pos(struct camu_screen *scr)
     return view;
 }
 
-
 static bool pointer_pos_callback(void *userdata, f64 x, f64 y)
 {
     struct camu_screen *scr = (struct camu_screen *)userdata;
@@ -84,8 +75,8 @@ static bool pointer_pos_callback(void *userdata, f64 x, f64 y)
     bool queue_refresh = false;
     if (SCREEN_IS_DRAGGING(scr)) {
         if (view && SCREEN_ZOOM_MODE(scr, CAMU_SCREEN_ZOOM_PAN_SIMPLE)) {
-            f64 dx = x - scr->last_mouse_x;
-            f64 dy = y - scr->last_mouse_y;
+            f64 dx = x - scr->last_pointer_x;
+            f64 dy = y - scr->last_pointer_y;
             if (camu_view_pan_simple(view, scr->width, scr->height, dx, dy)) {
                 view->mode = CAMU_VIEW_DETACHED;
                 queue_refresh = true;
@@ -95,14 +86,67 @@ static bool pointer_pos_callback(void *userdata, f64 x, f64 y)
             }
         }
     }
-    scr->last_mouse_x = x;
-    scr->last_mouse_y = y;
+    scr->last_pointer_x = x;
+    scr->last_pointer_y = y;
     return queue_refresh;
 }
 
+static bool scroll_callback(void *userdata, f64 y);
+
+static bool touch_callback(void *userdata, s32 index, u8 phase, f64 x, f64 y)
+{
+    struct camu_screen *scr = (struct camu_screen *)userdata;
+    // Rough testing stuff.
+    switch (phase) {
+    case STELA_TOUCH_BEGAN: {
+        if (index == 0) {
+            scr->flags |= CAMU_SCREEN_DRAGGING;
+            scr->last_click_ts = nn_get_timestamp();
+            scr->last_pointer_x = x;
+            scr->last_pointer_y = y;
+        } else if (index == 1) {
+            scr->flags &= ~CAMU_SCREEN_DRAGGING;
+            scr->flags |= CAMU_SCREEN_ZOOMING;
+        } else if (index == 2) {
+            struct camu_view *view = get_view_from_mouse_pos(scr);
+            view->mode = CAMU_DEFAULT_VIEW;
+            camu_view_calculate(view, scr->width, scr->height);
+        }
+        break;
+    }
+    case STELA_TOUCH_MOVED: {
+        if (index == 0) {
+            if (SCREEN_IS_ZOOMING(scr)) {
+                f64 dy = (y - scr->last_pointer_y) / 50.0;
+                scr->last_pointer_x = x;
+                scr->last_pointer_y = y;
+                return scroll_callback(scr, dy);
+            } else if (SCREEN_IS_DRAGGING(scr)) {
+                return pointer_pos_callback(scr, x, y);
+            }
+        }
+        break;
+    }
+    case STELA_TOUCH_ENDED: {
+        if (index == 0) {
+            scr->flags &= ~(CAMU_SCREEN_DRAGGING | CAMU_SCREEN_ZOOMING);
+            if (SCREEN_LAST_CLICK_WITHIN(200000)) {
+                s32 n = (x >= scr->width / 2.0) ? 1 : -1;
+                scr->callback(scr->userdata, CAMU_SCREEN_SKIP, &n);
+            }
+        } else if (index == 1) {
+            scr->flags &= ~CAMU_SCREEN_ZOOMING;
+            scr->flags |= CAMU_SCREEN_DRAGGING;
+        }
+        break;
+    }
+    }
+    return false;
+}
+
 static void seek_to_percent_at_pointer(struct camu_screen *scr)
 {
-    f64 percent = scr->last_mouse_x / scr->width;
+    f64 percent = scr->last_pointer_x / scr->width;
     percent = CLAMP(percent, 0.0, 100.0);
     scr->callback(scr->userdata, CAMU_SCREEN_PERCENT_SEEK, &percent);
 }
@@ -123,7 +167,7 @@ static bool mouse_button_callback(void *userdata, u8 state, u8 button)
                 if (SCREEN_MOD1(scr)) {
                     seek_to_percent_at_pointer(scr);
                 } else {
-                    s32 n = (scr->last_mouse_x >= scr->width / 2.0) ? 1 : -1;
+                    s32 n = (scr->last_pointer_x >= scr->width / 2.0) ? 1 : -1;
                     scr->callback(scr->userdata, CAMU_SCREEN_SKIP, &n);
                 }
             }
@@ -145,7 +189,7 @@ static bool mouse_button_callback(void *userdata, u8 state, u8 button)
     return false;
 }
 
-static bool scroll_callback(void *userdata, f64 y)
+bool scroll_callback(void *userdata, f64 y)
 {
     struct camu_screen *scr = (struct camu_screen *)userdata;
     if (SCREEN_MOD1(scr)) {
@@ -162,7 +206,7 @@ static bool scroll_callback(void *userdata, f64 y)
 #endif
         struct camu_view *view = get_view_from_mouse_pos(scr);
         if (view && SCREEN_ZOOM_MODE(scr, CAMU_SCREEN_ZOOM_PAN_SIMPLE)) {
-            if (camu_view_zoom_simple(view, scr->width, scr->height, scr->last_mouse_x, scr->last_mouse_y, y)) {
+            if (camu_view_zoom_simple(view, scr->width, scr->height, scr->last_pointer_x, scr->last_pointer_y, y)) {
                 view->mode = CAMU_VIEW_DETACHED;
                 return true;
             }
@@ -370,21 +414,21 @@ bool camu_screen_init(struct camu_screen *scr)
     al_atomic_store(s32)(&scr->state, CAMU_SCREEN_PAUSED, AL_ATOMIC_RELAXED);
     scr->window = stl_window_create();
     scr->window->render_callback = render_callback;
-    scr->window->refresh_callback = refresh_callback;
+    scr->window->resize_callback = resize_callback;
     scr->window->pointer_pos_callback = pointer_pos_callback;
+    scr->window->touch_callback = touch_callback;
     scr->window->scroll_callback = scroll_callback;
     scr->window->mouse_button_callback = mouse_button_callback;
     scr->window->key_callback = key_callback;
     scr->window->key_immediate_callback = key_immediate_callback;
-    scr->window->resize_callback = resize_callback;
     scr->window->should_close_callback = should_close_callback;
     scr->window->userdata = scr;
     scr->renderer = NULL;
     al_atomic_store(u32)(&scr->force_refresh, 1, AL_ATOMIC_RELAXED);
     scr->flags = CAMU_SCREEN_ZOOM_PAN_SIMPLE;
     scr->last_click_ts = SCREEN_INVALID_TS;
-    scr->last_mouse_x = 0.0;
-    scr->last_mouse_y = 0.0;
+    scr->last_pointer_x = 0.0;
+    scr->last_pointer_y = 0.0;
     al_array_init(scr->videos);
 #ifdef CAMU_SCREEN_THREADED
     al_array_init(scr->add_queue);
@@ -399,6 +443,7 @@ bool camu_screen_init(struct camu_screen *scr)
 static nn_thread_result NNWT_THREADCALL event_thread(void *userdata)
 {
     struct camu_screen *scr = (struct camu_screen *)userdata;
+    nn_thread_set_name("window_events");
     while (scr->window->poll(scr->window, true) && al_atomic_load(s32)(&scr->state, AL_ATOMIC_RELAXED) != CAMU_SCREEN_STOPPED) {
         scr->window->process_events(scr->window);
     }
@@ -613,7 +658,7 @@ void camu_screen_force_refresh(struct camu_screen *scr)
     camu_screen_wake(scr);
 }
 
-#define CAMU_SCREEN_POLL_HZ 576
+#define CAMU_SCREEN_POLL_HZ 432
 
 bool camu_screen_poll(struct camu_screen *scr, bool block)
 {
diff --git a/src/screen/screen.h b/src/screen/screen.h
index afd2dee..dacf756 100644
--- a/src/screen/screen.h
+++ b/src/screen/screen.h
@@ -21,7 +21,8 @@ enum {
     CAMU_SCREEN_MOD_SHIFT = 1,
     CAMU_SCREEN_MOD_CONTROL = 1 << 1,
     CAMU_SCREEN_DRAGGING = 1 << 2,
-    CAMU_SCREEN_ZOOM_PAN_SIMPLE = 1 << 3
+    CAMU_SCREEN_ZOOMING = 1 << 3,
+    CAMU_SCREEN_ZOOM_PAN_SIMPLE = 1 << 4
 };
 
 enum {
@@ -66,8 +67,8 @@ struct camu_screen {
     bool scaling_disabled;
     bool transparent_background;
     u64 last_click_ts;
-    f64 last_mouse_y;
-    f64 last_mouse_x;
+    f64 last_pointer_y;
+    f64 last_pointer_x;
     array(struct camu_screen_video) videos;
 #ifdef CAMU_SCREEN_THREADED
     array(struct camu_video_buffer *) add_queue;