/************************************************************************** * IShellBrowserImpl_BrowseObject * * See Windows documentation on IShellBrowser::BrowseObject for more details * * This function will override user specified flags and will always * use SBSP_DEFBROWSER and SBSP_DEFMODE. */ static HRESULT WINAPI IShellBrowserImpl_BrowseObject(IShellBrowser *iface, LPCITEMIDLIST pidl, UINT wFlags) { HRESULT hRes; IShellFolder *psfTmp; IShellView *psvTmp; FileOpenDlgInfos *fodInfos; LPITEMIDLIST pidlTmp; HWND hwndView; HWND hDlgWnd; BOOL bViewHasFocus; RECT rectView; IShellBrowserImpl *This = impl_from_IShellBrowser(iface); TRACE("(%p)(pidl=%p,flags=0x%08x)\n", This, pidl, wFlags); COMDLG32_DumpSBSPFlags(wFlags); fodInfos = GetPropA(This->hwndOwner,FileOpenDlgInfosStr); /* Format the pidl according to its parameter's category */ if(wFlags & SBSP_RELATIVE) { /* SBSP_RELATIVE A relative pidl (relative from the current folder) */ if(FAILED(hRes = IShellFolder_BindToObject(fodInfos->Shell.FOIShellFolder, pidl, NULL, &IID_IShellFolder, (LPVOID *)&psfTmp))) { ERR("bind to object failed\n"); return hRes; } /* create an absolute pidl */ pidlTmp = COMDLG32_PIDL_ILCombine(fodInfos->ShellInfos.pidlAbsCurrent, pidl); } else if(wFlags & SBSP_PARENT) { /* Browse the parent folder (ignores the pidl) */ pidlTmp = GetParentPidl(fodInfos->ShellInfos.pidlAbsCurrent); psfTmp = GetShellFolderFromPidl(pidlTmp); } else /* SBSP_ABSOLUTE is 0x0000 */ { /* An absolute pidl (relative from the desktop) */ pidlTmp = COMDLG32_PIDL_ILClone(pidl); psfTmp = GetShellFolderFromPidl(pidlTmp); } if(!psfTmp) { ERR("could not browse to folder\n"); return E_FAIL; } /* If the pidl to browse to is equal to the actual pidl ... do nothing and pretend you did it*/ if(COMDLG32_PIDL_ILIsEqual(pidlTmp,fodInfos->ShellInfos.pidlAbsCurrent)) { IShellFolder_Release(psfTmp); COMDLG32_SHFree(pidlTmp); TRACE("keep current folder\n"); return NOERROR; } /* Release the current DataObject */ if (fodInfos->Shell.FOIDataObject) { IDataObject_Release(fodInfos->Shell.FOIDataObject); fodInfos->Shell.FOIDataObject = NULL; } /* Create the associated view */ TRACE("create view object\n"); if(FAILED(hRes = IShellFolder_CreateViewObject(psfTmp, fodInfos->ShellInfos.hwndOwner, &IID_IShellView, (LPVOID *)&psvTmp))) goto error; /* Check if listview has focus */ bViewHasFocus = IsChild(fodInfos->ShellInfos.hwndView,GetFocus()); /* Get the foldersettings from the old view */ if(fodInfos->Shell.FOIShellView) IShellView_GetCurrentInfo(fodInfos->Shell.FOIShellView, &fodInfos->ShellInfos.folderSettings); /* Release the old fodInfos->Shell.FOIShellView and update its value. We have to update this early since ShellView_CreateViewWindow of native shell32 calls OnStateChange and needs the correct view here.*/ if(fodInfos->Shell.FOIShellView) { IShellView_DestroyViewWindow(fodInfos->Shell.FOIShellView); IShellView_Release(fodInfos->Shell.FOIShellView); } fodInfos->Shell.FOIShellView = psvTmp; /* Release old FOIShellFolder and update its value */ if (fodInfos->Shell.FOIShellFolder) IShellFolder_Release(fodInfos->Shell.FOIShellFolder); fodInfos->Shell.FOIShellFolder = psfTmp; /* Release old pidlAbsCurrent and update its value */ COMDLG32_SHFree(fodInfos->ShellInfos.pidlAbsCurrent); fodInfos->ShellInfos.pidlAbsCurrent = pidlTmp; COMDLG32_UpdateCurrentDir(fodInfos); GetWindowRect(GetDlgItem(This->hwndOwner, IDC_SHELLSTATIC), &rectView); MapWindowPoints(0, This->hwndOwner, (LPPOINT)&rectView, 2); /* Create the window */ TRACE("create view window\n"); if(FAILED(hRes = IShellView_CreateViewWindow(psvTmp, NULL, &fodInfos->ShellInfos.folderSettings, fodInfos->Shell.FOIShellBrowser, &rectView, &hwndView))) goto error; fodInfos->ShellInfos.hwndView = hwndView; /* Set view window control id to 5002 */ SetWindowLongPtrW(hwndView, GWLP_ID, lst2); SendMessageW( hwndView, WM_SETFONT, SendMessageW( GetParent(hwndView), WM_GETFONT, 0, 0 ), FALSE ); /* Select the new folder in the Look In combo box of the Open file dialog */ FILEDLG95_LOOKIN_SelectItem(fodInfos->DlgInfos.hwndLookInCB,fodInfos->ShellInfos.pidlAbsCurrent); /* changes the tab order of the ListView to reflect the window's File Dialog */ hDlgWnd = GetDlgItem(GetParent(hwndView), IDC_LOOKIN); SetWindowPos(hwndView, hDlgWnd, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE); /* Since we destroyed the old view if it had focus set focus to the newly created view */ if (bViewHasFocus) SetFocus(fodInfos->ShellInfos.hwndView); return hRes; error: ERR("Failed with error 0x%08x\n", hRes); return hRes; }
/*********************************************************************** * WININET_PasswordDialog */ static INT_PTR WINAPI WININET_PasswordDialog( HWND hdlg, UINT uMsg, WPARAM wParam, LPARAM lParam ) { HWND hitem; struct WININET_ErrorDlgParams *params; WCHAR szRealm[0x80], szServer[0x80]; if( uMsg == WM_INITDIALOG ) { TRACE("WM_INITDIALOG (%08lx)\n", lParam); /* save the parameter list */ params = (struct WININET_ErrorDlgParams*) lParam; SetWindowLongPtrW( hdlg, GWLP_USERDATA, lParam ); /* extract the Realm from the response and show it */ if( WININET_GetAuthRealm( params->req->hdr.hInternet, szRealm, sizeof szRealm/sizeof(WCHAR), FALSE ) ) { hitem = GetDlgItem( hdlg, IDC_REALM ); SetWindowTextW( hitem, szRealm ); } hitem = GetDlgItem( hdlg, IDC_SERVER ); SetWindowTextW( hitem, params->req->session->hostName ); WININET_GetSetPassword( hdlg, szServer, szRealm, FALSE ); return TRUE; } params = (struct WININET_ErrorDlgParams*) GetWindowLongPtrW( hdlg, GWLP_USERDATA ); switch( uMsg ) { case WM_COMMAND: if( wParam == IDOK ) { WCHAR username[0x20], password[0x20]; username[0] = 0; hitem = GetDlgItem( hdlg, IDC_USERNAME ); if( hitem ) GetWindowTextW( hitem, username, sizeof username/sizeof(WCHAR) ); password[0] = 0; hitem = GetDlgItem( hdlg, IDC_PASSWORD ); if( hitem ) GetWindowTextW( hitem, password, sizeof password/sizeof(WCHAR) ); hitem = GetDlgItem( hdlg, IDC_SAVEPASSWORD ); if( hitem && SendMessageW( hitem, BM_GETSTATE, 0, 0 ) && WININET_GetAuthRealm( params->req->hdr.hInternet, szRealm, sizeof szRealm/sizeof(WCHAR), FALSE )) { WININET_GetSetPassword( hdlg, params->req->session->hostName, szRealm, TRUE ); } WININET_SetAuthorization( params->req, username, password, FALSE ); EndDialog( hdlg, ERROR_INTERNET_FORCE_RETRY ); return TRUE; } if( wParam == IDCANCEL ) { EndDialog( hdlg, 0 ); return TRUE; } break; } return FALSE; }
/*********************************************************************** * SERIALUI_ConfigDialogProc * * Shows a dialog for configuring a COMM port */ static INT_PTR CALLBACK SERIALUI_ConfigDialogProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { static const WCHAR szSettings[] = { 'S','e','t','t','i','n','g','s',' ','f','o','r',' ',0 }; WCHAR szTitle[40]; SERIALUI_DialogInfo *info; switch (uMsg) { case WM_INITDIALOG: info = (SERIALUI_DialogInfo*) lParam; if(!info) return FALSE; SetWindowLongPtrW(hWnd, DWLP_USER, lParam); strcpyW( szTitle, szSettings ); strcatW( szTitle, info->lpszDevice ); SetWindowTextW(hWnd, szTitle); SERIALUI_DCBToDialogInfo(hWnd, info); return TRUE; case WM_COMMAND: { WORD wID = LOWORD(wParam); info = (SERIALUI_DialogInfo *) GetWindowLongPtrW(hWnd, DWLP_USER); if(!info) EndDialog(hWnd,0); switch (wID) { case IDOK: SERIALUI_DialogInfoToDCB(hWnd,info); EndDialog(hWnd, ERROR_SUCCESS); return TRUE; case IDCANCEL: EndDialog(hWnd, ERROR_CANCELLED); return TRUE; /* test code for Get/SetDefaultCommConfig begins */ case ID_GETDEFAULT: { DWORD r,dwConfSize = sizeof (COMMCONFIG); r = GetDefaultCommConfigW(info->lpszDevice, info->lpCommConfig, &dwConfSize); if(!r) MessageBoxA(hWnd,"Failed","GetDefaultCommConfig",MB_OK); } SERIALUI_DCBToDialogInfo(hWnd, info); break; case ID_SETDEFAULT: { DWORD r; SERIALUI_DialogInfoToDCB(hWnd,info); r = SetDefaultCommConfigW(info->lpszDevice, info->lpCommConfig, sizeof (COMMCONFIG)); if(!r) MessageBoxA(hWnd,"Failed","GetDefaultCommConfig",MB_OK); } break; /* test code for Get/SetDefaultCommConfig ends */ } } default: return FALSE; } }
/***************************************************************** * DdeConnect (USER32.@) */ HCONV WINAPI DdeConnect(DWORD idInst, HSZ hszService, HSZ hszTopic, PCONVCONTEXT pCC) { HWND hwndClient; WDML_INSTANCE* pInstance; WDML_CONV* pConv = NULL; ATOM aSrv = 0, aTpc = 0; TRACE("(0x%x,%p,%p,%p)\n", idInst, hszService, hszTopic, pCC); pInstance = WDML_GetInstance(idInst); if (!pInstance) return NULL; /* make sure this conv is never created */ pConv = WDML_FindConv(pInstance, WDML_CLIENT_SIDE, hszService, hszTopic); if (pConv != NULL) { ERR("This Conv already exists: (%p)\n", pConv); return NULL; } /* we need to establish a conversation with server, so create a window for it */ if (pInstance->unicode) { WNDCLASSEXW wndclass; wndclass.cbSize = sizeof(wndclass); wndclass.style = 0; wndclass.lpfnWndProc = WDML_ClientProc; wndclass.cbClsExtra = 0; wndclass.cbWndExtra = 2 * sizeof(ULONG_PTR); wndclass.hInstance = 0; wndclass.hIcon = 0; wndclass.hCursor = 0; wndclass.hbrBackground = 0; wndclass.lpszMenuName = NULL; wndclass.lpszClassName = WDML_szClientConvClassW; wndclass.hIconSm = 0; RegisterClassExW(&wndclass); hwndClient = CreateWindowW(WDML_szClientConvClassW, NULL, WS_POPUP, 0, 0, 0, 0, 0, 0, 0, 0); } else { WNDCLASSEXA wndclass; wndclass.cbSize = sizeof(wndclass); wndclass.style = 0; wndclass.lpfnWndProc = WDML_ClientProc; wndclass.cbClsExtra = 0; wndclass.cbWndExtra = 2 * sizeof(ULONG_PTR); wndclass.hInstance = 0; wndclass.hIcon = 0; wndclass.hCursor = 0; wndclass.hbrBackground = 0; wndclass.lpszMenuName = NULL; wndclass.lpszClassName = WDML_szClientConvClassA; wndclass.hIconSm = 0; RegisterClassExA(&wndclass); hwndClient = CreateWindowA(WDML_szClientConvClassA, NULL, WS_POPUP, 0, 0, 0, 0, 0, 0, 0, 0); } SetWindowLongPtrW(hwndClient, GWL_WDML_INSTANCE, (ULONG_PTR)pInstance); if (hszService) { aSrv = WDML_MakeAtomFromHsz(hszService); if (!aSrv) goto theEnd; } if (hszTopic) { aTpc = WDML_MakeAtomFromHsz(hszTopic); if (!aTpc) goto theEnd; } /* note: sent messages shall not use packing */ SendMessageTimeoutW( HWND_BROADCAST, WM_DDE_INITIATE, (WPARAM)hwndClient, MAKELPARAM(aSrv, aTpc), SMTO_ABORTIFHUNG, 2000, NULL ); pInstance = WDML_GetInstance(idInst); if (!pInstance) { goto theEnd; } /* At this point, Client WM_DDE_ACK should have saved hwndServer for this instance id and hwndClient if server responds. So get HCONV and return it. And add it to conv list */ pConv = WDML_GetConvFromWnd(hwndClient); if (pConv == NULL || pConv->hwndServer == 0) { WARN("Done with INITIATE, but no Server window available\n"); pConv = NULL; goto theEnd; } TRACE("Connected to Server window (%p)\n", pConv->hwndServer); pConv->wConvst = XST_CONNECTED; /* finish init of pConv */ if (pCC != NULL) { pConv->convContext = *pCC; } else { memset(&pConv->convContext, 0, sizeof(pConv->convContext)); pConv->convContext.cb = sizeof(pConv->convContext); pConv->convContext.iCodePage = (pInstance->unicode) ? CP_WINUNICODE : CP_WINANSI; } theEnd: if (aSrv) GlobalDeleteAtom(aSrv); if (aTpc) GlobalDeleteAtom(aTpc); return (HCONV)pConv; }
static BOOL OnMainCreate(HWND hwnd, PRDPSETTINGS pRdpSettings) { PINFO pInfo; TCITEMW item; BOOL bRet = FALSE; pInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(INFO)); if (pInfo) { SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR)pInfo); pInfo->hSelf = hwnd; /* add main settings pointer */ pInfo->pRdpSettings = pRdpSettings; /* set the dialog icons */ pInfo->hMstscSm = LoadImageW(hInst, MAKEINTRESOURCEW(IDI_MSTSC), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR); if (pInfo->hMstscSm) { SendMessageW(hwnd, WM_SETICON, ICON_SMALL, (WPARAM)pInfo->hMstscSm); } pInfo->hMstscLg = LoadImageW(hInst, MAKEINTRESOURCEW(IDI_MSTSC), IMAGE_ICON, 32, 32, LR_DEFAULTCOLOR); if (pInfo->hMstscLg) { SendMessageW(hwnd, WM_SETICON, ICON_BIG, (WPARAM)pInfo->hMstscLg); } pInfo->hHeader = (HBITMAP)LoadImageW(hInst, MAKEINTRESOURCEW(IDB_HEADER), IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR); if (pInfo->hHeader) { GetObjectW(pInfo->hHeader, sizeof(BITMAP), &pInfo->headerbitmap); } /* setup the tabs */ pInfo->hTab = GetDlgItem(hwnd, IDC_TAB); if (pInfo->hTab) { if (CreateDialogParamW(hInst, MAKEINTRESOURCEW(IDD_GENERAL), pInfo->hTab, GeneralDlgProc, (LPARAM)pInfo)) { WCHAR str[256]; ZeroMemory(&item, sizeof(TCITEM)); item.mask = TCIF_TEXT; if (LoadStringW(hInst, IDS_TAB_GENERAL, str, 256)) item.pszText = str; item.cchTextMax = 256; (void)TabCtrl_InsertItem(pInfo->hTab, 0, &item); } if (CreateDialogParamW(hInst, MAKEINTRESOURCEW(IDD_DISPLAY), pInfo->hTab, DisplayDlgProc, (LPARAM)pInfo)) { WCHAR str[256]; ZeroMemory(&item, sizeof(TCITEM)); item.mask = TCIF_TEXT; if (LoadStringW(hInst, IDS_TAB_DISPLAY, str, 256)) item.pszText = str; item.cchTextMax = 256; (void)TabCtrl_InsertItem(pInfo->hTab, 1, &item); } OnTabWndSelChange(pInfo); } } return bRet; }
static LRESULT CALLBACK GROUP_GroupWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { PROGGROUP* group; INT iItem; LVITEMW lvItem; POINT pt; group = (PROGGROUP*)GetWindowLongPtrW(hWnd, 0); switch (uMsg) { case WM_NCCREATE: { LPCREATESTRUCTW pcs = (LPCREATESTRUCTW)lParam; LPMDICREATESTRUCTW pMDIcs = (LPMDICREATESTRUCTW)pcs->lpCreateParams; group = (PROGGROUP*)pMDIcs->lParam; SetWindowLongPtrW(hWnd, 0, (LONG_PTR)group); if (group->bIsCommonGroup) { DefMDIChildProcW(hWnd, WM_SETICON, ICON_BIG, (LPARAM)CopyImage(Globals.hCommonGroupIcon, IMAGE_ICON, GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON), LR_COPYFROMRESOURCE)); DefMDIChildProcW(hWnd, WM_SETICON, ICON_SMALL, (LPARAM)CopyImage(Globals.hCommonGroupIcon, IMAGE_ICON, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_COPYFROMRESOURCE)); } else { DefMDIChildProcW(hWnd, WM_SETICON, ICON_BIG, (LPARAM)CopyImage(Globals.hPersonalGroupIcon, IMAGE_ICON, GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON), LR_COPYFROMRESOURCE)); DefMDIChildProcW(hWnd, WM_SETICON, ICON_SMALL, (LPARAM)CopyImage(Globals.hPersonalGroupIcon, IMAGE_ICON, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_COPYFROMRESOURCE)); } break; } case WM_NCDESTROY: SetWindowLongPtrW(hWnd, 0, 0); break; case WM_CREATE: { DWORD dwStyle; RECT rect; GetClientRect(hWnd, &rect); group->hListView = CreateWindowW(WC_LISTVIEW, NULL, WS_CHILD | WS_VISIBLE | WS_OVERLAPPED, 0, 0, rect.right - rect.left, rect.bottom - rect.top, hWnd, NULL, Globals.hInstance, NULL); dwStyle = (GetWindowLongPtrW(group->hListView, GWL_STYLE) | LVS_SHOWSELALWAYS) & ~LVS_AUTOARRANGE; SetWindowLongPtrW(group->hListView, GWL_STYLE, dwStyle); dwStyle = SendMessageA(group->hListView, LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0) | LVS_EX_BORDERSELECT; SendMessageA(group->hListView, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_SNAPTOGRID, dwStyle); InitUxTheme(); SetWindowTheme(group->hListView, L"Explorer", NULL); group->hListLarge = ImageList_Create(GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON), ILC_COLOR24 | ILC_MASK, 1, 1); SendMessageA(group->hListView, LVM_SETIMAGELIST, 0, (LPARAM)group->hListLarge); SendMessageA(group->hListView, LVM_SETICONSPACING, 0, MAKELPARAM(80, 64)); break; } case WM_DESTROY: { SendMessageA(group->hListView, LVM_SETIMAGELIST, 0, 0); ImageList_Destroy(group->hListLarge); DestroyWindow(group->hListView); break; } case WM_SIZE: { RECT rect; rect.left = 0; rect.top = 0; rect.right = LOWORD(lParam); rect.bottom = HIWORD(lParam); AdjustWindowRectEx(&rect, GetWindowLongPtrW(group->hListView, GWL_STYLE), FALSE, GetWindowLongPtrW(group->hListView, GWL_EXSTYLE)); MoveWindow(group->hListView, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, TRUE); break; } case WM_CLOSE: SendMessageW(hWnd, WM_SYSCOMMAND, SC_MINIMIZE, 0); break; case WM_SYSCOMMAND: if (wParam == SC_CLOSE) wParam = SC_MINIMIZE; break; case WM_CHILDACTIVATE: case WM_NCLBUTTONDOWN: Globals.hActiveGroup = (PROGGROUP*)GetWindowLongPtrW(hWnd, 0); Globals.hActiveGroup->hActiveProgram = NULL; break; case WM_NOTIFY: switch (((LPNMHDR)lParam)->code) { case NM_CLICK: { iItem = ((LPNMITEMACTIVATE)lParam)->iItem; if (iItem == -1) { group->hActiveProgram = NULL; break; } lvItem.mask = LVIF_PARAM; lvItem.iItem = iItem; SendMessageW(group->hListView, LVM_GETITEMW, 0, (LPARAM)&lvItem); group->hActiveProgram = (PROGRAM*)lvItem.lParam; break; } case NM_DBLCLK: { iItem = ((LPNMITEMACTIVATE)lParam)->iItem; if (iItem == -1) break; lvItem.mask = LVIF_PARAM; lvItem.iItem = iItem; SendMessageW(group->hListView, LVM_GETITEMW, 0, (LPARAM)&lvItem); /* ... or use group->hActiveProgram */ PROGRAM_ExecuteProgram((PROGRAM*)lvItem.lParam); break; } case LVN_BEGINDRAG: { POINT ptMin; BOOL bFirst = TRUE; for (iItem = SendMessageA(group->hListView, LVM_GETNEXTITEM, -1, LVNI_SELECTED); iItem != -1; iItem = SendMessageA(group->hListView, LVM_GETNEXTITEM, iItem, LVNI_SELECTED)) { if (bFirst) { group->hDragImageList = (HIMAGELIST)SendMessageA(group->hListView, LVM_CREATEDRAGIMAGE, iItem, (LPARAM)&pt); ptMin = pt; bFirst = FALSE; } else { HIMAGELIST hOneImageList, hTempImageList; hOneImageList = (HIMAGELIST)SendMessageA(group->hListView, LVM_CREATEDRAGIMAGE, iItem, (LPARAM)&pt); hTempImageList = ImageList_Merge(group->hDragImageList, 0, hOneImageList, 0, pt.x - ptMin.x, pt.y - ptMin.y); ImageList_Destroy(group->hDragImageList); ImageList_Destroy(hOneImageList); group->hDragImageList = hTempImageList; ptMin.x = min(ptMin.x, pt.x); ptMin.y = min(ptMin.y, pt.y); } } // pt = ((LPNMLISTVIEW)lParam)->ptAction; pt.x = ((LPNMLISTVIEW)lParam)->ptAction.x; pt.y = ((LPNMLISTVIEW)lParam)->ptAction.y; group->ptStart = pt; pt.x -= ptMin.x; pt.y -= ptMin.y; ImageList_BeginDrag(group->hDragImageList, 0, pt.x, pt.y); MapWindowPoints(group->hListView, Globals.hMDIWnd, &pt, 1); ImageList_DragEnter(Globals.hMDIWnd, pt.x, pt.y); group->bDragging = TRUE; group->hOldCursor = GetCursor(); SetCapture(group->hWnd); break; } } break; case WM_MOUSEMOVE: if (group->bDragging) { pt.x = GET_X_LPARAM(lParam); pt.y = GET_Y_LPARAM(lParam); MapWindowPoints(group->hWnd, Globals.hMDIWnd, &pt, 1); ImageList_DragMove(pt.x, pt.y); } break; case WM_LBUTTONUP: if (group->bDragging) { // LVHITTESTINFO lvhti; POINT ptHit; group->bDragging = FALSE; ImageList_DragLeave(Globals.hMDIWnd); ImageList_EndDrag(); ImageList_Destroy(group->hDragImageList); ReleaseCapture(); SetCursor(group->hOldCursor); ptHit.x = GET_X_LPARAM(lParam); ptHit.y = GET_Y_LPARAM(lParam); MapWindowPoints(group->hWnd, group->hListView, &ptHit, 1); for (iItem = SendMessageA(group->hListView, LVM_GETNEXTITEM, -1, LVNI_SELECTED); iItem != -1; iItem = SendMessageA(group->hListView, LVM_GETNEXTITEM, iItem, LVNI_SELECTED)) { SendMessageA(group->hListView, LVM_GETITEMPOSITION, iItem, (LPARAM)&pt); pt.x += ptHit.x - group->ptStart.x; pt.y += ptHit.y - group->ptStart.y; SendMessageA(group->hListView, LVM_SETITEMPOSITION, iItem, MAKELPARAM(pt.x, pt.y)); } } break; } return DefMDIChildProcW(hWnd, uMsg, wParam, lParam); }
/*********************************************************************** * ButtonWndProc_common */ LRESULT ButtonWndProc_common(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL unicode ) { RECT rect; POINT pt; LONG style = GetWindowLongW( hWnd, GWL_STYLE ); UINT btn_type = get_button_type( style ); LONG state; HANDLE oldHbitmap; if (!IsWindow( hWnd )) return 0; pt.x = (short)LOWORD(lParam); pt.y = (short)HIWORD(lParam); switch (uMsg) { case WM_GETDLGCODE: switch(btn_type) { case BS_USERBUTTON: case BS_PUSHBUTTON: return DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON; case BS_DEFPUSHBUTTON: return DLGC_BUTTON | DLGC_DEFPUSHBUTTON; case BS_RADIOBUTTON: case BS_AUTORADIOBUTTON: return DLGC_BUTTON | DLGC_RADIOBUTTON; case BS_GROUPBOX: return DLGC_STATIC; default: return DLGC_BUTTON; } case WM_ENABLE: paint_button( hWnd, btn_type, ODA_DRAWENTIRE ); break; case WM_CREATE: if (!hbitmapCheckBoxes) { BITMAP bmp; hbitmapCheckBoxes = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_CHECKBOXES)); GetObjectW( hbitmapCheckBoxes, sizeof(bmp), &bmp ); checkBoxWidth = bmp.bmWidth / 4; checkBoxHeight = bmp.bmHeight / 3; } if (btn_type >= MAX_BTN_TYPE) return -1; /* abort */ /* XP turns a BS_USERBUTTON into BS_PUSHBUTTON */ if (btn_type == BS_USERBUTTON ) { style = (style & ~0x0f) | BS_PUSHBUTTON; WIN_SetStyle( hWnd, style, 0x0f & ~style ); } set_button_state( hWnd, BUTTON_UNCHECKED ); return 0; case WM_ERASEBKGND: if (btn_type == BS_OWNERDRAW) { HDC hdc = (HDC)wParam; RECT rc; HBRUSH hBrush; HWND parent = GetParent(hWnd); if (!parent) parent = hWnd; hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORBTN, (WPARAM)hdc, (LPARAM)hWnd); if (!hBrush) /* did the app forget to call defwindowproc ? */ hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORBTN, (WPARAM)hdc, (LPARAM)hWnd); GetClientRect(hWnd, &rc); FillRect(hdc, &rc, hBrush); } return 1; case WM_PRINTCLIENT: case WM_PAINT: if (btnPaintFunc[btn_type]) { PAINTSTRUCT ps; HDC hdc = wParam ? (HDC)wParam : BeginPaint( hWnd, &ps ); int nOldMode = SetBkMode( hdc, OPAQUE ); (btnPaintFunc[btn_type])( hWnd, hdc, ODA_DRAWENTIRE ); SetBkMode(hdc, nOldMode); /* reset painting mode */ if( !wParam ) EndPaint( hWnd, &ps ); } break; case WM_KEYDOWN: if (wParam == VK_SPACE) { SendMessageW( hWnd, BM_SETSTATE, TRUE, 0 ); set_button_state( hWnd, get_button_state( hWnd ) | BUTTON_BTNPRESSED ); SetCapture( hWnd ); } break; case WM_LBUTTONDBLCLK: if(style & BS_NOTIFY || btn_type == BS_RADIOBUTTON || btn_type == BS_USERBUTTON || btn_type == BS_OWNERDRAW) { BUTTON_NOTIFY_PARENT(hWnd, BN_DOUBLECLICKED); break; } /* fall through */ case WM_LBUTTONDOWN: SetCapture( hWnd ); SetFocus( hWnd ); set_button_state( hWnd, get_button_state( hWnd ) | BUTTON_BTNPRESSED ); SendMessageW( hWnd, BM_SETSTATE, TRUE, 0 ); break; case WM_KEYUP: if (wParam != VK_SPACE) break; /* fall through */ case WM_LBUTTONUP: state = get_button_state( hWnd ); if (!(state & BUTTON_BTNPRESSED)) break; state &= BUTTON_NSTATES; set_button_state( hWnd, state ); if (!(state & BUTTON_HIGHLIGHTED)) { ReleaseCapture(); break; } SendMessageW( hWnd, BM_SETSTATE, FALSE, 0 ); ReleaseCapture(); GetClientRect( hWnd, &rect ); if (uMsg == WM_KEYUP || PtInRect( &rect, pt )) { state = get_button_state( hWnd ); switch(btn_type) { case BS_AUTOCHECKBOX: SendMessageW( hWnd, BM_SETCHECK, !(state & BUTTON_CHECKED), 0 ); break; case BS_AUTORADIOBUTTON: SendMessageW( hWnd, BM_SETCHECK, TRUE, 0 ); break; case BS_AUTO3STATE: SendMessageW( hWnd, BM_SETCHECK, (state & BUTTON_3STATE) ? 0 : ((state & 3) + 1), 0 ); break; } BUTTON_NOTIFY_PARENT(hWnd, BN_CLICKED); } break; case WM_CAPTURECHANGED: TRACE("WM_CAPTURECHANGED %p\n", hWnd); state = get_button_state( hWnd ); if (state & BUTTON_BTNPRESSED) { state &= BUTTON_NSTATES; set_button_state( hWnd, state ); if (state & BUTTON_HIGHLIGHTED) SendMessageW( hWnd, BM_SETSTATE, FALSE, 0 ); } break; case WM_MOUSEMOVE: if ((wParam & MK_LBUTTON) && GetCapture() == hWnd) { GetClientRect( hWnd, &rect ); SendMessageW( hWnd, BM_SETSTATE, PtInRect(&rect, pt), 0 ); } break; case WM_SETTEXT: { /* Clear an old text here as Windows does */ HDC hdc = GetDC(hWnd); HBRUSH hbrush; RECT client, rc; HWND parent = GetParent(hWnd); if (!parent) parent = hWnd; hbrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORSTATIC, (WPARAM)hdc, (LPARAM)hWnd); if (!hbrush) /* did the app forget to call DefWindowProc ? */ hbrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORSTATIC, (WPARAM)hdc, (LPARAM)hWnd); GetClientRect(hWnd, &client); rc = client; BUTTON_CalcLabelRect(hWnd, hdc, &rc); /* Clip by client rect bounds */ if (rc.right > client.right) rc.right = client.right; if (rc.bottom > client.bottom) rc.bottom = client.bottom; FillRect(hdc, &rc, hbrush); ReleaseDC(hWnd, hdc); if (unicode) DefWindowProcW( hWnd, WM_SETTEXT, wParam, lParam ); else DefWindowProcA( hWnd, WM_SETTEXT, wParam, lParam ); if (btn_type == BS_GROUPBOX) /* Yes, only for BS_GROUPBOX */ InvalidateRect( hWnd, NULL, TRUE ); else paint_button( hWnd, btn_type, ODA_DRAWENTIRE ); return 1; /* success. FIXME: check text length */ } case WM_SETFONT: set_button_font( hWnd, (HFONT)wParam ); if (lParam) InvalidateRect(hWnd, NULL, TRUE); break; case WM_GETFONT: return (LRESULT)get_button_font( hWnd ); case WM_SETFOCUS: TRACE("WM_SETFOCUS %p\n",hWnd); set_button_state( hWnd, get_button_state(hWnd) | BUTTON_HASFOCUS ); paint_button( hWnd, btn_type, ODA_FOCUS ); if (style & BS_NOTIFY) BUTTON_NOTIFY_PARENT(hWnd, BN_SETFOCUS); break; case WM_KILLFOCUS: TRACE("WM_KILLFOCUS %p\n",hWnd); state = get_button_state( hWnd ); set_button_state( hWnd, state & ~BUTTON_HASFOCUS ); paint_button( hWnd, btn_type, ODA_FOCUS ); if ((state & BUTTON_BTNPRESSED) && GetCapture() == hWnd) ReleaseCapture(); if (style & BS_NOTIFY) BUTTON_NOTIFY_PARENT(hWnd, BN_KILLFOCUS); InvalidateRect( hWnd, NULL, FALSE ); break; case WM_SYSCOLORCHANGE: InvalidateRect( hWnd, NULL, FALSE ); break; case BM_SETSTYLE: if ((wParam & 0x0f) >= MAX_BTN_TYPE) break; btn_type = wParam & 0x0f; style = (style & ~0x0f) | btn_type; WIN_SetStyle( hWnd, style, 0x0f & ~style ); /* Only redraw if lParam flag is set.*/ if (lParam) InvalidateRect( hWnd, NULL, TRUE ); break; case BM_CLICK: SendMessageW( hWnd, WM_LBUTTONDOWN, 0, 0 ); SendMessageW( hWnd, WM_LBUTTONUP, 0, 0 ); break; case BM_SETIMAGE: /* Check that image format matches button style */ switch (style & (BS_BITMAP|BS_ICON)) { case BS_BITMAP: if (wParam != IMAGE_BITMAP) return 0; break; case BS_ICON: if (wParam != IMAGE_ICON) return 0; break; default: return 0; } oldHbitmap = (HBITMAP)SetWindowLongPtrW( hWnd, HIMAGE_GWL_OFFSET, lParam ); InvalidateRect( hWnd, NULL, FALSE ); return (LRESULT)oldHbitmap; case BM_GETIMAGE: return GetWindowLongPtrW( hWnd, HIMAGE_GWL_OFFSET ); case BM_GETCHECK: return get_button_state( hWnd ) & 3; case BM_SETCHECK: if (wParam > maxCheckState[btn_type]) wParam = maxCheckState[btn_type]; state = get_button_state( hWnd ); if ((btn_type == BS_RADIOBUTTON) || (btn_type == BS_AUTORADIOBUTTON)) { if (wParam) style |= WS_TABSTOP; else style &= ~WS_TABSTOP; SetWindowLongW( hWnd, GWL_STYLE, style ); } if ((state & 3) != wParam) { set_button_state( hWnd, (state & ~3) | wParam ); paint_button( hWnd, btn_type, ODA_SELECT ); } if ((btn_type == BS_AUTORADIOBUTTON) && (wParam == BUTTON_CHECKED) && (style & WS_CHILD)) BUTTON_CheckAutoRadioButton( hWnd ); break; case BM_GETSTATE: return get_button_state( hWnd ); case BM_SETSTATE: state = get_button_state( hWnd ); if (wParam) { if (state & BUTTON_HIGHLIGHTED) break; set_button_state( hWnd, state | BUTTON_HIGHLIGHTED ); } else { if (!(state & BUTTON_HIGHLIGHTED)) break; set_button_state( hWnd, state & ~BUTTON_HIGHLIGHTED ); } paint_button( hWnd, btn_type, ODA_SELECT ); break; case WM_NCHITTEST: if(btn_type == BS_GROUPBOX) return HTTRANSPARENT; /* fall through */ default: return unicode ? DefWindowProcW(hWnd, uMsg, wParam, lParam) : DefWindowProcA(hWnd, uMsg, wParam, lParam); } return 0; }
static INT_PTR CALLBACK DownloadDlgProc(HWND Dlg, UINT uMsg, WPARAM wParam, LPARAM lParam) { HANDLE Thread; DWORD ThreadId; HWND Item; switch (uMsg) { case WM_INITDIALOG: { HICON hIconSm = NULL, hIconBg = NULL; hIconBg = (HICON)GetClassLongPtr(hMainWnd, GCLP_HICON); hIconSm = (HICON)GetClassLongPtr(hMainWnd, GCLP_HICONSM); if (hIconBg && hIconSm) { SendMessageW(Dlg, WM_SETICON, ICON_BIG, (LPARAM) hIconBg); SendMessageW(Dlg, WM_SETICON, ICON_SMALL, (LPARAM) hIconSm); } SetWindowLongPtrW(Dlg, GWLP_USERDATA, 0); Item = GetDlgItem(Dlg, IDC_DOWNLOAD_PROGRESS); if (Item) { /* initialize the default values for our nifty progress bar and subclass it so that it learns to print a status text */ SendMessageW(Item, PBM_SETRANGE, 0, MAKELPARAM(0, 100)); SendMessageW(Item, PBM_SETPOS, 0, 0); SetWindowSubclass(Item, DownloadProgressProc, 0, 0); } /* add a neat placeholder until the download URL is retrieved */ Item = GetDlgItem(Dlg, IDC_DOWNLOAD_STATUS); SendMessageW(Item, WM_SETTEXT, 0, (LPARAM)L"\x2022 \x2022 \x2022"); Thread = CreateThread(NULL, 0, ThreadFunc, Dlg, 0, &ThreadId); if (!Thread) return FALSE; CloseHandle(Thread); return TRUE; } case WM_COMMAND: if (wParam == IDCANCEL) { SetWindowLongPtrW(Dlg, GWLP_USERDATA, 1); PostMessageW(Dlg, WM_CLOSE, 0, 0); } return FALSE; case WM_CLOSE: EndDialog(Dlg, 0); return TRUE; default: return FALSE; } }
bool csGraphics2DOpenGL::Open () { if (is_open) return true; csRef<iVerbosityManager> verbosemgr ( csQueryRegistry<iVerbosityManager> (object_reg)); if (verbosemgr) detector.SetVerbose (verbosemgr->Enabled ("renderer.windows.gldriver")); // create the window. if (FullScreen) { SwitchDisplayMode (false); } int pixelFormat = -1; csGLPixelFormatPicker picker (this); /* Check if the WGL pixel format check should be used at all. It appears that some drivers take "odd" choices when using the WGL pixel format path (e.g. returning Accum-capable formats even if none was requested). */ bool doWGLcheck = false; { GLPixelFormat format; if (picker.GetNextFormat (format)) { doWGLcheck = (format[glpfvMultiSamples] != 0); picker.Reset (); } } if (doWGLcheck) pixelFormat = FindPixelFormatWGL (picker); m_bActivated = true; int wwidth = fbWidth; int wheight = fbHeight; DWORD exStyle = 0; DWORD style = WS_POPUP | WS_SYSMENU; int xpos = 0; int ypos = 0; if (FullScreen) { /*exStyle |= WS_EX_TOPMOST;*/ } else { style |= WS_CAPTION | WS_MINIMIZEBOX; if (AllowResizing) style |= WS_THICKFRAME | WS_MAXIMIZEBOX; wwidth += 2 * GetSystemMetrics (SM_CXFIXEDFRAME); wheight += 2 * GetSystemMetrics (SM_CYFIXEDFRAME) + GetSystemMetrics (SM_CYCAPTION); xpos = (GetSystemMetrics (SM_CXSCREEN) - wwidth) / 2; ypos = (GetSystemMetrics (SM_CYSCREEN) - wheight) / 2; } m_hWnd = m_piWin32Assistant->CreateCSWindow (this, exStyle, style, xpos, ypos, wwidth, wheight); if (!m_hWnd) SystemFatalError (L"Cannot create Crystal Space window", GetLastError()); SetTitle (win_title); // Subclass the window if (IsWindowUnicode (m_hWnd)) { m_OldWndProc = (WNDPROC)SetWindowLongPtrW (m_hWnd, GWLP_WNDPROC, (LONG_PTR) WindowProc); SetWindowLongPtrW (m_hWnd, GWLP_USERDATA, (LONG_PTR)this); } else { m_OldWndProc = (WNDPROC)SetWindowLongPtrA (m_hWnd, GWLP_WNDPROC, (LONG_PTR) WindowProc); SetWindowLongPtrA (m_hWnd, GWLP_USERDATA, (LONG_PTR)this); } hDC = GetDC (m_hWnd); if (pixelFormat == -1) { picker.Reset(); pixelFormat = FindPixelFormatGDI (hDC, picker); } PIXELFORMATDESCRIPTOR pfd; if (DescribePixelFormat (hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd) == 0) SystemFatalError (L"DescribePixelFormat failed.", GetLastError()); if (SetPixelFormat (hDC, pixelFormat, &pfd) != TRUE) { HRESULT spfErr = (HRESULT)GetLastError(); SystemFatalError (L"SetPixelFormat failed.", spfErr); } currentFormat[glpfvColorBits] = pfd.cColorBits; currentFormat[glpfvAlphaBits] = pfd.cAlphaBits; currentFormat[glpfvDepthBits] = pfd.cDepthBits; currentFormat[glpfvStencilBits] = pfd.cStencilBits; currentFormat[glpfvAccumColorBits] = pfd.cAccumBits; currentFormat[glpfvAccumAlphaBits] = pfd.cAccumAlphaBits; Depth = pfd.cColorBits; hardwareAccelerated = !(pfd.dwFlags & PFD_GENERIC_FORMAT) || (pfd.dwFlags & PFD_GENERIC_ACCELERATED); hGLRC = wglCreateContext (hDC); wglMakeCurrent (hDC, hGLRC); UpdateWindow (m_hWnd); ShowWindow (m_hWnd, m_nCmdShow); SetForegroundWindow (m_hWnd); SetFocus (m_hWnd); /* Small hack to emit "no HW acceleration" message on both GDI Generic and * sucky Direct3D default OpenGL */ hardwareAccelerated &= (strncmp ((char*)glGetString (GL_VENDOR), "Microsoft", 9) != 0); if (!hardwareAccelerated) { Report (CS_REPORTER_SEVERITY_WARNING, "No hardware acceleration!"); } detector.DoDetection (m_hWnd, hDC); Report (CS_REPORTER_SEVERITY_NOTIFY, "GL driver: %s %s", detector.GetDriverDLL(), detector.GetDriverVersion() ? detector.GetDriverVersion() : "<version unknown>"); if (FullScreen) { /* * from the Windows Shell docs: * "It is possible to cover the taskbar by explicitly setting the size * of the window rectangle equal to the size of the screen with * SetWindowPos." */ SetWindowPos (m_hWnd, CS_WINDOW_Z_ORDER, 0, 0, fbWidth, fbHeight, 0); } if (!csGraphics2DGLCommon::Open ()) return false; ext.InitWGL_EXT_swap_control (hDC); if (ext.CS_WGL_EXT_swap_control) { ext.wglSwapIntervalEXT (vsync ? 1 : 0); vsync = (ext.wglGetSwapIntervalEXT() != 0); Report (CS_REPORTER_SEVERITY_NOTIFY, "VSync is %s.", vsync ? "enabled" : "disabled"); } return true; }
static inline void set_button_font( HWND hwnd, HFONT font ) { SetWindowLongPtrW( hwnd, HFONT_GWL_OFFSET, (LONG_PTR)font ); }
/*********************************************************************** * UpDownWndProc */ static LRESULT WINAPI UpDownWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd); static const WCHAR themeClass[] = {'S','p','i','n',0}; HTHEME theme; TRACE("hwnd=%p msg=%04x wparam=%08lx lparam=%08lx\n", hwnd, message, wParam, lParam); if (!infoPtr && (message != WM_CREATE)) return DefWindowProcW (hwnd, message, wParam, lParam); switch(message) { case WM_CREATE: { CREATESTRUCTW *pcs = (CREATESTRUCTW*)lParam; infoPtr = Alloc (sizeof(UPDOWN_INFO)); SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr); /* initialize the info struct */ infoPtr->Self = hwnd; infoPtr->Notify = pcs->hwndParent; infoPtr->dwStyle = pcs->style; infoPtr->AccelCount = 0; infoPtr->AccelVect = 0; infoPtr->AccelIndex = -1; infoPtr->CurVal = 0; infoPtr->MinVal = 100; infoPtr->MaxVal = 0; infoPtr->Base = 10; /* Default to base 10 */ infoPtr->Buddy = 0; /* No buddy window yet */ infoPtr->Flags = (infoPtr->dwStyle & UDS_SETBUDDYINT) ? FLAG_BUDDYINT : 0; SetWindowLongW (hwnd, GWL_STYLE, infoPtr->dwStyle & ~WS_BORDER); if (!(infoPtr->dwStyle & UDS_HORZ)) SetWindowPos (hwnd, NULL, 0, 0, DEFAULT_WIDTH, pcs->cy, SWP_NOOWNERZORDER | SWP_NOZORDER | SWP_NOMOVE); /* Do we pick the buddy win ourselves? */ if (infoPtr->dwStyle & UDS_AUTOBUDDY) UPDOWN_SetBuddy (infoPtr, GetWindow (hwnd, GW_HWNDPREV)); OpenThemeData (hwnd, themeClass); TRACE("UpDown Ctrl creation, hwnd=%p\n", hwnd); } break; case WM_DESTROY: Free (infoPtr->AccelVect); if (infoPtr->Buddy) RemoveWindowSubclass(infoPtr->Buddy, UPDOWN_Buddy_SubclassProc, BUDDY_SUBCLASSID); Free (infoPtr); SetWindowLongPtrW (hwnd, 0, 0); theme = GetWindowTheme (hwnd); CloseThemeData (theme); TRACE("UpDown Ctrl destruction, hwnd=%p\n", hwnd); break; case WM_ENABLE: if (wParam) { infoPtr->dwStyle &= ~WS_DISABLED; } else { infoPtr->dwStyle |= WS_DISABLED; UPDOWN_CancelMode (infoPtr); } InvalidateRect (infoPtr->Self, NULL, FALSE); break; case WM_STYLECHANGED: if (wParam == GWL_STYLE) { infoPtr->dwStyle = ((LPSTYLESTRUCT)lParam)->styleNew; InvalidateRect (infoPtr->Self, NULL, FALSE); } break; case WM_THEMECHANGED: theme = GetWindowTheme (hwnd); CloseThemeData (theme); OpenThemeData (hwnd, themeClass); InvalidateRect (hwnd, NULL, FALSE); break; case WM_TIMER: /* is this the auto-press timer? */ if(wParam == TIMER_AUTOPRESS) { KillTimer(hwnd, TIMER_AUTOPRESS); infoPtr->Flags &= ~(FLAG_PRESSED | FLAG_ARROW); InvalidateRect(infoPtr->Self, NULL, FALSE); } /* if initial timer, kill it and start the repeat timer */ if(wParam == TIMER_AUTOREPEAT) { INT delay; KillTimer(hwnd, TIMER_AUTOREPEAT); /* if no accel info given, used default timer */ if(infoPtr->AccelCount==0 || infoPtr->AccelVect==0) { infoPtr->AccelIndex = -1; delay = REPEAT_DELAY; } else { infoPtr->AccelIndex = 0; /* otherwise, use it */ delay = infoPtr->AccelVect[infoPtr->AccelIndex].nSec * 1000 + 1; } SetTimer(hwnd, TIMER_ACCEL, delay, 0); } /* now, if the mouse is above us, do the thing...*/ if(infoPtr->Flags & FLAG_MOUSEIN) { int temp; temp = infoPtr->AccelIndex == -1 ? 1 : infoPtr->AccelVect[infoPtr->AccelIndex].nInc; UPDOWN_DoAction(infoPtr, temp, infoPtr->Flags & FLAG_ARROW); if(infoPtr->AccelIndex != -1 && infoPtr->AccelIndex < infoPtr->AccelCount-1) { KillTimer(hwnd, TIMER_ACCEL); infoPtr->AccelIndex++; /* move to the next accel info */ temp = infoPtr->AccelVect[infoPtr->AccelIndex].nSec * 1000 + 1; /* make sure we have at least 1ms intervals */ SetTimer(hwnd, TIMER_ACCEL, temp, 0); } } break; case WM_CANCELMODE: return UPDOWN_CancelMode (infoPtr); case WM_LBUTTONUP: if (GetCapture() != infoPtr->Self) break; if ( (infoPtr->Flags & FLAG_MOUSEIN) && (infoPtr->Flags & FLAG_ARROW) ) { SendMessageW( infoPtr->Notify, (infoPtr->dwStyle & UDS_HORZ) ? WM_HSCROLL : WM_VSCROLL, MAKELONG(SB_ENDSCROLL, infoPtr->CurVal), (LPARAM)hwnd); if (UPDOWN_IsBuddyEdit(infoPtr)) SendMessageW(infoPtr->Buddy, EM_SETSEL, 0, MAKELONG(0, -1)); } UPDOWN_CancelMode(infoPtr); break; case WM_LBUTTONDOWN: case WM_MOUSEMOVE: case WM_MOUSELEAVE: if(UPDOWN_IsEnabled(infoPtr)) UPDOWN_HandleMouseEvent (infoPtr, message, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam)); break; case WM_MOUSEWHEEL: UPDOWN_MouseWheel(infoPtr, wParam); break; case WM_KEYDOWN: if((infoPtr->dwStyle & UDS_ARROWKEYS) && UPDOWN_IsEnabled(infoPtr)) return UPDOWN_KeyPressed(infoPtr, (int)wParam); break; case WM_PRINTCLIENT: case WM_PAINT: return UPDOWN_Paint (infoPtr, (HDC)wParam); case UDM_GETACCEL: if (wParam==0 && lParam==0) return infoPtr->AccelCount; if (wParam && lParam) { int temp = min(infoPtr->AccelCount, wParam); memcpy((void *)lParam, infoPtr->AccelVect, temp*sizeof(UDACCEL)); return temp; } return 0; case UDM_SETACCEL: { TRACE("UDM_SETACCEL\n"); if(infoPtr->AccelVect) { Free (infoPtr->AccelVect); infoPtr->AccelCount = 0; infoPtr->AccelVect = 0; } if(wParam==0) return TRUE; infoPtr->AccelVect = Alloc (wParam*sizeof(UDACCEL)); if(infoPtr->AccelVect == 0) return FALSE; memcpy(infoPtr->AccelVect, (void*)lParam, wParam*sizeof(UDACCEL)); infoPtr->AccelCount = wParam; if (TRACE_ON(updown)) { INT i; for (i = 0; i < wParam; i++) TRACE("%d: nSec %u nInc %u\n", i, infoPtr->AccelVect[i].nSec, infoPtr->AccelVect[i].nInc); } return TRUE; } case UDM_GETBASE: return infoPtr->Base; case UDM_SETBASE: TRACE("UpDown Ctrl new base(%ld), hwnd=%p\n", wParam, hwnd); if (wParam==10 || wParam==16) { WPARAM old_base = infoPtr->Base; infoPtr->Base = wParam; if (old_base != infoPtr->Base) UPDOWN_SetBuddyInt(infoPtr); return old_base; } break; case UDM_GETBUDDY: return (LRESULT)infoPtr->Buddy; case UDM_SETBUDDY: return (LRESULT)UPDOWN_SetBuddy (infoPtr, (HWND)wParam); case UDM_GETPOS: { BOOL ret = UPDOWN_GetBuddyInt (infoPtr); return MAKELONG(infoPtr->CurVal, ret ? 0 : 1); } case UDM_SETPOS: { int temp = (short)LOWORD(lParam); TRACE("UpDown Ctrl new value(%d), hwnd=%p\n", temp, hwnd); if(!UPDOWN_InBounds(infoPtr, temp)) { if(temp < infoPtr->MinVal) temp = infoPtr->MinVal; if(temp > infoPtr->MaxVal) temp = infoPtr->MaxVal; } wParam = infoPtr->CurVal; infoPtr->CurVal = temp; UPDOWN_SetBuddyInt (infoPtr); return wParam; /* return prev value */ } case UDM_GETRANGE: return MAKELONG(infoPtr->MaxVal, infoPtr->MinVal); case UDM_SETRANGE: /* we must have: UD_MINVAL <= Max <= UD_MAXVAL UD_MINVAL <= Min <= UD_MAXVAL |Max-Min| <= UD_MAXVAL */ UPDOWN_SetRange(infoPtr, (short)lParam, (short)HIWORD(lParam)); break; case UDM_GETRANGE32: if (wParam) *(LPINT)wParam = infoPtr->MinVal; if (lParam) *(LPINT)lParam = infoPtr->MaxVal; break; case UDM_SETRANGE32: UPDOWN_SetRange(infoPtr, (INT)lParam, (INT)wParam); break; case UDM_GETPOS32: { BOOL ret = UPDOWN_GetBuddyInt (infoPtr); if ((LPBOOL)lParam) *((LPBOOL)lParam) = !ret; return infoPtr->CurVal; } case UDM_SETPOS32: { int temp; if(!UPDOWN_InBounds(infoPtr, (int)lParam)) { if((int)lParam < infoPtr->MinVal) lParam = infoPtr->MinVal; if((int)lParam > infoPtr->MaxVal) lParam = infoPtr->MaxVal; } temp = infoPtr->CurVal; /* save prev value */ infoPtr->CurVal = (int)lParam; /* set the new value */ UPDOWN_SetBuddyInt (infoPtr); return temp; /* return prev value */ } case UDM_GETUNICODEFORMAT: /* we lie a bit here, we're always using Unicode internally */ return infoPtr->UnicodeFormat; case UDM_SETUNICODEFORMAT: { /* do we really need to honour this flag? */ int temp = infoPtr->UnicodeFormat; infoPtr->UnicodeFormat = (BOOL)wParam; return temp; } default: if ((message >= WM_USER) && (message < WM_APP) && !COMCTL32_IsReflectedMessage(message)) ERR("unknown msg %04x wp=%04lx lp=%08lx\n", message, wParam, lParam); return DefWindowProcW (hwnd, message, wParam, lParam); } return 0; }
static LRESULT STATUSBAR_WMCreate (HWND hwnd, const CREATESTRUCTA *lpCreate) { STATUS_INFO *infoPtr; NONCLIENTMETRICSW nclm; DWORD dwStyle; RECT rect; int len; TRACE("\n"); infoPtr = Alloc (sizeof(STATUS_INFO)); if (!infoPtr) goto create_fail; SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr); infoPtr->Self = hwnd; infoPtr->Notify = lpCreate->hwndParent; infoPtr->numParts = 1; infoPtr->parts = 0; infoPtr->simple = FALSE; infoPtr->clrBk = CLR_DEFAULT; infoPtr->hFont = 0; infoPtr->horizontalBorder = HORZ_BORDER; infoPtr->verticalBorder = VERT_BORDER; infoPtr->horizontalGap = HORZ_GAP; infoPtr->minHeight = GetSystemMetrics(SM_CYSIZE); if (infoPtr->minHeight & 1) infoPtr->minHeight--; STATUSBAR_NotifyFormat(infoPtr, infoPtr->Notify, NF_REQUERY); ZeroMemory (&nclm, sizeof(nclm)); nclm.cbSize = sizeof(nclm); SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, nclm.cbSize, &nclm, 0); infoPtr->hDefaultFont = CreateFontIndirectW (&nclm.lfStatusFont); GetClientRect (hwnd, &rect); /* initialize simple case */ infoPtr->part0.bound = rect; infoPtr->part0.text = 0; infoPtr->part0.x = 0; infoPtr->part0.style = 0; infoPtr->part0.hIcon = 0; /* initialize first part */ infoPtr->parts = Alloc (sizeof(STATUSWINDOWPART)); if (!infoPtr->parts) goto create_fail; infoPtr->parts[0].bound = rect; infoPtr->parts[0].text = 0; infoPtr->parts[0].x = -1; infoPtr->parts[0].style = 0; infoPtr->parts[0].hIcon = 0; OpenThemeData (hwnd, themeClass); if (lpCreate->lpszName && (len = strlenW ((LPCWSTR)lpCreate->lpszName))) { infoPtr->parts[0].text = Alloc ((len + 1)*sizeof(WCHAR)); if (!infoPtr->parts[0].text) goto create_fail; strcpyW (infoPtr->parts[0].text, (LPCWSTR)lpCreate->lpszName); } dwStyle = GetWindowLongW (hwnd, GWL_STYLE); /* native seems to clear WS_BORDER, too */ dwStyle &= ~WS_BORDER; SetWindowLongW (hwnd, GWL_STYLE, dwStyle); infoPtr->height = STATUSBAR_ComputeHeight(infoPtr); if (dwStyle & SBT_TOOLTIPS) { infoPtr->hwndToolTip = CreateWindowExW (0, TOOLTIPS_CLASSW, NULL, WS_POPUP | TTS_ALWAYSTIP, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, hwnd, 0, (HINSTANCE)GetWindowLongPtrW(hwnd, GWLP_HINSTANCE), NULL); if (infoPtr->hwndToolTip) { NMTOOLTIPSCREATED nmttc; nmttc.hdr.hwndFrom = hwnd; nmttc.hdr.idFrom = GetWindowLongPtrW (hwnd, GWLP_ID); nmttc.hdr.code = NM_TOOLTIPSCREATED; nmttc.hwndToolTips = infoPtr->hwndToolTip; SendMessageW (lpCreate->hwndParent, WM_NOTIFY, nmttc.hdr.idFrom, (LPARAM)&nmttc); } } return 0; create_fail: TRACE(" failed!\n"); if (infoPtr) STATUSBAR_WMDestroy(infoPtr); return -1; }
PlatformWindow *Win32WindowManager::createWindow(GFXDevice *device, const GFXVideoMode &mode) { // Do the allocation. Win32Window *w32w = new Win32Window(); w32w->setOffscreenRender(mOffscreenRender); w32w->mWindowId = getNextId(); w32w->mOwningManager = this; // Link into our list of windows. linkWindow(w32w); DWORD dwExStyle; DWORD dwStyle = WS_CLIPCHILDREN | WS_CLIPSIBLINGS; dwStyle |= WS_OVERLAPPEDWINDOW | WS_THICKFRAME | WS_CAPTION; dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // If we're parented, we want a different set of window styles. if(mParentWindow) dwStyle = WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_CHILDWINDOW; if (mOffscreenRender) { dwStyle = WS_OVERLAPPEDWINDOW; dwExStyle = 0; } // Create the window handle w32w->mWindowHandle = CreateWindowEx( dwExStyle, Win32Window::getWindowClassName(), //class name String( getEngineProductString() ).utf16(), //window title dwStyle, //style - need clip siblings/children for opengl 0, 0, 0, 0, mParentWindow, //parent window NULL, //menu? No. NULL, //the hInstance NULL ); //no funky params // Note the style we created with so we can switch back to it when we're // done with full-screen mode. w32w->mWindowedWindowStyle = dwStyle; // Set the video mode on the window w32w->setVideoMode(mode); // Associate our window struct with the HWND. SetWindowLongPtrW(w32w->mWindowHandle, GWLP_USERDATA, (LONG)w32w); // Do some error checking. AssertFatal(w32w->mWindowHandle != NULL, "Win32WindowManager::createWindow - Could not create window!"); if(w32w->mWindowHandle == NULL) { Con::errorf("Win32WindowManager::createWindow - Could not create window!"); delete w32w; return NULL; } // If we're not rendering offscreen, make sure our window is shown and drawn to. if (!mOffscreenRender) ShowWindow( w32w->mWindowHandle, SW_SHOWDEFAULT ); // Close any splash screen we created CloseSplashWindow(winState.appInstance); // Bind the window to the specified device. if(device) { w32w->mDevice = device; w32w->mTarget = device->allocWindowTarget(w32w); AssertISV(w32w->mTarget, "Win32WindowManager::createWindow - failed to get a window target back from the device."); } else { Con::warnf("Win32WindowManager::createWindow - created a window with no device!"); } // Update it if needed. UpdateWindow( w32w->mWindowHandle ); return w32w; }
/*********************************************************************** * WININET_InvalidCertificateDialog */ static INT_PTR WINAPI WININET_InvalidCertificateDialog( HWND hdlg, UINT uMsg, WPARAM wParam, LPARAM lParam ) { struct WININET_ErrorDlgParams *params; HWND hitem; WCHAR buf[1024]; if( uMsg == WM_INITDIALOG ) { TRACE("WM_INITDIALOG (%08lx)\n", lParam); /* save the parameter list */ params = (struct WININET_ErrorDlgParams*) lParam; SetWindowLongPtrW( hdlg, GWLP_USERDATA, lParam ); switch( params->dwError ) { case ERROR_INTERNET_INVALID_CA: LoadStringW( WININET_hModule, IDS_CERT_CA_INVALID, buf, 1024 ); break; case ERROR_INTERNET_SEC_CERT_DATE_INVALID: LoadStringW( WININET_hModule, IDS_CERT_DATE_INVALID, buf, 1024 ); break; case ERROR_INTERNET_SEC_CERT_CN_INVALID: LoadStringW( WININET_hModule, IDS_CERT_CN_INVALID, buf, 1024 ); break; case ERROR_INTERNET_SEC_CERT_ERRORS: /* FIXME: We should fetch information about the * certificate here and show all the relevant errors. */ LoadStringW( WININET_hModule, IDS_CERT_ERRORS, buf, 1024 ); break; default: FIXME( "No message for error %d\n", params->dwError ); buf[0] = '\0'; } hitem = GetDlgItem( hdlg, IDC_CERT_ERROR ); SetWindowTextW( hitem, buf ); return TRUE; } params = (struct WININET_ErrorDlgParams*) GetWindowLongPtrW( hdlg, GWLP_USERDATA ); switch( uMsg ) { case WM_COMMAND: if( wParam == IDOK ) { if( params->dwFlags & FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS ) { http_request_t *req = params->req; DWORD flags, size = sizeof(flags); InternetQueryOptionW( req->hdr.hInternet, INTERNET_OPTION_SECURITY_FLAGS, &flags, &size ); switch( params->dwError ) { case ERROR_INTERNET_INVALID_CA: flags |= SECURITY_FLAG_IGNORE_UNKNOWN_CA; break; case ERROR_INTERNET_SEC_CERT_DATE_INVALID: flags |= SECURITY_FLAG_IGNORE_CERT_DATE_INVALID; break; case ERROR_INTERNET_SEC_CERT_CN_INVALID: flags |= SECURITY_FLAG_IGNORE_CERT_CN_INVALID; break; case ERROR_INTERNET_SEC_CERT_REV_FAILED: flags |= SECURITY_FLAG_IGNORE_REVOCATION; break; case ERROR_INTERNET_SEC_CERT_ERRORS: if(flags & _SECURITY_FLAG_CERT_REV_FAILED) flags |= SECURITY_FLAG_IGNORE_REVOCATION; if(flags & _SECURITY_FLAG_CERT_INVALID_CA) flags |= SECURITY_FLAG_IGNORE_UNKNOWN_CA; if(flags & _SECURITY_FLAG_CERT_INVALID_CN) flags |= SECURITY_FLAG_IGNORE_CERT_CN_INVALID; if(flags & _SECURITY_FLAG_CERT_INVALID_DATE) flags |= SECURITY_FLAG_IGNORE_CERT_DATE_INVALID; break; } /* FIXME: Use helper function */ flags |= SECURITY_FLAG_SECURE; req->security_flags |= flags; if(is_valid_netconn(req->netconn)) req->netconn->security_flags |= flags; } EndDialog( hdlg, ERROR_SUCCESS ); return TRUE; } if( wParam == IDCANCEL ) { TRACE("Pressed cancel.\n"); EndDialog( hdlg, ERROR_CANCELLED ); return TRUE; } break; } return FALSE; }
static INT_PTR CALLBACK dlgproc_addport(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) { addportui_t * data; DWORD status; DWORD dummy; DWORD len; DWORD res; switch(msg) { case WM_INITDIALOG: SetWindowLongPtrW(hwnd, DWLP_USER, lparam); return TRUE; case WM_COMMAND: if (wparam == MAKEWPARAM(IDOK, BN_CLICKED)) { data = (addportui_t *) GetWindowLongPtrW(hwnd, DWLP_USER); /* length in WCHAR, without the '\0' */ len = SendDlgItemMessageW(hwnd, ADDPORT_EDIT, WM_GETTEXTLENGTH, 0, 0); data->portname = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR)); if (!data->portname) { EndDialog(hwnd, FALSE); return TRUE; } /* length is in WCHAR, including the '\0' */ GetDlgItemTextW(hwnd, ADDPORT_EDIT, data->portname, len + 1); status = ERROR_SUCCESS; res = XcvDataW( data->hXcv, cmd_PortIsValidW, (PBYTE) data->portname, (lstrlenW(data->portname) + 1) * sizeof(WCHAR), (PBYTE) &dummy, 0, &len, &status); TRACE("got %u with status %u\n", res, status); if (res && (status == ERROR_SUCCESS)) { /* The caller must free data->portname */ EndDialog(hwnd, TRUE); return TRUE; } if (res && (status == ERROR_INVALID_NAME)) { dlg_invalid_portname(hwnd, data->portname); HeapFree(GetProcessHeap(), 0, data->portname); data->portname = NULL; return TRUE; } dlg_win32error(hwnd, status); HeapFree(GetProcessHeap(), 0, data->portname); data->portname = NULL; return TRUE; } if (wparam == MAKEWPARAM(IDCANCEL, BN_CLICKED)) { EndDialog(hwnd, FALSE); return TRUE; } return FALSE; } return FALSE; }
// // Switch System Class Window Proc. // LRESULT WINAPI SwitchWndProc_common(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL unicode ) { PWND pWnd; PALTTABINFO ati; pWnd = ValidateHwnd(hWnd); if (pWnd) { if (!pWnd->fnid) { NtUserSetWindowFNID(hWnd, FNID_SWITCH); } } switch (uMsg) { case WM_NCCREATE: if (!(ati = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ati)))) return 0; SetWindowLongPtrW( hWnd, 0, (LONG_PTR)ati ); return TRUE; case WM_SHOWWINDOW: if (wParam) { PrepareWindow(); ati = (PALTTABINFO)GetWindowLongPtrW(hWnd, 0); ati->cbSize = sizeof(ALTTABINFO); ati->cItems = nItems; ati->cColumns = nCols; ati->cRows = nRows; if (nCols) { ati->iColFocus = (selectedWindow - nShift) % nCols; ati->iRowFocus = (selectedWindow - nShift) / nCols; } else { ati->iColFocus = 0; ati->iRowFocus = 0; } ati->cxItem = CX_ITEM_SPACE; ati->cyItem = CY_ITEM_SPACE; ati->ptStart = ptStart; } return 0; case WM_MOUSEMOVE: ProcessMouseMessage(uMsg, lParam); return 0; case WM_ACTIVATE: if (wParam == WA_INACTIVE) { CompleteSwitch(FALSE); } return 0; case WM_PAINT: OnPaint(hWnd); return 0; case WM_DESTROY: isOpen = FALSE; ati = (PALTTABINFO)GetWindowLongPtrW(hWnd, 0); HeapFree( GetProcessHeap(), 0, ati ); SetWindowLongPtrW( hWnd, 0, 0 ); DestroyAppWindows(); NtUserSetWindowFNID(hWnd, FNID_DESTROY); return 0; } return DefWindowProcW(hWnd, uMsg, wParam, lParam); }
static INT_PTR CALLBACK dlgproc_lptconfig(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) { lptconfig_t * data; WCHAR bufferW[16]; DWORD status; DWORD dummy; DWORD len; DWORD res; switch(msg) { case WM_INITDIALOG: SetWindowLongPtrW(hwnd, DWLP_USER, lparam); data = (lptconfig_t *) lparam; /* Get current setting */ data->value = 45; status = ERROR_SUCCESS; res = XcvDataW( data->hXcv, cmd_GetTransmissionRetryTimeoutW, (PBYTE) &dummy, 0, (PBYTE) &data->value, sizeof(data->value), &len, &status); TRACE("got %u with status %u\n", res, status); /* Set current setting as the initial value in the Dialog */ SetDlgItemInt(hwnd, LPTCONFIG_EDIT, data->value, FALSE); return TRUE; case WM_COMMAND: if (wparam == MAKEWPARAM(IDOK, BN_CLICKED)) { data = (lptconfig_t *) GetWindowLongPtrW(hwnd, DWLP_USER); status = FALSE; res = GetDlgItemInt(hwnd, LPTCONFIG_EDIT, (BOOL *) &status, FALSE); /* length is in WCHAR, including the '\0' */ GetDlgItemTextW(hwnd, LPTCONFIG_EDIT, bufferW, sizeof(bufferW) / sizeof(bufferW[0])); TRACE("got %s and %u (translated: %u)\n", debugstr_w(bufferW), res, status); /* native localui.dll use the same limits */ if ((res > 0) && (res < 1000000) && status) { sprintfW(bufferW, fmt_uW, res); res = XcvDataW( data->hXcv, cmd_ConfigureLPTPortCommandOKW, (PBYTE) bufferW, (lstrlenW(bufferW) +1) * sizeof(WCHAR), (PBYTE) &dummy, 0, &len, &status); TRACE("got %u with status %u\n", res, status); EndDialog(hwnd, TRUE); return TRUE; } /* Set initial value and rerun the Dialog */ SetDlgItemInt(hwnd, LPTCONFIG_EDIT, data->value, FALSE); return TRUE; } if (wparam == MAKEWPARAM(IDCANCEL, BN_CLICKED)) { EndDialog(hwnd, FALSE); return TRUE; } return FALSE; } return FALSE; }
static VOID DisplayOnInit(HWND hwnd, PINFO pInfo) { DISPLAY_DEVICEW displayDevice; DWORD iDevNum = 0; BOOL GotDev = FALSE; SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR)pInfo); pInfo->hDisplayPage = hwnd; SetWindowPos(pInfo->hDisplayPage, NULL, 2, 22, 0, 0, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_NOZORDER); pInfo->hRemote = LoadImageW(hInst, MAKEINTRESOURCEW(IDI_REMOTE), IMAGE_ICON, 32, 32, LR_DEFAULTCOLOR); if (pInfo->hRemote) { SendDlgItemMessageW(pInfo->hDisplayPage, IDC_REMICON, STM_SETICON, (WPARAM)pInfo->hRemote, 0); } pInfo->hColor = LoadImageW(hInst, MAKEINTRESOURCEW(IDI_COLORS), IMAGE_ICON, 32, 32, LR_DEFAULTCOLOR); if (pInfo->hColor) { SendDlgItemMessageW(pInfo->hDisplayPage, IDC_COLORSICON, STM_SETICON, (WPARAM)pInfo->hColor, 0); } pInfo->hSpectrum = LoadImageW(hInst, MAKEINTRESOURCEW(IDB_SPECT), IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR); if (pInfo->hSpectrum) { GetObjectW(pInfo->hSpectrum, sizeof(BITMAP), &pInfo->bitmap); } /* Get video cards list */ displayDevice.cb = (DWORD)sizeof(DISPLAY_DEVICE); while (EnumDisplayDevicesW(NULL, iDevNum, &displayDevice, 0x1)) { if ((displayDevice.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE) != 0) { if (AddDisplayDevice(pInfo, &displayDevice)) GotDev = TRUE; } iDevNum++; } if (GotDev) { FillResolutionsAndColors(pInfo); ReLoadDisplayPage(pInfo); } }
/****************************************************************** * WDML_ClientProc * * Window Proc created on client side for each conversation */ static LRESULT CALLBACK WDML_ClientProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam) { UINT uiLo, uiHi; WDML_CONV* pConv = NULL; HSZ hszSrv, hszTpc; TRACE("%p %04x %08lx %08lx\n", hwnd, iMsg, wParam , lParam); if (iMsg == WM_DDE_ACK && /* in the initial WM_INITIATE sendmessage */ ((pConv = WDML_GetConvFromWnd(hwnd)) == NULL || pConv->wStatus == XST_INIT1)) { /* In response to WM_DDE_INITIATE, save server window */ char buf[256]; WDML_INSTANCE* pInstance; /* note: sent messages do not need packing */ uiLo = LOWORD(lParam); uiHi = HIWORD(lParam); /* FIXME: convlist should be handled here */ if (pConv) { /* we already have started the conv with a server, drop other replies */ GlobalDeleteAtom(uiLo); GlobalDeleteAtom(uiHi); PostMessageW((HWND)wParam, WM_DDE_TERMINATE, (WPARAM)hwnd, 0); return 0; } pInstance = WDML_GetInstanceFromWnd(hwnd); hszSrv = WDML_MakeHszFromAtom(pInstance, uiLo); hszTpc = WDML_MakeHszFromAtom(pInstance, uiHi); pConv = WDML_AddConv(pInstance, WDML_CLIENT_SIDE, hszSrv, hszTpc, hwnd, (HWND)wParam); SetWindowLongPtrW(hwnd, GWL_WDML_CONVERSATION, (ULONG_PTR)pConv); pConv->wStatus |= ST_CONNECTED; pConv->wConvst = XST_INIT1; /* check if server is handled by DDEML */ if ((GetClassNameA((HWND)wParam, buf, sizeof(buf)) && lstrcmpiA(buf, WDML_szServerConvClassA) == 0) || (GetClassNameW((HWND)wParam, (LPWSTR)buf, sizeof(buf)/sizeof(WCHAR)) && lstrcmpiW((LPWSTR)buf, WDML_szServerConvClassW) == 0)) { pConv->wStatus |= ST_ISLOCAL; } WDML_BroadcastDDEWindows(WDML_szEventClass, WM_WDML_CONNECT_CONFIRM, (WPARAM)hwnd, wParam); GlobalDeleteAtom(uiLo); GlobalDeleteAtom(uiHi); /* accept conversation */ return 1; } if (iMsg >= WM_DDE_FIRST && iMsg <= WM_DDE_LAST) { pConv = WDML_GetConvFromWnd(hwnd); if (pConv) { MSG msg; HDDEDATA hdd; msg.hwnd = hwnd; msg.message = iMsg; msg.wParam = wParam; msg.lParam = lParam; WDML_HandleReply(pConv, &msg, &hdd, NULL); } return 0; } return IsWindowUnicode(hwnd) ? DefWindowProcW(hwnd, iMsg, wParam, lParam) : DefWindowProcA(hwnd, iMsg, wParam, lParam); }
static INT_PTR CALLBACK MessageBoxProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam ) { int i, Alert; PMSGBOXINFO mbi; HELPINFO hi; HWND owner; switch(message) { case WM_INITDIALOG: mbi = (PMSGBOXINFO)lParam; SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR)mbi); NtUserxSetMessageBox(hwnd); if(!GetPropW(hwnd, L"ROS_MSGBOX")) { SetPropW(hwnd, L"ROS_MSGBOX", (HANDLE)lParam); if (mbi->dwContextHelpId) SetWindowContextHelpId(hwnd, mbi->dwContextHelpId); if (mbi->Icon) { SendDlgItemMessageW(hwnd, MSGBOX_IDICON, STM_SETICON, (WPARAM)mbi->Icon, 0); Alert = ALERT_SYSTEM_WARNING; } else // Setup the rest of the alerts. { switch(mbi->dwStyle & MB_ICONMASK) { case MB_ICONWARNING: Alert = ALERT_SYSTEM_WARNING; break; case MB_ICONERROR: Alert = ALERT_SYSTEM_ERROR; break; case MB_ICONQUESTION: Alert = ALERT_SYSTEM_QUERY; break; default: Alert = ALERT_SYSTEM_INFORMATIONAL; /* fall through */ } } /* Send out the alert notifications. */ NotifyWinEvent(EVENT_SYSTEM_ALERT, hwnd, OBJID_ALERT, Alert); /* set control fonts */ SendDlgItemMessageW(hwnd, MSGBOX_IDTEXT, WM_SETFONT, (WPARAM)mbi->Font, 0); for(i = 0; i < mbi->nButtons; i++) { SendDlgItemMessageW(hwnd, mbi->Btns[i], WM_SETFONT, (WPARAM)mbi->Font, 0); } switch(mbi->dwStyle & MB_TYPEMASK) { case MB_ABORTRETRYIGNORE: case MB_YESNO: RemoveMenu(GetSystemMenu(hwnd, FALSE), SC_CLOSE, MF_BYCOMMAND); break; } SetFocus(GetDlgItem(hwnd, mbi->DefBtn)); if(mbi->Timeout && (mbi->Timeout != (UINT)-1)) SetTimer(hwnd, 0, mbi->Timeout, NULL); } return 0; case WM_COMMAND: switch (LOWORD(wParam)) { case IDOK: case IDCANCEL: case IDABORT: case IDRETRY: case IDIGNORE: case IDYES: case IDNO: case IDTRYAGAIN: case IDCONTINUE: EndDialog(hwnd, wParam); return 0; case IDHELP: /* send WM_HELP message to messagebox window */ hi.cbSize = sizeof(HELPINFO); hi.iContextType = HELPINFO_WINDOW; hi.iCtrlId = LOWORD(wParam); hi.hItemHandle = (HANDLE)lParam; hi.dwContextId = 0; GetCursorPos(&hi.MousePos); SendMessageW(hwnd, WM_HELP, 0, (LPARAM)&hi); return 0; } return 0; case WM_COPY: MessageBoxTextToClipboard(hwnd); return 0; case WM_HELP: mbi = (PMSGBOXINFO)GetPropW(hwnd, L"ROS_MSGBOX"); if(!mbi) return 0; memcpy(&hi, (void *)lParam, sizeof(hi)); hi.dwContextId = GetWindowContextHelpId(hwnd); if (mbi->lpfnMsgBoxCallback) mbi->lpfnMsgBoxCallback(&hi); else { owner = GetWindow(hwnd, GW_OWNER); if(owner) SendMessageW(GetWindow(hwnd, GW_OWNER), WM_HELP, 0, (LPARAM)&hi); } return 0; case WM_CLOSE: mbi = (PMSGBOXINFO)GetPropW(hwnd, L"ROS_MSGBOX"); if(!mbi) return 0; switch(mbi->dwStyle & MB_TYPEMASK) { case MB_ABORTRETRYIGNORE: case MB_YESNO: return 1; } EndDialog(hwnd, IDCANCEL); return 1; case WM_TIMER: if(wParam == 0) { EndDialog(hwnd, 32000); } return 0; } return 0; }
/***************************************************************** * DdeReconnect (DDEML.37) * DdeReconnect (USER32.@) */ HCONV WINAPI DdeReconnect(HCONV hConv) { WDML_CONV* pConv; WDML_CONV* pNewConv = NULL; ATOM aSrv = 0, aTpc = 0; TRACE("(%p)\n", hConv); pConv = WDML_GetConv(hConv, FALSE); if (pConv != NULL && (pConv->wStatus & ST_CLIENT)) { BOOL ret; /* to reestablish a connection, we have to make sure that: * 1/ pConv is the conversation attached to the client window (it wouldn't be * if a call to DdeReconnect would have already been done...) * FIXME: is this really an error ??? * 2/ the pConv conversation had really been deconnected */ if (pConv == WDML_GetConvFromWnd(pConv->hwndClient) && (pConv->wStatus & ST_TERMINATED) && !(pConv->wStatus & ST_CONNECTED)) { HWND hwndClient = pConv->hwndClient; HWND hwndServer = pConv->hwndServer; SetWindowLongPtrW(pConv->hwndClient, GWL_WDML_CONVERSATION, 0); aSrv = WDML_MakeAtomFromHsz(pConv->hszService); aTpc = WDML_MakeAtomFromHsz(pConv->hszTopic); if (!aSrv || !aTpc) goto theEnd; /* note: sent messages shall not use packing */ ret = SendMessageW(hwndServer, WM_DDE_INITIATE, (WPARAM)hwndClient, MAKELPARAM(aSrv, aTpc)); pConv = WDML_GetConv(hConv, FALSE); if (pConv == NULL) { FIXME("Should fail reconnection\n"); goto theEnd; } if (ret && (pNewConv = WDML_GetConvFromWnd(pConv->hwndClient)) != NULL) { /* re-establish all links... */ WDML_LINK* pLink; for (pLink = pConv->instance->links[WDML_CLIENT_SIDE]; pLink; pLink = pLink->next) { if (pLink->hConv == hConv) { /* try to reestablish the links... */ DdeClientTransaction(NULL, 0, (HCONV)pNewConv, pLink->hszItem, pLink->uFmt, pLink->transactionType, 1000, NULL); } } } else { /* reset the conversation as it was */ SetWindowLongPtrW(pConv->hwndClient, GWL_WDML_CONVERSATION, (ULONG_PTR)pConv); } } } theEnd: if (aSrv) GlobalDeleteAtom(aSrv); if (aTpc) GlobalDeleteAtom(aTpc); return (HCONV)pNewConv; }
static LRESULT iewnd_OnCreate(HWND hwnd, LPCREATESTRUCTW lpcs) { SetWindowLongPtrW(hwnd, 0, (LONG_PTR) lpcs->lpCreateParams); return 0; }
static LRESULT CALLBACK MonthCalWndProc(IN HWND hwnd, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam) { PMONTHCALWND infoPtr; LRESULT Ret = 0; infoPtr = (PMONTHCALWND)GetWindowLongPtrW(hwnd, 0); if (infoPtr == NULL && uMsg != WM_CREATE) { goto HandleDefaultMessage; } switch (uMsg) { #if MONTHCAL_CTRLBG != MONTHCAL_DISABLED_CTRLBG case WM_ERASEBKGND: Ret = !infoPtr->Enabled; break; #endif case WM_PAINT: case WM_PRINTCLIENT: { if (infoPtr->CellSize.cx != 0 && infoPtr->CellSize.cy != 0) { PAINTSTRUCT ps; HDC hDC; if (wParam != 0) { if (!GetUpdateRect(hwnd, &ps.rcPaint, TRUE)) { break; } hDC = (HDC)wParam; } else { hDC = BeginPaint(hwnd, &ps); if (hDC == NULL) { break; } } MonthCalPaint(infoPtr, hDC, &ps.rcPaint); if (wParam == 0) { EndPaint(hwnd, &ps); } } break; } case WM_LBUTTONDBLCLK: case WM_LBUTTONDOWN: { WORD SelDay; SelDay = MonthCalPtToDay(infoPtr, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)); if (SelDay != 0 && SelDay != infoPtr->Day) { MonthCalSetDate(infoPtr, SelDay, infoPtr->Month, infoPtr->Year); } /* Fall through */ } case WM_MBUTTONDOWN: case WM_RBUTTONDOWN: { if (!infoPtr->HasFocus) { SetFocus(hwnd); } break; } case WM_KEYDOWN: { WORD NewDay = 0; switch (wParam) { case VK_UP: { if (infoPtr->Day > 7) { NewDay = infoPtr->Day - 7; } break; } case VK_DOWN: { if (infoPtr->Day + 7 <= MonthCalMonthLength(infoPtr->Month, infoPtr->Year)) { NewDay = infoPtr->Day + 7; } break; } case VK_LEFT: { if (infoPtr->Day > 1) { NewDay = infoPtr->Day - 1; } break; } case VK_RIGHT: { if (infoPtr->Day < MonthCalMonthLength(infoPtr->Month, infoPtr->Year)) { NewDay = infoPtr->Day + 1; } break; } } /* Update the selection */ if (NewDay != 0) { MonthCalSetDate(infoPtr, NewDay, infoPtr->Month, infoPtr->Year); } goto HandleDefaultMessage; } case WM_GETDLGCODE: { INT virtKey; virtKey = (lParam != 0 ? (INT)((LPMSG)lParam)->wParam : 0); switch (virtKey) { case VK_TAB: { /* Change the UI status */ SendMessageW(GetAncestor(hwnd, GA_PARENT), WM_CHANGEUISTATE, MAKEWPARAM(UIS_INITIALIZE, 0), 0); break; } } Ret |= DLGC_WANTARROWS; break; } case WM_SETFOCUS: { infoPtr->HasFocus = TRUE; MonthCalRepaintDay(infoPtr, infoPtr->Day); break; } case WM_KILLFOCUS: { infoPtr->HasFocus = FALSE; MonthCalRepaintDay(infoPtr, infoPtr->Day); break; } case WM_UPDATEUISTATE: { DWORD OldUIState; Ret = DefWindowProcW(hwnd, uMsg, wParam, lParam); OldUIState = infoPtr->UIState; switch (LOWORD(wParam)) { case UIS_SET: infoPtr->UIState |= HIWORD(wParam); break; case UIS_CLEAR: infoPtr->UIState &= ~HIWORD(wParam); break; } if (infoPtr->UIState != OldUIState) { MonthCalRepaintDay(infoPtr, infoPtr->Day); } break; } case MCCM_SETDATE: { WORD Day, Month, Year, DaysCount; Day = LOWORD(wParam); Month = HIWORD(wParam); Year = LOWORD(lParam); if (Day == (WORD)-1) Day = infoPtr->Day; if (Month == (WORD)-1) Month = infoPtr->Month; if (Year == (WORD)-1) Year = infoPtr->Year; DaysCount = MonthCalMonthLength(Month, Year); if (Day > DaysCount) Day = DaysCount; if (MonthCalValidDate(Day, Month, Year)) { if (Day != infoPtr->Day || Month != infoPtr->Month || Year != infoPtr->Year) { Ret = MonthCalSetDate(infoPtr, Day, Month, Year); } } break; } case MCCM_GETDATE: { LPSYSTEMTIME lpSystemTime = (LPSYSTEMTIME)wParam; lpSystemTime->wYear = infoPtr->Year; lpSystemTime->wMonth = infoPtr->Month; lpSystemTime->wDay = infoPtr->Day; Ret = TRUE; break; } case MCCM_RESET: { MonthCalSetLocalTime(infoPtr, NULL); Ret = TRUE; break; } case MCCM_CHANGED: { Ret = infoPtr->Changed; break; } case WM_TIMER: { switch (wParam) { case ID_DAYTIMER: { /* Kill the timer */ KillTimer(hwnd, ID_DAYTIMER); infoPtr->DayTimerSet = FALSE; if (!infoPtr->Changed) { /* Update the system time and setup the new day timer */ MonthCalSetLocalTime(infoPtr, NULL); /* Update the control */ MonthCalUpdate(infoPtr); } break; } } break; } case WM_SETFONT: { Ret = (LRESULT)MonthCalChangeFont(infoPtr, (HFONT)wParam, (BOOL)LOWORD(lParam)); break; } case WM_SIZE: { infoPtr->ClientSize.cx = LOWORD(lParam); infoPtr->ClientSize.cy = HIWORD(lParam); infoPtr->CellSize.cx = infoPtr->ClientSize.cx / 7; infoPtr->CellSize.cy = infoPtr->ClientSize.cy / 7; /* Repaint the control */ InvalidateRect(hwnd, NULL, TRUE); break; } case WM_GETFONT: { Ret = (LRESULT)infoPtr->hFont; break; } case WM_ENABLE: { infoPtr->Enabled = ((BOOL)wParam != FALSE); MonthCalReload(infoPtr); break; } case WM_STYLECHANGED: { if (wParam == GWL_STYLE) { unsigned int OldEnabled = infoPtr->Enabled; infoPtr->Enabled = !(((LPSTYLESTRUCT)lParam)->styleNew & WS_DISABLED); if (OldEnabled != infoPtr->Enabled) { MonthCalReload(infoPtr); } } break; } case WM_CREATE: { infoPtr = (MONTHCALWND*) HeapAlloc(GetProcessHeap(), 0, sizeof(MONTHCALWND)); if (infoPtr == NULL) { Ret = (LRESULT)-1; break; } SetWindowLongPtrW(hwnd, 0, (LONG_PTR)infoPtr); ZeroMemory(infoPtr, sizeof(MONTHCALWND)); infoPtr->hSelf = hwnd; infoPtr->hNotify = ((LPCREATESTRUCTW)lParam)->hwndParent; infoPtr->Enabled = !(((LPCREATESTRUCTW)lParam)->style & WS_DISABLED); MonthCalSetLocalTime(infoPtr, NULL); MonthCalReload(infoPtr); break; } case WM_DESTROY: { HeapFree(GetProcessHeap(), 0, infoPtr); SetWindowLongPtrW(hwnd, 0, (DWORD_PTR)NULL); break; } default: { HandleDefaultMessage: Ret = DefWindowProcW(hwnd, uMsg, wParam, lParam); break; } } return Ret; }