static LRESULT CALLBACK PxTabProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { PxTabObject* self = (PxTabObject*)GetWindowLongPtrW(hwnd, GWLP_USERDATA); switch (msg) { case OCM_NOTIFY: { switch (((LPNMHDR)lParam)->code) { case TCN_SELCHANGING: return FALSE; case TCN_SELCHANGE: { int iIndex = TabCtrl_GetCurSel(self->hWin); PxTabPage_GotSelected(PyList_GetItem(self->pyPages, iIndex)); break; } } } } return CallWindowProcW(self->fnOldWinProcedure, hwnd, msg, wParam, lParam); }
static void draw_joystick_buttons(HWND hwnd, struct JoystickData* data) { int i; int row = 0, col = 0; WCHAR button_label[3]; HINSTANCE hinst = (HINSTANCE) GetWindowLongPtrW(hwnd, GWLP_HINSTANCE); static WCHAR button_class[] = {'B','u','t','t','o','n','\0'}; for (i = 0; i < TEST_MAX_BUTTONS; i++) { RECT r; if ((i % TEST_BUTTON_COL_MAX) == 0 && i != 0) { row += 1; col = 0; } r.left = (TEST_BUTTON_X + TEST_NEXT_BUTTON_X*col); r.top = (TEST_BUTTON_Y + TEST_NEXT_BUTTON_Y*row); r.right = r.left + TEST_BUTTON_SIZE_X; r.bottom = r.top + TEST_BUTTON_SIZE_Y; MapDialogRect(hwnd, &r); button_number_to_wchar(i + 1, button_label); data->graphics.buttons[i] = CreateWindowW(button_class, button_label, WS_CHILD, r.left, r.top, r.right - r.left, r.bottom - r.top, hwnd, NULL, NULL, hinst); col += 1; } }
static void draw_joystick_axes(HWND hwnd, struct JoystickData* data) { int i; HINSTANCE hinst = (HINSTANCE) GetWindowLongPtrW(hwnd, GWLP_HINSTANCE); static const WCHAR button_class[] = {'B','u','t','t','o','n','\0'}; static const WCHAR axes_names[TEST_MAX_AXES][7] = { {'X',',','Y','\0'}, {'R','x',',','R','y','\0'}, {'Z',',','R','z','\0'}, {'P','O','V','\0'} }; static const DWORD axes_idc[TEST_MAX_AXES] = { IDC_TESTGROUPXY, IDC_TESTGROUPRXRY, IDC_TESTGROUPZRZ, IDC_TESTGROUPPOV }; for (i = 0; i < TEST_MAX_AXES; i++) { RECT r; /* Set axis box name */ SetWindowTextW(GetDlgItem(hwnd, axes_idc[i]), axes_names[i]); r.left = (TEST_AXIS_X + TEST_NEXT_AXIS_X*i); r.top = TEST_AXIS_Y; r.right = r.left + TEST_AXIS_SIZE_X; r.bottom = r.top + TEST_AXIS_SIZE_Y; MapDialogRect(hwnd, &r); data->graphics.axes[i] = CreateWindowW( button_class, NULL, WS_CHILD | WS_VISIBLE, r.left, r.top, r.right - r.left, r.bottom - r.top, hwnd, NULL, NULL, hinst); } }
/** * clutter_win32_get_stage_from_window: * @hwnd: a window handle * * Gets the stage for a particular window. * * Return value: The stage or NULL if a stage does not exist for the * window. * * Since: 0.8 */ ClutterStage * clutter_win32_get_stage_from_window (HWND hwnd) { /* Check whether the window handle is an instance of the stage window class */ if ((ATOM) GetClassLongPtrW (hwnd, GCW_ATOM) == clutter_stage_win32_get_window_class ()) /* If it is there should be a pointer to the stage in the window extra data */ return CLUTTER_STAGE_WIN32 (GetWindowLongPtrW (hwnd, 0))->wrapper; else { /* Otherwise it might be a foreign window so we should check the stage list */ ClutterStageManager *stage_manager; const GSList *stages, *l; stage_manager = clutter_stage_manager_get_default (); stages = clutter_stage_manager_peek_stages (stage_manager); for (l = stages; l != NULL; l = l->next) { ClutterStage *stage = l->data; ClutterStageWindow *impl; impl = _clutter_stage_get_window (stage); g_assert (CLUTTER_IS_STAGE_WIN32 (impl)); if (CLUTTER_STAGE_WIN32 (impl)->hwnd == hwnd) return stage; } } return NULL; }
static LRESULT APIENTRY ACLBoxSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { IAutoCompleteImpl *This = (IAutoCompleteImpl *)GetWindowLongPtrW(hwnd, GWLP_USERDATA); WCHAR *msg; int sel, len; switch (uMsg) { case WM_MOUSEMOVE: sel = SendMessageW(hwnd, LB_ITEMFROMPOINT, 0, lParam); SendMessageW(hwnd, LB_SETCURSEL, (WPARAM)sel, (LPARAM)0); break; case WM_LBUTTONDOWN: sel = SendMessageW(hwnd, LB_GETCURSEL, 0, 0); if (sel < 0) break; len = SendMessageW(This->hwndListBox, LB_GETTEXTLEN, sel, 0); msg = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (len+1)*sizeof(WCHAR)); SendMessageW(hwnd, LB_GETTEXT, sel, (LPARAM)msg); SendMessageW(This->hwndEdit, WM_SETTEXT, 0, (LPARAM)msg); SendMessageW(This->hwndEdit, EM_SETSEL, 0, lstrlenW(msg)); ShowWindow(hwnd, SW_HIDE); HeapFree(GetProcessHeap(), 0, msg); break; default: return CallWindowProcW(This->wpOrigLBoxProc, hwnd, uMsg, wParam, lParam); } return 0; }
static void OB_Paint( HWND hwnd, HDC hDC, UINT action ) { LONG state = get_button_state( hwnd ); DRAWITEMSTRUCT dis; LONG_PTR id = GetWindowLongPtrW( hwnd, GWLP_ID ); HWND parent; HFONT hFont, hPrevFont = 0; HRGN hrgn; dis.CtlType = ODT_BUTTON; dis.CtlID = id; dis.itemID = 0; dis.itemAction = action; dis.itemState = ((state & BST_FOCUS) ? ODS_FOCUS : 0) | ((state & BST_PUSHED) ? ODS_SELECTED : 0) | (IsWindowEnabled(hwnd) ? 0: ODS_DISABLED); dis.hwndItem = hwnd; dis.hDC = hDC; dis.itemData = 0; GetClientRect( hwnd, &dis.rcItem ); if ((hFont = get_button_font( hwnd ))) hPrevFont = SelectObject( hDC, hFont ); parent = GetParent(hwnd); if (!parent) parent = hwnd; SendMessageW( parent, WM_CTLCOLORBTN, (WPARAM)hDC, (LPARAM)hwnd ); hrgn = set_control_clipping( hDC, &dis.rcItem ); SendMessageW( GetParent(hwnd), WM_DRAWITEM, id, (LPARAM)&dis ); if (hPrevFont) SelectObject(hDC, hPrevFont); SelectClipRgn( hDC, hrgn ); if (hrgn) DeleteObject( hrgn ); }
LRESULT DefWndNCLButtonDblClk(HWND hWnd, WPARAM wParam, LPARAM lParam) { ULONG Style; Style = GetWindowLongPtrW(hWnd, GWL_STYLE); switch(wParam) { case HTCAPTION: { /* Maximize/Restore the window */ if((Style & WS_CAPTION) == WS_CAPTION && (Style & WS_MAXIMIZEBOX)) { SendMessageW(hWnd, WM_SYSCOMMAND, ((Style & (WS_MINIMIZE | WS_MAXIMIZE)) ? SC_RESTORE : SC_MAXIMIZE), 0); } break; } case HTSYSMENU: { SendMessageW(hWnd, WM_SYSCOMMAND, SC_CLOSE, 0); break; } default: return DefWndNCLButtonDown(hWnd, wParam, lParam); } return(0); }
LRESULT DefWndNCLButtonDblClk(HWND hWnd, WPARAM wParam, LPARAM lParam) { ULONG Style; Style = GetWindowLongPtrW(hWnd, GWL_STYLE); switch(wParam) { case HTCAPTION: { /* Maximize/Restore the window */ if((Style & WS_CAPTION) == WS_CAPTION && (Style & WS_MAXIMIZEBOX)) { SendMessageW(hWnd, WM_SYSCOMMAND, ((Style & (WS_MINIMIZE | WS_MAXIMIZE)) ? SC_RESTORE : SC_MAXIMIZE), 0); } break; } case HTSYSMENU: { HMENU hSysMenu = GetSystemMenu(hWnd, FALSE); UINT state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND); /* If the close item of the sysmenu is disabled or not present do nothing */ if ((state & (MF_DISABLED | MF_GRAYED)) || (state == 0xFFFFFFFF)) break; SendMessageW(hWnd, WM_SYSCOMMAND, SC_CLOSE, lParam); break; } default: return DefWndNCLButtonDown(hWnd, wParam, lParam); } return(0); }
static LRESULT Help_OnSize(HWND hWnd) { HHInfo *pHHInfo = (HHInfo *)GetWindowLongPtrW(hWnd, GWLP_USERDATA); DWORD dwSize; RECT rc; if (!pHHInfo) return 0; NP_GetNavigationRect(pHHInfo, &rc); SetWindowPos(pHHInfo->WinType.hwndNavigation, HWND_TOP, 0, 0, rc.right, rc.bottom, SWP_NOMOVE); SB_GetSizeBarRect(pHHInfo, &rc); SetWindowPos(pHHInfo->hwndSizeBar, HWND_TOP, rc.left, rc.top, rc.right, rc.bottom, SWP_SHOWWINDOW); HP_GetHTMLRect(pHHInfo, &rc); SetWindowPos(pHHInfo->WinType.hwndHTML, HWND_TOP, rc.left, rc.top, rc.right, rc.bottom, SWP_SHOWWINDOW); /* Resize browser window taking the frame size into account */ dwSize = GetSystemMetrics(SM_CXFRAME); ResizeWebBrowser(pHHInfo, rc.right - dwSize, rc.bottom - dwSize); return 0; }
/******************************************************************* * WINPOS_ActivateOtherWindow * * Activates window other than pWnd. */ void WINAPI WinPosActivateOtherWindow(HWND hwnd) { HWND hwndTo, fg; if ((GetWindowLongPtrW( hwnd, GWL_STYLE ) & WS_POPUP) && (hwndTo = GetWindow( hwnd, GW_OWNER ))) { hwndTo = GetAncestor( hwndTo, GA_ROOT ); if (can_activate_window( hwndTo )) goto done; } hwndTo = hwnd; for (;;) { if (!(hwndTo = GetWindow( hwndTo, GW_HWNDNEXT ))) break; if (can_activate_window( hwndTo )) break; } done: fg = GetForegroundWindow(); TRACE("win = %p fg = %p\n", hwndTo, fg); if (!fg || (hwnd == fg)) { if (SetForegroundWindow( hwndTo )) return; } if (!SetActiveWindow( hwndTo )) SetActiveWindow(0); }
static INT_PTR CALLBACK dlgProc(HWND i_hwnd, UINT i_message, WPARAM i_wParam, LPARAM i_lParam) { DialogPassphrase *This = reinterpret_cast<DialogPassphrase *>( GetWindowLongPtrW(i_hwnd, GWLP_USERDATA)); if (!This) switch (i_message) { case WM_INITDIALOG: This = reinterpret_cast<DialogPassphrase *>(i_lParam); SetWindowLongPtrW(i_hwnd, GWLP_USERDATA, i_lParam); This->initialize(i_hwnd); return This->wmInitDialog(reinterpret_cast<HWND>(i_wParam)); } else switch (i_message) { case WM_CLOSE: return This->wmClose(); case WM_COMMAND: return This->wmCommand(HIWORD(i_wParam), LOWORD(i_wParam), reinterpret_cast<HWND>(i_lParam)); } return FALSE; }
void wined3d_unregister_window(HWND window) { unsigned int i; wined3d_mutex_lock(); for (i = 0; i < wndproc_table.count; ++i) { if (wndproc_table.entries[i].window == window) { struct wined3d_wndproc *entry = &wndproc_table.entries[i]; struct wined3d_wndproc *last = &wndproc_table.entries[--wndproc_table.count]; if (entry->unicode) { if (GetWindowLongPtrW(window, GWLP_WNDPROC) == (LONG_PTR)wined3d_wndproc) SetWindowLongPtrW(window, GWLP_WNDPROC, (LONG_PTR)entry->proc); } else { if (GetWindowLongPtrA(window, GWLP_WNDPROC) == (LONG_PTR)wined3d_wndproc) SetWindowLongPtrA(window, GWLP_WNDPROC, (LONG_PTR)entry->proc); } if (entry != last) *entry = *last; wined3d_mutex_unlock(); return; } } wined3d_mutex_unlock(); ERR("Window %p is not registered with wined3d.\n", window); }
static LRESULT CALLBACK explorer_wnd_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { explorer_info *info = (explorer_info*)GetWindowLongPtrW(hwnd,EXPLORER_INFO_INDEX); IExplorerBrowser *browser = NULL; if(info) browser = info->browser; switch(uMsg) { case WM_DESTROY: IExplorerBrowser_Release(browser); HeapFree(GetProcessHeap(),0,info); PostQuitMessage(0); break; case WM_QUIT: do_exit(wParam); case WM_SIZE: update_window_size(info,HIWORD(lParam),LOWORD(lParam)); break; default: return DefWindowProcW(hwnd,uMsg,wParam,lParam); } return 0; }
BOOL BotCfg_OnCommand( HWND hDlg, WPARAM wParam, LPARAM lParam ) { UNREFERENCED_PARAMETER(lParam); BotCfgDlgSt *st = (BotCfgDlgSt *)GetWindowLongPtrW( hDlg, GWLP_USERDATA ); int ctrlID = LOWORD(wParam); switch( ctrlID ) { case IDCANCEL: EndDialog( hDlg, IDCANCEL ); break; case IDOK: BotCfg_OnOK( hDlg, st ); break; case IDC_APPLY: BotCfg_OnApply( hDlg, st ); break; case IDC_LOAD: BotCfg_OnLoad( hDlg, st ); break; case IDC_SAVE: BotCfg_OnSave( hDlg, st ); break; default: return FALSE; break; // call default handler } return TRUE; }
static void draw_joystick_buttons(HWND hwnd, struct JoystickData* data) { int i; int row = 0, col = 0; WCHAR button_label[3]; HINSTANCE hinst = (HINSTANCE) GetWindowLongPtrW(hwnd, GWLP_HINSTANCE); static WCHAR button_class[] = {'B','u','t','t','o','n','\0'}; for (i = 0; i < TEST_MAX_BUTTONS; i++) { if ((i % TEST_BUTTON_COL_MAX) == 0 && i != 0) { row += 1; col = 0; } button_number_to_wchar(i + 1, button_label); data->buttons[i] = CreateWindowW(button_class, button_label, WS_CHILD, TEST_BUTTON_X + TEST_NEXT_BUTTON_X*col, TEST_BUTTON_Y + TEST_NEXT_BUTTON_Y*row, TEST_BUTTON_SIZE_X, TEST_BUTTON_SIZE_Y, hwnd, NULL, NULL, hinst); col += 1; } }
/*********************************************************************** * SYSLINK_SendParentNotify * Sends a WM_NOTIFY message to the parent window. */ static LRESULT SYSLINK_SendParentNotify (const SYSLINK_INFO *infoPtr, UINT code, const DOC_ITEM *Link, int iLink) { NMLINK nml; nml.hdr.hwndFrom = infoPtr->Self; nml.hdr.idFrom = GetWindowLongPtrW(infoPtr->Self, GWLP_ID); nml.hdr.code = code; nml.item.mask = 0; nml.item.iLink = iLink; nml.item.state = 0; nml.item.stateMask = 0; if(Link->u.Link.szID) { lstrcpyW(nml.item.szID, Link->u.Link.szID); } else { nml.item.szID[0] = 0; } if(Link->u.Link.szUrl) { lstrcpyW(nml.item.szUrl, Link->u.Link.szUrl); } else { nml.item.szUrl[0] = 0; } return SendMessageW(infoPtr->Notify, WM_NOTIFY, nml.hdr.idFrom, (LPARAM)&nml); }
/************************************************************************* * ShellAboutW [SHELL32.289] */ BOOL WINAPI ShellAboutW( HWND hWnd, LPCWSTR szApp, LPCWSTR szOtherStuff, HICON hIcon ) { ABOUT_INFO info; HRSRC hRes; DLGTEMPLATE *DlgTemplate; BOOL bRet; TRACE("\n"); // DialogBoxIndirectParamW will be called with the hInstance of the calling application, so we have to preload the dialog template hRes = FindResourceW(shell32_hInstance, MAKEINTRESOURCEW(IDD_ABOUT), (LPWSTR)RT_DIALOG); if(!hRes) return FALSE; DlgTemplate = (DLGTEMPLATE *)LoadResource(shell32_hInstance, hRes); if(!DlgTemplate) return FALSE; info.szApp = szApp; info.szOtherStuff = szOtherStuff; info.hIcon = hIcon ? hIcon : LoadIconW( 0, (LPWSTR)IDI_WINLOGO ); bRet = DialogBoxIndirectParamW((HINSTANCE)GetWindowLongPtrW( hWnd, GWLP_HINSTANCE ), DlgTemplate, hWnd, AboutDlgProc, (LPARAM)&info ); return bRet; }
static INT_PTR CALLBACK endtask_dlg_proc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam ) { struct endtask_dlg_data *data; HANDLE handle; switch (msg) { case WM_INITDIALOG: SetWindowLongPtrW( hwnd, DWLP_USER, lparam ); ShowWindow( hwnd, SW_SHOWNORMAL ); return TRUE; case WM_COMMAND: data = (struct endtask_dlg_data *)GetWindowLongPtrW( hwnd, DWLP_USER ); switch (wparam) { case MAKEWPARAM(IDOK, BN_CLICKED): handle = OpenProcess( PROCESS_TERMINATE, FALSE, data->win[0].pid ); if (handle) { WINE_TRACE( "terminating process %04x\n", data->win[0].pid ); TerminateProcess( handle, 0 ); CloseHandle( handle ); data->terminated = TRUE; } return TRUE; case MAKEWPARAM(IDCANCEL, BN_CLICKED): data->cancelled = TRUE; return TRUE; } break; } return FALSE; }
/*********************************************************************** * UPDOWN_DoAction * * This function increments/decrements the CurVal by the * 'delta' amount according to the 'action' flag which can be a * combination of FLAG_INCR and FLAG_DECR * It notifies the parent as required. * It handles wrapping and non-wrapping correctly. * It is assumed that delta>0 */ static void UPDOWN_DoAction (UPDOWN_INFO *infoPtr, int delta, int action) { NM_UPDOWN ni; TRACE("%d by %d\n", action, delta); /* check if we can do the modification first */ delta *= (action & FLAG_INCR ? 1 : -1) * (infoPtr->MaxVal < infoPtr->MinVal ? -1 : 1); if ( (action & FLAG_INCR) && (action & FLAG_DECR) ) delta = 0; TRACE("current %d, delta: %d\n", infoPtr->CurVal, delta); /* We must notify parent now to obtain permission */ ni.iPos = infoPtr->CurVal; ni.iDelta = delta; ni.hdr.hwndFrom = infoPtr->Self; ni.hdr.idFrom = GetWindowLongPtrW (infoPtr->Self, GWLP_ID); ni.hdr.code = UDN_DELTAPOS; if (!SendMessageW(infoPtr->Notify, WM_NOTIFY, ni.hdr.idFrom, (LPARAM)&ni)) { /* Parent said: OK to adjust */ /* Now adjust value with (maybe new) delta */ if (UPDOWN_OffsetVal (infoPtr, ni.iDelta)) { TRACE("new %d, delta: %d\n", infoPtr->CurVal, ni.iDelta); /* Now take care about our buddy */ UPDOWN_SetBuddyInt (infoPtr); } } /* Also, notify it. This message is sent in any case. */ SendMessageW( infoPtr->Notify, (infoPtr->dwStyle & UDS_HORZ) ? WM_HSCROLL : WM_VSCROLL, MAKELONG(SB_THUMBPOSITION, infoPtr->CurVal), (LPARAM)infoPtr->Self); }
//Every Windows Message will hit this function. LRESULT CALLBACK GlobalWndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) { //Hold our target window instance SystemWindow *targetWindow = NULL; //If it's the WM_NCCREATE message (which should be the first message we get...) if(msg == WM_NCCREATE) { //Pull the target window out of the lpCreateParams which is the this pointer we pass into CreateWindowEx targetWindow = reinterpret_cast<SystemWindow*>((LONG)((LPCREATESTRUCT)lparam)->lpCreateParams); //Set the pointer to this instance in the GWLP_USERDATA so we can pull it out reliably in the future SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR)targetWindow); } else { //Pull the window instance out of the GWLP_USERDATA targetWindow = reinterpret_cast<SystemWindow*>(GetWindowLongPtrW(hwnd, GWLP_USERDATA)); } //If we still don't have a window we can't respond to any events so kick it to the default. if(targetWindow == NULL) { return DefWindowProc(hwnd, msg, wparam, lparam); } //Otherwise we're all good and we can pipe it to the instances version of the WndProc return targetWindow->LocalWndProc(hwnd, msg, wparam, lparam); }
/********************************************************************* * security_dlgproc [internal] * */ INT_PTR CALLBACK security_dlgproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) { secdlg_data *sd; if (msg == WM_INITDIALOG) { return security_on_initdialog(hwnd); } sd = (secdlg_data *)GetWindowLongPtrW(hwnd, DWLP_USER); if (sd) { switch (msg) { case WM_NOTIFY: return security_on_notify(sd, wparam, lparam); case WM_NCDESTROY: return security_on_destroy(sd); default: /* do not flood the log */ if ((msg == WM_SETCURSOR) || (msg == WM_NCHITTEST) || (msg == WM_MOUSEMOVE) || (msg == WM_MOUSEACTIVATE) || (msg == WM_PARENTNOTIFY)) return FALSE; TRACE("(%p, 0x%08x/%03d, 0x%08lx, 0x%08lx)\n", hwnd, msg, msg, wparam, lparam); } } return FALSE; }
// Function mostly compatible with the normal EnumChildWindows, // except it lists in Z-Order and it doesn't ensure consistency // if a window is removed while enumerating void EnumWindowsZOrder(WNDENUMPROC callback, LPARAM lParam) { HWND hwnd, hwndOwner; WCHAR szClass[64]; DWORD ExStyle; for (hwnd = GetTopWindow(NULL); hwnd; hwnd = GetWindow(hwnd, GW_HWNDNEXT)) { if (!IsWindowVisible(hwnd)) continue; // check special windows if (!GetClassNameW(hwnd, szClass, _countof(szClass)) || wcscmp(szClass, L"Shell_TrayWnd") == 0 || wcscmp(szClass, L"Progman") == 0) { continue; } ExStyle = GetWindowLongPtrW(hwnd, GWL_EXSTYLE); if (ExStyle & WS_EX_TOOLWINDOW) continue; hwndOwner = GetWindow(hwnd, GW_OWNER); if ((ExStyle & WS_EX_APPWINDOW) || !IsWindowVisible(hwndOwner)) { if (!callback(hwnd, lParam)) break; continue; } } }
static LRESULT CALLBACK WinPrevProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { PWINPREV_DATA pData; pData = (PWINPREV_DATA)GetWindowLongPtrW(hWnd, GWLP_USERDATA); switch (msg) { case WM_CREATE: { pData = (PWINPREV_DATA)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pData)); if (!pData) { /* We failed to allocate our private data, halt the window creation */ return (LRESULT)-1; } pData->hWnd = hWnd; pData->pData = ConInfo; GetClientRect(pData->hWnd, &pData->rcMaxArea); // LPCREATESTRUCT::cx and cy give window (not client) size WinPrev_OnDisplayChange(pData); SetWindowLongPtrW(hWnd, GWLP_USERDATA, (LONG_PTR)pData); break; } case WM_DESTROY: { if (pData) HeapFree(GetProcessHeap(), 0, pData); break; } case WM_DISPLAYCHANGE: { WinPrev_OnDisplayChange(pData); UpdateWindow(hWnd); // InvalidateRect(hWnd, NULL, FALSE); break; } case WM_SIZE: break; case WM_ERASEBKGND: return 1; case WM_PAINT: { PAINTSTRUCT ps; BeginPaint(hWnd, &ps); WinPrev_OnDraw(ps.hdc, pData); EndPaint(hWnd, &ps); return 0; } } return DefWindowProcW(hWnd, msg, wParam, lParam); }
LRESULT CALLBACK Synchronizer::s_wndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) // Win32-only { Synchronizer * pThis; int swlresult; switch (msg) { case WM_NCCREATE: pThis = (Synchronizer *)((LPCREATESTRUCT(lParam))->lpCreateParams); UT_return_val_if_fail(pThis, 0); pThis->m_hWnd = hWnd; SetLastError(0); swlresult=SetWindowLongPtrW(hWnd,GWLP_USERDATA,LONG_PTR(pThis)); if (swlresult==0) { // we might have an error int errorcode=GetLastError(); if (errorcode) { UT_DEBUGMSG(("Error in setting the WindowLong GWLP_USERDATA: %d\n", errorcode)); } } return 1; case WM_ABI_SYNCHRONIZER: UT_DEBUGMSG(("Received a message in Synchronizer message loop! 0x%x\n", msg)); pThis = (Synchronizer *)GetWindowLongPtrW(hWnd,GWLP_USERDATA); UT_return_val_if_fail(pThis, 0); if (pThis->m_bIsProcessing) { pThis->m_iDeferredMessages++; } else { pThis->m_bIsProcessing = true; bool bIsDestroyed = false; pThis->m_bIsDestroyed = &bIsDestroyed; pThis->callMainloop(); while (!bIsDestroyed && pThis->m_iDeferredMessages) { pThis->callMainloop(); --pThis->m_iDeferredMessages; } if (!bIsDestroyed) { pThis->m_bIsProcessing = false; pThis->m_bIsDestroyed = NULL; } } return true; default: UT_DEBUGMSG(("return DefWindowProc for message 0x%x\n", msg)); // We do not want to handle this message so pass back to Windows // to handle it in a default way return 0; } }
static LRESULT CALLBACK PopupChild_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { switch (message) { case WM_NOTIFY: { NMHDR *nmhdr = (NMHDR*)lParam; switch(nmhdr->code) { case NM_DBLCLK: { HHInfo *info = (HHInfo*)GetWindowLongPtrW(hWnd, GWLP_USERDATA); IndexSubItem *iter; if(info == 0 || lParam == 0) return 0; iter = (IndexSubItem*) ((NMITEMACTIVATE *)lParam)->lParam; if(iter == 0) return 0; NavigateToChm(info, info->index->merge.chm_file, iter->local); ShowWindow(info->popup.hwndPopup, SW_HIDE); return 0; } case NM_RETURN: { HHInfo *info = (HHInfo*)GetWindowLongPtrW(hWnd, GWLP_USERDATA); IndexSubItem *iter; LVITEMW lvItem; if(info == 0) return 0; lvItem.iItem = (int) SendMessageW(info->popup.hwndList, LVM_GETSELECTIONMARK, 0, 0); lvItem.mask = TVIF_PARAM; SendMessageW(info->popup.hwndList, LVM_GETITEMW, 0, (LPARAM)&lvItem); iter = (IndexSubItem*) lvItem.lParam; NavigateToChm(info, info->index->merge.chm_file, iter->local); ShowWindow(info->popup.hwndPopup, SW_HIDE); return 0; } } break; } default: return DefWindowProcW(hWnd, message, wParam, lParam); } return 0; }
static LRESULT CALLBACK CFont_WndProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { switch(msg) { HANDLE_MSG (hwnd, WM_KILLFOCUS, CFont_OnKillFocus); default: return CallWindowProcW((WNDPROC)GetWindowLongPtrW(hwnd, GWLP_USERDATA), hwnd, msg, wParam, lParam); } }
VOID UserDrawCaptionButtonWnd(HWND hWnd, HDC hDC, BOOL bDown, ULONG Type) { RECT WindowRect; SIZE WindowBorder; DWORD Style, ExStyle; GetWindowRect(hWnd, &WindowRect); WindowRect.right -= WindowRect.left; WindowRect.bottom -= WindowRect.top; WindowRect.left = WindowRect.top = 0; Style = GetWindowLongPtrW(hWnd, GWL_STYLE); ExStyle = GetWindowLongPtrW(hWnd, GWL_EXSTYLE); UserGetWindowBorders(Style, ExStyle, &WindowBorder, FALSE); InflateRect(&WindowRect, -WindowBorder.cx, -WindowBorder.cy); UserDrawCaptionButton(hWnd, &WindowRect, Style, ExStyle, hDC, bDown, Type); }
/* Dialogue procedure for general message boxes */ static INT_PTR CALLBACK SHDlgProcEx(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) { DLGDATAEX *d = (DLGDATAEX *)GetWindowLongPtrW(hDlg, DWLP_USER); TRACE("(%p,%u,%ld,%ld) data %p\n", hDlg, uMsg, wParam, lParam, d); switch (uMsg) { case WM_INITDIALOG: { /* FIXME: Not sure where native stores its lParam */ SetWindowLongPtrW(hDlg, DWLP_USER, lParam); d = (DLGDATAEX *)lParam; TRACE("WM_INITDIALOG: %p, %s,%p,%p\n", hDlg, debugstr_w(d->lpszId), d->dlgProc, (void*)d->lParam); if (d->dlgProc) return d->dlgProc(hDlg, uMsg, wParam, d->lParam); return TRUE; } case WM_COMMAND: switch (LOWORD(wParam)) { case IDYES: wParam = MAKELONG(IDOK, HIWORD(wParam)); /* Fall through ... */ case IDNO: if (LOWORD(wParam) == IDNO) wParam = MAKELONG(IDCANCEL, HIWORD(wParam)); /* Fall through ... */ case IDOK: case IDCANCEL: TRACE("WM_COMMAND: id=%s data=%p\n", LOWORD(wParam) == IDOK ? "IDOK" : "IDCANCEL", d); if (SendMessageW(GetDlgItem(hDlg, IDC_ERR_DONT_SHOW), BM_GETCHECK, 0L, 0L)) { DWORD dwZero = 0; /* The user clicked 'don't show again', so set the key */ SHRegSetUSValueW(szDontShowKey, d->lpszId, REG_DWORD, &dwZero, sizeof(dwZero), SHREGSET_DEFAULT); } if (!d->dlgProc || !d->dlgProc(hDlg, uMsg, wParam, lParam)) EndDialog(hDlg, wParam); return TRUE; } break; default: break; } if (d && d->dlgProc) return d->dlgProc(hDlg, uMsg, wParam, lParam); return FALSE; }
static INT_PTR CALLBACK fontDialogDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { struct fontDialog *f; f = (struct fontDialog *) GetWindowLongPtrW(hwnd, DWLP_USER); if (f == NULL) { if (uMsg == WM_INITDIALOG) { f = beginFontDialog(hwnd, lParam); SetWindowLongPtrW(hwnd, DWLP_USER, (LONG_PTR) f); return TRUE; } return FALSE; } switch (uMsg) { case WM_COMMAND: SetWindowLongPtrW(f->hwnd, DWLP_MSGRESULT, 0); // just in case switch (LOWORD(wParam)) { case IDOK: case IDCANCEL: if (HIWORD(wParam) != BN_CLICKED) return FALSE; return tryFinishDialog(f, wParam); case rcFontFamilyCombobox: if (HIWORD(wParam) == CBN_SELCHANGE) { familyChanged(f); return TRUE; } if (HIWORD(wParam) == CBN_EDITCHANGE) { familyEdited(f); return TRUE; } return FALSE; case rcFontStyleCombobox: if (HIWORD(wParam) == CBN_SELCHANGE) { styleChanged(f); return TRUE; } if (HIWORD(wParam) == CBN_EDITCHANGE) { styleEdited(f); return TRUE; } return FALSE; case rcFontSizeCombobox: if (HIWORD(wParam) == CBN_SELCHANGE) { sizeChanged(f); return TRUE; } if (HIWORD(wParam) == CBN_EDITCHANGE) { sizeEdited(f); return TRUE; } return FALSE; } return FALSE; } return FALSE; }
static LRESULT IPADDRESS_Create (HWND hwnd, const CREATESTRUCTA *lpCreate) { IPADDRESS_INFO *infoPtr; RECT rcClient, edit; int i, fieldsize; HFONT hFont, hSysFont; LOGFONTW logFont, logSysFont; TRACE("\n"); SetWindowLongW (hwnd, GWL_STYLE, GetWindowLongW(hwnd, GWL_STYLE) & ~WS_BORDER); infoPtr = heap_alloc_zero (sizeof(*infoPtr)); if (!infoPtr) return -1; SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr); GetClientRect (hwnd, &rcClient); fieldsize = (rcClient.right - rcClient.left) / 4; edit.top = rcClient.top + 2; edit.bottom = rcClient.bottom - 2; infoPtr->Self = hwnd; infoPtr->Enabled = TRUE; infoPtr->Notify = lpCreate->hwndParent; hSysFont = GetStockObject(ANSI_VAR_FONT); GetObjectW(hSysFont, sizeof(LOGFONTW), &logSysFont); SystemParametersInfoW(SPI_GETICONTITLELOGFONT, 0, &logFont, 0); lstrcpyW(logFont.lfFaceName, logSysFont.lfFaceName); hFont = CreateFontIndirectW(&logFont); for (i = 0; i < 4; i++) { IPPART_INFO* part = &infoPtr->Part[i]; part->LowerLimit = 0; part->UpperLimit = 255; edit.left = rcClient.left + i*fieldsize + 6; edit.right = rcClient.left + (i+1)*fieldsize - 2; part->EditHwnd = CreateWindowW (WC_EDITW, NULL, WS_CHILD | WS_VISIBLE | ES_CENTER, edit.left, edit.top, edit.right - edit.left, edit.bottom - edit.top, hwnd, (HMENU) 1, (HINSTANCE)GetWindowLongPtrW(hwnd, GWLP_HINSTANCE), NULL); SendMessageW(part->EditHwnd, WM_SETFONT, (WPARAM) hFont, FALSE); SetPropW(part->EditHwnd, IP_SUBCLASS_PROP, hwnd); part->OrigProc = (WNDPROC) SetWindowLongPtrW (part->EditHwnd, GWLP_WNDPROC, (DWORD_PTR)IPADDRESS_SubclassProc); EnableWindow(part->EditHwnd, infoPtr->Enabled); } IPADDRESS_UpdateText (infoPtr); return 0; }