[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/xpmhand.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;
#if (!(defined(__VISAGECPP__) && (__IBMCPP__ < 400 || __IBMC__ < 400 )))
        delete pNode;
#endif
        pNode = pNext;
    }
}

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

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