xdotool 1.0.50 → 1.0.55

package/.history/src/XdoTool_20220115190619.cpp

@@ -0,0 +1,350 @@
+#include "XdoTool.h"
+#include "tasks/SearchWindows.h"
+#include "tasks/GetMouseLocation.h"
+#include "tasks/GetViewportDimensions.h"
+#include "tasks/SendKeysequence.h"
+#include "tasks/GetWindowPID.h"
+#include "tasks/MoveMouse.h"
+#include "tasks/ActivateWindow.h"
+#include "tasks/EnterText.h"
+#include "tasks/WindowHasProperty.h"
+#include "ClassCreator.h"
+#include "TypeConverter.h"
+#include "XdoToolTaskWorker.h"
+#include "tasks/Sync.h"
+#include "tasks/GetFocusedWindow.h"
+#include "tasks/GetWindowSize.h"
+
+#include <iostream>
+
+using v8::FunctionTemplate;
+using v8::Function;
+using v8::String;
+using v8::Local;
+using v8::Isolate;
+using v8::Object;
+using v8::Value;
+using Nan::Set;
+using Nan::To;
+using Nan::GetCurrentContext;
+using Nan::Callback;
+using Nan::New;
+using Nan::FunctionCallback;
+
+Nan::Persistent<Function> XdoTool::constructor;
+
+XdoTool::XdoTool(xdo_t* xdo): XService(xdo->xdpy), xdo(xdo) {
+}
+
+XdoTool::~XdoTool() {
+    xdo_free(xdo);
+}
+
+NAN_METHOD(XdoTool::GetViewportDimensions) {
+    int screen;
+    if(!TypeConverter::GetInt32(info[0], screen)){
+        Nan::ThrowError("First argument must be a valid integer");
+        return;
+    }
+    XdoTool* tool;
+    if(!TypeConverter::Unwrap(info.This(),&tool)) {
+        Nan::ThrowError("Method called in invalid context");
+        return;
+    }
+    auto task = new tasks::GetViewportDimensions(tool->xdo, screen);
+    auto callback = new Callback(To<Function>(info[1]).ToLocalChecked());
+    AsyncQueueWorker(new XdoToolTaskWorker(callback, task));
+}
+
+NAN_METHOD(XdoTool::GetWindowSize) {
+    XID window;
+    if(!TypeConverter::GetWindow(info[0], window)){
+        Nan::ThrowError("First argument must be a valid integer");
+        return;
+    }
+    XdoTool* tool;
+    if(!TypeConverter::Unwrap(info.This(),&tool)) {
+        Nan::ThrowError("Method called in invalid context");
+        return;
+    }
+    auto task = new tasks::GetWindowSize(tool->xdo, window);
+    auto callback = new Callback(To<Function>(info[1]).ToLocalChecked());
+    AsyncQueueWorker(new XdoToolTaskWorker(callback, task));
+}
+
+NAN_METHOD(XdoTool::SendKeysequence) {
+    XdoTool* tool = nullptr;
+    char* keySequence = nullptr;
+    Window window;
+    int32_t delay;
+    if(!TypeConverter::Unwrap(info.This(),&tool)) {
+        Nan::ThrowError("Method called in invalid context");
+        return;
+    }
+    if(!TypeConverter::GetWindow(info[0],window)) {
+        Nan::ThrowError("First argument must be a valid window identifier");
+        return;
+    }
+    if(!TypeConverter::GetString(info[1], &keySequence)) {
+        Nan::ThrowError("Second parameter must be a valid string");
+        return;
+    }
+    if(!TypeConverter::GetInt32(info[2], delay)) {
+        Nan::ThrowError("Third parameter must be a valid integer");
+        return;
+    }
+    auto callback = new Callback(To<Function>(info[3]).ToLocalChecked());
+    auto task = new XdoToolTask_SendKeysequence(tool->xdo, window, keySequence, delay);
+    AsyncQueueWorker(new XdoToolTaskWorker(callback, task));
+}
+
+NAN_METHOD(XdoTool::GetWindowPID) {
+    Window window;
+    if(!TypeConverter::GetWindow(info[0],window)) {
+        Nan::ThrowError("First argument must be a window");
+        return;
+    }
+    XdoTool* tool;
+    if(!TypeConverter::Unwrap(info.This(),&tool)) {
+        Nan::ThrowError("Method called in invalid context");
+        return;
+    }
+    auto task = new XdoToolTask_GetWindowPID(tool->xdo, window);
+    auto callback = new Callback(To<Function>(info[1]).ToLocalChecked());
+    AsyncQueueWorker(new XdoToolTaskWorker(callback, task));
+}
+
+NAN_METHOD(XdoTool::MoveMouse) {
+    if(info[0]->IsUndefined() || !info[0]->IsObject()) {
+        Nan::ThrowError("First argument must be a valid object");
+        return;
+    }
+
+    int x, y, screen = 0;
+
+    Local<Object> opts = info[0]->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
+    if(!TypeConverter::GetInt32(opts, "x", &x) || !TypeConverter::GetInt32(opts, "y", &y)) {
+        Nan::ThrowError("x and y properties must be defined");
+        return;
+    }
+    TypeConverter::GetInt32(opts, "screen_num", &screen);
+
+    XdoTool* tool;
+    if(!TypeConverter::Unwrap(info.This(),&tool)) {
+        Nan::ThrowError("Method called in invalid context");
+        return;
+    }
+    auto task = new XdoToolTask_MoveMouse(tool->xdo, x, y, screen);
+    auto callback = new Callback(To<Function>(info[1]).ToLocalChecked());
+    AsyncQueueWorker(new XdoToolTaskWorker(callback, task));
+}
+
+NAN_METHOD(XdoTool::WindowHasProperty) {
+    Window window;
+    if(!TypeConverter::GetWindow(info[0],window)) {
+        Nan::ThrowError("First argument must be a valid window");
+        return;
+    }
+    std::string property;
+    if(!TypeConverter::GetString(info[1], property)) {
+        Nan::ThrowError("Second argument must be a valid string representing window property");
+        return;
+    }
+    XdoTool* tool;
+    if(!TypeConverter::Unwrap(info.This(),&tool)) {
+        Nan::ThrowError("Method called in invalid context");
+        return;
+    }
+    auto task = new XdoToolTask_WindowHasProperty(tool->xdo, window, property);
+    auto callback = new Callback(To<Function>(info[2]).ToLocalChecked());
+    AsyncQueueWorker(new XdoToolTaskWorker(callback, task));
+}
+
+NAN_METHOD(XdoTool::ActivateWindow) {
+    Window window;
+    if(!TypeConverter::GetWindow(info[0],window)) {
+        Nan::ThrowError("First argument must be a valid string pointing to a Window object");
+        return;
+    }
+    XdoTool* tool;
+    if(!TypeConverter::Unwrap(info.This(),&tool)) {
+        Nan::ThrowError("Method called in invalid context");
+        return;
+    }
+    auto task = new tasks::ActivateWindow(tool->xdo, window);
+    auto callback = new Callback(To<Function>(info[1]).ToLocalChecked());
+    AsyncQueueWorker(new XdoToolTaskWorker(callback, task));
+}
+
+NAN_METHOD(XdoTool::EnterText) {
+    Window window;
+    std::string text;
+    int32_t delay;
+    if(!TypeConverter::GetWindow(info[0],window)) {
+        Nan::ThrowError("First argument must be a valid string pointing to a Window object");
+        return;
+    }
+    if(!TypeConverter::GetString(info[1],text)) {
+        Nan::ThrowError("Second argument must be a string");
+        return;
+    }
+    if(!TypeConverter::GetInt32(info[2],delay)) {
+        Nan::ThrowError("Third argument must be an integer");
+        return;
+    }
+    XdoTool* tool;
+    if(!TypeConverter::Unwrap(info.This(),&tool)) {
+        Nan::ThrowError("Method called in invalid context");
+        return;
+    }
+    auto task = new XdoToolTask_EnterText(tool->xdo, window, text, delay);
+    auto callback = new Callback(To<Function>(info[3]).ToLocalChecked());
+    AsyncQueueWorker(new XdoToolTaskWorker(callback, task));
+}
+
+NAN_METHOD(XdoTool::GetFocusedWindow) {
+    XdoTool* tool;
+    if(!TypeConverter::Unwrap(info.This(),&tool)) {
+        Nan::ThrowError("Method called in invalid context");
+        return;
+    }
+    auto task = new XdoToolTask_GetFocusedWindow(tool->xdo);
+    auto callback = new Callback(To<Function>(info[0]).ToLocalChecked());
+    AsyncQueueWorker(new XdoToolTaskWorker(callback,task));
+}
+
+void XdoTool::Init(Local<Object> exports) {
+    std::map<std::string, FunctionCallback> methods {
+        { "constructor", Constructor },
+        { "getMouseLocation", GetMouseLocation },
+        { "searchWindows", SearchWindows },
+        { "getWindowPID", GetWindowPID },
+        { "moveMouse", MoveMouse },
+        { "getFocusedWindow", GetFocusedWindow },
+        { "enterText", EnterText },
+        { "sync", Sync },
+        { "sendKeysequence", SendKeysequence },
+        { "windowHasProperty", WindowHasProperty },
+        { "activateWindow", ActivateWindow },
+        { "getViewportDimensions", GetViewportDimensions }
+    };
+
+    Set(
+        exports,
+        Nan::New<String>("XdoTool").ToLocalChecked(),
+        ClassCreator::NewClass<XdoTool>("XdoTool", methods)
+    );
+}
+
+NAN_METHOD(XdoTool::Constructor) {
+    xdo_t* xdo = xdo_new(nullptr);
+    if(xdo == nullptr) {
+        Nan::ThrowError("Failed to create xdo_t instance. Please make sure X.org is running");
+        return;
+    }
+
+    auto* tool = new XdoTool(xdo);
+    printf("%p\n",tool);
+    tool->Wrap(info.This());
+    info.GetReturnValue().Set(info.This());
+}
+
+NAN_METHOD(XdoTool::SearchWindows) {
+    if(!info[0]->IsObject()) {
+        Nan::ThrowError("First argument must be a valid object");
+        return;
+    }
+
+    auto search = (xdo_search_t*) calloc(1, sizeof(xdo_search_t)*1);
+    if(search == nullptr) {
+        Nan::ThrowError("Memory allocation failed");
+        return;
+    }
+    search->require = xdo_search_t::SEARCH_ANY;
+    search->max_depth = -1;
+
+    XdoTool* tool;
+    if(!TypeConverter::Unwrap(info.This(),&tool)) {
+        Nan::ThrowError("Method called in invalid context");
+        return;
+    }
+    auto task = new XdoToolTask_SearchWindows(tool->xdo, search);
+    Local<Object> search_obj = Nan::To<Object>(info[0]).ToLocalChecked();
+
+    task->AddResource(search);
+
+    char* string;
+    if(TypeConverter::GetString(search_obj, "title", &string)) {
+        search->title = string;
+        search->searchmask |= SEARCH_TITLE;
+        task->AddResource(string);
+    }
+
+    if(TypeConverter::GetString(search_obj, "winclass", &string)) {
+        search->winclass = string;
+        search->searchmask |= SEARCH_CLASS;
+        task->AddResource(string);
+    }
+
+    if(TypeConverter::GetString(search_obj, "winclassname", &string)) {
+        search->winclassname = string;
+        search->searchmask |= SEARCH_CLASSNAME;
+        task->AddResource(string);
+    }
+
+    if(TypeConverter::GetString(search_obj, "winname", &string)) {
+        search->winname = string;
+        search->searchmask |= SEARCH_NAME;
+    }
+
+    int32_t int32_value;
+    if(TypeConverter::GetInt32(search_obj, "pid", &int32_value)) {
+        search->pid = int32_value;
+    }
+
+    if(TypeConverter::GetInt32(search_obj, "maxDepth", &int32_value)) {
+        search->max_depth = int32_value;
+    }
+
+    bool boolean_value;
+    if(TypeConverter::GetBool(search_obj, "onlyVisible", &boolean_value)) {
+        search->only_visible = boolean_value ? 1 : 0;
+    }
+
+    if(TypeConverter::GetInt32(search_obj, "screen", &int32_value)) {
+        search->screen = int32_value;
+    }
+
+    if(TypeConverter::GetInt32(search_obj, "desktop", &int32_value)) {
+        search->desktop = int32_value;
+    }
+
+    if(TypeConverter::GetInt32(search_obj, "limit", &int32_value)) {
+        search->limit = int32_value;
+    }
+
+    auto callback = new Nan::Callback(Nan::To<Function>(info[1]).ToLocalChecked());
+    AsyncQueueWorker(new XdoToolTaskWorker(callback, task));
+}
+
+NAN_METHOD(XdoTool::GetMouseLocation) {
+    XdoTool* tool;
+    if(!TypeConverter::Unwrap(info.This(),&tool)) {
+        Nan::ThrowError("Method called in invalid context");
+        return;
+    }
+    auto task = new XdoToolTask_GetMouseLocation(tool->xdo);
+    auto callback = new Nan::Callback(Nan::To<Function>(info[0]).ToLocalChecked());
+    AsyncQueueWorker(new XdoToolTaskWorker(callback, task));
+}
+
+NAN_METHOD(XdoTool::Sync) {
+    XdoTool* tool;
+    if(!TypeConverter::Unwrap(info.This(),&tool)) {
+        Nan::ThrowError("Method called in invalid context");
+        return;
+    }
+    auto task = new XdoToolTask_Sync(tool->xdo->xdpy);
+    auto callback = new Nan::Callback(Nan::To<Function>(info[0]).ToLocalChecked());
+    AsyncQueueWorker(new XdoToolTaskWorker(callback, task));
+}

