Main Page   Namespace List   Class Hierarchy   Compound List   File List   Compound Members   File Members  

FBase.h File Reference

#include <iostream>
#include <vector>
#include <math.h>

Go to the source code of this file.

Compounds

class  BitBuffer
class  BitStreamIn
class  BitStreamOut
struct  flash_pair
class  FlashColorTransform
class  FlashFixed
class  FlashFixed16
class  FlashHeader
class  FlashIDEnabled
class  FlashIDFactory
class  FlashMatrix
class  FlashMatrixRotate
class  FlashMatrixScale
class  FlashMatrixTranslate
class  FlashRect
class  FlashRGB
class  FlashSpriteEnabled
class  FlashTag
class  FlashTagHeader
class  FlashVersionEnabled
class  gc_vector

Defines

#define WRITE_UBYTE(x)   { UBYTE s = (x); out.write((char*)&s,1); }
#define WRITE_SBYTE(x)   { SBYTE s = (x); out.write((char*)&s,1); }
#define WRITE_UWORD(x)   { UWORD s = (x); out.write((char*)&s,2); }
#define WRITE_SWORD(x)   { SWORD s = (x); out.write((char*)&s,2); }
#define WRITE_UDWORD(x)   { UDWORD s = (x); out.write((char*)&s,4); }
#define WRITE_SDWORD(x)   { SDWORD s = (x); out.write((char*)&s,4); }
#define WRITE_UBYTE2(x, f)   { UBYTE s = (x); f.write((char*)&s,1); }
#define WRITE_SBYTE2(x, f)   { SBYTE s = (x); f.write((char*)&s,1); }
#define WRITE_UWORD2(x, f)   { UWORD s = (x); f.write((char*)&s,2); }
#define WRITE_SWORD2(x, f)   { SWORD s = (x); f.write((char*)&s,2); }
#define WRITE_UDWORD2(x, f)   { UDWORD s = (x); f.write((char*)&s,4); }
#define WRITE_SDWORD2(x, f)   { SDWORD s = (x); f.write((char*)&s,4); }
#define READ_UBYTE(x)   { in.read((char*)&x,1); }
#define READ_SBYTE(x)   { in.read((char*)&x,1); }
#define READ_UWORD(x)   { in.read((char*)&x,2); }
#define READ_SWORD(x)   { in.read((char*)&x,2); }
#define READ_UDWORD(x)   { in.read((char*)&x,4); }
#define READ_SDWORD(x)   { in.read((char*)&x,4); }
#define READ_UBYTE2(x, f)   { f.read((char*)&x,1); }
#define READ_SBYTE2(x, f)   { f.read((char*)&x,1); }
#define READ_UWORD2(x, f)   { f.read((char*)&x,2); }
#define READ_SWORD2(x, f)   { f.read((char*)&x,2); }
#define READ_UDWORD2(x, f)   { f.read((char*)&x,4); }
#define READ_SDWORD2(x, f)   { f.read((char*)&x,4); }
#define DEFINE_RW_INTERFACE
#define DEFINE_SIMPLE_TAG(x, n)
#define DECLARE_SIMPLE_TAG(x)
#define DECLARE_SIMPLE_TAG2(x)
#define DECLARE_SIMPLE_TAG3(x)

Typedefs

typedef unsigned char UBYTE
typedef char SBYTE
typedef unsigned short UWORD
typedef short SWORD
typedef unsigned int UDWORD
typedef int SDWORD

Functions

template<class T>
T 		max (T a, T b)
template<class T>
T 		min (T a, T b)
template<class T>
T 		LSHR (T x, int num)
template<class T>
int 		GetBitSize (T x)
template<class T>
int 		GetBitSizeSigned (T x)
template<class T>
T 		PackBitsSigned (T x)
template<class T>
T 		UnPackBitsSigned (T x, int size)
template<class T>
char 		GetBit (T x, int bit)
template<class T>
T 		IsolateBits (T x, int bit1, int bit2)
template<class T>
T 		GetIsolatedBits (T x, int bit1, int bit2)
template<class T>
BitStreamOut & 		operator<< (BitStreamOut &o, const T t)
FlashMatrix CreateMatrix (FlashRect bounds, float scaleX, float scaleY, float rotation, float translateX, float translateY, bool bScale, bool bRotate)

Define Documentation

#define DECLARE_SIMPLE_TAG (  x ) 
 

Value:

class x : public FlashTag \
{                               \
        DEFINE_RW_INTERFACE                     \
public:                         \
    x() {} \
    ~x() {} \
    friend std::ostream &operator << (std::ostream &out, const x &data); \
    friend std::istream &operator >> (std::istream &in,  x &data); \
};

#define DECLARE_SIMPLE_TAG2 (  x ) 
 

Value:

