xref: /dports/graphics/sswf/sswf-1.8.4/include/sswf/libsswf.h

/* libsswf.h -- written by Alexis WILKE for Made to Order Software Corp. (c) 2002-2009 */
#ifndef LIBSSWF_H
#define	LIBSSWF_H

/*

Copyright (c) 2002-2009 Made to Order Software Corp.

Permission is hereby granted, free of charge, to any
person obtaining a copy of this software and
associated documentation files (the "Software"), to
deal in the Software without restriction, including
without limitation the rights to use, copy, modify,
merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom
the Software is furnished to do so, subject to the
following conditions:

The above copyright notice and this permission notice
shall be included in all copies or substantial
portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

*/

/** \file
 *
 * \brief The header to include to use the SSWF C++ library
 *
 * The libsswf.h file includes all the necessary classes
 * for the SSWF library.
 */



#include	<stdarg.h>
#include	<stdio.h>
#include	<stdlib.h>
#ifndef _MSVC
#include	<unistd.h>
#endif
#include	<string.h>
#include	<limits.h>
#include	<errno.h>
#include	<zlib.h>
#include	<math.h>
#include	<ctype.h>
#include	<wctype.h>
#ifdef STATIC_ICONV
#include	<iconv.h.static>
#else
#include	<iconv.h>
#endif

#if IRIX
#include	<sys/endian.h>
#endif

#include	"sswf/libsswf-config.h"

#ifndef	M_PI
#define	M_PI		3.14159265358979323846
#endif


#ifdef _MSVC
#define	strcasecmp	stricmp
#define	rint(x)		((double) (long) floor(x + 0.5))
#endif

#if defined(_LIBICONV_VERSION) && _LIBICONV_VERSION < 0x010B
#define	ICONV_INPUT_CAST
#else
/* older versions of iconv() were broken in regard to the
 * input buffer which wasn't const; newer versions have the
 * _LIBICONV_H #define at the start so this is good to know
 * whether we have to cast or not.
 */
#define	ICONV_INPUT_CAST	(char**)
#endif



/* The following I use to tell my C++ to C tool
 * what needs to be exposed in C & PHP.
 * These macros show you what is equivalent in C++
 *
 * exposed_class	A class we want exposed in C.
 *
 * invisible		Members which are public in C++ but
 *			not exposed to C users.
 */
#define	exposed_class	class
#define	invisible	public



/** \brief The C++ SSWF library namespace
 *
 * The SSWF library is fully defined with the 'sswf' namespace.
 *
 * Do 'using namespace sswf;' to "get rid of it".
 *
 * The SSWF library is a full set of classes and functions used to create
 * SWF binary files. The library supports most of the tags available in
 * SWF and is used to compress them in the appropriate format for use
 * by a Flash player.
 *
 * One important point about this library: it hides from you, the user,
 * the lower layers of the SWF tags. For one thing, you will never have
 * to worry about how to compress the data in a valid SWF tag. But not
 * only that, the library takes care of selecting the appropriate tag
 * depending on the output movie version and what each tag support.
 *
 * For instance, when you create a TagFont, the library hides from you
 * the fact that it supports 3 different types of DefineFont tags (and
 * once version 8 is supported, it will hide the DefineFontAlignZones).
 * This means you don't need to know all the details of how to create
 * a font. Such details are important for the library, but not to you.
 *
 * None the less, it is complicated to create a valid SWF shape and the
 * library does not do that automatically for you. For more information
 * about each specific tag, please read the corresponding documentation.
 */
namespace sswf
{




void assert(int cond, const char *format, ...)
#ifndef _MSVC
			__attribute__ ((format (printf, 2, 3)))
#endif
		;


#if DEBUG
inline void assert(int cond, const char *format, ...)
{
	va_list		ap;

	// if the condition is true then we have no problem!
	if(cond) {
		return;
	}
	fflush(stdout);
	fflush(stderr);
	fprintf(stderr, "\n");
	va_start(ap, format);
	vfprintf(stderr, format, ap);
	va_end(ap);
	fprintf(stderr, ".\n");
	fflush(stderr);		// some systems don't do this inside the abort()!
	abort();
}
#else
inline void assert(int /*cond*/, const char * /*format*/, ...) {}
#endif


typedef	unsigned short		sswf_id_t;		// object ID reference
typedef	unsigned short		sswf_frame_t;		// frame counter
typedef	int32_t			sswf_ucs4_t;		// a wide character (must be at least 32 bits)


#define	SSWF_ID_NONE		((sswf_id_t) -1)	// this is an invalid ID (it seems)


extern	void			swap(void *s1, void *s2, size_t size);
extern	int			wctomb(const sswf_ucs4_t *wc, size_t wc_len, char *mb, size_t& mb_size);
extern	int			mbtowc(const char *mb, size_t mb_len, sswf_ucs4_t *& wc, size_t& wc_len);
extern	char *			wcname(sswf_ucs4_t wc, char *result);
extern	long			wcslen(sswf_ucs4_t *wcstr);

inline unsigned short		swap_short(unsigned short s)
				{
					return (s >> 8) | (s << 8);
				}

inline unsigned int		swap_int(unsigned int l)
				{
					return (l >> 24) | (l << 24)
						| ((l >> 8) & 0x0000FF00)
						| ((l << 8) & 0x00FF0000);
				}

extern	const char *		sswf_version(void);




/*
 * Your class derives from ErrorManager::ErrorHandler, you pass a pointer
 * to the TagHeader object and whenever an error occurs in the SSWF
 * library, the OnError() function is called. You can then decide what to do
 * (i.e. print the message in a file and then throw, exit or return...)
 */
exposed_class ErrorManager
{
public:
	enum error_code_t {
		ERROR_CODE_NONE = 0,

		ERROR_CODE_ACTION_OVERFLOW,
		ERROR_CODE_ALPHA_MISMATCH,
		ERROR_CODE_BAD_STATE_FLAGS,
		ERROR_CODE_BUTTON_MISSING_STATE,
		ERROR_CODE_CANNOT_CHANGE_STYLE,
		ERROR_CODE_CHILDREN_NOT_SUPPORTED,
		ERROR_CODE_COMPRESSED_SOUND_8BITS,
		ERROR_CODE_EMPTY_POSITION_RANGE,
		ERROR_CODE_ENDED_ACTION_SCRIPT,
		ERROR_CODE_ENHANCED_LINE_REQUIRES_ALPHA,
		ERROR_CODE_ENVELOPE_EXISTS,
		ERROR_CODE_ENVELOPE_OVERFLOW,
		ERROR_CODE_FILE_NOT_FOUND,
		ERROR_CODE_FORMAT_LOCKED,
		ERROR_CODE_GLYPH_DEFINED_TWICE,
		ERROR_CODE_ICONV_ENCODER_NOT_AVAILABLE,
		ERROR_CODE_ICONV_FAILED,
		ERROR_CODE_IO,
		ERROR_CODE_INCOMPATIBLE_CHILD,
		ERROR_CODE_INCOMPATIBLE_MORPH,
		ERROR_CODE_INTERNAL_ERROR,
		ERROR_CODE_INVALID_DEPTH,
		ERROR_CODE_INVALID_EM_SQUARE,
		ERROR_CODE_INVALID_FILL_PARAMETER,
		ERROR_CODE_INVALID_FOCAL,
		ERROR_CODE_INVALID_GLYPH,
		ERROR_CODE_INVALID_IDENTIFIER,
		ERROR_CODE_INVALID_IMAGE,
		ERROR_CODE_INVALID_INTERPOLATION_MODE,
		ERROR_CODE_INVALID_LINE_INFO,
		ERROR_CODE_INVALID_MORPH_INDEX,
		ERROR_CODE_INVALID_OBJECT_EXPORTED,
		ERROR_CODE_INVALID_POSITION,
		ERROR_CODE_INVALID_SHAPE,
		ERROR_CODE_INVALID_SPREAD_MODE,
		ERROR_CODE_INVALID_STYLE,
		ERROR_CODE_INVALID_TEXT_SETUP,
		ERROR_CODE_JPEG,
		ERROR_CODE_LOOP_ZERO,
		ERROR_CODE_MISSING_FRAME_NAME,
		ERROR_CODE_MISSING_SHAPE,
		ERROR_CODE_MORPH_GRADIENT_LIMIT,
		ERROR_CODE_MORPH_REQUIRES_ALPHA,
		ERROR_CODE_NAME_TOO_LONG,
		ERROR_CODE_NEGATIVE_MITER,
		ERROR_CODE_NO_FOCAL_WITH_MORPH,
		ERROR_CODE_NO_HEADER,
		ERROR_CODE_NO_STATES,
		ERROR_CODE_NO_SUCH_GLYPH,
		ERROR_CODE_LABEL_NOT_FOUND,
		ERROR_CODE_LABEL_OVERFLOW,
		ERROR_CODE_MORPH_MISMATCH,
		ERROR_CODE_OBJECT_NOT_FOUND,
		ERROR_CODE_REGISTER_OVERFLOW,
		ERROR_CODE_SIZE_MISMATCH,
		ERROR_CODE_START_SOUND_NO_INFO,
		ERROR_CODE_TOO_MANY_STYLES,
		ERROR_CODE_TWO_OR_MORE_JPEGTABLES,
		ERROR_CODE_TWO_OR_MORE_METADATA,
		ERROR_CODE_UNEXPECTED_EVENT_FLAG,
		ERROR_CODE_UNKNOWN_FORMAT,
		ERROR_CODE_UNKNOWN_OBJECT_EXPORTED,
		ERROR_CODE_UNSUPPORTED_IMAGE_FORMAT,
		ERROR_CODE_UNSUPPORTED_SOUND_FORMAT,
		ERROR_CODE_VERSION_UNSATISFIED,
		ERROR_CODE_VOLUME_OUT_OF_RANGE,

		ERROR_CODE_max
	};

				ErrorManager(void);

	void			Reset(void);
	int			Count(void) const;
	static error_code_t	KeepFirst(error_code_t a, error_code_t b);

	error_code_t		OnError(error_code_t errcode, const char *message, va_list ap) const;

invisible:
	class InternalErrorException {};

	class ErrorHandler
	{
	public:
		virtual			~ErrorHandler();
		virtual error_code_t	OnError(error_code_t errcode, const char *msg) = 0;
	};

	ErrorHandler *		SetErrorHandler(ErrorHandler *error_handler);
	error_code_t		OnError(error_code_t errcode, const char *message, ...) const;

private:
	mutable int		f_error_count;
	ErrorHandler *		f_error_handler;
};






class Buffer;
class MemBuffer
{
public:
				MemBuffer(void);
	virtual			~MemBuffer();

	void			AttachBuffer(Buffer *buffer);
	Buffer *		GetBuffer(void) const;

private:
	Buffer *		f_buffer;
};


class Buffer
{
public:
				Buffer(Buffer **head, size_t size, const char *info);
				Buffer(Buffer **head, MemBuffer *ptr, size_t size, const char *info);
				//Buffer(Buffer **head, void *ptr, size_t size, const char *info);
				~Buffer();

	void *			Realloc(size_t size);
	void *			Data(void) const { return f_data; }
	Buffer *		Next(void) const { return (Buffer *) f_next; }
	Buffer *		Previous(void) const { return (Buffer *) f_previous; }
	size_t			Size(void) const { return f_size; }
	const char *		Info(void) const { return f_info; }

	static Buffer *		FindBuffer(void *ptr);
#if 0
// this is totally wrong and it simply can't be used safely
	static bool		IsBuffer(void *ptr);
#endif

private:
	/// Hold the magic and a pointer to the actual buffer
	struct mem_buffer_t {
		unsigned long	f_magic;	// to make sure we have indeed a valid buffer
		Buffer *	f_buffer;	// reference back to 'this' buffer
	};
	enum {
		DMAGIC = (unsigned long) 0x53535746,	// direct (malloc)
		OMAGIC = (unsigned long) 0x5353574F	// object (new/delete)
	};
#define	SSWF_ALIGN(value, modulo)	(((value) + ((modulo) - 1)) & - (long) (modulo))
#define	SSWF_SPACE			SSWF_ALIGN(sizeof(mem_buffer_t), sizeof(double))
#if DEBUG
	void				Test(void);
#define SSWF_SAFE			(sizeof(double) * 32)
#define	SSWF_TEST			((long)0xBADC0FFE)
#else
#define	SSWF_SAFE			0
#endif

	Buffer **		f_head;		// header for this list of buffers
	Buffer *		f_next;
	Buffer *		f_previous;
	const char *		f_info;
	size_t			f_size;
	mutable void *		f_data;
};


class MemoryManager
{
public:
				MemoryManager(void);
	virtual			~MemoryManager();

