]> git.saurik.com Git - wxWidgets.git/blob - src/os2/toplevel.cpp
projects / wxWidgets.git / blob
? search:


b60548850154fe81e5ad1e2a7275b766037d91d3
[wxWidgets.git] / src / os2 / toplevel.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/os2/toplevel.cpp
3 // Purpose: implements wxTopLevelWindow for OS/2
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 30.12.01
7 // RCS-ID: $Id$
8 // Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #include "wx/toplevel.h"
28
29 #ifndef WX_PRECOMP
30 #include "wx/app.h"
31 #include "wx/dialog.h"
32 #include "wx/string.h"
33 #include "wx/log.h"
34 #include "wx/intl.h"
35 #include "wx/frame.h"
36 #include "wx/control.h"
37 #include "wx/containr.h" // wxSetFocusToChild()
38 #include "wx/settings.h"
39 #include "wx/module.h" // wxSetFocusToChild()
40 #endif //WX_PRECOMP
41
42 #include "wx/os2/private.h"
43
44 // ----------------------------------------------------------------------------
45 // stubs for missing functions under MicroWindows
46 // ----------------------------------------------------------------------------
47
48
49 // ----------------------------------------------------------------------------
50 // globals
51 // ----------------------------------------------------------------------------
52
53 // the name of the default wxWidgets class
54 extern void wxAssociateWinWithHandle( HWND hWnd, wxWindowOS2* pWin );
55
56 bool wxTopLevelWindowOS2::m_sbInitialized = false;
57 wxWindow* wxTopLevelWindowOS2::m_spHiddenParent = NULL;
58
59 // ============================================================================
60 // wxTopLevelWindowOS2 implementation
61 // ============================================================================
62
63 BEGIN_EVENT_TABLE(wxTopLevelWindowOS2, wxTopLevelWindowBase)
64 EVT_ACTIVATE(wxTopLevelWindowOS2::OnActivate)
65 END_EVENT_TABLE()
66
67 // ============================================================================
68 // wxTopLevelWindowMSW implementation
69 // ============================================================================
70
71 // Dialog window proc
72 MRESULT EXPENTRY wxDlgProc( HWND WXUNUSED(hWnd)
73 ,UINT uMessage
74 ,void * WXUNUSED(wParam)
75 ,void * WXUNUSED(lParam)
76 )
77 {
78 switch(uMessage)
79 {
80 case WM_INITDLG:
81 //
82 // For this message, returning TRUE tells system to set focus to
83 // the first control in the dialog box, but we set the focus
84 // ourselves, however in OS/2 we must return true to enable the dialog
85 //
86 return (MRESULT)TRUE;
87 default:
88 //
89 // For all the other ones, FALSE means that we didn't process the
90 // message
91 //
92 return (MRESULT)FALSE;
93 }
94 } // end of wxDlgProc
95
96 // ----------------------------------------------------------------------------
97 // wxTLWHiddenParentModule: used to manage the hidden parent window (we need a
98 // module to ensure that the window is always deleted)
99 // ----------------------------------------------------------------------------
100
101 class wxTLWHiddenParentModule : public wxModule
102 {
103 public:
104 //
105 // Module init/finalize
106 //
107 virtual bool OnInit(void);
108 virtual void OnExit(void);
109
110 //
111 // Get the hidden window (creates on demand)
112 //
113 static HWND GetHWND(void);
114
115 private:
116 //
117 // The HWND of the hidden parent
118 //
119 static HWND m_shWnd;
120
121 //
122 // The class used to create it
123 //
124 static const wxChar* m_szClassName;
125 DECLARE_DYNAMIC_CLASS(wxTLWHiddenParentModule)
126 }; // end of CLASS wxTLWHiddenParentModule
127
128 IMPLEMENT_DYNAMIC_CLASS(wxTLWHiddenParentModule, wxModule)
129
130 // ----------------------------------------------------------------------------
131 // wxTopLevelWindowOS2 creation
132 // ----------------------------------------------------------------------------
133
134 void wxTopLevelWindowOS2::Init()
135 {
136 m_bIconized = m_bMaximizeOnShow = false;
137
138 //
139 // Unlike (almost?) all other windows, frames are created hidden
140 //
141 m_isShown = false;
142
143 //
144 // Data to save/restore when calling ShowFullScreen
145 m_lFsStyle = 0;
146 m_lFsOldWindowStyle = 0;
147 m_bFsIsMaximized = false;
148 m_bFsIsShowing = false;
149
150 m_hFrame = NULLHANDLE;
151 memset(&m_vSwp, 0, sizeof(SWP));
152 memset(&m_vSwpClient, 0, sizeof(SWP));
153 m_pWinLastFocused = NULL;
154 } // end of wxTopLevelWindowIOS2::Init
155
156 void wxTopLevelWindowOS2::OnActivate(
157 wxActivateEvent& rEvent
158 )
159 {
160 if (rEvent.GetActive())
161 {
162 //
163 // Restore focus to the child which was last focused
164 //
165 wxLogTrace(wxT("focus"), wxT("wxTLW %08lx activated."), m_hWnd);
166
167 wxWindow* pParent = m_pWinLastFocused ? m_pWinLastFocused->GetParent()
168 : NULL;
169 if (!pParent)
170 {
171 pParent = this;
172 }
173
174 wxSetFocusToChild( pParent
175 ,&m_pWinLastFocused
176 );
177 }
178 else // deactivating
179 {
180 //
181 // Remember the last focused child if it is our child
182 //
183 m_pWinLastFocused = FindFocus();
184
185 //
186 // So we NULL it out if it's a child from some other frame
187 //
188 wxWindow* pWin = m_pWinLastFocused;
189
190 while (pWin)
191 {
192 if (pWin->IsTopLevel())
193 {
194 if (pWin != this)
195 {
196 m_pWinLastFocused = NULL;
197 }
198 break;
199 }
200 pWin = pWin->GetParent();
201 }
202
203 wxLogTrace(wxT("focus"),
204 wxT("wxTLW %08lx deactivated, last focused: %08lx."),
205 m_hWnd,
206 m_pWinLastFocused ? GetHwndOf(m_pWinLastFocused)
207 : NULL);
208 rEvent.Skip();
209 }
210 } // end of wxTopLevelWindowOS2::OnActivate
211
212 WXDWORD wxTopLevelWindowOS2::OS2GetStyle(
213 long lStyle
214 , WXDWORD* pdwExflags
215 ) const
216 {
217 long lMsflags = wxWindow::OS2GetStyle( (lStyle & ~wxBORDER_MASK) | wxBORDER_NONE
218 ,pdwExflags
219 );
220
221 if ((lStyle & wxDEFAULT_FRAME_STYLE) == wxDEFAULT_FRAME_STYLE)
222 lMsflags |= FCF_SIZEBORDER | FCF_TITLEBAR | FCF_SYSMENU |
223 FCF_MINMAX | FCF_TASKLIST;
224
225 if ((lStyle & wxCAPTION) == wxCAPTION)
226 lMsflags |= FCF_TASKLIST;
227 else
228 lMsflags |= FCF_NOMOVEWITHOWNER;
229
230 if ((lStyle & wxVSCROLL) == wxVSCROLL)
231 lMsflags |= FCF_VERTSCROLL;
232 if ((lStyle & wxHSCROLL) == wxHSCROLL)
233 lMsflags |= FCF_HORZSCROLL;
234 if (lStyle & wxMINIMIZE_BOX)
235 lMsflags |= FCF_MINBUTTON;
236 if (lStyle & wxMAXIMIZE_BOX)
237 lMsflags |= FCF_MAXBUTTON;
238 if (lStyle & wxRESIZE_BORDER)
239 lMsflags |= FCF_DLGBORDER;
240 if (lStyle & wxSYSTEM_MENU)
241 lMsflags |= FCF_SYSMENU;
242 if (lStyle & wxCAPTION)
243 lMsflags |= FCF_TASKLIST;
244 if (lStyle & wxCLIP_CHILDREN)
245 {
246 // Invalid for frame windows under PM
247 }
248
249 if (lStyle & wxTINY_CAPTION)
250 lMsflags |= FCF_TASKLIST;
251
252 if ((lStyle & wxRESIZE_BORDER) == 0)
253 lMsflags |= FCF_BORDER;
254 if (lStyle & wxFRAME_TOOL_WINDOW)
255 *pdwExflags = kFrameToolWindow;
256
257 if (lStyle & wxSTAY_ON_TOP)
258 lMsflags |= FCF_SYSMODAL;
259
260 return lMsflags;
261 } // end of wxTopLevelWindowOS2::OS2GetCreateWindowFlags
262
263 WXHWND wxTopLevelWindowOS2::OS2GetParent() const
264 {
265 HWND hWndParent = NULL;
266
267 //
268 // For the frames without wxFRAME_FLOAT_ON_PARENT style we should use NULL
269 // parent HWND or it would be always on top of its parent which is not what
270 // we usually want (in fact, we only want it for frames with the
271 // wxFRAME_FLOAT_ON_PARENT flag)
272 //
273 if (HasFlag(wxFRAME_FLOAT_ON_PARENT) )
274 {
275 const wxWindow* pParent = GetParent();
276
277 if (!pParent)
278 {
279 //
280 // This flag doesn't make sense then and will be ignored
281 //
282 wxFAIL_MSG( wxT("wxFRAME_FLOAT_ON_PARENT but no parent?") );
283 }
284 else
285 {
286 hWndParent = GetHwndOf(pParent);
287 }
288 }
289 //else: don't float on parent, must not be owned
290
291 //
292 // Now deal with the 2nd taskbar-related problem (see comments above in
293 // OS2GetStyle())
294 //
295 if (HasFlag(wxFRAME_NO_TASKBAR) && !hWndParent)
296 {
297 //
298 // Use hidden parent
299 //
300 hWndParent = wxTLWHiddenParentModule::GetHWND();
301 }
302 return (WXHWND)hWndParent;
303 } // end of wxTopLevelWindowOS2::OS2GetParent
304
305
306 bool wxTopLevelWindowOS2::CreateDialog( ULONG ulDlgTemplate,
307 const wxString& WXUNUSED(rsTitle),
308 const wxPoint& rPos,
309 const wxSize& rSize )
310 {
311 wxWindow* pParent = GetParent();
312
313 //
314 // For the dialogs without wxDIALOG_NO_PARENT style, use the top level
315 // app window as parent - this avoids creating modal dialogs without
316 // parent
317 //
318 if (!pParent && !(GetWindowStyleFlag() & wxDIALOG_NO_PARENT))
319 {
320 pParent = wxTheApp->GetTopWindow();
321
322 if (pParent)
323 {
324 //
325 // Don't use transient windows as parents, this is dangerous as it
326 // can lead to a crash if the parent is destroyed before the child
327 //
328 // also don't use the window which is currently hidden as then the
329 // dialog would be hidden as well
330 if ((pParent->GetExtraStyle() & wxWS_EX_TRANSIENT) ||
331 !pParent->IsShown())
332 {
333 pParent = NULL;
334 }
335 }
336 }
337
338 HWND hWndDlg;
339 HWND hWndOwner;
340
341 if (pParent)
342 hWndOwner = GetHwndOf(pParent);
343 else
344 hWndOwner = HWND_DESKTOP;
345
346 hWndDlg = ::WinLoadDlg( HWND_DESKTOP
347 ,hWndOwner
348 ,(PFNWP)wxDlgProc
349 ,NULL
350 ,(ULONG)ulDlgTemplate
351 ,(PVOID)this
352 );
353
354 m_hWnd = (WXHWND) hWndDlg;
355
356 if ( !m_hWnd )
357 {
358 wxFAIL_MSG(wxT("Did you forget to include wx/os2/wx.rc in your resources?"));
359
360 wxLogSysError(wxT("Can't create dialog using template '%ld'"), ulDlgTemplate);
361
362 return false;
363 }
364
365 //
366 // Move the dialog to its initial position without forcing repainting
367 //
368 int nX;
369 int nY;
370 int nWidth;
371 int nHeight;
372
373 if (!OS2GetCreateWindowCoords( rPos
374 ,rSize
375 ,nX
376 ,nY
377 ,nWidth
378 ,nHeight
379 ))
380 {
381 nX = nWidth = (int)CW_USEDEFAULT;
382 }
383
384 //
385 // We can't use CW_USEDEFAULT here as we're not calling CreateWindow()
386 // and passing CW_USEDEFAULT to MoveWindow() results in resizing the
387 // window to (0, 0) size which breaks quite a lot of things, e.g. the
388 // sizer calculation in wxSizer::Fit()
389 //
390 if (nWidth == (int)CW_USEDEFAULT)
391 {
392 //
393 // The exact number doesn't matter, the dialog will be resized
394 // again soon anyhow but it should be big enough to allow
395 // calculation relying on "totalSize - clientSize > 0" work, i.e.
396 // at least greater than the title bar height
397 //
398 nWidth = nHeight = 100;
399 }
400 if (nX == (int)CW_USEDEFAULT)
401 {
402 //
403 // Centre it on the screen - what else can we do?
404 //
405 wxSize vSizeDpy = wxGetDisplaySize();
406
407 nX = (vSizeDpy.x - nWidth) / 2;
408 nY = (vSizeDpy.y - nHeight) / 2;
409 }
410 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
411
412 LONG lColor = (LONG)m_backgroundColour.GetPixel();
413
414 if (!::WinSetPresParam( m_hWnd
415 ,PP_BACKGROUNDCOLOR
416 ,sizeof(LONG)
417 ,(PVOID)&lColor
418 ))
419 {
420 return false;
421 }
422
423 // Convert to OS/2 coordinates
424 nY = GetOS2ParentHeight(pParent) - nY - nHeight;
425
426 ::WinSetWindowPos( GetHwnd()
427 ,HWND_TOP
428 ,nX
429 ,nY
430 ,nWidth
431 ,nHeight
432 ,SWP_MOVE | SWP_SIZE | SWP_ZORDER | SWP_SHOW | SWP_ACTIVATE
433 );
434 ::WinQueryWindowPos(GetHwnd(), GetSwp());
435 m_hFrame = m_hWnd;
436 SubclassWin(m_hWnd);
437 return true;
438 } // end of wxTopLevelWindowOS2::CreateDialog
439
440 bool wxTopLevelWindowOS2::CreateFrame( const wxString& rsTitle,
441 const wxPoint& rPos,
442 const wxSize& rSize )
443 {
444 WXDWORD lExflags;
445 WXDWORD lFlags = OS2GetCreateWindowFlags(&lExflags);
446 long lStyle = GetWindowStyleFlag();
447 int nX = rPos.x;
448 int nY = rPos.y;
449 int nWidth = rSize.x;
450 int nHeight = rSize.y;
451 ULONG ulStyleFlags = 0L;
452 ERRORID vError;
453 wxString sError;
454 wxWindow* pParent = GetParent();
455 HWND hParent;
456 HWND hFrame;
457 HWND hClient;
458
459 if (pParent)
460 hParent = GetHwndOf(pParent);
461 else
462 hParent = HWND_DESKTOP;
463
464 if ((lStyle & wxMINIMIZE) || (lStyle & wxICONIZE))
465 ulStyleFlags |= WS_MINIMIZED;
466 if (lStyle & wxMAXIMIZE)
467 ulStyleFlags |= WS_MAXIMIZED;
468
469 //
470 // Clear the visible flag, we always call show
471 //
472 ulStyleFlags &= (unsigned long)~WS_VISIBLE;
473 m_bIconized = false;
474
475 //
476 // Create the frame window: We break ranks with other ports now
477 // and instead of calling down into the base wxWindow class' OS2Create
478 // we do all our own stuff here. We will set the needed pieces
479 // of wxWindow manually, here.
480 //
481
482 hFrame = ::WinCreateStdWindow( hParent
483 ,ulStyleFlags // frame-window style
484 ,(PULONG)&lFlags // window style
485 ,wxString(wxFrameClassName).c_str() // class name
486 ,rsTitle.c_str() // window title
487 ,0L // default client style
488 ,NULLHANDLE // resource in executable file
489 ,0 // resource id
490 ,&hClient // receives client window handle
491 );
492 if (!hFrame)
493 {
494 vError = ::WinGetLastError(vHabmain);
495 sError = wxPMErrorToStr(vError);
496 wxLogError(wxT("Error creating frame. Error: %s\n"), sError.c_str());
497 return false;
498 }
499
500 //
501 // wxWindow class' m_hWnd set here and needed associations
502 //
503 m_hFrame = hFrame;
504 m_hWnd = hClient;
505 wxAssociateWinWithHandle(m_hWnd, this);
506 wxAssociateWinWithHandle(m_hFrame, this);
507
508 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
509
510 LONG lColor = (LONG)m_backgroundColour.GetPixel();
511
512 if (!::WinSetPresParam( m_hWnd
513 ,PP_BACKGROUNDCOLOR
514 ,sizeof(LONG)
515 ,(PVOID)&lColor
516 ))
517 {
518 vError = ::WinGetLastError(vHabmain);
519 sError = wxPMErrorToStr(vError);
520 wxLogError(wxT("Error creating frame. Error: %s\n"), sError.c_str());
521 return false;
522 }
523
524 //
525 // Now need to subclass window. Instead of calling the SubClassWin in wxWindow
526 // we manually subclass here because we don't want to use the main wxWndProc
527 // by default
528 //
529 m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(m_hFrame, (PFNWP)wxFrameMainWndProc);
530
531 //
532 // Now size everything. If adding a menu the client will need to be resized.
533 //
534
535 if (!OS2GetCreateWindowCoords( rPos
536 ,rSize
537 ,nX
538 ,nY
539 ,nWidth
540 ,nHeight
541 ))
542 {
543 nX = nWidth = (int)CW_USEDEFAULT;
544 }
545
546 //
547 // We can't use CW_USEDEFAULT here as we're not calling CreateWindow()
548 // and passing CW_USEDEFAULT to MoveWindow() results in resizing the
549 // window to (0, 0) size which breaks quite a lot of things, e.g. the
550 // sizer calculation in wxSizer::Fit()
551 //
552 if (nWidth == (int)CW_USEDEFAULT)
553 {
554 //
555 // The exact number doesn't matter, the dialog will be resized
556 // again soon anyhow but it should be big enough to allow
557 // calculation relying on "totalSize - clientSize > 0" work, i.e.
558 // at least greater than the title bar height
559 //
560 nWidth = nHeight = 100;
561 }
562 if (nX == (int)CW_USEDEFAULT)
563 {
564 //
565 // Centre it on the screen for now - what else can we do?
566 // TODO: We could try FCF_SHELLPOSITION but it will require moving
567 // things around a bit.
568 //
569 wxSize vSizeDpy = wxGetDisplaySize();
570
571 nX = (vSizeDpy.x - nWidth) / 2;
572 nY = (vSizeDpy.y - nHeight) / 2;
573 }
574
575 // Convert to OS/2 coordinates
576 nY = GetOS2ParentHeight(pParent) - nY - nHeight;
577
578 if (!::WinSetWindowPos( m_hFrame
579 ,HWND_TOP
580 ,nX
581 ,nY
582 ,nWidth
583 ,nHeight
584 ,SWP_SIZE | SWP_MOVE | SWP_ACTIVATE | SWP_ZORDER
585 ))
586 {
587 vError = ::WinGetLastError(vHabmain);
588 sError = wxPMErrorToStr(vError);
589 wxLogError(wxT("Error sizing frame. Error: %s\n"), sError.c_str());
590 return false;
591 }
592 lStyle = ::WinQueryWindowULong( m_hWnd
593 ,QWL_STYLE
594 );
595 lStyle |= WS_CLIPCHILDREN;
596 ::WinSetWindowULong( m_hWnd
597 ,QWL_STYLE
598 ,lStyle
599 );
600 return true;
601 } // end of wxTopLevelWindowOS2::CreateFrame
602
603 bool wxTopLevelWindowOS2::Create(
604 wxWindow* pParent
605 , wxWindowID vId
606 , const wxString& rsTitle
607 , const wxPoint& rPos
608 , const wxSize& rSizeOrig
609 , long lStyle
610 , const wxString& rsName
611 )
612 {
613 //
614 // Init our fields
615 //
616 Init();
617 m_windowStyle = lStyle;
618 SetName(rsName);
619 m_windowId = vId == -1 ? NewControlId() : vId;
620
621 // always create a frame of some reasonable, even if arbitrary, size (at
622 // least for MSW compatibility)
623 wxSize rSize = rSizeOrig;
624 if ( rSize.x == -1 || rSize.y == -1 )
625 {
626 wxSize sizeDpy = wxGetDisplaySize();
627 if ( rSize.x == -1 )
628 rSize.x = sizeDpy.x / 3;
629 if ( rSize.y == -1 )
630 rSize.y = sizeDpy.y / 5;
631 }
632
633 wxTopLevelWindows.Append(this);
634 if (pParent)
635 pParent->AddChild(this);
636
637 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
638 {
639 //
640 // We have different dialog templates to allow creation of dialogs
641 // with & without captions under OS2indows, resizable or not (but a
642 // resizable dialog always has caption - otherwise it would look too
643 // strange)
644 //
645 ULONG ulDlgTemplate;
646
647 if (lStyle & wxRESIZE_BORDER)
648 ulDlgTemplate = (ULONG)kResizeableDialog;
649 else if (lStyle & wxCAPTION)
650 ulDlgTemplate = (ULONG)kCaptionDialog;
651 else
652 ulDlgTemplate = (ULONG)kNoCaptionDialog;
653 return CreateDialog( ulDlgTemplate
654 ,rsTitle
655 ,rPos
656 ,rSize
657 );
658 }
659 else // !dialog
660 {
661 return CreateFrame( rsTitle
662 ,rPos
663 ,rSize
664 );
665 }
666 } // end of wxTopLevelWindowOS2::Create
667
668 wxTopLevelWindowOS2::~wxTopLevelWindowOS2()
669 {
670 //
671 // After destroying an owned window, Windows activates the next top level
672 // window in Z order but it may be different from our owner (to reproduce
673 // this simply Alt-TAB to another application and back before closing the
674 // owned frame) whereas we always want to yield activation to our parent
675 //
676 if (HasFlag(wxFRAME_FLOAT_ON_PARENT))
677 {
678 wxWindow* pParent = GetParent();
679
680 if (pParent)
681 {
682 ::WinSetWindowPos( GetHwndOf(pParent)
683 ,HWND_TOP
684 ,0, 0, 0, 0
685 ,SWP_ZORDER
686 );
687 }
688 }
689 } // end of wxTopLevelWindowOS2::~wxTopLevelWindowOS2
690
691 // ----------------------------------------------------------------------------
692 // wxTopLevelWindowOS2 client size
693 // ----------------------------------------------------------------------------
694
695 void wxTopLevelWindowOS2::DoSetClientSize(
696 int nWidth
697 , int nHeight
698 )
699 {
700 //
701 // Call GetClientAreaOrigin() to take the toolbar into account
702 //
703 wxPoint vPt = GetClientAreaOrigin();
704
705 nWidth += vPt.x;
706 nHeight += vPt.y;
707
708 wxWindow::DoSetClientSize( nWidth
709 ,nHeight
710 );
711 } // end of wxTopLevelWindowOS2::DoSetClientSize
712
713 void wxTopLevelWindowOS2::DoGetClientSize(
714 int* pnX
715 , int* pnY
716 ) const
717 {
718 wxWindow::DoGetClientSize( pnX
719 ,pnY
720 );
721
722 wxPoint vPt = GetClientAreaOrigin();
723
724 if (pnX)
725 *pnX -= vPt.x;
726
727 if (pnY)
728 *pnY += vPt.y;
729 } // end of wxTopLevelWindowOS2::DoGetClientSize
730
731 // ----------------------------------------------------------------------------
732 // wxTopLevelWindowOS2 showing
733 // ----------------------------------------------------------------------------
734
735 void wxTopLevelWindowOS2::DoShowWindow(
736 int nShowCmd
737 )
738 {
739 ::WinShowWindow(m_hFrame, (BOOL)(nShowCmd & SWP_SHOW));
740
741 //
742 // Need to artificially send a size event as wxApps often expect to do some
743 // final child control sizing
744 SendSizeEvent();
745 m_bIconized = nShowCmd == SWP_MINIMIZE;
746 } // end of wxTopLevelWindowOS2::DoShowWindow
747
748 bool wxTopLevelWindowOS2::Show( bool bShow )
749 {
750 int nShowCmd;
751 SWP vSwp;
752
753 if (bShow != IsShown() )
754 {
755 m_isShown = bShow;
756 }
757 else
758 {
759 return false;
760 }
761 if (bShow)
762 {
763 if (m_bMaximizeOnShow)
764 {
765 nShowCmd = SWP_MAXIMIZE;
766 m_bMaximizeOnShow = false;
767 }
768 else
769 {
770 nShowCmd = SWP_SHOW;
771 }
772 }
773 else // hide
774 {
775 nShowCmd = SWP_HIDE;
776 }
777 DoShowWindow(nShowCmd);
778
779 if (bShow)
780 {
781 wxActivateEvent vEvent(wxEVT_ACTIVATE, true, m_windowId);
782
783 ::WinQueryWindowPos(m_hFrame, &vSwp);
784 m_bIconized = ( vSwp.fl & SWP_MINIMIZE ) == SWP_MINIMIZE ;
785 ::WinQueryWindowPos(m_hWnd, &m_vSwpClient);
786 ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
787 ::WinQueryWindowPos(m_hWnd, &vSwp);
788 ::WinEnableWindow(m_hFrame, TRUE);
789
790 vEvent.SetEventObject(this);
791 HandleWindowEvent(vEvent);
792 }
793 else
794 {
795 //
796 // Try to highlight the correct window (the parent)
797 //
798 if (GetParent())
799 {
800 HWND hWndParent = GetHwndOf(GetParent());
801
802 ::WinQueryWindowPos(hWndParent, &vSwp);
803 m_bIconized = (vSwp.fl & SWP_MINIMIZE)==SWP_MINIMIZE;
804 ::WinEnableWindow(hWndParent, TRUE);
805 }
806 }
807 return true;
808 } // end of wxTopLevelWindowOS2::Show
809
810 // ----------------------------------------------------------------------------
811 // wxTopLevelWindowOS2 maximize/minimize
812 // ----------------------------------------------------------------------------
813
814 void wxTopLevelWindowOS2::Maximize(
815 bool bMaximize
816 )
817 {
818 if (IsShown())
819 {
820 //
821 // Just maximize it directly
822 //
823 DoShowWindow(bMaximize ? SWP_MAXIMIZE : SWP_RESTORE);
824 }
825 else // hidden
826 {
827 //
828 // We can't maximize the hidden frame because it shows it as well, so
829 // just remember that we should do it later in this case
830 //
831 m_bMaximizeOnShow = bMaximize;
832 }
833 } // end of wxTopLevelWindowOS2::Maximize
834
835 bool wxTopLevelWindowOS2::IsMaximized() const
836 {
837 ::WinQueryWindowPos(m_hFrame, (PSWP)&m_vSwp);
838 return (m_vSwp.fl & SWP_MAXIMIZE) == SWP_MAXIMIZE;
839 } // end of wxTopLevelWindowOS2::IsMaximized
840
841 void wxTopLevelWindowOS2::SetTitle( const wxString& title)
842 {
843 SetLabel(title);
844 }
845
846 wxString wxTopLevelWindowOS2::GetTitle() const
847 {
848 return GetLabel();
849 }
850
851 void wxTopLevelWindowOS2::Iconize( bool bIconize )
852 {
853 DoShowWindow(bIconize ? SWP_MINIMIZE : SWP_RESTORE);
854 } // end of wxTopLevelWindowOS2::Iconize
855
856 bool wxTopLevelWindowOS2::IsIconized() const
857 {
858 // also update the current state
859 ::WinQueryWindowPos(m_hFrame, (PSWP)&m_vSwp);
860 if (m_vSwp.fl & SWP_MINIMIZE)
861 ((wxTopLevelWindow*)this)->m_bIconized = true;
862 else
863 ((wxTopLevelWindow*)this)->m_bIconized = false;
864 return m_bIconized;
865 } // end of wxTopLevelWindowOS2::IsIconized
866
867 void wxTopLevelWindowOS2::Restore()
868 {
869 DoShowWindow(SWP_RESTORE);
870 } // end of wxTopLevelWindowOS2::Restore
871
872 // generate an artificial resize event
873 void wxTopLevelWindowOS2::SendSizeEvent(int flags)
874 {
875 if (!m_bIconized)
876 {
877 RECTL vRect = wxGetWindowRect(GetHwnd());
878
879 if ( flags & wxSEND_EVENT_POST )
880 {
881 (void)::WinPostMsg( m_hFrame
882 ,WM_SIZE
883 ,MPFROM2SHORT(vRect.xRight - vRect.xLeft, vRect.yTop - vRect.yBottom)
884 ,MPFROM2SHORT(vRect.xRight - vRect.xLeft, vRect.yTop - vRect.yBottom)
885 );
886 }
887 else // send it
888 {
889 (void)::WinSendMsg( m_hFrame
890 ,WM_SIZE
891 ,MPFROM2SHORT(vRect.xRight - vRect.xLeft, vRect.yTop - vRect.yBottom)
892 ,MPFROM2SHORT(vRect.xRight - vRect.xLeft, vRect.yTop - vRect.yBottom)
893 );
894 }
895 }
896 } // end of wxTopLevelWindowOS2::SendSizeEvent
897
898 // ----------------------------------------------------------------------------
899 // wxTopLevelWindowOS2 fullscreen
900 // ----------------------------------------------------------------------------
901
902 bool wxTopLevelWindowOS2::ShowFullScreen( bool bShow,
903 long lStyle )
904 {
905 if (bShow)
906 {
907 if (IsFullScreen())
908 return false;
909
910 m_bFsIsShowing = true;
911 m_lFsStyle = lStyle;
912
913 //
914 // Zap the frame borders
915 //
916
917 //
918 // Save the 'normal' window lStyle
919 //
920 m_lFsOldWindowStyle = ::WinQueryWindowULong( (HWND)GetHWND()
921 ,QWL_STYLE
922 );
923
924 //
925 // Save the old position, width & height, maximize state
926 //
927 m_vFsOldSize = GetRect();
928 m_bFsIsMaximized = IsMaximized();
929
930 //
931 // Decide which window lStyle flags to turn off
932 //
933 LONG lNewStyle = m_lFsOldWindowStyle;
934 LONG lOffFlags = 0;
935
936 if (lStyle & wxFULLSCREEN_NOBORDER)
937 lOffFlags |= FCF_BORDER;
938 if (lStyle & wxFULLSCREEN_NOCAPTION)
939 lOffFlags |= (FCF_TASKLIST | FCF_SYSMENU);
940
941 lNewStyle &= (~lOffFlags);
942
943 //
944 // Change our window style to be compatible with full-screen mode
945 //
946 ::WinSetWindowULong( (HWND)GetHWND()
947 ,QWL_STYLE
948 ,lNewStyle
949 );
950
951 //
952 // Resize to the size of the desktop
953 //
954 int nWidth;
955 int nHeight;
956 RECTL vRect = wxGetWindowRect(HWND_DESKTOP);
957
958 nWidth = vRect.xRight - vRect.xLeft;
959 nHeight = vRect.yTop - vRect.yBottom;
960
961 SetSize( nWidth, nHeight );
962
963 //
964 // Now flush the window style cache and actually go full-screen
965 //
966 ::WinSetWindowPos( m_hFrame
967 ,HWND_TOP
968 ,0
969 ,0
970 ,nWidth
971 ,nHeight
972 ,SWP_SIZE | SWP_MOVE
973 );
974
975 wxSize full( nWidth, nHeight );
976 wxSizeEvent vEvent( full, GetId() );
977 HandleWindowEvent(vEvent);
978 return true;
979 }
980 else
981 {
982 if (!IsFullScreen())
983 return false;
984
985 m_bFsIsShowing = false;
986 Maximize(m_bFsIsMaximized);
987 ::WinSetWindowULong( (HWND)GetHWND()
988 ,QWL_STYLE
989 ,m_lFsOldWindowStyle
990 );
991 ::WinSetWindowPos( m_hFrame
992 ,HWND_TOP
993 ,m_vFsOldSize.x
994 ,m_vFsOldSize.y
995 ,m_vFsOldSize.width
996 ,m_vFsOldSize.height
997 ,SWP_SIZE | SWP_MOVE
998 );
999 return true;
1000 }
1001 } // end of wxTopLevelWindowOS2::ShowFullScreen
1002
1003 // ----------------------------------------------------------------------------
1004 // wxTopLevelWindowOS2 misc
1005 // ----------------------------------------------------------------------------
1006
1007 void wxTopLevelWindowOS2::SetIcons(
1008 const wxIconBundle& rIcons
1009 )
1010 {
1011 //
1012 // This sets m_icon
1013 //
1014 wxTopLevelWindowBase::SetIcons(rIcons);
1015
1016 const wxIcon& vIcon = rIcons.GetIconOfExactSize(32);
1017
1018 if (vIcon.Ok())
1019 {
1020 ::WinSendMsg( m_hFrame
1021 ,WM_SETICON
1022 ,(MPARAM)((HPOINTER)vIcon.GetHICON())
1023 ,NULL
1024 );
1025 ::WinSendMsg( m_hFrame
1026 ,WM_UPDATEFRAME
1027 ,(MPARAM)FCF_ICON
1028 ,(MPARAM)0
1029 );
1030 }
1031 } // end of wxTopLevelWindowOS2::SetIcon
1032
1033 bool wxTopLevelWindowOS2::EnableCloseButton( bool bEnable )
1034 {
1035 //
1036 // Get system (a.k.a. window) menu
1037 //
1038 HMENU hMenu = ::WinWindowFromID(m_hFrame, FID_SYSMENU);
1039
1040 if (!hMenu)
1041 {
1042 wxLogLastError(wxT("GetSystemMenu"));
1043 return false;
1044 }
1045
1046 //
1047 // Enabling/disabling the close item from it also automatically
1048 // disables/enables the close title bar button
1049 //
1050 if (bEnable)
1051 (void)::WinSendMsg( hMenu
1052 ,MM_SETITEMATTR
1053 ,MPFROM2SHORT(SC_CLOSE, FALSE)
1054 ,MPFROM2SHORT(MIA_DISABLED, FALSE)
1055 );
1056 else
1057 (void)::WinSendMsg( hMenu
1058 ,MM_SETITEMATTR
1059 ,MPFROM2SHORT(SC_CLOSE, FALSE)
1060 ,MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED)
1061 );
1062
1063 //
1064 // Update appearance immediately
1065 //
1066 ::WinSendMsg( m_hFrame
1067 ,WM_UPDATEFRAME
1068 ,(MPARAM)FCF_MENU
1069 ,(MPARAM)0
1070 );
1071 return true;
1072 } // end of wxTopLevelWindowOS2::EnableCloseButton
1073
1074 // ============================================================================
1075 // wxTLWHiddenParentModule implementation
1076 // ============================================================================
1077
1078 HWND wxTLWHiddenParentModule::m_shWnd = NULL;
1079 const wxChar* wxTLWHiddenParentModule::m_szClassName = NULL;
1080
1081 bool wxTLWHiddenParentModule::OnInit()
1082 {
1083 m_shWnd = NULL;
1084 m_szClassName = NULL;
1085 return true;
1086 } // end of wxTLWHiddenParentModule::OnInit
1087
1088 void wxTLWHiddenParentModule::OnExit()
1089 {
1090 if (m_shWnd)
1091 {
1092 if (!::WinDestroyWindow(m_shWnd))
1093 {
1094 wxLogLastError(wxT("DestroyWindow(hidden TLW parent)"));
1095 }
1096 m_shWnd = NULL;
1097 }
1098
1099 m_szClassName = NULL;
1100 } // end of wxTLWHiddenParentModule::OnExit
1101
1102 /* static */
1103 HWND wxTLWHiddenParentModule::GetHWND()
1104 {
1105 if (!m_shWnd)
1106 {
1107 if (!m_szClassName)
1108 {
1109 static const wxChar* zHIDDEN_PARENT_CLASS = wxT("wxTLWHiddenParent");
1110
1111 if (!::WinRegisterClass( wxGetInstance()
1112 ,(PSZ)zHIDDEN_PARENT_CLASS
1113 ,NULL
1114 ,0
1115 ,sizeof(ULONG)
1116 ))
1117 {
1118 wxLogLastError(wxT("RegisterClass(\"wxTLWHiddenParent\")"));
1119 }
1120 else
1121 {
1122 m_szClassName = zHIDDEN_PARENT_CLASS;
1123 }
1124 }
1125 m_shWnd = ::WinCreateWindow( HWND_DESKTOP,
1126 (PSZ)m_szClassName,
1127 "",
1128 0L,
1129 (LONG)0L,
1130 (LONG)0L,
1131 (LONG)0L,
1132 (LONG)0L,
1133 NULLHANDLE,
1134 HWND_TOP,
1135 0L,
1136 NULL,
1137 NULL );
1138 if (!m_shWnd)
1139 {
1140 wxLogLastError(wxT("CreateWindow(hidden TLW parent)"));
1141 }
1142 }
1143 return m_shWnd;
1144 } // end of wxTLWHiddenParentModule::GetHWND
wxWidgets (Impactor)