#ifndef _WX_BITMAP_H_
#define _WX_BITMAP_H_
-#ifdef __GNUG__
- #pragma interface "bitmap.h"
-#endif
-
+#include "wx/os2/private.h"
#include "wx/os2/gdiimage.h"
#include "wx/gdicmn.h"
#include "wx/palette.h"
class WXDLLEXPORT wxMask;
class WXDLLEXPORT wxCursor;
class WXDLLEXPORT wxControl;
+class WXDLLEXPORT wxImage;
// ----------------------------------------------------------------------------
// Bitmap data
// ------------
wxDC* m_pSelectedInto;
- HPS m_hPresentationSpace;
- // optional mask for transparent drawing
+ //
+ // Optional mask for transparent drawing
+ //
wxMask* m_pBitmapMask;
-};
+}; // end of CLASS wxBitmapRefData
// ----------------------------------------------------------------------------
// wxBitmap: a mono or colour bitmap
// Copy constructors
inline wxBitmap(const wxBitmap& rBitmap)
- { Init(); Ref(rBitmap); }
+ { Init(); Ref(rBitmap); SetHandle(rBitmap.GetHandle()); }
// Initialize with raw data
wxBitmap( const char bits[]
);
// Initialize with XPM data
- wxBitmap( char** ppData
- ,wxControl* pAnItem = NULL
- );
+ wxBitmap(const char** ppData) { CreateFromXpm(ppData); }
+ wxBitmap(char** ppData) { CreateFromXpm((const char**)ppData); }
- // Load a file or resource
- wxBitmap( const wxString& rName
+ // Load a resource
+ wxBitmap( int nId
,long lType = wxBITMAP_TYPE_BMP_RESOURCE
);
+ // For compatiability with other ports, under OS/2 does same as default ctor
+ inline wxBitmap( const wxString& WXUNUSED(rFilename)
+ ,long WXUNUSED(lType)
+ )
+ { Init(); }
// New constructor for generalised creation from data
wxBitmap( void* pData
,long lType
);
// If depth is omitted, will create a bitmap compatible with the display
- wxBitmap( int nWidth
- ,int nHeight
- ,int nDepth = -1
- );
+ wxBitmap( int nWidth, int nHeight, int nDepth = -1 );
+
+ wxBitmap( const wxImage& image, int depth = -1 )
+ { (void)CreateFromImage(image, depth); }
// we must have this, otherwise icons are silently copied into bitmaps using
// the copy ctor but the resulting bitmap is invalid!
virtual ~wxBitmap();
+ wxImage ConvertToImage() const;
+
+ // get the given part of bitmap
+ wxBitmap GetSubBitmap(const wxRect& rRect) const;
+
// copies the contents and mask of the given (colour) icon to the bitmap
bool CopyFromIcon(const wxIcon& rIcon);
,int nHeight
,int nDepth = 1
);
- virtual bool LoadFile( const wxString& rName
+ virtual bool LoadFile( int nId
,long lType = wxBITMAP_TYPE_BMP_RESOURCE
);
+ virtual bool LoadFile( const wxString& rName
+ ,long lType = wxBITMAP_TYPE_XPM
+ );
virtual bool SaveFile( const wxString& rName
,int lType
,const wxPalette* pCmap = NULL
{ return (wxBitmapRefData *)m_refData; }
inline int GetQuality() const
- { return (GetBitmapData() ? GetBitmapData()->m_quality : 0); }
+ { return (GetBitmapData() ? GetBitmapData()->m_nQuality : 0); }
void SetQuality(int nQ);
wxPalette* GetPalette() const
- { return (GetBitmapData() ? (& GetBitmapData()->m_bitmapPalette) : (wxPalette*) NULL); }
+ { return (GetBitmapData() ? (& GetBitmapData()->m_vBitmapPalette) : (wxPalette*) NULL); }
void SetPalette(const wxPalette& rPalette);
inline wxMask* GetMask() const
- { return (GetBitmapData() ? GetBitmapData()->m_bitmapMask : (wxMask*) NULL); }
+ { return (GetBitmapData() ? GetBitmapData()->m_pBitmapMask : (wxMask*) NULL); }
void SetMask(wxMask* pMask) ;
- inline bool operator==(const wxBitmap& rBitmap)
+ inline bool operator==(const wxBitmap& rBitmap) const
{ return m_refData == rBitmap.m_refData; }
- inline bool operator!=(const wxBitmap& rBitmap)
+ inline bool operator!=(const wxBitmap& rBitmap) const
{ return m_refData != rBitmap.m_refData; }
-#if WXWIN_COMPATIBILITY_2
- void SetOk(bool bIsOk);
-#endif // WXWIN_COMPATIBILITY_2
-
-#if WXWIN_COMPATIBILITY
- inline wxPalette* GetColourMap() const
- { return GetPalette(); }
-
- inline void SetColourMap(wxPalette* pCmap)
- { SetPalette(*pCmap); };
-
-#endif // WXWIN_COMPATIBILITY
-
// Implementation
public:
- inline void SetHBITMAP(WXHBITMAP hHmp)
- { SetHandle((WXHANDLE)bmp); }
+ inline void SetHBITMAP(WXHBITMAP hBmp)
+ { SetHandle((WXHANDLE)hBmp); }
inline WXHBITMAP GetHBITMAP() const
{ return (WXHBITMAP)GetHandle(); }
inline void SetSelectedInto(wxDC* pDc)
- { if (GetBitmapData()) GetBitmapData()->m_selectedInto = pDc; }
+ { if (GetBitmapData()) GetBitmapData()->m_pSelectedInto = pDc; }
inline wxDC* GetSelectedInto() const
- { return (GetBitmapData() ? GetBitmapData()->m_selectedInto : (wxDC*) NULL); }
-
- // Creates a bitmap that matches the device context's depth, from an
- // arbitray bitmap. At present, the original bitmap must have an associated
- // palette. (TODO: use a default palette if no palette exists.) This
- // function is necessary for you to Blit an arbitrary bitmap (which may
- // have the wrong depth). wxDC::SelectObject will compare the depth of the
- // bitmap with the DC's depth, and create a new bitmap if the depths
- // differ. Eventually we should perhaps make this a public API function so
- // that an app can efficiently produce bitmaps of the correct depth. The
- // Windows solution is to use SetDibBits to blit an arbotrary DIB directly
- // to a DC, but this is too Windows-specific, hence this solution of
- // quietly converting the wxBitmap. Contributed by Frederic Villeneuve
- // <frederic.villeneuve@natinst.com>
+ { return (GetBitmapData() ? GetBitmapData()->m_pSelectedInto : (wxDC*) NULL); }
+
+ inline bool IsMono(void) const { return m_bIsMono; }
+
+ // An OS/2 version that probably doesn't do anything like the msw version
wxBitmap GetBitmapForDC(wxDC& rDc) const;
protected:
inline virtual wxGDIImageRefData* CreateData() const
{ return new wxBitmapRefData; }
+ // creates the bitmap from XPM data, supposed to be called from ctor
+ bool CreateFromXpm(const char** ppData);
+ bool CreateFromImage(const wxImage& image, int depth);
+
private:
bool CopyFromIconOrCursor(const wxGDIImage& rIcon);
+ bool m_bIsMono;
DECLARE_DYNAMIC_CLASS(wxBitmap)
-};
+}; // end of CLASS wxBitmap
// ----------------------------------------------------------------------------
// wxMask: a mono bitmap used for drawing bitmaps transparently.
protected:
WXHBITMAP m_hMaskBitmap;
DECLARE_DYNAMIC_CLASS(wxMask)
-};
+}; // end of CLASS wxMask
// ----------------------------------------------------------------------------
// wxBitmapHandler is a class which knows how to load/save bitmaps to/from file
,int nHeight
,int nDepth = 1
);
+ virtual bool LoadFile( wxBitmap* pBitmap
+ ,int nId
+ ,long lFlags
+ ,int nDesiredWidth
+ ,int nDesiredHeight
+ );
virtual bool LoadFile( wxBitmap* pBitmap
,const wxString& rName
,long lFlags
,int nDepth = 1
);
virtual bool Load( wxGDIImage* pImage
- ,const wxString& rName
+ ,int nId
,long lFlags
,int nDesiredWidth
,int nDesiredHeight
);
- virtual bool Save(wxGDIImage* pImage
- const wxString& rName
- int lType
+ virtual bool Save( wxGDIImage* pImage
+ ,const wxString& rName
+ ,int lType
);
private:
+ inline virtual bool Load( wxGDIImage* WXUNUSED(pImage)
+ ,const wxString& WXUNUSED(rName)
+ ,HPS WXUNUSED(hPs)
+ ,long WXUNUSED(lFlags)
+ ,int WXUNUSED(nDesiredWidth)
+ ,int WXUNUSED(nDesiredHeight)
+ )
+ { return false; }
DECLARE_DYNAMIC_CLASS(wxBitmapHandler)
-};
+}; // end of CLASS wxBitmapHandler
#endif
// _WX_BITMAP_H_
projects / wxWidgets.git / blobdiff