[wxWidgets.git] / src / os2 / 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"


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

#include "wx/os2/private.h"

#include "wx/app.h"

#include "wx/os2/gdiimage.h"

// ----------------------------------------------------------------------------
// 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*       pBitmap
                          ,const wxString& rName
                          ,HPS             hPs
                          ,long            lFlags
                          ,int             nDesiredWidth
                          ,int             nDesiredHeight
                         );
    virtual bool SaveFile( wxBitmap*        pBitmap
                          ,const wxString&  rName
                          ,int              lType
                          ,const wxPalette* pPalette = 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*       pBitmap
                          ,const wxString& rName
                          ,HPS             hPs
                          ,long            lFlags
                          ,int             nDesiredWidth
                          ,int             nDesiredHeight
                         );

private:
    DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler)
};

class WXDLLEXPORT wxIconHandler : public wxGDIImageHandler
{
public:
    wxIconHandler( const wxString& rName
                  ,const wxString& rExt
                  ,long            lType
                 ) : wxGDIImageHandler( rName
                                       ,rExt
                                       ,lType
                                      )
    {
    }

    // creating and saving icons is not supported
    virtual bool Create( wxGDIImage* WXUNUSED(pImage)
                        ,void*       WXUNUSED(pData)
                        ,long        WXUNUSED(lFlags)
                        ,int         WXUNUSED(nWidth)
                        ,int         WXUNUSED(nHeight)
                        ,int         WXUNUSED(nDepth) = 1
                       )
    {
        return(FALSE);
    }

    virtual bool Save( wxGDIImage*     WXUNUSED(pImage)
                      ,const wxString& WXUNUSED(rName)
                      ,int             WXUNUSED(nType)
                     )
    {
        return(FALSE);
    }
    virtual bool Load( wxGDIImage*     pImage
                      ,const wxString& rName
                      ,HPS             hPs
                      ,long            lFlags
                      ,int             nDesiredWidth
                      ,int             nDesiredHeight
                     )
    {
        wxIcon*                     pIcon = wxDynamicCast(pImage, wxIcon);
        wxCHECK_MSG(pIcon, FALSE, _T("wxIconHandler only works with icons"));

        return LoadIcon( pIcon
                        ,rName
                        ,hPs
                        ,lFlags
                        ,nDesiredWidth
                        ,nDesiredHeight
                       );
    }

protected:
    virtual bool LoadIcon( wxIcon*         pIcon
                          ,const wxString& rName
                          ,HPS             hPs
                          ,long            lFlags
                          ,int             nDesiredWidth = -1
                          ,int             nDesiredHeight = -1
                         ) = 0;
};

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

    virtual bool LoadIcon( wxIcon *        pIcon
                          ,const wxString& rName
                          ,HPS             hPs
                          ,long            lFlags
                          ,int             nDesiredWidth = -1
                          ,int             nDesiredHeight = -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*         pIcon
                          ,const wxString& rName
                          ,HPS             hPs
                          ,long            lFlags
                          ,int             nDesiredWidth = -1
                          ,int             nDesiredHeight = -1
                         );

private:
    DECLARE_DYNAMIC_CLASS(wxICOResourceHandler)
};

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

#if !USE_SHARED_LIBRARIES
    IMPLEMENT_DYNAMIC_CLASS(wxBMPFileHandler, wxBitmapHandler)
    IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
    IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxGDIImageHandler)
    IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxGDIImageHandler)
#endif

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

static wxSize GetHiconSize(WXHICON hicon);

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

wxList wxGDIImage::ms_handlers;

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

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

    return(TRUE);
}

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

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

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

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

bool wxGDIImage::RemoveHandler(
  const wxString&                   rName
)
{
    wxGDIImageHandler*              pHandler = FindHandler(rName);

    if (pHandler)
    {
        ms_handlers.DeleteObject(pHandler);
        return(TRUE);
    }
    else
        return(FALSE);
}

wxGDIImageHandler* wxGDIImage::FindHandler(
  const wxString&                   rName
)
{
    wxNode*                         pNode = ms_handlers.First();

    while (pNode)
    {
        wxGDIImageHandler*          pHandler = (wxGDIImageHandler *)pNode->Data();

        if (pHandler->GetName() == rName)
            return(pHandler);
        pNode = pNode->Next();
    }
    return(NULL);
}

wxGDIImageHandler* wxGDIImage::FindHandler(
  const wxString&                   rExtension
, long                              lType
)
{
    wxNode*                         pNode = ms_handlers.First();

    while (pNode)
    {
        wxGDIImageHandler*          pHandler = (wxGDIImageHandler *)pNode->Data();

        if ((pHandler->GetExtension() = rExtension) &&
            (lType == -1 || pHandler->GetType() == lType))
        {
            return(pHandler);
        }
        pNode = pNode->Next();
    }
    return(NULL);
}

