Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

replaced size_t with unsigned int in wxAnimation and related classes and a couple of minor cleanups (use C++ comments; wrap long lines; put private parts after the public ones)

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@43898 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2006-12-10 14:18:37 +00:00
parent e02c9235c0
commit 870cf35c45
11 changed files with 263 additions and 271 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
docs/latex/wx/animation.tex
View File

@@ -65,7 +65,7 @@ See \helpref{reference-counted object destruction}{refcountdestruct} for more in
\membersection{wxAnimation::GetDelay}\label{wxanimationgetdelay} \membersection{wxAnimation::GetDelay}\label{wxanimationgetdelay}
\constfunc{int}{GetDelay}{\param{size\_t }{i}} \constfunc{int}{GetDelay}{\param{unsigned int }{i}}
Returns the delay for the i-th frame in milliseconds. Returns the delay for the i-th frame in milliseconds.
If {\tt -1} is returned the frame is to be displayed forever. If {\tt -1} is returned the frame is to be displayed forever.
@@ -73,14 +73,14 @@ If {\tt -1} is returned the frame is to be displayed forever.
\membersection{wxAnimation::GetFrameCount}\label{wxanimationgetframecount} \membersection{wxAnimation::GetFrameCount}\label{wxanimationgetframecount}
\constfunc{size\_t}{GetFrameCount}{\void} \constfunc{unsigned int}{GetFrameCount}{\void}
Returns the number of frames for this animation. Returns the number of frames for this animation.
\membersection{wxAnimation::GetFrame}\label{wxanimationgetframe} \membersection{wxAnimation::GetFrame}\label{wxanimationgetframe}
\constfunc{wxImage}{GetFrame}{\param{size\_t }{i}} \constfunc{wxImage}{GetFrame}{\param{unsigned int }{i}}
Returns the i-th frame as a \helpref{wxImage}{wximage}. Returns the i-th frame as a \helpref{wxImage}{wximage}.

48
include/wx/anidecod.h
View File

@@ -30,8 +30,30 @@ WX_DECLARE_EXPORTED_OBJARRAY(wxImage, wxImageArray);
class WXDLLEXPORT wxANIDecoder : public wxAnimationDecoder class WXDLLEXPORT wxANIDecoder : public wxAnimationDecoder
{ {
private: public:
// constructor, destructor, etc.
wxANIDecoder();
~wxANIDecoder();
virtual wxSize GetFrameSize(unsigned int frame) const;
virtual wxPoint GetFramePosition(unsigned int frame) const;
virtual wxAnimationDisposal GetDisposalMethod(unsigned int frame) const;
virtual long GetDelay(unsigned int frame) const;
virtual wxColour GetTransparentColour(unsigned int frame) const;
// implementation of wxAnimationDecoder's pure virtuals
virtual bool CanRead( wxInputStream& stream ) const;
virtual bool Load( wxInputStream& stream );
bool ConvertToImage(unsigned int frame, wxImage *image) const;
wxAnimationDecoder *Clone() const
{ return new wxANIDecoder; }
wxAnimationType GetType() const
{ return wxANIMATION_TYPE_ANI; }
private:
// frames stored as wxImage(s): ANI files are meant to be used mostly for animated // frames stored as wxImage(s): ANI files are meant to be used mostly for animated
// cursors and thus they do not use any optimization to encode differences between // cursors and thus they do not use any optimization to encode differences between
// two frames: they are just a list of images to display sequentially. // two frames: they are just a list of images to display sequentially.
@@ -44,31 +66,7 @@ private:
// this is the wxCURHandler used to load the ICON chunk of the ANI files // this is the wxCURHandler used to load the ICON chunk of the ANI files
static wxCURHandler sm_handler; static wxCURHandler sm_handler;
public:
virtual wxSize GetFrameSize(size_t frame) const;
virtual wxPoint GetFramePosition(size_t frame) const;
virtual wxAnimationDisposal GetDisposalMethod(size_t frame) const;
virtual long GetDelay(size_t frame) const;
virtual wxColour GetTransparentColour(size_t frame) const;
public:
// constructor, destructor, etc.
wxANIDecoder();
~wxANIDecoder();
public: // implementation of wxAnimationDecoder's pure virtuals
virtual bool CanRead( wxInputStream& stream ) const;
virtual bool Load( wxInputStream& stream );
bool ConvertToImage(size_t frame, wxImage *image) const;
wxAnimationDecoder *Clone() const
{ return new wxANIDecoder; }
wxAnimationType GetType() const
{ return wxANIMATION_TYPE_ANI; }
private:
DECLARE_NO_COPY_CLASS(wxANIDecoder) DECLARE_NO_COPY_CLASS(wxANIDecoder)
}; };

28
include/wx/animate.h
View File

