libsswf: libsswf.h Source File

# libsswf.h

Go to the documentation of this file.

    00001 /* libsswf.h -- written by Alexis WILKE for Made to Order Software Corp. (c) 2002-2009 */
    00002 #ifndef LIBSSWF_H
    00003 #define LIBSSWF_H
    00004
    00005 /*
    00006
    00007 Copyright (c) 2002-2009 Made to Order Software Corp.
    00008
    00009 Permission is hereby granted, free of charge, to any
    00010 person obtaining a copy of this software and
    00011 associated documentation files (the "Software"), to
    00012 deal in the Software without restriction, including
    00013 without limitation the rights to use, copy, modify,
    00014 merge, publish, distribute, sublicense, and/or sell
    00015 copies of the Software, and to permit persons to whom
    00016 the Software is furnished to do so, subject to the
    00017 following conditions:
    00018
    00019 The above copyright notice and this permission notice
    00020 shall be included in all copies or substantial
    00021 portions of the Software.
    00022
    00023 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
    00024 ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
    00025 LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
    00026 FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
    00027 EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
    00028 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
    00029 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
    00030 ARISING FROM, OUT OF OR IN CONNECTION WITH THE
    00031 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    00032 SOFTWARE.
    00033
    00034 */
    00035
    00036 /** \file
    00037  *
    00038  * \brief The header to include to use the SSWF C++ library
    00039  *
    00040  * The libsswf.h file includes all the necessary classes
    00041  * for the SSWF library.
    00042  */
    00043
    00044
    00045
    00046 #include        <stdarg.h>
    00047 #include        <stdio.h>
    00048 #include        <stdlib.h>
    00049 #ifndef _MSVC
    00050 #include        <unistd.h>
    00051 #endif
    00052 #include        <string.h>
    00053 #include        <limits.h>
    00054 #include        <errno.h>
    00055 #include        <zlib.h>
    00056 #include        <math.h>
    00057 #include        <ctype.h>
    00058 #include        <wctype.h>
    00059 #ifdef STATIC_ICONV
    00060 #include        <iconv.h.static>
    00061 #else
    00062 #include        <iconv.h>
    00063 #endif
    00064
    00065 #if IRIX
    00066 #include        <sys/endian.h>
    00067 #endif
    00068
    00069 #include        "sswf/libsswf-config.h"
    00070
    00071 /* wint_t is an "equivalent" to wchar_t without being limited to 16 bits as on MS-Windows */
    00072 #ifndef _MSVC
    00073 #ifndef __APPLE_CC__
    00074 #ifndef _WINT_T
    00075 #define _WINT_T
    00076 typedef unsigned int    wint_t;
    00077 #endif
    00078 #endif
    00079 #endif
    00080
    00081 #ifndef M_PI
    00082 #define M_PI            3.14159265358979323846
    00083 #endif
    00084
    00085
    00086 #ifdef _MSVC
    00087 #define strcasecmp      stricmp
    00088 #define rint(x)         ((double) (long) floor(x + 0.5))
    00089 #endif
    00090
    00091 #ifdef _LIBICONV_H
    00092 #define ICONV_INPUT_CAST
    00093 #else
    00094 /* older versions of iconv() were broken in regard to the
    00095  * input buffer which wasn't const; newer versions have the
    00096  * _LIBICONV_H #define at the start so this is good to know
    00097  * whether we have to cast or not.
    00098  */
    00099 #define ICONV_INPUT_CAST        (char**)
    00100 #endif
    00101
    00102
    00103
    00104 /* The following I use to tell my C++ to C tool
    00105  * what needs to be exposed in C & PHP.
    00106  * These macros show you what is equivalent in C++
    00107  *
    00108  * exposed_class        A class we want exposed in C.
    00109  *
    00110  * invisible            Members that are public in C++ but
    00111  *                      not exposed to C users.
    00112  */
    00113 #define exposed_class   class
    00114 #define invisible       public
    00115
    00116
    00117
    00118 /** \brief The C++ SSWF library namespace
    00119  *
    00120  * The SSWF library is fully defined with the 'sswf' namespace.
    00121  *
    00122  * Do 'using namespace sswf;' to "get rid of it".
    00123  *
    00124  * The SSWF library is a full set of classes and functions used to create
    00125  * SWF binary files. The library supports most of the tags available in
    00126  * SWF and is used to compress them in the appropriate format for use
    00127  * by a Flash player.
    00128  *
    00129  * One important point about this library: it hides from you, the user,
    00130  * the lower layers of the SWF tags. For one thing, you will never have
    00131  * to worry about how to compress the data in a valid SWF tag. But not
    00132  * only that, the library takes care of selecting the appropriate tag
    00133  * depending on the output movie version and what each tag support.
    00134  *
    00135  * For instance, when you create a TagFont, the library hides from you
    00136  * the fact that it supports 3 different types of DefineFont tags (and
    00137  * once version 8 is supported, it will hide the DefineFontAlignZones).
    00138  * This means you don't need to know all the details of how to create
    00139  * a font. Such details are important for the library, but not to you.
    00140  *
    00141  * None the less, it is complicated to create a valid SWF shape and the
    00142  * library does not do that automatically for you. For more information
    00143  * about each specific tag, please read the corresponding documentation.
    00144  */
    00145 namespace sswf
    00146 {
    00147
    00148
    00149
    00150
    00151 void assert(int cond, const char *format, ...)
    00152 #ifndef _MSVC
    00153                         __attribute__ ((format (printf, 2, 3)))
    00154 #endif
    00155                 ;
    00156
    00157
    00158 #if DEBUG
    00159 inline void assert(int cond, const char *format, ...)
    00160 {
    00161         va_list         ap;
    00162
    00163         // if the condition is true then we have no problem!
    00164         if(cond) {
    00165                 return;
    00166         }
    00167         fflush(stdout);
    00168         fflush(stderr);
    00169         fprintf(stderr, "\n");
    00170         va_start(ap, format);
    00171         vfprintf(stderr, format, ap);
    00172         va_end(ap);
    00173         fprintf(stderr, ".\n");
    00174         fflush(stderr);         // some systems don't do this inside the abort()!
    00175         abort();
    00176 }
    00177 #else
    00178 inline void assert(int /*cond*/, const char * /*format*/, ...) {}
    00179 #endif
    00180
    00181
    00182 typedef unsigned short          sswf_id_t;              // object ID reference
    00183 typedef unsigned short          sswf_frame_t;           // frame counter
    00184 typedef int32_t                 sswf_ucs4_t;            // a wide character (must be at least 32 bits)
    00185
    00186
    00187 #define SSWF_ID_NONE            ((sswf_id_t) -1)        // this is an invalid ID (it seems)
    00188
    00189
    00190 extern  void                    swap(void *s1, void *s2, size_t size);
    00191 extern  int                     wctomb(const sswf_ucs4_t *wc, size_t wc_len, char *mb, size_t& mb_size);
    00192 extern  int                     mbtowc(const char *mb, size_t mb_len, sswf_ucs4_t *& wc, size_t& wc_len);
    00193 extern  char *                  wcname(sswf_ucs4_t wc, char *result);
    00194 extern  long                    wcslen(sswf_ucs4_t *wcstr);
    00195
    00196 inline unsigned short           swap_short(unsigned short s)
    00197                                 {
    00198                                         return (s >> 8) | (s << 8);
    00199                                 }
    00200
    00201 inline unsigned int             swap_int(unsigned int l)
    00202                                 {
    00203                                         return (l >> 24) | (l << 24)
    00204                                                 | ((l >> 8) & 0x0000FF00)
    00205                                                 | ((l << 8) & 0x00FF0000);
    00206                                 }
    00207
    00208 extern  const char *            sswf_version(void);
    00209
    00210
    00211
    00212
    00213 /*
    00214  * Your class derives from ErrorManager::ErrorHandler, you pass a pointer
    00215  * to the TagHeader object and whenever an error occurs in the SSWF
    00216  * library, the OnError() function is called. You can then decide what to do
    00217  * (i.e. print the message in a file and then throw, exit or return...)
    00218  */
    00219 class ErrorManager
    00220 {
    00221 public:
    00222         enum error_code_t {
    00223                 ERROR_CODE_NONE = 0,
    00224
    00225                 ERROR_CODE_ACTION_OVERFLOW,
    00226                 ERROR_CODE_ALPHA_MISMATCH,
    00227                 ERROR_CODE_BAD_STATE_FLAGS,
    00228                 ERROR_CODE_BAD_STRING,
    00229                 ERROR_CODE_BUTTON_MISSING_STATE,
    00230                 ERROR_CODE_CANNOT_CHANGE_STYLE,
    00231                 ERROR_CODE_CHILDREN_NOT_SUPPORTED,
    00232                 ERROR_CODE_COMPRESSED_SOUND_8BITS,
    00233                 ERROR_CODE_EMPTY_POSITION_RANGE,
    00234                 ERROR_CODE_ENDED_ACTION_SCRIPT,
    00235                 ERROR_CODE_END_OF_STATES,
    00236                 ERROR_CODE_ENHANCED_LINE_REQUIRES_ALPHA,
    00237                 ERROR_CODE_ENVELOPE_EXISTS,
    00238                 ERROR_CODE_ENVELOPE_OVERFLOW,
    00239                 ERROR_CODE_ERRONEOUS_FORMAT,
    00240                 ERROR_CODE_FILE_NOT_FOUND,
    00241                 ERROR_CODE_FORMAT_LOCKED,
    00242                 ERROR_CODE_GLYPH_DEFINED_TWICE,
    00243                 ERROR_CODE_ICONV_ENCODER_NOT_AVAILABLE,
    00244                 ERROR_CODE_ICONV_FAILED,
    00245                 ERROR_CODE_IO,
    00246                 ERROR_CODE_INCOMPATIBLE_CHILD,
    00247                 ERROR_CODE_INCOMPATIBLE_MORPH,
    00248                 ERROR_CODE_INTERNAL_ERROR,
    00249                 ERROR_CODE_INVALID_DEPTH,
    00250                 ERROR_CODE_INVALID_EM_SQUARE,
    00251                 ERROR_CODE_INVALID_FILL_PARAMETER,
    00252                 ERROR_CODE_INVALID_FOCAL,
    00253                 ERROR_CODE_INVALID_GLYPH,
    00254                 ERROR_CODE_INVALID_IDENTIFIER,
    00255                 ERROR_CODE_INVALID_IMAGE,
    00256                 ERROR_CODE_INVALID_INTERPOLATION_MODE,
    00257                 ERROR_CODE_INVALID_LINE_INFO,
    00258                 ERROR_CODE_INVALID_MORPH_INDEX,
    00259                 ERROR_CODE_INVALID_OBJECT_EXPORTED,
    00260                 ERROR_CODE_INVALID_POSITION,
    00261                 ERROR_CODE_INVALID_SHAPE,
    00262                 ERROR_CODE_INVALID_SPREAD_MODE,
    00263                 ERROR_CODE_INVALID_SPRITE_DEFINITION,
    00264                 ERROR_CODE_INVALID_STYLE,
    00265                 ERROR_CODE_INVALID_TEXT_SETUP,
    00266                 ERROR_CODE_JPEG,
    00267                 ERROR_CODE_LOOP_ZERO,
    00268                 ERROR_CODE_MISSING_FRAME_NAME,
    00269                 ERROR_CODE_MISSING_SHAPE,
    00270                 ERROR_CODE_MORPH_GRADIENT_LIMIT,
    00271                 ERROR_CODE_MORPH_REQUIRES_ALPHA,
    00272                 ERROR_CODE_NAME_TOO_LONG,
    00273                 ERROR_CODE_NEGATIVE_MITER,
    00274                 ERROR_CODE_NO_FOCAL_WITH_MORPH,
    00275                 ERROR_CODE_NO_HEADER,
    00276                 ERROR_CODE_NO_STATES,
    00277                 ERROR_CODE_NO_SUCH_GLYPH,
    00278                 ERROR_CODE_LABEL_NOT_FOUND,
    00279                 ERROR_CODE_LABEL_OVERFLOW,
    00280                 ERROR_CODE_MORPH_MISMATCH,
    00281                 ERROR_CODE_NOT_ENOUGH_DATA,
    00282                 ERROR_CODE_OBJECT_NOT_FOUND,
    00283                 ERROR_CODE_REGISTER_OVERFLOW,
    00284                 ERROR_CODE_SIZE_MISMATCH,
    00285                 ERROR_CODE_START_SOUND_NO_INFO,
    00286                 ERROR_CODE_TOO_MANY_STYLES,
    00287                 ERROR_CODE_TWO_OR_MORE_JPEGTABLES,
    00288                 ERROR_CODE_TWO_OR_MORE_METADATA,
    00289                 ERROR_CODE_UNEXPECTED_EVENT_FLAG,
    00290                 ERROR_CODE_UNKNOWN_ACTION,
    00291                 ERROR_CODE_UNKNOWN_FORMAT,
    00292                 ERROR_CODE_UNKNOWN_IMMEDIATE_DATA_TYPE,
    00293                 ERROR_CODE_UNKNOWN_OBJECT_EXPORTED,
    00294                 ERROR_CODE_UNKNOWN_TAG,
    00295                 ERROR_CODE_UNSUPPORTED_IMAGE_FORMAT,
    00296                 ERROR_CODE_UNSUPPORTED_SOUND_FORMAT,
    00297                 ERROR_CODE_UNSUPPORTED_ZONE_COUNT,
    00298                 ERROR_CODE_VERSION_UNSATISFIED,
    00299                 ERROR_CODE_VOLUME_OUT_OF_RANGE,
    00300
    00301                 ERROR_CODE_max
    00302         };
    00303
    00304                                 ErrorManager(void);
    00305
    00306         void                    Reset(void);
    00307         int                     Count(void) const;
    00308         static error_code_t     KeepFirst(error_code_t a, error_code_t b);
    00309
    00310         error_code_t            OnError(error_code_t errcode, const char *message, va_list ap) const;
    00311
    00312 public:
    00313         class OutOfBoundsErrorException {};
    00314         class InternalErrorException {};
    00315
    00316         class ErrorHandler
    00317         {
    00318         public:
    00319                 virtual                 ~ErrorHandler();
    00320                 virtual error_code_t    OnError(error_code_t errcode, const char *msg) = 0;
    00321         };
    00322
    00323         ErrorHandler *          SetErrorHandler(ErrorHandler *error_handler);
    00324         error_code_t            OnError(error_code_t errcode, const char *message, ...) const;
    00325
    00326 private:
    00327         mutable int             f_error_count;
    00328         ErrorHandler *          f_error_handler;
    00329 };
    00330
    00331
    00332
    00333
    00334
    00335
    00336 class Buffer;
    00337 class MemBuffer
    00338 {
    00339 public:
    00340                                 MemBuffer(void);
    00341         virtual                 ~MemBuffer();
    00342
    00343         void                    AttachBuffer(Buffer *buffer);
    00344         Buffer *                GetBuffer(void) const;
    00345
    00346 private:
    00347         Buffer *                f_buffer;
    00348 };
    00349
    00350
    00351 class Buffer
    00352 {
    00353 public:
    00354                                 Buffer(Buffer **head, size_t size, const char *info);
    00355                                 Buffer(Buffer **head, MemBuffer *ptr, size_t size, const char *info);
    00356                                 //Buffer(Buffer **head, void *ptr, size_t size, const char *info);
    00357                                 ~Buffer();
    00358
    00359         void *                  Realloc(size_t size);
    00360         void *                  Data(void) const { return f_data; }
    00361         Buffer *                Next(void) const { return (Buffer *) f_next; }
    00362         Buffer *                Previous(void) const { return (Buffer *) f_previous; }
    00363         size_t                  Size(void) const { return f_size; }
    00364         const char *            Info(void) const { return f_info; }
    00365
    00366         static Buffer *         FindBuffer(void *ptr);
    00367 #if 0
    00368 // this is totally wrong and it simply can't be used safely
    00369         static bool             IsBuffer(void *ptr);
    00370 #endif
    00371
    00372 private:
    00373         /// Hold the magic and a pointer to the actual buffer
    00374         struct mem_buffer_t {
    00375                 unsigned long   f_magic;        // to make sure we have indeed a valid buffer
    00376                 Buffer *        f_buffer;       // reference back to 'this' buffer
    00377         };
    00378         enum {
    00379                 DMAGIC = (unsigned long) 0x53535746,    // direct (malloc)
    00380                 OMAGIC = (unsigned long) 0x5353574F     // object (new/delete)
    00381         };
    00382 #define SSWF_ALIGN(value, modulo)       (((value) + ((modulo) - 1)) & - (long) (modulo))
    00383 #define SSWF_SPACE                      SSWF_ALIGN(sizeof(mem_buffer_t), sizeof(double))
    00384 #if DEBUG
    00385         void                            Test(void);
    00386 #define SSWF_SAFE                       (sizeof(double) * 32)
    00387 #define SSWF_TEST                       ((long)0xBADC0FFE)
    00388 #else
    00389 #define SSWF_SAFE                       0
    00390 #endif
    00391
    00392         Buffer **               f_head;         // header for this list of buffers
    00393         Buffer *                f_next;
    00394         Buffer *                f_previous;
    00395         const char *            f_info;
    00396         size_t                  f_size;
    00397         mutable void *          f_data;
    00398 };
    00399
    00400
    00401 class MemoryManager
    00402 {
    00403 public:
    00404                                 MemoryManager(void);
    00405         virtual                 ~MemoryManager();
    00406
    00407         void                    MemAttach(MemBuffer *ptr, size_t size, const char *info);       // used when you require the use of a ::new ... call
    00408         void *                  MemAlloc(size_t size, const char *info);
    00409         void *                  MemRealloc(void *ptr, size_t size, const char *info);   // info used ONLY if ptr == 0
    00410         void                    MemFree(void *ptr);
    00411         void                    MemClean(void *ptr);
    00412         char *                  StrDup(const char *string);
    00413         char *                  StrCat(const char *s1, const char *s2);
    00414 #if DEBUG
    00415         void                    MemTest(void *ptr);
    00416 #endif
    00417         unsigned long           Size(void *ptr);
    00418
    00419 private:
    00420         Buffer *                f_head;
    00421 };
    00422
    00423
    00424
    00425 class ItemBase : public MemBuffer
    00426 {
    00427 public:
    00428                                 ItemBase(void) {}
    00429         virtual                 ~ItemBase() {}
    00430 };
    00431
    00432
    00433 class Vectors : public MemoryManager, public MemBuffer
    00434 {
    00435 public:
    00436                                 Vectors(void);
    00437                                 Vectors(const Vectors& vector);
    00438                                 ~Vectors();
    00439
    00440         ItemBase *              Get(int index) const;
    00441         void                    Set(int index, ItemBase *vector);
    00442         void                    Insert(int index, ItemBase *vector);
    00443         void                    SetSize(int size);
    00444         int                     Count(void) const { return f_count; }
    00445         void                    Empty(void) { f_count = 0; }    // currently we keep the f_vectors buffer
    00446
    00447 public:
    00448         Vectors&                operator = (const Vectors& vectors);
    00449
    00450 private:
    00451         int                     f_count;                // # of valid pointers
    00452         int                     f_max;                  // max. # of pointers until realloc
    00453         ItemBase **             f_vectors;              // an array of pointers
    00454 };
    00455
    00456
    00457
    00458
    00459
    00460
    00461
    00462 class Data : public MemoryManager
    00463 {
    00464 public:
    00465                                 Data(void);
    00466                                 ~Data();
    00467
    00468         void                    Empty(void) { f_pos = 0; f_limit = 0; f_rpos = 0; }     // mark the buffer as empty (reset/restart)
    00469         void                    Align(void);                            // align to the next byte
    00470         void                    Overwrite(size_t offset, const void *ptr, size_t size);
    00471         void                    OverwriteByte(size_t offset, char c);
    00472         void                    OverwriteShort(size_t offset, short s);
    00473         void                    OverwriteLong(size_t offset, long l);
    00474         void                    Write(const void *ptr, size_t size);    // write bytes
    00475         void                    WriteBits(long value, size_t bits);     // write the 'bits' lower bits of 'value'
    00476         void                    PutByte(char c);                        // write one byte
    00477         void                    PutShort(short s);                      // write one short (auto-swap)
    00478         void                    PutLong(long l);                        // write one long, 32 bits (auto-swap)
    00479         void                    PutDLong(int64_t ll);                   // write one long, 64 bits (auto-swap)
    00480         void                    PutShortFloat(float f);                 // write one float, 16 bits (auto-conversion)
    00481         void                    PutLongFloat(float f);                  // write one float, 32 bits (auto-swap)
    00482         void                    PutDoubleFloat(double f);               // write one float, 64 bits (auto-swap)
    00483         void                    PutString(const char *string);          // write a null terminated string (including the terminator)
    00484         void                    Append(const Data& append);             // append another data buffer in here
    00485
    00486         void                    Read(void *& ptr, size_t& size);        // retrieve the buffer and its size rounded up to the next byte (Align() is called once)
    00487         void                    Read(const void *& ptr, size_t& size) const;    // retrieve the buffer and its size rounded up to the next byte (Align() is called once)
    00488                                                                         // if you want the size in bits, use the Size() function call
    00489
    00490         unsigned long           ByteSize(void) const { return (f_pos + CHAR_BIT - 1) / CHAR_BIT; }
    00491         unsigned long           GetSize(void) const { return f_pos; }   // total size in bits
    00492         void                    SetSize(unsigned long size);
    00493
    00494         bool                    IsEndOfData(void) const;
    00495         unsigned long           Limit(unsigned long limit, bool offset) const;
    00496
    00497 public:
    00498         // The Get...() functions return an error if the position is out of bounds
    00499         ErrorManager::error_code_t      ReadAlign(void) const;          // fails when we reach the end of the buffer
    00500         size_t                          GetReadPosition(void) const;            // bit position for the Get...() functions, default to 0
    00501         ErrorManager::error_code_t      SetReadPosition(size_t pos) const;      // bit position for the Get...() functions
    00502         ErrorManager::error_code_t      ReadBytes(void *ptr, size_t size) const;// read 'size' bytes
    00503         ErrorManager::error_code_t      GetBits(int& value, size_t bits) const; // read 'bits' bits from buffer and write the result in 'value'
    00504         ErrorManager::error_code_t      GetByte(int8_t& c) const;
    00505         ErrorManager::error_code_t      GetByte(uint8_t& c) const;
    00506         ErrorManager::error_code_t      GetShort(int16_t& s) const;
    00507         ErrorManager::error_code_t      GetShort(uint16_t& s) const;
    00508         ErrorManager::error_code_t      GetLong(int32_t& l) const;
    00509         ErrorManager::error_code_t      GetLong(uint32_t& l) const;
    00510         ErrorManager::error_code_t      GetDLong(int64_t& ll) const;
    00511         ErrorManager::error_code_t      GetDLong(uint64_t& ll) const;
    00512         ErrorManager::error_code_t      GetShortFloat(float& f) const;          // 16 bits
    00513         ErrorManager::error_code_t      GetLongFloat(float& f) const;           // 32 bits
    00514         ErrorManager::error_code_t      GetDoubleFloat(double& f) const;        // 64 bits
    00515         ErrorManager::error_code_t      GetString(MemoryManager *mem, int l, char **str) const; // read a whole string
    00516
    00517         class DataLimit
    00518         {
    00519         public:
    00520                                         DataLimit(const Data& data, unsigned long limit, bool offset = true);
    00521                                         ~DataLimit();
    00522
    00523                 void                    Restore();
    00524
    00525         private:
    00526                 const Data * const      f_data;
    00527                 const unsigned long     f_old_limit;
    00528                 bool                    f_restored;
    00529         };
    00530
    00531 private:
    00532         void                    AdjustSize(size_t size);
    00533
    00534         unsigned long           f_pos;
    00535         unsigned long           f_limit;        // current limit (if not zero)
    00536         mutable unsigned long   f_rpos;         // read position (fot Get...() functions)
    00537         unsigned long           f_size;
    00538         char *                  f_data;
    00539 };
    00540
    00541
    00542
    00543
    00544
    00545
    00546 // the following are structures used within the tags defined afterward
    00547 class SRectangle
    00548 {
    00549 public:
    00550                                 SRectangle(void);
    00551
    00552         void                    Reset(void);
    00553         void                    Set(long xmin, long xmax, long ymin, long ymax);
    00554         void                    SetReorder(long xmin, long xmax, long ymin, long ymax);
    00555         long                    XMin(void) const;
    00556         long                    XMax(void) const;
    00557         long                    YMin(void) const;
    00558         long                    YMax(void) const;
    00559         bool                    IsEmpty(void) const;
    00560
    00561         void                    Save(Data& data) const;
    00562         ErrorManager::error_code_t Parse(const Data& data);
    00563
    00564 private:
    00565         long                    f_xmin;
    00566         long                    f_xmax;
    00567         long                    f_ymin;
    00568         long                    f_ymax;
    00569 };
    00570
    00571
    00572 class Color
    00573 {
    00574 public:
    00575                                 Color(void) { Reset(); }
    00576
    00577         void                    Reset(void);
    00578         void                    Set(unsigned char red, unsigned char green, unsigned char blue, unsigned char alpha = 255);
    00579         unsigned char           Red(void)   const { return f_red;   }
    00580         unsigned char           Green(void) const { return f_green; }
    00581         unsigned char           Blue(void)  const { return f_blue;  }
    00582         unsigned char           Alpha(void) const { return f_alpha; }
    00583
    00584         void                    Save(Data& data, bool save_alpha = true) const;
    00585         ErrorManager::error_code_t Parse(const Data& data, bool parse_alpha = true);
    00586
    00587         bool                    IsSolid(void) const { return f_alpha == 255; }
    00588         bool                    IsInvisible(void) const { return f_alpha == 0; }
    00589
    00590 public:
    00591         bool                    operator == (const Color& color) const;
    00592         bool                    operator != (const Color& color) const;
    00593
    00594 private:
    00595         unsigned char           f_red;
    00596         unsigned char           f_green;
    00597         unsigned char           f_blue;
    00598         unsigned char           f_alpha;
    00599 };
    00600
    00601
    00602
    00603 class ColorTransform
    00604 {
    00605 public:
    00606                                 ColorTransform(void);
    00607
    00608         void                    Reset(void);
    00609         void                    SetAdd(double red, double green, double blue, double alpha = 0.0);
    00610         void                    SetMult(double red, double green, double blue, double alpha = 1.0);
    00611         double                  AddRed(void)    const { return f_add_red;   }
    00612         double                  AddGreen(void)  const { return f_add_green; }
    00613         double                  AddBlue(void)   const { return f_add_blue;  }
    00614         double                  AddAlpha(void)  const { return f_add_alpha; }
    00615         double                  MultRed(void)   const { return f_add_red;   }
    00616         double                  MultGreen(void) const { return f_add_green; }
    00617         double                  MultBlue(void)  const { return f_add_blue;  }
    00618         double                  MultAlpha(void) const { return f_add_alpha; }
    00619
    00620         void                    Save(Data& data, bool save_alpha = true);
    00621         ErrorManager::error_code_t Parse(const Data& data, bool load_alpha = true);
    00622
    00623         bool                    IsNull(bool with_alpha) const;          // if true we can ignore this transformation!
    00624         bool                    IsSolidCompatible(void) const;          // if true we can ignore the alpha channel!
    00625
    00626 private:
    00627         double                  f_add_red;
    00628         double                  f_add_green;
    00629         double                  f_add_blue;
    00630         double                  f_add_alpha;
    00631         double                  f_mult_red;
    00632         double                  f_mult_green;
    00633         double                  f_mult_blue;
    00634         double                  f_mult_alpha;
    00635 };
    00636
    00637
    00638
    00639 class Matrix
    00640 {
    00641 public:
    00642                                 Matrix(void);
    00643
    00644         void                    Reset(void);
    00645         void                    SetScale(double x, double y) { f_scale_x = x; f_scale_y = y; }
    00646         void                    SetScale(double scale) { f_scale_x = scale; f_scale_y = scale; }
    00647         void                    SetRotate(double rotate);
    00648         void                    SetSkew(double skew0, double skew1) { f_skew_0 = skew0; f_skew_1 = skew1; }
    00649         void                    SetTranslate(long x, long y) { f_translate_x = x; f_translate_y = y; }
    00650
    00651         void                    Save(Data& data);
    00652         ErrorManager::error_code_t Parse(const Data& data);
    00653
    00654         bool                    IsNull(void) const;
    00655
    00656 public:
    00657         bool                    operator == (const Matrix& matrix) const;
    00658         bool                    operator != (const Matrix& matrix) const;
    00659
    00660 private:
    00661         /// Matrix of longs; used to compute the matrix to be saved in the movie
    00662         struct signed_matrix_t {
    00663                 long    m[4];
    00664         };
    00665
    00666         void                    ComputeMatrix(signed_matrix_t& m) const;
    00667         void                    UncomputeMatrix(const signed_matrix_t& m);
    00668
    00669         double                  f_scale_x;
    00670         double                  f_scale_y;
    00671         double                  f_rotate;
    00672         long                    f_translate_x;
    00673         long                    f_translate_y;
    00674         double                  f_skew_0;
    00675         double                  f_skew_1;
    00676 };
    00677
    00678
    00679
    00680 class Envelope : public ItemBase
    00681 {
    00682 public:
    00683                                 Envelope(unsigned long p, unsigned short l, unsigned short r);
    00684                                 Envelope(const Envelope& envelope);
    00685
    00686         unsigned long           Position(void) const;
    00687         unsigned short          Left(void) const;
    00688         unsigned short          Right(void) const;
    00689         void                    Save(Data& data) const;
    00690
    00691 private:
    00692         unsigned long           f_position;
    00693         unsigned short          f_left;
    00694         unsigned short          f_right;
    00695 };
    00696
    00697
    00698 class SoundInfo : public MemoryManager
    00699 {
    00700 public:
    00701                                 SoundInfo(ErrorManager& error_manager);
    00702
    00703         void                    SetSoundID(sswf_id_t id);
    00704         void                    StopSound(bool stop = true);
    00705         void                    NoMultiple(bool no_multiple = true);
    00706         void                    SetRange(unsigned long start, unsigned long end);
    00707         void                    SetLoop(unsigned short loop);
    00708         void                    AddEnvelope(const Envelope& envelope);
    00709
    00710         ErrorManager::error_code_t PreSave(void);               // called by the TagStartSound::PreSave()
    00711         void                    Save(Data& data) const;
    00712
    00713 private:
    00714         ErrorManager&           f_error_manager;        // the TagHeader
    00715         sswf_id_t               f_sound_id;
    00716         bool                    f_stop;                 // if true, ignore all the other info
    00717         bool                    f_no_multiple;          // never play this sound more than once
    00718         unsigned long           f_start_position;       // start playing from this sample
    00719         unsigned long           f_end_position;         // stop playing at this sample
    00720         unsigned short          f_loop;                 // repeat the sound this many times
    00721         Vectors                 f_envelopes;            // a list of position + volume information
    00722 };
    00723
    00724
    00725
    00726
    00727 class BlendMode
    00728 {
    00729 public:
    00730         enum blend_mode_t {
    00731                 BLEND_MODE_UNDEFINED = -1,
    00732                 BLEND_MODE_NORMAL = 1,
    00733                 BLEND_MODE_LAYER = 2,
    00734                 BLEND_MODE_MULTIPLY = 3,
    00735                 BLEND_MODE_SCREEN = 4,
    00736                 BLEND_MODE_LIGHTEN = 5,
    00737                 BLEND_MODE_DARKEN = 6,
    00738                 BLEND_MODE_DIFFERENCE = 7,
    00739                 BLEND_MODE_ADD = 8,
    00740                 BLEND_MODE_SUBTRACT = 9,
    00741                 BLEND_MODE_INVERT = 10,
    00742                 BLEND_MODE_ALPHA = 11,
    00743                 BLEND_MODE_ERASE = 12,
    00744                 BLEND_MODE_OVERLAY = 13,
    00745                 BLEND_MODE_HARDLIGHT = 14
    00746         };
    00747
    00748                                 BlendMode(void);
    00749
    00750         bool                    HasBlendMode(void) const;
    00751         void                    SetBlendMode(blend_mode_t blend_mode_value);
    00752         bool                    SetBlendModeByName(const char *blend_mode_name);
    00753         blend_mode_t            GetBlendMode(void) const;
    00754
    00755         void                    Save(Data& data);
    00756         ErrorManager::error_code_t Parse(const Data& data);
    00757
    00758 private:
    00759         blend_mode_t            f_blend_mode;
    00760 };
    00761
    00762
    00763 class State : public ItemBase
    00764 {
    00765 public:
    00766         // Use with SetFlags()
    00767         enum state_flags_t {
    00768                 STATE_FLAG_UP           = 0x01,
    00769                 STATE_FLAG_OVER         = 0x02,
    00770                 STATE_FLAG_DOWN         = 0x04,
    00771                 STATE_FLAG_HIT_TEST     = 0x08,
    00772
    00773                 STATE_ALL_FLAGS         = 0x0F
    00774         };
    00775
    00776         explicit                State(ErrorManager& error_manager);
    00777
    00778         void                    Reset(void);
    00779         void                    SetObjectID(sswf_id_t id);
    00780         bool                    SetFlags(unsigned char flags);
    00781         void                    SetLayer(unsigned short layer);
    00782         void                    SetMatrix(const Matrix& matrix);
    00783         void                    SetColorTransform(const ColorTransform& color_transform);
    00784         bool                    HasColorTransform(void) const;
    00785         void                    SetBlendMode(const BlendMode& blend_mode);
    00786         ErrorManager::error_code_t Save(Data& data, bool color_transform);
    00787         ErrorManager::error_code_t Parse(const Data& data, bool color_transform);
    00788
    00789         unsigned char           GetFlags(void) const;
    00790
    00791 private:
    00792         ErrorManager&           f_error_manager;        // the TagHeader
    00793         sswf_id_t               f_id;
    00794         bool                    f_has_color_transform;
    00795         unsigned char           f_flags;
    00796         unsigned short          f_layer;
    00797         Matrix                  f_matrix;
    00798         ColorTransform          f_color_transform;
    00799         BlendMode               f_blend_mode;
    00800 };
    00801
    00802
    00803
    00804
    00805
    00806 class Action;
    00807 class Event : public MemoryManager, public ItemBase
    00808 {
    00809 public:
    00810                                 Event(void);
    00811
    00812         void                    Reset(void);
    00813         void                    SetEvents(unsigned long events);
    00814         void                    SetConditions(unsigned long events);
    00815         void                    SetKey(unsigned char key);
    00816         unsigned long           Events(void) const;     // PlaceObject2 flags
    00817         unsigned long           Conditions(void) const; // DefineButton2 flags
    00818         unsigned char           Key(void) const;
    00819         Vectors&                Actions(void);
    00820
    00821         static unsigned long    StringToEvents(const char *s);
    00822         static unsigned char    StringToKeyCode(const char *s);
    00823
    00824         // the flags are saved with the following bits
    00825         // in a PlaceObject2
    00826         // these have to be converted when saved in a
    00827         // DefineButton2 tag
    00828         enum event_flag_t {
    00829                 EVENT_COND_MENU_LEAVE           = 0x80000000,   // for DefineButton2
    00830                 EVENT_COND_MENU_ENTER           = 0x40000000,   // for DefineButton2
    00831
    00832                 EVENT_CONSTRUCT                 = 0x00040000,   // V7.x
    00833                 EVENT_KEY_PRESS                 = 0x00020000,   // V6.x
    00834                 EVENT_POINTER_DRAG_LEAVE        = 0x00010000,   // V6.x shared with DefineButton2
    00835                 EVENT_POINTER_DRAG_ENTER        = 0x00008000,   // V5.x shared with DefineButton2
    00836                 EVENT_POINTER_LEAVE             = 0x00004000,   // V5.x shared with DefineButton2
    00837                 EVENT_POINTER_ENTER             = 0x00002000,   // V5.x shared with DefineButton2
    00838                 EVENT_POINTER_RELEASE_OUTSIDE   = 0x00001000,   // V5.x shared with DefineButton2
    00839                 EVENT_POINTER_RELEASE_INSIDE    = 0x00000800,   // V5.x shared with DefineButton2
    00840                 EVENT_POINTER_PUSH              = 0x00000400,   // V5.x shared with DefineButton2
    00841                 EVENT_INITIALIZE                = 0x00000200,   // V5.x
    00842                 EVENT_DATA                      = 0x00000100,   // V5.x
    00843                 EVENT_KEY_UP                    = 0x00000080,   // V6.x
    00844                 EVENT_KEY_DOWN                  = 0x00000040,   // V6.x
    00845                 EVENT_POINTER_UP                = 0x00000020,   // V6.x
    00846                 EVENT_POINTER_DOWN              = 0x00000010,   // V6.x
    00847                 EVENT_POINTER_MOVE              = 0x00000008,   // V6.x
    00848                 EVENT_UNLOAD                    = 0x00000004,   // V6.x
    00849                 EVENT_ENTER_FRAME               = 0x00000002,   // V6.x
    00850                 EVENT_ONLOAD                    = 0x00000001    // V5.x
    00851         };
    00852 #define SSWF_EVENT_V5                   0x0000FF01      // flags present in V5
    00853 #define SSWF_EVENT_V6                   0x000300FE      // flags added in V6
    00854 #define SSWF_EVENT_V7                   0x00040000      // flag added in V7
    00855 #define SSWF_EVENT_CONDITIONS           0xC001FC00      // flags used by conditions in DefineButton2
    00856 #define SSWF_EVENT_COUNT                20
    00857         struct event_names_t {
    00858                 event_flag_t            f_flag;
    00859                 const char *            f_name;
    00860         };
    00861
    00862         enum condition_flag_t {
    00863                 CONDITION_KEY_MASK                      = 0xFE00,
    00864                 CONDITION_KEY_SHIFT                     = 9,
    00865                 CONDITION_MENU_LEAVE                    = 0x0100,       // OVER_DOWN_TO_IDLE
    00866                 CONDITION_MENU_ENTER                    = 0x0080,       // IDLE_TO_OVER_DOWN
    00867                 CONDITION_POINTER_RELEASE_OUTSIDE       = 0x0040,       // OUT_DOWN_TO_IDLE
    00868                 CONDITION_POINTER_DRAG_ENTER            = 0x0020,       // OUT_DOWN_TO_OVER_DOWN
    00869                 CONDITION_POINTER_DRAG_LEAVE            = 0x0010,       // OVER_DOWN_TO_OUT_DOWN
    00870                 CONDITION_POINTER_RELEASE_INSIDE        = 0x0008,       // OVER_DOWN_TO_OVER_UP
    00871                 CONDITION_POINTER_PUSH                  = 0x0004,       // OVER_UP_TO_OVER_DOWN
    00872                 CONDITION_POINTER_LEAVE                 = 0x0002,       // OVER_UP_TO_IDLE
    00873                 CONDITION_POINTER_ENTER                 = 0x0001        // IDLE_TO_OVER_UP
    00874         };
    00875
    00876         enum key_code_t {
    00877                 KEY_CODE_NONE = 0,
    00878                 KEY_CODE_LEFT_ARROW = 1,
    00879                 KEY_CODE_RIGHT_ARROW = 2,
    00880                 KEY_CODE_HOME = 3,
    00881                 KEY_CODE_END = 4,
    00882                 KEY_CODE_INSERT = 5,
    00883                 KEY_CODE_DELETE = 6,
    00884                 KEY_CODE_BACKSPACE = 8,
    00885                 KEY_CODE_ENTER = 13,
    00886                 KEY_CODE_UP_ARROW = 14,
    00887                 KEY_CODE_DOWN_ARROW = 15,
    00888                 KEY_CODE_PAGE_UP = 16,
    00889                 KEY_CODE_PAGE_DOWN = 17,
    00890                 KEY_CODE_TAB = 18,
    00891                 KEY_CODE_ESCAPE = 19,
    00892                 KEY_CODE_SPACE = 20,            // equal to ' '
    00893                 // and also all the ASCII codes from 32 to 126
    00894         };
    00895 #define SSWF_KEY_COUNT                  15
    00896         struct key_names_t {
    00897                 key_code_t              f_code;
    00898                 const char *            f_name;
    00899         };
    00900
    00901 public:
    00902         static const event_names_t      g_event_names[SSWF_EVENT_COUNT];
    00903         static const key_names_t        g_key_names[SSWF_KEY_COUNT];
    00904
    00905 private:
    00906         unsigned long           f_events;
    00907         unsigned char           f_key;
    00908         Vectors                 f_actions;
    00909 };
    00910
    00911
    00912
    00913
    00914
    00915 class Style : public ItemBase
    00916 {
    00917 public:
    00918         enum style_t {
    00919                 STYLE_TYPE_UNKNOWN = 0,
    00920                 STYLE_TYPE_NO_LINE,
    00921                 STYLE_TYPE_NO_FILL,
    00922                 STYLE_TYPE_LINE,
    00923                 STYLE_TYPE_ENHANCED_LINE,       // Line 2
    00924                 STYLE_TYPE_SOLID,
    00925                 STYLE_TYPE_GRADIENT_LINEAR,
    00926                 STYLE_TYPE_GRADIENT_RADIAL,
    00927                 STYLE_TYPE_GRADIENT_FOCAL,
    00928                 STYLE_TYPE_BITMAP_TILLED,
    00929                 STYLE_TYPE_BITMAP_CLIPPED,
    00930                 STYLE_TYPE_BITMAP_HARDEDGE_TILLED,
    00931                 STYLE_TYPE_BITMAP_HARDEDGE_CLIPPED,
    00932
    00933                 STYLE_TYPE_MATRIX,              // intermediate type used when a matrix is defined before
    00934                                                 // a gradient or bitmap info (or the SetType() is called)
    00935
    00936                 STYLE_TYPE_max
    00937         };
    00938
    00939         enum cap_t {
    00940                 STYLE_LINE_CAP_SAME   = -1,
    00941                 STYLE_LINE_CAP_ROUND  = 0,
    00942                 STYLE_LINE_CAP_NONE   = 1,
    00943                 STYLE_LINE_CAP_SQUARE = 2
    00944         };
    00945
    00946         enum join_t {
    00947                 STYLE_LINE_JOIN_UNKNOWN = -1,
    00948                 STYLE_LINE_JOIN_ROUND   = 0,
    00949                 STYLE_LINE_JOIN_BEVEL   = 1,
    00950                 STYLE_LINE_JOIN_MITER   = 2
    00951         };
    00952
    00953         enum spread_t {
    00954                 STYLE_GRADIENT_SPREAD_PAD     = 0,
    00955                 STYLE_GRADIENT_SPREAD_REFLECT = 1,
    00956                 STYLE_GRADIENT_SPREAD_REPEAT  = 2,
    00957         };
    00958
    00959         enum interpolation_t {
    00960                 STYLE_GRADIENT_INTERPOLATION_NORMAL = 0,
    00961                 STYLE_GRADIENT_INTERPOLATION_LINEAR = 1
    00962         };
    00963
    00964         explicit                Style(ErrorManager& error_manager);
    00965         virtual                 ~Style();
    00966
    00967         void                    Reset(void);
    00968         style_t                 Type(void) const { return f_style; }
    00969         signed char             Gradients(void) const { return f_gradient; }
    00970         bool                    HasMorph(void) const { return f_morph; }
    00971         bool                    HasAlpha(void) const { return f_use_alpha; }
    00972         bool                    HasHardEdges(void) const { return f_style == STYLE_TYPE_BITMAP_HARDEDGE_TILLED
    00973                                                                 || f_style == STYLE_TYPE_BITMAP_HARDEDGE_CLIPPED; }
    00974         bool                    SetType(style_t style_type);
    00975         bool                    SetLine(int index, unsigned short width, const Color& color);
    00976         bool                    SetLineCaps(cap_t start, cap_t end = STYLE_LINE_CAP_SAME);
    00977         bool                    SetLineJoin(join_t join, float miter_limit_factor = 0.0f);
    00978         bool                    SetLineScale(bool horiz, bool vert);
    00979         bool                    SetLinePixelHinting(bool pixel_hinting);
    00980         bool                    SetLineNoClose(bool no_close);
    00981         bool                    SetLineFillStyle(const Style& fill_style);
    00982         bool                    SetColor(int index, const Color& color);
    00983         bool                    SetGradient(int index, int pos, const Color& color);
    00984         bool                    SetGradientModes(spread_t spread, interpolation_t interpolation);
    00985         bool                    SetGradientFocal(float focal);
    00986         bool                    SetMatrix(int index, const Matrix& matrix);
    00987         bool                    SetBitmap(sswf_id_t id_ref);
    00988         bool                    SetClipping(void);
    00989
    00990         ErrorManager::error_code_t Save(Data& data, bool save_alpha, bool save_morph);
    00991
    00992 public:
    00993         /** \brief Defines the total number of gradients available in a gradient style.
    00994          *
    00995          * This value represents the maximum number of gradients a
    00996          * gradient style supports. Older movies would support up to
    00997          * 8 gradients. Newer movies (since SWF version 8) support
    00998          * up to 15 gradient definitions.
    00999          */
    01000         static const signed char MAX_GRADIENTS = 15;
    01001
    01002         bool                    operator == (const Style& style) const;
    01003
    01004 private:
    01005         // An error manager (TagHeader)
    01006         ErrorManager&           f_error_manager;
    01007
    01008         // the style
    01009         style_t                 f_style;
    01010
    01011         // whether this is for a DefineMorphShape or not
    01012         bool                    f_morph;
    01013
    01014         // whether some color alpha is not 255
    01015         bool                    f_use_alpha;
    01016
    01017         // a line width
    01018         unsigned short          f_line_width[2];
    01019         cap_t                   f_start_cap_style;
    01020         cap_t                   f_end_cap_style;
    01021         join_t                  f_join_style;
    01022         float                   f_miter_limit_factor;           // means we have f_join_style == 2
    01023         bool                    f_no_hscale;
    01024         bool                    f_no_vscale;
    01025         bool                    f_pixel_hinting;
    01026         bool                    f_no_close;
    01027         Style *                 f_fill_style;                   // if defined, no color and f_has_fill is set to true in output
    01028
    01029         // solid fill or line colors
    01030         Color                   f_color[2];
    01031
    01032         // bitmap reference (its ID)
    01033         sswf_id_t               f_bitmap_ref;
    01034
    01035         // matrices - 1 or 2 - regular of morph shapes
    01036         Matrix                  f_matrix[2];
    01037
    01038         // gradient positions & colors - 8 or 16 - regular or morph shapes
    01039         signed char             f_gradient;             // largest index used (0..7 only or -1 when no gradient)
    01040         unsigned char           f_gradient_pos[MAX_GRADIENTS * 2];
    01041         Color                   f_gradient_color[MAX_GRADIENTS * 2];
    01042         spread_t                f_gradient_spread;
    01043         interpolation_t         f_gradient_interpolation;
    01044         signed short            f_gradient_focal;
    01045 };
    01046
    01047
    01048
    01049
    01050
    01051 class Edges : public MemoryManager, public ItemBase
    01052 {
    01053 public:
    01054         // This structure is too complex at this time to reproduce
    01055         // automatically in C. We do not need it anyway.
    01056         struct edge_t {
    01057                 long            f_x;
    01058                 long            f_y;
    01059                 long            f_ctrl_x;               /* LONG_MIN if a line only */
    01060                 long            f_ctrl_y;
    01061
    01062                                 edge_t(void)
    01063                                 {
    01064                                         f_x = 0;
    01065                                         f_y = 0;
    01066                                         f_ctrl_x = LONG_MIN;
    01067                                         f_ctrl_y = LONG_MIN;
    01068                                 }
    01069                                 edge_t(long x, long y)
    01070                                 {
    01071                                         f_x = x;
    01072                                         f_y = y;
    01073                                         f_ctrl_x = LONG_MIN;
    01074                                         f_ctrl_y = LONG_MIN;
    01075                                 }
    01076                                 edge_t(long x, long y, long ctrl_x, long ctrl_y)
    01077                                 {
    01078                                         f_x = x;
    01079                                         f_y = y;
    01080                                         f_ctrl_x = ctrl_x;
    01081                                         f_ctrl_y = ctrl_y;
    01082                                 }
    01083                                 edge_t(const edge_t& edge)
    01084                                 {
    01085                                         f_x = edge.f_x;
    01086                                         f_y = edge.f_y;
    01087                                         f_ctrl_x = edge.f_ctrl_x;
    01088                                         f_ctrl_y = edge.f_ctrl_y;
    01089                                 }
    01090                 edge_t&         operator = (const edge_t& edge)
    01091                                 {
    01092                                         if(this != &edge) {
    01093                                                 f_x = edge.f_x;
    01094                                                 f_y = edge.f_y;
    01095                                                 f_ctrl_x = edge.f_ctrl_x;
    01096                                                 f_ctrl_y = edge.f_ctrl_y;
    01097                                         }
    01098                                         return *this;
    01099                                 }
    01100                 bool            IsLine(void) const { return f_ctrl_x == LONG_MIN || f_ctrl_y == LONG_MIN; }
    01101         };
    01102
    01103 public:
    01104         // This should be private but cl (C++ compiler from Mr Microsoft) does not
    01105         // understand the use of private too well...
    01106         enum {
    01107                 // better with a power of two (we use * and / a lot with it!)
    01108                 EDGE_BLOCK = 64
    01109         };
    01110
    01111                                 Edges(void);
    01112         virtual                 ~Edges();
    01113
    01114         //void                  Reset(void); -- not implemented yet
    01115         void                    Set(long x, long y) { edge_t edge(x, y); Set(-1, edge); }
    01116         void                    Set(long x, long y, long ctrl_x, long ctrl_y) { edge_t edge(x, y, ctrl_x, ctrl_y); Set(-1, edge); }
    01117         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); }
    01118
    01119         void                    Save(Data& data, long& x, long& y);
    01120
    01121 public:
    01122         void                    Set(const edge_t& edge) { Set(-1, edge); }
    01123         void                    Set(int index, const edge_t& edge);
    01124
    01125 private:
    01126         /// One set of edges; when full, allocate another
    01127         struct array_edge_t : public ItemBase {
    01128                 edge_t          f_edge[EDGE_BLOCK];
    01129         };
    01130
    01131                                 // no copy operators at this time
    01132                                 Edges(const Edges& edges) {}
    01133         Edges&                  operator = (const Edges& edges) { return *this; }
    01134
    01135         void                    SaveEdge(Data& data, const edge_t& edge, long& x, long& y);
    01136
    01137         Vectors                 f_edges;
    01138         int                     f_pos;          /* position in the current array */
    01139         array_edge_t            f_array;        /* current array; when full, put in f_edges */
    01140 };
    01141
    01142
    01143
    01144
    01145
    01146
    01147
    01148 // one can't create a tag base, only full qualified
    01149 // tags can be created (see below)
    01150 class TagHeader;
    01151 class TagBase : public MemoryManager
    01152 {
    01153 public:
    01154         // anything in the file is represented by a tag
    01155         enum swf_tag_t {
    01156                 SWF_TAG_UNKNOWN = -1,           // undefined tag
    01157
    01158                 // V1.0
    01159                 SWF_TAG_END = 0,                        // mark the end of the flash script
    01160                 SWF_TAG_SHOW_FRAME = 1,                 // show the current frame
    01161                 SWF_TAG_DEFINE_SHAPE = 2,               // define a vector based shape
    01162                 SWF_TAG_PLACE_OBJECT = 4,               // place an object in the current frame
    01163                 SWF_TAG_REMOVE_OBJECT = 5,              // remove specified object
    01164                 SWF_TAG_DEFINE_BITS = 6,                // JPEG data bit stream (old name, I will obsolete this name at some point)
    01165                 SWF_TAG_DEFINE_BITS_JPEG = 6,           // JPEG data bit stream (renaming)
    01166                 SWF_TAG_DEFINE_BUTTON = 7,              // define an action button
    01167                 SWF_TAG_JPEG_TABLES = 8,                // define the JPEG tables
    01168                 SWF_TAG_SET_BACKGROUND_COLOR = 9,       // define the RGB color for the background
    01169                 SWF_TAG_DEFINE_FONT = 10,               // links a list of shapes to characters
    01170                 SWF_TAG_DEFINE_TEXT = 11,               // define a text to be printed with a font
    01171                 SWF_TAG_DO_ACTION = 12,                 // action to perform in this frame
    01172                 SWF_TAG_DEFINE_FONT_INFO = 13,          // font metrics
    01173
    01174                 // V2.0
    01175                 SWF_TAG_DEFINE_SOUND = 14,              // define how a sound effect will be played
    01176                 SWF_TAG_START_SOUND = 15,               // start playing a sound effect
    01177                 SWF_TAG_STOP_SOUND = 16,                // (V9.0) stop playing a sound effect
    01178                 SWF_TAG_DEFINE_BUTTON_SOUND = 17,       // sound effects attached to a button
    01179                 SWF_TAG_SOUND_STREAM_HEAD = 18,         // define how a sound effect will be loaded & played
    01180                 SWF_TAG_SOUND_STREAM_BLOCK = 19,        // actual sound samples to play (embedded with the rest)
    01181                 SWF_TAG_DEFINE_BITS_LOSSLESS = 20,      // a loss less compressed image
    01182                 SWF_TAG_DEFINE_BITS_JPEG2 = 21,         // a complete JPEG definition
    01183                 SWF_TAG_DEFINE_SHAPE2 = 22,             // define a shape including large number of styles
    01184                 SWF_TAG_DEFINE_BUTTON_COLOR_TRANSFORM = 23,     // how a button changes color
    01185                 SWF_TAG_PROTECT = 24,                   // whether the resulting file is protected against editing
    01186
    01187                 // V3.0
    01188                 SWF_TAG_PLACE_OBJECT2 = 26,             // extended place
    01189                 SWF_TAG_REMOVE_OBJECT2 = 28,            // simplified remove
    01190                 SWF_TAG_DEFINE_SHAPE3 = 32,             // define a shape including RGBA colors
    01191                 SWF_TAG_DEFINE_TEXT2 = 33,              // define a text to draw including RGBA colors
    01192                 SWF_TAG_DEFINE_BUTTON2 = 34,            // define an action button with RGBA colors and color transformation
    01193                 SWF_TAG_DEFINE_BITS_JPEG3 = 35,         // define two JPEG images, one RGB and one GREY used as the alpha channel
    01194                 SWF_TAG_DEFINE_BITS_LOSSLESS2 = 36,     // define a loss less image with an alpha channel
    01195                 SWF_TAG_DEFINE_SPRITE = 39,             // define a movie as an object to play in another movie
    01196                 SWF_TAG_PRODUCT_INFO = 41,              // generator version info
    01197                 SWF_TAG_FRAME_LABEL = 43,               // name a place holder in the movie
    01198                 SWF_TAG_DEFINE_BEHAVIOR = 44,           // (V9.0) ?
    01199                 SWF_TAG_SOUND_STREAM_HEAD2 = 45,        // define a sound effect with more details for embedded playing
    01200                 SWF_TAG_DEFINE_MORPH_SHAPE = 46,        // define a shape which can easilly be changed with a position
    01201                 SWF_TAG_DEFINE_FONT2 = 48,              // define a set of fonts
    01202                 SWF_TAG_DEFINE_INFO = 49,               // define a comment about the generator, etc.
    01203
    01204                 // V4.0
    01205                 SWF_TAG_TEXT_FIELD = 37,                // define an area with text which can be edited
    01206
    01207                 // V9.0
    01208                 SWF_TAG_DEFINE_FUNCTION = 53,           // ABC function
    01209                 SWF_TAG_PLACE_FUNCTION = 54,            // Place(?) ABC function
    01210                 SWF_TAG_GENERATE_TAG_OBJECT = 55,       // ?
    01211
    01212                 // V5.0
    01213                 SWF_TAG_EXPORT = 56,                    // export a set of definitions to other files
    01214                 SWF_TAG_IMPORT = 57,                    // look for definitions from another file (supported up to V7.0)
    01215                 SWF_TAG_PROTECT_DEBUG = 58,             // a password to protect debugging of flash movies -- use only in V5.x movies
    01216
    01217                 // V6.0
    01218                 SWF_TAG_DO_INIT_ACTION = 59,            // action to perform once on specified sprite in this frame
    01219                 SWF_TAG_DEFINE_VIDEO_STREAM = 60,       // record defining the following video frames
    01220                 SWF_TAG_VIDEO_FRAME = 61,               // a frame of video
    01221                 SWF_TAG_DEFINE_FONT_INFO2 = 62,         // font metrics including language reference
    01222                 SWF_TAG_DEBUG_ID = 63,                  // (SWF 9)
    01223                 SWF_TAG_PROTECT_DEBUG2 = 64,            // a password to protect debugging of flash movies
    01224
    01225                 // V7.0
    01226                 SWF_TAG_SCRIPT_LIMITS = 65,             // the recursive depth and script timeout parameters
    01227                 SWF_TAG_SET_TAB_INDEX = 66,             // the depth of an object to be set at the given index (next/previous Tab key positioning)
    01228
    01229                 // V8.0
    01230                 SWF_TAG_FILE_ATTRIBUTES = 69,           // file attributes appended right after the header (see TagHeader)
    01231                 SWF_TAG_PLACE_OBJECT3 = 70,             // place an object with blend mode, filters, bitmap caching
    01232                 SWF_TAG_IMPORT2 = 71,                   // look for definitions from another file (only supported tag in V8.0+)
    01233                 SWF_TAG_DEFINE_FONT_ALIGN_ZONES = 73,   // define hints to properly align fonts to pixel boundaries
    01234                 SWF_TAG_CSM_TEXT_SETTINGS = 74,         // extra information about text (on how to render text)
    01235                 SWF_TAG_DEFINE_FONT3 = 75,              // define a set of fonts which uses lines with caps information
    01236                 SWF_TAG_METADATA = 77,                  // an XML document describing the Flash movie
    01237                 SWF_TAG_DEFINE_SCALING_GRID = 78,       // a grid to avoid scaling the edges of an object
    01238                 SWF_TAG_DEFINE_SHAPE4 = 83,             // define a vector based shape with end caps definitions
    01239                 SWF_TAG_DEFINE_MORPH_SHAPE2 = 84,       // define a shape which can easilly be changed with a position
    01240
    01241                 // V9.0
    01242                 SWF_TAG_ACTIONSCRIPT2 = 72,             // define action script version 2
    01243                 SWF_TAG_ACTIONSCRIPT2_INSTANTIATE = 76, // create an object from an action script version 2
    01244                 SWF_TAG_ACTIONSCRIPT2_DEFINE = 82,      // initialize a named action script version 2
    01245                 SWF_TAG_SCENE_FRAME_DATA = 86,          // define raw data for a scene/frame
    01246                 SWF_TAG_DEFINE_BINARY_DATA = 87,        // define a block of data with an identifier
    01247                 SWF_TAG_DEFINE_FONT_NAME = 88,          // define the name and copyright notice of a font
    01248
    01249                 // V10.0
    01250                 SWF_TAG_DEFINE_BITS_JPEG4 = 90,         // define two JPEG images, one RGB and one GREY used as the alpha channel
    01251
    01252                 SWF_TAG_max             // just end this list really
    01253         };
    01254         typedef long                    swf_type_t;
    01255
    01256 #define SWF_TYPE_DEFINE                 0x00000001      // a definition tag, must be in the main movie
    01257 #define SWF_TYPE_CONTROL                0x00000002      // a control tag, can be in sprites as well
    01258 #define SWF_TYPE_UNIQUE                 0x00000004      // a unique tag, can't be duplicated in the movie (merge if possible)
    01259 #define SWF_TYPE_START                  0x00000008      // if present, put it near the start of the movie
    01260 #define SWF_TYPE_ONE                    0x00000010      // (should) use at most one per frame
    01261 #define SWF_TYPE_REFERENCE              0x00000020      // object includes references to other objects
    01262 #define SWF_TYPE_HAS_ID                 0x00000040      // this object was derived from TagBaseID and has an ID
    01263
    01264 #define SWF_TYPE_SCRIPT                 0x20000000      // object can accept action scripts
    01265 #define SWF_TYPE_SPRITE                 0x40000000      // this is a sprite (can include other tags)
    01266 #define SWF_TYPE_HEADER                 0x80000000      // the header
    01267
    01268         virtual                         ~TagBase();
    01269
    01270         ErrorManager::error_code_t      SaveString(Data& data, const char *string);
    01271         static int                      SaveTag(Data& data, swf_tag_t tag, size_t size);
    01272
    01273         static long                     SIBitSize(long value);          // return the number of bits necessary to represent a signed integer
    01274         static long                     UIBitSize(unsigned long value); // return the number of bits necessary to represent an unsigned integer
    01275         static long                     Double2Signed16(double value);  // return a valid fixed value 8.8 bits from a double
    01276         static double                   Signed162Double(long value);    // return a valid fixed value 8.8 bits from a double
    01277         static long                     Double2Signed(double value);    // return a valid fixed value 16.16 bits from a double
    01278         static double                   Signed2Double(long value);      // return a valid double from a fixed value 16.16 bits
    01279
    01280         virtual void                    MinimumVersion(unsigned char version);
    01281         virtual unsigned char           Version(void) const;
    01282
    01283         const char *                    Name(void) const;       // return the name (type) of this tag
    01284         const char *                    Label(void) const;
    01285         void                            ResetFrames(void);
    01286         void                            ShowFrame(void);
    01287         sswf_frame_t                    FrameCount(void) const;
    01288
    01289         sswf_frame_t                    WhichFrame(void) const;
    01290         void                            SetLabel(const char *label);
    01291         TagBase *                       FindLabelledTag(const char *label) const;
    01292         TagBase *                       FindTagWithID(sswf_id_t id, bool search_import = true) const;
    01293         TagBase *                       Children(void);
    01294         TagBase *                       Next(void);
    01295         TagBase *                       Previous(void);
    01296         TagBase *                       Parent(void);
    01297         TagHeader *                     Header(void) const;
    01298         virtual ErrorManager::error_code_t OnError(ErrorManager::error_code_t errcode, const char *message, va_list ap) const;
    01299
    01300 public:
    01301         virtual ErrorManager::error_code_t Save(Data& data) = 0;        // print out a tag in a Data buffer
    01302         virtual swf_type_t              TypeFlags(void) const = 0;
    01303         virtual ErrorManager::error_code_t OnError(ErrorManager::error_code_t errcode, const char *message, ...) const;
    01304         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data) = 0;
    01305
    01306         /** \brief A pointer you are welcome to use
    01307          *
    01308          * This pointer is public and is provided so users of any one of
    01309          * the tag classes can save a pointer back to his/her own
    01310          * container.
    01311          *
    01312          * The library initializes this pointer to NULL on construction
    01313          * and never touches it again until the object is deleted.
    01314          */
    01315         void *                          f_userdata;             // anything you feel necessary!
    01316
    01317 protected:
    01318                                 // only sub-classes can create a TagBase
    01319                                         TagBase(const char *name, TagBase *parent);
    01320         virtual ErrorManager::error_code_t PreSave(void);               // called by the header Save() function
    01321         virtual ErrorManager::error_code_t PreSave2ndPass(void);        // called by the header Save() function after all the PreSave() were called
    01322
    01323         virtual ErrorManager::error_code_t OnNewChild(const char *child_name) const;
    01324
    01325 private:
    01326         TagBase *                       FindLabel(const TagBase *p, const char *label) const;
    01327         TagBase *                       FindID(const TagBase *p, sswf_id_t id, bool search_import) const;
    01328
    01329         const char *                    f_name;
    01330         char *                          f_label;
    01331
    01332         TagBase *                       f_parent;
    01333         TagBase *                       f_next;
    01334         TagBase *                       f_previous;
    01335         TagBase *                       f_children;
    01336
    01337         sswf_frame_t                    f_frames;               // total number of frames
    01338 };
    01339
    01340
    01341
    01342
    01343
    01344
    01345 /********************* TAGS WITHOUT IDs (possibly references though) ****/
    01346
    01347
    01348 // The TagHeader includes the TagFileAttributes because
    01349 // it is very much like an extension of the header and not
    01350 // a separate tag. Also it needs to be unique and saved right
    01351 // after the header. Thus it becomes totally transparent to
    01352 // you. At this time you have the SetUseNetwork() function to
    01353 // set the network flag and add a TagMetadata to set the
    01354 // metadata flag (that is automatic.)
    01355 class TagHeader : public TagBase, public ErrorManager
    01356 {
    01357 public:
    01358         enum load_flag_t {
    01359                 LOAD_FLAG_IGNORE_UNKNOWN_TAGS = 0x0001
    01360         };
    01361
    01362                                         TagHeader(void);
    01363         virtual                         ~TagHeader();
    01364
    01365         ErrorManager::error_code_t      Load(const Data& data, load_flag_t flags);
    01366
    01367         virtual ErrorManager::error_code_t Save(Data& data);
    01368         ErrorManager::error_code_t      SaveEncodedString(Data& data, const char *string);
    01369         virtual swf_type_t              TypeFlags(void) const;
    01370         virtual ErrorManager::error_code_t OnError(ErrorManager::error_code_t errcode, const char *message, va_list ap) const;
    01371
    01372         sswf_id_t                       NextID(void);
    01373         void                            RemoveID(sswf_id_t id);
    01374
    01375 /////////////// SETUP FUNCTIONS
    01376         virtual unsigned char           Version(void) const;                            // retrieve the selected version
    01377         void                            SetVersion(unsigned char version);              // save a movie with that version if set
    01378         void                            SetMinimumVersion(unsigned char version);       // the minimum version you want to support
    01379         void                            SetMaximumVersion(unsigned char version);       // the maximum version you want to support
    01380
    01381         void                            SetCompress(bool compress = true);
    01382         void                            SetAutoOrder(bool auto_order = true);
    01383         void                            SetUseNetwork(bool use_network = true);
    01384         void                            SetFrame(const SRectangle& rect);
    01385         const SRectangle&               Frame(void) const;
    01386
    01387         void                            SetOutputEncoding(const char *encoding);
    01388         void                            SetRate(float rate);
    01389         float                           Rate(void) const;
    01390
    01391 public:
    01392         class Factory
    01393         {
    01394         public:
    01395                                                 Factory(swf_tag_t tag, int priority = 0);
    01396                 virtual                         ~Factory();
    01397
    01398                 swf_tag_t                       GetTag(void) const;
    01399                 int                             GetPriority(void) const;
    01400                 virtual TagBase *               NewTag(TagBase *parent, const Data& data) const = 0;
    01401
    01402         private:
    01403                 const swf_tag_t                 f_tag_id;
    01404                 const int                       f_priority;
    01405         };
    01406
    01407         const Factory *                 GetFactory(TagBase::swf_tag_t tag) const;
    01408         virtual void                    MinimumVersion(unsigned char version);          // used internally to determine the minimum version
    01409         ErrorManager::error_code_t      DefineMinimumVersion(int& min_version);         // function used to compute the minimum version (a negative result represents an error)
    01410         virtual ErrorManager::error_code_t OnError(ErrorManager::error_code_t errcode, const char *message, ...) const;
    01411
    01412 protected:
    01413         virtual ErrorManager::error_code_t PreSave(void);               // overwrite the base PreSave() so we can know whether we have a Metadata tag
    01414         virtual ErrorManager::error_code_t ParseTag(TagBase::swf_tag_t tag, const Data& data);  // not used, but we have to have this function defined in each tag class
    01415         virtual ErrorManager::error_code_t OnNewChild(const char *child_name) const;
    01416
    01417 private:
    01418         enum load_status_t {
    01419                 HEADER_LOAD_STATUS_RESET = 0,           // not loading
    01420                 HEADER_LOAD_STATUS_HEADER,              // loading the header
    01421                 HEADER_LOAD_STATUS_TAG,                 // loading the tag header
    01422                 HEADER_LOAD_STATUS_TAG_SIZE,            // loading the tag size when 4 extra bytes
    01423                 HEADER_LOAD_STATUS_DATA,                // loading the data for the tag body
    01424                 HEADER_LOAD_STATUS_DONE,                // we loaded the total amount of data defined in the header
    01425                 HEADER_LOAD_STATUS_ERROR                // there was a blocking error, we cannot continue
    01426         };
    01427
    01428         // NOTE: use 0 to get a default version (a version computed from the options used)
    01429         unsigned char                   f_version;              // file version (0 to 8 at time of writing)
    01430         unsigned char                   f_min_version;          // once the whole file was saved, this is the minimum version we need to use
    01431         unsigned char                   f_minimum_version;      // user defined minimum version; the system will start with this minimum version instead of 1
    01432         unsigned char                   f_maximum_version;      // user defined maximum version; if a larger version is required, return an error
    01433         SRectangle                      f_frame;                // the frame rectangle
    01434         float                           f_rate;                 // frames per second (8.8 fixed number in file)
    01435         bool                            f_compress;             // compress the resulting movie (v6.x upward)
    01436         bool                            f_auto_order;           // automatically order definition tags (discard unused definitions also)
    01437         bool                            f_use_network;          // whether the SWF movie is authorized to access the network when launched locally
    01438         bool                            f_has_metadata;         // whether the SWF movie includes a TagMetadata
    01439         bool                            f_has_jpegtables;       // whether the SWF movie includes a TagJPEGTables
    01440         sswf_id_t                       f_next_id;              // returned and then increased when NextID() is called
    01441         char *                          f_output_encoding;      // encoding used prior V6.x SWF files
    01442         bool                            f_iconvertor_open;      // whether the f_iconvertor is a valid descriptor
    01443         iconv_t                         f_iconvertor;           // to convert strings from U18N to user specified encoding
    01444 #if DEBUG
    01445         bool                            f_saving;               // if true the f_min_version can't be changed ever anymore
    01446 #endif
    01447         load_status_t                   f_load_status;          // current loader status
    01448         swf_tag_t                       f_tag;                  // the tag identifier
    01449         size_t                          f_tag_size;             // the size of the "tag" being loaded
    01450         bool                            f_compressed_input;     // the file we're reading is compressed
    01451         size_t                          f_file_size;            // total size of the file
    01452         size_t                          f_position;             // current position in the file (will grow up to f_file_size)
    01453         Data                            f_tag_data;             // data for the next tag (so the Load() function can be called again and again)
    01454         z_stream                        f_zstream;              // in case the file is compressed
    01455         TagBase *                       f_sprite;               // the parent for a while
    01456         size_t                          f_sprite_size;          // size of the sprite data
    01457 };
    01458
    01459
    01460
    01461
    01462 // Actions:
    01463 //
    01464 //      Whenever you want to create an action, you simply
    01465 //      create a new Action object with the proper type
    01466 //      unless you need to use an action which requires
    01467 //      some additional data. The actions which require
    01468 //      additional data are listed here:
    01469 //
    01470 //      Action Name             Data
    01471 //
    01472 //      ActionBranch            label
    01473 //      ActionCallFrame         <nothing -- this is a mistake from Macromedia>
    01474 //      ActionDictionary        strings
    01475 //      ActionFunction          name, registers, parameters, body (actions)
    01476 //      ActionGoto              frame name, play flag
    01477 //      ActionLabel             label (generates no output code)
    01478 //      ActionPushData          strings, floats, doubles, etc.
    01479 //      ActionSetTarget         target name
    01480 //      ActionStoreRegister     register number
    01481 //      ActionTry               try, catch and finally actions and identifier/register
    01482 //      ActionURL               url, target and method
    01483 //      ActionWaitForFrame      frame name, actions
    01484 //      ActionWith              actions to execute with the specified object
    01485
    01486
    01487 class ActionLabel;
    01488 class Action : public ItemBase
    01489 {
    01490 public:
    01491         enum action_t {
    01492                 ACTION_UNKNOWN                  = -1,   /* unknown action (invalid) */
    01493                 ACTION_LABEL                    = -2,   /* used to mark a position within the actions */
    01494                 ACTION_min                      = 0x00, /* the minimum action number */
    01495
    01496                 /* all the valid Flash actions */
    01497                 ACTION_END                      = 0x00, /* this is automatically added by the higher level Save()'s */
    01498                 ACTION_NEXT_FRAME               = 0x04,
    01499                 ACTION_PREVIOUS_FRAME           = 0x05,
    01500                 ACTION_PLAY                     = 0x06,
    01501                 ACTION_STOP                     = 0x07,
    01502                 ACTION_TOGGLE_QUALITY           = 0x08,
    01503                 ACTION_STOP_SOUND               = 0x09,
    01504                 ACTION_ADD                      = 0x0A,
    01505                 /*ACTION_SUBSTRACT              = 0x0B, -- this is the wrong spelling, it is not totally obsolete */
    01506                 ACTION_SUBTRACT                 = 0x0B,
    01507                 ACTION_MULTIPLY                 = 0x0C,
    01508                 ACTION_DIVIDE                   = 0x0D,
    01509                 ACTION_EQUAL                    = 0x0E,
    01510                 ACTION_LESS_THAN                = 0x0F,
    01511                 ACTION_LOGICAL_AND              = 0x10,
    01512                 ACTION_LOGICAL_OR               = 0x11,
    01513                 ACTION_LOGICAL_NOT              = 0x12,
    01514                 ACTION_STRING_EQUAL             = 0x13,
    01515                 ACTION_STRING_LENGTH            = 0x14,
    01516                 ACTION_SUB_STRING               = 0x15,
    01517                 ACTION_POP                      = 0x17,
    01518                 ACTION_INTEGRAL_PART            = 0x18,
    01519                 ACTION_GET_VARIABLE             = 0x1C,
    01520                 ACTION_SET_VARIABLE             = 0x1D,
    01521                 ACTION_SET_TARGET2              = 0x20,
    01522                 ACTION_CONCATENATE              = 0x21,
    01523                 ACTION_GET_PROPERTY             = 0x22,
    01524                 ACTION_SET_PROPERTY             = 0x23,
    01525                 ACTION_DUPLICATE_SPRITE         = 0x24,
    01526                 ACTION_REMOVE_SPRITE            = 0x25,
    01527                 ACTION_TRACE                    = 0x26,
    01528                 ACTION_START_DRAG               = 0x27,
    01529                 ACTION_STOP_DRAG                = 0x28,
    01530                 ACTION_STRING_LESS_THAN         = 0x29,
    01531                 ACTION_THROW                    = 0x2A,
    01532                 ACTION_CAST_OBJECT              = 0x2B,
    01533                 ACTION_IMPLEMENTS               = 0x2C,
    01534                 ACTION_FSCOMMAND2               = 0x2D,
    01535                 ACTION_RANDOM                   = 0x30,
    01536                 ACTION_MBSTRING_LENGTH          = 0x31,
    01537                 ACTION_ORD                      = 0x32,
    01538                 ACTION_CHR                      = 0x33,
    01539                 ACTION_GET_TIMER                = 0x34,
    01540                 ACTION_SUB_MBSTRING             = 0x35,
    01541                 ACTION_MBORD                    = 0x36,
    01542                 ACTION_MBCHR                    = 0x37,
    01543                 ACTION_DELETE                   = 0x3A,
    01544                 ACTION_SET_LOCAL_VAR            = 0x3C,
    01545                 ACTION_SET_LOCAL_VARIABLE       = 0x3C,
    01546                 ACTION_CALL_FUNCTION            = 0x3D,
    01547                 ACTION_RETURN                   = 0x3E,
    01548                 ACTION_MODULO                   = 0x3F,
    01549                 ACTION_NEW                      = 0x40,
    01550                 ACTION_DECLARE_LOCAL_VAR        = 0x41,
    01551                 ACTION_DECLARE_LOCAL_VARIABLE   = 0x41,
    01552                 ACTION_DECLARE_ARRAY            = 0x42,
    01553                 ACTION_DECLARE_OBJECT           = 0x43,
    01554                 ACTION_TYPE_OF                  = 0x44,
    01555                 ACTION_GET_TARGET               = 0x45,
    01556                 ACTION_ENUMERATE                = 0x46,
    01557                 ACTION_ADD_TYPED                = 0x47,
    01558                 ACTION_LESS_THAN_TYPED          = 0x48,
    01559                 ACTION_EQUAL_TYPED              = 0x49,
    01560                 ACTION_NUMBER                   = 0x4A,
    01561                 ACTION_STRING                   = 0x4B,
    01562                 ACTION_DUPLICATE                = 0x4C,
    01563                 ACTION_SWAP                     = 0x4D,
    01564                 ACTION_GET_MEMBER               = 0x4E,
    01565                 ACTION_SET_MEMBER               = 0x4F,
    01566                 ACTION_INCREMENT                = 0x50,
    01567                 ACTION_DECREMENT                = 0x51,
    01568                 ACTION_CALL_METHOD              = 0x52,
    01569                 ACTION_NEW_METHOD               = 0x53,
    01570                 ACTION_INSTANCE_OF              = 0x54,
    01571                 ACTION_ENUMERATE_OBJECT         = 0x55,
    01572                 ACTION_AND                      = 0x60,
    01573                 ACTION_OR                       = 0x61,
    01574                 ACTION_XOR                      = 0x62,
    01575                 ACTION_SHIFT_LEFT               = 0x63,
    01576                 ACTION_SHIFT_RIGHT              = 0x64,
    01577                 ACTION_SHIFT_RIGHT_UNSIGNED     = 0x65,
    01578                 ACTION_STRICT_EQUAL             = 0x66,
    01579                 ACTION_GREATER_THAN_TYPED       = 0x67,
    01580                 ACTION_STRING_GREATER_THAN      = 0x68,
    01581                 ACTION_EXTENDS                  = 0x69,
    01582                 ACTION_GOTO_FRAME               = 0x81,
    01583                 ACTION_URL                      = 0x83,
    01584                 ACTION_STORE_REGISTER           = 0x87,
    01585                 ACTION_DECLARE_DICTIONARY       = 0x88,
    01586                 ACTION_STRICT_MODE              = 0x89,
    01587                 ACTION_WAIT_FOR_FRAME           = 0x8A,
    01588                 ACTION_SET_TARGET               = 0x8B,
    01589                 ACTION_GOTO_LABEL               = 0x8C,
    01590                 ACTION_WAIT_FOR_FRAME2          = 0x8D,
    01591                 ACTION_DECLARE_FUNCTION2        = 0x8E,
    01592                 ACTION_TRY                      = 0x8F,
    01593                 ACTION_WITH                     = 0x94,
    01594                 ACTION_PUSH_DATA                = 0x96,
    01595                 ACTION_BRANCH_ALWAYS            = 0x99,
    01596                 ACTION_URL2                     = 0x9A,
    01597                 ACTION_DECLARE_FUNCTION         = 0x9B,
    01598                 ACTION_BRANCH_IF_TRUE           = 0x9D,
    01599                 ACTION_CALL_FRAME               = 0x9E,
    01600                 ACTION_GOTO_EXPRESSION          = 0x9F,
    01601
    01602                 ACTION_max              = 0xFF          /* the maximum action number */
    01603         };
    01604
    01605                                         Action(TagBase *tag, action_t action);
    01606         virtual                         ~Action() {}
    01607
    01608         virtual Action *                Duplicate(void) const;
    01609         unsigned long                   Offset(void) const { return f_offset; }
    01610         virtual unsigned char           Version(void) const { return f_min_version; }
    01611
    01612         ErrorManager::error_code_t      Save(Data& data);
    01613         virtual Vectors *               SubList(void);
    01614         ErrorManager::error_code_t      SaveList(const Vectors *list, Data& data, const Vectors *extra = 0);
    01615         static int                      MinimumListVersion(const Vectors& list);
    01616         static int                      GetMaximumRegister(const Vectors& list);
    01617         static ActionLabel *            FindLabel(const Vectors& list, const char *label);
    01618         static ActionLabel *            FindLabelAtOffset(Vectors& list, unsigned long offset);
    01619         static ErrorManager::error_code_t ParseList(TagBase *tag, const Data& data, Vectors& actions);
    01620         static ErrorManager::error_code_t Parse(TagBase *tag, const Data& data, Vectors& actions);
    01621         TagBase *                       GetTag(void) const { return f_tag; }
    01622
    01623 public:
    01624         ErrorManager::error_code_t      OnError(ErrorManager::error_code_t errcode, const char *message, ...) const;
    01625
    01626 protected:
    01627         virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
    01628         virtual ErrorManager::error_code_t Save2ndPass(const Vectors& list, Data& data);
    01629         virtual ErrorManager::error_code_t ParseData(const Data& data);
    01630         virtual ErrorManager::error_code_t Parse2ndPass(Vectors& list);
    01631         virtual int                     GetMaxRegister(void) const { return 0; }
    01632         ErrorManager::error_code_t      SaveString(Data& data, const char *string);
    01633         TagBase *                       Tag(void) const { return const_cast<TagBase *>(f_tag); }
    01634
    01635         const action_t                  f_action;
    01636         unsigned long                   f_offset;               /* offset where this tag is being saved (saved for branches and with statments) */
    01637
    01638 private:
    01639 #if DEBUG
    01640         /*
    01641          * Forbid copies (only in DEBUG mode so we don't have extra functions
    01642          * for nothing otherwise) If you need a copy, use the Duplicate() instead
    01643          */
    01644                                         Action(const Action& action);
    01645         Action&                         operator = (const Action& action);
    01646 #endif
    01647
    01648         TagBase *                       f_tag;
    01649         unsigned char                   f_min_version;          /* minimum version to use this action */
    01650 };
    01651
    01652
    01653 class ActionBranch : public Action, public MemoryManager
    01654 {
    01655 public:
    01656         /* one of:
    01657          *      ACTION_BRANCH_ALWAYS
    01658          *      ACTION_BRANCH_IF_TRUE
    01659          */
    01660                                         ActionBranch(TagBase *tag, action_t action = ACTION_BRANCH_ALWAYS);
    01661
    01662         void                            SetLabel(const char *label);
    01663
    01664 private:
    01665         virtual Action *                Duplicate(void) const;
    01666         virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
    01667         virtual ErrorManager::error_code_t Save2ndPass(const Vectors& list, Data& data);
    01668         virtual ErrorManager::error_code_t ParseData(const Data& data);
    01669         virtual ErrorManager::error_code_t Parse2ndPass(Vectors& list);
    01670
    01671         char *                          f_label;
    01672         unsigned long                   f_goto_offset;  // when loading
    01673 };
    01674
    01675
    01676
    01677 class ActionCallFrame : public Action, public MemoryManager
    01678 {
    01679 public:
    01680         /* auto:
    01681          *      ACTION_CALL_FRAME
    01682          */
    01683                                         ActionCallFrame(TagBase *tag);
    01684
    01685 private:
    01686         virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
    01687         virtual ErrorManager::error_code_t ParseData(const Data& data);
    01688 };
    01689
    01690
    01691
    01692 class ActionDictionary : public Action, public MemoryManager
    01693 {
    01694 public:
    01695         /* auto:
    01696          *      ACTION_DECLARE_DICTIONARY
    01697          */
    01698                                         ActionDictionary(TagBase *tag);
    01699
    01700         void                            AddString(const char *string);
    01701
    01702 private:
    01703         /// Holds one dictionary string
    01704         struct string_t : public ItemBase
    01705         {
    01706                 /// Constructor that ensures the string is NULL
    01707                                 string_t(char *str = 0) :
    01708                                         f_string(str)
    01709                                 {
    01710                                 }
    01711
    01712                 /// Pointer to the dictionary string
    01713                 char *          f_string;
    01714         };
    01715
    01716         virtual Action *                Duplicate(void) const;
    01717         virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
    01718         virtual ErrorManager::error_code_t ParseData(const Data& data);
    01719
    01720         /// Array of dictionary strings
    01721         Vectors                         f_strings;
    01722 };
    01723
    01724
    01725
    01726 class ActionFunction : public Action, public MemoryManager
    01727 {
    01728 public:
    01729         /* one of:
    01730          *      ACTION_DECLARE_FUNCTION
    01731          *      ACTION_DECLARE_FUNCTION2
    01732          */
    01733                                         ActionFunction(TagBase *tag, action_t action = ACTION_DECLARE_FUNCTION);
    01734
    01735         enum action_function_t {
    01736                 ACTION_FUNCTION_LOAD_THIS          = 0x0001,
    01737                 ACTION_FUNCTION_SUPPRESS_THIS      = 0x0002,
    01738                 ACTION_FUNCTION_LOAD_ARGUMENTS     = 0x0004,
    01739                 ACTION_FUNCTION_SUPPRESS_ARGUMENTS = 0x0008,
    01740                 ACTION_FUNCTION_LOAD_SUPER         = 0x0010,
    01741                 ACTION_FUNCTION_SUPPRESS_SUPER     = 0x0020,
    01742                 ACTION_FUNCTION_LOAD_ROOT          = 0x0040,
    01743                 ACTION_FUNCTION_LOAD_PARENT        = 0x0080,
    01744                 ACTION_FUNCTION_LOAD_GLOBAL        = 0x0100
    01745         };
    01746
    01747         void                            SetName(const char *name);
    01748         void                            SetRegistersCount(unsigned int count);
    01749         void                            AddParameter(const char *name, int register_number = -1);
    01750         void                            AddAction(Action *action);
    01751         virtual Vectors *               SubList(void);
    01752
    01753         // flags for the ASSetPropFlags(obj, props, flags [, allow])
    01754         // (see include/sswf/scripts/global/extensions.asc)
    01755         enum as_set_prop_flags_t {
    01756                 PROP_FLAG_IS_HIDDEN = 1,
    01757                 PROP_FLAG_CAN_DELETE = 2,
    01758                 PROP_FLAG_CAN_OVERWRITE = 4
    01759         };
    01760
    01761 private:
    01762         /// Hold the parameters name and register number
    01763         struct parameter_t : public ItemBase
    01764         {
    01765                 /// The name of the parameter
    01766                 char *          f_name;
    01767                 /// The register number (-1 means no register and 0 means auto-assign the number)
    01768                 int             f_register_number;      // if -1, use the name, if 0, auto-assign
    01769         };
    01770
    01771         virtual Action *                Duplicate(void) const;
    01772         virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
    01773         virtual ErrorManager::error_code_t ParseData(const Data& data);
    01774
    01775         char *                          f_name;
    01776         unsigned int                    f_registers_count;
    01777         unsigned short                  f_flags;
    01778         Vectors                         f_parameters;
    01779         Vectors                         f_actions;
    01780 };
    01781
    01782
    01783
    01784 class ActionGoto : public Action, public MemoryManager
    01785 {
    01786 public:
    01787         /* one of:
    01788          *      ACTION_GOTO_FRAME
    01789          *      ACTION_GOTO_LABEL
    01790          *      ACTION_GOTO_EXPRESSION
    01791          */
    01792                                         ActionGoto(TagBase *tag, action_t action = ACTION_GOTO_FRAME);
    01793
    01794         void                            SetFrameName(const char *frame_name);
    01795         void                            SetPlay(bool play) { f_play = play; }
    01796
    01797 private:
    01798         virtual Action *                Duplicate(void) const;
    01799         virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
    01800         virtual ErrorManager::error_code_t ParseData(const Data& data);
    01801
    01802         char *                          f_frame_name;
    01803         unsigned long                   f_frame_number;
    01804         bool                            f_play;
    01805 };
    01806
    01807
    01808
    01809 class ActionLabel : public Action, public MemoryManager
    01810 {
    01811 public:
    01812         /* auto:
    01813          * ACTION_LABEL (special case)
    01814          */
    01815                                         ActionLabel(TagBase *tag);
    01816
    01817         void                            SetLabel(const char *label);
    01818         const char *                    GetLabel(void) const { return f_label; }
    01819
    01820 private:
    01821         virtual Action *                Duplicate(void) const;
    01822         // we shall never even try to load or save a label! so no Parse/SaveData() are necessary
    01823
    01824         char *                          f_label;
    01825 };
    01826
    01827
    01828
    01829
    01830 class ActionPushData : public Action, public MemoryManager
    01831 {
    01832 public:
    01833         /* auto:
    01834          * ACTION_PUSH_DATA
    01835          */
    01836                                         ActionPushData(TagBase *tag);
    01837
    01838         void                            AddEmptyString(void) { AddString(0); }
    01839         void                            AddString(const char *string);
    01840         void                            AddTrue(void) { AddBoolean(true); }
    01841         void                            AddFalse(void) { AddBoolean(false); }
    01842         void                            AddBoolean(bool value);
    01843         void                            AddInteger(long value);
    01844         void                            AddFloat(float value);
    01845         void                            AddDouble(double value);
    01846         void                            AddNull(void);
    01847         void                            AddLookup(unsigned short index);
    01848         void                            AddRegister(unsigned char reg_index);
    01849         void                            AddUndefined(void);
    01850
    01851 private:
    01852         enum action_immediate_type_t
    01853         {
    01854                 ACTION_IMMEDIATE_TYPE_UNKNOWN           = -1,
    01855                 ACTION_IMMEDIATE_TYPE_STRING            = 0x00,
    01856                 ACTION_IMMEDIATE_TYPE_FLOAT             = 0x01,
    01857                 ACTION_IMMEDIATE_TYPE_NULL              = 0x02,
    01858                 ACTION_IMMEDIATE_TYPE_UNDEFINED         = 0x03,
    01859                 ACTION_IMMEDIATE_TYPE_REGISTER          = 0x04,
    01860                 ACTION_IMMEDIATE_TYPE_BOOLEAN           = 0x05,
    01861                 ACTION_IMMEDIATE_TYPE_DOUBLE            = 0x06,
    01862                 ACTION_IMMEDIATE_TYPE_INTEGER           = 0x07,
    01863                 ACTION_IMMEDIATE_TYPE_LOOKUP            = 0x08,
    01864                 ACTION_IMMEDIATE_TYPE_LOOKUP_LARGE      = 0x09
    01865         };
    01866         /// One data entry of a PushData action
    01867         struct action_immediate_t : public ItemBase
    01868         {
    01869                 action_immediate_type_t f_type;
    01870                 union
    01871                 {
    01872                         char *          f_string;
    01873                         float           f_float32;
    01874                         double          f_float64;
    01875                         bool            f_boolean;
    01876                         long            f_integer32;
    01877                         unsigned short  f_lookup;
    01878                         unsigned char   f_register;
    01879                 } f_data;
    01880
    01881                 action_immediate_t(action_immediate_type_t type)
    01882                 {
    01883                         f_type = type;
    01884                         memset(&f_data, 0, sizeof(f_data));
    01885                 }
    01886         };
    01887
    01888         virtual Action *                Duplicate(void) const;
    01889         virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
    01890         virtual ErrorManager::error_code_t ParseData(const Data& data);
    01891         virtual int                     GetMaxRegister(void) const;
    01892
    01893         Vectors                         f_data;
    01894 };
    01895
    01896
    01897
    01898
    01899 class ActionSetTarget : public Action, public MemoryManager
    01900 {
    01901 public:
    01902         /* auto:
    01903          * ACTION_SET_TARGET
    01904          */
    01905                                         ActionSetTarget(TagBase *tag);
    01906
    01907         void                            SetTarget(const char *target);
    01908
    01909 private:
    01910         virtual Action *                Duplicate(void) const;
    01911         virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
    01912         virtual ErrorManager::error_code_t ParseData(const Data& data);
    01913
    01914         char *                          f_target;
    01915 };
    01916
    01917
    01918 class ActionStoreRegister : public Action, public MemoryManager
    01919 {
    01920 public:
    01921         /* auto:
    01922          * ACTION_STORE_REGISTER
    01923          */
    01924                                         ActionStoreRegister(TagBase *tag);
    01925
    01926         void                            SetRegister(unsigned char reg);
    01927
    01928 private:
    01929         virtual Action *                Duplicate(void) const;
    01930         virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
    01931         virtual ErrorManager::error_code_t ParseData(const Data& data);
    01932         virtual int                     GetMaxRegister(void) const;
    01933
    01934         unsigned char                   f_reg;
    01935 };
    01936
    01937
    01938 class ActionStrictMode : public Action, public MemoryManager
    01939 {
    01940 public:
    01941         /* auto:
    01942          * ACTION_STRICT_MODE
    01943          */
    01944                                         ActionStrictMode(TagBase *tag);
    01945
    01946         void                            SetStrict(bool strict);
    01947
    01948 private:
    01949         virtual Action *                Duplicate(void) const;
    01950         virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
    01951         virtual ErrorManager::error_code_t ParseData(const Data& data);
    01952
    01953         bool                            f_strict;
    01954 };
    01955
    01956
    01957 class ActionTry : public Action, public MemoryManager
    01958 {
    01959 public:
    01960         /* auto:
    01961          * ACTION_TRY
    01962          */
    01963                                         ActionTry(TagBase *tag);
    01964
    01965         void                            AddTryAction(Action *action);
    01966         void                            AddCatchAction(Action *action);
    01967         void                            AddFinallyAction(Action *action);
    01968         void                            SetIdentifier(int register_number);             // Catch(#)
    01969         void                            SetIdentifier(const char *variable_name);       // Catch(var)
    01970
    01971         Vectors *                       SubListTry(void);
    01972         Vectors *                       SubListCatch(void);
    01973         Vectors *                       SubListFinally(void);
    01974
    01975 private:
    01976         virtual Action *                Duplicate(void) const;
    01977         virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
    01978         virtual ErrorManager::error_code_t ParseData(const Data& data);
    01979         virtual int                     GetMaxRegister(void) const;
    01980         virtual unsigned char           Version(void) const;
    01981
    01982         int                             f_register;
    01983         char *                          f_variable_name;
    01984         bool                            f_has_catch;
    01985         bool                            f_has_finally;
    01986         Vectors                         f_actions_try;
    01987         Vectors                         f_actions_catch;
    01988         Vectors                         f_actions_finally;
    01989 };
    01990
    01991
    01992
    01993 class ActionURL : public Action, public MemoryManager
    01994 {
    01995 public:
    01996         /* one of:
    01997          *      ACTION_URL
    01998          *      ACTION_URL2
    01999          */
    02000                                         ActionURL(TagBase *tag, action_t action = ACTION_URL);
    02001
    02002         enum url_method_t {
    02003                 URL_METHOD_UNDEFINED = -1,
    02004                 URL_METHOD_NOVARIABLE = 0,
    02005                 URL_METHOD_NOVARIABLES = URL_METHOD_NOVARIABLE,
    02006                 URL_METHOD_GET = 1,
    02007                 URL_METHOD_POST = 2
    02008         };
    02009
    02010         void                            SetURL(const char *url, const char *target);
    02011         void                            SetMethod(url_method_t method);
    02012
    02013 private:
    02014         virtual Action *                Duplicate(void) const;
    02015         virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
    02016         virtual ErrorManager::error_code_t ParseData(const Data& data);
    02017
    02018         char *                          f_url;
    02019         char *                          f_target;
    02020         url_method_t                    f_method;
    02021 };
    02022
    02023
    02024
    02025 class ActionWaitForFrame : public Action, public MemoryManager
    02026 {
    02027 public:
    02028         /* one of:
    02029          *      ACTION_WAIT_FOR_FRAME
    02030          *      ACTION_WAIT_FOR_FRAME2
    02031          */
    02032                                         ActionWaitForFrame(TagBase *tag, action_t action = ACTION_WAIT_FOR_FRAME);
    02033
    02034         void                            SetFrameName(const char *name);
    02035         void                            AddAction(Action *action);
    02036         virtual Vectors *               SubList(void);
    02037
    02038 private:
    02039         virtual Action *                Duplicate(void) const;
    02040         virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
    02041         virtual ErrorManager::error_code_t ParseData(const Data& data);
    02042
    02043         Vectors                         f_actions;      // actions executed once frame is loaded
    02044         char *                          f_frame_name;
    02045         uint16_t                        f_frame;        // frame number (when loading)
    02046 };
    02047
    02048
    02049
    02050 class ActionWith : public Action, public MemoryManager
    02051 {
    02052 public:
    02053         /* auto:
    02054          * ACTION_WITH
    02055          */
    02056                                         ActionWith(TagBase *tag);
    02057
    02058         void                            AddAction(Action *action);
    02059         virtual Vectors *               SubList(void);
    02060
    02061 private:
    02062         virtual Action *                Duplicate(void) const;
    02063         virtual ErrorManager::error_code_t SaveData(Data& data, Data& nested_data);
    02064         virtual ErrorManager::error_code_t ParseData(const Data& data);
    02065
    02066         Vectors                         f_actions;
    02067 };
    02068
    02069
    02070
    02071
    02072
    02073
    02074 class TagDoAction : public TagBase
    02075 {
    02076 public:
    02077         /* one of:
    02078          *      SWF_TAG_DO_ACTION
    02079          *      SWF_TAG_DO_INIT_ACTION (uses this when sprite ID was defined)
    02080          */
    02081                                 TagDoAction(TagBase *parent);
    02082
    02083         virtual ErrorManager::error_code_t Save(Data& data);
    02084         virtual swf_type_t      TypeFlags(void) const;
    02085
    02086 /////////////// SETUP FUNCTIONS
    02087         void                    SetAction(const Action& action);
    02088         void                    SetSprite(sswf_id_t sprite);
    02089         Vectors&                Actions(void) { return f_actions; }
    02090
    02091 private:
    02092         virtual ErrorManager::error_code_t PreSave(void);               // called by the header Save() function
    02093         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02094
    02095         sswf_id_t               f_sprite;
    02096         Vectors                 f_actions;
    02097 };
    02098
    02099
    02100
    02101
    02102
    02103 class TagMetadata : public TagBase
    02104 {
    02105 public:
    02106                                 TagMetadata(TagBase *parent);
    02107
    02108         virtual ErrorManager::error_code_t Save(Data& data);
    02109         virtual swf_type_t      TypeFlags(void) const;
    02110
    02111 /////////////// SETUP FUNCTIONS
    02112         // You should not call all of these functions.
    02113         // There are three groups decreasing priority:
    02114         //
    02115         //  o Read the RDF from a file
    02116         //
    02117         //      SetFilename()
    02118         //
    02119         //  o Define the RDF verbatim
    02120         //
    02121         //      SetMetadata()
    02122         //
    02123         //  o Set values to be saved in an RDF built by SSWF
    02124         //
    02125         //      SetTitle()
    02126         //      SetDescription()
    02127         //      SetAuthor()
    02128         //      SetPublisher()
    02129         //      SetCopyright()
    02130         //      SetURL()
    02131         //
    02132         void                    SetFilename(const char *filename);
    02133         void                    SetMetadata(const char *xml);
    02134         void                    SetTitle(const char *title);
    02135         void                    SetDescription(const char *description);
    02136         void                    SetAuthor(const char *description);
    02137         void                    SetPublisher(const char *publisher);
    02138         void                    SetCopyright(const char *copyright);
    02139         void                    SetURL(const char *url);
    02140
    02141 private:
    02142         virtual ErrorManager::error_code_t PreSave(void);               // called by the header Save() function
    02143         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02144
    02145         char *                  f_xml;
    02146         char *                  f_filename;
    02147         char *                  f_title;
    02148         char *                  f_description;
    02149         char *                  f_author;
    02150         char *                  f_publisher;
    02151         char *                  f_copyright;
    02152         char *                  f_url;
    02153 };
    02154
    02155
    02156
    02157
    02158
    02159 class TagPlace : public TagBase
    02160 {
    02161 public:
    02162                                         TagPlace(TagBase *parent);
    02163
    02164         virtual ErrorManager::error_code_t Save(Data& data);
    02165         virtual swf_type_t              TypeFlags(void) const;
    02166
    02167 /////////////// SETUP FUNCTIONS
    02168         void                            SetObjectID(sswf_id_t id);
    02169         void                            SetDepth(int depth);
    02170         void                            SetClip(int depth);
    02171         void                            SetMatrix(const Matrix& matrix);
    02172         void                            SetColorTransform(const ColorTransform& color_transform);
    02173         void                            SetName(const char *name);
    02174         void                            SetMorphPosition(int position);
    02175         void                            SetBlendMode(const BlendMode& blend_mode);
    02176         void                            SetBitmapCaching(int bitmap_caching);
    02177         void                            Replace(void);
    02178         void                            Place(void);
    02179         bool                            AddEvent(Event *event);
    02180
    02181 private:
    02182         virtual ErrorManager::error_code_t PreSave(void);               // called by the header Save() function
    02183         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02184
    02185         bool                            f_id_defined;
    02186         sswf_id_t                       f_id;
    02187         int                             f_replace;
    02188         int                             f_depth;
    02189         int                             f_clip_depth;
    02190         char *                          f_name;
    02191         unsigned long                   f_events_all_flags;
    02192         int                             f_position;             // morph position
    02193         BlendMode                       f_blend_mode;
    02194         int                             f_bitmap_caching;
    02195         bool                            f_has_matrix;
    02196         Matrix                          f_matrix;
    02197         ColorTransform                  f_color_transform;
    02198         Vectors                         f_events;
    02199 };
    02200
    02201
    02202
    02203 class TagRemove : public TagBase
    02204 {
    02205 public:
    02206                                 TagRemove(TagBase *parent);
    02207
    02208         virtual ErrorManager::error_code_t Save(Data& data);
    02209         virtual swf_type_t      TypeFlags(void) const;
    02210
    02211 /////////////// SETUP FUNCTIONS
    02212         void                    SetDepth(int depth) { f_depth = depth; }
    02213         void                    SetObjectID(sswf_id_t id) { f_id = id; }
    02214
    02215 private:
    02216         virtual ErrorManager::error_code_t PreSave(void);               // called by the header Save() function
    02217         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02218
    02219         int                     f_depth;
    02220         sswf_id_t               f_id;
    02221 };
    02222
    02223
    02224
    02225 class TagSceneFrameData : public TagBase
    02226 {
    02227 public:
    02228                                 TagSceneFrameData(TagBase *parent);
    02229
    02230         virtual ErrorManager::error_code_t Save(Data& data);
    02231         virtual swf_type_t      TypeFlags(void) const;
    02232
    02233 /////////////// SETUP FUNCTIONS
    02234         bool                    SetFileData(const char *filename);
    02235         void                    SetSceneFrameData(const char *data, size_t size);
    02236
    02237 private:
    02238         virtual ErrorManager::error_code_t PreSave(void);               // called by the header Save() function
    02239         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02240
    02241         char *                  f_data;
    02242         size_t                  f_size;
    02243 };
    02244
    02245
    02246
    02247
    02248 class TagScriptLimits : public TagBase
    02249 {
    02250 public:
    02251                                 TagScriptLimits(TagBase *parent);
    02252
    02253         virtual ErrorManager::error_code_t Save(Data& data);
    02254         virtual swf_type_t      TypeFlags(void) const;
    02255
    02256 /////////////// SETUP FUNCTIONS
    02257         void                    SetMaxRecursionDepth(int depth);
    02258         void                    SetTimeoutSeconds(int timeout);
    02259         int                     GetMaxRecursionDepth(void) const;
    02260         int                     GetTimeoutSeconds(void) const;
    02261
    02262 private:
    02263         virtual ErrorManager::error_code_t PreSave(void);
    02264         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02265
    02266         int                     f_depth;
    02267         int                     f_timeout;
    02268 };
    02269
    02270
    02271
    02272 class TagSetTabIndex : public TagBase
    02273 {
    02274 public:
    02275                                 TagSetTabIndex(TagBase *parent);
    02276
    02277         virtual ErrorManager::error_code_t Save(Data& data);
    02278         virtual swf_type_t      TypeFlags(void) const;
    02279
    02280 /////////////// SETUP FUNCTIONS
    02281         void                    SetDepth(int depth);
    02282         void                    SetIndex(int timeout);
    02283         int                     GetDepth(void) const;
    02284         int                     GetIndex(void) const;
    02285
    02286 private:
    02287         virtual ErrorManager::error_code_t PreSave(void);
    02288         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02289
    02290         int                     f_depth;
    02291         int                     f_index;
    02292 };
    02293
    02294
    02295
    02296 class TagSetBackgroundColor : public TagBase
    02297 {
    02298 public:
    02299                                 TagSetBackgroundColor(TagBase *parent);
    02300
    02301         virtual ErrorManager::error_code_t Save(Data& data);
    02302         virtual swf_type_t      TypeFlags(void) const;
    02303
    02304 /////////////// SETUP FUNCTIONS
    02305         void                    SetColor(Color& color);
    02306         Color&                  GetColor(void);
    02307
    02308 private:
    02309         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02310
    02311         Color                   f_color;
    02312 };
    02313
    02314
    02315 class TagShowFrame : public TagBase
    02316 {
    02317 public:
    02318                                 TagShowFrame(TagBase *parent);
    02319
    02320         virtual ErrorManager::error_code_t Save(Data& data);
    02321         virtual swf_type_t      TypeFlags(void) const;
    02322
    02323 private:
    02324         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02325 };
    02326
    02327
    02328 class TagEnd : public TagBase
    02329 {
    02330 public:
    02331                                 TagEnd(TagBase *parent);
    02332
    02333         virtual ErrorManager::error_code_t Save(Data& data);
    02334         virtual swf_type_t      TypeFlags(void) const;
    02335
    02336 private:
    02337         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02338 };
    02339
    02340
    02341 class TagFrameLabel : public TagBase
    02342 {
    02343 public:
    02344                                 TagFrameLabel(TagBase *parent);
    02345
    02346         virtual ErrorManager::error_code_t Save(Data& data);
    02347         virtual swf_type_t      TypeFlags(void) const;
    02348
    02349 /////////////// SETUP FUNCTIONS
    02350         void                    SetFrameLabel(const char *label);
    02351
    02352 private:
    02353         virtual ErrorManager::error_code_t PreSave(void);
    02354         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02355
    02356         char *                  f_label;
    02357 };
    02358
    02359
    02360
    02361 class TagExport : public TagBase
    02362 {
    02363 public:
    02364                                 TagExport(TagBase *parent);
    02365
    02366         virtual ErrorManager::error_code_t Save(Data& data);
    02367         virtual swf_type_t      TypeFlags(void) const;
    02368
    02369 /////////////// SETUP FUNCTIONS
    02370         void                    SetObject(sswf_id_t id, const char *name, const char *used_glyphs);
    02371
    02372 private:
    02373         /// One export entry with the identifier of the object to export and the export name
    02374         struct export_t : public ItemBase
    02375         {
    02376                 sswf_id_t       f_id;
    02377                 const char *    f_name;
    02378                 const char *    f_used_glyphs;
    02379         };
    02380
    02381         virtual ErrorManager::error_code_t PreSave(void);
    02382         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02383
    02384         Vectors                 f_objects;
    02385 };
    02386
    02387
    02388
    02389 class TagImport : public TagBase
    02390 {
    02391 public:
    02392         /* one of:
    02393          *      SWF_TAG_IMPORT (movies before version 8)
    02394          *      SWF_TAG_IMPORT2 (since version 8)
    02395          */
    02396                                 TagImport(TagBase *parent);
    02397
    02398         virtual ErrorManager::error_code_t Save(Data& data);
    02399         virtual swf_type_t      TypeFlags(void) const;
    02400         const char *            HasID(sswf_id_t id) const;
    02401         sswf_id_t               HasName(const char *name) const;
    02402
    02403 /////////////// SETUP FUNCTIONS
    02404         void                    SetURL(const char *url);
    02405         void                    SetFilename(const char *filename);
    02406         void                    AddName(const char *name, const char *type);
    02407
    02408 private:
    02409         /// Defines each imported object identifier, name and type
    02410         struct import_t : public ItemBase
    02411         {
    02412                 sswf_id_t       f_id;           // dynamically allocated
    02413                 const char *    f_name;         // external symbol name
    02414                 const char *    f_type;         // user specified type
    02415         };
    02416
    02417         virtual ErrorManager::error_code_t PreSave(void);
    02418         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02419
    02420         char *                  f_url;
    02421         char *                  f_filename;
    02422         Vectors                 f_objects;
    02423 };
    02424
    02425
    02426
    02427 class TagProtect : public TagBase
    02428 {
    02429 public:
    02430         /* one of:
    02431          *      SWF_TAG_PROTECT
    02432          *      SWF_TAG_PROTECT_DEBUG
    02433          *      SWF_TAG_PROTECT_DEBUG2
    02434          *      (now with automatic selection only)
    02435          */
    02436                                 TagProtect(TagBase *parent);
    02437
    02438         virtual ErrorManager::error_code_t Save(Data& data);
    02439         virtual swf_type_t      TypeFlags(void) const;
    02440
    02441 /////////////// SETUP FUNCTIONS
    02442         void                    SetPassword(const char *password);
    02443         void                    SetEncodedPassword(const char *password);
    02444
    02445 private:
    02446         virtual ErrorManager::error_code_t PreSave(void);
    02447         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02448
    02449         char *                  f_password;
    02450 };
    02451
    02452
    02453
    02454 class TagProductInfo : public TagBase
    02455 {
    02456 public:
    02457                                 TagProductInfo(TagBase *parent);
    02458
    02459         virtual ErrorManager::error_code_t Save(Data& data);
    02460         virtual swf_type_t      TypeFlags(void) const;
    02461
    02462 /////////////// SETUP FUNCTIONS
    02463         void                    SetProduct(long product_id);
    02464         void                    SetEdition(long edition);
    02465         void                    SetVersion(int major, int minor);
    02466         void                    SetBuild(int64_t build_number);
    02467         void                    SetCompileDate(int64_t date);
    02468
    02469 private:
    02470         virtual ErrorManager::error_code_t PreSave(void);
    02471         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02472
    02473         long                    f_product_id;
    02474         long                    f_edition;
    02475         int                     f_major;
    02476         int                     f_minor;
    02477         int64_t                 f_build_number;
    02478         int64_t                 f_date;
    02479 };
    02480
    02481
    02482
    02483 class TagInfo : public TagBase
    02484 {
    02485 public:
    02486                                 TagInfo(TagBase *parent);
    02487
    02488         virtual ErrorManager::error_code_t Save(Data& data);
    02489         virtual swf_type_t      TypeFlags(void) const;
    02490
    02491 /////////////// SETUP FUNCTIONS
    02492         void                    SetInfo(const char *info);
    02493         void                    SetVersion(long version);
    02494
    02495 private:
    02496         virtual ErrorManager::error_code_t PreSave(void);
    02497         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02498
    02499         char *                  f_info;
    02500         long                    f_version;
    02501 };
    02502
    02503
    02504 class TagStartSound : public TagBase
    02505 {
    02506 public:
    02507                                 TagStartSound(TagBase *parent);
    02508
    02509         virtual ErrorManager::error_code_t Save(Data& data);
    02510         virtual swf_type_t      TypeFlags(void) const;
    02511
    02512 /////////////// SETUP FUNCTIONS
    02513         void                    SetInfo(SoundInfo *sound_info);
    02514
    02515 private:
    02516         virtual ErrorManager::error_code_t PreSave(void);
    02517         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02518
    02519         SoundInfo *             f_sound_info;
    02520 };
    02521
    02522
    02523
    02524
    02525
    02526
    02527
    02528
    02529 class TagScalingGrid
    02530 {
    02531 public:
    02532         virtual                 ~TagScalingGrid();
    02533
    02534         ErrorManager::error_code_t GridSave(Data& data, sswf_id_t id);
    02535         ErrorManager::error_code_t GridPreSave(void);
    02536
    02537         const SRectangle&       Grid(void) const;
    02538
    02539 /////////////// SETUP FUNCTIONS
    02540         void                    SetGrid(const SRectangle& rect);
    02541
    02542         ErrorManager::error_code_t ParseGridTag(TagBase::swf_tag_t tag, const Data& data);      // not used, but we have to have this function defined in each tag class
    02543
    02544 private:
    02545         SRectangle              f_grid;
    02546 };
    02547
    02548
    02549
    02550
    02551
    02552
    02553
    02554
    02555
    02556
    02557 /****************************************/
    02558 /****************************************/
    02559 /********************* TAGS WITH IDs ****/
    02560 /****************************************/
    02561 /****************************************/
    02562
    02563 class TagBaseID : public TagBase
    02564 {
    02565 public:
    02566         virtual                 ~TagBaseID();
    02567
    02568         virtual sswf_id_t       Identification(void) const;
    02569         void                    NoIdentification(void);
    02570         bool                    HasIdentification(void) const;
    02571
    02572         int                     SaveID(Data& data) const;
    02573         ErrorManager::error_code_t ParseID(const Data& data);
    02574
    02575 public:
    02576                                 TagBaseID(const char *name, TagBase *parent);
    02577
    02578 private:
    02579         sswf_id_t               f_id;
    02580         bool                    f_identified;
    02581 };
    02582
    02583
    02584
    02585
    02586
    02587 class TagBinaryData : public TagBaseID
    02588 {
    02589 public:
    02590                                 TagBinaryData(TagBase *parent);
    02591         virtual                 ~TagBinaryData();
    02592
    02593         virtual ErrorManager::error_code_t Save(Data& data);
    02594         virtual swf_type_t      TypeFlags(void) const;
    02595
    02596 /////////////// SETUP FUNCTIONS
    02597         void                    GetData(const char *& data, size_t& size) const;
    02598         void                    SetData(const char *data, size_t size);
    02599
    02600 private:
    02601         virtual ErrorManager::error_code_t PreSave(void);
    02602         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02603
    02604         char *                  f_data;
    02605         size_t                  f_size;
    02606 };
    02607
    02608
    02609
    02610
    02611 class TagButton : public TagBaseID, public TagScalingGrid
    02612 {
    02613 public:
    02614                                 TagButton(TagBase *parent);
    02615
    02616         virtual ErrorManager::error_code_t Save(Data& data);
    02617         virtual swf_type_t      TypeFlags(void) const;
    02618
    02619 /////////////// SETUP FUNCTIONS
    02620         bool                    SetState(const State& state);
    02621         void                    SetAction(const Action& action);
    02622         void                    SetMenu(bool menu = true);
    02623         Vectors&                Actions(void);
    02624         bool                    AddEvent(Event *event);
    02625
    02626 private:
    02627         virtual ErrorManager::error_code_t PreSave(void);               // called by the header Save() function
    02628         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02629
    02630         bool                    f_save_button2;
    02631         bool                    f_menu;                 // whether to track as a menu
    02632         Vectors                 f_states;
    02633         Vectors                 f_actions;
    02634         Vectors                 f_events;
    02635 };
    02636
    02637
    02638
    02639 class TagCSMTextSettings
    02640 {
    02641 public:
    02642         enum csm_text_renderer_t {
    02643                 CSM_TEXT_RENDERER_NORMAL = 0,
    02644                 CSM_TEXT_RENDERER_FLASH = 1
    02645         };
    02646         enum csm_text_gridfit_t {
    02647                 CSM_TEXT_GRIDFIT_NO_GRID = 0,
    02648                 CSM_TEXT_GRIDFIT_PIXEL = 1,
    02649                 CSM_TEXT_GRIDFIT_SUBPIXEL = 2
    02650         };
    02651
    02652                                         TagCSMTextSettings(void);
    02653         virtual                         ~TagCSMTextSettings(void);
    02654
    02655         bool                            IsCSMTextSettingsDefined(void) const;
    02656
    02657         void                            SetRenderer(csm_text_renderer_t csm_text_renderer);
    02658         void                            SetGridFit(csm_text_gridfit_t csm_text_gridfit);
    02659         void                            SetThickness(float thickness);
    02660         void                            SetSharpness(float sharpness);
    02661
    02662 protected:
    02663         // Access via the PreSave()/Save() functions of the TagEditText and TagText
    02664         ErrorManager::error_code_t      PreSaveCSMTextSettings(void);
    02665         ErrorManager::error_code_t      SaveCSMTextSettings(Data& data);
    02666         ErrorManager::error_code_t      ParseTag(TagBase::swf_tag_t tag, const Data& data);
    02667
    02668 private:
    02669         csm_text_renderer_t             f_csm_text_renderer;
    02670         csm_text_gridfit_t              f_csm_text_gridfit;
    02671         float                           f_thickness;
    02672         float                           f_sharpness;
    02673 };
    02674
    02675
    02676 class TagShape;
    02677 class TagFont : public TagBaseID
    02678 {
    02679 public:
    02680         enum font_type_t {
    02681                 FONT_TYPE_BEST = 0,             // create the best possible result
    02682                 FONT_TYPE_ASCII,
    02683                 FONT_TYPE_UNICODE,
    02684                 FONT_TYPE_SHIFTJIS,
    02685         };
    02686         enum font_language_t {
    02687                 FONT_LANGUAGE_UNKNOWN                   = -1,
    02688                 FONT_LANGUAGE_LOCALE                    = 0,
    02689                 FONT_LANGUAGE_LATIN                     = 1,
    02690                 FONT_LANGUAGE_JAPANESE                  = 2,
    02691                 FONT_LANGUAGE_KOREAN                    = 3,
    02692                 FONT_LANGUAGE_SIMPLIFIED_CHINESE        = 4,
    02693                 FONT_LANGUAGE_TRADITIONAL_CHINESE       = 5,
    02694
    02695                 FONT_LANGUAGE_max                       = 6
    02696         };
    02697         enum font_thickness_t {
    02698                 FONT_THICKNESS_UNKNOWN  = -1,
    02699                 FONT_THICKNESS_THIN     =  0,
    02700                 FONT_THICKNESS_MEDIUM   =  1,
    02701                 FONT_THICKNESS_THICK    =  2,
    02702
    02703                 FONT_THICKNESS_max      =  3
    02704         };
    02705         enum font_em_size_t {
    02706                 FONT_EM_SMALL = 0,
    02707                 FONT_EM_LARGE = 1
    02708         };
    02709
    02710 #define SSWF_FONT_SPACE_INDEX           static_cast<unsigned long>(-1)
    02711
    02712         /// Structure used to handle one glyph information
    02713         struct font_info_t {
    02714                 sswf_ucs4_t             f_glyph;        // the glyph name ('A', 'B', ...)
    02715                 unsigned short          f_saved_index;  // index in the SWF file (within the referenced glyphs)
    02716                 unsigned long           f_index;        // index in the memory array (of all glyphs)
    02717                 unsigned long           f_position;     // closest position or exact position in the list of glyphs
    02718                 long                    f_advance;      // the advance in TWIPs
    02719                 bool                    f_is_empty;     // if true, it's like a space (i.e. invisible)
    02720         };
    02721
    02722                                 TagFont(TagBase *parent);
    02723
    02724         virtual ErrorManager::error_code_t Save(Data& data);
    02725         virtual swf_type_t              TypeFlags(void) const;
    02726         ErrorManager::error_code_t      GlyphInfo(font_info_t& info) const;
    02727         bool                            HasGlyph(void) const;
    02728         bool                            FindGlyph(font_info_t& info, bool mark_empty_in_use = false) const;
    02729         const char *                    FontName(void) const;
    02730         long                            DefaultAscent(void) const;
    02731         long                            DefaultDescent(void) const;
    02732         long                            DefaultLeadingHeight(void) const;
    02733         static font_language_t          StringToLanguage(const char *language);
    02734         static const char *             LanguageToString(font_language_t language);
    02735
    02736 /////////////// SETUP FUNCTIONS
    02737         //
    02738         // WARNING: The pointers of the shape referenced are kept as is (the shape is not
    02739         //          copied in any way)
    02740         //
    02741         //          So you have to make sure that these shapes still exist at the time
    02742         //          the Save() is called.
    02743         //
    02744         ErrorManager::error_code_t      AddGlyph(sswf_ucs4_t name, const TagBase *ref, long advance = LONG_MIN);
    02745         void                            SetName(const char *font_name);
    02746         void                            SetDisplayName(const char *display_name);
    02747         void                            SetCopyright(const char *copyright);
    02748         void                            SetLayout(long ascent, long descent, long leading_height);
    02749         void                            SetDefaultAdvance(long advance);
    02750         void                            SetSpaceAdvance(long advance);
    02751         void                            SetType(font_type_t type);
    02752         void                            SetLanguage(font_language_t language);
    02753         void                            SetBold(bool bold);
    02754         void                            SetItalic(bool italic);
    02755         void                            SetSmallText(bool small_text = true);
    02756         void                            SetThickness(font_thickness_t thickness);
    02757         void                            SetEMSize(font_em_size_t font_em_size);
    02758         void                            SetWide(bool wide);
    02759         ErrorManager::error_code_t      SetUsedGlyphs(const char *used_glyphs, bool mark_empty_in_use = false);
    02760         ErrorManager::error_code_t      SetUsedGlyphs(const sswf_ucs4_t *used_glyphs, bool mark_empty_in_use = false);
    02761         void                            SetUsedByEditText(bool used = true);
    02762         void                            AddKern(sswf_ucs4_t code0, sswf_ucs4_t code1, long advance);
    02763
    02764 private:
    02765         /// Structure used to represent a glyph
    02766         struct font_glyph_t : public ItemBase
    02767         {
    02768                 sswf_ucs4_t     f_name;         /* "A", "B", "0", "1", etc. */
    02769                 unsigned short  f_index;        /* index of this item when saved in the output file */
    02770                 const TagShape *f_shape;        /* the shape used for this glyph */
    02771                 long            f_advance;      /* the number of TWIPs to advance */
    02772                 bool            f_in_use;       /* if true this glyph was referenced at least once */
    02773         };
    02774         /// Structure used to define one kern entry
    02775         struct font_kern_t : public ItemBase
    02776         {
    02777                 sswf_ucs4_t     f_code[2];
    02778                 long            f_advance;
    02779         };
    02780
    02781         virtual ErrorManager::error_code_t PreSave(void);
    02782         virtual ErrorManager::error_code_t PreSave2ndPass(void);
    02783         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02784
    02785         static const char *     g_font_language_name[FONT_LANGUAGE_max];
    02786         char *                  f_font_name;
    02787         char *                  f_display_name;
    02788         char *                  f_copyright;
    02789         font_language_t         f_language;             // v6.x language definition
    02790         font_type_t             f_type;                 // unused in v6.x
    02791         bool                    f_bold;
    02792         bool                    f_italic;
    02793         bool                    f_small_text;
    02794         bool                    f_wide;
    02795         bool                    f_has_wide_char;        // defined in PreSave2ndPass()
    02796         bool                    f_has_wide_offsets;     // defined in PreSave2ndPass()
    02797         bool                    f_has_layout;           // defined in PreSave2ndPass()
    02798         bool                    f_used_by_edit_text;    // reset in PreSave() used in PreSave2ndPass()
    02799         bool                    f_define_font2;         // defined in PreSave2ndPass()
    02800         font_thickness_t        f_thickness;
    02801         font_em_size_t          f_font_em_size;
    02802         long                    f_ascent;
    02803         long                    f_descent;
    02804         long                    f_leading_height;
    02805         long                    f_default_advance;
    02806         long                    f_space_advance;
    02807         long                    f_offsets_max;          // size of the current f_offsets buffer
    02808         unsigned long *         f_offsets;              // this is a list of unsigned shorts if f_has_wide_offset if false -- defined in PreSave2ndPass()
    02809         unsigned long           f_count;                // the number of glyphs saved (defined in PreSave2ndPass())
    02810         Data                    f_save_glyphs;          // defined in PreSave2ndPass()
    02811         Vectors                 f_glyphs;
    02812         Vectors                 f_kerns;
    02813 };
    02814
    02815
    02816
    02817
    02818
    02819 class TagEditText : public TagBaseID, public TagCSMTextSettings
    02820 {
    02821 public:
    02822         enum edit_text_alignment_t {
    02823                 EDIT_TEXT_ALIGNMENT_LEFT = 0,
    02824                 EDIT_TEXT_ALIGNMENT_RIGHT = 1,
    02825                 EDIT_TEXT_ALIGNMENT_CENTER = 2,
    02826                 EDIT_TEXT_ALIGNMENT_JUSTIFY = 3
    02827         };
    02828
    02829                                 TagEditText(TagBase *parent);
    02830
    02831         virtual ErrorManager::error_code_t Save(Data& data);
    02832         virtual swf_type_t      TypeFlags(void) const;
    02833
    02834 /////////////// SETUP FUNCTIONS
    02835         void                    SetText(const char *text);
    02836         void                    SetVariableName(const char *name);
    02837         void                    SetFont(const TagFont *font, long height);
    02838         void                    SetMargins(long left, long right);
    02839         void                    SetBounds(const SRectangle& bounds);
    02840         void                    SetAlign(edit_text_alignment_t align);
    02841         void                    SetIndent(long indent);
    02842         void                    SetLeading(long leading);
    02843         void                    SetColor(Color& color);
    02844         void                    SetMaxLength(long length);
    02845         void                    SetWordWrap(bool status = true);
    02846         void                    SetMultiline(bool status = true);
    02847         void                    SetPassword(bool status = true);
    02848         void                    SetReadOnly(bool status = true);
    02849         void                    SetNoSelect(bool status = true);
    02850         void                    SetBorder(bool status = true);
    02851         void                    SetOutline(bool status = true);
    02852         void                    SetHTML(bool status = true);
    02853         void                    SetAutoSize(bool status = true);
    02854         void                    SetUsedGlyphs(const char *lists);
    02855         void                    AddUsedString(const char *string);
    02856
    02857 private:
    02858         virtual ErrorManager::error_code_t PreSave(void);
    02859         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02860
    02861         SRectangle              f_bounds;               // where the string is drawn
    02862         edit_text_alignment_t   f_align;
    02863         long                    f_left_margin;
    02864         long                    f_right_margin;
    02865         long                    f_indent;
    02866         long                    f_leading;
    02867         const TagFont *         f_font;
    02868         unsigned short          f_font_height;
    02869         long                    f_max_length;           // maximum number of character, if <= 0 - undefined
    02870         char *                  f_var_name;             // required
    02871         char *                  f_text;                 // if 0, no initialization text [SaveString() expects a UTF-8 so we keep it that way]
    02872         sswf_ucs4_t *           f_used_glyphs;          // default to "*" if undefined
    02873         sswf_ucs4_t *           f_used_strings;         // concatenation of used strings
    02874         Color                   f_color;
    02875         bool                    f_has_color;            // if this is true then the user defined the color
    02876         bool                    f_word_wrap;
    02877         bool                    f_multiline;
    02878         bool                    f_password;
    02879         bool                    f_readonly;
    02880         bool                    f_no_select;
    02881         bool                    f_border;
    02882         bool                    f_outline;
    02883         bool                    f_html;
    02884         bool                    f_autosize;
    02885 };
    02886
    02887
    02888 class TagImage : public TagBaseID
    02889 {
    02890 public:
    02891         enum image_format_t {
    02892                 IMAGE_FORMAT_UNKNOWN = 0,
    02893                 IMAGE_FORMAT_LOSSLESS_BEST,
    02894                 IMAGE_FORMAT_LOSSLESS_8,
    02895                 IMAGE_FORMAT_LOSSLESS_16,
    02896                 IMAGE_FORMAT_LOSSLESS_32,
    02897                 IMAGE_FORMAT_JPEG,
    02898                 IMAGE_FORMAT_max
    02899         };
    02900         /// Defines a bitmap
    02901         struct image_t {
    02902                 bool            f_alpha;                // whether the source had 4 components (depth = 0x20)
    02903                 long            f_width;                // size of the image in pixels
    02904                 long            f_height;
    02905                 unsigned char * f_data;                 // data of the image
    02906         };
    02907
    02908                                         TagImage(TagBase *parent);
    02909         //virtual                       ~TagImage();
    02910
    02911         virtual ErrorManager::error_code_t Save(Data& data);
    02912         virtual swf_type_t              TypeFlags(void) const;
    02913         void                            GetImageData(image_t& image_data) { image_data = f_image; }
    02914
    02915 /////////////// SETUP FUNCTIONS
    02916         void                            SetFormat(image_format_t format) { f_format = format; }
    02917         void                            SetQuality(int quality) { f_quality = quality; }
    02918         void                            SetDeblock(int deblock) { f_deblock = deblock; }
    02919         ErrorManager::error_code_t      SetFilename(const char *image, const char *mask);
    02920         void                            SetImage(long width, long height, unsigned char *data, bool alpha = false, long count = 0, unsigned char *colormap = 0);
    02921
    02922         ErrorManager::error_code_t      LoadTGA(const char *filename, image_t& im);
    02923         ErrorManager::error_code_t      LoadJPEG(const char *filename, image_t& im);
    02924         ErrorManager::error_code_t      SaveJPEG(Data& encoding, Data& image);
    02925         ErrorManager::error_code_t      SetAlpha(image_t& im, const image_t& mask);
    02926
    02927 private:
    02928         virtual ErrorManager::error_code_t PreSave(void);
    02929         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    02930
    02931         image_format_t          f_format;               // one of the IMAGE_FORMAT_...
    02932         image_t                 f_image;                // the image
    02933         int                     f_quality;              // for JPEG, the quality level (0 to 100)
    02934         int                     f_deblock;              // for JPEG, the deblock filter parameter (0 to 256)
    02935         long                    f_count;                // number of colors in the colormap
    02936         unsigned char *         f_colormap;             // the colormap when it can be generated
    02937 };
    02938
    02939
    02940
    02941 class TagShape : public TagBaseID
    02942 {
    02943 public:
    02944         enum morph_t {
    02945                 MORPH_MODE_SHAPE0 = 0,
    02946                 MORPH_MODE_SHAPE1 = 1,
    02947                 MORPH_MODE_BOTH_SHAPES = 2
    02948         };
    02949         enum fill_t {
    02950                 SHAPE_FILL_EVEN = 0,            // Also called Fill0
    02951                 SHAPE_FILL_ODD = 1              // Also called Fill1
    02952         };
    02953
    02954                                         TagShape(TagBase *parent);
    02955
    02956         virtual ErrorManager::error_code_t Save(Data& data);
    02957         virtual swf_type_t              TypeFlags(void) const;
    02958         ErrorManager::error_code_t      SaveWithoutStyles(Data& data);
    02959         void                            SaveAlignZone(Data& data) const;
    02960         bool                            HasAlignZone(void) const;
    02961         bool                            HasBounds(void) const { return !f_bounds[0].IsEmpty() || !f_bounds[1].IsEmpty(); }
    02962         const SRectangle&               Bounds(int index) const { assert(index == 0 || index == 1, "invalid index to query bounds"); return f_bounds[index]; }
    02963         bool                            IsGlyph(void) const;
    02964         bool                            IsEmpty(void) const;
    02965
    02966
    02967 /////////////// SETUP FUNCTIONS
    02968         ErrorManager::error_code_t      AddMove(morph_t morph_mode, long x, long y);
    02969         ErrorManager::error_code_t      AddEdge(morph_t morph_mode, long x, long y) { Edges::edge_t edge(x, y); return AddEdge(morph_mode, edge); }
    02970         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); };
    02971         void                            NewStyles(void);
    02972         ErrorManager::error_code_t      AddStyle(const Style& style, fill_t fill = SHAPE_FILL_EVEN);
    02973         void                            SetAlignZone(const SRectangle& zone);
    02974         ErrorManager::error_code_t      SetBounds(int index, const SRectangle& rect, bool show = false);
    02975         ErrorManager::error_code_t      SetStrokesBounds(int index, const SRectangle& rect);
    02976         void                            ShowBounds(bool show = true) { f_show_bounds = show; }
    02977         void                            ShowOrigin(bool show = true) { f_show_origin = show; }
    02978         void                            SetNonScalingStrokes(bool has_non_scaling_strokes) { f_has_non_scaling_strokes = has_non_scaling_strokes; }
    02979         void                            SetScalingStrokes(bool has_scaling_strokes) { f_has_scaling_strokes = has_scaling_strokes; }
    02980         void                            Glyph(void);
    02981
    02982         bool                            HasShowBounds(void) const { return f_show_bounds; }
    02983
    02984 public:
    02985         ErrorManager::error_code_t      AddEdge(morph_t morph_mode, const Edges::edge_t& edge);
    02986
    02987 private:
    02988         enum what_t {
    02989                 SHAPE_EDGES,
    02990                 SHAPE_SETUP
    02991         };
    02992
    02993         /// A base class to define edges and setup information
    02994         struct shape_what_t : public ItemBase
    02995         {
    02996                 what_t          f_what;
    02997                                 shape_what_t(what_t what) { f_what = what; }
    02998         };
    02999         /// The set of edges: line and curve segments
    03000         struct shape_edges_t : public shape_what_t
    03001         {
    03002                 Edges           f_edges;
    03003                                 shape_edges_t(what_t what) : shape_what_t(what) {}
    03004         };
    03005         /// The set of setup: fill, line and move
    03006         struct shape_setup_t : public shape_what_t
    03007         {
    03008                 int             f_fill_ref[2];
    03009                 int             f_line_ref;
    03010                 long            f_x;
    03011                 long            f_y;
    03012
    03013                                 shape_setup_t(what_t what, bool origin = false) : shape_what_t(what)
    03014                                 {
    03015                                         f_fill_ref[0] = f_fill_ref[1] = f_line_ref = -1;
    03016                                         if(origin) {
    03017                                                 f_x = f_y = 0;
    03018                                         }
    03019                                         else {
    03020                                                 f_x = f_y = LONG_MIN;
    03021                                         }
    03022                                 }
    03023         };
    03024
    03025         /// Records to separate different sets of styles
    03026         struct shape_record_t : public ItemBase {               // used to save in f_shapes
    03027                 Vectors *       f_fill_styles;
    03028                 Vectors *       f_line_styles;
    03029                 Vectors *       f_record;
    03030         };
    03031
    03032         /// Holds information used to save a shape
    03033         struct save_info_t {
    03034                 shape_record_t  f_sr;
    03035                 bool            f_save_alpha;
    03036                 bool            f_ext_size;
    03037                 bool            f_first;
    03038                 bool            f_save_styles;
    03039                 bool            f_shape4;
    03040                 Data            f_data;                 // we save it all here (we need to have the size before to create the tag data)
    03041                 int             f_fill_bits_count;
    03042                 int             f_line_bits_count;
    03043         };
    03044
    03045         void                            RecordEdges(void);
    03046         void                            RecordSetup(void);
    03047         void                            NewEdges(void);
    03048         void                            NewSetup(void);
    03049         void                            SetMorph(void);
    03050
    03051         // save sub-functions
    03052         virtual ErrorManager::error_code_t PreSave(void);
    03053         ErrorManager::error_code_t      SaveShape(save_info_t& info, shape_setup_t& last_setup);
    03054         //ErrorManager::error_code_t    SaveMorph(Data& data);
    03055         ErrorManager::error_code_t      SaveSetup(save_info_t& info, const shape_setup_t& setup, shape_setup_t& last);
    03056         ErrorManager::error_code_t      SaveStyles(save_info_t& info);
    03057         ErrorManager::error_code_t      SaveStylesCount(save_info_t& info, long count);
    03058         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    03059         void                            ParseAlignZone(const Data& data);
    03060
    03061         unsigned char                   f_version;              // the minimum version necessary to save this shape (determines the tag)
    03062         bool                            f_morph;                // this is a morph shape
    03063         bool                            f_is_glyph;             // used only as a glyph (font character)
    03064         bool                            f_show_bounds;          // draw the bounding rectangle around the shape
    03065         bool                            f_show_origin;          // draw lines showing the origin
    03066         bool                            f_has_non_scaling_strokes;      // whether there is at least one non-scaling stroke
    03067         bool                            f_has_scaling_strokes;  // whether there is at least one scaling stroke
    03068         SRectangle                      f_align_zone;           // to align glyphs the best we can
    03069         SRectangle                      f_bounds[2];            // where the shape is drawn
    03070         SRectangle                      f_strokes_bounds[2];    // where the shape is drawn
    03071
    03072         Vectors                         f_shapes;               // each shape saved here has its own set of fill & line style
    03073
    03074         shape_edges_t *                 f_edges;                // if not NULL that's the current Edges to fill
    03075         shape_edges_t *                 f_morph_edges;          // if not NULL that's the current Edges to fill the morph (2nd shape)
    03076         shape_setup_t *                 f_setup;                // if not NULL that's the current Setup to define
    03077         Vectors                         f_fill_styles;
    03078         Vectors                         f_line_styles;
    03079         Vectors                         f_record;               // the current shape being built
    03080         Vectors                         f_morph_record;         // the current morph shape being built
    03081 };
    03082
    03083
    03084
    03085 class TagSound : public TagBaseID
    03086 {
    03087 public:
    03088         enum sound_format_t {
    03089                 SOUND_FORMAT_UNKNOWN = -1,
    03090                 SOUND_FORMAT_RAW = 0,
    03091                 SOUND_FORMAT_ADPCM = 1,
    03092                 SOUND_FORMAT_MP3 = 2,
    03093                 SOUND_FORMAT_UNCOMPRESSED = 3,
    03094                 SOUND_FORMAT_NELLYMOSER = 6
    03095         };
    03096         enum sound_endian_t {
    03097                 SOUND_ENDIAN_LITTLE = 0,        // the user data is in little endian
    03098                 SOUND_ENDIAN_BIG,               // the user data is in big endian
    03099                 SOUND_ENDIAN_SAME,              // accept processor endianess as the data endianess
    03100                 SOUND_ENDIAN_DONTUSE,           // use this for 8bits data
    03101                 SOUND_ENDIAN_UNKNOWN            // undefined endianess -- the SetData() will always fail with this value
    03102         };
    03103
    03104                                 TagSound(TagBase *parent);
    03105
    03106         virtual ErrorManager::error_code_t Save(Data& data);
    03107         virtual swf_type_t      TypeFlags(void) const;
    03108
    03109         size_t                  GetSamplesCount(void) const;
    03110
    03111 /////////////// SETUP FUNCTIONS
    03112         ErrorManager::error_code_t SetFilename(const char *filename);
    03113         void                    SetFormat(sound_format_t format);
    03114         int                     SetData(const void *data, size_t size, sound_endian_t endian, int width, unsigned int rate, bool stereo);
    03115         void                    SetMono(void);
    03116         void                    Set8Bits(void);
    03117
    03118 public:
    03119         static const int        g_sound_rates[4];
    03120
    03121 private:
    03122         /// defines an MP3 sound wave (format, channels, rate, alignment, etc.)
    03123         struct sound_wave_t {
    03124                 short           format;                 // the data format (we only support PCM)
    03125                 short           channels;               // number of channels (1 - mono, 2 - stereo)
    03126                 int             rate;                   // exact sample rate to play the sound at
    03127                 int             average_rate;           // average rate for the entire set of samples (this may vary in compressed files)
    03128                 short           align;                  // byte alignment of the samples (every char, short, long...)
    03129                 /* the following is format dependent, but at this time doesn't vary for us */
    03130                 short           width;                  // width of the samples (8 or 16)
    03131         };
    03132
    03133         virtual ErrorManager::error_code_t PreSave(void);
    03134         short                   ReadSample(const unsigned char *data, unsigned short adjust, int in_fmt);
    03135         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);
    03136         int                     LoadWaveFile(FILE *f);
    03137         int                     LoadMP3File(FILE *f);
    03138         int                     CheckMP3Header(FILE *f, unsigned char *header, int& frame_size);
    03139         int                     ReadMP3Header(FILE *f, unsigned char *header);
    03140         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    03141
    03142         static const int        g_bitrates[2][16];
    03143         static const int        g_frequencies[4][4];
    03144
    03145         sound_format_t          f_format;
    03146         bool                    f_stereo;
    03147         int                     f_rate;
    03148         int                     f_width;
    03149         size_t                  f_samples;
    03150         int                     f_data_size;
    03151         int                     f_data_maxsize;
    03152         unsigned char *         f_data;
    03153         int                     f_latency_seek;
    03154 };
    03155
    03156
    03157
    03158
    03159
    03160
    03161 class TagSprite : public TagBaseID, public TagScalingGrid
    03162 {
    03163 public:
    03164                                 TagSprite(TagBase *parent);
    03165
    03166         virtual ErrorManager::error_code_t Save(Data& data);
    03167         virtual swf_type_t      TypeFlags(void) const;
    03168
    03169 /////////////// SETUP FUNCTIONS
    03170         // Add objects to a sprite by defining the sprite tag as
    03171         // the parent of these objects.
    03172         // The parent of a sprite must be a TagHeader object.
    03173
    03174         // We now have one setup function: SetGrid() inherited from
    03175         // the TagScalingGrid class
    03176
    03177 protected:
    03178         virtual ErrorManager::error_code_t OnNewChild(const char *child_name) const;
    03179
    03180 private:
    03181         virtual ErrorManager::error_code_t PreSave(void);
    03182         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    03183 };
    03184
    03185
    03186
    03187
    03188 class TagText : public TagBaseID, public TagCSMTextSettings
    03189 {
    03190 public:
    03191                                         TagText(TagBase *parent);
    03192
    03193         virtual ErrorManager::error_code_t Save(Data& data);
    03194         virtual swf_type_t              TypeFlags(void) const;
    03195
    03196 /////////////// SETUP FUNCTIONS
    03197         void                            SetMatrix(const Matrix& matrix);
    03198         void                            SetBounds(const SRectangle& bounds);
    03199         ErrorManager::error_code_t      AddText(const char *string, long advance = LONG_MIN);
    03200         void                            AddFont(const TagFont *font, long height);
    03201         void                            AddOffsets(long x, long y);
    03202         void                            AddColor(Color& color);
    03203
    03204 private:
    03205         enum text_type_t {
    03206                 TEXT_ENTRY_TEXT = 0,
    03207                 TEXT_ENTRY_SETUP
    03208         };
    03209
    03210         /// Structure used to memories the type of definition
    03211         struct text_define_t : public ItemBase {                // used to save in f_shapes
    03212                 const text_type_t       f_type;
    03213
    03214                                         text_define_t(text_type_t type) : f_type(type) {}
    03215         };
    03216
    03217         /// Structure representing a text setup
    03218         struct text_setup_t : public text_define_t {            // used to save in f_shapes
    03219                 bool                    f_has_font;
    03220                 const TagFont *         f_font;
    03221                 unsigned short          f_font_height;
    03222                 bool                    f_has_xadjust;
    03223                 long                    f_xadjust;
    03224                 bool                    f_has_xoffset;
    03225                 long                    f_x;
    03226                 bool                    f_has_yoffset;
    03227                 long                    f_y;
    03228                 bool                    f_has_color;
    03229                 Color                   f_color;
    03230
    03231                                         text_setup_t(void);
    03232                                         text_setup_t(const text_setup_t& setup);
    03233                 void                    Unused(void);
    03234                 bool                    IsUsed(void) const;
    03235         };
    03236
    03237         /// Structure representing a text entry (an actual string)
    03238         struct text_entry_t : public text_define_t {
    03239                 sswf_ucs4_t *           f_text;
    03240                 long                    f_advance;
    03241                 unsigned long           f_length;               // length of the string
    03242                 unsigned long           f_exact_length;         // length of string without spaces
    03243                 TagFont::font_info_t *  f_entries;              // an array of entries
    03244
    03245                                         text_entry_t(sswf_ucs4_t *string, long advance);
    03246         };
    03247
    03248         virtual ErrorManager::error_code_t PreSave(void);
    03249         int                             DefineText(int start, text_setup_t *s, const TagFont *font, int font_height);
    03250         ErrorManager::error_code_t      RecordSetup(void);
    03251         void                            NewSetup(void);
    03252         virtual ErrorManager::error_code_t ParseTag(swf_tag_t tag, const Data& data);
    03253
    03254         Matrix                  f_matrix;               // a transformation matrix for this text
    03255         SRectangle              f_bounds;               // where the string is drawn
    03256         text_setup_t            f_setup;                // current setup definition
    03257         bool                    f_new_text;             // if true we need to recompute the text info entries
    03258         int                     f_version;              // the PreSave() defines this, Save() uses it
    03259         Vectors                 f_records;              // text records
    03260 };
    03261
    03262
    03263
    03264
    03265
    03266
    03267
    03268
    03269
    03270 };              // namespace sswf
    03271 #endif                  /* #ifndef LIBSSWF_H */