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