Retrieve window dimensions

.travis.yml

@@ -38,9 +38,10 @@ script:
   - npm run patch && npm i
   - if [[ $TRAVIS_OS_NAME = "windows" ]]; then npm run build:release:win; else npm run build:release; fi
   - cd test
-  - npm ci
-  - npm test
-  - cd ..
+  - npm cit
+  - cd window-integration-tests
+  - npm cit
+  - cd ../..
 
 before_deploy:
   - echo "//registry.npmjs.org/:_authToken=\${NPM_TOKEN}" >> $HOME/.npmrc 2> /dev/null

CMakeLists.txt

@@ -6,11 +6,11 @@ project(libnut)
 # Source
 set(SOURCE_FILES "src/main.cc" "src/deadbeef_rand.c" "src/keycode.c" "src/keypress.c" "src/MMBitmap.c" "src/mouse.c" "src/screen.c" "src/screengrab.c")
 if (UNIX AND NOT APPLE)
-    set(SOURCE_FILES "${SOURCE_FILES}" "src/linux/xdisplay.c" "src/linux/highlightwindow.c")
+    set(SOURCE_FILES "${SOURCE_FILES}" "src/linux/xdisplay.c" "src/linux/highlightwindow.c" "src/linux/window_manager.cc")
 elseif (UNIX AND APPLE)
-    set(SOURCE_FILES "${SOURCE_FILES}" "src/macos/highlightwindow.m")
+    set(SOURCE_FILES "${SOURCE_FILES}" "src/macos/highlightwindow.m" "src/macos/window_manager.mm")
 elseif (WIN32)
-    set(SOURCE_FILES "${SOURCE_FILES}" "src/win32/highlightwindow.c")
+    set(SOURCE_FILES "${SOURCE_FILES}" "src/win32/highlightwindow.c" "src/win32/window_manager.cc")
 endif()
 add_library(${PROJECT_NAME} SHARED ${SOURCE_FILES} ${CMAKE_JS_SRC})
 

appveyor.yml

@@ -33,10 +33,11 @@ test_script:
   - npm --version
   # run tests
   - cd test
-  - npm ci
-  - npm test test
-  - npm test run test:it
-  - cd ..
+  - npm cit
+  - npm run test:it
+  - cd window-integration-tests
+  - npm cit
+  - cd ../..
 
 on_success:
   - IF defined APPVEYOR_REPO_TAG_NAME npm publish

index.d.ts

@@ -12,6 +12,23 @@ export interface Screen {
   highlight(x: number, y: number, width: number, height: number, duration: number, opacity: number): void;
 }
 
