Merge branch 'zephylac-feature/mouse_support'

Author: GeertJohan

README.md

@@ -49,6 +49,7 @@ It's also possible to [manually install](https://github.com/go-flutter-desktop/g
   - <kbd>Right</kbd>  <kbd>ctrl-Right</kbd>  <kbd>ctrl-shift-Right</kbd>
   - <kbd>Backspace</kbd>  <kbd>ctrl-Backspace</kbd> <kbd>Delete</kbd>
 - Mouse-over/hovering
+- Mouse-buttons
 - RawKeyboard events (through `RawKeyEventDataLinux` regardless of the platform)
 
 Are you missing a feature? [Open an issue!](https://github.com/go-flutter-desktop/go-flutter/issues/new)

embedder/embedder.go

@@ -143,6 +143,16 @@ const (
 	PointerPhaseHover  PointerPhase = C.kHover
 )
 
+// PointerButtonMouse corresponds to the C.enum describing the mouse buttons.
+type PointerButtonMouse int64
+
+// Values representing the mouse buttons.
+const (
+	PointerButtonMousePrimary   PointerButtonMouse = C.kFlutterPointerButtonMousePrimary
+	PointerButtonMouseSecondary PointerButtonMouse = C.kFlutterPointerButtonMouseSecondary
+	PointerButtonMouseMiddle    PointerButtonMouse = C.kFlutterPointerButtonMouseMiddle
+)
+
 // PointerSignalKind corresponds to the C.enum describing signal kind of the mouse pointer.
 type PointerSignalKind int32
 
@@ -152,6 +162,15 @@ const (
 	PointerSignalKindScroll PointerSignalKind = C.kFlutterPointerSignalKindScroll
 )
 
+// PointerDeviceKind corresponds to the C.enum describing device kind of the mouse pointer.
+type PointerDeviceKind int32
+
+// Values representing the pointer signal kind.
+const (
+	PointerDeviceKindMouse PointerDeviceKind = C.kFlutterPointerDeviceKindMouse
+	PointerDeviceKindTouch PointerDeviceKind = C.kFlutterPointerDeviceKindTouch
+)
+
 // PointerEvent represents the position and phase of the mouse at a given time.
 type PointerEvent struct {
 	Phase        PointerPhase
@@ -161,6 +180,7 @@ type PointerEvent struct {
 	SignalKind   PointerSignalKind
 	ScrollDeltaX float64
 	ScrollDeltaY float64
+	Buttons      PointerButtonMouse
 }
 
 // SendPointerEvent is used to send an PointerEvent to the Flutter engine.
@@ -171,8 +191,10 @@ func (flu *FlutterEngine) SendPointerEvent(event PointerEvent) Result {
 		y:              C.double(event.Y),
 		timestamp:      C.size_t(event.Timestamp),
 		signal_kind:    (C.FlutterPointerSignalKind)(event.SignalKind),
+		device_kind:    (C.FlutterPointerDeviceKind)(PointerDeviceKindMouse),
 		scroll_delta_x: C.double(event.ScrollDeltaX),
 		scroll_delta_y: C.double(event.ScrollDeltaY),
+		buttons:        C.int64_t(event.Buttons),
 	}
 	cPointerEvent.struct_size = C.size_t(unsafe.Sizeof(cPointerEvent))
 

embedder/embedder.h

@@ -280,14 +280,57 @@ typedef struct {
 // The phase of the pointer event.
 typedef enum {
   kCancel,
+  // The pointer, which must have been down (see kDown), is now up.
+  //
+  // For touch, this means that the pointer is no longer in contact with the
+  // screen. For a mouse, it means the last button was released. Note that if
+  // any other buttons are still pressed when one button is released, that
+  // should be sent as a kMove rather than a kUp.
   kUp,
+  // The pointer, which must have been been up, is now down.
+  //
+  // For touch, this means that the pointer has come into contact with the
+  // screen. For a mouse, it means a button is now pressed. Note that if any
+  // other buttons are already pressed when a new button is pressed, that should
+  // be sent as a kMove rather than a kDown.
   kDown,
+  // The pointer moved while down.
+  //
+  // This is also used for changes in button state that don't cause a kDown or
+  // kUp, such as releasing one of two pressed buttons.
   kMove,
+  // The pointer is now sending input to Flutter. For instance, a mouse has
+  // entered the area where the Flutter content is displayed.
+  //
+  // A pointer should always be added before sending any other events.
   kAdd,
+  // The pointer is no longer sending input to Flutter. For instance, a mouse
+  // has left the area where the Flutter content is displayed.
+  //
+  // A removed pointer should no longer send events until sending a new kAdd.
   kRemove,
+  // The pointer moved while up.
   kHover,
 } FlutterPointerPhase;
 
+// The device type that created a pointer event.
+typedef enum {
+  kFlutterPointerDeviceKindMouse = 1,
+  kFlutterPointerDeviceKindTouch,
+} FlutterPointerDeviceKind;
+
+// Flags for the |buttons| field of |FlutterPointerEvent| when |device_kind|
+// is |kFlutterPointerDeviceKindMouse|.
+typedef enum {
+  kFlutterPointerButtonMousePrimary = 1 << 0,
+  kFlutterPointerButtonMouseSecondary = 1 << 1,
+  kFlutterPointerButtonMouseMiddle = 1 << 2,
+  kFlutterPointerButtonMouseBack = 1 << 3,
+  kFlutterPointerButtonMouseForward = 1 << 4,
+  // If a mouse has more than five buttons, send higher bit shifted values
+  // corresponding to the button number: 1 << 5 for the 6th, etc.
+} FlutterPointerMouseButtons;
+
 // The type of a pointer signal.
 typedef enum {
   kFlutterPointerSignalKindNone,
@@ -307,6 +350,14 @@ typedef struct {
   FlutterPointerSignalKind signal_kind;
   double scroll_delta_x;
   double scroll_delta_y;
+  // The type of the device generating this event.
+  // Backwards compatibility note: If this is not set, the device will be
+  // treated as a mouse, with the primary button set for |kDown| and |kMove|.
+  // If set explicitly to |kFlutterPointerDeviceKindMouse|, you must set the
+  // correct buttons.
+  FlutterPointerDeviceKind device_kind;
+  // The buttons currently pressed, if any.
+  int64_t buttons;
 } FlutterPointerEvent;
 
 struct _FlutterPlatformMessageResponseHandle;
@@ -322,11 +373,10 @@ typedef struct {
   // The response handle on which to invoke
   // |FlutterEngineSendPlatformMessageResponse| when the response is ready. This
   // field is ignored for messages being sent from the embedder to the
-  // framework. If the embedder ever receives a message with a non-null response
-  // handle, that handle must always be used with a
-  // |FlutterEngineSendPlatformMessageResponse| call. If not, this is a memory
-  // leak. It is not safe to send multiple responses on a single response
-  // object.
+  // framework. |FlutterEngineSendPlatformMessageResponse| must be called for
+  // all messages received by the embedder. Failure to call
+  // |FlutterEngineSendPlatformMessageResponse| will cause a memory leak. It is
+  // not safe to send multiple responses on a single response object.
   const FlutterPlatformMessageResponseHandle* response_handle;
 } FlutterPlatformMessage;
 
@@ -432,7 +482,7 @@ typedef struct {
   size_t struct_size;
   // The unique custom action or action override ID.
   int32_t id;
-  // For overriden standard actions, corresponds to the
+  // For overridden standard actions, corresponds to the
   // |FlutterSemanticsAction| to override.
   FlutterSemanticsAction override_action;
   // The user-readable name of this custom semantics action.
@@ -785,4 +835,4 @@ FlutterEngineResult FlutterEngineRunTask(FlutterEngine engine,
 }  // extern "C"
 #endif
 
-#endif  // FLUTTER_EMBEDDER_H_
+#endif  // FLUTTER_EMBEDDER_H_

glfw.go

@@ -24,6 +24,7 @@ type windowManager struct {
 	pointerPhase              embedder.PointerPhase
 	pixelsPerScreenCoordinate float64
 	pointerCurrentlyAdded     bool
+	pointerButton             embedder.PointerButtonMouse
 }
 
 func newWindowManager() *windowManager {
@@ -51,6 +52,7 @@ func (m *windowManager) sendPointerEvent(window *glfw.Window, phase embedder.Poi
 		X:         x * m.pixelsPerScreenCoordinate,
 		Y:         y * m.pixelsPerScreenCoordinate,
 		Timestamp: time.Now().UnixNano() / int64(time.Millisecond),
+		Buttons:   m.pointerButton,
 	}
 
 	flutterEnginePointer := *(*uintptr)(window.GetUserPointer())
@@ -65,6 +67,21 @@ func (m *windowManager) sendPointerEvent(window *glfw.Window, phase embedder.Poi
 	}
 }
 
+func (m *windowManager) sendPointerEventButton(window *glfw.Window, phase embedder.PointerPhase) {
+	x, y := window.GetCursorPos()
+	event := embedder.PointerEvent{
+		Phase:      phase,
+		X:          x * m.pixelsPerScreenCoordinate,
+		Y:          y * m.pixelsPerScreenCoordinate,
+		Timestamp:  time.Now().UnixNano() / int64(time.Millisecond),
+		SignalKind: embedder.PointerSignalKindNone,
+		Buttons:    m.pointerButton,
+	}
+	flutterEnginePointer := *(*uintptr)(window.GetUserPointer())
+	flutterEngine := (*embedder.FlutterEngine)(unsafe.Pointer(flutterEnginePointer))
+	flutterEngine.SendPointerEvent(event)
+}
+
 func (m *windowManager) sendPointerEventScroll(window *glfw.Window, xDelta, yDelta float64) {
 	x, y := window.GetCursorPos()
 	event := embedder.PointerEvent{
@@ -75,6 +92,7 @@ func (m *windowManager) sendPointerEventScroll(window *glfw.Window, xDelta, yDel
 		SignalKind:   embedder.PointerSignalKindScroll,
 		ScrollDeltaX: xDelta,
 		ScrollDeltaY: yDelta,
+		Buttons:      m.pointerButton,
 	}
 
 	flutterEnginePointer := *(*uintptr)(window.GetUserPointer())
@@ -97,22 +115,48 @@ 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()
-
-		if action == glfw.Press {
-			m.sendPointerEvent(window, embedder.PointerPhaseDown, x, y)
-			m.pointerPhase = embedder.PointerPhaseMove
+func (m *windowManager) handleButtonPhase(window *glfw.Window, action glfw.Action, buttons embedder.PointerButtonMouse) {
+	if action == glfw.Press {
+		m.pointerButton |= buttons
+		// If only one button is pressed then each bits of buttons will be equals
+		// to m.pointerButton.
+		if m.pointerButton == buttons {
+			m.sendPointerEventButton(window, embedder.PointerPhaseDown)
+		} else {
+			// if any other buttons are already pressed when a new button is pressed,
+			// the engine is expecting a Move phase instead of a Down phase.
+			m.sendPointerEventButton(window, embedder.PointerPhaseMove)
 		}
+		m.pointerPhase = embedder.PointerPhaseMove
+	}
 
-		if action == glfw.Release {
-			m.sendPointerEvent(window, embedder.PointerPhaseUp, x, y)
+	if action == glfw.Release {
+		m.pointerButton ^= buttons
+		// If all button are released then m.pointerButton is cleared
+		if m.pointerButton == 0 {
+			m.sendPointerEventButton(window, embedder.PointerPhaseUp)
 			m.pointerPhase = embedder.PointerPhaseHover
+		} else {
+			// if any other buttons are still pressed when one button is released
+			// the engine is expecting a Move phase instead of a Up phase.
+			m.sendPointerEventButton(window, embedder.PointerPhaseMove)
 		}
 	}
 }
 
+func (m *windowManager) glfwMouseButtonCallback(window *glfw.Window, key glfw.MouseButton, action glfw.Action, mods glfw.ModifierKey) {
+	switch key {
+	case glfw.MouseButtonLeft:
+		m.handleButtonPhase(window, action, embedder.PointerButtonMousePrimary)
+	case glfw.MouseButtonRight:
+		m.handleButtonPhase(window, action, embedder.PointerButtonMouseSecondary)
+	case glfw.MouseButtonMiddle:
+		m.handleButtonPhase(window, action, embedder.PointerButtonMouseMiddle)
+	default:
+		m.handleButtonPhase(window, action, 1<<uint(key))
+	}
+}
+
 func (m *windowManager) glfwScrollCallback(window *glfw.Window, xoff float64, yoff float64) {
 	const scrollModifier = -50
 	m.sendPointerEventScroll(window, xoff*scrollModifier, yoff*scrollModifier)