//see Q160957 and http://developer.netscape.com/docs/manuals/communicator/DDE/index.htm
static void GetOpenBrowserUrlsForBrowser(const char *szBrowser, HWND hwndDlg, HWND hwndCombo)
{
int windowCount, i;
DWORD *windowId;
DWORD dwResult;
ATOM hSzBrowser = GlobalAddAtomA(szBrowser);
ATOM hSzTopic = GlobalAddAtomA("WWW_ListWindows");
ddeAcked = 0;
if ( !SendMessageTimeout(HWND_BROADCAST, WM_DDE_INITIATE, (WPARAM)hwndDlg, MAKELPARAM(hSzBrowser, hSzTopic), SMTO_ABORTIFHUNG|SMTO_NORMAL, DDEMESSAGETIMEOUT, (PDWORD_PTR)&dwResult)
|| !ddeAcked) {
GlobalDeleteAtom(hSzTopic);
GlobalDeleteAtom(hSzBrowser);
return;
}
HGLOBAL hData = DoDdeRequest("WWW_ListWindows", hwndDlg);
if (hData == NULL) {
GlobalDeleteAtom(hSzTopic);
GlobalDeleteAtom(hSzBrowser);
return;
}
int dataLength = GlobalSize(hData)-offsetof(DDEDATA, Value);
DDEDATA *data = (DDEDATA*)GlobalLock(hData);
windowCount = dataLength / sizeof(DWORD);
windowId = (PDWORD)mir_alloc(sizeof(DWORD)*windowCount);
memcpy(windowId, data->Value, windowCount*sizeof(DWORD));
GlobalUnlock(hData);
FreeDdeRequestData(hData);
PostMessage(hwndDde, WM_DDE_TERMINATE, (WPARAM)hwndDlg, 0);
GlobalDeleteAtom(hSzTopic);
hSzTopic = GlobalAddAtomA("WWW_GetWindowInfo");
ddeAcked = 0;
if ( !SendMessageTimeout(HWND_BROADCAST, WM_DDE_INITIATE, (WPARAM)hwndDlg, MAKELPARAM(hSzBrowser, hSzTopic), SMTO_ABORTIFHUNG|SMTO_NORMAL, DDEMESSAGETIMEOUT, (PDWORD_PTR)&dwResult)
|| !ddeAcked) {
GlobalDeleteAtom(hSzTopic);
GlobalDeleteAtom(hSzBrowser);
mir_free(windowId);
return;
}
for (i=0;i<windowCount;i++) {
if (windowId[i] == 0) break;
{ char str[16];
mir_snprintf(str, _countof(str), "%d", windowId[i]);
hData = DoDdeRequest(str, hwndDlg);
}
if (hData != NULL) {
dataLength = GlobalSize(hData)-offsetof(DDEDATA, Value);
data = (DDEDATA*)GlobalLock(hData);
AddBrowserPageToCombo((char*)data->Value, hwndCombo);
GlobalUnlock(hData);
FreeDdeRequestData(hData);
}
}
PostMessage(hwndDde, WM_DDE_TERMINATE, (WPARAM)hwndDlg, 0);
GlobalDeleteAtom(hSzTopic);
GlobalDeleteAtom(hSzBrowser);
mir_free(windowId);
}
void InitPasteSerial()
{
bInitPasteSerial=TRUE;
if (nHotkeyDelimSkipID=GlobalAddAtomA("AkelPad::PasteSerial::DelimSkip"))
RegisterHotKey(hMainWnd, nHotkeyDelimSkipID, GetHotkeyMod(dwHotkeyDelimSkip), LOBYTE(dwHotkeyDelimSkip));
if (nHotkeyDelimAsTabID=GlobalAddAtomA("AkelPad::PasteSerial::DelimAsTab"))
RegisterHotKey(hMainWnd, nHotkeyDelimAsTabID, GetHotkeyMod(dwHotkeyDelimAsTab), LOBYTE(dwHotkeyDelimAsTab));
if (nHotkeyDelimAsIsID=GlobalAddAtomA("AkelPad::PasteSerial::DelimAsIs"))
RegisterHotKey(hMainWnd, nHotkeyDelimAsIsID, GetHotkeyMod(dwHotkeyDelimAsIs), LOBYTE(dwHotkeyDelimAsIs));
}
static HGLOBAL DoDdeRequest(const char *szItemName, HWND hwndDlg)
{
DWORD timeoutTick, thisTick;
MSG msg;
ATOM hSzItemName = GlobalAddAtomA(szItemName);
if ( !PostMessage(hwndDde, WM_DDE_REQUEST, (WPARAM)hwndDlg, MAKELPARAM(CF_TEXT, hSzItemName))) {
GlobalDeleteAtom(hSzItemName);
return NULL;
}
timeoutTick = GetTickCount()+5000;
ddeData = 0; ddeAcked = 0;
do {
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if (ddeData || ddeAcked) break;
thisTick = GetTickCount();
if (thisTick>timeoutTick) break;
}
while (MsgWaitForMultipleObjects(0, NULL, FALSE, timeoutTick-thisTick, QS_ALLINPUT) == WAIT_OBJECT_0);
if ( !ddeData) {
GlobalDeleteAtom(hSzItemName);
return NULL;
}
return hGlobalDdeData;
}
// assumes UnregisterHotKeys was called before
static int RegisterHotKeys()
{
hMessageWindow = CreateWindowEx(0, _T("STATIC"), NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL);
SetWindowLongPtr(hMessageWindow, GWLP_WNDPROC, (LONG_PTR)MessageWndProc);
int count = GetProfileCount(0, 0);
for ( int i=0; i < count; i++ ) {
if (!db_get_b(NULL, MODULENAME, OptName(i, SETTING_REGHOTKEY), 0))
continue;
WORD wHotKey = db_get_w(NULL, MODULENAME, OptName(i, SETTING_HOTKEY), 0);
hkInfo = ( HKINFO* )realloc(hkInfo, (hkiCount+1)*sizeof(HKINFO));
if (hkInfo == NULL)
return -1;
char atomname[255];
mir_snprintf(atomname, _countof(atomname), "StatusProfile_%d", i);
hkInfo[hkiCount].id = GlobalAddAtomA(atomname);
if (hkInfo[hkiCount].id == 0)
continue;
hkInfo[hkiCount].profile = i;
hkiCount ++;
RegisterHotKey(hMessageWindow, (int)hkInfo[hkiCount-1].id, GetFsModifiers(wHotKey), LOBYTE(wHotKey));
}
if (hkiCount == 0)
UnregisterHotKeys();
return 0;
}
static void initialize_display_settings( HWND desktop )
{
static const WCHAR display_device_guid_propW[] = {
'_','_','w','i','n','e','_','d','i','s','p','l','a','y','_',
'd','e','v','i','c','e','_','g','u','i','d',0 };
GUID guid;
RPC_CSTR guid_str;
ATOM guid_atom;
DEVMODEW dmW;
UuidCreate( &guid );
UuidToStringA( &guid, &guid_str );
WINE_TRACE( "display guid %s\n", guid_str );
guid_atom = GlobalAddAtomA( (LPCSTR)guid_str );
SetPropW( desktop, display_device_guid_propW, ULongToHandle(guid_atom) );
RpcStringFreeA( &guid_str );
/* Store current display mode in the registry */
if (EnumDisplaySettingsExW( NULL, ENUM_CURRENT_SETTINGS, &dmW, 0 ))
{
WINE_TRACE( "Current display mode %ux%u %u bpp %u Hz\n", dmW.dmPelsWidth,
dmW.dmPelsHeight, dmW.dmBitsPerPel, dmW.dmDisplayFrequency );
ChangeDisplaySettingsExW( NULL, &dmW, 0,
CDS_GLOBAL | CDS_NORESET | CDS_UPDATEREGISTRY,
NULL );
}
}
int ps_create_resolution(int monitor_index, ModeLine *modeline)
{
LRESULT lresult;
ATOM atom;
char out[256];
MonitorTiming timing = {0};
if (!hPSWnd) return 0;
modeline_to_pstiming(modeline, &timing);
fill_timing_string(out, &timing);
atom = GlobalAddAtomA(out);
if (atom)
{
lresult = SendMessage(hPSWnd, UM_CREATERESOLUTION, monitor_index, atom);
if (lresult < 0)
{
mame_printf_verbose("PStrip: SendMessage failed\n");
GlobalDeleteAtom(atom);
}
else
{
mame_printf_verbose("PStrip: ps_create_resolution(%d): %dx%d succeded \n",
modeline->a_width, modeline->a_height, monitor_index);
return 1;
}
}
else mame_printf_verbose("PStrip: ps_create_resolution atom creation failed\n");
return 0;
}
int ps_set_monitor_timing(int monitor_index, MonitorTiming *timing)
{
LRESULT lresult;
ATOM atom;
char out[256];
if (!hPSWnd) return 0;
fill_timing_string(out, timing);
atom = GlobalAddAtomA(out);
if (atom)
{
lresult = SendMessage(hPSWnd, UM_SETCUSTOMTIMING, monitor_index, atom);
if (lresult < 0)
{
mame_printf_verbose("PStrip: SendMessage failed\n");
GlobalDeleteAtom(atom);
}
else
{
mame_printf_verbose("PStrip: ps_set_monitor_timing(%d): %s\n", monitor_index, out);
return 1;
}
}
else mame_printf_verbose("PStrip: ps_set_monitor_timing atom creation failed\n");
return 0;
}
GlobalKey::GlobalKey(CommandDef *cmd)
{
m_cmd = *cmd;
int mod, key;
getKey(cmd->accel, mod, key);
QWidget *main = ShortcutsPlugin::getMainWindow();
if (key && main){
string atom = "sim_";
atom += number(cmd->id);
m_key = GlobalAddAtomA(atom.c_str());
RegisterHotKey(main->winId(), m_key, mod, key);
}
}
static void test_error_handling(void)
{
char buffer[260];
WCHAR bufferW[260];
int i;
memset( buffer, 'a', 256 );
buffer[256] = 0;
ok( !GlobalAddAtomA(buffer), "add succeeded\n" );
ok( !GlobalFindAtomA(buffer), "find succeeded\n" );
if (unicode_OS)
{
for (i = 0; i < 256; i++) bufferW[i] = 'b';
bufferW[256] = 0;
ok( !GlobalAddAtomW(bufferW), "add succeeded\n" );
ok( !GlobalFindAtomW(bufferW), "find succeeded\n" );
}
}
static void test_handles(void)
{
HWINSTA w1, w2, w3;
HDESK d1, d2, d3;
HANDLE hthread;
DWORD id, flags, le;
ATOM atom;
char buffer[20];
/* win stations */
w1 = GetProcessWindowStation();
ok( GetProcessWindowStation() == w1, "GetProcessWindowStation returned different handles\n" );
ok( !CloseWindowStation(w1), "closing process win station succeeded\n" );
SetLastError( 0xdeadbeef );
ok( !CloseHandle(w1), "closing process win station handle succeeded\n" );
ok( GetLastError() == ERROR_INVALID_HANDLE, "bad last error %d\n", GetLastError() );
print_object( w1 );
flags = 0;
ok( GetHandleInformation( w1, &flags ), "GetHandleInformation failed\n" );
ok( !(flags & HANDLE_FLAG_PROTECT_FROM_CLOSE) ||
broken(flags & HANDLE_FLAG_PROTECT_FROM_CLOSE), /* set on nt4 */
"handle %p PROTECT_FROM_CLOSE set\n", w1 );
ok( DuplicateHandle( GetCurrentProcess(), w1, GetCurrentProcess(), (PHANDLE)&w2, 0,
TRUE, DUPLICATE_SAME_ACCESS ), "DuplicateHandle failed\n" );
ok( CloseWindowStation(w2), "closing dup win station failed\n" );
ok( DuplicateHandle( GetCurrentProcess(), w1, GetCurrentProcess(), (PHANDLE)&w2, 0,
TRUE, DUPLICATE_SAME_ACCESS ), "DuplicateHandle failed\n" );
ok( CloseHandle(w2), "closing dup win station handle failed\n" );
w2 = CreateWindowStation("WinSta0", 0, WINSTA_ALL_ACCESS, NULL );
le = GetLastError();
ok( w2 != 0 || le == ERROR_ACCESS_DENIED, "CreateWindowStation failed (%u)\n", le );
if (w2 != 0)
{
ok( w2 != w1, "CreateWindowStation returned default handle\n" );
SetLastError( 0xdeadbeef );
ok( !CloseDesktop( (HDESK)w2 ), "CloseDesktop succeeded on win station\n" );
ok( GetLastError() == ERROR_INVALID_HANDLE || broken(GetLastError() == 0xdeadbeef), /* wow64 */
"bad last error %d\n", GetLastError() );
ok( CloseWindowStation( w2 ), "CloseWindowStation failed\n" );
w2 = CreateWindowStation("WinSta0", 0, WINSTA_ALL_ACCESS, NULL );
ok( CloseHandle( w2 ), "CloseHandle failed\n" );
}
else if (le == ERROR_ACCESS_DENIED)
win_skip( "Not enough privileges for CreateWindowStation\n" );
w2 = OpenWindowStation("winsta0", TRUE, WINSTA_ALL_ACCESS );
ok( w2 != 0, "OpenWindowStation failed\n" );
ok( w2 != w1, "OpenWindowStation returned default handle\n" );
ok( CloseWindowStation( w2 ), "CloseWindowStation failed\n" );
w2 = OpenWindowStation("dummy name", TRUE, WINSTA_ALL_ACCESS );
ok( !w2, "open dummy win station succeeded\n" );
CreateMutexA( NULL, 0, "foobar" );
w2 = CreateWindowStation("foobar", 0, WINSTA_ALL_ACCESS, NULL );
le = GetLastError();
ok( w2 != 0 || le == ERROR_ACCESS_DENIED, "create foobar station failed (%u)\n", le );
if (w2 != 0)
{
w3 = OpenWindowStation("foobar", TRUE, WINSTA_ALL_ACCESS );
ok( w3 != 0, "open foobar station failed\n" );
ok( w3 != w2, "open foobar station returned same handle\n" );
ok( CloseWindowStation( w2 ), "CloseWindowStation failed\n" );
ok( CloseWindowStation( w3 ), "CloseWindowStation failed\n" );
w3 = OpenWindowStation("foobar", TRUE, WINSTA_ALL_ACCESS );
ok( !w3, "open foobar station succeeded\n" );
w2 = CreateWindowStation("foobar1", 0, WINSTA_ALL_ACCESS, NULL );
ok( w2 != 0, "create foobar station failed\n" );
w3 = CreateWindowStation("foobar2", 0, WINSTA_ALL_ACCESS, NULL );
ok( w3 != 0, "create foobar station failed\n" );
ok( GetHandleInformation( w2, &flags ), "GetHandleInformation failed\n" );
ok( GetHandleInformation( w3, &flags ), "GetHandleInformation failed\n" );
SetProcessWindowStation( w2 );
atom = GlobalAddAtomA("foo");
ok( GlobalGetAtomNameA( atom, buffer, sizeof(buffer) ) == 3, "GlobalGetAtomName failed\n" );
ok( !lstrcmpiA( buffer, "foo" ), "bad atom value %s\n", buffer );
ok( !CloseWindowStation( w2 ), "CloseWindowStation succeeded\n" );
ok( GetHandleInformation( w2, &flags ), "GetHandleInformation failed\n" );
SetProcessWindowStation( w3 );
ok( GetHandleInformation( w2, &flags ), "GetHandleInformation failed\n" );
ok( CloseWindowStation( w2 ), "CloseWindowStation failed\n" );
ok( GlobalGetAtomNameA( atom, buffer, sizeof(buffer) ) == 3, "GlobalGetAtomName failed\n" );
ok( !lstrcmpiA( buffer, "foo" ), "bad atom value %s\n", buffer );
}
else if (le == ERROR_ACCESS_DENIED)
win_skip( "Not enough privileges for CreateWindowStation\n" );
/* desktops */
d1 = GetThreadDesktop(GetCurrentThreadId());
initial_desktop = d1;
ok( GetThreadDesktop(GetCurrentThreadId()) == d1,
"GetThreadDesktop returned different handles\n" );
flags = 0;
ok( GetHandleInformation( d1, &flags ), "GetHandleInformation failed\n" );
ok( !(flags & HANDLE_FLAG_PROTECT_FROM_CLOSE), "handle %p PROTECT_FROM_CLOSE set\n", d1 );
SetLastError( 0xdeadbeef );
ok( !CloseDesktop(d1), "closing thread desktop succeeded\n" );
ok( GetLastError() == ERROR_BUSY || broken(GetLastError() == 0xdeadbeef), /* wow64 */
"bad last error %d\n", GetLastError() );
SetLastError( 0xdeadbeef );
if (CloseHandle( d1 )) /* succeeds on nt4 */
{
win_skip( "NT4 desktop handle management is completely different\n" );
return;
}
ok( GetLastError() == ERROR_INVALID_HANDLE, "bad last error %d\n", GetLastError() );
ok( DuplicateHandle( GetCurrentProcess(), d1, GetCurrentProcess(), (PHANDLE)&d2, 0,
TRUE, DUPLICATE_SAME_ACCESS ), "DuplicateHandle failed\n" );
ok( CloseDesktop(d2), "closing dup desktop failed\n" );
ok( DuplicateHandle( GetCurrentProcess(), d1, GetCurrentProcess(), (PHANDLE)&d2, 0,
TRUE, DUPLICATE_SAME_ACCESS ), "DuplicateHandle failed\n" );
ok( CloseHandle(d2), "closing dup desktop handle failed\n" );
d2 = OpenDesktop( "dummy name", 0, TRUE, DESKTOP_ALL_ACCESS );
ok( !d2, "open dummy desktop succeeded\n" );
d2 = CreateDesktop( "foobar", NULL, NULL, 0, DESKTOP_ALL_ACCESS, NULL );
ok( d2 != 0, "create foobar desktop failed\n" );
SetLastError( 0xdeadbeef );
ok( !CloseWindowStation( (HWINSTA)d2 ), "CloseWindowStation succeeded on desktop\n" );
ok( GetLastError() == ERROR_INVALID_HANDLE || broken(GetLastError() == 0xdeadbeef), /* wow64 */
"bad last error %d\n", GetLastError() );
SetLastError( 0xdeadbeef );
d3 = CreateDesktop( "foobar", NULL, NULL, 0, DESKTOP_ALL_ACCESS, NULL );
ok( d3 != 0, "create foobar desktop again failed\n" );
ok( GetLastError() == 0xdeadbeef, "bad last error %d\n", GetLastError() );
ok( CloseDesktop( d3 ), "CloseDesktop failed\n" );
d3 = OpenDesktop( "foobar", 0, TRUE, DESKTOP_ALL_ACCESS );
ok( d3 != 0, "open foobar desktop failed\n" );
ok( d3 != d2, "open foobar desktop returned same handle\n" );
ok( CloseDesktop( d2 ), "CloseDesktop failed\n" );
ok( CloseDesktop( d3 ), "CloseDesktop failed\n" );
d3 = OpenDesktop( "foobar", 0, TRUE, DESKTOP_ALL_ACCESS );
ok( !d3, "open foobar desktop succeeded\n" );
ok( !CloseHandle(d1), "closing thread desktop handle succeeded\n" );
d2 = GetThreadDesktop(GetCurrentThreadId());
ok( d1 == d2, "got different handles after close\n" );
register_class();
trace( "thread 1 desktop: %p\n", d1 );
print_object( d1 );
hthread = CreateThread( NULL, 0, thread, (LPVOID)2, 0, &id );
Sleep(1000);
trace( "get other thread desktop: %p\n", GetThreadDesktop(id) );
WaitForSingleObject( hthread, INFINITE );
CloseHandle( hthread );
}
/*****************************************************************************
* Thread: main loop
*****************************************************************************/
static void *Thread( void *p_data )
{
MSG message;
intf_thread_t *p_intf = p_data;
intf_sys_t *p_sys = p_intf->p_sys;
/* Window which receives Hotkeys */
vlc_mutex_lock( &p_sys->lock );
p_sys->hotkeyWindow =
(void*)CreateWindow( _T("STATIC"), /* name of window class */
_T("VLC ghk ") _T(VERSION), /* window title bar text */
0, /* window style */
0, /* default X coordinate */
0, /* default Y coordinate */
0, /* window width */
0, /* window height */
NULL, /* no parent window */
NULL, /* no menu in this window */
GetModuleHandle(NULL), /* handle of this program instance */
NULL ); /* sent to WM_CREATE */
if( p_sys->hotkeyWindow == NULL )
{
p_sys->hotkeyWindow = INVALID_HANDLE_VALUE;
vlc_cond_signal( &p_sys->wait );
vlc_mutex_unlock( &p_sys->lock );
return NULL;
}
vlc_cond_signal( &p_sys->wait );
vlc_mutex_unlock( &p_sys->lock );
SetWindowLongPtr( p_sys->hotkeyWindow, GWLP_WNDPROC,
(LONG_PTR)WMHOTKEYPROC );
SetWindowLongPtr( p_sys->hotkeyWindow, GWLP_USERDATA,
(LONG_PTR)p_intf );
/* Registering of Hotkeys */
for( const struct hotkey *p_hotkey = p_intf->obj.libvlc->p_hotkeys;
p_hotkey->psz_action != NULL;
p_hotkey++ )
{
char varname[12 + strlen( p_hotkey->psz_action )];
sprintf( varname, "global-key-%s", p_hotkey->psz_action );
char *key = var_InheritString( p_intf, varname );
if( key == NULL )
continue;
UINT i_key = vlc_str2keycode( key );
free( key );
if( i_key == KEY_UNSET )
continue;
UINT i_keyMod = 0;
if( i_key & KEY_MODIFIER_SHIFT ) i_keyMod |= MOD_SHIFT;
if( i_key & KEY_MODIFIER_ALT ) i_keyMod |= MOD_ALT;
if( i_key & KEY_MODIFIER_CTRL ) i_keyMod |= MOD_CONTROL;
#define HANDLE( key ) case KEY_##key: i_vk = VK_##key; break
#define HANDLE2( key, key2 ) case KEY_##key: i_vk = VK_##key2; break
#define KEY_SPACE ' '
#ifndef VK_VOLUME_DOWN
#define VK_VOLUME_DOWN 0xAE
#define VK_VOLUME_UP 0xAF
#endif
#ifndef VK_MEDIA_NEXT_TRACK
#define VK_MEDIA_NEXT_TRACK 0xB0
#define VK_MEDIA_PREV_TRACK 0xB1
#define VK_MEDIA_STOP 0xB2
#define VK_MEDIA_PLAY_PAUSE 0xB3
#endif
#ifndef VK_PAGEUP
#define VK_PAGEUP 0x21
#define VK_PAGEDOWN 0x22
#endif
UINT i_vk = 0;
switch( i_key & ~KEY_MODIFIER )
{
HANDLE( LEFT );
HANDLE( RIGHT );
HANDLE( UP );
HANDLE( DOWN );
HANDLE( SPACE );
HANDLE2( ESC, ESCAPE );
HANDLE2( ENTER, RETURN );
HANDLE( F1 );
HANDLE( F2 );
HANDLE( F3 );
HANDLE( F4 );
HANDLE( F5 );
HANDLE( F6 );
HANDLE( F7 );
HANDLE( F8 );
HANDLE( F9 );
HANDLE( F10 );
HANDLE( F11 );
HANDLE( F12 );
HANDLE( PAGEUP );
HANDLE( PAGEDOWN );
HANDLE( HOME );
HANDLE( END );
HANDLE( INSERT );
HANDLE( DELETE );
HANDLE( VOLUME_DOWN );
HANDLE( VOLUME_UP );
HANDLE( MEDIA_PLAY_PAUSE );
HANDLE( MEDIA_STOP );
HANDLE( MEDIA_PREV_TRACK );
HANDLE( MEDIA_NEXT_TRACK );
default:
i_vk = toupper( (uint8_t)(i_key & ~KEY_MODIFIER) );
break;
}
if( !i_vk ) continue;
#undef HANDLE
#undef HANDLE2
ATOM atom = GlobalAddAtomA( p_hotkey->psz_action );
if( !atom ) continue;
if( !RegisterHotKey( p_sys->hotkeyWindow, atom, i_keyMod, i_vk ) )
GlobalDeleteAtom( atom );
}
/* Main message loop */
while( GetMessage( &message, NULL, 0, 0 ) )
DispatchMessage( &message );
/* Unregistering of Hotkeys */
for( const struct hotkey *p_hotkey = p_intf->obj.libvlc->p_hotkeys;
p_hotkey->psz_action != NULL;
p_hotkey++ )
{
ATOM atom = GlobalFindAtomA( p_hotkey->psz_action );
if( !atom ) continue;
if( UnregisterHotKey( p_sys->hotkeyWindow, atom ) )
GlobalDeleteAtom( atom );
}
/* close window */
vlc_mutex_lock( &p_sys->lock );
DestroyWindow( p_sys->hotkeyWindow );
p_sys->hotkeyWindow = NULL;
vlc_mutex_unlock( &p_sys->lock );
return NULL;
}
static void test_add_atom(void)
{
ATOM atom, w_atom;
INT_PTR i;
SetLastError( 0xdeadbeef );
atom = GlobalAddAtomA( "foobar" );
ok( atom >= 0xc000, "bad atom id %x\n", atom );
ok( GetLastError() == 0xdeadbeef, "GlobalAddAtomA set last error\n" );
/* Verify that it can be found (or not) appropriately */
ok( GlobalFindAtomA( "foobar" ) == atom, "could not find atom foobar\n" );
ok( GlobalFindAtomA( "FOOBAR" ) == atom, "could not find atom FOOBAR\n" );
ok( !GlobalFindAtomA( "_foobar" ), "found _foobar\n" );
/* Add the same atom, specifying string as unicode; should
* find the first one, not add a new one */
SetLastError( 0xdeadbeef );
w_atom = GlobalAddAtomW( foobarW );
if (w_atom && GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
unicode_OS = TRUE;
else
trace("WARNING: Unicode atom APIs are not supported on this platform\n");
if (unicode_OS)
{
ok( w_atom == atom, "Unicode atom does not match ASCII\n" );
ok( GetLastError() == 0xdeadbeef, "GlobalAddAtomW set last error\n" );
}
/* Verify that it can be found (or not) appropriately via unicode name */
if (unicode_OS)
{
ok( GlobalFindAtomW( foobarW ) == atom, "could not find atom foobar\n" );
ok( GlobalFindAtomW( FOOBARW ) == atom, "could not find atom FOOBAR\n" );
ok( !GlobalFindAtomW( _foobarW ), "found _foobar\n" );
}
/* Test integer atoms
* (0x0001 .. 0xbfff) should be valid;
* (0xc000 .. 0xffff) should be invalid */
SetLastError( 0xdeadbeef );
ok( GlobalAddAtomA(0) == 0 && GetLastError() == 0xdeadbeef, "succeeded to add atom 0\n" );
if (unicode_OS)
{
SetLastError( 0xdeadbeef );
ok( GlobalAddAtomW(0) == 0 && GetLastError() == 0xdeadbeef, "succeeded to add atom 0\n" );
}
SetLastError( 0xdeadbeef );
for (i = 1; i <= 0xbfff; i++)
{
SetLastError( 0xdeadbeef );
ok( GlobalAddAtomA((LPCSTR)i) == i && GetLastError() == 0xdeadbeef,
"failed to add atom %lx\n", i );
if (unicode_OS)
{
SetLastError( 0xdeadbeef );
ok( GlobalAddAtomW((LPCWSTR)i) == i && GetLastError() == 0xdeadbeef,
"failed to add atom %lx\n", i );
}
}
for (i = 0xc000; i <= 0xffff; i++)
{
ok( !GlobalAddAtomA((LPCSTR)i), "succeeded adding %lx\n", i );
if (unicode_OS)
ok( !GlobalAddAtomW((LPCWSTR)i), "succeeded adding %lx\n", i );
}
}
static void test_get_atom_name(void)
{
char buf[10];
WCHAR bufW[10];
int i;
UINT len;
static const WCHAR resultW[] = {'f','o','o','b','a','r',0,'.','.','.'};
char in[257], out[257];
WCHAR inW[257], outW[257];
ATOM atom = GlobalAddAtomA( "foobar" );
/* Get the name of the atom we added above */
memset( buf, '.', sizeof(buf) );
len = GlobalGetAtomNameA( atom, buf, 10 );
ok( len == strlen("foobar"), "bad length %d\n", len );
ok( !memcmp( buf, "foobar\0...", 10 ), "bad buffer contents\n" );
/* Repeat, unicode-style */
if (unicode_OS)
{
for (i = 0; i < 10; i++) bufW[i] = '.';
SetLastError( 0xdeadbeef );
len = GlobalGetAtomNameW( atom, bufW, 10 );
ok( len && GetLastError() == 0xdeadbeef, "GlobalGetAtomNameW failed\n" );
ok( len == lstrlenW(foobarW), "bad length %d\n", len );
ok( !memcmp( bufW, resultW, 10*sizeof(WCHAR) ), "bad buffer contents\n" );
}
/* Check error code returns */
memset(buf, '.', 10);
ok( !GlobalGetAtomNameA( atom, buf, 0 ), "succeeded\n" );
ok( !memcmp( buf, "..........", 10 ), "should not touch buffer\n" );
if (unicode_OS)
{
static const WCHAR sampleW[] = {'.','.','.','.','.','.','.','.','.','.'};
for (i = 0; i < 10; i++) bufW[i] = '.';
ok( !GlobalGetAtomNameW( atom, bufW, 0 ), "succeeded\n" );
ok( !memcmp( bufW, sampleW, sizeof(sampleW) ), "should not touch buffer\n" );
}
/* Test integer atoms */
for (i = 0; i <= 0xbfff; i++)
{
memset( buf, 'a', 10 );
len = GlobalGetAtomNameA( (ATOM)i, buf, 10 );
if (i)
{
char res[20];
ok( (len > 1) && (len < 7), "bad length %d\n", len );
sprintf( res, "#%d", i );
memset( res + strlen(res) + 1, 'a', 10 );
ok( !memcmp( res, buf, 10 ), "bad buffer contents %s\n", buf );
if (len <= 1 || len >= 7) break; /* don't bother testing all of them */
}
else
ok( !len, "bad length %d\n", len );
SetLastError(0xdeadbeef);
len = GlobalGetAtomNameA( (ATOM)i, buf, 2);
ok(!len, "bad length %d\n", len);
ok(GetLastError() == ERROR_MORE_DATA || GetLastError() == ERROR_INVALID_PARAMETER,
"wrong error conditions %u for %u\n", GetLastError(), i);
}
memset( buf, '.', sizeof(buf) );
len = GlobalGetAtomNameA( atom, buf, 6 );
ok( len == 0, "bad length %d\n", len );
ok( !memcmp( buf, "fooba\0....", 10 ), "bad buffer contents\n");
if (unicode_OS)
{
static const WCHAR resW[] = {'f','o','o','b','a','r','.','.','.','.'};
for (len = 0; len < 10; len++) bufW[len] = '.';
SetLastError(0xdeadbeef);
len = GlobalGetAtomNameW( atom, bufW, 6 );
ok( len && GetLastError() == 0xdeadbeef, "GlobalGetAtomNameW failed\n" );
ok( len == lstrlenW(foobarW), "bad length %d\n", len );
ok( !memcmp( bufW, resW, 10*sizeof(WCHAR) ), "bad buffer contents\n" );
}
/* test string limits & overflow */
do_initA(in, "abcdefghij", 255);
atom = GlobalAddAtomA(in);
ok(atom, "couldn't add atom for %s\n", in);
len = GlobalGetAtomNameA(atom, out, sizeof(out));
ok(len == 255, "length mismatch (%u instead of 255)\n", len);
for (i = 0; i < 255; i++)
{
ok(out[i] == "abcdefghij"[i % 10], "wrong string at %i (%c instead of %c)\n", i, out[i], "abcdefghij"[i % 10]);
}
ok(out[255] == '\0', "wrong end of string\n");
memset(out, '.', sizeof(out));
SetLastError(0xdeadbeef);
len = GlobalGetAtomNameA(atom, out, 10);
ok(!len, "bad length %d\n", len);
ok(GetLastError() == ERROR_MORE_DATA, "wrong error code (%u instead of %u)\n", GetLastError(), ERROR_MORE_DATA);
for (i = 0; i < 9; i++)
{
ok(out[i] == "abcdefghij"[i % 10], "wrong string at %i (%c instead of %c)\n", i, out[i], "abcdefghij"[i % 10]);
}
ok(out[9] == '\0', "wrong end of string\n");
ok(out[10] == '.', "wrote after end of buf\n");
do_initA(in, "abcdefghij", 256);
atom = GlobalAddAtomA(in);
ok(!atom, "succeeded\n");
if (unicode_OS)
{
/* test integral atoms */
for (i = 0; i <= 0xbfff; i++)
{
memset(outW, 'a', sizeof(outW));
len = GlobalGetAtomNameW( (ATOM)i, outW, 10 );
if (i)
{
WCHAR res[20];
ok( (len > 1) && (len < 7), "bad length %d\n", len );
wsprintfW( res, integfmt, i );
memset( res + lstrlenW(res) + 1, 'a', 10 * sizeof(WCHAR));
ok( !memcmp( res, outW, 10 * sizeof(WCHAR) ), "bad buffer contents for %d\n", i );
if (len <= 1 || len >= 7) break; /* don't bother testing all of them */
}
else
ok( !len, "bad length %d\n", len );
memset(outW, '.', sizeof(outW));
SetLastError(0xdeadbeef);
len = GlobalGetAtomNameW( (ATOM)i, outW, 1);
if (i)
{
/* len == 0 with ERROR_MORE_DATA is on NT3.51 */
ok(len == 1 || (len == 0 && GetLastError() == ERROR_MORE_DATA),
"0x%04x: got %u with %d (expected '1' or '0' with "
"ERROR_MORE_DATA)\n", i, len, GetLastError());
ok(outW[1] == DOUBLE('.'), "buffer overwrite\n");
}
else ok(len == 0 && GetLastError() == ERROR_INVALID_PARAMETER, "0 badly handled\n");
}
do_initW(inW, "abcdefghij", 255);
atom = GlobalAddAtomW(inW);
ok(atom, "couldn't add atom for %s\n", in);
len = GlobalGetAtomNameW(atom, outW, sizeof(outW)/sizeof(outW[0]));
ok(len == 255, "length mismatch (%u instead of 255)\n", len);
for (i = 0; i < 255; i++)
{
ok(outW[i] == "abcdefghij"[i % 10], "wrong string at %i (%c instead of %c)\n", i, outW[i], "abcdefghij"[i % 10]);
}
ok(outW[255] == '\0', "wrong end of string\n");
memset(outW, '.', sizeof(outW));
len = GlobalGetAtomNameW(atom, outW, 10);
ok(len == 10, "succeeded\n");
for (i = 0; i < 10; i++)
{
ok(outW[i] == "abcdefghij"[i % 10], "wrong string at %i (%c instead of %c)\n", i, outW[i], "abcdefghij"[i % 10]);
}
ok(outW[10] == DOUBLE('.'), "wrote after end of buf\n");
do_initW(inW, "abcdefghij", 256);
atom = GlobalAddAtomW(inW);
ok(!atom, "succeeded\n");
ok(GetLastError() == ERROR_INVALID_PARAMETER, "wrong error code\n");
}
}
STDAPI OleInitializeEx(LPVOID pMalloc, ULONG ulFlags)
{
OLETRACEIN((API_OleInitialize, PARAMFMT("pMalloc= %p, ulFlags= %x"), pMalloc, ulFlags));
VDATEHEAP();
HRESULT hr;
#if DBG==1
HRESULT hrCoInit = S_OK;
#endif
DWORD cThreadOleInits;
StartPerfCounter(CoInitialize);
hr = CoInitializeEx(pMalloc, ulFlags);
EndPerfCounter(CoInitialize);
if (SUCCEEDED(hr))
{
Assert (g_hmodOLE2);
#if DBG==1
hrCoInit = hr;
#endif
COleTls tls;
cThreadOleInits = ++ tls->cOleInits;
do
{
// We only want to do the below initialization once per apartment
if (cThreadOleInits > 1)
{
// We've already been this way before, just return
Assert(SUCCEEDED(hr) && "Bad OleInitializeEx logic");
break;
}
// single thread registration of DDE and clipboard formats.
// Only do this once per process.
COleStaticLock lck(g_mxsSingleThreadOle);
if (++g_cOleProcessInits != 1)
{
// already done the per-process initialization
break;
}
if (FALSE==DDELibMain (g_hmodOLE2, (WORD)0, (WORD)0, NULL))
{
Assert (!"DDELibMain failed()");
hr = E_OUTOFMEMORY;
break;
}
// Only need to do the initialization once so check the global
// that gets assigned last.
if( !g_aDropTarget )
{
#ifndef _CHICAGO_
// on NT3.51, clipboard formats are pre-registered for us by user32.
// We know they are going to be sequential. This gives us a
// good performance improvement (since the clipboard formats never
// change.
// BUGBUG(alexgo); Chicago needs to get this behaviour too
g_cfObjectLink = RegisterClipboardFormat(OLESTR("ObjectLink"));
g_cfOwnerLink = g_cfObjectLink + 1;
Assert(g_cfOwnerLink == RegisterClipboardFormat(OLESTR("OwnerLink")));
g_cfNative = g_cfObjectLink + 2;
Assert(g_cfNative == RegisterClipboardFormat(OLESTR("Native")));
g_cfBinary = g_cfObjectLink + 3;
Assert(g_cfBinary == RegisterClipboardFormat(OLESTR("Binary")));
g_cfFileName = g_cfObjectLink + 4;
Assert(g_cfFileName == RegisterClipboardFormat(OLESTR("FileName")));
g_cfFileNameW = g_cfObjectLink + 5;
Assert(g_cfFileNameW ==
RegisterClipboardFormat(OLESTR("FileNameW")));
g_cfNetworkName = g_cfObjectLink + 6;
Assert(g_cfNetworkName ==
RegisterClipboardFormat(OLESTR("NetworkName")));
g_cfDataObject = g_cfObjectLink + 7;
Assert(g_cfDataObject ==
RegisterClipboardFormat(OLESTR("DataObject")));
g_cfEmbeddedObject = g_cfObjectLink + 8;
Assert(g_cfEmbeddedObject ==
RegisterClipboardFormat(OLESTR("Embedded Object")));
g_cfEmbedSource = g_cfObjectLink + 9;
Assert(g_cfEmbedSource ==
RegisterClipboardFormat(OLESTR("Embed Source")));
g_cfCustomLinkSource = g_cfObjectLink + 10;
Assert(g_cfCustomLinkSource ==
RegisterClipboardFormat(OLESTR("Custom Link Source")));
g_cfLinkSource = g_cfObjectLink + 11;
Assert(g_cfLinkSource ==
RegisterClipboardFormat(OLESTR("Link Source")));
g_cfObjectDescriptor = g_cfObjectLink + 12;
Assert(g_cfObjectDescriptor ==
RegisterClipboardFormat(OLESTR("Object Descriptor")));
g_cfLinkSrcDescriptor = g_cfObjectLink + 13;
Assert(g_cfLinkSrcDescriptor ==
RegisterClipboardFormat(OLESTR("Link Source Descriptor")));
g_cfOleDraw = g_cfObjectLink + 14;
Assert(g_cfOleDraw == RegisterClipboardFormat(OLESTR("OleDraw")));
g_cfPBrush = g_cfObjectLink + 15;
Assert(g_cfPBrush == RegisterClipboardFormat(OLESTR("PBrush")));
g_cfMSDraw = g_cfObjectLink + 16;
Assert(g_cfMSDraw == RegisterClipboardFormat(OLESTR("MSDraw")));
g_cfOlePrivateData = g_cfObjectLink + 17;
Assert(g_cfOlePrivateData ==
RegisterClipboardFormat(OLESTR("Ole Private Data")));
g_cfScreenPicture = g_cfObjectLink + 18;
Assert(g_cfScreenPicture ==
RegisterClipboardFormat(OLESTR("Screen Picture")));
g_aDropTarget = GlobalAddAtom(OLE_DROP_TARGET_PROP);
AssertSz(g_aDropTarget, "Couldn't add drop target atom\n");
}
// Used in Inplace editing
uOmPostWmCommand = RegisterWindowMessage(OLESTR("OM_POST_WM_COMMAND"));
uOleMessage = RegisterWindowMessage(OLESTR("OLE_MESSAHE"));
#else // !_CHICAGO_
g_cfObjectLink = SSRegisterClipboardFormatA("ObjectLink");
g_cfOwnerLink = SSRegisterClipboardFormatA("OwnerLink");
g_cfNative = SSRegisterClipboardFormatA("Native");
g_cfBinary = SSRegisterClipboardFormatA("Binary");
g_cfFileName = SSRegisterClipboardFormatA("FileName");
g_cfFileNameW = SSRegisterClipboardFormatA("FileNameW");
g_cfNetworkName = SSRegisterClipboardFormatA("NetworkName");
g_cfDataObject = SSRegisterClipboardFormatA("DataObject");
g_cfEmbeddedObject = SSRegisterClipboardFormatA("Embedded Object");
g_cfEmbedSource = SSRegisterClipboardFormatA("Embed Source");
g_cfCustomLinkSource = SSRegisterClipboardFormatA("Custom Link Source");
g_cfLinkSource = SSRegisterClipboardFormatA("Link Source");
g_cfObjectDescriptor = SSRegisterClipboardFormatA("Object Descriptor");
g_cfLinkSrcDescriptor = SSRegisterClipboardFormatA("Link Source Descriptor");
g_cfOleDraw = SSRegisterClipboardFormatA("OleDraw");
g_cfPBrush = SSRegisterClipboardFormatA("PBrush");
g_cfMSDraw = SSRegisterClipboardFormatA("MSDraw");
g_cfOlePrivateData = SSRegisterClipboardFormatA("Ole Private Data");
g_cfScreenPicture = SSRegisterClipboardFormatA("Screen Picture");
g_aDropTarget = GlobalAddAtomA(OLE_DROP_TARGET_PROPA);
AssertSz(g_aDropTarget, "Couldn't add drop target atom\n");
}
// Used in Inplace editing
uOmPostWmCommand = RegisterWindowMessageA("OM_POST_WM_COMMAND");
uOleMessage = RegisterWindowMessageA("OLE_MESSAHE");
#endif // !_CHICAGO_
} while (FALSE); // end of do
if (FAILED(hr))
{
// clean up and break out
DDEWEP (WEP_FREE_DLL);
tls->cOleInits--;
CoUninitialize();
}
else
{
#if defined(_CHICAGO_)
if (!gfShellInitialized && CoGetCurrentProcess() == 1)
{
// The Chicago Shell will dynamically load the OLE32.DLL to improve
// bootup start time. When an application calls CoInitialize, post
// a message to the shell to inform it to load OLE32.DLL if it hasn't
// already. The Shell will never unload OLE32.DLL.
//
// We are using an undocumented Shell interface.
//
// We do this last so that we dont take a task switch while in
// CoInitialize.
#if DBG==1
if (RegQueryValueEx(HKEY_CURRENT_USER,
L"Software\\Microsoft\\OLE2\\NoShellNotify",
NULL, // reserved
NULL, // lpdwType
NULL, // lpbData
NULL) != ERROR_SUCCESS) // lpcbData
#endif
{
HWND hwndShell = GetShellWindow();
if (hwndShell)
{
PostMessage(hwndShell,WM_SHELLNOTIFY,
SHELLNOTIFY_OLELOADED,0L);
}
}
}
gfShellInitialized = TRUE;
#endif // _CHICAGO_
Assert(SUCCEEDED(hr) && "Bad OleInitializeEx logic");
// If we're overriding the allocator, we return whatever
// CoInitializeEx returned
if (NULL != pMalloc)
{
Assert(hr == hrCoInit && "Bad OleInit logic");
}
else if (1 == cThreadOleInits)
{
// First successful call to OleInitializeEx - S_OK
hr = S_OK;
}
else
{
// Second or greater succesful call to OleInitializeEx - S_FALSE
hr = S_FALSE;
}
}
}
static INT_PTR svcHotkeyRegister(WPARAM wParam, LPARAM lParam)
{
HOTKEYDESC *desc = (HOTKEYDESC *)lParam;
if (desc->cbSize != sizeof(HOTKEYDESC))
return 0;
THotkeyItem *item = (THotkeyItem*)mir_alloc(sizeof(THotkeyItem));
DWORD dwFlags = (desc->cbSize >= sizeof(HOTKEYDESC)) ? desc->dwFlags : 0;
if (dwFlags & HKD_UNICODE) {
item->ptszSection = mir_tstrdup(desc->ptszSection);
item->ptszDescription = mir_tstrdup(desc->ptszDescription);
}
else {
item->ptszSection = mir_a2u(desc->pszSection);
item->ptszDescription = mir_a2u(desc->pszDescription);
}
item->hLangpack = (int)wParam;
item->allowSubHotkeys = TRUE;
item->rootHotkey = NULL;
item->nSubHotkeys = 0;
if (item->rootHotkey = hotkeys.find(item)) {
if (item->rootHotkey->allowSubHotkeys) {
char nameBuf[MAXMODULELABELLENGTH];
mir_snprintf(nameBuf, _countof(nameBuf), "%s$%d", item->rootHotkey->pszName, item->rootHotkey->nSubHotkeys);
item->pszName = mir_strdup(nameBuf);
item->Enabled = TRUE;
item->rootHotkey->nSubHotkeys++;
}
else {
mir_free(item->ptszSection);
mir_free(item->ptszDescription);
mir_free(item);
return 0;
}
}
else {
item->pszName = mir_strdup(desc->pszName);
item->Enabled = !db_get_b(NULL, DBMODULENAME "Off", item->pszName, 0);
}
item->pszService = desc->pszService ? mir_strdup(desc->pszService) : 0;
item->DefHotkey = desc->DefHotKey & ~HKF_MIRANDA_LOCAL;
item->Hotkey = db_get_w(NULL, DBMODULENAME, item->pszName, item->DefHotkey);
item->type = item->pszService ?
(THotkeyType)db_get_b(NULL, DBMODULENAME "Types", item->pszName,
(desc->DefHotKey & HKF_MIRANDA_LOCAL) ? HKT_LOCAL : HKT_GLOBAL) : HKT_MANUAL;
item->lParam = desc->lParam;
char buf[256];
mir_snprintf(buf, "mir_hotkey_%d_%d", g_pid, g_hkid++);
item->idHotkey = GlobalAddAtomA(buf);
if (item->type == HKT_GLOBAL) {
if (item->Enabled) {
BYTE mod, vk;
sttWordToModAndVk(item->Hotkey, &mod, &vk);
if (vk) RegisterHotKey(g_hwndHotkeyHost, item->idHotkey, mod, vk);
}
}
hotkeys.insert(item);
if (!item->rootHotkey) {
/* try to load alternatives from db */
int count, i;
mir_snprintf(buf, "%s$count", item->pszName);
count = (int)db_get_dw(NULL, DBMODULENAME, buf, -1);
for (i = 0; i < count; i++) {
mir_snprintf(buf, "%s$%d", item->pszName, i);
if (!db_get_w(NULL, DBMODULENAME, buf, 0))
continue;
svcHotkeyRegister(wParam, lParam);
}
item->allowSubHotkeys = count < 0;
}
else {
mir_free(item->pszName);
item->pszName = NULL;
}
return item->idHotkey;
}
extern "C" __declspec(dllexport) BOOL Main_RegisterHotkeys(HWND hwnd)
{
nPad1 = GlobalAddAtomA("nPad1Hotkey");
nPad2 = GlobalAddAtomA("nPad2Hotkey");
nPad3 = GlobalAddAtomA("nPad3Hotkey");
nPad4 = GlobalAddAtomA("nPad4Hotkey");
nPad5 = GlobalAddAtomA("nPad5Hotkey");
nPad6 = GlobalAddAtomA("nPad6Hotkey");
nPad7 = GlobalAddAtomA("nPad7Hotkey");
nPad8 = GlobalAddAtomA("nPad8Hotkey");
nPad9 = GlobalAddAtomA("nPad9Hotkey");
nPad0 = GlobalAddAtomA("nPad0Hotkey");
nPadDot = GlobalAddAtomA("nPadDotHotkey");
nPadPlus = GlobalAddAtomA("nPadPlusHotkey");
nPadMinus = GlobalAddAtomA("nPadMinusHotkey");
nPadMultiply = GlobalAddAtomA("nPadMultiplyHotkey");
nPadDivide = GlobalAddAtomA("nPadDivideHotkey");
nPadEnter = GlobalAddAtomA("nPadEnter");
nPadEnterAlt = GlobalAddAtomA("nPadEnterAlt");
if(!(
RegisterHotKey(hwnd, nPad1, MOD_CONTROL, VK_NUMPAD1))||!(
RegisterHotKey(hwnd, nPad2, MOD_CONTROL, VK_NUMPAD2))||!(
RegisterHotKey(hwnd, nPad3, MOD_CONTROL, VK_NUMPAD3))||!(
RegisterHotKey(hwnd, nPad4, MOD_CONTROL, VK_NUMPAD4))||!(
RegisterHotKey(hwnd, nPad5, MOD_CONTROL, VK_NUMPAD5))||!(
RegisterHotKey(hwnd, nPad6, MOD_CONTROL, VK_NUMPAD6))||!(
RegisterHotKey(hwnd, nPad7, MOD_CONTROL, VK_NUMPAD7))||!(
RegisterHotKey(hwnd, nPad8, MOD_CONTROL, VK_NUMPAD8))||!(
RegisterHotKey(hwnd, nPad9, MOD_CONTROL, VK_NUMPAD9))||!(
RegisterHotKey(hwnd, nPad0, MOD_CONTROL, VK_NUMPAD0))||!(
RegisterHotKey(hwnd, nPadDot, MOD_CONTROL, VK_DECIMAL))||!(
RegisterHotKey(hwnd, nPadPlus, MOD_CONTROL, VK_ADD))||!(
RegisterHotKey(hwnd, nPadMinus, MOD_CONTROL, VK_SUBTRACT))||!(
RegisterHotKey(hwnd, nPadMultiply, MOD_CONTROL, VK_MULTIPLY))||!(
RegisterHotKey(hwnd, nPadDivide, MOD_CONTROL, VK_DIVIDE))||!(
RegisterHotKey(hwnd, nPadEnter, MOD_CONTROL, VK_RETURN))||!(
RegisterHotKey(hwnd, nPadEnterAlt, MOD_CONTROL | MOD_ALT, VK_RETURN)))
{
int error = GetLastError();
error;
return FALSE;
}
return TRUE;
}
