自学教程：C++ GetWindowLongPtrW函数代码示例

static LRESULT CALLBACKPxTabProc(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 );}

LRESULTDefWndNCLButtonDblClk(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. */voidWINAPIWinPosActivateOtherWindow(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);}

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 enumeratingvoid 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 CALLBACKWinPrevProc(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);	}}

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