src/os2/xpmhand.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        os2/xpmhand.cpp
   3 // Purpose:     wxBitmap: XPM handler and constructors
   4 // Author:      Julian Smart
   5 // Modified for OS/2 by: Evgeny Kotsuba
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13     #pragma implementation "xpmhand.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 //#include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20     #pragma hdrstop
  21 #endif
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/list.h"
  25     #include "wx/utils.h"
  26     #include "wx/app.h"
  27     #include "wx/palette.h"
  28     #include "wx/dcmemory.h"
  29     #include "wx/bitmap.h"
  30     #include "wx/icon.h"
  31 #endif
  32
  33 #include "wx/os2/private.h"
  34 #include "wx/log.h"
  35
  36
  37 #if wxUSE_XPM_IN_OS2
  38     #define FOR_MSW 1
  39     #include "../xpm/xpm.h"
  40 #endif
  41
  42 #include  "wx/xpmhand.h"
  43
  44 #if wxUSE_XPM_IN_OS2
  45
  46 static void XpmToBitmap(
  47   wxBitmap*                         pBitmap
  48 , const XImage*                     pXimage
  49 , const XImage*                     pXmask
  50 , const XpmAttributes&              rXpmAttr
  51 )
  52 {
  53     wxBitmapRefData*                pRefData = pBitmap->GetBitmapData();
  54     pRefData->m_hBitmap = (WXHBITMAP)pXimage->bitmap;
  55
  56     //
  57     // First set the bitmap width, height, depth...
  58     //
  59     BITMAPINFOHEADER                vBm;
  60
  61     if (!::GpiQueryBitmapParameters( GetHbitmapOf(*pBitmap)
  62                                     ,&vBm
  63                                    ))
  64     {
  65         wxLogLastError(wxT("GetObject(pBitmap)"));
  66     }
  67
  68     pRefData->m_nWidth     = vBm.cx;
  69     pRefData->m_nHeight    = vBm.cy;
  70     pRefData->m_nDepth     = vBm.cPlanes * vBm.cBitCount;
  71     pRefData->m_nNumColors = rXpmAttr.npixels;
  72 #if 0
  73     if (pXmask)
  74     {
  75         wxMask*                     pMask = new wxMask();
  76
  77         pMask->SetMaskBitmap((WXHBITMAP) wxInvertMask( pXmask->bitmap
  78                                                       ,vBm.cx
  79                                                       ,vBm.cy
  80                                                      ));
  81         pBitmap->SetMask(pMask);
  82     }
  83 #endif
  84 } // end of XpmToBitmap
  85
  86 IMPLEMENT_DYNAMIC_CLASS(wxXPMFileHandler, wxBitmapHandler)
  87
  88 bool wxXPMFileHandler::LoadFile(
  89   wxBitmap*                         pBitmap
  90 , const wxString&                   rName
  91 , long                              lFlags
  92 , int                               lDesiredWidth
  93 , int                               lDesiredHeight
  94 )
  95 {
  96     XImage*                         pXimage = NULL;
  97     XImage*                         pXmask = NULL;
  98     XpmAttributes                   vXpmAttr;
  99     HDC                             hDC;
 100     HPS                             hPS;
 101     DEVOPENSTRUC                    dOP = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
 102     SIZEL                           vSizl;
 103
 104     hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&dOP, NULLHANDLE);
 105     hPS = ::GpiCreatePS(vHabmain, hDC, &vSizl, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
 106     if (hPS)
 107     {
 108         vXpmAttr.valuemask = XpmReturnPixels | XpmColorTable;
 109
 110         int                         nErrorStatus = XpmReadFileToImage( &hPS
 111                                                                       ,wxMBSTRINGCAST rName.fn_str()
 112                                                                       ,&pXimage
 113                                                                       ,&pXmask
 114                                                                       ,&vXpmAttr
 115                                                                      );
 116         ::GpiDestroyPS(hPS);
 117         if (nErrorStatus == XpmSuccess)
 118         {
 119             XpmToBitmap( pBitmap
 120                         ,pXimage
 121                         ,pXmask
 122                         ,vXpmAttr
 123                        );
 124             XpmFree(vXpmAttr.pixels);
 125             XpmFreeAttributes(&vXpmAttr);
 126             XImageFree(pXimage);
 127             if (pXmask)
 128                 XDestroyImage(pXmask);
 129         }
 130         return pBitmap->Ok();
 131     }
 132     return FALSE;
 133 } // end of wxXPMFileHandler::LoadFile
 134
 135 bool wxXPMFileHandler::SaveFile(
 136   wxBitmap*                         pBitmap
 137 , const wxString&                   rName
 138 , int                               lType
 139 , const wxPalette*                  pPalette
 140 )
 141 {
 142     XImage                          vXimage;
 143     XImage                          vXmask;
 144     bool                            bHasmask = FALSE;
 145     HDC                             hDC;
 146     HPS                             hPS;
 147     DEVOPENSTRUC                    dOP = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
 148     SIZEL                           vSizl;
 149
 150     hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&dOP, NULLHANDLE);
 151     hPS = ::GpiCreatePS(vHabmain, hDC, &vSizl, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
 152     if (hPS)
 153     {
 154         // fill the XImage struct 'by hand'
 155         wxBitmapRefData*            pRefData = pBitmap->GetBitmapData();
 156
 157         vXimage.width  = pRefData->m_nWidth;
 158         vXimage.height = pRefData->m_nHeight;
 159         vXimage.depth  = pRefData->m_nDepth;
 160         vXimage.bitmap = (HBITMAP)pRefData->m_hBitmap;
 161
 162         bHasmask = (pRefData->m_pBitmapMask != NULL);
 163         if (bHasmask)
 164         {
 165             //
 166             // Strangely enough, the MSW version of xpmlib is not
 167             // coherent with itself regarding masks; we have to invert
 168             // the mask we get when loading, but we still must pass it
 169             // 'as is' when saving...
 170             //
 171             vXmask.bitmap = (HBITMAP)pRefData->m_pBitmapMask->GetMaskBitmap();
 172             vXmask.width  = pRefData->m_nWidth;
 173             vXmask.height = pRefData->m_nHeight;
 174             vXmask.depth  = 1;
 175         }
 176
 177         int                         nErrorStatus = XpmWriteFileFromImage( &hPS
 178                                                                          ,wxMBSTRINGCAST rName.fn_str()
 179                                                                          ,&vXimage
 180                                                                          ,(bHasmask? &vXmask : (XImage *)NULL)
 181                                                                          ,(XpmAttributes *) NULL
 182                                                                         );
 183         ::GpiDestroyPS(hPS);
 184         return (nErrorStatus == XpmSuccess);
 185     }
 186     return FALSE;
 187 } // end of wxXPMFileHandler::SaveFile
 188
 189 IMPLEMENT_DYNAMIC_CLASS(wxXPMDataHandler, wxBitmapHandler)
 190
 191 bool wxXPMDataHandler::Create(
 192   wxBitmap*                         pBitmap
 193 , void*                             pData
 194 , long                              lFlags
 195 , int                               nWidth
 196 , int                               nHeight
 197 , int                               nDepth
 198 )
 199 {
 200     XImage*                         pXimage = NULL;
 201     XImage*                         pXmask = NULL;
 202     XpmAttributes                   vXpmAttr;
 203     HDC                             hDC;
 204     HPS                             hPS;
 205     DEVOPENSTRUC                    dOP = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
 206     SIZEL                           vSizl;
 207
 208     hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&dOP, NULLHANDLE);
 209     hPS = ::GpiCreatePS(vHabmain, hDC, &vSizl, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
 210     if (hPS)
 211     {
 212         vXpmAttr.valuemask = XpmReturnInfos | XpmColorTable;
 213         int                         nErrorStatus = XpmCreateImageFromData( &hPS
 214                                                                           ,(char **)pData
 215                                                                           ,&pXimage
 216                                                                           ,&pXmask
 217                                                                           ,&vXpmAttr
 218                                                                          );
 219         GpiDestroyPS(hPS);
 220         if (nErrorStatus == XpmSuccess)
 221         {
 222             XpmToBitmap( pBitmap
 223                         ,pXimage
 224                         ,pXmask
 225                         ,vXpmAttr
 226                        );
 227             XpmFree(vXpmAttr.pixels);
 228             XpmFreeAttributes(&vXpmAttr);
 229             XImageFree(pXimage); // releases the malloc, but does not destroy bitmap
 230             if (pXmask)
 231                 XDestroyImage(pXmask);
 232         }
 233         return pBitmap->Ok();
 234     }
 235     return FALSE;
 236 } // end of wxXPMDataHandler::Create
 237
 238 #endif // wxUSE_XPM_IN_OS2