rum 0.0.1-x86-mingw32

data/ext/windows/system/clipboard_watcher.h

@@ -0,0 +1,2 @@
+VALUE install_watcher(VALUE self);
+VALUE evaluate_watcher(VALUE self, VALUE window);

data/ext/windows/system/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+$LIBS << ' gdi32.lib' # needed for input_box.c
+create_makefile("system")

data/ext/windows/system/input_box.c

@@ -0,0 +1,239 @@
+
+/* Inspired by https://sourceforge.net/projects/cinputbox */
+
+#define UNICODE
+#include <windows.h>
+#include <stdio.h>
+#include "input_box.h"
+
+#define IB_CLASS_NAME L"RumInputBox"
+#define IB_WIDTH 300
+#define IB_HEIGHT 130
+#define IB_SPAN 10
+#define IB_LEFT_OFFSET 6
+#define IB_TOP_OFFSET 4
+#define IB_BTN_WIDTH 60
+#define IB_BTN_HEIGHT 20
+
+typedef struct {
+  HWND  main_window, text, ok, cancel, edit_control;
+  LPTSTR result_text;
+  INT  max_chars, result;
+  HINSTANCE instance;
+} InputBox;
+
+HMODULE global_instance;
+
+static void input_box_populate_window(InputBox *box, HWND blank_window)
+{
+  NONCLIENTMETRICS metrics;
+  HFONT	font;
+  
+  box->main_window = blank_window;
+
+  box->text = CreateWindow(L"Static", L"",
+                            WS_CHILD | WS_VISIBLE,
+                            IB_LEFT_OFFSET, IB_TOP_OFFSET,
+                            IB_WIDTH-IB_LEFT_OFFSET*2, IB_BTN_HEIGHT*2,
+                            box->main_window, NULL,
+                            box->instance, NULL);
+  box->edit_control = CreateWindow(L"Edit", L"",
+                                   (WS_CHILD | WS_VISIBLE | WS_BORDER |
+                                    ES_AUTOHSCROLL | ES_LEFT),
+                                   IB_LEFT_OFFSET,
+                                   IB_TOP_OFFSET + IB_BTN_HEIGHT*2,
+                                   IB_WIDTH-IB_LEFT_OFFSET*3, IB_BTN_HEIGHT,
+                                   box->main_window, NULL,
+                                   box->instance, NULL);
+  box->ok = CreateWindow(L"Button", L"OK",
+                         WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON,
+                         IB_WIDTH/2 - IB_SPAN*2 - IB_BTN_WIDTH,
+                         IB_HEIGHT - IB_TOP_OFFSET*4 - IB_BTN_HEIGHT*2,
+                         IB_BTN_WIDTH, IB_BTN_HEIGHT,
+                         box->main_window, (HMENU)IDOK,
+                         box->instance, NULL);
+  box->cancel = CreateWindow(L"Button", L"Cancel",
+                             WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON,
+                             IB_WIDTH/2 + IB_SPAN,
+                             IB_HEIGHT - IB_TOP_OFFSET*4 - IB_BTN_HEIGHT*2,
+                             IB_BTN_WIDTH, IB_BTN_HEIGHT,
+                             box->main_window, (HMENU)IDCANCEL,
+                             box->instance, NULL);
+
+  font = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
+  
+  SendMessage(box->text,WM_SETFONT,(WPARAM)font,FALSE);
+  SendMessage(box->edit_control,WM_SETFONT,(WPARAM)font,FALSE);
+  SendMessage(box->ok,WM_SETFONT,(WPARAM)font,FALSE);
+  SendMessage(box->cancel,WM_SETFONT,(WPARAM)font,FALSE);
+}
+
+static void input_box_close(InputBox *box)
+{
+  PostMessage(box->main_window, WM_CLOSE, 0, 0);
+}
+
+static void input_box_submit(InputBox *box)
+{
+  int input_length = (int)SendMessage(box->edit_control, EM_LINELENGTH, 0, 0);
+  if (input_length){
+    // Provide the max number of chars to be copied as a word in the buffer.
+    *((LPWORD)box->result_text) = box->max_chars;
+    // Although undocumented, the copied string is null-terminated.
+    input_length = (WORD)SendMessage(box->edit_control, EM_GETLINE, 0,
+                                     (LPARAM)box->result_text);
+  }
+  box->result = input_length;
+}
+
+LRESULT CALLBACK window_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+  InputBox *box = (InputBox*)GetWindowLong(hwnd, GWL_USERDATA);
+  
+  switch(msg)
+    {
+    case WM_CREATE:
+      box = (InputBox *) ((CREATESTRUCT *)lParam)->lpCreateParams;
+      SetWindowLong(hwnd, GWL_USERDATA, (long)box);
+      input_box_populate_window(box, hwnd);
+      break;
+    case WM_COMMAND:
+      switch(LOWORD(wParam)) {
+      case IDOK:
+        input_box_submit(box);
+      case IDCANCEL:
+        input_box_close(box);
+        break;
+      }
+      break;
+    case WM_SETFOCUS:
+      SetFocus(box->edit_control);
+      break;
+    case WM_CLOSE:
+      DestroyWindow(hwnd);
+      break;
+    case WM_DESTROY:
+      PostQuitMessage(0);
+      break;
+    }
+  return DefWindowProc(hwnd, msg, wParam, lParam);
+}
+
+void input_box_register_window_class(HINSTANCE instance)
+{
+  WNDCLASSEX wndInputBox;
+
+  wndInputBox.cbSize = sizeof(wndInputBox);
+  wndInputBox.style = CS_HREDRAW | CS_VREDRAW;
+  wndInputBox.lpszClassName = IB_CLASS_NAME;
+  wndInputBox.lpfnWndProc = window_proc;
+  wndInputBox.lpszMenuName = NULL;
+  wndInputBox.cbClsExtra = 0;
+  wndInputBox.cbWndExtra = 0;
+  wndInputBox.hInstance = instance;
+  wndInputBox.hIcon = LoadIcon(NULL, IDI_QUESTION);
+  wndInputBox.hIconSm = NULL;
+  wndInputBox.hCursor = LoadCursor(NULL, IDC_ARROW);
+  wndInputBox.hbrBackground = (HBRUSH)(COLOR_WINDOW);
+
+  if(!RegisterClassEx(&wndInputBox))
+    {
+      MessageBox(NULL, L"Window Registration Failed!", L"Error!",
+                 MB_ICONEXCLAMATION | MB_OK);
+    }
+}
+
+void input_box_unregister_window_class(InputBox *box)
+{
+  UnregisterClass(IB_CLASS_NAME, box->instance);
+}
+
+static void input_box_show(InputBox *box, LPCTSTR title, LPCTSTR text,
+                           LPTSTR result_text, int max_chars)
+{
+  box->result_text = result_text;
+  box->max_chars   = max_chars;
+  box->result      = 0;
+
+  SetWindowText(box->main_window, title);
+  SetWindowText(box->edit_control, result_text);
+  SetWindowText(box->text, text);
+  SendMessage(box->edit_control, EM_LIMITTEXT,
+              max_chars-1, // Leave room for the terminating null char.
+              0);
+  SendMessage(box->edit_control, EM_SETSEL, 0, -1); // Select the whole text
+  ShowWindow(box->main_window, SW_SHOWNORMAL);
+}
+
+static void input_box_create(InputBox *box, HINSTANCE instance)
+{
+  RECT rect;
+
+  GetWindowRect(GetDesktopWindow(), &rect);
+  
+  box->instance    = instance;
+  box->main_window = CreateWindowEx(WS_EX_TOPMOST,
+                                    IB_CLASS_NAME, L"",
+                                    (WS_BORDER | WS_CAPTION | WS_SYSMENU),
+                                    (rect.left + rect.right - IB_WIDTH)/2,
+                                    (rect.top + rect.bottom - IB_HEIGHT)/2,
+                                    IB_WIDTH, IB_HEIGHT,
+                                    GetForegroundWindow(), 0,
+                                    instance, box);
+}
+
+
+
+static void input_box_destroy(InputBox *box)
+{
+  SendMessage(box->main_window, WM_DESTROY, 0, 0);
+}
+
+
+void input_box_initialize(HINSTANCE instance)
+{
+  global_instance = instance;
+  input_box_register_window_class(instance);
+}
+
+int input_box(LPCTSTR text, LPCTSTR title,
+              LPTSTR result_text, int max_chars)
+{
+  MSG msg;
+  InputBox box;
+  
+  input_box_create(&box, global_instance);
+  
+  input_box_show(&box, title, text, result_text, max_chars);
+
+  while(GetMessage(&msg, NULL, 0, 0) > 0)
+    {
+      if (msg.message == WM_KEYDOWN) {
+        switch (msg.wParam) {
+        case VK_RETURN:
+          input_box_submit(&box);
+        case VK_ESCAPE:
+          input_box_close(&box);
+          break;
+        default:
+          TranslateMessage(&msg);
+        }
+      } else {
+        TranslateMessage(&msg);
+      }
+      DispatchMessage(&msg);	
+    }
+
+  input_box_destroy(&box);
+  
+  return(box.result);
+}
+
+/* void input_box_demo() */
+/* { */
+/*   input_box_initialize(GetModuleHandle(NULL)); */
+/*   #define chars 100 */
+/*   /\* UTF-16LE: 2 bytes per char. *\/ */
+/*   char buffer[chars*2] = {187, 3, 184, 3, 4, 4}; */
+/*   input_box(L"text", L"title", (LPTSTR)buffer, chars); */
+/* } */