	void			MemAttach(MemBuffer *ptr, size_t size, const char *info);	// used when you require the use of a ::new ... call
	void *			MemAlloc(size_t size, const char *info);
	void *			MemRealloc(void *ptr, size_t size, const char *info);	// info used ONLY if ptr == 0
	void			MemFree(void *ptr);
	void			MemClean(void *ptr);
	char *			StrDup(const char *string);
	char *			StrCat(const char *s1, const char *s2);
#if DEBUG
	void			MemTest(void *ptr);
#endif
	unsigned long		Size(void *ptr);

private:
	Buffer *		f_head;
};



exposed_class ItemBase : public MemBuffer
{
invisible:
				ItemBase(void) {}
	virtual			~ItemBase() {}
};


exposed_class Vectors : public MemoryManager, public MemBuffer
{
public:
				Vectors(void);
				Vectors(const Vectors& vector);
				~Vectors();

	ItemBase *		Get(int index) const;
	void			Set(int index, ItemBase *vector);
	void			Insert(int index, ItemBase *vector);
	void			SetSize(int size);
	int			Count(void) const { return f_count; }
	void			Empty(void) { f_count = 0; }	// currently we keep the f_vectors buffer

invisible:
	Vectors&		operator = (const Vectors& vectors);

private:
	int			f_count;		// # of valid pointers
	int			f_max;			// max. # of pointers until realloc
	ItemBase **		f_vectors;		// an array of pointers
};







exposed_class Data : public MemoryManager
{
public:
				Data(void);
				~Data();

	void			Empty(void) { f_pos = 0; }		// make the buffer empty (reset/restart)
	void			Align(void);				// align to the next byte
	void			Overwrite(size_t offset, const void *ptr, size_t size);
	void			OverwriteByte(size_t offset, char c);
	void			OverwriteShort(size_t offset, short s);
	void			OverwriteLong(size_t offset, long l);
	void			Write(const void *ptr, size_t size);	// write bytes
	void			WriteBits(long value, size_t bits);	// write the 'bits' lower bits of 'value'
	void			PutByte(char c);			// write one byte
	void			PutShort(short s);			// write one short (auto-swap)
	void			PutLong(long l);			// write one long, 32 bits (auto-swap)
	void			PutDLong(int64_t ll);			// write one long, 64 bits (auto-swap)
	void			PutShortFloat(float f);			// write one float, 16 bits (auto-conversion)
	void			PutLongFloat(float f);			// write one float, 32 bits (auto-swap)
	void			PutDoubleFloat(double f);		// write one float, 64 bits (auto-swap)
	void			PutString(const char *string);		// write a null terminated string (including the terminator)
	void			Append(const Data& append);		// append another data buffer in here

	void			Read(void *& ptr, size_t& size);	// retrieve the buffer and its size rounded up to the next byte (Align() is called once)
									// if you want the size in bits, use the Size() function call

	unsigned long		ByteSize(void) const { return (f_pos + CHAR_BIT - 1) / CHAR_BIT; }
	unsigned long		GetSize(void) const { return f_pos; }	// total size in bits
	void			SetSize(unsigned long size);

private:
	void			AdjustSize(size_t size);

	unsigned long		f_pos;
	unsigned long		f_size;
	char *			f_data;
};






// the following are structures used within the tags defined afterward
exposed_class SRectangle
{
public:
				SRectangle(void);

	void			Reset(void);
	void			Set(long xmin, long xmax, long ymin, long ymax);
	void			SetReorder(long xmin, long xmax, long ymin, long ymax);
	long			XMin(void) const;
	long			XMax(void) const;
	long			YMin(void) const;
	long			YMax(void) const;
	bool			IsEmpty(void) const;

	void			Save(Data& data) const;

private:
	long			f_xmin;
	long			f_xmax;
	long			f_ymin;
	long			f_ymax;
};


exposed_class Color
{
public:
				Color(void) { Reset(); }

	void			Reset(void);
	void			Set(unsigned char red, unsigned char green, unsigned char blue, unsigned char alpha = 255);
	unsigned char		Red(void)   const { return f_red;   }
	unsigned char		Green(void) const { return f_green; }
	unsigned char		Blue(void)  const { return f_blue;  }
	unsigned char		Alpha(void) const { return f_alpha; }

	void			Save(Data& data, bool save_alpha = true);

	bool			IsSolid(void) const { return f_alpha == 255; }
	bool			IsInvisible(void) const { return f_alpha == 0; }

invisible:
	bool			operator == (const Color& color) const;
	bool			operator != (const Color& color) const;

private:
	unsigned char		f_red;
	unsigned char		f_green;
	unsigned char		f_blue;
	unsigned char		f_alpha;
};



exposed_class ColorTransform
{
public:
				ColorTransform(void);

	void			Reset(void);
	void			SetAdd(double red, double green, double blue, double alpha = 0.0);
	void			SetMult(double red, double green, double blue, double alpha = 1.0);
	double			AddRed(void)    const { return f_add_red;   }
	double			AddGreen(void)  const { return f_add_green; }
	double			AddBlue(void)   const { return f_add_blue;  }
	double			AddAlpha(void)  const { return f_add_alpha; }
	double			MultRed(void)   const { return f_add_red;   }
	double			MultGreen(void) const { return f_add_green; }
	double			MultBlue(void)  const { return f_add_blue;  }
	double			MultAlpha(void) const { return f_add_alpha; }

	void			Save(Data& data, bool save_alpha = true);

	bool			IsNull(bool with_alpha) const;		// if true we can ignore this transformation!
	bool			IsSolidCompatible(void) const;		// if true we can ignore the alpha channel!

private:
	double			f_add_red;
	double			f_add_green;
	double			f_add_blue;
	double			f_add_alpha;
	double			f_mult_red;
	double			f_mult_green;
	double			f_mult_blue;
	double			f_mult_alpha;
};



exposed_class Matrix
{
public:
				Matrix(void);

	void			Reset(void);
	void			SetScale(double x, double y) { f_scale_x = x; f_scale_y = y; }
	void			SetScale(double scale) { f_scale_x = scale; f_scale_y = scale; }
	void			SetRotate(double rotate);
	void			SetSkew(double skew0, double skew1) { f_skew_0 = skew0; f_skew_1 = skew1; }
	void			SetTranslate(long x, long y) { f_translate_x = x; f_translate_y = y; }

	void			Save(Data& data);

	bool			IsNull(void) const;

invisible:
	bool			operator == (const Matrix& matrix) const;
	bool			operator != (const Matrix& matrix) const;

private:
	/// Matrix of longs; used to compute the matrix to be saved in the movie
	struct signed_matrix_t {
		long	m[4];
	};

	void			ComputeMatrix(signed_matrix_t& m) const;

	double			f_scale_x;
	double			f_scale_y;
	double			f_rotate;
	long			f_translate_x;
	long			f_translate_y;
	double			f_skew_0;
	double			f_skew_1;
};



exposed_class Envelope : public ItemBase
{
public:
				Envelope(unsigned long p, unsigned short l, unsigned short r);
				Envelope(const Envelope& envelope);

	unsigned long		Position(void) const;
	unsigned short		Left(void) const;
	unsigned short		Right(void) const;
	void			Save(Data& data) const;

private:
	unsigned long		f_position;
	unsigned short		f_left;
	unsigned short		f_right;
};


exposed_class SoundInfo : public MemoryManager
{
public:
				SoundInfo(ErrorManager& error_manager);

	void			SetSoundID(sswf_id_t id);
	void			StopSound(bool stop = true);
	void			NoMultiple(bool no_multiple = true);
	void			SetRange(unsigned long start, unsigned long end);
	void			SetLoop(unsigned short loop);
	void			AddEnvelope(const Envelope& envelope);

	ErrorManager::error_code_t PreSave(void);		// called by the TagStartSound::PreSave()
	void			Save(Data& data) const;

private:
	ErrorManager&		f_error_manager;	// the TagHeader
	sswf_id_t		f_sound_id;
	bool			f_stop;			// if true, ignore all the other info
	bool			f_no_multiple;		// never play this sound more than once
	unsigned long		f_start_position;	// start playing from this sample
	unsigned long		f_end_position;		// stop playing at this sample
	unsigned short		f_loop;			// repeat the sound this many times
	Vectors			f_envelopes;		// a list of position + volume information
};




exposed_class BlendMode
{
public:
	enum blend_mode_t {
		BLEND_MODE_UNDEFINED = -1,
		BLEND_MODE_NORMAL = 1,
		BLEND_MODE_LAYER = 2,
		BLEND_MODE_MULTIPLY = 3,
		BLEND_MODE_SCREEN = 4,
		BLEND_MODE_LIGHTEN = 5,
		BLEND_MODE_DARKEN = 6,
		BLEND_MODE_DIFFERENCE = 7,
		BLEND_MODE_ADD = 8,
		BLEND_MODE_SUBTRACT = 9,
		BLEND_MODE_INVERT = 10,
		BLEND_MODE_ALPHA = 11,
		BLEND_MODE_ERASE = 12,
		BLEND_MODE_OVERLAY = 13,
		BLEND_MODE_HARDLIGHT = 14
	};

				BlendMode(void);

	bool			HasBlendMode(void) const;
	void			SetBlendMode(blend_mode_t blend_mode_value);
	bool			SetBlendModeByName(const char *blend_mode_name);
	blend_mode_t		GetBlendMode(void) const;

	void			Save(Data& data);

private:
	blend_mode_t		f_blend_mode;
};


exposed_class State : public ItemBase
{
public:
	// Use with SetFlags()
	enum state_flags_t {
		STATE_FLAG_UP		= 0x01,
		STATE_FLAG_OVER		= 0x02,
		STATE_FLAG_DOWN		= 0x04,
		STATE_FLAG_HIT_TEST	= 0x08,

		STATE_ALL_FLAGS		= 0x0F
	};

	explicit		State(ErrorManager& error_manager);

	void			Reset(void);
	void			SetObjectID(sswf_id_t id);
	bool			SetFlags(unsigned char flags);
	void			SetLayer(unsigned short layer);
	void			SetMatrix(const Matrix& matrix);
	void			SetColorTransform(const ColorTransform& color_transform);
	bool			HasColorTransform(void) const;
	void			SetBlendMode(const BlendMode& blend_mode);
	ErrorManager::error_code_t Save(Data& data, bool color_transform = false);

	unsigned char		GetFlags(void) const;

private:
	ErrorManager&		f_error_manager;	// the TagHeader
	sswf_id_t		f_id;
	bool			f_has_color_transform;
	unsigned char		f_flags;
	unsigned short		f_layer;
	Matrix			f_matrix;
	ColorTransform		f_color_transform;
	BlendMode		f_blend_mode;
};





class Action;
exposed_class Event : public MemoryManager, public ItemBase
{
public:
				Event(void);

	void			Reset(void);
	void			SetEvents(unsigned long events);
	void			SetKey(unsigned char key);
	unsigned long		Events(void) const;	// PlaceObject2 flags
	unsigned long		Conditions(void) const;	// DefineButton2 flags
	unsigned char		Key(void) const;
	Vectors&		Actions(void);

	static unsigned long	StringToEvents(const char *s);
	static unsigned char	StringToKeyCode(const char *s);

	// the flags are saved with the following bits
	// in a PlaceObject2
	// these have to be converted when saved in a
	// DefineButton2 tag
	enum event_flag_t {
		EVENT_COND_MENU_LEAVE		= 0x80000000,	// for DefineButton2
		EVENT_COND_MENU_ENTER		= 0x40000000,	// for DefineButton2

		EVENT_CONSTRUCT			= 0x00040000,	// V7.x
		EVENT_KEY_PRESS			= 0x00020000,	// V6.x
		EVENT_POINTER_DRAG_LEAVE	= 0x00010000,	// V6.x shared with DefineButton2
		EVENT_POINTER_DRAG_ENTER	= 0x00008000,	// V5.x shared with DefineButton2
		EVENT_POINTER_LEAVE		= 0x00004000,	// V5.x shared with DefineButton2
		EVENT_POINTER_ENTER		= 0x00002000,	// V5.x shared with DefineButton2
		EVENT_POINTER_RELEASE_OUTSIDE	= 0x00001000,	// V5.x shared with DefineButton2
		EVENT_POINTER_RELEASE_INSIDE	= 0x00000800,	// V5.x shared with DefineButton2
		EVENT_POINTER_PUSH		= 0x00000400,	// V5.x shared with DefineButton2
		EVENT_INITIALIZE		= 0x00000200,	// V5.x
		EVENT_DATA			= 0x00000100,	// V5.x
		EVENT_KEY_UP			= 0x00000080,	// V6.x
		EVENT_KEY_DOWN			= 0x00000040,	// V6.x
		EVENT_POINTER_UP		= 0x00000020,	// V6.x
		EVENT_POINTER_DOWN		= 0x00000010,	// V6.x
		EVENT_POINTER_MOVE		= 0x00000008,	// V6.x
		EVENT_UNLOAD			= 0x00000004,	// V6.x
		EVENT_ENTER_FRAME		= 0x00000002,	// V6.x
		EVENT_ONLOAD			= 0x00000001	// V5.x
	};
#define	SSWF_EVENT_V5			0x0000FF01	// flags present in V5
#define	SSWF_EVENT_V6			0x000300FE	// flags added in V6
#define SSWF_EVENT_V7			0x00040000	// flag added in V7
#define	SSWF_EVENT_CONDITIONS		0xC001FC00	// flags used by conditions in DefineButton2
#define	SSWF_EVENT_COUNT		20
	struct event_names_t {
		event_flag_t		f_flag;
		const char *		f_name;
	};

	enum condition_flag_t {
		CONDITION_KEY_MASK			= 0xFE00,
		CONDITION_KEY_SHIFT			= 9,
		CONDITION_MENU_LEAVE			= 0x0100,	// OVER_DOWN_TO_IDLE
		CONDITION_MENU_ENTER			= 0x0080,	// IDLE_TO_OVER_DOWN
		CONDITION_POINTER_RELEASE_OUTSIDE	= 0x0040,	// OUT_DOWN_TO_IDLE
		CONDITION_POINTER_DRAG_ENTER		= 0x0020,	// OUT_DOWN_TO_OVER_DOWN
		CONDITION_POINTER_DRAG_LEAVE		= 0x0010,	// OVER_DOWN_TO_OUT_DOWN
		CONDITION_POINTER_RELEASE_INSIDE	= 0x0008,	// OVER_DOWN_TO_OVER_UP
		CONDITION_POINTER_PUSH			= 0x0004,	// OVER_UP_TO_OVER_DOWN
		CONDITION_POINTER_LEAVE			= 0x0002,	// OVER_UP_TO_IDLE
		CONDITION_POINTER_ENTER			= 0x0001	// IDLE_TO_OVER_UP
	};

	enum key_code_t {
		KEY_CODE_NONE = 0,
		KEY_CODE_LEFT_ARROW = 1,
		KEY_CODE_RIGHT_ARROW = 2,
		KEY_CODE_HOME = 3,
		KEY_CODE_END = 4,
		KEY_CODE_INSERT = 5,
		KEY_CODE_DELETE = 6,
		KEY_CODE_BACKSPACE = 8,
		KEY_CODE_ENTER = 13,
		KEY_CODE_UP_ARROW = 14,
		KEY_CODE_DOWN_ARROW = 15,
		KEY_CODE_PAGE_UP = 16,
		KEY_CODE_PAGE_DOWN = 17,
		KEY_CODE_TAB = 18,
		KEY_CODE_ESCAPE = 19,
		KEY_CODE_SPACE = 20,		// equal to ' '
		// and also all the ASCII codes from 32 to 126
	};
#define	SSWF_KEY_COUNT			15
	struct key_names_t {
		key_code_t		f_code;
		const char *		f_name;
	};

invisible:
	static const event_names_t	g_event_names[SSWF_EVENT_COUNT];
	static const key_names_t	g_key_names[SSWF_KEY_COUNT];

private:
	unsigned long		f_events;
	unsigned char		f_key;
	Vectors			f_actions;
};





exposed_class Style : public ItemBase
{
public:
	enum style_t {
		STYLE_TYPE_UNKNOWN = 0,
		STYLE_TYPE_NO_LINE,
		STYLE_TYPE_NO_FILL,
		STYLE_TYPE_LINE,
		STYLE_TYPE_ENHANCED_LINE,	// Line 2
		STYLE_TYPE_SOLID,
		STYLE_TYPE_GRADIENT_LINEAR,
		STYLE_TYPE_GRADIENT_RADIAL,
		STYLE_TYPE_GRADIENT_FOCAL,
		STYLE_TYPE_BITMAP_TILLED,
		STYLE_TYPE_BITMAP_CLIPPED,
		STYLE_TYPE_BITMAP_HARDEDGE_TILLED,
		STYLE_TYPE_BITMAP_HARDEDGE_CLIPPED,

		STYLE_TYPE_MATRIX,		// intermediate type used when a matrix is defined before
						// a gradient or bitmap info (or the SetType() is called)

		STYLE_TYPE_max
	};

	enum cap_t {
		STYLE_LINE_CAP_SAME   = -1,
		STYLE_LINE_CAP_ROUND  = 0,
		STYLE_LINE_CAP_NONE   = 1,
		STYLE_LINE_CAP_SQUARE = 2
	};

	enum join_t {
		STYLE_LINE_JOIN_UNKNOWN = -1,
		STYLE_LINE_JOIN_ROUND   = 0,
		STYLE_LINE_JOIN_BEVEL   = 1,
		STYLE_LINE_JOIN_MITER   = 2
	};

	enum spread_t {
		STYLE_GRADIENT_SPREAD_PAD     = 0,
		STYLE_GRADIENT_SPREAD_REFLECT = 1,
		STYLE_GRADIENT_SPREAD_REPEAT  = 2,
	};

	enum interpolation_t {
		STYLE_GRADIENT_INTERPOLATION_NORMAL = 0,
		STYLE_GRADIENT_INTERPOLATION_LINEAR = 1
	};

	explicit		Style(ErrorManager& error_manager);
	virtual			~Style();

	void			Reset(void);
	style_t			Type(void) const { return f_style; }
	signed char		Gradients(void) const { return f_gradient; }
	bool			HasMorph(void) const { return f_morph; }
	bool			HasAlpha(void) const { return f_use_alpha; }
	bool			HasHardEdges(void) const { return f_style == STYLE_TYPE_BITMAP_HARDEDGE_TILLED
								|| f_style == STYLE_TYPE_BITMAP_HARDEDGE_CLIPPED; }
	bool			SetType(style_t style_type);
	bool			SetLine(int index, unsigned short width, const Color& color);
	bool			SetLineCaps(cap_t start, cap_t end = STYLE_LINE_CAP_SAME);
	bool			SetLineJoin(join_t join, float miter_limit_factor = 0.0f);
	bool			SetLineScale(bool horiz, bool vert);
	bool			SetLinePixelHinting(bool pixel_hinting);
	bool			SetLineNoClose(bool no_close);
	bool			SetLineFillStyle(const Style& fill_style);
	bool			SetColor(int index, const Color& color);
	bool			SetGradient(int index, int pos, const Color& color);
	bool			SetGradientModes(spread_t spread, interpolation_t interpolation);
	bool			SetGradientFocal(float focal);
	bool			SetMatrix(int index, const Matrix& matrix);
	bool			SetBitmap(sswf_id_t id_ref);
	bool			SetClipping(void);

	ErrorManager::error_code_t Save(Data& data, bool save_alpha, bool save_morph);

invisible:
	/** \brief Defines the total number of gradients available in a gradient style.
	 *
	 * This value represents the maximum number of gradients a
	 * gradient style supports. Older movies would support up to
	 * 8 gradients. Newer movies (since SWF version 8) support
	 * up to 15 gradient definitions.
	 */
	static const signed char MAX_GRADIENTS = 15;

	bool			operator == (const Style& style) const;

private:
	// An error manager (TagHeader)
	ErrorManager&		f_error_manager;

	// the style
	style_t			f_style;

	// whether this is for a DefineMorphShape or not
	bool			f_morph;

	// whether some color alpha is not 255
	bool			f_use_alpha;

	// a line width
	unsigned short		f_line_width[2];
	cap_t			f_start_cap_style;
	cap_t			f_end_cap_style;
	join_t			f_join_style;
	float			f_miter_limit_factor;		// means we have f_join_style == 2
	bool			f_no_hscale;
	bool			f_no_vscale;
	bool			f_pixel_hinting;
	bool			f_no_close;
	Style *			f_fill_style;			// if defined, no color and f_has_fill is set to true in output

	// solid fill or line colors
	Color			f_color[2];

	// bitmap reference (its ID)
	sswf_id_t		f_bitmap_ref;

	// matrices - 1 or 2 - regular of morph shapes
	Matrix			f_matrix[2];

	// gradient positions & colors - 8 or 16 - regular or morph shapes
	signed char		f_gradient;		// largest index used (0..7 only or -1 when no gradient)
	unsigned char		f_gradient_pos[MAX_GRADIENTS * 2];
	Color			f_gradient_color[MAX_GRADIENTS * 2];
	spread_t		f_gradient_spread;
	interpolation_t		f_gradient_interpolation;
	signed short		f_gradient_focal;
};





exposed_class Edges : public MemoryManager, public ItemBase
{
invisible:
	// This structure is too complex at this time to reproduce
	// automatically in C. We do not need it anyway.
	struct edge_t {
		long		f_x;
		long		f_y;
		long		f_ctrl_x;		/* LONG_MIN if a line only */
		long		f_ctrl_y;

				edge_t(void)
				{
					f_x = 0;
					f_y = 0;
					f_ctrl_x = LONG_MIN;
					f_ctrl_y = LONG_MIN;
				}
				edge_t(long x, long y)
				{
					f_x = x;
					f_y = y;
					f_ctrl_x = LONG_MIN;
					f_ctrl_y = LONG_MIN;
				}
				edge_t(long x, long y, long ctrl_x, long ctrl_y)
				{
					f_x = x;
					f_y = y;
					f_ctrl_x = ctrl_x;
					f_ctrl_y = ctrl_y;
				}
				edge_t(const edge_t& edge)
				{
					f_x = edge.f_x;
					f_y = edge.f_y;
					f_ctrl_x = edge.f_ctrl_x;
					f_ctrl_y = edge.f_ctrl_y;
				}
		edge_t&		operator = (const edge_t& edge)
				{
					if(this != &edge) {
						f_x = edge.f_x;
						f_y = edge.f_y;
						f_ctrl_x = edge.f_ctrl_x;
						f_ctrl_y = edge.f_ctrl_y;
					}
					return *this;
				}
		bool		IsLine(void) const { return f_ctrl_x == LONG_MIN || f_ctrl_y == LONG_MIN; }
	};

public:
	// This should be private but cl (C++ compiler from Mr Microsoft) does not
	// understand the use of private too well...
	enum {
		// better with a power of two (we use * and / a lot with it!)
		EDGE_BLOCK = 64
	};

				Edges(void);
	virtual			~Edges();

	//void			Reset(void); -- not implemented yet
	void			Set(long x, long y) { edge_t edge(x, y); Set(-1, edge); }
	void			Set(long x, long y, long ctrl_x, long ctrl_y) { edge_t edge(x, y, ctrl_x, ctrl_y); Set(-1, edge); }
	void			Set(int index, long x, long y, long ctrl_x, long ctrl_y) { edge_t edge(x, y, ctrl_x, ctrl_y); Set(index, edge); }

	void			Save(Data& data, long& x, long& y);

invisible:
	void			Set(const edge_t& edge) { Set(-1, edge); }
	void			Set(int index, const edge_t& edge);

private:
	/// One set of edges; when full, allocate another
	struct array_edge_t : public ItemBase {
		edge_t		f_edge[EDGE_BLOCK];
	};

				// no copy operators at this time
				Edges(const Edges& edges) {}
	Edges&			operator = (const Edges& edges) { return *this; }

	void			SaveEdge(Data& data, const edge_t& edge, long& x, long& y);

	Vectors			f_edges;
	int			f_pos;		/* position in the current array */
	array_edge_t		f_array;	/* current array; when full, put in f_edges */
};







// one can't create a tag base, only full qualified
// tags can be created (see below)
class TagHeader;
exposed_class TagBase : public MemoryManager
{
public:
	// anything in the file is represented by a tag
	enum swf_tag_t {
		SWF_TAG_UNKNOWN = -1,		// undefined tag

		// V1.0
		SWF_TAG_END = 0,			// mark the end of the flash script
		SWF_TAG_SHOW_FRAME = 1,			// show the current frame
		SWF_TAG_DEFINE_SHAPE = 2,		// define a vector based shape
		SWF_TAG_PLACE_OBJECT = 4,		// place an object in the current frame
		SWF_TAG_REMOVE_OBJECT = 5,		// remove specified object
		SWF_TAG_DEFINE_BITS = 6,		// JPEG data bit stream (old name, I will obsolete this name at some point)
		SWF_TAG_DEFINE_BITS_JPEG = 6,		// JPEG data bit stream (renaming)
		SWF_TAG_DEFINE_BUTTON = 7,		// define an action button
		SWF_TAG_JPEG_TABLES = 8,		// define the JPEG tables
		SWF_TAG_SET_BACKGROUND_COLOR = 9,	// define the RGB color for the background
		SWF_TAG_DEFINE_FONT = 10,		// links a list of shapes to characters
		SWF_TAG_DEFINE_TEXT = 11,		// define a text to be printed with a font
		SWF_TAG_DO_ACTION = 12,			// action to perform in this frame
		SWF_TAG_DEFINE_FONT_INFO = 13,		// font metrics

		// V2.0
		SWF_TAG_DEFINE_SOUND = 14,		// define how a sound effect will be played
		SWF_TAG_START_SOUND = 15,		// start playing a sound effect
		SWF_TAG_STOP_SOUND = 16,		// (V9.0) stop playing a sound effect
		SWF_TAG_DEFINE_BUTTON_SOUND = 17,	// sound effects attached to a button
		SWF_TAG_SOUND_STREAM_HEAD = 18,		// define how a sound effect will be loaded & played
		SWF_TAG_SOUND_STREAM_BLOCK = 19,	// actual sound samples to play (embedded with the rest)
		SWF_TAG_DEFINE_BITS_LOSSLESS = 20,	// a loss less compressed image
		SWF_TAG_DEFINE_BITS_JPEG2 = 21,		// a complete JPEG definition
		SWF_TAG_DEFINE_SHAPE2 = 22,		// define a shape including large number of styles
		SWF_TAG_DEFINE_BUTTON_COLOR_TRANSFORM = 23,	// how a button changes color
		SWF_TAG_PROTECT = 24,			// whether the resulting file is protected against editing

		// V3.0
		SWF_TAG_PLACE_OBJECT2 = 26,		// extended place
		SWF_TAG_REMOVE_OBJECT2 = 28,		// simplified remove
		SWF_TAG_DEFINE_SHAPE3 = 32,		// define a shape including RGBA colors
		SWF_TAG_DEFINE_TEXT2 = 33,		// define a text to draw including RGBA colors
		SWF_TAG_DEFINE_BUTTON2 = 34,		// define an action button with RGBA colors and color transformation
		SWF_TAG_DEFINE_BITS_JPEG3 = 35,		// define two JPEG images, one RGB and one GREY used as the alpha channel
		SWF_TAG_DEFINE_BITS_LOSSLESS2 = 36,	// define a loss less image with an alpha channel
		SWF_TAG_DEFINE_SPRITE = 39,		// define a movie as an object to play in another movie
		SWF_TAG_PRODUCT_INFO = 41,		// generator version info
		SWF_TAG_FRAME_LABEL = 43,		// name a place holder in the movie
		SWF_TAG_DEFINE_BEHAVIOR = 44,		// (V9.0) ?
		SWF_TAG_SOUND_STREAM_HEAD2 = 45,	// define a sound effect with more details for embedded playing
		SWF_TAG_DEFINE_MORPH_SHAPE = 46,	// define a shape which can easilly be changed with a position
		SWF_TAG_DEFINE_FONT2 = 48,		// define a set of fonts
		SWF_TAG_DEFINE_INFO = 49,		// define a comment about the generator, etc.

		// V4.0
		SWF_TAG_TEXT_FIELD = 37,		// define an area with text which can be edited

		// V9.0
		SWF_TAG_DEFINE_FUNCTION = 53,		// ABC function
		SWF_TAG_PLACE_FUNCTION = 54,		// Place(?) ABC function
		SWF_TAG_GENERATE_TAG_OBJECT = 55,	// ?

		// V5.0
		SWF_TAG_EXPORT = 56,			// export a set of definitions to other files
		SWF_TAG_IMPORT = 57,			// look for definitions from another file (supported up to V7.0)
		SWF_TAG_PROTECT_DEBUG = 58,		// a password to protect debugging of flash movies -- use only in V5.x movies

		// V6.0
		SWF_TAG_DO_INIT_ACTION = 59,		// action to perform once on specified sprite in this frame
		SWF_TAG_DEFINE_VIDEO_STREAM = 60,	// record defining the following video frames
		SWF_TAG_VIDEO_FRAME = 61,		// a frame of video
		SWF_TAG_DEFINE_FONT_INFO2 = 62,		// font metrics including language reference
		SWF_TAG_DEBUG_ID = 63,			// (SWF 9)
		SWF_TAG_PROTECT_DEBUG2 = 64,		// a password to protect debugging of flash movies

		// V7.0
		SWF_TAG_SCRIPT_LIMITS = 65,		// the recursive depth and script timeout parameters
		SWF_TAG_SET_TAB_INDEX = 66,		// the depth of an object to be set at the given index (next/previous Tab key positioning)

		// V8.0
		SWF_TAG_FILE_ATTRIBUTES = 69,		// file attributes appended right after the header (see TagHeader)
		SWF_TAG_PLACE_OBJECT3 = 70,		// place an object with blend mode, filters, bitmap caching
		SWF_TAG_IMPORT2 = 71,			// look for definitions from another file (only supported tag in V8.0+)
		SWF_TAG_DEFINE_FONT_ALIGN_ZONES = 73,	// define hints to properly align fonts to pixel boundaries
		SWF_TAG_CSM_TEXT_SETTINGS = 74,		// extra information about text (on how to render text)
		SWF_TAG_DEFINE_FONT3 = 75,		// define a set of fonts which uses lines with caps information
		SWF_TAG_METADATA = 77,			// an XML document describing the Flash movie
		SWF_TAG_DEFINE_SCALING_GRID = 78,	// a grid to avoid scaling the edges of an object
		SWF_TAG_DEFINE_SHAPE4 = 83,		// define a vector based shape with end caps definitions
		SWF_TAG_DEFINE_MORPH_SHAPE2 = 84,	// define a shape which can easilly be changed with a position

		// V9.0
		SWF_TAG_ACTIONSCRIPT2 = 72,		// define action script version 2
		SWF_TAG_ACTIONSCRIPT2_INSTANTIATE = 76,	// create an object from an action script version 2
		SWF_TAG_ACTIONSCRIPT2_DEFINE = 82,	// initialize a named action script version 2
		SWF_TAG_SCENE_FRAME_DATA = 86,		// define raw data for a scene/frame
		SWF_TAG_DEFINE_BINARY_DATA = 87,	// define a block of data with an identifier
		SWF_TAG_DEFINE_FONT_NAME = 88,		// define the name and copyright notice of a font

		SWF_TAG_max		// just end this list really
	};
	typedef long			swf_type_t;

#define	SWF_TYPE_DEFINE			0x00000001	// a definition tag, must be in the main movie
#define	SWF_TYPE_CONTROL		0x00000002	// a control tag, can be in sprites as well
#define	SWF_TYPE_UNIQUE			0x00000004	// a unique tag, can't be duplicated in the movie (merge if possible)
#define	SWF_TYPE_START			0x00000008	// if present, put it near the start of the movie
#define	SWF_TYPE_ONE			0x00000010	// (should) use at most one per frame
#define	SWF_TYPE_REFERENCE		0x00000020	// object includes references to other objects
#define	SWF_TYPE_HAS_ID			0x00000040	// this object was derived from TagBaseID and has an ID

#define	SWF_TYPE_SCRIPT			0x20000000	// object can accept action scripts
#define	SWF_TYPE_SPRITE			0x40000000	// this is a sprite (can include other tags)
#define	SWF_TYPE_HEADER			0x80000000	// the header

	virtual				~TagBase();

	ErrorManager::error_code_t	SaveString(Data& data, const char *string);
	static int			SaveTag(Data& data, swf_tag_t tag, size_t size);

	static long			SIBitSize(long value);		// return the number of bits necessary to represent a signed integer
	static long			UIBitSize(unsigned long value);	// return the number of bits necessary to represent an unsigned integer
	static long			Double2Signed16(double value);	// return a valid fixed value 8.8 bits from a double
	static long			Double2Signed(double value);	// return a valid fixed value 16.16 bits from a double
	static double			Signed2Double(long value);	// return a valid double from a fixed value 16.16 bits

	virtual void			MinimumVersion(unsigned char version);
	virtual unsigned char		Version(void) const;

	const char *			Name(void) const;	// return the name (type) of this tag
	const char *			Label(void) const;
	void				ResetFrames(void);
	void				ShowFrame(void);
	sswf_frame_t			FrameCount(void) const;

	sswf_frame_t			WhichFrame(void) const;
	void				SetLabel(const char *label);
	TagBase *			FindLabelledTag(const char *label) const;
	TagBase *			FindTagWithID(sswf_id_t id, bool search_import = true) const;
	TagBase *			Children(void);
	TagBase *			Next(void);
	TagBase *			Previous(void);
	TagBase *			Parent(void);
	TagHeader *			Header(void) const;
	virtual ErrorManager::error_code_t OnError(ErrorManager::error_code_t errcode, const char *message, va_list ap) const;

invisible:
	virtual ErrorManager::error_code_t Save(Data& data) = 0;	// print out a tag in a Data buffer
	virtual swf_type_t		TypeFlags(void) const = 0;
	virtual ErrorManager::error_code_t OnError(ErrorManager::error_code_t errcode, const char *message, ...) const;

	/** \brief A pointer you are welcome to use
	 *
	 * This pointer is public and is provided so users of any one of
	 * the tag classes can save a pointer back to his/her own
	 * container.
	 *
	 * The library initializes this pointer to NULL on construction
	 * and never touches it again until the object is deleted.
	 */
	void *				f_userdata;		// anything you feel necessary!

protected:
				// only sub-classes can create a TagBase
					TagBase(const char *name, TagBase *parent);
	virtual ErrorManager::error_code_t PreSave(void);		// called by the header Save() function
	virtual ErrorManager::error_code_t PreSave2ndPass(void);	// called by the header Save() function after all the PreSave() were called

	virtual ErrorManager::error_code_t OnNewChild(const char *child_name) const;

private:
	TagBase *			FindLabel(const TagBase *p, const char *label) const;
	TagBase *			FindID(const TagBase *p, sswf_id_t id, bool search_import) const;

	const char *			f_name;
	char *				f_label;

	TagBase *			f_parent;
	TagBase *			f_next;
	TagBase *			f_previous;
	TagBase *			f_children;

	sswf_frame_t			f_frames;		// total number of frames
};






/********************* TAGS WITHOUT IDs (possibly references though) ****/


// The TagHeader includes the TagFileAttributes because
// it is very much like an extension of the header and not
// a separate tag. Also it needs to be unique and saved right
// after the header. Thus it becomes totally transparent to
// you. At this time you have the SetUseNetwork() function to
// set the network flag and add a TagMetadata to set the
// metadata flag (that is automatic.)
exposed_class TagHeader : public TagBase, public ErrorManager
{
public:
					TagHeader(void);
	virtual				~TagHeader();

	virtual ErrorManager::error_code_t Save(Data& data);
	ErrorManager::error_code_t	SaveEncodedString(Data& data, const char *string);
	virtual swf_type_t		TypeFlags(void) const;
	virtual ErrorManager::error_code_t OnError(ErrorManager::error_code_t errcode, const char *message, va_list ap) const;

	sswf_id_t			NextID(void);
	void				RemoveID(sswf_id_t id);

/////////////// SETUP FUNCTIONS
	virtual unsigned char		Version(void) const;				// retrieve the selected version
	void				SetVersion(unsigned char version);		// save a movie with that version if set
	void				SetMinimumVersion(unsigned char version);	// the minimum version you want to support
	void				SetMaximumVersion(unsigned char version);	// the maximum version you want to support

	void				SetCompress(bool compress = true);
	void				SetAutoOrder(bool auto_order = true);
	void				SetUseNetwork(bool use_network = true);
	void				SetFrame(const SRectangle& rect);
	const SRectangle&		Frame(void) const;

	void				SetOutputEncoding(const char *encoding);
	void				SetRate(float rate);
	float				Rate(void) const;

invisible:
	virtual void			MinimumVersion(unsigned char version);		// used internally to determine the minimum version
	ErrorManager::error_code_t	DefineMinimumVersion(int& min_version);		// function used to compute the minimum version (a negative result represents an error)
	virtual ErrorManager::error_code_t OnError(ErrorManager::error_code_t errcode, const char *message, ...) const;

protected:
	virtual ErrorManager::error_code_t PreSave(void);		// overwrite the base PreSave() so we can know whether we have a Metadata tag
	virtual ErrorManager::error_code_t OnNewChild(const char *child_name) const;

private:
	// NOTE: use 0 to get a default version (a version computed from the options used)
	unsigned char			f_version;		// file version (0 to 8 at time of writing)
	unsigned char			f_min_version;		// once the whole file was saved, this is the minimum version we need to use
	unsigned char			f_minimum_version;	// user defined minimum version; the system will start with this minimum version instead of 1
	unsigned char			f_maximum_version;	// user defined maximum version; if a larger version is required, return an error
	SRectangle			f_frame;		// the frame rectangle
	float				f_rate;			// frames per second (8.8 fixed number in file)
	bool				f_compress;		// compress the resulting movie (v6.x upward)
	bool				f_auto_order;		// automatically order definition tags (discard unused definitions also)
	bool				f_use_network;		// whether the SWF movie is authorized to access the network when launched locally
	bool				f_has_metadata;		// whether the SWF movie includes a TagMetadata
	bool				f_has_jpegtables;	// whether the SWF movie includes a TagJPEGTables
	sswf_id_t			f_next_id;		// returned and then increased when NextID() is called
	char *				f_output_encoding;	// encoding used prior V6.x SWF files
	bool				f_iconvertor_open;	// whether the f_iconvertor is a valid descriptor
	iconv_t				f_iconvertor;		// to convert strings from U18N to user specified encoding
#if DEBUG
	bool				f_saving;		// if true the f_min_version can't be changed ever anymore
#endif
};




// Actions:
//
//	Whenever you want to create an action, you simply
//	create a new Action object with the proper type
//	unless you need to use an action which requires
//	some additional data. The actions which require
//	additional data are listed here:
//
//	Action Name		Data
//
//	ActionBranch		label
//	ActionCallFrame		<nothing -- this is a mistake from Macromedia>
//	ActionDictionary	strings
//	ActionFunction		name, registers, parameters, body (actions)
//	ActionGoto		frame name, play flag
//	ActionLabel		label (generates no output code)
//	ActionPushData		strings, floats, doubles, etc.
//	ActionSetTarget		target name
//	ActionStoreRegister	register number
//	ActionTry		try, catch and finally actions and identifier/register
//	ActionURL		url, target and method
//	ActionWaitForFrame	frame name, actions
//	ActionWith		actions to execute with the specified object


class ActionLabel;
exposed_class Action : public ItemBase
{
public:
	enum action_t {
		ACTION_UNKNOWN			= -1,	/* unknown action (invalid) */
		ACTION_LABEL			= -2,	/* used to mark a position within the actions */
		ACTION_min			= 0x00,	/* the minimum action number */

		/* all the valid Flash actions */
		ACTION_END			= 0x00,	/* this is automatically added by the higher level Save()'s */
		ACTION_NEXT_FRAME		= 0x04,
		ACTION_PREVIOUS_FRAME		= 0x05,
		ACTION_PLAY			= 0x06,
		ACTION_STOP			= 0x07,
		ACTION_TOGGLE_QUALITY		= 0x08,
		ACTION_STOP_SOUND		= 0x09,
		ACTION_ADD			= 0x0A,
		/*ACTION_SUBSTRACT		= 0x0B,	-- this is the wrong spelling, it is not totally obsolete */
		ACTION_SUBTRACT			= 0x0B,
		ACTION_MULTIPLY			= 0x0C,
		ACTION_DIVIDE			= 0x0D,
		ACTION_EQUAL			= 0x0E,
		ACTION_LESS_THAN		= 0x0F,
		ACTION_LOGICAL_AND		= 0x10,
		ACTION_LOGICAL_OR		= 0x11,
		ACTION_LOGICAL_NOT		= 0x12,
		ACTION_STRING_EQUAL		= 0x13,
		ACTION_STRING_LENGTH		= 0x14,
		ACTION_SUB_STRING		= 0x15,
		ACTION_POP			= 0x17,
		ACTION_INTEGRAL_PART		= 0x18,
		ACTION_GET_VARIABLE		= 0x1C,
		ACTION_SET_VARIABLE		= 0x1D,
		ACTION_SET_TARGET2		= 0x20,
		ACTION_CONCATENATE		= 0x21,
		ACTION_GET_PROPERTY		= 0x22,
		ACTION_SET_PROPERTY		= 0x23,
		ACTION_DUPLICATE_SPRITE		= 0x24,
		ACTION_REMOVE_SPRITE		= 0x25,
		ACTION_TRACE			= 0x26,
		ACTION_START_DRAG		= 0x27,
		ACTION_STOP_DRAG		= 0x28,
		ACTION_STRING_LESS_THAN		= 0x29,
		ACTION_THROW			= 0x2A,
		ACTION_CAST_OBJECT		= 0x2B,
		ACTION_IMPLEMENTS		= 0x2C,
		ACTION_FSCOMMAND2		= 0x2D,
		ACTION_RANDOM			= 0x30,
		ACTION_MBSTRING_LENGTH		= 0x31,
		ACTION_ORD			= 0x32,
		ACTION_CHR			= 0x33,
		ACTION_GET_TIMER		= 0x34,
		ACTION_SUB_MBSTRING		= 0x35,
		ACTION_MBORD			= 0x36,
		ACTION_MBCHR			= 0x37,
		ACTION_DELETE			= 0x3A,
		ACTION_SET_LOCAL_VAR		= 0x3C,
		ACTION_SET_LOCAL_VARIABLE	= 0x3C,
		ACTION_CALL_FUNCTION		= 0x3D,
		ACTION_RETURN			= 0x3E,
		ACTION_MODULO			= 0x3F,
		ACTION_NEW			= 0x40,
		ACTION_DECLARE_LOCAL_VAR	= 0x41,
		ACTION_DECLARE_LOCAL_VARIABLE	= 0x41,
		ACTION_DECLARE_ARRAY		= 0x42,
		ACTION_DECLARE_OBJECT		= 0x43,
		ACTION_TYPE_OF			= 0x44,
		ACTION_GET_TARGET		= 0x45,
		ACTION_ENUMERATE		= 0x46,
		ACTION_ADD_TYPED		= 0x47,
		ACTION_LESS_THAN_TYPED		= 0x48,
		ACTION_EQUAL_TYPED		= 0x49,
		ACTION_NUMBER			= 0x4A,
		ACTION_STRING			= 0x4B,
		ACTION_DUPLICATE		= 0x4C,
		ACTION_SWAP			= 0x4D,
		ACTION_GET_MEMBER		= 0x4E,
		ACTION_SET_MEMBER		= 0x4F,
		ACTION_INCREMENT		= 0x50,
		ACTION_DECREMENT		= 0x51,
		ACTION_CALL_METHOD		= 0x52,
		ACTION_NEW_METHOD		= 0x53,
		ACTION_INSTANCE_OF		= 0x54,
		ACTION_ENUMERATE_OBJECT		= 0x55,
		ACTION_AND			= 0x60,
		ACTION_OR			= 0x61,
		ACTION_XOR			= 0x62,
		ACTION_SHIFT_LEFT		= 0x63,
		ACTION_SHIFT_RIGHT		= 0x64,
		ACTION_SHIFT_RIGHT_UNSIGNED	= 0x65,
		ACTION_STRICT_EQUAL		= 0x66,
		ACTION_GREATER_THAN_TYPED	= 0x67,
		ACTION_STRING_GREATER_THAN	= 0x68,
		ACTION_EXTENDS			= 0x69,
		ACTION_GOTO_FRAME		= 0x81,
		ACTION_URL			= 0x83,
		ACTION_STORE_REGISTER		= 0x87,
		ACTION_DECLARE_DICTIONARY	= 0x88,
		ACTION_STRICT_MODE		= 0x89,
		ACTION_WAIT_FOR_FRAME		= 0x8A,
		ACTION_SET_TARGET		= 0x8B,
		ACTION_GOTO_LABEL		= 0x8C,
		ACTION_WAIT_FOR_FRAME2		= 0x8D,
		ACTION_DECLARE_FUNCTION2	= 0x8E,
		ACTION_TRY			= 0x8F,
		ACTION_WITH			= 0x94,
		ACTION_PUSH_DATA		= 0x96,
		ACTION_BRANCH_ALWAYS		= 0x99,
		ACTION_URL2			= 0x9A,
		ACTION_DECLARE_FUNCTION		= 0x9B,
		ACTION_BRANCH_IF_TRUE		= 0x9D,
		ACTION_CALL_FRAME		= 0x9E,
		ACTION_GOTO_EXPRESSION		= 0x9F,

		ACTION_max		= 0xFF		/* the maximum action number */
	};

					Action(TagBase *tag, action_t action);
	virtual				~Action() {}

	virtual Action *		Duplicate(void) const;
	unsigned long			Offset(void) const { return f_offset; }
	virtual unsigned char		Version(void) const { return f_min_version; }

	ErrorManager::error_code_t	Save(Data& data);
	virtual Vectors *		SubList(void);
	ErrorManager::error_code_t	SaveList(const Vectors *list, Data& data, const Vectors *extra = 0);
	static int			MinimumListVersion(const Vectors& list);
	static int			GetMaximumRegister(const Vectors& list);
	static ActionLabel *		FindLabel(const Vectors& list, const char *label);

invisible:
	ErrorManager::error_code_t	OnError(ErrorManager::error_code_t errcode, const char *message, ...) const;

protected:
	virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
	virtual ErrorManager::error_code_t Save2ndPass(const Vectors& list, Data& data);
	virtual int			GetMaxRegister(void) const { return 0; }
	ErrorManager::error_code_t	SaveString(Data& data, const char *string);
	TagBase *			Tag(void) const { return const_cast<TagBase *>(f_tag); }

	const action_t			f_action;
	unsigned long			f_offset;		/* offset where this tag is being saved (saved for branches and with statments) */

private:
#if DEBUG
	/*
	 * Forbid copies (only in DEBUG mode so we don't have extra functions
	 * for nothing otherwise) If you need a copy, use the Duplicate() instead
	 */
					Action(const Action& action);
	Action&				operator = (const Action& action);
#endif

	TagBase *			f_tag;
	unsigned char			f_min_version;		/* minimum version to use this action */
};


exposed_class ActionBranch : public Action, public MemoryManager
{
public:
	/* one of:
	 *	ACTION_BRANCH_ALWAYS
	 *	ACTION_BRANCH_IF_TRUE
	 */
					ActionBranch(TagBase *tag, action_t action = ACTION_BRANCH_ALWAYS);

	void				SetLabel(const char *label);

private:
	virtual Action *		Duplicate(void) const;
	virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
	virtual ErrorManager::error_code_t Save2ndPass(const Vectors& list, Data& data);

	char *				f_label;
};



exposed_class ActionCallFrame : public Action, public MemoryManager
{
public:
					ActionCallFrame(TagBase *tag);

private:
	virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
};



exposed_class ActionDictionary : public Action, public MemoryManager
{
public:
					ActionDictionary(TagBase *tag);

	void				AddString(const char *string);

private:
	/// Holds one dictionary string
	struct string_t : public ItemBase
	{
		/// Pointer to the dictionary string
		char *		f_string;
	};

	virtual Action *		Duplicate(void) const;
	virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);

