]> 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
correction for Mac OS X
[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/defs.h"
17 #include "wx/object.h"
18 #include "wx/dynarray.h"
19 #include "wx/list.h"
20 #include "wx/hash.h"
21 #include "wx/string.h"
22 #include "wx/intl.h"
23 #include "wx/log.h"
24 #include "wx/event.h"
25 #include "wx/setup.h"
26 #include "wx/frame.h"
27 #include "wx/menu.h"
28 #include "wx/app.h"
29 #include "wx/utils.h"
30 #include "wx/dialog.h"
31 #include "wx/settings.h"
32 #include "wx/dcclient.h"
33 #endif // WX_PRECOMP
34
35 #include "wx/os2/private.h"
36
37 #if wxUSE_STATUSBAR
38 #include "wx/statusbr.h"
39 #include "wx/generic/statusbr.h"
40 #endif // wxUSE_STATUSBAR
41
42 #if wxUSE_TOOLBAR
43 #include "wx/toolbar.h"
44 #endif // wxUSE_TOOLBAR
45
46 #include "wx/menuitem.h"
47 #include "wx/log.h"
48
49 // ----------------------------------------------------------------------------
50 // globals
51 // ----------------------------------------------------------------------------
52
53 extern wxWindowList wxModelessWindows;
54 extern wxList WXDLLEXPORT wxPendingDelete;
55 extern wxChar wxFrameClassName[];
56 extern wxMenu *wxCurrentPopupMenu;
57
58 extern void wxAssociateWinWithHandle( HWND hWnd
59 ,wxWindow* pWin
60 );
61
62 // ----------------------------------------------------------------------------
63 // event tables
64 // ----------------------------------------------------------------------------
65
66 BEGIN_EVENT_TABLE(wxFrame, wxFrameBase)
67 EVT_ACTIVATE(wxFrame::OnActivate)
68 EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
69 END_EVENT_TABLE()
70
71 IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
72
73 // ============================================================================
74 // implementation
75 // ============================================================================
76
77 // ----------------------------------------------------------------------------
78 // static class members
79 // ----------------------------------------------------------------------------
80 #if wxUSE_STATUSBAR
81
82 #if wxUSE_NATIVE_STATUSBAR
83 bool wxFrame::m_bUseNativeStatusBar = TRUE;
84 #else
85 bool wxFrame::m_bUseNativeStatusBar = FALSE;
86 #endif
87
88 #endif //wxUSE_STATUSBAR
89
90 // ----------------------------------------------------------------------------
91 // creation/destruction
92 // ----------------------------------------------------------------------------
93
94 void wxFrame::Init()
95 {
96 m_bIconized = FALSE;
97
98 #if wxUSE_TOOLTIPS
99 m_hWndToolTip = 0;
100 #endif
101 // Data to save/restore when calling ShowFullScreen
102 m_lFsStyle = 0L;
103 m_lFsOldWindowStyle = 0L;
104 m_nFsStatusBarFields = 0;
105 m_nFsStatusBarHeight = 0;
106 m_nFsToolBarHeight = 0;
107 m_bFsIsMaximized = FALSE;
108 m_bFsIsShowing = FALSE;
109 m_bIsShown = FALSE;
110 m_pWinLastFocused = (wxWindow *)NULL;
111
112 m_hFrame = NULL;
113 m_hTitleBar = NULL;
114 m_hHScroll = NULL;
115 m_hVScroll = NULL;
116
117 //
118 // Initialize SWP's
119 //
120 memset(&m_vSwp, 0, sizeof(SWP));
121 memset(&m_vSwpClient, 0, sizeof(SWP));
122 memset(&m_vSwpTitleBar, 0, sizeof(SWP));
123 memset(&m_vSwpMenuBar, 0, sizeof(SWP));
124 memset(&m_vSwpHScroll, 0, sizeof(SWP));
125 memset(&m_vSwpVScroll, 0, sizeof(SWP));
126 memset(&m_vSwpStatusBar, 0, sizeof(SWP));
127 memset(&m_vSwpToolBar, 0, sizeof(SWP));
128 } // end of wxFrame::Init
129
130 bool wxFrame::Create(
131 wxWindow* pParent
132 , wxWindowID vId
133 , const wxString& rsTitle
134 , const wxPoint& rPos
135 , const wxSize& rSize
136 , long lulStyle
137 , const wxString& rsName
138 )
139 {
140 int nX = rPos.x;
141 int nY = rPos.y;
142 int nWidth = rSize.x;
143 int nHeight = rSize.y;
144 bool bOk = FALSE;
145
146 SetName(rsName);
147 m_windowStyle = lulStyle;
148 m_frameMenuBar = NULL;
149 #if wxUSE_TOOLBAR
150 m_frameToolBar = NULL;
151 #endif //wxUSE_TOOLBAR
152
153 #if wxUSE_STATUSBAR
154 m_frameStatusBar = NULL;
155 #endif //wxUSE_STATUSBAR
156
157 SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
158
159 if (vId > -1 )
160 m_windowId = vId;
161 else
162 m_windowId = (int)NewControlId();
163
164 if (pParent)
165 pParent->AddChild(this);
166
167 m_bIconized = FALSE;
168
169 if ((m_windowStyle & wxFRAME_FLOAT_ON_PARENT) == 0)
170 pParent = NULL;
171
172 bOk = OS2Create( m_windowId
173 ,pParent
174 ,wxFrameClassName
175 ,this
176 ,rsTitle
177 ,nX
178 ,nY
179 ,nWidth
180 ,nHeight
181 ,lulStyle
182 );
183 if (bOk)
184 {
185 if (!pParent)
186 wxTopLevelWindows.Append(this);
187 wxModelessWindows.Append(this);
188 }
189 return(bOk);
190 } // end of wxFrame::Create
191
192 wxFrame::~wxFrame()
193 {
194 m_isBeingDeleted = TRUE;
195
196 wxTopLevelWindows.DeleteObject(this);
197
198 DeleteAllBars();
199
200 if (wxTheApp && (wxTopLevelWindows.Number() == 0))
201 {
202 wxTheApp->SetTopWindow(NULL);
203
204 if (wxTheApp->GetExitOnFrameDelete())
205 {
206 ::WinPostMsg(NULL, WM_QUIT, 0, 0);
207 }
208 }
209
210 wxModelessWindows.DeleteObject(this);
211
212 //
213 // For some reason, wxWindows can activate another task altogether
214 // when a frame is destroyed after a modal dialog has been invoked.
215 // Try to bring the parent to the top.
216 //
217 // MT:Only do this if this frame is currently the active window, else weird
218 // things start to happen.
219 //
220 if (wxGetActiveWindow() == this)
221 {
222 if (GetParent() && GetParent()->GetHWND())
223 {
224 ::WinSetWindowPos( (HWND) GetParent()->GetHWND()
225 ,HWND_TOP
226 ,0
227 ,0
228 ,0
229 ,0
230 ,SWP_ZORDER
231 );
232 }
233 }
234 } // end of wxFrame::~wxFrame
235
236 //
237 // Get size *available for subwindows* i.e. excluding menu bar, toolbar etc.
238 //
239 void wxFrame::DoGetClientSize(
240 int* pX
241 , int* pY
242 ) const
243 {
244 RECTL vRect;
245 ::WinQueryWindowRect(GetHwnd(), &vRect);
246 if (pX)
247 *pX = vRect.xRight - vRect.xLeft;
248 if (pY)
249 *pY = vRect.yTop - vRect.yBottom;
250 } // end of wxFrame::DoGetClientSize
251
252 //
253 // Set the client size (i.e. leave the calculation of borders etc.
254 // to wxWindows)
255 //
256 void wxFrame::DoSetClientSize(
257 int nWidth
258 , int nHeight
259 )
260 {
261 HWND hWnd = GetHwnd();
262 RECTL vRect;
263 RECTL vRect2;
264
265 ::WinQueryWindowRect(GetHwnd(), &vRect);
266 ::WinQueryWindowRect(GetHwnd(), &vRect2);
267
268 //
269 // Find the difference between the entire window (title bar and all)
270 // and the client area; add this to the new client size to move the
271 // window. Remember OS/2's backwards y coord system!
272 //
273 int nActualWidth = vRect2.xRight - vRect2.xLeft - vRect.xRight + nWidth;
274 int nActualHeight = vRect2.yTop + vRect2.yTop - vRect.yTop + nHeight;
275
276 #if wxUSE_STATUSBAR
277 if ( GetStatusBar() )
278 {
279 int nStatusX;
280 int nStatusY;
281
282 GetStatusBar()->GetClientSize( &nStatusX
283 ,&nStatusY
284 );
285 nActualHeight += nStatusY;
286 }
287 #endif // wxUSE_STATUSBAR
288
289 wxPoint vPoint(GetClientAreaOrigin());
290 nActualWidth += vPoint.y;
291 nActualHeight += vPoint.x;
292
293 POINTL vPointl;
294
295 vPointl.x = vRect2.xLeft;
296 vPointl.y = vRect2.yTop;
297
298 ::WinSetWindowPos( hWnd
299 ,HWND_TOP
300 ,vPointl.x
301 ,vPointl.y
302 ,nActualWidth
303 ,nActualHeight
304 ,SWP_MOVE | SWP_SIZE | SWP_SHOW
305 );
306
307 wxSizeEvent vEvent( wxSize( nWidth
308 ,nHeight
309 )
310 ,m_windowId
311 );
312 vEvent.SetEventObject(this);
313 GetEventHandler()->ProcessEvent(vEvent);
314 } // end of wxFrame::DoSetClientSize
315
316 void wxFrame::DoGetSize(
317 int* pWidth
318 , int* pHeight
319 ) const
320 {
321 RECTL vRect;
322
323 ::WinQueryWindowRect(m_hFrame, &vRect);
324 *pWidth = vRect.xRight - vRect.xLeft;
325 *pHeight = vRect.yTop - vRect.yBottom;
326 } // end of wxFrame::DoGetSize
327
328 void wxFrame::DoGetPosition(
329 int* pX
330 , int* pY
331 ) const
332 {
333 RECTL vRect;
334 POINTL vPoint;
335
336 ::WinQueryWindowRect(m_hFrame, &vRect);
337 vPoint.x = vRect.xLeft;
338
339 //
340 // OS/2 is backwards [WIN32 it is vRect.yTop]
341 //
342 vPoint.y = vRect.yBottom;
343
344 *pX = vPoint.x;
345 *pY = vPoint.y;
346 } // end of wxFrame::DoGetPosition
347
348 // ----------------------------------------------------------------------------
349 // variations around ::ShowWindow()
350 // ----------------------------------------------------------------------------
351
352 void wxFrame::DoShowWindow(
353 int bShowCmd
354 )
355 {
356 ::WinShowWindow(m_hFrame, (BOOL)bShowCmd);
357 m_bIconized = bShowCmd == SWP_MINIMIZE;
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(m_hFrame, &vSwp);
373 m_bIconized = vSwp.fl & SWP_MINIMIZE;
374 ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
375 ::WinEnableWindow(m_hFrame, TRUE);
376 vEvent.SetEventObject(this);
377 GetEventHandler()->ProcessEvent(vEvent);
378 }
379 else
380 {
381 //
382 // Try to highlight the correct window (the parent)
383 //
384 if (GetParent())
385 {
386 HWND hWndParent = GetHwndOf(GetParent());
387
388 ::WinQueryWindowPos(hWndParent, &vSwp);
389 m_bIconized = vSwp.fl & SWP_MINIMIZE;
390 if (hWndParent)
391 ::WinSetWindowPos( hWndParent
392 ,HWND_TOP
393 ,vSwp.x
394 ,vSwp.y
395 ,vSwp.cx
396 ,vSwp.cy
397 ,SWP_ZORDER | SWP_ACTIVATE | SWP_SHOW | SWP_MOVE
398 );
399 ::WinEnableWindow(hWndParent, TRUE);
400 }
401 }
402 return TRUE;
403 } // end of wxFrame::Show
404
405 void wxFrame::Iconize(
406 bool bIconize
407 )
408 {
409 DoShowWindow(bIconize ? SWP_MINIMIZE : SWP_RESTORE);
410 } // end of wxFrame::Iconize
411
412 void wxFrame::Maximize(
413 bool bMaximize)
414 {
415 DoShowWindow(bMaximize ? SWP_MAXIMIZE : SWP_RESTORE);
416 } // end of wxFrame::Maximize
417
418 void wxFrame::Restore()
419 {
420 DoShowWindow(SWP_RESTORE);
421 } // end of wxFrame::Restore
422
423 bool wxFrame::IsIconized() const
424 {
425 SWP vSwp;
426
427 ::WinQueryWindowPos(m_hFrame, &vSwp);
428
429 if (vSwp.fl & SWP_MINIMIZE)
430 ((wxFrame*)this)->m_bIconized = TRUE;
431 else
432 ((wxFrame*)this)->m_bIconized = FALSE;
433 return m_bIconized;
434 } // end of wxFrame::IsIconized
435
436 // Is it maximized?
437 bool wxFrame::IsMaximized() const
438 {
439 SWP vSwp;
440 bool bIconic;
441
442 ::WinQueryWindowPos(m_hFrame, &vSwp);
443 return (vSwp.fl & SWP_MAXIMIZE);
444 } // end of wxFrame::IsMaximized
445
446 void wxFrame::SetIcon(
447 const wxIcon& rIcon
448 )
449 {
450 wxFrameBase::SetIcon(rIcon);
451
452 if ((m_icon.GetHICON()) != NULLHANDLE)
453 {
454 ::WinSendMsg( m_hFrame
455 ,WM_SETICON
456 ,(MPARAM)((HPOINTER)m_icon.GetHICON())
457 ,NULL
458 );
459 ::WinSendMsg( m_hFrame
460 ,WM_UPDATEFRAME
461 ,(MPARAM)FCF_ICON
462 ,(MPARAM)0
463 );
464 }
465 } // end of wxFrame::SetIcon
466
467 #if wxUSE_STATUSBAR
468 wxStatusBar* wxFrame::OnCreateStatusBar(
469 int nNumber
470 , long lulStyle
471 , wxWindowID vId
472 , const wxString& rName
473 )
474 {
475 wxStatusBar* pStatusBar = NULL;
476 SWP vSwp;
477 ERRORID vError;
478 wxString sError;
479
480 pStatusBar = wxFrameBase::OnCreateStatusBar( nNumber
481 ,lulStyle
482 ,vId
483 ,rName
484 );
485
486 if( !pStatusBar )
487 return NULL;
488
489 ::WinSetParent( pStatusBar->GetHWND()
490 ,m_hFrame
491 ,FALSE
492 );
493 ::WinSetOwner( pStatusBar->GetHWND()
494 ,m_hFrame
495 );
496 //
497 // to show statusbar
498 //
499 if(::WinIsWindowShowing(m_hFrame))
500 ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
501
502 return pStatusBar;
503 } // end of wxFrame::OnCreateStatusBar
504
505 void wxFrame::PositionStatusBar()
506 {
507 SWP vSwp;
508 ERRORID vError;
509 wxString sError;
510
511 //
512 // Native status bar positions itself
513 //
514 if (m_frameStatusBar)
515 {
516 int nWidth;
517 int nStatbarWidth;
518 int nStatbarHeight;
519 HWND hWndClient;
520 RECTL vRect;
521 RECTL vFRect;
522
523 ::WinQueryWindowRect(m_hFrame, &vRect);
524 ::WinMapWindowPoints(m_hFrame, HWND_DESKTOP, (PPOINTL)&vRect, 2);
525 vFRect = vRect;
526 ::WinCalcFrameRect(m_hFrame, &vRect, TRUE);
527 nWidth = vRect.xRight - vRect.xLeft;
528
529 m_frameStatusBar->GetSize( &nStatbarWidth
530 ,&nStatbarHeight
531 );
532
533 //
534 // Since we wish the status bar to be directly under the client area,
535 // we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS.
536 //
537 m_frameStatusBar->SetSize( vRect.xLeft - vFRect.xLeft
538 ,vRect.yBottom - vFRect.yBottom
539 ,nWidth
540 ,nStatbarHeight
541 );
542 if (!::WinQueryWindowPos(m_frameStatusBar->GetHWND(), &vSwp))
543 {
544 vError = ::WinGetLastError(vHabmain);
545 sError = wxPMErrorToStr(vError);
546 wxLogError("Error setting parent for StautsBar. Error: %s\n", sError);
547 return;
548 }
549 }
550 } // end of wxFrame::PositionStatusBar
551 #endif // wxUSE_STATUSBAR
552
553 void wxFrame::DetachMenuBar()
554 {
555 if (m_frameMenuBar)
556 {
557 m_frameMenuBar->Detach();
558 m_frameMenuBar = NULL;
559 }
560 } // end of wxFrame::DetachMenuBar
561
562 void wxFrame::SetMenuBar(
563 wxMenuBar* pMenuBar
564 )
565 {
566 ERRORID vError;
567 wxString sError;
568 HWND hTitlebar = NULLHANDLE;
569 HWND hHScroll = NULLHANDLE;
570 HWND hVScroll = NULLHANDLE;
571 HWND hMenuBar = NULLHANDLE;
572 SWP vSwp;
573 SWP vSwpTitlebar;
574 SWP vSwpVScroll;
575 SWP vSwpHScroll;
576 SWP vSwpMenu;
577
578 if (!pMenuBar)
579 {
580 DetachMenuBar();
581
582 //
583 // Actually remove the menu from the frame
584 //
585 m_hMenu = (WXHMENU)0;
586 InternalSetMenuBar();
587 }
588 else // set new non NULL menu bar
589 {
590 m_frameMenuBar = NULL;
591
592 //
593 // Can set a menubar several times.
594 // TODO: how to prevent a memory leak if you have a currently-unattached
595 // menubar? wxWindows assumes that the frame will delete the menu (otherwise
596 // there are problems for MDI).
597 //
598 if (pMenuBar->GetHMenu())
599 {
600 m_hMenu = pMenuBar->GetHMenu();
601 }
602 else
603 {
604 pMenuBar->Detach();
605 m_hMenu = pMenuBar->Create();
606 if (!m_hMenu)
607 return;
608 }
609 InternalSetMenuBar();
610 m_frameMenuBar = pMenuBar;
611 pMenuBar->Attach(this);
612 }
613 } // end of wxFrame::SetMenuBar
614
615 void wxFrame::InternalSetMenuBar()
616 {
617 ERRORID vError;
618 wxString sError;
619 //
620 // Set the parent and owner of the menubar to be the frame
621 //
622 if (!::WinSetParent(m_hMenu, m_hFrame, FALSE))
623 {
624 vError = ::WinGetLastError(vHabmain);
625 sError = wxPMErrorToStr(vError);
626 wxLogError("Error setting parent for submenu. Error: %s\n", sError);
627 }
628
629 if (!::WinSetOwner(m_hMenu, m_hFrame))
630 {
631 vError = ::WinGetLastError(vHabmain);
632 sError = wxPMErrorToStr(vError);
633 wxLogError("Error setting parent for submenu. Error: %s\n", sError);
634 }
635 ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
636 } // end of wxFrame::InternalSetMenuBar
637
638 //
639 // Responds to colour changes, and passes event on to children
640 //
641 void wxFrame::OnSysColourChanged(
642 wxSysColourChangedEvent& rEvent
643 )
644 {
645 SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
646 Refresh();
647
648 #if wxUSE_STATUSBAR
649 if (m_frameStatusBar)
650 {
651 wxSysColourChangedEvent vEvent2;
652
653 vEvent2.SetEventObject(m_frameStatusBar);
654 m_frameStatusBar->GetEventHandler()->ProcessEvent(vEvent2);
655 }
656 #endif //wxUSE_STATUSBAR
657
658 //
659 // Propagate the event to the non-top-level children
660 //
661 wxWindow::OnSysColourChanged(rEvent);
662 } // end of wxFrame::OnSysColourChanged
663
664 // Pass TRUE to show full screen, FALSE to restore.
665 bool wxFrame::ShowFullScreen(
666 bool bShow
667 , long lStyle
668 )
669 {
670 if (bShow)
671 {
672 if (IsFullScreen())
673 return FALSE;
674
675 m_bFsIsShowing = TRUE;
676 m_lFsStyle = lStyle;
677
678 #if wxUSE_TOOLBAR
679 wxToolBar* pTheToolBar = GetToolBar();
680 #endif //wxUSE_TOOLBAR
681
682 #if wxUSE_STATUSBAR
683 wxStatusBar* pTheStatusBar = GetStatusBar();
684 #endif //wxUSE_STATUSBAR
685
686 int nDummyWidth;
687
688 #if wxUSE_TOOLBAR
689 if (pTheToolBar)
690 pTheToolBar->GetSize(&nDummyWidth, &m_nFsToolBarHeight);
691 #endif //wxUSE_TOOLBAR
692
693 #if wxUSE_STATUSBAR
694 if (pTheStatusBar)
695 pTheStatusBar->GetSize(&nDummyWidth, &m_nFsStatusBarHeight);
696 #endif //wxUSE_STATUSBAR
697
698 #if wxUSE_TOOLBAR
699 //
700 // Zap the toolbar, menubar, and statusbar
701 //
702 if ((lStyle & wxFULLSCREEN_NOTOOLBAR) && pTheToolBar)
703 {
704 pTheToolBar->SetSize(-1,0);
705 pTheToolBar->Show(FALSE);
706 }
707 #endif //wxUSE_TOOLBAR
708
709 if (lStyle & wxFULLSCREEN_NOMENUBAR)
710 {
711 ::WinSetParent(m_hMenu, m_hFrame, FALSE);
712 ::WinSetOwner(m_hMenu, m_hFrame);
713 ::WinSendMsg((HWND)m_hFrame, WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
714 }
715
716 #if wxUSE_STATUSBAR
717 //
718 // Save the number of fields in the statusbar
719 //
720 if ((lStyle & wxFULLSCREEN_NOSTATUSBAR) && pTheStatusBar)
721 {
722 m_nFsStatusBarFields = pTheStatusBar->GetFieldsCount();
723 SetStatusBar((wxStatusBar*) NULL);
724 delete pTheStatusBar;
725 }
726 else
727 m_nFsStatusBarFields = 0;
728 #endif //wxUSE_STATUSBAR
729
730 //
731 // Zap the frame borders
732 //
733
734 //
735 // Save the 'normal' window style
736 //
737 m_lFsOldWindowStyle = ::WinQueryWindowULong(m_hFrame, QWL_STYLE);
738
739 //
740 // Save the old position, width & height, maximize state
741 //
742 m_vFsOldSize = GetRect();
743 m_bFsIsMaximized = IsMaximized();
744
745 //
746 // Decide which window style flags to turn off
747 //
748 LONG lNewStyle = m_lFsOldWindowStyle;
749 LONG lOffFlags = 0;
750
751 if (lStyle & wxFULLSCREEN_NOBORDER)
752 lOffFlags |= FCF_BORDER;
753 if (lStyle & wxFULLSCREEN_NOCAPTION)
754 lOffFlags |= (FCF_TASKLIST | FCF_SYSMENU);
755
756 lNewStyle &= (~lOffFlags);
757
758 //
759 // Change our window style to be compatible with full-screen mode
760 //
761 ::WinSetWindowULong((HWND)m_hFrame, QWL_STYLE, (ULONG)lNewStyle);
762
763 //
764 // Resize to the size of the desktop
765 int nWidth;
766 int nHeight;
767
768 RECTL vRect;
769
770 ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
771 nWidth = vRect.xRight - vRect.xLeft;
772 //
773 // Rmember OS/2 is backwards!
774 //
775 nHeight = vRect.yTop - vRect.yBottom;
776
777 SetSize( nWidth
778 ,nHeight
779 );
780
781 //
782 // Now flush the window style cache and actually go full-screen
783 //
784 ::WinSetWindowPos( (HWND) GetParent()->GetHWND()
785 ,HWND_TOP
786 ,0
787 ,0
788 ,nWidth
789 ,nHeight
790 ,SWP_SIZE | SWP_SHOW
791 );
792
793 wxSizeEvent vEvent( wxSize( nWidth
794 ,nHeight
795 )
796 ,GetId()
797 );
798
799 GetEventHandler()->ProcessEvent(vEvent);
800 return TRUE;
801 }
802 else
803 {
804 if (!IsFullScreen())
805 return FALSE;
806
807 m_bFsIsShowing = FALSE;
808
809 #if wxUSE_TOOLBAR
810 wxToolBar* pTheToolBar = GetToolBar();
811
812 //
813 // Restore the toolbar, menubar, and statusbar
814 //
815 if (pTheToolBar && (m_lFsStyle & wxFULLSCREEN_NOTOOLBAR))
816 {
817 pTheToolBar->SetSize(-1, m_nFsToolBarHeight);
818 pTheToolBar->Show(TRUE);
819 }
820 #endif //wxUSE_TOOLBAR
821
822 #if wxUSE_STATUSBAR
823 if ((m_lFsStyle & wxFULLSCREEN_NOSTATUSBAR) && (m_nFsStatusBarFields > 0))
824 {
825 CreateStatusBar(m_nFsStatusBarFields);
826 // PositionStatusBar();
827 }
828 #endif //wxUSE_STATUSBAR
829
830 if ((m_lFsStyle & wxFULLSCREEN_NOMENUBAR) && (m_hMenu != 0))
831 {
832 ::WinSetParent(m_hMenu, m_hFrame, FALSE);
833 ::WinSetOwner(m_hMenu, m_hFrame);
834 ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
835 }
836 Maximize(m_bFsIsMaximized);
837
838 ::WinSetWindowULong( m_hFrame
839 ,QWL_STYLE
840 ,(ULONG)m_lFsOldWindowStyle
841 );
842 ::WinSetWindowPos( (HWND) GetParent()->GetHWND()
843 ,HWND_TOP
844 ,m_vFsOldSize.x
845 ,m_vFsOldSize.y
846 ,m_vFsOldSize.width
847 ,m_vFsOldSize.height
848 ,SWP_SIZE | SWP_SHOW
849 );
850 return TRUE;
851 }
852 } // end of wxFrame::ShowFullScreen
853
854 //
855 // Frame window
856 //
857 bool wxFrame::OS2Create(
858 int nId
859 , wxWindow* pParent
860 , const wxChar* zWclass
861 , wxWindow* pWxWin
862 , const wxChar* zTitle
863 , int nX
864 , int nY
865 , int nWidth
866 , int nHeight
867 , long ulStyle
868 )
869 {
870 ULONG ulCreateFlags = 0L;
871 ULONG ulStyleFlags = 0L;
872 ULONG ulExtraFlags = 0L;
873 FRAMECDATA vFrameCtlData;
874 HWND hParent = NULLHANDLE;
875 HWND hTitlebar = NULLHANDLE;
876 HWND hHScroll = NULLHANDLE;
877 HWND hVScroll = NULLHANDLE;
878 HWND hFrame = NULLHANDLE;
879 HWND hClient = NULLHANDLE;
880 SWP vSwp[10];
881 RECTL vRect[10];
882 USHORT uCtlCount;
883 ERRORID vError;
884 wxString sError;
885
886 m_hDefaultIcon = (WXHICON) (wxSTD_FRAME_ICON ? wxSTD_FRAME_ICON : wxDEFAULT_FRAME_ICON);
887
888 if (pParent)
889 hParent = GetWinHwnd(pParent);
890 else
891 hParent = HWND_DESKTOP;
892
893 if (ulStyle == wxDEFAULT_FRAME_STYLE)
894 ulCreateFlags = FCF_SIZEBORDER | FCF_TITLEBAR | FCF_SYSMENU |
895 FCF_MINMAX | FCF_TASKLIST;
896 else
897 {
898 if ((ulStyle & wxCAPTION) == wxCAPTION)
899 ulCreateFlags = FCF_TASKLIST;
900 else
901 ulCreateFlags = FCF_NOMOVEWITHOWNER;
902
903 if ((ulStyle & wxVSCROLL) == wxVSCROLL)
904 ulCreateFlags |= FCF_VERTSCROLL;
905 if ((ulStyle & wxHSCROLL) == wxHSCROLL)
906 ulCreateFlags |= FCF_HORZSCROLL;
907 if (ulStyle & wxMINIMIZE_BOX)
908 ulCreateFlags |= FCF_MINBUTTON;
909 if (ulStyle & wxMAXIMIZE_BOX)
910 ulCreateFlags |= FCF_MAXBUTTON;
911 if (ulStyle & wxTHICK_FRAME)
912 ulCreateFlags |= FCF_DLGBORDER;
913 if (ulStyle & wxSYSTEM_MENU)
914 ulCreateFlags |= FCF_SYSMENU;
915 if (ulStyle & wxCAPTION)
916 ulCreateFlags |= FCF_TASKLIST;
917 if (ulStyle & wxCLIP_CHILDREN)
918 {
919 // Invalid for frame windows under PM
920 }
921
922 if (ulStyle & wxTINY_CAPTION_VERT)
923 ulCreateFlags |= FCF_TASKLIST;
924 if (ulStyle & wxTINY_CAPTION_HORIZ)
925 ulCreateFlags |= FCF_TASKLIST;
926
927 if ((ulStyle & wxTHICK_FRAME) == 0)
928 ulCreateFlags |= FCF_BORDER;
929 if (ulStyle & wxFRAME_TOOL_WINDOW)
930 ulExtraFlags = kFrameToolWindow;
931
932 if (ulStyle & wxSTAY_ON_TOP)
933 ulCreateFlags |= FCF_SYSMODAL;
934 }
935 if ((ulStyle & wxMINIMIZE) || (ulStyle & wxICONIZE))
936 ulStyleFlags |= WS_MINIMIZED;
937 if (ulStyle & wxMAXIMIZE)
938 ulStyleFlags |= WS_MAXIMIZED;
939
940 //
941 // Clear the visible flag, we always call show
942 //
943 ulStyleFlags &= (unsigned long)~WS_VISIBLE;
944 m_bIconized = FALSE;
945
946 //
947 // Set the frame control block
948 //
949 vFrameCtlData.cb = sizeof(vFrameCtlData);
950 vFrameCtlData.flCreateFlags = ulCreateFlags;
951 vFrameCtlData.hmodResources = 0L;
952 vFrameCtlData.idResources = 0;
953
954 //
955 // Create the frame window: We break ranks with other ports now
956 // and instead of calling down into the base wxWindow class' OS2Create
957 // we do all our own stuff here. We will set the needed pieces
958 // of wxWindow manually, here.
959 //
960
961 hFrame = ::WinCreateStdWindow( hParent
962 ,ulStyleFlags // frame-window style
963 ,&ulCreateFlags // window style
964 ,(PSZ)zWclass // class name
965 ,(PSZ)zTitle // window title
966 ,0L // default client style
967 ,NULLHANDLE // resource in executable file
968 ,0 // resource id
969 ,&hClient // receives client window handle
970 );
971 if (!hFrame)
972 {
973 vError = ::WinGetLastError(vHabmain);
974 sError = wxPMErrorToStr(vError);
975 wxLogError("Error creating frame. Error: %s\n", sError);
976 return FALSE;
977 }
978
979 //
980 // wxWindow class' m_hWnd set here and needed associations
981 //
982 m_hFrame = hFrame;
983 m_hWnd = hClient;
984 wxAssociateWinWithHandle(m_hWnd, this);
985 wxAssociateWinWithHandle(m_hFrame, this);
986
987 m_backgroundColour.Set(wxString("GREY"));
988
989 LONG lColor = (LONG)m_backgroundColour.GetPixel();
990
991 if (!::WinSetPresParam( m_hWnd
992 ,PP_BACKGROUNDCOLOR
993 ,sizeof(LONG)
994 ,(PVOID)&lColor
995 ))
996 {
997 vError = ::WinGetLastError(vHabmain);
998 sError = wxPMErrorToStr(vError);
999 wxLogError("Error creating frame. Error: %s\n", sError);
1000 return FALSE;
1001 }
1002
1003 //
1004 // Now need to subclass window. Instead of calling the SubClassWin in wxWindow
1005 // we manually subclass here because we don't want to use the main wxWndProc
1006 // by default
1007 //
1008 m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(m_hFrame, (PFNWP)wxFrameMainWndProc);
1009
1010 //
1011 // Now size everything. If adding a menu the client will need to be resized.
1012 //
1013
1014 if (!::WinSetWindowPos( m_hFrame
1015 ,HWND_TOP
1016 ,nX
1017 ,nY
1018 ,nWidth
1019 ,nHeight
1020 ,SWP_SIZE | SWP_MOVE | SWP_ACTIVATE | SWP_ZORDER
1021 ))
1022 {
1023 vError = ::WinGetLastError(vHabmain);
1024 sError = wxPMErrorToStr(vError);
1025 wxLogError("Error sizing frame. Error: %s\n", sError);
1026 return FALSE;
1027 }
1028 //
1029 // We may have to be smarter here when variable sized toolbars are added!
1030 //
1031 if (!::WinSetWindowPos( m_hWnd
1032 ,HWND_TOP
1033 ,nX // + 20
1034 ,nY // + 20
1035 ,nWidth // - 60
1036 ,nHeight // - 60
1037 ,SWP_SIZE | SWP_MOVE | SWP_ACTIVATE | SWP_ZORDER
1038 ))
1039 {
1040 vError = ::WinGetLastError(vHabmain);
1041 sError = wxPMErrorToStr(vError);
1042 wxLogError("Error sizing client. Error: %s\n", sError);
1043 return FALSE;
1044 }
1045 return TRUE;
1046 } // end of wxFrame::OS2Create
1047
1048 //
1049 // Default activation behaviour - set the focus for the first child
1050 // subwindow found.
1051 //
1052 void wxFrame::OnActivate(
1053 wxActivateEvent& rEvent
1054 )
1055 {
1056 if ( rEvent.GetActive() )
1057 {
1058 // restore focus to the child which was last focused
1059 wxLogTrace(_T("focus"), _T("wxFrame %08x activated."), m_hWnd);
1060
1061 wxWindow* pParent = m_pWinLastFocused ? m_pWinLastFocused->GetParent()
1062 : NULL;
1063 if (!pParent)
1064 {
1065 pParent = this;
1066 }
1067
1068 wxSetFocusToChild( pParent
1069 ,&m_pWinLastFocused
1070 );
1071 }
1072 else // deactivating
1073 {
1074 //
1075 // Remember the last focused child if it is our child
1076 //
1077 m_pWinLastFocused = FindFocus();
1078
1079 for (wxWindowList::Node* pNode = GetChildren().GetFirst();
1080 pNode;
1081 pNode = pNode->GetNext())
1082 {
1083 // FIXME all this is totally bogus - we need to do the same as wxPanel,
1084 // but how to do it without duplicating the code?
1085
1086 // restore focus
1087 wxWindow* pChild = pNode->GetData();
1088
1089 if (!pChild->IsTopLevel()
1090 #if wxUSE_TOOLBAR
1091 && !wxDynamicCast(pChild, wxToolBar)
1092 #endif // wxUSE_TOOLBAR
1093 #if wxUSE_STATUSBAR
1094 && !wxDynamicCast(pChild, wxStatusBar)
1095 #endif // wxUSE_STATUSBAR
1096 )
1097 {
1098 pChild->SetFocus();
1099 return;
1100 }
1101 }
1102 }
1103 } // end of wxFrame::OnActivate
1104
1105 // ----------------------------------------------------------------------------
1106 // wxFrame size management: we exclude the areas taken by menu/status/toolbars
1107 // from the client area, so the client area is what's really available for the
1108 // frame contents
1109 // ----------------------------------------------------------------------------
1110
1111 // Checks if there is a toolbar, and returns the first free client position
1112 wxPoint wxFrame::GetClientAreaOrigin() const
1113 {
1114 wxPoint vPoint(0, 0);
1115
1116 #if wxUSE_TOOLBAR
1117 if (GetToolBar())
1118 {
1119 int nWidth;
1120 int nHeight;
1121
1122 GetToolBar()->GetSize( &nWidth
1123 ,&nHeight
1124 );
1125
1126 if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
1127 {
1128 vPoint.x += nWidth;
1129 }
1130 else
1131 {
1132 // PM is backwards from windows
1133 vPoint.y += nHeight;
1134 }
1135 }
1136 #endif //wxUSE_TOOLBAR
1137 return vPoint;
1138 } // end of wxFrame::GetClientAreaOrigin
1139
1140 // ----------------------------------------------------------------------------
1141 // tool/status bar stuff
1142 // ----------------------------------------------------------------------------
1143
1144 #if wxUSE_TOOLBAR
1145
1146 wxToolBar* wxFrame::CreateToolBar(
1147 long lStyle
1148 , wxWindowID vId
1149 , const wxString& rName
1150 )
1151 {
1152 if (wxFrameBase::CreateToolBar( lStyle
1153 ,vId
1154 ,rName
1155 ))
1156 {
1157 PositionToolBar();
1158 }
1159 return m_frameToolBar;
1160 } // end of wxFrame::CreateToolBar
1161
1162 void wxFrame::PositionToolBar()
1163 {
1164 HWND hWndClient;
1165 RECTL vRect;
1166
1167 ::WinQueryWindowRect(GetHwnd(), &vRect);
1168
1169 #if wxUSE_STATUSBAR
1170 if (GetStatusBar())
1171 {
1172 int nStatusX;
1173 int nStatusY;
1174
1175 GetStatusBar()->GetClientSize( &nStatusX
1176 ,&nStatusY
1177 );
1178 // PM is backwards from windows
1179 vRect.yBottom += nStatusY;
1180 }
1181 #endif // wxUSE_STATUSBAR
1182
1183 if ( GetToolBar() )
1184 {
1185 int nToolbarWidth;
1186 int nToolbarHeight;
1187
1188 GetToolBar()->GetSize( &nToolbarWidth
1189 ,&nToolbarHeight
1190 );
1191
1192 if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
1193 {
1194 nToolbarHeight = vRect.yBottom;
1195 }
1196 else
1197 {
1198 nToolbarWidth = vRect.xRight;
1199 }
1200
1201 //
1202 // Use the 'real' PM position here
1203 //
1204 GetToolBar()->SetSize( 0
1205 ,0
1206 ,nToolbarWidth
1207 ,nToolbarHeight
1208 ,wxSIZE_NO_ADJUSTMENTS
1209 );
1210 }
1211 } // end of wxFrame::PositionToolBar
1212 #endif // wxUSE_TOOLBAR
1213
1214 // ----------------------------------------------------------------------------
1215 // frame state (iconized/maximized/...)
1216 // ----------------------------------------------------------------------------
1217
1218 //
1219 // propagate our state change to all child frames: this allows us to emulate X
1220 // Windows behaviour where child frames float independently of the parent one
1221 // on the desktop, but are iconized/restored with it
1222 //
1223 void wxFrame::IconizeChildFrames(
1224 bool bIconize
1225 )
1226 {
1227 for (wxWindowList::Node* pNode = GetChildren().GetFirst();
1228 pNode;
1229 pNode = pNode->GetNext() )
1230 {
1231 wxWindow* pWin = pNode->GetData();
1232
1233 if (pWin->IsKindOf(CLASSINFO(wxFrame)) )
1234 {
1235 ((wxFrame *)pWin)->Iconize(bIconize);
1236 }
1237 }
1238 } // end of wxFrame::IconizeChildFrames
1239
1240 // ===========================================================================
1241 // message processing
1242 // ===========================================================================
1243
1244 // ---------------------------------------------------------------------------
1245 // preprocessing
1246 // ---------------------------------------------------------------------------
1247 bool wxFrame::OS2TranslateMessage(
1248 WXMSG* pMsg
1249 )
1250 {
1251 //
1252 // try the menu bar accels
1253 //
1254 wxMenuBar* pMenuBar = GetMenuBar();
1255
1256 if (!pMenuBar )
1257 return FALSE;
1258
1259 #if wxUSE_ACCEL
1260 const wxAcceleratorTable& rAcceleratorTable = pMenuBar->GetAccelTable();
1261 return rAcceleratorTable.Translate(GetHWND(), pMsg);
1262 #else
1263 return FALSE;
1264 #endif //wxUSE_ACCEL
1265 } // end of wxFrame::OS2TranslateMessage
1266
1267 // ---------------------------------------------------------------------------
1268 // our private (non virtual) message handlers
1269 // ---------------------------------------------------------------------------
1270 bool wxFrame::HandlePaint()
1271 {
1272 RECTL vRect;
1273
1274 if (::WinQueryUpdateRect(GetHWND(), &vRect))
1275 {
1276 if (m_bIconized)
1277 {
1278 //
1279 // Icons in PM are the same as "pointers"
1280 //
1281 HPOINTER hIcon;
1282
1283 if (m_icon.Ok())
1284 hIcon = (HPOINTER)::WinSendMsg(m_hFrame, WM_QUERYICON, 0L, 0L);
1285 else
1286 hIcon = (HPOINTER)m_hDefaultIcon;
1287
1288 //
1289 // Hold a pointer to the dc so long as the OnPaint() message
1290 // is being processed
1291 //
1292 RECTL vRect2;
1293 HPS hPs = ::WinBeginPaint(GetHwnd(), NULLHANDLE, &vRect2);
1294
1295 //
1296 // Erase background before painting or we get white background
1297 //
1298 OS2DefWindowProc(WM_ERASEBACKGROUND, (MPARAM)hPs, (MPARAM)&vRect2);
1299
1300 if (hIcon)
1301 {
1302 HWND hWndClient;
1303 RECTL vRect3;
1304
1305 ::WinQueryWindowRect(GetHwnd(), &vRect3);
1306
1307 static const int nIconWidth = 32;
1308 static const int nIconHeight = 32;
1309 int nIconX = (int)((vRect3.xRight - nIconWidth)/2);
1310 int nIconY = (int)((vRect3.yBottom + nIconHeight)/2);
1311
1312 ::WinDrawPointer(hPs, nIconX, nIconY, hIcon, DP_NORMAL);
1313 }
1314 ::WinEndPaint(hPs);
1315 return TRUE;
1316 }
1317 else
1318 {
1319 return(wxWindow::HandlePaint());
1320 }
1321 }
1322 else
1323 {
1324 // nothing to paint - processed
1325 return TRUE;
1326 }
1327 return FALSE;
1328 } // end of wxFrame::HandlePaint
1329
1330 bool wxFrame::HandleSize(
1331 int nX
1332 , int nY
1333 , WXUINT nId
1334 )
1335 {
1336 bool bProcessed = FALSE;
1337
1338 switch (nId)
1339 {
1340 case kSizeNormal:
1341 //
1342 // Only do it it if we were iconized before, otherwise resizing the
1343 // parent frame has a curious side effect of bringing it under it's
1344 // children
1345 if (!m_bIconized )
1346 break;
1347
1348 //
1349 // restore all child frames too
1350 //
1351 IconizeChildFrames(FALSE);
1352
1353 //
1354 // fall through
1355 //
1356
1357 case kSizeMax:
1358 m_bIconized = FALSE;
1359 break;
1360
1361 case kSizeMin:
1362 //
1363 // Iconize all child frames too
1364 //
1365 IconizeChildFrames(TRUE);
1366 m_bIconized = TRUE;
1367 break;
1368 }
1369
1370 if (!m_bIconized)
1371 {
1372 //
1373 // forward WM_SIZE to status bar control
1374 //
1375 #if wxUSE_NATIVE_STATUSBAR
1376 if (m_frameStatusBar && m_frameStatusBar->IsKindOf(CLASSINFO(wxStatusBar95)))
1377 {
1378 wxSizeEvent vEvent( wxSize( nX
1379 ,nY
1380 )
1381 ,m_frameStatusBar->GetId()
1382 );
1383
1384 vEvent.SetEventObject(m_frameStatusBar);
1385 m_frameStatusBar->OnSize(vEvent);
1386 }
1387 #endif // wxUSE_NATIVE_STATUSBAR
1388
1389 PositionStatusBar();
1390 #if wxUSE_TOOLBAR
1391 PositionToolBar();
1392 #endif // wxUSE_TOOLBAR
1393
1394 wxSizeEvent vEvent( wxSize( nX
1395 ,nY
1396 )
1397 ,m_windowId
1398 );
1399
1400 vEvent.SetEventObject(this);
1401 bProcessed = GetEventHandler()->ProcessEvent(vEvent);
1402 }
1403 return bProcessed;
1404 } // end of wxFrame::HandleSize
1405
1406 bool wxFrame::HandleCommand(
1407 WXWORD nId
1408 , WXWORD nCmd
1409 , WXHWND hControl
1410 )
1411 {
1412 if (hControl)
1413 {
1414 //
1415 // In case it's e.g. a toolbar.
1416 //
1417 wxWindow* pWin = wxFindWinFromHandle(hControl);
1418
1419 if (pWin)
1420 return pWin->OS2Command( nCmd
1421 ,nId
1422 );
1423 }
1424
1425 //
1426 // Handle here commands from menus and accelerators
1427 //
1428 if (nCmd == CMDSRC_MENU || nCmd == CMDSRC_ACCELERATOR)
1429 {
1430 if (wxCurrentPopupMenu)
1431 {
1432 wxMenu* pPopupMenu = wxCurrentPopupMenu;
1433
1434 wxCurrentPopupMenu = NULL;
1435
1436 return pPopupMenu->OS2Command( nCmd
1437 ,nId
1438 );
1439 }
1440
1441 if (ProcessCommand(nId))
1442 {
1443 return TRUE;
1444 }
1445 }
1446 return FALSE;
1447 } // end of wxFrame::HandleCommand
1448
1449 bool wxFrame::HandleMenuSelect(
1450 WXWORD nItem
1451 , WXWORD nFlags
1452 , WXHMENU hMenu
1453 )
1454 {
1455 if( !nFlags )
1456 {
1457 MENUITEM mItem;
1458 MRESULT rc;
1459
1460 rc = ::WinSendMsg(hMenu, MM_QUERYITEM, MPFROM2SHORT(nItem, TRUE), (MPARAM)&mItem);
1461
1462 if(rc && !(mItem.afStyle & (MIS_SUBMENU | MIS_SEPARATOR)))
1463 {
1464 wxMenuEvent vEvent(wxEVT_MENU_HIGHLIGHT, nItem);
1465
1466 vEvent.SetEventObject(this);
1467 GetEventHandler()->ProcessEvent(vEvent); // return value would be ignored by PM
1468 }
1469 }
1470 return TRUE;
1471 } // end of wxFrame::HandleMenuSelect
1472
1473 // ---------------------------------------------------------------------------
1474 // Main Frame window proc
1475 // ---------------------------------------------------------------------------
1476 MRESULT EXPENTRY wxFrameMainWndProc(
1477 HWND hWnd
1478 , ULONG ulMsg
1479 , MPARAM wParam
1480 , MPARAM lParam
1481 )
1482 {
1483 MRESULT rc = (MRESULT)0;
1484 bool bProcessed = FALSE;
1485 wxFrame* pWnd = NULL;
1486
1487 pWnd = (wxFrame*) wxFindWinFromHandle((WXHWND) hWnd);
1488 switch (ulMsg)
1489 {
1490 case WM_QUERYFRAMECTLCOUNT:
1491 if(pWnd && pWnd->m_fnOldWndProc)
1492 {
1493 USHORT uItemCount = SHORT1FROMMR(pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam));
1494
1495 rc = MRFROMSHORT(uItemCount);
1496 }
1497 break;
1498
1499 case WM_FORMATFRAME:
1500 /////////////////////////////////////////////////////////////////////////////////
1501 // Applications that subclass frame controls may find that the frame is already
1502 // subclassed the number of frame controls is variable.
1503 // The WM_FORMATFRAME and WM_QUERYFRAMECTLCOUNT messages must always be
1504 // subclassed by calling the previous window procedure and modifying its result.
1505 ////////////////////////////////////////////////////////////////////////////////
1506 {
1507 int nItemCount;
1508 int i;
1509 PSWP pSWP = NULL;
1510 SWP vSwpStb;
1511 RECTL vRectl;
1512 RECTL vRstb;
1513 int nHeight=0;
1514
1515 pSWP = (PSWP)PVOIDFROMMP(wParam);
1516 nItemCount = SHORT1FROMMR(pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam));
1517 if(pWnd->m_frameStatusBar)
1518 {
1519 ::WinQueryWindowRect(pWnd->m_frameStatusBar->GetHWND(), &vRstb);
1520 pWnd->m_frameStatusBar->GetSize(NULL, &nHeight);
1521 ::WinQueryWindowRect(pWnd->m_hFrame, &vRectl);
1522 ::WinMapWindowPoints(pWnd->m_hFrame, HWND_DESKTOP, (PPOINTL)&vRectl, 2);
1523 vRstb = vRectl;
1524 ::WinCalcFrameRect(pWnd->m_hFrame, &vRectl, TRUE);
1525
1526 vSwpStb.x = vRectl.xLeft - vRstb.xLeft;
1527 vSwpStb.y = vRectl.yBottom - vRstb.yBottom;
1528 vSwpStb.cx = vRectl.xRight - vRectl.xLeft - 1; //?? -1 ??
1529 vSwpStb.cy = nHeight;
1530 vSwpStb.fl = SWP_SIZE |SWP_MOVE | SWP_SHOW;
1531 vSwpStb.hwnd = pWnd->m_frameStatusBar->GetHWND();
1532 vSwpStb.hwndInsertBehind = HWND_TOP;
1533 }
1534 ::WinQueryWindowRect(pWnd->m_hFrame, &vRectl);
1535 ::WinMapWindowPoints(pWnd->m_hFrame, HWND_DESKTOP, (PPOINTL)&vRectl, 2);
1536 ::WinCalcFrameRect(pWnd->m_hFrame, &vRectl, TRUE);
1537 ::WinMapWindowPoints(HWND_DESKTOP, pWnd->m_hFrame, (PPOINTL)&vRectl, 2);
1538 for(i = 0; i < nItemCount; i++)
1539 {
1540 if(pWnd->m_hWnd && pSWP[i].hwnd == pWnd->m_hWnd)
1541 {
1542 pSWP[i].x = vRectl.xLeft;
1543 pSWP[i].y = vRectl.yBottom + nHeight;
1544 pSWP[i].cx = vRectl.xRight - vRectl.xLeft;
1545 pSWP[i].cy = vRectl.yTop - vRectl.yBottom - nHeight;
1546 pSWP[i].fl = SWP_SIZE | SWP_MOVE | SWP_SHOW;
1547 pSWP[i].hwndInsertBehind = HWND_TOP;
1548 }
1549 }
1550 bProcessed = TRUE;
1551 rc = MRFROMSHORT(nItemCount);
1552 }
1553 break;
1554
1555 default:
1556 if(pWnd && pWnd->m_fnOldWndProc)
1557 rc = pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam);
1558 else
1559 rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
1560 }
1561 return rc;
1562 } // end of wxFrameMainWndProc
1563
1564 MRESULT EXPENTRY wxFrameWndProc(
1565 HWND hWnd
1566 , ULONG ulMsg
1567 , MPARAM wParam
1568 , MPARAM lParam
1569 )
1570 {
1571 //
1572 // Trace all ulMsgs - useful for the debugging
1573 //
1574 HWND parentHwnd;
1575 wxFrame* pWnd = NULL;
1576
1577 parentHwnd = WinQueryWindow(hWnd,QW_PARENT);
1578 pWnd = (wxFrame*) wxFindWinFromHandle((WXHWND) hWnd);
1579
1580 //
1581 // When we get the first message for the HWND we just created, we associate
1582 // it with wxWindow stored in wxWndHook
1583 //
1584
1585 MRESULT rc = (MRESULT)0;
1586 bool bProcessed = FALSE;
1587
1588 //
1589 // Stop right here if we don't have a valid handle in our wxWindow object.
1590 //
1591 if (pWnd && !pWnd->GetHWND())
1592 {
1593 pWnd->SetHWND((WXHWND) hWnd);
1594 rc = pWnd->OS2DefWindowProc(ulMsg, wParam, lParam );
1595 pWnd->SetHWND(0);
1596 }
1597 else
1598 {
1599 if (pWnd)
1600 rc = pWnd->OS2WindowProc(ulMsg, wParam, lParam);
1601 else
1602 rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
1603 }
1604 return rc;
1605 } // end of wxFrameWndProc
1606
1607 MRESULT wxFrame::OS2WindowProc(
1608 WXUINT uMessage
1609 , WXWPARAM wParam
1610 , WXLPARAM lParam
1611 )
1612 {
1613 MRESULT mRc = 0L;
1614 bool bProcessed = FALSE;
1615
1616 switch (uMessage)
1617 {
1618 case WM_CLOSE:
1619 //
1620 // If we can't close, tell the system that we processed the
1621 // message - otherwise it would close us
1622 //
1623 bProcessed = !Close();
1624 break;
1625
1626 case WM_PAINT:
1627 bProcessed = HandlePaint();
1628 mRc = (MRESULT)FALSE;
1629 break;
1630
1631 case WM_ERASEBACKGROUND:
1632 //
1633 // Returning TRUE to requests PM to paint the window background
1634 // in SYSCLR_WINDOW. We capture this here because the PS returned
1635 // in Frames is the PS for the whole frame, which we can't really
1636 // use at all. If you want to paint a different background, do it
1637 // in an OnPaint using a wxPaintDC.
1638 //
1639 mRc = (MRESULT)(TRUE);
1640 break;
1641
1642 case WM_COMMAND:
1643 {
1644 WORD wId;
1645 WORD wCmd;
1646 WXHWND hWnd;
1647
1648 UnpackCommand( (WXWPARAM)wParam
1649 ,(WXLPARAM)lParam
1650 ,&wId
1651 ,&hWnd
1652 ,&wCmd
1653 );
1654
1655 bProcessed = HandleCommand( wId
1656 ,wCmd
1657 ,(WXHWND)hWnd
1658 );
1659 }
1660 break;
1661
1662 case WM_MENUSELECT:
1663 {
1664 WXWORD wItem;
1665 WXWORD wFlags;
1666 WXHMENU hMenu;
1667
1668 UnpackMenuSelect( wParam
1669 ,lParam
1670 ,&wItem
1671 ,&wFlags
1672 ,&hMenu
1673 );
1674 bProcessed = HandleMenuSelect( wItem
1675 ,wFlags
1676 ,hMenu
1677 );
1678 mRc = (MRESULT)TRUE;
1679 }
1680 break;
1681
1682 case WM_SIZE:
1683 {
1684 SHORT nScxold = SHORT1FROMMP(wParam); // Old horizontal size.
1685 SHORT nScyold = SHORT2FROMMP(wParam); // Old vertical size.
1686 SHORT nScxnew = SHORT1FROMMP(lParam); // New horizontal size.
1687 SHORT nScynew = SHORT2FROMMP(lParam); // New vertical size.
1688
1689 lParam = MRFROM2SHORT( nScxnew - 20
1690 ,nScynew - 30
1691 );
1692 }
1693 bProcessed = HandleSize(LOWORD(lParam), HIWORD(lParam), (WXUINT)wParam);
1694 mRc = (MRESULT)FALSE;
1695 break;
1696
1697 case CM_QUERYDRAGIMAGE:
1698 {
1699 HPOINTER hIcon;
1700
1701 if (m_icon.Ok())
1702 hIcon = (HPOINTER)::WinSendMsg(GetHWND(), WM_QUERYICON, 0L, 0L);
1703 else
1704 hIcon = (HPOINTER)m_hDefaultIcon;
1705 mRc = (MRESULT)hIcon;
1706 bProcessed = mRc != 0;
1707 }
1708 break;
1709 }
1710
1711 if (!bProcessed )
1712 mRc = wxWindow::OS2WindowProc( uMessage
1713 ,wParam
1714 ,lParam
1715 );
1716 return (MRESULT)mRc;
1717 } // wxFrame::OS2WindowProc
1718
1719 void wxFrame::SetClient(WXHWND c_Hwnd)
1720 {
1721 // Duh...nothing to do under OS/2
1722 }
1723
1724 void wxFrame::SetClient(
1725 wxWindow* pWindow
1726 )
1727 {
1728 wxWindow* pOldClient = this->GetClient();
1729 bool bClientHasFocus = pOldClient && (pOldClient == wxWindow::FindFocus());
1730
1731 if(pOldClient == pWindow) // nothing to do
1732 return;
1733 if(pWindow == NULL) // just need to remove old client
1734 {
1735 if(pOldClient == NULL) // nothing to do
1736 return;
1737
1738 if(bClientHasFocus )
1739 this->SetFocus();
1740
1741 pOldClient->Enable( FALSE );
1742 pOldClient->Show( FALSE );
1743 ::WinSetWindowUShort(pOldClient->GetHWND(), QWS_ID, (USHORT)pOldClient->GetId());
1744 // to avoid OS/2 bug need to update frame
1745 ::WinSendMsg((HWND)this->GetFrame(), WM_UPDATEFRAME, (MPARAM)~0, 0);
1746 return;
1747 }
1748
1749 //
1750 // Else need to change client
1751 //
1752 if(bClientHasFocus)
1753 this->SetFocus();
1754
1755 ::WinEnableWindowUpdate((HWND)GetHWND(), FALSE);
1756 if(pOldClient)
1757 {
1758 pOldClient->Enable(FALSE);
1759 pOldClient->Show(FALSE);
1760 ::WinSetWindowUShort(pOldClient->GetHWND(), QWS_ID, (USHORT)pOldClient->GetId());
1761 }
1762 pWindow->Reparent(this);
1763 ::WinSetWindowUShort(pWindow->GetHWND(), QWS_ID, FID_CLIENT);
1764 ::WinEnableWindowUpdate((HWND)GetHWND(), TRUE);
1765 pWindow->Enable();
1766 pWindow->Show(); // ensure client is showing
1767 if( this->IsShown() )
1768 {
1769 this->Show();
1770 ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
1771 }
1772 }
1773
1774 wxWindow* wxFrame::GetClient()
1775 {
1776 return wxFindWinFromHandle((WXHWND)::WinWindowFromID(m_hFrame, FID_CLIENT));
1777 }
wxWidgets (Impactor)