X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/68be9f090f422450d333385cf62c9b4d350674be..237c5c02427fe15b0f7c5ed87a4b582d5b069c8e:/src/common/image.cpp

diff --git a/src/common/image.cpp b/src/common/image.cpp
index 5f61154db2..893eed643f 100644
--- a/src/common/image.cpp
+++ b/src/common/image.cpp
@@ -56,6 +56,10 @@ public:
     bool            m_hasMask;
     unsigned char   m_maskRed,m_maskGreen,m_maskBlue;
     bool            m_ok;
+    bool            m_static;
+    wxPalette       m_palette;
+    wxArrayString   m_optionNames;
+    wxArrayString   m_optionValues;
 };
 
 wxImageRefData::wxImageRefData()
@@ -68,11 +72,12 @@ wxImageRefData::wxImageRefData()
     m_maskGreen = 0;
     m_maskBlue = 0;
     m_hasMask = FALSE;
+    m_static = FALSE;
 }
 
 wxImageRefData::~wxImageRefData()
 {
-    if (m_data)
+    if (m_data && !m_static)
         free( m_data );
 }
 
@@ -82,7 +87,7 @@ wxList wxImage::sm_handlers;
 
 #define M_IMGDATA ((wxImageRefData *)m_refData)
 
-    IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)
+IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)
 
 wxImage::wxImage()
 {
@@ -93,6 +98,11 @@ wxImage::wxImage( int width, int height )
     Create( width, height );
 }
 
+wxImage::wxImage( int width, int height, unsigned char* data, bool static_data )
+{
+    Create( width, height, data, static_data );
+}
+
 wxImage::wxImage( const wxString& name, long type )
 {
     LoadFile( name, type );
@@ -146,11 +156,51 @@ void wxImage::Create( int width, int height )
     }
 }
 
+void wxImage::Create( int width, int height, unsigned char* data, bool static_data )
+{
+    UnRef();
+
+    m_refData = new wxImageRefData();
+
+    M_IMGDATA->m_data = data;
+    if (M_IMGDATA->m_data)
+    {
+        M_IMGDATA->m_width = width;
+        M_IMGDATA->m_height = height;
+        M_IMGDATA->m_ok = TRUE;
+        M_IMGDATA->m_static = static_data;
+    }
+    else
+    {
+        UnRef();
+    }
+}
+
 void wxImage::Destroy()
 {
     UnRef();
 }
 
+wxImage wxImage::Copy() const
+{
+    wxImage image;
+
+    wxCHECK_MSG( Ok(), image, wxT("invalid image") );
+
+    image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height );
+
+    char unsigned *data = image.GetData();
+
+    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 );
+
+    memcpy( data, GetData(), M_IMGDATA->m_width*M_IMGDATA->m_height*3 );
+
+    return image;
+}
+
 wxImage wxImage::Scale( int width, int height ) const
 {
     wxImage image;
@@ -190,6 +240,91 @@ wxImage wxImage::Scale( int width, int height ) const
     return image;
 }
 
+wxImage wxImage::Rotate90( bool clockwise ) const
+{
+    wxImage image;
+
+    wxCHECK_MSG( Ok(), image, wxT("invalid image") );
+
+    image.Create( M_IMGDATA->m_height, M_IMGDATA->m_width );
+
+    char unsigned *data = image.GetData();
+
+    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 );
+
+    long height = M_IMGDATA->m_height;
+    long width  = M_IMGDATA->m_width;
+
+    char unsigned *source_data = M_IMGDATA->m_data;
+    char unsigned *target_data;
+
+    for (long j = 0; j < height; j++)
+    {
+        for (long i = 0; i < width; i++)
+        {
+            if (clockwise)
+                target_data = data + (((i+1)*height) - j - 1)*3;
+            else
+                target_data = data + ((height*(width-1)) + j - (i*height))*3;
+            memcpy( target_data, source_data, 3 );
+            source_data += 3;
+        }
+    }
+
+    return image;
+}
+
+wxImage wxImage::Mirror( bool horizontally ) const
+{
+    wxImage image;
+
+    wxCHECK_MSG( Ok(), image, wxT("invalid image") );
+
+    image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height );
+
+    char unsigned *data = image.GetData();
+
+    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 );
+
+    long height = M_IMGDATA->m_height;
+    long width  = M_IMGDATA->m_width;
+
+    char unsigned *source_data = M_IMGDATA->m_data;
+    char unsigned *target_data;
+
+    if (horizontally)
+    {
+        for (long j = 0; j < height; j++)
+        {
+            data += width*3;
+            target_data = data-3;
+            for (long i = 0; i < width; i++)
+            {
+                memcpy( target_data, source_data, 3 );
+                source_data += 3;
+                target_data -= 3;
+            }
+        }
+    }
+    else
+    {
+        for (long i = 0; i < height; i++)
+        {
+            target_data = data + 3*width*(height-1-i);
+            memcpy( target_data, source_data, (size_t)3*width );
+            source_data += 3*width;
+        }
+    }
+
+    return image;
+}
+
 wxImage wxImage::GetSubImage( const wxRect &rect ) const
 {
     wxImage image;
@@ -227,6 +362,86 @@ wxImage wxImage::GetSubImage( const wxRect &rect ) const
     return image;
 }
 
