+ //else: normal case
+
+ wxTopLevelWindowBase::DoGetSize(width, height);
+}
+
+#endif // __WXWINCE__
+
+void
+wxTopLevelWindowMSW::MSWGetCreateWindowCoords(const wxPoint& pos,
+ const wxSize& size,
+ int& x, int& y,
+ int& w, int& h) const
+{
+ // let the system position the window if no explicit position was specified
+ if ( pos.x == wxDefaultCoord )
+ {
+ // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
+ // can just as well set it to CW_USEDEFAULT as well
+ x =
+ y = CW_USEDEFAULT;
+ }
+ else
+ {
+ // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
+ // neither because it is not handled as a special value by Windows then
+ // and so we have to choose some default value for it, even if a
+ // completely arbitrary one
+ static const int DEFAULT_Y = 200;
+
+ x = pos.x;
+ y = pos.y == wxDefaultCoord ? DEFAULT_Y : pos.y;
+ }
+
+ if ( size.x == wxDefaultCoord || size.y == wxDefaultCoord )
+ {
+ // We don't use CW_USEDEFAULT here for several reasons:
+ //
+ // 1. It results in huge frames on modern screens (1000*800 is not
+ // uncommon on my 1280*1024 screen) which is way too big for a half
+ // empty frame of most of wxWidgets samples for example)
+ //
+ // 2. It is buggy for frames with wxFRAME_TOOL_WINDOW style for which
+ // the default is for whatever reason 8*8 which breaks client <->
+ // window size calculations (it would be nice if it didn't, but it
+ // does and the simplest way to fix it seemed to change the broken
+ // default size anyhow)
+ //
+ // 3. There is just no advantage in doing it: with x and y it is
+ // possible that [future versions of] Windows position the new top
+ // level window in some smart way which we can't do, but we can
+ // guess a reasonably good size for a new window just as well
+ // ourselves
+ //
+ // The only exception is for the Windows CE platform where the system
+ // does know better than we how should the windows be sized
+#ifdef _WIN32_WCE
+ w =
+ h = CW_USEDEFAULT;
+#else // !_WIN32_WCE
+ wxSize sizeReal = size;
+ sizeReal.SetDefaults(GetDefaultSize());
+
+ w = sizeReal.x;
+ h = sizeReal.y;
+#endif // _WIN32_WCE/!_WIN32_WCE
+ }
+ else
+ {
+ w = size.x;
+ h = size.y;
+ }
+}
+
+// ----------------------------------------------------------------------------
+// wxTopLevelWindowMSW fullscreen
+// ----------------------------------------------------------------------------
+
+bool wxTopLevelWindowMSW::ShowFullScreen(bool show, long style)
+{
+ if ( show == IsFullScreen() )
+ {
+ // nothing to do
+ return true;
+ }
+
+ m_fsIsShowing = show;
+
+ if ( show )
+ {
+ m_fsStyle = style;
+
+ // zap the frame borders
+
+ // save the 'normal' window style
+ m_fsOldWindowStyle = GetWindowLong(GetHwnd(), GWL_STYLE);
+
+ // save the old position, width & height, maximize state
+ m_fsOldSize = GetRect();
+ m_fsIsMaximized = IsMaximized();
+
+ // decide which window style flags to turn off
+ LONG newStyle = m_fsOldWindowStyle;
+ LONG offFlags = 0;
+
+ if (style & wxFULLSCREEN_NOBORDER)
+ {
+ offFlags |= WS_BORDER;
+#ifndef __WXWINCE__
+ offFlags |= WS_THICKFRAME;
+#endif
+ }
+ if (style & wxFULLSCREEN_NOCAPTION)
+ offFlags |= WS_CAPTION | WS_SYSMENU;
+
+ newStyle &= ~offFlags;
+
+ // change our window style to be compatible with full-screen mode
+ ::SetWindowLong(GetHwnd(), GWL_STYLE, newStyle);
+
+ wxRect rect;
+#if wxUSE_DISPLAY
+ // resize to the size of the display containing us
+ int dpy = wxDisplay::GetFromWindow(this);
+ if ( dpy != wxNOT_FOUND )
+ {
+ rect = wxDisplay(dpy).GetGeometry();
+ }
+ else // fall back to the main desktop
+#endif // wxUSE_DISPLAY
+ {
+ // resize to the size of the desktop
+ wxCopyRECTToRect(wxGetWindowRect(::GetDesktopWindow()), rect);
+#ifdef __WXWINCE__
+ // FIXME: size of the bottom menu (toolbar)
+ // should be taken in account
+ rect.height += rect.y;
+ rect.y = 0;
+#endif
+ }
+
+ SetSize(rect);
+
+ // now flush the window style cache and actually go full-screen
+ long flags = SWP_FRAMECHANGED;
+
+ // showing the frame full screen should also show it if it's still
+ // hidden
+ if ( !IsShown() )
+ {
+ // don't call wxWindow version to avoid flicker from calling
+ // ::ShowWindow() -- we're going to show the window at the correct
+ // location directly below -- but do call the wxWindowBase version
+ // to sync the internal m_isShown flag
+ wxWindowBase::Show();
+
+ flags |= SWP_SHOWWINDOW;
+ }
+
+ SetWindowPos(GetHwnd(), HWND_TOP,
+ rect.x, rect.y, rect.width, rect.height,
+ flags);
+
+#if !defined(__HANDHELDPC__) && (defined(__WXWINCE__) && (_WIN32_WCE < 400))
+ ::SHFullScreen(GetHwnd(), SHFS_HIDETASKBAR | SHFS_HIDESIPBUTTON);
+#endif
+
+ // finally send an event allowing the window to relayout itself &c
+ wxSizeEvent event(rect.GetSize(), GetId());
+ event.SetEventObject(this);
+ HandleWindowEvent(event);
+ }
+ else // stop showing full screen
+ {
+#if !defined(__HANDHELDPC__) && (defined(__WXWINCE__) && (_WIN32_WCE < 400))
+ ::SHFullScreen(GetHwnd(), SHFS_SHOWTASKBAR | SHFS_SHOWSIPBUTTON);
+#endif
+ Maximize(m_fsIsMaximized);
+ SetWindowLong(GetHwnd(),GWL_STYLE, m_fsOldWindowStyle);
+ SetWindowPos(GetHwnd(),HWND_TOP,m_fsOldSize.x, m_fsOldSize.y,
+ m_fsOldSize.width, m_fsOldSize.height, SWP_FRAMECHANGED);
+ }
+
+ return true;
+}
+
+// ----------------------------------------------------------------------------
+// wxTopLevelWindowMSW misc
+// ----------------------------------------------------------------------------
+
+void wxTopLevelWindowMSW::SetTitle( const wxString& title)
+{
+ SetLabel(title);
+}
+
+wxString wxTopLevelWindowMSW::GetTitle() const
+{
+ return GetLabel();
+}
+
+bool wxTopLevelWindowMSW::DoSelectAndSetIcon(const wxIconBundle& icons,
+ int smX,
+ int smY,
+ int i)
+{
+ const wxSize size(::GetSystemMetrics(smX), ::GetSystemMetrics(smY));
+
+ wxIcon icon = icons.GetIcon(size, wxIconBundle::FALLBACK_NEAREST_LARGER);
+
+ if ( !icon.IsOk() )
+ return false;
+
+ ::SendMessage(GetHwnd(), WM_SETICON, i, (LPARAM)GetHiconOf(icon));
+ return true;
+}
+
+void wxTopLevelWindowMSW::SetIcons(const wxIconBundle& icons)
+{
+ wxTopLevelWindowBase::SetIcons(icons);
+
+ if ( icons.IsEmpty() )
+ {
+ // FIXME: SetIcons(wxNullIconBundle) should unset existing icons,
+ // but we currently don't do that
+ wxASSERT_MSG( m_icons.IsEmpty(), "unsetting icons doesn't work" );
+ return;
+ }
+
+ DoSelectAndSetIcon(icons, SM_CXSMICON, SM_CYSMICON, ICON_SMALL);
+ DoSelectAndSetIcon(icons, SM_CXICON, SM_CYICON, ICON_BIG);
+}
+
+bool wxTopLevelWindowMSW::EnableCloseButton(bool enable)
+{
+#if !defined(__WXMICROWIN__)
+ // get system (a.k.a. window) menu
+ HMENU hmenu = GetSystemMenu(GetHwnd(), FALSE /* get it */);
+ if ( !hmenu )
+ {
+ // no system menu at all -- ok if we want to remove the close button
+ // anyhow, but bad if we want to show it
+ return !enable;
+ }
+
+ // enabling/disabling the close item from it also automatically
+ // disables/enables the close title bar button
+ if ( ::EnableMenuItem(hmenu, SC_CLOSE,
+ MF_BYCOMMAND |
+ (enable ? MF_ENABLED : MF_GRAYED)) == -1 )
+ {
+ wxLogLastError(wxT("EnableMenuItem(SC_CLOSE)"));
+
+ return false;
+ }
+#ifndef __WXWINCE__
+ // update appearance immediately
+ if ( !::DrawMenuBar(GetHwnd()) )
+ {
+ wxLogLastError(wxT("DrawMenuBar"));
+ }
+#endif
+#endif // !__WXMICROWIN__
+
+ return true;
+}
+
+void wxTopLevelWindowMSW::RequestUserAttention(int flags)
+{
+ // check if we can use FlashWindowEx(): unfortunately a simple test for
+ // FLASHW_STOP doesn't work because MSVC6 headers do #define it but don't
+ // provide FlashWindowEx() declaration, so try to detect whether we have
+ // real headers for WINVER 0x0500 by checking for existence of a symbol not
+ // declated in MSVC6 header
+#if defined(FLASHW_STOP) && defined(VK_XBUTTON1) && wxUSE_DYNLIB_CLASS
+ // available in the headers, check if it is supported by the system
+ typedef BOOL (WINAPI *FlashWindowEx_t)(FLASHWINFO *pfwi);
+ static FlashWindowEx_t s_pfnFlashWindowEx = NULL;
+ if ( !s_pfnFlashWindowEx )
+ {
+ wxDynamicLibrary dllUser32(wxT("user32.dll"));
+ s_pfnFlashWindowEx = (FlashWindowEx_t)
+ dllUser32.GetSymbol(wxT("FlashWindowEx"));
+
+ // we can safely unload user32.dll here, it's going to remain loaded as
+ // long as the program is running anyhow
+ }
+
+ if ( s_pfnFlashWindowEx )
+ {
+ WinStruct<FLASHWINFO> fwi;
+ fwi.hwnd = GetHwnd();
+ fwi.dwFlags = FLASHW_ALL;
+ if ( flags & wxUSER_ATTENTION_INFO )
+ {
+ // just flash a few times
+ fwi.uCount = 3;
+ }
+ else // wxUSER_ATTENTION_ERROR
+ {
+ // flash until the user notices it
+ fwi.dwFlags |= FLASHW_TIMERNOFG;
+ }
+
+ s_pfnFlashWindowEx(&fwi);
+ }
+ else // FlashWindowEx() not available
+#endif // FlashWindowEx() defined
+ {
+ wxUnusedVar(flags);
+#ifndef __WXWINCE__
+ ::FlashWindow(GetHwnd(), TRUE);
+#endif // __WXWINCE__
+ }
+}
+
+wxMenu *wxTopLevelWindowMSW::MSWGetSystemMenu() const
+{
+#ifndef __WXUNIVERSAL__
+ if ( !m_menuSystem )
+ {
+ HMENU hmenu = ::GetSystemMenu(GetHwnd(), FALSE);
+ if ( !hmenu )
+ {
+ wxLogLastError(wxT("GetSystemMenu()"));
+ return NULL;
+ }
+
+ wxTopLevelWindowMSW * const
+ self = const_cast<wxTopLevelWindowMSW *>(this);
+
+ self->m_menuSystem = wxMenu::MSWNewFromHMENU(hmenu);
+
+ // We need to somehow associate this menu with this window to ensure
+ // that we get events from it. A natural idea would be to pretend that
+ // it's attached to our menu bar but this wouldn't work if we don't
+ // have any menu bar which is a common case for applications using
+ // custom items in the system menu (they mostly do it exactly because
+ // they don't have any other menus).
+ //
+ // So reuse the invoking window pointer instead, this is not exactly
+ // correct but doesn't seem to have any serious drawbacks.
+ m_menuSystem->SetInvokingWindow(self);
+ }
+#endif // #ifndef __WXUNIVERSAL__
+
+ return m_menuSystem;
+}
+
+// ----------------------------------------------------------------------------
+// Transparency support
+// ---------------------------------------------------------------------------
+
+bool wxTopLevelWindowMSW::SetTransparent(wxByte alpha)
+{
+#if wxUSE_DYNLIB_CLASS
+ typedef DWORD (WINAPI *PSETLAYEREDWINDOWATTR)(HWND, DWORD, BYTE, DWORD);
+ static PSETLAYEREDWINDOWATTR
+ pSetLayeredWindowAttributes = (PSETLAYEREDWINDOWATTR)-1;
+
+ if ( pSetLayeredWindowAttributes == (PSETLAYEREDWINDOWATTR)-1 )
+ {
+ wxDynamicLibrary dllUser32(wxT("user32.dll"));
+
+ // use RawGetSymbol() and not GetSymbol() to avoid error messages under
+ // Windows 95: there is nothing the user can do about this anyhow
+ pSetLayeredWindowAttributes = (PSETLAYEREDWINDOWATTR)
+ dllUser32.RawGetSymbol(wxT("SetLayeredWindowAttributes"));
+
+ // it's ok to destroy dllUser32 here, we link statically to user32.dll
+ // anyhow so it won't be unloaded
+ }
+
+ if ( !pSetLayeredWindowAttributes )
+ return false;
+#endif // wxUSE_DYNLIB_CLASS
+
+ LONG exstyle = GetWindowLong(GetHwnd(), GWL_EXSTYLE);
+
+ // if setting alpha to fully opaque then turn off the layered style
+ if (alpha == 255)
+ {
+ SetWindowLong(GetHwnd(), GWL_EXSTYLE, exstyle & ~WS_EX_LAYERED);
+ Refresh();
+ return true;
+ }
+
+#if wxUSE_DYNLIB_CLASS
+ // Otherwise, set the layered style if needed and set the alpha value
+ if ((exstyle & WS_EX_LAYERED) == 0 )
+ SetWindowLong(GetHwnd(), GWL_EXSTYLE, exstyle | WS_EX_LAYERED);
+
+ if ( pSetLayeredWindowAttributes(GetHwnd(), 0, (BYTE)alpha, LWA_ALPHA) )
+ return true;
+#endif // wxUSE_DYNLIB_CLASS
+
+ return false;
+}
+
+bool wxTopLevelWindowMSW::CanSetTransparent()
+{
+ // The API is available on win2k and above
+
+ static int os_type = -1;
+ static int ver_major = -1;
+
+ if (os_type == -1)
+ os_type = ::wxGetOsVersion(&ver_major);
+
+ return (os_type == wxOS_WINDOWS_NT && ver_major >= 5);
+}
+
+void wxTopLevelWindowMSW::DoFreeze()
+{
+ // do nothing: freezing toplevel window causes paint and mouse events
+ // to go through it any TLWs under it, so the best we can do is to freeze
+ // all children -- and wxWindowBase::Freeze() does that
+}
+
+void wxTopLevelWindowMSW::DoThaw()
+{
+ // intentionally empty -- see DoFreeze()
+}
+
+
+// ----------------------------------------------------------------------------
+// wxTopLevelWindow event handling
+// ----------------------------------------------------------------------------
+
+void wxTopLevelWindowMSW::DoSaveLastFocus()
+{
+ if ( m_iconized )
+ return;
+
+ // remember the last focused child if it is our child
+ m_winLastFocused = FindFocus();
+
+ if ( m_winLastFocused )
+ {
+ // and don't remember it if it's a child from some other frame
+ if ( wxGetTopLevelParent(m_winLastFocused) != this )
+ {
+ m_winLastFocused = NULL;
+ }
+ }
+}
+
+void wxTopLevelWindowMSW::DoRestoreLastFocus()
+{
+ wxWindow *parent = m_winLastFocused ? m_winLastFocused->GetParent()
+ : NULL;
+ if ( !parent )
+ {
+ parent = this;
+ }
+
+ wxSetFocusToChild(parent, &m_winLastFocused);
+}
+
+void wxTopLevelWindowMSW::OnActivate(wxActivateEvent& event)
+{
+ if ( event.GetActive() )
+ {
+ // We get WM_ACTIVATE before being restored from iconized state, so we
+ // can be still iconized here. In this case, avoid restoring the focus
+ // as it doesn't work anyhow and we will do when we're really restored.
+ if ( m_iconized )
+ {
+ event.Skip();
+ return;
+ }
+
+ // restore focus to the child which was last focused unless we already
+ // have it
+ wxLogTrace(wxT("focus"), wxT("wxTLW %p activated."), m_hWnd);
+
+ wxWindow *winFocus = FindFocus();
+ if ( !winFocus || wxGetTopLevelParent(winFocus) != this )
+ DoRestoreLastFocus();
+ }
+ else // deactivating
+ {
+ DoSaveLastFocus();
+
+ wxLogTrace(wxT("focus"),
+ wxT("wxTLW %p deactivated, last focused: %p."),
+ m_hWnd,
+ m_winLastFocused ? GetHwndOf(m_winLastFocused) : NULL);
+
+ event.Skip();
+ }
+}
+
+#if wxUSE_MENUS
+
+bool
+wxTopLevelWindowMSW::HandleMenuSelect(WXWORD nItem, WXWORD flags, WXHMENU hMenu)
+{
+ // Ignore the special messages generated when the menu is closed (this is
+ // the only case when the flags are set to -1), in particular don't clear
+ // the help string in the status bar when this happens as it had just been
+ // restored by the base class code.
+ if ( !hMenu && flags == 0xffff )
+ return false;
+
+ // Unfortunately we also need to ignore another message which is sent after
+ // closing the currently active submenu of the menu bar by pressing Escape:
+ // in this case we get WM_UNINITMENUPOPUP, from which we generate
+ // wxEVT_MENU_CLOSE, and _then_ we get WM_MENUSELECT for the top level menu
+ // from which we overwrite the help string just restored by OnMenuClose()
+ // handler in wxFrameBase. To prevent this from happening we discard these
+ // messages but only in the case it's really the top level menu as we still
+ // need to clear the help string when a submenu is selected in a menu.
+ if ( flags == (MF_POPUP | MF_HILITE) && !m_menuDepth )
+ return false;
+
+ // sign extend to int from unsigned short we get from Windows
+ int item = (signed short)nItem;
+
+ // WM_MENUSELECT is generated for both normal items and menus, including
+ // the top level menus of the menu bar, which can't be represented using
+ // any valid identifier in wxMenuEvent so use an otherwise unused value for
+ // them
+ if ( flags & (MF_POPUP | MF_SEPARATOR) )
+ item = wxID_NONE;
+
+ wxMenuEvent event(wxEVT_MENU_HIGHLIGHT, item);
+ event.SetEventObject(this);
+
+ if ( HandleWindowEvent(event) )
+ return true;
+
+ // by default, i.e. if the event wasn't handled above, clear the status bar
+ // text when an item which can't have any associated help string in wx API
+ // is selected
+ if ( item == wxID_NONE )
+ DoGiveHelp(wxEmptyString, true);
+
+ return false;
+}
+
+bool
+wxTopLevelWindowMSW::DoSendMenuOpenCloseEvent(wxEventType evtType, wxMenu* menu, bool popup)
+{
+ // Update the menu depth when dealing with the top level menus.
+ if ( !popup )
+ {
+ if ( evtType == wxEVT_MENU_OPEN )
+ {
+ m_menuDepth++;
+ }
+ else if ( evtType == wxEVT_MENU_CLOSE )
+ {
+ wxASSERT_MSG( m_menuDepth > 0, wxS("No open menus?") );
+
+ m_menuDepth--;
+ }
+ else
+ {
+ wxFAIL_MSG( wxS("Unexpected menu event type") );
+ }
+ }
+
+ wxMenuEvent event(evtType, popup ? wxID_ANY : 0, menu);
+ event.SetEventObject(menu);
+
+ return HandleWindowEvent(event);
+}
+
+bool wxTopLevelWindowMSW::HandleExitMenuLoop(WXWORD isPopup)
+{
+ return DoSendMenuOpenCloseEvent(wxEVT_MENU_CLOSE,
+ isPopup ? wxCurrentPopupMenu : NULL,
+ isPopup != 0);
+}
+
+bool wxTopLevelWindowMSW::HandleMenuPopup(wxEventType evtType, WXHMENU hMenu)
+{
+ bool isPopup = false;
+ wxMenu* menu = NULL;
+ if ( wxCurrentPopupMenu && wxCurrentPopupMenu->GetHMenu() == hMenu )
+ {
+ menu = wxCurrentPopupMenu;
+ isPopup = true;
+ }
+ else
+ {
+ menu = MSWFindMenuFromHMENU(hMenu);
+ }
+
+
+ return DoSendMenuOpenCloseEvent(evtType, menu, isPopup);
+}
+
+wxMenu* wxTopLevelWindowMSW::MSWFindMenuFromHMENU(WXHMENU WXUNUSED(hMenu))
+{
+ // We don't have any menus at this level.
+ return NULL;
+}
+
+#endif // wxUSE_MENUS
+
+
+
+// the DialogProc for all wxWidgets dialogs
+LONG APIENTRY _EXPORT
+wxDlgProc(HWND hDlg,
+ UINT message,
+ WPARAM WXUNUSED(wParam),
+ LPARAM WXUNUSED(lParam))
+{
+ switch ( message )
+ {
+ case WM_INITDIALOG:
+ {
+ // under CE, add a "Ok" button in the dialog title bar and make it full
+ // screen
+ //
+ // TODO: find the window for this HWND, and take into account
+ // wxMAXIMIZE and wxCLOSE_BOX. For now, assume both are present.
+ //
+ // Standard SDK doesn't have aygshell.dll: see
+ // include/wx/msw/wince/libraries.h
+#if defined(__WXWINCE__) && !defined(__WINCE_STANDARDSDK__) && !defined(__HANDHELDPC__)
+ SHINITDLGINFO shidi;
+ shidi.dwMask = SHIDIM_FLAGS;
+ shidi.dwFlags = SHIDIF_SIZEDLG // take account of the SIP or menubar
+#ifndef __SMARTPHONE__
+ | SHIDIF_DONEBUTTON
+#endif
+ ;
+ shidi.hDlg = hDlg;
+ SHInitDialog( &shidi );
+#else // no SHInitDialog()
+ wxUnusedVar(hDlg);
+#endif
+ // for WM_INITDIALOG, returning TRUE tells system to set focus to
+ // the first control in the dialog box, but as we set the focus
+ // ourselves, we return FALSE for it as well
+ return FALSE;
+ }
+ }
+
+ // for almost all messages, returning FALSE means that we didn't process
+ // the message
+ return FALSE;
+}
+
+// ============================================================================
+// wxTLWHiddenParentModule implementation
+// ============================================================================
+
+HWND wxTLWHiddenParentModule::ms_hwnd = NULL;
+
+const wxChar *wxTLWHiddenParentModule::ms_className = NULL;
+
+bool wxTLWHiddenParentModule::OnInit()
+{
+ ms_hwnd = NULL;
+ ms_className = NULL;
+
+ return true;
+}
+
+void wxTLWHiddenParentModule::OnExit()
+{
+ if ( ms_hwnd )
+ {
+ if ( !::DestroyWindow(ms_hwnd) )
+ {
+ wxLogLastError(wxT("DestroyWindow(hidden TLW parent)"));
+ }
+
+ ms_hwnd = NULL;
+ }
+
+ if ( ms_className )
+ {
+ if ( !::UnregisterClass(ms_className, wxGetInstance()) )
+ {
+ wxLogLastError(wxT("UnregisterClass(\"wxTLWHiddenParent\")"));
+ }
+
+ ms_className = NULL;
+ }
+}
+
+/* static */
+HWND wxTLWHiddenParentModule::GetHWND()
+{
+ if ( !ms_hwnd )
+ {
+ if ( !ms_className )
+ {
+ static const wxChar *HIDDEN_PARENT_CLASS = wxT("wxTLWHiddenParent");
+
+ WNDCLASS wndclass;
+ wxZeroMemory(wndclass);
+
+ wndclass.lpfnWndProc = DefWindowProc;
+ wndclass.hInstance = wxGetInstance();
+ wndclass.lpszClassName = HIDDEN_PARENT_CLASS;
+
+ if ( !::RegisterClass(&wndclass) )
+ {
+ wxLogLastError(wxT("RegisterClass(\"wxTLWHiddenParent\")"));
+ }
+ else
+ {
+ ms_className = HIDDEN_PARENT_CLASS;
+ }
+ }
+
+ ms_hwnd = ::CreateWindow(ms_className, wxEmptyString, 0, 0, 0, 0, 0, NULL,
+ (HMENU)NULL, wxGetInstance(), NULL);
+ if ( !ms_hwnd )
+ {
+ wxLogLastError(wxT("CreateWindow(hidden TLW parent)"));
+ }
+ }
+
+ return ms_hwnd;
projects / wxWidgets.git / blobdiff