// wxAnimationBase
// ----------------------------------------------------------------------------
-class WXDLLIMPEXP_ADV wxAnimationBase : public wxGDIObject
+class WXDLLIMPEXP_ADV wxAnimationBase : public wxObject
{
public:
wxAnimationBase() {}
static void InitStandardHandlers();
*/
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk() const = 0;
-
virtual int GetHeight() const = 0;
virtual int GetWidth() const = 0;
virtual int GetDepth() const = 0;
// ========================================================================
class WXDLLEXPORT wxBitmap: public wxGDIObject
{
- DECLARE_DYNAMIC_CLASS(wxBitmap)
// ------------------------------------------------------------------------
// initialization
// ------------------------------------------------------------------------
// get the given part of bitmap
wxBitmap GetSubBitmap( const wxRect& rect ) const;
- bool Ok() const { return IsOk(); }
- bool IsOk() const;
int GetWidth() const;
int GetHeight() const;
int GetDepth() const;
int GetBitmapType() const;
- // wxObjectRefData
- wxObjectRefData *CreateRefData() const;
- wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
-
// wxCocoa
WX_NSBitmapImageRep GetNSBitmapImageRep();
void SetNSBitmapImageRep(WX_NSBitmapImageRep bitmapImageRep);
static void InitStandardHandlers() { }
static void CleanUpHandlers() { }
+
+protected:
+ wxGDIRefData *CreateGDIRefData() const;
+ wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
+ DECLARE_DYNAMIC_CLASS(wxBitmap)
};
class WXDLLIMPEXP_CORE wxBitmapHandler: public wxBitmapHandlerBase
DECLARE_ABSTRACT_CLASS(wxBitmapHandler)
};
-#endif
- // __WX_COCOA_BITMAP_H__
+#endif // __WX_COCOA_BITMAP_H__
virtual int GetStyle() const;
wxBitmap *GetStipple() const;
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk() const
- { return (m_refData != NULL); }
-
- // wxObjectRefData
- wxObjectRefData *CreateRefData() const;
- wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
-
// wxCocoa
WX_NSColor GetNSColor();
+
+protected:
+ wxGDIRefData *CreateGDIRefData() const;
+ wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
};
#endif // __WX_COCOA_BRUSH_H__
virtual ~wxColour();
// accessors
- bool IsOk() const { return m_cocoaNSColor; }
+ virtual bool IsOk() const { return m_cocoaNSColor; }
WX_NSColor GetNSColor() { return m_cocoaNSColor; }
unsigned char Red() const { return m_red; }
#include "wx/bitmap.h"
-class WXDLLEXPORT wxCursorRefData: public wxObjectRefData
+class WXDLLEXPORT wxCursorRefData : public wxGDIRefData
{
- DECLARE_NO_COPY_CLASS(wxCursorRefData)
-
- friend class WXDLLIMPEXP_FWD_CORE wxBitmap;
- friend class WXDLLIMPEXP_FWD_CORE wxCursor;
public:
wxCursorRefData();
virtual ~wxCursorRefData();
protected:
int m_width, m_height;
WX_NSCursor m_hCursor;
+
+ friend class WXDLLIMPEXP_FWD_CORE wxBitmap;
+ friend class WXDLLIMPEXP_FWD_CORE wxCursor;
+
+ DECLARE_NO_COPY_CLASS(wxCursorRefData)
};
#define M_CURSORDATA ((wxCursorRefData *)m_refData)
// Cursor
class WXDLLEXPORT wxCursor: public wxBitmap
{
- DECLARE_DYNAMIC_CLASS(wxCursor)
-
public:
- wxCursor();
-
- wxCursor(const char bits[], int width, int height, int hotSpotX = -1, int hotSpotY = -1,
- const char maskBits[] = NULL);
+ wxCursor();
- wxCursor(const wxString& name, long flags = 0,
- int hotSpotX = 0, int hotSpotY = 0);
+ wxCursor(const char bits[], int width, int height,
+ int hotSpotX = -1, int hotSpotY = -1,
+ const char maskBits[] = NULL);
- wxCursor(int cursor_type);
- virtual ~wxCursor();
+ wxCursor(const wxString& name, long flags = 0,
+ int hotSpotX = 0, int hotSpotY = 0);
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk() const { return m_refData ; }
+ wxCursor(int cursor_type);
+ virtual ~wxCursor();
- inline bool operator == (const wxCursor& cursor) const { return m_refData == cursor.m_refData; }
- inline bool operator != (const wxCursor& cursor) const { return m_refData != cursor.m_refData; }
+ // FIXME: operator==() is wrong!
+ bool operator==(const wxCursor& cursor) const { return m_refData == cursor.m_refData; }
+ bool operator!=(const wxCursor& cursor) const { return !(*this == cursor); }
- inline WX_NSCursor GetNSCursor() const
- {
- return (M_CURSORDATA ? M_CURSORDATA->m_hCursor : 0);
- }
+ WX_NSCursor GetNSCursor() const { return M_CURSORDATA ? M_CURSORDATA->m_hCursor : 0; }
+ DECLARE_DYNAMIC_CLASS(wxCursor)
};
extern WXDLLEXPORT void wxSetCursor(const wxCursor& cursor);
virtual bool RealizeResource();
protected:
- /*! @abstract Helper method for COW.
- @discussion
- wxFont can be considered a mutable holder of an immutable opaque implementation object.
- All methods that mutate the font should first call Unshare() to ensure that mutating
- the implementation object does not cause another wxFont that happened to share the
- same ref data to mutate.
- */
- void Unshare();
-
/*! @abstract Internal constructor with ref data
@discussion
Takes ownership of @a refData. That is, it is assumed that refData has either just been
explicit wxFont(wxFontRefData *refData)
{ Create(refData); }
bool Create(wxFontRefData *refData);
+
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
private:
DECLARE_DYNAMIC_CLASS(wxFont)
};
// ========================================================================
// wxIcon
// ========================================================================
-class WXDLLEXPORT wxIcon: public wxGDIObject
+class WXDLLEXPORT wxIcon : public wxGDIObject
{
- DECLARE_DYNAMIC_CLASS(wxIcon)
public:
wxIcon();
// ctors, assignment operators...), but it's ok to have such function
void CopyFromBitmap(const wxBitmap& bmp);
- bool Ok() const { return IsOk(); }
- bool IsOk() const;
int GetWidth() const;
int GetHeight() const;
WX_NSImage GetNSImage() const;
bool CreateFromXpm(const char **bits);
+
+protected:
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
+private:
+ DECLARE_DYNAMIC_CLASS(wxIcon)
};
-#endif
- // _WX_COCOA_ICON_H__
+#endif // _WX_COCOA_ICON_H__
// ========================================================================
class WXDLLEXPORT wxPen: public wxGDIObject
{
- DECLARE_DYNAMIC_CLASS(wxPen)
public:
wxPen();
wxPen(const wxColour& col, int width = 1, int style = wxSOLID);
wxPen(const wxBitmap& stipple, int width);
virtual ~wxPen();
- // wxObjectRefData
- wxObjectRefData *CreateRefData() const;
- wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
-
- inline bool operator == (const wxPen& pen) const
- { return m_refData == pen.m_refData; }
- inline bool operator != (const wxPen& pen) const
- { return m_refData != pen.m_refData; }
-
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk() const { return (m_refData != NULL) ; }
+ // FIXME: operator==() is wrong
+ bool operator==(const wxPen& pen) const { return m_refData == pen.m_refData; }
+ bool operator!=(const wxPen& pen) const { return !(*this == pen); }
void SetColour(const wxColour& col) ;
void SetColour(unsigned char r, unsigned char g, unsigned char b) ;
WX_NSColor GetNSColor();
int GetCocoaLineDash(const CGFloat **pattern);
+
+protected:
+ wxGDIRefData *CreateGDIRefData() const;
+ wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
+ DECLARE_DYNAMIC_CLASS(wxPen)
};
#endif // __WX_COCOA_PEN_H__
// accessors
// ---------
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk() const = 0;
-
virtual ChannelType Red() const = 0;
virtual ChannelType Green() const = 0;
virtual ChannelType Blue() const = 0;
InitRGBA(ChannelType r, ChannelType g, ChannelType b, ChannelType a) = 0;
virtual bool FromString(const wxString& s);
+
+ // wxColour doesn't use reference counted data (at least not in all ports)
+ // so provide stubs for the functions which need to be defined if we do use
+ // them
+ virtual wxGDIRefData *CreateGDIRefData() const
+ {
+ wxFAIL_MSG( "must be overridden if used" );
+
+ return NULL;
+ }
+
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *WXUNUSED(data)) const
+ {
+ wxFAIL_MSG( "must be overridden if used" );
+
+ return NULL;
+ }
};
// wxBitmap
//-----------------------------------------------------------------------------
-class WXDLLIMPEXP_CORE wxBitmapHandler: public wxBitmapHandlerBase
+class WXDLLIMPEXP_CORE wxBitmapHandler : public wxBitmapHandlerBase
{
DECLARE_ABSTRACT_CLASS(wxBitmapHandler)
};
-class WXDLLIMPEXP_CORE wxBitmap: public wxBitmapBase
+class WXDLLIMPEXP_CORE wxBitmap : public wxBitmapBase
{
public:
wxBitmap() {}
wxBitmap(const wxImage& image, int depth = -1);
#endif
- bool Ok() const { return IsOk(); }
- bool IsOk() const;
-
bool Create(const wxIDirectFBSurfacePtr& surface);
bool Create(int width, int height, int depth = -1);
wxIDirectFBSurfacePtr GetDirectFBSurface() const;
protected:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
bool CreateWithFormat(int width, int height, int dfbFormat);
// wxBrush
//-----------------------------------------------------------------------------
-class WXDLLIMPEXP_CORE wxBrush: public wxBrushBase
+class WXDLLIMPEXP_CORE wxBrush : public wxBrushBase
{
public:
wxBrush() {}
wxBrush(const wxColour &colour, int style = wxSOLID);
wxBrush(const wxBitmap &stippleBitmap);
- bool Ok() const { return IsOk(); }
- bool IsOk() const;
bool operator==(const wxBrush& brush) const;
bool operator!=(const wxBrush& brush) const { return !(*this == brush); }
virtual int GetStyle() const;
- wxColour &GetColour() const;
+ wxColour& GetColour() const;
wxBitmap *GetStipple() const;
void SetColour(const wxColour& col);
void SetStipple(const wxBitmap& stipple);
protected:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
DECLARE_DYNAMIC_CLASS(wxBrush)
};
#ifndef _WX_DFB_CURSOR_H_
#define _WX_DFB_CURSOR_H_
-#include "wx/object.h"
+#include "wx/gdiobj.h"
#include "wx/gdicmn.h"
class WXDLLIMPEXP_FWD_CORE wxBitmap;
// wxCursor
//-----------------------------------------------------------------------------
-class WXDLLIMPEXP_CORE wxCursor: public wxObject
+class WXDLLIMPEXP_CORE wxCursor : public wxGDIObject
{
public:
wxCursor() {}
long flags = wxBITMAP_TYPE_CUR_RESOURCE,
int hotSpotX = 0, int hotSpotY = 0);
- bool Ok() const { return IsOk(); }
- bool IsOk() const;
-
// implementation
wxBitmap GetBitmap() const;
protected:
// ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
DECLARE_DYNAMIC_CLASS(wxCursor)
};
wxIDirectFBFontPtr GetDirectFBFont(bool antialiased) const;
protected:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
private:
DECLARE_DYNAMIC_CLASS(wxFont)
wxDash* GetDash() const;
wxBitmap *GetStipple() const;
- bool Ok() const { return IsOk(); }
- bool IsOk() const;
-
protected:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
DECLARE_DYNAMIC_CLASS(wxPen)
};
wxRect AsRect() const { return GetBox(); }
protected:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
// wxRegionBase pure virtuals
virtual bool DoIsEqual(const wxRegion& region) const;
// from the string representation of wxNativeFontInfo
static wxFont *New(const wxString& strNativeFontDesc);
- // was the font successfully created?
- bool Ok() const { return IsOk(); }
- bool IsOk() const { return m_refData != NULL; }
-
// comparison
- bool operator == (const wxFont& font) const;
- bool operator != (const wxFont& font) const;
+ bool operator==(const wxFont& font) const;
+ bool operator!=(const wxFont& font) const { return !(*this == font); }
// accessors: get the font characteristics
virtual int GetPointSize() const = 0;
// the same native GDI object
// ----------------------------------------------------------------------------
-class WXDLLIMPEXP_FWD_CORE wxGDIRefData: public wxObjectRefData { };
+class WXDLLIMPEXP_FWD_CORE wxGDIRefData : public wxObjectRefData
+{
+public:
+ // override this in the derived classes to check if this data object is
+ // really fully initialized
+ virtual bool IsOk() const { return true; }
+};
// ----------------------------------------------------------------------------
-// wxGDIObject
+// wxGDIObject: base class for bitmaps, pens, brushes, ...
// ----------------------------------------------------------------------------
-class WXDLLIMPEXP_CORE wxGDIObject: public wxObject
+class WXDLLIMPEXP_CORE wxGDIObject : public wxObject
{
public:
+ // checks if the object can be used
+ bool IsOk() const
+ {
+ // the cast here is safe because the derived classes always create
+ // wxGDIRefData objects
+ return m_refData && wx_static_cast(wxGDIRefData *, m_refData)->IsOk();
+ }
+
+ // don't use in the new code, use IsOk() instead
bool IsNull() const { return m_refData == NULL; }
- // older version, for backwards compat
+ // older version, for backwards compatibility only (but not deprecated
+ // because it's still widely used)
bool Ok() const { return IsOk(); }
-
- virtual bool IsOk() const { return (m_refData != NULL) ; }
#if defined(__WXMSW__) || defined(__WXPM__) || defined(__WXPALMOS__)
// Creates the resource
virtual WXHANDLE GetResourceHandle() const { return 0; }
#endif // defined(__WXMSW__) || defined(__WXPM__)
+protected:
+ // replace base class functions using wxObjectRefData with our own which
+ // use wxGDIRefData to ensure that we always work with data objects of the
+ // correct type (i.e. derived from wxGDIRefData)
+ virtual wxObjectRefData *CreateRefData() const
+ {
+ return CreateGDIRefData();
+ }
+
+ virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const
+ {
+ return CloneGDIRefData(wx_static_cast(const wxGDIRefData *, data));
+ }
+
+ virtual wxGDIRefData *CreateGDIRefData() const = 0;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const = 0;
+
DECLARE_DYNAMIC_CLASS(wxGDIObject)
};
-#endif
- // _WX_GDIOBJ_H_BASE_
+#endif // _WX_GDIOBJ_H_BASE_
virtual ~wxColour();
// accessors
- bool IsOk() const { return m_isInit; }
+ virtual bool IsOk() const { return m_isInit; }
unsigned char Red() const { return m_red; }
unsigned char Green() const { return m_green; }
wxPalette();
wxPalette( int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue );
virtual ~wxPalette();
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk() const;
bool Create( int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);
int GetPixel( unsigned char red, unsigned char green, unsigned char blue ) const;
virtual int GetColoursCount() const;
+protected:
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
private:
DECLARE_DYNAMIC_CLASS(wxPalette)
};
virtual bool IsEmpty() const;
protected:
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
// wxRegionBase pure virtuals
virtual bool DoIsEqual(const wxRegion& region) const;
wxBitmap( const wxImage& image, int depth = -1 ) { (void)CreateFromImage(image, depth); }
#endif // wxUSE_IMAGE
virtual ~wxBitmap();
- bool Ok() const { return IsOk(); }
- bool IsOk() const;
bool Create(int width, int height, int depth = -1);
- int GetHeight() const;
- int GetWidth() const;
- int GetDepth() const;
+ virtual int GetHeight() const;
+ virtual int GetWidth() const;
+ virtual int GetDepth() const;
#if wxUSE_IMAGE
wxImage ConvertToImage() const;
bool CreateFromImage(const wxImage& image, int depth);
#endif // wxUSE_IMAGE
- virtual wxObjectRefData* CreateRefData() const;
- virtual wxObjectRefData* CloneRefData(const wxObjectRefData* data) const;
+ virtual wxGDIRefData* CreateGDIRefData() const;
+ virtual wxGDIRefData* CloneGDIRefData(const wxGDIRefData* data) const;
private:
#if wxUSE_IMAGE
wxBrush( const wxBitmap &stippleBitmap );
virtual ~wxBrush();
- bool Ok() const { return IsOk(); }
- bool IsOk() const { return m_refData != NULL; }
-
- bool operator == ( const wxBrush& brush ) const;
- bool operator != (const wxBrush& brush) const { return !(*this == brush); }
+ bool operator==(const wxBrush& brush) const;
+ bool operator!=(const wxBrush& brush) const { return !(*this == brush); }
virtual int GetStyle() const;
wxColour &GetColour() const;
void SetStipple( const wxBitmap& stipple );
protected:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
DECLARE_DYNAMIC_CLASS(wxBrush)
};
virtual ~wxColour();
- bool IsOk() const { return m_refData != NULL; }
-
- bool operator == ( const wxColour& col ) const;
- bool operator != ( const wxColour& col ) const { return !(*this == col); }
+ bool operator==(const wxColour& col) const;
+ bool operator!=(const wxColour& col) const { return !(*this == col); }
unsigned char Red() const;
unsigned char Green() const;
#ifndef _WX_GTK_CURSOR_H_
#define _WX_GTK_CURSOR_H_
-#include "wx/object.h"
+#include "wx/gdiobj.h"
class WXDLLIMPEXP_FWD_CORE wxColour;
class WXDLLIMPEXP_FWD_CORE wxImage;
// wxCursor
//-----------------------------------------------------------------------------
-class WXDLLIMPEXP_CORE wxCursor: public wxObject
+class WXDLLIMPEXP_CORE wxCursor : public wxGDIObject
{
public:
-
wxCursor();
wxCursor( int cursorId );
#if wxUSE_IMAGE
#endif
wxCursor( const char bits[], int width, int height,
int hotSpotX=-1, int hotSpotY=-1,
- const char maskBits[] = NULL, const wxColour *fg = NULL, const wxColour *bg = NULL );
+ const char maskBits[] = NULL,
+ const wxColour *fg = NULL, const wxColour *bg = NULL );
virtual ~wxCursor();
- bool Ok() const { return IsOk(); }
- bool IsOk() const;
// implementation
GdkCursor *GetCursor() const;
+protected:
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
private:
DECLARE_DYNAMIC_CLASS(wxCursor)
};
// common part of all ctors
void Init();
- virtual wxObjectRefData* CreateRefData() const;
- virtual wxObjectRefData* CloneRefData(const wxObjectRefData* data) const;
+ virtual wxGDIRefData* CreateGDIRefData() const;
+ virtual wxGDIRefData* CloneGDIRefData(const wxGDIRefData* data) const;
private:
DECLARE_DYNAMIC_CLASS(wxFont)
wxPen( const wxColour &colour, int width = 1, int style = wxSOLID );
virtual ~wxPen();
- bool Ok() const { return IsOk(); }
- bool IsOk() const { return m_refData != NULL; }
-
- bool operator == ( const wxPen& pen ) const;
- bool operator != (const wxPen& pen) const { return !(*this == pen); }
+ bool operator==(const wxPen& pen) const;
+ bool operator!=(const wxPen& pen) const { return !(*this == pen); }
void SetColour( const wxColour &colour );
void SetColour( unsigned char red, unsigned char green, unsigned char blue );
wxDash* GetDash() const;
protected:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
DECLARE_DYNAMIC_CLASS(wxPen)
};
GdkRegion *GetRegion() const;
protected:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
// wxRegionBase pure virtuals
virtual bool DoIsEqual(const wxRegion& region) const;
wxBitmap( const wxString &filename, wxBitmapType type = wxBITMAP_TYPE_XPM );
wxBitmap( const wxImage& image, int depth = -1 ) { (void)CreateFromImage(image, depth); }
virtual ~wxBitmap();
- bool Ok() const { return IsOk(); }
- bool IsOk() const;
bool Create(int width, int height, int depth = -1);
- int GetHeight() const;
- int GetWidth() const;
- int GetDepth() const;
+ virtual int GetHeight() const;
+ virtual int GetWidth() const;
+ virtual int GetDepth() const;
wxImage ConvertToImage() const;
protected:
bool CreateFromImage(const wxImage& image, int depth);
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
private:
// to be called from CreateFromImage only!
wxBrush( const wxBitmap &stippleBitmap );
virtual ~wxBrush();
- bool Ok() const { return IsOk(); }
- bool IsOk() const { return m_refData != NULL; }
-
- bool operator == ( const wxBrush& brush ) const;
- bool operator != (const wxBrush& brush) const { return !(*this == brush); }
+ bool operator==(const wxBrush& brush) const;
+ bool operator!=(const wxBrush& brush) const { return !(*this == brush); }
virtual int GetStyle() const;
wxColour &GetColour() const;
void SetStipple( const wxBitmap& stipple );
private:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
DECLARE_DYNAMIC_CLASS(wxBrush)
};
virtual bool FromString(const wxString& str);
- bool IsOk() const { return m_refData != NULL; }
-
- bool operator == ( const wxColour& col ) const;
- bool operator != ( const wxColour& col ) const { return !(*this == col); }
+ bool operator==(const wxColour& col) const;
+ bool operator!=(const wxColour& col) const { return !(*this == col); }
unsigned char Red() const;
unsigned char Green() const;
protected:
// ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
virtual void
InitRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a);
#ifndef __GTKCURSORH__
#define __GTKCURSORH__
-#include "wx/defs.h"
-#include "wx/object.h"
+#include "wx/gdiobj.h"
#include "wx/gdicmn.h"
#if wxUSE_IMAGE
// wxCursor
//-----------------------------------------------------------------------------
-class WXDLLIMPEXP_CORE wxCursor: public wxObject
+class WXDLLIMPEXP_CORE wxCursor : public wxGDIObject
{
public:
-
wxCursor();
wxCursor( int cursorId );
#if wxUSE_IMAGE
int hotSpotX=-1, int hotSpotY=-1,
const char maskBits[] = NULL, const wxColour *fg = NULL, const wxColour *bg = NULL );
virtual ~wxCursor();
- bool Ok() const { return IsOk(); }
- bool IsOk() const;
// implementation
GdkCursor *GetCursor() const;
+protected:
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
private:
DECLARE_DYNAMIC_CLASS(wxCursor)
};
GdkFont* GetInternalFont(float scale = 1.0) const;
- // no data :-)
-
protected:
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
virtual void DoSetNativeFontInfo( const wxNativeFontInfo& info );
private:
wxPen( const wxColour &colour, int width = 1, int style = wxSOLID );
virtual ~wxPen();
- bool Ok() const { return IsOk(); }
- bool IsOk() const { return m_refData != NULL; }
-
- bool operator == ( const wxPen& pen ) const;
- bool operator != (const wxPen& pen) const { return !(*this == pen); }
+ bool operator==(const wxPen& pen) const;
+ bool operator!=(const wxPen& pen) const { return !(*this == pen); }
void SetColour( const wxColour &colour );
void SetColour( unsigned char red, unsigned char green, unsigned char blue );
wxDash* GetDash() const;
private:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
DECLARE_DYNAMIC_CLASS(wxPen)
};
GdkRegion *GetRegion() const;
protected:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
// wxRegionBase pure virtuals
virtual bool DoIsEqual(const wxRegion& region) const;
wxIconBundle& operator=(const wxIconBundle& ic)
{ if ( this != &ic) Ref(ic); return *this; }
- virtual bool IsOk() const;
-
// adds all the icons contained in the file to the collection,
// if the collection already contains icons with the same
bool IsEmpty() const { return GetIconCount() == 0; }
protected:
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
private:
// delete all icons
// Construct a mask from a mono bitmap (black meaning show pixels, white meaning transparent)
wxMask(const wxBitmap& bitmap);
-
+
// implementation helper only : construct a mask from a 32 bit memory buffer
wxMask(const wxMemoryBuffer& buf, int width , int height , int bytesPerRow ) ;
void Init() ;
- // a 8 bit depth mask
+ // a 8 bit depth mask
void* GetRawAccess() const;
int GetBytesPerRow() const { return m_bytesPerRow ; }
- // renders/updates native representation when necessary
+ // renders/updates native representation when necessary
void RealizeNative() ;
WXHBITMAP GetHBITMAP() const ;
// copies the contents and mask of the given (colour) icon to the bitmap
virtual bool CopyFromIcon(const wxIcon& icon);
- bool Ok() const { return IsOk(); }
- bool IsOk() const;
int GetWidth() const;
int GetHeight() const;
int GetDepth() const;
bool HasAlpha() const;
void UseAlpha();
- // returns the 'native' implementation, a GWorldPtr for the content and one for the mask
+ // returns the 'native' implementation, a GWorldPtr for the content and one for the mask
WXHBITMAP GetHBITMAP( WXHBITMAP * mask = NULL ) const;
// returns a CGImageRef which must released after usage with CGImageRelease
void EndRawAccess() ;
protected:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
};
-#endif
- // _WX_BITMAP_H_
+
+#endif // _WX_BITMAP_H_
// Brush
class WXDLLEXPORT wxBrush: public wxBrushBase
{
- public:
+public:
wxBrush();
wxBrush(const wxColour& col, int style = wxSOLID);
wxBrush(const wxBitmap& stipple);
virtual void SetStyle(int style) ;
virtual void SetStipple(const wxBitmap& stipple) ;
- bool operator == (const wxBrush& brush) const;
- bool operator != (const wxBrush& brush) const
- { return !(*this == brush); }
+ bool operator==(const wxBrush& brush) const;
+ bool operator!=(const wxBrush& brush) const { return !(*this == brush); }
const wxColour& GetColour() const ;
virtual int GetStyle() const ;
wxBitmap *GetStipple() const ;
protected:
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
private:
- DECLARE_DYNAMIC_CLASS(wxBrush)
+ DECLARE_DYNAMIC_CLASS(wxBrush)
};
-#endif
- // _WX_BRUSH_H_
+#endif // _WX_BRUSH_H_
virtual ~wxColour();
// accessors
- bool IsOk() const;
+ virtual bool IsOk() const { return m_cgColour; }
ChannelType Red() const { return m_red; }
ChannelType Green() const { return m_green; }
#include "wx/bitmap.h"
// Cursor
-class WXDLLEXPORT wxCursor: public wxGDIObject
+class WXDLLEXPORT wxCursor : public wxGDIObject
{
- DECLARE_DYNAMIC_CLASS(wxCursor)
-
public:
- wxCursor();
+ wxCursor();
- wxCursor(const char bits[], int width, int height, int hotSpotX = -1, int hotSpotY = -1,
- const char maskBits[] = NULL);
+ wxCursor(const char bits[], int width, int height,
+ int hotSpotX = -1, int hotSpotY = -1,
+ const char maskBits[] = NULL);
wxCursor(const wxImage & image) ;
wxCursor(const char **bits) ;
wxCursor(char **bits) ;
wxCursor(const wxString& name, long flags = wxBITMAP_TYPE_MACCURSOR_RESOURCE,
- int hotSpotX = 0, int hotSpotY = 0);
+ int hotSpotX = 0, int hotSpotY = 0);
- wxCursor(int cursor_type);
- virtual ~wxCursor();
+ wxCursor(int cursor_type);
+ virtual ~wxCursor();
- bool CreateFromXpm(const char **bits) ;
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk() const ;
+ bool CreateFromXpm(const char **bits) ;
void MacInstall() const ;
- void SetHCURSOR(WXHCURSOR cursor);
- inline WXHCURSOR GetHCURSOR() const ;
-private :
+ void SetHCURSOR(WXHCURSOR cursor);
+ WXHCURSOR GetHCURSOR() const;
+
+private:
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
void CreateFromImage(const wxImage & image) ;
+
+ DECLARE_DYNAMIC_CLASS(wxCursor)
};
extern WXDLLEXPORT void wxSetCursor(const wxCursor& cursor);
-#endif
- // _WX_CURSOR_H_
+#endif // _WX_CURSOR_H_
bool MacCreateFromThemeFont( wxUint16 themeFontID ) ;
#if wxMAC_USE_CORE_TEXT
- bool MacCreateFromUIFont( wxUint32 coreTextFontType );
+ bool MacCreateFromUIFont( wxUint32 coreTextFontType );
bool MacCreateFromCTFontDescriptor( const void * ctFontDescriptor, int pointSize = 0 );
bool MacCreateFromCTFont( const void * ctFont );
#endif
-
+
virtual ~wxFont();
// implement base class pure virtuals
virtual bool GetNoAntiAliasing() const ;
// Mac-specific, risks to change, don't use in portable code
-
+
#if wxMAC_USE_ATSU_TEXT
// 'old' Quickdraw accessors
short MacGetFontNum() const;
short MacGetFontSize() const;
wxByte MacGetFontStyle() const;
-
+
// 'new' ATSUI accessors
wxUint32 MacGetATSUFontID() const;
wxUint32 MacGetATSUAdditionalQDStyles() const;
const void * MacGetCTFontDescriptor() const;
#endif
#if wxMAC_USE_CORE_TEXT || wxMAC_USE_ATSU_TEXT
- void* MacGetATSUStyle() const ;
+ void* MacGetATSUStyle() const ;
#endif
-
+
+protected:
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
private:
void Unshare();
DECLARE_DYNAMIC_CLASS(wxFont)
};
-#endif
- // _WX_FONT_H_
+#endif // _WX_FONT_H_
#include "wx/bitmap.h"
// Icon
-class WXDLLEXPORT wxIcon: public wxGDIObject
+class WXDLLEXPORT wxIcon : public wxGDIObject
{
public:
wxIcon();
// ctors, assignment operators...), but it's ok to have such function
void CopyFromBitmap(const wxBitmap& bmp);
- bool Ok() const { return IsOk(); }
- bool IsOk() const;
int GetWidth() const;
int GetHeight() const;
int GetDepth() const;
WXHICON GetHICON() const ;
+protected:
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
+private:
DECLARE_DYNAMIC_CLASS(wxIcon)
};
#define M_METAFILEDATA ((wxMetafileRefData *)m_refData)
-class WXDLLEXPORT wxMetafile: public wxGDIObject
+class WXDLLEXPORT wxMetafile : public wxGDIObject
{
- DECLARE_DYNAMIC_CLASS(wxMetafile)
public:
wxMetafile(const wxString& file = wxEmptyString);
virtual ~wxMetafile(void);
virtual bool SetClipboard(int width = 0, int height = 0);
virtual bool Play(wxDC *dc);
- bool Ok() const { return IsOk(); }
- bool IsOk() const ;
wxSize GetSize() const;
int GetWidth() const { return GetSize().x; }
// backwards compatibility
void SetPICT(void* pictHandle) ;
#endif
+
+protected:
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
+ DECLARE_DYNAMIC_CLASS(wxMetafile)
};
virtual void DoGetSize(int *width, int *height) const;
wxMetafile* m_metaFile;
-
+
private:
DECLARE_CLASS(wxMetafileDCImpl)
DECLARE_NO_COPY_CLASS(wxMetafileDCImpl)
const wxString& description = wxEmptyString ) :
wxDC( new wxMetafileDCImpl( this, filename, width, height, description) )
{ }
-
- wxMetafile *GetMetafile() const
+
+ wxMetafile *GetMetafile() const
{ return ((wxMetafileDCImpl*)m_pimpl)->GetMetaFile(); }
-
+
wxMetafile *Close()
{ return ((wxMetafileDCImpl*)m_pimpl)->Close(); }
-
+
private:
DECLARE_CLASS(wxMetafileDC)
DECLARE_NO_COPY_CLASS(wxMetafileDC)
};
-
-
+
+
/*
* Pass filename of existing non-placeable metafile, and bounding box.
* Adds a placeable metafile header, sets the mapping mode to anisotropic,
{
public:
// ctors
- wxMetafileDataObject()
+ wxMetafileDataObject()
: wxDataObjectSimple(wxDF_METAFILE) { };
wxMetafileDataObject(const wxMetafile& metafile)
: wxDataObjectSimple(wxDF_METAFILE), m_metafile(metafile) { }
#ifndef _WX_PALETTE_H_
#define _WX_PALETTE_H_
-#include "wx/colour.h"
#include "wx/gdiobj.h"
-class WXDLLIMPEXP_FWD_CORE wxPalette;
-
-class WXDLLEXPORT wxPaletteRefData: public wxGDIRefData
-{
- DECLARE_NO_COPY_CLASS(wxPaletteRefData)
-
- friend class WXDLLIMPEXP_FWD_CORE wxPalette;
-public:
- wxPaletteRefData();
- virtual ~wxPaletteRefData();
-protected:
- wxColour* m_palette;
- wxInt32 m_count ;
-};
-
#define M_PALETTEDATA ((wxPaletteRefData *)m_refData)
-class WXDLLEXPORT wxPalette: public wxPaletteBase
+class WXDLLEXPORT wxPalette : public wxPaletteBase
{
public:
wxPalette();
wxPalette(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);
virtual ~wxPalette();
bool Create(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);
-
+
int GetPixel(unsigned char red, unsigned char green, unsigned char blue) const;
bool GetRGB(int pixel, unsigned char *red, unsigned char *green, unsigned char *blue) const;
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk() const { return (m_refData != NULL) ; }
-
virtual int GetColoursCount() const;
-
+
+protected:
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
private:
DECLARE_DYNAMIC_CLASS(wxPalette)
};
-#endif
- // _WX_PALETTE_H_
+#endif // _WX_PALETTE_H_
#include "wx/colour.h"
#include "wx/bitmap.h"
-class WXDLLIMPEXP_FWD_CORE wxPen;
-
// Pen
-class WXDLLEXPORT wxPen: public wxGDIObject
+class WXDLLEXPORT wxPen : public wxGDIObject
{
- DECLARE_DYNAMIC_CLASS(wxPen)
public:
- wxPen();
- wxPen(const wxColour& col, int width = 1, int style = wxSOLID);
- wxPen(const wxBitmap& stipple, int width);
- virtual ~wxPen();
+ wxPen();
+ wxPen(const wxColour& col, int width = 1, int style = wxSOLID);
+ wxPen(const wxBitmap& stipple, int width);
+ virtual ~wxPen();
+
+ bool operator==(const wxPen& pen) const;
+ bool operator!=(const wxPen& pen) const { return !(*this == pen); }
- bool operator == (const wxPen& pen) const;
- bool operator != (const wxPen& pen) const { return !(*this == pen); }
+ // Override in order to recreate the pen
+ void SetColour(const wxColour& col) ;
+ void SetColour(unsigned char r, unsigned char g, unsigned char b) ;
- // Override in order to recreate the pen
- void SetColour(const wxColour& col) ;
- void SetColour(unsigned char r, unsigned char g, unsigned char b) ;
+ void SetWidth(int width) ;
+ void SetStyle(int style) ;
+ void SetStipple(const wxBitmap& stipple) ;
+ void SetDashes(int nb_dashes, const wxDash *dash) ;
+ void SetJoin(int join) ;
+ void SetCap(int cap) ;
- void SetWidth(int width) ;
- void SetStyle(int style) ;
- void SetStipple(const wxBitmap& stipple) ;
- void SetDashes(int nb_dashes, const wxDash *dash) ;
- void SetJoin(int join) ;
- void SetCap(int cap) ;
+ wxColour& GetColour() const ;
+ int GetWidth() const;
+ int GetStyle() const;
+ int GetJoin() const;
+ int GetCap() const;
+ int GetDashes(wxDash **ptr) const;
- wxColour& GetColour() const ;
- int GetWidth() const;
- int GetStyle() const;
- int GetJoin() const;
- int GetCap() const;
- int GetDashes(wxDash **ptr) const;
+ wxBitmap *GetStipple() const ;
- wxBitmap *GetStipple() const ;
+ // Implementation
-// Implementation
+ // Useful helper: create the brush resource
+ bool RealizeResource();
- // Useful helper: create the brush resource
- bool RealizeResource();
+protected:
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
private:
void Unshare();
+
+ DECLARE_DYNAMIC_CLASS(wxPen)
};
#endif
const WXHRGN GetWXHRGN() const ;
protected:
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
virtual bool DoIsEqual(const wxRegion& region) const;
virtual bool DoGetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const;
virtual wxRegionContain DoContainsPoint(wxCoord x, wxCoord y) const;
wxBitmap(const wxString &filename, wxBitmapType type = wxBITMAP_TYPE_RESOURCE);
wxBitmap(const wxImage& image, int depth = -1);
virtual ~wxBitmap() {}
- bool Ok() const { return IsOk(); }
- bool IsOk() const;
bool Create(int width, int height, int depth = -1);
// wxBrush
//-----------------------------------------------------------------------------
-class WXDLLEXPORT wxBrush: public wxBrushBase
+class WXDLLEXPORT wxBrush : public wxBrushBase
{
public:
wxBrush() {}
wxBrush(const wxColour &colour, int style = wxSOLID);
wxBrush(const wxBitmap &stippleBitmap);
- virtual ~wxBrush() {}
- bool operator == (const wxBrush& brush) const;
- bool operator != (const wxBrush& brush) const;
- bool Ok() const { return IsOk(); }
- bool IsOk() const;
+
+ bool operator==(const wxBrush& brush) const;
+ bool operator!=(const wxBrush& brush) const;
virtual int GetStyle() const;
wxColour &GetColour() const;
void* GetPixPattern() const;
protected:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
private:
DECLARE_DYNAMIC_CLASS(wxBrush)
#ifndef __WX_CURSOR_H__
#define __WX_CURSOR_H__
-#include "wx/defs.h"
-#include "wx/object.h"
+#include "wx/gdiobj.h"
#include "wx/gdicmn.h"
class MGLCursor;
// wxCursor
//-----------------------------------------------------------------------------
-class WXDLLEXPORT wxCursor: public wxObject
+class WXDLLEXPORT wxCursor : public wxGDIObject
{
public:
long flags = wxBITMAP_TYPE_CUR_RESOURCE,
int hotSpotX = 0, int hotSpotY = 0);
virtual ~wxCursor();
- bool Ok() const { return IsOk(); }
- bool IsOk() const;
// implementation
MGLCursor *GetMGLCursor() const;
protected:
// ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
private:
DECLARE_DYNAMIC_CLASS(wxFont)
// wxPalette
//-----------------------------------------------------------------------------
-class WXDLLEXPORT wxPalette: public wxPaletteBase
+class WXDLLEXPORT wxPalette : public wxPaletteBase
{
- DECLARE_DYNAMIC_CLASS(wxPalette)
-
public:
wxPalette();
wxPalette(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);
virtual ~wxPalette();
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk() const;
bool Create(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);
int GetPixel(unsigned char red, unsigned char green, unsigned char blue) const;
virtual int GetColoursCount() const;
palette_t *GetMGLpalette_t() const;
+
+ DECLARE_DYNAMIC_CLASS(wxPalette)
};
#endif // __WX_PALETTE_H__
// wxPen
//-----------------------------------------------------------------------------
-class WXDLLEXPORT wxPen: public wxGDIObject
+class WXDLLEXPORT wxPen : public wxGDIObject
{
public:
wxPen() {}
wxDash* GetDash() const;
wxBitmap *GetStipple() const;
- bool Ok() const { return IsOk(); }
- bool IsOk() const;
-
// implementation:
void* GetPixPattern() const;
protected:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
private:
DECLARE_DYNAMIC_CLASS(wxPen)
const MGLRegion& GetMGLRegion() const;
protected:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
// wxRegionBase pure virtuals
virtual bool DoIsEqual(const wxRegion& region) const;
// accessors
- bool IsOk() const {return m_isInit; }
+ virtual bool IsOk() const {return m_isInit; }
unsigned char Red() const { return m_red; }
unsigned char Green() const { return m_green; }
unsigned char Blue() const { return m_blue; }
#ifndef _WX_CURSOR_H_
#define _WX_CURSOR_H_
-#include "wx/object.h"
+#include "wx/gdiobj.h"
#include "wx/gdicmn.h"
class WXDLLIMPEXP_FWD_CORE wxImage;
// Cursor
-class WXDLLEXPORT wxCursor: public wxObject
+class WXDLLEXPORT wxCursor : public wxGDIObject
{
- DECLARE_DYNAMIC_CLASS(wxCursor)
-
public:
wxCursor();
wxCursor(wxStockCursor id);
virtual ~wxCursor();
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk() const;
-
// Motif-specific.
// Create/get a cursor for the current display
WXCursor GetXCursor(WXDisplay* display) const;
+
+protected:
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
private:
void Create(const char bits[], int width, int height,
int hotSpotX = -1, int hotSpotY = -1,
// Make a cursor from standard id
WXCursor MakeCursor(WXDisplay* display, wxStockCursor id) const;
+
+ DECLARE_DYNAMIC_CLASS(wxCursor)
};
extern WXDLLEXPORT void wxSetCursor(const wxCursor& cursor);
// like the function above but does a copy for XmFontList
WXFontType GetFontTypeC(WXDisplay* display) const;
static WXString GetFontTag();
+
protected:
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
virtual void DoSetNativeFontInfo( const wxNativeFontInfo& info );
void Unshare();
DECLARE_DYNAMIC_CLASS(wxFont)
};
-#endif
-// _WX_FONT_H_
+#endif // _WX_FONT_H_
protected:
virtual wxGDIImageRefData *CreateData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
// creates an uninitialized bitmap, called from Create()s above
bool DoCreate(int w, int h, int depth, WXHDC hdc);
virtual int GetStyle() const;
wxBitmap *GetStipple() const;
- bool Ok() const { return IsOk(); }
- bool IsOk() const { return m_refData != NULL; }
-
// return the HBRUSH for this brush
virtual WXHANDLE GetResourceHandle() const;
protected:
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
private:
DECLARE_DYNAMIC_CLASS(wxBrush)
};
-#endif
- // _WX_BRUSH_H_
+#endif // _WX_BRUSH_H_
// accessors
// ---------
- bool IsOk() const { return m_isInit; }
+ virtual bool IsOk() const { return m_isInit; }
unsigned char Red() const { return m_red; }
unsigned char Green() const { return m_green; }
#define _WX_MSW_ENHMETA_H_
#include "wx/dc.h"
+#include "wx/gdiobj.h"
#if wxUSE_DRAG_AND_DROP
#include "wx/dataobj.h"
// wxEnhMetaFile: encapsulation of Win32 HENHMETAFILE
// ----------------------------------------------------------------------------
-class WXDLLEXPORT wxEnhMetaFile : public wxObject
+class WXDLLEXPORT wxEnhMetaFile : public wxGDIObject
{
public:
wxEnhMetaFile(const wxString& file = wxEmptyString) : m_filename(file)
{ Init(); }
- wxEnhMetaFile(const wxEnhMetaFile& metafile) : wxObject()
+ wxEnhMetaFile(const wxEnhMetaFile& metafile) : wxGDIObject()
{ Init(); Assign(metafile); }
wxEnhMetaFile& operator=(const wxEnhMetaFile& metafile)
{ Free(); Assign(metafile); return *this; }
bool Play(wxDC *dc, wxRect *rectBound = (wxRect *)NULL);
// accessors
- bool Ok() const { return IsOk(); }
- bool IsOk() const { return m_hMF != 0; }
+ virtual bool IsOk() const { return m_hMF != 0; }
wxSize GetSize() const;
int GetWidth() const { return GetSize().x; }
void Free();
void Assign(const wxEnhMetaFile& mf);
+ // we don't use these functions (but probably should) but have to implement
+ // them as they're pure virtual in the base class
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
private:
wxString m_filename;
WXHANDLE m_hMF;
virtual void DoSetNativeFontInfo(const wxNativeFontInfo& info);
// implement wxObject virtuals which are used by AllocExclusive()
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
private:
DECLARE_DYNAMIC_CLASS(wxFont)
}
// accessors
- bool IsOk() const { return m_handle != 0; }
+ virtual bool IsOk() const { return m_handle != 0; }
void SetSize(int w, int h) { m_width = w; m_height = h; }
void SetHandle(WXHANDLE handle)
{ AllocExclusive(); GetGDIImageData()->m_handle = handle; }
- bool Ok() const { return IsOk(); }
- bool IsOk() const { return GetHandle() != 0; }
-
int GetWidth() const { return IsNull() ? 0 : GetGDIImageData()->m_width; }
int GetHeight() const { return IsNull() ? 0 : GetGDIImageData()->m_height; }
int GetDepth() const { return IsNull() ? 0 : GetGDIImageData()->m_depth; }
// create the data for the derived class here
virtual wxGDIImageRefData *CreateData() const = 0;
- // implement the wxObject method in terms of our, more specific, one
- virtual wxObjectRefData *CreateRefData() const { return CreateData(); }
+ // implement the wxGDIObject method in terms of our, more specific, one
+ virtual wxGDIRefData *CreateGDIRefData() const { return CreateData(); }
+
+ // we can't [efficiently] clone objects of this class
+ virtual wxGDIRefData *
+ CloneGDIRefData(const wxGDIRefData *WXUNUSED(data)) const
+ {
+ wxFAIL_MSG( _T("must be implemented if used") );
+
+ return NULL;
+ }
static wxGDIImageHandlerList ms_handlers;
};
class WXDLLEXPORT wxMetafileRefData: public wxGDIRefData
{
- friend class WXDLLIMPEXP_FWD_CORE wxMetafile;
public:
wxMetafileRefData();
virtual ~wxMetafileRefData();
+ virtual bool IsOk() const { return m_metafile != 0; }
+
public:
WXHANDLE m_metafile;
int m_windowsMappingMode;
int m_width, m_height;
+
+ friend class WXDLLIMPEXP_FWD_CORE wxMetafile;
};
#define M_METAFILEDATA ((wxMetafileRefData *)m_refData)
virtual bool SetClipboard(int width = 0, int height = 0);
virtual bool Play(wxDC *dc);
- bool Ok() const { return IsOk(); }
- bool IsOk() const { return (M_METAFILEDATA && (M_METAFILEDATA->m_metafile != 0)); };
// set/get the size of metafile for clipboard operations
wxSize GetSize() const { return wxSize(GetWidth(), GetHeight()); }
protected:
virtual void DoGetSize(int *width, int *height) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
int m_windowsMappingMode;
wxMetafile* m_metaFile;
#include "wx/gdiobj.h"
-class WXDLLIMPEXP_FWD_CORE wxPalette;
-
-class WXDLLEXPORT wxPaletteRefData: public wxGDIRefData
+class WXDLLEXPORT wxPalette : public wxPaletteBase
{
- friend class WXDLLIMPEXP_FWD_CORE wxPalette;
public:
- wxPaletteRefData(void);
- virtual ~wxPaletteRefData(void);
-protected:
- WXHPALETTE m_hPalette;
-};
+ wxPalette() { }
+ wxPalette(int n,
+ unsigned char *red, unsigned char *green, unsigned char *blue)
+ {
+ Create(n, red, green, blue);
+ }
-#define M_PALETTEDATA ((wxPaletteRefData *)m_refData)
-
-class WXDLLEXPORT wxPalette: public wxPaletteBase
-{
-public:
- wxPalette();
- wxPalette(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);
- virtual ~wxPalette(void);
- bool Create(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);
-
- int GetPixel(unsigned char red, unsigned char green, unsigned char blue) const;
- bool GetRGB(int pixel, unsigned char *red, unsigned char *green, unsigned char *blue) const;
+ bool Create(int n,
+ unsigned char *red, unsigned char *green, unsigned char *blue);
virtual int GetColoursCount() const;
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk(void) const { return (m_refData != NULL) ; }
+ int
+ GetPixel(unsigned char red, unsigned char green, unsigned char blue) const;
- virtual bool FreeResource(bool force = false);
+ bool
+ GetRGB(int pixel,
+ unsigned char *red, unsigned char *green, unsigned char *blue) const;
// implemetation
- inline WXHPALETTE GetHPALETTE(void) const { return (M_PALETTEDATA ? M_PALETTEDATA->m_hPalette : 0); }
+ WXHPALETTE GetHPALETTE() const;
void SetHPALETTE(WXHPALETTE pal);
-
+
+protected:
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
private:
DECLARE_DYNAMIC_CLASS(wxPalette)
};
-#endif
- // _WX_PALETTE_H_
+#endif // _WX_PALETTE_H_
bool operator==(const wxPen& pen) const;
bool operator!=(const wxPen& pen) const { return !(*this == pen); }
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk() const { return (m_refData != NULL); }
-
// Override in order to recreate the pen
void SetColour(const wxColour& col);
void SetColour(unsigned char r, unsigned char g, unsigned char b);
virtual bool IsFree() const;
protected:
- virtual wxObjectRefData* CreateRefData() const;
- virtual wxObjectRefData* CloneRefData(const wxObjectRefData* data) const;
+ virtual wxGDIRefData* CreateGDIRefData() const;
+ virtual wxGDIRefData* CloneGDIRefData(const wxGDIRefData* data) const;
// same as FreeResource() + RealizeResource()
bool Recreate();
WXHRGN GetHRGN() const;
protected:
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
virtual bool DoIsEqual(const wxRegion& region) const;
virtual bool DoGetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const;
bool CreateFromImage(const wxImage& image, int depth);
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
private:
bool CopyFromIconOrCursor(const wxGDIImage& rIcon);
inline wxBitmap* GetStipple(void) const { return (M_BRUSHDATA ? & M_BRUSHDATA->m_vStipple : 0); };
inline int GetPS(void) const { return (M_BRUSHDATA ? M_BRUSHDATA->m_hBrush : 0); };
- inline virtual bool Ok() const { return IsOk(); }
- inline virtual bool IsOk(void) const { return (m_refData != NULL) ; }
-
//
// Implementation
//
virtual ~wxColour();
// Accessors
- bool IsOk(void) const {return m_bIsInit; }
+ virtual bool IsOk(void) const { return m_bIsInit; }
unsigned char Red(void) const { return m_cRed; }
unsigned char Green(void) const { return m_cGreen; }
}
// accessors
- bool IsOk() const
+ virtual bool IsOk() const
{
if (m_hHandle == 0)
return false;
pData->m_hHandle = hHandle;
}
- bool Ok() const { return IsOk(); }
- bool IsOk() const { return GetHandle() != 0; }
-
int GetWidth() const { return IsNull() ? 0 : GetGDIImageData()->m_nWidth; }
int GetHeight() const { return IsNull() ? 0 : GetGDIImageData()->m_nHeight; }
int GetDepth() const { return IsNull() ? 0 : GetGDIImageData()->m_nDepth; }
protected:
// create the data for the derived class here
virtual wxGDIImageRefData* CreateData() const = 0;
+ virtual wxGDIRefData *CreateGDIRefData() const { return CreateData(); }
static wxGDIImageHandlerList ms_handlers;
};
wxMetafileRefData(void);
virtual ~wxMetafileRefData(void);
+ virtual bool IsOk() const { return m_metafile != 0; }
+
public:
WXHANDLE m_metafile;
int m_windowsMappingMode;
virtual bool SetClipboard(int width = 0, int height = 0);
virtual bool Play(wxDC *dc);
- inline bool Ok() const { return IsOk(); }
- inline bool IsOk(void) const { return (M_METAFILEDATA && (M_METAFILEDATA->m_metafile != 0)); };
// Implementation
inline WXHANDLE GetHMETAFILE(void) { return M_METAFILEDATA->m_metafile; }
,unsigned char* pBlue
) const;
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk(void) const { return (m_refData != NULL) ; }
-
virtual bool FreeResource(bool bForce = false);
inline WXHPALETTE GetHPALETTE(void) const { return (M_PALETTEDATA ? M_PALETTEDATA->m_hPalette : 0); }
inline bool operator != (const wxPen& rPen) const
{ return !(*this == rPen); }
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk(void) const { return (m_refData != NULL); }
-
//
// Override in order to recreate the pen
//
void SetPS(HPS hPS);
protected:
- virtual wxObjectRefData* CreateData(void) const;
- virtual wxObjectRefData* CloneData(const wxObjectRefData* pData) const;
+ virtual wxGDIRefData* CreateData(void) const;
+ virtual wxGDIRefData* CloneData(const wxGDIRefData* pData) const;
virtual bool DoIsEqual(const wxRegion& region) const;
virtual bool DoGetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const;
public:
virtual ~wxPaletteBase() { }
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk() const = 0;
virtual int GetColoursCount() const { wxFAIL_MSG( _T("not implemented") ); return 0; }
};
virtual int GetStyle() const;
wxBitmap *GetStipple() const;
- bool Ok() const { return IsOk(); }
- bool IsOk() const { return m_refData != NULL; }
-
// return the HBRUSH for this brush
virtual WXHANDLE GetResourceHandle() const;
protected:
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
private:
DECLARE_DYNAMIC_CLASS(wxBrush)
};
-#endif
- // _WX_BRUSH_H_
+#endif // _WX_BRUSH_H_
#define _WX_PALMOS_ENHMETA_H_
#include "wx/dc.h"
+#include "wx/gdiobj.h"
#if wxUSE_DRAG_AND_DROP
#include "wx/dataobj.h"
// wxEnhMetaFile: encapsulation of Win32 HENHMETAFILE
// ----------------------------------------------------------------------------
-class WXDLLEXPORT wxEnhMetaFile : public wxObject
+class WXDLLEXPORT wxEnhMetaFile : public wxGDIObject
{
public:
wxEnhMetaFile(const wxString& file = wxEmptyString) : m_filename(file)
bool Play(wxDC *dc, wxRect *rectBound = (wxRect *)NULL);
// accessors
- bool Ok() const { return IsOk(); }
- bool IsOk() const { return m_hMF != 0; }
+ virtual bool IsOk() const { return m_hMF != 0; }
wxSize GetSize() const;
int GetWidth() const { return GetSize().x; }
}
// accessors
- bool IsOk() const { return m_handle != 0; }
+ virtual bool IsOk() const { return m_handle != 0; }
void SetSize(int w, int h) { m_width = w; m_height = h; }
void SetHandle(WXHANDLE handle)
{ EnsureHasData(); GetGDIImageData()->m_handle = handle; }
- bool Ok() const { return IsOk(); }
- bool IsOk() const { return GetHandle() != 0; }
-
int GetWidth() const { return IsNull() ? 0 : GetGDIImageData()->m_width; }
int GetHeight() const { return IsNull() ? 0 : GetGDIImageData()->m_height; }
int GetDepth() const { return IsNull() ? 0 : GetGDIImageData()->m_depth; }
protected:
// create the data for the derived class here
virtual wxGDIImageRefData *CreateData() const = 0;
+ virtual wxGDIRefData *CreateGDIRefData() const { return CreateData(); }
static wxGDIImageHandlerList ms_handlers;
};
class WXDLLEXPORT wxMetafileRefData: public wxGDIRefData
{
- friend class WXDLLIMPEXP_FWD_CORE wxMetafile;
public:
wxMetafileRefData();
virtual ~wxMetafileRefData();
+ virtual bool IsOk() const { return m_metafile != 0; }
+
public:
WXHANDLE m_metafile;
int m_windowsMappingMode;
int m_width, m_height;
+
+ friend class WXDLLIMPEXP_FWD_CORE wxMetafile;
};
#define M_METAFILEDATA ((wxMetafileRefData *)m_refData)
virtual bool SetClipboard(int width = 0, int height = 0);
virtual bool Play(wxDC *dc);
- bool Ok() const { return IsOk(); }
- bool IsOk() const { return (M_METAFILEDATA && (M_METAFILEDATA->m_metafile != 0)); };
// set/get the size of metafile for clipboard operations
wxSize GetSize() const { return wxSize(GetWidth(), GetHeight()); }
int GetPixel(unsigned char red, unsigned char green, unsigned char blue) const;
bool GetRGB(int pixel, unsigned char *red, unsigned char *green, unsigned char *blue) const;
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk(void) const { return (m_refData != NULL) ; }
-
virtual bool FreeResource(bool force = false);
inline WXHPALETTE GetHPALETTE(void) const { return (M_PALETTEDATA ? M_PALETTEDATA->m_hPalette : 0); }
bool operator!=(const wxPen& pen) const { return !(*this == pen); }
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk() const { return (m_refData != NULL); }
-
// Override in order to recreate the pen
void SetColour(const wxColour& col);
void SetColour(unsigned char r, unsigned char g, unsigned char b);
WXHRGN GetHRGN() const;
protected:
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
virtual bool DoIsEqual(const wxRegion& region) const;
virtual bool DoGetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const;
/// wxFontMgrFontRefData implementation using wxFontsManager classes
-class wxFontMgrFontRefData : public wxObjectRefData
+class wxFontMgrFontRefData : public wxGDIRefData
{
public:
wxFontMgrFontRefData(int size = wxDEFAULT,
// accessors
// ---------
- bool Ok() const { return IsOk(); }
- bool IsOk() const { return m_refData != NULL; }
-
// Is region empty?
virtual bool IsEmpty() const = 0;
bool Empty() const { return IsEmpty(); }
wxBitmap( const wxString &filename, wxBitmapType type = wxBITMAP_TYPE_XPM );
virtual ~wxBitmap();
- bool Ok() const { return IsOk(); }
- bool IsOk() const;
-
static void InitStandardHandlers();
bool Create(int width, int height, int depth = -1);
WXDisplay *GetDisplay() const;
protected:
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
private:
DECLARE_DYNAMIC_CLASS(wxBitmap)
// wxBrush
//-----------------------------------------------------------------------------
-class WXDLLIMPEXP_CORE wxBrush: public wxBrushBase
+class WXDLLIMPEXP_CORE wxBrush : public wxBrushBase
{
public:
wxBrush() { }
wxBrush( const wxBitmap &stippleBitmap );
virtual ~wxBrush();
- bool Ok() const { return IsOk(); }
- bool IsOk() const { return m_refData != NULL; }
-
- bool operator == ( const wxBrush& brush ) const;
- bool operator != (const wxBrush& brush) const { return !(*this == brush); }
+ bool operator==(const wxBrush& brush) const;
+ bool operator!=(const wxBrush& brush) const { return !(*this == brush); }
virtual int GetStyle() const;
wxColour &GetColour() const;
void SetStipple( const wxBitmap& stipple );
protected:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
DECLARE_DYNAMIC_CLASS(wxBrush)
};
-#endif
-// _WX_BRUSH_H_
+#endif // _WX_BRUSH_H_
virtual ~wxColour();
- bool IsOk() const { return m_refData != NULL; }
-
- bool operator == ( const wxColour& col ) const;
- bool operator != ( const wxColour& col ) const { return !(*this == col); }
+ bool operator==(const wxColour& col) const;
+ bool operator!=(const wxColour& col) const { return !(*this == col); }
unsigned char Red() const;
unsigned char Green() const;
WXColor *GetColor() const;
protected:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
virtual void
InitRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a);
DECLARE_DYNAMIC_CLASS(wxColour)
};
-#endif
-
-// _WX_COLOUR_H_
+#endif // _WX_COLOUR_H_
#ifndef _WX_CURSOR_H_
#define _WX_CURSOR_H_
-#include "wx/bitmap.h"
+#include "wx/gdiobj.h"
-#if wxUSE_IMAGE
-#include "wx/image.h"
-#endif
+class WXDLLIMPEXP_FWD_CORE wxImage;
//-----------------------------------------------------------------------------
// wxCursor
//-----------------------------------------------------------------------------
-class WXDLLIMPEXP_CORE wxCursor: public wxObject
+class WXDLLIMPEXP_CORE wxCursor : public wxGDIObject
{
public:
-
wxCursor();
wxCursor( int cursorId );
#if wxUSE_IMAGE
wxCursor( const wxImage & image );
#endif
+
wxCursor( const char bits[], int width, int height,
int hotSpotX=-1, int hotSpotY=-1,
const char maskBits[]=0, wxColour *fg=0, wxColour *bg=0 );
virtual ~wxCursor();
- bool Ok() const { return IsOk(); }
- bool IsOk() const;
// implementation
WXCursor GetCursor() const;
+protected:
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
private:
DECLARE_DYNAMIC_CLASS(wxCursor)
};
-
-#endif
- // _WX_CURSOR_H_
+#endif // _WX_CURSOR_H_
#endif
protected:
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
+
virtual void DoSetNativeFontInfo( const wxNativeFontInfo& info );
void Unshare();
#ifndef _WX_PALETTE_H_
#define _WX_PALETTE_H_
-#include "wx/gdiobj.h"
#include "wx/list.h"
class WXDLLIMPEXP_FWD_CORE wxPalette;
#define M_PALETTEDATA ((wxPaletteRefData *)m_refData)
-class WXDLLEXPORT wxPalette: public wxPaletteBase
+class WXDLLEXPORT wxPalette : public wxPaletteBase
{
DECLARE_DYNAMIC_CLASS(wxPalette)
int GetPixel(unsigned char red, unsigned char green, unsigned char blue) const;
bool GetRGB(int pixel, unsigned char *red, unsigned char *green, unsigned char *blue) const;
- virtual bool Ok() const { return IsOk(); }
- virtual bool IsOk() const { return (m_refData != NULL) ; }
-
// X-specific
WXColormap GetXColormap(WXDisplay* display = NULL) const;
bool TransferBitmap(void *data, int depth, int size);
bool TransferBitmap8(unsigned char *data, unsigned long size, void *dest, unsigned int bpp);
unsigned long *GetXPixArray(WXDisplay* display, int *pix_array_n);
void PutXColormap(WXDisplay* display, WXColormap cmap, bool destroyable);
+
+protected:
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
};
-#endif
-// _WX_PALETTE_H_
+#endif // _WX_PALETTE_H_
wxPen( const wxBitmap &stipple, int width );
virtual ~wxPen();
- bool Ok() const { return IsOk(); }
- bool IsOk() const { return m_refData != NULL; }
-
bool operator == ( const wxPen& pen ) const;
bool operator != (const wxPen& pen) const { return !(*this == pen); }
wxBitmap* GetStipple() const;
protected:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
DECLARE_DYNAMIC_CLASS(wxPen)
};
-#endif
-// _WX_PEN_H_
+#endif // _WX_PEN_H_
WXRegion *GetX11Region() const;
protected:
- // ref counting code
- virtual wxObjectRefData *CreateRefData() const;
- virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
+ virtual wxGDIRefData *CreateGDIRefData() const;
+ virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
// wxRegionBase pure virtuals
virtual bool DoIsEqual(const wxRegion& region) const;
wxBitmapRefData( const wxBitmapRefData& data );
virtual ~wxBitmapRefData();
+ virtual bool IsOk() const { return m_ok; }
+
protected:
int m_width;
int m_height;
LoadFile(filename, type);
}
-wxObjectRefData *wxBitmap::CreateRefData() const
+wxGDIRefData *wxBitmap::CreateGDIRefData() const
{
return new wxBitmapRefData;
}
-wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxBitmap::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxBitmapRefData(*(wxBitmapRefData*)data);
}
M_BITMAPDATA->m_bitmapMask = mask ;
}
-bool wxBitmap::IsOk() const
-{
- return m_refData && M_BITMAPDATA->m_ok;
-}
-
wxPalette* wxBitmap::GetPalette() const
{
if(!m_refData)
m_refData = new wxBrushRefData(stipple);
}
-wxObjectRefData *wxBrush::CreateRefData() const
+wxGDIRefData *wxBrush::CreateGDIRefData() const
{
return new wxBrushRefData;
}
-wxObjectRefData *wxBrush::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxBrush::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxBrushRefData(*(wxBrushRefData *)data);
}
{
UnRef();
m_refData = refData;
-
+
return m_refData != NULL;
}
{
UnRef();
m_refData = new wxFontRefData(nativeFontInfo);
-
+
return true;
}
+wxGDIRefData *wxFont::CreateGDIRefData() const
+{
+ return new wxFontRefData;
+}
+
+wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxFontRefData(*wx_static_cast(const wxFontRefData *, data));
+}
+
void wxFont::SetEncoding(wxFontEncoding)
{
}
return false;
}
-void wxFont::Unshare()
-{
- // Don't change shared data
- if (!m_refData)
- {
- m_refData = new wxFontRefData();
- }
- else
- {
- wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
- UnRef();
- m_refData = ref;
- }
-}
-
void wxFont::SetPointSize(int pointSize)
{
- Unshare();
+ AllocExclusive();
M_FONTDATA->m_info.pointSize = pointSize;
void wxFont::SetFamily(int family)
{
- Unshare();
+ AllocExclusive();
M_FONTDATA->m_info.family = static_cast<wxFontFamily>(family);
void wxFont::SetStyle(int style)
{
- Unshare();
+ AllocExclusive();
M_FONTDATA->m_info.style = static_cast<wxFontStyle>(style);
void wxFont::SetWeight(int weight)
{
- Unshare();
+ AllocExclusive();
M_FONTDATA->m_info.weight = static_cast<wxFontWeight>(weight);
bool wxFont::SetFaceName(const wxString& faceName)
{
- Unshare();
+ AllocExclusive();
M_FONTDATA->m_info.faceName = faceName;
void wxFont::SetUnderlined(bool underlined)
{
- Unshare();
+ AllocExclusive();
M_FONTDATA->m_info.underlined = underlined;
wxIconRefData( const wxIconRefData& data );
virtual ~wxIconRefData();
+ virtual bool IsOk() const { return m_ok; }
+
protected:
int m_width;
int m_height;
{
}
+wxGDIRefData *wxIcon::CreateGDIRefData() const
+{
+ return new wxIconRefData;
+}
+
+wxGDIRefData *wxIcon::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxIconRefData(*wx_static_cast(const wxIconRefData *, data));
+}
+
bool wxIcon::CreateFromXpm(const char **xpm)
{
wxBitmap bitmap(xpm);
M_ICONDATA->m_quality = 0;
}
-bool wxIcon::IsOk() const
-{
- return m_refData && M_ICONDATA->m_ok;
-}
-
int wxIcon::GetWidth() const
{
if(!m_refData)
m_refData = new wxPenRefData(wxNullColour,width,wxSTIPPLE,stipple);
}
-wxObjectRefData *wxPen::CreateRefData() const
+wxGDIRefData *wxPen::CreateGDIRefData() const
{
return new wxPenRefData;
}
-wxObjectRefData *wxPen::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxPen::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxPenRefData(*(wxPenRefData *)data);
}
);
}
-bool wxFontBase::operator!=(const wxFont& font) const
-{
- return !(*this == font);
-}
-
wxString wxFontBase::GetFamilyString() const
{
wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );
#endif
-IMPLEMENT_DYNAMIC_CLASS(wxGDIObject, wxObject)
+IMPLEMENT_ABSTRACT_CLASS(wxGDIObject, wxObject)
WXDLLIMPEXP_DATA_CORE(wxBrushList*) wxTheBrushList;
public:
// default and copy ctors and assignment operators are ok
+ virtual bool IsOk() const { return !m_icons.empty(); }
+
protected:
wxIconArray m_icons;
AddIcon(icon);
}
-wxObjectRefData *wxIconBundle::CreateRefData() const
+wxGDIRefData *wxIconBundle::CreateGDIRefData() const
{
return new wxIconBundleRefData;
}
-wxObjectRefData *wxIconBundle::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxIconBundle::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxIconBundleRefData(*wx_static_cast(const wxIconBundleRefData *, data));
}
UnRef();
}
-bool wxIconBundle::IsOk() const
-{
- return M_ICONBUNDLEDATA && !M_ICONBUNDLEDATA->m_icons.IsEmpty();
-}
-
void wxIconBundle::AddIcon(const wxString& file, long type)
{
#ifdef __WXMAC__
// wxBitmapRefData
//-----------------------------------------------------------------------------
-class wxBitmapRefData: public wxObjectRefData
+class wxBitmapRefData: public wxGDIRefData
{
public:
wxBitmapRefData()
#endif
}
+ virtual bool IsOk() const { return m_surface; }
+
wxIDirectFBSurfacePtr m_surface;
wxMask *m_mask;
#if wxUSE_PALETTE
wxFAIL_MSG( "not implemented" );
}
-bool wxBitmap::IsOk() const
-{
- return (m_refData != NULL && M_BITMAP->m_surface);
-}
-
int wxBitmap::GetHeight() const
{
wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
return M_BITMAP->m_surface;
}
-wxObjectRefData *wxBitmap::CreateRefData() const
+wxGDIRefData *wxBitmap::CreateGDIRefData() const
{
return new wxBitmapRefData;
}
-wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxBitmap::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxBitmapRefData(*(wxBitmapRefData *)data);
}
// wxBrush
//-----------------------------------------------------------------------------
-class wxBrushRefData: public wxObjectRefData
+class wxBrushRefData : public wxGDIRefData
{
public:
wxBrushRefData(const wxColour& clr = wxNullColour, int style = wxSOLID)
m_style = data.m_style;
}
+ virtual bool IsOk() const { return m_colour.IsOk(); }
+
void SetStyle(int style)
{
if ( style != wxSOLID && style != wxTRANSPARENT )
return m_refData == brush.m_refData;
}
-bool wxBrush::IsOk() const
-{
- return ((m_refData) && M_BRUSHDATA->m_colour.Ok());
-}
-
int wxBrush::GetStyle() const
{
if (m_refData == NULL)
wxFAIL_MSG( wxT("brushes with stipple bitmaps not implemented") );
}
-wxObjectRefData *wxBrush::CreateRefData() const
+wxGDIRefData *wxBrush::CreateGDIRefData() const
{
return new wxBrushRefData;
}
-wxObjectRefData *wxBrush::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxBrush::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxBrushRefData(*(wxBrushRefData *)data);
}
// wxCursorRefData
//-----------------------------------------------------------------------------
-class wxCursorRefData: public wxObjectRefData
+class wxCursorRefData : public wxGDIRefData
{
public:
wxCursorRefData(const wxBitmap& bmp = wxNullBitmap, int id = -1)
: m_id(id), m_bitmap(bmp) {}
+ virtual bool IsOk() const { return m_bitmap.IsOk(); }
+
int m_id;
wxBitmap m_bitmap;
};
#warning "FIXME"
}
-bool wxCursor::IsOk() const
-{
- return m_refData && M_CURSOR->m_bitmap.Ok();
-}
-
-wxObjectRefData *wxCursor::CreateRefData() const
+wxGDIRefData *wxCursor::CreateGDIRefData() const
{
return new wxCursorRefData;
}
-wxObjectRefData *wxCursor::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxCursor::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxCursorRefData(*(wxCursorRefData *)data);
}
return true;
}
-wxObjectRefData *wxFont::CreateRefData() const
+wxGDIRefData *wxFont::CreateGDIRefData() const
{
return new wxFontRefData;
}
-wxObjectRefData *wxFont::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxFontRefData(*(wxFontRefData *)data);
}
// wxPen
//-----------------------------------------------------------------------------
-class wxPenRefData: public wxObjectRefData
+class wxPenRefData : public wxGDIRefData
{
public:
wxPenRefData(const wxColour& clr = wxNullColour, int style = wxSOLID)
wxPenRefData(const wxPenRefData& data)
: m_style(data.m_style), m_colour(data.m_colour) {}
+ virtual bool IsOk() const { return m_colour.IsOk(); }
+
void SetStyle(int style)
{
if ( style != wxSOLID && style != wxTRANSPARENT )
return NULL;
}
-bool wxPen::IsOk() const
-{
- return ((m_refData) && M_PENDATA->m_colour.Ok());
-}
-
-wxObjectRefData *wxPen::CreateRefData() const
+wxGDIRefData *wxPen::CreateGDIRefData() const
{
return new wxPenRefData;
}
-wxObjectRefData *wxPen::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxPen::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxPenRefData(*(wxPenRefData *)data);
}
// wxRegion
//-----------------------------------------------------------------------------
-wxObjectRefData *wxRegion::CreateRefData() const
+wxGDIRefData *wxRegion::CreateGDIRefData() const
{
return new wxRegionRefData;
}
-wxObjectRefData *wxRegion::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxRegion::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxRegionRefData(*(wxRegionRefData *)data);
}
unsigned char red, green, blue;
};
-class wxPaletteRefData: public wxObjectRefData
+class wxPaletteRefData : public wxGDIRefData
{
- public:
-
- wxPaletteRefData(void);
- virtual ~wxPaletteRefData(void);
+public:
+ wxPaletteRefData();
+ wxPaletteRefData(const wxPaletteRefData& palette);
+ virtual ~wxPaletteRefData();
int m_count;
wxPaletteEntry *m_entries;
m_entries = NULL;
}
+wxPaletteRefData::wxPaletteRefData(const wxPaletteRefData& palette)
+{
+ m_count = palette.m_count;
+ m_entries = new wxPaletteEntry[m_count];
+ for ( int i = 0; i < m_count; i++ )
+ m_entries[i] = palette.m_entries[i];
+}
+
wxPaletteRefData::~wxPaletteRefData()
{
delete[] m_entries;
{
}
-bool wxPalette::IsOk() const
-{
- return (m_refData != NULL);
-}
-
int wxPalette::GetColoursCount() const
{
if (m_refData)
return true;
}
+wxGDIRefData *wxPalette::CreateGDIRefData() const
+{
+ return new wxPaletteRefData;
+}
+
+wxGDIRefData *wxPalette::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxPaletteRefData(*wx_static_cast(const wxPaletteRefData *, data));
+}
+
#endif // wxUSE_PALETTE
// wxRegionRefData
// ========================================================================
-class wxRegionRefData : public wxObjectRefData,
+class wxRegionRefData : public wxGDIRefData,
public REGION
{
public:
wxRegionRefData()
- : wxObjectRefData(),
+ : wxGDIRefData(),
REGION()
{
size = 1;
}
wxRegionRefData(const wxPoint& topLeft, const wxPoint& bottomRight)
- : wxObjectRefData(),
+ : wxGDIRefData(),
REGION()
{
rects = (BOX*)malloc(sizeof(BOX));
}
wxRegionRefData(const wxRect& rect)
- : wxObjectRefData(),
+ : wxGDIRefData(),
REGION(rect)
{
rects = (BOX*)malloc(sizeof(BOX));
}
wxRegionRefData(const wxRegionRefData& refData)
- : wxObjectRefData(),
+ : wxGDIRefData(),
REGION()
{
size = refData.size;
UnRef();
}
-wxObjectRefData *wxRegionGeneric::CreateRefData() const
+wxGDIRefData *wxRegionGeneric::CreateGDIRefData() const
{
return new wxRegionRefData;
}
-wxObjectRefData *wxRegionGeneric::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxRegionGeneric::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxRegionRefData(*(wxRegionRefData *)data);
}
// wxBitmap
//-----------------------------------------------------------------------------
-class wxBitmapRefData: public wxObjectRefData
+class wxBitmapRefData: public wxGDIRefData
{
public:
wxBitmapRefData();
virtual ~wxBitmapRefData();
+ virtual bool IsOk() const { return m_pixmap || m_pixbuf; }
+
GdkPixmap *m_pixmap;
GdkPixbuf *m_pixbuf;
wxMask *m_mask;
#endif // wxUSE_IMAGE
-bool wxBitmap::IsOk() const
-{
- return (m_refData != NULL) &&
- (
- M_BMPDATA->m_pixbuf ||
- M_BMPDATA->m_pixmap
- );
-}
-
int wxBitmap::GetHeight() const
{
wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
gdk_pixbuf_get_has_alpha(M_BMPDATA->m_pixbuf);
}
-wxObjectRefData* wxBitmap::CreateRefData() const
+wxGDIRefData* wxBitmap::CreateGDIRefData() const
{
return new wxBitmapRefData;
}
-wxObjectRefData* wxBitmap::CloneRefData(const wxObjectRefData* data) const
+wxGDIRefData* wxBitmap::CloneGDIRefData(const wxGDIRefData* data) const
{
const wxBitmapRefData* oldRef = wx_static_cast(const wxBitmapRefData*, data);
wxBitmapRefData* newRef = new wxBitmapRefData;
// wxBrush
//-----------------------------------------------------------------------------
-class wxBrushRefData: public wxObjectRefData
+class wxBrushRefData: public wxGDIRefData
{
public:
wxBrushRefData()
}
wxBrushRefData( const wxBrushRefData& data )
- : wxObjectRefData()
+ : wxGDIRefData()
{
m_style = data.m_style;
m_stipple = data.m_stipple;
// m_refData unrefed in ~wxObject
}
-wxObjectRefData *wxBrush::CreateRefData() const
+wxGDIRefData *wxBrush::CreateGDIRefData() const
{
return new wxBrushRefData;
}
-wxObjectRefData *wxBrush::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxBrush::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxBrushRefData(*(wxBrushRefData *)data);
}
-bool wxBrush::operator == ( const wxBrush& brush ) const
+bool wxBrush::operator==(const wxBrush& brush) const
{
if (m_refData == brush.m_refData) return true;
// wxColour
//-----------------------------------------------------------------------------
-class wxColourRefData: public wxObjectRefData
+class wxColourRefData : public wxGDIRefData
{
public:
wxColourRefData(guint16 red, guint16 green, guint16 blue, guint16 alpha)
// wxCursor
//-----------------------------------------------------------------------------
-class wxCursorRefData: public wxObjectRefData
+class wxCursorRefData: public wxGDIRefData
{
- public:
-
+public:
wxCursorRefData();
virtual ~wxCursorRefData();
+ virtual bool IsOk() const { return m_cursor != NULL; }
+
GdkCursor *m_cursor;
};
{
}
-bool wxCursor::IsOk() const
+GdkCursor *wxCursor::GetCursor() const
{
- return (m_refData != NULL);
+ return M_CURSORDATA->m_cursor;
}
-GdkCursor *wxCursor::GetCursor() const
+wxGDIRefData *wxCursor::CreateGDIRefData() const
{
- return M_CURSORDATA->m_cursor;
+ return new wxCursorRefData;
+}
+
+wxGDIRefData *wxCursor::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxCursorRefData(*wx_static_cast(const wxCursorRefData *, data));
}
//-----------------------------------------------------------------------------
// wxFontRefData
// ----------------------------------------------------------------------------
-class wxFontRefData : public wxObjectRefData
+class wxFontRefData : public wxGDIRefData
{
public:
// from broken down font parameters, also default ctor
}
wxFontRefData::wxFontRefData( const wxFontRefData& data )
- : wxObjectRefData()
+ : wxGDIRefData()
{
m_pointSize = data.m_pointSize;
m_family = data.m_family;
M_FONTDATA->SetNoAntiAliasing( no );
}
-wxObjectRefData* wxFont::CreateRefData() const
+wxGDIRefData* wxFont::CreateGDIRefData() const
{
return new wxFontRefData;
}
-wxObjectRefData* wxFont::CloneRefData(const wxObjectRefData* data) const
+wxGDIRefData* wxFont::CloneGDIRefData(const wxGDIRefData* data) const
{
return new wxFontRefData(*wx_static_cast(const wxFontRefData*, data));
}
// wxPen
//-----------------------------------------------------------------------------
-class wxPenRefData: public wxObjectRefData
+class wxPenRefData: public wxGDIRefData
{
public:
wxPenRefData()
}
wxPenRefData( const wxPenRefData& data )
- : wxObjectRefData()
+ : wxGDIRefData()
{
m_style = data.m_style;
m_width = data.m_width;
// m_refData unrefed in ~wxObject
}
-wxObjectRefData *wxPen::CreateRefData() const
+wxGDIRefData *wxPen::CreateGDIRefData() const
{
return new wxPenRefData;
}
-wxObjectRefData *wxPen::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxPen::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxPenRefData(*(wxPenRefData *)data);
}
// wxRegionRefData: private class containing the information about the region
// ----------------------------------------------------------------------------
-class wxRegionRefData : public wxObjectRefData
+class wxRegionRefData : public wxGDIRefData
{
public:
wxRegionRefData()
}
wxRegionRefData(const wxRegionRefData& refData)
- : wxObjectRefData()
+ : wxGDIRefData()
{
m_region = gdk_region_copy(refData.m_region);
}
// m_refData unrefed in ~wxObject
}
-wxObjectRefData *wxRegion::CreateRefData() const
+wxGDIRefData *wxRegion::CreateGDIRefData() const
{
return new wxRegionRefData;
}
-wxObjectRefData *wxRegion::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxRegion::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxRegionRefData(*(wxRegionRefData *)data);
}
// wxBitmap
//-----------------------------------------------------------------------------
-class wxBitmapRefData: public wxObjectRefData
+class wxBitmapRefData : public wxGDIRefData
{
public:
wxBitmapRefData();
bool Create(int width, int height, int bpp);
virtual ~wxBitmapRefData();
+ virtual bool IsOk() const { return m_pixmap || m_bitmap; }
+
GdkPixmap *m_pixmap;
GdkBitmap *m_bitmap;
wxMask *m_mask;
Create( width, height, depth );
}
-wxObjectRefData *wxBitmap::CreateRefData() const
+wxGDIRefData *wxBitmap::CreateGDIRefData() const
{
return new wxBitmapRefData;
}
-wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxBitmap::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxBitmapRefData(*wx_static_cast(const wxBitmapRefData *, data));
}
{
}
-bool wxBitmap::IsOk() const
-{
- return (m_refData != NULL) &&
- (M_BMPDATA->m_bitmap || M_BMPDATA->m_pixmap);
-}
-
int wxBitmap::GetHeight() const
{
wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
// wxBrush
//-----------------------------------------------------------------------------
-class wxBrushRefData: public wxObjectRefData
+class wxBrushRefData: public wxGDIRefData
{
public:
wxBrushRefData()
}
wxBrushRefData( const wxBrushRefData& data )
- : wxObjectRefData()
+ : wxGDIRefData()
{
m_style = data.m_style;
m_stipple = data.m_stipple;
// m_refData unrefed in ~wxObject
}
-wxObjectRefData *wxBrush::CreateRefData() const
+wxGDIRefData *wxBrush::CreateGDIRefData() const
{
return new wxBrushRefData;
}
-wxObjectRefData *wxBrush::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxBrush::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxBrushRefData(*(wxBrushRefData *)data);
}
// wxColour
//-----------------------------------------------------------------------------
-class wxColourRefData: public wxObjectRefData
+class wxColourRefData : public wxGDIRefData
{
public:
wxColourRefData()
}
wxColourRefData(const wxColourRefData& data)
- : wxObjectRefData()
{
m_color = data.m_color;
m_colormap = data.m_colormap;
own->green == other->green;
}
-wxObjectRefData *wxColour::CreateRefData() const
+wxGDIRefData *wxColour::CreateGDIRefData() const
{
return new wxColourRefData;
}
-wxObjectRefData *wxColour::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxColour::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxColourRefData(*(wxColourRefData *)data);
}
// wxCursor
//-----------------------------------------------------------------------------
-class wxCursorRefData: public wxObjectRefData
+class wxCursorRefData : public wxGDIRefData
{
- public:
-
+public:
wxCursorRefData();
virtual ~wxCursorRefData();
{
}
-bool wxCursor::IsOk() const
+GdkCursor *wxCursor::GetCursor() const
{
- return (m_refData != NULL);
+ return M_CURSORDATA->m_cursor;
}
-GdkCursor *wxCursor::GetCursor() const
+wxGDIRefData *wxCursor::CreateGDIRefData() const
{
- return M_CURSORDATA->m_cursor;
+ return new wxCursorRefData;
+}
+
+wxGDIRefData *wxCursor::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxCursorRefData(*wx_static_cast(const wxCursorRefData *, data));
}
//-----------------------------------------------------------------------------
// wxFontRefData
// ----------------------------------------------------------------------------
-class wxFontRefData : public wxObjectRefData
+class wxFontRefData : public wxGDIRefData
{
public:
// from broken down font parameters, also default ctor
}
wxFontRefData::wxFontRefData( const wxFontRefData& data )
- : wxObjectRefData()
+ : wxGDIRefData()
{
m_pointSize = data.m_pointSize;
m_family = data.m_family;
{
}
+wxGDIRefData *wxFont::CreateGDIRefData() const
+{
+ return new wxFontRefData;
+}
+
+wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxFontRefData(*wx_static_cast(const wxFontRefData *, data));
+}
+
// ----------------------------------------------------------------------------
// accessors
// ----------------------------------------------------------------------------
// m_refData unrefed in ~wxObject
}
-wxObjectRefData *wxPen::CreateRefData() const
+wxGDIRefData *wxPen::CreateGDIRefData() const
{
return new wxPenRefData;
}
-wxObjectRefData *wxPen::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxPen::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxPenRefData(*(wxPenRefData *)data);
}
// wxRegionRefData: private class containing the information about the region
// ----------------------------------------------------------------------------
-class wxRegionRefData : public wxObjectRefData
+class wxRegionRefData : public wxGDIRefData
{
public:
wxRegionRefData()
}
wxRegionRefData(const wxRegionRefData& refData)
- : wxObjectRefData()
+ : wxGDIRefData()
{
m_region = gdk_regions_union(wxGdkRegion(), refData.m_region);
}
// m_refData unrefed in ~wxObject
}
-wxObjectRefData *wxRegion::CreateRefData() const
+wxGDIRefData *wxRegion::CreateGDIRefData() const
{
return new wxRegionRefData;
}
-wxObjectRefData *wxRegion::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxRegion::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxRegionRefData(*(wxRegionRefData *)data);
}
};
-class wxRIRefData: public wxObjectRefData
+class wxRIRefData : public wxGDIRefData
{
public:
wxRIRefData() { Init(); }
wxBitmapRefData(int width , int height , int depth);
wxBitmapRefData();
wxBitmapRefData(const wxBitmapRefData &tocopy);
-
+
virtual ~wxBitmapRefData();
-
+
+ virtual bool IsOk() const { return m_ok; }
+
void Free();
- bool Ok() const { return IsOk(); }
- bool IsOk() const { return m_ok; }
void SetOk( bool isOk) { m_ok = isOk; }
-
+
void SetWidth( int width ) { m_width = width; }
void SetHeight( int height ) { m_height = height; }
void SetDepth( int depth ) { m_depth = depth; }
-
+
int GetWidth() const { return m_width; }
int GetHeight() const { return m_height; }
int GetDepth() const { return m_depth; }
-
+
void *GetRawAccess() const;
void *BeginRawAccess();
void EndRawAccess();
-
+
bool HasAlpha() const { return m_hasAlpha; }
void UseAlpha( bool useAlpha );
-
+
public:
#if wxUSE_PALETTE
wxPalette m_bitmapPalette;
#endif // wxUSE_PALETTE
-
+
wxMask * m_bitmapMask; // Optional mask
CGImageRef CreateCGImage() const;
-
+
// returns true if the bitmap has a size that
// can be natively transferred into a true icon
// if no is returned GetIconRef will still produce
// an icon but it will be generated via a PICT and
// rescaled to 16 x 16
bool HasNativeSize();
-
+
// caller should increase ref count if needed longer
// than the bitmap exists
IconRef GetIconRef();
-
+
// returns a Pict from the bitmap content
PicHandle GetPictHandle();
-
+
CGContextRef GetBitmapContext() const;
-
+
int GetBytesPerRow() const { return m_bytesPerRow; }
private :
bool Create(int width , int height , int depth);
void Init();
-
+
int m_width;
int m_height;
int m_bytesPerRow;
int m_rawAccessCount;
bool m_ok;
mutable CGImageRef m_cgImageRef;
-
+
IconRef m_iconRef;
PicHandle m_pictHandle;
-
+
CGContextRef m_hBitmap;
};
wxBitmapRefData::wxBitmapRefData(const wxBitmapRefData &tocopy)
{
Init();
- Create(tocopy.m_width, tocopy.m_height, tocopy.m_depth);
-
+ Create(tocopy.m_width, tocopy.m_height, tocopy.m_depth);
+
if (tocopy.m_bitmapMask)
m_bitmapMask = new wxMask(*tocopy.m_bitmapMask);
else if (tocopy.m_hasAlpha)
void *wxBitmapRefData::GetRawAccess() const
{
- wxCHECK_MSG( Ok(), NULL , wxT("invalid bitmap") ) ;
+ wxCHECK_MSG( IsOk(), NULL , wxT("invalid bitmap") ) ;
return m_memBuf.GetData() ;
}
void *wxBitmapRefData::BeginRawAccess()
{
- wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") ) ;
+ wxCHECK_MSG( IsOk(), NULL, wxT("invalid bitmap") ) ;
wxASSERT( m_rawAccessCount == 0 ) ;
wxASSERT_MSG( m_pictHandle == NULL && m_iconRef == NULL ,
wxT("Currently, modifing bitmaps that are used in controls already is not supported") ) ;
void wxBitmapRefData::EndRawAccess()
{
- wxCHECK_RET( Ok() , wxT("invalid bitmap") ) ;
+ wxCHECK_RET( IsOk() , wxT("invalid bitmap") ) ;
wxASSERT( m_rawAccessCount == 1 ) ;
--m_rawAccessCount ;
#endif
{
// setup the header properly
-
+
Handle data = NULL ;
Handle maskdata = NULL ;
unsigned char * maskptr = NULL ;
unsigned char * ptr = NULL ;
size_t datasize, masksize ;
-
+
datasize = sz * sz * 4 ;
data = NewHandle( datasize ) ;
HLock( data ) ;
ptr = (unsigned char*) *data ;
memset( ptr , 0, datasize ) ;
-
+
masksize = sz * sz ;
maskdata = NewHandle( masksize ) ;
HLock( maskdata ) ;
maskptr = (unsigned char*) *maskdata ;
memset( maskptr , 0 , masksize ) ;
-
+
bool hasAlpha = HasAlpha() ;
wxMask *mask = m_bitmapMask ;
unsigned char * sourcePtr = (unsigned char*) GetRawAccess() ;
unsigned char * masksourcePtr = mask ? (unsigned char*) mask->GetRawAccess() : NULL ;
-
+
for ( int y = 0 ; y < h ; ++y, sourcePtr += m_bytesPerRow , masksourcePtr += mask ? mask->GetBytesPerRow() : 0 )
{
unsigned char * source = sourcePtr;
unsigned char * dest = ptr + y * sz * 4 ;
unsigned char * maskdest = maskptr + y * sz ;
unsigned char a, r, g, b;
-
+
for ( int x = 0 ; x < w ; ++x )
{
a = *source ++ ;
r = *source ++ ;
g = *source ++ ;
b = *source ++ ;
-
+
*dest++ = 0 ;
*dest++ = r ;
*dest++ = g ;
*dest++ = b ;
-
+
if ( mask )
*maskdest++ = 0xFF - *masksource++ ;
else if ( hasAlpha )
*maskdest++ = 0xFF ;
}
}
-
+
OSStatus err = SetIconFamilyData( iconFamily, dataType , data ) ;
wxASSERT_MSG( err == noErr , wxT("Error when adding bitmap") ) ;
-
+
err = SetIconFamilyData( iconFamily, maskType , maskdata ) ;
wxASSERT_MSG( err == noErr , wxT("Error when adding mask") ) ;
-
+
HUnlock( data ) ;
HUnlock( maskdata ) ;
DisposeHandle( data ) ;
int h = m_height ;
CGImageAlphaInfo alphaInfo = kCGImageAlphaNoneSkipFirst ;
wxMemoryBuffer membuf;
-
+
if ( m_bitmapMask )
{
alphaInfo = kCGImageAlphaFirst ;
alphaInfo = kCGImageAlphaFirst ;
#endif
}
-
+
membuf = m_memBuf;
}
-
+
CGDataProviderRef dataProvider = NULL ;
if ( m_depth == 1 )
{
}
}
maskBuf.UngetWriteBuf( m_width * m_height );
-
+
dataProvider =
wxMacCGDataProviderCreateWithMemoryBuffer( maskBuf );
-
+
image = ::CGImageMaskCreate( w, h, 8, 8, m_width , dataProvider, NULL, false );
}
else
*destination++ = ( (*source++) * a + 127 ) / 255;
*destination++ = ( (*source++) * a + 127 ) / 255;
*destination++ = ( (*source++) * a + 127 ) / 255;
-#else
+#else
*destination++ = *source++ ;
*destination++ = *source++ ;
*destination++ = *source++ ;
LoadFile(filename, type);
}
-wxObjectRefData* wxBitmap::CreateRefData() const
+wxGDIRefData* wxBitmap::CreateGDIRefData() const
{
return new wxBitmapRefData;
}
-wxObjectRefData* wxBitmap::CloneRefData(const wxObjectRefData* data) const
+wxGDIRefData* wxBitmap::CloneGDIRefData(const wxGDIRefData* data) const
{
return new wxBitmapRefData(*wx_static_cast(const wxBitmapRefData *, data));
}
IconRef wxBitmap::GetIconRef() const
{
wxCHECK_MSG( Ok(), NULL , wxT("invalid bitmap") ) ;
-
+
return M_BITMAPDATA->GetIconRef() ;
}
m_refData = new wxBitmapRefData( w , h , d );
- return M_BITMAPDATA->Ok() ;
+ return M_BITMAPDATA->IsOk() ;
}
bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type)
wxBitmap::wxBitmap(const wxImage& image, int depth)
{
wxCHECK_RET( image.Ok(), wxT("invalid image") );
-
+
// width and height of the device-dependent bitmap
int width = image.GetWidth();
int height = image.GetHeight();
-
+
m_refData = new wxBitmapRefData( width , height , depth ) ;
-
+
// Create picture
-
+
bool hasAlpha = false ;
-
+
if ( image.HasMask() )
{
// takes precedence, don't mix with alpha info
{
hasAlpha = image.HasAlpha() ;
}
-
+
if ( hasAlpha )
UseAlpha() ;
-
+
unsigned char* destinationstart = (unsigned char*) BeginRawAccess() ;
register unsigned char* data = image.GetData();
if ( destinationstart != NULL && data != NULL )
{
const unsigned char a = *alpha++;
*destination++ = a ;
-
+
#if wxMAC_USE_PREMULTIPLIED_ALPHA
*destination++ = ((*data++) * a + 127) / 255 ;
*destination++ = ((*data++) * a + 127) / 255 ;
}
}
}
-
+
EndRawAccess() ;
}
if ( image.HasMask() )
return success;
}
-bool wxBitmap::IsOk() const
-{
- return (M_BITMAPDATA && M_BITMAPDATA->Ok());
-}
-
int wxBitmap::GetHeight() const
{
wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceGray();
// from MouseTracking sample :
- // Ironically, due to a bug in CGImageCreateWithMask, you cannot use
+ // Ironically, due to a bug in CGImageCreateWithMask, you cannot use
// CGColorSpaceCreateWithName(kCGColorSpaceGenericGray) at this point!
-
- m_maskBitmap = CGBitmapContextCreate((char*) m_memBuf.GetData(), m_width, m_height, 8, m_bytesPerRow, colorspace,
+
+ m_maskBitmap = CGBitmapContextCreate((char*) m_memBuf.GetData(), m_width, m_height, 8, m_bytesPerRow, colorspace,
kCGImageAlphaNone );
CGColorSpaceRelease( colorspace );
wxASSERT_MSG( m_maskBitmap , wxT("Unable to create CGBitmapContext context") ) ;
return m_refData ? (brushData && *M_BRUSHDATA == *brushData) : !brushData;
}
-wxObjectRefData *wxBrush::CreateRefData() const
+wxGDIRefData *wxBrush::CreateGDIRefData() const
{
return new wxBrushRefData;
}
-wxObjectRefData *wxBrush::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxBrush::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxBrushRefData(*(const wxBrushRefData *)data);
}
return *this;
}
-bool wxColour::IsOk() const
-{
- return m_cgColour;
-}
-
void wxColour::InitRGBA (ChannelType r, ChannelType g, ChannelType b, ChannelType a)
{
m_red = r;
class WXDLLEXPORT wxCursorRefData: public wxGDIRefData
{
- friend class wxCursor;
-
- DECLARE_NO_COPY_CLASS(wxCursorRefData)
-
public:
wxCursorRefData();
+ wxCursorRefData(const wxCursorRefData& cursor);
virtual ~wxCursorRefData();
+ virtual bool IsOk() const
+ {
+ if ( m_hCursor != NULL )
+ return true;
+#if !wxMAC_USE_COCOA
+ if ( m_themeCursor != -1 )
+ return true;
+#endif
+
+ return false;
+ }
+
protected:
#if wxMAC_USE_COCOA
WX_NSCursor m_hCursor;
bool m_isColorCursor;
long m_themeCursor;
#endif
+
+ friend class wxCursor;
+
+ DECLARE_NO_ASSIGN_CLASS(wxCursorRefData)
};
#define M_CURSORDATA wx_static_cast(wxCursorRefData*, m_refData)
#endif
}
+wxCursorRefData::wxCursorRefData(const wxCursorRefData& cursor)
+{
+ // FIXME: need to copy the cursor
+ m_hCursor = NULL;
+
+#if wxMAC_USE_COCOA
+ wxUnusedVar(cursor);
+#else
+ m_disposeHandle = false;
+ m_releaseHandle = false;
+ m_isColorCursor = cursor.m_isColorCursor;
+ m_themeCursor = cursor.m_themeCursor;
+#endif
+}
+
wxCursorRefData::~wxCursorRefData()
{
#if wxMAC_USE_COCOA
(void) CreateFromXpm((const char **)bits);
}
+wxGDIRefData *wxCursor::CreateGDIRefData() const
+{
+ return new wxCursorRefData;
+}
+
+wxGDIRefData *wxCursor::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxCursorRefData(*wx_static_cast(const wxCursorRefData *, data));
+}
+
bool wxCursor::CreateFromXpm(const char **bits)
{
#if wxUSE_IMAGE
return (M_CURSORDATA ? M_CURSORDATA->m_hCursor : 0);
}
-bool wxCursor::IsOk() const
-{
-#if wxMAC_USE_COCOA
- return GetHCURSOR() != NULL;
-#else
- return (m_refData != NULL && ( M_CURSORDATA->m_hCursor != NULL || M_CURSORDATA->m_themeCursor != -1 ) ) ;
-#endif
-}
-
#if !wxMAC_USE_COCOA
short GetCTabIndex( CTabHandle colors , RGBColor *col )
{
{
Init(size, family, style, weight, underlined, faceName, encoding);
}
-
+
#if wxMAC_USE_CORE_TEXT
wxFontRefData( wxUint32 coreTextFontType );
wxFontRefData( CTFontRef font );
bool GetNoAntiAliasing() const { return m_noAA; }
- void SetPointSize( int size )
+ void SetPointSize( int size )
{
m_pointSize = size;
MacInvalidateNativeFont();
}
-
+
int GetPointSize() const { return m_pointSize; }
-
- void SetFamily( int family )
+
+ void SetFamily( int family )
{
m_family = family;
MacInvalidateNativeFont();
}
-
-
+
+
int GetFamily() const { return m_family; }
-
- void SetStyle( int style )
+
+ void SetStyle( int style )
{
m_style = style;
MacInvalidateNativeFont();
}
-
-
+
+
int GetStyle() const { return m_style; }
-
- void SetWeight( int weight )
+
+ void SetWeight( int weight )
{
m_weight = weight;
MacInvalidateNativeFont();
}
-
-
+
+
int GetWeight() const { return m_weight; }
-
- void SetUnderlined( bool u )
+
+ void SetUnderlined( bool u )
{
m_underlined = u;
MacInvalidateNativeFont();
}
-
+
bool GetUnderlined() const { return m_underlined; }
-
- void SetFaceName( const wxString& facename )
+
+ void SetFaceName( const wxString& facename )
{
m_faceName = facename;
MacInvalidateNativeFont();
}
-
+
const wxString& GetFaceName() const { return m_faceName; }
-
- void SetEncoding( wxFontEncoding encoding )
+
+ void SetEncoding( wxFontEncoding encoding )
{
m_encoding = encoding;
MacInvalidateNativeFont();
- }
-
- wxFontEncoding GetEncoding() const { return m_encoding; }
-
+ }
+
+ wxFontEncoding GetEncoding() const { return m_encoding; }
+
void MacInvalidateNativeFont();
-
+
void MacFindFont();
-
+
protected:
// common part of all ctors
void Init(int size,
#if wxMAC_USE_CORE_TEXT
void Init( CTFontRef font );
-#endif
+#endif
// font characterstics
int m_pointSize;
int m_family;
#if wxMAC_USE_CORE_TEXT
-/* from Core Text Manual Common Operations */
+/* from Core Text Manual Common Operations */
static CTFontDescriptorRef wxMacCreateCTFontDescriptor(CFStringRef iFamilyName, CTFontSymbolicTraits iTraits )
{
CTFontDescriptorRef descriptor = NULL;
CFMutableDictionaryRef attributes;
-
+
assert(iFamilyName != NULL);
// Create a mutable dictionary to hold our attributes.
attributes = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
check(attributes != NULL);
-
- if (attributes != NULL) {
+
+ if (attributes != NULL) {
// Add a family name to our attributes.
CFDictionaryAddValue(attributes, kCTFontFamilyNameAttribute, iFamilyName);
-
-
+
+
if ( iTraits ) {
CFMutableDictionaryRef traits;
CFNumberRef symTraits;
symTraits = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type,
&iTraits);
check(symTraits != NULL);
-
+
if (symTraits != NULL) {
// Create a dictionary to hold our traits values.
traits = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
check(traits != NULL);
-
+
if (traits != NULL) {
// Add the symbolic traits value to the traits dictionary.
CFDictionaryAddValue(traits, kCTFontSymbolicTrait, symTraits);
-
+
// Add the traits attribute to our attributes.
CFDictionaryAddValue(attributes, kCTFontTraitsAttribute, traits);
CFRelease(traits);
// Create the font descriptor with our attributes and input size.
descriptor = CTFontDescriptorCreateWithAttributes(attributes);
check(descriptor != NULL);
-
+
CFRelease(attributes);
}
// Return our font descriptor.
if ( size == 0 )
{
wxCFRef< CFNumberRef > value( (CFNumberRef) CTFontDescriptorCopyAttribute( fontdescriptor, kCTFontSizeAttribute ) );
-
+
float fsize;
if ( CFNumberGetValue( value , kCFNumberFloatType , &fsize ) )
{
{
m_ctFont.reset(CTFontCreateUIFontForLanguage( kCTFontSystemFontType, 0.0, NULL ));
}
-
+
if ( m_ctFont )
- {
+ {
wxCFStringRef name( CTFontCopyFamilyName( m_ctFont ) );
m_faceName = name.AsString();
m_pointSize = CTFontGetSize(m_ctFont) ;
case wxDECORATIVE :
m_faceName = wxT("Times");
break ;
-
+
case wxSWISS :
m_faceName = wxT("Lucida Grande");
break ;
-
+
case wxMODERN :
case wxTELETYPE:
m_faceName = wxT("Monaco");
break ;
-
+
default:
m_faceName = wxT("Times");
break ;
wxCFStringRef cf( m_faceName, wxLocale::GetSystemEncoding() );
CTFontSymbolicTraits traits = 0;
-
+
if (m_weight == wxBOLD)
traits |= kCTFontBoldTrait;
if (m_style == wxITALIC || m_style == wxSLANT)
traits |= kCTFontItalicTrait;
-
+
m_ctFontDescriptor.reset( wxMacCreateCTFontDescriptor( cf, traits ) );
m_ctFont.reset( CTFontCreateWithFontDescriptor( m_ctFontDescriptor, m_pointSize, NULL ) );
};
Boolean kTrue = true ;
Boolean kFalse = false ;
-
+
Fixed atsuSize = IntToFixed( m_pointSize );
ATSUVerticalCharacterType kHorizontal = kATSUStronglyHorizontal;
ATSUAttributeValuePtr atsuValues[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
(m_style == wxITALIC || m_style == wxSLANT) ? &kTrue : &kFalse ,
(m_underlined) ? &kTrue : &kFalse ,
};
-
+
if ( m_macATSUStyle )
{
::ATSUDisposeStyle((ATSUStyle)m_macATSUStyle);
case wxDECORATIVE :
m_faceName = wxT("Times");
break ;
-
+
case wxSWISS :
m_faceName = wxT("Lucida Grande");
break ;
-
+
case wxMODERN :
case wxTELETYPE:
m_faceName = wxT("Monaco");
break ;
-
+
default:
m_faceName = wxT("Times");
break ;
m_macFontFamily = FMGetFontFamilyFromATSFontFamilyRef( atsfamily );
}
}
-
+
m_macFontStyle = 0;
if (m_weight == wxBOLD)
m_macFontStyle |= bold;
m_macFontStyle |= underline;
m_macFontSize = m_pointSize ;
}
-
+
// we try to get as much styles as possible into ATSU
-
-
+
+
// ATSUFontID and FMFont are equivalent
FMFontStyle intrinsicStyle = 0 ;
status = FMGetFontFromFontFamilyInstance( m_macFontFamily , m_macFontStyle , &m_macATSUFontID , &intrinsicStyle);
wxASSERT_MSG( status == noErr , wxT("couldn't get an ATSUFont from font family") );
m_macATSUAdditionalQDStyles = m_macFontStyle & (~intrinsicStyle );
-
+
if ( m_macATSUStyle )
{
::ATSUDisposeStyle((ATSUStyle)m_macATSUStyle);
m_macATSUStyle = NULL ;
}
-
+
status = ::ATSUCreateStyle((ATSUStyle *)&m_macATSUStyle);
wxASSERT_MSG( status == noErr , wxT("couldn't create ATSU style") );
-
+
ATSUAttributeTag atsuTags[] =
{
kATSUFontTag ,
sizeof( Boolean ) ,
sizeof( Boolean ) ,
};
-
+
Boolean kTrue = true ;
Boolean kFalse = false ;
-
+
Fixed atsuSize = IntToFixed( m_macFontSize );
ATSUVerticalCharacterType kHorizontal = kATSUStronglyHorizontal;
ATSUAttributeValuePtr atsuValues[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
(m_macATSUAdditionalQDStyles & condense) ? &kTrue : &kFalse ,
(m_macATSUAdditionalQDStyles & extend) ? &kTrue : &kFalse ,
};
-
+
status = ::ATSUSetAttributes(
(ATSUStyle)m_macATSUStyle,
sizeof(atsuTags) / sizeof(ATSUAttributeTag) ,
atsuTags, atsuSizes, atsuValues);
-
+
wxASSERT_MSG( status == noErr , wxT("couldn't modify ATSU style") );
return;
}
bool wxFont::MacCreateFromCTFontDescriptor( const void * ctFontDescriptor , int size )
{
UnRef();
-
+
m_refData = new wxFontRefData((CTFontDescriptorRef)ctFontDescriptor, size);;
RealizeResource();
-
+
return true;
}
}
}
+wxGDIRefData *wxFont::CreateGDIRefData() const
+{
+ return new wxFontRefData;
+}
+
+wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxFontRefData(*wx_static_cast(const wxFontRefData *, data));
+}
+
void wxFont::SetPointSize(int pointSize)
{
if ( M_FONTDATA->GetPointSize() == pointSize )
return;
-
+
Unshare();
M_FONTDATA->SetPointSize( pointSize );
void * wxFont::MacGetATSUStyle() const
{
wxCHECK_MSG( M_FONTDATA != NULL , NULL, wxT("invalid font") );
-
+
return M_FONTDATA->m_macATSUStyle;
}
#endif
const void * wxFont::MacGetCTFontDescriptor() const
{
wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
-
+
return (CTFontDescriptorRef)(M_FONTDATA->m_ctFontDescriptor);
}
class WXDLLEXPORT wxIconRefData : public wxGDIRefData
{
public:
- wxIconRefData();
+ wxIconRefData() { Init(); }
wxIconRefData( WXHICON iconref, int desiredWidth, int desiredHeight );
virtual ~wxIconRefData() { Free(); }
-
- void Init();
+
+ virtual bool IsOk() const { return m_iconRef != NULL; }
+
virtual void Free();
-
+
void SetWidth( int width ) { m_width = width; }
void SetHeight( int height ) { m_height = height; }
-
+
int GetWidth() const { return m_width; }
int GetHeight() const { return m_height; }
-
+
WXHICON GetHICON() const { return (WXHICON) m_iconRef; }
- private :
+
+private:
+ void Init();
+
IconRef m_iconRef;
int m_width;
int m_height;
wxIconRefData::wxIconRefData( WXHICON icon, int desiredWidth, int desiredHeight )
{
m_iconRef = MAC_WXHICON( icon ) ;
-
+
// Standard sizes
SetWidth( desiredWidth == -1 ? 32 : desiredWidth ) ;
SetHeight( desiredHeight == -1 ? 32 : desiredHeight ) ;
void wxIconRefData::Init()
{
m_iconRef = NULL ;
+ m_width =
+ m_height = 0;
}
void wxIconRefData::Free()
{
}
+wxGDIRefData *wxIcon::CreateGDIRefData() const
+{
+ return new wxIconRefData;
+}
+
+wxGDIRefData *wxIcon::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxIconRefData(*wx_static_cast(const wxIconRefData *, data));
+}
+
WXHICON wxIcon::GetHICON() const
{
wxASSERT( Ok() ) ;
{
}
-bool wxIcon::IsOk() const
-{
- return m_refData != NULL ;
-}
-
bool wxIcon::LoadFile(
const wxString& filename, wxBitmapType type,
int desiredWidth, int desiredHeight )
}
else
{
- IconRef iconRef = NULL ;
-
- // first look in the resource fork
- if ( iconRef == NULL )
- {
- Str255 theName ;
-
- wxMacStringToPascal( filename , theName ) ;
- Handle resHandle = GetNamedResource( 'icns' , theName ) ;
- if ( resHandle != 0L )
- {
- IconFamilyHandle iconFamily = (IconFamilyHandle) resHandle ;
+ IconRef iconRef = NULL ;
+
+ // first look in the resource fork
+ if ( iconRef == NULL )
+ {
+ Str255 theName ;
+
+ wxMacStringToPascal( filename , theName ) ;
+ Handle resHandle = GetNamedResource( 'icns' , theName ) ;
+ if ( resHandle != 0L )
+ {
+ IconFamilyHandle iconFamily = (IconFamilyHandle) resHandle ;
HLock((Handle) iconFamily);
OSStatus err = GetIconRefFromIconFamilyPtr( *iconFamily, GetHandleSize((Handle) iconFamily), &iconRef );
HUnlock((Handle) iconFamily);
wxASSERT_MSG( err == noErr , wxT("Error when constructing icon ref") );
ReleaseResource( resHandle ) ;
- }
- }
+ }
+ }
if ( iconRef == NULL )
{
// TODO add other attempts to load it from files etc here
}
- if ( iconRef )
- {
- m_refData = new wxIconRefData( (WXHICON) iconRef, desiredWidth, desiredHeight ) ;
- return true ;
- }
+ if ( iconRef )
+ {
+ m_refData = new wxIconRefData( (WXHICON) iconRef, desiredWidth, desiredHeight ) ;
+ return true ;
+ }
}
if ( theId != 0 )
#define M_METAFILEREFDATA( a ) ((wxMetafileRefData*)(a).GetRefData())
-class wxMetafileRefData: public wxGDIRefData
+class wxMetafileRefData : public wxGDIRefData
{
public:
+ // default ctor needed for CreateGDIRefData(), must be initialized later
+ wxMetafileRefData() { Init(); }
+
// creates a metafile from memory, assumes ownership
wxMetafileRefData(CFDataRef data);
+
// prepares a recording metafile
wxMetafileRefData( int width, int height);
+
// prepares a metafile to be read from a file (if filename is not empty)
wxMetafileRefData( const wxString& filename);
+
virtual ~wxMetafileRefData();
+ virtual bool IsOk() const { return m_data != NULL; }
+
void Init();
int GetWidth() const { return m_width; }
{
}
-bool wxMetaFile::IsOk() const
+wxGDIRefData *wxMetaFile::CreateGDIRefData() const
+{
+ return new wxMetafileRefData;
+}
+
+wxGDIRefData *wxMetaFile::CloneGDIRefData(const wxGDIRefData *data) const
{
- return (M_METAFILEDATA && (M_METAFILEDATA->GetData() != NULL));
+ return new wxMetafileRefData(*wx_static_cast(const wxMetafileRefData *, data));
}
WXHMETAFILE wxMetaFile::GetHMETAFILE() const
IMPLEMENT_DYNAMIC_CLASS(wxPalette, wxGDIObject)
-/*
- * Palette
- *
- */
+// ============================================================================
+// wxPaletteRefData
+// ============================================================================
+
+class WXDLLEXPORT wxPaletteRefData: public wxGDIRefData
+{
+public:
+ wxPaletteRefData();
+ wxPaletteRefData(const wxPaletteRefData& data);
+ virtual ~wxPaletteRefData();
+
+ virtual bool IsOk() const { return m_count > 0; }
+
+protected:
+ wxColour* m_palette;
+ wxInt32 m_count;
+
+ friend class WXDLLIMPEXP_FWD_CORE wxPalette;
+
+ DECLARE_NO_ASSIGN_CLASS(wxPaletteRefData)
+};
wxPaletteRefData::wxPaletteRefData()
{
- m_palette = NULL ;
- m_count = 0 ;
+ m_palette = NULL;
+ m_count = 0;
+}
+
+wxPaletteRefData::wxPaletteRefData(const wxPaletteRefData& data)
+{
+ m_count = data.m_count;
+ m_palette = new wxColour[m_count];
+ for ( wxInt32 i = 0; i < m_count; i++ )
+ m_palette[i] = data.m_palette[i];
}
wxPaletteRefData::~wxPaletteRefData()
{
- if (m_palette != NULL) {
- delete[] m_palette ;
- m_palette = NULL;
- }
+ delete[] m_palette;
}
+// ============================================================================
+// wxPalette
+// ============================================================================
+
wxPalette::wxPalette()
{
}
{
if (m_refData)
return M_PALETTEDATA->m_count;
-
- return 0;
+
+ return 0;
+}
+
+wxGDIRefData *wxPalette::CreateGDIRefData() const
+{
+ return new wxPaletteRefData;
}
+wxGDIRefData *wxPalette::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxPaletteRefData(*wx_static_cast(const wxPaletteRefData *, data));
+}
-#endif
-// wxUSE_PALETTE
+#endif // wxUSE_PALETTE
IMPLEMENT_DYNAMIC_CLASS(wxPen, wxGDIObject)
-class WXDLLEXPORT wxPenRefData: public wxGDIRefData
+class WXDLLEXPORT wxPenRefData : public wxGDIRefData
{
- friend class WXDLLIMPEXP_FWD_CORE wxPen;
public:
wxPenRefData();
wxPenRefData(const wxPenRefData& data);
{
// we intentionally don't compare m_hPen fields here
return m_style == data.m_style &&
- m_width == data.m_width &&
- m_join == data.m_join &&
- m_cap == data.m_cap &&
- m_colour == data.m_colour &&
- (m_style != wxSTIPPLE || m_stipple.IsSameAs(data.m_stipple)) &&
- (m_style != wxUSER_DASH ||
- (m_nbDash == data.m_nbDash &&
- memcmp(m_dash, data.m_dash, m_nbDash*sizeof(wxDash)) == 0));
+ m_width == data.m_width &&
+ m_join == data.m_join &&
+ m_cap == data.m_cap &&
+ m_colour == data.m_colour &&
+ (m_style != wxSTIPPLE || m_stipple.IsSameAs(data.m_stipple)) &&
+ (m_style != wxUSER_DASH ||
+ (m_nbDash == data.m_nbDash &&
+ memcmp(m_dash, data.m_dash, m_nbDash*sizeof(wxDash)) == 0));
}
protected:
- int m_width;
- int m_style;
- int m_join ;
- int m_cap ;
- wxBitmap m_stipple ;
- int m_nbDash ;
- wxDash * m_dash ;
- wxColour m_colour;
-/* TODO: implementation
- WXHPEN m_hPen;
-*/
+ int m_width;
+ int m_style;
+ int m_join ;
+ int m_cap ;
+ wxBitmap m_stipple ;
+ int m_nbDash ;
+ wxDash * m_dash ;
+ wxColour m_colour;
+ /* TODO: implementation
+ WXHPEN m_hPen;
+ */
+
+ friend class WXDLLIMPEXP_FWD_CORE wxPen;
};
wxPenRefData::wxPenRefData()
RealizeResource();
}
-bool wxPen::operator == (const wxPen& pen) const
+wxGDIRefData *wxPen::CreateGDIRefData() const
+{
+ return new wxPenRefData;
+}
+
+wxGDIRefData *wxPen::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxPenRefData(*wx_static_cast(const wxPenRefData *, data));
+}
+
+bool wxPen::operator==(const wxPen& pen) const
{
const wxPenRefData *penData = (wxPenRefData *)pen.m_refData;
return m_refData ? penData && *M_PENDATA == *penData : !penData;
}
-wxColour& wxPen::GetColour() const
-{
- return (M_PENDATA ? M_PENDATA->m_colour : wxNullColour);
+wxColour& wxPen::GetColour() const
+{
+ return (M_PENDATA ? M_PENDATA->m_colour : wxNullColour);
}
-int wxPen::GetWidth() const
-{
- return (M_PENDATA ? M_PENDATA->m_width : 0);
+int wxPen::GetWidth() const
+{
+ return (M_PENDATA ? M_PENDATA->m_width : 0);
}
-int wxPen::GetStyle() const
-{
- return (M_PENDATA ? M_PENDATA->m_style : 0);
+int wxPen::GetStyle() const
+{
+ return (M_PENDATA ? M_PENDATA->m_style : 0);
}
-int wxPen::GetJoin() const
-{
- return (M_PENDATA ? M_PENDATA->m_join : 0);
+int wxPen::GetJoin() const
+{
+ return (M_PENDATA ? M_PENDATA->m_join : 0);
}
-int wxPen::GetCap() const
-{
- return (M_PENDATA ? M_PENDATA->m_cap : 0);
+int wxPen::GetCap() const
+{
+ return (M_PENDATA ? M_PENDATA->m_cap : 0);
}
-int wxPen::GetDashes(wxDash **ptr) const
+int wxPen::GetDashes(wxDash **ptr) const
{
*ptr = (M_PENDATA ? M_PENDATA->m_dash : (wxDash*) NULL); return (M_PENDATA ? M_PENDATA->m_nbDash : 0);
}
-wxBitmap *wxPen::GetStipple() const
-{
- return (M_PENDATA ? (& M_PENDATA->m_stipple) : (wxBitmap*) NULL);
+wxBitmap *wxPen::GetStipple() const
+{
+ return (M_PENDATA ? (& M_PENDATA->m_stipple) : (wxBitmap*) NULL);
}
void wxPen::Unshare()
// m_refData unrefed in ~wxObject
}
+wxGDIRefData *wxRegion::CreateGDIRefData() const
+{
+ return new wxRegionRefData;
+}
+
+wxGDIRefData *wxRegion::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxRegionRefData(*wx_static_cast(const wxRegionRefData *, data));
+}
+
//-----------------------------------------------------------------------------
//# Modify region
//-----------------------------------------------------------------------------
wxBitmapRefData();
virtual ~wxBitmapRefData();
+ virtual bool IsOk() const { return m_bitmap != NULL; }
+
int m_width;
int m_height;
int m_bpp;
delete bdc;
}
-bool wxBitmap::IsOk() const
-{
- return (m_refData != NULL && M_BMPDATA->m_bitmap != NULL);
-}
-
int wxBitmap::GetHeight() const
{
wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
// wxBrush
//-----------------------------------------------------------------------------
-class wxBrushRefData: public wxObjectRefData
+class wxBrushRefData : public wxGDIRefData
{
public:
wxBrushRefData();
wxBrushRefData(const wxBrushRefData& data);
- bool operator == (const wxBrushRefData& data) const
+ virtual bool IsOk() const { return m_colour.IsOk(); }
+
+ bool operator==(const wxBrushRefData& data) const
{
return (m_style == data.m_style &&
m_stipple.IsSameAs(data.m_stipple) &&
return m_refData != brush.m_refData;
}
-bool wxBrush::IsOk() const
-{
- return ((m_refData) && M_BRUSHDATA->m_colour.Ok());
-}
-
int wxBrush::GetStyle() const
{
if (m_refData == NULL)
M_BRUSHDATA->m_style = wxSTIPPLE;
}
-wxObjectRefData *wxBrush::CreateRefData() const
+wxGDIRefData *wxBrush::CreateGDIRefData() const
{
return new wxBrushRefData;
}
-wxObjectRefData *wxBrush::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxBrush::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxBrushRefData(*(wxBrushRefData *)data);
}
// wxObject unrefs data
}
-bool wxCursor::IsOk() const
-{
- return (m_refData != NULL);
-}
-
MGLCursor *wxCursor::GetMGLCursor() const
{
return M_CURSORDATA->m_cursor;
return true;
}
-wxObjectRefData *wxFont::CreateRefData() const
+wxGDIRefData *wxFont::CreateGDIRefData() const
{
return new wxFontRefData;
}
-wxObjectRefData *wxFont::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxFontRefData(*(wxFontRefData *)data);
}
{
}
-bool wxPalette::IsOk(void) const
-{
- return (m_refData != NULL);
-}
-
bool wxPalette::Create(int n,
const unsigned char *red,
const unsigned char *green,
}
-bool wxPen::IsOk() const
-{
- return (m_refData != NULL);
-}
-
-wxObjectRefData *wxPen::CreateRefData() const
+wxGDIRefData *wxPen::CreateGDIRefData() const
{
return new wxPenRefData;
}
-wxObjectRefData *wxPen::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxPen::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxPenRefData(*(wxPenRefData *)data);
}
// wxRegion
//-----------------------------------------------------------------------------
-wxObjectRefData *wxRegion::CreateRefData() const
+wxGDIRefData *wxRegion::CreateGDIRefData() const
{
return new wxRegionRefData;
}
-wxObjectRefData *wxRegion::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxRegion::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxRegionRefData(*(wxRegionRefData *)data);
}
#include "wx/listimpl.cpp"
WX_DEFINE_LIST(wxXCursorList)
-class WXDLLEXPORT wxCursorRefData: public wxObjectRefData
+class WXDLLEXPORT wxCursorRefData: public wxGDIRefData
{
- friend class wxCursor;
public:
wxCursorRefData();
virtual ~wxCursorRefData();
wxXCursorList m_cursors; // wxXCursor objects, one per display
wxStockCursor m_cursorId; // wxWidgets standard cursor id
+
+ friend class wxCursor;
};
#define M_CURSORDATA ((wxCursorRefData *)m_refData)
{
}
-bool wxCursor::IsOk() const
+wxGDIRefData *wxCursor::CreateGDIRefData() const
+{
+ return new wxCursorRefData;
+}
+
+wxGDIRefData *wxCursor::CloneGDIRefData(const wxGDIRefData *data) const
{
- return m_refData != NULL;
+ return new wxCursorRefData(*wx_static_cast(const wxCursorRefData *, data));
}
// Motif-specific: create/get a cursor for the current display
{
}
+wxGDIRefData *wxFont::CreateGDIRefData() const
+{
+ return new wxFontRefData;
+}
+
+wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxFontRefData(*wx_static_cast(const wxFontRefData *, data));
+}
+
// ----------------------------------------------------------------------------
// change the font attributes
// ----------------------------------------------------------------------------
m_bitmapMask = new wxMask(*data.m_bitmapMask);
// FIXME: we don't copy m_hBitmap currently but we should, see wxBitmap::
- // CloneRefData()
+ // CloneGDIRefData()
wxASSERT_MSG( !data.m_isDIB,
_T("can't copy bitmap locked for raw access!") );
return new wxBitmapRefData;
}
-wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *dataOrig) const
+wxGDIRefData *wxBitmap::CloneGDIRefData(const wxGDIRefData *dataOrig) const
{
const wxBitmapRefData *
data = wx_static_cast(const wxBitmapRefData *, dataOrig);
self->m_refData = new wxBitmapRefData(*data);
}
+ wxBitmapRefData * const
+ selfdata = wx_static_cast(wxBitmapRefData *, m_refData);
+
// copy also the mask
wxMask * const maskSrc = data->GetMask();
if ( maskSrc )
{
- wxBitmapRefData *selfdata = wx_static_cast(wxBitmapRefData *, m_refData);
-
selfdata->SetMask(new wxMask(*maskSrc));
}
- return m_refData;
+ return selfdata;
}
bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& icon,
return m_refData ? (brushData && *M_BRUSHDATA == *brushData) : !brushData;
}
-wxObjectRefData *wxBrush::CreateRefData() const
+wxGDIRefData *wxBrush::CreateGDIRefData() const
{
return new wxBrushRefData;
}
-wxObjectRefData *wxBrush::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxBrush::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxBrushRefData(*(const wxBrushRefData *)data);
}
// wxEnhMetaFile
// ----------------------------------------------------------------------------
+wxGDIRefData *wxEnhMetaFile::CreateGDIRefData() const
+{
+ wxFAIL_MSG( _T("must be implemented if used") );
+
+ return NULL;
+}
+
+wxGDIRefData *
+wxEnhMetaFile::CloneGDIRefData(const wxGDIRefData *WXUNUSED(data)) const
+{
+ wxFAIL_MSG( _T("must be implemented if used") );
+
+ return NULL;
+}
+
void wxEnhMetaFile::Init()
{
if ( m_filename.empty() )
// real implementation
// ----------------------------------------------------------------------------
-wxObjectRefData *wxFont::CreateRefData() const
+wxGDIRefData *wxFont::CreateGDIRefData() const
{
return new wxFontRefData();
}
-wxObjectRefData *wxFont::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxFontRefData(*wx_static_cast(const wxFontRefData *, data));
}
{
}
+wxGDIRefData *wxMetafile::CreateGDIRefData() const
+{
+ return new wxMetafileRefData;
+}
+
+wxGDIRefData *wxMetafile::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxMetafileRefData(wx_static_cast(wxMetafileRefData *, data));
+}
+
bool wxMetafile::SetClipboard(int width, int height)
{
#if !wxUSE_CLIPBOARD
#include "wx/palette.h"
-#ifndef WX_PRECOMP
-#endif
-
#include "wx/msw/private.h"
-IMPLEMENT_DYNAMIC_CLASS(wxPalette, wxGDIObject)
-
-/*
- * Palette
- *
- */
+// ============================================================================
+// wxPaletteRefData
+// ============================================================================
-wxPaletteRefData::wxPaletteRefData(void)
+class WXDLLEXPORT wxPaletteRefData: public wxGDIRefData
{
- m_hPalette = 0;
-}
+public:
+ wxPaletteRefData() { Init(); }
-wxPaletteRefData::~wxPaletteRefData(void)
-{
- if ( m_hPalette )
- ::DeleteObject((HPALETTE) m_hPalette);
-}
+ wxPaletteRefData(int n,
+ unsigned char *red,
+ unsigned char *green,
+ unsigned char *blue)
+ {
+ Init();
+
+ LOGPALETTE *pPal = Alloc(n);
+ if ( !pPal )
+ return;
+
+ for ( int i = 0; i < n; i++ )
+ {
+ pPal->palPalEntry[i].peRed = red[i];
+ pPal->palPalEntry[i].peGreen = green[i];
+ pPal->palPalEntry[i].peBlue = blue[i];
+ pPal->palPalEntry[i].peFlags = 0;
+ }
+
+ m_hPalette = ::CreatePalette(pPal);
+ free(pPal);
+ }
-wxPalette::wxPalette()
-{
-}
+ wxPaletteRefData(const wxPaletteRefData& data)
+ {
+ Init();
-wxPalette::wxPalette(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue)
-{
- Create(n, red, green, blue);
-}
+ const UINT n = data.GetEntries();
+ if ( !n )
+ return;
-wxPalette::~wxPalette(void)
-{
-// FreeResource(true);
-}
+ LOGPALETTE *pPal = Alloc(n);
+ if ( !pPal )
+ return;
-bool wxPalette::FreeResource(bool WXUNUSED(force))
-{
- if ( M_PALETTEDATA && M_PALETTEDATA->m_hPalette)
+ if ( ::GetPaletteEntries(data.m_hPalette, 0, n, pPal->palPalEntry) )
+ m_hPalette = ::CreatePalette(pPal);
+
+ free(pPal);
+ }
+
+ virtual ~wxPaletteRefData()
{
- DeleteObject((HPALETTE)M_PALETTEDATA->m_hPalette);
+ if ( m_hPalette )
+ ::DeleteObject(m_hPalette);
}
- return true;
-}
+ virtual bool IsOk() const { return m_hPalette != 0; }
-int wxPalette::GetColoursCount() const
-{
- if ( M_PALETTEDATA && M_PALETTEDATA->m_hPalette)
+ UINT GetEntries() const
{
- return ::GetPaletteEntries((HPALETTE) M_PALETTEDATA->m_hPalette, 0, 0, NULL );
+ return ::GetPaletteEntries(m_hPalette, 0, 0, NULL);
}
- return 0;
-}
+private:
+ // caller must free() the pointer
+ static LOGPALETTE *Alloc(UINT numEntries)
+ {
+ LOGPALETTE *pPal = (LOGPALETTE *)
+ malloc(sizeof(LOGPALETTE) + numEntries*sizeof(PALETTEENTRY));
+ if ( pPal )
+ {
+ pPal->palVersion = 0x300;
+ pPal->palNumEntries = numEntries;
+ }
+
+ return pPal;
+ }
-bool wxPalette::Create(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue)
-{
- UnRef();
+ void Init() { m_hPalette = 0; }
-#if defined(__WXMICROWIN__)
+ HPALETTE m_hPalette;
- return false;
+ friend class WXDLLIMPEXP_FWD_CORE wxPalette;
+};
-#else
+// ============================================================================
+// wxPalette
+// ============================================================================
- m_refData = new wxPaletteRefData;
+IMPLEMENT_DYNAMIC_CLASS(wxPalette, wxGDIObject)
- NPLOGPALETTE npPal = (NPLOGPALETTE)LocalAlloc(LMEM_FIXED, sizeof(LOGPALETTE) +
- (WORD)n * sizeof(PALETTEENTRY));
- if (!npPal)
- return false;
+#define M_PALETTEDATA ((wxPaletteRefData *)m_refData)
- npPal->palVersion = 0x300;
- npPal->palNumEntries = (WORD)n;
+bool wxPalette::Create(int n,
+ unsigned char *red,
+ unsigned char *green,
+ unsigned char *blue)
+{
+ m_refData = new wxPaletteRefData(n, red, green, blue);
- int i;
- for (i = 0; i < n; i ++)
- {
- npPal->palPalEntry[i].peRed = red[i];
- npPal->palPalEntry[i].peGreen = green[i];
- npPal->palPalEntry[i].peBlue = blue[i];
- npPal->palPalEntry[i].peFlags = 0;
- }
- M_PALETTEDATA->m_hPalette = (WXHPALETTE) CreatePalette((LPLOGPALETTE)npPal);
- LocalFree((HANDLE)npPal);
- return true;
+ return IsOk();
+}
-#endif
+wxGDIRefData *wxPalette::CreateGDIRefData() const
+{
+ return new wxPaletteRefData;
}
-int wxPalette::GetPixel(unsigned char red, unsigned char green, unsigned char blue) const
+wxGDIRefData *wxPalette::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxPaletteRefData(*wx_static_cast(const wxPaletteRefData *, data));
+}
+
+int wxPalette::GetColoursCount() const
+{
+ return IsOk() ? M_PALETTEDATA->GetEntries() : 0;
+}
+
+int wxPalette::GetPixel(unsigned char red,
+ unsigned char green,
+ unsigned char blue) const
{
-#ifdef __WXMICROWIN__
- return wxNOT_FOUND;
-#else
if ( !m_refData )
return wxNOT_FOUND;
- return ::GetNearestPaletteIndex((HPALETTE) M_PALETTEDATA->m_hPalette, PALETTERGB(red, green, blue));
-#endif
+ return ::GetNearestPaletteIndex(M_PALETTEDATA->m_hPalette,
+ PALETTERGB(red, green, blue));
}
-bool wxPalette::GetRGB(int index, unsigned char *red, unsigned char *green, unsigned char *blue) const
+bool wxPalette::GetRGB(int index,
+ unsigned char *red,
+ unsigned char *green,
+ unsigned char *blue) const
{
-#ifdef __WXMICROWIN__
- return false;
-#else
if ( !m_refData )
return false;
return false;
PALETTEENTRY entry;
- if (::GetPaletteEntries((HPALETTE) M_PALETTEDATA->m_hPalette, index, 1, &entry))
- {
- *red = entry.peRed;
- *green = entry.peGreen;
- *blue = entry.peBlue;
- return true;
- }
- else
+ if ( !::GetPaletteEntries(M_PALETTEDATA->m_hPalette, index, 1, &entry) )
return false;
-#endif
+
+ *red = entry.peRed;
+ *green = entry.peGreen;
+ *blue = entry.peBlue;
+
+ return true;
+}
+
+WXHPALETTE wxPalette::GetHPALETTE() const
+{
+ return M_PALETTEDATA ? (WXHPALETTE)M_PALETTEDATA->m_hPalette : 0;
}
void wxPalette::SetHPALETTE(WXHPALETTE pal)
{
- if ( !m_refData )
- m_refData = new wxPaletteRefData;
+ AllocExclusive();
- M_PALETTEDATA->m_hPalette = pal;
+ M_PALETTEDATA->m_hPalette = (HPALETTE)pal;
}
#endif // wxUSE_PALETTE
return M_PENDATA && !M_PENDATA->HasHPEN();
}
-wxObjectRefData* wxPen::CreateRefData() const
+wxGDIRefData* wxPen::CreateGDIRefData() const
{
return new wxPenRefData;
}
-wxObjectRefData* wxPen::CloneRefData(const wxObjectRefData* data) const
+wxGDIRefData* wxPen::CloneGDIRefData(const wxGDIRefData* data) const
{
return new wxPenRefData(*wx_static_cast(const wxPenRefData*, data));
}
// m_refData unrefed in ~wxObject
}
-wxObjectRefData *wxRegion::CreateRefData() const
+wxGDIRefData *wxRegion::CreateGDIRefData() const
{
return new wxRegionRefData;
}
-wxObjectRefData *wxRegion::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxRegion::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxRegionRefData(*(wxRegionRefData *)data);
}
// wxBitmap creation
// ----------------------------------------------------------------------------
-wxObjectRefData* wxBitmap::CreateRefData() const
+wxGDIRefData* wxBitmap::CreateGDIRefData() const
{
return new wxBitmapRefData;
}
-wxObjectRefData* wxBitmap::CloneRefData(const wxObjectRefData* data) const
+wxGDIRefData* wxBitmap::CloneGDIRefData(const wxGDIRefData* data) const
{
return new wxBitmapRefData(*wx_static_cast(const wxBitmapRefData *, data));
}
{
} // end of wxRegion::~wxRegion
-wxObjectRefData *wxRegion::CreateData() const
+wxGDIRefData *wxRegion::CreateData() const
{
return new wxRegionRefData;
}
-wxObjectRefData *wxRegion::CloneData(const wxObjectRefData *data) const
+wxGDIRefData *wxRegion::CloneData(const wxGDIRefData *data) const
{
return new wxRegionRefData(*(wxRegionRefData *)data);
}
return false;
}
-wxObjectRefData *wxBrush::CreateRefData() const
+wxGDIRefData *wxBrush::CreateGDIRefData() const
{
return NULL;
}
-wxObjectRefData *wxBrush::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxBrush::CloneGDIRefData(const wxGDIRefData *data) const
{
return NULL;
}
{
}
-wxObjectRefData *wxRegion::CreateRefData() const
+wxGDIRefData *wxRegion::CreateGDIRefData() const
{
return NULL;
}
-wxObjectRefData *wxRegion::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxRegion::CloneGDIRefData(const wxGDIRefData *data) const
{
return NULL;
}
// wxBitmap
//-----------------------------------------------------------------------------
-class wxBitmapRefData: public wxObjectRefData
+class wxBitmapRefData : public wxGDIRefData
{
public:
wxBitmapRefData();
// shouldn't be called more than once as it doesn't free the existing data
bool Create(int width, int height, int depth);
+ virtual bool IsOk() const { return m_pixmap || m_bitmap; }
+
Pixmap m_pixmap;
Pixmap m_bitmap;
Display *m_display;
Create(bits, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
}
-wxObjectRefData *wxBitmap::CreateRefData() const
+wxGDIRefData *wxBitmap::CreateGDIRefData() const
{
return new wxBitmapRefData;
}
-wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxBitmap::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxBitmapRefData(*wx_static_cast(const wxBitmapRefData *, data));
}
{
}
-bool wxBitmap::IsOk() const
-{
- return (m_refData != NULL);
-}
-
int wxBitmap::GetHeight() const
{
wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
// wxBrush
//-----------------------------------------------------------------------------
-class wxBrushRefData: public wxObjectRefData
+class wxBrushRefData : public wxGDIRefData
{
public:
wxBrushRefData()
// m_refData unrefed in ~wxObject
}
-wxObjectRefData *wxBrush::CreateRefData() const
+wxGDIRefData *wxBrush::CreateGDIRefData() const
{
return new wxBrushRefData;
}
-wxObjectRefData *wxBrush::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxBrush::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxBrushRefData(*(wxBrushRefData *)data);
}
// wxColour
//-----------------------------------------------------------------------------
-class wxColourRefData: public wxObjectRefData
+class wxColourRefData : public wxGDIRefData
{
public:
wxColourRefData()
m_colormap = (WXColormap *) NULL;
m_hasPixel = false;
}
- wxColourRefData(const wxColourRefData& data):
- wxObjectRefData()
+
+ wxColourRefData(const wxColourRefData& data)
{
m_color = data.m_color;
m_colormap = data.m_colormap;
FreeColour();
}
- bool operator == (const wxColourRefData& data) const
+ bool operator==(const wxColourRefData& data) const
{
return (m_colormap == data.m_colormap &&
m_hasPixel == data.m_hasPixel &&
}
-wxObjectRefData *wxColour::CreateRefData() const
+wxGDIRefData *wxColour::CreateGDIRefData() const
{
return new wxColourRefData;
}
-wxObjectRefData *wxColour::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxColour::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxColourRefData(*(wxColourRefData *)data);
}
#include "wx/utils.h"
#include "wx/icon.h"
#include "wx/gdicmn.h"
+ #include "wx/image.h"
#endif
#include "wx/x11/private.h"
// wxCursor
//-----------------------------------------------------------------------------
-class wxCursorRefData: public wxObjectRefData
+class wxCursorRefData: public wxGDIRefData
{
public:
{
}
-bool wxCursor::IsOk() const
+wxGDIRefData *wxCursor::CreateGDIRefData() const
{
- return (m_refData != NULL);
+ return new wxCursorRefData;
+}
+
+wxGDIRefData *wxCursor::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxCursorRefData(*wx_static_cast(const wxCursorRefData *, data));
}
WXCursor wxCursor::GetCursor() const
// wxFontRefData
// ----------------------------------------------------------------------------
-class wxFontRefData: public wxObjectRefData
+class wxFontRefData: public wxGDIRefData
{
friend class wxFont;
}
wxFontRefData::wxFontRefData( const wxFontRefData& data )
- : wxObjectRefData()
+ : wxGDIRefData()
{
m_pointSize = data.m_pointSize;
m_family = data.m_family;
{
}
+wxGDIRefData *wxFont::CreateGDIRefData() const
+{
+ return new wxFontRefData;
+}
+
+wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxFontRefData(*wx_static_cast(const wxFontRefData *, data));
+}
+
// ----------------------------------------------------------------------------
// change the font attributes
// ----------------------------------------------------------------------------
return true;
}
+wxGDIRefData *wxPalette::CreateGDIRefData() const
+{
+ return new wxPaletteRefData;
+}
+
+wxGDIRefData *wxPalette::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxPaletteRefData(*wx_static_cast(const wxPaletteRefData *, data));
+}
+
int wxPalette::GetPixel(unsigned char WXUNUSED(red),
unsigned char WXUNUSED(green),
unsigned char WXUNUSED(blue)) const
// wxPen
//-----------------------------------------------------------------------------
-class wxPenRefData: public wxObjectRefData
+class wxPenRefData : public wxGDIRefData
{
public:
wxPenRefData()
// m_refData unrefed in ~wxObject
}
-wxObjectRefData *wxPen::CreateRefData() const
+wxGDIRefData *wxPen::CreateGDIRefData() const
{
return new wxPenRefData;
}
-wxObjectRefData *wxPen::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxPen::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxPenRefData(*(wxPenRefData *)data);
}
// wxRegionRefData: private class containing the information about the region
// ----------------------------------------------------------------------------
-class wxRegionRefData : public wxObjectRefData
+class wxRegionRefData : public wxGDIRefData
{
public:
wxRegionRefData()
// m_refData unrefed in ~wxObject
}
-wxObjectRefData *wxRegion::CreateRefData() const
+wxGDIRefData *wxRegion::CreateGDIRefData() const
{
return new wxRegionRefData;
}
-wxObjectRefData *wxRegion::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxRegion::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxRegionRefData(*(wxRegionRefData *)data);
}
_XBox *rects, extents;
};
-class wxRIRefData: public wxObjectRefData
+class wxRIRefData: public wxGDIRefData
{
public:
projects / wxWidgets.git / commitdiff
