1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: univ/window.cpp
3 // Purpose: implementation of extra wxWindow methods for wxUniv port
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 2000 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows license
10 ///////////////////////////////////////////////////////////////////////////////
12 // ===========================================================================
14 // ===========================================================================
16 // ---------------------------------------------------------------------------
18 // ---------------------------------------------------------------------------
21 #pragma implementation "univwindow.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
33 #include "wx/window.h"
34 #include "wx/dcclient.h"
35 #include "wx/dcmemory.h"
37 #include "wx/scrolbar.h"
42 #include "wx/univ/colschem.h"
43 #include "wx/univ/renderer.h"
44 #include "wx/univ/theme.h"
50 // turn Refresh() debugging on/off
51 #define WXDEBUG_REFRESH
54 #undef WXDEBUG_REFRESH
57 // ============================================================================
59 // ============================================================================
61 // ----------------------------------------------------------------------------
63 // ----------------------------------------------------------------------------
65 // we can't use wxWindowNative here as it won't be expanded inside the macro
66 #if defined(__WXMSW__)
67 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowMSW
)
68 #elif defined(__WXGTK__)
69 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowGTK
)
70 #elif defined(__WXMGL__)
71 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowMGL
)
74 BEGIN_EVENT_TABLE(wxWindow
, wxWindowNative
)
75 EVT_SIZE(wxWindow::OnSize
)
77 #if wxUSE_ACCEL || wxUSE_MENUS
78 EVT_KEY_DOWN(wxWindow::OnKeyDown
)
82 EVT_CHAR(wxWindow::OnChar
)
83 EVT_KEY_UP(wxWindow::OnKeyUp
)
86 EVT_PAINT(wxWindow::OnPaint
)
87 EVT_NC_PAINT(wxWindow::OnNcPaint
)
88 EVT_ERASE_BACKGROUND(wxWindow::OnErase
)
91 // ----------------------------------------------------------------------------
93 // ----------------------------------------------------------------------------
98 m_scrollbarHorz
= (wxScrollBar
*)NULL
;
102 m_renderer
= wxTheme::Get()->GetRenderer();
105 bool wxWindow::Create(wxWindow
*parent
,
110 const wxString
& name
)
112 // we add wxCLIP_CHILDREN and wxNO_FULL_REPAINT_ON_RESIZE because without
113 // these styles we can't get rid of flicker on wxMSW
114 if ( !wxWindowNative::Create(parent
, id
, pos
, size
,
117 wxNO_FULL_REPAINT_ON_RESIZE
, name
) )
122 // if we should always have the scrollbar, do show it
123 if ( GetWindowStyle() & wxALWAYS_SHOW_SB
)
125 m_scrollbarVert
= new wxScrollBar(this, -1,
126 wxDefaultPosition
, wxDefaultSize
,
130 PositionScrollbars();
133 // the colours/fonts are default
141 // ----------------------------------------------------------------------------
143 // ----------------------------------------------------------------------------
145 void wxWindow::SetBackground(const wxBitmap
& bitmap
,
150 m_alignBgBitmap
= alignment
;
151 m_stretchBgBitmap
= stretch
;
154 const wxBitmap
& wxWindow::GetBackgroundBitmap(int *alignment
,
155 wxStretch
*stretch
) const
157 if ( m_bitmapBg
.Ok() )
160 *alignment
= m_alignBgBitmap
;
162 *stretch
= m_stretchBgBitmap
;
168 // ----------------------------------------------------------------------------
170 // ----------------------------------------------------------------------------
172 // the event handler executed when the window background must be painted
173 void wxWindow::OnErase(wxEraseEvent
& event
)
182 DoDrawBackground(*event
.GetDC());
184 // if we have both scrollbars, we also have a square in the corner between
185 // them which we must paint
186 if ( m_scrollbarVert
&& m_scrollbarHorz
)
188 wxSize size
= GetSize();
189 wxRect rectClient
= GetClientRect(),
190 rectBorder
= m_renderer
->GetBorderDimensions(GetBorder());
193 rectCorner
.x
= rectClient
.GetRight() + 1;
194 rectCorner
.y
= rectClient
.GetBottom() + 1;
195 rectCorner
.SetRight(size
.x
- rectBorder
.width
);
196 rectCorner
.SetBottom(size
.y
- rectBorder
.height
);
198 if ( GetUpdateRegion().Contains(rectCorner
) )
200 m_renderer
->DrawScrollCorner(*event
.GetDC(), rectCorner
);
205 // the event handlers executed when the window must be repainted
206 void wxWindow::OnNcPaint(wxPaintEvent
& event
)
210 // get the window rect
212 wxSize size
= GetSize();
216 rect
.height
= size
.y
;
218 // if the scrollbars are outside the border, we must adjust the rect to
220 if ( !m_renderer
->AreScrollbarsInsideBorder() )
222 wxScrollBar
*scrollbar
= GetScrollbar(wxVERTICAL
);
224 rect
.width
-= scrollbar
->GetSize().x
;
226 scrollbar
= GetScrollbar(wxHORIZONTAL
);
228 rect
.height
-= scrollbar
->GetSize().y
;
231 // get the DC and draw the border on it
233 DoDrawBorder(dc
, rect
);
237 void wxWindow::OnPaint(wxPaintEvent
& event
)
241 // it is a native control which paints itself
246 // get the DC to use and create renderer on it
248 wxControlRenderer
renderer(this, dc
, m_renderer
);
255 bool wxWindow::DoDrawBackground(wxDC
& dc
)
257 // FIXME: leaving this code in leads to partial bg redraws sometimes under
261 rect
= GetUpdateRegion().GetBox();
262 if ( !rect
.width
&& !rect
.height
)
265 wxSize size
= GetSize();
267 rect
.height
= size
.y
;
270 if ( GetBackgroundBitmap().Ok() )
272 // get the bitmap and the flags
275 wxBitmap bmp
= GetBackgroundBitmap(&alignment
, &stretch
);
276 wxControlRenderer::DrawBitmap(dc
, bmp
, rect
, alignment
, stretch
);
278 else // just fill it with bg colour if no bitmap
280 m_renderer
->DrawBackground(dc
, wxTHEME_BG_COLOUR(this),
281 rect
, GetStateFlags());
287 void wxWindow::EraseBackground(wxDC
& dc
, const wxRect
& rect
)
289 // TODO: handle bg bitmaps here!
291 m_renderer
->DrawBackground(dc
, wxTHEME_BG_COLOUR(this), rect
, GetStateFlags());
294 void wxWindow::DoDrawBorder(wxDC
& dc
, const wxRect
& rect
)
296 // draw outline unless the update region is enitrely inside it in which
297 // case we don't need to do it
298 #if 0 // doesn't seem to work, why?
299 if ( wxRegion(rect
).Contains(GetUpdateRegion().GetBox()) != wxInRegion
)
302 m_renderer
->DrawBorder(dc
, GetBorder(), rect
, GetStateFlags());
306 void wxWindow::DoDraw(wxControlRenderer
*renderer
)
310 void wxWindow::Refresh(bool eraseBackground
, const wxRect
*rectClient
)
313 wxPoint pt
= GetClientAreaOrigin();
315 wxSize size
= GetClientSize();
319 rectWin
= *rectClient
;
321 // don't refresh anything beyond the client area (scrollbars for
323 if ( rectWin
.GetRight() > size
.x
)
324 rectWin
.SetRight(size
.x
);
325 if ( rectWin
.GetBottom() > size
.y
)
326 rectWin
.SetBottom(size
.y
);
330 else // refresh the entire client area
334 rectWin
.width
= size
.x
;
335 rectWin
.height
= size
.y
;
339 #ifdef WXDEBUG_REFRESH
340 static bool s_refreshDebug
= FALSE
;
341 if ( s_refreshDebug
)
344 dc
.SetBrush(*wxCYAN_BRUSH
);
345 dc
.SetPen(*wxTRANSPARENT_PEN
);
346 dc
.DrawRectangle(rectWin
);
348 // under Unix we use "--sync" X option for this
349 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
354 #endif // WXDEBUG_REFRESH
356 wxWindowNative::Refresh(eraseBackground
, &rectWin
);
359 // ----------------------------------------------------------------------------
361 // ----------------------------------------------------------------------------
363 bool wxWindow::Enable(bool enable
)
365 if ( !wxWindowNative::Enable(enable
) )
368 // disabled window can't keep focus
369 if ( FindFocus() == this )
371 GetParent()->SetFocus();
376 // a window with renderer is drawn by ourselves and it has to be
377 // refreshed to reflect its new status
384 bool wxWindow::IsFocused() const
386 wxWindow
*self
= wxConstCast(this, wxWindow
);
387 return self
->FindFocus() == self
;
390 bool wxWindow::IsPressed() const
395 bool wxWindow::IsDefault() const
400 bool wxWindow::IsCurrent() const
405 bool wxWindow::SetCurrent(bool doit
)
407 if ( doit
== m_isCurrent
)
412 if ( CanBeHighlighted() )
418 int wxWindow::GetStateFlags() const
422 flags
|= wxCONTROL_DISABLED
;
424 // the following states are only possible if our application is active - if
425 // it is not, even our default/focused controls shouldn't appear as such
426 if ( wxTheApp
->IsActive() )
429 flags
|= wxCONTROL_CURRENT
;
431 flags
|= wxCONTROL_FOCUSED
;
433 flags
|= wxCONTROL_PRESSED
;
435 flags
|= wxCONTROL_ISDEFAULT
;
441 // ----------------------------------------------------------------------------
443 // ----------------------------------------------------------------------------
445 void wxWindow::OnSize(wxSizeEvent
& event
)
447 if ( m_scrollbarVert
|| m_scrollbarHorz
)
449 PositionScrollbars();
455 wxSize
wxWindow::DoGetBestSize() const
457 return AdjustSize(DoGetBestClientSize());
460 wxSize
wxWindow::DoGetBestClientSize() const
462 return wxWindowNative::DoGetBestSize();
465 wxSize
wxWindow::AdjustSize(const wxSize
& size
) const
469 m_renderer
->AdjustSize(&sz
, this);
473 wxPoint
wxWindow::GetClientAreaOrigin() const
475 wxPoint pt
= wxWindowBase::GetClientAreaOrigin();
478 pt
+= m_renderer
->GetBorderDimensions(GetBorder()).GetPosition();
483 void wxWindow::DoGetClientSize(int *width
, int *height
) const
486 wxWindowNative::DoGetClientSize(&w
, &h
);
488 // we assume that the scrollbars are positioned correctly (by a previous
489 // call to PositionScrollbars()) here
493 rectBorder
= m_renderer
->GetBorderDimensions(GetBorder());
495 bool inside
= m_renderer
->AreScrollbarsInsideBorder();
499 // in any case, take account of the scrollbar
500 if ( m_scrollbarVert
)
501 w
-= m_scrollbarVert
->GetSize().x
;
503 // if we don't have scrollbar or if it is outside the border (and not
504 // blended into it), take account of the right border as well
505 if ( !m_scrollbarVert
|| inside
)
506 w
-= rectBorder
.width
;
508 // and always account for the left border
509 *width
= w
- rectBorder
.x
;
511 // we shouldn't return invalid width
518 if ( m_scrollbarHorz
)
519 h
-= m_scrollbarHorz
->GetSize().y
;
521 if ( !m_scrollbarHorz
|| inside
)
522 h
-= rectBorder
.height
;
524 *height
= h
- rectBorder
.y
;
526 // we shouldn't return invalid height
532 void wxWindow::DoSetClientSize(int width
, int height
)
534 // take into account the borders
535 wxRect rectBorder
= m_renderer
->GetBorderDimensions(GetBorder());
536 width
+= rectBorder
.x
;
537 height
+= rectBorder
.y
;
539 // and the scrollbars (as they may be offset into the border, use the
540 // scrollbar position, not size - this supposes that PositionScrollbars()
541 // had been called before)
542 bool inside
= m_renderer
->AreScrollbarsInsideBorder();
543 wxSize size
= GetSize();
544 if ( m_scrollbarVert
)
545 width
+= size
.x
- m_scrollbarVert
->GetPosition().x
;
546 if ( !m_scrollbarVert
|| inside
)
547 width
+= rectBorder
.width
;
549 if ( m_scrollbarHorz
)
550 height
+= size
.y
- m_scrollbarHorz
->GetPosition().y
;
551 if ( !m_scrollbarHorz
|| inside
)
552 height
+= rectBorder
.height
;
554 wxWindowNative::DoSetClientSize(width
, height
);
557 wxHitTest
wxWindow::DoHitTest(wxCoord x
, wxCoord y
) const
559 wxHitTest ht
= wxWindowNative::DoHitTest(x
, y
);
560 if ( ht
== wxHT_WINDOW_INSIDE
)
562 if ( m_scrollbarVert
&& x
>= m_scrollbarVert
->GetPosition().x
)
564 // it can still be changed below because it may also be the corner
565 ht
= wxHT_WINDOW_VERT_SCROLLBAR
;
568 if ( m_scrollbarHorz
&& y
>= m_scrollbarHorz
->GetPosition().y
)
570 ht
= ht
== wxHT_WINDOW_VERT_SCROLLBAR
? wxHT_WINDOW_CORNER
571 : wxHT_WINDOW_HORZ_SCROLLBAR
;
578 // ----------------------------------------------------------------------------
579 // scrolling: we implement it entirely ourselves except for ScrollWindow()
580 // function which is supposed to be (efficiently) implemented by the native
582 // ----------------------------------------------------------------------------
584 void wxWindow::RefreshScrollbars()
586 if ( m_scrollbarHorz
)
587 m_scrollbarHorz
->Refresh();
589 if ( m_scrollbarVert
)
590 m_scrollbarVert
->Refresh();
593 void wxWindow::PositionScrollbars()
595 // do not use GetClientSize/Rect as it relies on the scrollbars being
596 // correctly positioned
598 wxSize size
= GetSize();
599 wxBorder border
= GetBorder();
600 wxRect rectBorder
= m_renderer
->GetBorderDimensions(border
);
601 bool inside
= m_renderer
->AreScrollbarsInsideBorder();
603 int height
= m_scrollbarHorz
? m_scrollbarHorz
->GetSize().y
: 0;
604 int width
= m_scrollbarVert
? m_scrollbarVert
->GetSize().x
: 0;
607 if ( m_scrollbarVert
)
609 rectBar
.x
= size
.x
- width
;
611 rectBar
.x
-= rectBorder
.width
;
612 rectBar
.width
= width
;
615 rectBar
.y
+= rectBorder
.y
;
616 rectBar
.height
= size
.y
- height
;
618 rectBar
.height
-= rectBorder
.y
+ rectBorder
.height
;
620 m_scrollbarVert
->SetSize(rectBar
, wxSIZE_NO_ADJUSTMENTS
);
623 if ( m_scrollbarHorz
)
625 rectBar
.y
= size
.y
- height
;
627 rectBar
.y
-= rectBorder
.height
;
628 rectBar
.height
= height
;
631 rectBar
.x
+= rectBorder
.x
;
632 rectBar
.width
= size
.x
- width
;
634 rectBar
.width
-= rectBorder
.x
+ rectBorder
.width
;
636 m_scrollbarHorz
->SetSize(rectBar
, wxSIZE_NO_ADJUSTMENTS
);
642 void wxWindow::SetScrollbar(int orient
,
648 bool hasClientSizeChanged
= FALSE
;
649 wxScrollBar
*scrollbar
= GetScrollbar(orient
);
655 scrollbar
= new wxScrollBar(this, -1,
656 wxDefaultPosition
, wxDefaultSize
,
657 orient
& wxVERTICAL
? wxSB_VERTICAL
659 if ( orient
& wxVERTICAL
)
660 m_scrollbarVert
= scrollbar
;
662 m_scrollbarHorz
= scrollbar
;
664 // the client area diminished as we created a scrollbar
665 hasClientSizeChanged
= TRUE
;
667 PositionScrollbars();
669 else if ( GetWindowStyle() & wxALWAYS_SHOW_SB
)
671 // we might have disabled it before
675 scrollbar
->SetScrollbar(pos
, pageSize
, range
, pageSize
, refresh
);
677 else // no range means no scrollbar
681 // wxALWAYS_SHOW_SB only applies to the vertical scrollbar
682 if ( (orient
& wxVERTICAL
) && (GetWindowStyle() & wxALWAYS_SHOW_SB
) )
684 // just disable the scrollbar
685 scrollbar
->SetScrollbar(pos
, pageSize
, range
, pageSize
, refresh
);
686 scrollbar
->Disable();
688 else // really remove the scrollbar
692 if ( orient
& wxVERTICAL
)
693 m_scrollbarVert
= NULL
;
695 m_scrollbarHorz
= NULL
;
697 // the client area increased as we removed a scrollbar
698 hasClientSizeChanged
= TRUE
;
700 // the size of the remaining scrollbar must be adjusted
701 if ( m_scrollbarHorz
|| m_scrollbarVert
)
703 PositionScrollbars();
709 // give the window a chance to relayout
710 if ( hasClientSizeChanged
)
712 wxSizeEvent
event(GetSize());
713 (void)GetEventHandler()->ProcessEvent(event
);
717 void wxWindow::SetScrollPos(int orient
, int pos
, bool refresh
)
719 wxScrollBar
*scrollbar
= GetScrollbar(orient
);
720 wxCHECK_RET( scrollbar
, _T("no scrollbar to set position for") );
722 scrollbar
->SetThumbPosition(pos
);
727 int wxWindow::GetScrollPos(int orient
) const
729 wxScrollBar
*scrollbar
= GetScrollbar(orient
);
730 return scrollbar
? scrollbar
->GetThumbPosition() : 0;
733 int wxWindow::GetScrollThumb(int orient
) const
735 wxScrollBar
*scrollbar
= GetScrollbar(orient
);
736 return scrollbar
? scrollbar
->GetThumbSize() : 0;
739 int wxWindow::GetScrollRange(int orient
) const
741 wxScrollBar
*scrollbar
= GetScrollbar(orient
);
742 return scrollbar
? scrollbar
->GetRange() : 0;
745 void wxWindow::ScrollWindow(int dx
, int dy
, const wxRect
*rect
)
747 // before scrolling it, ensure that we don't have any unpainted areas
754 r
= ScrollNoRefresh(dx
, 0, rect
);
755 Refresh(TRUE
/* erase bkgnd */, &r
);
760 r
= ScrollNoRefresh(0, dy
, rect
);
761 Refresh(TRUE
/* erase bkgnd */, &r
);
765 wxRect
wxWindow::ScrollNoRefresh(int dx
, int dy
, const wxRect
*rectTotal
)
767 wxASSERT_MSG( !dx
|| !dy
, _T("can't be used for diag scrolling") );
769 // the rect to refresh (which we will calculate)
778 // calculate the part of the window which we can just redraw in the new
780 wxSize sizeTotal
= rectTotal
? rectTotal
->GetSize() : GetClientSize();
782 wxLogTrace(_T("scroll"), _T("rect is %dx%d, scroll by %d, %d"),
783 sizeTotal
.x
, sizeTotal
.y
, dx
, dy
);
785 // the initial and end point of the region we move in client coords
786 wxPoint ptSource
, ptDest
;
789 ptSource
= rectTotal
->GetPosition();
790 ptDest
= rectTotal
->GetPosition();
793 // the size of this region
795 size
.x
= sizeTotal
.x
- abs(dx
);
796 size
.y
= sizeTotal
.y
- abs(dy
);
797 if ( size
.x
<= 0 || size
.y
<= 0 )
799 // just redraw everything as nothing of the displayed image will stay
800 wxLogTrace(_T("scroll"), _T("refreshing everything"));
802 rect
= rectTotal
? *rectTotal
: wxRect(0, 0, sizeTotal
.x
, sizeTotal
.y
);
804 else // move the part which doesn't change to the new location
806 // note that when we scroll the canvas in some direction we move the
807 // block which doesn't need to be refreshed in the opposite direction
811 // scroll to the right, move to the left
816 // scroll to the left, move to the right
822 // scroll down, move up
827 // scroll up, move down
832 // we need to hide the caret before moving or it will erase itself at
833 // the wrong (old) location
834 wxCaret
*caret
= GetCaret();
837 #endif // wxUSE_CARET
841 wxBitmap
bmp(size
.x
, size
.y
);
843 dcMem
.SelectObject(bmp
);
845 dcMem
.Blit(wxPoint(0, 0), size
, &dc
, ptSource
846 #if defined(__WXGTK__) && !defined(__WX_DC_BLIT_FIXED__)
847 + GetClientAreaOrigin()
848 #endif // broken wxGTK wxDC::Blit
850 dc
.Blit(ptDest
, size
, &dcMem
, wxPoint(0, 0));
852 wxLogTrace(_T("scroll"),
853 _T("Blit: (%d, %d) of size %dx%d -> (%d, %d)"),
854 ptSource
.x
, ptSource
.y
,
858 // and now repaint the uncovered area
860 // FIXME: We repaint the intersection of these rectangles twice - is
861 // it bad? I don't think so as it is rare to scroll the window
862 // diagonally anyhow and so adding extra logic to compute
863 // rectangle intersection is probably not worth the effort
872 // refresh the area along the right border
873 rect
.x
+= size
.x
+ dx
;
878 // refresh the area along the left border
882 rect
.height
= sizeTotal
.y
;
884 wxLogTrace(_T("scroll"), _T("refreshing (%d, %d)-(%d, %d)"),
886 rect
.GetRight() + 1, rect
.GetBottom() + 1);
893 // refresh the area along the bottom border
894 rect
.y
+= size
.y
+ dy
;
899 // refresh the area along the top border
903 rect
.width
= sizeTotal
.x
;
905 wxLogTrace(_T("scroll"), _T("refreshing (%d, %d)-(%d, %d)"),
907 rect
.GetRight() + 1, rect
.GetBottom() + 1);
913 #endif // wxUSE_CARET
919 // ----------------------------------------------------------------------------
921 // ----------------------------------------------------------------------------
923 bool wxWindow::SetBackgroundColour(const wxColour
& colour
)
925 if ( !wxWindowNative::SetBackgroundColour(colour
) )
933 bool wxWindow::SetForegroundColour(const wxColour
& colour
)
935 if ( !wxWindowNative::SetForegroundColour(colour
) )
943 bool wxWindow::SetFont(const wxFont
& font
)
945 if ( !wxWindowNative::SetFont(font
) )
953 // ----------------------------------------------------------------------------
955 // ----------------------------------------------------------------------------
957 struct WXDLLEXPORT wxWindowNext
961 } *wxWindow::ms_winCaptureNext
= NULL
;
963 void wxWindow::CaptureMouse()
965 wxWindow
*winOld
= GetCapture();
969 wxWindowNext
*item
= new wxWindowNext
;
971 item
->next
= ms_winCaptureNext
;
972 ms_winCaptureNext
= item
;
974 //else: no mouse capture to save
976 wxWindowNative::CaptureMouse();
979 void wxWindow::ReleaseMouse()
981 wxWindowNative::ReleaseMouse();
983 if ( ms_winCaptureNext
)
985 ms_winCaptureNext
->win
->CaptureMouse();
987 wxWindowNext
*item
= ms_winCaptureNext
;
988 ms_winCaptureNext
= item
->next
;
991 //else: stack is empty, no previous capture
994 // ----------------------------------------------------------------------------
995 // accelerators and menu hot keys
996 // ----------------------------------------------------------------------------
999 // the last window over which Alt was pressed (used by OnKeyUp)
1000 wxWindow
*wxWindow::ms_winLastAltPress
= NULL
;
1001 #endif // wxUSE_MENUS
1003 #if wxUSE_ACCEL || wxUSE_MENUS
1005 void wxWindow::OnKeyDown(wxKeyEvent
& event
)
1008 int key
= event
.GetKeyCode();
1009 if ( !event
.ControlDown() && (key
== WXK_MENU
|| key
== WXK_F10
) )
1011 ms_winLastAltPress
= this;
1013 // it can't be an accel anyhow
1017 ms_winLastAltPress
= NULL
;
1018 #endif // wxUSE_MENUS
1021 for ( wxWindow
*win
= this; win
; win
= win
->GetParent() )
1023 int command
= win
->GetAcceleratorTable()->GetCommand(event
);
1024 if ( command
!= -1 )
1026 wxCommandEvent
eventCmd(wxEVT_COMMAND_MENU_SELECTED
, command
);
1027 if ( win
->GetEventHandler()->ProcessEvent(eventCmd
) )
1029 // skip "event.Skip()" below
1034 if ( win
->IsTopLevel() )
1036 // try the frame menu bar
1038 wxFrame
*frame
= wxDynamicCast(win
, wxFrame
);
1041 wxMenuBar
*menubar
= frame
->GetMenuBar();
1042 if ( menubar
&& menubar
->ProcessAccelEvent(event
) )
1044 // skip "event.Skip()" below
1048 #endif // wxUSE_MENUS
1050 // don't propagate accels from the child frame to the parent one
1054 #endif // wxUSE_ACCEL
1059 #endif // wxUSE_ACCEL
1063 wxMenuBar
*wxWindow::GetParentFrameMenuBar() const
1065 for ( const wxWindow
*win
= this; win
; win
= win
->GetParent() )
1067 if ( win
->IsTopLevel() )
1069 wxFrame
*frame
= wxDynamicCast(win
, wxFrame
);
1072 return frame
->GetMenuBar();
1075 // don't look further - we don't want to return the menubar of the
1084 void wxWindow::OnChar(wxKeyEvent
& event
)
1086 if ( event
.AltDown() && !event
.ControlDown() )
1088 int key
= event
.GetKeyCode();
1090 wxMenuBar
*menubar
= GetParentFrameMenuBar();
1093 int item
= menubar
->FindNextItemForAccel(-1, key
);
1096 menubar
->PopupMenu((size_t)item
);
1098 // skip "event.Skip()" below
1107 void wxWindow::OnKeyUp(wxKeyEvent
& event
)
1109 int key
= event
.GetKeyCode();
1110 if ( !event
.HasModifiers() && (key
== WXK_MENU
|| key
== WXK_F10
) )
1112 // only process Alt release specially if there were no other key
1113 // presses since Alt had been pressed and if both events happened in
1115 if ( ms_winLastAltPress
== this )
1117 wxMenuBar
*menubar
= GetParentFrameMenuBar();
1118 if ( menubar
&& this != menubar
)
1120 menubar
->SelectMenu(0);
1129 // in any case reset it
1130 ms_winLastAltPress
= NULL
;
1133 #endif // wxUSE_MENUS