projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
more framework fixes for menu displays
[wxWidgets.git] / src / os2 / frame.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: frame.cpp
3 // Purpose: wxFrame
4 // Author: David Webster
5 // Modified by:
6 // Created: 10/27/99
7 // RCS-ID: $Id$
8 // Copyright: (c) David Webster
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
14
15 #ifndef WX_PRECOMP
16 #include "wx/setup.h"
17 #include "wx/frame.h"
18 #include "wx/menu.h"
19 #include "wx/app.h"
20 #include "wx/utils.h"
21 #include "wx/dialog.h"
22 #include "wx/settings.h"
23 #include "wx/dcclient.h"
24 #endif // WX_PRECOMP
25
26 #include "wx/os2/private.h"
27
28 #if wxUSE_STATUSBAR
29 #include "wx/statusbr.h"
30 #include "wx/generic/statusbr.h"
31 #endif // wxUSE_STATUSBAR
32
33 #if wxUSE_TOOLBAR
34 #include "wx/toolbar.h"
35 #endif // wxUSE_TOOLBAR
36
37 #include "wx/menuitem.h"
38 #include "wx/log.h"
39
40 // ----------------------------------------------------------------------------
41 // globals
42 // ----------------------------------------------------------------------------
43
44 extern wxWindowList wxModelessWindows;
45 extern wxList WXDLLEXPORT wxPendingDelete;
46 extern wxChar wxFrameClassName[];
47 extern wxMenu *wxCurrentPopupMenu;
48
49 // ----------------------------------------------------------------------------
50 // event tables
51 // ----------------------------------------------------------------------------
52
53 BEGIN_EVENT_TABLE(wxFrame, wxFrameBase)
54 EVT_ACTIVATE(wxFrame::OnActivate)
55 EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
56 END_EVENT_TABLE()
57
58 IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
59
60 // ============================================================================
61 // implementation
62 // ============================================================================
63
64 // ----------------------------------------------------------------------------
65 // static class members
66 // ----------------------------------------------------------------------------
67
68 #if wxUSE_NATIVE_STATUSBAR
69 bool wxFrame::m_bUseNativeStatusBar = TRUE;
70 #else
71 bool wxFrame::m_bUseNativeStatusBar = FALSE;
72 #endif
73
74 // ----------------------------------------------------------------------------
75 // creation/destruction
76 // ----------------------------------------------------------------------------
77
78 void wxFrame::Init()
79 {
80 m_bIconized = FALSE;
81
82 #if wxUSE_TOOLTIPS
83 m_hWndToolTip = 0;
84 #endif
85 // Data to save/restore when calling ShowFullScreen
86 m_lFsStyle = 0L;
87 m_lFsOldWindowStyle = 0L;
88 m_nFsStatusBarFields = 0;
89 m_nFsStatusBarHeight = 0;
90 m_nFsToolBarHeight = 0;
91 m_bFsIsMaximized = FALSE;
92 m_bFsIsShowing = FALSE;
93 } // end of wxFrame::Init
94
95 bool wxFrame::Create(
96 wxWindow* pParent
97 , wxWindowID vId
98 , const wxString& rsTitle
99 , const wxPoint& rPos
100 , const wxSize& rSize
101 , long lulStyle
102 , const wxString& rsName
103 )
104 {
105 int nX = rPos.x;
106 int nY = rPos.y;
107 int nWidth = rSize.x;
108 int nHeight = rSize.y;
109
110 SetName(rsName);
111 m_windowStyle = lulStyle;
112 m_frameMenuBar = NULL;
113 m_frameToolBar = NULL;
114 m_frameStatusBar = NULL;
115
116 SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
117
118 if (vId > -1 )
119 m_windowId = vId;
120 else
121 m_windowId = (int)NewControlId();
122
123 if (pParent)
124 pParent->AddChild(this);
125
126 m_bIconized = FALSE;
127
128 if ((m_windowStyle & wxFRAME_FLOAT_ON_PARENT) == 0)
129 pParent = NULL;
130
131 if (!pParent)
132 wxTopLevelWindows.Append(this);
133
134 OS2Create( m_windowId
135 ,pParent
136 ,wxFrameClassName
137 ,this
138 ,rsTitle
139 ,nX
140 ,nY
141 ,nWidth
142 ,nHeight
143 ,lulStyle
144 );
145
146 wxModelessWindows.Append(this);
147 return TRUE;
148 } // end of wxFrame::Create
149
150 wxFrame::~wxFrame()
151 {
152 m_isBeingDeleted = TRUE;
153 wxTopLevelWindows.DeleteObject(this);
154
155 DeleteAllBars();
156
157 if (wxTheApp && (wxTopLevelWindows.Number() == 0))
158 {
159 wxTheApp->SetTopWindow(NULL);
160
161 if (wxTheApp->GetExitOnFrameDelete())
162 {
163 ::WinPostMsg(GetHwnd(), WM_QUIT, 0, 0);
164 }
165 }
166 wxModelessWindows.DeleteObject(this);
167
168 //
169 // For some reason, wxWindows can activate another task altogether
170 // when a frame is destroyed after a modal dialog has been invoked.
171 // Try to bring the parent to the top.
172 //
173 // MT:Only do this if this frame is currently the active window, else weird
174 // things start to happen.
175 //
176 if (wxGetActiveWindow() == this)
177 {
178 if (GetParent() && GetParent()->GetHWND())
179 {
180 ::WinSetWindowPos( (HWND) GetParent()->GetHWND()
181 ,HWND_TOP
182 ,0
183 ,0
184 ,0
185 ,0
186 ,SWP_ZORDER
187 );
188 }
189 }
190 } // end of wxFrame::~wxFrame
191
192 //
193 // Get size *available for subwindows* i.e. excluding menu bar, toolbar etc.
194 //
195 void wxFrame::DoGetClientSize(
196 int* pX
197 , int* pY
198 ) const
199 {
200 //
201 // OS/2 PM's coordinates go from bottom-left not
202 // top-left thus the += instead of the -=
203 //
204 RECTL vRect;
205 HWND hWndClient;
206
207 //
208 // PM has no GetClientRect that inherantly knows about the client window
209 // We have to explicitly go fetch it!
210 //
211 hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
212 ::WinQueryWindowRect(hWndClient, &vRect);
213
214 #if wxUSE_STATUSBAR
215 if ( GetStatusBar() )
216 {
217 int nStatusX;
218 int nStatusY;
219
220 GetStatusBar()->GetClientSize( &nStatusX
221 ,&nStatusY
222 );
223 vRect.yBottom += nStatusY;
224 }
225 #endif // wxUSE_STATUSBAR
226
227 wxPoint vPoint(GetClientAreaOrigin());
228
229 vRect.yBottom += vPoint.y;
230 vRect.xRight -= vPoint.x;
231
232 if (pX)
233 *pX = vRect.xRight;
234 if (pY)
235 *pY = vRect.yBottom;
236 } // end of wxFrame::DoGetClientSize
237
238 //
239 // Set the client size (i.e. leave the calculation of borders etc.
240 // to wxWindows)
241 //
242 void wxFrame::DoSetClientSize(
243 int nWidth
244 , int nHeight
245 )
246 {
247 HWND hWnd = GetHwnd();
248 HWND hWndClient;
249 RECTL vRect;
250 RECTL vRect2;
251
252 hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
253 ::WinQueryWindowRect(hWndClient, &vRect);
254
255 ::WinQueryWindowRect(hWnd, &vRect2);
256
257 //
258 // Find the difference between the entire window (title bar and all)
259 // and the client area; add this to the new client size to move the
260 // window. Remember OS/2's backwards y coord system!
261 //
262 int nActualWidth = vRect2.xRight - vRect2.xLeft - vRect.xRight + nWidth;
263 int nActualHeight = vRect2.yTop + vRect2.yTop - vRect.yTop + nHeight;
264
265 #if wxUSE_STATUSBAR
266 if ( GetStatusBar() )
267 {
268 int nStatusX;
269 int nStatusY;
270
271 GetStatusBar()->GetClientSize( &nStatusX
272 ,&nStatusY
273 );
274 nActualHeight += nStatusY;
275 }
276 #endif // wxUSE_STATUSBAR
277
278 wxPoint vPoint(GetClientAreaOrigin());
279 nActualWidth += vPoint.y;
280 nActualHeight += vPoint.x;
281
282 POINTL vPointl;
283
284 vPointl.x = vRect2.xLeft;
285 vPoint.y = vRect2.yTop;
286
287 ::WinSetWindowPos( hWnd
288 ,HWND_TOP
289 ,vPointl.x
290 ,vPointl.y
291 ,nActualWidth
292 ,nActualHeight
293 ,SWP_MOVE | SWP_SIZE | SWP_SHOW
294 );
295
296 wxSizeEvent vEvent( wxSize( nWidth
297 ,nHeight
298 )
299 ,m_windowId
300 );
301 vEvent.SetEventObject(this);
302 GetEventHandler()->ProcessEvent(vEvent);
303 } // end of wxFrame::DoSetClientSize
304
305 void wxFrame::DoGetSize(
306 int* pWidth
307 , int* pHeight
308 ) const
309 {
310 RECTL vRect;
311
312 ::WinQueryWindowRect(GetHwnd(), &vRect);
313 *pWidth = vRect.xRight - vRect.xLeft;
314 *pHeight = vRect.yTop - vRect.yBottom;
315 } // end of wxFrame::DoGetSize
316
317 void wxFrame::DoGetPosition(
318 int* pX
319 , int* pY
320 ) const
321 {
322 RECTL vRect;
323 POINTL vPoint;
324
325 ::WinQueryWindowRect(GetHwnd(), &vRect);
326 vPoint.x = vRect.xLeft;
327
328 //
329 // OS/2 is backwards [WIN32 it is vRect.yTop]
330 //
331 vPoint.y = vRect.yBottom;
332
333 *pX = vPoint.x;
334 *pY = vPoint.y;
335 } // end of wxFrame::DoGetPosition
336
337 // ----------------------------------------------------------------------------
338 // variations around ::ShowWindow()
339 // ----------------------------------------------------------------------------
340
341 void wxFrame::DoShowWindow(
342 int bShowCmd
343 )
344 {
345 HWND hClient;
346 HWND hTitlebar = NULLHANDLE;
347 HWND hHScroll = NULLHANDLE;
348 HWND hVScroll = NULLHANDLE;
349 HWND hMenuBar = NULLHANDLE;
350 SWP vSwp;
351 SWP vSwpTitlebar;
352 SWP vSwpVScroll;
353 SWP vSwpHScroll;
354 SWP vSwpMenu;
355
356 //
357 // Send anything to initialize the frame
358 //
359 WinQueryWindowPos(GetHwnd(), &vSwp);
360 hClient = WinWindowFromID(GetHwnd(), FID_CLIENT);
361 hTitlebar = WinWindowFromID(GetHwnd(), FID_TITLEBAR);
362 WinQueryWindowPos(hTitlebar, &vSwpTitlebar);
363 hHScroll = WinWindowFromID(GetHwnd(), FID_HORZSCROLL);
364 WinQueryWindowPos(hHScroll, &vSwpHScroll);
365 hVScroll = WinWindowFromID(GetHwnd(), FID_VERTSCROLL);
366 WinQueryWindowPos(hVScroll, &vSwpVScroll);
367 hMenuBar = WinWindowFromID(GetHwnd(), FID_MENU);
368 WinQueryWindowPos(hMenuBar, &vSwpMenu);
369 WinSetWindowPos( hClient
370 ,HWND_TOP
371 ,SV_CXSIZEBORDER
372 ,(SV_CYSIZEBORDER - 1) + vSwpHScroll.cy
373 ,vSwp.cx - ((SV_CXSIZEBORDER * 2) + vSwpVScroll.cx)
374 ,vSwp.cy - ((SV_CYSIZEBORDER * 2) + 1 + vSwpTitlebar.cy + vSwpMenu.cy + vSwpHScroll.cy)
375 ,SWP_SIZE | SWP_MOVE
376 );
377 ::WinShowWindow(GetHwnd(), (BOOL)bShowCmd);
378 ::WinShowWindow(hClient, (BOOL)bShowCmd);
379 } // end of wxFrame::DoShowWindow
380
381 bool wxFrame::Show(
382 bool bShow
383 )
384 {
385 SWP vSwp;
386
387 DoShowWindow((int)bShow);
388
389 if (bShow)
390 {
391 wxActivateEvent vEvent(wxEVT_ACTIVATE, TRUE, m_windowId);
392
393 ::WinQueryWindowPos(GetHwnd(), &vSwp);
394 m_bIconized = vSwp.fl & SWP_MINIMIZE;
395 ::WinEnableWindow(GetHwnd(), TRUE);
396 vEvent.SetEventObject(this);
397 GetEventHandler()->ProcessEvent(vEvent);
398 }
399 else
400 {
401 //
402 // Try to highlight the correct window (the parent)
403 //
404 if (GetParent())
405 {
406 HWND hWndParent = GetHwndOf(GetParent());
407
408 ::WinQueryWindowPos(hWndParent, &vSwp);
409 m_bIconized = vSwp.fl & SWP_MINIMIZE;
410 if (hWndParent)
411 ::WinSetWindowPos( hWndParent
412 ,HWND_TOP
413 ,vSwp.x
414 ,vSwp.y
415 ,vSwp.cx
416 ,vSwp.cy
417 ,SWP_ZORDER | SWP_ACTIVATE | SWP_SHOW | SWP_MOVE
418 );
419 ::WinEnableWindow(hWndParent, TRUE);
420 }
421 }
422 return TRUE;
423 } // end of wxFrame::Show
424
425 void wxFrame::Iconize(
426 bool bIconize
427 )
428 {
429 DoShowWindow(bIconize ? SWP_MINIMIZE : SWP_RESTORE);
430 } // end of wxFrame::Iconize
431
432 void wxFrame::Maximize(
433 bool bMaximize)
434 {
435 DoShowWindow(bMaximize ? SWP_MAXIMIZE : SWP_RESTORE);
436 } // end of wxFrame::Maximize
437
438 void wxFrame::Restore()
439 {
440 DoShowWindow(SWP_RESTORE);
441 } // end of wxFrame::Restore
442
443 bool wxFrame::IsIconized() const
444 {
445 SWP vSwp;
446 bool bIconic;
447
448 ::WinQueryWindowPos(GetHwnd(), &vSwp);
449
450 if (vSwp.fl & SWP_MINIMIZE)
451 ((wxFrame*)this)->m_bIconized = TRUE;
452 else
453 ((wxFrame*)this)->m_bIconized = FALSE;
454 return m_bIconized;
455 } // end of wxFrame::IsIconized
456
457 // Is it maximized?
458 bool wxFrame::IsMaximized() const
459 {
460 SWP vSwp;
461 bool bIconic;
462
463 ::WinQueryWindowPos(GetHwnd(), &vSwp);
464 return (vSwp.fl & SWP_MAXIMIZE);
465 } // end of wxFrame::IsMaximized
466
467 void wxFrame::SetIcon(
468 const wxIcon& rIcon
469 )
470 {
471 wxFrameBase::SetIcon(rIcon);
472
473 if ((m_icon.GetHICON()) != NULLHANDLE)
474 {
475 ::WinSendMsg( GetHwnd()
476 ,WM_SETICON
477 ,(MPARAM)((HPOINTER)m_icon.GetHICON())
478 ,NULL
479 );
480 ::WinSendMsg( GetHwnd()
481 ,WM_UPDATEFRAME
482 ,(MPARAM)FCF_ICON
483 ,(MPARAM)0
484 );
485 }
486 } // end of wxFrame::SetIcon
487
488 #if wxUSE_STATUSBAR
489 wxStatusBar* wxFrame::OnCreateStatusBar(
490 int nNumber
491 , long lulStyle
492 , wxWindowID vId
493 , const wxString& rName
494 )
495 {
496 wxStatusBar* pStatusBar = NULL;
497
498 pStatusBar = wxFrameBase::OnCreateStatusBar( nNumber
499 ,lulStyle
500 ,vId
501 ,rName
502 );
503 return pStatusBar;
504 } // end of wxFrame::OnCreateStatusBar
505
506 void wxFrame::PositionStatusBar()
507 {
508 //
509 // Native status bar positions itself
510 //
511 if (m_frameStatusBar)
512 {
513 int nWidth;
514 int nHeight;
515 int nStatbarWidth;
516 int nStatbarHeight;
517 HWND hWndClient;
518 RECTL vRect;
519
520 hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
521 ::WinQueryWindowRect(hWndClient, &vRect);
522 nWidth = vRect.xRight - vRect.xLeft;
523 nHeight = vRect.yTop - vRect.yBottom;
524
525 m_frameStatusBar->GetSize( &nStatbarWidth
526 ,&nStatbarHeight
527 );
528
529 //
530 // Since we wish the status bar to be directly under the client area,
531 // we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS.
532 //
533 m_frameStatusBar->SetSize( 0
534 ,nHeight
535 ,nWidth
536 ,nStatbarHeight
537 );
538 }
539 } // end of wxFrame::PositionStatusBar
540 #endif // wxUSE_STATUSBAR
541
542 void wxFrame::DetachMenuBar()
543 {
544 if (m_frameMenuBar)
545 {
546 m_frameMenuBar->Detach();
547 m_frameMenuBar = NULL;
548 }
549 } // end of wxFrame::DetachMenuBar
550
551 void wxFrame::SetMenuBar(
552 wxMenuBar* pMenuBar
553 )
554 {
555 ERRORID vError;
556 wxString sError;
557
558 if (!pMenuBar)
559 {
560 DetachMenuBar();
561 return;
562 }
563
564 m_frameMenuBar = NULL;
565
566 // Can set a menubar several times.
567 // TODO: how to prevent a memory leak if you have a currently-unattached
568 // menubar? wxWindows assumes that the frame will delete the menu (otherwise
569 // there are problems for MDI).
570 if (pMenuBar->GetHMenu())
571 {
572 m_hMenu = pMenuBar->GetHMenu();
573 }
574 else
575 {
576 pMenuBar->Detach();
577
578 m_hMenu = pMenuBar->Create();
579
580 if (!m_hMenu)
581 return;
582 }
583
584 //
585 // Set the parent and owner of the menubar to be the frame
586 //
587 if (!::WinSetParent(m_hMenu, GetHwnd(), FALSE))
588 {
589 vError = ::WinGetLastError(vHabmain);
590 sError = wxPMErrorToStr(vError);
591 wxLogError("Error setting parent for submenu. Error: %s\n", sError);
592 }
593
594 if (!::WinSetOwner(m_hMenu, GetHwnd()))
595 {
596 vError = ::WinGetLastError(vHabmain);
597 sError = wxPMErrorToStr(vError);
598 wxLogError("Error setting parent for submenu. Error: %s\n", sError);
599 }
600 InternalSetMenuBar();
601
602 m_frameMenuBar = pMenuBar;
603 pMenuBar->Attach(this);
604 } // end of wxFrame::SetMenuBar
605
606 void wxFrame::InternalSetMenuBar()
607 {
608 WinSendMsg((HWND)GetHwnd(), WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
609 } // end of wxFrame::InternalSetMenuBar
610
611 //
612 // Responds to colour changes, and passes event on to children
613 //
614 void wxFrame::OnSysColourChanged(
615 wxSysColourChangedEvent& rEvent
616 )
617 {
618 SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
619 Refresh();
620
621 if (m_frameStatusBar)
622 {
623 wxSysColourChangedEvent vEvent2;
624
625 vEvent2.SetEventObject(m_frameStatusBar);
626 m_frameStatusBar->GetEventHandler()->ProcessEvent(vEvent2);
627 }
628
629 //
630 // Propagate the event to the non-top-level children
631 //
632 wxWindow::OnSysColourChanged(rEvent);
633 } // end of wxFrame::OnSysColourChanged
634
635 // Pass TRUE to show full screen, FALSE to restore.
636 bool wxFrame::ShowFullScreen(
637 bool bShow
638 , long lStyle
639 )
640 {
641 /*
642 // TODO
643 if (show)
644 {
645 if (IsFullScreen())
646 return FALSE;
647
648 m_fsIsShowing = TRUE;
649 m_fsStyle = style;
650
651 wxToolBar *theToolBar = GetToolBar();
652 wxStatusBar *theStatusBar = GetStatusBar();
653
654 int dummyWidth;
655
656 if (theToolBar)
657 theToolBar->GetSize(&dummyWidth, &m_fsToolBarHeight);
658 if (theStatusBar)
659 theStatusBar->GetSize(&dummyWidth, &m_fsStatusBarHeight);
660
661 // zap the toolbar, menubar, and statusbar
662
663 if ((style & wxFULLSCREEN_NOTOOLBAR) && theToolBar)
664 {
665 theToolBar->SetSize(-1,0);
666 theToolBar->Show(FALSE);
667 }
668
669 if (style & wxFULLSCREEN_NOMENUBAR)
670 SetMenu((HWND)GetHWND(), (HMENU) NULL);
671
672 // Save the number of fields in the statusbar
673 if ((style & wxFULLSCREEN_NOSTATUSBAR) && theStatusBar)
674 {
675 m_fsStatusBarFields = theStatusBar->GetFieldsCount();
676 SetStatusBar((wxStatusBar*) NULL);
677 delete theStatusBar;
678 }
679 else
680 m_fsStatusBarFields = 0;
681
682 // zap the frame borders
683
684 // save the 'normal' window style
685 m_fsOldWindowStyle = GetWindowLong((HWND)GetHWND(), GWL_STYLE);
686
687 // save the old position, width & height, maximize state
688 m_fsOldSize = GetRect();
689 m_fsIsMaximized = IsMaximized();
690
691 // decide which window style flags to turn off
692 LONG newStyle = m_fsOldWindowStyle;
693 LONG offFlags = 0;
694
695 if (style & wxFULLSCREEN_NOBORDER)
696 offFlags |= WS_BORDER;
697 if (style & wxFULLSCREEN_NOCAPTION)
698 offFlags |= (WS_CAPTION | WS_SYSMENU);
699
700 newStyle &= (~offFlags);
701
702 // change our window style to be compatible with full-screen mode
703 SetWindowLong((HWND)GetHWND(), GWL_STYLE, newStyle);
704
705 // resize to the size of the desktop
706 int width, height;
707
708 RECT rect;
709 ::GetWindowRect(GetDesktopWindow(), &rect);
710 width = rect.right - rect.left;
711 height = rect.bottom - rect.top;
712
713 SetSize(width, height);
714
715 // now flush the window style cache and actually go full-screen
716 SetWindowPos((HWND)GetHWND(), HWND_TOP, 0, 0, width, height, SWP_FRAMECHANGED);
717
718 wxSizeEvent event(wxSize(width, height), GetId());
719 GetEventHandler()->ProcessEvent(event);
720
721 return TRUE;
722 }
723 else
724 {
725 if (!IsFullScreen())
726 return FALSE;
727
728 m_fsIsShowing = FALSE;
729
730 wxToolBar *theToolBar = GetToolBar();
731
732 // restore the toolbar, menubar, and statusbar
733 if (theToolBar && (m_fsStyle & wxFULLSCREEN_NOTOOLBAR))
734 {
735 theToolBar->SetSize(-1, m_fsToolBarHeight);
736 theToolBar->Show(TRUE);
737 }
738
739 if ((m_fsStyle & wxFULLSCREEN_NOSTATUSBAR) && (m_fsStatusBarFields > 0))
740 {
741 CreateStatusBar(m_fsStatusBarFields);
742 PositionStatusBar();
743 }
744
745 if ((m_fsStyle & wxFULLSCREEN_NOMENUBAR) && (m_hMenu != 0))
746 SetMenu((HWND)GetHWND(), (HMENU)m_hMenu);
747
748 Maximize(m_fsIsMaximized);
749 SetWindowLong((HWND)GetHWND(),GWL_STYLE, m_fsOldWindowStyle);
750 SetWindowPos((HWND)GetHWND(),HWND_TOP,m_fsOldSize.x, m_fsOldSize.y,
751 m_fsOldSize.width, m_fsOldSize.height, SWP_FRAMECHANGED);
752
753 return TRUE;
754 }
755 */
756 return TRUE;
757 } // end of wxFrame::ShowFullScreen
758
759 //
760 // Frame window
761 //
762 bool wxFrame::OS2Create(
763 int nId
764 , wxWindow* pParent
765 , const wxChar* zWclass
766 , wxWindow* pWxWin
767 , const wxChar* zTitle
768 , int nX
769 , int nY
770 , int nWidth
771 , int nHeight
772 , long ulStyle
773 )
774 {
775 ULONG ulCreateFlags = 0L;
776 ULONG ulStyleFlags = 0L;
777 ULONG ulExtraFlags = 0L;
778 FRAMECDATA vFrameCtlData;
779 HWND hParent = NULLHANDLE;
780 HWND hClient = NULLHANDLE;
781 HWND hTitlebar = NULLHANDLE;
782 HWND hHScroll = NULLHANDLE;
783 HWND hVScroll = NULLHANDLE;
784 HWND hMenuBar = NULLHANDLE;
785 HWND hMenu1 = NULLHANDLE;
786 HWND hMenu2 = NULLHANDLE;
787 HWND hFrame = NULLHANDLE;
788 SWP vSwp;
789 SWP vSwpTitlebar;
790 SWP vSwpVScroll;
791 SWP vSwpHScroll;
792 SWP vSwpMenu;
793 RGB2 vRgb;
794
795 m_hDefaultIcon = (WXHICON) (wxSTD_FRAME_ICON ? wxSTD_FRAME_ICON : wxDEFAULT_FRAME_ICON);
796 memset(&vSwp, '\0', sizeof(SWP));
797 memset(&vSwpTitlebar, '\0', sizeof(SWP));
798 memset(&vSwpVScroll, '\0', sizeof(SWP));
799 memset(&vSwpHScroll, '\0', sizeof(SWP));
800
801 if (pParent)
802 hParent = GetWinHwnd(pParent);
803 else
804 hParent = HWND_DESKTOP;
805
806 if (ulStyle == wxDEFAULT_FRAME_STYLE)
807 ulCreateFlags = FCF_SIZEBORDER | FCF_TITLEBAR | FCF_SYSMENU |
808 FCF_MINMAX | FCF_VERTSCROLL | FCF_HORZSCROLL | FCF_TASKLIST;
809 else
810 {
811 if ((ulStyle & wxCAPTION) == wxCAPTION)
812 ulCreateFlags = FCF_TASKLIST;
813 else
814 ulCreateFlags = FCF_NOMOVEWITHOWNER;
815
816 if (ulStyle & wxMINIMIZE_BOX)
817 ulCreateFlags |= FCF_MINBUTTON;
818 if (ulStyle & wxMAXIMIZE_BOX)
819 ulCreateFlags |= FCF_MAXBUTTON;
820 if (ulStyle & wxTHICK_FRAME)
821 ulCreateFlags |= FCF_DLGBORDER;
822 if (ulStyle & wxSYSTEM_MENU)
823 ulCreateFlags |= FCF_SYSMENU;
824 if (ulStyle & wxCAPTION)
825 ulCreateFlags |= FCF_TASKLIST;
826 if (ulStyle & wxCLIP_CHILDREN)
827 {
828 // Invalid for frame windows under PM
829 }
830
831 if (ulStyle & wxTINY_CAPTION_VERT)
832 ulCreateFlags |= FCF_TASKLIST;
833 if (ulStyle & wxTINY_CAPTION_HORIZ)
834 ulCreateFlags |= FCF_TASKLIST;
835
836 if ((ulStyle & wxTHICK_FRAME) == 0)
837 ulCreateFlags |= FCF_BORDER;
838 if (ulStyle & wxFRAME_TOOL_WINDOW)
839 ulExtraFlags = kFrameToolWindow;
840
841 if (ulStyle & wxSTAY_ON_TOP)
842 ulCreateFlags |= FCF_SYSMODAL;
843 }
844 if ((ulStyle & wxMINIMIZE) || (ulStyle & wxICONIZE))
845 ulStyleFlags |= WS_MINIMIZED;
846 if (ulStyle & wxMAXIMIZE)
847 ulStyleFlags |= WS_MAXIMIZED;
848
849 //
850 // Clear the visible flag, we always call show
851 //
852 ulStyleFlags &= (unsigned long)~WS_VISIBLE;
853 m_bIconized = FALSE;
854
855 //
856 // Set the frame control block
857 //
858 vFrameCtlData.cb = sizeof(vFrameCtlData);
859 vFrameCtlData.flCreateFlags = ulCreateFlags;
860 vFrameCtlData.hmodResources = 0L;
861 vFrameCtlData.idResources = 0;
862
863 //
864 // Create the frame window
865 //
866 if (!wxWindow::OS2Create( hParent
867 ,WC_FRAME
868 ,zTitle
869 ,ulStyleFlags
870 ,(long)nX
871 ,(long)nY
872 ,(long)nWidth
873 ,(long)nHeight
874 ,NULLHANDLE
875 ,HWND_TOP
876 ,(long)nId
877 ,(void*)&vFrameCtlData
878 ,NULL
879 ))
880 {
881 return FALSE;
882 }
883
884 //
885 // Create the client window. We must call the API from here rather than
886 // the static base class create because we need a separate handle
887 //
888 if ((hClient = ::WinCreateWindow( hFrame // Frame is parent
889 ,wxFrameClassName
890 ,NULL // Window title
891 ,0 // No styles
892 ,0, 0, 0, 0 // Window position
893 ,NULLHANDLE // Owner
894 ,HWND_TOP // Sibling
895 ,FID_CLIENT // standard client ID
896 ,NULL // Creation data
897 ,NULL // Window Pres Params
898 )) == 0L)
899 {
900 return FALSE;
901 }
902 //
903 // Send anything to initialize the frame
904 //
905 ::WinSendMsg( hFrame
906 ,WM_UPDATEFRAME
907 ,(MPARAM)FCF_TASKLIST
908 ,(MPARAM)0
909 );
910
911 //
912 // Now size everything. If adding a menu the client will need to be resized.
913 //
914 if (!::WinSetWindowPos( hFrame
915 ,HWND_TOP
916 ,nX
917 ,nY
918 ,nWidth
919 ,nHeight
920 ,SWP_SIZE | SWP_MOVE | SWP_ACTIVATE
921 ))
922 return FALSE;
923
924 WinQueryWindowPos(hFrame, &vSwp);
925
926 //
927 // Set the client window's background, otherwise it is transparent!
928 //
929 wxColour vColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW);
930
931 vRgb.bRed = (BYTE)vColour.Red();
932 vRgb.bGreen = (BYTE)vColour.Green();
933 vRgb.bBlue = (BYTE)vColour.Blue();
934 WinSetPresParam( hClient
935 ,PP_BACKGROUNDCOLOR
936 ,(ULONG)sizeof(RGB2)
937 ,(PVOID)&vRgb
938 );
939 if (ulCreateFlags & FCF_TITLEBAR)
940 {
941 hTitlebar = WinWindowFromID(hFrame, FID_TITLEBAR);
942 WinQueryWindowPos(hTitlebar, &vSwpTitlebar);
943 }
944 if (ulCreateFlags & FCF_HORZSCROLL)
945 {
946 hHScroll = WinWindowFromID(hFrame, FID_HORZSCROLL);
947 WinQueryWindowPos(hHScroll, &vSwpHScroll);
948 }
949 if (ulCreateFlags & FCF_VERTSCROLL)
950 {
951 hVScroll = WinWindowFromID(hFrame, FID_VERTSCROLL);
952 WinQueryWindowPos(hVScroll, &vSwpVScroll);
953 }
954 if (!::WinSetWindowPos( hClient
955 ,HWND_TOP
956 ,SV_CXSIZEBORDER
957 ,(SV_CYSIZEBORDER - 1) + vSwpHScroll.cy
958 ,vSwp.cx - ((SV_CXSIZEBORDER * 2) + vSwpVScroll.cx)
959 ,vSwp.cy - ((SV_CYSIZEBORDER * 2) + 1 + vSwpTitlebar.cy + vSwpHScroll.cy)
960 ,SWP_SIZE | SWP_MOVE
961 ))
962 return FALSE;
963 WinQueryWindowPos(hClient, &vSwp);
964 ::WinShowWindow(hClient, TRUE);
965 return TRUE;
966 } // end of wxFrame::OS2Create
967
968 //
969 // Default activation behaviour - set the focus for the first child
970 // subwindow found.
971 //
972 void wxFrame::OnActivate(
973 wxActivateEvent& rEvent
974 )
975 {
976 for (wxWindowList::Node* pNode = GetChildren().GetFirst();
977 pNode;
978 pNode = pNode->GetNext())
979 {
980 // FIXME all this is totally bogus - we need to do the same as wxPanel,
981 // but how to do it without duplicating the code?
982
983 // restore focus
984 wxWindow* pChild = pNode->GetData();
985
986 if (!pChild->IsTopLevel()
987 #if wxUSE_TOOLBAR
988 && !wxDynamicCast(pChild, wxToolBar)
989 #endif // wxUSE_TOOLBAR
990 #if wxUSE_STATUSBAR
991 && !wxDynamicCast(pChild, wxStatusBar)
992 #endif // wxUSE_STATUSBAR
993 )
994 {
995 pChild->SetFocus();
996 return;
997 }
998 }
999 } // end of wxFrame::OnActivate
1000
1001 // ----------------------------------------------------------------------------
1002 // wxFrame size management: we exclude the areas taken by menu/status/toolbars
1003 // from the client area, so the client area is what's really available for the
1004 // frame contents
1005 // ----------------------------------------------------------------------------
1006
1007 // Checks if there is a toolbar, and returns the first free client position
1008 wxPoint wxFrame::GetClientAreaOrigin() const
1009 {
1010 wxPoint vPoint(0, 0);
1011
1012 if (GetToolBar())
1013 {
1014 int nWidth;
1015 int nHeight;
1016
1017 GetToolBar()->GetSize( &nWidth
1018 ,&nHeight
1019 );
1020
1021 if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
1022 {
1023 vPoint.x += nWidth;
1024 }
1025 else
1026 {
1027 // PM is backwards from windows
1028 vPoint.y += nHeight;
1029 }
1030 }
1031 return vPoint;
1032 } // end of wxFrame::GetClientAreaOrigin
1033
1034 // ----------------------------------------------------------------------------
1035 // tool/status bar stuff
1036 // ----------------------------------------------------------------------------
1037
1038 #if wxUSE_TOOLBAR
1039
1040 wxToolBar* wxFrame::CreateToolBar(
1041 long lStyle
1042 , wxWindowID vId
1043 , const wxString& rName
1044 )
1045 {
1046 if (wxFrameBase::CreateToolBar( lStyle
1047 ,vId
1048 ,rName
1049 ))
1050 {
1051 PositionToolBar();
1052 }
1053 return m_frameToolBar;
1054 } // end of wxFrame::CreateToolBar
1055
1056 void wxFrame::PositionToolBar()
1057 {
1058 HWND hWndClient;
1059 RECTL vRect;
1060
1061 hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
1062 ::WinQueryWindowRect(hWndClient, &vRect);
1063
1064 #if wxUSE_STATUSBAR
1065 if (GetStatusBar())
1066 {
1067 int nStatusX;
1068 int nStatusY;
1069
1070 GetStatusBar()->GetClientSize( &nStatusX
1071 ,&nStatusY
1072 );
1073 // PM is backwards from windows
1074 vRect.yBottom += nStatusY;
1075 }
1076 #endif // wxUSE_STATUSBAR
1077
1078 if ( GetToolBar() )
1079 {
1080 int nToolbarWidth;
1081 int nToolbarHeight;
1082
1083 GetToolBar()->GetSize( &nToolbarWidth
1084 ,&nToolbarHeight
1085 );
1086
1087 if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
1088 {
1089 nToolbarHeight = vRect.yBottom;
1090 }
1091 else
1092 {
1093 nToolbarWidth = vRect.xRight;
1094 }
1095
1096 //
1097 // Use the 'real' PM position here
1098 //
1099 GetToolBar()->SetSize( 0
1100 ,0
1101 ,nToolbarWidth
1102 ,nToolbarHeight
1103 ,wxSIZE_NO_ADJUSTMENTS
1104 );
1105 }
1106 } // end of wxFrame::PositionToolBar
1107 #endif // wxUSE_TOOLBAR
1108
1109 // ----------------------------------------------------------------------------
1110 // frame state (iconized/maximized/...)
1111 // ----------------------------------------------------------------------------
1112
1113 //
1114 // propagate our state change to all child frames: this allows us to emulate X
1115 // Windows behaviour where child frames float independently of the parent one
1116 // on the desktop, but are iconized/restored with it
1117 //
1118 void wxFrame::IconizeChildFrames(
1119 bool bIconize
1120 )
1121 {
1122 for (wxWindowList::Node* pNode = GetChildren().GetFirst();
1123 pNode;
1124 pNode = pNode->GetNext() )
1125 {
1126 wxWindow* pWin = pNode->GetData();
1127
1128 if (pWin->IsKindOf(CLASSINFO(wxFrame)) )
1129 {
1130 ((wxFrame *)pWin)->Iconize(bIconize);
1131 }
1132 }
1133 } // end of wxFrame::IconizeChildFrames
1134
1135 // ===========================================================================
1136 // message processing
1137 // ===========================================================================
1138
1139 // ---------------------------------------------------------------------------
1140 // preprocessing
1141 // ---------------------------------------------------------------------------
1142 bool wxFrame::OS2TranslateMessage(
1143 WXMSG* pMsg
1144 )
1145 {
1146 if (wxWindow::OS2TranslateMessage(pMsg))
1147 return TRUE;
1148 //
1149 // try the menu bar accels
1150 //
1151 wxMenuBar* pMenuBar = GetMenuBar();
1152
1153 if (!pMenuBar )
1154 return FALSE;
1155
1156 const wxAcceleratorTable& rAcceleratorTable = pMenuBar->GetAccelTable();
1157 return rAcceleratorTable.Translate(this, pMsg);
1158 } // end of wxFrame::OS2TranslateMessage
1159
1160 // ---------------------------------------------------------------------------
1161 // our private (non virtual) message handlers
1162 // ---------------------------------------------------------------------------
1163 bool wxFrame::HandlePaint()
1164 {
1165 RECTL vRect;
1166
1167 if (::WinQueryUpdateRect(GetHwnd(), &vRect))
1168 {
1169 if (m_bIconized)
1170 {
1171 //
1172 // Icons in PM are the same as "pointers"
1173 //
1174 HPOINTER hIcon;
1175
1176 if (m_icon.Ok())
1177 hIcon = (HPOINTER)::WinSendMsg(GetHwnd(), WM_QUERYICON, 0L, 0L);
1178 else
1179 hIcon = (HPOINTER)m_hDefaultIcon;
1180
1181 //
1182 // Hold a pointer to the dc so long as the OnPaint() message
1183 // is being processed
1184 //
1185 RECTL vRect2;
1186 HPS hPs = ::WinBeginPaint(GetHwnd(), NULLHANDLE, &vRect2);
1187
1188 //
1189 // Erase background before painting or we get white background
1190 //
1191 OS2DefWindowProc(WM_ERASEBACKGROUND, (MPARAM)hPs, (MPARAM)&vRect2);
1192
1193 if (hIcon)
1194 {
1195 HWND hWndClient;
1196 RECTL vRect3;
1197
1198 hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
1199 ::WinQueryWindowRect(hWndClient, &vRect3);
1200
1201 static const int nIconWidth = 32;
1202 static const int nIconHeight = 32;
1203 int nIconX = (int)((vRect3.xRight - nIconWidth)/2);
1204 int nIconY = (int)((vRect3.yBottom + nIconHeight)/2);
1205
1206 ::WinDrawPointer(hPs, nIconX, nIconY, hIcon, DP_NORMAL);
1207 }
1208 ::WinEndPaint(hPs);
1209 return TRUE;
1210 }
1211 else
1212 {
1213 return wxWindow::HandlePaint();
1214 }
1215 }
1216 else
1217 {
1218 // nothing to paint - processed
1219 return TRUE;
1220 }
1221 return FALSE;
1222 } // end of wxFrame::HandlePaint
1223
1224 bool wxFrame::HandleSize(
1225 int nX
1226 , int nY
1227 , WXUINT nId
1228 )
1229 {
1230 bool bProcessed = FALSE;
1231
1232 switch (nId)
1233 {
1234 case kSizeNormal:
1235 //
1236 // Only do it it if we were iconized before, otherwise resizing the
1237 // parent frame has a curious side effect of bringing it under it's
1238 // children
1239 if (!m_bIconized )
1240 break;
1241
1242 //
1243 // restore all child frames too
1244 //
1245 IconizeChildFrames(FALSE);
1246
1247 //
1248 // fall through
1249 //
1250
1251 case kSizeMax:
1252 m_bIconized = FALSE;
1253 break;
1254
1255 case kSizeMin:
1256 //
1257 // Iconize all child frames too
1258 //
1259 IconizeChildFrames(TRUE);
1260 m_bIconized = TRUE;
1261 break;
1262 }
1263
1264 if (!m_bIconized)
1265 {
1266 //
1267 // forward WM_SIZE to status bar control
1268 //
1269 #if wxUSE_NATIVE_STATUSBAR
1270 if (m_frameStatusBar && m_frameStatusBar->IsKindOf(CLASSINFO(wxStatusBar95)))
1271 {
1272 wxSizeEvent vEvent( wxSize( nX
1273 ,nY
1274 )
1275 ,m_frameStatusBar->GetId()
1276 );
1277
1278 vEvent.SetEventObject(m_frameStatusBar);
1279 m_frameStatusBar->OnSize(vEvent);
1280 }
1281 #endif // wxUSE_NATIVE_STATUSBAR
1282
1283 PositionStatusBar();
1284 PositionToolBar();
1285 wxSizeEvent vEvent( wxSize( nX
1286 ,nY
1287 )
1288 ,m_windowId
1289 );
1290
1291 vEvent.SetEventObject(this);
1292 bProcessed = GetEventHandler()->ProcessEvent(vEvent);
1293 }
1294 return bProcessed;
1295 } // end of wxFrame::HandleSize
1296
1297 bool wxFrame::HandleCommand(
1298 WXWORD nId
1299 , WXWORD nCmd
1300 , WXHWND hControl
1301 )
1302 {
1303 if (hControl)
1304 {
1305 //
1306 // In case it's e.g. a toolbar.
1307 //
1308 wxWindow* pWin = wxFindWinFromHandle(hControl);
1309
1310 if (pWin)
1311 return pWin->OS2Command( nCmd
1312 ,nId
1313 );
1314 }
1315
1316 //
1317 // Handle here commands from menus and accelerators
1318 //
1319 if (nCmd == 0 || nCmd == 1)
1320 {
1321 if (wxCurrentPopupMenu)
1322 {
1323 wxMenu* pPopupMenu = wxCurrentPopupMenu;
1324
1325 wxCurrentPopupMenu = NULL;
1326
1327 return pPopupMenu->OS2Command( nCmd
1328 ,nId
1329 );
1330 }
1331
1332 if (ProcessCommand(nId))
1333 {
1334 return TRUE;
1335 }
1336 }
1337 return FALSE;
1338 } // end of wxFrame::HandleCommand
1339
1340 bool wxFrame::HandleMenuSelect(
1341 WXWORD nItem
1342 , WXWORD nFlags
1343 , WXHMENU hMenu
1344 )
1345 {
1346 int nMenuItem;
1347
1348 if (nFlags == 0xFFFF && hMenu == 0)
1349 {
1350 //
1351 // Menu was removed from screen
1352 //
1353 nMenuItem = -1;
1354 }
1355 else if (!(nFlags & MIS_SUBMENU) && !(nFlags & MIS_SEPARATOR))
1356 {
1357 nMenuItem = nItem;
1358 }
1359 else
1360 {
1361 //
1362 // Don't give hints for separators (doesn't make sense) nor for the
1363 // items opening popup menus (they don't have them anyhow)
1364 //
1365 return FALSE;
1366 }
1367 wxMenuEvent vEvent(wxEVT_MENU_HIGHLIGHT, nMenuItem);
1368
1369 vEvent.SetEventObject(this);
1370 return GetEventHandler()->ProcessEvent(vEvent);
1371 } // end of wxFrame::HandleMenuSelect
1372
1373 // ---------------------------------------------------------------------------
1374 // the window proc for wxFrame
1375 // ---------------------------------------------------------------------------
1376
1377 MRESULT wxFrame::OS2WindowProc(
1378 WXUINT uMessage
1379 , WXWPARAM wParam
1380 , WXLPARAM lParam
1381 )
1382 {
1383 MRESULT mRc = 0L;
1384 bool bProcessed = FALSE;
1385
1386 switch (uMessage)
1387 {
1388 case WM_CLOSE:
1389 //
1390 // If we can't close, tell the system that we processed the
1391 // message - otherwise it would close us
1392 //
1393 bProcessed = !Close();
1394 break;
1395
1396 case WM_COMMAND:
1397 {
1398 WORD wId;
1399 WORD wCmd;
1400 WXHWND hWnd;
1401
1402 UnpackCommand( (WXWPARAM)wParam
1403 ,(WXLPARAM)lParam
1404 ,&wId
1405 ,&hWnd
1406 ,&wCmd
1407 );
1408 bProcessed = HandleCommand( wId
1409 ,wCmd
1410 ,(WXHWND)hWnd
1411 );
1412 }
1413 break;
1414
1415 case WM_MENUSELECT:
1416 {
1417 WXWORD wItem;
1418 WXWORD wFlags;
1419 WXHMENU hMenu;
1420
1421 UnpackMenuSelect( wParam
1422 ,lParam
1423 ,&wItem
1424 ,&wFlags
1425 ,&hMenu
1426 );
1427 bProcessed = HandleMenuSelect( wItem
1428 ,wFlags
1429 ,hMenu
1430 );
1431 }
1432 break;
1433
1434 case WM_PAINT:
1435 bProcessed = HandlePaint();
1436 break;
1437
1438 case CM_QUERYDRAGIMAGE:
1439 {
1440 HPOINTER hIcon;
1441
1442 if (m_icon.Ok())
1443 hIcon = (HPOINTER)::WinSendMsg(GetHwnd(), WM_QUERYICON, 0L, 0L);
1444 else
1445 hIcon = (HPOINTER)m_hDefaultIcon;
1446 mRc = (MRESULT)hIcon;
1447 bProcessed = mRc != 0;
1448 }
1449 break;
1450
1451 case WM_SIZE:
1452 bProcessed = HandleSize(LOWORD(lParam), HIWORD(lParam), (WXUINT)wParam);
1453 break;
1454 }
1455
1456 if (!bProcessed )
1457 mRc = wxWindow::OS2WindowProc( uMessage
1458 ,wParam
1459 ,lParam
1460 );
1461 return (MRESULT)0;
1462 } // wxFrame::OS2WindowProc
1463
wxWidgets (Impactor)