data/ext/windows/system/input_box.h

@@ -0,0 +1,4 @@
+void input_box_initialize(HINSTANCE instance);
+
+int input_box(LPCTSTR title, LPCTSTR query,
+              LPTSTR result_text, int max_chars);

data/ext/windows/system/system.c

@@ -0,0 +1,273 @@
+#include "ruby.h"
+#include <windows.h>
+#include <winuser.h>
+#include <tlhelp32.h>
+#include "autohotkey_stuff.h"
+#include "input_box.h"
+#include "clipboard_watcher.h"
+
+VALUE mSystem;
+VALUE mDesktop;
+VALUE mScreen;
+VALUE mClipboard;
+VALUE cWindow;
+
+struct KeybdEventParams {
+  int vkcode;
+  int scancode;
+  DWORD flags;
+};
+
+struct InputBoxParams {
+  LPCTSTR text;
+  LPCTSTR title;
+  LPTSTR result_text;
+  int length;
+};
+
+struct MessageBoxParams {
+  LPCWSTR text;
+  LPCWSTR title;
+};
+
+static BOOL CALLBACK enum_windows_proc(HWND hwnd, LPARAM lParam)
+{
+  rb_yield(LONG2NUM((DWORD)hwnd));
+  return TRUE;
+}
+
+static VALUE enum_windows(VALUE self) {
+  EnumWindows(enum_windows_proc, 0);
+  return Qnil;
+}
+
+static void call_keybd_event(struct KeybdEventParams *event) {
+  #ifdef DEBUG
+  printf("Sending key: vkcode: %d, scancode: %d\n", event.vkcode, event.scancode);
+  #endif
+  keybd_event(event->vkcode, event->scancode, event->flags, 0);
+}
+
+static VALUE f_keybd_event(int argc, VALUE* argv, VALUE self)
+{
+  VALUE vkcode, down, scancode, extended;
+  struct KeybdEventParams event;
+  rb_scan_args(argc, argv, "22", &vkcode, &down, &scancode, &extended);
+
+  event.flags = 0;
+  if (down != Qtrue)
+    event.flags |= KEYEVENTF_KEYUP;
+  if ( !(extended == Qnil || extended == Qfalse) )
+    event.flags |= KEYEVENTF_EXTENDEDKEY;
+
+  event.vkcode = NUM2INT(vkcode);
+  event.scancode = (NIL_P(scancode) ? 0 : NUM2INT(scancode));
+  rb_thread_blocking_region(call_keybd_event, &event, 0, 0);
+  return Qnil;
+}
+
+/* Returns 'true' if successful, 'false' if not. */
+static VALUE ForceWindowToFront(VALUE self)
+{
+  HWND TargetWindow = (HWND)NUM2ULONG(rb_iv_get(self, "@handle"));
+  if (SetForegroundWindowEx(TargetWindow))
+    return Qtrue;
+  else
+    return Qfalse;
+}
+
+static DWORD process_id(VALUE window)
+{
+  VALUE handle = rb_iv_get(window, "@handle");
+  HWND window_handle = (HWND)NUM2ULONG(handle);
+  
+  DWORD process_id = 0;
+  GetWindowThreadProcessId(window_handle, &process_id);
+  return process_id;
+}
+
+static void process_module(VALUE window, MODULEENTRY32 *module) {
+  DWORD processID = process_id(window);
+  
+  // Take a snapshot of the modules of this process
+  HANDLE moduleSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, processID);
+
+  //Get the first module
+  module->dwSize = sizeof(MODULEENTRY32);
+  Module32First(moduleSnapshot, module);
+}
+
+static void get_exe_path(MODULEENTRY32 *module, char *buffer) {
+  strcpy(buffer, module->szExePath);
+}
+
+static void get_exe_name(MODULEENTRY32 *module, char *buffer) {
+  strcpy(buffer, module->szModule);
+  buffer[strlen(buffer) - 4] = '\0'; /* Remove .exe suffix */
+}
+
+static void access_window_process_data(VALUE window, void fn(MODULEENTRY32 *module, char *buffer), char *buffer) {
+  MODULEENTRY32 module = {0};
+  process_module(window, &module);
+  (*fn)(&module, buffer);
+}
+
+static VALUE exe_name(VALUE self)
+{
+  char buffer[MAX_MODULE_NAME32 + 1];
+  access_window_process_data(self, &get_exe_name, buffer);
+  return rb_str_new2(buffer);
+}
+
+static VALUE exe_path(VALUE self)
+{
+  char buffer[MAX_PATH];
+  access_window_process_data(self, &get_exe_path, buffer);
+  return rb_str_new2(buffer);
+}
+
+static LPRECT get_window_rect(VALUE window, LPRECT rect)
+{
+  HWND window_handle = (HWND)NUM2ULONG(rb_iv_get(window, "@handle"));
+  GetWindowRect(window_handle, rect);
+  return rect;
+}
+
+static VALUE top(VALUE self)
+{
+  RECT rect;
+  return LONG2NUM((get_window_rect(self, &rect)->top));
+}
+
+
+static VALUE right(VALUE self)
+{
+  RECT rect;
+  return LONG2NUM((get_window_rect(self, &rect)->right));
+}
+
+static VALUE bottom(VALUE self)
+{
+  RECT rect;
+  return LONG2NUM((get_window_rect(self, &rect)->bottom));
+}
+
+static VALUE left(VALUE self)
+{
+  RECT rect;
+  return LONG2NUM((get_window_rect(self, &rect)->left));
+}
+
+static VALUE desktop_top(VALUE self)
+{
+  RECT work_area;
+  SystemParametersInfo(SPI_GETWORKAREA, 0, &work_area, 0);
+  return LONG2NUM(work_area.top);
+}
+
+static VALUE desktop_right(VALUE self)
+{
+  RECT work_area;
+  SystemParametersInfo(SPI_GETWORKAREA, 0, &work_area, 0);
+  return LONG2NUM(work_area.right);
+}
+
+static VALUE desktop_bottom(VALUE self)
+{
+  RECT work_area;
+  SystemParametersInfo(SPI_GETWORKAREA, 0, &work_area, 0);
+  return LONG2NUM(work_area.bottom);
+}
+
+static VALUE desktop_left(VALUE self)
+{
+  RECT work_area;
+  SystemParametersInfo(SPI_GETWORKAREA, 0, &work_area, 0);
+  return LONG2NUM(work_area.left);
+}
+
+static VALUE screen_width(VALUE self)
+{
+  return INT2NUM(GetSystemMetrics(SM_CXSCREEN));
+}
+
+static VALUE screen_height(VALUE self)
+{
+  return INT2NUM(GetSystemMetrics(SM_CYSCREEN));
+}
+
+static VALUE get_console_window(VALUE self)
+{
+  /* Cast to ULONG_PTR to neutralize a compiler warning. */
+  return LONG2NUM((ULONG_PTR)GetConsoleWindow());
+}
+
+static VALUE call_message_box(struct MessageBoxParams *params)
+{
+  int result = MessageBoxW(0, params->text, params->title,
+                           MB_OKCANCEL | MB_TOPMOST | MB_SETFOREGROUND);
+  return result == IDOK ? Qtrue : Qfalse;
+}
+
+static VALUE message_box_internal(VALUE self, VALUE text, VALUE title)
+{
+  struct MessageBoxParams params;
+  params.text  = (LPCWSTR)RSTRING_PTR(text);
+  params.title = (LPCWSTR)RSTRING_PTR(title);
+  return rb_thread_blocking_region(call_message_box, &params, 0, 0);
+}
+
+static VALUE call_input_box(struct InputBoxParams *params)
+{
+  return INT2FIX(input_box(params->text, params->title,
+                           params->result_text, params->length));
+}
+
+static VALUE input_box_internal(VALUE self, VALUE text, VALUE title,
+                                VALUE result_text)
+{
+  struct InputBoxParams params;
+  params.text        = RSTRING_PTR(text);
+  params.title       = RSTRING_PTR(title);
+  params.result_text = RSTRING_PTR(result_text);
+  params.length      = RSTRING_LEN(result_text)/2;
+
+  return rb_thread_blocking_region(call_input_box, &params, 0, 0);
+}
+
+
+void Init_system() {
+  input_box_initialize(GetModuleHandle(NULL));
+  autohotkey_stuff_initialize(GetCurrentThreadId());
+  
+  mSystem        = rb_define_module_under(rb_define_module("Rum"), "System");
+  mDesktop   = rb_define_module_under(mSystem, "Desktop");
+  mScreen    = rb_define_module_under(mSystem, "Screen");
+  mClipboard = rb_define_module_under(mSystem, "Clipboard");
+  cWindow    = rb_define_class_under(mSystem, "Window", rb_cObject);
+  
+  rb_define_method(mSystem, "enum_windows", enum_windows, 0);
+  rb_define_method(mSystem, "keybd_event", f_keybd_event, -1);
+  rb_define_method(mSystem, "get_console_window", get_console_window, 0);
+  rb_define_method(mSystem, "message_box_internal", message_box_internal, 2);
+  rb_define_method(mSystem, "input_box_internal", input_box_internal, 3);
+
+  rb_define_method(cWindow, "show", ForceWindowToFront, 0);
+  rb_define_method(cWindow, "exe_path", exe_path, 0);
+  rb_define_method(cWindow, "exe_name", exe_name, 0);
+  rb_define_method(cWindow, "left", left, 0);
+  rb_define_method(cWindow, "right", right, 0);
+  rb_define_method(cWindow, "top", top, 0);
+  rb_define_method(cWindow, "bottom", bottom, 0);
+  
+  rb_define_module_function(mDesktop, "top", desktop_top, 0);
+  rb_define_module_function(mDesktop, "left", desktop_left, 0);
+  rb_define_module_function(mDesktop, "bottom", desktop_bottom, 0);
+  rb_define_module_function(mDesktop, "right", desktop_right, 0);
+  
+  rb_define_module_function(mScreen, "width", screen_width, 0);
+  rb_define_module_function(mScreen, "height", screen_height, 0);
+  
+  rb_define_method(mClipboard, "install_watcher", install_watcher, 0);
+  rb_define_method(mClipboard, "evaluate_watcher", evaluate_watcher, 2);
+}