Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

reorganized wxBitmap/wxBitmapHandler classes to use wxBitmapType instead of "long" where possible; made them const-correct; introduce wxBITMAP_SCREEN_DEPTH instead of -1 for clearness (specially in the docs); remove wxBitmapHandler empty stubs and rename wxBitmapHandlerBase as wxBitmapHandler

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@52820 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Francesco Montorsi
2008-03-25 20:31:48 +00:00
parent 0685aa9eb6
commit e86f2cc84a
22 changed files with 184 additions and 236 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
include/wx/bitmap.h
View File

@@ -40,6 +40,8 @@ DECLARE_VARIANT_OBJECT_EXPORTED(wxBitmap,WXDLLEXPORT)
// wxMask represents the transparent area of the bitmap // wxMask represents the transparent area of the bitmap
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// TODO: all implementation of wxMask, except the generic one,
// do not derive from wxMaskBase,,, they should
class WXDLLEXPORT wxMaskBase : public wxObject class WXDLLEXPORT wxMaskBase : public wxObject
{ {
public: public:
@@ -78,8 +80,13 @@ protected:
#define wxUSE_BITMAP_BASE 0 #define wxUSE_BITMAP_BASE 0
#endif #endif
// Only used by some ports // a more readable way to tell
// FIXME -- make all ports (but MSW which uses wxGDIImage) use these base classes #define wxBITMAP_SCREEN_DEPTH (-1)
// All ports except wxMSW,wxOS2,wxPalmOS use wxBitmapHandler and wxBitmapBase as base class
// for wxBitmapHandler; wxMSW,wxOS2,wxPalmOS use wxGDIImageHandler as base class
// since it allows some code reuse there.
#if wxUSE_BITMAP_BASE #if wxUSE_BITMAP_BASE
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -87,18 +94,29 @@ protected:
// different formats // different formats
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT wxBitmapHandlerBase : public wxObject class WXDLLEXPORT wxBitmapHandler : public wxObject
{ {
public: public:
wxBitmapHandlerBase() { m_type = wxBITMAP_TYPE_INVALID; } wxBitmapHandler() { m_type = wxBITMAP_TYPE_INVALID; }
virtual ~wxBitmapHandlerBase() { } virtual ~wxBitmapHandler() { }
virtual bool Create(wxBitmap *bitmap, const void* data, long flags, // NOTE: the following functions should be pure virtuals, but they aren't
int width, int height, int depth = 1); // because otherwise almost all ports would have to implement
virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags, // them as "return false"...
int desiredWidth, int desiredHeight);
virtual bool SaveFile(const wxBitmap *bitmap, const wxString& name, virtual bool Create(wxBitmap *WXUNUSED(bitmap), const void* WXUNUSED(data),
int type, const wxPalette *palette = NULL); wxBitmapType WXUNUSED(type), int WXUNUSED(width), int WXUNUSED(height),
int WXUNUSED(depth) = 1)
{ return false; }
virtual bool LoadFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name),
wxBitmapType WXUNUSED(type), int WXUNUSED(desiredWidth),
int WXUNUSED(desiredHeight))
{ return false; }
virtual bool SaveFile(const wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name),
wxBitmapType WXUNUSED(type), const wxPalette *WXUNUSED(palette) = NULL) const
{ return false; }
void SetName(const wxString& name) { m_name = name; } void SetName(const wxString& name) { m_name = name; }
void SetExtension(const wxString& ext) { m_extension = ext; } void SetExtension(const wxString& ext) { m_extension = ext; }
@@ -112,9 +130,14 @@ private:
wxString m_extension; wxString m_extension;
wxBitmapType m_type; wxBitmapType m_type;
DECLARE_ABSTRACT_CLASS(wxBitmapHandlerBase) DECLARE_ABSTRACT_CLASS(wxBitmapHandler)
}; };
// ----------------------------------------------------------------------------
// wxBitmap: class which represents platform-dependent bitmap (unlike wxImage)
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxBitmapBase : public wxGDIObject class WXDLLEXPORT wxBitmapBase : public wxGDIObject
{ {
public: public:
@@ -122,17 +145,18 @@ public:
Derived class must implement these: Derived class must implement these:
wxBitmap(); wxBitmap();
wxBitmap(int width, int height, int depth = -1); wxBitmap(const wxBitmap& bmp);
wxBitmap(const char bits[], int width, int height, int depth = 1); wxBitmap(const char bits[], int width, int height, int depth = 1);
wxBitmap(int width, int height, int depth = wxBITMAP_SCREEN_DEPTH);
wxBitmap(const char* const* bits); wxBitmap(const char* const* bits);
wxBitmap(const wxString &filename, wxBitmapType type = wxBITMAP_TYPE_XPM); wxBitmap(const wxString &filename, wxBitmapType type = wxBITMAP_TYPE_XPM);
wxBitmap(const wxImage& image, int depth = -1); wxBitmap(const wxImage& image, int depth = wxBITMAP_SCREEN_DEPTH);
bool Create(int width, int height, int depth = -1);
static void InitStandardHandlers(); static void InitStandardHandlers();
*/ */
virtual bool Create(int width, int height, int depth = wxBITMAP_SCREEN_DEPTH) = 0;
virtual int GetHeight() const = 0; virtual int GetHeight() const = 0;
virtual int GetWidth() const = 0; virtual int GetWidth() const = 0;
virtual int GetDepth() const = 0; virtual int GetDepth() const = 0;
@@ -173,8 +197,8 @@ public:
// Format handling // Format handling
static inline wxList& GetHandlers() { return sm_handlers; } static inline wxList& GetHandlers() { return sm_handlers; }
static void AddHandler(wxBitmapHandlerBase *handler); static void AddHandler(wxBitmapHandler *handler);
static void InsertHandler(wxBitmapHandlerBase *handler); static void InsertHandler(wxBitmapHandler *handler);
static bool RemoveHandler(const wxString& name); static bool RemoveHandler(const wxString& name);
static wxBitmapHandler *FindHandler(const wxString& name); static wxBitmapHandler *FindHandler(const wxString& name);
static wxBitmapHandler *FindHandler(const wxString& extension, wxBitmapType bitmapType); static wxBitmapHandler *FindHandler(const wxString& extension, wxBitmapType bitmapType);

6
include/wx/cocoa/bitmap.h
View File

@@ -135,7 +135,7 @@ public:
wxMask *GetMask() const; wxMask *GetMask() const;
void SetMask(wxMask *mask) ; void SetMask(wxMask *mask) ;
int GetBitmapType() const; wxBitmapType GetBitmapType() const;
// wxCocoa // wxCocoa
WX_NSBitmapImageRep GetNSBitmapImageRep(); WX_NSBitmapImageRep GetNSBitmapImageRep();
@@ -152,9 +152,5 @@ protected:
DECLARE_DYNAMIC_CLASS(wxBitmap) DECLARE_DYNAMIC_CLASS(wxBitmap)
}; };
class WXDLLIMPEXP_CORE wxBitmapHandler: public wxBitmapHandlerBase
{
DECLARE_ABSTRACT_CLASS(wxBitmapHandler)
};
#endif // __WX_COCOA_BITMAP_H__ #endif // __WX_COCOA_BITMAP_H__

