X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fbase%2Ffilterdxf.cpp;fp=src%2Fbase%2Ffilterdxf.cpp;h=5bc10588c7704b4ac09fd6255ac548cd93580277;hb=16354e0421b316a62c6b9f7b0b4f3b8cf6f06284;hp=18fb3f9586926c6a038d525ccbebd121ccd5a6c9;hpb=3239ef39dcee08fa6e8cd68cdf2727fc68cc7a8c;p=architektonas

diff --git a/src/base/filterdxf.cpp b/src/base/filterdxf.cpp
index 18fb3f9..5bc1058 100644
--- a/src/base/filterdxf.cpp
+++ b/src/base/filterdxf.cpp
@@ -35,9 +35,9 @@
  * 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);
@@ -52,16 +52,16 @@ RS_FilterDXF::RS_FilterDXF(): RS_FilterInterface()
 	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");
 }
 
 /**
@@ -72,50 +72,50 @@ RS_FilterDXF::~RS_FilterDXF()
  * 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;
 }
@@ -123,17 +123,17 @@ bool RS_FilterDXF::fileImport(Drawing & g, const QString & file, RS2::FormatType
 /**
  * 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);
     }
@@ -141,9 +141,9 @@ void RS_FilterDXF::addLayer(const DL_LayerData& data) {
         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");
 }
 
 /**
@@ -151,10 +151,10 @@ void RS_FilterDXF::addLayer(const DL_LayerData& data) {
  *
  * @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"
@@ -168,7 +168,7 @@ void RS_FilterDXF::addBlock(const DL_BlockData & data)
 #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);
@@ -178,7 +178,7 @@ void RS_FilterDXF::addBlock(const DL_BlockData & data)
 		{
 #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))
@@ -192,7 +192,7 @@ void RS_FilterDXF::addBlock(const DL_BlockData & data)
 /**
  * Implementation of the method which closes blocks.
  */
-void RS_FilterDXF::endBlock()
+void FilterDXF::endBlock()
 {
 	currentContainer = graphic;
 }
