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