R8: finish app/ pure C ABI migration (P3-P9) and make OTIO required

- app/ no longer includes engine C++ headers nor holds engine C++ types:
  engine access goes through the oakengine C ABI plus C++ wrappers
  (oakutil/oaknode.h, oakutil/oakvideo.h) and app-local mirror types
  (tooltypes, trackreferencehandle, timelinecommonapp, keyframetypes,
  subtitleapp, serializedlayoutinfoapp, nodevaluehandle, sliderdisplaytypeapp)
- engine: new C ABI functions for block/track/clip/transition navigation
  and predicates, links, caches, waveform/playback, disk folder,
  sequence_track_list, node_free, footage_is_valid, block_get_track,
  get_brush; loadotio/saveotio ported to the current engine API
- OTIO is now a required dependency: CI and CD build it on every
  platform, FindOpenTimelineIO fixed for OTIO 0.16/0.19 (the old deps
  include requirement silently disabled OTIO everywhere), runtime
  libraries are bundled into packages and copied next to macOS binaries
  (oak_copy_otio_runtime)
- fix ProjectViewModel drag&drop mime read/write size mismatch (segfault)
- unify color label naming (k_olive -> "Oak") in the app-side mirror
- docs: OTIO required, FFmpeg minimum corrected to 6.0 (en/zh)
- gtest suite: 1925 passed, 0 failed

engine/src/capi/gizmo.cpp

@@ -20,12 +20,20 @@
 
 #include "oakengine/gizmo.h"
 
+#include <QPainter>
 #include <QString>
 
 #include "node/gizmo/draggable.h"
+#include "node/gizmo/path.h"
+#include "node/gizmo/point.h"
+#include "node/gizmo/polygon.h"
+#include "node/gizmo/screen.h"
 #include "node/gizmo/text.h"
+#include "node/globals.h"
 #include "node/generator/text/textv3.h"
 #include "node/node.h"
+#include "render/loopmode.h"
+#include "render/videoparams.h"
 
 extern "C" {
 
@@ -265,4 +273,76 @@ int oakengine_gizmo_drag_end(void *gizmo, void *command)
     return OAKENGINE_OK;
 }
 
+int oakengine_gizmo_is_visible(void *gizmo)
+{
+    if (!gizmo) {
+        return 0;
+    }
+    return static_cast<olive::NodeGizmo *>(gizmo)->is_visible() ? 1 : 0;
+}
+
+int oakengine_gizmo_draw(void *gizmo, void *painter)
+{
+    if (!gizmo || !painter) {
+        return OAKENGINE_E_INVALID;
+    }
+    static_cast<olive::NodeGizmo *>(gizmo)->draw(
+        static_cast<QPainter *>(painter));
+    return OAKENGINE_OK;
+}
+
+int oakengine_gizmo_set_globals(void *gizmo,
+    int video_width, int video_height,
+    int64_t time_num, int64_t time_den)
+{
+    if (!gizmo) {
+        return OAKENGINE_E_INVALID;
+    }
+    olive::VideoParams vp;
+    if (video_width > 0 && video_height > 0) {
+        vp.set_width(video_width);
+        vp.set_height(video_height);
+    }
+    olive::NodeGlobals globals(
+        vp, olive::AudioParams(),
+        olive::Rational(time_num, time_den),
+        olive::LoopMode::k_loop_mode_off);
+    static_cast<olive::NodeGizmo *>(gizmo)->set_globals(globals);
+    return OAKENGINE_OK;
+}
+
+int oakengine_gizmo_hit_test(void *gizmo,
+    const double *transform6, double px, double py)
+{
+    if (!gizmo) {
+        return 0;
+    }
+    auto *g = static_cast<olive::NodeGizmo *>(gizmo);
+    if (!g->is_visible()) {
+        return 0;
+    }
+
+    const QPointF p(px, py);
+
+    if (auto *point = dynamic_cast<olive::PointGizmo *>(g)) {
+        if (!transform6) {
+            return 0;
+        }
+        const QTransform t(transform6[0], transform6[1], transform6[2],
+                           transform6[3], transform6[4], transform6[5]);
+        return point->get_clicking_rect(t).contains(p) ? 1 : 0;
+    }
+    if (auto *poly = dynamic_cast<olive::PolygonGizmo *>(g)) {
+        return poly->get_polygon().containsPoint(p, Qt::OddEvenFill) ? 1 : 0;
+    }
+    if (auto *path = dynamic_cast<olive::PathGizmo *>(g)) {
+        return path->get_path().contains(p) ? 1 : 0;
+    }
+    if (dynamic_cast<olive::ScreenGizmo *>(g)) {
+        // Screen gizmos are hittable anywhere (mirrors the viewer logic).
+        return 1;
+    }
+    return 0;
+}
+
 } // extern "C"