return begining of the selection for GetInsertionPoint to match what

[wxWidgets.git] / src / msw / imaglist.cpp

diff --git a/src/msw/imaglist.cpp b/src/msw/imaglist.cpp
index 4cd16e46c2ae1ed67645240178ff2408ffd0cfa1..785a18c637274512ec79dd1400f007fbb81e7450 100644 (file)
--- a/src/msw/imaglist.cpp
+++ b/src/msw/imaglist.cpp
@@ -5,8 +5,8 @@
 // Modified by:
 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Modified by:
 // Created:     04/01/98
 // RCS-ID:      $Id$

-// Copyright:   (c) Julian Smart and Markus Holzem
-// Licence:     wxWindows license
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================


@@ -17,7 +17,7 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)

     #pragma implementation "imaglist.h"
 #endif
 
     #pragma implementation "imaglist.h"
 #endif
 


@@ -42,11 +42,12 @@
 
 #include "wx/log.h"
 #include "wx/intl.h"
 
 #include "wx/log.h"
 #include "wx/intl.h"

+#include "wx/image.h"

 
 #include "wx/msw/imaglist.h"
 #include "wx/msw/private.h"
 
 
 #include "wx/msw/imaglist.h"
 #include "wx/msw/private.h"
 

-#if !defined(__GNUWIN32_OLD__) && !defined(__TWIN32__)
+#if defined(__WIN95__) && !(defined(__GNUWIN32_OLD__) && !defined(__CYGWIN10__))

     #include <commctrl.h>
 #endif
 
     #include <commctrl.h>
 #endif
 


@@ -64,7 +65,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxImageList, wxObject)
 
 // returns the mask if it's valid, otherwise the bitmap mask and, if it's not
 // valid neither, a "solid" mask (no transparent zones at all)
 
 // returns the mask if it's valid, otherwise the bitmap mask and, if it's not
 // valid neither, a "solid" mask (no transparent zones at all)

-static wxBitmap GetMaskForImage(const wxBitmap& bitmap, const wxBitmap& mask);
+static HBITMAP GetMaskForImage(const wxBitmap& bitmap, const wxBitmap& mask);

 
 // ============================================================================
 // implementation
 
 // ============================================================================
 // implementation


@@ -82,7 +83,21 @@ wxImageList::wxImageList()
 // Creates an image list
 bool wxImageList::Create(int width, int height, bool mask, int initial)
 {
 // Creates an image list
 bool wxImageList::Create(int width, int height, bool mask, int initial)
 {

-    UINT flags = 0; // TODO shouldallow to specify ILC_COLORxxx here
+    UINT flags = 0;
+
+    // set appropriate color depth
+#ifdef __WXWINCE__
+    flags |= ILC_COLOR;
+#else
+    int dd = wxDisplayDepth();
+
+    if (dd <= 4)       flags |= ILC_COLOR;   // 16 color
+    else if (dd <= 8)  flags |= ILC_COLOR8;  // 256 color
+    else if (dd <= 16) flags |= ILC_COLOR16; // 64k hi-color
+    else if (dd <= 24) flags |= ILC_COLOR24; // 16m truecolor
+    else if (dd <= 32) flags |= ILC_COLOR32; // 16m truecolor
+#endif
+

     if ( mask )
         flags |= ILC_MASK;
 
     if ( mask )
         flags |= ILC_MASK;
 


@@ -91,7 +106,7 @@ bool wxImageList::Create(int width, int height, bool mask, int initial)
                                                    initial, 1);
     if ( !m_hImageList )
     {
                                                    initial, 1);
     if ( !m_hImageList )
     {

-        wxLogLastError("ImageList_Create()");
+        wxLogLastError(wxT("ImageList_Create()"));

     }
 
     return m_hImageList != 0;
     }
 
     return m_hImageList != 0;


@@ -118,6 +133,14 @@ int wxImageList::GetImageCount() const
     return ImageList_GetImageCount(GetHImageList());
 }
 
     return ImageList_GetImageCount(GetHImageList());
 }
 

