]> git.saurik.com Git - wxWidgets.git/blobdiff - src/os2/gdiimage.cpp
update window before changing the scrolling position and really scrolling it to avoid...
[wxWidgets.git] / src / os2 / gdiimage.cpp
index a3ccae8a117a426d1d988d17a018750146f34c90..0d21c81be07966255c235c9ee2e20b5dcf27fe97 100644 (file)
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
-// Name:        msw/gdiimage.cpp
+// Name:        src/os2/gdiimage.cpp
 // Purpose:     wxGDIImage implementation
 // Author:      Vadim Zeitlin
 // Modified by:
 // 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"
+    #include "wx/app.h"
 #endif // WX_PRECOMP
 
 #include "wx/os2/private.h"
-#include "wx/app.h"
 #include "wx/os2/gdiimage.h"
 
+#include "wx/listimpl.cpp"
+WX_DEFINE_LIST(wxGDIImageHandlerList)
+
 // ----------------------------------------------------------------------------
 // private classes
 // ----------------------------------------------------------------------------
@@ -114,14 +113,14 @@ public:
 
     // creating and saving icons is not supported
     virtual bool Create( wxGDIImage* WXUNUSED(pImage)
-                        ,void*       WXUNUSED(pData)
+                        ,const void* WXUNUSED(pData)
                         ,long        WXUNUSED(lFlags)
                         ,int         WXUNUSED(nWidth)
                         ,int         WXUNUSED(nHeight)
                         ,int         WXUNUSED(nDepth) = 1
                        )
     {
-        return(FALSE);
+        return false;
     }
 
     virtual bool Save( wxGDIImage*     WXUNUSED(pImage)
@@ -129,7 +128,7 @@ public:
                       ,int             WXUNUSED(nType)
                      )
     {
-        return(FALSE);
+        return false;
     }
     virtual bool Load( wxGDIImage*     pImage
                       ,const wxString& rName
@@ -140,7 +139,7 @@ public:
                      )
     {
         wxIcon*                     pIcon = wxDynamicCast(pImage, wxIcon);
-        wxCHECK_MSG(pIcon, FALSE, _T("wxIconHandler only works with icons"));
+        wxCHECK_MSG(pIcon, false, _T("wxIconHandler only works with icons"));
 
         return LoadIcon( pIcon
                         ,rName
@@ -160,14 +159,13 @@ protected:
                           ,int             nDesiredHeight = -1
                          ) = 0;
 private:
-    inline virtual bool Load( wxGDIImage*     pImage
-                             ,int             nId
-                             ,long            lFlags
-                             ,int             nDesiredWidth
-                             ,int             nDesiredHeight
-                            )
+    inline virtual bool Load( wxGDIImage* WXUNUSED(pImage),
+                              int         WXUNUSED(nId),
+                              long        WXUNUSED(lFlags),
+                              int         WXUNUSED(nDesiredWidth),
+                              int         WXUNUSED(nDesiredHeight) )
     {
-        return FALSE;
+        return false;
     }
 };
 
@@ -217,32 +215,22 @@ private:
 // 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
 // ============================================================================
 
-wxList wxGDIImage::ms_handlers;
+wxGDIImageHandlerList wxGDIImage::ms_handlers;
 
 // ----------------------------------------------------------------------------
 // wxGDIImage functions forwarded to wxGDIImageRefData
 // ----------------------------------------------------------------------------
 
-bool wxGDIImage::FreeResource(
-  bool                              WXUNUSED(bForce)
-)
+bool wxGDIImage::FreeResource( bool WXUNUSED(bForce) )
 {
     if ( !IsNull() )
     {
@@ -250,10 +238,10 @@ bool wxGDIImage::FreeResource(
         GetGDIImageData()->m_hHandle = 0;
     }
 
-    return(TRUE);
+    return true;
 }
 
-WXHANDLE wxGDIImage::GetResourceHandle()
+WXHANDLE wxGDIImage::GetResourceHandle() const
 {
     return GetHandle();
 }
@@ -262,50 +250,44 @@ WXHANDLE wxGDIImage::GetResourceHandle()
 // wxGDIImage handler stuff
 // ----------------------------------------------------------------------------
 
-void wxGDIImage::AddHandler(
-  wxGDIImageHandler*                pHandler
-)
+void wxGDIImage::AddHandler( wxGDIImageHandler* pHandler )
 {
     ms_handlers.Append(pHandler);
 }
 
-void wxGDIImage::InsertHandler(
-  wxGDIImageHandler*                pHandler
-)
+void wxGDIImage::InsertHandler( wxGDIImageHandler* 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);
-        return(TRUE);
+        return true;
     }
     else
