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


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