Centre wxSlider value correctly when wxSL_MIN_MAX_LABELS is not used.

[wxWidgets.git] / src / os2 / gdiimage.cpp

diff --git a/src/os2/gdiimage.cpp b/src/os2/gdiimage.cpp
index 82ec08a00c78cf5f51b0cf2cd6701ec0f3cf650e..405d2221f3bf3a580219807e43f3fef4cd46977b 100644 (file)
--- a/src/os2/gdiimage.cpp
+++ b/src/os2/gdiimage.cpp
@@ -1,12 +1,12 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        msw/gdiimage.cpp
+// Name:        src/os2/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>
 // 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
+// Licence:     wxWindows licence

 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================


@@ -17,23 +17,21 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // 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"
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 
 #ifndef WX_PRECOMP
     #include "wx/string.h"

+    #include "wx/app.h"

 #endif // WX_PRECOMP
 
 #include "wx/os2/private.h"
 #endif // WX_PRECOMP
 
 #include "wx/os2/private.h"

-#include "wx/app.h"
-#include "wx/xpmhand.h"

 #include "wx/os2/gdiimage.h"
 
 #include "wx/os2/gdiimage.h"
 

+#include "wx/listimpl.cpp"
+WX_DEFINE_LIST(wxGDIImageHandlerList)
+

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


