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