]> git.saurik.com Git - wxWidgets.git/blob - src/msw/frame.cpp
use AlphaBlt() when blitting to a bitmap with alpha channel too (patch 991166)
[wxWidgets.git] / src / msw / frame.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: msw/frame.cpp
3 // Purpose: wxFrame
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 01/02/97
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
21 #pragma implementation "frame.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #ifndef WX_PRECOMP
32 #include "wx/frame.h"
33 #include "wx/app.h"
34 #include "wx/menu.h"
35 #include "wx/utils.h"
36 #include "wx/dialog.h"
37 #include "wx/settings.h"
38 #include "wx/dcclient.h"
39 #include "wx/mdi.h"
40 #include "wx/panel.h"
41 #endif // WX_PRECOMP
42
43 #include "wx/msw/private.h"
44
45 #ifdef __WXWINCE__
46 #include <commctrl.h>
47 #endif
48
49 #if wxUSE_STATUSBAR
50 #include "wx/statusbr.h"
51 #include "wx/generic/statusbr.h"
52 #endif // wxUSE_STATUSBAR
53
54 #if wxUSE_TOOLBAR
55 #include "wx/toolbar.h"
56 #endif // wxUSE_TOOLBAR
57
58 #include "wx/menuitem.h"
59 #include "wx/log.h"
60
61 #ifdef __WXUNIVERSAL__
62 #include "wx/univ/theme.h"
63 #include "wx/univ/colschem.h"
64 #endif // __WXUNIVERSAL__
65
66 // ----------------------------------------------------------------------------
67 // globals
68 // ----------------------------------------------------------------------------
69
70 #if wxUSE_MENUS_NATIVE
71 extern wxMenu *wxCurrentPopupMenu;
72 #endif // wxUSE_MENUS_NATIVE
73
74 // ----------------------------------------------------------------------------
75 // event tables
76 // ----------------------------------------------------------------------------
77
78 BEGIN_EVENT_TABLE(wxFrame, wxFrameBase)
79 EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
80 END_EVENT_TABLE()
81
82 #if wxUSE_EXTENDED_RTTI
83 WX_DEFINE_FLAGS( wxFrameStyle )
84
85 wxBEGIN_FLAGS( wxFrameStyle )
86 // new style border flags, we put them first to
87 // use them for streaming out
88 wxFLAGS_MEMBER(wxBORDER_SIMPLE)
89 wxFLAGS_MEMBER(wxBORDER_SUNKEN)
90 wxFLAGS_MEMBER(wxBORDER_DOUBLE)
91 wxFLAGS_MEMBER(wxBORDER_RAISED)
92 wxFLAGS_MEMBER(wxBORDER_STATIC)
93 wxFLAGS_MEMBER(wxBORDER_NONE)
94
95 // old style border flags
96 wxFLAGS_MEMBER(wxSIMPLE_BORDER)
97 wxFLAGS_MEMBER(wxSUNKEN_BORDER)
98 wxFLAGS_MEMBER(wxDOUBLE_BORDER)
99 wxFLAGS_MEMBER(wxRAISED_BORDER)
100 wxFLAGS_MEMBER(wxSTATIC_BORDER)
101 wxFLAGS_MEMBER(wxBORDER)
102
103 // standard window styles
104 wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
105 wxFLAGS_MEMBER(wxCLIP_CHILDREN)
106 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
107 wxFLAGS_MEMBER(wxWANTS_CHARS)
108 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
109 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
110 wxFLAGS_MEMBER(wxVSCROLL)
111 wxFLAGS_MEMBER(wxHSCROLL)
112
113 // frame styles
114 wxFLAGS_MEMBER(wxSTAY_ON_TOP)
115 wxFLAGS_MEMBER(wxCAPTION)
116 wxFLAGS_MEMBER(wxTHICK_FRAME)
117 wxFLAGS_MEMBER(wxSYSTEM_MENU)
118 wxFLAGS_MEMBER(wxRESIZE_BORDER)
119 wxFLAGS_MEMBER(wxRESIZE_BOX)
120 wxFLAGS_MEMBER(wxCLOSE_BOX)
121 wxFLAGS_MEMBER(wxMAXIMIZE_BOX)
122 wxFLAGS_MEMBER(wxMINIMIZE_BOX)
123
124 wxFLAGS_MEMBER(wxFRAME_TOOL_WINDOW)
125 wxFLAGS_MEMBER(wxFRAME_FLOAT_ON_PARENT)
126
127 wxFLAGS_MEMBER(wxFRAME_SHAPED)
128
129 wxEND_FLAGS( wxFrameStyle )
130
131 IMPLEMENT_DYNAMIC_CLASS_XTI(wxFrame, wxTopLevelWindow,"wx/frame.h")
132
133 wxBEGIN_PROPERTIES_TABLE(wxFrame)
134 wxEVENT_PROPERTY( Menu , wxEVT_COMMAND_MENU_SELECTED , wxCommandEvent)
135
136 wxPROPERTY( Title,wxString, SetTitle, GetTitle, wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
137 wxPROPERTY_FLAGS( WindowStyle , wxFrameStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
138 wxPROPERTY( MenuBar , wxMenuBar * , SetMenuBar , GetMenuBar , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
139 wxEND_PROPERTIES_TABLE()
140
141 wxBEGIN_HANDLERS_TABLE(wxFrame)
142 wxEND_HANDLERS_TABLE()
143
144 wxCONSTRUCTOR_6( wxFrame , wxWindow* , Parent , wxWindowID , Id , wxString , Title , wxPoint , Position , wxSize , Size , long , WindowStyle)
145
146 #else
147 IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxTopLevelWindow)
148 #endif
149
150 // ============================================================================
151 // implementation
152 // ============================================================================
153
154 // ----------------------------------------------------------------------------
155 // static class members
156 // ----------------------------------------------------------------------------
157
158 #if wxUSE_STATUSBAR
159 #if wxUSE_NATIVE_STATUSBAR
160 bool wxFrame::m_useNativeStatusBar = true;
161 #else
162 bool wxFrame::m_useNativeStatusBar = false;
163 #endif
164 #endif // wxUSE_NATIVE_STATUSBAR
165
166 // ----------------------------------------------------------------------------
167 // creation/destruction
168 // ----------------------------------------------------------------------------
169
170 void wxFrame::Init()
171 {
172 #if wxUSE_TOOLTIPS
173 m_hwndToolTip = 0;
174 #endif
175
176 // Data to save/restore when calling ShowFullScreen
177 m_fsStatusBarFields = 0;
178 m_fsStatusBarHeight = 0;
179 m_fsToolBarHeight = 0;
180
181 m_wasMinimized = false;
182 }
183
184 bool wxFrame::Create(wxWindow *parent,
185 wxWindowID id,
186 const wxString& title,
187 const wxPoint& pos,
188 const wxSize& size,
189 long style,
190 const wxString& name)
191 {
192 if ( !wxTopLevelWindow::Create(parent, id, title, pos, size, style, name) )
193 return false;
194
195 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
196
197 #if defined(__SMARTPHONE__) && defined(__WXWINCE__)
198 SetLeftMenu(wxID_EXIT, _("Done"));
199 #endif
200
201 return true;
202 }
203
204 wxFrame::~wxFrame()
205 {
206 m_isBeingDeleted = true;
207 DeleteAllBars();
208 }
209
210 // ----------------------------------------------------------------------------
211 // wxFrame client size calculations
212 // ----------------------------------------------------------------------------
213
214 void wxFrame::DoSetClientSize(int width, int height)
215 {
216 // leave enough space for the status bar if we have (and show) it
217 #if wxUSE_STATUSBAR
218 wxStatusBar *statbar = GetStatusBar();
219 if ( statbar && statbar->IsShown() )
220 {
221 height += statbar->GetSize().y;
222 }
223 #endif // wxUSE_STATUSBAR
224
225 // call GetClientAreaOrigin() to take the toolbar into account
226 wxPoint pt = GetClientAreaOrigin();
227 width += pt.x;
228 height += pt.y;
229
230 wxTopLevelWindow::DoSetClientSize(width, height);
231 }
232
233 // Get size *available for subwindows* i.e. excluding menu bar, toolbar etc.
234 void wxFrame::DoGetClientSize(int *x, int *y) const
235 {
236 wxTopLevelWindow::DoGetClientSize(x, y);
237
238 // account for the possible toolbar
239 wxPoint pt = GetClientAreaOrigin();
240 if ( x )
241 *x -= pt.x;
242
243 if ( y )
244 *y -= pt.y;
245
246 #if wxUSE_STATUSBAR
247 // adjust client area height to take the status bar into account
248 if ( y )
249 {
250 wxStatusBar *statbar = GetStatusBar();
251 if ( statbar && statbar->IsShown() )
252 {
253 *y -= statbar->GetClientSize().y;
254 }
255 }
256 #endif // wxUSE_STATUSBAR
257 }
258
259 // ----------------------------------------------------------------------------
260 // wxFrame: various geometry-related functions
261 // ----------------------------------------------------------------------------
262
263 void wxFrame::Raise()
264 {
265 ::SetForegroundWindow(GetHwnd());
266 }
267
268 // generate an artificial resize event
269 void wxFrame::SendSizeEvent()
270 {
271 if ( !m_iconized )
272 {
273 RECT r = wxGetWindowRect(GetHwnd());
274
275 (void)::PostMessage(GetHwnd(), WM_SIZE,
276 IsMaximized() ? SIZE_MAXIMIZED : SIZE_RESTORED,
277 MAKELPARAM(r.right - r.left, r.bottom - r.top));
278 }
279 }
280
281 #if wxUSE_STATUSBAR
282 wxStatusBar *wxFrame::OnCreateStatusBar(int number,
283 long style,
284 wxWindowID id,
285 const wxString& name)
286 {
287 wxStatusBar *statusBar wxDUMMY_INITIALIZE(NULL);
288
289 #if wxUSE_NATIVE_STATUSBAR
290 if ( !UsesNativeStatusBar() )
291 {
292 statusBar = (wxStatusBar *)new wxStatusBarGeneric(this, id, style);
293 }
294 else
295 #endif
296 {
297 statusBar = new wxStatusBar(this, id, style, name);
298 }
299
300 statusBar->SetFieldsCount(number);
301
302 return statusBar;
303 }
304
305 void wxFrame::PositionStatusBar()
306 {
307 if ( !m_frameStatusBar || !m_frameStatusBar->IsShown() )
308 return;
309
310 int w, h;
311 GetClientSize(&w, &h);
312 int sw, sh;
313 m_frameStatusBar->GetSize(&sw, &sh);
314
315 // Since we wish the status bar to be directly under the client area,
316 // we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS.
317 m_frameStatusBar->SetSize(0, h, w, sh);
318 }
319 #endif // wxUSE_STATUSBAR
320
321 #if wxUSE_MENUS_NATIVE
322
323 void wxFrame::AttachMenuBar(wxMenuBar *menubar)
324 {
325 #if defined(__SMARTPHONE__) && defined(__WXWINCE__)
326
327 wxMenu *autoMenu = NULL;
328
329 if( menubar->GetMenuCount() == 1 )
330 {
331 autoMenu = wxTopLevelWindowMSW::ButtonMenu::DuplicateMenu(menubar->GetMenu(0));
332 SetRightMenu(wxID_ANY, menubar->GetLabelTop(0), autoMenu);
333 }
334 else
335 {
336 autoMenu = new wxMenu;
337
338 for( size_t n = 0; n < menubar->GetMenuCount(); n++ )
339 {
340 wxMenu *item = menubar->GetMenu(n);
341 wxString label = menubar->GetLabelTop(n);
342 wxMenu *new_item = wxTopLevelWindowMSW::ButtonMenu::DuplicateMenu(item);
343 autoMenu->Append(wxID_ANY, label, new_item);
344 }
345
346 SetRightMenu(wxID_ANY, _("Menu"), autoMenu);
347 }
348
349 #elif defined(WINCE_WITHOUT_COMMANDBAR)
350 if (!GetToolBar())
351 {
352 wxToolBar* toolBar = new wxToolBar(this, wxID_ANY,
353 wxDefaultPosition, wxDefaultSize,
354 wxBORDER_NONE | wxTB_HORIZONTAL,
355 wxToolBarNameStr, menubar);
356 SetToolBar(toolBar);
357 menubar->SetToolBar(toolBar);
358 }
359 // Now adjust size for menu bar
360 int menuHeight = 26;
361
362 //When the main window is created using CW_USEDEFAULT the height of the
363 // is created is not taken into account). So we resize the window after
364 // if a menubar is present
365 {
366 RECT rc;
367 ::GetWindowRect((HWND) GetHWND(), &rc);
368 // adjust for menu / titlebar height
369 rc.bottom -= (2*menuHeight-1);
370
371 ::MoveWindow((HWND) GetHWND(), rc.left, rc.top, rc.right, rc.bottom, FALSE);
372 }
373 #endif
374
375 wxFrameBase::AttachMenuBar(menubar);
376
377 if ( !menubar )
378 {
379 // actually remove the menu from the frame
380 m_hMenu = (WXHMENU)0;
381 InternalSetMenuBar();
382 }
383 else // set new non NULL menu bar
384 {
385 #if !defined(__WXWINCE__) || defined(WINCE_WITH_COMMANDBAR)
386 // Can set a menubar several times.
387 if ( menubar->GetHMenu() )
388 {
389 m_hMenu = menubar->GetHMenu();
390 }
391 else // no HMENU yet
392 {
393 m_hMenu = menubar->Create();
394
395 if ( !m_hMenu )
396 {
397 wxFAIL_MSG( _T("failed to create menu bar") );
398 return;
399 }
400 }
401 #endif
402 InternalSetMenuBar();
403 }
404 }
405
406 void wxFrame::InternalSetMenuBar()
407 {
408 #if defined(__WXMICROWIN__) || defined(__WXWINCE__)
409 // Nothing
410 #else
411 if ( !::SetMenu(GetHwnd(), (HMENU)m_hMenu) )
412 {
413 wxLogLastError(wxT("SetMenu"));
414 }
415 #endif
416 }
417
418 #endif // wxUSE_MENUS_NATIVE
419
420 // Responds to colour changes, and passes event on to children.
421 void wxFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
422 {
423 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
424 Refresh();
425
426 #if wxUSE_STATUSBAR
427 if ( m_frameStatusBar )
428 {
429 wxSysColourChangedEvent event2;
430 event2.SetEventObject( m_frameStatusBar );
431 m_frameStatusBar->GetEventHandler()->ProcessEvent(event2);
432 }
433 #endif // wxUSE_STATUSBAR
434
435 // Propagate the event to the non-top-level children
436 wxWindow::OnSysColourChanged(event);
437 }
438
439 // Pass true to show full screen, false to restore.
440 bool wxFrame::ShowFullScreen(bool show, long style)
441 {
442 if ( IsFullScreen() == show )
443 return false;
444
445 if (show)
446 {
447 #if wxUSE_TOOLBAR
448
449 #if defined(WINCE_WITH_COMMANDBAR)
450 // TODO: hide commandbar
451 #else
452 wxToolBar *theToolBar = GetToolBar();
453 if (theToolBar)
454 theToolBar->GetSize(NULL, &m_fsToolBarHeight);
455
456 // zap the toolbar, menubar, and statusbar
457
458 if ((style & wxFULLSCREEN_NOTOOLBAR) && theToolBar)
459 {
460 theToolBar->SetSize(wxDefaultCoord,0);
461 theToolBar->Show(false);
462 }
463 #endif // __WXWINCE__
464 #endif // wxUSE_TOOLBAR
465
466 #if defined(__WXMICROWIN__)
467 #elif defined(__WXWINCE__)
468 // TODO: make it work for WinCE
469 #else
470 if (style & wxFULLSCREEN_NOMENUBAR)
471 SetMenu((HWND)GetHWND(), (HMENU) NULL);
472 #endif
473
474 #if wxUSE_STATUSBAR
475 wxStatusBar *theStatusBar = GetStatusBar();
476 if (theStatusBar)
477 theStatusBar->GetSize(NULL, &m_fsStatusBarHeight);
478
479 // Save the number of fields in the statusbar
480 if ((style & wxFULLSCREEN_NOSTATUSBAR) && theStatusBar)
481 {
482 //m_fsStatusBarFields = theStatusBar->GetFieldsCount();
483 //SetStatusBar((wxStatusBar*) NULL);
484 //delete theStatusBar;
485 theStatusBar->Show(false);
486 }
487 else
488 m_fsStatusBarFields = 0;
489 #endif // wxUSE_STATUSBAR
490 }
491 else
492 {
493 #if wxUSE_TOOLBAR
494 #if defined(WINCE_WITHOUT_COMMANDBAR)
495 // TODO: show commandbar
496 #else
497 wxToolBar *theToolBar = GetToolBar();
498
499 // restore the toolbar, menubar, and statusbar
500 if (theToolBar && (m_fsStyle & wxFULLSCREEN_NOTOOLBAR))
501 {
502 theToolBar->SetSize(wxDefaultCoord, m_fsToolBarHeight);
503 theToolBar->Show(true);
504 }
505 #endif // __WXWINCE__
506 #endif // wxUSE_TOOLBAR
507
508 #if wxUSE_STATUSBAR
509 if ( m_fsStyle & wxFULLSCREEN_NOSTATUSBAR )
510 {
511 //CreateStatusBar(m_fsStatusBarFields);
512 if (GetStatusBar())
513 {
514 GetStatusBar()->Show(true);
515 PositionStatusBar();
516 }
517 }
518 #endif // wxUSE_STATUSBAR
519
520 #if defined(__WXMICROWIN__)
521 #elif defined(__WXWINCE__)
522 // TODO: make it work for WinCE
523 #else
524 if ((m_fsStyle & wxFULLSCREEN_NOMENUBAR) && (m_hMenu != 0))
525 SetMenu((HWND)GetHWND(), (HMENU)m_hMenu);
526 #endif
527 }
528
529 return wxFrameBase::ShowFullScreen(show, style);
530 }
531
532 // ----------------------------------------------------------------------------
533 // tool/status bar stuff
534 // ----------------------------------------------------------------------------
535
536 #if wxUSE_TOOLBAR
537
538 wxToolBar* wxFrame::CreateToolBar(long style, wxWindowID id, const wxString& name)
539 {
540 #if defined(WINCE_WITHOUT_COMMANDBAR)
541 // We may already have a toolbar from calling SetMenuBar.
542 if (GetToolBar())
543 return GetToolBar();
544 #endif
545 if ( wxFrameBase::CreateToolBar(style, id, name) )
546 {
547 PositionToolBar();
548 }
549
550 return m_frameToolBar;
551 }
552
553 void wxFrame::PositionToolBar()
554 {
555 wxToolBar *toolbar = GetToolBar();
556 if ( toolbar && toolbar->IsShown() )
557 {
558 #if defined(WINCE_WITHOUT_COMMANDBAR)
559 // We want to do something different in WinCE, because
560 // the toolbar should be associated with the commandbar,
561 // and not an independent window.
562 // TODO
563 #else
564 // don't call our (or even wxTopLevelWindow) version because we want
565 // the real (full) client area size, not excluding the tool/status bar
566 int width, height;
567 wxWindow::DoGetClientSize(&width, &height);
568
569 #if wxUSE_STATUSBAR
570 wxStatusBar *statbar = GetStatusBar();
571 if ( statbar && statbar->IsShown() )
572 {
573 height -= statbar->GetClientSize().y;
574 }
575 #endif // wxUSE_STATUSBAR
576
577 int x = 0;
578 int y = 0;
579 #if defined(WINCE_WITH_COMMANDBAR)
580 // We're using a commandbar - so we have to allow for it.
581 if (GetMenuBar() && GetMenuBar()->GetCommandBar())
582 {
583 RECT rect;
584 ::GetWindowRect((HWND) GetMenuBar()->GetCommandBar(), &rect);
585 y = rect.bottom - rect.top;
586 }
587 #endif
588
589 int tx, ty;
590 int tw, th;
591 toolbar->GetPosition(&tx, &ty);
592 toolbar->GetSize(&tw, &th);
593
594 // Adjust
595 if (ty < 0 && (-ty == th))
596 ty = 0;
597 if (tx < 0 && (-tx == tw))
598 tx = 0;
599
600 int desiredW = tw;
601 int desiredH = th;
602
603 if ( toolbar->GetWindowStyleFlag() & wxTB_VERTICAL )
604 {
605 desiredH = height;
606 }
607 else
608 {
609 desiredW = width;
610 // if ( toolbar->GetWindowStyleFlag() & wxTB_FLAT )
611 // desiredW -= 3;
612 }
613
614 // use the 'real' MSW position here, don't offset relativly to the
615 // client area origin
616
617 // Optimise such that we don't have to always resize the toolbar
618 // when the frame changes, otherwise we'll get a lot of flicker.
619 bool heightChanging wxDUMMY_INITIALIZE(true);
620 bool widthChanging wxDUMMY_INITIALIZE(true);
621
622 if ( toolbar->GetWindowStyleFlag() & wxTB_VERTICAL )
623 {
624 // It's OK if the current height is greater than what can be shown.
625 heightChanging = (desiredH > th) ;
626 widthChanging = (desiredW != tw) ;
627
628 // The next time around, we may not have to set the size
629 if (heightChanging)
630 desiredH = desiredH + 200;
631 }
632 else
633 {
634 // It's OK if the current width is greater than what can be shown.
635 widthChanging = (desiredW > tw) ;
636 heightChanging = (desiredH != th) ;
637
638 // The next time around, we may not have to set the size
639 if (widthChanging)
640 desiredW = desiredW + 200;
641 }
642
643 if (tx != 0 || ty != 0 || widthChanging || heightChanging)
644 toolbar->SetSize(x, y, desiredW, desiredH, wxSIZE_NO_ADJUSTMENTS);
645
646 #endif // __WXWINCE__
647 }
648 }
649
650 #endif // wxUSE_TOOLBAR
651
652 // ----------------------------------------------------------------------------
653 // frame state (iconized/maximized/...)
654 // ----------------------------------------------------------------------------
655
656 // propagate our state change to all child frames: this allows us to emulate X
657 // Windows behaviour where child frames float independently of the parent one
658 // on the desktop, but are iconized/restored with it
659 void wxFrame::IconizeChildFrames(bool bIconize)
660 {
661 m_iconized = bIconize;
662
663 for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
664 node;
665 node = node->GetNext() )
666 {
667 wxWindow *win = node->GetData();
668
669 // iconizing the frames with this style under Win95 shell puts them at
670 // the bottom of the screen (as the MDI children) instead of making
671 // them appear in the taskbar because they are, by virtue of this
672 // style, not managed by the taskbar - instead leave Windows take care
673 // of them
674 #ifdef __WIN95__
675 if ( win->GetWindowStyle() & wxFRAME_TOOL_WINDOW )
676 continue;
677 #endif // Win95
678
679 // the child MDI frames are a special case and should not be touched by
680 // the parent frame - instead, they are managed by the user
681 wxFrame *frame = wxDynamicCast(win, wxFrame);
682 if ( frame
683 #if wxUSE_MDI_ARCHITECTURE
684 && !wxDynamicCast(frame, wxMDIChildFrame)
685 #endif // wxUSE_MDI_ARCHITECTURE
686 )
687 {
688 // we don't want to restore the child frames which had been
689 // iconized even before we were iconized, so save the child frame
690 // status when iconizing the parent frame and check it when
691 // restoring it
692 if ( bIconize )
693 {
694 frame->m_wasMinimized = frame->IsIconized();
695 }
696
697 // note that we shouldn't touch the hidden frames neither because
698 // iconizing/restoring them would show them as a side effect
699 if ( !frame->m_wasMinimized && frame->IsShown() )
700 frame->Iconize(bIconize);
701 }
702 }
703 }
704
705 WXHICON wxFrame::GetDefaultIcon() const
706 {
707 // we don't have any standard icons (any more)
708 return (WXHICON)0;
709 }
710
711 // ===========================================================================
712 // message processing
713 // ===========================================================================
714
715 // ---------------------------------------------------------------------------
716 // preprocessing
717 // ---------------------------------------------------------------------------
718
719 bool wxFrame::MSWTranslateMessage(WXMSG* pMsg)
720 {
721 if ( wxWindow::MSWTranslateMessage(pMsg) )
722 return true;
723
724 #if wxUSE_MENUS && wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
725 // try the menu bar accels
726 wxMenuBar *menuBar = GetMenuBar();
727 if ( !menuBar )
728 return false;
729
730 const wxAcceleratorTable& acceleratorTable = menuBar->GetAccelTable();
731 return acceleratorTable.Translate(this, pMsg);
732 #else
733 return false;
734 #endif // wxUSE_MENUS && wxUSE_ACCEL
735 }
736
737 // ---------------------------------------------------------------------------
738 // our private (non virtual) message handlers
739 // ---------------------------------------------------------------------------
740
741 bool wxFrame::HandlePaint()
742 {
743 RECT rect;
744 if ( ::GetUpdateRect(GetHwnd(), &rect, FALSE) )
745 {
746 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
747 if ( m_iconized )
748 {
749 const wxIcon& icon = GetIcon();
750 HICON hIcon = icon.Ok() ? GetHiconOf(icon)
751 : (HICON)GetDefaultIcon();
752
753 // Hold a pointer to the dc so long as the OnPaint() message
754 // is being processed
755 PAINTSTRUCT ps;
756 HDC hdc = ::BeginPaint(GetHwnd(), &ps);
757
758 // Erase background before painting or we get white background
759 MSWDefWindowProc(WM_ICONERASEBKGND, (WORD)(LONG)ps.hdc, 0L);
760
761 if ( hIcon )
762 {
763 RECT rect;
764 ::GetClientRect(GetHwnd(), &rect);
765
766 // FIXME: why hardcoded?
767 static const int icon_width = 32;
768 static const int icon_height = 32;
769
770 int icon_x = (int)((rect.right - icon_width)/2);
771 int icon_y = (int)((rect.bottom - icon_height)/2);
772
773 ::DrawIcon(hdc, icon_x, icon_y, hIcon);
774 }
775
776 ::EndPaint(GetHwnd(), &ps);
777
778 return true;
779 }
780 else
781 #endif
782 {
783 return wxWindow::HandlePaint();
784 }
785 }
786 else
787 {
788 // nothing to paint - processed
789 return true;
790 }
791 }
792
793 bool wxFrame::HandleSize(int WXUNUSED(x), int WXUNUSED(y), WXUINT id)
794 {
795 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
796 switch ( id )
797 {
798 case SIZE_RESTORED:
799 case SIZE_MAXIMIZED:
800 // only do it it if we were iconized before, otherwise resizing the
801 // parent frame has a curious side effect of bringing it under it's
802 // children
803 if ( !m_iconized )
804 break;
805
806 // restore all child frames too
807 IconizeChildFrames(false);
808
809 (void)SendIconizeEvent(false);
810 break;
811
812 case SIZE_MINIMIZED:
813 // iconize all child frames too
814 IconizeChildFrames(true);
815 break;
816 }
817 #else
818 wxUnusedVar(id);
819 #endif // !__WXWINCE__
820
821 if ( !m_iconized )
822 {
823 #if wxUSE_STATUSBAR
824 PositionStatusBar();
825 #endif // wxUSE_STATUSBAR
826
827 #if wxUSE_TOOLBAR
828 PositionToolBar();
829 #endif // wxUSE_TOOLBAR
830
831 #if defined(WINCE_WITH_COMMANDBAR)
832 // Position the menu command bar
833 if (GetMenuBar() && GetMenuBar()->GetCommandBar())
834 {
835 RECT rect;
836 ::GetWindowRect((HWND) GetMenuBar()->GetCommandBar(), &rect);
837 wxSize clientSz = GetClientSize();
838
839 if ( !::MoveWindow((HWND) GetMenuBar()->GetCommandBar(), 0, 0, clientSz.x, rect.bottom - rect.top, true ) )
840 {
841 wxLogLastError(wxT("MoveWindow"));
842 }
843
844 }
845 #endif // WINCE_WITH_COMMANDBAR
846 }
847
848 // call the base class version to generate the appropriate events
849 return false;
850 }
851
852 bool wxFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
853 {
854 if ( control )
855 {
856 // In case it's e.g. a toolbar.
857 wxWindow *win = wxFindWinFromHandle(control);
858 if ( win )
859 return win->MSWCommand(cmd, id);
860 }
861
862 // handle here commands from menus and accelerators
863 if ( cmd == 0 || cmd == 1 )
864 {
865 #if wxUSE_MENUS_NATIVE
866 if ( wxCurrentPopupMenu )
867 {
868 wxMenu *popupMenu = wxCurrentPopupMenu;
869 wxCurrentPopupMenu = NULL;
870
871 return popupMenu->MSWCommand(cmd, id);
872 }
873 #endif // wxUSE_MENUS_NATIVE
874
875 #if defined(__SMARTPHONE__) && defined(__WXWINCE__)
876 // handle here commands from Smartphone menu bar
877 if ( wxTopLevelWindow::HandleCommand(id, cmd, control ) )
878 {
879 return true;
880 }
881 #endif // __SMARTPHONE__ && __WXWINCE__
882
883 if ( ProcessCommand(id) )
884 {
885 return true;
886 }
887 }
888
889 return false;
890 }
891
892 bool wxFrame::HandleMenuSelect(WXWORD nItem, WXWORD flags, WXHMENU hMenu)
893 {
894 int item;
895 if ( flags == 0xFFFF && hMenu == 0 )
896 {
897 // menu was removed from screen
898 item = -1;
899 }
900 #ifndef __WXMICROWIN__
901 else if ( !(flags & MF_POPUP) && !(flags & MF_SEPARATOR) )
902 {
903 item = nItem;
904 }
905 #endif
906 else
907 {
908 // don't give hints for separators (doesn't make sense) nor for the
909 // items opening popup menus (they don't have them anyhow) but do clear
910 // the status line - otherwise, we would be left with the help message
911 // for the previous item which doesn't apply any more
912 DoGiveHelp(wxEmptyString, false);
913
914 return false;
915 }
916
917 wxMenuEvent event(wxEVT_MENU_HIGHLIGHT, item);
918 event.SetEventObject(this);
919
920 return GetEventHandler()->ProcessEvent(event);
921 }
922
923 bool wxFrame::HandleMenuLoop(const wxEventType& evtType, WXWORD isPopup)
924 {
925 // we don't have the menu id here, so we use the id to specify if the event
926 // was from a popup menu or a normal one
927 wxMenuEvent event(evtType, isPopup ? -1 : 0);
928 event.SetEventObject(this);
929
930 return GetEventHandler()->ProcessEvent(event);
931 }
932
933 // ---------------------------------------------------------------------------
934 // the window proc for wxFrame
935 // ---------------------------------------------------------------------------
936
937 WXLRESULT wxFrame::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
938 {
939 WXLRESULT rc = 0;
940 bool processed = false;
941
942 switch ( message )
943 {
944 case WM_CLOSE:
945 // if we can't close, tell the system that we processed the
946 // message - otherwise it would close us
947 processed = !Close();
948 break;
949
950 case WM_SIZE:
951 processed = HandleSize(LOWORD(lParam), HIWORD(lParam), wParam);
952 break;
953
954 case WM_COMMAND:
955 {
956 WORD id, cmd;
957 WXHWND hwnd;
958 UnpackCommand((WXWPARAM)wParam, (WXLPARAM)lParam,
959 &id, &hwnd, &cmd);
960
961 processed = HandleCommand(id, cmd, (WXHWND)hwnd);
962 }
963 break;
964
965 case WM_PAINT:
966 processed = HandlePaint();
967 break;
968
969 case WM_INITMENUPOPUP:
970 processed = HandleInitMenuPopup((WXHMENU) wParam);
971 break;
972
973 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
974 case WM_MENUSELECT:
975 {
976 WXWORD item, flags;
977 WXHMENU hmenu;
978 UnpackMenuSelect(wParam, lParam, &item, &flags, &hmenu);
979
980 processed = HandleMenuSelect(item, flags, hmenu);
981 }
982 break;
983
984 case WM_EXITMENULOOP:
985 processed = HandleMenuLoop(wxEVT_MENU_CLOSE, wParam);
986 break;
987
988 case WM_QUERYDRAGICON:
989 {
990 const wxIcon& icon = GetIcon();
991 HICON hIcon = icon.Ok() ? GetHiconOf(icon)
992 : (HICON)GetDefaultIcon();
993 rc = (long)hIcon;
994 processed = rc != 0;
995 }
996 break;
997 #endif // !__WXMICROWIN__
998 }
999
1000 if ( !processed )
1001 rc = wxFrameBase::MSWWindowProc(message, wParam, lParam);
1002
1003 return rc;
1004 }
1005
1006 // handle WM_INITMENUPOPUP message
1007 bool wxFrame::HandleInitMenuPopup(WXHMENU hMenu)
1008 {
1009 wxMenu* menu = NULL;
1010 if (GetMenuBar())
1011 {
1012 int nCount = GetMenuBar()->GetMenuCount();
1013 for (int n = 0; n < nCount; n++)
1014 {
1015 if (GetMenuBar()->GetMenu(n)->GetHMenu() == hMenu)
1016 {
1017 menu = GetMenuBar()->GetMenu(n);
1018 break;
1019 }
1020 }
1021 }
1022
1023 wxMenuEvent event(wxEVT_MENU_OPEN, 0, menu);
1024 event.SetEventObject(this);
1025
1026 return GetEventHandler()->ProcessEvent(event);
1027 }
1028
1029 // ----------------------------------------------------------------------------
1030 // wxFrame size management: we exclude the areas taken by menu/status/toolbars
1031 // from the client area, so the client area is what's really available for the
1032 // frame contents
1033 // ----------------------------------------------------------------------------
1034
1035 // get the origin of the client area in the client coordinates
1036 wxPoint wxFrame::GetClientAreaOrigin() const
1037 {
1038 wxPoint pt = wxTopLevelWindow::GetClientAreaOrigin();
1039
1040 #if wxUSE_TOOLBAR && !defined(__WXUNIVERSAL__) && \
1041 (!defined(__WXWINCE__) || (_WIN32_WCE >= 400 && !defined(__POCKETPC__) && !defined(__SMARTPHONE__)))
1042 wxToolBar *toolbar = GetToolBar();
1043 if ( toolbar && toolbar->IsShown() )
1044 {
1045 int w, h;
1046 toolbar->GetSize(&w, &h);
1047
1048 if ( toolbar->GetWindowStyleFlag() & wxTB_VERTICAL )
1049 {
1050 pt.x += w;
1051 }
1052 else
1053 {
1054 pt.y += h;
1055 }
1056 }
1057 #endif // wxUSE_TOOLBAR
1058
1059 #if defined(WINCE_WITH_COMMANDBAR)
1060 if (GetMenuBar() && GetMenuBar()->GetCommandBar())
1061 {
1062 RECT rect;
1063 ::GetWindowRect((HWND) GetMenuBar()->GetCommandBar(), &rect);
1064 pt.y += (rect.bottom - rect.top);
1065 }
1066 #endif
1067
1068 return pt;
1069 }