LRESULT UT_DefWindowProc(HWND hWnd, UINT Msg, WPARAM wParam,LPARAM lParam) { return DefWindowProcW(hWnd, Msg, wParam, lParam); }
static void GB_draw(HTHEME theme, HWND hwnd, HDC hDC, ButtonState drawState, UINT dtFlags, BOOL focused) #endif { static const int states[] = { GBS_NORMAL, GBS_NORMAL, GBS_NORMAL, GBS_DISABLED, GBS_NORMAL }; RECT bgRect, textRect, contentRect; int state = states[ drawState ]; WCHAR *text = get_button_text(hwnd); LOGFONTW lf; HFONT font, hPrevFont = NULL; BOOL created_font = FALSE; #ifdef __REACTOS__ /* r74406 */ HWND parent; HBRUSH hBrush; RECT clientRect; #endif HRESULT hr = GetThemeFont(theme, hDC, BP_GROUPBOX, state, TMT_FONT, &lf); if (SUCCEEDED(hr)) { font = CreateFontIndirectW(&lf); if (!font) TRACE("Failed to create font\n"); else { hPrevFont = SelectObject(hDC, font); created_font = TRUE; } } else { #ifdef __REACTOS__ /* r73885 */ font = get_button_font(hwnd); #else font = (HFONT)SendMessageW(hwnd, WM_GETFONT, 0, 0); #endif hPrevFont = SelectObject(hDC, font); } GetClientRect(hwnd, &bgRect); textRect = bgRect; if (text) { SIZE textExtent; GetTextExtentPoint32W(hDC, text, lstrlenW(text), &textExtent); bgRect.top += (textExtent.cy / 2); textRect.left += 10; textRect.bottom = textRect.top + textExtent.cy; textRect.right = textRect.left + textExtent.cx + 4; ExcludeClipRect(hDC, textRect.left, textRect.top, textRect.right, textRect.bottom); } GetThemeBackgroundContentRect(theme, hDC, BP_GROUPBOX, state, &bgRect, &contentRect); ExcludeClipRect(hDC, contentRect.left, contentRect.top, contentRect.right, contentRect.bottom); #ifdef __REACTOS__ /* r73885 & r74149 */ if (prfFlag == 0) { if (IsThemeBackgroundPartiallyTransparent(theme, BP_GROUPBOX, state)) DrawThemeParentBackground(hwnd, hDC, NULL); } #else if (IsThemeBackgroundPartiallyTransparent(theme, BP_GROUPBOX, state)) DrawThemeParentBackground(hwnd, hDC, NULL); #endif #ifdef __REACTOS__ /* r74406 */ parent = GetParent(hwnd); if (!parent) parent = hwnd; hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORSTATIC, (WPARAM)hDC, (LPARAM)hwnd); if (!hBrush) /* did the app forget to call defwindowproc ? */ hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORSTATIC, (WPARAM)hDC, (LPARAM)hwnd ); GetClientRect(hwnd, &clientRect); FillRect( hDC, &clientRect, hBrush ); #endif DrawThemeBackground(theme, hDC, BP_GROUPBOX, state, &bgRect, NULL); SelectClipRgn(hDC, NULL); if (text) { InflateRect(&textRect, -2, 0); DrawThemeText(theme, hDC, BP_GROUPBOX, state, text, lstrlenW(text), 0, 0, &textRect); HeapFree(GetProcessHeap(), 0, text); } if (created_font) DeleteObject(font); if (hPrevFont) SelectObject(hDC, hPrevFont); }
/*********************************************************************** * UpDownWndProc */ static LRESULT WINAPI UpDownWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr (hwnd); static const WCHAR themeClass[] = {'S','p','i','n',0}; HTHEME theme; TRACE("hwnd=%p msg=%04x wparam=%08lx lparam=%08lx\n", hwnd, message, wParam, lParam); if (!infoPtr && (message != WM_CREATE)) return DefWindowProcW (hwnd, message, wParam, lParam); switch(message) { case WM_CREATE: infoPtr = Alloc (sizeof(UPDOWN_INFO)); SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr); /* initialize the info struct */ infoPtr->Self = hwnd; infoPtr->Notify = ((LPCREATESTRUCTW)lParam)->hwndParent; infoPtr->dwStyle = ((LPCREATESTRUCTW)lParam)->style; infoPtr->AccelCount = 0; infoPtr->AccelVect = 0; infoPtr->AccelIndex = -1; infoPtr->CurVal = 0; infoPtr->MinVal = 100; infoPtr->MaxVal = 0; infoPtr->Base = 10; /* Default to base 10 */ infoPtr->Buddy = 0; /* No buddy window yet */ infoPtr->Flags = 0; /* And no flags */ SetWindowLongW (hwnd, GWL_STYLE, infoPtr->dwStyle & ~WS_BORDER); /* Do we pick the buddy win ourselves? */ if (infoPtr->dwStyle & UDS_AUTOBUDDY) UPDOWN_SetBuddy (infoPtr, GetWindow (hwnd, GW_HWNDPREV)); OpenThemeData (hwnd, themeClass); TRACE("UpDown Ctrl creation, hwnd=%p\n", hwnd); break; case WM_DESTROY: Free (infoPtr->AccelVect); if(infoPtr->Buddy) RemovePropW(infoPtr->Buddy, BUDDY_UPDOWN_HWND); Free (infoPtr); SetWindowLongPtrW (hwnd, 0, 0); theme = GetWindowTheme (hwnd); CloseThemeData (theme); TRACE("UpDown Ctrl destruction, hwnd=%p\n", hwnd); break; case WM_ENABLE: if (wParam) { infoPtr->dwStyle &= ~WS_DISABLED; } else { infoPtr->dwStyle |= WS_DISABLED; UPDOWN_CancelMode (infoPtr); } InvalidateRect (infoPtr->Self, NULL, FALSE); break; case WM_STYLECHANGED: if (wParam == GWL_STYLE) { infoPtr->dwStyle = ((LPSTYLESTRUCT)lParam)->styleNew; InvalidateRect (infoPtr->Self, NULL, FALSE); } break; case WM_THEMECHANGED: theme = GetWindowTheme (hwnd); CloseThemeData (theme); OpenThemeData (hwnd, themeClass); InvalidateRect (hwnd, NULL, FALSE); break; case WM_TIMER: /* is this the auto-press timer? */ if(wParam == TIMER_AUTOPRESS) { KillTimer(hwnd, TIMER_AUTOPRESS); infoPtr->Flags &= ~(FLAG_PRESSED | FLAG_ARROW); InvalidateRect(infoPtr->Self, NULL, FALSE); } /* if initial timer, kill it and start the repeat timer */ if(wParam == TIMER_AUTOREPEAT) { int temp; KillTimer(hwnd, TIMER_AUTOREPEAT); /* if no accel info given, used default timer */ if(infoPtr->AccelCount==0 || infoPtr->AccelVect==0) { infoPtr->AccelIndex = -1; temp = REPEAT_DELAY; } else { infoPtr->AccelIndex = 0; /* otherwise, use it */ temp = infoPtr->AccelVect[infoPtr->AccelIndex].nSec * 1000 + 1; } SetTimer(hwnd, TIMER_ACCEL, temp, 0); } /* now, if the mouse is above us, do the thing...*/ if(infoPtr->Flags & FLAG_MOUSEIN) { int temp; temp = infoPtr->AccelIndex == -1 ? 1 : infoPtr->AccelVect[infoPtr->AccelIndex].nInc; UPDOWN_DoAction(infoPtr, temp, infoPtr->Flags & FLAG_ARROW); if(infoPtr->AccelIndex != -1 && infoPtr->AccelIndex < infoPtr->AccelCount-1) { KillTimer(hwnd, TIMER_ACCEL); infoPtr->AccelIndex++; /* move to the next accel info */ temp = infoPtr->AccelVect[infoPtr->AccelIndex].nSec * 1000 + 1; /* make sure we have at least 1ms intervals */ SetTimer(hwnd, TIMER_ACCEL, temp, 0); } } break; case WM_CANCELMODE: return UPDOWN_CancelMode (infoPtr); case WM_LBUTTONUP: if (GetCapture() != infoPtr->Self) break; if ( (infoPtr->Flags & FLAG_MOUSEIN) && (infoPtr->Flags & FLAG_ARROW) ) { SendMessageW( infoPtr->Notify, (infoPtr->dwStyle & UDS_HORZ) ? WM_HSCROLL : WM_VSCROLL, MAKELONG(SB_ENDSCROLL, infoPtr->CurVal), (LPARAM)hwnd); if (UPDOWN_IsBuddyEdit(infoPtr)) SendMessageW(infoPtr->Buddy, EM_SETSEL, 0, MAKELONG(0, -1)); } UPDOWN_CancelMode(infoPtr); break; case WM_LBUTTONDOWN: case WM_MOUSEMOVE: case WM_MOUSELEAVE: if(UPDOWN_IsEnabled(infoPtr)) UPDOWN_HandleMouseEvent (infoPtr, message, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam)); break; case WM_MOUSEWHEEL: UPDOWN_MouseWheel(infoPtr, wParam); break; case WM_KEYDOWN: if((infoPtr->dwStyle & UDS_ARROWKEYS) && UPDOWN_IsEnabled(infoPtr)) return UPDOWN_KeyPressed(infoPtr, (int)wParam); break; case WM_PRINTCLIENT: case WM_PAINT: return UPDOWN_Paint (infoPtr, (HDC)wParam); case UDM_GETACCEL: if (wParam==0 && lParam==0) return infoPtr->AccelCount; if (wParam && lParam) { int temp = min(infoPtr->AccelCount, wParam); memcpy((void *)lParam, infoPtr->AccelVect, temp*sizeof(UDACCEL)); return temp; } return 0; case UDM_SETACCEL: { unsigned temp; TRACE("UDM_SETACCEL\n"); if(infoPtr->AccelVect) { Free (infoPtr->AccelVect); infoPtr->AccelCount = 0; infoPtr->AccelVect = 0; } if(wParam==0) return TRUE; infoPtr->AccelVect = Alloc (wParam*sizeof(UDACCEL)); if(infoPtr->AccelVect == 0) return FALSE; memcpy(infoPtr->AccelVect, (void*)lParam, wParam*sizeof(UDACCEL)); infoPtr->AccelCount = wParam; for (temp = 0; temp < wParam; temp++) TRACE("%d: nSec %u nInc %u\n", temp, infoPtr->AccelVect[temp].nSec, infoPtr->AccelVect[temp].nInc); return TRUE; } case UDM_GETBASE: return infoPtr->Base; case UDM_SETBASE: TRACE("UpDown Ctrl new base(%ld), hwnd=%p\n", wParam, hwnd); if (wParam==10 || wParam==16) { WPARAM temp = infoPtr->Base; infoPtr->Base = wParam; return temp; } break; case UDM_GETBUDDY: return (LRESULT)infoPtr->Buddy; case UDM_SETBUDDY: return (LRESULT)UPDOWN_SetBuddy (infoPtr, (HWND)wParam); case UDM_GETPOS: { int temp = UPDOWN_GetBuddyInt (infoPtr); return MAKELONG(infoPtr->CurVal, temp ? 0 : 1); } case UDM_SETPOS: { int temp = (short)LOWORD(lParam); TRACE("UpDown Ctrl new value(%d), hwnd=%p\n", temp, hwnd); if(!UPDOWN_InBounds(infoPtr, temp)) { if(temp < infoPtr->MinVal) temp = infoPtr->MinVal; if(temp > infoPtr->MaxVal) temp = infoPtr->MaxVal; } wParam = infoPtr->CurVal; infoPtr->CurVal = temp; UPDOWN_SetBuddyInt (infoPtr); return wParam; /* return prev value */ } case UDM_GETRANGE: return MAKELONG(infoPtr->MaxVal, infoPtr->MinVal); case UDM_SETRANGE: /* we must have: */ infoPtr->MaxVal = (short)(lParam); /* UD_MINVAL <= Max <= UD_MAXVAL */ infoPtr->MinVal = (short)HIWORD(lParam); /* UD_MINVAL <= Min <= UD_MAXVAL */ /* |Max-Min| <= UD_MAXVAL */ TRACE("UpDown Ctrl new range(%d to %d), hwnd=%p\n", infoPtr->MinVal, infoPtr->MaxVal, hwnd); break; case UDM_GETRANGE32: if (wParam) *(LPINT)wParam = infoPtr->MinVal; if (lParam) *(LPINT)lParam = infoPtr->MaxVal; break; case UDM_SETRANGE32: infoPtr->MinVal = (INT)wParam; infoPtr->MaxVal = (INT)lParam; if (infoPtr->MaxVal <= infoPtr->MinVal) infoPtr->MaxVal = infoPtr->MinVal + 1; TRACE("UpDown Ctrl new range(%d to %d), hwnd=%p\n", infoPtr->MinVal, infoPtr->MaxVal, hwnd); break; case UDM_GETPOS32: if ((LPBOOL)lParam != NULL) *((LPBOOL)lParam) = TRUE; return infoPtr->CurVal; case UDM_SETPOS32: { int temp; if(!UPDOWN_InBounds(infoPtr, (int)lParam)) { if((int)lParam < infoPtr->MinVal) lParam = infoPtr->MinVal; if((int)lParam > infoPtr->MaxVal) lParam = infoPtr->MaxVal; } temp = infoPtr->CurVal; /* save prev value */ infoPtr->CurVal = (int)lParam; /* set the new value */ UPDOWN_SetBuddyInt (infoPtr); return temp; /* return prev value */ } case UDM_GETUNICODEFORMAT: /* we lie a bit here, we're always using Unicode internally */ return infoPtr->UnicodeFormat; case UDM_SETUNICODEFORMAT: { /* do we really need to honour this flag? */ int temp = infoPtr->UnicodeFormat; infoPtr->UnicodeFormat = (BOOL)wParam; return temp; } default: if ((message >= WM_USER) && (message < WM_APP) && !COMCTL32_IsReflectedMessage(message)) ERR("unknown msg %04x wp=%04lx lp=%08lx\n", message, wParam, lParam); return DefWindowProcW (hwnd, message, wParam, lParam); } return 0; }
LRESULT CALLBACK HostWndProcW (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { RECT boundingRect; switch(message){ /* mousing */ case WM_MOUSEMOVE: recordMouseEvent(lastMessage); break; case WM_LBUTTONDOWN: case WM_RBUTTONDOWN: case WM_MBUTTONDOWN: if(GetFocus() != hwnd) SetFocus(hwnd); SetCapture(hwnd); /* capture mouse input */ recordMouseEvent(lastMessage); break; case WM_LBUTTONUP: case WM_RBUTTONUP: case WM_MBUTTONUP: if(GetFocus() != hwnd) SetFocus(hwnd); ReleaseCapture(); /* release mouse capture */ recordMouseEvent(lastMessage); break; /*keyboard events*/ case WM_KEYDOWN: case WM_SYSKEYDOWN: case WM_KEYUP: case WM_SYSKEYUP: case WM_CHAR: case WM_SYSCHAR: recordKeyboardEvent(lastMessage); break; /*window events*/ case WM_MOVE: case WM_SIZE: if ((GetWindowRect(hwnd, &boundingRect)) != 0){ sqWindowEvent *windowevent = (sqWindowEvent*) sqNextEventPut(); windowevent->type = EventTypeWindow; windowevent->timeStamp = lastMessage ? lastMessage->time : GetTickCount(); windowevent->action = WindowEventMetricChange; windowevent->value1 = boundingRect.left ; windowevent->value2 = boundingRect.top; windowevent->value3 = boundingRect.right; windowevent->value4 = boundingRect.bottom; windowevent->windowIndex =(int) hwnd; } break; case WM_PAINT: if ((GetWindowRect(hwnd, &boundingRect)) != 0){ sqWindowEvent *windowevent = (sqWindowEvent*) sqNextEventPut(); windowevent->type = EventTypeWindow; windowevent->timeStamp = lastMessage ? lastMessage->time : GetTickCount(); windowevent->action = WindowEventPaint; windowevent->value1 = boundingRect.left ; windowevent->value2 = boundingRect.top; windowevent->value3 = boundingRect.right; windowevent->value4 = boundingRect.bottom; windowevent->windowIndex =(int) hwnd; } break; case WM_CLOSE: { sqWindowEvent *windowevent = (sqWindowEvent*) sqNextEventPut(); windowevent->type = EventTypeWindow; windowevent->timeStamp = lastMessage ? lastMessage->time : GetTickCount(); windowevent->action = WindowEventClose; windowevent->windowIndex =(int) hwnd; } break; case WM_ACTIVATE: { sqWindowEvent *windowevent = (sqWindowEvent*) sqNextEventPut(); windowevent->type = EventTypeWindow; windowevent->timeStamp = lastMessage ? lastMessage->time : GetTickCount(); if (wParam == WA_INACTIVE) windowevent->action = WindowEventIconise; else windowevent->action = WindowEventActivated; windowevent->windowIndex =(int) hwnd; } break; case WM_GETMINMAXINFO: { sqWindowEvent *windowevent = (sqWindowEvent*) sqNextEventPut(); windowevent->type = EventTypeWindow; windowevent->timeStamp = lastMessage ? lastMessage->time : GetTickCount(); if (IsIconic(hwnd) != 0)windowevent->action = WindowEventIconise; else windowevent->action = WindowEventActivated; windowevent->windowIndex =(int) hwnd; } break; } return DefWindowProcW(hwnd,message,wParam,lParam); }
static LRESULT WINAPI PAGER_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { PAGER_INFO *infoPtr = (PAGER_INFO *)GetWindowLongPtrW(hwnd, 0); if (!infoPtr && (uMsg != WM_CREATE)) return DefWindowProcW (hwnd, uMsg, wParam, lParam); switch (uMsg) { case EM_FMTLINES: return PAGER_FmtLines(infoPtr); case PGM_FORWARDMOUSE: return PAGER_ForwardMouse (infoPtr, (BOOL)wParam); case PGM_GETBKCOLOR: return PAGER_GetBkColor(infoPtr); case PGM_GETBORDER: return PAGER_GetBorder(infoPtr); case PGM_GETBUTTONSIZE: return PAGER_GetButtonSize(infoPtr); case PGM_GETPOS: return PAGER_GetPos(infoPtr); case PGM_GETBUTTONSTATE: return PAGER_GetButtonState (infoPtr, (INT)lParam); /* case PGM_GETDROPTARGET: */ case PGM_RECALCSIZE: return PAGER_RecalcSize(infoPtr); case PGM_SETBKCOLOR: return PAGER_SetBkColor (infoPtr, (COLORREF)lParam); case PGM_SETBORDER: return PAGER_SetBorder (infoPtr, (INT)lParam); case PGM_SETBUTTONSIZE: return PAGER_SetButtonSize (infoPtr, (INT)lParam); case PGM_SETCHILD: return PAGER_SetChild (infoPtr, (HWND)lParam); case PGM_SETPOS: return PAGER_SetPos(infoPtr, (INT)lParam, FALSE); case WM_CREATE: return PAGER_Create (hwnd, (LPCREATESTRUCTW)lParam); case WM_DESTROY: return PAGER_Destroy (infoPtr); case WM_SIZE: return PAGER_Size (infoPtr, (INT)wParam, (short)LOWORD(lParam), (short)HIWORD(lParam)); case WM_NCPAINT: return PAGER_NCPaint (infoPtr, (HRGN)wParam); case WM_WINDOWPOSCHANGING: return PAGER_WindowPosChanging (infoPtr, (WINDOWPOS*)lParam); case WM_STYLECHANGED: return PAGER_StyleChanged(infoPtr, wParam, (LPSTYLESTRUCT)lParam); case WM_NCCALCSIZE: return PAGER_NCCalcSize (infoPtr, wParam, (LPRECT)lParam); case WM_NCHITTEST: return PAGER_NCHitTest (infoPtr, (short)LOWORD(lParam), (short)HIWORD(lParam)); case WM_MOUSEMOVE: if (infoPtr->bForward && infoPtr->hwndChild) PostMessageW(infoPtr->hwndChild, WM_MOUSEMOVE, wParam, lParam); return PAGER_MouseMove (infoPtr, (INT)wParam, (short)LOWORD(lParam), (short)HIWORD(lParam)); case WM_LBUTTONDOWN: return PAGER_LButtonDown (infoPtr, (INT)wParam, (short)LOWORD(lParam), (short)HIWORD(lParam)); case WM_LBUTTONUP: return PAGER_LButtonUp (infoPtr, (INT)wParam, (short)LOWORD(lParam), (short)HIWORD(lParam)); case WM_ERASEBKGND: return PAGER_EraseBackground (infoPtr, (HDC)wParam); case WM_TIMER: return PAGER_Timer (infoPtr, (INT)wParam); case WM_NOTIFY: case WM_COMMAND: return SendMessageW (infoPtr->hwndNotify, uMsg, wParam, lParam); default: return DefWindowProcW (hwnd, uMsg, wParam, lParam); } }
static LRESULT CALLBACK Child_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { switch (message) { case WM_PAINT: return Child_OnPaint(hWnd); case WM_SIZE: return Child_OnSize(hWnd); case WM_NOTIFY: { HHInfo *info = (HHInfo*)GetWindowLongPtrW(hWnd, GWLP_USERDATA); NMHDR *nmhdr = (NMHDR*)lParam; switch(nmhdr->code) { case TCN_SELCHANGE: return OnTabChange(hWnd); case TVN_SELCHANGEDW: return OnTopicChange(info, (void*)((NMTREEVIEWW *)lParam)->itemNew.lParam); case NM_DBLCLK: if(!info) return 0; switch(info->current_tab) { case TAB_INDEX: return OnTopicChange(info, (void*)((NMITEMACTIVATE *)lParam)->lParam); case TAB_SEARCH: return OnTopicChange(info, (void*)((NMITEMACTIVATE *)lParam)->lParam); } break; case NM_RETURN: if(!info) return 0; switch(info->current_tab) { case TAB_INDEX: { HWND hwndList = info->tabs[TAB_INDEX].hwnd; LVITEMW lvItem; lvItem.iItem = (int) SendMessageW(hwndList, LVM_GETSELECTIONMARK, 0, 0); lvItem.mask = TVIF_PARAM; SendMessageW(hwndList, LVM_GETITEMW, 0, (LPARAM)&lvItem); OnTopicChange(info, (void*) lvItem.lParam); return 0; } case TAB_SEARCH: { if(nmhdr->hwndFrom == info->search.hwndEdit) { char needle[100]; DWORD i, len; len = GetWindowTextA(info->search.hwndEdit, needle, sizeof(needle)); if(!len) { FIXME("Unable to get search text.\n"); return 0; } /* Convert the requested text for comparison later against the * lower case version of HTML file contents. */ for(i=0;i<len;i++) needle[i] = tolower(needle[i]); InitSearch(info, needle); return 0; }else if(nmhdr->hwndFrom == info->search.hwndList) { HWND hwndList = info->search.hwndList; LVITEMW lvItem; lvItem.iItem = (int) SendMessageW(hwndList, LVM_GETSELECTIONMARK, 0, 0); lvItem.mask = TVIF_PARAM; SendMessageW(hwndList, LVM_GETITEMW, 0, (LPARAM)&lvItem); OnTopicChange(info, (void*) lvItem.lParam); return 0; } break; } } break; } break; } default: return DefWindowProcW(hWnd, message, wParam, lParam); } return 0; }
static LRESULT WINAPI IME_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { LRESULT rc = 0; HIMC hIMC; TRACE("Incoming Message 0x%x (0x%08lx, 0x%08lx)\n", msg, wParam, lParam); /* * Each UI window contains the current Input Context. * This Input Context can be obtained by calling GetWindowLong * with IMMGWL_IMC when the UI window receives a WM_IME_xxx message. * The UI window can refer to this Input Context and handles the * messages. */ hIMC = (HIMC)GetWindowLongPtrW(hwnd,IMMGWL_IMC); if (!hIMC) hIMC = RealIMC(FROM_X11); /* if we have no hIMC there are many messages we cannot process */ if (hIMC == NULL) { switch (msg) { case WM_IME_STARTCOMPOSITION: case WM_IME_ENDCOMPOSITION: case WM_IME_COMPOSITION: case WM_IME_NOTIFY: case WM_IME_CONTROL: case WM_IME_COMPOSITIONFULL: case WM_IME_SELECT: case WM_IME_CHAR: return 0L; default: break; } } switch(msg) { case WM_CREATE: { LPIMEPRIVATE myPrivate; LPINPUTCONTEXT lpIMC; SetWindowTextA(hwnd,"Wine Ime Active"); lpIMC = LockRealIMC(hIMC); if (lpIMC) { myPrivate = ImmLockIMCC(lpIMC->hPrivate); myPrivate->hwndDefault = hwnd; ImmUnlockIMCC(lpIMC->hPrivate); } UnlockRealIMC(hIMC); return TRUE; } case WM_PAINT: PaintDefaultIMEWnd(hIMC, hwnd); return FALSE; case WM_NCCREATE: return TRUE; case WM_SETFOCUS: if (wParam) SetFocus((HWND)wParam); else FIXME("Received focus, should never have focus\n"); break; case WM_IME_COMPOSITION: DefaultIMEComposition(hIMC, hwnd, lParam); break; case WM_IME_STARTCOMPOSITION: DefaultIMEStartComposition(hIMC, hwnd); break; case WM_IME_ENDCOMPOSITION: TRACE("IME message %s, 0x%lx, 0x%lx\n", "WM_IME_ENDCOMPOSITION", wParam, lParam); ShowWindow(hwnd,SW_HIDE); break; case WM_IME_SELECT: TRACE("IME message %s, 0x%lx, 0x%lx\n","WM_IME_SELECT", wParam, lParam); break; case WM_IME_CONTROL: TRACE("IME message %s, 0x%lx, 0x%lx\n","WM_IME_CONTROL", wParam, lParam); rc = 1; break; case WM_IME_NOTIFY: rc = ImeHandleNotify(hIMC,hwnd,msg,wParam,lParam); break; default: TRACE("Non-standard message 0x%x\n",msg); } /* check the MSIME messages */ if (msg == WM_MSIME_SERVICE) { TRACE("IME message %s, 0x%lx, 0x%lx\n","WM_MSIME_SERVICE", wParam, lParam); rc = FALSE; } else if (msg == WM_MSIME_RECONVERTOPTIONS) { TRACE("IME message %s, 0x%lx, 0x%lx\n","WM_MSIME_RECONVERTOPTIONS", wParam, lParam); } else if (msg == WM_MSIME_MOUSE) { TRACE("IME message %s, 0x%lx, 0x%lx\n","WM_MSIME_MOUSE", wParam, lParam); } else if (msg == WM_MSIME_RECONVERTREQUEST) { TRACE("IME message %s, 0x%lx, 0x%lx\n","WM_MSIME_RECONVERTREQUEST", wParam, lParam); } else if (msg == WM_MSIME_RECONVERT) { TRACE("IME message %s, 0x%lx, 0x%lx\n","WM_MSIME_RECONVERT", wParam, lParam); } else if (msg == WM_MSIME_QUERYPOSITION) { TRACE("IME message %s, 0x%lx, 0x%lx\n","WM_MSIME_QUERYPOSITION", wParam, lParam); } else if (msg == WM_MSIME_DOCUMENTFEED) { TRACE("IME message %s, 0x%lx, 0x%lx\n","WM_MSIME_DOCUMENTFEED", wParam, lParam); } /* DefWndProc if not an IME message */ if (!rc && !((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) || (msg >= WM_IME_SETCONTEXT && msg <= WM_IME_KEYUP))) rc = DefWindowProcW(hwnd,msg,wParam,lParam); return rc; }
/* Message handler for dialog box. */ static INT_PTR CALLBACK TaskManagerWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) { static const WCHAR wszTaskmgr[] = {'t','a','s','k','m','g','r',0}; HDC hdc; PAINTSTRUCT ps; LPRECT pRC; RECT rc; LPNMHDR pnmh; WINDOWPLACEMENT wp; switch (message) { case WM_INITDIALOG: hMainWnd = hDlg; return OnCreate(hDlg); case WM_COMMAND: if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) { EndDialog(hDlg, LOWORD(wParam)); return TRUE; } /* Process menu commands */ switch (LOWORD(wParam)) { case ID_FILE_NEW: TaskManager_OnFileNew(); break; case ID_OPTIONS_ALWAYSONTOP: TaskManager_OnOptionsAlwaysOnTop(); break; case ID_OPTIONS_MINIMIZEONUSE: TaskManager_OnOptionsMinimizeOnUse(); break; case ID_OPTIONS_HIDEWHENMINIMIZED: TaskManager_OnOptionsHideWhenMinimized(); break; case ID_OPTIONS_SHOW16BITTASKS: TaskManager_OnOptionsShow16BitTasks(); break; case ID_RESTORE: TaskManager_OnRestoreMainWindow(); break; case ID_VIEW_LARGE: ApplicationPage_OnViewLargeIcons(); break; case ID_VIEW_SMALL: ApplicationPage_OnViewSmallIcons(); break; case ID_VIEW_DETAILS: ApplicationPage_OnViewDetails(); break; case ID_VIEW_SHOWKERNELTIMES: PerformancePage_OnViewShowKernelTimes(); break; case ID_VIEW_CPUHISTORY_ONEGRAPHALL: PerformancePage_OnViewCPUHistoryOneGraphAll(); break; case ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU: PerformancePage_OnViewCPUHistoryOneGraphPerCPU(); break; case ID_VIEW_UPDATESPEED_HIGH: TaskManager_OnViewUpdateSpeedHigh(); break; case ID_VIEW_UPDATESPEED_NORMAL: TaskManager_OnViewUpdateSpeedNormal(); break; case ID_VIEW_UPDATESPEED_LOW: TaskManager_OnViewUpdateSpeedLow(); break; case ID_VIEW_UPDATESPEED_PAUSED: TaskManager_OnViewUpdateSpeedPaused(); break; case ID_VIEW_SELECTCOLUMNS: ProcessPage_OnViewSelectColumns(); break; case ID_VIEW_REFRESH: PostMessageW(hDlg, WM_TIMER, 0, 0); break; case ID_WINDOWS_TILEHORIZONTALLY: ApplicationPage_OnWindowsTileHorizontally(); break; case ID_WINDOWS_TILEVERTICALLY: ApplicationPage_OnWindowsTileVertically(); break; case ID_WINDOWS_MINIMIZE: ApplicationPage_OnWindowsMinimize(); break; case ID_WINDOWS_MAXIMIZE: ApplicationPage_OnWindowsMaximize(); break; case ID_WINDOWS_CASCADE: ApplicationPage_OnWindowsCascade(); break; case ID_WINDOWS_BRINGTOFRONT: ApplicationPage_OnWindowsBringToFront(); break; case ID_APPLICATION_PAGE_SWITCHTO: ApplicationPage_OnSwitchTo(); break; case ID_APPLICATION_PAGE_ENDTASK: ApplicationPage_OnEndTask(); break; case ID_APPLICATION_PAGE_GOTOPROCESS: ApplicationPage_OnGotoProcess(); break; case ID_PROCESS_PAGE_ENDPROCESS: ProcessPage_OnEndProcess(); break; case ID_PROCESS_PAGE_ENDPROCESSTREE: ProcessPage_OnEndProcessTree(); break; case ID_PROCESS_PAGE_DEBUG: ProcessPage_OnDebug(); break; case ID_PROCESS_PAGE_SETAFFINITY: ProcessPage_OnSetAffinity(); break; case ID_PROCESS_PAGE_SETPRIORITY_REALTIME: ProcessPage_OnSetPriorityRealTime(); break; case ID_PROCESS_PAGE_SETPRIORITY_HIGH: ProcessPage_OnSetPriorityHigh(); break; case ID_PROCESS_PAGE_SETPRIORITY_ABOVENORMAL: ProcessPage_OnSetPriorityAboveNormal(); break; case ID_PROCESS_PAGE_SETPRIORITY_NORMAL: ProcessPage_OnSetPriorityNormal(); break; case ID_PROCESS_PAGE_SETPRIORITY_BELOWNORMAL: ProcessPage_OnSetPriorityBelowNormal(); break; case ID_PROCESS_PAGE_SETPRIORITY_LOW: ProcessPage_OnSetPriorityLow(); break; case ID_PROCESS_PAGE_DEBUGCHANNELS: ProcessPage_OnDebugChannels(); break; case ID_HELP_TOPICS: WinHelpW(hDlg, wszTaskmgr, HELP_FINDER, 0); break; case ID_HELP_ABOUT: OnAbout(); break; case ID_FILE_EXIT: EndDialog(hDlg, IDOK); break; } break; case WM_ONTRAYICON: switch(lParam) { case WM_RBUTTONDOWN: { POINT pt; BOOL OnTop; HMENU hMenu, hPopupMenu; GetCursorPos(&pt); OnTop = (GetWindowLongW(hMainWnd, GWL_EXSTYLE) & WS_EX_TOPMOST) != 0; hMenu = LoadMenuW(hInst, MAKEINTRESOURCEW(IDR_TRAY_POPUP)); hPopupMenu = GetSubMenu(hMenu, 0); if(IsWindowVisible(hMainWnd)) { DeleteMenu(hPopupMenu, ID_RESTORE, MF_BYCOMMAND); } else { SetMenuDefaultItem(hPopupMenu, ID_RESTORE, FALSE); } if(OnTop) { CheckMenuItem(hPopupMenu, ID_OPTIONS_ALWAYSONTOP, MF_BYCOMMAND | MF_CHECKED); } SetForegroundWindow(hMainWnd); TrackPopupMenuEx(hPopupMenu, 0, pt.x, pt.y, hMainWnd, NULL); DestroyMenu(hMenu); break; } case WM_LBUTTONDBLCLK: TaskManager_OnRestoreMainWindow(); break; } break; case WM_NOTIFY: pnmh = (LPNMHDR)lParam; if ((pnmh->hwndFrom == hTabWnd) && (pnmh->idFrom == IDC_TAB) && (pnmh->code == TCN_SELCHANGE)) { TaskManager_OnTabWndSelChange(); } break; case WM_NCPAINT: hdc = GetDC(hDlg); GetClientRect(hDlg, &rc); Draw3dRect(hdc, rc.left, rc.top, rc.right, rc.top + 2, GetSysColor(COLOR_3DSHADOW), GetSysColor(COLOR_3DHILIGHT)); ReleaseDC(hDlg, hdc); break; case WM_PAINT: hdc = BeginPaint(hDlg, &ps); GetClientRect(hDlg, &rc); Draw3dRect(hdc, rc.left, rc.top, rc.right, rc.top + 2, GetSysColor(COLOR_3DSHADOW), GetSysColor(COLOR_3DHILIGHT)); EndPaint(hDlg, &ps); break; case WM_SIZING: /* Make sure the user is sizing the dialog */ /* in an acceptable range */ pRC = (LPRECT)lParam; if ((wParam == WMSZ_LEFT) || (wParam == WMSZ_TOPLEFT) || (wParam == WMSZ_BOTTOMLEFT)) { /* If the width is too small enlarge it to the minimum */ if (nMinimumWidth > (pRC->right - pRC->left)) pRC->left = pRC->right - nMinimumWidth; } else { /* If the width is too small enlarge it to the minimum */ if (nMinimumWidth > (pRC->right - pRC->left)) pRC->right = pRC->left + nMinimumWidth; } if ((wParam == WMSZ_TOP) || (wParam == WMSZ_TOPLEFT) || (wParam == WMSZ_TOPRIGHT)) { /* If the height is too small enlarge it to the minimum */ if (nMinimumHeight > (pRC->bottom - pRC->top)) pRC->top = pRC->bottom - nMinimumHeight; } else { /* If the height is too small enlarge it to the minimum */ if (nMinimumHeight > (pRC->bottom - pRC->top)) pRC->bottom = pRC->top + nMinimumHeight; } return TRUE; case WM_SIZE: /* Handle the window sizing in it's own function */ OnSize(wParam, LOWORD(lParam), HIWORD(lParam)); break; case WM_MOVE: /* Handle the window moving in it's own function */ OnMove(wParam, LOWORD(lParam), HIWORD(lParam)); break; case WM_DESTROY: ShowWindow(hDlg, SW_HIDE); TrayIcon_ShellRemoveTrayIcon(); wp.length = sizeof(WINDOWPLACEMENT); GetWindowPlacement(hDlg, &wp); TaskManagerSettings.Left = wp.rcNormalPosition.left; TaskManagerSettings.Top = wp.rcNormalPosition.top; TaskManagerSettings.Right = wp.rcNormalPosition.right; TaskManagerSettings.Bottom = wp.rcNormalPosition.bottom; if (IsZoomed(hDlg) || (wp.flags & WPF_RESTORETOMAXIMIZED)) TaskManagerSettings.Maximized = TRUE; else TaskManagerSettings.Maximized = FALSE; return DefWindowProcW(hDlg, message, wParam, lParam); case WM_TIMER: /* Refresh the performance data */ PerfDataRefresh(); RefreshApplicationPage(); RefreshProcessPage(); RefreshPerformancePage(); TrayIcon_ShellUpdateTrayIcon(); break; case WM_ENTERMENULOOP: TaskManager_OnEnterMenuLoop(hDlg); break; case WM_EXITMENULOOP: TaskManager_OnExitMenuLoop(hDlg); break; case WM_MENUSELECT: TaskManager_OnMenuSelect(hDlg, LOWORD(wParam), HIWORD(wParam), (HMENU)lParam); break; } return 0; }
LRESULT handleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam) override { switch (uMsg) { // If the user tries to destroy the window case WM_DESTROY: // Send a quit message with value of false to exit the loop PostQuitMessage(false); return 0; // If the user clicks the window case WM_LBUTTONDOWN: { // Pointer for the file dialog CComPtr<IFileOpenDialog> fileDialog; // Try to create the dialog HRESULT hr = fileDialog.CoCreateInstance(__uuidof(FileOpenDialog)); // If it failed to create the file dialog if (FAILED(hr)) { displayError(L"Could not open file selection dialog!"); return 0; } // Ask the user to select a file hr = fileDialog->Show(nullptr); // If the user chose Cancel if (FAILED(hr)) { displayError(L"No file selected!"); return 0; } // The selected file CComPtr<IShellItem> item; // Get the selected file hr = fileDialog->GetResult(&item); if (FAILED(hr)) { displayError(L"File selection failed!"); return 0; } PWSTR filePath; // Get the absolute name of the chosen file hr = item->GetDisplayName(SIGDN_FILESYSPATH, &filePath); if (FAILED(hr)) { displayError(L"Could not get file path!"); return 0; } // Display the absolute file path MessageBox(hWnd, filePath, L"File selected", MB_OK); // Release memory from the string CoTaskMemFree(filePath); return 0; } // If Windows wants to repaint the app case WM_PAINT: { PAINTSTRUCT ps; // Fill in the paint structure with info from the area to repaint HDC hDC = BeginPaint(hWnd, &ps); // Create a new solid brush for the background HBRUSH color{ CreateSolidBrush(RGB(120, 120, 120)) }; // Paint the window FillRect(hDC, &ps.rcPaint, color); // Stop painting EndPaint(hWnd, &ps); // Delete the brush to save memory DeleteObject(color); } return 0; default: // If we don't handle the message, use the default window process return DefWindowProcW(hWnd, uMsg, wParam, lParam); } }
LRESULT CWebWindow::_windowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { switch(message) { case WM_CREATE: { DragAcceptFiles(hwnd, TRUE); //SetTimer(hwnd, 100, 20, NULL); } return 0; case WM_CLOSE: if (m_windowClosingCallback) { if (!m_windowClosingCallback(this, m_windowClosingCallbackParam)) return 0; } ShowWindow(hwnd, SW_HIDE); DestroyWindow(hwnd); return 0; case WM_DESTROY: { //KillTimer(hwnd, 100); RemovePropW(hwnd, L"wkeWebWindow"); m_hwnd = NULL; if (m_windowDestroyCallback) m_windowDestroyCallback(this, m_windowDestroyCallbackParam); wkeDestroyWebView(this); } return 0; //case WM_TIMER: // { // wkeRepaintIfNeeded(this); // } // return 0; case WM_PAINT: { PAINTSTRUCT ps = { 0 }; HDC hdc = BeginPaint(hwnd, &ps); _paintDC(hdc, (HDC)wkeGetViewDC(this)); EndPaint(hwnd, &ps); } return 0; case WM_ERASEBKGND: return TRUE; case WM_SIZE: { RECT rc = { 0 }; GetClientRect(hwnd, &rc); int width = rc.right - rc.left; int height = rc.bottom - rc.top; CWebView::resize(width, height); wkeRepaintIfNeeded(this); } return 0; case WM_DROPFILES: { wchar_t szFile[MAX_PATH + 8] = {0}; wcscpy(szFile, L"file:///"); HDROP hDrop = reinterpret_cast<HDROP>(wParam); UINT uFilesCount = DragQueryFileW(hDrop, 0xFFFFFFFF, szFile, MAX_PATH); if (uFilesCount != 0) { UINT uRet = DragQueryFileW(hDrop, 0, (wchar_t*)szFile + 8, MAX_PATH); if ( uRet != 0) { wkeLoadURLW(this, szFile); SetWindowTextW(hwnd, szFile); } } DragFinish(hDrop); } return 0; //case WM_NCHITTEST: // if (IsWindow(m_hwnd) && flagsOff(GetWindowLong(m_hwnd, GWL_STYLE), WS_CAPTION)) // { // IWebkitObserverPtr observer = m_observer.lock(); // if (!observer) // break; // QPoint cursor(LOWORD(lParam), HIWORD(lParam)); // ScreenToClient(m_hwnd, &cursor); // QRect clientRect; // QSize clientSize; // GetClientRect(hwnd, &clientRect); // clientSize.cx = clientRect.width(); // clientSize.cy = clientRect.height(); // EWebkitHitTest hit = observer->onHitTest(QWebkitView(thisView), clientSize, cursor); // switch (hit) // { // case eWebkitHitLeftTop: return HTTOPLEFT; // case eWebkitHitLeft: return HTLEFT; // case eWebkitHitLeftBottom: return HTBOTTOMLEFT; // case eWebkitHitRightTop: return HTTOPRIGHT; // case eWebkitHitRight: return HTRIGHT; // case eWebkitHitRightBottom: return HTBOTTOMRIGHT; // case eWebkitHitTop: return HTTOP; // case eWebkitHitBottom: return HTBOTTOM; // case eWebkitHitCaption: return HTCAPTION; // case eWebkitHitClient: return HTCLIENT; // case eWebkitHitNone: return HTCLIENT; // } // } // break; //case WM_SETCURSOR: // if (IsWindow(m_hwnd) && flagsOff(GetWindowLong(m_hwnd, GWL_STYLE), WS_CAPTION)) // { // WORD hit = LOWORD(lParam); // switch (hit) // { // case HTCAPTION: // case HTSYSMENU: // case HTMENU: // case HTCLIENT: // SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW))); // return TRUE; // case HTTOP: // case HTBOTTOM: // SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_SIZENS))); // return TRUE; // case HTLEFT: // case HTRIGHT: // SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_SIZEWE))); // return TRUE; // case HTTOPLEFT: // case HTBOTTOMRIGHT: // SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_SIZENWSE))); // return TRUE; // case HTTOPRIGHT: // case HTBOTTOMLEFT: // SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_SIZENESW))); // return TRUE; // default: // SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW))); // return TRUE; // } // } // break; //case WM_NCLBUTTONDOWN: // if (IsWindow(m_hwnd) && flagsOff(GetWindowLong(m_hwnd, GWL_STYLE), WS_CAPTION)) // { // int hit = wParam; // switch (hit) // { // case HTTOP: SendMessageW(m_hwnd, WM_SYSCOMMAND, SC_SIZE|WMSZ_TOP, lParam); return 0; // case HTBOTTOM: SendMessageW(m_hwnd, WM_SYSCOMMAND, SC_SIZE|WMSZ_BOTTOM, lParam); return 0; // case HTLEFT: SendMessageW(m_hwnd, WM_SYSCOMMAND, SC_SIZE|WMSZ_LEFT, lParam); return 0; // case HTRIGHT: SendMessageW(m_hwnd, WM_SYSCOMMAND, SC_SIZE|WMSZ_RIGHT, lParam); return 0; // case HTTOPLEFT: SendMessageW(m_hwnd, WM_SYSCOMMAND, SC_SIZE|WMSZ_TOPLEFT, lParam); return 0; // case HTTOPRIGHT: SendMessageW(m_hwnd, WM_SYSCOMMAND, SC_SIZE|WMSZ_TOPRIGHT, lParam); return 0; // case HTBOTTOMLEFT: SendMessageW(m_hwnd, WM_SYSCOMMAND, SC_SIZE|WMSZ_BOTTOMLEFT, lParam); return 0; // case HTBOTTOMRIGHT: SendMessageW(m_hwnd, WM_SYSCOMMAND, SC_SIZE|WMSZ_BOTTOMRIGHT, lParam); return 0; // case HTCAPTION: SendMessageW(m_hwnd, WM_SYSCOMMAND, SC_MOVE|4, lParam); return 0; // } // } // break; //case WM_NCLBUTTONDBLCLK: // if (IsWindow(m_hwnd) && flagsOff(GetWindowLong(m_hwnd, GWL_STYLE), WS_CAPTION)) // { // int hit = wParam; // if (hit == HTCAPTION) // { // if (IsZoomed(m_hwnd)) // SendMessageW(m_hwnd, WM_SYSCOMMAND, SC_RESTORE, lParam); // else // SendMessageW(m_hwnd, WM_SYSCOMMAND, SC_MAXIMIZE, lParam); // return 0; // } // } // break; case WM_KEYDOWN: { unsigned int virtualKeyCode = wParam; unsigned int flags = 0; if (HIWORD(lParam) & KF_REPEAT) flags |= WKE_REPEAT; if (HIWORD(lParam) & KF_EXTENDED) flags |= WKE_EXTENDED; if (wkeFireKeyDownEvent(this, virtualKeyCode, flags, false)) return 0; } break; case WM_KEYUP: { unsigned int virtualKeyCode = wParam; unsigned int flags = 0; if (HIWORD(lParam) & KF_REPEAT) flags |= WKE_REPEAT; if (HIWORD(lParam) & KF_EXTENDED) flags |= WKE_EXTENDED; if (wkeFireKeyUpEvent(this, virtualKeyCode, flags, false)) return 0; } break; case WM_CHAR: { unsigned int charCode = wParam; unsigned int flags = 0; if (HIWORD(lParam) & KF_REPEAT) flags |= WKE_REPEAT; if (HIWORD(lParam) & KF_EXTENDED) flags |= WKE_EXTENDED; if (wkeFireKeyPressEvent(this, charCode, flags, false)) return 0; } break; case WM_LBUTTONDOWN: case WM_MBUTTONDOWN: case WM_RBUTTONDOWN: case WM_LBUTTONDBLCLK: case WM_MBUTTONDBLCLK: case WM_RBUTTONDBLCLK: case WM_LBUTTONUP: case WM_MBUTTONUP: case WM_RBUTTONUP: case WM_MOUSEMOVE: { if (message == WM_LBUTTONDOWN || message == WM_MBUTTONDOWN || message == WM_RBUTTONDOWN) { SetFocus(hwnd); SetCapture(hwnd); } else if (message == WM_LBUTTONUP || message == WM_MBUTTONUP || message == WM_RBUTTONUP) { ReleaseCapture(); } int x = LOWORD(lParam); int y = HIWORD(lParam); unsigned int flags = 0; if (wParam & MK_CONTROL) flags |= WKE_CONTROL; if (wParam & MK_SHIFT) flags |= WKE_SHIFT; if (wParam & MK_LBUTTON) flags |= WKE_LBUTTON; if (wParam & MK_MBUTTON) flags |= WKE_MBUTTON; if (wParam & MK_RBUTTON) flags |= WKE_RBUTTON; if (wkeFireMouseEvent(this, message, x, y, flags)) return 0; } break; case WM_CONTEXTMENU: { POINT pt; pt.x = LOWORD(lParam); pt.y = HIWORD(lParam); if (pt.x != -1 && pt.y != -1) ScreenToClient(hwnd, &pt); unsigned int flags = 0; if (wParam & MK_CONTROL) flags |= WKE_CONTROL; if (wParam & MK_SHIFT) flags |= WKE_SHIFT; if (wParam & MK_LBUTTON) flags |= WKE_LBUTTON; if (wParam & MK_MBUTTON) flags |= WKE_MBUTTON; if (wParam & MK_RBUTTON) flags |= WKE_RBUTTON; if (wkeFireContextMenuEvent(this, pt.x, pt.y, flags)) return 0; } break; case WM_MOUSEWHEEL: { POINT pt; pt.x = LOWORD(lParam); pt.y = HIWORD(lParam); ScreenToClient(hwnd, &pt); int delta = GET_WHEEL_DELTA_WPARAM(wParam); unsigned int flags = 0; if (wParam & MK_CONTROL) flags |= WKE_CONTROL; if (wParam & MK_SHIFT) flags |= WKE_SHIFT; if (wParam & MK_LBUTTON) flags |= WKE_LBUTTON; if (wParam & MK_MBUTTON) flags |= WKE_MBUTTON; if (wParam & MK_RBUTTON) flags |= WKE_RBUTTON; if (wkeFireMouseWheelEvent(this, pt.x, pt.y, delta, flags)) return 0; } break; case WM_SETFOCUS: wkeSetFocus(this); return 0; case WM_KILLFOCUS: wkeKillFocus(this); return 0; case WM_IME_STARTCOMPOSITION: { wkeRect caret = wkeGetCaretRect(this); CANDIDATEFORM form; form.dwIndex = 0; form.dwStyle = CFS_EXCLUDE; form.ptCurrentPos.x = caret.x; form.ptCurrentPos.y = caret.y + caret.h; form.rcArea.top = caret.y; form.rcArea.bottom = caret.y + caret.h; form.rcArea.left = caret.x; form.rcArea.right = caret.x + caret.w; COMPOSITIONFORM compForm; compForm.ptCurrentPos = form.ptCurrentPos; compForm.rcArea = form.rcArea; compForm.dwStyle = CFS_POINT; HIMC hIMC = ImmGetContext(hwnd); ImmSetCandidateWindow(hIMC, &form); ImmSetCompositionWindow(hIMC, &compForm); ImmReleaseContext(hwnd, hIMC); } return 0; } return DefWindowProcW(hwnd, message, wParam, lParam); }
static LRESULT CALLBACK tableWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { struct table *t; HDC dc; PAINTSTRUCT ps; NMHDR *nmhdr = (NMHDR *) lParam; NMHEADERW *nm = (NMHEADERW *) lParam; t = (struct table *) GetWindowLongPtrW(hwnd, GWLP_USERDATA); if (t == NULL) { // we have to do things this way because creating the header control will fail mysteriously if we create it first thing // (which is fine; we can get the parent hInstance this way too) if (uMsg == WM_NCCREATE) { CREATESTRUCTW *cs = (CREATESTRUCTW *) lParam; t = (struct table *) malloc(sizeof (struct table)); if (t == NULL) abort(); ZeroMemory(t, sizeof (struct table)); t->hwnd = hwnd; // TODO this should be a global t->defaultFont = (HFONT) GetStockObject(SYSTEM_FONT); if (t->defaultFont == NULL) abort(); t->font = t->defaultFont; t->selected = 5;t->count=100;//TODO t->header = CreateWindowExW(0, WC_HEADERW, L"", // TODO is HOTTRACK needed? WS_CHILD | HDS_FULLDRAG | HDS_HORZ | HDS_HOTTRACK, 0, 0, 0, 0, t->hwnd, (HMENU) 100, cs->hInstance, NULL); if (t->header == NULL) abort(); {t->imagelist = ImageList_Create(GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), ILC_COLOR32, 1, 1); if(t->imagelist==NULL)abort(); { HICON icon; int unused; icon = LoadIconW(NULL, IDI_ERROR); if(icon == NULL)abort(); if (ImageList_AddIcon(t->imagelist, icon) == -1)abort(); if (ImageList_GetIconSize(t->imagelist, &unused, &(t->imagelistHeight)) == 0)abort(); } } t->checkboxes = makeCheckboxImageList(t->hwnd, &(t->theme), &(t->checkboxWidth), &(t->checkboxHeight)); t->focusedColumn = -1; SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR) t); } // even if we did the above, fall through return DefWindowProcW(hwnd, uMsg, wParam, lParam); } switch (uMsg) { case WM_PAINT: dc = BeginPaint(hwnd, &ps); if (dc == NULL) abort(); drawItems(t, dc, ps.rcPaint); EndPaint(hwnd, &ps); return 0; case WM_SETFONT: t->font = (HFONT) wParam; if (t->font == NULL) t->font = t->defaultFont; // also set the header font SendMessageW(t->header, WM_SETFONT, wParam, lParam); if (LOWORD(lParam) != FALSE) { // the scrollbar page size will change so redraw that too // also recalculate the header height // TODO do that when this is FALSE too somehow resize(t); redrawAll(t); } return 0; case WM_GETFONT: return (LRESULT) t->font; case WM_VSCROLL: vscroll(t, wParam); return 0; case WM_MOUSEWHEEL: wheelscroll(t, wParam); return 0; case WM_HSCROLL: hscroll(t, wParam); return 0; case WM_SIZE: resize(t); return 0; case WM_LBUTTONDOWN: selectItem(t, wParam, lParam); return 0; case WM_SETFOCUS: case WM_KILLFOCUS: // all we need to do here is redraw the highlight // TODO ensure giving focus works right redrawRow(t, t->selected); return 0; case WM_KEYDOWN: keySelect(t, wParam, lParam); return 0; // TODO header double-click case WM_NOTIFY: if (nmhdr->hwndFrom == t->header) switch (nmhdr->code) { // I could use HDN_TRACK but wine doesn't emit that case HDN_ITEMCHANGING: case HDN_ITEMCHANGED: // TODO needed? recomputeHScroll(t); redrawAll(t); return FALSE; } return DefWindowProcW(hwnd, uMsg, wParam, lParam); // TODO others? case WM_WININICHANGE: case WM_SYSCOLORCHANGE: case WM_THEMECHANGED: if (ImageList_Destroy(t->checkboxes) == 0) abort(); t->checkboxes = makeCheckboxImageList(t->hwnd, &(t->theme), &(t->checkboxWidth), &(t->checkboxHeight)); resize(t); // TODO needed? redrawAll(t); // now defer back to DefWindowProc() in case other things are needed // TODO needed? return DefWindowProcW(hwnd, uMsg, wParam, lParam); case tableAddColumn: addColumn(t, wParam, lParam); return 0; case WM_GETOBJECT: // accessibility /* if (((DWORD) lParam) == OBJID_CLIENT) { TODO *server; LRESULT lResult; // TODO create the server object lResult = LresultFromObject(IID_IAccessible, wParam, server); if (/* TODO failure *|/) abort(); // TODO release object return lResult; } */ return DefWindowProcW(hwnd, uMsg, wParam, lParam); default: return DefWindowProcW(hwnd, uMsg, wParam, lParam); } abort(); return 0; // unreached }
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) && mp_input_use_alt_gr(vo->input_ctx)) 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 LRESULT CALLBACK mainWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { switch(msg) { case WM_CREATE: { trackViewWin = trackView->create(hInst, hwnd); InitCommonControls(); statusBarWin = createStatusBar(hInst, hwnd); if (ERROR_SUCCESS != RegOpenKey(HKEY_CURRENT_USER, keyName, ®ConfigKey)) { if (ERROR_SUCCESS != RegCreateKey(HKEY_CURRENT_USER, keyName, ®ConfigKey)) die("failed to create registry key"); } /* Recent Files menu */ mruFileList = RecentFiles(findSubMenuContaining(GetMenu(hwnd), ID_RECENTFILES_NORECENTFILES)); mruFileList.load(regConfigKey); } break; case WM_CLOSE: attemptQuit(); break; case WM_DESTROY: mruFileList.save(regConfigKey); RegCloseKey(regConfigKey); regConfigKey = NULL; PostQuitMessage(0); break; case WM_SIZE: { int width = LOWORD(lParam); int height = HIWORD(lParam); RECT statusBarRect; GetClientRect(statusBarWin, &statusBarRect); int statusBarHeight = statusBarRect.bottom - statusBarRect.top; MoveWindow(trackViewWin, 0, 0, width, height - statusBarHeight, TRUE); MoveWindow(statusBarWin, 0, height - statusBarHeight, width, statusBarHeight, TRUE); } break; case WM_SETFOCUS: SetFocus(trackViewWin); // needed to forward keyboard input break; case WM_SETROWS: trackView->setRows(int(lParam)); break; case WM_BIASSELECTION: trackView->editBiasValue(float(lParam)); break; case WM_COMMAND: switch (LOWORD(wParam)) { case ID_FILE_NEW: fileNew(); InvalidateRect(trackViewWin, NULL, FALSE); break; case ID_FILE_OPEN: fileOpen(); break; case ID_FILE_SAVE_AS: fileSaveAs(); break; case ID_FILE_SAVE: fileSave(); break; case ID_EDIT_SELECTALL: trackView->selectAll(); break; case ID_EDIT_SELECTTRACK: trackView->selectTrack(trackView->getEditTrack()); break; case ID_EDIT_SELECTROW: trackView->selectRow(trackView->getEditRow()); break; case ID_FILE_REMOTEEXPORT: document.sendSaveCommand(); break; case ID_RECENTFILES_FILE1: case ID_RECENTFILES_FILE2: case ID_RECENTFILES_FILE3: case ID_RECENTFILES_FILE4: case ID_RECENTFILES_FILE5: { int index = LOWORD(wParam) - ID_RECENTFILES_FILE1; std::wstring fileName; if (mruFileList.getEntry(index, fileName)) { loadDocument(fileName); } } break; case ID_FILE_EXIT: attemptQuit(); break; case ID_EDIT_UNDO: SendMessage(trackViewWin, WM_UNDO, 0, 0); break; case ID_EDIT_REDO: SendMessage(trackViewWin, WM_REDO, 0, 0); break; case ID_EDIT_COPY: SendMessage(trackViewWin, WM_COPY, 0, 0); break; case ID_EDIT_CUT: SendMessage(trackViewWin, WM_CUT, 0, 0); break; case ID_EDIT_PASTE: SendMessage(trackViewWin, WM_PASTE, 0, 0); break; case ID_EDIT_SETROWS: { int rows = int(trackView->getRows()); INT_PTR result = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SETROWS), hwnd, (DLGPROC)setRowsDialogProc, (LPARAM)&rows); if (FAILED(result)) error("unable to create dialog box"); } break; case ID_EDIT_BIAS: { int initialBias = 0; INT_PTR result = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_BIASSELECTION), hwnd, (DLGPROC)biasSelectionDialogProc, (LPARAM)&initialBias); if (FAILED(result)) error("unable to create dialog box"); } break; } break; case WM_ROWCHANGED: { char temp[256]; snprintf(temp, 256, "%d", lParam ); SendMessage(statusBarWin, SB_SETTEXT, 1, (LPARAM)temp); } break; case WM_TRACKCHANGED: { char temp[256]; snprintf(temp, 256, "%d", lParam); SendMessage(statusBarWin, SB_SETTEXT, 2, (LPARAM)temp); } break; case WM_CURRVALDIRTY: { char temp[256]; if (document.num_tracks > 0) { const sync_track *t = document.tracks[document.getTrackIndexFromPos(trackView->getEditTrack())]; int row = trackView->getEditRow(); int idx = key_idx_floor(t, row); snprintf(temp, 256, "%f", sync_get_val(t, row)); const char *str = "---"; if (idx >= 0) { switch (t->keys[idx].type) { case KEY_STEP: str = "step"; break; case KEY_LINEAR: str = "linear"; break; case KEY_SMOOTH: str = "smooth"; break; case KEY_RAMP: str = "ramp"; break; } } SendMessage(statusBarWin, SB_SETTEXT, 4, (LPARAM)str); } else snprintf(temp, 256, "---"); SendMessage(statusBarWin, SB_SETTEXT, 3, (LPARAM)temp); } break; default: return DefWindowProcW(hwnd, msg, wParam, lParam); } return 0; }
LRESULT CALLBACK WndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch (uMsg) { case WM_ACTIVATE: { Active=(!HIWORD(wParam)); return 0; } case WM_SYSCOMMAND: { switch (wParam) { case SC_SCREENSAVE: case SC_MONITORPOWER: return 0; } break; } case WM_CLOSE: { Done = true; return 0; } case WM_KEYDOWN: { Keys[wParam] = true; return 0; } case WM_KEYUP: { Keys[wParam] = false; if (wParam==VK_SNAPSHOT) { ScreenSave(); return DefWindowProcW(hWnd,uMsg,wParam,lParam); } return 0; } #ifdef MINIMALTWEAKER case WM_MOUSEMOVE: { POINT ap; GetCursorPos(&ap); ScreenToClient(hWnd,&ap); mx=ap.x; my=ap.y; return 0; } case WM_LBUTTONDOWN: { LeftButton=true; POINT ap; GetCursorPos(&ap); LeftShift=(wParam & MK_SHIFT)==0; LeftCtrl=(wParam & MK_CONTROL)==0; ScreenToClient(hWnd,&ap); lx=ap.x; ly=ap.y; return 0; } case WM_LBUTTONUP: { LeftButton=false; LeftButtonReleased=true; return 0; } case WM_RBUTTONDOWN: { RightButton=true; POINT ap; GetCursorPos(&ap); RightShift=(wParam & MK_SHIFT)==0; RightCtrl=(wParam & MK_CONTROL)==0; ScreenToClient(hWnd,&ap); rx=ap.x; ry=ap.y; return 0; } case WM_RBUTTONUP: { RightButton=false; RightButtonReleased=true; return 0; } case WM_MBUTTONDOWN: { MiddleButton=true; POINT ap; GetCursorPos(&ap); MidShift=(wParam & MK_SHIFT)==0; MidCtrl=(wParam & MK_CONTROL)==0; ScreenToClient(hWnd,&ap); mbx=ap.x; mby=ap.y; //DemoPlayback=false; return 0; } case WM_MBUTTONUP: { MiddleButton=false; MiddleButtonReleased=true; return 0; } #endif } return DefWindowProc(hWnd,uMsg,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; 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_msg(MSGT_VO, MSGL_V, "[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_msg(MSGT_VO, MSGL_V, "[vo] resize window: %d:%d\n", vo->dwidth, vo->dheight); break; } case WM_SIZING: if (vo->opts->keepaspect && !vo->opts->fs && 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 = vo->aspdat.asp; 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: mplayer_put_key(vo->key_fifo, MP_KEY_CLOSE_WIN); break; case WM_SYSCOMMAND: switch (wParam) { case SC_SCREENSAVE: case SC_MONITORPOWER: mp_msg(MSGT_VO, MSGL_V, "vo: win32: killing screensaver\n"); return 0; } break; case WM_KEYDOWN: case WM_SYSKEYDOWN: { int mpkey = lookup_keymap_table(vk_map, wParam); if (mpkey) mplayer_put_key(vo->key_fifo, 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)) { mplayer_put_key(vo->key_fifo, code | mods); // At least with Alt+char, not calling DefWindowProcW stops // Windows from emitting a beep. return 0; } break; } case WM_LBUTTONDOWN: if (!vo->opts->nomouse_input && (vo->opts->fs || (wParam & MK_CONTROL))) { mplayer_put_key(vo->key_fifo, MP_MOUSE_BTN0 | mod_state(vo)); break; } if (!vo->opts->fs) { ReleaseCapture(); SendMessage(hWnd, WM_NCLBUTTONDOWN, HTCAPTION, 0); return 0; } break; case WM_MBUTTONDOWN: if (!vo->opts->nomouse_input) mplayer_put_key(vo->key_fifo, MP_MOUSE_BTN1 | mod_state(vo)); break; case WM_RBUTTONDOWN: if (!vo->opts->nomouse_input) mplayer_put_key(vo->key_fifo, MP_MOUSE_BTN2 | mod_state(vo)); break; case WM_MOUSEMOVE: vo_mouse_movement(vo, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)); break; case WM_MOUSEWHEEL: if (!vo->opts->nomouse_input) { int x = GET_WHEEL_DELTA_WPARAM(wParam); if (x > 0) mplayer_put_key(vo->key_fifo, MP_MOUSE_BTN3 | mod_state(vo)); else mplayer_put_key(vo->key_fifo, MP_MOUSE_BTN4 | mod_state(vo)); } break; case WM_XBUTTONDOWN: if (!vo->opts->nomouse_input) { int x = HIWORD(wParam); if (x == 1) mplayer_put_key(vo->key_fifo, MP_MOUSE_BTN5 | mod_state(vo)); else // if (x == 2) mplayer_put_key(vo->key_fifo, MP_MOUSE_BTN6 | mod_state(vo)); } break; } return DefWindowProcW(hWnd, message, wParam, lParam); }
LRESULT VDDualDefWindowProcW32(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { return IsWindowUnicode(hwnd) ? DefWindowProcW(hwnd, msg, wParam, lParam) : DefWindowProcA(hwnd, msg, wParam, lParam); }
static LRESULT WINAPI IPADDRESS_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { IPADDRESS_INFO *infoPtr = (IPADDRESS_INFO *)GetWindowLongPtrW (hwnd, 0); TRACE("(hwnd=%p msg=0x%x wparam=0x%x lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam); if (!infoPtr && (uMsg != WM_CREATE)) return DefWindowProcW (hwnd, uMsg, wParam, lParam); switch (uMsg) { case WM_CREATE: return IPADDRESS_Create (hwnd, (LPCREATESTRUCTA)lParam); case WM_DESTROY: return IPADDRESS_Destroy (infoPtr); case WM_ENABLE: return IPADDRESS_Enable (infoPtr, (BOOL)wParam); break; case WM_PAINT: return IPADDRESS_Paint (infoPtr, (HDC)wParam); case WM_COMMAND: switch(wParam >> 16) { case EN_CHANGE: IPADDRESS_Notify(infoPtr, EN_CHANGE); break; case EN_KILLFOCUS: IPADDRESS_ConstrainField(infoPtr, IPADDRESS_GetPartIndex(infoPtr, (HWND)lParam)); break; } break; case IPM_CLEARADDRESS: IPADDRESS_ClearAddress (infoPtr); break; case IPM_SETADDRESS: return IPADDRESS_SetAddress (infoPtr, (DWORD)lParam); case IPM_GETADDRESS: return IPADDRESS_GetAddress (infoPtr, (LPDWORD)lParam); case IPM_SETRANGE: return IPADDRESS_SetRange (infoPtr, (int)wParam, (WORD)lParam); case IPM_SETFOCUS: IPADDRESS_SetFocusToField (infoPtr, (int)wParam); break; case IPM_ISBLANK: return IPADDRESS_IsBlank (infoPtr); default: if ((uMsg >= WM_USER) && (uMsg < WM_APP)) ERR("unknown msg %04x wp=%08x lp=%08lx\n", uMsg, wParam, lParam); return DefWindowProcW (hwnd, uMsg, wParam, lParam); } return 0; }
/* window procedure for the desktop window */ static LRESULT WINAPI desktop_wnd_proc( HWND hwnd, UINT message, WPARAM wp, LPARAM lp ) { WINE_TRACE( "got msg %04x wp %lx lp %lx\n", message, wp, lp ); switch(message) { case WM_SYSCOMMAND: switch(wp & 0xfff0) { case SC_CLOSE: ExitWindows( 0, 0 ); break; case SC_SCREENSAVE: return start_screensaver(); } return 0; case WM_CLOSE: PostQuitMessage(0); return 0; case WM_SETCURSOR: return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_ARROW ) ); case WM_NCHITTEST: return HTCLIENT; case WM_ERASEBKGND: if (!using_root) PaintDesktop( (HDC)wp ); return TRUE; case WM_SETTINGCHANGE: if (wp == SPI_SETDESKWALLPAPER) SystemParametersInfoW( SPI_SETDESKWALLPAPER, 0, NULL, FALSE ); return 0; case WM_LBUTTONDBLCLK: if (!using_root) { const struct launcher *launcher = launcher_from_point( (short)LOWORD(lp), (short)HIWORD(lp) ); if (launcher) do_launch( launcher ); } return 0; case WM_PAINT: { PAINTSTRUCT ps; BeginPaint( hwnd, &ps ); if (!using_root) { if (ps.fErase) PaintDesktop( ps.hdc ); draw_launchers( ps.hdc, ps.rcPaint ); } EndPaint( hwnd, &ps ); } return 0; default: return DefWindowProcW( hwnd, message, wp, lp ); } }
/** * Helper: Subclassed Windows WNDPROC */ static LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { if (::GetPropW(hwnd, kWatch) > (HANDLE)0x0) { // Watcher stuff switch (uMsg) { case WM_WINDOWPOSCHANGING: { /* XXX Fix this bit to something more reasonable The following code kinda replicates the way mozilla gets the window state. We intensionally "hide" the SW_SHOWMINIMIZED here. This indeed might cause some side effects, but if it didn't we couldn't open menus due to bugzilla #435848. This might defeat said bugfix completely reverting to old behavior, but only when we're active, of course. */ WINDOWPOS *wp = reinterpret_cast<WINDOWPOS*>(lParam); if (wp == 0) { goto WndProcEnd; } if (wp->flags & SWP_FRAMECHANGED && ::IsWindowVisible(hwnd)) { WINDOWPLACEMENT pl; pl.length = sizeof(WINDOWPLACEMENT); ::GetWindowPlacement(hwnd, &pl); if (pl.showCmd == SW_SHOWMINIMIZED) { return 0; } } break; } case WM_WINDOWPOSCHANGED: { /* XXX Fix this bit to something more reasonable The following code kinda replicates the way mozilla gets the window state. We intensionally "hide" the SW_SHOWMINIMIZED here. This indeed might cause some side effects, but if it didn't we couldn't open menus due to bugzilla #435848,. This might defeat said bugfix completely reverting to old behavior, but only when we're active, of course. */ WINDOWPOS *wp = reinterpret_cast<WINDOWPOS*>(lParam); if (wp == 0) { goto WndProcEnd; } if (wp->flags & SWP_SHOWWINDOW) { // Shown again, unexpectedly that is, so release PostMessage(hwnd, WM_TRAYCALLBACK, 0, 1); } else if (wp->flags & SWP_FRAMECHANGED && ::IsWindowVisible(hwnd)) { WINDOWPLACEMENT pl; pl.length = sizeof(WINDOWPLACEMENT); ::GetWindowPlacement(hwnd, &pl); if (pl.showCmd == SW_SHOWMINIMIZED && (gWatchMode & kTrayOnMinimize)) { PostMessage(hwnd, WM_TRAYCALLBACK, 0, 0); // We're active, ignore return 0; } } break; } // case WM_WINDOWPOSCHANGED case WM_NCLBUTTONDOWN: case WM_NCLBUTTONUP: // Frame button clicked if (wParam == HTCLOSE && (gWatchMode & kTrayOnClose)) { PostMessage(hwnd, WM_TRAYCALLBACK, 0, 0); return TRUE; } break; case WM_SYSCOMMAND: // Window menu if (wParam == SC_CLOSE && (gWatchMode & kTrayOnClose)) { PostMessage(hwnd, WM_TRAYCALLBACK, 0, 0); return 0; } break; } } if (::GetPropW(hwnd, kIcon) == (HANDLE)0x1) { // Icon stuff // This is a badly documented custom broadcast message by explorer if (uMsg == WM_TASKBARCREATED) { // Try to get the platform icon NOTIFYICONDATAW *iconData = reinterpret_cast<NOTIFYICONDATAW*>(GetPropW(hwnd, kIconData)); if (iconData == 0) { goto WndProcEnd; } // The taskbar was (re)created. Add ourselves again. Shell_NotifyIconW(NIM_ADD, iconData); } // We got clicked. How exciting, isn't it. else if (uMsg == WM_TRAYMESSAGE) { mouseevent_t *event = new(std::nothrow) mouseevent_t; if (!event) { goto WndProcEnd; } event->clickCount = 0; switch (LOWORD(lParam)) { case WM_LBUTTONUP: case WM_MBUTTONUP: case WM_RBUTTONUP: case WM_CONTEXTMENU: case NIN_KEYSELECT: event->clickCount = 1; break; case WM_LBUTTONDBLCLK: case WM_MBUTTONDBLCLK: case WM_RBUTTONDBLCLK: event->clickCount = 2; break; } switch (LOWORD(lParam)) { case WM_LBUTTONUP: case WM_LBUTTONDBLCLK: event->button = 0; break; case WM_MBUTTONUP: case WM_MBUTTONDBLCLK: event->button = 1; break; case WM_RBUTTONUP: case WM_RBUTTONDBLCLK: case WM_CONTEXTMENU: case NIN_KEYSELECT: event->button = 2; break; } if (event->clickCount) { POINT wpt; if (GetCursorPos(&wpt) == TRUE) { event->x = wpt.x; event->y = wpt.y; event->keys = 0; if (::GetKeyState(VK_CONTROL) & 0x8000) { event->keys += (1<<0); } if (::GetKeyState(VK_MENU) & 0x8000) { event->keys += (1<<1); } if (::GetKeyState(VK_SHIFT) & 0x8000) { event->keys += (1<<2); } PostMessage(hwnd, WM_TRAYCALLBACK, 1, (LPARAM)event); } else { delete event; } } return 0; } // Window title changed else if (uMsg == WM_SETTEXT) { NOTIFYICONDATAW *iconData = reinterpret_cast<NOTIFYICONDATAW*>(GetPropW(hwnd, kIconData)); if (iconData == 0) { goto WndProcEnd; } // First, let the original wndproc process this message, // so that we may query the thing afterwards ;) // this is required because we cannot know the encoding of this message for sure ;) LRESULT rv; WNDPROC oldWindowProc = reinterpret_cast<WNDPROC>(::GetPropW(hwnd, kOldProc)); if (oldWindowProc != 0) { rv = CallWindowProcW(oldWindowProc, hwnd, uMsg, wParam, lParam); } else { rv = DefWindowProcW(hwnd, uMsg, wParam, lParam); } if (::GetWindowTextW(hwnd, iconData->szTip, 127) != 0) { iconData->szTip[128] = '\0'; Shell_NotifyIconW(NIM_MODIFY, iconData); } return rv; } } // Need to handle this in or own message or crash! // See https://bugzilla.mozilla.org/show_bug.cgi?id=671266 if (uMsg == WM_TRAYCALLBACK) { if (wParam == 0) { minimize_callback_t callback = reinterpret_cast<minimize_callback_t>(::GetPropW(hwnd, kWatchMinimizeProc)); if (callback) { callback(hwnd, (int)lParam); } } else if (wParam == 1) { mouseevent_t *event = reinterpret_cast<mouseevent_t*>(lParam); mouseevent_callback_t callback = reinterpret_cast<mouseevent_callback_t>(::GetPropW(hwnd, kIconMouseEventProc)); if (event && callback) { // SFW/PM is a win32 hack, so that the context menu is hidden when loosing focus. ::SetForegroundWindow(hwnd); callback(hwnd, event); ::PostMessage(hwnd, WM_NULL, 0, 0L); } delete event; } return 0; } WndProcEnd: // Call the old WNDPROC or at lest DefWindowProc WNDPROC oldProc = reinterpret_cast<WNDPROC>(::GetPropW(hwnd, kOldProc)); if (oldProc != 0) { return ::CallWindowProcW(oldProc, hwnd, uMsg, wParam, lParam); } return ::DefWindowProcW(hwnd, uMsg, wParam, lParam); }
// Window callback function (handles window messages) // static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { _GLFWwindow* window = (_GLFWwindow*) GetWindowLongPtrW(hWnd, 0); if (!window) { switch (uMsg) { case WM_NCCREATE: { CREATESTRUCTW* cs = (CREATESTRUCTW*) lParam; SetWindowLongPtrW(hWnd, 0, (LONG_PTR) cs->lpCreateParams); break; } case WM_DEVICECHANGE: { if (wParam == DBT_DEVNODES_CHANGED) { _glfwInputMonitorChange(); return TRUE; } break; } } return DefWindowProcW(hWnd, uMsg, wParam, lParam); } switch (uMsg) { case WM_SETFOCUS: { if (window->cursorMode == GLFW_CURSOR_DISABLED) _glfwPlatformSetCursorMode(window, GLFW_CURSOR_DISABLED); _glfwInputWindowFocus(window, GLFW_TRUE); return 0; } case WM_KILLFOCUS: { if (window->cursorMode == GLFW_CURSOR_DISABLED) _glfwPlatformSetCursorMode(window, GLFW_CURSOR_NORMAL); if (window->monitor && window->autoIconify) _glfwPlatformIconifyWindow(window); _glfwInputWindowFocus(window, GLFW_FALSE); return 0; } case WM_SYSCOMMAND: { switch (wParam & 0xfff0) { case SC_SCREENSAVE: case SC_MONITORPOWER: { if (window->monitor) { // We are running in full screen mode, so disallow // screen saver and screen blanking return 0; } else break; } // User trying to access application menu using ALT? case SC_KEYMENU: return 0; } break; } case WM_CLOSE: { _glfwInputWindowCloseRequest(window); return 0; } case WM_CHAR: case WM_SYSCHAR: case WM_UNICHAR: { const GLFWbool plain = (uMsg != WM_SYSCHAR); if (uMsg == WM_UNICHAR && wParam == UNICODE_NOCHAR) { // WM_UNICHAR is not sent by Windows, but is sent by some // third-party input method engine // Returning TRUE here announces support for this message return TRUE; } _glfwInputChar(window, (unsigned int) wParam, getKeyMods(), plain); return 0; } case WM_KEYDOWN: case WM_SYSKEYDOWN: case WM_KEYUP: case WM_SYSKEYUP: { const int key = translateKey(wParam, lParam); const int scancode = (lParam >> 16) & 0x1ff; const int action = ((lParam >> 31) & 1) ? GLFW_RELEASE : GLFW_PRESS; const int mods = getKeyMods(); if (key == _GLFW_KEY_INVALID) break; if (action == GLFW_RELEASE && wParam == VK_SHIFT) { // Release both Shift keys on Shift up event, as only one event // is sent even if both keys are released _glfwInputKey(window, GLFW_KEY_LEFT_SHIFT, scancode, action, mods); _glfwInputKey(window, GLFW_KEY_RIGHT_SHIFT, scancode, action, mods); } else if (wParam == VK_SNAPSHOT) { // Key down is not reported for the Print Screen key _glfwInputKey(window, key, scancode, GLFW_PRESS, mods); _glfwInputKey(window, key, scancode, GLFW_RELEASE, mods); } else _glfwInputKey(window, key, scancode, action, mods); break; } case WM_LBUTTONDOWN: case WM_RBUTTONDOWN: case WM_MBUTTONDOWN: case WM_XBUTTONDOWN: case WM_LBUTTONUP: case WM_RBUTTONUP: case WM_MBUTTONUP: case WM_XBUTTONUP: { int button, action; if (uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONUP) button = GLFW_MOUSE_BUTTON_LEFT; else if (uMsg == WM_RBUTTONDOWN || uMsg == WM_RBUTTONUP) button = GLFW_MOUSE_BUTTON_RIGHT; else if (uMsg == WM_MBUTTONDOWN || uMsg == WM_MBUTTONUP) button = GLFW_MOUSE_BUTTON_MIDDLE; else if (GET_XBUTTON_WPARAM(wParam) == XBUTTON1) button = GLFW_MOUSE_BUTTON_4; else button = GLFW_MOUSE_BUTTON_5; if (uMsg == WM_LBUTTONDOWN || uMsg == WM_RBUTTONDOWN || uMsg == WM_MBUTTONDOWN || uMsg == WM_XBUTTONDOWN) { action = GLFW_PRESS; SetCapture(hWnd); } else { action = GLFW_RELEASE; ReleaseCapture(); } _glfwInputMouseClick(window, button, action, getKeyMods()); if (uMsg == WM_XBUTTONDOWN || uMsg == WM_XBUTTONUP) return TRUE; return 0; } case WM_MOUSEMOVE: { const int x = GET_X_LPARAM(lParam); const int y = GET_Y_LPARAM(lParam); if (window->cursorMode == GLFW_CURSOR_DISABLED) { if (_glfw.cursorWindow != window) break; _glfwInputCursorMotion(window, x - window->win32.cursorPosX, y - window->win32.cursorPosY); } else _glfwInputCursorMotion(window, x, y); window->win32.cursorPosX = x; window->win32.cursorPosY = y; if (!window->win32.cursorTracked) { TRACKMOUSEEVENT tme; ZeroMemory(&tme, sizeof(tme)); tme.cbSize = sizeof(tme); tme.dwFlags = TME_LEAVE; tme.hwndTrack = window->win32.handle; TrackMouseEvent(&tme); window->win32.cursorTracked = GLFW_TRUE; _glfwInputCursorEnter(window, GLFW_TRUE); } return 0; } case WM_MOUSELEAVE: { window->win32.cursorTracked = GLFW_FALSE; _glfwInputCursorEnter(window, GLFW_FALSE); return 0; } case WM_MOUSEWHEEL: { _glfwInputScroll(window, 0.0, (SHORT) HIWORD(wParam) / (double) WHEEL_DELTA); return 0; } case WM_MOUSEHWHEEL: { // This message is only sent on Windows Vista and later // NOTE: The X-axis is inverted for consistency with OS X and X11. _glfwInputScroll(window, -((SHORT) HIWORD(wParam) / (double) WHEEL_DELTA), 0.0); return 0; } case WM_SIZE: { if (_glfw.cursorWindow == window) { if (window->cursorMode == GLFW_CURSOR_DISABLED) updateClipRect(window); } if (!window->win32.iconified && wParam == SIZE_MINIMIZED) { window->win32.iconified = GLFW_TRUE; if (window->monitor) leaveFullscreenMode(window); _glfwInputWindowIconify(window, GLFW_TRUE); } else if (window->win32.iconified && (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED)) { window->win32.iconified = GLFW_FALSE; if (window->monitor) enterFullscreenMode(window); _glfwInputWindowIconify(window, GLFW_FALSE); } _glfwInputFramebufferSize(window, LOWORD(lParam), HIWORD(lParam)); _glfwInputWindowSize(window, LOWORD(lParam), HIWORD(lParam)); return 0; } case WM_MOVE: { if (_glfw.cursorWindow == window) { if (window->cursorMode == GLFW_CURSOR_DISABLED) updateClipRect(window); } // NOTE: This cannot use LOWORD/HIWORD recommended by MSDN, as // those macros do not handle negative window positions correctly _glfwInputWindowPos(window, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)); return 0; } case WM_SIZING: { if (window->win32.numer == GLFW_DONT_CARE || window->win32.denom == GLFW_DONT_CARE) { break; } applyAspectRatio(window, (int) wParam, (RECT*) lParam); return TRUE; } case WM_GETMINMAXINFO: { int xoff, yoff; MINMAXINFO* mmi = (MINMAXINFO*) lParam; getFullWindowSize(getWindowStyle(window), getWindowExStyle(window), 0, 0, &xoff, &yoff); if (window->win32.minwidth != GLFW_DONT_CARE && window->win32.minheight != GLFW_DONT_CARE) { mmi->ptMinTrackSize.x = window->win32.minwidth + xoff; mmi->ptMinTrackSize.y = window->win32.minheight + yoff; } if (window->win32.maxwidth != GLFW_DONT_CARE && window->win32.maxheight != GLFW_DONT_CARE) { mmi->ptMaxTrackSize.x = window->win32.maxwidth + xoff; mmi->ptMaxTrackSize.y = window->win32.maxheight + yoff; } return 0; } case WM_PAINT: { _glfwInputWindowDamage(window); break; } case WM_ERASEBKGND: { return TRUE; } case WM_SETCURSOR: { if (_glfw.cursorWindow == window && LOWORD(lParam) == HTCLIENT) { if (window->cursorMode == GLFW_CURSOR_HIDDEN || window->cursorMode == GLFW_CURSOR_DISABLED) { SetCursor(NULL); return TRUE; } else if (window->cursor) { SetCursor(window->cursor->win32.handle); return TRUE; } } break; } case WM_DPICHANGED: { RECT* rect = (RECT*) lParam; SetWindowPos(window->win32.handle, HWND_TOP, rect->left, rect->top, rect->right - rect->left, rect->bottom - rect->top, SWP_NOACTIVATE | SWP_NOZORDER); break; } case WM_DROPFILES: { HDROP drop = (HDROP) wParam; POINT pt; int i; const int count = DragQueryFileW(drop, 0xffffffff, NULL, 0); char** paths = calloc(count, sizeof(char*)); // Move the mouse to the position of the drop DragQueryPoint(drop, &pt); _glfwInputCursorMotion(window, pt.x, pt.y); for (i = 0; i < count; i++) { const UINT length = DragQueryFileW(drop, i, NULL, 0); WCHAR* buffer = calloc(length + 1, sizeof(WCHAR)); DragQueryFileW(drop, i, buffer, length + 1); paths[i] = _glfwCreateUTF8FromWideStringWin32(buffer); free(buffer); } _glfwInputDrop(window, count, (const char**) paths); for (i = 0; i < count; i++) free(paths[i]); free(paths); DragFinish(drop); return 0; } } return DefWindowProcW(hWnd, uMsg, wParam, lParam); }
// // FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM) // // PURPOSE: Processes messages for the main window. // // WM_PAINT - Paint the main window // WM_DESTROY - post a quit message and return // // LRESULT CALLBACK UGameWindow::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { switch (message) { case WM_PAINT: { PAINTSTRUCT ps; BeginPaint(hWnd, &ps); EndPaint(hWnd, &ps); break; } case WM_DESTROY: { PostQuitMessage(0); break; } case WM_CHAR: { // For textual input (i.e. a text box) const TCHAR character = static_cast<TCHAR>(wParam); const bool bRepeat = (lParam & (1 << 30)) != 0; // Send character to input text system UGameInput::Get().OnChar(character, bRepeat); break; } case WM_KEYDOWN: { // For key events (i.e. game input) const UINT key = static_cast<UINT>(wParam); const UINT CharCode = MapVirtualKeyW(key, MAPVK_VK_TO_CHAR); const bool bRepeat = (lParam & (1 << 30)) != 0; // Send character to input event system UGameInput::Get().OnKeyDown(key, CharCode, bRepeat); // TEMP: ESC quits the game if (key == VK_ESCAPE) { PostQuitMessage(0); } break; } case WM_KEYUP: { // For key events (i.e. game input) const UINT key = static_cast<UINT>(wParam); const UINT CharCode = MapVirtualKeyW(key, MAPVK_VK_TO_CHAR); const bool bRepeat = (lParam & (1 << 30)) != 0; // Send character to input event system UGameInput::Get().OnKeyUp(key, CharCode, bRepeat); break; } case WM_MOUSEWHEEL: { const short wheelRotation = GET_WHEEL_DELTA_WPARAM(wParam); const int numClicks = wheelRotation / WHEEL_DELTA; // Send numClicks to input mouse system break; } case WM_LBUTTONDOWN: { return 0; break; } case WM_MBUTTONDOWN: { return 0; break; } case WM_RBUTTONDOWN: { return 0; break; } case WM_LBUTTONUP: { return 0; break; } case WM_MBUTTONUP: { return 0; break; } case WM_RBUTTONUP: { return 0; break; } case WM_SIZE: { //NOTE: You NEVER want to put a breakpoint here or you'll have to restart your computer. if (gEngine) { gEngine->GetRenderer()->OnScreenSizeChanged(); } break; } case WM_ACTIVATE: { auto activeStatus = LOWORD(wParam); if (activeStatus == WA_ACTIVE || activeStatus == WA_CLICKACTIVE) { UGameInput::Get().OnFocusChanged(true); } else if (activeStatus == WA_INACTIVE) { UGameInput::Get().OnFocusChanged(false); } break; } default: return DefWindowProcW(hWnd, message, wParam, lParam); } return 0; }
// Window event handler - Use as less as possible LRESULT CALLBACK WinProc(HWND _hwnd, UINT _id, WPARAM wParam, LPARAM lParam) { WindowsDesc* gCurrentWindow = NULL; tinystl::unordered_hash_node<void*, WindowsDesc*>* pNode = gHWNDMap.find(_hwnd).node; if (pNode) gCurrentWindow = pNode->second; else return DefWindowProcW(_hwnd, _id, wParam, lParam); switch (_id) { case WM_ACTIVATE: if (LOWORD(wParam) == WA_INACTIVE) { captureMouse(_hwnd, false); } break; case WM_DISPLAYCHANGE: { if (gCurrentWindow) { if (gCurrentWindow->fullScreen) { adjustWindow(gCurrentWindow); } else { adjustWindow(gCurrentWindow); } } break; } case WM_SIZE: if (gCurrentWindow) { RectDesc rect = { 0 }; if (gCurrentWindow->fullScreen) { gCurrentWindow->fullscreenRect = { 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN) }; rect = gCurrentWindow->fullscreenRect; } else { if (IsIconic(_hwnd)) return 0; RECT windowRect; GetClientRect(_hwnd, &windowRect); rect = { (int)windowRect.left, (int)windowRect.top, (int)windowRect.right, (int)windowRect.bottom }; gCurrentWindow->windowedRect = rect; } WindowResizeEventData eventData = { rect, gCurrentWindow }; PlatformEvents::onWindowResize(&eventData); } break; case WM_CLOSE: case WM_QUIT: gAppRunning = false; break; case WM_CHAR: { KeyboardCharEventData eventData; eventData.unicode = (unsigned)wParam; PlatformEvents::onKeyboardChar(&eventData); break; } case WM_MOUSEMOVE: { static int lastX = 0, lastY = 0; int x, y; x = GETX(lParam); y = GETY(lParam); MouseMoveEventData eventData; eventData.x = x; eventData.y = y; eventData.deltaX = x - lastX; eventData.deltaY = y - lastY; eventData.captured = isCaptured; PlatformEvents::onMouseMove(&eventData); lastX = x; lastY = y; break; } case WM_INPUT: { UINT dwSize; static BYTE lpb[128] = {}; GetRawInputData((HRAWINPUT)lParam, RID_INPUT, lpb, &dwSize, sizeof(RAWINPUTHEADER)); RAWINPUT* raw = (RAWINPUT*)lpb; if (raw->header.dwType == RIM_TYPEMOUSE) { static int lastX = 0, lastY = 0; int xPosRelative = raw->data.mouse.lLastX; int yPosRelative = raw->data.mouse.lLastY; RawMouseMoveEventData eventData; eventData.x = xPosRelative; eventData.y = yPosRelative; eventData.captured = isCaptured; PlatformEvents::onRawMouseMove(&eventData); lastX = xPosRelative; lastY = yPosRelative; } return 0; } case WM_LBUTTONDOWN: { MouseButtonEventData eventData; eventData.button = MOUSE_LEFT; eventData.pressed = true; eventData.x = GETX(lParam); eventData.y = GETY(lParam); if (PlatformEvents::wantsMouseCapture && !PlatformEvents::skipMouseCapture && !isCaptured) { captureMouse(_hwnd, true); } PlatformEvents::onMouseButton(&eventData); break; } case WM_LBUTTONUP: { MouseButtonEventData eventData; eventData.button = MOUSE_LEFT; eventData.pressed = false; eventData.x = GETX(lParam); eventData.y = GETY(lParam); PlatformEvents::onMouseButton(&eventData); break; } case WM_RBUTTONDOWN: { MouseButtonEventData eventData; eventData.button = MOUSE_RIGHT; eventData.pressed = true; eventData.x = GETX(lParam); eventData.y = GETY(lParam); PlatformEvents::onMouseButton(&eventData); break; } case WM_RBUTTONUP: { MouseButtonEventData eventData; eventData.button = MOUSE_RIGHT; eventData.pressed = false; eventData.x = GETX(lParam); eventData.y = GETY(lParam); PlatformEvents::onMouseButton(&eventData); break; } case WM_MBUTTONDOWN: { MouseButtonEventData eventData; eventData.button = MOUSE_MIDDLE; eventData.pressed = true; eventData.x = GETX(lParam); eventData.y = GETY(lParam); PlatformEvents::onMouseButton(&eventData); break; } case WM_MBUTTONUP: { MouseButtonEventData eventData; eventData.button = MOUSE_MIDDLE; eventData.pressed = false; eventData.x = GETX(lParam); eventData.y = GETY(lParam); PlatformEvents::onMouseButton(&eventData); break; } case WM_MOUSEWHEEL: { static int scroll; int s; scroll += GET_WHEEL_DELTA_WPARAM(wParam); s = scroll / WHEEL_DELTA; scroll %= WHEEL_DELTA; POINT point; point.x = GETX(lParam); point.y = GETY(lParam); ScreenToClient(_hwnd, &point); if (s != 0) { MouseWheelEventData eventData; eventData.scroll = s; eventData.x = point.x; eventData.y = point.y; PlatformEvents::onMouseWheel(&eventData); } break; } case WM_SYSKEYDOWN: if ((lParam & (1 << 29)) && (wParam == KEY_ENTER)) { toggleFullscreen(gCurrentWindow); } updateKeyArray(_id, (unsigned)wParam); break; case WM_SYSKEYUP: updateKeyArray(_id, (unsigned)wParam); break; case WM_KEYUP: if (wParam == KEY_ESCAPE) { if (!isCaptured) { gAppRunning = false; } else { captureMouse(_hwnd, false); } } updateKeyArray(_id, (unsigned)wParam); break; case WM_KEYDOWN: updateKeyArray(_id, (unsigned)wParam); break; default: return DefWindowProcW(_hwnd, _id, wParam, lParam); break; } return 0; }
static LRESULT WINAPI ANIMATE_WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { ANIMATE_INFO *infoPtr = (ANIMATE_INFO *)GetWindowLongPtrW(hWnd, 0); TRACE("hwnd=%p msg=%x wparam=%lx lparam=%lx\n", hWnd, uMsg, wParam, lParam); if (!infoPtr && (uMsg != WM_NCCREATE)) return DefWindowProcW(hWnd, uMsg, wParam, lParam); switch (uMsg) { case ACM_OPENA: return ANIMATE_OpenA(infoPtr, (HINSTANCE)wParam, (LPSTR)lParam); case ACM_OPENW: return ANIMATE_OpenW(infoPtr, (HINSTANCE)wParam, (LPWSTR)lParam); case ACM_PLAY: return ANIMATE_Play(infoPtr, (INT)wParam, LOWORD(lParam), HIWORD(lParam)); case ACM_STOP: return ANIMATE_Stop(infoPtr); case WM_CLOSE: ANIMATE_Free(infoPtr); return 0; case WM_NCCREATE: return ANIMATE_Create(hWnd, (LPCREATESTRUCTW)lParam); case WM_NCHITTEST: return HTTRANSPARENT; case WM_DESTROY: return ANIMATE_Destroy(infoPtr); case WM_ERASEBKGND: return ANIMATE_EraseBackground(infoPtr, (HDC)wParam); case WM_STYLECHANGED: return ANIMATE_StyleChanged(infoPtr, wParam, (LPSTYLESTRUCT)lParam); case WM_TIMER: return ANIMATE_Timer(infoPtr); case WM_PRINTCLIENT: case WM_PAINT: { /* the animation has not decompressed * (and displayed) the first frame yet, don't paint */ if (!infoPtr->hbmPrevFrame) { /* default paint handling */ return DefWindowProcW(hWnd, uMsg, wParam, lParam); } if (wParam) { EnterCriticalSection(&infoPtr->cs); ANIMATE_PaintFrame(infoPtr, (HDC)wParam); LeaveCriticalSection(&infoPtr->cs); } else { PAINTSTRUCT ps; HDC hDC = BeginPaint(infoPtr->hwndSelf, &ps); EnterCriticalSection(&infoPtr->cs); ANIMATE_PaintFrame(infoPtr, hDC); LeaveCriticalSection(&infoPtr->cs); EndPaint(infoPtr->hwndSelf, &ps); } } break; case WM_SIZE: if (infoPtr->dwStyle & ACS_CENTER) InvalidateRect(infoPtr->hwndSelf, NULL, TRUE); return DefWindowProcW(hWnd, uMsg, wParam, lParam); default: if ((uMsg >= WM_USER) && (uMsg < WM_APP) && !COMCTL32_IsReflectedMessage(uMsg)) ERR("unknown msg %04x wp=%08lx lp=%08lx\n", uMsg, wParam, lParam); return DefWindowProcW(hWnd, uMsg, wParam, lParam); } return 0; }
LRESULT CALLBACK CInputModeWindow::_WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { PAINTSTRUCT ps; HDC hdc; HDC hmemdc; HBITMAP hmembmp; HPEN npen; HBRUSH nbrush; HGDIOBJ bmp, pen, brush; HICON hIcon; RECT r; switch(uMsg) { case WM_CREATE: if(!_bCandidateWindow) { SetTimer(hWnd, INPUTMODE_TIMER_ID, _pTextService->cx_showmodesec * 1000, nullptr); } break; case WM_TIMER: if(wParam == INPUTMODE_TIMER_ID) { // CAUTION!! killing self _pTextService->_EndInputModeWindow(); } break; case WM_DESTROY: if(!_bCandidateWindow) { KillTimer(hWnd, INPUTMODE_TIMER_ID); } break; case WM_PAINT: hdc = BeginPaint(hWnd, &ps); GetClientRect(hWnd, &r); hmemdc = CreateCompatibleDC(hdc); hmembmp = CreateCompatibleBitmap(hdc, r.right, r.bottom); bmp = SelectObject(hmemdc, hmembmp); npen = CreatePen(PS_SOLID, 1, RGB(0x00, 0x00, 0x00)); pen = SelectObject(hmemdc, npen); nbrush = CreateSolidBrush(RGB(0xFF, 0xFF, 0xFF)); brush = SelectObject(hmemdc, nbrush); Rectangle(hmemdc, 0, 0, r.right, r.bottom); _pTextService->_GetIcon(&hIcon); DrawIconEx(hmemdc, IM_MERGIN_X, IM_MERGIN_Y, hIcon, _size, _size, 0, nbrush, DI_NORMAL); SelectObject(hmemdc, pen); SelectObject(hmemdc, brush); DeleteObject(npen); DeleteObject(nbrush); BitBlt(hdc, 0, 0, r.right, r.bottom, hmemdc, 0, 0, SRCCOPY); SelectObject(hmemdc, bmp); DeleteObject(hmembmp); DeleteObject(hmemdc); EndPaint(hWnd, &ps); break; case WM_MOUSEACTIVATE: return MA_NOACTIVATE; default: return DefWindowProcW(hWnd, uMsg, wParam, lParam); } return 0; }
static void CB_draw(HTHEME theme, HWND hwnd, HDC hDC, ButtonState drawState, UINT dtFlags, BOOL focused, LPARAM prfFlag) { static const int cb_states[3][5] = { { CBS_UNCHECKEDNORMAL, CBS_UNCHECKEDHOT, CBS_UNCHECKEDPRESSED, CBS_UNCHECKEDDISABLED, CBS_UNCHECKEDNORMAL }, { CBS_CHECKEDNORMAL, CBS_CHECKEDHOT, CBS_CHECKEDPRESSED, CBS_CHECKEDDISABLED, CBS_CHECKEDNORMAL }, { CBS_MIXEDNORMAL, CBS_MIXEDHOT, CBS_MIXEDPRESSED, CBS_MIXEDDISABLED, CBS_MIXEDNORMAL } }; static const int rb_states[2][5] = { { RBS_UNCHECKEDNORMAL, RBS_UNCHECKEDHOT, RBS_UNCHECKEDPRESSED, RBS_UNCHECKEDDISABLED, RBS_UNCHECKEDNORMAL }, { RBS_CHECKEDNORMAL, RBS_CHECKEDHOT, RBS_CHECKEDPRESSED, RBS_CHECKEDDISABLED, RBS_CHECKEDNORMAL } }; SIZE sz; RECT bgRect, textRect; HFONT font, hPrevFont = NULL; LRESULT checkState = get_button_state(hwnd) & 3; DWORD dwStyle = GetWindowLongW(hwnd, GWL_STYLE); int part = ((dwStyle & BUTTON_TYPE) == BS_RADIOBUTTON) || ((dwStyle & BUTTON_TYPE) == BS_AUTORADIOBUTTON) ? BP_RADIOBUTTON : BP_CHECKBOX; int state = (part == BP_CHECKBOX) ? cb_states[ checkState ][ drawState ] : rb_states[ checkState ][ drawState ]; WCHAR *text; LOGFONTW lf; BOOL created_font = FALSE; HWND parent; HBRUSH hBrush; DWORD cdrf; HRESULT hr = GetThemeFont(theme, hDC, part, state, TMT_FONT, &lf); if (SUCCEEDED(hr)) { font = CreateFontIndirectW(&lf); if (!font) TRACE("Failed to create font\n"); else { TRACE("font = %s\n", debugstr_w(lf.lfFaceName)); hPrevFont = SelectObject(hDC, font); created_font = TRUE; } } else { font = get_button_font(hwnd); hPrevFont = SelectObject(hDC, font); } if (FAILED(GetThemePartSize(theme, hDC, part, state, NULL, TS_DRAW, &sz))) sz.cx = sz.cy = 13; GetClientRect(hwnd, &bgRect); if (prfFlag == 0) { DrawThemeParentBackground(hwnd, hDC, NULL); } parent = GetParent(hwnd); if (!parent) parent = hwnd; hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORSTATIC, (WPARAM)hDC, (LPARAM)hwnd); if (!hBrush) /* did the app forget to call defwindowproc ? */ hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORSTATIC, (WPARAM)hDC, (LPARAM)hwnd ); FillRect( hDC, &bgRect, hBrush ); cdrf = BUTTON_SendCustomDraw(hwnd, hDC, CDDS_PREERASE, &bgRect); if (cdrf == CDRF_SKIPDEFAULT) goto cleanup; GetThemeBackgroundContentRect(theme, hDC, part, state, &bgRect, &textRect); if (dtFlags & DT_SINGLELINE) /* Center the checkbox / radio button to the text. */ bgRect.top = bgRect.top + (textRect.bottom - textRect.top - sz.cy) / 2; /* adjust for the check/radio marker */ bgRect.bottom = bgRect.top + sz.cy; bgRect.right = bgRect.left + sz.cx; textRect.left = bgRect.right + 6; DrawThemeBackground(theme, hDC, part, state, &bgRect, NULL); if (cdrf == CDRF_NOTIFYPOSTERASE) BUTTON_SendCustomDraw(hwnd, hDC, CDDS_POSTERASE, &bgRect); cdrf = BUTTON_SendCustomDraw(hwnd, hDC, CDDS_PREPAINT, &bgRect); if (cdrf == CDRF_SKIPDEFAULT) goto cleanup; text = get_button_text(hwnd); if (text) { DrawThemeText(theme, hDC, part, state, text, lstrlenW(text), dtFlags, 0, &textRect); if (focused) { RECT focusRect; focusRect = textRect; DrawTextW(hDC, text, lstrlenW(text), &focusRect, dtFlags | DT_CALCRECT); if (focusRect.right < textRect.right) focusRect.right++; focusRect.bottom = textRect.bottom; DrawFocusRect( hDC, &focusRect ); } HeapFree(GetProcessHeap(), 0, text); } if (cdrf == CDRF_NOTIFYPOSTPAINT) BUTTON_SendCustomDraw(hwnd, hDC, CDDS_POSTPAINT, &bgRect); cleanup: if (created_font) DeleteObject(font); if (hPrevFont) SelectObject(hDC, hPrevFont); }
/******************************************************************************* * * FUNCTION: ChildWndProc(HWND, unsigned, WORD, LONG) * * PURPOSE: Processes messages for the child windows. * * WM_COMMAND - process the application menu * WM_PAINT - Paint the main window * WM_DESTROY - post a quit message and return * */ LRESULT CALLBACK ChildWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { BOOL Result; switch (message) { case WM_CREATE: { WNDPROC oldproc; HFONT hFont; WCHAR buffer[MAX_PATH]; /* Load "My Computer" string */ LoadStringW(hInst, IDS_MY_COMPUTER, buffer, COUNT_OF(buffer)); g_pChildWnd = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ChildWnd)); if (!g_pChildWnd) return 0; wcsncpy(g_pChildWnd->szPath, buffer, MAX_PATH); g_pChildWnd->nSplitPos = 250; g_pChildWnd->hWnd = hWnd; g_pChildWnd->hAddressBarWnd = CreateWindowExW(WS_EX_CLIENTEDGE, L"Edit", NULL, WS_CHILD | WS_VISIBLE | WS_CHILDWINDOW | WS_TABSTOP, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, hWnd, (HMENU)0, hInst, 0); g_pChildWnd->hAddressBtnWnd = CreateWindowExW(0, L"Button", L"»", WS_CHILD | WS_VISIBLE | WS_CHILDWINDOW | WS_TABSTOP | BS_TEXT | BS_CENTER | BS_VCENTER | BS_FLAT | BS_DEFPUSHBUTTON, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, hWnd, (HMENU)0, hInst, 0); g_pChildWnd->hTreeWnd = CreateTreeView(hWnd, g_pChildWnd->szPath, (HMENU) TREE_WINDOW); g_pChildWnd->hListWnd = CreateListView(hWnd, (HMENU) LIST_WINDOW/*, g_pChildWnd->szPath*/); SetFocus(g_pChildWnd->hTreeWnd); /* set the address bar and button font */ if ((g_pChildWnd->hAddressBarWnd) && (g_pChildWnd->hAddressBtnWnd)) { hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT); SendMessageW(g_pChildWnd->hAddressBarWnd, WM_SETFONT, (WPARAM)hFont, 0); SendMessageW(g_pChildWnd->hAddressBtnWnd, WM_SETFONT, (WPARAM)hFont, 0); } /* Subclass the AddressBar */ oldproc = (WNDPROC)(LONG_PTR)GetWindowLongPtr(g_pChildWnd->hAddressBarWnd, GWLP_WNDPROC); SetWindowLongPtr(g_pChildWnd->hAddressBarWnd, GWLP_USERDATA, (DWORD_PTR)oldproc); SetWindowLongPtr(g_pChildWnd->hAddressBarWnd, GWLP_WNDPROC, (DWORD_PTR)AddressBarProc); break; } case WM_COMMAND: if(HIWORD(wParam) == BN_CLICKED) { PostMessageW(g_pChildWnd->hAddressBarWnd, WM_KEYUP, VK_RETURN, 0); } if (!_CmdWndProc(hWnd, message, wParam, lParam)) { goto def; } break; case WM_PAINT: OnPaint(hWnd); return 0; case WM_SETCURSOR: if (LOWORD(lParam) == HTCLIENT) { POINT pt; GetCursorPos(&pt); ScreenToClient(hWnd, &pt); if (pt.x>=g_pChildWnd->nSplitPos-SPLIT_WIDTH/2 && pt.x<g_pChildWnd->nSplitPos+SPLIT_WIDTH/2+1) { SetCursor(LoadCursorW(0, IDC_SIZEWE)); return TRUE; } } goto def; case WM_DESTROY: DestroyTreeView(); DestroyListView(g_pChildWnd->hListWnd); DestroyMainMenu(); HeapFree(GetProcessHeap(), 0, g_pChildWnd); g_pChildWnd = NULL; PostQuitMessage(0); break; case WM_LBUTTONDOWN: { RECT rt; int x = (short)LOWORD(lParam); GetClientRect(hWnd, &rt); if (x>=g_pChildWnd->nSplitPos-SPLIT_WIDTH/2 && x<g_pChildWnd->nSplitPos+SPLIT_WIDTH/2+1) { last_split = g_pChildWnd->nSplitPos; draw_splitbar(hWnd, last_split); SetCapture(hWnd); } break; } case WM_LBUTTONUP: case WM_RBUTTONDOWN: if (GetCapture() == hWnd) { finish_splitbar(hWnd, LOWORD(lParam)); } break; case WM_CAPTURECHANGED: if (GetCapture()==hWnd && last_split>=0) draw_splitbar(hWnd, last_split); break; case WM_KEYDOWN: if (wParam == VK_ESCAPE) if (GetCapture() == hWnd) { RECT rt; draw_splitbar(hWnd, last_split); GetClientRect(hWnd, &rt); ResizeWnd(rt.right, rt.bottom); last_split = -1; ReleaseCapture(); SetCursor(LoadCursorW(0, IDC_ARROW)); } break; case WM_MOUSEMOVE: if (GetCapture() == hWnd) { HDC hdc; RECT rt; HGDIOBJ OldObj; int x = LOWORD(lParam); if(!SizingPattern) { const DWORD Pattern[4] = {0x5555AAAA, 0x5555AAAA, 0x5555AAAA, 0x5555AAAA}; SizingPattern = CreateBitmap(8, 8, 1, 1, Pattern); } if(!SizingBrush) { SizingBrush = CreatePatternBrush(SizingPattern); } GetClientRect(hWnd, &rt); x = (SHORT) min(max(x, SPLIT_MIN), rt.right - SPLIT_MIN); if(last_split != x) { rt.left = last_split-SPLIT_WIDTH/2; rt.right = last_split+SPLIT_WIDTH/2+1; hdc = GetDC(hWnd); OldObj = SelectObject(hdc, SizingBrush); PatBlt(hdc, rt.left, rt.top, rt.right - rt.left, rt.bottom - rt.top, PATINVERT); last_split = x; rt.left = x-SPLIT_WIDTH/2; rt.right = x+SPLIT_WIDTH/2+1; PatBlt(hdc, rt.left, rt.top, rt.right - rt.left, rt.bottom - rt.top, PATINVERT); SelectObject(hdc, OldObj); ReleaseDC(hWnd, hdc); } } break; case WM_SETFOCUS: if (g_pChildWnd != NULL) { SetFocus(g_pChildWnd->nFocusPanel? g_pChildWnd->hListWnd: g_pChildWnd->hTreeWnd); } break; case WM_TIMER: break; case WM_NOTIFY: if ((int)wParam == TREE_WINDOW && g_pChildWnd != NULL) { switch (((LPNMHDR)lParam)->code) { case TVN_ITEMEXPANDING: return !OnTreeExpanding(g_pChildWnd->hTreeWnd, (NMTREEVIEW*)lParam); case TVN_SELCHANGED: UpdateAddress(((NMTREEVIEW*)lParam)->itemNew.hItem, NULL, NULL); break; case NM_SETFOCUS: g_pChildWnd->nFocusPanel = 0; break; case TVN_BEGINLABELEDIT: { LPNMTVDISPINFO ptvdi; /* cancel label edit for rootkeys */ ptvdi = (LPNMTVDISPINFO) lParam; if (!TreeView_GetParent(g_pChildWnd->hTreeWnd, ptvdi->item.hItem) || !TreeView_GetParent(g_pChildWnd->hTreeWnd, TreeView_GetParent(g_pChildWnd->hTreeWnd, ptvdi->item.hItem))) return TRUE; break; } case TVN_ENDLABELEDIT: { LPCWSTR keyPath; HKEY hRootKey; HKEY hKey = NULL; LPNMTVDISPINFO ptvdi; LONG lResult = TRUE; WCHAR szBuffer[MAX_PATH]; ptvdi = (LPNMTVDISPINFO) lParam; if (ptvdi->item.pszText) { keyPath = GetItemPath(g_pChildWnd->hTreeWnd, TreeView_GetParent(g_pChildWnd->hTreeWnd, ptvdi->item.hItem), &hRootKey); _snwprintf(szBuffer, COUNT_OF(szBuffer), L"%s\\%s", keyPath, ptvdi->item.pszText); keyPath = GetItemPath(g_pChildWnd->hTreeWnd, ptvdi->item.hItem, &hRootKey); if (RegOpenKeyExW(hRootKey, szBuffer, 0, KEY_READ, &hKey) == ERROR_SUCCESS) { lResult = FALSE; RegCloseKey(hKey); (void)TreeView_EditLabel(g_pChildWnd->hTreeWnd, ptvdi->item.hItem); } else { if (RenameKey(hRootKey, keyPath, ptvdi->item.pszText) != ERROR_SUCCESS) lResult = FALSE; else UpdateAddress(ptvdi->item.hItem, hRootKey, szBuffer); } return lResult; } } default: return 0; } } else { if ((int)wParam == LIST_WINDOW && g_pChildWnd != NULL) { switch (((LPNMHDR)lParam)->code) { case NM_SETFOCUS: g_pChildWnd->nFocusPanel = 1; break; default: if(!ListWndNotifyProc(g_pChildWnd->hListWnd, wParam, lParam, &Result)) { goto def; } return Result; break; } } } break; case WM_CONTEXTMENU: { POINT pt; if((HWND)wParam == g_pChildWnd->hListWnd) { int i, cnt; BOOL IsDefault; pt.x = (short) LOWORD(lParam); pt.y = (short) HIWORD(lParam); cnt = ListView_GetSelectedCount(g_pChildWnd->hListWnd); i = ListView_GetNextItem(g_pChildWnd->hListWnd, -1, LVNI_FOCUSED | LVNI_SELECTED); if (pt.x == -1 && pt.y == -1) { RECT rc; if (i != -1) { rc.left = LVIR_BOUNDS; SendMessageW(g_pChildWnd->hListWnd, LVM_GETITEMRECT, i, (LPARAM) &rc); pt.x = rc.left + 8; pt.y = rc.top + 8; } else pt.x = pt.y = 0; ClientToScreen(g_pChildWnd->hListWnd, &pt); } if(i == -1) { TrackPopupMenu(GetSubMenu(hPopupMenus, PM_NEW), TPM_RIGHTBUTTON, pt.x, pt.y, 0, hFrameWnd, NULL); } else { HMENU mnu = GetSubMenu(hPopupMenus, PM_MODIFYVALUE); SetMenuDefaultItem(mnu, ID_EDIT_MODIFY, MF_BYCOMMAND); IsDefault = IsDefaultValue(g_pChildWnd->hListWnd, i); if(cnt == 1) EnableMenuItem(mnu, ID_EDIT_RENAME, MF_BYCOMMAND | (IsDefault ? MF_DISABLED | MF_GRAYED : MF_ENABLED)); else EnableMenuItem(mnu, ID_EDIT_RENAME, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED); EnableMenuItem(mnu, ID_EDIT_MODIFY, MF_BYCOMMAND | (cnt == 1 ? MF_ENABLED : MF_DISABLED | MF_GRAYED)); EnableMenuItem(mnu, ID_EDIT_MODIFY_BIN, MF_BYCOMMAND | (cnt == 1 ? MF_ENABLED : MF_DISABLED | MF_GRAYED)); TrackPopupMenu(mnu, TPM_RIGHTBUTTON, pt.x, pt.y, 0, hFrameWnd, NULL); } } else if ((HWND)wParam == g_pChildWnd->hTreeWnd) { TVHITTESTINFO hti; HMENU hContextMenu; TVITEMW item; MENUITEMINFOW mii; WCHAR resource[256]; WCHAR buffer[256]; LPWSTR s; LPCWSTR keyPath; HKEY hRootKey; int iLastPos; WORD wID; pt.x = (short) LOWORD(lParam); pt.y = (short) HIWORD(lParam); if (pt.x == -1 && pt.y == -1) { RECT rc; hti.hItem = TreeView_GetSelection(g_pChildWnd->hTreeWnd); if (hti.hItem != NULL) { TreeView_GetItemRect(g_pChildWnd->hTreeWnd, hti.hItem, &rc, TRUE); pt.x = rc.left + 8; pt.y = rc.top + 8; ClientToScreen(g_pChildWnd->hTreeWnd, &pt); hti.flags = TVHT_ONITEM; } else hti.flags = 0; } else { hti.pt.x = pt.x; hti.pt.y = pt.y; ScreenToClient(g_pChildWnd->hTreeWnd, &hti.pt); (void)TreeView_HitTest(g_pChildWnd->hTreeWnd, &hti); } if (hti.flags & TVHT_ONITEM) { hContextMenu = GetSubMenu(hPopupMenus, PM_TREECONTEXT); (void)TreeView_SelectItem(g_pChildWnd->hTreeWnd, hti.hItem); memset(&item, 0, sizeof(item)); item.mask = TVIF_STATE | TVIF_CHILDREN; item.hItem = hti.hItem; (void)TreeView_GetItem(g_pChildWnd->hTreeWnd, &item); /* Set the Expand/Collapse menu item appropriately */ LoadStringW(hInst, (item.state & TVIS_EXPANDED) ? IDS_COLLAPSE : IDS_EXPAND, buffer, COUNT_OF(buffer)); memset(&mii, 0, sizeof(mii)); mii.cbSize = sizeof(mii); mii.fMask = MIIM_STRING | MIIM_STATE | MIIM_ID; mii.fState = (item.cChildren > 0) ? MFS_DEFAULT : MFS_GRAYED; mii.wID = (item.state & TVIS_EXPANDED) ? ID_TREE_COLLAPSEBRANCH : ID_TREE_EXPANDBRANCH; mii.dwTypeData = (LPWSTR) buffer; SetMenuItemInfo(hContextMenu, 0, TRUE, &mii); /* Remove any existing suggestions */ memset(&mii, 0, sizeof(mii)); mii.cbSize = sizeof(mii); mii.fMask = MIIM_ID; GetMenuItemInfo(hContextMenu, GetMenuItemCount(hContextMenu) - 1, TRUE, &mii); if ((mii.wID >= ID_TREE_SUGGESTION_MIN) && (mii.wID <= ID_TREE_SUGGESTION_MAX)) { do { iLastPos = GetMenuItemCount(hContextMenu) - 1; GetMenuItemInfo(hContextMenu, iLastPos, TRUE, &mii); RemoveMenu(hContextMenu, iLastPos, MF_BYPOSITION); } while((mii.wID >= ID_TREE_SUGGESTION_MIN) && (mii.wID <= ID_TREE_SUGGESTION_MAX)); } /* Come up with suggestions */ keyPath = GetItemPath(g_pChildWnd->hTreeWnd, NULL, &hRootKey); SuggestKeys(hRootKey, keyPath, Suggestions, COUNT_OF(Suggestions)); if (Suggestions[0]) { AppendMenu(hContextMenu, MF_SEPARATOR, 0, NULL); LoadStringW(hInst, IDS_GOTO_SUGGESTED_KEY, resource, COUNT_OF(resource)); s = Suggestions; wID = ID_TREE_SUGGESTION_MIN; while(*s && (wID <= ID_TREE_SUGGESTION_MAX)) { _snwprintf(buffer, COUNT_OF(buffer), resource, s); memset(&mii, 0, sizeof(mii)); mii.cbSize = sizeof(mii); mii.fMask = MIIM_STRING | MIIM_ID; mii.wID = wID++; mii.dwTypeData = buffer; InsertMenuItem(hContextMenu, GetMenuItemCount(hContextMenu), TRUE, &mii); s += wcslen(s) + 1; } } TrackPopupMenu(hContextMenu, TPM_RIGHTBUTTON, pt.x, pt.y, 0, g_pChildWnd->hWnd, NULL); } } break; } case WM_SIZE: if (wParam != SIZE_MINIMIZED && g_pChildWnd != NULL) { ResizeWnd(LOWORD(lParam), HIWORD(lParam)); } /* fall through */ default: def: return DefWindowProcW(hWnd, message, wParam, lParam); } return 0; }
static LRESULT CALLBACK MonitorSelWndProc(IN HWND hwnd, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam) { PMONITORSELWND infoPtr; LRESULT Ret = 0; infoPtr = (PMONITORSELWND)GetWindowLongPtrW(hwnd, 0); if (infoPtr == NULL && uMsg != WM_CREATE) { goto HandleDefaultMessage; } switch (uMsg) { case WM_PAINT: case WM_PRINTCLIENT: { PAINTSTRUCT ps; HDC hDC; if (wParam != 0) { if (!GetUpdateRect(hwnd, &ps.rcPaint, TRUE)) { break; } hDC = (HDC)wParam; } else { hDC = BeginPaint(hwnd, &ps); if (hDC == NULL) { break; } } if (infoPtr->CanDisplay) { MonSelPaint(infoPtr, hDC, &ps.rcPaint); } if (wParam == 0) { EndPaint(hwnd, &ps); } break; } case WM_MOUSEMOVE: { POINT pt; if (!(wParam & MK_LBUTTON)) { MonSelCancelDragging(infoPtr); break; } if (infoPtr->LeftBtnDown) { pt.x = (LONG)LOWORD(lParam); pt.y = (LONG)HIWORD(lParam); MonSelDrag(infoPtr, &pt); } break; } case WM_RBUTTONDOWN: { if (!(infoPtr->ControlExStyle & MSLM_EX_SELECTONRIGHTCLICK)) break; /* Fall through */ } case WM_LBUTTONDBLCLK: case WM_LBUTTONDOWN: { INT Index; POINT pt; if (!infoPtr->HasFocus) SetFocus(infoPtr->hSelf); pt.x = (LONG)LOWORD(lParam); pt.y = (LONG)HIWORD(lParam); Index = MonSelHitTest(infoPtr, &pt); if (Index >= 0 || (infoPtr->ControlExStyle & MSLM_EX_ALLOWSELECTNONE)) { MonSelSetCurSelMonitor(infoPtr, Index, TRUE); } if (Index >= 0 && (uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONDBLCLK)) { infoPtr->LeftBtnDown = TRUE; MonSelInitDragging(infoPtr, (DWORD)Index, &pt); } /* Fall through */ } case WM_MBUTTONDOWN: { if (!infoPtr->HasFocus) SetFocus(hwnd); break; } case WM_RBUTTONUP: { MonSelContextMenu(infoPtr, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam)); break; } case WM_LBUTTONUP: { MonSelCancelDragging(infoPtr); infoPtr->LeftBtnDown = FALSE; break; } case WM_GETDLGCODE: { INT virtKey; virtKey = (lParam != 0 ? (INT)((LPMSG)lParam)->wParam : 0); switch (virtKey) { case VK_TAB: { /* Change the UI status */ SendMessage(GetAncestor(hwnd, GA_PARENT), WM_CHANGEUISTATE, MAKEWPARAM(UIS_INITIALIZE, 0), 0); break; } } Ret |= DLGC_WANTARROWS; if (infoPtr->ControlExStyle & MSLM_EX_SELECTBYNUMKEY) Ret |= DLGC_WANTCHARS; break; } case WM_SETFOCUS: { infoPtr->HasFocus = TRUE; MonSelRepaintSelected(infoPtr); break; } case WM_KILLFOCUS: { infoPtr->HasFocus = FALSE; MonSelCancelDragging(infoPtr); MonSelRepaintSelected(infoPtr); break; } case WM_UPDATEUISTATE: { DWORD OldUIState; Ret = DefWindowProcW(hwnd, uMsg, wParam, lParam); OldUIState = infoPtr->UIState; switch (LOWORD(wParam)) { case UIS_SET: infoPtr->UIState |= HIWORD(wParam); break; case UIS_CLEAR: infoPtr->UIState &= ~HIWORD(wParam); break; } if (infoPtr->UIState != OldUIState) MonSelRepaintSelected(infoPtr); break; } case WM_SETFONT: { Ret = (LRESULT)MonSelChangeFont(infoPtr, (HFONT)wParam, (BOOL)LOWORD(lParam)); break; } case WM_SIZE: { infoPtr->ClientSize.cx = LOWORD(lParam); infoPtr->ClientSize.cy = HIWORD(lParam); /* Don't let MonSelUpdateMonitorsInfo repaint the control because this won't work properly in case the control was sized down! */ MonSelUpdateMonitorsInfo(infoPtr, FALSE); InvalidateRect(infoPtr->hSelf, NULL, TRUE); break; } case WM_GETFONT: { Ret = (LRESULT)infoPtr->hFont; break; } case WM_ENABLE: { infoPtr->Enabled = ((BOOL)wParam != FALSE); MonSelRepaint(infoPtr); break; } case WM_STYLECHANGED: { if (wParam == GWL_STYLE) { unsigned int OldEnabled = infoPtr->Enabled; infoPtr->Enabled = !(((LPSTYLESTRUCT)lParam)->styleNew & WS_DISABLED); if (OldEnabled != infoPtr->Enabled) MonSelRepaint(infoPtr); } break; } case WM_KEYDOWN: { INT Index; if (infoPtr->ControlExStyle & MSLM_EX_SELECTBYARROWKEY) { switch (wParam) { case VK_UP: case VK_LEFT: { Index = infoPtr->SelectedMonitor; if (infoPtr->MonitorsCount != 0) { if (Index < 0) Index = 0; else if (Index > 0) Index--; } if (Index >= 0) { MonSelSetCurSelMonitor(infoPtr, Index, TRUE); } break; } case VK_DOWN: case VK_RIGHT: { Index = infoPtr->SelectedMonitor; if (infoPtr->MonitorsCount != 0) { if (Index < 0) Index = (INT)infoPtr->MonitorsCount - 1; else if (Index < (INT)infoPtr->MonitorsCount - 1) Index++; } if (infoPtr->SelectedMonitor < (INT)infoPtr->MonitorsCount) { MonSelSetCurSelMonitor(infoPtr, Index, TRUE); } break; } } } break; } case WM_CHAR: { if ((infoPtr->ControlExStyle & MSLM_EX_SELECTBYNUMKEY) && wParam >= '1' && wParam <= '9') { INT Index = (INT)(wParam - '1'); if (Index < (INT)infoPtr->MonitorsCount) { MonSelSetCurSelMonitor(infoPtr, Index, TRUE); } } break; } case MSLM_SETMONITORSINFO: { Ret = MonSelSetMonitorsInfo(infoPtr, (DWORD)wParam, (const MONSL_MONINFO *)lParam); break; } case MSLM_GETMONITORSINFO: { Ret = MonSelGetMonitorsInfo(infoPtr, (DWORD)wParam, (PMONSL_MONINFO)lParam); break; } case MSLM_GETMONITORINFOCOUNT: { Ret = infoPtr->MonitorsCount; break; } case MSLM_HITTEST: { Ret = MonSelHitTest(infoPtr, (const POINT *)wParam); break; } case MSLM_SETCURSEL: { Ret = MonSelSetCurSelMonitor(infoPtr, (INT)wParam, FALSE); break; } case MSLM_GETCURSEL: { Ret = infoPtr->SelectedMonitor; break; } case MSLM_SETMONITORINFO: { Ret = MonSelSetMonitorInfo(infoPtr, (INT)wParam, (const MONSL_MONINFO *)lParam); break; } case MSLM_GETMONITORINFO: { Ret = MonSelGetMonitorInfo(infoPtr, (INT)wParam, (PMONSL_MONINFO)lParam); break; } case MSLM_SETEXSTYLE: { Ret = MonSelSetExtendedStyle(infoPtr, (DWORD)lParam); break; } case MSLM_GETEXSTYLE: { Ret = MonSelGetExtendedStyle(infoPtr); break; } case MSLM_GETMONITORRECT: { Ret = (LRESULT)MonSelGetMonitorRect(infoPtr, (INT)wParam, (PRECT)lParam); break; } case WM_CREATE: { infoPtr = (PMONITORSELWND) HeapAlloc(GetProcessHeap(), 0, sizeof(MONITORSELWND)); if (infoPtr == NULL) { Ret = (LRESULT)-1; break; } ZeroMemory(infoPtr, sizeof(MONITORSELWND)); infoPtr->hSelf = hwnd; infoPtr->hNotify = ((LPCREATESTRUCTW)lParam)->hwndParent; infoPtr->Enabled = !(((LPCREATESTRUCTW)lParam)->style & WS_DISABLED); infoPtr->UIState = SendMessage(hwnd, WM_QUERYUISTATE, 0, 0); SetWindowLongPtrW(hwnd, 0, (LONG_PTR)infoPtr); MonSelCreate(infoPtr); break; } case WM_DESTROY: { MonSelDestroy(infoPtr); HeapFree(GetProcessHeap(), 0, infoPtr); SetWindowLongPtrW(hwnd, 0, (DWORD_PTR)NULL); break; } default: { HandleDefaultMessage: Ret = DefWindowProcW(hwnd, uMsg, wParam, lParam); break; } } return Ret; }
LRESULT MyProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { //static BOOL bActiveApp = FALSE; if(message == WM_IPOD_SIGNAL) { switch (wParam) { case IPOD_REMOVE: { //CEIPC_UnRegist(); //HWND hServerWnd = ::FindWindow(STR_PROCESSNAME_MANAGE, STR_PROCESSNAME_MANAGE); //if (hServerWnd) //{ // ::PostMessage(hServerWnd, VWM_SERVER_SRC_CLOSE, IPC_ID_IPOD, NULL); // IPODDEBEGINFO(L"POSTMSG:: VWM_SERVER_SRC_CLOSE IPC_ID_IPOD"); //} //exit(11); //if(g_pDlg != NULL) //{ // //g_pDlg->OnIpodRemove(); //} ////PostQuitMessage(10); //g_bInsert = false; } break; case IPOD_INSERT: { g_bInsert = true; if(g_pDlg != NULL) { //g_pDlg->OnIpodreInsert(); } } break; } } switch (message) { case VWM_SETUP_CHANGE_THEME: { IPODDEBEGINFO(L"VWM_SETUP_CHANGE_THEME:wparam = %d,lparam = %d",wParam,lParam); g_SetupSetting.cThemeMode = wParam; ::PostMessage(CEIPC_GetHWND(IPC_ID_MANAGE),VWM_SERVER_CHANGE_THEME_OK,NULL,NULL); SetCurThemeMode(g_SetupSetting.cThemeMode); UI_TranslateMsg(KMSG_WND_ACTIVE,NULL,NULL,false); } break; case VWM_SERVER_KET_BTN: { IPODDEBEGINFO(L"VWM_SERVER_KET_BTN:wparam = %d,lparam = %d",wParam,lParam); if(g_pDlg != NULL && g_bInsert) { switch (lParam) { case eKEY_DOWN: { if(g_pDlg->IsIpodConnect()) { g_pDlg->OnForward(NULL); } } break; case eKEY_UP: { if(g_pDlg->IsIpodConnect()) { g_pDlg->OnBack(NULL); } } break; case eKEY_PLAY_CONTROL: { switch (wParam) { case 0: { } break; case 1: { if(g_pDlg->IsIpodConnect()) { //g_pDlg->OnFF(NULL); } } break; case 2: { if(g_pDlg->IsIpodConnect()) { //g_pDlg->OnStartRew(NULL); } } break; } } } } } break; case VWM_SERVER_RESUME_AV: { IPODDEBEGINFO(L"VWM_SERVER_RESUME_AV:lparam = %d",lParam); bool bReady = g_pDlg->IsIpodConnect(); if( g_bInsert) { IPODDEBEGINFO(L"222222222222222222"); switch (lParam) { case 0: { //bool bReady = g_pDlg->WaitForIpodReady(5000); if(bReady) { g_pDlg->StartPlayIpodMusic(); } } break; case 1: { //bool bReady = g_pDlg->WaitForIpodReady(5000); if(bReady) { g_pDlg->PauseIpodMusic(); } } break; } } IPODDEBEGINFO(L"__________11111"); } break; //case VWM_IPOD_BACKGROUND://ipod进程前后台切换 wParam 0:由前台切换为后台运行 1:后台切换为前台运行 // { // if(g_pDlg != NULL) // { // switch (wParam) // { // case 0: // { // g_pDlg->RunInBackground(true); // } // break; // case 1: // { // g_pDlg->RunInBackground(false); // } // break; // default: // break; // } // } // } // break; case WM_USER + 1://串口数据 { } break; case WM_USER + 2://Ipod是否插入,wparam;0 未插入 1:已插入 { HINT nstate = (HINT)(wParam); if(g_pDlg != NULL) { bool bResult = false; if(nstate == 1) { IPODDEBEGINFO(L"33333Ipod已插入"); if(s_nPlugIn == 1) { bResult = g_pDlg->ConectAndStartPlay(); } if(bResult) { /*UINT nretTime = SetTimer(g_hWnd,100,1000,UpDataMusicInfo); if(nretTime == 0) { IPODDEBEGINFO(L"SetTimer error: %d",GetLastError()); }*/ } } else { IPODDEBEGINFO(L"33333Ipod已拔出"); //KillTimer(g_hWnd,100); // g_pDlg->ClearIpodData(); } } } break; case WM_USER + 3: { if(g_pDlg != NULL) { g_pDlg->UpDataMediaInfo(); } } break; case WM_USER + 4: { IPODDEBEGINFO(L"g_bInsert = %d",g_bInsert); if(g_pDlg != NULL && g_bInsert) { g_pDlg->IpodListsAddItem((HCListItem*)wParam,lParam); IPODDEBEGINFO(L"IpodListsAddItem:HCListItem = %d,lParam = %d",wParam,lParam); } } break; case WM_USER + 5: { IPODDEBEGINFO(L"Ipod重新插入"); if(g_pDlg != NULL) { } } break; case WM_USER + 6: { IPODDEBEGINFO(L"Ipod断开"); if(g_pDlg != NULL) { g_pDlg->ClearIpodData(); } } break; case WM_USER + 7://演唱者照片跟新 { IPODDEBEGINFO(L"演唱者照片跟新,wparam = %d",wParam); HINT nn = (HINT)wParam; if(g_pDlg != NULL && g_bInsert) { printf("演唱者照片跟新+++++++++\r\n"); // g_pDlg->UpdataArteistPic(wParam); } } break; case WM_USER +8://读取数据超时 { CEIPC_UnRegist(); HWND hServerWnd = ::FindWindow(STR_PROCESSNAME_MANAGE, STR_PROCESSNAME_MANAGE); if (hServerWnd) { ::PostMessage(hServerWnd, VWM_SERVER_SRC_CLOSE, IPC_ID_IPOD, NULL); IPODDEBEGINFO(L"+++++++POSTMSG:: VWM_SERVER_SRC_CLOSE IPC_ID_IPOD"); } exit(11); } break; case WM_USER + 9: { CEIPC_UnRegist(); HWND hServerWnd = ::FindWindow(STR_PROCESSNAME_MANAGE, STR_PROCESSNAME_MANAGE); if (hServerWnd) { ::PostMessage(hServerWnd, VWM_SERVER_SRC_CLOSE, IPC_ID_IPOD, NULL); IPODDEBEGINFO(L"++++111111++++POSTMSG:: VWM_SERVER_SRC_CLOSE IPC_ID_IPOD"); } exit(11); } break; case WM_USER + 10://Repeat图标更新 { bool bReady = g_pDlg->IsIpodConnect(); if(g_pDlg != NULL && bReady) { g_pDlg->UpdataRepeatIcon(ipodctlREPEAT(wParam)); } } break; case WM_USER + 11://Shffle图标跟新 { bool bReady = g_pDlg->IsIpodConnect(); if(g_pDlg != NULL && bReady) { g_pDlg->UpdataShuffleIcon(ipodctlSHUFFLE(wParam)); } } break; case WM_USER + 12: { bool bReady = g_pDlg->IsIpodConnect(); if(g_pDlg != NULL && bReady) { sPlayTime *pPlayTime = (sPlayTime*)(wParam); if(pPlayTime != NULL) { g_pDlg->UpdataPlayingTime(pPlayTime->nPostionTime,pPlayTime->nTotalTime); SAFE_DELETE(pPlayTime); } } } break; case WM_USER + 13: { bool bReady = g_pDlg->IsIpodConnect(); if(g_pDlg != NULL && bReady) { g_pDlg->UpdataSongInfo(wParam); } } break; case WM_USER + 14: { bool bReady = g_pDlg->IsIpodConnect(); if(g_pDlg != NULL && bReady) { g_pDlg->UpdataPlayPauseIcon((ipodctlPLAYSTATUS)wParam); } } break; case WM_USER +15: { IPODDEBEGINFO(L"ShowLoadDataFailed!!!!"); bool bReady = g_pDlg->IsIpodConnect(); if(g_pDlg != NULL && bReady) { g_pDlg->HideIpodPopUP(); } } break; case WM_USER + 16: { IPODDEBEGINFO(L"ShowLoadDataFailed!!!!"); if(g_pDlg != NULL) { g_pDlg->ShowLoadDataFailed(); } } break; case WM_USER + 17: { IPODDEBEGINFO(L"Updata songInfo!!!!"); bool bReady = g_pDlg->IsIpodConnect(); if(g_pDlg != NULL && bReady) { if(wParam != NULL) { sSongInfo *p = (sSongInfo*)wParam; if(p != NULL && s_pSong != NULL) { memcpy(s_pSong,p,sizeof(sSongInfo)); g_pDlg->UpdataTrackInfo(s_pSong); } } } } break; default: { UI_TranslateMsg(message, wParam, lParam, false); } break; } return DefWindowProcW(hWnd, message, wParam, lParam); }
static LRESULT WINAPI StatusWindowProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { STATUS_INFO *infoPtr = (STATUS_INFO *)GetWindowLongPtrW (hwnd, 0); INT nPart = ((INT) wParam) & 0x00ff; LRESULT res; TRACE("hwnd=%p msg=%x wparam=%lx lparam=%lx\n", hwnd, msg, wParam, lParam); if (!infoPtr && msg != WM_CREATE) return DefWindowProcW (hwnd, msg, wParam, lParam); switch (msg) { case SB_GETBORDERS: return STATUSBAR_GetBorders (infoPtr, (INT *)lParam); case SB_GETICON: return (LRESULT)STATUSBAR_GetIcon (infoPtr, nPart); case SB_GETPARTS: return STATUSBAR_GetParts (infoPtr, (INT)wParam, (INT *)lParam); case SB_GETRECT: return STATUSBAR_GetRect (infoPtr, nPart, (LPRECT)lParam); case SB_GETTEXTA: return STATUSBAR_GetTextA (infoPtr, nPart, (LPSTR)lParam); case SB_GETTEXTW: return STATUSBAR_GetTextW (infoPtr, nPart, (LPWSTR)lParam); case SB_GETTEXTLENGTHA: case SB_GETTEXTLENGTHW: return STATUSBAR_GetTextLength (infoPtr, nPart); case SB_GETTIPTEXTA: return STATUSBAR_GetTipTextA (infoPtr, LOWORD(wParam), (LPSTR)lParam, HIWORD(wParam)); case SB_GETTIPTEXTW: return STATUSBAR_GetTipTextW (infoPtr, LOWORD(wParam), (LPWSTR)lParam, HIWORD(wParam)); case SB_GETUNICODEFORMAT: return infoPtr->bUnicode; case SB_ISSIMPLE: return infoPtr->simple; case SB_SETBORDERS: return STATUSBAR_SetBorders (infoPtr, (INT *)lParam); case SB_SETBKCOLOR: return STATUSBAR_SetBkColor (infoPtr, (COLORREF)lParam); case SB_SETICON: return STATUSBAR_SetIcon (infoPtr, nPart, (HICON)lParam); case SB_SETMINHEIGHT: return STATUSBAR_SetMinHeight (infoPtr, (INT)wParam); case SB_SETPARTS: return STATUSBAR_SetParts (infoPtr, (INT)wParam, (LPINT)lParam); case SB_SETTEXTA: return STATUSBAR_SetTextT (infoPtr, nPart, wParam & 0xff00, (LPWSTR)lParam, FALSE); case SB_SETTEXTW: return STATUSBAR_SetTextT (infoPtr, nPart, wParam & 0xff00, (LPWSTR)lParam, TRUE); case SB_SETTIPTEXTA: return STATUSBAR_SetTipTextA (infoPtr, (INT)wParam, (LPSTR)lParam); case SB_SETTIPTEXTW: return STATUSBAR_SetTipTextW (infoPtr, (INT)wParam, (LPWSTR)lParam); case SB_SETUNICODEFORMAT: return STATUSBAR_SetUnicodeFormat (infoPtr, (BOOL)wParam); case SB_SIMPLE: return STATUSBAR_Simple (infoPtr, (BOOL)wParam); case WM_CREATE: return STATUSBAR_WMCreate (hwnd, (LPCREATESTRUCTA)lParam); case WM_DESTROY: return STATUSBAR_WMDestroy (infoPtr); case WM_GETFONT: return (LRESULT)(infoPtr->hFont? infoPtr->hFont : infoPtr->hDefaultFont); case WM_GETTEXT: return STATUSBAR_WMGetText (infoPtr, (INT)wParam, (LPWSTR)lParam); case WM_GETTEXTLENGTH: return LOWORD(STATUSBAR_GetTextLength (infoPtr, 0)); case WM_LBUTTONDBLCLK: return STATUSBAR_SendMouseNotify(infoPtr, NM_DBLCLK, msg, wParam, lParam); case WM_LBUTTONUP: return STATUSBAR_SendMouseNotify(infoPtr, NM_CLICK, msg, wParam, lParam); case WM_MOUSEMOVE: return STATUSBAR_Relay2Tip (infoPtr, msg, wParam, lParam); case WM_NCHITTEST: res = STATUSBAR_WMNCHitTest(infoPtr, (short)LOWORD(lParam), (short)HIWORD(lParam)); if (res != HTERROR) return res; return DefWindowProcW (hwnd, msg, wParam, lParam); case WM_NCLBUTTONUP: case WM_NCLBUTTONDOWN: PostMessageW (infoPtr->Notify, msg, wParam, lParam); return 0; case WM_NOTIFYFORMAT: return STATUSBAR_NotifyFormat(infoPtr, (HWND)wParam, (INT)lParam); case WM_PRINTCLIENT: case WM_PAINT: return STATUSBAR_WMPaint (infoPtr, (HDC)wParam); case WM_RBUTTONDBLCLK: return STATUSBAR_SendMouseNotify(infoPtr, NM_RDBLCLK, msg, wParam, lParam); case WM_RBUTTONUP: return STATUSBAR_SendMouseNotify(infoPtr, NM_RCLICK, msg, wParam, lParam); case WM_SETFONT: return STATUSBAR_WMSetFont (infoPtr, (HFONT)wParam, LOWORD(lParam)); case WM_SETTEXT: return STATUSBAR_WMSetText (infoPtr, (LPCSTR)lParam); case WM_SIZE: if (STATUSBAR_WMSize (infoPtr, (WORD)wParam)) return 0; return DefWindowProcW (hwnd, msg, wParam, lParam); case WM_SYSCOLORCHANGE: COMCTL32_RefreshSysColors(); return 0; case WM_THEMECHANGED: return theme_changed (infoPtr); default: if ((msg >= WM_USER) && (msg < WM_APP) && !COMCTL32_IsReflectedMessage(msg)) ERR("unknown msg %04x wp=%04lx lp=%08lx\n", msg, wParam, lParam); return DefWindowProcW (hwnd, msg, wParam, lParam); } }
static LRESULT CALLBACK GraphicsWindow_WndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam ) { CHECKPOINT_M( ssprintf("%p, %u, %08x, %08x", hWnd, msg, wParam, lParam) ); // Suppress autorun. if( msg == g_iQueryCancelAutoPlayMessage ) return true; switch( msg ) { case WM_ACTIVATE: { const bool bInactive = (LOWORD(wParam) == WA_INACTIVE); const bool bMinimized = (HIWORD(wParam) != 0); const bool bHadFocus = g_bHasFocus; g_bHasFocus = !bInactive && !bMinimized; LOG->Trace( "WM_ACTIVATE (%i, %i): %s", bInactive, bMinimized, g_bHasFocus? "has focus":"doesn't have focus" ); if( !g_bHasFocus ) { RString sName = GetNewWindow(); static set<RString> sLostFocusTo; sLostFocusTo.insert( sName ); RString sStr; for( set<RString>::const_iterator it = sLostFocusTo.begin(); it != sLostFocusTo.end(); ++it ) sStr += (sStr.size()?", ":"") + *it; LOG->MapLog( "LOST_FOCUS", "Lost focus to: %s", sStr.c_str() ); } if( !g_bD3D && !g_CurrentParams.windowed && !g_bRecreatingVideoMode ) { /* In OpenGL (not D3D), it's our job to unset and reset the * full-screen video mode when we focus changes, and to hide * and show the window. Hiding is done in WM_KILLFOCUS, * because that's where most other apps seem to do it. */ if( g_bHasFocus && !bHadFocus ) { ChangeDisplaySettings( &g_FullScreenDevMode, CDS_FULLSCREEN ); ShowWindow( g_hWndMain, SW_SHOWNORMAL ); } else if( !g_bHasFocus && bHadFocus ) { ChangeDisplaySettings( NULL, 0 ); } } return 0; } case WM_KILLFOCUS: if( !g_bD3D && !g_CurrentParams.windowed && !g_bRecreatingVideoMode ) ShowWindow( g_hWndMain, SW_SHOWMINNOACTIVE ); break; /* Is there any reason we should care what size the user resizes * the window to? (who? -aj) * Short answer: yes. -aj */ // case WM_GETMINMAXINFO: case WM_SETCURSOR: if( !g_CurrentParams.windowed ) { SetCursor( NULL ); return 1; } break; case WM_SYSCOMMAND: switch( wParam&0xFFF0 ) { case SC_MONITORPOWER: case SC_SCREENSAVE: return 0; } break; case WM_PAINT: { PAINTSTRUCT ps; BeginPaint( hWnd, &ps ); EndPaint( hWnd, &ps ); break; } case WM_KEYDOWN: case WM_KEYUP: case WM_SYSKEYDOWN: case WM_SYSKEYUP: case WM_MOUSEWHEEL: // might want to use this for GET_WHEEL_DELTA_WPARAM(wParam) -aj // We handle all input ourself, via DirectInput. return 0; case WM_CLOSE: LOG->Trace("WM_CLOSE: shutting down"); ArchHooks::SetUserQuit(); return 0; case WM_WINDOWPOSCHANGED: { /* If we're fullscreen and don't have focus, our window is hidden, * so GetClientRect isn't meaningful. */ if( !g_CurrentParams.windowed && !g_bHasFocus ) break; RECT rect; GetClientRect( hWnd, &rect ); int iWidth = rect.right - rect.left; int iHeight = rect.bottom - rect.top; if( g_CurrentParams.width != iWidth || g_CurrentParams.height != iHeight ) { g_CurrentParams.width = iWidth; g_CurrentParams.height = iHeight; g_bResolutionChanged = true; } break; } case WM_COPYDATA: { PCOPYDATASTRUCT pMyCDS = (PCOPYDATASTRUCT) lParam; RString sCommandLine( (char*)pMyCDS->lpData, pMyCDS->cbData ); CommandLineActions::CommandLineArgs args; split( sCommandLine, "|", args.argv, false ); CommandLineActions::ToProcess.push_back( args ); break; } } CHECKPOINT_M( ssprintf("%p, %u, %08x, %08x", hWnd, msg, wParam, lParam) ); if( m_bWideWindowClass ) return DefWindowProcW( hWnd, msg, wParam, lParam ); else return DefWindowProcA( hWnd, msg, wParam, lParam ); }