<wx/accel.h>
+\wxheading{Predefined objects}
+
+Objects:
+
+{\bf wxNullAcceleratorTable}
+
\wxheading{Example}
{\small%
\func{}{\destruct{wxAcceleratorTable}}{\void}
Destroys the wxAcceleratorTable object.
+See \helpref{reference-counted object destruction}{refcountdestruct} for more info.
\membersection{wxAcceleratorTable::IsOk}\label{wxacceleratortableisok}
\wxheading{Return value}
Returns reference to this object.
-
-\membersection{wxAcceleratorTable::operator $==$}\label{wxacceleratortableequal}
-
-\func{bool}{operator $==$}{\param{const wxAcceleratorTable\& }{accel}}
-
-Equality operator. This operator tests whether the internal data pointers are
-equal (a fast test).
-
-\wxheading{Parameters}
-
-\docparam{accel}{Accelerator table to compare with}
-
-\wxheading{Return value}
-
-Returns true if the accelerator tables were effectively equal, false otherwise.
-
-\membersection{wxAcceleratorTable::operator $!=$}\label{wxacceleratortablenotequal}
-
-\func{bool}{operator $!=$}{\param{const wxAcceleratorTable\& }{accel}}
-
-Inequality operator. This operator tests whether the internal data pointers are
-unequal (a fast test).
-
-\wxheading{Parameters}
-
-\docparam{accel}{Accelerator table to compare with}
-
-\wxheading{Return value}
-
-Returns true if the accelerator tables were unequal, false otherwise.
-
-
\func{}{wxAnimation}{\param{const wxAnimation\& }{anim}}
-Copy constructor.
-wxAnimation objects are reference counted so that this operation is very fast.
+Copy constructor, uses \helpref{reference counting}{trefcount}.
\func{}{wxAnimation}{\param{const wxString\& }{name}, \param{wxAnimationType}{ type = wxANIMATION\_TYPE\_ANY}}
\func{}{\destruct{wxAnimation}}{\void}
-Destroys the wxAnimation object and possibly the underlying animation data.
-Because reference counting is used, the animation may not actually be
-destroyed at this point - only when the reference count is zero will the
-data be deleted.
+Destructor.
+See \helpref{reference-counted object destruction}{refcountdestruct} for more info.
\membersection{wxAnimation::GetDelay}\label{wxanimationgetdelay}
\true if the operation succeeded, \false otherwise.
+
+\membersection{wxAnimation::operator $=$}\label{wxanimationassignment}
+
+\func{wxAnimation\&}{operator $=$}{\param{const wxAnimation\& }{brush}}
+
+Assignment operator, using \helpref{reference counting}{trefcount}.
+
\func{}{\destruct{wxBitmap}}{\void}
-Destroys the wxBitmap object and possibly the underlying bitmap data.
-Because reference counting is used, the bitmap may not actually be
-destroyed at this point - only when the reference count is zero will the
-data be deleted.
+Destructor.
+See \helpref{reference-counted object destruction}{refcountdestruct} for more info.
If the application omits to delete the bitmap explicitly, the bitmap will be
destroyed automatically by wxWidgets when the application exits.
Returns 'this' object.
-\membersection{wxBitmap::operator $==$}\label{wxbitmapequal}
-
-\func{bool}{operator $==$}{\param{const wxBitmap\& }{bitmap}}
-
-Equality operator. This operator tests whether the internal data pointers are
-equal (a fast test).
-
-\wxheading{Parameters}
-
-\docparam{bitmap}{Bitmap to compare with 'this'}
-
-\wxheading{Return value}
-
-Returns true if the bitmaps were effectively equal, false otherwise.
-
-\membersection{wxBitmap::operator $!=$}\label{wxbitmapnotequal}
-
-\func{bool}{operator $!=$}{\param{const wxBitmap\& }{bitmap}}
-
-Inequality operator. This operator tests whether the internal data pointers are
-unequal (a fast test).
-
-\wxheading{Parameters}
-
-\docparam{bitmap}{Bitmap to compare with 'this'}
-
-\wxheading{Return value}
-
-Returns true if the bitmaps were unequal, false otherwise.
\func{}{\destruct{wxBrush}}{\void}
Destructor.
+See \helpref{reference-counted object destruction}{refcountdestruct} for more info.
\wxheading{Remarks}
-The destructor may not delete the underlying brush object of the native windowing
-system, since wxBrush uses a reference counting system for efficiency.
-
Although all remaining brushes are deleted when the application exits,
the application should try to clean up all brushes itself. This is because
wxWidgets cannot know if a pointer to the brush object is stored in an
\func{bool}{operator $==$}{\param{const wxBrush\& }{brush}}
-Equality operator. Two brushes are equal if they contain pointers
-to the same underlying brush data. It does not compare each attribute,
-so two independently-created brushes using the same parameters will
-fail the test.
+Equality operator.
+See \helpref{reference-counted object comparison}{refcountequality} for more info.
\membersection{wxBrush::operator $!=$}\label{wxbrushnotequals}
\func{bool}{operator $!=$}{\param{const wxBrush\& }{brush}}
-Inequality operator. Two brushes are not equal if they contain pointers
-to different underlying brush data. It does not compare each attribute.
+Inequality operator.
+See \helpref{reference-counted object comparison}{refcountequality} for more info.
+
\section{\class{wxBrushList}}\label{wxbrushlist}
\func{}{\destruct{wxCursor}}{\void}
-Destroys the cursor. A cursor can be reused for more
+Destroys the cursor.
+See \helpref{reference-counted object destruction}{refcountdestruct} for more info.
+
+A cursor can be reused for more
than one window, and does not get destroyed when the window is
destroyed. wxWidgets destroys all cursors on application exit, although
it is best to clean them up explicitly.
Assignment operator, using \helpref{reference counting}{trefcount}.
-\membersection{wxCursor::operator $==$}\label{wxcursorequals}
-
-\func{bool}{operator $==$}{\param{const wxCursor\& }{cursor}}
-
-Equality operator. Two cursors are equal if they contain pointers
-to the same underlying cursor data. It does not compare each attribute,
-so two independently-created cursors using the same parameters will
-fail the test.
-
-\membersection{wxCursor::operator $!=$}\label{wxcursornotequals}
-
-\func{bool}{operator $!=$}{\param{const wxCursor\& }{cursor}}
-
-Inequality operator. Two cursors are not equal if they contain pointers
-to different underlying cursor data. It does not compare each attribute.
-
-
\func{}{\destruct{wxFont}}{\void}
Destructor.
+See \helpref{reference-counted object destruction}{refcountdestruct} for more info.
\wxheading{Remarks}
-The destructor may not delete the underlying font object of the native windowing
-system, since wxFont uses a reference counting system for efficiency.
-
Although all remaining fonts are deleted when the application exits,
the application should try to clean up all fonts itself. This is because
wxWidgets cannot know if a pointer to the font object is stored in an
\func{bool}{operator $==$}{\param{const wxFont\& }{font}}
-Equality operator. Two fonts are equal if they contain pointers
-to the same underlying font data. It does not compare each attribute,
-so two independently-created fonts using the same parameters will
-fail the test.
+Equality operator.
+See \helpref{reference-counted object comparison}{refcountequality} for more info.
\membersection{wxFont::operator $!=$}\label{wxfontnotequals}
\func{bool}{operator $!=$}{\param{const wxFont\& }{font}}
-Inequality operator. Two fonts are not equal if they contain pointers
-to different underlying font data. It does not compare each attribute.
+Inequality operator.
+See \helpref{reference-counted object comparison}{refcountequality} for more info.
\func{}{\destruct{wxIcon}}{\void}
-Destroys the wxIcon object and possibly the underlying icon data.
-Because reference counting is used, the icon may not actually be
-destroyed at this point - only when the reference count is zero will the
-data be deleted.
+Destructor.
+See \helpref{reference-counted object destruction}{refcountdestruct} for more info.
If the application omits to delete the icon explicitly, the icon will be
destroyed automatically by wxWidgets when the application exits.
\func{wxIcon\& }{operator $=$}{\param{const wxIcon\& }{icon}}
-Assignment operator. This operator does not copy any data, but instead
-passes a pointer to the data in {\it icon} and increments a reference
-counter. It is a fast operation.
+Assignment operator, using \helpref{reference counting}{trefcount}.
\wxheading{Parameters}
Returns 'this' object.
-\membersection{wxIcon::operator $==$}\label{wxiconequal}
-
-\func{bool}{operator $==$}{\param{const wxIcon\& }{icon}}
-
-Equality operator. This operator tests whether the internal data pointers are
-equal (a fast test).
-
-\wxheading{Parameters}
-
-\docparam{icon}{Icon to compare with 'this'}
-
-\wxheading{Return value}
-
-Returns true if the icons were effectively equal, false otherwise.
-
-\membersection{wxIcon::operator $!=$}\label{wxiconnotequal}
-
-\func{bool}{operator $!=$}{\param{const wxIcon\& }{icon}}
-
-Inequality operator. This operator tests whether the internal data pointers are
-unequal (a fast test).
-
-\wxheading{Parameters}
-
-\docparam{icon}{Icon to compare with 'this'}
-
-\wxheading{Return value}
-
-Returns true if the icons were unequal, false otherwise.
-
\func{}{\destruct{wxImage}}{\void}
Destructor.
+See \helpref{reference-counted object destruction}{refcountdestruct} for more info.
\membersection{wxImage::AddHandler}\label{wximageaddhandler}
Returns 'this' object.
-\membersection{wxImage::operator $==$}\label{wximageequal}
-
-\constfunc{bool}{operator $==$}{\param{const wxImage\& }{image}}
-
-Equality operator. This operator tests whether the internal data pointers are
-equal (a fast test).
-
-\wxheading{Parameters}
-
-\docparam{image}{Image to compare with 'this'}
-
-\wxheading{Return value}
-
-Returns true if the images were effectively equal, false otherwise.
-
-
-\membersection{wxImage::operator $!=$}\label{wximagenotequal}
-
-\constfunc{bool}{operator $!=$}{\param{const wxImage\& }{image}}
-
-Inequality operator. This operator tests whether the internal data pointers are
-unequal (a fast test).
-
-\wxheading{Parameters}
-
-\docparam{image}{Image to compare with 'this'}
-
-\wxheading{Return value}
-
-Returns true if the images were unequal, false otherwise.
\section{\class{wxImageHandler}}\label{wximagehandler}
\func{}{\destruct{wxMetafile}}{\void}
Destructor.
+See \helpref{reference-counted object destruction}{refcountdestruct} for more info.
\membersection{wxMetafile::IsOk}\label{wxmetafileisok}
bool tmp = obj->IsKindOf(CLASSINFO(wxFrame));
\end{verbatim}
+\membersection{wxObject::IsRefTo}\label{wxobjectisrefto}
+
+\func{bool}{IsRefTo}{\param{const wxObject *}{ obj}}
+
+Returns \true if this object is referencing the \arg{obj}'s data.
+Note that this function only does a {\tt shallow} comparison.
+
\membersection{wxObject::Ref}\label{wxobjectref}
\func{void}{Ref}{\param{const wxObject\& }{clone}}
\helpref{wxObject::SetRefData}{wxobjectsetrefdata}, \helpref{wxObject::GetRefData}{wxobjectgetrefdata},\rtfsp
\helpref{wxObjectRefData}{wxobjectrefdata}
+\membersection{wxObject::UnShare}\label{wxobjectunshare}
+
+\func{void}{UnShare}{\void}
+
+Ensure that this object's data is not shared with any other object.
+
+if we have no
+data, it is created using CreateRefData() below, if we have shared data
+it is copied using CloneRefData(), otherwise nothing is done.
+
+
\membersection{wxObject::operator new}\label{wxobjectnew}
\func{void *}{new}{\param{size\_t }{size}, \param{const wxString\& }{filename = NULL}, \param{int}{ lineNum = 0}}
\func{}{\destruct{wxPalette}}{\void}
Destructor.
+See \helpref{reference-counted object destruction}{refcountdestruct} for more info.
\membersection{wxPalette::Create}\label{wxpalettecreate}
Assignment operator, using \helpref{reference counting}{trefcount}.
-\membersection{wxPalette::operator $==$}\label{wxpaletteequals}
-
-\func{bool}{operator $==$}{\param{const wxPalette\& }{palette}}
-
-Equality operator. Two palettes are equal if they contain pointers
-to the same underlying palette data. It does not compare each attribute,
-so two independently-created palettes using the same parameters will
-fail the test.
-
-\membersection{wxPalette::operator $!=$}\label{wxpalettenotequals}
-
-\func{bool}{operator $!=$}{\param{const wxPalette\& }{palette}}
-
-Inequality operator. Two palettes are not equal if they contain pointers
-to different underlying palette data. It does not compare each attribute.
-
\func{}{\destruct{wxPen}}{\void}
Destructor.
+See \helpref{reference-counted object destruction}{refcountdestruct} for more info.
\wxheading{Remarks}
-The destructor may not delete the underlying pen object of the native windowing
-system, since wxBrush uses a reference counting system for efficiency.
-
Although all remaining pens are deleted when the application exits,
the application should try to clean up all pens itself. This is because
wxWidgets cannot know if a pointer to the pen object is stored in an
\func{bool}{operator $==$}{\param{const wxPen\& }{pen}}
-Equality operator. Two pens are equal if they contain pointers
-to the same underlying pen data. It does not compare each attribute,
-so two independently-created pens using the same parameters will
-fail the test.
+Equality operator.
+See \helpref{reference-counted object comparison}{refcountequality} for more info.
\membersection{wxPen::operator $!=$}\label{wxpennotequals}
\func{bool}{operator $!=$}{\param{const wxPen\& }{pen}}
-Inequality operator. Two pens are not equal if they contain pointers
-to different underlying pen data. It does not compare each attribute.
+Inequality operator.
+See \helpref{reference-counted object comparison}{refcountequality} for more info.
\section{\class{wxPenList}}\label{wxpenlist}
\func{}{\destruct{wxRegion}}{\void}
Destructor.
+See \helpref{reference-counted object destruction}{refcountdestruct} for more info.
\membersection{wxRegion::Clear}\label{wxregionclear}
\section{Reference counting}\label{trefcount}
-\subsection{Reference counting and why you shouldn't care about it}\label{refcount}
+\subsection{Why you shouldn't care about it}\label{refcount}
Many wxWidgets objects use a technique known as \it{reference counting}, also known
as {\it copy on write} (COW).
operation on it is the same.
\subsection{List of reference-counted wxWidgets classes}\label{refcountlist}
+\subsection{Object comparison}\label{refcountequality}
+
+The $==$ and $!=$ operators of \helpref{wxWidgets COW objects}{refcountlist}
+always do a {\tt deep} comparison.
+
+This means that the equality operator will return \true if two objects are
+identic and not only if they share the same data.
+
+Note that wxWidgets follows the {\it STL philosophy}: when a comparison operator cannot
+be implemented efficiently (like for e.g. wxImage's $==$ operator which would need to
+compare pixel-by-pixel the entire image's data), it's not implemented at all.
+
+That's why not all reference-counted wxWidgets classes provide comparison operators.
+
+Also note that if you only need to do a {\tt shallow} comparison between two
+\helpref{wxObject}{wxobject}-derived classes, you should not use the $==$ and $!=$ operators
+but rather the \helpref{wxObject::IsRefTo}{wxobjectisrefto} function.
+
+
+\subsection{Object destruction}\label{refcountdestruct}
+
+When a COW object destructor is called, it may not delete the data: if it's shared,
+the destructor will just decrement the shared data's reference count without destroying it.
+
+Only when the destructor of the last object owning the data is called, the data is really
+destroyed. As for all other COW-things, this happens transparently to the class users so
+that you shouldn't care about it.
+
The following classes in wxWidgets have efficient (i.e. fast) assignment operators
and copy constructors since they are reference-counted:
\helpref{wxAcceleratorTable}{wxacceleratortable}\\
+\helpref{wxAnimation}{wxanimation}\\
+\helpref{wxBitmap}{wxbitmap}\\
\helpref{wxBrush}{wxbrush}\\
\helpref{wxCursor}{wxcursor}\\
\helpref{wxFont}{wxfont}\\
+\helpref{wxIcon}{wxicon}\\
\helpref{wxImage}{wximage}\\
\helpref{wxMetafile}{wxmetafile}\\
\helpref{wxPalette}{wxpalette}\\
\helpref{wxPen}{wxpen}\\
\helpref{wxRegion}{wxregion}\\
-\helpref{wxRegionIterator}{wxregioniterator}\\
\helpref{wxString}{wxstring}
+Note that the list above reports the objects which are reference-counted in all ports of
+wxWidgets; some ports may use this tecnique also for other classes.
\subsection{Make your own reference-counted class}\label{wxobjectoverview}
Reference counting can be implemented easily using \helpref{wxObject}{wxobject}
wxBitmap(const char* const* bits);
wxBitmap(const wxString &filename, wxBitmapType type = wxBITMAP_TYPE_XPM);
wxBitmap(const wxImage& image, int depth = -1);
- bool operator == (const wxBitmap& bmp) const;
- bool operator != (const wxBitmap& bmp) const;
bool Create(int width, int height, int depth = -1);
int GetBitmapType() const;
- inline bool operator == (const wxBitmap& bitmap) const
- { return m_refData == bitmap.m_refData; }
- inline bool operator != (const wxBitmap& bitmap) const
- { return m_refData != bitmap.m_refData; }
-
// wxObjectRefData
wxObjectRefData *CreateRefData() const;
wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
if (style & wxBUFFER_VIRTUAL_AREA)
window->PrepareDC( m_paintdc );
- if( buffer != wxNullBitmap )
+ if( buffer.IsOk() )
Init(&m_paintdc, buffer, style);
else
Init(&m_paintdc, window->GetClientSize(), style);
bool Ok() const { return IsOk(); }
bool IsOk() const;
- bool operator==(const wxBitmap& bmp) const;
- bool operator!=(const wxBitmap& bmp) const { return !(*this == bmp); }
bool Create(const wxIDirectFBSurfacePtr& surface);
bool Create(int width, int height, int depth = -1);
bool Ok() const { return IsOk(); }
bool IsOk() const;
- bool operator==(const wxCursor& cursor) const;
- bool operator!=(const wxCursor& cursor) const { return !(*this == cursor); }
// implementation
wxBitmap GetBitmap() const;
wxAcceleratorTable(int n, const wxAcceleratorEntry entries[]);
virtual ~wxAcceleratorTable();
-#if WXWIN_COMPATIBILITY_2_4
- bool operator==(const wxAcceleratorTable& accel) const
- { return m_refData == accel.m_refData; }
- bool operator!=(const wxAcceleratorTable& accel) const
- { return !(*this == accel); }
-#endif
-
bool Ok() const { return IsOk(); }
bool IsOk() const;
class WXDLLIMPEXP_ADV wxAnimation : public wxAnimationBase
{
public:
- bool operator == (const wxAnimation& anim) const
- { return m_refData == anim.m_refData; }
- bool operator != (const wxAnimation& anim) const
- { return m_refData != anim.m_refData; }
-
virtual bool IsOk() const
{ return m_refData != NULL; }
{
}
- bool operator==(const wxIcon& icon) const
- { return m_refData == icon.m_refData; }
- bool operator!=(const wxIcon& icon) const
- { return !(*this == icon); }
-
// create from bitmap (which should have a mask unless it's monochrome):
// there shouldn't be any implicit bitmap -> icon conversion (i.e. no
// ctors, assignment operators...), but it's ok to have such function
wxPalette();
wxPalette( int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue );
virtual ~wxPalette();
- bool operator == ( const wxPalette& palette ) const;
- bool operator != ( const wxPalette& palette ) const;
virtual bool Ok() const { return IsOk(); }
virtual bool IsOk() const;
wxAnimation& operator= (const wxAnimation&);
- bool operator == (const wxAnimation& anim) const
- { return m_pixbuf == anim.m_pixbuf; }
- bool operator != (const wxAnimation& anim) const
- { return m_pixbuf != anim.m_pixbuf; }
-
virtual bool IsOk() const
{ return m_pixbuf != NULL; }
wxBitmap( const wxString &filename, wxBitmapType type = wxBITMAP_TYPE_XPM );
wxBitmap( const wxImage& image, int depth = -1 ) { (void)CreateFromImage(image, depth); }
virtual ~wxBitmap();
- bool operator == ( const wxBitmap& bmp ) const;
- bool operator != ( const wxBitmap& bmp ) const { return !(*this == bmp); }
bool Ok() const { return IsOk(); }
bool IsOk() const;
int hotSpotX=-1, int hotSpotY=-1,
const char maskBits[] = NULL, const wxColour *fg = NULL, const wxColour *bg = NULL );
virtual ~wxCursor();
- bool operator == ( const wxCursor& cursor ) const;
- bool operator != ( const wxCursor& cursor ) const;
bool Ok() const { return IsOk(); }
bool IsOk() const;
public:
wxRegionIterator();
wxRegionIterator(const wxRegion& region);
+ ~wxRegionIterator();
void Reset() { m_current = 0u; }
void Reset(const wxRegion& region);
wxRect GetRect() const;
private:
+ void Init();
+ void CreateRects( const wxRegion& r );
+
size_t m_current;
wxRegion m_region;
+ wxRect *m_rects;
+ size_t m_numRects;
+
private:
DECLARE_DYNAMIC_CLASS(wxRegionIterator)
};
wxBitmap( const wxString &filename, wxBitmapType type = wxBITMAP_TYPE_XPM );
wxBitmap( const wxImage& image, int depth = -1 ) { (void)CreateFromImage(image, depth); }
virtual ~wxBitmap();
- bool operator == ( const wxBitmap& bmp ) const;
- bool operator != ( const wxBitmap& bmp ) const;
bool Ok() const { return IsOk(); }
bool IsOk() const;
int hotSpotX=-1, int hotSpotY=-1,
const char maskBits[] = NULL, const wxColour *fg = NULL, const wxColour *bg = NULL );
virtual ~wxCursor();
- bool operator == ( const wxCursor& cursor ) const;
- bool operator != ( const wxCursor& cursor ) const;
bool Ok() const { return IsOk(); }
bool IsOk() const;
// -1.0..1.0 where -1.0 is -360 degrees and 1.0 is 360 degrees
void RotateHue(double angle);
- bool operator == (const wxImage& image) const
- { return m_refData == image.m_refData; }
- bool operator != (const wxImage& image) const
- { return m_refData != image.m_refData; }
-
static wxList& GetHandlers() { return sm_handlers; }
static void AddHandler( wxImageHandler *handler );
static void InsertHandler( wxImageHandler *handler );
virtual ~wxAcceleratorTable();
- bool operator == (const wxAcceleratorTable& accel) const
- { return m_refData == accel.m_refData; }
- bool operator != (const wxAcceleratorTable& accel) const
- { return m_refData != accel.m_refData; }
-
bool Ok() const { return IsOk(); }
bool IsOk() const;
wxMask *GetMask() const;
void SetMask(wxMask *mask) ;
- inline bool operator == (const wxBitmap& bitmap) const { return m_refData == bitmap.m_refData; }
- inline bool operator != (const wxBitmap& bitmap) const { return m_refData != bitmap.m_refData; }
-
static void InitStandardHandlers();
// raw bitmap access support functions, for internal use only
virtual void MacSetTheme(short macThemeBrush) ;
virtual void MacSetThemeBackground(unsigned long macThemeBackground , WXRECTPTR extent) ;
- bool operator == (const wxBrush& brush) const
- { return m_refData == brush.m_refData; }
+ bool operator == (const wxBrush& brush) const;
bool operator != (const wxBrush& brush) const
- { return m_refData != brush.m_refData; }
+ { return !(*this == brush); }
wxMacBrushKind MacGetBrushKind() const ;
virtual bool Ok() const { return IsOk(); }
virtual bool IsOk() const ;
- 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; }
-
void MacInstall() const ;
void SetHCURSOR(WXHCURSOR cursor);
bool LoadFile(const wxString& name ,wxBitmapType flags = wxBITMAP_TYPE_ICON_RESOURCE )
{ return LoadFile( name , flags , -1 , -1 ) ; }
- bool operator==(const wxIcon& icon) const { return m_refData == icon.m_refData; }
- bool operator!=(const wxIcon& icon) const { return !(*this == icon); }
// create from bitmap (which should have a mask unless it's monochrome):
// there shouldn't be any implicit bitmap -> icon conversion (i.e. no
// Implementation
WXHMETAFILE GetHMETAFILE() const ;
void SetHMETAFILE(WXHMETAFILE mf) ;
-
- // Operators
- inline bool operator == (const wxMetafile& metafile) const { return m_refData == metafile.m_refData; }
- inline bool operator != (const wxMetafile& metafile) const { return m_refData != metafile.m_refData; }
-
-protected:
};
class WXDLLEXPORT wxMetafileDC: public wxDC
virtual bool Ok() const { return IsOk(); }
virtual bool IsOk() const { return (m_refData != NULL) ; }
- inline bool operator == (const wxPalette& palette) const { return m_refData == palette.m_refData; }
- inline bool operator != (const wxPalette& palette) const { return m_refData != palette.m_refData; }
-
virtual int GetColoursCount() const;
private:
wxPenRefData& operator=(const wxPenRefData& data);
+ bool operator==(const wxPenRefData& data) const
+ {
+ // 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.IsRefTo(&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;
wxPen(const wxBitmap& stipple, int width);
virtual ~wxPen();
- 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; }
+ inline bool operator == (const wxPen& pen) const
+ {
+ const wxPenRefData *penData = (wxPenRefData *)pen.m_refData;
+
+ // an invalid pen is only equal to another invalid pen
+ return m_refData ? penData && *M_PENDATA == *penData : !penData;
+ }
+
+ inline bool operator != (const wxPen& pen) const { return *(this == pen); }
virtual bool Ok() const { return IsOk(); }
virtual bool IsOk() const { return (m_refData != NULL) ; }
int GetBitmapType() const;
- inline bool operator == (const wxBitmap& bitmap) const { return m_refData == bitmap.m_refData; }
- inline bool operator != (const wxBitmap& bitmap) const { return m_refData != bitmap.m_refData; }
-
static void InitStandardHandlers();
// raw bitmap access support functions, for internal use only
wxBitmap(const wxString &filename, wxBitmapType type = wxBITMAP_TYPE_RESOURCE);
wxBitmap(const wxImage& image, int depth = -1);
virtual ~wxBitmap() {}
- bool operator == (const wxBitmap& bmp) const;
- bool operator != (const wxBitmap& bmp) const;
bool Ok() const { return IsOk(); }
bool IsOk() const;
long flags = wxBITMAP_TYPE_CUR_RESOURCE,
int hotSpotX = 0, int hotSpotY = 0);
virtual ~wxCursor();
- bool operator == (const wxCursor& cursor) const;
- bool operator != (const wxCursor& cursor) const;
bool Ok() const { return IsOk(); }
bool IsOk() const;
wxPalette();
wxPalette(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);
virtual ~wxPalette();
- bool operator == (const wxPalette& palette) const;
- bool operator != (const wxPalette& palette) const;
virtual bool Ok() const { return IsOk(); }
virtual bool IsOk() const;
virtual ~wxAcceleratorTable();
- bool operator == (const wxAcceleratorTable& accel) const { return m_refData == accel.m_refData; }
- bool operator != (const wxAcceleratorTable& accel) const { return m_refData != accel.m_refData; }
-
bool Ok() const { return IsOk(); }
bool IsOk() const;
virtual bool Ok() const { return IsOk(); }
virtual bool IsOk() const;
- bool operator == (const wxCursor& cursor) const
- { return m_refData == cursor.m_refData; }
- bool operator != (const wxCursor& cursor) const
- { return m_refData != cursor.m_refData; }
-
// Motif-specific.
// Create/get a cursor for the current display
WXCursor GetXCursor(WXDisplay* display) const;
// ctors, assignment operators...), but it's ok to have such function
void CopyFromBitmap(const wxBitmap& bmp);
- bool operator == (const wxIcon& icon) const
- { return m_refData == icon.m_refData; }
- bool operator != (const wxIcon& icon) const
- { return !(*this == icon); }
-
DECLARE_DYNAMIC_CLASS(wxIcon)
};
virtual bool Ok() const { return IsOk(); }
virtual bool IsOk() const { return (m_refData != NULL) ; }
- bool operator == (const wxPalette& palette) const { return m_refData == palette.m_refData; }
- bool operator != (const wxPalette& palette) const { return m_refData != palette.m_refData; }
-
// Motif-specific
WXColormap GetXColormap(WXDisplay* display = NULL) const;
bool TransferBitmap(void *data, int depth, int size);
// initialize from array
wxAcceleratorTable(int n, const wxAcceleratorEntry entries[]);
- bool operator==(const wxAcceleratorTable& accel) const;
- bool operator!=(const wxAcceleratorTable& accel) const
- { return !(*this == accel); }
-
bool Ok() const { return IsOk(); }
bool IsOk() const;
void SetHACCEL(WXHACCEL hAccel);
wxBitmap GetMaskBitmap() const;
void SetMask(wxMask *mask);
- bool operator==(const wxBitmap& bitmap) const { return m_refData == bitmap.m_refData; }
- bool operator!=(const wxBitmap& bitmap) const { return m_refData != bitmap.m_refData; }
-
// these functions are internal and shouldn't be used, they risk to
// disappear in the future
bool HasAlpha() const;
wxCursor(int idCursor);
virtual ~wxCursor();
- bool operator==(const wxCursor& cursor) const;
- bool operator!=(const wxCursor& cursor) const
- { return !(*this == cursor); }
-
// implementation only
void SetHCURSOR(WXHCURSOR cursor) { SetHandle((WXHANDLE)cursor); }
WXHCURSOR GetHCURSOR() const { return (WXHCURSOR)GetHandle(); }
long type = wxBITMAP_TYPE_ICO_RESOURCE,
int desiredWidth = -1, int desiredHeight = -1);
- bool operator == (const wxIcon& icon) const
- { return m_refData == icon.m_refData; }
- bool operator != (const wxIcon& icon) const
- { return m_refData != icon.m_refData; }
-
// implementation only from now on
wxIconRefData *GetIconData() const { return (wxIconRefData *)m_refData; }
int GetWindowsMappingMode() const { return M_METAFILEDATA->m_windowsMappingMode; }
void SetWindowsMappingMode(int mm);
- // Operators
- bool operator==(const wxMetafile& metafile) const
- { return m_refData == metafile.m_refData; }
- bool operator!=(const wxMetafile& metafile) const
- { return m_refData != metafile.m_refData; }
-
private:
DECLARE_DYNAMIC_CLASS(wxMetafile)
};
virtual bool Ok() const { return IsOk(); }
virtual bool IsOk(void) const { return (m_refData != NULL) ; }
- inline bool operator == (const wxPalette& palette) const { return m_refData == palette.m_refData; }
- inline bool operator != (const wxPalette& palette) const { return m_refData != palette.m_refData; }
-
virtual bool FreeResource(bool force = false);
// implemetation
m_join == data.m_join &&
m_cap == data.m_cap &&
m_colour == data.m_colour &&
- (m_style != wxSTIPPLE || m_stipple == data.m_stipple) &&
+ (m_style != wxSTIPPLE || m_stipple.IsRefTo(&data.m_stipple)) &&
(m_style != wxUSER_DASH ||
(m_nbDash == data.m_nbDash &&
memcmp(m_dash, data.m_dash, m_nbDash*sizeof(wxDash)) == 0));
// Make sure this object has only one reference
void UnShare() { AllocExclusive(); }
+ // Do a shallow comparison of our referenced data with the given object's refdata
+ bool IsRefTo(const wxObject *p) const { return m_refData == p->m_refData; }
+
protected:
// ensure that our data is not shared with anybody else: if we have no
// data, it is created using CreateRefData() below, if we have shared data
virtual ~wxAcceleratorTable();
- inline bool operator== (const wxAcceleratorTable& rAccel) const
- { return m_refData == rAccel.m_refData; };
- inline bool operator!= (const wxAcceleratorTable& rAccel) const
- { return m_refData != rAccel.m_refData; };
-
bool Ok() const { return IsOk(); }
bool IsOk() const;
void SetHACCEL(WXHACCEL hAccel);
void SetMask(wxMask* pMask) ;
- inline bool operator==(const wxBitmap& rBitmap) const
- { return m_refData == rBitmap.m_refData; }
-
- inline bool operator!=(const wxBitmap& rBitmap) const
- { return m_refData != rBitmap.m_refData; }
-
// Implementation
public:
inline void SetHBITMAP(WXHBITMAP hBmp)
wxBrush(const wxBitmap& rStipple);
virtual ~wxBrush();
- inline bool operator == (const wxBrush& rBrush) const { return m_refData == rBrush.m_refData; }
- inline bool operator != (const wxBrush& rBrush) const { return m_refData != rBrush.m_refData; }
+ inline bool operator == (const wxBrush& rBrush) const;
+ inline bool operator != (const wxBrush& rBrush) const { return !(*this == rBrush); }
virtual void SetColour(const wxColour& rColour);
virtual void SetColour(unsigned char cRed, unsigned char cGreen, unsigned char cBrush);
);
wxCursor(int nCursorType);
inline ~wxCursor() { }
- inline bool operator == (const wxCursor& rCursor) const { return m_refData == rCursor.m_refData; }
- inline bool operator != (const wxCursor& rCursor) const { return m_refData != rCursor.m_refData; }
inline WXHCURSOR GetHCURSOR(void) const { return (M_CURSORDATA ? M_CURSORDATA->m_hCursor : 0); }
inline void SetHCURSOR(WXHCURSOR hCursor) { SetHandle((WXHANDLE)hCursor); }
,int nDesiredHeight = -1
);
- inline bool operator == (const wxIcon& rIcon) const
- { return m_refData == rIcon.m_refData; }
- inline bool operator != (const wxIcon& rIcon) const
- { return m_refData != rIcon.m_refData; }
-
wxIconRefData *GetIconData() const { return (wxIconRefData *)m_refData; }
inline void SetHICON(WXHICON hIcon) { SetHandle((WXHANDLE)hIcon); }
void SetHMETAFILE(WXHANDLE mf) ;
inline int GetWindowsMappingMode(void) { return M_METAFILEDATA->m_windowsMappingMode; }
void SetWindowsMappingMode(int mm);
-
- // Operators
- inline bool operator== (const wxMetafile& metafile) const
- { return m_refData == metafile.m_refData; }
- inline bool operator!= (const wxMetafile& metafile) const
- { return m_refData != metafile.m_refData; }
};
class WXDLLEXPORT wxMetafileDC: public wxDC
virtual bool Ok() const { return IsOk(); }
virtual bool IsOk(void) const { return (m_refData != NULL) ; }
- inline bool operator == (const wxPalette& rPalette) const
- { return m_refData == rPalette.m_refData; }
- inline bool operator != (const wxPalette& rPalette) const
- { return m_refData != rPalette.m_refData; }
-
virtual bool FreeResource(bool bForce = false);
inline WXHPALETTE GetHPALETTE(void) const { return (M_PALETTEDATA ? M_PALETTEDATA->m_hPalette : 0); }
wxPenRefData(const wxPenRefData& rData);
virtual ~wxPenRefData();
+ bool operator==(const wxPenRefData& data) const
+ {
+ // we intentionally don't compare m_hPen fields here
+ return m_nStyle == data.m_nStyle &&
+ m_nWidth == data.m_nWidth &&
+ m_nJoin == data.m_nJoin &&
+ m_nCap == data.m_nCap &&
+ m_vColour == data.m_vColour &&
+ (m_style != wxSTIPPLE || m_stipple.IsRefTo(&data.m_stipple)) &&
+ (m_style != wxUSER_DASH ||
+ (m_dash == data.m_dash &&
+ memcmp(m_dash, data.m_dash, m_nbDash*sizeof(wxDash)) == 0));
+ }
+
protected:
int m_nWidth;
int m_nStyle;
virtual ~wxPen();
inline bool operator == (const wxPen& rPen) const
- { return m_refData == rPen.m_refData; }
+ {
+ const wxPenRefData *penData = (wxPenRefData *)pen.m_refData;
+
+ // an invalid pen is only equal to another invalid pen
+ return m_refData ? penData && *M_PENDATA == *penData : !penData;
+ }
+
inline bool operator != (const wxPen& rPen) const
- { return m_refData != rPen.m_refData; }
+ { return !(*this == rPen); }
virtual bool Ok() const { return IsOk(); }
virtual bool IsOk(void) const { return (m_refData != NULL); }
virtual ~wxAcceleratorTable();
-#if WXWIN_COMPATIBILITY_2_4
- bool operator==(const wxAcceleratorTable& accel) const
- { return m_refData == accel.m_refData; }
- bool operator!=(const wxAcceleratorTable& accel) const
- { return !(*this == accel); }
-#endif
-
bool Ok() const { return IsOk(); }
bool IsOk() const;
void SetHACCEL(WXHACCEL hAccel);
wxMask *GetMask() const;
void SetMask(wxMask *mask);
- bool operator==(const wxBitmap& bitmap) const { return m_refData == bitmap.m_refData; }
- bool operator!=(const wxBitmap& bitmap) const { return m_refData != bitmap.m_refData; }
-
// these functions are internal and shouldn't be used, they risk to
// disappear in the future
bool HasAlpha() const;
wxCursor(int idCursor);
virtual ~wxCursor();
- bool operator==(const wxCursor& cursor) const;
- bool operator!=(const wxCursor& cursor) const
- { return !(*this == cursor); }
-
// implementation only
void SetHCURSOR(WXHCURSOR cursor) { SetHandle((WXHANDLE)cursor); }
WXHCURSOR GetHCURSOR() const { return (WXHCURSOR)GetHandle(); }
int GetWindowsMappingMode() const { return M_METAFILEDATA->m_windowsMappingMode; }
void SetWindowsMappingMode(int mm);
- // Operators
- bool operator==(const wxMetafile& metafile) const
- { return m_refData == metafile.m_refData; }
- bool operator!=(const wxMetafile& metafile) const
- { return m_refData != metafile.m_refData; }
-
private:
DECLARE_DYNAMIC_CLASS(wxMetafile)
};
virtual bool Ok() const { return IsOk(); }
virtual bool IsOk(void) const { return (m_refData != NULL) ; }
- inline bool operator == (const wxPalette& palette) const { return m_refData == palette.m_refData; }
- inline bool operator != (const wxPalette& palette) const { return m_refData != palette.m_refData; }
-
virtual bool FreeResource(bool force = false);
inline WXHPALETTE GetHPALETTE(void) const { return (M_PALETTEDATA ? M_PALETTEDATA->m_hPalette : 0); }
m_join == data.m_join &&
m_cap == data.m_cap &&
m_colour == data.m_colour &&
- (m_style != wxSTIPPLE || m_stipple == data.m_stipple) &&
+ (m_style != wxSTIPPLE || m_stipple.IsRefTo(&data.m_stipple)) &&
(m_style != wxUSER_DASH ||
(m_nbDash == data.m_nbDash &&
memcmp(m_dash, data.m_dash, m_nbDash*sizeof(wxDash)) == 0));
#define IMPLEMENT_VARIANT_OBJECT(classname) \
IMPLEMENT_VARIANT_OBJECT_EXPORTED(classname,EMPTY_PARAMETER_VALUE)
-#define IMPLEMENT_VARIANT_OBJECT_EXPORTED(classname,expdecl) \
+#define IMPLEMENT_VARIANT_OBJECT_EXPORTED_NO_EQ(classname,expdecl) \
class classname##VariantData: public wxVariantData \
{ \
public:\
\
IMPLEMENT_CLASS(classname##VariantData, wxVariantData)\
\
-bool classname##VariantData::Eq(wxVariantData& data) const \
-{\
- wxASSERT( wxIsKindOf((&data), classname##VariantData) );\
-\
- classname##VariantData & otherData = (classname##VariantData &) data;\
-\
- return (otherData.m_value == m_value);\
-}\
-\
wxString classname##VariantData::GetType() const\
{\
return m_value.GetClassInfo()->GetClassName();\
return variant;\
}
+// implements a wxVariantData-derived class using for the Eq() method the operator==
+// which must have been provided by "classname"
+#define IMPLEMENT_VARIANT_OBJECT_EXPORTED(classname,expdecl) \
+IMPLEMENT_VARIANT_OBJECT_EXPORTED_NO_EQ(classname,expdecl) \
+\
+bool classname##VariantData::Eq(wxVariantData& data) const \
+{\
+ wxASSERT( wxIsKindOf((&data), classname##VariantData) );\
+\
+ classname##VariantData & otherData = (classname##VariantData &) data;\
+\
+ return otherData.m_value == m_value;\
+}\
+
+
+// implements a wxVariantData-derived class using for the Eq() method a shallow
+// comparison (through wxObject::IsRefTo function)
+#define IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(classname,expdecl) \
+IMPLEMENT_VARIANT_OBJECT_EXPORTED_NO_EQ(classname,expdecl) \
+\
+bool classname##VariantData::Eq(wxVariantData& data) const \
+{\
+ wxASSERT( wxIsKindOf((&data), classname##VariantData) );\
+\
+ classname##VariantData & otherData = (classname##VariantData &) data;\
+\
+ return (otherData.m_value.IsRefTo(&m_value));\
+}\
+
+
// Since we want type safety wxVariant we need to fetch and dynamic_cast
// in a seemingly safe way so the compiler can check, so we define
// a dynamic_cast /wxDynamicCast analogue.
wxBitmap( const wxString &filename, wxBitmapType type = wxBITMAP_TYPE_XPM );
virtual ~wxBitmap();
- bool operator == ( const wxBitmap& bmp ) const;
- bool operator != ( const wxBitmap& bmp ) const;
bool Ok() const { return IsOk(); }
bool IsOk() const;
int hotSpotX=-1, int hotSpotY=-1,
const char maskBits[]=0, wxColour *fg=0, wxColour *bg=0 );
virtual ~wxCursor();
- bool operator == ( const wxCursor& cursor ) const;
- bool operator != ( const wxCursor& cursor ) const;
bool Ok() const { return IsOk(); }
bool IsOk() const;
virtual bool Ok() const { return IsOk(); }
virtual bool IsOk() const { return (m_refData != NULL) ; }
- bool operator == (const wxPalette& palette) const { return m_refData == palette.m_refData; }
- bool operator != (const wxPalette& palette) const { return m_refData != palette.m_refData; }
-
// X-specific
WXColormap GetXColormap(WXDisplay* display = NULL) const;
bool TransferBitmap(void *data, int depth, int size);
// ----------------------------------------------------------------------------
#if wxUSE_VARIANT
-IMPLEMENT_VARIANT_OBJECT_EXPORTED(wxBitmap,WXDLLEXPORT)
-IMPLEMENT_VARIANT_OBJECT_EXPORTED(wxIcon,WXDLLEXPORT)
+IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(wxBitmap,WXDLLEXPORT)
+IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(wxIcon,WXDLLEXPORT)
#endif
// ----------------------------------------------------------------------------
#endif // HAS_FILE_STREAMS
#if wxUSE_VARIANT
-IMPLEMENT_VARIANT_OBJECT_EXPORTED(wxImage,WXDLLEXPORT)
+IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(wxImage,WXDLLEXPORT)
#endif
//-----------------------------------------------------------------------------
{
// setting an invalid cursor is ok, it means that we don't have any special
// cursor
- if ( m_cursor == cursor )
+ if ( m_cursor.IsRefTo(&cursor) )
{
// no change
return false;
return (m_refData != NULL && M_BITMAP->m_surface);
}
-bool wxBitmap::operator==(const wxBitmap& bmp) const
-{
- // FIXME: is this the right way to compare bitmaps?
- return (m_refData == bmp.m_refData);
-}
-
int wxBitmap::GetHeight() const
{
wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
{
wxCHECK_RET( Ok(), wxT("invalid bitmap") );
+ AllocExclusive();
delete M_BITMAP->m_mask;
M_BITMAP->m_mask = mask;
}
wxCHECK_RET( Ok(), wxT("invalid bitmap") );
wxCHECK_RET( GetDepth() > 1 && GetDepth() <= 8, wxT("cannot set palette for bitmap of this depth") );
+ AllocExclusive();
delete M_BITMAP->m_palette;
M_BITMAP->m_palette = NULL;
return m_refData && M_CURSOR->m_bitmap.Ok();
}
-bool wxCursor::operator==(const wxCursor& cursor) const
-{
- if ( Ok() )
- {
- if ( !cursor.Ok() )
- return false;
- else if ( M_CURSOR->m_id != M_CURSOR_OF(cursor)->m_id )
- return false;
- else if ( M_CURSOR->m_id == -1 ) // non-stock cursor
- return (m_refData == cursor.m_refData);
- else
- return true; // IDs != -1 and are the same
- }
- else
- {
- return !cursor.Ok();
- }
-}
-
wxObjectRefData *wxCursor::CreateRefData() const
{
return new wxCursorRefData;
{
}
-bool wxPalette::operator == (const wxPalette& palette) const
-{
- return m_refData == palette.m_refData;
-}
-
-bool wxPalette::operator != (const wxPalette& palette) const
-{
- return m_refData != palette.m_refData;
-}
-
bool wxPalette::IsOk() const
{
return (m_refData != NULL);
if ( !bmpPrev.Ok() )
bmpPrev = m_bitmap;
- if ( bmp != bmpPrev )
+ if ( !bmp.IsRefTo(&bmpPrev) )
m_statbmp->SetBitmap(bmp);
}
#endif // wxUSE_STATBMP
PostCreation(size);
SetBestSize(size);
- if (anim != wxNullAnimation)
+ if (anim.IsOk())
SetAnimation(anim);
// init the timer used for animation
return image;
}
-bool wxBitmap::operator == ( const wxBitmap& bmp ) const
-{
- return m_refData == bmp.m_refData;
-}
-
bool wxBitmap::IsOk() const
{
return (m_refData != NULL) &&
bool operator == (const wxBrushRefData& data) const
{
return (m_style == data.m_style &&
- m_stipple == data.m_stipple &&
+ m_stipple.IsRefTo(&data.m_stipple) &&
m_colour == data.m_colour);
}
{
}
-bool wxCursor::operator == ( const wxCursor& cursor ) const
-{
- return m_refData == cursor.m_refData;
-}
-
-bool wxCursor::operator != ( const wxCursor& cursor ) const
-{
- return m_refData != cursor.m_refData;
-}
-
bool wxCursor::IsOk() const
{
return (m_refData != NULL);
// wxRegionIterator
// ----------------------------------------------------------------------------
-class wxRIRefData: public wxObjectRefData
+wxRegionIterator::wxRegionIterator()
{
-public:
- wxRIRefData() { Init(); }
- virtual ~wxRIRefData();
-
- void CreateRects( const wxRegion& r );
-
- void Init() { m_rects = NULL; m_numRects = 0; }
+ Init();
+ Reset();
+}
- wxRect *m_rects;
- size_t m_numRects;
-};
+wxRegionIterator::wxRegionIterator( const wxRegion& region )
+{
+ Init();
+ Reset(region);
+}
-wxRIRefData::~wxRIRefData()
+void wxRegionIterator::Init()
{
- delete [] m_rects;
+ m_rects = NULL;
+ m_numRects = 0;
}
-void wxRIRefData::CreateRects( const wxRegion& region )
+wxRegionIterator::~wxRegionIterator()
{
- delete [] m_rects;
+ wxDELETEA(m_rects);
+}
- Init();
+void wxRegionIterator::CreateRects( const wxRegion& region )
+{
+ wxDELETEA(m_rects);
+ m_numRects = 0;
GdkRegion *gdkregion = region.GetRegion();
if (!gdkregion)
g_free( gdkrects );
}
-wxRegionIterator::wxRegionIterator()
-{
- m_refData = new wxRIRefData();
- Reset();
-}
-
-wxRegionIterator::wxRegionIterator( const wxRegion& region )
-{
- m_refData = new wxRIRefData();
- Reset(region);
-}
-
void wxRegionIterator::Reset( const wxRegion& region )
{
m_region = region;
- ((wxRIRefData*)m_refData)->CreateRects(region);
+ CreateRects(region);
Reset();
}
bool wxRegionIterator::HaveRects() const
{
- return m_current < ((wxRIRefData*)m_refData)->m_numRects;
+ return m_current < m_numRects;
}
wxRegionIterator& wxRegionIterator::operator ++ ()
wxRegionIterator wxRegionIterator::operator ++ (int)
{
wxRegionIterator tmp = *this;
+
if (HaveRects())
++m_current;
{
wxCHECK_MSG( HaveRects(), 0, _T("invalid wxRegionIterator") );
- return ((wxRIRefData*)m_refData)->m_rects[m_current].x;
+ return m_rects[m_current].x;
}
wxCoord wxRegionIterator::GetY() const
{
wxCHECK_MSG( HaveRects(), 0, _T("invalid wxRegionIterator") );
- return ((wxRIRefData*)m_refData)->m_rects[m_current].y;
+ return m_rects[m_current].y;
}
wxCoord wxRegionIterator::GetW() const
{
wxCHECK_MSG( HaveRects(), 0, _T("invalid wxRegionIterator") );
- return ((wxRIRefData*)m_refData)->m_rects[m_current].width;
+ return m_rects[m_current].width;
}
wxCoord wxRegionIterator::GetH() const
{
wxCHECK_MSG( HaveRects(), 0, _T("invalid wxRegionIterator") );
- return ((wxRIRefData*)m_refData)->m_rects[m_current].height;
+ return m_rects[m_current].height;
}
wxRect wxRegionIterator::GetRect() const
{
wxRect r;
if( HaveRects() )
- r = ((wxRIRefData*)m_refData)->m_rects[m_current];
+ r = m_rects[m_current];
return r;
}
{
}
-bool wxBitmap::operator == ( const wxBitmap& bmp ) const
-{
- return m_refData == bmp.m_refData;
-}
-
-bool wxBitmap::operator != ( const wxBitmap& bmp ) const
-{
- return m_refData != bmp.m_refData;
-}
-
bool wxBitmap::IsOk() const
{
return (m_refData != NULL) &&
{
wxCHECK_RET( Ok(), wxT("invalid bitmap") );
+ AllocExclusive();
if (M_BMPDATA->m_mask) delete M_BMPDATA->m_mask;
M_BMPDATA->m_mask = mask;
void wxBitmap::SetHeight( int height )
{
- if (!m_refData)
- m_refData = new wxBitmapRefData();
-
+ AllocExclusive();
M_BMPDATA->m_height = height;
}
void wxBitmap::SetWidth( int width )
{
- if (!m_refData)
- m_refData = new wxBitmapRefData();
-
+ AllocExclusive();
M_BMPDATA->m_width = width;
}
void wxBitmap::SetDepth( int depth )
{
- if (!m_refData)
- m_refData = new wxBitmapRefData();
-
+ AllocExclusive();
M_BMPDATA->m_bpp = depth;
}
bool operator == (const wxBrushRefData& data) const
{
return (m_style == data.m_style &&
- m_stipple == data.m_stipple &&
+ m_stipple.IsRefTo(&data.m_stipple) &&
m_colour == data.m_colour);
}
{
}
-bool wxCursor::operator == ( const wxCursor& cursor ) const
-{
- return m_refData == cursor.m_refData;
-}
-
-bool wxCursor::operator != ( const wxCursor& cursor ) const
-{
- return m_refData != cursor.m_refData;
-}
-
bool wxCursor::IsOk() const
{
return (m_refData != NULL);
void wxBitmap::SetWidth(int w)
{
- if (!M_BITMAPDATA)
- m_refData = new wxBitmapRefData;
-
+ AllocExclusive();
M_BITMAPDATA->SetWidth(w);
}
void wxBitmap::SetHeight(int h)
{
- if (!M_BITMAPDATA)
- m_refData = new wxBitmapRefData;
-
+ AllocExclusive();
M_BITMAPDATA->SetHeight(h);
}
void wxBitmap::SetDepth(int d)
{
- if (!M_BITMAPDATA)
- m_refData = new wxBitmapRefData;
-
+ AllocExclusive();
M_BITMAPDATA->SetDepth(d);
}
void wxBitmap::SetOk(bool isOk)
{
- if (!M_BITMAPDATA)
- m_refData = new wxBitmapRefData;
-
+ AllocExclusive();
M_BITMAPDATA->SetOk(isOk);
}
void wxBitmap::SetPalette(const wxPalette& palette)
{
- if (!M_BITMAPDATA)
- m_refData = new wxBitmapRefData;
-
+ AllocExclusive();
M_BITMAPDATA->m_bitmapPalette = palette ;
}
#endif // wxUSE_PALETTE
void wxBitmap::SetMask(wxMask *mask)
{
- if (!M_BITMAPDATA)
- m_refData = new wxBitmapRefData;
-
+ AllocExclusive();
// Remove existing mask if there is one.
delete M_BITMAPDATA->m_bitmapMask;
wxBrushRefData(const wxBrushRefData& data);
virtual ~wxBrushRefData();
+ bool operator == ( const wxBrushRefData& brush ) const
+ {
+ return m_style == brush.m_style &&
+ m_stipple.IsRefTo(&data.m_stipple) &&
+ m_colour == brush.m_colour &&
+ m_macBrushKind == brush.m_macBrushKind &&
+ m_macThemeBrush == brush.m_macThemeBrush &&
+ m_macThemeBackground == brush.m_macThemeBackground &&
+ m_macThemeBackgroundExtent == brush.m_macThemeBackgroundExtent;
+ }
+
+
protected:
wxMacBrushKind m_macBrushKind ;
int m_style;
{
return (M_BRUSHDATA ? M_BRUSHDATA->m_macBrushKind : kwxMacBrushColour);
}
+
+bool wxBrush::operator == ( const wxBrush& brush ) const
+{
+ if (m_refData == brush.m_refData) return true;
+
+ if (!m_refData || !brush.m_refData) return false;
+
+ return ( *(wxBrushRefData*)m_refData == *(wxBrushRefData*)brush.m_refData );
+}
void wxBitmap::SetWidth(int w)
{
- if (!M_BITMAPDATA)
- m_refData = new wxBitmapRefData;
-
+ AllocExclusive();
M_BITMAPDATA->m_width = w;
}
void wxBitmap::SetHeight(int h)
{
- if (!M_BITMAPDATA)
- m_refData = new wxBitmapRefData;
-
+ AllocExclusive();
M_BITMAPDATA->m_height = h;
}
void wxBitmap::SetDepth(int d)
{
- if (!M_BITMAPDATA)
- m_refData = new wxBitmapRefData;
-
+ AllocExclusive();
M_BITMAPDATA->m_depth = d;
}
delete bdc;
}
-bool wxBitmap::operator == (const wxBitmap& bmp) const
-{
- return (m_refData == bmp.m_refData);
-}
-
-bool wxBitmap::operator != (const wxBitmap& bmp) const
-{
- return (m_refData != bmp.m_refData);
-}
-
bool wxBitmap::IsOk() const
{
return (m_refData != NULL && M_BMPDATA->m_bitmap != NULL);
{
wxCHECK_RET( Ok(), wxT("invalid bitmap") );
+ AllocExclusive();
delete M_BMPDATA->m_mask;
M_BMPDATA->m_mask = mask;
}
{
wxCHECK_RET( Ok(), wxT("invalid bitmap") );
+ AllocExclusive();
palette_t *mono = M_BMPDATA->m_bitmap->pal;
wxCHECK_RET( M_BMPDATA->m_bpp == 1, wxT("bitmap is not 1bpp") );
wxCHECK_RET( Ok(), wxT("invalid bitmap") );
wxCHECK_RET( GetDepth() > 1 && GetDepth() <= 8, wxT("cannot set palette for bitmap of this depth") );
+ AllocExclusive();
delete M_BMPDATA->m_palette;
M_BMPDATA->m_palette = NULL;
void wxBitmap::SetHeight(int height)
{
- if (!m_refData) m_refData = new wxBitmapRefData();
+ AllocExclusive();
M_BMPDATA->m_height = height;
}
void wxBitmap::SetWidth(int width)
{
- if (!m_refData) m_refData = new wxBitmapRefData();
+ AllocExclusive();
M_BMPDATA->m_width = width;
}
void wxBitmap::SetDepth(int depth)
{
- if (!m_refData) m_refData = new wxBitmapRefData();
+ AllocExclusive();
M_BMPDATA->m_bpp = depth;
}
wxBrushRefData();
wxBrushRefData(const wxBrushRefData& data);
+ bool operator == (const wxBrushRefData& data) const
+ {
+ return (m_style == data.m_style &&
+ m_stipple.IsRefTo(&data.m_stipple) &&
+ m_colour == data.m_colour);
+ }
+
int m_style;
wxColour m_colour;
wxBitmap m_stipple;
bool wxBrush::operator == (const wxBrush& brush) const
{
- return m_refData == brush.m_refData;
+ if (m_refData == brush.m_refData) return true;
+
+ if (!m_refData || !brush.m_refData) return false;
+
+ return *(wxBrushRefData*)m_refData == *(wxBrushRefData*)brush.m_refData;
}
bool wxBrush::operator != (const wxBrush& brush) const
// wxObject unrefs data
}
-bool wxCursor::operator == (const wxCursor& cursor) const
-{
- return (m_refData == cursor.m_refData);
-}
-
-bool wxCursor::operator != (const wxCursor& cursor) const
-{
- return (m_refData != cursor.m_refData);
-}
-
bool wxCursor::IsOk() const
{
return (m_refData != NULL);
{
}
-bool wxPalette::operator == (const wxPalette& palette) const
-{
- return m_refData == palette.m_refData;
-}
-
-bool wxPalette::operator != (const wxPalette& palette) const
-{
- return m_refData != palette.m_refData;
-}
-
bool wxPalette::IsOk(void) const
{
return (m_refData != NULL);
wxPenRefData();
wxPenRefData(const wxPenRefData& data);
+ bool operator==(const wxPenRefData& data) const
+ {
+ // we intentionally don't compare m_hPen fields here
+ return m_style == data.m_style &&
+ m_width == data.m_width &&
+ m_pixPattern == data.m_pixPattern &&
+ m_capStyle == data.m_capStyle &&
+ m_joinStyle == data.m_joinStyle &&
+ m_colour == data.m_colour &&
+ (m_style != wxSTIPPLE || m_stipple.IsRefTo(&data.m_stipple)) &&
+ (m_style != wxUSER_DASH ||
+ (m_dash == data.m_dash &&
+ memcmp(m_dash, data.m_dash, m_countDashes*sizeof(wxDash)) == 0));
+ }
+
int m_width;
int m_style;
wxColour m_colour;
bool wxPen::operator == (const wxPen& pen) const
{
- return m_refData == pen.m_refData;
+ if (m_refData == pen.m_refData) return true;
+
+ if (!m_refData || !pen.m_refData) return false;
+
+ return ( *(wxPenRefData*)m_refData == *(wxPenRefData*)pen.m_refData );
}
bool wxPen::operator != (const wxPen& pen) const
M_ACCELDATA->m_ok = (M_ACCELDATA->m_hAccel != 0);
}
-bool wxAcceleratorTable::operator==(const wxAcceleratorTable& accel) const
-{
- const wxAcceleratorRefData *
- accelData = (wxAcceleratorRefData *)accel.m_refData;
-
- return m_refData ? (accelData &&
- M_ACCELDATA->m_hAccel == accelData->m_hAccel)
- : !accelData;
-}
-
bool wxAcceleratorTable::IsOk() const
{
return (M_ACCELDATA && (M_ACCELDATA->m_ok));
// don't compare HBRUSHes
return m_style == data.m_style &&
m_colour == data.m_colour &&
- m_stipple == data.m_stipple;
+ m_stipple.IsRefTo(&data.m_stipple);
}
void wxBrushRefData::DoSetStipple(const wxBitmap& stipple)
// other wxCursor functions
// ----------------------------------------------------------------------------
-bool wxCursor::operator==(const wxCursor& cursor) const
-{
- if ( !m_refData )
- return !cursor.m_refData;
-
- return cursor.m_refData &&
- ((wxCursorRefData *)m_refData)->m_hCursor ==
- ((wxCursorRefData *)cursor.m_refData)->m_hCursor;
-}
-
wxGDIImageRefData *wxCursor::CreateData() const
{
return new wxCursorRefData;
// other wxCursor functions
// ----------------------------------------------------------------------------
-bool wxCursor::operator==(const wxCursor& cursor) const
-{
- return false;
-}
-
wxGDIImageRefData *wxCursor::CreateData() const
{
return NULL;
{
}
-bool wxBitmap::operator == ( const wxBitmap& bmp ) const
-{
- return m_refData == bmp.m_refData;
-}
-
-bool wxBitmap::operator != ( const wxBitmap& bmp ) const
-{
- return m_refData != bmp.m_refData;
-}
-
bool wxBitmap::IsOk() const
{
return (m_refData != NULL);
{
wxCHECK_RET( Ok(), wxT("invalid bitmap") );
+ AllocExclusive();
if (M_BMPDATA->m_mask) delete M_BMPDATA->m_mask;
M_BMPDATA->m_mask = mask;
wxCHECK_RET(GetDepth() > 1 && GetDepth() <= 8,
wxT("cannot set palette for bitmap of this depth"));
+ AllocExclusive();
delete M_BMPDATA->m_palette;
M_BMPDATA->m_palette = NULL;
void wxBitmap::SetHeight( int height )
{
- if (!m_refData) m_refData = new wxBitmapRefData();
+ AllocExclusive();
M_BMPDATA->m_height = height;
}
void wxBitmap::SetWidth( int width )
{
- if (!m_refData) m_refData = new wxBitmapRefData();
+ AllocExclusive();
M_BMPDATA->m_width = width;
}
void wxBitmap::SetDepth( int depth )
{
- if (!m_refData) m_refData = new wxBitmapRefData();
+ AllocExclusive();
M_BMPDATA->m_bpp = depth;
}
bool operator == (const wxBrushRefData& data) const
{
return (m_style == data.m_style &&
- m_stipple == data.m_stipple &&
+ m_stipple.IsRefTo(&data.m_stipple) &&
m_colour == data.m_colour);
}
{
}
-bool wxCursor::operator == ( const wxCursor& cursor ) const
-{
- return m_refData == cursor.m_refData;
-}
-
-bool wxCursor::operator != ( const wxCursor& cursor ) const
-{
- return m_refData != cursor.m_refData;
-}
-
bool wxCursor::IsOk() const
{
return (m_refData != NULL);
projects / wxWidgets.git / commitdiff
