src/msw/gdiimage.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        msw/gdiimage.cpp
// Purpose:     wxGDIImage implementation
// Author:      Vadim Zeitlin
// Modified by:
// Created:     20.11.99
// RCS-ID:      $Id$
// Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence:     wxWindows license
///////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#ifdef __GNUG__
    #pragma implementation "gdiimage.h"
#endif

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

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/string.h"
    #include "wx/log.h"
#endif // WX_PRECOMP

#include "wx/msw/private.h"

#include "wx/app.h"

#include "wx/msw/dib.h"
#include "wx/msw/bitmap.h"
#include "wx/msw/gdiimage.h"
#include "wx/bitmap.h"

#if wxUSE_XPM_IN_MSW
#   include "wx/xpmhand.h"
#endif // wxUSE_XPM_IN_MSW

#ifdef __WIN16__
#   include "wx/msw/curico.h"
#endif // __WIN16__

// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------

// all image handlers are declared/defined in this file because the outside
// world doesn't have to know about them (but only about wxBITMAP_TYPE_XXX ids)

class WXDLLEXPORT wxBMPFileHandler : public wxBitmapHandler
{
public:
    wxBMPFileHandler() : wxBitmapHandler(_T("Windows bitmap file"), _T("bmp"),
                                         wxBITMAP_TYPE_BMP)
    {
    }

    virtual bool LoadFile(wxBitmap *bitmap,
                          const wxString& name, long flags,
                          int desiredWidth, int desiredHeight);
    virtual bool SaveFile(wxBitmap *bitmap,
                          const wxString& name, int type,
                          const wxPalette *palette = NULL);

private:
    DECLARE_DYNAMIC_CLASS(wxBMPFileHandler)
};

class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
{
public:
    wxBMPResourceHandler() : wxBitmapHandler(_T("Windows bitmap resource"),
                                             wxEmptyString,
                                             wxBITMAP_TYPE_BMP_RESOURCE)
    {
    }

    virtual bool LoadFile(wxBitmap *bitmap,
                          const wxString& name, long flags,
                          int desiredWidth, int desiredHeight);

private:
    DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler)
};

class WXDLLEXPORT wxIconHandler : public wxGDIImageHandler
{
public:
    wxIconHandler(const wxString& name, const wxString& ext, long type)
        : wxGDIImageHandler(name, ext, type)
    {
    }

    // creating and saving icons is not supported
    virtual bool Create(wxGDIImage *WXUNUSED(image),
                        void *WXUNUSED(data),
                        long WXUNUSED(flags),
                        int WXUNUSED(width),
                        int WXUNUSED(height),
                        int WXUNUSED(depth) = 1)
    {
        return FALSE;
    }

    virtual bool Save(wxGDIImage *WXUNUSED(image),
                      const wxString& WXUNUSED(name),
                      int WXUNUSED(type))
    {
        return FALSE;
    }

    virtual bool Load(wxGDIImage *image,
                      const wxString& name,
                      long flags,
                      int desiredWidth, int desiredHeight)
    {
        wxIcon *icon = wxDynamicCast(image, wxIcon);
        wxCHECK_MSG( icon, FALSE, _T("wxIconHandler only works with icons") );

        return LoadIcon(icon, name, flags, desiredWidth, desiredHeight);
    }

protected:
    virtual bool LoadIcon(wxIcon *icon,
                          const wxString& name, long flags,
                          int desiredWidth = -1, int desiredHeight = -1) = 0;
};

class WXDLLEXPORT wxICOFileHandler : public wxIconHandler
{
public:
    wxICOFileHandler() : wxIconHandler(_T("ICO icon file"),
                                       _T("ico"),
                                       wxBITMAP_TYPE_ICO)
    {
    }

    virtual bool LoadIcon(wxIcon *icon,
                          const wxString& name, long flags,
                          int desiredWidth = -1, int desiredHeight = -1);

private:
    DECLARE_DYNAMIC_CLASS(wxICOFileHandler)
};

class WXDLLEXPORT wxICOResourceHandler: public wxIconHandler
{
public:
    wxICOResourceHandler() : wxIconHandler(_T("ICO resource"),
                                           _T("ico"),
                                           wxBITMAP_TYPE_ICO_RESOURCE)
    {
    }

