supporting promised file urls for transfer, see #14281

[wxWidgets.git] / src / common / iconbndl.cpp

diff --git a/src/common/iconbndl.cpp b/src/common/iconbndl.cpp
index 479c5dd27ccf08b3788221879a7c860970fc5dc9..d589943453e98af4d6057971c3f09bee82d56d69 100644 (file)
--- a/src/common/iconbndl.cpp
+++ b/src/common/iconbndl.cpp
@@ -1,17 +1,13 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        iconbndl.cpp
+// Name:        src/common/iconbndl.cpp

 // Purpose:     wxIconBundle
 // Purpose:     wxIconBundle

-// Author:      Mattia Barbon
+// Author:      Mattia Barbon, Vadim Zeitlin

 // Created:     23.03.2002
 // RCS-ID:      $Id$
 // Copyright:   (c) Mattia barbon
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Created:     23.03.2002
 // RCS-ID:      $Id$
 // Copyright:   (c) Mattia barbon
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

-#ifdef __GNUG__
-    #pragma implementation "iconbndl.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 


@@ -19,99 +15,314 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

+#include "wx/iconbndl.h"
+

 #ifndef WX_PRECOMP
     #include "wx/settings.h"
 #ifndef WX_PRECOMP
     #include "wx/settings.h"

-    #include "wx/icon.h"

     #include "wx/log.h"
     #include "wx/intl.h"
     #include "wx/log.h"
     #include "wx/intl.h"

-#endif
-
-#ifndef _WX_IMAGE_H_
+    #include "wx/bitmap.h"

     #include "wx/image.h"
     #include "wx/image.h"

+    #include "wx/stream.h"

 #endif
 
 #endif
 

-#include "wx/iconbndl.h"
-#include "wx/arrimpl.cpp"
+#include "wx/wfstream.h"

 
 

+#include "wx/arrimpl.cpp"

 WX_DEFINE_OBJARRAY(wxIconArray)
 
 WX_DEFINE_OBJARRAY(wxIconArray)
 

-const wxIconBundle& wxIconBundle::operator =( const wxIconBundle& ic )
+IMPLEMENT_DYNAMIC_CLASS(wxIconBundle, wxGDIObject)
+
+#define M_ICONBUNDLEDATA static_cast<wxIconBundleRefData*>(m_refData)
+
+// ----------------------------------------------------------------------------
+// wxIconBundleRefData
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxIconBundleRefData : public wxGDIRefData
+{
+public:
+    wxIconBundleRefData() { }
+
+    // We need the copy ctor for CloneGDIRefData() but notice that we use the
+    // base class default ctor in it and not the copy one which it doesn't have.
+    wxIconBundleRefData(const wxIconBundleRefData& other)
+        : wxGDIRefData(),
+          m_icons(other.m_icons)
+    {
+    }
+
+    // default assignment operator and dtor are ok
+
+    virtual bool IsOk() const { return !m_icons.empty(); }
+
+    wxIconArray m_icons;
+};
+
+// ============================================================================
+// wxIconBundle implementation
+// ============================================================================
+
+wxIconBundle::wxIconBundle()
+{
+}
+
+#if wxUSE_STREAMS && wxUSE_IMAGE
+
+#if wxUSE_FFILE || wxUSE_FILE
+wxIconBundle::wxIconBundle(const wxString& file, wxBitmapType type)
+            : wxGDIObject()
+{
+    AddIcon(file, type);
+}
+#endif // wxUSE_FFILE || wxUSE_FILE
+
+wxIconBundle::wxIconBundle(wxInputStream& stream, wxBitmapType type)
+            : wxGDIObject()

 {
 {

-    if( this == &ic ) return *this;
+    AddIcon(stream, type);
+}
+#endif // wxUSE_STREAMS && wxUSE_IMAGE

 
 

-    size_t i, max = ic.m_icons.GetCount();
+wxIconBundle::wxIconBundle(const wxIcon& icon)
+            : wxGDIObject()
+{
+    AddIcon(icon);
+}

 
 

-    DeleteIcons();
-    for( i = 0; i < max; ++i )
-        m_icons.Add( ic.m_icons[i] );
+wxGDIRefData *wxIconBundle::CreateGDIRefData() const
+{
+    return new wxIconBundleRefData;
+}

 
 

-    return *this;
+wxGDIRefData *wxIconBundle::CloneGDIRefData(const wxGDIRefData *data) const
+{
+    return new wxIconBundleRefData(*static_cast<const wxIconBundleRefData *>(data));

 }
 
 void wxIconBundle::DeleteIcons()
 {
 }
 
 void wxIconBundle::DeleteIcons()
 {

-    m_icons.Empty();
+    UnRef();

 }
 
 }
 

