@atom-js-org/runtime 0.5.3-alpha.2 → 0.5.3-alpha.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atom-js-org/runtime",
-  "version": "0.5.3-alpha.2",
+  "version": "0.5.3-alpha.4",
   "description": "Electron-like desktop runtime powered by the operating system WebView.",
   "main": "src/index.cjs",
   "types": "index.d.ts",
@@ -23,7 +23,8 @@
   },
   "dependencies": {
     "ws": "^8.21.1",
-    "@webviewjs/webview": "0.4.0"
+    "@webviewjs/webview": "0.4.0",
+    "koffi": "3.1.2"
   },
   "repository": {
     "type": "git",

package/src/windows-native-drag.cjs

@@ -0,0 +1,126 @@
+'use strict';
+
+const WM_NCLBUTTONDOWN = 0x00A1;
+const HTCAPTION = 2;
+const VK_LBUTTON = 0x01;
+const SM_CXDOUBLECLK = 36;
+const SM_CYDOUBLECLK = 37;
+
+let singleton = null;
+let warned = false;
+
+class WindowsNativeDragApi {
+  constructor(koffi) {
+    if (!koffi || typeof koffi.load !== 'function') {
+      throw new TypeError('A Koffi module is required.');
+    }
+
+    const user32 = koffi.load('user32.dll');
+    const pointType = koffi.struct('ATOMJS_WIN32_POINT', { x: 'long', y: 'long' });
+    this.releaseCapture = user32.func('__stdcall', 'ReleaseCapture', 'bool', []);
+    this.postMessageW = user32.func(
+      '__stdcall',
+      'PostMessageW',
+      'bool',
+      ['void *', 'uint32_t', 'uintptr_t', 'intptr_t']
+    );
+    this.getAsyncKeyState = user32.func('__stdcall', 'GetAsyncKeyState', 'int16_t', ['int']);
+    this.getCursorPos = user32.func('__stdcall', 'GetCursorPos', 'bool', [koffi.out(koffi.pointer(pointType))]);
+    this.getDoubleClickTime = user32.func('__stdcall', 'GetDoubleClickTime', 'uint32_t', []);
+    this.getSystemMetrics = user32.func('__stdcall', 'GetSystemMetrics', 'int', ['int']);
+  }
+
+  isLeftButtonDown() {
+    return (Number(this.getAsyncKeyState(VK_LBUTTON)) & 0x8000) !== 0;
+  }
+
+  doubleClickSettings() {
+    return {
+      time: positiveInteger(this.getDoubleClickTime(), 500),
+      width: positiveInteger(this.getSystemMetrics(SM_CXDOUBLECLK), 4),
+      height: positiveInteger(this.getSystemMetrics(SM_CYDOUBLECLK), 4)
+    };
+  }
+
+  startWindowDrag(nativeWindow) {
+    const handle = nativeWindowHandle(nativeWindow);
+    if (handle === 0n || !this.isLeftButtonDown()) return false;
+
+    // Queue the standard non-client title-bar press and return immediately.
+    // PostMessageW is important here: SendMessageW blocks Node while Windows runs
+    // its modal move loop, which causes frozen rendering and erratic input. Tao's
+    // own Window::drag_window() follows the same asynchronous Win32 path.
+    const cursor = {};
+    const cursorPosition = this.getCursorPos(cursor) ? packScreenPoint(cursor.x, cursor.y) : 0n;
+
+    this.releaseCapture();
+    return Boolean(this.postMessageW(handle, WM_NCLBUTTONDOWN, HTCAPTION, cursorPosition));
+  }
+}
+
+
+function packScreenPoint(x, y) {
+  const xWord = BigInt.asUintN(16, BigInt(Math.trunc(Number(x) || 0)));
+  const yWord = BigInt.asUintN(16, BigInt(Math.trunc(Number(y) || 0)));
+  return BigInt.asIntN(32, xWord | (yWord << 16n));
+}
+
+function nativeWindowHandle(nativeWindow) {
+  if (!nativeWindow) return 0n;
+
+  let value = 0n;
+  try {
+    if (typeof nativeWindow.getNativeHandleAnyThread === 'function') {
+      value = nativeWindow.getNativeHandleAnyThread();
+    } else if (typeof nativeWindow.getNativeHandle === 'function') {
+      value = nativeWindow.getNativeHandle();
+    }
+  } catch {
+    return 0n;
+  }
+
+  try {
+    return BigInt(value || 0);
+  } catch {
+    return 0n;
+  }
+}
+
+function positiveInteger(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? Math.round(number) : fallback;
+}
+
+function getWindowsNativeDragApi() {
+  if (process.platform !== 'win32') return null;
+  if (singleton) return singleton;
+
+  try {
+    singleton = new WindowsNativeDragApi(require('koffi'));
+    return singleton;
+  } catch (error) {
+    if (!warned) {
+      warned = true;
+      console.warn([
+        '[AtomJS] Native Windows window dragging could not be initialized.',
+        'Run npm install so the prebuilt koffi Windows package is present.',
+        error && error.message ? error.message : String(error)
+      ].join('\n'));
+    }
+    return null;
+  }
+}
+
+module.exports = {
+  WindowsNativeDragApi,
+  getWindowsNativeDragApi,
+  nativeWindowHandle,
+  packScreenPoint,
+  constants: {
+    WM_NCLBUTTONDOWN,
+    HTCAPTION,
+    VK_LBUTTON,
+    SM_CXDOUBLECLK,
+    SM_CYDOUBLECLK
+  }
+};

package/src/windows-native-host.cjs

@@ -3,6 +3,7 @@
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
+const { getWindowsNativeDragApi } = require('./windows-native-drag.cjs');
 
 let singleton = null;
 
@@ -114,6 +115,7 @@ class WindowsNativeHost {
     });
 
     const record = {
+      windowId: Number(config.windowId),
       atomWindow,
       nativeWindow,
       webview,
@@ -122,9 +124,8 @@ class WindowsNativeHost {
         width: positive(config.width, 800),
         height: positive(config.height, 600)
       },
-      lastCursorPhysical: null,
-      dragState: null,
-      lastDragClick: null
+      lastDragClick: null,
+      nativeDragPending: false
     };
     this.windows.set(Number(config.windowId), record);
     this._attachEvents(Number(config.windowId), record);
