wxDialUpManager fixes

[wxWidgets.git] / src / common / image.cpp

diff --git a/src/common/image.cpp b/src/common/image.cpp
index 69b1f520362e5b2be33ad30864eaf27d5a4bcb90..ab36e52be6d04b5260e104fd2823efe0c9cd274f 100644 (file)
--- a/src/common/image.cpp
+++ b/src/common/image.cpp
@@ -15,7 +15,7 @@
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__

-#pragma hdrstop
+    #pragma hdrstop

 #endif
 
 #include "wx/image.h"
 #endif
 
 #include "wx/image.h"


@@ -32,13 +32,11 @@
 #include <string.h>
 
 #ifdef __SALFORDC__
 #include <string.h>
 
 #ifdef __SALFORDC__

-#ifdef FAR
-#undef FAR
-#endif
+    #undef FAR

 #endif
 
 #ifdef __WXMSW__
 #endif
 
 #ifdef __WXMSW__

-#include <windows.h>
+    #include "wx/msw/private.h"

 #endif
 
 //-----------------------------------------------------------------------------
 #endif
 
 //-----------------------------------------------------------------------------


@@ -49,8 +47,8 @@ class wxImageRefData: public wxObjectRefData
 {
 
 public:
 {
 
 public:

-    wxImageRefData(void);
-    ~wxImageRefData(void);
+    wxImageRefData();
+    ~wxImageRefData();

 
     int             m_width;
     int             m_height;
 
     int             m_width;
     int             m_height;


@@ -60,7 +58,7 @@ public:
     bool            m_ok;
 };
 
     bool            m_ok;
 };
 

-wxImageRefData::wxImageRefData(void)
+wxImageRefData::wxImageRefData()

 {
     m_width = 0;
     m_height = 0;
 {
     m_width = 0;
     m_height = 0;


@@ -72,7 +70,7 @@ wxImageRefData::wxImageRefData(void)
     m_hasMask = FALSE;
 }
 
     m_hasMask = FALSE;
 }
 

-wxImageRefData::~wxImageRefData(void)
+wxImageRefData::~wxImageRefData()

 {
     if (m_data) free( m_data );
 }
 {
     if (m_data) free( m_data );
 }


@@ -84,7 +82,7 @@ wxList wxImage::sm_handlers;
 #define M_IMGDATA ((wxImageRefData *)m_refData)
 
 #if !USE_SHARED_LIBRARIES
 #define M_IMGDATA ((wxImageRefData *)m_refData)
 
 #if !USE_SHARED_LIBRARIES

-IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)
+    IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)

 #endif
 
 wxImage::wxImage()
 #endif
 
 wxImage::wxImage()


@@ -152,7 +150,7 @@ void wxImage::Destroy()
     UnRef();
 }
 
     UnRef();
 }
 

-wxImage wxImage::Scale( int width, int height )
+wxImage wxImage::Scale( int width, int height ) const

 {
     wxImage image;
 
 {
     wxImage image;
 


@@ -191,6 +189,43 @@ wxImage wxImage::Scale( int width, int height )
     return image;
 }
 
     return image;
 }
 

+wxImage wxImage::GetSubImage( const wxRect &rect ) const
+{
+    wxImage image;
+
+    wxCHECK_MSG( Ok(), image, _T("invalid image") );
+
+    wxCHECK_MSG( (rect.GetLeft()>=0) && (rect.GetTop()>=0) && (rect.GetRight()<=GetWidth()) && (rect.GetBottom()<=GetHeight())
+                , image, _T("invalid subimage size") );
+
+    int subwidth=rect.GetWidth();
+    const int subheight=rect.GetHeight();
+
+    image.Create( subwidth, subheight );
+
+    char unsigned *subdata = image.GetData(), *data=GetData();
+
+    wxCHECK_MSG( subdata, image, _T("unable to create image") );
+
+    if (M_IMGDATA->m_hasMask)
+        image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
+
+    const int subleft=3*rect.GetLeft();
+    const int width=3*GetWidth();
+    subwidth*=3;
+    
+    data+=rect.GetTop()*width+subleft;
+
+    for (long j = 0; j < subheight; ++j)
+    {
+        memcpy( subdata, data, subwidth);
+        subdata+=subwidth;
+       data+=width;
+    }
+
+    return image;
+}
+

 void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b )
 {
     wxCHECK_RET( Ok(), _T("invalid image") );
 void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b )
 {
     wxCHECK_RET( Ok(), _T("invalid image") );


@@ -265,7 +300,20 @@ void wxImage::SetData( char unsigned *data )
 {
     wxCHECK_RET( Ok(), _T("invalid image") );
 
 {
     wxCHECK_RET( Ok(), _T("invalid image") );
 

-    memcpy(M_IMGDATA->m_data, data, M_IMGDATA->m_width * M_IMGDATA->m_height * 3);
+    wxImageRefData *newRefData = new wxImageRefData();
+
+    newRefData->m_width = M_IMGDATA->m_width;
+    newRefData->m_height = M_IMGDATA->m_height;
+    newRefData->m_data = data;
+    newRefData->m_ok = TRUE;
+    newRefData->m_maskRed = M_IMGDATA->m_maskRed;
+    newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
+    newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
+    newRefData->m_hasMask = M_IMGDATA->m_hasMask;
+    
+    UnRef();
+    
+    m_refData = newRefData;

 }
 
 void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )
 }
 
 void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )


