projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Added missing include for non-precompiled headers.
[wxWidgets.git] / src / os2 / frame.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: frame.cpp
3 // Purpose: wxFrame
4 // Author: David Webster
5 // Modified by:
6 // Created: 10/27/99
7 // RCS-ID: $Id$
8 // Copyright: (c) David Webster
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
14
15 #ifndef WX_PRECOMP
16 #include "wx/defs.h"
17 #include "wx/object.h"
18 #include "wx/dynarray.h"
19 #include "wx/list.h"
20 #include "wx/hash.h"
21 #include "wx/string.h"
22 #include "wx/intl.h"
23 #include "wx/log.h"
24 #include "wx/event.h"
25 #include "wx/setup.h"
26 #include "wx/frame.h"
27 #include "wx/menu.h"
28 #include "wx/app.h"
29 #include "wx/utils.h"
30 #include "wx/dialog.h"
31 #include "wx/settings.h"
32 #include "wx/dcclient.h"
33 #include "wx/mdi.h"
34 #endif // WX_PRECOMP
35
36 #include "wx/os2/private.h"
37
38 #if wxUSE_STATUSBAR
39 #include "wx/statusbr.h"
40 #include "wx/generic/statusbr.h"
41 #endif // wxUSE_STATUSBAR
42
43 #if wxUSE_TOOLBAR
44 #include "wx/toolbar.h"
45 #endif // wxUSE_TOOLBAR
46
47 #include "wx/menuitem.h"
48 #include "wx/log.h"
49
50 // ----------------------------------------------------------------------------
51 // globals
52 // ----------------------------------------------------------------------------
53
54 extern wxWindowList wxModelessWindows;
55 extern wxList WXDLLEXPORT wxPendingDelete;
56
57 #if wxUSE_MENUS_NATIVE
58 extern wxMenu *wxCurrentPopupMenu;
59 #endif
60
61 extern void wxAssociateWinWithHandle( HWND hWnd
62 ,wxWindowOS2* pWin
63 );
64
65 // ----------------------------------------------------------------------------
66 // event tables
67 // ----------------------------------------------------------------------------
68
69 BEGIN_EVENT_TABLE(wxFrame, wxFrameBase)
70 EVT_ACTIVATE(wxFrame::OnActivate)
71 EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
72 END_EVENT_TABLE()
73
74 IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
75
76 // ============================================================================
77 // implementation
78 // ============================================================================
79
80 // ----------------------------------------------------------------------------
81 // static class members
82 // ----------------------------------------------------------------------------
83 #if wxUSE_STATUSBAR
84
85 #if wxUSE_NATIVE_STATUSBAR
86 bool wxFrame::m_bUseNativeStatusBar = TRUE;
87 #else
88 bool wxFrame::m_bUseNativeStatusBar = FALSE;
89 #endif
90
91 #endif //wxUSE_STATUSBAR
92
93 // ----------------------------------------------------------------------------
94 // creation/destruction
95 // ----------------------------------------------------------------------------
96
97 void wxFrame::Init()
98 {
99 m_nFsStatusBarFields = 0;
100 m_nFsStatusBarHeight = 0;
101 m_nFsToolBarHeight = 0;
102 m_hWndToolTip = 0L;
103 m_bWasMinimized = FALSE;
104 m_pWinLastFocused = NULL;
105
106
107 m_frameMenuBar = NULL;
108 m_frameToolBar = NULL;
109 m_frameStatusBar = NULL;
110
111 m_hTitleBar = NULLHANDLE;
112 m_hHScroll = NULLHANDLE;
113 m_hVScroll = NULLHANDLE;
114
115 //
116 // Initialize SWP's
117 //
118 memset(&m_vSwpTitleBar, 0, sizeof(SWP));
119 memset(&m_vSwpMenuBar, 0, sizeof(SWP));
120 memset(&m_vSwpHScroll, 0, sizeof(SWP));
121 memset(&m_vSwpVScroll, 0, sizeof(SWP));
122 memset(&m_vSwpStatusBar, 0, sizeof(SWP));
123 memset(&m_vSwpToolBar, 0, sizeof(SWP));
124 m_bIconized = FALSE;
125
126 } // end of wxFrame::Init
127
128 bool wxFrame::Create(
129 wxWindow* pParent
130 , wxWindowID vId
131 , const wxString& rsTitle
132 , const wxPoint& rPos
133 , const wxSize& rSize
134 , long lStyle
135 , const wxString& rsName
136 )
137 {
138 if (!wxTopLevelWindow::Create( pParent
139 ,vId
140 ,rsTitle
141 ,rPos
142 ,rSize
143 ,lStyle
144 ,rsName
145 ))
146 return FALSE;
147 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
148 wxModelessWindows.Append(this);
149 return TRUE;
150 } // end of wxFrame::Create
151
152 wxFrame::~wxFrame()
153 {
154 m_isBeingDeleted = TRUE;
155 DeleteAllBars();
156 } // end of wxFrame::~wxFrame
157
158 //
159 // Get size *available for subwindows* i.e. excluding menu bar, toolbar etc.
160 //
161 void wxFrame::DoGetClientSize(
162 int* pX
163 , int* pY
164 ) const
165 {
166 wxTopLevelWindow::DoGetClientSize( pX
167 ,pY
168 );
169 //
170 // No need to use statusbar code as in WIN32 as the FORMATFRAME
171 // window procedure ensures PM knows about the new frame client
172 // size internally. A ::WinQueryWindowRect (that is called in
173 // wxWindow's GetClient size from above) is all that is needed!
174 //
175 } // end of wxFrame::DoGetClientSize
176
177 //
178 // Set the client size (i.e. leave the calculation of borders etc.
179 // to wxWindows)
180 //
181 void wxFrame::DoSetClientSize(
182 int nWidth
183 , int nHeight
184 )
185 {
186 wxStatusBar* pStatusBar = GetStatusBar();
187
188 //
189 // Statusbars are not part of the OS/2 Client but parent frame
190 // so no statusbar consideration
191 //
192 wxTopLevelWindow::DoSetClientSize( nWidth
193 ,nHeight
194 );
195 } // end of wxFrame::DoSetClientSize
196
197 // ----------------------------------------------------------------------------
198 // wxFrame: various geometry-related functions
199 // ----------------------------------------------------------------------------
200
201 void wxFrame::Raise()
202 {
203 wxFrameBase::Raise();
204 ::WinSetWindowPos( (HWND) GetParent()->GetHWND()
205 ,HWND_TOP
206 ,0
207 ,0
208 ,0
209 ,0
210 ,SWP_ZORDER
211 );
212 }
213
214 // generate an artificial resize event
215 void wxFrame::SendSizeEvent()
216 {
217 if (!m_bIconized)
218 {
219 RECTL vRect = wxGetWindowRect(GetHwnd());
220
221 (void)::WinPostMsg( m_hFrame
222 ,WM_SIZE
223 ,MPFROM2SHORT(vRect.xRight - vRect.xLeft, vRect.yTop - vRect.yBottom)
224 ,MPFROM2SHORT(vRect.xRight - vRect.xLeft, vRect.yTop - vRect.yBottom)
225 );
226 }
227 }
228
229 #if wxUSE_STATUSBAR
230 wxStatusBar* wxFrame::OnCreateStatusBar(
231 int nNumber
232 , long lulStyle
233 , wxWindowID vId
234 , const wxString& rName
235 )
236 {
237 wxStatusBar* pStatusBar = NULL;
238 SWP vSwp;
239 ERRORID vError;
240 wxString sError;
241
242 pStatusBar = wxFrameBase::OnCreateStatusBar( nNumber
243 ,lulStyle
244 ,vId
245 ,rName
246 );
247
248 if( !pStatusBar )
249 return NULL;
250
251 ::WinSetParent( pStatusBar->GetHWND()
252 ,m_hFrame
253 ,FALSE
254 );
255 ::WinSetOwner( pStatusBar->GetHWND()
256 ,m_hFrame
257 );
258 //
259 // to show statusbar
260 //
261 if(::WinIsWindowShowing(m_hFrame))
262 ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
263
264 return pStatusBar;
265 } // end of wxFrame::OnCreateStatusBar
266
267 void wxFrame::PositionStatusBar()
268 {
269 SWP vSwp;
270 ERRORID vError;
271 wxString sError;
272
273 //
274 // Native status bar positions itself
275 //
276 if (m_frameStatusBar)
277 {
278 int nWidth;
279 int nY;
280 int nStatbarWidth;
281 int nStatbarHeight;
282 HWND hWndClient;
283 RECTL vRect;
284 RECTL vFRect;
285
286 ::WinQueryWindowRect(m_hFrame, &vRect);
287 nY = vRect.yTop;
288 ::WinMapWindowPoints(m_hFrame, HWND_DESKTOP, (PPOINTL)&vRect, 2);
289 vFRect = vRect;
290 ::WinCalcFrameRect(m_hFrame, &vRect, TRUE);
291 nWidth = vRect.xRight - vRect.xLeft;
292 nY = nY - (vRect.yBottom - vFRect.yBottom);
293
294 m_frameStatusBar->GetSize( &nStatbarWidth
295 ,&nStatbarHeight
296 );
297
298 nY= nY - nStatbarHeight;
299 //
300 // Since we wish the status bar to be directly under the client area,
301 // we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS.
302 //
303 m_frameStatusBar->SetSize( vRect.xLeft - vFRect.xLeft
304 ,nY
305 ,nWidth
306 ,nStatbarHeight
307 );
308 if (!::WinQueryWindowPos(m_frameStatusBar->GetHWND(), &vSwp))
309 {
310 vError = ::WinGetLastError(vHabmain);
311 sError = wxPMErrorToStr(vError);
312 wxLogError("Error setting parent for StautsBar. Error: %s\n", sError);
313 return;
314 }
315 }
316 } // end of wxFrame::PositionStatusBar
317 #endif // wxUSE_STATUSBAR
318
319 #if wxUSE_MENUS_NATIVE
320 void wxFrame::DetachMenuBar()
321 {
322 if (m_frameMenuBar)
323 {
324 m_frameMenuBar->Detach();
325 m_frameMenuBar = NULL;
326 }
327 } // end of wxFrame::DetachMenuBar
328
329 void wxFrame::SetMenuBar(
330 wxMenuBar* pMenuBar
331 )
332 {
333 ERRORID vError;
334 wxString sError;
335 HWND hTitlebar = NULLHANDLE;
336 HWND hHScroll = NULLHANDLE;
337 HWND hVScroll = NULLHANDLE;
338 HWND hMenuBar = NULLHANDLE;
339 SWP vSwp;
340 SWP vSwpTitlebar;
341 SWP vSwpVScroll;
342 SWP vSwpHScroll;
343 SWP vSwpMenu;
344
345 if (!pMenuBar)
346 {
347 DetachMenuBar();
348
349 //
350 // Actually remove the menu from the frame
351 //
352 m_hMenu = (WXHMENU)0;
353 InternalSetMenuBar();
354 }
355 else // set new non NULL menu bar
356 {
357 m_frameMenuBar = NULL;
358
359 //
360 // Can set a menubar several times.
361 // TODO: how to prevent a memory leak if you have a currently-unattached
362 // menubar? wxWindows assumes that the frame will delete the menu (otherwise
363 // there are problems for MDI).
364 //
365 if (pMenuBar->GetHMenu())
366 {
367 m_hMenu = pMenuBar->GetHMenu();
368 }
369 else
370 {
371 pMenuBar->Detach();
372 m_hMenu = pMenuBar->Create();
373 if (!m_hMenu)
374 return;
375 }
376 InternalSetMenuBar();
377 m_frameMenuBar = pMenuBar;
378 pMenuBar->Attach((wxFrame*)this);
379 }
380 } // end of wxFrame::SetMenuBar
381
382 void wxFrame::AttachMenuBar(
383 wxMenuBar* pMenubar
384 )
385 {
386 wxFrameBase::AttachMenuBar(pMenubar);
387
388 m_frameMenuBar = pMenubar;
389
390 if (!pMenubar)
391 {
392 //
393 // Actually remove the menu from the frame
394 //
395 m_hMenu = (WXHMENU)0;
396 InternalSetMenuBar();
397 }
398 else // Set new non NULL menu bar
399 {
400 //
401 // Can set a menubar several times.
402 //
403 if (pMenubar->GetHMenu())
404 {
405 m_hMenu = pMenubar->GetHMenu();
406 }
407 else
408 {
409 if (pMenubar->IsAttached())
410 pMenubar->Detach();
411
412 m_hMenu = pMenubar->Create();
413
414 if (!m_hMenu)
415 return;
416 }
417 InternalSetMenuBar();
418 }
419 } // end of wxFrame::AttachMenuBar
420
421 void wxFrame::InternalSetMenuBar()
422 {
423 ERRORID vError;
424 wxString sError;
425 //
426 // Set the parent and owner of the menubar to be the frame
427 //
428 if (!::WinSetParent(m_hMenu, m_hFrame, FALSE))
429 {
430 vError = ::WinGetLastError(vHabmain);
431 sError = wxPMErrorToStr(vError);
432 wxLogError("Error setting parent for submenu. Error: %s\n", sError);
433 }
434
435 if (!::WinSetOwner(m_hMenu, m_hFrame))
436 {
437 vError = ::WinGetLastError(vHabmain);
438 sError = wxPMErrorToStr(vError);
439 wxLogError("Error setting parent for submenu. Error: %s\n", sError);
440 }
441 ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
442 } // end of wxFrame::InternalSetMenuBar
443 #endif // wxUSE_MENUS_NATIVE
444
445 //
446 // Responds to colour changes, and passes event on to children
447 //
448 void wxFrame::OnSysColourChanged(
449 wxSysColourChangedEvent& rEvent
450 )
451 {
452 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
453 Refresh();
454
455 #if wxUSE_STATUSBAR
456 if (m_frameStatusBar)
457 {
458 wxSysColourChangedEvent vEvent2;
459
460 vEvent2.SetEventObject(m_frameStatusBar);
461 m_frameStatusBar->GetEventHandler()->ProcessEvent(vEvent2);
462 }
463 #endif //wxUSE_STATUSBAR
464
465 //
466 // Propagate the event to the non-top-level children
467 //
468 wxWindow::OnSysColourChanged(rEvent);
469 } // end of wxFrame::OnSysColourChanged
470
471 // Pass TRUE to show full screen, FALSE to restore.
472 bool wxFrame::ShowFullScreen(
473 bool bShow
474 , long lStyle
475 )
476 {
477 if (bShow)
478 {
479 if (IsFullScreen())
480 return FALSE;
481
482 m_bFsIsShowing = TRUE;
483 m_lFsStyle = lStyle;
484
485 #if wxUSE_TOOLBAR
486 wxToolBar* pTheToolBar = GetToolBar();
487 #endif //wxUSE_TOOLBAR
488
489 #if wxUSE_STATUSBAR
490 wxStatusBar* pTheStatusBar = GetStatusBar();
491 #endif //wxUSE_STATUSBAR
492
493 int nDummyWidth;
494
495 #if wxUSE_TOOLBAR
496 if (pTheToolBar)
497 pTheToolBar->GetSize(&nDummyWidth, &m_nFsToolBarHeight);
498 #endif //wxUSE_TOOLBAR
499
500 #if wxUSE_STATUSBAR
501 if (pTheStatusBar)
502 pTheStatusBar->GetSize(&nDummyWidth, &m_nFsStatusBarHeight);
503 #endif //wxUSE_STATUSBAR
504
505 #if wxUSE_TOOLBAR
506 //
507 // Zap the toolbar, menubar, and statusbar
508 //
509 if ((lStyle & wxFULLSCREEN_NOTOOLBAR) && pTheToolBar)
510 {
511 pTheToolBar->SetSize(-1,0);
512 pTheToolBar->Show(FALSE);
513 }
514 #endif //wxUSE_TOOLBAR
515
516 if (lStyle & wxFULLSCREEN_NOMENUBAR)
517 {
518 ::WinSetParent(m_hMenu, m_hFrame, FALSE);
519 ::WinSetOwner(m_hMenu, m_hFrame);
520 ::WinSendMsg((HWND)m_hFrame, WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
521 }
522
523 #if wxUSE_STATUSBAR
524 //
525 // Save the number of fields in the statusbar
526 //
527 if ((lStyle & wxFULLSCREEN_NOSTATUSBAR) && pTheStatusBar)
528 {
529 m_nFsStatusBarFields = pTheStatusBar->GetFieldsCount();
530 SetStatusBar((wxStatusBar*) NULL);
531 delete pTheStatusBar;
532 }
533 else
534 m_nFsStatusBarFields = 0;
535 #endif //wxUSE_STATUSBAR
536
537 //
538 // Zap the frame borders
539 //
540
541 //
542 // Save the 'normal' window style
543 //
544 m_lFsOldWindowStyle = ::WinQueryWindowULong(m_hFrame, QWL_STYLE);
545
546 //
547 // Save the old position, width & height, maximize state
548 //
549 m_vFsOldSize = GetRect();
550 m_bFsIsMaximized = IsMaximized();
551
552 //
553 // Decide which window style flags to turn off
554 //
555 LONG lNewStyle = m_lFsOldWindowStyle;
556 LONG lOffFlags = 0;
557
558 if (lStyle & wxFULLSCREEN_NOBORDER)
559 lOffFlags |= FCF_BORDER;
560 if (lStyle & wxFULLSCREEN_NOCAPTION)
561 lOffFlags |= (FCF_TASKLIST | FCF_SYSMENU);
562
563 lNewStyle &= (~lOffFlags);
564
565 //
566 // Change our window style to be compatible with full-screen mode
567 //
568 ::WinSetWindowULong((HWND)m_hFrame, QWL_STYLE, (ULONG)lNewStyle);
569
570 //
571 // Resize to the size of the desktop
572 int nWidth;
573 int nHeight;
574
575 RECTL vRect;
576
577 ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
578 nWidth = vRect.xRight - vRect.xLeft;
579 //
580 // Rmember OS/2 is backwards!
581 //
582 nHeight = vRect.yTop - vRect.yBottom;
583
584 SetSize( nWidth
585 ,nHeight
586 );
587
588 //
589 // Now flush the window style cache and actually go full-screen
590 //
591 ::WinSetWindowPos( (HWND) GetParent()->GetHWND()
592 ,HWND_TOP
593 ,0
594 ,0
595 ,nWidth
596 ,nHeight
597 ,SWP_SIZE | SWP_SHOW
598 );
599
600 wxSizeEvent vEvent( wxSize( nWidth
601 ,nHeight
602 )
603 ,GetId()
604 );
605
606 GetEventHandler()->ProcessEvent(vEvent);
607 return TRUE;
608 }
609 else
610 {
611 if (!IsFullScreen())
612 return FALSE;
613
614 m_bFsIsShowing = FALSE;
615
616 #if wxUSE_TOOLBAR
617 wxToolBar* pTheToolBar = GetToolBar();
618
619 //
620 // Restore the toolbar, menubar, and statusbar
621 //
622 if (pTheToolBar && (m_lFsStyle & wxFULLSCREEN_NOTOOLBAR))
623 {
624 pTheToolBar->SetSize(-1, m_nFsToolBarHeight);
625 pTheToolBar->Show(TRUE);
626 }
627 #endif //wxUSE_TOOLBAR
628
629 #if wxUSE_STATUSBAR
630 if ((m_lFsStyle & wxFULLSCREEN_NOSTATUSBAR) && (m_nFsStatusBarFields > 0))
631 {
632 CreateStatusBar(m_nFsStatusBarFields);
633 // PositionStatusBar();
634 }
635 #endif //wxUSE_STATUSBAR
636
637 if ((m_lFsStyle & wxFULLSCREEN_NOMENUBAR) && (m_hMenu != 0))
638 {
639 ::WinSetParent(m_hMenu, m_hFrame, FALSE);
640 ::WinSetOwner(m_hMenu, m_hFrame);
641 ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
642 }
643 Maximize(m_bFsIsMaximized);
644
645 ::WinSetWindowULong( m_hFrame
646 ,QWL_STYLE
647 ,(ULONG)m_lFsOldWindowStyle
648 );
649 ::WinSetWindowPos( (HWND) GetParent()->GetHWND()
650 ,HWND_TOP
651 ,m_vFsOldSize.x
652 ,m_vFsOldSize.y
653 ,m_vFsOldSize.width
654 ,m_vFsOldSize.height
655 ,SWP_SIZE | SWP_SHOW
656 );
657 return TRUE;
658 }
659 } // end of wxFrame::ShowFullScreen
660
661 //
662 // Frame window
663 //
664 //
665 // Default activation behaviour - set the focus for the first child
666 // subwindow found.
667 //
668 void wxFrame::OnActivate(
669 wxActivateEvent& rEvent
670 )
671 {
672 if ( rEvent.GetActive() )
673 {
674 // restore focus to the child which was last focused
675 wxLogTrace(_T("focus"), _T("wxFrame %08x activated."), m_hWnd);
676
677 wxWindow* pParent = m_pWinLastFocused ? m_pWinLastFocused->GetParent()
678 : NULL;
679 if (!pParent)
680 {
681 pParent = this;
682 }
683
684 wxSetFocusToChild( pParent
685 ,&m_pWinLastFocused
686 );
687 }
688 else // deactivating
689 {
690 //
691 // Remember the last focused child if it is our child
692 //
693 m_pWinLastFocused = FindFocus();
694
695 for (wxWindowList::Node* pNode = GetChildren().GetFirst();
696 pNode;
697 pNode = pNode->GetNext())
698 {
699 // FIXME all this is totally bogus - we need to do the same as wxPanel,
700 // but how to do it without duplicating the code?
701
702 // restore focus
703 wxWindow* pChild = pNode->GetData();
704
705 if (!pChild->IsTopLevel()
706 #if wxUSE_TOOLBAR
707 && !wxDynamicCast(pChild, wxToolBar)
708 #endif // wxUSE_TOOLBAR
709 #if wxUSE_STATUSBAR
710 && !wxDynamicCast(pChild, wxStatusBar)
711 #endif // wxUSE_STATUSBAR
712 )
713 {
714 pChild->SetFocus();
715 return;
716 }
717 }
718 }
719 } // end of wxFrame::OnActivate
720
721 // ----------------------------------------------------------------------------
722 // wxFrame size management: we exclude the areas taken by menu/status/toolbars
723 // from the client area, so the client area is what's really available for the
724 // frame contents
725 // ----------------------------------------------------------------------------
726
727 // Checks if there is a toolbar, and returns the first free client position
728 wxPoint wxFrame::GetClientAreaOrigin() const
729 {
730 wxPoint vPoint(0, 0);
731
732 #if wxUSE_TOOLBAR
733 if (GetToolBar())
734 {
735 int nWidth;
736 int nHeight;
737
738 GetToolBar()->GetSize( &nWidth
739 ,&nHeight
740 );
741
742 if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
743 {
744 vPoint.x += nWidth;
745 }
746 else
747 {
748 // PM is backwards from windows
749 vPoint.y += nHeight;
750 }
751 }
752 #endif //wxUSE_TOOLBAR
753 return vPoint;
754 } // end of wxFrame::GetClientAreaOrigin
755
756 // ----------------------------------------------------------------------------
757 // tool/status bar stuff
758 // ----------------------------------------------------------------------------
759
760 #if wxUSE_TOOLBAR
761
762 wxToolBar* wxFrame::CreateToolBar(
763 long lStyle
764 , wxWindowID vId
765 , const wxString& rName
766 )
767 {
768 if (wxFrameBase::CreateToolBar( lStyle
769 ,vId
770 ,rName
771 ))
772 {
773 PositionToolBar();
774 }
775 return m_frameToolBar;
776 } // end of wxFrame::CreateToolBar
777
778 void wxFrame::PositionToolBar()
779 {
780 HWND hWndClient;
781 RECTL vRect;
782
783 ::WinQueryWindowRect(GetHwnd(), &vRect);
784
785 #if wxUSE_STATUSBAR
786 if (GetStatusBar())
787 {
788 int nStatusX;
789 int nStatusY;
790
791 GetStatusBar()->GetClientSize( &nStatusX
792 ,&nStatusY
793 );
794 // PM is backwards from windows
795 vRect.yBottom += nStatusY;
796 }
797 #endif // wxUSE_STATUSBAR
798
799 if ( m_frameToolBar )
800 {
801 int nToolbarWidth;
802 int nToolbarHeight;
803
804 m_frameToolBar->GetSize( &nToolbarWidth
805 ,&nToolbarHeight
806 );
807
808 if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
809 {
810 nToolbarHeight = vRect.yBottom;
811 }
812 else
813 {
814 nToolbarWidth = vRect.xRight;
815 }
816
817 //
818 // Use the 'real' PM position here
819 //
820 GetToolBar()->SetSize( 0
821 ,0
822 ,nToolbarWidth
823 ,nToolbarHeight
824 ,wxSIZE_NO_ADJUSTMENTS
825 );
826 }
827 } // end of wxFrame::PositionToolBar
828 #endif // wxUSE_TOOLBAR
829
830 // ----------------------------------------------------------------------------
831 // frame state (iconized/maximized/...)
832 // ----------------------------------------------------------------------------
833
834 //
835 // propagate our state change to all child frames: this allows us to emulate X
836 // Windows behaviour where child frames float independently of the parent one
837 // on the desktop, but are iconized/restored with it
838 //
839 void wxFrame::IconizeChildFrames(
840 bool bIconize
841 )
842 {
843 for (wxWindowList::Node* pNode = GetChildren().GetFirst();
844 pNode;
845 pNode = pNode->GetNext() )
846 {
847 wxWindow* pWin = pNode->GetData();
848 wxFrame* pFrame = wxDynamicCast(pWin, wxFrame);
849
850 if ( pFrame
851 #if wxUSE_MDI_ARCHITECTURE
852 && !wxDynamicCast(pFrame, wxMDIChildFrame)
853 #endif // wxUSE_MDI_ARCHITECTURE
854 )
855 {
856 //
857 // We don't want to restore the child frames which had been
858 // iconized even before we were iconized, so save the child frame
859 // status when iconizing the parent frame and check it when
860 // restoring it.
861 //
862 if (bIconize)
863 {
864 pFrame->m_bWasMinimized = pFrame->IsIconized();
865 }
866
867 //
868 // This test works for both iconizing and restoring
869 //
870 if (!pFrame->m_bWasMinimized)
871 pFrame->Iconize(bIconize);
872 }
873 }
874 } // end of wxFrame::IconizeChildFrames
875
876 WXHICON wxFrame::GetDefaultIcon() const
877 {
878 return (WXHICON)(wxSTD_FRAME_ICON ? wxSTD_FRAME_ICON
879 : wxDEFAULT_FRAME_ICON);
880 }
881 // ===========================================================================
882 // message processing
883 // ===========================================================================
884
885 // ---------------------------------------------------------------------------
886 // preprocessing
887 // ---------------------------------------------------------------------------
888 bool wxFrame::OS2TranslateMessage(
889 WXMSG* pMsg
890 )
891 {
892 //
893 // try the menu bar accels
894 //
895 wxMenuBar* pMenuBar = GetMenuBar();
896
897 if (!pMenuBar)
898 return FALSE;
899
900 #if wxUSE_ACCEL && wxUSE_MENUS_NATIVE
901 const wxAcceleratorTable& rAcceleratorTable = pMenuBar->GetAccelTable();
902 return rAcceleratorTable.Translate(GetHWND(), pMsg);
903 #else
904 return FALSE;
905 #endif //wxUSE_ACCEL
906 } // end of wxFrame::OS2TranslateMessage
907
908 // ---------------------------------------------------------------------------
909 // our private (non virtual) message handlers
910 // ---------------------------------------------------------------------------
911 bool wxFrame::HandlePaint()
912 {
913 RECTL vRect;
914
915 if (::WinQueryUpdateRect(GetHWND(), &vRect))
916 {
917 if (m_bIconized)
918 {
919 //
920 // Icons in PM are the same as "pointers"
921 //
922 HPOINTER hIcon;
923
924 if (m_icon.Ok())
925 hIcon = (HPOINTER)::WinSendMsg(m_hFrame, WM_QUERYICON, 0L, 0L);
926 else
927 hIcon = (HPOINTER)m_hDefaultIcon;
928
929 //
930 // Hold a pointer to the dc so long as the OnPaint() message
931 // is being processed
932 //
933 RECTL vRect2;
934 HPS hPs = ::WinBeginPaint(GetHwnd(), NULLHANDLE, &vRect2);
935
936 //
937 // Erase background before painting or we get white background
938 //
939 OS2DefWindowProc(WM_ERASEBACKGROUND, (MPARAM)hPs, (MPARAM)&vRect2);
940
941 if (hIcon)
942 {
943 HWND hWndClient;
944 RECTL vRect3;
945
946 ::WinQueryWindowRect(GetHwnd(), &vRect3);
947
948 static const int nIconWidth = 32;
949 static const int nIconHeight = 32;
950 int nIconX = (int)((vRect3.xRight - nIconWidth)/2);
951 int nIconY = (int)((vRect3.yBottom + nIconHeight)/2);
952
953 ::WinDrawPointer(hPs, nIconX, nIconY, hIcon, DP_NORMAL);
954 }
955 ::WinEndPaint(hPs);
956 return TRUE;
957 }
958 else
959 {
960 if (!wxWindow::HandlePaint())
961 {
962 HPS hPS;
963 RECTL vRect;
964
965 hPS = ::WinBeginPaint( GetHwnd()
966 ,NULLHANDLE
967 ,&vRect
968 );
969 if(hPS)
970 {
971 ::GpiCreateLogColorTable( hPS
972 ,0L
973 ,LCOLF_CONSECRGB
974 ,0L
975 ,(LONG)wxTheColourDatabase->m_nSize
976 ,(PLONG)wxTheColourDatabase->m_palTable
977 );
978 ::GpiCreateLogColorTable( hPS
979 ,0L
980 ,LCOLF_RGB
981 ,0L
982 ,0L
983 ,NULL
984 );
985
986 ::WinFillRect( hPS
987 ,&vRect
988 ,GetBackgroundColour().GetPixel()
989 );
990 ::WinEndPaint(hPS);
991 }
992 }
993 return TRUE;
994 }
995 }
996 else
997 {
998 // nothing to paint - processed
999 return TRUE;
1000 }
1001 return FALSE;
1002 } // end of wxFrame::HandlePaint
1003
1004 bool wxFrame::HandleSize(
1005 int nX
1006 , int nY
1007 , WXUINT nId
1008 )
1009 {
1010 bool bProcessed = FALSE;
1011
1012 switch (nId)
1013 {
1014 case kSizeNormal:
1015 //
1016 // Only do it it if we were iconized before, otherwise resizing the
1017 // parent frame has a curious side effect of bringing it under it's
1018 // children
1019 if (!m_bIconized )
1020 break;
1021
1022 //
1023 // restore all child frames too
1024 //
1025 IconizeChildFrames(FALSE);
1026 (void)SendIconizeEvent(FALSE);
1027
1028 //
1029 // fall through
1030 //
1031
1032 case kSizeMax:
1033 m_bIconized = FALSE;
1034 break;
1035
1036 case kSizeMin:
1037 //
1038 // Iconize all child frames too
1039 //
1040 IconizeChildFrames(TRUE);
1041 (void)SendIconizeEvent();
1042 m_bIconized = TRUE;
1043 break;
1044 }
1045
1046 if (!m_bIconized)
1047 {
1048 //
1049 // forward WM_SIZE to status bar control
1050 //
1051 #if wxUSE_NATIVE_STATUSBAR
1052 if (m_frameStatusBar && m_frameStatusBar->IsKindOf(CLASSINFO(wxStatusBar95)))
1053 {
1054 wxSizeEvent vEvent( wxSize( nX
1055 ,nY
1056 )
1057 ,m_frameStatusBar->GetId()
1058 );
1059
1060 vEvent.SetEventObject(m_frameStatusBar);
1061 m_frameStatusBar->OnSize(vEvent);
1062 }
1063 #endif // wxUSE_NATIVE_STATUSBAR
1064
1065 PositionStatusBar();
1066 #if wxUSE_TOOLBAR
1067 PositionToolBar();
1068 #endif // wxUSE_TOOLBAR
1069
1070 wxSizeEvent vEvent( wxSize( nX
1071 ,nY
1072 )
1073 ,m_windowId
1074 );
1075
1076 vEvent.SetEventObject(this);
1077 bProcessed = GetEventHandler()->ProcessEvent(vEvent);
1078 AlterChildPos();
1079 }
1080 return bProcessed;
1081 } // end of wxFrame::HandleSize
1082
1083 bool wxFrame::HandleCommand(
1084 WXWORD nId
1085 , WXWORD nCmd
1086 , WXHWND hControl
1087 )
1088 {
1089 if (hControl)
1090 {
1091 //
1092 // In case it's e.g. a toolbar.
1093 //
1094 wxWindow* pWin = wxFindWinFromHandle(hControl);
1095
1096 if (pWin)
1097 return pWin->OS2Command( nCmd
1098 ,nId
1099 );
1100 }
1101
1102 //
1103 // Handle here commands from menus and accelerators
1104 //
1105 if (nCmd == CMDSRC_MENU || nCmd == CMDSRC_ACCELERATOR)
1106 {
1107 #if wxUSE_MENUS_NATIVE
1108 if (wxCurrentPopupMenu)
1109 {
1110 wxMenu* pPopupMenu = wxCurrentPopupMenu;
1111
1112 wxCurrentPopupMenu = NULL;
1113
1114 return pPopupMenu->OS2Command( nCmd
1115 ,nId
1116 );
1117 return TRUE;
1118 }
1119 #endif
1120
1121 if (ProcessCommand(nId))
1122 {
1123 return TRUE;
1124 }
1125 }
1126 return FALSE;
1127 } // end of wxFrame::HandleCommand
1128
1129 bool wxFrame::HandleMenuSelect(
1130 WXWORD nItem
1131 , WXWORD nFlags
1132 , WXHMENU hMenu
1133 )
1134 {
1135 if( !nFlags )
1136 {
1137 MENUITEM mItem;
1138 MRESULT rc;
1139
1140 rc = ::WinSendMsg(hMenu, MM_QUERYITEM, MPFROM2SHORT(nItem, TRUE), (MPARAM)&mItem);
1141
1142 if(rc && !(mItem.afStyle & (MIS_SUBMENU | MIS_SEPARATOR)))
1143 {
1144 wxMenuEvent vEvent(wxEVT_MENU_HIGHLIGHT, nItem);
1145
1146 vEvent.SetEventObject(this);
1147 GetEventHandler()->ProcessEvent(vEvent); // return value would be ignored by PM
1148 }
1149 }
1150 return TRUE;
1151 } // end of wxFrame::HandleMenuSelect
1152
1153 // ---------------------------------------------------------------------------
1154 // Main Frame window proc
1155 // ---------------------------------------------------------------------------
1156 MRESULT EXPENTRY wxFrameMainWndProc(
1157 HWND hWnd
1158 , ULONG ulMsg
1159 , MPARAM wParam
1160 , MPARAM lParam
1161 )
1162 {
1163 MRESULT rc = (MRESULT)0;
1164 bool bProcessed = FALSE;
1165 wxFrame* pWnd = NULL;
1166
1167 pWnd = (wxFrame*) wxFindWinFromHandle((WXHWND) hWnd);
1168 switch (ulMsg)
1169 {
1170 case WM_QUERYFRAMECTLCOUNT:
1171 if(pWnd && pWnd->m_fnOldWndProc)
1172 {
1173 USHORT uItemCount = SHORT1FROMMR(pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam));
1174
1175 rc = MRFROMSHORT(uItemCount);
1176 }
1177 break;
1178
1179 case WM_FORMATFRAME:
1180 /////////////////////////////////////////////////////////////////////////////////
1181 // Applications that subclass frame controls may find that the frame is already
1182 // subclassed the number of frame controls is variable.
1183 // The WM_FORMATFRAME and WM_QUERYFRAMECTLCOUNT messages must always be
1184 // subclassed by calling the previous window procedure and modifying its result.
1185 ////////////////////////////////////////////////////////////////////////////////
1186 {
1187 int nItemCount;
1188 int i;
1189 PSWP pSWP = NULL;
1190 SWP vSwpStb;
1191 RECTL vRectl;
1192 RECTL vRstb;
1193 int nHeight=0;
1194
1195 pSWP = (PSWP)PVOIDFROMMP(wParam);
1196 nItemCount = SHORT1FROMMR(pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam));
1197 if(pWnd->m_frameStatusBar)
1198 {
1199 ::WinQueryWindowRect(pWnd->m_frameStatusBar->GetHWND(), &vRstb);
1200 pWnd->m_frameStatusBar->GetSize(NULL, &nHeight);
1201 ::WinQueryWindowRect(pWnd->m_hFrame, &vRectl);
1202 ::WinMapWindowPoints(pWnd->m_hFrame, HWND_DESKTOP, (PPOINTL)&vRectl, 2);
1203 vRstb = vRectl;
1204 ::WinCalcFrameRect(pWnd->m_hFrame, &vRectl, TRUE);
1205
1206 vSwpStb.x = vRectl.xLeft - vRstb.xLeft;
1207 vSwpStb.y = vRectl.yBottom - vRstb.yBottom;
1208 vSwpStb.cx = vRectl.xRight - vRectl.xLeft - 1; //?? -1 ??
1209 vSwpStb.cy = nHeight;
1210 vSwpStb.fl = SWP_SIZE |SWP_MOVE | SWP_SHOW;
1211 vSwpStb.hwnd = pWnd->m_frameStatusBar->GetHWND();
1212 vSwpStb.hwndInsertBehind = HWND_TOP;
1213 }
1214 ::WinQueryWindowRect(pWnd->m_hFrame, &vRectl);
1215 ::WinMapWindowPoints(pWnd->m_hFrame, HWND_DESKTOP, (PPOINTL)&vRectl, 2);
1216 ::WinCalcFrameRect(pWnd->m_hFrame, &vRectl, TRUE);
1217 ::WinMapWindowPoints(HWND_DESKTOP, pWnd->m_hFrame, (PPOINTL)&vRectl, 2);
1218 for(i = 0; i < nItemCount; i++)
1219 {
1220 if(pWnd->m_hWnd && pSWP[i].hwnd == pWnd->m_hWnd)
1221 {
1222 pSWP[i].x = vRectl.xLeft;
1223 pSWP[i].y = vRectl.yBottom + nHeight;
1224 pSWP[i].cx = vRectl.xRight - vRectl.xLeft;
1225 pSWP[i].cy = vRectl.yTop - vRectl.yBottom - nHeight;
1226 pSWP[i].fl = SWP_SIZE | SWP_MOVE | SWP_SHOW;
1227 pSWP[i].hwndInsertBehind = HWND_TOP;
1228 }
1229 }
1230 bProcessed = TRUE;
1231 rc = MRFROMSHORT(nItemCount);
1232 }
1233 break;
1234
1235 default:
1236 if(pWnd && pWnd->m_fnOldWndProc)
1237 rc = pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam);
1238 else
1239 rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
1240 }
1241 return rc;
1242 } // end of wxFrameMainWndProc
1243
1244 MRESULT EXPENTRY wxFrameWndProc(
1245 HWND hWnd
1246 , ULONG ulMsg
1247 , MPARAM wParam
1248 , MPARAM lParam
1249 )
1250 {
1251 //
1252 // Trace all ulMsgs - useful for the debugging
1253 //
1254 HWND parentHwnd;
1255 wxFrame* pWnd = NULL;
1256
1257 parentHwnd = WinQueryWindow(hWnd,QW_PARENT);
1258 pWnd = (wxFrame*) wxFindWinFromHandle((WXHWND) hWnd);
1259
1260 //
1261 // When we get the first message for the HWND we just created, we associate
1262 // it with wxWindow stored in wxWndHook
1263 //
1264
1265 MRESULT rc = (MRESULT)0;
1266 bool bProcessed = FALSE;
1267
1268 //
1269 // Stop right here if we don't have a valid handle in our wxWindow object.
1270 //
1271 if (pWnd && !pWnd->GetHWND())
1272 {
1273 pWnd->SetHWND((WXHWND) hWnd);
1274 rc = pWnd->OS2DefWindowProc(ulMsg, wParam, lParam );
1275 pWnd->SetHWND(0);
1276 }
1277 else
1278 {
1279 if (pWnd)
1280 rc = pWnd->OS2WindowProc(ulMsg, wParam, lParam);
1281 else
1282 rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
1283 }
1284 return rc;
1285 } // end of wxFrameWndProc
1286
1287 MRESULT wxFrame::OS2WindowProc(
1288 WXUINT uMessage
1289 , WXWPARAM wParam
1290 , WXLPARAM lParam
1291 )
1292 {
1293 MRESULT mRc = 0L;
1294 bool bProcessed = FALSE;
1295
1296 switch (uMessage)
1297 {
1298 case WM_CLOSE:
1299 //
1300 // If we can't close, tell the system that we processed the
1301 // message - otherwise it would close us
1302 //
1303 bProcessed = !Close();
1304 break;
1305
1306 case WM_PAINT:
1307 bProcessed = HandlePaint();
1308 mRc = (MRESULT)FALSE;
1309 break;
1310
1311 case WM_ERASEBACKGROUND:
1312 //
1313 // Returning TRUE to requests PM to paint the window background
1314 // in SYSCLR_WINDOW. We capture this here because the PS returned
1315 // in Frames is the PS for the whole frame, which we can't really
1316 // use at all. If you want to paint a different background, do it
1317 // in an OnPaint using a wxPaintDC.
1318 //
1319 mRc = (MRESULT)(TRUE);
1320 break;
1321
1322 case WM_COMMAND:
1323 {
1324 WORD wId;
1325 WORD wCmd;
1326 WXHWND hWnd;
1327
1328 UnpackCommand( (WXWPARAM)wParam
1329 ,(WXLPARAM)lParam
1330 ,&wId
1331 ,&hWnd
1332 ,&wCmd
1333 );
1334
1335 bProcessed = HandleCommand( wId
1336 ,wCmd
1337 ,(WXHWND)hWnd
1338 );
1339 }
1340 break;
1341
1342 case WM_MENUSELECT:
1343 {
1344 WXWORD wItem;
1345 WXWORD wFlags;
1346 WXHMENU hMenu;
1347
1348 UnpackMenuSelect( wParam
1349 ,lParam
1350 ,&wItem
1351 ,&wFlags
1352 ,&hMenu
1353 );
1354 bProcessed = HandleMenuSelect( wItem
1355 ,wFlags
1356 ,hMenu
1357 );
1358 mRc = (MRESULT)TRUE;
1359 }
1360 break;
1361
1362 case WM_SIZE:
1363 {
1364 SHORT nScxold = SHORT1FROMMP(wParam); // Old horizontal size.
1365 SHORT nScyold = SHORT2FROMMP(wParam); // Old vertical size.
1366 SHORT nScxnew = SHORT1FROMMP(lParam); // New horizontal size.
1367 SHORT nScynew = SHORT2FROMMP(lParam); // New vertical size.
1368
1369 lParam = MRFROM2SHORT( nScxnew - 20
1370 ,nScynew - 30
1371 );
1372 }
1373 bProcessed = HandleSize(LOWORD(lParam), HIWORD(lParam), (WXUINT)wParam);
1374 mRc = (MRESULT)FALSE;
1375 break;
1376
1377 case CM_QUERYDRAGIMAGE:
1378 {
1379 HPOINTER hIcon;
1380
1381 if (m_icon.Ok())
1382 hIcon = (HPOINTER)::WinSendMsg(GetHWND(), WM_QUERYICON, 0L, 0L);
1383 else
1384 hIcon = (HPOINTER)m_hDefaultIcon;
1385 mRc = (MRESULT)hIcon;
1386 bProcessed = mRc != 0;
1387 }
1388 break;
1389 }
1390
1391 if (!bProcessed )
1392 mRc = wxWindow::OS2WindowProc( uMessage
1393 ,wParam
1394 ,lParam
1395 );
1396 return (MRESULT)mRc;
1397 } // wxFrame::OS2WindowProc
1398
1399 void wxFrame::SetClient(WXHWND c_Hwnd)
1400 {
1401 // Duh...nothing to do under OS/2
1402 }
1403
1404 void wxFrame::SetClient(
1405 wxWindow* pWindow
1406 )
1407 {
1408 wxWindow* pOldClient = this->GetClient();
1409 bool bClientHasFocus = pOldClient && (pOldClient == wxWindow::FindFocus());
1410
1411 if(pOldClient == pWindow) // nothing to do
1412 return;
1413 if(pWindow == NULL) // just need to remove old client
1414 {
1415 if(pOldClient == NULL) // nothing to do
1416 return;
1417
1418 if(bClientHasFocus )
1419 this->SetFocus();
1420
1421 pOldClient->Enable( FALSE );
1422 pOldClient->Show( FALSE );
1423 ::WinSetWindowUShort(pOldClient->GetHWND(), QWS_ID, (USHORT)pOldClient->GetId());
1424 // to avoid OS/2 bug need to update frame
1425 ::WinSendMsg((HWND)this->GetFrame(), WM_UPDATEFRAME, (MPARAM)~0, 0);
1426 return;
1427 }
1428
1429 //
1430 // Else need to change client
1431 //
1432 if(bClientHasFocus)
1433 this->SetFocus();
1434
1435 ::WinEnableWindowUpdate((HWND)GetHWND(), FALSE);
1436 if(pOldClient)
1437 {
1438 pOldClient->Enable(FALSE);
1439 pOldClient->Show(FALSE);
1440 ::WinSetWindowUShort(pOldClient->GetHWND(), QWS_ID, (USHORT)pOldClient->GetId());
1441 }
1442 pWindow->Reparent(this);
1443 ::WinSetWindowUShort(pWindow->GetHWND(), QWS_ID, FID_CLIENT);
1444 ::WinEnableWindowUpdate((HWND)GetHWND(), TRUE);
1445 pWindow->Enable();
1446 pWindow->Show(); // ensure client is showing
1447 if( this->IsShown() )
1448 {
1449 this->Show();
1450 ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
1451 }
1452 }
1453
1454 wxWindow* wxFrame::GetClient()
1455 {
1456 return wxFindWinFromHandle((WXHWND)::WinWindowFromID(m_hFrame, FID_CLIENT));
1457 }
wxWidgets (Impactor)