[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:
    inline virtual bool LoadFile( wxBitmap*       pBitmap
                                 ,int             nId
                                 ,long            lFlags
                                 ,int             nDesiredWidth
                                 ,int             nDesiredHeight
                                )
    {
        return wxBitmapHandler::LoadFile( pBitmap
                                         ,nId
                                         ,lFlags
                                         ,nDesiredWidth
                                         ,nDesiredHeight
                                        );
    }
    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
                          ,int             nId
                          ,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;
private:
    inline virtual bool Load( wxGDIImage*     pImage
                             ,int             nId
                             ,long            lFlags
                             ,int             nDesiredWidth
                             ,int             nDesiredHeight
                            )
    {
        return FALSE;
    }
};

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
, int                               nId
, long                              lFlags
, int                               nDesiredWidth
, int                               nDesiredHeight
)
{
    SIZEL                               vSize = {0, 0};
    DEVOPENSTRUC                        vDop  = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
    HDC                                 hDC   = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
    HPS                                 hPS   = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);

    pBitmap->SetHBITMAP((WXHBITMAP)::GpiLoadBitmap( hPS
                                                   ,NULLHANDLE
                                                   ,nId
                                                   ,0
                                                   ,0
                                                  ));
    ::GpiDestroyPS(hPS);
    ::DevCloseDC(hDC);

    wxBitmapRefData*                pData = pBitmap->GetBitmapData();

    if ( pBitmap->Ok() )
    {
        BITMAPINFOHEADER            vBmph;

        ::GpiQueryBitmapParameters(GetHbitmapOf(*pBitmap), &vBmph);
        pData->m_nWidth  = vBmph.cx;
        pData->m_nHeight = vBmph.cy;
        pData->m_nDepth  = vBmph.cBitCount;
    }
    return(pBitmap->Ok());
} // end of wxBMPResourceHandler::LoadFile

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;

    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:
3029781e DW	65	inline virtual bool LoadFile( wxBitmap* pBitmap
	66	,int nId
	67	,long lFlags
	68	,int nDesiredWidth
	69	,int nDesiredHeight
	70	)
	71	{
	72	return wxBitmapHandler::LoadFile( pBitmap
	73	,nId
	74	,lFlags
	75	,nDesiredWidth
	76	,nDesiredHeight
	77	);
	78	}
