home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2240.zip / wxWindows-2.4.0 / include / wx / os2 / bitmap.h < prev    next >
C/C++ Source or Header  |  2002-07-22  |  12KB  |  368 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Name:        wx/os2/bitmap.h
  3. // Purpose:     wxBitmap class
  4. // Author:      David Webster
  5. // Modified by:
  6. // Created:     11/28/99
  7. // RCS-ID:      $Id: BITMAP.H,v 1.21 2002/07/22 03:27:36 DW Exp $
  8. // Copyright:   (c) David Webster
  9. // Licence:     wxWindows licence
  10. /////////////////////////////////////////////////////////////////////////////
  11.  
  12. #ifndef _WX_BITMAP_H_
  13. #define _WX_BITMAP_H_
  14.  
  15. #ifdef __GNUG__
  16.     #pragma interface "bitmap.h"
  17. #endif
  18.  
  19. #include "wx/os2/private.h"
  20. #include "wx/os2/gdiimage.h"
  21. #include "wx/gdicmn.h"
  22. #include "wx/palette.h"
  23.  
  24. class WXDLLEXPORT wxDC;
  25. class WXDLLEXPORT wxControl;
  26. class WXDLLEXPORT wxBitmap;
  27. class WXDLLEXPORT wxBitmapHandler;
  28. class WXDLLEXPORT wxIcon;
  29. class WXDLLEXPORT wxMask;
  30. class WXDLLEXPORT wxCursor;
  31. class WXDLLEXPORT wxControl;
  32. class WXDLLEXPORT wxImage;
  33.  
  34. // ----------------------------------------------------------------------------
  35. // Bitmap data
  36. //
  37. // NB: this class is private, but declared here to make it possible inline
  38. //     wxBitmap functions accessing it
  39. // ----------------------------------------------------------------------------
  40.  
  41. class WXDLLEXPORT wxBitmapRefData : public wxGDIImageRefData
  42. {
  43. public:
  44.     wxBitmapRefData();
  45.     virtual ~wxBitmapRefData() { Free(); }
  46.  
  47.     virtual void Free();
  48.  
  49. public:
  50.     int                             m_nNumColors;
  51.     wxPalette                       m_vBitmapPalette;
  52.     int                             m_nQuality;
  53.  
  54.     // OS2-specific
  55.     // ------------
  56.  
  57.     wxDC*                           m_pSelectedInto;
  58.  
  59.     //
  60.     // Optional mask for transparent drawing
  61.     //
  62.     wxMask*                         m_pBitmapMask;
  63. }; // end of CLASS wxBitmapRefData
  64.  
  65. // ----------------------------------------------------------------------------
  66. // wxBitmap: a mono or colour bitmap
  67. // ----------------------------------------------------------------------------
  68.  
  69. class WXDLLEXPORT wxBitmap : public wxGDIImage
  70. {
  71. public:
  72.     // default ctor creates an invalid bitmap, you must Create() it later
  73.     wxBitmap() { Init(); }
  74.  
  75.     // Copy constructors
  76.     inline wxBitmap(const wxBitmap& rBitmap)
  77.       { Init(); Ref(rBitmap); SetHandle(rBitmap.GetHandle()); }
  78.  
  79.     // Initialize with raw data
  80.     wxBitmap( const char bits[]
  81.              ,int        nWidth
  82.              ,int        nHeight
  83.              ,int        nDepth = 1
  84.             );
  85.  
  86.     // Initialize with XPM data
  87.     wxBitmap(const char** ppData) { CreateFromXpm(ppData); }
  88.     wxBitmap(char** ppData) { CreateFromXpm((const char**)ppData); }
  89.  
  90.     // Load a resource
  91.     wxBitmap( int             nId
  92.              ,long            lType = wxBITMAP_TYPE_BMP_RESOURCE
  93.             );
  94.  
  95.     // For compatiability with other ports, under OS/2 does same as default ctor
  96.     inline wxBitmap( const wxString& WXUNUSED(rFilename)
  97.                     ,long            WXUNUSED(lType)
  98.                    )
  99.     { Init(); }
  100.     // New constructor for generalised creation from data
  101.     wxBitmap( void* pData
  102.              ,long  lType
  103.              ,int   nWidth
  104.              ,int   nHeight
  105.              ,int   nDepth = 1
  106.             );
  107.  
  108.     // If depth is omitted, will create a bitmap compatible with the display
  109.     wxBitmap( int nWidth
  110.              ,int nHeight
  111.              ,int nDepth = -1
  112.             );
  113.  
  114.     wxBitmap( const wxImage& image, int depth = -1 )
  115.                          { (void)CreateFromImage(image, depth); }
  116.  
  117.     // we must have this, otherwise icons are silently copied into bitmaps using
  118.     // the copy ctor but the resulting bitmap is invalid!
  119.     inline wxBitmap(const wxIcon& rIcon)
  120.       { Init(); CopyFromIcon(rIcon); }
  121.  
  122.     wxBitmap& operator=(const wxBitmap& rBitmap)
  123.     {
  124.         if ( m_refData != rBitmap.m_refData )
  125.             Ref(rBitmap);
  126.         return(*this);
  127.     }
  128.  
  129.     wxBitmap& operator=(const wxIcon& rIcon)
  130.     {
  131.         (void)CopyFromIcon(rIcon);
  132.  
  133.         return(*this);
  134.     }
  135.  
  136.     wxBitmap& operator=(const wxCursor& rCursor)
  137.     {
  138.         (void)CopyFromCursor(rCursor);
  139.         return (*this);
  140.     }
  141.  
  142.     virtual ~wxBitmap();
  143.  
  144.     wxImage ConvertToImage() const;
  145.  
  146.     // get the given part of bitmap
  147.     wxBitmap GetSubBitmap(const wxRect& rRect) const;
  148.  
  149.     // copies the contents and mask of the given (colour) icon to the bitmap
  150.     bool CopyFromIcon(const wxIcon& rIcon);
  151.  
  152.     // copies the contents and mask of the given cursor to the bitmap
  153.     bool CopyFromCursor(const wxCursor& rCursor);
  154.  
  155.     virtual bool Create( int nWidth
  156.                         ,int nHeight
  157.                         ,int nDepth = -1
  158.                        );
  159.     virtual bool Create( void* pData
  160.                         ,long  lType
  161.                         ,int   nWidth
  162.                         ,int   nHeight
  163.                         ,int   nDepth = 1
  164.                        );
  165.     virtual bool LoadFile( int             nId
  166.                           ,long            lType = wxBITMAP_TYPE_BMP_RESOURCE
  167.                          );
  168.     virtual bool SaveFile( const wxString&  rName
  169.                           ,int              lType
  170.                           ,const wxPalette* pCmap = NULL
  171.                          );
  172.  
  173.     inline wxBitmapRefData* GetBitmapData() const
  174.       { return (wxBitmapRefData *)m_refData; }
  175.  
  176.     inline int GetQuality() const
  177.       { return (GetBitmapData() ? GetBitmapData()->m_nQuality : 0); }
  178.  
  179.     void SetQuality(int nQ);
  180.  
  181.     wxPalette* GetPalette() const
  182.       { return (GetBitmapData() ? (& GetBitmapData()->m_vBitmapPalette) : (wxPalette*) NULL); }
  183.  
  184.     void       SetPalette(const wxPalette& rPalette);
  185.  
  186.     inline wxMask* GetMask() const
  187.       { return (GetBitmapData() ? GetBitmapData()->m_pBitmapMask : (wxMask*) NULL); }
  188.  
  189.     void SetMask(wxMask* pMask) ;
  190.  
  191.     inline bool operator==(const wxBitmap& rBitmap) const
  192.       { return m_refData == rBitmap.m_refData; }
  193.  
  194.     inline bool operator!=(const wxBitmap& rBitmap) const
  195.       { return m_refData != rBitmap.m_refData; }
  196.  
  197. #if WXWIN_COMPATIBILITY_2
  198.     void SetOk(bool bIsOk);
  199. #endif // WXWIN_COMPATIBILITY_2
  200.  
  201. #if WXWIN_COMPATIBILITY
  202.     inline wxPalette* GetColourMap() const
  203.       { return GetPalette(); }
  204.  
  205.     inline void       SetColourMap(wxPalette* pCmap)
  206.       { SetPalette(*pCmap); };
  207.  
  208. #endif // WXWIN_COMPATIBILITY
  209.  
  210.     // Implementation
  211. public:
  212.     inline void SetHBITMAP(WXHBITMAP hBmp)
  213.       { SetHandle((WXHANDLE)hBmp); }
  214.  
  215.     inline WXHBITMAP GetHBITMAP() const
  216.       { return (WXHBITMAP)GetHandle(); }
  217.  
  218.     inline void  SetSelectedInto(wxDC* pDc)
  219.       { if (GetBitmapData()) GetBitmapData()->m_pSelectedInto = pDc; }
  220.  
  221.     inline wxDC* GetSelectedInto() const
  222.       { return (GetBitmapData() ? GetBitmapData()->m_pSelectedInto : (wxDC*) NULL); }
  223.  
  224.     inline bool IsMono(void) const { return m_bIsMono; }
  225.  
  226.     // An OS/2 version that probably doesn't do anything like the msw version
  227.     wxBitmap GetBitmapForDC(wxDC& rDc) const;
  228.  
  229. protected:
  230.     // common part of all ctors
  231.     void Init();
  232.  
  233.     inline virtual wxGDIImageRefData* CreateData() const
  234.         { return new wxBitmapRefData; }
  235.  
  236.     // creates the bitmap from XPM data, supposed to be called from ctor
  237.     bool CreateFromXpm(const char** ppData);
  238.     bool CreateFromImage(const wxImage& image, int depth);
  239.  
  240. private:
  241.     bool CopyFromIconOrCursor(const wxGDIImage& rIcon);
  242.  
  243.     bool                            m_bIsMono;
  244.     DECLARE_DYNAMIC_CLASS(wxBitmap)
  245. }; // end of CLASS wxBitmap
  246.  
  247. // ----------------------------------------------------------------------------
  248. // wxMask: a mono bitmap used for drawing bitmaps transparently.
  249. // ----------------------------------------------------------------------------
  250.  
  251. class WXDLLEXPORT wxMask : public wxObject
  252. {
  253. public:
  254.     wxMask();
  255.  
  256.     // Construct a mask from a bitmap and a colour indicating the transparent
  257.     // area
  258.     wxMask( const wxBitmap& rBitmap
  259.            ,const wxColour& rColour
  260.           );
  261.  
  262.     // Construct a mask from a bitmap and a palette index indicating the
  263.     // transparent area
  264.     wxMask( const wxBitmap& rBitmap
  265.            ,int             nPaletteIndex
  266.           );
  267.  
  268.     // Construct a mask from a mono bitmap (copies the bitmap).
  269.     wxMask(const wxBitmap& rBitmap);
  270.  
  271.     // construct a mask from the givne bitmap handle
  272.     wxMask(WXHBITMAP hBmp)
  273.       { m_hMaskBitmap = hBmp; }
  274.  
  275.     virtual ~wxMask();
  276.  
  277.     bool Create( const wxBitmap& bitmap
  278.                 ,const wxColour& rColour
  279.                );
  280.     bool Create( const wxBitmap& rBitmap
  281.                 ,int             nPaletteIndex
  282.                );
  283.     bool Create(const wxBitmap& rBitmap);
  284.  
  285.     // Implementation
  286.     WXHBITMAP GetMaskBitmap() const
  287.       { return m_hMaskBitmap; }
  288.     void SetMaskBitmap(WXHBITMAP hBmp)
  289.       { m_hMaskBitmap = hBmp; }
  290.  
  291. protected:
  292.     WXHBITMAP                       m_hMaskBitmap;
  293.     DECLARE_DYNAMIC_CLASS(wxMask)
  294. }; // end of CLASS wxMask
  295.  
  296. // ----------------------------------------------------------------------------
  297. // wxBitmapHandler is a class which knows how to load/save bitmaps to/from file
  298. // ----------------------------------------------------------------------------
  299.  
  300. class WXDLLEXPORT wxBitmapHandler : public wxGDIImageHandler
  301. {
  302. public:
  303.     inline wxBitmapHandler()
  304.       { m_lType = wxBITMAP_TYPE_INVALID; }
  305.  
  306.     inline wxBitmapHandler( const wxString& rName
  307.                     ,const wxString& rExt
  308.                     ,long            lType
  309.                    )
  310.                    : wxGDIImageHandler( rName
  311.                                        ,rExt
  312.                                        ,lType)
  313.     {
  314.     }
  315.  
  316.     // keep wxBitmapHandler derived from wxGDIImageHandler compatible with the
  317.     // old class which worked only with bitmaps
  318.     virtual bool Create( wxBitmap* pBitmap
  319.                         ,void*     pData
  320.                         ,long      lFlags
  321.                         ,int       nWidth
  322.                         ,int       nHeight
  323.                         ,int       nDepth = 1
  324.                        );
  325.     virtual bool LoadFile( wxBitmap*       pBitmap
  326.                           ,int             nId
  327.                           ,long            lFlags
  328.                           ,int             nDesiredWidth
  329.                           ,int             nDesiredHeight
  330.                          );
  331.     virtual bool SaveFile( wxBitmap*        pBitmap
  332.                           ,const wxString&  rName
  333.                           ,int              lType
  334.                           ,const wxPalette* pPalette = NULL
  335.                          );
  336.  
  337.     virtual bool Create( wxGDIImage* pImage
  338.                         ,void*       pData
  339.                         ,long        lFlags
  340.                         ,int         nWidth
  341.                         ,int         nHeight
  342.                         ,int         nDepth = 1
  343.                        );
  344.     virtual bool Load( wxGDIImage*     pImage
  345.                       ,int             nId
  346.                       ,long            lFlags
  347.                       ,int             nDesiredWidth
  348.                       ,int             nDesiredHeight
  349.                      );
  350.     virtual bool Save( wxGDIImage*     pImage
  351.                       ,const wxString& rName
  352.                       ,int             lType
  353.                      );
  354. private:
  355.     inline virtual bool Load( wxGDIImage*     pImage
  356.                              ,const wxString& rName
  357.                              ,HPS             hPs
  358.                              ,long            lFlags
  359.                              ,int             nDesiredWidth
  360.                              ,int             nDesiredHeight
  361.                             )
  362.     { return FALSE; }
  363.     DECLARE_DYNAMIC_CLASS(wxBitmapHandler)
  364. }; // end of CLASS wxBitmapHandler
  365.  
  366. #endif
  367.   // _WX_BITMAP_H_
  368.