fshape.cpp

这是一个用VC++开发的flashsource端的程序

#include <iostream>
#include <sstream>
#include <strstream>
#include "FShape.h"

std::ostream &operator<< (std::ostream &out, FlashFillStyle &data)
{
	data.Write(out);
	return out;
}
std::istream &operator>> (std::istream &in,  FlashFillStyle &data)
{
	data.Read(in);
	return in;
}

void FlashFillStyleSolid::Write(std::ostream &out) 
{
	out.put((char)0);
	if(GetTagVersion() > 2) r1.SetAlphaWriteMode(true);
	else					r1.SetAlphaWriteMode(false);
	out << r1;
}
void FlashFillStyleSolid::Read(std::istream &in) 
{
	int c = in.get();
	if(c==EOF || c != 0)
	{
		//throw
	}
	if(GetTagVersion() > 2) r1.SetAlphaWriteMode(true);
	else					r1.SetAlphaWriteMode(false);
	in >> r1;
}
void FlashFillStyleBitmap::Write(std::ostream &out) 
{
	if(tiled) out.put((char)0x40);
	else	  out.put((char)0x41);
	WRITE_UWORD(bitmapID);
	out << matrix;

}
void FlashFillStyleBitmap::Read(std::istream &in) 
{
	int c = in.get();
	if(c == EOF)
	{
		//throw
	}
	else if(c == 0x40)
	{
		tiled = true;
		type = 0x40;
	}
	else if(c == 0x41)
	{
		tiled = false;
		type = 0x41;
	}
	else
	{
		//throw
	}
	READ_UWORD(bitmapID);

	in >> matrix;
}


std::ostream &operator<< (std::ostream &out, FlashGradientRecord &data)
{
	out.put((unsigned char)data.ratios.size());
	for(unsigned int i = 0; i < data.ratios.size(); i++)
	{
		out.put(data.ratios[i]);
		
		if(data.GetTagVersion() > 2) data.colors[i].SetAlphaWriteMode(true);
		else						 data.colors[i].SetAlphaWriteMode(false);

		out << data.colors[i];
	}
	return out;
}

std::istream &operator>> (std::istream &in,  FlashGradientRecord &data)
{
	int c = in.get();
	//if(i == EOF) throw;
	for(int i = 0; i < c; i++)
	{
		int c2 = in.get();
		//if(c2 == EOF) throw;

		data.ratios.push_back(c2);
		data.colors.push_back(FlashRGB(0,0,0));

		if(data.GetTagVersion() > 2) data.colors[i].SetAlphaWriteMode(true);
		else						 data.colors[i].SetAlphaWriteMode(false);

		in >> data.colors[i];
	}
	return in;
}


void FlashFillStyleGradient::Write(std::ostream &out)
{
	out.put((char)type);
	gradient.SetTagVersion(GetTagVersion());
	out << matrix;
	out << gradient;
}

void FlashFillStyleGradient::Read(std::istream &in)
{
	int c = in.get();
	//if(c == EOF) throw;
	//if(c != 0x10 || c != 0x12) throw;
	
	type = c;
	
	gradient.SetTagVersion(GetTagVersion());
	in >> matrix;
	in >> gradient;
}

FlashFillStyleArray::FlashFillStyleArray( const FlashFillStyleArray &that )
{
	// Copy list contents
	for(std::vector<FlashFillStyle*>::const_iterator i = that.styles.begin(); 
		i != that.styles.end(); i++ )
	{
		FlashFillStyle *style = (*i)->Copy();
		gc.push_back( style );
		styles.push_back( style );
	}
}

FlashLineStyleArray::FlashLineStyleArray( const FlashLineStyleArray &that )
{
	// Copy list contents
	for(std::vector<FlashLineStyle*>::const_iterator i = that.styles.begin(); 
		i != that.styles.end(); i++ )
	{
		FlashLineStyle *style = (*i)->Copy();
		gc.push_back( style );
		styles.push_back( style );
	}
}

std::ostream &operator<< (std::ostream &out, FlashFillStyleArray &data)
{
	out.put((unsigned char)data.styles.size());
	for(std::vector<FlashFillStyle*>::iterator i=data.styles.begin(); i!=data.styles.end(); i++)
	{
		FlashFillStyle *style = *i;
		(*style).SetTagVersion(data.GetTagVersion());
		out << **i;
	}
	return out;
}
std::istream &operator>> (std::istream &in,  FlashFillStyleArray &data)
{
	SWORD c2 = in.get();
	if((c2 == 0xff) && (data.GetTagVersion() > 1))
	{
		READ_SWORD(c2);		
	}
	//if(c == EOF) throw;
	for(int i = 0; i < c2; i++)
	{
		//if(c == EOF) throw;
		int c = in.get();	
		/* FILL TYPES
		0x00 - solid
		0x10 - linear gradient
		0x12 - radial gradient
		0x40 - tiled bitmap
		0x41 - clipped bitmap
		*/
		FlashFillStyle *style = NULL;
		if(c == 0x00)
		{
			in.putback(c);
			FlashFillStyleSolid *tmp = new FlashFillStyleSolid();
			data.gc.push_back(tmp);
			tmp->SetTagVersion(data.GetTagVersion());
			in >> *tmp;
			style = tmp;

		}
		else if(c == 0x10 || c == 0x12)
		{
			in.putback(c);
			FlashFillStyleGradient *tmp = new FlashFillStyleGradient();
			data.gc.push_back(tmp);
			tmp->SetTagVersion(data.GetTagVersion());
			in >> *tmp;
			style = tmp;
		}
		else if(c == 0x40 || c == 0x41)
		{			
			in.putback(c);
			FlashFillStyleBitmap *tmp = new FlashFillStyleBitmap();
			data.gc.push_back(tmp);
			tmp->SetTagVersion(data.GetTagVersion());
			in >> *tmp;
			style = tmp;
		}
		else
		{
			//throw
		}
		if ( style != NULL )
			data.styles.push_back(style);
	}
	return in;
}

