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}
\constfunc{int}{GetDelay}{\param{size\_t }{i}}
\constfunc{int}{GetDelay}{\param{unsigned int }{i}}
Returns the delay for the i-th frame in milliseconds.
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}
\constfunc{size\_t}{GetFrameCount}{\void}
\constfunc{unsigned int}{GetFrameCount}{\void}
Returns the number of frames for this animation.
\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}.

48
include/wx/anidecod.h
View File

@@ -30,8 +30,30 @@ WX_DECLARE_EXPORTED_OBJARRAY(wxImage, wxImageArray);
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
// 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.
@@ -44,31 +66,7 @@ private:
// this is the wxCURHandler used to load the ICON chunk of the ANI files
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)
};

28
include/wx/animate.h
View File

@@ -9,8 +9,8 @@
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_ANIMATEH__
#define _WX_ANIMATEH__
#ifndef _WX_ANIMATE_H_
#define _WX_ANIMATE_H_
#include "wx/defs.h"
@@ -39,14 +39,16 @@ public:
virtual bool IsOk() const = 0;
// 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 wxImage GetFrame(size_t i) const = 0;
virtual unsigned int GetFrameCount() const = 0;
virtual wxImage GetFrame(unsigned int frame) const = 0;
virtual wxSize GetSize() const = 0;
virtual bool LoadFile(const wxString &name, wxAnimationType type = wxANIMATION_TYPE_ANY) = 0;
virtual bool Load(wxInputStream &stream, wxAnimationType type = wxANIMATION_TYPE_ANY) = 0;
virtual bool LoadFile(const wxString& name,
wxAnimationType type = wxANIMATION_TYPE_ANY) = 0;
virtual bool Load(wxInputStream& stream,
wxAnimationType type = wxANIMATION_TYPE_ANY) = 0;
protected:
DECLARE_ABSTRACT_CLASS(wxAnimationBase)
@@ -68,11 +70,11 @@ protected:
class WXDLLIMPEXP_ADV wxAnimationCtrlBase : public wxControl
{
public:
wxAnimationCtrlBase() {}
wxAnimationCtrlBase() { }
public: // public API
virtual bool LoadFile(const wxString& filename, wxAnimationType type = wxANIMATION_TYPE_ANY) = 0;
// public API
virtual bool LoadFile(const wxString& filename,
wxAnimationType type = wxANIMATION_TYPE_ANY) = 0;
virtual void SetAnimation(const wxAnimation &anim) = 0;
virtual wxAnimation GetAnimation() const = 0;
@@ -117,6 +119,6 @@ private:
#include "wx/generic/animate.h"
#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
{
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:
wxAnimationDecoder()
{
m_background = wxNullColour;
m_nFrames = 0;
}
~wxAnimationDecoder() {}
virtual ~wxAnimationDecoder() { }
virtual bool Load( wxInputStream& stream ) = 0;
@@ -136,7 +102,42 @@ public:
virtual wxAnimationType GetType() const = 0;
// 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
{ return m_refData != NULL; }
virtual size_t GetFrameCount() const;
virtual int GetDelay(size_t i) const;
virtual wxImage GetFrame(size_t i) const;
virtual unsigned int GetFrameCount() const;
virtual int GetDelay(unsigned int i) const;
virtual wxImage GetFrame(unsigned int i) const;
virtual wxSize GetSize() const;
virtual bool LoadFile(const wxString& filename,
@@ -36,12 +36,11 @@ public:
virtual bool Load(wxInputStream& stream,
wxAnimationType type = wxANIMATION_TYPE_ANY);
public: // extended interface used by the generic implementation of wxAnimationCtrl
wxPoint GetFramePosition(size_t frame) const;
wxSize GetFrameSize(size_t frame) const;
wxAnimationDisposal GetDisposalMethod(size_t frame) const;
wxColour GetTransparentColour(size_t frame) const;
// extended interface used by the generic implementation of wxAnimationCtrl
wxPoint GetFramePosition(unsigned int frame) const;
wxSize GetFrameSize(unsigned int frame) const;
wxAnimationDisposal GetDisposalMethod(unsigned int frame) const;
wxColour GetTransparentColour(unsigned int frame) const;
wxColour GetBackgroundColour() const;
protected:
@@ -147,14 +146,14 @@ protected: // internal utilities
void DisposeToBackground(wxDC& dc, const wxPoint &pos, const wxSize &sz);
void IncrementalUpdateBackingStore();
bool RebuildBackingStoreUpToFrame(size_t);
void DrawFrame(wxDC &dc, size_t);
bool RebuildBackingStoreUpToFrame(unsigned int);
void DrawFrame(wxDC &dc, unsigned int);
virtual void DisplayStaticImage();
virtual wxSize DoGetBestSize() const;
protected:
size_t m_currentFrame; // Current frame
unsigned int m_currentFrame; // Current frame
bool m_looped; // Looped, or not
wxTimer m_timer; // The timer
wxAnimation m_animation; // The animation

91
include/wx/gifdecod.h
View File

@@ -8,8 +8,8 @@
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GIFDECOD_H
#define _WX_GIFDECOD_H
#ifndef _WX_GIFDECOD_H_
#define _WX_GIFDECOD_H_
#include "wx/defs.h"
@@ -20,7 +20,7 @@
#include "wx/animdecod.h"
// 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
// 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,
// the stream will not be correctly positioned. the
// the stream will not be correctly positioned.
//
enum wxGIFErrorCode
{
wxGIF_OK = 0, /* everything was OK */
wxGIF_INVFORMAT, /* error in gif header */
wxGIF_MEMERR, /* error allocating memory */
wxGIF_TRUNCATED /* file appears to be truncated */
wxGIF_OK = 0, // everything was OK
wxGIF_INVFORMAT, // error in GIF header
wxGIF_MEMERR, // error allocating memory
wxGIF_TRUNCATED // file appears to be truncated
};
#define MAX_BLOCK_SIZE 256 /* max. block size */
// --------------------------------------------------------------------------
// wxGIFDecoder class
// --------------------------------------------------------------------------
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:
// constructor, destructor, etc.
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():
wxGIFErrorCode LoadGIF( wxInputStream& stream );
// free all internal frames
void Destroy();
public: // implementation of wxAnimationDecoder's pure virtuals
// implementation of wxAnimationDecoder's pure virtuals
virtual bool CanRead( wxInputStream& stream ) const;
virtual bool Load( wxInputStream& stream )
{ return LoadGIF(stream) == wxGIF_OK; }
bool ConvertToImage(size_t frame, wxImage *image) const;
bool ConvertToImage(unsigned int frame, wxImage *image) const;
wxAnimationDecoder *Clone() const
{ return new wxGIFDecoder; }
@@ -108,9 +87,23 @@ public: // implementation of wxAnimationDecoder's pure virtuals
{ return wxANIMATION_TYPE_GIF; }
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)
};
#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:
virtual size_t GetFrameCount() const
{ return 0; }
virtual wxImage GetFrame(size_t i) const;
virtual unsigned int GetFrameCount() const { return 0; }
virtual wxImage GetFrame(unsigned int frame) const;
// we can retrieve the delay for a frame only after building
// a GdkPixbufAnimationIter...
virtual int GetDelay(size_t i) const
{ return 0; }
virtual int GetDelay(unsigned int frame) const { return 0; }
virtual wxSize GetSize() const;

30
src/common/anidecod.cpp
View File

@@ -35,10 +35,10 @@ wxCURHandler wxANIDecoder::sm_handler;
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;
};
@@ -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
return image->IsOk();
}
@@ -73,32 +73,32 @@ bool wxANIDecoder::ConvertToImage(size_t frame, wxImage *image) const
// 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(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())
return wxNullColour;
@@ -205,7 +205,7 @@ bool wxANIDecoder::Load( wxInputStream& stream )
{
wxInt32 FCC1, FCC2;
wxUint32 datalen;
size_t globaldelay=0;
unsigned int globaldelay=0;
wxInt32 riff32;
memcpy( &riff32, "RIFF", 4 );
@@ -278,7 +278,7 @@ bool wxANIDecoder::Load( wxInputStream& stream )
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);
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
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);
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
// 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;

