+ HDC m_hdc;
+ HGDIOBJ m_hgdiobj;
+
+ wxDECLARE_NO_COPY_CLASS(SelectInHDC);
+};
+
+// a class which cleans up any GDI object
+class AutoGDIObject
+{
+protected:
+ AutoGDIObject() { m_gdiobj = NULL; }
+ AutoGDIObject(HGDIOBJ gdiobj) : m_gdiobj(gdiobj) { }
+ ~AutoGDIObject() { if ( m_gdiobj ) ::DeleteObject(m_gdiobj); }
+
+ void InitGdiobj(HGDIOBJ gdiobj)
+ {
+ wxASSERT_MSG( !m_gdiobj, _T("initializing twice?") );
+
+ m_gdiobj = gdiobj;
+ }
+
+ HGDIOBJ GetObject() const { return m_gdiobj; }
+
+private:
+ HGDIOBJ m_gdiobj;
+};
+
+// TODO: all this asks for using a AutoHandler<T, CreateFunc> template...
+
+// a class for temporary brushes
+class AutoHBRUSH : private AutoGDIObject
+{
+public:
+ AutoHBRUSH(COLORREF col)
+ : AutoGDIObject(::CreateSolidBrush(col)) { }
+
+ operator HBRUSH() const { return (HBRUSH)GetObject(); }
+};
+
+// a class for temporary fonts
+class AutoHFONT : private AutoGDIObject
+{
+private:
+public:
+ AutoHFONT()
+ : AutoGDIObject() { }
+
+ AutoHFONT(const LOGFONT& lf)
+ : AutoGDIObject(::CreateFontIndirect(&lf)) { }
+
+ void Init(const LOGFONT& lf) { InitGdiobj(::CreateFontIndirect(&lf)); }
+
+ operator HFONT() const { return (HFONT)GetObject(); }
+};
+
+// a class for temporary pens
+class AutoHPEN : private AutoGDIObject
+{
+public:
+ AutoHPEN(COLORREF col)
+ : AutoGDIObject(::CreatePen(PS_SOLID, 0, col)) { }
+
+ operator HPEN() const { return (HPEN)GetObject(); }
+};
+
+// classes for temporary bitmaps
+class AutoHBITMAP : private AutoGDIObject
+{
+public:
+ AutoHBITMAP(HBITMAP hbmp) : AutoGDIObject(hbmp) { }
+
+ operator HBITMAP() const { return (HBITMAP)GetObject(); }
+};
+
+class CompatibleBitmap : public AutoHBITMAP
+{
+public:
+ CompatibleBitmap(HDC hdc, int w, int h)
+ : AutoHBITMAP(::CreateCompatibleBitmap(hdc, w, h))
+ {
+ }
+};
+
+class MonoBitmap : public AutoHBITMAP
+{
+public:
+ MonoBitmap(int w, int h)
+ : AutoHBITMAP(::CreateBitmap(w, h, 1, 1, 0))
+ {
+ }
+};
+
+// class automatically destroys the region object
+class AutoHRGN : private AutoGDIObject
+{
+public:
+ AutoHRGN(HRGN hrgn) : AutoGDIObject(hrgn) { }
+
+ operator HRGN() const { return (HRGN)GetObject(); }
+};
+
+// class sets the specified clipping region during its life time
+class HDCClipper
+{
+public:
+ HDCClipper(HDC hdc, HRGN hrgn)
+ : m_hdc(hdc)
+ {
+ if ( !::SelectClipRgn(hdc, hrgn) )
+ wxLogLastError(_T("SelectClipRgn"));
+ }
+
+ ~HDCClipper()
+ {
+ ::SelectClipRgn(m_hdc, NULL);
+ }
+
+private:
+ HDC m_hdc;
+
+ wxDECLARE_NO_COPY_CLASS(HDCClipper);
+};
+
+// set the given map mode for the life time of this object
+//
+// NB: SetMapMode() is not supported by CE so we also define a helper macro
+// to avoid using it there
+#ifdef __WXWINCE__
+ #define wxCHANGE_HDC_MAP_MODE(hdc, mm)
+#else // !__WXWINCE__
+ class HDCMapModeChanger
+ {
+ public:
+ HDCMapModeChanger(HDC hdc, int mm)
+ : m_hdc(hdc)
+ {
+ m_modeOld = ::SetMapMode(hdc, mm);
+ if ( !m_modeOld )
+ wxLogLastError(_T("SelectClipRgn"));
+ }
+
+ ~HDCMapModeChanger()
+ {
+ if ( m_modeOld )
+ ::SetMapMode(m_hdc, m_modeOld);
+ }
+
+ private:
+ HDC m_hdc;
+ int m_modeOld;
+
+ wxDECLARE_NO_COPY_CLASS(HDCMapModeChanger);
+ };
+
+ #define wxCHANGE_HDC_MAP_MODE(hdc, mm) \
+ HDCMapModeChanger wxMAKE_UNIQUE_NAME(wxHDCMapModeChanger)(hdc, mm)
+#endif // __WXWINCE__/!__WXWINCE__
+
+// smart pointer using GlobalAlloc/GlobalFree()
+class GlobalPtr
+{
+public:
+ // default ctor, call Init() later
+ GlobalPtr()
+ {
+ m_hGlobal = NULL;
+ }
+
+ // allocates a block of given size
+ void Init(size_t size, unsigned flags = GMEM_MOVEABLE)
+ {
+ m_hGlobal = ::GlobalAlloc(flags, size);
+ if ( !m_hGlobal )
+ wxLogLastError(_T("GlobalAlloc"));
+ }
+
+ GlobalPtr(size_t size, unsigned flags = GMEM_MOVEABLE)
+ {
+ Init(size, flags);
+ }
+
+ ~GlobalPtr()
+ {
+ if ( m_hGlobal && ::GlobalFree(m_hGlobal) )
+ wxLogLastError(_T("GlobalFree"));
+ }
+
+ // implicit conversion
+ operator HGLOBAL() const { return m_hGlobal; }
+
+private:
+ HGLOBAL m_hGlobal;
+
+ wxDECLARE_NO_COPY_CLASS(GlobalPtr);
+};
+
+// when working with global pointers (which is unfortunately still necessary
+// sometimes, e.g. for clipboard) it is important to unlock them exactly as
+// many times as we lock them which just asks for using a "smart lock" class
+class GlobalPtrLock
+{
+public:
+ // default ctor, use Init() later -- should only be used if the HGLOBAL can
+ // be NULL (in which case Init() shouldn't be called)
+ GlobalPtrLock()
+ {
+ m_hGlobal = NULL;
+ m_ptr = NULL;
+ }
+
+ // initialize the object, may be only called if we were created using the
+ // default ctor; HGLOBAL must not be NULL
+ void Init(HGLOBAL hGlobal)
+ {
+ m_hGlobal = hGlobal;
+
+ // NB: GlobalLock() is a macro, not a function, hence don't use the
+ // global scope operator with it (and neither with GlobalUnlock())
+ m_ptr = GlobalLock(hGlobal);
+ if ( !m_ptr )
+ wxLogLastError(_T("GlobalLock"));
+ }
+
+ // initialize the object, HGLOBAL must not be NULL
+ GlobalPtrLock(HGLOBAL hGlobal)
+ {
+ Init(hGlobal);
+ }
+
+ ~GlobalPtrLock()
+ {
+ if ( m_hGlobal && !GlobalUnlock(m_hGlobal) )
+ {
+#ifdef __WXDEBUG__
+ // this might happen simply because the block became unlocked
+ DWORD dwLastError = ::GetLastError();
+ if ( dwLastError != NO_ERROR )
+ {
+ wxLogApiError(_T("GlobalUnlock"), dwLastError);
+ }
+#endif // __WXDEBUG__
+ }
+ }
+
+ void *Get() const { return m_ptr; }
+ operator void *() const { return m_ptr; }
+
+private:
+ HGLOBAL m_hGlobal;
+ void *m_ptr;
+
+ wxDECLARE_NO_COPY_CLASS(GlobalPtrLock);
+};
+
+// register the class when it is first needed and unregister it in dtor
+class ClassRegistrar
+{
+public:
+ // ctor doesn't register the class, call Initialize() for this
+ ClassRegistrar() { m_registered = -1; }
+
+ // return true if the class is already registered
+ bool IsInitialized() const { return m_registered != -1; }
+
+ // return true if the class had been already registered
+ bool IsRegistered() const { return m_registered == 1; }
+
+ // try to register the class if not done yet, return true on success
+ bool Register(const WNDCLASS& wc)
+ {
+ // we should only be called if we hadn't been initialized yet
+ wxASSERT_MSG( m_registered == -1,
+ _T("calling ClassRegistrar::Register() twice?") );
+
+ m_registered = ::RegisterClass(&wc) ? 1 : 0;
+ if ( !IsRegistered() )
+ {
+ wxLogLastError(_T("RegisterClassEx()"));
+ }
+ else
+ {
+ m_clsname = wc.lpszClassName;
+ }
+
+ return m_registered == 1;
+ }
+
+ // get the name of the registered class (returns empty string if not
+ // registered)
+ const wxString& GetName() const { return m_clsname; }
+
+ // unregister the class if it had been registered
+ ~ClassRegistrar()
+ {
+ if ( IsRegistered() )
+ {
+ if ( !::UnregisterClass(m_clsname.wx_str(), wxhInstance) )
+ {
+ wxLogLastError(_T("UnregisterClass"));
+ }
+ }
+ }
+
+private:
+ // initial value is -1 which means that we hadn't tried registering the
+ // class yet, it becomes true or false (1 or 0) when Initialize() is called
+ int m_registered;
+
+ // the name of the class, only non empty if it had been registered
+ wxString m_clsname;
projects / wxWidgets.git / blobdiff