@@ -390,13 +438,32 @@ bool wxImage::SaveFile( const wxString& filename, const wxString& mimetype )
 }
 
 #if wxUSE_STREAMS
 }
 
 #if wxUSE_STREAMS

+

 bool wxImage::LoadFile( wxInputStream& stream, long type )
 {
     UnRef();
 
     m_refData = new wxImageRefData;
 
 bool wxImage::LoadFile( wxInputStream& stream, long type )
 {
     UnRef();
 
     m_refData = new wxImageRefData;
 

-    wxImageHandler *handler = FindHandler(type);
+    wxImageHandler *handler;
+
+    if (type==wxBITMAP_TYPE_ANY)
+    {
+       wxList &list=GetHandlers();
+
+       for ( wxList::Node *node = list.GetFirst(); node; node = node->GetNext() )
+       {  
+           handler=(wxImageHandler*)node->GetData();
+        if (handler->CanRead( stream ))
+            return handler->LoadFile( this, stream );
+
+       }
+
+       wxLogWarning( _T("No handler found for this image.") );
+       return FALSE;
+    }
+
+    handler = FindHandler(type);

 
     if (handler == NULL)
     {
 
     if (handler == NULL)
     {


@@ -540,7 +607,7 @@ wxImageHandler *wxImage::FindHandlerMime( const wxString& mimetype )
 
 void wxImage::InitStandardHandlers()
 {
 
 void wxImage::InitStandardHandlers()
 {

-    AddHandler( new wxBMPHandler );
+  AddHandler( new wxBMPHandler );

 }
 
 void wxImage::CleanUpHandlers()
 }
 
 void wxImage::CleanUpHandlers()


@@ -565,381 +632,61 @@ IMPLEMENT_DYNAMIC_CLASS(wxImageHandler,wxObject)
 #endif
 
 #if wxUSE_STREAMS
 #endif
 
 #if wxUSE_STREAMS

-bool wxImageHandler::LoadFile( wxImage *WXUNUSED(image), wxInputStream& WXUNUSED(stream) )
+bool wxImageHandler::LoadFile( wxImage *WXUNUSED(image), wxInputStream& WXUNUSED(stream), bool WXUNUSED(verbose) )

 {
     return FALSE;
 }
 
 {
     return FALSE;
 }
 

-bool wxImageHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream) )
+bool wxImageHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream), bool WXUNUSED(verbose) )

 {
     return FALSE;
 }
 {
     return FALSE;
 }

-#endif // wxUSE_STREAMS
-
-//-----------------------------------------------------------------------------
-// wxBMPHandler
-//-----------------------------------------------------------------------------
-
-#if !USE_SHARED_LIBRARIES
-IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler,wxImageHandler)
-#endif
-
-#if wxUSE_STREAMS
-
-#ifndef BI_RGB
-#define BI_RGB       0
-#define BI_RLE8      1
-#define BI_RLE4      2
-#endif
-
-#ifndef BI_BITFIELDS
-#define BI_BITFIELDS 3
-#endif

 
 

