def key Solidus Slash = 0x35 # /?
def key NumSolidus NumSlash = E0-0x35 # Numpad /
def key RightShift RShift = 0x36
+def key E0RightShift E0RShift = E0-0x36
def key NumAsterisk NumMultiply = 0x37 # Numpad *
def key PrintScreen Snapshot = E0-0x37
def key LeftAlt LAlt LMenu = 0x38
def mod Alt = LAlt RAlt
def mod Control = LControl RControl
def mod Windows = LWindows RWindows
+mod shift += E0RShift
+key *E0RShift = *RShift
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def key FullStop Period = 0x34 # .>
def key Solidus Slash = 0x35 # /?
def key RightShift RShift = 0x36
+def key E0RightShift E0RShift = E0-0x36
def key NumAsterisk NumMultiply = 0x37 # \83e\83\93\83L\81[ *
def key LeftAlt LAlt LMenu = 0x38
def key Space = 0x39
def mod Alt = LAlt RAlt
def mod Control = LControl RControl
def mod Windows = LWindows RWindows
+mod shift += E0RShift
+key *E0RShift = *RShift
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
+#ifdef MAYU64
+INT_PTR CALLBACK dlgEditSetting_dlgProc(HWND i_hwnd, UINT i_message,
+#else
BOOL CALLBACK dlgEditSetting_dlgProc(HWND i_hwnd, UINT i_message,
+#endif
WPARAM i_wParam, LPARAM i_lParam)
{
DlgEditSetting *wc;
/// dialog procedure of "Edit Setting" dialog box
+#ifdef MAYU64
+INT_PTR CALLBACK dlgEditSetting_dlgProc(
+#else
BOOL CALLBACK dlgEditSetting_dlgProc(
+#endif
HWND i_hwnd, UINT i_message, WPARAM i_wParam, LPARAM i_lParam);
/// parameters for "Edit Setting" dialog box
//
+#ifdef MAYU64
+INT_PTR CALLBACK dlgInvestigate_dlgProc(HWND i_hwnd, UINT i_message,
+#else
BOOL CALLBACK dlgInvestigate_dlgProc(HWND i_hwnd, UINT i_message,
+#endif
WPARAM i_wParam, LPARAM i_lParam)
{
DlgInvestigate *wc;
/// dialog procedure of "Investigate" dialog box
+#ifdef MAYU64
+INT_PTR CALLBACK dlgInvestigate_dlgProc(
+#else
BOOL CALLBACK dlgInvestigate_dlgProc(
+#endif
HWND i_hwnd, UINT i_message, WPARAM i_wParam, LPARAM i_lParam);
class Engine;
//
+#ifdef MAYU64
+INT_PTR CALLBACK dlgLog_dlgProc(HWND i_hwnd, UINT i_message,
+#else
BOOL CALLBACK dlgLog_dlgProc(HWND i_hwnd, UINT i_message,
+#endif
WPARAM i_wParam, LPARAM i_lParam)
{
DlgLog *wc;
//
+#ifdef MAYU64
+INT_PTR CALLBACK dlgLog_dlgProc(
+#else
BOOL CALLBACK dlgLog_dlgProc(
+#endif
HWND i_hwnd, UINT i_message, WPARAM i_wParam, LPARAM i_lParam);
enum
//
+#ifdef MAYU64
+INT_PTR CALLBACK dlgSetting_dlgProc(
+#else
BOOL CALLBACK dlgSetting_dlgProc(
+#endif
HWND i_hwnd, UINT i_message, WPARAM i_wParam, LPARAM i_lParam)
{
DlgSetting *wc;
///
+#ifdef MAYU64
+INT_PTR CALLBACK dlgSetting_dlgProc(
+#else
BOOL CALLBACK dlgSetting_dlgProc(
+#endif
HWND i_hwnd, UINT i_message, WPARAM i_wParam, LPARAM i_lParam);
//
+#ifdef MAYU64
+INT_PTR CALLBACK dlgVersion_dlgProc(
+#else
BOOL CALLBACK dlgVersion_dlgProc(
+#endif
HWND i_hwnd, UINT i_message, WPARAM i_wParam, LPARAM i_lParam)
{
DlgVersion *wc;
///
+#ifdef MAYU64
+INT_PTR CALLBACK dlgVersion_dlgProc(
+#else
BOOL CALLBACK dlgVersion_dlgProc(
+#endif
HWND i_hwnd, UINT i_message, WPARAM i_wParam, LPARAM i_lParam);
kid.Flags = sc[i].m_flags;
if (!i_doPress)
kid.Flags |= KEYBOARD_INPUT_DATA::BREAK;
- DWORD len;
#if defined(_WINNT)
+#ifdef NO_DRIVER
+ injectInput(&kid, NULL);
+#else // !NO_DRIVER
+ DWORD len;
WriteFile(m_device, &kid, sizeof(kid), &len, &m_ol);
CHECK_TRUE( GetOverlappedResult(m_device, &m_ol, &len, TRUE) );
+#endif // !NO_DRIVER
#elif defined(_WIN95)
DeviceIoControl(m_device, 2, &kid, sizeof(kid), NULL, 0, &len, NULL);
#else
}
+#ifdef NO_DRIVER
+unsigned int Engine::injectInput(const KEYBOARD_INPUT_DATA *i_kid, const KBDLLHOOKSTRUCT *i_kidRaw)
+{
+ INPUT kid;
+ kid.type = INPUT_KEYBOARD;
+ kid.ki.wVk = 0;
+ kid.ki.wScan = i_kid->MakeCode;
+ kid.ki.dwFlags = KEYEVENTF_SCANCODE;
+ kid.ki.time = i_kidRaw ? i_kidRaw->time : 0;
+ kid.ki.dwExtraInfo = i_kidRaw ? i_kidRaw->dwExtraInfo : 0;
+ if (i_kid->Flags & KEYBOARD_INPUT_DATA::BREAK)
+ {
+ kid.ki.dwFlags |= KEYEVENTF_KEYUP;
+ }
+ if (i_kid->Flags & KEYBOARD_INPUT_DATA::E0)
+ {
+ kid.ki.dwFlags |= KEYEVENTF_EXTENDEDKEY;
+ }
+ SendInput(1, &kid, sizeof(kid));
+ return 1;
+}
+#endif // NO_DRIVER
+
+
// pop all pressed key on win32
void Engine::keyboardResetOnWin32()
{
}
+#ifdef NO_DRIVER
+unsigned int WINAPI Engine::keyboardDetour(Engine *i_this, KBDLLHOOKSTRUCT *i_kid)
+{
+ return i_this->keyboardDetour(i_kid);
+}
+
+unsigned int Engine::keyboardDetour(KBDLLHOOKSTRUCT *i_kid)
+{
+#if 0
+ Acquire a(&m_log, 1);
+ m_log << std::hex
+ << _T("keyboardDetour: vkCode=") << i_kid->vkCode
+ << _T(" scanCode=") << i_kid->scanCode
+ << _T(" flags=") << i_kid->flags << std::endl;
+#endif
+ if (i_kid->flags & LLKHF_INJECTED)
+ {
+ return 0;
+ }
+ else
+ {
+ Key key;
+ KEYBOARD_INPUT_DATA kid;
+
+ kid.UnitId = 0;
+ kid.MakeCode = i_kid->scanCode;
+ kid.Flags = 0;
+ if (i_kid->flags & LLKHF_UP)
+ {
+ kid.Flags |= KEYBOARD_INPUT_DATA::BREAK;
+ }
+ if (i_kid->flags & LLKHF_EXTENDED)
+ {
+ kid.Flags |= KEYBOARD_INPUT_DATA::E0;
+ }
+ kid.Reserved = 0;
+ kid.ExtraInformation = 0;
+
+ Acquire a(&m_cskidq);
+ m_kidq.push_back(kid);
+ SetEvent(m_readEvent);
+ return 1;
+ }
+}
+#endif // NO_DRIVER
+
// keyboard handler thread
unsigned int WINAPI Engine::keyboardHandler(void *i_this)
{
{
KEYBOARD_INPUT_DATA kid;
+#ifndef NO_DRIVER
DWORD len;
+#endif // !NO_DRIVER
#if defined(_WINNT)
{
Acquire a(&m_log, 1);
m_log << _T("begin ReadFile();") << std::endl;
}
+#ifdef NO_DRIVER
+ if (1)
+ {
+#else // !NO_DRIVER
if (!ReadFile(m_device, &kid, sizeof(kid), &len, &m_ol))
{
if (GetLastError() != ERROR_IO_PENDING)
continue;
+#endif // !NO_DRIVER
HANDLE handles[] = { m_readEvent, m_interruptThreadEvent };
rewait:
FALSE, INFINITE, QS_POSTMESSAGE))
{
case WAIT_OBJECT_0: // m_readEvent
+#ifdef NO_DRIVER
+ {
+ Acquire a(&m_cskidq);
+ if (m_kidq.empty())
+ {
+ goto rewait;
+ }
+ kid = m_kidq.front();
+ m_kidq.pop_front();
+ if (!m_kidq.empty())
+ {
+ SetEvent(m_readEvent);
+ }
+ }
+#else // !NO_DRIVER
if (!GetOverlappedResult(m_device, &m_ol, &len, FALSE))
continue;
+#endif // !NO_DRIVER
break;
case WAIT_OBJECT_0 + 1: // m_interruptThreadEvent
else
{
#if defined(_WINNT)
+#ifdef NO_DRIVER
+ injectInput(&kid, NULL);
+#else // !NO_DRIVER
WriteFile(m_device, &kid, sizeof(kid), &len, &m_ol);
GetOverlappedResult(m_device, &m_ol, &len, TRUE);
+#endif // !NO_DRIVER
#elif defined(_WIN95)
DeviceIoControl(m_device, 2, &kid, sizeof(kid), NULL, 0, &len, NULL);
#else
!m_currentKeymap)
{
#if defined(_WINNT)
+#ifndef NO_DRIVER
WriteFile(m_device, &kid, sizeof(kid), &len, &m_ol);
GetOverlappedResult(m_device, &m_ol, &len, TRUE);
+#endif // !NO_DRIVER
#elif defined(_WIN95)
DeviceIoControl(m_device, 2, &kid, sizeof(kid), NULL, 0, &len, NULL);
#else
for (int i = Modifier::Type_Lock0; i <= Modifier::Type_Lock9; ++ i)
m_currentLock.release(static_cast<Modifier::Type>(i));
+#ifndef NO_DRIVER
if (!open()) {
throw ErrorMessage() << loadString(IDS_driverNotInstalled);
}
+#endif // !NO_DRIVER
+#ifndef NO_DRIVER
{
TCHAR versionBuf[256];
DWORD length = 0;
&& length < sizeof(versionBuf)) // fail safe
m_mayudVersion = tstring(versionBuf, length / 2);
}
+#endif // !NO_DRIVER
// create event for sync
CHECK_TRUE( m_eSync = CreateEvent(NULL, FALSE, FALSE, NULL) );
#if defined(_WINNT)
{
// open mayu m_device
#if defined(_WINNT)
+#ifndef NO_DRIVER
m_device = CreateFile(MAYU_DEVICE_FILE_NAME, GENERIC_READ | GENERIC_WRITE,
0, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
+#endif // !NO_DRIVER
#elif defined(_WIN95)
m_device = CreateFile(MAYU_DEVICE_FILE_NAME, 0,
0, NULL, CREATE_NEW, FILE_FLAG_DELETE_ON_CLOSE, NULL);
}
#if defined(_WINNT)
+#ifndef NO_DRIVER
// start mayud
SC_HANDLE hscm = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
if (hscm)
m_device = CreateFile(MAYU_DEVICE_FILE_NAME, GENERIC_READ | GENERIC_WRITE,
0, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
+#endif // !NO_DRIVER
#endif // _WINNT
return (m_device != INVALID_HANDLE_VALUE);
}
void Engine::close()
{
if (m_device != INVALID_HANDLE_VALUE) {
+#ifndef NO_DRIVER
CHECK_TRUE( CloseHandle(m_device) );
+#endif // !NO_DRIVER
}
m_device = INVALID_HANDLE_VALUE;
}
m_interruptThreadReason = InterruptThreadReason_Pause;
SetEvent(m_interruptThreadEvent);
} while (WaitForSingleObject(m_threadEvent, 100) != WAIT_OBJECT_0);
+#ifndef NO_DRIVER
close();
+#endif // !NO_DRIVER
}
#endif // _WINNT
return true;
{
#if defined(_WINNT)
if (m_device == INVALID_HANDLE_VALUE) {
+#ifndef NO_DRIVER
if (!open()) {
return false; // FIXME
}
+#endif // !NO_DRIVER
do {
m_interruptThreadReason = InterruptThreadReason_Resume;
SetEvent(m_interruptThreadEvent);
CHECK_TRUE( CloseHandle(m_eSync) );
// close m_device
+#ifndef NO_DRIVER
close();
+#endif // !NO_DRIVER
#if defined(_WINNT)
// destroy named pipe for &SetImeString
- DisconnectNamedPipe(m_hookPipe);
- CHECK_TRUE( CloseHandle(m_hookPipe) );
+ if (m_hookPipe && m_hookPipe != INVALID_HANDLE_VALUE)
+ {
+ DisconnectNamedPipe(m_hookPipe);
+ CHECK_TRUE( CloseHandle(m_hookPipe) );
+ }
#endif // _WINNT
}
bool isMDIMinimized = false;
while (i_hwnd)
{
+#ifdef MAYU64
+ LONG_PTR exStyle = GetWindowLongPtr(i_hwnd, GWL_EXSTYLE);
+#else
LONG exStyle = GetWindowLong(i_hwnd, GWL_EXSTYLE);
+#endif
if (exStyle & WS_EX_MDICHILD)
{
WINDOWPLACEMENT placement;
}
}
+#ifdef MAYU64
+ LONG_PTR style = GetWindowLongPtr(i_hwnd, GWL_STYLE);
+#else
LONG style = GetWindowLong(i_hwnd, GWL_STYLE);
+#endif
if ((style & WS_CHILD) == 0)
{
WINDOWPLACEMENT placement;
if (!m_detachedThreadIds.empty())
{
DetachedThreadIds::iterator i;
+ bool retry;
do
{
+ retry = false;
for (i = m_detachedThreadIds.begin();
i != m_detachedThreadIds.end(); ++ i)
if (*i == i_threadId)
{
m_detachedThreadIds.erase(i);
+ retry = true;
break;
}
- } while (i != m_detachedThreadIds.end());
+ } while (retry);
}
FocusOfThread *fot;
HWND h = hf;
while (h)
{
+#ifdef MAYU64
+ LONG_PTR style = GetWindowLongPtr(h, GWL_STYLE);
+#else
LONG style = GetWindowLong(h, GWL_STYLE);
+#endif
if ((style & WS_CHILD) == 0)
break;
h = GetParent(h);
# include "setting.h"
# include "msgstream.h"
# include <set>
+# include <queue>
enum
unsigned m_threadId;
tstring m_mayudVersion; /// version of mayud.sys
#if defined(_WINNT)
+#ifdef NO_DRIVER
+ std::deque<KEYBOARD_INPUT_DATA> m_kidq;
+ CriticalSection m_cskidq;
+#endif // NO_DRIVER
HANDLE m_readEvent; /** reading from mayu device
has been completed */
HANDLE m_interruptThreadEvent; /// interrupt thread event
tomsgstream &m_log; /** log stream (output to log
dialog's edit) */
+public:
+#ifdef NO_DRIVER
+ /// keyboard handler thread
+ static unsigned int WINAPI keyboardDetour(Engine *i_this, KBDLLHOOKSTRUCT *i_kid);
+private:
+ ///
+ unsigned int keyboardDetour(KBDLLHOOKSTRUCT *i_kid);
+ ///
+ unsigned int injectInput(const KEYBOARD_INPUT_DATA *i_kid, const KBDLLHOOKSTRUCT *i_kidRaw);
+#endif // NO_DRIVER
+
private:
/// keyboard handler thread
static unsigned int WINAPI keyboardHandler(void *i_this);
{
while (hwnd)
{
+#ifdef MAYU64
+ LONG_PTR style = GetWindowLongPtr(hwnd, GWL_STYLE);
+#else
LONG style = GetWindowLong(hwnd, GWL_STYLE);
+#endif
if ((style & WS_CHILD) == 0)
break;
hwnd = GetParent(hwnd);
return;
SetWindowPos(
hwnd,
+#ifdef MAYU64
+ (GetWindowLongPtr(hwnd, GWL_EXSTYLE) & WS_EX_TOPMOST) ?
+#else
(GetWindowLong(hwnd, GWL_EXSTYLE) & WS_EX_TOPMOST) ?
+#endif
HWND_NOTOPMOST : HWND_TOPMOST,
0, 0, 0, 0,
SWP_ASYNCWINDOWPOS | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOSIZE);
for (WindowsWithAlpha::iterator i = m_windowsWithAlpha.begin();
i != m_windowsWithAlpha.end(); ++ i)
{
+#ifdef MAYU64
+ SetWindowLongPtr(*i, GWL_EXSTYLE,
+ GetWindowLongPtr(*i, GWL_EXSTYLE) & ~WS_EX_LAYERED);
+#else
SetWindowLong(*i, GWL_EXSTYLE,
GetWindowLong(*i, GWL_EXSTYLE) & ~WS_EX_LAYERED);
+#endif
RedrawWindow(*i, NULL, NULL,
RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN);
}
}
else
{
+#ifdef MAYU64
+ LONG_PTR exStyle = GetWindowLongPtr(hwnd, GWL_EXSTYLE);
+#else
LONG exStyle = GetWindowLong(hwnd, GWL_EXSTYLE);
+#endif
if (exStyle & WS_EX_LAYERED) // remove alpha
{
WindowsWithAlpha::iterator
m_windowsWithAlpha.erase(i);
+#ifdef MAYU64
+ SetWindowLongPtr(hwnd, GWL_EXSTYLE, exStyle & ~WS_EX_LAYERED);
+#else
SetWindowLong(hwnd, GWL_EXSTYLE, exStyle & ~WS_EX_LAYERED);
+#endif
}
else // add alpha
{
+#ifdef MAYU64
+ SetWindowLongPtr(hwnd, GWL_EXSTYLE, exStyle | WS_EX_LAYERED);
+#else
SetWindowLong(hwnd, GWL_EXSTYLE, exStyle | WS_EX_LAYERED);
+#endif
i_alpha %= 101;
if (!setLayeredWindowAttributes(hwnd, 0,
(BYTE)(255 * i_alpha / 100), LWA_ALPHA))
cd.cbData = request.size();
cd.lpData = (void *)request.c_str();
#endif
+#ifdef MAYU64
+ DWORD_PTR result;
+#else
DWORD result;
+#endif
SendMessageTimeout(i->second.m_hwnd, WM_COPYDATA,
reinterpret_cast<WPARAM>(m_hwndAssocWindow),
reinterpret_cast<LPARAM>(&cd),
target = i_param->m_hwnd;
g_hookData->m_hwndMouseHookTarget =
- getToplevelWindow(target, &isMDI);
+ reinterpret_cast<DWORD>(getToplevelWindow(target, &isMDI));
break;
default:
g_hookData->m_hwndMouseHookTarget = NULL;
///
#define HOOK_DATA_NAME _T("{08D6E55C-5103-4e00-8209-A1C4AB13BBEF}") _T(VERSION)
+#ifdef _WIN64
+#define HOOK_DATA_NAME_ARCH _T("{290C0D51-8AEE-403d-9172-E43D46270996}") _T(VERSION)
+#else // !_WIN64
+#define HOOK_DATA_NAME_ARCH _T("{716A5DEB-CB02-4438-ABC8-D00E48673E45}") _T(VERSION)
+#endif // !_WIN64
// Some applications use different values for below messages
// when double click of title bar.
#define SC_MINIMIZE2 (SC_MINIMIZE + 2)
#define SC_RESTORE2 (SC_RESTORE + 2)
+// Debug Macros
+#ifdef NDEBUG
+#define HOOK_RPT0(msg)
+#define HOOK_RPT1(msg, arg1)
+#define HOOK_RPT2(msg, arg1, arg2)
+#else
+#define HOOK_RPT0(msg) if (g.m_isLogging) { _RPT0(_CRT_WARN, msg); }
+#define HOOK_RPT1(msg, arg1) if (g.m_isLogging) { _RPT1(_CRT_WARN, msg, arg1); }
+#define HOOK_RPT2(msg, arg1, arg2) if (g.m_isLogging) { _RPT2(_CRT_WARN, msg, arg1, arg2); }
+#endif
+
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Global Variables
DllExport HookData *g_hookData; ///
+///
+class HookDataArch
+{
+public:
+ HHOOK m_hHookGetMessage; ///
+ HHOOK m_hHookCallWndProc; ///
+};
+
+static HookDataArch *s_hookDataArch;
+
struct Globals
{
HANDLE m_hHookData; ///
+ HANDLE m_hHookDataArch; ///
HWND m_hwndFocus; ///
HINSTANCE m_hInstDLL; ///
bool m_isInMenu; ///
UINT m_WM_MAYU_MESSAGE; ///
bool m_isImeLock; ///
bool m_isImeCompositioning; ///
+ HHOOK m_hHookMouseProc; ///
+#ifdef NO_DRIVER
+ HHOOK m_hHookKeyboardProc; ///
+ KEYBOARD_DETOUR m_keyboardDetour;
+ Engine *m_engine;
+#endif // NO_DRIVER
+ DWORD m_hwndTaskTray; ///
+ HANDLE m_hMailslot;
+ bool m_isInitialized;
+#ifndef NDEBUG
+ bool m_isLogging;
+ _TCHAR m_moduleName[GANA_MAX_PATH];
+#endif // !NDEBUG
};
static Globals g;
static void notifyLog(_TCHAR *i_msg);
static bool mapHookData();
static void unmapHookData();
+static bool initialize();
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Functions
+bool initialize()
+{
+#ifndef NDEBUG
+ _TCHAR path[GANA_MAX_PATH];
+ GetModuleFileName(NULL, path, GANA_MAX_PATH);
+ _tsplitpath_s(path, NULL, 0, NULL, 0, g.m_moduleName, GANA_MAX_PATH, NULL, 0);
+ if (_tcsncmp(g.m_moduleName, _T("Dbgview"), sizeof(_T("Dbgview"))/sizeof(_TCHAR)) != 0 &&
+ _tcsncmp(g.m_moduleName, _T("windbg"), sizeof(_T("windbg"))/sizeof(_TCHAR)) != 0)
+ {
+ g.m_isLogging = true;
+ }
+#endif // !NDEBUG
+#ifdef USE_MAILSLOT
+ g.m_hMailslot =
+ CreateFile(NOTIFY_MAILSLOT_NAME, GENERIC_WRITE,
+ FILE_SHARE_READ | FILE_SHARE_WRITE,
+ (SECURITY_ATTRIBUTES *)NULL, OPEN_EXISTING,
+ FILE_ATTRIBUTE_NORMAL, (HANDLE)NULL);
+ if (g.m_hMailslot == INVALID_HANDLE_VALUE)
+ {
+ HOOK_RPT2("MAYU: %S create mailslot failed(0x%08x)\r\n", g.m_moduleName, GetLastError());
+ }
+ else
+ {
+ HOOK_RPT1("MAYU: %S create mailslot successed\r\n", g.m_moduleName);
+ }
+#endif //USE_MAILSLOT
+ if (!mapHookData())
+ return false;
+ _tsetlocale(LC_ALL, _T(""));
+ g.m_WM_MAYU_MESSAGE =
+ RegisterWindowMessage(addSessionId(WM_MAYU_MESSAGE_NAME).c_str());
+ g.m_hwndTaskTray = g_hookData->m_hwndTaskTray;
+ g.m_isInitialized = true;
+ return true;
+}
/// EntryPoint
BOOL WINAPI DllMain(HINSTANCE i_hInstDLL, DWORD i_fdwReason,
{
case DLL_PROCESS_ATTACH:
{
- if (!mapHookData())
- return FALSE;
+#ifndef NDEBUG
+ g.m_isLogging = false;
+#endif // !NDEBUG
+ g.m_isInitialized = false;
g.m_hInstDLL = i_hInstDLL;
- _tsetlocale(LC_ALL, _T(""));
- g.m_WM_MAYU_MESSAGE = RegisterWindowMessage(
- addSessionId(WM_MAYU_MESSAGE_NAME).c_str());
break;
}
case DLL_THREAD_ATTACH:
case DLL_PROCESS_DETACH:
notifyThreadDetach();
unmapHookData();
+#ifdef USE_MAILSLOT
+ if (g.m_hMailslot != INVALID_HANDLE_VALUE)
+ {
+ CloseHandle(g.m_hMailslot);
+ g.m_hMailslot = INVALID_HANDLE_VALUE;
+ }
+#endif //USE_MAILSLOT
break;
case DLL_THREAD_DETACH:
notifyThreadDetach();
/// map hook data
static bool mapHookData()
{
- g.m_hHookData = CreateFileMapping((HANDLE)0xffffffff, NULL, PAGE_READWRITE,
+ g.m_hHookData = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
0, sizeof(HookData),
addSessionId(HOOK_DATA_NAME).c_str());
if (!g.m_hHookData)
+ {
+ unmapHookData();
return false;
+ }
g_hookData =
(HookData *)MapViewOfFile(g.m_hHookData, FILE_MAP_READ | FILE_MAP_WRITE,
unmapHookData();
return false;
}
+
+ g.m_hHookDataArch = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
+ 0, sizeof(HookDataArch),
+ addSessionId(HOOK_DATA_NAME_ARCH).c_str());
+ if (!g.m_hHookDataArch)
+ {
+ unmapHookData();
+ return false;
+ }
+
+ s_hookDataArch =
+ (HookDataArch *)MapViewOfFile(g.m_hHookDataArch, FILE_MAP_READ | FILE_MAP_WRITE,
+ 0, 0, sizeof(HookDataArch));
+ if (!s_hookDataArch)
+ {
+ unmapHookData();
+ return false;
+ }
+
return true;
}
static void unmapHookData()
{
if (g_hookData)
- if (!UnmapViewOfFile(g_hookData))
- return;
+ UnmapViewOfFile(g_hookData);
g_hookData = NULL;
if (g.m_hHookData)
CloseHandle(g.m_hHookData);
g.m_hHookData = NULL;
+ if (s_hookDataArch)
+ UnmapViewOfFile(s_hookDataArch);
+ s_hookDataArch = NULL;
+ if (g.m_hHookDataArch)
+ CloseHandle(g.m_hHookDataArch);
+ g.m_hHookDataArch = NULL;
}
DllExport bool notify(void *i_data, size_t i_dataSize)
{
COPYDATASTRUCT cd;
+#ifdef MAYU64
+ DWORD_PTR result;
+#else // MAYU64
DWORD result;
+#endif // MAYU64
+#ifdef USE_MAILSLOT
+ DWORD len;
+ if (g.m_hMailslot != INVALID_HANDLE_VALUE)
+ {
+ BOOL ret;
+ ret = WriteFile(g.m_hMailslot, i_data, i_dataSize, &len, NULL);
+#ifndef NDEBUG
+ if (ret == 0)
+ {
+ HOOK_RPT2("MAYU: %S WriteFile to mailslot failed(0x%08x)\r\n", g.m_moduleName, GetLastError());
+ }
+ else
+ {
+ HOOK_RPT1("MAYU: %S WriteFile to mailslot successed\r\n", g.m_moduleName);
+ }
+#endif // !NDEBUG
+ }
+#else // !USE_MAILSLOT
cd.dwData = reinterpret_cast<Notify *>(i_data)->m_type;
cd.cbData = i_dataSize;
cd.lpData = i_data;
- if (g_hookData->m_hwndTaskTray == NULL)
+ if (g.m_hwndTaskTray == 0)
return false;
- if (!SendMessageTimeout(g_hookData->m_hwndTaskTray, WM_COPYDATA,
- NULL, reinterpret_cast<LPARAM>(&cd),
+ if (!SendMessageTimeout(reinterpret_cast<HWND>(g.m_hwndTaskTray),
+ WM_COPYDATA, NULL, reinterpret_cast<LPARAM>(&cd),
SMTO_ABORTIFHUNG | SMTO_NORMAL, 5000, &result))
+ {
+ _RPT0(_CRT_WARN, "MAYU: SendMessageTimeout() timeouted\r\n");
return false;
+ }
+#endif // !USE_MAILSLOT
return true;
}
if (!i_hwnd)
return;
+#ifdef MAYU64
+ LONG_PTR style = GetWindowLongPtr(i_hwnd, GWL_STYLE);
+#else
LONG style = GetWindowLong(i_hwnd, GWL_STYLE);
+#endif
if (!(style & WS_MAXIMIZEBOX) && !(style & WS_MAXIMIZEBOX))
return; // ignore window that has neither maximize or minimize button
if (style & WS_CHILD)
{
+#ifdef MAYU64
+ LONG_PTR exStyle = GetWindowLongPtr(i_hwnd, GWL_EXSTYLE);
+#else
LONG exStyle = GetWindowLong(i_hwnd, GWL_EXSTYLE);
+#endif
if (exStyle & WS_EX_MDICHILD)
{
isMDI = true;
NotifySetFocus *nfc = new NotifySetFocus;
nfc->m_type = i_type;
nfc->m_threadId = GetCurrentThreadId();
- nfc->m_hwnd = i_hwnd;
+ nfc->m_hwnd = reinterpret_cast<DWORD>(i_hwnd);
tcslcpy(nfc->m_className, className.c_str(), NUMBER_OF(nfc->m_className));
tcslcpy(nfc->m_titleName, titleName.c_str(), NUMBER_OF(nfc->m_titleName));
static void notifyCommand(
HWND i_hwnd, UINT i_message, WPARAM i_wParam, LPARAM i_lParam)
{
+#ifndef _WIN64
if (g_hookData->m_doesNotifyCommand)
{
NotifyCommand ntc;
ntc.m_lParam = i_lParam;
notify(&ntc, sizeof(ntc));
}
+#endif
}
else
return; // this function only works for Edit control
+#ifdef MAYU64
+ LONG_PTR style = GetWindowLongPtr(i_hwnd, GWL_STYLE);
+#else
LONG style = GetWindowLong(i_hwnd, GWL_STYLE);
+#endif
if (!(style & ES_MULTILINE))
return; // this function only works for multi line Edit control
/// hook of GetMessage
LRESULT CALLBACK getMessageProc(int i_nCode, WPARAM i_wParam, LPARAM i_lParam)
{
+ if (!g.m_isInitialized)
+ initialize();
+
if (!g_hookData)
return 0;
MSG &msg = (*(MSG *)i_lParam);
+ if (i_wParam != PM_REMOVE)
+ goto finally;
+
switch (msg.message)
{
case WM_COMMAND:
}
break;
}
- return CallNextHookEx(g_hookData->m_hHookGetMessage,
+ finally:
+ return CallNextHookEx(s_hookDataArch->m_hHookGetMessage,
i_nCode, i_wParam, i_lParam);
}
/// hook of SendMessage
LRESULT CALLBACK callWndProc(int i_nCode, WPARAM i_wParam, LPARAM i_lParam)
{
+ if (!g.m_isInitialized)
+ initialize();
+
if (!g_hookData)
return 0;
break;
}
}
- return CallNextHookEx(g_hookData->m_hHookCallWndProc, i_nCode,
+ return CallNextHookEx(s_hookDataArch->m_hHookCallWndProc, i_nCode,
i_wParam, i_lParam);
}
MSLLHOOKSTRUCT *pMsll = (MSLLHOOKSTRUCT*)lParam;
LONG dx = pMsll->pt.x - g_hookData->m_mousePos.x;
LONG dy = pMsll->pt.y - g_hookData->m_mousePos.y;
- HWND target = g_hookData->m_hwndMouseHookTarget;
+ HWND target = reinterpret_cast<HWND>(g_hookData->m_hwndMouseHookTarget);
+
+ if (!g.m_isInitialized)
+ initialize();
if (!g_hookData || nCode < 0 || wParam != WM_MOUSEMOVE)
goto through;
}
through:
- return CallNextHookEx(g_hookData->m_hHookMouseProc,
+ return CallNextHookEx(g.m_hHookMouseProc,
+ nCode, wParam, lParam);
+}
+
+
+#ifdef NO_DRIVER
+static LRESULT CALLBACK lowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
+{
+ KBDLLHOOKSTRUCT *pKbll = (KBDLLHOOKSTRUCT*)lParam;
+
+ if (!g.m_isInitialized)
+ initialize();
+
+ if (!g_hookData || nCode < 0)
+ goto through;
+
+ if (g.m_keyboardDetour && g.m_engine)
+ {
+ unsigned int result;
+ result = g.m_keyboardDetour(g.m_engine, pKbll);
+ if (result)
+ {
+ return 1;
+ }
+ }
+ through:
+ return CallNextHookEx(g.m_hHookKeyboardProc,
nCode, wParam, lParam);
}
+#endif // NO_DRIVER
/// install hooks
-DllExport int installHooks()
+DllExport int installHooks(KEYBOARD_DETOUR i_keyboardDetour, Engine *i_engine)
{
- g_hookData->m_hwndTaskTray = NULL;
- g_hookData->m_hHookGetMessage =
+ if (!g.m_isInitialized)
+ initialize();
+
+ g.m_hwndTaskTray = g_hookData->m_hwndTaskTray;
+ s_hookDataArch->m_hHookGetMessage =
SetWindowsHookEx(WH_GETMESSAGE, (HOOKPROC)getMessageProc,
g.m_hInstDLL, 0);
- g_hookData->m_hHookCallWndProc =
+ s_hookDataArch->m_hHookCallWndProc =
SetWindowsHookEx(WH_CALLWNDPROC, (HOOKPROC)callWndProc, g.m_hInstDLL, 0);
g_hookData->m_mouseHookType = MouseHookType_None;
- g_hookData->m_hHookMouseProc =
- SetWindowsHookEx(WH_MOUSE_LL, (HOOKPROC)lowLevelMouseProc,
- g.m_hInstDLL, 0);
+ if (i_engine != NULL)
+ {
+#ifdef NO_DRIVER
+ g.m_keyboardDetour = i_keyboardDetour;
+ g.m_engine = i_engine;
+ g.m_hHookKeyboardProc =
+ SetWindowsHookEx(WH_KEYBOARD_LL, (HOOKPROC)lowLevelKeyboardProc,
+ g.m_hInstDLL, 0);
+#endif // NO_DRIVER
+ g.m_hHookMouseProc =
+ SetWindowsHookEx(WH_MOUSE_LL, (HOOKPROC)lowLevelMouseProc,
+ g.m_hInstDLL, 0);
+ }
return 0;
}
/// uninstall hooks
DllExport int uninstallHooks()
{
- if (g_hookData->m_hHookGetMessage)
- UnhookWindowsHookEx(g_hookData->m_hHookGetMessage);
- g_hookData->m_hHookGetMessage = NULL;
- if (g_hookData->m_hHookCallWndProc)
- UnhookWindowsHookEx(g_hookData->m_hHookCallWndProc);
- g_hookData->m_hHookCallWndProc = NULL;
- if (g_hookData->m_hHookMouseProc)
- UnhookWindowsHookEx(g_hookData->m_hHookMouseProc);
- g_hookData->m_hHookMouseProc = NULL;
+ if (s_hookDataArch->m_hHookGetMessage)
+ UnhookWindowsHookEx(s_hookDataArch->m_hHookGetMessage);
+ s_hookDataArch->m_hHookGetMessage = NULL;
+ if (s_hookDataArch->m_hHookCallWndProc)
+ UnhookWindowsHookEx(s_hookDataArch->m_hHookCallWndProc);
+ s_hookDataArch->m_hHookCallWndProc = NULL;
+ if (g.m_hHookMouseProc)
+ UnhookWindowsHookEx(g.m_hHookMouseProc);
+ g.m_hHookMouseProc = NULL;
+#ifdef NO_DRIVER
+ if (g.m_hHookKeyboardProc)
+ UnhookWindowsHookEx(g.m_hHookKeyboardProc);
+ g.m_hHookKeyboardProc = NULL;
+#endif // NO_DRIVER
+ g.m_hwndTaskTray = 0;
return 0;
}
# include "misc.h"
# include <tchar.h>
+#ifdef NO_DRIVER
+# include <windows.h>
+#endif // NO_DRIVER
///
# define HOOK_PIPE_NAME \
_T("\\\\.\\pipe\\GANAware\\mayu\\{4B22D464-7A4E-494b-982A-C2B2BBAAF9F3}") _T(VERSION)
///
+#ifdef USE_MAILSLOT
+# define NOTIFY_MAILSLOT_NAME \
+_T("\\\\.\\mailslot\\GANAware\\mayu\\{330F7914-EB5B-49be-ACCE-D2B8DF585B32}") _T(VERSION)
+///
+#endif // USE_MAILSLOT
# define WM_MAYU_MESSAGE_NAME _T("GANAware\\mayu\\WM_MAYU_MESSAGE")
///
struct NotifySetFocus : public Notify
{
DWORD m_threadId; ///
- HWND m_hwnd; ///
+ DWORD m_hwnd; ///
_TCHAR m_className[GANA_MAX_PATH]; ///
_TCHAR m_titleName[GANA_MAX_PATH]; ///
};
MouseHookType_WindowMove = 1 << 1, /// window move
};
+#ifdef NO_DRIVER
+class Engine;
+typedef unsigned int (WINAPI *KEYBOARD_DETOUR)(Engine *i_engine, KBDLLHOOKSTRUCT *i_kid);
+#endif // NO_DRIVER
+
///
class HookData
{
public:
- HHOOK m_hHookGetMessage; ///
- HHOOK m_hHookCallWndProc; ///
- HHOOK m_hHookMouseProc; ///
USHORT m_syncKey; ///
bool m_syncKeyIsExtended; ///
bool m_doesNotifyCommand; ///
- HWND m_hwndTaskTray; ///
+ DWORD m_hwndTaskTray; ///
bool m_correctKanaLockHandling; /// does use KL- ?
MouseHookType m_mouseHookType; ///
int m_mouseHookParam; ///
- HWND m_hwndMouseHookTarget; ///
+ DWORD m_hwndMouseHookTarget; ///
POINT m_mousePos; ///
};
# ifndef _HOOK_CPP
extern DllImport HookData *g_hookData;
-extern DllImport int installHooks();
+extern DllImport int installHooks(KEYBOARD_DETOUR i_keyboardDetour, Engine *i_engine);
extern DllImport int uninstallHooks();
extern DllImport bool notify(void *data, size_t sizeof_data);
extern DllImport void notifyLockState();
m_i((*m_hashedKeys).begin())
{
if ((*m_hashedKeys).empty())
- next();
+ {
+ do
+ {
+ -- m_hashedKeysSize;
+ ++ m_hashedKeys;
+ } while (0 < m_hashedKeysSize && (*m_hashedKeys).empty());
+ if (0 < m_hashedKeysSize)
+ m_i = (*m_hashedKeys).begin();
+ }
}
try
{
tregex::flag_type f = (tregex::normal |
- tregex::icase |
- tregex::use_except);
+ tregex::icase);
if (!i_windowClass.empty())
m_windowClass.assign(i_windowClass, f);
if (!i_windowTitle.empty())
if (!i_hwnd)\r
return false;\r
item.m_hwnd = i_hwnd;\r
+#ifdef MAYU64\r
+ if (!(GetWindowLongPtr(i_hwnd, GWL_STYLE) & WS_CHILD))\r
+#else\r
if (!(GetWindowLong(i_hwnd, GWL_STYLE) & WS_CHILD))\r
+#endif\r
return false;\r
item.m_hwndParent = GetParent(i_hwnd);\r
if (!item.m_hwndParent)\r
if (rc.right - GetSystemMetrics(SM_CXHTHUMB) <= p.x &&\r
rc.bottom - GetSystemMetrics(SM_CYVTHUMB) <= p.y)\r
{\r
+#ifdef MAYU64\r
+ SetWindowLongPtr(m_hwnd, DWLP_MSGRESULT, HTBOTTOMRIGHT);\r
+#else\r
SetWindowLong(m_hwnd, DWL_MSGRESULT, HTBOTTOMRIGHT);\r
+#endif\r
return TRUE;\r
}\r
return FALSE;\r
COMMON_DEFINES = -DSTRICT -D_WIN32_IE=0x0500 $(OS_SPECIFIC_DEFINES)
BOOST_DIR = ../boost_$(BOOST_VER)_0
+!ifdef X64
+BOOST_DIR = $(BOOST_DIR)_x64
+!endif
# mayu.exe ###############################################################
-TARGET_1 = $(OUT_DIR)\mayu.exe
+TARGET_1 = $(OUT_DIR_EXE)\mayu$(X64).exe
OBJS_1 = \
$(OUT_DIR)\compiler_specific_func.obj \
$(OUT_DIR)\dlgeditsetting.obj \
shell32.lib \
comctl32.lib \
wtsapi32.lib \
- $(OUT_DIR)\mayu.lib \
+ $(OUT_DIR_EXE)\mayu$(X64).lib \
-EXTRADEP_1 = $(OUT_DIR)\mayu.lib
+EXTRADEP_1 = $(OUT_DIR_EXE)\mayu$(X64).lib
# mayu.dll ###############################################################
-TARGET_2 = $(OUT_DIR)\mayu.dll
+TARGET_2 = $(OUT_DIR_EXE)\mayu$(X64).dll
OBJS_2 = $(OUT_DIR)\hook.obj $(OUT_DIR)\stringtool.obj
SRCS_2 = hook.cpp stringtool.cpp
LIBS_2 = $(guixlibsmt) imm32.lib
# mayu.lib ###############################################################
-TARGET_3 = $(OUT_DIR)\mayu.lib
-DLL_3 = $(OUT_DIR)\mayu.dll
+TARGET_3 = $(OUT_DIR_EXE)\mayu$(X64).lib
+DLL_3 = $(OUT_DIR_EXE)\mayu$(X64).dll
+
+
+# yamyd ###############################################################
+TARGET_4 = $(OUT_DIR_EXE)\yamyd$(X64)
+OBJS_4 = $(OUT_DIR)\yamyd.obj
+
+SRCS_4 = yamyd.cpp
+LIBS_4 = user32.lib $(OUT_DIR_EXE)\mayu$(X64).lib
+
+EXTRADEP_4 = $(OUT_DIR_EXE)\mayu$(X64).lib
# distribution ###############################################################
DISTRIB = \
$(TARGET_1) \
$(TARGET_2) \
+ $(TARGET_4) \
s\$(OUT_DIR)\setup.exe \
$(DISTRIB_SETTINGS) \
$(DISTRIB_MANUAL) \
# rules ###############################################################
-all: boost $(OUT_DIR) $(TARGET_1) $(TARGET_2) $(TARGET_3)
+all: boost $(OUT_DIR) $(OUT_DIR_EXE) $(TARGET_1) $(TARGET_2) $(TARGET_3) $(TARGET_4)
$(OUT_DIR):
if not exist "$(OUT_DIR)\\" $(MKDIR) $(OUT_DIR)
+$(OUT_DIR_EXE):
+ if not exist "$(OUT_DIR_EXE)\\" $(MKDIR) $(OUT_DIR_EXE)
+
functions.h: engine.h tools/makefunc
$(MAKEFUNC) < engine.h > functions.h
clean::
- -$(RM) $(TARGET_1) $(TARGET_2) $(TARGET_3)
+ -$(RM) $(TARGET_1) $(TARGET_2) $(TARGET_3) $(TARGET_4)
-$(RM) $(OUT_DIR)\*.obj
- -$(RM) $(OUT_DIR)\*.res $(OUT_DIR)\*.exp
- -$(RM) mayu.aps mayu.opt $(OUT_DIR)\*.pdb
+ -$(RM) $(OUT_DIR)\*.res $(OUT_DIR_EXE)\*.exp
+ -$(RM) mayu.aps mayu.opt $(OUT_DIR_EXE)\*.pdb
-$(RM) *~ $(CLEAN)
-$(RMDIR) $(OUT_DIR)
###############################################################################
!if "$(BOOST_VER)" == ""
-BOOST_VER = 1_32
+BOOST_VER = 1_38
!endif
INCLUDES = -I$(BOOST_DIR) # why here ?
DEPENDIGNORE = --ignore=$(BOOST_DIR)
!if "$(MAYU_VC)" == ""
-MAYU_VC = vc6
+MAYU_VC = vc9
!endif
!if ( "$(MAYU_VC)" == "vct" )
!include <mayu-common.mak>
DEFINES = $(COMMON_DEFINES) -DVERSION=""""$(VERSION)"""" \
- -DLOGNAME=""""$(LOGNAME)"""" \
- -DCOMPUTERNAME=""""$(COMPUTERNAME)""""
+ -DLOGNAME=""""$(USERNAME)"""" \
+ -DCOMPUTERNAME=""""$(COMPUTERNAME)"""" -D_CRT_SECURE_NO_WARNINGS -DMAYU64 -DNO_DRIVER -DUSE_MAILSLOT -DUSE_INI
# INCLUDES = -I$(BOOST_DIR) # make -f mayu-vc.mak depend fails ...
LDFLAGS_1 = \
$(guilflags) \
/PDB:$(TARGET_1).pdb \
- /LIBPATH:$(BOOST_DIR)/libs/regex/build/$(MAYU_REGEX_VC) \
+ /LIBPATH:$(BOOST_DIR)/libs/regex/build/$(MAYU_REGEX_VC)0 \
LDFLAGS_2 = \
$(dlllflags) \
/PDB:$(TARGET_2).pdb \
- /LIBPATH:$(BOOST_DIR)/libs/regex/build/$(MAYU_REGEX_VC) \
+ /LIBPATH:$(BOOST_DIR)/libs/regex/build/$(MAYU_REGEX_VC)0 \
+
+LDFLAGS_4 = \
+ $(guilflags) \
+ /PDB:$(TARGET_4).pdb \
+ /LIBPATH:$(BOOST_DIR)/libs/regex/build/$(MAYU_REGEX_VC)0 \
$(TARGET_1): $(OBJS_1) $(RES_1) $(EXTRADEP_1)
$(link) -out:$@ $(ldebug) $(LDFLAGS_1) $(OBJS_1) $(LIBS_1) $(RES_1)
$(TARGET_3): $(DLL_3)
+$(TARGET_4): $(OBJS_4) $(EXTRADEP_4)
+ $(link) -out:$@ $(ldebug) $(LDFLAGS_4) $(OBJS_4) $(LIBS_4)
+
REGEXPP_XCFLAGS = $(REGEXPP_XCFLAGS) XCFLAGS=-D_WCTYPE_INLINE_DEFINED
clean::
boost:
cd $(BOOST_DIR)/libs/regex/build/
- $(MAKE) -f $(MAYU_REGEX_VC).mak $(REGEXPP_XCFLAGS) main_dir libboost_regex-$(MAYU_REGEX_VC)-mt-s-$(BOOST_VER)_dir ./$(MAYU_REGEX_VC)/libboost_regex-$(MAYU_REGEX_VC)-mt-s-$(BOOST_VER).lib
- cd ../../../../mayu
+ $(MAKE) -f $(MAYU_REGEX_VC).mak $(REGEXPP_XCFLAGS) main_dir libboost_regex-$(MAYU_REGEX_VC)0-mt-s-$(BOOST_VER)_dir ./$(MAYU_REGEX_VC)0/libboost_regex-$(MAYU_REGEX_VC)0-mt-s-$(BOOST_VER).lib libboost_regex-$(MAYU_REGEX_VC)0-mt-sgd-$(BOOST_VER)_dir ./$(MAYU_REGEX_VC)0/libboost_regex-$(MAYU_REGEX_VC)0-mt-sgd-$(BOOST_VER).lib
+ cd ../../../../yamy
distclean:: clean
cd $(BOOST_DIR)/libs/regex/build/
-$(MAKE) -k -f $(MAYU_REGEX_VC).mak clean
- cd ../../../../mayu
+ cd ../../../../yamy
batch:
!if "$(MAYU_VC)" != "vct"
- -$(MAKE) -k -f mayu-vc.mak MAYU_VC=$(MAYU_VC) TARGETOS=WINNT
+ -$(MAKE) -f mayu-vc.mak MAYU_VC=$(MAYU_VC) TARGETOS=WINNT
!endif
- -$(MAKE) -k -f mayu-vc.mak MAYU_VC=$(MAYU_VC) TARGETOS=WINNT nodebug=1
- cd s
- -$(MAKE) -k -f setup-vc.mak MAYU_VC=$(MAYU_VC) batch
- cd ..
+ -$(MAKE) -f mayu-vc.mak MAYU_VC=$(MAYU_VC) TARGETOS=WINNT nodebug=1
+# cd s
+# -$(MAKE) -f setup-vc.mak MAYU_VC=$(MAYU_VC) batch
+# cd ..
batch_clean:
-$(MAKE) -k -f mayu-vc.mak MAYU_VC=$(MAYU_VC) TARGETOS=WINNT nodebug=1 clean
#include "setting.h"
#include "target.h"
#include "windowstool.h"
+#include "vk2tchar.h"
#include <process.h>
#include <time.h>
#include <commctrl.h>
tomsgstream m_log; /** log stream (output to log
dialog's edit) */
+#ifdef LOG_TO_FILE
+ tofstream m_logFile;
+#endif // LOG_TO_FILE
HMENU m_hMenuTaskTray; /// tasktray menu
+ STARTUPINFO m_si;
+ PROCESS_INFORMATION m_pi;
+ HANDLE m_mutex;
+#ifdef USE_MAILSLOT
+ HANDLE m_hNotifyMailslot; /// mailslot to receive notify
+ HANDLE m_hNotifyEvent; /// event on receive notify
+ OVERLAPPED m_olNotify; ///
+ BYTE m_notifyBuf[NOTIFY_MESSAGE_SIZE];
+#endif // USE_MAILSLOT
Setting *m_setting; /// current setting
bool m_isSettingDialogOpened; /// is setting dialog opened ?
};
private:
+#ifdef USE_MAILSLOT
+ static VOID CALLBACK mailslotProc(DWORD i_code, DWORD i_len, LPOVERLAPPED i_ol)
+ {
+ Mayu *pThis;
+
+ pThis = reinterpret_cast<Mayu*>(CONTAINING_RECORD(i_ol, Mayu, m_olNotify));
+ pThis->mailslotHandler(i_code, i_len);
+ return;
+ }
+
+ BOOL mailslotHandler(DWORD i_code, DWORD i_len)
+ {
+ BOOL result;
+
+ if (i_len)
+ {
+ COPYDATASTRUCT cd;
+
+ cd.dwData = reinterpret_cast<Notify *>(m_notifyBuf)->m_type;
+ cd.cbData = i_len;
+ cd.lpData = m_notifyBuf;
+ notifyHandler(&cd);
+ }
+
+ memset(m_notifyBuf, 0, sizeof(m_notifyBuf));
+ result = ReadFileEx(m_hNotifyMailslot, m_notifyBuf, sizeof(m_notifyBuf),
+ &m_olNotify, Mayu::mailslotProc);
+ return result;
+ }
+#endif // USE_MAILSLOT
+
/// register class for tasktray
ATOM Register_tasktray()
{
n->m_titleName[NUMBER_OF(n->m_titleName) - 1] = _T('\0');
if (n->m_type == Notify::Type_setFocus)
- m_engine.setFocus(n->m_hwnd, n->m_threadId,
+ m_engine.setFocus(reinterpret_cast<HWND>(n->m_hwnd), n->m_threadId,
n->m_className, n->m_titleName, false);
{
Acquire a(&m_log, 1);
m_log << _T("HWND:\t") << std::hex
- << reinterpret_cast<int>(n->m_hwnd)
+ << n->m_hwnd
<< std::dec << std::endl;
m_log << _T("THREADID:") << static_cast<int>(n->m_threadId)
<< std::endl;
m_log << _T("TITLE:\t") << n->m_titleName << std::endl;
bool isMDI = true;
- HWND hwnd = getToplevelWindow(n->m_hwnd, &isMDI);
+ HWND hwnd = getToplevelWindow(reinterpret_cast<HWND>(n->m_hwnd), &isMDI);
RECT rc;
if (isMDI)
{
<< rc.left << _T(", ") << rc.top << _T(") / (")
<< rcWidth(&rc) << _T("x") << rcHeight(&rc) << _T(")")
<< std::endl;
- hwnd = getToplevelWindow(n->m_hwnd, NULL);
+ hwnd = getToplevelWindow(reinterpret_cast<HWND>(n->m_hwnd), NULL);
}
GetWindowRect(hwnd, &rc);
tasktray_wndProc(HWND i_hwnd, UINT i_message,
WPARAM i_wParam, LPARAM i_lParam)
{
+#ifdef MAYU64
+ Mayu *This = reinterpret_cast<Mayu *>(GetWindowLongPtr(i_hwnd, 0));
+#else
Mayu *This = reinterpret_cast<Mayu *>(GetWindowLong(i_hwnd, 0));
+#endif
if (!This)
switch (i_message)
case WM_CREATE:
This = reinterpret_cast<Mayu *>(
reinterpret_cast<CREATESTRUCT *>(i_lParam)->lpCreateParams);
+#ifdef MAYU64
+ SetWindowLongPtr(i_hwnd, 0, (LONG_PTR)This);
+#else
SetWindowLong(i_hwnd, 0, (long)This);
+#endif
return 0;
}
else
tomsgstream::StreamBuf *log =
reinterpret_cast<tomsgstream::StreamBuf *>(i_lParam);
const tstring &str = log->acquireString();
+#ifdef LOG_TO_FILE
+ This->m_logFile << str << std::flush;
+#endif // LOG_TO_FILE
editInsertTextAtLast(GetDlgItem(This->m_hwndLog, IDC_EDIT_log),
str, 65000);
log->releaseString();
ShowWindow(This->m_hwndLog, SW_SHOW);
SetForegroundWindow(This->m_hwndLog);
break;
+ case ID_MENUITEM_check:
+ {
+ BOOL ret;
+ BYTE keys[256];
+ ret = GetKeyboardState(keys);
+ if (ret == 0)
+ {
+ This->m_log << _T("Check Keystate Failed(%d)")
+ << GetLastError() << std::endl;
+ }
+ else
+ {
+ This->m_log << _T("Check Keystate: ") << std::endl;
+ for (int i = 0; i < 0xff; i++)
+ {
+ USHORT asyncKey;
+ asyncKey = GetAsyncKeyState(i);
+ This->m_log << std::hex;
+ if (asyncKey & 0x8000)
+ {
+ This->m_log << _T(" ") << VK2TCHAR[i]
+ << _T("(0x") << i << _T("): pressed!")
+ << std::endl;
+ }
+ if (i == 0x14 || // VK_CAPTITAL
+ i == 0x15 || // VK_KANA
+ i == 0x19 || // VK_KANJI
+ i == 0x90 || // VK_NUMLOCK
+ i == 0x91 // VK_SCROLL
+ )
+ {
+ if (keys[i] & 1)
+ {
+ This->m_log << _T(" ") << VK2TCHAR[i]
+ << _T("(0x") << i << _T("): locked!")
+ << std::endl;
+ }
+ }
+ This->m_log << std::dec;
+ }
+ This->m_log << std::endl;
+ }
+ break;
+ }
case ID_MENUITEM_version:
ShowWindow(This->m_hwndVersion, SW_SHOW);
SetForegroundWindow(This->m_hwndVersion);
public:
///
- Mayu()
+ Mayu(HANDLE i_mutex)
: m_hwndTaskTray(NULL),
+ m_mutex(i_mutex),
m_hwndLog(NULL),
m_WM_TaskbarRestart(RegisterWindowMessage(_T("TaskbarCreated"))),
m_WM_MayuIPC(RegisterWindowMessage(WM_MayuIPC_NAME)),
m_isSettingDialogOpened(false),
m_engine(m_log)
{
+#ifdef USE_MAILSLOT
+ m_hNotifyMailslot = CreateMailslot(NOTIFY_MAILSLOT_NAME, 0, MAILSLOT_WAIT_FOREVER, (SECURITY_ATTRIBUTES *)NULL);
+ ASSERT(m_hNotifyMailslot != INVALID_HANDLE_VALUE);
+ m_hNotifyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+ ASSERT(m_hNotifyEvent);
+ m_olNotify.Offset = 0;
+ m_olNotify.OffsetHigh = 0;
+ m_olNotify.hEvent = m_hNotifyEvent;
+#endif // USE_MAILSLOT
time(&m_startTime);
CHECK_TRUE( Register_focus() );
CHECK_TRUE( m_hwndTaskTray );
// set window handle of tasktray to hooks
- g_hookData->m_hwndTaskTray = m_hwndTaskTray;
+#ifndef USE_MAILSLOT
+ g_hookData->m_hwndTaskTray = reinterpret_cast<DWORD>(m_hwndTaskTray);
+#endif // !USE_MAILSLOT
+ CHECK_FALSE( installHooks(Engine::keyboardDetour, &m_engine) );
m_usingSN = wtsRegisterSessionNotification(m_hwndTaskTray,
NOTIFY_FOR_THIS_SESSION);
CHECK_TRUE( m_hwndVersion );
// attach log
+#ifdef LOG_TO_FILE
+ tstring path;
+ _TCHAR exePath[GANA_MAX_PATH];
+ _TCHAR exeDrive[GANA_MAX_PATH];
+ _TCHAR exeDir[GANA_MAX_PATH];
+ GetModuleFileName(NULL, exePath, GANA_MAX_PATH);
+ _tsplitpath_s(exePath, exeDrive, GANA_MAX_PATH, exeDir, GANA_MAX_PATH, NULL, 0, NULL, 0);
+ path = exeDrive;
+ path += exeDir;
+ path += _T("mayu.log");
+ m_logFile.open(path.c_str(), std::ios::app);
+ m_logFile.imbue(std::locale("japanese"));
+#endif // LOG_TO_FILE
SendMessage(GetDlgItem(m_hwndLog, IDC_EDIT_log), EM_SETLIMITTEXT, 0, 0);
m_log.attach(m_hwndTaskTray);
// set initial lock state
notifyLockState();
+
+ BOOL result;
+
+ ZeroMemory(&m_pi,sizeof(m_pi));
+ ZeroMemory(&m_si,sizeof(m_si));
+ m_si.cb=sizeof(m_si);
+#ifdef _WIN64
+ result = CreateProcess(_T("yamyd"), _T("yamyd"), NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS, 0, NULL, &m_si, &m_pi);
+#endif // _WIN64
}
///
~Mayu()
{
+ ReleaseMutex(m_mutex);
+ WaitForSingleObject(m_mutex, INFINITE);
// first, detach log from edit control to avoid deadlock
m_log.detach();
+#ifdef LOG_TO_FILE
+ m_logFile.close();
+#endif // LOG_TO_FILE
// stop notify from mayu.dll
g_hookData->m_hwndTaskTray = NULL;
+ CHECK_FALSE( uninstallHooks() );
+ SendMessage(HWND_BROADCAST, WM_NULL, 0, 0);
// destroy windows
CHECK_TRUE( DestroyWindow(m_hwndVersion) );
// remove setting;
delete m_setting;
+
+#ifdef USE_MAILSLOT
+ CloseHandle(m_hNotifyEvent);
+ CloseHandle(m_hNotifyMailslot);
+#endif // USE_MAILSLOT
}
/// message loop
showBanner(false);
load();
+#ifdef USE_MAILSLOT
+ mailslotHandler(0, 0);
+ while (1)
+ {
+ HANDLE handles[] = { m_hNotifyEvent };
+ DWORD ret;
+ switch (ret = MsgWaitForMultipleObjectsEx(NUMBER_OF(handles), &handles[0],
+ INFINITE, QS_ALLINPUT, MWMO_ALERTABLE | MWMO_INPUTAVAILABLE))
+ {
+ case WAIT_OBJECT_0: // m_hNotifyEvent
+ break;
+
+ case WAIT_OBJECT_0 + NUMBER_OF(handles):
+ {
+ MSG msg;
+ if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) != 0)
+ {
+ if (msg.message == WM_QUIT)
+ {
+ return msg.wParam;
+ }
+ if (IsDialogMessage(m_hwndLog, &msg))
+ break;
+ if (IsDialogMessage(m_hwndInvestigate, &msg))
+ break;
+ if (IsDialogMessage(m_hwndVersion, &msg))
+ break;
+ TranslateMessage(&msg);
+ DispatchMessage(&msg);
+ break;
+ }
+ break;
+ }
+
+ case WAIT_IO_COMPLETION:
+ break;
+
+ case 0x102:
+ default:
+ break;
+ }
+ }
+#else // !USE_MAILSLOT
MSG msg;
while (0 < GetMessage(&msg, NULL, 0, 0))
{
DispatchMessage(&msg);
}
return msg.wParam;
+#endif // !USE_MAILSLOT
}
};
#endif
// convert old registry to new registry
+#ifndef USE_INI
convertRegistry();
+#endif // !USE_INI
// is another mayu running ?
- HANDLE mutex = CreateMutex(
- (SECURITY_ATTRIBUTES *)NULL, TRUE,
- addSessionId(MUTEX_MAYU_EXCLUSIVE_RUNNING).c_str());
+ HANDLE mutex = CreateMutex((SECURITY_ATTRIBUTES *)NULL, TRUE,
+ MUTEX_MAYU_EXCLUSIVE_RUNNING);
if (GetLastError() == ERROR_ALREADY_EXISTS)
{
// another mayu already running
tstring title = loadString(IDS_mayu);
if (g_hookData) {
UINT WM_TaskbarRestart = RegisterWindowMessage(_T("TaskbarCreated"));
- PostMessage(g_hookData->m_hwndTaskTray, WM_TaskbarRestart, 0, 0);
+ PostMessage(reinterpret_cast<HWND>(g_hookData->m_hwndTaskTray),
+ WM_TaskbarRestart, 0, 0);
}
MessageBox((HWND)NULL, text.c_str(), title.c_str(), MB_OK | MB_ICONSTOP);
return 1;
return 1;
}
- CHECK_FALSE( installHooks() );
try
{
- Mayu().messageLoop();
+ Mayu(mutex).messageLoop();
}
catch (ErrorMessage &i_e)
{
MessageBox((HWND)NULL, i_e.getMessage().c_str(), title.c_str(),
MB_OK | MB_ICONSTOP);
}
- CHECK_FALSE( uninstallHooks() );
CHECK_TRUE( CloseHandle(mutex) );
return 0;
MENUITEM SEPARATOR\r
MENUITEM "\92²\8d¸(&I)...", ID_MENUITEM_investigate\r
MENUITEM "\83\8d\83O(&L)...", ID_MENUITEM_log\r
+ MENUITEM "\83`\83F\83b\83N(&C)...", ID_MENUITEM_check\r
MENUITEM "\83o\81[\83W\83\87\83\93(&V)...", ID_MENUITEM_version\r
MENUITEM "\83w\83\8b\83v(&H)...", ID_MENUITEM_help\r
MENUITEM SEPARATOR\r
MENUITEM SEPARATOR\r
MENUITEM "&Investigation...", ID_MENUITEM_investigate\r
MENUITEM "&Log...", ID_MENUITEM_log\r
+ MENUITEM "&Check...", ID_MENUITEM_check\r
MENUITEM "&Version...", ID_MENUITEM_version\r
MENUITEM "&Help...", ID_MENUITEM_help\r
MENUITEM SEPARATOR\r
#define ID_MENUITEM_help 40006\r
#define ID_MENUITEM_disable 40007\r
#define ID_MENUITEM_log 40008\r
+#define ID_MENUITEM_check 40009\r
#define IDC_STATIC -1\r
\r
// Next default values for new objects\r
bool Registry::remove(HKEY i_root, const tstring &i_path,
const tstring &i_name)
{
+#ifdef USE_INI
+ return false;
+ if (i_name.empty())
+ return false;
+ return WritePrivateProfileString(_T("yamy"), i_name.c_str(), NULL, i_path.c_str()) == TRUE;
+#else // !USE_INI
if (i_name.empty())
return RegDeleteKey(i_root, i_path.c_str()) == ERROR_SUCCESS;
HKEY hkey;
LONG r = RegDeleteValue(hkey, i_name.c_str());
RegCloseKey(hkey);
return r == ERROR_SUCCESS;
+#endif // !USE_INI
}
// does exist the key ?
bool Registry::doesExist(HKEY i_root, const tstring &i_path)
{
+#ifdef USE_INI
+ return true;
+#else // !USE_INI
HKEY hkey;
if (ERROR_SUCCESS !=
RegOpenKeyEx(i_root, i_path.c_str(), 0, KEY_READ, &hkey))
return false;
RegCloseKey(hkey);
return true;
+#endif // !USE_INI
}
bool Registry::read(HKEY i_root, const tstring &i_path,
const tstring &i_name, int *o_value, int i_defaultValue)
{
+#ifdef USE_INI
+ *o_value =
+ GetPrivateProfileInt(_T("yamy"), i_name.c_str(), i_defaultValue, i_path.c_str());
+ return true;
+#else // !USE_INI
HKEY hkey;
if (ERROR_SUCCESS ==
RegOpenKeyEx(i_root, i_path.c_str(), 0, KEY_READ, &hkey))
}
*o_value = i_defaultValue;
return false;
+#endif // !USE_INI
}
bool Registry::write(HKEY i_root, const tstring &i_path, const tstring &i_name,
int i_value)
{
+#ifdef USE_INI
+ DWORD ret;
+ _TCHAR buf[GANA_MAX_PATH];
+
+ _stprintf(buf, _T("%d"), i_value);
+ ret = WritePrivateProfileString(_T("yamy"), i_name.c_str(),
+ buf, i_path.c_str());
+ return ret != 0;
+#else // !USE_INI
HKEY hkey;
DWORD disposition;
if (ERROR_SUCCESS !=
(BYTE *)&i_value, sizeof(i_value));
RegCloseKey(hkey);
return r == ERROR_SUCCESS;
+#endif // !USE_INI
}
bool Registry::read(HKEY i_root, const tstring &i_path, const tstring &i_name,
tstring *o_value, const tstring &i_defaultValue)
{
+#ifdef USE_INI
+ _TCHAR buf[GANA_MAX_PATH];
+ DWORD len;
+ len = GetPrivateProfileString(_T("yamy"), i_name.c_str(), _T(""),
+ buf, sizeof(buf) / sizeof(buf[0]), i_path.c_str());
+ if (len > 0)
+ {
+ *o_value = buf;
+ return true;
+ }
+ if (!i_defaultValue.empty())
+ *o_value = i_defaultValue;
+ return false;
+#else // !USE_INI
HKEY hkey;
if (ERROR_SUCCESS ==
RegOpenKeyEx(i_root, i_path.c_str(), 0, KEY_READ, &hkey))
if (!i_defaultValue.empty())
*o_value = i_defaultValue;
return false;
+#endif // !USE_INI
}
bool Registry::write(HKEY i_root, const tstring &i_path,
const tstring &i_name, const tstring &i_value)
{
+#ifdef USE_INI
+ DWORD ret;
+
+ ret = WritePrivateProfileString(_T("yamy"), i_name.c_str(),
+ i_value.c_str(), i_path.c_str());
+ return ret != 0;
+#else // !USE_INI
HKEY hkey;
DWORD disposition;
if (ERROR_SUCCESS !=
(i_value.size() + 1) * sizeof(tstring::value_type));
RegCloseKey(hkey);
return true;
+#endif // !USE_INI
}
+#ifndef USE_INI
// read list of string
bool Registry::read(HKEY i_root, const tstring &i_path, const tstring &i_name,
tstrings *o_value, const tstrings &i_defaultValue)
RegCloseKey(hkey);
return true;
}
+#endif //!USE_INI
//
public:
///
- Registry() : m_root(NULL) { }
+ Registry() : m_root(NULL) { setRoot(NULL, _T("")); }
///
Registry(HKEY i_root, const tstring &i_path)
- : m_root(i_root), m_path(i_path) { }
+ : m_root(i_root), m_path(i_path) { setRoot(i_root, i_path); }
/// set registry root and path
void setRoot(HKEY i_root, const tstring &i_path)
- { m_root = i_root; m_path = i_path; }
+ {
+ m_root = i_root;
+ m_path = i_path;
+ _TCHAR exePath[GANA_MAX_PATH];
+ _TCHAR exeDrive[GANA_MAX_PATH];
+ _TCHAR exeDir[GANA_MAX_PATH];
+ GetModuleFileName(NULL, exePath, GANA_MAX_PATH);
+ _tsplitpath_s(exePath, exeDrive, GANA_MAX_PATH, exeDir, GANA_MAX_PATH, NULL, 0, NULL, 0);
+ m_path = exeDrive;
+ m_path += exeDir;
+ m_path += _T("yamy.ini");
+ }
/// remvoe
bool remove(const tstring &i_name = _T("")) const
bool write(const tstring &i_name, const tstring &i_value) const
{ return write(m_root, m_path, i_name, i_value); }
+#ifndef USE_INI
/// read list of tstring
bool read(const tstring &i_name, tstrings *o_value,
const tstrings &i_defaultValue = tstrings()) const
bool write(const tstring &i_name, const BYTE *i_value,
DWORD i_valueSize) const
{ return write(m_root, m_path, i_name, i_value, i_valueSize); }
+#endif //!USE_INI
public:
/// remove
static bool write(HKEY i_root, const tstring &i_path, const tstring &i_name,
const tstring &i_value);
+#ifndef USE_INI
/// read list of tstring
static bool read(HKEY i_root, const tstring &i_path, const tstring &i_name,
tstrings *o_value, const tstrings &i_defaultValue = tstrings());
/// write binary data
static bool write(HKEY i_root, const tstring &i_path, const tstring &i_name,
const BYTE *i_value, DWORD i_valueSize);
+#endif //!USE_INI
/// read LOGFONT
static bool read(HKEY i_root, const tstring &i_path, const tstring &i_name,
LOGFONT *o_value, const tstring &i_defaultStringValue);
void getHomeDirectories(HomeDirectories *o_pathes)
{
tstringi filename;
+#ifndef USE_INI
if (getFilenameFromRegistry(NULL, &filename, NULL) &&
!filename.empty())
{
DWORD len = GetCurrentDirectory(NUMBER_OF(buf), buf);
if (0 < len && len < NUMBER_OF(buf))
o_pathes->push_back(buf);
+#else //USE_INI
+ _TCHAR buf[GANA_MAX_PATH];
+#endif //USE_INI
if (GetModuleFileName(GetModuleHandle(NULL), buf, NUMBER_OF(buf)))
o_pathes->push_back(pathRemoveFileSpec(buf));
// <ARGUMENT>
+void SettingLoader::load_ARGUMENT(unsigned __int64 *o_arg)
+{
+ *o_arg = getToken()->getNumber();
+}
+
+
+// <ARGUMENT>
+void SettingLoader::load_ARGUMENT(__int64 *o_arg)
+{
+ *o_arg = getToken()->getNumber();
+}
+
+
+// <ARGUMENT>
void SettingLoader::load_ARGUMENT(tstringq *o_arg)
{
*o_arg = getToken()->getString();
void load_ARGUMENT(int *o_arg); /// <ARGUMENT>
void load_ARGUMENT(unsigned int *o_arg); /// <ARGUMENT>
void load_ARGUMENT(long *o_arg); /// <ARGUMENT>
+ void load_ARGUMENT(unsigned __int64 *o_arg); /// <ARGUMENT>
+ void load_ARGUMENT(__int64 *o_arg); /// <ARGUMENT>
void load_ARGUMENT(tstringq *o_arg); /// <ARGUMENT>
void load_ARGUMENT(std::list<tstringq> *o_arg); /// <ARGUMENT>
void load_ARGUMENT(tregex *o_arg); /// <ARGUMENT>
# include <cctype>
# include <string>
# include <iosfwd>
+# include <fstream>
+# include <locale>
# include <boost/regex.hpp>
# include <stdio.h> // for snprintf
typedef std::basic_stringstream<_TCHAR> tstringstream;
/// ifstream for generic international text
typedef std::basic_ifstream<_TCHAR> tifstream;
+/// ofstream for generic international text
+typedef std::basic_ofstream<_TCHAR> tofstream;
/// basic_regex for generic international text
typedef boost::basic_regex<_TCHAR> tregex;
/// match_results for generic international text
!if "$(TARGETOS)" == "WINNT"
APPVER = 5.0
!ifdef nodebug
-OUT_DIR = out$(MAYU_VC)_winnt
+OUT_DIR_EXE = out$(MAYU_VC)_winnt
!else # nodebug
-OUT_DIR = out$(MAYU_VC)_winnt_debug
+OUT_DIR_EXE = out$(MAYU_VC)_winnt_debug
!endif # nodebug
+!ifdef X64
+OUT_DIR = $(OUT_DIR_EXE)_x64
+!else
+OUT_DIR = $(OUT_DIR_EXE)_x86
+!endif
!endif # TARGETOS
!if "$(TARGETOS)" == "WIN95"
#NMAKE_WINVER = 0x0500 # trick for WS_EX_LAYERED
!ifdef nodebug
-DEBUG_FLAG = $(cdebug)
-!else # nodebug
DEBUG_FLAG =
+!else # nodebug
+DEBUG_FLAG = $(cdebug)
!endif # nodebug
{}.cpp{$(OUT_DIR)}.obj:
- $(cc) -GX $(cflags) $(cvarsmt) $(DEFINES) $(INCLUDES) \
+ $(cc) -EHsc $(cflags) $(cvarsmt) $(DEFINES) $(INCLUDES) \
$(DEBUG_FLAG) -Fo$@ $(*B).cpp
{}.rc{$(OUT_DIR)}.res:
$(rc) $(rcflags) $(rcvars) /fo$@ $(*B).rc
+!ifdef nodebug
conxlibsmt = $(conlibsmt) libcpmt.lib libcmt.lib
guixlibsmt = $(guilibsmt) libcpmt.lib libcmt.lib
+!else # nodebug
+conxlibsmt = $(conlibsmt) libcpmtd.lib libcmtd.lib
+guixlibsmt = $(guilibsmt) libcpmtd.lib libcmtd.lib
+!endif # nodebug
DEPENDFLAGS = --cpp=vc --ignore='$(INCLUDE)' -p"$$(OUT_DIR)\\" \
--path-delimiter=dos --newline=unix \
- $(DEPENDIGNORE) -GX $(cflags) $(cvarsmt) \
+ $(DEPENDIGNORE) -EHsc $(cflags) $(cvarsmt) \
$(DEFINES) $(INCLUDES) $(DEBUG_FLAG)
CLEAN = $(OUT_DIR)\*.pdb
{
while (i_hwnd)
{
+#ifdef MAYU64
+ LONG_PTR style = GetWindowLongPtr(i_hwnd, GWL_STYLE);
+#else
LONG style = GetWindowLong(i_hwnd, GWL_STYLE);
+#endif
if ((style & WS_CHILD) == 0)
break;
if (io_isMDI && *io_isMDI)
{
+#ifdef MAYU64
+ LONG_PTR exStyle = GetWindowLongPtr(i_hwnd, GWL_EXSTYLE);
+#else
LONG exStyle = GetWindowLong(i_hwnd, GWL_EXSTYLE);
+#endif
if (exStyle & WS_EX_MDICHILD)
return i_hwnd;
}
/// get/set GWL_USERDATA
template <class T> inline T getUserData(HWND i_hwnd, T *i_wc)
{
+#ifdef MAYU64
+ return (*i_wc = reinterpret_cast<T>(GetWindowLongPtr(i_hwnd, GWLP_USERDATA)));
+#else
return (*i_wc = reinterpret_cast<T>(GetWindowLong(i_hwnd, GWL_USERDATA)));
+#endif
}
///
template <class T> inline T setUserData(HWND i_hwnd, T i_wc)
{
+#ifdef MAYU64
+ SetWindowLongPtr(i_hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(i_wc));
+#else
SetWindowLong(i_hwnd, GWL_USERDATA, reinterpret_cast<long>(i_wc));
+#endif
return i_wc;
}
OSDN Git Service
