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