+void wxImage::Paste( const wxImage &image, int x, int y )
+{
+    wxCHECK_RET( Ok(), wxT("invalid image") );
+    wxCHECK_RET( image.Ok(), wxT("invalid image") );
+
+    int xx = 0;
+    int yy = 0;
+    int width = image.GetWidth();
+    int height = image.GetHeight();
+
+    if (x < 0)
+    {
+        xx = -x;
+        width += x;
+    }
+    if (y < 0)
+    {
+        yy = -y;
+        height += y;
+    }
+
+    if ((x+xx)+width > M_IMGDATA->m_width)
+        width = M_IMGDATA->m_width - (x+xx);
+    if ((y+yy)+height > M_IMGDATA->m_height)
+        height = M_IMGDATA->m_height - (y+yy);
+
+    if (width < 1) return;
+    if (height < 1) return;
+
+    if ((!HasMask() && !image.HasMask()) ||
+       ((HasMask() && image.HasMask() &&
+         (GetMaskRed()==image.GetMaskRed()) &&
+         (GetMaskGreen()==image.GetMaskGreen()) &&
+         (GetMaskBlue()==image.GetMaskBlue()))))
+    {
+        width *= 3;
+        unsigned char* source_data = image.GetData() + xx*3 + yy*3*image.GetWidth();
+        int source_step = image.GetWidth()*3;
+
+        unsigned char* target_data = GetData() + (x+xx)*3 + (y+yy)*3*M_IMGDATA->m_width;
+        int target_step = M_IMGDATA->m_width*3;
+        for (int j = 0; j < height; j++)
+        {
+            memcpy( target_data, source_data, width );
+            source_data += source_step;
+            target_data += target_step;
+        }
+        return;
+    }
+    
+    if (!HasMask() && image.HasMask())
+    {
+        unsigned char r = image.GetMaskRed();
+        unsigned char g = image.GetMaskGreen();
+        unsigned char b = image.GetMaskBlue();
+        
+        width *= 3;
+        unsigned char* source_data = image.GetData() + xx*3 + yy*3*image.GetWidth();
+        int source_step = image.GetWidth()*3;
+
+        unsigned char* target_data = GetData() + (x+xx)*3 + (y+yy)*3*M_IMGDATA->m_width;
+        int target_step = M_IMGDATA->m_width*3;
+        
+        for (int j = 0; j < height; j++)
+        {
+            for (int i = 0; i < width; i+=3)
+            {
+                if ((source_data[i]   != r) && 
+                    (source_data[i+1] != g) && 
+                    (source_data[i+2] != b))
+                {
+                    memcpy( target_data+i, source_data+i, 3 );
+                }
+            } 
+            source_data += source_step;
+            target_data += target_step;
+        }
+    }
+}
+
 void wxImage::Replace( unsigned char r1, unsigned char g1, unsigned char b1,
                        unsigned char r2, unsigned char g2, unsigned char b2 )
 {
@@ -266,7 +481,7 @@ void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned c
     M_IMGDATA->m_data[ pos+2 ] = b;
 }
 
-unsigned char wxImage::GetRed( int x, int y )
+unsigned char wxImage::GetRed( int x, int y ) const
 {
     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
 
@@ -280,7 +495,7 @@ unsigned char wxImage::GetRed( int x, int y )
     return M_IMGDATA->m_data[pos];
 }
 
-unsigned char wxImage::GetGreen( int x, int y )
+unsigned char wxImage::GetGreen( int x, int y ) const
 {
     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
 
@@ -294,7 +509,7 @@ unsigned char wxImage::GetGreen( int x, int y )
     return M_IMGDATA->m_data[pos+1];
 }
 
-unsigned char wxImage::GetBlue( int x, int y )
+unsigned char wxImage::GetBlue( int x, int y ) const
 {
     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
 
@@ -340,6 +555,34 @@ void wxImage::SetData( char unsigned *data )
     m_refData = newRefData;
 }
 
