// ---------------------------------------------------------------------------
// the window proc for all our windows
-#ifdef __DIGITALMARS__
-extern "C" LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message,
- WPARAM wParam, LPARAM lParam);
-#else
LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam);
-#endif
-
+
#ifdef __WXDEBUG__
const char *wxGetMessageName(int message);
#endif //__WXDEBUG__
void wxRemoveHandleAssociation(wxWindowMSW *win);
-#ifdef __DIGITALMARS__
-extern "C" void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win);
-#else
extern void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win);
-#endif
wxWindow *wxFindWinFromHandle(WXHWND hWnd);
// this magical function is used to translate VK_APPS key presses to right
EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground)
EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged)
EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog)
- EVT_IDLE(wxWindowMSW::OnIdle)
END_EVENT_TABLE()
// ===========================================================================
// MSW specific
m_isBeingDeleted = FALSE;
m_oldWndProc = NULL;
- m_useCtl3D = FALSE;
m_mouseInWindow = FALSE;
m_lastKeydownProcessed = FALSE;
m_xThumbSize = 0;
m_yThumbSize = 0;
- m_backgroundTransparent = FALSE;
// as all windows are created with WS_VISIBLE style...
m_isShown = TRUE;
void wxWindowMSW::SetFocusFromKbd()
{
- wxWindowBase::SetFocusFromKbd();
-
// when the focus is given to the control with DLGC_HASSETSEL style from
// keyboard its contents should be entirely selected: this is what
// ::IsDialogMessage() does and so we should do it as well to provide the
{
::SendMessage(GetHwnd(), EM_SETSEL, 0, -1);
}
+
+ // do this after (maybe) setting the selection as like this when
+ // wxEVT_SET_FOCUS handler is called, the selection would have been already
+ // set correctly -- this may be important
+ wxWindowBase::SetFocusFromKbd();
}
// Get the window with the focus
info.nMin = 0;
info.nPos = pos;
info.fMask = SIF_POS;
+ if ( HasFlag(wxALWAYS_SHOW_SB) )
+ {
+ // disable scrollbar instead of removing it then
+ info.fMask |= SIF_DISABLENOSCROLL;
+ }
::SetScrollInfo(hWnd, orient == wxHORIZONTAL ? SB_HORZ : SB_VERT,
&info, refresh);
info.nMax = range - 1; // as both nMax and nMax are inclusive
info.nPos = pos;
info.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
+ if ( HasFlag(wxALWAYS_SHOW_SB) )
+ {
+ // disable scrollbar instead of removing it then
+ info.fMask |= SIF_DISABLENOSCROLL;
+ }
HWND hWnd = GetHwnd();
if ( hWnd )
if ( flags & wxHSCROLL )
style |= WS_HSCROLL;
- wxBorder border = (wxBorder)(flags & wxBORDER_MASK);
-
- // Check if we want to automatically give it a sunken style.
- // Note than because 'sunken' actually maps to WS_EX_CLIENTEDGE, which
- // is a more neutral term, we don't necessarily get a sunken effect in
- // Windows XP. Instead we get the appropriate style for the theme.
-
- if (border == wxBORDER_DEFAULT && wxTheApp->GetAuto3D() &&
- IsKindOf(CLASSINFO(wxControl)) &&
- GetParent() && (GetParent()->IsKindOf(CLASSINFO(wxPanel)) ||
- GetParent()->IsKindOf(CLASSINFO(wxDialog))) &&
- ((GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS) != wxUSER_COLOURS))
- {
- border = (wxBorder)((flags & wxBORDER_MASK) | wxBORDER_SUNKEN);
- }
-
- // Only give it WS_BORDER for wxBORDER_SIMPLE
- if (border & wxBORDER_SIMPLE)
+ const wxBorder border = GetBorder(flags);
+
+ // WS_BORDER is only required for wxBORDER_SIMPLE
+ if ( border == wxBORDER_SIMPLE )
style |= WS_BORDER;
-
+
// now deal with ext style if the caller wants it
if ( exstyle )
{
switch ( border )
{
default:
+ case wxBORDER_DEFAULT:
wxFAIL_MSG( _T("unknown border style") );
// fall through
case wxBORDER_NONE:
case wxBORDER_SIMPLE:
- case wxBORDER_DEFAULT:
break;
case wxBORDER_STATIC:
return hwnd != NULL;
}
-void wxWindowMSW::OnIdle(wxIdleEvent& WXUNUSED(event))
+void wxWindowMSW::OnInternalIdle()
{
// Check if we need to send a LEAVE event
if ( m_mouseInWindow )
m_mouseInWindow = FALSE;
// Unfortunately the mouse button and keyboard state may have
- // changed by the time the OnIdle function is called, so 'state'
+ // changed by the time the OnInternalIdle function is called, so 'state'
// may be meaningless.
int state = 0;
if ( wxIsShiftDown() )
}
}
- UpdateWindowUI();
+ if (wxUpdateUIEvent::CanUpdate(this))
+ UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
}
// Set this window to be the child of 'parent'.
wxLogLastError(_T("UpdateWindow"));
}
-#if defined(__WIN32__) && !defined(__WXMICROWIN__)
+#if !defined(__WXMICROWIN__)
// just calling UpdateWindow() is not enough, what we did in our WM_PAINT
// handler needs to be really drawn right now
(void)::GdiFlush();
long wxWindowMSW::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
{
if ( m_oldWndProc )
-#ifdef __DIGITALMARS__
- return ::CallWindowProc( (FARPROC) m_oldWndProc, GetHwnd(), (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam);
-#else
return ::CallWindowProc(CASTWNDPROC m_oldWndProc, GetHwnd(), (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam);
-#endif
else
return ::DefWindowProc(GetHwnd(), nMsg, wParam, lParam);
}
// place edit control from being closed with Escape in a dialog
if ( msg->message != WM_KEYDOWN || msg->wParam != VK_ESCAPE )
{
- // ::IsDialogMessage() can enter in an infinite loop when the
- // currently focused window is disabled or hidden and its parent
- // has WS_EX_CONTROLPARENT style, so don't call it in this case
+ // ::IsDialogMessage() is broken and may sometimes hang the
+ // application by going into an infinite loop, so we try to detect
+ // [some of] the situatations when this may happen and not call it
+ // then
+
+ // assume we can call it by default
bool canSafelyCallIsDlgMsg = TRUE;
HWND hwndFocus = ::GetFocus();
- while ( hwndFocus )
+
+ // if the currently focused window itself has WS_EX_CONTROLPARENT style, ::IsDialogMessage() will also enter
+ // an infinite loop, because it will recursively check the child
+ // windows but not the window itself and so if none of the children
+ // accepts focus it loops forever (as it only stops when it gets
+ // back to the window it started from)
+ //
+ // while it is very unusual that a window with WS_EX_CONTROLPARENT
+ // style has the focus, it can happen. One such possibility is if
+ // all windows are either toplevel, wxDialog, wxPanel or static
+ // controls and no window can actually accept keyboard input.
+ if ( ::GetWindowLong(hwndFocus, GWL_EXSTYLE) & WS_EX_CONTROLPARENT )
{
- if ( !::IsWindowEnabled(hwndFocus) ||
- !::IsWindowVisible(hwndFocus) )
+ // passimistic by default
+ canSafelyCallIsDlgMsg = FALSE;
+ for ( wxWindowList::Node *node = GetChildren().GetFirst();
+ node;
+ node = node->GetNext() )
{
- // it would enter an infinite loop if we do this!
- canSafelyCallIsDlgMsg = FALSE;
+ if ( node->GetData()->AcceptsFocus() )
+ {
+ // it shouldn't hang...
+ canSafelyCallIsDlgMsg = TRUE;
- break;
+ break;
+ }
}
+ }
- if ( !(::GetWindowLong(hwndFocus, GWL_STYLE) & WS_CHILD) )
+ if ( canSafelyCallIsDlgMsg )
+ {
+ // ::IsDialogMessage() can enter in an infinite loop when the
+ // currently focused window is disabled or hidden and its
+ // parent has WS_EX_CONTROLPARENT style, so don't call it in
+ // this case
+ while ( hwndFocus )
{
- // it's a top level window, don't go further -- e.g. even
- // if the parent of a dialog is disabled, this doesn't
- // break navigation inside the dialog
- break;
- }
+ if ( !::IsWindowEnabled(hwndFocus) ||
+ !::IsWindowVisible(hwndFocus) )
+ {
+ // it would enter an infinite loop if we do this!
+ canSafelyCallIsDlgMsg = FALSE;
+
+ break;
+ }
+
+ if ( !(::GetWindowLong(hwndFocus, GWL_STYLE) & WS_CHILD) )
+ {
+ // it's a top level window, don't go further -- e.g. even
+ // if the parent of a dialog is disabled, this doesn't
+ // break navigation inside the dialog
+ break;
+ }
- hwndFocus = ::GetParent(hwndFocus);
+ hwndFocus = ::GetParent(hwndFocus);
+ }
}
+ // let IsDialogMessage() have the message if it's safe to call it
if ( canSafelyCallIsDlgMsg && ::IsDialogMessage(GetHwnd(), msg) )
{
// IsDialogMessage() did something...
}
// ---------------------------------------------------------------------------
-// message params unpackers (different for Win16 and Win32)
+// message params unpackers
// ---------------------------------------------------------------------------
-#ifdef __WIN32__
-
void wxWindowMSW::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
WORD *id, WXHWND *hwnd, WORD *cmd)
{
*hmenu = (WXHMENU)lParam;
}
-#else // Win16
-
-void wxWindowMSW::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
- WXWORD *id, WXHWND *hwnd, WXWORD *cmd)
-{
- *id = (WXWORD)wParam;
- *hwnd = (WXHWND)LOWORD(lParam);
- *cmd = HIWORD(lParam);
-}
-
-void wxWindowMSW::UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
- WXWORD *state, WXWORD *minimized, WXHWND *hwnd)
-{
- *state = (WXWORD)wParam;
- *minimized = LOWORD(lParam);
- *hwnd = (WXHWND)HIWORD(lParam);
-}
-
-void wxWindowMSW::UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
- WXWORD *code, WXWORD *pos, WXHWND *hwnd)
-{
- *code = (WXWORD)wParam;
- *pos = LOWORD(lParam);
- *hwnd = (WXHWND)HIWORD(lParam);
-}
-
-void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
- WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd)
-{
- *hwnd = (WXHWND)LOWORD(lParam);
- *nCtlColor = (int)HIWORD(lParam);
- *hdc = (WXHDC)wParam;
-}
-
-void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
- WXWORD *item, WXWORD *flags, WXHMENU *hmenu)
-{
- *item = (WXWORD)wParam;
- *flags = LOWORD(lParam);
- *hmenu = (WXHMENU)HIWORD(lParam);
-}
-
-#endif // Win32/16
-
// ---------------------------------------------------------------------------
// Main wxWindows window proc and the window proc for wxWindow
// ---------------------------------------------------------------------------
{
// trace all messages - useful for the debugging
#ifdef __WXDEBUG__
-#if wxUSE_LOG
- wxLogTrace(wxTraceMessages, wxT("Processing %s(wParam=%8lx, lParam=%8lx)"),
- wxGetMessageName(message), (long) wParam, lParam);
-#endif // wxUSE_LOG
+ wxLogTrace(wxTraceMessages,
+ wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
+ wxGetMessageName(message), (long)hWnd, (long)wParam, lParam);
#endif // __WXDEBUG__
wxWindowMSW *wnd = wxFindWinFromHandle((WXHWND) hWnd);
break;
case WM_MOVING:
- {
- LPRECT pRect = (LPRECT)lParam;
- wxRect rc;
- rc.SetLeft(pRect->left);
- rc.SetTop(pRect->top);
- rc.SetRight(pRect->right);
- rc.SetBottom(pRect->bottom);
- processed = HandleMoving(rc);
- if (processed) {
- pRect->left = rc.GetLeft();
- pRect->top = rc.GetTop();
- pRect->right = rc.GetRight();
- pRect->bottom = rc.GetBottom();
- }
- }
+ {
+ LPRECT pRect = (LPRECT)lParam;
+ wxRect rc;
+ rc.SetLeft(pRect->left);
+ rc.SetTop(pRect->top);
+ rc.SetRight(pRect->right);
+ rc.SetBottom(pRect->bottom);
+ processed = HandleMoving(rc);
+ if (processed) {
+ pRect->left = rc.GetLeft();
+ pRect->top = rc.GetTop();
+ pRect->right = rc.GetRight();
+ pRect->bottom = rc.GetBottom();
+ }
+ }
break;
case WM_SIZE:
}
break;
+#if wxUSE_HOTKEY
+ case WM_HOTKEY:
+ processed = HandleHotKey((WORD)wParam, lParam);
+ break;
+#endif // wxUSE_HOTKEY
+
case WM_HSCROLL:
case WM_VSCROLL:
{
// CTLCOLOR messages are sent by children to query the parent for their
// colors#ifndef __WXMICROWIN__
#ifndef __WXMICROWIN__
-#ifdef __WIN32__
case WM_CTLCOLORMSGBOX:
case WM_CTLCOLOREDIT:
case WM_CTLCOLORLISTBOX:
case WM_CTLCOLORDLG:
case WM_CTLCOLORSCROLLBAR:
case WM_CTLCOLORSTATIC:
-#else // Win16
- case WM_CTLCOLOR:
-#endif // Win32/16
{
WXWORD nCtlColor;
WXHDC hdc;
}
#endif
-#if defined(__WIN32__) && defined(WM_HELP)
+#if defined(WM_HELP)
case WM_HELP:
{
HELPINFO* info = (HELPINFO*) lParam;
}
}
break;
-#endif // __WIN32__
+#endif
}
if ( !processed )
{
#ifdef __WXDEBUG__
-#if wxUSE_LOG
wxLogTrace(wxTraceMessages, wxT("Forwarding %s to DefWindowProc."),
wxGetMessageName(message));
-#endif // wxUSE_LOG
#endif // __WXDEBUG__
rc.result = MSWDefWindowProc(message, wParam, lParam);
}
(
extendedStyle,
className,
- title ? title : wxT(""),
+ title ? title : wxEmptyString,
style,
x, y, w, h,
(HWND)MSWGetParent(),
bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam)
{
-#if defined (__WXMICROWIN__)
+#if defined (__WXMICROWIN__)
return FALSE;
#else // __WXMICROWIN__
HDROP hFilesInfo = (HDROP) wParam;
#endif
}
-#ifdef __DIGITALMARS__
-extern "C" HCURSOR wxGetCurrentBusyCursor();
-#endif
bool wxWindowMSW::HandleSetCursor(WXHWND WXUNUSED(hWnd),
short nHitTest,
// first ask the user code - it may wish to set the cursor in some very
// specific way (for example, depending on the current position)
POINT pt;
-#ifdef __WIN32__
if ( !::GetCursorPos(&pt) )
{
wxLogLastError(wxT("GetCursorPos"));
}
-#else
- // In WIN16 it doesn't return a value.
- ::GetCursorPos(&pt);
-#endif
int x = pt.x,
y = pt.y;
#if wxUSE_CONTROLS
- wxWindow *item = FindItem(id);
#if wxUSE_OWNER_DRAWN
+ wxWindow *item = FindItem(id);
if ( item && item->IsKindOf(CLASSINFO(wxControl)) )
return ((wxControl *)item)->MSWOnDraw(itemStruct);
-#else
+#elif !defined(__WXUNIVERSAL__)
+ // we may still have owner-drawn buttons internally because we have to make
+ // them owner-drawn to support colour change
+ wxWindow *item = FindItem(id);
if ( item && item->IsKindOf(CLASSINFO(wxButton)) )
return ((wxButton *)item)->MSWOnDraw(itemStruct);
#endif // USE_OWNER_DRAWN
{
// if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
// return FALSE;
-
-#ifdef __WIN32__
+
HRGN hRegion = ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
if ( !hRegion )
wxLogLastError(wxT("CreateRectRgn"));
wxLogLastError(wxT("GetUpdateRgn"));
m_updateRegion = wxRegion((WXHRGN) hRegion);
-#else // Win16
- RECT updateRect;
- ::GetUpdateRect(GetHwnd(), &updateRect, FALSE);
-
- m_updateRegion = wxRegion(updateRect.left, updateRect.top,
- updateRect.right - updateRect.left,
- updateRect.bottom - updateRect.top);
-#endif // Win32/16
wxPaintEvent event(m_windowId);
event.SetEventObject(this);
}
}
#endif
-
+
wxDCTemp dc(hdc);
dc.SetHDC(hdc);
{
wxMoveEvent event(rect, m_windowId);
event.SetEventObject(this);
-
+
bool rc = GetEventHandler()->ProcessEvent(event);
if (rc)
rect = event.GetRect();
{
wxSizeEvent event(rect, m_windowId);
event.SetEventObject(this);
-
+
bool rc = GetEventHandler()->ProcessEvent(event);
if (rc)
rect = event.GetRect();
HWND hwnd = GetHwndOf(win),
hwndUnderMouse;
-#ifdef __WIN32__
hwndUnderMouse = ::ChildWindowFromPointEx
(
hwnd,
);
if ( !hwndUnderMouse || hwndUnderMouse == hwnd )
-#endif // __WIN32__
{
// now try any child window at all
hwndUnderMouse = ::ChildWindowFromPoint(hwnd, pt);
event.m_wheelRotation = (short)HIWORD(wParam);
event.m_wheelDelta = WHEEL_DELTA;
-#ifdef __WIN32__
static int s_linesPerRotation = -1;
if ( s_linesPerRotation == -1 )
{
s_linesPerRotation = 3;
}
}
-#else // Win16
- // no SystemParametersInfo() under Win16
- static const int s_linesPerRotation = 3;
-#endif
event.m_linesPerAction = s_linesPerRotation;
return GetEventHandler()->ProcessEvent(event);
return FALSE;
}
-#ifdef __WIN32__
-
int wxWindowMSW::HandleMenuChar(int chAccel, WXLPARAM lParam)
{
const HMENU hmenu = (HMENU)lParam;
}
}
}
- else // failed ot get the menu text?
+ else // failed to get the menu text?
{
// it's not fatal, so don't show error, but still log
// it
return wxNOT_FOUND;
}
-#endif // __WIN32__
-
// ---------------------------------------------------------------------------
// joystick
// ---------------------------------------------------------------------------
case SB_THUMBPOSITION:
case SB_THUMBTRACK:
-#ifdef __WIN32__
// under Win32, the scrollbar range and position are 32 bit integers,
// but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
// explicitly query the scrollbar for the correct position (this must
event.SetPosition(scrollInfo.nTrackPos);
}
-#endif // Win32
event.m_eventType = wParam == SB_THUMBPOSITION
? wxEVT_SCROLLWIN_THUMBRELEASE
win = wxFindWinFromHandle((WXHWND)hwnd);
if ( !win )
{
- // all these hacks only work under Win32 anyhow
-#ifdef __WIN32__
-
#if wxUSE_RADIOBOX
// native radiobuttons return DLGC_RADIOBUTTON here and for any
// wxWindow class which overrides WM_GETDLGCODE processing to
win = wxSpinCtrl::GetSpinForTextCtrl((WXHWND)hwnd);
}
#endif // wxUSE_SPINCTRL
-
-#endif // Win32
}
}
wxTheKeyboardHookProc = MakeProcInstance((FARPROC) wxKeyboardHook, wxGetInstance());
wxTheKeyboardHook = SetWindowsHookEx(WH_KEYBOARD, (HOOKPROC) wxTheKeyboardHookProc, wxGetInstance(),
-#if defined(__WIN32__)
GetCurrentThreadId()
// (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
-#else
- GetCurrentTask()
-#endif
);
}
else
{
UnhookWindowsHookEx(wxTheKeyboardHook);
-
- // avoids warning about statement with no effect (FreeProcInstance
- // doesn't do anything under Win32)
-#if !defined(__WIN32__) && !defined(__NT__)
- FreeProcInstance(wxTheKeyboardHookProc);
-#endif
}
}
case 0x0047: return "WM_WINDOWPOSCHANGED";
case 0x0048: return "WM_POWER";
-#ifdef __WIN32__
case 0x004A: return "WM_COPYDATA";
case 0x004B: return "WM_CANCELJOURNAL";
case 0x004E: return "WM_NOTIFY";
case 0x007E: return "WM_DISPLAYCHANGE";
case 0x007F: return "WM_GETICON";
case 0x0080: return "WM_SETICON";
-#endif //WIN32
case 0x0081: return "WM_NCCREATE";
case 0x0082: return "WM_NCDESTROY";
case 0x0107: return "WM_SYSDEADCHAR";
case 0x0108: return "WM_KEYLAST";
-#ifdef __WIN32__
case 0x010D: return "WM_IME_STARTCOMPOSITION";
case 0x010E: return "WM_IME_ENDCOMPOSITION";
case 0x010F: return "WM_IME_COMPOSITION";
-#endif //WIN32
case 0x0110: return "WM_INITDIALOG";
case 0x0111: return "WM_COMMAND";
case 0x0211: return "WM_ENTERMENULOOP";
case 0x0212: return "WM_EXITMENULOOP";
-#ifdef __WIN32__
case 0x0213: return "WM_NEXTMENU";
case 0x0214: return "WM_SIZING";
case 0x0215: return "WM_CAPTURECHANGED";
case 0x0216: return "WM_MOVING";
case 0x0218: return "WM_POWERBROADCAST";
case 0x0219: return "WM_DEVICECHANGE";
-#endif //WIN32
case 0x0220: return "WM_MDICREATE";
case 0x0221: return "WM_MDIDESTROY";
case 0x0230: return "WM_MDISETMENU";
case 0x0233: return "WM_DROPFILES";
-#ifdef __WIN32__
case 0x0281: return "WM_IME_SETCONTEXT";
case 0x0282: return "WM_IME_NOTIFY";
case 0x0283: return "WM_IME_CONTROL";
case 0x0286: return "WM_IME_CHAR";
case 0x0290: return "WM_IME_KEYDOWN";
case 0x0291: return "WM_IME_KEYUP";
-#endif //WIN32
case 0x0300: return "WM_CUT";
case 0x0301: return "WM_COPY";
case 0x030F: return "WM_QUERYNEWPALETTE";
case 0x0310: return "WM_PALETTEISCHANGING";
case 0x0311: return "WM_PALETTECHANGED";
+#if wxUSE_HOTKEY
+ case 0x0312: return "WM_HOTKEY";
+#endif
-#ifdef __WIN32__
// common controls messages - although they're not strictly speaking
// standard, it's nice to decode them nevertheless
case WM_USER+61: return "TB_GETTEXTROWS";
case WM_USER+41: return "TB_GETBITMAPFLAGS";
-#endif //WIN32
-
default:
static char s_szBuf[128];
sprintf(s_szBuf, "<unknown message = %d>", message);
return wxPoint(pt.x, pt.y);
}
+#if wxUSE_HOTKEY
+
+bool wxWindowMSW::RegisterHotKey(int hotkeyId, int modifiers, int keycode)
+{
+ UINT win_modifiers=0;
+ if ( modifiers & wxMOD_ALT )
+ win_modifiers |= MOD_ALT;
+ if ( modifiers & wxMOD_SHIFT )
+ win_modifiers |= MOD_SHIFT;
+ if ( modifiers & wxMOD_CONTROL )
+ win_modifiers |= MOD_CONTROL;
+ if ( modifiers & wxMOD_WIN )
+ win_modifiers |= MOD_WIN;
+
+ if ( !::RegisterHotKey(GetHwnd(), hotkeyId, win_modifiers, keycode) )
+ {
+ wxLogLastError(_T("RegisterHotKey"));
+
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+bool wxWindowMSW::UnregisterHotKey(int hotkeyId)
+{
+ if ( !::UnregisterHotKey(GetHwnd(), hotkeyId) )
+ {
+ wxLogLastError(_T("UnregisterHotKey"));
+
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+bool wxWindowMSW::HandleHotKey(WXWPARAM wParam, WXLPARAM lParam)
+{
+ int hotkeyId = wParam;
+ int virtualKey = HIWORD(lParam);
+ int win_modifiers = LOWORD(lParam);
+
+ wxKeyEvent event(CreateKeyEvent(wxEVT_HOTKEY, virtualKey, wParam, lParam));
+ event.SetId(hotkeyId);
+ event.m_shiftDown = (win_modifiers & MOD_SHIFT) != 0;
+ event.m_controlDown = (win_modifiers & MOD_CONTROL) != 0;
+ event.m_altDown = (win_modifiers & MOD_ALT) != 0;
+ event.m_metaDown = (win_modifiers & MOD_WIN) != 0;
+
+ return GetEventHandler()->ProcessEvent(event);
+}
+
+#endif // wxUSE_HOTKEY
+
projects / wxWidgets.git / blobdiff