package/.history/src/tasks/ActivateWindow_20210721132815.h

@@ -0,0 +1,15 @@
+#ifndef NODE_XDOTOOL_ACTIVATE_WINDOW_TASK_H_
+#define NODE_XDOTOOL_ACTIVATE_WINDOW_TASK_H_
+
+#include "../XdoToolTask.h"
+
+class XdoToolTask_ActivateWindow : public XdoToolTask {
+public:
+    XdoToolTask_ActivateWindow(xdo_t*, Window);
+    void Execute() override;
+    v8::Local<v8::Value> GetResult() override;
+private:
+    Window window;
+};
+
+#endif // NODE_XDOTOOL_ACTIVATE_WINDOW_TASK_H_

package/.history/src/tasks/ActivateWindow_20210721133108.cpp

@@ -0,0 +1,23 @@
+#include "ActivateWindow.h"
+
+using v8::Local;
+using v8::Value;
+
+XdoToolTask_ActivateWindow::XdoToolTask_ActivateWindow(
+    xdo_t* xdo,
+    Window window
+): XdoToolTask(xdo), window(window) {}
+
+void XdoToolTask_ActivateWindow::Execute() {
+    if(xdo_activate_window(xdo, window) != XDO_SUCCESS) {
+        SetFailure("Failed to activate window");
+        return;
+    }
+    if(xdo_wait_for_window_active(xdo, window, 1) != XDO_SUCCESS) {
+        SetFailure("Failed to wait for window to be active");
+    }
+}
+
+Local<Value> XdoToolTask_ActivateWindow::GetResult() {
+    return Nan::Undefined();
+}

