bare-pointer 0.1.1 → 0.1.3

package/README.md

@@ -32,7 +32,9 @@ pointer.destroy()
 | Android  | `bare-ndk`     | Motion events dispatched to the root of the view       |
 | Windows  | `bare-win-ui`  | `SendInput()` through `bare-user32`                    |
 
-On Linux and Windows the input goes through the system, so the window of the view has to be the one on top at the point. On macOS, a control tracks the mouse until it is released, so press one with `tap()` rather than `down()`.
+On Linux the input goes through the system, so the window of the view has to be the one on top at the point. On Windows it does too, and a window covered at the point is brought to the foreground first. On macOS, a control tracks the mouse until it is released, so press one with `tap()` rather than `down()`.
+
+On Windows, a press that no element marks as handled can leave windows opened after it without pointer input once one of them has closed. Have something take every press, such as the root of each window.
 
 ## License
 

package/index.js

@@ -14,10 +14,14 @@ module.exports = class Pointer {
   async down(view, x, y) {
     if (this._view !== null) throw new Error('Pointer is already down')
 
-    this._backend.down(view, ...this._point(view, x, y))
+    const point = this._point(view, x, y)
+
+    await this._reach(view, point)
+
+    this._backend.down(view, ...point)
     this._view = view
 
-    await frame(view)
+    await this._frame(view)
   }
 
   async move(view, x, y) {
@@ -25,7 +29,7 @@ module.exports = class Pointer {
 
     this._backend.move(view, ...this._point(view, x, y))
 
-    await frame(view)
+    await this._frame(view)
   }
 
   async up() {
@@ -36,7 +40,7 @@ module.exports = class Pointer {
     this._backend.up()
     this._view = null
 
-    await frame(view)
+    await this._frame(view)
   }
 
   async tap(view, x, y) {
@@ -44,18 +48,20 @@ module.exports = class Pointer {
 
     const point = this._point(view, x, y)
 
+    await this._reach(view, point)
+
     if (this._backend.tap) {
       this._backend.tap(view, ...point)
     } else {
       this._backend.down(view, ...point)
 
       // UIKit controls only see a press that lasts past a frame.
-      await frame(view)
+      await this._frame(view)
 
       this._backend.up()
     }
 
-    await frame(view)
+    await this._frame(view)
   }
 
   destroy() {
@@ -65,6 +71,51 @@ module.exports = class Pointer {
     this._backend.destroy()
   }
 
+  async _reach(view, point) {
+    if (this._backend.covered !== undefined) {
+      for (let frames = 0; this._backend.covered(view, ...point); frames++) {
+        if (frames === 60) throw new Error('The view is covered at the point')
+
+        await this._frame(view)
+      }
+    }
+
+    if (this._backend.hover !== undefined) {
+      this._backend.hover(view, ...point)
+
+      await this._frame(view)
+    }
+  }
+
+  _frame(view) {
+    const provider = new AnimationFrameProvider(view)
+
+    if (this._backend.watch === undefined) return provider.afterAnimationFrame()
+
+    return new Promise((resolve) => {
+      let ended = false
+      let unwatch = null
+
+      const request = provider.afterAnimationFrame(done)
+
+      unwatch = this._backend.watch(view, done)
+
+      if (ended) unwatch()
+
+      function done() {
+        if (ended) return
+
+        ended = true
+
+        request.cancel()
+
+        if (unwatch !== null) unwatch()
+
+        resolve()
+      }
+    })
+  }
+
   _point(view, x, y) {
     if (x !== undefined && y !== undefined) return [x, y]
 
@@ -73,7 +124,3 @@ module.exports = class Pointer {
     return [x === undefined ? width / 2 : x, y === undefined ? height / 2 : y]
   }
 }
-
-function frame(view) {
-  return new AnimationFrameProvider(view).afterAnimationFrame()
-}

package/lib/android.js

@@ -30,8 +30,6 @@ module.exports = class AndroidPointer {
 
   destroy() {}
 
-  // The root is not always at the origin of the window, so the view is placed
-  // by its offset from the root.
   _dispatch(action, view, x, y) {
     const root = view.rootView
     const here = view.locationInWindow

package/lib/darwin.js

@@ -1,3 +1,4 @@
+const AnimationFrameProvider = require('bare-animation-frame')
 const AppKitApplication = require('bare-app-kit/application')
 const AppKitEvent = require('bare-app-kit/event')
 
@@ -15,6 +16,35 @@ module.exports = class DarwinPointer {
     return [width, height]
   }
 
+  covered(view) {
+    const window = view.window
+
+    if (window.keyWindow || !window.canBecomeKeyWindow || !AppKitApplication.active) {
+      return false
+    }
+
+    window.makeKeyAndOrderFront()
+
+    return true
+  }
+
+  watch(view, onhidden) {
+    let request = null
+
+    check()
+
+    function check() {
+      const window = view.window
+
+      if (window === null || !window.visible) onhidden()
+      else request = AnimationFrameProvider.requestAnimationFrame(check)
+    }
+
+    return () => {
+      if (request !== null) request.cancel()
+    }
+  }
+
   down(view, x, y) {
     this._send(TYPE.LEFT_MOUSE_DOWN, view, x, y)
   }
@@ -27,9 +57,6 @@ module.exports = class DarwinPointer {
     this._window.sendEvent(this._event(TYPE.LEFT_MOUSE_UP, this._window, this._point))
   }
 
-  // A control tracks the mouse by reading the event queue until it is released,
-  // and a press that could start a double click is held back until the event
-  // after it, so both have to go through the queue in order.
   tap(view, x, y) {
     const window = view.window
     const point = view.convertPointToView(x, y, null)

package/lib/linux.js

@@ -10,6 +10,20 @@ module.exports = class LinuxPointer {
     return [view.width, view.height]
   }
 
+  watch(view, onhidden) {
+    const window = view.native
+
+    if (window === null || !window.visible) {
+      onhidden()
+
+      return () => {}
+    }
+
+    window.on('hide', onhidden)
+
+    return () => window.off('hide', onhidden)
+  }
+
   down(view, x, y) {
     this._move(view, x, y)
 
@@ -40,9 +54,6 @@ module.exports = class LinuxPointer {
     xtest.fakeMotionEvent(this._display, xtest.CURRENT_SCREEN, point.x, point.y)
   }
 
-  // A point in the widget becomes one in its native, then in the surface of
-  // that, which is drawn in device pixels on an X11 window that the server can
-  // place on the root.
   _point(view, x, y) {
     const native = view.native
     const surface = native.surface

package/lib/win32.js

@@ -2,6 +2,7 @@ const Win32Interop = require('bare-win-ui/win32-interop')
 const user32 = require('bare-user32')
 
 const {
+  GA_ROOT,
   SM_XVIRTUALSCREEN,
   SM_YVIRTUALSCREEN,
   SM_CXVIRTUALSCREEN,
@@ -15,47 +16,53 @@ const {
 } = user32.constants
 
 module.exports = class Win32Pointer {
-  constructor() {
-    this._point = null
-  }
-
   size(view) {
     return [view.actualWidth, view.actualHeight]
   }
 
-  down(view, x, y) {
-    this._point = locate(view, x, y)
-    this._send(MOUSEEVENTF_LEFTDOWN)
+  covered(view, x, y) {
+    const { window, screen } = locate(view, x, y)
+    const top = user32.windowFromPoint(screen.x, screen.y)
+
+    if (top !== null && user32.getAncestor(top, GA_ROOT) === window) return false
+
+    user32.setForegroundWindow(window)
+
+    return true
+  }
+
+  hover(view, x, y) {
+    this._move(view, x, y)
+  }
+
+  down() {
+    this._send({ flags: MOUSEEVENTF_LEFTDOWN })
   }
 
   move(view, x, y) {
-    this._point = locate(view, x, y)
-    this._send(0)
+    this._move(view, x, y)
   }
 
   up() {
-    this._send(MOUSEEVENTF_LEFTUP)
+    this._send({ flags: MOUSEEVENTF_LEFTUP })
   }
 
   destroy() {}
 
-  _send(flags) {
-    const sent = user32.sendInput([
-      {
-        type: INPUT_MOUSE,
-        mi: {
-          ...this._point,
-          flags: flags | MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_VIRTUALDESK
-        }
-      }
-    ])
+  _move(view, x, y) {
+    this._send({
+      ...normalize(locate(view, x, y).screen),
+      flags: MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_VIRTUALDESK
+    })
+  }
+
+  _send(mi) {
+    const sent = user32.sendInput([{ type: INPUT_MOUSE, mi }])
 
     if (sent === 0) throw new Error('Input was blocked')
   }
 }
 
-// An element is placed in DIPs from the XAML root, which fills the client area
-// of its window. Absolute input divides the virtual screen into 65536 steps.
 function locate(view, x, y) {
   const root = view.xamlRoot
   const scale = root.rasterizationScale
@@ -68,13 +75,17 @@ function locate(view, x, y) {
     Math.round(point.y * scale)
   )
 
+  return { window, screen }
+}
+
+function normalize(screen) {
   const left = user32.getSystemMetrics(SM_XVIRTUALSCREEN)
   const top = user32.getSystemMetrics(SM_YVIRTUALSCREEN)
   const width = user32.getSystemMetrics(SM_CXVIRTUALSCREEN)
   const height = user32.getSystemMetrics(SM_CYVIRTUALSCREEN)
 
   return {
-    dx: Math.round(((screen.x - left) * 65536) / width),
-    dy: Math.round(((screen.y - top) * 65536) / height)
+    dx: Math.round(((screen.x - left + 0.5) * 65536) / width),
+    dy: Math.round(((screen.y - top + 0.5) * 65536) / height)
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-pointer",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Simulated pointer input for testing Bare apps",
   "exports": {
     "./package": "./package.json",
@@ -51,13 +51,13 @@
     "bare-app-kit": "^0.3.1",
     "bare-ndk": "^0.3.4",
     "bare-ui-kit-touch": "^0.1.0",
-    "bare-user32": "^0.1.0",
+    "bare-user32": "^0.1.1",
     "bare-win-ui": "^0.3.7",
     "bare-x11": "^0.1.0",
     "bare-x11-xtest": "^0.1.0"
   },
   "devDependencies": {
-    "bare-gtk": "^0.4.1",
+    "bare-gtk": "^0.4.2",
     "bare-native-test": "^0.1.3",
     "bare-tap": "^1.1.0",
     "bare-ui-kit": "^0.3.1",