wxGDIImageHandler* wxGDIImage::FindHandler(
  long                              lType
)
{
    wxNode*                         pNode = ms_handlers.First();

    while (pNode)
    {
        wxGDIImageHandler*          pHandler = (wxGDIImageHandler *)pNode->Data();

        if (pHandler->GetType() == lType)
            return pHandler;
        pNode = pNode->Next();
    }
    return(NULL);
}

void wxGDIImage::CleanUpHandlers()
{
    wxNode*                         pNode = ms_handlers.First();

    while (pNode)
    {
        wxGDIImageHandler*          pHandler = (wxGDIImageHandler *)pNode->Data();
        wxNode*                     pNext    = pNode->Next();

        delete pHandler;
        delete pNode;
        pNode = pNext;
    }
}

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

    // Not added by default: include xpmhand.h in your app
    // and call these in your wxApp::OnInit.
    //  AddHandler(new wxXPMFileHandler);
    //  AddHandler(new wxXPMDataHandler);

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

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

bool wxBMPResourceHandler::LoadFile(
  wxBitmap*                         pBitmap
, const wxString&                   rName
, HPS                               hPs
, long                              lFlags
, int                               nDesiredWidth
, int                               nDesiredHeight
)
{
    // TODO: load a bitmap from a file
    /*
    rBitmap->SetHBITMAP((WXHBITMAP)::LoadBitmap(wxGetInstance(), rName));

    wxBitmapRefData*                pData = bitmap->GetBitmapData();

    if (pBitmap->Ok())
    {
        BITMAP                       bm;

        if ( !::GetObject(GetHbitmapOf(*pBitmap), sizeof(BITMAP), (LPSTR) &bm) )
        {
            wxLogLastError("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();
    */
    return(FALSE);
}

bool wxBMPFileHandler::LoadFile(
  wxBitmap*                         pBitmap
, const wxString&                   rName
, HPS                               hPs
, long                              WXUNUSED(lFlags)
, int                               WXUNUSED(nDesiredWidth)
, int                               WXUNUSED(nDesiredHeight)
)
{
#if wxUSE_IMAGE_LOADING_IN_OS2
    wxPalette*                      pPalette = NULL;

    bool                            bSuccess = FALSE; /* wxLoadIntoBitmap( WXSTRINGCAST rName
                                                                ,pBitmap
                                                                ,&pPalette
                                                               ) != 0; */
    if (bSuccess && pPalette)
    {
        pBitmap->SetPalette(*pPalette);
    }

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

    return(bSuccess);
#else
    return(FALSE);
#endif
}

bool wxBMPFileHandler::SaveFile(
  wxBitmap*                         pBitmap
, const wxString&                   rName
, int                               WXUNUSED(nType)
, const wxPalette*                  pPal
)
{
#if wxUSE_IMAGE_LOADING_IN_OS2
    wxPalette*                      pActualPalette = (wxPalette *)pPal;

    if (!pActualPalette)
        pActualPalette = pBitmap->GetPalette();
    /* return(wxSaveBitmap( WXSTRINGCAST rName
                        ,pBitmap
                        ,pActualPalette
                       ) != 0); */
    return(FALSE);
#else
    return(FALSE);
#endif
}

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

bool wxICOFileHandler::LoadIcon(
  wxIcon*                           pIcon
, const wxString&                   rName
, HPS                               hPs
, long                              lFlags
, int                               nDesiredWidth
, int                               nDesiredHeight
)
{
#if wxUSE_RESOURCE_LOADING_IN_OS2
    pIcon->UnRef();

    // actual size
    wxSize                          vSize;

    // TODO: load icon directly from a file
    /*
#ifdef __WIN32__
    HICON hicon = ::ExtractIcon(wxGetInstance(), name, 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) )
    {
        wxLogDebug(_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();
    */
    return(FALSE);
#else
    return(FALSE);
#endif
}

bool wxICOResourceHandler::LoadIcon(
  wxIcon*                           pIcon
, const wxString&                   rName
, HPS                               hPs
, long                              lFlags
, int                               WXUNUSED(nDesiredWidth)
, int                               WXUNUSED(nDesiredHeight)
)
{
    HPOINTER                        hIcon;

    hIcon = ::WinLoadFileIcon( (PSZ)rName.c_str()
                              ,TRUE // load for private use
                             );

    pIcon->SetSize(32, 32); // all OS/2 icons are 32 x 32


    pIcon->SetHICON((WXHICON)hIcon);

    return pIcon->Ok();
} // end of wxICOResourceHandler::LoadIcon

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

static wxSize GetHiconSize(
  WXHICON                           hicon
)
{
    wxSize                          vSize(32, 32);    // default

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