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