@@ -144,11 +145,12 @@ class WindowsNativeHost {
       this.windows.delete(windowId);
     });
     record.nativeWindow.on('focus', () => emit({ type: 'focus' }));
-    record.nativeWindow.on('blur', () => {
-      record.dragState = null;
-      emit({ type: 'blur' });
-    });
+    record.nativeWindow.on('blur', () => emit({ type: 'blur' }));
     record.nativeWindow.on('move', (event) => {
+      if (record.nativeDragPending) {
+        record.nativeDragPending = false;
+        record.lastDragClick = null;
+      }
       const scale = safeScaleFactor(record.nativeWindow);
       emit({
         type: 'bounds-changed',
@@ -164,60 +166,37 @@ class WindowsNativeHost {
         bounds: { width: Number(event.width) / scale, height: Number(event.height) / scale }
       });
     });
-    record.nativeWindow.on('mouse-move', (event) => {
-      const point = physicalPoint(event);
-      if (!point) return;
-      record.lastCursorPhysical = point;
-      if (record.dragState) this._continueWindowDrag(record, point);
-    });
     record.nativeWindow.on('mouse-down', (event) => {
       if (Number(event.button) !== 0) return;
       const point = physicalPoint(event);
-      if (!point) return;
-      record.lastCursorPhysical = point;
-      if (!isDraggablePoint(record, point)) return;
-
-      const now = Date.now();
-      const previous = record.lastDragClick;
-      record.lastDragClick = { time: now, x: point.x, y: point.y };
-      if (previous && now - previous.time <= 450 && distanceSquared(previous, point) <= 64) {
-        record.dragState = null;
-        record.lastDragClick = null;
-        try { record.nativeWindow.setMaximized(!record.nativeWindow.isMaximized()); } catch {}
-        return;
-      }
-
-      this._beginWindowDrag(record, point);
+      if (!point || !isDraggablePoint(record, point)) return;
+      this._startNativeWindowDrag(record, point);
     });
     record.nativeWindow.on('mouse-up', (event) => {
-      if (Number(event.button) === 0) record.dragState = null;
+      if (Number(event.button) === 0) record.nativeDragPending = false;
     });
     record.webview.on('page-load-started', (event) => emit({ type: 'did-start-loading', url: event.url || '' }));
     record.webview.on('page-load-finished', (event) => emit({ type: 'did-finish-load', url: event.url || '' }));
     record.webview.on('title-changed', (event) => emit({ type: 'page-title-updated', title: event.title || '' }));
   }
 