	/// Array of dictionary strings
	Vectors				f_strings;
};



exposed_class ActionFunction : public Action, public MemoryManager
{
public:
	/* one of:
	 *	ACTION_DECLARE_FUNCTION
	 *	ACTION_DECLARE_FUNCTION2
	 */
					ActionFunction(TagBase *tag, action_t action = ACTION_DECLARE_FUNCTION);

	enum action_function_t {
		ACTION_FUNCTION_LOAD_THIS          = 0x0001,
		ACTION_FUNCTION_SUPPRESS_THIS      = 0x0002,
		ACTION_FUNCTION_LOAD_ARGUMENTS     = 0x0004,
		ACTION_FUNCTION_SUPPRESS_ARGUMENTS = 0x0008,
		ACTION_FUNCTION_LOAD_SUPER         = 0x0010,
		ACTION_FUNCTION_SUPPRESS_SUPER     = 0x0020,
		ACTION_FUNCTION_LOAD_ROOT          = 0x0040,
		ACTION_FUNCTION_LOAD_PARENT        = 0x0080,
		ACTION_FUNCTION_LOAD_GLOBAL        = 0x0100
	};

	void				SetName(const char *name);
	void				SetRegistersCount(unsigned int count);
	void				AddParameter(const char *name, int register_number = -1);
	void				AddAction(Action *action);
	virtual Vectors *		SubList(void);

	// flags for the ASSetPropFlags(obj, props, flags [, allow])
	// (see include/sswf/scripts/global/extensions.asc)
	enum as_set_prop_flags_t {
		PROP_FLAG_IS_HIDDEN = 1,
		PROP_FLAG_CAN_DELETE = 2,
		PROP_FLAG_CAN_OVERWRITE = 4
	};

private:
	/// Hold the parameters name and register number
	struct parameter_t : public ItemBase
	{
		/// The name of the parameter
		char *		f_name;
		/// The register number (-1 means no register and 0 means auto-assign the number)
		int		f_register_number;	// if -1, use the name, if 0, auto-assign
	};

	virtual Action *		Duplicate(void) const;
	virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);

	char *				f_name;
	unsigned int			f_registers_count;
	unsigned short			f_flags;
	Vectors				f_parameters;
	Vectors				f_actions;
};