-void wxIconBundle::AddIcon( const wxString& file, long type )
+#if wxUSE_STREAMS && wxUSE_IMAGE
+
+namespace
+{
+
+// Adds icon from 'input' to the bundle. Shows 'errorMessage' on failure
+// (it must contain "%d", because it is used to report # of image in the file
+// that failed to load):
+void DoAddIcon(wxIconBundle& bundle,
+               wxInputStream& input,
+               wxBitmapType type,
+               const wxString& errorMessage)

 {
 {

-    size_t count = wxImage::GetImageCount( file, type );
-    size_t i;

     wxImage image;
     wxImage image;

-    wxIcon tmp;

 
 

-    for( i = 0; i < count; ++i )
+    const wxFileOffset posOrig = input.TellI();
+
+    const size_t count = wxImage::GetImageCount(input, type);
+    for ( size_t i = 0; i < count; ++i )

     {
     {

-        if( !image.LoadFile( file, type, i ) )
+        if ( i )
+        {
+            // the call to LoadFile() for the first sub-image updated the
+            // stream position but we need to start reading the subsequent
+            // sub-image at the image beginning too
+            input.SeekI(posOrig);
+        }
+
+        if ( !image.LoadFile(input, type, i) )

         {
         {

-            wxLogError( _("Failed to load image %d from file '%s'."),
-                        i, file.c_str() );
+            wxLogError(errorMessage, i);

             continue;
         }
 
             continue;
         }
 

-        tmp.CopyFromBitmap( wxBitmap( image ) );
-        AddIcon( tmp );
+        if ( type == wxBITMAP_TYPE_ANY )
+        {
+            // store the type so that we don't need to try all handlers again
+            // for the subsequent images, they should all be of the same type
+            type = image.GetType();
+        }
+
+        wxIcon tmp;
+        tmp.CopyFromBitmap(wxBitmap(image));
+        bundle.AddIcon(tmp);

     }
 }
 
     }
 }
 

-const wxIcon& wxIconBundle::GetIcon( const wxSize& size ) const
+} // anonymous namespace
+
+#if wxUSE_FFILE || wxUSE_FILE
+
+void wxIconBundle::AddIcon(const wxString& file, wxBitmapType type)

 {
 {

-    size_t i, max = m_icons.GetCount();
-    wxCoord sysX = wxSystemSettings::GetMetric( wxSYS_ICON_X ),
-            sysY = wxSystemSettings::GetMetric( wxSYS_ICON_Y );
-    wxIcon* sysIcon = 0;
+#ifdef __WXMAC__
+    // Deal with standard icons
+    if ( type == wxBITMAP_TYPE_ICON_RESOURCE )
+    {
+        wxIcon tmp(file, type);
+        if (tmp.IsOk())
+        {
+            AddIcon(tmp);
+            return;
+        }
+    }
+#endif // __WXMAC__
+
+#if wxUSE_FFILE
+    wxFFileInputStream stream(file);
+#elif wxUSE_FILE
+    wxFileInputStream stream(file);
+#endif
+    DoAddIcon
+    (
+        *this,
+        stream, type,
+        wxString::Format(_("Failed to load image %%d from file '%s'."), file)
+    );
+}
+
+#endif // wxUSE_FFILE || wxUSE_FILE
+
+void wxIconBundle::AddIcon(wxInputStream& stream, wxBitmapType type)
+{
+    DoAddIcon(*this, stream, type, _("Failed to load image %d from stream."));
+}
+
+#endif // wxUSE_STREAMS && wxUSE_IMAGE
+
+wxIcon wxIconBundle::GetIcon(const wxSize& size, int flags) const
+{
+    wxASSERT( size == wxDefaultSize || (size.x >= 0 && size.y > 0) );
+
+    // We need the standard system icon size when using FALLBACK_SYSTEM.
+    wxCoord sysX = 0,
+            sysY = 0;
+    if ( flags & FALLBACK_SYSTEM )
+    {
+        sysX = wxSystemSettings::GetMetric(wxSYS_ICON_X);
+        sysY = wxSystemSettings::GetMetric(wxSYS_ICON_Y);
+    }

 
 

-    for( i = 0; i < max; ++i )
+    // If size == wxDefaultSize, we use system default icon size by convention.
+    wxCoord sizeX = size.x;
+    wxCoord sizeY = size.y;
+    if ( size == wxDefaultSize )

     {
     {

-        wxCoord sx = m_icons[i].GetWidth(), sy = m_icons[i].GetHeight();
-        // requested size
-        if( sx == size.x && sy == size.y )
-            return m_icons[i];
-        // keep track if there is a system-size icon
-        if( sx == sysX && sy == sysY )
-            sysIcon = &m_icons[i];
+        wxASSERT_MSG( flags == FALLBACK_SYSTEM,
+                      wxS("Must have valid size if not using FALLBACK_SYSTEM") );
+
+        sizeX = sysX;
+        sizeY = sysY;

     }
 
     }
 

-    // return the system-sized icon if we've got one
-    if( sysIcon ) return *sysIcon;
-    // return the first icon, if we have one
-    return max > 0 ? m_icons[0] : wxNullIcon;
+    // Iterate over all icons searching for the exact match or the closest icon
+    // for FALLBACK_NEAREST_LARGER.
+    wxIcon iconBest;
+    int bestDiff = 0;
+    bool bestIsLarger = false;
+    bool bestIsSystem = false;
+
+    const size_t count = GetIconCount();
+
+    const wxIconArray& iconArray = M_ICONBUNDLEDATA->m_icons;
+    for ( size_t i = 0; i < count; i++ )
+    {
+        const wxIcon& icon = iconArray[i];
+        if ( !icon.IsOk() )
+            continue;
+        wxCoord sx = icon.GetWidth(),
+                sy = icon.GetHeight();
+
+        // Exact match ends search immediately in any case.
+        if ( sx == sizeX && sy == sizeY )
+        {
+            iconBest = icon;
+            break;
+        }
+
+        if ( flags & FALLBACK_SYSTEM )
+        {
+            if ( sx == sysX && sy == sysY )
+            {
+                iconBest = icon;
+                bestIsSystem = true;
+                continue;
+            }
+        }
+
+        if ( !bestIsSystem && (flags & FALLBACK_NEAREST_LARGER) )
+        {
+            bool iconLarger = (sx >= sizeX) && (sy >= sizeY);
+            int iconDiff = abs(sx - sizeX) + abs(sy - sizeY);
+
+            // Use current icon as candidate for the best icon, if either:
+            // - we have no candidate yet
+            // - we have no candidate larger than desired size and current icon is
+            // - current icon is closer to desired size than candidate
+            if ( !iconBest.IsOk() ||
+                    (!bestIsLarger && iconLarger) ||
+                        (iconLarger && (iconDiff < bestDiff)) )
+            {
+                iconBest = icon;
+                bestIsLarger = iconLarger;
+                bestDiff = iconDiff;
+                continue;
+            }
+        }
+    }
+
+#if defined( __WXMAC__ ) && wxOSX_USE_CARBON
+    if (!iconBest.IsOk())
+        return wxNullIcon;
+
+    return wxIcon(iconBest.GetHICON(), size);
+#else
+    return iconBest;
+#endif

 }
 
 }
 