+// Returns the size (same for all images) of the images in the list
+bool wxImageList::GetSize(int WXUNUSED(index), int &width, int &height) const
+{
+    wxASSERT_MSG( m_hImageList, _T("invalid image list") );
+
+    return ImageList_GetIconSize(GetHImageList(), &width, &height) != 0;
+}
+

 // ----------------------------------------------------------------------------
 // wxImageList operations
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxImageList operations
 // ----------------------------------------------------------------------------


@@ -127,8 +150,7 @@ int wxImageList::GetImageCount() const
 // 'bitmap' and 'mask'.
 int wxImageList::Add(const wxBitmap& bitmap, const wxBitmap& mask)
 {
 // 'bitmap' and 'mask'.
 int wxImageList::Add(const wxBitmap& bitmap, const wxBitmap& mask)
 {

-    wxBitmap bmpMask = GetMaskForImage(bitmap, mask);
-    HBITMAP hbmpMask = wxInvertMask(GetHbitmapOf(bmpMask));
+    HBITMAP hbmpMask = GetMaskForImage(bitmap, mask);

 
     int index = ImageList_Add(GetHImageList(), GetHbitmapOf(bitmap), hbmpMask);
     if ( index == -1 )
 
     int index = ImageList_Add(GetHImageList(), GetHbitmapOf(bitmap), hbmpMask);
     if ( index == -1 )


@@ -146,10 +168,6 @@ int wxImageList::Add(const wxBitmap& bitmap, const wxBitmap& mask)
 // 'bitmap'.
 int wxImageList::Add(const wxBitmap& bitmap, const wxColour& maskColour)
 {
 // 'bitmap'.
 int wxImageList::Add(const wxBitmap& bitmap, const wxColour& maskColour)
 {

-#ifdef __TWIN32__
-    wxFAIL_MSG(_T("ImageList_AddMasked not implemented in TWIN32"));
-    return -1;
-#else

     int index = ImageList_AddMasked(GetHImageList(),
                                     GetHbitmapOf(bitmap),
                                     wxColourToRGB(maskColour));
     int index = ImageList_AddMasked(GetHImageList(),
                                     GetHbitmapOf(bitmap),
                                     wxColourToRGB(maskColour));


@@ -159,7 +177,6 @@ int wxImageList::Add(const wxBitmap& bitmap, const wxColour& maskColour)
     }
 
     return index;
     }
 
     return index;

-#endif

 }
 
 // Adds a bitmap and mask from an icon.
 }
 
 // Adds a bitmap and mask from an icon.


@@ -180,24 +197,18 @@ int wxImageList::Add(const wxIcon& icon)
 bool wxImageList::Replace(int index,
                           const wxBitmap& bitmap, const wxBitmap& mask)
 {
 bool wxImageList::Replace(int index,
                           const wxBitmap& bitmap, const wxBitmap& mask)
 {

-#ifdef __TWIN32__
-    wxFAIL_MSG(_T("ImageList_Replace not implemented in TWIN32"));
-    return FALSE;
-#else
-    wxBitmap bmpMask = GetMaskForImage(bitmap, mask);
-    HBITMAP hbmpMask = wxInvertMask(GetHbitmapOf(bmpMask));
+    HBITMAP hbmpMask = GetMaskForImage(bitmap, mask);

 
     bool ok = ImageList_Replace(GetHImageList(), index,
                                 GetHbitmapOf(bitmap), hbmpMask) != 0;
     if ( !ok )
     {
 
     bool ok = ImageList_Replace(GetHImageList(), index,
                                 GetHbitmapOf(bitmap), hbmpMask) != 0;
     if ( !ok )
     {

-        wxLogLastError("ImageList_Add()");
+        wxLogLastError(wxT("ImageList_Add()"));

     }
 
     ::DeleteObject(hbmpMask);
 
     return ok;
     }
 
     ::DeleteObject(hbmpMask);
 
     return ok;

-#endif

 }
 
 // Replaces a bitmap and mask from an icon.
 }
 
 // Replaces a bitmap and mask from an icon.


@@ -206,7 +217,7 @@ bool wxImageList::Replace(int i, const wxIcon& icon)
     bool ok = ImageList_ReplaceIcon(GetHImageList(), i, GetHiconOf(icon)) != 0;
     if ( !ok )
     {
     bool ok = ImageList_ReplaceIcon(GetHImageList(), i, GetHiconOf(icon)) != 0;
     if ( !ok )
     {

-        wxLogLastError("ImageList_ReplaceIcon()");
+        wxLogLastError(wxT("ImageList_ReplaceIcon()"));

     }
 
     return ok;
     }
 
     return ok;