@@ -9,8 +9,8 @@
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _WX_ANIMATEH__ #ifndef _WX_ANIMATE_H_
#define _WX_ANIMATEH__ #define _WX_ANIMATE_H_
#include "wx/defs.h" #include "wx/defs.h"
@@ -39,14 +39,16 @@ public:
virtual bool IsOk() const = 0; virtual bool IsOk() const = 0;
// can be -1 // can be -1
virtual int GetDelay(size_t i) const = 0; virtual int GetDelay(unsigned int frame) const = 0;
virtual size_t GetFrameCount() const = 0; virtual unsigned int GetFrameCount() const = 0;
virtual wxImage GetFrame(size_t i) const = 0; virtual wxImage GetFrame(unsigned int frame) const = 0;
virtual wxSize GetSize() const = 0; virtual wxSize GetSize() const = 0;
virtual bool LoadFile(const wxString &name, wxAnimationType type = wxANIMATION_TYPE_ANY) = 0; virtual bool LoadFile(const wxString& name,
virtual bool Load(wxInputStream &stream, wxAnimationType type = wxANIMATION_TYPE_ANY) = 0; wxAnimationType type = wxANIMATION_TYPE_ANY) = 0;
virtual bool Load(wxInputStream& stream,
wxAnimationType type = wxANIMATION_TYPE_ANY) = 0;
protected: protected:
DECLARE_ABSTRACT_CLASS(wxAnimationBase) DECLARE_ABSTRACT_CLASS(wxAnimationBase)
@@ -68,11 +70,11 @@ protected:
class WXDLLIMPEXP_ADV wxAnimationCtrlBase : public wxControl class WXDLLIMPEXP_ADV wxAnimationCtrlBase : public wxControl
{ {
public: public:
wxAnimationCtrlBase() {} wxAnimationCtrlBase() { }
public: // public API // public API
virtual bool LoadFile(const wxString& filename,
virtual bool LoadFile(const wxString& filename, wxAnimationType type = wxANIMATION_TYPE_ANY) = 0; wxAnimationType type = wxANIMATION_TYPE_ANY) = 0;
virtual void SetAnimation(const wxAnimation &anim) = 0; virtual void SetAnimation(const wxAnimation &anim) = 0;
virtual wxAnimation GetAnimation() const = 0; virtual wxAnimation GetAnimation() const = 0;
@@ -117,6 +119,6 @@ private:
#include "wx/generic/animate.h" #include "wx/generic/animate.h"
#endif #endif
#endif // wxUSE_ANIMATIONCTRL #endif // wxUSE_ANIMATIONCTRL
#endif // _WX_ANIMATEH__ #endif // _WX_ANIMATE_H_

73
include/wx/animdecod.h
View File

@@ -86,47 +86,13 @@ enum wxAnimationType
class WXDLLEXPORT wxAnimationDecoder : public wxObjectRefData class WXDLLEXPORT wxAnimationDecoder : public wxObjectRefData
{ {
protected:
wxSize m_szAnimation;
size_t m_nFrames;
// this is the colour to use for the wxANIM_TOBACKGROUND disposal.
// if not specified by the animation, it's set to wxNullColour
wxColour m_background;
public: // frame specific data getters
// not all frames may be of the same size; e.g. GIF allows to
// specify that between two frames only a smaller portion of the
// entire animation has changed.
virtual wxSize GetFrameSize(size_t frame) const = 0;
// the position of this frame in case it's not as big as m_szAnimation
// or wxPoint(0,0) otherwise.
virtual wxPoint GetFramePosition(size_t frame) const = 0;
// what should be done after displaying this frame.
virtual wxAnimationDisposal GetDisposalMethod(size_t frame) const = 0;
// the number of milliseconds this frame should be displayed.
// if returns -1 then the frame must be displayed forever.
virtual long GetDelay(size_t frame) const = 0;
// the transparent colour for this frame if any or wxNullColour.
virtual wxColour GetTransparentColour(size_t frame) const = 0;
// get global data
wxSize GetAnimationSize() const { return m_szAnimation; }
wxColour GetBackgroundColour() const { return m_background; }
size_t GetFrameCount() const { return m_nFrames; }
public: public:
wxAnimationDecoder() wxAnimationDecoder()
{ {
m_background = wxNullColour; m_background = wxNullColour;
m_nFrames = 0; m_nFrames = 0;
} }
~wxAnimationDecoder() {} virtual ~wxAnimationDecoder() { }
virtual bool Load( wxInputStream& stream ) = 0; virtual bool Load( wxInputStream& stream ) = 0;
@@ -136,7 +102,42 @@ public:
virtual wxAnimationType GetType() const = 0; virtual wxAnimationType GetType() const = 0;
// convert given frame to wxImage // convert given frame to wxImage
virtual bool ConvertToImage(size_t frame, wxImage *image) const = 0; virtual bool ConvertToImage(unsigned int frame, wxImage *image) const = 0;
// frame specific data getters
// not all frames may be of the same size; e.g. GIF allows to
// specify that between two frames only a smaller portion of the
// entire animation has changed.
virtual wxSize GetFrameSize(unsigned int frame) const = 0;
// the position of this frame in case it's not as big as m_szAnimation
// or wxPoint(0,0) otherwise.
virtual wxPoint GetFramePosition(unsigned int frame) const = 0;
// what should be done after displaying this frame.
virtual wxAnimationDisposal GetDisposalMethod(unsigned int frame) const = 0;
// the number of milliseconds this frame should be displayed.
// if returns -1 then the frame must be displayed forever.
virtual long GetDelay(unsigned int frame) const = 0;
// the transparent colour for this frame if any or wxNullColour.
virtual wxColour GetTransparentColour(unsigned int frame) const = 0;
// get global data
wxSize GetAnimationSize() const { return m_szAnimation; }
wxColour GetBackgroundColour() const { return m_background; }
unsigned int GetFrameCount() const { return m_nFrames; }
protected:
wxSize m_szAnimation;
unsigned int m_nFrames;
// this is the colour to use for the wxANIM_TOBACKGROUND disposal.
// if not specified by the animation, it's set to wxNullColour
wxColour m_background;
}; };

23
include/wx/generic/animate.h
View File

@@ -26,9 +26,9 @@ public:
virtual bool IsOk() const virtual bool IsOk() const
{ return m_refData != NULL; } { return m_refData != NULL; }
virtual size_t GetFrameCount() const; virtual unsigned int GetFrameCount() const;
virtual int GetDelay(size_t i) const; virtual int GetDelay(unsigned int i) const;
virtual wxImage GetFrame(size_t i) const; virtual wxImage GetFrame(unsigned int i) const;
virtual wxSize GetSize() const; virtual wxSize GetSize() const;
virtual bool LoadFile(const wxString& filename, virtual bool LoadFile(const wxString& filename,
@@ -36,12 +36,11 @@ public:
virtual bool Load(wxInputStream& stream, virtual bool Load(wxInputStream& stream,
wxAnimationType type = wxANIMATION_TYPE_ANY); wxAnimationType type = wxANIMATION_TYPE_ANY);
public: // extended interface used by the generic implementation of wxAnimationCtrl // extended interface used by the generic implementation of wxAnimationCtrl
wxPoint GetFramePosition(unsigned int frame) const;
wxPoint GetFramePosition(size_t frame) const; wxSize GetFrameSize(unsigned int frame) const;
wxSize GetFrameSize(size_t frame) const; wxAnimationDisposal GetDisposalMethod(unsigned int frame) const;
wxAnimationDisposal GetDisposalMethod(size_t frame) const; wxColour GetTransparentColour(unsigned int frame) const;
wxColour GetTransparentColour(size_t frame) const;
wxColour GetBackgroundColour() const; wxColour GetBackgroundColour() const;
protected: protected:
@@ -147,14 +146,14 @@ protected: // internal utilities
void DisposeToBackground(wxDC& dc, const wxPoint &pos, const wxSize &sz); void DisposeToBackground(wxDC& dc, const wxPoint &pos, const wxSize &sz);
void IncrementalUpdateBackingStore(); void IncrementalUpdateBackingStore();
bool RebuildBackingStoreUpToFrame(size_t); bool RebuildBackingStoreUpToFrame(unsigned int);
void DrawFrame(wxDC &dc, size_t); void DrawFrame(wxDC &dc, unsigned int);
virtual void DisplayStaticImage(); virtual void DisplayStaticImage();
virtual wxSize DoGetBestSize() const; virtual wxSize DoGetBestSize() const;
protected: protected:
size_t m_currentFrame; // Current frame unsigned int m_currentFrame; // Current frame
bool m_looped; // Looped, or not bool m_looped; // Looped, or not
wxTimer m_timer; // The timer wxTimer m_timer; // The timer
wxAnimation m_animation; // The animation wxAnimation m_animation; // The animation

91
include/wx/gifdecod.h
View File

@@ -8,8 +8,8 @@
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GIFDECOD_H #ifndef _WX_GIFDECOD_H_
#define _WX_GIFDECOD_H #define _WX_GIFDECOD_H_
#include "wx/defs.h" #include "wx/defs.h"
@@ -20,7 +20,7 @@
#include "wx/animdecod.h" #include "wx/animdecod.h"
// internal utility used to store a frame in 8bit-per-pixel format // internal utility used to store a frame in 8bit-per-pixel format
class /*WXDLLEXPORT*/ GIFImage; class GIFImage;
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -31,76 +31,55 @@ class /*WXDLLEXPORT*/ GIFImage;
// Note that the error code wxGIF_TRUNCATED means that the image itself // Note that the error code wxGIF_TRUNCATED means that the image itself
// is most probably OK, but the decoder didn't reach the end of the data // is most probably OK, but the decoder didn't reach the end of the data
// stream; this means that if it was not reading directly from file, // stream; this means that if it was not reading directly from file,
// the stream will not be correctly positioned. the // the stream will not be correctly positioned.
// //
enum wxGIFErrorCode enum wxGIFErrorCode
{ {
wxGIF_OK = 0, /* everything was OK */ wxGIF_OK = 0, // everything was OK
wxGIF_INVFORMAT, /* error in gif header */ wxGIF_INVFORMAT, // error in GIF header
wxGIF_MEMERR, /* error allocating memory */ wxGIF_MEMERR, // error allocating memory
wxGIF_TRUNCATED /* file appears to be truncated */ wxGIF_TRUNCATED // file appears to be truncated
}; };
#define MAX_BLOCK_SIZE 256 /* max. block size */
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// wxGIFDecoder class // wxGIFDecoder class
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
class WXDLLEXPORT wxGIFDecoder : public wxAnimationDecoder class WXDLLEXPORT wxGIFDecoder : public wxAnimationDecoder
{ {
private:
// a wxArray provides a constant access time rather than a linear time
// like for linked lists.
wxArrayPtrVoid m_frames;
// decoder state vars
int m_restbits; /* remaining valid bits */
unsigned int m_restbyte; /* remaining bytes in this block */
unsigned int m_lastbyte; /* last byte read */
unsigned char m_buffer[MAX_BLOCK_SIZE]; /* buffer for reading */
unsigned char *m_bufp; /* pointer to next byte in buffer */
private:
int getcode(wxInputStream& stream, int bits, int abfin);
wxGIFErrorCode dgif(wxInputStream& stream, GIFImage *img, int interl, int bits);
public:
// get data of current frame
unsigned char* GetData(size_t frame) const;
unsigned char* GetPalette(size_t frame) const;
unsigned int GetNcolours(size_t frame) const;
int GetTransparentColourIndex(size_t frame) const;
wxColour GetTransparentColour(size_t frame) const;
virtual wxSize GetFrameSize(size_t frame) const;
virtual wxPoint GetFramePosition(size_t frame) const;
virtual wxAnimationDisposal GetDisposalMethod(size_t frame) const;
virtual long GetDelay(size_t frame) const;
// GIFs can contain both static images and animations
bool IsAnimation() const
{ return m_nFrames > 1; }
public: public:
// constructor, destructor, etc. // constructor, destructor, etc.
wxGIFDecoder(); wxGIFDecoder();
~wxGIFDecoder(); ~wxGIFDecoder();
// get data of current frame
unsigned char* GetData(unsigned int frame) const;
unsigned char* GetPalette(unsigned int frame) const;
unsigned int GetNcolours(unsigned int frame) const;
int GetTransparentColourIndex(unsigned int frame) const;
wxColour GetTransparentColour(unsigned int frame) const;
virtual wxSize GetFrameSize(unsigned int frame) const;
virtual wxPoint GetFramePosition(unsigned int frame) const;
virtual wxAnimationDisposal GetDisposalMethod(unsigned int frame) const;
virtual long GetDelay(unsigned int frame) const;
// GIFs can contain both static images and animations
bool IsAnimation() const
{ return m_nFrames > 1; }
// load function which returns more info than just Load(): // load function which returns more info than just Load():
wxGIFErrorCode LoadGIF( wxInputStream& stream ); wxGIFErrorCode LoadGIF( wxInputStream& stream );
// free all internal frames // free all internal frames
void Destroy(); void Destroy();
public: // implementation of wxAnimationDecoder's pure virtuals // implementation of wxAnimationDecoder's pure virtuals
virtual bool CanRead( wxInputStream& stream ) const; virtual bool CanRead( wxInputStream& stream ) const;
virtual bool Load( wxInputStream& stream ) virtual bool Load( wxInputStream& stream )
{ return LoadGIF(stream) == wxGIF_OK; } { return LoadGIF(stream) == wxGIF_OK; }
bool ConvertToImage(size_t frame, wxImage *image) const; bool ConvertToImage(unsigned int frame, wxImage *image) const;
wxAnimationDecoder *Clone() const wxAnimationDecoder *Clone() const
{ return new wxGIFDecoder; } { return new wxGIFDecoder; }
@@ -108,9 +87,23 @@ public: // implementation of wxAnimationDecoder's pure virtuals
{ return wxANIMATION_TYPE_GIF; } { return wxANIMATION_TYPE_GIF; }
private: private:
// array of all frames
wxArrayPtrVoid m_frames;
// decoder state vars
int m_restbits; // remaining valid bits
unsigned int m_restbyte; // remaining bytes in this block
unsigned int m_lastbyte; // last byte read
unsigned char m_buffer[256]; // buffer for reading
unsigned char *m_bufp; // pointer to next byte in buffer
int getcode(wxInputStream& stream, int bits, int abfin);
wxGIFErrorCode dgif(wxInputStream& stream,
GIFImage *img, int interl, int bits);
DECLARE_NO_COPY_CLASS(wxGIFDecoder) DECLARE_NO_COPY_CLASS(wxGIFDecoder)
}; };
#endif // wxUSE_STREAM && wxUSE_GIF
#endif // wxUSE_STREAM && wxUSE_GIF #endif // _WX_GIFDECOD_H_
#endif // _WX_GIFDECOD_H

8
include/wx/gtk/animate.h
View File

@@ -39,14 +39,12 @@ public:
// unfortunately GdkPixbufAnimation does not expose these info: // unfortunately GdkPixbufAnimation does not expose these info:
virtual size_t GetFrameCount() const virtual unsigned int GetFrameCount() const { return 0; }
{ return 0; } virtual wxImage GetFrame(unsigned int frame) const;
virtual wxImage GetFrame(size_t i) const;
// we can retrieve the delay for a frame only after building // we can retrieve the delay for a frame only after building
// a GdkPixbufAnimationIter... // a GdkPixbufAnimationIter...
virtual int GetDelay(size_t i) const virtual int GetDelay(unsigned int frame) const { return 0; }
{ return 0; }
virtual wxSize GetSize() const; virtual wxSize GetSize() const;

30
src/common/anidecod.cpp
View File

@@ -35,10 +35,10 @@ wxCURHandler wxANIDecoder::sm_handler;
class wxANIFrameInfo class wxANIFrameInfo
{ {
public: public:
wxANIFrameInfo(size_t delay = 0, int idx = -1) wxANIFrameInfo(unsigned int delay = 0, int idx = -1)
{ m_delay=delay; m_imageIndex=idx; } { m_delay=delay; m_imageIndex=idx; }
size_t m_delay; unsigned int m_delay;
int m_imageIndex; int m_imageIndex;
}; };
@@ -61,9 +61,9 @@ wxANIDecoder::~wxANIDecoder()
{ {
} }
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 *image = m_images[idx]; // copy
return image->IsOk(); return image->IsOk();
} }
@@ -73,32 +73,32 @@ bool wxANIDecoder::ConvertToImage(size_t frame, wxImage *image) const
// Data accessors // 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... // all frames are of the same size...
return m_szAnimation; 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... // all frames are of the same size...
return wxPoint(0,0); 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 // this disposal is implicit for all frames inside an ANI file
return wxANIM_TOBACKGROUND; return wxANIM_TOBACKGROUND;
} }
long wxANIDecoder::GetDelay(size_t frame) const long wxANIDecoder::GetDelay(unsigned int frame) const
{ {
return m_info[frame].m_delay; return m_info[frame].m_delay;
} }
wxColour wxANIDecoder::GetTransparentColour(size_t frame) const wxColour wxANIDecoder::GetTransparentColour(unsigned int frame) const
{ {
size_t idx = m_info[frame].m_imageIndex; unsigned int idx = m_info[frame].m_imageIndex;
if (!m_images[idx].HasMask()) if (!m_images[idx].HasMask())
return wxNullColour; return wxNullColour;
@@ -205,7 +205,7 @@ bool wxANIDecoder::Load( wxInputStream& stream )
{ {
wxInt32 FCC1, FCC2; wxInt32 FCC1, FCC2;
wxUint32 datalen; wxUint32 datalen;
size_t globaldelay=0; unsigned int globaldelay=0;
wxInt32 riff32; wxInt32 riff32;
memcpy( &riff32, "RIFF", 4 ); memcpy( &riff32, "RIFF", 4 );
@@ -278,7 +278,7 @@ bool wxANIDecoder::Load( wxInputStream& stream )
return false; // rate chunks should always be placed after anih chunk return false; // rate chunks should always be placed after anih chunk
wxASSERT(m_info.GetCount() == m_nFrames); 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); stream.Read(&FCC2, 4);
m_info[i].m_delay = wxINT32_SWAP_ON_BE(FCC2) * 1000 / 60; m_info[i].m_delay = wxINT32_SWAP_ON_BE(FCC2) * 1000 / 60;
@@ -291,7 +291,7 @@ bool wxANIDecoder::Load( wxInputStream& stream )
return false; // seq chunks should always be placed after anih chunk return false; // seq chunks should always be placed after anih chunk
wxASSERT(m_info.GetCount() == m_nFrames); 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); stream.Read(&FCC2, 4);
m_info[i].m_imageIndex = wxINT32_SWAP_ON_BE(FCC2); m_info[i].m_imageIndex = wxINT32_SWAP_ON_BE(FCC2);
@@ -322,14 +322,14 @@ bool wxANIDecoder::Load( wxInputStream& stream )
{ {
// if no SEQ chunk is available, display the frames in the order // if no SEQ chunk is available, display the frames in the order
// they were loaded // 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) if (m_info[i].m_imageIndex == -1)
m_info[i].m_imageIndex = i; m_info[i].m_imageIndex = i;
} }
// if some frame has an invalid delay, use the global delay given in the // if some frame has an invalid delay, use the global delay given in the
// ANI header // 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) if (m_info[i].m_delay == 0)
m_info[i].m_delay = globaldelay; m_info[i].m_delay = globaldelay;

205
src/common/gifdecod.cpp
View File

@@ -38,16 +38,16 @@ public:
// def ctor // def ctor
GIFImage(); GIFImage();
unsigned int w; /* width */ unsigned int w; // width
unsigned int h; /* height */ unsigned int h; // height
unsigned int left; /* x coord (in logical screen) */ unsigned int left; // x coord (in logical screen)
unsigned int top; /* y coord (in logical screen) */ unsigned int top; // y coord (in logical screen)
int transparent; /* transparent color index (-1 = none) */ int transparent; // transparent color index (-1 = none)
wxAnimationDisposal disposal; /* disposal method */ wxAnimationDisposal disposal; // disposal method
long delay; /* delay in ms (-1 = unused) */ long delay; // delay in ms (-1 = unused)
unsigned char *p; /* bitmap */ unsigned char *p; // bitmap
unsigned char *pal; /* palette */ unsigned char *pal; // palette
unsigned int ncolours; /* number of colours */ unsigned int ncolours; // number of colours
DECLARE_NO_COPY_CLASS(GIFImage) DECLARE_NO_COPY_CLASS(GIFImage)
}; };
@@ -87,7 +87,7 @@ wxGIFDecoder::~wxGIFDecoder()
void wxGIFDecoder::Destroy() void wxGIFDecoder::Destroy()
{ {
wxASSERT(m_nFrames==m_frames.GetCount()); wxASSERT(m_nFrames==m_frames.GetCount());
for (size_t i=0; i<m_nFrames; i++) for (unsigned int i=0; i<m_nFrames; i++)
{ {
GIFImage *f = (GIFImage*)m_frames[i]; GIFImage *f = (GIFImage*)m_frames[i];
free(f->p); free(f->p);
@@ -106,16 +106,16 @@ void wxGIFDecoder::Destroy()
// This function was designed by Vaclav Slavik // This function was designed by Vaclav Slavik
bool wxGIFDecoder::ConvertToImage(size_t frame, wxImage *image) const bool wxGIFDecoder::ConvertToImage(unsigned int frame, wxImage *image) const
{ {
unsigned char *src, *dst, *pal; unsigned char *src, *dst, *pal;
unsigned long i; unsigned long i;
int transparent; int transparent;
/* just in case... */ // just in case...
image->Destroy(); image->Destroy();
/* create the image */ // create the image
wxSize sz = GetFrameSize(frame); wxSize sz = GetFrameSize(frame);
image->Create(sz.GetWidth(), sz.GetHeight()); image->Create(sz.GetWidth(), sz.GetHeight());
@@ -127,7 +127,7 @@ bool wxGIFDecoder::ConvertToImage(size_t frame, wxImage *image) const
dst = image->GetData(); dst = image->GetData();
transparent = GetTransparentColourIndex(frame); transparent = GetTransparentColourIndex(frame);
/* set transparent colour mask */ // set transparent colour mask
if (transparent != -1) if (transparent != -1)
{ {
for (i = 0; i < GetNcolours(frame); i++) for (i = 0; i < GetNcolours(frame); i++)
@@ -164,7 +164,7 @@ bool wxGIFDecoder::ConvertToImage(size_t frame, wxImage *image) const
image->SetPalette(wxPalette(GetNcolours(frame), r, g, b)); image->SetPalette(wxPalette(GetNcolours(frame), r, g, b));
#endif // wxUSE_PALETTE #endif // wxUSE_PALETTE
/* copy image data */ // copy image data
unsigned long npixel = sz.GetWidth() * sz.GetHeight(); unsigned long npixel = sz.GetWidth() * sz.GetHeight();
for (i = 0; i < npixel; i++, src++) for (i = 0; i < npixel; i++, src++)
{ {
@@ -186,27 +186,27 @@ bool wxGIFDecoder::ConvertToImage(size_t frame, wxImage *image) const
// Get data for current frame // Get data for current frame
wxSize wxGIFDecoder::GetFrameSize(size_t frame) const wxSize wxGIFDecoder::GetFrameSize(unsigned int frame) const
{ {
return wxSize(GetFrame(frame)->w, GetFrame(frame)->h); return wxSize(GetFrame(frame)->w, GetFrame(frame)->h);
} }
wxPoint wxGIFDecoder::GetFramePosition(size_t frame) const wxPoint wxGIFDecoder::GetFramePosition(unsigned int frame) const
{ {
return wxPoint(GetFrame(frame)->left, GetFrame(frame)->top); return wxPoint(GetFrame(frame)->left, GetFrame(frame)->top);
} }
wxAnimationDisposal wxGIFDecoder::GetDisposalMethod(size_t frame) const wxAnimationDisposal wxGIFDecoder::GetDisposalMethod(unsigned int frame) const
{ {
return GetFrame(frame)->disposal; return GetFrame(frame)->disposal;
} }
long wxGIFDecoder::GetDelay(size_t frame) const long wxGIFDecoder::GetDelay(unsigned int frame) const
{ {
return GetFrame(frame)->delay; return GetFrame(frame)->delay;
} }
wxColour wxGIFDecoder::GetTransparentColour(size_t frame) const wxColour wxGIFDecoder::GetTransparentColour(unsigned int frame) const
{ {
unsigned char *pal = GetFrame(frame)->pal; unsigned char *pal = GetFrame(frame)->pal;
int n = GetFrame(frame)->transparent; int n = GetFrame(frame)->transparent;
@@ -218,10 +218,10 @@ wxColour wxGIFDecoder::GetTransparentColour(size_t frame) const
pal[n*3 + 2]); pal[n*3 + 2]);
} }
unsigned char* wxGIFDecoder::GetData(size_t frame) const { return (GetFrame(frame)->p); } unsigned char* wxGIFDecoder::GetData(unsigned int frame) const { return (GetFrame(frame)->p); }
unsigned char* wxGIFDecoder::GetPalette(size_t frame) const { return (GetFrame(frame)->pal); } unsigned char* wxGIFDecoder::GetPalette(unsigned int frame) const { return (GetFrame(frame)->pal); }
unsigned int wxGIFDecoder::GetNcolours(size_t frame) const { return (GetFrame(frame)->ncolours); } unsigned int wxGIFDecoder::GetNcolours(unsigned int frame) const { return (GetFrame(frame)->ncolours); }
int wxGIFDecoder::GetTransparentColourIndex(size_t frame) const { return (GetFrame(frame)->transparent); } int wxGIFDecoder::GetTransparentColourIndex(unsigned int frame) const { return (GetFrame(frame)->transparent); }
@@ -234,17 +234,17 @@ int wxGIFDecoder::GetTransparentColourIndex(size_t frame) const { return (GetFr
// //
int wxGIFDecoder::getcode(wxInputStream& stream, int bits, int ab_fin) int wxGIFDecoder::getcode(wxInputStream& stream, int bits, int ab_fin)
{ {
unsigned int mask; /* bit mask */ unsigned int mask; // bit mask
unsigned int code; /* code (result) */ unsigned int code; // code (result)
/* get remaining bits from last byte read */ // get remaining bits from last byte read
mask = (1 << bits) - 1; mask = (1 << bits) - 1;
code = (m_lastbyte >> (8 - m_restbits)) & mask; code = (m_lastbyte >> (8 - m_restbits)) & mask;
/* keep reading new bytes while needed */ // keep reading new bytes while needed
while (bits > m_restbits) while (bits > m_restbits)
{ {
/* if no bytes left in this block, read the next block */ // if no bytes left in this block, read the next block
if (m_restbyte == 0) if (m_restbyte == 0)
{ {
m_restbyte = (unsigned char)stream.GetC(); m_restbyte = (unsigned char)stream.GetC();
@@ -260,7 +260,7 @@ int wxGIFDecoder::getcode(wxInputStream& stream, int bits, int ab_fin)
break; break;
} }
/* prefetch data */ // prefetch data
stream.Read((void *) m_buffer, m_restbyte); stream.Read((void *) m_buffer, m_restbyte);
if (stream.LastRead() != m_restbyte) if (stream.LastRead() != m_restbyte)
{ {
@@ -270,17 +270,17 @@ int wxGIFDecoder::getcode(wxInputStream& stream, int bits, int ab_fin)
m_bufp = m_buffer; m_bufp = m_buffer;
} }
/* read next byte and isolate the bits we need */ // read next byte and isolate the bits we need
m_lastbyte = (unsigned char) (*m_bufp++); m_lastbyte = (unsigned char) (*m_bufp++);
mask = (1 << (bits - m_restbits)) - 1; mask = (1 << (bits - m_restbits)) - 1;
code = code + ((m_lastbyte & mask) << m_restbits); code = code + ((m_lastbyte & mask) << m_restbits);
m_restbyte--; m_restbyte--;
/* adjust total number of bits extracted from the buffer */ // adjust total number of bits extracted from the buffer
m_restbits = m_restbits + 8; m_restbits = m_restbits + 8;
} }
/* find number of bits remaining for next code */ // find number of bits remaining for next code
m_restbits = (m_restbits - bits); m_restbits = (m_restbits - bits);
return code; return code;
@@ -292,23 +292,24 @@ int wxGIFDecoder::getcode(wxInputStream& stream, int bits, int ab_fin)
// is 'bits'. Supports interlaced images (interl == 1). // is 'bits'. Supports interlaced images (interl == 1).
// Returns wxGIF_OK (== 0) on success, or an error code if something // Returns wxGIF_OK (== 0) on success, or an error code if something
// fails (see header file for details) // fails (see header file for details)
wxGIFErrorCode wxGIFDecoder::dgif(wxInputStream& stream, GIFImage *img, int interl, int bits) wxGIFErrorCode
wxGIFDecoder::dgif(wxInputStream& stream, GIFImage *img, int interl, int bits)
{ {
static const int allocSize = 4096 + 1; static const int allocSize = 4096 + 1;
int *ab_prefix = new int[allocSize]; /* alphabet (prefixes) */ int *ab_prefix = new int[allocSize]; // alphabet (prefixes)
if (ab_prefix == NULL) if (ab_prefix == NULL)
{ {
return wxGIF_MEMERR; return wxGIF_MEMERR;
} }
int *ab_tail = new int[allocSize]; /* alphabet (tails) */ int *ab_tail = new int[allocSize]; // alphabet (tails)
if (ab_tail == NULL) if (ab_tail == NULL)
{ {
delete[] ab_prefix; delete[] ab_prefix;
return wxGIF_MEMERR; return wxGIF_MEMERR;
} }
int *stack = new int[allocSize]; /* decompression stack */ int *stack = new int[allocSize]; // decompression stack
if (stack == NULL) if (stack == NULL)
{ {
delete[] ab_prefix; delete[] ab_prefix;
@@ -316,22 +317,22 @@ wxGIFErrorCode wxGIFDecoder::dgif(wxInputStream& stream, GIFImage *img, int inte
return wxGIF_MEMERR; return wxGIF_MEMERR;
} }
int ab_clr; /* clear code */ int ab_clr; // clear code
int ab_fin; /* end of info code */ int ab_fin; // end of info code
int ab_bits; /* actual symbol width, in bits */ int ab_bits; // actual symbol width, in bits
int ab_free; /* first free position in alphabet */ int ab_free; // first free position in alphabet
int ab_max; /* last possible character in alphabet */ int ab_max; // last possible character in alphabet
int pass; /* pass number in interlaced images */ int pass; // pass number in interlaced images
int pos; /* index into decompresion stack */ int pos; // index into decompresion stack
unsigned int x, y; /* position in image buffer */ unsigned int x, y; // position in image buffer
int code, readcode, lastcode, abcabca; int code, readcode, lastcode, abcabca;
/* these won't change */ // these won't change
ab_clr = (1 << bits); ab_clr = (1 << bits);
ab_fin = (1 << bits) + 1; ab_fin = (1 << bits) + 1;
/* these will change through the decompression proccess */ // these will change through the decompression proccess
ab_bits = bits + 1; ab_bits = bits + 1;
ab_free = (1 << bits) + 2; ab_free = (1 << bits) + 2;
ab_max = (1 << ab_bits) - 1; ab_max = (1 << ab_bits) - 1;
@@ -340,41 +341,41 @@ wxGIFErrorCode wxGIFDecoder::dgif(wxInputStream& stream, GIFImage *img, int inte
pass = 1; pass = 1;
pos = x = y = 0; pos = x = y = 0;
/* reset decoder vars */ // reset decoder vars
m_restbits = 0; m_restbits = 0;
m_restbyte = 0; m_restbyte = 0;
m_lastbyte = 0; m_lastbyte = 0;
do do
{ {
/* get next code */ // get next code
readcode = code = getcode(stream, ab_bits, ab_fin); readcode = code = getcode(stream, ab_bits, ab_fin);
/* end of image? */ // end of image?
if (code == ab_fin) break; if (code == ab_fin) break;
/* reset alphabet? */ // reset alphabet?
if (code == ab_clr) if (code == ab_clr)
{ {
/* reset main variables */ // reset main variables
ab_bits = bits + 1; ab_bits = bits + 1;
ab_free = (1 << bits) + 2; ab_free = (1 << bits) + 2;
ab_max = (1 << ab_bits) - 1; ab_max = (1 << ab_bits) - 1;
lastcode = -1; lastcode = -1;
abcabca = -1; abcabca = -1;
/* skip to next code */ // skip to next code
continue; continue;
} }
/* unknown code: special case (like in ABCABCA) */ // unknown code: special case (like in ABCABCA)
if (code >= ab_free) if (code >= ab_free)
{ {
code = lastcode; /* take last string */ code = lastcode; // take last string
stack[pos++] = abcabca; /* add first character */ stack[pos++] = abcabca; // add first character
} }
/* build the string for this code in the stack */ // build the string for this code in the stack
while (code > ab_clr) while (code > ab_clr)
{ {
stack[pos++] = ab_tail[code]; stack[pos++] = ab_tail[code];
@@ -400,10 +401,10 @@ wxGIFErrorCode wxGIFDecoder::dgif(wxInputStream& stream, GIFImage *img, int inte
return wxGIF_INVFORMAT; return wxGIF_INVFORMAT;
} }
stack[pos] = code; /* push last code into the stack */ stack[pos] = code; // push last code into the stack
abcabca = code; /* save for special case */ abcabca = code; // save for special case
/* make new entry in alphabet (only if NOT just cleared) */ // make new entry in alphabet (only if NOT just cleared)
if (lastcode != -1) if (lastcode != -1)
{ {
// Normally, after the alphabet is full and can't grow any // Normally, after the alphabet is full and can't grow any
@@ -436,7 +437,7 @@ wxGIFErrorCode wxGIFDecoder::dgif(wxInputStream& stream, GIFImage *img, int inte
} }
} }
/* dump stack data to the image buffer */ // dump stack data to the image buffer
while (pos >= 0) while (pos >= 0)
{ {
(img->p)[x + (y * (img->w))] = (char) stack[pos]; (img->p)[x + (y * (img->w))] = (char) stack[pos];
@@ -448,7 +449,7 @@ wxGIFErrorCode wxGIFDecoder::dgif(wxInputStream& stream, GIFImage *img, int inte
if (interl) if (interl)
{ {
/* support for interlaced images */ // support for interlaced images
switch (pass) switch (pass)
{ {
case 1: y += 8; break; case 1: y += 8; break;
@@ -505,7 +506,7 @@ wxGIFErrorCode wxGIFDecoder::dgif(wxInputStream& stream, GIFImage *img, int inte
} }
else else
{ {
/* non-interlaced */ // non-interlaced
y++; y++;
/* /*
Normally image decoding is finished when an End of Information code is Normally image decoding is finished when an End of Information code is
@@ -601,13 +602,13 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
unsigned char buf[16]; unsigned char buf[16];
bool anim = true; bool anim = true;
/* check GIF signature */ // check GIF signature
if (!CanRead(stream)) if (!CanRead(stream))
return wxGIF_INVFORMAT; return wxGIF_INVFORMAT;
/* check for animated GIF support (ver. >= 89a) */ // check for animated GIF support (ver. >= 89a)
static const size_t headerSize = (3 + 3); static const unsigned int headerSize = (3 + 3);
stream.Read(buf, headerSize); stream.Read(buf, headerSize);
if (stream.LastRead() != headerSize) if (stream.LastRead() != headerSize)
{ {
@@ -619,8 +620,8 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
anim = false; anim = false;
} }
/* read logical screen descriptor block (LSDB) */ // read logical screen descriptor block (LSDB)
static const size_t lsdbSize = (2 + 2 + 1 + 1 + 1); static const unsigned int lsdbSize = (2 + 2 + 1 + 1 + 1);
stream.Read(buf, lsdbSize); stream.Read(buf, lsdbSize);
if (stream.LastRead() != lsdbSize) if (stream.LastRead() != lsdbSize)
{ {
@@ -635,13 +636,13 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
return wxGIF_INVFORMAT; return wxGIF_INVFORMAT;
} }
/* load global color map if available */ // load global color map if available
if ((buf[4] & 0x80) == 0x80) if ((buf[4] & 0x80) == 0x80)
{ {
int backgroundColIndex = buf[5]; int backgroundColIndex = buf[5];
global_ncolors = 2 << (buf[4] & 0x07); global_ncolors = 2 << (buf[4] & 0x07);
size_t numBytes = 3 * global_ncolors; unsigned int numBytes = 3 * global_ncolors;
stream.Read(pal, numBytes); stream.Read(pal, numBytes);
if (stream.LastRead() != numBytes) if (stream.LastRead() != numBytes)
{ {
@@ -653,7 +654,7 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
pal[backgroundColIndex*3 + 2]); pal[backgroundColIndex*3 + 2]);
} }
/* transparent colour, disposal method and delay default to unused */ // transparent colour, disposal method and delay default to unused
transparent = -1; transparent = -1;
disposal = wxANIM_UNSPECIFIED; disposal = wxANIM_UNSPECIFIED;
delay = -1; delay = -1;
@@ -680,19 +681,19 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
break; // Alternative : "return wxGIF_INVFORMAT;" break; // Alternative : "return wxGIF_INVFORMAT;"
} }
/* end of data? */ // end of data?
if (type == 0x3B) if (type == 0x3B)
{ {
done = true; done = true;
} }
else else
/* extension block? */ // extension block?
if (type == 0x21) if (type == 0x21)
{ {
if (((unsigned char)stream.GetC()) == 0xF9) if (((unsigned char)stream.GetC()) == 0xF9)
/* graphics control extension, parse it */ // graphics control extension, parse it
{ {
static const size_t gceSize = 6; static const unsigned int gceSize = 6;
stream.Read(buf, gceSize); stream.Read(buf, gceSize);
if (stream.LastRead() != gceSize) if (stream.LastRead() != gceSize)
{ {
@@ -700,18 +701,18 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
return wxGIF_INVFORMAT; return wxGIF_INVFORMAT;
} }
/* read delay and convert from 1/100 of a second to ms */ // read delay and convert from 1/100 of a second to ms
delay = 10 * (buf[2] + 256 * buf[3]); delay = 10 * (buf[2] + 256 * buf[3]);
/* read transparent colour index, if used */ // read transparent colour index, if used
if (buf[1] & 0x01) if (buf[1] & 0x01)
transparent = buf[4]; transparent = buf[4];
/* read disposal method */ // read disposal method
disposal = (wxAnimationDisposal)(((buf[1] & 0x1C) >> 2) - 1); disposal = (wxAnimationDisposal)(((buf[1] & 0x1C) >> 2) - 1);
} }
else else
/* other extension, skip */ // other extension, skip
{ {
while ((i = (unsigned char)stream.GetC()) != 0) while ((i = (unsigned char)stream.GetC()) != 0)
{ {
@@ -725,10 +726,10 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
} }
} }
else else
/* image descriptor block? */ // image descriptor block?
if (type == 0x2C) if (type == 0x2C)
{ {
/* allocate memory for IMAGEN struct */ // allocate memory for IMAGEN struct
GIFImage *pimg = new GIFImage(); GIFImage *pimg = new GIFImage();
if (pimg == NULL) if (pimg == NULL)
@@ -737,8 +738,8 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
return wxGIF_MEMERR; return wxGIF_MEMERR;
} }
/* fill in the data */ // fill in the data
static const size_t idbSize = (2 + 2 + 2 + 2 + 1); static const unsigned int idbSize = (2 + 2 + 2 + 2 + 1);
stream.Read(buf, idbSize); stream.Read(buf, idbSize);
if (stream.LastRead() != idbSize) if (stream.LastRead() != idbSize)
{ {
@@ -769,8 +770,8 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
pimg->disposal = disposal; pimg->disposal = disposal;
pimg->delay = delay; pimg->delay = delay;
/* allocate memory for image and palette */ // allocate memory for image and palette
pimg->p = (unsigned char *) malloc((size_t)size); pimg->p = (unsigned char *) malloc((unsigned int)size);
pimg->pal = (unsigned char *) malloc(768); pimg->pal = (unsigned char *) malloc(768);
if ((!pimg->p) || (!pimg->pal)) if ((!pimg->p) || (!pimg->pal))
@@ -779,11 +780,11 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
return wxGIF_MEMERR; return wxGIF_MEMERR;
} }
/* load local color map if available, else use global map */ // load local color map if available, else use global map
if ((buf[8] & 0x80) == 0x80) if ((buf[8] & 0x80) == 0x80)
{ {
unsigned int local_ncolors = 2 << (buf[8] & 0x07); unsigned int local_ncolors = 2 << (buf[8] & 0x07);
size_t numBytes = 3 * local_ncolors; unsigned int numBytes = 3 * local_ncolors;
stream.Read(pimg->pal, numBytes); stream.Read(pimg->pal, numBytes);
pimg->ncolours = local_ncolors; pimg->ncolours = local_ncolors;
if (stream.LastRead() != numBytes) if (stream.LastRead() != numBytes)
@@ -798,7 +799,7 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
pimg->ncolours = global_ncolors; pimg->ncolours = global_ncolors;
} }
/* get initial code size from first byte in raster data */ // get initial code size from first byte in raster data
bits = (unsigned char)stream.GetC(); bits = (unsigned char)stream.GetC();
if (bits == 0) if (bits == 0)
{ {
@@ -806,7 +807,7 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
return wxGIF_INVFORMAT; return wxGIF_INVFORMAT;
} }
/* decode image */ // decode image
wxGIFErrorCode result = dgif(stream, pimg, interl, bits); wxGIFErrorCode result = dgif(stream, pimg, interl, bits);
if (result != wxGIF_OK) if (result != wxGIF_OK)
{ {
@@ -814,11 +815,11 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
return result; return result;
} }
/* add the image to our frame array */ // add the image to our frame array
m_frames.Add((void*)pimg); m_frames.Add((void*)pimg);
m_nFrames++; m_nFrames++;
/* if this is not an animated GIF, exit after first image */ // if this is not an animated GIF, exit after first image
if (!anim) if (!anim)
done = true; done = true;
} }
@@ -830,7 +831,7 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
return wxGIF_INVFORMAT; return wxGIF_INVFORMAT;
} }
/* try to read to the end of the stream */ // try to read to the end of the stream
while (type != 0x3B) while (type != 0x3B)
{ {
if (!stream.IsOk()) if (!stream.IsOk())
@@ -840,10 +841,10 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
if (type == 0x21) if (type == 0x21)
{ {
/* extension type */ // extension type
(void) stream.GetC(); (void) stream.GetC();
/* skip all data */ // skip all data
while ((i = (unsigned char)stream.GetC()) != 0) while ((i = (unsigned char)stream.GetC()) != 0)
{ {
if (stream.Eof() || (stream.LastRead() == 0)) if (stream.Eof() || (stream.LastRead() == 0))
@@ -856,8 +857,8 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
} }
else if (type == 0x2C) else if (type == 0x2C)
{ {
/* image descriptor block */ // image descriptor block
static const size_t idbSize = (2 + 2 + 2 + 2 + 1); static const unsigned int idbSize = (2 + 2 + 2 + 2 + 1);
stream.Read(buf, idbSize); stream.Read(buf, idbSize);
if (stream.LastRead() != idbSize) if (stream.LastRead() != idbSize)
{ {
@@ -865,7 +866,7 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
return wxGIF_INVFORMAT; return wxGIF_INVFORMAT;
} }
/* local color map */ // local color map
if ((buf[8] & 0x80) == 0x80) if ((buf[8] & 0x80) == 0x80)
{ {
unsigned int local_ncolors = 2 << (buf[8] & 0x07); unsigned int local_ncolors = 2 << (buf[8] & 0x07);
@@ -873,7 +874,7 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
stream.SeekI(numBytes, wxFromCurrent); stream.SeekI(numBytes, wxFromCurrent);
} }
/* initial code size */ // initial code size
(void) stream.GetC(); (void) stream.GetC();
if (stream.Eof() || (stream.LastRead() == 0)) if (stream.Eof() || (stream.LastRead() == 0))
{ {
@@ -881,7 +882,7 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
return wxGIF_INVFORMAT; return wxGIF_INVFORMAT;
} }
/* skip all data */ // skip all data
while ((i = (unsigned char)stream.GetC()) != 0) while ((i = (unsigned char)stream.GetC()) != 0)
{ {
if (stream.Eof() || (stream.LastRead() == 0)) if (stream.Eof() || (stream.LastRead() == 0))
@@ -892,9 +893,9 @@ wxGIFErrorCode wxGIFDecoder::LoadGIF(wxInputStream& stream)
stream.SeekI(i, wxFromCurrent); stream.SeekI(i, wxFromCurrent);
} }
} }
else if ((type != 0x3B) && (type != 00)) /* testing */ else if ((type != 0x3B) && (type != 00)) // testing
{ {
/* images are OK, but couldn't read to the end of the stream */ // images are OK, but couldn't read to the end of the stream
return wxGIF_TRUNCATED; return wxGIF_TRUNCATED;
} }
} }

20
src/generic/animateg.cpp
View File

@@ -51,14 +51,14 @@ wxSize wxAnimation::GetSize() const
return M_ANIMDATA->GetAnimationSize(); return M_ANIMDATA->GetAnimationSize();
} }
size_t wxAnimation::GetFrameCount() const unsigned int wxAnimation::GetFrameCount() const
{ {
wxCHECK_MSG( IsOk(), 0, wxT("invalid animation") ); wxCHECK_MSG( IsOk(), 0, wxT("invalid animation") );
return M_ANIMDATA->GetFrameCount(); return M_ANIMDATA->GetFrameCount();
} }
wxImage wxAnimation::GetFrame(size_t i) const wxImage wxAnimation::GetFrame(unsigned int i) const
{ {
wxCHECK_MSG( IsOk(), wxNullImage, wxT("invalid animation") ); wxCHECK_MSG( IsOk(), wxNullImage, wxT("invalid animation") );
@@ -68,35 +68,35 @@ wxImage wxAnimation::GetFrame(size_t i) const
return ret; return ret;
} }
int wxAnimation::GetDelay(size_t i) const int wxAnimation::GetDelay(unsigned int i) const
{ {
wxCHECK_MSG( IsOk(), 0, wxT("invalid animation") ); wxCHECK_MSG( IsOk(), 0, wxT("invalid animation") );
return M_ANIMDATA->GetDelay(i); return M_ANIMDATA->GetDelay(i);
} }
wxPoint wxAnimation::GetFramePosition(size_t frame) const wxPoint wxAnimation::GetFramePosition(unsigned int frame) const
{ {
wxCHECK_MSG( IsOk(), wxDefaultPosition, wxT("invalid animation") ); wxCHECK_MSG( IsOk(), wxDefaultPosition, wxT("invalid animation") );
return M_ANIMDATA->GetFramePosition(frame); return M_ANIMDATA->GetFramePosition(frame);
} }
wxSize wxAnimation::GetFrameSize(size_t frame) const wxSize wxAnimation::GetFrameSize(unsigned int frame) const
{ {
wxCHECK_MSG( IsOk(), wxDefaultSize, wxT("invalid animation") ); wxCHECK_MSG( IsOk(), wxDefaultSize, wxT("invalid animation") );
return M_ANIMDATA->GetFrameSize(frame); return M_ANIMDATA->GetFrameSize(frame);
} }
wxAnimationDisposal wxAnimation::GetDisposalMethod(size_t frame) const wxAnimationDisposal wxAnimation::GetDisposalMethod(unsigned int frame) const
{ {
wxCHECK_MSG( IsOk(), wxANIM_UNSPECIFIED, wxT("invalid animation") ); wxCHECK_MSG( IsOk(), wxANIM_UNSPECIFIED, wxT("invalid animation") );
return M_ANIMDATA->GetDisposalMethod(frame); return M_ANIMDATA->GetDisposalMethod(frame);
} }
wxColour wxAnimation::GetTransparentColour(size_t frame) const wxColour wxAnimation::GetTransparentColour(unsigned int frame) const
{ {
wxCHECK_MSG( IsOk(), wxNullColour, wxT("invalid animation") ); wxCHECK_MSG( IsOk(), wxNullColour, wxT("invalid animation") );
@@ -428,7 +428,7 @@ bool wxAnimationCtrl::Play(bool looped)
// wxAnimationCtrl - rendering methods // wxAnimationCtrl - rendering methods
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
bool wxAnimationCtrl::RebuildBackingStoreUpToFrame(size_t frame) bool wxAnimationCtrl::RebuildBackingStoreUpToFrame(unsigned int frame)
{ {
// if we've not created the backing store yet or it's too // if we've not created the backing store yet or it's too
// small, then recreate it // small, then recreate it
@@ -451,7 +451,7 @@ bool wxAnimationCtrl::RebuildBackingStoreUpToFrame(size_t frame)
DisposeToBackground(dc); DisposeToBackground(dc);
// Draw all intermediate frames that haven't been removed from the animation // Draw all intermediate frames that haven't been removed from the animation
for (size_t i = 0; i < frame; i++) for (unsigned int i = 0; i < frame; i++)
{ {
if (m_animation.GetDisposalMethod(i) == wxANIM_DONOTREMOVE || if (m_animation.GetDisposalMethod(i) == wxANIM_DONOTREMOVE ||
m_animation.GetDisposalMethod(i) == wxANIM_UNSPECIFIED) m_animation.GetDisposalMethod(i) == wxANIM_UNSPECIFIED)
@@ -557,7 +557,7 @@ void wxAnimationCtrl::DisplayStaticImage()
Refresh(); Refresh();
} }
void wxAnimationCtrl::DrawFrame(wxDC &dc, size_t frame) void wxAnimationCtrl::DrawFrame(wxDC &dc, unsigned int frame)
{ {
// PERFORMANCE NOTE: // PERFORMANCE NOTE:
// this draw stuff is not as fast as possible: the wxAnimationDecoder // this draw stuff is not as fast as possible: the wxAnimationDecoder

2
src/gtk/animate.cpp
View File

@@ -150,7 +150,7 @@ bool wxAnimation::Load(wxInputStream &stream, wxAnimationType type)
return true; return true;
} }
wxImage wxAnimation::GetFrame(size_t i) const wxImage wxAnimation::GetFrame(unsigned int WXUNUSED(frame)) const
{ {
return wxNullImage; return wxNullImage;
} }