summaryrefslogtreecommitdiff
path: root/filter/source/graphicfilter/idxf
diff options
context:
space:
mode:
Diffstat (limited to 'filter/source/graphicfilter/idxf')
-rw-r--r--filter/source/graphicfilter/idxf/dxf2mtf.cxx980
-rw-r--r--filter/source/graphicfilter/idxf/dxf2mtf.hxx128
-rw-r--r--filter/source/graphicfilter/idxf/dxfblkrd.cxx139
-rw-r--r--filter/source/graphicfilter/idxf/dxfblkrd.hxx87
-rw-r--r--filter/source/graphicfilter/idxf/dxfentrd.cxx871
-rw-r--r--filter/source/graphicfilter/idxf/dxfentrd.hxx602
-rw-r--r--filter/source/graphicfilter/idxf/dxfgrprd.cxx361
-rw-r--r--filter/source/graphicfilter/idxf/dxfgrprd.hxx155
-rw-r--r--filter/source/graphicfilter/idxf/dxfreprd.cxx385
-rw-r--r--filter/source/graphicfilter/idxf/dxfreprd.hxx138
-rw-r--r--filter/source/graphicfilter/idxf/dxftblrd.cxx348
-rw-r--r--filter/source/graphicfilter/idxf/dxftblrd.hxx183
-rw-r--r--filter/source/graphicfilter/idxf/dxfvec.cxx254
-rw-r--r--filter/source/graphicfilter/idxf/dxfvec.hxx261
-rw-r--r--filter/source/graphicfilter/idxf/exports.map7
-rw-r--r--filter/source/graphicfilter/idxf/idxf.cxx82
-rw-r--r--filter/source/graphicfilter/idxf/makefile.mk79
17 files changed, 5060 insertions, 0 deletions
diff --git a/filter/source/graphicfilter/idxf/dxf2mtf.cxx b/filter/source/graphicfilter/idxf/dxf2mtf.cxx
new file mode 100644
index 000000000000..11e82f97b328
--- /dev/null
+++ b/filter/source/graphicfilter/idxf/dxf2mtf.cxx
@@ -0,0 +1,980 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_filter.hxx"
+
+#include <string.h>
+#include <vcl/gdimtf.hxx>
+#include <vcl/virdev.hxx>
+#include <tools/poly.hxx>
+#include "dxf2mtf.hxx"
+
+#include <math.h>
+
+
+ULONG DXF2GDIMetaFile::CountEntities(const DXFEntities & rEntities)
+{
+ const DXFBasicEntity * pBE;
+ ULONG nRes;
+
+ nRes=0;
+ for (pBE=rEntities.pFirst; pBE!=NULL; pBE=pBE->pSucc) nRes++;
+ return nRes;
+}
+
+
+void DXF2GDIMetaFile::MayCallback(ULONG /*nMainEntitiesProcessed*/)
+{
+ // ULONG nPercent;
+/*
+ if (pCallback!=NULL && nMainEntitiesCount!=0) {
+ nPercent=nMinPercent+(nMaxPercent-nMinPercent)*nMainEntitiesProcessed/nMainEntitiesCount;
+ if (nPercent>=nLastPercent+4) {
+ if (((*pCallback)(pCallerData,(USHORT)nPercent))==TRUE) bStatus=FALSE;
+ nLastPercent=nPercent;
+ }
+ }
+*/
+}
+
+Color DXF2GDIMetaFile::ConvertColor(BYTE nColor)
+{
+ return Color(
+ pDXF->aPalette.GetRed( nColor ),
+ pDXF->aPalette.GetGreen( nColor ),
+ pDXF->aPalette.GetBlue( nColor ) );
+}
+
+long DXF2GDIMetaFile::GetEntityColor(const DXFBasicEntity & rE)
+{
+ long nColor;
+ const DXFLayer * pLayer;
+
+ nColor=rE.nColor;
+ if (nColor==256) {
+ if (rE.sLayer[0]=='0' && rE.sLayer[1]==0) nColor=nParentLayerColor;
+ else {
+ pLayer=pDXF->aTables.SearchLayer(rE.sLayer);
+ if (pLayer!=NULL) nColor=pLayer->nColor;
+ else nColor=nParentLayerColor;
+ }
+ }
+ else if (nColor==0) nColor=nBlockColor;
+ return nColor;
+}
+
+DXFLineInfo DXF2GDIMetaFile::LTypeToDXFLineInfo(const char * sLineType)
+{
+ const DXFLType * pLT;
+ DXFLineInfo aDXFLineInfo;
+
+ pLT=pDXF->aTables.SearchLType(sLineType);
+ if (pLT==NULL || pLT->nDashCount == 0) {
+ aDXFLineInfo.eStyle = LINE_SOLID;
+ }
+ else {
+ sal_Int32 i;
+ double x;
+ aDXFLineInfo.eStyle = LINE_DASH;
+ for (i=0; i < (pLT->nDashCount); i++) {
+ x = pLT->fDash[i] * pDXF->getGlobalLineTypeScale();
+// ####
+ // x = (sal_Int32) rTransform.TransLineWidth( pLT->fDash[i] * pDXF->getGlobalLineTypeScale() );
+ if ( x >= 0.0 ) {
+ if ( aDXFLineInfo.nDotCount == 0 ) {
+ aDXFLineInfo.nDotCount ++;
+ aDXFLineInfo.fDotLen = x;
+ }
+ else if ( aDXFLineInfo.fDotLen == x ) {
+ aDXFLineInfo.nDotCount ++;
+ }
+ else if ( aDXFLineInfo.nDashCount == 0 ) {
+ aDXFLineInfo.nDashCount ++;
+ aDXFLineInfo.fDashLen = x;
+ }
+ else if ( aDXFLineInfo.fDashLen == x ) {
+ aDXFLineInfo.nDashCount ++;
+ }
+ else {
+ // It is impossible to be converted.
+ }
+ }
+ else {
+ if ( aDXFLineInfo.fDistance == 0 ) {
+ aDXFLineInfo.fDistance = -1 * x;
+ }
+ else {
+ // It is impossible to be converted.
+ }
+ }
+
+ }
+ }
+
+#if 0
+ if (aDXFLineInfo.DashCount > 0 && aDXFLineInfo.DashLen == 0.0)
+ aDXFLineInfo.DashLen ( 1 );
+ if (aDXFLineInfo.DotCount > 0 && aDXFLineInfo.DotLen() == 0.0)
+ aDXFLineInfo.SetDotLen( 1 );
+ if (aDXFLineInfo.GetDashCount > 0 || aDXFLineInfo.GetDotCount > 0)
+ if (aDXFLineInfo.GetDistance() == 0)
+ aDXFLineInfo.SetDistance( 1 );
+#endif
+
+ return aDXFLineInfo;
+}
+
+DXFLineInfo DXF2GDIMetaFile::GetEntityDXFLineInfo(const DXFBasicEntity & rE)
+{
+ DXFLineInfo aDXFLineInfo;
+ const DXFLayer * pLayer;
+
+ aDXFLineInfo.eStyle = LINE_SOLID;
+ aDXFLineInfo.fWidth = 0;
+ aDXFLineInfo.nDashCount = 0;
+ aDXFLineInfo.fDashLen = 0;
+ aDXFLineInfo.nDotCount = 0;
+ aDXFLineInfo.fDotLen = 0;
+ aDXFLineInfo.fDistance = 0;
+
+ if (strcmp(rE.sLineType,"BYLAYER")==0) {
+ if (rE.sLayer[0]=='0' && rE.sLayer[1]==0) aDXFLineInfo=aParentLayerDXFLineInfo;
+ else {
+ pLayer=pDXF->aTables.SearchLayer(rE.sLayer);
+ if (pLayer!=NULL) aDXFLineInfo=LTypeToDXFLineInfo(pLayer->sLineType);
+ else aDXFLineInfo=aParentLayerDXFLineInfo;
+ }
+ }
+ else if (strcmp(rE.sLineType,"BYBLOCK")==0) {
+ aDXFLineInfo=aBlockDXFLineInfo;
+ }
+ else aDXFLineInfo=LTypeToDXFLineInfo(rE.sLineType);
+ return aDXFLineInfo;
+}
+
+
+BOOL DXF2GDIMetaFile::SetLineAttribute(const DXFBasicEntity & rE, ULONG /*nWidth*/)
+{
+ long nColor;
+ Color aColor;
+
+ nColor=GetEntityColor(rE);
+ if (nColor<0) return FALSE;
+ aColor=ConvertColor((BYTE)nColor);
+
+ if (aActLineColor!=aColor) {
+ pVirDev->SetLineColor( aActLineColor = aColor );
+ }
+
+ if (aActFillColor!=Color( COL_TRANSPARENT )) {
+ pVirDev->SetFillColor(aActFillColor = Color( COL_TRANSPARENT ));
+ }
+ return TRUE;
+}
+
+
+BOOL DXF2GDIMetaFile::SetAreaAttribute(const DXFBasicEntity & rE)
+{
+ long nColor;
+ Color aColor;
+
+ nColor=GetEntityColor(rE);
+ if (nColor<0) return FALSE;
+ aColor=ConvertColor((BYTE)nColor);
+
+ if (aActLineColor!=aColor) {
+ pVirDev->SetLineColor( aActLineColor = aColor );
+ }
+
+ if ( aActFillColor == Color( COL_TRANSPARENT ) || aActFillColor != aColor) {
+ pVirDev->SetFillColor( aActFillColor = aColor );
+ }
+ return TRUE;
+}
+
+
+BOOL DXF2GDIMetaFile::SetFontAttribute(const DXFBasicEntity & rE, short nAngle, USHORT nHeight, double /*fWidthScale*/)
+{
+ long nColor;
+ Color aColor;
+ Font aFont;
+
+ nAngle=-nAngle;
+ while (nAngle>3600) nAngle-=3600;
+ while (nAngle<0) nAngle+=3600;
+
+ nColor=GetEntityColor(rE);
+ if (nColor<0) return FALSE;
+ aColor=ConvertColor((BYTE)nColor);
+
+ aFont.SetColor(aColor);
+ aFont.SetTransparent(TRUE);
+ aFont.SetFamily(FAMILY_SWISS);
+ aFont.SetSize(Size(0,nHeight));
+ aFont.SetAlign(ALIGN_BASELINE);
+ aFont.SetOrientation(nAngle);
+ if (aActFont!=aFont) {
+ aActFont=aFont;
+ pVirDev->SetFont(aActFont);
+ }
+
+ return TRUE;
+}
+
+
+void DXF2GDIMetaFile::DrawLineEntity(const DXFLineEntity & rE, const DXFTransform & rTransform)
+{
+ if (SetLineAttribute(rE)) {
+ Point aP0,aP1;
+ rTransform.Transform(rE.aP0,aP0);
+ rTransform.Transform(rE.aP1,aP1);
+
+ DXFLineInfo aDXFLineInfo;
+ aDXFLineInfo=GetEntityDXFLineInfo(rE);
+ LineInfo aLineInfo;
+ aLineInfo = rTransform.Transform(aDXFLineInfo);
+
+#if 0
+ printf("%f\n", rTransform.TransLineWidth(1000.0));
+
+ // LINE_NONE = 0, LINE_SOLID = 1, LINE_DASH = 2, LineStyle_FORCE_EQUAL_SIZE = SAL_MAX_ENUM
+ aLineInfo.SetStyle( LINE_DASH );
+ aLineInfo.SetWidth( 300 );
+ aLineInfo.SetDashCount( 2 );
+ aLineInfo.SetDashLen( 100 );
+ aLineInfo.SetDotCount( 1 );
+ aLineInfo.SetDotLen( 0 );
+ aLineInfo.SetDistance( 500 );
+#endif
+
+ pVirDev->DrawLine(aP0,aP1,aLineInfo);
+ if (rE.fThickness!=0) {
+ Point aP2,aP3;
+ rTransform.Transform(rE.aP0+DXFVector(0,0,rE.fThickness),aP2);
+ rTransform.Transform(rE.aP1+DXFVector(0,0,rE.fThickness),aP3);
+ pVirDev->DrawLine(aP2,aP3);
+ pVirDev->DrawLine(aP0,aP2);
+ pVirDev->DrawLine(aP1,aP3);
+ }
+ }
+}
+
+
+void DXF2GDIMetaFile::DrawPointEntity(const DXFPointEntity & rE, const DXFTransform & rTransform)
+{
+
+ if (SetLineAttribute(rE)) {
+ Point aP0;
+ rTransform.Transform(rE.aP0,aP0);
+ if (rE.fThickness==0) pVirDev->DrawPixel(aP0);
+ else {
+ Point aP1;
+ rTransform.Transform(rE.aP0+DXFVector(0,0,rE.fThickness),aP1);
+ pVirDev->DrawLine(aP0,aP1);
+ }
+ }
+}
+
+
+void DXF2GDIMetaFile::DrawCircleEntity(const DXFCircleEntity & rE, const DXFTransform & rTransform)
+{
+ double frx,fry,fAng;
+ USHORT nPoints,i;
+ DXFVector aC;
+
+ if (SetLineAttribute(rE)==FALSE) return;
+ rTransform.Transform(rE.aP0,aC);
+ if (rE.fThickness==0 && rTransform.TransCircleToEllipse(rE.fRadius,frx,fry)==TRUE) {
+ pVirDev->DrawEllipse(
+ Rectangle((long)(aC.fx-frx+0.5),(long)(aC.fy-fry+0.5),
+ (long)(aC.fx+frx+0.5),(long)(aC.fy+fry+0.5)));
+ }
+ else {
+ nPoints=OptPointsPerCircle;
+ Polygon aPoly(nPoints);
+ for (i=0; i<nPoints; i++) {
+ fAng=2*3.14159265359/(double)(nPoints-1)*(double)i;
+ rTransform.Transform(
+ rE.aP0+DXFVector(rE.fRadius*cos(fAng),rE.fRadius*sin(fAng),0),
+ aPoly[i]
+ );
+ }
+ pVirDev->DrawPolyLine(aPoly);
+ if (rE.fThickness!=0) {
+ Polygon aPoly2(nPoints);
+ for (i=0; i<nPoints; i++) {
+ fAng=2*3.14159265359/(double)(nPoints-1)*(double)i;
+ rTransform.Transform(
+ rE.aP0+DXFVector(rE.fRadius*cos(fAng),rE.fRadius*sin(fAng),rE.fThickness),
+ aPoly2[i]
+ );
+
+ }
+ pVirDev->DrawPolyLine(aPoly2);
+ for (i=0; i<nPoints-1; i++) pVirDev->DrawLine(aPoly[i],aPoly2[i]);
+ }
+ }
+}
+
+
+void DXF2GDIMetaFile::DrawArcEntity(const DXFArcEntity & rE, const DXFTransform & rTransform)
+{
+ double frx,fry,fA1,fdA,fAng;
+ USHORT nPoints,i;
+ DXFVector aC;
+ Point aPS,aPE;
+
+ if (SetLineAttribute(rE)==FALSE) return;
+ fA1=rE.fStart;
+ fdA=rE.fEnd-fA1;
+ while (fdA>=360.0) fdA-=360.0;
+ while (fdA<=0) fdA+=360.0;
+ rTransform.Transform(rE.aP0,aC);
+ if (rE.fThickness==0 && fdA>5.0 && rTransform.TransCircleToEllipse(rE.fRadius,frx,fry)==TRUE) {
+ DXFVector aVS(cos(fA1/180.0*3.14159265359),sin(fA1/180.0*3.14159265359),0.0);
+ aVS*=rE.fRadius;
+ aVS+=rE.aP0;
+ DXFVector aVE(cos((fA1+fdA)/180.0*3.14159265359),sin((fA1+fdA)/180.0*3.14159265359),0.0);
+ aVE*=rE.fRadius;
+ aVE+=rE.aP0;
+ if (rTransform.Mirror()==TRUE) {
+ rTransform.Transform(aVS,aPS);
+ rTransform.Transform(aVE,aPE);
+ }
+ else {
+ rTransform.Transform(aVS,aPE);
+ rTransform.Transform(aVE,aPS);
+ }
+ pVirDev->DrawArc(
+ Rectangle((long)(aC.fx-frx+0.5),(long)(aC.fy-fry+0.5),
+ (long)(aC.fx+frx+0.5),(long)(aC.fy+fry+0.5)),
+ aPS,aPE
+ );
+ }
+ else {
+ nPoints=(USHORT)(fdA/360.0*(double)OptPointsPerCircle+0.5);
+ if (nPoints<2) nPoints=2;
+ Polygon aPoly(nPoints);
+ for (i=0; i<nPoints; i++) {
+ fAng=3.14159265359/180.0 * ( fA1 + fdA/(double)(nPoints-1)*(double)i );
+ rTransform.Transform(
+ rE.aP0+DXFVector(rE.fRadius*cos(fAng),rE.fRadius*sin(fAng),0),
+ aPoly[i]
+ );
+ }
+ pVirDev->DrawPolyLine(aPoly);
+ if (rE.fThickness!=0) {
+ Polygon aPoly2(nPoints);
+ for (i=0; i<nPoints; i++) {
+ fAng=3.14159265359/180.0 * ( fA1 + fdA/(double)(nPoints-1)*(double)i );
+ rTransform.Transform(
+ rE.aP0+DXFVector(rE.fRadius*cos(fAng),rE.fRadius*sin(fAng),rE.fThickness),
+ aPoly2[i]
+ );
+ }
+ pVirDev->DrawPolyLine(aPoly2);
+ for (i=0; i<nPoints; i++) pVirDev->DrawLine(aPoly[i],aPoly2[i]);
+ }
+ }
+}
+
+
+void DXF2GDIMetaFile::DrawTraceEntity(const DXFTraceEntity & rE, const DXFTransform & rTransform)
+{
+ if (SetLineAttribute(rE)) {
+ Polygon aPoly(4);
+ rTransform.Transform(rE.aP0,aPoly[0]);
+ rTransform.Transform(rE.aP1,aPoly[1]);
+ rTransform.Transform(rE.aP3,aPoly[2]);
+ rTransform.Transform(rE.aP2,aPoly[3]);
+ pVirDev->DrawPolygon(aPoly);
+ if (rE.fThickness!=0) {
+ USHORT i;
+ Polygon aPoly2(4);
+ DXFVector aVAdd(0,0,rE.fThickness);
+ rTransform.Transform(rE.aP0+aVAdd,aPoly2[0]);
+ rTransform.Transform(rE.aP1+aVAdd,aPoly2[1]);
+ rTransform.Transform(rE.aP3+aVAdd,aPoly2[2]);
+ rTransform.Transform(rE.aP2+aVAdd,aPoly2[3]);
+ pVirDev->DrawPolygon(aPoly2);
+ for (i=0; i<4; i++) pVirDev->DrawLine(aPoly[i],aPoly2[i]);
+ }
+ }
+}
+
+
+void DXF2GDIMetaFile::DrawSolidEntity(const DXFSolidEntity & rE, const DXFTransform & rTransform)
+{
+ if (SetAreaAttribute(rE)) {
+ USHORT nN;
+ if (rE.aP2==rE.aP3) nN=3; else nN=4;
+ Polygon aPoly(nN);
+ rTransform.Transform(rE.aP0,aPoly[0]);
+ rTransform.Transform(rE.aP1,aPoly[1]);
+ rTransform.Transform(rE.aP3,aPoly[2]);
+ if (nN>3) rTransform.Transform(rE.aP2,aPoly[3]);
+ pVirDev->DrawPolygon(aPoly);
+ if (rE.fThickness!=0) {
+ Polygon aPoly2(nN);
+ DXFVector aVAdd(0,0,rE.fThickness);
+ rTransform.Transform(rE.aP0+aVAdd,aPoly2[0]);
+ rTransform.Transform(rE.aP1+aVAdd,aPoly2[1]);
+ rTransform.Transform(rE.aP3+aVAdd,aPoly2[2]);
+ if (nN>3) rTransform.Transform(rE.aP2+aVAdd,aPoly2[3]);
+ pVirDev->DrawPolygon(aPoly2);
+ if (SetLineAttribute(rE)) {
+ USHORT i;
+ for (i=0; i<nN; i++) pVirDev->DrawLine(aPoly[i],aPoly2[i]);
+ }
+ }
+ }
+}
+
+
+void DXF2GDIMetaFile::DrawTextEntity(const DXFTextEntity & rE, const DXFTransform & rTransform)
+{
+ DXFVector aV;
+ Point aPt;
+ double fA;
+ USHORT nHeight;
+ short nAng;
+ ByteString aStr( rE.sText );
+ DXFTransform aT( DXFTransform(rE.fXScale,rE.fHeight,1.0,rE.fRotAngle,rE.aP0), rTransform );
+ aT.TransDir(DXFVector(0,1,0),aV);
+ nHeight=(USHORT)(aV.Abs()+0.5);
+ fA=aT.CalcRotAngle();
+ nAng=(short)(fA*10.0+0.5);
+ aT.TransDir(DXFVector(1,0,0),aV);
+ if ( SetFontAttribute( rE,nAng, nHeight, aV. Abs() ) )
+ {
+ String aUString( aStr, pDXF->getTextEncoding() );
+ aT.Transform( DXFVector( 0, 0, 0 ), aPt );
+ pVirDev->DrawText( aPt, aUString );
+ }
+}
+
+
+void DXF2GDIMetaFile::DrawInsertEntity(const DXFInsertEntity & rE, const DXFTransform & rTransform)
+{
+ const DXFBlock * pB;
+ pB=pDXF->aBlocks.Search(rE.sName);
+ if (pB!=NULL) {
+ DXFTransform aDXFTransform1(1.0,1.0,1.0,DXFVector(0.0,0.0,0.0)-pB->aBasePoint);
+ DXFTransform aDXFTransform2(rE.fXScale,rE.fYScale,rE.fZScale,rE.fRotAngle,rE.aP0);
+ DXFTransform aT(
+ DXFTransform( aDXFTransform1, aDXFTransform2 ),
+ rTransform
+ );
+ long nSavedBlockColor, nSavedParentLayerColor;
+ DXFLineInfo aSavedBlockDXFLineInfo, aSavedParentLayerDXFLineInfo;
+ nSavedBlockColor=nBlockColor;
+ nSavedParentLayerColor=nParentLayerColor;
+ aSavedBlockDXFLineInfo=aBlockDXFLineInfo;
+ aSavedParentLayerDXFLineInfo=aParentLayerDXFLineInfo;
+ nBlockColor=GetEntityColor(rE);
+ aBlockDXFLineInfo=GetEntityDXFLineInfo(rE);
+ if (rE.sLayer[0]!='0' || rE.sLayer[1]!=0) {
+ DXFLayer * pLayer=pDXF->aTables.SearchLayer(rE.sLayer);
+ if (pLayer!=NULL) {
+ nParentLayerColor=pLayer->nColor;
+ aParentLayerDXFLineInfo=LTypeToDXFLineInfo(pLayer->sLineType);
+ }
+ }
+ DrawEntities(*pB,aT,FALSE);
+ aBlockDXFLineInfo=aSavedBlockDXFLineInfo;
+ aParentLayerDXFLineInfo=aSavedParentLayerDXFLineInfo;
+ nBlockColor=nSavedBlockColor;
+ nParentLayerColor=nSavedParentLayerColor;
+ }
+}
+
+
+void DXF2GDIMetaFile::DrawAttribEntity(const DXFAttribEntity & rE, const DXFTransform & rTransform)
+{
+ if ((rE.nAttrFlags&1)==0) {
+ DXFVector aV;
+ Point aPt;
+ double fA;
+ USHORT nHeight;
+ short nAng;
+ ByteString aStr( rE.sText );
+ DXFTransform aT( DXFTransform( rE.fXScale, rE.fHeight, 1.0, rE.fRotAngle, rE.aP0 ), rTransform );
+ aT.TransDir(DXFVector(0,1,0),aV);
+ nHeight=(USHORT)(aV.Abs()+0.5);
+ fA=aT.CalcRotAngle();
+ nAng=(short)(fA*10.0+0.5);
+ aT.TransDir(DXFVector(1,0,0),aV);
+ if (SetFontAttribute(rE,nAng,nHeight,aV.Abs()))
+ {
+ String aUString( aStr, pDXF->getTextEncoding() );
+ aT.Transform( DXFVector( 0, 0, 0 ), aPt );
+ pVirDev->DrawText( aPt, aUString );
+ }
+ }
+}
+
+
+void DXF2GDIMetaFile::DrawPolyLineEntity(const DXFPolyLineEntity & rE, const DXFTransform & rTransform)
+{
+ USHORT i,nPolySize;
+ double fW;
+ const DXFBasicEntity * pBE;
+
+ nPolySize=0;
+ pBE=rE.pSucc;
+ while (pBE!=NULL && pBE->eType==DXF_VERTEX) {
+ nPolySize++;
+ pBE=pBE->pSucc;
+ }
+ if (nPolySize<2) return;
+ Polygon aPoly(nPolySize);
+ fW=0.0;
+ pBE=rE.pSucc;
+ for (i=0; i<nPolySize; i++) {
+ rTransform.Transform(((DXFVertexEntity*)pBE)->aP0,aPoly[i]);
+ if (i+1<nPolySize || (rE.nFlags&1)!=0) {
+ if (((DXFVertexEntity*)pBE)->fSWidth>=0.0) fW+=((DXFVertexEntity*)pBE)->fSWidth;
+ else fW+=rE.fSWidth;
+ if (((DXFVertexEntity*)pBE)->fEWidth>=0.0) fW+=((DXFVertexEntity*)pBE)->fEWidth;
+ else fW+=rE.fEWidth;
+ }
+ pBE=pBE->pSucc;
+ }
+ fW/=2.0;
+ if ((rE.nFlags&1)!=0) fW/=(double)nPolySize;
+ else fW/=(double)(nPolySize-1);
+ if (SetLineAttribute(rE,rTransform.TransLineWidth(fW))) {
+ if ((rE.nFlags&1)!=0) pVirDev->DrawPolygon(aPoly);
+ else pVirDev->DrawPolyLine(aPoly);
+ if (rE.fThickness!=0) {
+ Polygon aPoly2(nPolySize);
+ pBE=rE.pSucc;
+ for (i=0; i<nPolySize; i++) {
+ rTransform.Transform(
+ (((DXFVertexEntity*)pBE)->aP0)+DXFVector(0,0,rE.fThickness),
+ aPoly2[i]
+ );
+ pBE=pBE->pSucc;
+ }
+ if ((rE.nFlags&1)!=0) pVirDev->DrawPolygon(aPoly2);
+ else pVirDev->DrawPolyLine(aPoly2);
+ for (i=0; i<nPolySize; i++) pVirDev->DrawLine(aPoly[i],aPoly2[i]);
+ }
+ }
+}
+
+void DXF2GDIMetaFile::DrawLWPolyLineEntity(const DXFLWPolyLineEntity & rE, const DXFTransform & rTransform )
+{
+ sal_Int32 i, nPolySize = rE.nCount;
+ if ( nPolySize && rE.pP )
+ {
+ Polygon aPoly( (sal_uInt16)nPolySize);
+ for ( i = 0; i < nPolySize; i++ )
+ {
+ rTransform.Transform( rE.pP[ (sal_uInt16)i ], aPoly[ (sal_uInt16)i ] );
+ }
+ double fW = rE.fConstantWidth;
+ if ( SetLineAttribute( rE, rTransform.TransLineWidth( fW ) ) )
+ {
+ if ( ( rE.nFlags & 1 ) != 0 )
+ pVirDev->DrawPolygon( aPoly );
+ else
+ pVirDev->DrawPolyLine( aPoly );
+ // ####
+ //pVirDev->DrawPolyLine( aPoly, aDXFLineInfo );
+ }
+ }
+}
+
+void DXF2GDIMetaFile::DrawHatchEntity(const DXFHatchEntity & rE, const DXFTransform & rTransform )
+{
+ if ( rE.nBoundaryPathCount )
+ {
+ SetAreaAttribute( rE );
+ sal_Int32 j = 0;
+ PolyPolygon aPolyPoly;
+ for ( j = 0; j < rE.nBoundaryPathCount; j++ )
+ {
+ DXFPointArray aPtAry;
+ const DXFBoundaryPathData& rPathData = rE.pBoundaryPathData[ j ];
+ if ( rPathData.bIsPolyLine )
+ {
+ sal_Int32 i;
+ for( i = 0; i < rPathData.nPointCount; i++ )
+ {
+ Point aPt;
+ rTransform.Transform( rPathData.pP[ i ], aPt );
+ aPtAry.push_back( aPt );
+ }
+ }
+ else
+ {
+ sal_uInt32 i;
+ for ( i = 0; i < rPathData.aEdges.size(); i++ )
+ {
+ const DXFEdgeType* pEdge = rPathData.aEdges[ i ];
+ switch( pEdge->nEdgeType )
+ {
+ case 1 :
+ {
+ Point aPt;
+ rTransform.Transform( ((DXFEdgeTypeLine*)pEdge)->aStartPoint, aPt );
+ aPtAry.push_back( aPt );
+ rTransform.Transform( ((DXFEdgeTypeLine*)pEdge)->aEndPoint, aPt );
+ aPtAry.push_back( aPt );
+ }
+ break;
+ case 2 :
+ {
+/*
+ double frx,fry,fA1,fdA,fAng;
+ USHORT nPoints,i;
+ DXFVector aC;
+ Point aPS,aPE;
+ fA1=((DXFEdgeTypeCircularArc*)pEdge)->fStartAngle;
+ fdA=((DXFEdgeTypeCircularArc*)pEdge)->fEndAngle - fA1;
+ while ( fdA >= 360.0 )
+ fdA -= 360.0;
+ while ( fdA <= 0 )
+ fdA += 360.0;
+ rTransform.Transform(((DXFEdgeTypeCircularArc*)pEdge)->aCenter, aC);
+ if ( fdA > 5.0 && rTransform.TransCircleToEllipse(((DXFEdgeTypeCircularArc*)pEdge)->fRadius,frx,fry ) == TRUE )
+ {
+ DXFVector aVS(cos(fA1/180.0*3.14159265359),sin(fA1/180.0*3.14159265359),0.0);
+ aVS*=((DXFEdgeTypeCircularArc*)pEdge)->fRadius;
+ aVS+=((DXFEdgeTypeCircularArc*)pEdge)->aCenter;
+ DXFVector aVE(cos((fA1+fdA)/180.0*3.14159265359),sin((fA1+fdA)/180.0*3.14159265359),0.0);
+ aVE*=((DXFEdgeTypeCircularArc*)pEdge)->fRadius;
+ aVE+=((DXFEdgeTypeCircularArc*)pEdge)->aCenter;
+ if ( rTransform.Mirror() == TRUE )
+ {
+ rTransform.Transform(aVS,aPS);
+ rTransform.Transform(aVE,aPE);
+ }
+ else
+ {
+ rTransform.Transform(aVS,aPE);
+ rTransform.Transform(aVE,aPS);
+ }
+ pVirDev->DrawArc(
+ Rectangle((long)(aC.fx-frx+0.5),(long)(aC.fy-fry+0.5),
+ (long)(aC.fx+frx+0.5),(long)(aC.fy+fry+0.5)),
+ aPS,aPE
+ );
+ }
+*/
+ }
+ break;
+ case 3 :
+ case 4 :
+ break;
+ }
+ }
+ }
+ sal_uInt16 i, nSize = (sal_uInt16)aPtAry.size();
+ if ( nSize )
+ {
+ Polygon aPoly( nSize );
+ for ( i = 0; i < nSize; i++ )
+ aPoly[ i ] = aPtAry[ i ];
+ aPolyPoly.Insert( aPoly, POLYPOLY_APPEND );
+ }
+ }
+ if ( aPolyPoly.Count() )
+ pVirDev->DrawPolyPolygon( aPolyPoly );
+ }
+}
+
+void DXF2GDIMetaFile::Draw3DFaceEntity(const DXF3DFaceEntity & rE, const DXFTransform & rTransform)
+{
+ USHORT nN,i;
+ if (SetLineAttribute(rE)) {
+ if (rE.aP2==rE.aP3) nN=3; else nN=4;
+ Polygon aPoly(nN);
+ rTransform.Transform(rE.aP0,aPoly[0]);
+ rTransform.Transform(rE.aP1,aPoly[1]);
+ rTransform.Transform(rE.aP2,aPoly[2]);
+ if (nN>3) rTransform.Transform(rE.aP3,aPoly[3]);
+ if ((rE.nIEFlags&0x0f)==0) pVirDev->DrawPolygon(aPoly);
+ else {
+ for (i=0; i<nN; i++) {
+ if ( (rE.nIEFlags & (1<<i)) == 0 ) {
+ pVirDev->DrawLine(aPoly[i],aPoly[(i+1)%nN]);
+ }
+ }
+ }
+ }
+}
+
+
+void DXF2GDIMetaFile::DrawDimensionEntity(const DXFDimensionEntity & rE, const DXFTransform & rTransform)
+{
+ const DXFBlock * pB;
+ pB=pDXF->aBlocks.Search(rE.sPseudoBlock);
+ if (pB!=NULL) {
+ DXFTransform aT(
+ DXFTransform(1.0,1.0,1.0,DXFVector(0.0,0.0,0.0)-pB->aBasePoint),
+ rTransform
+ );
+ long nSavedBlockColor, nSavedParentLayerColor;
+ DXFLineInfo aSavedBlockDXFLineInfo, aSavedParentLayerDXFLineInfo;
+ nSavedBlockColor=nBlockColor;
+ nSavedParentLayerColor=nParentLayerColor;
+ aSavedBlockDXFLineInfo=aBlockDXFLineInfo;
+ aSavedParentLayerDXFLineInfo=aParentLayerDXFLineInfo;
+ nBlockColor=GetEntityColor(rE);
+ aBlockDXFLineInfo=GetEntityDXFLineInfo(rE);
+ if (rE.sLayer[0]!='0' || rE.sLayer[1]!=0) {
+ DXFLayer * pLayer=pDXF->aTables.SearchLayer(rE.sLayer);
+ if (pLayer!=NULL) {
+ nParentLayerColor=pLayer->nColor;
+ aParentLayerDXFLineInfo=LTypeToDXFLineInfo(pLayer->sLineType);
+ }
+ }
+ DrawEntities(*pB,aT,FALSE);
+ aBlockDXFLineInfo=aSavedBlockDXFLineInfo;
+ aParentLayerDXFLineInfo=aSavedParentLayerDXFLineInfo;
+ nBlockColor=nSavedBlockColor;
+ nParentLayerColor=nSavedParentLayerColor;
+ }
+}
+
+
+void DXF2GDIMetaFile::DrawEntities(const DXFEntities & rEntities,
+ const DXFTransform & rTransform,
+ BOOL bTopEntities)
+{
+ ULONG nCount=0;
+ DXFTransform aET;
+ const DXFTransform * pT;
+
+ const DXFBasicEntity * pE=rEntities.pFirst;
+
+ while (pE!=NULL && bStatus==TRUE) {
+ if (pE->nSpace==0) {
+ if (pE->aExtrusion.fz==1.0) {
+ pT=&rTransform;
+ }
+ else {
+ aET=DXFTransform(DXFTransform(pE->aExtrusion),rTransform);
+ pT=&aET;
+ }
+ switch (pE->eType) {
+ case DXF_LINE:
+ DrawLineEntity((DXFLineEntity&)*pE,*pT);
+ break;
+ case DXF_POINT:
+ DrawPointEntity((DXFPointEntity&)*pE,*pT);
+ break;
+ case DXF_CIRCLE:
+ DrawCircleEntity((DXFCircleEntity&)*pE,*pT);
+ break;
+ case DXF_ARC:
+ DrawArcEntity((DXFArcEntity&)*pE,*pT);
+ break;
+ case DXF_TRACE:
+ DrawTraceEntity((DXFTraceEntity&)*pE,*pT);
+ break;
+ case DXF_SOLID:
+ DrawSolidEntity((DXFSolidEntity&)*pE,*pT);
+ break;
+ case DXF_TEXT:
+ DrawTextEntity((DXFTextEntity&)*pE,*pT);
+ break;
+ case DXF_INSERT:
+ DrawInsertEntity((DXFInsertEntity&)*pE,*pT);
+ break;
+ case DXF_ATTRIB:
+ DrawAttribEntity((DXFAttribEntity&)*pE,*pT);
+ break;
+ case DXF_POLYLINE:
+ DrawPolyLineEntity((DXFPolyLineEntity&)*pE,*pT);
+ break;
+ case DXF_LWPOLYLINE :
+ DrawLWPolyLineEntity((DXFLWPolyLineEntity&)*pE, *pT);
+ break;
+ case DXF_HATCH :
+ DrawHatchEntity((DXFHatchEntity&)*pE, *pT);
+ break;
+ case DXF_3DFACE:
+ Draw3DFaceEntity((DXF3DFaceEntity&)*pE,*pT);
+ break;
+ case DXF_DIMENSION:
+ DrawDimensionEntity((DXFDimensionEntity&)*pE,*pT);
+ break;
+ default:
+ break; // four other values not handled -Wall
+ }
+ }
+ pE=pE->pSucc;
+ nCount++;
+ if (bTopEntities) MayCallback(nCount);
+ }
+}
+
+
+DXF2GDIMetaFile::DXF2GDIMetaFile()
+{
+}
+
+
+DXF2GDIMetaFile::~DXF2GDIMetaFile()
+{
+}
+
+
+BOOL DXF2GDIMetaFile::Convert(const DXFRepresentation & rDXF, GDIMetaFile & rMTF, USHORT nminpercent, USHORT nmaxpercent)
+{
+ double fWidth,fHeight,fScale;
+ DXFTransform aTransform;
+ Size aPrefSize;
+ const DXFLayer * pLayer;
+ const DXFVPort * pVPort;
+
+ pVirDev = new VirtualDevice;
+ pDXF = &rDXF;
+ bStatus = TRUE;
+
+ OptPointsPerCircle=50;
+
+ nMinPercent=(ULONG)nminpercent;
+ nMaxPercent=(ULONG)nmaxpercent;
+ nLastPercent=nMinPercent;
+ nMainEntitiesCount=CountEntities(pDXF->aEntities);
+
+ nBlockColor=7;
+ aBlockDXFLineInfo.eStyle = LINE_SOLID;
+ aBlockDXFLineInfo.fWidth = 0;
+ aBlockDXFLineInfo.nDashCount = 0;
+ aBlockDXFLineInfo.fDashLen = 0;
+ aBlockDXFLineInfo.nDotCount = 0;
+ aBlockDXFLineInfo.fDotLen = 0;
+ aBlockDXFLineInfo.fDistance = 0;
+
+ pLayer=pDXF->aTables.SearchLayer("0");
+ if (pLayer!=NULL) {
+ nParentLayerColor=pLayer->nColor & 0xff;
+ aParentLayerDXFLineInfo=LTypeToDXFLineInfo(pLayer->sLineType);
+ }
+ else {
+ nParentLayerColor=7;
+ aParentLayerDXFLineInfo.eStyle = LINE_SOLID;
+ aParentLayerDXFLineInfo.fWidth = 0;
+ aParentLayerDXFLineInfo.nDashCount = 0;
+ aParentLayerDXFLineInfo.fDashLen = 0;
+ aParentLayerDXFLineInfo.nDotCount = 0;
+ aParentLayerDXFLineInfo.fDotLen = 0;
+ aParentLayerDXFLineInfo.fDistance = 0;
+ }
+
+ pVirDev->EnableOutput(FALSE);
+ rMTF.Record(pVirDev);
+
+ aActLineColor = pVirDev->GetLineColor();
+ aActFillColor = pVirDev->GetFillColor();
+ aActFont = pVirDev->GetFont();
+
+ pVPort=pDXF->aTables.SearchVPort("*ACTIVE");
+ if (pVPort!=NULL) {
+ if (pVPort->aDirection.fx==0 && pVPort->aDirection.fy==0)
+ pVPort=NULL;
+ }
+
+ if (pVPort==NULL) {
+ if (pDXF->aBoundingBox.bEmpty==TRUE)
+ bStatus=FALSE;
+ else {
+ fWidth=pDXF->aBoundingBox.fMaxX-pDXF->aBoundingBox.fMinX;
+ fHeight=pDXF->aBoundingBox.fMaxY-pDXF->aBoundingBox.fMinY;
+ if (fWidth<=0 || fHeight<=0) {
+ bStatus=FALSE;
+ fScale = 0; // -Wall added this...
+ }
+ else {
+// if (fWidth<500.0 || fHeight<500.0 || fWidth>32767.0 || fHeight>32767.0) {
+ if (fWidth>fHeight)
+ fScale=10000.0/fWidth;
+ else
+ fScale=10000.0/fHeight;
+// }
+// else
+// fScale=1.0;
+ aTransform=DXFTransform(fScale,-fScale,fScale,
+ DXFVector(-pDXF->aBoundingBox.fMinX*fScale,
+ pDXF->aBoundingBox.fMaxY*fScale,
+ -pDXF->aBoundingBox.fMinZ*fScale));
+ }
+ aPrefSize.Width() =(long)(fWidth*fScale+1.5);
+ aPrefSize.Height()=(long)(fHeight*fScale+1.5);
+ }
+ }
+ else {
+ fHeight=pVPort->fHeight;
+ fWidth=fHeight*pVPort->fAspectRatio;
+// if (fWidth<500.0 || fHeight<500.0 || fWidth>32767.0 || fHeight>32767.0) {
+ if (fWidth>fHeight)
+ fScale=10000.0/fWidth;
+ else
+ fScale=10000.0/fHeight;
+// }
+// else
+// fScale=1.0;
+ aTransform=DXFTransform(
+ DXFTransform(pVPort->aDirection,pVPort->aTarget),
+ DXFTransform(
+ DXFTransform(1.0,-1.0,1.0,DXFVector(fWidth/2-pVPort->fCenterX,fHeight/2+pVPort->fCenterY,0)),
+ DXFTransform(fScale,fScale,fScale,DXFVector(0,0,0))
+ )
+ );
+ aPrefSize.Width() =(long)(fWidth*fScale+1.5);
+ aPrefSize.Height()=(long)(fHeight*fScale+1.5);
+ }
+
+ if (bStatus==TRUE)
+ DrawEntities(pDXF->aEntities,aTransform,TRUE);
+
+ rMTF.Stop();
+
+ if ( bStatus==TRUE )
+ {
+ rMTF.SetPrefSize( aPrefSize );
+
+ // MapMode einfach, falls Grafik dann nicht zu klein wird (<0,5cm),
+ // auf 1/100-mm (1/10-mm) setzen
+ if( ( aPrefSize.Width() < 500 ) && ( aPrefSize.Height() < 500 ) )
+ rMTF.SetPrefMapMode( MapMode( MAP_10TH_MM ) );
+ else
+ rMTF.SetPrefMapMode( MapMode( MAP_100TH_MM ) );
+ }
+
+ delete pVirDev;
+ return bStatus;
+}
+
+
+
diff --git a/filter/source/graphicfilter/idxf/dxf2mtf.hxx b/filter/source/graphicfilter/idxf/dxf2mtf.hxx
new file mode 100644
index 000000000000..cb03c47429fc
--- /dev/null
+++ b/filter/source/graphicfilter/idxf/dxf2mtf.hxx
@@ -0,0 +1,128 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+#ifndef _DXF2MTF_HXX
+#define _DXF2MTF_HXX
+
+#include "dxfreprd.hxx"
+#include <vcl/font.hxx>
+#include <vcl/lineinfo.hxx>
+
+// MT: NOOLDSV, someone should change the code...
+enum PenStyle { PEN_NULL, PEN_SOLID, PEN_DOT, PEN_DASH, PEN_DASHDOT };
+enum BrushStyle { BRUSH_NULL, BRUSH_SOLID, BRUSH_HORZ, BRUSH_VERT,
+ BRUSH_CROSS, BRUSH_DIAGCROSS, BRUSH_UPDIAG, BRUSH_DOWNDIAG,
+ BRUSH_25, BRUSH_50, BRUSH_75,
+ BRUSH_BITMAP };
+
+
+class DXF2GDIMetaFile {
+private:
+
+ VirtualDevice * pVirDev;
+ const DXFRepresentation * pDXF;
+ BOOL bStatus;
+
+ USHORT OptPointsPerCircle;
+
+ ULONG nMinPercent;
+ ULONG nMaxPercent;
+ ULONG nLastPercent;
+ ULONG nMainEntitiesCount;
+
+ long nBlockColor;
+ DXFLineInfo aBlockDXFLineInfo;
+ long nParentLayerColor;
+ DXFLineInfo aParentLayerDXFLineInfo;
+ Color aActLineColor;
+ Color aActFillColor;
+ Font aActFont;
+
+ ULONG CountEntities(const DXFEntities & rEntities);
+
+ void MayCallback(ULONG nMainEntitiesProcessed);
+
+ Color ConvertColor(BYTE nColor);
+
+ long GetEntityColor(const DXFBasicEntity & rE);
+
+ DXFLineInfo LTypeToDXFLineInfo(const char * sLineType);
+
+ DXFLineInfo GetEntityDXFLineInfo(const DXFBasicEntity & rE);
+
+ BOOL SetLineAttribute(const DXFBasicEntity & rE, ULONG nWidth=0);
+
+ BOOL SetAreaAttribute(const DXFBasicEntity & rE);
+
+ BOOL SetFontAttribute(const DXFBasicEntity & rE, short nAngle,
+ USHORT nHeight, double fWidthScale);
+
+ void DrawLineEntity(const DXFLineEntity & rE, const DXFTransform & rTransform);
+
+ void DrawPointEntity(const DXFPointEntity & rE, const DXFTransform & rTransform);
+
+ void DrawCircleEntity(const DXFCircleEntity & rE, const DXFTransform & rTransform);
+
+ void DrawArcEntity(const DXFArcEntity & rE, const DXFTransform & rTransform);
+
+ void DrawTraceEntity(const DXFTraceEntity & rE, const DXFTransform & rTransform);
+
+ void DrawSolidEntity(const DXFSolidEntity & rE, const DXFTransform & rTransform);
+
+ void DrawTextEntity(const DXFTextEntity & rE, const DXFTransform & rTransform);
+
+ void DrawInsertEntity(const DXFInsertEntity & rE, const DXFTransform & rTransform);
+
+ void DrawAttribEntity(const DXFAttribEntity & rE, const DXFTransform & rTransform);
+
+ void DrawPolyLineEntity(const DXFPolyLineEntity & rE, const DXFTransform & rTransform);
+
+ void Draw3DFaceEntity(const DXF3DFaceEntity & rE, const DXFTransform & rTransform);
+
+ void DrawDimensionEntity(const DXFDimensionEntity & rE, const DXFTransform & rTransform);
+
+ void DrawLWPolyLineEntity( const DXFLWPolyLineEntity & rE, const DXFTransform & rTransform );
+
+ void DrawHatchEntity( const DXFHatchEntity & rE, const DXFTransform & rTransform );
+
+ void DrawEntities(const DXFEntities & rEntities,
+ const DXFTransform & rTransform,
+ BOOL bTopEntities);
+
+public:
+
+ DXF2GDIMetaFile();
+ ~DXF2GDIMetaFile();
+
+ BOOL Convert( const DXFRepresentation & rDXF, GDIMetaFile & rMTF, USHORT nMinPercent, USHORT nMaxPercent);
+
+};
+
+
+#endif
+
+
diff --git a/filter/source/graphicfilter/idxf/dxfblkrd.cxx b/filter/source/graphicfilter/idxf/dxfblkrd.cxx
new file mode 100644
index 000000000000..da7753615bf3
--- /dev/null
+++ b/filter/source/graphicfilter/idxf/dxfblkrd.cxx
@@ -0,0 +1,139 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_filter.hxx"
+
+#include <string.h>
+#include <dxfblkrd.hxx>
+
+
+//----------------------------------------------------------------------------
+//---------------- DXFBlock --------------------------------------------------
+//----------------------------------------------------------------------------
+
+
+DXFBlock::DXFBlock()
+{
+ pSucc=NULL;
+}
+
+
+DXFBlock::~DXFBlock()
+{
+}
+
+
+void DXFBlock::Read(DXFGroupReader & rDGR)
+{
+ sName[0]=0;
+ sAlsoName[0]=0;
+ aBasePoint.fx=0.0;
+ aBasePoint.fy=0.0;
+ aBasePoint.fz=0.0;
+ nFlags=0;
+ sXRef[0]=0;
+
+ while (rDGR.Read()!=0)
+ {
+ switch (rDGR.GetG())
+ {
+ case 2: strncpy( sName, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 3: strncpy( sAlsoName, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 70: nFlags=rDGR.GetI(); break;
+ case 10: aBasePoint.fx=rDGR.GetF(); break;
+ case 20: aBasePoint.fy=rDGR.GetF(); break;
+ case 30: aBasePoint.fz=rDGR.GetF(); break;
+ case 1: strncpy( sXRef, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ }
+ }
+ DXFEntities::Read(rDGR);
+}
+
+
+//----------------------------------------------------------------------------
+//---------------- DXFBlocks -------------------------------------------------
+//----------------------------------------------------------------------------
+
+
+DXFBlocks::DXFBlocks()
+{
+ pFirst=NULL;
+}
+
+
+DXFBlocks::~DXFBlocks()
+{
+ Clear();
+}
+
+
+void DXFBlocks::Read(DXFGroupReader & rDGR)
+{
+ DXFBlock * pB, * * ppSucc;
+
+ ppSucc=&pFirst;
+ while (*ppSucc!=NULL) ppSucc=&((*ppSucc)->pSucc);
+
+ for (;;) {
+ while (rDGR.GetG()!=0) rDGR.Read();
+ if (strcmp(rDGR.GetS(),"ENDSEC")==0 ||
+ strcmp(rDGR.GetS(),"EOF")==0) break;
+ if (strcmp(rDGR.GetS(),"BLOCK")==0) {
+ pB=new DXFBlock;
+ pB->Read(rDGR);
+ *ppSucc=pB;
+ ppSucc=&(pB->pSucc);
+ }
+ else rDGR.Read();
+ }
+}
+
+
+DXFBlock * DXFBlocks::Search(const char * sName) const
+{
+ DXFBlock * pB;
+ for (pB=pFirst; pB!=NULL; pB=pB->pSucc) {
+ if (strcmp(sName,pB->sName)==0) break;
+ }
+ return pB;
+}
+
+
+void DXFBlocks::Clear()
+{
+ DXFBlock * ptmp;
+
+ while (pFirst!=NULL) {
+ ptmp=pFirst;
+ pFirst=ptmp->pSucc;
+ delete ptmp;
+ }
+}
+
+
+
diff --git a/filter/source/graphicfilter/idxf/dxfblkrd.hxx b/filter/source/graphicfilter/idxf/dxfblkrd.hxx
new file mode 100644
index 000000000000..9f0d92e3fa6d
--- /dev/null
+++ b/filter/source/graphicfilter/idxf/dxfblkrd.hxx
@@ -0,0 +1,87 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+#ifndef _DXFBLKRD_HXX
+#define _DXFBLKRD_HXX
+
+#include <dxfentrd.hxx>
+
+//----------------------------------------------------------------------------
+//---------------- Ein Block (= Menge von Entities) --------------------------
+//----------------------------------------------------------------------------
+
+class DXFBlock : public DXFEntities {
+
+public:
+
+ DXFBlock * pSucc;
+ // Zeiger auf naechsten Block in der Liste DXFBlocks::pFirst
+
+ // Eigenschaften des Blocks, durch Gruppencodes kommentiert:
+ char sName[DXF_MAX_STRING_LEN+1]; // 2
+ char sAlsoName[DXF_MAX_STRING_LEN+1]; // 3
+ long nFlags; // 70
+ DXFVector aBasePoint; // 10,20,30
+ char sXRef[DXF_MAX_STRING_LEN+1]; // 1
+
+ DXFBlock();
+ ~DXFBlock();
+
+ void Read(DXFGroupReader & rDGR);
+ // Liest den Block (einschliesslich der Entities) per rGDR
+ // aus einer DXF-Datei bis zu einem ENDBLK, ENDSEC oder EOF.
+};
+
+
+//----------------------------------------------------------------------------
+//---------------- Eine Menge von Bloecken -----------------------------------
+//----------------------------------------------------------------------------
+
+class DXFBlocks {
+
+public:
+
+ DXFBlock * pFirst;
+ // Liste der Bloecke, READ ONLY!
+
+ DXFBlocks();
+ ~DXFBlocks();
+
+ void Read(DXFGroupReader & rDGR);
+ // Liesst alle Bloecke per rDGR bis zu einem ENDSEC oder EOF.
+
+ DXFBlock * Search(const char * sName) const;
+ // Sucht einen Block mit dem Namen, liefert NULL bei Misserfolg.
+
+ void Clear();
+ // Loescht alle Bloecke;
+
+};
+
+#endif
+
+
diff --git a/filter/source/graphicfilter/idxf/dxfentrd.cxx b/filter/source/graphicfilter/idxf/dxfentrd.cxx
new file mode 100644
index 000000000000..990594a90731
--- /dev/null
+++ b/filter/source/graphicfilter/idxf/dxfentrd.cxx
@@ -0,0 +1,871 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_filter.hxx"
+
+#include <string.h>
+#include <dxfentrd.hxx>
+
+//--------------------------DXFBasicEntity--------------------------------------
+
+DXFBasicEntity::DXFBasicEntity(DXFEntityType eThisType)
+{
+ eType=eThisType;
+ pSucc=NULL;
+ strncpy(sLayer,"0", 2 );
+ strncpy(sLineType,"BYLAYER", 8 );
+ fElevation=0;
+ fThickness=0;
+ nColor=256;
+ nSpace=0;
+ aExtrusion.fx=0.0;
+ aExtrusion.fy=0.0;
+ aExtrusion.fz=1.0;
+}
+
+void DXFBasicEntity::Read(DXFGroupReader & rDGR)
+{
+ while (rDGR.Read()!=0) EvaluateGroup(rDGR);
+}
+
+void DXFBasicEntity::EvaluateGroup(DXFGroupReader & rDGR)
+{
+ switch (rDGR.GetG())
+ {
+ case 8: strncpy( sLayer, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 6: strncpy( sLineType, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 38: fElevation=rDGR.GetF(); break;
+ case 39: fThickness=rDGR.GetF(); break;
+ case 62: nColor=rDGR.GetI(); break;
+ case 67: nSpace=rDGR.GetI(); break;
+ case 210: aExtrusion.fx=rDGR.GetF(); break;
+ case 220: aExtrusion.fy=rDGR.GetF(); break;
+ case 230: aExtrusion.fz=rDGR.GetF(); break;
+ }
+}
+
+DXFBasicEntity::~DXFBasicEntity()
+{
+}
+
+//--------------------------DXFLineEntity---------------------------------------
+
+DXFLineEntity::DXFLineEntity() : DXFBasicEntity(DXF_LINE)
+{
+}
+
+void DXFLineEntity::EvaluateGroup(DXFGroupReader & rDGR)
+{
+ switch (rDGR.GetG()) {
+ case 10: aP0.fx=rDGR.GetF(); break;
+ case 20: aP0.fy=rDGR.GetF(); break;
+ case 30: aP0.fz=rDGR.GetF(); break;
+ case 11: aP1.fx=rDGR.GetF(); break;
+ case 21: aP1.fy=rDGR.GetF(); break;
+ case 31: aP1.fz=rDGR.GetF(); break;
+ default: DXFBasicEntity::EvaluateGroup(rDGR);
+ }
+}
+
+//--------------------------DXFPointEntity--------------------------------------
+
+DXFPointEntity::DXFPointEntity() : DXFBasicEntity(DXF_POINT)
+{
+}
+
+void DXFPointEntity::EvaluateGroup(DXFGroupReader & rDGR)
+{
+ switch (rDGR.GetG()) {
+ case 10: aP0.fx=rDGR.GetF(); break;
+ case 20: aP0.fy=rDGR.GetF(); break;
+ case 30: aP0.fz=rDGR.GetF(); break;
+ default: DXFBasicEntity::EvaluateGroup(rDGR);
+ }
+}
+
+//--------------------------DXFCircleEntity-------------------------------------
+
+DXFCircleEntity::DXFCircleEntity() : DXFBasicEntity(DXF_CIRCLE)
+{
+ fRadius=1.0;
+}
+
+void DXFCircleEntity::EvaluateGroup(DXFGroupReader & rDGR)
+{
+ switch (rDGR.GetG()) {
+ case 10: aP0.fx=rDGR.GetF(); break;
+ case 20: aP0.fy=rDGR.GetF(); break;
+ case 30: aP0.fz=rDGR.GetF(); break;
+ case 40: fRadius=rDGR.GetF(); break;
+ default: DXFBasicEntity::EvaluateGroup(rDGR);
+ }
+}
+
+//--------------------------DXFArcEntity----------------------------------------
+
+DXFArcEntity::DXFArcEntity() : DXFBasicEntity(DXF_ARC)
+{
+ fRadius=1.0;
+ fStart=0;
+ fEnd=360.0;
+}
+
+void DXFArcEntity::EvaluateGroup(DXFGroupReader & rDGR)
+{
+ switch (rDGR.GetG()) {
+ case 10: aP0.fx=rDGR.GetF(); break;
+ case 20: aP0.fy=rDGR.GetF(); break;
+ case 30: aP0.fz=rDGR.GetF(); break;
+ case 40: fRadius=rDGR.GetF(); break;
+ case 50: fStart=rDGR.GetF(); break;
+ case 51: fEnd=rDGR.GetF(); break;
+ default: DXFBasicEntity::EvaluateGroup(rDGR);
+ }
+}
+
+//--------------------------DXFTraceEntity--------------------------------------
+
+DXFTraceEntity::DXFTraceEntity() : DXFBasicEntity(DXF_TRACE)
+{
+}
+
+void DXFTraceEntity::EvaluateGroup(DXFGroupReader & rDGR)
+{
+ switch (rDGR.GetG()) {
+ case 10: aP0.fx=rDGR.GetF(); break;
+ case 20: aP0.fy=rDGR.GetF(); break;
+ case 30: aP0.fz=rDGR.GetF(); break;
+ case 11: aP1.fx=rDGR.GetF(); break;
+ case 21: aP1.fy=rDGR.GetF(); break;
+ case 31: aP1.fz=rDGR.GetF(); break;
+ case 12: aP2.fx=rDGR.GetF(); break;
+ case 22: aP2.fy=rDGR.GetF(); break;
+ case 32: aP2.fz=rDGR.GetF(); break;
+ case 13: aP3.fx=rDGR.GetF(); break;
+ case 23: aP3.fy=rDGR.GetF(); break;
+ case 33: aP3.fz=rDGR.GetF(); break;
+ default: DXFBasicEntity::EvaluateGroup(rDGR);
+ }
+}
+
+//--------------------------DXFSolidEntity--------------------------------------
+
+DXFSolidEntity::DXFSolidEntity() : DXFBasicEntity(DXF_SOLID)
+{
+}
+
+void DXFSolidEntity::EvaluateGroup(DXFGroupReader & rDGR)
+{
+ switch (rDGR.GetG()) {
+ case 10: aP0.fx=rDGR.GetF(); break;
+ case 20: aP0.fy=rDGR.GetF(); break;
+ case 30: aP0.fz=rDGR.GetF(); break;
+ case 11: aP1.fx=rDGR.GetF(); break;
+ case 21: aP1.fy=rDGR.GetF(); break;
+ case 31: aP1.fz=rDGR.GetF(); break;
+ case 12: aP2.fx=rDGR.GetF(); break;
+ case 22: aP2.fy=rDGR.GetF(); break;
+ case 32: aP2.fz=rDGR.GetF(); break;
+ case 13: aP3.fx=rDGR.GetF(); break;
+ case 23: aP3.fy=rDGR.GetF(); break;
+ case 33: aP3.fz=rDGR.GetF(); break;
+ default: DXFBasicEntity::EvaluateGroup(rDGR);
+ }
+}
+
+//--------------------------DXFTextEntity---------------------------------------
+
+DXFTextEntity::DXFTextEntity() : DXFBasicEntity(DXF_TEXT)
+{
+ fHeight=1.0;
+ sText[0]=0;
+ fRotAngle=0.0;
+ fXScale=1.0;
+ fOblAngle=0.0;
+ strncpy( sStyle, "STANDARD", 9 );
+ nGenFlags=0;
+ nHorzJust=0;
+ nVertJust=0;
+}
+
+void DXFTextEntity::EvaluateGroup(DXFGroupReader & rDGR)
+{
+ switch (rDGR.GetG()) {
+ case 10: aP0.fx=rDGR.GetF(); break;
+ case 20: aP0.fy=rDGR.GetF(); break;
+ case 30: aP0.fz=rDGR.GetF(); break;
+ case 40: fHeight=rDGR.GetF(); break;
+ case 1: strncpy( sText, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 50: fRotAngle=rDGR.GetF(); break;
+ case 41: fXScale=rDGR.GetF(); break;
+ case 42: fOblAngle=rDGR.GetF(); break;
+ case 7: strncpy( sStyle, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 71: nGenFlags=rDGR.GetI(); break;
+ case 72: nHorzJust=rDGR.GetI(); break;
+ case 73: nVertJust=rDGR.GetI(); break;
+ case 11: aAlign.fx=rDGR.GetF(); break;
+ case 21: aAlign.fy=rDGR.GetF(); break;
+ case 31: aAlign.fz=rDGR.GetF(); break;
+ default: DXFBasicEntity::EvaluateGroup(rDGR);
+ }
+}
+
+//--------------------------DXFShapeEntity--------------------------------------
+
+DXFShapeEntity::DXFShapeEntity() : DXFBasicEntity(DXF_SHAPE)
+{
+ fSize=1.0;
+ sName[0]=0;
+ fRotAngle=0;
+ fXScale=1.0;
+ fOblAngle=0;
+}
+
+void DXFShapeEntity::EvaluateGroup(DXFGroupReader & rDGR)
+{
+ switch (rDGR.GetG()) {
+ case 10: aP0.fx=rDGR.GetF(); break;
+ case 20: aP0.fy=rDGR.GetF(); break;
+ case 30: aP0.fz=rDGR.GetF(); break;
+ case 40: fSize=rDGR.GetF(); break;
+ case 2: strncpy( sName, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 50: fRotAngle=rDGR.GetF(); break;
+ case 41: fXScale=rDGR.GetF(); break;
+ case 51: fOblAngle=rDGR.GetF(); break;
+ default: DXFBasicEntity::EvaluateGroup(rDGR);
+ }
+}
+
+//--------------------------DXFInsertEntity-------------------------------------
+
+DXFInsertEntity::DXFInsertEntity() : DXFBasicEntity(DXF_INSERT)
+{
+ nAttrFlag=0;
+ sName[0]=0;
+ fXScale=1.0;
+ fYScale=1.0;
+ fZScale=1.0;
+ fRotAngle=0.0;
+ nColCount=1;
+ nRowCount=1;
+ fColSpace=0.0;
+ fRowSpace=0.0;
+}
+
+void DXFInsertEntity::EvaluateGroup(DXFGroupReader & rDGR)
+{
+ switch (rDGR.GetG()) {
+ case 66: nAttrFlag=rDGR.GetI(); break;
+ case 2: strncpy( sName, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 10: aP0.fx=rDGR.GetF(); break;
+ case 20: aP0.fy=rDGR.GetF(); break;
+ case 30: aP0.fz=rDGR.GetF(); break;
+ case 41: fXScale=rDGR.GetF(); break;
+ case 42: fYScale=rDGR.GetF(); break;
+ case 43: fZScale=rDGR.GetF(); break;
+ case 50: fRotAngle=rDGR.GetF(); break;
+ case 70: nColCount=rDGR.GetI(); break;
+ case 71: nRowCount=rDGR.GetI(); break;
+ case 44: fColSpace=rDGR.GetF(); break;
+ case 45: fRowSpace=rDGR.GetF(); break;
+ default: DXFBasicEntity::EvaluateGroup(rDGR);
+ }
+}
+
+//--------------------------DXFAttDefEntity-------------------------------------
+
+DXFAttDefEntity::DXFAttDefEntity() : DXFBasicEntity(DXF_ATTDEF)
+{
+ fHeight=1.0;
+ sDefVal[0]=0;
+ sPrompt[0]=0;
+ sTagStr[0]=0;
+ nAttrFlags=0;
+ nFieldLen=0;
+ fRotAngle=0.0;
+ fXScale=1.0;
+ fOblAngle=0.0;
+ strncpy( sStyle, "STANDARD", 9 );
+ nGenFlags=0;
+ nHorzJust=0;
+ nVertJust=0;
+}
+
+void DXFAttDefEntity::EvaluateGroup(DXFGroupReader & rDGR)
+{
+ switch (rDGR.GetG()) {
+ case 10: aP0.fx=rDGR.GetF(); break;
+ case 20: aP0.fy=rDGR.GetF(); break;
+ case 30: aP0.fz=rDGR.GetF(); break;
+ case 40: fHeight=rDGR.GetF(); break;
+ case 1: strncpy( sDefVal, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 3: strncpy( sPrompt, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 2: strncpy( sTagStr, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 70: nAttrFlags=rDGR.GetI(); break;
+ case 73: nFieldLen=rDGR.GetI(); break;
+ case 50: fRotAngle=rDGR.GetF(); break;
+ case 41: fXScale=rDGR.GetF(); break;
+ case 51: fOblAngle=rDGR.GetF(); break;
+ case 7: strncpy( sStyle, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 71: nGenFlags=rDGR.GetI(); break;
+ case 72: nHorzJust=rDGR.GetI(); break;
+ case 74: nVertJust=rDGR.GetI(); break;
+ case 11: aAlign.fx=rDGR.GetF(); break;
+ case 21: aAlign.fy=rDGR.GetF(); break;
+ case 31: aAlign.fz=rDGR.GetF(); break;
+ default: DXFBasicEntity::EvaluateGroup(rDGR);
+ }
+}
+
+//--------------------------DXFAttribEntity-------------------------------------
+
+DXFAttribEntity::DXFAttribEntity() : DXFBasicEntity(DXF_ATTRIB)
+{
+ fHeight=1.0;
+ sText[0]=0;
+ sTagStr[0]=0;
+ nAttrFlags=0;
+ nFieldLen=0;
+ fRotAngle=0.0;
+ fXScale=1.0;
+ fOblAngle=0.0;
+ strncpy( sStyle, "STANDARD", 9 );
+ nGenFlags=0;
+ nHorzJust=0;
+ nVertJust=0;
+}
+
+void DXFAttribEntity::EvaluateGroup(DXFGroupReader & rDGR)
+{
+ switch (rDGR.GetG()) {
+ case 10: aP0.fx=rDGR.GetF(); break;
+ case 20: aP0.fy=rDGR.GetF(); break;
+ case 30: aP0.fz=rDGR.GetF(); break;
+ case 40: fHeight=rDGR.GetF(); break;
+ case 1: strncpy( sText, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 2: strncpy( sTagStr, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 70: nAttrFlags=rDGR.GetI(); break;
+ case 73: nFieldLen=rDGR.GetI(); break;
+ case 50: fRotAngle=rDGR.GetF(); break;
+ case 41: fXScale=rDGR.GetF(); break;
+ case 51: fOblAngle=rDGR.GetF(); break;
+ case 7: strncpy( sStyle, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 71: nGenFlags=rDGR.GetI(); break;
+ case 72: nHorzJust=rDGR.GetI(); break;
+ case 74: nVertJust=rDGR.GetI(); break;
+ case 11: aAlign.fx=rDGR.GetF(); break;
+ case 21: aAlign.fy=rDGR.GetF(); break;
+ case 31: aAlign.fz=rDGR.GetF(); break;
+ default: DXFBasicEntity::EvaluateGroup(rDGR);
+ }
+}
+
+//--------------------------DXFPolyLine-----------------------------------------
+
+DXFPolyLineEntity::DXFPolyLineEntity() : DXFBasicEntity(DXF_POLYLINE)
+{
+ fElevation=0.0;
+ nFlags=0;
+ fSWidth=0.0;
+ fEWidth=0.0;
+ nMeshMCount=0;
+ nMeshNCount=0;
+ nMDensity=0;
+ nNDensity=0;
+ nCSSType=0;
+}
+
+void DXFPolyLineEntity::EvaluateGroup(DXFGroupReader & rDGR)
+{
+ switch (rDGR.GetG()) {
+ case 30: fElevation=rDGR.GetF(); break;
+ case 70: nFlags=rDGR.GetI(); break;
+ case 40: fSWidth=rDGR.GetF(); break;
+ case 41: fEWidth=rDGR.GetF(); break;
+ case 71: nMeshMCount=rDGR.GetI(); break;
+ case 72: nMeshNCount=rDGR.GetI(); break;
+ case 73: nMDensity=rDGR.GetI(); break;
+ case 74: nNDensity=rDGR.GetI(); break;
+ case 75: nCSSType=rDGR.GetI(); break;
+ default: DXFBasicEntity::EvaluateGroup(rDGR);
+ }
+}
+
+//--------------------------DXFLWPolyLine---------------------------------------
+
+DXFLWPolyLineEntity::DXFLWPolyLineEntity() :
+ DXFBasicEntity( DXF_LWPOLYLINE ),
+ nIndex( 0 ),
+ nCount( 0 ),
+ nFlags( 0 ),
+ fConstantWidth( 0.0 ),
+ fStartWidth( 0.0 ),
+ fEndWidth( 0.0 ),
+ pP( NULL )
+{
+}
+
+void DXFLWPolyLineEntity::EvaluateGroup( DXFGroupReader & rDGR )
+{
+ switch ( rDGR.GetG() )
+ {
+ case 90 :
+ {
+ nCount = rDGR.GetI();
+ if ( nCount )
+ pP = new DXFVector[ nCount ];
+ }
+ break;
+ case 70: nFlags = rDGR.GetI(); break;
+ case 43: fConstantWidth = rDGR.GetF(); break;
+ case 40: fStartWidth = rDGR.GetF(); break;
+ case 41: fEndWidth = rDGR.GetF(); break;
+ case 10:
+ {
+ if ( pP && ( nIndex < nCount ) )
+ pP[ nIndex ].fx = rDGR.GetF();
+ }
+ break;
+ case 20:
+ {
+ if ( pP && ( nIndex < nCount ) )
+ pP[ nIndex++ ].fy = rDGR.GetF();
+ }
+ break;
+ default: DXFBasicEntity::EvaluateGroup(rDGR);
+ }
+}
+
+DXFLWPolyLineEntity::~DXFLWPolyLineEntity()
+{
+ delete[] pP;
+}
+
+//--------------------------DXFHatchEntity-------------------------------------
+
+DXFEdgeTypeLine::DXFEdgeTypeLine() :
+ DXFEdgeType( 1 )
+{
+
+}
+DXFEdgeTypeLine::~DXFEdgeTypeLine()
+{
+
+}
+sal_Bool DXFEdgeTypeLine::EvaluateGroup( DXFGroupReader & rDGR )
+{
+ sal_Bool bExecutingGroupCode = sal_True;
+ switch ( rDGR.GetG() )
+ {
+ case 10 : aStartPoint.fx = rDGR.GetF(); break;
+ case 20 : aStartPoint.fy = rDGR.GetF(); break;
+ case 11 : aEndPoint.fx = rDGR.GetF(); break;
+ case 21 : aEndPoint.fy = rDGR.GetF(); break;
+ default : bExecutingGroupCode = sal_False; break;
+ }
+ return bExecutingGroupCode;
+}
+
+DXFEdgeTypeCircularArc::DXFEdgeTypeCircularArc() :
+ DXFEdgeType( 2 ),
+ fRadius( 0.0 ),
+ fStartAngle( 0.0 ),
+ fEndAngle( 0.0 ),
+ nIsCounterClockwiseFlag( 0 )
+{
+}
+DXFEdgeTypeCircularArc::~DXFEdgeTypeCircularArc()
+{
+}
+sal_Bool DXFEdgeTypeCircularArc::EvaluateGroup( DXFGroupReader & rDGR )
+{
+ sal_Bool bExecutingGroupCode = sal_True;
+ switch ( rDGR.GetG() )
+ {
+ case 10 : aCenter.fx = rDGR.GetF(); break;
+ case 20 : aCenter.fy = rDGR.GetF(); break;
+ case 40 : fRadius = rDGR.GetF(); break;
+ case 50 : fStartAngle = rDGR.GetF(); break;
+ case 51 : fEndAngle = rDGR.GetF(); break;
+ case 73 : nIsCounterClockwiseFlag = rDGR.GetI(); break;
+ default : bExecutingGroupCode = sal_False; break;
+ }
+ return bExecutingGroupCode;
+}
+
+DXFEdgeTypeEllipticalArc::DXFEdgeTypeEllipticalArc() :
+ DXFEdgeType( 3 ),
+ fLength( 0.0 ),
+ fStartAngle( 0.0 ),
+ fEndAngle( 0.0 ),
+ nIsCounterClockwiseFlag( 0 )
+{
+}
+DXFEdgeTypeEllipticalArc::~DXFEdgeTypeEllipticalArc()
+{
+
+}
+sal_Bool DXFEdgeTypeEllipticalArc::EvaluateGroup( DXFGroupReader & rDGR )
+{
+ sal_Bool bExecutingGroupCode = sal_True;
+ switch( rDGR.GetG() )
+ {
+ case 10 : aCenter.fx = rDGR.GetF(); break;
+ case 20 : aCenter.fy = rDGR.GetF(); break;
+ case 11 : aEndPoint.fx = rDGR.GetF(); break;
+ case 21 : aEndPoint.fy = rDGR.GetF(); break;
+ case 40 : fLength = rDGR.GetF(); break;
+ case 50 : fStartAngle = rDGR.GetF(); break;
+ case 51 : fEndAngle = rDGR.GetF(); break;
+ case 73 : nIsCounterClockwiseFlag = rDGR.GetI(); break;
+ default : bExecutingGroupCode = sal_False; break;
+ }
+ return bExecutingGroupCode;
+}
+
+DXFEdgeTypeSpline::DXFEdgeTypeSpline() :
+ DXFEdgeType( 4 ),
+ nDegree( 0 ),
+ nRational( 0 ),
+ nPeriodic( 0 ),
+ nKnotCount( 0 ),
+ nControlCount( 0 )
+{
+}
+DXFEdgeTypeSpline::~DXFEdgeTypeSpline()
+{
+
+}
+sal_Bool DXFEdgeTypeSpline::EvaluateGroup( DXFGroupReader & rDGR )
+{
+ sal_Bool bExecutingGroupCode = sal_True;
+ switch ( rDGR.GetG() )
+ {
+ case 94 : nDegree = rDGR.GetI(); break;
+ case 73 : nRational = rDGR.GetI(); break;
+ case 74 : nPeriodic = rDGR.GetI(); break;
+ case 95 : nKnotCount = rDGR.GetI(); break;
+ case 96 : nControlCount = rDGR.GetI(); break;
+ default : bExecutingGroupCode = sal_False; break;
+ }
+ return bExecutingGroupCode;
+}
+
+DXFBoundaryPathData::DXFBoundaryPathData() :
+ nFlags( 0 ),
+ nHasBulgeFlag( 0 ),
+ nIsClosedFlag( 0 ),
+ nPointCount( 0 ),
+ fBulge( 0.0 ),
+ nSourceBoundaryObjects( 0 ),
+ nEdgeCount( 0 ),
+ bIsPolyLine( sal_True ),
+ nPointIndex( 0 ),
+ pP( NULL )
+{
+}
+
+DXFBoundaryPathData::~DXFBoundaryPathData()
+{
+ sal_uInt32 i = 0;
+ for ( i = 0; i < aEdges.size(); i++ )
+ delete aEdges[ i ];
+ delete[] pP;
+}
+
+sal_Bool DXFBoundaryPathData::EvaluateGroup( DXFGroupReader & rDGR )
+{
+ sal_Bool bExecutingGroupCode = sal_True;
+ if ( bIsPolyLine )
+ {
+ switch( rDGR.GetG() )
+ {
+ case 92 :
+ {
+ nFlags = rDGR.GetI();
+ if ( ( nFlags & 2 ) == 0 )
+ bIsPolyLine = sal_False;
+ }
+ break;
+ case 93 :
+ {
+ nPointCount = rDGR.GetI();
+ if ( nPointCount )
+ pP = new DXFVector[ nPointCount ];
+ }
+ break;
+ case 72 : nHasBulgeFlag = rDGR.GetI(); break;
+ case 73 : nIsClosedFlag = rDGR.GetI(); break;
+ case 97 : nSourceBoundaryObjects = rDGR.GetI(); break;
+ case 42 : fBulge = rDGR.GetF(); break;
+ case 10:
+ {
+ if ( pP && ( nPointIndex < nPointCount ) )
+ pP[ nPointIndex ].fx = rDGR.GetF();
+ }
+ break;
+ case 20:
+ {
+ if ( pP && ( nPointIndex < nPointCount ) )
+ pP[ nPointIndex++ ].fy = rDGR.GetF();
+ }
+ break;
+
+ default : bExecutingGroupCode = sal_False; break;
+ }
+ }
+ else
+ {
+ if ( rDGR.GetG() == 93 )
+ nEdgeCount = rDGR.GetI();
+ else if ( rDGR.GetG() == 72 )
+ {
+ sal_Int32 nEdgeType = rDGR.GetI();
+ switch( nEdgeType )
+ {
+ case 1 : aEdges.push_back( new DXFEdgeTypeLine() ); break;
+ case 2 : aEdges.push_back( new DXFEdgeTypeCircularArc() ); break;
+ case 3 : aEdges.push_back( new DXFEdgeTypeEllipticalArc() ); break;
+ case 4 : aEdges.push_back( new DXFEdgeTypeSpline() ); break;
+ }
+ }
+ else if ( aEdges.size() )
+ aEdges[ aEdges.size() - 1 ]->EvaluateGroup( rDGR );
+ else
+ bExecutingGroupCode = sal_False;
+ }
+ return bExecutingGroupCode;
+}
+
+DXFHatchEntity::DXFHatchEntity() :
+ DXFBasicEntity( DXF_HATCH ),
+ bIsInBoundaryPathContext( sal_False ),
+ nCurrentBoundaryPathIndex( -1 ),
+ nFlags( 0 ),
+ nAssociativityFlag( 0 ),
+ nBoundaryPathCount( 0 ),
+ nHatchStyle( 0 ),
+ nHatchPatternType( 0 ),
+ fHatchPatternAngle( 0.0 ),
+ fHatchPatternScale( 1.0 ),
+ nHatchDoubleFlag( 0 ),
+ nHatchPatternDefinitionLines( 0 ),
+ fPixelSize( 1.0 ),
+ nNumberOfSeedPoints( 0 ),
+ pBoundaryPathData( NULL )
+{
+}
+
+void DXFHatchEntity::EvaluateGroup( DXFGroupReader & rDGR )
+{
+ switch ( rDGR.GetG() )
+ {
+// case 10 : aElevationPoint.fx = rDGR.GetF(); break;
+// case 20 : aElevationPoint.fy = rDGR.GetF(); break;
+// case 30 : aElevationPoint.fz = rDGR.GetF(); break;
+ case 70 : nFlags = rDGR.GetI(); break;
+ case 71 : nAssociativityFlag = rDGR.GetI(); break;
+ case 91 :
+ {
+ bIsInBoundaryPathContext = sal_True;
+ nBoundaryPathCount = rDGR.GetI();
+ if ( nBoundaryPathCount )
+ pBoundaryPathData = new DXFBoundaryPathData[ nBoundaryPathCount ];
+ }
+ break;
+ case 75 :
+ {
+ nHatchStyle = rDGR.GetI();
+ bIsInBoundaryPathContext = sal_False;
+ }
+ break;
+ case 76 : nHatchPatternType = rDGR.GetI(); break;
+ case 52 : fHatchPatternAngle = rDGR.GetF(); break;
+ case 41 : fHatchPatternScale = rDGR.GetF(); break;
+ case 77 : nHatchDoubleFlag = rDGR.GetI(); break;
+ case 78 : nHatchPatternDefinitionLines = rDGR.GetI(); break;
+ case 47 : fPixelSize = rDGR.GetF(); break;
+ case 98 : nNumberOfSeedPoints = rDGR.GetI(); break;
+
+ //!! passthrough !!
+ case 92 : nCurrentBoundaryPathIndex++;
+ default:
+ {
+ sal_Bool bExecutingGroupCode = sal_False;
+ if ( bIsInBoundaryPathContext )
+ {
+ if ( ( nCurrentBoundaryPathIndex >= 0 ) &&
+ ( nCurrentBoundaryPathIndex < nBoundaryPathCount ) )
+ bExecutingGroupCode = pBoundaryPathData[ nCurrentBoundaryPathIndex ].EvaluateGroup( rDGR );
+ }
+ if ( bExecutingGroupCode == sal_False )
+ DXFBasicEntity::EvaluateGroup(rDGR);
+ }
+ break;
+ }
+}
+
+DXFHatchEntity::~DXFHatchEntity()
+{
+ delete[] pBoundaryPathData;
+}
+
+//--------------------------DXFVertexEntity-------------------------------------
+
+DXFVertexEntity::DXFVertexEntity() : DXFBasicEntity(DXF_VERTEX)
+{
+ fSWidth=-1.0;
+ fEWidth=-1.0;
+ fBulge=0.0;
+ nFlags=0;
+ fCFTDir=0.0;
+
+}
+
+void DXFVertexEntity::EvaluateGroup(DXFGroupReader & rDGR)
+{
+ switch (rDGR.GetG()) {
+ case 10: aP0.fx=rDGR.GetF(); break;
+ case 20: aP0.fy=rDGR.GetF(); break;
+ case 30: aP0.fz=rDGR.GetF(); break;
+ case 40: fSWidth=rDGR.GetF(); break;
+ case 41: fEWidth=rDGR.GetF(); break;
+ case 42: fBulge=rDGR.GetF(); break;
+ case 70: nFlags=rDGR.GetI(); break;
+ case 50: fCFTDir=rDGR.GetF(); break;
+ default: DXFBasicEntity::EvaluateGroup(rDGR);
+ }
+}
+
+//--------------------------DXFSeqEndEntity-------------------------------------
+
+DXFSeqEndEntity::DXFSeqEndEntity() : DXFBasicEntity(DXF_SEQEND)
+{
+}
+
+//--------------------------DXF3DFace-------------------------------------------
+
+DXF3DFaceEntity::DXF3DFaceEntity() : DXFBasicEntity(DXF_3DFACE)
+{
+ nIEFlags=0;
+}
+
+void DXF3DFaceEntity::EvaluateGroup(DXFGroupReader & rDGR)
+{
+ switch (rDGR.GetG()) {
+ case 10: aP0.fx=rDGR.GetF(); break;
+ case 20: aP0.fy=rDGR.GetF(); break;
+ case 30: aP0.fz=rDGR.GetF(); break;
+ case 11: aP1.fx=rDGR.GetF(); break;
+ case 21: aP1.fy=rDGR.GetF(); break;
+ case 31: aP1.fz=rDGR.GetF(); break;
+ case 12: aP2.fx=rDGR.GetF(); break;
+ case 22: aP2.fy=rDGR.GetF(); break;
+ case 32: aP2.fz=rDGR.GetF(); break;
+ case 13: aP3.fx=rDGR.GetF(); break;
+ case 23: aP3.fy=rDGR.GetF(); break;
+ case 33: aP3.fz=rDGR.GetF(); break;
+ case 70: nIEFlags=rDGR.GetI(); break;
+ default: DXFBasicEntity::EvaluateGroup(rDGR);
+ }
+}
+
+
+//--------------------------DXFDimensionEntity----------------------------------
+
+DXFDimensionEntity::DXFDimensionEntity() : DXFBasicEntity(DXF_DIMENSION)
+{
+ sPseudoBlock[0]=0;
+}
+
+void DXFDimensionEntity::EvaluateGroup(DXFGroupReader & rDGR)
+{
+ switch (rDGR.GetG()) {
+ case 2: strncpy( sPseudoBlock, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ default: DXFBasicEntity::EvaluateGroup(rDGR);
+ }
+}
+
+//---------------------------- DXFEntites --------------------------------------
+
+void DXFEntities::Read(DXFGroupReader & rDGR)
+{
+ DXFBasicEntity * pE, * * ppSucc;
+
+ ppSucc=&pFirst;
+ while (*ppSucc!=NULL) ppSucc=&((*ppSucc)->pSucc);
+
+ while (rDGR.GetG()!=0) rDGR.Read();
+
+ while (strcmp(rDGR.GetS(),"ENDBLK")!=0 &&
+ strcmp(rDGR.GetS(),"ENDSEC")!=0 &&
+ strcmp(rDGR.GetS(),"EOF")!=0 )
+ {
+
+ if (strcmp(rDGR.GetS(),"LINE" )==0) pE=new DXFLineEntity;
+ else if (strcmp(rDGR.GetS(),"POINT" )==0) pE=new DXFPointEntity;
+ else if (strcmp(rDGR.GetS(),"CIRCLE" )==0) pE=new DXFCircleEntity;
+ else if (strcmp(rDGR.GetS(),"ARC" )==0) pE=new DXFArcEntity;
+ else if (strcmp(rDGR.GetS(),"TRACE" )==0) pE=new DXFTraceEntity;
+ else if (strcmp(rDGR.GetS(),"SOLID" )==0) pE=new DXFSolidEntity;
+ else if (strcmp(rDGR.GetS(),"TEXT" )==0) pE=new DXFTextEntity;
+ else if (strcmp(rDGR.GetS(),"SHAPE" )==0) pE=new DXFShapeEntity;
+ else if (strcmp(rDGR.GetS(),"INSERT" )==0) pE=new DXFInsertEntity;
+ else if (strcmp(rDGR.GetS(),"ATTDEF" )==0) pE=new DXFAttDefEntity;
+ else if (strcmp(rDGR.GetS(),"ATTRIB" )==0) pE=new DXFAttribEntity;
+ else if (strcmp(rDGR.GetS(),"POLYLINE" )==0) pE=new DXFPolyLineEntity;
+ else if (strcmp(rDGR.GetS(),"LWPOLYLINE")==0) pE=new DXFLWPolyLineEntity;
+ else if (strcmp(rDGR.GetS(),"VERTEX" )==0) pE=new DXFVertexEntity;
+ else if (strcmp(rDGR.GetS(),"SEQEND" )==0) pE=new DXFSeqEndEntity;
+ else if (strcmp(rDGR.GetS(),"3DFACE" )==0) pE=new DXF3DFaceEntity;
+ else if (strcmp(rDGR.GetS(),"DIMENSION" )==0) pE=new DXFDimensionEntity;
+ else if (strcmp(rDGR.GetS(),"HATCH" )==0) pE=new DXFHatchEntity;
+ else
+ {
+ do {
+ rDGR.Read();
+ } while (rDGR.GetG()!=0);
+ continue;
+ }
+ *ppSucc=pE;
+ ppSucc=&(pE->pSucc);
+ pE->Read(rDGR);
+ }
+}
+
+void DXFEntities::Clear()
+{
+ DXFBasicEntity * ptmp;
+
+ while (pFirst!=NULL) {
+ ptmp=pFirst;
+ pFirst=ptmp->pSucc;
+ delete ptmp;
+ }
+}
+
diff --git a/filter/source/graphicfilter/idxf/dxfentrd.hxx b/filter/source/graphicfilter/idxf/dxfentrd.hxx
new file mode 100644
index 000000000000..3ddcc8f3d7ea
--- /dev/null
+++ b/filter/source/graphicfilter/idxf/dxfentrd.hxx
@@ -0,0 +1,602 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+#ifndef _DXFENTRD_HXX
+#define _DXFENTRD_HXX
+
+#include <dxfgrprd.hxx>
+#include <dxfvec.hxx>
+
+#include <deque>
+
+typedef std::deque< Point > DXFPointArray;
+
+//------------------------------------------------------------------------------
+//------------------------- Art eines Entity -----------------------------------
+//------------------------------------------------------------------------------
+
+enum DXFEntityType {
+ DXF_LINE,
+ DXF_POINT,
+ DXF_CIRCLE,
+ DXF_ARC,
+ DXF_TRACE,
+ DXF_SOLID,
+ DXF_TEXT,
+ DXF_SHAPE,
+ DXF_INSERT,
+ DXF_ATTDEF,
+ DXF_ATTRIB,
+ DXF_POLYLINE,
+ DXF_VERTEX,
+ DXF_SEQEND,
+ DXF_3DFACE,
+ DXF_DIMENSION,
+ DXF_LWPOLYLINE,
+ DXF_HATCH
+};
+
+//------------------------------------------------------------------------------
+//---------------------- Basisklasse fuer ein Entity ---------------------------
+//------------------------------------------------------------------------------
+
+class DXFBasicEntity {
+
+public:
+
+ DXFBasicEntity * pSucc;
+ // Zeiger auf naechstes Entity (in der Liste DXFEntities.pFirst)
+
+ DXFEntityType eType;
+ // Art des Entitys (Linie oder Kreis oder was)
+
+ // Eigenschaftenm, die alle Entities besitzen, jeweils
+ // durch den Gruppencode kommentiert:
+ char sLayer[DXF_MAX_STRING_LEN+1]; // 8
+ char sLineType[DXF_MAX_STRING_LEN+1]; // 6
+ double fElevation; // 38
+ double fThickness; // 39
+ long nColor; // 62
+ long nSpace; // 67
+ DXFVector aExtrusion; // 210,220,230
+
+protected:
+
+ DXFBasicEntity(DXFEntityType eThisType);
+ // Konstruktoren der Entities initialiseren immer mit Defaultwerten.
+
+public:
+
+ virtual ~DXFBasicEntity();
+ virtual void Read(DXFGroupReader & rDGR);
+ // Liest die Prameter ein, bis zur naechten 0-Gruppe
+
+protected:
+
+ virtual void EvaluateGroup(DXFGroupReader & rDGR);
+ // Diese Methode wird durch Read() fuer jeden Parameter (bzw. fuer jede
+ // Gruppe) aufgerufen.
+ // Sofern der Gruppencode dem Entity bekannt ist, wird der entsprechende
+ // Parameter geholt.
+
+};
+
+//------------------------------------------------------------------------------
+//---------------- die verschiedenen Arten von Entyties ------------------------
+//------------------------------------------------------------------------------
+
+//--------------------------Line------------------------------------------------
+
+class DXFLineEntity : public DXFBasicEntity {
+
+public:
+
+ DXFVector aP0; // 10,20,30
+ DXFVector aP1; // 11,21,31
+
+ DXFLineEntity();
+
+protected:
+
+ virtual void EvaluateGroup(DXFGroupReader & rDGR);
+};
+
+//--------------------------Point-----------------------------------------------
+
+class DXFPointEntity : public DXFBasicEntity {
+
+public:
+
+ DXFVector aP0; // 10,20,30
+
+ DXFPointEntity();
+
+protected:
+
+ virtual void EvaluateGroup(DXFGroupReader & rDGR);
+};
+
+//--------------------------Circle----------------------------------------------
+
+class DXFCircleEntity : public DXFBasicEntity {
+
+public:
+
+ DXFVector aP0; // 10,20,30
+ double fRadius; // 40
+
+ DXFCircleEntity();
+
+protected:
+
+ virtual void EvaluateGroup(DXFGroupReader & rDGR);
+};
+
+//--------------------------Arc-------------------------------------------------
+
+class DXFArcEntity : public DXFBasicEntity {
+
+public:
+
+ DXFVector aP0; // 10,20,30
+ double fRadius; // 40
+ double fStart; // 50
+ double fEnd; // 51
+
+ DXFArcEntity();
+
+protected:
+
+ virtual void EvaluateGroup(DXFGroupReader & rDGR);
+};
+
+//--------------------------Trace-----------------------------------------------
+
+class DXFTraceEntity : public DXFBasicEntity {
+
+public:
+
+ DXFVector aP0; // 10,20,30
+ DXFVector aP1; // 11,21,31
+ DXFVector aP2; // 12,22,32
+ DXFVector aP3; // 13,23,33
+
+ DXFTraceEntity();
+
+protected:
+
+ virtual void EvaluateGroup(DXFGroupReader & rDGR);
+};
+
+//--------------------------Solid-----------------------------------------------
+
+class DXFSolidEntity : public DXFBasicEntity {
+
+public:
+
+ DXFVector aP0; // 10,20,30
+ DXFVector aP1; // 11,21,31
+ DXFVector aP2; // 12,22,32
+ DXFVector aP3; // 13,23,33
+
+ DXFSolidEntity();
+
+protected:
+
+ virtual void EvaluateGroup(DXFGroupReader & rDGR);
+};
+
+//--------------------------Text------------------------------------------------
+
+class DXFTextEntity : public DXFBasicEntity {
+
+public:
+
+ DXFVector aP0; // 10,20,30
+ double fHeight; // 40
+ char sText[DXF_MAX_STRING_LEN+1]; // 1
+ double fRotAngle; // 50
+ double fXScale; // 41
+ double fOblAngle; // 42
+ char sStyle[DXF_MAX_STRING_LEN+1]; // 7
+ long nGenFlags; // 71
+ long nHorzJust; // 72
+ long nVertJust; // 73
+ DXFVector aAlign; // 11,21,31
+
+ DXFTextEntity();
+
+protected:
+
+ virtual void EvaluateGroup(DXFGroupReader & rDGR);
+};
+
+//--------------------------Shape-----------------------------------------------
+
+class DXFShapeEntity : public DXFBasicEntity {
+
+public:
+
+ DXFVector aP0; // 10,20,30
+ double fSize; // 40
+ char sName[DXF_MAX_STRING_LEN+1]; // 2
+ double fRotAngle; // 50
+ double fXScale; // 41
+ double fOblAngle; // 51
+
+ DXFShapeEntity();
+
+protected:
+
+ virtual void EvaluateGroup(DXFGroupReader & rDGR);
+};
+
+//--------------------------Insert----------------------------------------------
+
+class DXFInsertEntity : public DXFBasicEntity {
+
+public:
+
+ long nAttrFlag; // 66
+ char sName[DXF_MAX_STRING_LEN+1]; // 2
+ DXFVector aP0; // 10,20,30
+ double fXScale; // 41
+ double fYScale; // 42
+ double fZScale; // 43
+ double fRotAngle; // 50
+ long nColCount; // 70
+ long nRowCount; // 71
+ double fColSpace; // 44
+ double fRowSpace; // 45
+
+ DXFInsertEntity();
+
+protected:
+
+ virtual void EvaluateGroup(DXFGroupReader & rDGR);
+};
+
+//--------------------------AttDef----------------------------------------------
+
+class DXFAttDefEntity : public DXFBasicEntity {
+
+public:
+
+ DXFVector aP0; // 10,20,30
+ double fHeight; // 40
+ char sDefVal[DXF_MAX_STRING_LEN+1]; // 1
+ char sPrompt[DXF_MAX_STRING_LEN+1]; // 3
+ char sTagStr[DXF_MAX_STRING_LEN+1]; // 2
+ long nAttrFlags; // 70
+ long nFieldLen; // 73
+ double fRotAngle; // 50
+ double fXScale; // 41
+ double fOblAngle; // 51
+ char sStyle[DXF_MAX_STRING_LEN+1]; // 7
+ long nGenFlags; // 71
+ long nHorzJust; // 72
+ long nVertJust; // 74
+ DXFVector aAlign; // 11,21,31
+
+ DXFAttDefEntity();
+
+protected:
+
+ virtual void EvaluateGroup(DXFGroupReader & rDGR);
+};
+
+//--------------------------Attrib----------------------------------------------
+
+class DXFAttribEntity : public DXFBasicEntity {
+
+public:
+
+ DXFVector aP0; // 10,20,30
+ double fHeight; // 40
+ char sText[DXF_MAX_STRING_LEN+1]; // 1
+ char sTagStr[DXF_MAX_STRING_LEN+1]; // 2
+ long nAttrFlags; // 70
+ long nFieldLen; // 73
+ double fRotAngle; // 50
+ double fXScale; // 41
+ double fOblAngle; // 51
+ char sStyle[DXF_MAX_STRING_LEN+1]; // 7
+ long nGenFlags; // 71
+ long nHorzJust; // 72
+ long nVertJust; // 74
+ DXFVector aAlign; // 11,21,31
+
+ DXFAttribEntity();
+
+protected:
+
+ virtual void EvaluateGroup(DXFGroupReader & rDGR);
+};
+
+//--------------------------PolyLine--------------------------------------------
+
+class DXFPolyLineEntity : public DXFBasicEntity {
+
+public:
+
+ double fElevation; // 30
+ long nFlags; // 70
+ double fSWidth; // 40
+ double fEWidth; // 41
+ long nMeshMCount; // 71
+ long nMeshNCount; // 72
+ long nMDensity; // 73
+ long nNDensity; // 74
+ long nCSSType; // 75
+
+ DXFPolyLineEntity();
+
+protected:
+
+ virtual void EvaluateGroup(DXFGroupReader & rDGR);
+};
+
+class DXFLWPolyLineEntity : public DXFBasicEntity
+{
+ sal_Int32 nIndex;
+
+ public :
+
+ sal_Int32 nCount; // 90
+ sal_Int32 nFlags; // 70 1 = closed, 128 = plinegen
+ double fConstantWidth; // 43 (optional - default: 0, not used if fStartWidth and/or fEndWidth is used)
+ double fStartWidth; // 40
+ double fEndWidth; // 41
+
+ DXFVector* pP;
+
+ DXFLWPolyLineEntity();
+ ~DXFLWPolyLineEntity();
+
+ protected :
+
+ virtual void EvaluateGroup( DXFGroupReader & rDGR );
+
+};
+
+//-------------------------- Hatch ---------------------------------------------
+
+struct DXFEdgeType
+{
+ sal_Int32 nEdgeType;
+
+ virtual ~DXFEdgeType(){};
+ virtual sal_Bool EvaluateGroup( DXFGroupReader & /*rDGR*/ ){ return sal_True; };
+
+ protected :
+
+ DXFEdgeType( sal_Int32 EdgeType ):nEdgeType(EdgeType){};
+};
+struct DXFEdgeTypeLine : public DXFEdgeType
+{
+ DXFVector aStartPoint; // 10,20
+ DXFVector aEndPoint; // 11,21
+ DXFEdgeTypeLine();
+ virtual ~DXFEdgeTypeLine();
+ virtual sal_Bool EvaluateGroup( DXFGroupReader & rDGR );
+};
+struct DXFEdgeTypeCircularArc : public DXFEdgeType
+{
+ DXFVector aCenter; // 10,20
+ double fRadius; // 40
+ double fStartAngle; // 50
+ double fEndAngle; // 51
+ sal_Int32 nIsCounterClockwiseFlag; // 73
+ DXFEdgeTypeCircularArc();
+ virtual ~DXFEdgeTypeCircularArc();
+ virtual sal_Bool EvaluateGroup( DXFGroupReader & rDGR );
+};
+struct DXFEdgeTypeEllipticalArc : public DXFEdgeType
+{
+ DXFVector aCenter; // 10,20
+ DXFVector aEndPoint; // 11,21
+ double fLength; // 40
+ double fStartAngle; // 50
+ double fEndAngle; // 51
+ sal_Int32 nIsCounterClockwiseFlag; // 73
+
+ DXFEdgeTypeEllipticalArc();
+ virtual ~DXFEdgeTypeEllipticalArc();
+ virtual sal_Bool EvaluateGroup( DXFGroupReader & rDGR );
+};
+struct DXFEdgeTypeSpline : public DXFEdgeType
+{
+ sal_Int32 nDegree; // 94
+ sal_Int32 nRational; // 73
+ sal_Int32 nPeriodic; // 74
+ sal_Int32 nKnotCount; // 75
+ sal_Int32 nControlCount; // 76
+
+ DXFEdgeTypeSpline();
+ virtual ~DXFEdgeTypeSpline();
+ virtual sal_Bool EvaluateGroup( DXFGroupReader & rDGR );
+};
+
+typedef std::deque< DXFEdgeType* > DXFEdgeTypeArray;
+
+struct DXFBoundaryPathData
+{
+ sal_Int32 nFlags; // 92
+ sal_Int32 nHasBulgeFlag; // 72
+ sal_Int32 nIsClosedFlag; // 73
+ sal_Int32 nPointCount; // 93
+ double fBulge; // 42
+ sal_Int32 nSourceBoundaryObjects; // 97
+ sal_Int32 nEdgeCount; // 93
+
+ sal_Bool bIsPolyLine;
+ sal_Int32 nPointIndex;
+
+ DXFVector* pP;
+ DXFEdgeTypeArray aEdges;
+
+ DXFBoundaryPathData();
+ ~DXFBoundaryPathData();
+
+ sal_Bool EvaluateGroup( DXFGroupReader & rDGR );
+};
+
+class DXFHatchEntity : public DXFBasicEntity
+{
+ sal_Bool bIsInBoundaryPathContext;
+ sal_Int32 nCurrentBoundaryPathIndex;
+
+ public :
+
+ DXFVector aElevationPoint;
+ sal_Int32 nFlags; // 70 (solid fill = 1, pattern fill = 0)
+ sal_Int32 nAssociativityFlag; // 71 (assoiciative = 1, non-associative = 0)
+ sal_Int32 nBoundaryPathCount; // 91
+ sal_Int32 nHatchStyle; // 75 (odd parity = 0, outmost area = 1, entire area = 2 )
+ sal_Int32 nHatchPatternType; // 76 (user defined = 0, predefined = 1, custom = 2)
+ double fHatchPatternAngle; // 52 (pattern fill only)
+ double fHatchPatternScale; // 41 (pattern fill only:scale or spacing)
+ sal_Int32 nHatchDoubleFlag; // 77 (pattern fill only:double = 1, not double = 0)
+ sal_Int32 nHatchPatternDefinitionLines; // 78
+ double fPixelSize; // 47
+ sal_Int32 nNumberOfSeedPoints; // 98
+
+ DXFBoundaryPathData* pBoundaryPathData;
+
+ DXFHatchEntity();
+ ~DXFHatchEntity();
+
+ protected :
+
+ virtual void EvaluateGroup( DXFGroupReader & rDGR );
+};
+
+
+//--------------------------Vertex----------------------------------------------
+
+class DXFVertexEntity : public DXFBasicEntity {
+
+public:
+
+ DXFVector aP0; // 10,20,30
+ double fSWidth; // 40 (Wenn <0.0, dann gilt DXFPolyLine::fSWidth)
+ double fEWidth; // 41 (Wenn <0.0, dann gilt DXFPolyLine::fEWidth)
+ double fBulge; // 42
+ long nFlags; // 70
+ double fCFTDir; // 50
+
+ DXFVertexEntity();
+
+protected:
+
+ virtual void EvaluateGroup(DXFGroupReader & rDGR);
+};
+
+//--------------------------SeqEnd----------------------------------------------
+
+class DXFSeqEndEntity : public DXFBasicEntity {
+
+public:
+
+ DXFSeqEndEntity();
+};
+
+//--------------------------3DFace----------------------------------------------
+
+class DXF3DFaceEntity : public DXFBasicEntity {
+
+public:
+
+ DXFVector aP0; // 10,20,30
+ DXFVector aP1; // 11,21,31
+ DXFVector aP2; // 12,22,32
+ DXFVector aP3; // 13,23,33
+ long nIEFlags; // 70
+
+ DXF3DFaceEntity();
+
+protected:
+
+ virtual void EvaluateGroup(DXFGroupReader & rDGR);
+};
+
+//--------------------------Dimension-------------------------------------------
+
+class DXFDimensionEntity : public DXFBasicEntity {
+
+public:
+
+ char sPseudoBlock[DXF_MAX_STRING_LEN+1]; // 2
+
+ DXFDimensionEntity();
+
+protected:
+
+ virtual void EvaluateGroup(DXFGroupReader & rDGR);
+};
+
+//------------------------------------------------------------------------------
+//----------- Eine Menge von Entities lesen und repraesentieren ----------------
+//------------------------------------------------------------------------------
+
+class DXFEntities {
+
+public:
+
+ DXFEntities();
+ ~DXFEntities();
+
+ DXFBasicEntity * pFirst; // Liste von Entities, READ ONLY!
+
+ void Read(DXFGroupReader & rDGR);
+ // Liest Entitis per rGDR aus einer DXF-Datei bis zu
+ // einem ENDBLK, ENDSEC oder EOF (der Gruppe 0).
+ // (Alle unbekannten Dinge werden uebersprungen)
+
+ void Clear();
+ // Loescht alle Entities
+};
+
+//------------------------------------------------------------------------------
+//--------------------------------- inlines ------------------------------------
+//------------------------------------------------------------------------------
+
+inline DXFEntities::DXFEntities()
+{
+ pFirst=NULL;
+}
+
+
+inline DXFEntities::~DXFEntities()
+{
+ Clear();
+}
+
+
+#endif
+
+
diff --git a/filter/source/graphicfilter/idxf/dxfgrprd.cxx b/filter/source/graphicfilter/idxf/dxfgrprd.cxx
new file mode 100644
index 000000000000..f09b17e80635
--- /dev/null
+++ b/filter/source/graphicfilter/idxf/dxfgrprd.cxx
@@ -0,0 +1,361 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_filter.hxx"
+
+#include <string.h>
+#include <stdlib.h>
+#include <tools/stream.hxx>
+#include "dxfgrprd.hxx"
+
+// ----------------------------------------------------------------------------
+
+// we use an own ReadLine function, because Stream::ReadLine stops if
+// a 0-sign occurs; this functions converts 0-signs to blanks and reads
+// a complete line until a cr/lf is found
+
+BOOL DXFReadLine( SvStream& rIStm, ByteString& rStr )
+{
+ char buf[256 + 1];
+ BOOL bEnd = FALSE;
+ ULONG nOldFilePos = rIStm.Tell();
+ char c = 0;
+
+ rStr.Erase();
+
+ while( !bEnd && !rIStm.GetError() ) // !!! nicht auf EOF testen,
+ // !!! weil wir blockweise
+ // !!! lesen
+ {
+ USHORT nLen = (USHORT)rIStm.Read( buf, sizeof(buf)-1 );
+ if( !nLen )
+ {
+ if( rStr.Len() == 0 )
+ return FALSE;
+ else
+ break;
+ }
+
+ for( USHORT n = 0; n < nLen ; n++ )
+ {
+ c = buf[n];
+ if( c != '\n' && c != '\r' )
+ {
+ if( !c )
+ c = ' ';
+ rStr += c;
+ }
+ else
+ {
+ bEnd = TRUE;
+ break;
+ }
+ }
+ }
+
+ if( !bEnd && !rIStm.GetError() && rStr.Len() )
+ bEnd = TRUE;
+
+ nOldFilePos += rStr.Len();
+ if( rIStm.Tell() > nOldFilePos )
+ nOldFilePos++;
+ rIStm.Seek( nOldFilePos ); // seeken wg. obigem BlockRead!
+
+ if( bEnd && (c=='\r' || c=='\n')) // Sonderbehandlung DOS-Dateien
+ {
+ char cTemp;
+ rIStm.Read((char*)&cTemp , sizeof(cTemp) );
+ if( cTemp == c || (cTemp != '\n' && cTemp != '\r') )
+ rIStm.Seek( nOldFilePos );
+ }
+
+ return bEnd;
+}
+
+// ------------------
+
+DXFGroupReader::DXFGroupReader(SvStream & rIStream, USHORT nminpercent, USHORT nmaxpercent ) :
+ rIS(rIStream)
+{
+ USHORT i;
+
+ nIBuffPos=0;
+ nIBuffSize=0;
+ bStatus=TRUE;
+ nLastG=0;
+ nGCount=0;
+
+ nMinPercent=(ULONG)nminpercent;
+ nMaxPercent=(ULONG)nmaxpercent;
+ nLastPercent=nMinPercent;
+
+ rIS.Seek(STREAM_SEEK_TO_END);
+ nFileSize=rIS.Tell();
+ rIS.Seek(0);
+
+ for (i=0; i<10; i++) S0_9[i][0]=0;
+ S100[ 0 ] = S102[ 0 ] = 0;
+ for (i=0; i<50; i++) F10_59[i]=0.0;
+ for (i=0; i<20; i++) I60_79[i]=0;
+ for (i=0; i<10; i++) I90_99[i]=0;
+ for (i=0; i< 8; i++) F140_147[i]=0.0;
+ for (i=0; i< 6; i++) I170_175[i]=0;
+ for (i=0; i<30; i++) F210_239[i]=0.0;
+ for (i=0; i<11; i++) S999_1009[i][0]=0;
+ for (i=0; i<50; i++) F1010_1059[i]=0.0;
+ for (i=0; i<20; i++) I1060_1079[i]=0;
+
+}
+
+
+USHORT DXFGroupReader::Read()
+{
+ sal_uInt16 nG = 0;
+ if ( bStatus )
+ {
+ nGCount++;
+ nG = (sal_uInt16)ReadI();
+ if ( bStatus )
+ {
+ char aTmp[ DXF_MAX_STRING_LEN + 1 ];
+
+ if (nG< 10) ReadS(S0_9[nG]);
+ else if (nG< 60) F10_59[nG-10]=ReadF();
+ else if (nG< 80) I60_79[nG-60]=ReadI();
+ else if (nG< 90) ReadS( aTmp );
+ else if (nG< 99) I90_99[nG-90]=ReadI();
+ else if (nG==100) ReadS(S100);
+ else if (nG==102) ReadS(S102);
+ else if (nG==105) ReadS( aTmp );
+ else if (nG< 140) ReadS( aTmp );
+ else if (nG< 148) F140_147[nG-140]=ReadF();
+ else if (nG< 170) ReadS( aTmp );
+ else if (nG< 176) I170_175[nG-175]=ReadI();
+ else if (nG< 180) ReadI();
+ else if (nG< 210) ReadS( aTmp );
+ else if (nG< 240) F210_239[nG-210]=ReadF();
+ else if (nG<=369) ReadS( aTmp );
+ else if (nG< 999) ReadS( aTmp );
+ else if (nG<1010) ReadS(S999_1009[nG-999]);
+ else if (nG<1060) F1010_1059[nG-1010]=ReadF();
+ else if (nG<1080) I1060_1079[nG-1060]=ReadI();
+ else bStatus = sal_False;
+ }
+ }
+ if ( bStatus )
+ nLastG = nG;
+ else
+ {
+ nG = 0;
+ SetS( 0, "EOF" );
+ if ( nGCount != 0xffffffff )
+ {
+ // InfoBox(NULL,String("Fehler ab Gruppe Nr ")+String(nGCount)).Execute();
+ nGCount=0xffffffff;
+ }
+ }
+ nLastG = nG;
+ return nG;
+}
+
+
+long DXFGroupReader::GetI(USHORT nG)
+{
+ sal_Int32 nRetValue = 0;
+ if ( ( nG >= 60 ) && ( nG <= 79 ) )
+ nRetValue = I60_79[ nG - 60 ];
+ else if ( ( nG >= 90 ) && ( nG <= 99 ) )
+ nRetValue = I90_99[ nG - 90 ];
+ else if ( ( nG >= 170 ) && ( nG <= 175 ) )
+ nRetValue = I170_175[ nG - 170 ];
+ else if ( ( nG >= 1060 ) && ( nG <= 1079 ) )
+ nRetValue = I1060_1079[ nG - 1060 ];
+ return nRetValue;
+}
+
+double DXFGroupReader::GetF(USHORT nG)
+{
+ nG-=10;
+ if (nG<50) return F10_59[nG];
+ else {
+ nG-=130;
+ if (nG<8) return F140_147[nG];
+ else {
+ nG-=70;
+ if (nG<30) return F210_239[nG];
+ else {
+ nG-=800;
+ if (nG<50) return F1010_1059[nG];
+ else return 0;
+ }
+ }
+ }
+}
+
+const char * DXFGroupReader::GetS(USHORT nG)
+{
+ if (nG<10) return S0_9[nG];
+ else if ( nG == 100 )
+ return S100;
+ else if ( nG == 102 )
+ return S102;
+ else
+ {
+ nG-=999;
+ if (nG<11) return S999_1009[nG];
+ else return NULL;
+ }
+}
+
+void DXFGroupReader::SetF(USHORT nG, double fF)
+{
+ nG-=10;
+ if (nG<50) F10_59[nG]=fF;
+ else {
+ nG-=130;
+ if (nG<8) F140_147[nG]=fF;
+ else {
+ nG-=70;
+ if (nG<30) F210_239[nG]=fF;
+ else {
+ nG-=800;
+ if (nG<50) F1010_1059[nG]=fF;
+ }
+ }
+ }
+}
+
+
+void DXFGroupReader::SetS(USHORT nG, const char * sS)
+{
+ char* pPtr = NULL;
+ if ( nG < 10 )
+ pPtr = S0_9[ nG ];
+ else if ( nG == 100 )
+ pPtr = S100;
+ else if ( nG == 102 )
+ pPtr = S102;
+ else
+ {
+ nG -= 999;
+ if ( nG < 11 )
+ pPtr = S999_1009[ nG ];
+ }
+ if ( pPtr )
+ strncpy( pPtr, sS, DXF_MAX_STRING_LEN + 1 );
+}
+
+
+void DXFGroupReader::ReadLine(char * ptgt)
+{
+ ByteString aStr;
+ ULONG nLen;
+
+ DXFReadLine( rIS, aStr );
+
+ nLen = aStr.Len();
+ if ( nLen > DXF_MAX_STRING_LEN )
+ nLen = DXF_MAX_STRING_LEN;
+
+ memcpy( ptgt, aStr.GetBuffer(), nLen );
+ ptgt[ nLen ] = 0x00;
+/*
+ if ( pCallback )
+ {
+ const ULONG nPercent= nMinPercent + (nMaxPercent-nMinPercent)*rIS.Tell() / nFileSize;
+
+ if ( nPercent >= nLastPercent + 4 )
+ {
+ nLastPercent=nPercent;
+ if (((*pCallback)(pCallerData,(USHORT)nPercent))==TRUE)
+ bStatus=FALSE;
+ }
+ }
+*/
+}
+
+
+long DXFGroupReader::ReadI()
+{
+ char sl[DXF_MAX_STRING_LEN+1],*p;
+ long res,nv;
+
+ ReadLine(sl);
+
+ p=sl;
+
+ while(*p==0x20) p++;
+
+ if ((*p<'0' || *p>'9') && *p!='-') {
+ bStatus=FALSE;
+ return 0;
+ }
+
+ if (*p=='-') {
+ nv=-1;
+ p++;
+ }
+ else nv=1;
+
+ res=0;
+ do {
+ res=res*10+(long)(*p-'0');
+ p++;
+ } while (*p>='0' && *p<='9');
+
+ while (*p==0x20) p++;
+ if (*p!=0) {
+ bStatus=FALSE;
+ return 0;
+ }
+
+ return res*nv;
+}
+
+
+double DXFGroupReader::ReadF()
+{
+ char sl[DXF_MAX_STRING_LEN+1],*p;
+
+ ReadLine(sl);
+ p=sl;
+ while(*p==0x20) p++;
+ if ((*p<'0' || *p>'9') && *p!='.' && *p!='-') {
+ bStatus=FALSE;
+ return 0.0;
+ }
+ return atof(p);
+}
+
+
+void DXFGroupReader::ReadS(char * ptgt)
+{
+ ReadLine(ptgt);
+}
+
+
diff --git a/filter/source/graphicfilter/idxf/dxfgrprd.hxx b/filter/source/graphicfilter/idxf/dxfgrprd.hxx
new file mode 100644
index 000000000000..0b9a40ff6bf8
--- /dev/null
+++ b/filter/source/graphicfilter/idxf/dxfgrprd.hxx
@@ -0,0 +1,155 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+#ifndef _DXFGRPRD_HXX
+#define _DXFGRPRD_HXX
+
+#include <svtools/fltcall.hxx>
+
+#define DXF_MAX_STRING_LEN 256 // Max Stringlaenge (ohne die 0)
+
+
+class DXFGroupReader
+{
+
+public:
+
+ // Anmerkkung:
+ // sizeof(DXFGroupReader) ist gross, also nur dynamisch anlegen!
+
+ DXFGroupReader( SvStream & rIStream, USHORT nMinPercent, USHORT nMaxPercent );
+
+ BOOL GetStatus();
+
+ void SetError();
+
+ USHORT Read();
+ // Liesst die naechste Gruppe ein und liefert den Gruppencode zurueck.
+ // Im Falle eines Fehlers liefert GetStatus() FALSE, Gruppencode wird 0
+ // gesetzt, und es wird SetS(0,"EOF") ausgefuehrt.
+
+ USHORT GetG();
+ // Liefert den letzten Gruppencode (also was Read() zuletzt lieferte)
+
+ long GetI();
+ // Liefert den Integer-Wert zur Gruppe, die vorher mit Read() gelesen wurde.
+ // Dabei muss es sich um einen Gruppencode fuer den Datentyp Integer
+ // gehandelt haben, wenn nicht, wird 0 gelieferet.
+
+ double GetF();
+ // Liefert den Floatingpoint-Wert zur Gruppe, die vorher mit Read() gelesen wurde.
+ // Dabei muss es sich um einen Gruppencode fuer den Datentyp Floatingpoint
+ // gehandelt haben, wenn nicht, wird 0 geliefert.
+
+ const char * GetS();
+ // Liefert den String zur Gruppe, die vorher mit Read() gelesen wurde.
+ // Dabei muss es sich um einen Gruppencode fuer den Datentyp String
+ // gehandelt haben, wenn nicht, wird NULL geliefert.
+
+ // Folgende drei Methoden arbeiten wie die obigen, nur kann auch ein anderer als der
+ // aktuelle Gruppencode angegeben werden. (DXFGroupReader speichert die Parameter
+ // zu allen Gruppencodes. Dadurch ist es moeglich, dass zunaechst mit Read() einige
+ // verschiedene Gruppen eingelesen werden, bevor sie ausgewertet werden.)
+ long GetI(USHORT nG);
+ double GetF(USHORT nG);
+ const char * GetS(USHORT nG);
+
+ // Mit folgenden Methoden koennen die aktuell gespeicherten Werte zu den
+ // Gruppencodes veraendert werden. (z.B. um Defaultwerte zu setzen, bevor
+ // 'blind' eine Menge von Gruppen eingelesen wird.)
+ void SetF(USHORT nG, double fF);
+ void SetS(USHORT nG, const char * sS); // (wird kopiert)
+
+private:
+
+ void ReadLine(char * ptgt);
+ long ReadI();
+ double ReadF();
+ void ReadS(char * ptgt);
+
+ SvStream & rIS;
+ char sIBuff[1024];
+ USHORT nIBuffSize,nIBuffPos;
+ BOOL bStatus;
+ USHORT nLastG;
+ ULONG nGCount;
+
+ ULONG nMinPercent;
+ ULONG nMaxPercent;
+ ULONG nLastPercent;
+ ULONG nFileSize;
+
+ char S0_9 [10][DXF_MAX_STRING_LEN+1]; // Strings Gruppencodes 0..9
+ double F10_59 [50]; // Floats Gruppencodes 10..59
+ long I60_79 [20]; // Integers Gruppencodes 60..79
+ long I90_99 [10];
+ char S100 [DXF_MAX_STRING_LEN+1];
+ char S102 [DXF_MAX_STRING_LEN+1];
+ double F140_147 [ 8]; // Floats Gruppencodes 140..147
+ long I170_175 [ 6]; // Integers Gruppencodes 170..175
+ double F210_239 [30]; // Floats Gruppencodes 210..239
+ char S999_1009 [11][DXF_MAX_STRING_LEN+1]; // Strings Gruppencodes 999..1009
+ double F1010_1059[50]; // Floats Gruppencodes 1010..1059
+ long I1060_1079[20]; // Integers Gruppencodes 1060..1079
+
+};
+
+
+inline BOOL DXFGroupReader::GetStatus()
+{
+ return bStatus;
+}
+
+
+inline void DXFGroupReader::SetError()
+{
+ bStatus=FALSE;
+}
+
+inline USHORT DXFGroupReader::GetG()
+{
+ return nLastG;
+}
+
+inline long DXFGroupReader::GetI()
+{
+ return GetI(nLastG);
+}
+
+inline double DXFGroupReader::GetF()
+{
+ return GetF(nLastG);
+}
+
+inline const char * DXFGroupReader::GetS()
+{
+ return GetS(nLastG);
+}
+
+#endif
+
+
diff --git a/filter/source/graphicfilter/idxf/dxfreprd.cxx b/filter/source/graphicfilter/idxf/dxfreprd.cxx
new file mode 100644
index 000000000000..9d6494b87f9d
--- /dev/null
+++ b/filter/source/graphicfilter/idxf/dxfreprd.cxx
@@ -0,0 +1,385 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_filter.hxx"
+
+#include <string.h>
+#include <dxfreprd.hxx>
+
+
+//------------------DXFBoundingBox--------------------------------------------
+
+
+void DXFBoundingBox::Union(const DXFVector & rVector)
+{
+ if (bEmpty==TRUE) {
+ fMinX=rVector.fx;
+ fMinY=rVector.fy;
+ fMinZ=rVector.fz;
+ fMaxX=rVector.fx;
+ fMaxY=rVector.fy;
+ fMaxZ=rVector.fz;
+ bEmpty=FALSE;
+ }
+ else {
+ if (fMinX>rVector.fx) fMinX=rVector.fx;
+ if (fMinY>rVector.fy) fMinY=rVector.fy;
+ if (fMinZ>rVector.fz) fMinZ=rVector.fz;
+ if (fMaxX<rVector.fx) fMaxX=rVector.fx;
+ if (fMaxY<rVector.fy) fMaxY=rVector.fy;
+ if (fMaxZ<rVector.fz) fMaxZ=rVector.fz;
+ }
+}
+
+
+//------------------DXFPalette------------------------------------------------
+
+
+DXFPalette::DXFPalette()
+{
+ short i,j,nHue,nNSat,nVal,nC[3],nmax,nmed,nmin;
+ BYTE nV;
+
+ pRed =new BYTE[256];
+ pGreen=new BYTE[256];
+ pBlue =new BYTE[256];
+
+ // Farben 0 - 9 (normale Farben)
+ SetColor(0, 0x00, 0x00, 0x00); // eigentlich nie benutzt
+ SetColor(1, 0xff, 0x00, 0x00);
+ SetColor(2, 0xff, 0xff, 0x00);
+ SetColor(3, 0x00, 0xff, 0x00);
+ SetColor(4, 0x00, 0xff, 0xff);
+ SetColor(5, 0x00, 0x00, 0xff);
+ SetColor(6, 0xff, 0x00, 0xff);
+ SetColor(7, 0x0f, 0x0f, 0x0f); // eigentlich weiss ???
+ SetColor(8, 0x80, 0x80, 0x80);
+ SetColor(9, 0xc0, 0xc0, 0xc0);
+
+ // Farben 10 - 249
+ // (Universal-Palette: 24 Farbtoene * 5 Helligkeiten * 2 Saettigungen )
+ i=10;
+ for (nHue=0; nHue<24; nHue++) {
+ for (nVal=5; nVal>=1; nVal--) {
+ for (nNSat=0; nNSat<2; nNSat++) {
+ nmax=((nHue+3)>>3)%3;
+ j=nHue-(nmax<<3); if (j>4) j=j-24;
+ if (j>=0) {
+ nmed=(nmax+1)%3;
+ nmin=(nmax+2)%3;
+ }
+ else {
+ nmed=(nmax+2)%3;
+ nmin=(nmax+1)%3;
+ j=-j;
+ }
+ nC[nmin]=0;
+ nC[nmed]=255*j/4;
+ nC[nmax]=255;
+ if (nNSat!=0) {
+ for (j=0; j<3; j++) nC[j]=(nC[j]>>1)+128;
+ }
+ for (j=0; j<3; j++) nC[j]=nC[j]*nVal/5;
+ SetColor((BYTE)(i++),(BYTE)nC[0],(BYTE)nC[1],(BYTE)nC[2]);
+ }
+ }
+ }
+
+ // Farben 250 - 255 (Grautoenne)
+ for (i=0; i<6; i++) {
+ nV=(BYTE)(i*38+65);
+ SetColor((BYTE)(250+i),nV,nV,nV);
+ }
+}
+
+
+DXFPalette::~DXFPalette()
+{
+ delete[] pBlue;
+ delete[] pGreen;
+ delete[] pRed;
+}
+
+
+void DXFPalette::SetColor(BYTE nIndex, BYTE nRed, BYTE nGreen, BYTE nBlue)
+{
+ pRed[nIndex]=nRed;
+ pGreen[nIndex]=nGreen;
+ pBlue[nIndex]=nBlue;
+}
+
+
+//------------------DXFRepresentation-----------------------------------------
+
+
+DXFRepresentation::DXFRepresentation()
+{
+ setTextEncoding(RTL_TEXTENCODING_IBM_437);
+ setGlobalLineTypeScale(1.0);
+}
+
+
+DXFRepresentation::~DXFRepresentation()
+{
+}
+
+
+BOOL DXFRepresentation::Read( SvStream & rIStream, USHORT nMinPercent, USHORT nMaxPercent)
+{
+ DXFGroupReader * pDGR;
+ BOOL bRes;
+
+ aTables.Clear();
+ aBlocks.Clear();
+ aEntities.Clear();
+
+ pDGR = new DXFGroupReader( rIStream, nMinPercent, nMaxPercent );
+
+ pDGR->Read();
+ while (pDGR->GetG()!=0 || strcmp(pDGR->GetS(),"EOF")!=0) {
+ if (pDGR->GetG()==0 && strcmp(pDGR->GetS(),"SECTION")==0) {
+ if (pDGR->Read()!=2) {
+ pDGR->SetError();
+ break;
+ }
+ if (strcmp(pDGR->GetS(),"HEADER" )==0) ReadHeader(*pDGR);
+ else if (strcmp(pDGR->GetS(),"TABLES" )==0) aTables.Read(*pDGR);
+ else if (strcmp(pDGR->GetS(),"BLOCKS" )==0) aBlocks.Read(*pDGR);
+ else if (strcmp(pDGR->GetS(),"ENTITIES")==0) aEntities.Read(*pDGR);
+ else pDGR->Read();
+ }
+ else pDGR->Read();
+ }
+
+ bRes=pDGR->GetStatus();
+
+ delete pDGR;
+
+ if (bRes==TRUE && aBoundingBox.bEmpty==TRUE)
+ CalcBoundingBox(aEntities,aBoundingBox);
+
+ return bRes;
+}
+
+
+void DXFRepresentation::ReadHeader(DXFGroupReader & rDGR)
+{
+
+ while (rDGR.GetG()!=0 || (strcmp(rDGR.GetS(),"EOF")!=0 && strcmp(rDGR.GetS(),"ENDSEC")!=0) )
+ {
+ if (rDGR.GetG()==9) {
+ if (strcmp(rDGR.GetS(),"$EXTMIN")==0 ||
+ strcmp(rDGR.GetS(),"$EXTMAX")==0)
+ {
+ DXFVector aVector;
+ rDGR.SetF(10,0.0);
+ rDGR.SetF(20,0.0);
+ rDGR.SetF(30,0.0);
+ do {
+ rDGR.Read();
+ } while (rDGR.GetG()!=9 && rDGR.GetG()!=0);
+ aVector.fx=rDGR.GetF(10);
+ aVector.fy=rDGR.GetF(20);
+ aVector.fz=rDGR.GetF(30);
+ aBoundingBox.Union(aVector);
+ } else {
+ if (strcmp(rDGR.GetS(),"$DWGCODEPAGE")==0)
+ {
+ rDGR.Read();
+
+ // FIXME: we really need a whole table of
+ // $DWGCODEPAGE to encodings mappings
+ if ( (strcmp(rDGR.GetS(),"ANSI_932")==0) ||
+ (strcmp(rDGR.GetS(),"ansi_932")==0) ||
+ (strcmp(rDGR.GetS(),"DOS932")==0) ||
+ (strcmp(rDGR.GetS(),"dos932")==0) )
+ {
+ setTextEncoding(RTL_TEXTENCODING_MS_932);
+ }
+ }
+ else if (strcmp(rDGR.GetS(),"$LTSCALE")==0)
+ {
+ rDGR.Read();
+ setGlobalLineTypeScale(getGlobalLineTypeScale() * rDGR.GetF());
+ }
+ else rDGR.Read();
+ }
+ }
+ else rDGR.Read();
+ }
+}
+
+
+void DXFRepresentation::CalcBoundingBox(const DXFEntities & rEntities,
+ DXFBoundingBox & rBox)
+{
+ DXFBasicEntity * pBE=rEntities.pFirst;
+ while (pBE!=NULL) {
+ switch (pBE->eType) {
+ case DXF_LINE: {
+ const DXFLineEntity * pE = (DXFLineEntity*)pBE;
+ rBox.Union(pE->aP0);
+ rBox.Union(pE->aP1);
+ break;
+ }
+ case DXF_POINT: {
+ const DXFPointEntity * pE = (DXFPointEntity*)pBE;
+ rBox.Union(pE->aP0);
+ break;
+ }
+ case DXF_CIRCLE: {
+ const DXFCircleEntity * pE = (DXFCircleEntity*)pBE;
+ DXFVector aP;
+ aP=pE->aP0;
+ aP.fx-=pE->fRadius;
+ aP.fy-=pE->fRadius;
+ rBox.Union(aP);
+ aP=pE->aP0;
+ aP.fx+=pE->fRadius;
+ aP.fy+=pE->fRadius;
+ rBox.Union(aP);
+ break;
+ }
+ case DXF_ARC: {
+ const DXFArcEntity * pE = (DXFArcEntity*)pBE;
+ DXFVector aP;
+ aP=pE->aP0;
+ aP.fx-=pE->fRadius;
+ aP.fy-=pE->fRadius;
+ rBox.Union(aP);
+ aP=pE->aP0;
+ aP.fx+=pE->fRadius;
+ aP.fy+=pE->fRadius;
+ rBox.Union(aP);
+ break;
+ }
+ case DXF_TRACE: {
+ const DXFTraceEntity * pE = (DXFTraceEntity*)pBE;
+ rBox.Union(pE->aP0);
+ rBox.Union(pE->aP1);
+ rBox.Union(pE->aP2);
+ rBox.Union(pE->aP3);
+ break;
+ }
+ case DXF_SOLID: {
+ const DXFSolidEntity * pE = (DXFSolidEntity*)pBE;
+ rBox.Union(pE->aP0);
+ rBox.Union(pE->aP1);
+ rBox.Union(pE->aP2);
+ rBox.Union(pE->aP3);
+ break;
+ }
+ case DXF_TEXT: {
+ //const DXFTextEntity * pE = (DXFTextEntity*)pBE;
+ //???
+ break;
+ }
+ case DXF_SHAPE: {
+ //const DXFShapeEntity * pE = (DXFShapeEntity*)pBE;
+ //???
+ break;
+ }
+ case DXF_INSERT: {
+ const DXFInsertEntity * pE = (DXFInsertEntity*)pBE;
+ DXFBlock * pB;
+ DXFBoundingBox aBox;
+ DXFVector aP;
+ pB=aBlocks.Search(pE->sName);
+ if (pB==NULL) break;
+ CalcBoundingBox(*pB,aBox);
+ if (aBox.bEmpty==TRUE) break;
+ aP.fx=(aBox.fMinX-pB->aBasePoint.fx)*pE->fXScale+pE->aP0.fx;
+ aP.fy=(aBox.fMinY-pB->aBasePoint.fy)*pE->fYScale+pE->aP0.fy;
+ aP.fz=(aBox.fMinZ-pB->aBasePoint.fz)*pE->fZScale+pE->aP0.fz;
+ rBox.Union(aP);
+ aP.fx=(aBox.fMaxX-pB->aBasePoint.fx)*pE->fXScale+pE->aP0.fx;
+ aP.fy=(aBox.fMaxY-pB->aBasePoint.fy)*pE->fYScale+pE->aP0.fy;
+ aP.fz=(aBox.fMaxZ-pB->aBasePoint.fz)*pE->fZScale+pE->aP0.fz;
+ rBox.Union(aP);
+ break;
+ }
+ case DXF_ATTDEF: {
+ //const DXFAttDefEntity * pE = (DXFAttDefEntity*)pBE;
+ //???
+ break;
+ }
+ case DXF_ATTRIB: {
+ //const DXFAttribEntity * pE = (DXFAttribEntity*)pBE;
+ //???
+ break;
+ }
+ case DXF_VERTEX: {
+ const DXFVertexEntity * pE = (DXFVertexEntity*)pBE;
+ rBox.Union(pE->aP0);
+ break;
+ }
+ case DXF_3DFACE: {
+ const DXF3DFaceEntity * pE = (DXF3DFaceEntity*)pBE;
+ rBox.Union(pE->aP0);
+ rBox.Union(pE->aP1);
+ rBox.Union(pE->aP2);
+ rBox.Union(pE->aP3);
+ break;
+ }
+ case DXF_DIMENSION: {
+ const DXFDimensionEntity * pE = (DXFDimensionEntity*)pBE;
+ DXFBlock * pB;
+ DXFBoundingBox aBox;
+ DXFVector aP;
+ pB=aBlocks.Search(pE->sPseudoBlock);
+ if (pB==NULL) break;
+ CalcBoundingBox(*pB,aBox);
+ if (aBox.bEmpty==TRUE) break;
+ aP.fx=aBox.fMinX-pB->aBasePoint.fx;
+ aP.fy=aBox.fMinY-pB->aBasePoint.fy;
+ aP.fz=aBox.fMinZ-pB->aBasePoint.fz;
+ rBox.Union(aP);
+ aP.fx=aBox.fMaxX-pB->aBasePoint.fx;
+ aP.fy=aBox.fMaxY-pB->aBasePoint.fy;
+ aP.fz=aBox.fMaxZ-pB->aBasePoint.fz;
+ rBox.Union(aP);
+ break;
+ }
+ case DXF_POLYLINE: {
+ //const DXFAttribEntity * pE = (DXFAttribEntity*)pBE;
+ //???
+ break;
+ }
+ case DXF_SEQEND: {
+ //const DXFAttribEntity * pE = (DXFAttribEntity*)pBE;
+ //???
+ break;
+ }
+ case DXF_HATCH :
+ break;
+ case DXF_LWPOLYLINE :
+ break;
+ }
+ pBE=pBE->pSucc;
+ }
+}
diff --git a/filter/source/graphicfilter/idxf/dxfreprd.hxx b/filter/source/graphicfilter/idxf/dxfreprd.hxx
new file mode 100644
index 000000000000..c95d65cfbe46
--- /dev/null
+++ b/filter/source/graphicfilter/idxf/dxfreprd.hxx
@@ -0,0 +1,138 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+#ifndef _DXFREPRD_HXX
+#define _DXFREPRD_HXX
+
+#include <dxfblkrd.hxx>
+#include <dxftblrd.hxx>
+
+
+//----------------------------------------------------------------------------
+//--------------------Nebensachen---------------------------------------------
+//----------------------------------------------------------------------------
+
+//-------------------Eine 3D-Min/Max-Box--------------------------------------
+
+class DXFBoundingBox {
+public:
+ BOOL bEmpty;
+ double fMinX;
+ double fMinY;
+ double fMinZ;
+ double fMaxX;
+ double fMaxY;
+ double fMaxZ;
+
+ DXFBoundingBox() { bEmpty=TRUE; }
+ void Union(const DXFVector & rVector);
+};
+
+
+//-------------------Die (konstante) Palette fuer DXF-------------------------
+
+class DXFPalette {
+
+public:
+
+ DXFPalette();
+ ~DXFPalette();
+
+ BYTE GetRed(BYTE nIndex) const;
+ BYTE GetGreen(BYTE nIndex) const;
+ BYTE GetBlue(BYTE nIndex) const;
+
+private:
+ BYTE * pRed;
+ BYTE * pGreen;
+ BYTE * pBlue;
+ void SetColor(BYTE nIndex, BYTE nRed, BYTE nGreen, BYTE nBlue);
+};
+
+
+//----------------------------------------------------------------------------
+//-----------------DXF Datei lesen und repraesentieren------------------------
+//----------------------------------------------------------------------------
+
+class DXFRepresentation {
+
+public:
+
+ DXFPalette aPalette;
+ // Die immer gleiche DXF-Farb-Palette
+
+ DXFBoundingBox aBoundingBox;
+ // Ist gleich den AutoCAD-Variablen EXTMIN, EXTMAX sofern in DXF-Datei
+ // vorhanden, anderenfalls wird die BoundingBox berechnet (in Read()).
+
+ DXFTables aTables;
+ // Die Tabellen der DXF-Datei
+
+ DXFBlocks aBlocks;
+ // Die Bloecke der DXF-Datei
+
+ DXFEntities aEntities;
+ // Die Entities (aus der Entities-Section) der DXF-Datei
+
+ rtl_TextEncoding mEnc; // $DWGCODEPAGE
+
+ double mfGlobalLineTypeScale; // $LTSCALE
+
+ DXFRepresentation();
+ ~DXFRepresentation();
+
+ rtl_TextEncoding getTextEncoding() const;
+ void setTextEncoding(rtl_TextEncoding aEnc);
+
+ double getGlobalLineTypeScale() const;
+ void setGlobalLineTypeScale(double fGlobalLineTypeScale);
+
+ BOOL Read( SvStream & rIStream, USHORT nMinPercent, USHORT nMaxPercent);
+ // Liesst die komplette DXF-Datei ein.
+
+private:
+
+ void ReadHeader(DXFGroupReader & rDGR);
+ void CalcBoundingBox(const DXFEntities & rEntities,
+ DXFBoundingBox & rBox);
+};
+
+//----------------------------------------------------------------------------
+//-------------------inlines--------------------------------------------------
+//----------------------------------------------------------------------------
+
+inline BYTE DXFPalette::GetRed(BYTE nIndex) const { return pRed[nIndex]; }
+inline BYTE DXFPalette::GetGreen(BYTE nIndex) const { return pGreen[nIndex]; }
+inline BYTE DXFPalette::GetBlue(BYTE nIndex) const { return pBlue[nIndex]; }
+inline rtl_TextEncoding DXFRepresentation::getTextEncoding() const { return mEnc; }
+inline void DXFRepresentation::setTextEncoding(rtl_TextEncoding aEnc) { mEnc = aEnc; }
+inline double DXFRepresentation::getGlobalLineTypeScale() const { return mfGlobalLineTypeScale; }
+inline void DXFRepresentation::setGlobalLineTypeScale(double fGlobalLineTypeScale) { mfGlobalLineTypeScale = fGlobalLineTypeScale; }
+
+#endif
+
+
diff --git a/filter/source/graphicfilter/idxf/dxftblrd.cxx b/filter/source/graphicfilter/idxf/dxftblrd.cxx
new file mode 100644
index 000000000000..337e43730cb6
--- /dev/null
+++ b/filter/source/graphicfilter/idxf/dxftblrd.cxx
@@ -0,0 +1,348 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_filter.hxx"
+
+#include <string.h>
+#include <dxftblrd.hxx>
+
+//----------------------------------DXFLType-----------------------------------
+
+DXFLType::DXFLType()
+{
+ pSucc=NULL;
+ sName[0]=0;
+ nFlags=0;
+ sDescription[0]=0;
+ nDashCount=0;
+}
+
+void DXFLType::Read(DXFGroupReader & rDGR)
+{
+ long nDashIndex=-1;
+
+ while (rDGR.Read()!=0)
+ {
+ switch (rDGR.GetG())
+ {
+ case 2: strncpy( sName, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 70: nFlags=rDGR.GetI(); break;
+ case 3: strncpy( sDescription, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 73:
+ if (nDashIndex!=-1) {
+ rDGR.SetError();
+ return;
+ }
+ nDashCount=rDGR.GetI();
+ if (nDashCount>DXF_MAX_DASH_COUNT)
+ nDashCount=DXF_MAX_DASH_COUNT;
+ nDashIndex=0;
+ break;
+ case 40: fPatternLength=rDGR.GetF(); break;
+ case 49:
+ if (nDashCount==-1) {
+ rDGR.SetError();
+ return;
+ }
+ if (nDashIndex<nDashCount)
+ fDash[nDashIndex++]=rDGR.GetF();
+ break;
+ }
+ }
+}
+
+//----------------------------------DXFLayer-----------------------------------
+
+DXFLayer::DXFLayer()
+{
+ pSucc=NULL;
+ sName[0]=0;
+ nFlags=0;
+ nColor=-1;
+ sLineType[0]=0;
+}
+
+void DXFLayer::Read(DXFGroupReader & rDGR)
+{
+ while (rDGR.Read()!=0) {
+ switch(rDGR.GetG()) {
+ case 2: strncpy( sName, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 70: nFlags=rDGR.GetI(); break;
+ case 62: nColor=rDGR.GetI(); break;
+ case 6: strncpy( sLineType, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ }
+ }
+}
+
+//----------------------------------DXFStyle-----------------------------------
+
+DXFStyle::DXFStyle()
+{
+ pSucc=NULL;
+ sName[0]=0;
+ nFlags=0;
+ fHeight=0.0;
+ fWidthFak=1.0;
+ fOblAngle=0.0;
+ nTextGenFlags=0;
+ fLastHeightUsed=0.0;
+ sPrimFontFile[0]=0;
+ sBigFontFile[0]=0;
+}
+
+void DXFStyle::Read(DXFGroupReader & rDGR)
+{
+ while (rDGR.Read()!=0) {
+ switch(rDGR.GetG()) {
+ case 2: strncpy( sName, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 70: nFlags=rDGR.GetI(); break;
+ case 40: fHeight=rDGR.GetF(); break;
+ case 41: fWidthFak=rDGR.GetF(); break;
+ case 50: fOblAngle=rDGR.GetF(); break;
+ case 71: nTextGenFlags=rDGR.GetI(); break;
+ case 42: fLastHeightUsed=rDGR.GetF(); break;
+ case 3: strncpy( sPrimFontFile, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ case 4: strncpy( sBigFontFile, rDGR.GetS(), DXF_MAX_STRING_LEN + 1 ); break;
+ }
+ }
+}
+
+//----------------------------------DXFVPort-----------------------------------
+
+DXFVPort::DXFVPort()
+{
+ pSucc=NULL;
+
+ sName[0]=0;
+ nFlags=0;
+ fMinX=0;
+ fMinY=0;
+ fMaxX=0;
+ fMaxY=0;
+ fCenterX=0;
+ fCenterY=0;
+ fSnapBaseX=0;
+ fSnapBaseY=0;
+ fSnapSapcingX=0;
+ fSnapSpacingY=0;
+ fGridX=0;
+ fGridY=0;
+ aDirection=DXFVector(0,0,1);
+ aTarget=DXFVector(0,0,0);
+ fHeight=0;
+ fAspectRatio=0;
+ fLensLength=0;
+ fFrontClipPlane=0;
+ fBackClipPlane=0;
+ fTwistAngle=0;
+ nStatus=0;
+ nID=0;
+ nMode=0;
+ nCircleZoomPercent=0;
+ nFastZoom=0;
+ nUCSICON=0;
+ nSnap=0;
+ nGrid=0;
+ nSnapStyle=0;
+ nSnapIsopair=0;
+}
+
+void DXFVPort::Read(DXFGroupReader & rDGR)
+{
+ while (rDGR.Read()!=0) {
+ switch(rDGR.GetG()) {
+ case 2: strncpy( sName, rDGR.GetS(), DXF_MAX_STRING_LEN + 1); break;
+ case 70: nFlags=rDGR.GetI(); break;
+ case 10: fMinX=rDGR.GetF(); break;
+ case 20: fMinY=rDGR.GetF(); break;
+ case 11: fMaxX=rDGR.GetF(); break;
+ case 21: fMaxY=rDGR.GetF(); break;
+ case 12: fCenterX=rDGR.GetF(); break;
+ case 22: fCenterY=rDGR.GetF(); break;
+ case 13: fSnapBaseX=rDGR.GetF(); break;
+ case 23: fSnapBaseY=rDGR.GetF(); break;
+ case 14: fSnapSapcingX=rDGR.GetF(); break;
+ case 24: fSnapSpacingY=rDGR.GetF(); break;
+ case 15: fGridX=rDGR.GetF(); break;
+ case 25: fGridY=rDGR.GetF(); break;
+ case 16: aDirection.fx=rDGR.GetF(); break;
+ case 26: aDirection.fy=rDGR.GetF(); break;
+ case 36: aDirection.fz=rDGR.GetF(); break;
+ case 17: aTarget.fx=rDGR.GetF(); break;
+ case 27: aTarget.fy=rDGR.GetF(); break;
+ case 37: aTarget.fz=rDGR.GetF(); break;
+ case 40: fHeight=rDGR.GetF(); break;
+ case 41: fAspectRatio=rDGR.GetF(); break;
+ case 42: fLensLength=rDGR.GetF(); break;
+ case 43: fFrontClipPlane=rDGR.GetF(); break;
+ case 44: fBackClipPlane=rDGR.GetF(); break;
+ case 51: fTwistAngle=rDGR.GetF(); break;
+ case 68: nStatus=rDGR.GetI(); break;
+ case 69: nID=rDGR.GetI(); break;
+ case 71: nMode=rDGR.GetI(); break;
+ case 72: nCircleZoomPercent=rDGR.GetI(); break;
+ case 73: nFastZoom=rDGR.GetI(); break;
+ case 74: nUCSICON=rDGR.GetI(); break;
+ case 75: nSnap=rDGR.GetI(); break;
+ case 76: nGrid=rDGR.GetI(); break;
+ case 77: nSnapStyle=rDGR.GetI(); break;
+ case 78: nSnapIsopair=rDGR.GetI(); break;
+ }
+ }
+}
+
+//----------------------------------DXFTables----------------------------------
+
+
+DXFTables::DXFTables()
+{
+ pLTypes=NULL;
+ pLayers=NULL;
+ pStyles=NULL;
+ pVPorts=NULL;
+}
+
+
+DXFTables::~DXFTables()
+{
+ Clear();
+}
+
+
+void DXFTables::Read(DXFGroupReader & rDGR)
+{
+ DXFLType * * ppLT, * pLT;
+ DXFLayer * * ppLa, * pLa;
+ DXFStyle * * ppSt, * pSt;
+ DXFVPort * * ppVP, * pVP;
+
+ ppLT=&pLTypes;
+ while(*ppLT!=NULL) ppLT=&((*ppLT)->pSucc);
+
+ ppLa=&pLayers;
+ while(*ppLa!=NULL) ppLa=&((*ppLa)->pSucc);
+
+ ppSt=&pStyles;
+ while(*ppSt!=NULL) ppSt=&((*ppSt)->pSucc);
+
+ ppVP=&pVPorts;
+ while(*ppVP!=NULL) ppVP=&((*ppVP)->pSucc);
+
+ for (;;) {
+ while (rDGR.GetG()!=0) rDGR.Read();
+ if (strcmp(rDGR.GetS(),"EOF")==0 ||
+ strcmp(rDGR.GetS(),"ENDSEC")==0) break;
+ else if (strcmp(rDGR.GetS(),"LTYPE")==0) {
+ pLT=new DXFLType;
+ pLT->Read(rDGR);
+ *ppLT=pLT;
+ ppLT=&(pLT->pSucc);
+ }
+ else if (strcmp(rDGR.GetS(),"LAYER")==0) {
+ pLa=new DXFLayer;
+ pLa->Read(rDGR);
+ *ppLa=pLa;
+ ppLa=&(pLa->pSucc);
+ }
+ else if (strcmp(rDGR.GetS(),"STYLE")==0) {
+ pSt=new DXFStyle;
+ pSt->Read(rDGR);
+ *ppSt=pSt;
+ ppSt=&(pSt->pSucc);
+ }
+ else if (strcmp(rDGR.GetS(),"VPORT")==0) {
+ pVP=new DXFVPort;
+ pVP->Read(rDGR);
+ *ppVP=pVP;
+ ppVP=&(pVP->pSucc);
+ }
+ else rDGR.Read();
+ }
+}
+
+
+void DXFTables::Clear()
+{
+ DXFLType * pLT;
+ DXFLayer * pLa;
+ DXFStyle * pSt;
+ DXFVPort * pVP;
+
+ while (pStyles!=NULL) {
+ pSt=pStyles;
+ pStyles=pSt->pSucc;
+ delete pSt;
+ }
+ while (pLayers!=NULL) {
+ pLa=pLayers;
+ pLayers=pLa->pSucc;
+ delete pLa;
+ }
+ while (pLTypes!=NULL) {
+ pLT=pLTypes;
+ pLTypes=pLT->pSucc;
+ delete pLT;
+ }
+ while (pVPorts!=NULL) {
+ pVP=pVPorts;
+ pVPorts=pVP->pSucc;
+ delete pVP;
+ }
+}
+
+
+DXFLType * DXFTables::SearchLType(const char * pName) const
+{
+ DXFLType * p;
+ for (p=pLTypes; p!=NULL; p=p->pSucc) {
+ if (strcmp(pName,p->sName)==0) break;
+ }
+ return p;
+}
+
+
+DXFLayer * DXFTables::SearchLayer(const char * pName) const
+{
+ DXFLayer * p;
+ for (p=pLayers; p!=NULL; p=p->pSucc) {
+ if (strcmp(pName,p->sName)==0) break;
+ }
+ return p;
+}
+
+
+DXFVPort * DXFTables::SearchVPort(const char * pName) const
+{
+ DXFVPort * p;
+ for (p=pVPorts; p!=NULL; p=p->pSucc) {
+ if (strcmp(pName,p->sName)==0) break;
+ }
+ return p;
+}
+
+
diff --git a/filter/source/graphicfilter/idxf/dxftblrd.hxx b/filter/source/graphicfilter/idxf/dxftblrd.hxx
new file mode 100644
index 000000000000..afa6274bd6cc
--- /dev/null
+++ b/filter/source/graphicfilter/idxf/dxftblrd.hxx
@@ -0,0 +1,183 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+#ifndef _DXFTBLRD_HXX
+#define _DXFTBLRD_HXX
+
+#include <dxfgrprd.hxx>
+#include <dxfvec.hxx>
+
+
+//----------------------------------------------------------------------------
+//------------------ Linien-Typ ----------------------------------------------
+//----------------------------------------------------------------------------
+
+#define DXF_MAX_DASH_COUNT 32
+
+class DXFLType {
+
+public:
+
+ DXFLType * pSucc;
+
+ char sName[DXF_MAX_STRING_LEN+1]; // 2
+ long nFlags; // 70
+ char sDescription[DXF_MAX_STRING_LEN+1]; // 3
+ long nDashCount; // 73
+ double fPatternLength; // 40
+ double fDash[DXF_MAX_DASH_COUNT]; // 49,49,...
+
+ DXFLType();
+ void Read(DXFGroupReader & rDGR);
+};
+
+
+//----------------------------------------------------------------------------
+//------------------ Layer ---------------------------------------------------
+//----------------------------------------------------------------------------
+
+class DXFLayer {
+
+public:
+
+ DXFLayer * pSucc;
+
+ char sName[DXF_MAX_STRING_LEN+1]; // 2
+ long nFlags; // 70
+ long nColor; // 62
+ char sLineType[DXF_MAX_STRING_LEN+1]; // 6
+
+ DXFLayer();
+ void Read(DXFGroupReader & rDGR);
+};
+
+
+//----------------------------------------------------------------------------
+//------------------ Style ---------------------------------------------------
+//----------------------------------------------------------------------------
+
+class DXFStyle {
+
+public:
+
+ DXFStyle * pSucc;
+
+ char sName[DXF_MAX_STRING_LEN+1]; // 2
+ long nFlags; // 70
+ double fHeight; // 40
+ double fWidthFak; // 41
+ double fOblAngle; // 50
+ long nTextGenFlags; // 71
+ double fLastHeightUsed; // 42
+ char sPrimFontFile[DXF_MAX_STRING_LEN+1]; // 3
+ char sBigFontFile[DXF_MAX_STRING_LEN+1]; // 4
+
+ DXFStyle();
+ void Read(DXFGroupReader & rDGR);
+};
+
+
+//----------------------------------------------------------------------------
+//------------------ VPort ---------------------------------------------------
+//----------------------------------------------------------------------------
+
+class DXFVPort {
+
+public:
+
+ DXFVPort * pSucc;
+
+ char sName[DXF_MAX_STRING_LEN+1]; // 2
+ long nFlags; // 70
+ double fMinX; // 10
+ double fMinY; // 20
+ double fMaxX; // 11
+ double fMaxY; // 21
+ double fCenterX; // 12
+ double fCenterY; // 22
+ double fSnapBaseX; // 13
+ double fSnapBaseY; // 23
+ double fSnapSapcingX; // 14
+ double fSnapSpacingY; // 24
+ double fGridX; // 15
+ double fGridY; // 25
+ DXFVector aDirection; // 16,26,36
+ DXFVector aTarget; // 17,27,37
+ double fHeight; // 40
+ double fAspectRatio; // 41
+ double fLensLength; // 42
+ double fFrontClipPlane; // 43
+ double fBackClipPlane; // 44
+ double fTwistAngle; // 51
+ long nStatus; // 68
+ long nID; // 69
+ long nMode; // 71
+ long nCircleZoomPercent; // 72
+ long nFastZoom; // 73
+ long nUCSICON; // 74
+ long nSnap; // 75
+ long nGrid; // 76
+ long nSnapStyle; // 77
+ long nSnapIsopair; // 78
+
+ DXFVPort();
+ void Read(DXFGroupReader & rDGR);
+};
+
+
+//----------------------------------------------------------------------------
+//------------------ Tabellen ------------------------------------------------
+//----------------------------------------------------------------------------
+
+class DXFTables {
+
+public:
+
+ DXFLType * pLTypes; // Liste der Linientypen
+ DXFLayer * pLayers; // Liste der Layers
+ DXFStyle * pStyles; // Liste der Styles
+ DXFVPort * pVPorts; // Liste der Viewports
+
+ DXFTables();
+ ~DXFTables();
+
+ void Read(DXFGroupReader & rDGR);
+ // Liest die Tabellen ein bis zu einem ENDSEC oder EOF
+ // (unbekannte Dinge/Tabellen werden uebersprungen)
+
+ void Clear();
+
+ // Suche nach Tabelleneintraegen:
+ DXFLType * SearchLType(const char * pName) const;
+ DXFLayer * SearchLayer(const char * pName) const;
+ DXFVPort * SearchVPort(const char * pName) const;
+
+};
+
+#endif
+
+
diff --git a/filter/source/graphicfilter/idxf/dxfvec.cxx b/filter/source/graphicfilter/idxf/dxfvec.cxx
new file mode 100644
index 000000000000..d71100cdc6b1
--- /dev/null
+++ b/filter/source/graphicfilter/idxf/dxfvec.cxx
@@ -0,0 +1,254 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_filter.hxx"
+
+#include <math.h>
+#include <dxfvec.hxx>
+
+
+//---------------------------- DXFVector ---------------------------------------
+
+
+double DXFVector::Abs() const
+{
+ return sqrt(SProd(*this));
+}
+
+
+DXFVector DXFVector::Unit() const
+{
+ double flen;
+
+ flen=Abs();
+ if (flen!=0) return (*this)*(1.0/flen);
+ else return DXFVector(1.0,0.0,0.0);
+}
+
+
+//---------------------------- DXFTransform ------------------------------------
+
+
+DXFTransform::DXFTransform() :
+ aMX(1.0, 0.0, 0.0),
+ aMY(0.0, 1.0, 0.0),
+ aMZ(0.0, 0.0, 1.0),
+ aMP(0.0, 0.0, 0.0)
+{
+}
+
+
+DXFTransform::DXFTransform(double fScaleX, double fScaleY, double fScaleZ,
+ const DXFVector & rShift) :
+ aMX(fScaleX, 0.0, 0.0),
+ aMY(0.0, fScaleY, 0.0),
+ aMZ(0.0, 0.0, fScaleZ),
+ aMP(rShift)
+{
+}
+
+
+DXFTransform::DXFTransform(double fScaleX, double fScaleY, double fScaleZ,
+ double fRotAngle,
+ const DXFVector & rShift) :
+ aMX(0.0, 0.0, 0.0),
+ aMY(0.0, 0.0, 0.0),
+ aMZ(0.0, 0.0, fScaleZ),
+ aMP(rShift)
+{
+ aMX.fx=cos(3.14159265359/180.0*fRotAngle);
+ aMX.fy=sin(3.14159265359/180.0*fRotAngle);
+ aMY.fx=-aMX.fy;
+ aMY.fy=aMX.fx;
+ aMX*=fScaleX;
+ aMY*=fScaleY;
+}
+
+
+DXFTransform::DXFTransform(const DXFVector & rExtrusion) :
+ aMX(), aMY(), aMZ(), aMP(0.0, 0.0, 0.0)
+{
+ // 'Arbitrary Axis Algorithm' (siehe DXF-Doku von Autodesk)
+ if ( fabs(rExtrusion.fx) < 1.0/64.0 && fabs(rExtrusion.fy) < 1.0/64.0) {
+ aMX = DXFVector(0.0, 1.0, 0.0) * rExtrusion;
+ }
+ else {
+ aMX = DXFVector(0.0, 0.0, 1.0) * rExtrusion;
+ }
+ aMX=aMX.Unit();
+ aMY=(rExtrusion*aMX).Unit();
+ aMZ=rExtrusion.Unit();
+}
+
+
+DXFTransform::DXFTransform(const DXFVector & rViewDir, const DXFVector & rViewTarget) :
+ aMX(), aMY(), aMZ(), aMP()
+{
+ DXFVector aV;
+
+ aV=rViewDir.Unit();
+ aMX.fz=aV.fx;
+ aMY.fz=aV.fy;
+ aMZ.fz=aV.fz;
+
+ aMZ.fx=0;
+ if (aV.fx==0) aMY.fx=0; else aMY.fx=sqrt(1/(1+aV.fy*aV.fy/(aV.fx*aV.fx)));
+ aMX.fx=sqrt(1-aMY.fx*aMY.fx);
+ if (aV.fx*aV.fy*aMY.fx>0) aMX.fx=-aMX.fx;
+
+ aV=aV*DXFVector(aMX.fx,aMY.fx,aMZ.fx);
+ aMX.fy=aV.fx;
+ aMY.fy=aV.fy;
+ aMZ.fy=aV.fz;
+
+ if (aMZ.fy<0) {
+ aMX.fy=-aMX.fy;
+ aMY.fy=-aMY.fy;
+ aMZ.fy=-aMZ.fy;
+ aMX.fx=-aMX.fx;
+ aMY.fx=-aMY.fx;
+ }
+
+ aV=DXFVector(0,0,0)-rViewTarget;
+ aMP.fx = aV.fx * aMX.fx + aV.fy * aMY.fx + aV.fz * aMZ.fx;
+ aMP.fy = aV.fx * aMX.fy + aV.fy * aMY.fy + aV.fz * aMZ.fy;
+ aMP.fz = aV.fx * aMX.fz + aV.fy * aMY.fz + aV.fz * aMZ.fz;
+}
+
+
+DXFTransform::DXFTransform(const DXFTransform & rT1, const DXFTransform & rT2) :
+ aMX(),aMY(),aMZ(),aMP()
+{
+ rT2.TransDir(rT1.aMX,aMX);
+ rT2.TransDir(rT1.aMY,aMY);
+ rT2.TransDir(rT1.aMZ,aMZ);
+ rT2.Transform(rT1.aMP,aMP);
+}
+
+
+void DXFTransform::Transform(const DXFVector & rSrc, DXFVector & rTgt) const
+{
+ rTgt.fx = rSrc.fx * aMX.fx + rSrc.fy * aMY.fx + rSrc.fz * aMZ.fx + aMP.fx;
+ rTgt.fy = rSrc.fx * aMX.fy + rSrc.fy * aMY.fy + rSrc.fz * aMZ.fy + aMP.fy;
+ rTgt.fz = rSrc.fx * aMX.fz + rSrc.fy * aMY.fz + rSrc.fz * aMZ.fz + aMP.fz;
+}
+
+
+void DXFTransform::Transform(const DXFVector & rSrc, Point & rTgt) const
+{
+ rTgt.X()=(long)( rSrc.fx * aMX.fx + rSrc.fy * aMY.fx + rSrc.fz * aMZ.fx + aMP.fx + 0.5 );
+ rTgt.Y()=(long)( rSrc.fx * aMX.fy + rSrc.fy * aMY.fy + rSrc.fz * aMZ.fy + aMP.fy + 0.5 );
+}
+
+
+void DXFTransform::TransDir(const DXFVector & rSrc, DXFVector & rTgt) const
+{
+ rTgt.fx = rSrc.fx * aMX.fx + rSrc.fy * aMY.fx + rSrc.fz * aMZ.fx;
+ rTgt.fy = rSrc.fx * aMX.fy + rSrc.fy * aMY.fy + rSrc.fz * aMZ.fy;
+ rTgt.fz = rSrc.fx * aMX.fz + rSrc.fy * aMY.fz + rSrc.fz * aMZ.fz;
+}
+
+
+BOOL DXFTransform::TransCircleToEllipse(double fRadius, double & rEx, double & rEy) const
+{
+ double fMXAbs=aMX.Abs();
+ double fMYAbs=aMY.Abs();
+ double fNearNull=(fMXAbs+fMYAbs)*0.001;
+
+ if (fabs(aMX.fy)<=fNearNull && fabs(aMX.fz)<=fNearNull &&
+ fabs(aMY.fx)<=fNearNull && fabs(aMY.fz)<=fNearNull)
+ {
+ rEx=fabs(aMX.fx*fRadius);
+ rEy=fabs(aMY.fy*fRadius);
+ return TRUE;
+ }
+ else if (fabs(aMX.fx)<=fNearNull && fabs(aMX.fz)<=fNearNull &&
+ fabs(aMY.fy)<=fNearNull && fabs(aMY.fz)<=fNearNull)
+ {
+ rEx=fabs(aMY.fx*fRadius);
+ rEy=fabs(aMX.fy*fRadius);
+ return TRUE;
+ }
+ else if (fabs(fMXAbs-fMYAbs)<=fNearNull &&
+ fabs(aMX.fz)<=fNearNull && fabs(aMY.fz)<=fNearNull)
+ {
+ rEx=rEy=fabs(((fMXAbs+fMYAbs)/2)*fRadius);
+ return TRUE;
+ }
+ else return FALSE;
+}
+
+LineInfo DXFTransform::Transform(const DXFLineInfo& aDXFLineInfo) const
+{
+ double fex,fey,scale;
+
+ fex=sqrt(aMX.fx*aMX.fx + aMX.fy*aMX.fy);
+ fey=sqrt(aMY.fx*aMY.fx + aMY.fy*aMY.fy);
+ scale = (fex+fey)/2.0;
+
+ LineInfo aLineInfo;
+
+ aLineInfo.SetStyle( aDXFLineInfo.eStyle );
+ aLineInfo.SetWidth( (sal_Int32) (aDXFLineInfo.fWidth * scale + 0.5) );
+ aLineInfo.SetDashCount( static_cast< USHORT >( aDXFLineInfo.nDashCount ) );
+ aLineInfo.SetDashLen( (sal_Int32) (aDXFLineInfo.fDashLen * scale + 0.5) );
+ aLineInfo.SetDotCount( static_cast< USHORT >( aDXFLineInfo.nDotCount ) );
+ aLineInfo.SetDotLen( (sal_Int32) (aDXFLineInfo.fDotLen * scale + 0.5) );
+ aLineInfo.SetDistance( (sal_Int32) (aDXFLineInfo.fDistance * scale + 0.5) );
+
+ if ( aLineInfo.GetDashCount() > 0 && aLineInfo.GetDashLen() == 0 )
+ aLineInfo.SetDashLen(1);
+
+ if ( aLineInfo.GetDotCount() > 0 && aLineInfo.GetDotLen() == 0 )
+ aLineInfo.SetDotLen(1);
+
+ return aLineInfo;
+}
+
+ULONG DXFTransform::TransLineWidth(double fW) const
+{
+ double fex,fey;
+
+ fex=sqrt(aMX.fx*aMX.fx + aMX.fy*aMX.fy);
+ fey=sqrt(aMY.fx*aMY.fx + aMY.fy*aMY.fy);
+ // ###
+ // printf("fex=%f fey=%f\n", fex, fey);
+ return (ULONG)(fabs(fW)*(fex+fey)/2.0+0.5);
+}
+
+
+double DXFTransform::CalcRotAngle() const
+{
+ return atan2(aMX.fy,aMX.fx)/3.14159265359*180.0;
+}
+
+BOOL DXFTransform::Mirror() const
+{
+ if (aMZ.SProd(aMX*aMY)<0) return TRUE; else return FALSE;
+}
+
diff --git a/filter/source/graphicfilter/idxf/dxfvec.hxx b/filter/source/graphicfilter/idxf/dxfvec.hxx
new file mode 100644
index 000000000000..2f7734e5277f
--- /dev/null
+++ b/filter/source/graphicfilter/idxf/dxfvec.hxx
@@ -0,0 +1,261 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+#ifndef _DXFVEC_HXX
+#define _DXFVEC_HXX
+
+#include <tools/gen.hxx>
+#include <vcl/lineinfo.hxx>
+
+class DXFLineInfo {
+public:
+ LineStyle eStyle;
+ double fWidth;
+ sal_Int32 nDashCount;
+ double fDashLen;
+ sal_Int32 nDotCount;
+ double fDotLen;
+ double fDistance;
+
+ DXFLineInfo() :
+ eStyle(LINE_SOLID),
+ fWidth(0),
+ nDashCount(0),
+ fDashLen(0),
+ nDotCount(0),
+ fDotLen(0),
+ fDistance(0) {}
+
+ DXFLineInfo(const DXFLineInfo& x) :
+ eStyle(x.eStyle),
+ fWidth(x.fWidth),
+ nDashCount(x.nDashCount),
+ fDashLen(x.fDashLen),
+ nDotCount(x.nDotCount),
+ fDotLen(x.fDotLen),
+ fDistance(x.fDistance) {}
+
+};
+
+
+//------------------------------------------------------------------------------
+//---------------------------- DXFVector ---------------------------------------
+//------------------------------------------------------------------------------
+// Allgemeiner 3D-Vektor mit double
+
+class DXFVector {
+
+public:
+
+ double fx,fy,fz; // public ! - Warum nicht ?
+
+ inline DXFVector(double fX=0.0, double fY=0.0, double fZ=0.0);
+ inline DXFVector(const DXFVector & rV);
+
+ // Addition/Subtraktion:
+ DXFVector & operator += (const DXFVector & rV);
+ DXFVector operator + (const DXFVector & rV) const;
+ DXFVector & operator -= (const DXFVector & rV);
+ DXFVector operator - (const DXFVector & rV) const;
+
+ // Vektorprodukt
+ DXFVector operator * (const DXFVector & rV) const;
+
+ // Skalarprodukt:
+ double SProd(const DXFVector & rV) const;
+
+ // Multiplikation mit Skalar:
+ DXFVector & operator *= (double fs);
+ DXFVector operator * (double fs) const;
+
+ // Laenge:
+ double Abs() const;
+
+ // Vektor gleicher Richtung und der Laenge 1:
+ DXFVector Unit() const;
+
+ // Aequivalenz oder nicht:
+ BOOL operator == (const DXFVector & rV) const;
+ BOOL operator != (const DXFVector & rV) const;
+};
+
+//------------------------------------------------------------------------------
+//---------------------------- DXFTransform ------------------------------------
+//------------------------------------------------------------------------------
+// Eine Transformationsmatrix, spezialisiert auf unser Problem
+
+class DXFTransform {
+
+public:
+
+ DXFTransform();
+ // Zielkoordinate = Quellkoordinate
+
+ DXFTransform(double fScaleX, double fScaleY, double fScaleZ,
+ const DXFVector & rShift);
+ // Zielkoordinate = Verschoben(Skaliert(Quellkoorinate))
+
+ DXFTransform(double fScaleX, double fScaleY, double fScaleZ,
+ double fRotAngle,
+ const DXFVector & rShift);
+ // Zielkoordinate = Verschoben(Gedreht(Skaliert(Quellkoorinate)))
+ // Drehung geshieht um die Z-Achse, fRotAngle in Grad.
+
+ DXFTransform(const DXFVector & rExtrusion);
+ // Transformation "ECS->WCS" per "Entity Extrusion Direction"
+ // und dem "Arbitrary Axis Algorithm"
+ // (Siehe DXF-Docu von AutoDesk)
+
+ DXFTransform(const DXFVector & rViewDir, const DXFVector & rViewTarget);
+ // Transformation Objektraum->Bildraum anhand von Richtung und
+ // Zielpunkt eines ViewPort.
+ // (siehe DXF-Docu von AutoDesk: VPORT)
+
+ DXFTransform(const DXFTransform & rT1, const DXFTransform & rT2);
+ // Zielkoordinate = rT2(rT1(Quellkoorinate))
+
+
+ void Transform(const DXFVector & rSrc, DXFVector & rTgt) const;
+ // Transformation DXFVector nach DXFVector
+
+ void Transform(const DXFVector & rSrc, Point & rTgt) const;
+ // Transformation DXFVector nach SvPoint
+
+ void TransDir(const DXFVector & rSrc, DXFVector & rTgt) const;
+ // Transformation eines relativen Vektors (also kein Verschiebung)
+
+ BOOL TransCircleToEllipse(double fRadius, double & rEx, double & rEy) const;
+ // Versucht, einen Kreis (in der XY-Ebene) zu transformieren, so dass eine
+ // ausgerichtete Ellipse entsteht. Wenn das nicht geht, weil Ellipse
+ // in belibieger Lage entstehen wuerde, wird FALSE geliefert.
+ // (Der Mittelpunkt wird hiermit nicht transformiert, nehme Transform(..))
+
+ ULONG TransLineWidth(double fW) const;
+ // Transformiert die Liniendicke (so gut es geht)
+
+ double CalcRotAngle() const;
+ // Ermittelt den Rotationswinkel um die Z-Achse (in Grad)
+
+ BOOL Mirror() const;
+ // Liefert TRUE, wenn die Matrix ein Linkssystem bildet
+
+ LineInfo Transform(const DXFLineInfo& aDXFLineInfo) const;
+ // Transform to LineInfo
+
+private:
+ DXFVector aMX;
+ DXFVector aMY;
+ DXFVector aMZ;
+ DXFVector aMP;
+};
+
+//------------------------------------------------------------------------------
+//------------------------------- inlines --------------------------------------
+//------------------------------------------------------------------------------
+
+
+inline DXFVector::DXFVector(double fX, double fY, double fZ)
+{
+ fx=fX; fy=fY; fz=fZ;
+}
+
+
+inline DXFVector::DXFVector(const DXFVector & rV)
+{
+ fx=rV.fx; fy=rV.fy; fz=rV.fz;
+}
+
+
+inline DXFVector & DXFVector::operator += (const DXFVector & rV)
+{
+ fx+=rV.fx; fy+=rV.fy; fz+=rV.fz;
+ return *this;
+}
+
+
+inline DXFVector DXFVector::operator + (const DXFVector & rV) const
+{
+ return DXFVector(fx+rV.fx, fy+rV.fy, fz+rV.fz);
+}
+
+
+inline DXFVector & DXFVector::operator -= (const DXFVector & rV)
+{
+ fx-=rV.fx; fy-=rV.fy; fz-=rV.fz;
+ return *this;
+}
+
+
+inline DXFVector DXFVector::operator - (const DXFVector & rV) const
+{
+ return DXFVector(fx-rV.fx, fy-rV.fy, fz-rV.fz);
+}
+
+
+inline DXFVector DXFVector::operator * (const DXFVector & rV) const
+{
+ return DXFVector(
+ fy * rV.fz - fz * rV.fy,
+ fz * rV.fx - fx * rV.fz,
+ fx * rV.fy - fy * rV.fx
+ );
+}
+
+
+inline double DXFVector::SProd(const DXFVector & rV) const
+{
+ return fx*rV.fx + fy*rV.fy + fz*rV.fz;
+}
+
+
+inline DXFVector & DXFVector::operator *= (double fs)
+{
+ fx*=fs; fy*=fs; fz*=fs;
+ return *this;
+}
+
+
+inline DXFVector DXFVector::operator * (double fs) const
+{
+ return DXFVector(fx*fs,fy*fs,fz*fs);
+}
+
+
+inline BOOL DXFVector::operator == (const DXFVector & rV) const
+{
+ if (fx==rV.fx && fy==rV.fy && fz==rV.fz) return TRUE;
+ else return FALSE;
+}
+
+
+inline BOOL DXFVector::operator != (const DXFVector & rV) const
+{
+ if (fx!=rV.fx || fy!=rV.fy || fz!=rV.fz) return TRUE;
+ else return FALSE;
+}
+
+#endif
diff --git a/filter/source/graphicfilter/idxf/exports.map b/filter/source/graphicfilter/idxf/exports.map
new file mode 100644
index 000000000000..941e4ab9bde8
--- /dev/null
+++ b/filter/source/graphicfilter/idxf/exports.map
@@ -0,0 +1,7 @@
+UDK_3_0_0 {
+ global:
+ GraphicImport;
+
+ local:
+ *;
+};
diff --git a/filter/source/graphicfilter/idxf/idxf.cxx b/filter/source/graphicfilter/idxf/idxf.cxx
new file mode 100644
index 000000000000..149f4c2feb78
--- /dev/null
+++ b/filter/source/graphicfilter/idxf/idxf.cxx
@@ -0,0 +1,82 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_filter.hxx"
+
+#include <string.h>
+#include <vcl/gdimtf.hxx>
+#include <vcl/graph.hxx>
+#include <vcl/virdev.hxx>
+#include "dxf2mtf.hxx"
+#include <math.h>
+
+//================== GraphicImport - die exportierte Funktion ================
+
+extern "C" BOOL __LOADONCALLAPI GraphicImport(SvStream & rStream, Graphic & rGraphic, FilterConfigItem*, BOOL )
+{
+ DXFRepresentation aDXF;
+ DXF2GDIMetaFile aConverter;
+ GDIMetaFile aMTF;
+
+ if ( aDXF.Read( rStream, 0, 60 ) == FALSE )
+ return FALSE;
+ if ( aConverter.Convert( aDXF, aMTF, 60, 100 ) == FALSE )
+ return FALSE;
+ rGraphic=Graphic(aMTF);
+
+ return TRUE;
+}
+
+//============================= fuer Windows ==================================
+#ifndef GCC
+#endif
+
+#ifdef WIN
+
+static HINSTANCE hDLLInst = 0; // HANDLE der DLL
+
+extern "C" int CALLBACK LibMain( HINSTANCE hDLL, WORD, WORD nHeap, LPSTR )
+{
+#ifndef WNT
+ if ( nHeap )
+ UnlockData( 0 );
+#endif
+
+ hDLLInst = hDLL;
+
+ return TRUE;
+}
+
+extern "C" int CALLBACK WEP( int )
+{
+ return 1;
+}
+
+#endif
+
+
diff --git a/filter/source/graphicfilter/idxf/makefile.mk b/filter/source/graphicfilter/idxf/makefile.mk
new file mode 100644
index 000000000000..046f0765a74e
--- /dev/null
+++ b/filter/source/graphicfilter/idxf/makefile.mk
@@ -0,0 +1,79 @@
+#*************************************************************************
+#
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# Copyright 2000, 2010 Oracle and/or its affiliates.
+#
+# OpenOffice.org - a multi-platform office productivity suite
+#
+# This file is part of OpenOffice.org.
+#
+# OpenOffice.org is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# only, as published by the Free Software Foundation.
+#
+# OpenOffice.org is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Lesser General Public License version 3 for more details
+# (a copy is included in the LICENSE file that accompanied this code).
+#
+# You should have received a copy of the GNU Lesser General Public License
+# version 3 along with OpenOffice.org. If not, see
+# <http://www.openoffice.org/license.html>
+# for a copy of the LGPLv3 License.
+#
+#*************************************************************************
+
+PRJ=..$/..$/..
+
+PRJNAME=filter
+TARGET=idxf
+DEPTARGET=vidxf
+
+# --- Settings -----------------------------------------------------------
+
+.INCLUDE : settings.mk
+
+# --- Allgemein ----------------------------------------------------------
+
+.IF "$(editdebug)"!="" || "$(EDITDEBUG)"!=""
+CDEFS+= -DEDITDEBUG
+.ENDIF
+.IF "$(L10N_framework)"==""
+EXCEPTIONSFILES=\
+ $(SLO)$/dxfentrd.obj \
+ $(SLO)$/dxf2mtf.obj
+
+SLOFILES = $(SLO)$/dxfgrprd.obj \
+ $(SLO)$/dxfvec.obj \
+ $(SLO)$/dxfentrd.obj \
+ $(SLO)$/dxfblkrd.obj \
+ $(SLO)$/dxftblrd.obj \
+ $(SLO)$/dxfreprd.obj \
+ $(SLO)$/dxf2mtf.obj \
+ $(SLO)$/idxf.obj
+
+# ==========================================================================
+
+SHL1TARGET= idx$(DLLPOSTFIX)
+SHL1IMPLIB= idxf
+SHL1STDLIBS= $(VCLLIB) $(TOOLSLIB) $(SALLIB)
+
+SHL1LIBS= $(SLB)$/idxf.lib # $(LB)$/rtftoken.lib
+
+.IF "$(GUI)" != "UNX"
+.IF "$(COM)" != "GCC"
+SHL1OBJS= $(SLO)$/idxf.obj
+.ENDIF
+.ENDIF
+
+SHL1VERSIONMAP=exports.map
+SHL1DEF= $(MISC)$/$(SHL1TARGET).def
+
+DEF1NAME=$(SHL1TARGET)
+.ENDIF
+
+# ==========================================================================
+
+.INCLUDE : target.mk
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-14 18:27:19 +0000