#pragma hdrstop
#endif
-#if wxUSE_STREAMS && wxUSE_GIF
+#if wxUSE_STREAMS && wxUSE_ICO_CUR
+
+#include "wx/anidecod.h"
#ifndef WX_PRECOMP
#include "wx/palette.h"
#include <stdlib.h>
#include <string.h>
-#include "wx/anidecod.h"
// static
wxCURHandler wxANIDecoder::sm_handler;
-
-
//---------------------------------------------------------------------------
// wxANIFrameInfo
//---------------------------------------------------------------------------
class wxANIFrameInfo
{
public:
- wxANIFrameInfo(size_t delay = 0, int idx = -1)
+ wxANIFrameInfo(unsigned int delay = 0, int idx = -1)
{ m_delay=delay; m_imageIndex=idx; }
- size_t m_delay;
+ unsigned int m_delay;
int m_imageIndex;
};
-#include <wx/arrimpl.cpp> // this is a magic incantation which must be done!
-WX_DEFINE_OBJARRAY(wxImageArray);
-
-#include <wx/arrimpl.cpp> // this is a magic incantation which must be done!
-WX_DEFINE_OBJARRAY(wxANIFrameInfoArray);
-
+#include "wx/arrimpl.cpp" // this is a magic incantation which must be done!
+WX_DEFINE_OBJARRAY(wxImageArray)
+#include "wx/arrimpl.cpp" // this is a magic incantation which must be done!
+WX_DEFINE_OBJARRAY(wxANIFrameInfoArray)
//---------------------------------------------------------------------------
{
}
-bool wxANIDecoder::ConvertToImage(size_t frame, wxImage *image) const
+bool wxANIDecoder::ConvertToImage(unsigned int frame, wxImage *image) const
{
- size_t idx = m_info[frame].m_imageIndex;
+ unsigned int idx = m_info[frame].m_imageIndex;
*image = m_images[idx]; // copy
return image->IsOk();
}
// Data accessors
//---------------------------------------------------------------------------
-wxSize wxANIDecoder::GetFrameSize(size_t WXUNUSED(frame)) const
+wxSize wxANIDecoder::GetFrameSize(unsigned int WXUNUSED(frame)) const
{
// all frames are of the same size...
return m_szAnimation;
}
-wxPoint wxANIDecoder::GetFramePosition(size_t WXUNUSED(frame)) const
+wxPoint wxANIDecoder::GetFramePosition(unsigned int WXUNUSED(frame)) const
{
// all frames are of the same size...
return wxPoint(0,0);
}
-wxAnimationDisposal wxANIDecoder::GetDisposalMethod(size_t WXUNUSED(frame)) const
+wxAnimationDisposal wxANIDecoder::GetDisposalMethod(unsigned int WXUNUSED(frame)) const
{
// this disposal is implicit for all frames inside an ANI file
return wxANIM_TOBACKGROUND;
}
-long wxANIDecoder::GetDelay(size_t frame) const
+long wxANIDecoder::GetDelay(unsigned int frame) const
{
return m_info[frame].m_delay;
}
+wxColour wxANIDecoder::GetTransparentColour(unsigned int frame) const
+{
+ unsigned int idx = m_info[frame].m_imageIndex;
+
+ if (!m_images[idx].HasMask())
+ return wxNullColour;
+
+ return wxColour(m_images[idx].GetMaskRed(),
+ m_images[idx].GetMaskGreen(),
+ m_images[idx].GetMaskBlue());
+}
+
//---------------------------------------------------------------------------
// ANI reading and decoding
//---------------------------------------------------------------------------
-bool wxANIDecoder::CanRead(wxInputStream& stream) const
+bool wxANIDecoder::DoCanRead(wxInputStream& stream) const
{
wxInt32 FCC1, FCC2;
- wxUint32 datalen ;
+ wxUint32 datalen;
wxInt32 riff32;
memcpy( &riff32, "RIFF", 4 );
wxInt32 anih32;
memcpy( &anih32, "anih", 4 );
- stream.SeekI(0);
+ if ( stream.IsSeekable() && stream.SeekI(0) == wxInvalidOffset )
+ {
+ return false;
+ }
+
if ( !stream.Read(&FCC1, 4) )
return false;
}
else
{
- stream.SeekI(stream.TellI() + datalen);
+ if ( stream.SeekI(stream.TellI() + datalen) == wxInvalidOffset )
+ return false;
}
// try to read next data chunk:
wxInt32 cPlanes; // 1
wxInt32 JifRate; // Default Jiffies (1/60th of a second) if rate chunk not present.
wxInt32 flags; // Animation Flag (see AF_ constants)
+
+ // ANI files are always little endian so we need to swap bytes on big
+ // endian architectures
+#ifdef WORDS_BIGENDIAN
+ void AdjustEndianness()
+ {
+ // this works because all our fields are wxInt32 and they must be
+ // packed without holes between them (if they're not, they wouldn't map
+ // to the file header!)
+ wxInt32 * const start = (wxInt32 *)this;
+ wxInt32 * const end = start + sizeof(wxANIHeader)/sizeof(wxInt32);
+ for ( wxInt32 *p = start; p != end; p++ )
+ {
+ *p = wxINT32_SWAP_ALWAYS(*p);
+ }
+ }
+#else
+ void AdjustEndianness() { }
+#endif
};
bool wxANIDecoder::Load( wxInputStream& stream )
{
wxInt32 FCC1, FCC2;
wxUint32 datalen;
- size_t globaldelay=0;
+ unsigned int globaldelay=0;
wxInt32 riff32;
memcpy( &riff32, "RIFF", 4 );
wxInt32 seq32;
memcpy( &seq32, "seq ", 4 );
- stream.SeekI(0);
- stream.Read(&FCC1, 4);
+ if ( stream.IsSeekable() && stream.SeekI(0) == wxInvalidOffset )
+ {
+ return false;
+ }
+
+ if ( !stream.Read(&FCC1, 4) )
+ return false;
if ( FCC1 != riff32 )
return false;
m_info.Clear();
// we have a riff file:
- while ( stream.IsOk() )
+ while ( !stream.Eof() )
{
// we always have a data size:
- stream.Read(&datalen, 4);
+ if (!stream.Read(&datalen, 4))
+ return false;
+
datalen = wxINT32_SWAP_ON_BE(datalen);
//data should be padded to make even number of bytes
// now either data or a FCC:
if ( (FCC1 == riff32) || (FCC1 == list32) )
{
- stream.Read(&FCC2, 4);
+ if (!stream.Read(&FCC2, 4))
+ return false;
}
else if ( FCC1 == anih32 )
{
return false; // already parsed an ani header?
struct wxANIHeader header;
- stream.Read(&header, sizeof(wxANIHeader));
+ if (!stream.Read(&header, sizeof(wxANIHeader)))
+ return false;
+ header.AdjustEndianness();
// we should have a global frame size
m_szAnimation = wxSize(header.cx, header.cy);
if ( m_nFrames == 0 )
return false;
- globaldelay = wxINT32_SWAP_ON_BE(header.JifRate) * 1000 / 60;
+ globaldelay = header.JifRate * 1000 / 60;
m_images.Alloc(header.cFrames);
m_info.Add(wxANIFrameInfo(), m_nFrames);
return false; // rate chunks should always be placed after anih chunk
wxASSERT(m_info.GetCount() == m_nFrames);
- for (size_t i=0; i<m_nFrames; i++)
+ for (unsigned int i=0; i<m_nFrames; i++)
{
- stream.Read(&FCC2, 4);
+ if (!stream.Read(&FCC2, 4))
+ return false;
m_info[i].m_delay = wxINT32_SWAP_ON_BE(FCC2) * 1000 / 60;
}
}
return false; // seq chunks should always be placed after anih chunk
wxASSERT(m_info.GetCount() == m_nFrames);
- for (size_t i=0; i<m_nFrames; i++)
+ for (unsigned int i=0; i<m_nFrames; i++)
{
- stream.Read(&FCC2, 4);
+ if (!stream.Read(&FCC2, 4))
+ return false;
m_info[i].m_imageIndex = wxINT32_SWAP_ON_BE(FCC2);
}
}
if (!sm_handler.DoLoadFile(&image, stream, false /* verbose */, -1))
return false;
+ image.SetType(wxBITMAP_TYPE_ANI);
m_images.Add(image);
}
else
- stream.SeekI(stream.TellI() + datalen);
+ {
+ if ( stream.SeekI(stream.TellI() + datalen) == wxInvalidOffset )
+ return false;
+ }
// try to read next data chunk:
- stream.Read(&FCC1, 4);
+ if ( !stream.Read(&FCC1, 4) && !stream.Eof())
+ {
+ // we didn't reach the EOF! An other kind of error has occurred...
+ return false;
+ }
+ //else: proceed with the parsing of the next header block or
+ // exiting this loop (if stream.Eof() == true)
}
if (m_nFrames==0)
{
// if no SEQ chunk is available, display the frames in the order
// they were loaded
- for (size_t i=0; i<m_nFrames; i++)
+ for (unsigned int i=0; i<m_nFrames; i++)
if (m_info[i].m_imageIndex == -1)
m_info[i].m_imageIndex = i;
}
// if some frame has an invalid delay, use the global delay given in the
// ANI header
- for (size_t i=0; i<m_nFrames; i++)
+ for (unsigned int i=0; i<m_nFrames; i++)
if (m_info[i].m_delay == 0)
m_info[i].m_delay = globaldelay;
m_szAnimation.GetHeight() == 0)
m_szAnimation = wxSize(m_images[0].GetWidth(), m_images[0].GetHeight());
- return m_szAnimation!=wxDefaultSize;
+ return m_szAnimation != wxDefaultSize;
}
-#endif // wxUSE_STREAMS && wxUSE_GIF
+#endif // wxUSE_STREAMS && wxUSE_ICO_CUR
projects / wxWidgets.git / blobdiff