src/msw/imaglist.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/imaglist.cpp
   3 // Purpose:     wxImageList implementation for Win32
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "imaglist.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #if defined(__WIN95__)
  32
  33 #ifndef WX_PRECOMP
  34     #include "wx/window.h"
  35     #include "wx/icon.h"
  36     #include "wx/dc.h"
  37     #include "wx/string.h"
  38     #include "wx/dcmemory.h"
  39
  40     #include <stdio.h>
  41 #endif
  42
  43 #include "wx/log.h"
  44 #include "wx/intl.h"
  45
  46 #include "wx/msw/imaglist.h"
  47 #include "wx/msw/private.h"
  48
  49 #if !defined(__GNUWIN32_OLD__) && !defined(__TWIN32__)
  50     #include <commctrl.h>
  51 #endif
  52
  53 // ----------------------------------------------------------------------------
  54 // wxWin macros
  55 // ----------------------------------------------------------------------------
  56
  57 IMPLEMENT_DYNAMIC_CLASS(wxImageList, wxObject)
  58
  59 #define GetHImageList()     ((HIMAGELIST)m_hImageList)
  60
  61 // ----------------------------------------------------------------------------
  62 // private functions
  63 // ----------------------------------------------------------------------------
  64
  65 // returns the mask if it's valid, otherwise the bitmap mask and, if it's not
  66 // valid neither, a "solid" mask (no transparent zones at all)
  67 static wxBitmap GetMaskForImage(const wxBitmap& bitmap, const wxBitmap& mask);
  68
  69 // ============================================================================
  70 // implementation
  71 // ============================================================================
  72
  73 // ----------------------------------------------------------------------------
  74 // wxImageList creation/destruction
  75 // ----------------------------------------------------------------------------
  76
  77 wxImageList::wxImageList()
  78 {
  79     m_hImageList = 0;
  80 }
  81
  82 // Creates an image list
  83 bool wxImageList::Create(int width, int height, bool mask, int initial)
  84 {
  85     UINT flags = 0;
  86
  87     // set appropriate color depth
  88     int dd = wxDisplayDepth();
  89     if (dd <= 4)       flags |= ILC_COLOR;      // 16 color
  90     else if (dd <= 8)  flags |= ILC_COLOR8;     // 256 color
  91     else if (dd <= 16) flags |= ILC_COLOR16;    // 64k hi-color
  92     else if (dd <= 24) flags |= ILC_COLOR24;    // 16m truecolor
  93     else if (dd <= 32) flags |= ILC_COLOR32;    // 16m truecolor
  94
  95     if ( mask )
  96         flags |= ILC_MASK;
  97
  98     // Grow by 1, I guess this is reasonable behaviour most of the time
  99     m_hImageList = (WXHIMAGELIST) ImageList_Create(width, height, flags,
 100                                                    initial, 1);
 101     if ( !m_hImageList )
 102     {
 103         wxLogLastError(wxT("ImageList_Create()"));
 104     }
 105
 106     return m_hImageList != 0;
 107 }
 108
 109 wxImageList::~wxImageList()
 110 {
 111     if ( m_hImageList )
 112     {
 113         ImageList_Destroy(GetHImageList());
 114         m_hImageList = 0;
 115     }
 116 }
 117
 118 // ----------------------------------------------------------------------------
 119 // wxImageList attributes
 120 // ----------------------------------------------------------------------------
 121
 122 // Returns the number of images in the image list.
 123 int wxImageList::GetImageCount() const
 124 {
 125     wxASSERT_MSG( m_hImageList, _T("invalid image list") );
 126
 127     return ImageList_GetImageCount(GetHImageList());
 128 }
 129
 130 // Returns the size (same for all images) of the images in the list
 131 bool wxImageList::GetSize(int WXUNUSED(index), int &width, int &height) const
 132 {
 133     wxASSERT_MSG( m_hImageList, _T("invalid image list") );
 134
 135     return ImageList_GetIconSize(GetHImageList(), &width, &height) != 0;
 136 }
 137
 138 // ----------------------------------------------------------------------------
 139 // wxImageList operations
 140 // ----------------------------------------------------------------------------
 141
 142 // Adds a bitmap, and optionally a mask bitmap.
 143 // Note that wxImageList creates new bitmaps, so you may delete
 144 // 'bitmap' and 'mask'.
 145 int wxImageList::Add(const wxBitmap& bitmap, const wxBitmap& mask)
 146 {
 147     wxBitmap bmpMask = GetMaskForImage(bitmap, mask);
 148     HBITMAP hbmpMask = wxInvertMask(GetHbitmapOf(bmpMask));
 149
 150     int index = ImageList_Add(GetHImageList(), GetHbitmapOf(bitmap), hbmpMask);
 151     if ( index == -1 )
 152     {
 153         wxLogError(_("Couldn't add an image to the image list."));
 154     }
 155
 156     ::DeleteObject(hbmpMask);
 157
 158     return index;
 159 }
 160
 161 // Adds a bitmap, using the specified colour to create the mask bitmap
 162 // Note that wxImageList creates new bitmaps, so you may delete
 163 // 'bitmap'.
 164 int wxImageList::Add(const wxBitmap& bitmap, const wxColour& maskColour)
 165 {
 166 #ifdef __TWIN32__
 167     wxFAIL_MSG(_T("ImageList_AddMasked not implemented in TWIN32"));
 168     return -1;
 169 #else
 170     int index = ImageList_AddMasked(GetHImageList(),
 171                                     GetHbitmapOf(bitmap),
 172                                     wxColourToRGB(maskColour));
 173     if ( index == -1 )
 174     {
 175         wxLogError(_("Couldn't add an image to the image list."));
 176     }
 177
 178     return index;
 179 #endif
 180 }
 181
 182 // Adds a bitmap and mask from an icon.
 183 int wxImageList::Add(const wxIcon& icon)
 184 {
 185     int index = ImageList_AddIcon(GetHImageList(), GetHiconOf(icon));
 186     if ( index == -1 )
 187     {
 188         wxLogError(_("Couldn't add an image to the image list."));
 189     }
 190
 191     return index;
 192 }
 193
 194 // Replaces a bitmap, optionally passing a mask bitmap.
 195 // Note that wxImageList creates new bitmaps, so you may delete
 196 // 'bitmap' and 'mask'.
 197 bool wxImageList::Replace(int index,
 198                           const wxBitmap& bitmap, const wxBitmap& mask)
 199 {
 200 #ifdef __TWIN32__
 201     wxFAIL_MSG(_T("ImageList_Replace not implemented in TWIN32"));
 202     return FALSE;
 203 #else
 204     wxBitmap bmpMask = GetMaskForImage(bitmap, mask);
 205     HBITMAP hbmpMask = wxInvertMask(GetHbitmapOf(bmpMask));
 206
 207     bool ok = ImageList_Replace(GetHImageList(), index,
 208                                 GetHbitmapOf(bitmap), hbmpMask) != 0;
 209     if ( !ok )
 210     {
 211         wxLogLastError(wxT("ImageList_Add()"));
 212     }
 213
 214     ::DeleteObject(hbmpMask);
 215
 216     return ok;
 217 #endif
 218 }
 219
 220 // Replaces a bitmap and mask from an icon.
 221 bool wxImageList::Replace(int i, const wxIcon& icon)
 222 {
 223     bool ok = ImageList_ReplaceIcon(GetHImageList(), i, GetHiconOf(icon)) != 0;
 224     if ( !ok )
 225     {
 226         wxLogLastError(wxT("ImageList_ReplaceIcon()"));
 227     }
 228
 229     return ok;
 230 }
 231
 232 // Removes the image at the given index.
 233 bool wxImageList::Remove(int index)
 234 {
 235 #ifdef __TWIN32__
 236     wxFAIL_MSG(_T("ImageList_Replace not implemented in TWIN32"));
 237     return FALSE;
 238 #else
 239     bool ok = ImageList_Remove(GetHImageList(), index) != 0;
 240     if ( !ok )
 241     {
 242         wxLogLastError(wxT("ImageList_Remove()"));
 243     }
 244
 245     return ok;
 246 #endif
 247 }
 248
 249 // Remove all images
 250 bool wxImageList::RemoveAll()
 251 {
 252     // don't use ImageList_RemoveAll() because mingw32 headers don't have it
 253     int count = ImageList_GetImageCount(GetHImageList());
 254     for ( int i = 0; i < count; i++ )
 255     {
 256         // the image indexes are shifted, so we should always remove the first
 257         // one
 258         (void)Remove(0);
 259     }
 260
 261     return TRUE;
 262 }
 263
 264 // Draws the given image on a dc at the specified position.
 265 // If 'solidBackground' is TRUE, Draw sets the image list background
 266 // colour to the background colour of the wxDC, to speed up
 267 // drawing by eliminating masked drawing where possible.
 268 bool wxImageList::Draw(int index,
 269                        wxDC& dc,
 270                        int x, int y,
 271                        int flags,
 272                        bool solidBackground)
 273 {
 274 #ifdef __TWIN32__
 275     wxFAIL_MSG(_T("ImageList_Replace not implemented in TWIN32"));
 276     return FALSE;
 277 #else
 278     HDC hDC = GetHdcOf(dc);
 279     wxCHECK_MSG( hDC, FALSE, _T("invalid wxDC in wxImageList::Draw") );
 280
 281     COLORREF clr = CLR_NONE;    // transparent by default
 282     if ( solidBackground )
 283     {
 284         wxBrush *brush = & dc.GetBackground();
 285         if ( brush && brush->Ok() )
 286         {
 287             clr = wxColourToRGB(brush->GetColour());
 288         }
 289     }
 290
 291     ImageList_SetBkColor(GetHImageList(), clr);
 292
 293     UINT style = 0;
 294     if ( flags & wxIMAGELIST_DRAW_NORMAL )
 295         style |= ILD_NORMAL;
 296     if ( flags & wxIMAGELIST_DRAW_TRANSPARENT )
 297         style |= ILD_TRANSPARENT;
 298     if ( flags & wxIMAGELIST_DRAW_SELECTED )
 299         style |= ILD_SELECTED;
 300     if ( flags & wxIMAGELIST_DRAW_FOCUSED )
 301         style |= ILD_FOCUS;
 302
 303     bool ok = ImageList_Draw(GetHImageList(), index, hDC, x, y, style) != 0;
 304     if ( !ok )
 305     {
 306         wxLogLastError(wxT("ImageList_Draw()"));
 307     }
 308
 309     return ok;
 310 #endif
 311 }
 312
 313 // ----------------------------------------------------------------------------
 314 // helpers
 315 // ----------------------------------------------------------------------------
 316
 317 static wxBitmap GetMaskForImage(const wxBitmap& bitmap, const wxBitmap& mask)
 318 {
 319     wxBitmap bmpMask;
 320
 321     if ( mask.Ok() )
 322     {
 323         bmpMask = mask;
 324     }
 325     else
 326     {
 327         wxMask *pMask = bitmap.GetMask();
 328         if ( pMask )
 329         {
 330             bmpMask.SetHBITMAP(pMask->GetMaskBitmap());
 331         }
 332     }
 333
 334     if ( !bmpMask.Ok() )
 335     {
 336         // create a non transparent mask - apparently, this is needed under
 337         // Win9x (it doesn't behave correctly if it's passed 0 mask)
 338         bmpMask.Create(bitmap.GetWidth(), bitmap.GetHeight(), 1);
 339
 340         wxMemoryDC dcMem;
 341         dcMem.SelectObject(bmpMask);
 342         dcMem.Clear();
 343         dcMem.SelectObject(wxNullBitmap);
 344     }
 345
 346     return bmpMask;
 347 }
 348
 349 #endif // Win95
 350