8
include/wx/dfb/bitmap.h
View File

@@ -21,11 +21,6 @@ wxDFB_DECLARE_INTERFACE(IDirectFBSurface);
// wxBitmap // wxBitmap
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBitmapHandler : public wxBitmapHandlerBase
{
DECLARE_ABSTRACT_CLASS(wxBitmapHandler)
};
class WXDLLIMPEXP_CORE wxBitmap : public wxBitmapBase class WXDLLIMPEXP_CORE wxBitmap : public wxBitmapBase
{ {
public: public:
@@ -55,7 +50,8 @@ public:
virtual wxBitmap GetSubBitmap(const wxRect& rect) const; virtual wxBitmap GetSubBitmap(const wxRect& rect) const;
virtual bool SaveFile(const wxString &name, wxBitmapType type, const wxPalette *palette = (wxPalette *) NULL) const; virtual bool SaveFile(const wxString &name, wxBitmapType type,
const wxPalette *palette = (wxPalette *) NULL) const;
virtual bool LoadFile(const wxString &name, wxBitmapType type = wxBITMAP_TYPE_RESOURCE); virtual bool LoadFile(const wxString &name, wxBitmapType type = wxBITMAP_TYPE_RESOURCE);
#if wxUSE_PALETTE #if wxUSE_PALETTE

23
include/wx/gtk/bitmap.h
View File

@@ -51,23 +51,22 @@ class WXDLLIMPEXP_CORE wxBitmap: public wxBitmapBase
{ {
public: public:
wxBitmap() { } wxBitmap() { }
wxBitmap( int width, int height, int depth = -1 ); wxBitmap( int width, int height, int depth = wxBITMAP_SCREEN_DEPTH );
wxBitmap( const char bits[], int width, int height, int depth = 1 ); wxBitmap( const char bits[], int width, int height, int depth = 1 );
wxBitmap( const char* const* bits ); wxBitmap( const char* const* bits );
#ifdef wxNEEDS_CHARPP #ifdef wxNEEDS_CHARPP
// needed for old GCC // needed for old GCC
wxBitmap(char** data) wxBitmap(char** data)
{ { *this = wxBitmap(wx_const_cast(const char* const*, data)); }
*this = wxBitmap(wx_const_cast(const char* const*, data));
}
#endif #endif
wxBitmap( const wxString &filename, wxBitmapType type = wxBITMAP_TYPE_XPM ); wxBitmap( const wxString &filename, wxBitmapType type = wxBITMAP_TYPE_XPM );
#if wxUSE_IMAGE #if wxUSE_IMAGE
wxBitmap( const wxImage& image, int depth = -1 ) { (void)CreateFromImage(image, depth); } wxBitmap( const wxImage& image, int depth = wxBITMAP_SCREEN_DEPTH )
{ (void)CreateFromImage(image, depth); }
#endif // wxUSE_IMAGE #endif // wxUSE_IMAGE
virtual ~wxBitmap(); virtual ~wxBitmap();
bool Create(int width, int height, int depth = -1); bool Create(int width, int height, int depth = wxBITMAP_SCREEN_DEPTH);
virtual int GetHeight() const; virtual int GetHeight() const;
virtual int GetWidth() const; virtual int GetWidth() const;
@@ -112,7 +111,8 @@ public:
GdkPixbuf *GetPixbuf() const; GdkPixbuf *GetPixbuf() const;
// Basically, this corresponds to Win32 StretchBlt() // Basically, this corresponds to Win32 StretchBlt()
wxBitmap Rescale(int clipx, int clipy, int clipwidth, int clipheight, int width, int height) const; wxBitmap Rescale(int clipx, int clipy, int clipwidth, int clipheight,
int width, int height) const;
// raw bitmap access support functions // raw bitmap access support functions
void *GetRawData(wxPixelDataBase& data, int bpp); void *GetRawData(wxPixelDataBase& data, int bpp);
@@ -150,13 +150,4 @@ private:
DECLARE_DYNAMIC_CLASS(wxBitmap) DECLARE_DYNAMIC_CLASS(wxBitmap)
}; };
//-----------------------------------------------------------------------------
// wxBitmapHandler
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBitmapHandler: public wxBitmapHandlerBase
{
DECLARE_ABSTRACT_CLASS(wxBitmapHandler)
};
#endif // _WX_GTK_BITMAP_H_ #endif // _WX_GTK_BITMAP_H_

8
include/wx/gtk1/bitmap.h
View File

@@ -146,13 +146,5 @@ private:
DECLARE_DYNAMIC_CLASS(wxBitmap) DECLARE_DYNAMIC_CLASS(wxBitmap)
}; };
//-----------------------------------------------------------------------------
// wxBitmapHandler
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBitmapHandler: public wxBitmapHandlerBase
{
DECLARE_ABSTRACT_CLASS(wxBitmapHandler)
};
#endif // __GTKBITMAPH__ #endif // __GTKBITMAPH__

