Merge branch 'feature/implement-scrolling'

Author: GeertJohan

application.go

@@ -181,8 +181,9 @@ func (a *Application) Run() error {
 	a.window.SetCharCallback(defaultTextinputPlugin.glfwCharCallback)
 
 	a.window.SetCursorEnterCallback(m.glfwCursorEnterCallback)
-	a.window.SetMouseButtonCallback(m.glfwMouseButtonCallback)
 	a.window.SetCursorPosCallback(m.glfwCursorPosCallback)
+	a.window.SetMouseButtonCallback(m.glfwMouseButtonCallback)
+	a.window.SetScrollCallback(m.glfwScrollCallback)
 	defer a.engine.Shutdown()
 
 	for !a.window.ShouldClose() {

embedder/embedder.go

@@ -1,10 +1,12 @@
 package embedder
 
-// #include "flutter_embedder.h"
+// #include "embedder.h"
 // FlutterEngineResult runFlutter(void *user_data, FlutterEngine *engine, FlutterProjectArgs * Args,
 //						 const char *const * vmArgs, int nVmAgrs);
 // char** makeCharArray(int size);
 // void setArrayString(char **a, char *s, int n);
+// const int32_t kFlutterSemanticsNodeIdBatchEnd = -1;
+// const int32_t kFlutterSemanticsCustomActionIdBatchEnd = -1;
 import "C"
 import (
 	"fmt"
@@ -141,21 +143,36 @@ const (
 	PointerPhaseHover  PointerPhase = C.kHover
 )
 
+// PointerSignalKind corresponds to the C.enum describing signal kind of the mouse pointer.
+type PointerSignalKind int32
+
+// Values representing the pointer signal kind.
+const (
+	PointerSignalKindNone   PointerSignalKind = C.kFlutterPointerSignalKindNone
+	PointerSignalKindScroll PointerSignalKind = C.kFlutterPointerSignalKindScroll
+)
+
 // PointerEvent represents the position and phase of the mouse at a given time.
 type PointerEvent struct {
-	Phase     PointerPhase
-	Timestamp int64
-	X         float64
-	Y         float64
+	Phase        PointerPhase
+	Timestamp    int64
+	X            float64
+	Y            float64
+	SignalKind   PointerSignalKind
+	ScrollDeltaX float64
+	ScrollDeltaY float64
 }
 
 // SendPointerEvent is used to send an PointerEvent to the Flutter engine.
 func (flu *FlutterEngine) SendPointerEvent(event PointerEvent) Result {
 	cPointerEvent := C.FlutterPointerEvent{
-		phase:     (C.FlutterPointerPhase)(event.Phase),
-		x:         C.double(event.X),
-		y:         C.double(event.Y),
-		timestamp: C.size_t(event.Timestamp),
+		phase:          (C.FlutterPointerPhase)(event.Phase),
+		x:              C.double(event.X),
+		y:              C.double(event.Y),
+		timestamp:      C.size_t(event.Timestamp),
+		signal_kind:    (C.FlutterPointerSignalKind)(event.SignalKind),
+		scroll_delta_x: C.double(event.ScrollDeltaX),
+		scroll_delta_y: C.double(event.ScrollDeltaY),
 	}
 	cPointerEvent.struct_size = C.size_t(unsafe.Sizeof(cPointerEvent))
 

embedder/flutter_embedder.h renamed to embedder/embedder.h

@@ -98,9 +98,9 @@ typedef enum {
   // A request that the node should be dismissed.
   kFlutterSemanticsActionDismiss = 1 << 18,
   // Move the cursor forward by one word.
-  kFlutterSemanticsActionMoveCursorForwardByWordIndex = 1 << 19,
+  kFlutterSemanticsActionMoveCursorForwardByWord = 1 << 19,
   // Move the cursor backward by one word.
-  kFlutterSemanticsActionMoveCursorBackwardByWordIndex = 1 << 20,
+  kFlutterSemanticsActionMoveCursorBackwardByWord = 1 << 20,
 } FlutterSemanticsAction;
 
 // The set of properties that may be associated with a semantics node.
@@ -277,6 +277,7 @@ typedef struct {
   double pixel_ratio;
 } FlutterWindowMetricsEvent;
 
+// The phase of the pointer event.
 typedef enum {
   kCancel,
   kUp,
@@ -287,6 +288,12 @@ typedef enum {
   kHover,
 } FlutterPointerPhase;
 
+// The type of a pointer signal.
+typedef enum {
+  kFlutterPointerSignalKindNone,
+  kFlutterPointerSignalKindScroll,
+} FlutterPointerSignalKind;
+
 typedef struct {
   // The size of this struct. Must be sizeof(FlutterPointerEvent).
   size_t struct_size;
@@ -297,6 +304,9 @@ typedef struct {
   // An optional device identifier. If this is not specified, it is assumed that
   // the embedder has no multitouch capability.
   int32_t device;
+  FlutterPointerSignalKind signal_kind;
+  double scroll_delta_x;
+  double scroll_delta_y;
 } FlutterPointerEvent;
 
 struct _FlutterPlatformMessageResponseHandle;
@@ -333,7 +343,8 @@ typedef struct {
 
 // |FlutterSemanticsNode| ID used as a sentinel to signal the end of a batch of
 // semantics node updates.
-// const int32_t kFlutterSemanticsNodeIdBatchEnd = -1;
+FLUTTER_EXPORT
+extern const int32_t kFlutterSemanticsNodeIdBatchEnd;
 
 // A node that represents some semantic data.
 //
@@ -404,7 +415,8 @@ typedef struct {
 
 // |FlutterSemanticsCustomAction| ID used as a sentinel to signal the end of a
 // batch of semantics custom action updates.
-// const int32_t kFlutterSemanticsCustomActionIdBatchEnd = -1;
+FLUTTER_EXPORT
+extern const int32_t kFlutterSemanticsCustomActionIdBatchEnd;
 
 // A custom semantics action, or action override.
 //
@@ -437,6 +449,52 @@ typedef void (*FlutterUpdateSemanticsCustomActionCallback)(
     const FlutterSemanticsCustomAction* /* semantics custom action */,
     void* /* user data */);
 
+typedef struct _FlutterTaskRunner* FlutterTaskRunner;
+
+typedef struct {
+  FlutterTaskRunner runner;
+  uint64_t task;
+} FlutterTask;
+
+typedef void (*FlutterTaskRunnerPostTaskCallback)(
+    FlutterTask /* task */,
+    uint64_t /* target time nanos */,
+    void* /* user data */);
+
+// An interface used by the Flutter engine to execute tasks at the target time
+// on a specified thread. There should be a 1-1 relationship between a thread
+// and a task runner. It is undefined behavior to run a task on a thread that is
+// not associated with its task runner.
+typedef struct {
+  // The size of this struct. Must be sizeof(FlutterTaskRunnerDescription).
+  size_t struct_size;
+  void* user_data;
+  // May be called from any thread. Should return true if tasks posted on the
+  // calling thread will be run on that same thread.
+  //
+  // This field is required.
+  BoolCallback runs_task_on_current_thread_callback;
+  // May be called from any thread. The given task should be executed by the
+  // embedder on the thread associated with that task runner by calling
+  // |FlutterEngineRunTask| at the given target time. The system monotonic clock
+  // should be used for the target time. The target time is the absolute time
+  // from epoch (NOT a delta) at which the task must be returned back to the
+  // engine on the correct thread. If the embedder needs to calculate a delta,
+  // |FlutterEngineGetCurrentTime| may be called and the difference used as the
+  // delta.
+  //
+  // This field is required.
+  FlutterTaskRunnerPostTaskCallback post_task_callback;
+} FlutterTaskRunnerDescription;
+
+typedef struct {
+  // The size of this struct. Must be sizeof(FlutterCustomTaskRunners).
+  size_t struct_size;
+  // Specify the task runner for the thread on which the |FlutterEngineRun| call
+  // is made.
+  const FlutterTaskRunnerDescription* platform_task_runner;
+} FlutterCustomTaskRunners;
+
 typedef struct {
   // The size of this struct. Must be sizeof(FlutterProjectArgs).
   size_t struct_size;
@@ -539,14 +597,34 @@ typedef struct {
   // Flutter application (such as compiled shader programs used by Skia).
   // This is optional.  The string must be NULL terminated.
   const char* persistent_cache_path;
-  // A callback that gets invoked by the engine when it attempts to wait for
-  // a platform vsync event. The engine will give the platform a baton that
-  // needs to be returned back to the engine via |FlutterEngineOnVsync|. All
-  // vsync operations must occur on the thread that made the call to
-  // |FlutterEngineRun|. All batons must be retured to the engine before
-  // initializing a |FlutterEngineShutdown|. Not doing the same will result in a
-  // memory leak.
+
+  // If true, we'll only read the existing cache, but not write new ones.
+  bool is_persistent_cache_read_only;
+
+  // A callback that gets invoked by the engine when it attempts to wait for a
+  // platform vsync event. The engine will give the platform a baton that needs
+  // to be returned back to the engine via |FlutterEngineOnVsync|. All batons
+  // must be retured to the engine before initializing a
+  // |FlutterEngineShutdown|. Not doing the same will result in a memory leak.
+  // While the call to |FlutterEngineOnVsync| must occur on the thread that made
+  // the call to |FlutterEngineRun|, the engine will make this callback on an
+  // internal engine-managed thread. If the components accessed on the embedder
+  // are not thread safe, the appropriate re-threading must be done.
   VsyncCallback vsync_callback;
+
+  // The name of a custom Dart entrypoint. This is optional and specifying a
+  // null or empty entrypoint makes the engine look for a method named "main" in
+  // the root library of the application.
+  //
+  // Care must be taken to ensure that the custom entrypoint is not tree-shaken
+  // away. Usually, this is done using the `@pragma('vm:entry-point')`
+  // decoration.
+  const char* custom_dart_entrypoint;
+
+  // Typically the Flutter engine create and manages its internal threads. This
+  // optional argument allows for the specification of task runner interfaces to
+  // event loops managed by the embedder on threads it creates.
+  const FlutterCustomTaskRunners* custom_task_runners;
 } FlutterProjectArgs;
 
 FLUTTER_EXPORT
@@ -635,7 +713,21 @@ FlutterEngineResult FlutterEngineDispatchSemanticsAction(
     size_t data_length);
 
 // Notify the engine that a vsync event occurred. A baton passed to the
-// platform via the vsync callback must be returned.
+// platform via the vsync callback must be returned. This call must be made on
+// the thread on which the call to |FlutterEngineRun| was made.
+//
+// |frame_start_time_nanos| is the point at which the vsync event occurred or
+// will occur. If the time point is in the future, the engine will wait till
+// that point to begin its frame workload. The system monotonic clock is used as
+// the timebase.
+//
+// |frame_target_time_nanos| is the point at which the embedder anticipates the
+// next vsync to occur. This is a hint the engine uses to schedule Dart VM
+// garbage collection in periods in which the various threads are most likely to
+// be idle. For example, for a 60Hz display, embedders should add 16.6 * 1e6 to
+// the frame time field. The system monotonic clock is used as the timebase.
+//
+// That frame timepoints are in nanoseconds.
 FLUTTER_EXPORT
 FlutterEngineResult FlutterEngineOnVsync(FlutterEngine engine,
                                          intptr_t baton,
@@ -646,24 +738,49 @@ FlutterEngineResult FlutterEngineOnVsync(FlutterEngine engine,
 // the timeline is unavailable or disabled, this has no effect. Must be
 // balanced with an duration end event (via
 // |FlutterEngineTraceEventDurationEnd|) with the same name on the same thread.
-// Can be called on any thread.
+// Can be called on any thread. Strings passed into the function will NOT be
+// copied when added to the timeline. Only string literals may be passed in.
 FLUTTER_EXPORT
 void FlutterEngineTraceEventDurationBegin(const char* name);
 
 // A profiling utility. Logs a trace duration end event to the timeline. If the
 // timeline is unavailable or disabled, this has no effect. This call must be
 // preceded by a trace duration begin call (via
 // |FlutterEngineTraceEventDurationBegin|) with the same name on the same
-// thread. Can be called on any thread.
+// thread. Can be called on any thread. Strings passed into the function will
+// NOT be copied when added to the timeline. Only string literals may be passed
+// in.
 FLUTTER_EXPORT
 void FlutterEngineTraceEventDurationEnd(const char* name);
 
 // A profiling utility. Logs a trace duration instant event to the timeline. If
 // the timeline is unavailable or disabled, this has no effect. Can be called
-// on any thread.
+// on any thread. Strings passed into the function will NOT be copied when added
+// to the timeline. Only string literals may be passed in.
 FLUTTER_EXPORT
 void FlutterEngineTraceEventInstant(const char* name);
 
+// Posts a task onto the Flutter render thread. Typically, this may be called
+// from any thread as long as a |FlutterEngineShutdown| on the specific engine
+// has not already been initiated.
+FLUTTER_EXPORT
+FlutterEngineResult FlutterEnginePostRenderThreadTask(FlutterEngine engine,
+                                                      VoidCallback callback,
+                                                      void* callback_data);
+
+// Get the current time in nanoseconds from the clock used by the flutter
+// engine. This is the system monotonic clock.
+FLUTTER_EXPORT
+uint64_t FlutterEngineGetCurrentTime();
+
+// Inform the engine to run the specified task. This task has been given to
+// the engine via the |FlutterTaskRunnerDescription.post_task_callback|. This
+// call must only be made at the target time specified in that callback. Running
+// the task before that time is undefined behavior.
+FLUTTER_EXPORT
+FlutterEngineResult FlutterEngineRunTask(FlutterEngine engine,
+                                         const FlutterTask* task);
+
 #if defined(__cplusplus)
 }  // extern "C"
 #endif

embedder/embedder_helper.c

@@ -1,7 +1,7 @@
 
 #include <stdlib.h>
 
-#include "flutter_embedder.h"
+#include "embedder.h"
 
 // C proxy definitions. These are implemented in Go.
 bool proxy_make_current(void *user_data);

embedder/embedder_proxy.go

@@ -1,6 +1,6 @@
 package embedder
 
-// #include "flutter_embedder.h"
+// #include "embedder.h"
 import "C"
 import (
 	"unsafe"

glfw.go

@@ -32,11 +32,6 @@ func newWindowManager() *windowManager {
 	}
 }
 
-// GLFW callbacks to the Flutter Engine
-func (m *windowManager) glfwCursorPosCallback(window *glfw.Window, x, y float64) {
-	m.sendPointerEvent(window, m.pointerPhase, x, y)
-}
-
 func (m *windowManager) sendPointerEvent(window *glfw.Window, phase embedder.PointerPhase, x, y float64) {
 	// synthesize an PointerPhaseAdd if the pointer isn't already added
 	if !m.pointerCurrentlyAdded && phase != embedder.PointerPhaseAdd {
@@ -69,6 +64,24 @@ func (m *windowManager) sendPointerEvent(window *glfw.Window, phase embedder.Poi
 	}
 }
 
+func (m *windowManager) sendPointerEventScroll(window *glfw.Window, xDelta, yDelta float64) {
+	x, y := window.GetCursorPos()
+	event := embedder.PointerEvent{
+		Phase:        m.pointerPhase,
+		X:            x * m.pixelsPerScreenCoordinate,
+		Y:            y * m.pixelsPerScreenCoordinate,
+		Timestamp:    time.Now().UnixNano() / int64(time.Millisecond),
+		SignalKind:   embedder.PointerSignalKindScroll,
+		ScrollDeltaX: xDelta,
+		ScrollDeltaY: yDelta,
+	}
+
+	flutterEnginePointer := *(*uintptr)(window.GetUserPointer())
+	flutterEngine := (*embedder.FlutterEngine)(unsafe.Pointer(flutterEnginePointer))
+
+	flutterEngine.SendPointerEvent(event)
+}
+
 func (m *windowManager) glfwCursorEnterCallback(window *glfw.Window, entered bool) {
 	x, y := window.GetCursorPos()
 	if entered {
@@ -79,6 +92,10 @@ func (m *windowManager) glfwCursorEnterCallback(window *glfw.Window, entered boo
 	}
 }
 
+func (m *windowManager) glfwCursorPosCallback(window *glfw.Window, x, y float64) {
+	m.sendPointerEvent(window, m.pointerPhase, x, y)
+}
+
 func (m *windowManager) glfwMouseButtonCallback(window *glfw.Window, key glfw.MouseButton, action glfw.Action, mods glfw.ModifierKey) {
 	if key == glfw.MouseButton1 {
 		x, y := window.GetCursorPos()
@@ -95,6 +112,11 @@ func (m *windowManager) glfwMouseButtonCallback(window *glfw.Window, key glfw.Mo
 	}
 }
 
+func (m *windowManager) glfwScrollCallback(window *glfw.Window, xoff float64, yoff float64) {
+	const scrollModifier = -50
+	m.sendPointerEventScroll(window, xoff*scrollModifier, yoff*scrollModifier)
+}
+
 // glfwRefreshCallback is called when the window needs a reresh, this
 // can occur when the window is resized, was covered by another window, etc.
 // When forcedPixelratio is zero, the forcedPixelratio communicated to the