#include "wx/msw/dib.h"
#endif
+// By default, use PNG resource handler if we can, i.e. have support for
+// loading PNG images in the library. This symbol could be predefined as 0 to
+// avoid doing this if anybody ever needs to do it for some reason.
+#if !defined(wxUSE_PNG_RESOURCE_HANDLER) && wxUSE_LIBPNG && wxUSE_IMAGE
+ #define wxUSE_PNG_RESOURCE_HANDLER 1
+#endif
+
+#if wxUSE_PNG_RESOURCE_HANDLER
+ #include "wx/image.h"
+ #include "wx/utils.h" // For wxLoadUserResource()
+#endif
+
#ifdef __WXWINCE__
#include <winreg.h>
#include <shellapi.h>
class WXDLLEXPORT wxBMPFileHandler : public wxBitmapHandler
{
public:
- wxBMPFileHandler() : wxBitmapHandler(_T("Windows bitmap file"), _T("bmp"),
+ wxBMPFileHandler() : wxBitmapHandler(wxT("Windows bitmap file"), wxT("bmp"),
wxBITMAP_TYPE_BMP)
{
}
virtual bool LoadFile(wxBitmap *bitmap,
- const wxString& name, long flags,
+ const wxString& name, wxBitmapType flags,
int desiredWidth, int desiredHeight);
- virtual bool SaveFile(wxBitmap *bitmap,
- const wxString& name, int type,
- const wxPalette *palette = NULL);
+ virtual bool SaveFile(const wxBitmap *bitmap,
+ const wxString& name, wxBitmapType type,
+ const wxPalette *palette = NULL) const;
private:
DECLARE_DYNAMIC_CLASS(wxBMPFileHandler)
class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
{
public:
- wxBMPResourceHandler() : wxBitmapHandler(_T("Windows bitmap resource"),
+ wxBMPResourceHandler() : wxBitmapHandler(wxT("Windows bitmap resource"),
wxEmptyString,
wxBITMAP_TYPE_BMP_RESOURCE)
{
}
virtual bool LoadFile(wxBitmap *bitmap,
- const wxString& name, long flags,
+ const wxString& name, wxBitmapType flags,
int desiredWidth, int desiredHeight);
private:
class WXDLLEXPORT wxIconHandler : public wxGDIImageHandler
{
public:
- wxIconHandler(const wxString& name, const wxString& ext, long type)
+ wxIconHandler(const wxString& name, const wxString& ext, wxBitmapType type)
: wxGDIImageHandler(name, ext, type)
{
}
// creating and saving icons is not supported
virtual bool Create(wxGDIImage *WXUNUSED(image),
const void* WXUNUSED(data),
- long WXUNUSED(flags),
+ wxBitmapType WXUNUSED(flags),
int WXUNUSED(width),
int WXUNUSED(height),
int WXUNUSED(depth) = 1)
return false;
}
- virtual bool Save(wxGDIImage *WXUNUSED(image),
+ virtual bool Save(const wxGDIImage *WXUNUSED(image),
const wxString& WXUNUSED(name),
- int WXUNUSED(type))
+ wxBitmapType WXUNUSED(type)) const
{
return false;
}
virtual bool Load(wxGDIImage *image,
const wxString& name,
- long flags,
+ wxBitmapType flags,
int desiredWidth, int desiredHeight)
{
wxIcon *icon = wxDynamicCast(image, wxIcon);
- wxCHECK_MSG( icon, false, _T("wxIconHandler only works with icons") );
+ wxCHECK_MSG( icon, false, wxT("wxIconHandler only works with icons") );
return LoadIcon(icon, name, flags, desiredWidth, desiredHeight);
}
protected:
virtual bool LoadIcon(wxIcon *icon,
- const wxString& name, long flags,
+ const wxString& name, wxBitmapType flags,
int desiredWidth = -1, int desiredHeight = -1) = 0;
};
class WXDLLEXPORT wxICOFileHandler : public wxIconHandler
{
public:
- wxICOFileHandler() : wxIconHandler(_T("ICO icon file"),
- _T("ico"),
+ wxICOFileHandler() : wxIconHandler(wxT("ICO icon file"),
+ wxT("ico"),
wxBITMAP_TYPE_ICO)
{
}
protected:
virtual bool LoadIcon(wxIcon *icon,
- const wxString& name, long flags,
+ const wxString& name, wxBitmapType flags,
int desiredWidth = -1, int desiredHeight = -1);
private:
class WXDLLEXPORT wxICOResourceHandler: public wxIconHandler
{
public:
- wxICOResourceHandler() : wxIconHandler(_T("ICO resource"),
- _T("ico"),
+ wxICOResourceHandler() : wxIconHandler(wxT("ICO resource"),
+ wxT("ico"),
wxBITMAP_TYPE_ICO_RESOURCE)
{
}
protected:
virtual bool LoadIcon(wxIcon *icon,
- const wxString& name, long flags,
+ const wxString& name, wxBitmapType flags,
int desiredWidth = -1, int desiredHeight = -1);
private:
DECLARE_DYNAMIC_CLASS(wxICOResourceHandler)
};
+#if wxUSE_PNG_RESOURCE_HANDLER
+
+class WXDLLEXPORT wxPNGResourceHandler : public wxBitmapHandler
+{
+public:
+ wxPNGResourceHandler() : wxBitmapHandler(wxS("Windows PNG resource"),
+ wxString(),
+ wxBITMAP_TYPE_PNG_RESOURCE)
+ {
+ }
+
+ virtual bool LoadFile(wxBitmap *bitmap,
+ const wxString& name, wxBitmapType flags,
+ int desiredWidth, int desiredHeight);
+
+private:
+ wxDECLARE_DYNAMIC_CLASS(wxPNGResourceHandler);
+};
+
+#endif // wxUSE_PNG_RESOURCE_HANDLER
+
// ----------------------------------------------------------------------------
// wxWin macros
// ----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxObject)
+#if wxUSE_PNG_RESOURCE_HANDLER
+IMPLEMENT_DYNAMIC_CLASS(wxPNGResourceHandler, wxBitmapHandler)
+#endif // wxUSE_PNG_RESOURCE_HANDLER
// ----------------------------------------------------------------------------
// private functions
#ifndef __WXMICROWIN__
AddHandler(new wxBMPResourceHandler);
AddHandler(new wxBMPFileHandler);
- AddHandler(new wxICOResourceHandler);
AddHandler(new wxICOFileHandler);
+ AddHandler(new wxICOResourceHandler);
+#if wxUSE_PNG_RESOURCE_HANDLER
+ AddHandler(new wxPNGResourceHandler);
+#endif // wxUSE_PNG_RESOURCE_HANDLER
#endif
}
// ----------------------------------------------------------------------------
bool wxBMPResourceHandler::LoadFile(wxBitmap *bitmap,
- const wxString& name, long WXUNUSED(flags),
+ const wxString& name, wxBitmapType WXUNUSED(flags),
int WXUNUSED(desiredWidth),
int WXUNUSED(desiredHeight))
{
// TODO: load colourmap.
- bitmap->SetHBITMAP((WXHBITMAP)::LoadBitmap(wxGetInstance(), name.wx_str()));
+ bitmap->SetHBITMAP((WXHBITMAP)::LoadBitmap(wxGetInstance(), name.t_str()));
- if ( !bitmap->Ok() )
+ if ( !bitmap->IsOk() )
{
// it's probably not found
wxLogError(wxT("Can't load bitmap '%s' from resources! Check .rc file."),
}
bool wxBMPFileHandler::LoadFile(wxBitmap *bitmap,
- const wxString& name, long WXUNUSED(flags),
+ const wxString& name, wxBitmapType WXUNUSED(flags),
int WXUNUSED(desiredWidth),
int WXUNUSED(desiredHeight))
{
#if wxUSE_WXDIB
- wxCHECK_MSG( bitmap, false, _T("NULL bitmap in LoadFile") );
+ wxCHECK_MSG( bitmap, false, wxT("NULL bitmap in LoadFile") );
wxDIB dib(name);
#endif
}
-bool wxBMPFileHandler::SaveFile(wxBitmap *bitmap,
+bool wxBMPFileHandler::SaveFile(const wxBitmap *bitmap,
const wxString& name,
- int WXUNUSED(type),
- const wxPalette * WXUNUSED(pal))
+ wxBitmapType WXUNUSED(type),
+ const wxPalette * WXUNUSED(pal)) const
{
#if wxUSE_WXDIB
- wxCHECK_MSG( bitmap, false, _T("NULL bitmap in SaveFile") );
+ wxCHECK_MSG( bitmap, false, wxT("NULL bitmap in SaveFile") );
wxDIB dib(*bitmap);
bool wxICOFileHandler::LoadIcon(wxIcon *icon,
const wxString& name,
- long WXUNUSED(flags),
+ wxBitmapType WXUNUSED(flags),
int desiredWidth, int desiredHeight)
{
icon->UnRef();
- // actual size
- wxSize size;
-
HICON hicon = NULL;
// Parse the filename: it may be of the form "filename;n" in order to
desiredHeight == ::GetSystemMetrics(SM_CYICON) )
{
// get the specified large icon from file
- if ( !::ExtractIconEx(nameReal.wx_str(), iconIndex, &hicon, NULL, 1) )
+ if ( !::ExtractIconEx(nameReal.t_str(), iconIndex, &hicon, NULL, 1) )
{
// it is not an error, but it might still be useful to be informed
// about it optionally
- wxLogTrace(_T("iconload"),
- _T("No large icons found in the file '%s'."),
+ wxLogTrace(wxT("iconload"),
+ wxT("No large icons found in the file '%s'."),
name.c_str());
}
}
desiredHeight == ::GetSystemMetrics(SM_CYSMICON) )
{
// get the specified small icon from file
- if ( !::ExtractIconEx(nameReal.wx_str(), iconIndex, NULL, &hicon, 1) )
+ if ( !::ExtractIconEx(nameReal.t_str(), iconIndex, NULL, &hicon, 1) )
{
- wxLogTrace(_T("iconload"),
- _T("No small icons found in the file '%s'."),
+ wxLogTrace(wxT("iconload"),
+ wxT("No small icons found in the file '%s'."),
name.c_str());
}
}
if ( !hicon )
{
// take any size icon from the file by index
- hicon = ::ExtractIcon(wxGetInstance(), nameReal.wx_str(), iconIndex);
+ hicon = ::ExtractIcon(wxGetInstance(), nameReal.t_str(), iconIndex);
}
#endif
if ( !hicon )
{
- wxLogSysError(_T("Failed to load icon from the file '%s'"),
+ wxLogSysError(wxT("Failed to load icon from the file '%s'"),
name.c_str());
return false;
}
- size = wxGetHiconSize(hicon);
+ if ( !icon->CreateFromHICON(hicon) )
+ return false;
- if ( (desiredWidth != -1 && desiredWidth != size.x) ||
- (desiredHeight != -1 && desiredHeight != size.y) )
+ if ( (desiredWidth != -1 && desiredWidth != icon->GetWidth()) ||
+ (desiredHeight != -1 && desiredHeight != icon->GetHeight()) )
{
- wxLogTrace(_T("iconload"),
- _T("Returning false from wxICOFileHandler::Load because of the size mismatch: actual (%d, %d), requested (%d, %d)"),
- size.x, size.y,
+ wxLogTrace(wxT("iconload"),
+ wxT("Returning false from wxICOFileHandler::Load because of the size mismatch: actual (%d, %d), requested (%d, %d)"),
+ icon->GetWidth(), icon->GetHeight(),
desiredWidth, desiredHeight);
- ::DestroyIcon(hicon);
+ icon->UnRef();
return false;
}
- icon->SetHICON((WXHICON)hicon);
- icon->SetSize(size.x, size.y);
-
- return icon->Ok();
+ return true;
}
bool wxICOResourceHandler::LoadIcon(wxIcon *icon,
const wxString& name,
- long WXUNUSED(flags),
+ wxBitmapType WXUNUSED(flags),
int desiredWidth, int desiredHeight)
{
HICON hicon;
bool hasSize = desiredWidth != -1 || desiredHeight != -1;
wxASSERT_MSG( !hasSize || (desiredWidth != -1 && desiredHeight != -1),
- _T("width and height should be either both -1 or not") );
+ wxT("width and height should be either both -1 or not") );
// try to load the icon from this program first to allow overriding the
// standard icons (although why one would want to do it considering that
// some icon rescaling internally which results in very ugly 16x16 icons
if ( hasSize )
{
- hicon = (HICON)::LoadImage(wxGetInstance(), name.wx_str(), IMAGE_ICON,
+ hicon = (HICON)::LoadImage(wxGetInstance(), name.t_str(), IMAGE_ICON,
desiredWidth, desiredHeight,
LR_DEFAULTCOLOR);
}
else
{
- hicon = ::LoadIcon(wxGetInstance(), name.wx_str());
+ hicon = ::LoadIcon(wxGetInstance(), name.t_str());
}
// next check if it's not a standard icon
if ( name == stdIcons[nIcon].name )
{
hicon = ::LoadIcon((HINSTANCE)NULL, stdIcons[nIcon].id);
+ break;
}
}
}
#endif
- wxSize size = wxGetHiconSize(hicon);
- icon->SetSize(size.x, size.y);
+ return icon->CreateFromHICON((WXHICON)hicon);
+}
+
+#if wxUSE_PNG_RESOURCE_HANDLER
+
+// ----------------------------------------------------------------------------
+// PNG handler
+// ----------------------------------------------------------------------------
+
+bool wxPNGResourceHandler::LoadFile(wxBitmap *bitmap,
+ const wxString& name,
+ wxBitmapType WXUNUSED(flags),
+ int WXUNUSED(desiredWidth),
+ int WXUNUSED(desiredHeight))
+{
+ const void* pngData = NULL;
+ size_t pngSize = 0;
+
+ // Currently we hardcode RCDATA resource type as this is what is usually
+ // used for the embedded images. We could allow specifying the type as part
+ // of the name in the future (e.g. "type:name" or something like this) if
+ // really needed.
+ if ( !wxLoadUserResource(&pngData, &pngSize,
+ name,
+ RT_RCDATA,
+ wxGetInstance()) )
+ {
+ // Notice that this message is not translated because only the
+ // programmer (and not the end user) can make any use of it.
+ wxLogError(wxS("Bitmap in PNG format \"%s\" not found, check ")
+ wxS("that the resource file contains \"RCDATA\" ")
+ wxS("resource with this name."),
+ name);
+
+ return false;
+ }
- icon->SetHICON((WXHICON)hicon);
+ *bitmap = wxBitmap::NewFromPNGData(pngData, pngSize);
+ if ( !bitmap->IsOk() )
+ {
+ wxLogError(wxS("Couldn't load resource bitmap \"%s\" as a PNG. "),
+ wxS("Have you registered PNG image handler?"),
+ name);
- return icon->Ok();
+ return false;
+ }
+
+ return true;
}
+#endif // wxUSE_PNG_RESOURCE_HANDLER
+
// ----------------------------------------------------------------------------
// private functions
// ----------------------------------------------------------------------------
projects / wxWidgets.git / blobdiff