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