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