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


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