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