@@ -200,10 +200,10 @@ void RS_FilterDXF::endBlock()
 /**
  * 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);
 }
@@ -211,27 +211,27 @@ void RS_FilterDXF::addPoint(const DL_PointData & data)
 /**
  * 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");
 }
 
 /**
@@ -240,17 +240,17 @@ void RS_FilterDXF::addLine(const DL_LineData & data)
  * @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);
@@ -264,18 +264,18 @@ void RS_FilterDXF::addArc(const DL_ArcData& data) {
  * @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);
@@ -286,15 +286,15 @@ void RS_FilterDXF::addEllipse(const DL_EllipseData& data) {
 /**
  * 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);
@@ -305,13 +305,13 @@ void RS_FilterDXF::addCircle(const DL_CircleData& data) {
 /**
  * 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);
@@ -322,8 +322,8 @@ void RS_FilterDXF::addPolyline(const DL_PolylineData& data) {
 /**
  * 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);
@@ -338,32 +338,32 @@ void RS_FilterDXF::addVertex(const DL_VertexData& data) {
 /**
  * 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);
 
@@ -377,9 +377,9 @@ void RS_FilterDXF::addControlPoint(const DL_ControlPointData & data)
 /**
  * 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;
@@ -390,20 +390,20 @@ void RS_FilterDXF::addInsert(const DL_InsertData & data)
 
 	//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 &)
 {
 }
 
@@ -411,15 +411,15 @@ void RS_FilterDXF::addInsert(const DL_InsertData & data)
  * 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));
@@ -434,9 +434,9 @@ void RS_FilterDXF::addMTextChunk(const char * text)
  * 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;
@@ -474,7 +474,7 @@ void RS_FilterDXF::addMText(const DL_MTextData & data)
 	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());
 
@@ -495,12 +495,12 @@ void RS_FilterDXF::addMText(const DL_MTextData & data)
 			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();
@@ -515,8 +515,8 @@ void RS_FilterDXF::addMText(const DL_MTextData & data)
  * 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;
@@ -604,7 +604,7 @@ void RS_FilterDXF::addText(const DL_TextData& data) {
  * 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);
@@ -650,11 +650,11 @@ RS_DimensionData RS_FilterDXF::convDimensionData(
         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,
@@ -667,18 +667,18 @@ RS_DimensionData RS_FilterDXF::convDimensionData(
  * 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();
@@ -691,19 +691,19 @@ void RS_FilterDXF::addDimAlign(const DL_DimensionData& data,
  * 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();
@@ -716,16 +716,16 @@ void RS_FilterDXF::addDimLinear(const DL_DimensionData& data,
  * 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);
@@ -739,16 +739,16 @@ void RS_FilterDXF::addDimRadial(const DL_DimensionData& data,
  * 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);
@@ -762,19 +762,19 @@ void RS_FilterDXF::addDimDiametric(const DL_DimensionData& data,
  * 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);
@@ -788,20 +788,20 @@ void RS_FilterDXF::addDimAngular(const DL_DimensionData& data,
  * 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);
@@ -814,11 +814,11 @@ void RS_FilterDXF::addDimAngular3P(const DL_DimensionData& data,
 /**
  * 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);
@@ -829,9 +829,9 @@ void RS_FilterDXF::addLeader(const DL_LeaderData& data) {
 /**
  * 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);
 
@@ -845,11 +845,11 @@ void RS_FilterDXF::addLeaderVertex(const DL_LeaderVertexData& data) {
 /**
  * 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())));
@@ -863,10 +863,10 @@ void RS_FilterDXF::addHatch(const DL_HatchData& data) {
 /**
  * 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);
     }
@@ -877,41 +877,41 @@ void RS_FilterDXF::addHatchLoop(const DL_HatchLoopData& /*data*/) {
 /**
  * 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));
                 }
             }
@@ -932,18 +932,18 @@ void RS_FilterDXF::addHatchEdge(const DL_HatchEdgeData& data) {
 /**
  * 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(""),
@@ -958,9 +958,9 @@ void RS_FilterDXF::addImage(const DL_ImageData& data) {
 /**
  * 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());
@@ -972,7 +972,7 @@ void RS_FilterDXF::linkImage(const DL_ImageDefData & data)
 	// 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;
@@ -981,7 +981,7 @@ void RS_FilterDXF::linkImage(const DL_ImageDefData & data)
 			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();
@@ -992,23 +992,23 @@ void RS_FilterDXF::linkImage(const DL_ImageDefData & data)
 			}
 			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();
 			}
 		}
@@ -1017,18 +1017,18 @@ void RS_FilterDXF::linkImage(const DL_ImageDefData & data)
 	// 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();
 				}
@@ -1036,42 +1036,42 @@ void RS_FilterDXF::linkImage(const DL_ImageDefData & data)
 		}
 	}
 
-	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)
@@ -1081,9 +1081,9 @@ void RS_FilterDXF::setVariableVector(const char * key, double v1, double v2, dou
 /**
  * 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);
@@ -1100,8 +1100,8 @@ void RS_FilterDXF::setVariableString(const char * key, const char * value, int c
 /**
  * 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) {
@@ -1115,8 +1115,8 @@ void RS_FilterDXF::setVariableInt(const char* key, int value, int code) {
 /**
  * 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)
@@ -1131,11 +1131,11 @@ void RS_FilterDXF::setVariableDouble(const char* key, double value, int code) {
  *
  * @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;
 
@@ -1146,7 +1146,7 @@ bool RS_FilterDXF::fileExport(Drawing & g, const QString & file, RS2::FormatType
 
 	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;
 	}
 	//
@@ -1169,27 +1169,27 @@ bool RS_FilterDXF::fileExport(Drawing & g, const QString & file, RS2::FormatType
 
 	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)
@@ -1206,37 +1206,37 @@ bool RS_FilterDXF::fileExport(Drawing & g, const QString & file, RS2::FormatType
 	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),
@@ -1247,12 +1247,12 @@ bool RS_FilterDXF::fileExport(Drawing & g, const QString & file, RS2::FormatType
 	// 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..:
@@ -1272,26 +1272,26 @@ bool RS_FilterDXF::fileExport(Drawing & g, const QString & file, RS2::FormatType
 	}
 
 	// 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
@@ -1304,21 +1304,21 @@ bool RS_FilterDXF::fileExport(Drawing & g, const QString & file, RS2::FormatType
 	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
@@ -1326,14 +1326,14 @@ bool RS_FilterDXF::fileExport(Drawing & g, const QString & file, RS2::FormatType
 
 		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)
 					{
@@ -1344,12 +1344,12 @@ bool RS_FilterDXF::fileExport(Drawing & g, const QString & file, RS2::FormatType
 			}
 		}
 
-		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)
 				{
@@ -1358,14 +1358,14 @@ bool RS_FilterDXF::fileExport(Drawing & g, const QString & file, RS2::FormatType
 				}
 			}
 		}
-		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;
@@ -1373,7 +1373,7 @@ bool RS_FilterDXF::fileExport(Drawing & g, const QString & file, RS2::FormatType
 	// 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;
 	}
 
@@ -1383,10 +1383,10 @@ bool RS_FilterDXF::fileExport(Drawing & g, const QString & file, RS2::FormatType
 /**
  * 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())
@@ -1434,28 +1434,28 @@ void RS_FilterDXF::writeVariables(DL_WriterA & dw)
  *
  * @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));
 }
@@ -1467,7 +1467,7 @@ void RS_FilterDXF::writeLineType(DL_WriterA & dw, RS2::LineType t)
  *
  * @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);
 }
 
@@ -1476,21 +1476,21 @@ void RS_FilterDXF::writeAppid(DL_WriterA& dw, const char* 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);
@@ -1503,7 +1503,7 @@ void RS_FilterDXF::writeBlock(DL_WriterA& dw, RS_Block* blk) {
 /**
  * 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));
 }
 
@@ -1511,43 +1511,43 @@ void RS_FilterDXF::writeEntity(DL_WriterA& dw, RS_Entity* 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:
@@ -1555,25 +1555,25 @@ void RS_FilterDXF::writeEntity(DL_WriterA& dw, RS_Entity* e,
     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
 
@@ -1587,7 +1587,7 @@ void RS_FilterDXF::writeEntity(DL_WriterA& dw, RS_Entity* e,
 /**
  * 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,
@@ -1601,7 +1601,7 @@ void RS_FilterDXF::writePoint(DL_WriterA& dw, RS_Point* p,
 /**
  * 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,
@@ -1619,8 +1619,8 @@ void RS_FilterDXF::writeLine(DL_WriterA& dw, RS_Line* l,
 /**
  * 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();
@@ -1635,10 +1635,10 @@ void RS_FilterDXF::writePolyline(DL_WriterA& dw,
                         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) {
 
@@ -1648,13 +1648,13 @@ void RS_FilterDXF::writePolyline(DL_WriterA& dw,
             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,
@@ -1667,7 +1667,7 @@ void RS_FilterDXF::writePolyline(DL_WriterA& dw,
         //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;
@@ -1675,7 +1675,7 @@ void RS_FilterDXF::writePolyline(DL_WriterA& dw,
             }
         /*} else {
             if (v->rtti()==RS2::EntityArc) {
-                bulge = ((RS_Arc*)v)->getBulge();
+                bulge = ((Arc*)v)->getBulge();
             }
         }*/
 
@@ -1696,7 +1696,7 @@ void RS_FilterDXF::writePolyline(DL_WriterA& dw,
 /**
  * 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)
@@ -1707,7 +1707,7 @@ void RS_FilterDXF::writeSpline(DL_WriterA & dw, RS_Spline * s, const DL_Attribut
 
 	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;
 	}
@@ -1757,7 +1757,7 @@ void RS_FilterDXF::writeSpline(DL_WriterA & dw, RS_Spline * s, const DL_Attribut
 /**
  * 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,
@@ -1771,7 +1771,7 @@ void RS_FilterDXF::writeCircle(DL_WriterA& dw, RS_Circle* c,
 
 
 
-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()) {
@@ -1792,7 +1792,7 @@ void RS_FilterDXF::writeArc(DL_WriterA& dw, RS_Arc* a,
 }
 
 
-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(
@@ -1823,7 +1823,7 @@ void RS_FilterDXF::writeEllipse(DL_WriterA& dw, RS_Ellipse* s,
     }
 }
 
-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,
@@ -1833,7 +1833,7 @@ void RS_FilterDXF::writeInsert(DL_WriterA & dw, RS_Insert * i, const DL_Attribut
 		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)
 	{
@@ -1915,7 +1915,7 @@ void RS_FilterDXF::writeText(DL_WriterA & dw, RS_Text * t, const DL_Attributes &
 
 
 
-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:
@@ -1975,7 +1975,7 @@ void RS_FilterDXF::writeDimension(DL_WriterA& dw, RS_Dimension* d,
                              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,
@@ -1986,7 +1986,7 @@ void RS_FilterDXF::writeDimension(DL_WriterA& dw, RS_Dimension* d,
 
         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,
@@ -1999,7 +1999,7 @@ void RS_FilterDXF::writeDimension(DL_WriterA& dw, RS_Dimension* d,
 
         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,
@@ -2008,7 +2008,7 @@ void RS_FilterDXF::writeDimension(DL_WriterA& dw, RS_Dimension* d,
 
         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,
@@ -2017,7 +2017,7 @@ void RS_FilterDXF::writeDimension(DL_WriterA& dw, RS_Dimension* d,
 
         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,
@@ -2038,7 +2038,7 @@ void RS_FilterDXF::writeDimension(DL_WriterA& dw, RS_Dimension* d,
 }
 
 
-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(
@@ -2053,13 +2053,13 @@ void RS_FilterDXF::writeLeader(DL_WriterA& dw, RS_Leader* l,
                           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,
@@ -2076,13 +2076,13 @@ void RS_FilterDXF::writeLeader(DL_WriterA& dw, RS_Leader* l,
             }
         }
     } 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:
@@ -2094,7 +2094,7 @@ void RS_FilterDXF::writeHatch(DL_WriterA& dw, RS_Hatch* h,
     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)) {
 
@@ -2109,8 +2109,8 @@ void RS_FilterDXF::writeHatch(DL_WriterA& dw, RS_Hatch* h,
     }
 
     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(),
@@ -2119,23 +2119,23 @@ void RS_FilterDXF::writeHatch(DL_WriterA& dw, RS_Hatch* h,
                           (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,
@@ -2143,7 +2143,7 @@ void RS_FilterDXF::writeHatch(DL_WriterA& dw, RS_Hatch* h,
                                              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,
@@ -2164,7 +2164,7 @@ void RS_FilterDXF::writeHatch(DL_WriterA& dw, RS_Hatch* h,
                                                  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,
@@ -2185,7 +2185,7 @@ void RS_FilterDXF::writeHatch(DL_WriterA& dw, RS_Hatch* h,
 
 
 
-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:
@@ -2206,7 +2206,7 @@ void RS_FilterDXF::writeSolid(DL_WriterA& dw, RS_Solid* s,
 }
 
 
-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,
@@ -2231,7 +2231,7 @@ void RS_FilterDXF::writeImage(DL_WriterA& dw, RS_Image* i,
 
 
 
-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";
@@ -2263,11 +2263,11 @@ void RS_FilterDXF::writeEntityContainer(DL_WriterA& dw, RS_EntityContainer* con,
     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);
     }
@@ -2281,11 +2281,11 @@ void RS_FilterDXF::writeEntityContainer(DL_WriterA& dw, RS_EntityContainer* con,
 /**
  * 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)) {
 
@@ -2296,7 +2296,7 @@ void RS_FilterDXF::writeAtomicEntities(DL_WriterA& dw, RS_EntityContainer* c,
 /**
  * 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;
     }
@@ -2327,11 +2327,11 @@ void RS_FilterDXF::writeImageDef(DL_WriterA& dw, RS_Image* i) {
  * 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);
 
@@ -2356,16 +2356,16 @@ void RS_FilterDXF::setEntityAttributes(RS_Entity* entity,
     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)
@@ -2373,7 +2373,7 @@ DL_Attributes RS_FilterDXF::getEntityAttributes(RS_Entity * entity)
 	else
 		layerName = "NULL";
 
-	RS_Pen pen = entity->getPen(false);
+	Pen pen = entity->getPen(false);
 
 	// Color:
 	int color = colorToNumber(pen.getColor());
@@ -2393,14 +2393,14 @@ DL_Attributes RS_FilterDXF::getEntityAttributes(RS_Entity * entity)
 /**
  * @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;
@@ -2409,13 +2409,13 @@ RS_Pen RS_FilterDXF::attributesToPen(const DL_Attributes & attrib) const
 
 
 /**
- * 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) {
@@ -2472,20 +2472,20 @@ RS_Color RS_FilterDXF::numberToColor(int num, bool comp) {
         }
     } 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();
 }
 
 
@@ -2494,7 +2494,7 @@ RS_Color RS_FilterDXF::numberToColor(int num, bool comp) {
  * 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());
 
@@ -2548,7 +2548,7 @@ int RS_FilterDXF::colorToNumber(const RS_Color& col) {
  * 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();
 
@@ -2601,9 +2601,9 @@ RS2::LineType RS_FilterDXF::nameToLineType(const QString & name)
 }
 
 /**
- * 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)
@@ -2689,9 +2689,9 @@ QString RS_FilterDXF::lineTypeToName(RS2::LineType 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) {
@@ -2721,7 +2721,7 @@ QString RS_FilterDXF::lineTypeToName(RS2::LineType 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;
@@ -2792,7 +2792,7 @@ RS2::LineWidth RS_FilterDXF::numberToWidth(int num) {
 /**
  * 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;
@@ -2818,7 +2818,7 @@ int RS_FilterDXF::widthToNumber(RS2::LineWidth width) {
  * - %%%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;
@@ -2880,7 +2880,7 @@ QString RS_FilterDXF::toDxfString(const QString & 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:
@@ -2952,8 +2952,8 @@ QString RS_FilterDXF::toNativeString(const QString & string)
 	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;
 }
 
@@ -2965,7 +2965,7 @@ QString RS_FilterDXF::toNativeString(const QString & string)
  *
  * @ret Matching AngleFormat enum value.
  */
-RS2::AngleFormat RS_FilterDXF::numberToAngleFormat(int num) {
+RS2::AngleFormat FilterDXF::numberToAngleFormat(int num) {
 
     RS2::AngleFormat af;
 
@@ -2995,7 +2995,7 @@ RS2::AngleFormat RS_FilterDXF::numberToAngleFormat(int num) {
 /**
  * Converts AngleFormat enum to DXF number.
  */
-int RS_FilterDXF::angleFormatToNumber(RS2::AngleFormat af) {
+int FilterDXF::angleFormatToNumber(RS2::AngleFormat af) {
 
     int num;
 
@@ -3026,7 +3026,7 @@ int RS_FilterDXF::angleFormatToNumber(RS2::AngleFormat af) {
 /**
  * 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:
@@ -3102,7 +3102,7 @@ RS2::Unit RS_FilterDXF::numberToUnit(int num) {
 /**
  * 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:
@@ -3178,7 +3178,7 @@ int RS_FilterDXF::unitToNumber(RS2::Unit unit) {
 /**
  * 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" ||