/* ______ ___ ___ * /\ _ \ /\_ \ /\_ \ * \ \ \L\ \\//\ \ \//\ \ __ __ _ __ ___ * \ \ __ \ \ \ \ \ \ \ /'__`\ /'_ `\/\`'__\/ __`\ * \ \ \/\ \ \_\ \_ \_\ \_/\ __//\ \L\ \ \ \//\ \L\ \ * \ \_\ \_\/\____\/\____\ \____\ \____ \ \_\\ \____/ * \/_/\/_/\/____/\/____/\/____/\/___L\ \/_/ \/___/ * /\____/ * \_/__/ * * New Windows system driver * * Based on the X11 OpenGL driver by Elias Pschernig. * * Heavily modified by Trent Gamblin. */ #include #include #include #include #include #include "allegro5/allegro.h" #include "allegro5/internal/aintern.h" #include "allegro5/internal/aintern_bitmap.h" #include "allegro5/internal/aintern_system.h" #include "allegro5/platform/aintwin.h" #include "allegro5/internal/aintern_wunicode.h" #if defined ALLEGRO_CFG_OPENGL #include "allegro5/allegro_opengl.h" #endif #include #include ALLEGRO_DEBUG_CHANNEL("system") /* FIXME: should we check for psapi _WIN32_IE and shlobj? { */ #include #if _WIN32_IE < 0x500 #undef _WIN32_IE #define _WIN32_IE 0x500 #endif #include #include /* } */ bool _al_win_disable_screensaver = false; static ALLEGRO_SYSTEM_INTERFACE *vt = 0; static bool using_higher_res_timer; static ALLEGRO_SYSTEM_WIN *_al_win_system; /* This is mostly here for _al_display_d3d_driver, which is stateful. */ static ALLEGRO_MUTEX* win_mutex; /* _WinMain: * Entry point for Windows GUI programs, hooked by a macro in alwin.h, * which makes it look as if the application can still have a normal * main() function. */ int _WinMain(void *_main, void *hInst, void *hPrev, char *Cmd, int nShow) { int (*mainfunc) (int argc, char *argv[]) = (int (*)(int, char *[]))_main; char *argbuf; char **argv; int argc; int argc_max; int i, q; (void)hInst; (void)hPrev; (void)Cmd; (void)nShow; /* can't use parameter because it doesn't include the executable name */ argbuf = _twin_tchar_to_utf8(GetCommandLine()); argc = 0; argc_max = 64; argv = al_malloc(sizeof(char *) * argc_max); if (!argv) { al_free(argbuf); return 1; } i = 0; /* parse commandline into argc/argv format */ while (argbuf[i]) { while ((argbuf[i]) && (isspace(argbuf[i]))) i++; if (argbuf[i]) { if ((argbuf[i] == '\'') || (argbuf[i] == '"')) { q = argbuf[i++]; if (!argbuf[i]) break; } else q = 0; argv[argc++] = &argbuf[i]; if (argc >= argc_max) { argc_max += 64; argv = al_realloc(argv, sizeof(char *) * argc_max); if (!argv) { al_free(argbuf); return 1; } } while ((argbuf[i]) && ((q) ? (argbuf[i] != q) : (!isspace(argbuf[i])))) i++; if (argbuf[i]) { argbuf[i] = 0; i++; } } } argv[argc] = NULL; /* call the application entry point */ i = mainfunc(argc, argv); al_free(argv); al_free(argbuf); return i; } static void set_dpi_awareness(void) { bool dpi_awareness_set = false; /* We load the shcore DLL and the APIs dynamically because these are * not often included in MinGW headers. */ HMODULE shcore_dll = _al_win_safe_load_library("shcore.dll"); if (shcore_dll) { typedef enum _AL_PROCESS_DPI_AWARENESS { AL_PROCESS_DPI_UNAWARE = 0, AL_PROCESS_SYSTEM_DPI_AWARE = 1, AL_PROCESS_PER_MONITOR_DPI_AWARE = 2 } AL_PROCESS_DPI_AWARENESS; typedef HRESULT (WINAPI *SetProcessDpiAwarenessPROC)(AL_PROCESS_DPI_AWARENESS); SetProcessDpiAwarenessPROC imp_SetProcessDpiAwareness = (SetProcessDpiAwarenessPROC)GetProcAddress(shcore_dll, "SetProcessDpiAwareness"); if (imp_SetProcessDpiAwareness) { /* Try setting the per-monitor awareness first. It might fail on Win 8.1. */ HRESULT ret = imp_SetProcessDpiAwareness(AL_PROCESS_PER_MONITOR_DPI_AWARE); if (ret == E_INVALIDARG) { ret = imp_SetProcessDpiAwareness(AL_PROCESS_SYSTEM_DPI_AWARE); } if (ret == S_OK) { dpi_awareness_set = true; } } FreeLibrary(shcore_dll); } /* SetProcessDPIAware is an older API that corresponds to system dpi * awareness above. This is the only option on pre-8.1 systems. */ if (!dpi_awareness_set) { HMODULE user32_dll = _al_win_safe_load_library("user32.dll"); if (user32_dll) { typedef BOOL (WINAPI *SetProcessDPIAwarePROC)(void); SetProcessDPIAwarePROC imp_SetProcessDPIAware = (SetProcessDPIAwarePROC)GetProcAddress(user32_dll, "SetProcessDPIAware"); if (imp_SetProcessDPIAware) { imp_SetProcessDPIAware(); } FreeLibrary(user32_dll); } } } /* Create a new system object. */ static ALLEGRO_SYSTEM *win_initialize(int flags) { (void)flags; set_dpi_awareness(); _al_win_system = al_calloc(1, sizeof *_al_win_system); // Request a 1ms resolution from our timer if (timeBeginPeriod(1) != TIMERR_NOCANDO) { using_higher_res_timer = true; } _al_win_init_time(); _al_win_init_window(); _al_vector_init(&_al_win_system->system.displays, sizeof (ALLEGRO_SYSTEM_WIN *)); _al_win_system->system.vt = vt; win_mutex = al_create_mutex(); return &_al_win_system->system; } static void win_shutdown(void) { ALLEGRO_SYSTEM *s; ASSERT(vt); /* Close all open displays. */ s = al_get_system_driver(); while (_al_vector_size(&s->displays) > 0) { ALLEGRO_DISPLAY **dptr = _al_vector_ref(&s->displays, 0); ALLEGRO_DISPLAY *d = *dptr; al_destroy_display(d); } _al_vector_free(&s->displays); #ifdef ALLEGRO_CFG_D3D _al_d3d_shutdown_display(); #endif _al_win_shutdown_window(); _al_win_shutdown_time(); if (using_higher_res_timer) { timeEndPeriod(1); } al_free(vt); vt = NULL; al_destroy_mutex(win_mutex); ASSERT(_al_win_system); al_free(_al_win_system); } static ALLEGRO_DISPLAY_INTERFACE *win_get_display_driver(void) { const int flags = al_get_new_display_flags(); ALLEGRO_SYSTEM *sys = al_get_system_driver(); ALLEGRO_CONFIG *sys_cfg = al_get_system_config(); ALLEGRO_SYSTEM_WIN *syswin = (ALLEGRO_SYSTEM_WIN *)sys; const char *s; /* Look up the toggle_mouse_grab_key binding. This isn't such a great place * to do it, but the config file is not available in win_initialize, * and this is neutral between the D3D and OpenGL display drivers. */ if (!syswin->toggle_mouse_grab_keycode) { const char *binding = al_get_config_value(sys_cfg, "keyboard", "toggle_mouse_grab_key"); if (binding) { syswin->toggle_mouse_grab_keycode = _al_parse_key_binding(binding, &syswin->toggle_mouse_grab_modifiers); if (syswin->toggle_mouse_grab_keycode) { ALLEGRO_DEBUG("Toggle mouse grab key: '%s'\n", binding); } else { ALLEGRO_WARN("Cannot parse key binding '%s'\n", binding); } } } /* Programmatic selection. */ #ifdef ALLEGRO_CFG_D3D if (flags & ALLEGRO_DIRECT3D_INTERNAL) { al_lock_mutex(win_mutex); ALLEGRO_DISPLAY_INTERFACE* iface = _al_display_d3d_driver(); al_unlock_mutex(win_mutex); if (iface == NULL) ALLEGRO_WARN("Direct3D graphics driver not available.\n"); return iface; } #endif #ifdef ALLEGRO_CFG_OPENGL if (flags & ALLEGRO_OPENGL) { return _al_display_wgl_driver(); } #endif /* Selection by configuration file. The configuration value is non-binding. * The user may unknowingly set a value which was configured out at compile * time. The value should have no effect instead of causing a failure. */ s = al_get_config_value(sys_cfg, "graphics", "driver"); if (s) { ALLEGRO_DEBUG("Configuration value graphics.driver = %s\n", s); if (0 == _al_stricmp(s, "DIRECT3D") || 0 == _al_stricmp(s, "D3D")) { #ifdef ALLEGRO_CFG_D3D al_lock_mutex(win_mutex); ALLEGRO_DISPLAY_INTERFACE* iface = _al_display_d3d_driver(); al_unlock_mutex(win_mutex); if (iface != NULL) { al_set_new_display_flags(flags | ALLEGRO_DIRECT3D_INTERNAL); return iface; } #endif } else if (0 == _al_stricmp(s, "OPENGL")) { #ifdef ALLEGRO_CFG_OPENGL al_set_new_display_flags(flags | ALLEGRO_OPENGL); return _al_display_wgl_driver(); #endif } else if (0 != _al_stricmp(s, "DEFAULT")) { ALLEGRO_WARN("Graphics driver selection unrecognised: %s\n", s); } } /* Automatic graphics driver selection. */ /* XXX is implicitly setting new_display_flags the desired behaviour? */ #ifdef ALLEGRO_CFG_D3D { al_lock_mutex(win_mutex); ALLEGRO_DISPLAY_INTERFACE* iface = _al_display_d3d_driver(); al_unlock_mutex(win_mutex); if (iface != NULL) { al_set_new_display_flags(flags | ALLEGRO_DIRECT3D_INTERNAL); return iface; } } #endif #ifdef ALLEGRO_CFG_OPENGL { al_set_new_display_flags(flags | ALLEGRO_OPENGL); return _al_display_wgl_driver(); } #endif ALLEGRO_WARN("No graphics driver available.\n"); return NULL; } /* FIXME: use the list */ static ALLEGRO_KEYBOARD_DRIVER *win_get_keyboard_driver(void) { return _al_keyboard_driver_list[0].driver; } /* Checks whether the configured joystick driver is of the given name. * Also returns false if the configuration entry was not set. */ static bool win_configured_joystick_driver_is(const char * name) { const char * driver; ALLEGRO_CONFIG * sysconf = al_get_system_config(); if (!sysconf) return false; driver = al_get_config_value(sysconf, "joystick", "driver"); if (!driver) return false; ALLEGRO_DEBUG("Configuration value joystick.driver = %s\n", driver); return (0 == _al_stricmp(driver, name)); } /* Checks whether xinput should be used or not not according * to configuration. */ static bool win_use_xinput(void) { return win_configured_joystick_driver_is("XINPUT"); } /* Checks whether directinput should be used or not not according * to configuration. */ static bool win_use_directinput(void) { return win_configured_joystick_driver_is("DIRECTINPUT"); } /* By default the combined xinput/directinput driver is used unless directinput * or xinput exclusive is set.*/ static ALLEGRO_JOYSTICK_DRIVER *win_get_joystick_driver(void) { if (win_use_directinput()) { ALLEGRO_DEBUG("Selected DirectInput joystick driver.\n"); return &_al_joydrv_directx; } if (win_use_xinput()) { #ifdef ALLEGRO_CFG_XINPUT ALLEGRO_DEBUG("Selected XInput joystick driver.\n"); return &_al_joydrv_xinput; #else ALLEGRO_WARN("XInput joystick driver not supported.\n"); #endif } #ifdef ALLEGRO_CFG_XINPUT ALLEGRO_DEBUG("Selected combined XInput/DirectInput joystick driver.\n"); return &_al_joydrv_windows_all; #else ALLEGRO_WARN("Combined XInput/DirectInput joystick driver not supported. Usign DirectInput in stead.\n"); return &_al_joydrv_directx; #endif } /* By default the combined haptic driver is used unless directinput or * xinput exclusive is set in the configuration.*/ static ALLEGRO_HAPTIC_DRIVER *win_get_haptic_driver(void) { if (win_use_directinput()) { ALLEGRO_DEBUG("Selected DirectInput haptic driver.\n"); return &_al_hapdrv_directx; } if (win_use_xinput()) { #ifdef ALLEGRO_CFG_XINPUT ALLEGRO_DEBUG("Selected XInput haptic driver.\n"); return &_al_hapdrv_xinput; #else ALLEGRO_WARN("XInput haptic driver not supported.\n"); #endif } #ifdef ALLEGRO_CFG_XINPUT ALLEGRO_DEBUG("Selected combined XInput/DirectInput haptic driver.\n"); return &_al_hapdrv_windows_all; #else ALLEGRO_WARN("Combined XInput/DirectInput haptic driver not supported. Using DirectInput in stead.\n"); return &_al_hapdrv_directx; #endif } static int win_get_num_display_modes(void) { int format = _al_deduce_color_format(_al_get_new_display_settings()); int refresh_rate = al_get_new_display_refresh_rate(); int flags = al_get_new_display_flags(); #if defined ALLEGRO_CFG_OPENGL if (flags & ALLEGRO_OPENGL) { return _al_wgl_get_num_display_modes(format, refresh_rate, flags); } #endif #if defined ALLEGRO_CFG_D3D return _al_d3d_get_num_display_modes(format, refresh_rate, flags); #endif return 0; } static ALLEGRO_DISPLAY_MODE *win_get_display_mode(int index, ALLEGRO_DISPLAY_MODE *mode) { int format = _al_deduce_color_format(_al_get_new_display_settings()); int refresh_rate = al_get_new_display_refresh_rate(); int flags = al_get_new_display_flags(); #if defined ALLEGRO_CFG_OPENGL if (flags & ALLEGRO_OPENGL) { return _al_wgl_get_display_mode(index, format, refresh_rate, flags, mode); } #endif #if defined ALLEGRO_CFG_D3D return _al_d3d_get_display_mode(index, format, refresh_rate, flags, mode); #endif return NULL; } static int win_get_num_video_adapters(void) { DISPLAY_DEVICE dd; int count = 0; int c = 0; memset(&dd, 0, sizeof(dd)); dd.cb = sizeof(dd); while (EnumDisplayDevices(NULL, count, &dd, 0) != false) { if (dd.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP) c++; count++; } return c; } static int win_find_nth_adapter_with_desktop(DISPLAY_DEVICE* pdd, int adapter) { int count = 0; int c = 0; while (EnumDisplayDevices(NULL, count, pdd, 0)) { if (pdd->StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP) { if (c == adapter) return true; c++; } count++; } return false; } static int win_get_monitor_refresh_rate(int adapter) { DISPLAY_DEVICE dd; DEVMODE dm; memset(&dd, 0, sizeof(dd)); dd.cb = sizeof(dd); if (!win_find_nth_adapter_with_desktop(&dd, adapter)) { return 0; } memset(&dm, 0, sizeof(dm)); dm.dmSize = sizeof(dm); if (!EnumDisplaySettings(dd.DeviceName, ENUM_CURRENT_SETTINGS, &dm)) { return 0; } return dm.dmDisplayFrequency; } static bool win_get_monitor_info(int adapter, ALLEGRO_MONITOR_INFO *info) { DISPLAY_DEVICE dd; DEVMODE dm; memset(&dd, 0, sizeof(dd)); dd.cb = sizeof(dd); if (!win_find_nth_adapter_with_desktop(&dd, adapter)) { return false; } memset(&dm, 0, sizeof(dm)); dm.dmSize = sizeof(dm); if (!EnumDisplaySettings(dd.DeviceName, ENUM_CURRENT_SETTINGS, &dm)) { return false; } ASSERT(dm.dmFields & DM_PELSHEIGHT); ASSERT(dm.dmFields & DM_PELSWIDTH); /* Disabled this assertion for now as it fails under Wine 1.2. */ /* ASSERT(dm.dmFields & DM_POSITION); */ info->x1 = dm.dmPosition.x; info->y1 = dm.dmPosition.y; info->x2 = info->x1 + dm.dmPelsWidth; info->y2 = info->y1 + dm.dmPelsHeight; return true; } static BOOL CALLBACK monitor_enum_proc(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData) { HMONITOR *h_monitor = (HMONITOR *) dwData; (void)hdcMonitor; (void)lprcMonitor; if (hMonitor) { *h_monitor = hMonitor; return false; } return true; } static HMONITOR win_get_monitor(ALLEGRO_MONITOR_INFO *info) { HMONITOR h_monitor; RECT rect; rect.left = info->x1; rect.top = info->y1; rect.right = info->x2; rect.bottom = info->y2; EnumDisplayMonitors(NULL, &rect, monitor_enum_proc, (LPARAM) &h_monitor); return h_monitor; } static int win_get_monitor_dpi(int adapter) { ALLEGRO_MONITOR_INFO info; HMODULE shcore_dll = _al_win_safe_load_library("shcore.dll"); UINT dpi_hori; UINT dpi_vert; typedef enum _AL_MONITOR_DPI_TYPE { AL_MDT_EFFECTIVE_DPI = 0, AL_MDT_ANGULAR_DPI = 1, AL_MDT_RAW_DPI = 2, AL_MDT_DEFAULT = AL_MDT_EFFECTIVE_DPI } AL_MONITOR_DPI_TYPE; typedef HRESULT (WINAPI *GetDpiForMonitorPROC)(HMONITOR hmonitor, AL_MONITOR_DPI_TYPE dpiType, UINT *dpiX, UINT *dpiY); GetDpiForMonitorPROC imp_GetDpiForMonitor = (GetDpiForMonitorPROC) GetProcAddress(shcore_dll, "GetDpiForMonitor"); if (!shcore_dll) { FreeLibrary(shcore_dll); return 0; } if (!win_get_monitor_info(adapter, &info)) { FreeLibrary(shcore_dll); return 0; } imp_GetDpiForMonitor(win_get_monitor(&info), 0, &dpi_hori, &dpi_vert); FreeLibrary(shcore_dll); return sqrt(dpi_hori * dpi_vert); } static bool win_get_cursor_position(int *ret_x, int *ret_y) { POINT p; GetCursorPos(&p); *ret_x = p.x; *ret_y = p.y; return true; } static bool win_grab_mouse(ALLEGRO_DISPLAY *display) { ALLEGRO_SYSTEM_WIN *system = (void *)al_get_system_driver(); ALLEGRO_DISPLAY_WIN *win_disp = (void *)display; RECT rect; GetWindowRect(win_disp->window, &rect); if (ClipCursor(&rect) != 0) { system->mouse_grab_display = display; return true; } return false; } static bool win_ungrab_mouse(void) { ALLEGRO_SYSTEM_WIN *system = (void *)al_get_system_driver(); ClipCursor(NULL); system->mouse_grab_display = NULL; return true; } static ALLEGRO_MOUSE_DRIVER *win_get_mouse_driver(void) { return _al_mouse_driver_list[0].driver; } static ALLEGRO_TOUCH_INPUT_DRIVER *win_get_touch_input_driver(void) { return _al_touch_input_driver_list[0].driver; } /* _al_win_get_path: * Returns full path to various system and user diretories */ ALLEGRO_PATH *_al_win_get_path(int id) { char path[MAX_PATH]; wchar_t pathw[MAX_PATH]; ALLEGRO_USTR *pathu; uint32_t csidl = 0; HRESULT ret = 0; ALLEGRO_PATH *cisdl_path = NULL; switch (id) { case ALLEGRO_TEMP_PATH: { /* Check: TMP, TMPDIR, TEMP or TEMPDIR */ DWORD ret = GetTempPathW(MAX_PATH, pathw); if (ret > MAX_PATH) { /* should this ever happen, windows is more broken than I ever thought */ return NULL; } pathu = al_ustr_new_from_utf16(pathw); al_ustr_to_buffer(pathu, path, sizeof path); al_ustr_free(pathu); return al_create_path_for_directory(path); } break; case ALLEGRO_RESOURCES_PATH: { /* where the program is in */ HANDLE process = GetCurrentProcess(); char *ptr; GetModuleFileNameExW(process, NULL, pathw, MAX_PATH); pathu = al_ustr_new_from_utf16(pathw); al_ustr_to_buffer(pathu, path, sizeof path); al_ustr_free(pathu); ptr = strrchr(path, '\\'); if (!ptr) { /* shouldn't happen */ return NULL; } /* chop off everything including and after the last slash */ /* should this not chop the slash? */ *ptr = '\0'; return al_create_path_for_directory(path); } break; case ALLEGRO_USER_DATA_PATH: /* CSIDL_APPDATA */ case ALLEGRO_USER_SETTINGS_PATH: csidl = CSIDL_APPDATA; break; case ALLEGRO_USER_HOME_PATH: /* CSIDL_PROFILE */ csidl = CSIDL_PROFILE; break; case ALLEGRO_USER_DOCUMENTS_PATH: /* CSIDL_PERSONAL */ csidl = CSIDL_PERSONAL; break; case ALLEGRO_EXENAME_PATH: { /* full path to the exe including its name */ HANDLE process = GetCurrentProcess(); GetModuleFileNameExW(process, NULL, pathw, MAX_PATH); pathu = al_ustr_new_from_utf16(pathw); al_ustr_to_buffer(pathu, path, sizeof path); al_ustr_free(pathu); return al_create_path(path); } break; default: return NULL; } ret = SHGetFolderPathW(NULL, csidl, NULL, SHGFP_TYPE_CURRENT, pathw); if (ret != S_OK) { return NULL; } pathu = al_ustr_new_from_utf16(pathw); al_ustr_to_buffer(pathu, path, sizeof path); al_ustr_free(pathu); cisdl_path = al_create_path_for_directory(path); if (!cisdl_path) return NULL; if (csidl == CSIDL_APPDATA) { const char *org_name = al_get_org_name(); const char *app_name = al_get_app_name(); if (!app_name || !app_name[0]) { /* this shouldn't ever happen. */ al_destroy_path(cisdl_path); return NULL; } if (org_name && org_name[0]) { al_append_path_component(cisdl_path, org_name); } al_append_path_component(cisdl_path, app_name); } return cisdl_path; } static bool win_inhibit_screensaver(bool inhibit) { _al_win_disable_screensaver = inhibit; return true; } static HMODULE load_library_at_path(const TCHAR *path_str) { HMODULE lib; /* * XXX LoadLibrary will search the current directory for any dependencies of * the library we are loading. Using LoadLibraryEx with the appropriate * flags would fix that, but when I tried it I was unable to load dsound.dll * on Vista. */ char* upath_str = _twin_tchar_to_utf8(path_str); ALLEGRO_DEBUG("Calling LoadLibrary %s\n", upath_str); lib = LoadLibrary(path_str); if (lib) { ALLEGRO_INFO("Loaded %s\n", upath_str); } else { DWORD error = GetLastError(); HRESULT hr = HRESULT_FROM_WIN32(error); /* XXX do something with it */ (void)hr; ALLEGRO_WARN("Failed to load %s (error: %ld)\n", upath_str, error); } al_free(upath_str); return lib; } static bool is_build_config_name(const char *s) { return s && ( 0 == strcmp(s, "Debug") || 0 == strcmp(s, "Release") || 0 == strcmp(s, "RelWithDebInfo") || 0 == strcmp(s, "Profile")); } static ALLEGRO_PATH *maybe_parent_dir(const ALLEGRO_PATH *path) { ALLEGRO_PATH *path2; if (!path) return NULL; if (!is_build_config_name(al_get_path_tail(path))) return NULL; path2 = al_clone_path(path); if (path2) { al_drop_path_tail(path2); al_set_path_filename(path2, NULL); ALLEGRO_DEBUG("Also searching %s\n", al_path_cstr(path2, '\\')); } return path2; } /* * Calling LoadLibrary with a relative file name is a security risk: * see e.g. Microsoft Security Advisory (2269637) * "Insecure Library Loading Could Allow Remote Code Execution" */ HMODULE _al_win_safe_load_library(const char *filename) { ALLEGRO_PATH *path1 = NULL; ALLEGRO_PATH *path2 = NULL; TCHAR buf[MAX_PATH]; const TCHAR *other_dirs[3]; HMODULE lib = NULL; bool msvc_only = false; TCHAR* tfilename; /* MSVC only: if the executable is in the build configuration directory, * which is also just under the current directory, then also try to load the * library from the current directory. This leads to less surprises when * running example programs. */ #if defined(ALLEGRO_MSVC) msvc_only = true; #endif /* Try to load the library from the directory containing the running * executable, the Windows system directories, or directories on the PATH. * Do NOT try to load the library from the current directory. */ if (al_is_system_installed()) { path1 = al_get_standard_path(ALLEGRO_RESOURCES_PATH); } else if (GetModuleFileName(NULL, buf, sizeof(buf)) < sizeof(buf)) { char* tmp = _twin_tchar_to_utf8(buf); path1 = al_create_path(tmp); al_free(tmp); } if (msvc_only) { path2 = maybe_parent_dir(path1); } other_dirs[0] = path1 ? _twin_ustr_to_tchar(al_path_ustr(path1, '\\')) : NULL; other_dirs[1] = path2 ? _twin_ustr_to_tchar(al_path_ustr(path2, '\\')) : NULL; other_dirs[2] = NULL; /* sentinel */ tfilename = _twin_utf8_to_tchar(filename); _tcsncpy(buf, tfilename, MAX_PATH); al_free(tfilename); if (PathFindOnPath(buf, other_dirs)) { char* tmp = _twin_tchar_to_utf8(buf); ALLEGRO_DEBUG("PathFindOnPath found: %s\n", tmp); al_free(tmp); lib = load_library_at_path(buf); } else { ALLEGRO_WARN("PathFindOnPath failed to find %s\n", filename); } al_free((void*) other_dirs[0]); al_free((void*) other_dirs[1]); al_destroy_path(path1); al_destroy_path(path2); return lib; } static void *win_open_library(const char *filename) { return _al_win_safe_load_library(filename); } static void *win_import_symbol(void *library, const char *symbol) { ASSERT(library); return GetProcAddress(library, symbol); } static void win_close_library(void *library) { ASSERT(library); FreeLibrary(library); } static ALLEGRO_SYSTEM_INTERFACE *_al_system_win_driver(void) { if (vt) return vt; vt = al_calloc(1, sizeof *vt); vt->id = ALLEGRO_SYSTEM_ID_WINDOWS; vt->initialize = win_initialize; vt->get_display_driver = win_get_display_driver; vt->get_keyboard_driver = win_get_keyboard_driver; vt->get_mouse_driver = win_get_mouse_driver; vt->get_touch_input_driver = win_get_touch_input_driver; vt->get_haptic_driver = win_get_haptic_driver; vt->get_joystick_driver = win_get_joystick_driver; vt->get_num_display_modes = win_get_num_display_modes; vt->get_display_mode = win_get_display_mode; vt->shutdown_system = win_shutdown; vt->get_num_video_adapters = win_get_num_video_adapters; vt->create_mouse_cursor = _al_win_create_mouse_cursor; vt->destroy_mouse_cursor = _al_win_destroy_mouse_cursor; vt->get_monitor_info = win_get_monitor_info; vt->get_monitor_dpi = win_get_monitor_dpi; vt->get_monitor_refresh_rate = win_get_monitor_refresh_rate; vt->get_cursor_position = win_get_cursor_position; vt->grab_mouse = win_grab_mouse; vt->ungrab_mouse = win_ungrab_mouse; vt->get_path = _al_win_get_path; vt->inhibit_screensaver = win_inhibit_screensaver; vt->open_library = win_open_library; vt->import_symbol = win_import_symbol; vt->close_library = win_close_library; vt->get_time = _al_win_get_time; vt->rest = _al_win_rest; vt->init_timeout = _al_win_init_timeout; return vt; } void _al_register_system_interfaces() { ALLEGRO_SYSTEM_INTERFACE **add; add = _al_vector_alloc_back(&_al_system_interfaces); *add = _al_system_win_driver(); } const char* _al_win_error(DWORD err) { LPTSTR msg = NULL; int len; static char buf[2048]; len = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, NULL, err, 0, (LPTSTR)&msg, 0, NULL); if (len == 0) { _al_sane_strncpy(buf, "(Unable to decode the error code)", sizeof(buf)); } else { /* Truncate trailing CRLF if it has one */ if (len >= 2 && _tcscmp(msg + len - 2, TEXT("\r\n")) == 0) { msg[len - 2] = (TCHAR)0; } _twin_copy_tchar_to_utf8(buf, msg, sizeof(buf)); LocalFree(msg); } return buf; } const char* _al_win_last_error() { return _al_win_error(GetLastError()); } /* vim: set sts=3 sw=3 et: */