From 8a22b1b13cbd23e4d0a0a1cf3da9c84596b55280 Mon Sep 17 00:00:00 2001 From: MikalaiR Date: Thu, 7 Jan 2016 12:25:32 +0000 Subject: MirLua: WinAPI module moved to external library git-svn-id: http://svn.miranda-ng.org/main/trunk@16045 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c --- plugins/MirLua/Modules/WinAPI/WinAPI.vcxproj | 36 + plugins/MirLua/Modules/WinAPI/src/stdafx.cxx | 1 + plugins/MirLua/Modules/WinAPI/src/stdafx.h | 69 + plugins/MirLua/Modules/WinAPI/src/winapi.cpp | 2157 +++++++++++++++++++++++++ plugins/MirLua/Modules/common.filters | 32 + plugins/MirLua/Modules/common.props | 98 ++ plugins/MirLua/Modules/module.props | 31 + plugins/MirLua/src/m_hotkeys.cpp | 3 +- plugins/MirLua/src/m_windows.cpp | 2224 -------------------------- plugins/MirLua/src/mlua_module_loader.cpp | 5 +- plugins/MirLua/src/stdafx.h | 2 - 11 files changed, 2427 insertions(+), 2231 deletions(-) create mode 100644 plugins/MirLua/Modules/WinAPI/WinAPI.vcxproj create mode 100644 plugins/MirLua/Modules/WinAPI/src/stdafx.cxx create mode 100644 plugins/MirLua/Modules/WinAPI/src/stdafx.h create mode 100644 plugins/MirLua/Modules/WinAPI/src/winapi.cpp create mode 100644 plugins/MirLua/Modules/common.filters create mode 100644 plugins/MirLua/Modules/common.props create mode 100644 plugins/MirLua/Modules/module.props delete mode 100644 plugins/MirLua/src/m_windows.cpp (limited to 'plugins/MirLua') diff --git a/plugins/MirLua/Modules/WinAPI/WinAPI.vcxproj b/plugins/MirLua/Modules/WinAPI/WinAPI.vcxproj new file mode 100644 index 0000000000..86a81c3522 --- /dev/null +++ b/plugins/MirLua/Modules/WinAPI/WinAPI.vcxproj @@ -0,0 +1,36 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + {bd291bf0-d804-4818-8311-de871e6bceaa} + + + + WinAPI + {045bac91-34d1-4b43-b52b-566801be7f85} + + + + + + + $(ProjectDir)..\..\..\..\libs\liblua\include;%(AdditionalIncludeDirectories) + + + \ No newline at end of file diff --git a/plugins/MirLua/Modules/WinAPI/src/stdafx.cxx b/plugins/MirLua/Modules/WinAPI/src/stdafx.cxx new file mode 100644 index 0000000000..1577c4e3bc --- /dev/null +++ b/plugins/MirLua/Modules/WinAPI/src/stdafx.cxx @@ -0,0 +1 @@ +#include "stdafx.h" \ No newline at end of file diff --git a/plugins/MirLua/Modules/WinAPI/src/stdafx.h b/plugins/MirLua/Modules/WinAPI/src/stdafx.h new file mode 100644 index 0000000000..9b4664bd1f --- /dev/null +++ b/plugins/MirLua/Modules/WinAPI/src/stdafx.h @@ -0,0 +1,69 @@ +/****h* Win32/luaw32.c [$Revision: 13 $] +* NAME +* luaw32 +* COPYRIGHT +* (C) 2004-2007 Daniel Quintela. All rights reserved. +* http://www.soongsoft.com mailto:dq@soongsoft.com +* (C) 2013 http://quik2dde.ru +* LICENSE +* Permission is hereby granted, free of charge, to any person obtaining +* a copy of this software and associated documentation files (the +* "Software"), to deal in the Software without restriction, including +* without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to +* permit persons to whom the Software is furnished to do so, subject to +* the following conditions: +* +* The above copyright notice and this permission notice shall be +* included in all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +* FUNCTION +* Win32 functions & constants binding.. +* AUTHOR +* Daniel Quintela +* CREATION DATE +* 2004/08/16 +* MODIFICATION HISTORY +* $Id: luaw32.c 13 2007-04-15 13:39:04Z $ +* +* When Who What +* ------------------- ---------------- ---------------------------------------- +* 2004-09-01 12:20:00 Danilo Tuler GetTempPath added. +* 2006-08-25 08:20:00 Denis Povshedny QueryServiceConfig & StartService added. +* 2007-04-15 10:31:00 Daniel Quintela CreateMutex parameter list fixed. +* 2013-10-27 00:00:15 www.quik2dde.ru Linking with qlia.dll +* +* NOTES +* +***/ +#define LUA_WINAPI_LIB extern "C" int __declspec(dllexport) + +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include + + +#include +#include + +#define MYP2HCAST (long) \ No newline at end of file diff --git a/plugins/MirLua/Modules/WinAPI/src/winapi.cpp b/plugins/MirLua/Modules/WinAPI/src/winapi.cpp new file mode 100644 index 0000000000..dbf564d210 --- /dev/null +++ b/plugins/MirLua/Modules/WinAPI/src/winapi.cpp @@ -0,0 +1,2157 @@ +#include "stdafx.h" + +typedef int(__stdcall *MSGBOXAAPI)(IN HWND hWnd, IN LPCSTR lpText, IN LPCSTR lpCaption, IN UINT uType, IN WORD wLanguageId, IN DWORD dwMilliseconds); +typedef int(__stdcall *MSGBOXWAPI)(IN HWND hWnd, IN LPCWSTR lpText, IN LPCWSTR lpCaption, IN UINT uType, IN WORD wLanguageId, IN DWORD dwMilliseconds); + +int MessageBoxTimeoutA(IN HWND hWnd, IN LPCSTR lpText, IN LPCSTR lpCaption, IN UINT uType, IN WORD wLanguageId, IN DWORD dwMilliseconds); +int MessageBoxTimeoutW(IN HWND hWnd, IN LPCWSTR lpText, IN LPCWSTR lpCaption, IN UINT uType, IN WORD wLanguageId, IN DWORD dwMilliseconds); + +#ifdef UNICODE + #define MessageBoxTimeout MessageBoxTimeoutW +#else + #define MessageBoxTimeout MessageBoxTimeoutA +#endif + +#define MB_TIMEDOUT 32000 + +int MessageBoxTimeoutA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType, WORD wLanguageId, DWORD dwMilliseconds) +{ + static MSGBOXAAPI MsgBoxTOA = NULL; + + if (!MsgBoxTOA) + { + if (HMODULE hUser32 = GetModuleHandle(_T("user32.dll"))) + { + MsgBoxTOA = (MSGBOXAAPI)GetProcAddress(hUser32, "MessageBoxTimeoutA"); + FreeLibrary(hUser32); + } + } + + if (MsgBoxTOA) + { + return MsgBoxTOA(hWnd, lpText, lpCaption, uType, wLanguageId, dwMilliseconds); + } + + return MessageBoxA(hWnd, lpText, lpCaption, uType); +} + +int MessageBoxTimeoutW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType, WORD wLanguageId, DWORD dwMilliseconds) +{ + static MSGBOXWAPI MsgBoxTOW = NULL; + + if (!MsgBoxTOW) + { + if (HMODULE hUser32 = GetModuleHandle(_T("user32.dll"))) + { + MsgBoxTOW = (MSGBOXWAPI)GetProcAddress(hUser32, "MessageBoxTimeoutW"); + FreeLibrary(hUser32); + } + + } + + if (MsgBoxTOW) + { + return MsgBoxTOW(hWnd, lpText, lpCaption, uType, wLanguageId, dwMilliseconds); + } + + return MessageBoxW(hWnd, lpText, lpCaption, uType); +} + +static int lua_MessageBox(lua_State *L) +{ + HWND hwnd = (HWND)lua_touserdata(L, 1); + ptrT text(mir_utf8decodeT(lua_tostring(L, 2))); + ptrT caption(mir_utf8decodeT(lua_tostring(L, 3))); + UINT flags = lua_tointeger(L, 4); + LANGID langId = GetUserDefaultUILanguage(); + DWORD timeout = luaL_optinteger(L, 5, 0xFFFFFFFF); + + int res = ::MessageBoxTimeout(hwnd, text, caption, flags, langId, timeout); + lua_pushinteger(L, res); + + return 1; +} + +/***********************************************/ + +static int lua_ShellExecute(lua_State *L) +{ + ptrT command(mir_utf8decodeT(lua_tostring(L, 1))); + ptrT file(mir_utf8decodeT(lua_tostring(L, 2))); + ptrT args(mir_utf8decodeT(lua_tostring(L, 3))); + int flags = lua_tointeger(L, 4); + + ::ShellExecute(NULL, command, file, args, NULL, flags); + + return 0; +} + +/***********************************************/ + +static int lua_FindIterator(lua_State *L) +{ + HANDLE hFind = lua_touserdata(L, lua_upvalueindex(1)); + TCHAR* path = (TCHAR*)lua_touserdata(L, lua_upvalueindex(2)); + + WIN32_FIND_DATA ffd = { 0 }; + if (hFind == NULL) + { + hFind = FindFirstFile(path, &ffd); + if (hFind == INVALID_HANDLE_VALUE) + { + mir_free(path); + lua_pushnil(L); + return 1; + } + } + else + { + if (FindNextFile(hFind, &ffd) == 0) + { + FindClose(hFind); + mir_free(path); + lua_pushnil(L); + return 1; + } + } + + if (!mir_tstrcmpi(ffd.cFileName, _T(".")) || + !mir_tstrcmpi(ffd.cFileName, _T("..")) || + (ffd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) + { + lua_pushlightuserdata(L, hFind); + lua_replace(L, lua_upvalueindex(1)); + + return lua_FindIterator(L); + } + + LARGE_INTEGER size; + size.HighPart = ffd.nFileSizeHigh; + size.LowPart = ffd.nFileSizeLow; + + lua_newtable(L); + lua_pushliteral(L, "Name"); + lua_pushstring(L, T2Utf(ffd.cFileName)); + lua_settable(L, -3); + lua_pushliteral(L, "Size"); + lua_pushinteger(L, size.QuadPart); + lua_settable(L, -3); + lua_pushliteral(L, "IsFile"); + lua_pushboolean(L, !(ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)); + lua_settable(L, -3); + lua_pushliteral(L, "IsDirectory"); + lua_pushboolean(L, ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY); + lua_settable(L, -3); + + lua_pushlightuserdata(L, hFind); + lua_replace(L, lua_upvalueindex(1)); + + return 1; +} + +static int lua_Find(lua_State *L) +{ + TCHAR *path = mir_utf8decodeT(luaL_checkstring(L, 1)); + + lua_pushlightuserdata(L, NULL); + lua_pushlightuserdata(L, path); + lua_pushcclosure(L, lua_FindIterator, 2); + + return 1; +} + +static int lua_GetKeyState(lua_State *L) +{ + int vKey = luaL_checkinteger(L, 1); + + int res = GetKeyState(vKey); + lua_pushinteger(L, res); + + return 1; +} + +/***********************************************/ + +static int lua_GetIniValue(lua_State *L) +{ + ptrT path(mir_utf8decodeT(luaL_checkstring(L, 1))); + ptrT section(mir_utf8decodeT(luaL_checkstring(L, 2))); + ptrT key(mir_utf8decodeT(luaL_checkstring(L, 3))); + + if (lua_isinteger(L, 4)) + { + int default = lua_tointeger(L, 4); + + UINT res = ::GetPrivateProfileInt(section, key, default, path); + lua_pushinteger(L, res); + + return 1; + } + + ptrT default(mir_utf8decodeT(lua_tostring(L, 4))); + + TCHAR value[MAX_PATH] = { 0 }; + if (!::GetPrivateProfileString(section, key, default, value, _countof(value), path)) + { + lua_pushvalue(L, 4); + } + + ptrA res(mir_utf8encodeT(value)); + lua_pushstring(L, res); + + return 1; +} + +static int lua_SetIniValue(lua_State *L) +{ + ptrT path(mir_utf8decodeT(luaL_checkstring(L, 1))); + ptrT section(mir_utf8decodeT(luaL_checkstring(L, 2))); + ptrT key(mir_utf8decodeT(luaL_checkstring(L, 3))); + ptrT value(mir_utf8decodeT(lua_tostring(L, 4))); + + bool res = ::WritePrivateProfileString(section, key, value, path) != 0; + lua_pushboolean(L, res); + + return 1; +} + +static int lua_DeleteIniValue(lua_State *L) +{ + ptrT path(mir_utf8decodeT(luaL_checkstring(L, 1))); + ptrT section(mir_utf8decodeT(luaL_checkstring(L, 2))); + ptrT key(mir_utf8decodeT(luaL_checkstring(L, 3))); + + bool res = ::WritePrivateProfileString(section, key, NULL, path) != 0; + lua_pushboolean(L, res); + + return 1; +} + +/***********************************************/ + +static int lua_GetRegValue(lua_State *L) +{ + HKEY hRootKey = (HKEY)lua_touserdata(L, 1); + ptrT path(mir_utf8decodeT(luaL_checkstring(L, 2))); + ptrT valueName(mir_utf8decodeT(luaL_checkstring(L, 3))); + + HKEY hKey = 0; + LSTATUS res = ::RegOpenKeyEx(hRootKey, path, NULL, KEY_READ, &hKey); + if (res != ERROR_SUCCESS) + { + lua_pushvalue(L, 4); + return 1; + } + + DWORD type = 0; + DWORD length = 1024; + BYTE* value = (BYTE*)mir_alloc(length); + res = ::RegQueryValueEx(hKey, valueName, NULL, &type, (LPBYTE)value, &length); + while (res == ERROR_MORE_DATA) + { + length += length; + value = (BYTE*)mir_realloc(value, length); + res = ::RegQueryValueEx(hKey, valueName, NULL, &type, (LPBYTE)value, &length); + } + + if (res == ERROR_SUCCESS) + { + switch (type) + { + case REG_DWORD: + case REG_DWORD_BIG_ENDIAN: + lua_pushinteger(L, (INT_PTR)value); + break; + + case REG_QWORD: + lua_pushnumber(L, (INT_PTR)value); + break; + + case REG_SZ: + case REG_LINK: + case REG_EXPAND_SZ: + { + ptrA str(Utf8EncodeT((TCHAR*)value)); + lua_pushlstring(L, str, mir_strlen(str)); + } + break; + + default: + lua_pushvalue(L, 4); + break; + } + } + else + lua_pushvalue(L, 4); + + ::RegCloseKey(hKey); + mir_free(value); + + return 1; +} + +static int lua_SetRegValue(lua_State *L) +{ + HKEY hRootKey = (HKEY)lua_touserdata(L, 1); + ptrT path(mir_utf8decodeT(luaL_checkstring(L, 2))); + ptrT valueName(mir_utf8decodeT(luaL_checkstring(L, 3))); + + HKEY hKey = 0; + LSTATUS res = ::RegOpenKeyEx(hRootKey, path, NULL, KEY_WRITE, &hKey); + if (res != ERROR_SUCCESS) + { + lua_pushboolean(L, FALSE); + return 1; + } + + DWORD type = 0; + DWORD length = 0; + BYTE* value = NULL; + switch (lua_type(L, 4)) + { + case LUA_TNUMBER: + if (lua_isinteger(L, 4) && lua_tointeger(L, 4) < UINT32_MAX) + { + type = REG_DWORD; + length = sizeof(DWORD); + value = (BYTE*)lua_tointeger(L, 4); + } + else + { + type = REG_QWORD; + length = sizeof(DWORD) * 2; + lua_Number num = lua_tonumber(L, 4); + value = (BYTE*)# + } + break; + + case LUA_TSTRING: + type = REG_SZ; + length = mir_strlen(lua_tostring(L, 4)) * sizeof(TCHAR); + value = (BYTE*)mir_utf8decodeT(lua_tostring(L, 4)); + break; + + default: + lua_pushboolean(L, FALSE); + break; + } + + res = ::RegSetValueEx(hKey, valueName, NULL, type, value, length); + lua_pushboolean(L, res == ERROR_SUCCESS); + + ::RegCloseKey(hKey); + if (lua_isstring(L, 4)) + mir_free(value); + + return 1; +} + +static int lua_DeleteRegValue(lua_State *L) +{ + HKEY hRootKey = (HKEY)lua_touserdata(L, 1); + ptrT path(mir_utf8decodeT(luaL_checkstring(L, 2))); + ptrT valueName(mir_utf8decodeT(luaL_checkstring(L, 3))); + + HKEY hKey = 0; + LSTATUS res = ::RegOpenKeyEx(hRootKey, path, NULL, KEY_WRITE, &hKey); + if (res != ERROR_SUCCESS) + { + lua_pushboolean(L, FALSE); + return 1; + } + + res = ::RegDeleteValue(hKey, valueName); + lua_pushboolean(L, res == ERROR_SUCCESS); + + ::RegCloseKey(hKey); + + return 1; +} + +/* Registered functions */ + +static int global_ShellOpen(lua_State *L) { + long lrc; + const char *fileref = luaL_checkstring(L, 1); + + lrc = (long)ShellExecuteA(NULL, "open", fileref, NULL, NULL, SW_SHOW); + + if (lrc > 32) + lrc = 0; + + lua_pushnumber(L, lrc); + + return(1); +} + +static int global_FindWindow(lua_State *L) { + long lrc; + const char *cname = luaL_checkstring(L, 1); + const char *wname = luaL_checkstring(L, 2); + + lrc = (long)FindWindowA(cname[0] ? cname : NULL, + wname[0] ? wname : NULL); + + lua_pushnumber(L, lrc); + + return(1); +} + +static int global_FindWindowEx(lua_State *L) { + const HWND parent = (HWND)(int)luaL_checknumber(L, 1); + const HWND childaft = (HWND)(int)luaL_checknumber(L, 2); + const char *cname = luaL_checkstring(L, 3); + const char *wname = luaL_checkstring(L, 4); + + long lrc = (long)FindWindowExA(parent, childaft, + cname[0] ? cname : NULL, + wname[0] ? wname : NULL); + + lua_pushnumber(L, lrc); + + return(1); +} + +static int global_SetWindowText(lua_State *L) { + const HWND hwnd = (HWND)(int)luaL_checknumber(L, 1); + const char *text = luaL_checkstring(L, 2); + + BOOL rc = SetWindowTextA(hwnd, text); + + lua_pushnumber(L, rc); + + return(1); +} + +static int global_SetFocus(lua_State *L) { + const HWND hwnd = (HWND)(int)luaL_checknumber(L, 1); + HWND rc = SetFocus(hwnd); + lua_pushinteger(L, (int)rc); + + return(1); +} + +// Lua: returns nil when error occurred +static int global_GetWindowText(lua_State *L) { + const HWND hwnd = (HWND)(int)luaL_checknumber(L, 1); + char buf[2048]; + + int rc = GetWindowTextA(hwnd, buf, sizeof(buf)); + + if (rc > 0) + lua_pushstring(L, buf); + else if (GetLastError() == ERROR_SUCCESS) + lua_pushstring(L, ""); + else + lua_pushnil(L); + + return(1); +} + +// Lua: returns left,top,right,bottom when successfully +// or +// returns nil when error occurred +static int global_GetWindowRect(lua_State *L) { + const HWND hwnd = (HWND)(int)luaL_checknumber(L, 1); + RECT rect; + + BOOL rc = GetWindowRect(hwnd, &rect); + + if (!rc) { + lua_pushnil(L); + return(1); + } + else { + lua_pushinteger(L, rect.left); + lua_pushinteger(L, rect.top); + lua_pushinteger(L, rect.right); + lua_pushinteger(L, rect.bottom); + return(4); + } +} + +struct S_HKT { + HWND hwnd; + int id; + UINT mdfs; + UINT vk; + UINT umsg; + WPARAM wparam; + LPARAM lparam; +}; + +static void HotKeyThread(void *v) { + struct S_HKT *s = (struct S_HKT *) v; + MSG msg; + + RegisterHotKey(NULL, s->id, s->mdfs, s->vk); + + while (GetMessage(&msg, NULL, 0, 0) > 0) + if (msg.message == WM_HOTKEY) + PostMessage(s->hwnd, s->umsg, s->wparam, s->lparam); +} + +static int global_RegisterHotKey(lua_State *L) { + struct S_HKT *s; + + s = (S_HKT*)mir_alloc(sizeof(struct S_HKT)); + if (s == NULL) + lua_pushnumber(L, -1); + else { + long hwnd = MYP2HCAST luaL_checknumber(L, 1); + s->hwnd = (HWND)hwnd; + s->id = (int)luaL_checknumber(L, 2); + s->mdfs = (UINT)luaL_checknumber(L, 3); + s->vk = (UINT)luaL_checknumber(L, 4); + s->umsg = (UINT)luaL_checknumber(L, 5); + s->wparam = (WPARAM)luaL_checknumber(L, 6); + s->lparam = (LPARAM)luaL_checknumber(L, 7); + + if (_beginthread(HotKeyThread, 0, s) < 0) + lua_pushnumber(L, -2); + else + lua_pushnumber(L, 0); + } + + return(1); +} + +static int global_SetForegroundWindow(lua_State *L) { + long hwnd = MYP2HCAST luaL_checknumber(L, 1); + + lua_pushnumber(L, SetForegroundWindow((HWND)hwnd)); + + return(1); +} + +static int global_PostMessage(lua_State *L) { + BOOL rc; + long hwnd = MYP2HCAST luaL_checknumber(L, 1); + UINT msg = (UINT)luaL_checknumber(L, 2); + WPARAM wparam = (WPARAM)luaL_checknumber(L, 3); + LPARAM lparam = (LPARAM)luaL_checknumber(L, 4); + + rc = PostMessage((HWND)hwnd, msg, wparam, lparam); + + lua_pushnumber(L, rc); + + return(1); +} + +static int global_PostThreadMessage(lua_State *L) { + BOOL rc; + DWORD tid = (DWORD)luaL_checknumber(L, 1); + UINT msg = (UINT)luaL_checknumber(L, 2); + WPARAM wparam = (WPARAM)luaL_checknumber(L, 3); + LPARAM lparam = (LPARAM)luaL_checknumber(L, 4); + + rc = PostThreadMessage(tid, msg, wparam, lparam); + + lua_pushnumber(L, rc); + + return(1); +} + +static int global_GetMessage(lua_State *L) { + MSG msg; + BOOL rc; + long lwnd = MYP2HCAST luaL_optinteger(L, 1, 0); + UINT mfmin = (UINT)luaL_optinteger(L, 2, 0); + UINT mfmax = (UINT)luaL_optinteger(L, 3, 0); + + rc = GetMessage(&msg, (HWND)lwnd, mfmin, mfmax); + + lua_pushnumber(L, rc); + if (rc) { + lua_pushnumber(L, (long)msg.hwnd); + lua_pushnumber(L, msg.message); + lua_pushnumber(L, msg.wParam); + lua_pushnumber(L, msg.lParam); + lua_pushnumber(L, msg.time); + lua_pushnumber(L, msg.pt.x); + lua_pushnumber(L, msg.pt.y); + } + else { + lua_pushnil(L); + lua_pushnil(L); + lua_pushnil(L); + lua_pushnil(L); + lua_pushnil(L); + lua_pushnil(L); + lua_pushnil(L); + } + + return(8); +} + +static int global_PeekMessage(lua_State *L) { + MSG msg; + BOOL rc; + long lwnd = MYP2HCAST luaL_optinteger(L, 1, 0); + UINT mfmin = (UINT)luaL_optinteger(L, 2, 0); + UINT mfmax = (UINT)luaL_optinteger(L, 3, 0); + UINT rmmsg = (UINT)luaL_optinteger(L, 4, PM_NOREMOVE); + + rc = PeekMessage(&msg, (HWND)lwnd, mfmin, mfmax, rmmsg); + + lua_pushnumber(L, rc); + if (rc) { + lua_pushnumber(L, (long)msg.hwnd); + lua_pushnumber(L, msg.message); + lua_pushnumber(L, msg.wParam); + lua_pushnumber(L, msg.lParam); + lua_pushnumber(L, msg.time); + lua_pushnumber(L, msg.pt.x); + lua_pushnumber(L, msg.pt.y); + } + else { + lua_pushnil(L); + lua_pushnil(L); + lua_pushnil(L); + lua_pushnil(L); + lua_pushnil(L); + lua_pushnil(L); + lua_pushnil(L); + } + + return(8); +} + +static int global_ReplyMessage(lua_State *L) { + BOOL rc; + LRESULT result = (LRESULT)luaL_checknumber(L, 1); + + rc = ReplyMessage(result); + + lua_pushboolean(L, rc); + + return(1); +} + +static int global_DispatchMessage(lua_State *L) { + MSG msg; + LRESULT rc; + long hwnd = MYP2HCAST luaL_checknumber(L, 1); + + msg.hwnd = (HWND)hwnd; + msg.message = (UINT)luaL_checknumber(L, 2); + msg.wParam = (WPARAM)luaL_checknumber(L, 3); + msg.lParam = (LPARAM)luaL_checknumber(L, 4); + msg.time = (DWORD)luaL_checknumber(L, 5); + msg.pt.x = (LONG)luaL_checknumber(L, 6); + msg.pt.y = (LONG)luaL_checknumber(L, 7); + + rc = DispatchMessage(&msg); + + lua_pushnumber(L, rc); + + return(1); +} + +static int global_SetTopmost(lua_State *L) { + BOOL rc; + long hwnd = MYP2HCAST luaL_checknumber(L, 1); + + rc = SetWindowPos((HWND)hwnd, HWND_TOPMOST, 0, 0, 0, 0, + SWP_NOMOVE | SWP_NOSIZE); + + lua_pushnumber(L, rc); + + return(1); +} + +/****if* luaw32/global_GetLastError +* NAME +* global_GetLastError +* FUNCTION +* Win32 GetLastError. +* RESULT +* stack[1]: The calling thread's last-error code value +* SOURCE +*/ + +static int global_GetLastError(lua_State *L) { + + lua_pushnumber(L, GetLastError()); + + return(1); +} +/***/ + +/****if* luaw32/global_CloseHandle +* NAME +* global_CloseHandle +* FUNCTION +* Win32 CloseHandle. +* INPUTS +* L: Lua state +* stack[1]: Handle to an open object +* RESULT +* stack[1]: True if ok. +* SOURCE +*/ + +static int global_CloseHandle(lua_State *L) { + long h = MYP2HCAST luaL_checknumber(L, 1); + + lua_pushboolean(L, CloseHandle((HANDLE)h)); + + return(1); +} +/***/ + +static int global_CreateEvent(lua_State *L) { + SECURITY_ATTRIBUTES sa; + BOOL mr = (BOOL)luaL_checknumber(L, 2); + BOOL is = (BOOL)luaL_checknumber(L, 3); + const char *name; + long h; + + sa.nLength = sizeof(sa); + sa.lpSecurityDescriptor = NULL; + sa.bInheritHandle = FALSE; + + if (lua_istable(L, 1)) { + lua_pushstring(L, "bInheritHandle"); + lua_gettable(L, 1); + if (!lua_isnil(L, -1)) + sa.bInheritHandle = (BOOL)luaL_checknumber(L, -1); + lua_pop(L, 1); + } + name = lua_tostring(L, 4); + + h = (long)CreateEventA(&sa, mr, is, name); + + if (h) + lua_pushnumber(L, h); + else + lua_pushnil(L); + + return(1); +} + +static int global_OpenEvent(lua_State *L) { + long h; + DWORD da = (DWORD)luaL_checknumber(L, 1); + BOOL ih = (BOOL)luaL_checknumber(L, 2); + const char *name = luaL_checkstring(L, 3); + + h = (long)OpenEventA(da, ih, name); + + if (h) + lua_pushnumber(L, h); + else + lua_pushnil(L); + + return(1); +} + +static int global_PulseEvent(lua_State *L) { + long h = MYP2HCAST luaL_checknumber(L, 1); + + lua_pushnumber(L, PulseEvent((HANDLE)h)); + + return(1); +} + +static int global_ResetEvent(lua_State *L) { + long h = MYP2HCAST luaL_checknumber(L, 1); + + lua_pushnumber(L, ResetEvent((HANDLE)h)); + + return(1); +} + +static int global_SetEvent(lua_State *L) { + long h = MYP2HCAST luaL_checknumber(L, 1); + + lua_pushnumber(L, SetEvent((HANDLE)h)); + + return(1); +} + +static int global_CreateMutex(lua_State *L) { + SECURITY_ATTRIBUTES sa; + BOOL io = (BOOL)luaL_checknumber(L, 2); + const char *name; + long h; + + sa.nLength = sizeof(sa); + sa.lpSecurityDescriptor = NULL; + sa.bInheritHandle = FALSE; + + if (lua_istable(L, 1)) { + lua_pushstring(L, "bInheritHandle"); + lua_gettable(L, 1); + if (!lua_isnil(L, -1)) + sa.bInheritHandle = (BOOL)luaL_checknumber(L, -1); + lua_pop(L, 1); + } + name = lua_tostring(L, 3); + + h = (long)CreateMutexA(&sa, io, name); + + if (h) + lua_pushnumber(L, h); + else + lua_pushnil(L); + + return(1); +} + +static int global_OpenMutex(lua_State *L) { + long h; + DWORD da = (DWORD)luaL_checknumber(L, 1); + BOOL ih = (BOOL)luaL_checknumber(L, 2); + const char *name = luaL_checkstring(L, 3); + + h = (long)OpenMutexA(da, ih, name); + + if (h) + lua_pushnumber(L, h); + else + lua_pushnil(L); + + return(1); +} + +static int global_ReleaseMutex(lua_State *L) { + long h = MYP2HCAST luaL_checknumber(L, 1); + + lua_pushnumber(L, ReleaseMutex((HANDLE)h)); + + return(1); +} + +static int global_CreateSemaphore(lua_State *L) { + SECURITY_ATTRIBUTES sa; + long ic = (long)luaL_checknumber(L, 2); + long mc = (long)luaL_checknumber(L, 3); + const char *name; + long h; + + sa.nLength = sizeof(sa); + sa.lpSecurityDescriptor = NULL; + sa.bInheritHandle = FALSE; + + if (lua_istable(L, 1)) { + lua_pushstring(L, "bInheritHandle"); + lua_gettable(L, 1); + if (!lua_isnil(L, -1)) + sa.bInheritHandle = (BOOL)luaL_checknumber(L, -1); + lua_pop(L, 1); + } + name = lua_tostring(L, 4); + + h = (long)CreateSemaphoreA(&sa, ic, mc, name); + + if (h) + lua_pushnumber(L, h); + else + lua_pushnil(L); + + return(1); +} + +static int global_OpenSemaphore(lua_State *L) { + long h; + DWORD da = (DWORD)luaL_checknumber(L, 1); + BOOL ih = (BOOL)luaL_checknumber(L, 2); + const char *name = luaL_checkstring(L, 3); + + h = (long)OpenSemaphoreA(da, ih, name); + + if (h) + lua_pushnumber(L, h); + else + lua_pushnil(L); + + return(1); +} + +static int global_ReleaseSemaphore(lua_State *L) { + long pc; + BOOL brc; + long h = MYP2HCAST luaL_checknumber(L, 1); + long rc = (long)luaL_checknumber(L, 2); + + brc = ReleaseSemaphore((HANDLE)h, rc, &pc); + lua_pushnumber(L, brc); + if (brc) + lua_pushnumber(L, pc); + else + lua_pushnil(L); + + return(2); +} + +static int global_CreateProcess(lua_State *L) { + SECURITY_ATTRIBUTES psa; + SECURITY_ATTRIBUTES tsa; + PROCESS_INFORMATION pi; + STARTUPINFOA si; + BOOL brc; + char *env; + const char *an = luaL_optstring(L, 1, NULL); + const char *cl = luaL_optstring(L, 2, NULL); + BOOL ih = (BOOL)luaL_checknumber(L, 5); + DWORD cf = (DWORD)luaL_checknumber(L, 6); + const char *cd = lua_tostring(L, 8); + + psa.nLength = sizeof(psa); + psa.lpSecurityDescriptor = NULL; + psa.bInheritHandle = FALSE; + if (lua_istable(L, 3)) { + lua_pushstring(L, "bInheritHandle"); + lua_gettable(L, 3); + if (!lua_isnil(L, -1)) + psa.bInheritHandle = (BOOL)luaL_checknumber(L, -1); + lua_pop(L, 3); + } + + tsa.nLength = sizeof(tsa); + tsa.lpSecurityDescriptor = NULL; + tsa.bInheritHandle = FALSE; + if (lua_istable(L, 4)) { + lua_pushstring(L, "bInheritHandle"); + lua_gettable(L, 4); + if (!lua_isnil(L, -1)) + tsa.bInheritHandle = (BOOL)luaL_checknumber(L, -1); + lua_pop(L, 4); + } + + env = NULL; + + memset(&si, 0, sizeof(si)); + si.cb = sizeof(si); + if (lua_istable(L, 7)) { + lua_pushnil(L); + while (lua_next(L, 7) != 0) { + const char *key = luaL_checkstring(L, -2); + if (!mir_strcmp(key, "lpDesktop")) { + si.lpDesktop = mir_strdup(luaL_checkstring(L, -1)); + } + else if (!mir_strcmp(key, "lpTitle")) { + si.lpTitle = mir_strdup(luaL_checkstring(L, -1)); + } + else if (!mir_strcmp(key, "dwX")) { + si.dwX = (DWORD)luaL_checknumber(L, -1); + } + else if (!mir_strcmp(key, "dwY")) { + si.dwY = (DWORD)luaL_checknumber(L, -1); + } + else if (!mir_strcmp(key, "dwXSize")) { + si.dwXSize = (DWORD)luaL_checknumber(L, -1); + } + else if (!mir_strcmp(key, "dwYSize")) { + si.dwYSize = (DWORD)luaL_checknumber(L, -1); + } + else if (!mir_strcmp(key, "dwXCountChars")) { + si.dwXCountChars = (DWORD)luaL_checknumber(L, -1); + } + else if (!mir_strcmp(key, "dwYCountChars")) { + si.dwYCountChars = (DWORD)luaL_checknumber(L, -1); + } + else if (!mir_strcmp(key, "dwFillAttribute")) { + si.dwFillAttribute = (DWORD)luaL_checknumber(L, -1); + } + else if (!mir_strcmp(key, "dwFlags")) { + si.dwFlags = (DWORD)luaL_checknumber(L, -1); + } + else if (!mir_strcmp(key, "wShowWindow")) { + si.wShowWindow = (WORD)luaL_checknumber(L, -1); + } + else if (!mir_strcmp(key, "hStdInput")) { + long h = (long)luaL_checknumber(L, -1); + si.hStdInput = (HANDLE)h; + } + else if (!mir_strcmp(key, "hStdOutput")) { + long h = (long)luaL_checknumber(L, -1); + si.hStdOutput = (HANDLE)h; + } + else if (!mir_strcmp(key, "hStdError")) { + long h = (long)luaL_checknumber(L, -1); + si.hStdError = (HANDLE)h; + } + lua_pop(L, 1); + } + } + + + brc = CreateProcessA(an, (char *)cl, &psa, &tsa, ih, cf, env, cd, &si, &pi); + + if (si.lpDesktop != NULL) + mir_free(si.lpDesktop); + if (si.lpTitle != NULL) + mir_free(si.lpTitle); + + lua_pushnumber(L, brc); + if (brc) { + lua_pushnumber(L, (long)(pi.hProcess)); + lua_pushnumber(L, (long)(pi.hThread)); + lua_pushnumber(L, pi.dwProcessId); + lua_pushnumber(L, pi.dwThreadId); + } + else { + lua_pushnil(L); + lua_pushnil(L); + lua_pushnil(L); + lua_pushnil(L); + } + + return(5); +} + +/****if* luaw32/global_GetTempFileName +* NAME +* global_GetTempFileName +* FUNCTION +* Win32 GetTempFileName. +* INPUTS +* L: Lua state +* stack[1]: specifies the directory path for the file name +* stack[2]: Specifies the type of access to the object +* stack[3]: Specifies an unsigned integer that the function +* converts to a hexadecimal string for use in creating +* the temporary file name +* RESULT +* stack[1]: Unique numeric value or 0 if error +* stack[2]: Temporary file name or nil if error +* SOURCE +*/ + +static int global_GetTempFileName(lua_State *L) { + UINT rc; + char tfn[MAX_PATH]; + const char *path = luaL_checkstring(L, 1); + const char *pfx = luaL_checkstring(L, 2); + UINT unique = (UINT)luaL_checknumber(L, 3); + + rc = GetTempFileNameA(path, pfx, unique, tfn); + + lua_pushnumber(L, rc); + if (rc) + lua_pushstring(L, tfn); + else + lua_pushnil(L); + + return(2); +} +/***/ + +/****if* luaw32/global_GetTempPath +* NAME +* global_GetTempPath +* FUNCTION +* Win32 GetTempPath. +* INPUTS +* L: Lua state +* RESULT +* stack[1]: Unique numeric value or 0 if error +* stack[2]: Path of the directory designated for temporary files +* SOURCE +*/ + +static int global_GetTempPath(lua_State *L) { + DWORD rc; + char tfn[MAX_PATH]; + + rc = GetTempPathA(MAX_PATH, tfn); + + lua_pushnumber(L, rc); + if (rc) + lua_pushstring(L, tfn); + else + lua_pushnil(L); + + return(2); +} +/***/ + +static int global_CreateNamedPipe(lua_State *L) +{ + LPCSTR lpName = luaL_checkstring(L, 1); + DWORD dwOpenMode = luaL_checknumber(L, 2); + DWORD dwPipeMode = luaL_checknumber(L, 3); + DWORD nMaxInstances = luaL_checknumber(L, 4); + DWORD nOutBufferSize = luaL_checknumber(L, 5); + DWORD nInBufferSize = luaL_checknumber(L, 6); + DWORD nDefaultTimeOut = luaL_checknumber(L, 7); + SECURITY_ATTRIBUTES sa = { sizeof(sa), NULL, false }; + + HANDLE hPipe = CreateNamedPipeA(lpName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, &sa); + lua_pushnumber(L, (long)hPipe); + return 1; +} + +/****if* luaw32/global_CreateFile +* NAME +* global_CreateFile +* FUNCTION +* Win32 CreateFile. +* INPUTS +* L: Lua state +* stack[1]: Name of the object to create or open +* stack[2]: Specifies the type of access to the object +* stack[3]: Specifies how the object can be shared +* stack[4]: Table: +* .bInheritHandle: determines whether the returned handle +* can be inherited by child processes +* stack[5]: Specifies which action to take on files that exist +* stack[6]: Specifies the file attributes and flags for the file +* stack[7]: Specifies a handle with GENERIC_READ access to a +* template file +* RESULT +* stack[1]: Handle +* SOURCE +*/ + +static int global_CreateFile(lua_State *L) { + SECURITY_ATTRIBUTES sa; + long h; + const char *name = luaL_checkstring(L, 1); + DWORD da = (DWORD)luaL_checknumber(L, 2); + DWORD sm = (DWORD)luaL_checknumber(L, 3); + DWORD cd = (DWORD)luaL_checknumber(L, 5); + DWORD fa = (DWORD)luaL_checknumber(L, 6); + long th = 0; + + sa.nLength = sizeof(sa); + sa.lpSecurityDescriptor = NULL; + sa.bInheritHandle = FALSE; + if (lua_istable(L, 4)) { + lua_pushstring(L, "bInheritHandle"); + lua_gettable(L, 4); + if (!lua_isnil(L, -1)) + sa.bInheritHandle = (BOOL)luaL_checknumber(L, -1); + lua_pop(L, 1); + } + if (!lua_isnil(L, 7)) + th = (long)luaL_checknumber(L, 7); + + h = (long)CreateFileA(name, da, sm, &sa, cd, fa, (HANDLE)th); + + lua_pushnumber(L, h); + + return(1); +} +/***/ + +/****if* luaw32/global_ReadFile +* NAME +* global_ReadFile +* FUNCTION +* Win32 ReadFile. +* INPUTS +* L: Lua state +* stack[1]: Handle to the file to be read +* stack[2]: Specifies the number of bytes to be read from the file +* RESULT +* stack[1]: True if ok. +* stack[2]: Buffer read or nil if error +* SOURCE +*/ + +static int global_ReadFile(lua_State *L) { + DWORD bread; + char *buf; + BOOL brc = FALSE; + long h = MYP2HCAST luaL_checknumber(L, 1); + DWORD btoread = (DWORD)luaL_checknumber(L, 2); + + buf = (char*)mir_alloc(btoread); + if (buf != NULL) { + brc = ReadFile((HANDLE)h, buf, btoread, &bread, NULL); + lua_pushboolean(L, TRUE); + lua_pushlstring(L, buf, bread); + mir_free(buf); + } + else { + lua_pushboolean(L, FALSE); + lua_pushnil(L); + } + + return(2); +} +/***/ + +/****if* luaw32/global_WriteFile +* NAME +* global_WriteFile +* FUNCTION +* Win32 WriteFile. +* INPUTS +* L: Lua state +* stack[1]: Handle to the file to be written to +* stack[2]: Buffer containing the data to be written to the file +* RESULT +* stack[1]: True if ok. +* stack[2]: Number of bytes written or nil if error +* SOURCE +*/ + +static int global_WriteFile(lua_State *L) { + DWORD bwrite; + DWORD btowrite; + BOOL brc; + long h = MYP2HCAST luaL_checknumber(L, 1); + const char *buf = luaL_checklstring(L, 2, (size_t*)&btowrite); + + brc = WriteFile((HANDLE)h, buf, btowrite, &bwrite, NULL); + lua_pushboolean(L, brc); + if (brc) + lua_pushnumber(L, bwrite); + else + lua_pushnil(L); + + return(2); +} +/***/ + +static int global_DeleteFile(lua_State *L) +{ + const char *path = luaL_checkstring(L, 1); + BOOL result = DeleteFileA(path); + lua_pushboolean(L, result); + return 1; +} + +static int global_WaitForSingleObject(lua_State *L) { + long h = MYP2HCAST luaL_checknumber(L, 1); + DWORD t = (DWORD)luaL_checknumber(L, 2); + + lua_pushnumber(L, WaitForSingleObject((HANDLE)h, t)); + + return(1); +} + +static int global_WaitForMultipleObjects(lua_State *L) { + HANDLE ha[64]; + DWORD c = 0; + BOOL wa = (BOOL)luaL_checknumber(L, 2); + DWORD t = (DWORD)luaL_checknumber(L, 3); + + if (lua_istable(L, 1)) { + for (; c < 64; c++) { + long h; + lua_pushnumber(L, c + 1); + lua_gettable(L, 1); + if (lua_isnil(L, -1)) + break; + h = (long)luaL_checknumber(L, -1); + ha[c] = (HANDLE)h; + } + } + + lua_pushnumber(L, WaitForMultipleObjects(c, ha, wa, t)); + + return(1); +} + +static int global_TerminateProcess(lua_State *L) { + long h = MYP2HCAST luaL_checknumber(L, 1); + DWORD ec = (DWORD)luaL_checknumber(L, 2); + + lua_pushnumber(L, TerminateProcess((HANDLE)h, ec)); + + return(1); +} + +static int global_GetExitCodeProcess(lua_State *L) { + BOOL ok; + DWORD ec; + long h = MYP2HCAST luaL_checknumber(L, 1); + + ok = GetExitCodeProcess((HANDLE)h, &ec); + lua_pushnumber(L, ok); + lua_pushnumber(L, ec); + + return(2); +} + +static int global_GetCurrentThreadId(lua_State *L) { + lua_pushnumber(L, GetCurrentThreadId()); + + return(1); +} + +static int global_RegisterWindowMessage(lua_State *L) { + const char *msg = luaL_checkstring(L, 1); + + lua_pushnumber(L, RegisterWindowMessageA(msg)); + + return(1); +} + +static int global_RegQueryValueEx(lua_State *L) { + long rv; + HKEY hsk; + DWORD type; + DWORD dwdata; + DWORD len; + char *szdata; + long hkey = MYP2HCAST luaL_checknumber(L, 1); + const char *subkey = luaL_checkstring(L, 2); + const char *valuename = luaL_checkstring(L, 3); + + rv = RegOpenKeyExA((HKEY)hkey, subkey, 0, KEY_QUERY_VALUE, &hsk); + if (rv == ERROR_SUCCESS) { + len = sizeof(dwdata); + rv = RegQueryValueExA(hsk, valuename, NULL, &type, (LPBYTE)&dwdata, &len); + if ((rv == ERROR_SUCCESS) || (rv == ERROR_MORE_DATA)) { + switch (type) { + case REG_DWORD_BIG_ENDIAN: + case REG_DWORD: + lua_pushnumber(L, dwdata); + break; + case REG_EXPAND_SZ: + case REG_BINARY: + case REG_MULTI_SZ: + case REG_SZ: + if (rv == ERROR_MORE_DATA) { + szdata = (char*)mir_alloc(len); + if (szdata == NULL) { + lua_pushnil(L); + } + else { + rv = RegQueryValueExA(hsk, valuename, NULL, &type, (LPBYTE)szdata, &len); + if (rv == ERROR_SUCCESS) + lua_pushlstring(L, szdata, len); + else + lua_pushnil(L); + mir_free(szdata); + } + } + else + lua_pushlstring(L, (const char *)&dwdata, len); + break; + default: + lua_pushnil(L); + } + } + else + lua_pushnil(L); + RegCloseKey(hsk); + } + else + lua_pushnil(L); + + return 1; +} + +static int global_RegSetValueEx(lua_State *L) { + long rv; + HKEY hsk; + DWORD type; + DWORD dwdata; + DWORD len = 0; + char *szdata = NULL; + long hkey = MYP2HCAST luaL_checknumber(L, 1); + const char *subkey = luaL_checkstring(L, 2); + const char *valuename = luaL_checkstring(L, 3); + + if (lua_isnumber(L, 4)) { + dwdata = (DWORD)luaL_checknumber(L, 4); + type = (DWORD)luaL_optnumber(L, 5, REG_DWORD); + } + else { + szdata = (char *)luaL_checklstring(L, 4, (size_t*)&len); + type = (DWORD)luaL_optnumber(L, 5, REG_SZ); + } + + rv = RegCreateKeyExA((HKEY)hkey, subkey, 0, "", REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hsk, NULL); + if (rv == ERROR_SUCCESS) { + if (szdata == NULL) + rv = RegSetValueExA(hsk, valuename, 0, type, (CONST BYTE *) &dwdata, sizeof(dwdata)); + else + rv = RegSetValueExA(hsk, valuename, 0, type, (CONST BYTE *) szdata, len + 1); + lua_pushboolean(L, rv == ERROR_SUCCESS); + RegCloseKey(hsk); + } + else + lua_pushboolean(L, 0); + + return 1; +} + +static int global_RegDeleteValue(lua_State *L) { + long rv; + HKEY hsk; + long hkey = MYP2HCAST luaL_checknumber(L, 1); + const char *subkey = luaL_checkstring(L, 2); + const char *valuename = luaL_checkstring(L, 3); + + rv = RegOpenKeyExA((HKEY)hkey, subkey, 0, KEY_SET_VALUE, &hsk); + if (rv == ERROR_SUCCESS) { + rv = RegDeleteValueA(hsk, valuename); + lua_pushboolean(L, rv == ERROR_SUCCESS); + RegCloseKey(hsk); + } + else + lua_pushboolean(L, 0); + + return 1; +} + +static int global_RegDeleteKey(lua_State *L) { + long hkey = MYP2HCAST luaL_checknumber(L, 1); + const char *subkey = luaL_checkstring(L, 2); + + lua_pushboolean(L, RegDeleteKeyA((HKEY)hkey, subkey) == ERROR_SUCCESS); + + return 1; +} + +static int global_RegEnumKeyEx(lua_State *L) { + long rv; + HKEY hsk; + DWORD len; + DWORD index; + char name[256]; + FILETIME ft; + long hkey = MYP2HCAST luaL_checknumber(L, 1); + const char *subkey = luaL_checkstring(L, 2); + + rv = RegOpenKeyExA((HKEY)hkey, subkey, 0, KEY_ENUMERATE_SUB_KEYS, &hsk); + if (rv == ERROR_SUCCESS) { + lua_newtable(L); + for (index = 0;; index++) { + len = sizeof(name); + if (RegEnumKeyExA(hsk, index, name, &len, + NULL, NULL, NULL, &ft) != ERROR_SUCCESS) + break; + lua_pushnumber(L, index + 1); + lua_pushstring(L, name); + lua_settable(L, -3); + } + RegCloseKey(hsk); + } + else + lua_pushnil(L); + + return 1; +} + +static int global_RegEnumValue(lua_State *L) { + long rv; + HKEY hsk; + DWORD len; + DWORD index; + char name[256]; + long hkey = MYP2HCAST luaL_checknumber(L, 1); + const char *subkey = luaL_checkstring(L, 2); + + rv = RegOpenKeyExA((HKEY)hkey, subkey, 0, KEY_QUERY_VALUE, &hsk); + if (rv == ERROR_SUCCESS) { + lua_newtable(L); + for (index = 0;; index++) { + len = sizeof(name); + if (RegEnumValueA(hsk, index, name, &len, + NULL, NULL, NULL, NULL) != ERROR_SUCCESS) + break; + lua_pushnumber(L, index + 1); + lua_pushstring(L, name); + lua_settable(L, -3); + } + RegCloseKey(hsk); + } + else + lua_pushnil(L); + + return 1; +} + +static int global_SetCurrentDirectory(lua_State *L) { + DWORD le; + BOOL ok; + const char *pname = luaL_checkstring(L, 1); + + ok = SetCurrentDirectoryA(pname); + if (!ok) { + le = GetLastError(); + lua_pushboolean(L, ok); + lua_pushnumber(L, le); + } + else { + lua_pushboolean(L, ok); + lua_pushnil(L); + } + + return 2; +} + +static int global_SHDeleteKey(lua_State *L) { + long hkey = MYP2HCAST luaL_checknumber(L, 1); + const char *subkey = luaL_checkstring(L, 2); + + lua_pushboolean(L, SHDeleteKeyA((HKEY)hkey, subkey) == ERROR_SUCCESS); + + return 1; +} + +static int global_Sleep(lua_State *L) { + DWORD tosleep = (DWORD)luaL_checknumber(L, 1); + + Sleep(tosleep); + + return 0; +} + +static int global_GetVersion(lua_State *L) { + + lua_pushnumber(L, GetVersion()); + + return 1; +} + +static void pushFFTime(lua_State *L, FILETIME *ft) { + SYSTEMTIME st; + FileTimeToSystemTime(ft, &st); + lua_newtable(L); + lua_pushstring(L, "Year"); + lua_pushnumber(L, st.wYear); + lua_rawset(L, -3); + lua_pushstring(L, "Month"); + lua_pushnumber(L, st.wMonth); + lua_rawset(L, -3); + lua_pushstring(L, "DayOfWeek"); + lua_pushnumber(L, st.wDayOfWeek); + lua_rawset(L, -3); + lua_pushstring(L, "Day"); + lua_pushnumber(L, st.wDay); + lua_rawset(L, -3); + lua_pushstring(L, "Hour"); + lua_pushnumber(L, st.wHour); + lua_rawset(L, -3); + lua_pushstring(L, "Minute"); + lua_pushnumber(L, st.wMinute); + lua_rawset(L, -3); + lua_pushstring(L, "Second"); + lua_pushnumber(L, st.wSecond); + lua_rawset(L, -3); + lua_pushstring(L, "Milliseconds"); + lua_pushnumber(L, st.wMilliseconds); + lua_rawset(L, -3); +} +static void pushFFData(lua_State *L, WIN32_FIND_DATAA *wfd) { + lua_newtable(L); + lua_pushstring(L, "FileAttributes"); + lua_pushnumber(L, wfd->dwFileAttributes); + lua_rawset(L, -3); + lua_pushstring(L, "CreationTime"); + pushFFTime(L, &(wfd->ftCreationTime)); + lua_rawset(L, -3); + lua_pushstring(L, "LastAccessTime"); + pushFFTime(L, &(wfd->ftLastAccessTime)); + lua_rawset(L, -3); + lua_pushstring(L, "LastWriteTime"); + pushFFTime(L, &(wfd->ftLastWriteTime)); + lua_rawset(L, -3); + lua_pushstring(L, "FileSizeHigh"); + lua_pushnumber(L, wfd->nFileSizeHigh); + lua_rawset(L, -3); + lua_pushstring(L, "FileSizeLow"); + lua_pushnumber(L, wfd->nFileSizeLow); + lua_rawset(L, -3); + lua_pushstring(L, "FileName"); + lua_pushstring(L, wfd->cFileName); + lua_rawset(L, -3); + lua_pushstring(L, "AlternateFileName"); + lua_pushstring(L, wfd->cAlternateFileName); + lua_rawset(L, -3); +} + +static int global_FindFirstFile(lua_State *L) { + WIN32_FIND_DATAA wfd; + HANDLE hfd; + const char *fname = luaL_checkstring(L, 1); + + hfd = FindFirstFileA(fname, &wfd); + if (hfd == NULL) { + lua_pushnumber(L, 0); + lua_pushnil(L); + } + else { + lua_pushnumber(L, (long)hfd); + pushFFData(L, &wfd); + } + + return(2); +} + +static int global_FindNextFile(lua_State *L) { + WIN32_FIND_DATAA wfd; + BOOL ok; + long lfd = MYP2HCAST luaL_checknumber(L, 1); + + ok = FindNextFileA((HANDLE)lfd, &wfd); + lua_pushboolean(L, ok); + if (!ok) { + lua_pushnil(L); + } + else { + pushFFData(L, &wfd); + } + + return(2); +} + +static int global_FindClose(lua_State *L) { + long lfd = MYP2HCAST luaL_checknumber(L, 1); + + lua_pushboolean(L, FindClose((HANDLE)lfd)); + + return(2); +} + +static void FreePIDL(LPITEMIDLIST idl) { +/* + Imalloc *m; + SHGetmalloc(&m); + if (m != NULL) + m->lpVtbl->Free(m, idl); + m->lpVtbl->Release(m); +*/ +} + +static int global_SHGetSpecialFolderLocation(lua_State *L) { + LPITEMIDLIST idl; + char out[MAX_PATH]; + int ifolder = (int)luaL_checknumber(L, 1); + + if (SHGetSpecialFolderLocation(GetDesktopWindow(), + ifolder, &idl) != NOERROR) { + lua_pushnil(L); + } + else { + if (!SHGetPathFromIDListA(idl, out)) + lua_pushnil(L); + else + lua_pushstring(L, out); + FreePIDL(idl); + } + + return 1; +} + +static int global_GetFullPathName(lua_State *L) { + DWORD le; + DWORD rc; + char fpname[MAX_PATH]; + char *fpart; + const char *pname = luaL_checkstring(L, 1); + + rc = GetFullPathNameA(pname, sizeof(fpname), fpname, &fpart); + if (!rc) { + le = GetLastError(); + lua_pushnumber(L, 0); + lua_pushnil(L); + lua_pushnumber(L, le); + } + else { + lua_pushnumber(L, rc); + lua_pushstring(L, fpname); + lua_pushnil(L); + } + + return 3; +} + +BOOL __declspec(dllimport) __stdcall +CheckTokenMembership(HANDLE TokenHandle, PSID SidToCheck, PBOOL IsMember); +static int global_IsUserAdmin(lua_State *L) { + BOOL b; + SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY; + PSID AdministratorsGroup; + + b = AllocateAndInitializeSid( + &NtAuthority, + 2, + SECURITY_BUILTIN_DOMAIN_RID, + DOMAIN_ALIAS_RID_ADMINS, + 0, 0, 0, 0, 0, 0, + &AdministratorsGroup); + if (b) { + if (!CheckTokenMembership(NULL, AdministratorsGroup, &b)) + b = FALSE; + FreeSid(AdministratorsGroup); + } + + lua_pushboolean(L, b); + + return 1; +} + + +static int global_OpenProcess(lua_State *L) { + HANDLE h; + DWORD da = (DWORD)luaL_checknumber(L, 1); + BOOL ih = (BOOL)luaL_checknumber(L, 2); + DWORD pid = (DWORD)luaL_checknumber(L, 3); + + h = OpenProcess(da, ih, pid); + if (h != NULL) + lua_pushnumber(L, (long)h); + else + lua_pushnil(L); + + return 1; +} + +static int global_IsRunning(lua_State *L) { + HANDLE h; + BOOL b = FALSE; + DWORD pid = (DWORD)luaL_checknumber(L, 1); + + h = OpenProcess(SYNCHRONIZE, FALSE, pid); + if (h != NULL) { + b = TRUE; + CloseHandle(h); + } + + lua_pushboolean(L, b); + + return 1; +} + +static int global_GetWindowThreadProcessId(lua_State *L) { + long h = MYP2HCAST luaL_checknumber(L, 1); + DWORD tid, pid; + + tid = GetWindowThreadProcessId((HWND)h, &pid); + lua_pushnumber(L, (long)tid); + lua_pushnumber(L, (long)pid); + + return 2; +} + +static int global_OpenSCManager(lua_State *L) { + SC_HANDLE h; + + h = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); + lua_pushnumber(L, (long)h); + + return 1; +} + +static int global_OpenService(lua_State *L) { + SC_HANDLE h; + long scm = MYP2HCAST luaL_checknumber(L, 1); + const char *sname = luaL_checkstring(L, 2); + + h = OpenServiceA((SC_HANDLE)scm, sname, SERVICE_ALL_ACCESS); + lua_pushnumber(L, (long)h); + + return 1; +} + +static int global_CloseServiceHandle(lua_State *L) { + long h = MYP2HCAST luaL_checknumber(L, 1); + + lua_pushboolean(L, CloseServiceHandle((SC_HANDLE)h)); + + return 1; +} + +static int global_QueryServiceStatus(lua_State *L) { + SERVICE_STATUS ss; + BOOL brc; + long h = MYP2HCAST luaL_checknumber(L, 1); + + brc = QueryServiceStatus((SC_HANDLE)h, &ss); + lua_pushboolean(L, brc); + if (brc) { + lua_pushnumber(L, (long)(ss.dwServiceType)); + lua_pushnumber(L, (long)(ss.dwCurrentState)); + lua_pushnumber(L, (long)(ss.dwControlsAccepted)); + lua_pushnumber(L, (long)(ss.dwWin32ExitCode)); + lua_pushnumber(L, (long)(ss.dwServiceSpecificExitCode)); + lua_pushnumber(L, (long)(ss.dwCheckPoint)); + lua_pushnumber(L, (long)(ss.dwWaitHint)); + return 8; + } + else + return 1; +} + +static int global_QueryServiceConfig(lua_State *L) { + union { + QUERY_SERVICE_CONFIGA sc; + char buf[4096]; + } storage; + BOOL brc; + DWORD needed = 0, errcode = 0; + long h = MYP2HCAST luaL_checknumber(L, 1); + + brc = QueryServiceConfig((SC_HANDLE)h, (LPQUERY_SERVICE_CONFIG)&storage, sizeof(storage), &needed); + if (!brc) { + errcode = GetLastError(); + } + + lua_pushboolean(L, brc); + if (brc) { + // todo: add other values, if needed + lua_pushnumber(L, (long)(storage.sc.dwServiceType)); + lua_pushnumber(L, (long)(storage.sc.dwStartType)); + lua_pushnumber(L, (long)(storage.sc.dwErrorControl)); + lua_pushstring(L, storage.sc.lpBinaryPathName); + lua_pushstring(L, storage.sc.lpDisplayName); + return 6; + } + else { + lua_pushnumber(L, (long)(errcode)); + return 2; + } +} + +static int global_ControlService(lua_State *L) { + SERVICE_STATUS ss; + BOOL brc; + long h = MYP2HCAST luaL_checknumber(L, 1); + DWORD c = (DWORD)luaL_checknumber(L, 2); + + brc = ControlService((SC_HANDLE)h, c, &ss); + lua_pushboolean(L, brc); + + return 1; +} + +static int global_DeleteService(lua_State *L) { + long h = MYP2HCAST luaL_checknumber(L, 1); + + lua_pushboolean(L, DeleteService((SC_HANDLE)h)); + + return 1; +} + +static int global_StartService(lua_State *L) { + long h = MYP2HCAST luaL_checknumber(L, 1); + + lua_pushboolean(L, StartService((SC_HANDLE)h, 0, NULL)); + + return 1; +} + +static int global_mciSendString(lua_State *L) { + const char *cmd = luaL_checkstring(L, 1); // only one string parameter is used + + long lrc = (long)mciSendStringA(cmd, NULL, 0, NULL); + + lua_pushnumber(L, lrc); + + return(1); +} + +static int global_MessageBeep(lua_State *L) { + const UINT uType = luaL_checkinteger(L, 1); + + BOOL rc = MessageBeep(uType); + + lua_pushboolean(L, rc); + + return(1); +} + +static int global_Beep(lua_State *L) { + const DWORD dwFreq = luaL_checkinteger(L, 1); + const DWORD dwDuration = luaL_checkinteger(L, 2); + + BOOL rc = Beep(dwFreq, dwDuration); + + lua_pushboolean(L, rc); + + return(1); +} + +static int global_CoInitialize(lua_State *L) { + long lrc = (long)CoInitialize(NULL); + lua_pushinteger(L, lrc); + return(1); +} + +static int global_CoUninitialize(lua_State *L) { + CoUninitialize(); + return(0); +} + + +/* Module exported function */ + +static struct { + char *name; + DWORD value; +} consts[] = { + { "TRUE", TRUE }, + { "FALSE", FALSE }, + { "INVALID_HANDLE_VALUE", (unsigned long)INVALID_HANDLE_VALUE }, + { "INFINITE", INFINITE }, + { "EVENT_ALL_ACCESS", EVENT_ALL_ACCESS }, + { "EVENT_MODIFY_STATE", EVENT_MODIFY_STATE }, + { "SYNCHRONIZE", SYNCHRONIZE }, + { "MUTEX_ALL_ACCESS", MUTEX_ALL_ACCESS }, + { "SEMAPHORE_ALL_ACCESS", SEMAPHORE_ALL_ACCESS }, + { "SEMAPHORE_MODIFY_STATE", SEMAPHORE_MODIFY_STATE }, + { "WAIT_OBJECT_0", WAIT_OBJECT_0 }, + { "WAIT_ABANDONED_0", WAIT_ABANDONED_0 }, + { "WAIT_ABANDONED", WAIT_ABANDONED }, + { "WAIT_TIMEOUT", WAIT_TIMEOUT }, + { "WAIT_FAILED", WAIT_FAILED }, + { "CREATE_DEFAULT_ERROR_MODE", CREATE_DEFAULT_ERROR_MODE }, + { "CREATE_NEW_CONSOLE", CREATE_NEW_CONSOLE }, + { "CREATE_NEW_PROCESS_GROUP", CREATE_NEW_PROCESS_GROUP }, + { "CREATE_SUSPENDED", CREATE_SUSPENDED }, + { "CREATE_UNICODE_ENVIRONMENT", CREATE_UNICODE_ENVIRONMENT }, + { "DETACHED_PROCESS", DETACHED_PROCESS }, + { "HIGH_PRIORITY_CLASS", HIGH_PRIORITY_CLASS }, + { "IDLE_PRIORITY_CLASS", IDLE_PRIORITY_CLASS }, + { "NORMAL_PRIORITY_CLASS", NORMAL_PRIORITY_CLASS }, + { "REALTIME_PRIORITY_CLASS", REALTIME_PRIORITY_CLASS }, + { "FOREGROUND_BLUE", FOREGROUND_BLUE }, + { "FOREGROUND_GREEN", FOREGROUND_GREEN }, + { "FOREGROUND_RED", FOREGROUND_RED }, + { "FOREGROUND_INTENSITY", FOREGROUND_INTENSITY }, + { "BACKGROUND_BLUE", BACKGROUND_BLUE }, + { "BACKGROUND_GREEN", BACKGROUND_GREEN }, + { "BACKGROUND_RED", BACKGROUND_RED }, + { "BACKGROUND_INTENSITY", BACKGROUND_INTENSITY }, + { "STARTF_FORCEONFEEDBACK", STARTF_FORCEONFEEDBACK }, + { "STARTF_FORCEOFFFEEDBACK", STARTF_FORCEOFFFEEDBACK }, + { "STARTF_RUNFULLSCREEN", STARTF_RUNFULLSCREEN }, + { "STARTF_USECOUNTCHARS", STARTF_USECOUNTCHARS }, + { "STARTF_USEFILLATTRIBUTE", STARTF_USEFILLATTRIBUTE }, + { "STARTF_USEPOSITION", STARTF_USEPOSITION }, + { "STARTF_USESHOWWINDOW", STARTF_USESHOWWINDOW }, + { "STARTF_USESIZE", STARTF_USESIZE }, + { "STARTF_USESTDHANDLES", STARTF_USESTDHANDLES }, + { "SW_HIDE", SW_HIDE }, + { "SW_MAXIMIZE", SW_MAXIMIZE }, + { "SW_MINIMIZE", SW_MINIMIZE }, + { "SW_RESTORE", SW_RESTORE }, + { "SW_SHOW", SW_SHOW }, + { "SW_SHOWDEFAULT", SW_SHOWDEFAULT }, + { "SW_SHOWMAXIMIZED", SW_SHOWMAXIMIZED }, + { "SW_SHOWMINIMIZED", SW_SHOWMINIMIZED }, + { "SW_SHOWMINNOACTIVE", SW_SHOWMINNOACTIVE }, + { "SW_SHOWNA", SW_SHOWNA }, + { "SW_SHOWNOACTIVATE", SW_SHOWNOACTIVATE }, + { "SW_SHOWNORMAL", SW_SHOWNORMAL }, + { "GENERIC_READ", GENERIC_READ }, + { "GENERIC_WRITE", GENERIC_WRITE }, + { "MAXIMUM_ALLOWED", MAXIMUM_ALLOWED }, + { "GENERIC_EXECUTE", GENERIC_EXECUTE }, + { "GENERIC_ALL", GENERIC_ALL }, + { "FILE_SHARE_READ", FILE_SHARE_READ }, + { "FILE_SHARE_WRITE", FILE_SHARE_WRITE }, + { "CREATE_NEW", CREATE_NEW }, + { "CREATE_ALWAYS", CREATE_ALWAYS }, + { "OPEN_EXISTING", OPEN_EXISTING }, + { "OPEN_ALWAYS", OPEN_ALWAYS }, + { "TRUNCATE_EXISTING", TRUNCATE_EXISTING }, + { "FILE_ATTRIBUTE_ARCHIVE", FILE_ATTRIBUTE_ARCHIVE }, + { "FILE_ATTRIBUTE_ENCRYPTED", FILE_ATTRIBUTE_ENCRYPTED }, + { "FILE_ATTRIBUTE_HIDDEN", FILE_ATTRIBUTE_HIDDEN }, + { "FILE_ATTRIBUTE_NORMAL", FILE_ATTRIBUTE_NORMAL }, + { "FILE_ATTRIBUTE_NOT_CONTENT_INDEXED", FILE_ATTRIBUTE_NOT_CONTENT_INDEXED }, + { "FILE_ATTRIBUTE_OFFLINE", FILE_ATTRIBUTE_OFFLINE }, + { "FILE_ATTRIBUTE_READONLY", FILE_ATTRIBUTE_READONLY }, + { "FILE_ATTRIBUTE_SYSTEM", FILE_ATTRIBUTE_SYSTEM }, + { "FILE_ATTRIBUTE_TEMPORARY", FILE_ATTRIBUTE_TEMPORARY }, + { "FILE_FLAG_FIRST_PIPE_INSTANCE", FILE_FLAG_FIRST_PIPE_INSTANCE }, + { "FILE_FLAG_WRITE_THROUGH", FILE_FLAG_WRITE_THROUGH }, + { "FILE_FLAG_OVERLAPPED", FILE_FLAG_OVERLAPPED }, + { "FILE_FLAG_NO_BUFFERING", FILE_FLAG_NO_BUFFERING }, + { "FILE_FLAG_RANDOM_ACCESS", FILE_FLAG_RANDOM_ACCESS }, + { "FILE_FLAG_SEQUENTIAL_SCAN", FILE_FLAG_SEQUENTIAL_SCAN }, + { "FILE_FLAG_DELETE_ON_CLOSE", FILE_FLAG_DELETE_ON_CLOSE }, + { "FILE_FLAG_POSIX_SEMANTICS", FILE_FLAG_POSIX_SEMANTICS }, + { "FILE_FLAG_OPEN_REPARSE_POINT", FILE_FLAG_OPEN_REPARSE_POINT }, + { "FILE_FLAG_OPEN_NO_RECALL", FILE_FLAG_OPEN_NO_RECALL }, + { "SECURITY_ANONYMOUS", SECURITY_ANONYMOUS }, + { "SECURITY_IDENTIFICATION", SECURITY_IDENTIFICATION }, + { "SECURITY_IMPERSONATION", SECURITY_IMPERSONATION }, + { "SECURITY_DELEGATION", SECURITY_DELEGATION }, + { "SECURITY_CONTEXT_TRACKING", SECURITY_CONTEXT_TRACKING }, + { "SECURITY_EFFECTIVE_ONLY", SECURITY_EFFECTIVE_ONLY }, + { "PM_REMOVE", PM_REMOVE }, + { "PM_NOREMOVE", PM_NOREMOVE }, + + { "PIPE_ACCESS_DUPLEX", PIPE_ACCESS_DUPLEX }, + { "PIPE_ACCESS_INBOUND", PIPE_ACCESS_INBOUND }, + { "PIPE_ACCESS_OUTBOUND", PIPE_ACCESS_OUTBOUND }, + { "PIPE_TYPE_BYTE", PIPE_TYPE_BYTE }, + { "PIPE_TYPE_MESSAGE", PIPE_TYPE_MESSAGE }, + { "PIPE_READMODE_BYTE", PIPE_READMODE_BYTE }, + { "PIPE_READMODE_MESSAGE", PIPE_READMODE_MESSAGE }, + { "PIPE_WAIT", PIPE_WAIT }, + { "PIPE_NOWAIT", PIPE_NOWAIT }, + { "PIPE_ACCEPT_REMOTE_CLIENTS", PIPE_ACCEPT_REMOTE_CLIENTS }, + { "PIPE_REJECT_REMOTE_CLIENTS", PIPE_REJECT_REMOTE_CLIENTS }, + { "WRITE_DAC", WRITE_DAC }, + { "WRITE_OWNER", WRITE_OWNER }, + { "ACCESS_SYSTEM_SECURITY", ACCESS_SYSTEM_SECURITY }, + + + { "HKEY_CLASSES_ROOT", (unsigned long)HKEY_CLASSES_ROOT }, + { "HKEY_CURRENT_CONFIG", (unsigned long)HKEY_CURRENT_CONFIG }, + { "HKEY_CURRENT_USER", (unsigned long)HKEY_CURRENT_USER }, + { "HKEY_LOCAL_MACHINE", (unsigned long)HKEY_LOCAL_MACHINE }, + { "HKEY_USERS", (unsigned long)HKEY_USERS }, + { "REG_BINARY", REG_BINARY }, + { "REG_DWORD", REG_DWORD }, + { "REG_DWORD_BIG_ENDIAN", REG_DWORD_BIG_ENDIAN }, + { "REG_EXPAND_SZ", REG_EXPAND_SZ }, + { "REG_MULTI_SZ", REG_MULTI_SZ }, + { "REG_SZ", REG_SZ }, + { "CSIDL_STARTUP", CSIDL_STARTUP }, + { "CSIDL_STARTMENU", CSIDL_STARTMENU }, + { "CSIDL_COMMON_PROGRAMS", CSIDL_COMMON_PROGRAMS }, + { "CSIDL_COMMON_STARTUP", CSIDL_COMMON_STARTUP }, + { "CSIDL_COMMON_STARTMENU", CSIDL_COMMON_STARTMENU }, + { "CSIDL_PROGRAM_FILES", 38 }, + { "SERVICE_CONTROL_STOP", SERVICE_CONTROL_STOP }, + { "SERVICE_CONTROL_PAUSE", SERVICE_CONTROL_PAUSE }, + { "SERVICE_CONTROL_CONTINUE", SERVICE_CONTROL_CONTINUE }, + { "SERVICE_CONTROL_INTERROGATE", SERVICE_CONTROL_INTERROGATE }, + { "SERVICE_CONTROL_SHUTDOWN", SERVICE_CONTROL_SHUTDOWN }, + + { "SERVICE_STOPPED", SERVICE_STOPPED }, + { "SERVICE_START_PENDING", SERVICE_START_PENDING }, + { "SERVICE_STOP_PENDING", SERVICE_STOP_PENDING }, + { "SERVICE_RUNNING", SERVICE_RUNNING }, + { "SERVICE_CONTINUE_PENDING", SERVICE_CONTINUE_PENDING }, + { "SERVICE_PAUSE_PENDING", SERVICE_PAUSE_PENDING }, + { "SERVICE_PAUSED", SERVICE_PAUSED }, + + { "SERVICE_BOOT_START", SERVICE_BOOT_START }, + { "SERVICE_SYSTEM_START", SERVICE_SYSTEM_START }, + { "SERVICE_AUTO_START", SERVICE_AUTO_START }, + { "SERVICE_DEMAND_START", SERVICE_DEMAND_START }, + { "SERVICE_DISABLED", SERVICE_DISABLED }, + + { "MB_ICONASTERISK", MB_ICONASTERISK }, + { "MB_ICONEXCLAMATION", MB_ICONEXCLAMATION }, + { "MB_ICONERROR", MB_ICONERROR }, + { "MB_ICONHAND", MB_ICONHAND }, + { "MB_ICONINFORMATION", MB_ICONINFORMATION }, + { "MB_ICONQUESTION", MB_ICONQUESTION }, + { "MB_ICONSTOP", MB_ICONSTOP }, + { "MB_ICONWARNING", MB_ICONWARNING }, + { "MB_OK", MB_OK }, + + { "BM_CLICK", BM_CLICK }, + { NULL, 0 } +}; + +/***********************************************/ + +static luaL_Reg winApi[] = +{ + { "MessageBox", lua_MessageBox }, + + { "ShellExecute", lua_ShellExecute }, + + { "Find", lua_Find }, + + { "GetKeyState", lua_GetKeyState }, + + { "GetIniValue", lua_GetIniValue }, + { "SetIniValue", lua_SetIniValue }, + { "DeleteIniValue", lua_DeleteIniValue }, + + { "GetRegValue", lua_GetRegValue }, + { "SetRegValue", lua_SetRegValue }, + { "DeleteRegValue", lua_DeleteRegValue }, + + { "ShellOpen", global_ShellOpen }, + { "FindWindow", global_FindWindow }, + { "FindWindowEx", global_FindWindowEx }, + { "SetFocus", global_SetFocus }, + { "GetWindowText", global_GetWindowText }, + { "SetWindowText", global_SetWindowText }, + { "GetWindowRect", global_GetWindowRect }, + { "RegisterHotKey", global_RegisterHotKey }, + { "SetForegroundWindow", global_SetForegroundWindow }, + { "PostMessage", global_PostMessage }, + { "PostThreadMessage", global_PostThreadMessage }, + { "GetMessage", global_GetMessage }, + { "PeekMessage", global_PeekMessage }, + { "ReplyMessage", global_ReplyMessage }, + { "DispatchMessage", global_DispatchMessage }, + { "SetTopmost", global_SetTopmost }, + { "GetLastError", global_GetLastError }, + { "CloseHandle", global_CloseHandle }, + { "CreateEvent", global_CreateEvent }, + { "OpenEvent", global_OpenEvent }, + { "PulseEvent", global_PulseEvent }, + { "ResetEvent", global_ResetEvent }, + { "SetEvent", global_SetEvent }, + { "CreateMutex", global_CreateMutex }, + { "OpenMutex", global_OpenMutex }, + { "ReleaseMutex", global_ReleaseMutex }, + { "CreateSemaphore", global_CreateSemaphore }, + { "OpenSemaphore", global_OpenSemaphore }, + { "ReleaseSemaphore", global_ReleaseSemaphore }, + { "CreateProcess", global_CreateProcess }, + { "GetTempFileName", global_GetTempFileName }, + { "GetTempPath", global_GetTempPath }, + { "CreateNamedPipe", global_CreateNamedPipe }, + { "CreateFile", global_CreateFile }, + { "ReadFile", global_ReadFile }, + { "WriteFile", global_WriteFile }, + { "DeleteFile", global_DeleteFile }, + { "TerminateProcess", global_TerminateProcess }, + { "GetExitCodeProcess", global_GetExitCodeProcess }, + { "WaitForSingleObject", global_WaitForSingleObject }, + { "WaitForMultipleObjects", global_WaitForMultipleObjects }, + { "GetCurrentThreadId", global_GetCurrentThreadId }, + { "RegisterWindowMessage", global_RegisterWindowMessage }, + { "RegQueryValueEx", global_RegQueryValueEx }, + { "RegSetValueEx", global_RegSetValueEx }, + { "RegDeleteKey", global_RegDeleteKey }, + { "RegDeleteValue", global_RegDeleteValue }, + { "RegEnumKeyEx", global_RegEnumKeyEx }, + { "RegEnumValue", global_RegEnumValue }, + { "SetCurrentDirectory", global_SetCurrentDirectory }, + { "SHDeleteKey", global_SHDeleteKey }, + { "Sleep", global_Sleep }, + { "GetVersion", global_GetVersion }, + { "FindFirstFile", global_FindFirstFile }, + { "FindNextFile", global_FindNextFile }, + { "FindClose", global_FindClose }, + { "SHGetSpecialFolderLocation", global_SHGetSpecialFolderLocation }, + { "GetFullPathName", global_GetFullPathName }, + { "IsUserAdmin", global_IsUserAdmin }, + { "OpenProcess", global_OpenProcess }, + { "IsRunning", global_IsRunning }, + { "GetWindowThreadProcessId", global_GetWindowThreadProcessId }, + { "OpenSCManager", global_OpenSCManager }, + { "OpenService", global_OpenService }, + { "CloseServiceHandle", global_CloseServiceHandle }, + { "QueryServiceStatus", global_QueryServiceStatus }, + { "QueryServiceConfig", global_QueryServiceConfig }, + { "ControlService", global_ControlService }, + { "DeleteService", global_DeleteService }, + { "StartService", global_StartService }, + { "mciSendString", global_mciSendString }, + { "MessageBeep", global_MessageBeep }, + { "Beep", global_Beep }, + { "CoInitialize", global_CoInitialize }, + { "CoUninitialize", global_CoUninitialize }, + + + { NULL, NULL } +}; + +LUA_WINAPI_LIB luaopen_WinAPI(lua_State *L) +{ + luaL_newlib(L, winApi); + + for (size_t i = 0; consts[i].name != NULL; i++) + { + lua_pushstring(L, consts[i].name); + lua_pushnumber(L, consts[i].value); + lua_settable(L, -3); + } + + return 1; +} diff --git a/plugins/MirLua/Modules/common.filters b/plugins/MirLua/Modules/common.filters new file mode 100644 index 0000000000..1af5b5334c --- /dev/null +++ b/plugins/MirLua/Modules/common.filters @@ -0,0 +1,32 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav + + + + + + Source Files + + + Header Files + + + Resource Files + + + Source Files + + + \ No newline at end of file diff --git a/plugins/MirLua/Modules/common.props b/plugins/MirLua/Modules/common.props new file mode 100644 index 0000000000..0e6422d781 --- /dev/null +++ b/plugins/MirLua/Modules/common.props @@ -0,0 +1,98 @@ + + + + 10.0 + $(ProjectDir)..\..\..\..\bin10\lib + $(ProjectDir)..\..\..\..\bin12\lib + $(ProjectDir)..\..\..\..\bin14\lib + + + $(ProjectName) + Win32Proj + Unicode + v100 + v110_xp + v120_xp + v140_xp + $(SolutionDir)$(Configuration)\Obj\$(ProjectName)\ + $(SolutionDir)$(Configuration)64\Obj\$(ProjectName)\ + true + false + + + + + + $(ProjectDir)..\..\..\..\include;$(ProjectDir)..\..\..\..\plugins\ExternalAPI;%(AdditionalIncludeDirectories) + _CRT_SECURE_NO_WARNINGS;_CRT_NONSTDC_NO_WARNINGS;_WIN32_WINNT=0x0601;%(PreprocessorDefinitions) + 4995;4996;4312;4091;%(DisableSpecificWarnings) + OnlyExplicitInline + false + Level4 + Use + stdafx.h + false + + + winmm.lib;Wtsapi32.lib;netapi32.lib;pdh.lib;shlwapi.lib;Strmiids.lib;gdiplus.lib;dbghelp.lib;Setupapi.lib;msimg32.lib;comctl32.lib;ws2_32.lib;UxTheme.lib;Iphlpapi.lib;%(AdditionalDependencies) + $(CommonLibDir) + true + false + Windows + $(IntDir)$(TargetName).lib + false + + + $(ProjectDir)..\..\..\..\include;$(ProjectDir)..\..\..\..\include\msapi + + + + + + Disabled + false + DEBUG;%(PreprocessorDefinitions) + true + MultiThreadedDebugDLL + + + + + + + + + + Full + true + Size + true + true + NDEBUG;%(PreprocessorDefinitions) + false + MultiThreadedDLL + true + + + true + true + UseLinkTimeCodeGeneration + /PDBALTPATH:%_PDB% + + + + + + Create + + + + NotUsing + + + + + + + + diff --git a/plugins/MirLua/Modules/module.props b/plugins/MirLua/Modules/module.props new file mode 100644 index 0000000000..59c3cc1d87 --- /dev/null +++ b/plugins/MirLua/Modules/module.props @@ -0,0 +1,31 @@ + + + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + false + false + DynamicLibrary + $(SolutionDir)$(Configuration)\Scripts\ + $(SolutionDir)$(Configuration)64\Scripts\ + + + diff --git a/plugins/MirLua/src/m_hotkeys.cpp b/plugins/MirLua/src/m_hotkeys.cpp index a052f5beb1..030107ebb6 100644 --- a/plugins/MirLua/src/m_hotkeys.cpp +++ b/plugins/MirLua/src/m_hotkeys.cpp @@ -46,8 +46,7 @@ static int lua_Register(lua_State *L) HOTKEYDESC hk; MakeHotkey(L, hk); - - INT_PTR res = ::CallService("CoreHotkeys/Register", (WPARAM)hScriptsLangpack, (LPARAM)&hk); + INT_PTR res = ::CallService("CoreHotkeys/Register", (WPARAM)hLangpack, (LPARAM)&hk); lua_pushboolean(L, res); return 1; diff --git a/plugins/MirLua/src/m_windows.cpp b/plugins/MirLua/src/m_windows.cpp deleted file mode 100644 index 8fec0f21c3..0000000000 --- a/plugins/MirLua/src/m_windows.cpp +++ /dev/null @@ -1,2224 +0,0 @@ -#include "stdafx.h" - -typedef int(__stdcall *MSGBOXAAPI)(IN HWND hWnd, IN LPCSTR lpText, IN LPCSTR lpCaption, IN UINT uType, IN WORD wLanguageId, IN DWORD dwMilliseconds); -typedef int(__stdcall *MSGBOXWAPI)(IN HWND hWnd, IN LPCWSTR lpText, IN LPCWSTR lpCaption, IN UINT uType, IN WORD wLanguageId, IN DWORD dwMilliseconds); - -int MessageBoxTimeoutA(IN HWND hWnd, IN LPCSTR lpText, IN LPCSTR lpCaption, IN UINT uType, IN WORD wLanguageId, IN DWORD dwMilliseconds); -int MessageBoxTimeoutW(IN HWND hWnd, IN LPCWSTR lpText, IN LPCWSTR lpCaption, IN UINT uType, IN WORD wLanguageId, IN DWORD dwMilliseconds); - -#ifdef UNICODE - #define MessageBoxTimeout MessageBoxTimeoutW -#else - #define MessageBoxTimeout MessageBoxTimeoutA -#endif - -#define MB_TIMEDOUT 32000 - -int MessageBoxTimeoutA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType, WORD wLanguageId, DWORD dwMilliseconds) -{ - static MSGBOXAAPI MsgBoxTOA = NULL; - - if (!MsgBoxTOA) - { - if (HMODULE hUser32 = GetModuleHandle(_T("user32.dll"))) - { - MsgBoxTOA = (MSGBOXAAPI)GetProcAddress(hUser32, "MessageBoxTimeoutA"); - FreeLibrary(hUser32); - } - } - - if (MsgBoxTOA) - { - return MsgBoxTOA(hWnd, lpText, lpCaption, uType, wLanguageId, dwMilliseconds); - } - - return MessageBoxA(hWnd, lpText, lpCaption, uType); -} - -int MessageBoxTimeoutW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType, WORD wLanguageId, DWORD dwMilliseconds) -{ - static MSGBOXWAPI MsgBoxTOW = NULL; - - if (!MsgBoxTOW) - { - if (HMODULE hUser32 = GetModuleHandle(_T("user32.dll"))) - { - MsgBoxTOW = (MSGBOXWAPI)GetProcAddress(hUser32, "MessageBoxTimeoutW"); - FreeLibrary(hUser32); - } - - } - - if (MsgBoxTOW) - { - return MsgBoxTOW(hWnd, lpText, lpCaption, uType, wLanguageId, dwMilliseconds); - } - - return MessageBoxW(hWnd, lpText, lpCaption, uType); -} - -static int lua_MessageBox(lua_State *L) -{ - HWND hwnd = (HWND)lua_touserdata(L, 1); - ptrT text(mir_utf8decodeT(lua_tostring(L, 2))); - ptrT caption(mir_utf8decodeT(lua_tostring(L, 3))); - UINT flags = lua_tointeger(L, 4); - LANGID langId = GetUserDefaultUILanguage(); - DWORD timeout = luaL_optinteger(L, 5, 0xFFFFFFFF); - - int res = ::MessageBoxTimeout(hwnd, text, caption, flags, langId, timeout); - lua_pushinteger(L, res); - - return 1; -} - -/***********************************************/ - -static int lua_ShellExecute(lua_State *L) -{ - ptrT command(mir_utf8decodeT(lua_tostring(L, 1))); - ptrT file(mir_utf8decodeT(lua_tostring(L, 2))); - ptrT args(mir_utf8decodeT(lua_tostring(L, 3))); - int flags = lua_tointeger(L, 4); - - ::ShellExecute(NULL, command, file, args, NULL, flags); - - return 0; -} - -/***********************************************/ - -static int lua_FindIterator(lua_State *L) -{ - HANDLE hFind = lua_touserdata(L, lua_upvalueindex(1)); - TCHAR* path = (TCHAR*)lua_touserdata(L, lua_upvalueindex(2)); - - WIN32_FIND_DATA ffd = { 0 }; - if (hFind == NULL) - { - hFind = FindFirstFile(path, &ffd); - if (hFind == INVALID_HANDLE_VALUE) - { - mir_free(path); - lua_pushnil(L); - return 1; - } - } - else - { - if (FindNextFile(hFind, &ffd) == 0) - { - FindClose(hFind); - mir_free(path); - lua_pushnil(L); - return 1; - } - } - - if (!mir_tstrcmpi(ffd.cFileName, _T(".")) || - !mir_tstrcmpi(ffd.cFileName, _T("..")) || - (ffd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) - { - lua_pushlightuserdata(L, hFind); - lua_replace(L, lua_upvalueindex(1)); - - return lua_FindIterator(L); - } - - LARGE_INTEGER size; - size.HighPart = ffd.nFileSizeHigh; - size.LowPart = ffd.nFileSizeLow; - - lua_newtable(L); - lua_pushliteral(L, "Name"); - lua_pushstring(L, T2Utf(ffd.cFileName)); - lua_settable(L, -3); - lua_pushliteral(L, "Size"); - lua_pushinteger(L, size.QuadPart); - lua_settable(L, -3); - lua_pushliteral(L, "IsFile"); - lua_pushboolean(L, !(ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)); - lua_settable(L, -3); - lua_pushliteral(L, "IsDirectory"); - lua_pushboolean(L, ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY); - lua_settable(L, -3); - - lua_pushlightuserdata(L, hFind); - lua_replace(L, lua_upvalueindex(1)); - - return 1; -} - -static int lua_Find(lua_State *L) -{ - TCHAR *path = mir_utf8decodeT(luaL_checkstring(L, 1)); - - lua_pushlightuserdata(L, NULL); - lua_pushlightuserdata(L, path); - lua_pushcclosure(L, lua_FindIterator, 2); - - return 1; -} - -static int lua_GetKeyState(lua_State *L) -{ - int vKey = luaL_checkinteger(L, 1); - - int res = GetKeyState(vKey); - lua_pushinteger(L, res); - - return 1; -} - -/***********************************************/ - -static int lua_GetIniValue(lua_State *L) -{ - ptrT path(mir_utf8decodeT(luaL_checkstring(L, 1))); - ptrT section(mir_utf8decodeT(luaL_checkstring(L, 2))); - ptrT key(mir_utf8decodeT(luaL_checkstring(L, 3))); - - if (lua_isinteger(L, 4)) - { - int default = lua_tointeger(L, 4); - - UINT res = ::GetPrivateProfileInt(section, key, default, path); - lua_pushinteger(L, res); - - return 1; - } - - ptrT default(mir_utf8decodeT(lua_tostring(L, 4))); - - TCHAR value[MAX_PATH] = { 0 }; - if (!::GetPrivateProfileString(section, key, default, value, _countof(value), path)) - { - lua_pushvalue(L, 4); - } - - ptrA res(mir_utf8encodeT(value)); - lua_pushstring(L, res); - - return 1; -} - -static int lua_SetIniValue(lua_State *L) -{ - ptrT path(mir_utf8decodeT(luaL_checkstring(L, 1))); - ptrT section(mir_utf8decodeT(luaL_checkstring(L, 2))); - ptrT key(mir_utf8decodeT(luaL_checkstring(L, 3))); - ptrT value(mir_utf8decodeT(lua_tostring(L, 4))); - - bool res = ::WritePrivateProfileString(section, key, value, path) != 0; - lua_pushboolean(L, res); - - return 1; -} - -static int lua_DeleteIniValue(lua_State *L) -{ - ptrT path(mir_utf8decodeT(luaL_checkstring(L, 1))); - ptrT section(mir_utf8decodeT(luaL_checkstring(L, 2))); - ptrT key(mir_utf8decodeT(luaL_checkstring(L, 3))); - - bool res = ::WritePrivateProfileString(section, key, NULL, path) != 0; - lua_pushboolean(L, res); - - return 1; -} - -/***********************************************/ - -static int lua_GetRegValue(lua_State *L) -{ - HKEY hRootKey = (HKEY)lua_touserdata(L, 1); - ptrT path(mir_utf8decodeT(luaL_checkstring(L, 2))); - ptrT valueName(mir_utf8decodeT(luaL_checkstring(L, 3))); - - HKEY hKey = 0; - LSTATUS res = ::RegOpenKeyEx(hRootKey, path, NULL, KEY_READ, &hKey); - if (res != ERROR_SUCCESS) - { - lua_pushvalue(L, 4); - return 1; - } - - DWORD type = 0; - DWORD length = 1024; - BYTE* value = (BYTE*)mir_alloc(length); - res = ::RegQueryValueEx(hKey, valueName, NULL, &type, (LPBYTE)value, &length); - while (res == ERROR_MORE_DATA) - { - length += length; - value = (BYTE*)mir_realloc(value, length); - res = ::RegQueryValueEx(hKey, valueName, NULL, &type, (LPBYTE)value, &length); - } - - if (res == ERROR_SUCCESS) - { - switch (type) - { - case REG_DWORD: - case REG_DWORD_BIG_ENDIAN: - lua_pushinteger(L, (INT_PTR)value); - break; - - case REG_QWORD: - lua_pushnumber(L, (INT_PTR)value); - break; - - case REG_SZ: - case REG_LINK: - case REG_EXPAND_SZ: - { - ptrA str(Utf8EncodeT((TCHAR*)value)); - lua_pushlstring(L, str, mir_strlen(str)); - } - break; - - default: - lua_pushvalue(L, 4); - break; - } - } - else - lua_pushvalue(L, 4); - - ::RegCloseKey(hKey); - mir_free(value); - - return 1; -} - -static int lua_SetRegValue(lua_State *L) -{ - HKEY hRootKey = (HKEY)lua_touserdata(L, 1); - ptrT path(mir_utf8decodeT(luaL_checkstring(L, 2))); - ptrT valueName(mir_utf8decodeT(luaL_checkstring(L, 3))); - - HKEY hKey = 0; - LSTATUS res = ::RegOpenKeyEx(hRootKey, path, NULL, KEY_WRITE, &hKey); - if (res != ERROR_SUCCESS) - { - lua_pushboolean(L, FALSE); - return 1; - } - - DWORD type = 0; - DWORD length = 0; - BYTE* value = NULL; - switch (lua_type(L, 4)) - { - case LUA_TNUMBER: - if (lua_isinteger(L, 4) && lua_tointeger(L, 4) < UINT32_MAX) - { - type = REG_DWORD; - length = sizeof(DWORD); - value = (BYTE*)lua_tointeger(L, 4); - } - else - { - type = REG_QWORD; - length = sizeof(DWORD) * 2; - lua_Number num = lua_tonumber(L, 4); - value = (BYTE*)# - } - break; - - case LUA_TSTRING: - type = REG_SZ; - length = mir_strlen(lua_tostring(L, 4)) * sizeof(TCHAR); - value = (BYTE*)mir_utf8decodeT(lua_tostring(L, 4)); - break; - - default: - lua_pushboolean(L, FALSE); - break; - } - - res = ::RegSetValueEx(hKey, valueName, NULL, type, value, length); - lua_pushboolean(L, res == ERROR_SUCCESS); - - ::RegCloseKey(hKey); - if (lua_isstring(L, 4)) - mir_free(value); - - return 1; -} - -static int lua_DeleteRegValue(lua_State *L) -{ - HKEY hRootKey = (HKEY)lua_touserdata(L, 1); - ptrT path(mir_utf8decodeT(luaL_checkstring(L, 2))); - ptrT valueName(mir_utf8decodeT(luaL_checkstring(L, 3))); - - HKEY hKey = 0; - LSTATUS res = ::RegOpenKeyEx(hRootKey, path, NULL, KEY_WRITE, &hKey); - if (res != ERROR_SUCCESS) - { - lua_pushboolean(L, FALSE); - return 1; - } - - res = ::RegDeleteValue(hKey, valueName); - lua_pushboolean(L, res == ERROR_SUCCESS); - - ::RegCloseKey(hKey); - - return 1; -} - - - -/****h* Win32/luaw32.c [$Revision: 13 $] -* NAME -* luaw32 -* COPYRIGHT -* (C) 2004-2007 Daniel Quintela. All rights reserved. -* http://www.soongsoft.com mailto:dq@soongsoft.com -* (C) 2013 http://quik2dde.ru -* LICENSE -* Permission is hereby granted, free of charge, to any person obtaining -* a copy of this software and associated documentation files (the -* "Software"), to deal in the Software without restriction, including -* without limitation the rights to use, copy, modify, merge, publish, -* distribute, sublicense, and/or sell copies of the Software, and to -* permit persons to whom the Software is furnished to do so, subject to -* the following conditions: -* -* The above copyright notice and this permission notice shall be -* included in all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -* FUNCTION -* Win32 functions & constants binding.. -* AUTHOR -* Daniel Quintela -* CREATION DATE -* 2004/08/16 -* MODIFICATION HISTORY -* $Id: luaw32.c 13 2007-04-15 13:39:04Z $ -* -* When Who What -* ------------------- ---------------- ---------------------------------------- -* 2004-09-01 12:20:00 Danilo Tuler GetTempPath added. -* 2006-08-25 08:20:00 Denis Povshedny QueryServiceConfig & StartService added. -* 2007-04-15 10:31:00 Daniel Quintela CreateMutex parameter list fixed. -* 2013-10-27 00:00:15 www.quik2dde.ru Linking with qlia.dll -* -* NOTES -* -***/ - - -#include -#include -#include -#include - -#undef Translate -#include -#include - -#include - -#include -#include -#include -#include - -#define MYP2HCAST (long) - -/* Registered functions */ - -static int global_ShellOpen(lua_State *L) { - long lrc; - const char *fileref = luaL_checkstring(L, 1); - - lrc = (long)ShellExecuteA(NULL, "open", fileref, NULL, NULL, SW_SHOW); - - if (lrc > 32) - lrc = 0; - - lua_pushnumber(L, lrc); - - return(1); -} - -static int global_FindWindow(lua_State *L) { - long lrc; - const char *cname = luaL_checkstring(L, 1); - const char *wname = luaL_checkstring(L, 2); - - lrc = (long)FindWindowA(cname[0] ? cname : NULL, - wname[0] ? wname : NULL); - - lua_pushnumber(L, lrc); - - return(1); -} - -static int global_FindWindowEx(lua_State *L) { - const HWND parent = (HWND)(int)luaL_checknumber(L, 1); - const HWND childaft = (HWND)(int)luaL_checknumber(L, 2); - const char *cname = luaL_checkstring(L, 3); - const char *wname = luaL_checkstring(L, 4); - - long lrc = (long)FindWindowExA(parent, childaft, - cname[0] ? cname : NULL, - wname[0] ? wname : NULL); - - lua_pushnumber(L, lrc); - - return(1); -} - -static int global_SetWindowText(lua_State *L) { - const HWND hwnd = (HWND)(int)luaL_checknumber(L, 1); - const char *text = luaL_checkstring(L, 2); - - BOOL rc = SetWindowTextA(hwnd, text); - - lua_pushnumber(L, rc); - - return(1); -} - -static int global_SetFocus(lua_State *L) { - const HWND hwnd = (HWND)(int)luaL_checknumber(L, 1); - HWND rc = SetFocus(hwnd); - lua_pushinteger(L, (int)rc); - - return(1); -} - -// Lua: returns nil when error occurred -static int global_GetWindowText(lua_State *L) { - const HWND hwnd = (HWND)(int)luaL_checknumber(L, 1); - char buf[2048]; - - int rc = GetWindowTextA(hwnd, buf, sizeof(buf)); - - if (rc > 0) - lua_pushstring(L, buf); - else if (GetLastError() == ERROR_SUCCESS) - lua_pushstring(L, ""); - else - lua_pushnil(L); - - return(1); -} - -// Lua: returns left,top,right,bottom when successfully -// or -// returns nil when error occurred -static int global_GetWindowRect(lua_State *L) { - const HWND hwnd = (HWND)(int)luaL_checknumber(L, 1); - RECT rect; - - BOOL rc = GetWindowRect(hwnd, &rect); - - if (!rc) { - lua_pushnil(L); - return(1); - } - else { - lua_pushinteger(L, rect.left); - lua_pushinteger(L, rect.top); - lua_pushinteger(L, rect.right); - lua_pushinteger(L, rect.bottom); - return(4); - } -} - -struct S_HKT { - HWND hwnd; - int id; - UINT mdfs; - UINT vk; - UINT umsg; - WPARAM wparam; - LPARAM lparam; -}; - -static void HotKeyThread(void *v) { - struct S_HKT *s = (struct S_HKT *) v; - MSG msg; - - RegisterHotKey(NULL, s->id, s->mdfs, s->vk); - - while (GetMessage(&msg, NULL, 0, 0) > 0) - if (msg.message == WM_HOTKEY) - PostMessage(s->hwnd, s->umsg, s->wparam, s->lparam); -} - -static int global_RegisterHotKey(lua_State *L) { - struct S_HKT *s; - - s = (S_HKT*)mir_alloc(sizeof(struct S_HKT)); - if (s == NULL) - lua_pushnumber(L, -1); - else { - long hwnd = MYP2HCAST luaL_checknumber(L, 1); - s->hwnd = (HWND)hwnd; - s->id = (int)luaL_checknumber(L, 2); - s->mdfs = (UINT)luaL_checknumber(L, 3); - s->vk = (UINT)luaL_checknumber(L, 4); - s->umsg = (UINT)luaL_checknumber(L, 5); - s->wparam = (WPARAM)luaL_checknumber(L, 6); - s->lparam = (LPARAM)luaL_checknumber(L, 7); - - if (_beginthread(HotKeyThread, 0, s) < 0) - lua_pushnumber(L, -2); - else - lua_pushnumber(L, 0); - } - - return(1); -} - -static int global_SetForegroundWindow(lua_State *L) { - long hwnd = MYP2HCAST luaL_checknumber(L, 1); - - lua_pushnumber(L, SetForegroundWindow((HWND)hwnd)); - - return(1); -} - -static int global_PostMessage(lua_State *L) { - BOOL rc; - long hwnd = MYP2HCAST luaL_checknumber(L, 1); - UINT msg = (UINT)luaL_checknumber(L, 2); - WPARAM wparam = (WPARAM)luaL_checknumber(L, 3); - LPARAM lparam = (LPARAM)luaL_checknumber(L, 4); - - rc = PostMessage((HWND)hwnd, msg, wparam, lparam); - - lua_pushnumber(L, rc); - - return(1); -} - -static int global_PostThreadMessage(lua_State *L) { - BOOL rc; - DWORD tid = (DWORD)luaL_checknumber(L, 1); - UINT msg = (UINT)luaL_checknumber(L, 2); - WPARAM wparam = (WPARAM)luaL_checknumber(L, 3); - LPARAM lparam = (LPARAM)luaL_checknumber(L, 4); - - rc = PostThreadMessage(tid, msg, wparam, lparam); - - lua_pushnumber(L, rc); - - return(1); -} - -static int global_GetMessage(lua_State *L) { - MSG msg; - BOOL rc; - long lwnd = MYP2HCAST luaL_optinteger(L, 1, 0); - UINT mfmin = (UINT)luaL_optinteger(L, 2, 0); - UINT mfmax = (UINT)luaL_optinteger(L, 3, 0); - - rc = GetMessage(&msg, (HWND)lwnd, mfmin, mfmax); - - lua_pushnumber(L, rc); - if (rc) { - lua_pushnumber(L, (long)msg.hwnd); - lua_pushnumber(L, msg.message); - lua_pushnumber(L, msg.wParam); - lua_pushnumber(L, msg.lParam); - lua_pushnumber(L, msg.time); - lua_pushnumber(L, msg.pt.x); - lua_pushnumber(L, msg.pt.y); - } - else { - lua_pushnil(L); - lua_pushnil(L); - lua_pushnil(L); - lua_pushnil(L); - lua_pushnil(L); - lua_pushnil(L); - lua_pushnil(L); - } - - return(8); -} - -static int global_PeekMessage(lua_State *L) { - MSG msg; - BOOL rc; - long lwnd = MYP2HCAST luaL_optinteger(L, 1, 0); - UINT mfmin = (UINT)luaL_optinteger(L, 2, 0); - UINT mfmax = (UINT)luaL_optinteger(L, 3, 0); - UINT rmmsg = (UINT)luaL_optinteger(L, 4, PM_NOREMOVE); - - rc = PeekMessage(&msg, (HWND)lwnd, mfmin, mfmax, rmmsg); - - lua_pushnumber(L, rc); - if (rc) { - lua_pushnumber(L, (long)msg.hwnd); - lua_pushnumber(L, msg.message); - lua_pushnumber(L, msg.wParam); - lua_pushnumber(L, msg.lParam); - lua_pushnumber(L, msg.time); - lua_pushnumber(L, msg.pt.x); - lua_pushnumber(L, msg.pt.y); - } - else { - lua_pushnil(L); - lua_pushnil(L); - lua_pushnil(L); - lua_pushnil(L); - lua_pushnil(L); - lua_pushnil(L); - lua_pushnil(L); - } - - return(8); -} - -static int global_ReplyMessage(lua_State *L) { - BOOL rc; - LRESULT result = (LRESULT)luaL_checknumber(L, 1); - - rc = ReplyMessage(result); - - lua_pushboolean(L, rc); - - return(1); -} - -static int global_DispatchMessage(lua_State *L) { - MSG msg; - LRESULT rc; - long hwnd = MYP2HCAST luaL_checknumber(L, 1); - - msg.hwnd = (HWND)hwnd; - msg.message = (UINT)luaL_checknumber(L, 2); - msg.wParam = (WPARAM)luaL_checknumber(L, 3); - msg.lParam = (LPARAM)luaL_checknumber(L, 4); - msg.time = (DWORD)luaL_checknumber(L, 5); - msg.pt.x = (LONG)luaL_checknumber(L, 6); - msg.pt.y = (LONG)luaL_checknumber(L, 7); - - rc = DispatchMessage(&msg); - - lua_pushnumber(L, rc); - - return(1); -} - -static int global_SetTopmost(lua_State *L) { - BOOL rc; - long hwnd = MYP2HCAST luaL_checknumber(L, 1); - - rc = SetWindowPos((HWND)hwnd, HWND_TOPMOST, 0, 0, 0, 0, - SWP_NOMOVE | SWP_NOSIZE); - - lua_pushnumber(L, rc); - - return(1); -} - -/****if* luaw32/global_GetLastError -* NAME -* global_GetLastError -* FUNCTION -* Win32 GetLastError. -* RESULT -* stack[1]: The calling thread's last-error code value -* SOURCE -*/ - -static int global_GetLastError(lua_State *L) { - - lua_pushnumber(L, GetLastError()); - - return(1); -} -/***/ - -/****if* luaw32/global_CloseHandle -* NAME -* global_CloseHandle -* FUNCTION -* Win32 CloseHandle. -* INPUTS -* L: Lua state -* stack[1]: Handle to an open object -* RESULT -* stack[1]: True if ok. -* SOURCE -*/ - -static int global_CloseHandle(lua_State *L) { - long h = MYP2HCAST luaL_checknumber(L, 1); - - lua_pushboolean(L, CloseHandle((HANDLE)h)); - - return(1); -} -/***/ - -static int global_CreateEvent(lua_State *L) { - SECURITY_ATTRIBUTES sa; - BOOL mr = (BOOL)luaL_checknumber(L, 2); - BOOL is = (BOOL)luaL_checknumber(L, 3); - const char *name; - long h; - - sa.nLength = sizeof(sa); - sa.lpSecurityDescriptor = NULL; - sa.bInheritHandle = FALSE; - - if (lua_istable(L, 1)) { - lua_pushstring(L, "bInheritHandle"); - lua_gettable(L, 1); - if (!lua_isnil(L, -1)) - sa.bInheritHandle = (BOOL)luaL_checknumber(L, -1); - lua_pop(L, 1); - } - name = lua_tostring(L, 4); - - h = (long)CreateEventA(&sa, mr, is, name); - - if (h) - lua_pushnumber(L, h); - else - lua_pushnil(L); - - return(1); -} - -static int global_OpenEvent(lua_State *L) { - long h; - DWORD da = (DWORD)luaL_checknumber(L, 1); - BOOL ih = (BOOL)luaL_checknumber(L, 2); - const char *name = luaL_checkstring(L, 3); - - h = (long)OpenEventA(da, ih, name); - - if (h) - lua_pushnumber(L, h); - else - lua_pushnil(L); - - return(1); -} - -static int global_PulseEvent(lua_State *L) { - long h = MYP2HCAST luaL_checknumber(L, 1); - - lua_pushnumber(L, PulseEvent((HANDLE)h)); - - return(1); -} - -static int global_ResetEvent(lua_State *L) { - long h = MYP2HCAST luaL_checknumber(L, 1); - - lua_pushnumber(L, ResetEvent((HANDLE)h)); - - return(1); -} - -static int global_SetEvent(lua_State *L) { - long h = MYP2HCAST luaL_checknumber(L, 1); - - lua_pushnumber(L, SetEvent((HANDLE)h)); - - return(1); -} - -static int global_CreateMutex(lua_State *L) { - SECURITY_ATTRIBUTES sa; - BOOL io = (BOOL)luaL_checknumber(L, 2); - const char *name; - long h; - - sa.nLength = sizeof(sa); - sa.lpSecurityDescriptor = NULL; - sa.bInheritHandle = FALSE; - - if (lua_istable(L, 1)) { - lua_pushstring(L, "bInheritHandle"); - lua_gettable(L, 1); - if (!lua_isnil(L, -1)) - sa.bInheritHandle = (BOOL)luaL_checknumber(L, -1); - lua_pop(L, 1); - } - name = lua_tostring(L, 3); - - h = (long)CreateMutexA(&sa, io, name); - - if (h) - lua_pushnumber(L, h); - else - lua_pushnil(L); - - return(1); -} - -static int global_OpenMutex(lua_State *L) { - long h; - DWORD da = (DWORD)luaL_checknumber(L, 1); - BOOL ih = (BOOL)luaL_checknumber(L, 2); - const char *name = luaL_checkstring(L, 3); - - h = (long)OpenMutexA(da, ih, name); - - if (h) - lua_pushnumber(L, h); - else - lua_pushnil(L); - - return(1); -} - -static int global_ReleaseMutex(lua_State *L) { - long h = MYP2HCAST luaL_checknumber(L, 1); - - lua_pushnumber(L, ReleaseMutex((HANDLE)h)); - - return(1); -} - -static int global_CreateSemaphore(lua_State *L) { - SECURITY_ATTRIBUTES sa; - long ic = (long)luaL_checknumber(L, 2); - long mc = (long)luaL_checknumber(L, 3); - const char *name; - long h; - - sa.nLength = sizeof(sa); - sa.lpSecurityDescriptor = NULL; - sa.bInheritHandle = FALSE; - - if (lua_istable(L, 1)) { - lua_pushstring(L, "bInheritHandle"); - lua_gettable(L, 1); - if (!lua_isnil(L, -1)) - sa.bInheritHandle = (BOOL)luaL_checknumber(L, -1); - lua_pop(L, 1); - } - name = lua_tostring(L, 4); - - h = (long)CreateSemaphoreA(&sa, ic, mc, name); - - if (h) - lua_pushnumber(L, h); - else - lua_pushnil(L); - - return(1); -} - -static int global_OpenSemaphore(lua_State *L) { - long h; - DWORD da = (DWORD)luaL_checknumber(L, 1); - BOOL ih = (BOOL)luaL_checknumber(L, 2); - const char *name = luaL_checkstring(L, 3); - - h = (long)OpenSemaphoreA(da, ih, name); - - if (h) - lua_pushnumber(L, h); - else - lua_pushnil(L); - - return(1); -} - -static int global_ReleaseSemaphore(lua_State *L) { - long pc; - BOOL brc; - long h = MYP2HCAST luaL_checknumber(L, 1); - long rc = (long)luaL_checknumber(L, 2); - - brc = ReleaseSemaphore((HANDLE)h, rc, &pc); - lua_pushnumber(L, brc); - if (brc) - lua_pushnumber(L, pc); - else - lua_pushnil(L); - - return(2); -} - -static int global_CreateProcess(lua_State *L) { - SECURITY_ATTRIBUTES psa; - SECURITY_ATTRIBUTES tsa; - PROCESS_INFORMATION pi; - STARTUPINFOA si; - BOOL brc; - char *env; - const char *an = luaL_optstring(L, 1, NULL); - const char *cl = luaL_optstring(L, 2, NULL); - BOOL ih = (BOOL)luaL_checknumber(L, 5); - DWORD cf = (DWORD)luaL_checknumber(L, 6); - const char *cd = lua_tostring(L, 8); - - psa.nLength = sizeof(psa); - psa.lpSecurityDescriptor = NULL; - psa.bInheritHandle = FALSE; - if (lua_istable(L, 3)) { - lua_pushstring(L, "bInheritHandle"); - lua_gettable(L, 3); - if (!lua_isnil(L, -1)) - psa.bInheritHandle = (BOOL)luaL_checknumber(L, -1); - lua_pop(L, 3); - } - - tsa.nLength = sizeof(tsa); - tsa.lpSecurityDescriptor = NULL; - tsa.bInheritHandle = FALSE; - if (lua_istable(L, 4)) { - lua_pushstring(L, "bInheritHandle"); - lua_gettable(L, 4); - if (!lua_isnil(L, -1)) - tsa.bInheritHandle = (BOOL)luaL_checknumber(L, -1); - lua_pop(L, 4); - } - - env = NULL; - - memset(&si, 0, sizeof(si)); - si.cb = sizeof(si); - if (lua_istable(L, 7)) { - lua_pushnil(L); - while (lua_next(L, 7) != 0) { - const char *key = luaL_checkstring(L, -2); - if (!mir_strcmp(key, "lpDesktop")) { - si.lpDesktop = mir_strdup(luaL_checkstring(L, -1)); - } - else if (!mir_strcmp(key, "lpTitle")) { - si.lpTitle = mir_strdup(luaL_checkstring(L, -1)); - } - else if (!mir_strcmp(key, "dwX")) { - si.dwX = (DWORD)luaL_checknumber(L, -1); - } - else if (!mir_strcmp(key, "dwY")) { - si.dwY = (DWORD)luaL_checknumber(L, -1); - } - else if (!mir_strcmp(key, "dwXSize")) { - si.dwXSize = (DWORD)luaL_checknumber(L, -1); - } - else if (!mir_strcmp(key, "dwYSize")) { - si.dwYSize = (DWORD)luaL_checknumber(L, -1); - } - else if (!mir_strcmp(key, "dwXCountChars")) { - si.dwXCountChars = (DWORD)luaL_checknumber(L, -1); - } - else if (!mir_strcmp(key, "dwYCountChars")) { - si.dwYCountChars = (DWORD)luaL_checknumber(L, -1); - } - else if (!mir_strcmp(key, "dwFillAttribute")) { - si.dwFillAttribute = (DWORD)luaL_checknumber(L, -1); - } - else if (!mir_strcmp(key, "dwFlags")) { - si.dwFlags = (DWORD)luaL_checknumber(L, -1); - } - else if (!mir_strcmp(key, "wShowWindow")) { - si.wShowWindow = (WORD)luaL_checknumber(L, -1); - } - else if (!mir_strcmp(key, "hStdInput")) { - long h = (long)luaL_checknumber(L, -1); - si.hStdInput = (HANDLE)h; - } - else if (!mir_strcmp(key, "hStdOutput")) { - long h = (long)luaL_checknumber(L, -1); - si.hStdOutput = (HANDLE)h; - } - else if (!mir_strcmp(key, "hStdError")) { - long h = (long)luaL_checknumber(L, -1); - si.hStdError = (HANDLE)h; - } - lua_pop(L, 1); - } - } - - - brc = CreateProcessA(an, (char *)cl, &psa, &tsa, ih, cf, env, cd, &si, &pi); - - if (si.lpDesktop != NULL) - mir_free(si.lpDesktop); - if (si.lpTitle != NULL) - mir_free(si.lpTitle); - - lua_pushnumber(L, brc); - if (brc) { - lua_pushnumber(L, (long)(pi.hProcess)); - lua_pushnumber(L, (long)(pi.hThread)); - lua_pushnumber(L, pi.dwProcessId); - lua_pushnumber(L, pi.dwThreadId); - } - else { - lua_pushnil(L); - lua_pushnil(L); - lua_pushnil(L); - lua_pushnil(L); - } - - return(5); -} - -/****if* luaw32/global_GetTempFileName -* NAME -* global_GetTempFileName -* FUNCTION -* Win32 GetTempFileName. -* INPUTS -* L: Lua state -* stack[1]: specifies the directory path for the file name -* stack[2]: Specifies the type of access to the object -* stack[3]: Specifies an unsigned integer that the function -* converts to a hexadecimal string for use in creating -* the temporary file name -* RESULT -* stack[1]: Unique numeric value or 0 if error -* stack[2]: Temporary file name or nil if error -* SOURCE -*/ - -static int global_GetTempFileName(lua_State *L) { - UINT rc; - char tfn[MAX_PATH]; - const char *path = luaL_checkstring(L, 1); - const char *pfx = luaL_checkstring(L, 2); - UINT unique = (UINT)luaL_checknumber(L, 3); - - rc = GetTempFileNameA(path, pfx, unique, tfn); - - lua_pushnumber(L, rc); - if (rc) - lua_pushstring(L, tfn); - else - lua_pushnil(L); - - return(2); -} -/***/ - -/****if* luaw32/global_GetTempPath -* NAME -* global_GetTempPath -* FUNCTION -* Win32 GetTempPath. -* INPUTS -* L: Lua state -* RESULT -* stack[1]: Unique numeric value or 0 if error -* stack[2]: Path of the directory designated for temporary files -* SOURCE -*/ - -static int global_GetTempPath(lua_State *L) { - DWORD rc; - char tfn[MAX_PATH]; - - rc = GetTempPathA(MAX_PATH, tfn); - - lua_pushnumber(L, rc); - if (rc) - lua_pushstring(L, tfn); - else - lua_pushnil(L); - - return(2); -} -/***/ - -static int global_CreateNamedPipe(lua_State *L) -{ - LPCSTR lpName = luaL_checkstring(L, 1); - DWORD dwOpenMode = luaL_checknumber(L, 2); - DWORD dwPipeMode = luaL_checknumber(L, 3); - DWORD nMaxInstances = luaL_checknumber(L, 4); - DWORD nOutBufferSize = luaL_checknumber(L, 5); - DWORD nInBufferSize = luaL_checknumber(L, 6); - DWORD nDefaultTimeOut = luaL_checknumber(L, 7); - SECURITY_ATTRIBUTES sa = { sizeof(sa), NULL, false }; - - HANDLE hPipe = CreateNamedPipeA(lpName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, &sa); - lua_pushnumber(L, (long)hPipe); - return 1; -} - -/****if* luaw32/global_CreateFile -* NAME -* global_CreateFile -* FUNCTION -* Win32 CreateFile. -* INPUTS -* L: Lua state -* stack[1]: Name of the object to create or open -* stack[2]: Specifies the type of access to the object -* stack[3]: Specifies how the object can be shared -* stack[4]: Table: -* .bInheritHandle: determines whether the returned handle -* can be inherited by child processes -* stack[5]: Specifies which action to take on files that exist -* stack[6]: Specifies the file attributes and flags for the file -* stack[7]: Specifies a handle with GENERIC_READ access to a -* template file -* RESULT -* stack[1]: Handle -* SOURCE -*/ - -static int global_CreateFile(lua_State *L) { - SECURITY_ATTRIBUTES sa; - long h; - const char *name = luaL_checkstring(L, 1); - DWORD da = (DWORD)luaL_checknumber(L, 2); - DWORD sm = (DWORD)luaL_checknumber(L, 3); - DWORD cd = (DWORD)luaL_checknumber(L, 5); - DWORD fa = (DWORD)luaL_checknumber(L, 6); - long th = 0; - - sa.nLength = sizeof(sa); - sa.lpSecurityDescriptor = NULL; - sa.bInheritHandle = FALSE; - if (lua_istable(L, 4)) { - lua_pushstring(L, "bInheritHandle"); - lua_gettable(L, 4); - if (!lua_isnil(L, -1)) - sa.bInheritHandle = (BOOL)luaL_checknumber(L, -1); - lua_pop(L, 1); - } - if (!lua_isnil(L, 7)) - th = (long)luaL_checknumber(L, 7); - - h = (long)CreateFileA(name, da, sm, &sa, cd, fa, (HANDLE)th); - - lua_pushnumber(L, h); - - return(1); -} -/***/ - -/****if* luaw32/global_ReadFile -* NAME -* global_ReadFile -* FUNCTION -* Win32 ReadFile. -* INPUTS -* L: Lua state -* stack[1]: Handle to the file to be read -* stack[2]: Specifies the number of bytes to be read from the file -* RESULT -* stack[1]: True if ok. -* stack[2]: Buffer read or nil if error -* SOURCE -*/ - -static int global_ReadFile(lua_State *L) { - DWORD bread; - char *buf; - BOOL brc = FALSE; - long h = MYP2HCAST luaL_checknumber(L, 1); - DWORD btoread = (DWORD)luaL_checknumber(L, 2); - - buf = (char*)mir_alloc(btoread); - if (buf != NULL) { - brc = ReadFile((HANDLE)h, buf, btoread, &bread, NULL); - lua_pushboolean(L, TRUE); - lua_pushlstring(L, buf, bread); - mir_free(buf); - } - else { - lua_pushboolean(L, FALSE); - lua_pushnil(L); - } - - return(2); -} -/***/ - -/****if* luaw32/global_WriteFile -* NAME -* global_WriteFile -* FUNCTION -* Win32 WriteFile. -* INPUTS -* L: Lua state -* stack[1]: Handle to the file to be written to -* stack[2]: Buffer containing the data to be written to the file -* RESULT -* stack[1]: True if ok. -* stack[2]: Number of bytes written or nil if error -* SOURCE -*/ - -static int global_WriteFile(lua_State *L) { - DWORD bwrite; - DWORD btowrite; - BOOL brc; - long h = MYP2HCAST luaL_checknumber(L, 1); - const char *buf = luaL_checklstring(L, 2, (size_t*)&btowrite); - - brc = WriteFile((HANDLE)h, buf, btowrite, &bwrite, NULL); - lua_pushboolean(L, brc); - if (brc) - lua_pushnumber(L, bwrite); - else - lua_pushnil(L); - - return(2); -} -/***/ - -static int global_DeleteFile(lua_State *L) -{ - const char *path = luaL_checkstring(L, 1); - BOOL result = DeleteFileA(path); - lua_pushboolean(L, result); - return 1; -} - -static int global_WaitForSingleObject(lua_State *L) { - long h = MYP2HCAST luaL_checknumber(L, 1); - DWORD t = (DWORD)luaL_checknumber(L, 2); - - lua_pushnumber(L, WaitForSingleObject((HANDLE)h, t)); - - return(1); -} - -static int global_WaitForMultipleObjects(lua_State *L) { - HANDLE ha[64]; - DWORD c = 0; - BOOL wa = (BOOL)luaL_checknumber(L, 2); - DWORD t = (DWORD)luaL_checknumber(L, 3); - - if (lua_istable(L, 1)) { - for (; c < 64; c++) { - long h; - lua_pushnumber(L, c + 1); - lua_gettable(L, 1); - if (lua_isnil(L, -1)) - break; - h = (long)luaL_checknumber(L, -1); - ha[c] = (HANDLE)h; - } - } - - lua_pushnumber(L, WaitForMultipleObjects(c, ha, wa, t)); - - return(1); -} - -static int global_TerminateProcess(lua_State *L) { - long h = MYP2HCAST luaL_checknumber(L, 1); - DWORD ec = (DWORD)luaL_checknumber(L, 2); - - lua_pushnumber(L, TerminateProcess((HANDLE)h, ec)); - - return(1); -} - -static int global_GetExitCodeProcess(lua_State *L) { - BOOL ok; - DWORD ec; - long h = MYP2HCAST luaL_checknumber(L, 1); - - ok = GetExitCodeProcess((HANDLE)h, &ec); - lua_pushnumber(L, ok); - lua_pushnumber(L, ec); - - return(2); -} - -static int global_GetCurrentThreadId(lua_State *L) { - lua_pushnumber(L, GetCurrentThreadId()); - - return(1); -} - -static int global_RegisterWindowMessage(lua_State *L) { - const char *msg = luaL_checkstring(L, 1); - - lua_pushnumber(L, RegisterWindowMessageA(msg)); - - return(1); -} - -static int global_RegQueryValueEx(lua_State *L) { - long rv; - HKEY hsk; - DWORD type; - DWORD dwdata; - DWORD len; - char *szdata; - long hkey = MYP2HCAST luaL_checknumber(L, 1); - const char *subkey = luaL_checkstring(L, 2); - const char *valuename = luaL_checkstring(L, 3); - - rv = RegOpenKeyExA((HKEY)hkey, subkey, 0, KEY_QUERY_VALUE, &hsk); - if (rv == ERROR_SUCCESS) { - len = sizeof(dwdata); - rv = RegQueryValueExA(hsk, valuename, NULL, &type, (LPBYTE)&dwdata, &len); - if ((rv == ERROR_SUCCESS) || (rv == ERROR_MORE_DATA)) { - switch (type) { - case REG_DWORD_BIG_ENDIAN: - case REG_DWORD: - lua_pushnumber(L, dwdata); - break; - case REG_EXPAND_SZ: - case REG_BINARY: - case REG_MULTI_SZ: - case REG_SZ: - if (rv == ERROR_MORE_DATA) { - szdata = (char*)mir_alloc(len); - if (szdata == NULL) { - lua_pushnil(L); - } - else { - rv = RegQueryValueExA(hsk, valuename, NULL, &type, (LPBYTE)szdata, &len); - if (rv == ERROR_SUCCESS) - lua_pushlstring(L, szdata, len); - else - lua_pushnil(L); - mir_free(szdata); - } - } - else - lua_pushlstring(L, (const char *)&dwdata, len); - break; - default: - lua_pushnil(L); - } - } - else - lua_pushnil(L); - RegCloseKey(hsk); - } - else - lua_pushnil(L); - - return 1; -} - -static int global_RegSetValueEx(lua_State *L) { - long rv; - HKEY hsk; - DWORD type; - DWORD dwdata; - DWORD len = 0; - char *szdata = NULL; - long hkey = MYP2HCAST luaL_checknumber(L, 1); - const char *subkey = luaL_checkstring(L, 2); - const char *valuename = luaL_checkstring(L, 3); - - if (lua_isnumber(L, 4)) { - dwdata = (DWORD)luaL_checknumber(L, 4); - type = (DWORD)luaL_optnumber(L, 5, REG_DWORD); - } - else { - szdata = (char *)luaL_checklstring(L, 4, (size_t*)&len); - type = (DWORD)luaL_optnumber(L, 5, REG_SZ); - } - - rv = RegCreateKeyExA((HKEY)hkey, subkey, 0, "", REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hsk, NULL); - if (rv == ERROR_SUCCESS) { - if (szdata == NULL) - rv = RegSetValueExA(hsk, valuename, 0, type, (CONST BYTE *) &dwdata, sizeof(dwdata)); - else - rv = RegSetValueExA(hsk, valuename, 0, type, (CONST BYTE *) szdata, len + 1); - lua_pushboolean(L, rv == ERROR_SUCCESS); - RegCloseKey(hsk); - } - else - lua_pushboolean(L, 0); - - return 1; -} - -static int global_RegDeleteValue(lua_State *L) { - long rv; - HKEY hsk; - long hkey = MYP2HCAST luaL_checknumber(L, 1); - const char *subkey = luaL_checkstring(L, 2); - const char *valuename = luaL_checkstring(L, 3); - - rv = RegOpenKeyExA((HKEY)hkey, subkey, 0, KEY_SET_VALUE, &hsk); - if (rv == ERROR_SUCCESS) { - rv = RegDeleteValueA(hsk, valuename); - lua_pushboolean(L, rv == ERROR_SUCCESS); - RegCloseKey(hsk); - } - else - lua_pushboolean(L, 0); - - return 1; -} - -static int global_RegDeleteKey(lua_State *L) { - long hkey = MYP2HCAST luaL_checknumber(L, 1); - const char *subkey = luaL_checkstring(L, 2); - - lua_pushboolean(L, RegDeleteKeyA((HKEY)hkey, subkey) == ERROR_SUCCESS); - - return 1; -} - -static int global_RegEnumKeyEx(lua_State *L) { - long rv; - HKEY hsk; - DWORD len; - DWORD index; - char name[256]; - FILETIME ft; - long hkey = MYP2HCAST luaL_checknumber(L, 1); - const char *subkey = luaL_checkstring(L, 2); - - rv = RegOpenKeyExA((HKEY)hkey, subkey, 0, KEY_ENUMERATE_SUB_KEYS, &hsk); - if (rv == ERROR_SUCCESS) { - lua_newtable(L); - for (index = 0;; index++) { - len = sizeof(name); - if (RegEnumKeyExA(hsk, index, name, &len, - NULL, NULL, NULL, &ft) != ERROR_SUCCESS) - break; - lua_pushnumber(L, index + 1); - lua_pushstring(L, name); - lua_settable(L, -3); - } - RegCloseKey(hsk); - } - else - lua_pushnil(L); - - return 1; -} - -static int global_RegEnumValue(lua_State *L) { - long rv; - HKEY hsk; - DWORD len; - DWORD index; - char name[256]; - long hkey = MYP2HCAST luaL_checknumber(L, 1); - const char *subkey = luaL_checkstring(L, 2); - - rv = RegOpenKeyExA((HKEY)hkey, subkey, 0, KEY_QUERY_VALUE, &hsk); - if (rv == ERROR_SUCCESS) { - lua_newtable(L); - for (index = 0;; index++) { - len = sizeof(name); - if (RegEnumValueA(hsk, index, name, &len, - NULL, NULL, NULL, NULL) != ERROR_SUCCESS) - break; - lua_pushnumber(L, index + 1); - lua_pushstring(L, name); - lua_settable(L, -3); - } - RegCloseKey(hsk); - } - else - lua_pushnil(L); - - return 1; -} - -static int global_SetCurrentDirectory(lua_State *L) { - DWORD le; - BOOL ok; - const char *pname = luaL_checkstring(L, 1); - - ok = SetCurrentDirectoryA(pname); - if (!ok) { - le = GetLastError(); - lua_pushboolean(L, ok); - lua_pushnumber(L, le); - } - else { - lua_pushboolean(L, ok); - lua_pushnil(L); - } - - return 2; -} - -static int global_SHDeleteKey(lua_State *L) { - long hkey = MYP2HCAST luaL_checknumber(L, 1); - const char *subkey = luaL_checkstring(L, 2); - - lua_pushboolean(L, SHDeleteKeyA((HKEY)hkey, subkey) == ERROR_SUCCESS); - - return 1; -} - -static int global_Sleep(lua_State *L) { - DWORD tosleep = (DWORD)luaL_checknumber(L, 1); - - Sleep(tosleep); - - return 0; -} - -static int global_GetVersion(lua_State *L) { - - lua_pushnumber(L, GetVersion()); - - return 1; -} - -static void pushFFTime(lua_State *L, FILETIME *ft) { - SYSTEMTIME st; - FileTimeToSystemTime(ft, &st); - lua_newtable(L); - lua_pushstring(L, "Year"); - lua_pushnumber(L, st.wYear); - lua_rawset(L, -3); - lua_pushstring(L, "Month"); - lua_pushnumber(L, st.wMonth); - lua_rawset(L, -3); - lua_pushstring(L, "DayOfWeek"); - lua_pushnumber(L, st.wDayOfWeek); - lua_rawset(L, -3); - lua_pushstring(L, "Day"); - lua_pushnumber(L, st.wDay); - lua_rawset(L, -3); - lua_pushstring(L, "Hour"); - lua_pushnumber(L, st.wHour); - lua_rawset(L, -3); - lua_pushstring(L, "Minute"); - lua_pushnumber(L, st.wMinute); - lua_rawset(L, -3); - lua_pushstring(L, "Second"); - lua_pushnumber(L, st.wSecond); - lua_rawset(L, -3); - lua_pushstring(L, "Milliseconds"); - lua_pushnumber(L, st.wMilliseconds); - lua_rawset(L, -3); -} -static void pushFFData(lua_State *L, WIN32_FIND_DATAA *wfd) { - lua_newtable(L); - lua_pushstring(L, "FileAttributes"); - lua_pushnumber(L, wfd->dwFileAttributes); - lua_rawset(L, -3); - lua_pushstring(L, "CreationTime"); - pushFFTime(L, &(wfd->ftCreationTime)); - lua_rawset(L, -3); - lua_pushstring(L, "LastAccessTime"); - pushFFTime(L, &(wfd->ftLastAccessTime)); - lua_rawset(L, -3); - lua_pushstring(L, "LastWriteTime"); - pushFFTime(L, &(wfd->ftLastWriteTime)); - lua_rawset(L, -3); - lua_pushstring(L, "FileSizeHigh"); - lua_pushnumber(L, wfd->nFileSizeHigh); - lua_rawset(L, -3); - lua_pushstring(L, "FileSizeLow"); - lua_pushnumber(L, wfd->nFileSizeLow); - lua_rawset(L, -3); - lua_pushstring(L, "FileName"); - lua_pushstring(L, wfd->cFileName); - lua_rawset(L, -3); - lua_pushstring(L, "AlternateFileName"); - lua_pushstring(L, wfd->cAlternateFileName); - lua_rawset(L, -3); -} - -static int global_FindFirstFile(lua_State *L) { - WIN32_FIND_DATAA wfd; - HANDLE hfd; - const char *fname = luaL_checkstring(L, 1); - - hfd = FindFirstFileA(fname, &wfd); - if (hfd == NULL) { - lua_pushnumber(L, 0); - lua_pushnil(L); - } - else { - lua_pushnumber(L, (long)hfd); - pushFFData(L, &wfd); - } - - return(2); -} - -static int global_FindNextFile(lua_State *L) { - WIN32_FIND_DATAA wfd; - BOOL ok; - long lfd = MYP2HCAST luaL_checknumber(L, 1); - - ok = FindNextFileA((HANDLE)lfd, &wfd); - lua_pushboolean(L, ok); - if (!ok) { - lua_pushnil(L); - } - else { - pushFFData(L, &wfd); - } - - return(2); -} - -static int global_FindClose(lua_State *L) { - long lfd = MYP2HCAST luaL_checknumber(L, 1); - - lua_pushboolean(L, FindClose((HANDLE)lfd)); - - return(2); -} - -static void FreePIDL(LPITEMIDLIST idl) { -/* - Imalloc *m; - SHGetmalloc(&m); - if (m != NULL) - m->lpVtbl->Free(m, idl); - m->lpVtbl->Release(m); -*/ -} - -static int global_SHGetSpecialFolderLocation(lua_State *L) { - LPITEMIDLIST idl; - char out[MAX_PATH]; - int ifolder = (int)luaL_checknumber(L, 1); - - if (SHGetSpecialFolderLocation(GetDesktopWindow(), - ifolder, &idl) != NOERROR) { - lua_pushnil(L); - } - else { - if (!SHGetPathFromIDListA(idl, out)) - lua_pushnil(L); - else - lua_pushstring(L, out); - FreePIDL(idl); - } - - return 1; -} - -static int global_GetFullPathName(lua_State *L) { - DWORD le; - DWORD rc; - char fpname[MAX_PATH]; - char *fpart; - const char *pname = luaL_checkstring(L, 1); - - rc = GetFullPathNameA(pname, sizeof(fpname), fpname, &fpart); - if (!rc) { - le = GetLastError(); - lua_pushnumber(L, 0); - lua_pushnil(L); - lua_pushnumber(L, le); - } - else { - lua_pushnumber(L, rc); - lua_pushstring(L, fpname); - lua_pushnil(L); - } - - return 3; -} - -BOOL __declspec(dllimport) __stdcall -CheckTokenMembership(HANDLE TokenHandle, PSID SidToCheck, PBOOL IsMember); -static int global_IsUserAdmin(lua_State *L) { - BOOL b; - SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY; - PSID AdministratorsGroup; - - b = AllocateAndInitializeSid( - &NtAuthority, - 2, - SECURITY_BUILTIN_DOMAIN_RID, - DOMAIN_ALIAS_RID_ADMINS, - 0, 0, 0, 0, 0, 0, - &AdministratorsGroup); - if (b) { - if (!CheckTokenMembership(NULL, AdministratorsGroup, &b)) - b = FALSE; - FreeSid(AdministratorsGroup); - } - - lua_pushboolean(L, b); - - return 1; -} - - -static int global_OpenProcess(lua_State *L) { - HANDLE h; - DWORD da = (DWORD)luaL_checknumber(L, 1); - BOOL ih = (BOOL)luaL_checknumber(L, 2); - DWORD pid = (DWORD)luaL_checknumber(L, 3); - - h = OpenProcess(da, ih, pid); - if (h != NULL) - lua_pushnumber(L, (long)h); - else - lua_pushnil(L); - - return 1; -} - -static int global_IsRunning(lua_State *L) { - HANDLE h; - BOOL b = FALSE; - DWORD pid = (DWORD)luaL_checknumber(L, 1); - - h = OpenProcess(SYNCHRONIZE, FALSE, pid); - if (h != NULL) { - b = TRUE; - CloseHandle(h); - } - - lua_pushboolean(L, b); - - return 1; -} - -static int global_GetWindowThreadProcessId(lua_State *L) { - long h = MYP2HCAST luaL_checknumber(L, 1); - DWORD tid, pid; - - tid = GetWindowThreadProcessId((HWND)h, &pid); - lua_pushnumber(L, (long)tid); - lua_pushnumber(L, (long)pid); - - return 2; -} - -static int global_OpenSCManager(lua_State *L) { - SC_HANDLE h; - - h = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); - lua_pushnumber(L, (long)h); - - return 1; -} - -static int global_OpenService(lua_State *L) { - SC_HANDLE h; - long scm = MYP2HCAST luaL_checknumber(L, 1); - const char *sname = luaL_checkstring(L, 2); - - h = OpenServiceA((SC_HANDLE)scm, sname, SERVICE_ALL_ACCESS); - lua_pushnumber(L, (long)h); - - return 1; -} - -static int global_CloseServiceHandle(lua_State *L) { - long h = MYP2HCAST luaL_checknumber(L, 1); - - lua_pushboolean(L, CloseServiceHandle((SC_HANDLE)h)); - - return 1; -} - -static int global_QueryServiceStatus(lua_State *L) { - SERVICE_STATUS ss; - BOOL brc; - long h = MYP2HCAST luaL_checknumber(L, 1); - - brc = QueryServiceStatus((SC_HANDLE)h, &ss); - lua_pushboolean(L, brc); - if (brc) { - lua_pushnumber(L, (long)(ss.dwServiceType)); - lua_pushnumber(L, (long)(ss.dwCurrentState)); - lua_pushnumber(L, (long)(ss.dwControlsAccepted)); - lua_pushnumber(L, (long)(ss.dwWin32ExitCode)); - lua_pushnumber(L, (long)(ss.dwServiceSpecificExitCode)); - lua_pushnumber(L, (long)(ss.dwCheckPoint)); - lua_pushnumber(L, (long)(ss.dwWaitHint)); - return 8; - } - else - return 1; -} - -static int global_QueryServiceConfig(lua_State *L) { - union { - QUERY_SERVICE_CONFIGA sc; - char buf[4096]; - } storage; - BOOL brc; - DWORD needed = 0, errcode = 0; - long h = MYP2HCAST luaL_checknumber(L, 1); - - brc = QueryServiceConfig((SC_HANDLE)h, (LPQUERY_SERVICE_CONFIG)&storage, sizeof(storage), &needed); - if (!brc) { - errcode = GetLastError(); - } - - lua_pushboolean(L, brc); - if (brc) { - // todo: add other values, if needed - lua_pushnumber(L, (long)(storage.sc.dwServiceType)); - lua_pushnumber(L, (long)(storage.sc.dwStartType)); - lua_pushnumber(L, (long)(storage.sc.dwErrorControl)); - lua_pushstring(L, storage.sc.lpBinaryPathName); - lua_pushstring(L, storage.sc.lpDisplayName); - return 6; - } - else { - lua_pushnumber(L, (long)(errcode)); - return 2; - } -} - -static int global_ControlService(lua_State *L) { - SERVICE_STATUS ss; - BOOL brc; - long h = MYP2HCAST luaL_checknumber(L, 1); - DWORD c = (DWORD)luaL_checknumber(L, 2); - - brc = ControlService((SC_HANDLE)h, c, &ss); - lua_pushboolean(L, brc); - - return 1; -} - -static int global_DeleteService(lua_State *L) { - long h = MYP2HCAST luaL_checknumber(L, 1); - - lua_pushboolean(L, DeleteService((SC_HANDLE)h)); - - return 1; -} - -static int global_StartService(lua_State *L) { - long h = MYP2HCAST luaL_checknumber(L, 1); - - lua_pushboolean(L, StartService((SC_HANDLE)h, 0, NULL)); - - return 1; -} - -static int global_mciSendString(lua_State *L) { - const char *cmd = luaL_checkstring(L, 1); // only one string parameter is used - - long lrc = (long)mciSendStringA(cmd, NULL, 0, NULL); - - lua_pushnumber(L, lrc); - - return(1); -} - -static int global_MessageBeep(lua_State *L) { - const UINT uType = luaL_checkinteger(L, 1); - - BOOL rc = MessageBeep(uType); - - lua_pushboolean(L, rc); - - return(1); -} - -static int global_Beep(lua_State *L) { - const DWORD dwFreq = luaL_checkinteger(L, 1); - const DWORD dwDuration = luaL_checkinteger(L, 2); - - BOOL rc = Beep(dwFreq, dwDuration); - - lua_pushboolean(L, rc); - - return(1); -} - -static int global_CoInitialize(lua_State *L) { - long lrc = (long)CoInitialize(NULL); - lua_pushinteger(L, lrc); - return(1); -} - -static int global_CoUninitialize(lua_State *L) { - CoUninitialize(); - return(0); -} - - -/* Module exported function */ - -static struct { - char *name; - DWORD value; -} consts[] = { - { "TRUE", TRUE }, - { "FALSE", FALSE }, - { "INVALID_HANDLE_VALUE", (unsigned long)INVALID_HANDLE_VALUE }, - { "INFINITE", INFINITE }, - { "EVENT_ALL_ACCESS", EVENT_ALL_ACCESS }, - { "EVENT_MODIFY_STATE", EVENT_MODIFY_STATE }, - { "SYNCHRONIZE", SYNCHRONIZE }, - { "MUTEX_ALL_ACCESS", MUTEX_ALL_ACCESS }, - { "SEMAPHORE_ALL_ACCESS", SEMAPHORE_ALL_ACCESS }, - { "SEMAPHORE_MODIFY_STATE", SEMAPHORE_MODIFY_STATE }, - { "WAIT_OBJECT_0", WAIT_OBJECT_0 }, - { "WAIT_ABANDONED_0", WAIT_ABANDONED_0 }, - { "WAIT_ABANDONED", WAIT_ABANDONED }, - { "WAIT_TIMEOUT", WAIT_TIMEOUT }, - { "WAIT_FAILED", WAIT_FAILED }, - { "CREATE_DEFAULT_ERROR_MODE", CREATE_DEFAULT_ERROR_MODE }, - { "CREATE_NEW_CONSOLE", CREATE_NEW_CONSOLE }, - { "CREATE_NEW_PROCESS_GROUP", CREATE_NEW_PROCESS_GROUP }, - { "CREATE_SUSPENDED", CREATE_SUSPENDED }, - { "CREATE_UNICODE_ENVIRONMENT", CREATE_UNICODE_ENVIRONMENT }, - { "DETACHED_PROCESS", DETACHED_PROCESS }, - { "HIGH_PRIORITY_CLASS", HIGH_PRIORITY_CLASS }, - { "IDLE_PRIORITY_CLASS", IDLE_PRIORITY_CLASS }, - { "NORMAL_PRIORITY_CLASS", NORMAL_PRIORITY_CLASS }, - { "REALTIME_PRIORITY_CLASS", REALTIME_PRIORITY_CLASS }, - { "FOREGROUND_BLUE", FOREGROUND_BLUE }, - { "FOREGROUND_GREEN", FOREGROUND_GREEN }, - { "FOREGROUND_RED", FOREGROUND_RED }, - { "FOREGROUND_INTENSITY", FOREGROUND_INTENSITY }, - { "BACKGROUND_BLUE", BACKGROUND_BLUE }, - { "BACKGROUND_GREEN", BACKGROUND_GREEN }, - { "BACKGROUND_RED", BACKGROUND_RED }, - { "BACKGROUND_INTENSITY", BACKGROUND_INTENSITY }, - { "STARTF_FORCEONFEEDBACK", STARTF_FORCEONFEEDBACK }, - { "STARTF_FORCEOFFFEEDBACK", STARTF_FORCEOFFFEEDBACK }, - { "STARTF_RUNFULLSCREEN", STARTF_RUNFULLSCREEN }, - { "STARTF_USECOUNTCHARS", STARTF_USECOUNTCHARS }, - { "STARTF_USEFILLATTRIBUTE", STARTF_USEFILLATTRIBUTE }, - { "STARTF_USEPOSITION", STARTF_USEPOSITION }, - { "STARTF_USESHOWWINDOW", STARTF_USESHOWWINDOW }, - { "STARTF_USESIZE", STARTF_USESIZE }, - { "STARTF_USESTDHANDLES", STARTF_USESTDHANDLES }, - { "SW_HIDE", SW_HIDE }, - { "SW_MAXIMIZE", SW_MAXIMIZE }, - { "SW_MINIMIZE", SW_MINIMIZE }, - { "SW_RESTORE", SW_RESTORE }, - { "SW_SHOW", SW_SHOW }, - { "SW_SHOWDEFAULT", SW_SHOWDEFAULT }, - { "SW_SHOWMAXIMIZED", SW_SHOWMAXIMIZED }, - { "SW_SHOWMINIMIZED", SW_SHOWMINIMIZED }, - { "SW_SHOWMINNOACTIVE", SW_SHOWMINNOACTIVE }, - { "SW_SHOWNA", SW_SHOWNA }, - { "SW_SHOWNOACTIVATE", SW_SHOWNOACTIVATE }, - { "SW_SHOWNORMAL", SW_SHOWNORMAL }, - { "GENERIC_READ", GENERIC_READ }, - { "GENERIC_WRITE", GENERIC_WRITE }, - { "MAXIMUM_ALLOWED", MAXIMUM_ALLOWED }, - { "GENERIC_EXECUTE", GENERIC_EXECUTE }, - { "GENERIC_ALL", GENERIC_ALL }, - { "FILE_SHARE_READ", FILE_SHARE_READ }, - { "FILE_SHARE_WRITE", FILE_SHARE_WRITE }, - { "CREATE_NEW", CREATE_NEW }, - { "CREATE_ALWAYS", CREATE_ALWAYS }, - { "OPEN_EXISTING", OPEN_EXISTING }, - { "OPEN_ALWAYS", OPEN_ALWAYS }, - { "TRUNCATE_EXISTING", TRUNCATE_EXISTING }, - { "FILE_ATTRIBUTE_ARCHIVE", FILE_ATTRIBUTE_ARCHIVE }, - { "FILE_ATTRIBUTE_ENCRYPTED", FILE_ATTRIBUTE_ENCRYPTED }, - { "FILE_ATTRIBUTE_HIDDEN", FILE_ATTRIBUTE_HIDDEN }, - { "FILE_ATTRIBUTE_NORMAL", FILE_ATTRIBUTE_NORMAL }, - { "FILE_ATTRIBUTE_NOT_CONTENT_INDEXED", FILE_ATTRIBUTE_NOT_CONTENT_INDEXED }, - { "FILE_ATTRIBUTE_OFFLINE", FILE_ATTRIBUTE_OFFLINE }, - { "FILE_ATTRIBUTE_READONLY", FILE_ATTRIBUTE_READONLY }, - { "FILE_ATTRIBUTE_SYSTEM", FILE_ATTRIBUTE_SYSTEM }, - { "FILE_ATTRIBUTE_TEMPORARY", FILE_ATTRIBUTE_TEMPORARY }, - { "FILE_FLAG_FIRST_PIPE_INSTANCE", FILE_FLAG_FIRST_PIPE_INSTANCE }, - { "FILE_FLAG_WRITE_THROUGH", FILE_FLAG_WRITE_THROUGH }, - { "FILE_FLAG_OVERLAPPED", FILE_FLAG_OVERLAPPED }, - { "FILE_FLAG_NO_BUFFERING", FILE_FLAG_NO_BUFFERING }, - { "FILE_FLAG_RANDOM_ACCESS", FILE_FLAG_RANDOM_ACCESS }, - { "FILE_FLAG_SEQUENTIAL_SCAN", FILE_FLAG_SEQUENTIAL_SCAN }, - { "FILE_FLAG_DELETE_ON_CLOSE", FILE_FLAG_DELETE_ON_CLOSE }, - { "FILE_FLAG_POSIX_SEMANTICS", FILE_FLAG_POSIX_SEMANTICS }, - { "FILE_FLAG_OPEN_REPARSE_POINT", FILE_FLAG_OPEN_REPARSE_POINT }, - { "FILE_FLAG_OPEN_NO_RECALL", FILE_FLAG_OPEN_NO_RECALL }, - { "SECURITY_ANONYMOUS", SECURITY_ANONYMOUS }, - { "SECURITY_IDENTIFICATION", SECURITY_IDENTIFICATION }, - { "SECURITY_IMPERSONATION", SECURITY_IMPERSONATION }, - { "SECURITY_DELEGATION", SECURITY_DELEGATION }, - { "SECURITY_CONTEXT_TRACKING", SECURITY_CONTEXT_TRACKING }, - { "SECURITY_EFFECTIVE_ONLY", SECURITY_EFFECTIVE_ONLY }, - { "PM_REMOVE", PM_REMOVE }, - { "PM_NOREMOVE", PM_NOREMOVE }, - - { "PIPE_ACCESS_DUPLEX", PIPE_ACCESS_DUPLEX }, - { "PIPE_ACCESS_INBOUND", PIPE_ACCESS_INBOUND }, - { "PIPE_ACCESS_OUTBOUND", PIPE_ACCESS_OUTBOUND }, - { "PIPE_TYPE_BYTE", PIPE_TYPE_BYTE }, - { "PIPE_TYPE_MESSAGE", PIPE_TYPE_MESSAGE }, - { "PIPE_READMODE_BYTE", PIPE_READMODE_BYTE }, - { "PIPE_READMODE_MESSAGE", PIPE_READMODE_MESSAGE }, - { "PIPE_WAIT", PIPE_WAIT }, - { "PIPE_NOWAIT", PIPE_NOWAIT }, - { "PIPE_ACCEPT_REMOTE_CLIENTS", PIPE_ACCEPT_REMOTE_CLIENTS }, - { "PIPE_REJECT_REMOTE_CLIENTS", PIPE_REJECT_REMOTE_CLIENTS }, - { "WRITE_DAC", WRITE_DAC }, - { "WRITE_OWNER", WRITE_OWNER }, - { "ACCESS_SYSTEM_SECURITY", ACCESS_SYSTEM_SECURITY }, - - - { "HKEY_CLASSES_ROOT", (unsigned long)HKEY_CLASSES_ROOT }, - { "HKEY_CURRENT_CONFIG", (unsigned long)HKEY_CURRENT_CONFIG }, - { "HKEY_CURRENT_USER", (unsigned long)HKEY_CURRENT_USER }, - { "HKEY_LOCAL_MACHINE", (unsigned long)HKEY_LOCAL_MACHINE }, - { "HKEY_USERS", (unsigned long)HKEY_USERS }, - { "REG_BINARY", REG_BINARY }, - { "REG_DWORD", REG_DWORD }, - { "REG_DWORD_BIG_ENDIAN", REG_DWORD_BIG_ENDIAN }, - { "REG_EXPAND_SZ", REG_EXPAND_SZ }, - { "REG_MULTI_SZ", REG_MULTI_SZ }, - { "REG_SZ", REG_SZ }, - { "CSIDL_STARTUP", CSIDL_STARTUP }, - { "CSIDL_STARTMENU", CSIDL_STARTMENU }, - { "CSIDL_COMMON_PROGRAMS", CSIDL_COMMON_PROGRAMS }, - { "CSIDL_COMMON_STARTUP", CSIDL_COMMON_STARTUP }, - { "CSIDL_COMMON_STARTMENU", CSIDL_COMMON_STARTMENU }, - { "CSIDL_PROGRAM_FILES", 38 }, - { "SERVICE_CONTROL_STOP", SERVICE_CONTROL_STOP }, - { "SERVICE_CONTROL_PAUSE", SERVICE_CONTROL_PAUSE }, - { "SERVICE_CONTROL_CONTINUE", SERVICE_CONTROL_CONTINUE }, - { "SERVICE_CONTROL_INTERROGATE", SERVICE_CONTROL_INTERROGATE }, - { "SERVICE_CONTROL_SHUTDOWN", SERVICE_CONTROL_SHUTDOWN }, - - { "SERVICE_STOPPED", SERVICE_STOPPED }, - { "SERVICE_START_PENDING", SERVICE_START_PENDING }, - { "SERVICE_STOP_PENDING", SERVICE_STOP_PENDING }, - { "SERVICE_RUNNING", SERVICE_RUNNING }, - { "SERVICE_CONTINUE_PENDING", SERVICE_CONTINUE_PENDING }, - { "SERVICE_PAUSE_PENDING", SERVICE_PAUSE_PENDING }, - { "SERVICE_PAUSED", SERVICE_PAUSED }, - - { "SERVICE_BOOT_START", SERVICE_BOOT_START }, - { "SERVICE_SYSTEM_START", SERVICE_SYSTEM_START }, - { "SERVICE_AUTO_START", SERVICE_AUTO_START }, - { "SERVICE_DEMAND_START", SERVICE_DEMAND_START }, - { "SERVICE_DISABLED", SERVICE_DISABLED }, - - { "MB_ICONASTERISK", MB_ICONASTERISK }, - { "MB_ICONEXCLAMATION", MB_ICONEXCLAMATION }, - { "MB_ICONERROR", MB_ICONERROR }, - { "MB_ICONHAND", MB_ICONHAND }, - { "MB_ICONINFORMATION", MB_ICONINFORMATION }, - { "MB_ICONQUESTION", MB_ICONQUESTION }, - { "MB_ICONSTOP", MB_ICONSTOP }, - { "MB_ICONWARNING", MB_ICONWARNING }, - { "MB_OK", MB_OK }, - - { "BM_CLICK", BM_CLICK }, - { NULL, 0 } -}; - -/***********************************************/ - -static luaL_Reg winApi[] = -{ - { "MessageBox", lua_MessageBox }, - - { "ShellExecute", lua_ShellExecute }, - - { "Find", lua_Find }, - - { "GetKeyState", lua_GetKeyState }, - - { "GetIniValue", lua_GetIniValue }, - { "SetIniValue", lua_SetIniValue }, - { "DeleteIniValue", lua_DeleteIniValue }, - - { "GetRegValue", lua_GetRegValue }, - { "SetRegValue", lua_SetRegValue }, - { "DeleteRegValue", lua_DeleteRegValue }, - - { "ShellOpen", global_ShellOpen }, - { "FindWindow", global_FindWindow }, - { "FindWindowEx", global_FindWindowEx }, - { "SetFocus", global_SetFocus }, - { "GetWindowText", global_GetWindowText }, - { "SetWindowText", global_SetWindowText }, - { "GetWindowRect", global_GetWindowRect }, - { "RegisterHotKey", global_RegisterHotKey }, - { "SetForegroundWindow", global_SetForegroundWindow }, - { "PostMessage", global_PostMessage }, - { "PostThreadMessage", global_PostThreadMessage }, - { "GetMessage", global_GetMessage }, - { "PeekMessage", global_PeekMessage }, - { "ReplyMessage", global_ReplyMessage }, - { "DispatchMessage", global_DispatchMessage }, - { "SetTopmost", global_SetTopmost }, - { "GetLastError", global_GetLastError }, - { "CloseHandle", global_CloseHandle }, - { "CreateEvent", global_CreateEvent }, - { "OpenEvent", global_OpenEvent }, - { "PulseEvent", global_PulseEvent }, - { "ResetEvent", global_ResetEvent }, - { "SetEvent", global_SetEvent }, - { "CreateMutex", global_CreateMutex }, - { "OpenMutex", global_OpenMutex }, - { "ReleaseMutex", global_ReleaseMutex }, - { "CreateSemaphore", global_CreateSemaphore }, - { "OpenSemaphore", global_OpenSemaphore }, - { "ReleaseSemaphore", global_ReleaseSemaphore }, - { "CreateProcess", global_CreateProcess }, - { "GetTempFileName", global_GetTempFileName }, - { "GetTempPath", global_GetTempPath }, - { "CreateNamedPipe", global_CreateNamedPipe }, - { "CreateFile", global_CreateFile }, - { "ReadFile", global_ReadFile }, - { "WriteFile", global_WriteFile }, - { "DeleteFile", global_DeleteFile }, - { "TerminateProcess", global_TerminateProcess }, - { "GetExitCodeProcess", global_GetExitCodeProcess }, - { "WaitForSingleObject", global_WaitForSingleObject }, - { "WaitForMultipleObjects", global_WaitForMultipleObjects }, - { "GetCurrentThreadId", global_GetCurrentThreadId }, - { "RegisterWindowMessage", global_RegisterWindowMessage }, - { "RegQueryValueEx", global_RegQueryValueEx }, - { "RegSetValueEx", global_RegSetValueEx }, - { "RegDeleteKey", global_RegDeleteKey }, - { "RegDeleteValue", global_RegDeleteValue }, - { "RegEnumKeyEx", global_RegEnumKeyEx }, - { "RegEnumValue", global_RegEnumValue }, - { "SetCurrentDirectory", global_SetCurrentDirectory }, - { "SHDeleteKey", global_SHDeleteKey }, - { "Sleep", global_Sleep }, - { "GetVersion", global_GetVersion }, - { "FindFirstFile", global_FindFirstFile }, - { "FindNextFile", global_FindNextFile }, - { "FindClose", global_FindClose }, - { "SHGetSpecialFolderLocation", global_SHGetSpecialFolderLocation }, - { "GetFullPathName", global_GetFullPathName }, - { "IsUserAdmin", global_IsUserAdmin }, - { "OpenProcess", global_OpenProcess }, - { "IsRunning", global_IsRunning }, - { "GetWindowThreadProcessId", global_GetWindowThreadProcessId }, - { "OpenSCManager", global_OpenSCManager }, - { "OpenService", global_OpenService }, - { "CloseServiceHandle", global_CloseServiceHandle }, - { "QueryServiceStatus", global_QueryServiceStatus }, - { "QueryServiceConfig", global_QueryServiceConfig }, - { "ControlService", global_ControlService }, - { "DeleteService", global_DeleteService }, - { "StartService", global_StartService }, - { "mciSendString", global_mciSendString }, - { "MessageBeep", global_MessageBeep }, - { "Beep", global_Beep }, - { "CoInitialize", global_CoInitialize }, - { "CoUninitialize", global_CoUninitialize }, - - - { NULL, NULL } -}; - -LUAMOD_API int luaopen_m_windows(lua_State *L) -{ - luaL_newlib(L, winApi); - - for (size_t i = 0; consts[i].name != NULL; i++) - { - lua_pushstring(L, consts[i].name); - lua_pushnumber(L, consts[i].value); - lua_settable(L, -3); - } - - return 1; -} diff --git a/plugins/MirLua/src/mlua_module_loader.cpp b/plugins/MirLua/src/mlua_module_loader.cpp index d48c600de1..426f7bd9e6 100644 --- a/plugins/MirLua/src/mlua_module_loader.cpp +++ b/plugins/MirLua/src/mlua_module_loader.cpp @@ -15,8 +15,8 @@ void CLuaModuleLoader::Load(const char *name, lua_CFunction loader) lua_pushstring(L, name); luaM_pcall(L, 1, 1); lua_setfield(L, -2, name); - lua_pop(L, 1); - lua_pop(L, 1); + lua_pop(L, 1); + lua_pop(L, 1); } void CLuaModuleLoader::Preload(const char *name, lua_CFunction loader) @@ -46,7 +46,6 @@ void CLuaModuleLoader::LoadModules() Preload(MLUA_POPUP, luaopen_m_popup); Preload(MLUA_TOPTOOLBAR, luaopen_m_toptoolbar); Preload(MLUA_VARIABLES, luaopen_m_variables); - Preload(MLUA_WINDOWS, luaopen_m_windows); } void CLuaModuleLoader::Load(lua_State *L) diff --git a/plugins/MirLua/src/stdafx.h b/plugins/MirLua/src/stdafx.h index 9282c6a77a..109e91c1e4 100644 --- a/plugins/MirLua/src/stdafx.h +++ b/plugins/MirLua/src/stdafx.h @@ -100,8 +100,6 @@ LUAMOD_API int (luaopen_m_sounds)(lua_State *L); #define MLUA_VARIABLES "m_variables" LUAMOD_API int (luaopen_m_variables)(lua_State *L); -#define MLUA_WINDOWS "m_windows" -LUAMOD_API int (luaopen_m_windows)(lua_State *L); /* utils */ -- cgit v1.2.3