exposed_class ActionGoto : public Action, public MemoryManager
{
public:
	/* one of:
	 *	ACTION_GOTO_FRAME
	 *	ACTION_GOTO_LABEL
	 *	ACTION_GOTO_EXPRESSION
	 */
					ActionGoto(TagBase *tag, action_t action = ACTION_GOTO_FRAME);

	void				SetFrameName(const char *frame_name);
	void				SetPlay(bool play) { f_play = play; }

private:
	virtual Action *		Duplicate(void) const;
	virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);

	char *				f_frame_name;
	bool				f_play;
};



exposed_class ActionLabel : public Action, public MemoryManager
{
public:
					ActionLabel(TagBase *tag);

	void				SetLabel(const char *label);
	const char *			GetLabel(void) const { return f_label; }

private:
	virtual Action *		Duplicate(void) const;
	// we shall never even try to save a label! so no SaveData() is necessary

	char *				f_label;
};




exposed_class ActionPushData : public Action, public MemoryManager
{
public:
					ActionPushData(TagBase *tag);

	void				AddEmptyString(void) { AddString(0); }
	void				AddString(const char *string);
	void				AddTrue(void) { AddBoolean(true); }
	void				AddFalse(void) { AddBoolean(false); }
	void				AddBoolean(bool value);
	void				AddInteger(long value);
	void				AddFloat(float value);
	void				AddDouble(double value);
	void				AddNull(void);
	void				AddLookup(unsigned short index);
	void				AddRegister(unsigned char reg_index);
	void				AddUndefined(void);

private:
	enum action_immediate_type_t
	{
		ACTION_IMMEDIATE_TYPE_UNKNOWN		= -1,
		ACTION_IMMEDIATE_TYPE_STRING		= 0x00,
		ACTION_IMMEDIATE_TYPE_FLOAT		= 0x01,
		ACTION_IMMEDIATE_TYPE_NULL		= 0x02,
		ACTION_IMMEDIATE_TYPE_UNDEFINED		= 0x03,
		ACTION_IMMEDIATE_TYPE_REGISTER		= 0x04,
		ACTION_IMMEDIATE_TYPE_BOOLEAN		= 0x05,
		ACTION_IMMEDIATE_TYPE_DOUBLE		= 0x06,
		ACTION_IMMEDIATE_TYPE_INTEGER		= 0x07,
		ACTION_IMMEDIATE_TYPE_LOOKUP		= 0x08,
		ACTION_IMMEDIATE_TYPE_LOOKUP_LARGE	= 0x09
	};
	/// One data entry of a PushData action
	struct action_immediate_t : public ItemBase
	{
		action_immediate_type_t	f_type;
		union
		{
			char *		f_string;
			float		f_float32;
			double		f_float64;
			bool		f_boolean;
			long		f_integer32;
			unsigned short	f_lookup;
			unsigned char	f_register;
		} f_data;

		action_immediate_t(action_immediate_type_t type)
		{
			f_type = type;
			memset(&f_data, 0, sizeof(f_data));
		}
	};

	virtual Action *		Duplicate(void) const;
	virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
	virtual int			GetMaxRegister(void) const;

	Vectors				f_data;
};