b4eb4c6b DW	79	DECLARE_DYNAMIC_CLASS(wxBMPFileHandler)
	80	};
	81
	82	class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
	83	{
	84	public:
	85	wxBMPResourceHandler() : wxBitmapHandler(_T("Windows bitmap resource"),
	86	wxEmptyString,
	87	wxBITMAP_TYPE_BMP_RESOURCE)
	88	{
	89	}
	90
	91	virtual bool LoadFile( wxBitmap* pBitmap
3029781e	92	,int nId
b4eb4c6b DW	93	,long lFlags
	94	,int nDesiredWidth
	95	,int nDesiredHeight
	96	);
	97
	98	private:
	99	DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler)
	100	};
	101
	102	class WXDLLEXPORT wxIconHandler : public wxGDIImageHandler
	103	{
	104	public:
	105	wxIconHandler( const wxString& rName
	106	,const wxString& rExt
	107	,long lType
	108	) : wxGDIImageHandler( rName
	109	,rExt
	110	,lType
	111	)
	112	{
	113	}
	114
	115	// creating and saving icons is not supported
	116	virtual bool Create( wxGDIImage* WXUNUSED(pImage)
	117	,void* WXUNUSED(pData)
	118	,long WXUNUSED(lFlags)
	119	,int WXUNUSED(nWidth)
	120	,int WXUNUSED(nHeight)
	121	,int WXUNUSED(nDepth) = 1
	122	)
	123	{
	124	return(FALSE);
	125	}
	126
	127	virtual bool Save( wxGDIImage* WXUNUSED(pImage)
	128	,const wxString& WXUNUSED(rName)
	129	,int WXUNUSED(nType)
	130	)
	131	{
	132	return(FALSE);
	133	}
	134	virtual bool Load( wxGDIImage* pImage
	135	,const wxString& rName
	136	,HPS hPs
	137	,long lFlags
	138	,int nDesiredWidth
	139	,int nDesiredHeight
	140	)
	141	{
	142	wxIcon* pIcon = wxDynamicCast(pImage, wxIcon);
	143	wxCHECK_MSG(pIcon, FALSE, _T("wxIconHandler only works with icons"));
	144
	145	return LoadIcon( pIcon
	146	,rName
	147	,hPs
	148	,lFlags
	149	,nDesiredWidth
	150	,nDesiredHeight
	151	);
	152	}
	153
	154	protected:
	155	virtual bool LoadIcon( wxIcon* pIcon
	156	,const wxString& rName
157	,HPS hPs
158	,long lFlags
159	,int nDesiredWidth = -1
160	,int nDesiredHeight = -1
161	) = 0;
3029781e DW	162	private:
	163	inline virtual bool Load( wxGDIImage* pImage
	164	,int nId
	165	,long lFlags
	166	,int nDesiredWidth
	167	,int nDesiredHeight
	168	)
	169	{
	170	return FALSE;
	171	}
b4eb4c6b DW	172	};
	173
	174	class WXDLLEXPORT wxICOFileHandler : public wxIconHandler
	175	{
	176	public:
	177	wxICOFileHandler() : wxIconHandler(_T("ICO icon file"),
	178	_T("ico"),
	179	wxBITMAP_TYPE_ICO)
	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(wxICOFileHandler)
	193	};
	194
	195	class WXDLLEXPORT wxICOResourceHandler: public wxIconHandler
	196	{
	197	public:
	198	wxICOResourceHandler() : wxIconHandler(_T("ICO resource"),
	199	_T("ico"),
	200	wxBITMAP_TYPE_ICO_RESOURCE)
	201	{
	202	}
	203
	204	virtual bool LoadIcon( wxIcon* pIcon
	205	,const wxString& rName
	206	,HPS hPs
	207	,long lFlags
	208	,int nDesiredWidth = -1
	209	,int nDesiredHeight = -1
	210	);
	211
	212	private:
	213	DECLARE_DYNAMIC_CLASS(wxICOResourceHandler)
	214	};
	215
	216	// ----------------------------------------------------------------------------
	217	// wxWin macros
	218	// ----------------------------------------------------------------------------
	219
	220	#if !USE_SHARED_LIBRARIES
	221	IMPLEMENT_DYNAMIC_CLASS(wxBMPFileHandler, wxBitmapHandler)
	222	IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
