\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.
\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}.
class WXDLLEXPORT wxANIDecoder : public wxAnimationDecoder
{
-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.
- wxImageArray m_images;
-
- // the info about each image stored in m_images.
- // NB: m_info.GetCount() may differ from m_images.GetCount()!
- wxANIFrameInfoArray m_info;
-
- // 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 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(size_t frame, wxImage *image) const;
+ bool ConvertToImage(unsigned int frame, wxImage *image) const;
wxAnimationDecoder *Clone() const
{ return new wxANIDecoder; }
{ 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.
+ wxImageArray m_images;
+
+ // the info about each image stored in m_images.
+ // NB: m_info.GetCount() may differ from m_images.GetCount()!
+ wxANIFrameInfoArray m_info;
+
+ // this is the wxCURHandler used to load the ICON chunk of the ANI files
+ static wxCURHandler sm_handler;
+
+
DECLARE_NO_COPY_CLASS(wxANIDecoder)
};
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifndef _WX_ANIMATEH__
-#define _WX_ANIMATEH__
+#ifndef _WX_ANIMATE_H_
+#define _WX_ANIMATE_H_
#include "wx/defs.h"
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)
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;
#include "wx/generic/animate.h"
#endif
-#endif // wxUSE_ANIMATIONCTRL
+#endif // wxUSE_ANIMATIONCTRL
-#endif // _WX_ANIMATEH__
+#endif // _WX_ANIMATE_H_
class WXDLLEXPORT wxAnimationDecoder : public wxObjectRefData
{
-protected:
- wxSize m_szAnimation;
- size_t m_nFrames;
+public:
+ wxAnimationDecoder()
+ {
+ m_background = wxNullColour;
+ m_nFrames = 0;
+ }
+ virtual ~wxAnimationDecoder() { }
+
+
+ virtual bool Load( wxInputStream& stream ) = 0;
+ virtual bool CanRead( wxInputStream& stream ) const = 0;
+
+ virtual wxAnimationDecoder *Clone() const = 0;
+ virtual wxAnimationType GetType() const = 0;
+
+ // convert given frame to wxImage
+ virtual bool ConvertToImage(unsigned int frame, wxImage *image) const = 0;
- // 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
+ // 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;
+ 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(size_t frame) const = 0;
+ virtual wxPoint GetFramePosition(unsigned int frame) const = 0;
// what should be done after displaying this frame.
- virtual wxAnimationDisposal GetDisposalMethod(size_t frame) const = 0;
+ 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(size_t frame) const = 0;
+ virtual long GetDelay(unsigned int frame) const = 0;
// the transparent colour for this frame if any or wxNullColour.
- virtual wxColour GetTransparentColour(size_t frame) const = 0;
+ virtual wxColour GetTransparentColour(unsigned int 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; }
+ unsigned int GetFrameCount() const { return m_nFrames; }
-public:
- wxAnimationDecoder()
- {
- m_background = wxNullColour;
- m_nFrames = 0;
- }
- ~wxAnimationDecoder() {}
-
-
- virtual bool Load( wxInputStream& stream ) = 0;
- virtual bool CanRead( wxInputStream& stream ) const = 0;
-
- virtual wxAnimationDecoder *Clone() const = 0;
- virtual wxAnimationType GetType() const = 0;
+protected:
+ wxSize m_szAnimation;
+ unsigned int m_nFrames;
- // convert given frame to wxImage
- virtual bool ConvertToImage(size_t frame, wxImage *image) const = 0;
+ // 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;
};
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,
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:
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
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifndef _WX_GIFDECOD_H
-#define _WX_GIFDECOD_H
+#ifndef _WX_GIFDECOD_H_
+#define _WX_GIFDECOD_H_
#include "wx/defs.h"
#include "wx/animdecod.h"
// internal utility used to store a frame in 8bit-per-pixel format
-class /*WXDLLEXPORT*/ GIFImage;
+class 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:
+ // constructor, destructor, etc.
+ wxGIFDecoder();
+ ~wxGIFDecoder();
+
// 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;
+ 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(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 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; }
-public:
- // constructor, destructor, etc.
- wxGIFDecoder();
- ~wxGIFDecoder();
-
// 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; }
{ 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_
// 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;
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;
};
{
}
-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(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;
{
wxInt32 FCC1, FCC2;
wxUint32 datalen;
- size_t globaldelay=0;
+ unsigned int globaldelay=0;
wxInt32 riff32;
memcpy( &riff32, "RIFF", 4 );
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;
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);
{
// 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;
// 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)
};
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);
// 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());
dst = image->GetData();
transparent = GetTransparentColourIndex(frame);
- /* set transparent colour mask */
+ // set transparent colour mask
if (transparent != -1)
{
for (i = 0; i < GetNcolours(frame); i++)
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++)
{
// 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;
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); }
//
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();
break;
}
- /* prefetch data */
+ // prefetch data
stream.Read((void *) m_buffer, m_restbyte);
if (stream.LastRead() != m_restbyte)
{
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;
// 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;
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;
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];
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
}
}
- /* 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];
if (interl)
{
- /* support for interlaced images */
+ // support for interlaced images
switch (pass)
{
case 1: y += 8; break;
}
else
{
- /* non-interlaced */
+ // non-interlaced
y++;
/*
Normally image decoding is finished when an End of Information code is
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)
{
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)
{
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)
{
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;
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)
{
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)
{
}
}
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)
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)
{
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))
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)
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)
{
return wxGIF_INVFORMAT;
}
- /* decode image */
+ // decode image
wxGIFErrorCode result = dgif(stream, pimg, interl, bits);
if (result != wxGIF_OK)
{
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;
}
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())
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))
}
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)
{
return wxGIF_INVFORMAT;
}
- /* local color map */
+ // local color map
if ((buf[8] & 0x80) == 0x80)
{
unsigned int local_ncolors = 2 << (buf[8] & 0x07);
stream.SeekI(numBytes, wxFromCurrent);
}
- /* initial code size */
+ // initial code size
(void) stream.GetC();
if (stream.Eof() || (stream.LastRead() == 0))
{
return wxGIF_INVFORMAT;
}
- /* skip all data */
+ // skip all data
while ((i = (unsigned char)stream.GetC()) != 0)
{
if (stream.Eof() || (stream.LastRead() == 0))
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 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") );
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") );
// 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
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)
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
return true;
}
-wxImage wxAnimation::GetFrame(size_t i) const
+wxImage wxAnimation::GetFrame(unsigned int WXUNUSED(frame)) const
{
return wxNullImage;
}
projects / wxWidgets.git / commitdiff