package/.history/src/tasks/ActivateWindow_20220115190504.cpp

@@ -0,0 +1,23 @@
+#include "ActivateWindow.h"
+
+using v8::Local;
+using v8::Value;
+
+tasks::ActivateWindow::tasks::ActivateWindow(
+    xdo_t* xdo,
+    Window window
+): XdoToolTask(xdo), window(window) {}
+
+void tasks::ActivateWindow::Execute() {
+    if(xdo_activate_window(xdo, window) != XDO_SUCCESS) {
+        SetFailure("Failed to activate window");
+        return;
+    }
+    if(xdo_wait_for_window_active(xdo, window, 1) != XDO_SUCCESS) {
+        SetFailure("Failed to wait for window to be active");
+    }
+}
+
+Local<Value> tasks::ActivateWindow::GetResult() {
+    return Nan::Undefined();
+}

package/.history/src/tasks/ActivateWindow_20220115190504.h

@@ -0,0 +1,15 @@
+#ifndef NODE_XDOTOOL_ACTIVATE_WINDOW_TASK_H_
+#define NODE_XDOTOOL_ACTIVATE_WINDOW_TASK_H_
+
+#include "../XdoToolTask.h"
+
+class tasks::ActivateWindow : public XdoToolTask {
+public:
+    tasks::ActivateWindow(xdo_t*, Window);
+    void Execute() override;
+    v8::Local<v8::Value> GetResult() override;
+private:
+    Window window;
+};
+
+#endif // NODE_XDOTOOL_ACTIVATE_WINDOW_TASK_H_

