X-Git-Url: http://pileus.org/git/?p=wmpus;a=blobdiff_plain;f=sys-win32.c;h=34d5c508bd062b77b508b1b3772b18c09cbaf7b5;hp=f6479c5fdc1dabaf233f09c9e3d4811745bffb40;hb=20508b0053a5925ca15f17813ca9176659d06ae1;hpb=078801ca18f69b82db8174109e1d1112fb98d1eb diff --git a/sys-win32.c b/sys-win32.c index f6479c5..34d5c50 100644 --- a/sys-win32.c +++ b/sys-win32.c @@ -1,20 +1,37 @@ +/* + * Copyright (c) 2011, Andy Spencer + * + * 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 #include #include +#include #define WIN32_LEAN_AND_MEAN -#define _WIN32_WINNT 0x0500 +#define _WIN32_WINNT 0x0501 #include #include #include #include "util.h" +#include "conf.h" #include "sys.h" #include "wm.h" -int test; -int shellhookid; -mod_t mod_state; +/* Configuration */ +static int no_capture = 0; +static int stack = 25; /* Internal structures */ struct win_sys { @@ -22,72 +39,99 @@ struct win_sys { }; typedef struct { - Key_t key; - int vk; -} keymap_t; + 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 */ -keymap_t key2vk[] = { - {key_mouse1 , VK_LBUTTON }, - {key_mouse2 , VK_MBUTTON }, - {key_mouse3 , VK_RBUTTON }, - {key_left , VK_LEFT }, - {key_right , VK_RIGHT }, - {key_up , VK_UP }, - {key_down , VK_DOWN }, - {key_home , VK_HOME }, - {key_end , VK_END }, - {key_pageup , VK_PRIOR }, - {key_pagedown, VK_NEXT }, - {key_f1 , VK_F1 }, - {key_f2 , VK_F2 }, - {key_f3 , VK_F3 }, - {key_f4 , VK_F4 }, - {key_f5 , VK_F5 }, - {key_f6 , VK_F6 }, - {key_f7 , VK_F7 }, - {key_f8 , VK_F8 }, - {key_f9 , VK_F9 }, - {key_f10 , VK_F10 }, - {key_f11 , VK_F11 }, - {key_f12 , VK_F12 }, - {key_shift , VK_SHIFT }, - {key_shift , VK_LSHIFT }, - {key_shift , VK_RSHIFT }, - {key_ctrl , VK_CONTROL }, - {key_ctrl , VK_LCONTROL}, - {key_ctrl , VK_RCONTROL}, - {key_alt , VK_MENU }, - {key_alt , VK_LMENU }, - {key_alt , VK_RMENU }, - {key_win , VK_LWIN }, - {key_win , VK_RWIN }, +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 */ -Key_t w2key(UINT vk) +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) { - keymap_t *km = map_getr(key2vk,vk); - return km ? km->key : vk; + event_map_t *em = map_get(ev2vk,ev); + return em ? em->vk : toupper(ev); } -UINT key2w(Key_t key) +static mod_t getmod(void) { - keymap_t *km = map_get(key2vk,key); - return km ? km->vk : toupper(key); + 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 */ -ptr_t getptr(void) +static ptr_t getptr(void) { POINT wptr; GetCursorPos(&wptr); return (ptr_t){-1, -1, wptr.x, wptr.y}; } -/* Helper functions */ -win_t *win_new(HWND hwnd) +/* 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); @@ -97,146 +141,347 @@ win_t *win_new(HWND hwnd) 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; - Key_t key = w2key(st->vkCode); - mod_state.up = !!(st->flags & 0x80); - if (key == key_alt ) mod_state.alt = !mod_state.up; - if (key == key_ctrl ) mod_state.ctrl = !mod_state.up; - if (key == key_shift) mod_state.shift = !mod_state.up; - if (key == key_win ) mod_state.win = !mod_state.up; + 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, - key, mod2int(mod_state)); - HWND fghwnd = GetForegroundWindow(); - wm_handle_key(win_new(fghwnd), key, mod_state, getptr()); - return CallNextHookEx(0, msg, wParam, lParam); + 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) { - Key_t key = key_none; - HWND fghwnd = GetForegroundWindow(); + event_t ev = EV_NONE; + mod_t mod = getmod(); + win_t *win = win_cursor(); + + /* Update modifiers */ switch (wParam) { - case WM_LBUTTONDOWN: mod_state.up = 0; key = key_mouse1; break; - case WM_LBUTTONUP: mod_state.up = 1; key = key_mouse1; break; - case WM_RBUTTONDOWN: mod_state.up = 0; key = key_mouse3; break; - case WM_RBUTTONUP: mod_state.up = 1; key = key_mouse3; break; + 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_new(fghwnd), getptr()); - else if (key != key_none) - return wm_handle_key(win_new(fghwnd), key, mod_state, getptr()); + 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 ShlWndProc(HWND hwnd, int msg, WPARAM wParam, LPARAM lParam) +LRESULT CALLBACK ShlProc(int msg, WPARAM wParam, LPARAM lParam) { - printf("ShlWndProc: %d, %x, %lx\n", msg, wParam, lParam); - switch (wParam) { + HWND hwnd = (HWND)wParam; + win_t *win = NULL; + switch (msg) { + case HSHELL_REDRAW: case HSHELL_WINDOWCREATED: - printf("ShlProc: window created\n"); - return 0; + 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: window destroyed\n"); - return 0; + 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: window activated\n"); + 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; } - return DefWindowProc(hwnd, msg, wParam, lParam); } LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { - printf("WndProc: %d, %x, %lx\n", msg, wParam, lParam); + //printf("WndProc: %d, %x, %lx\n", msg, wParam, lParam); switch (msg) { - case WM_CREATE: - case WM_CLOSE: - case WM_DESTROY: - return 0; - } - if (msg == shellhookid) { - printf("WndProc: shellhook\n"); - return ShlWndProc(hwnd, msg, wParam, lParam); + 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); } -/***************** - * Sys functions * - *****************/ +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); - MoveWindow(win->sys->hwnd, x, y, w, h, TRUE); + 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, Key_t key, mod_t mod) +void sys_watch(win_t *win, event_t ev, mod_t mod) { - printf("sys_watch: %p\n", win); + (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); - test = 123; - - /* Class */ - WNDCLASSEX wc = {}; - wc.cbSize = sizeof(WNDCLASSEX); - wc.lpfnWndProc = WndProc; - wc.hInstance = hInst; - wc.lpszClassName = "awm_class"; + 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()); - /* Bargh!? */ - HWND hwnd = CreateWindowEx(0, "awm_class", "awm", 0, - 0, 0, 0, 0, HWND_MESSAGE, NULL, hInst, NULL); - if (!hwnd) - printf("sys_init: Error Creating Window - %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()); - /* Try Shell Hook Window */ - HINSTANCE hInstUser32 = GetModuleHandle("USER32.DLL"); - BOOL (*RegisterShellHookWindow)(HWND hwnd) = (void*)GetProcAddress(hInstUser32, "RegisterShellHookWindow"); + /* 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"); - /* Register other hooks for testing */ - SetWindowsHookEx(WH_MOUSE_LL, MllProc, hInst, 0); + /* 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()); + //if (!RegisterHotKey(NULL, 123, MOD_CONTROL, VK_LBUTTON)) + // printf("sys_init: Error Registering Hotkey - %lu\n", GetLastError()); - return win_new(hwnd); + /* Capture ctrl-c and console widnow close */ + SetConsoleCtrlHandler(CtrlProc, TRUE); + return root = win_new(hwnd,0); } void sys_run(win_t *root) { - MSG msg; - while (GetMessage(&msg, NULL, 0, 0) > 0) { + 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.. */ +}