1771 lines
47 KiB
C++
1771 lines
47 KiB
C++
// Copyright © 1999 Middlesoft, Inc. All rights reserved.
|
|
// First Created By Lee Thomason.
|
|
// First Created On 09/08/1999.
|
|
// Last Modified On 11/09/1999.
|
|
|
|
/****************************************************************************************
|
|
|
|
File Summary: FDTShapes.cpp
|
|
|
|
This source file contains the definition for all low-level shape-related functions,
|
|
grouped by classes:
|
|
|
|
Class Member Function
|
|
|
|
FCXForm FCXForm(U32, U32, S32, S32, S32, S32, S32, S32);
|
|
U32 FCXForm::MinBits();
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
FCXFormWAlpha FCXFormWAlpha(U32, U32, S32, S32, S32, S32, S32, S32, S32, S32);
|
|
U32 MinBits();
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
FDTDefineMorphShape FDTDefineMorphShape (FRect*, FRect*);
|
|
~FDTDefineMorphShape();
|
|
U32 AddFillStyle(FMorphFillStyle*);
|
|
U32 AddLineStyle(U32, FColor*,
|
|
U32, FColor*);
|
|
void FinishStyleArrays();
|
|
void AddShapeRec_1(FShapeRec*);
|
|
void AddEdgeRec_2(FShapeRec*);
|
|
U16 ID();
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
FDTDefineShape FDTDefineShape(FRect*);
|
|
~FDTDefineShape();
|
|
void AddShapeRec(FShapeRec*);
|
|
U32 AddFillStyle(FFillStyle*);
|
|
U32 AddSolidFillStyle(FColor*);
|
|
U32 AddLineStyle(U32, FColor*);
|
|
void FinishStyleArrays();
|
|
U16 ID();
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
FDTDefineShape2 FDTDefineShape2(FRect*);
|
|
~FDTDefineShape2();
|
|
void AddShapeRec(FShapeRec*);
|
|
U32 AddFillStyle(FFillStyle*);
|
|
U32 AddSolidFillStyle(FColor*);
|
|
U32 AddLineStyle(U32, FColor*);
|
|
void FinishStyleArrays();
|
|
U16 ID();
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
FDTDefineShape3 FDTDefineShape3(FRect*);
|
|
~FDTDefineShape3();
|
|
void AddShapeRec(FShapeRec*);
|
|
U32 AddFillStyle(FFillStyle*);
|
|
U32 AddSolidFillStyle(FColor*);
|
|
U32 AddLineStyle(U32, FColor*);
|
|
void FinishStyleArrays();
|
|
U16 ID();
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
FFillStyleArray U32 Size();
|
|
U32 Add(FAFillStyle*);
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
FFillStyleBitmap FFillStyleBitmap(int, U16, FMatrix*);
|
|
~FFillStyleBitmap();
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
FFillStyleGradient FFillStyleGradient(int, FMatrix*, FGradient*);
|
|
~FFillStyleGradient();
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
FFillStyleSolid FFillStyleSolid(FColor*);
|
|
~FFillStyleSolid();
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
FGradient FGradient(void);
|
|
~FGradient(void);
|
|
void Add(FAGradRecord*);
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
FGradRecord FGradRecord(U32, FColor*);
|
|
~FGradRecord();
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
FLineStyle FLineStyle(U32, FColor*);
|
|
~FLineStyle();
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
FLineStyleArray FLineStyleArray();
|
|
~FLineStyleArray();
|
|
U32 Size();
|
|
U32 Add(FALineStyle *);
|
|
void WriteToSWFStream(FSWFStream *);
|
|
|
|
FMorphFillStyleBitmap FMorphFillStyleBitmap(int, U16, FMatrix*, FMatrix*);
|
|
~FMorphFillStyleBitmap();
|
|
void WriteToSWFStream(FSWFStream *);
|
|
|
|
FMorphFillStyleGradient FMorphFillStyleGradient(int, FMatrix*, FMatrix*, FGradient*);
|
|
~FMorphFillStyleGradient();
|
|
void WriteToSWFStream(FSWFStream *);
|
|
|
|
FMorphFillStyleSolid FMorphFillStyleSolid( FColor*, FColor*);
|
|
~FMorphFillStyleSolid()
|
|
void WriteToSWFStream(FSWFStream *);
|
|
|
|
FMorphGradRecord FMorphGradRecord(U32, FColor*, U32, FColor*);
|
|
~FMorphGradRecord();
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
FMorphLineStyle FMorphLineStyle(U32, U32, FColor*, FColor*);
|
|
~FMorphLineStyle();
|
|
void WriteToSWFStream(FSWFStream *);
|
|
|
|
FShape FShape();
|
|
~FShape();
|
|
SetFillBits(U32);
|
|
SetLineBits(U32);
|
|
AddShapeRec(FShapeRec *);
|
|
void WriteToSWFStream(FSWFStream *);
|
|
|
|
FShapeRecChange FShapeRecChange(U32, U32, U32, U32, U32,
|
|
S32, S32, U32, U32, U32,
|
|
FFillStyleArray*, FLineStyleArray*);
|
|
~FShapeRecChange();
|
|
void IncludeNFillBitInfo(U32);
|
|
void IncludeNLineBitInfo(U32);
|
|
U32 MinBits();
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
FShapeRecEdgeStraight FShapeRecEdgeStraight(S32, S32);
|
|
U32 MinBits(void);
|
|
void IncludeNFillBitInfo(U32);
|
|
void IncludeNLineBitInfo(U32);
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
FShapeRecEdgeCurved FShapeRecEdgeCurved(S32, S32, S32, S32);
|
|
U32 MinBits(void);
|
|
void IncludeNFillBitInfo(U32 );
|
|
void IncludeNLineBitInfo(U32 );
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
FShapeRecEnd FShapeRecEnd();
|
|
void IncludeNFillBitInfo(U32 );
|
|
void IncludeNLineBitInfo(U32 );
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
FShapeWStyle FShapeWStyle(FFillStyleArray*, FLineStyleArray*);
|
|
~FShapeWStyle() ;
|
|
void AddShapeRec(FShapeRec*);
|
|
U32 NumFillBits();
|
|
U32 NumLineBits();
|
|
void WriteToSWFStream(FSWFStream*);
|
|
|
|
****************************************************************************************/
|
|
|
|
#include "tpixel.h"
|
|
#include "FDTShapes.h"
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FCXForm ----------------------------------------------------------------
|
|
|
|
FCXForm::FCXForm(U32 _hasAdd, U32 _hasMult, S32 _redMultTerm, S32 _greenMultTerm, S32 _blueMultTerm, S32 _redAddTerm, S32 _greenAddTerm, S32 _blueAddTerm)
|
|
{
|
|
hasAdd = _hasAdd;
|
|
hasMult = _hasMult;
|
|
redMultTerm = _redMultTerm;
|
|
greenMultTerm = _greenMultTerm;
|
|
blueMultTerm = _blueMultTerm;
|
|
redAddTerm = _redAddTerm;
|
|
greenAddTerm = _greenAddTerm;
|
|
blueAddTerm = _blueAddTerm;
|
|
nBits = MinBits();
|
|
}
|
|
|
|
//
|
|
U32 FCXForm::MinBits()
|
|
{
|
|
|
|
// two step process to find maximum value of 6 numbers because "FSWFStream::MaxNum" takes only 4 arguments
|
|
U32 maxValue = FSWFStream::MaxNum(redMultTerm, greenMultTerm, blueMultTerm, redAddTerm);
|
|
maxValue = FSWFStream::MaxNum(greenAddTerm, blueAddTerm, (S32)maxValue, 0);
|
|
|
|
return FSWFStream::MinBits(maxValue, 1) + 1;
|
|
}
|
|
|
|
//
|
|
void FCXForm::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
|
|
_SWFStream->WriteBits(hasMult, 1);
|
|
_SWFStream->WriteBits(hasAdd, 1);
|
|
_SWFStream->WriteBits(nBits, 4);
|
|
|
|
if (hasMult) {
|
|
_SWFStream->WriteBits((S32)redMultTerm, nBits);
|
|
_SWFStream->WriteBits((S32)greenMultTerm, nBits);
|
|
_SWFStream->WriteBits((S32)blueMultTerm, nBits);
|
|
}
|
|
if (hasAdd) {
|
|
_SWFStream->WriteBits((S32)redAddTerm, nBits);
|
|
_SWFStream->WriteBits((S32)greenAddTerm, nBits);
|
|
_SWFStream->WriteBits((S32)blueAddTerm, nBits);
|
|
}
|
|
|
|
_SWFStream->FlushBits();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FCXFormWAlpha ----------------------------------------------------------
|
|
|
|
FCXFormWAlpha::FCXFormWAlpha(U32 _hasAdd, U32 _hasMult, S32 _redMultTerm, S32 _greenMultTerm, S32 _blueMultTerm, S32 _alphaMultTerm,
|
|
S32 _redAddTerm, S32 _greenAddTerm, S32 _blueAddTerm, S32 _alphaAddTerm)
|
|
: FCXForm(_hasAdd, _hasMult, _redMultTerm, _greenMultTerm, _blueMultTerm,
|
|
_redAddTerm, _greenAddTerm, _blueAddTerm)
|
|
{
|
|
alphaMultTerm = _alphaMultTerm;
|
|
|
|
alphaAddTerm = _alphaAddTerm;
|
|
|
|
nBits = MinBits();
|
|
}
|
|
|
|
U32 FCXFormWAlpha::MinBits()
|
|
{
|
|
|
|
// FFileWrite's MaxNum method takes only 4 arguments, so finding maximum value of 8 arguments takes three steps:
|
|
U32 maxMult = FSWFStream::MaxNum(redMultTerm, greenMultTerm, blueMultTerm, alphaMultTerm);
|
|
U32 maxAdd = FSWFStream::MaxNum(redAddTerm, greenAddTerm, blueAddTerm, alphaAddTerm);
|
|
U32 maxValue = FSWFStream::MaxNum((S32)maxMult, (S32)maxAdd, 0, 0);
|
|
|
|
return FSWFStream::MinBits(maxValue, 1) + 1;
|
|
}
|
|
|
|
void FCXFormWAlpha::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
|
|
//fill? I think so
|
|
_SWFStream->FlushBits();
|
|
|
|
_SWFStream->WriteBits(hasMult, 1);
|
|
_SWFStream->WriteBits(hasAdd, 1);
|
|
_SWFStream->WriteBits(nBits, 4);
|
|
|
|
if (hasMult) {
|
|
_SWFStream->WriteBits((S32)redMultTerm, nBits);
|
|
_SWFStream->WriteBits((S32)greenMultTerm, nBits);
|
|
_SWFStream->WriteBits((S32)blueMultTerm, nBits);
|
|
_SWFStream->WriteBits((S32)alphaMultTerm, nBits);
|
|
}
|
|
if (hasAdd) {
|
|
_SWFStream->WriteBits((S32)redAddTerm, nBits);
|
|
_SWFStream->WriteBits((S32)greenAddTerm, nBits);
|
|
_SWFStream->WriteBits((S32)blueAddTerm, nBits);
|
|
_SWFStream->WriteBits((S32)alphaAddTerm, nBits);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FDTDefineMorphShape ----------------------------------------------------
|
|
|
|
FDTDefineMorphShape::FDTDefineMorphShape(FRect *_rect1, FRect *_rect2)
|
|
{
|
|
|
|
characterID = FObjCollection::Increment();
|
|
shapeBounds_1 = _rect1;
|
|
shapeBounds_2 = _rect2;
|
|
morphFillStyleArray = new FFillStyleArray();
|
|
morphLineStyleArray = new FLineStyleArray();
|
|
styleArraysFinished = false;
|
|
}
|
|
|
|
FDTDefineMorphShape::~FDTDefineMorphShape()
|
|
{
|
|
|
|
delete shapeBounds_1;
|
|
delete shapeBounds_2;
|
|
delete morphFillStyleArray;
|
|
delete morphLineStyleArray;
|
|
}
|
|
|
|
U32 FDTDefineMorphShape::AddFillStyle(FMorphFillStyle *fillStyle)
|
|
{
|
|
|
|
assert(!styleArraysFinished);
|
|
return morphFillStyleArray->Add(fillStyle);
|
|
}
|
|
|
|
U32 FDTDefineMorphShape::AddLineStyle(U32 startLineWidth, FColor *startLineColor,
|
|
U32 finalLineWidth, FColor *finalLineColor)
|
|
{
|
|
assert(!styleArraysFinished);
|
|
|
|
// here changed.
|
|
// morph shape always has RGBA color.
|
|
startLineColor->AlphaChannel(true);
|
|
finalLineColor->AlphaChannel(true);
|
|
|
|
// Create a morph line style (one which contains both "morph from" and "morph to" line style information
|
|
FMorphLineStyle *startToFinalLine = new FMorphLineStyle(startLineWidth, finalLineWidth,
|
|
startLineColor, finalLineColor);
|
|
return morphLineStyleArray->Add(startToFinalLine);
|
|
}
|
|
|
|
void FDTDefineMorphShape::FinishStyleArrays(void)
|
|
{
|
|
|
|
styleArraysFinished = true;
|
|
nFillBits = FSWFStream::MinBits(morphFillStyleArray->Size(), 0);
|
|
nLineBits = FSWFStream::MinBits(morphLineStyleArray->Size(), 0);
|
|
|
|
shape1.SetFillBits(nFillBits);
|
|
shape1.SetLineBits(nLineBits);
|
|
|
|
// asumption: shape2 will never contain fill or line syle info and this means no need
|
|
// for fill or line style bits
|
|
}
|
|
|
|
void FDTDefineMorphShape::AddShapeRec_1(FShapeRec *_shapeRec)
|
|
{
|
|
|
|
assert(styleArraysFinished);
|
|
shape1.AddShapeRec(_shapeRec);
|
|
}
|
|
|
|
void FDTDefineMorphShape::AddEdgeRec_2(FShapeRec *_shapeRec)
|
|
{
|
|
|
|
assert(styleArraysFinished);
|
|
_shapeRec->IncludeNFillBitInfo(0); // Always Zero
|
|
_shapeRec->IncludeNLineBitInfo(0);
|
|
shape2.AddShapeRec(_shapeRec);
|
|
}
|
|
|
|
U16 FDTDefineMorphShape::ID(void)
|
|
{
|
|
|
|
return characterID;
|
|
}
|
|
|
|
void FDTDefineMorphShape::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
FSWFStream body;
|
|
|
|
body.WriteWord((U32)characterID);
|
|
|
|
shapeBounds_1->WriteToSWFStream(&body);
|
|
|
|
shapeBounds_2->WriteToSWFStream(&body);
|
|
|
|
FSWFStream temp;
|
|
|
|
morphFillStyleArray->WriteToSWFStream(&temp);
|
|
morphLineStyleArray->WriteToSWFStream(&temp);
|
|
|
|
shape1.WriteToSWFStream(&temp);
|
|
|
|
body.WriteDWord(temp.Size());
|
|
|
|
body.Append(&temp);
|
|
|
|
shape2.WriteToSWFStream(&body);
|
|
|
|
_SWFStream->AppendTag(stagDefineMorphShape, body.Size(), &body);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FDTDefineShape ---------------------------------------------------------
|
|
|
|
FDTDefineShape::FDTDefineShape(FRect *_rect)
|
|
{
|
|
|
|
characterID = FObjCollection::Increment();
|
|
shapeBounds = _rect;
|
|
fillStyleArray = new FFillStyleArray();
|
|
lineStyleArray = new FLineStyleArray();
|
|
shapeWithStyle = NULL;
|
|
styleArraysFinished = false;
|
|
}
|
|
|
|
FDTDefineShape::~FDTDefineShape()
|
|
{
|
|
|
|
delete fillStyleArray;
|
|
delete lineStyleArray;
|
|
delete shapeBounds;
|
|
delete shapeWithStyle;
|
|
}
|
|
|
|
void FDTDefineShape::AddShapeRec(FShapeRec *_shapeRec)
|
|
{
|
|
|
|
//you must be done creating the fill style and line style arrays
|
|
//before you can begin adding shape records
|
|
assert(styleArraysFinished);
|
|
|
|
//Change rec doesn't know how many bits for saving the FillStyle0
|
|
//and FillStyle1. It gets this from the ShapeWithStyle which contains
|
|
//it. What happens when the change Rec also contains Fill and Line
|
|
//Syles??? The other types of ShapeRecs just use the "current style"
|
|
//and don't need this info so their methods don't actually do anything.
|
|
//Why not just go to the container when writing?
|
|
_shapeRec->IncludeNFillBitInfo(shapeWithStyle->NumFillBits());
|
|
_shapeRec->IncludeNLineBitInfo(shapeWithStyle->NumLineBits());
|
|
//now have the shapeWithStyle add the ShapeRec
|
|
shapeWithStyle->AddShapeRec(_shapeRec);
|
|
}
|
|
|
|
//This shapes internal fillStyleArray adds a fillStyle to itself.
|
|
U32 FDTDefineShape::AddFillStyle(FFillStyle *fillStyle)
|
|
{
|
|
|
|
assert(!styleArraysFinished); //once complete, cannot change
|
|
return fillStyleArray->Add(fillStyle);
|
|
}
|
|
// here changed.
|
|
U32 FDTDefineShape::AddSolidFillStyle(FColor *fillColor)
|
|
{
|
|
fillColor->AlphaChannel(false);
|
|
FFillStyle *fillStyle = new FFillStyleSolid(fillColor);
|
|
|
|
assert(!styleArraysFinished); //once complete, cannot change
|
|
return fillStyleArray->Add(fillStyle);
|
|
}
|
|
|
|
U32 FDTDefineShape::AddLineStyle(U32 lineWidth, FColor *lineColor)
|
|
{
|
|
|
|
assert(!styleArraysFinished); //once complete, cannot change
|
|
|
|
// here changed.
|
|
lineColor->AlphaChannel(false);
|
|
FLineStyle *lineStyle = new FLineStyle(lineWidth, lineColor);
|
|
|
|
//add line style to rectangle, remembering to store the position of the line style
|
|
//just as in the fill style
|
|
return lineStyleArray->Add(lineStyle);
|
|
}
|
|
|
|
/*! Creates the shape with style. Can only do this once the fill style
|
|
and line style arrays are complete because the shapeWithStyle constructor
|
|
takes in complete fill and line style arrays.
|
|
*/
|
|
void FDTDefineShape::FinishStyleArrays(void)
|
|
{
|
|
|
|
styleArraysFinished = true;
|
|
shapeWithStyle = new FShapeWStyle(fillStyleArray, lineStyleArray);
|
|
fillStyleArray = NULL; /*AMM*/
|
|
lineStyleArray = NULL;
|
|
}
|
|
|
|
U16 FDTDefineShape::ID(void)
|
|
{
|
|
|
|
return characterID;
|
|
}
|
|
|
|
//Called by the FObjCollection when writing to the stream
|
|
//In turn, it calls the WriteToSWFStream methods of its embedded objects.
|
|
|
|
void FDTDefineShape::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
FSWFStream tempBuffer;
|
|
|
|
tempBuffer.WriteWord((U32)characterID);
|
|
shapeBounds->WriteToSWFStream(&tempBuffer);
|
|
shapeWithStyle->WriteToSWFStream(&tempBuffer);
|
|
|
|
_SWFStream->AppendTag(stagDefineShape, tempBuffer.Size(), &tempBuffer);
|
|
}
|
|
|
|
bool FDTDefineShape::IsDefineShape()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FDTDefineShape2 --------------------------------------------------------
|
|
FDTDefineShape2::FDTDefineShape2(FRect *_rect)
|
|
{
|
|
|
|
characterID = FObjCollection::Increment();
|
|
shapeBounds = _rect;
|
|
fillStyleArray = new FFillStyleArray();
|
|
lineStyleArray = new FLineStyleArray();
|
|
shapeWithStyle = NULL;
|
|
styleArraysFinished = false;
|
|
}
|
|
|
|
FDTDefineShape2::~FDTDefineShape2()
|
|
{
|
|
|
|
delete fillStyleArray;
|
|
delete lineStyleArray;
|
|
delete shapeBounds;
|
|
delete shapeWithStyle;
|
|
}
|
|
|
|
void FDTDefineShape2::AddShapeRec(FShapeRec *_shapeRec)
|
|
{
|
|
|
|
//you must be done creating the fill style and line style arrays
|
|
//before you can begin adding shape records
|
|
assert(styleArraysFinished);
|
|
|
|
_shapeRec->IncludeNFillBitInfo(shapeWithStyle->NumFillBits());
|
|
_shapeRec->IncludeNLineBitInfo(shapeWithStyle->NumLineBits());
|
|
shapeWithStyle->AddShapeRec(_shapeRec);
|
|
}
|
|
|
|
U32 FDTDefineShape2::AddFillStyle(FFillStyle *fillStyle)
|
|
{
|
|
|
|
assert(!styleArraysFinished); //once complete, cannot change
|
|
return fillStyleArray->Add(fillStyle);
|
|
}
|
|
// here changed.
|
|
U32 FDTDefineShape2::AddSolidFillStyle(FColor *fillColor)
|
|
{
|
|
fillColor->AlphaChannel(false);
|
|
FFillStyle *fillStyle = new FFillStyleSolid(fillColor);
|
|
|
|
assert(!styleArraysFinished); //once complete, cannot change
|
|
return fillStyleArray->Add(fillStyle);
|
|
}
|
|
|
|
U32 FDTDefineShape2::AddLineStyle(U32 lineWidth, FColor *lineColor)
|
|
{
|
|
|
|
assert(!styleArraysFinished); //once complete, cannot change
|
|
|
|
// here changed.
|
|
lineColor->AlphaChannel(false);
|
|
FLineStyle *lineStyle = new FLineStyle(lineWidth, lineColor);
|
|
|
|
//add line style to rectangle, remembering to store the position of the line style
|
|
//just as in the fill style
|
|
return lineStyleArray->Add(lineStyle);
|
|
}
|
|
|
|
// Creates the shape with style. Can only do this once the fill style
|
|
// and line style arrays are complete because the shapeWithStyle constructor
|
|
// takes in complete fill and line style arrays.
|
|
|
|
void FDTDefineShape2::FinishStyleArrays(void)
|
|
{
|
|
|
|
styleArraysFinished = true;
|
|
shapeWithStyle = new FShapeWStyle(fillStyleArray, lineStyleArray);
|
|
fillStyleArray = NULL; /*AMM*/
|
|
lineStyleArray = NULL;
|
|
}
|
|
|
|
U16 FDTDefineShape2::ID(void)
|
|
{
|
|
|
|
return characterID;
|
|
}
|
|
|
|
bool FDTDefineShape2::IsDefineShape()
|
|
{
|
|
assert(false);
|
|
return true;
|
|
}
|
|
|
|
void FDTDefineShape2::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
FSWFStream body;
|
|
|
|
body.WriteWord((U32)characterID);
|
|
shapeBounds->WriteToSWFStream(&body);
|
|
shapeWithStyle->WriteToSWFStream(&body);
|
|
|
|
_SWFStream->AppendTag(stagDefineShape2, body.Size(), &body);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FDTDefineShape3 --------------------------------------------------------
|
|
|
|
FDTDefineShape3::FDTDefineShape3(FRect *_rect)
|
|
{
|
|
characterID = FObjCollection::Increment();
|
|
shapeBounds = _rect;
|
|
fillStyleArray = new FFillStyleArray();
|
|
lineStyleArray = new FLineStyleArray();
|
|
shapeWithStyle = NULL;
|
|
styleArraysFinished = false;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
FDTDefineShape3::FDTDefineShape3()
|
|
{
|
|
|
|
characterID = FObjCollection::Increment();
|
|
shapeBounds = 0;
|
|
fillStyleArray = new FFillStyleArray();
|
|
lineStyleArray = new FLineStyleArray();
|
|
shapeWithStyle = NULL;
|
|
styleArraysFinished = false;
|
|
}
|
|
|
|
FDTDefineShape3::~FDTDefineShape3()
|
|
{
|
|
|
|
delete fillStyleArray;
|
|
delete lineStyleArray;
|
|
delete shapeBounds;
|
|
delete shapeWithStyle;
|
|
}
|
|
|
|
void FDTDefineShape3::setBounds(FRect *_rect)
|
|
{
|
|
if (shapeBounds)
|
|
delete shapeBounds;
|
|
shapeBounds = _rect;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool FDTDefineShape3::IsDefineShape()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
inline FColor tpixel2fcolor(const TPixel &color)
|
|
{
|
|
return FColor(color.r, color.g, color.b, color.m);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
inline TPixel fcolor2tpixel(FColor &color)
|
|
{
|
|
return TPixel(color.Red(), color.Green(), color.Blue(), color.Alpha());
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void FDTDefineShape3::changeColor(const std::map<TPixel, TPixel> &table)
|
|
{
|
|
unsigned int i;
|
|
if (fillStyleArray)
|
|
for (i = 0; i < fillStyleArray->Size(); i++) {
|
|
FAFillStyle *style = fillStyleArray->get(i);
|
|
if (style->IsSolidStyle()) {
|
|
TPixel oldColor = fcolor2tpixel(*(((FFillStyleSolid *)style)->getColor()));
|
|
std::map<TPixel, TPixel>::const_iterator it = table.find(oldColor);
|
|
if (it != table.end())
|
|
((FFillStyleSolid *)style)->setColor(new FColor(tpixel2fcolor(it->second)));
|
|
}
|
|
}
|
|
|
|
shapeWithStyle->changeColor(table);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void FDTDefineShape3::changeColor(const FColor &oldColor, const FColor &newColor)
|
|
{
|
|
unsigned int i;
|
|
if (fillStyleArray)
|
|
for (i = 0; i < fillStyleArray->Size(); i++) {
|
|
FAFillStyle *style = fillStyleArray->get(i);
|
|
if (style->IsSolidStyle() && (*((FFillStyleSolid *)style)->getColor()) == oldColor)
|
|
((FFillStyleSolid *)style)->setColor(new FColor(newColor));
|
|
}
|
|
|
|
shapeWithStyle->changeColor(oldColor, newColor);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void FDTDefineShape3::AddShapeRec(FShapeRec *_shapeRec)
|
|
{
|
|
|
|
//you must be done creating the fill style and line style arrays
|
|
//before you can begin adding shape records
|
|
assert(styleArraysFinished);
|
|
|
|
_shapeRec->IncludeNFillBitInfo(shapeWithStyle->NumFillBits());
|
|
_shapeRec->IncludeNLineBitInfo(shapeWithStyle->NumLineBits());
|
|
shapeWithStyle->AddShapeRec(_shapeRec);
|
|
}
|
|
|
|
U32 FDTDefineShape3::AddFillStyle(FFillStyle *fillStyle)
|
|
{
|
|
|
|
assert(!styleArraysFinished); //once complete, cannot change
|
|
return fillStyleArray->Add(fillStyle);
|
|
}
|
|
|
|
// here changed.
|
|
U32 FDTDefineShape3::AddSolidFillStyle(FColor *fillColor)
|
|
{
|
|
fillColor->AlphaChannel(true);
|
|
FFillStyle *fillStyle = new FFillStyleSolid(fillColor);
|
|
|
|
assert(!styleArraysFinished); //once complete, cannot change
|
|
return fillStyleArray->Add(fillStyle);
|
|
}
|
|
|
|
U32 FDTDefineShape3::AddLineStyle(U32 lineWidth, FColor *lineColor)
|
|
{
|
|
|
|
assert(!styleArraysFinished); //once complete, cannot change
|
|
|
|
// here changed.
|
|
lineColor->AlphaChannel(true);
|
|
FLineStyle *lineStyle = new FLineStyle(lineWidth, lineColor);
|
|
|
|
//add line style to rectangle, remembering to store the position of the line style
|
|
//just as in the fill style
|
|
return lineStyleArray->Add(lineStyle);
|
|
}
|
|
|
|
// Creates the shape with style. Can only do this once the fill style
|
|
// and line style arrays are complete because the shapeWithStyle constructor
|
|
// takes in complete fill and line style arrays.
|
|
|
|
void FDTDefineShape3::FinishStyleArrays(void)
|
|
{
|
|
|
|
styleArraysFinished = true;
|
|
shapeWithStyle = new FShapeWStyle(fillStyleArray, lineStyleArray);
|
|
fillStyleArray = NULL;
|
|
lineStyleArray = NULL;
|
|
}
|
|
|
|
U16 FDTDefineShape3::ID(void)
|
|
{
|
|
|
|
return characterID;
|
|
}
|
|
|
|
void FDTDefineShape3::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
FSWFStream body;
|
|
|
|
body.WriteWord((U32)characterID);
|
|
shapeBounds->WriteToSWFStream(&body);
|
|
shapeWithStyle->WriteToSWFStream(&body);
|
|
|
|
_SWFStream->AppendTag(stagDefineShape3, body.Size(), &body);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FFillStyleArray --------------------------------------------------------
|
|
|
|
FFillStyleArray::~FFillStyleArray()
|
|
{
|
|
while (!fillStyleArray.empty()) {
|
|
delete fillStyleArray.back();
|
|
fillStyleArray.pop_back();
|
|
}
|
|
}
|
|
|
|
// Returns the size of the fill style list.
|
|
U32 FFillStyleArray::Size(void)
|
|
{
|
|
return (U32)fillStyleArray.size();
|
|
}
|
|
|
|
// The given fill style is added to the end of the fill style array. The position of
|
|
// the added fill style is returned so that the fill style can later be referenced.
|
|
|
|
U32 FFillStyleArray::Add(FAFillStyle *fillStyle)
|
|
{
|
|
FLASHASSERT(fillStyle);
|
|
|
|
fillStyleArray.push_back(fillStyle);
|
|
return ((U32)fillStyleArray.size());
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
FAFillStyle *FFillStyleArray::get(unsigned int index)
|
|
{
|
|
return fillStyleArray[index];
|
|
}
|
|
|
|
// Writes to the stream by travelling through all of the nodes in the array and writing
|
|
// their fill styles. First has to write the count of fill style arrays. See's if count
|
|
// is small enough to fit in to an 8 bit field, and either writes the count into an 8 bit
|
|
// field, or writes all 1's into an 8 bit field and writes the real count into a 16 bit
|
|
// field.
|
|
|
|
void FFillStyleArray::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
|
|
//write the size
|
|
U32 size = fillStyleArray.size();
|
|
|
|
if (size >= 0xff) {
|
|
|
|
_SWFStream->WriteByte(0xff);
|
|
_SWFStream->WriteWord(size);
|
|
|
|
} else {
|
|
|
|
_SWFStream->WriteByte(size);
|
|
}
|
|
|
|
//write the fill styles
|
|
std::vector<FAFillStyle *>::iterator cursor;
|
|
|
|
for (cursor = fillStyleArray.begin(); cursor != fillStyleArray.end(); cursor++) {
|
|
(*cursor)->WriteToSWFStream(_SWFStream);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FFillStyleBitmap -------------------------------------------------------
|
|
|
|
// The tiledFlag indicates if the Bitmap fill style is tiled (tiledFlag==1) or
|
|
// clipped (tiledFlag==0).
|
|
FFillStyleBitmap::FFillStyleBitmap(int tiled, U16 ID, FMatrix *matrix)
|
|
{
|
|
|
|
tiledFlag = tiled;
|
|
bitmapID = ID;
|
|
bitmapMatrix = matrix;
|
|
}
|
|
|
|
// Deletes the matrix.
|
|
|
|
FFillStyleBitmap::~FFillStyleBitmap(void)
|
|
{
|
|
|
|
delete bitmapMatrix;
|
|
bitmapMatrix = NULL;
|
|
}
|
|
|
|
// Writes the bitmap fill style to the given FSWFStream.
|
|
|
|
void FFillStyleBitmap::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
|
|
//write the type
|
|
if (tiledFlag)
|
|
_SWFStream->WriteByte(fillTiledBits);
|
|
else
|
|
_SWFStream->WriteByte(fillClippedBits);
|
|
|
|
//write the bitmap id
|
|
_SWFStream->WriteWord(bitmapID);
|
|
|
|
//write the matrix
|
|
bitmapMatrix->WriteToSWFStream(_SWFStream);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FFillStyleGradient -----------------------------------------------------
|
|
|
|
// The linearFlag indicates if the gradient fill style is linear (linearFlag==1) or
|
|
// radial (linearFlag==0).
|
|
FFillStyleGradient::FFillStyleGradient(int linear, FMatrix *matrix, FGradient *gradient)
|
|
{
|
|
linearFlag = linear;
|
|
gradFillMatrix = matrix;
|
|
gradFill = gradient;
|
|
}
|
|
|
|
// Deletes the matrix and gradient.
|
|
|
|
FFillStyleGradient::~FFillStyleGradient(void)
|
|
{
|
|
delete gradFillMatrix;
|
|
delete gradFill;
|
|
}
|
|
|
|
// Writes the Gradient fill style to the given FSWFStream.
|
|
|
|
void FFillStyleGradient::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
//write the type
|
|
if (linearFlag)
|
|
_SWFStream->WriteByte(fillLinearGradient);
|
|
else
|
|
_SWFStream->WriteByte(fillRadialGradient);
|
|
|
|
//write the matrix
|
|
gradFillMatrix->WriteToSWFStream(_SWFStream);
|
|
|
|
//write the gradient
|
|
gradFill->WriteToSWFStream(_SWFStream);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FFillStyleSolid --------------------------------------------------------
|
|
|
|
// Stores the color of the solid fill style.
|
|
FFillStyleSolid::FFillStyleSolid(FColor *_color) : color(_color) {}
|
|
|
|
FFillStyleSolid::~FFillStyleSolid()
|
|
{
|
|
delete color;
|
|
}
|
|
|
|
// Writes the solid fill style to the given FSWFStream.
|
|
|
|
void FFillStyleSolid::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
|
|
//write the type
|
|
_SWFStream->WriteByte(fillSolid); //cast to U32?
|
|
|
|
//write the color
|
|
color->WriteToSWFStream(_SWFStream); //, FColor::WRITE_SMALLEST ); changed here.
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FGradient --------------------------------------------------------------
|
|
|
|
// Constructor. The grad record list is automatically constructed.
|
|
FGradient::FGradient(void) {}
|
|
|
|
// Removes and deletes all the grad records from the grad record list.
|
|
|
|
FGradient::~FGradient(void)
|
|
{
|
|
|
|
while (!gradRecords.empty()) {
|
|
|
|
delete gradRecords.front();
|
|
|
|
gradRecords.pop_front();
|
|
}
|
|
}
|
|
|
|
// Adds the given grad record to the end of the grad record list.
|
|
|
|
void FGradient::Add(FAGradRecord *gradRec)
|
|
{
|
|
|
|
gradRecords.push_back(gradRec);
|
|
}
|
|
|
|
// Writes the grad records to the given _SWFStream.
|
|
|
|
void FGradient::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
|
|
//write the size
|
|
|
|
_SWFStream->WriteByte((U32)gradRecords.size());
|
|
|
|
//write the grad records
|
|
|
|
std::list<FAGradRecord *>::iterator cursor;
|
|
|
|
for (cursor = gradRecords.begin(); cursor != gradRecords.end(); cursor++) {
|
|
|
|
(*cursor)->WriteToSWFStream(_SWFStream);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FGradientRecord --------------------------------------------------------
|
|
|
|
// FGradRecord class constructor.
|
|
FGradRecord::FGradRecord(U32 _ratio, FColor *_color)
|
|
{
|
|
color = _color;
|
|
ratio = _ratio;
|
|
}
|
|
|
|
FGradRecord::~FGradRecord()
|
|
{
|
|
delete color;
|
|
}
|
|
|
|
// Writes the grad record to the given buffer.
|
|
|
|
void FGradRecord::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
|
|
_SWFStream->WriteByte((U32)ratio);
|
|
|
|
color->WriteToSWFStream(_SWFStream); //, FColor::WRITE_SMALLEST ); changed here.
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FLineStyle -------------------------------------------------------------
|
|
|
|
// LineStyle class constructor.
|
|
FLineStyle::FLineStyle(U32 _width, FColor *_color)
|
|
{
|
|
color = _color;
|
|
width = _width; //in TWIPS
|
|
}
|
|
|
|
FLineStyle::~FLineStyle()
|
|
{
|
|
delete color;
|
|
}
|
|
|
|
// Writes the object to the given _SWFStream.
|
|
|
|
void FLineStyle::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
|
|
_SWFStream->WriteWord(width);
|
|
color->WriteToSWFStream(_SWFStream); //, FColor::WRITE_SMALLEST ); changed here.
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FLineStyleArray --------------------------------------------------------
|
|
|
|
// The line style array is automatically constructed
|
|
FLineStyleArray::FLineStyleArray(void) {}
|
|
|
|
// Removes and deletes every element in the list.
|
|
|
|
FLineStyleArray::~FLineStyleArray(void)
|
|
{
|
|
|
|
while (!lineStyleArray.empty()) {
|
|
|
|
delete lineStyleArray.front();
|
|
lineStyleArray.pop_front();
|
|
}
|
|
}
|
|
|
|
// Returns the size of the line style list.
|
|
|
|
U32 FLineStyleArray::Size(void)
|
|
{
|
|
|
|
return (U32)lineStyleArray.size();
|
|
}
|
|
|
|
// The given line style is added to the end of the line style array. The position of
|
|
// the added line style is returned so that the line style can later be referenced.
|
|
|
|
U32 FLineStyleArray::Add(FALineStyle *lineStyle)
|
|
{
|
|
|
|
lineStyleArray.push_back(lineStyle);
|
|
return ((U32)lineStyleArray.size());
|
|
}
|
|
|
|
// Writes to the stream by travelling through all of the nodes in the array and writing
|
|
// their line styles. First has to write the count of line style arrays. See's if count
|
|
// is small enough to fit in to an 8 bit field, and either writes the count into an 8 bit
|
|
// field, or writes all 1's into an 8 bit field and writes the real count into a 16 bit
|
|
// field.
|
|
|
|
void FLineStyleArray::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
|
|
//write the size
|
|
U32 size = lineStyleArray.size();
|
|
|
|
if (size >= 0xff) {
|
|
|
|
_SWFStream->WriteByte(0xff);
|
|
_SWFStream->WriteWord(size);
|
|
|
|
} else {
|
|
|
|
_SWFStream->WriteByte(size);
|
|
}
|
|
|
|
//write the line styles
|
|
std::list<FALineStyle *>::iterator cursor;
|
|
|
|
for (cursor = lineStyleArray.begin(); cursor != lineStyleArray.end(); cursor++) {
|
|
|
|
(*cursor)->WriteToSWFStream(_SWFStream);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FMorphFillStyleBitmap --------------------------------------------------
|
|
|
|
// The tiledFlag indicates if the Bitmap fill style is tiled (tiledFlag==1) or
|
|
// clipped (tiledFlag==0).
|
|
FMorphFillStyleBitmap::FMorphFillStyleBitmap(int tiled, U16 ID,
|
|
FMatrix *matrix1, FMatrix *matrix2)
|
|
{
|
|
|
|
tiledFlag = tiled;
|
|
bitmapID = ID;
|
|
bitmapMatrix1 = matrix1;
|
|
bitmapMatrix2 = matrix2;
|
|
}
|
|
|
|
// Deletes the matrices.
|
|
|
|
FMorphFillStyleBitmap::~FMorphFillStyleBitmap(void)
|
|
{
|
|
|
|
delete bitmapMatrix1;
|
|
bitmapMatrix1 = NULL;
|
|
|
|
delete bitmapMatrix2;
|
|
bitmapMatrix2 = NULL;
|
|
}
|
|
|
|
// Writes the bitmap fill style to the given FSWFStream.
|
|
|
|
void FMorphFillStyleBitmap::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
|
|
//write the type
|
|
if (tiledFlag)
|
|
_SWFStream->WriteByte(fillTiledBits);
|
|
else
|
|
_SWFStream->WriteByte(fillClippedBits);
|
|
|
|
//write the bitmap id
|
|
_SWFStream->WriteWord(bitmapID);
|
|
|
|
//write the matrices
|
|
bitmapMatrix1->WriteToSWFStream(_SWFStream);
|
|
bitmapMatrix2->WriteToSWFStream(_SWFStream);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FMorphFillStyleGradient ------------------------------------------------
|
|
|
|
// The linearFlag indicates if the gradient fill style is linear (linearFlag==1) or
|
|
// radial (linearFlag==0).
|
|
FMorphFillStyleGradient::FMorphFillStyleGradient(int linear, FMatrix *matrix1, FMatrix *matrix2,
|
|
FGradient *gradient)
|
|
{
|
|
|
|
linearFlag = linear;
|
|
gradFillMatrix1 = matrix1;
|
|
gradFillMatrix2 = matrix2;
|
|
gradFill = gradient;
|
|
}
|
|
|
|
// Deletes the matrices and gradient.
|
|
|
|
FMorphFillStyleGradient::~FMorphFillStyleGradient(void)
|
|
{
|
|
|
|
delete gradFillMatrix1;
|
|
gradFillMatrix1 = NULL;
|
|
delete gradFillMatrix2;
|
|
gradFillMatrix2 = NULL;
|
|
delete gradFill;
|
|
gradFill = NULL;
|
|
}
|
|
|
|
// Writes the Gradient fill style to the given FSWFStream.
|
|
|
|
void FMorphFillStyleGradient::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
|
|
//write the type
|
|
if (linearFlag)
|
|
_SWFStream->WriteByte(fillLinearGradient);
|
|
else
|
|
_SWFStream->WriteByte(fillRadialGradient);
|
|
|
|
//write the matrices
|
|
gradFillMatrix1->WriteToSWFStream(_SWFStream);
|
|
gradFillMatrix2->WriteToSWFStream(_SWFStream);
|
|
|
|
//write the gradient
|
|
gradFill->WriteToSWFStream(_SWFStream);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FMorphFillStyleSolid ---------------------------------------------------
|
|
|
|
// Stores the colors of the solid fill style.
|
|
FMorphFillStyleSolid::FMorphFillStyleSolid(FColor *_color1, FColor *_color2)
|
|
{
|
|
color1 = _color1;
|
|
color2 = _color2;
|
|
}
|
|
|
|
FMorphFillStyleSolid::~FMorphFillStyleSolid()
|
|
{
|
|
delete color1;
|
|
delete color2;
|
|
}
|
|
|
|
// Writes the solid fill style to the given FSWFStream.
|
|
|
|
void FMorphFillStyleSolid::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
|
|
//write the type
|
|
_SWFStream->WriteByte(fillSolid); //cast to U32?
|
|
|
|
//write the colors
|
|
color1->WriteToSWFStream(_SWFStream); //, FColor::WRITE_SMALLEST ); changed here.
|
|
color2->WriteToSWFStream(_SWFStream); //, FColor::WRITE_SMALLEST ); changed here.
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FMorphGradRecord -------------------------------------------------------
|
|
|
|
// Constructor.
|
|
FMorphGradRecord::FMorphGradRecord(U32 _ratio1, FColor *_color1, U32 _ratio2, FColor *_color2)
|
|
{
|
|
|
|
ratio1 = _ratio1;
|
|
ratio2 = _ratio2;
|
|
|
|
color1 = _color1;
|
|
color2 = _color2;
|
|
}
|
|
|
|
FMorphGradRecord::~FMorphGradRecord()
|
|
{
|
|
delete color1;
|
|
delete color2;
|
|
}
|
|
|
|
// Writes to the given _SWFStream.
|
|
|
|
void FMorphGradRecord::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
|
|
_SWFStream->WriteByte((U32)ratio1);
|
|
color1->WriteToSWFStream(_SWFStream); //, FColor::WRITE_SMALLEST ); changed here.
|
|
|
|
_SWFStream->WriteByte((U32)ratio2);
|
|
color2->WriteToSWFStream(_SWFStream); //, FColor::WRITE_SMALLEST ); changed here.
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FMorphLineStyle --------------------------------------------------------
|
|
|
|
//The line style used by morph shapes
|
|
FMorphLineStyle::FMorphLineStyle(U32 _width1, U32 _width2, FColor *_color1,
|
|
FColor *_color2) : color1(_color1), color2(_color2)
|
|
{
|
|
width1 = _width1;
|
|
width2 = _width2;
|
|
|
|
color1 = _color1;
|
|
color2 = _color2;
|
|
}
|
|
|
|
FMorphLineStyle::~FMorphLineStyle()
|
|
{
|
|
delete color1;
|
|
delete color2;
|
|
}
|
|
|
|
// Writes to the given _SWFStream.
|
|
|
|
void FMorphLineStyle::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
//write the widths
|
|
_SWFStream->WriteWord(width1);
|
|
_SWFStream->WriteWord(width2);
|
|
|
|
//write the colors
|
|
color1->WriteToSWFStream(_SWFStream); //, FColor::WRITE_SMALLEST ); changed here.
|
|
color2->WriteToSWFStream(_SWFStream); //, FColor::WRITE_SMALLEST ); changed here.
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FShape -----------------------------------------------------------------
|
|
|
|
// Shape class constructor. The shape record list is automatically constructed
|
|
FShape::FShape(void)
|
|
{
|
|
|
|
nFillBits = 0;
|
|
nLineBits = 0;
|
|
}
|
|
|
|
// Removes and deletes every element in the list.
|
|
|
|
FShape::~FShape(void)
|
|
{
|
|
|
|
while (!shapeRecs.empty()) {
|
|
|
|
delete shapeRecs.back();
|
|
shapeRecs.pop_back();
|
|
}
|
|
}
|
|
|
|
// Sets the nFillBits field.
|
|
|
|
void FShape::SetFillBits(U32 _nFillBits)
|
|
{
|
|
|
|
nFillBits = _nFillBits;
|
|
}
|
|
|
|
// Sets the nLineBits field.
|
|
|
|
void FShape::SetLineBits(U32 _nLineBits)
|
|
{
|
|
|
|
nLineBits = _nLineBits;
|
|
}
|
|
|
|
// Adds a shape record to the end of the shape record list.
|
|
|
|
void FShape::AddShapeRec(FShapeRec *shapeRec)
|
|
{
|
|
|
|
shapeRecs.push_back(shapeRec);
|
|
}
|
|
|
|
// Writes the object to the given buffer.
|
|
|
|
void FShape::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
|
|
_SWFStream->WriteBits(nFillBits, 4);
|
|
_SWFStream->WriteBits(nLineBits, 4);
|
|
|
|
std::vector<FShapeRec *>::iterator cursor;
|
|
|
|
for (cursor = shapeRecs.begin(); cursor != shapeRecs.end(); cursor++) {
|
|
//the shape rec might be referring to a fillor line style arry
|
|
//external (ShapesWStyle) and will need the # of fillBits.
|
|
(*cursor)->IncludeNFillBitInfo(nFillBits); //enter fillbits
|
|
(*cursor)->IncludeNLineBitInfo(nLineBits); //enter linebits
|
|
(*cursor)->WriteToSWFStream(_SWFStream);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FShapeRecChange --------------------------------------------------------
|
|
|
|
// FShapeRecChange class constructor. It is passed the nFillBits and nLineBits values.
|
|
FShapeRecChange::FShapeRecChange(U32 _stateNewStyles,
|
|
U32 _stateLineStyle,
|
|
U32 _stateFillStyle1,
|
|
U32 _stateFillStyle0,
|
|
U32 _stateMoveTo,
|
|
S32 _moveDeltaX,
|
|
S32 _moveDeltaY,
|
|
U32 _fill0Style,
|
|
U32 _fill1Style,
|
|
U32 _lineStyle,
|
|
FFillStyleArray *_fillStyles,
|
|
FLineStyleArray *_lineStyles)
|
|
{
|
|
stateNewStyles = _stateNewStyles;
|
|
stateLineStyle = _stateLineStyle;
|
|
stateFillStyle1 = _stateFillStyle1;
|
|
stateFillStyle0 = _stateFillStyle0;
|
|
stateMoveTo = _stateMoveTo;
|
|
|
|
moveDeltaX = _moveDeltaX;
|
|
moveDeltaY = _moveDeltaY;
|
|
fill0Style = _fill0Style;
|
|
fill1Style = _fill1Style;
|
|
lineStyle = _lineStyle;
|
|
fillStyles = _fillStyles;
|
|
lineStyles = _lineStyles;
|
|
nMoveBits = MinBits();
|
|
}
|
|
|
|
FFillStyleArray *FShapeRecChange::GetFillStyles()
|
|
{
|
|
return fillStyles;
|
|
}
|
|
|
|
// Deletes fillStyles and lineStyles if they exist.
|
|
|
|
FShapeRecChange::~FShapeRecChange(void)
|
|
{
|
|
|
|
if (fillStyles) { //if fillStyles isn't NULL
|
|
|
|
delete fillStyles;
|
|
fillStyles = NULL;
|
|
}
|
|
|
|
if (lineStyles) { //if lineStyles isn't NULL
|
|
|
|
delete lineStyles;
|
|
lineStyles = NULL;
|
|
}
|
|
}
|
|
|
|
//!Change Rec needs to know how many bits to write for the Fill and Line Styles
|
|
/*!Change Rec doesn't actually store the nLineBits or nFillBits, but needs to know
|
|
them when it writes the active style fields so that it knows how many bits
|
|
to write
|
|
\param _nFillBits the size in bits of the index into the FillStyleArray
|
|
*/
|
|
void FShapeRecChange::IncludeNFillBitInfo(U32 _nFillBits)
|
|
{
|
|
|
|
nFillBits = _nFillBits;
|
|
}
|
|
|
|
//!Change Rec needs to know how many bits to write for the Fill and Line Styles
|
|
/*!Change Rec doesn't actually store the nLineBits or nFillBits, but needs to know
|
|
them when it writes the active style fields so that it knows how many bits
|
|
to write
|
|
\param _nLineBits the size in bits of the index into the LineStyleArray
|
|
*/
|
|
void FShapeRecChange::IncludeNLineBitInfo(U32 _nLineBits)
|
|
{
|
|
|
|
nLineBits = _nLineBits;
|
|
}
|
|
|
|
// Calculates nMoveBits by returning the number of bits needed to store the larger of
|
|
// moveDeltaX and moveDeltaY.
|
|
|
|
U32 FShapeRecChange::MinBits(void)
|
|
{
|
|
|
|
U32 max = FSWFStream::MaxNum(moveDeltaX, moveDeltaY, 0, 0);
|
|
return FSWFStream::MinBits(max, 1);
|
|
}
|
|
|
|
// Writes the shape record to the given _SWFStream.
|
|
|
|
void FShapeRecChange::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
|
|
//non-edge record flag
|
|
_SWFStream->WriteBits(NOT_EDGE_REC, 1);
|
|
|
|
_SWFStream->WriteBits(stateNewStyles, 1);
|
|
_SWFStream->WriteBits(stateLineStyle, 1);
|
|
_SWFStream->WriteBits(stateFillStyle1, 1);
|
|
_SWFStream->WriteBits(stateFillStyle0, 1);
|
|
_SWFStream->WriteBits(stateMoveTo, 1);
|
|
|
|
if (stateMoveTo) {
|
|
|
|
_SWFStream->WriteBits(nMoveBits, 5);
|
|
_SWFStream->WriteBits(moveDeltaX, nMoveBits);
|
|
_SWFStream->WriteBits(moveDeltaY, nMoveBits);
|
|
}
|
|
|
|
if (stateFillStyle0) {
|
|
|
|
_SWFStream->WriteBits(fill0Style, nFillBits);
|
|
}
|
|
|
|
if (stateFillStyle1) {
|
|
|
|
_SWFStream->WriteBits(fill1Style, nFillBits);
|
|
}
|
|
|
|
if (stateLineStyle) {
|
|
|
|
_SWFStream->WriteBits(lineStyle, nLineBits);
|
|
}
|
|
|
|
if (stateNewStyles) {
|
|
|
|
fillStyles->WriteToSWFStream(_SWFStream);
|
|
lineStyles->WriteToSWFStream(_SWFStream);
|
|
|
|
nFillBits = FSWFStream::MinBits(fillStyles->Size(), 0);
|
|
nLineBits = FSWFStream::MinBits(lineStyles->Size(), 0);
|
|
|
|
_SWFStream->WriteBits(nFillBits, 4); //li mortacci loro!!! "dimenticavano" di mettere questi...
|
|
_SWFStream->WriteBits(nLineBits, 4);
|
|
}
|
|
|
|
//NO FILLING IN BETWEEN SHAPE RECORDS
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FShapeRecEdgeStraight --------------------------------------------------
|
|
|
|
FShapeRecEdgeStraight::FShapeRecEdgeStraight(S32 dx, S32 dy)
|
|
{
|
|
generalLineFlag = 0;
|
|
generalDeltaX = 0;
|
|
generalDeltaY = 0;
|
|
verticalLineFlag = 0;
|
|
horizontalDeltaX = 0;
|
|
verticalDeltaY = 0;
|
|
|
|
edgeFlag = 1;
|
|
|
|
// is this a general line?
|
|
if (dx != 0 && dy != 0) {
|
|
generalLineFlag = true;
|
|
generalDeltaX = dx;
|
|
generalDeltaY = dy;
|
|
} else if (dx == 0) // not general, is it vertical?
|
|
{
|
|
verticalLineFlag = true;
|
|
verticalDeltaY = dy;
|
|
} else {
|
|
verticalLineFlag = false;
|
|
horizontalDeltaX = dx;
|
|
}
|
|
nBits = MinBits();
|
|
assert(nBits < 16 + 2); //vincenzo: se no non entra nei quattro bits riservati per scrivere questo valore...
|
|
}
|
|
|
|
U32 FShapeRecEdgeStraight::MinBits(void)
|
|
{
|
|
|
|
U32 maxDelta = FSWFStream::MaxNum(generalDeltaX, generalDeltaY,
|
|
horizontalDeltaX, verticalDeltaY);
|
|
|
|
return FSWFStream::MinBits(maxDelta, 1);
|
|
}
|
|
|
|
void FShapeRecEdgeStraight::IncludeNFillBitInfo(U32 /*_nFillBits*/)
|
|
{
|
|
}
|
|
|
|
void FShapeRecEdgeStraight::IncludeNLineBitInfo(U32 /*_nLineBits*/)
|
|
{
|
|
}
|
|
|
|
void FShapeRecEdgeStraight::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
//edge record flag
|
|
_SWFStream->WriteBits(EDGE_REC, 1);
|
|
|
|
_SWFStream->WriteBits(STRAIGHT_EDGE, 1); //This is a Straight edge record
|
|
_SWFStream->WriteBits(nBits - 2, 4);
|
|
_SWFStream->WriteBits(generalLineFlag, 1);
|
|
|
|
if (generalLineFlag) {
|
|
|
|
_SWFStream->WriteBits((U32)generalDeltaX, nBits);
|
|
_SWFStream->WriteBits((U32)generalDeltaY, nBits);
|
|
|
|
} else {
|
|
|
|
_SWFStream->WriteBits(verticalLineFlag, 1); //verticalFlag is supposed to be signed but don't think it matters
|
|
|
|
if (!verticalLineFlag)
|
|
_SWFStream->WriteBits((U32)horizontalDeltaX, nBits);
|
|
|
|
else
|
|
_SWFStream->WriteBits((U32)verticalDeltaY, nBits);
|
|
}
|
|
|
|
//NO FILLING IN BETWEEN SHAPE RECORDS
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FShapeRecEdgeCurved ---------------------------------------------------
|
|
|
|
// FShapeRecEdge class constructor.
|
|
FShapeRecEdgeCurved::FShapeRecEdgeCurved(S32 controlDX, S32 controlDY, S32 anchorDX, S32 anchorDY)
|
|
{
|
|
edgeFlag = 0;
|
|
|
|
controlDeltaX = controlDX;
|
|
controlDeltaY = controlDY;
|
|
anchorDeltaX = anchorDX;
|
|
anchorDeltaY = anchorDY;
|
|
|
|
nBits = MinBits();
|
|
}
|
|
// Finds the min bits necessary to represent the 4 fields, by seeing how many bits are
|
|
// necessary to represent the largest field of the four.
|
|
|
|
U32 FShapeRecEdgeCurved::MinBits(void)
|
|
{
|
|
|
|
U32 maxDelta = FSWFStream::MaxNum(controlDeltaX, controlDeltaY, anchorDeltaX, anchorDeltaY);
|
|
|
|
return FSWFStream::MinBits(maxDelta, 1);
|
|
}
|
|
|
|
void FShapeRecEdgeCurved::IncludeNFillBitInfo(U32 /*_nFillBits*/)
|
|
{
|
|
}
|
|
|
|
void FShapeRecEdgeCurved::IncludeNLineBitInfo(U32 /*_nLineBits*/)
|
|
{
|
|
}
|
|
|
|
// Writes the shape record to the given _SWFStream.
|
|
|
|
void FShapeRecEdgeCurved::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
//edge record flag
|
|
_SWFStream->WriteBits(EDGE_REC, 1);
|
|
|
|
_SWFStream->WriteBits(CURVED_EDGE, 1); //This is a curved edge record
|
|
|
|
_SWFStream->WriteBits(nBits - 2, 4);
|
|
|
|
_SWFStream->WriteBits((U32)controlDeltaX, nBits);
|
|
_SWFStream->WriteBits((U32)controlDeltaY, nBits);
|
|
_SWFStream->WriteBits((U32)anchorDeltaX, nBits);
|
|
_SWFStream->WriteBits((U32)anchorDeltaY, nBits);
|
|
|
|
//NO FILLING IN BETWEEN SHAPE RECORDS
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FShapeRecEnd ----------------------------------------------------------
|
|
|
|
// ShapeRecEnd class constructor. Doesn't take in anything because the
|
|
// object serves as an end tag and has no details.
|
|
FShapeRecEnd::FShapeRecEnd(void) {}
|
|
|
|
void FShapeRecEnd::IncludeNFillBitInfo(U32 /*_nFillBits*/)
|
|
{
|
|
// does nothing
|
|
//virtual method needed for shape rec change
|
|
}
|
|
|
|
void FShapeRecEnd::IncludeNLineBitInfo(U32 /*_nLineBits*/)
|
|
{
|
|
//same deal
|
|
}
|
|
|
|
// Writes the object to the given buffer.
|
|
|
|
void FShapeRecEnd::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
|
|
//stream of 0's signifies the end
|
|
_SWFStream->WriteBits(0, 6);
|
|
|
|
//need to fill to end shape rec array structure.
|
|
_SWFStream->FlushBits();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// -------- FShapeWStyle ----------------------------------------------------------
|
|
|
|
// FShapeWStyle class constructor. The shape record list is automatically constructed.
|
|
FShapeWStyle::FShapeWStyle(FFillStyleArray *_fillStyles, FLineStyleArray *_lineStyles)
|
|
{
|
|
|
|
fillStyles = _fillStyles;
|
|
lineStyles = _lineStyles;
|
|
|
|
nFillBits = FSWFStream::MinBits(fillStyles->Size(), 0);
|
|
nLineBits = FSWFStream::MinBits(lineStyles->Size(), 0);
|
|
}
|
|
|
|
// Deleted the fill style array, line style array, and shape records.
|
|
|
|
FShapeWStyle::~FShapeWStyle(void)
|
|
{
|
|
|
|
delete fillStyles;
|
|
fillStyles = NULL;
|
|
|
|
delete lineStyles;
|
|
lineStyles = NULL;
|
|
|
|
while (!shapeRecs.empty()) {
|
|
|
|
delete shapeRecs.back();
|
|
shapeRecs.pop_back();
|
|
}
|
|
}
|
|
|
|
// Adds a shape record to the end of the shape record list.
|
|
|
|
void FShapeWStyle::AddShapeRec(FShapeRec *shapeRec)
|
|
{
|
|
|
|
shapeRecs.push_back(shapeRec);
|
|
}
|
|
|
|
U32 FShapeWStyle::NumFillBits()
|
|
{
|
|
|
|
return nFillBits;
|
|
}
|
|
|
|
U32 FShapeWStyle::NumLineBits()
|
|
{
|
|
|
|
return nLineBits;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
void FShapeWStyle::changeColor(const std::map<TPixel, TPixel> &table)
|
|
{
|
|
unsigned int i, j;
|
|
if (fillStyles)
|
|
for (i = 0; i < fillStyles->Size(); i++) {
|
|
FAFillStyle *style = fillStyles->get(i);
|
|
//FColor* color = ((FFillStyleSolid*)style)->getColor();
|
|
if (style->IsSolidStyle()) {
|
|
TPixel oldColor = fcolor2tpixel(*(((FFillStyleSolid *)style)->getColor()));
|
|
std::map<TPixel, TPixel>::const_iterator it = table.find(oldColor);
|
|
if (it != table.end())
|
|
((FFillStyleSolid *)style)->setColor(new FColor(tpixel2fcolor(it->second)));
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < shapeRecs.size(); i++) {
|
|
FShapeRec *rec = shapeRecs[i];
|
|
if (rec->isFShapeRecChange() && ((FShapeRecChange *)rec)->GetFillStyles())
|
|
for (j = 0; j < ((FShapeRecChange *)rec)->GetFillStyles()->Size(); j++) {
|
|
FAFillStyle *style = ((FShapeRecChange *)rec)->GetFillStyles()->get(j);
|
|
//FColor* color = ((FFillStyleSolid*)style)->getColor();
|
|
if (style->IsSolidStyle()) {
|
|
TPixel oldColor = fcolor2tpixel(*(((FFillStyleSolid *)style)->getColor()));
|
|
std::map<TPixel, TPixel>::const_iterator it = table.find(oldColor);
|
|
if (it != table.end())
|
|
((FFillStyleSolid *)style)->setColor(new FColor(tpixel2fcolor(it->second)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
void FShapeWStyle::changeColor(const FColor &oldColor, const FColor &newColor)
|
|
{
|
|
unsigned int i, j;
|
|
if (fillStyles)
|
|
for (i = 0; i < fillStyles->Size(); i++) {
|
|
FAFillStyle *style = fillStyles->get(i);
|
|
FColor *color = ((FFillStyleSolid *)style)->getColor();
|
|
if (style->IsSolidStyle() && *color == oldColor)
|
|
((FFillStyleSolid *)style)->setColor(new FColor(newColor));
|
|
color = ((FFillStyleSolid *)style)->getColor();
|
|
}
|
|
|
|
for (i = 0; i < shapeRecs.size(); i++) {
|
|
FShapeRec *rec = shapeRecs[i];
|
|
if (rec->isFShapeRecChange() && ((FShapeRecChange *)rec)->GetFillStyles())
|
|
for (j = 0; j < ((FShapeRecChange *)rec)->GetFillStyles()->Size(); j++) {
|
|
FAFillStyle *style = ((FShapeRecChange *)rec)->GetFillStyles()->get(j);
|
|
FColor *color = ((FFillStyleSolid *)style)->getColor();
|
|
if (style->IsSolidStyle() && *color == oldColor)
|
|
((FFillStyleSolid *)style)->setColor(new FColor(newColor));
|
|
color = ((FFillStyleSolid *)style)->getColor();
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
// Writes the shape with style to the given _SWFStream.
|
|
|
|
void FShapeWStyle::WriteToSWFStream(FSWFStream *_SWFStream)
|
|
{
|
|
|
|
fillStyles->WriteToSWFStream(_SWFStream);
|
|
lineStyles->WriteToSWFStream(_SWFStream);
|
|
|
|
_SWFStream->WriteBits(nFillBits, 4);
|
|
_SWFStream->WriteBits(nLineBits, 4);
|
|
|
|
//write the shape records
|
|
std::vector<FShapeRec *>::iterator cursor;
|
|
|
|
for (cursor = shapeRecs.begin(); cursor != shapeRecs.end(); cursor++) {
|
|
(*cursor)->IncludeNFillBitInfo(nFillBits); //vincenzo
|
|
(*cursor)->IncludeNLineBitInfo(nLineBits); //vincenzo
|
|
|
|
(*cursor)->WriteToSWFStream(_SWFStream);
|
|
if ((*cursor)->isFShapeRecChange()) //vincenzo
|
|
((FShapeRecChange *)(*cursor))->getFillLineBits(nFillBits, nLineBits); //vincenzo
|
|
}
|
|
_SWFStream->FlushBits();
|
|
}
|