src/os2/gdiimage.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/os2/gdiimage.cpp
   3 // Purpose:     wxGDIImage implementation
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     20.11.99
   7 // Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   8 // Licence:     wxWindows licence
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 // ============================================================================
  12 // declarations
  13 // ============================================================================
  14
  15 // ----------------------------------------------------------------------------
  16 // headers
  17 // ----------------------------------------------------------------------------
  18
  19 // For compilers that support precompilation, includes "wx.h".
  20 #include "wx/wxprec.h"
  21
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/string.h"
  25     #include "wx/app.h"
  26 #endif // WX_PRECOMP
  27
  28 #include "wx/os2/private.h"
  29 #include "wx/os2/gdiimage.h"
  30
  31 #include "wx/listimpl.cpp"
  32 WX_DEFINE_LIST(wxGDIImageHandlerList)
  33
  34 // ----------------------------------------------------------------------------
  35 // private classes
  36 // ----------------------------------------------------------------------------
  37
  38 // all image handlers are declared/defined in this file because the outside
  39 // world doesn't have to know about them (but only about wxBITMAP_TYPE_XXX ids)
  40
  41 class WXDLLEXPORT wxBMPFileHandler : public wxBitmapHandler
  42 {
  43 public:
  44     wxBMPFileHandler() : wxBitmapHandler(wxT("Windows bitmap file"), wxT("bmp"),
  45                                          wxBITMAP_TYPE_BMP)
  46     {
  47     }
  48
  49     virtual bool LoadFile( wxBitmap*       pBitmap
  50                           ,const wxString& rName
  51                           ,HPS             hPs
  52                           ,wxBitmapType    lFlags
  53                           ,int             nDesiredWidth
  54                           ,int             nDesiredHeight
  55                          );
  56     virtual bool SaveFile( wxBitmap*        pBitmap
  57                           ,const wxString&  rName
  58                           ,wxBitmapType     lType
  59                           ,const wxPalette* pPalette = NULL
  60                          );
  61
  62 private:
  63     inline virtual bool LoadFile( wxBitmap*       pBitmap
  64                                  ,int             nId
  65                                  ,wxBitmapType    lFlags
  66                                  ,int             nDesiredWidth
  67                                  ,int             nDesiredHeight
  68                                 )
  69     {
  70         return wxBitmapHandler::LoadFile( pBitmap
  71                                          ,nId
  72                                          ,lFlags
  73                                          ,nDesiredWidth
  74                                          ,nDesiredHeight
  75                                         );
  76     }
  77     DECLARE_DYNAMIC_CLASS(wxBMPFileHandler)
  78 };
  79
  80 class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
  81 {
  82 public:
  83     wxBMPResourceHandler() : wxBitmapHandler(wxT("Windows bitmap resource"),
  84                                              wxEmptyString,
  85                                              wxBITMAP_TYPE_BMP_RESOURCE)
  86     {
  87     }
  88
  89     virtual bool LoadFile( wxBitmap*       pBitmap
  90                           ,int             nId
  91                           ,wxBitmapType    lFlags
  92                           ,int             nDesiredWidth
  93                           ,int             nDesiredHeight
  94                          );
  95
  96 private:
  97     DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler)
  98 };
  99
 100 class WXDLLEXPORT wxIconHandler : public wxGDIImageHandler
 101 {
 102 public:
 103     wxIconHandler( const wxString& rName
 104                   ,const wxString& rExt
 105                   ,wxBitmapType    lType
 106                  ) : wxGDIImageHandler( rName
 107                                        ,rExt
 108                                        ,lType
 109                                       )
 110     {
 111     }
 112
 113     // creating and saving icons is not supported
 114     virtual bool Create( wxGDIImage* WXUNUSED(pImage)
 115                         ,const void* WXUNUSED(pData)
 116                         ,wxBitmapType WXUNUSED(lFlags)
 117                         ,int         WXUNUSED(nWidth)
 118                         ,int         WXUNUSED(nHeight)
 119                         ,int         WXUNUSED(nDepth) = 1
 120                        )
 121     {
 122         return false;
 123     }
 124
 125     virtual bool Save( const wxGDIImage* WXUNUSED(pImage)
 126                       ,const wxString&   WXUNUSED(rName)
 127                       ,wxBitmapType      WXUNUSED(nType)
 128                      ) const
 129     {
 130         return false;
 131     }
 132     virtual bool Load( wxGDIImage*     pImage
 133                       ,const wxString& rName
 134                       ,HPS             hPs
 135                       ,wxBitmapType    lFlags
 136                       ,int             nDesiredWidth
 137                       ,int             nDesiredHeight
 138                      )
 139     {
 140         wxIcon*                     pIcon = wxDynamicCast(pImage, wxIcon);
 141         wxCHECK_MSG(pIcon, false, wxT("wxIconHandler only works with icons"));
 142
 143         return LoadIcon( pIcon
 144                         ,rName
 145                         ,hPs
 146                         ,lFlags
 147                         ,nDesiredWidth
 148                         ,nDesiredHeight
 149                        );
 150     }
 151
 152 protected:
 153     virtual bool LoadIcon( wxIcon*         pIcon
 154                           ,const wxString& rName
 155                           ,HPS             hPs
 156                           ,wxBitmapType    lFlags
 157                           ,int             nDesiredWidth = -1
 158                           ,int             nDesiredHeight = -1
 159                          ) = 0;
 160 private:
 161     inline virtual bool Load( wxGDIImage* WXUNUSED(pImage),
 162                               int         WXUNUSED(nId),
 163                               wxBitmapType WXUNUSED(lFlags),
 164                               int         WXUNUSED(nDesiredWidth),
 165                               int         WXUNUSED(nDesiredHeight) )
 166     {
 167         return false;
 168     }
 169 };
 170
 171 class WXDLLEXPORT wxICOFileHandler : public wxIconHandler
 172 {
 173 public:
 174     wxICOFileHandler() : wxIconHandler(wxT("ICO icon file"),
 175                                        wxT("ico"),
 176                                        wxBITMAP_TYPE_ICO)
 177     {
 178     }
 179
 180     virtual bool LoadIcon( wxIcon *        pIcon
 181                           ,const wxString& rName
 182                           ,HPS             hPs
 183                           ,wxBitmapType    lFlags
 184                           ,int             nDesiredWidth = -1
 185                           ,int             nDesiredHeight = -1
 186                          );
 187
 188 private:
 189     DECLARE_DYNAMIC_CLASS(wxICOFileHandler)
 190 };
 191
 192 class WXDLLEXPORT wxICOResourceHandler: public wxIconHandler
 193 {
 194 public:
 195     wxICOResourceHandler() : wxIconHandler(wxT("ICO resource"),
 196                                            wxT("ico"),
 197                                            wxBITMAP_TYPE_ICO_RESOURCE)
 198     {
 199     }
 200
 201     virtual bool LoadIcon( wxIcon*         pIcon
 202                           ,const wxString& rName
 203                           ,HPS             hPs
 204                           ,wxBitmapType    lFlags
 205                           ,int             nDesiredWidth = -1
 206                           ,int             nDesiredHeight = -1
 207                          );
 208
 209 private:
 210     DECLARE_DYNAMIC_CLASS(wxICOResourceHandler)
 211 };
 212
 213 // ----------------------------------------------------------------------------
 214 // wxWin macros
 215 // ----------------------------------------------------------------------------
 216
 217 IMPLEMENT_DYNAMIC_CLASS(wxBMPFileHandler, wxBitmapHandler)
 218 IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
 219 IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxObject)
 220 IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxObject)
 221
 222 // ============================================================================
 223 // implementation
 224 // ============================================================================
 225
 226 wxGDIImageHandlerList wxGDIImage::ms_handlers;
 227
 228 // ----------------------------------------------------------------------------
 229 // wxGDIImage functions forwarded to wxGDIImageRefData
 230 // ----------------------------------------------------------------------------
 231
 232 bool wxGDIImage::FreeResource( bool WXUNUSED(bForce) )
 233 {
 234     if ( !IsNull() )
 235     {
 236         GetGDIImageData()->Free();
 237         GetGDIImageData()->m_hHandle = 0;
 238     }
 239
 240     return true;
 241 }
 242
 243 WXHANDLE wxGDIImage::GetResourceHandle() const
 244 {
 245     return GetHandle();
 246 }
 247
 248 // ----------------------------------------------------------------------------
 249 // wxGDIImage handler stuff
 250 // ----------------------------------------------------------------------------
 251
 252 void wxGDIImage::AddHandler( wxGDIImageHandler* pHandler )
 253 {
 254     ms_handlers.Append(pHandler);
 255 }
 256
 257 void wxGDIImage::InsertHandler( wxGDIImageHandler* pHandler )
 258 {
 259     ms_handlers.Insert(pHandler);
 260 }
 261
 262 bool wxGDIImage::RemoveHandler( const wxString& rName )
 263 {
 264     wxGDIImageHandler*              pHandler = FindHandler(rName);
 265
 266     if (pHandler)
 267     {
 268         ms_handlers.DeleteObject(pHandler);
 269         return true;
 270     }
 271     else
 272         return false;
 273 }
 274
 275 wxGDIImageHandler* wxGDIImage::FindHandler(
 276   const wxString&                   rName
 277 )
 278 {
 279     wxGDIImageHandlerList::compatibility_iterator   pNode = ms_handlers.GetFirst();
 280
 281     while ( pNode )
 282     {
 283         wxGDIImageHandler*          pHandler = pNode->GetData();
 284
 285         if ( pHandler->GetName() == rName )
 286             return pHandler;
 287         pNode = pNode->GetNext();
 288     }
 289     return(NULL);
 290 }
 291
 292 wxGDIImageHandler* wxGDIImage::FindHandler(
 293   const wxString&                   rExtension
 294 , wxBitmapType                      lType
 295 )
 296 {
 297     wxGDIImageHandlerList::compatibility_iterator   pNode = ms_handlers.GetFirst();
 298     while ( pNode )
 299     {
 300         wxGDIImageHandler*          pHandler = pNode->GetData();
 301
 302         if ( (pHandler->GetExtension() == rExtension) &&
 303              (lType == -1 || pHandler->GetType() == lType) )
 304         {
 305             return pHandler;
 306         }
 307         pNode = pNode->GetNext();
 308     }
 309     return(NULL);
 310 }
 311
 312 wxGDIImageHandler* wxGDIImage::FindHandler(
 313   wxBitmapType                           lType
 314 )
 315 {
 316     wxGDIImageHandlerList::compatibility_iterator   pNode = ms_handlers.GetFirst();
 317
 318     while ( pNode )
 319     {
 320         wxGDIImageHandler*          pHandler = pNode->GetData();
 321
 322         if ( pHandler->GetType() == lType )
 323             return pHandler;
 324         pNode = pNode->GetNext();
 325     }
 326     return(NULL);
 327 }
 328
 329 void wxGDIImage::CleanUpHandlers()
 330 {
 331     wxGDIImageHandlerList::compatibility_iterator   pNode = ms_handlers.GetFirst();
 332
 333     while ( pNode )
 334     {
 335         wxGDIImageHandler*                              pHandler = pNode->GetData();
 336         wxGDIImageHandlerList::compatibility_iterator   pNext = pNode->GetNext();
 337
 338         delete pHandler;
 339         ms_handlers.Erase( pNode );
 340         pNode = pNext;
 341     }
 342 }
 343
 344 void wxGDIImage::InitStandardHandlers()
 345 {
 346     AddHandler(new wxBMPResourceHandler);
 347     AddHandler(new wxBMPFileHandler);
 348     AddHandler(new wxICOResourceHandler);
 349     AddHandler(new wxICOFileHandler);
 350 }
 351
 352 // ----------------------------------------------------------------------------
 353 // wxBitmap handlers
 354 // ----------------------------------------------------------------------------
 355
 356 bool wxBMPResourceHandler::LoadFile( wxBitmap* pBitmap,
 357                                      int       nId,
 358                                      wxBitmapType WXUNUSED(lFlags),
 359                                      int       WXUNUSED(nDesiredWidth),
 360                                      int       WXUNUSED(nDesiredHeight) )
 361 {
 362     SIZEL                               vSize = {0, 0};
 363     DEVOPENSTRUC                        vDop  = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
 364     HDC                                 hDC   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
 365     HPS                                 hPS   = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
 366
 367     pBitmap->SetHBITMAP((WXHBITMAP)::GpiLoadBitmap( hPS
 368                                                    ,NULLHANDLE
 369                                                    ,nId
 370                                                    ,0
 371                                                    ,0
 372                                                   ));
 373     ::GpiDestroyPS(hPS);
 374     ::DevCloseDC(hDC);
 375
 376     wxBitmapRefData*                pData = pBitmap->GetBitmapData();
 377
 378     if ( pBitmap->IsOk() )
 379     {
 380         BITMAPINFOHEADER            vBmph;
 381
 382         ::GpiQueryBitmapParameters(GetHbitmapOf(*pBitmap), &vBmph);
 383         pData->m_nWidth  = vBmph.cx;
 384         pData->m_nHeight = vBmph.cy;
 385         pData->m_nDepth  = vBmph.cBitCount;
 386     }
 387     return(pBitmap->IsOk());
 388 } // end of wxBMPResourceHandler::LoadFile
 389
 390 bool wxBMPFileHandler::LoadFile( wxBitmap*       pBitmap,
 391                                  const wxString& WXUNUSED(rName),
 392                                  HPS             WXUNUSED(hPs),
 393                                  wxBitmapType    WXUNUSED(lFlags),
 394                                  int             WXUNUSED(nDesiredWidth),
 395                                  int             WXUNUSED(nDesiredHeight) )
 396 {
 397 #if defined(wxUSE_IMAGE_LOADING_IN_OS2) && wxUSE_IMAGE_LOADING_IN_OS2
 398     wxPalette* pPalette = NULL;
 399
 400     bool bSuccess = false; /* wxLoadIntoBitmap( WXSTRINGCAST rName
 401                                                ,pBitmap
 402                                                ,&pPalette
 403                                               ) != 0; */
 404     if (bSuccess && pPalette)
 405     {
 406         pBitmap->SetPalette(*pPalette);
 407     }
 408
 409     // it was copied by the bitmap if it was loaded successfully
 410     delete pPalette;
 411
 412     return(bSuccess);
 413 #else
 414     wxUnusedVar(pBitmap);
 415     return false;
 416 #endif
 417 }
 418
 419 bool wxBMPFileHandler::SaveFile( wxBitmap*        pBitmap,
 420                                  const wxString&  WXUNUSED(rName),
 421                                  wxBitmapType     WXUNUSED(nType),
 422                                  const wxPalette* pPal )
 423 {
 424 #if defined(wxUSE_IMAGE_LOADING_IN_OS2) && wxUSE_IMAGE_LOADING_IN_OS2
 425     wxPalette* pActualPalette = (wxPalette *)pPal;
 426
 427     if (!pActualPalette)
 428         pActualPalette = pBitmap->GetPalette();
 429     /* return(wxSaveBitmap( WXSTRINGCAST rName
 430                         ,pBitmap
 431                         ,pActualPalette
 432                        ) != 0); */
 433     return false;
 434 #else
 435     wxUnusedVar(pBitmap);
 436     wxUnusedVar(pPal);
 437     return false;
 438 #endif
 439 }
 440
 441 // ----------------------------------------------------------------------------
 442 // wxIcon handlers
 443 // ----------------------------------------------------------------------------
 444
 445 bool wxICOFileHandler::LoadIcon( wxIcon*         pIcon,
 446                                  const wxString& WXUNUSED(rName),
 447                                  HPS             WXUNUSED(hPs),
 448                                  wxBitmapType    WXUNUSED(lFlags),
 449                                  int             WXUNUSED(nDesiredWidth),
 450                                  int             WXUNUSED(nDesiredHeight) )
 451 {
 452 #if defined(wxUSE_RESOURCE_LOADING_IN_OS2) && wxUSE_RESOURCE_LOADING_IN_OS2
 453     pIcon->UnRef();
 454
 455     return false;
 456 #else
 457     wxUnusedVar(pIcon);
 458     return false;
 459 #endif
 460 }
 461
 462 bool wxICOResourceHandler::LoadIcon( wxIcon*         pIcon,
 463                                      const wxString& rName,
 464                                      HPS             WXUNUSED(hPs),
 465                                      wxBitmapType    WXUNUSED(lFlags),
 466                                      int             WXUNUSED(nDesiredWidth),
 467                                      int             WXUNUSED(nDesiredHeight) )
 468 {
 469     HPOINTER                        hIcon;
 470
 471     hIcon = ::WinLoadFileIcon( rName.c_str()
 472                               ,TRUE // load for private use
 473                              );
 474
 475     pIcon->SetSize(32, 32); // all OS/2 icons are 32 x 32
 476
 477     pIcon->SetHICON((WXHICON)hIcon);
 478
 479     return pIcon->IsOk();
 480 } // end of wxICOResourceHandler::LoadIcon