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