Made wxGTK compile and link again. Broke wxMSW a little.

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

diff --git a/src/common/image.cpp b/src/common/image.cpp
index bb000882425f86786b9ff445351fe8a3d32a1157..05344a678fc2f928c108393d1b2af8623b8988dd 100644 (file)
--- a/src/common/image.cpp
+++ b/src/common/image.cpp
@@ -150,19 +150,19 @@ void wxImage::Destroy()
     UnRef();
 }
 
     UnRef();
 }
 

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

 {
     wxImage image;
 
 {
     wxImage image;
 

-    wxCHECK_MSG( Ok(), image, _T("invalid image") );
+    wxCHECK_MSG( Ok(), image, wxT("invalid image") );

 
 

-    wxCHECK_MSG( (width > 0) && (height > 0), image, _T("invalid image size") );
+    wxCHECK_MSG( (width > 0) && (height > 0), image, wxT("invalid image size") );

 
     image.Create( width, height );
 
     char unsigned *data = image.GetData();
 
 
     image.Create( width, height );
 
     char unsigned *data = image.GetData();
 

-    wxCHECK_MSG( data, image, _T("unable to create image") );
+    wxCHECK_MSG( data, image, wxT("unable to create image") );

 
     if (M_IMGDATA->m_hasMask)
         image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
 
     if (M_IMGDATA->m_hasMask)
         image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );


@@ -189,14 +189,51 @@ wxImage wxImage::Scale( int width, int height )
     return image;
 }
 
     return image;
 }
 

