#define HAS_FILE_STREAMS (wxUSE_STREAMS && (wxUSE_FILE || wxUSE_FFILE))
#if HAS_FILE_STREAMS
- #if wxUSE_FILE
- typedef wxFileInputStream wxImageFileInputStream;
- typedef wxFileOutputStream wxImageFileOutputStream;
- #elif wxUSE_FFILE
+ #if wxUSE_FFILE
typedef wxFFileInputStream wxImageFileInputStream;
typedef wxFFileOutputStream wxImageFileOutputStream;
+ #elif wxUSE_FILE
+ typedef wxFileInputStream wxImageFileInputStream;
+ typedef wxFileOutputStream wxImageFileOutputStream;
#endif // wxUSE_FILE/wxUSE_FFILE
#endif // HAS_FILE_STREAMS
int m_width;
int m_height;
+ wxBitmapType m_type;
unsigned char *m_data;
bool m_hasMask;
{
m_width = 0;
m_height = 0;
+ m_type = wxBITMAP_TYPE_INVALID;
m_data =
m_alpha = (unsigned char *) NULL;
//-----------------------------------------------------------------------------
-#define M_IMGDATA wx_static_cast(wxImageRefData*, m_refData)
+#define M_IMGDATA static_cast<wxImageRefData*>(m_refData)
IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)
Create( width, height, data, alpha, static_data );
}
-wxImage::wxImage( const wxString& name, long type, int index )
+wxImage::wxImage( const wxString& name, wxBitmapType type, int index )
{
LoadFile( name, type, index );
}
}
#if wxUSE_STREAMS
-wxImage::wxImage( wxInputStream& stream, long type, int index )
+wxImage::wxImage( wxInputStream& stream, wxBitmapType type, int index )
{
LoadFile( stream, type, index );
}
return false;
}
- if (clear)
- memset(M_IMGDATA->m_data, 0, width*height*3);
-
M_IMGDATA->m_width = width;
M_IMGDATA->m_height = height;
M_IMGDATA->m_ok = true;
+ if (clear)
+ {
+ Clear();
+ }
+
return true;
}
M_IMGDATA->m_height = height;
M_IMGDATA->m_ok = true;
M_IMGDATA->m_static = static_data;
+ M_IMGDATA->m_staticAlpha = static_data;
return true;
}
UnRef();
}
+void wxImage::Clear(unsigned char value)
+{
+ memset(M_IMGDATA->m_data, value, M_IMGDATA->m_width*M_IMGDATA->m_height*3);
+}
+
wxObjectRefData* wxImage::CreateRefData() const
{
return new wxImageRefData;
wxObjectRefData* wxImage::CloneRefData(const wxObjectRefData* that) const
{
- const wxImageRefData* refData = wx_static_cast(const wxImageRefData*, that);
+ const wxImageRefData* refData = static_cast<const wxImageRefData*>(that);
wxCHECK_MSG(refData->m_ok, NULL, wxT("invalid image") );
wxImageRefData* refData_new = new wxImageRefData;
const int scale_factor_x_2 = (int)(scale_factor_x / 2);
const int scale_factor_y_2 = (int)(scale_factor_y / 2);
- // If we want good-looking results we need to pre-blur the image a bit first
- wxImage src_image(*this);
- src_image = src_image.BlurHorizontal(scale_factor_x_2);
- src_image = src_image.BlurVertical(scale_factor_y_2);
-
- unsigned char* src_data = src_image.GetData();
- unsigned char* src_alpha = src_image.GetAlpha();
+ unsigned char* src_data = M_IMGDATA->m_data;
+ unsigned char* src_alpha = M_IMGDATA->m_alpha;
unsigned char* dst_data = ret_image.GetData();
unsigned char* dst_alpha = NULL;
j++ )
{
// We don't care to average pixels that don't exist (edges)
- if ( j < 0 || j > M_IMGDATA->m_height )
+ if ( j < 0 || j > M_IMGDATA->m_height - 1 )
continue;
for ( int i = int(src_x - scale_factor_x/2.0 + 1);
i++ )
{
// Don't average edge pixels
- if ( i < 0 || i > M_IMGDATA->m_width )
+ if ( i < 0 || i > M_IMGDATA->m_width - 1 )
continue;
// Calculate the actual index in our source pixels
- src_pixel_index = src_y * M_IMGDATA->m_width + src_x;
+ src_pixel_index = j * M_IMGDATA->m_width + i;
sum_r += src_data[src_pixel_index * 3 + 0];
sum_g += src_data[src_pixel_index * 3 + 1];
for ( int dsty = 0; dsty < height; dsty++ )
{
// We need to calculate the source pixel to interpolate from - Y-axis
- double srcpixy = dsty * M_IMGDATA->m_height / height;
+ double srcpixy = double(dsty * M_IMGDATA->m_height) / height;
double dy = srcpixy - (int)srcpixy;
for ( int dstx = 0; dstx < width; dstx++ )
{
// X-axis of pixel to interpolate from
- double srcpixx = dstx * M_IMGDATA->m_width / width;
+ double srcpixx = double(dstx * M_IMGDATA->m_width) / width;
double dx = srcpixx - (int)srcpixx;
// Sums for each color channel
}
// Blur in the horizontal direction
-wxImage wxImage::BlurHorizontal(int blurRadius)
+wxImage wxImage::BlurHorizontal(int blurRadius) const
{
wxImage ret_image;
ret_image.Create(M_IMGDATA->m_width, M_IMGDATA->m_height, false);
}
// Blur in the vertical direction
-wxImage wxImage::BlurVertical(int blurRadius)
+wxImage wxImage::BlurVertical(int blurRadius) const
{
wxImage ret_image;
ret_image.Create(M_IMGDATA->m_width, M_IMGDATA->m_height, false);
}
// The new blur function
-wxImage wxImage::Blur(int blurRadius)
+wxImage wxImage::Blur(int blurRadius) const
{
wxImage ret_image;
ret_image.Create(M_IMGDATA->m_width, M_IMGDATA->m_height, false);
(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;
int target_step = M_IMGDATA->m_width*3;
for (int j = 0; j < height; j++)
{
- memcpy( target_data, source_data, width );
+ memcpy( target_data, source_data, width*3 );
source_data += source_step;
target_data += target_step;
}
- return;
+ }
+
+ // Copy over the alpha channel from the original image
+ if ( image.HasAlpha() )
+ {
+ if ( !HasAlpha() )
+ InitAlpha();
+
+ unsigned char* source_data = image.GetAlpha() + xx + yy*image.GetWidth();
+ int source_step = image.GetWidth();
+
+ unsigned char* target_data = GetAlpha() + (x+xx) + (y+yy)*M_IMGDATA->m_width;
+ int target_step = M_IMGDATA->m_width;
+
+ for (int j = 0; j < height; j++,
+ source_data += source_step,
+ target_data += target_step)
+ {
+ memcpy( target_data, source_data, width );
+ }
}
if (!HasMask() && image.HasMask())
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;
for (int j = 0; j < height; j++)
{
- for (int i = 0; i < width; i+=3)
+ for (int i = 0; i < width*3; i+=3)
{
if ((source_data[i] != r) ||
(source_data[i+1] != g) ||
{
// calculate the luma
double luma = (src[0] * lr + src[1] * lg + src[2] * lb) + 0.5;
- dest[0] = dest[1] = dest[2] = wx_static_cast(unsigned char, luma);
+ dest[0] = dest[1] = dest[2] = static_cast<unsigned char>(luma);
}
}
return M_IMGDATA->m_height;
}
+wxBitmapType wxImage::GetType() const
+{
+ wxCHECK_MSG( IsOk(), wxBITMAP_TYPE_INVALID, wxT("invalid image") );
+
+ return M_IMGDATA->m_type;
+}
+
+void wxImage::SetType(wxBitmapType type)
+{
+ wxCHECK_RET( IsOk(), "must create the image before setting its type");
+
+ // type can be wxBITMAP_TYPE_INVALID to reset the image type to default
+ wxASSERT_MSG( type != wxBITMAP_TYPE_MAX, "invalid bitmap type" );
+
+ M_IMGDATA->m_type = type;
+}
+
long wxImage::XYToIndex(int x, int y) const
{
if ( Ok() &&
alpha = (unsigned char *)malloc(M_IMGDATA->m_width*M_IMGDATA->m_height);
}
- free(M_IMGDATA->m_alpha);
+ if( !M_IMGDATA->m_staticAlpha )
+ free(M_IMGDATA->m_alpha);
+
M_IMGDATA->m_alpha = alpha;
M_IMGDATA->m_staticAlpha = static_data;
}
bool wxImage::ConvertAlphaToMask(unsigned char threshold)
{
- if (!HasAlpha())
+ if ( !HasAlpha() )
return true;
unsigned char mr, mg, mb;
- if (!FindFirstUnusedColour(&mr, &mg, &mb))
+ if ( !FindFirstUnusedColour(&mr, &mg, &mb) )
{
wxLogError( _("No unused colour in image being masked.") );
return false;
}
+ ConvertAlphaToMask(mr, mg, mb, threshold);
+ return true;
+}
+
+void wxImage::ConvertAlphaToMask(unsigned char mr,
+ unsigned char mg,
+ unsigned char mb,
+ unsigned char threshold)
+{
+ if ( !HasAlpha() )
+ return;
+
AllocExclusive();
SetMask(true);
}
}
- free(M_IMGDATA->m_alpha);
- M_IMGDATA->m_alpha = NULL;
+ if ( !M_IMGDATA->m_staticAlpha )
+ free(M_IMGDATA->m_alpha);
- return true;
+ M_IMGDATA->m_alpha = NULL;
+ M_IMGDATA->m_staticAlpha = false;
}
// ----------------------------------------------------------------------------
void wxImage::SetOption(const wxString& name, const wxString& value)
{
- wxCHECK_RET( Ok(), wxT("invalid image") );
-
AllocExclusive();
int idx = M_IMGDATA->m_optionNames.Index(name, false);
- if (idx == wxNOT_FOUND)
+ if ( idx == wxNOT_FOUND )
{
M_IMGDATA->m_optionNames.Add(name);
M_IMGDATA->m_optionValues.Add(value);
wxString wxImage::GetOption(const wxString& name) const
{
- wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid image") );
+ if ( !M_IMGDATA )
+ return wxEmptyString;
int idx = M_IMGDATA->m_optionNames.Index(name, false);
- if (idx == wxNOT_FOUND)
+ if ( idx == wxNOT_FOUND )
return wxEmptyString;
else
return M_IMGDATA->m_optionValues[idx];
bool wxImage::HasOption(const wxString& name) const
{
- wxCHECK_MSG( Ok(), false, wxT("invalid image") );
-
- return (M_IMGDATA->m_optionNames.Index(name, false) != wxNOT_FOUND);
+ return M_IMGDATA ? M_IMGDATA->m_optionNames.Index(name, false) != wxNOT_FOUND
+ : false;
}
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
bool wxImage::LoadFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename),
- long WXUNUSED_UNLESS_STREAMS(type),
+ wxBitmapType WXUNUSED_UNLESS_STREAMS(type),
int WXUNUSED_UNLESS_STREAMS(index) )
{
#if HAS_FILE_STREAMS
}
-
bool wxImage::SaveFile( const wxString& filename ) const
{
wxString ext = filename.AfterLast('.').Lower();
- wxImageHandler * pHandler = FindHandler(ext, -1);
- if (pHandler)
+ wxImageHandler *handler = FindHandler(ext, wxBITMAP_TYPE_ANY);
+ if ( !handler)
{
- SaveFile(filename, pHandler->GetType());
- return true;
+ wxLogError(_("Can't save image to file '%s': unknown extension."),
+ filename);
+ return false;
}
- wxLogError(_("Can't save image to file '%s': unknown extension."), filename.c_str());
-
- return false;
+ return SaveFile(filename, handler->GetType());
}
bool wxImage::SaveFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename),
- int WXUNUSED_UNLESS_STREAMS(type) ) const
+ wxBitmapType WXUNUSED_UNLESS_STREAMS(type) ) const
{
#if HAS_FILE_STREAMS
wxCHECK_MSG( Ok(), false, wxT("invalid image") );
}
int wxImage::GetImageCount( const wxString& WXUNUSED_UNLESS_STREAMS(name),
- long WXUNUSED_UNLESS_STREAMS(type) )
+ wxBitmapType WXUNUSED_UNLESS_STREAMS(type) )
{
#if HAS_FILE_STREAMS
wxImageFileInputStream stream(name);
return false;
}
-int wxImage::GetImageCount( wxInputStream &stream, long type )
+int wxImage::GetImageCount( wxInputStream &stream, wxBitmapType type )
{
wxImageHandler *handler;
if ( type == wxBITMAP_TYPE_ANY )
{
- wxList &list=GetHandlers();
+ const wxList& list = GetHandlers();
- for (wxList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext())
+ for ( wxList::compatibility_iterator node = list.GetFirst();
+ node;
+ node = node->GetNext() )
{
- handler=(wxImageHandler*)node->GetData();
+ handler = (wxImageHandler*)node->GetData();
if ( handler->CanRead(stream) )
- return handler->GetImageCount(stream);
+ {
+ const int count = handler->GetImageCount(stream);
+ if ( count >= 0 )
+ return count;
+ }
}
}
}
-bool wxImage::LoadFile( wxInputStream& stream, long type, int index )
+bool wxImage::DoLoad(wxImageHandler& handler, wxInputStream& stream, int index)
{
- UnRef();
+ // save the options values which can be clobbered by the handler (e.g. many
+ // of them call Destroy() before trying to load the file)
+ const unsigned maxWidth = GetOptionInt(wxIMAGE_OPTION_MAX_WIDTH),
+ maxHeight = GetOptionInt(wxIMAGE_OPTION_MAX_HEIGHT);
- m_refData = new wxImageRefData;
+ if ( !handler.LoadFile(this, stream, true/*verbose*/, index) )
+ return false;
- wxImageHandler *handler;
+ M_IMGDATA->m_type = handler.GetType();
- if ( type == wxBITMAP_TYPE_ANY )
+ // rescale the image to the specified size if needed
+ if ( maxWidth || maxHeight )
{
- wxList &list=GetHandlers();
+ const unsigned widthOrig = GetWidth(),
+ heightOrig = GetHeight();
- for ( wxList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext() )
+ // this uses the same (trivial) algorithm as the JPEG handler
+ unsigned width = widthOrig,
+ height = heightOrig;
+ while ( (maxWidth && width > maxWidth) ||
+ (maxHeight && height > maxHeight) )
{
- handler=(wxImageHandler*)node->GetData();
- if ( handler->CanRead(stream) )
- return handler->LoadFile(this, stream, true/*verbose*/, index);
+ width /= 2;
+ height /= 2;
+ }
+
+ if ( width != widthOrig || height != heightOrig )
+ Rescale(width, height, wxIMAGE_QUALITY_HIGH);
+ }
+
+ return true;
+}
+bool wxImage::LoadFile( wxInputStream& stream, wxBitmapType type, int index )
+{
+ AllocExclusive();
+
+ wxImageHandler *handler;
+
+ if ( type == wxBITMAP_TYPE_ANY )
+ {
+ const wxList& list = GetHandlers();
+ for ( wxList::compatibility_iterator node = list.GetFirst();
+ node;
+ node = node->GetNext() )
+ {
+ handler = (wxImageHandler*)node->GetData();
+ if ( handler->CanRead(stream) && DoLoad(*handler, stream, index) )
+ return true;
}
wxLogWarning( _("No handler found for image type.") );
+
return false;
}
+ //else: have specific type
handler = FindHandler(type);
-
- if (handler == 0)
+ if ( !handler )
{
wxLogWarning( _("No image handler for type %ld defined."), type );
-
return false;
}
- if (stream.IsSeekable() && !handler->CanRead(stream))
+ if ( stream.IsSeekable() && !handler->CanRead(stream) )
{
wxLogError(_("Image file is not of type %ld."), type);
return false;
}
- else
- return handler->LoadFile(this, stream, true/*verbose*/, index);
+
+ return DoLoad(*handler, stream, index);
}
bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype, int index )
wxImageHandler *handler = FindHandlerMime(mimetype);
- if (handler == 0)
+ if ( !handler )
{
wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
-
return false;
}
- if (stream.IsSeekable() && !handler->CanRead(stream))
+ if ( stream.IsSeekable() && !handler->CanRead(stream) )
{
- wxLogError(_("Image file is not of type %s."), (const wxChar*) mimetype);
+ wxLogError(_("Image file is not of type %s."), mimetype);
return false;
}
- else
- return handler->LoadFile( this, stream, true/*verbose*/, index );
+
+ return DoLoad(*handler, stream, index);
}
-bool wxImage::SaveFile( wxOutputStream& stream, int type ) const
+bool wxImage::DoSave(wxImageHandler& handler, wxOutputStream& stream) const
+{
+ wxImage * const self = const_cast<wxImage *>(this);
+ if ( !handler.SaveFile(self, stream) )
+ return false;
+
+ M_IMGDATA->m_type = handler.GetType();
+ return true;
+}
+
+bool wxImage::SaveFile( wxOutputStream& stream, wxBitmapType type ) const
{
wxCHECK_MSG( Ok(), false, wxT("invalid image") );
if ( !handler )
{
wxLogWarning( _("No image handler for type %d defined."), type );
-
return false;
}
- return handler->SaveFile( (wxImage*)this, stream );
+ return DoSave(*handler, stream);
}
bool wxImage::SaveFile( wxOutputStream& stream, const wxString& mimetype ) const
if ( !handler )
{
wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
-
- return false;
}
- return handler->SaveFile( (wxImage*)this, stream );
+ return DoSave(*handler, stream);
}
+
#endif // wxUSE_STREAMS
// ----------------------------------------------------------------------------
node = node->GetNext();
}
- return 0;
+ return NULL;
}
-wxImageHandler *wxImage::FindHandler( const wxString& extension, long bitmapType )
+wxImageHandler *wxImage::FindHandler( const wxString& extension, wxBitmapType bitmapType )
{
wxList::compatibility_iterator node = sm_handlers.GetFirst();
while (node)
{
wxImageHandler *handler = (wxImageHandler*)node->GetData();
if ( (handler->GetExtension().Cmp(extension) == 0) &&
- (bitmapType == -1 || handler->GetType() == bitmapType) )
+ ( (bitmapType == wxBITMAP_TYPE_ANY) || (handler->GetType() == bitmapType)) )
+ {
return handler;
+ }
node = node->GetNext();
}
- return 0;
+ return NULL;
}
-wxImageHandler *wxImage::FindHandler( long bitmapType )
+wxImageHandler *wxImage::FindHandler(wxBitmapType bitmapType )
{
wxList::compatibility_iterator node = sm_handlers.GetFirst();
while (node)
if (handler->GetType() == bitmapType) return handler;
node = node->GetNext();
}
- return 0;
+ return NULL;
}
wxImageHandler *wxImage::FindHandlerMime( const wxString& mimetype )
if (handler->GetMimeType().IsSameAs(mimetype, false)) return handler;
node = node->GetNext();
}
- return 0;
+ return NULL;
}
void wxImage::InitStandardHandlers()
projects / wxWidgets.git / blobdiff