]> git.saurik.com Git - wxWidgets.git/blob - src/os2/frame.cpp
projects / wxWidgets.git / blob
? search:


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