]> 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
Update OS/2 Frame WM_PAINT processing
[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 //
988 // Now need to subclass window. Instead of calling the SubClassWin in wxWindow
989 // we manually subclass here because we don't want to use the main wxWndProc
990 // by default
991 //
992 m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(m_hFrame, (PFNWP)wxFrameMainWndProc);
993
994 //
995 // Now size everything. If adding a menu the client will need to be resized.
996 //
997
998 if (!::WinSetWindowPos( m_hFrame
999 ,HWND_TOP
1000 ,nX
1001 ,nY
1002 ,nWidth
1003 ,nHeight
1004 ,SWP_SIZE | SWP_MOVE | SWP_ACTIVATE | SWP_ZORDER
1005 ))
1006 {
1007 vError = ::WinGetLastError(vHabmain);
1008 sError = wxPMErrorToStr(vError);
1009 wxLogError("Error sizing frame. Error: %s\n", sError);
1010 return FALSE;
1011 }
1012 //
1013 // We may have to be smarter here when variable sized toolbars are added!
1014 //
1015 if (!::WinSetWindowPos( m_hWnd
1016 ,HWND_TOP
1017 ,nX + 20
1018 ,nY + 20
1019 ,nWidth - 60
1020 ,nHeight - 60
1021 ,SWP_SIZE | SWP_MOVE | SWP_ACTIVATE | SWP_ZORDER
1022 ))
1023 {
1024 vError = ::WinGetLastError(vHabmain);
1025 sError = wxPMErrorToStr(vError);
1026 wxLogError("Error sizing client. Error: %s\n", sError);
1027 return FALSE;
1028 }
1029
1030 /*
1031 uCtlCount = SHORT1FROMMP(::WinSendMsg(GetHWND(), WM_FORMATFRAME, (MPARAM)vSwp, (MPARAM)vRect));
1032 for (int i = 0; i < uCtlCount; i++)
1033 {
1034 if (vSwp[i].hwnd == GetHWND())
1035 memcpy(&m_vSwp, &vSwp[i], sizeof(SWP));
1036 else if (vSwp[i].hwnd == m_hVScroll)
1037 memcpy(&m_vSwpVScroll, &vSwp[i], sizeof(SWP));
1038 else if (vSwp[i].hwnd == m_hHScroll)
1039 memcpy(&m_vSwpVScroll, &vSwp[i], sizeof(SWP));
1040 else if (vSwp[i].hwnd == m_hTitleBar)
1041 memcpy(&m_vSwpTitleBar, &vSwp[i], sizeof(SWP));
1042 }*/
1043 return TRUE;
1044 } // end of wxFrame::OS2Create
1045
1046 //
1047 // Default activation behaviour - set the focus for the first child
1048 // subwindow found.
1049 //
1050 void wxFrame::OnActivate(
1051 wxActivateEvent& rEvent
1052 )
1053 {
1054 for (wxWindowList::Node* pNode = GetChildren().GetFirst();
1055 pNode;
1056 pNode = pNode->GetNext())
1057 {
1058 // FIXME all this is totally bogus - we need to do the same as wxPanel,
1059 // but how to do it without duplicating the code?
1060
1061 // restore focus
1062 wxWindow* pChild = pNode->GetData();
1063
1064 if (!pChild->IsTopLevel()
1065 #if wxUSE_TOOLBAR
1066 && !wxDynamicCast(pChild, wxToolBar)
1067 #endif // wxUSE_TOOLBAR
1068 #if wxUSE_STATUSBAR
1069 && !wxDynamicCast(pChild, wxStatusBar)
1070 #endif // wxUSE_STATUSBAR
1071 )
1072 {
1073 pChild->SetFocus();
1074 return;
1075 }
1076 }
1077 } // end of wxFrame::OnActivate
1078
1079 // ----------------------------------------------------------------------------
1080 // wxFrame size management: we exclude the areas taken by menu/status/toolbars
1081 // from the client area, so the client area is what's really available for the
1082 // frame contents
1083 // ----------------------------------------------------------------------------
1084
1085 // Checks if there is a toolbar, and returns the first free client position
1086 wxPoint wxFrame::GetClientAreaOrigin() const
1087 {
1088 wxPoint vPoint(0, 0);
1089
1090 #if wxUSE_TOOLBAR
1091 if (GetToolBar())
1092 {
1093 int nWidth;
1094 int nHeight;
1095
1096 GetToolBar()->GetSize( &nWidth
1097 ,&nHeight
1098 );
1099
1100 if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
1101 {
1102 vPoint.x += nWidth;
1103 }
1104 else
1105 {
1106 // PM is backwards from windows
1107 vPoint.y += nHeight;
1108 }
1109 }
1110 #endif //wxUSE_TOOLBAR
1111 return vPoint;
1112 } // end of wxFrame::GetClientAreaOrigin
1113
1114 // ----------------------------------------------------------------------------
1115 // tool/status bar stuff
1116 // ----------------------------------------------------------------------------
1117
1118 #if wxUSE_TOOLBAR
1119
1120 wxToolBar* wxFrame::CreateToolBar(
1121 long lStyle
1122 , wxWindowID vId
1123 , const wxString& rName
1124 )
1125 {
1126 if (wxFrameBase::CreateToolBar( lStyle
1127 ,vId
1128 ,rName
1129 ))
1130 {
1131 PositionToolBar();
1132 }
1133 return m_frameToolBar;
1134 } // end of wxFrame::CreateToolBar
1135
1136 void wxFrame::PositionToolBar()
1137 {
1138 HWND hWndClient;
1139 RECTL vRect;
1140
1141 ::WinQueryWindowRect(GetHwnd(), &vRect);
1142
1143 #if wxUSE_STATUSBAR
1144 if (GetStatusBar())
1145 {
1146 int nStatusX;
1147 int nStatusY;
1148
1149 GetStatusBar()->GetClientSize( &nStatusX
1150 ,&nStatusY
1151 );
1152 // PM is backwards from windows
1153 vRect.yBottom += nStatusY;
1154 }
1155 #endif // wxUSE_STATUSBAR
1156
1157 if ( GetToolBar() )
1158 {
1159 int nToolbarWidth;
1160 int nToolbarHeight;
1161
1162 GetToolBar()->GetSize( &nToolbarWidth
1163 ,&nToolbarHeight
1164 );
1165
1166 if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
1167 {
1168 nToolbarHeight = vRect.yBottom;
1169 }
1170 else
1171 {
1172 nToolbarWidth = vRect.xRight;
1173 }
1174
1175 //
1176 // Use the 'real' PM position here
1177 //
1178 GetToolBar()->SetSize( 0
1179 ,0
1180 ,nToolbarWidth
1181 ,nToolbarHeight
1182 ,wxSIZE_NO_ADJUSTMENTS
1183 );
1184 }
1185 } // end of wxFrame::PositionToolBar
1186 #endif // wxUSE_TOOLBAR
1187
1188 // ----------------------------------------------------------------------------
1189 // frame state (iconized/maximized/...)
1190 // ----------------------------------------------------------------------------
1191
1192 //
1193 // propagate our state change to all child frames: this allows us to emulate X
1194 // Windows behaviour where child frames float independently of the parent one
1195 // on the desktop, but are iconized/restored with it
1196 //
1197 void wxFrame::IconizeChildFrames(
1198 bool bIconize
1199 )
1200 {
1201 for (wxWindowList::Node* pNode = GetChildren().GetFirst();
1202 pNode;
1203 pNode = pNode->GetNext() )
1204 {
1205 wxWindow* pWin = pNode->GetData();
1206
1207 if (pWin->IsKindOf(CLASSINFO(wxFrame)) )
1208 {
1209 ((wxFrame *)pWin)->Iconize(bIconize);
1210 }
1211 }
1212 } // end of wxFrame::IconizeChildFrames
1213
1214 // ===========================================================================
1215 // message processing
1216 // ===========================================================================
1217
1218 // ---------------------------------------------------------------------------
1219 // preprocessing
1220 // ---------------------------------------------------------------------------
1221 bool wxFrame::OS2TranslateMessage(
1222 WXMSG* pMsg
1223 )
1224 {
1225 //
1226 // try the menu bar accels
1227 //
1228 wxMenuBar* pMenuBar = GetMenuBar();
1229
1230 if (!pMenuBar )
1231 return FALSE;
1232
1233 #if wxUSE_ACCEL
1234 const wxAcceleratorTable& rAcceleratorTable = pMenuBar->GetAccelTable();
1235 return rAcceleratorTable.Translate(GetHWND(), pMsg);
1236 #else
1237 return FALSE;
1238 #endif //wxUSE_ACCEL
1239 } // end of wxFrame::OS2TranslateMessage
1240
1241 // ---------------------------------------------------------------------------
1242 // our private (non virtual) message handlers
1243 // ---------------------------------------------------------------------------
1244 bool wxFrame::HandlePaint()
1245 {
1246 RECTL vRect;
1247
1248 if (::WinQueryUpdateRect(GetHWND(), &vRect))
1249 {
1250 if (m_bIconized)
1251 {
1252 //
1253 // Icons in PM are the same as "pointers"
1254 //
1255 HPOINTER hIcon;
1256
1257 if (m_icon.Ok())
1258 hIcon = (HPOINTER)::WinSendMsg(m_hFrame, WM_QUERYICON, 0L, 0L);
1259 else
1260 hIcon = (HPOINTER)m_hDefaultIcon;
1261
1262 //
1263 // Hold a pointer to the dc so long as the OnPaint() message
1264 // is being processed
1265 //
1266 RECTL vRect2;
1267 HPS hPs = ::WinBeginPaint(GetHwnd(), NULLHANDLE, &vRect2);
1268
1269 //
1270 // Erase background before painting or we get white background
1271 //
1272 OS2DefWindowProc(WM_ERASEBACKGROUND, (MPARAM)hPs, (MPARAM)&vRect2);
1273
1274 if (hIcon)
1275 {
1276 HWND hWndClient;
1277 RECTL vRect3;
1278
1279 ::WinQueryWindowRect(GetHwnd(), &vRect3);
1280
1281 static const int nIconWidth = 32;
1282 static const int nIconHeight = 32;
1283 int nIconX = (int)((vRect3.xRight - nIconWidth)/2);
1284 int nIconY = (int)((vRect3.yBottom + nIconHeight)/2);
1285
1286 ::WinDrawPointer(hPs, nIconX, nIconY, hIcon, DP_NORMAL);
1287 }
1288 ::WinEndPaint(hPs);
1289 return TRUE;
1290 }
1291 else
1292 {
1293 return wxWindow::HandlePaint();
1294 }
1295 }
1296 else
1297 {
1298 // nothing to paint - processed
1299 return TRUE;
1300 }
1301 return FALSE;
1302 } // end of wxFrame::HandlePaint
1303
1304 bool wxFrame::HandleSize(
1305 int nX
1306 , int nY
1307 , WXUINT nId
1308 )
1309 {
1310 bool bProcessed = FALSE;
1311
1312 switch (nId)
1313 {
1314 case kSizeNormal:
1315 //
1316 // Only do it it if we were iconized before, otherwise resizing the
1317 // parent frame has a curious side effect of bringing it under it's
1318 // children
1319 if (!m_bIconized )
1320 break;
1321
1322 //
1323 // restore all child frames too
1324 //
1325 IconizeChildFrames(FALSE);
1326
1327 //
1328 // fall through
1329 //
1330
1331 case kSizeMax:
1332 m_bIconized = FALSE;
1333 break;
1334
1335 case kSizeMin:
1336 //
1337 // Iconize all child frames too
1338 //
1339 IconizeChildFrames(TRUE);
1340 m_bIconized = TRUE;
1341 break;
1342 }
1343
1344 if (!m_bIconized)
1345 {
1346 //
1347 // forward WM_SIZE to status bar control
1348 //
1349 #if wxUSE_NATIVE_STATUSBAR
1350 if (m_frameStatusBar && m_frameStatusBar->IsKindOf(CLASSINFO(wxStatusBar95)))
1351 {
1352 wxSizeEvent vEvent( wxSize( nX
1353 ,nY
1354 )
1355 ,m_frameStatusBar->GetId()
1356 );
1357
1358 vEvent.SetEventObject(m_frameStatusBar);
1359 m_frameStatusBar->OnSize(vEvent);
1360 }
1361 #endif // wxUSE_NATIVE_STATUSBAR
1362
1363 PositionStatusBar();
1364 #if wxUSE_TOOLBAR
1365 PositionToolBar();
1366 #endif // wxUSE_TOOLBAR
1367
1368 wxSizeEvent vEvent( wxSize( nX
1369 ,nY
1370 )
1371 ,m_windowId
1372 );
1373
1374 vEvent.SetEventObject(this);
1375 bProcessed = GetEventHandler()->ProcessEvent(vEvent);
1376 }
1377 return bProcessed;
1378 } // end of wxFrame::HandleSize
1379
1380 bool wxFrame::HandleCommand(
1381 WXWORD nId
1382 , WXWORD nCmd
1383 , WXHWND hControl
1384 )
1385 {
1386 if (hControl)
1387 {
1388 //
1389 // In case it's e.g. a toolbar.
1390 //
1391 wxWindow* pWin = wxFindWinFromHandle(hControl);
1392
1393 if (pWin)
1394 return pWin->OS2Command( nCmd
1395 ,nId
1396 );
1397 }
1398
1399 //
1400 // Handle here commands from menus and accelerators
1401 //
1402 if (nCmd == CMDSRC_MENU || nCmd == CMDSRC_ACCELERATOR)
1403 {
1404 if (wxCurrentPopupMenu)
1405 {
1406 wxMenu* pPopupMenu = wxCurrentPopupMenu;
1407
1408 wxCurrentPopupMenu = NULL;
1409
1410 return pPopupMenu->OS2Command( nCmd
1411 ,nId
1412 );
1413 }
1414
1415 if (ProcessCommand(nId))
1416 {
1417 return TRUE;
1418 }
1419 }
1420 return FALSE;
1421 } // end of wxFrame::HandleCommand
1422
1423 bool wxFrame::HandleMenuSelect(
1424 WXWORD nItem
1425 , WXWORD nFlags
1426 , WXHMENU hMenu
1427 )
1428 {
1429 if( !nFlags )
1430 {
1431 MENUITEM mItem;
1432 MRESULT rc;
1433
1434 rc = ::WinSendMsg(hMenu, MM_QUERYITEM, MPFROM2SHORT(nItem, TRUE), (MPARAM)&mItem);
1435
1436 if(rc && !(mItem.afStyle & (MIS_SUBMENU | MIS_SEPARATOR)))
1437 {
1438 wxMenuEvent vEvent(wxEVT_MENU_HIGHLIGHT, nItem);
1439
1440 vEvent.SetEventObject(this);
1441 GetEventHandler()->ProcessEvent(vEvent); // return value would be ignored by PM
1442 }
1443 }
1444 return TRUE;
1445 } // end of wxFrame::HandleMenuSelect
1446
1447 // ---------------------------------------------------------------------------
1448 // Main Frame window proc
1449 // ---------------------------------------------------------------------------
1450 MRESULT EXPENTRY wxFrameMainWndProc(
1451 HWND hWnd
1452 , ULONG ulMsg
1453 , MPARAM wParam
1454 , MPARAM lParam
1455 )
1456 {
1457 MRESULT rc = (MRESULT)0;
1458 bool bProcessed = FALSE;
1459 wxFrame* pWnd = NULL;
1460
1461 pWnd = (wxFrame*) wxFindWinFromHandle((WXHWND) hWnd);
1462 switch (ulMsg)
1463 {
1464 case WM_QUERYFRAMECTLCOUNT:
1465 if(pWnd && pWnd->m_fnOldWndProc)
1466 {
1467 USHORT uItemCount = SHORT1FROMMR(pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam));
1468
1469 rc = MRFROMSHORT(uItemCount);
1470 }
1471 break;
1472
1473 case WM_FORMATFRAME:
1474 /////////////////////////////////////////////////////////////////////////////////
1475 // Applications that subclass frame controls may find that the frame is already
1476 // subclassed the number of frame controls is variable.
1477 // The WM_FORMATFRAME and WM_QUERYFRAMECTLCOUNT messages must always be
1478 // subclassed by calling the previous window procedure and modifying its result.
1479 ////////////////////////////////////////////////////////////////////////////////
1480 {
1481 int nItemCount;
1482 int i;
1483 PSWP pSWP = NULL;
1484 SWP vSwpStb;
1485 RECTL vRectl;
1486 RECTL vRstb;
1487 int nHeight=0;
1488
1489 pSWP = (PSWP)PVOIDFROMMP(wParam);
1490 nItemCount = SHORT1FROMMR(pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam));
1491 if(pWnd->m_frameStatusBar)
1492 {
1493 ::WinQueryWindowRect(pWnd->m_frameStatusBar->GetHWND(), &vRstb);
1494 pWnd->m_frameStatusBar->GetSize(NULL, &nHeight);
1495 ::WinQueryWindowRect(pWnd->m_hFrame, &vRectl);
1496 ::WinMapWindowPoints(pWnd->m_hFrame, HWND_DESKTOP, (PPOINTL)&vRectl, 2);
1497 vRstb = vRectl;
1498 ::WinCalcFrameRect(pWnd->m_hFrame, &vRectl, TRUE);
1499
1500 vSwpStb.x = vRectl.xLeft - vRstb.xLeft;
1501 vSwpStb.y = vRectl.yBottom - vRstb.yBottom;
1502 vSwpStb.cx = vRectl.xRight - vRectl.xLeft - 1; //?? -1 ??
1503 vSwpStb.cy = nHeight;
1504 vSwpStb.fl = SWP_SIZE |SWP_MOVE | SWP_SHOW;
1505 vSwpStb.hwnd = pWnd->m_frameStatusBar->GetHWND();
1506 vSwpStb.hwndInsertBehind = HWND_TOP;
1507 }
1508 ::WinQueryWindowRect(pWnd->m_hFrame, &vRectl);
1509 ::WinMapWindowPoints(pWnd->m_hFrame, HWND_DESKTOP, (PPOINTL)&vRectl, 2);
1510 ::WinCalcFrameRect(pWnd->m_hFrame, &vRectl, TRUE);
1511 ::WinMapWindowPoints(HWND_DESKTOP, pWnd->m_hFrame, (PPOINTL)&vRectl, 2);
1512 for(i = 0; i < nItemCount; i++)
1513 {
1514 if(pWnd->m_hWnd && pSWP[i].hwnd == pWnd->m_hWnd)
1515 {
1516 pSWP[i].x = vRectl.xLeft;
1517 pSWP[i].y = vRectl.yBottom + nHeight;
1518 pSWP[i].cx = vRectl.xRight - vRectl.xLeft;
1519 pSWP[i].cy = vRectl.yTop - vRectl.yBottom - nHeight;
1520 pSWP[i].fl = SWP_SIZE | SWP_MOVE | SWP_SHOW;
1521 pSWP[i].hwndInsertBehind = HWND_TOP;
1522 }
1523 }
1524 bProcessed = TRUE;
1525 rc = MRFROMSHORT(nItemCount);
1526 }
1527 break;
1528
1529 default:
1530 if(pWnd && pWnd->m_fnOldWndProc)
1531 rc = pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam);
1532 else
1533 rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
1534 }
1535 return rc;
1536 } // end of wxFrameMainWndProc
1537
1538 MRESULT EXPENTRY wxFrameWndProc(
1539 HWND hWnd
1540 , ULONG ulMsg
1541 , MPARAM wParam
1542 , MPARAM lParam
1543 )
1544 {
1545 //
1546 // Trace all ulMsgs - useful for the debugging
1547 //
1548 HWND parentHwnd;
1549 wxFrame* pWnd = NULL;
1550
1551 parentHwnd = WinQueryWindow(hWnd,QW_PARENT);
1552 pWnd = (wxFrame*) wxFindWinFromHandle((WXHWND) hWnd);
1553
1554 //
1555 // When we get the first message for the HWND we just created, we associate
1556 // it with wxWindow stored in wxWndHook
1557 //
1558
1559 MRESULT rc = (MRESULT)0;
1560 bool bProcessed = FALSE;
1561
1562 //
1563 // Stop right here if we don't have a valid handle in our wxWindow object.
1564 //
1565 if (pWnd && !pWnd->GetHWND())
1566 {
1567 pWnd->SetHWND((WXHWND) hWnd);
1568 rc = pWnd->OS2DefWindowProc(ulMsg, wParam, lParam );
1569 pWnd->SetHWND(0);
1570 }
1571 else
1572 {
1573 if (pWnd)
1574 rc = pWnd->OS2WindowProc(ulMsg, wParam, lParam);
1575 else
1576 rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
1577 }
1578 return rc;
1579 } // end of wxFrameWndProc
1580
1581 MRESULT wxFrame::OS2WindowProc(
1582 WXUINT uMessage
1583 , WXWPARAM wParam
1584 , WXLPARAM lParam
1585 )
1586 {
1587 MRESULT mRc = 0L;
1588 bool bProcessed = FALSE;
1589
1590 switch (uMessage)
1591 {
1592 case WM_CLOSE:
1593 //
1594 // If we can't close, tell the system that we processed the
1595 // message - otherwise it would close us
1596 //
1597 bProcessed = !Close();
1598 break;
1599
1600 case WM_PAINT:
1601 {
1602 HPS hPS;
1603 RECTL vRect;
1604 wxPaintEvent vEvent;
1605
1606 hPS = WinBeginPaint(m_hWnd, 0L, &vRect);
1607 ::WinFillRect(hPS, &vRect, CLR_BLUE /* SYSCLR_WINDOW */);
1608 ::WinEndPaint(hPS);
1609
1610 mRc = (MRESULT)FALSE;
1611 vEvent.SetEventObject(this);
1612 GetEventHandler()->ProcessEvent(vEvent);
1613 bProcessed = TRUE;
1614 }
1615 break;
1616
1617 case WM_COMMAND:
1618 {
1619 WORD wId;
1620 WORD wCmd;
1621 WXHWND hWnd;
1622
1623 UnpackCommand( (WXWPARAM)wParam
1624 ,(WXLPARAM)lParam
1625 ,&wId
1626 ,&hWnd
1627 ,&wCmd
1628 );
1629
1630 bProcessed = HandleCommand( wId
1631 ,wCmd
1632 ,(WXHWND)hWnd
1633 );
1634 }
1635 break;
1636
1637 case WM_MENUSELECT:
1638 {
1639 WXWORD wItem;
1640 WXWORD wFlags;
1641 WXHMENU hMenu;
1642
1643 UnpackMenuSelect( wParam
1644 ,lParam
1645 ,&wItem
1646 ,&wFlags
1647 ,&hMenu
1648 );
1649 bProcessed = HandleMenuSelect( wItem
1650 ,wFlags
1651 ,hMenu
1652 );
1653 mRc = (MRESULT)TRUE;
1654 }
1655 break;
1656
1657 case WM_SIZE:
1658 {
1659 SHORT nScxold = SHORT1FROMMP(wParam); // Old horizontal size.
1660 SHORT nScyold = SHORT2FROMMP(wParam); // Old vertical size.
1661 SHORT nScxnew = SHORT1FROMMP(lParam); // New horizontal size.
1662 SHORT nScynew = SHORT2FROMMP(lParam); // New vertical size.
1663
1664 lParam = MRFROM2SHORT( nScxnew - 20
1665 ,nScynew - 30
1666 );
1667 }
1668 bProcessed = HandleSize(LOWORD(lParam), HIWORD(lParam), (WXUINT)wParam);
1669 mRc = (MRESULT)FALSE;
1670 break;
1671
1672 case WM_ERASEBACKGROUND:
1673 //
1674 // Return TRUE to request PM to paint the window background
1675 // in SYSCLR_WINDOW.
1676 //
1677 bProcessed = TRUE;
1678 mRc = (MRESULT)(TRUE);
1679 break;
1680
1681 case CM_QUERYDRAGIMAGE:
1682 {
1683 HPOINTER hIcon;
1684
1685 if (m_icon.Ok())
1686 hIcon = (HPOINTER)::WinSendMsg(GetHWND(), WM_QUERYICON, 0L, 0L);
1687 else
1688 hIcon = (HPOINTER)m_hDefaultIcon;
1689 mRc = (MRESULT)hIcon;
1690 bProcessed = mRc != 0;
1691 }
1692 break;
1693 }
1694
1695 if (!bProcessed )
1696 mRc = wxWindow::OS2WindowProc( uMessage
1697 ,wParam
1698 ,lParam
1699 );
1700 return (MRESULT)mRc;
1701 } // wxFrame::OS2WindowProc
1702
1703 void wxFrame::SetClient(WXHWND c_Hwnd)
1704 {
1705 // Duh...nothing to do under OS/2
1706 }
1707
1708 void wxFrame::SetClient(
1709 wxWindow* pWindow
1710 )
1711 {
1712 wxWindow* pOldClient = this->GetClient();
1713 bool bClientHasFocus = pOldClient && (pOldClient == wxWindow::FindFocus());
1714
1715 if(pOldClient == pWindow) // nothing to do
1716 return;
1717 if(pWindow == NULL) // just need to remove old client
1718 {
1719 if(pOldClient == NULL) // nothing to do
1720 return;
1721
1722 if(bClientHasFocus )
1723 this->SetFocus();
1724
1725 pOldClient->Enable( FALSE );
1726 pOldClient->Show( FALSE );
1727 ::WinSetWindowUShort(pOldClient->GetHWND(), QWS_ID, (USHORT)pOldClient->GetId());
1728 // to avoid OS/2 bug need to update frame
1729 ::WinSendMsg((HWND)this->GetFrame(), WM_UPDATEFRAME, (MPARAM)~0, 0);
1730 return;
1731 }
1732
1733 //
1734 // Else need to change client
1735 //
1736 if(bClientHasFocus)
1737 this->SetFocus();
1738
1739 ::WinEnableWindowUpdate((HWND)GetHWND(), FALSE);
1740 if(pOldClient)
1741 {
1742 pOldClient->Enable(FALSE);
1743 pOldClient->Show(FALSE);
1744 ::WinSetWindowUShort(pOldClient->GetHWND(), QWS_ID, (USHORT)pOldClient->GetId());
1745 }
1746 pWindow->Reparent(this);
1747 ::WinSetWindowUShort(pWindow->GetHWND(), QWS_ID, FID_CLIENT);
1748 ::WinEnableWindowUpdate((HWND)GetHWND(), TRUE);
1749 pWindow->Enable();
1750 pWindow->Show(); // ensure client is showing
1751 if( this->IsShown() )
1752 {
1753 this->Show();
1754 ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
1755 }
1756 }
1757
1758 wxWindow* wxFrame::GetClient()
1759 {
1760 return wxFindWinFromHandle((WXHWND)::WinWindowFromID(m_hFrame, FID_CLIENT));
1761 }
wxWidgets (Impactor)