+wxImage wxImage::GetSubImage( const wxRect &rect ) const
+{
+    wxImage image;
+
+    wxCHECK_MSG( Ok(), image, wxT("invalid image") );
+
+    wxCHECK_MSG( (rect.GetLeft()>=0) && (rect.GetTop()>=0) && (rect.GetRight()<=GetWidth()) && (rect.GetBottom()<=GetHeight())
+                 , image, wxT("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, wxT("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 )
 {
 void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b )
 {

-    wxCHECK_RET( Ok(), _T("invalid image") );
+    wxCHECK_RET( Ok(), wxT("invalid image") );

 
     int w = M_IMGDATA->m_width;
     int h = M_IMGDATA->m_height;
 
 
     int w = M_IMGDATA->m_width;
     int h = M_IMGDATA->m_height;
 

-    wxCHECK_RET( (x>=0) && (y>=0) && (x<w) && (y<h), _T("invalid image index") );
+    wxCHECK_RET( (x>=0) && (y>=0) && (x<w) && (y<h), wxT("invalid image index") );

 
     long pos = (y * w + x) * 3;
 
 
     long pos = (y * w + x) * 3;
 


@@ -207,12 +244,12 @@ void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned c
 
 unsigned char wxImage::GetRed( int x, int y )
 {
 
 unsigned char wxImage::GetRed( int x, int y )
 {

-    wxCHECK_MSG( Ok(), 0, _T("invalid image") );
+    wxCHECK_MSG( Ok(), 0, wxT("invalid image") );

 
     int w = M_IMGDATA->m_width;
     int h = M_IMGDATA->m_height;
 
 
     int w = M_IMGDATA->m_width;
     int h = M_IMGDATA->m_height;
 

-    wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, _T("invalid image index") );
+    wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, wxT("invalid image index") );

 
     long pos = (y * w + x) * 3;
 
 
     long pos = (y * w + x) * 3;
 


@@ -221,12 +258,12 @@ unsigned char wxImage::GetRed( int x, int y )
 
 unsigned char wxImage::GetGreen( int x, int y )
 {
 
 unsigned char wxImage::GetGreen( int x, int y )
 {

-    wxCHECK_MSG( Ok(), 0, _T("invalid image") );
+    wxCHECK_MSG( Ok(), 0, wxT("invalid image") );

 
     int w = M_IMGDATA->m_width;
     int h = M_IMGDATA->m_height;
 
 
     int w = M_IMGDATA->m_width;
     int h = M_IMGDATA->m_height;
 

-    wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, _T("invalid image index") );
+    wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, wxT("invalid image index") );

 
     long pos = (y * w + x) * 3;
 
 
     long pos = (y * w + x) * 3;
 


@@ -235,12 +272,12 @@ unsigned char wxImage::GetGreen( int x, int y )
 
 unsigned char wxImage::GetBlue( int x, int y )
 {
 
 unsigned char wxImage::GetBlue( int x, int y )
 {

-    wxCHECK_MSG( Ok(), 0, _T("invalid image") );
+    wxCHECK_MSG( Ok(), 0, wxT("invalid image") );

 
     int w = M_IMGDATA->m_width;
     int h = M_IMGDATA->m_height;
 
 
     int w = M_IMGDATA->m_width;
     int h = M_IMGDATA->m_height;
 

-    wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, _T("invalid image index") );
+    wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, wxT("invalid image index") );

 
     long pos = (y * w + x) * 3;
 
 
     long pos = (y * w + x) * 3;
 


@@ -254,21 +291,34 @@ bool wxImage::Ok() const
 
 char unsigned *wxImage::GetData() const
 {
 
 char unsigned *wxImage::GetData() const
 {

-    wxCHECK_MSG( Ok(), (char unsigned *)NULL, _T("invalid image") );
+    wxCHECK_MSG( Ok(), (char unsigned *)NULL, wxT("invalid image") );

 
     return M_IMGDATA->m_data;
 }
 
 void wxImage::SetData( char unsigned *data )
 {
 
     return M_IMGDATA->m_data;
 }
 
 void wxImage::SetData( char unsigned *data )
 {

-    wxCHECK_RET( Ok(), _T("invalid image") );
+    wxCHECK_RET( Ok(), wxT("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 )
 {

-    wxCHECK_RET( Ok(), _T("invalid image") );
+    wxCHECK_RET( Ok(), wxT("invalid image") );

 
     M_IMGDATA->m_maskRed = r;
     M_IMGDATA->m_maskGreen = g;
 
     M_IMGDATA->m_maskRed = r;
     M_IMGDATA->m_maskGreen = g;


@@ -278,49 +328,49 @@ void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )
 
 unsigned char wxImage::GetMaskRed() const
 {
 
 unsigned char wxImage::GetMaskRed() const
 {

-    wxCHECK_MSG( Ok(), 0, _T("invalid image") );
+    wxCHECK_MSG( Ok(), 0, wxT("invalid image") );

 
     return M_IMGDATA->m_maskRed;
 }
 
 unsigned char wxImage::GetMaskGreen() const
 {
 
     return M_IMGDATA->m_maskRed;
 }
 
 unsigned char wxImage::GetMaskGreen() const
 {

-    wxCHECK_MSG( Ok(), 0, _T("invalid image") );
+    wxCHECK_MSG( Ok(), 0, wxT("invalid image") );

 
     return M_IMGDATA->m_maskGreen;
 }
 
 unsigned char wxImage::GetMaskBlue() const
 {
 
     return M_IMGDATA->m_maskGreen;
 }
 
 unsigned char wxImage::GetMaskBlue() const
 {

-    wxCHECK_MSG( Ok(), 0, _T("invalid image") );
+    wxCHECK_MSG( Ok(), 0, wxT("invalid image") );

 
     return M_IMGDATA->m_maskBlue;
 }
 
 void wxImage::SetMask( bool mask )
 {
 
     return M_IMGDATA->m_maskBlue;
 }
 
 void wxImage::SetMask( bool mask )
 {

-    wxCHECK_RET( Ok(), _T("invalid image") );
+    wxCHECK_RET( Ok(), wxT("invalid image") );

 
     M_IMGDATA->m_hasMask = mask;
 }
 
 bool wxImage::HasMask() const
 {
 
     M_IMGDATA->m_hasMask = mask;
 }
 
 bool wxImage::HasMask() const
 {

-    wxCHECK_MSG( Ok(), FALSE, _T("invalid image") );
+    wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );

 
     return M_IMGDATA->m_hasMask;
 }
 
 int wxImage::GetWidth() const
 {
 
     return M_IMGDATA->m_hasMask;
 }
 
 int wxImage::GetWidth() const
 {

-    wxCHECK_MSG( Ok(), 0, _T("invalid image") );
+    wxCHECK_MSG( Ok(), 0, wxT("invalid image") );

 
     return M_IMGDATA->m_width;
 }
 
 int wxImage::GetHeight() const
 {
 
     return M_IMGDATA->m_width;
 }
 
 int wxImage::GetHeight() const
 {

-    wxCHECK_MSG( Ok(), 0, _T("invalid image") );
+    wxCHECK_MSG( Ok(), 0, wxT("invalid image") );

 
     return M_IMGDATA->m_height;
 }
 
     return M_IMGDATA->m_height;
 }


@@ -335,7 +385,7 @@ bool wxImage::LoadFile( const wxString& filename, long type )
     }
 
     else {
     }
 
     else {

-        wxLogError( _T("Can't load image from file '%s': file does not exist."), filename.c_str() );
+        wxLogError( wxT("Can't load image from file '%s': file does not exist."), filename.c_str() );

 
         return FALSE;
     }
 
         return FALSE;
     }


@@ -354,7 +404,7 @@ bool wxImage::LoadFile( const wxString& filename, const wxString& mimetype )
     }
 
     else {
     }
 
     else {

-        wxLogError( _T("Can't load image from file '%s': file does not exist."), filename.c_str() );
+        wxLogError( wxT("Can't load image from file '%s': file does not exist."), filename.c_str() );

 
         return FALSE;
     }
 
         return FALSE;
     }


@@ -387,18 +437,61 @@ bool wxImage::SaveFile( const wxString& filename, const wxString& mimetype )
         return FALSE;
 }
 
         return FALSE;
 }
 