205
src/common/gifdecod.cpp
View File

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

20
src/generic/animateg.cpp
View File

@@ -51,14 +51,14 @@ wxSize wxAnimation::GetSize() const
return M_ANIMDATA->GetAnimationSize();
}
size_t wxAnimation::GetFrameCount() const
unsigned int wxAnimation::GetFrameCount() const
{
wxCHECK_MSG( IsOk(), 0, wxT("invalid animation") );
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") );
@@ -68,35 +68,35 @@ wxImage wxAnimation::GetFrame(size_t i) const
return ret;
}
int wxAnimation::GetDelay(size_t i) const
int wxAnimation::GetDelay(unsigned int i) const
{
wxCHECK_MSG( IsOk(), 0, wxT("invalid animation") );
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") );
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") );
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") );
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") );
@@ -428,7 +428,7 @@ bool wxAnimationCtrl::Play(bool looped)
// 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
// small, then recreate it
@@ -451,7 +451,7 @@ bool wxAnimationCtrl::RebuildBackingStoreUpToFrame(size_t frame)
DisposeToBackground(dc);
// 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 ||
m_animation.GetDisposalMethod(i) == wxANIM_UNSPECIFIED)
@@ -557,7 +557,7 @@ void wxAnimationCtrl::DisplayStaticImage()
Refresh();
}
void wxAnimationCtrl::DrawFrame(wxDC &dc, size_t frame)
void wxAnimationCtrl::DrawFrame(wxDC &dc, unsigned int frame)
{
// PERFORMANCE NOTE:
// 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;
}
wxImage wxAnimation::GetFrame(size_t i) const
wxImage wxAnimation::GetFrame(unsigned int WXUNUSED(frame)) const
{
return wxNullImage;
}