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