+bool wxImage::CanRead( const wxString &name )
+{
+#if wxUSE_STREAMS
+  wxFileInputStream stream(name);
+  return CanRead(stream);
+#else
+  return FALSE;
+#endif
+}
+

 #if wxUSE_STREAMS
 #if wxUSE_STREAMS

+
+bool wxImage::CanRead( wxInputStream &stream )
+{
+  wxList &list=GetHandlers();
+  
+  for ( wxList::Node *node = list.GetFirst(); node; node = node->GetNext() )
+    {  
+      wxImageHandler *handler=(wxImageHandler*)node->GetData();
+      if (handler->CanRead( stream ))
+       return TRUE;
+    }
+
+  return FALSE;
+}
+

 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( wxT("No handler found for this image.") );
+        return FALSE;
+    }
+
+    handler = FindHandler(type);

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

-        wxLogWarning( _T("No image handler for type %d defined."), type );
+        wxLogWarning( wxT("No image handler for type %d defined."), type );

 
         return FALSE;
     }
 
         return FALSE;
     }


@@ -416,7 +509,7 @@ bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype )
 
     if (handler == NULL)
     {
 
     if (handler == NULL)
     {

-        wxLogWarning( _T("No image handler for type %s defined."), mimetype.GetData() );
+        wxLogWarning( wxT("No image handler for type %s defined."), mimetype.GetData() );

 
         return FALSE;
     }
 
         return FALSE;
     }


@@ -426,13 +519,13 @@ bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype )
 
 bool wxImage::SaveFile( wxOutputStream& stream, int type )
 {
 
 bool wxImage::SaveFile( wxOutputStream& stream, int type )
 {

-    wxCHECK_MSG( Ok(), FALSE, _T("invalid image") );
+    wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );

 
     wxImageHandler *handler = FindHandler(type);
 
     if (handler == NULL)
     {
 
     wxImageHandler *handler = FindHandler(type);
 
     if (handler == NULL)
     {

-        wxLogWarning( _T("No image handler for type %d defined."), type );
+        wxLogWarning( wxT("No image handler for type %d defined."), type );

 
         return FALSE;
     }
 
         return FALSE;
     }


@@ -442,13 +535,13 @@ bool wxImage::SaveFile( wxOutputStream& stream, int type )
 
 bool wxImage::SaveFile( wxOutputStream& stream, const wxString& mimetype )
 {
 
 bool wxImage::SaveFile( wxOutputStream& stream, const wxString& mimetype )
 {

-    wxCHECK_MSG( Ok(), FALSE, _T("invalid image") );
+    wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );

 
     wxImageHandler *handler = FindHandlerMime(mimetype);
 
     if (handler == NULL)
     {
 
     wxImageHandler *handler = FindHandlerMime(mimetype);
 
     if (handler == NULL)
     {

-        wxLogWarning( _T("No image handler for type %s defined."), mimetype.GetData() );
+        wxLogWarning( wxT("No image handler for type %s defined."), mimetype.GetData() );

 
         return FALSE;
     }
 
         return FALSE;
     }


@@ -538,7 +631,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()


@@ -559,19 +652,41 @@ void wxImage::CleanUpHandlers()
 //-----------------------------------------------------------------------------
 
 #if !USE_SHARED_LIBRARIES
 //-----------------------------------------------------------------------------
 
 #if !USE_SHARED_LIBRARIES

-IMPLEMENT_DYNAMIC_CLASS(wxImageHandler,wxObject)
+IMPLEMENT_ABSTRACT_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;
+}
+
+bool wxImageHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream), bool WXUNUSED(verbose) )

 {
     return FALSE;
 }
 
 {
     return FALSE;
 }
 