-#define poffset (line * width * 3 + column * 3)
-
-bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
+bool wxImageHandler::CanRead( wxInputStream& stream )

 {
 {

-    int             rshift = 0, gshift = 0, bshift = 0;
-    wxUint8         aByte;
-    wxUint16        aWord;
-    wxInt32         dbuf[4], aDword, 
-                    rmask = 0, gmask = 0, bmask = 0;
-    wxInt8          bbuf[4];
-    struct _cmap {
-        unsigned char r, g, b;
-    } *cmap = NULL;
-    
-    off_t start_offset = stream.TellI();
-
-    image->Destroy();
-
-    /*
-     * Read the BMP header
-     */
-
-    stream.Read( &bbuf, 2 );
-    stream.Read( dbuf, 4 * 4 );
-
-    wxInt32 size = wxINT32_SWAP_FROM_LE( dbuf[0] );
-    wxInt32 offset = wxINT32_SWAP_FROM_LE( dbuf[2] );
-
-    stream.Read(dbuf, 4 * 2);
-    int width = (int)wxINT32_SWAP_FROM_LE( dbuf[0] );
-    int height = (int)wxINT32_SWAP_FROM_LE( dbuf[1] );
-    if (width > 32767)
-    {
-        wxLogError( _T("Image width > 32767 pixels for file.") );
-        return FALSE;
-    }
-    if (height > 32767)
-    {
-        wxLogError( _T("Image height > 32767 pixels for file.") );
-        return FALSE;
-    }
-    
-    stream.Read( &aWord, 2 );
-/*
-    TODO
-    int planes = (int)wxUINT16_SWAP_FROM_LE( aWord );
-*/
-    stream.Read( &aWord, 2 );
-    int bpp = (int)wxUINT16_SWAP_FROM_LE( aWord );
-    if (bpp != 1 && bpp != 4 && bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32)
-    {
-        wxLogError( _T("unknown bitdepth in file.") );
-        return FALSE;
-    }
-    
-    stream.Read( dbuf, 4 * 4 );
-    int comp = (int)wxINT32_SWAP_FROM_LE( dbuf[0] );
-    if (comp != BI_RGB && comp != BI_RLE4 && comp != BI_RLE8 && comp != BI_BITFIELDS)
-    {
-        wxLogError( _T("unknown encoding in Windows BMP file.") );
-        return FALSE;
-    }
-    
-    stream.Read( dbuf, 4 * 2 );
-    int ncolors = (int)wxINT32_SWAP_FROM_LE( dbuf[0] );
-    if (ncolors == 0)
-        ncolors = 1 << bpp;
-    /* some more sanity checks */
-    if (((comp == BI_RLE4) && (bpp != 4)) || 
-        ((comp == BI_RLE8) && (bpp != 8)) || 
-       ((comp == BI_BITFIELDS) && (bpp != 16 && bpp != 32)))
-    {
-        wxLogError( _T("encoding of BMP doesn't match bitdepth.") );
-        return FALSE;
-    }
-    if (bpp < 16)
-    {
-        cmap = (struct _cmap *)malloc(sizeof(struct _cmap) * ncolors);
-        if (!cmap)
-        {
-            wxLogError( _T("Cannot allocate RAM for color map in BMP file.") );
-            return FALSE;
-        }
-    }
-    else
-        cmap = NULL;
+    return FALSE;
+}

 
 

-    image->Create( width, height );
-    unsigned char *ptr = image->GetData();
-    if (!ptr)
+bool wxImageHandler::CanRead( const wxString& name )
+{
+#if wxUSE_STREAMS
+    if (wxFileExists(name))

     {
     {

-        wxLogError( _T("Cannot allocate RAM for RGB data in file.") );
-        if (cmap)
-            free(cmap);
-        return FALSE;
+        wxFileInputStream stream(name);
+        return CanRead(stream);

     }
 
     }
 

-    /*
-     * Reading the palette, if it exists.
-     */
-    if (bpp < 16 && ncolors != 0)
-    {
-        for (int j = 0; j < ncolors; j++)
-        {
-            stream.Read( bbuf, 4 );
-            cmap[j].b = bbuf[0];
-            cmap[j].g = bbuf[1];
-            cmap[j].r = bbuf[2];
-        }
-    }
-    else if (bpp == 16 || bpp == 32)
-    {
-        if (comp == BI_BITFIELDS)
-        {
-            int bit = 0;
-            stream.Read( dbuf, 4 * 3 );
-            bmask = wxINT32_SWAP_FROM_LE( dbuf[0] );
-            gmask = wxINT32_SWAP_FROM_LE( dbuf[1] );
-            rmask = wxINT32_SWAP_FROM_LE( dbuf[2] );
-            /* find shift amount.. ugly, but i can't think of a better way */
-            for (bit = 0; bit < bpp; bit++)
-            {
-                if (bmask & (1 << bit))
-                    bshift = bit;
-                if (gmask & (1 << bit))
-                    gshift = bit;
-                if (rmask & (1 << bit))
-                    rshift = bit;
-            }
-        }
-        else if (bpp == 16)
-        {
-            rmask = 0x7C00;
-            gmask = 0x03E0;
-            bmask = 0x001F;
-            rshift = 10;
-            gshift = 5;
-            bshift = 0;
-        }
-        else if (bpp == 32)
-        {
-            rmask = 0x00FF0000;
-            gmask = 0x0000FF00;
-            bmask = 0x000000FF;
-            rshift = 16;
-            gshift = 8;
-            bshift = 0;
-        }
-    }
-
-    /*
-     * Reading the image data
-     */
-    stream.SeekI( start_offset + offset );
-    unsigned char *data = ptr;
+    else {
+        wxLogError( _T("Can't check image format of file '%s': file does not exist."), name.c_str() );

 
 

-    /* set the whole image to the background color */
-    if (bpp < 16 && (comp == BI_RLE4 || comp == BI_RLE8))
-    {
-        for (int i = 0; i < width * height; i++)
-        {
-            *ptr++ = cmap[0].r;
-            *ptr++ = cmap[0].g;
-            *ptr++ = cmap[0].b;
-        }
-        ptr = data;
+        return FALSE;

     }
     }

-    
-    int line = 0;
-    int column = 0;
-    int linesize = ((width * bpp + 31) / 32) * 4;
+#else // !wxUSE_STREAMS
+    return FALSE;
+#endif // wxUSE_STREAMS
+}

 
 

-    /* BMPs are stored upside down */
-    for (line = (height - 1); line >= 0; line--) 
-    {
-        int linepos = 0;
-        for (column = 0; column < width;)
-        {
-            if (bpp < 16)
-            {
-                int index = 0;
-                linepos++;
-                aByte = stream.GetC();
-                if (bpp == 1)
-                {
-                    int bit = 0;
-                    for (bit = 0; bit < 8; bit++)
-                    {
-                        index = ((aByte & (0x80 >> bit)) ? 1 : 0);
-                        ptr[poffset] = cmap[index].r;
-                        ptr[poffset + 1] = cmap[index].g;
-                        ptr[poffset + 2] = cmap[index].b;
-                        column++;
-                    }
-                }
-                else if (bpp == 4)
-                {
-                    if (comp == BI_RLE4)
-                    {
-                        wxLogError( _T("Can't deal with 4bit encoded yet.") );
-                        image->Destroy();
-                        free(cmap);
-                        return FALSE;
-                    }
-                    else
-                    {
-                        int nibble = 0;
-                        for (nibble = 0; nibble < 2; nibble++)
-                        {
-                            index = ((aByte & (0xF0 >> nibble * 4)) >> (!nibble * 4));
-                            if (index >= 16)
-                                index = 15;
-                            ptr[poffset] = cmap[index].r;
-                            ptr[poffset + 1] = cmap[index].g;
-                            ptr[poffset + 2] = cmap[index].b;
-                            column++;
-                        }
-                    }
-                }
-                else if (bpp == 8)
-                {
-                    if (comp == BI_RLE8)
-                    {
-                        unsigned char first;
-                        first = aByte;
-                        aByte = stream.GetC();
-                        if (first == 0)
-                        {
-                            if (aByte == 0)
-                            {
-                                /* column = width; */
-                            }
-                            else if (aByte == 1)
-                            {
-                                column = width;
-                                line = -1;
-                            }
-                            else if (aByte == 2)
-                            {
-                                aByte = stream.GetC();
-                                column += aByte;
-                                linepos = column * bpp / 8;
-                                aByte = stream.GetC();
-                                line += aByte;
-                            }
-                            else
-                            {
-                                int absolute = aByte;
-                                for (int k = 0; k < absolute; k++)
-                                {
-                                    linepos++;
-                                    aByte = stream.GetC();
-                                    ptr[poffset    ] = cmap[aByte].r;
-                                    ptr[poffset + 1] = cmap[aByte].g;
-                                    ptr[poffset + 2] = cmap[aByte].b;
-                                    column++;
-                                }
-                                if (absolute & 0x01)
-                                    aByte = stream.GetC();
-                            }
-                        }
-                        else
-                        {
-                            for (int l = 0; l < first; l++)
-                            {
-                                ptr[poffset    ] = cmap[aByte].r;
-                                ptr[poffset + 1] = cmap[aByte].g;
-                                ptr[poffset + 2] = cmap[aByte].b;
-                                column++;
-                                linepos++;
-                            }
-                        }
-                    }
-                    else
-                    {
-                        ptr[poffset    ] = cmap[aByte].r;
-                        ptr[poffset + 1] = cmap[aByte].g;
-                        ptr[poffset + 2] = cmap[aByte].b;
-                        column++;
-                        linepos += size;
-                    }
-                }
-               }
-               else if (bpp == 24)
-               {
-                   stream.Read( &bbuf, 3 );
-                   linepos += 3;
-                   ptr[poffset    ] = (unsigned char)bbuf[2];
-                   ptr[poffset + 1] = (unsigned char)bbuf[1];
-                   ptr[poffset + 2] = (unsigned char)bbuf[0];
-                   column++;
-               }
-               else if (bpp == 16)
-               {
-                   unsigned char temp;
-                   stream.Read( &aWord, 2 );
-                  aWord = wxUINT16_SWAP_FROM_LE( aWord );
-                   linepos += 2;
-                   temp = (aWord & rmask) >> rshift;
-                   ptr[poffset] = temp;
-                   temp = (aWord & gmask) >> gshift;
-                   ptr[poffset + 1] = temp;
-                   temp = (aWord & bmask) >> gshift;
-                   ptr[poffset + 2] = temp;
-                   column++;
-               }
-               else
-               {
-                   unsigned char temp;
-                   stream.Read( &aDword, 4 );
-                  aDword = wxINT32_SWAP_FROM_LE( aDword );
-                   linepos += 4;
-                   temp = (aDword & rmask) >> rshift;
-                   ptr[poffset] = temp;
-                   temp = (aDword & gmask) >> gshift;
-                   ptr[poffset + 1] = temp;
-                   temp = (aDword & bmask) >> bshift;
-                   ptr[poffset + 2] = temp;
-                   column++;
-               }
-          }
-          while ((linepos < linesize) && (comp != 1) && (comp != 2))
-          {
-              stream.Read( &aByte, 1 );
-              linepos += 1;
-              if (stream.LastError() != wxStream_NOERROR)
-                  break;
-          }
-     }
-     if (cmap) 
-       free(cmap);

 
 

-     image->SetMask( FALSE );

 
 

-     return TRUE;
-}

 #endif // wxUSE_STREAMS
 
 #endif // wxUSE_STREAMS
 

