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