int FlashFillStyleArray::GetNBits()
{
	return GetBitSize(styles.size());
}

std::ostream &operator<< (std::ostream &out, FlashLineStyle &data)
{
	WRITE_UWORD(data.width);

	if(data.GetTagVersion() > 2) data.color.SetAlphaWriteMode(true);
	else					data.color.SetAlphaWriteMode(false);

	out << data.color;
	return out;
}
std::istream &operator>> (std::istream &in,  FlashLineStyle &data)
{
	READ_UWORD(data.width);

	if(data.GetTagVersion() > 2) data.color.SetAlphaWriteMode(true);
	else						 data.color.SetAlphaWriteMode(false);

	
	in >> data.color;
	return in;
}

int FlashLineStyleArray::GetNBits()
{
	return GetBitSize(styles.size());
}
std::ostream &operator<< (std::ostream &out, FlashLineStyleArray &data)
{
	out.put((char)data.styles.size());
	for(std::vector<FlashLineStyle*>::iterator i=data.styles.begin(); i!=data.styles.end(); i++)
	{
		(**i).SetTagVersion(data.GetTagVersion());
		out << **i;
	}
	return out;
}
std::istream &operator>> (std::istream &in,  FlashLineStyleArray &data)
{
	int c = in.get();
	//if(c == EOF) throw;
	for(int i = 0; i < c; i++)
	{
		FlashLineStyle *style = new FlashLineStyle();
		data.gc.push_back(style);
		style->SetTagVersion(data.GetTagVersion());		
		in >> *style;
		data.styles.push_back(style);		
	}
	return in;
}


void FlashShapeRecordStraight::Write(BitBuffer &out, FlashShapeCommon &data)
{
	int bits = fbase_max(GetBitSizeSigned(dx),GetBitSizeSigned(dy))-2;
	if(bits < 1) bits = 1;
	
	BitBuffer &b=out;
	b.Write(1,1);
	b.Write(1,1);
	
	b.Write(bits,4);
	if(dx==0)
	{
		b.Write(0,1);
		b.Write(1,1);
		b.Write(PackBitsSigned(dy),bits+2);
	}
	else if(dy==0)
	{
		b.Write(0,1);
		b.Write(0,1);
		b.Write(PackBitsSigned(dx),bits+2);
	}
	else
	{
		b.Write(1,1);
		b.Write(PackBitsSigned(dx),bits+2);
		b.Write(PackBitsSigned(dy),bits+2);
	}
}
void FlashShapeRecordStraight::Read(BitStreamIn &in, FlashShapeCommon &data)
{
	int bits;	
	in.Read(bits,4);

	bits+=2;

	int type;
	in.Read(type, 1);
	if(type == 0)
	{
		int type2;
		in.Read(type2, 1);

		if(type2 == 1)
		{
			in.Read(dy,bits);
			dy = UnPackBitsSigned(dy, bits);
			dx = 0;
		}
		else if(type2 == 0)
		{
			in.Read(dx,bits);
			dx = UnPackBitsSigned(dx, bits);
			dy = 0;
		}
	}
	else
	{
		in.Read(dx,bits);
		dx = UnPackBitsSigned(dx, bits);
		in.Read(dy,bits);
		dy = UnPackBitsSigned(dy, bits);
	}
}

void FlashShapeRecordCurved::Write(BitBuffer &out, FlashShapeCommon &data)
{
	BitBuffer &b=out;
	int bits = (fbase_max(fbase_max(GetBitSizeSigned(dxa),GetBitSizeSigned(dya)), 
					fbase_max(GetBitSizeSigned(dxc),GetBitSizeSigned(dyc))
					)
				)-2;
	if(bits < 1) bits = 1;


	b.Write(1,1);
	b.Write(0,1);
	
	b.Write(bits,4);
	b.Write(PackBitsSigned(dxc),bits+2);
	b.Write(PackBitsSigned(dyc),bits+2);
	b.Write(PackBitsSigned(dxa),bits+2);
	b.Write(PackBitsSigned(dya),bits+2);
}
void FlashShapeRecordCurved::Read(BitStreamIn &in, FlashShapeCommon &data)
{
	BitStreamIn &b=in;
	int bits;
	b.Read(bits,4);
	b.Read(dxc,bits+2);
	dxc = UnPackBitsSigned(dxc, bits+2);
	b.Read(dyc,bits+2);
	dyc = UnPackBitsSigned(dyc, bits+2);
	b.Read(dxa,bits+2);
	dxa = UnPackBitsSigned(dxa, bits+2);
	b.Read(dya,bits+2);
	dya = UnPackBitsSigned(dya, bits+2);
}
FlashShapeRecordChange::FlashShapeRecordChange()
{
	newstyles=false;
	linestyle=false;
	fillstyle1=false;
	fillstyle0=false;
	moveto=false;
}

FlashShapeRecordChange::FlashShapeRecordChange(SDWORD _dx, SDWORD _dy)
{
	newstyles=false;