class x : public FlashSpriteEnabled \
{                               \
        DEFINE_RW_INTERFACE                     \
public:                         \
    x() {} \
    ~x() {} \
    friend std::ostream &operator << (std::ostream &out, const x &data); \
    friend std::istream &operator >> (std::istream &in,  x &data); \
};

#define DECLARE_SIMPLE_TAG3 (  x ) 
 

Value:

class x : public FlashSpriteEnabled \
{                               \
        DEFINE_RW_INTERFACE                     \
public:                         \
    x() {} \
    ~x() {} \
        virtual bool isFrame() { return true; }\
    friend std::ostream &operator << (std::ostream &out, const x &data); \
    friend std::istream &operator >> (std::istream &in,  x &data); \
};

#define DEFINE_RW_INTERFACE
 

Value:

public:                                                                                                 \
virtual void Write(std::ostream &out) { out << *this; } \
virtual void Read(std::istream &in) { in >> *this; }    \

#define DEFINE_SIMPLE_TAG (  x, n ) 
 

Value:

std::ostream &operator << (std::ostream &out, const x &data) \
{ \
    return (out << FlashTagHeader(n,0)); \
} \
std::istream &operator >> (std::istream &in,  x &data) \
{ \
    return in; \
}

#define READ_SBYTE (  x )     { in.read((char*)&x,1); }
 

#define READ_SBYTE2 (  x, f )     { f.read((char*)&x,1); }
 

#define READ_SDWORD (  x )     { in.read((char*)&x,4); }
 

#define READ_SDWORD2 (  x, f )     { f.read((char*)&x,4); }
 

#define READ_SWORD (  x )     { in.read((char*)&x,2); }
 

#define READ_SWORD2 (  x, f )     { f.read((char*)&x,2); }
 

#define READ_UBYTE (  x )     { in.read((char*)&x,1); }
 

#define READ_UBYTE2 (  x, f )     { f.read((char*)&x,1); }
 

#define READ_UDWORD (  x )     { in.read((char*)&x,4); }
 

#define READ_UDWORD2 (  x, f )     { f.read((char*)&x,4); }
 

#define READ_UWORD (  x )     { in.read((char*)&x,2); }
 

#define READ_UWORD2 (  x, f )     { f.read((char*)&x,2); }
 

#define WRITE_SBYTE (  x )     { SBYTE s = (x); out.write((char*)&s,1); }
 

#define WRITE_SBYTE2 (  x, f )     { SBYTE s = (x); f.write((char*)&s,1); }
 

#define WRITE_SDWORD (  x )     { SDWORD s = (x); out.write((char*)&s,4); }
 

#define WRITE_SDWORD2 (  x, f )     { SDWORD s = (x); f.write((char*)&s,4); }
 

#define WRITE_SWORD (  x )     { SWORD s = (x); out.write((char*)&s,2); }
 

#define WRITE_SWORD2 (  x, f )     { SWORD s = (x); f.write((char*)&s,2); }
 

#define WRITE_UBYTE (  x )     { UBYTE s = (x); out.write((char*)&s,1); }
 

#define WRITE_UBYTE2 (  x, f )     { UBYTE s = (x); f.write((char*)&s,1); }
 

#define WRITE_UDWORD (  x )     { UDWORD s = (x); out.write((char*)&s,4); }
 

#define WRITE_UDWORD2 (  x, f )     { UDWORD s = (x); f.write((char*)&s,4); }
 

#define WRITE_UWORD (  x )     { UWORD s = (x); out.write((char*)&s,2); }
 

#define WRITE_UWORD2 (  x, f )     { UWORD s = (x); f.write((char*)&s,2); }
 

Typedef Documentation

typedef char SBYTE
 

typedef int SDWORD
 

typedef short SWORD
 

typedef unsigned char UBYTE
 

typedef unsigned int UDWORD
 

typedef unsigned short UWORD
 

Function Documentation

FlashMatrix CreateMatrix (  FlashRect bounds,
float scaleX,
float scaleY,
float rotation,
float translateX,
float translateY,
bool bScale,
bool bRotate
) 
 

template<class T>
char GetBit (  T x,
int bit
) 
 

template<class T>
int GetBitSize (  T x ) 
 

template<class T>
int GetBitSizeSigned (  T x ) 
 

template<class T>
T GetIsolatedBits (  T x,
int bit1,
int bit2
) 
 

template<class T>
T IsolateBits (  T x,
int bit1,
int bit2
) 
 

template<class T>
T LSHR (  T x,
int num
) 
 

template<class T>
T PackBitsSigned (  T x ) 
 

template<class T>
T UnPackBitsSigned (  T x,
int size
) 
 

template<class T>
T max (  T a,
T b
) 
 

template<class T>
T min (  T a,
T b
) 
 

template<class T>
BitStreamOut& operator<< (  BitStreamOut & o,
const T t
) 
 

Generated at Wed Aug 1 13:33:52 2001 for SWFSource by doxygen1.2.9 written by Dimitri van Heesch, © 1997-2001