char* -> wxString

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

diff --git a/src/common/image.cpp b/src/common/image.cpp
index 414ea15c251084dc93be573d7c2c2e85ef996dad..a5b3a74df6b1c37c6bece65b7977e6125d8f7201 100644 (file)
--- a/src/common/image.cpp
+++ b/src/common/image.cpp
@@ -23,13 +23,19 @@
 #include "wx/debug.h"
 #include "wx/log.h"
 #include "wx/app.h"
 #include "wx/debug.h"
 #include "wx/log.h"
 #include "wx/app.h"

-#ifdef wxUSE_LIBPNG
+#if wxUSE_LIBPNG

 #include "../png/png.h"
 #endif
 #include "wx/filefn.h"
 #include "wx/wfstream.h"
 #include "wx/intl.h"
 
 #include "../png/png.h"
 #endif
 #include "wx/filefn.h"
 #include "wx/wfstream.h"
 #include "wx/intl.h"
 

+#ifdef __SALFORDC__
+#ifdef FAR
+#undef FAR
+#endif
+#endif
+

 #ifdef __WXMSW__
 #include <windows.h>
 #endif
 #ifdef __WXMSW__
 #include <windows.h>
 #endif


@@ -94,10 +100,12 @@ wxImage::wxImage( const wxString& name, long type )
     LoadFile( name, type );
 }
 
     LoadFile( name, type );
 }
 

+#if wxUSE_STREAMS

 wxImage::wxImage( wxInputStream& stream, long type )
 {
     LoadFile( stream, type );
 }
 wxImage::wxImage( wxInputStream& stream, long type )
 {
     LoadFile( stream, type );
 }