    virtual bool LoadIcon(wxIcon *icon,
                          const wxString& name, long flags,
                          int desiredWidth = -1, int desiredHeight = -1);

private:
    DECLARE_DYNAMIC_CLASS(wxICOResourceHandler)
};

// ----------------------------------------------------------------------------
// wxWin macros
// ----------------------------------------------------------------------------

    IMPLEMENT_DYNAMIC_CLASS(wxBMPFileHandler, wxBitmapHandler)
    IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
    IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxGDIImageHandler)
    IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxGDIImageHandler)

// ----------------------------------------------------------------------------
// private functions
// ----------------------------------------------------------------------------

static wxSize GetHiconSize(HICON hicon);

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

wxList wxGDIImage::ms_handlers;

// ----------------------------------------------------------------------------
// wxGDIImage functions forwarded to wxGDIImageRefData
// ----------------------------------------------------------------------------

bool wxGDIImage::FreeResource(bool WXUNUSED(force))
{
    if ( !IsNull() )
    {
        GetGDIImageData()->Free();
        GetGDIImageData()->m_handle = 0;
    }

    return TRUE;
}

WXHANDLE wxGDIImage::GetResourceHandle()
{
    return GetHandle();
}

// ----------------------------------------------------------------------------
// wxGDIImage handler stuff
// ----------------------------------------------------------------------------

void wxGDIImage::AddHandler(wxGDIImageHandler *handler)
{
    ms_handlers.Append(handler);
}

void wxGDIImage::InsertHandler(wxGDIImageHandler *handler)
{
    ms_handlers.Insert(handler);
}

bool wxGDIImage::RemoveHandler(const wxString& name)
{
    wxGDIImageHandler *handler = FindHandler(name);
    if ( handler )
    {
        ms_handlers.DeleteObject(handler);
        return TRUE;
    }
    else
        return FALSE;
}

wxGDIImageHandler *wxGDIImage::FindHandler(const wxString& name)
{
    wxNode *node = ms_handlers.First();
    while ( node )
    {
        wxGDIImageHandler *handler = (wxGDIImageHandler *)node->Data();
        if ( handler->GetName() == name )
            return handler;
        node = node->Next();
    }

    return NULL;
}

wxGDIImageHandler *wxGDIImage::FindHandler(const wxString& extension,
                                           long type)
{
    wxNode *node = ms_handlers.First();
    while ( node )
    {
        wxGDIImageHandler *handler = (wxGDIImageHandler *)node->Data();
        if ( (handler->GetExtension() = extension) &&
             (type == -1 || handler->GetType() == type) )
        {
            return handler;
        }

        node = node->Next();
    }
    return NULL;
}

wxGDIImageHandler *wxGDIImage::FindHandler(long type)
{
    wxNode *node = ms_handlers.First();
    while ( node )
    {
        wxGDIImageHandler *handler = (wxGDIImageHandler *)node->Data();
        if ( handler->GetType() == type )
            return handler;

        node = node->Next();
    }

    return NULL;
}

void wxGDIImage::CleanUpHandlers()
{
    wxNode *node = ms_handlers.First();
    while ( node )
    {
        wxGDIImageHandler *handler = (wxGDIImageHandler *)node->Data();
        wxNode *next = node->Next();
        delete handler;
        delete node;
        node = next;
    }
}

void wxGDIImage::InitStandardHandlers()
{
    AddHandler(new wxBMPResourceHandler);
    AddHandler(new wxBMPFileHandler);

    // GRG: Add these handlers by default if XPM support is enabled

#if wxUSE_XPM_IN_MSW
    AddHandler(new wxXPMFileHandler);
    AddHandler(new wxXPMDataHandler);
#endif // wxUSE_XPM_IN_MSW

    AddHandler(new wxICOResourceHandler);
    AddHandler(new wxICOFileHandler);
}

// ----------------------------------------------------------------------------
// wxBitmap handlers
// ----------------------------------------------------------------------------

