///////////////////////////////////////////////////////////////////////////////
-// Name: msw/gdiimage.cpp
+// Name: src/msw/gdiimage.cpp
// Purpose: wxGDIImage implementation
// Author: Vadim Zeitlin
// Modified by:
// headers
// ----------------------------------------------------------------------------
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
- #pragma implementation "gdiimage.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifndef WX_PRECOMP
#include "wx/string.h"
#include "wx/log.h"
+ #include "wx/app.h"
+ #include "wx/bitmap.h"
#endif // WX_PRECOMP
#include "wx/msw/private.h"
-#include "wx/app.h"
-
-#include "wx/bitmap.h"
#include "wx/msw/gdiimage.h"
#if wxUSE_WXDIB
#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>
#include "wx/file.h"
#include "wx/listimpl.cpp"
-WX_DEFINE_LIST(wxGDIImageHandlerList);
-
-// ----------------------------------------------------------------------------
-// auxiliary functions
-// ----------------------------------------------------------------------------
-
-#ifdef __WXWINCE__
-// Used in wxBMPFileHandler::LoadFile
-HBITMAP wxLoadBMP(const wxString& filename) ;
-#endif
+WX_DEFINE_LIST(wxGDIImageHandlerList)
// ----------------------------------------------------------------------------
// private classes
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),
- void *WXUNUSED(data),
- long WXUNUSED(flags),
+ const void* WXUNUSED(data),
+ 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
while ( node )
{
wxGDIImageHandler *handler = node->GetData();
- if ( (handler->GetExtension() = extension) &&
+ if ( (handler->GetExtension() == extension) &&
(type == -1 || handler->GetType() == type) )
{
return handler;
#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));
+ 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);
- bool ok = dib.IsOk() && bitmap->CopyFromDIB(dib);
- return ok;
+ return dib.IsOk() && bitmap->CopyFromDIB(dib);
#else
- WXHBITMAP hBitmap = (WXHBITMAP)wxLoadBMP(name);
- if(hBitmap) {
- bitmap->SetHBITMAP(hBitmap);
- return true;
- }
return false;
#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, 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, 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, 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, IMAGE_ICON,
+ hicon = (HICON)::LoadImage(wxGetInstance(), name.t_str(), IMAGE_ICON,
desiredWidth, desiredHeight,
LR_DEFAULTCOLOR);
}
else
{
- hicon = ::LoadIcon(wxGetInstance(), name);
+ 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);
+}
- icon->SetHICON((WXHICON)hicon);
+#if wxUSE_PNG_RESOURCE_HANDLER
- return icon->Ok();
+// ----------------------------------------------------------------------------
+// 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;
+ }
+
+ *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 false;
+ }
+
+ return true;
}
+#endif // wxUSE_PNG_RESOURCE_HANDLER
+
// ----------------------------------------------------------------------------
// private functions
// ----------------------------------------------------------------------------
-wxSize wxGetHiconSize(HICON hicon)
+wxSize wxGetHiconSize(HICON WXUNUSED_IN_WINCE(hicon))
{
- // default icon size on this hardware
- // usually 32x32 but can be other (smaller) on pocket devices
- wxSize size(::GetSystemMetrics(SM_CXICON), ::GetSystemMetrics(SM_CYICON));
+ wxSize size;
#ifndef __WXWINCE__
- if ( hicon && wxGetOsVersion() != wxWIN32S )
+ if ( hicon )
{
ICONINFO info;
if ( !::GetIconInfo(hicon, &info) )
::DeleteObject(info.hbmColor);
}
}
-#else
- wxUnusedVar(hicon);
-#endif
- return size;
-}
-
-#endif // __WXMICROWIN__
-#ifdef __WXWINCE__
-// Used in wxBMPFileHandler::LoadFile
-HBITMAP wxLoadBMP(const wxString& filename)
-{
- wxFile file;
- if(!file.Open(filename))
- return 0;
-
- // The first part of the file contains the file header.
- // This will tell us if it is a bitmap, how big the header is, and how big
- // the file is. The header size in the file header includes the color table.
- BITMAPFILEHEADER BmpFileHdr;
- BITMAPINFO *pBmpInfo = (BITMAPINFO*)malloc(sizeof(BITMAPINFO)+255*sizeof(RGBQUAD));
- BYTE* pBits = 0;
- HBITMAP hBitmap = 0;
-
- if(file.Read(&BmpFileHdr, sizeof(BmpFileHdr))==sizeof(BmpFileHdr)
- && !strncmp((char*)&BmpFileHdr.bfType,"BM",2)
- && file.Read(pBmpInfo, sizeof(BITMAPINFOHEADER))==sizeof(BITMAPINFOHEADER)
- && pBmpInfo->bmiHeader.biSize == sizeof(BITMAPINFOHEADER)) {
-
-
- unsigned int nColors = pBmpInfo->bmiHeader.biClrUsed ?
- pBmpInfo->bmiHeader.biClrUsed : 1 << pBmpInfo->bmiHeader.biBitCount;
- if (nColors < 1
- || file.Read(pBmpInfo->bmiColors, nColors * sizeof(RGBQUAD))
- == nColors * sizeof(RGBQUAD)) {
-
- // So how big the bitmap surface is.
- int nBitsSize = BmpFileHdr.bfSize - BmpFileHdr.bfOffBits;
-
- // Allocate the memory for the bits and read the bits from the file.
- pBits = (BYTE*) malloc(nBitsSize*2);
- if (pBits) {
- // Seek to the bits in the file.
- file.Seek(BmpFileHdr.bfOffBits);
-
- // read the bits
- if(file.Read(pBits, nBitsSize)==nBitsSize) {
- // Everything went OK.
- pBmpInfo->bmiHeader.biSizeImage = nBitsSize;
-
- //HBITMAP hBitmap=SetBitmap((LPBITMAPINFO)pBmpInfo, pBits);
- //DWORD dwBitmapInfoSize = sizeof(BITMAPINFO) + nColors*sizeof(RGBQUAD);
-
- // Create a DC which will be used to get DIB, then create DIBsection
- HDC hDC = ::GetDC(NULL);
- if (hDC) {
- LPVOID bits;
- hBitmap = CreateDIBSection(hDC, (const BITMAPINFO*) pBmpInfo,
- DIB_RGB_COLORS, &bits, NULL, 0);
- ReleaseDC(0,hDC);
-
- if (hBitmap) {
- DWORD dwImageSize = pBmpInfo->bmiHeader.biSizeImage;
- if (dwImageSize == 0) {
- int nBytesPerLine = pBmpInfo->bmiHeader.biWidth * pBmpInfo->bmiHeader.biBitCount;
- nBytesPerLine = ( (nBytesPerLine + 31) & (~31) ) / 8;
- dwImageSize = nBytesPerLine * pBmpInfo->bmiHeader.biHeight;
- }
- memcpy(bits, pBits, dwImageSize);
- }
- }
- }
- }
+ if ( !size.x )
+#endif // !__WXWINCE__
+ {
+ // use default icon size on this hardware
+ size.x = ::GetSystemMetrics(SM_CXICON);
+ size.y = ::GetSystemMetrics(SM_CYICON);
}
- }
- if(pBmpInfo)
- free(pBmpInfo);
- if(pBits)
- free(pBits);
-
- return hBitmap;
+ return size;
}
-#endif
+#endif // __WXMICROWIN__
projects / wxWidgets.git / blobdiff