#endif
//-----------------------------------------------------------------------------
-// wxImage
+// global data
+//-----------------------------------------------------------------------------
+
+wxList wxImage::sm_handlers;
+wxImage wxNullImage;
+
+//-----------------------------------------------------------------------------
+// wxImageRefData
//-----------------------------------------------------------------------------
class wxImageRefData: public wxObjectRefData
int m_width;
int m_height;
+ wxBitmapType m_type;
unsigned char *m_data;
bool m_hasMask;
wxArrayString m_optionNames;
wxArrayString m_optionValues;
- DECLARE_NO_COPY_CLASS(wxImageRefData)
+ wxDECLARE_NO_COPY_CLASS(wxImageRefData);
};
wxImageRefData::wxImageRefData()
{
m_width = 0;
m_height = 0;
+ m_type = wxBITMAP_TYPE_INVALID;
m_data =
m_alpha = (unsigned char *) NULL;
free( m_alpha );
}
-wxList wxImage::sm_handlers;
-
-wxImage wxNullImage;
+//-----------------------------------------------------------------------------
+// wxImage
//-----------------------------------------------------------------------------
-#define M_IMGDATA wx_static_cast(wxImageRefData*, m_refData)
+#define M_IMGDATA static_cast<wxImageRefData*>(m_refData)
IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)
-wxImage::wxImage( int width, int height, bool clear )
-{
- Create( width, height, clear );
-}
-
-wxImage::wxImage( int width, int height, unsigned char* data, bool static_data )
-{
- Create( width, height, data, static_data );
-}
-
-wxImage::wxImage( int width, int height, unsigned char* data, unsigned char* alpha, bool static_data )
-{
- Create( width, height, data, alpha, static_data );
-}
-
-wxImage::wxImage( const wxString& name, long type, int index )
-{
- LoadFile( name, type, index );
-}
-
-wxImage::wxImage( const wxString& name, const wxString& mimetype, int index )
-{
- LoadFile( name, mimetype, index );
-}
-
-#if wxUSE_STREAMS
-wxImage::wxImage( wxInputStream& stream, long type, int index )
-{
- LoadFile( stream, type, index );
-}
-
-wxImage::wxImage( wxInputStream& stream, const wxString& mimetype, int index )
-{
- LoadFile( stream, mimetype, index );
-}
-#endif // wxUSE_STREAMS
-
-wxImage::wxImage(const char* const* xpmData)
-{
- Create(xpmData);
-}
-
bool wxImage::Create(const char* const* xpmData)
{
#if wxUSE_XPM
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;
}
{
UnRef();
- wxCHECK_MSG( data, false, _T("NULL data in wxImage::Create") );
+ wxCHECK_MSG( data, false, wxT("NULL data in wxImage::Create") );
m_refData = new wxImageRefData();
{
UnRef();
- wxCHECK_MSG( data, false, _T("NULL data in wxImage::Create") );
+ wxCHECK_MSG( data, false, wxT("NULL data in wxImage::Create") );
m_refData = new wxImageRefData();
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];
(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() &&
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);
}
}
- if( !M_IMGDATA->m_staticAlpha )
+ if ( !M_IMGDATA->m_staticAlpha )
free(M_IMGDATA->m_alpha);
M_IMGDATA->m_alpha = NULL;
M_IMGDATA->m_staticAlpha = false;
-
- return true;
}
// ----------------------------------------------------------------------------
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."), 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
// ----------------------------------------------------------------------------
// may) we should probably refcount the duplicates.
// also an issue in InsertHandler below.
- wxLogDebug( _T("Adding duplicate image handler for '%s'"),
+ wxLogDebug( wxT("Adding duplicate image handler for '%s'"),
handler->GetName().c_str() );
delete handler;
}
else
{
// see AddHandler for additional comments.
- wxLogDebug( _T("Inserting duplicate image handler for '%s'"),
+ wxLogDebug( wxT("Inserting duplicate image handler for '%s'"),
handler->GetName().c_str() );
delete handler;
}
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) )
- return handler;
+ if ((bitmapType == wxBITMAP_TYPE_ANY) || (handler->GetType() == bitmapType))
+ {
+ if (handler->GetExtension() == extension)
+ return handler;
+ if (handler->GetAltExtensions().Index(extension, false) != wxNOT_FOUND)
+ return handler;
+ }
node = node->GetNext();
}
return NULL;
}
-wxImageHandler *wxImage::FindHandler( long bitmapType )
+wxImageHandler *wxImage::FindHandler(wxBitmapType bitmapType )
{
wxList::compatibility_iterator node = sm_handlers.GetFirst();
while (node)
{
wxImageHandler* Handler = (wxImageHandler*)Node->GetData();
fmts += wxT("*.") + Handler->GetExtension();
+ for (size_t i = 0; i < Handler->GetAltExtensions().size(); i++)
+ fmts += wxT(";*.") + Handler->GetAltExtensions()[i];
Node = Node->GetNext();
if ( Node ) fmts += wxT(";");
}
IMPLEMENT_ABSTRACT_CLASS(wxImageHandler,wxObject)
#if wxUSE_STREAMS
-bool wxImageHandler::LoadFile( wxImage *WXUNUSED(image), wxInputStream& WXUNUSED(stream), bool WXUNUSED(verbose), int WXUNUSED(index) )
+int wxImageHandler::GetImageCount( wxInputStream& stream )
{
- return false;
-}
+ // NOTE: this code is the same of wxAnimationDecoder::CanRead and
+ // wxImageHandler::CallDoCanRead
-bool wxImageHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream), bool WXUNUSED(verbose) )
-{
- return false;
-}
+ if ( !stream.IsSeekable() )
+ return false; // can't test unseekable stream
-int wxImageHandler::GetImageCount( wxInputStream& WXUNUSED(stream) )
-{
- return 1;
+ wxFileOffset posOld = stream.TellI();
+ int n = DoGetImageCount(stream);
+
+ // restore the old position to be able to test other formats and so on
+ if ( stream.SeekI(posOld) == wxInvalidOffset )
+ {
+ wxLogDebug(wxT("Failed to rewind the stream in wxImageHandler!"));
+
+ // reading would fail anyhow as we're not at the right position
+ return false;
+ }
+
+ return n;
}
bool wxImageHandler::CanRead( const wxString& name )
bool wxImageHandler::CallDoCanRead(wxInputStream& stream)
{
- wxFileOffset posOld = stream.TellI();
- if ( posOld == wxInvalidOffset )
- {
- // can't test unseekable stream
- return false;
- }
+ // NOTE: this code is the same of wxAnimationDecoder::CanRead and
+ // wxImageHandler::GetImageCount
+
+ if ( !stream.IsSeekable() )
+ return false; // can't test unseekable stream
+ wxFileOffset posOld = stream.TellI();
bool ok = DoCanRead(stream);
// restore the old position to be able to test other formats and so on
if ( stream.SeekI(posOld) == wxInvalidOffset )
{
- wxLogDebug(_T("Failed to rewind the stream in wxImageHandler!"));
+ wxLogDebug(wxT("Failed to rewind the stream in wxImageHandler!"));
// reading would fail anyhow as we're not at the right position
return false;
wxImageResolution
wxImageHandler::GetResolutionFromOptions(const wxImage& image, int *x, int *y)
{
- wxCHECK_MSG( x && y, wxIMAGE_RESOLUTION_NONE, _T("NULL pointer") );
+ wxCHECK_MSG( x && y, wxIMAGE_RESOLUTION_NONE, wxT("NULL pointer") );
if ( image.HasOption(wxIMAGE_OPTION_RESOLUTIONX) &&
image.HasOption(wxIMAGE_OPTION_RESOLUTIONY) )
projects / wxWidgets.git / blobdiff