-  _beginWindowDrag(record, point) {
-    if (!point) return false;
-    record.dragState = { offsetX: point.x, offsetY: point.y };
-    return true;
-  }
+  _startNativeWindowDrag(record, point = null) {
+    const nativeDrag = getWindowsNativeDragApi();
+    if (!nativeDrag) return false;
 
-  _continueWindowDrag(record, point) {
-    const state = record.dragState;
-    if (!state) return;
-    try {
-      const current = record.nativeWindow.getPosition(false);
-      const globalX = Number(current.x) + point.x;
-      const globalY = Number(current.y) + point.y;
-      record.nativeWindow.setPosition(
-        Math.round(globalX - state.offsetX),
-        Math.round(globalY - state.offsetY),
-        false
-      );
-    } catch {
-      record.dragState = null;
+    if (point && isSystemDoubleClick(record, point, nativeDrag.doubleClickSettings())) {
+      record.lastDragClick = null;
+      try { record.nativeWindow.setMaximized(!record.nativeWindow.isMaximized()); } catch {}
+      return true;
     }
+
+    const started = nativeDrag.startWindowDrag(record.nativeWindow);
+    if (!started) return false;
+
+    // The Win32 move loop is queued asynchronously. Native move events keep the
+    // BrowserWindow bounds synchronized while Windows owns the pointer.
+    record.nativeDragPending = true;
+    return true;
   }
 
   send(message) {
@@ -256,7 +235,7 @@ class WindowsNativeHost {
         record.dragViewport = normalizeViewport(message.viewport, win);
         return true;
       case 'start-drag':
-        return this._beginWindowDrag(record, record.lastCursorPhysical);
+        return this._startNativeWindowDrag(record);
       case 'set-bounds': {
         const bounds = message.bounds || {};
         if (Number.isFinite(Number(bounds.width)) && Number.isFinite(Number(bounds.height))) {
@@ -363,12 +342,20 @@ function isDraggablePoint(record, physical) {
   return draggable;
 }
 
-function distanceSquared(a, b) {
-  const dx = Number(a.x) - Number(b.x);
-  const dy = Number(a.y) - Number(b.y);
-  return (dx * dx) + (dy * dy);
+function isSystemDoubleClick(record, point, settings) {
+  const now = Date.now();
+  const previous = record.lastDragClick;
+  record.lastDragClick = { time: now, x: point.x, y: point.y };
+  if (!previous) return false;
+
+  const halfWidth = Math.max(1, Number(settings && settings.width) / 2);
+  const halfHeight = Math.max(1, Number(settings && settings.height) / 2);
+  return now - previous.time <= Number(settings && settings.time || 500) &&
+    Math.abs(Number(previous.x) - Number(point.x)) <= halfWidth &&
+    Math.abs(Number(previous.y) - Number(point.y)) <= halfHeight;
 }
 
+
 function resolveWritableWebViewDataDirectory() {
   const identity = sanitizePathSegment(
     process.env.ATOM_APP_ID || process.env.ATOM_APP_NAME || 'AtomJS.App'
@@ -422,5 +409,6 @@ module.exports = {
   stopWindowsNativeHost,
   isDraggablePoint,
   normalizeDragRegions,
-  resolveWritableWebViewDataDirectory
+  resolveWritableWebViewDataDirectory,
+  isSystemDoubleClick
 };