@@ -215,34 +226,32 @@ bool wxImageList::Replace(int i, const wxIcon& icon)
 // Removes the image at the given index.
 bool wxImageList::Remove(int index)
 {
 // Removes the image at the given index.
 bool wxImageList::Remove(int index)
 {

-#ifdef __TWIN32__
-    wxFAIL_MSG(_T("ImageList_Replace not implemented in TWIN32"));
-    return FALSE;
-#else

     bool ok = ImageList_Remove(GetHImageList(), index) != 0;
     if ( !ok )
     {
     bool ok = ImageList_Remove(GetHImageList(), index) != 0;
     if ( !ok )
     {

-        wxLogLastError("ImageList_Remove()");
+        wxLogLastError(wxT("ImageList_Remove()"));

     }
 
     return ok;
     }
 
     return ok;

-#endif

 }
 
 // Remove all images
 bool wxImageList::RemoveAll()
 {
 }
 
 // Remove all images
 bool wxImageList::RemoveAll()
 {

-    bool ok = ImageList_RemoveAll(GetHImageList()) != 0;
-    if ( !ok )
+    // don't use ImageList_RemoveAll() because mingw32 headers don't have it
+    int count = ImageList_GetImageCount(GetHImageList());
+    for ( int i = 0; i < count; i++ )

     {
     {

-        wxLogLastError("ImageList_RemoveAll()");
+        // the image indexes are shifted, so we should always remove the first
+        // one
+        (void)Remove(0);

     }
 
     }
 

-    return ok;
+    return true;

 }
 
 // Draws the given image on a dc at the specified position.
 }
 
 // Draws the given image on a dc at the specified position.

