void CAnimationEditorDlg::OnMouseMove(UINT nFlags, CPoint point)
{
//While the mouse is moving, this routine is called.
//This routine will redraw the drag image at the present
// mouse location to display the dragging.
//Also, while over a CListCtrl, this routine will highlight
// the item we are hovering over.
//// If we are in a drag/drop procedure (m_bDragging is true)
if (m_bDragging)
{
//// Move the drag image
CPoint pt(point); //get our current mouse coordinates
ClientToScreen(&pt); //convert to screen coordinates
m_pDragImage->DragMove(pt); //move the drag image to those coordinates
// Unlock window updates (this allows the dragging image to be shown smoothly)
m_pDragImage->DragShowNolock(false);
//// Get the CWnd pointer of the window that is under the mouse cursor
CWnd* pDropWnd = WindowFromPoint (pt);
ASSERT(pDropWnd); //make sure we have a window
//// If we drag outside current window we need to adjust the highlights displayed
if (pDropWnd != m_pDropWnd)
{
if (m_nDropIndex != -1) //If we drag over the CListCtrl header, turn off the hover highlight
{
TRACE("m_nDropIndex is -1\n");
CListCtrl* pList = (CListCtrl*)m_pDropWnd;
VERIFY (pList->SetItemState (m_nDropIndex, 0, LVIS_DROPHILITED));
// redraw item
VERIFY (pList->RedrawItems (m_nDropIndex, m_nDropIndex));
pList->UpdateWindow ();
m_nDropIndex = -1;
}
else //If we drag out of the CListCtrl altogether
{
TRACE("m_nDropIndex is not -1\n");
CListCtrl* pList = (CListCtrl*)m_pDropWnd;
int i = 0;
int nCount = pList->GetItemCount();
for(i = 0; i < nCount; i++)
{
pList->SetItemState(i, 0, LVIS_DROPHILITED);
}
pList->RedrawItems(0, nCount);
pList->UpdateWindow();
}
}
// Save current window pointer as the CListCtrl we are dropping onto
m_pDropWnd = pDropWnd;
// Convert from screen coordinates to drop target client coordinates
pDropWnd->ScreenToClient(&pt);
//If we are hovering over a CListCtrl we need to adjust the highlights
if(pDropWnd->IsKindOf(RUNTIME_CLASS (CListCtrl)))
{
//Note that we can drop here
SetCursor(LoadCursor(NULL, IDC_ARROW));
UINT uFlags;
CListCtrl* pList = (CListCtrl*)pDropWnd;
// Turn off hilight for previous drop target
pList->SetItemState (m_nDropIndex, 0, LVIS_DROPHILITED);
// Redraw previous item
pList->RedrawItems (m_nDropIndex, m_nDropIndex);
// Get the item that is below cursor
m_nDropIndex = ((CListCtrl*)pDropWnd)->HitTest(pt, &uFlags);
// Highlight it
if(m_nDropIndex >= 0)
pList->SetItemState(m_nDropIndex, LVIS_DROPHILITED, LVIS_DROPHILITED);
// Redraw item
pList->RedrawItems(m_nDropIndex, m_nDropIndex);
pList->UpdateWindow();
}
else
{
//If we are not hovering over a CListCtrl, change the cursor
// to note that we cannot drop here
SetCursor(LoadCursor(NULL, IDC_NO));
}
// Lock window updates
m_pDragImage->DragShowNolock(true);
}
CDialog::OnMouseMove(nFlags, point);
}
/*****
* Internal functions to help with IME window management
*/
static void PaintDefaultIMEWnd(HIMC hIMC, HWND hwnd)
{
PAINTSTRUCT ps;
RECT rect;
HDC hdc;
LPCOMPOSITIONSTRING compstr;
LPBYTE compdata = NULL;
HMONITOR monitor;
MONITORINFO mon_info;
INT offX=0, offY=0;
LPINPUTCONTEXT lpIMC;
lpIMC = LockRealIMC(hIMC);
if (lpIMC == NULL)
return;
hdc = BeginPaint(hwnd,&ps);
GetClientRect(hwnd,&rect);
FillRect(hdc, &rect, (HBRUSH)(COLOR_WINDOW + 1));
compdata = ImmLockIMCC(lpIMC->hCompStr);
compstr = (LPCOMPOSITIONSTRING)compdata;
if (compstr->dwCompStrLen && compstr->dwCompStrOffset)
{
SIZE size;
POINT pt;
HFONT oldfont = NULL;
LPWSTR CompString;
LPIMEPRIVATE myPrivate;
CompString = (LPWSTR)(compdata + compstr->dwCompStrOffset);
myPrivate = ImmLockIMCC(lpIMC->hPrivate);
if (myPrivate->textfont)
oldfont = SelectObject(hdc,myPrivate->textfont);
ImmUnlockIMCC(lpIMC->hPrivate);
GetTextExtentPoint32W(hdc, CompString, compstr->dwCompStrLen, &size);
pt.x = size.cx;
pt.y = size.cy;
LPtoDP(hdc,&pt,1);
/*
* How this works based on tests on windows:
* CFS_POINT: then we start our window at the point and grow it as large
* as it needs to be for the string.
* CFS_RECT: we still use the ptCurrentPos as a starting point and our
* window is only as large as we need for the string, but we do not
* grow such that our window exceeds the given rect. Wrapping if
* needed and possible. If our ptCurrentPos is outside of our rect
* then no window is displayed.
* CFS_FORCE_POSITION: appears to behave just like CFS_POINT
* maybe because the default MSIME does not do any IME adjusting.
*/
if (lpIMC->cfCompForm.dwStyle != CFS_DEFAULT)
{
POINT cpt = lpIMC->cfCompForm.ptCurrentPos;
ClientToScreen(lpIMC->hWnd,&cpt);
rect.left = cpt.x;
rect.top = cpt.y;
rect.right = rect.left + pt.x;
rect.bottom = rect.top + pt.y;
monitor = MonitorFromPoint(cpt, MONITOR_DEFAULTTOPRIMARY);
}
else /* CFS_DEFAULT */
{
/* Windows places the default IME window in the bottom left */
HWND target = lpIMC->hWnd;
if (!target) target = GetFocus();
GetWindowRect(target,&rect);
rect.top = rect.bottom;
rect.right = rect.left + pt.x + 20;
rect.bottom = rect.top + pt.y + 20;
offX=offY=10;
monitor = MonitorFromWindow(target, MONITOR_DEFAULTTOPRIMARY);
}
if (lpIMC->cfCompForm.dwStyle == CFS_RECT)
{
RECT client;
client =lpIMC->cfCompForm.rcArea;
MapWindowPoints( lpIMC->hWnd, 0, (POINT *)&client, 2 );
IntersectRect(&rect,&rect,&client);
/* TODO: Wrap the input if needed */
}
if (lpIMC->cfCompForm.dwStyle == CFS_DEFAULT)
{
/* make sure we are on the desktop */
mon_info.cbSize = sizeof(mon_info);
GetMonitorInfoW(monitor, &mon_info);
if (rect.bottom > mon_info.rcWork.bottom)
{
int shift = rect.bottom - mon_info.rcWork.bottom;
rect.top -= shift;
rect.bottom -= shift;
}
if (rect.left < 0)
{
rect.right -= rect.left;
rect.left = 0;
}
if (rect.right > mon_info.rcWork.right)
{
int shift = rect.right - mon_info.rcWork.right;
rect.left -= shift;
rect.right -= shift;
}
}
SetWindowPos(hwnd, HWND_TOPMOST, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, SWP_NOACTIVATE);
TextOutW(hdc, offX,offY, CompString, compstr->dwCompStrLen);
if (oldfont)
SelectObject(hdc,oldfont);
}
ImmUnlockIMCC(lpIMC->hCompStr);
EndPaint(hwnd,&ps);
UnlockRealIMC(hIMC);
}
/**
* This is the message procedure for my nice looking message box
*
* @param hDlg - window handle
* @param uMsg - message to handle
* @param wParam - message specific parameter
* @param lParam - message specific parameter
*
* @return TRUE, FALSE, IDOK, IDYES, IDALL, IDNO or IDCANCEL
**/
static INT_PTR CALLBACK MsgBoxProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static int retOk = IDOK;
static int retAll = IDALL;
static int retNon = IDNONE;
static int retCancel = IDCANCEL;
switch (uMsg) {
case WM_INITDIALOG:
{
LPMSGBOX pMsgBox = (LPMSGBOX)lParam;
if (PtrIsValid(pMsgBox)) {
int icoWidth = 0;
int InfoBarHeight = 0;
HFONT hNormalFont;
hNormalFont = (HFONT)SendDlgItemMessage(hDlg, TXT_NAME, WM_GETFONT, 0, 0);
if (pMsgBox->uType & MB_INFOBAR) {
LOGFONT lf;
// set bold font for name in description area
GetObject(hNormalFont, sizeof(lf), &lf);
lf.lfWeight = FW_BOLD;
hNormalFont = CreateFontIndirect(&lf);
// set infobar's textfont
SendDlgItemMessage(hDlg, TXT_NAME, WM_SETFONT, (WPARAM)hNormalFont, 0);
// set infobar's logo icon
SendDlgItemMessage(hDlg, ICO_DLGLOGO, STM_SETIMAGE, IMAGE_ICON,
(pMsgBox->hiLogo ? (LPARAM)pMsgBox->hiLogo : (LPARAM)IcoLib_GetIcon(ICO_DLG_DETAILS)));
// enable headerbar
ShowWindow(GetDlgItem(hDlg, TXT_NAME), SW_SHOW);
ShowWindow(GetDlgItem(hDlg, ICO_DLGLOGO), SW_SHOW);
}
else {
RECT rc;
GetClientRect(GetDlgItem(hDlg, TXT_NAME), &rc);
InfoBarHeight = rc.bottom;
if (pMsgBox->hiLogo)
SendMessage(hDlg, WM_SETICON, ICON_BIG, (LPARAM)pMsgBox->hiLogo);
}
// draw the desired status icon
HICON hIcon = MsgLoadIcon(pMsgBox);
if (hIcon)
SendDlgItemMessage(hDlg, ICO_MSGDLG, STM_SETIMAGE, IMAGE_ICON, (LPARAM)hIcon);
else {
RECT ws;
GetWindowRect(GetDlgItem(hDlg, ICO_MSGDLG), &ws);
icoWidth = ws.right - ws.left;
ShowWindow(GetDlgItem(hDlg, ICO_MSGDLG), SW_HIDE);
}
// resize the messagebox and reorganize the buttons
if (HDC hDC = GetDC(hDlg)) {
POINT mpt = { 0, 0 };
RECT ws = { 0, 0, 0, 0 };
int txtWidth = 0, txtHeight = 0, needX, needY;
RECT rcDlg;
SIZE ts;
LPTSTR h, rs;
SelectObject(hDC, hNormalFont);
// get message text width and height
if (pMsgBox->ptszMsg) for (rs = h = pMsgBox->ptszMsg;; ++h) {
if (*h == '\n' || !*h) {
GetTextExtentPoint32(hDC, rs, h - rs, &ts);
if (ts.cx > txtWidth)
txtWidth = ts.cx;
txtHeight += ts.cy;
if (!*h)
break;
rs = h + 1;
}
}
// increase width if info text requires more
if ((pMsgBox->uType&MB_INFOBAR) && pMsgBox->ptszInfoText && *pMsgBox->ptszInfoText) {
int multiline = 0;
RECT rcico; GetClientRect(GetDlgItem(hDlg, ICO_DLGLOGO), &rcico);
rcico.right = rcico.right * 100 / 66; // padding
for (rs = h = pMsgBox->ptszInfoText;; ++h) {
if (*h == '\n' || !*h) {
GetTextExtentPoint32(hDC, rs, h - rs, &ts);
ts.cx += rcico.right;
if (ts.cx > txtWidth)
txtWidth = ts.cx;
if (!*h)
break;
rs = h + 1;
++multiline;
}
}
if (!multiline)
SetWindowLongPtr(GetDlgItem(hDlg, TXT_NAME), GWL_STYLE, GetWindowLongPtr(GetDlgItem(hDlg, TXT_NAME), GWL_STYLE) | SS_CENTERIMAGE);
}
ReleaseDC(hDlg, hDC);
// calc new dialog size
GetWindowRect(hDlg, &rcDlg);
GetWindowRect(GetDlgItem(hDlg, TXT_MESSAGE), &ws);
needX = txtWidth - (ws.right - ws.left) - icoWidth;
needY = max(0, txtHeight - (ws.bottom - ws.top) + 5);
rcDlg.left -= needX / 2; rcDlg.right += needX / 2;
rcDlg.top -= (needY - InfoBarHeight) / 2; rcDlg.bottom += (needY - InfoBarHeight) / 2;
// resize dialog window
MoveWindow(hDlg, rcDlg.left, rcDlg.top, rcDlg.right - rcDlg.left, rcDlg.bottom - rcDlg.top, FALSE);
ClientToScreen(hDlg, &mpt);
MoveCtrl(hDlg, STATIC_WHITERECT, -mpt.x, -mpt.y, needX, needY - InfoBarHeight);
MoveCtrl(hDlg, TXT_NAME, -mpt.x, -mpt.y, needX, 0);
MoveCtrl(hDlg, ICO_DLGLOGO, -mpt.x + needX, -mpt.y, 0, 0);
MoveCtrl(hDlg, ICO_MSGDLG, -mpt.x, -mpt.y - InfoBarHeight, 0, 0);
MoveCtrl(hDlg, TXT_MESSAGE, -mpt.x - icoWidth, -mpt.y - InfoBarHeight, needX, needY);
MoveCtrl(hDlg, STATIC_LINE2, -mpt.x, -mpt.y + needY - InfoBarHeight, needX, 0);
//
// Do pushbutton positioning
//
RECT rcOk, rcAll, rcNone, rcCancel;
// get button rectangles
GetWindowRect(GetDlgItem(hDlg, IDOK), &rcOk);
OffsetRect(&rcOk, -mpt.x, -mpt.y + needY - InfoBarHeight);
GetWindowRect(GetDlgItem(hDlg, IDALL), &rcAll);
OffsetRect(&rcAll, -mpt.x, -mpt.y + needY - InfoBarHeight);
GetWindowRect(GetDlgItem(hDlg, IDNONE), &rcNone);
OffsetRect(&rcNone, -mpt.x, -mpt.y + needY - InfoBarHeight);
GetWindowRect(GetDlgItem(hDlg, IDCANCEL), &rcCancel);
OffsetRect(&rcCancel, -mpt.x, -mpt.y + needY - InfoBarHeight);
LONG okWidth = rcOk.right - rcOk.left;
LONG allWidth = rcAll.right - rcAll.left;
LONG noneWidth = rcNone.right - rcNone.left;
LONG caWidth = rcCancel.right - rcCancel.left;
LONG dlgMid = (rcDlg.right - rcDlg.left) / 2;
// load button configuration
switch (MB_TYPE(pMsgBox->uType)) {
case MB_OK:
rcOk.left = dlgMid - (okWidth / 2);
rcOk.right = rcOk.left + okWidth;
ShowWindow(GetDlgItem(hDlg, IDOK), SW_SHOW);
break;
case MB_OKCANCEL:
retOk = IDRETRY;
SetDlgItemText(hDlg, IDOK, LPGENT("OK"));
retCancel = IDCANCEL;
SetDlgItemText(hDlg, IDCANCEL, LPGENT("Cancel"));
rcOk.left = dlgMid - okWidth - 10;
rcOk.right = rcOk.left + okWidth;
rcCancel.left = dlgMid + 10;
rcCancel.right = rcCancel.left + caWidth;
ShowWindow(GetDlgItem(hDlg, IDOK), SW_SHOW);
ShowWindow(GetDlgItem(hDlg, IDCANCEL), SW_SHOW);
break;
case MB_RETRYCANCEL:
retOk = IDRETRY;
SetDlgItemText(hDlg, IDOK, LPGENT("Retry"));
retCancel = IDCANCEL;
SetDlgItemText(hDlg, IDCANCEL, LPGENT("Cancel"));
rcOk.left = dlgMid - okWidth - 10;
rcOk.right = rcOk.left + okWidth;
rcCancel.left = dlgMid + 10;
rcCancel.right = rcCancel.left + caWidth;
ShowWindow(GetDlgItem(hDlg, IDOK), SW_SHOW);
ShowWindow(GetDlgItem(hDlg, IDCANCEL), SW_SHOW);
break;
case MB_YESNO:
retOk = IDYES;
SetDlgItemText(hDlg, IDOK, LPGENT("Yes"));
retCancel = IDNO;
SetDlgItemText(hDlg, IDCANCEL, LPGENT("No"));
rcOk.left = dlgMid - okWidth - 10;
rcOk.right = rcOk.left + okWidth;
rcCancel.left = dlgMid + 10;
rcCancel.right = rcCancel.left + caWidth;
ShowWindow(GetDlgItem(hDlg, IDOK), SW_SHOW);
ShowWindow(GetDlgItem(hDlg, IDCANCEL), SW_SHOW);
break;
case MB_ABORTRETRYIGNORE:
retOk = IDABORT;
SetDlgItemText(hDlg, IDOK, LPGENT("Abort"));
retAll = IDABORT;
SetDlgItemText(hDlg, IDALL, LPGENT("Retry"));
retCancel = IDCANCEL;
SetDlgItemText(hDlg, IDCANCEL, LPGENT("Ignore"));
rcAll.left = dlgMid - (allWidth / 2);
rcAll.right = rcAll.left + allWidth;
rcOk.left = rcAll.left - okWidth - 5;
rcOk.right = rcOk.left + okWidth;
rcCancel.left = rcAll.right + 5;
rcCancel.right = rcCancel.left + caWidth;
ShowWindow(GetDlgItem(hDlg, IDOK), SW_SHOW);
ShowWindow(GetDlgItem(hDlg, IDALL), SW_SHOW);
ShowWindow(GetDlgItem(hDlg, IDCANCEL), SW_SHOW);
break;
case MB_YESNOCANCEL:
retOk = IDYES;
SetDlgItemText(hDlg, IDOK, LPGENT("Yes"));
retAll = IDNO;
SetDlgItemText(hDlg, IDALL, LPGENT("No"));
retCancel = IDCANCEL;
SetDlgItemText(hDlg, IDCANCEL, LPGENT("Cancel"));
rcAll.left = dlgMid - (allWidth / 2);
rcAll.right = rcAll.left + allWidth;
rcOk.left = rcAll.left - okWidth - 5;
rcOk.right = rcOk.left + okWidth;
rcCancel.left = rcAll.right + 5;
rcCancel.right = rcCancel.left + caWidth;
ShowWindow(GetDlgItem(hDlg, IDOK), SW_SHOW);
ShowWindow(GetDlgItem(hDlg, IDALL), SW_SHOW);
ShowWindow(GetDlgItem(hDlg, IDCANCEL), SW_SHOW);
break;
case MB_YESALLNO:
retOk = IDYES;
SetDlgItemText(hDlg, IDOK, LPGENT("Yes"));
retAll = IDALL;
SetDlgItemText(hDlg, IDALL, LPGENT("All"));
//retNon = IDNONE;
SetDlgItemText(hDlg, IDNONE, LPGENT("None"));
retCancel = IDNO;
SetDlgItemText(hDlg, IDCANCEL, LPGENT("No"));
rcCancel.right = rcDlg.right - rcDlg.left - 10;
rcCancel.left = rcCancel.right - caWidth;
rcNone.right = rcCancel.left - 5;
rcNone.left = rcNone.right - noneWidth;
rcAll.right = rcNone.left - 5;
rcAll.left = rcAll.right - allWidth;
rcOk.right = rcAll.left - 5;
rcOk.left = rcOk.right - okWidth;
// show buttons
ShowWindow(GetDlgItem(hDlg, IDOK), SW_SHOW);
ShowWindow(GetDlgItem(hDlg, IDALL), SW_SHOW);
ShowWindow(GetDlgItem(hDlg, IDNONE), SW_SHOW);
ShowWindow(GetDlgItem(hDlg, IDCANCEL), SW_SHOW);
break;
default:
rcOk.left = dlgMid - (okWidth / 2);
rcOk.right = rcOk.left + okWidth;
}
MoveWindow(GetDlgItem(hDlg, IDOK), rcOk.left, rcOk.top, rcOk.right - rcOk.left, rcOk.bottom - rcOk.top, FALSE);
MoveWindow(GetDlgItem(hDlg, IDALL), rcAll.left, rcAll.top, rcAll.right - rcAll.left, rcAll.bottom - rcAll.top, FALSE);
MoveWindow(GetDlgItem(hDlg, IDNONE), rcNone.left, rcNone.top, rcNone.right - rcNone.left, rcNone.bottom - rcNone.top, FALSE);
MoveWindow(GetDlgItem(hDlg, IDCANCEL), rcCancel.left, rcCancel.top, rcCancel.right - rcCancel.left, rcCancel.bottom - rcCancel.top, FALSE);
}
// set text's
SetWindowText(hDlg, pMsgBox->ptszTitle);
SetDlgItemText(hDlg, TXT_NAME, pMsgBox->ptszInfoText);
SetDlgItemText(hDlg, TXT_MESSAGE, pMsgBox->ptszMsg);
TranslateDialogDefault(hDlg);
return TRUE;
}
}
break;
case WM_CTLCOLORSTATIC:
switch (GetWindowLongPtr((HWND)lParam, GWLP_ID)) {
case STATIC_WHITERECT:
case ICO_DLGLOGO:
case ICO_MSGDLG:
case TXT_MESSAGE:
case TXT_NAME:
SetTextColor((HDC)wParam, GetSysColor(COLOR_WINDOWTEXT));
return GetSysColor(COLOR_WINDOW);
}
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDOK:
EndDialog(hDlg, retOk);
break;
case IDCANCEL:
EndDialog(hDlg, retCancel);
break;
case IDALL:
EndDialog(hDlg, retAll);
break;
case IDNONE:
EndDialog(hDlg, retNon);
}
break;
case WM_DESTROY:
DeleteObject((HFONT)SendDlgItemMessage(hDlg, TXT_NAME, WM_GETFONT, 0, 0));
break;
}
return FALSE;
}
INT_PTR CALLBACK OptionsProc(HWND hdlg,UINT msg,WPARAM wparam,LPARAM lparam)
{
switch(msg){
case WM_INITDIALOG:{
DWORD style;
g_opHdlg=hdlg;
bOptionsInit=TRUE;
TranslateDialogDefault(hdlg);
if(g_iButtonsCount!=db_get_b(NULL, PLGNAME,"ButtonsCount", 0))
{
LOGFONT logFont;
HFONT hFont;
bNeedRestart=TRUE;
EnableWindow(GetDlgItem(hdlg,IDC_BUTTONSLIST),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_BLISTADD),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_BLISTREMOVE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_MENUTREE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_MTREEADD),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_MTREEREMOVE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_RCLICKVALUE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_BUTTONNAME),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_MENUNAME),FALSE);
ShowWindow(GetDlgItem(hdlg,IDC_WARNING),SW_SHOW);
hFont = (HFONT)SendDlgItemMessage(hdlg, IDC_WARNING, WM_GETFONT, 0, 0);
GetObject(hFont, sizeof(logFont), &logFont);
logFont.lfWeight = FW_BOLD;
hFont = CreateFontIndirect(&logFont);
SendDlgItemMessage(hdlg, IDC_WARNING, WM_SETFONT, (WPARAM)hFont, 0);
break;
}
g_iOPButtonsCount=g_iButtonsCount;
hButtonsList=GetDlgItem(hdlg,IDC_BUTTONSLIST);
hMenuTree=GetDlgItem(hdlg,IDC_MENUTREE);
style = GetWindowLongPtr(hButtonsList,GWL_STYLE);
style |=TVS_NOHSCROLL;
SetWindowLongPtr(hButtonsList,GWL_STYLE, style);
style = GetWindowLongPtr(hMenuTree,GWL_STYLE);
style |=TVS_NOHSCROLL;
SetWindowLongPtr(hMenuTree,GWL_STYLE, style);
BuildButtonsList(hButtonsList);
if (!TreeView_GetCount(hButtonsList))
EnableWindow(GetDlgItem(hdlg,IDC_RCLICKVALUE),FALSE);
mir_subclassWindow( GetDlgItem(hdlg,IDC_BUTTONNAME), EditSubclassProc);
mir_subclassWindow( GetDlgItem(hdlg,IDC_MENUNAME), EditSubclassProc);
EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
CheckDlgButton(hdlg,IDC_RAUTOSEND,(g_bRClickAuto=db_get_b(NULL,PLGNAME,"RClickAuto",0)) ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hdlg,IDC_LAUTOSEND,(g_bLClickAuto=db_get_b(NULL,PLGNAME,"LClickAuto",0)) ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hdlg,IDC_ENABLEQUICKMENU,(g_bQuickMenu=db_get_b(NULL, PLGNAME,"QuickMenu", 1)) ? BST_CHECKED : BST_UNCHECKED);
bOptionsInit=FALSE;
}break;
case WM_LBUTTONUP:
if(drag) {
TVHITTESTINFO hti;
HTREEITEM htiAfter=NULL;
ButtonData* bd=NULL;
TVITEM tvi;
RECT rc;
BYTE height;
BOOLEAN bAsChild = FALSE;
TreeView_SetInsertMark(hMenuTree, NULL, 0 );
ReleaseCapture();
SetCursor( LoadCursor( NULL, IDC_ARROW ));
hti.pt.x = ( SHORT )LOWORD( lparam );
hti.pt.y = ( SHORT )HIWORD( lparam );
ClientToScreen(hdlg,&hti.pt);
ScreenToClient(hMenuTree,&hti.pt);
TreeView_HitTest( hMenuTree, &hti );
if(TreeView_GetParent(hMenuTree,hti.hItem)&&TreeView_GetChild(hMenuTree,hDragItem))
break;
if(TreeView_GetChild(hMenuTree,hti.hItem)&&TreeView_GetChild(hMenuTree,hDragItem))
break;
if ( hti.flags & TVHT_ABOVE ) {
htiAfter = TVI_FIRST;
}
else
if ( hti.flags & ( TVHT_NOWHERE|TVHT_BELOW )) {
htiAfter = TVI_LAST;
}
else
if ( hti.flags & ( TVHT_ONITEM|TVHT_ONITEMRIGHT )) {
// check where over the item, the pointer is
if ( !TreeView_GetItemRect( hMenuTree, hti.hItem, &rc, FALSE )) {
drag=0;
break;
}
height = ( BYTE )( rc.bottom - rc.top );
if ( hti.pt.y - ( height / 3 ) < rc.top ) {
HTREEITEM hItem = hti.hItem;
if ( !( hti.hItem = TreeView_GetPrevSibling( hMenuTree, hItem )) ) {
if ( !( hti.hItem = TreeView_GetParent(hMenuTree, hItem )))
htiAfter = TVI_FIRST;
else
bAsChild = TRUE;
}
}
else
if ( hti.pt.y + ( height / 3 ) <= rc.bottom ) {
bAsChild = TRUE;
}
}
if(TreeView_GetChild(hMenuTree,hDragItem)&&bAsChild)
break;
if(hti.hItem){
tvi.hItem=hti.hItem;
tvi.mask=TVIF_PARAM |TVIF_HANDLE;
TreeView_GetItem(hMenuTree,&tvi);
if ((bd=(ButtonData*)tvi.lParam)&&(bd->fEntryOpType&QMF_EX_SEPARATOR))
bAsChild = FALSE;
}
if(TreeView_GetParent(hMenuTree,hti.hItem))
bAsChild = FALSE;
MoveItem( hDragItem, htiAfter?htiAfter:hti.hItem, bAsChild );
SendMessage(GetParent(hdlg),PSM_CHANGED,0,0);
drag=0;
}
break;
///////////////////////////////////
//From UserInfoEx by DeathAxe
//
case WM_MOUSEMOVE:
{
if (!drag) break;
{
TVHITTESTINFO hti;
hti.pt.x=(short)LOWORD(lparam);
hti.pt.y=(short)HIWORD(lparam);
ClientToScreen(hdlg,&hti.pt);
ScreenToClient(hMenuTree,&hti.pt);
TreeView_HitTest(hMenuTree,&hti);
if ( hti.flags & ( TVHT_ONITEM|TVHT_ONITEMRIGHT )) {
RECT rc;
BYTE height;
if ( TreeView_GetItemRect(hMenuTree, hti.hItem, &rc, FALSE )) {
height = ( BYTE )( rc.bottom - rc.top );
if ( hti.pt.y - ( height / 3 ) < rc.top ) {
SetCursor( LoadCursor( NULL, IDC_ARROW ));
TreeView_SetInsertMark( hMenuTree, hti.hItem, 0 );
}
else
if ( hti.pt.y + ( height / 3 ) > rc.bottom ) {
SetCursor( LoadCursor( NULL, IDC_ARROW ));
TreeView_SetInsertMark( hMenuTree, hti.hItem, 1 );
}
else {
TreeView_SetInsertMark( hMenuTree, NULL, 0 );
SetCursor( LoadCursor( GetModuleHandle(NULL), MAKEINTRESOURCE( 183 )) );
}
}
}
else {
if ( hti.flags & TVHT_ABOVE ) SendMessage( hMenuTree, WM_VSCROLL, MAKEWPARAM( SB_LINEUP, 0 ), 0 );
if ( hti.flags & TVHT_BELOW ) SendMessage( hMenuTree, WM_VSCROLL, MAKEWPARAM( SB_LINEDOWN, 0 ), 0 );
TreeView_SetInsertMark( hMenuTree, NULL, 0 );
}
}
}break;
/////////////
case WM_DESTROY:
if (g_varhelpDlg)
DestroyWindow(g_varhelpDlg);
g_varhelpDlg=NULL;
break;
case WM_NOTIFY:
switch(((LPNMHDR)lparam)->idFrom) {
case 0:
if (((LPNMHDR)lparam)->code == PSN_APPLY ) {
if (!bNeedRestart){
SetMenuEntryProperties(hdlg);
SaveMenuTree(hdlg);
}
db_set_b(NULL,PLGNAME,"RClickAuto",(BYTE)(g_bRClickAuto=IsDlgButtonChecked(hdlg,IDC_RAUTOSEND)));
db_set_b(NULL,PLGNAME,"LClickAuto",(BYTE)(g_bLClickAuto=IsDlgButtonChecked(hdlg,IDC_LAUTOSEND)));
db_set_b(NULL,PLGNAME,"QuickMenu",(BYTE)(g_bQuickMenu=IsDlgButtonChecked(hdlg,IDC_ENABLEQUICKMENU)));
return 1;
}
else if (((LPNMHDR)lparam)->code == PSN_RESET ) {
if (!bNeedRestart)
RestoreModuleData(hdlg);
return 1;
}
break;
case IDC_MENUTREE:
switch (((LPNMHDR)lparam)->code){
case TVN_KEYDOWN:{
TV_KEYDOWN* pTVKeyDown = (TV_KEYDOWN*) ((LPNMHDR)lparam);
if ( pTVKeyDown->wVKey == VK_F2 )
TreeView_EditLabel(hMenuTree,TreeView_GetSelection(hMenuTree));
else if ( pTVKeyDown->wVKey == VK_DELETE )
SendMessage(hdlg,WM_COMMAND,IDC_MTREEREMOVE,0);
}break;
case TVN_BEGINLABELEDITA:
case TVN_BEGINLABELEDITW:
hwndEdit=TreeView_GetEditControl(hMenuTree);
mir_subclassWindow(hwndEdit, LabelEditSubclassProc);
break;
case TVN_ENDLABELEDITA:
case TVN_ENDLABELEDITW:
{
TVITEM tvi;
ButtonData* bd=NULL;
TCHAR strbuf[256];
TCHAR szLabel[256];
tvi.pszText = strbuf;
tvi.cchTextMax = SIZEOF(strbuf);
tvi.mask=TVIF_TEXT |TVIF_HANDLE|TVIF_PARAM;
tvi.hItem=TreeView_GetSelection(hMenuTree);
TreeView_GetItem(hMenuTree,&tvi);
GetWindowText(hwndEdit, szLabel, SIZEOF(szLabel));
hwndEdit=NULL;
if (!_tcslen(szLabel)) break;
if (bd = (ButtonData*)tvi.lParam){
if (!_tcscmp(szLabel,_T("---"))) {
if(TreeView_GetChild(hMenuTree,tvi.hItem))
break;
else{
bd->fEntryOpType=QMF_EX_SEPARATOR;
EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
SetDlgItemText(hdlg, IDC_MENUVALUE, _T(""));
}
}
else {
bd->fEntryOpType&=~QMF_EX_SEPARATOR;
EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),TRUE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),TRUE);
SetDlgItemText(hdlg, IDC_MENUVALUE, bd->pszOpValue/*?bd->pszOpValue:bd->pszValue*/);
}
bd->pszOpName=mir_tstrdup(szLabel);
tvi.pszText=szLabel;
TreeView_SetItem(hMenuTree, &tvi);
SendMessage(GetParent(hdlg),PSM_CHANGED,0,0);
}
}break;
case NM_KILLFOCUS:
TreeView_EndEditLabelNow(hButtonsList, 1);
break;
case TVN_BEGINDRAGA:
case TVN_BEGINDRAGW:
SetCapture(hdlg);
drag=1;
hDragItem=((LPNMTREEVIEW)lparam)->itemNew.hItem;
TreeView_SelectItem(hMenuTree,hDragItem);
break;
case TVN_SELCHANGINGA:
case TVN_SELCHANGINGW:
{
TVITEM tvi;
HTREEITEM hti;
ButtonData* bd;
hti=TreeView_GetSelection(hMenuTree);
if (hti==NULL)
break;
tvi.hItem=hti;
tvi.mask=TVIF_HANDLE|TVIF_PARAM;
TreeView_GetItem(hMenuTree,&tvi);
if (tvi.lParam == 0)
break;
bd = ( ButtonData* )tvi.lParam;
if (bd) {
TCHAR szValue[256];
GetDlgItemText(hdlg, IDC_MENUVALUE, szValue, SIZEOF(szValue));
if(_tcslen(szValue))
{
if(bd->pszOpValue&&(bd->pszOpValue!=bd->pszValue))
mir_free(bd->pszOpValue);
bd->pszOpValue=mir_tstrdup(szValue);
}
bd->bOpInQMenu=IsDlgButtonChecked(hdlg,IDC_INQMENU);
bd->bIsOpServName=IsDlgButtonChecked(hdlg,IDC_ISSERVNAME);
}
}break;
case TVN_SELCHANGEDA:
case TVN_SELCHANGEDW:
{
TVITEM tvi;
HTREEITEM hti;
ButtonData* bd=NULL;
hti=TreeView_GetSelection(hMenuTree);
if (hti==NULL)
break;
tvi.mask=TVIF_HANDLE|TVIF_PARAM;
tvi.hItem=hti;
TreeView_GetItem(hMenuTree,&tvi);
bd = ( ButtonData* )tvi.lParam;
if (bd) {
if (!TreeView_GetChild(hMenuTree, tvi.hItem)&&!(bd->fEntryOpType&QMF_EX_SEPARATOR))
{
EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),TRUE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),TRUE);
EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),TRUE);
SetDlgItemText(hdlg, IDC_MENUVALUE, bd->pszOpValue/*?bd->pszOpValue:bd->pszValue*/);
}
else
{
EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
if (!(bd->fEntryOpType&QMF_EX_SEPARATOR))
EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),FALSE);
SetDlgItemText(hdlg, IDC_MENUVALUE, _T(""));
}
CheckDlgButton(hdlg,IDC_INQMENU,bd->bOpInQMenu ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hdlg,IDC_ISSERVNAME,bd->bIsOpServName ? BST_CHECKED : BST_UNCHECKED);
}
}
}break;
case IDC_BUTTONSLIST:
switch (((LPNMHDR)lparam)->code) {
case TVN_KEYDOWN:{
TV_KEYDOWN* pTVKeyDown = (TV_KEYDOWN*) ((LPNMHDR)lparam);
if ( pTVKeyDown->wVKey == VK_F2 )
TreeView_EditLabel(hButtonsList,TreeView_GetSelection(hButtonsList));
else if ( pTVKeyDown->wVKey == VK_DELETE )
SendMessage(hdlg,WM_COMMAND,IDC_BLISTREMOVE,0);
}break;
case TVN_BEGINLABELEDITA:
case TVN_BEGINLABELEDITW:
hwndEdit = TreeView_GetEditControl(hButtonsList);
mir_subclassWindow(hwndEdit, LabelEditSubclassProc);
break;
case TVN_ENDLABELEDITA:
case TVN_ENDLABELEDITW:
{
TVITEM tvi;
TCHAR strbuf[128];
TCHAR szLabel[128];
tvi.pszText = strbuf;
tvi.cchTextMax = SIZEOF(strbuf);
tvi.mask=TVIF_TEXT |TVIF_HANDLE|TVIF_PARAM;
tvi.hItem=TreeView_GetSelection(hButtonsList);
TreeView_GetItem(hButtonsList,&tvi);
GetWindowText(hwndEdit, szLabel, SIZEOF(szLabel));
hwndEdit=NULL;
if (!_tcslen(szLabel)) break;
tvi.pszText=szLabel;
((ListData*)tvi.lParam)->dwOPFlags|=QMF_RENAMED;
TreeView_SetItem(hButtonsList, &tvi);
SendMessage(GetParent(hdlg),PSM_CHANGED,0,0);
}break;
case TVN_SELCHANGINGA:
case TVN_SELCHANGINGW:
SetMenuEntryProperties(hdlg);
break;
case TVN_SELCHANGEDA:
case TVN_SELCHANGEDW:
{
TVITEM tvi;
HTREEITEM hti;
hti=TreeView_GetSelection(hButtonsList);
if(hti==NULL||!TreeView_GetCount(hButtonsList)) {
EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME2),FALSE);
SetDlgItemText(hdlg, IDC_MENUVALUE, _T(""));
break;
}
tvi.mask=TVIF_HANDLE|TVIF_PARAM;
tvi.hItem=hti;
TreeView_GetItem(hButtonsList,&tvi);
if(tvi.lParam==0) break;
BuildMenuTree(hMenuTree,(SortedList *)((ListData*)tvi.lParam)->sl);
SetDlgItemText(hdlg, IDC_MENUVALUE, _T(""));
EnableWindow(GetDlgItem(hdlg,IDC_RCLICKVALUE),TRUE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME2),TRUE);
CheckDlgButton(hdlg,IDC_ISSERVNAME2,((ListData*)tvi.lParam)->bIsOpServName ? BST_CHECKED : BST_UNCHECKED);
if (((ListData*)tvi.lParam)->ptszOPQValue)
SetDlgItemText(hdlg, IDC_RCLICKVALUE, ((ListData*)tvi.lParam)->ptszOPQValue);
else
SetDlgItemText(hdlg, IDC_RCLICKVALUE, _T(""));
}break;
}break;
}
break;
case WM_COMMAND:
switch(LOWORD(wparam)) {
case IDC_VARHELP:
if (!g_varhelpDlg)
g_varhelpDlg=CreateDialog(hinstance,MAKEINTRESOURCE(IDD_HELPDIALOG), 0, HelpDlgProc);
else
//ShowWindow(g_varhelpDlg,SW_SHOWDEFAULT);
SetWindowPos(g_varhelpDlg,0,0,0,0,0,SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOSIZE);
break;
case IDC_BLISTADD:
{
TVINSERTSTRUCT tvis;
ListData* ld=NULL;
TCHAR namebuff[MAX_PATH]={'\0'};
int count=TreeView_GetCount(hButtonsList);
if (count>10) break;
if(g_iOPButtonsCount==99){
MessageBox(NULL, TranslateT("Congratulation!\r\nYou have clicked this button 100 times!\r\nThere was access violation at this point...\r\nAnd now function for freeing resources must be called...\r\nBut no! there's only break :D"), TranslateT("You win!"),MB_OK);
break;
}
ld = (ListData *)mir_alloc(sizeof(ListData));
ButtonsList[g_iOPButtonsCount++]=ld;
ld->sl=List_Create(0,1);
ld->dwOPFlags=QMF_NEW;
ld->bIsOpServName=0;
ld->ptszButtonName=NULL;
ld->ptszOPQValue=NULL;
ld->ptszQValue=NULL;
tvis.hParent = NULL;
tvis.hInsertAfter = TVI_LAST;
GetDlgItemText(hdlg, IDC_BUTTONNAME, namebuff, SIZEOF(namebuff));
tvis.item.mask=TVIF_PARAM|TVIF_TEXT;
tvis.item.pszText=(_tcslen(namebuff))?namebuff:TranslateT("New Button");
tvis.item.lParam=(LPARAM)ld;
TreeView_SelectItem(hButtonsList,TreeView_InsertItem(hButtonsList,&tvis));
}break;
case IDC_BLISTREMOVE:
{
TVITEM tvi;
ListData* ld;
if (!(tvi.hItem=TreeView_GetSelection(hButtonsList)))
break;
tvi.mask=TVIF_HANDLE|TVIF_PARAM;
TreeView_GetItem(hButtonsList,&tvi);
ld= (ListData*)tvi.lParam;
ld->dwOPFlags|=QMF_DELETNEEDED;
TreeView_DeleteItem(hButtonsList,tvi.hItem);
if (!TreeView_GetCount(hButtonsList)) {
TreeView_DeleteAllItems(hMenuTree);
EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_RCLICKVALUE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME2),FALSE);
SetDlgItemText(hdlg, IDC_MENUVALUE, _T(""));
SetDlgItemText(hdlg, IDC_RCLICKVALUE, _T(""));
}
}break;
case IDC_MTREEADD:
{
TVINSERTSTRUCT tvis;
TVITEM tvi;
ButtonData *bd=NULL;
SortedList *sl=NULL;
TCHAR namebuff[MAX_PATH]={'\0'};
if (!TreeView_GetCount(hButtonsList)) break;
if (!(tvi.hItem=TreeView_GetSelection(hButtonsList))) break;
bd = (ButtonData *)mir_alloc(sizeof(ButtonData));
memset(bd,0,sizeof(ButtonData));
GetDlgItemText(hdlg, IDC_MENUNAME, namebuff, SIZEOF(namebuff));
bd->dwOPPos=TreeView_GetCount(hMenuTree)-1;
bd->pszOpName=_tcslen(namebuff)?mir_tstrdup(namebuff):mir_tstrdup(TranslateT("New Menu Entry"));
bd->pszOpValue=mir_tstrdup(bd->pszOpName);
bd->fEntryOpType=!_tcscmp(namebuff,_T("---"))?QMF_EX_SEPARATOR:0;
bd->dwOPFlags=QMF_NEW;
bd->pszName=NULL;
bd->pszValue=NULL;
tvi.mask=TVIF_HANDLE|TVIF_PARAM;
TreeView_GetItem(hButtonsList,&tvi);
sl=((ListData*)tvi.lParam)->sl;
List_InsertPtr(sl,bd);
tvis.hParent = NULL;
tvis.hInsertAfter = TVI_LAST;
tvis.item.mask=TVIF_PARAM|TVIF_TEXT;
tvis.item.pszText=bd->pszOpName;
tvis.item.lParam=(LPARAM)bd;
TreeView_SelectItem(hMenuTree,TreeView_InsertItem(hMenuTree,&tvis));
}break;
case IDC_MTREEREMOVE:
{
TVITEM tvi;
TVINSERTSTRUCT tvis;
HTREEITEM hti=NULL;
ButtonData *bd=NULL;
tvi.mask=TVIF_HANDLE|TVIF_PARAM;
if (!(tvi.hItem=TreeView_GetSelection(hMenuTree)))
break;
TreeView_GetItem(hMenuTree,&tvi);
hti=tvi.hItem;
bd= (ButtonData*)tvi.lParam;
bd->dwOPFlags|=QMF_DELETNEEDED;
if(tvi.hItem=TreeView_GetChild(hMenuTree,tvi.hItem)) {
TCHAR strbuf[128];
while(tvi.hItem){
tvis.hInsertAfter=hti;
tvi.pszText = strbuf;
tvi.cchTextMax = SIZEOF(strbuf);
tvi.mask=TVIF_HANDLE|TVIF_PARAM|TVIF_TEXT;
TreeView_GetItem(hMenuTree,&tvi);
tvis.hParent=NULL;
tvis.item=tvi;
TreeView_InsertItem(hMenuTree,&tvis);
tvi.hItem=TreeView_GetNextSibling(hMenuTree,tvi.hItem);
}
}
TreeView_DeleteItem(hMenuTree,hti);
if (!TreeView_GetCount(hMenuTree)) {
EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),FALSE);
SetDlgItemText(hdlg, IDC_MENUVALUE, _T(""));
}
}break;
}
break;
case WM_CLOSE:
EndDialog(hdlg,0);
return 0;
}
if (HIWORD(wparam)==BN_CLICKED && GetFocus()==(HWND)lparam)
SendMessage(GetParent(hdlg),PSM_CHANGED,0,0);
else if ((HIWORD(wparam) == EN_CHANGE)&&(GetFocus()==(HWND)lparam))
if (!bOptionsInit) SendMessage(GetParent(hdlg),PSM_CHANGED,0,0);
return 0;
}
// ¶Ô»°¿ò»Øµ÷º¯Êý
inline LRESULT CALLBACK CalendarProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK:
{
EndDialog(hDlg, TRUE);
return TRUE;
}
break;
case IDM_EATZAC:
if (fMealMap[m_iDay-1]==M100 || fMealMap[m_iDay-1]==M101 || fMealMap[m_iDay-1]==M110 || fMealMap[m_iDay-1]==M111)
{
// <-Ôç²Í>
fMealMap[m_iDay-1] -= M100;
fTotalFee += M100;
}
else {
// <+Ôç²Í>
fMealMap[m_iDay-1] += M100;
fTotalFee -= M100;
}
ShowMealData(hDlg);
SaveMealMap();
return TRUE;
break;
case IDM_EATWUC:
if (fMealMap[m_iDay-1]==M010 || fMealMap[m_iDay-1]==M011 || fMealMap[m_iDay-1]==M110 || fMealMap[m_iDay-1]==M111)
{
// <-Îç²Í>
fMealMap[m_iDay-1] -= M010;
fTotalFee += M010;
}
else {
// <+Îç²Í>
fMealMap[m_iDay-1] += M010;
fTotalFee -= M010;
}
ShowMealData(hDlg);
SaveMealMap();
return TRUE;
break;
case IDM_EATWAC:
if (fMealMap[m_iDay-1]==M001 || fMealMap[m_iDay-1]==M101 || fMealMap[m_iDay-1]==M011 || fMealMap[m_iDay-1]==M111)
{
// <-Íí²Í>
fMealMap[m_iDay-1] -= M001;
fTotalFee += (M001-(float)0.1);
}
else {
// <+Íí²Í>
fMealMap[m_iDay-1] += M001;
fTotalFee -= (M001-(float)0.1);
//wchar_t szTmp[50] = { 0 };
//char strTmp[50] = { 0 };
//sprintf_s(strTmp, "fMealMap[m_iDay-1]: %.1f, fTotalFee: %.1f", fMealMap[m_iDay - 1], fTotalFee);
//MultiByteToWideChar(CP_OEMCP, NULL, strTmp, 50, szTmp, 50);
//MessageBox(NULL, szTmp, _T("OK"), MB_OK);
}
ShowMealData(hDlg);
SaveMealMap();
return TRUE;
break;
}
return FALSE;
break;
case WM_RBUTTONDOWN:
case WM_LBUTTONDOWN:
{
POINT pt;
GetCursorPos(&pt);
m_iDay = (WORD)SelectDay(hDlg, &pt);
if (m_iDay == 0) {
return TRUE;
}
PaintCalc(hDlg);
if (uMsg == WM_RBUTTONDOWN) {
CString menu1, menu2, menu3, menu4;
if (fMealMap[m_iDay-1] == M000)
{
menu1.Format(_T("+Ôç²Í"));
menu2.Format(_T("+Îç²Í"));
menu3.Format(_T("+Íí²Í"));
menu4.Format(_T("*δ³Ô"));
}
else if (fMealMap[m_iDay-1] == M110)
{
menu1.Format(_T("-Ôç²Í"));
menu2.Format(_T("-Îç²Í"));
menu3.Format(_T("+Íí²Í"));
menu4.Format(_T("*ÔçÎç"));
}
else if (fMealMap[m_iDay-1] == M111)
{
menu1.Format(_T("-Ôç²Í"));
menu2.Format(_T("-Îç²Í"));
menu3.Format(_T("-Íí²Í"));
menu4.Format(_T("*È«³Ô"));
}
else if (fMealMap[m_iDay-1] == M100)
{
menu1.Format(_T("-Ôç²Í"));
menu2.Format(_T("+Îç²Í"));
menu3.Format(_T("+Íí²Í"));
menu4.Format(_T("*Ôç²Í"));
}
else if (fMealMap[m_iDay-1] == M010)
{
menu1.Format(_T("+Ôç²Í"));
menu2.Format(_T("-Îç²Í"));
menu3.Format(_T("+Íí²Í"));
menu4.Format(_T("*Îç²Í"));
}
else if (fMealMap[m_iDay-1] == M001)
{
menu1.Format(_T("+Ôç²Í"));
menu2.Format(_T("+Îç²Í"));
menu3.Format(_T("-Íí²Í"));
menu4.Format(_T("*Íí²Í"));
}
else if (fMealMap[m_iDay-1] == M101)
{
menu1.Format(_T("-Ôç²Í"));
menu2.Format(_T("+Îç²Í"));
menu3.Format(_T("-Íí²Í"));
menu4.Format(_T("*ÔçÍí"));
}
else if (fMealMap[m_iDay-1] == M011)
{
menu1.Format(_T("+Ôç²Í"));
menu2.Format(_T("-Îç²Í"));
menu3.Format(_T("-Íí²Í"));
menu4.Format(_T("*ÎçÍí"));
}
ClientToScreen(hDlg, &pt);
HMENU hMenu = CreatePopupMenu();
AppendMenu(hMenu, MF_STRING, IDM_EATZAC, menu1);
AppendMenu(hMenu, MF_STRING, IDM_EATWUC, menu2);
AppendMenu(hMenu, MF_STRING, IDM_EATWAC, menu3);
AppendMenu(hMenu, MF_STRING|MF_DISABLED|MF_GRAYED, IDM_EATNOW, menu4);
TrackPopupMenu(hMenu, TPM_RIGHTBUTTON, pt.x, pt.y, NULL, hDlg, NULL);
}
return TRUE;
}
break;
case WM_WINDOWPOSCHANGED:
PostMessage(hDlg, WM_SHOWCAL, 0, 0);
return TRUE;
break;
case WM_SHOWCAL:
PaintCalc(hDlg);
ShowMealData(hDlg);
return TRUE;
break;
case WM_CLOSE:
DestroyWindow(hDlg);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
}
return FALSE;
}
void CBGridCtrl::OnLButtonDown(UINT nFlags, CPoint point)
{
HWND hOldFocusWnd = ::GetFocus();
nFlags=1;
BOOL m_IsSort=FALSE;
if(m_SortColumn!=-1)
m_IsSort=TRUE;
if(m_idCurrentCell.row>0)
m_CurrSortCell=m_idCurrentCell ;
m_CurrrSortClick=FALSE;
m_BeforeRow=m_idCurrentCell.row;
m_LeftClickDownPoint = point;
m_LeftClickDownCell = GetCellFromPt(point);
if (!IsValid(m_LeftClickDownCell)) return;
m_SelectionStartCell = (nFlags & MK_SHIFT)? m_idCurrentCell : m_LeftClickDownCell;
SetFocus();
if (m_LeftClickDownCell == m_idCurrentCell)
{
m_MouseMode = MOUSE_PREPARE_EDIT;
return;
} else {
SetFocusCell(-1,-1);
SetFocusCell(max(m_LeftClickDownCell.row, m_nFixedRows),
max(m_LeftClickDownCell.col, m_nFixedCols));//Do not modify the contents of this file.
}
if (m_bAllowDragAndDrop && hOldFocusWnd == GetSafeHwnd() &&
GetItemState(m_LeftClickDownCell.row, m_LeftClickDownCell.col) & GVNI_SELECTED)
{
m_MouseMode = MOUSE_PREPARE_DRAG;
return;
}
SetCapture();
// 股票列表视图的列变量定义，以及自定义列的表达式计算
if (m_MouseMode == MOUSE_OVER_COL_DIVIDE)
{
m_MouseMode = MOUSE_SIZING_COL;
CPoint start;
if (!GetCellOrigin(0, m_LeftClickDownCell.col, &start)) return;
CRect rect;
GetClientRect(rect);
CRect invertedRect(point.x, rect.top, point.x + 2, rect.bottom);
CDC* pDC = GetDC();
if (pDC) {
pDC->InvertRect(&invertedRect);
ReleaseDC(pDC);//Do not modify the contents of this file.
}
if (point.x - start.x <= m_nResizeCaptureRange)
if (!GetCellOrigin(0, --m_LeftClickDownCell.col, &start)) return;
rect.left = start.x;
ClientToScreen(rect);
ClipCursor(rect);
}
else if (m_MouseMode == MOUSE_OVER_ROW_DIVIDE)
{
m_MouseMode = MOUSE_SIZING_ROW;
CPoint start;
if (!GetCellOrigin(m_LeftClickDownCell, &start)) return;
CRect rect;
GetClientRect(rect);
CRect invertedRect(rect.left, point.y, rect.right, point.y + 2);
CDC* pDC = GetDC();
if (pDC) {
pDC->InvertRect(&invertedRect);
ReleaseDC(pDC);
}
if (point.y - start.y <= m_nResizeCaptureRange)
if (!GetCellOrigin(--m_LeftClickDownCell.row, 0, &start)) return;
rect.top = start.y;
ClientToScreen(rect);
ClipCursor(rect);//Do not modify the contents of this file.
}
else
{
if (m_LeftClickDownCell.row < GetFixedRowCount())
{
m_CurrrSortClick=TRUE;
OnFixedRowClick(m_LeftClickDownCell);// NOTE: the ClassWizard will add member functions here
}
else if (m_LeftClickDownCell.col < GetFixedColumnCount())
{
m_CurrrSortClick=FALSE;
OnFixedColumnClick(m_LeftClickDownCell);
}
else
{
m_CurrrSortClick=FALSE;// NOTE: the ClassWizard will add member functions here
m_MouseMode = m_bListMode? MOUSE_SELECT_ROW : MOUSE_SELECT_CELLS;
OnSelecting(m_LeftClickDownCell);
}
m_nTimerID = SetTimer(WM_LBUTTONDOWN, m_nTimerInterval, 0);
}
m_LastMousePoint = point;
m_CurrSortCell=m_idCurrentCell ;
}
LRESULT WINAPI
User32DefWindowProc(HWND hWnd,
UINT Msg,
WPARAM wParam,
LPARAM lParam,
BOOL bUnicode)
{
PWND pWnd = NULL;
if (hWnd)
{
pWnd = ValidateHwnd(hWnd);
if (!pWnd) return 0;
}
switch (Msg)
{
case WM_NCPAINT:
{
return DefWndNCPaint(hWnd, (HRGN)wParam, -1);
}
case WM_NCCALCSIZE:
{
return DefWndNCCalcSize(hWnd, (BOOL)wParam, (RECT*)lParam);
}
case WM_POPUPSYSTEMMENU:
{
/* This is an undocumented message used by the windows taskbar to
display the system menu of windows that belong to other processes. */
HMENU menu = GetSystemMenu(hWnd, FALSE);
if (menu)
TrackPopupMenu(menu, TPM_LEFTBUTTON|TPM_RIGHTBUTTON,
LOWORD(lParam), HIWORD(lParam), 0, hWnd, NULL);
return 0;
}
case WM_NCACTIVATE:
{
return DefWndNCActivate(hWnd, wParam, lParam);
}
case WM_NCHITTEST:
{
POINT Point;
Point.x = GET_X_LPARAM(lParam);
Point.y = GET_Y_LPARAM(lParam);
return (DefWndNCHitTest(hWnd, Point));
}
case WM_LBUTTONDOWN:
case WM_RBUTTONDOWN:
case WM_MBUTTONDOWN:
iF10Key = iMenuSysKey = 0;
break;
case WM_NCLBUTTONDOWN:
{
return (DefWndNCLButtonDown(hWnd, wParam, lParam));
}
case WM_LBUTTONDBLCLK:
return (DefWndNCLButtonDblClk(hWnd, HTCLIENT, lParam));
case WM_NCLBUTTONDBLCLK:
{
return (DefWndNCLButtonDblClk(hWnd, wParam, lParam));
}
case WM_NCRBUTTONDOWN:
return NC_HandleNCRButtonDown( hWnd, wParam, lParam );
case WM_RBUTTONUP:
{
POINT Pt;
Pt.x = GET_X_LPARAM(lParam);
Pt.y = GET_Y_LPARAM(lParam);
ClientToScreen(hWnd, &Pt);
lParam = MAKELPARAM(Pt.x, Pt.y);
if (bUnicode)
{
SendMessageW(hWnd, WM_CONTEXTMENU, (WPARAM)hWnd, lParam);
}
else
{
SendMessageA(hWnd, WM_CONTEXTMENU, (WPARAM)hWnd, lParam);
}
break;
}
case WM_NCRBUTTONUP:
/*
* FIXME : we must NOT send WM_CONTEXTMENU on a WM_NCRBUTTONUP (checked
* in Windows), but what _should_ we do? According to MSDN :
* "If it is appropriate to do so, the system sends the WM_SYSCOMMAND
* message to the window". When is it appropriate?
*/
break;
case WM_CONTEXTMENU:
{
if (GetWindowLongPtrW(hWnd, GWL_STYLE) & WS_CHILD)
{
if (bUnicode)
{
SendMessageW(GetParent(hWnd), Msg, wParam, lParam);
}
else
{
SendMessageA(GetParent(hWnd), WM_CONTEXTMENU, wParam, lParam);
}
}
else
{
POINT Pt;
LONG_PTR Style;
LONG HitCode;
Style = GetWindowLongPtrW(hWnd, GWL_STYLE);
Pt.x = GET_X_LPARAM(lParam);
Pt.y = GET_Y_LPARAM(lParam);
if (Style & WS_CHILD)
{
ScreenToClient(GetParent(hWnd), &Pt);
}
HitCode = DefWndNCHitTest(hWnd, Pt);
if (HitCode == HTCAPTION || HitCode == HTSYSMENU)
{
HMENU SystemMenu;
UINT Flags;
if((SystemMenu = GetSystemMenu(hWnd, FALSE)))
{
MenuInitSysMenuPopup(SystemMenu, GetWindowLongPtrW(hWnd, GWL_STYLE),
GetClassLongPtrW(hWnd, GCL_STYLE), HitCode);
if(HitCode == HTCAPTION)
Flags = TPM_LEFTBUTTON | TPM_RIGHTBUTTON;
else
Flags = TPM_LEFTBUTTON;
TrackPopupMenu(SystemMenu, Flags,
Pt.x, Pt.y, 0, hWnd, NULL);
}
}
}
break;
}
case WM_PRINT:
{
DefWndPrint(hWnd, (HDC)wParam, lParam);
return (0);
}
case WM_SYSCOLORCHANGE:
{
/* force to redraw non-client area */
DefWndNCPaint(hWnd, HRGN_WINDOW, -1);
/* Use InvalidateRect to redraw client area, enable
* erase to redraw all subcontrols otherwise send the
* WM_SYSCOLORCHANGE to child windows/controls is required
*/
InvalidateRect(hWnd,NULL,TRUE);
return (0);
}
case WM_PAINTICON:
case WM_PAINT:
{
PAINTSTRUCT Ps;
HDC hDC;
/* If already in Paint and Client area is not empty just return. */
if (pWnd->state2 & WNDS2_STARTPAINT && !IsRectEmpty(&pWnd->rcClient))
{
ERR("In Paint and Client area is not empty!\n");
return 0;
}
hDC = BeginPaint(hWnd, &Ps);
if (hDC)
{
HICON hIcon;
if (IsIconic(hWnd) && ((hIcon = (HICON)GetClassLongPtrW( hWnd, GCLP_HICON))))
{
RECT ClientRect;
INT x, y;
GetClientRect(hWnd, &ClientRect);
x = (ClientRect.right - ClientRect.left -
GetSystemMetrics(SM_CXICON)) / 2;
y = (ClientRect.bottom - ClientRect.top -
GetSystemMetrics(SM_CYICON)) / 2;
DrawIcon(hDC, x, y, hIcon);
}
EndPaint(hWnd, &Ps);
}
return (0);
}
case WM_CLOSE:
DestroyWindow(hWnd);
return (0);
case WM_MOUSEACTIVATE:
if (GetWindowLongPtrW(hWnd, GWL_STYLE) & WS_CHILD)
{
LONG Ret = SendMessageW(GetParent(hWnd), WM_MOUSEACTIVATE, wParam, lParam);
if (Ret) return (Ret);
}
return ( (HIWORD(lParam) == WM_LBUTTONDOWN && LOWORD(lParam) == HTCAPTION) ? MA_NOACTIVATE : MA_ACTIVATE );
case WM_ACTIVATE:
/* The default action in Windows is to set the keyboard focus to
* the window, if it's being activated and not minimized */
if (LOWORD(wParam) != WA_INACTIVE &&
!(GetWindowLongPtrW(hWnd, GWL_STYLE) & WS_MINIMIZE))
{
//ERR("WM_ACTIVATE %p\n",hWnd);
SetFocus(hWnd);
}
break;
case WM_MOUSEWHEEL:
if (GetWindowLongPtrW(hWnd, GWL_STYLE) & WS_CHILD)
return SendMessageW( GetParent(hWnd), WM_MOUSEWHEEL, wParam, lParam);
break;
case WM_ERASEBKGND:
case WM_ICONERASEBKGND:
{
RECT Rect;
HBRUSH hBrush = (HBRUSH)GetClassLongPtrW(hWnd, GCL_HBRBACKGROUND);
if (NULL == hBrush)
{
return 0;
}
if (GetClassLongPtrW(hWnd, GCL_STYLE) & CS_PARENTDC)
{
/* can't use GetClipBox with a parent DC or we fill the whole parent */
GetClientRect(hWnd, &Rect);
DPtoLP((HDC)wParam, (LPPOINT)&Rect, 2);
}
else
{
GetClipBox((HDC)wParam, &Rect);
}
FillRect((HDC)wParam, &Rect, hBrush);
return (1);
}
case WM_CTLCOLORMSGBOX:
case WM_CTLCOLOREDIT:
case WM_CTLCOLORLISTBOX:
case WM_CTLCOLORBTN:
case WM_CTLCOLORDLG:
case WM_CTLCOLORSTATIC:
case WM_CTLCOLORSCROLLBAR:
return (LRESULT) DefWndControlColor((HDC)wParam, Msg - WM_CTLCOLORMSGBOX);
case WM_CTLCOLOR:
return (LRESULT) DefWndControlColor((HDC)wParam, HIWORD(lParam));
case WM_SETCURSOR:
{
LONG_PTR Style = GetWindowLongPtrW(hWnd, GWL_STYLE);
if (Style & WS_CHILD)
{
/* with the exception of the border around a resizable wnd,
* give the parent first chance to set the cursor */
if (LOWORD(lParam) < HTLEFT || LOWORD(lParam) > HTBOTTOMRIGHT)
{
HWND parent = GetParent( hWnd );
if (bUnicode)
{
if (parent != GetDesktopWindow() &&
SendMessageW( parent, WM_SETCURSOR, wParam, lParam))
return TRUE;
}
else
{
if (parent != GetDesktopWindow() &&
SendMessageA( parent, WM_SETCURSOR, wParam, lParam))
return TRUE;
}
}
}
return (DefWndHandleSetCursor(hWnd, wParam, lParam, Style));
}
case WM_SYSCOMMAND:
return (DefWndHandleSysCommand(hWnd, wParam, lParam));
case WM_KEYDOWN:
if(wParam == VK_F10) iF10Key = VK_F10;
break;
case WM_SYSKEYDOWN:
{
if (HIWORD(lParam) & KF_ALTDOWN)
{ /* Previous state, if the key was down before this message,
this is a cheap way to ignore autorepeat keys. */
if ( !(HIWORD(lParam) & KF_REPEAT) )
{
if ( ( wParam == VK_MENU ||
wParam == VK_LMENU ||
wParam == VK_RMENU ) && !iMenuSysKey )
iMenuSysKey = 1;
else
iMenuSysKey = 0;
}
iF10Key = 0;
if (wParam == VK_F4) /* Try to close the window */
{
HWND top = GetAncestor(hWnd, GA_ROOT);
if (!(GetClassLongPtrW(top, GCL_STYLE) & CS_NOCLOSE))
PostMessageW(top, WM_SYSCOMMAND, SC_CLOSE, 0);
}
else if (wParam == VK_SNAPSHOT) // Alt-VK_SNAPSHOT?
{
HWND hwnd = hWnd;
while (GetParent(hwnd) != NULL)
{
hwnd = GetParent(hwnd);
}
DefWndScreenshot(hwnd);
}
else if ( wParam == VK_ESCAPE || wParam == VK_TAB ) // Alt-Tab/ESC Alt-Shift-Tab/ESC
{
WPARAM wParamTmp;
HWND Active = GetActiveWindow(); // Noticed MDI problem.
if (!Active)
{
FIXME("WM_SYSKEYDOWN VK_ESCAPE no active\n");
break;
}
wParamTmp = GetKeyState(VK_SHIFT) & 0x8000 ? SC_PREVWINDOW : SC_NEXTWINDOW;
SendMessageW( Active, WM_SYSCOMMAND, wParamTmp, wParam );
}
}
else if( wParam == VK_F10 )
{
if (GetKeyState(VK_SHIFT) & 0x8000)
SendMessageW( hWnd, WM_CONTEXTMENU, (WPARAM)hWnd, MAKELPARAM(-1, -1) );
iF10Key = 1;
}
break;
}
case WM_KEYUP:
case WM_SYSKEYUP:
{
/* Press and release F10 or ALT */
if (((wParam == VK_MENU || wParam == VK_LMENU || wParam == VK_RMENU)
&& iMenuSysKey) || ((wParam == VK_F10) && iF10Key))
SendMessageW( GetAncestor( hWnd, GA_ROOT ), WM_SYSCOMMAND, SC_KEYMENU, 0L );
iMenuSysKey = iF10Key = 0;
break;
}
case WM_SYSCHAR:
{
iMenuSysKey = 0;
if (wParam == VK_RETURN && IsIconic(hWnd))
{
PostMessageW( hWnd, WM_SYSCOMMAND, SC_RESTORE, 0L );
break;
}
if ((HIWORD(lParam) & KF_ALTDOWN) && wParam)
{
if (wParam == VK_TAB || wParam == VK_ESCAPE) break;
if (wParam == VK_SPACE && (GetWindowLongPtrW( hWnd, GWL_STYLE ) & WS_CHILD))
SendMessageW( GetParent(hWnd), Msg, wParam, lParam );
else
SendMessageW( hWnd, WM_SYSCOMMAND, SC_KEYMENU, wParam );
}
else /* check for Ctrl-Esc */
if (wParam != VK_ESCAPE) MessageBeep(0);
break;
}
case WM_CANCELMODE:
{
iMenuSysKey = 0;
/* FIXME: Check for a desktop. */
//if (!(GetWindowLongPtrW( hWnd, GWL_STYLE ) & WS_CHILD)) EndMenu();
MENU_EndMenu( hWnd );
if (GetCapture() == hWnd)
{
ReleaseCapture();
}
break;
}
case WM_VKEYTOITEM:
case WM_CHARTOITEM:
return (-1);
/*
case WM_DROPOBJECT:
return DRAG_FILE;
*/
case WM_QUERYDROPOBJECT:
{
if (GetWindowLongPtrW(hWnd, GWL_EXSTYLE) & WS_EX_ACCEPTFILES)
{
return(1);
}
break;
}
case WM_QUERYDRAGICON:
{
UINT Len;
HICON hIcon;
hIcon = (HICON)GetClassLongPtrW(hWnd, GCL_HICON);
if (hIcon)
{
return ((LRESULT)hIcon);
}
for (Len = 1; Len < 64; Len++)
{
if ((hIcon = LoadIconW(NULL, MAKEINTRESOURCEW(Len))) != NULL)
{
return((LRESULT)hIcon);
}
}
return ((LRESULT)LoadIconW(0, IDI_APPLICATION));
}
case WM_ISACTIVEICON:
{
BOOL isai;
isai = (pWnd->state & WNDS_ACTIVEFRAME) != 0;
return isai;
}
case WM_NOTIFYFORMAT:
{
if (lParam == NF_QUERY)
return IsWindowUnicode(hWnd) ? NFR_UNICODE : NFR_ANSI;
break;
}
case WM_SETICON:
{
return DefWndSetIcon(pWnd, wParam, lParam);
}
case WM_GETICON:
{
return DefWndGetIcon(pWnd, wParam, lParam);
}
case WM_HELP:
{
if (bUnicode)
{
SendMessageW(GetParent(hWnd), Msg, wParam, lParam);
}
else
{
SendMessageA(GetParent(hWnd), Msg, wParam, lParam);
}
break;
}
case WM_SYSTIMER:
{
THRDCARETINFO CaretInfo;
switch(wParam)
{
case 0xffff: /* Caret timer */
/* switch showing byte in win32k and get information about the caret */
if(NtUserxSwitchCaretShowing(&CaretInfo) && (CaretInfo.hWnd == hWnd))
{
DrawCaret(hWnd, &CaretInfo);
}
break;
}
break;
}
case WM_QUERYOPEN:
case WM_QUERYENDSESSION:
{
return (1);
}
case WM_INPUTLANGCHANGEREQUEST:
{
HKL NewHkl;
if(wParam & INPUTLANGCHANGE_BACKWARD
&& wParam & INPUTLANGCHANGE_FORWARD)
{
return FALSE;
}
//FIXME: What to do with INPUTLANGCHANGE_SYSCHARSET ?
if(wParam & INPUTLANGCHANGE_BACKWARD) NewHkl = (HKL) HKL_PREV;
else if(wParam & INPUTLANGCHANGE_FORWARD) NewHkl = (HKL) HKL_NEXT;
else NewHkl = (HKL) lParam;
NtUserActivateKeyboardLayout(NewHkl, 0);
return TRUE;
}
case WM_INPUTLANGCHANGE:
{
int count = 0;
HWND *win_array = WIN_ListChildren( hWnd );
if (!win_array)
break;
while (win_array[count])
SendMessageW( win_array[count++], WM_INPUTLANGCHANGE, wParam, lParam);
HeapFree(GetProcessHeap(),0,win_array);
break;
}
case WM_QUERYUISTATE:
{
LRESULT Ret = 0;
PWND Wnd = ValidateHwnd(hWnd);
if (Wnd != NULL)
{
if (Wnd->HideFocus)
Ret |= UISF_HIDEFOCUS;
if (Wnd->HideAccel)
Ret |= UISF_HIDEACCEL;
}
return Ret;
}
case WM_CHANGEUISTATE:
{
BOOL AlwaysShowCues = FALSE;
WORD Action = LOWORD(wParam);
WORD Flags = HIWORD(wParam);
PWND Wnd;
SystemParametersInfoW(SPI_GETKEYBOARDCUES, 0, &AlwaysShowCues, 0);
if (AlwaysShowCues)
break;
Wnd= ValidateHwnd(hWnd);
if (!Wnd || lParam != 0)
break;
if (Flags & ~(UISF_HIDEFOCUS | UISF_HIDEACCEL | UISF_ACTIVE))
break;
if (Flags & UISF_ACTIVE)
{
WARN("WM_CHANGEUISTATE does not yet support UISF_ACTIVE!\n");
}
if (Action == UIS_INITIALIZE)
{
PDESKTOPINFO Desk = GetThreadDesktopInfo();
if (Desk == NULL)
break;
Action = Desk->LastInputWasKbd ? UIS_CLEAR : UIS_SET;
Flags = UISF_HIDEFOCUS | UISF_HIDEACCEL;
/* We need to update wParam in case we need to send out messages */
wParam = MAKEWPARAM(Action, Flags);
}
switch (Action)
{
case UIS_SET:
/* See if we actually need to change something */
if ((Flags & UISF_HIDEFOCUS) && !Wnd->HideFocus)
break;
if ((Flags & UISF_HIDEACCEL) && !Wnd->HideAccel)
break;
/* Don't need to do anything... */
return 0;
case UIS_CLEAR:
/* See if we actually need to change something */
if ((Flags & UISF_HIDEFOCUS) && Wnd->HideFocus)
break;
if ((Flags & UISF_HIDEACCEL) && Wnd->HideAccel)
break;
/* Don't need to do anything... */
return 0;
default:
WARN("WM_CHANGEUISTATE: Unsupported Action 0x%x\n", Action);
break;
}
if ((Wnd->style & WS_CHILD) && Wnd->spwndParent != NULL)
{
/* We're a child window and we need to pass this message down until
we reach the root */
hWnd = UserHMGetHandle((PWND)DesktopPtrToUser(Wnd->spwndParent));
}
else
{
/* We're a top level window, we need to change the UI state */
Msg = WM_UPDATEUISTATE;
}
if (bUnicode)
return SendMessageW(hWnd, Msg, wParam, lParam);
else
return SendMessageA(hWnd, Msg, wParam, lParam);
}
case WM_UPDATEUISTATE:
{
BOOL Change = TRUE;
BOOL AlwaysShowCues = FALSE;
WORD Action = LOWORD(wParam);
WORD Flags = HIWORD(wParam);
PWND Wnd;
SystemParametersInfoW(SPI_GETKEYBOARDCUES, 0, &AlwaysShowCues, 0);
if (AlwaysShowCues)
break;
Wnd = ValidateHwnd(hWnd);
if (!Wnd || lParam != 0)
break;
if (Flags & ~(UISF_HIDEFOCUS | UISF_HIDEACCEL | UISF_ACTIVE))
break;
if (Flags & UISF_ACTIVE)
{
WARN("WM_UPDATEUISTATE does not yet support UISF_ACTIVE!\n");
}
if (Action == UIS_INITIALIZE)
{
PDESKTOPINFO Desk = GetThreadDesktopInfo();
if (Desk == NULL)
break;
Action = Desk->LastInputWasKbd ? UIS_CLEAR : UIS_SET;
Flags = UISF_HIDEFOCUS | UISF_HIDEACCEL;
/* We need to update wParam for broadcasting the update */
wParam = MAKEWPARAM(Action, Flags);
}
switch (Action)
{
case UIS_SET:
/* See if we actually need to change something */
if ((Flags & UISF_HIDEFOCUS) && !Wnd->HideFocus)
break;
if ((Flags & UISF_HIDEACCEL) && !Wnd->HideAccel)
break;
/* Don't need to do anything... */
Change = FALSE;
break;
case UIS_CLEAR:
/* See if we actually need to change something */
if ((Flags & UISF_HIDEFOCUS) && Wnd->HideFocus)
break;
if ((Flags & UISF_HIDEACCEL) && Wnd->HideAccel)
break;
/* Don't need to do anything... */
Change = FALSE;
break;
default:
WARN("WM_UPDATEUISTATE: Unsupported Action 0x%x\n", Action);
return 0;
}
/* Pack the information and call win32k */
if (Change)
{
if (!NtUserxUpdateUiState(hWnd, Flags | ((DWORD)Action << 3)))
break;
}
/* Always broadcast the update to all children */
EnumChildWindows(hWnd,
UserSendUiUpdateMsg,
(LPARAM)wParam);
break;
}
/* Move to Win32k !*/
case WM_SHOWWINDOW:
if (!lParam) break; // Call when it is necessary.
case WM_SYNCPAINT:
case WM_SETREDRAW:
case WM_CLIENTSHUTDOWN:
case WM_GETHOTKEY:
case WM_SETHOTKEY:
case WM_WINDOWPOSCHANGING:
case WM_WINDOWPOSCHANGED:
case WM_APPCOMMAND:
{
LRESULT lResult;
NtUserMessageCall( hWnd, Msg, wParam, lParam, (ULONG_PTR)&lResult, FNID_DEFWINDOWPROC, !bUnicode);
return lResult;
}
}
return 0;
}
void CUIDesignerView::OnRButtonUp(UINT nFlags, CPoint point)
{
ClientToScreen(&point);
OnContextMenu(this, point);
}
static LRESULT
PAGER_MouseMove (PAGER_INFO* infoPtr, INT keys, INT x, INT y)
{
POINT clpt, pt;
RECT wnrect;
BOOL topLeft = FALSE;
INT btnstate = 0;
INT hit;
HDC hdc;
pt.x = x;
pt.y = y;
TRACE("[%p] to (%d,%d)\n", infoPtr->hwndSelf, x, y);
ClientToScreen(infoPtr->hwndSelf, &pt);
GetWindowRect(infoPtr->hwndSelf, &wnrect);
if (PtInRect(&wnrect, pt)) {
RECT topleft, bottomright, *rect = NULL;
PAGER_GetButtonRects(infoPtr, &topleft, &bottomright, FALSE);
clpt = pt;
MapWindowPoints(0, infoPtr->hwndSelf, &clpt, 1);
hit = PAGER_HitTest(infoPtr, &clpt);
if ((hit == PGB_TOPORLEFT) && (infoPtr->TLbtnState == PGF_NORMAL))
{
topLeft = TRUE;
rect = &topleft;
infoPtr->TLbtnState = PGF_HOT;
btnstate = infoPtr->TLbtnState;
}
else if ((hit == PGB_BOTTOMORRIGHT) && (infoPtr->BRbtnState == PGF_NORMAL))
{
topLeft = FALSE;
rect = &bottomright;
infoPtr->BRbtnState = PGF_HOT;
btnstate = infoPtr->BRbtnState;
}
/* If in one of the buttons the capture and draw buttons */
if (rect)
{
TRACE("[%p] draw btn (%s), Capture %s, style %08x\n",
infoPtr->hwndSelf, wine_dbgstr_rect(rect),
(infoPtr->bCapture) ? "TRUE" : "FALSE",
infoPtr->dwStyle);
if (!infoPtr->bCapture)
{
TRACE("[%p] SetCapture\n", infoPtr->hwndSelf);
SetCapture(infoPtr->hwndSelf);
infoPtr->bCapture = TRUE;
}
if (infoPtr->dwStyle & PGS_AUTOSCROLL)
SetTimer(infoPtr->hwndSelf, TIMERID1, 0x3e, 0);
hdc = GetWindowDC(infoPtr->hwndSelf);
/* OffsetRect(wnrect, 0 | 1, 0 | 1) */
PAGER_DrawButton(hdc, infoPtr->clrBk, *rect,
infoPtr->dwStyle & PGS_HORZ, topLeft, btnstate);
ReleaseDC(infoPtr->hwndSelf, hdc);
return 0;
}
}
/* If we think we are captured, then do release */
if (infoPtr->bCapture && (WindowFromPoint(pt) != infoPtr->hwndSelf))
{
NMHDR nmhdr;
infoPtr->bCapture = FALSE;
if (GetCapture() == infoPtr->hwndSelf)
{
ReleaseCapture();
if (infoPtr->TLbtnState == PGF_GRAYED)
{
infoPtr->TLbtnState = PGF_INVISIBLE;
SetWindowPos(infoPtr->hwndSelf, 0, 0, 0, 0, 0,
SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE |
SWP_NOZORDER | SWP_NOACTIVATE);
}
else if (infoPtr->TLbtnState == PGF_HOT)
{
infoPtr->TLbtnState = PGF_NORMAL;
/* FIXME: just invalidate button rect */
RedrawWindow(infoPtr->hwndSelf, NULL, NULL, RDW_FRAME | RDW_INVALIDATE);
}
if (infoPtr->BRbtnState == PGF_GRAYED)
{
infoPtr->BRbtnState = PGF_INVISIBLE;
SetWindowPos(infoPtr->hwndSelf, 0, 0, 0, 0, 0,
SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE |
SWP_NOZORDER | SWP_NOACTIVATE);
}
else if (infoPtr->BRbtnState == PGF_HOT)
{
infoPtr->BRbtnState = PGF_NORMAL;
/* FIXME: just invalidate button rect */
RedrawWindow(infoPtr->hwndSelf, NULL, NULL, RDW_FRAME | RDW_INVALIDATE);
}
/* Notify parent of released mouse capture */
memset(&nmhdr, 0, sizeof(NMHDR));
nmhdr.hwndFrom = infoPtr->hwndSelf;
nmhdr.idFrom = GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_ID);
nmhdr.code = NM_RELEASEDCAPTURE;
SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, nmhdr.idFrom, (LPARAM)&nmhdr);
}
if (IsWindow(infoPtr->hwndSelf))
KillTimer(infoPtr->hwndSelf, TIMERID1);
}
return 0;
}
void CResizeDlg::OnSize(UINT nType,int cx,int cy)
{
int nCount;
std::vector<CItemCtrl>::iterator it;
CDialog::OnSize(nType,cx,cy);
if((nCount = m_Items.size()) > 0) {
CRect cltRect;
GetClientRect(&cltRect);
ClientToScreen(cltRect);
HDWP hDWP;
int sizeType = WST_NONE;
#if 0
int deltaX = cltRect.Width() - m_cltRect.Width();
int deltaY = cltRect.Height()- m_cltRect.Height();
int midX = (cltRect.left + cltRect.right) / 2;
int midY = (cltRect.top + cltRect.bottom) / 2;
CPoint csrPt(::GetMessagePos());
if (deltaX) {
if (csrPt.x < midX)
sizeType |= WST_LEFT;
else
sizeType |= WST_RIGHT;
}
if (deltaY) {
if (csrPt.y < midY)
sizeType |= WST_TOP;
else
sizeType |= WST_BOTTOM;
}
#else
switch (m_nDelaySide) {
case WMSZ_BOTTOM:
sizeType = WST_BOTTOM;
break;
case WMSZ_BOTTOMLEFT:
sizeType = WST_BOTTOM|WST_LEFT;
break;
case WMSZ_BOTTOMRIGHT:
sizeType = WST_BOTTOM|WST_RIGHT;
break;
case WMSZ_LEFT:
sizeType = WST_LEFT;
break;
case WMSZ_RIGHT:
sizeType = WST_RIGHT;
break;
case WMSZ_TOP:
sizeType = WST_TOP;
break;
case WMSZ_TOPLEFT:
sizeType = WST_TOP|WST_LEFT;
break;
case WMSZ_TOPRIGHT:
sizeType = WST_TOP|WST_RIGHT;
break;
default:
break;
}
#endif
if (sizeType != WST_NONE) {
hDWP = ::BeginDeferWindowPos(nCount);
for (it = m_Items.begin(); it != m_Items.end(); it++)
hDWP = it->OnSize(hDWP, sizeType, &cltRect, &m_cltRect, &m_cltR0, this);
::EndDeferWindowPos(hDWP);
}
m_cltRect = cltRect;
}
m_nDelaySide = 0;
}
/*****************************************************************************
* x11_copy_to_screen
*
* Helper function that blts the front buffer contents to the target window
*
* Params:
* This: Surface to copy from
* rc: Rectangle to copy
*
*****************************************************************************/
void x11_copy_to_screen(IWineD3DSwapChainImpl *This, const RECT *rc)
{
IWineD3DSurfaceImpl *front = This->front_buffer;
if(front->resource.usage & WINED3DUSAGE_RENDERTARGET) {
POINT offset = {0,0};
HWND hDisplayWnd;
HDC hDisplayDC;
HDC hSurfaceDC = 0;
RECT drawrect;
TRACE("(%p)->(%p): Copying to screen\n", front, rc);
hSurfaceDC = front->hDC;
hDisplayWnd = This->win_handle;
hDisplayDC = GetDCEx(hDisplayWnd, 0, DCX_CLIPSIBLINGS|DCX_CACHE);
if(rc) {
TRACE(" copying rect (%d,%d)->(%d,%d), offset (%d,%d)\n",
rc->left, rc->top, rc->right, rc->bottom, offset.x, offset.y);
}
/* Front buffer coordinates are screen coordinates. Map them to the destination
* window if not fullscreened
*/
if(This->presentParms.Windowed) {
ClientToScreen(hDisplayWnd, &offset);
}
#if 0
/* FIXME: This doesn't work... if users really want to run
* X in 8bpp, then we need to call directly into display.drv
* (or Wine's equivalent), and force a private colormap
* without default entries. */
if (front->palette) {
SelectPalette(hDisplayDC, front->palette->hpal, FALSE);
RealizePalette(hDisplayDC); /* sends messages => deadlocks */
}
#endif
drawrect.left = 0;
drawrect.right = front->currentDesc.Width;
drawrect.top = 0;
drawrect.bottom = front->currentDesc.Height;
#if 0
/* TODO: Support clippers */
if (front->clipper)
{
RECT xrc;
HWND hwnd = ((IWineD3DClipperImpl *) front->clipper)->hWnd;
if (hwnd && GetClientRect(hwnd,&xrc))
{
OffsetRect(&xrc,offset.x,offset.y);
IntersectRect(&drawrect,&drawrect,&xrc);
}
}
#endif
if (rc) {
IntersectRect(&drawrect,&drawrect,rc);
}
else {
/* Only use this if the caller did not pass a rectangle, since
* due to double locking this could be the wrong one ...
*/
if (front->lockedRect.left != front->lockedRect.right) {
IntersectRect(&drawrect,&drawrect,&front->lockedRect);
}
}
BitBlt(hDisplayDC,
drawrect.left-offset.x, drawrect.top-offset.y,
drawrect.right-drawrect.left, drawrect.bottom-drawrect.top,
hSurfaceDC,
drawrect.left, drawrect.top,
SRCCOPY);
ReleaseDC(hDisplayWnd, hDisplayDC);
}
}
static LRESULT CALLBACK ContactListSubclassProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
TVITEM tvi;
CCList *dat = CWndUserData(GetParent(hWnd)).GetCList();
switch (Msg) {
case INTM_CONTACTDELETED: // wParam = (HANDLE)hContact
{
HTREEITEM hItem = dat->FindContact(wParam);
if (hItem)
TreeView_DeleteItem(hWnd, hItem);
}
break;
case INTM_ICONCHANGED: // wParam = (HANDLE)hContact, lParam = IconID
tvi.hItem = dat->FindContact(wParam);
if (tvi.hItem) {
tvi.mask = TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
tvi.iImage = tvi.iSelectedImage = lParam;
TreeView_SetItem(hWnd, &tvi);
dat->SortContacts();
InvalidateRect(hWnd, NULL, false);
}
break;
case INTM_INVALIDATE:
InvalidateRect(hWnd, NULL, true);
break;
case WM_RBUTTONDOWN:
SetFocus(hWnd);
{
TVHITTESTINFO hitTest;
hitTest.pt.x = (short)LOWORD(lParam);
hitTest.pt.y = (short)HIWORD(lParam);
TreeView_HitTest(hWnd, &hitTest);
if (hitTest.hItem && hitTest.flags & TVHT_ONITEM)
TreeView_SelectItem(hWnd, hitTest.hItem);
}
return DefWindowProc(hWnd, Msg, wParam, lParam);
case WM_LBUTTONDOWN:
{
POINT pt = { (short)LOWORD(lParam), (short)HIWORD(lParam) };
DWORD hitFlags;
HTREEITEM hItem = dat->HitTest(&pt, &hitFlags);
if (!hItem)
break;
if (hitFlags & MCLCHT_ONITEMICON) {
if (TreeView_GetChild(hWnd, hItem)) { // if it's a group, then toggle its state
NMTREEVIEW nmtv;
nmtv.hdr.hwndFrom = hWnd;
nmtv.hdr.idFrom = GetDlgCtrlID(hWnd);
nmtv.hdr.code = TVN_ITEMEXPANDING;
nmtv.action = TVE_TOGGLE;
nmtv.itemNew.hItem = hItem;
nmtv.itemNew.mask = TVIF_HANDLE | TVIF_STATE | TVIF_PARAM;
TreeView_GetItem(hWnd, &nmtv.itemNew);
nmtv.ptDrag = pt;
if (SendMessage(GetParent(hWnd), WM_NOTIFY, 0, (LPARAM)&nmtv))
return 0;
HTREEITEM hOldSelItem = TreeView_GetSelection(hWnd);
TreeView_Expand(hWnd, hItem, TVE_TOGGLE);
HTREEITEM hNewSelItem = TreeView_GetSelection(hWnd);
if (hNewSelItem != hOldSelItem) {
TreeView_SetItemState(hWnd, hOldSelItem, (dat->SelectedItems.Find(hOldSelItem) == -1) ? 0 : TVIS_SELECTED, TVIS_SELECTED);
TreeView_SetItemState(hWnd, hNewSelItem, (dat->SelectedItems.Find(hNewSelItem) == -1) ? 0 : TVIS_SELECTED, TVIS_SELECTED);
}
nmtv.hdr.code = TVN_ITEMEXPANDED;
TreeView_GetItem(hWnd, &nmtv.itemNew);
SendMessage(GetParent(hWnd), WM_NOTIFY, 0, (LPARAM)&nmtv);
return 0;
}
}
if (hitFlags & MCLCHT_ONITEM) {
if (wParam & MK_CONTROL) {
SetFocus(hWnd);
TREEITEMARRAY OldSelection = dat->SelectedItems;
int nIndex = dat->SelectedItems.Find(hItem);
if (nIndex == -1) {
TreeView_SetItemState(hWnd, hItem, TVIS_SELECTED, TVIS_SELECTED);
dat->SelectedItems.AddElem(hItem);
}
else {
TreeView_SetItemState(hWnd, hItem, 0, TVIS_SELECTED);
dat->SelectedItems.RemoveElem(nIndex);
}
dat->SelectGroups(hItem, nIndex == -1);
NMCLIST nm;
nm.hdr.code = MCLN_SELCHANGED;
nm.hdr.hwndFrom = hWnd;
nm.hdr.idFrom = GetDlgCtrlID(hWnd);
nm.OldSelection = &OldSelection;
nm.NewSelection = &dat->SelectedItems;
SendMessage(GetParent(hWnd), WM_NOTIFY, 0, (LPARAM)&nm);
return 0;
}
// if it was a click on the selected item and there's need to do something in this case, then send SELCHANGED notification by ourselves, as the tree control doesn't do anything
if (hItem == TreeView_GetSelection(hWnd) && (dat->SelectedItems.GetSize() != 1 || (dat->SelectedItems.GetSize() == 1 && dat->SelectedItems[0] != hItem))) {
TreeView_SetItemState(hWnd, hItem, TVIS_SELECTED, TVIS_SELECTED);
NMTREEVIEW nm = { 0 };
nm.hdr.code = TVN_SELCHANGED;
nm.hdr.hwndFrom = hWnd;
nm.hdr.idFrom = GetDlgCtrlID(hWnd);
nm.itemOld.hItem = TreeView_GetSelection(hWnd);
nm.itemOld.mask = TVIF_HANDLE | TVIF_STATE | TVIF_PARAM;
TreeView_GetItem(hWnd, &nm.itemOld);
nm.itemNew = nm.itemOld;
SendMessage(GetParent(hWnd), WM_NOTIFY, 0, (LPARAM)&nm);
}
}
}
break;
case WM_SETFOCUS:
case WM_KILLFOCUS:
for (int i = 0; i < dat->SelectedItems.GetSize(); i++) {
RECT rc;
if (TreeView_GetItemRect(hWnd, dat->SelectedItems[i], &rc, false))
InvalidateRect(hWnd, &rc, false);
}
break;
case WM_SIZE:
case WM_HSCROLL:
InvalidateRect(hWnd, NULL, false);
break;
case WM_MEASUREITEM:
if (!wParam) // if the message was sent by a menu
return Menu_MeasureItem((LPMEASUREITEMSTRUCT)lParam);
break;
case WM_DRAWITEM:
if (!wParam) // if the message was sent by a menu
return Menu_DrawItem((LPDRAWITEMSTRUCT)lParam);
break;
case WM_CONTEXTMENU:
{
POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
HTREEITEM hItem = NULL;
if (pt.x == -1 && pt.y == -1) {
if (dat->SelectedItems.GetSize() == 1) {
hItem = dat->SelectedItems[0];
TreeView_EnsureVisible(hWnd, hItem);
RECT rc;
TreeView_GetItemRect(hWnd, hItem, &rc, true);
pt.x = rc.left;
pt.y = rc.bottom;
}
}
else {
DWORD hitFlags;
ScreenToClient(hWnd, &pt);
hItem = dat->HitTest(&pt, &hitFlags);
if (!(hitFlags & MCLCHT_ONITEM))
hItem = NULL;
}
if (hItem) {
MCONTACT hContact = dat->GetItemData(hItem).hContact;
if (IsHContactContact(hContact)) {
HMENU hMenu = Menu_BuildContactMenu(hContact);
if (hMenu) {
ClientToScreen(hWnd, &pt);
CallService(MS_CLIST_MENUPROCESSCOMMAND, MAKEWPARAM(TrackPopupMenu(hMenu, TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_RETURNCMD, pt.x, pt.y, 0, hWnd, NULL), MPCF_CONTACTMENU), hContact);
DestroyMenu(hMenu);
return 0;
}
}
}
}
break;
case WM_DESTROY:
if (dat->ExtraImageList)
ImageList_Destroy(dat->ExtraImageList);
dat->SelectedItems.RemoveAll();
dat->Items.RemoveAll();
break;
}
return CallWindowProc(dat->OrigTreeViewProc, hWnd, Msg, wParam, lParam);
}
LRESULT CMainWindow::Splitter_OnLButtonUp(HWND hwnd, UINT /*iMsg*/, WPARAM /*wParam*/, LPARAM lParam)
{
HDC hdc;
RECT rect;
RECT clientrect;
POINT pt;
pt.x = (short)LOWORD(lParam); // horizontal position of cursor
pt.y = (short)HIWORD(lParam);
if (bDragMode == FALSE)
return 0;
GetClientRect(hwnd, &clientrect);
GetWindowRect(hwnd, &rect);
POINT zero = {0,0};
ClientToScreen(hwnd, &zero);
OffsetRect(&clientrect, zero.x-rect.left, zero.y-rect.top);
ClientToScreen(hwnd, &pt);
pt.x -= rect.left;
pt.y -= rect.top;
OffsetRect(&rect, -rect.left, -rect.top);
if (pt.x < 0)
pt.x = 0;
if (pt.x > rect.right-4)
pt.x = rect.right-4;
if (pt.y < 0)
pt.y = 0;
if (pt.y > rect.bottom-4)
pt.y = rect.bottom-4;
hdc = GetWindowDC(hwnd);
if (bVertical)
DrawXorBar(hdc, clientrect.left, oldy+2, clientrect.right-clientrect.left-2, 4);
else
DrawXorBar(hdc, oldx+2, clientrect.top, 4, clientrect.bottom-clientrect.top-2);
ReleaseDC(hwnd, hdc);
oldx = pt.x;
oldy = pt.y;
bDragMode = false;
//convert the splitter position back to screen coords.
GetWindowRect(hwnd, &rect);
pt.x += rect.left;
pt.y += rect.top;
//now convert into CLIENT coordinates
ScreenToClient(hwnd, &pt);
GetClientRect(hwnd, &rect);
#define MINWINSIZE 10
if (bVertical)
{
if (bDrag2)
{
if (pt.y < (nSplitterPos+MINWINSIZE))
pt.y = nSplitterPos+MINWINSIZE;
nSplitterPos2 = pt.y;
}
else
{
if (pt.y > (nSplitterPos2-MINWINSIZE))
pt.y = nSplitterPos2-MINWINSIZE;
nSplitterPos = pt.y;
}
}
else
{
if (bDrag2)
{
if (pt.x < (nSplitterPos+MINWINSIZE))
pt.x = nSplitterPos+MINWINSIZE;
nSplitterPos2 = pt.x;
}
else
{
if (pt.x > (nSplitterPos2-MINWINSIZE))
pt.x = nSplitterPos2-MINWINSIZE;
nSplitterPos = pt.x;
}
}
ReleaseCapture();
//position the child controls
PositionChildren(&rect);
return 0;
}
LRESULT CMainWindow::Splitter_OnLButtonDown(HWND hwnd, UINT /*iMsg*/, WPARAM /*wParam*/, LPARAM lParam)
{
POINT pt;
HDC hdc;
RECT rect;
RECT clientrect;
pt.x = (short)LOWORD(lParam); // horizontal position of cursor
pt.y = (short)HIWORD(lParam);
GetClientRect(hwnd, &clientrect);
GetWindowRect(hwnd, &rect);
POINT zero = {0,0};
ClientToScreen(hwnd, &zero);
OffsetRect(&clientrect, zero.x-rect.left, zero.y-rect.top);
ClientToScreen(hwnd, &pt);
// find out which drag bar is used
bDrag2 = false;
if (!selectionPaths.empty())
{
RECT pic2Rect;
GetWindowRect(picWindow2, &pic2Rect);
if (bVertical)
{
if (pic2Rect.bottom <= pt.y)
bDrag2 = true;
}
else
{
if (pic2Rect.right <= pt.x)
bDrag2 = true;
}
}
//convert the mouse coordinates relative to the top-left of
//the window
pt.x -= rect.left;
pt.y -= rect.top;
//same for the window coordinates - make them relative to 0,0
OffsetRect(&rect, -rect.left, -rect.top);
if (pt.x < 0)
pt.x = 0;
if (pt.x > rect.right-4)
pt.x = rect.right-4;
if (pt.y < 0)
pt.y = 0;
if (pt.y > rect.bottom-4)
pt.y = rect.bottom-4;
bDragMode = true;
SetCapture(hwnd);
hdc = GetWindowDC(hwnd);
if (bVertical)
DrawXorBar(hdc, clientrect.left, pt.y+2, clientrect.right-clientrect.left-2, 4);
else
DrawXorBar(hdc, pt.x+2, clientrect.top, 4, clientrect.bottom-clientrect.top-2);
ReleaseDC(hwnd, hdc);
oldx = pt.x;
oldy = pt.y;
return 0;
}
// This shows a little tooltip with the current Game's emulation state
void CGameListCtrl::OnMouseMotion(wxMouseEvent& event)
{
int flags;
long subitem = 0;
const long item = HitTest(event.GetPosition(), flags, &subitem);
static int lastItem = -1;
if (GetColumnCount() <= 1)
return;
if (item != wxNOT_FOUND)
{
wxRect Rect;
#ifdef __WXMSW__
if (subitem == COLUMN_EMULATION_STATE)
#else
// The subitem parameter of HitTest is only implemented for wxMSW. On
// all other platforms it will always be -1. Check the x position
// instead.
GetItemRect(item, Rect);
if (Rect.GetX() + Rect.GetWidth() - GetColumnWidth(COLUMN_EMULATION_STATE) < event.GetX())
#endif
{
if (toolTip || lastItem == item || this != FindFocus())
{
if (lastItem != item) lastItem = -1;
event.Skip();
return;
}
// Emulation status
static const char* const emuState[] = { "Broken", "Intro", "In-Game", "Playable", "Perfect" };
const GameListItem& rISO = *m_ISOFiles[GetItemData(item)];
const int emu_state = rISO.GetEmuState();
const std::string& issues = rISO.GetIssues();
// Show a tooltip containing the EmuState and the state description
if (emu_state > 0 && emu_state < 6)
{
char temp[2048];
sprintf(temp, "^ %s%s%s", emuState[emu_state - 1],
issues.size() > 0 ? " :\n" : "", issues.c_str());
toolTip = new wxEmuStateTip(this, StrToWxStr(temp), &toolTip);
}
else
{
toolTip = new wxEmuStateTip(this, _("Not Set"), &toolTip);
}
// Get item Coords
GetItemRect(item, Rect);
int mx = Rect.GetWidth();
int my = Rect.GetY();
#ifndef __WXMSW__
// For some reason the y position does not account for the header
// row, so subtract the y position of the first visible item.
GetItemRect(GetTopItem(), Rect);
my -= Rect.GetY();
#endif
// Convert to screen coordinates
ClientToScreen(&mx, &my);
toolTip->SetBoundingRect(wxRect(mx - GetColumnWidth(COLUMN_EMULATION_STATE),
my, GetColumnWidth(COLUMN_EMULATION_STATE), Rect.GetHeight()));
toolTip->SetPosition(wxPoint(mx - GetColumnWidth(COLUMN_EMULATION_STATE),
my - 5 + Rect.GetHeight()));
lastItem = item;
}
}
if (!toolTip)
lastItem = -1;
event.Skip();
}
LRESULT FTPWindow::MessageProc(UINT uMsg, WPARAM wParam, LPARAM lParam) {
bool doDefaultProc = false;
LRESULT result = 0;
switch(uMsg) {
case WM_SETFOCUS: {
//Why restore focus here? This window should never be able to get focus in the first place
HWND hPrev = (HWND)wParam;
if (hPrev != NULL)
::SetFocus(hPrev);
break; }
case WM_ERASEBKGND: {
HDC hDC = (HDC) wParam;
RECT rectClient;
GetClientRect(m_hwnd, &rectClient);
FillRect(hDC, &rectClient, m_backgroundBrush);
result = TRUE;
break; }
case WM_SETCURSOR: {
if (m_splitter.OnSetCursor()) {
return TRUE;
}
return FALSE;
break; }
case WM_CAPTURECHANGED: {
m_splitter.OnCaptureChanged((HWND)lParam);
break; }
case WM_LBUTTONDOWN: {
m_splitter.OnButtonDown();
break; }
case WM_LBUTTONUP: {
m_splitter.OnButtonUp();
m_ftpSettings->SetSplitRatio(m_splitter.GetRatio());
break; }
case WM_MOUSEMOVE: {
if (wParam & MK_LBUTTON) {
m_splitter.OnMouseMove();
}
break; }
case WM_COMMAND: {
switch(LOWORD(wParam)) {
case IDM_POPUP_QUEUE_ABORT: {
if (m_cancelOperation && m_cancelOperation->GetRunning()) {
m_ftpSession->AbortTransfer();
}
m_cancelOperation = NULL;
result = TRUE;
break; }
case IDM_POPUP_QUEUE_CANCEL: {
if (m_cancelOperation && !m_cancelOperation->GetRunning()) {
m_ftpSession->CancelOperation(m_cancelOperation);
}
m_cancelOperation = NULL;
result = TRUE;
break; }
case IDM_POPUP_LINKTYPE: {
m_currentSelection->SetDir(!m_currentSelection->isDir());
m_currentSelection->GetParent()->Sort();
m_treeview.UpdateFileObject(m_currentSelection);
result = TRUE;
break; }
case IDB_BUTTON_TOOLBAR_CONNECT: {
//Called by chevron popup: disconnect (ie no popup)
//disconnect();
result = TRUE;
break;}
case IDB_BUTTON_TOOLBAR_OPENDIR: {
// Show the dialog to get input directory name from the user.
InputDialog id;
int res = id.Create(m_hwnd, TEXT("Open Directory"), TEXT("Enter directory name:"), TEXT(""));
if (res != 1) {
return 0;
}
// Read the input directory name.
const TCHAR *dirName = id.GetValue();
char *dirNameCP = SU::TCharToCP(dirName, CP_ACP);
m_ftpSession->GetDirectoryHierarchy(dirNameCP);
break;
}
case IDM_POPUP_DOWNLOADFILE:
case IDB_BUTTON_TOOLBAR_DOWNLOAD: {
SHORT state = GetKeyState(VK_CONTROL);
if (!(state & 0x8000)) {
m_ftpSession->DownloadFileCache(m_currentSelection->GetPath());
result = TRUE;
break;
}
//else fallthrough
}
case IDM_POPUP_DLDTOLOCATION: {
TCHAR target[MAX_PATH];
lstrcpy(target, m_currentSelection->GetLocalName());
int res = PU::GetSaveFilename(target, MAX_PATH, m_hwnd);
if (res == 0) {
m_ftpSession->DownloadFile(m_currentSelection->GetPath(), target, false);
}
result = TRUE;
break; }
case IDM_POPUP_UPLOADFILE:
case IDB_BUTTON_TOOLBAR_UPLOAD: {
//upload(TRUE, TRUE); //upload to cached folder is present, else upload to last selected folder
//m_ftpSession->UploadFile();
TCHAR source[MAX_PATH];
BOOL doUpload = FALSE;
SHORT state = GetKeyState(VK_CONTROL);
if ((state & 0x8000) && LOWORD(wParam) == IDB_BUTTON_TOOLBAR_UPLOAD) {
source[0] = 0;
int res = PU::GetOpenFilename(source, MAX_PATH, m_hParent);
if (res == 0)
doUpload = TRUE;
} else {
doUpload = ::SendMessage(m_hNpp, NPPM_GETFULLCURRENTPATH, (WPARAM)MAX_PATH, (LPARAM)source);
}
if (doUpload == TRUE) {
if (m_currentSelection->isDir()) {
m_ftpSession->UploadFile(source, m_currentSelection->GetPath(), true);
} else {
m_ftpSession->UploadFile(source, m_currentSelection->GetParent()->GetPath(), true);
}
}
result = TRUE;
break;}
case IDM_POPUP_UPLOADOTHERFILE: {
TCHAR source[MAX_PATH];
source[0] = 0;
int res = PU::GetOpenFilename(source, MAX_PATH, m_hwnd);
if (res == 0) {
m_ftpSession->UploadFile(source, m_currentSelection->GetPath(), true);
}
result = TRUE;
break; }
case IDM_POPUP_REFRESHDIR:
case IDB_BUTTON_TOOLBAR_REFRESH: {
m_ftpSession->GetDirectory(m_currentSelection->GetPath());
result = TRUE;
break; }
case IDB_BUTTON_TOOLBAR_ABORT: {
m_ftpSession->AbortTransfer();
result = TRUE;
break; }
case IDB_BUTTON_TOOLBAR_RAWCMD: {
//rawCommand();
result = TRUE;
break; }
case IDB_BUTTON_TOOLBAR_SETTINGS: {
//Should be handled by dropdown
result = TRUE;
break; }
case IDB_BUTTON_TOOLBAR_MESSAGES: {
m_outputShown = !m_outputWindow.IsVisible();
m_outputWindow.Show(m_outputShown);
result = TRUE;
break; }
case IDM_POPUP_NEWDIR: {
this->CreateDirectory(m_currentSelection);
result = TRUE;
break; }
case IDM_POPUP_DELETEDIR: {
this->DeleteDirectory(m_currentSelection);
result = TRUE;
break; }
case IDM_POPUP_NEWFILE: {
this->CreateFile(m_currentSelection);
result = TRUE;
break; }
case IDM_POPUP_DELETEFILE: {
this->DeleteFile(m_currentSelection);
result = TRUE;
break; }
case IDM_POPUP_RENAMEFILE:
case IDM_POPUP_RENAMEDIR: {
this->Rename(m_currentSelection);
result = TRUE;
break; }
case IDM_POPUP_SETTINGSGENERAL: {
m_settingsDialog.Create(m_hwnd, m_ftpSettings);
result = TRUE;
break; }
case IDM_POPUP_SETTINGSPROFILE: {
m_profilesDialog.Create(m_hwnd, this, m_vProfiles, m_ftpSettings->GetGlobalCache());
result = TRUE;
break; }
default: {
unsigned int value = LOWORD(wParam);
if (!m_busy && value >= IDM_POPUP_PROFILE_FIRST && value <= IDM_POPUP_PROFILE_MAX) {
FTPProfile * profile = m_vProfiles->at(value - IDM_POPUP_PROFILE_FIRST);
int ret = m_ftpSession->StartSession(profile);
if (ret == -1) {
OutErr("[NppFTP] Cannot start FTP session");
result = TRUE;
break;
}
m_ftpSession->Connect();
result = TRUE;
} else {
doDefaultProc = true;
}
break; }
}
break; }
case WM_NOTIFY: {
NMHDR nmh = (NMHDR) *((NMHDR*)lParam);
if (nmh.hwndFrom == m_toolbar.GetHWND()) {
switch(nmh.code) {
case TBN_DROPDOWN: {
NMTOOLBAR * pnmtb = (NMTOOLBAR*)lParam;
switch(pnmtb->iItem) {
case IDB_BUTTON_TOOLBAR_CONNECT: {
if (m_ftpSession->IsConnected()) { //only call disconnect routine to disconnect, else pick profile
m_ftpSession->TerminateSession();
return TBDDRET_DEFAULT;
}
result = m_toolbar.DoDropDown(IDB_BUTTON_TOOLBAR_CONNECT);
break; }
case IDB_BUTTON_TOOLBAR_SETTINGS: {
result = m_toolbar.DoDropDown(IDB_BUTTON_TOOLBAR_SETTINGS);
break; }
default: {
result = TBDDRET_NODEFAULT;
break; }
}
break; }
default: {
doDefaultProc = true;
break; }
}
} else if (nmh.hwndFrom == m_hNpp) {
return DockableWindow::MessageProc(uMsg, wParam, lParam);
} else if (nmh.hwndFrom == m_treeview.GetHWND()) {
switch(nmh.code) {
case TVN_SELCHANGED: {
const NM_TREEVIEW & nmt = (NM_TREEVIEW) *(NM_TREEVIEW*)lParam;
m_currentSelection = m_treeview.GetItemFileObject(nmt.itemNew.hItem);
SetToolbarState();
result = TRUE;
break; }
case TVN_ITEMEXPANDING: {
const NM_TREEVIEW & nmt = (NM_TREEVIEW) *(NM_TREEVIEW*)lParam;
int res = m_treeview.OnExpanding(&nmt);
if (res == TRUE) {
FileObject * fo = (FileObject*) nmt.itemNew.lParam;
m_ftpSession->GetDirectory(fo->GetPath());
}
return res;
break; }
case TVN_GETDISPINFO: {
TV_DISPINFO * ptvdi = (TV_DISPINFO*)lParam;
m_treeview.GetDispInfo(ptvdi);
result = TRUE;
break; }
case NM_RCLICK:
case NM_DBLCLK:
case NM_CLICK: {
HTREEITEM res = m_treeview.OnClick();
if (res) {
m_currentSelection = m_treeview.GetItemFileObject(res);
SetToolbarState();
if (nmh.code == (UINT)NM_DBLCLK) {
OnItemActivation();
result = TRUE;
}
}
break; }
case NM_RETURN: {
OnItemActivation();
result = TRUE; //handle message
break; }
case TVN_SELCHANGING: {
result = FALSE;
break; }
case TVN_BEGINDRAG: {
result = FALSE;
/*
if (m_currentDropObject != NULL) { //currently only one queued DnD op is supported
result = FALSE;
break;
}
NMTREEVIEW * pnmtv = (NMTREEVIEW*)lParam;
HTREEITEM hti = pnmtv->itemNew.hItem;
FileObject * fo = m_treeview.GetItemFileObject(hti);
if (fo != NULL) {
m_currentDropObject = fo;
m_dndWindow.Create(m_hwnd);
::PostMessage(m_dndWindow.GetHWND(), WM_DND, 0, 0);
result = TRUE;
}
*/
break; }
default: {
doDefaultProc = true;
break; }
}
} else if (nmh.hwndFrom == m_rebar.GetHWND()) {
switch(nmh.code) {
case RBN_CHEVRONPUSHED: {
NMREBARCHEVRON * lpnm = (NMREBARCHEVRON*) lParam;
POINT pt;
pt.x = lpnm->rc.left;//right;
pt.y = lpnm->rc.bottom;
ClientToScreen(m_rebar.GetHWND(), &pt);
m_toolbar.DoPopop(pt);
result = TRUE;
break; }
default: {
doDefaultProc = true;
break; }
}
} else {
switch(nmh.code) {
case TTN_GETDISPINFO: {
LPTOOLTIPTEXT lpttt = (LPTOOLTIPTEXT) lParam;
lpttt->hinst = NULL;
lpttt->lpszText = (TCHAR*)m_toolbar.GetTooltip(lpttt->hdr.idFrom);
result = TRUE;
break; }
default: {
doDefaultProc = true;
break; }
}
}
break; }
case WM_CONTEXTMENU: {
HWND hWinContext = (HWND)wParam;
HMENU hContext = NULL;
POINT menuPos;
menuPos.x = GET_X_LPARAM(lParam);
menuPos.y = GET_Y_LPARAM(lParam);
bool fromKeyboard = (menuPos.x == -1 && menuPos.y == -1);
if (fromKeyboard) { //keyboard activation
DWORD pos = GetMessagePos();
menuPos.x = GET_X_LPARAM(pos);
menuPos.y = GET_Y_LPARAM(pos);
}
if (hWinContext == m_treeview.GetHWND()) {
if (!m_currentSelection) {
result = FALSE;
break;
}
if (fromKeyboard) {
RECT treerect;
bool res = m_treeview.GetObjectItemRect(m_currentSelection, &treerect);
if (res) {
menuPos.x = treerect.left;
menuPos.y = treerect.bottom;
::ClientToScreen(m_treeview.GetHWND(), &menuPos);
}
}
SHORT state = GetKeyState(VK_SHIFT);
if ((state & 0x8000) && m_currentSelection->isLink() && !fromKeyboard) {
hContext = m_popupLink;
} else if (m_currentSelection->isDir()) {
hContext = m_popupDir;
} else {
hContext = m_popupFile;
}
} else if (hWinContext == m_queueWindow.GetHWND()) {
QueueOperation * op = m_queueWindow.GetSelectedQueueOperation();
if (!op) {
result = FALSE;
break;
}
m_cancelOperation = op;
bool run = op->GetRunning();
if (fromKeyboard) {
RECT queuerect;
bool res = m_queueWindow.GetSelectedQueueRect(&queuerect);
if (res) {
menuPos.x = queuerect.left;
menuPos.y = queuerect.bottom;
::ClientToScreen(m_queueWindow.GetHWND(), &menuPos);
}
}
if (run) {
hContext = m_popupQueueActive;
} else {
hContext = m_popupQueueHold;
}
}
if (!hContext) {
result = FALSE;
break;
}
::TrackPopupMenu(hContext, TPM_LEFTALIGN, menuPos.x, menuPos.y, 0, m_hwnd, NULL);
result = TRUE;
break; }
case WM_OUTPUTSHOWN: {
if (wParam == TRUE) {
m_outputShown = true;
m_toolbar.SetChecked(IDB_BUTTON_TOOLBAR_MESSAGES, TRUE);
m_ftpSettings->SetOutputShown(true);
} else {
m_outputShown = false;
m_toolbar.SetChecked(IDB_BUTTON_TOOLBAR_MESSAGES, FALSE);
m_ftpSettings->SetOutputShown(false);
}
break; }
case NotifyMessageStart:
case NotifyMessageEnd: {
bool isStart = (uMsg == (UINT)NotifyMessageStart);
int code = (int)wParam;
QueueOperation * queueOp = (QueueOperation*)lParam;
void * notifyData = queueOp->GetNotifyData();
int res = OnEvent(queueOp, code, notifyData, isStart);
if (res != 1) //if res == 1, then queueop becomes invalid
queueOp->AckNotification();
return TRUE;
break;}
case NotifyMessageAdd: {
QueueOperation * queueOp = (QueueOperation*)lParam;
m_queueWindow.PushQueueItem(queueOp);
queueOp->AckNotification();
return TRUE;
break; }
case NotifyMessageRemove: {
QueueOperation * queueOp = (QueueOperation*)lParam;
m_queueWindow.RemoveQueueItem(queueOp);
queueOp->AckNotification();
return TRUE;
break; }
case NotifyMessageProgress: {
QueueOperation * queueOp = (QueueOperation*)lParam;
m_queueWindow.ProgressQueueItem(queueOp);
queueOp->AckNotification();
break; }
default:
doDefaultProc = true;
break;
}
if (doDefaultProc)
result = DockableWindow::MessageProc(uMsg, wParam, lParam);
return result;
}
void CHistoryCombo::OnMouseMove(UINT nFlags, CPoint point)
{
CRect rectClient;
GetClientRect(&rectClient);
int nComboButtonWidth = ::GetSystemMetrics(SM_CXHTHUMB) + 2;
rectClient.right = rectClient.right - nComboButtonWidth;
if (rectClient.PtInRect(point))
{
ClientToScreen(&rectClient);
m_ToolText = GetString();
m_ToolInfo.lpszText = (LPTSTR)(LPCTSTR)m_ToolText;
HDC hDC = ::GetDC(m_hWnd);
CFont *pFont = GetFont();
HFONT hOldFont = (HFONT) ::SelectObject(hDC, (HFONT) *pFont);
SIZE size;
::GetTextExtentPoint32(hDC, m_ToolText, m_ToolText.GetLength(), &size);
::SelectObject(hDC, hOldFont);
::ReleaseDC(m_hWnd, hDC);
if (size.cx > (rectClient.Width() - 6))
{
rectClient.left += 1;
rectClient.top += 3;
COLORREF rgbText = ::GetSysColor(COLOR_WINDOWTEXT);
COLORREF rgbBackground = ::GetSysColor(COLOR_WINDOW);
CWnd *pWnd = GetFocus();
if (pWnd)
{
if (pWnd->m_hWnd == m_hWnd)
{
rgbText = ::GetSysColor(COLOR_HIGHLIGHTTEXT);
rgbBackground = ::GetSysColor(COLOR_HIGHLIGHT);
}
}
if (!m_ttShown)
{
::SendMessage(m_hWndToolTip, TTM_SETTIPBKCOLOR, rgbBackground, 0);
::SendMessage(m_hWndToolTip, TTM_SETTIPTEXTCOLOR, rgbText, 0);
::SendMessage(m_hWndToolTip, TTM_UPDATETIPTEXT, 0, (LPARAM) &m_ToolInfo);
::SendMessage(m_hWndToolTip, TTM_TRACKPOSITION, 0, (LPARAM)MAKELONG(rectClient.left, rectClient.top));
::SendMessage(m_hWndToolTip, TTM_TRACKACTIVATE, TRUE, (LPARAM)(LPTOOLINFO) &m_ToolInfo);
SetTimer(1, 80, nullptr);
SetTimer(2, 2000, nullptr);
m_ttShown = TRUE;
}
}
else
{
::SendMessage(m_hWndToolTip, TTM_TRACKACTIVATE, FALSE, (LPARAM)(LPTOOLINFO) &m_ToolInfo);
m_ttShown = FALSE;
}
}
else
{
::SendMessage(m_hWndToolTip, TTM_TRACKACTIVATE, FALSE, (LPARAM)(LPTOOLINFO) &m_ToolInfo);
m_ttShown = FALSE;
}
CComboBoxEx::OnMouseMove(nFlags, point);
}
/*
================
rvGENavigator::WndProc
Window Procedure
================
*/
LRESULT CALLBACK rvGENavigator::WndProc ( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
rvGENavigator* nav = (rvGENavigator*) GetWindowLong ( hWnd, GWL_USERDATA );
switch ( msg )
{
case WM_INITMENUPOPUP:
return SendMessage ( gApp.GetMDIFrame ( ), msg, wParam, lParam );
case WM_ACTIVATE:
common->ActivateTool( LOWORD( wParam ) != WA_INACTIVE );
break;
case WM_ERASEBKGND:
return TRUE;
case WM_DESTROY:
gApp.GetOptions().SetWindowPlacement ( "navigator", hWnd );
break;
case WM_CLOSE:
gApp.GetOptions().SetNavigatorVisible ( false );
nav->Show ( false );
return 0;
case WM_DRAWITEM:
{
DRAWITEMSTRUCT* dis = (DRAWITEMSTRUCT*) lParam;
idWindow* window = (idWindow*)dis->itemData;
if ( window )
{
rvGEWindowWrapper* wrapper = rvGEWindowWrapper::GetWrapper ( window );
idStr name = window->GetName();
RECT rDraw;
float offset;
bool disabled;
idWindow* parent = window;
offset = 1;
disabled = false;
while ( parent = parent->GetParent ( ) )
{
if ( rvGEWindowWrapper::GetWrapper ( parent )->IsHidden ( ) )
{
disabled = true;
}
offset += 10;
}
CopyRect ( &rDraw, &dis->rcItem );
rDraw.right = rDraw.left + GENAV_ITEMHEIGHT;
rDraw.top ++;
rDraw.right ++;
FrameRect ( dis->hDC, &rDraw, (HBRUSH)GetStockObject ( BLACK_BRUSH ) );
rDraw.right --;
FillRect ( dis->hDC, &rDraw, GetSysColorBrush ( COLOR_3DFACE ) );
Draw3dRect ( dis->hDC, &rDraw, GetSysColorBrush ( COLOR_3DHILIGHT ), GetSysColorBrush ( COLOR_3DSHADOW ) );
InflateRect ( &rDraw, -3, -3 );
Draw3dRect ( dis->hDC, &rDraw, GetSysColorBrush ( COLOR_3DSHADOW ), GetSysColorBrush ( COLOR_3DHILIGHT ) );
if ( !wrapper->IsHidden ( ) )
{
DrawIconEx ( dis->hDC, rDraw.left, rDraw.top, disabled?nav->mVisibleIconDisabled:nav->mVisibleIcon, 16, 16,0, NULL, DI_NORMAL );
}
CopyRect ( &rDraw, &dis->rcItem );
rDraw.left += GENAV_ITEMHEIGHT;
rDraw.left += 1;
if ( dis->itemState & ODS_SELECTED )
{
FillRect ( dis->hDC, &rDraw, GetSysColorBrush ( COLOR_HIGHLIGHT ) );
}
else
{
FillRect ( dis->hDC, &rDraw, GetSysColorBrush ( COLOR_WINDOW ) );
}
if ( wrapper->CanHaveChildren ( ) && window->GetChildCount ( ) )
{
if ( wrapper->IsExpanded ( ) )
{
DrawIconEx ( dis->hDC, rDraw.left + offset, rDraw.top + 3, nav->mCollapseIcon, 16, 16,0, NULL, DI_NORMAL );
}
else
{
DrawIconEx ( dis->hDC, rDraw.left + offset, rDraw.top + 3, nav->mExpandIcon, 16, 16,0, NULL, DI_NORMAL );
}
}
HPEN pen = CreatePen ( PS_SOLID, 1, GetSysColor ( COLOR_3DSHADOW ) );
HPEN oldpen = (HPEN)SelectObject ( dis->hDC, pen );
MoveToEx ( dis->hDC, rDraw.left, dis->rcItem.top, NULL );
LineTo ( dis->hDC, dis->rcItem.right, dis->rcItem.top );
MoveToEx ( dis->hDC, rDraw.left, dis->rcItem.bottom, NULL );
LineTo ( dis->hDC, dis->rcItem.right, dis->rcItem.bottom);
SelectObject ( dis->hDC, oldpen );
DeleteObject ( pen );
rDraw.left += offset;
rDraw.left += 20;
int colorIndex = ( (dis->itemState & ODS_SELECTED ) ? COLOR_HIGHLIGHTTEXT : COLOR_WINDOWTEXT );
SetTextColor ( dis->hDC, GetSysColor ( colorIndex ) );
DrawText ( dis->hDC, name, name.Length(), &rDraw, DT_LEFT|DT_VCENTER|DT_SINGLELINE );
if ( wrapper->GetVariableDict().GetNumKeyVals ( ) || wrapper->GetScriptDict().GetNumKeyVals ( ) )
{
DrawIconEx ( dis->hDC, dis->rcItem.right - 16, (dis->rcItem.bottom+dis->rcItem.top)/2-6, (dis->itemState & ODS_SELECTED)?nav->mScriptsLightIcon:nav->mScriptsIcon, 13, 13,0, NULL, DI_NORMAL );
}
}
break;
}
case WM_MEASUREITEM:
{
MEASUREITEMSTRUCT* mis = (MEASUREITEMSTRUCT*) lParam;
mis->itemHeight = 22;
break;
}
case WM_CREATE:
{
LPCREATESTRUCT cs;
LVCOLUMN col;
// Attach the class to the window first
cs = (LPCREATESTRUCT) lParam;
nav = (rvGENavigator*) cs->lpCreateParams;
SetWindowLong ( hWnd, GWL_USERDATA, (LONG)nav );
// Create the List view
nav->mTree = CreateWindowEx ( 0, "SysListView32", "", WS_VSCROLL|WS_CHILD|WS_VISIBLE|LVS_REPORT|LVS_OWNERDRAWFIXED|LVS_NOCOLUMNHEADER|LVS_SHOWSELALWAYS, 0, 0, 0, 0, hWnd, (HMENU)IDC_GUIED_WINDOWTREE, win32.hInstance, 0 );
ListView_SetExtendedListViewStyle ( nav->mTree, LVS_EX_FULLROWSELECT );
ListView_SetBkColor ( nav->mTree, GetSysColor ( COLOR_3DFACE ) );
ListView_SetTextBkColor ( nav->mTree, GetSysColor ( COLOR_3DFACE ) );
nav->mListWndProc = (WNDPROC)GetWindowLong ( nav->mTree, GWL_WNDPROC );
SetWindowLong ( nav->mTree, GWL_USERDATA, (LONG)nav );
SetWindowLong ( nav->mTree, GWL_WNDPROC, (LONG)ListWndProc );
// Insert the only column
col.mask = 0;
ListView_InsertColumn ( nav->mTree, 0, &col );
break;
}
case WM_SIZE:
{
RECT rClient;
MoveWindow ( nav->mTree, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE );
GetClientRect ( nav->mTree, &rClient );
ListView_SetColumnWidth ( nav->mTree, 0, rClient.right-rClient.left-1 );
break;
}
case WM_NCACTIVATE:
return gApp.ToolWindowActivate ( gApp.GetMDIFrame(), msg, wParam, lParam );
case WM_NOTIFY:
{
LPNMHDR nh;
nh = (LPNMHDR) lParam;
switch ( nh->code )
{
case NM_CLICK:
case NM_DBLCLK:
{
DWORD dwpos = GetMessagePos();
LVHITTESTINFO info;
info.pt.x = LOWORD(dwpos);
info.pt.y = HIWORD(dwpos);
MapWindowPoints(HWND_DESKTOP, nh->hwndFrom, &info.pt, 1);
int index = ListView_HitTest ( nav->mTree, &info );
if ( index != -1 )
{
RECT rItem;
int offset;
ListView_GetItemRect ( nav->mTree, index, &rItem, LVIR_BOUNDS );
LVITEM item;
item.mask = LVIF_PARAM;
item.iItem = index;
ListView_GetItem ( nav->mTree, &item );
idWindow* window = (idWindow*)item.lParam;
rvGEWindowWrapper* wrapper = rvGEWindowWrapper::GetWrapper(window);
offset = wrapper->GetDepth ( ) * 10 + 1;
if ( info.pt.x < GENAV_ITEMHEIGHT )
{
if ( !rvGEWindowWrapper::GetWrapper(window)->IsHidden ( ) )
{
nav->mWorkspace->HideWindow ( window );
}
else
{
nav->mWorkspace->UnhideWindow ( window );
}
}
else if ( info.pt.x > GENAV_ITEMHEIGHT + offset && info.pt.x < GENAV_ITEMHEIGHT + offset + 16 )
{
if ( wrapper->CanHaveChildren ( ) && window->GetChildCount ( ) )
{
if ( wrapper->IsExpanded ( ) )
{
wrapper->Collapse ( );
nav->Update ( );
}
else
{
wrapper->Expand ( );
nav->Update ( );
}
}
}
else if ( nh->code == NM_DBLCLK )
{
SendMessage ( gApp.GetMDIFrame ( ), WM_COMMAND, MAKELONG(ID_GUIED_ITEM_PROPERTIES,0), 0 );
}
}
break;
}
case NM_RCLICK:
{
DWORD dwpos = GetMessagePos();
LVHITTESTINFO info;
info.pt.x = LOWORD(dwpos);
info.pt.y = HIWORD(dwpos);
MapWindowPoints(HWND_DESKTOP, nh->hwndFrom, &info.pt, 1);
int index = ListView_HitTest ( nav->mTree, &info );
if ( index != -1 )
{
ClientToScreen ( hWnd, &info.pt );
HMENU menu = GetSubMenu ( LoadMenu ( gApp.GetInstance(), MAKEINTRESOURCE(IDR_GUIED_ITEM_POPUP) ), 0 );
TrackPopupMenu ( menu, TPM_RIGHTBUTTON|TPM_LEFTALIGN, info.pt.x, info.pt.y, 0, gApp.GetMDIFrame ( ), NULL );
DestroyMenu ( menu );
}
break;
}
case LVN_ITEMCHANGED:
{
NMLISTVIEW* nml = (NMLISTVIEW*) nh;
if ( (nml->uNewState & LVIS_SELECTED) != (nml->uOldState & LVIS_SELECTED) )
{
LVITEM item;
item.iItem = nml->iItem;
item.mask = LVIF_PARAM;
ListView_GetItem ( nav->mTree, &item );
if ( nml->uNewState & LVIS_SELECTED )
{
nav->mWorkspace->GetSelectionMgr().Add ( (idWindow*)item.lParam, false );
}
else
{
nav->mWorkspace->GetSelectionMgr().Remove ( (idWindow*)item.lParam );
}
}
break;
}
}
break;
}
}
return DefWindowProc ( hWnd, msg, wParam, lParam );
}
static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam,
LPARAM lParam)
{
if (message == WM_NCCREATE) {
CREATESTRUCT *cs = (void*)lParam;
SetWindowLongPtrW(hWnd, GWLP_USERDATA, (LONG_PTR)cs->lpCreateParams);
}
struct vo *vo = (void*)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
// message before WM_NCCREATE, pray to Raymond Chen that it's not important
if (!vo)
return DefWindowProcW(hWnd, message, wParam, lParam);
struct vo_w32_state *w32 = vo->w32;
int mouse_button = 0;
switch (message) {
case WM_ERASEBKGND: // no need to erase background seperately
return 1;
case WM_PAINT:
w32->event_flags |= VO_EVENT_EXPOSE;
break;
case WM_MOVE: {
POINT p = {0};
ClientToScreen(w32->window, &p);
w32->window_x = p.x;
w32->window_y = p.y;
MP_VERBOSE(vo, "move window: %d:%d\n",
w32->window_x, w32->window_y);
break;
}
case WM_SIZE: {
w32->event_flags |= VO_EVENT_RESIZE;
RECT r;
GetClientRect(w32->window, &r);
vo->dwidth = r.right;
vo->dheight = r.bottom;
MP_VERBOSE(vo, "resize window: %d:%d\n",
vo->dwidth, vo->dheight);
break;
}
case WM_SIZING:
if (vo->opts->keepaspect && !vo->opts->fullscreen &&
vo->opts->WinID < 0)
{
RECT *rc = (RECT*)lParam;
// get client area of the windows if it had the rect rc
// (subtracting the window borders)
RECT r = *rc;
subtract_window_borders(w32->window, &r);
int c_w = r.right - r.left, c_h = r.bottom - r.top;
float aspect = w32->o_dwidth / (float) MPMAX(w32->o_dheight, 1);
int d_w = c_h * aspect - c_w;
int d_h = c_w / aspect - c_h;
int d_corners[4] = { d_w, d_h, -d_w, -d_h };
int corners[4] = { rc->left, rc->top, rc->right, rc->bottom };
int corner = get_resize_border(wParam);
if (corner >= 0)
corners[corner] -= d_corners[corner];
*rc = (RECT) { corners[0], corners[1], corners[2], corners[3] };
return TRUE;
}
break;
case WM_CLOSE:
mp_input_put_key(vo->input_ctx, MP_KEY_CLOSE_WIN);
break;
case WM_SYSCOMMAND:
switch (wParam) {
case SC_SCREENSAVE:
case SC_MONITORPOWER:
if (w32->disable_screensaver) {
MP_VERBOSE(vo, "win32: killing screensaver\n");
return 0;
}
break;
}
break;
case WM_KEYDOWN:
case WM_SYSKEYDOWN: {
int mpkey = lookup_keymap_table(vk_map, wParam);
if (mpkey)
mp_input_put_key(vo->input_ctx, mpkey | mod_state(vo));
if (wParam == VK_F10)
return 0;
break;
}
case WM_CHAR:
case WM_SYSCHAR: {
int mods = mod_state(vo);
int code = wParam;
// Windows enables Ctrl+Alt when AltGr (VK_RMENU) is pressed.
// E.g. AltGr+9 on a German keyboard would yield Ctrl+Alt+[
// Warning: wine handles this differently. Don't test this on wine!
if (key_state(vo, VK_RMENU))
mods &= ~(MP_KEY_MODIFIER_CTRL | MP_KEY_MODIFIER_ALT);
// Apparently Ctrl+A to Ctrl+Z is special cased, and produces
// character codes from 1-26. Work it around.
// Also, enter/return (including the keypad variant) and CTRL+J both
// map to wParam==10. As a workaround, check VK_RETURN to
// distinguish these two key combinations.
if ((mods & MP_KEY_MODIFIER_CTRL) && code >= 1 && code <= 26
&& !key_state(vo, VK_RETURN))
code = code - 1 + (mods & MP_KEY_MODIFIER_SHIFT ? 'A' : 'a');
if (code >= 32 && code < (1<<21)) {
mp_input_put_key(vo->input_ctx, code | mods);
// At least with Alt+char, not calling DefWindowProcW stops
// Windows from emitting a beep.
return 0;
}
break;
}
case WM_SETCURSOR:
if (LOWORD(lParam) == HTCLIENT && !w32->cursor_visible) {
SetCursor(NULL);
return TRUE;
}
break;
case WM_MOUSELEAVE:
w32->tracking = FALSE;
mp_input_put_key(vo->input_ctx, MP_KEY_MOUSE_LEAVE);
break;
case WM_MOUSEMOVE: {
if (!w32->tracking)
w32->tracking = TrackMouseEvent(&w32->trackEvent);
// Windows can send spurious mouse events, which would make the mpv
// core unhide the mouse cursor on completely unrelated events. See:
// https://blogs.msdn.com/b/oldnewthing/archive/2003/10/01/55108.aspx
int x = GET_X_LPARAM(lParam);
int y = GET_Y_LPARAM(lParam);
if (x != w32->mouse_x || y != w32->mouse_y) {
w32->mouse_x = x;
w32->mouse_y = y;
vo_mouse_movement(vo, x, y);
}
break;
}
case WM_LBUTTONDOWN:
mouse_button = MP_MOUSE_BTN0 | MP_KEY_STATE_DOWN;
break;
case WM_LBUTTONUP:
mouse_button = MP_MOUSE_BTN0 | MP_KEY_STATE_UP;
break;
case WM_MBUTTONDOWN:
mouse_button = MP_MOUSE_BTN1 | MP_KEY_STATE_DOWN;
break;
case WM_MBUTTONUP:
mouse_button = MP_MOUSE_BTN1 | MP_KEY_STATE_UP;
break;
case WM_RBUTTONDOWN:
mouse_button = MP_MOUSE_BTN2 | MP_KEY_STATE_DOWN;
break;
case WM_RBUTTONUP:
mouse_button = MP_MOUSE_BTN2 | MP_KEY_STATE_UP;
break;
case WM_MOUSEWHEEL: {
int x = GET_WHEEL_DELTA_WPARAM(wParam);
mouse_button = x > 0 ? MP_MOUSE_BTN3 : MP_MOUSE_BTN4;
break;
}
case WM_XBUTTONDOWN:
mouse_button = HIWORD(wParam) == 1 ? MP_MOUSE_BTN5 : MP_MOUSE_BTN6;
mouse_button |= MP_KEY_STATE_DOWN;
break;
case WM_XBUTTONUP:
mouse_button = HIWORD(wParam) == 1 ? MP_MOUSE_BTN5 : MP_MOUSE_BTN6;
mouse_button |= MP_KEY_STATE_UP;
break;
}
if (mouse_button && vo->opts->enable_mouse_movements) {
int x = GET_X_LPARAM(lParam);
int y = GET_Y_LPARAM(lParam);
mouse_button |= mod_state(vo);
if (mouse_button == (MP_MOUSE_BTN0 | MP_KEY_STATE_DOWN) &&
!vo->opts->fullscreen && !mp_input_test_dragging(vo->input_ctx, x, y))
{
// Window dragging hack
ReleaseCapture();
SendMessage(hWnd, WM_NCLBUTTONDOWN, HTCAPTION, 0);
return 0;
}
mp_input_put_key(vo->input_ctx, mouse_button);
}
return DefWindowProcW(hWnd, message, wParam, lParam);
}
static IntPoint globalPositionForEvent(HWND hWnd, LPARAM lParam)
{
POINT point = {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
ClientToScreen(hWnd, &point);
return point;
}
static void test_default_client_accessible_object(void)
{
static const WCHAR testW[] = {'t','e','s','t',' ','t',' ','&','j','u','n','k',0};
static const WCHAR shortcutW[] = {'A','l','t','+','t',0};
IAccessible *acc;
IDispatch *disp;
IOleWindow *ow;
IEnumVARIANT *ev;
HWND chld, hwnd, hwnd2;
HRESULT hr;
VARIANT vid, v;
BSTR str;
POINT pt;
RECT rect;
LONG l, left, top, width, height;
ULONG fetched;
hwnd = CreateWindowA("oleacc_test", "test &t &junk", WS_OVERLAPPEDWINDOW,
0, 0, 100, 100, NULL, NULL, NULL, NULL);
ok(hwnd != NULL, "CreateWindow failed\n");
chld = CreateWindowA("static", "message", WS_CHILD | WS_VISIBLE,
0, 0, 50, 50, hwnd, NULL, NULL, NULL);
ok(chld != NULL, "CreateWindow failed\n");
hr = CreateStdAccessibleObject(NULL, OBJID_CLIENT, &IID_IAccessible, (void**)&acc);
ok(hr == E_FAIL, "got %x\n", hr);
hr = CreateStdAccessibleObject(hwnd, OBJID_CLIENT, &IID_IAccessible, (void**)&acc);
ok(hr == S_OK, "got %x\n", hr);
hr = IAccessible_QueryInterface(acc, &IID_IOleWindow, (void**)&ow);
ok(hr == S_OK, "got %x\n", hr);
hr = IOleWindow_GetWindow(ow, &hwnd2);
ok(hr == S_OK, "got %x\n", hr);
ok(hwnd == hwnd2, "hwnd2 = %p, expected %p\n", hwnd2, hwnd);
hr = WindowFromAccessibleObject(acc, &hwnd2);
ok(hr == S_OK, "got %x\n", hr);
ok(hwnd == hwnd2, "hwnd2 = %p, expected %p\n", hwnd2, hwnd);
IOleWindow_Release(ow);
hr = IAccessible_get_accChildCount(acc, &l);
ok(hr == S_OK, "got %x\n", hr);
ok(l == 1, "l = %d\n", l);
V_VT(&vid) = VT_I4;
V_I4(&vid) = CHILDID_SELF;
disp = (void*)0xdeadbeef;
hr = IAccessible_get_accChild(acc, vid, &disp);
ok(hr == E_INVALIDARG, "get_accChild returned %x\n", hr);
ok(disp == NULL, "disp = %p\n", disp);
V_I4(&vid) = 1;
disp = (void*)0xdeadbeef;
hr = IAccessible_get_accChild(acc, vid, &disp);
ok(hr == E_INVALIDARG, "get_accChild returned %x\n", hr);
ok(disp == NULL, "disp = %p\n", disp);
hr = IAccessible_QueryInterface(acc, &IID_IEnumVARIANT, (void**)&ev);
ok(hr == S_OK, "got %x\n", hr);
hr = IEnumVARIANT_Skip(ev, 100);
ok(hr == S_FALSE, "Skip returned %x\n", hr);
V_VT(&v) = VT_I4;
fetched = 1;
hr = IEnumVARIANT_Next(ev, 1, &v, &fetched);
ok(hr == S_FALSE, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(fetched == 0, "fetched = %d\n", fetched);
hr = IEnumVARIANT_Reset(ev);
ok(hr == S_OK, "got %x\n", hr);
V_VT(&v) = VT_I4;
fetched = 2;
hr = IEnumVARIANT_Next(ev, 1, &v, &fetched);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_DISPATCH, "V_VT(&v) = %d\n", V_VT(&v));
IDispatch_Release(V_DISPATCH(&v));
ok(fetched == 1, "fetched = %d\n", fetched);
IEnumVARIANT_Release(ev);
test_AccessibleChildren(acc);
V_VT(&vid) = VT_I4;
V_I4(&vid) = CHILDID_SELF;
hr = IAccessible_get_accName(acc, vid, &str);
ok(hr == S_OK, "got %x\n", hr);
ok(!lstrcmpW(str, testW), "name = %s\n", wine_dbgstr_w(str));
SysFreeString(str);
V_I4(&vid) = 1;
str = (void*)0xdeadbeef;
hr = IAccessible_get_accName(acc, vid, &str);
ok(hr == E_INVALIDARG, "got %x\n", hr);
ok(!str, "str != NULL\n");
V_I4(&vid) = CHILDID_SELF;
str = (void*)0xdeadbeef;
hr = IAccessible_get_accValue(acc, vid, &str);
ok(hr == S_FALSE, "got %x\n", hr);
ok(!str, "str != NULL\n");
str = (void*)0xdeadbeef;
hr = IAccessible_get_accDescription(acc, vid, &str);
ok(hr == S_FALSE, "got %x\n", hr);
ok(!str, "str != NULL\n");
V_VT(&v) = VT_DISPATCH;
V_DISPATCH(&v) = (void*)0xdeadbeef;
hr = IAccessible_get_accRole(acc, vid, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == ROLE_SYSTEM_CLIENT, "V_I4(&v) = %d\n", V_I4(&v));
V_VT(&v) = VT_DISPATCH;
V_DISPATCH(&v) = (void*)0xdeadbeef;
hr = IAccessible_get_accState(acc, vid, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == (STATE_SYSTEM_FOCUSABLE|STATE_SYSTEM_INVISIBLE),
"V_I4(&v) = %x\n", V_I4(&v));
str = (void*)0xdeadbeef;
hr = IAccessible_get_accHelp(acc, vid, &str);
ok(hr == S_FALSE, "got %x\n", hr);
ok(!str, "str != NULL\n");
hr = IAccessible_get_accKeyboardShortcut(acc, vid, &str);
ok(hr == S_OK, "got %x\n", hr);
ok(!lstrcmpW(str, shortcutW), "str = %s\n", wine_dbgstr_w(str));
SysFreeString(str);
str = (void*)0xdeadbeef;
hr = IAccessible_get_accDefaultAction(acc, vid, &str);
ok(hr == S_FALSE, "got %x\n", hr);
ok(!str, "str != NULL\n");
pt.x = pt.y = 60;
ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
pt.x = pt.y = 25;
ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
ShowWindow(hwnd, TRUE);
pt.x = pt.y = 60;
ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
pt.x = pt.y = 25;
ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_DISPATCH, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_DISPATCH(&v) != NULL, "V_DISPATCH(&v) = %p\n", V_DISPATCH(&v));
VariantClear(&v);
ShowWindow(chld, FALSE);
pt.x = pt.y = 25;
ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
hr = IAccessible_get_accParent(acc, &disp);
ok(hr == S_OK, "got %x\n", hr);
ok(disp != NULL, "disp == NULL\n");
IDispatch_Release(disp);
ok(GetClientRect(hwnd, &rect), "GetClientRect failed\n");
pt.x = rect.left;
pt.y = rect.top;
MapWindowPoints(hwnd, NULL, &pt, 1);
rect.left = pt.x;
rect.top = pt.y;
pt.x = rect.right;
pt.y = rect.bottom;
MapWindowPoints(hwnd, NULL, &pt, 1);
hr = IAccessible_accLocation(acc, &left, &top, &width, &height, vid);
ok(hr == S_OK, "got %x\n", hr);
ok(left == rect.left, "left = %d, expected %d\n", left, rect.left);
ok(top == rect.top, "top = %d, expected %d\n", top, rect.top);
ok(width == pt.x-rect.left, "width = %d, expected %d\n", width, pt.x-rect.left);
ok(height == pt.y-rect.top, "height = %d, expected %d\n", height, pt.y-rect.top);
DestroyWindow(hwnd);
hr = IAccessible_get_accChildCount(acc, &l);
ok(hr == S_OK, "got %x\n", hr);
ok(l == 0, "l = %d\n", l);
hr = IAccessible_get_accName(acc, vid, &str);
ok(hr == E_INVALIDARG, "got %x\n", hr);
hr = IAccessible_get_accValue(acc, vid, &str);
ok(hr == S_FALSE, "got %x\n", hr);
hr = IAccessible_get_accRole(acc, vid, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == ROLE_SYSTEM_CLIENT, "V_I4(&v) = %d\n", V_I4(&v));
hr = IAccessible_get_accState(acc, vid, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == STATE_SYSTEM_INVISIBLE, "V_I4(&v) = %x\n", V_I4(&v));
hr = IAccessible_accHitTest(acc, 200, 200, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
disp = (void*)0xdeadbeef;
hr = IAccessible_get_accParent(acc, &disp);
ok(hr == E_FAIL, "got %x\n", hr);
ok(disp == NULL, "disp = %p\n", disp);
hr = IAccessible_accLocation(acc, &left, &top, &width, &height, vid);
ok(hr == S_OK, "got %x\n", hr);
ok(left == 0, "left = %d\n", left);
ok(top == 0, "top = %d\n", top);
ok(width == 0, "width = %d\n", width);
ok(height == 0, "height = %d\n", height);
IAccessible_Release(acc);
}
/*-------------------------------*/
LRESULT CALLBACK WndProc(HWND hWnd, UINT komunikat, WPARAM wParam, LPARAM lParam)
{
static BOOL bDragging;
static int poz;
POINT pkt;
HIMAGELIST hDragImgList;
static NOTIFYICONDATA nim;
switch (komunikat)
{
case WM_CREATE:
HWND hToolTip;
HFONT hFont;
TOOLINFO tinf;
RECT rect;
/*-----tworzenie kontrolek-----*/
hList = CreateWindow("SysListView32", "lista_przyciskow", WS_VISIBLE | WS_CHILD | WS_BORDER |
LVS_REPORT | LVS_SINGLESEL,0,0,493,230,hWnd,NULL,hInst, NULL);
hRefresh = CreateWindow("button", "Odœwie¿ listê", WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON,
135, 232, 100, 20, hWnd, NULL, hInst, NULL);
hShow = CreateWindow("button", "Poka¿ przycisk", WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON,
15, 232, 100, 20,/*255, 232, 100, 20,*/ hWnd, NULL, hInst, NULL);
hInfo = CreateWindow("button", "O programie...", WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON,
375, 232, 100, 20, hWnd, NULL, hInst, NULL);
/*-----tworzenie i ustawianie czcionki dla przycisków-----*/
hFont = CreateFont(14, 0, 0, 0, 0, false, false, false, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY,
DEFAULT_PITCH, NULL);
SendMessage(hRefresh, WM_SETFONT, (WPARAM) hFont, true);
SendMessage(hShow, WM_SETFONT, (WPARAM) hFont, true);
SendMessage(hInfo, WM_SETFONT, (WPARAM) hFont, true);
ListView_SetExtendedListViewStyle(hList, LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES | LVS_EX_INFOTIP);
/*-----ustawianie tooltipów-----*/
hToolTip = CreateWindow(TOOLTIPS_CLASS, NULL, TTS_ALWAYSTIP | TTS_BALLOON, 0,0,0,0, hWnd, NULL, hInst, NULL);
//Ustawianie parametrów wspó³nych dla ka¿dego tooltipa: tytu³, kolor.
SendMessage(hToolTip, TTM_SETTITLE, TTI_INFO, (LPARAM)"Skrót");
SendMessage(hToolTip, TTM_SETTIPTEXTCOLOR, (LPARAM)RGB(0, 0, 100), 0);
SendMessage(hToolTip, TTM_SETTIPBKCOLOR, (LPARAM)RGB(250, 250, 250), 0);
GetClientRect (hWnd, &rect);
tinf.cbSize = sizeof(TOOLINFO);
tinf.uFlags = TTF_SUBCLASS;
tinf.hinst = hInst;
tinf.uId = 0;
tinf.rect.left = rect.left;
tinf.rect.top = rect.top;
tinf.rect.right = rect.right;
tinf.rect.bottom = rect.bottom;
tinf.hwnd = hRefresh;
tinf.lpszText = "F5";
SendMessage(hToolTip, TTM_ADDTOOL, 0, (LPARAM)&tinf);
tinf.hwnd = hShow;
tinf.lpszText = "dwuklik LPM";
SendMessage(hToolTip, TTM_ADDTOOL, 0, (LPARAM)&tinf);
tinf.hwnd = hInfo;
tinf.lpszText = "F1";
SendMessage(hToolTip, TTM_ADDTOOL, 0, (LPARAM)&tinf);
/*-----ustawianie ikony programu w zasobniku systemowym-----*/
nim.cbSize = sizeof(NOTIFYICONDATA);
nim.hWnd = hWnd;
nim.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
nim.hIcon = ikona;
nim.uCallbackMessage = WM_TRAY;
nim.uID = 7;
lstrcpyn(nim.szTip, "Manipulator by FeniX", sizeof(nim.szTip));
Shell_NotifyIcon(NIM_ADD, &nim);
refresh();
break;
case WM_KEYUP: //obs³uga skrótów klawiaturowych dla konkretnych akcji
switch (wParam)
{
case VK_F5:
SendMessage(hRefresh, BM_CLICK, 0, 0);
break;
case VK_F1:
SendMessage(hInfo, BM_CLICK, 0, 0);
break;
case VK_SPACE:
SendMessage(hShow, BM_CLICK, 0, 0);
break;
case VK_ESCAPE:
ShowWindow(hWnd, SW_MINIMIZE);
break;
}
break;
case WM_COMMAND: //obs³uga zdarzeñ okien pochodnych okna g³ównego
switch (HIWORD(wParam))
{
case BN_CLICKED: //komunikat klikniêcia przycisku
if ((HWND)lParam == hRefresh)
{
refresh();
SetFocus(hList);
}
else if ((HWND)lParam == hInfo)
{
MessageBox(hWnd, "Autor:\nKonrad Gadzina <*****@*****.**>\n"
"Grupa 1131, Informatyka, rok akad. 2008/2009"
"\nPracownia In¿ynierii Oprogramowania M-74\n"
"Instytut Informatyki Stosowanej\n"
"Wydzia³ Mechaniczny, Politechnika Krakowska\nJêzyki i Techniki Programowania",
"O programie", MB_OK);
}
else if ((HWND)lParam == hShow)
{
int poz;
char buf[10];
bool hidden;
TBBUTTON *ptbb, tbb;
NOTIFYICONDATA fake; //potrzebne do "odswiezania" paska zadan i dopasowywania szerokosci przyciskow
ptbb = (TBBUTTON*)VirtualAllocEx(proces, NULL, sizeof(TBBUTTON), MEM_COMMIT, PAGE_READWRITE);
poz = ListView_GetNextItem(hList, (WPARAM)-1, LVNI_SELECTED);
SendMessage(hPasek, TB_GETBUTTON, (WPARAM)poz, (LPARAM)ptbb);
ReadProcessMemory(proces, (void*)ptbb, (void*)&tbb, sizeof(TBBUTTON), NULL);
hidden = SendMessage(hPasek, TB_ISBUTTONHIDDEN, (WPARAM)tbb.idCommand, 0);
SendMessage(hPasek, TB_HIDEBUTTON, (WPARAM)tbb.idCommand, (LPARAM)!hidden);
if (hidden)
SendMessage(hShow, WM_SETTEXT, 0, (LPARAM)"Ukryj przycisk");
else
SendMessage(hShow, WM_SETTEXT, 0, (LPARAM)"Poka¿ przycisk");
/*---dodawanie i usuwanie ikony do zasobnika, by pasek zadañ siê "odœwie¿y³"---*/
fake.cbSize = sizeof(NOTIFYICONDATA);
fake.hWnd = hWnd;
fake.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
fake.hIcon = ikona;
fake.uCallbackMessage = WM_TRAY;
fake.uID = 19;
lstrcpyn(fake.szTip, "Manipulator by FeniX", sizeof(fake.szTip));
Shell_NotifyIcon(NIM_ADD, &fake);
Shell_NotifyIcon(NIM_DELETE, &fake);
for (int i = 0; i<ile; i++)
{
SendMessage(hPasek, TB_GETBUTTON, (WPARAM)i, (LPARAM)ptbb);
ReadProcessMemory(proces, (void*)ptbb, (void*)&tbb, sizeof(TBBUTTON), NULL);
hidden = SendMessage(hPasek, TB_ISBUTTONHIDDEN, (WPARAM)tbb.idCommand, 0);
if (!hidden)
strcpy(buf, "[widoczny]");
else
strcpy(buf, "[ukryty]");
ListView_SetItemText(hList, i, 1, buf);
}
SetFocus(hList);
VirtualFreeEx(proces, ptbb, 0, MEM_RELEASE);
}
break;
}
break;
case WM_TRAY: //obs³uga klikniêcia na ikonkê programu w zasobniku systemowym
switch ((UINT)lParam)
{
case WM_LBUTTONDOWN:
if (!IsWindowVisible(hWnd))
{
if (IsZoomed(hWnd))
ShowWindow(hWnd, SW_MAXIMIZE);
else
ShowWindow(hWnd, SW_RESTORE);
SetForegroundWindow(hWnd);
}
else if (GetForegroundWindow() == hWnd)
ShowWindow(hWnd, SW_HIDE);
else
SetForegroundWindow(hWnd);
break;
}
break;
case WM_ACTIVATE:
if (LOWORD(wParam) != WA_INACTIVE)
refresh();
break;
case WM_SIZE: //zdarzenie zmienienia rozmiaru
int szer, wys;
if (wParam & SIZE_MINIMIZED)
ShowWindow(hWnd, SW_HIDE);
szer = (int)LOWORD(lParam);
wys = (int)HIWORD(lParam );
/*
Poni¿ze linijki pozwalaj¹ przestawiaæ kontrolki tak, by
dopasowa ich pozycjê/rozmiar do rozmiaru okna g³ównego
*/
MoveWindow(hList, 0, 0, szer, wys-23, false);
MoveWindow(hShow, 20, wys-21, 120, 20, false);
MoveWindow(hRefresh, szer-310, wys-21, 120, 20, false);
MoveWindow(hInfo, szer-140, wys-21, 120, 20, false);
break;
case WM_SIZING: //zdarzenie zmieniania rozmiaru
RECT* rc;
rc = (RECT*)lParam;
/*
Poni¿sze linie pozwalaj¹ ograniczyc rozmiar okna - jako, ¿e to zdarzenie jest
wywo³ywane w trakcie zmiany rozmiaru, warunki s¹ sprawdzane nie po puszczeniu
przycisku myszy, a jeszcze w trakcie jego trzymania. Dziêki temu okno nie
nigdy nie bêdzie mia³o rozmiarów mniejszych ni¿ 500x100 pikseli.
*/
if (rc->right - rc->left <= 500)
rc->right = rc->left + 500;
if (rc->bottom - rc->top <= 100)
rc->bottom = rc->top + 100;
break;
case WM_DESTROY: //zdarzenie niszczenia okna
CloseHandle(proces);
Shell_NotifyIcon(NIM_DELETE, &nim);
PostQuitMessage(0);
break;
case WM_NOTIFY: //obs³uga komunikatów od kontrolki ListView
if (((LPNMHDR)lParam)->hwndFrom == hList && ((LPNMHDR)lParam)->code == (unsigned int)NM_DBLCLK)
SendMessage(hShow, BM_CLICK, 0, 0);
else if (((LPNMHDR)lParam)->hwndFrom == hList && ((LPNMHDR)lParam)->code == (unsigned int)NM_CLICK)
{
char buf[10];
int poz = ListView_GetNextItem(hList, (WPARAM)-1, LVNI_SELECTED);
ListView_GetItemText(hList, poz, 1, buf, 50);
if (!strcmp(buf, "[ukryty]"))
SendMessage(hShow, WM_SETTEXT, 0, (LPARAM)"Poka¿ przycisk");
else
SendMessage(hShow, WM_SETTEXT, 0, (LPARAM)"Ukryj przycisk");
}
else if (((LPNMHDR)lParam)->hwndFrom == hList && ((LPNMHDR)lParam)->code == LVN_KEYDOWN)
{
switch (((LV_KEYDOWN*)lParam)->wVKey)
{
case VK_F5:
SendMessage(hRefresh, BM_CLICK, 0, 0);
break;
case VK_F1:
SendMessage(hInfo, BM_CLICK, 0, 0);
break;
case VK_SPACE:
SendMessage(hShow, BM_CLICK, 0, 0);
break;
case VK_ESCAPE:
ShowWindow(hWnd, SW_MINIMIZE);
break;
}
}
/*------------------- obs³uga drag & drop na liœcie z przyciskami -------------------*/
else if (((LPNMHDR)lParam)->hwndFrom == hList && ((LPNMHDR)lParam)->code == LVN_BEGINDRAG)
{
//wiadomoœæ wysy³ana do okna g³ównego, gdy rozpoczynamy drag & drop na liœcie
//czyli ³apiemy element lewym przyciskiem myszy
HIMAGELIST hOneImageList, hTempImageList;
IMAGEINFO imginf;
int x = 0, wys;
pkt.x = 1;
pkt.y = 1;
poz = ListView_GetNextItem(hList, (WPARAM)-1, LVNI_SELECTED); //pobieranie indexu zaznaczonego elementu
item.iItem = poz;
item.mask = LVIF_IMAGE | LVIF_INDENT | LVIF_PARAM; //ustawienie maski elementu listy do pobrania
ListView_GetItem(hList, &item); //pobieranie danego elementu do zmiennej item
if (item.iIndent) //element z wciêciem nas nie interesuje
break;
hDragImgList = ListView_CreateDragImage(hList, poz, &pkt); //tworzenie "duszka" do d&d
ImageList_GetImageInfo(hDragImgList, 0, &imginf);
wys = imginf.rcImage.bottom;
while(true) //dodawanie elementów danej grupy do "duszka" w pêtli
{
if (++item.iItem >= ile)
break;
item.mask = LVIF_IMAGE | LVIF_INDENT | LVIF_PARAM; //ustawianie maski pobierania danych elementu
ListView_GetItem(hList, &item);
if(item.iIndent == 0) //je¿eli napotkano kolejny przycisk grupowy trzeba przerwaæ
break;
hOneImageList = ListView_CreateDragImage(hList, item.iItem, &pkt);
hTempImageList = ImageList_Merge(hDragImgList, 0, hOneImageList, 0, 0, wys);
ImageList_Destroy(hDragImgList);
ImageList_Destroy(hOneImageList);
hDragImgList = hTempImageList;
ImageList_GetImageInfo(hDragImgList, 0, &imginf);
wys = imginf.rcImage.bottom;
}
item.iItem = poz;
item.mask = LVIF_IMAGE | LVIF_INDENT | LVIF_PARAM;
ListView_GetItem(hList, &item);
ImageList_BeginDrag(hDragImgList, 0, x, 0);
pkt = ((NM_LISTVIEW*) ((LPNMHDR)lParam))->ptAction;
ClientToScreen(hList, &pkt);
ImageList_DragEnter(GetDesktopWindow(), pkt.x, pkt.y);
bDragging = true;
SetCapture(hWnd);
}
break;
case WM_MOUSEMOVE: //zdarzenie ruchu kursora myszy
if (!bDragging) //je¿eli nie obs³gujemy akurat d&d na liœcie to nie trzeba nic robiæ
break;
pkt.x = LOWORD(lParam);
pkt.y = HIWORD(lParam);
ClientToScreen(hWnd, &pkt);
ImageList_DragMove(pkt.x, pkt.y);
break;
case WM_LBUTTONUP: //zdarzenie puszczenia lewego przycisku myszy
if (!bDragging) //je¿eli nie obs³gujemy akurat d&d na liœcie to nie trzeba nic robiæ
break;
LVHITTESTINFO lvhti;
char buf[256], sub[12];
/*---puszczamy przycisk, wiêc przeci¹ganie siê koñczy---*/
bDragging = false;
ImageList_DragLeave(hList);
ImageList_EndDrag();
//ImageList_Destroy(hDragImgList); //nie wiem czemu, ale ta linia wywo³uje b³¹d segfault przy uruchomieniu debuggera
ReleaseCapture();
/*---sprawdzanie, czy przeci¹gany element zosta³ upuszczony na inny element listy---*/
lvhti.pt.x = LOWORD(lParam);
lvhti.pt.y = HIWORD(lParam);
ClientToScreen(hWnd, &lvhti.pt);
ScreenToClient(hList, &lvhti.pt);
ListView_HitTest(hList, &lvhti);
if (lvhti.iItem == -1)
break;
if ((lvhti.flags & LVHT_ONITEMLABEL == 0) && (lvhti.flags & LVHT_ONITEMSTATEICON == 0))
break;
if (!item.iIndent) //je¿eli wciêcie = 0, to znaczy ¿e zajmujemy siê przyciskiem "grupowym"
{
poz = ListView_GetNextItem(hList, (WPARAM)-1, LVNI_SELECTED);
if (lvhti.iItem > poz)
lvhti.iItem++;
while (true)
{
if (lvhti.iItem == poz || lvhti.iItem > ile-1 || lvhti.iItem < 0)
break;
item.iItem = lvhti.iItem;
item.iSubItem = 0;
item.mask = LVIF_STATE | LVIF_IMAGE | LVIF_INDENT | LVIF_TEXT | LVIF_PARAM;
item.stateMask = LVIS_SELECTED;
ListView_GetItem(hList, &item);
if (item.iIndent)
{
if (lvhti.iItem > poz)
lvhti.iItem++;
else if (lvhti.iItem < poz)
lvhti.iItem--;
}
else
{
if (lvhti.iItem > poz)
lvhti.iItem--;
break;
}
}
ListView_GetItemText(hList, poz, 0, buf, 256); //pobieranie tekstu danego elementu listy
while (true)
{
int tmp = poz;
item.iItem = poz;
item.iSubItem = 0;
item.cchTextMax = 256;
item.pszText = buf;
item.stateMask = ~LVIS_SELECTED;
item.mask = LVIF_STATE | LVIF_IMAGE | LVIF_INDENT | LVIF_TEXT | LVIF_PARAM;
ListView_GetItem(hList, &item);
ListView_GetItemText(hList, poz, 1, sub, 12);
SendMessage(hPasek, TB_MOVEBUTTON, (WPARAM)poz, (LPARAM)lvhti.iItem);
if (lvhti.iItem > poz && lvhti.iItem < ile)
lvhti.iItem++;
item.iItem = lvhti.iItem;
ListView_InsertItem(hList, &item);
ListView_SetItemText(hList, item.iItem, 1, sub);
if (lvhti.iItem < poz)
poz++;
ListView_DeleteItem(hList, poz);
if (lvhti.iItem > tmp)
lvhti.iItem--;
if (lvhti.iItem < tmp)
lvhti.iItem++;
ListView_GetItemText(hList, poz, 0, buf, 256);
item.iItem = poz;
item.iSubItem = 0;
item.cchTextMax = 256;
item.pszText = buf;
ListView_GetItem(hList, &item);
if (!item.iIndent || poz > ile-1) //je¿eli
break;
}
}
break;
default:
return DefWindowProc(hWnd, komunikat, wParam, lParam);
}
return 0;
}
static void blit_to_primary(win_window_info *window, int srcwidth, int srcheight)
{
dd_info *dd = (dd_info *)window->drawdata;
IDirectDrawSurface7 *target = (dd->back != NULL) ? dd->back : dd->primary;
win_monitor_info *monitor = winwindow_video_window_monitor(window, NULL);
DDBLTFX blitfx = { sizeof(DDBLTFX) };
RECT clear, outer, dest, source;
INT32 dstwidth, dstheight;
HRESULT result;
// compute source rect
source.left = source.top = 0;
source.right = srcwidth;
source.bottom = srcheight;
// compute outer rect -- windowed version
if (!window->fullscreen)
{
GetClientRect(window->hwnd, &outer);
ClientToScreen(window->hwnd, &((LPPOINT)&outer)[0]);
ClientToScreen(window->hwnd, &((LPPOINT)&outer)[1]);
// adjust to be relative to the monitor
outer.left -= monitor->info.rcMonitor.left;
outer.right -= monitor->info.rcMonitor.left;
outer.top -= monitor->info.rcMonitor.top;
outer.bottom -= monitor->info.rcMonitor.top;
}
// compute outer rect -- full screen version
else
{
calc_fullscreen_margins(window, dd->primarydesc.dwWidth, dd->primarydesc.dwHeight, &outer);
}
// if we're respecting the aspect ratio, we need to adjust to fit
dstwidth = rect_width(&outer);
dstheight = rect_height(&outer);
if (!video_config.hwstretch)
{
// trim the source if necessary
if (rect_width(&outer) < srcwidth)
{
source.left += (srcwidth - rect_width(&outer)) / 2;
source.right = source.left + rect_width(&outer);
}
if (rect_height(&outer) < srcheight)
{
source.top += (srcheight - rect_height(&outer)) / 2;
source.bottom = source.top + rect_height(&outer);
}
// match the destination and source sizes
dstwidth = srcwidth = source.right - source.left;
dstheight = srcheight = source.bottom - source.top;
}
else if (video_config.keepaspect)
{
// compute the appropriate visible area
window->target->compute_visible_area(rect_width(&outer), rect_height(&outer), winvideo_monitor_get_aspect(monitor), window->target->orientation(), dstwidth, dstheight);
}
// center within
dest.left = outer.left + (rect_width(&outer) - dstwidth) / 2;
dest.right = dest.left + dstwidth;
dest.top = outer.top + (rect_height(&outer) - dstheight) / 2;
dest.bottom = dest.top + dstheight;
// compare against last destination; if different, force a redraw
if (dest.left != dd->lastdest.left || dest.right != dd->lastdest.right || dest.top != dd->lastdest.top || dest.bottom != dd->lastdest.bottom)
{
dd->lastdest = dest;
update_outer_rects(dd);
}
// clear outer rects if we need to
if (dd->clearouter != 0)
{
dd->clearouter--;
// clear the left edge
if (dest.left > outer.left)
{
clear = outer;
clear.right = dest.left;
result = IDirectDrawSurface_Blt(target, &clear, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &blitfx);
if (result != DD_OK) mame_printf_verbose("DirectDraw: Error %08X clearing the screen\n", (int)result);
}
// clear the right edge
if (dest.right < outer.right)
{
clear = outer;
clear.left = dest.right;
result = IDirectDrawSurface_Blt(target, &clear, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &blitfx);
if (result != DD_OK) mame_printf_verbose("DirectDraw: Error %08X clearing the screen\n", (int)result);
}
// clear the top edge
if (dest.top > outer.top)
{
clear = outer;
clear.bottom = dest.top;
result = IDirectDrawSurface_Blt(target, &clear, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &blitfx);
if (result != DD_OK) mame_printf_verbose("DirectDraw: Error %08X clearing the screen\n", (int)result);
}
// clear the bottom edge
if (dest.bottom < outer.bottom)
{
clear = outer;
clear.top = dest.bottom;
result = IDirectDrawSurface_Blt(target, &clear, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &blitfx);
if (result != DD_OK) mame_printf_verbose("DirectDraw: Error %08X clearing the screen\n", (int)result);
}
}
// do the blit
result = IDirectDrawSurface7_Blt(target, &dest, dd->blit, &source, DDBLT_WAIT, NULL);
if (result != DD_OK) mame_printf_verbose("DirectDraw: Error %08X blitting to the screen\n", (int)result);
// page flip if triple buffered
if (window->fullscreen && dd->back != NULL)
{
result = IDirectDrawSurface7_Flip(dd->primary, NULL, DDFLIP_WAIT);
if (result != DD_OK) mame_printf_verbose("DirectDraw: Error %08X waiting for VBLANK\n", (int)result);
}
}
void COlelistBox::OnLButtonDown(UINT nFlags, CPoint point)
{
FNAME *lpResult;
CDataItem *pDataItem;
LPIMAGE lpImage = GetActiveImage();
CServerDoc *pDoc = PictPubApp.GetDocument(lpImage);
int num;
CRect r,rr;
BOOL bCreateDoc = (pDoc == NULL);
CPoint p;
CListBox::OnLButtonDown(nFlags, point);
FORWARD_WM_LBUTTONUP(GetSafeHwnd(), point.x, point.y, nFlags, ::SendMessage);
lpResult = ExtBsr_GetSelection(GetParent()->GetSafeHwnd(), &num);
if (!lpResult || num != 1)
return;
lstrcpy(Names.Clipboard, lpResult[0]);
if (LookupExtFileN(Names.Clipboard, Names.PasteImageFile,
IDN_CLIPBOARD, NO))
{
if (bCreateDoc)
{
LPFRAME lpFrame = FrameOpen(FDT_GRAYSCALE, 1, 1, 72);
if (lpFrame)
{
POSITION Pos;
lpImage = CreateImage(NULL,lpFrame,NULL,NULL,
IDN_PP,IDC_SAVECT,IMG_DOCUMENT,NULL);
if (!lpImage)
{
FrameClose(lpFrame);
return;
}
pDoc = (CServerDoc*)PictPubApp.OpenDocumentFile(
lpImage->CurFile, lpImage, FALSE);
if (!pDoc)
{
DestroyImage(lpImage);
return;
}
}
else
return;
}
if (pDoc)
{
pDataItem = new CDataItem(pDoc, Names.Clipboard, YES);
GetParent()->GetWindowRect(&r);
ClientToScreen(&point);
GetItemRect(GetCurSel(), &rr);
ClientToScreen(&rr);
p.x = rr.Width() / 2;
p.y = rr.Height() / 2;
// NOTE!!the pDataItem will be internally destroyed once the drag/drop
// operation is completed therefore we do not need to delete the pDataItem
pDataItem->DoDragDrop(&rr, p, FALSE, DROPEFFECT_COPY, &r);
if (bCreateDoc)
pDoc->OnCloseDocument();
}
}
else if(Names.Clipboard[0])
{
// deleted the file...notify the browser
UpdatePasteFromFile(NULL);
}
}
///////////////////////////////////////////////////
// full screen
void CBSWndContainer::SetFullScreen(BOOL bFlag)
{
if(bFlag==m_bFullScreen) return;
if( bFlag )
{//全屏
// //得到显示器分辨率
// int cx=GetSystemMetrics(SM_CXSCREEN);
// int cy=GetSystemMetrics(SM_CYSCREEN);
//
// //保存位置信息
// GetWindowPlacement(&_temppl);
// //修改风格
// ModifyStyle(WS_CHILD,WS_POPUP);
// //修改父窗口
// _tempparent=SetParent(NULL);
// _tempparent->ShowWindow(SW_HIDE);
//移动窗口
/* MoveWindow(0,0,cx,cy);*/
ModifyStyle(WS_CHILD,WS_POPUP);
//修改父窗口
// _tempparent=SetParent(NULL);
// _tempparent->ShowWindow(SW_HIDE);
GetWindowPlacement(&m_OldWndPlacement);
CRect WindowRect;
GetWindowRect(&WindowRect);
CRect ClientRect;
RepositionBars(0, 0xffff, AFX_IDW_PANE_FIRST, reposQuery, &ClientRect);
ClientToScreen(&ClientRect);
// 获取屏幕的分辨率
CRect screenRect;
GetCurrentScreenMonitorRect(m_hWnd, screenRect);
int nFullWidth = screenRect.Width(); //GetSystemMetrics(SM_CXSCREEN);
int nFullHeight = screenRect.Height(); //GetSystemMetrics(SM_CYSCREEN);
//将除控制条外的客户区全屏显示到从(0,0)到(nFullWidth, nFullHeight)区域, 将(0,0)和(nFullWidth, nFullHeight)两个点外扩充原窗口和除控制条之外的 客户区位置间的差值, 就得到全屏显示的窗口位置
m_FullScreenRect.left= WindowRect.left - ClientRect.left + screenRect.left;
m_FullScreenRect.top = WindowRect.top - ClientRect.top + screenRect.top;
m_FullScreenRect.right = m_FullScreenRect.left + WindowRect.right - ClientRect.right + nFullWidth;//::GetSystemMetrics(SM_CXSCREEN);
m_FullScreenRect.bottom = m_FullScreenRect.top + WindowRect.bottom - ClientRect.bottom + nFullHeight;//::GetSystemMetrics(SM_CYSCREEN);
m_bFullScreen=TRUE; // 设置全屏显示标志为 TRUE
// 进入全屏显示状态
WINDOWPLACEMENT wndpl;
wndpl.length=sizeof(WINDOWPLACEMENT);
wndpl.flags=0;
wndpl.showCmd=SW_SHOWNORMAL;
wndpl.rcNormalPosition= m_FullScreenRect;
_tempparent=SetParent(NULL);
_tempparent->ShowWindow(SW_HIDE);
SetWindowPlacement(&wndpl);
// SetWindowPos(&wndTopMost,0,0,cx,cy,NULL);
}
else
{//还原
//还原父窗口
// _tempparent->ShowWindow(SW_SHOW);
// SetParent(_tempparent);
// //还原风格
// ModifyStyle(WS_POPUP,WS_CHILD);
// //还原位置
// SetWindowPlacement(&_temppl);
_tempparent->ShowWindow(SW_SHOW);
SetParent(_tempparent);
//还原风格
ModifyStyle(WS_POPUP,WS_CHILD);
SetWindowPlacement(&m_OldWndPlacement);
}
m_bFullScreen=bFlag;
Invalidate();
}
static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message){
case WM_DESTROY:
PostQuitMessage(0);
return 0;
case WM_CLOSE:
mplayer_put_key(KEY_CLOSE_WIN);
break;
case WM_WINDOWPOSCHANGED:
{
int tmpheight=0;
/*calculate new window rect*/
if(!vo_fs){
RECT rd;
POINT point_window;
if(!hWnd)hWnd=hwnd;
ShowCursor(TRUE);
point_window.x = 0;
point_window.y = 0;
ClientToScreen(hWnd,&point_window);
GetClientRect(hWnd,&rd);
vo_dwidth=rd.right - rd.left;
vo_dheight=rd.bottom - rd.top;
vo_dx =point_window.x;
vo_dy =point_window.y;
// aspect(&vo_dwidth, &vo_dheight, A_NOZOOM);
/* keep aspect on resize, borrowed from vo_directx.c */
tmpheight = ((float)vo_dwidth/window_aspect);
tmpheight += tmpheight % 2;
if(tmpheight > vo_dheight)
{
vo_dwidth = ((float)vo_dheight*window_aspect);
vo_dwidth += vo_dwidth % 2;
}
else vo_dheight = tmpheight;
rd.right = rd.left + vo_dwidth;
rd.bottom = rd.top + vo_dheight;
if(rd.left < 0) rd.left = 0;
if(rd.right > vo_screenwidth) rd.right = vo_screenwidth;
if(rd.top < 0) rd.top = 0;
if(rd.bottom > vo_screenheight) rd.bottom = vo_screenheight;
AdjustWindowRect(&rd, WS_OVERLAPPEDWINDOW | WS_SIZEBOX, 0);
SetWindowPos(hWnd, HWND_TOPMOST, vo_dx+rd.left, vo_dy+rd.top, rd.right-rd.left, rd.bottom-rd.top, SWP_NOOWNERZORDER);
}
else {
if(ShowCursor(FALSE)>=0)while(ShowCursor(FALSE)>=0){}
aspect(&vo_dwidth, &vo_dheight, A_ZOOM);
vo_dx = (vo_screenwidth - vo_dwidth)/2;
vo_dy = (vo_screenheight - vo_dheight)/2;
}
/*update vidix*/
/* FIXME: implement runtime resize/move if possible, this way is very ugly! */
vidix_stop();
if(vidix_init(image_width, image_height, vo_dx, vo_dy, vo_dwidth, vo_dheight, image_format, vo_depthonscreen, vo_screenwidth, vo_screenheight) != 0)
mp_msg(MSGT_VO, MSGL_FATAL, "Can't initialize VIDIX driver: %s\n", strerror(errno));
/*set colorkey*/
vidix_start();
mp_msg(MSGT_VO, MSGL_V, "[winvidix] window properties: pos: %dx%d, size: %dx%d\n",vo_dx, vo_dy, vo_dwidth, vo_dheight);
if(vidix_grkey_support()){
vidix_grkey_get(&gr_key);
gr_key.key_op = KEYS_PUT;
gr_key.ckey.op = CKEY_TRUE;
if(vo_fs)gr_key.ckey.red = gr_key.ckey.green = gr_key.ckey.blue = 0;
else {
gr_key.ckey.red = gr_key.ckey.blue = 255;
gr_key.ckey.green = 0;
}
vidix_grkey_set(&gr_key);
}
}
break;
case WM_SYSCOMMAND:
switch (wParam){
case SC_SCREENSAVE:
case SC_MONITORPOWER:
return 0;
}
break;
case WM_KEYDOWN:
switch (wParam){
case VK_LEFT:
{mplayer_put_key(KEY_LEFT);break;}
case VK_UP:
{mplayer_put_key(KEY_UP);break;}
case VK_RIGHT:
{mplayer_put_key(KEY_RIGHT);break;}
case VK_DOWN:
{mplayer_put_key(KEY_DOWN);break;}
case VK_TAB:
{mplayer_put_key(KEY_TAB);break;}
case VK_CONTROL:
{mplayer_put_key(KEY_CTRL);break;}
case VK_DELETE:
{mplayer_put_key(KEY_DELETE);break;}
case VK_INSERT:
{mplayer_put_key(KEY_INSERT);break;}
case VK_HOME:
{mplayer_put_key(KEY_HOME);break;}
case VK_END:
{mplayer_put_key(KEY_END);break;}
case VK_PRIOR:
{mplayer_put_key(KEY_PAGE_UP);break;}
case VK_NEXT:
{mplayer_put_key(KEY_PAGE_DOWN);break;}
case VK_ESCAPE:
{mplayer_put_key(KEY_ESC);break;}
}
break;
case WM_CHAR:
mplayer_put_key(wParam);
break;
}
return DefWindowProc(hwnd, message, wParam, lParam);
}
void Cv11View::OnRButtonUp(UINT /* nFlags */, CPoint point)
{
ClientToScreen(&point);
OnContextMenu(this, point);
}
long WINAPI ComboSubClassProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
WNDPROC OldWndProc=(WNDPROC) GetWindowLong(hWnd, GWL_USERDATA);
switch(msg) {
case WM_LBUTTONDOWN:
{
SHRGINFO shrg;
shrg.cbSize = sizeof(shrg);
shrg.hwndClient = hWnd;
shrg.ptDown.x = LOWORD(lParam);
shrg.ptDown.y = HIWORD(lParam);
shrg.dwFlags = SHRG_RETURNCMD /*| SHRG_NOANIMATION*/;
if (SHRecognizeGesture(&shrg) == GN_CONTEXTMENU) {
DWORD sel=SendMessage(hWnd, EM_GETSEL, 0, 0);
UINT paste = (IsClipboardFormatAvailable(CF_UNICODETEXT))? MF_STRING : MF_STRING | MF_GRAYED;
UINT cut = (LOWORD(sel)!=HIWORD(sel))? MF_STRING : MF_STRING | MF_GRAYED;
UINT undo= (SendMessage(hWnd, EM_CANUNDO, 0, 0))? MF_STRING : MF_STRING | MF_GRAYED;;
HMENU hmenu = CreatePopupMenu();
if (hmenu==NULL) break;
//AppendMenu(hmenu, (smileParser->hasSmiles())? MF_STRING : MF_STRING | MF_GRAYED, WM_USER, TEXT("Add Smile"));
//AppendMenu(hmenu, MF_SEPARATOR, 0, NULL);
AppendMenu(hmenu, cut, WM_CUT, TEXT("Cut") );
AppendMenu(hmenu, cut, WM_COPY, TEXT("Copy") );
AppendMenu(hmenu, paste, WM_PASTE, TEXT("Paste") );
AppendMenu(hmenu, MF_SEPARATOR, 0, NULL);
AppendMenu(hmenu, undo, EM_UNDO, TEXT("Undo") );
POINT pt={LOWORD(lParam), HIWORD(lParam) };
ClientToScreen(hWnd, &pt);
int cmdId=TrackPopupMenuEx(hmenu,
TPM_BOTTOMALIGN | TPM_RETURNCMD,
pt.x, pt.y,
hWnd,
NULL);
//if (cmdId==WM_USER) SmileBox::showSmileBox(hWnd, pt.x, pt.y, smileParser);
DestroyMenu(hmenu);
if (cmdId>0) PostMessage(hWnd, cmdId, 0, 0);
return 0;
}
break;
}
/*case WM_KEYDOWN:
if (wParam==VK_CONTROL) editbox::editBoxShifts=true;
if (wParam==VK_SHIFT) editbox::editBoxShifts=true;
break;
case WM_KEYUP:
editbox::editBoxShifts=false;
break;
*/
case WM_CHAR:
if (wParam==VK_RETURN) {
PostMessage(GetParent(GetParent(hWnd)), WM_COMMAND, IDOK, 0);
return 0;
}
break;
}
return CallWindowProc(OldWndProc,hWnd,msg,wParam,lParam);
}
long CALLBACK kgmWindow::WndProc(HWND hWnd, u32 msg, WPARAM wPar, LPARAM lPar)
{
static bool set_cursor = false;
kgmWindow* wnd = (kgmWindow*)GetWindowLong(hWnd, GWL_USERDATA);
kgmEvent::Event evt;
RECT wRect;
RECT wcRect;
POINT msPoint;
MSG m;
m.message = msg;
m.wParam = wPar;
m.lParam = lPar;
if(!wnd)
return 1;
GetClientRect(hWnd, &wcRect);
GetWindowRect(hWnd, &wRect);
GetCursorPos(&msPoint);
switch(msg){
case WM_DESTROY:
evt.event = evtClose;
break;
case WM_SIZE:
evt.event = evtResize;
evt.width = LOWORD(lPar);
evt.height = HIWORD(lPar);
break;
case WM_PAINT:
evt.event = evtPaint;
evt.gc = 0;
ValidateRect(hWnd, NULL);
break;
case WM_MOUSEWHEEL:
evt.event = evtMsWheel;
msPoint.x = LOWORD(lPar);
msPoint.y = HIWORD(lPar);
ClientToScreen(hWnd, &msPoint);
evt.msx = msPoint.x;
evt.msy = msPoint.y;
evt.msz = HIWORD(wPar);
break;
case WM_MOUSEMOVE:
evt.event = evtMsMove;
msPoint.x = LOWORD(lPar);
msPoint.y = HIWORD(lPar);
switch(wPar)
{
case MK_LBUTTON:
evt.keyMask = KEY_MSBLEFT;
break;
case MK_RBUTTON:
evt.keyMask = KEY_MSBRIGHT;
break;
case MK_MBUTTON:
evt.keyMask = KEY_MSBMIDDLE;
break;
default:
evt.key = KEY_NONE;
}
//ClientToScreen(hWnd, &msPoint);
if(!wnd->m_msAbs)
{
RECT rc;
GetClientRect(wnd->m_wnd, (LPRECT)&rc);
RECT wrc;
GetWindowRect(wnd->m_wnd, (LPRECT)&wrc);
evt.msx = rc.right / 2 - msPoint.x;
evt.msy = rc.bottom / 2 - msPoint.y;
static bool seted = false;
if(seted)
{
seted = false;
}
else
{
POINT pt = {rc.right / 2, rc.bottom / 2};
ClientToScreen(wnd->m_wnd, &pt);
SetCursorPos(pt.x, pt.y);
seted = true;
}
}
else
{
evt.msx = msPoint.x;
evt.msy = msPoint.y;
}
break;
case WM_LBUTTONDOWN:
evt.event = evtMsLeftDown;
evt.key = keyTranslate(WPARAM_KEY(wPar));
evt.msx = LOWORD(lPar);
evt.msy = HIWORD(lPar);
break;
case WM_LBUTTONUP:
evt.event = evtMsLeftUp;
evt.key = keyTranslate(WPARAM_KEY(wPar));
evt.msx = LOWORD(lPar);
evt.msy = HIWORD(lPar);
break;
case WM_RBUTTONDOWN:
evt.event = evtMsRightDown;
evt.key = keyTranslate(WPARAM_KEY(wPar));
evt.msx = LOWORD(lPar);
evt.msy = HIWORD(lPar);
break;
case WM_RBUTTONUP:
evt.event = evtMsRightUp;
evt.key = keyTranslate(WPARAM_KEY(wPar));
evt.msx = LOWORD(lPar);
evt.msy = HIWORD(lPar);
break;
case WM_KEYDOWN:
evt.event = evtKeyDown;
evt.key = keyTranslate(wPar);
break;
case WM_KEYUP:
evt.event = evtKeyUp;
evt.key = keyTranslate(wPar);
break;
default:
return DefWindowProc(hWnd, msg, wPar, lPar);
break;
}
if(evt.event)
wnd->onEvent(&evt);
return 1;
}
static INT_PTR CALLBACK LangOptDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
HWND hwndList = GetDlgItem(hwndDlg, IDC_LANGLIST);
LVITEM lvi;
switch(msg) {
case WM_INITDIALOG:
TranslateDialogDefault(hwndDlg);
hwndLangOpt = hwndDlg;
ListView_SetExtendedListViewStyle(hwndList, LVS_EX_FULLROWSELECT|LVS_EX_LABELTIP);
ListView_SetImageList(hwndList, CreateRadioImages(ListView_GetBkColor(hwndList), ListView_GetTextColor(hwndList)), LVSIL_STATE); /* auto-destroyed */
{
LVCOLUMN lvc;
lvc.mask = LVCF_TEXT;
lvc.pszText = TranslateT("Installed Languages");
ListView_InsertColumn(hwndList, 0, &lvc);
}
if ( ServiceExists(MS_FLAGS_LOADFLAGICON))
ListView_SetImageList(hwndList, ImageList_Create(GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), ILC_COLOR24, 8, 8), LVSIL_SMALL);
TCHAR szPath[MAX_PATH];
GetPackPath(szPath, SIZEOF(szPath), FALSE, _T(""));
SetDlgItemText(hwndDlg, IDC_SKINROOTFOLDER, szPath);
SendMessage(hwndDlg, M_RELOADLIST, 0, 0);
SendMessage(hwndDlg, M_SHOWFILECOL, 0, 1);
return TRUE;
case M_RELOADLIST:
/* init list */
ListView_DeleteAllItems(hwndList);
ListView_DeleteColumn(hwndList, 1); /* if present */
{
HIMAGELIST himl = ListView_GetImageList(hwndList, LVSIL_SMALL);
ImageList_RemoveAll(himl);
/* enum all packs */
EnumPacks(InsertPackItemEnumProc, _T("langpack_*.txt"), "Miranda Language Pack Version 1", (WPARAM)hwndList, (LPARAM)himl);
/* make it use current langpack locale for sort */
ListView_SortItems(hwndList, CompareListItem, CallService(MS_LANGPACK_GETLOCALE, 0, 0));
//CheckDlgButton(hwndDlg, IDC_ENABLEAUTOUPDATES, db_get_b(NULL, "LangMan", "EnableAutoUpdates", SETTING_ENABLEAUTOUPDATES_DEFAULT) != 0);
/* show selection */
int iItem = ListView_GetNextItem(hwndList, -1, LVNI_SELECTED);
if (iItem != -1)
ListView_EnsureVisible(hwndList, iItem, FALSE);
}
return TRUE;
case M_SHOWFILECOL:
if ((BOOL)lParam && ListView_GetItemCount(hwndList) > 1) {
/* add column */
LVCOLUMN lvc;
ListView_SetColumnWidth(hwndList, 0, LVSCW_AUTOSIZE_USEHEADER);
lvc.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
lvc.pszText = TranslateT("File");
lvc.cx = 160;
ListView_InsertColumn(hwndList, lvc.iSubItem = 1, &lvc);
ListView_SetColumnWidth(hwndList, 0, ListView_GetColumnWidth(hwndList, 0) - lvc.cx);
/* add text */
lvi.mask = LVIF_PARAM;
lvi.iSubItem = 0;
for (lvi.iItem = 0; ListView_GetItem(hwndList, &lvi); ++lvi.iItem) {
LANGPACK_INFO *pack = (LANGPACK_INFO*)lvi.lParam;
ListView_SetItemText(hwndList, lvi.iItem, 1, (pack->flags&LPF_DEFAULT) ? TranslateT("built-in") : pack->szFileName);
}
}
else {
ListView_DeleteColumn(hwndList, 1);
ListView_SetColumnWidth(hwndList, 0, LVSCW_AUTOSIZE_USEHEADER);
}
return TRUE;
case WM_DESTROY:
ListView_DeleteAllItems(GetDlgItem(hwndDlg, IDC_LANGLIST));
return TRUE;
case WM_THEMECHANGED:
case WM_SETTINGCHANGE:
{
HIMAGELIST himl = ListView_SetImageList(hwndList, CreateRadioImages(ListView_GetBkColor(hwndList), ListView_GetTextColor(hwndList)), LVSIL_STATE); /* auto-destroyed */
if (himl != NULL)
ImageList_Destroy(himl);
}
break;
case WM_CTLCOLORLISTBOX: /* mimic readonly edit */
return (BOOL)SendMessage(hwndDlg, WM_CTLCOLORSTATIC, wParam, lParam);
case WM_COMMAND:
switch(LOWORD(wParam)) {
case IDC_LANGEMAIL:
{
char buf[512];
lstrcpyA(buf, "mailto:");
if (GetWindowTextA(GetDlgItem(hwndDlg, LOWORD(wParam)), &buf[7], sizeof(buf)-7))
CallService(MS_UTILS_OPENURL, FALSE, (LPARAM)buf);
return TRUE;
}
case IDC_MORELANG:
CallService(MS_UTILS_OPENURL, TRUE, (LPARAM)"http://miranda-ng.org/");
return TRUE;
}
break;
case WM_CONTEXTMENU:
if (GetDlgCtrlID((HWND)wParam) == IDC_LANGLIST) {
/* get item */
LVHITTESTINFO hti;
POINTSTOPOINT(hti.pt, MAKEPOINTS(lParam));
if (hti.pt.x == -1 && hti.pt.y == -1) {
/* keyboard invoked */
hti.iItem = ListView_GetNextItem((HWND)wParam, -1, LVNI_SELECTED);
if (hti.iItem != -1)
break;
RECT rc;
if (!ListView_GetItemRect((HWND)wParam, hti.iItem, &rc, LVIR_SELECTBOUNDS))
break;
hti.pt.x = rc.left + (rc.right - rc.left) / 2;
hti.pt.y = rc.top + (rc.bottom - rc.top) / 2;
ClientToScreen((HWND)wParam, &hti.pt);
}
else {
ScreenToClient((HWND)wParam, &hti.pt);
if (ListView_HitTest((HWND)wParam, &hti) == -1 || !(hti.flags&LVHT_ONITEM))
break;
POINTSTOPOINT(hti.pt, MAKEPOINTS(lParam));
}
/* param */
lvi.iItem = hti.iItem;
lvi.iSubItem = 0;
lvi.mask = LVIF_PARAM;
if (!ListView_GetItem((HWND)wParam, &lvi))
break;
/* context menu */
LANGPACK_INFO *pack = (LANGPACK_INFO*)lvi.lParam;
if (!(pack->flags & LPF_DEFAULT)) {
HMENU hContextMenu = CreatePopupMenu();
if (hContextMenu != NULL) {
AppendMenu(hContextMenu, MF_STRING, 2, TranslateT("&Remove..."));
if (TrackPopupMenuEx(hContextMenu, TPM_RETURNCMD | TPM_NONOTIFY | TPM_TOPALIGN | TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_HORPOSANIMATION | TPM_VERPOSANIMATION, hti.pt.x, hti.pt.y, (HWND)wParam, NULL))
DeletePackFile(hwndDlg, (HWND)wParam, hti.iItem, pack);
DestroyMenu(hContextMenu);
}
}
return TRUE;
}
break;
case WM_NOTIFYFORMAT:
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, NFR_UNICODE);
return TRUE;
case WM_NOTIFY:
NMHDR *nmhdr = (NMHDR*)lParam;
switch (nmhdr->idFrom) {
case IDC_LANGLIST:
switch (nmhdr->code) {
case LVN_DELETEITEM:
lvi.iItem = ((NMLISTVIEW*)lParam)->iItem; /* nmlv->lParam is invalid */
lvi.iSubItem = 0;
lvi.mask = LVIF_PARAM;
if (ListView_GetItem(nmhdr->hwndFrom, &lvi))
mir_free((LANGPACK_INFO*)lvi.lParam);
break;
case LVN_ITEMCHANGED:
{
NMLISTVIEW *nmlv = (NMLISTVIEW*)lParam;
if (!(nmlv->uChanged&LVIF_STATE))
break;
/* display info and check radio item */
if (nmlv->uNewState&LVIS_SELECTED && !(nmlv->uOldState&LVIS_SELECTED)) {
ListView_SetItemState(nmhdr->hwndFrom, nmlv->iItem, INDEXTOSTATEIMAGEMASK(2), LVIS_STATEIMAGEMASK);
DisplayPackInfo(hwndDlg, (LANGPACK_INFO*)nmlv->lParam);
}
/* disable all other radio items */
else if (nmlv->uNewState&INDEXTOSTATEIMAGEMASK(2)) {
for (int iItem = ListView_GetItemCount(nmhdr->hwndFrom) - 1; iItem != -1; --iItem)
if (iItem != nmlv->iItem)
ListView_SetItemState(nmhdr->hwndFrom, iItem, INDEXTOSTATEIMAGEMASK(1), LVIS_STATEIMAGEMASK);
/* enable apply */
if (nmlv->uOldState) {
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
ShowWindow(GetDlgItem(hwndDlg, IDC_RESTART), SW_SHOW);
}
}
}
break;
case LVN_KEYDOWN:
{
int iItem = ListView_GetNextItem(nmhdr->hwndFrom, -1, LVNI_SELECTED);
switch (((NMLVKEYDOWN*)lParam)->wVKey) {
case VK_SPACE:
ListView_SetItemState(nmhdr->hwndFrom, iItem, INDEXTOSTATEIMAGEMASK(2), LVIS_STATEIMAGEMASK);
break;
case VK_DELETE:
lvi.iItem = iItem;
lvi.iSubItem = 0;
lvi.mask = LVIF_PARAM;
if (ListView_GetItem(nmhdr->hwndFrom, &lvi)) {
LANGPACK_INFO *pack = (LANGPACK_INFO*)lvi.lParam;
if (!(pack->flags&LPF_DEFAULT))
DeletePackFile(hwndDlg, nmhdr->hwndFrom, iItem, pack);
}
break;
}
}
break;
case NM_CLICK:
LVHITTESTINFO hti;
lParam = GetMessagePos();
POINTSTOPOINT(hti.pt, MAKEPOINTS(lParam));
ScreenToClient(nmhdr->hwndFrom, &hti.pt);
if (ListView_HitTest(nmhdr->hwndFrom, &hti) != -1)
if (hti.flags&(LVHT_ONITEMSTATEICON | LVHT_ONITEMICON)) /* one of them */
ListView_SetItemState(nmhdr->hwndFrom, hti.iItem, LVIS_SELECTED, LVIS_SELECTED);
}
break;
case 0:
switch (nmhdr->code) {
case PSN_APPLY:
lvi.mask = LVIF_STATE | LVIF_PARAM;
lvi.stateMask = LVIS_STATEIMAGEMASK;
lvi.iSubItem = 0;
for (lvi.iItem = 0; ListView_GetItem(hwndList, &lvi); ++lvi.iItem) {
LANGPACK_INFO *pack = (LANGPACK_INFO*)lvi.lParam;
if (lvi.state&INDEXTOSTATEIMAGEMASK(2) && !(pack->flags & LPF_ENABLED)) {
if(!(pack->flags & LPF_DEFAULT))
db_set_ws(NULL, "LangMan", "Langpack", pack->szFileName);
else
db_unset(NULL, "LangMan", "Langpack");
TCHAR szPath[MAX_PATH];
GetPackPath(szPath, SIZEOF(szPath), FALSE, pack->szFileName);
CallService(MS_LANGPACK_RELOAD, 0, (LPARAM)szPath);
pack->flags |= LPF_ENABLED;
CloseWindow(GetParent(hwndDlg));
DestroyWindow(GetParent(hwndDlg));
}
else pack->flags &= ~LPF_ENABLED;
}
return TRUE;
}
}
break;
}
return FALSE;
}