-        return(FALSE);
+        return false;
 }
 
 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);
+    return((wxGDIImageHandler*)NULL);
 }
 
 wxGDIImageHandler* wxGDIImage::FindHandler(
@@ -313,52 +295,49 @@ wxGDIImageHandler* wxGDIImage::FindHandler(
 , long                              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);
+    return((wxGDIImageHandler*)NULL);
 }
 
 wxGDIImageHandler* wxGDIImage::FindHandler(
   long                              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;
-        pNode = pNode->Next();
+        pNode = pNode->GetNext();
     }
-    return(NULL);
+    return((wxGDIImageHandler*)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;
-#if (!(defined(__VISAGECPP__) && (__IBMCPP__ < 400 || __IBMC__ < 400 )))
-        delete pNode;
-#endif
+        ms_handlers.Erase( pNode );
         pNode = pNext;
     }
 }
@@ -375,13 +354,11 @@ void wxGDIImage::InitStandardHandlers()
 // wxBitmap handlers
 // ----------------------------------------------------------------------------
 
-bool wxBMPResourceHandler::LoadFile(
-  wxBitmap*                         pBitmap
-, int                               nId
-, long                              lFlags
-, int                               nDesiredWidth
-, int                               nDesiredHeight
-)
+bool wxBMPResourceHandler::LoadFile( wxBitmap* pBitmap,
+                                     int       nId,
+                                     long      WXUNUSED(lFlags),
+                                     int       WXUNUSED(nDesiredWidth),
+                                     int       WXUNUSED(nDesiredHeight) )
 {
     SIZEL                               vSize = {0, 0};
     DEVOPENSTRUC                        vDop  = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
@@ -411,22 +388,20 @@ bool wxBMPResourceHandler::LoadFile(
     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)
-)
+bool wxBMPFileHandler::LoadFile( wxBitmap*       pBitmap,
+                                 const wxString& WXUNUSED(rName),
+                                 HPS             WXUNUSED(hPs),
+                                 long            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);
@@ -437,19 +412,18 @@ bool wxBMPFileHandler::LoadFile(
 
     return(bSuccess);
 #else
-    return(FALSE);
+    wxUnusedVar(pBitmap);
+    return false;
 #endif
 }
 
-bool wxBMPFileHandler::SaveFile(
-  wxBitmap*                         pBitmap
-, const wxString&                   rName
-, int                               WXUNUSED(nType)
-, const wxPalette*                  pPal
-)
+bool wxBMPFileHandler::SaveFile( wxBitmap*        pBitmap,
+                                 const wxString&  WXUNUSED(rName),
+                                 int              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();
@@ -457,9 +431,11 @@ bool wxBMPFileHandler::SaveFile(
                         ,pBitmap
                         ,pActualPalette
                        ) != 0); */
-    return(FALSE);
+    return false;
 #else
-    return(FALSE);
+    wxUnusedVar(pBitmap);
+    wxUnusedVar(pPal);
+    return false;
 #endif
 }
 
@@ -467,35 +443,29 @@ bool wxBMPFileHandler::SaveFile(
 // 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),
+                                 long            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();
 
-    // actual size
-    wxSize                          vSize;
-
-    return(FALSE);
+    return false;
 #else
-    return(FALSE);
+    wxUnusedVar(pIcon);
+    return false;
 #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),
+                                     long            WXUNUSED(lFlags),
+                                     int             WXUNUSED(nDesiredWidth),
+                                     int             WXUNUSED(nDesiredHeight) )
 {
     HPOINTER                        hIcon;
 
@@ -505,23 +475,7 @@ bool wxICOResourceHandler::LoadIcon(
 
     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);
-}
-