+//-----------------------------------------------------------------------------
+// MSW conversion routines
+//-----------------------------------------------------------------------------
+

 #ifdef __WXMSW__
 
 wxBitmap wxImage::ConvertToBitmap() const
 {
 #ifdef __WXMSW__
 
 wxBitmap wxImage::ConvertToBitmap() const
 {

+    if ( !Ok() )
+        return wxNullBitmap;
+

     // sizeLimit is the MS upper limit for the DIB size
     // sizeLimit is the MS upper limit for the DIB size

+#ifdef  WIN32

     int sizeLimit = 1024*768*3;
     int sizeLimit = 1024*768*3;

+#else
+    int sizeLimit = 0x7fff ;
+#endif

 
     // width and height of the device-dependent bitmap
     int width = GetWidth();
 
     // width and height of the device-dependent bitmap
     int width = GetWidth();


@@ -948,11 +695,11 @@ wxBitmap wxImage::ConvertToBitmap() const
     // calc the number of bytes per scanline and padding
     int bytePerLine = width*3;
     int sizeDWORD = sizeof( DWORD );
     // calc the number of bytes per scanline and padding
     int bytePerLine = width*3;
     int sizeDWORD = sizeof( DWORD );

-    div_t lineBoundary = div( bytePerLine, sizeDWORD );
+    int lineBoundary = bytePerLine % sizeDWORD;

     int padding = 0;
     int padding = 0;

-    if( lineBoundary.rem > 0 )
+    if( lineBoundary > 0 )

     {
     {

-        padding = sizeDWORD - lineBoundary.rem;
+        padding = sizeDWORD - lineBoundary;

         bytePerLine += padding;
     }
     // calc the number of DIBs and heights of DIBs
         bytePerLine += padding;
     }
     // calc the number of DIBs and heights of DIBs


@@ -963,9 +710,8 @@ wxBitmap wxImage::ConvertToBitmap() const
         height = bmpHeight;
     else
     {
         height = bmpHeight;
     else
     {

-        div_t result = div( bmpHeight, height );
-        numDIB = result.quot;
-        hRemain = result.rem;
+        numDIB =  bmpHeight / height;
+        hRemain = bmpHeight % height;

         if( hRemain >0 )  numDIB++;
     }
 
         if( hRemain >0 )  numDIB++;
     }
 


@@ -1161,11 +907,11 @@ wxImage::wxImage( const wxBitmap &bitmap )
     // calc the number of bytes per scanline and padding in the DIB
     int bytePerLine = width*3;
     int sizeDWORD = sizeof( DWORD );
     // calc the number of bytes per scanline and padding in the DIB
     int bytePerLine = width*3;
     int sizeDWORD = sizeof( DWORD );

-    div_t lineBoundary = div( bytePerLine, sizeDWORD );
+    int lineBoundary =  bytePerLine % sizeDWORD;

     int padding = 0;
     int padding = 0;

-    if( lineBoundary.rem > 0 )
+    if( lineBoundary > 0 )

     {
     {

-        padding = sizeDWORD - lineBoundary.rem;
+        padding = sizeDWORD - lineBoundary;

         bytePerLine += padding;
     }
 
         bytePerLine += padding;
     }
 


@@ -1269,6 +1015,10 @@ wxImage::wxImage( const wxBitmap &bitmap )
 
 #endif
 
 
 #endif
 

+//-----------------------------------------------------------------------------
+// GTK conversion routines
+//-----------------------------------------------------------------------------
+

 #ifdef __WXGTK__
 
 #include "gtk/gtk.h"
 #ifdef __WXGTK__
 
 #include "gtk/gtk.h"


@@ -1296,7 +1046,7 @@ wxBitmap wxImage::ConvertToBitmap() const
      // Retrieve depth
 
     GdkVisual *visual = gdk_window_get_visual( bitmap.GetPixmap() );
      // Retrieve depth
 
     GdkVisual *visual = gdk_window_get_visual( bitmap.GetPixmap() );

-    if (visual == NULL) visual = gdk_window_get_visual( (GdkWindow*) &gdk_root_parent );
+    if (visual == NULL) visual = gdk_visual_get_system();

     int bpp = visual->depth;
 
     bitmap.SetDepth( bpp );
     int bpp = visual->depth;
 
     bitmap.SetDepth( bpp );


@@ -1531,7 +1281,8 @@ wxImage::wxImage( const wxBitmap &bitmap )
     {
         for (int i = 0; i < bitmap.GetWidth(); i++)
         {
     {
         for (int i = 0; i < bitmap.GetWidth(); i++)
         {

-            int pixel = gdk_image_get_pixel( gdk_image, i, j );
+            wxInt32 pixel = gdk_image_get_pixel( gdk_image, i, j );
+           pixel = wxINT32_SWAP_ON_BE( pixel );

             if (bpp <= 8)
             {
                 data[pos] = cmap->colors[pixel].red >> 8;
             if (bpp <= 8)
             {
                 data[pos] = cmap->colors[pixel].red >> 8;


@@ -1575,6 +1326,10 @@ wxImage::wxImage( const wxBitmap &bitmap )
 
 #endif
 
 
 #endif
 

+//-----------------------------------------------------------------------------
+// Motif conversion routines
+//-----------------------------------------------------------------------------
+

 #ifdef __WXMOTIF__
 
 #include <Xm/Xm.h>
 #ifdef __WXMOTIF__
 
 #include <Xm/Xm.h>


@@ -1833,7 +1588,7 @@ wxImage::wxImage( const wxBitmap &bitmap )
 
     vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
 
 
     vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
 

-    wxCHECK_MSG( vi, wxNullBitmap, _T("no visual") );
+    wxCHECK_RET( vi, _T("no visual") );

 
     if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
 
 
     if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;