5
include/wx/mac/carbon/bitmap.h
View File

@@ -80,11 +80,6 @@ private:
}; };
class WXDLLIMPEXP_CORE wxBitmapHandler: public wxBitmapHandlerBase
{
DECLARE_ABSTRACT_CLASS(wxBitmapHandler)
};
class WXDLLEXPORT wxBitmap: public wxBitmapBase class WXDLLEXPORT wxBitmap: public wxBitmapBase
{ {
DECLARE_DYNAMIC_CLASS(wxBitmap) DECLARE_DYNAMIC_CLASS(wxBitmap)

5
include/wx/mgl/bitmap.h
View File

@@ -23,11 +23,6 @@ struct bitmap_t;
// wxBitmap // wxBitmap
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBitmapHandler: public wxBitmapHandlerBase
{
DECLARE_ABSTRACT_CLASS(wxBitmapHandler)
};
class WXDLLEXPORT wxBitmap: public wxBitmapBase class WXDLLEXPORT wxBitmap: public wxBitmapBase
{ {
public: public:

59
include/wx/msw/bitmap.h
View File

@@ -41,6 +41,7 @@ enum wxBitmapTransparency
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxBitmap: a mono or colour bitmap // wxBitmap: a mono or colour bitmap
// NOTE: for wxMSW we don't use the wxBitmapBase base class declared in bitmap.h!
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT wxBitmap : public wxGDIImage class WXDLLEXPORT wxBitmap : public wxGDIImage
@@ -65,7 +66,7 @@ public:
wxBitmap(const wxString& name, wxBitmapType type = wxBITMAP_TYPE_BMP_RESOURCE); wxBitmap(const wxString& name, wxBitmapType type = wxBITMAP_TYPE_BMP_RESOURCE);
// New constructor for generalised creation from data // New constructor for generalised creation from data
wxBitmap(const void* data, long type, int width, int height, int depth = 1); wxBitmap(const void* data, wxBitmapType type, int width, int height, int depth = 1);
// Create a new, uninitialized bitmap of the given size and depth (if it // Create a new, uninitialized bitmap of the given size and depth (if it
// is omitted, will create a bitmap compatible with the display) // is omitted, will create a bitmap compatible with the display)
@@ -135,11 +136,11 @@ public:
bool CopyFromDIB(const wxDIB& dib); bool CopyFromDIB(const wxDIB& dib);
#endif #endif
virtual bool Create(int width, int height, int depth = -1); virtual bool Create(int width, int height, int depth = wxBITMAP_SCREEN_DEPTH);
virtual bool Create(int width, int height, const wxDC& dc); virtual bool Create(int width, int height, const wxDC& dc);
virtual bool Create(const void* data, long type, int width, int height, int depth = 1); virtual bool Create(const void* data, wxBitmapType type, int width, int height, int depth = 1);
virtual bool LoadFile(const wxString& name, long type = wxBITMAP_TYPE_BMP_RESOURCE); virtual bool LoadFile(const wxString& name, wxBitmapType type = wxBITMAP_TYPE_BMP_RESOURCE);
virtual bool SaveFile(const wxString& name, int type, const wxPalette *cmap = NULL); virtual bool SaveFile(const wxString& name, wxBitmapType type, const wxPalette *cmap = NULL) const;
wxBitmapRefData *GetBitmapData() const wxBitmapRefData *GetBitmapData() const
{ return (wxBitmapRefData *)m_refData; } { return (wxBitmapRefData *)m_refData; }
@@ -244,45 +245,49 @@ protected:
DECLARE_DYNAMIC_CLASS(wxMask) DECLARE_DYNAMIC_CLASS(wxMask)
}; };
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxBitmapHandler is a class which knows how to load/save bitmaps to/from file // wxBitmapHandler is a class which knows how to load/save bitmaps to/from file
// NOTE: for wxMSW we don't use the wxBitmapHandler class declared in bitmap.h!
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT wxBitmapHandler : public wxGDIImageHandler class WXDLLEXPORT wxBitmapHandler : public wxGDIImageHandler
{ {
public: public:
wxBitmapHandler() { } wxBitmapHandler() { }
wxBitmapHandler(const wxString& name, const wxString& ext, long type) wxBitmapHandler(const wxString& name, const wxString& ext, wxBitmapType type)
: wxGDIImageHandler(name, ext, type) : wxGDIImageHandler(name, ext, type) { }
{
}
// keep wxBitmapHandler derived from wxGDIImageHandler compatible with the // implement wxGDIImageHandler's pure virtuals:
// old class which worked only with bitmaps
virtual bool Create(wxBitmap *bitmap,
const void* data,
long flags,
int width, int height, int depth = 1);
virtual bool LoadFile(wxBitmap *bitmap,
const wxString& name,
long flags,
int desiredWidth, int desiredHeight);
virtual bool SaveFile(wxBitmap *bitmap,
const wxString& name,
int type,
const wxPalette *palette = NULL);
virtual bool Create(wxGDIImage *image, virtual bool Create(wxGDIImage *image,
const void* data, const void* data,
long flags, wxBitmapType type,
int width, int height, int depth = 1); int width, int height, int depth = 1);
virtual bool Load(wxGDIImage *image, virtual bool Load(wxGDIImage *image,
const wxString& name, const wxString& name,
long flags, wxBitmapType type,
int desiredWidth, int desiredHeight); int desiredWidth, int desiredHeight);
virtual bool Save(wxGDIImage *image, virtual bool Save(const wxGDIImage *image,
const wxString& name, const wxString& name,
int type); wxBitmapType type) const;
// make wxBitmapHandler compatible with the wxBitmapHandler interface
// declared in bitmap.h, even if it's derived from wxGDIImageHandler:
virtual bool Create(wxBitmap *bitmap,
const void* data,
wxBitmapType type,
int width, int height, int depth = 1);
virtual bool LoadFile(wxBitmap *bitmap,
const wxString& name,
wxBitmapType type,
int desiredWidth, int desiredHeight);
virtual bool SaveFile(const wxBitmap *bitmap,
const wxString& name,
wxBitmapType type,
const wxPalette *palette = NULL) const;
private: private:
DECLARE_DYNAMIC_CLASS(wxBitmapHandler) DECLARE_DYNAMIC_CLASS(wxBitmapHandler)

87
include/wx/msw/gdiimage.h
View File

@@ -76,51 +76,6 @@ public:
}; };
}; };
// ----------------------------------------------------------------------------
// wxGDIImageHandler: a class which knows how to load/save wxGDIImages.
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxGDIImageHandler : public wxObject
{
public:
// ctor
wxGDIImageHandler() { m_type = wxBITMAP_TYPE_INVALID; }
wxGDIImageHandler(const wxString& name,
const wxString& ext,
long type)
: m_name(name), m_extension(ext)
{
m_type = type;
}
// accessors
void SetName(const wxString& name) { m_name = name; }
void SetExtension(const wxString& ext) { m_extension = ext; }
void SetType(long type) { m_type = type; }
const wxString& GetName() const { return m_name; }
const wxString& GetExtension() const { return m_extension; }
long GetType() const { return m_type; }
// real handler operations: to implement in derived classes
virtual bool Create(wxGDIImage *image,
const void* data,
long flags,
int width, int height, int depth = 1) = 0;
virtual bool Load(wxGDIImage *image,
const wxString& name,
long flags,
int desiredWidth, int desiredHeight) = 0;
virtual bool Save(wxGDIImage *image,
const wxString& name,
int type) = 0;
protected:
wxString m_name;
wxString m_extension;
long m_type;
};
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxGDIImage: this class supports GDI image handlers which may be registered // wxGDIImage: this class supports GDI image handlers which may be registered
// dynamically and will be used for loading/saving the images in the specified // dynamically and will be used for loading/saving the images in the specified
@@ -192,4 +147,46 @@ protected:
static wxGDIImageHandlerList ms_handlers; static wxGDIImageHandlerList ms_handlers;
}; };
// ----------------------------------------------------------------------------
// wxGDIImageHandler: a class which knows how to load/save wxGDIImages.
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxGDIImageHandler : public wxObject
{
public:
// ctor
wxGDIImageHandler() { m_type = wxBITMAP_TYPE_INVALID; }
wxGDIImageHandler(const wxString& name,
const wxString& ext,
wxBitmapType type)
: m_name(name), m_extension(ext), m_type(type) { }
// accessors
void SetName(const wxString& name) { m_name = name; }
void SetExtension(const wxString& ext) { m_extension = ext; }
void SetType(wxBitmapType type) { m_type = type; }
const wxString& GetName() const { return m_name; }
const wxString& GetExtension() const { return m_extension; }
wxBitmapType GetType() const { return m_type; }
// real handler operations: to implement in derived classes
virtual bool Create(wxGDIImage *image,
const void* data,
wxBitmapType flags,
int width, int height, int depth = 1) = 0;
virtual bool Load(wxGDIImage *image,
const wxString& name,
wxBitmapType flags,
int desiredWidth, int desiredHeight) = 0;
virtual bool Save(const wxGDIImage *image,
const wxString& name,
wxBitmapType type) const = 0;
protected:
wxString m_name;
wxString m_extension;
wxBitmapType m_type;
};
#endif // _WX_MSW_GDIIMAGE_H_ #endif // _WX_MSW_GDIIMAGE_H_

