1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/frame.cpp
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
30 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
34 #include "wx/dialog.h"
35 #include "wx/settings.h"
36 #include "wx/dcclient.h"
40 #include "wx/toolbar.h"
41 #include "wx/statusbr.h"
42 #include "wx/menuitem.h"
45 #include "wx/msw/private.h"
47 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
50 #include "wx/msw/winundef.h"
53 #include "wx/generic/statusbr.h"
55 #ifdef __WXUNIVERSAL__
56 #include "wx/univ/theme.h"
57 #include "wx/univ/colschem.h"
58 #endif // __WXUNIVERSAL__
60 // ----------------------------------------------------------------------------
62 // ----------------------------------------------------------------------------
64 #if wxUSE_MENUS_NATIVE
65 extern wxMenu
*wxCurrentPopupMenu
;
66 #endif // wxUSE_MENUS_NATIVE
68 // ----------------------------------------------------------------------------
70 // ----------------------------------------------------------------------------
72 BEGIN_EVENT_TABLE(wxFrame
, wxFrameBase
)
73 EVT_SYS_COLOUR_CHANGED(wxFrame
::OnSysColourChanged
)
76 #if wxUSE_EXTENDED_RTTI
77 WX_DEFINE_FLAGS( wxFrameStyle
)
79 wxBEGIN_FLAGS( wxFrameStyle
)
80 // new style border flags, we put them first to
81 // use them for streaming out
82 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
83 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
84 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
85 wxFLAGS_MEMBER(wxBORDER_RAISED
)
86 wxFLAGS_MEMBER(wxBORDER_STATIC
)
87 wxFLAGS_MEMBER(wxBORDER_NONE
)
89 // old style border flags
90 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
91 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
92 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
93 wxFLAGS_MEMBER(wxRAISED_BORDER
)
94 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
95 wxFLAGS_MEMBER(wxBORDER
)
97 // standard window styles
98 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
99 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
100 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
101 wxFLAGS_MEMBER(wxWANTS_CHARS
)
102 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
103 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
104 wxFLAGS_MEMBER(wxVSCROLL
)
105 wxFLAGS_MEMBER(wxHSCROLL
)
108 wxFLAGS_MEMBER(wxSTAY_ON_TOP
)
109 wxFLAGS_MEMBER(wxCAPTION
)
110 #if WXWIN_COMPATIBILITY_2_6
111 wxFLAGS_MEMBER(wxTHICK_FRAME
)
112 #endif // WXWIN_COMPATIBILITY_2_6
113 wxFLAGS_MEMBER(wxSYSTEM_MENU
)
114 wxFLAGS_MEMBER(wxRESIZE_BORDER
)
115 #if WXWIN_COMPATIBILITY_2_6
116 wxFLAGS_MEMBER(wxRESIZE_BOX
)
117 #endif // WXWIN_COMPATIBILITY_2_6
118 wxFLAGS_MEMBER(wxCLOSE_BOX
)
119 wxFLAGS_MEMBER(wxMAXIMIZE_BOX
)
120 wxFLAGS_MEMBER(wxMINIMIZE_BOX
)
122 wxFLAGS_MEMBER(wxFRAME_TOOL_WINDOW
)
123 wxFLAGS_MEMBER(wxFRAME_FLOAT_ON_PARENT
)
125 wxFLAGS_MEMBER(wxFRAME_SHAPED
)
127 wxEND_FLAGS( wxFrameStyle
)
129 IMPLEMENT_DYNAMIC_CLASS_XTI(wxFrame
, wxTopLevelWindow
,"wx/frame.h")
131 wxBEGIN_PROPERTIES_TABLE(wxFrame
)
132 wxEVENT_PROPERTY( Menu
, wxEVT_COMMAND_MENU_SELECTED
, wxCommandEvent
)
134 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
135 wxPROPERTY_FLAGS( WindowStyle
, wxFrameStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
136 wxPROPERTY( MenuBar
, wxMenuBar
* , SetMenuBar
, GetMenuBar
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
137 wxEND_PROPERTIES_TABLE()
139 wxBEGIN_HANDLERS_TABLE(wxFrame
)
140 wxEND_HANDLERS_TABLE()
142 wxCONSTRUCTOR_6( wxFrame
, wxWindow
* , Parent
, wxWindowID
, Id
, wxString
, Title
, wxPoint
, Position
, wxSize
, Size
, long , WindowStyle
)
145 IMPLEMENT_DYNAMIC_CLASS(wxFrame
, wxTopLevelWindow
)
148 // ============================================================================
150 // ============================================================================
152 // ----------------------------------------------------------------------------
153 // static class members
154 // ----------------------------------------------------------------------------
157 #if wxUSE_NATIVE_STATUSBAR
158 bool wxFrame
::m_useNativeStatusBar
= true;
160 bool wxFrame
::m_useNativeStatusBar
= false;
162 #endif // wxUSE_NATIVE_STATUSBAR
164 // ----------------------------------------------------------------------------
165 // creation/destruction
166 // ----------------------------------------------------------------------------
172 #endif // wxUSE_MENUS
178 m_wasMinimized
= false;
181 bool wxFrame
::Create(wxWindow
*parent
,
183 const wxString
& title
,
187 const wxString
& name
)
189 if ( !wxTopLevelWindow
::Create(parent
, id
, title
, pos
, size
, style
, name
) )
192 SetOwnBackgroundColour(wxSystemSettings
::GetColour(wxSYS_COLOUR_APPWORKSPACE
));
194 #if defined(__SMARTPHONE__)
195 SetLeftMenu(wxID_EXIT
, _("Done"));
198 #if wxUSE_ACCEL && defined(__POCKETPC__)
199 // The guidelines state that Ctrl+Q should quit the app.
200 // Let's define an accelerator table to send wxID_EXIT.
201 wxAcceleratorEntry entries
[1];
202 entries
[0].Set(wxACCEL_CTRL
, 'Q', wxID_EXIT
);
203 wxAcceleratorTable
accel(1, entries
);
204 SetAcceleratorTable(accel
);
205 #endif // wxUSE_ACCEL && __POCKETPC__
212 m_isBeingDeleted
= true;
216 // ----------------------------------------------------------------------------
217 // wxFrame client size calculations
218 // ----------------------------------------------------------------------------
220 void wxFrame
::DoSetClientSize(int width
, int height
)
222 // leave enough space for the status bar if we have (and show) it
224 wxStatusBar
*statbar
= GetStatusBar();
225 if ( statbar
&& statbar
->IsShown() )
227 height
+= statbar
->GetSize().y
;
229 #endif // wxUSE_STATUSBAR
231 // call GetClientAreaOrigin() to take the toolbar into account
232 wxPoint pt
= GetClientAreaOrigin();
237 wxToolBar
* const toolbar
= GetToolBar();
240 if ( toolbar
->HasFlag(wxTB_RIGHT
| wxTB_BOTTOM
) )
242 const wxSize sizeTB
= toolbar
->GetSize();
243 if ( toolbar
->HasFlag(wxTB_RIGHT
) )
248 //else: toolbar already taken into account by GetClientAreaOrigin()
250 #endif // wxUSE_TOOLBAR
252 wxTopLevelWindow
::DoSetClientSize(width
, height
);
255 // Get size *available for subwindows* i.e. excluding menu bar, toolbar etc.
256 void wxFrame
::DoGetClientSize(int *x
, int *y
) const
258 wxTopLevelWindow
::DoGetClientSize(x
, y
);
260 // account for the possible toolbar
261 wxPoint pt
= GetClientAreaOrigin();
269 wxToolBar
* const toolbar
= GetToolBar();
272 if ( toolbar
->HasFlag(wxTB_RIGHT
| wxTB_BOTTOM
) )
274 const wxSize sizeTB
= toolbar
->GetSize();
275 if ( toolbar
->HasFlag(wxTB_RIGHT
) )
286 //else: toolbar already taken into account by GetClientAreaOrigin()
288 #endif // wxUSE_TOOLBAR
291 // adjust client area height to take the status bar into account
294 wxStatusBar
*statbar
= GetStatusBar();
295 if ( statbar
&& statbar
->IsShown() )
297 *y
-= statbar
->GetClientSize().y
;
300 #endif // wxUSE_STATUSBAR
303 // ----------------------------------------------------------------------------
304 // wxFrame: various geometry-related functions
305 // ----------------------------------------------------------------------------
307 void wxFrame
::Raise()
309 ::SetForegroundWindow(GetHwnd());
312 // generate an artificial resize event
313 void wxFrame
::SendSizeEvent()
317 RECT r
= wxGetWindowRect(GetHwnd());
319 (void)::PostMessage(GetHwnd(), WM_SIZE
,
320 IsMaximized() ? SIZE_MAXIMIZED
: SIZE_RESTORED
,
321 MAKELPARAM(r
.right
- r
.left
, r
.bottom
- r
.top
));
326 wxStatusBar
*wxFrame
::OnCreateStatusBar(int number
,
329 const wxString
& name
)
331 wxStatusBar
*statusBar
wxDUMMY_INITIALIZE(NULL
);
333 #if wxUSE_NATIVE_STATUSBAR
334 if ( !UsesNativeStatusBar() )
336 statusBar
= (wxStatusBar
*)new wxStatusBarGeneric(this, id
, style
);
341 statusBar
= new wxStatusBar(this, id
, style
, name
);
344 statusBar
->SetFieldsCount(number
);
349 void wxFrame
::PositionStatusBar()
351 if ( !m_frameStatusBar
|| !m_frameStatusBar
->IsShown() )
355 GetClientSize(&w
, &h
);
358 m_frameStatusBar
->GetSize(&sw
, &sh
);
360 // Since we wish the status bar to be directly under the client area,
361 // we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS.
362 m_frameStatusBar
->SetSize(0, h
, w
, sh
);
365 #endif // wxUSE_STATUSBAR
367 #if wxUSE_MENUS_NATIVE
369 void wxFrame
::AttachMenuBar(wxMenuBar
*menubar
)
371 #if defined(__SMARTPHONE__) && defined(__WXWINCE__)
373 wxMenu
*autoMenu
= NULL
;
375 if( menubar
->GetMenuCount() == 1 )
377 autoMenu
= wxTopLevelWindowMSW
::ButtonMenu
::DuplicateMenu(menubar
->GetMenu(0));
378 SetRightMenu(wxID_ANY
, menubar
->GetLabelTop(0), autoMenu
);
382 autoMenu
= new wxMenu
;
384 for( size_t n
= 0; n
< menubar
->GetMenuCount(); n
++ )
386 wxMenu
*item
= menubar
->GetMenu(n
);
387 wxString label
= menubar
->GetLabelTop(n
);
388 wxMenu
*new_item
= wxTopLevelWindowMSW
::ButtonMenu
::DuplicateMenu(item
);
389 autoMenu
->Append(wxID_ANY
, label
, new_item
);
392 SetRightMenu(wxID_ANY
, _("Menu"), autoMenu
);
395 #elif defined(WINCE_WITHOUT_COMMANDBAR)
398 wxToolMenuBar
* toolBar
= new wxToolMenuBar(this, wxID_ANY
,
399 wxDefaultPosition
, wxDefaultSize
,
400 wxBORDER_NONE
| wxTB_HORIZONTAL
,
401 wxToolBarNameStr
, menubar
);
403 menubar
->SetToolBar(toolBar
);
405 // Now adjust size for menu bar
408 //When the main window is created using CW_USEDEFAULT the height of the
409 // is created is not taken into account). So we resize the window after
410 // if a menubar is present
413 ::GetWindowRect((HWND
) GetHWND(), &rc
);
414 // adjust for menu / titlebar height
415 rc
.bottom
-= (2*menuHeight
-1);
417 ::MoveWindow((HWND
) GetHWND(), rc
.left
, rc
.top
, rc
.right
, rc
.bottom
, FALSE
);
421 wxFrameBase
::AttachMenuBar(menubar
);
425 // actually remove the menu from the frame
426 m_hMenu
= (WXHMENU
)0;
427 InternalSetMenuBar();
429 else // set new non NULL menu bar
431 #if !defined(__WXWINCE__) || defined(WINCE_WITH_COMMANDBAR)
432 // Can set a menubar several times.
433 if ( menubar
->GetHMenu() )
435 m_hMenu
= menubar
->GetHMenu();
439 m_hMenu
= menubar
->Create();
443 wxFAIL_MSG( _T("failed to create menu bar") );
448 InternalSetMenuBar();
452 void wxFrame
::InternalSetMenuBar()
454 #if defined(__WXMICROWIN__) || defined(__WXWINCE__)
457 if ( !::SetMenu(GetHwnd(), (HMENU
)m_hMenu
) )
459 wxLogLastError(wxT("SetMenu"));
464 #endif // wxUSE_MENUS_NATIVE
466 // Responds to colour changes, and passes event on to children.
467 void wxFrame
::OnSysColourChanged(wxSysColourChangedEvent
& event
)
469 SetOwnBackgroundColour(wxSystemSettings
::GetColour(wxSYS_COLOUR_APPWORKSPACE
));
473 if ( m_frameStatusBar
)
475 wxSysColourChangedEvent event2
;
476 event2
.SetEventObject( m_frameStatusBar
);
477 m_frameStatusBar
->GetEventHandler()->ProcessEvent(event2
);
479 #endif // wxUSE_STATUSBAR
481 // Propagate the event to the non-top-level children
482 wxWindow
::OnSysColourChanged(event
);
485 // Pass true to show full screen, false to restore.
486 bool wxFrame
::ShowFullScreen(bool show
, long style
)
488 // TODO-CE: add support for CE
489 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
490 if ( IsFullScreen() == show
)
495 // zap the toolbar, menubar, and statusbar if needed
497 // TODO: hide commandbar for WINCE_WITH_COMMANDBAR
499 wxToolBar
*theToolBar
= GetToolBar();
501 if ((style
& wxFULLSCREEN_NOTOOLBAR
) && theToolBar
)
503 if ( theToolBar
->IsShown() )
505 theToolBar
->SetSize(wxDefaultCoord
,0);
506 theToolBar
->Show(false);
508 else // prevent it from being restored later
510 style
&= ~wxFULLSCREEN_NOTOOLBAR
;
513 #endif // wxUSE_TOOLBAR
515 if (style
& wxFULLSCREEN_NOMENUBAR
)
516 SetMenu((HWND
)GetHWND(), (HMENU
) NULL
);
519 wxStatusBar
*theStatusBar
= GetStatusBar();
521 // Save the number of fields in the statusbar
522 if ((style
& wxFULLSCREEN_NOSTATUSBAR
) && theStatusBar
)
524 if ( theStatusBar
->IsShown() )
525 theStatusBar
->Show(false);
527 style
&= ~wxFULLSCREEN_NOSTATUSBAR
;
529 #endif // wxUSE_STATUSBAR
531 else // restore to normal
533 // restore the toolbar, menubar, and statusbar if we had hid them
535 wxToolBar
*theToolBar
= GetToolBar();
537 if ((m_fsStyle
& wxFULLSCREEN_NOTOOLBAR
) && theToolBar
)
539 theToolBar
->Show(true);
541 #endif // wxUSE_TOOLBAR
543 if (m_fsStyle
& wxFULLSCREEN_NOMENUBAR
)
545 WXHMENU menu
= m_hMenu
;
547 #if wxUSE_MDI_ARCHITECTURE
548 wxMDIParentFrame
*frame
= wxDynamicCast(this, wxMDIParentFrame
);
551 wxMDIChildFrame
*child
= frame
->GetActiveChild();
554 menu
= child
->GetWinMenu();
557 #endif // wxUSE_MDI_ARCHITECTURE
561 ::SetMenu(GetHwnd(), (HMENU
)menu
);
566 wxStatusBar
*theStatusBar
= GetStatusBar();
568 if ((m_fsStyle
& wxFULLSCREEN_NOSTATUSBAR
) && theStatusBar
)
570 theStatusBar
->Show(true);
573 #endif // wxUSE_STATUSBAR
575 #endif // !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
577 return wxFrameBase
::ShowFullScreen(show
, style
);
580 // ----------------------------------------------------------------------------
581 // tool/status bar stuff
582 // ----------------------------------------------------------------------------
586 wxToolBar
* wxFrame
::CreateToolBar(long style
, wxWindowID id
, const wxString
& name
)
588 #if defined(WINCE_WITHOUT_COMMANDBAR)
589 // We may already have a toolbar from calling SetMenuBar.
593 if ( wxFrameBase
::CreateToolBar(style
, id
, name
) )
598 return m_frameToolBar
;
601 void wxFrame
::PositionToolBar()
604 wxToolBar
*toolbar
= GetToolBar();
605 if ( toolbar
&& toolbar
->IsShown() )
607 #if defined(WINCE_WITHOUT_COMMANDBAR)
608 // We want to do something different in WinCE, because
609 // the toolbar should be associated with the commandbar,
610 // and not an independent window.
613 // don't call our (or even wxTopLevelWindow) version because we want
614 // the real (full) client area size, not excluding the tool/status bar
616 wxWindow
::DoGetClientSize(&width
, &height
);
619 wxStatusBar
*statbar
= GetStatusBar();
620 if ( statbar
&& statbar
->IsShown() )
622 height
-= statbar
->GetClientSize().y
;
624 #endif // wxUSE_STATUSBAR
627 toolbar
->GetPosition( &tx
, &ty
);
628 toolbar
->GetSize( &tw
, &th
);
630 if ( toolbar
->HasFlag(wxTB_BOTTOM
) )
635 else if ( toolbar
->HasFlag(wxTB_RIGHT
) )
646 #if defined(WINCE_WITH_COMMANDBAR)
647 // We're using a commandbar - so we have to allow for it.
648 if (GetMenuBar() && GetMenuBar()->GetCommandBar())
651 ::GetWindowRect((HWND
) GetMenuBar()->GetCommandBar(), &rect
);
652 y
= rect
.bottom
- rect
.top
;
654 #endif // WINCE_WITH_COMMANDBAR
656 if ( toolbar
->HasFlag(wxTB_BOTTOM
) )
658 if ( ty
< 0 && ( -ty
== th
) )
660 if ( tx
< 0 && (-tx
== tw
) )
663 else if ( toolbar
->HasFlag(wxTB_RIGHT
) )
665 if( ty
< 0 && ( -ty
== th
) )
667 if( tx
< 0 && ( -tx
== tw
) )
672 if (ty
< 0 && (-ty
== th
))
674 if (tx
< 0 && (-tx
== tw
))
681 if ( toolbar
->IsVertical() )
690 // use the 'real' MSW position here, don't offset relativly to the
691 // client area origin
693 // Optimise such that we don't have to always resize the toolbar
694 // when the frame changes, otherwise we'll get a lot of flicker.
695 bool heightChanging
wxDUMMY_INITIALIZE(true);
696 bool widthChanging
wxDUMMY_INITIALIZE(true);
698 if ( toolbar
->IsVertical() )
700 // It's OK if the current height is greater than what can be shown.
701 heightChanging
= (desiredH
> th
) ;
702 widthChanging
= (desiredW
!= tw
) ;
704 // The next time around, we may not have to set the size
706 desiredH
= desiredH
+ 200;
710 // It's OK if the current width is greater than what can be shown.
711 widthChanging
= (desiredW
> tw
) ;
712 heightChanging
= (desiredH
!= th
) ;
714 // The next time around, we may not have to set the size
716 desiredW
= desiredW
+ 200;
719 if (tx
!= 0 || ty
!= 0 || widthChanging
|| heightChanging
)
720 toolbar
->SetSize(x
, y
, desiredW
, desiredH
, wxSIZE_NO_ADJUSTMENTS
);
722 #endif // __WXWINCE__
726 #endif // wxUSE_TOOLBAR
728 // ----------------------------------------------------------------------------
729 // frame state (iconized/maximized/...)
730 // ----------------------------------------------------------------------------
732 // propagate our state change to all child frames: this allows us to emulate X
733 // Windows behaviour where child frames float independently of the parent one
734 // on the desktop, but are iconized/restored with it
735 void wxFrame
::IconizeChildFrames(bool bIconize
)
737 m_iconized
= bIconize
;
739 for ( wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
741 node
= node
->GetNext() )
743 wxWindow
*win
= node
->GetData();
745 // iconizing the frames with this style under Win95 shell puts them at
746 // the bottom of the screen (as the MDI children) instead of making
747 // them appear in the taskbar because they are, by virtue of this
748 // style, not managed by the taskbar - instead leave Windows take care
750 if ( win
->GetWindowStyle() & wxFRAME_TOOL_WINDOW
)
753 // the child MDI frames are a special case and should not be touched by
754 // the parent frame - instead, they are managed by the user
755 wxFrame
*frame
= wxDynamicCast(win
, wxFrame
);
757 #if wxUSE_MDI_ARCHITECTURE
758 && !frame
->IsMDIChild()
759 #endif // wxUSE_MDI_ARCHITECTURE
762 // we don't want to restore the child frames which had been
763 // iconized even before we were iconized, so save the child frame
764 // status when iconizing the parent frame and check it when
768 frame
->m_wasMinimized
= frame
->IsIconized();
771 // note that we shouldn't touch the hidden frames neither because
772 // iconizing/restoring them would show them as a side effect
773 if ( !frame
->m_wasMinimized
&& frame
->IsShown() )
774 frame
->Iconize(bIconize
);
779 WXHICON wxFrame
::GetDefaultIcon() const
781 // we don't have any standard icons (any more)
785 // ===========================================================================
786 // message processing
787 // ===========================================================================
789 // ---------------------------------------------------------------------------
791 // ---------------------------------------------------------------------------
793 bool wxFrame
::MSWDoTranslateMessage(wxFrame
*frame
, WXMSG
*pMsg
)
795 if ( wxWindow
::MSWTranslateMessage(pMsg
) )
798 #if wxUSE_MENUS && wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
799 // try the menu bar accels
800 wxMenuBar
*menuBar
= GetMenuBar();
803 const wxAcceleratorTable
& acceleratorTable
= menuBar
->GetAccelTable();
804 return acceleratorTable
.Translate(frame
, pMsg
);
806 #endif // wxUSE_MENUS && wxUSE_ACCEL
811 // ---------------------------------------------------------------------------
812 // our private (non virtual) message handlers
813 // ---------------------------------------------------------------------------
815 bool wxFrame
::HandlePaint()
818 if ( ::GetUpdateRect(GetHwnd(), &rect
, FALSE
) )
820 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
823 const wxIcon
& icon
= GetIcon();
824 HICON hIcon
= icon
.Ok() ?
GetHiconOf(icon
)
825 : (HICON
)GetDefaultIcon();
827 // Hold a pointer to the dc so long as the OnPaint() message
828 // is being processed
830 HDC hdc
= ::BeginPaint(GetHwnd(), &ps
);
832 // Erase background before painting or we get white background
833 MSWDefWindowProc(WM_ICONERASEBKGND
, (WORD
)(LONG
)ps
.hdc
, 0L);
838 ::GetClientRect(GetHwnd(), &rect
);
840 // FIXME: why hardcoded?
841 static const int icon_width
= 32;
842 static const int icon_height
= 32;
844 int icon_x
= (int)((rect
.right
- icon_width
)/2);
845 int icon_y
= (int)((rect
.bottom
- icon_height
)/2);
847 ::DrawIcon(hdc
, icon_x
, icon_y
, hIcon
);
850 ::EndPaint(GetHwnd(), &ps
);
857 return wxWindow
::HandlePaint();
862 // nothing to paint - processed
867 bool wxFrame
::HandleSize(int WXUNUSED(x
), int WXUNUSED(y
), WXUINT id
)
869 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
874 // only do it it if we were iconized before, otherwise resizing the
875 // parent frame has a curious side effect of bringing it under it's
880 // restore all child frames too
881 IconizeChildFrames(false);
883 (void)SendIconizeEvent(false);
887 // iconize all child frames too
888 IconizeChildFrames(true);
893 #endif // !__WXWINCE__
899 #endif // wxUSE_STATUSBAR
903 #endif // wxUSE_TOOLBAR
905 #if defined(WINCE_WITH_COMMANDBAR)
906 // Position the menu command bar
907 if (GetMenuBar() && GetMenuBar()->GetCommandBar())
910 ::GetWindowRect((HWND
) GetMenuBar()->GetCommandBar(), &rect
);
911 wxSize clientSz
= GetClientSize();
913 if ( !::MoveWindow((HWND
) GetMenuBar()->GetCommandBar(), 0, 0, clientSz
.x
, rect
.bottom
- rect
.top
, true ) )
915 wxLogLastError(wxT("MoveWindow"));
919 #endif // WINCE_WITH_COMMANDBAR
922 // call the base class version to generate the appropriate events
926 bool wxFrame
::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
930 // In case it's e.g. a toolbar.
931 wxWindow
*win
= wxFindWinFromHandle(control
);
933 return win
->MSWCommand(cmd
, id
);
936 // handle here commands from menus and accelerators
937 if ( cmd
== 0 || cmd
== 1 )
939 #if wxUSE_MENUS_NATIVE
940 if ( wxCurrentPopupMenu
)
942 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
943 wxCurrentPopupMenu
= NULL
;
945 return popupMenu
->MSWCommand(cmd
, id
);
947 #endif // wxUSE_MENUS_NATIVE
949 #if defined(__SMARTPHONE__) && defined(__WXWINCE__)
950 // handle here commands from Smartphone menu bar
951 if ( wxTopLevelWindow
::HandleCommand(id
, cmd
, control
) )
955 #endif // __SMARTPHONE__ && __WXWINCE__
957 if ( ProcessCommand(id
) )
966 bool wxFrame
::HandleMenuSelect(WXWORD nItem
, WXWORD flags
, WXHMENU hMenu
)
969 if ( flags
== 0xFFFF && hMenu
== 0 )
971 // menu was removed from screen
974 #ifndef __WXMICROWIN__
975 else if ( !(flags
& MF_POPUP
) && !(flags
& MF_SEPARATOR
) )
982 // don't give hints for separators (doesn't make sense) nor for the
983 // items opening popup menus (they don't have them anyhow) but do clear
984 // the status line - otherwise, we would be left with the help message
985 // for the previous item which doesn't apply any more
986 DoGiveHelp(wxEmptyString
, false);
991 wxMenuEvent
event(wxEVT_MENU_HIGHLIGHT
, item
);
992 event
.SetEventObject(this);
994 return GetEventHandler()->ProcessEvent(event
);
997 bool wxFrame
::HandleMenuLoop(const wxEventType
& evtType
, WXWORD isPopup
)
999 // we don't have the menu id here, so we use the id to specify if the event
1000 // was from a popup menu or a normal one
1001 wxMenuEvent
event(evtType
, isPopup ?
-1 : 0);
1002 event
.SetEventObject(this);
1004 return GetEventHandler()->ProcessEvent(event
);
1007 // ---------------------------------------------------------------------------
1008 // the window proc for wxFrame
1009 // ---------------------------------------------------------------------------
1011 WXLRESULT wxFrame
::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
1014 bool processed
= false;
1019 // if we can't close, tell the system that we processed the
1020 // message - otherwise it would close us
1021 processed
= !Close();
1025 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
1032 UnpackCommand((WXWPARAM
)wParam
, (WXLPARAM
)lParam
,
1035 processed
= HandleCommand(id
, cmd
, (WXHWND
)hwnd
);
1040 processed
= HandlePaint();
1043 case WM_INITMENUPOPUP
:
1044 processed
= HandleInitMenuPopup((WXHMENU
) wParam
);
1047 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1052 UnpackMenuSelect(wParam
, lParam
, &item
, &flags
, &hmenu
);
1054 processed
= HandleMenuSelect(item
, flags
, hmenu
);
1058 case WM_EXITMENULOOP
:
1059 processed
= HandleMenuLoop(wxEVT_MENU_CLOSE
, (WXWORD
)wParam
);
1062 case WM_QUERYDRAGICON
:
1064 const wxIcon
& icon
= GetIcon();
1065 HICON hIcon
= icon
.Ok() ?
GetHiconOf(icon
)
1066 : (HICON
)GetDefaultIcon();
1068 processed
= rc
!= 0;
1071 #endif // !__WXMICROWIN__
1075 rc
= wxFrameBase
::MSWWindowProc(message
, wParam
, lParam
);
1080 // handle WM_INITMENUPOPUP message
1081 bool wxFrame
::HandleInitMenuPopup(WXHMENU hMenu
)
1083 wxMenu
* menu
= NULL
;
1086 int nCount
= GetMenuBar()->GetMenuCount();
1087 for (int n
= 0; n
< nCount
; n
++)
1089 if (GetMenuBar()->GetMenu(n
)->GetHMenu() == hMenu
)
1091 menu
= GetMenuBar()->GetMenu(n
);
1097 wxMenuEvent
event(wxEVT_MENU_OPEN
, 0, menu
);
1098 event
.SetEventObject(this);
1100 return GetEventHandler()->ProcessEvent(event
);
1103 // ----------------------------------------------------------------------------
1104 // wxFrame size management: we exclude the areas taken by menu/status/toolbars
1105 // from the client area, so the client area is what's really available for the
1107 // ----------------------------------------------------------------------------
1109 // get the origin of the client area in the client coordinates
1110 wxPoint wxFrame
::GetClientAreaOrigin() const
1112 wxPoint pt
= wxTopLevelWindow
::GetClientAreaOrigin();
1114 #if wxUSE_TOOLBAR && !defined(__WXUNIVERSAL__) && \
1115 (!defined(__WXWINCE__) || (_WIN32_WCE >= 400 && !defined(__POCKETPC__) && !defined(__SMARTPHONE__)))
1116 wxToolBar
* const toolbar
= GetToolBar();
1117 if ( toolbar
&& toolbar
->IsShown() )
1119 const wxSize sizeTB
= toolbar
->GetSize();
1121 if ( toolbar
->HasFlag(wxTB_TOP
) )
1125 else if ( toolbar
->HasFlag(wxTB_LEFT
) )
1130 #endif // wxUSE_TOOLBAR
1132 #if defined(WINCE_WITH_COMMANDBAR)
1133 if (GetMenuBar() && GetMenuBar()->GetCommandBar())
1136 ::GetWindowRect((HWND
) GetMenuBar()->GetCommandBar(), &rect
);
1137 pt
.y
+= (rect
.bottom
- rect
.top
);