-bool wxImageHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream) )
+bool wxImageHandler::CanRead( const wxString& name )

 {
 {

+#if wxUSE_STREAMS
+    if (wxFileExists(name))
+    {
+        wxFileInputStream stream(name);
+        return CanRead(stream);
+    }
+
+    else {
+        wxLogError( wxT("Can't check image format of file '%s': file does not exist."), name.c_str() );
+
+        return FALSE;
+    }
+#else // !wxUSE_STREAMS

     return FALSE;
     return FALSE;

+#endif // wxUSE_STREAMS

 }
 }

+
+
+

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


@@ -582,8 +697,15 @@ bool wxImageHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSE
 
 wxBitmap wxImage::ConvertToBitmap() const
 {
 
 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();


@@ -592,11 +714,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


@@ -607,15 +729,14 @@ 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++;
     }
 
     // set bitmap parameters
     wxBitmap bitmap;
         if( hRemain >0 )  numDIB++;
     }
 
     // set bitmap parameters
     wxBitmap bitmap;

-    wxCHECK_MSG( Ok(), bitmap, _T("invalid image") );
+    wxCHECK_MSG( Ok(), bitmap, wxT("invalid image") );

     bitmap.SetWidth( width );
     bitmap.SetHeight( bmpHeight );
     bitmap.SetDepth( wxDisplayDepth() );
     bitmap.SetWidth( width );
     bitmap.SetHeight( bmpHeight );
     bitmap.SetDepth( wxDisplayDepth() );


@@ -623,7 +744,7 @@ wxBitmap wxImage::ConvertToBitmap() const
     // create a DIB header
     int headersize = sizeof(BITMAPINFOHEADER);
     LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
     // create a DIB header
     int headersize = sizeof(BITMAPINFOHEADER);
     LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );

-    wxCHECK_MSG( lpDIBh, bitmap, _T("could not allocate memory for DIB header") );
+    wxCHECK_MSG( lpDIBh, bitmap, wxT("could not allocate memory for DIB header") );

     // Fill in the DIB header
     lpDIBh->bmiHeader.biSize = headersize;
     lpDIBh->bmiHeader.biWidth = (DWORD)width;
     // Fill in the DIB header
     lpDIBh->bmiHeader.biSize = headersize;
     lpDIBh->bmiHeader.biWidth = (DWORD)width;


@@ -644,7 +765,7 @@ wxBitmap wxImage::ConvertToBitmap() const
     lpBits = (unsigned char *)malloc( lpDIBh->bmiHeader.biSizeImage );
     if( !lpBits )
     {
     lpBits = (unsigned char *)malloc( lpDIBh->bmiHeader.biSizeImage );
     if( !lpBits )
     {

-        wxFAIL_MSG( _T("could not allocate memory for DIB") );
+        wxFAIL_MSG( wxT("could not allocate memory for DIB") );

         free( lpDIBh );
         return bitmap;
     }
         free( lpDIBh );
         return bitmap;
     }


@@ -699,7 +820,7 @@ wxBitmap wxImage::ConvertToBitmap() const
         //    HDC memdc = ::CreateCompatibleDC( hdc );
         //    ::SelectObject( memdc, hbitmap);
         //    ::SetDIBitsToDevice( memdc, 0, 0, width, height,
         //    HDC memdc = ::CreateCompatibleDC( hdc );
         //    ::SelectObject( memdc, hbitmap);
         //    ::SetDIBitsToDevice( memdc, 0, 0, width, height,

-        //         0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);
+        //            0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);

         //    ::SelectObject( memdc, 0 );
         //    ::DeleteDC( memdc );
     }
         //    ::SelectObject( memdc, 0 );
         //    ::DeleteDC( memdc );
     }


@@ -787,7 +908,7 @@ wxImage::wxImage( const wxBitmap &bitmap )
     // check the bitmap
     if( !bitmap.Ok() )
     {
     // check the bitmap
     if( !bitmap.Ok() )
     {

-        wxFAIL_MSG( _T("invalid bitmap") );
+        wxFAIL_MSG( wxT("invalid bitmap") );

         return;
     }
 
         return;
     }
 