4
include/wx/msw/icon.h
View File

@@ -54,7 +54,7 @@ public:
#endif #endif
// from resource/file // from resource/file
wxIcon(const wxString& name, wxIcon(const wxString& name,
long type = wxBITMAP_TYPE_ICO_RESOURCE, wxBitmapType type = wxBITMAP_TYPE_ICO_RESOURCE,
int desiredWidth = -1, int desiredHeight = -1); int desiredWidth = -1, int desiredHeight = -1);
wxIcon(const wxIconLocation& loc); wxIcon(const wxIconLocation& loc);
@@ -62,7 +62,7 @@ public:
virtual ~wxIcon(); virtual ~wxIcon();
virtual bool LoadFile(const wxString& name, virtual bool LoadFile(const wxString& name,
long type = wxBITMAP_TYPE_ICO_RESOURCE, wxBitmapType type = wxBITMAP_TYPE_ICO_RESOURCE,
int desiredWidth = -1, int desiredHeight = -1); int desiredWidth = -1, int desiredHeight = -1);
// implementation only from now on // implementation only from now on

14
include/wx/os2/bitmap.h
View File

@@ -287,7 +287,7 @@ public:
inline wxBitmapHandler( const wxString& rName inline wxBitmapHandler( const wxString& rName
,const wxString& rExt ,const wxString& rExt
,long lType ,wxBitmapType lType
) )
: wxGDIImageHandler( rName : wxGDIImageHandler( rName
,rExt ,rExt
@@ -299,28 +299,28 @@ public:
// old class which worked only with bitmaps // old class which worked only with bitmaps
virtual bool Create( wxBitmap* pBitmap virtual bool Create( wxBitmap* pBitmap
,const void* pData ,const void* pData
,long lFlags ,wxBitmapType lType
,int nWidth ,int nWidth
,int nHeight ,int nHeight
,int nDepth = 1 ,int nDepth = 1
); );
virtual bool LoadFile( wxBitmap* pBitmap virtual bool LoadFile( wxBitmap* pBitmap
,int nId ,int nId
,long lFlags ,wxBitmapType lType
,int nDesiredWidth ,int nDesiredWidth
,int nDesiredHeight ,int nDesiredHeight
); );
virtual bool LoadFile( wxBitmap* pBitmap virtual bool LoadFile( wxBitmap* pBitmap
,const wxString& rName ,const wxString& rName
,long lFlags ,wxBitmapType lType
,int nDesiredWidth ,int nDesiredWidth
,int nDesiredHeight ,int nDesiredHeight
); );
virtual bool SaveFile( wxBitmap* pBitmap virtual bool SaveFile( wxBitmap* pBitmap
,const wxString& rName ,const wxString& rName
,int lType ,wxBitmapType lType
,const wxPalette* pPalette = NULL ,const wxPalette* pPalette = NULL
); ) const;
virtual bool Create( wxGDIImage* pImage virtual bool Create( wxGDIImage* pImage
,const void* pData ,const void* pData
@@ -338,7 +338,7 @@ public:
virtual bool Save( wxGDIImage* pImage virtual bool Save( wxGDIImage* pImage
,const wxString& rName ,const wxString& rName
,int lType ,int lType
); ) const;
private: private:
inline virtual bool Load( wxGDIImage* WXUNUSED(pImage) inline virtual bool Load( wxGDIImage* WXUNUSED(pImage)
,const wxString& WXUNUSED(rName) ,const wxString& WXUNUSED(rName)

5
include/wx/x11/bitmap.h
View File

@@ -62,11 +62,6 @@ private:
// wxBitmap // wxBitmap
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBitmapHandler: public wxBitmapHandlerBase
{
DECLARE_ABSTRACT_CLASS(wxBitmapHandler)
};
class WXDLLIMPEXP_CORE wxBitmap: public wxBitmapBase class WXDLLIMPEXP_CORE wxBitmap: public wxBitmapBase
{ {
public: public:

17
src/common/bmpbase.cpp
View File

@@ -47,7 +47,7 @@ IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(wxIcon,WXDLLEXPORT)
IMPLEMENT_ABSTRACT_CLASS(wxBitmapBase, wxGDIObject) IMPLEMENT_ABSTRACT_CLASS(wxBitmapBase, wxGDIObject)
IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandlerBase,wxObject) IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxObject)
wxList wxBitmapBase::sm_handlers; wxList wxBitmapBase::sm_handlers;
@@ -126,21 +126,6 @@ void wxBitmapBase::CleanUpHandlers()
} }
} }
bool wxBitmapHandlerBase::Create(wxBitmap*, const void*, long, int, int, int)
{
return false;
}
bool wxBitmapHandlerBase::LoadFile(wxBitmap*, const wxString&, long, int, int)
{
return false;
}
bool wxBitmapHandlerBase::SaveFile(const wxBitmap*, const wxString&, int, const wxPalette*)
{
return false;
}
class wxBitmapBaseModule: public wxModule class wxBitmapBaseModule: public wxModule
{ {
DECLARE_DYNAMIC_CLASS(wxBitmapBaseModule) DECLARE_DYNAMIC_CLASS(wxBitmapBaseModule)

6
src/gtk/bitmap.cpp
View File

@@ -968,12 +968,6 @@ wxGDIRefData* wxBitmap::CloneGDIRefData(const wxGDIRefData* data) const
return newRef; return newRef;
} }
//-----------------------------------------------------------------------------
// wxBitmapHandler
//-----------------------------------------------------------------------------
IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)
/* static */ void wxBitmap::InitStandardHandlers() /* static */ void wxBitmap::InitStandardHandlers()
{ {
// TODO: Insert handler based on GdkPixbufs handler later // TODO: Insert handler based on GdkPixbufs handler later

6
src/gtk1/bitmap.cpp
View File

@@ -1373,12 +1373,6 @@ bool wxBitmap::HasAlpha() const
return false; return false;
} }
//-----------------------------------------------------------------------------
// wxBitmapHandler
//-----------------------------------------------------------------------------
IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)
/* static */ void wxBitmap::InitStandardHandlers() /* static */ void wxBitmap::InitStandardHandlers()
{ {
// TODO: Insert handler based on GdkPixbufs handler later // TODO: Insert handler based on GdkPixbufs handler later

6
src/mac/carbon/bitmap.cpp
View File

@@ -1615,12 +1615,6 @@ WXHBITMAP wxMask::GetHBITMAP() const
return m_maskBitmap ; return m_maskBitmap ;
} }
// ----------------------------------------------------------------------------
// wxBitmapHandler
// ----------------------------------------------------------------------------
IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Standard Handlers // Standard Handlers
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

