* Default constructor.
*
*/
-RS_FilterDXF::RS_FilterDXF(): RS_FilterInterface()
+FilterDXF::FilterDXF(): FilterInterface()
{
- RS_DEBUG->print("RS_FilterDXF::RS_FilterDXF()");
+ DEBUG->print("FilterDXF::FilterDXF()");
addImportFormat(RS2::FormatDXF);
addExportFormat(RS2::FormatDXF);
graphic = NULL;
//exportVersion = DL_Codes::VER_2002;
//systemVariables.setAutoDelete(true);
- RS_DEBUG->print("RS_FilterDXF::RS_FilterDXF(): OK");
+ DEBUG->print("FilterDXF::FilterDXF(): OK");
}
/**
* Destructor.
*/
-RS_FilterDXF::~RS_FilterDXF()
+FilterDXF::~FilterDXF()
{
- RS_DEBUG->print("RS_FilterDXF::~RS_FilterDXF()");
- RS_DEBUG->print("RS_FilterDXF::~RS_FilterDXF(): OK");
+ DEBUG->print("FilterDXF::~FilterDXF()");
+ DEBUG->print("FilterDXF::~FilterDXF(): OK");
}
/**
* will be created or the graphics from which the entities are
* taken to be stored in a file.
*/
-bool RS_FilterDXF::fileImport(Drawing & g, const QString & file, RS2::FormatType /*type*/)
+bool FilterDXF::fileImport(Drawing & g, const QString & file, RS2::FormatType /*type*/)
{
- RS_DEBUG->print("RS_FilterDXF::fileImport");
- //RS_DEBUG->timestamp();
+ DEBUG->print("FilterDXF::fileImport");
+ //DEBUG->timestamp();
- RS_DEBUG->print("DXF Filter: importing file '%s'...", (const char *)QFile::encodeName(file));
+ DEBUG->print("DXF Filter: importing file '%s'...", (const char *)QFile::encodeName(file));
graphic = &g;
currentContainer = graphic;
this->file = file;
- RS_DEBUG->print("graphic->countLayers(): %d", graphic->countLayers());
+ DEBUG->print("graphic->countLayers(): %d", graphic->countLayers());
//graphic->setAutoUpdateBorders(false);
- RS_DEBUG->print("RS_FilterDXF::fileImport: reading file");
+ DEBUG->print("FilterDXF::fileImport: reading file");
bool success = dxf.in((const char *)QFile::encodeName(file), this);
- RS_DEBUG->print("RS_FilterDXF::fileImport: reading file: OK");
+ DEBUG->print("FilterDXF::fileImport: reading file: OK");
//graphic->setAutoUpdateBorders(true);
if (!success)
{
- RS_DEBUG->print(RS_Debug::D_WARNING, "Cannot open DXF file '%s'.",
+ DEBUG->print(Debug::D_WARNING, "Cannot open DXF file '%s'.",
(const char *)QFile::encodeName(file));
return false;
}
- RS_DEBUG->print("RS_FilterDXF::fileImport: adding variables");
+ DEBUG->print("FilterDXF::fileImport: adding variables");
// add some variables that need to be there for DXF drawings:
if (graphic->getVariableString("$DIMSTYLE", "").isEmpty())
{
- RS_DEBUG->print("RS_FilterDXF::fileImport: adding DIMSTYLE");
+ DEBUG->print("FilterDXF::fileImport: adding DIMSTYLE");
graphic->addVariable("$DIMSTYLE", "Standard", 2);
- RS_DEBUG->print("RS_FilterDXF::fileImport: adding DIMSTYLE: OK");
+ DEBUG->print("FilterDXF::fileImport: adding DIMSTYLE: OK");
}
- RS_DEBUG->print("RS_FilterDXF::fileImport: adding variables: OK");
+ DEBUG->print("FilterDXF::fileImport: adding variables: OK");
- RS_DEBUG->print("RS_FilterDXF::fileImport: updating inserts");
+ DEBUG->print("FilterDXF::fileImport: updating inserts");
graphic->updateInserts();
- RS_DEBUG->print("RS_FilterDXF::fileImport: updating inserts: OK");
+ DEBUG->print("FilterDXF::fileImport: updating inserts: OK");
- RS_DEBUG->print("RS_FilterDXF::fileImport OK");
- //RS_DEBUG->timestamp();
+ DEBUG->print("FilterDXF::fileImport OK");
+ //DEBUG->timestamp();
return true;
}
/**
* Implementation of the method which handles layers.
*/
-void RS_FilterDXF::addLayer(const DL_LayerData& data) {
- RS_DEBUG->print("RS_FilterDXF::addLayer");
- RS_DEBUG->print(" adding layer: %s", data.name.c_str());
+void FilterDXF::addLayer(const DL_LayerData& data) {
+ DEBUG->print("FilterDXF::addLayer");
+ DEBUG->print(" adding layer: %s", data.name.c_str());
- RS_DEBUG->print("RS_FilterDXF::addLayer: creating layer");
- RS_Layer* layer = new RS_Layer(data.name.c_str());
- RS_DEBUG->print("RS_FilterDXF::addLayer: set pen");
+ DEBUG->print("FilterDXF::addLayer: creating layer");
+ Layer* layer = new Layer(data.name.c_str());
+ DEBUG->print("FilterDXF::addLayer: set pen");
layer->setPen(attributesToPen(attributes));
//layer->setFlags(data.flags&0x07);
- RS_DEBUG->print("RS_FilterDXF::addLayer: flags");
+ DEBUG->print("FilterDXF::addLayer: flags");
if (data.flags&0x01) {
layer->freeze(true);
}
layer->lock(true);
}
- RS_DEBUG->print("RS_FilterDXF::addLayer: add layer to graphic");
+ DEBUG->print("FilterDXF::addLayer: add layer to graphic");
graphic->addLayer(layer);
- RS_DEBUG->print("RS_FilterDXF::addLayer: OK");
+ DEBUG->print("FilterDXF::addLayer: OK");
}
/**
*
* @todo Adding blocks to blocks (stack for currentContainer)
*/
-void RS_FilterDXF::addBlock(const DL_BlockData & data)
+void FilterDXF::addBlock(const DL_BlockData & data)
{
- RS_DEBUG->print("RS_FilterDXF::addBlock");
- RS_DEBUG->print(" adding block: %s", data.name.c_str());
+ DEBUG->print("FilterDXF::addBlock");
+ DEBUG->print(" adding block: %s", data.name.c_str());
// Prevent special blocks (paper_space, model_space) from being added:
if (QString(data.name.c_str()).toLower() != "*paper_space0"
#ifndef RS_NO_COMPLEX_ENTITIES
if (QString(data.name.c_str()).startsWith("__CE"))
{
- RS_EntityContainer * ec = new RS_EntityContainer();
+ EntityContainer * ec = new EntityContainer();
ec->setLayer("0");
currentContainer = ec;
graphic->addEntity(ec);
{
#endif
Vector bp(data.bpx, data.bpy);
- RS_Block * block = new RS_Block(graphic, RS_BlockData(data.name.c_str(), bp, false));
+ Block * block = new Block(graphic, BlockData(data.name.c_str(), bp, false));
//block->setFlags(flags);
if (graphic->addBlock(block))
/**
* Implementation of the method which closes blocks.
*/
-void RS_FilterDXF::endBlock()
+void FilterDXF::endBlock()
{
currentContainer = graphic;
}
/**
* Implementation of the method which handles point entities.
*/
-void RS_FilterDXF::addPoint(const DL_PointData & data)
+void FilterDXF::addPoint(const DL_PointData & data)
{
Vector v(data.x, data.y);
- RS_Point * entity = new RS_Point(currentContainer, RS_PointData(v));
+ Point * entity = new Point(currentContainer, PointData(v));
setEntityAttributes(entity, attributes);
currentContainer->addEntity(entity);
}
/**
* Implementation of the method which handles line entities.
*/
-void RS_FilterDXF::addLine(const DL_LineData & data)
+void FilterDXF::addLine(const DL_LineData & data)
{
- RS_DEBUG->print("RS_FilterDXF::addLine");
+ DEBUG->print("FilterDXF::addLine");
Vector v1(data.x1, data.y1);
Vector v2(data.x2, data.y2);
- RS_DEBUG->print("RS_FilterDXF::addLine: create line");
+ DEBUG->print("FilterDXF::addLine: create line");
if (currentContainer == NULL)
- RS_DEBUG->print("RS_FilterDXF::addLine: currentContainer is NULL");
+ DEBUG->print("FilterDXF::addLine: currentContainer is NULL");
- RS_Line * entity = new RS_Line(currentContainer, RS_LineData(v1, v2));
- RS_DEBUG->print("RS_FilterDXF::addLine: set attributes");
+ Line * entity = new Line(currentContainer, LineData(v1, v2));
+ DEBUG->print("FilterDXF::addLine: set attributes");
setEntityAttributes(entity, attributes);
- RS_DEBUG->print("RS_FilterDXF::addLine: add entity");
+ DEBUG->print("FilterDXF::addLine: add entity");
currentContainer->addEntity(entity);
- RS_DEBUG->print("RS_FilterDXF::addLine: OK");
+ DEBUG->print("FilterDXF::addLine: OK");
}
/**
* @param angle1 Start angle in deg (!)
* @param angle2 End angle in deg (!)
*/
-void RS_FilterDXF::addArc(const DL_ArcData& data) {
- RS_DEBUG->print("RS_FilterDXF::addArc");
+void FilterDXF::addArc(const DL_ArcData& data) {
+ DEBUG->print("FilterDXF::addArc");
//printf("LINE (%12.6f, %12.6f, %12.6f) (%12.6f, %12.6f, %12.6f)\n",
// p1[0], p1[1], p1[2],
// p2[0], p2[1], p2[2]);
Vector v(data.cx, data.cy);
- RS_ArcData d(v, data.radius,
+ ArcData d(v, data.radius,
data.angle1/ARAD,
data.angle2/ARAD,
false);
- RS_Arc* entity = new RS_Arc(currentContainer, d);
+ Arc* entity = new Arc(currentContainer, d);
setEntityAttributes(entity, attributes);
currentContainer->addEntity(entity);
* @param angle1 Start angle in rad (!)
* @param angle2 End angle in rad (!)
*/
-void RS_FilterDXF::addEllipse(const DL_EllipseData& data) {
- RS_DEBUG->print("RS_FilterDXF::addEllipse");
+void FilterDXF::addEllipse(const DL_EllipseData& data) {
+ DEBUG->print("FilterDXF::addEllipse");
Vector v1(data.cx, data.cy);
Vector v2(data.mx, data.my);
- RS_EllipseData ed(v1, v2,
+ EllipseData ed(v1, v2,
data.ratio,
data.angle1,
data.angle2,
false);
- RS_Ellipse* entity = new RS_Ellipse(currentContainer, ed);
+ Ellipse* entity = new Ellipse(currentContainer, ed);
setEntityAttributes(entity, attributes);
currentContainer->addEntity(entity);
/**
* Implementation of the method which handles circle entities.
*/
-void RS_FilterDXF::addCircle(const DL_CircleData& data) {
- RS_DEBUG->print("RS_FilterDXF::addCircle");
+void FilterDXF::addCircle(const DL_CircleData& data) {
+ DEBUG->print("FilterDXF::addCircle");
//printf("LINE (%12.6f, %12.6f, %12.6f) (%12.6f, %12.6f, %12.6f)\n",
// p1[0], p1[1], p1[2],
// p2[0], p2[1], p2[2]);
Vector v(data.cx, data.cy);
- RS_CircleData d(v, data.radius);
- RS_Circle* entity = new RS_Circle(currentContainer, d);
+ CircleData d(v, data.radius);
+ Circle* entity = new Circle(currentContainer, d);
setEntityAttributes(entity, attributes);
currentContainer->addEntity(entity);
/**
* Implementation of the method which handles polyline entities.
*/
-void RS_FilterDXF::addPolyline(const DL_PolylineData& data) {
- RS_DEBUG->print("RS_FilterDXF::addPolyline");
- //RS_DEBUG->print("RS_FilterDXF::addPolyline()");
- RS_PolylineData d(Vector(false),
+void FilterDXF::addPolyline(const DL_PolylineData& data) {
+ DEBUG->print("FilterDXF::addPolyline");
+ //DEBUG->print("FilterDXF::addPolyline()");
+ PolylineData d(Vector(false),
Vector(false),
data.flags&0x1);
- polyline = new RS_Polyline(currentContainer, d);
+ polyline = new Polyline(currentContainer, d);
setEntityAttributes(polyline, attributes);
currentContainer->addEntity(polyline);
/**
* Implementation of the method which handles polyline vertices.
*/
-void RS_FilterDXF::addVertex(const DL_VertexData& data) {
- RS_DEBUG->print("RS_FilterDXF::addVertex(): %f/%f bulge: %f",
+void FilterDXF::addVertex(const DL_VertexData& data) {
+ DEBUG->print("FilterDXF::addVertex(): %f/%f bulge: %f",
data.x, data.y, data.bulge);
Vector v(data.x, data.y);
/**
* Implementation of the method which handles splines.
*/
-void RS_FilterDXF::addSpline(const DL_SplineData& data) {
- RS_DEBUG->print("RS_FilterDXF::addSpline: degree: %d", data.degree);
+void FilterDXF::addSpline(const DL_SplineData& data) {
+ DEBUG->print("FilterDXF::addSpline: degree: %d", data.degree);
if (data.degree>=1 && data.degree<=3) {
- RS_SplineData d(data.degree, ((data.flags&0x1)==0x1));
- spline = new RS_Spline(currentContainer, d);
+ SplineData d(data.degree, ((data.flags&0x1)==0x1));
+ spline = new Spline(currentContainer, d);
setEntityAttributes(spline, attributes);
currentContainer->addEntity(spline);
} else {
- RS_DEBUG->print(RS_Debug::D_WARNING,
- "RS_FilterDXF::addSpline: Invalid degree for spline: %d. "
+ DEBUG->print(Debug::D_WARNING,
+ "FilterDXF::addSpline: Invalid degree for spline: %d. "
"Accepted values are 1..3.", data.degree);
}
}
-/*virtual*/ void RS_FilterDXF::addKnot(const DL_KnotData &)
+/*virtual*/ void FilterDXF::addKnot(const DL_KnotData &)
{
}
/**
* Implementation of the method which handles spline control points.
*/
-void RS_FilterDXF::addControlPoint(const DL_ControlPointData & data)
+void FilterDXF::addControlPoint(const DL_ControlPointData & data)
{
- RS_DEBUG->print("RS_FilterDXF::addControlPoint: %f/%f", data.x, data.y);
+ DEBUG->print("FilterDXF::addControlPoint: %f/%f", data.x, data.y);
Vector v(data.x, data.y);
/**
* Implementation of the method which handles inserts.
*/
-void RS_FilterDXF::addInsert(const DL_InsertData & data)
+void FilterDXF::addInsert(const DL_InsertData & data)
{
- RS_DEBUG->print("RS_FilterDXF::addInsert");
+ DEBUG->print("FilterDXF::addInsert");
if (QString(data.name.c_str()).left(3) == "A$C")
return;
//cout << "Insert: " << name << " " << ip << " " << cols << "/" << rows << endl;
- RS_InsertData d(data.name.c_str(), ip, sc, data.angle / ARAD, data.cols, data.rows,
+ InsertData d(data.name.c_str(), ip, sc, data.angle / ARAD, data.cols, data.rows,
sp, NULL, RS2::NoUpdate);
- RS_Insert * entity = new RS_Insert(currentContainer, d);
+ Insert * entity = new Insert(currentContainer, d);
setEntityAttributes(entity, attributes);
- RS_DEBUG->print(" id: %d", entity->getId());
+ DEBUG->print(" id: %d", entity->getId());
//entity->update();
currentContainer->addEntity(entity);
}
-/*virtual*/ void RS_FilterDXF::addTrace(const DL_TraceData &)
+/*virtual*/ void FilterDXF::addTrace(const DL_TraceData &)
{
}
-/*virtual*/ void RS_FilterDXF::addSolid(const DL_SolidData &)
+/*virtual*/ void FilterDXF::addSolid(const DL_SolidData &)
{
}
* Implementation of the method which handles text
* chunks for MText entities.
*/
-void RS_FilterDXF::addMTextChunk(const char * text)
+void FilterDXF::addMTextChunk(const char * text)
{
- RS_DEBUG->print("RS_FilterDXF::addMTextChunk: %s", text);
+ DEBUG->print("FilterDXF::addMTextChunk: %s", text);
//mtext += text;
//mtext += QString::fromUtf8(text);
/*
QCString locallyEncoded = text;
- QString enc = RS_System::getEncoding(variables.getString("$DWGCODEPAGE", "ANSI_1252"));
+ QString enc = System::getEncoding(variables.getString("$DWGCODEPAGE", "ANSI_1252"));
QTextCodec *codec = QTextCodec::codecForName(enc); // get the codec for Japanese
if (codec!=NULL) {
mtext += codec->toUnicode(toNativeString(locallyEncoded));
* Implementation of the method which handles
* multi texts (MTEXT).
*/
-void RS_FilterDXF::addMText(const DL_MTextData & data)
+void FilterDXF::addMText(const DL_MTextData & data)
{
- RS_DEBUG->print("RS_FilterDXF::addMText: %s", data.text.c_str());
+ DEBUG->print("FilterDXF::addMText: %s", data.text.c_str());
Vector ip(data.ipx, data.ipy);
RS2::VAlign valign;
mtext += QString(data.text.c_str());
QString locallyEncoded = mtext;
- QString enc = RS_System::getEncoding(variables.getString("$DWGCODEPAGE", "ANSI_1252"));
+ QString enc = System::getEncoding(variables.getString("$DWGCODEPAGE", "ANSI_1252"));
// get the codec for Japanese
QTextCodec * codec = QTextCodec::codecForName(enc.toAscii());
sty = variables.getString("$TEXTSTYLE", "Standard");
}
- RS_DEBUG->print("Text as unicode:");
- RS_DEBUG->printUnicode(mtext);
+ DEBUG->print("Text as unicode:");
+ DEBUG->printUnicode(mtext);
- RS_TextData d(ip, data.height, data.width, valign, halign, dir, lss,
+ TextData d(ip, data.height, data.width, valign, halign, dir, lss,
data.lineSpacingFactor, mtext, sty, data.angle, RS2::NoUpdate);
- RS_Text * entity = new RS_Text(currentContainer, d);
+ Text * entity = new Text(currentContainer, d);
setEntityAttributes(entity, attributes);
entity->update();
* Implementation of the method which handles
* texts (TEXT).
*/
-void RS_FilterDXF::addText(const DL_TextData& data) {
- RS_DEBUG->print("RS_FilterDXF::addText");
+void FilterDXF::addText(const DL_TextData& data) {
+ DEBUG->print("FilterDXF::addText");
int attachmentPoint;
Vector refPoint;
double angle = data.angle;
* Implementation of the method which handles
* dimensions (DIMENSION).
*/
-RS_DimensionData RS_FilterDXF::convDimensionData(
+DimensionData FilterDXF::convDimensionData(
const DL_DimensionData& data) {
Vector defP(data.dpx, data.dpy);
sty = variables.getString("$DIMSTYLE", "Standard");
}
- RS_DEBUG->print("Text as unicode:");
- RS_DEBUG->printUnicode(t);
+ DEBUG->print("Text as unicode:");
+ DEBUG->printUnicode(t);
// data needed to add the actual dimension entity
- return RS_DimensionData(defP, midP,
+ return DimensionData(defP, midP,
valign, halign,
lss,
data.lineSpacingFactor,
* Implementation of the method which handles
* aligned dimensions (DIMENSION).
*/
-void RS_FilterDXF::addDimAlign(const DL_DimensionData& data,
+void FilterDXF::addDimAlign(const DL_DimensionData& data,
const DL_DimAlignedData& edata) {
- RS_DEBUG->print("RS_FilterDXF::addDimAligned");
+ DEBUG->print("FilterDXF::addDimAligned");
- RS_DimensionData dimensionData = convDimensionData(data);
+ DimensionData dimensionData = convDimensionData(data);
Vector ext1(edata.epx1, edata.epy1);
Vector ext2(edata.epx2, edata.epy2);
- RS_DimAlignedData d(ext1, ext2);
+ DimAlignedData d(ext1, ext2);
- RS_DimAligned* entity = new RS_DimAligned(currentContainer,
+ DimAligned* entity = new DimAligned(currentContainer,
dimensionData, d);
setEntityAttributes(entity, attributes);
entity->update();
* Implementation of the method which handles
* linear dimensions (DIMENSION).
*/
-void RS_FilterDXF::addDimLinear(const DL_DimensionData& data,
+void FilterDXF::addDimLinear(const DL_DimensionData& data,
const DL_DimLinearData& edata) {
- RS_DEBUG->print("RS_FilterDXF::addDimLinear");
+ DEBUG->print("FilterDXF::addDimLinear");
- RS_DimensionData dimensionData = convDimensionData(data);
+ DimensionData dimensionData = convDimensionData(data);
Vector dxt1(edata.dpx1, edata.dpy1);
Vector dxt2(edata.dpx2, edata.dpy2);
- RS_DimLinearData d(dxt1, dxt2, RS_Math::deg2rad(edata.angle),
- RS_Math::deg2rad(edata.oblique));
+ DimLinearData d(dxt1, dxt2, Math::deg2rad(edata.angle),
+ Math::deg2rad(edata.oblique));
- RS_DimLinear* entity = new RS_DimLinear(currentContainer,
+ DimLinear* entity = new DimLinear(currentContainer,
dimensionData, d);
setEntityAttributes(entity, attributes);
entity->update();
* Implementation of the method which handles
* radial dimensions (DIMENSION).
*/
-void RS_FilterDXF::addDimRadial(const DL_DimensionData& data,
+void FilterDXF::addDimRadial(const DL_DimensionData& data,
const DL_DimRadialData& edata) {
- RS_DEBUG->print("RS_FilterDXF::addDimRadial");
+ DEBUG->print("FilterDXF::addDimRadial");
- RS_DimensionData dimensionData = convDimensionData(data);
+ DimensionData dimensionData = convDimensionData(data);
Vector dp(edata.dpx, edata.dpy);
- RS_DimRadialData d(dp, edata.leader);
+ DimRadialData d(dp, edata.leader);
- RS_DimRadial* entity = new RS_DimRadial(currentContainer,
+ DimRadial* entity = new DimRadial(currentContainer,
dimensionData, d);
setEntityAttributes(entity, attributes);
* Implementation of the method which handles
* diametric dimensions (DIMENSION).
*/
-void RS_FilterDXF::addDimDiametric(const DL_DimensionData& data,
+void FilterDXF::addDimDiametric(const DL_DimensionData& data,
const DL_DimDiametricData& edata) {
- RS_DEBUG->print("RS_FilterDXF::addDimDiametric");
+ DEBUG->print("FilterDXF::addDimDiametric");
- RS_DimensionData dimensionData = convDimensionData(data);
+ DimensionData dimensionData = convDimensionData(data);
Vector dp(edata.dpx, edata.dpy);
- RS_DimDiametricData d(dp, edata.leader);
+ DimDiametricData d(dp, edata.leader);
- RS_DimDiametric* entity = new RS_DimDiametric(currentContainer,
+ DimDiametric* entity = new DimDiametric(currentContainer,
dimensionData, d);
setEntityAttributes(entity, attributes);
* Implementation of the method which handles
* angular dimensions (DIMENSION).
*/
-void RS_FilterDXF::addDimAngular(const DL_DimensionData& data,
+void FilterDXF::addDimAngular(const DL_DimensionData& data,
const DL_DimAngularData& edata) {
- RS_DEBUG->print("RS_FilterDXF::addDimAngular");
+ DEBUG->print("FilterDXF::addDimAngular");
- RS_DimensionData dimensionData = convDimensionData(data);
+ DimensionData dimensionData = convDimensionData(data);
Vector dp1(edata.dpx1, edata.dpy1);
Vector dp2(edata.dpx2, edata.dpy2);
Vector dp3(edata.dpx3, edata.dpy3);
Vector dp4(edata.dpx4, edata.dpy4);
- RS_DimAngularData d(dp1, dp2, dp3, dp4);
+ DimAngularData d(dp1, dp2, dp3, dp4);
- RS_DimAngular* entity = new RS_DimAngular(currentContainer,
+ DimAngular* entity = new DimAngular(currentContainer,
dimensionData, d);
setEntityAttributes(entity, attributes);
* Implementation of the method which handles
* angular dimensions (DIMENSION).
*/
-void RS_FilterDXF::addDimAngular3P(const DL_DimensionData& data,
+void FilterDXF::addDimAngular3P(const DL_DimensionData& data,
const DL_DimAngular3PData& edata) {
- RS_DEBUG->print("RS_FilterDXF::addDimAngular3P");
+ DEBUG->print("FilterDXF::addDimAngular3P");
- RS_DimensionData dimensionData = convDimensionData(data);
+ DimensionData dimensionData = convDimensionData(data);
Vector dp1(edata.dpx3, edata.dpy3);
Vector dp2(edata.dpx1, edata.dpy1);
Vector dp3(edata.dpx3, edata.dpy3);
Vector dp4 = dimensionData.definitionPoint;
dimensionData.definitionPoint = Vector(edata.dpx2, edata.dpy2);
- RS_DimAngularData d(dp1, dp2, dp3, dp4);
+ DimAngularData d(dp1, dp2, dp3, dp4);
- RS_DimAngular* entity = new RS_DimAngular(currentContainer,
+ DimAngular* entity = new DimAngular(currentContainer,
dimensionData, d);
setEntityAttributes(entity, attributes);
/**
* Implementation of the method which handles leader entities.
*/
-void RS_FilterDXF::addLeader(const DL_LeaderData& data) {
- RS_DEBUG->print("RS_FilterDXF::addDimLeader");
- //RS_DEBUG->print("RS_FilterDXF::addPolyline()");
- RS_LeaderData d(data.arrowHeadFlag==1);
- leader = new RS_Leader(currentContainer, d);
+void FilterDXF::addLeader(const DL_LeaderData& data) {
+ DEBUG->print("FilterDXF::addDimLeader");
+ //DEBUG->print("FilterDXF::addPolyline()");
+ LeaderData d(data.arrowHeadFlag==1);
+ leader = new Leader(currentContainer, d);
setEntityAttributes(leader, attributes);
currentContainer->addEntity(leader);
/**
* Implementation of the method which handles leader vertices.
*/
-void RS_FilterDXF::addLeaderVertex(const DL_LeaderVertexData& data) {
- RS_DEBUG->print("RS_FilterDXF::addLeaderVertex");
- //RS_DEBUG->print("RS_FilterDXF::addVertex() bulge: %f", bulge);
+void FilterDXF::addLeaderVertex(const DL_LeaderVertexData& data) {
+ DEBUG->print("FilterDXF::addLeaderVertex");
+ //DEBUG->print("FilterDXF::addVertex() bulge: %f", bulge);
Vector v(data.x, data.y);
/**
* Implementation of the method which handles hatch entities.
*/
-void RS_FilterDXF::addHatch(const DL_HatchData& data) {
- RS_DEBUG->print("RS_FilterDXF::addHatch()");
+void FilterDXF::addHatch(const DL_HatchData& data) {
+ DEBUG->print("FilterDXF::addHatch()");
- hatch = new RS_Hatch(currentContainer,
- RS_HatchData(data.solid,
+ hatch = new Hatch(currentContainer,
+ HatchData(data.solid,
data.scale,
data.angle,
QString(data.pattern.c_str())));
/**
* Implementation of the method which handles hatch loops.
*/
-void RS_FilterDXF::addHatchLoop(const DL_HatchLoopData& /*data*/) {
- RS_DEBUG->print("RS_FilterDXF::addHatchLoop()");
+void FilterDXF::addHatchLoop(const DL_HatchLoopData& /*data*/) {
+ DEBUG->print("FilterDXF::addHatchLoop()");
if (hatch!=NULL) {
- hatchLoop = new RS_EntityContainer(hatch);
+ hatchLoop = new EntityContainer(hatch);
hatchLoop->setLayer(NULL);
hatch->addEntity(hatchLoop);
}
/**
* Implementation of the method which handles hatch edge entities.
*/
-void RS_FilterDXF::addHatchEdge(const DL_HatchEdgeData& data) {
- RS_DEBUG->print("RS_FilterDXF::addHatchEdge()");
+void FilterDXF::addHatchEdge(const DL_HatchEdgeData& data) {
+ DEBUG->print("FilterDXF::addHatchEdge()");
if (hatchLoop!=NULL) {
- RS_Entity* e = NULL;
+ Entity* e = NULL;
switch (data.type) {
case 1:
- RS_DEBUG->print("RS_FilterDXF::addHatchEdge(): "
+ DEBUG->print("FilterDXF::addHatchEdge(): "
"line: %f,%f %f,%f",
data.x1, data.y1, data.x2, data.y2);
- e = new RS_Line(hatchLoop,
- RS_LineData(Vector(data.x1, data.y1),
+ e = new Line(hatchLoop,
+ LineData(Vector(data.x1, data.y1),
Vector(data.x2, data.y2)));
break;
case 2:
if (data.ccw && data.angle1<1.0e-6 && data.angle2>2*M_PI-1.0e-6) {
- e = new RS_Circle(hatchLoop,
- RS_CircleData(Vector(data.cx, data.cy),
+ e = new Circle(hatchLoop,
+ CircleData(Vector(data.cx, data.cy),
data.radius));
} else {
if (data.ccw) {
- e = new RS_Arc(
+ e = new Arc(
hatchLoop,
- RS_ArcData(Vector(data.cx, data.cy),
+ ArcData(Vector(data.cx, data.cy),
data.radius,
- RS_Math::correctAngle(data.angle1),
- RS_Math::correctAngle(data.angle2),
+ Math::correctAngle(data.angle1),
+ Math::correctAngle(data.angle2),
false));
} else {
- e = new RS_Arc(
+ e = new Arc(
hatchLoop,
- RS_ArcData(Vector(data.cx, data.cy),
+ ArcData(Vector(data.cx, data.cy),
data.radius,
- RS_Math::correctAngle(2*M_PI-data.angle1),
- RS_Math::correctAngle(2*M_PI-data.angle2),
+ Math::correctAngle(2*M_PI-data.angle1),
+ Math::correctAngle(2*M_PI-data.angle2),
true));
}
}
/**
* Implementation of the method which handles image entities.
*/
-void RS_FilterDXF::addImage(const DL_ImageData& data) {
- RS_DEBUG->print("RS_FilterDXF::addImage");
+void FilterDXF::addImage(const DL_ImageData& data) {
+ DEBUG->print("FilterDXF::addImage");
Vector ip(data.ipx, data.ipy);
Vector uv(data.ux, data.uy);
Vector vv(data.vx, data.vy);
Vector size(data.width, data.height);
- RS_Image* image =
- new RS_Image(
+ Image* image =
+ new Image(
currentContainer,
- RS_ImageData(QString(data.ref.c_str()).toInt(NULL, 16),
+ ImageData(QString(data.ref.c_str()).toInt(NULL, 16),
ip, uv, vv,
size,
QString(""),
/**
* Implementation of the method which links image entities to image files.
*/
-void RS_FilterDXF::linkImage(const DL_ImageDefData & data)
+void FilterDXF::linkImage(const DL_ImageDefData & data)
{
- RS_DEBUG->print("RS_FilterDXF::linkImage");
+ DEBUG->print("FilterDXF::linkImage");
int handle = QString(data.ref.c_str()).toInt(NULL, 16);
QString sfile(data.file.c_str());
// first: absolute path:
if (!fiBitmap.exists())
{
- RS_DEBUG->print("File %s doesn't exist.", (const char *)QFile::encodeName(sfile));
+ DEBUG->print("File %s doesn't exist.", (const char *)QFile::encodeName(sfile));
// try relative path:
// QString f1 = fiDxf.dirPath(true) + "/" + sfile;
QString f1 = fiDxf.absolutePath() + "/" + sfile;
sfile = f1;
else
{
- RS_DEBUG->print("File %s doesn't exist.", (const char *)QFile::encodeName(f1));
+ DEBUG->print("File %s doesn't exist.", (const char *)QFile::encodeName(f1));
// try drawing path:
// QString f2 = fiDxf.dirPath(true) + "/" + fiBitmap.fileName();
QString f2 = fiDxf.absolutePath() + "/" + fiBitmap.fileName();
}
else
{
- RS_DEBUG->print("File %s doesn't exist.", (const char *)QFile::encodeName(f2));
+ DEBUG->print("File %s doesn't exist.", (const char *)QFile::encodeName(f2));
}
}
}
// Also link images in subcontainers (e.g. inserts):
- for(RS_Entity * e=graphic->firstEntity(RS2::ResolveNone); e!=NULL;
+ for(Entity * e=graphic->firstEntity(RS2::ResolveNone); e!=NULL;
e=graphic->nextEntity(RS2::ResolveNone))
{
if (e->rtti() == RS2::EntityImage)
{
- RS_Image * img = (RS_Image *)e;
+ Image * img = (Image *)e;
if (img->getHandle() == handle)
{
img->setFile(sfile);
- RS_DEBUG->print("image found: %s", (const char *)QFile::encodeName(img->getFile()));
+ DEBUG->print("image found: %s", (const char *)QFile::encodeName(img->getFile()));
img->update();
}
}
// update images in blocks:
for(uint i=0; i<graphic->countBlocks(); ++i)
{
- RS_Block * b = graphic->blockAt(i);
+ Block * b = graphic->blockAt(i);
- for(RS_Entity * e=b->firstEntity(RS2::ResolveNone); e!=NULL; e=b->nextEntity(RS2::ResolveNone))
+ for(Entity * e=b->firstEntity(RS2::ResolveNone); e!=NULL; e=b->nextEntity(RS2::ResolveNone))
{
if (e->rtti() == RS2::EntityImage)
{
- RS_Image * img = (RS_Image *)e;
+ Image * img = (Image *)e;
if (img->getHandle() == handle)
{
img->setFile(sfile);
- RS_DEBUG->print("image in block found: %s",
+ DEBUG->print("image in block found: %s",
(const char*)QFile::encodeName(img->getFile()));
img->update();
}
}
}
- RS_DEBUG->print("linking image: OK");
+ DEBUG->print("linking image: OK");
}
/**
* Finishes a hatch entity.
*/
-void RS_FilterDXF::endEntity()
+void FilterDXF::endEntity()
{
- RS_DEBUG->print("RS_FilterDXF::endEntity");
+ DEBUG->print("FilterDXF::endEntity");
if (hatch != NULL)
{
- RS_DEBUG->print("hatch->update()");
+ DEBUG->print("hatch->update()");
if (hatch->validate())
hatch->update();
else
{
graphic->removeEntity(hatch);
- RS_DEBUG->print(RS_Debug::D_ERROR, "RS_FilterDXF::endEntity(): updating hatch failed: invalid hatch area");
+ DEBUG->print(Debug::D_ERROR, "FilterDXF::endEntity(): updating hatch failed: invalid hatch area");
}
hatch = NULL;
}
}
-/*virtual*/ void RS_FilterDXF::endSequence()
+/*virtual*/ void FilterDXF::endSequence()
{
}
/**
* Sets a vector variable from the DXF file.
*/
-void RS_FilterDXF::setVariableVector(const char * key, double v1, double v2, double v3, int code)
+void FilterDXF::setVariableVector(const char * key, double v1, double v2, double v3, int code)
{
- RS_DEBUG->print("RS_FilterDXF::setVariableVector");
+ DEBUG->print("FilterDXF::setVariableVector");
// update document's variable list:
if (currentContainer->rtti() == RS2::EntityGraphic)
/**
* Sets a string variable from the DXF file.
*/
-void RS_FilterDXF::setVariableString(const char * key, const char * value, int code)
+void FilterDXF::setVariableString(const char * key, const char * value, int code)
{
- RS_DEBUG->print("RS_FilterDXF::setVariableString");
+ DEBUG->print("FilterDXF::setVariableString");
// update local DXF variable list:
variables.add(QString(key), QString(value), code);
/**
* Sets an int variable from the DXF file.
*/
-void RS_FilterDXF::setVariableInt(const char* key, int value, int code) {
- RS_DEBUG->print("RS_FilterDXF::setVariableInt");
+void FilterDXF::setVariableInt(const char* key, int value, int code) {
+ DEBUG->print("FilterDXF::setVariableInt");
// update document's variable list:
if (currentContainer->rtti()==RS2::EntityGraphic) {
/**
* Sets a double variable from the DXF file.
*/
-void RS_FilterDXF::setVariableDouble(const char* key, double value, int code) {
- RS_DEBUG->print("RS_FilterDXF::setVariableDouble");
+void FilterDXF::setVariableDouble(const char* key, double value, int code) {
+ DEBUG->print("FilterDXF::setVariableDouble");
// update document's variable list:
if (currentContainer->rtti() == RS2::EntityGraphic)
*
* @param file Full path to the DXF file that will be written.
*/
-bool RS_FilterDXF::fileExport(Drawing & g, const QString & file, RS2::FormatType type)
+bool FilterDXF::fileExport(Drawing & g, const QString & file, RS2::FormatType type)
{
- RS_DEBUG->print("RS_FilterDXF::fileExport: exporting file '%s'...",
+ DEBUG->print("FilterDXF::fileExport: exporting file '%s'...",
(const char *)QFile::encodeName(file));
- RS_DEBUG->print("RS_FilterDXF::fileExport: file type '%d'", (int)type);
+ DEBUG->print("FilterDXF::fileExport: file type '%d'", (int)type);
this->graphic = &g;
if (QFileInfo(path).isWritable() == false)
{
- RS_DEBUG->print("RS_FilterDXF::fileExport: can't write file: no permission");
+ DEBUG->print("FilterDXF::fileExport: can't write file: no permission");
return false;
}
//
if (dw == NULL)
{
- RS_DEBUG->print("RS_FilterDXF::fileExport: can't write file");
+ DEBUG->print("FilterDXF::fileExport: can't write file");
return false;
}
// Header
- RS_DEBUG->print("writing headers...");
+ DEBUG->print("writing headers...");
dxf.writeHeader(*dw);
// Variables
- RS_DEBUG->print("writing variables...");
+ DEBUG->print("writing variables...");
writeVariables(*dw);
// Section TABLES
- RS_DEBUG->print("writing tables...");
+ DEBUG->print("writing tables...");
dw->sectionTables();
// VPORT:
dxf.writeVPort(*dw);
// Line types:
- RS_DEBUG->print("writing line types...");
+ DEBUG->print("writing line types...");
int numLT = (int)RS2::BorderLineX2 - (int)RS2::LineByBlock;
if (type == RS2::FormatDXF12)
dw->tableEnd();
// Layers:
- RS_DEBUG->print("writing layers...");
+ DEBUG->print("writing layers...");
dw->tableLayers(graphic->countLayers());
for(uint i=0; i<graphic->countLayers(); ++i)
{
- RS_Layer * l = graphic->layerAt(i);
+ Layer * l = graphic->layerAt(i);
writeLayer(*dw, l);
}
dw->tableEnd();
// STYLE:
- RS_DEBUG->print("writing styles...");
+ DEBUG->print("writing styles...");
dxf.writeStyle(*dw);
// VIEW:
- RS_DEBUG->print("writing views...");
+ DEBUG->print("writing views...");
dxf.writeView(*dw);
// UCS:
- RS_DEBUG->print("writing ucs...");
+ DEBUG->print("writing ucs...");
dxf.writeUcs(*dw);
// Appid:
- RS_DEBUG->print("writing appid...");
+ DEBUG->print("writing appid...");
dw->tableAppid(1);
writeAppid(*dw, "ACAD");
dw->tableEnd();
// DIMSTYLE:
- RS_DEBUG->print("writing dim styles...");
+ DEBUG->print("writing dim styles...");
dxf.writeDimStyle(*dw,
graphic->getVariableDouble("$DIMASZ", 2.5),
graphic->getVariableDouble("$DIMEXE", 1.25),
// BLOCK_RECORD:
if (type == RS2::FormatDXF)
{
- RS_DEBUG->print("writing block records...");
+ DEBUG->print("writing block records...");
dxf.writeBlockRecord(*dw);
for(uint i=0; i<graphic->countBlocks(); ++i)
{
- RS_Block * blk = graphic->blockAt(i);
+ Block * blk = graphic->blockAt(i);
dxf.writeBlockRecord(*dw, std::string((const char *)blk->getName().toLocal8Bit()));
/*
// v2.0.4.9..:
}
// end of tables:
- RS_DEBUG->print("writing end of section TABLES...");
+ DEBUG->print("writing end of section TABLES...");
dw->sectionEnd();
// Section BLOCKS:
- RS_DEBUG->print("writing blocks...");
+ DEBUG->print("writing blocks...");
dw->sectionBlocks();
if (type == RS2::FormatDXF)
{
- RS_Block b1(graphic, RS_BlockData("*Model_Space", Vector(0.0, 0.0), false));
+ Block b1(graphic, BlockData("*Model_Space", Vector(0.0, 0.0), false));
writeBlock(*dw, &b1);
- RS_Block b2(graphic, RS_BlockData("*Paper_Space", Vector(0.0, 0.0), false));
+ Block b2(graphic, BlockData("*Paper_Space", Vector(0.0, 0.0), false));
writeBlock(*dw, &b2);
- RS_Block b3(graphic, RS_BlockData("*Paper_Space0", Vector(0.0, 0.0), false));
+ Block b3(graphic, BlockData("*Paper_Space0", Vector(0.0, 0.0), false));
writeBlock(*dw, &b3);
}
for(uint i=0; i<graphic->countBlocks(); ++i)
{
- RS_Block * blk = graphic->blockAt(i);
+ Block * blk = graphic->blockAt(i);
// Save block if it's not a model or paper space:
// Careful: other blocks with * / $ exist
dw->sectionEnd();
// Section ENTITIES:
- RS_DEBUG->print("writing section ENTITIES...");
+ DEBUG->print("writing section ENTITIES...");
dw->sectionEntities();
- for(RS_Entity * e=graphic->firstEntity(RS2::ResolveNone); e!=NULL;
+ for(Entity * e=graphic->firstEntity(RS2::ResolveNone); e!=NULL;
e=graphic->nextEntity(RS2::ResolveNone))
{
writeEntity(*dw, e);
}
- RS_DEBUG->print("writing end of section ENTITIES...");
+ DEBUG->print("writing end of section ENTITIES...");
dw->sectionEnd();
if (type == RS2::FormatDXF)
{
- RS_DEBUG->print("writing section OBJECTS...");
+ DEBUG->print("writing section OBJECTS...");
dxf.writeObjects(*dw);
// IMAGEDEF's from images in entities and images in blocks
for(uint i=0; i<graphic->countBlocks(); ++i)
{
- RS_Block * block = graphic->blockAt(i);
+ Block * block = graphic->blockAt(i);
- for(RS_Entity * e=block->firstEntity(RS2::ResolveAll); e!=NULL;
+ for(Entity * e=block->firstEntity(RS2::ResolveAll); e!=NULL;
e=block->nextEntity(RS2::ResolveAll))
{
if (e->rtti() == RS2::EntityImage)
{
- RS_Image * img = ((RS_Image *)e);
+ Image * img = ((Image *)e);
if (written.contains(file) == 0 && img->getHandle() != 0)
{
}
}
- for(RS_Entity * e=graphic->firstEntity(RS2::ResolveNone); e!=NULL;
+ for(Entity * e=graphic->firstEntity(RS2::ResolveNone); e!=NULL;
e=graphic->nextEntity(RS2::ResolveNone))
{
if (e->rtti() == RS2::EntityImage)
{
- RS_Image * img = ((RS_Image *)e);
+ Image * img = ((Image *)e);
if (written.contains(file) == 0 && img->getHandle() != 0)
{
}
}
}
- RS_DEBUG->print("writing end of section OBJECTS...");
+ DEBUG->print("writing end of section OBJECTS...");
dxf.writeObjectsEnd(*dw);
}
- RS_DEBUG->print("writing EOF...");
+ DEBUG->print("writing EOF...");
dw->dxfEOF();
- RS_DEBUG->print("close..");
+ DEBUG->print("close..");
dw->close();
delete dw;
// check if file was actually written (strange world of windoze xp):
if (QFileInfo(file).exists() == false)
{
- RS_DEBUG->print("RS_FilterDXF::fileExport: file could not be written");
+ DEBUG->print("FilterDXF::fileExport: file could not be written");
return false;
}
/**
* Writes all known variable settings to the DXF file.
*/
-void RS_FilterDXF::writeVariables(DL_WriterA & dw)
+void FilterDXF::writeVariables(DL_WriterA & dw)
{
-// Q3DictIterator<RS_Variable> it(graphic->getVariableDict());
- QHashIterator<QString, RS_Variable *> it(graphic->getVariableDict());
+// Q3DictIterator<Variable> it(graphic->getVariableDict());
+ QHashIterator<QString, Variable *> it(graphic->getVariableDict());
// for (; it.current(); ++it)
while (it.hasNext())
*
* @todo Add support for unicode layer names
*/
-void RS_FilterDXF::writeLayer(DL_WriterA & dw, RS_Layer * l)
+void FilterDXF::writeLayer(DL_WriterA & dw, Layer * l)
{
if (l == NULL)
{
- RS_DEBUG->print(RS_Debug::D_WARNING, "RS_FilterDXF::writeLayer: layer is NULL");
+ DEBUG->print(Debug::D_WARNING, "FilterDXF::writeLayer: layer is NULL");
return;
}
- RS_DEBUG->print("RS_FilterDXF::writeLayer %s", l->getName().toLatin1().data());
+ DEBUG->print("FilterDXF::writeLayer %s", l->getName().toLatin1().data());
dxf.writeLayer(dw, DL_LayerData((const char *)l->getName().toLocal8Bit(),
l->isFrozen() + (l->isLocked() << 2)), DL_Attributes(std::string(""),
colorToNumber(l->getPen().getColor()), widthToNumber(l->getPen().getWidth()),
(const char *)lineTypeToName(l->getPen().getLineType()).toLocal8Bit()));
- RS_DEBUG->print("RS_FilterDXF::writeLayer end");
+ DEBUG->print("FilterDXF::writeLayer end");
}
/**
* Writes a line type to the DXF file.
*/
-void RS_FilterDXF::writeLineType(DL_WriterA & dw, RS2::LineType t)
+void FilterDXF::writeLineType(DL_WriterA & dw, RS2::LineType t)
{
dxf.writeLineType(dw, DL_LineTypeData((const char *)lineTypeToName(t).toLocal8Bit(), 0));
}
*
* @param appid Application ID (e.g. "QCad").
*/
-void RS_FilterDXF::writeAppid(DL_WriterA& dw, const char* appid) {
+void FilterDXF::writeAppid(DL_WriterA& dw, const char* appid) {
dxf.writeAppid(dw, appid);
}
/**
* Writes a block (just the definition, not the entities in it).
*/
-void RS_FilterDXF::writeBlock(DL_WriterA& dw, RS_Block* blk) {
+void FilterDXF::writeBlock(DL_WriterA& dw, Block* blk) {
if (blk==NULL) {
- RS_DEBUG->print(RS_Debug::D_WARNING,
- "RS_FilterDXF::writeBlock: Block is NULL");
+ DEBUG->print(Debug::D_WARNING,
+ "FilterDXF::writeBlock: Block is NULL");
return;
}
- RS_DEBUG->print("writing block: %s", (const char*)blk->getName().toLocal8Bit());
+ DEBUG->print("writing block: %s", (const char*)blk->getName().toLocal8Bit());
dxf.writeBlock(dw,
DL_BlockData((const char*)blk->getName().toLocal8Bit(), 0,
blk->getBasePoint().x,
blk->getBasePoint().y,
blk->getBasePoint().z));
- for (RS_Entity* e=blk->firstEntity(RS2::ResolveNone);
+ for (Entity* e=blk->firstEntity(RS2::ResolveNone);
e!=NULL;
e=blk->nextEntity(RS2::ResolveNone)) {
writeEntity(dw, e);
/**
* Writes the given entity to the DXF file.
*/
-void RS_FilterDXF::writeEntity(DL_WriterA& dw, RS_Entity* e) {
+void FilterDXF::writeEntity(DL_WriterA& dw, Entity* e) {
writeEntity(dw, e, getEntityAttributes(e));
}
/**
* Writes the given entity to the DXF file.
*/
-void RS_FilterDXF::writeEntity(DL_WriterA& dw, RS_Entity* e,
+void FilterDXF::writeEntity(DL_WriterA& dw, Entity* e,
const DL_Attributes& attrib) {
if (e==NULL || e->getFlag(RS2::FlagUndone)) {
return;
}
- RS_DEBUG->print("writing Entity");
+ DEBUG->print("writing Entity");
switch (e->rtti()) {
case RS2::EntityPoint:
- writePoint(dw, (RS_Point*)e, attrib);
+ writePoint(dw, (Point*)e, attrib);
break;
case RS2::EntityLine:
- writeLine(dw, (RS_Line*)e, attrib);
+ writeLine(dw, (Line*)e, attrib);
break;
case RS2::EntityPolyline:
- writePolyline(dw, (RS_Polyline*)e, attrib);
+ writePolyline(dw, (Polyline*)e, attrib);
break;
case RS2::EntitySpline:
- writeSpline(dw, (RS_Spline*)e, attrib);
+ writeSpline(dw, (Spline*)e, attrib);
break;
case RS2::EntityVertex:
break;
case RS2::EntityCircle:
- writeCircle(dw, (RS_Circle*)e, attrib);
+ writeCircle(dw, (Circle*)e, attrib);
break;
case RS2::EntityArc:
- writeArc(dw, (RS_Arc*)e, attrib);
+ writeArc(dw, (Arc*)e, attrib);
break;
case RS2::EntityEllipse:
- writeEllipse(dw, (RS_Ellipse*)e, attrib);
+ writeEllipse(dw, (Ellipse*)e, attrib);
break;
case RS2::EntityInsert:
- writeInsert(dw, (RS_Insert*)e, attrib);
+ writeInsert(dw, (Insert*)e, attrib);
break;
case RS2::EntityText:
- writeText(dw, (RS_Text*)e, attrib);
+ writeText(dw, (Text*)e, attrib);
break;
case RS2::EntityDimAligned:
case RS2::EntityDimLinear:
case RS2::EntityDimRadial:
case RS2::EntityDimDiametric:
- writeDimension(dw, (RS_Dimension*)e, attrib);
+ writeDimension(dw, (Dimension*)e, attrib);
break;
case RS2::EntityDimLeader:
- writeLeader(dw, (RS_Leader*)e, attrib);
+ writeLeader(dw, (Leader*)e, attrib);
break;
case RS2::EntityHatch:
- writeHatch(dw, (RS_Hatch*)e, attrib);
+ writeHatch(dw, (Hatch*)e, attrib);
break;
case RS2::EntityImage:
- writeImage(dw, (RS_Image*)e, attrib);
+ writeImage(dw, (Image*)e, attrib);
break;
case RS2::EntitySolid:
- writeSolid(dw, (RS_Solid*)e, attrib);
+ writeSolid(dw, (Solid*)e, attrib);
break;
#ifndef RS_NO_COMPLEX_ENTITIES
case RS2::EntityContainer:
- writeEntityContainer(dw, (RS_EntityContainer*)e, attrib);
+ writeEntityContainer(dw, (EntityContainer*)e, attrib);
break;
#endif
/**
* Writes the given Point entity to the file.
*/
-void RS_FilterDXF::writePoint(DL_WriterA& dw, RS_Point* p,
+void FilterDXF::writePoint(DL_WriterA& dw, Point* p,
const DL_Attributes& attrib) {
dxf.writePoint(
dw,
/**
* Writes the given Line( entity to the file.
*/
-void RS_FilterDXF::writeLine(DL_WriterA& dw, RS_Line* l,
+void FilterDXF::writeLine(DL_WriterA& dw, Line* l,
const DL_Attributes& attrib) {
dxf.writeLine(
dw,
/**
* Writes the given polyline entity to the file.
*/
-void RS_FilterDXF::writePolyline(DL_WriterA& dw,
- RS_Polyline* l,
+void FilterDXF::writePolyline(DL_WriterA& dw,
+ Polyline* l,
const DL_Attributes& attrib) {
int count = l->count();
l->isClosed()*0x1),
attrib);
bool first = true;
- RS_Entity* nextEntity = 0;
- RS_AtomicEntity* ae = NULL;
- RS_Entity* lastEntity = l->lastEntity(RS2::ResolveNone);
- for (RS_Entity* v=l->firstEntity(RS2::ResolveNone);
+ Entity* nextEntity = 0;
+ AtomicEntity* ae = NULL;
+ Entity* lastEntity = l->lastEntity(RS2::ResolveNone);
+ for (Entity* v=l->firstEntity(RS2::ResolveNone);
v!=NULL;
v=nextEntity) {
continue;
}
- ae = (RS_AtomicEntity*)v;
+ ae = (AtomicEntity*)v;
double bulge=0.0;
// Write vertex:
if (first) {
if (v->rtti()==RS2::EntityArc) {
- bulge = ((RS_Arc*)v)->getBulge();
+ bulge = ((Arc*)v)->getBulge();
}
dxf.writeVertex(dw,
DL_VertexData(ae->getStartpoint().x,
//if (dxf.getVersion()==VER_R12) {
if (nextEntity!=NULL) {
if (nextEntity->rtti()==RS2::EntityArc) {
- bulge = ((RS_Arc*)nextEntity)->getBulge();
+ bulge = ((Arc*)nextEntity)->getBulge();
}
else {
bulge = 0.0;
}
/*} else {
if (v->rtti()==RS2::EntityArc) {
- bulge = ((RS_Arc*)v)->getBulge();
+ bulge = ((Arc*)v)->getBulge();
}
}*/
/**
* Writes the given spline entity to the file.
*/
-void RS_FilterDXF::writeSpline(DL_WriterA & dw, RS_Spline * s, const DL_Attributes & attrib)
+void FilterDXF::writeSpline(DL_WriterA & dw, Spline * s, const DL_Attributes & attrib)
{
// split spline into atomic entities for DXF R12:
if (dxf.getVersion() == VER_R12)
if (s->getNumberOfControlPoints() < s->getDegree() + 1)
{
- RS_DEBUG->print(RS_Debug::D_ERROR, "RS_FilterDXF::writeSpline: "
+ DEBUG->print(Debug::D_ERROR, "FilterDXF::writeSpline: "
"Discarding spline: not enough control points given.");
return;
}
/**
* Writes the given circle entity to the file.
*/
-void RS_FilterDXF::writeCircle(DL_WriterA& dw, RS_Circle* c,
+void FilterDXF::writeCircle(DL_WriterA& dw, Circle* c,
const DL_Attributes& attrib) {
dxf.writeCircle(
dw,
-void RS_FilterDXF::writeArc(DL_WriterA& dw, RS_Arc* a,
+void FilterDXF::writeArc(DL_WriterA& dw, Arc* a,
const DL_Attributes& attrib) {
double a1, a2;
if (a->isReversed()) {
}
-void RS_FilterDXF::writeEllipse(DL_WriterA& dw, RS_Ellipse* s,
+void FilterDXF::writeEllipse(DL_WriterA& dw, Ellipse* s,
const DL_Attributes& attrib) {
if (s->isReversed()) {
dxf.writeEllipse(
}
}
-void RS_FilterDXF::writeInsert(DL_WriterA & dw, RS_Insert * i, const DL_Attributes & attrib)
+void FilterDXF::writeInsert(DL_WriterA & dw, Insert * i, const DL_Attributes & attrib)
{
dxf.writeInsert(dw, DL_InsertData(i->getName().toLatin1().data(),
i->getInsertionPoint().x, i->getInsertionPoint().y, 0.0,
attrib);
}
-void RS_FilterDXF::writeText(DL_WriterA & dw, RS_Text * t, const DL_Attributes & attrib)
+void FilterDXF::writeText(DL_WriterA & dw, Text * t, const DL_Attributes & attrib)
{
if (dxf.getVersion()==VER_R12)
{
-void RS_FilterDXF::writeDimension(DL_WriterA& dw, RS_Dimension* d,
+void FilterDXF::writeDimension(DL_WriterA& dw, Dimension* d,
const DL_Attributes& attrib) {
// split hatch into atomic entities:
d->getAngle());
if (d->rtti()==RS2::EntityDimAligned) {
- RS_DimAligned* da = (RS_DimAligned*)d;
+ DimAligned* da = (DimAligned*)d;
DL_DimAlignedData dimAlignedData(da->getExtensionPoint1().x,
da->getExtensionPoint1().y,
dxf.writeDimAligned(dw, dimData, dimAlignedData, attrib);
} else if (d->rtti()==RS2::EntityDimLinear) {
- RS_DimLinear* dl = (RS_DimLinear*)d;
+ DimLinear* dl = (DimLinear*)d;
DL_DimLinearData dimLinearData(dl->getExtensionPoint1().x,
dl->getExtensionPoint1().y,
dxf.writeDimLinear(dw, dimData, dimLinearData, attrib);
} else if (d->rtti()==RS2::EntityDimRadial) {
- RS_DimRadial* dr = (RS_DimRadial*)d;
+ DimRadial* dr = (DimRadial*)d;
DL_DimRadialData dimRadialData(dr->getDefinitionPoint().x,
dr->getDefinitionPoint().y,
dxf.writeDimRadial(dw, dimData, dimRadialData, attrib);
} else if (d->rtti()==RS2::EntityDimDiametric) {
- RS_DimDiametric* dr = (RS_DimDiametric*)d;
+ DimDiametric* dr = (DimDiametric*)d;
DL_DimDiametricData dimDiametricData(dr->getDefinitionPoint().x,
dr->getDefinitionPoint().y,
dxf.writeDimDiametric(dw, dimData, dimDiametricData, attrib);
} else if (d->rtti()==RS2::EntityDimAngular) {
- RS_DimAngular* da = (RS_DimAngular*)d;
+ DimAngular* da = (DimAngular*)d;
DL_DimAngularData dimAngularData(da->getDefinitionPoint1().x,
da->getDefinitionPoint1().y,
}
-void RS_FilterDXF::writeLeader(DL_WriterA& dw, RS_Leader* l,
+void FilterDXF::writeLeader(DL_WriterA& dw, Leader* l,
const DL_Attributes& attrib) {
if (l->count()>0) {
dxf.writeLeader(
l->count()),
attrib);
bool first = true;
- for (RS_Entity* v=l->firstEntity(RS2::ResolveNone);
+ for (Entity* v=l->firstEntity(RS2::ResolveNone);
v!=NULL;
v=l->nextEntity(RS2::ResolveNone)) {
// Write line verties:
if (v->rtti()==RS2::EntityLine) {
- RS_Line* l = (RS_Line*)v;
+ Line* l = (Line*)v;
if (first) {
dxf.writeLeaderVertex(
dw,
}
}
} else {
- RS_DEBUG->print(RS_Debug::D_WARNING,
+ DEBUG->print(Debug::D_WARNING,
"dropping leader with no vertices");
}
}
-void RS_FilterDXF::writeHatch(DL_WriterA& dw, RS_Hatch* h,
+void FilterDXF::writeHatch(DL_WriterA& dw, Hatch* h,
const DL_Attributes& attrib) {
// split hatch into atomic entities:
bool writeIt = true;
if (h->countLoops()>0) {
// check if all of the loops contain entities:
- for (RS_Entity* l=h->firstEntity(RS2::ResolveNone);
+ for (Entity* l=h->firstEntity(RS2::ResolveNone);
l!=NULL;
l=h->nextEntity(RS2::ResolveNone)) {
}
if (!writeIt) {
- RS_DEBUG->print(RS_Debug::D_WARNING,
- "RS_FilterDXF::writeHatch: Dropping Hatch");
+ DEBUG->print(Debug::D_WARNING,
+ "FilterDXF::writeHatch: Dropping Hatch");
} else {
DL_HatchData data(h->countLoops(),
h->isSolid(),
(const char*)h->getPattern().toLocal8Bit());
dxf.writeHatch1(dw, data, attrib);
- for (RS_Entity* l=h->firstEntity(RS2::ResolveNone);
+ for (Entity* l=h->firstEntity(RS2::ResolveNone);
l!=NULL;
l=h->nextEntity(RS2::ResolveNone)) {
// Write hatch loops:
if (l->isContainer() && !l->getFlag(RS2::FlagTemp)) {
- RS_EntityContainer* loop = (RS_EntityContainer*)l;
+ EntityContainer* loop = (EntityContainer*)l;
DL_HatchLoopData lData(loop->count());
dxf.writeHatchLoop1(dw, lData);
- for (RS_Entity* ed=loop->firstEntity(RS2::ResolveNone);
+ for (Entity* ed=loop->firstEntity(RS2::ResolveNone);
ed!=NULL;
ed=loop->nextEntity(RS2::ResolveNone)) {
// Write hatch loop edges:
if (ed->rtti()==RS2::EntityLine) {
- RS_Line* ln = (RS_Line*)ed;
+ Line* ln = (Line*)ed;
dxf.writeHatchEdge(
dw,
DL_HatchEdgeData(ln->getStartpoint().x,
ln->getEndpoint().x,
ln->getEndpoint().y));
} else if (ed->rtti()==RS2::EntityArc) {
- RS_Arc* ar = (RS_Arc*)ed;
+ Arc* ar = (Arc*)ed;
if (!ar->isReversed()) {
dxf.writeHatchEdge(
dw,
false));
}
} else if (ed->rtti()==RS2::EntityCircle) {
- RS_Circle* ci = (RS_Circle*)ed;
+ Circle* ci = (Circle*)ed;
dxf.writeHatchEdge(
dw,
DL_HatchEdgeData(ci->getCenter().x,
-void RS_FilterDXF::writeSolid(DL_WriterA& dw, RS_Solid* s,
+void FilterDXF::writeSolid(DL_WriterA& dw, Solid* s,
const DL_Attributes& attrib) {
// split solid into line entities:
}
-void RS_FilterDXF::writeImage(DL_WriterA& dw, RS_Image* i,
+void FilterDXF::writeImage(DL_WriterA& dw, Image* i,
const DL_Attributes& attrib) {
int handle = dxf.writeImage(
dw,
-void RS_FilterDXF::writeEntityContainer(DL_WriterA& dw, RS_EntityContainer* con,
+void FilterDXF::writeEntityContainer(DL_WriterA& dw, EntityContainer* con,
const DL_Attributes& /*attrib*/) {
QString blkName;
blkName = "__CE";
dw.dxfString(0, "ENDTAB");
//Block creation
- RS_BlockData blkdata(blkName, Vector(0,0), false);
+ BlockData blkdata(blkName, Vector(0,0), false);
- RS_Block* blk = new RS_Block(graphic, blkdata);
+ Block* blk = new Block(graphic, blkdata);
- for (RS_Entity* e1 = con->firstEntity(); e1 != NULL;
+ for (Entity* e1 = con->firstEntity(); e1 != NULL;
e1 = con->nextEntity() ) {
blk->addEntity(e1);
}
/**
* Writes the atomic entities of the given cotnainer to the file.
*/
-void RS_FilterDXF::writeAtomicEntities(DL_WriterA& dw, RS_EntityContainer* c,
+void FilterDXF::writeAtomicEntities(DL_WriterA& dw, EntityContainer* c,
const DL_Attributes& attrib,
RS2::ResolveLevel level) {
- for (RS_Entity* e=c->firstEntity(level);
+ for (Entity* e=c->firstEntity(level);
e!=NULL;
e=c->nextEntity(level)) {
/**
* Writes an IMAGEDEF object into an OBJECT section.
*/
-void RS_FilterDXF::writeImageDef(DL_WriterA& dw, RS_Image* i) {
+void FilterDXF::writeImageDef(DL_WriterA& dw, Image* i) {
if (i==NULL || i->getFlag(RS2::FlagUndone)) {
return;
}
* Sets the entities attributes according to the attributes
* that come from a DXF file.
*/
-void RS_FilterDXF::setEntityAttributes(RS_Entity* entity,
+void FilterDXF::setEntityAttributes(Entity* entity,
const DL_Attributes& attrib) {
- RS_DEBUG->print("RS_FilterDXF::setEntityAttributes");
+ DEBUG->print("FilterDXF::setEntityAttributes");
- RS_Pen pen;
+ Pen pen;
pen.setColor(Qt::black);
pen.setLineType(RS2::SolidLine);
pen.setWidth(numberToWidth(attrib.getWidth()));
entity->setPen(pen);
- RS_DEBUG->print("RS_FilterDXF::setEntityAttributes: OK");
+ DEBUG->print("FilterDXF::setEntityAttributes: OK");
}
/**
* Gets the entities attributes as a DL_Attributes object.
*/
-DL_Attributes RS_FilterDXF::getEntityAttributes(RS_Entity * entity)
+DL_Attributes FilterDXF::getEntityAttributes(Entity * entity)
{
// Layer:
- RS_Layer * layer = entity->getLayer();
+ Layer * layer = entity->getLayer();
QString layerName;
if (layer != NULL)
else
layerName = "NULL";
- RS_Pen pen = entity->getPen(false);
+ Pen pen = entity->getPen(false);
// Color:
int color = colorToNumber(pen.getColor());
/**
* @return Pen with the same attributes as 'attrib'.
*/
-RS_Pen RS_FilterDXF::attributesToPen(const DL_Attributes & attrib) const
+Pen FilterDXF::attributesToPen(const DL_Attributes & attrib) const
{
/*
printf("converting Color %d to %s\n",
attrib.getColor(), numberToColor(attrib.getColor()).name().toLatin1());
*/
- RS_Pen pen(numberToColor(attrib.getColor()),
+ Pen pen(numberToColor(attrib.getColor()),
numberToWidth(attrib.getWidth()),
nameToLineType(attrib.getLineType().c_str()));
return pen;
/**
- * Converts a color index (num) into a RS_Color object.
+ * Converts a color index (num) into a Color object.
* Please refer to the dxflib documentation for details.
*
* @param num Color number.
* @param comp Compatibility with older QCad versions (1.5.3 and older)
*/
-RS_Color RS_FilterDXF::numberToColor(int num, bool comp) {
+Color FilterDXF::numberToColor(int num, bool comp) {
// Compatibility with QCad 1.5.3 and older:
if (comp) {
switch(num) {
}
} else {
if (num==0) {
- return RS_Color(RS2::FlagByBlock);
+ return Color(RS2::FlagByBlock);
} else if (num==256) {
- return RS_Color(RS2::FlagByLayer);
+ return Color(RS2::FlagByLayer);
} else if (num<=255 && num>=0) {
- return RS_Color((int)(dxfColors[num][0]*255),
+ return Color((int)(dxfColors[num][0]*255),
(int)(dxfColors[num][1]*255),
(int)(dxfColors[num][2]*255));
} else {
- RS_DEBUG->print(RS_Debug::D_WARNING,
- "RS_FilterDXF::numberToColor: Invalid color number given.");
- return RS_Color(RS2::FlagByLayer);
+ DEBUG->print(Debug::D_WARNING,
+ "FilterDXF::numberToColor: Invalid color number given.");
+ return Color(RS2::FlagByLayer);
}
}
- return RS_Color();
+ return Color();
}
* Converts a color into a color number in the DXF palette.
* The color that fits best is chosen.
*/
-int RS_FilterDXF::colorToNumber(const RS_Color& col) {
+int FilterDXF::colorToNumber(const Color& col) {
//printf("Searching color for %s\n", col.name().toLatin1());
* Converts a line type name (e.g. "CONTINUOUS") into a RS2::LineType
* object.
*/
-RS2::LineType RS_FilterDXF::nameToLineType(const QString & name)
+RS2::LineType FilterDXF::nameToLineType(const QString & name)
{
QString uName = name.toUpper();
}
/**
- * Converts a RS_LineType into a name for a line type.
+ * Converts a LineType into a name for a line type.
*/
-QString RS_FilterDXF::lineTypeToName(RS2::LineType lineType)
+QString FilterDXF::lineTypeToName(RS2::LineType lineType)
{
// Standard linetypes for QCad II / AutoCAD
switch (lineType)
/**
- * Converts a RS_LineType into a name for a line type.
+ * Converts a LineType into a name for a line type.
*/
-/*QString RS_FilterDXF::lineTypeToDescription(RS2::LineType lineType) {
+/*QString FilterDXF::lineTypeToDescription(RS2::LineType lineType) {
// Standard linetypes for QCad II / AutoCAD
switch (lineType) {
/**
* Converts a line width number (e.g. 1) into a RS2::LineWidth.
*/
-RS2::LineWidth RS_FilterDXF::numberToWidth(int num) {
+RS2::LineWidth FilterDXF::numberToWidth(int num) {
switch (num) {
case -1:
return RS2::WidthByLayer;
/**
* Converts a RS2::LineWidth into an int width.
*/
-int RS_FilterDXF::widthToNumber(RS2::LineWidth width) {
+int FilterDXF::widthToNumber(RS2::LineWidth width) {
switch (width) {
case RS2::WidthByLayer:
return -1;
* - %%%d for a degree sign
* - %%%p for a plus/minus sign
*/
-QString RS_FilterDXF::toDxfString(const QString & string)
+QString FilterDXF::toDxfString(const QString & string)
{
/*
QString res = string;
/**
* Converts a DXF encoded string into a native Unicode string.
*/
-QString RS_FilterDXF::toNativeString(const QString & string)
+QString FilterDXF::toNativeString(const QString & string)
{
QString res = string;
// Line feed:
res = res.replace("}", "");
res = res.replace("#curly#", "}");
- RS_DEBUG->print("RS_FilterDXF::toNativeString:");
- RS_DEBUG->printUnicode(res);
+ DEBUG->print("FilterDXF::toNativeString:");
+ DEBUG->printUnicode(res);
return res;
}
*
* @ret Matching AngleFormat enum value.
*/
-RS2::AngleFormat RS_FilterDXF::numberToAngleFormat(int num) {
+RS2::AngleFormat FilterDXF::numberToAngleFormat(int num) {
RS2::AngleFormat af;
/**
* Converts AngleFormat enum to DXF number.
*/
-int RS_FilterDXF::angleFormatToNumber(RS2::AngleFormat af) {
+int FilterDXF::angleFormatToNumber(RS2::AngleFormat af) {
int num;
/**
* converts a DXF unit setting (e.g. INSUNITS) to a unit enum.
*/
-RS2::Unit RS_FilterDXF::numberToUnit(int num) {
+RS2::Unit FilterDXF::numberToUnit(int num) {
switch (num) {
default:
case 0:
/**
* Converst a unit enum into a DXF unit number e.g. for INSUNITS.
*/
-int RS_FilterDXF::unitToNumber(RS2::Unit unit) {
+int FilterDXF::unitToNumber(RS2::Unit unit) {
switch (unit) {
default:
case RS2::None:
/**
* Checks if the given variable is two-dimensional (e.g. $LIMMIN).
*/
-bool RS_FilterDXF::isVariableTwoDimensional(const QString& var) {
+bool FilterDXF::isVariableTwoDimensional(const QString& var) {
if (var=="$LIMMIN" ||
var=="$LIMMAX" ||
var=="$PLIMMIN" ||
projects / architektonas / blobdiff