bool wxBMPResourceHandler::LoadFile(wxBitmap *bitmap,
                                    const wxString& name, long WXUNUSED(flags),
                                    int WXUNUSED(desiredWidth),
                                    int WXUNUSED(desiredHeight))
{
    // TODO: load colourmap.
    bitmap->SetHBITMAP((WXHBITMAP)::LoadBitmap(wxGetInstance(), name));

    wxBitmapRefData *data = bitmap->GetBitmapData();
    if ( bitmap->Ok() )
    {
        BITMAP bm;
        if ( !::GetObject(GetHbitmapOf(*bitmap), sizeof(BITMAP), (LPSTR) &bm) )
        {
            wxLogLastError(wxT("GetObject(HBITMAP)"));
        }

        data->m_width = bm.bmWidth;
        data->m_height = bm.bmHeight;
        data->m_depth = bm.bmBitsPixel;
    }
    else
    {
        // it's probably not found
        wxLogError(wxT("Can't load bitmap '%s' from resources! Check .rc file."),
                   name.c_str());
    }

    return bitmap->Ok();
}

bool wxBMPFileHandler::LoadFile(wxBitmap *bitmap,
                                const wxString& name, long WXUNUSED(flags),
                                int WXUNUSED(desiredWidth),
                                int WXUNUSED(desiredHeight))
{
#if wxUSE_IMAGE_LOADING_IN_MSW
    wxPalette *palette = NULL;
    bool success = wxLoadIntoBitmap(WXSTRINGCAST name, bitmap, &palette) != 0;
    if ( success && palette )
    {
        bitmap->SetPalette(*palette);
    }

    // it was copied by the bitmap if it was loaded successfully
    delete palette;

    return success;
#else
    return FALSE;
#endif
}

bool wxBMPFileHandler::SaveFile(wxBitmap *bitmap,
                                const wxString& name,
                                int WXUNUSED(type),
                                const wxPalette *pal)
{
#if wxUSE_IMAGE_LOADING_IN_MSW
    wxPalette *actualPalette = (wxPalette *)pal;
    if ( !actualPalette )
        actualPalette = bitmap->GetPalette();
    return wxSaveBitmap(WXSTRINGCAST name, bitmap, actualPalette) != 0;
#else
    return FALSE;
#endif
}

// ----------------------------------------------------------------------------
// wxIcon handlers
// ----------------------------------------------------------------------------

bool wxICOFileHandler::LoadIcon(wxIcon *icon,
                                const wxString& name,
                                long flags,
                                int desiredWidth, int desiredHeight)
{
#if wxUSE_RESOURCE_LOADING_IN_MSW
    icon->UnRef();

    // actual size
    wxSize size;

#ifdef __WIN32__
    HICON hicon = NULL;

    // were we asked for a large icon?
    if ( desiredWidth == ::GetSystemMetrics(SM_CXICON) &&
         desiredHeight == ::GetSystemMetrics(SM_CYICON) )
    {
        // get the first large icon from file
        if ( !::ExtractIconEx(name, 0, &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'."),
                       name.c_str());
        }
    }
    else if ( desiredWidth == ::GetSystemMetrics(SM_CXSMICON) &&
              desiredHeight == ::GetSystemMetrics(SM_CYSMICON) )
    {
        // get the first small icon from file
        if ( !::ExtractIconEx(name, 0, NULL, &hicon, 1) )
        {
            wxLogTrace(_T("iconload"),
                       _T("No small icons found in the file '%s'."),
                       name.c_str());
        }
    }
    //else: not standard size, load below

    if ( !hicon )
    {
        // take any (the first one) icon from the file by default
        hicon = ::ExtractIcon(wxGetInstance(), name, 0 /* first */);
    }

    if ( !hicon )
    {
        wxLogSysError(_T("Failed to load icon from the file '%s'"),
                      name.c_str());

        return FALSE;
    }

    size = GetHiconSize(hicon);
#else // Win16
    HICON hicon = ReadIconFile((wxChar *)name.c_str(),
                               wxGetInstance(),
                               &size.x, &size.y);
#endif // Win32/Win16

    if ( (desiredWidth != -1 && desiredWidth != size.x) ||
         (desiredHeight != -1 && desiredHeight != size.y) )
    {
        wxLogTrace(_T("iconload"),
                   _T("Returning FALSE from wxICOFileHandler::Load because of the size mismatch: actual (%d, %d), requested (%d, %d)"),
                   size.x, size.y,
                   desiredWidth, desiredHeight);

        ::DestroyIcon(hicon);

        return FALSE;
    }

    icon->SetHICON((WXHICON)hicon);
    icon->SetSize(size.x, size.y);

    return icon->Ok();
#else
    return FALSE;
#endif
}