2
src/mgl/bitmap.cpp
View File

@@ -92,8 +92,6 @@ wxBitmapRefData::~wxBitmapRefData()
#define M_BMPDATA ((wxBitmapRefData *)m_refData) #define M_BMPDATA ((wxBitmapRefData *)m_refData)
IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)
IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxBitmapBase) IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxBitmapBase)
wxBitmap::wxBitmap(int width, int height, int depth) wxBitmap::wxBitmap(int width, int height, int depth)

34
src/msw/bitmap.cpp
View File

@@ -520,14 +520,14 @@ wxBitmap::wxBitmap(int w, int h, const wxDC& dc)
(void)Create(w, h, dc); (void)Create(w, h, dc);
} }
wxBitmap::wxBitmap(const void* data, long type, int width, int height, int depth) wxBitmap::wxBitmap(const void* data, wxBitmapType type, int width, int height, int depth)
{ {
(void)Create(data, type, width, height, depth); (void)Create(data, type, width, height, depth);
} }
wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type) wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type)
{ {
LoadFile(filename, (int)type); LoadFile(filename, type);
} }
bool wxBitmap::Create(int width, int height, int depth) bool wxBitmap::Create(int width, int height, int depth)
@@ -1027,7 +1027,7 @@ wxImage wxBitmap::ConvertToImage() const
// loading and saving bitmaps // loading and saving bitmaps
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
bool wxBitmap::LoadFile(const wxString& filename, long type) bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type)
{ {
UnRef(); UnRef();
@@ -1055,7 +1055,7 @@ bool wxBitmap::LoadFile(const wxString& filename, long type)
return false; return false;
} }
bool wxBitmap::Create(const void* data, long type, int width, int height, int depth) bool wxBitmap::Create(const void* data, wxBitmapType type, int width, int height, int depth)
{ {
UnRef(); UnRef();
@@ -1074,8 +1074,8 @@ bool wxBitmap::Create(const void* data, long type, int width, int height, int de
} }
bool wxBitmap::SaveFile(const wxString& filename, bool wxBitmap::SaveFile(const wxString& filename,
int type, wxBitmapType type,
const wxPalette *palette) const wxPalette *palette) const
{ {
wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler); wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
@@ -1563,27 +1563,27 @@ bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
bool wxBitmapHandler::Create(wxGDIImage *image, bool wxBitmapHandler::Create(wxGDIImage *image,
const void* data, const void* data,
long flags, wxBitmapType type,
int width, int height, int depth) int width, int height, int depth)
{ {
wxBitmap *bitmap = wxDynamicCast(image, wxBitmap); wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
return bitmap && Create(bitmap, data, flags, width, height, depth); return bitmap && Create(bitmap, data, type, width, height, depth);
} }
bool wxBitmapHandler::Load(wxGDIImage *image, bool wxBitmapHandler::Load(wxGDIImage *image,
const wxString& name, const wxString& name,
long flags, wxBitmapType type,
int width, int height) int width, int height)
{ {
wxBitmap *bitmap = wxDynamicCast(image, wxBitmap); wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
return bitmap && LoadFile(bitmap, name, flags, width, height); return bitmap && LoadFile(bitmap, name, type, width, height);
} }
bool wxBitmapHandler::Save(wxGDIImage *image, bool wxBitmapHandler::Save(const wxGDIImage *image,
const wxString& name, const wxString& name,
int type) wxBitmapType type) const
{ {
wxBitmap *bitmap = wxDynamicCast(image, wxBitmap); wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
@@ -1592,7 +1592,7 @@ bool wxBitmapHandler::Save(wxGDIImage *image,
bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap), bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap),
const void* WXUNUSED(data), const void* WXUNUSED(data),
long WXUNUSED(type), wxBitmapType WXUNUSED(type),
int WXUNUSED(width), int WXUNUSED(width),
int WXUNUSED(height), int WXUNUSED(height),
int WXUNUSED(depth)) int WXUNUSED(depth))
@@ -1602,17 +1602,17 @@ bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap),
bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap), bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap),
const wxString& WXUNUSED(name), const wxString& WXUNUSED(name),
long WXUNUSED(type), wxBitmapType WXUNUSED(type),
int WXUNUSED(desiredWidth), int WXUNUSED(desiredWidth),
int WXUNUSED(desiredHeight)) int WXUNUSED(desiredHeight))
{ {
return false; return false;
} }
bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap), bool wxBitmapHandler::SaveFile(const wxBitmap *WXUNUSED(bitmap),
const wxString& WXUNUSED(name), const wxString& WXUNUSED(name),
int WXUNUSED(type), wxBitmapType WXUNUSED(type),
const wxPalette *WXUNUSED(palette)) const wxPalette *WXUNUSED(palette)) const
{ {
return false; return false;
} }