-void wxIconBundle::AddIcon( const wxIcon& icon )
+wxIcon wxIconBundle::GetIconOfExactSize(const wxSize& size) const

 {
 {

-    size_t i, max = m_icons.GetCount();
+    return GetIcon(size, FALLBACK_NONE);
+}

 
 

-    for( i = 0; i < max; ++i )
+void wxIconBundle::AddIcon(const wxIcon& icon)
+{
+    wxCHECK_RET( icon.IsOk(), wxT("invalid icon") );
+
+    AllocExclusive();
+
+    wxIconArray& iconArray = M_ICONBUNDLEDATA->m_icons;
+
+    // replace existing icon with the same size if we already have it
+    const size_t count = iconArray.size();
+    for ( size_t i = 0; i < count; ++i )

     {
     {

-        wxIcon& tmp = m_icons[i];
-        if( tmp.GetWidth() == icon.GetWidth() &&
-            tmp.GetHeight() == icon.GetHeight() )
+        wxIcon& tmp = iconArray[i];
+        if ( tmp.IsOk() &&
+                tmp.GetWidth() == icon.GetWidth() &&
+                tmp.GetHeight() == icon.GetHeight() )

         {
             tmp = icon;
             return;
         }
     }
 
         {
             tmp = icon;
             return;
         }
     }
 

-    m_icons.Add( icon );
+    // if we don't, add an icon with new size
+    iconArray.Add(icon);
+}
+
+size_t wxIconBundle::GetIconCount() const
+{
+    return IsOk() ? M_ICONBUNDLEDATA->m_icons.size() : 0;
+}
+
+wxIcon wxIconBundle::GetIconByIndex(size_t n) const
+{
+    wxCHECK_MSG( n < GetIconCount(), wxNullIcon, wxT("invalid index") );
+
+    return M_ICONBUNDLEDATA->m_icons[n];

 }
 }