//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; }