]> git.saurik.com Git - wxWidgets.git/blob - src/os2/frame.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
*** empty log message ***
[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
347 //
348 // Send anything to initialize the frame
349 //
350 ::WinSendMsg( GetHwnd()
351 ,WM_UPDATEFRAME
352 ,(MPARAM)FCF_MENU
353 ,(MPARAM)0
354 );
355 hClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
356 ::WinShowWindow(GetHwnd(), (BOOL)bShowCmd);
357 ::WinShowWindow(hClient, (BOOL)bShowCmd);
358 } // end of wxFrame::DoShowWindow
359
360 bool wxFrame::Show(
361 bool bShow
362 )
363 {
364 SWP vSwp;
365
366 DoShowWindow((int)bShow);
367
368 if (bShow)
369 {
370 wxActivateEvent vEvent(wxEVT_ACTIVATE, TRUE, m_windowId);
371
372 ::WinQueryWindowPos(GetHwnd(), &vSwp);
373 m_bIconized = vSwp.fl & SWP_MINIMIZE;
374 ::WinSetWindowPos( (HWND) GetHWND()
375 ,HWND_TOP
376 ,vSwp.x
377 ,vSwp.y
378 ,vSwp.cx
379 ,vSwp.cy
380 ,SWP_ZORDER | SWP_ACTIVATE | SWP_SHOW | SWP_MOVE
381 );
382 vEvent.SetEventObject(this);
383 GetEventHandler()->ProcessEvent(vEvent);
384 }
385 else
386 {
387 //
388 // Try to highlight the correct window (the parent)
389 //
390 if (GetParent())
391 {
392 HWND hWndParent = GetHwndOf(GetParent());
393
394 ::WinQueryWindowPos(hWndParent, &vSwp);
395 m_bIconized = vSwp.fl & SWP_MINIMIZE;
396 if (hWndParent)
397 ::WinSetWindowPos( hWndParent
398 ,HWND_TOP
399 ,vSwp.x
400 ,vSwp.y
401 ,vSwp.cx
402 ,vSwp.cy
403 ,SWP_ZORDER | SWP_ACTIVATE | SWP_SHOW | SWP_MOVE
404 );
405 }
406 }
407 return TRUE;
408 } // end of wxFrame::Show
409
410 void wxFrame::Iconize(
411 bool bIconize
412 )
413 {
414 DoShowWindow(bIconize ? SWP_MINIMIZE : SWP_RESTORE);
415 } // end of wxFrame::Iconize
416
417 void wxFrame::Maximize(
418 bool bMaximize)
419 {
420 DoShowWindow(bMaximize ? SWP_MAXIMIZE : SWP_RESTORE);
421 } // end of wxFrame::Maximize
422
423 void wxFrame::Restore()
424 {
425 DoShowWindow(SWP_RESTORE);
426 } // end of wxFrame::Restore
427
428 bool wxFrame::IsIconized() const
429 {
430 SWP vSwp;
431 bool bIconic;
432
433 ::WinQueryWindowPos(GetHwnd(), &vSwp);
434
435 if (vSwp.fl & SWP_MINIMIZE)
436 ((wxFrame*)this)->m_bIconized = TRUE;
437 else
438 ((wxFrame*)this)->m_bIconized = FALSE;
439 return m_bIconized;
440 } // end of wxFrame::IsIconized
441
442 // Is it maximized?
443 bool wxFrame::IsMaximized() const
444 {
445 SWP vSwp;
446 bool bIconic;
447
448 ::WinQueryWindowPos(GetHwnd(), &vSwp);
449 return (vSwp.fl & SWP_MAXIMIZE);
450 } // end of wxFrame::IsMaximized
451
452 void wxFrame::SetIcon(
453 const wxIcon& rIcon
454 )
455 {
456 wxFrameBase::SetIcon(rIcon);
457
458 if ((m_icon.GetHICON()) != NULLHANDLE)
459 {
460 ::WinSendMsg( GetHwnd()
461 ,WM_SETICON
462 ,(MPARAM)((HPOINTER)m_icon.GetHICON())
463 ,NULL
464 );
465 ::WinSendMsg( GetHwnd()
466 ,WM_UPDATEFRAME
467 ,(MPARAM)FCF_ICON
468 ,(MPARAM)0
469 );
470 }
471 } // end of wxFrame::SetIcon
472
473 #if wxUSE_STATUSBAR
474 wxStatusBar* wxFrame::OnCreateStatusBar(
475 int nNumber
476 , long lulStyle
477 , wxWindowID vId
478 , const wxString& rName
479 )
480 {
481 wxStatusBar* pStatusBar = NULL;
482
483 pStatusBar = wxFrameBase::OnCreateStatusBar( nNumber
484 ,lulStyle
485 ,vId
486 ,rName
487 );
488 return pStatusBar;
489 } // end of wxFrame::OnCreateStatusBar
490
491 void wxFrame::PositionStatusBar()
492 {
493 //
494 // Native status bar positions itself
495 //
496 if (m_frameStatusBar)
497 {
498 int nWidth;
499 int nHeight;
500 int nStatbarWidth;
501 int nStatbarHeight;
502 HWND hWndClient;
503 RECTL vRect;
504
505 hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
506 ::WinQueryWindowRect(hWndClient, &vRect);
507 nWidth = vRect.xRight - vRect.xLeft;
508 nHeight = vRect.yTop - vRect.yBottom;
509
510 m_frameStatusBar->GetSize( &nStatbarWidth
511 ,&nStatbarHeight
512 );
513
514 //
515 // Since we wish the status bar to be directly under the client area,
516 // we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS.
517 //
518 m_frameStatusBar->SetSize( 0
519 ,nHeight
520 ,nWidth
521 ,nStatbarHeight
522 );
523 }
524 } // end of wxFrame::PositionStatusBar
525 #endif // wxUSE_STATUSBAR
526
527 void wxFrame::DetachMenuBar()
528 {
529 if (m_frameMenuBar)
530 {
531 m_frameMenuBar->Detach();
532 m_frameMenuBar = NULL;
533 }
534 } // end of wxFrame::DetachMenuBar
535
536 void wxFrame::SetMenuBar(
537 wxMenuBar* pMenuBar
538 )
539 {
540 if (!pMenuBar)
541 {
542 DetachMenuBar();
543 return;
544 }
545
546 m_frameMenuBar = NULL;
547
548 // Can set a menubar several times.
549 // TODO: how to prevent a memory leak if you have a currently-unattached
550 // menubar? wxWindows assumes that the frame will delete the menu (otherwise
551 // there are problems for MDI).
552 if (pMenuBar->GetHMenu())
553 {
554 m_hMenu = pMenuBar->GetHMenu();
555 }
556 else
557 {
558 pMenuBar->Detach();
559
560 m_hMenu = pMenuBar->Create();
561
562 if (!m_hMenu)
563 return;
564 }
565
566 InternalSetMenuBar();
567
568 m_frameMenuBar = pMenuBar;
569 pMenuBar->Attach(this);
570 } // end of wxFrame::SetMenuBar
571
572 void wxFrame::InternalSetMenuBar()
573 {
574 WinSendMsg((HWND)GetHwnd(), WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
575 } // end of wxFrame::InternalSetMenuBar
576
577 //
578 // Responds to colour changes, and passes event on to children
579 //
580 void wxFrame::OnSysColourChanged(
581 wxSysColourChangedEvent& rEvent
582 )
583 {
584 SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
585 Refresh();
586
587 if (m_frameStatusBar)
588 {
589 wxSysColourChangedEvent vEvent2;
590
591 vEvent2.SetEventObject(m_frameStatusBar);
592 m_frameStatusBar->GetEventHandler()->ProcessEvent(vEvent2);
593 }
594
595 //
596 // Propagate the event to the non-top-level children
597 //
598 wxWindow::OnSysColourChanged(rEvent);
599 } // end of wxFrame::OnSysColourChanged
600
601 // Pass TRUE to show full screen, FALSE to restore.
602 bool wxFrame::ShowFullScreen(
603 bool bShow
604 , long lStyle
605 )
606 {
607 /*
608 // TODO
609 if (show)
610 {
611 if (IsFullScreen())
612 return FALSE;
613
614 m_fsIsShowing = TRUE;
615 m_fsStyle = style;
616
617 wxToolBar *theToolBar = GetToolBar();
618 wxStatusBar *theStatusBar = GetStatusBar();
619
620 int dummyWidth;
621
622 if (theToolBar)
623 theToolBar->GetSize(&dummyWidth, &m_fsToolBarHeight);
624 if (theStatusBar)
625 theStatusBar->GetSize(&dummyWidth, &m_fsStatusBarHeight);
626
627 // zap the toolbar, menubar, and statusbar
628
629 if ((style & wxFULLSCREEN_NOTOOLBAR) && theToolBar)
630 {
631 theToolBar->SetSize(-1,0);
632 theToolBar->Show(FALSE);
633 }
634
635 if (style & wxFULLSCREEN_NOMENUBAR)
636 SetMenu((HWND)GetHWND(), (HMENU) NULL);
637
638 // Save the number of fields in the statusbar
639 if ((style & wxFULLSCREEN_NOSTATUSBAR) && theStatusBar)
640 {
641 m_fsStatusBarFields = theStatusBar->GetFieldsCount();
642 SetStatusBar((wxStatusBar*) NULL);
643 delete theStatusBar;
644 }
645 else
646 m_fsStatusBarFields = 0;
647
648 // zap the frame borders
649
650 // save the 'normal' window style
651 m_fsOldWindowStyle = GetWindowLong((HWND)GetHWND(), GWL_STYLE);
652
653 // save the old position, width & height, maximize state
654 m_fsOldSize = GetRect();
655 m_fsIsMaximized = IsMaximized();
656
657 // decide which window style flags to turn off
658 LONG newStyle = m_fsOldWindowStyle;
659 LONG offFlags = 0;
660
661 if (style & wxFULLSCREEN_NOBORDER)
662 offFlags |= WS_BORDER;
663 if (style & wxFULLSCREEN_NOCAPTION)
664 offFlags |= (WS_CAPTION | WS_SYSMENU);
665
666 newStyle &= (~offFlags);
667
668 // change our window style to be compatible with full-screen mode
669 SetWindowLong((HWND)GetHWND(), GWL_STYLE, newStyle);
670
671 // resize to the size of the desktop
672 int width, height;
673
674 RECT rect;
675 ::GetWindowRect(GetDesktopWindow(), &rect);
676 width = rect.right - rect.left;
677 height = rect.bottom - rect.top;
678
679 SetSize(width, height);
680
681 // now flush the window style cache and actually go full-screen
682 SetWindowPos((HWND)GetHWND(), HWND_TOP, 0, 0, width, height, SWP_FRAMECHANGED);
683
684 wxSizeEvent event(wxSize(width, height), GetId());
685 GetEventHandler()->ProcessEvent(event);
686
687 return TRUE;
688 }
689 else
690 {
691 if (!IsFullScreen())
692 return FALSE;
693
694 m_fsIsShowing = FALSE;
695
696 wxToolBar *theToolBar = GetToolBar();
697
698 // restore the toolbar, menubar, and statusbar
699 if (theToolBar && (m_fsStyle & wxFULLSCREEN_NOTOOLBAR))
700 {
701 theToolBar->SetSize(-1, m_fsToolBarHeight);
702 theToolBar->Show(TRUE);
703 }
704
705 if ((m_fsStyle & wxFULLSCREEN_NOSTATUSBAR) && (m_fsStatusBarFields > 0))
706 {
707 CreateStatusBar(m_fsStatusBarFields);
708 PositionStatusBar();
709 }
710
711 if ((m_fsStyle & wxFULLSCREEN_NOMENUBAR) && (m_hMenu != 0))
712 SetMenu((HWND)GetHWND(), (HMENU)m_hMenu);
713
714 Maximize(m_fsIsMaximized);
715 SetWindowLong((HWND)GetHWND(),GWL_STYLE, m_fsOldWindowStyle);
716 SetWindowPos((HWND)GetHWND(),HWND_TOP,m_fsOldSize.x, m_fsOldSize.y,
717 m_fsOldSize.width, m_fsOldSize.height, SWP_FRAMECHANGED);
718
719 return TRUE;
720 }
721 */
722 return TRUE;
723 } // end of wxFrame::ShowFullScreen
724
725 //
726 // Frame window
727 //
728 bool wxFrame::OS2Create(
729 int nId
730 , wxWindow* pParent
731 , const wxChar* zWclass
732 , wxWindow* pWxWin
733 , const wxChar* zTitle
734 , int nX
735 , int nY
736 , int nWidth
737 , int nHeight
738 , long ulStyle
739 )
740 {
741 ULONG ulCreateFlags = 0L;
742 ULONG ulStyleFlags = 0L;
743 ULONG ulExtraFlags = 0L;
744 FRAMECDATA vFrameCtlData;
745 HWND hParent = NULLHANDLE;
746 HWND hClient = NULLHANDLE;
747 HWND hTitlebar = NULLHANDLE;
748 HWND hHScroll = NULLHANDLE;
749 HWND hVScroll = NULLHANDLE;
750 SWP vSwp;
751 SWP vSwpTitlebar;
752 SWP vSwpVScroll;
753 SWP vSwpHScroll;
754
755 m_hDefaultIcon = (WXHICON) (wxSTD_FRAME_ICON ? wxSTD_FRAME_ICON : wxDEFAULT_FRAME_ICON);
756 memset(&vSwp, '\0', sizeof(SWP));
757 memset(&vSwpTitlebar, '\0', sizeof(SWP));
758 memset(&vSwpVScroll, '\0', sizeof(SWP));
759 memset(&vSwpHScroll, '\0', sizeof(SWP));
760 if (pParent)
761 hParent = GetWinHwnd(pParent);
762 else
763 hParent = HWND_DESKTOP;
764
765 if (ulStyle == wxDEFAULT_FRAME_STYLE)
766 ulCreateFlags = FCF_SIZEBORDER | FCF_TITLEBAR | FCF_SYSMENU |
767 FCF_MINMAX | FCF_VERTSCROLL | FCF_HORZSCROLL | FCF_TASKLIST;
768 else
769 {
770 if ((ulStyle & wxCAPTION) == wxCAPTION)
771 ulCreateFlags = FCF_TASKLIST;
772 else
773 ulCreateFlags = FCF_NOMOVEWITHOWNER;
774
775 if (ulStyle & wxMINIMIZE_BOX)
776 ulCreateFlags |= FCF_MINBUTTON;
777 if (ulStyle & wxMAXIMIZE_BOX)
778 ulCreateFlags |= FCF_MAXBUTTON;
779 if (ulStyle & wxTHICK_FRAME)
780 ulCreateFlags |= FCF_DLGBORDER;
781 if (ulStyle & wxSYSTEM_MENU)
782 ulCreateFlags |= FCF_SYSMENU;
783 if (ulStyle & wxCAPTION)
784 ulCreateFlags |= FCF_TASKLIST;
785 if (ulStyle & wxCLIP_CHILDREN)
786 {
787 // Invalid for frame windows under PM
788 }
789
790 if (ulStyle & wxTINY_CAPTION_VERT)
791 ulCreateFlags |= FCF_TASKLIST;
792 if (ulStyle & wxTINY_CAPTION_HORIZ)
793 ulCreateFlags |= FCF_TASKLIST;
794
795 if ((ulStyle & wxTHICK_FRAME) == 0)
796 ulCreateFlags |= FCF_BORDER;
797 if (ulStyle & wxFRAME_TOOL_WINDOW)
798 ulExtraFlags = kFrameToolWindow;
799
800 if (ulStyle & wxSTAY_ON_TOP)
801 ulCreateFlags |= FCF_SYSMODAL;
802 }
803 if ((ulStyle & wxMINIMIZE) || (ulStyle & wxICONIZE))
804 ulStyleFlags |= WS_MINIMIZED;
805 if (ulStyle & wxMAXIMIZE)
806 ulStyleFlags |= WS_MAXIMIZED;
807
808 //
809 // Clear the visible flag, we always call show
810 //
811 ulStyleFlags &= (unsigned long)~WS_VISIBLE;
812 m_bIconized = FALSE;
813
814 //
815 // Set the frame control block
816 //
817 vFrameCtlData.cb = sizeof(vFrameCtlData);
818 vFrameCtlData.flCreateFlags = ulCreateFlags;
819 vFrameCtlData.hmodResources = 0L;
820 vFrameCtlData.idResources = 0;
821
822 //
823 // Create the frame window
824 //
825 if (!wxWindow::OS2Create( hParent
826 ,WC_FRAME
827 ,zTitle
828 ,ulStyleFlags
829 ,(long)nX
830 ,(long)nY
831 ,(long)nWidth
832 ,(long)nHeight
833 ,NULLHANDLE
834 ,HWND_TOP
835 ,(long)nId
836 ,(void*)&vFrameCtlData
837 ,NULL
838 ))
839 {
840 return FALSE;
841 }
842
843 //
844 // Create the client window. We must call the API from here rather than
845 // the static base class create because we need a separate handle
846 //
847 if ((hClient = ::WinCreateWindow( GetHwnd() // Frame is parent
848 ,zWclass // Custom client class
849 ,NULL // Window title
850 ,0 // No styles
851 ,0, 0, 0, 0 // Window position
852 ,NULLHANDLE // Owner
853 ,HWND_TOP // Sibling
854 ,FID_CLIENT // standard client ID
855 ,NULL // Creation data
856 ,NULL // Window Pres Params
857 )) == 0L)
858 {
859 return FALSE;
860 }
861 //
862 // Send anything to initialize the frame
863 //
864 ::WinSendMsg( GetHwnd()
865 ,WM_UPDATEFRAME
866 ,(MPARAM)FCF_TASKLIST
867 ,(MPARAM)0
868 );
869
870 //
871 // Now size everything. If adding a menu the client will need to be resized.
872 //
873 if (!::WinSetWindowPos( GetHwnd()
874 ,HWND_TOP
875 ,nX
876 ,nY
877 ,nWidth
878 ,nHeight
879 ,SWP_SIZE | SWP_MOVE | SWP_ACTIVATE
880 ))
881 return FALSE;
882
883 WinQueryWindowPos(GetHwnd(), &vSwp);
884
885 if (ulCreateFlags & FCF_TITLEBAR)
886 {
887 hTitlebar = WinWindowFromID(GetHwnd(), FID_TITLEBAR);
888 WinQueryWindowPos(hTitlebar, &vSwpTitlebar);
889 }
890 if (ulCreateFlags & FCF_HORZSCROLL)
891 {
892 hHScroll = WinWindowFromID(GetHwnd(), FID_HORZSCROLL);
893 WinQueryWindowPos(hHScroll, &vSwpHScroll);
894 }
895 if (ulCreateFlags & FCF_VERTSCROLL)
896 {
897 hVScroll = WinWindowFromID(GetHwnd(), FID_VERTSCROLL);
898 WinQueryWindowPos(hVScroll, &vSwpVScroll);
899 }
900 if (!::WinSetWindowPos( hClient
901 ,HWND_TOP
902 ,SV_CXSIZEBORDER
903 ,(SV_CYSIZEBORDER - 1) + vSwpHScroll.cy
904 ,vSwp.cx - ((SV_CXSIZEBORDER * 2) + vSwpVScroll.cx)
905 ,vSwp.cy - ((SV_CYSIZEBORDER * 2) + 1 + vSwpTitlebar.cy + vSwpHScroll.cy)
906 ,SWP_SIZE | SWP_MOVE
907 ))
908 return FALSE;
909 WinQueryWindowPos(hClient, &vSwp);
910 return TRUE;
911 } // end of wxFrame::OS2Create
912
913 //
914 // Default activation behaviour - set the focus for the first child
915 // subwindow found.
916 //
917 void wxFrame::OnActivate(
918 wxActivateEvent& rEvent
919 )
920 {
921 for (wxWindowList::Node* pNode = GetChildren().GetFirst();
922 pNode;
923 pNode = pNode->GetNext())
924 {
925 // FIXME all this is totally bogus - we need to do the same as wxPanel,
926 // but how to do it without duplicating the code?
927
928 // restore focus
929 wxWindow* pChild = pNode->GetData();
930
931 if (!pChild->IsTopLevel()
932 #if wxUSE_TOOLBAR
933 && !wxDynamicCast(pChild, wxToolBar)
934 #endif // wxUSE_TOOLBAR
935 #if wxUSE_STATUSBAR
936 && !wxDynamicCast(pChild, wxStatusBar)
937 #endif // wxUSE_STATUSBAR
938 )
939 {
940 pChild->SetFocus();
941 return;
942 }
943 }
944 } // end of wxFrame::OnActivate
945
946 // ----------------------------------------------------------------------------
947 // wxFrame size management: we exclude the areas taken by menu/status/toolbars
948 // from the client area, so the client area is what's really available for the
949 // frame contents
950 // ----------------------------------------------------------------------------
951
952 // Checks if there is a toolbar, and returns the first free client position
953 wxPoint wxFrame::GetClientAreaOrigin() const
954 {
955 wxPoint vPoint(0, 0);
956
957 if (GetToolBar())
958 {
959 int nWidth;
960 int nHeight;
961
962 GetToolBar()->GetSize( &nWidth
963 ,&nHeight
964 );
965
966 if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
967 {
968 vPoint.x += nWidth;
969 }
970 else
971 {
972 // PM is backwards from windows
973 vPoint.y += nHeight;
974 }
975 }
976 return vPoint;
977 } // end of wxFrame::GetClientAreaOrigin
978
979 // ----------------------------------------------------------------------------
980 // tool/status bar stuff
981 // ----------------------------------------------------------------------------
982
983 #if wxUSE_TOOLBAR
984
985 wxToolBar* wxFrame::CreateToolBar(
986 long lStyle
987 , wxWindowID vId
988 , const wxString& rName
989 )
990 {
991 if (wxFrameBase::CreateToolBar( lStyle
992 ,vId
993 ,rName
994 ))
995 {
996 PositionToolBar();
997 }
998 return m_frameToolBar;
999 } // end of wxFrame::CreateToolBar
1000
1001 void wxFrame::PositionToolBar()
1002 {
1003 HWND hWndClient;
1004 RECTL vRect;
1005
1006 hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
1007 ::WinQueryWindowRect(hWndClient, &vRect);
1008
1009 #if wxUSE_STATUSBAR
1010 if (GetStatusBar())
1011 {
1012 int nStatusX;
1013 int nStatusY;
1014
1015 GetStatusBar()->GetClientSize( &nStatusX
1016 ,&nStatusY
1017 );
1018 // PM is backwards from windows
1019 vRect.yBottom += nStatusY;
1020 }
1021 #endif // wxUSE_STATUSBAR
1022
1023 if ( GetToolBar() )
1024 {
1025 int nToolbarWidth;
1026 int nToolbarHeight;
1027
1028 GetToolBar()->GetSize( &nToolbarWidth
1029 ,&nToolbarHeight
1030 );
1031
1032 if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
1033 {
1034 nToolbarHeight = vRect.yBottom;
1035 }
1036 else
1037 {
1038 nToolbarWidth = vRect.xRight;
1039 }
1040
1041 //
1042 // Use the 'real' PM position here
1043 //
1044 GetToolBar()->SetSize( 0
1045 ,0
1046 ,nToolbarWidth
1047 ,nToolbarHeight
1048 ,wxSIZE_NO_ADJUSTMENTS
1049 );
1050 }
1051 } // end of wxFrame::PositionToolBar
1052 #endif // wxUSE_TOOLBAR
1053
1054 // ----------------------------------------------------------------------------
1055 // frame state (iconized/maximized/...)
1056 // ----------------------------------------------------------------------------
1057
1058 //
1059 // propagate our state change to all child frames: this allows us to emulate X
1060 // Windows behaviour where child frames float independently of the parent one
1061 // on the desktop, but are iconized/restored with it
1062 //
1063 void wxFrame::IconizeChildFrames(
1064 bool bIconize
1065 )
1066 {
1067 for (wxWindowList::Node* pNode = GetChildren().GetFirst();
1068 pNode;
1069 pNode = pNode->GetNext() )
1070 {
1071 wxWindow* pWin = pNode->GetData();
1072
1073 if (pWin->IsKindOf(CLASSINFO(wxFrame)) )
1074 {
1075 ((wxFrame *)pWin)->Iconize(bIconize);
1076 }
1077 }
1078 } // end of wxFrame::IconizeChildFrames
1079
1080 // ===========================================================================
1081 // message processing
1082 // ===========================================================================
1083
1084 // ---------------------------------------------------------------------------
1085 // preprocessing
1086 // ---------------------------------------------------------------------------
1087 bool wxFrame::OS2TranslateMessage(
1088 WXMSG* pMsg
1089 )
1090 {
1091 if (wxWindow::OS2TranslateMessage(pMsg))
1092 return TRUE;
1093 //
1094 // try the menu bar accels
1095 //
1096 wxMenuBar* pMenuBar = GetMenuBar();
1097
1098 if (!pMenuBar )
1099 return FALSE;
1100
1101 const wxAcceleratorTable& rAcceleratorTable = pMenuBar->GetAccelTable();
1102 return rAcceleratorTable.Translate(this, pMsg);
1103 } // end of wxFrame::OS2TranslateMessage
1104
1105 // ---------------------------------------------------------------------------
1106 // our private (non virtual) message handlers
1107 // ---------------------------------------------------------------------------
1108 bool wxFrame::HandlePaint()
1109 {
1110 RECTL vRect;
1111
1112 if (::WinQueryUpdateRect(GetHwnd(), &vRect))
1113 {
1114 if (m_bIconized)
1115 {
1116 //
1117 // Icons in PM are the same as "pointers"
1118 //
1119 HPOINTER hIcon;
1120
1121 if (m_icon.Ok())
1122 hIcon = (HPOINTER)::WinSendMsg(GetHwnd(), WM_QUERYICON, 0L, 0L);
1123 else
1124 hIcon = (HPOINTER)m_hDefaultIcon;
1125
1126 //
1127 // Hold a pointer to the dc so long as the OnPaint() message
1128 // is being processed
1129 //
1130 RECTL vRect2;
1131 HPS hPs = ::WinBeginPaint(GetHwnd(), NULLHANDLE, &vRect2);
1132
1133 //
1134 // Erase background before painting or we get white background
1135 //
1136 OS2DefWindowProc(WM_ERASEBACKGROUND, (MPARAM)hPs, (MPARAM)&vRect2);
1137
1138 if (hIcon)
1139 {
1140 HWND hWndClient;
1141 RECTL vRect3;
1142
1143 hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
1144 ::WinQueryWindowRect(hWndClient, &vRect3);
1145
1146 static const int nIconWidth = 32;
1147 static const int nIconHeight = 32;
1148 int nIconX = (int)((vRect3.xRight - nIconWidth)/2);
1149 int nIconY = (int)((vRect3.yBottom + nIconHeight)/2);
1150
1151 ::WinDrawPointer(hPs, nIconX, nIconY, hIcon, DP_NORMAL);
1152 }
1153 ::WinEndPaint(hPs);
1154 return TRUE;
1155 }
1156 else
1157 {
1158 return wxWindow::HandlePaint();
1159 }
1160 }
1161 else
1162 {
1163 // nothing to paint - processed
1164 return TRUE;
1165 }
1166 return FALSE;
1167 } // end of wxFrame::HandlePaint
1168
1169 bool wxFrame::HandleSize(
1170 int nX
1171 , int nY
1172 , WXUINT nId
1173 )
1174 {
1175 bool bProcessed = FALSE;
1176
1177 switch (nId)
1178 {
1179 case kSizeNormal:
1180 //
1181 // Only do it it if we were iconized before, otherwise resizing the
1182 // parent frame has a curious side effect of bringing it under it's
1183 // children
1184 if (!m_bIconized )
1185 break;
1186
1187 //
1188 // restore all child frames too
1189 //
1190 IconizeChildFrames(FALSE);
1191
1192 //
1193 // fall through
1194 //
1195
1196 case kSizeMax:
1197 m_bIconized = FALSE;
1198 break;
1199
1200 case kSizeMin:
1201 //
1202 // Iconize all child frames too
1203 //
1204 IconizeChildFrames(TRUE);
1205 m_bIconized = TRUE;
1206 break;
1207 }
1208
1209 if (!m_bIconized)
1210 {
1211 //
1212 // forward WM_SIZE to status bar control
1213 //
1214 #if wxUSE_NATIVE_STATUSBAR
1215 if (m_frameStatusBar && m_frameStatusBar->IsKindOf(CLASSINFO(wxStatusBar95)))
1216 {
1217 wxSizeEvent vEvent( wxSize( nX
1218 ,nY
1219 )
1220 ,m_frameStatusBar->GetId()
1221 );
1222
1223 vEvent.SetEventObject(m_frameStatusBar);
1224 m_frameStatusBar->OnSize(vEvent);
1225 }
1226 #endif // wxUSE_NATIVE_STATUSBAR
1227
1228 PositionStatusBar();
1229 PositionToolBar();
1230 wxSizeEvent vEvent( wxSize( nX
1231 ,nY
1232 )
1233 ,m_windowId
1234 );
1235
1236 vEvent.SetEventObject(this);
1237 bProcessed = GetEventHandler()->ProcessEvent(vEvent);
1238 }
1239 return bProcessed;
1240 } // end of wxFrame::HandleSize
1241
1242 bool wxFrame::HandleCommand(
1243 WXWORD nId
1244 , WXWORD nCmd
1245 , WXHWND hControl
1246 )
1247 {
1248 if (hControl)
1249 {
1250 //
1251 // In case it's e.g. a toolbar.
1252 //
1253 wxWindow* pWin = wxFindWinFromHandle(hControl);
1254
1255 if (pWin)
1256 return pWin->OS2Command( nCmd
1257 ,nId
1258 );
1259 }
1260
1261 //
1262 // Handle here commands from menus and accelerators
1263 //
1264 if (nCmd == 0 || nCmd == 1)
1265 {
1266 if (wxCurrentPopupMenu)
1267 {
1268 wxMenu* pPopupMenu = wxCurrentPopupMenu;
1269
1270 wxCurrentPopupMenu = NULL;
1271
1272 return pPopupMenu->OS2Command( nCmd
1273 ,nId
1274 );
1275 }
1276
1277 if (ProcessCommand(nId))
1278 {
1279 return TRUE;
1280 }
1281 }
1282 return FALSE;
1283 } // end of wxFrame::HandleCommand
1284
1285 bool wxFrame::HandleMenuSelect(
1286 WXWORD nItem
1287 , WXWORD nFlags
1288 , WXHMENU hMenu
1289 )
1290 {
1291 int nMenuItem;
1292
1293 if (nFlags == 0xFFFF && hMenu == 0)
1294 {
1295 //
1296 // Menu was removed from screen
1297 //
1298 nMenuItem = -1;
1299 }
1300 else if (!(nFlags & MIS_SUBMENU) && !(nFlags & MIS_SEPARATOR))
1301 {
1302 nMenuItem = nItem;
1303 }
1304 else
1305 {
1306 //
1307 // Don't give hints for separators (doesn't make sense) nor for the
1308 // items opening popup menus (they don't have them anyhow)
1309 //
1310 return FALSE;
1311 }
1312 wxMenuEvent vEvent(wxEVT_MENU_HIGHLIGHT, nMenuItem);
1313
1314 vEvent.SetEventObject(this);
1315 return GetEventHandler()->ProcessEvent(vEvent);
1316 } // end of wxFrame::HandleMenuSelect
1317
1318 // ---------------------------------------------------------------------------
1319 // the window proc for wxFrame
1320 // ---------------------------------------------------------------------------
1321
1322 MRESULT wxFrame::OS2WindowProc(
1323 WXUINT uMessage
1324 , WXWPARAM wParam
1325 , WXLPARAM lParam
1326 )
1327 {
1328 MRESULT mRc = 0L;
1329 bool bProcessed = FALSE;
1330
1331 switch (uMessage)
1332 {
1333 case WM_CLOSE:
1334 //
1335 // If we can't close, tell the system that we processed the
1336 // message - otherwise it would close us
1337 //
1338 bProcessed = !Close();
1339 break;
1340
1341 case WM_COMMAND:
1342 {
1343 WORD wId;
1344 WORD wCmd;
1345 WXHWND hWnd;
1346
1347 UnpackCommand( (WXWPARAM)wParam
1348 ,(WXLPARAM)lParam
1349 ,&wId
1350 ,&hWnd
1351 ,&wCmd
1352 );
1353 bProcessed = HandleCommand( wId
1354 ,wCmd
1355 ,(WXHWND)hWnd
1356 );
1357 }
1358 break;
1359
1360 case WM_MENUSELECT:
1361 {
1362 WXWORD wItem;
1363 WXWORD wFlags;
1364 WXHMENU hMenu;
1365
1366 UnpackMenuSelect( wParam
1367 ,lParam
1368 ,&wItem
1369 ,&wFlags
1370 ,&hMenu
1371 );
1372 bProcessed = HandleMenuSelect( wItem
1373 ,wFlags
1374 ,hMenu
1375 );
1376 }
1377 break;
1378
1379 case WM_PAINT:
1380 bProcessed = HandlePaint();
1381 break;
1382
1383 case CM_QUERYDRAGIMAGE:
1384 {
1385 HPOINTER hIcon;
1386
1387 if (m_icon.Ok())
1388 hIcon = (HPOINTER)::WinSendMsg(GetHwnd(), WM_QUERYICON, 0L, 0L);
1389 else
1390 hIcon = (HPOINTER)m_hDefaultIcon;
1391 mRc = (MRESULT)hIcon;
1392 bProcessed = mRc != 0;
1393 }
1394 break;
1395
1396 case WM_SIZE:
1397 bProcessed = HandleSize(LOWORD(lParam), HIWORD(lParam), (WXUINT)wParam);
1398 break;
1399 }
1400
1401 if (!bProcessed )
1402 mRc = wxWindow::OS2WindowProc( uMessage
1403 ,wParam
1404 ,lParam
1405 );
1406 return (MRESULT)0;
1407 } // wxFrame::OS2WindowProc
1408
wxWidgets (Impactor)