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