+export interface Point {
+  x: number;
+  y: number
+}
+
+export interface Size {
+  width: number;
+  height: number;
+}
+
+export interface Rect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
 export function setKeyboardDelay(ms: number): void;
 export function keyTap(key: string, modifier?: string | string[]): void;
 export function keyToggle(
@@ -28,7 +45,11 @@ export function mouseClick(button?: string, double?: boolean): void;
 export function mouseToggle(down?: string, button?: string): void;
 export function dragMouse(x: number, y: number): void;
 export function scrollMouse(x: number, y: number): void;
-export function getMousePos(): { x: number; y: number };
-export function getScreenSize(): { width: number; height: number };
+export function getMousePos(): Point;
+export function getScreenSize(): Size;
+export function getWindows(): number[];
+export function getActiveWindow(): number;
+export function getWindowRect(handle: number): Rect;
+export function getWindowTitle(handle: number): string;
 
 export const screen: Screen;

src/linux/window_manager.cc

@@ -0,0 +1,65 @@
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include "../window_manager.h"
+extern "C" {
+    #include "../xdisplay.h"
+}
+
+WindowHandle getActiveWindow() {
+    Display* xServer = XGetMainDisplay();
+    Window window;
+    if (xServer != NULL) {
+        int32_t revertToWindow;
+        XGetInputFocus(xServer, &window, &revertToWindow);
+        return window;
+    }
+    return -1;
+}
+
+std::vector<WindowHandle> getWindows() {
+    Display* xServer = XGetMainDisplay();
+    std::vector<WindowHandle> windowHandles;
+    if (xServer != NULL) {
+        Window defaultRootWindow = DefaultRootWindow(xServer);
+        Window rootWindow;
+        Window parentWindow;
+        Window* windowList;
+        uint32_t windowCount;
+
+        Status queryTreeResult = XQueryTree(xServer, defaultRootWindow, &rootWindow, &parentWindow, &windowList, &windowCount);
+        if (queryTreeResult > 0) {
+            for (size_t idx = 0; idx < windowCount; ++idx) {
+                windowHandles.push_back(windowList[idx]);
+            }
+        }
+    }
+    return windowHandles;
+}
+
+std::string getWindowTitle(const WindowHandle windowHandle) {
+    Display* xServer = XGetMainDisplay();
+    std::string windowName = "";
+    if (xServer != NULL) {
+        XTextProperty windowTextProperty;
+        Status getWMNameResult = XGetWMName(xServer, windowHandle, &windowTextProperty);
+        if (getWMNameResult > 0) {
+            windowName = std::string(reinterpret_cast<const char*>(windowTextProperty.value));
+        }
+    }
+    return windowName;
+}
+
+MMRect getWindowRect(const WindowHandle windowHandle) {
+    Display* xServer = XGetMainDisplay();
+    MMRect windowRect = MMRectMake(0, 0, 0, 0);
+    if (xServer != NULL) {
+        Window rootWindow;
+        int32_t x, y;
+        uint32_t width, height, border_width, border_height;
+        Status getXGeometryResult = XGetGeometry(xServer, windowHandle, &rootWindow, &x, &y, &width, &height, &border_width, &border_height);
+        if (getXGeometryResult > 0) {
+            windowRect = MMRectMake(x, y, width, height);
+        }
+    }
+    return windowRect;
+}

src/macos/window_manager.mm

@@ -0,0 +1,95 @@
+#import <Foundation/Foundation.h>
+#import <AppKit/AppKit.h>
+#import <ApplicationServices/ApplicationServices.h>
+#include "../window_manager.h"
+
+NSDictionary* getWindowInfo(int64_t windowHandle) {
+  CGWindowListOption listOptions = kCGWindowListOptionOnScreenOnly | kCGWindowListExcludeDesktopElements;
+  CFArrayRef windowList = CGWindowListCopyWindowInfo(listOptions, kCGNullWindowID);
+
+  for (NSDictionary *info in (NSArray *)windowList) {
+    NSNumber *windowNumber = info[(id)kCGWindowNumber];
+
+    if (windowHandle == [windowNumber intValue]) {
+      CFRetain(info);
+      CFRelease(windowList);
+      return info;
+    }
+  }
+
+  if (windowList) {
+    CFRelease(windowList);
+  }
+
+  return nullptr;
+}
+
+WindowHandle getActiveWindow() {
+  CGWindowListOption listOptions = kCGWindowListOptionOnScreenOnly | kCGWindowListExcludeDesktopElements;
+  CFArrayRef windowList = CGWindowListCopyWindowInfo(listOptions, kCGNullWindowID);
+
+  for (NSDictionary *info in (NSArray *)windowList) {
+    NSNumber *ownerPid = info[(id)kCGWindowOwnerPID];
+    NSNumber *windowNumber = info[(id)kCGWindowNumber];
+
+    auto app = [NSRunningApplication runningApplicationWithProcessIdentifier: [ownerPid intValue]];
+
+    if (![app isActive]) {
+      continue;
+    }
+
+    CFRelease(windowList);
+    return [windowNumber intValue];
+  }
+
+  if (windowList) {
+    CFRelease(windowList);
+  }
+  return -1;
+}
+
+std::vector<WindowHandle> getWindows() {
+  CGWindowListOption listOptions = kCGWindowListOptionOnScreenOnly | kCGWindowListExcludeDesktopElements;
+  CFArrayRef windowList = CGWindowListCopyWindowInfo(listOptions, kCGNullWindowID);
+
+  std::vector<WindowHandle> windowHandles;
+
+  for (NSDictionary *info in (NSArray *)windowList) {
+    NSNumber *ownerPid = info[(id)kCGWindowOwnerPID];
+    NSNumber *windowNumber = info[(id)kCGWindowNumber];
+
+    auto app = [NSRunningApplication runningApplicationWithProcessIdentifier: [ownerPid intValue]];
+    auto path = app ? [app.bundleURL.path UTF8String] : "";
+
+    if (app && path != "") {
+      windowHandles.push_back([windowNumber intValue]);
+    }
+  }
+
+  if (windowList) {
+    CFRelease(windowList);
+  }
+
+  return windowHandles;
+}
+
+MMRect getWindowRect(const WindowHandle windowHandle) {
+  auto windowInfo = getWindowInfo(windowHandle);
+  if (windowInfo != nullptr) {
+    CGRect windowRect;
+    if (CGRectMakeWithDictionaryRepresentation((CFDictionaryRef)windowInfo[(id)kCGWindowBounds], &windowRect)) {
+      return MMRectMake(windowRect.origin.x, windowRect.origin.y, windowRect.size.width, windowRect.size.height);
+    }
+    return MMRectMake(0, 0, 0, 0);
+  }
+  return MMRectMake(0, 0, 0, 0);
+}
+
+std::string getWindowTitle(const WindowHandle windowHandle) {
+  auto windowInfo = getWindowInfo(windowHandle);
+  if (windowInfo != nullptr) {
+    NSString *windowName = windowInfo[(id)kCGWindowName];
+    return [windowName UTF8String];
+  }
+  return "";
+}

src/main.cc

@@ -7,6 +7,7 @@
 #include "mouse.h"
 #include "screen.h"
 #include "screengrab.h"
+#include "window_manager.h"
 
 int mouseDelay = 10;
 int keyboardDelay = 10;
@@ -668,6 +669,48 @@ Napi::Number _highlight(const Napi::CallbackInfo &info)
 	return Napi::Number::New(env, 1);
 }
 
