]> git.saurik.com Git - wxWidgets.git/blob - src/msw/toplevel.cpp
adjust the toolbar tools bitmap size to fit the biggest bitmap used under wxOSX too...
[wxWidgets.git] / src / msw / toplevel.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/toplevel.cpp
3 // Purpose: implements wxTopLevelWindow for MSW
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 24.09.01
7 // RCS-ID: $Id$
8 // Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
9 // License: 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/containr.h" // wxSetFocusToChild()
37 #include "wx/module.h"
38 #endif //WX_PRECOMP
39
40 #include "wx/dynlib.h"
41
42 #include "wx/msw/private.h"
43 #if defined(__WXWINCE__) && !defined(__HANDHELDPC__)
44 #include <ole2.h>
45 #include <shellapi.h>
46 // Standard SDK doesn't have aygshell.dll: see include/wx/msw/wince/libraries.h
47 #if _WIN32_WCE < 400 || !defined(__WINCE_STANDARDSDK__)
48 #include <aygshell.h>
49 #endif
50 #endif
51
52 #include "wx/msw/winundef.h"
53 #include "wx/msw/missing.h"
54
55 #include "wx/display.h"
56
57 #ifndef ICON_BIG
58 #define ICON_BIG 1
59 #endif
60
61 #ifndef ICON_SMALL
62 #define ICON_SMALL 0
63 #endif
64
65 // ----------------------------------------------------------------------------
66 // stubs for missing functions under MicroWindows
67 // ----------------------------------------------------------------------------
68
69 #ifdef __WXMICROWIN__
70
71 // static inline bool IsIconic(HWND WXUNUSED(hwnd)) { return false; }
72 static inline bool IsZoomed(HWND WXUNUSED(hwnd)) { return false; }
73
74 #endif // __WXMICROWIN__
75
76 // NB: wxDlgProc must be defined here and not in dialog.cpp because the latter
77 // is not included by wxUniv build which does need wxDlgProc
78 LONG APIENTRY _EXPORT
79 wxDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
80
81 // ----------------------------------------------------------------------------
82 // wxTLWHiddenParentModule: used to manage the hidden parent window (we need a
83 // module to ensure that the window is always deleted)
84 // ----------------------------------------------------------------------------
85
86 class wxTLWHiddenParentModule : public wxModule
87 {
88 public:
89 // module init/finalize
90 virtual bool OnInit();
91 virtual void OnExit();
92
93 // get the hidden window (creates on demand)
94 static HWND GetHWND();
95
96 private:
97 // the HWND of the hidden parent
98 static HWND ms_hwnd;
99
100 // the class used to create it
101 static const wxChar *ms_className;
102
103 DECLARE_DYNAMIC_CLASS(wxTLWHiddenParentModule)
104 };
105
106 IMPLEMENT_DYNAMIC_CLASS(wxTLWHiddenParentModule, wxModule)
107
108 // ============================================================================
109 // wxTopLevelWindowMSW implementation
110 // ============================================================================
111
112 BEGIN_EVENT_TABLE(wxTopLevelWindowMSW, wxTopLevelWindowBase)
113 EVT_ACTIVATE(wxTopLevelWindowMSW::OnActivate)
114 END_EVENT_TABLE()
115
116 // ----------------------------------------------------------------------------
117 // wxTopLevelWindowMSW creation
118 // ----------------------------------------------------------------------------
119
120 void wxTopLevelWindowMSW::Init()
121 {
122 m_iconized =
123 m_maximizeOnShow = false;
124
125 // Data to save/restore when calling ShowFullScreen
126 m_fsStyle = 0;
127 m_fsOldWindowStyle = 0;
128 m_fsIsMaximized = false;
129 m_fsIsShowing = false;
130
131 m_winLastFocused = NULL;
132
133 #if defined(__SMARTPHONE__) && defined(__WXWINCE__)
134 m_MenuBarHWND = 0;
135 #endif
136
137 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
138 SHACTIVATEINFO* info = new SHACTIVATEINFO;
139 wxZeroMemory(*info);
140 info->cbSize = sizeof(SHACTIVATEINFO);
141
142 m_activateInfo = (void*) info;
143 #endif
144 }
145
146 WXDWORD wxTopLevelWindowMSW::MSWGetStyle(long style, WXDWORD *exflags) const
147 {
148 // let the base class deal with the common styles but fix the ones which
149 // don't make sense for us (we also deal with the borders ourselves)
150 WXDWORD msflags = wxWindow::MSWGetStyle
151 (
152 (style & ~wxBORDER_MASK) | wxBORDER_NONE, exflags
153 ) & ~WS_CHILD & ~WS_VISIBLE;
154
155 // For some reason, WS_VISIBLE needs to be defined on creation for
156 // SmartPhone 2003. The title can fail to be displayed otherwise.
157 #if defined(__SMARTPHONE__) || (defined(__WXWINCE__) && _WIN32_WCE < 400)
158 msflags |= WS_VISIBLE;
159 ((wxTopLevelWindowMSW*)this)->wxWindowBase::Show(true);
160 #endif
161
162 // first select the kind of window being created
163 //
164 // note that if we don't set WS_POPUP, Windows assumes WS_OVERLAPPED and
165 // creates a window with both caption and border, hence we need to use
166 // WS_POPUP in a few cases just to avoid having caption/border which we
167 // don't want
168
169 // border and caption styles
170 if ( ( style & wxRESIZE_BORDER ) && !IsAlwaysMaximized())
171 msflags |= WS_THICKFRAME;
172 else if ( exflags && ((style & wxBORDER_DOUBLE) || (style & wxBORDER_RAISED)) )
173 *exflags |= WS_EX_DLGMODALFRAME;
174 else if ( !(style & wxBORDER_NONE) )
175 msflags |= WS_BORDER;
176 #ifndef __POCKETPC__
177 else
178 msflags |= WS_POPUP;
179 #endif
180
181 // normally we consider that all windows without a caption must be popups,
182 // but CE is an exception: there windows normally do not have the caption
183 // but shouldn't be made popups as popups can't have menus and don't look
184 // like normal windows anyhow
185
186 // TODO: Smartphone appears to like wxCAPTION, but we should check that
187 // we need it.
188 #if defined(__SMARTPHONE__) || !defined(__WXWINCE__)
189 if ( style & wxCAPTION )
190 msflags |= WS_CAPTION;
191 #ifndef __WXWINCE__
192 else
193 msflags |= WS_POPUP;
194 #endif // !__WXWINCE__
195 #endif
196
197 // next translate the individual flags
198
199 // WS_EX_CONTEXTHELP is incompatible with WS_MINIMIZEBOX and WS_MAXIMIZEBOX
200 // and is ignored if we specify both of them, but chances are that if we
201 // use wxWS_EX_CONTEXTHELP, we really do want to have the context help
202 // button while wxMINIMIZE/wxMAXIMIZE are included by default, so the help
203 // takes precedence
204 if ( !(GetExtraStyle() & wxWS_EX_CONTEXTHELP) )
205 {
206 if ( style & wxMINIMIZE_BOX )
207 msflags |= WS_MINIMIZEBOX;
208 if ( style & wxMAXIMIZE_BOX )
209 msflags |= WS_MAXIMIZEBOX;
210 }
211
212 #ifndef __WXWINCE__
213 // notice that if wxCLOSE_BOX is specified we need to use WS_SYSMENU too as
214 // otherwise the close box doesn't appear
215 if ( style & (wxSYSTEM_MENU | wxCLOSE_BOX) )
216 msflags |= WS_SYSMENU;
217 #endif // !__WXWINCE__
218
219 // NB: under CE these 2 styles are not supported currently, we should
220 // call Minimize()/Maximize() "manually" if we want to support them
221 if ( style & wxMINIMIZE )
222 msflags |= WS_MINIMIZE;
223
224 if ( style & wxMAXIMIZE )
225 msflags |= WS_MAXIMIZE;
226
227 // Keep this here because it saves recoding this function in wxTinyFrame
228 if ( style & (wxTINY_CAPTION_VERT | wxTINY_CAPTION_HORIZ) )
229 msflags |= WS_CAPTION;
230
231 if ( exflags )
232 {
233 // there is no taskbar under CE, so omit all this
234 #if !defined(__WXWINCE__)
235 if ( !(GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) )
236 {
237 if ( style & wxFRAME_TOOL_WINDOW )
238 {
239 // create the palette-like window
240 *exflags |= WS_EX_TOOLWINDOW;
241
242 // tool windows shouldn't appear on the taskbar (as documented)
243 style |= wxFRAME_NO_TASKBAR;
244 }
245
246 // We have to solve 2 different problems here:
247 //
248 // 1. frames with wxFRAME_NO_TASKBAR flag shouldn't appear in the
249 // taskbar even if they don't have a parent
250 //
251 // 2. frames without this style should appear in the taskbar even
252 // if they're owned (Windows only puts non owned windows into
253 // the taskbar normally)
254 //
255 // The second one is solved here by using WS_EX_APPWINDOW flag, the
256 // first one is dealt with in our MSWGetParent() method
257 // implementation
258 if ( !(style & wxFRAME_NO_TASKBAR) && GetParent() )
259 {
260 // need to force the frame to appear in the taskbar
261 *exflags |= WS_EX_APPWINDOW;
262 }
263 //else: nothing to do [here]
264 }
265
266 if ( GetExtraStyle() & wxWS_EX_CONTEXTHELP )
267 *exflags |= WS_EX_CONTEXTHELP;
268 #endif // !__WXWINCE__
269
270 if ( style & wxSTAY_ON_TOP )
271 *exflags |= WS_EX_TOPMOST;
272 }
273
274 return msflags;
275 }
276
277 WXHWND wxTopLevelWindowMSW::MSWGetParent() const
278 {
279 // for the frames without wxFRAME_FLOAT_ON_PARENT style we should use NULL
280 // parent HWND or it would be always on top of its parent which is not what
281 // we usually want (in fact, we only want it for frames with the
282 // wxFRAME_FLOAT_ON_PARENT flag)
283 HWND hwndParent = NULL;
284 if ( HasFlag(wxFRAME_FLOAT_ON_PARENT) )
285 {
286 const wxWindow *parent = GetParent();
287
288 if ( !parent )
289 {
290 // this flag doesn't make sense then and will be ignored
291 wxFAIL_MSG( _T("wxFRAME_FLOAT_ON_PARENT but no parent?") );
292 }
293 else
294 {
295 hwndParent = GetHwndOf(parent);
296 }
297 }
298 //else: don't float on parent, must not be owned
299
300 // now deal with the 2nd taskbar-related problem (see comments above in
301 // MSWGetStyle())
302 if ( HasFlag(wxFRAME_NO_TASKBAR) && !hwndParent )
303 {
304 // use hidden parent
305 hwndParent = wxTLWHiddenParentModule::GetHWND();
306 }
307
308 return (WXHWND)hwndParent;
309 }
310
311 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
312 bool wxTopLevelWindowMSW::HandleSettingChange(WXWPARAM wParam, WXLPARAM lParam)
313 {
314 SHACTIVATEINFO *info = (SHACTIVATEINFO*) m_activateInfo;
315 if ( info )
316 {
317 SHHandleWMSettingChange(GetHwnd(), wParam, lParam, info);
318 }
319
320 return wxWindowMSW::HandleSettingChange(wParam, lParam);
321 }
322 #endif
323
324 WXLRESULT wxTopLevelWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
325 {
326 WXLRESULT rc = 0;
327 bool processed = false;
328
329 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
330 switch ( message )
331 {
332 case WM_ACTIVATE:
333 {
334 SHACTIVATEINFO* info = (SHACTIVATEINFO*) m_activateInfo;
335 if (info)
336 {
337 DWORD flags = 0;
338 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) flags = SHA_INPUTDIALOG;
339 SHHandleWMActivate(GetHwnd(), wParam, lParam, info, flags);
340 }
341
342 // This implicitly sends a wxEVT_ACTIVATE_APP event
343 if (wxTheApp)
344 wxTheApp->SetActive(wParam != 0, FindFocus());
345
346 break;
347 }
348 case WM_HIBERNATE:
349 {
350 if (wxTheApp)
351 {
352 wxActivateEvent event(wxEVT_HIBERNATE, true, wxID_ANY);
353 event.SetEventObject(wxTheApp);
354 processed = wxTheApp->ProcessEvent(event);
355 }
356 break;
357 }
358 }
359 #endif
360
361 if ( !processed )
362 rc = wxTopLevelWindowBase::MSWWindowProc(message, wParam, lParam);
363
364 return rc;
365 }
366
367 bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate,
368 const wxString& title,
369 const wxPoint& pos,
370 const wxSize& size)
371 {
372 #ifdef __WXMICROWIN__
373 // no dialogs support under MicroWin yet
374 return CreateFrame(title, pos, size);
375 #else // !__WXMICROWIN__
376 // static cast is valid as we're only ever called for dialogs
377 wxWindow * const
378 parent = static_cast<wxDialog *>(this)->
379 GetParentForModalDialog(GetParent());
380
381 m_hWnd = (WXHWND)::CreateDialogIndirect
382 (
383 wxGetInstance(),
384 (DLGTEMPLATE*)dlgTemplate,
385 parent ? GetHwndOf(parent) : NULL,
386 (DLGPROC)wxDlgProc
387 );
388
389 if ( !m_hWnd )
390 {
391 wxFAIL_MSG(wxT("Failed to create dialog. Incorrect DLGTEMPLATE?"));
392
393 wxLogSysError(wxT("Can't create dialog using memory template"));
394
395 return false;
396 }
397
398 #if !defined(__WXWINCE__)
399 // For some reason, the system menu is activated when we use the
400 // WS_EX_CONTEXTHELP style, so let's set a reasonable icon
401 if ( HasExtraStyle(wxWS_EX_CONTEXTHELP) )
402 {
403 wxFrame *winTop = wxDynamicCast(wxTheApp->GetTopWindow(), wxFrame);
404 if ( winTop )
405 {
406 wxIcon icon = winTop->GetIcon();
407 if ( icon.Ok() )
408 {
409 ::SendMessage(GetHwnd(), WM_SETICON,
410 (WPARAM)TRUE,
411 (LPARAM)GetHiconOf(icon));
412 }
413 }
414 }
415 #endif // !__WXWINCE__
416
417 // move the dialog to its initial position without forcing repainting
418 int x, y, w, h;
419 (void)MSWGetCreateWindowCoords(pos, size, x, y, w, h);
420
421 if ( x == (int)CW_USEDEFAULT )
422 {
423 // centre it on the screen - what else can we do?
424 wxSize sizeDpy = wxGetDisplaySize();
425
426 x = (sizeDpy.x - w) / 2;
427 y = (sizeDpy.y - h) / 2;
428 }
429
430 #if !defined(__WXWINCE__) || defined(__WINCE_STANDARDSDK__)
431 if ( !::MoveWindow(GetHwnd(), x, y, w, h, FALSE) )
432 {
433 wxLogLastError(wxT("MoveWindow"));
434 }
435 #endif
436
437 if ( !title.empty() )
438 {
439 ::SetWindowText(GetHwnd(), title.wx_str());
440 }
441
442 SubclassWin(m_hWnd);
443
444 #ifdef __SMARTPHONE__
445 // Work around title non-display glitch
446 Show(false);
447 #endif
448
449 return true;
450 #endif // __WXMICROWIN__/!__WXMICROWIN__
451 }
452
453 bool wxTopLevelWindowMSW::CreateFrame(const wxString& title,
454 const wxPoint& pos,
455 const wxSize& size)
456 {
457 WXDWORD exflags;
458 WXDWORD flags = MSWGetCreateWindowFlags(&exflags);
459
460 const wxSize sz = IsAlwaysMaximized() ? wxDefaultSize : size;
461
462 #ifndef __WXWINCE__
463 if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft )
464 exflags |= WS_EX_LAYOUTRTL;
465 #endif
466
467 return MSWCreate(MSWGetRegisteredClassName(),
468 title.wx_str(), pos, sz, flags, exflags);
469 }
470
471 bool wxTopLevelWindowMSW::Create(wxWindow *parent,
472 wxWindowID id,
473 const wxString& title,
474 const wxPoint& pos,
475 const wxSize& size,
476 long style,
477 const wxString& name)
478 {
479 bool ret wxDUMMY_INITIALIZE(false);
480
481 wxSize sizeReal = size;
482 if ( !sizeReal.IsFullySpecified() )
483 {
484 sizeReal.SetDefaults(GetDefaultSize());
485 }
486
487 m_windowStyle = style;
488
489 SetName(name);
490
491 m_windowId = id == wxID_ANY ? NewControlId() : id;
492
493 wxTopLevelWindows.Append(this);
494
495 if ( parent )
496 parent->AddChild(this);
497
498 if ( GetExtraStyle() & wxTOPLEVEL_EX_DIALOG )
499 {
500 // we have different dialog templates to allows creation of dialogs
501 // with & without captions under MSWindows, resizeable or not (but a
502 // resizeable dialog always has caption - otherwise it would look too
503 // strange)
504
505 // we need 3 additional WORDs for dialog menu, class and title (as we
506 // don't use DS_SETFONT we don't need the fourth WORD for the font)
507 static const int dlgsize = sizeof(DLGTEMPLATE) + (sizeof(WORD) * 3);
508 DLGTEMPLATE *dlgTemplate = (DLGTEMPLATE *)malloc(dlgsize);
509 memset(dlgTemplate, 0, dlgsize);
510
511 // these values are arbitrary, they won't be used normally anyhow
512 dlgTemplate->x = 34;
513 dlgTemplate->y = 22;
514 dlgTemplate->cx = 144;
515 dlgTemplate->cy = 75;
516
517 // reuse the code in MSWGetStyle() but correct the results slightly for
518 // the dialog
519 //
520 // NB: we need a temporary variable as we can't pass pointer to
521 // dwExtendedStyle directly, it's not aligned correctly for 64 bit
522 // architectures
523 WXDWORD dwExtendedStyle;
524 dlgTemplate->style = MSWGetStyle(style, &dwExtendedStyle);
525 dlgTemplate->dwExtendedStyle = dwExtendedStyle;
526
527 // all dialogs are popups
528 dlgTemplate->style |= WS_POPUP;
529
530 #ifndef __WXWINCE__
531 if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft )
532 {
533 dlgTemplate->dwExtendedStyle |= WS_EX_LAYOUTRTL;
534 }
535
536 // force 3D-look if necessary, it looks impossibly ugly otherwise
537 if ( style & (wxRESIZE_BORDER | wxCAPTION) )
538 dlgTemplate->style |= DS_MODALFRAME;
539 #endif
540
541 ret = CreateDialog(dlgTemplate, title, pos, sizeReal);
542 free(dlgTemplate);
543 }
544 else // !dialog
545 {
546 ret = CreateFrame(title, pos, sizeReal);
547 }
548
549 #ifndef __WXWINCE__
550 if ( ret && !(GetWindowStyleFlag() & wxCLOSE_BOX) )
551 {
552 EnableCloseButton(false);
553 }
554 #endif
555
556 // for standard dialogs the dialog manager generates WM_CHANGEUISTATE
557 // itself but for custom windows we have to do it ourselves in order to
558 // make the keyboard indicators (such as underlines for accelerators and
559 // focus rectangles) work under Win2k+
560 if ( ret )
561 {
562 MSWUpdateUIState(UIS_INITIALIZE);
563 }
564
565 // Note: if we include PocketPC in this test, dialogs can fail to show up,
566 // for example the text entry dialog in the dialogs sample. Problem with Maximise()?
567 #if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__WINCE_STANDARDSDK__))
568 if ( ( style & wxMAXIMIZE ) || IsAlwaysMaximized() )
569 {
570 this->Maximize();
571 }
572 #endif
573
574 #if defined(__SMARTPHONE__) && defined(__WXWINCE__)
575 SetRightMenu(); // to nothing for initialization
576 #endif
577
578 return ret;
579 }
580
581 wxTopLevelWindowMSW::~wxTopLevelWindowMSW()
582 {
583 SendDestroyEvent();
584
585 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
586 SHACTIVATEINFO* info = (SHACTIVATEINFO*) m_activateInfo;
587 delete info;
588 m_activateInfo = NULL;
589 #endif
590
591 // after destroying an owned window, Windows activates the next top level
592 // window in Z order but it may be different from our owner (to reproduce
593 // this simply Alt-TAB to another application and back before closing the
594 // owned frame) whereas we always want to yield activation to our parent
595 if ( HasFlag(wxFRAME_FLOAT_ON_PARENT) )
596 {
597 wxWindow *parent = GetParent();
598 if ( parent )
599 {
600 ::BringWindowToTop(GetHwndOf(parent));
601 }
602 }
603 }
604
605 // ----------------------------------------------------------------------------
606 // wxTopLevelWindowMSW showing
607 // ----------------------------------------------------------------------------
608
609 void wxTopLevelWindowMSW::DoShowWindow(int nShowCmd)
610 {
611 ::ShowWindow(GetHwnd(), nShowCmd);
612
613 m_iconized = nShowCmd == SW_MINIMIZE;
614 }
615
616 bool wxTopLevelWindowMSW::Show(bool show)
617 {
618 // don't use wxWindow version as we want to call DoShowWindow() ourselves
619 if ( !wxWindowBase::Show(show) )
620 return false;
621
622 int nShowCmd;
623 if ( show )
624 {
625 if ( m_maximizeOnShow )
626 {
627 // show and maximize
628 nShowCmd = SW_MAXIMIZE;
629
630 // This is necessary, or no window appears
631 #if defined( __WINCE_STANDARDSDK__) || defined(__SMARTPHONE__)
632 DoShowWindow(SW_SHOW);
633 #endif
634
635 m_maximizeOnShow = false;
636 }
637 else if ( m_iconized )
638 {
639 // iconize and show
640 nShowCmd = SW_MINIMIZE;
641 }
642 else // just show
643 {
644 // we shouldn't use SW_SHOW which also activates the window for
645 // tool frames (as they shouldn't steal focus from the main window)
646 // nor for the currently disabled windows as they would be enabled
647 // as a side effect
648 if ( HasFlag(wxFRAME_TOOL_WINDOW) || !IsEnabled() )
649 nShowCmd = SW_SHOWNA;
650 else
651 nShowCmd = SW_SHOW;
652 }
653 }
654 else // hide
655 {
656 nShowCmd = SW_HIDE;
657 }
658
659 DoShowWindow(nShowCmd);
660
661 #if defined(__WXWINCE__) && (_WIN32_WCE >= 400 && !defined(__POCKETPC__) && !defined(__SMARTPHONE__))
662 // Addornments have to be added when the frame is the correct size
663 wxFrame* frame = wxDynamicCast(this, wxFrame);
664 if (frame && frame->GetMenuBar())
665 frame->GetMenuBar()->AddAdornments(GetWindowStyleFlag());
666 #endif
667
668 // we only set pending size if we're maximized before being shown, now that
669 // we're shown we don't need it any more (it is reset in size event handler
670 // for child windows but we have to do it ourselves for this parent window)
671 m_pendingSize = wxDefaultSize;
672
673 return true;
674 }
675
676 // ----------------------------------------------------------------------------
677 // wxTopLevelWindowMSW maximize/minimize
678 // ----------------------------------------------------------------------------
679
680 void wxTopLevelWindowMSW::Maximize(bool maximize)
681 {
682 if ( IsShown() )
683 {
684 // just maximize it directly
685 DoShowWindow(maximize ? SW_MAXIMIZE : SW_RESTORE);
686 }
687 else // hidden
688 {
689 // we can't maximize the hidden frame because it shows it as well,
690 // so just remember that we should do it later in this case
691 m_maximizeOnShow = maximize;
692
693 // after calling Maximize() the client code expects to get the frame
694 // "real" size and doesn't want to know that, because of implementation
695 // details, the frame isn't really maximized yet but will be only once
696 // it's shown, so return our size as it will be then in this case
697 if ( maximize )
698 {
699 // we must only change pending size here, and not call SetSize()
700 // because otherwise Windows would think that this (full screen)
701 // size is the natural size for the frame and so would use it when
702 // the user clicks on "restore" title bar button instead of the
703 // correct initial frame size
704 //
705 // NB: unfortunately we don't know which display we're on yet so we
706 // have to use the default one
707 m_pendingSize = wxGetClientDisplayRect().GetSize();
708 }
709 //else: can't do anything in this case, we don't have the old size
710 }
711 }
712
713 bool wxTopLevelWindowMSW::IsMaximized() const
714 {
715 return IsAlwaysMaximized() ||
716 #if !defined(__SMARTPHONE__) && !defined(__POCKETPC__) && !defined(__WINCE_STANDARDSDK__)
717
718 (::IsZoomed(GetHwnd()) != 0) ||
719 #endif
720 m_maximizeOnShow;
721 }
722
723 void wxTopLevelWindowMSW::Iconize(bool iconize)
724 {
725 if ( IsShown() )
726 {
727 // change the window state immediately
728 DoShowWindow(iconize ? SW_MINIMIZE : SW_RESTORE);
729 }
730 else // hidden
731 {
732 // iconizing the window shouldn't show it so just remember that we need
733 // to become iconized when shown later
734 m_iconized = true;
735 }
736 }
737
738 bool wxTopLevelWindowMSW::IsIconized() const
739 {
740 #ifdef __WXWINCE__
741 return false;
742 #else
743 if ( !IsShown() )
744 return m_iconized;
745
746 // don't use m_iconized, it may be briefly out of sync with the real state
747 // as it's only modified when we receive a WM_SIZE and we could be called
748 // from an event handler from one of the messages we receive before it,
749 // such as WM_MOVE
750 return ::IsIconic(GetHwnd()) != 0;
751 #endif
752 }
753
754 void wxTopLevelWindowMSW::Restore()
755 {
756 DoShowWindow(SW_RESTORE);
757 }
758
759 void wxTopLevelWindowMSW::SetLayoutDirection(wxLayoutDirection dir)
760 {
761 if ( dir == wxLayout_Default )
762 dir = wxTheApp->GetLayoutDirection();
763
764 if ( dir != wxLayout_Default )
765 wxTopLevelWindowBase::SetLayoutDirection(dir);
766 }
767
768 // ----------------------------------------------------------------------------
769 // wxTopLevelWindowMSW geometry
770 // ----------------------------------------------------------------------------
771
772 #ifndef __WXWINCE__
773
774 void wxTopLevelWindowMSW::DoGetPosition(int *x, int *y) const
775 {
776 if ( IsIconized() )
777 {
778 WINDOWPLACEMENT wp;
779 wp.length = sizeof(WINDOWPLACEMENT);
780 if ( ::GetWindowPlacement(GetHwnd(), &wp) )
781 {
782 RECT& rc = wp.rcNormalPosition;
783
784 // the position returned by GetWindowPlacement() is in workspace
785 // coordinates except for windows with WS_EX_TOOLWINDOW style
786 if ( !HasFlag(wxFRAME_TOOL_WINDOW) )
787 {
788 // we must use the correct display for the translation as the
789 // task bar might be shown on one display but not the other one
790 int n = wxDisplay::GetFromWindow(this);
791 wxDisplay dpy(n == wxNOT_FOUND ? 0 : n);
792 const wxPoint ptOfs = dpy.GetClientArea().GetPosition() -
793 dpy.GetGeometry().GetPosition();
794
795 rc.left += ptOfs.x;
796 rc.top += ptOfs.y;
797 }
798
799 if ( x )
800 *x = rc.left;
801 if ( y )
802 *y = rc.top;
803
804 return;
805 }
806
807 wxLogLastError(_T("GetWindowPlacement"));
808 }
809 //else: normal case
810
811 wxTopLevelWindowBase::DoGetPosition(x, y);
812 }
813
814 void wxTopLevelWindowMSW::DoGetSize(int *width, int *height) const
815 {
816 if ( IsIconized() )
817 {
818 WINDOWPLACEMENT wp;
819 wp.length = sizeof(WINDOWPLACEMENT);
820 if ( ::GetWindowPlacement(GetHwnd(), &wp) )
821 {
822 const RECT& rc = wp.rcNormalPosition;
823
824 if ( width )
825 *width = rc.right - rc.left;
826 if ( height )
827 *height = rc.bottom - rc.top;
828
829 return;
830 }
831
832 wxLogLastError(_T("GetWindowPlacement"));
833 }
834 //else: normal case
835
836 wxTopLevelWindowBase::DoGetSize(width, height);
837 }
838
839 #endif // __WXWINCE__
840
841 // ----------------------------------------------------------------------------
842 // wxTopLevelWindowMSW fullscreen
843 // ----------------------------------------------------------------------------
844
845 bool wxTopLevelWindowMSW::ShowFullScreen(bool show, long style)
846 {
847 if ( show == IsFullScreen() )
848 {
849 // nothing to do
850 return true;
851 }
852
853 m_fsIsShowing = show;
854
855 if ( show )
856 {
857 m_fsStyle = style;
858
859 // zap the frame borders
860
861 // save the 'normal' window style
862 m_fsOldWindowStyle = GetWindowLong(GetHwnd(), GWL_STYLE);
863
864 // save the old position, width & height, maximize state
865 m_fsOldSize = GetRect();
866 m_fsIsMaximized = IsMaximized();
867
868 // decide which window style flags to turn off
869 LONG newStyle = m_fsOldWindowStyle;
870 LONG offFlags = 0;
871
872 if (style & wxFULLSCREEN_NOBORDER)
873 {
874 offFlags |= WS_BORDER;
875 #ifndef __WXWINCE__
876 offFlags |= WS_THICKFRAME;
877 #endif
878 }
879 if (style & wxFULLSCREEN_NOCAPTION)
880 offFlags |= WS_CAPTION | WS_SYSMENU;
881
882 newStyle &= ~offFlags;
883
884 // change our window style to be compatible with full-screen mode
885 ::SetWindowLong(GetHwnd(), GWL_STYLE, newStyle);
886
887 wxRect rect;
888 #if wxUSE_DISPLAY
889 // resize to the size of the display containing us
890 int dpy = wxDisplay::GetFromWindow(this);
891 if ( dpy != wxNOT_FOUND )
892 {
893 rect = wxDisplay(dpy).GetGeometry();
894 }
895 else // fall back to the main desktop
896 #endif // wxUSE_DISPLAY
897 {
898 // resize to the size of the desktop
899 wxCopyRECTToRect(wxGetWindowRect(::GetDesktopWindow()), rect);
900 #ifdef __WXWINCE__
901 // FIXME: size of the bottom menu (toolbar)
902 // should be taken in account
903 rect.height += rect.y;
904 rect.y = 0;
905 #endif
906 }
907
908 SetSize(rect);
909
910 // now flush the window style cache and actually go full-screen
911 long flags = SWP_FRAMECHANGED;
912
913 // showing the frame full screen should also show it if it's still
914 // hidden
915 if ( !IsShown() )
916 {
917 // don't call wxWindow version to avoid flicker from calling
918 // ::ShowWindow() -- we're going to show the window at the correct
919 // location directly below -- but do call the wxWindowBase version
920 // to sync the internal m_isShown flag
921 wxWindowBase::Show();
922
923 flags |= SWP_SHOWWINDOW;
924 }
925
926 SetWindowPos(GetHwnd(), HWND_TOP,
927 rect.x, rect.y, rect.width, rect.height,
928 flags);
929
930 #if !defined(__HANDHELDPC__) && (defined(__WXWINCE__) && (_WIN32_WCE < 400))
931 ::SHFullScreen(GetHwnd(), SHFS_HIDETASKBAR | SHFS_HIDESIPBUTTON);
932 #endif
933
934 // finally send an event allowing the window to relayout itself &c
935 wxSizeEvent event(rect.GetSize(), GetId());
936 HandleWindowEvent(event);
937 }
938 else // stop showing full screen
939 {
940 #if !defined(__HANDHELDPC__) && (defined(__WXWINCE__) && (_WIN32_WCE < 400))
941 ::SHFullScreen(GetHwnd(), SHFS_SHOWTASKBAR | SHFS_SHOWSIPBUTTON);
942 #endif
943 Maximize(m_fsIsMaximized);
944 SetWindowLong(GetHwnd(),GWL_STYLE, m_fsOldWindowStyle);
945 SetWindowPos(GetHwnd(),HWND_TOP,m_fsOldSize.x, m_fsOldSize.y,
946 m_fsOldSize.width, m_fsOldSize.height, SWP_FRAMECHANGED);
947 }
948
949 return true;
950 }
951
952 // ----------------------------------------------------------------------------
953 // wxTopLevelWindowMSW misc
954 // ----------------------------------------------------------------------------
955
956 void wxTopLevelWindowMSW::SetTitle( const wxString& title)
957 {
958 SetLabel(title);
959 }
960
961 wxString wxTopLevelWindowMSW::GetTitle() const
962 {
963 return GetLabel();
964 }
965
966 bool wxTopLevelWindowMSW::DoSelectAndSetIcon(const wxIconBundle& icons,
967 int smX,
968 int smY,
969 int i)
970 {
971 const wxSize size(::GetSystemMetrics(smX), ::GetSystemMetrics(smY));
972
973 const wxIcon icon = icons.GetIconOfExactSize(size);
974 if ( icon.Ok() )
975 {
976 ::SendMessage(GetHwnd(), WM_SETICON, i, (LPARAM)GetHiconOf(icon));
977 return true;
978 }
979
980 return false;
981 }
982
983 void wxTopLevelWindowMSW::SetIcons(const wxIconBundle& icons)
984 {
985 wxTopLevelWindowBase::SetIcons(icons);
986
987 if ( icons.IsEmpty() )
988 {
989 // FIXME: SetIcons(wxNullIconBundle) should unset existing icons,
990 // but we currently don't do that
991 wxASSERT_MSG( m_icons.IsEmpty(), "unsetting icons doesn't work" );
992 return;
993 }
994
995 bool anySet =
996 DoSelectAndSetIcon(icons, SM_CXSMICON, SM_CYSMICON, ICON_SMALL);
997 if ( DoSelectAndSetIcon(icons, SM_CXICON, SM_CYICON, ICON_BIG) )
998 anySet = true;
999
1000 if ( !anySet )
1001 {
1002 wxFAIL_MSG( "icon bundle doesn't contain any suitable icon" );
1003 }
1004 }
1005
1006 bool wxTopLevelWindowMSW::EnableCloseButton(bool enable)
1007 {
1008 #if !defined(__WXMICROWIN__)
1009 // get system (a.k.a. window) menu
1010 HMENU hmenu = GetSystemMenu(GetHwnd(), FALSE /* get it */);
1011 if ( !hmenu )
1012 {
1013 // no system menu at all -- ok if we want to remove the close button
1014 // anyhow, but bad if we want to show it
1015 return !enable;
1016 }
1017
1018 // enabling/disabling the close item from it also automatically
1019 // disables/enables the close title bar button
1020 if ( ::EnableMenuItem(hmenu, SC_CLOSE,
1021 MF_BYCOMMAND |
1022 (enable ? MF_ENABLED : MF_GRAYED)) == -1 )
1023 {
1024 wxLogLastError(_T("EnableMenuItem(SC_CLOSE)"));
1025
1026 return false;
1027 }
1028 #ifndef __WXWINCE__
1029 // update appearance immediately
1030 if ( !::DrawMenuBar(GetHwnd()) )
1031 {
1032 wxLogLastError(_T("DrawMenuBar"));
1033 }
1034 #endif
1035 #endif // !__WXMICROWIN__
1036
1037 return true;
1038 }
1039
1040 #ifndef __WXWINCE__
1041
1042 bool wxTopLevelWindowMSW::SetShape(const wxRegion& region)
1043 {
1044 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
1045 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1046
1047 // The empty region signifies that the shape should be removed from the
1048 // window.
1049 if ( region.IsEmpty() )
1050 {
1051 if (::SetWindowRgn(GetHwnd(), NULL, TRUE) == 0)
1052 {
1053 wxLogLastError(_T("SetWindowRgn"));
1054 return false;
1055 }
1056 return true;
1057 }
1058
1059 // Windows takes ownership of the region, so
1060 // we'll have to make a copy of the region to give to it.
1061 DWORD noBytes = ::GetRegionData(GetHrgnOf(region), 0, NULL);
1062 RGNDATA *rgnData = (RGNDATA*) new char[noBytes];
1063 ::GetRegionData(GetHrgnOf(region), noBytes, rgnData);
1064 HRGN hrgn = ::ExtCreateRegion(NULL, noBytes, rgnData);
1065 delete[] (char*) rgnData;
1066
1067 // SetWindowRgn expects the region to be in coordinants
1068 // relative to the window, not the client area. Figure
1069 // out the offset, if any.
1070 RECT rect;
1071 DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE);
1072 DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
1073 ::GetClientRect(GetHwnd(), &rect);
1074 ::AdjustWindowRectEx(&rect, dwStyle, ::GetMenu(GetHwnd()) != NULL, dwExStyle);
1075 ::OffsetRgn(hrgn, -rect.left, -rect.top);
1076
1077 // Now call the shape API with the new region.
1078 if (::SetWindowRgn(GetHwnd(), hrgn, TRUE) == 0)
1079 {
1080 wxLogLastError(_T("SetWindowRgn"));
1081 return false;
1082 }
1083 return true;
1084 }
1085
1086 #endif // !__WXWINCE__
1087
1088 void wxTopLevelWindowMSW::RequestUserAttention(int flags)
1089 {
1090 // check if we can use FlashWindowEx(): unfortunately a simple test for
1091 // FLASHW_STOP doesn't work because MSVC6 headers do #define it but don't
1092 // provide FlashWindowEx() declaration, so try to detect whether we have
1093 // real headers for WINVER 0x0500 by checking for existence of a symbol not
1094 // declated in MSVC6 header
1095 #if defined(FLASHW_STOP) && defined(VK_XBUTTON1) && wxUSE_DYNLIB_CLASS
1096 // available in the headers, check if it is supported by the system
1097 typedef BOOL (WINAPI *FlashWindowEx_t)(FLASHWINFO *pfwi);
1098 static FlashWindowEx_t s_pfnFlashWindowEx = NULL;
1099 if ( !s_pfnFlashWindowEx )
1100 {
1101 wxDynamicLibrary dllUser32(_T("user32.dll"));
1102 s_pfnFlashWindowEx = (FlashWindowEx_t)
1103 dllUser32.GetSymbol(_T("FlashWindowEx"));
1104
1105 // we can safely unload user32.dll here, it's going to remain loaded as
1106 // long as the program is running anyhow
1107 }
1108
1109 if ( s_pfnFlashWindowEx )
1110 {
1111 WinStruct<FLASHWINFO> fwi;
1112 fwi.hwnd = GetHwnd();
1113 fwi.dwFlags = FLASHW_ALL;
1114 if ( flags & wxUSER_ATTENTION_INFO )
1115 {
1116 // just flash a few times
1117 fwi.uCount = 3;
1118 }
1119 else // wxUSER_ATTENTION_ERROR
1120 {
1121 // flash until the user notices it
1122 fwi.dwFlags |= FLASHW_TIMERNOFG;
1123 }
1124
1125 s_pfnFlashWindowEx(&fwi);
1126 }
1127 else // FlashWindowEx() not available
1128 #endif // FlashWindowEx() defined
1129 {
1130 wxUnusedVar(flags);
1131 #ifndef __WXWINCE__
1132 ::FlashWindow(GetHwnd(), TRUE);
1133 #endif // __WXWINCE__
1134 }
1135 }
1136
1137 // ---------------------------------------------------------------------------
1138
1139 bool wxTopLevelWindowMSW::SetTransparent(wxByte alpha)
1140 {
1141 #if wxUSE_DYNLIB_CLASS
1142 typedef DWORD (WINAPI *PSETLAYEREDWINDOWATTR)(HWND, DWORD, BYTE, DWORD);
1143 static PSETLAYEREDWINDOWATTR
1144 pSetLayeredWindowAttributes = (PSETLAYEREDWINDOWATTR)-1;
1145
1146 if ( pSetLayeredWindowAttributes == (PSETLAYEREDWINDOWATTR)-1 )
1147 {
1148 wxDynamicLibrary dllUser32(_T("user32.dll"));
1149
1150 // use RawGetSymbol() and not GetSymbol() to avoid error messages under
1151 // Windows 95: there is nothing the user can do about this anyhow
1152 pSetLayeredWindowAttributes = (PSETLAYEREDWINDOWATTR)
1153 dllUser32.RawGetSymbol(wxT("SetLayeredWindowAttributes"));
1154
1155 // it's ok to destroy dllUser32 here, we link statically to user32.dll
1156 // anyhow so it won't be unloaded
1157 }
1158
1159 if ( !pSetLayeredWindowAttributes )
1160 return false;
1161 #endif // wxUSE_DYNLIB_CLASS
1162
1163 LONG exstyle = GetWindowLong(GetHwnd(), GWL_EXSTYLE);
1164
1165 // if setting alpha to fully opaque then turn off the layered style
1166 if (alpha == 255)
1167 {
1168 SetWindowLong(GetHwnd(), GWL_EXSTYLE, exstyle & ~WS_EX_LAYERED);
1169 Refresh();
1170 return true;
1171 }
1172
1173 #if wxUSE_DYNLIB_CLASS
1174 // Otherwise, set the layered style if needed and set the alpha value
1175 if ((exstyle & WS_EX_LAYERED) == 0 )
1176 SetWindowLong(GetHwnd(), GWL_EXSTYLE, exstyle | WS_EX_LAYERED);
1177
1178 if ( pSetLayeredWindowAttributes(GetHwnd(), 0, (BYTE)alpha, LWA_ALPHA) )
1179 return true;
1180 #endif // wxUSE_DYNLIB_CLASS
1181
1182 return false;
1183 }
1184
1185 bool wxTopLevelWindowMSW::CanSetTransparent()
1186 {
1187 // The API is available on win2k and above
1188
1189 static int os_type = -1;
1190 static int ver_major = -1;
1191
1192 if (os_type == -1)
1193 os_type = ::wxGetOsVersion(&ver_major);
1194
1195 return (os_type == wxOS_WINDOWS_NT && ver_major >= 5);
1196 }
1197
1198
1199 void wxTopLevelWindowMSW::DoFreeze()
1200 {
1201 // do nothing: freezing toplevel window causes paint and mouse events
1202 // to go through it any TLWs under it, so the best we can do is to freeze
1203 // all children -- and wxWindowBase::Freeze() does that
1204 }
1205
1206 void wxTopLevelWindowMSW::DoThaw()
1207 {
1208 // intentionally empty -- see DoFreeze()
1209 }
1210
1211
1212 // ----------------------------------------------------------------------------
1213 // wxTopLevelWindow event handling
1214 // ----------------------------------------------------------------------------
1215
1216 // Default activation behaviour - set the focus for the first child
1217 // subwindow found.
1218 void wxTopLevelWindowMSW::OnActivate(wxActivateEvent& event)
1219 {
1220 if ( event.GetActive() )
1221 {
1222 // restore focus to the child which was last focused unless we already
1223 // have it
1224 wxLogTrace(_T("focus"), _T("wxTLW %p activated."), m_hWnd);
1225
1226 wxWindow *winFocus = FindFocus();
1227 if ( !winFocus || wxGetTopLevelParent(winFocus) != this )
1228 {
1229 wxWindow *parent = m_winLastFocused ? m_winLastFocused->GetParent()
1230 : NULL;
1231 if ( !parent )
1232 {
1233 parent = this;
1234 }
1235
1236 wxSetFocusToChild(parent, &m_winLastFocused);
1237 }
1238 }
1239 else // deactivating
1240 {
1241 // remember the last focused child if it is our child
1242 m_winLastFocused = FindFocus();
1243
1244 if ( m_winLastFocused )
1245 {
1246 // let it know that it doesn't have focus any more
1247 // But this will already be done via WM_KILLFOCUS, so we'll get two kill
1248 // focus events if we call it explicitly.
1249 // m_winLastFocused->HandleKillFocus((WXHWND)NULL);
1250
1251 // and don't remember it if it's a child from some other frame
1252 if ( wxGetTopLevelParent(m_winLastFocused) != this )
1253 {
1254 m_winLastFocused = NULL;
1255 }
1256 }
1257
1258 wxLogTrace(_T("focus"),
1259 _T("wxTLW %p deactivated, last focused: %p."),
1260 m_hWnd,
1261 m_winLastFocused ? GetHwndOf(m_winLastFocused) : NULL);
1262
1263 event.Skip();
1264 }
1265 }
1266
1267 // the DialogProc for all wxWidgets dialogs
1268 LONG APIENTRY _EXPORT
1269 wxDlgProc(HWND hDlg,
1270 UINT message,
1271 WPARAM WXUNUSED(wParam),
1272 LPARAM WXUNUSED(lParam))
1273 {
1274 switch ( message )
1275 {
1276 case WM_INITDIALOG:
1277 {
1278 // under CE, add a "Ok" button in the dialog title bar and make it full
1279 // screen
1280 //
1281 // TODO: find the window for this HWND, and take into account
1282 // wxMAXIMIZE and wxCLOSE_BOX. For now, assume both are present.
1283 //
1284 // Standard SDK doesn't have aygshell.dll: see
1285 // include/wx/msw/wince/libraries.h
1286 #if defined(__WXWINCE__) && !defined(__WINCE_STANDARDSDK__) && !defined(__HANDHELDPC__)
1287 SHINITDLGINFO shidi;
1288 shidi.dwMask = SHIDIM_FLAGS;
1289 shidi.dwFlags = SHIDIF_SIZEDLG // take account of the SIP or menubar
1290 #ifndef __SMARTPHONE__
1291 | SHIDIF_DONEBUTTON
1292 #endif
1293 ;
1294 shidi.hDlg = hDlg;
1295 SHInitDialog( &shidi );
1296 #else // no SHInitDialog()
1297 wxUnusedVar(hDlg);
1298 #endif
1299 // for WM_INITDIALOG, returning TRUE tells system to set focus to
1300 // the first control in the dialog box, but as we set the focus
1301 // ourselves, we return FALSE for it as well
1302 return FALSE;
1303 }
1304 }
1305
1306 // for almost all messages, returning FALSE means that we didn't process
1307 // the message
1308 return FALSE;
1309 }
1310
1311 // ============================================================================
1312 // wxTLWHiddenParentModule implementation
1313 // ============================================================================
1314
1315 HWND wxTLWHiddenParentModule::ms_hwnd = NULL;
1316
1317 const wxChar *wxTLWHiddenParentModule::ms_className = NULL;
1318
1319 bool wxTLWHiddenParentModule::OnInit()
1320 {
1321 ms_hwnd = NULL;
1322 ms_className = NULL;
1323
1324 return true;
1325 }
1326
1327 void wxTLWHiddenParentModule::OnExit()
1328 {
1329 if ( ms_hwnd )
1330 {
1331 if ( !::DestroyWindow(ms_hwnd) )
1332 {
1333 wxLogLastError(_T("DestroyWindow(hidden TLW parent)"));
1334 }
1335
1336 ms_hwnd = NULL;
1337 }
1338
1339 if ( ms_className )
1340 {
1341 if ( !::UnregisterClass(ms_className, wxGetInstance()) )
1342 {
1343 wxLogLastError(_T("UnregisterClass(\"wxTLWHiddenParent\")"));
1344 }
1345
1346 ms_className = NULL;
1347 }
1348 }
1349
1350 /* static */
1351 HWND wxTLWHiddenParentModule::GetHWND()
1352 {
1353 if ( !ms_hwnd )
1354 {
1355 if ( !ms_className )
1356 {
1357 static const wxChar *HIDDEN_PARENT_CLASS = _T("wxTLWHiddenParent");
1358
1359 WNDCLASS wndclass;
1360 wxZeroMemory(wndclass);
1361
1362 wndclass.lpfnWndProc = DefWindowProc;
1363 wndclass.hInstance = wxGetInstance();
1364 wndclass.lpszClassName = HIDDEN_PARENT_CLASS;
1365
1366 if ( !::RegisterClass(&wndclass) )
1367 {
1368 wxLogLastError(_T("RegisterClass(\"wxTLWHiddenParent\")"));
1369 }
1370 else
1371 {
1372 ms_className = HIDDEN_PARENT_CLASS;
1373 }
1374 }
1375
1376 ms_hwnd = ::CreateWindow(ms_className, wxEmptyString, 0, 0, 0, 0, 0, NULL,
1377 (HMENU)NULL, wxGetInstance(), NULL);
1378 if ( !ms_hwnd )
1379 {
1380 wxLogLastError(_T("CreateWindow(hidden TLW parent)"));
1381 }
1382 }
1383
1384 return ms_hwnd;
1385 }