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