package/.history/src/tasks/ActivateWindow_20220115190527.h

@@ -0,0 +1,19 @@
+#ifndef NODE_XDOTOOL_ACTIVATE_WINDOW_TASK_H_
+#define NODE_XDOTOOL_ACTIVATE_WINDOW_TASK_H_
+
+#include "../XdoToolTask.h"
+
+namespace tasks {
+
+class ActivateWindow : public XdoToolTask {
+public:
+    ActivateWindow(xdo_t*, Window);
+    void Execute() override;
+    v8::Local<v8::Value> GetResult() override;
+private:
+    Window window;
+};
+
+}
+
+#endif // NODE_XDOTOOL_ACTIVATE_WINDOW_TASK_H_

package/.history/src/tasks/ActivateWindow_20220115190528.cpp

@@ -0,0 +1,23 @@
+#include "ActivateWindow.h"
+
+using v8::Local;
+using v8::Value;
+
+tasks::ActivateWindow::ActivateWindow(
+    xdo_t* xdo,
+    Window window
+): XdoToolTask(xdo), window(window) {}
+
+void tasks::ActivateWindow::Execute() {
+    if(xdo_activate_window(xdo, window) != XDO_SUCCESS) {
+        SetFailure("Failed to activate window");
+        return;
+    }
+    if(xdo_wait_for_window_active(xdo, window, 1) != XDO_SUCCESS) {
+        SetFailure("Failed to wait for window to be active");
+    }
+}
+
+Local<Value> tasks::ActivateWindow::GetResult() {
+    return Nan::Undefined();
+}