4a46a5df DW	223	IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxObject)
4a46a5df DW	224	IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxObject)
b4eb4c6b DW	225	#endif
	226
	227	// ----------------------------------------------------------------------------
	228	// private functions
	229	// ----------------------------------------------------------------------------
	230
	231	static wxSize GetHiconSize(WXHICON hicon);
	232
	233	// ============================================================================
	234	// implementation
	235	// ============================================================================
	236
	237	wxList wxGDIImage::ms_handlers;
	238
	239	// ----------------------------------------------------------------------------
	240	// wxGDIImage functions forwarded to wxGDIImageRefData
	241	// ----------------------------------------------------------------------------
	242
	243	bool wxGDIImage::FreeResource(
	244	bool WXUNUSED(bForce)
	245	)
	246	{
	247	if ( !IsNull() )
	248	{
	249	GetGDIImageData()->Free();
	250	GetGDIImageData()->m_hHandle = 0;
	251	}
	252
	253	return(TRUE);
	254	}
	255
	256	WXHANDLE wxGDIImage::GetResourceHandle()
	257	{
	258	return GetHandle();
	259	}
	260
	261	// ----------------------------------------------------------------------------
	262	// wxGDIImage handler stuff
	263	// ----------------------------------------------------------------------------
	264
	265	void wxGDIImage::AddHandler(
	266	wxGDIImageHandler* pHandler
	267	)
	268	{
	269	ms_handlers.Append(pHandler);
	270	}
	271
	272	void wxGDIImage::InsertHandler(
	273	wxGDIImageHandler* pHandler
	274	)
	275	{
	276	ms_handlers.Insert(pHandler);
	277	}
	278
	279	bool wxGDIImage::RemoveHandler(
	280	const wxString& rName
	281	)
	282	{
	283	wxGDIImageHandler* pHandler = FindHandler(rName);
	284
	285	if (pHandler)
	286	{
	287	ms_handlers.DeleteObject(pHandler);
	288	return(TRUE);
289	}
290	else
291	return(FALSE);
292	}
293
294	wxGDIImageHandler* wxGDIImage::FindHandler(
295	const wxString& rName
296	)
297	{
298	wxNode* pNode = ms_handlers.First();
299
300	while (pNode)
301	{
302	wxGDIImageHandler* pHandler = (wxGDIImageHandler *)pNode->Data();
303
304	if (pHandler->GetName() == rName)
305	return(pHandler);
306	pNode = pNode->Next();
307	}
308	return(NULL);
309	}
310
311	wxGDIImageHandler* wxGDIImage::FindHandler(
312	const wxString& rExtension
313	, long lType
314	)
315	{
316	wxNode* pNode = ms_handlers.First();
317
318	while (pNode)
319	{
320	wxGDIImageHandler* pHandler = (wxGDIImageHandler *)pNode->Data();
321
322	if ((pHandler->GetExtension() = rExtension) &&
323	(lType == -1 \|\| pHandler->GetType() == lType))
324	{
325	return(pHandler);
326	}
327	pNode = pNode->Next();
328	}
329	return(NULL);
330	}
331
332	wxGDIImageHandler* wxGDIImage::FindHandler(
333	long lType
334	)
335	{
336	wxNode* pNode = ms_handlers.First();
337
338	while (pNode)
339	{
340	wxGDIImageHandler* pHandler = (wxGDIImageHandler *)pNode->Data();
341
342	if (pHandler->GetType() == lType)
343	return pHandler;
344	pNode = pNode->Next();
345	}
346	return(NULL);
347	}
348
349	void wxGDIImage::CleanUpHandlers()
350	{
351	wxNode* pNode = ms_handlers.First();
352
353	while (pNode)
354	{
355	wxGDIImageHandler* pHandler = (wxGDIImageHandler *)pNode->Data();
356	wxNode* pNext = pNode->Next();
357
358	delete pHandler;
f6bcfd97	359	#if (!(defined(__VISAGECPP__) && (__IBMCPP__ < 400 \|\| __IBMC__ < 400 )))
b4eb4c6b	360	delete pNode;
f6bcfd97	361	#endif
b4eb4c6b DW	362	pNode = pNext;
	363	}
	364	}
	365
	366	void wxGDIImage::InitStandardHandlers()
	367	{
	368	AddHandler(new wxBMPResourceHandler);
	369	AddHandler(new wxBMPFileHandler);
b4eb4c6b DW	370	AddHandler(new wxICOResourceHandler);
	371	AddHandler(new wxICOFileHandler);
	372	}
	373
	374	// ----------------------------------------------------------------------------
	375	// wxBitmap handlers
	376	// ----------------------------------------------------------------------------
	377
	378	bool wxBMPResourceHandler::LoadFile(
	379	wxBitmap* pBitmap
3029781e	380	, int nId
b4eb4c6b DW	381	, long lFlags
	382	, int nDesiredWidth
	383	, int nDesiredHeight
	384	)
	385	{
3029781e DW	386	SIZEL vSize = {0, 0};
	387	DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
	388	HDC hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
	389	HPS hPS = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS \| GPIA_ASSOC);
	390
	391	pBitmap->SetHBITMAP((WXHBITMAP)::GpiLoadBitmap( hPS
	392	,NULLHANDLE
	393	,nId
	394	,0
	395	,0
	396	));
	397	::GpiDestroyPS(hPS);
	398	::DevCloseDC(hDC);
	399
	400	wxBitmapRefData* pData = pBitmap->GetBitmapData();
	401
	402	if ( pBitmap->Ok() )
