+/*
+ * Copyright (c) 2011, Andy Spencer <andy753421@gmail.com>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <search.h>
+
+#define WIN32_LEAN_AND_MEAN
+#define _WIN32_WINNT 0x0501
+#include <windows.h>
+#include <winbase.h>
+#include <winuser.h>
+
+#include "util.h"
+#include "conf.h"
+#include "sys.h"
+#include "wm.h"
+
+/* Configuration */
+static int no_capture = 0;
+static int stack = 25;
+
+/* Internal structures */
+struct win_sys {
+ HWND hwnd;
+};
+
+typedef struct {
+ event_t ev;
+ int vk;
+} event_map_t;
+
+/* Global data */
+static int shellhookid;
+static void *cache;
+static win_t *root;
+static list_t *screens;
+
+/* Conversion functions */
+static event_map_t ev2vk[] = {
+ {EV_MOUSE1 , VK_LBUTTON },
+ {EV_MOUSE2 , VK_MBUTTON },
+ {EV_MOUSE3 , VK_RBUTTON },
+ {EV_LEFT , VK_LEFT },
+ {EV_RIGHT , VK_RIGHT },
+ {EV_UP , VK_UP },
+ {EV_DOWN , VK_DOWN },
+ {EV_HOME , VK_HOME },
+ {EV_END , VK_END },
+ {EV_PAGEUP , VK_PRIOR },
+ {EV_PAGEDOWN, VK_NEXT },
+ {EV_F1 , VK_F1 },
+ {EV_F2 , VK_F2 },
+ {EV_F3 , VK_F3 },
+ {EV_F4 , VK_F4 },
+ {EV_F5 , VK_F5 },
+ {EV_F6 , VK_F6 },
+ {EV_F7 , VK_F7 },
+ {EV_F8 , VK_F8 },
+ {EV_F9 , VK_F9 },
+ {EV_F10 , VK_F10 },
+ {EV_F11 , VK_F11 },
+ {EV_F12 , VK_F12 },
+ {EV_SHIFT , VK_SHIFT },
+ {EV_SHIFT , VK_LSHIFT },
+ {EV_SHIFT , VK_RSHIFT },
+ {EV_CTRL , VK_CONTROL },
+ {EV_CTRL , VK_LCONTROL},
+ {EV_CTRL , VK_RCONTROL},
+ {EV_ALT , VK_MENU },
+ {EV_ALT , VK_LMENU },
+ {EV_ALT , VK_RMENU },
+ {EV_WIN , VK_LWIN },
+ {EV_WIN , VK_RWIN },
+};
+
+/* - Keycodes */
+static event_t w2ev(UINT vk)
+{
+ event_map_t *em = map_getr(ev2vk,vk);
+ return em ? em->ev : tolower(vk);
+}
+
+static UINT ev2w(event_t ev)
+{
+ event_map_t *em = map_get(ev2vk,ev);
+ return em ? em->vk : toupper(ev);
+}
+
+static mod_t getmod(void)
+{
+ return (mod_t){
+ .alt = GetKeyState(VK_MENU) < 0,
+ .ctrl = GetKeyState(VK_CONTROL) < 0,
+ .shift = GetKeyState(VK_SHIFT) < 0,
+ .win = GetKeyState(VK_LWIN) < 0 ||
+ GetKeyState(VK_RWIN) < 0,
+ };
+}
+
+/* - Pointers */
+static ptr_t getptr(void)
+{
+ POINT wptr;
+ GetCursorPos(&wptr);
+ return (ptr_t){-1, -1, wptr.x, wptr.y};
+}
+
+/* Window functions */
+static win_t *win_new(HWND hwnd, int checkwin)
+{
+ if (checkwin) {
+ char winclass[256];
+ int exstyle = GetWindowLong(hwnd, GWL_EXSTYLE);
+ GetClassName(hwnd, winclass, sizeof(winclass));
+ if (!IsWindowVisible(hwnd)) return NULL; // Invisible stuff..
+ if (!strcmp("#32770", winclass)) return NULL; // Message boxes
+ if (GetWindow(hwnd, GW_OWNER)) return NULL; // Dialog boxes, etc
+ if (exstyle & WS_EX_TOOLWINDOW) return NULL; // Floating toolbars
+ }
+
+ RECT rect = {};
+ GetWindowRect(hwnd, &rect);
+ win_t *win = new0(win_t);
+ win->x = rect.left;
+ win->y = rect.top;
+ win->w = rect.right - rect.left;
+ win->h = rect.bottom - rect.top;
+ win->sys = new0(win_sys_t);
+ win->sys->hwnd = hwnd;
+ printf("win_new: %p = %p (%d,%d %dx%d)\n", win, hwnd,
+ win->x, win->y, win->w, win->h);
+ return win;
+}
+
+static int win_cmp(const void *_a, const void *_b)
+{
+ const win_t *a = _a, *b = _b;
+ if (a->sys->hwnd < b->sys->hwnd) return -1;
+ if (a->sys->hwnd > b->sys->hwnd) return 1;
+ return 0;
+}
+
+static win_t *win_find(HWND hwnd, int create)
+{
+ if (!hwnd)
+ return NULL;
+ //printf("win_find: %p, %d\n", dpy, (int)xid);
+ win_sys_t sys = {.hwnd=hwnd};
+ win_t tmp = {.sys=&sys};
+ win_t **old = NULL, *new = NULL;
+ if ((old = tfind(&tmp, &cache, win_cmp)))
+ return *old;
+ if (create && (new = win_new(hwnd,1)))
+ tsearch(new, &cache, win_cmp);
+ return new;
+}
+
+static void win_remove(win_t *win)
+{
+ tdelete(win, &cache, win_cmp);
+ free(win->sys);
+ free(win);
+}
+
+static win_t *win_cursor(void)
+{
+ POINT wptr;
+ GetCursorPos(&wptr);
+ return win_find(GetAncestor(WindowFromPoint(wptr),GA_ROOT),0);
+}
+
+static win_t *win_focused(void)
+{
+ return win_find(GetForegroundWindow(),0);
+}
+
+/* Callbacks */
+LRESULT CALLBACK KbdProc(int msg, WPARAM wParam, LPARAM lParam)
+{
+ KBDLLHOOKSTRUCT *st = (KBDLLHOOKSTRUCT *)lParam;
+ event_t ev = w2ev(st->vkCode);
+ mod_t mod = getmod();
+ mod.up = !!(st->flags & 0x80);
+ printf("KbdProc: %d,%x,%lx - %lx,%lx,%lx - %x,%x\n",
+ msg, wParam, lParam,
+ st->vkCode, st->scanCode, st->flags,
+ ev, mod2int(mod));
+ return wm_handle_event(win_focused() ?: root, ev, mod, getptr())
+ || CallNextHookEx(0, msg, wParam, lParam);
+}
+
+LRESULT CALLBACK MllProc(int msg, WPARAM wParam, LPARAM lParam)
+{
+ event_t ev = EV_NONE;
+ mod_t mod = getmod();
+ win_t *win = win_cursor();
+
+ /* Update modifiers */
+ switch (wParam) {
+ case WM_LBUTTONDOWN: mod.up = 0; ev = EV_MOUSE1; break;
+ case WM_LBUTTONUP: mod.up = 1; ev = EV_MOUSE1; break;
+ case WM_RBUTTONDOWN: mod.up = 0; ev = EV_MOUSE3; break;
+ case WM_RBUTTONUP: mod.up = 1; ev = EV_MOUSE3; break;
+ }
+
+ /* Check for focus-in/focus-out */
+ static win_t *old = NULL;
+ if (win && win != old) {
+ wm_handle_event(old, EV_LEAVE, mod, getptr());
+ wm_handle_event(win, EV_ENTER, mod, getptr());
+ }
+ old = win;
+
+ /* Send mouse movement event */
+ if (wParam == WM_MOUSEMOVE)
+ return wm_handle_ptr(win_cursor(), getptr());
+ else if (ev != EV_NONE)
+ return wm_handle_event(win_cursor(), ev, mod, getptr());
+ else
+ return CallNextHookEx(0, msg, wParam, lParam);
+}
+
+LRESULT CALLBACK ShlProc(int msg, WPARAM wParam, LPARAM lParam)
+{
+ HWND hwnd = (HWND)wParam;
+ win_t *win = NULL;
+ switch (msg) {
+ case HSHELL_REDRAW:
+ case HSHELL_WINDOWCREATED:
+ printf("ShlProc: %p - %s\n", hwnd, msg == HSHELL_REDRAW ?
+ "redraw" : "window created");
+ if (!(win = win_find(hwnd,0)))
+ if ((win = win_find(hwnd,1)))
+ wm_insert(win);
+ return 1;
+ case HSHELL_WINDOWREPLACED:
+ case HSHELL_WINDOWDESTROYED:
+ printf("ShlProc: %p - %s\n", hwnd, msg == HSHELL_WINDOWREPLACED ?
+ "window replaced" : "window destroyed");
+ if ((win = win_find(hwnd,0)) &&
+ (win->state == ST_SHOW ||
+ win->state == ST_SHADE)) {
+ wm_remove(win);
+ win_remove(win);
+ }
+ return 1;
+ case HSHELL_WINDOWACTIVATED:
+ printf("ShlProc: %p - window activated\n", hwnd);
+ // Fake button-click (causes crazy switching)
+ //if ((win = win_find(hwnd,0)))
+ // wm_handle_event(win, EV_MOUSE1, MOD(), getptr());
+ return 0;
+ default:
+ printf("ShlProc: %p - unknown msg, %d\n", hwnd, msg);
+ return 0;
+ }
+}
+
+LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+ //printf("WndProc: %d, %x, %lx\n", msg, wParam, lParam);
+ switch (msg) {
+ case WM_CREATE: printf("WndProc: %p - create\n", hwnd); return 0;
+ case WM_CLOSE: printf("WndProc: %p - close\n", hwnd); return 0;
+ case WM_DESTROY: printf("WndProc: %p - destroy\n", hwnd); return 0;
+ case WM_HOTKEY: printf("WndProc: %p - hotkey\n", hwnd); return 0;
+ }
+ if (msg == shellhookid)
+ if (ShlProc(wParam, lParam, 0))
+ return 1;
+ return DefWindowProc(hwnd, msg, wParam, lParam);
+}
+
+BOOL CALLBACK MonProc(HMONITOR mon, HDC dc, LPRECT rect, LPARAM _screens)
+{
+ MONITORINFO info = {.cbSize=sizeof(MONITORINFO)};
+ GetMonitorInfo(mon, &info);
+ RECT *work = &info.rcWork;
+
+ list_t **screens = (list_t**)_screens;
+ win_t *screen = new0(win_t);
+ screen->x = work->left;
+ screen->y = work->top;
+ screen->z = !!(info.dwFlags & MONITORINFOF_PRIMARY);
+ screen->w = work->right - work->left;
+ screen->h = work->bottom - work->top;
+ *screens = list_append(*screens, screen);
+ printf("mon_proc: %d,%d %dx%d\n",
+ screen->x, screen->y, screen->w, screen->h);
+ return TRUE;
+}
+
+BOOL CALLBACK LoopProc(HWND hwnd, LPARAM user)
+{
+ win_t *win;
+ if ((win = win_find(hwnd,1)))
+ wm_insert(win);
+ return TRUE;
+}
+
+BOOL WINAPI CtrlProc(DWORD type)
+{
+ sys_exit();
+ return TRUE;
+}
+
+/********************
+ * System functions *
+ ********************/
+void sys_move(win_t *win, int x, int y, int w, int h)
+{
+ printf("sys_move: %p - %d,%d %dx%d\n", win, x, y, w, h);
+ win->x = x; win->y = y;
+ win->w = MAX(w,1); win->h = MAX(h,1);
+ MoveWindow(win->sys->hwnd, win->x, win->y, win->w, win->h, TRUE);
+}
+
+void sys_raise(win_t *win)
+{
+ printf("sys_raise: %p\n", win);
+
+ /* See note in sys_focus */
+ DWORD oldId = GetWindowThreadProcessId(GetForegroundWindow(), NULL);
+ DWORD newId = GetCurrentThreadId();
+ AttachThreadInput(oldId, newId, TRUE);
+
+ SetWindowPos(win->sys->hwnd, NULL, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
+
+ AttachThreadInput(oldId, newId, FALSE);
+}
+
+void sys_focus(win_t *win)
+{
+ printf("sys_focus: %p\n", win);
+
+ /* Windows prevents a thread from using SetForegroundInput under
+ * certain circumstances and instead flashes the windows toolbar icon.
+ * Attaching the thread input queues avoids this behavior */
+ HWND fgWin = GetForegroundWindow();
+ if (fgWin == win->sys->hwnd)
+ return; // already focused
+ DWORD oldId = GetWindowThreadProcessId(fgWin, NULL);
+ DWORD newId = GetCurrentThreadId();
+ if (oldId != newId)
+ AttachThreadInput(oldId, newId, TRUE);
+
+ HWND next = GetWindow(win->sys->hwnd, GW_HWNDNEXT);
+ SetWindowPos(win->sys->hwnd, NULL, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
+ if (next)
+ SetWindowPos(win->sys->hwnd, next, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
+
+ if (oldId != newId)
+ AttachThreadInput(oldId, newId, FALSE);
+}
+
+void sys_show(win_t *win, state_t state)
+{
+ static struct {
+ char *str;
+ int cmd;
+ } map[] = {
+ [ST_SHOW ] {"show" , SW_SHOW },
+ [ST_FULL ] {"full" , SW_MAXIMIZE},
+ [ST_SHADE] {"shade", SW_SHOW },
+ [ST_ICON ] {"icon" , SW_MINIMIZE},
+ [ST_HIDE ] {"hide" , SW_HIDE },
+ };
+ if (win->state != state && win->state == ST_SHADE)
+ SetWindowRgn(win->sys->hwnd, NULL, TRUE);
+ win->state = state;
+ printf("sys_show: %s\n", map[state].str);
+ ShowWindow(win->sys->hwnd, map[state].cmd);
+ if (state == ST_SHADE)
+ SetWindowRgn(win->sys->hwnd, CreateRectRgn(0,0,win->w,stack), TRUE);
+}
+
+void sys_watch(win_t *win, event_t ev, mod_t mod)
+{
+ (void)ev2w; // TODO
+ //printf("sys_watch: %p\n", win);
+}
+
+void sys_unwatch(win_t *win, event_t ev, mod_t mod)
+{
+ (void)ev2w; // TODO
+ //printf("sys_unwatch: %p\n", win);
+}
+
+list_t *sys_info(win_t *win)
+{
+ if (screens == NULL)
+ EnumDisplayMonitors(NULL, NULL, MonProc, (LPARAM)&screens);
+ return screens;
+}
+
+win_t *sys_init(void)
+{
+ HINSTANCE hInst = GetModuleHandle(NULL);
+ HWND hwnd = NULL;
+
+ /* Load configuration */
+ no_capture = conf_get_int("main.no-capture", no_capture);
+ stack = conf_get_int("main.stack", stack);
+
+ /* Setup window class */
+ WNDCLASSEX wc = {
+ .cbSize = sizeof(WNDCLASSEX),
+ .lpfnWndProc = WndProc,
+ .hInstance = hInst,
+ .lpszClassName = "wmpus_class",
+ };
+ if (!RegisterClassEx(&wc))
+ printf("sys_init: Error Registering Class - %lu\n", GetLastError());
+
+ /* Get work area */
+ RECT rc;
+ SystemParametersInfo(SPI_GETWORKAREA, 0, &rc, 0);
+
+ /* Create shell hook window */
+ if (!(hwnd = CreateWindowEx(0, "wmpus_class", "wmpus", 0,
+ rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top,
+ HWND_MESSAGE, NULL, hInst, NULL)))
+ printf("sys_init: Error Creating Shell Hook Window - %lu\n", GetLastError());
+
+ /* Register shell hook */
+ BOOL (*RegisterShellHookWindow)(HWND) = (void*)GetProcAddress(
+ GetModuleHandle("USER32.DLL"), "RegisterShellHookWindow");
+ if (!RegisterShellHookWindow)
+ printf("sys_init: Error Finding RegisterShellHookWindow - %lu\n", GetLastError());
+ if (!RegisterShellHookWindow(hwnd))
+ printf("sys_init: Error Registering ShellHook Window - %lu\n", GetLastError());
+ shellhookid = RegisterWindowMessage("SHELLHOOK");
+
+ /* Input hooks */
+ SetWindowsHookEx(WH_KEYBOARD_LL, KbdProc, hInst, 0);
+ SetWindowsHookEx(WH_MOUSE_LL, MllProc, hInst, 0);
+ //SetWindowsHookEx(WH_SHELL, ShlProc, hInst, 0);
+
+ /* Alternate ways to get input */
+ //if (!RegisterHotKey(hwnd, 123, MOD_CONTROL, VK_LBUTTON))
+ // printf("sys_init: Error Registering Hotkey - %lu\n", GetLastError());
+ //if (!RegisterHotKey(NULL, 123, MOD_CONTROL, VK_LBUTTON))
+ // printf("sys_init: Error Registering Hotkey - %lu\n", GetLastError());
+
+ /* Capture ctrl-c and console widnow close */
+ SetConsoleCtrlHandler(CtrlProc, TRUE);
+
+ return root = win_new(hwnd,0);
+}
+
+void sys_run(win_t *root)
+{
+ MSG msg = {};
+ if (!no_capture)
+ EnumWindows(LoopProc, 0);
+ while (GetMessage(&msg, NULL, 0, 0) > 0 &&
+ msg.message != WM_QUIT) {
+ TranslateMessage(&msg);
+ DispatchMessage(&msg);
+ }
+}
+
+void sys_exit(void)
+{
+ PostMessage(root->sys->hwnd, WM_QUIT, 0, 0);
+}
+
+void sys_free(win_t *root)
+{
+ /* I don't really care about this
+ * since I don't know how to use
+ * valgrind on win32 anyway.. */
+}
projects / wmpus / blobdiff