package/.history/src/tasks/GetViewportDimensions_20210721132156.h

@@ -0,0 +1,17 @@
+#ifndef NODE_XDOTOOL_GET_VIEWPORT_DIMENSIONS_H_
+#define NODE_XDOTOOL_GET_VIEWPORT_DIMENSIONS_H_
+
+#include "../XdoToolTask.h"
+
+class XdoToolTask_GetViewportDimensions : public XdoToolTask {
+public:
+    XdoToolTask_GetViewportDimensions(xdo_t*, int);
+    void Execute() override;
+    v8::Local<v8::Value> GetResult() override;
+private:
+    int screen;
+    unsigned int width;
+    unsigned int height;
+};
+
+#endif // NODE_XDOTOOL_GET_VIEWPORT_DIMENSIONS_H_

package/.history/src/tasks/GetViewportDimensions_20210721132157.cpp

@@ -0,0 +1,26 @@
+#include "GetViewportDimensions.h"
+
+using Nan::New;
+using Nan::Set;
+using v8::Number;
+using v8::String;
+using v8::Local;
+using v8::Value;
+using v8::Object;
+
+XdoToolTask_GetViewportDimensions::XdoToolTask_GetViewportDimensions(xdo_t* xdo, int screen): XdoToolTask(xdo), screen(screen) {
+
+}
+
+void XdoToolTask_GetViewportDimensions::Execute() {
+    if(xdo_get_viewport_dimensions(xdo, &width, &height, screen) != XDO_SUCCESS) {
+        SetFailure("Failed to get viewport dimensions");
+    }
+}
+
+Local<Value> XdoToolTask_GetViewportDimensions::GetResult() {
+    Local<Object> obj = New<Object>();
+    Set(obj, New<String>("width").ToLocalChecked(), New<Number>(width));
+    Set(obj, New<String>("height").ToLocalChecked(), New<Number>(height));
+    return obj;
+}

package/.history/src/tasks/GetViewportDimensions_20220115190619.cpp

@@ -0,0 +1,26 @@
+#include "GetViewportDimensions.h"
+
+using Nan::New;
+using Nan::Set;
+using v8::Number;
+using v8::String;
+using v8::Local;
+using v8::Value;
+using v8::Object;
+
+tasks::GetViewportDimensions::tasks::GetViewportDimensions(xdo_t* xdo, int screen): XdoToolTask(xdo), screen(screen) {
+
+}
+
+void tasks::GetViewportDimensions::Execute() {
+    if(xdo_get_viewport_dimensions(xdo, &width, &height, screen) != XDO_SUCCESS) {
+        SetFailure("Failed to get viewport dimensions");
+    }
+}
+
+Local<Value> tasks::GetViewportDimensions::GetResult() {
+    Local<Object> obj = New<Object>();
+    Set(obj, New<String>("width").ToLocalChecked(), New<Number>(width));
+    Set(obj, New<String>("height").ToLocalChecked(), New<Number>(height));
+    return obj;
+}