-// If 'solidBackground' is TRUE, Draw sets the image list background
+// If 'solidBackground' is true, Draw sets the image list background

 // colour to the background colour of the wxDC, to speed up
 // drawing by eliminating masked drawing where possible.
 bool wxImageList::Draw(int index,
 // colour to the background colour of the wxDC, to speed up
 // drawing by eliminating masked drawing where possible.
 bool wxImageList::Draw(int index,


@@ -251,20 +260,16 @@ bool wxImageList::Draw(int index,
                        int flags,
                        bool solidBackground)
 {
                        int flags,
                        bool solidBackground)
 {

-#ifdef __TWIN32__
-    wxFAIL_MSG(_T("ImageList_Replace not implemented in TWIN32"));
-    return FALSE;
-#else

     HDC hDC = GetHdcOf(dc);
     HDC hDC = GetHdcOf(dc);

-    wxCHECK_MSG( hDC, FALSE, _T("invalid wxDC in wxImageList::Draw") );
+    wxCHECK_MSG( hDC, false, _T("invalid wxDC in wxImageList::Draw") );

 
     COLORREF clr = CLR_NONE;    // transparent by default
     if ( solidBackground )
     {
 
     COLORREF clr = CLR_NONE;    // transparent by default
     if ( solidBackground )
     {

-        wxBrush *brush = & dc.GetBackground();
-        if ( brush && brush->Ok() )
+        const wxBrush& brush = dc.GetBackground();
+        if ( brush.Ok() )

         {
         {

-            clr = wxColourToRGB(brush->GetColour());
+            clr = wxColourToRGB(brush.GetColour());

         }
     }
 
         }
     }
 


@@ -283,47 +288,112 @@ bool wxImageList::Draw(int index,
     bool ok = ImageList_Draw(GetHImageList(), index, hDC, x, y, style) != 0;
     if ( !ok )
     {
     bool ok = ImageList_Draw(GetHImageList(), index, hDC, x, y, style) != 0;
     if ( !ok )
     {

-        wxLogLastError("ImageList_Draw()");
+        wxLogLastError(wxT("ImageList_Draw()"));

     }
 
     return ok;
     }
 
     return ok;

-#endif
+}
+
+// Get the bitmap
+wxBitmap wxImageList::GetBitmap(int index) const
+{
+    int bmp_width = 0, bmp_height = 0;
+    GetSize(index, bmp_width, bmp_height);
+
+    wxBitmap bitmap(bmp_width, bmp_height);
+    wxMemoryDC dc;
+    dc.SelectObject(bitmap);
+
+    // draw it the first time to find a suitable mask colour
+    ((wxImageList*)this)->Draw(index, dc, 0, 0, wxIMAGELIST_DRAW_TRANSPARENT);
+    dc.SelectObject(wxNullBitmap);
+
+    // find the suitable mask colour
+    wxImage image = bitmap.ConvertToImage();
+    unsigned char r = 0, g = 0, b = 0;
+    image.FindFirstUnusedColour(&r, &g, &b);
+
+    // redraw whole image and bitmap in the mask colour
+    image.Create(bmp_width, bmp_height);
+    image.Replace(0, 0, 0, r, g, b);
+    bitmap = wxBitmap(image);
+
+    // redraw icon over the mask colour to actually draw it
+    dc.SelectObject(bitmap);
+    ((wxImageList*)this)->Draw(index, dc, 0, 0, wxIMAGELIST_DRAW_TRANSPARENT);
+    dc.SelectObject(wxNullBitmap);
+
+    // get the image, set the mask colour and convert back to get transparent bitmap
+    image = bitmap.ConvertToImage();
+    image.SetMaskColour(r, g, b);
+    bitmap = wxBitmap(image);
+    
+    return bitmap;
+}
+
+// Get the icon
+wxIcon wxImageList::GetIcon(int index) const
+{
+    HICON hIcon = ImageList_ExtractIcon(0, GetHImageList(), index);
+    if (hIcon)
+    {
+        wxIcon icon;
+        icon.SetHICON((WXHICON)hIcon);
+        
+        int iconW, iconH;
+        GetSize(index, iconW, iconH);
+        icon.SetSize(iconW, iconH);
+        
+        return icon;
+    }
+    else               
+        return wxNullIcon;

 }
 
 // ----------------------------------------------------------------------------
 // helpers
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // helpers
 // ----------------------------------------------------------------------------
 

-static wxBitmap GetMaskForImage(const wxBitmap& bitmap, const wxBitmap& mask)
+static HBITMAP GetMaskForImage(const wxBitmap& bitmap, const wxBitmap& mask)

 {
 {

-    wxBitmap bmpMask;
+    HBITMAP hbmpMask;
+    wxMask *pMask;
+    bool deleteMask = false;

 
     if ( mask.Ok() )
     {
 
     if ( mask.Ok() )
     {

-        bmpMask = mask;
+        hbmpMask = GetHbitmapOf(mask);
+        pMask = NULL;

     }
     else
     {
     }
     else
     {

-        wxMask *pMask = bitmap.GetMask();
-        if ( pMask )
+        pMask = bitmap.GetMask();
+        if ( !pMask )

         {
         {

-            bmpMask.SetHBITMAP(pMask->GetMaskBitmap());
+            // use the light grey count as transparent: the trouble here is
+            // that the light grey might have been changed by Windows behind
+            // our back, so use the standard colour map to get its real value
+            wxCOLORMAP *cmap = wxGetStdColourMap();
+            wxColour col;
+            wxRGBToColour(col, cmap[wxSTD_COL_BTNFACE].from);
+
+            pMask = new wxMask(bitmap, col);
+
+            deleteMask = true;

         }
         }

+
+        hbmpMask = (HBITMAP)pMask->GetMaskBitmap();

     }
 
     }
 

-    if ( !bmpMask.Ok() )
+    // windows mask convention is opposite to the wxWidgets one
+    HBITMAP hbmpMaskInv = wxInvertMask(hbmpMask);
+
+    if ( deleteMask )

     {
     {

-        // create a non transparent mask - apparently, this is needed under
-        // Win9x (it doesn't behave correctly if it's passed 0 mask)
-        bmpMask.Create(bitmap.GetWidth(), bitmap.GetHeight(), 1);
-
-        wxMemoryDC dcMem;
-        dcMem.SelectObject(bmpMask);
-        dcMem.Clear();
-        dcMem.SelectObject(wxNullBitmap);
+        delete pMask;

     }
 
     }
 

-    return bmpMask;
+    return hbmpMaskInv;

 }
 
 #endif // Win95
 }
 
 #endif // Win95