+void wxImage::SetData( char unsigned *data, int new_width, int new_height )
+{
+    wxImageRefData *newRefData = new wxImageRefData();
+
+    if (m_refData)
+    {
+        newRefData->m_width = new_width;
+        newRefData->m_height = new_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;
+    }
+    else
+    {
+        newRefData->m_width = new_width;
+        newRefData->m_height = new_height;
+        newRefData->m_data = data;
+        newRefData->m_ok = TRUE;
+    }
+
+    UnRef();
+
+    m_refData = newRefData;
+}
+
 void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )
 {
     wxCHECK_RET( Ok(), wxT("invalid image") );
@@ -399,6 +642,80 @@ int wxImage::GetHeight() const
     return M_IMGDATA->m_height;
 }
 
+// Palette functions
+
+bool wxImage::HasPalette() const
+{
+    if (!Ok())
+        return FALSE;
+
+    return M_IMGDATA->m_palette.Ok();
+}
+
+const wxPalette& wxImage::GetPalette() const
+{
+    wxCHECK_MSG( Ok(), wxNullPalette, wxT("invalid image") );
+
+    return M_IMGDATA->m_palette;
+}
+
+void wxImage::SetPalette(const wxPalette& palette)
+{
+    wxCHECK_RET( Ok(), wxT("invalid image") );
+
+    M_IMGDATA->m_palette = palette;
+}
+
+// Option functions (arbitrary name/value mapping)
+void wxImage::SetOption(const wxString& name, const wxString& value)
+{
+    wxCHECK_RET( Ok(), wxT("invalid image") );
+
+    int idx = M_IMGDATA->m_optionNames.Index(name, FALSE);
+    if (idx == wxNOT_FOUND)
+    {
+        M_IMGDATA->m_optionNames.Add(name);
+        M_IMGDATA->m_optionValues.Add(value);
+    }
+    else
+    {
+        M_IMGDATA->m_optionNames[idx] = name;
+        M_IMGDATA->m_optionValues[idx] = value;
+    }
+}
+
+void wxImage::SetOption(const wxString& name, int value)
+{
+    wxString valStr;
+    valStr.Printf(wxT("%d"), value);
+    SetOption(name, valStr);
+}
+
+wxString wxImage::GetOption(const wxString& name) const
+{
+    wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid image") );
+
+    int idx = M_IMGDATA->m_optionNames.Index(name, FALSE);
+    if (idx == wxNOT_FOUND)
+        return wxEmptyString;
+    else
+        return M_IMGDATA->m_optionValues[idx];
+}
+
+int wxImage::GetOptionInt(const wxString& name) const
+{
+    wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
+
+    return wxAtoi(GetOption(name));
+}
+
+bool wxImage::HasOption(const wxString& name) const
+{
+    wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );
+
+    return (M_IMGDATA->m_optionNames.Index(name, FALSE) != wxNOT_FOUND);
+}
+
 bool wxImage::LoadFile( const wxString& filename, long type )
 {
 #if wxUSE_STREAMS
@@ -449,9 +766,9 @@ bool wxImage::SaveFile( const wxString& filename, int type )
         wxBufferedOutputStream bstream( stream );
         return SaveFile(bstream, type);
     }
-    else
 #endif // wxUSE_STREAMS
-        return FALSE;
+
+    return FALSE;
 }
 
 bool wxImage::SaveFile( const wxString& filename, const wxString& mimetype )
@@ -464,9 +781,9 @@ bool wxImage::SaveFile( const wxString& filename, const wxString& mimetype )
         wxBufferedOutputStream bstream( stream );
         return SaveFile(bstream, mimetype);
     }
-    else
 #endif // wxUSE_STREAMS
-        return FALSE;
+
+    return FALSE;
 }
 
 bool wxImage::CanRead( const wxString &name )
@@ -807,6 +1124,13 @@ wxBitmap wxImage::ConvertToBitmap() const
     hbitmap = ::CreateCompatibleBitmap( hdc, width, bmpHeight );
     ::SelectObject( memdc, hbitmap);
 
+    HPALETTE hOldPalette = 0;
+    if (GetPalette().Ok())
+    {
+        hOldPalette = ::SelectPalette(memdc, (HPALETTE) GetPalette().GetHPALETTE(), FALSE);
+        ::RealizePalette(memdc);
+    }
+
     // copy image data into DIB data and then into DDB (in a loop)
     unsigned char *data = GetData();
     int i, j, n;
@@ -856,6 +1180,9 @@ wxBitmap wxImage::ConvertToBitmap() const
     }
     bitmap.SetHBITMAP( (WXHBITMAP) hbitmap );
 
+    if (hOldPalette)
+        SelectPalette(memdc, hOldPalette, FALSE);
+
     // similarly, created an mono-bitmap for the possible mask
     if( HasMask() )
     {
@@ -1621,7 +1948,7 @@ wxImage::wxImage( const wxBitmap &bitmap )
     }
 
     wxCHECK_RET( gdk_image, wxT("couldn't create image") );
-
+    
     Create( bitmap.GetWidth(), bitmap.GetHeight() );
     char unsigned *data = GetData();