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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atom-js-org/runtime",
-  "version": "0.5.3-alpha.2",
+  "version": "0.5.3-alpha.3",
   "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.sendMessageW = user32.func(
+      '__stdcall',
+      'SendMessageW',
+      'intptr_t',
+      ['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;
+
+    // Hand control to DefWindowProc instead of moving the window from JavaScript.
+    // This enters Windows' normal move loop, including snapping, monitor/DPI
+    // transitions and maximized-window restore behavior.
+    const cursor = {};
+    const cursorPosition = this.getCursorPos(cursor) ? packScreenPoint(cursor.x, cursor.y) : 0n;
+
+    this.releaseCapture();
+    this.sendMessageW(handle, WM_NCLBUTTONDOWN, HTCAPTION, cursorPosition);
+    return true;
+  }
+}
+
+
+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,8 +124,6 @@ class WindowsNativeHost {
         width: positive(config.width, 800),
         height: positive(config.height, 600)
       },
-      lastCursorPhysical: null,
-      dragState: null,
       lastDragClick: null
     };
     this.windows.set(Number(config.windowId), record);
@@ -144,10 +144,7 @@ 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) => {
       const scale = safeScaleFactor(record.nativeWindow);
       emit({
@@ -164,60 +161,39 @@ 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);
-    });
-    record.nativeWindow.on('mouse-up', (event) => {
-      if (Number(event.button) === 0) record.dragState = null;
+      if (!point || !isDraggablePoint(record, point)) return;
+      this._startNativeWindowDrag(record, point);
     });
     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 before = readPhysicalWindowPosition(record.nativeWindow);
+    const started = nativeDrag.startWindowDrag(record.nativeWindow);
+    if (!started) return false;
+
+    // SendMessageW returns when the native move loop ends. A real movement must
+    // not become the first half of a later title-bar double click.
+    const after = readPhysicalWindowPosition(record.nativeWindow);
+    if (!samePhysicalPosition(before, after)) {
+      record.lastDragClick = null;
+      emitFinalWindowBounds(record);
     }
+    return true;
   }
 
   send(message) {
@@ -256,7 +232,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,10 +339,54 @@ 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 readPhysicalWindowPosition(win) {
+  try {
+    const position = win.getPosition(false);
+    const x = Number(position && position.x);
+    const y = Number(position && position.y);
+    return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : null;
+  } catch {
+    return null;
+  }
+}
+
+
+function emitFinalWindowBounds(record) {
+  try {
+    const win = record.nativeWindow;
+    const scale = safeScaleFactor(win);
+    const position = win.getPosition(false);
+    const size = win.getInnerSize(true);
+    record.atomWindow._handleHostEvent({
+      type: 'bounds-changed',
+      reason: 'move',
+      windowId: record.windowId,
+      bounds: {
+        x: Number(position.x) / scale,
+        y: Number(position.y) / scale,
+        width: Number(size.width),
+        height: Number(size.height)
+      }
+    });
+  } catch {}
+}
+
+function samePhysicalPosition(a, b) {
+  if (!a || !b) return true;
+  return Math.abs(a.x - b.x) <= 1 && Math.abs(a.y - b.y) <= 1;
 }
 
 function resolveWritableWebViewDataDirectory() {
@@ -422,5 +442,8 @@ module.exports = {
   stopWindowsNativeHost,
   isDraggablePoint,
   normalizeDragRegions,
-  resolveWritableWebViewDataDirectory
+  resolveWritableWebViewDataDirectory,
+  isSystemDoubleClick,
+  emitFinalWindowBounds,
+  samePhysicalPosition
 };