#pragma hdrstop
#endif
-#include "wx/defs.h"
-
#if wxUSE_IMAGE
#include "wx/image.h"
-#include "wx/bitmap.h"
-#include "wx/debug.h"
-#include "wx/log.h"
-#include "wx/app.h"
+
+#ifndef WX_PRECOMP
+ #include "wx/log.h"
+ #include "wx/app.h"
+ #include "wx/hash.h"
+ #include "wx/utils.h"
+ #include "wx/bitmap.h"
+ #include "wx/math.h"
+#endif
+
#include "wx/filefn.h"
#include "wx/wfstream.h"
#include "wx/intl.h"
#include "wx/module.h"
-#include "wx/hash.h"
-#include "wx/utils.h"
-#include "wx/math.h"
#if wxUSE_XPM
-#include "wx/xpmdecod.h"
+ #include "wx/xpmdecod.h"
#endif
// For memcpy
//-----------------------------------------------------------------------------
-#define M_IMGDATA ((wxImageRefData *)m_refData)
+#define M_IMGDATA wx_static_cast(wxImageRefData*, m_refData)
IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)
}
#endif // wxUSE_STREAMS
-wxImage::wxImage( const wxImage& image )
- : wxObject()
-{
- Ref(image);
-}
-
-wxImage::wxImage( const wxImage* image )
-{
- if (image) Ref(*image);
-}
-
wxImage::wxImage( const char** xpmData )
{
Create(xpmData);
UnRef();
}
-wxImage wxImage::Copy() const
+wxObjectRefData* wxImage::CreateRefData() const
{
- wxImage image;
-
- wxCHECK_MSG( Ok(), image, wxT("invalid image") );
+ return new wxImageRefData;
+}
- image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height, false );
+wxObjectRefData* wxImage::CloneRefData(const wxObjectRefData* that) const
+{
+ const wxImageRefData* refData = wx_static_cast(const wxImageRefData*, that);
+ wxCHECK_MSG(refData->m_ok, NULL, wxT("invalid image") );
- unsigned char *data = image.GetData();
+ wxImageRefData* refData_new = new wxImageRefData;
+ refData_new->m_width = refData->m_width;
+ refData_new->m_height = refData->m_height;
+ refData_new->m_maskRed = refData->m_maskRed;
+ refData_new->m_maskGreen = refData->m_maskGreen;
+ refData_new->m_maskBlue = refData->m_maskBlue;
+ refData_new->m_hasMask = refData->m_hasMask;
+ refData_new->m_ok = true;
+ unsigned size = unsigned(refData->m_width) * unsigned(refData->m_height);
+ if (refData->m_alpha != NULL)
+ {
+ refData_new->m_alpha = (unsigned char*)malloc(size);
+ memcpy(refData_new->m_alpha, refData->m_alpha, size);
+ }
+ size *= 3;
+ refData_new->m_data = (unsigned char*)malloc(size);
+ memcpy(refData_new->m_data, refData->m_data, size);
+#if wxUSE_PALETTE
+ refData_new->m_palette = refData->m_palette;
+#endif
+ refData_new->m_optionNames = refData->m_optionNames;
+ refData_new->m_optionValues = refData->m_optionValues;
+ return refData_new;
+}
- wxCHECK_MSG( data, image, wxT("unable to create image") );
+wxImage wxImage::Copy() const
+{
+ wxImage image;
- image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
- image.SetMask( M_IMGDATA->m_hasMask );
+ wxCHECK_MSG( Ok(), image, wxT("invalid image") );
- memcpy( data, GetData(), M_IMGDATA->m_width*M_IMGDATA->m_height*3 );
-
- wxImageRefData *imgData = (wxImageRefData *)image.m_refData;
-
- // also copy the alpha channel
- if (HasAlpha())
- {
- image.SetAlpha();
- unsigned char* alpha = image.GetAlpha();
- memcpy( alpha, GetAlpha(), M_IMGDATA->m_width*M_IMGDATA->m_height );
- }
-
- // also copy the image options
- imgData->m_optionNames = M_IMGDATA->m_optionNames;
- imgData->m_optionValues = M_IMGDATA->m_optionValues;
+ image.m_refData = CloneRefData(m_refData);
return image;
}
wxImage wxImage::ShrinkBy( int xFactor , int yFactor ) const
{
if( xFactor == 1 && yFactor == 1 )
- return Copy() ;
+ return *this;
wxImage image;
image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height, false );
unsigned char *data = image.GetData();
+ unsigned char *alpha = NULL;
wxCHECK_MSG( data, image, wxT("unable to create image") );
+ if (M_IMGDATA->m_alpha != NULL) {
+ image.SetAlpha();
+ alpha = image.GetAlpha();
+ wxCHECK_MSG( alpha, image, wxT("unable to create alpha channel") );
+ }
+
if (M_IMGDATA->m_hasMask)
image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
target_data -= 3;
}
}
+
+ if (alpha != NULL)
+ {
+ // src_alpha starts at the first pixel and increases by 1 after each step
+ // (a step here is the copy of the alpha value of one pixel)
+ const unsigned char *src_alpha = M_IMGDATA->m_alpha;
+ // dest_alpha starts just beyond the first line, decreases before each step,
+ // and after each line is finished, increases by 2 widths (skipping the line
+ // just copied and the line that will be copied next)
+ unsigned char *dest_alpha = alpha + width;
+
+ for (long jj = 0; jj < height; ++jj)
+ {
+ for (long i = 0; i < width; ++i) {
+ *(--dest_alpha) = *(src_alpha++); // copy one pixel
+ }
+ dest_alpha += 2 * width; // advance beyond the end of the next line
+ }
+ }
}
else
{
memcpy( target_data, source_data, (size_t)3*width );
source_data += 3*width;
}
+
+ if (alpha != NULL)
+ {
+ // src_alpha starts at the first pixel and increases by 1 width after each step
+ // (a step here is the copy of the alpha channel of an entire line)
+ const unsigned char *src_alpha = M_IMGDATA->m_alpha;
+ // dest_alpha starts just beyond the last line (beyond the whole image)
+ // and decreases by 1 width before each step
+ unsigned char *dest_alpha = alpha + width * height;
+
+ for (long jj = 0; jj < height; ++jj)
+ {
+ dest_alpha -= width;
+ memcpy( dest_alpha, src_alpha, (size_t)width );
+ src_alpha += width;
+ }
+ }
}
return image;
wxCHECK_MSG( Ok(), image, wxT("invalid image") );
- wxCHECK_MSG( (rect.GetLeft()>=0) && (rect.GetTop()>=0) && (rect.GetRight()<=GetWidth()) && (rect.GetBottom()<=GetHeight()),
+ 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();
+ const int subwidth = rect.GetWidth();
+ const int subheight = rect.GetHeight();
image.Create( subwidth, subheight, false );
- unsigned char *subdata = image.GetData(), *data=GetData();
+ const unsigned char *src_data = GetData();
+ const unsigned char *src_alpha = M_IMGDATA->m_alpha;
+ unsigned char *subdata = image.GetData();
+ unsigned char *subalpha = NULL;
wxCHECK_MSG( subdata, image, wxT("unable to create image") );
+ if (src_alpha != NULL) {
+ image.SetAlpha();
+ subalpha = image.GetAlpha();
+ wxCHECK_MSG( subalpha, image, wxT("unable to create alpha channel"));
+ }
+
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;
+ const int width = GetWidth();
+ const int pixsoff = rect.GetLeft() + width * rect.GetTop();
- data+=rect.GetTop()*width+subleft;
+ src_data += 3 * pixsoff;
+ src_alpha += pixsoff; // won't be used if was NULL, so this is ok
for (long j = 0; j < subheight; ++j)
{
- memcpy( subdata, data, subwidth);
- subdata+=subwidth;
- data+=width;
+ memcpy( subdata, src_data, 3 * subwidth );
+ subdata += 3 * subwidth;
+ src_data += 3 * width;
+ if (subalpha != NULL) {
+ memcpy( subalpha, src_alpha, subwidth );
+ subalpha += subwidth;
+ src_alpha += width;
+ }
}
return image;
wxRect subRect(pos.x, pos.y, width, height);
wxRect finalRect(0, 0, size.GetWidth(), size.GetHeight());
+ if (pos.x < 0)
+ finalRect.width -= pos.x;
+ if (pos.y < 0)
+ finalRect.height -= pos.y;
subRect.Intersect(finalRect);
wxCHECK_RET( Ok(), wxT("invalid image") );
wxCHECK_RET( image.Ok(), wxT("invalid image") );
+ AllocExclusive();
+
int xx = 0;
int yy = 0;
int width = image.GetWidth();
{
wxCHECK_RET( Ok(), wxT("invalid image") );
+ AllocExclusive();
+
unsigned char *data = GetData();
const int w = GetWidth();
}
}
+ // copy the alpha channel, if any
+ if (HasAlpha())
+ {
+ const size_t alphaSize = GetWidth() * GetHeight();
+ unsigned char *alpha = (unsigned char*)malloc(alphaSize);
+ memcpy(alpha, GetAlpha(), alphaSize);
+ image.InitAlpha();
+ image.SetAlpha(alpha);
+ }
+
return image;
}
long pos = XYToIndex(x, y);
wxCHECK_RET( pos != -1, wxT("invalid image coordinates") );
+ AllocExclusive();
+
pos *= 3;
M_IMGDATA->m_data[ pos ] = r;
{
wxCHECK_RET( Ok(), wxT("invalid image") );
+ AllocExclusive();
+
wxRect rect(rect_);
wxRect imageRect(0, 0, GetWidth(), GetHeight());
if ( rect == wxRect() )
long pos = XYToIndex(x, y);
wxCHECK_RET( pos != -1, wxT("invalid image coordinates") );
+ AllocExclusive();
+
M_IMGDATA->m_alpha[pos] = alpha;
}
{
wxCHECK_RET( Ok(), wxT("invalid image") );
+ AllocExclusive();
+
if ( !alpha )
{
alpha = (unsigned char *)malloc(M_IMGDATA->m_width*M_IMGDATA->m_height);
{
wxCHECK_RET( Ok(), wxT("invalid image") );
+ AllocExclusive();
+
M_IMGDATA->m_maskRed = r;
M_IMGDATA->m_maskGreen = g;
M_IMGDATA->m_maskBlue = b;
{
wxCHECK_RET( Ok(), wxT("invalid image") );
+ AllocExclusive();
+
M_IMGDATA->m_hasMask = mask;
}
return false ;
}
+ AllocExclusive();
+
unsigned char *imgdata = GetData();
unsigned char *maskdata = mask.GetData();
return false;
}
+ AllocExclusive();
+
SetMask(true);
SetMaskColour(mr, mg, mb);
{
wxCHECK_RET( Ok(), wxT("invalid image") );
+ AllocExclusive();
+
M_IMGDATA->m_palette = palette;
}
{
wxCHECK_RET( Ok(), wxT("invalid image") );
+ AllocExclusive();
+
int idx = M_IMGDATA->m_optionNames.Index(name, false);
if (idx == wxNOT_FOUND)
{
// image I/O
// ----------------------------------------------------------------------------
-bool wxImage::LoadFile( const wxString& filename, long type, int index )
+bool wxImage::LoadFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename),
+ long WXUNUSED_UNLESS_STREAMS(type),
+ int WXUNUSED_UNLESS_STREAMS(index) )
{
#if wxUSE_STREAMS
if (wxFileExists(filename))
#endif // wxUSE_STREAMS
}
-bool wxImage::LoadFile( const wxString& filename, const wxString& mimetype, int index )
+bool wxImage::LoadFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename),
+ const wxString& WXUNUSED_UNLESS_STREAMS(mimetype),
+ int WXUNUSED_UNLESS_STREAMS(index) )
{
#if wxUSE_STREAMS
if (wxFileExists(filename))
return false;
}
-bool wxImage::SaveFile( const wxString& filename, int type ) const
+bool wxImage::SaveFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename),
+ int WXUNUSED_UNLESS_STREAMS(type) ) const
{
#if wxUSE_STREAMS
wxCHECK_MSG( Ok(), false, wxT("invalid image") );
return false;
}
-bool wxImage::SaveFile( const wxString& filename, const wxString& mimetype ) const
+bool wxImage::SaveFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename),
+ const wxString& WXUNUSED_UNLESS_STREAMS(mimetype) ) const
{
#if wxUSE_STREAMS
wxCHECK_MSG( Ok(), false, wxT("invalid image") );
return false;
}
-bool wxImage::CanRead( const wxString &name )
+bool wxImage::CanRead( const wxString& WXUNUSED_UNLESS_STREAMS(name) )
{
#if wxUSE_STREAMS
- wxFileInputStream stream(name);
- return CanRead(stream);
+ wxFileInputStream stream(name);
+ return CanRead(stream);
#else
- return false;
+ return false;
#endif
}
-int wxImage::GetImageCount( const wxString &name, long type )
+int wxImage::GetImageCount( const wxString& WXUNUSED_UNLESS_STREAMS(name),
+ long WXUNUSED_UNLESS_STREAMS(type) )
{
#if wxUSE_STREAMS
- wxFileInputStream stream(name);
- if (stream.Ok())
- return GetImageCount(stream, type);
+ wxFileInputStream stream(name);
+ if (stream.Ok())
+ return GetImageCount(stream, type);
#endif
return 0;
*/
void wxImage::RotateHue(double angle)
{
+ AllocExclusive();
+
unsigned char *srcBytePtr;
unsigned char *dstBytePtr;
unsigned long count;
projects / wxWidgets.git / blobdiff