#include "wx/evtloop.h"
#include "wx/thread.h"
#include "wx/scopeguard.h"
+#include "wx/vector.h"
#include "wx/msw/private.h"
#include "wx/msw/dc.h"
extern void wxSetKeyboardHook(bool doIt);
#endif
-// NB: all "NoRedraw" classes must have the same names as the "normal" classes
-// with NR suffix - wxWindow::MSWCreate() supposes this
-#ifdef __WXWINCE__
-WXDLLIMPEXP_CORE wxChar *wxCanvasClassName;
-WXDLLIMPEXP_CORE wxChar *wxCanvasClassNameNR;
-#else
-WXDLLIMPEXP_CORE const wxChar *wxCanvasClassName = NULL;
-WXDLLIMPEXP_CORE const wxChar *wxCanvasClassNameNR = NULL;
-#endif
-WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassName = NULL;
-WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassNameNoRedraw = NULL;
-WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassName = NULL;
-WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassNameNoRedraw = NULL;
+// because of mingw32 4.3 bug this struct can't be inside the namespace below:
+// see http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/110282
+struct ClassRegInfo
+{
+ // the base name of the class: this is used to construct the unique name in
+ // RegisterClassWithUniqueNames()
+ wxString basename;
+
+ // the name of the registered class with and without CS_[HV]REDRAW styles
+ wxString regname,
+ regnameNR;
+};
+
+namespace
+{
+
+wxVector<ClassRegInfo> gs_regClassesInfo;
+
+} // anonymous namespace
// ----------------------------------------------------------------------------
// private functions
// ensure that base cleanup is done if we return too early
wxCallBaseCleanup callBaseCleanup(this);
-#ifdef __WXWINCE__
- wxString tmp = GetAppName();
- tmp += wxT("ClassName");
- wxCanvasClassName = wxStrdup( tmp.wc_str() );
- tmp += wxT("NR");
- wxCanvasClassNameNR = wxStrdup( tmp.wc_str() );
- HWND hWnd = FindWindow( wxCanvasClassNameNR, NULL );
- if (hWnd)
- {
- SetForegroundWindow( (HWND)(((DWORD)hWnd)|0x01) );
- return false;
- }
-#endif
-
#if !defined(__WXMICROWIN__)
InitCommonControls();
#endif // !defined(__WXMICROWIN__)
wxOleInitialize();
- RegisterWindowClasses();
-
#if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
wxSetKeyboardHook(true);
#endif
}
// ---------------------------------------------------------------------------
-// RegisterWindowClasses
+// Win32 window class registration
// ---------------------------------------------------------------------------
-// This function registers the given class name and stores a pointer to a
-// heap-allocated copy of it at the specified location, it must be deleted
-// later.
-static void RegisterAndStoreClassName(const wxString& uniqueClassName,
- const wxChar **className,
- WNDCLASS *lpWndClass)
+/* static */
+const wxChar *wxApp::GetRegisteredClassName(const wxChar *name,
+ int bgBrushCol,
+ int extraStyles)
{
- const size_t length = uniqueClassName.length() + 1; // for trailing NUL
- wxChar *newChars = new wxChar[length];
- wxStrncpy(newChars, uniqueClassName, length);
- *className = newChars;
- lpWndClass->lpszClassName = *className;
-
- if ( !::RegisterClass(lpWndClass) )
+ const size_t count = gs_regClassesInfo.size();
+ for ( size_t n = 0; n < count; n++ )
{
- wxLogLastError(wxString::Format(wxT("RegisterClass(%s)"), newChars));
+ if ( gs_regClassesInfo[n].basename == name )
+ return gs_regClassesInfo[n].regname.c_str();
}
-}
-
-// This function registers the class defined by the provided WNDCLASS struct
-// contents using a unique name constructed from the specified base name and
-// and a suffix unique to this library instance. It also stores the generated
-// unique names for normal and "no redraw" versions of the class in the
-// provided variables, caller must delete their contents later.
-static void RegisterClassWithUniqueNames(const wxString& baseName,
- const wxChar **className,
- const wxChar **classNameNR,
- WNDCLASS *lpWndClass)
-{
- // for each class we register one with CS_(V|H)REDRAW style and one
- // without for windows created with wxNO_FULL_REDRAW_ON_REPAINT flag
- static const long styleNormal = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
- static const long styleNoRedraw = CS_DBLCLKS;
-
- const wxString uniqueSuffix(wxString::Format(wxT("@%p"), className));
- wxString uniqueClassName(baseName + uniqueSuffix);
- lpWndClass->style = styleNormal;
- RegisterAndStoreClassName(uniqueClassName, className, lpWndClass);
-
- // NB: remember that code elsewhere supposes that no redraw class names
- // use the same names as normal classes with "NR" suffix so we must put
- // "NR" at the end instead of using more natural baseName+"NR"+suffix
- wxString uniqueClassNameNR(uniqueClassName + wxT("NR"));
- lpWndClass->style = styleNoRedraw;
- RegisterAndStoreClassName(uniqueClassNameNR, classNameNR, lpWndClass);
-}
-
-// TODO we should only register classes really used by the app. For this it
-// would be enough to just delay the class registration until an attempt
-// to create a window of this class is made.
-bool wxApp::RegisterWindowClasses()
-{
+ // we need to register this class
WNDCLASS wndclass;
wxZeroMemory(wndclass);
- // the fields which are common to all classes
wndclass.lpfnWndProc = (WNDPROC)wxWndProc;
wndclass.hInstance = wxhInstance;
- wndclass.hCursor = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
-
- // register the class for all normal windows and "no redraw" frames
- wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
- RegisterClassWithUniqueNames(wxT("wxWindowClass"),
- &wxCanvasClassName,
- &wxCanvasClassNameNR,
- &wndclass);
-
- // Register the MDI frame window class and "no redraw" MDI frame
- wndclass.hbrBackground = (HBRUSH)NULL; // paint MDI frame ourselves
- RegisterClassWithUniqueNames(wxT("wxMDIFrameClass"),
- &wxMDIFrameClassName,
- &wxMDIFrameClassNameNoRedraw,
- &wndclass);
-
- // Register the MDI child frame window class and "no redraw" MDI child frame
- wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
- RegisterClassWithUniqueNames(wxT("wxMDIChildFrameClass"),
- &wxMDIChildFrameClassName,
- &wxMDIChildFrameClassNameNoRedraw,
- &wndclass);
-
- return true;
-}
-
-// ---------------------------------------------------------------------------
-// UnregisterWindowClasses
-// ---------------------------------------------------------------------------
-
-// This function unregisters the class with the given name and frees memory
-// allocated for it by RegisterAndStoreClassName().
-static bool UnregisterAndFreeClassName(const wxChar **ppClassName)
-{
- bool retval = true;
-
- if ( !::UnregisterClass(*ppClassName, wxhInstance) )
+ wndclass.hCursor = ::LoadCursor(NULL, IDC_ARROW);
+ wndclass.hbrBackground = (HBRUSH)wxUIntToPtr(bgBrushCol + 1);
+ wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | extraStyles;
+
+
+ ClassRegInfo regClass;
+ regClass.basename = name;
+
+ // constuct a unique suffix to allow registering the class with the same
+ // base name in a main application using wxWidgets and a DLL using
+ // wxWidgets loaded into its address space: as gs_regClassesInfo variable
+ // is different in them, we're going to obtain a unique prefix by using its
+ // address here
+ regClass.regname = regClass.basename +
+ wxString::Format(wxT("@%p"), &gs_regClassesInfo);
+ wndclass.lpszClassName = regClass.regname.wx_str();
+ if ( !::RegisterClass(&wndclass) )
{
- wxLogLastError(
- wxString::Format(wxT("UnregisterClass(%s)"), *ppClassName));
+ wxLogLastError(wxString::Format(wxT("RegisterClass(%s)"),
+ regClass.regname));
+ return NULL;
+ }
- retval = false;
+ // NB: remember that code elsewhere supposes that no redraw class names
+ // use the same names as normal classes with "NR" suffix so we must put
+ // "NR" at the end instead of using more natural basename+"NR"+suffix
+ regClass.regnameNR = regClass.regname + GetNoRedrawClassSuffix();
+ wndclass.style &= ~(CS_HREDRAW | CS_VREDRAW);
+ wndclass.lpszClassName = regClass.regnameNR.wx_str();
+ if ( !::RegisterClass(&wndclass) )
+ {
+ wxLogLastError(wxString::Format(wxT("RegisterClass(%s)"),
+ regClass.regname));
+ ::UnregisterClass(regClass.regname.c_str(), wxhInstance);
+ return NULL;
}
- delete [] (wxChar*) *ppClassName;
- *ppClassName = NULL;
+ gs_regClassesInfo.push_back(regClass);
- return retval;
+ // take care to return the pointer which will remain valid after the
+ // function returns (it could be invalidated later if new elements are
+ // added to the vector and it's reallocated but this shouldn't matter as
+ // this pointer should be used right now, not stored)
+ return gs_regClassesInfo.back().regname.wx_str();
}
-bool wxApp::UnregisterWindowClasses()
+bool wxApp::IsRegisteredClassName(const wxString& name)
{
- bool retval = true;
-
-#ifndef __WXMICROWIN__
- if ( !UnregisterAndFreeClassName(&wxMDIFrameClassName) )
- retval = false;
-
- if ( !UnregisterAndFreeClassName(&wxMDIFrameClassNameNoRedraw) )
- retval = false;
-
- if ( !UnregisterAndFreeClassName(&wxMDIChildFrameClassName) )
- retval = false;
+ const size_t count = gs_regClassesInfo.size();
+ for ( size_t n = 0; n < count; n++ )
+ {
+ if ( gs_regClassesInfo[n].regname == name ||
+ gs_regClassesInfo[n].regnameNR == name )
+ return true;
+ }
- if ( !UnregisterAndFreeClassName(&wxMDIChildFrameClassNameNoRedraw) )
- retval = false;
+ return false;
+}
- if ( !UnregisterAndFreeClassName(&wxCanvasClassName) )
- retval = false;
+void wxApp::UnregisterWindowClasses()
+{
+ const size_t count = gs_regClassesInfo.size();
+ for ( size_t n = 0; n < count; n++ )
+ {
+ const ClassRegInfo& regClass = gs_regClassesInfo[n];
+ if ( !::UnregisterClass(regClass.regname.c_str(), wxhInstance) )
+ {
+ wxLogLastError(wxString::Format(wxT("UnregisterClass(%s)"),
+ regClass.regname));
+ }
- if ( !UnregisterAndFreeClassName(&wxCanvasClassNameNR) )
- retval = false;
-#endif // __WXMICROWIN__
+ if ( !::UnregisterClass(regClass.regnameNR.c_str(), wxhInstance) )
+ {
+ wxLogLastError(wxString::Format(wxT("UnregisterClass(%s)"),
+ regClass.regnameNR));
+ }
+ }
- return retval;
+ gs_regClassesInfo.clear();
}
void wxApp::CleanUp()
// which case the registration will fail after the first time if we don't
// unregister the classes now
UnregisterWindowClasses();
-
-#ifdef __WXWINCE__
- free( wxCanvasClassName );
- free( wxCanvasClassNameNR );
-#endif
}
// ----------------------------------------------------------------------------
// depending on the OS version and the presence of the manifest, it can
// be either v5 or v6 and instead of trying to guess it just get the
// handle of the already loaded version
- wxDynamicLibrary dllComCtl32(_T("comctl32.dll"),
- wxDL_VERBATIM |
- wxDL_QUIET |
- wxDL_GET_LOADED);
+ wxLoadedDLL dllComCtl32(_T("comctl32.dll"));
if ( !dllComCtl32.IsLoaded() )
{
s_verComCtl32 = 0;
}
}
}
-
- // we shouldn't unload it here as we didn't really load it above
- dllComCtl32.Detach();
}
return s_verComCtl32;
bool wxApp::Yield(bool onlyIfNeeded)
{
- // MT-FIXME
- static bool s_inYield = false;
-
- if ( s_inYield )
+ if ( m_isInsideYield )
{
if ( !onlyIfNeeded )
{
}
// set the flag and don't forget to reset it before returning
- s_inYield = true;
- wxON_BLOCK_EXIT_SET(s_inYield, false);
+ m_isInsideYield = true;
+ wxON_BLOCK_EXIT_SET(m_isInsideYield, false);
#if wxUSE_LOG
projects / wxWidgets.git / blobdiff