40
src/msw/gdiimage.cpp
View File

@@ -67,11 +67,11 @@ public:
} }
virtual bool LoadFile(wxBitmap *bitmap, virtual bool LoadFile(wxBitmap *bitmap,
const wxString& name, long flags, const wxString& name, wxBitmapType flags,
int desiredWidth, int desiredHeight); int desiredWidth, int desiredHeight);
virtual bool SaveFile(wxBitmap *bitmap, virtual bool SaveFile(const wxBitmap *bitmap,
const wxString& name, int type, const wxString& name, wxBitmapType type,
const wxPalette *palette = NULL); const wxPalette *palette = NULL) const;
private: private:
DECLARE_DYNAMIC_CLASS(wxBMPFileHandler) DECLARE_DYNAMIC_CLASS(wxBMPFileHandler)
@@ -87,7 +87,7 @@ public:
} }
virtual bool LoadFile(wxBitmap *bitmap, virtual bool LoadFile(wxBitmap *bitmap,
const wxString& name, long flags, const wxString& name, wxBitmapType flags,
int desiredWidth, int desiredHeight); int desiredWidth, int desiredHeight);
private: private:
@@ -97,7 +97,7 @@ private:
class WXDLLEXPORT wxIconHandler : public wxGDIImageHandler class WXDLLEXPORT wxIconHandler : public wxGDIImageHandler
{ {
public: public:
wxIconHandler(const wxString& name, const wxString& ext, long type) wxIconHandler(const wxString& name, const wxString& ext, wxBitmapType type)
: wxGDIImageHandler(name, ext, type) : wxGDIImageHandler(name, ext, type)
{ {
} }
@@ -105,7 +105,7 @@ public:
// creating and saving icons is not supported // creating and saving icons is not supported
virtual bool Create(wxGDIImage *WXUNUSED(image), virtual bool Create(wxGDIImage *WXUNUSED(image),
const void* WXUNUSED(data), const void* WXUNUSED(data),
long WXUNUSED(flags), wxBitmapType WXUNUSED(flags),
int WXUNUSED(width), int WXUNUSED(width),
int WXUNUSED(height), int WXUNUSED(height),
int WXUNUSED(depth) = 1) int WXUNUSED(depth) = 1)
@@ -113,16 +113,16 @@ public:
return false; return false;
} }
virtual bool Save(wxGDIImage *WXUNUSED(image), virtual bool Save(const wxGDIImage *WXUNUSED(image),
const wxString& WXUNUSED(name), const wxString& WXUNUSED(name),
int WXUNUSED(type)) wxBitmapType WXUNUSED(type)) const
{ {
return false; return false;
} }
virtual bool Load(wxGDIImage *image, virtual bool Load(wxGDIImage *image,
const wxString& name, const wxString& name,
long flags, wxBitmapType flags,
int desiredWidth, int desiredHeight) int desiredWidth, int desiredHeight)
{ {
wxIcon *icon = wxDynamicCast(image, wxIcon); wxIcon *icon = wxDynamicCast(image, wxIcon);
@@ -133,7 +133,7 @@ public:
protected: protected:
virtual bool LoadIcon(wxIcon *icon, virtual bool LoadIcon(wxIcon *icon,
const wxString& name, long flags, const wxString& name, wxBitmapType flags,
int desiredWidth = -1, int desiredHeight = -1) = 0; int desiredWidth = -1, int desiredHeight = -1) = 0;
}; };
@@ -148,7 +148,7 @@ public:
protected: protected:
virtual bool LoadIcon(wxIcon *icon, virtual bool LoadIcon(wxIcon *icon,
const wxString& name, long flags, const wxString& name, wxBitmapType flags,
int desiredWidth = -1, int desiredHeight = -1); int desiredWidth = -1, int desiredHeight = -1);
private: private:
@@ -166,7 +166,7 @@ public:
protected: protected:
virtual bool LoadIcon(wxIcon *icon, virtual bool LoadIcon(wxIcon *icon,
const wxString& name, long flags, const wxString& name, wxBitmapType flags,
int desiredWidth = -1, int desiredHeight = -1); int desiredWidth = -1, int desiredHeight = -1);
private: private:
@@ -318,7 +318,7 @@ void wxGDIImage::InitStandardHandlers()
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
bool wxBMPResourceHandler::LoadFile(wxBitmap *bitmap, bool wxBMPResourceHandler::LoadFile(wxBitmap *bitmap,
const wxString& name, long WXUNUSED(flags), const wxString& name, wxBitmapType WXUNUSED(flags),
int WXUNUSED(desiredWidth), int WXUNUSED(desiredWidth),
int WXUNUSED(desiredHeight)) int WXUNUSED(desiredHeight))
{ {
@@ -351,7 +351,7 @@ bool wxBMPResourceHandler::LoadFile(wxBitmap *bitmap,
} }
bool wxBMPFileHandler::LoadFile(wxBitmap *bitmap, bool wxBMPFileHandler::LoadFile(wxBitmap *bitmap,
const wxString& name, long WXUNUSED(flags), const wxString& name, wxBitmapType WXUNUSED(flags),
int WXUNUSED(desiredWidth), int WXUNUSED(desiredWidth),
int WXUNUSED(desiredHeight)) int WXUNUSED(desiredHeight))
{ {
@@ -366,10 +366,10 @@ bool wxBMPFileHandler::LoadFile(wxBitmap *bitmap,
#endif #endif
} }
bool wxBMPFileHandler::SaveFile(wxBitmap *bitmap, bool wxBMPFileHandler::SaveFile(const wxBitmap *bitmap,
const wxString& name, const wxString& name,
int WXUNUSED(type), wxBitmapType WXUNUSED(type),
const wxPalette * WXUNUSED(pal)) const wxPalette * WXUNUSED(pal)) const
{ {
#if wxUSE_WXDIB #if wxUSE_WXDIB
wxCHECK_MSG( bitmap, false, _T("NULL bitmap in SaveFile") ); wxCHECK_MSG( bitmap, false, _T("NULL bitmap in SaveFile") );
@@ -388,7 +388,7 @@ bool wxBMPFileHandler::SaveFile(wxBitmap *bitmap,
bool wxICOFileHandler::LoadIcon(wxIcon *icon, bool wxICOFileHandler::LoadIcon(wxIcon *icon,
const wxString& name, const wxString& name,
long WXUNUSED(flags), wxBitmapType WXUNUSED(flags),
int desiredWidth, int desiredHeight) int desiredWidth, int desiredHeight)
{ {
icon->UnRef(); icon->UnRef();
@@ -499,7 +499,7 @@ bool wxICOFileHandler::LoadIcon(wxIcon *icon,
bool wxICOResourceHandler::LoadIcon(wxIcon *icon, bool wxICOResourceHandler::LoadIcon(wxIcon *icon,
const wxString& name, const wxString& name,
long WXUNUSED(flags), wxBitmapType WXUNUSED(flags),
int desiredWidth, int desiredHeight) int desiredWidth, int desiredHeight)
{ {
HICON hicon; HICON hicon;

6
src/msw/icon.cpp
View File

@@ -72,12 +72,12 @@ wxIcon::wxIcon(const char bits[], int width, int height)
} }
wxIcon::wxIcon(const wxString& iconfile, wxIcon::wxIcon(const wxString& iconfile,
long flags, wxBitmapType type,
int desiredWidth, int desiredWidth,
int desiredHeight) int desiredHeight)
{ {
LoadFile(iconfile, flags, desiredWidth, desiredHeight); LoadFile(iconfile, type, desiredWidth, desiredHeight);
} }
wxIcon::wxIcon(const wxIconLocation& loc) wxIcon::wxIcon(const wxIconLocation& loc)
@@ -135,7 +135,7 @@ void wxIcon::CreateIconFromXpm(const char* const* data)
} }
bool wxIcon::LoadFile(const wxString& filename, bool wxIcon::LoadFile(const wxString& filename,
long type, wxBitmapType type,
int desiredWidth, int desiredHeight) int desiredWidth, int desiredHeight)
{ {
UnRef(); UnRef();

17
src/os2/bitmap.cpp
View File

@@ -39,7 +39,6 @@
IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject) IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject) IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
// ============================================================================ // ============================================================================
// implementation // implementation
@@ -1457,7 +1456,7 @@ bool wxMask::Create(
bool wxBitmapHandler::Create( wxGDIImage* pImage, bool wxBitmapHandler::Create( wxGDIImage* pImage,
const void* pData, const void* pData,
long WXUNUSED(lFlags), wxBitmapType WXUNUSED(lFlags),
int nWidth, int nWidth,
int nHeight, int nHeight,
int nDepth) int nDepth)
@@ -1477,7 +1476,7 @@ bool wxBitmapHandler::Create( wxGDIImage* pImage,
bool wxBitmapHandler::Load( bool wxBitmapHandler::Load(
wxGDIImage* pImage wxGDIImage* pImage
, int nId , int nId
, long lFlags , wxBitmapType lFlags
, int nWidth , int nWidth
, int nHeight , int nHeight
) )
@@ -1498,7 +1497,7 @@ bool wxBitmapHandler::Save(
wxGDIImage* pImage wxGDIImage* pImage
, const wxString& rName , const wxString& rName
, int lType , int lType
) ) const
{ {
wxBitmap* pBitmap = wxDynamicCast( pImage wxBitmap* pBitmap = wxDynamicCast( pImage
,wxBitmap ,wxBitmap
@@ -1513,7 +1512,7 @@ bool wxBitmapHandler::Save(
bool wxBitmapHandler::Create( bool wxBitmapHandler::Create(
wxBitmap* WXUNUSED(pBitmap) wxBitmap* WXUNUSED(pBitmap)
, const void* WXUNUSED(pData) , const void* WXUNUSED(pData)
, long WXUNUSED(lType) , wxBitmapType WXUNUSED(lType)
, int WXUNUSED(nWidth) , int WXUNUSED(nWidth)
, int WXUNUSED(nHeight) , int WXUNUSED(nHeight)
, int WXUNUSED(nDepth) , int WXUNUSED(nDepth)
@@ -1525,7 +1524,7 @@ bool wxBitmapHandler::Create(
bool wxBitmapHandler::LoadFile( bool wxBitmapHandler::LoadFile(
wxBitmap* WXUNUSED(pBitmap) wxBitmap* WXUNUSED(pBitmap)
, int WXUNUSED(nId) , int WXUNUSED(nId)
, long WXUNUSED(lType) , wxBitmapType WXUNUSED(lType)
, int WXUNUSED(nDesiredWidth) , int WXUNUSED(nDesiredWidth)
, int WXUNUSED(nDesiredHeight) , int WXUNUSED(nDesiredHeight)
) )
@@ -1536,7 +1535,7 @@ bool wxBitmapHandler::LoadFile(
bool wxBitmapHandler::LoadFile( bool wxBitmapHandler::LoadFile(
wxBitmap* WXUNUSED(pBitmap) wxBitmap* WXUNUSED(pBitmap)
, const wxString& WXUNUSED(rName) , const wxString& WXUNUSED(rName)
, long WXUNUSED(lType) , wxBitmapType WXUNUSED(lType)
, int WXUNUSED(nDesiredWidth) , int WXUNUSED(nDesiredWidth)
, int WXUNUSED(nDesiredHeight) , int WXUNUSED(nDesiredHeight)
) )
@@ -1547,9 +1546,9 @@ bool wxBitmapHandler::LoadFile(
bool wxBitmapHandler::SaveFile( bool wxBitmapHandler::SaveFile(
wxBitmap* WXUNUSED(pBitmap) wxBitmap* WXUNUSED(pBitmap)
, const wxString& WXUNUSED(rName) , const wxString& WXUNUSED(rName)
, int WXUNUSED(nType) , wxBitmapType WXUNUSED(nType)
, const wxPalette* WXUNUSED(pPalette) , const wxPalette* WXUNUSED(pPalette)
) ) const
{ {
return false; return false;
} }

2
src/x11/bitmap.cpp
View File

@@ -1296,8 +1296,6 @@ int GrGetPixelColor(GR_SCREEN_INFO* sinfo, GR_PALETTE* palette, GR_PIXELVAL pixe
// Bitmap handlers // Bitmap handlers
// ============================================================================ // ============================================================================
IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)
#define M_BMPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData()) #define M_BMPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData())
#if wxUSE_XPM #if wxUSE_XPM