bool XARGenerator::OutputPolygonEntity(const Style& style, const Transformation& trans, const PointDVector& coordVector)
{
bool ok = true;
CXaraFileRecord Rec(0);
if (style.IsFillColourDefined() || style.IsFillGradientDefined()) {
if (style.IsStrokeColourDefined())
Rec.Reinit(TAG_PATH_FILLED_STROKED, TAG_PATH_SIZE);
else
Rec.Reinit(TAG_PATH_FILLED, TAG_PATH_SIZE);
} else // if (style.IsStrokeColourDefined())
Rec.Reinit(TAG_PATH_STROKED, TAG_PATH_SIZE);
Rec.WriteUINT32(coordVector.GetCount());
Rec.WriteBYTE(0x06); // moveto
for (unsigned int i = 1; i < coordVector.GetCount() - 1; ++i)
Rec.WriteBYTE(0x02); // lineto
Rec.WriteBYTE(0x03); // lineto + closepath
for (unsigned int i = 0; i < coordVector.GetCount(); ++i) {
PointD p = coordVector[i];
Rec.WriteCoord(DocCoord((INT32)p.x, m_docSize.y - (INT32)p.y));
}
ok = m_pExporter->WriteRecord(&Rec);
RectD boundings = GetMaximumBoundings(coordVector);
/***/ ok = m_pExporter->WriteZeroSizedRecord(TAG_DOWN);
OutputStyles(style, trans, boundings, STYLE_FILL_ALL|STYLE_STROKE_ALL|STYLE_OPACITY);
/***/ ok = m_pExporter->WriteZeroSizedRecord(TAG_UP);
return ok;
}
bool XARGenerator::OutputPathEntity(const Style& style, const Transformation& trans, PathDataVector& pathVector)
{
bool ok = true;
CXaraFileRecord Rec(0);
if (style.IsFillColourDefined() || style.IsFillGradientDefined()) {
if (style.IsStrokeColourDefined())
Rec.Reinit(TAG_PATH_FILLED_STROKED, TAG_PATH_SIZE);
else
Rec.Reinit(TAG_PATH_FILLED, TAG_PATH_SIZE);
} else // if (style.IsStrokeColourDefined())
Rec.Reinit(TAG_PATH_STROKED, TAG_PATH_SIZE);
Rec.WriteUINT32(pathVector.GetCount());
for (unsigned int i = 0; i < pathVector.GetCount(); ++i)
Rec.WriteBYTE(pathVector[i].m_verb);
for (unsigned int i = 0; i < pathVector.GetCount(); ++i) {
PointD p = pathVector[i].m_coord;
Rec.WriteCoord(DocCoord((INT32)p.x, m_docSize.y - (INT32)p.y));
}
ok = m_pExporter->WriteRecord(&Rec);
RectD boundings = GetMaximumBoundings(pathVector);
/***/ ok = m_pExporter->WriteZeroSizedRecord(TAG_DOWN);
OutputStyles(style, trans, boundings, STYLE_FILL_ALL|STYLE_STROKE_ALL|STYLE_OPACITY);
/***/ ok = m_pExporter->WriteZeroSizedRecord(TAG_UP);
return ok;
}
bool XARGenerator::OutputLineEntity(const Style& style, const Transformation& trans, const PointD& p1, const PointD& p2)
{
// truncate floating point values to INT32
DocCoord dcPos1((INT32)p1.x, m_docSize.y - (INT32)p1.y);
DocCoord dcPos2((INT32)p2.x, m_docSize.y - (INT32)p2.y);
#if SVGDEBUG
svgtrace(DBGTRACE_SHAPES, "line: x1=%d y1=%d x2=%d y2=%d\n", dcPos1.x, dcPos1.y, dcPos2.x, dcPos2.y);
#endif
bool ok = true;
CXaraFileRecord Rec(0);
Rec.Reinit(TAG_PATH_STROKED, TAG_PATH_SIZE);
Rec.WriteUINT32(2); // two coordinates
Rec.WriteBYTE(0x06); // moveto
Rec.WriteBYTE(0x02); // lineno
Rec.WriteCoord(dcPos1);
Rec.WriteCoord(dcPos2);
ok = m_pExporter->WriteRecord(&Rec);
RectD boundings = RectD(p1, p2);
/***/ ok = m_pExporter->WriteZeroSizedRecord(TAG_DOWN);
OutputStyles(style, trans, boundings, STYLE_STROKE_ALL|STYLE_OPACITY);
/***/ ok = m_pExporter->WriteZeroSizedRecord(TAG_UP);
return ok;
}
bool XARGenerator::OutputUprightEllipse(const RectD& r)
{
// no rotation or skew was applied
double fX = r.p11.x;
double fY = r.p11.y;
double fWidth = r.p12.x - r.p11.x;
double fHeight = r.p21.y - r.p11.y;
// adjust coordinates
fX += fWidth/2.0;
fY = m_docSize.y - fY - fHeight/2.0;
// truncate floating point values to INT32
DocCoord dcPos((INT32)fX, (INT32)fY);
DocCoord dcSize((INT32)fWidth, (INT32)fHeight);
bool ok = true;
CXaraFileRecord Rec(0);
#if SVGDEBUG
svgtrace(DBGTRACE_SHAPES, "translated upright ellipse: x=%d y=%d w=%d h=%d\n", dcPos.x, dcPos.y, dcSize.x, dcSize.y);
#endif
Rec.Reinit(TAG_ELLIPSE_SIMPLE, TAG_ELLIPSE_SIMPLE_SIZE);
ok = Rec.WriteCoord(dcPos);
ok = Rec.WriteINT32(dcSize.x);
ok = Rec.WriteINT32(dcSize.y);
ok = m_pExporter->WriteRecord(&Rec);
return ok;
}
bool XARGenerator::OutputComplexRect(const RectD& r, double fRoundAxis)
{
// complex (non-upright) rectangle
double fX = (r.p12.x + r.p21.x)*0.5;
double fY = (r.p12.y + r.p21.y)*0.5;
double fMaX = (r.p12.x + r.p22.x)*0.5;
double fMaY = (r.p12.y + r.p22.y)*0.5;
double fMiX = (r.p12.x + r.p11.x)*0.5;
double fMiY = (r.p12.y + r.p11.y)*0.5;
// adjust coordinates
fY = m_docSize.y - fY;
fMaY = m_docSize.y - fMaY;
fMiY = m_docSize.y - fMiY;
// axes are relative to center
fMaX -= fX;
fMaY -= fY;
fMiX -= fX;
fMiY -= fY;
// determine circumscribed ellipse axes
fMaX *= M_SQRT2;
fMaY *= M_SQRT2;
fMiX *= M_SQRT2;
fMiY *= M_SQRT2;
// truncate floating point values to INT32
DocCoord dcPos((INT32)fX, (INT32)fY);
DocCoord dcMaj((INT32)fMaX, (INT32)fMaY);
DocCoord dcMin((INT32)fMiX, (INT32)fMiY);
bool ok = true;
CXaraFileRecord Rec(0);
if (fRoundAxis == 0.0) {
// non-rounded rectangle
#if SVGDEBUG
svgtrace(DBGTRACE_SHAPES, "translated complex rect: x=%d y=%d M=%d,%d m=%d,%d\n", dcPos.x, dcPos.y, dcMaj.x, dcMaj.y, dcMin.x, dcMin.y);
#endif
Rec.Reinit(TAG_RECTANGLE_COMPLEX, TAG_RECTANGLE_COMPLEX_SIZE);
ok = Rec.WriteCoord(dcPos);
ok = Rec.WriteCoord(dcMaj);
ok = Rec.WriteCoord(dcMin);
ok = m_pExporter->WriteRecord(&Rec);
} else {
// rounded rectangle
double fRound = fRoundAxis / dcMaj.x;
#if SVGDEBUG
svgtrace(DBGTRACE_SHAPES, "translated complex rounded rect: x=%d y=%d M=%d,%d m=%d,%d f=%.2f\n", dcPos.x, dcPos.y, dcMaj.x, dcMaj.y, dcMin.x, dcMin.y, fRound);
#endif
Rec.Reinit(TAG_RECTANGLE_COMPLEX_ROUNDED, TAG_RECTANGLE_COMPLEX_ROUNDED_SIZE);
ok = Rec.WriteCoord(dcPos);
ok = Rec.WriteCoord(dcMaj);
ok = Rec.WriteCoord(dcMin);
ok = Rec.WriteDOUBLE(fRound);
ok = m_pExporter->WriteRecord(&Rec);
}
return ok;
}
SkPDFObject* SkPDFDict::append(SkPDFName* key, SkPDFObject* value) {
SkASSERT(key);
SkASSERT(value);
SkAutoMutexAcquire lock(fMutex); // If the SkTDArray resizes while
// two threads access array, one
// is left with a bad pointer.
*(fValue.append()) = Rec(key, value);
return value;
}
int64_t Euler_51()
{
int n;
for (n = 0; n < 8; n++)
Number[n] = 0;
Primes = primeIndexListE(1000000);
Rec(2);
free(Primes);
return g_min;
}
void SkPDFDict::mergeFrom(const SkPDFDict& other) {
SkAutoMutexAcquire lockOther(other.fMutex);
SkTDArray<Rec> copy(other.fValue);
lockOther.release(); // Do not hold both mutexes at once.
SkAutoMutexAcquire lock(fMutex);
for (int i = 0; i < copy.count(); i++) {
*(fValue.append()) = Rec(SkRef(copy[i].key), SkRef(copy[i].value));
}
}
void WeeklyDD(const std::vector<double> &TargetedEffort, const std::vector<double> &NontargetedEffort, std::vector<double> &Biomass, const std::vector<double> &par){
// Global variables
extern int NIPY;
extern double CatchabilityScalingFactor, BiomassScalingFactor,RecruitmentScalingFactor;
extern double rho, wk, wk_1;//, M;
assert(TargetedEffort.size() == Biomass.size());
unsigned int max_timestep = TargetedEffort.size();
// Define necessary containers
std::vector< double > Rec(max_timestep, 0.0), survival(max_timestep, 0.0);
// Remember that the optimizer work on parameters of the same order of magnitude
double M = par[0];
double Targeted_catchability = par[1] * CatchabilityScalingFactor;
double Nontargeted_catchability = par[2] * CatchabilityScalingFactor;
// Initialise the vector of biomass
Biomass[0] = par[4] * BiomassScalingFactor;
Biomass[1] = par[5] * BiomassScalingFactor;
// von mises parameters
double vm_mean = par[6]; // make sure it varies between -M_PI and +M_PI
double vm_sigma = par[7]; // should be positive
// Calculate survival given the vector of effort
for(unsigned int i=0; i < max_timestep; i += 1) {
survival[i] = exp(-(M + Targeted_catchability * TargetedEffort[i] + Nontargeted_catchability * NontargetedEffort[i]));
}
// Calculate the proportion of recruitment in each week
std::vector<double> RecDist(NIPY, 0.0);
RecDist = vonMisesRecDist(vm_mean, vm_sigma);
// Create the vector of recruitment
for(unsigned int counter = 0; counter < max_timestep; counter++){
Rec[counter] = par[8 + counter / NIPY] * RecruitmentScalingFactor * RecDist[counter % NIPY];
}
// Example how to print the vector of parameters
//std::cout << "This is par[0] " << par[0] << "\n";
//std::cout << "This is par[1] " << par[1] << "\n";
//std::cout << "Number of parameters " << par.size() << "\n";
// Recursive calculation of biomass
for(unsigned int counter = 2; counter < max_timestep; counter++){
// calculate biomass
Biomass[counter] = survival[counter-1] * Biomass[counter-1] + rho * survival[counter-1] * Biomass[counter-1] - rho * survival[counter-1] *survival[counter -2] * Biomass[counter-2] - rho * survival[counter-1] * wk_1 * Rec[counter-1] + wk * Rec[counter];
if(Biomass[counter] < 0){Biomass[counter] = 0;}
}
}
BOOL PrintComponent::ExportImagesetting(BaseCamelotFilter *pFilter)
{
BOOL ok = TRUE;
#if !defined(EXCLUDE_FROM_RALPH)
TypesetInfo *TInfo = GetPrintControl()->GetTypesetInfo();
if (TInfo == NULL)
return(TRUE); // If we can't find imagesetting info, don't sweat it
CXaraFileRecord Rec(TAG_IMAGESETTING, TAG_IMAGESETTING_SIZE);
if (ok) ok = Rec.Init();
if (ok) ok = Rec.WriteINT32(TInfo->GetPrintResolution());
if (ok) ok = Rec.WriteDOUBLE(TInfo->GetDefaultScreenFrequency());
if (ok)
{
UINT16 Func = 0;
switch(TInfo->GetScreenFunction())
{
case SCRTYPE_SPOT1: Func = 1; break;
case SCRTYPE_SPOT2: Func = 2; break;
case SCRTYPE_TRIPLESPOT1: Func = 3; break;
case SCRTYPE_TRIPLESPOT2: Func = 4; break;
case SCRTYPE_ELLIPTICAL: Func = 5; break;
case SCRTYPE_LINE: Func = 6; break;
case SCRTYPE_CROSSHATCH: Func = 7; break;
case SCRTYPE_MEZZOTINT: Func = 8; break;
case SCRTYPE_SQUARE: Func = 9; break;
case SCRTYPE_DITHER: Func = 10; break;
default:
break;
}
ok = Rec.WriteUINT16(Func);
}
if (ok)
{
BYTE Flags = 0x00;
if (TInfo->AreSeparating()) Flags |= 0x01;
if (TInfo->AreScreening()) Flags |= 0x02;
if (TInfo->PrintEmulsionDown()) Flags |= 0x04;
if (TInfo->PrintPhotoNegative()) Flags |= 0x08;
if (TInfo->AlwaysOverprintBlack()) Flags |= 0x10;
ok = Rec.WriteBYTE(Flags);
}
if (ok)
pFilter->Write(&Rec);
#endif // EXCLUDE_FROM_RALPH
return(ok);
}
bool XARGenerator::OutputHeader()
{
bool ok = true;
// Create a CXaraFileRecord object for the document header record
CXaraFileRecord Rec(TAG_FILEHEADER);
ok = Rec.Init();
if (ok) ok = Rec.WriteBuffer((BYTE*)"CXN", 3);
if (ok) ok = Rec.WriteUINT32(123); // File size
if (ok) ok = Rec.WriteUINT32(0); // Native/Web link ID
if (ok) ok = Rec.WriteUINT32(0); // Precompression flags
if (ok) ok = Rec.WriteASCII(_T("SVGFilter")); // Producer
if (ok) ok = Rec.WriteASCII(VERSION_TSTRING); // Producer version
if (ok) ok = Rec.WriteASCII(_T("")); // Producer build
if (ok) ok = m_pExporter->WriteRecord(&Rec);
// If any part of the header writing fails then return our own specific error
if (!ok)
{
// XXX Set an appropriate error here
return false;
}
// XXX From this point on the error handling becomes a bit thin
ok = m_pExporter->WriteZeroSizedRecord(TAG_SPREAD);
/***/ ok = m_pExporter->WriteZeroSizedRecord(TAG_DOWN);
if (m_docSize != DocCoord(0, 0)) {
ok = Rec.Reinit(TAG_SPREADINFORMATION, TAG_SPREADINFORMATION_SIZE);
ok = Rec.WriteUINT32(m_docSize.x); // width
ok = Rec.WriteUINT32(m_docSize.y); // height
ok = Rec.WriteUINT32(10000); // margin
ok = Rec.WriteUINT32(0); // bleed
ok = Rec.WriteBYTE(2); // flags (1:shadow)
ok = m_pExporter->WriteRecord(&Rec);
}
ok = Rec.Reinit(TAG_VIEWPORT, TAG_VIEWPORT_SIZE);
ok = Rec.WriteCoord(DocCoord(0, 0)); // bottom-left
ok = Rec.WriteCoord(DocCoord(m_docSize.x, m_docSize.y));// top-right
ok = m_pExporter->WriteRecord(&Rec);
// Write a layer
ok = m_pExporter->WriteZeroSizedRecord(TAG_LAYER);
/***/ ok = m_pExporter->WriteZeroSizedRecord(TAG_DOWN);
ok = Rec.Reinit(TAG_LAYERDETAILS, TAG_LAYERDETAILS_SIZE);
ok = Rec.WriteBYTE(1|4|8); // flags (0:visible, 2:printable, 3:active)
ok = Rec.WriteUnicode(_T("Layer 1"));
ok = m_pExporter->WriteRecord(&Rec);
return ok;
}
bool C4Record::Rec(C4PacketType eCtrlType, C4ControlPacket *pCtrl, int iFrame) {
if (!fRecording) return false;
// create copy
C4IDPacket Pkt = C4IDPacket(eCtrlType, pCtrl, false);
if (!Pkt.getPkt()) return false;
C4ControlPacket *pCtrlCpy = static_cast<C4ControlPacket *>(Pkt.getPkt());
// prepare for recording
pCtrlCpy->PreRec(this);
// record it
return Rec(iFrame, DecompileToBuf<StdCompilerBinWrite>(Pkt), RCT_CtrlPkt);
}
bool C4Record::Rec(const C4Control &Ctrl, int iFrame) {
if (!fRecording) return false;
// don't record empty control
if (!Ctrl.firstPkt()) return true;
// create copy
C4Control Cpy;
Cpy.Copy(Ctrl);
// prepare it for record
Cpy.PreRec(this);
// record it
return Rec(iFrame, DecompileToBuf<StdCompilerBinWrite>(Cpy), RCT_Ctrl);
}
BOOL PrintComponent::ExportColourPlate(BaseCamelotFilter *pFilter, ColourPlate *pPlate)
{
ERROR3IF(pPlate == NULL, "Illegal NULL params");
BOOL ok = TRUE;
#if !defined(EXCLUDE_FROM_RALPH)
// --- Save any referenced spot colour
IndexedColour *pCol = pPlate->GetSpotColour();
INT32 SpotRecordNumber = 0;
if (pCol != NULL)
{
DocColour Fred;
Fred.MakeRefToIndexedColour(pCol);
SpotRecordNumber = pFilter->WriteRecord(&Fred);
ok = (SpotRecordNumber > 0);
}
// -- Now save the ColourPlate
CXaraFileRecord Rec(TAG_COLOURPLATE, TAG_COLOURPLATE_SIZE);
if (ok) ok = Rec.Init();
BYTE Type = 0;
switch(pPlate->GetType())
{
case COLOURPLATE_CYAN: Type = 1; break;
case COLOURPLATE_MAGENTA: Type = 2; break;
case COLOURPLATE_YELLOW: Type = 3; break;
case COLOURPLATE_KEY: Type = 4; break;
case COLOURPLATE_SPOT: Type = 5; break;
default:
break;
}
// Size Total
if (ok) ok = Rec.WriteBYTE(Type); // 1 1
if (ok) ok = Rec.WriteReference(SpotRecordNumber); // 4 5
double temp = pPlate->GetScreenAngle();
if (ok) ok = Rec.WriteDOUBLE(temp); // 8 13
temp = pPlate->GetScreenFrequency();
if (ok) ok = Rec.WriteDOUBLE(temp); // 8 21
//
BYTE Flags = 0x00; // 1 22
if (!pPlate->IsDisabled()) Flags |= 0x01;
if (pPlate->Overprints()) Flags |= 0x02;
if (ok) ok = Rec.WriteBYTE(Flags);
if (ok)
pFilter->Write(&Rec);
#endif // EXCLUDE_FROM_RALPH
return(ok);
}
BOOL CXaraFileRectangle::WriteRectangleSimple(BaseCamelotFilter * pFilter, NodeRegularShape * pShape)
{
BOOL ok;
CamelotFileRecord Rec(pFilter,TAG_RECTANGLE_SIMPLE, TAG_RECTANGLE_SIMPLE_SIZE);
ok = Rec.Init();
if (ok) ok = Rec.WriteCoord(GetCentrePoint(pShape));
if (ok) ok = Rec.WriteINT32(GetWidth(pShape));
if (ok) ok = Rec.WriteINT32(GetHeight(pShape));
if (ok) ok = pFilter->Write(&Rec);
return ok;
}
BOOL CXaraFileRectangle::WriteRectangleComplex(BaseCamelotFilter * pFilter, NodeRegularShape * pShape)
{
BOOL ok;
CamelotFileRecord Rec(pFilter,TAG_RECTANGLE_COMPLEX, TAG_RECTANGLE_COMPLEX_SIZE);
ok = Rec.Init();
if (ok) ok = Rec.WriteCoord(GetCentrePoint(pShape));
if (ok) ok = Rec.WriteCoordTrans(GetMajorAxis(pShape),0,0);
if (ok) ok = Rec.WriteCoordTrans(GetMinorAxis(pShape),0,0);
if (ok) ok = pFilter->Write(&Rec);
return ok;
}
/********************************************************************************************
> virtual BOOL TemplateAttribute::WritePreChildrenWeb(BaseCamelotFilter* pFilter)
Author: Colin_Barfoot (Xara Group Ltd) <*****@*****.**>
Created: 27/06/97
Purpose: Writes the TemplateAttribute to the filter
Inputs: pFilter = ptr to the filter
Returns: TRUE if record is written, FALSE if not
********************************************************************************************/
BOOL TemplateAttribute::WritePreChildrenWeb(BaseCamelotFilter* pFilter)
{
#ifdef DO_EXPORT
ERROR2IF(pFilter == NULL,FALSE,"NULL filter param");
// Add a description of the TAG_WIZOP record for older importers
pFilter->AddTagDescription(TAG_WIZOP, _R(IDS_TAG_WIZOP));
CamelotFileRecord Rec(pFilter, TAG_WIZOP, CXF_UNKNOWN_SIZE);
BOOL ok = Rec.Init();
if (ok)
{
String_64 InternalName = GetInternalName();
ok = Rec.WriteUnicode((TCHAR*)InternalName);
}
if (ok)
{
String_256 Question = GetQuestion();
ok = Rec.WriteUnicode((TCHAR*)Question);
}
if (ok)
{
String_64 Param = GetParam();
ok = Rec.WriteUnicode((TCHAR*)Param);
}
if (ok)
{
// Write out some patch space
String_8 NonConstNullString = NullString;
ok = Rec.WriteUnicode((TCHAR*)NonConstNullString);
}
if (ok)
{
ok = pFilter->Write(&Rec);
}
if (!ok)
{
pFilter->GotError(_R(IDE_FILE_WRITE_ERROR));
}
return ok;
#else
return FALSE;
#endif
}
BOOL CXaraFileRectangle::WriteRectangleComplexReformed(BaseCamelotFilter * pFilter, NodeRegularShape * pShape)
{
BOOL ok;
CamelotFileRecord Rec(pFilter,TAG_RECTANGLE_COMPLEX_REFORMED, TAG_RECTANGLE_COMPLEX_REFORMED_SIZE);
ok = Rec.Init();
if (ok) ok = Rec.WriteCoordTrans(GetUTMajorAxis(pShape),0,0);
if (ok) ok = Rec.WriteCoordTrans(GetUTMinorAxis(pShape),0,0);
if (ok) ok = Rec.WriteMatrix(GetTransformMatrix(pShape));
if (ok) ok = Rec.WritePath(GetEdgePath(pShape));
if (ok) ok = pFilter->Write(&Rec);
return ok;
}
BOOL CXaraFilePolygon::WritePolygonComplex(BaseCamelotFilter * pFilter, NodeRegularShape * pShape)
{
BOOL ok;
CamelotFileRecord Rec(pFilter,TAG_POLYGON_COMPLEX, TAG_POLYGON_COMPLEX_SIZE);
ok = Rec.Init();
if (ok) ok = Rec.WriteUINT16(GetNumberOfSides(pShape));
if (ok) ok = Rec.WriteCoord(GetCentrePoint(pShape));
if (ok) ok = Rec.WriteCoordTrans(GetMajorAxis(pShape),0,0);
if (ok) ok = Rec.WriteCoordTrans(GetMinorAxis(pShape),0,0);
if (ok) ok = pFilter->Write(&Rec);
return ok;
}
bool XARGenerator::OutputUprightRect(const RectD& r, double fRoundAxis)
{
// no rotation or skew was applied
double fX = r.p11.x;
double fY = r.p11.y;
double fWidth = r.p12.x - r.p11.x;
double fHeight = r.p21.y - r.p11.y;
// adjust coordinates
fX += fWidth/2.0;
fY = m_docSize.y - fY - fHeight/2.0;
// determine circumscribed ellipse axes
fWidth *= M_SQRT2;
fHeight *= M_SQRT2;
// truncate floating point values to INT32
DocCoord dcPos((INT32)fX, (INT32)fY);
DocCoord dcSize((INT32)fWidth, (INT32)fHeight);
bool ok = true;
CXaraFileRecord Rec(0);
if (fRoundAxis == 0.0) {
// non-rounded rectangle
#if SVGDEBUG
svgtrace(DBGTRACE_SHAPES, "translated upright rect: x=%d y=%d w=%d h=%d\n", dcPos.x, dcPos.y, dcSize.x, dcSize.y);
#endif
Rec.Reinit(TAG_RECTANGLE_SIMPLE, TAG_RECTANGLE_SIMPLE_SIZE);
ok = Rec.WriteCoord(dcPos);
ok = Rec.WriteINT32(dcSize.x);
ok = Rec.WriteINT32(dcSize.y);
ok = m_pExporter->WriteRecord(&Rec);
} else {
// rounded rectangle
double fRound = (fRoundAxis*2.0) / dcSize.x;
#if SVGDEBUG
svgtrace(DBGTRACE_SHAPES, "translated upright rounded rect: x=%d y=%d w=%d h=%d f=%.2f\n", dcPos.x, dcPos.y, dcSize.x, dcSize.y, fRound);
#endif
Rec.Reinit(TAG_RECTANGLE_SIMPLE_ROUNDED, TAG_RECTANGLE_SIMPLE_ROUNDED_SIZE);
ok = Rec.WriteCoord(dcPos);
ok = Rec.WriteINT32(dcSize.x);
ok = Rec.WriteINT32(dcSize.y);
ok = Rec.WriteDOUBLE(fRound);
ok = m_pExporter->WriteRecord(&Rec);
}
return ok;
}
bool XARGenerator::OutputOpacity(double fOpacity)
{
bool ok = true;
CXaraFileRecord Rec(0);
if (fOpacity < 1.0) {
BYTE bOpacity = (BYTE)((1.0-fOpacity)*255.0);
Rec.Reinit(TAG_FLATTRANSPARENTFILL, TAG_FLATTRANSPARENTFILL_SIZE);
ok = Rec.WriteBYTE(bOpacity);
ok = Rec.WriteBYTE(0x01); // mix
ok = m_pExporter->WriteRecord(&Rec);
}
return ok;
}
BOOL CXaraFileRectangle::WriteRectangleComplexStellated(BaseCamelotFilter * pFilter, NodeRegularShape * pShape)
{
BOOL ok;
CamelotFileRecord Rec(pFilter,TAG_RECTANGLE_COMPLEX_STELLATED, TAG_RECTANGLE_COMPLEX_STELLATED_SIZE);
ok = Rec.Init();
if (ok) ok = Rec.WriteCoord(GetCentrePoint(pShape));
if (ok) ok = Rec.WriteCoordTrans(GetMajorAxis(pShape),0,0);
if (ok) ok = Rec.WriteCoordTrans(GetMinorAxis(pShape),0,0);
if (ok) ok = Rec.WriteDOUBLE(GetStellationRadius(pShape));
if (ok) ok = Rec.WriteDOUBLE(GetStellationOffset(pShape));
if (ok) ok = pFilter->Write(&Rec);
return ok;
}
BOOL CXaraFileRectangle::WriteRectangleSimpleRoundedReformed(BaseCamelotFilter * pFilter, NodeRegularShape * pShape)
{
BOOL ok;
CamelotFileRecord Rec(pFilter,TAG_RECTANGLE_SIMPLE_ROUNDED_REFORMED, TAG_RECTANGLE_SIMPLE_ROUNDED_REFORMED_SIZE);
ok = Rec.Init();
if (ok) ok = Rec.WriteCoord(GetCentrePoint(pShape));
if (ok) ok = Rec.WriteINT32(GetWidth(pShape));
if (ok) ok = Rec.WriteINT32(GetHeight(pShape));
if (ok) ok = Rec.WriteDOUBLE(GetCurvature(pShape));
if (ok) ok = Rec.WritePath(GetEdgePath(pShape));
if (ok) ok = pFilter->Write(&Rec);
return ok;
}
BOOL CXaraFileRectangle::WriteRectangleSimpleStellated(BaseCamelotFilter * pFilter, NodeRegularShape * pShape)
{
BOOL ok;
CamelotFileRecord Rec(pFilter,TAG_RECTANGLE_SIMPLE_STELLATED, TAG_RECTANGLE_SIMPLE_STELLATED_SIZE);
ok = Rec.Init();
if (ok) ok = Rec.WriteCoord(GetCentrePoint(pShape));
if (ok) ok = Rec.WriteINT32(GetWidth(pShape));
if (ok) ok = Rec.WriteINT32(GetHeight(pShape));
if (ok) ok = Rec.WriteDOUBLE(GetStellationRadius(pShape));
if (ok) ok = Rec.WriteDOUBLE(GetStellationOffset(pShape));
if (ok) ok = pFilter->Write(&Rec);
return ok;
}
BOOL CXaraFilePolygon::WritePolygonComplexReformed(BaseCamelotFilter * pFilter, NodeRegularShape * pShape)
{
BOOL ok;
CamelotFileRecord Rec(pFilter,TAG_POLYGON_COMPLEX_REFORMED, TAG_POLYGON_COMPLEX_REFORMED_SIZE);
ok = Rec.Init();
if (ok) ok = Rec.WriteUINT16(GetNumberOfSides(pShape));
if (ok) ok = Rec.WriteCoordTrans(GetUTMajorAxis(pShape),0,0);
if (ok) ok = Rec.WriteCoordTrans(GetUTMinorAxis(pShape),0,0);
if (ok) ok = Rec.WriteMatrix(GetTransformMatrix(pShape));
if (ok) ok = Rec.WritePath(GetEdgePath(pShape));
if (ok) ok = pFilter->Write(&Rec);
return ok;
}
BOOL Chapter::WritePreChildrenNative(BaseCamelotFilter* pFilter)
{
#ifdef DO_EXPORT
BOOL RecordWritten = FALSE;
// Always write out the spread record in native files
CXaraFileRecord Rec(TAG_CHAPTER,TAG_CHAPTER_SIZE);
if (pFilter->Write(&Rec) != 0)
RecordWritten = TRUE;
else
pFilter->GotError(_R(IDE_FILE_WRITE_ERROR));
return RecordWritten;
#else
return FALSE;
#endif
}
/********************************************************************************************
> virtual BOOL StyleReferenceAttribute::WritePreChildrenWeb(BaseCamelotFilter* pFilter)
Author: Colin_Barfoot (Xara Group Ltd) <*****@*****.**>
Created: 09/06/97
Purpose: Writes this StyleReferenceAttribute via the given filter.
Inputs: pFilter: The filter to use
Returns: FALSE if it failed
Notes: this StyleReferenceAttribute attempts to write the referenced style out
first.
********************************************************************************************/
BOOL StyleReferenceAttribute::WritePreChildrenWeb(BaseCamelotFilter* pFilter)
{
#ifdef DO_EXPORT
ENSURE_NOT_NULL(Value.m_pStyle);
ERROR2IF(pFilter == NULL,FALSE,"NULL filter param");
// Must write out the style first
ENSURE_KIND(Value.m_pStyle, WizOpStyle);
const WizOpStyle& ActualStyle = (WizOpStyle&)*Value.m_pStyle;
WizOpStyles* const pStyles = GetStylesForFilter(*pFilter);
BOOL Ok = (pStyles != NULL);
XFileRef RecordRef = 0;
if (Ok)
{
RecordRef = pStyles->GetRecordRefForStyle(ActualStyle);
// Is the style reference ok?
Ok = (RecordRef != 0);
}
if (Ok)
{
// Add a description of the TAG_WIZOP_STYLEREF record for older importers
pFilter->AddTagDescription(TAG_WIZOP_STYLEREF, _R(IDS_TAG_WIZOP_STYLEREF));
}
if (Ok)
{
CamelotFileRecord Rec(pFilter, TAG_WIZOP_STYLEREF, TAG_WIZOP_STYLEREF_SIZE);
if (Ok) Ok = Rec.Init();
if (Ok) Ok = Rec.WriteReference(RecordRef);
if (Ok) Ok = pFilter->Write(&Rec);
}
if (!Ok)
pFilter->GotError(_R(IDE_FILE_WRITE_ERROR));
return Ok;
#else
return FALSE;
#endif
}
BOOL UnitListComponent::ExportDefaultDisplayUnits(BaseCamelotFilter *pFilter)
{
#ifdef DO_EXPORT
ERROR2IF(pDocUnitList == NULL,FALSE,"UnitListComponent::ExportDisplayDefaultUnits called with no doc unit list pointer");
// Get the current default settings
UnitType PageUnits = pDocUnitList->GetPageUnits(); // The units used to display page measurements
//UnitType ScaledUnits = pDocUnitList->GetScaleUnits(); // The units to display scaled measurements
UnitType FontUnits = pDocUnitList->GetFontUnits(); // The units to display font measurements
// Convert these into the export unit types
//INT32 ExportPageUnits = GetExportUnitType(PageUnits);
//INT32 ExportFontUnits = GetExportUnitType(FontUnits);
INT32 ExportPageUnits = GetWriteUnitReference(PageUnits, pFilter);
ERROR2IF(ExportPageUnits == 0,FALSE,"UnitListComponent::ExportDisplayDefaultUnits bad page units reference!");
INT32 ExportFontUnits = GetWriteUnitReference(FontUnits, pFilter);
ERROR2IF(ExportFontUnits == 0,FALSE,"UnitListComponent::ExportDisplayDefaultUnits bad font units reference!");
BOOL ok = TRUE;
if (ExportPageUnits !=0 && ExportFontUnits != 0)
{
CXaraFileRecord Rec(TAG_DEFINE_DEFAULTUNITS, TAG_DEFINE_DEFAULTUNITS_SIZE);
ok = Rec.Init();
if (ok) ok = Rec.WriteINT32(ExportPageUnits);
if (ok) ok = Rec.WriteINT32(ExportFontUnits);
// Finally, write the record out to file
// In the process get the record number that this was written out as
INT32 RecordNumber = 0L;
if (ok) RecordNumber = pFilter->Write(&Rec); // Get the document comment
// If we have had a problem at any of the stages then return that to the caller
if (RecordNumber <= 0)
ok = FALSE;
}
else
ERROR3("Bad conversion of default font or page units");
return ok;
#else
return TRUE;
#endif
}
BOOL CXaraFileRectangle::WriteRectangleComplexStellatedReformed(BaseCamelotFilter * pFilter, NodeRegularShape * pShape)
{
BOOL ok;
CamelotFileRecord Rec(pFilter,TAG_RECTANGLE_COMPLEX_STELLATED_REFORMED, TAG_RECTANGLE_COMPLEX_STELLATED_REFORMED_SIZE);
ok = Rec.Init();
if (ok) ok = Rec.WriteCoordTrans(GetUTMajorAxis(pShape),0,0);
if (ok) ok = Rec.WriteCoordTrans(GetUTMinorAxis(pShape),0,0);
if (ok) ok = Rec.WriteMatrix(GetTransformMatrix(pShape));
if (ok) ok = Rec.WriteDOUBLE(GetStellationRadius(pShape));
if (ok) ok = Rec.WriteDOUBLE(GetStellationOffset(pShape));
if (ok) ok = Rec.WritePath(GetPrimaryEdgePath(pShape));
if (ok) ok = Rec.WritePath(GetSecondaryEdgePath(pShape));
if (ok) ok = pFilter->Write(&Rec);
return ok;
}
BOOL CXaraFilePolygon::WritePolygonComplexRoundedStellated(BaseCamelotFilter * pFilter, NodeRegularShape * pShape)
{
BOOL ok;
CamelotFileRecord Rec(pFilter,TAG_POLYGON_COMPLEX_ROUNDED_STELLATED, TAG_POLYGON_COMPLEX_ROUNDED_STELLATED_SIZE);
ok = Rec.Init();
if (ok) ok = Rec.WriteUINT16(GetNumberOfSides(pShape));
if (ok) ok = Rec.WriteCoord(GetCentrePoint(pShape));
if (ok) ok = Rec.WriteCoordTrans(GetMajorAxis(pShape),0,0);
if (ok) ok = Rec.WriteCoordTrans(GetMinorAxis(pShape),0,0);
if (ok) ok = Rec.WriteDOUBLE(GetStellationRadius(pShape));
if (ok) ok = Rec.WriteDOUBLE(GetStellationOffset(pShape));
if (ok) ok = Rec.WriteDOUBLE(GetPrimaryCurvature(pShape));
if (ok) ok = Rec.WriteDOUBLE(GetSecondaryCurvature(pShape));
if (ok) ok = pFilter->Write(&Rec);
return ok;
}