@@ -44,7 +42,7 @@
 class WXDLLEXPORT wxBMPFileHandler : public wxBitmapHandler
 {
 public:
 class WXDLLEXPORT wxBMPFileHandler : public wxBitmapHandler
 {
 public:

-    wxBMPFileHandler() : wxBitmapHandler(_T("Windows bitmap file"), _T("bmp"),
+    wxBMPFileHandler() : wxBitmapHandler(wxT("Windows bitmap file"), wxT("bmp"),

                                          wxBITMAP_TYPE_BMP)
     {
     }
                                          wxBITMAP_TYPE_BMP)
     {
     }


@@ -52,33 +50,46 @@ public:
     virtual bool LoadFile( wxBitmap*       pBitmap
                           ,const wxString& rName
                           ,HPS             hPs
     virtual bool LoadFile( wxBitmap*       pBitmap
                           ,const wxString& rName
                           ,HPS             hPs

-                          ,long            lFlags
+                          ,wxBitmapType    lFlags

                           ,int             nDesiredWidth
                           ,int             nDesiredHeight
                          );
     virtual bool SaveFile( wxBitmap*        pBitmap
                           ,const wxString&  rName
                           ,int             nDesiredWidth
                           ,int             nDesiredHeight
                          );
     virtual bool SaveFile( wxBitmap*        pBitmap
                           ,const wxString&  rName

-                          ,int              lType
+                          ,wxBitmapType     lType

                           ,const wxPalette* pPalette = NULL
                          );
 
 private:
                           ,const wxPalette* pPalette = NULL
                          );
 
 private:

+    inline virtual bool LoadFile( wxBitmap*       pBitmap
+                                 ,int             nId
+                                 ,wxBitmapType    lFlags
+                                 ,int             nDesiredWidth
+                                 ,int             nDesiredHeight
+                                )
+    {
+        return wxBitmapHandler::LoadFile( pBitmap
+                                         ,nId
+                                         ,lFlags
+                                         ,nDesiredWidth
+                                         ,nDesiredHeight
+                                        );
+    }

     DECLARE_DYNAMIC_CLASS(wxBMPFileHandler)
 };
 
 class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
 {
 public:
     DECLARE_DYNAMIC_CLASS(wxBMPFileHandler)
 };
 
 class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
 {
 public:

-    wxBMPResourceHandler() : wxBitmapHandler(_T("Windows bitmap resource"),
+    wxBMPResourceHandler() : wxBitmapHandler(wxT("Windows bitmap resource"),

                                              wxEmptyString,
                                              wxBITMAP_TYPE_BMP_RESOURCE)
     {
     }
 
     virtual bool LoadFile( wxBitmap*       pBitmap
                                              wxEmptyString,
                                              wxBITMAP_TYPE_BMP_RESOURCE)
     {
     }
 
     virtual bool LoadFile( wxBitmap*       pBitmap

-                          ,const wxString& rName
-                          ,HPS             hPs
-                          ,long            lFlags
+                          ,int             nId
+                          ,wxBitmapType    lFlags

                           ,int             nDesiredWidth
                           ,int             nDesiredHeight
                          );
                           ,int             nDesiredWidth
                           ,int             nDesiredHeight
                          );


@@ -92,7 +103,7 @@ class WXDLLEXPORT wxIconHandler : public wxGDIImageHandler
 public:
     wxIconHandler( const wxString& rName
                   ,const wxString& rExt
 public:
     wxIconHandler( const wxString& rName
                   ,const wxString& rExt

-                  ,long            lType
+                  ,wxBitmapType    lType

                  ) : wxGDIImageHandler( rName
                                        ,rExt
                                        ,lType
                  ) : wxGDIImageHandler( rName
                                        ,rExt
                                        ,lType


@@ -102,33 +113,33 @@ public:
 
     // creating and saving icons is not supported
     virtual bool Create( wxGDIImage* WXUNUSED(pImage)
 
     // creating and saving icons is not supported
     virtual bool Create( wxGDIImage* WXUNUSED(pImage)

-                        ,void*       WXUNUSED(pData)
-                        ,long        WXUNUSED(lFlags)
+                        ,const void* WXUNUSED(pData)
+                        ,wxBitmapType WXUNUSED(lFlags)

                         ,int         WXUNUSED(nWidth)
                         ,int         WXUNUSED(nHeight)
                         ,int         WXUNUSED(nDepth) = 1
                        )
     {
                         ,int         WXUNUSED(nWidth)
                         ,int         WXUNUSED(nHeight)
                         ,int         WXUNUSED(nDepth) = 1
                        )
     {

-        return(FALSE);
+        return false;

     }
 
     }
 

-    virtual bool Save( wxGDIImage*     WXUNUSED(pImage)
-                      ,const wxString& WXUNUSED(rName)
-                      ,int             WXUNUSED(nType)
-                     )
+    virtual bool Save( const wxGDIImage* WXUNUSED(pImage)
+                      ,const wxString&   WXUNUSED(rName)
+                      ,wxBitmapType      WXUNUSED(nType)
+                     ) const

     {
     {

-        return(FALSE);
+        return false;

     }
     virtual bool Load( wxGDIImage*     pImage
                       ,const wxString& rName
                       ,HPS             hPs
     }
     virtual bool Load( wxGDIImage*     pImage
                       ,const wxString& rName
                       ,HPS             hPs

-                      ,long            lFlags
+                      ,wxBitmapType    lFlags

                       ,int             nDesiredWidth
                       ,int             nDesiredHeight
                      )
     {
         wxIcon*                     pIcon = wxDynamicCast(pImage, wxIcon);
                       ,int             nDesiredWidth
                       ,int             nDesiredHeight
                      )
     {
         wxIcon*                     pIcon = wxDynamicCast(pImage, wxIcon);

-        wxCHECK_MSG(pIcon, FALSE, _T("wxIconHandler only works with icons"));
+        wxCHECK_MSG(pIcon, false, wxT("wxIconHandler only works with icons"));

 
         return LoadIcon( pIcon
                         ,rName
 
         return LoadIcon( pIcon
                         ,rName


@@ -143,17 +154,26 @@ protected:
     virtual bool LoadIcon( wxIcon*         pIcon
                           ,const wxString& rName
                           ,HPS             hPs
     virtual bool LoadIcon( wxIcon*         pIcon
                           ,const wxString& rName
                           ,HPS             hPs

-                          ,long            lFlags
+                          ,wxBitmapType    lFlags

                           ,int             nDesiredWidth = -1
                           ,int             nDesiredHeight = -1
                          ) = 0;
                           ,int             nDesiredWidth = -1
                           ,int             nDesiredHeight = -1
                          ) = 0;

+private:
+    inline virtual bool Load( wxGDIImage* WXUNUSED(pImage),
+                              int         WXUNUSED(nId),
+                              wxBitmapType WXUNUSED(lFlags),
+                              int         WXUNUSED(nDesiredWidth),
+                              int         WXUNUSED(nDesiredHeight) )
+    {
+        return false;
+    }

 };
 
 class WXDLLEXPORT wxICOFileHandler : public wxIconHandler
 {
 public:
 };
 
 class WXDLLEXPORT wxICOFileHandler : public wxIconHandler
 {
 public:

-    wxICOFileHandler() : wxIconHandler(_T("ICO icon file"),
-                                       _T("ico"),
+    wxICOFileHandler() : wxIconHandler(wxT("ICO icon file"),
+                                       wxT("ico"),

                                        wxBITMAP_TYPE_ICO)
     {
     }
                                        wxBITMAP_TYPE_ICO)
     {
     }


@@ -161,7 +181,7 @@ public:
     virtual bool LoadIcon( wxIcon *        pIcon
                           ,const wxString& rName
                           ,HPS             hPs
     virtual bool LoadIcon( wxIcon *        pIcon
                           ,const wxString& rName
                           ,HPS             hPs

-                          ,long            lFlags
+                          ,wxBitmapType    lFlags

                           ,int             nDesiredWidth = -1
                           ,int             nDesiredHeight = -1
                          );
                           ,int             nDesiredWidth = -1
                           ,int             nDesiredHeight = -1
                          );


@@ -173,8 +193,8 @@ private:
 class WXDLLEXPORT wxICOResourceHandler: public wxIconHandler
 {
 public:
 class WXDLLEXPORT wxICOResourceHandler: public wxIconHandler
 {
 public:

-    wxICOResourceHandler() : wxIconHandler(_T("ICO resource"),
-                                           _T("ico"),
+    wxICOResourceHandler() : wxIconHandler(wxT("ICO resource"),
+                                           wxT("ico"),

                                            wxBITMAP_TYPE_ICO_RESOURCE)
     {
     }
                                            wxBITMAP_TYPE_ICO_RESOURCE)
     {
     }


@@ -182,7 +202,7 @@ public:
     virtual bool LoadIcon( wxIcon*         pIcon
                           ,const wxString& rName
                           ,HPS             hPs
     virtual bool LoadIcon( wxIcon*         pIcon
                           ,const wxString& rName
                           ,HPS             hPs

-                          ,long            lFlags
+                          ,wxBitmapType    lFlags

                           ,int             nDesiredWidth = -1
                           ,int             nDesiredHeight = -1
                          );
                           ,int             nDesiredWidth = -1
                           ,int             nDesiredHeight = -1
                          );


@@ -195,32 +215,22 @@ private:
 // wxWin macros
 // ----------------------------------------------------------------------------
 
 // 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);
+IMPLEMENT_DYNAMIC_CLASS(wxBMPFileHandler, wxBitmapHandler)
+IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
+IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxObject)
+IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxObject)

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

-wxList wxGDIImage::ms_handlers;
+wxGDIImageHandlerList wxGDIImage::ms_handlers;

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

-bool wxGDIImage::FreeResource(
-  bool                              WXUNUSED(bForce)
-)
+bool wxGDIImage::FreeResource( bool WXUNUSED(bForce) )

 {
     if ( !IsNull() )
     {
 {
     if ( !IsNull() )
     {


@@ -228,10 +238,10 @@ bool wxGDIImage::FreeResource(
         GetGDIImageData()->m_hHandle = 0;
     }
 
         GetGDIImageData()->m_hHandle = 0;
     }
 

-    return(TRUE);
+    return true;

 }
 
 }
 

-WXHANDLE wxGDIImage::GetResourceHandle()
+WXHANDLE wxGDIImage::GetResourceHandle() const

 {
     return GetHandle();
 }
 {
     return GetHandle();
 }


@@ -240,103 +250,94 @@ WXHANDLE wxGDIImage::GetResourceHandle()
 // wxGDIImage handler stuff
 // ----------------------------------------------------------------------------
 
 // wxGDIImage handler stuff
 // ----------------------------------------------------------------------------
 

-void wxGDIImage::AddHandler(
-  wxGDIImageHandler*                pHandler
-)
+void wxGDIImage::AddHandler( wxGDIImageHandler* pHandler )

 {
     ms_handlers.Append(pHandler);
 }
 
 {
     ms_handlers.Append(pHandler);
 }
 

-void wxGDIImage::InsertHandler(
-  wxGDIImageHandler*                pHandler
-)
+void wxGDIImage::InsertHandler( wxGDIImageHandler* pHandler )

 {
     ms_handlers.Insert(pHandler);
 }
 
 {
     ms_handlers.Insert(pHandler);
 }
 

-bool wxGDIImage::RemoveHandler(
-  const wxString&                   rName
-)
+bool wxGDIImage::RemoveHandler( const wxString& rName )

 {
     wxGDIImageHandler*              pHandler = FindHandler(rName);
 
     if (pHandler)
     {
         ms_handlers.DeleteObject(pHandler);
 {
     wxGDIImageHandler*              pHandler = FindHandler(rName);
 
     if (pHandler)
     {
         ms_handlers.DeleteObject(pHandler);

-        return(TRUE);
+        return true;

     }
     else
     }
     else

-        return(FALSE);
+        return false;

 }
 
 wxGDIImageHandler* wxGDIImage::FindHandler(
   const wxString&                   rName
 )
 {
 }
 
 wxGDIImageHandler* wxGDIImage::FindHandler(
   const wxString&                   rName
 )
 {

-    wxNode*                         pNode = ms_handlers.First();
+    wxGDIImageHandlerList::compatibility_iterator   pNode = ms_handlers.GetFirst();

 
 

-    while (pNode)
+    while ( pNode )

     {
     {

-        wxGDIImageHandler*          pHandler = (wxGDIImageHandler *)pNode->Data();
+        wxGDIImageHandler*          pHandler = pNode->GetData();

 
 

-        if (pHandler->GetName() == rName)
-            return(pHandler);
-        pNode = pNode->Next();
+        if ( pHandler->GetName() == rName )
+            return pHandler;
+        pNode = pNode->GetNext();

     }
     return(NULL);
 }
 
 wxGDIImageHandler* wxGDIImage::FindHandler(
   const wxString&                   rExtension
     }
     return(NULL);
 }
 
 wxGDIImageHandler* wxGDIImage::FindHandler(
   const wxString&                   rExtension

-, long                              lType
+, wxBitmapType                      lType

 )
 {
 )
 {

-    wxNode*                         pNode = ms_handlers.First();
-
-    while (pNode)
+    wxGDIImageHandlerList::compatibility_iterator   pNode = ms_handlers.GetFirst();
+    while ( pNode )

     {
     {

-        wxGDIImageHandler*          pHandler = (wxGDIImageHandler *)pNode->Data();
+        wxGDIImageHandler*          pHandler = pNode->GetData();

 
 

-        if ((pHandler->GetExtension() = rExtension) &&
-            (lType == -1 || pHandler->GetType() == lType))
+        if ( (pHandler->GetExtension() == rExtension) &&
+             (lType == -1 || pHandler->GetType() == lType) )

         {
         {

-            return(pHandler);
+            return pHandler;

         }
         }

-        pNode = pNode->Next();
+        pNode = pNode->GetNext();

     }
     return(NULL);
 }
 
 wxGDIImageHandler* wxGDIImage::FindHandler(
     }
     return(NULL);
 }
 
 wxGDIImageHandler* wxGDIImage::FindHandler(

-  long                              lType
+  wxBitmapType                           lType

 )
 {
 )
 {

-    wxNode*                         pNode = ms_handlers.First();
+    wxGDIImageHandlerList::compatibility_iterator   pNode = ms_handlers.GetFirst();

 
 

-    while (pNode)
+    while ( pNode )

     {
     {

-        wxGDIImageHandler*          pHandler = (wxGDIImageHandler *)pNode->Data();
+        wxGDIImageHandler*          pHandler = pNode->GetData();

 
 

-        if (pHandler->GetType() == lType)
+        if ( pHandler->GetType() == lType )

             return pHandler;
             return pHandler;

-        pNode = pNode->Next();
+        pNode = pNode->GetNext();

     }
     return(NULL);
 }
 
 void wxGDIImage::CleanUpHandlers()
 {
     }
     return(NULL);
 }
 
 void wxGDIImage::CleanUpHandlers()
 {

-    wxNode*                         pNode = ms_handlers.First();
+    wxGDIImageHandlerList::compatibility_iterator   pNode = ms_handlers.GetFirst();

 
 

-    while (pNode)
+    while ( pNode )

     {
     {

-        wxGDIImageHandler*          pHandler = (wxGDIImageHandler *)pNode->Data();
-        wxNode*                     pNext    = pNode->Next();
+        wxGDIImageHandler*                              pHandler = pNode->GetData();
+        wxGDIImageHandlerList::compatibility_iterator   pNext = pNode->GetNext();

 
         delete pHandler;
 
         delete pHandler;

-#if (!(defined(__VISAGECPP__) && (__IBMCPP__ < 400 || __IBMC__ < 400 )))
-        delete pNode;
-#endif
+        ms_handlers.Erase( pNode );

         pNode = pNext;
     }
 }
         pNode = pNext;
     }
 }


@@ -345,12 +346,6 @@ void wxGDIImage::InitStandardHandlers()
 {
     AddHandler(new wxBMPResourceHandler);
     AddHandler(new wxBMPFileHandler);
 {
     AddHandler(new wxBMPResourceHandler);
     AddHandler(new wxBMPFileHandler);

-
-#if wxUSE_XPM_IN_OS2
-    AddHandler(new wxXPMFileHandler);
-    AddHandler(new wxXPMDataHandler);
-#endif
-

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


@@ -359,62 +354,54 @@ void wxGDIImage::InitStandardHandlers()
 // wxBitmap handlers
 // ----------------------------------------------------------------------------
 
 // wxBitmap handlers
 // ----------------------------------------------------------------------------
 

-bool wxBMPResourceHandler::LoadFile(
-  wxBitmap*                         pBitmap
-, const wxString&                   rName
-, HPS                               hPs
-, long                              lFlags
-, int                               nDesiredWidth
-, int                               nDesiredHeight
-)
+bool wxBMPResourceHandler::LoadFile( wxBitmap* pBitmap,
+                                     int       nId,
+                                     wxBitmapType WXUNUSED(lFlags),
+                                     int       WXUNUSED(nDesiredWidth),
+                                     int       WXUNUSED(nDesiredHeight) )

 {
 {

-    // TODO: load a bitmap from a file
-    /*
-    rBitmap->SetHBITMAP((WXHBITMAP)::LoadBitmap(wxGetInstance(), rName));
-
-    wxBitmapRefData*                pData = bitmap->GetBitmapData();
-
-    if (pBitmap->Ok())
+    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->IsOk() )

     {
     {

-        BITMAP                       bm;
-
-        if ( !::GetObject(GetHbitmapOf(*pBitmap), sizeof(BITMAP), (LPSTR) &bm) )
-        {
-            wxLogLastError("GetObject(HBITMAP)");
-        }
+        BITMAPINFOHEADER            vBmph;

 
 

-        data->m_width = bm.bmWidth;
-        data->m_height = bm.bmHeight;
-        data->m_depth = bm.bmBitsPixel;
+        ::GpiQueryBitmapParameters(GetHbitmapOf(*pBitmap), &vBmph);
+        pData->m_nWidth  = vBmph.cx;
+        pData->m_nHeight = vBmph.cy;
+        pData->m_nDepth  = vBmph.cBitCount;

     }
     }

-    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)
-)
+    return(pBitmap->IsOk());
+} // end of wxBMPResourceHandler::LoadFile
+
+bool wxBMPFileHandler::LoadFile( wxBitmap*       pBitmap,
+                                 const wxString& WXUNUSED(rName),
+                                 HPS             WXUNUSED(hPs),
+                                 wxBitmapType    WXUNUSED(lFlags),
+                                 int             WXUNUSED(nDesiredWidth),
+                                 int             WXUNUSED(nDesiredHeight) )

 {
 {

-#if wxUSE_IMAGE_LOADING_IN_OS2
-    wxPalette*                      pPalette = NULL;
+#if defined(wxUSE_IMAGE_LOADING_IN_OS2) && wxUSE_IMAGE_LOADING_IN_OS2
+    wxPalette* pPalette = NULL;

 
 

-    bool                            bSuccess = FALSE; /* wxLoadIntoBitmap( WXSTRINGCAST rName
-                                                                ,pBitmap
-                                                                ,&pPalette
-                                                               ) != 0; */
+    bool bSuccess = false; /* wxLoadIntoBitmap( WXSTRINGCAST rName
+                                               ,pBitmap
+                                               ,&pPalette
+                                              ) != 0; */

     if (bSuccess && pPalette)
     {
         pBitmap->SetPalette(*pPalette);
     if (bSuccess && pPalette)
     {
         pBitmap->SetPalette(*pPalette);


@@ -425,19 +412,18 @@ bool wxBMPFileHandler::LoadFile(
 
     return(bSuccess);
 #else
 
     return(bSuccess);
 #else

-    return(FALSE);
+    wxUnusedVar(pBitmap);
+    return false;

 #endif
 }
 
 #endif
 }
 

-bool wxBMPFileHandler::SaveFile(
-  wxBitmap*                         pBitmap
-, const wxString&                   rName
-, int                               WXUNUSED(nType)
-, const wxPalette*                  pPal
-)
+bool wxBMPFileHandler::SaveFile( wxBitmap*        pBitmap,
+                                 const wxString&  WXUNUSED(rName),
+                                 wxBitmapType     WXUNUSED(nType),
+                                 const wxPalette* pPal )

 {
 {

-#if wxUSE_IMAGE_LOADING_IN_OS2
-    wxPalette*                      pActualPalette = (wxPalette *)pPal;
+#if defined(wxUSE_IMAGE_LOADING_IN_OS2) && wxUSE_IMAGE_LOADING_IN_OS2
+    wxPalette* pActualPalette = (wxPalette *)pPal;

 
     if (!pActualPalette)
         pActualPalette = pBitmap->GetPalette();
 
     if (!pActualPalette)
         pActualPalette = pBitmap->GetPalette();


@@ -445,9 +431,11 @@ bool wxBMPFileHandler::SaveFile(
                         ,pBitmap
                         ,pActualPalette
                        ) != 0); */
                         ,pBitmap
                         ,pActualPalette
                        ) != 0); */

-    return(FALSE);
+    return false;

 #else
 #else

-    return(FALSE);
+    wxUnusedVar(pBitmap);
+    wxUnusedVar(pPal);
+    return false;

 #endif
 }
 
 #endif
 }
 


@@ -455,99 +443,39 @@ bool wxBMPFileHandler::SaveFile(
 // wxIcon handlers
 // ----------------------------------------------------------------------------
 
 // wxIcon handlers
 // ----------------------------------------------------------------------------
 

-bool wxICOFileHandler::LoadIcon(
-  wxIcon*                           pIcon
-, const wxString&                   rName
-, HPS                               hPs
-, long                              lFlags
-, int                               nDesiredWidth
-, int                               nDesiredHeight
-)
+bool wxICOFileHandler::LoadIcon( wxIcon*         pIcon,
+                                 const wxString& WXUNUSED(rName),
+                                 HPS             WXUNUSED(hPs),
+                                 wxBitmapType    WXUNUSED(lFlags),
+                                 int             WXUNUSED(nDesiredWidth),
+                                 int             WXUNUSED(nDesiredHeight) )

 {
 {

-#if wxUSE_RESOURCE_LOADING_IN_OS2
+#if defined(wxUSE_RESOURCE_LOADING_IN_OS2) && wxUSE_RESOURCE_LOADING_IN_OS2

     pIcon->UnRef();
 
     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);
+    return false;

 #else
 #else

-    return(FALSE);
+    wxUnusedVar(pIcon);
+    return false;

 #endif
 }
 
 #endif
 }
 

-bool wxICOResourceHandler::LoadIcon(
-  wxIcon*                           pIcon
-, const wxString&                   rName
-, HPS                               hPs
-, long                              lFlags
-, int                               WXUNUSED(nDesiredWidth)
-, int                               WXUNUSED(nDesiredHeight)
-)
+bool wxICOResourceHandler::LoadIcon( wxIcon*         pIcon,
+                                     const wxString& rName,
+                                     HPS             WXUNUSED(hPs),
+                                     wxBitmapType    WXUNUSED(lFlags),
+                                     int             WXUNUSED(nDesiredWidth),
+                                     int             WXUNUSED(nDesiredHeight) )

 {
     HPOINTER                        hIcon;
 
 {
     HPOINTER                        hIcon;
 

-    hIcon = ::WinLoadFileIcon( (PSZ)rName.c_str()
+    hIcon = ::WinLoadFileIcon( rName.c_str()

                               ,TRUE // load for private use
                              );
 
     pIcon->SetSize(32, 32); // all OS/2 icons are 32 x 32
 
                               ,TRUE // load for private use
                              );
 
     pIcon->SetSize(32, 32); // all OS/2 icons are 32 x 32
 

-

     pIcon->SetHICON((WXHICON)hIcon);
 
     pIcon->SetHICON((WXHICON)hIcon);
 

-    return pIcon->Ok();
+    return pIcon->IsOk();

 } // end of wxICOResourceHandler::LoadIcon
 } // end of wxICOResourceHandler::LoadIcon

-
-// ----------------------------------------------------------------------------
-// private functions
-// ----------------------------------------------------------------------------
-
-static wxSize GetHiconSize(
-  WXHICON                           hicon
-)
-{
-    wxSize                          vSize(32, 32);    // default
-
-    // all OS/2 icons are 32x32
-    return(vSize);
-}
-