exposed_class ActionSetTarget : public Action, public MemoryManager
{
public:
					ActionSetTarget(TagBase *tag);

	void				SetTarget(const char *target);

private:
	virtual Action *		Duplicate(void) const;
	virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);

	char *				f_target;
};


exposed_class ActionStoreRegister : public Action, public MemoryManager
{
public:
					ActionStoreRegister(TagBase *tag);

	void				SetRegister(unsigned char reg);

private:
	virtual Action *		Duplicate(void) const;
	virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
	virtual int			GetMaxRegister(void) const;

	unsigned char			f_reg;
};


exposed_class ActionStrictMode : public Action, public MemoryManager
{
public:
					ActionStrictMode(TagBase *tag);

	void				SetStrict(bool strict);

private:
	virtual Action *		Duplicate(void) const;
	virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);

	bool				f_strict;
};


exposed_class ActionTry : public Action, public MemoryManager
{
public:
					ActionTry(TagBase *tag);

	void				AddTryAction(Action *action);
	void				AddCatchAction(Action *action);
	void				AddFinallyAction(Action *action);
	void				SetIdentifier(int register_number);		// Catch(#)
	void				SetIdentifier(const char *variable_name);	// Catch(var)

	Vectors *			SubListTry(void);
	Vectors *			SubListCatch(void);
	Vectors *			SubListFinally(void);

private:
	virtual Action *		Duplicate(void) const;
	virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
	virtual int			GetMaxRegister(void) const;
	virtual unsigned char		Version(void) const;

	int				f_register;
	char *				f_variable_name;
	bool				f_has_catch;
	bool				f_has_finally;
	Vectors				f_actions_try;
	Vectors				f_actions_catch;
	Vectors				f_actions_finally;
};