+#endif // wxUSE_STREAMS

 
 wxImage::wxImage( const wxImage& image )
 {
 
 wxImage::wxImage( const wxImage& image )
 {


@@ -304,6 +312,7 @@ int wxImage::GetHeight() const
 
 bool wxImage::LoadFile( const wxString& filename, long type )
 {
 
 bool wxImage::LoadFile( const wxString& filename, long type )
 {

+#if wxUSE_STREAMS

     if (wxFileExists(filename))
     {
         wxFileInputStream stream(filename);
     if (wxFileExists(filename))
     {
         wxFileInputStream stream(filename);


@@ -311,12 +320,28 @@ bool wxImage::LoadFile( const wxString& filename, long type )
     }
 
     else {
     }
 
     else {

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

 
         return FALSE;
     }
 
         return FALSE;
     }

+#else // !wxUSE_STREAMS
+        return FALSE;
+#endif // wxUSE_STREAMS

 }
 
 }
 

+bool wxImage::SaveFile( const wxString& filename, int type )
+{
+#if wxUSE_STREAMS
+    wxFileOutputStream stream(filename);
+
+    if ( stream.LastError() == wxStream_NOERROR )
+        return SaveFile(stream, type);
+    else
+#endif // wxUSE_STREAMS
+        return FALSE;
+}
+
+#if wxUSE_STREAMS

 bool wxImage::LoadFile( wxInputStream& stream, long type )
 {
     UnRef();
 bool wxImage::LoadFile( wxInputStream& stream, long type )
 {
     UnRef();


@@ -335,16 +360,6 @@ bool wxImage::LoadFile( wxInputStream& stream, long type )
     return handler->LoadFile( this, stream );
 }
 
     return handler->LoadFile( this, stream );
 }
 

-bool wxImage::SaveFile( const wxString& filename, int type )
-{
-    wxFileOutputStream stream(filename);
-
-    if ( stream.LastError() == wxStream_NOERROR )
-        return SaveFile(stream, type);
-    else
-        return FALSE;
-}
-

 bool wxImage::SaveFile( wxOutputStream& stream, int type )
 {
     wxCHECK_MSG( Ok(), FALSE, "invalid image" );
 bool wxImage::SaveFile( wxOutputStream& stream, int type )
 {
     wxCHECK_MSG( Ok(), FALSE, "invalid image" );


@@ -360,6 +375,7 @@ bool wxImage::SaveFile( wxOutputStream& stream, int type )
 
     return handler->SaveFile( this, stream );
 }
 
     return handler->SaveFile( this, stream );
 }

+#endif // wxUSE_STREAMS

 
 void wxImage::AddHandler( wxImageHandler *handler )
 {
 
 void wxImage::AddHandler( wxImageHandler *handler )
 {


@@ -395,7 +411,8 @@ wxImageHandler *wxImage::FindHandler( const wxString& name )
     while (node)
     {
         wxImageHandler *handler = (wxImageHandler*)node->Data();
     while (node)
     {
         wxImageHandler *handler = (wxImageHandler*)node->Data();

-        if (handler->GetName() == name) return handler;
+        if (handler->GetName().Cmp(name) == 0) return handler;
+

         node = node->Next();
     }
     return (wxImageHandler *)NULL;
         node = node->Next();
     }
     return (wxImageHandler *)NULL;


@@ -407,7 +424,7 @@ wxImageHandler *wxImage::FindHandler( const wxString& extension, long bitmapType
     while (node)
     {
         wxImageHandler *handler = (wxImageHandler*)node->Data();
     while (node)
     {
         wxImageHandler *handler = (wxImageHandler*)node->Data();

-        if ( handler->GetExtension() == extension &&
+        if ( (handler->GetExtension().Cmp(extension) == 0) &&

             (bitmapType == -1 || handler->GetType() == bitmapType) )
         return handler;
         node = node->Next();
             (bitmapType == -1 || handler->GetType() == bitmapType) )
         return handler;
         node = node->Next();


@@ -430,7 +447,7 @@ wxImageHandler *wxImage::FindHandler( long bitmapType )
 void wxImage::InitStandardHandlers()
 {
     AddHandler( new wxBMPHandler );
 void wxImage::InitStandardHandlers()
 {
     AddHandler( new wxBMPHandler );

-#ifdef wxUSE_LIBPNG
+#if wxUSE_LIBPNG

     AddHandler( new wxPNGHandler );
 #endif
 }
     AddHandler( new wxPNGHandler );
 #endif
 }


@@ -456,6 +473,7 @@ void wxImage::CleanUpHandlers()
 IMPLEMENT_DYNAMIC_CLASS(wxImageHandler,wxObject)
 #endif
 
 IMPLEMENT_DYNAMIC_CLASS(wxImageHandler,wxObject)
 #endif
 

+#if wxUSE_STREAMS

 bool wxImageHandler::LoadFile( wxImage *WXUNUSED(image), wxInputStream& WXUNUSED(stream) )
 {
     return FALSE;
 bool wxImageHandler::LoadFile( wxImage *WXUNUSED(image), wxInputStream& WXUNUSED(stream) )
 {
     return FALSE;


@@ -465,18 +483,20 @@ bool wxImageHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSE
 {
     return FALSE;
 }
 {
     return FALSE;
 }

+#endif // wxUSE_STREAMS

 
 //-----------------------------------------------------------------------------
 // wxPNGHandler
 //-----------------------------------------------------------------------------
 
 
 //-----------------------------------------------------------------------------
 // wxPNGHandler
 //-----------------------------------------------------------------------------
 

-#ifdef wxUSE_LIBPNG
+#if wxUSE_LIBPNG

 
 #if !USE_SHARED_LIBRARIES
 IMPLEMENT_DYNAMIC_CLASS(wxPNGHandler,wxImageHandler)
 #endif
 
 
 
 #if !USE_SHARED_LIBRARIES
 IMPLEMENT_DYNAMIC_CLASS(wxPNGHandler,wxImageHandler)
 #endif
 
 

+#if wxUSE_STREAMS

 static void _PNG_stream_reader( png_structp png_ptr, png_bytep data, png_size_t length )
 {
    ((wxInputStream*) png_get_io_ptr( png_ptr )) -> Read(data, length);
 static void _PNG_stream_reader( png_structp png_ptr, png_bytep data, png_size_t length )
 {
    ((wxInputStream*) png_get_io_ptr( png_ptr )) -> Read(data, length);


@@ -491,11 +511,12 @@ bool wxPNGHandler::LoadFile( wxImage *image, wxInputStream& stream )
 {
     // VZ: as this function uses setjmp() the only fool proof error handling
     //     method is to use goto (setjmp is not really C++ dtors friendly...)
 {
     // VZ: as this function uses setjmp() the only fool proof error handling
     //     method is to use goto (setjmp is not really C++ dtors friendly...)

-    image->Destroy();
-
+    
+    unsigned char **lines = (unsigned char **) NULL;

     unsigned int i;
     unsigned int i;

-    unsigned char **lines = NULL;
-    png_infop info_ptr = NULL;
+    png_infop info_ptr = (png_infop) NULL;
+    
+    image->Destroy();

 
     png_structp png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING,
                                                   (voidp) NULL,
 
     png_structp png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING,
                                                   (voidp) NULL,


@@ -728,6 +749,7 @@ bool wxPNGHandler::SaveFile( wxImage *image, wxOutputStream& stream )
   }
   return TRUE;
 }
   }
   return TRUE;
 }

+#endif // wxUSE_STREAMS

 
 #endif
 
 
 #endif
 


@@ -741,6 +763,7 @@ bool wxPNGHandler::SaveFile( wxImage *image, wxOutputStream& stream )
 IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler,wxImageHandler)
 #endif
 
 IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler,wxImageHandler)
 #endif
 

+#if wxUSE_STREAMS

 bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
 {
    unsigned char      *data, *ptr;
 bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
 {
    unsigned char      *data, *ptr;


@@ -1090,220 +1113,339 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
 
    return TRUE;
 }
 
    return TRUE;
 }

+#endif // wxUSE_STREAMS

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

+// sizeLimit is the MS upper limit for the DIB size
+    int sizeLimit = 1024*768*3; 

 
 

-  wxBitmap bitmap;
-  wxCHECK_MSG( Ok(), bitmap, "invalid image" );
-  int width = GetWidth();
-  int height = GetHeight();
-  bitmap.SetWidth( width );
-  bitmap.SetHeight( height );
-  bitmap.SetDepth( wxDisplayDepth() );
+// width and height of the device-dependent bitmap
+    int width = GetWidth();
+    int bmpHeight = GetHeight();
+
+// calc the number of bytes per scanline and padding
+    int bytePerLine = width*3;
+    int sizeDWORD = sizeof( DWORD );
+    div_t lineBoundary = div( bytePerLine, sizeDWORD );
+    int padding = 0;
+    if( lineBoundary.rem > 0 )  
+    {
+        padding = sizeDWORD - lineBoundary.rem;
+        bytePerLine += padding;
+    }
+// calc the number of DIBs and heights of DIBs
+    int numDIB = 1;
+    int hRemain = 0;
+    int height = sizeLimit/bytePerLine;
+    if( height >= bmpHeight )
+        height = bmpHeight; 
+    else
+    {
+        div_t result = div( bmpHeight, height );
+        numDIB = result.quot;
+       hRemain = result.rem;
+       if( hRemain >0 )  numDIB++;
+    }

 
 

-  int headersize = sizeof(BITMAPINFOHEADER);
-  LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
-  wxCHECK_MSG( lpDIBh, bitmap, "could not allocate memory for DIB header" );
+// set bitmap parameters
+    wxBitmap bitmap;
+    wxCHECK_MSG( Ok(), bitmap, "invalid image" );
+    bitmap.SetWidth( width );
+    bitmap.SetHeight( bmpHeight );
+    bitmap.SetDepth( wxDisplayDepth() );

 
 

+// create a DIB header
+    int headersize = sizeof(BITMAPINFOHEADER);
+    LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
+    wxCHECK_MSG( lpDIBh, bitmap, "could not allocate memory for DIB header" );

 // Fill in the DIB header
 // Fill in the DIB header

-  lpDIBh->bmiHeader.biSize = headersize;
-  lpDIBh->bmiHeader.biWidth = width;
-  lpDIBh->bmiHeader.biHeight = -height;
-  lpDIBh->bmiHeader.biSizeImage = width * height * 3;
-
-  lpDIBh->bmiHeader.biPlanes = 1;
-  lpDIBh->bmiHeader.biBitCount = 24;
-  lpDIBh->bmiHeader.biCompression = BI_RGB;
-  lpDIBh->bmiHeader.biClrUsed = 0;
-
-// These seem not needed for our purpose here.
-//  lpDIBh->bmiHeader.biClrImportant = 0;
-//  lpDIBh->bmiHeader.biXPelsPerMeter = 0;
-//  lpDIBh->bmiHeader.biYPelsPerMeter = 0;
-
-  unsigned char *lpBits = (unsigned char *) malloc( width*height*3 );
-  if( !lpBits )
-  {
-      wxFAIL_MSG( "could not allocate memory for DIB" );
-      free( lpDIBh );
-      return bitmap;
-  }
-
-  unsigned char *data = GetData();
-
-  unsigned char *ptdata = data, *ptbits = lpBits;
-  for( int i=0; i<width*height; i++ )
-  {
-    *(ptbits++) = *(ptdata+2);
-    *(ptbits++) = *(ptdata+1);
-    *(ptbits++) = *(ptdata  );
-    ptdata += 3;
-  }
-
-  HDC hdc = ::GetDC(NULL);
-
-  HBITMAP hbitmap;
-  hbitmap = CreateDIBitmap( hdc, &(lpDIBh->bmiHeader), CBM_INIT, lpBits, lpDIBh, DIB_RGB_COLORS );
+    lpDIBh->bmiHeader.biSize = headersize;
+    lpDIBh->bmiHeader.biWidth = (DWORD)width;
+    lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
+    lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
+//   the general formula for biSizeImage:
+//      ( ( ( ((DWORD)width*24) +31 ) & ~31 ) >> 3 ) * height;
+    lpDIBh->bmiHeader.biPlanes = 1;
+    lpDIBh->bmiHeader.biBitCount = 24;
+    lpDIBh->bmiHeader.biCompression = BI_RGB;
+    lpDIBh->bmiHeader.biClrUsed = 0;
+// These seem not really needed for our purpose here.
+    lpDIBh->bmiHeader.biClrImportant = 0;
+    lpDIBh->bmiHeader.biXPelsPerMeter = 0;
+    lpDIBh->bmiHeader.biYPelsPerMeter = 0;
+// memory for DIB data
+    unsigned char *lpBits;
+    lpBits = (unsigned char *)malloc( lpDIBh->bmiHeader.biSizeImage );
+    if( !lpBits )
+    {
+        wxFAIL_MSG( "could not allocate memory for DIB" );
+        free( lpDIBh );
+        return bitmap;
+    }

 
 

+// create and set the device-dependent bitmap
+    HDC hdc = ::GetDC(NULL);
+    HDC memdc = ::CreateCompatibleDC( hdc );
+    HBITMAP hbitmap;
+    hbitmap = ::CreateCompatibleBitmap( hdc, width, bmpHeight );
+    ::SelectObject( memdc, hbitmap); 
+
+// copy image data into DIB data and then into DDB (in a loop)
+    unsigned char *data = GetData();
+    int i, j, n;
+    int origin = 0;
+    unsigned char *ptdata = data;
+    unsigned char *ptbits;
+
+    for( n=0; n<numDIB; n++ )
+    {
+       if( numDIB > 1 && n == numDIB-1 && hRemain > 0 )
+       {
+           // redefine height and size of the (possibly) last smaller DIB
+           // memory is not reallocated
+           height = hRemain; 
+            lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
+            lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
+       }
+        ptbits = lpBits;
+
+        for( j=0; j<height; j++ )
+        {
+            for( i=0; i<width; i++ )
+            {
+                *(ptbits++) = *(ptdata+2);
+                *(ptbits++) = *(ptdata+1);
+                *(ptbits++) = *(ptdata  );
+                ptdata += 3;
+           }
+           for( i=0; i< padding; i++ )   *(ptbits++) = 0;
+        }
+        ::StretchDIBits( memdc, 0, origin, width, height,\
+           0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
+       origin += height;
+// if numDIB = 1,  lines below can also be used
+//    hbitmap = CreateDIBitmap( hdc, &(lpDIBh->bmiHeader), CBM_INIT, lpBits, lpDIBh, DIB_RGB_COLORS );

 // The above line is equivalent to the following two lines.
 //    hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
 //    ::SetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS);
 // or the following lines
 //    hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
 //    HDC memdc = ::CreateCompatibleDC( hdc );
 // The above line is equivalent to the following two lines.
 //    hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
 //    ::SetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS);
 // or the following lines
 //    hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
 //    HDC memdc = ::CreateCompatibleDC( hdc );

-//    ::SelectObject( memdc, hbitmap);
+//    ::SelectObject( memdc, hbitmap); 

 //    ::SetDIBitsToDevice( memdc, 0, 0, width, height,
 //    ::SetDIBitsToDevice( memdc, 0, 0, width, height,

-//          0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);
-//    ::SelectObject( memdc, 0 );
-//    ::DeleteDC( memdc );
-
-  bitmap.SetHBITMAP( (WXHBITMAP) hbitmap );
-
-  if( HasMask() )
-  {
-    unsigned char r = GetMaskRed();
-    unsigned char g = GetMaskGreen();
-    unsigned char b = GetMaskBlue();
-    unsigned char zero = 0, one = 255;
-    ptdata = data;
-    ptbits = lpBits;
-    for( int i=0; i<width*height; i++ )
-    {
-      if( (*(ptdata++)!=r) | (*(ptdata++)!=g) | (*(ptdata++)!=b) )
-      {
-        *(ptbits++) = one;
-        *(ptbits++) = one;
-        *(ptbits++) = one;
-      }
-      else
-      {
-        *(ptbits++) = zero;
-        *(ptbits++) = zero;
-        *(ptbits++) = zero;
-      }
+//         0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);
+//    ::SelectObject( memdc, 0 ); 
+//    ::DeleteDC( memdc ); 

     }
     }

-    hbitmap = ::CreateBitmap( (WORD)width, (WORD)height, 1, 1, NULL );
-    ::SetDIBits( hdc, hbitmap, 0, (WORD)height, lpBits, lpDIBh, DIB_RGB_COLORS);
-    wxMask *mask = new wxMask();
-    mask->SetMaskBitmap( (WXHBITMAP) hbitmap );
-    bitmap.SetMask( mask );
+    bitmap.SetHBITMAP( (WXHBITMAP) hbitmap );

 
 

+// similarly, created an mono-bitmap for the possible mask
+    if( HasMask() )
+    {
+        hbitmap = ::CreateBitmap( (WORD)width, (WORD)bmpHeight, 1, 1, NULL );
+        ::SelectObject( memdc, hbitmap); 
+        if( numDIB == 1 )   height = bmpHeight; 
+        else                height = sizeLimit/bytePerLine;
+        lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
+        lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
+        origin = 0;
+        unsigned char r = GetMaskRed();
+        unsigned char g = GetMaskGreen();
+        unsigned char b = GetMaskBlue();
+        unsigned char zero = 0, one = 255;
+        ptdata = data;
+        for( n=0; n<numDIB; n++ )
+        {
+            if( numDIB > 1 && n == numDIB - 1 && hRemain > 0 )
+            {
+               // redefine height and size of the (possibly) last smaller DIB
+               // memory is not reallocated
+               height = hRemain; 
+                lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
+                lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
+           }
+            ptbits = lpBits;
+            for( int j=0; j<height; j++ )
+            {
+                for( int i=0; i<width; i++ )
+                {
+                    if( (*(ptdata++)!=r) | (*(ptdata++)!=g) | (*(ptdata++)!=b) )
+                    {
+                        *(ptbits++) = one;
+                        *(ptbits++) = one;
+                        *(ptbits++) = one;
+                    }
+                    else
+                    {
+                        *(ptbits++) = zero;
+                        *(ptbits++) = zero;
+                        *(ptbits++) = zero;
+                    }
+                }
+               for( i=0; i< padding; i++ )   *(ptbits++) = zero;
+            }
+            ::StretchDIBits( memdc, 0, origin, width, height,\
+               0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
+           origin += height;
+       }
+// create a wxMask object
+        wxMask *mask = new wxMask();
+        mask->SetMaskBitmap( (WXHBITMAP) hbitmap );
+        bitmap.SetMask( mask );
+// It will be deleted when the wxBitmap object is deleted (as of 01/1999)

 /* The following can also be used but is slow to run
 /* The following can also be used but is slow to run

-    wxColour colour( GetMaskRed(), GetMaskGreen(), GetMaskBlue());
-    wxMask *mask = new wxMask( bitmap, colour );
-    bitmap.SetMask( mask );
+        wxColour colour( GetMaskRed(), GetMaskGreen(), GetMaskBlue());
+        wxMask *mask = new wxMask( bitmap, colour );
+        bitmap.SetMask( mask );

 */
 */

-  }
-
-  ::ReleaseDC(NULL, hdc);
-  free(lpDIBh);
-  free(lpBits);
+    }

 
 

-  if( bitmap.GetHBITMAP() )
-    bitmap.SetOk( TRUE );
-  else
-    bitmap.SetOk( FALSE );
+// free allocated resources  
+    ::SelectObject( memdc, 0 ); 
+    ::DeleteDC( memdc ); 
+    ::ReleaseDC(NULL, hdc);   
+    free(lpDIBh);
+    free(lpBits);

 
 

-  return bitmap;
+// check the wxBitmap object
+    if( bitmap.GetHBITMAP() )
+        bitmap.SetOk( TRUE );
+    else
+        bitmap.SetOk( FALSE );
+   
+    return bitmap;

 }
 
 }
 

-

 wxImage::wxImage( const wxBitmap &bitmap )
 {
 wxImage::wxImage( const wxBitmap &bitmap )
 {

-  if( !bitmap.Ok() )
-  {
-      wxFAIL_MSG( "invalid bitmap" );
-      return;
-  }
+// check the bitmap
+    if( !bitmap.Ok() )
+    {
+        wxFAIL_MSG( "invalid bitmap" );
+        return;
+    }

 
 

-  int width = bitmap.GetWidth();
-  int height = bitmap.GetHeight();
-  Create( width, height );
-  unsigned char *data = GetData();
-  if( !data )
-  {
-      wxFAIL_MSG( "could not allocate data for image" );
-      return;
-  }
+// create an wxImage object
+    int width = bitmap.GetWidth();
+    int height = bitmap.GetHeight();
+    Create( width, height ); 
+    unsigned char *data = GetData();
+    if( !data )
+    {
+        wxFAIL_MSG( "could not allocate data for image" );
+        return;
+    }

 
 

-  int headersize = sizeof(BITMAPINFOHEADER);
-  LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
-  if( !lpDIBh )
-  {
-      wxFAIL_MSG( "could not allocate data for DIB header" );
-      free( data );
-      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 padding = 0;
+    if( lineBoundary.rem > 0 )  
+    {
+        padding = sizeDWORD - lineBoundary.rem;
+        bytePerLine += padding;
+    }

 
 

+// create a DIB header
+    int headersize = sizeof(BITMAPINFOHEADER);
+    LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
+    if( !lpDIBh )
+    {
+        wxFAIL_MSG( "could not allocate data for DIB header" );
+        free( data );
+        return;
+    }

 // Fill in the DIB header
 // Fill in the DIB header

-  lpDIBh->bmiHeader.biSize = headersize;
-  lpDIBh->bmiHeader.biWidth = width;
-  lpDIBh->bmiHeader.biHeight = -height;
-  lpDIBh->bmiHeader.biSizeImage = width * height * 3;
-
-  lpDIBh->bmiHeader.biPlanes = 1;
-  lpDIBh->bmiHeader.biBitCount = 24;
-  lpDIBh->bmiHeader.biCompression = BI_RGB;
-  lpDIBh->bmiHeader.biClrUsed = 0;
-
-// These seem not needed for our purpose here.
-//    lpDIBh->bmiHeader.biClrImportant = 0;
-//    lpDIBh->bmiHeader.biXPelsPerMeter = 0;
-//    lpDIBh->bmiHeader.biYPelsPerMeter = 0;
-
-  unsigned char *lpBits = (unsigned char *) malloc( width*height*3 );
-  if( !lpBits )
-  {
-      wxFAIL_MSG( "could not allocate data for DIB" );
-      free( data );
-      free( lpDIBh );
-      return;
-  }
-
-  HBITMAP hbitmap;
-  hbitmap = (HBITMAP) bitmap.GetHBITMAP();
-  HDC hdc = ::GetDC(NULL);
-  ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
-
-  unsigned char *ptdata = data, *ptbits = lpBits;
-  for( int i=0; i<width*height; i++ )
-  {
-    *(ptdata++) = *(ptbits+2);
-    *(ptdata++) = *(ptbits+1);
-    *(ptdata++) = *(ptbits  );
-    ptbits += 3;
-  }
-
-  if( bitmap.GetMask() && bitmap.GetMask()->GetMaskBitmap() )
-  {
-    hbitmap = (HBITMAP) bitmap.GetMask()->GetMaskBitmap();
-    HDC memdc = ::CreateCompatibleDC( hdc );
-    ::SetTextColor( memdc, RGB( 0, 0, 0 ) );
-    ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
-    ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
-    ::DeleteDC( memdc );
-    unsigned char r=16, g=16, b=16;  // background set to RGB(16,16,16)
-    ptdata = data;
-    ptbits = lpBits;
-    for( int i=0; i<width*height; i++ )
+    lpDIBh->bmiHeader.biSize = headersize;
+    lpDIBh->bmiHeader.biWidth = width;
+    lpDIBh->bmiHeader.biHeight = -height;
+    lpDIBh->bmiHeader.biSizeImage = bytePerLine * height;
+    lpDIBh->bmiHeader.biPlanes = 1;
+    lpDIBh->bmiHeader.biBitCount = 24;
+    lpDIBh->bmiHeader.biCompression = BI_RGB;
+    lpDIBh->bmiHeader.biClrUsed = 0;
+// These seem not really needed for our purpose here.
+    lpDIBh->bmiHeader.biClrImportant = 0;
+    lpDIBh->bmiHeader.biXPelsPerMeter = 0;
+    lpDIBh->bmiHeader.biYPelsPerMeter = 0;
+// memory for DIB data
+    unsigned char *lpBits;
+    lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
+    if( !lpBits )

     {
     {

-      if( *ptbits != 0 )
-      {
-        *(ptdata++)  = r;
-        *(ptdata++)  = g;
-        *(ptdata++)  = b;
-      }
-      ptbits += 3;
+        wxFAIL_MSG( "could not allocate data for DIB" );
+        free( data );
+        free( lpDIBh );
+        return;

     }
     }

-    SetMaskColour( r, g, b );
-  }
-
-  ::ReleaseDC(NULL, hdc);
-  free(lpDIBh);
-  free(lpBits);
+    
+// copy data from the device-dependent bitmap to the DIB
+    HDC hdc = ::GetDC(NULL);
+    HBITMAP hbitmap;
+    hbitmap = (HBITMAP) bitmap.GetHBITMAP();
+    ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
+       
+// copy DIB data into the wxImage object
+    int i, j;
+    unsigned char *ptdata = data;
+    unsigned char *ptbits = lpBits;
+    for( i=0; i<height; i++ )
+    {
+        for( j=0; j<width; j++ )
+        {
+            *(ptdata++) = *(ptbits+2);
+            *(ptdata++) = *(ptbits+1);
+            *(ptdata++) = *(ptbits  );
+            ptbits += 3;
+       }
+        ptbits += padding;
+    }  
+      
+// similarly, set data according to the possible mask bitmap
+    if( bitmap.GetMask() && bitmap.GetMask()->GetMaskBitmap() )
+    {
+        hbitmap = (HBITMAP) bitmap.GetMask()->GetMaskBitmap();
+       // memory DC created, color set, data copied, and memory DC deleted
+        HDC memdc = ::CreateCompatibleDC( hdc );
+        ::SetTextColor( memdc, RGB( 0, 0, 0 ) );
+        ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
+        ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
+        ::DeleteDC( memdc ); 
+// background color set to RGB(16,16,16) in consistent with wxGTK
+        unsigned char r=16, g=16, b=16;  
+        ptdata = data;
+        ptbits = lpBits;
+        for( i=0; i<height; i++ )
+        {
+            for( j=0; j<width; j++ )
+            {
+                if( *ptbits != 0 )
+                   ptdata += 3;
+               else
+                {
+                    *(ptdata++)  = r;
+                    *(ptdata++)  = g;
+                    *(ptdata++)  = b;
+               }
+                ptbits += 3;
+            }
+            ptbits += padding;
+        }       
+        SetMaskColour( r, g, b );
+        SetMask( TRUE );
+    }  
+    else
+    {
+        SetMask( FALSE );
+    }  
+// free allocated resources      
+    ::ReleaseDC(NULL, hdc);   
+    free(lpDIBh);
+    free(lpBits);

 }
 
 #endif
 }
 
 #endif


@@ -1417,8 +1559,7 @@ wxBitmap wxImage::ConvertToBitmap() const
                     int pixel = -1;
                     if (wxTheApp->m_colorCube)
                     {
                     int pixel = -1;
                     if (wxTheApp->m_colorCube)
                     {

-                        pixel = wxTheApp->m_colorCube
-                           [ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
+                        pixel = wxTheApp->m_colorCube[ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];

                     }
                     else
                     {
                     }
                     else
                     {


@@ -1582,12 +1723,11 @@ wxImage::wxImage( const wxBitmap &bitmap )
 
 #endif
 
 
 #endif
 

-// TODO
-

 #ifdef __WXMOTIF__
 
 #include <Xm/Xm.h>
 #include "wx/utils.h"
 #ifdef __WXMOTIF__
 
 #include <Xm/Xm.h>
 #include "wx/utils.h"

+#include <math.h>

 
 wxBitmap wxImage::ConvertToBitmap() const
 {
 
 wxBitmap wxImage::ConvertToBitmap() const
 {


@@ -1630,8 +1770,6 @@ wxBitmap wxImage::ConvertToBitmap() const
     }
 */
 
     }
 */
 

-//    bitmap.SetDepth( bpp );
-    

     // Retrieve depth info
     
     XVisualInfo vinfo_template;
     // Retrieve depth info
     
     XVisualInfo vinfo_template;


@@ -1650,6 +1788,8 @@ wxBitmap wxImage::ConvertToBitmap() const
         return wxNullBitmap;
     }
        
         return wxNullBitmap;
     }
        

+    XFree( vi );
+

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


@@ -1674,6 +1814,15 @@ wxBitmap wxImage::ConvertToBitmap() const
     int b_mask = GetMaskBlue();
 */
 
     int b_mask = GetMaskBlue();
 */
 

+    XColor colors[256];
+    if (bpp == 8)
+    {
+       Colormap cmap = (Colormap) wxTheApp->GetMainColormap( dpy );
+       
+        for (int i = 0; i < 256; i++) colors[i].pixel = i;
+       XQueryColors( dpy, cmap, colors, 256 );
+    }
+

     unsigned char* data = GetData();
 
     int index = 0;
     unsigned char* data = GetData();
 
     int index = 0;


@@ -1702,8 +1851,8 @@ wxBitmap wxImage::ConvertToBitmap() const
            {
                case 8:
                {
            {
                case 8:
                {

-/*

                     int pixel = -1;
                     int pixel = -1;

+/*

                    if (wxTheApp->m_colorCube)
                    {
                        pixel = wxTheApp->m_colorCube
                    if (wxTheApp->m_colorCube)
                    {
                        pixel = wxTheApp->m_colorCube


@@ -1711,23 +1860,20 @@ wxBitmap wxImage::ConvertToBitmap() const
                     }              
                     else
                    {
                     }              
                     else
                    {

-                       GdkColormap *cmap = gtk_widget_get_default_colormap();
-                        GdkColor *colors = cmap->colors;
+*/

                         int max = 3 * (65536);
                         int max = 3 * (65536);

-
-                        for (int i = 0; i < cmap->size; i++)
+                        for (int i = 0; i < 256; i++)

                         {
                             int rdiff = (r << 8) - colors[i].red;
                             int gdiff = (g << 8) - colors[i].green;
                             int bdiff = (b << 8) - colors[i].blue;
                         {
                             int rdiff = (r << 8) - colors[i].red;
                             int gdiff = (g << 8) - colors[i].green;
                             int bdiff = (b << 8) - colors[i].blue;

-                            int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
+                            int sum = abs (rdiff) + abs (gdiff) + abs (bdiff);

                             if (sum < max) { pixel = i; max = sum; }
                        }
                             if (sum < max) { pixel = i; max = sum; }
                        }

-                    }
-
-                   gdk_image_put_pixel( data_image, x, y, pixel );
+/*
+                   }

 */
 */

-
+                   XPutPixel( data_image, x, y, pixel );

                    break;
                }
                case 15:
                    break;
                }
                case 15:


@@ -1791,6 +1937,121 @@ wxBitmap wxImage::ConvertToBitmap() const
 
 wxImage::wxImage( const wxBitmap &bitmap )
 {
 
 wxImage::wxImage( const wxBitmap &bitmap )
 {

-  wxFAIL_MSG("Sorry, wxImage::wxImage(const wxBitmap&) isn't implemented for wxMotif yet.");
+    wxCHECK_RET( bitmap.Ok(), "invalid bitmap" );
+
+    Display *dpy = (Display*) wxGetDisplay();
+    Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
+    int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
+    
+    XImage *ximage = XGetImage( dpy,
+                                (Drawable)bitmap.GetPixmap(),
+                                0, 0,
+                                bitmap.GetWidth(), bitmap.GetHeight(),
+                               AllPlanes, ZPixmap );
+
+    wxCHECK_RET( ximage, "couldn't create image" );
+
+    Create( bitmap.GetWidth(), bitmap.GetHeight() );
+    char unsigned *data = GetData();
+
+    if (!data)
+    {
+        XDestroyImage( ximage );
+        wxFAIL_MSG( "couldn't create image" );
+        return;
+    }
+
+/*
+    GdkImage *gdk_image_mask = (GdkImage*) NULL;
+    if (bitmap.GetMask())
+    {
+        gdk_image_mask = gdk_image_get( bitmap.GetMask()->GetBitmap(),
+                                        0, 0,
+                                        bitmap.GetWidth(), bitmap.GetHeight() );
+
+        SetMaskColour( 16, 16, 16 );  // anything unlikely and dividable
+    }
+*/
+
+    // Retrieve depth info
+    
+    XVisualInfo vinfo_template;
+    XVisualInfo *vi;
+    
+    vinfo_template.visual = vis;
+    vinfo_template.visualid = XVisualIDFromVisual( vis );
+    vinfo_template.depth = bpp;
+    int nitem = 0;
+    
+    vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
+    
+    if (!vi) 
+    {
+        printf("no visual.\n" );
+        return;
+    }
+       
+    if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
+    
+    XFree( vi );
+
+    XColor colors[256];
+    if (bpp == 8)
+    {
+       Colormap cmap = (Colormap)wxTheApp->GetMainColormap( dpy );
+       
+        for (int i = 0; i < 256; i++) colors[i].pixel = i;
+       XQueryColors( dpy, cmap, colors, 256 );
+    }
+
+    long pos = 0;
+    for (int j = 0; j < bitmap.GetHeight(); j++)
+    {
+        for (int i = 0; i < bitmap.GetWidth(); i++)
+        {
+           int pixel = XGetPixel( ximage, i, j );
+            if (bpp <= 8)
+            {
+                data[pos] = colors[pixel].red >> 8;
+                data[pos+1] = colors[pixel].green >> 8;
+                data[pos+2] = colors[pixel].blue >> 8;
+            } else if (bpp == 15)
+            {
+                data[pos] = (pixel >> 7) & 0xf8;
+                data[pos+1] = (pixel >> 2) & 0xf8;
+                data[pos+2] = (pixel << 3) & 0xf8;
+            } else if (bpp == 16)
+            {
+                data[pos] = (pixel >> 8) & 0xf8;
+                data[pos+1] = (pixel >> 3) & 0xfc;
+                data[pos+2] = (pixel << 3) & 0xf8;
+            } else
+            {
+                data[pos] = (pixel >> 16) & 0xff;
+                data[pos+1] = (pixel >> 8) & 0xff;
+                data[pos+2] = pixel & 0xff;
+            }
+
+/*
+            if (gdk_image_mask)
+            {
+                int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
+                if (mask_pixel == 0)
+                {
+                    data[pos] = 16;
+                    data[pos+1] = 16;
+                    data[pos+2] = 16;
+               }
+            }
+*/
+
+            pos += 3;
+        }
+    }
+
+    XDestroyImage( ximage );
+/*
+    if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
+*/

 }
 #endif
 }
 #endif