b4eb4c6b	403	{
3029781e	404	BITMAPINFOHEADER vBmph;
b4eb4c6b	405
3029781e DW	406	::GpiQueryBitmapParameters(GetHbitmapOf(*pBitmap), &vBmph);
	407	pData->m_nWidth = vBmph.cx;
	408	pData->m_nHeight = vBmph.cy;
	409	pData->m_nDepth = vBmph.cBitCount;
b4eb4c6b	410	}
3029781e DW	411	return(pBitmap->Ok());
3029781e DW	412	} // end of wxBMPResourceHandler::LoadFile
b4eb4c6b DW	413
	414	bool wxBMPFileHandler::LoadFile(
	415	wxBitmap* pBitmap
	416	, const wxString& rName
	417	, HPS hPs
	418	, long WXUNUSED(lFlags)
	419	, int WXUNUSED(nDesiredWidth)
	420	, int WXUNUSED(nDesiredHeight)
	421	)
	422	{
	423	#if wxUSE_IMAGE_LOADING_IN_OS2
	424	wxPalette* pPalette = NULL;
	425
	426	bool bSuccess = FALSE; /* wxLoadIntoBitmap( WXSTRINGCAST rName
	427	,pBitmap
	428	,&pPalette
	429	) != 0; */
	430	if (bSuccess && pPalette)
	431	{
	432	pBitmap->SetPalette(*pPalette);
	433	}
	434
	435	// it was copied by the bitmap if it was loaded successfully
	436	delete pPalette;
	437
	438	return(bSuccess);
	439	#else
	440	return(FALSE);
	441	#endif
	442	}
	443
	444	bool wxBMPFileHandler::SaveFile(
	445	wxBitmap* pBitmap
	446	, const wxString& rName
	447	, int WXUNUSED(nType)
	448	, const wxPalette* pPal
	449	)
	450	{
	451	#if wxUSE_IMAGE_LOADING_IN_OS2
	452	wxPalette* pActualPalette = (wxPalette *)pPal;
	453
	454	if (!pActualPalette)
	455	pActualPalette = pBitmap->GetPalette();
	456	/* return(wxSaveBitmap( WXSTRINGCAST rName
	457	,pBitmap
	458	,pActualPalette
	459	) != 0); */
	460	return(FALSE);
	461	#else
	462	return(FALSE);
	463	#endif
	464	}
	465
	466	// ----------------------------------------------------------------------------
	467	// wxIcon handlers
	468	// ----------------------------------------------------------------------------
	469
	470	bool wxICOFileHandler::LoadIcon(
	471	wxIcon* pIcon
	472	, const wxString& rName
	473	, HPS hPs
	474	, long lFlags
	475	, int nDesiredWidth
	476	, int nDesiredHeight
477	)
478	{
479	#if wxUSE_RESOURCE_LOADING_IN_OS2
480	pIcon->UnRef();
481
482	// actual size
483	wxSize vSize;
484
b4eb4c6b DW	485	return(FALSE);
	486	#else
	487	return(FALSE);
	488	#endif
	489	}
	490
	491	bool wxICOResourceHandler::LoadIcon(
	492	wxIcon* pIcon
	493	, const wxString& rName
	494	, HPS hPs
	495	, long lFlags
22e90769 DW	496	, int WXUNUSED(nDesiredWidth)
22e90769 DW	497	, int WXUNUSED(nDesiredHeight)
b4eb4c6b DW	498	)
b4eb4c6b DW	499	{
22e90769	500	HPOINTER hIcon;
b4eb4c6b	501
22e90769 DW	502	hIcon = ::WinLoadFileIcon( (PSZ)rName.c_str()
	503	,TRUE // load for private use
	504	);
b4eb4c6b	505
22e90769	506	pIcon->SetSize(32, 32); // all OS/2 icons are 32 x 32
b4eb4c6b	507
b4eb4c6b	508
22e90769	509	pIcon->SetHICON((WXHICON)hIcon);
b4eb4c6b	510
22e90769 DW	511	return pIcon->Ok();
22e90769 DW	512	} // end of wxICOResourceHandler::LoadIcon
b4eb4c6b DW	513
	514	// ----------------------------------------------------------------------------
	515	// private functions
	516	// ----------------------------------------------------------------------------
	517
	518	static wxSize GetHiconSize(
	519	WXHICON hicon
	520	)
	521	{
	522	wxSize vSize(32, 32); // default
	523
	524	// all OS/2 icons are 32x32
	525	return(vSize);
	526	}
	527