+Napi::Number _getActiveWindow(const Napi::CallbackInfo &info) {
+	Napi::Env env = info.Env();
+
+	WindowHandle windowHandle = getActiveWindow();
+	return Napi::Number::New(env, windowHandle);
+}
+
+Napi::Array _getWindows(const Napi::CallbackInfo &info) {
+	Napi::Env env = info.Env();
+
+	std::vector<WindowHandle> windowHandles = getWindows();
+	auto arr = Napi::Array::New(env, windowHandles.size());
+
+	for (size_t idx = 0; idx < windowHandles.size(); ++idx) {
+		arr[idx] = windowHandles[idx];
+	}
+
+	return arr;
+}
+
+Napi::Object _getWindowRect(const Napi::CallbackInfo &info) {
+	Napi::Env env = info.Env();
+
+	WindowHandle windowHandle = info[0].As<Napi::Number>().Int64Value();
+	MMRect windowRect = getWindowRect(windowHandle);
+
+	Napi::Object obj = Napi::Object::New(env);
+	obj.Set(Napi::String::New(env, "x"), Napi::Number::New(env, windowRect.origin.x));
+	obj.Set(Napi::String::New(env, "y"), Napi::Number::New(env, windowRect.origin.y));
+	obj.Set(Napi::String::New(env, "width"), Napi::Number::New(env, windowRect.size.width));
+	obj.Set(Napi::String::New(env, "height"), Napi::Number::New(env, windowRect.size.height));
+
+	return obj;
+}
+
+Napi::String _getWindowTitle(const Napi::CallbackInfo &info) {
+	Napi::Env env = info.Env();
+
+	WindowHandle windowHandle = info[0].As<Napi::Number>().Int64Value();
+	return Napi::String::New(env, getWindowTitle(windowHandle));
+}
+
 Napi::Object _captureScreen(const Napi::CallbackInfo &info)
 {
 	Napi::Env env = info.Env();
@@ -749,6 +792,10 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
 
 	exports.Set(Napi::String::New(env, "getScreenSize"), Napi::Function::New(env, _getScreenSize));
 	exports.Set(Napi::String::New(env, "highlight"), Napi::Function::New(env, _highlight));
+	exports.Set(Napi::String::New(env, "getWindows"), Napi::Function::New(env, _getWindows));
+	exports.Set(Napi::String::New(env, "getActiveWindow"), Napi::Function::New(env, _getActiveWindow));
+	exports.Set(Napi::String::New(env, "getWindowRect"), Napi::Function::New(env, _getWindowRect));
+	exports.Set(Napi::String::New(env, "getWindowTitle"), Napi::Function::New(env, _getWindowTitle));
 	exports.Set(Napi::String::New(env, "captureScreen"), Napi::Function::New(env, _captureScreen));
 	exports.Set(Napi::String::New(env, "getXDisplayName"), Napi::Function::New(env, _getXDisplayName));
 	exports.Set(Napi::String::New(env, "setXDisplayName"), Napi::Function::New(env, _setXDisplayName));

src/types.h

@@ -5,19 +5,20 @@
 #include "os.h"
 #include "inline_keywords.h" /* For H_INLINE */
 #include <stddef.h>
+#include <stdint.h>
 
 /* Some generic, cross-platform types. */
 
 struct _MMPoint {
-	size_t x;
-	size_t y;
+	int64_t x;
+	int64_t y;
 };
 
 typedef struct _MMPoint MMPoint;
 
 struct _MMSize {
-	size_t width;
-	size_t height;
+	int64_t width;
+	int64_t height;
 };
 
 typedef struct _MMSize MMSize;
@@ -29,23 +30,23 @@ struct _MMRect {
 
 typedef struct _MMRect MMRect;
 
-H_INLINE MMPoint MMPointMake(size_t x, size_t y)
+H_INLINE MMPoint MMPointMake(int64_t x, int64_t y)
 {
 	MMPoint point;
 	point.x = x;
 	point.y = y;
 	return point;
 }
 
-H_INLINE MMSize MMSizeMake(size_t width, size_t height)
+H_INLINE MMSize MMSizeMake(int64_t width, int64_t height)
 {
 	MMSize size;
 	size.width = width;
 	size.height = height;
 	return size;
 }
 
-H_INLINE MMRect MMRectMake(size_t x, size_t y, size_t width, size_t height)
+H_INLINE MMRect MMRectMake(int64_t x, int64_t y, int64_t width, int64_t height)
 {
 	MMRect rect;
 	rect.origin = MMPointMake(x, y);
@@ -66,4 +67,6 @@ H_INLINE MMRect MMRectMake(size_t x, size_t y, size_t width, size_t height)
 
 #endif
 
+typedef int64_t WindowHandle;
+
 #endif /* TYPES_H */