exposed_class ActionURL : public Action, public MemoryManager
{
public:
	/* one of:
	 *	ACTION_URL
	 *	ACTION_URL2
	 */
					ActionURL(TagBase *tag, action_t action = ACTION_URL);

	enum url_method_t {
		URL_METHOD_UNDEFINED = -1,
		URL_METHOD_NOVARIABLE = 0,
		URL_METHOD_NOVARIABLES = URL_METHOD_NOVARIABLE,
		URL_METHOD_GET = 1,
		URL_METHOD_POST = 2
	};

	void				SetURL(const char *url, const char *target);
	void				SetMethod(url_method_t method);

private:
	virtual Action *		Duplicate(void) const;
	virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);

	char *				f_url;
	char *				f_target;
	url_method_t			f_method;
};



exposed_class ActionWaitForFrame : public Action, public MemoryManager
{
public:
	/* one of:
	 *	ACTION_WAIT_FOR_FRAME
	 *	ACTION_WAIT_FOR_FRAME2
	 */
					ActionWaitForFrame(TagBase *tag, action_t action = ACTION_WAIT_FOR_FRAME);

	void				SetFrameName(const char *name);
	void				AddAction(Action *action);
	virtual Vectors *		SubList(void);

private:
	virtual Action *		Duplicate(void) const;
	virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);

	Vectors				f_actions;	// actions executed once frame is loaded
	char *				f_frame_name;
};



exposed_class ActionWith : public Action, public MemoryManager
{
public:
					ActionWith(TagBase *tag);

	void				AddAction(Action *action);
	virtual Vectors *		SubList(void);

private:
	virtual Action *		Duplicate(void) const;
	virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);

	Vectors				f_actions;
};