bool wxICOResourceHandler::LoadIcon(wxIcon *icon,
                                    const wxString& name,
                                    long flags,
                                    int desiredWidth, int desiredHeight)
{
    HICON hicon;

#if defined(__WIN32__) && !defined(__SC__)
    if ( desiredWidth != -1 && desiredHeight != -1 )
    {
        hicon = (HICON)::LoadImage(wxGetInstance(), name, IMAGE_ICON,
                                    desiredWidth, desiredHeight,
                                    LR_DEFAULTCOLOR);
    }
    else
#endif // Win32
    {
        hicon = ::LoadIcon(wxGetInstance(), name);
    }

    wxSize size = GetHiconSize(hicon);
    icon->SetSize(size.x, size.y);

    // Override the found values with desired values
    if ( desiredWidth > -1 && desiredHeight > -1 )
    {
        icon->SetSize(desiredWidth, desiredHeight);
    }

    icon->SetHICON((WXHICON)hicon);

    return icon->Ok();
}

// ----------------------------------------------------------------------------
// private functions
// ----------------------------------------------------------------------------

static wxSize GetHiconSize(HICON hicon)
{
    wxSize size(32, 32);    // default

#ifdef __WIN32__
    // Win32s doesn't have GetIconInfo function...
    if ( hicon && wxGetOsVersion() != wxWIN32S )
    {
        ICONINFO info;
        if ( !::GetIconInfo(hicon, &info) )
        {
            wxLogLastError(wxT("GetIconInfo"));
        }
        else
        {
            HBITMAP hbmp = info.hbmMask;
            if ( hbmp )
            {
                BITMAP bm;
                if ( ::GetObject(hbmp, sizeof(BITMAP), (LPSTR) &bm) )
                {
                    size = wxSize(bm.bmWidth, bm.bmHeight);
                }

                ::DeleteObject(info.hbmMask);
            }
            if ( info.hbmColor )
                ::DeleteObject(info.hbmColor);
        }
    }
#endif

    return size;
}
Commit	Line	Data
	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: msw/gdiimage.cpp
	3	// Purpose: wxGDIImage implementation
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 20.11.99
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
	9	// Licence: wxWindows license
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	#ifdef __GNUG__
	21	#pragma implementation "gdiimage.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	#ifndef WX_PRECOMP
	32	#include "wx/string.h"
	33	#include "wx/log.h"
	34	#endif // WX_PRECOMP
	35
	36	#include "wx/msw/private.h"
	37
	38	#include "wx/app.h"
	39
	40	#include "wx/msw/dib.h"
	41	#include "wx/msw/bitmap.h"
	42	#include "wx/msw/gdiimage.h"
	43	#include "wx/bitmap.h"
	44
	45	#if wxUSE_XPM_IN_MSW
	46	# include "wx/xpmhand.h"
	47	#endif // wxUSE_XPM_IN_MSW
	48
	49	#ifdef __WIN16__
	50	# include "wx/msw/curico.h"
	51	#endif // __WIN16__
	52
	53	// ----------------------------------------------------------------------------
	54	// private classes
	55	// ----------------------------------------------------------------------------
	56
	57	// all image handlers are declared/defined in this file because the outside
	58	// world doesn't have to know about them (but only about wxBITMAP_TYPE_XXX ids)
	59
	60	class WXDLLEXPORT wxBMPFileHandler : public wxBitmapHandler
	61	{
	62	public:
	63	wxBMPFileHandler() : wxBitmapHandler(_T("Windows bitmap file"), _T("bmp"),
	64	wxBITMAP_TYPE_BMP)
	65	{
	66	}
	67
	68	virtual bool LoadFile(wxBitmap *bitmap,
	69	const wxString& name, long flags,
	70	int desiredWidth, int desiredHeight);
	71	virtual bool SaveFile(wxBitmap *bitmap,
	72	const wxString& name, int type,
	73	const wxPalette *palette = NULL);
	74
	75	private:
	76	DECLARE_DYNAMIC_CLASS(wxBMPFileHandler)
	77	};
	78
	79	class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
	80	{
	81	public:
	82	wxBMPResourceHandler() : wxBitmapHandler(_T("Windows bitmap resource"),
	83	wxEmptyString,
	84	wxBITMAP_TYPE_BMP_RESOURCE)
	85	{
	86	}
	87
	88	virtual bool LoadFile(wxBitmap *bitmap,
	89	const wxString& name, long flags,
	90	int desiredWidth, int desiredHeight);
	91
	92	private:
	93	DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler)
	94	};
	95
	96	class WXDLLEXPORT wxIconHandler : public wxGDIImageHandler
	97	{
	98	public:
	99	wxIconHandler(const wxString& name, const wxString& ext, long type)
	100	: wxGDIImageHandler(name, ext, type)
	101	{
	102	}
	103
	104	// creating and saving icons is not supported
	105	virtual bool Create(wxGDIImage *WXUNUSED(image),
	106	void *WXUNUSED(data),
	107	long WXUNUSED(flags),
	108	int WXUNUSED(width),
	109	int WXUNUSED(height),
	110	int WXUNUSED(depth) = 1)
	111	{
	112	return FALSE;
	113	}
	114
	115	virtual bool Save(wxGDIImage *WXUNUSED(image),
	116	const wxString& WXUNUSED(name),
	117	int WXUNUSED(type))
	118	{
	119	return FALSE;
	120	}
	121
	122	virtual bool Load(wxGDIImage *image,
	123	const wxString& name,
	124	long flags,
	125	int desiredWidth, int desiredHeight)
	126	{
	127	wxIcon *icon = wxDynamicCast(image, wxIcon);
	128	wxCHECK_MSG( icon, FALSE, _T("wxIconHandler only works with icons") );
	129
	130	return LoadIcon(icon, name, flags, desiredWidth, desiredHeight);
	131	}
	132
	133	protected:
	134	virtual bool LoadIcon(wxIcon *icon,
	135	const wxString& name, long flags,
	136	int desiredWidth = -1, int desiredHeight = -1) = 0;
	137	};
	138
	139	class WXDLLEXPORT wxICOFileHandler : public wxIconHandler
	140	{
	141	public:
	142	wxICOFileHandler() : wxIconHandler(_T("ICO icon file"),
	143	_T("ico"),
	144	wxBITMAP_TYPE_ICO)
	145	{
	146	}
	147
	148	virtual bool LoadIcon(wxIcon *icon,
	149	const wxString& name, long flags,
	150	int desiredWidth = -1, int desiredHeight = -1);
	151
	152	private:
	153	DECLARE_DYNAMIC_CLASS(wxICOFileHandler)
	154	};
	155
	156	class WXDLLEXPORT wxICOResourceHandler: public wxIconHandler
	157	{
	158	public:
	159	wxICOResourceHandler() : wxIconHandler(_T("ICO resource"),
	160	_T("ico"),
	161	wxBITMAP_TYPE_ICO_RESOURCE)
	162	{
	163	}
	164
	165	virtual bool LoadIcon(wxIcon *icon,
	166	const wxString& name, long flags,
	167	int desiredWidth = -1, int desiredHeight = -1);
	168
	169	private:
	170	DECLARE_DYNAMIC_CLASS(wxICOResourceHandler)
	171	};
	172
	173	// ----------------------------------------------------------------------------
	174	// wxWin macros
	175	// ----------------------------------------------------------------------------
	176
	177	IMPLEMENT_DYNAMIC_CLASS(wxBMPFileHandler, wxBitmapHandler)
	178	IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
	179	IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxGDIImageHandler)
	180	IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxGDIImageHandler)
	181
	182	// ----------------------------------------------------------------------------
	183	// private functions
	184	// ----------------------------------------------------------------------------
	185
	186	static wxSize GetHiconSize(HICON hicon);
	187
	188	// ============================================================================
	189	// implementation
	190	// ============================================================================
	191
	192	wxList wxGDIImage::ms_handlers;
	193
	194	// ----------------------------------------------------------------------------
	195	// wxGDIImage functions forwarded to wxGDIImageRefData
	196	// ----------------------------------------------------------------------------
	197
	198	bool wxGDIImage::FreeResource(bool WXUNUSED(force))
	199	{
	200	if ( !IsNull() )
	201	{
	202	GetGDIImageData()->Free();
	203	GetGDIImageData()->m_handle = 0;
	204	}
	205
	206	return TRUE;
	207	}
	208
	209	WXHANDLE wxGDIImage::GetResourceHandle()
	210	{
	211	return GetHandle();
	212	}
	213
	214	// ----------------------------------------------------------------------------
	215	// wxGDIImage handler stuff
	216	// ----------------------------------------------------------------------------
	217
	218	void wxGDIImage::AddHandler(wxGDIImageHandler *handler)
	219	{
	220	ms_handlers.Append(handler);
	221	}
	222
	223	void wxGDIImage::InsertHandler(wxGDIImageHandler *handler)
	224	{
	225	ms_handlers.Insert(handler);
	226	}
	227
	228	bool wxGDIImage::RemoveHandler(const wxString& name)
	229	{
	230	wxGDIImageHandler *handler = FindHandler(name);
	231	if ( handler )
	232	{
	233	ms_handlers.DeleteObject(handler);
	234	return TRUE;
	235	}
	236	else
	237	return FALSE;
	238	}
	239
	240	wxGDIImageHandler *wxGDIImage::FindHandler(const wxString& name)
	241	{
	242	wxNode *node = ms_handlers.First();
	243	while ( node )
	244	{
	245	wxGDIImageHandler handler = (wxGDIImageHandler )node->Data();
	246	if ( handler->GetName() == name )
	247	return handler;
	248	node = node->Next();
	249	}
	250
	251	return NULL;
	252	}
	253
	254	wxGDIImageHandler *wxGDIImage::FindHandler(const wxString& extension,
	255	long type)
	256	{
	257	wxNode *node = ms_handlers.First();
	258	while ( node )
	259	{
	260	wxGDIImageHandler handler = (wxGDIImageHandler )node->Data();
	261	if ( (handler->GetExtension() = extension) &&
	262	(type == -1 \|\| handler->GetType() == type) )
	263	{
	264	return handler;
	265	}
	266
	267	node = node->Next();
	268	}
	269	return NULL;
	270	}
	271
	272	wxGDIImageHandler *wxGDIImage::FindHandler(long type)
	273	{
	274	wxNode *node = ms_handlers.First();
	275	while ( node )
	276	{
	277	wxGDIImageHandler handler = (wxGDIImageHandler )node->Data();
	278	if ( handler->GetType() == type )
	279	return handler;
	280
	281	node = node->Next();
	282	}
	283
	284	return NULL;
	285	}
	286
	287	void wxGDIImage::CleanUpHandlers()
	288	{
	289	wxNode *node = ms_handlers.First();
	290	while ( node )
	291	{
	292	wxGDIImageHandler handler = (wxGDIImageHandler )node->Data();
	293	wxNode *next = node->Next();
	294	delete handler;
	295	delete node;
	296	node = next;
	297	}
	298	}
	299
	300	void wxGDIImage::InitStandardHandlers()
	301	{
	302	AddHandler(new wxBMPResourceHandler);
	303	AddHandler(new wxBMPFileHandler);
	304
	305	// GRG: Add these handlers by default if XPM support is enabled
	306
	307	#if wxUSE_XPM_IN_MSW
	308	AddHandler(new wxXPMFileHandler);
	309	AddHandler(new wxXPMDataHandler);
	310	#endif // wxUSE_XPM_IN_MSW
	311
	312	AddHandler(new wxICOResourceHandler);
	313	AddHandler(new wxICOFileHandler);
	314	}
	315
	316	// ----------------------------------------------------------------------------
	317	// wxBitmap handlers
	318	// ----------------------------------------------------------------------------
	319
	320	bool wxBMPResourceHandler::LoadFile(wxBitmap *bitmap,
	321	const wxString& name, long WXUNUSED(flags),
	322	int WXUNUSED(desiredWidth),
	323	int WXUNUSED(desiredHeight))
	324	{
	325	// TODO: load colourmap.
	326	bitmap->SetHBITMAP((WXHBITMAP)::LoadBitmap(wxGetInstance(), name));
	327
	328	wxBitmapRefData *data = bitmap->GetBitmapData();
	329	if ( bitmap->Ok() )
	330	{
	331	BITMAP bm;
	332	if ( !::GetObject(GetHbitmapOf(*bitmap), sizeof(BITMAP), (LPSTR) &bm) )
	333	{
	334	wxLogLastError(wxT("GetObject(HBITMAP)"));
	335	}
	336
	337	data->m_width = bm.bmWidth;
	338	data->m_height = bm.bmHeight;
	339	data->m_depth = bm.bmBitsPixel;
	340	}
	341	else
	342	{
	343	// it's probably not found
	344	wxLogError(wxT("Can't load bitmap '%s' from resources! Check .rc file."),
	345	name.c_str());
	346	}
	347
	348	return bitmap->Ok();
	349	}
	350
	351	bool wxBMPFileHandler::LoadFile(wxBitmap *bitmap,
	352	const wxString& name, long WXUNUSED(flags),
	353	int WXUNUSED(desiredWidth),
	354	int WXUNUSED(desiredHeight))
	355	{
	356	#if wxUSE_IMAGE_LOADING_IN_MSW
	357	wxPalette *palette = NULL;
	358	bool success = wxLoadIntoBitmap(WXSTRINGCAST name, bitmap, &palette) != 0;
	359	if ( success && palette )
	360	{
	361	bitmap->SetPalette(*palette);
	362	}
	363
	364	// it was copied by the bitmap if it was loaded successfully
	365	delete palette;
	366
	367	return success;
	368	#else
	369	return FALSE;
	370	#endif
	371	}
	372
	373	bool wxBMPFileHandler::SaveFile(wxBitmap *bitmap,
	374	const wxString& name,
	375	int WXUNUSED(type),
	376	const wxPalette *pal)
	377	{
	378	#if wxUSE_IMAGE_LOADING_IN_MSW
	379	wxPalette actualPalette = (wxPalette )pal;
	380	if ( !actualPalette )
	381	actualPalette = bitmap->GetPalette();
	382	return wxSaveBitmap(WXSTRINGCAST name, bitmap, actualPalette) != 0;
	383	#else
	384	return FALSE;
	385	#endif
	386	}
	387
	388	// ----------------------------------------------------------------------------
	389	// wxIcon handlers
	390	// ----------------------------------------------------------------------------
	391
	392	bool wxICOFileHandler::LoadIcon(wxIcon *icon,
	393	const wxString& name,
	394	long flags,
	395	int desiredWidth, int desiredHeight)
	396	{
	397	#if wxUSE_RESOURCE_LOADING_IN_MSW
	398	icon->UnRef();
	399
	400	// actual size
	401	wxSize size;
	402
	403	#ifdef __WIN32__
	404	HICON hicon = NULL;
	405
	406	// were we asked for a large icon?
	407	if ( desiredWidth == ::GetSystemMetrics(SM_CXICON) &&
	408	desiredHeight == ::GetSystemMetrics(SM_CYICON) )
	409	{
	410	// get the first large icon from file
	411	if ( !::ExtractIconEx(name, 0, &hicon, NULL, 1) )
	412	{
	413	// it is not an error, but it might still be useful to be informed
	414	// about it optionally
	415	wxLogTrace(_T("iconload"),
	416	_T("No large icons found in the file '%s'."),
	417	name.c_str());
	418	}
	419	}
	420	else if ( desiredWidth == ::GetSystemMetrics(SM_CXSMICON) &&
	421	desiredHeight == ::GetSystemMetrics(SM_CYSMICON) )
	422	{
	423	// get the first small icon from file
	424	if ( !::ExtractIconEx(name, 0, NULL, &hicon, 1) )
	425	{
	426	wxLogTrace(_T("iconload"),
	427	_T("No small icons found in the file '%s'."),
	428	name.c_str());
	429	}
	430	}
	431	//else: not standard size, load below
	432
	433	if ( !hicon )
	434	{
	435	// take any (the first one) icon from the file by default
	436	hicon = ::ExtractIcon(wxGetInstance(), name, 0 /* first */);
	437	}
	438
	439	if ( !hicon )
	440	{
	441	wxLogSysError(_T("Failed to load icon from the file '%s'"),
	442	name.c_str());
	443
	444	return FALSE;
	445	}
	446
	447	size = GetHiconSize(hicon);
	448	#else // Win16
	449	HICON hicon = ReadIconFile((wxChar *)name.c_str(),
	450	wxGetInstance(),
	451	&size.x, &size.y);
	452	#endif // Win32/Win16
	453
	454	if ( (desiredWidth != -1 && desiredWidth != size.x) \|\|
	455	(desiredHeight != -1 && desiredHeight != size.y) )
	456	{
	457	wxLogTrace(_T("iconload"),
	458	_T("Returning FALSE from wxICOFileHandler::Load because of the size mismatch: actual (%d, %d), requested (%d, %d)"),
	459	size.x, size.y,
	460	desiredWidth, desiredHeight);
	461
	462	::DestroyIcon(hicon);
	463
	464	return FALSE;
	465	}
	466
	467	icon->SetHICON((WXHICON)hicon);
	468	icon->SetSize(size.x, size.y);
	469
	470	return icon->Ok();
	471	#else
	472	return FALSE;
	473	#endif
	474	}
	475
	476	bool wxICOResourceHandler::LoadIcon(wxIcon *icon,
	477	const wxString& name,
	478	long flags,
	479	int desiredWidth, int desiredHeight)
	480	{
	481	HICON hicon;
	482
	483	#if defined(__WIN32__) && !defined(__SC__)
	484	if ( desiredWidth != -1 && desiredHeight != -1 )
	485	{
	486	hicon = (HICON)::LoadImage(wxGetInstance(), name, IMAGE_ICON,
	487	desiredWidth, desiredHeight,
	488	LR_DEFAULTCOLOR);
	489	}
	490	else
	491	#endif // Win32
	492	{
	493	hicon = ::LoadIcon(wxGetInstance(), name);
	494	}
	495
	496	wxSize size = GetHiconSize(hicon);
	497	icon->SetSize(size.x, size.y);
	498
	499	// Override the found values with desired values
	500	if ( desiredWidth > -1 && desiredHeight > -1 )
	501	{
	502	icon->SetSize(desiredWidth, desiredHeight);
	503	}
	504
	505	icon->SetHICON((WXHICON)hicon);
	506
	507	return icon->Ok();
	508	}
	509
	510	// ----------------------------------------------------------------------------
	511	// private functions
	512	// ----------------------------------------------------------------------------
	513
	514	static wxSize GetHiconSize(HICON hicon)
	515	{
	516	wxSize size(32, 32); // default
	517
	518	#ifdef __WIN32__
	519	// Win32s doesn't have GetIconInfo function...
	520	if ( hicon && wxGetOsVersion() != wxWIN32S )
	521	{
	522	ICONINFO info;
	523	if ( !::GetIconInfo(hicon, &info) )
	524	{
	525	wxLogLastError(wxT("GetIconInfo"));
	526	}
	527	else
	528	{
	529	HBITMAP hbmp = info.hbmMask;
	530	if ( hbmp )
	531	{
	532	BITMAP bm;
	533	if ( ::GetObject(hbmp, sizeof(BITMAP), (LPSTR) &bm) )
	534	{
	535	size = wxSize(bm.bmWidth, bm.bmHeight);
	536	}
	537
	538	::DeleteObject(info.hbmMask);
	539	}
	540	if ( info.hbmColor )
	541	::DeleteObject(info.hbmColor);
	542	}
	543	}
	544	#endif
	545
	546	return size;
	547	}