@@ -798,18 +919,18 @@ wxImage::wxImage( const wxBitmap &bitmap )
     unsigned char *data = GetData();
     if( !data )
     {
     unsigned char *data = GetData();
     if( !data )
     {

-        wxFAIL_MSG( _T("could not allocate data for image") );
+        wxFAIL_MSG( wxT("could not allocate data for image") );

         return;
     }
 
     // calc the number of bytes per scanline and padding in the DIB
     int bytePerLine = width*3;
     int sizeDWORD = sizeof( DWORD );
         return;
     }
 
     // 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;
     }
 


@@ -818,7 +939,7 @@ wxImage::wxImage( const wxBitmap &bitmap )
     LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
     if( !lpDIBh )
     {
     LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
     if( !lpDIBh )
     {

-        wxFAIL_MSG( _T("could not allocate data for DIB header") );
+        wxFAIL_MSG( wxT("could not allocate data for DIB header") );

         free( data );
         return;
     }
         free( data );
         return;
     }


@@ -840,7 +961,7 @@ wxImage::wxImage( const wxBitmap &bitmap )
     lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
     if( !lpBits )
     {
     lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
     if( !lpBits )
     {

-        wxFAIL_MSG( _T("could not allocate data for DIB") );
+        wxFAIL_MSG( wxT("could not allocate data for DIB") );

         free( data );
         free( lpDIBh );
         return;
         free( data );
         free( lpDIBh );
         return;


@@ -931,7 +1052,7 @@ wxBitmap wxImage::ConvertToBitmap() const
 {
     wxBitmap bitmap;
 
 {
     wxBitmap bitmap;
 

-    wxCHECK_MSG( Ok(), bitmap, _T("invalid image") );
+    wxCHECK_MSG( Ok(), bitmap, wxT("invalid image") );

 
     int width = GetWidth();
     int height = GetHeight();
 
     int width = GetWidth();
     int height = GetHeight();


@@ -958,25 +1079,25 @@ wxBitmap wxImage::ConvertToBitmap() const
     {
         static bool s_hasInitialized = FALSE;
 
     {
         static bool s_hasInitialized = FALSE;
 

-       if (!s_hasInitialized)
-       {
-           gdk_rgb_init();
-           s_hasInitialized = TRUE;
-       }
+        if (!s_hasInitialized)
+        {
+            gdk_rgb_init();
+            s_hasInitialized = TRUE;
+        }

 
         GdkGC *gc = gdk_gc_new( bitmap.GetPixmap() );
 
 
         GdkGC *gc = gdk_gc_new( bitmap.GetPixmap() );
 

-       gdk_draw_rgb_image( bitmap.GetPixmap(),
-                           gc,
-                           0, 0,
-                           width, height,
-                           GDK_RGB_DITHER_NONE,
-                           GetData(),
-                           width*3 );
+        gdk_draw_rgb_image( bitmap.GetPixmap(),
+                            gc,
+                            0, 0,
+                            width, height,
+                            GDK_RGB_DITHER_NONE,
+                            GetData(),
+                            width*3 );

 
         gdk_gc_unref( gc );
 
 
         gdk_gc_unref( gc );
 

-       return bitmap;
+        return bitmap;

     }
 
 #endif
     }
 
 #endif


@@ -1139,13 +1260,26 @@ wxBitmap wxImage::ConvertToBitmap() const
 
 wxImage::wxImage( const wxBitmap &bitmap )
 {
 
 wxImage::wxImage( const wxBitmap &bitmap )
 {

-    wxCHECK_RET( bitmap.Ok(), _T("invalid bitmap") );
+    wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );

 
 

-    GdkImage *gdk_image = gdk_image_get( bitmap.GetPixmap(),
-        0, 0,
-        bitmap.GetWidth(), bitmap.GetHeight() );
+    GdkImage *gdk_image = (GdkImage*) NULL;
+    if (bitmap.GetPixmap())
+    {
+        gdk_image = gdk_image_get( bitmap.GetPixmap(),
+            0, 0,
+            bitmap.GetWidth(), bitmap.GetHeight() );
+    } else
+    if (bitmap.GetBitmap())
+    {
+        gdk_image = gdk_image_get( bitmap.GetBitmap(),
+            0, 0,
+            bitmap.GetWidth(), bitmap.GetHeight() );
+    } else
+    {
+        wxFAIL_MSG( wxT("Ill-formed bitmap") );
+    }

 
 

-    wxCHECK_RET( gdk_image, _T("couldn't create image") );
+    wxCHECK_RET( gdk_image, wxT("couldn't create image") );

 
     Create( bitmap.GetWidth(), bitmap.GetHeight() );
     char unsigned *data = GetData();
 
     Create( bitmap.GetWidth(), bitmap.GetHeight() );
     char unsigned *data = GetData();


@@ -1153,7 +1287,7 @@ wxImage::wxImage( const wxBitmap &bitmap )
     if (!data)
     {
         gdk_image_destroy( gdk_image );
     if (!data)
     {
         gdk_image_destroy( gdk_image );

-        wxFAIL_MSG( _T("couldn't create image") );
+        wxFAIL_MSG( wxT("couldn't create image") );

         return;
     }
 
         return;
     }
 


@@ -1167,7 +1301,12 @@ wxImage::wxImage( const wxBitmap &bitmap )
         SetMaskColour( 16, 16, 16 );  // anything unlikely and dividable
     }
 
         SetMaskColour( 16, 16, 16 );  // anything unlikely and dividable
     }
 

-    GdkVisual *visual = gdk_window_get_visual( bitmap.GetPixmap() );
+    GdkVisual *visual = (GdkVisual*) NULL;
+    if (bitmap.GetPixmap())
+        visual = gdk_window_get_visual( bitmap.GetPixmap() );
+    else
+        visual = gdk_window_get_visual( bitmap.GetBitmap() );
+

     if (visual == NULL) visual = gdk_window_get_visual( (GdkWindow*) &gdk_root_parent );
     int bpp = visual->depth;
     if ((bpp == 16) && (visual->red_mask != 0xf800)) bpp = 15;
     if (visual == NULL) visual = gdk_window_get_visual( (GdkWindow*) &gdk_root_parent );
     int bpp = visual->depth;
     if ((bpp == 16) && (visual->red_mask != 0xf800)) bpp = 15;


@@ -1179,7 +1318,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;


@@ -1237,7 +1377,7 @@ wxBitmap wxImage::ConvertToBitmap() const
 {
     wxBitmap bitmap;
 
 {
     wxBitmap bitmap;
 

-    wxCHECK_MSG( Ok(), bitmap, _T("invalid image") );
+    wxCHECK_MSG( Ok(), bitmap, wxT("invalid image") );

 
     int width = GetWidth();
     int height = GetHeight();
 
     int width = GetWidth();
     int height = GetHeight();


@@ -1286,7 +1426,7 @@ wxBitmap wxImage::ConvertToBitmap() const
 
     vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
 
 
     vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
 

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

 
     XFree( vi );
 
 
     XFree( vi );
 


@@ -1437,7 +1577,7 @@ wxBitmap wxImage::ConvertToBitmap() const
 
 wxImage::wxImage( const wxBitmap &bitmap )
 {
 
 wxImage::wxImage( const wxBitmap &bitmap )
 {

-    wxCHECK_RET( bitmap.Ok(), _T("invalid bitmap") );
+    wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );

 
     Display *dpy = (Display*) wxGetDisplay();
     Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
 
     Display *dpy = (Display*) wxGetDisplay();
     Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );


@@ -1449,7 +1589,7 @@ wxImage::wxImage( const wxBitmap &bitmap )
         bitmap.GetWidth(), bitmap.GetHeight(),
         AllPlanes, ZPixmap );
 
         bitmap.GetWidth(), bitmap.GetHeight(),
         AllPlanes, ZPixmap );
 

-    wxCHECK_RET( ximage, _T("couldn't create image") );
+    wxCHECK_RET( ximage, wxT("couldn't create image") );

 
     Create( bitmap.GetWidth(), bitmap.GetHeight() );
     char unsigned *data = GetData();
 
     Create( bitmap.GetWidth(), bitmap.GetHeight() );
     char unsigned *data = GetData();


@@ -1457,7 +1597,7 @@ wxImage::wxImage( const wxBitmap &bitmap )
     if (!data)
     {
         XDestroyImage( ximage );
     if (!data)
     {
         XDestroyImage( ximage );

-        wxFAIL_MSG( _T("couldn't create image") );
+        wxFAIL_MSG( wxT("couldn't create image") );

         return;
     }
 
         return;
     }
 


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

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

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