exposed_class TagDoAction : public TagBase
{
public:
	/* one of:
	 *	SWF_TAG_DO_ACTION
	 *	SWF_TAG_DO_INIT_ACTION (uses this when sprite ID was defined)
	 */
				TagDoAction(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	void			SetAction(const Action& action);
	void			SetSprite(sswf_id_t sprite);
	Vectors&		Actions(void) { return f_actions; }

private:
	virtual ErrorManager::error_code_t PreSave(void);		// called by the header Save() function

	sswf_id_t		f_sprite;
	Vectors			f_actions;
};





exposed_class TagMetadata : public TagBase
{
public:
				TagMetadata(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	// You should not call all of these functions.
	// There are three groups decreasing priority:
	//
	//  o Read the RDF from a file
	//
	//	SetFilename()
	//
	//  o Define the RDF verbatim
	//
	//	SetMetadata()
	//
	//  o Set values to be saved in an RDF built by SSWF
	//
	//	SetTitle()
	//	SetDescription()
	//	SetAuthor()
	//	SetPublisher()
	//	SetCopyright()
	//	SetURL()
	//
	void			SetFilename(const char *filename);
	void			SetMetadata(const char *xml);
	void			SetTitle(const char *title);
	void			SetDescription(const char *description);
	void			SetAuthor(const char *description);
	void			SetPublisher(const char *publisher);
	void			SetCopyright(const char *copyright);
	void			SetURL(const char *url);

private:
	virtual ErrorManager::error_code_t PreSave(void);		// called by the header Save() function

	char *			f_xml;
	char *			f_filename;
	char *			f_title;
	char *			f_description;
	char *			f_author;
	char *			f_publisher;
	char *			f_copyright;
	char *			f_url;
};





exposed_class TagPlace : public TagBase
{
public:
					TagPlace(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t		TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	void				SetObjectID(sswf_id_t id);
	void				SetDepth(int depth);
	void				SetClip(int depth);
	void				SetMatrix(const Matrix& matrix);
	void				SetColorTransform(const ColorTransform& color_transform);
	void				SetName(const char *name);
	void				SetMorphPosition(int position);
	void				SetBlendMode(const BlendMode& blend_mode);
	void				SetBitmapCaching(int bitmap_caching);
	void				Replace(void);
	void				Place(void);
	bool				AddEvent(Event *event);

private:
	virtual ErrorManager::error_code_t PreSave(void);		// called by the header Save() function

	bool				f_id_defined;
	sswf_id_t			f_id;
	int				f_replace;
	int				f_depth;
	int				f_clip_depth;
	char *				f_name;
	unsigned long			f_events_all_flags;
	int				f_position;		// morph position
	BlendMode			f_blend_mode;
	int				f_bitmap_caching;
	bool				f_has_matrix;
	Matrix				f_matrix;
	ColorTransform			f_color_transform;
	Vectors				f_events;
};



exposed_class TagRemove : public TagBase
{
public:
				TagRemove(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	void			SetDepth(int depth) { f_depth = depth; }
	void			SetObjectID(sswf_id_t id) { f_id = id; }

private:
	virtual ErrorManager::error_code_t PreSave(void);		// called by the header Save() function

	int			f_depth;
	sswf_id_t		f_id;
};



exposed_class TagSceneFrameData : public TagBase
{
public:
				TagSceneFrameData(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	bool			SetFileData(const char *filename);
	void			SetSceneFrameData(const char *data, size_t size);

private:
	virtual ErrorManager::error_code_t PreSave(void);		// called by the header Save() function

	char *			f_data;
	size_t			f_size;
};




exposed_class TagScriptLimits : public TagBase
{
public:
				TagScriptLimits(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	void			SetMaxRecursionDepth(int depth);
	void			SetTimeoutSeconds(int timeout);
	int			GetMaxRecursionDepth(void) const;
	int			GetTimeoutSeconds(void) const;

private:
	virtual ErrorManager::error_code_t PreSave(void);

	int			f_depth;
	int			f_timeout;
};



exposed_class TagSetTabIndex : public TagBase
{
public:
				TagSetTabIndex(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	void			SetDepth(int depth);
	void			SetIndex(int timeout);
	int			GetDepth(void) const;
	int			GetIndex(void) const;

private:
	virtual ErrorManager::error_code_t PreSave(void);

	int			f_depth;
	int			f_index;
};



exposed_class TagSetBackgroundColor : public TagBase
{
public:
				TagSetBackgroundColor(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	void			SetColor(Color& color);
	Color&			GetColor(void);

private:
	Color			f_color;
};


exposed_class TagShowFrame : public TagBase
{
public:
				TagShowFrame(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;
};


exposed_class TagEnd : public TagBase
{
public:
				TagEnd(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;
};


exposed_class TagFrameLabel : public TagBase
{
public:
				TagFrameLabel(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	void			SetFrameLabel(const char *label);

private:
	virtual ErrorManager::error_code_t PreSave(void);

	char *			f_label;
};



exposed_class TagExport : public TagBase
{
public:
				TagExport(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	void			SetObject(sswf_id_t id, const char *name, const char *used_glyphs);

private:
	/// One export entry with the identifier of the object to export and the export name
	struct export_t : public ItemBase
	{
		sswf_id_t	f_id;
		const char *	f_name;
		const char *	f_used_glyphs;
	};

	virtual ErrorManager::error_code_t PreSave(void);

	Vectors			f_objects;
};



exposed_class TagImport : public TagBase
{
public:
	/* one of:
	 *	SWF_TAG_IMPORT (movies before version 8)
	 *	SWF_TAG_IMPORT2 (since version 8)
	 */
				TagImport(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;
	const char *		HasID(sswf_id_t id) const;
	sswf_id_t		HasName(const char *name) const;

/////////////// SETUP FUNCTIONS
	void			SetURL(const char *url);
	void			SetFilename(const char *filename);
	void			AddName(const char *name, const char *type);

private:
	/// Defines each imported object identifier, name and type
	struct import_t : public ItemBase
	{
		sswf_id_t	f_id;		// dynamically allocated
		const char *	f_name;		// external symbol name
		const char *	f_type;		// user specified type
	};

	virtual ErrorManager::error_code_t PreSave(void);

	char *			f_url;
	char *			f_filename;
	Vectors			f_objects;
};



exposed_class TagProtect : public TagBase
{
public:
	/* one of:
	 *	SWF_TAG_PROTECT
	 *	SWF_TAG_PROTECT_DEBUG
	 *	SWF_TAG_PROTECT_DEBUG2
	 *	(now with automatic selection only)
	 */
				TagProtect(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	void			SetPassword(const char *password);
	void			SetEncodedPassword(const char *password);

private:
	virtual ErrorManager::error_code_t PreSave(void);

	char *			f_password;
};



exposed_class TagProductInfo : public TagBase
{
public:
				TagProductInfo(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	void			SetProduct(long product_id);
	void			SetEdition(long edition);
	void			SetVersion(int major, int minor);
	void			SetBuild(int64_t build_number);
	void			SetCompileDate(int64_t date);

private:
	virtual ErrorManager::error_code_t PreSave(void);

	long			f_product_id;
	long			f_edition;
	int			f_major;
	int			f_minor;
	int64_t			f_build_number;
	int64_t			f_date;
};



exposed_class TagInfo : public TagBase
{
public:
				TagInfo(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	void			SetInfo(const char *info);
	void			SetVersion(long version);

private:
	virtual ErrorManager::error_code_t PreSave(void);

	char *			f_info;
	long			f_version;
};


exposed_class TagStartSound : public TagBase
{
public:
				TagStartSound(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	void			SetInfo(SoundInfo *sound_info);

private:
	virtual ErrorManager::error_code_t PreSave(void);

	SoundInfo *		f_sound_info;
};








exposed_class TagScalingGrid
{
public:
	virtual			~TagScalingGrid();

	ErrorManager::error_code_t GridSave(Data& data, sswf_id_t id);
	ErrorManager::error_code_t GridPreSave(void);

	const SRectangle&	Grid(void) const;

/////////////// SETUP FUNCTIONS
	void			SetGrid(const SRectangle& rect);

private:
	SRectangle		f_grid;
};










/****************************************/
/****************************************/
/********************* TAGS WITH IDs ****/
/****************************************/
/****************************************/

exposed_class TagBaseID : public TagBase
{
public:
	virtual			~TagBaseID();

	virtual sswf_id_t	Identification(void) const;
	void			NoIdentification(void);
	bool			HasIdentification(void) const;

	int			SaveID(Data& data) const;

invisible:
				TagBaseID(const char *name, TagBase *parent);

private:
	sswf_id_t		f_id;
	bool			f_identified;
};





exposed_class TagBinaryData : public TagBaseID
{
public:
				TagBinaryData(TagBase *parent);
	virtual			~TagBinaryData();

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	void			GetData(const char *& data, size_t& size) const;
	void			SetData(const char *data, size_t size);

private:
	virtual ErrorManager::error_code_t PreSave(void);

	char *			f_data;
	size_t			f_size;
};




exposed_class TagButton : public TagBaseID, public TagScalingGrid
{
public:
				TagButton(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	bool			SetState(const State& state);
	void			SetAction(const Action& action);
	void			SetMenu(bool menu = true);
	Vectors&		Actions(void);
	bool			AddEvent(Event *event);

private:
	virtual ErrorManager::error_code_t PreSave(void);		// called by the header Save() function

	bool			f_save_button2;
	bool			f_menu;			// whether to track as a menu
	Vectors			f_states;
	Vectors			f_actions;
	Vectors			f_events;
};



exposed_class TagCSMTextSettings
{
public:
	enum csm_text_renderer_t {
		CSM_TEXT_RENDERER_NORMAL = 0,
		CSM_TEXT_RENDERER_FLASH = 1
	};
	enum csm_text_gridfit_t {
		CSM_TEXT_GRIDFIT_NO_GRID = 0,
		CSM_TEXT_GRIDFIT_PIXEL = 1,
		CSM_TEXT_GRIDFIT_SUBPIXEL = 2
	};

					TagCSMTextSettings(void);
	virtual				~TagCSMTextSettings(void);

	bool				IsCSMTextSettingsDefined(void) const;

	void				SetRenderer(csm_text_renderer_t csm_text_renderer);
	void				SetGridFit(csm_text_gridfit_t csm_text_gridfit);
	void				SetThickness(float thickness);
	void				SetSharpness(float sharpness);

protected:
	// Access via the PreSave()/Save() functions of the TagEditText and TagText
	ErrorManager::error_code_t	PreSaveCSMTextSettings(void);
	ErrorManager::error_code_t	SaveCSMTextSettings(Data& data);

private:
	csm_text_renderer_t		f_csm_text_renderer;
	csm_text_gridfit_t		f_csm_text_gridfit;
	float			f_thickness;
	float			f_sharpness;
};


class TagShape;
exposed_class TagFont : public TagBaseID
{
public:
	enum font_type_t {
		FONT_TYPE_BEST = 0,		// create the best possible result
		FONT_TYPE_ASCII,
		FONT_TYPE_UNICODE,
		FONT_TYPE_SHIFTJIS,
	};
	enum font_language_t {
		FONT_LANGUAGE_UNKNOWN			= -1,
		FONT_LANGUAGE_LOCALE			= 0,
		FONT_LANGUAGE_LATIN			= 1,
		FONT_LANGUAGE_JAPANESE			= 2,
		FONT_LANGUAGE_KOREAN			= 3,
		FONT_LANGUAGE_SIMPLIFIED_CHINESE	= 4,
		FONT_LANGUAGE_TRADITIONAL_CHINESE	= 5,

		FONT_LANGUAGE_max			= 6
	};
	enum font_thickness_t {
		FONT_THICKNESS_UNKNOWN	= -1,
		FONT_THICKNESS_THIN	=  0,
		FONT_THICKNESS_MEDIUM	=  1,
		FONT_THICKNESS_THICK	=  2,

		FONT_THICKNESS_max	=  3
	};
	enum font_em_size_t {
		FONT_EM_SMALL = 0,
		FONT_EM_LARGE = 1
	};

#define	SSWF_FONT_SPACE_INDEX		static_cast<unsigned long>(-1)

	/// Structure used to handle one glyph information
	struct font_info_t {
		sswf_ucs4_t		f_glyph;	// the glyph name ('A', 'B', ...)
		unsigned short		f_saved_index;	// index in the SWF file (within the referenced glyphs)
		unsigned long		f_index;	// index in the memory array (of all glyphs)
		unsigned long		f_position;	// closest position or exact position in the list of glyphs
		long			f_advance;	// the advance in TWIPs
		bool			f_is_empty;	// if true, it's like a space (i.e. invisible)
	};

				TagFont(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t		TypeFlags(void) const;
	ErrorManager::error_code_t	GlyphInfo(font_info_t& info) const;
	bool				HasGlyph(void) const;
	bool				FindGlyph(font_info_t& info, bool mark_empty_in_use = false) const;
	const char *			FontName(void) const;
	long				DefaultAscent(void) const;
	long				DefaultDescent(void) const;
	long				DefaultLeadingHeight(void) const;
	static font_language_t		StringToLanguage(const char *language);
	static const char *		LanguageToString(font_language_t language);

/////////////// SETUP FUNCTIONS
	//
	// WARNING: The pointers of the shape referenced are kept as is (the shape is not
	//	    copied in any way)
	//
	//	    So you have to make sure that these shapes still exist at the time
	//	    the Save() is called.
	//
	ErrorManager::error_code_t	AddGlyph(sswf_ucs4_t name, const TagBase *ref, long advance = LONG_MIN);
	void				SetName(const char *font_name);
	void				SetDisplayName(const char *display_name);
	void				SetCopyright(const char *copyright);
	void				SetLayout(long ascent, long descent, long leading_height);
	void				SetDefaultAdvance(long advance);
	void				SetSpaceAdvance(long advance);
	void				SetType(font_type_t type);
	void				SetLanguage(font_language_t language);
	void				SetBold(bool bold);
	void				SetItalic(bool italic);
	void				SetSmallText(bool small_text = true);
	void				SetThickness(font_thickness_t thickness);
	void				SetEMSize(font_em_size_t font_em_size);
	void				SetWide(bool wide);
	ErrorManager::error_code_t	SetUsedGlyphs(const char *used_glyphs, bool mark_empty_in_use = false);
	ErrorManager::error_code_t	SetUsedGlyphs(const sswf_ucs4_t *used_glyphs, bool mark_empty_in_use = false);
	void				SetUsedByEditText(bool used = true);
	void				AddKern(sswf_ucs4_t code0, sswf_ucs4_t code1, long advance);

private:
	/// Structure used to represent a glyph
	struct font_glyph_t : public ItemBase
	{
		sswf_ucs4_t	f_name;		/* "A", "B", "0", "1", etc. */
		unsigned short	f_index;	/* index of this item when saved in the output file */
		const TagShape *f_shape;	/* the shape used for this glyph */
		long		f_advance;	/* the number of TWIPs to advance */
		bool		f_in_use;	/* if true this glyph was referenced at least once */
	};
	/// Structure used to define one kern entry
	struct font_kern_t : public ItemBase
	{
		sswf_ucs4_t	f_code[2];
		long		f_advance;
	};

	virtual ErrorManager::error_code_t PreSave(void);
	virtual ErrorManager::error_code_t PreSave2ndPass(void);

	static const char *	g_font_language_name[FONT_LANGUAGE_max];
	char *			f_font_name;
	char *			f_display_name;
	char *			f_copyright;
	font_language_t		f_language;		// v6.x language definition
	font_type_t		f_type;			// unused in v6.x
	bool			f_bold;
	bool			f_italic;
	bool			f_small_text;
	bool			f_wide;
	bool			f_has_wide_char;	// defined in PreSave2ndPass()
	bool			f_has_wide_offsets;	// defined in PreSave2ndPass()
	bool			f_has_layout;		// defined in PreSave2ndPass()
	bool			f_used_by_edit_text;	// reset in PreSave() used in PreSave2ndPass()
	bool			f_define_font2;		// defined in PreSave2ndPass()
	font_thickness_t	f_thickness;
	font_em_size_t		f_font_em_size;
	long			f_ascent;
	long			f_descent;
	long			f_leading_height;
	long			f_default_advance;
	long			f_space_advance;
	long			f_offsets_max;		// size of the current f_offsets buffer
	unsigned long *		f_offsets;		// this is a list of unsigned shorts if f_has_wide_offset if false -- defined in PreSave2ndPass()
	unsigned long		f_count;		// the number of glyphs saved (defined in PreSave2ndPass())
	Data			f_save_glyphs;		// defined in PreSave2ndPass()
	Vectors			f_glyphs;
	Vectors			f_kerns;
};





exposed_class TagEditText : public TagBaseID, public TagCSMTextSettings
{
public:
	enum edit_text_alignment_t {
		EDIT_TEXT_ALIGNMENT_LEFT = 0,
		EDIT_TEXT_ALIGNMENT_RIGHT = 1,
		EDIT_TEXT_ALIGNMENT_CENTER = 2,
		EDIT_TEXT_ALIGNMENT_JUSTIFY = 3
	};

				TagEditText(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	void			SetText(const char *text);
	void			SetVariableName(const char *name);
	void			SetFont(const TagFont *font, long height);
	void			SetMargins(long left, long right);
	void			SetBounds(const SRectangle& bounds);
	void			SetAlign(edit_text_alignment_t align);
	void			SetIndent(long indent);
	void			SetLeading(long leading);
	void			SetColor(Color& color);
	void			SetMaxLength(long length);
	void			SetWordWrap(bool status = true);
	void			SetMultiline(bool status = true);
	void			SetPassword(bool status = true);
	void			SetReadOnly(bool status = true);
	void			SetNoSelect(bool status = true);
	void			SetBorder(bool status = true);
	void			SetOutline(bool status = true);
	void			SetHTML(bool status = true);
	void			SetAutoSize(bool status = true);
	void			SetUsedGlyphs(const char *lists);
	void			AddUsedString(const char *string);

private:
	virtual ErrorManager::error_code_t PreSave(void);

	SRectangle		f_bounds;		// where the string is drawn
	edit_text_alignment_t	f_align;
	long			f_left_margin;
	long			f_right_margin;
	long			f_indent;
	long			f_leading;
	const TagFont *		f_font;
	unsigned short		f_font_height;
	long			f_max_length;		// maximum number of character, if <= 0 - undefined
	char *			f_var_name;		// required
	char *			f_text;			// if 0, no initialization text [SaveString() expects a UTF-8 so we keep it that way]
	sswf_ucs4_t *		f_used_glyphs;		// default to "*" if undefined
	sswf_ucs4_t *		f_used_strings;		// concatenation of used strings
	Color			f_color;
	bool			f_has_color;		// if this is true then the user defined the color
	bool			f_word_wrap;
	bool			f_multiline;
	bool			f_password;
	bool			f_readonly;
	bool			f_no_select;
	bool			f_border;
	bool			f_outline;
	bool			f_html;
	bool			f_autosize;
};


exposed_class TagImage : public TagBaseID
{
public:
	enum image_format_t {
		IMAGE_FORMAT_UNKNOWN = 0,
		IMAGE_FORMAT_LOSSLESS_BEST,
		IMAGE_FORMAT_LOSSLESS_8,
		IMAGE_FORMAT_LOSSLESS_16,
		IMAGE_FORMAT_LOSSLESS_32,
		IMAGE_FORMAT_JPEG,
		IMAGE_FORMAT_max
	};
	/// Defines a bitmap
	struct image_t {
		bool		f_alpha;		// whether the source had 4 components (depth = 0x20)
		long		f_width;		// size of the image in pixels
		long		f_height;
		unsigned char *	f_data;			// data of the image
	};

					TagImage(TagBase *parent);
	//virtual			~TagImage();

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t		TypeFlags(void) const;
	void				GetImageData(image_t& image_data) { image_data = f_image; }

/////////////// SETUP FUNCTIONS
	void				SetFormat(image_format_t format) { f_format = format; }
	void				SetQuality(int quality) { f_quality = quality; }
	ErrorManager::error_code_t	SetFilename(const char *image, const char *mask);
	void				SetImage(long width, long height, unsigned char *data, bool alpha = false, long count = 0, unsigned char *colormap = 0);

	ErrorManager::error_code_t	LoadTGA(const char *filename, image_t& im);
	ErrorManager::error_code_t	LoadJPEG(const char *filename, image_t& im);
	ErrorManager::error_code_t	SaveJPEG(Data& encoding, Data& image);
	ErrorManager::error_code_t	SetAlpha(image_t& im, const image_t& mask);

private:
	virtual ErrorManager::error_code_t PreSave(void);

	image_format_t		f_format;		// one of the IMAGE_FORMAT_...
	image_t			f_image;		// the image
	int			f_quality;		// for JPEG, the quality level
	long			f_count;		// number of colors in the colormap
	unsigned char *		f_colormap;		// the colormap when it can be generated
};



exposed_class TagShape : public TagBaseID
{
public:
	enum morph_t {
		MORPH_MODE_SHAPE0 = 0,
		MORPH_MODE_SHAPE1 = 1,
		MORPH_MODE_BOTH_SHAPES = 2
	};
	enum fill_t {
		SHAPE_FILL_EVEN = 0,		// Also called Fill0
		SHAPE_FILL_ODD = 1		// Also called Fill1
	};

					TagShape(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t		TypeFlags(void) const;
	ErrorManager::error_code_t	SaveWithoutStyles(Data& data);
	void				SaveAlignZone(Data& data) const;
	bool				HasAlignZone(void) const;
	bool				HasBounds(void) const { return !f_bounds[0].IsEmpty() || !f_bounds[1].IsEmpty(); }
	const SRectangle&		Bounds(int index) const { assert(index == 0 || index == 1, "invalid index to query bounds"); return f_bounds[index]; }
	bool				IsGlyph(void) const;
	bool				IsEmpty(void) const;


/////////////// SETUP FUNCTIONS
	ErrorManager::error_code_t	AddMove(morph_t morph_mode, long x, long y);
	ErrorManager::error_code_t	AddEdge(morph_t morph_mode, long x, long y) { Edges::edge_t edge(x, y); return AddEdge(morph_mode, edge); }
	ErrorManager::error_code_t	AddEdge(morph_t morph_mode, long x, long y, long ctrl_x, long ctrl_y) { Edges::edge_t edge(x, y, ctrl_x, ctrl_y); return AddEdge(morph_mode, edge); };
	void				NewStyles(void);
	ErrorManager::error_code_t	AddStyle(const Style& style, fill_t fill = SHAPE_FILL_EVEN);
	void				SetAlignZone(const SRectangle& zone);
	ErrorManager::error_code_t	SetBounds(int index, const SRectangle& rect, bool show = false);
	ErrorManager::error_code_t	SetStrokesBounds(int index, const SRectangle& rect);
	void				ShowBounds(bool show = true) { f_show_bounds = show; }
	void				ShowOrigin(bool show = true) { f_show_origin = show; }
	void				SetNonScalingStrokes(bool has_non_scaling_strokes) { f_has_non_scaling_strokes = has_non_scaling_strokes; }
	void				SetScalingStrokes(bool has_scaling_strokes) { f_has_scaling_strokes = has_scaling_strokes; }
	void				Glyph(void);

	bool				HasShowBounds(void) const { return f_show_bounds; }

invisible:
	ErrorManager::error_code_t	AddEdge(morph_t morph_mode, const Edges::edge_t& edge);

private:
	enum what_t {
		SHAPE_EDGES,
		SHAPE_SETUP
	};

	/// A base class to define edges and setup information
	struct shape_what_t : public ItemBase
	{
		what_t		f_what;
				shape_what_t(what_t what) { f_what = what; }
	};
	/// The set of edges: line and curve segments
	struct shape_edges_t : public shape_what_t
	{
		Edges		f_edges;
				shape_edges_t(what_t what) : shape_what_t(what) {}
	};
	/// The set of setup: fill, line and move
	struct shape_setup_t : public shape_what_t
	{
		int		f_fill_ref[2];
		int		f_line_ref;
		long		f_x;
		long		f_y;

				shape_setup_t(what_t what, bool origin = false) : shape_what_t(what)
				{
					f_fill_ref[0] = f_fill_ref[1] = f_line_ref = -1;
					if(origin) {
						f_x = f_y = 0;
					}
					else {
						f_x = f_y = LONG_MIN;
					}
				}
	};

	/// Records to separate different sets of styles
	struct shape_record_t : public ItemBase {		// used to save in f_shapes
		Vectors *	f_fill_styles;
		Vectors *	f_line_styles;
		Vectors *	f_record;
	};

	/// Holds information used to save a shape
	struct save_info_t {
		shape_record_t	f_sr;
		bool		f_save_alpha;
		bool		f_ext_size;
		bool		f_first;
		bool		f_save_styles;
		bool		f_shape4;
		Data		f_data;			// we save it all here (we need to have the size before to create the tag data)
		int		f_fill_bits_count;
		int		f_line_bits_count;
	};

	void				RecordEdges(void);
	void				RecordSetup(void);
	void				NewEdges(void);
	void				NewSetup(void);
	void				SetMorph(void);

	// save sub-functions
	virtual ErrorManager::error_code_t PreSave(void);
	ErrorManager::error_code_t	SaveShape(save_info_t& info, shape_setup_t& last_setup);
	//ErrorManager::error_code_t	SaveMorph(Data& data);
	ErrorManager::error_code_t	SaveSetup(save_info_t& info, const shape_setup_t& setup, shape_setup_t& last);
	ErrorManager::error_code_t	SaveStyles(save_info_t& info);
	ErrorManager::error_code_t	SaveStylesCount(save_info_t& info, long count);

	unsigned char			f_version;		// the minimum version necessary to save this shape (determines the tag)
	bool				f_morph;		// this is a morph shape
	bool				f_is_glyph;		// used only as a glyph (font character)
	bool				f_show_bounds;		// draw the bounding rectangle around the shape
	bool				f_show_origin;		// draw lines showing the origin
	bool				f_has_non_scaling_strokes;	// whether there is at least one non-scaling stroke
	bool				f_has_scaling_strokes;	// whether there is at least one scaling stroke
	SRectangle			f_align_zone;		// to align glyphs the best we can
	SRectangle			f_bounds[2];		// where the shape is drawn
	SRectangle			f_strokes_bounds[2];	// where the shape is drawn

	Vectors				f_shapes;		// each shape saved here has its own set of fill & line style

	shape_edges_t *			f_edges;		// if not NULL that's the current Edges to fill
	shape_edges_t *			f_morph_edges;		// if not NULL that's the current Edges to fill the morph (2nd shape)
	shape_setup_t *			f_setup;		// if not NULL that's the current Setup to define
	Vectors				f_fill_styles;
	Vectors				f_line_styles;
	Vectors				f_record;		// the current shape being built
	Vectors				f_morph_record;		// the current morph shape being built
};



exposed_class TagSound : public TagBaseID
{
public:
	enum sound_format_t {
		SOUND_FORMAT_UNKNOWN = -1,
		SOUND_FORMAT_RAW = 0,
		SOUND_FORMAT_ADPCM = 1,
		SOUND_FORMAT_MP3 = 2,
		SOUND_FORMAT_UNCOMPRESSED = 3,
		SOUND_FORMAT_NELLYMOSER = 6
	};
	enum sound_endian_t {
		SOUND_ENDIAN_LITTLE = 0,	// the user data is in little endian
		SOUND_ENDIAN_BIG,		// the user data is in big endian
		SOUND_ENDIAN_SAME,		// accept processor endianess as the data endianess
		SOUND_ENDIAN_DONTUSE,		// use this for 8bits data
		SOUND_ENDIAN_UNKNOWN		// undefined endianess -- the SetData() will always fail with this value
	};

				TagSound(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;

	size_t			GetSamplesCount(void) const;

/////////////// SETUP FUNCTIONS
	ErrorManager::error_code_t SetFilename(const char *filename);
	void			SetFormat(sound_format_t format);
	int			SetData(const void *data, size_t size, sound_endian_t endian, int width, unsigned int rate, bool stereo);
	void			SetMono(void);
	void			Set8Bits(void);

invisible:
	static const int	g_sound_rates[4];

private:
	/// defines an MP3 sound wave (format, channels, rate, alignment, etc.)
	struct sound_wave_t {
		short		format;			// the data format (we only support PCM)
		short		channels;		// number of channels (1 - mono, 2 - stereo)
		int		rate;			// exact sample rate to play the sound at
		int		average_rate;		// average rate for the entire set of samples (this may vary in compressed files)
		short		align;			// byte alignment of the samples (every char, short, long...)
		/* the following is format dependent, but at this time doesn't vary for us */
		short		width;			// width of the samples (8 or 16)
	};

	virtual ErrorManager::error_code_t PreSave(void);
	short			ReadSample(const unsigned char *data, unsigned short adjust, int in_fmt);
	void			Resample(unsigned char *snd, unsigned int out_bytes, const unsigned char *src, size_t size, unsigned int in_bytes, size_t max, double fix, unsigned short adjust, int in_fmt);
	int			LoadWaveFile(FILE *f);
	int			LoadMP3File(FILE *f);
	int			CheckMP3Header(FILE *f, unsigned char *header, int& frame_size);
	int			ReadMP3Header(FILE *f, unsigned char *header);

	static const int	g_bitrates[2][16];
	static const int	g_frequencies[4][4];

	sound_format_t		f_format;
	bool			f_stereo;
	int			f_rate;
	int			f_width;
	size_t			f_samples;
	int			f_data_size;
	int			f_data_maxsize;
	unsigned char *		f_data;
	int			f_latency_seek;
};






exposed_class TagSprite : public TagBaseID, public TagScalingGrid
{
public:
				TagSprite(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t	TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	// Add objects to a sprite by defining the sprite tag as
	// the parent of these objects.
	// The parent of a sprite must be a TagHeader object.

	// We now have one setup function: SetGrid() inherited from
	// the TagScalingGrid class

protected:
	virtual ErrorManager::error_code_t OnNewChild(const char *child_name) const;

private:
	virtual ErrorManager::error_code_t PreSave(void);
};




exposed_class TagText : public TagBaseID, public TagCSMTextSettings
{
public:
					TagText(TagBase *parent);

	virtual ErrorManager::error_code_t Save(Data& data);
	virtual swf_type_t		TypeFlags(void) const;

/////////////// SETUP FUNCTIONS
	void				SetMatrix(const Matrix& matrix);
	void				SetBounds(const SRectangle& bounds);
	ErrorManager::error_code_t	AddText(const char *string, long advance = LONG_MIN);
	void				AddFont(const TagFont *font, long height);
	void				AddOffsets(long x, long y);
	void				AddColor(Color& color);

private:
	enum text_type_t {
		TEXT_ENTRY_TEXT = 0,
		TEXT_ENTRY_SETUP
	};

	/// Structure used to memories the type of definition
	struct text_define_t : public ItemBase {		// used to save in f_shapes
		const text_type_t	f_type;

					text_define_t(text_type_t type) : f_type(type) {}
	};

	/// Structure representing a text setup
	struct text_setup_t : public text_define_t {		// used to save in f_shapes
		bool			f_has_font;
		const TagFont *		f_font;
		unsigned short		f_font_height;
		bool			f_has_xadjust;
		long			f_xadjust;
		bool			f_has_xoffset;
		long			f_x;
		bool			f_has_yoffset;
		long			f_y;
		bool			f_has_color;
		Color			f_color;

					text_setup_t(void);
					text_setup_t(const text_setup_t& setup);
		void			Unused(void);
		bool			IsUsed(void) const;
	};

	/// Structure representing a text entry (an actual string)
	struct text_entry_t : public text_define_t {
		sswf_ucs4_t *		f_text;
		long			f_advance;
		unsigned long		f_length;		// length of the string
		unsigned long		f_exact_length;		// length of string without spaces
		TagFont::font_info_t *	f_entries;		// an array of entries

					text_entry_t(sswf_ucs4_t *string, long advance);
	};

	virtual ErrorManager::error_code_t PreSave(void);
	int				DefineText(int start, text_setup_t *s, const TagFont *font, int font_height);
	ErrorManager::error_code_t	RecordSetup(void);
	void				NewSetup(void);

	Matrix			f_matrix;		// a transformation matrix for this text
	SRectangle		f_bounds;		// where the string is drawn
	text_setup_t		f_setup;		// current setup definition
	bool			f_new_text;		// if true we need to recompute the text info entries
	int			f_version;		// the PreSave() defines this, Save() uses it
	Vectors			f_records;		// text records
};









};		// namespace sswf
#endif			/* #ifndef LIBSSWF_H */