package/.history/src/tasks/GetViewportDimensions_20220115190622.cpp

@@ -0,0 +1,26 @@
+#include "GetViewportDimensions.h"
+
+using Nan::New;
+using Nan::Set;
+using v8::Number;
+using v8::String;
+using v8::Local;
+using v8::Value;
+using v8::Object;
+
+tasks::GetViewportDimensions::GetViewportDimensions(xdo_t* xdo, int screen): XdoToolTask(xdo), screen(screen) {
+
+}
+
+void tasks::GetViewportDimensions::Execute() {
+    if(xdo_get_viewport_dimensions(xdo, &width, &height, screen) != XDO_SUCCESS) {
+        SetFailure("Failed to get viewport dimensions");
+    }
+}
+
+Local<Value> tasks::GetViewportDimensions::GetResult() {
+    Local<Object> obj = New<Object>();
+    Set(obj, New<String>("width").ToLocalChecked(), New<Number>(width));
+    Set(obj, New<String>("height").ToLocalChecked(), New<Number>(height));
+    return obj;
+}

package/.history/src/tasks/GetViewportDimensions_20220115190623.h

@@ -0,0 +1,21 @@
+#ifndef NODE_XDOTOOL_GET_VIEWPORT_DIMENSIONS_H_
+#define NODE_XDOTOOL_GET_VIEWPORT_DIMENSIONS_H_
+
+#include "../XdoToolTask.h"
+
+namespace tasks {
+
+class GetViewportDimensions : public XdoToolTask {
+public:
+    GetViewportDimensions(xdo_t*, int);
+    void Execute() override;
+    v8::Local<v8::Value> GetResult() override;
+private:
+    int screen;
+    unsigned int width;
+    unsigned int height;
+};
+
+}
+
+#endif // NODE_XDOTOOL_GET_VIEWPORT_DIMENSIONS_H_

package/CMakeLists.txt

@@ -1,21 +1,21 @@
 project(node_xdotool)
 cmake_minimum_required(VERSION 3.0)
 
-set(CMAKE_CXX_STANDARD 11)
+option(NAN_INCLUDE_DIRECTORY "NAN bindings directory" ${CMAKE_CURRENT_SOURCE_DIR}/node_modules/nan)
+option(NODE_INSTALL_DIR "Node.js path" "")
+
+set(CMAKE_CXX_STANDARD 14)
 set(NODE_XDOTOOL_COMPILE_OPTIONS -Wfatal-errors)
 set(NODE_XDOTOOL_INCLUDE_DIRS ${CMAKE_JS_INC} ${NODE_INSTALL_DIR}/include/node ${NAN_INCLUDE_DIRECTORY} ${NODE_XDOTOOL_INCLUDE_DIRS})
 set(NODE_XDOTOOL_LIBRARIES xdo ${CMAKE_JS_LIB})
 
-option(NAN_INCLUDE_DIRECTORY "NAN bindings directory" "")
-option(NODE_INSTALL_DIR "Node.js path" "")
-
 set(NODE_XDOTOOL_SOURCE_FILES src/main.cpp
     src/xdo_c.h
     src/XdoTool.cpp
     src/ResourceManager.cpp
     src/XdoToolTaskWorker.cpp
     src/XdoToolTask.cpp
-        src/TypeConverter.cpp
+    src/TypeConverter.cpp
     src/tasks/SendKeysequence.cpp
     src/Screenshooter.cpp
     src/XTask.cpp
@@ -32,7 +32,10 @@ set(NODE_XDOTOOL_SOURCE_FILES src/main.cpp
     src/tasks/GetMouseLocation.cpp
     src/tasks/ActivateWindow.cpp
     src/tasks/SearchWindows.cpp
-)
+    #src/tasks/GetActiveKeysToKeycodeList.cpp
+    #src/tasks/GetActiveKeysToKeycodeList.h
+    src/tasks/Sync.cpp
+    src/tasks/Sync.h src/tasks/GetFocusedWindow.cpp src/tasks/GetFocusedWindow.h src/tasks/GetWindowSize.cpp src/tasks/GetWindowSize.h)
 
 add_library(node_xdotool SHARED ${NODE_XDOTOOL_SOURCE_FILES})
 set_target_properties(node_xdotool PROPERTIES PREFIX "" SUFFIX ".node")