De-Qt-ification continues, almost done with DxfData

12 files changed, 221 insertions, 213 deletions

diff --git a/src/CGAL_Nef_polyhedron_DxfData.cc b/src/CGAL_Nef_polyhedron_DxfData.cc
index 4bfb205..fe58636 100644
--- a/src/CGAL_Nef_polyhedron_DxfData.cc
+++ b/src/CGAL_Nef_polyhedron_DxfData.cc
@@ -55,21 +55,21 @@ DxfData *CGAL_Nef_polyhedron::convertToDxfData() const
 					this_point = grid.align(x, y);
 				} else {
 					this_point = grid.align(x, y) = dxfdata->points.size();
-					dxfdata->points.append(Vector2d(x, y));
+					dxfdata->points.push_back(Vector2d(x, y));
 				}
 				if (first_point < 0) {
-					dxfdata->paths.append(DxfData::Path());
+					dxfdata->paths.push_back(DxfData::Path());
 					first_point = this_point;
 				}
 				if (this_point != last_point) {
-					dxfdata->paths.last().points.append(&dxfdata->points[this_point]);
+					dxfdata->paths.back().indices.push_back(this_point);
 					last_point = this_point;
 				}
 			}
 		}
 		if (first_point >= 0) {
-			dxfdata->paths.last().is_closed = 1;
-			dxfdata->paths.last().points.append(&dxfdata->points[first_point]);
+			dxfdata->paths.back().is_closed = 1;
+			dxfdata->paths.back().indices.push_back(first_point);
 		}
 	}
 
diff --git a/src/PolySetCGALEvaluator.cc b/src/PolySetCGALEvaluator.cc
index 791ad51..652881f 100644
--- a/src/PolySetCGALEvaluator.cc
+++ b/src/PolySetCGALEvaluator.cc
@@ -155,7 +155,7 @@ PolySet *PolySetCGALEvaluator::evaluatePolySet(const ProjectionNode &node, Abstr
 		}
 		DxfData *dxf = np.convertToDxfData();
 		dxf_tesselate(ps, *dxf, 0, true, false, 0);
-		dxf_border_to_ps(ps, dxf);
+		dxf_border_to_ps(ps, *dxf);
 		ps3->unlink();
 		delete dxf;
 	}
@@ -166,23 +166,23 @@ cant_project_non_simple_polyhedron:
 	return ps;
 }
 
-static void add_slice(PolySet *ps, DxfData::Path &pt, double rot1, double rot2, double h1, double h2)
+static void add_slice(PolySet *ps, const DxfData &dxf, DxfData::Path &path, double rot1, double rot2, double h1, double h2)
 {
-	for (int j = 1; j < pt.points.count(); j++)
+	for (size_t j = 1; j < path.indices.size(); j++)
 	{
 		int k = j - 1;
 
-		double jx1 = (*pt.points[j])[0] *  cos(rot1*M_PI/180) + (*pt.points[j])[1] * sin(rot1*M_PI/180);
-		double jy1 = (*pt.points[j])[0] * -sin(rot1*M_PI/180) + (*pt.points[j])[1] * cos(rot1*M_PI/180);
+		double jx1 = dxf.points[path.indices[j]][0] *  cos(rot1*M_PI/180) + dxf.points[path.indices[j]][1] * sin(rot1*M_PI/180);
+		double jy1 = dxf.points[path.indices[j]][0] * -sin(rot1*M_PI/180) + dxf.points[path.indices[j]][1] * cos(rot1*M_PI/180);
 
-		double jx2 = (*pt.points[j])[0] *  cos(rot2*M_PI/180) + (*pt.points[j])[1] * sin(rot2*M_PI/180);
-		double jy2 = (*pt.points[j])[0] * -sin(rot2*M_PI/180) + (*pt.points[j])[1] * cos(rot2*M_PI/180);
+		double jx2 = dxf.points[path.indices[j]][0] *  cos(rot2*M_PI/180) + dxf.points[path.indices[j]][1] * sin(rot2*M_PI/180);
+		double jy2 = dxf.points[path.indices[j]][0] * -sin(rot2*M_PI/180) + dxf.points[path.indices[j]][1] * cos(rot2*M_PI/180);
 
-		double kx1 = (*pt.points[k])[0] *  cos(rot1*M_PI/180) + (*pt.points[k])[1] * sin(rot1*M_PI/180);
-		double ky1 = (*pt.points[k])[0] * -sin(rot1*M_PI/180) + (*pt.points[k])[1] * cos(rot1*M_PI/180);
+		double kx1 = dxf.points[path.indices[k]][0] *  cos(rot1*M_PI/180) + dxf.points[path.indices[k]][1] * sin(rot1*M_PI/180);
+		double ky1 = dxf.points[path.indices[k]][0] * -sin(rot1*M_PI/180) + dxf.points[path.indices[k]][1] * cos(rot1*M_PI/180);
 
-		double kx2 = (*pt.points[k])[0] *  cos(rot2*M_PI/180) + (*pt.points[k])[1] * sin(rot2*M_PI/180);
-		double ky2 = (*pt.points[k])[0] * -sin(rot2*M_PI/180) + (*pt.points[k])[1] * cos(rot2*M_PI/180);
+		double kx2 = dxf.points[path.indices[k]][0] *  cos(rot2*M_PI/180) + dxf.points[path.indices[k]][1] * sin(rot2*M_PI/180);
+		double ky2 = dxf.points[path.indices[k]][0] * -sin(rot2*M_PI/180) + dxf.points[path.indices[k]][1] * cos(rot2*M_PI/180);
 
 		double dia1_len_sq = (jy1-ky2)*(jy1-ky2) + (jx1-kx2)*(jx1-kx2);
 		double dia2_len_sq = (jy2-ky1)*(jy2-ky1) + (jx2-kx1)*(jx2-kx1);
@@ -190,7 +190,7 @@ static void add_slice(PolySet *ps, DxfData::Path &pt, double rot1, double rot2,
 		if (dia1_len_sq > dia2_len_sq)
 		{
 			ps->append_poly();
-			if (pt.is_inner) {
+			if (path.is_inner) {
 				ps->append_vertex(kx1, ky1, h1);
 				ps->append_vertex(jx1, jy1, h1);
 				ps->append_vertex(jx2, jy2, h2);
@@ -201,7 +201,7 @@ static void add_slice(PolySet *ps, DxfData::Path &pt, double rot1, double rot2,
 			}
 
 			ps->append_poly();
-			if (pt.is_inner) {
+			if (path.is_inner) {
 				ps->append_vertex(kx2, ky2, h2);
 				ps->append_vertex(kx1, ky1, h1);
 				ps->append_vertex(jx2, jy2, h2);
@@ -214,7 +214,7 @@ static void add_slice(PolySet *ps, DxfData::Path &pt, double rot1, double rot2,
 		else
 		{
 			ps->append_poly();
-			if (pt.is_inner) {
+			if (path.is_inner) {
 				ps->append_vertex(kx1, ky1, h1);
 				ps->append_vertex(jx1, jy1, h1);
 				ps->append_vertex(kx2, ky2, h2);
@@ -225,7 +225,7 @@ static void add_slice(PolySet *ps, DxfData::Path &pt, double rot1, double rot2,
 			}
 
 			ps->append_poly();
-			if (pt.is_inner) {
+			if (path.is_inner) {
 				ps->append_vertex(jx2, jy2, h2);
 				ps->append_vertex(kx2, ky2, h2);
 				ps->append_vertex(jx1, jy1, h1);
@@ -260,7 +260,7 @@ PolySet *PolySetCGALEvaluator::evaluatePolySet(const DxfLinearExtrudeNode &node,
 
 		dxf = sum.convertToDxfData();;
 	} else {
-		dxf = new DxfData(node.fn, node.fs, node.fa, QString::fromStdString(node.filename), QString::fromStdString(node.layername), node.origin_x, node.origin_y, node.scale);
+		dxf = new DxfData(node.fn, node.fs, node.fa, node.filename, node.layername, node.origin_x, node.origin_y, node.scale);
 	}
 
 	PolySet *ps = extrudeDxfData(node, *dxf);
@@ -285,7 +285,7 @@ PolySet *PolySetCGALEvaluator::extrudeDxfData(const DxfLinearExtrudeNode &node,
 	}
 
 	bool first_open_path = true;
-	for (int i = 0; i < dxf.paths.count(); i++)
+	for (size_t i = 0; i < dxf.paths.size(); i++)
 	{
 		if (dxf.paths[i].is_closed)
 			continue;
@@ -295,10 +295,10 @@ PolySet *PolySetCGALEvaluator::extrudeDxfData(const DxfLinearExtrudeNode &node,
 			first_open_path = false;
 		}
 		PRINTF("   %9.5f %10.5f ... %10.5f %10.5f",
-					 (*dxf.paths[i].points.first())[0] / node.scale + node.origin_x,
-					 (*dxf.paths[i].points.first())[1] / node.scale + node.origin_y, 
-					 (*dxf.paths[i].points.last())[0] / node.scale + node.origin_x,
-					 (*dxf.paths[i].points.last())[1] / node.scale + node.origin_y);
+					 dxf.points[dxf.paths[i].indices.front()][0] / node.scale + node.origin_x,
+					 dxf.points[dxf.paths[i].indices.front()][1] / node.scale + node.origin_y, 
+					 dxf.points[dxf.paths[i].indices.back()][0] / node.scale + node.origin_x,
+					 dxf.points[dxf.paths[i].indices.back()][1] / node.scale + node.origin_y);
 	}
 
 
@@ -312,11 +312,11 @@ PolySet *PolySetCGALEvaluator::extrudeDxfData(const DxfLinearExtrudeNode &node,
 			double t2 = node.twist*(j+1) / node.slices;
 			double g1 = h1 + (h2-h1)*j / node.slices;
 			double g2 = h1 + (h2-h1)*(j+1) / node.slices;
-			for (int i = 0; i < dxf.paths.count(); i++)
+			for (size_t i = 0; i < dxf.paths.size(); i++)
 			{
 				if (!dxf.paths[i].is_closed)
 					continue;
-				add_slice(ps, dxf.paths[i], t1, t2, g1, g2);
+				add_slice(ps, dxf, dxf.paths[i], t1, t2, g1, g2);
 			}
 		}
 	}
@@ -324,11 +324,11 @@ PolySet *PolySetCGALEvaluator::extrudeDxfData(const DxfLinearExtrudeNode &node,
 	{
 		dxf_tesselate(ps, dxf, 0, false, true, h1);
 		dxf_tesselate(ps, dxf, 0, true, true, h2);
-		for (int i = 0; i < dxf.paths.count(); i++)
+		for (size_t i = 0; i < dxf.paths.size(); i++)
 		{
 			if (!dxf.paths[i].is_closed)
 				continue;
-			add_slice(ps, dxf.paths[i], 0, 0, h1, h2);
+			add_slice(ps, dxf, dxf.paths[i], 0, 0, h1, h2);
 		}
 	}
 
@@ -357,7 +357,7 @@ PolySet *PolySetCGALEvaluator::evaluatePolySet(const DxfRotateExtrudeNode &node,
 
 		dxf = sum.convertToDxfData();
 	} else {
-		dxf = new DxfData(node.fn, node.fs, node.fa, QString::fromStdString(node.filename), QString::fromStdString(node.layername), node.origin_x, node.origin_y, node.scale);
+		dxf = new DxfData(node.fn, node.fs, node.fa, node.filename, node.layername, node.origin_x, node.origin_y, node.scale);
 	}
 
 	PolySet *ps = rotateDxfData(node, *dxf);
@@ -371,11 +371,11 @@ PolySet *PolySetCGALEvaluator::rotateDxfData(const DxfRotateExtrudeNode &node, D
 	PolySet *ps = new PolySet();
 	ps->convexity = node.convexity;
 
-	for (int i = 0; i < dxf.paths.count(); i++)
+	for (int i = 0; i < dxf.paths.size(); i++)
 	{
 		double max_x = 0;
-		for (int j = 0; j < dxf.paths[i].points.count(); j++) {
-			max_x = fmax(max_x, (*dxf.paths[i].points[j])[0]);
+		for (int j = 0; j < dxf.paths[i].indices.size(); j++) {
+			max_x = fmax(max_x, dxf.points[dxf.paths[i].indices[j]][0]);
 		}
 
 		int fragments = get_fragments_from_r(max_x, node.fn, node.fs, node.fa);
@@ -383,29 +383,29 @@ PolySet *PolySetCGALEvaluator::rotateDxfData(const DxfRotateExtrudeNode &node, D
 		double ***points;
 		points = new double**[fragments];
 		for (int j=0; j < fragments; j++) {
-			points[j] = new double*[dxf.paths[i].points.count()];
-			for (int k=0; k < dxf.paths[i].points.count(); k++)
+			points[j] = new double*[dxf.paths[i].indices.size()];
+			for (int k=0; k < dxf.paths[i].indices.size(); k++)
 				points[j][k] = new double[3];
 		}
 
 		for (int j = 0; j < fragments; j++) {
 			double a = (j*2*M_PI) / fragments;
-			for (int k = 0; k < dxf.paths[i].points.count(); k++) {
-				if ((*dxf.paths[i].points[k])[0] == 0) {
+			for (int k = 0; k < dxf.paths[i].indices.size(); k++) {
+				if (dxf.points[dxf.paths[i].indices[k]][0] == 0) {
 					points[j][k][0] = 0;
 					points[j][k][1] = 0;
 				} else {
-					points[j][k][0] = (*dxf.paths[i].points[k])[0] * sin(a);
-					points[j][k][1] = (*dxf.paths[i].points[k])[0] * cos(a);
+					points[j][k][0] = dxf.points[dxf.paths[i].indices[k]][0] * sin(a);
+					points[j][k][1] = dxf.points[dxf.paths[i].indices[k]][0] * cos(a);
 				}
-				points[j][k][2] = (*dxf.paths[i].points[k])[1];
+				points[j][k][2] = dxf.points[dxf.paths[i].indices[k]][1];
 			}
 		}
 
 		for (int j = 0; j < fragments; j++) {
 			int j1 = j + 1 < fragments ? j + 1 : 0;
-			for (int k = 0; k < dxf.paths[i].points.count(); k++) {
-				int k1 = k + 1 < dxf.paths[i].points.count() ? k + 1 : 0;
+			for (size_t k = 0; k < dxf.paths[i].indices.size(); k++) {
+				int k1 = k + 1 < dxf.paths[i].indices.size() ? k + 1 : 0;
 				if (points[j][k][0] != points[j1][k][0] ||
 						points[j][k][1] != points[j1][k][1] ||
 						points[j][k][2] != points[j1][k][2]) {
@@ -432,7 +432,7 @@ PolySet *PolySetCGALEvaluator::rotateDxfData(const DxfRotateExtrudeNode &node, D
 		}
 
 		for (int j=0; j < fragments; j++) {
-			for (int k=0; k < dxf.paths[i].points.count(); k++)
+			for (size_t k=0; k < dxf.paths[i].indices.size(); k++)
 				delete[] points[j][k];
 			delete[] points[j];
 		}
diff --git a/src/dxfdata.cc b/src/dxfdata.cc
index 7bf4364..430a1c3 100644
--- a/src/dxfdata.cc
+++ b/src/dxfdata.cc
@@ -35,12 +35,14 @@
 #include <QVector>
 #include "mathc99.h"
 #include <assert.h>
+#include <boost/unordered_map.hpp>
+#include <boost/foreach.hpp>
+#include <algorithm>
 
 struct Line {
-	Vector2d *p[2];
+	int idx[2]; // indices into DxfData::points
 	bool disabled;
-	Line(Vector2d *p1, Vector2d *p2) { p[0] = p1; p[1] = p2; disabled = false; }
-	Line() { p[0] = NULL; p[1] = NULL; disabled = false; }
+	Line(int i1 = -1, int i2 = -1) { idx[0] = i1; idx[1] = i2; disabled = false; }
 };
 
 DxfData::DxfData()
@@ -48,51 +50,53 @@ DxfData::DxfData()
 }
 
 /*!
-	Reads a layer from the given file, or all layers if layername.isEmpty()
+	Reads a layer from the given file, or all layers if layername.empty()
  */
-DxfData::DxfData(double fn, double fs, double fa, QString filename, QString layername, double xorigin, double yorigin, double scale)
+DxfData::DxfData(double fn, double fs, double fa, 
+								 const std::string &filename, const std::string &layername, 
+								 double xorigin, double yorigin, double scale)
 {
-	handle_dep(filename); // Register ourselves as a dependency
+	handle_dep(QString::fromStdString(filename)); // Register ourselves as a dependency
 
-	QFile f(filename);
+	QFile f(QString::fromStdString(filename));
 	if (!f.open(QIODevice::ReadOnly | QIODevice::Text)) {
-		PRINTF("WARNING: Can't open DXF file `%s'.", filename.toUtf8().data());
+		PRINTF("WARNING: Can't open DXF file `%s'.", filename.c_str());
 		return;
 	}
 	QTextStream stream(&f);
 
-	Grid2d< QVector<int> > grid(GRID_COARSE);
-	QList<Line> lines;                       // Global lines
-	QHash< QString, QList<Line> > blockdata; // Lines in blocks
+	Grid2d< std::vector<int> > grid(GRID_COARSE);
+	std::vector<Line> lines;                       // Global lines
+	QHash< QString, std::vector<Line> > blockdata; // Lines in blocks
 
 	bool in_entities_section = false;
 	bool in_blocks_section = false;
-	QString current_block;
+	std::string current_block;
 
 #define ADD_LINE(_x1, _y1, _x2, _y2) do {										\
 		double _p1x = _x1, _p1y = _y1, _p2x = _x2, _p2y = _y2;  \
 		if (!in_entities_section && !in_blocks_section)         \
 			break;                                                \
 		if (in_entities_section &&                              \
-				!(layername.isEmpty() || layername == layer))        \
+				!(layername.empty() || layername == layer))        \
 			break;                                                \
 		grid.align(_p1x, _p1y);                                 \
 		grid.align(_p2x, _p2y);                                 \
-		grid.data(_p1x, _p1y).append(lines.count());            \
-		grid.data(_p2x, _p2y).append(lines.count());            \
+		grid.data(_p1x, _p1y).push_back(lines.size());            \
+		grid.data(_p2x, _p2y).push_back(lines.size());            \
 		if (in_entities_section)                                \
-			lines.append(                                         \
+			lines.push_back(                                         \
 				Line(addPoint(_p1x, _p1y), addPoint(_p2x, _p2y)));	\
-		if (in_blocks_section && !current_block.isNull())       \
-			blockdata[current_block].append(                      \
+		if (in_blocks_section && !current_block.empty())       \
+			blockdata[QString::fromStdString(current_block)].push_back(	\
 				Line(addPoint(_p1x, _p1y), addPoint(_p2x, _p2y)));	\
 	} while (0)
 
-	QString mode, layer, name, iddata;
+	std::string mode, layer, name, iddata;
 	int dimtype = 0;
 	double coords[7][2]; // Used by DIMENSION entities
-	QVector<double> xverts;
-	QVector<double> yverts;
+	std::vector<double> xverts;
+	std::vector<double> yverts;
 	double radius = 0;
 	double arc_start_angle = 0, arc_stop_angle = 0;
 	double ellipse_start_angle = 0, ellipse_stop_angle = 0;
@@ -116,7 +120,7 @@ DxfData::DxfData(double fn, double fs, double fa, QString filename, QString laye
 		int id = id_str.toInt(&status);
 
 		if (!status) {
-			PRINTA("WARNING: Illegal ID `%1' in `%3'.", id_str, filename);
+			PRINTF("WARNING: Illegal ID `%s' in `%s'.", id_str.toUtf8().data(), filename.c_str());
 			break;
 		}
 
@@ -234,13 +238,13 @@ DxfData::DxfData(double fn, double fs, double fa, QString filename, QString laye
 			else if (mode == "INSERT") {
 				// scale is stored in ellipse_start|stop_angle, rotation in arc_start_angle;
 				// due to the parser code not checking entity type
-				int n = blockdata[iddata].size();
+				int n = blockdata[QString::fromStdString(iddata)].size();
 				for (int i = 0; i < n; i++) {
 					double a = arc_start_angle * M_PI / 180.0;
-					double lx1 = (*blockdata[iddata][i].p[0])[0] * ellipse_start_angle;
-					double ly1 = (*blockdata[iddata][i].p[0])[1] * ellipse_stop_angle;
-					double lx2 = (*blockdata[iddata][i].p[1])[0] * ellipse_start_angle;
-					double ly2 = (*blockdata[iddata][i].p[1])[1] * ellipse_stop_angle;
+					double lx1 = this->points[blockdata[QString::fromStdString(iddata)][i].idx[0]][0] * ellipse_start_angle;
+					double ly1 = this->points[blockdata[QString::fromStdString(iddata)][i].idx[0]][1] * ellipse_stop_angle;
+					double lx2 = this->points[blockdata[QString::fromStdString(iddata)][i].idx[1]][0] * ellipse_start_angle;
+					double ly2 = this->points[blockdata[QString::fromStdString(iddata)][i].idx[1]][1] * ellipse_stop_angle;
 					double px1 = (cos(a)*lx1 - sin(a)*ly1) * scale + xverts[0];
 					double py1 = (sin(a)*lx1 + cos(a)*ly1) * scale + yverts[0];
 					double px2 = (cos(a)*lx2 - sin(a)*ly2) * scale + xverts[0];
@@ -249,32 +253,32 @@ DxfData::DxfData(double fn, double fs, double fa, QString filename, QString laye
 				}
 			}
 			else if (mode == "DIMENSION" &&
-					(layername.isEmpty() || layername == layer)) {
-				this->dims.append(Dim());
-				this->dims.last().type = dimtype;
+					(layername.empty() || layername == layer)) {
+				this->dims.push_back(Dim());
+				this->dims.back().type = dimtype;
 				for (int i = 0; i < 7; i++)
 					for (int j = 0; j < 2; j++)
-						this->dims.last().coords[i][j] = coords[i][j];
-				this->dims.last().angle = arc_start_angle;
-				this->dims.last().length = radius;
-				this->dims.last().name = name;
+						this->dims.back().coords[i][j] = coords[i][j];
+				this->dims.back().angle = arc_start_angle;
+				this->dims.back().length = radius;
+				this->dims.back().name = name;
 			}
 			else if (mode == "BLOCK") {
 				current_block = iddata;
 			}
 			else if (mode == "ENDBLK") {
-				current_block = QString();
+				current_block.erase();
 			}
 			else if (mode == "ENDSEC") {
 			}
 			else if (in_blocks_section || (in_entities_section &&
-					(layername.isEmpty() || layername == layer))) {
-				unsupported_entities_list[mode]++;
+					(layername.empty() || layername == layer))) {
+				unsupported_entities_list[QString::fromStdString(mode)]++;
 			}
-			mode = data;
-			layer = QString();
-			name = QString();
-			iddata = QString();
+			mode = data.toStdString();
+			layer.erase();
+			name.erase();
+			iddata.erase();
 			dimtype = 0;
 			for (int i = 0; i < 7; i++)
 				for (int j = 0; j < 2; j++)
@@ -288,37 +292,37 @@ DxfData::DxfData(double fn, double fs, double fa, QString filename, QString laye
 			}
 			break;
 		case 1:
-			name = data;
+			name = data.toStdString();
 			break;
 		case 2:
-			iddata = data;
+			iddata = data.toStdString();
 			break;
 		case 8:
-			layer = data;
+			layer = data.toStdString();
 			break;
 		case 10:
 			if (in_blocks_section)
-				xverts.append((data.toDouble()));
+				xverts.push_back((data.toDouble()));
 			else
-				xverts.append((data.toDouble() - xorigin) * scale);
+				xverts.push_back((data.toDouble() - xorigin) * scale);
 			break;
 		case 11:
 			if (in_blocks_section)
-				xverts.append((data.toDouble()));
+				xverts.push_back((data.toDouble()));
 			else
-				xverts.append((data.toDouble() - xorigin) * scale);
+				xverts.push_back((data.toDouble() - xorigin) * scale);
 			break;
 		case 20:
 			if (in_blocks_section)
-				yverts.append((data.toDouble()));
+				yverts.push_back((data.toDouble()));
 			else
-				yverts.append((data.toDouble() - yorigin) * scale);
+				yverts.push_back((data.toDouble() - yorigin) * scale);
 			break;
 		case 21:
 			if (in_blocks_section)
-				yverts.append((data.toDouble()));
+				yverts.push_back((data.toDouble()));
 			else
-				yverts.append((data.toDouble() - yorigin) * scale);
+				yverts.push_back((data.toDouble() - yorigin) * scale);
 			break;
 		case 40:
 			// CIRCLE, ARC: radius
@@ -357,37 +361,39 @@ DxfData::DxfData(double fn, double fs, double fa, QString filename, QString laye
 	QHashIterator<QString, int> i(unsupported_entities_list);
 	while (i.hasNext()) {
 		i.next();
-		if (layername.isEmpty()) {
+		if (layername.empty()) {
 			PRINTA("WARNING: Unsupported DXF Entity `%1' (%2x) in `%3'.",
-					 i.key(), QString::number(i.value()), filename);
+						 i.key(), QString::number(i.value()), QString::fromStdString(filename));
 		} else {
 			PRINTA("WARNING: Unsupported DXF Entity `%1' (%2x) in layer `%3' of `%4'.",
-					 i.key(), QString::number(i.value()), layername, filename);
+						 i.key(), QString::number(i.value()), QString::fromStdString(layername), QString::fromStdString(filename));
 		}
 	}
 
 	// Extract paths from parsed data
 
-	QHash<int, int> enabled_lines;
-	for (int i = 0; i < lines.count(); i++) {
+	typedef boost::unordered_map<int, int> LineMap;
+	LineMap enabled_lines;
+	for (size_t i = 0; i < lines.size(); i++) {
 		enabled_lines[i] = i;
 	}
 
 	// extract all open paths
-	while (enabled_lines.count() > 0)
+	while (enabled_lines.size() > 0)
 	{
 		int current_line, current_point;
 
-		foreach (int i, enabled_lines) {
+		BOOST_FOREACH(const LineMap::value_type &l, enabled_lines) {
+			int idx = l.second;
 			for (int j = 0; j < 2; j++) {
-				QVector<int> *lv = &grid.data((*lines[i].p[j])[0], (*lines[i].p[j])[1]);
-				for (int ki = 0; ki < lv->count(); ki++) {
+				std::vector<int> *lv = &grid.data(this->points[lines[idx].idx[j]][0], this->points[lines[idx].idx[j]][1]);
+				for (int ki = 0; ki < lv->size(); ki++) {
 					int k = lv->at(ki);
-					if (k == i || lines[k].disabled)
+					if (k == idx || lines[k].disabled)
 						continue;
 					goto next_open_path_j;
 				}
-				current_line = i;
+				current_line = idx;
 				current_point = j;
 				goto create_open_path;
 			next_open_path_j:;
@@ -397,26 +403,26 @@ DxfData::DxfData(double fn, double fs, double fa, QString filename, QString laye
 		break;
 
 	create_open_path:
-		this->paths.append(Path());
-		Path *this_path = &this->paths.last();
+		this->paths.push_back(Path());
+		Path *this_path = &this->paths.back();
 
-		this_path->points.append(lines[current_line].p[current_point]);
+		this_path->indices.push_back(lines[current_line].idx[current_point]);
 		while (1) {
-			this_path->points.append(lines[current_line].p[!current_point]);
-			const Vector2d &ref_point = *lines[current_line].p[!current_point];
+			this_path->indices.push_back(lines[current_line].idx[!current_point]);
+			const Vector2d &ref_point = this->points[lines[current_line].idx[!current_point]];
 			lines[current_line].disabled = true;
-			enabled_lines.remove(current_line);
-			QVector<int> *lv = &grid.data(ref_point[0], ref_point[1]);
-			for (int ki = 0; ki < lv->count(); ki++) {
+			enabled_lines.erase(current_line);
+			std::vector<int> *lv = &grid.data(ref_point[0], ref_point[1]);
+			for (int ki = 0; ki < lv->size(); ki++) {
 				int k = lv->at(ki);
 				if (lines[k].disabled)
 					continue;
-				if (grid.eq(ref_point[0], ref_point[1], (*lines[k].p[0])[0], (*lines[k].p[0])[1])) {
+				if (grid.eq(ref_point[0], ref_point[1], this->points[lines[k].idx[0]][0], this->points[lines[k].idx[0]][1])) {
 					current_line = k;
 					current_point = 0;
 					goto found_next_line_in_open_path;
 				}
-				if (grid.eq(ref_point[0], ref_point[1], (*lines[k].p[1])[0], (*lines[k].p[1])[1])) {
+				if (grid.eq(ref_point[0], ref_point[1], this->points[lines[k].idx[1]][0], this->points[lines[k].idx[1]][1])) {
 					current_line = k;
 					current_point = 1;
 					goto found_next_line_in_open_path;
@@ -428,31 +434,31 @@ DxfData::DxfData(double fn, double fs, double fa, QString filename, QString laye
 	}
 
 	// extract all closed paths
-	while (enabled_lines.count() > 0)
+	while (enabled_lines.size() > 0)
 	{
-		int current_line = enabled_lines.begin().value(), current_point = 0;
+		int current_line = enabled_lines.begin()->second, current_point = 0;
 
-		this->paths.append(Path());
-		Path *this_path = &this->paths.last();
+		this->paths.push_back(Path());
+		Path *this_path = &this->paths.back();
 		this_path->is_closed = true;
 		
-		this_path->points.append(lines[current_line].p[current_point]);
+		this_path->indices.push_back(lines[current_line].idx[current_point]);
 		while (1) {
-			this_path->points.append(lines[current_line].p[!current_point]);
-			const Vector2d &ref_point = *lines[current_line].p[!current_point];
+			this_path->indices.push_back(lines[current_line].idx[!current_point]);
+			const Vector2d &ref_point = this->points[lines[current_line].idx[!current_point]];
 			lines[current_line].disabled = true;
-			enabled_lines.remove(current_line);
-			QVector<int> *lv = &grid.data(ref_point[0], ref_point[1]);
-			for (int ki = 0; ki < lv->count(); ki++) {
+			enabled_lines.erase(current_line);
+			std::vector<int> *lv = &grid.data(ref_point[0], ref_point[1]);
+			for (int ki = 0; ki < lv->size(); ki++) {
 				int k = lv->at(ki);
 				if (lines[k].disabled)
 					continue;
-				if (grid.eq(ref_point[0], ref_point[1], (*lines[k].p[0])[0], (*lines[k].p[0])[1])) {
+				if (grid.eq(ref_point[0], ref_point[1], this->points[lines[k].idx[0]][0], this->points[lines[k].idx[0]][1])) {
 					current_line = k;
 					current_point = 0;
 					goto found_next_line_in_closed_path;
 				}
-					if (grid.eq(ref_point[0], ref_point[1], (*lines[k].p[1])[0], (*lines[k].p[1])[1])) {
+					if (grid.eq(ref_point[0], ref_point[1], this->points[lines[k].idx[1]][0], this->points[lines[k].idx[1]][1])) {
 					current_line = k;
 					current_point = 1;
 					goto found_next_line_in_closed_path;
@@ -467,9 +473,9 @@ DxfData::DxfData(double fn, double fs, double fa, QString filename, QString laye
 
 #if 0
 	printf("----- DXF Data -----\n");
-	for (int i = 0; i < this->paths.count(); i++) {
+	for (int i = 0; i < this->paths.size(); i++) {
 		printf("Path %d (%s):\n", i, this->paths[i].is_closed ? "closed" : "open");
-		for (int j = 0; j < this->paths[i].points.count(); j++)
+		for (int j = 0; j < this->paths[i].points.size(); j++)
 			printf("  %f %f\n", (*this->paths[i].points[j])[0], (*this->paths[i].points[j])[1]);
 	}
 	printf("--------------------\n");
@@ -483,26 +489,26 @@ DxfData::DxfData(double fn, double fs, double fa, QString filename, QString laye
 */
 void DxfData::fixup_path_direction()
 {
-	for (int i = 0; i < this->paths.count(); i++) {
+	for (size_t i = 0; i < this->paths.size(); i++) {
 		if (!this->paths[i].is_closed)
 			break;
 		this->paths[i].is_inner = true;
-		double min_x = (*this->paths[i].points[0])[0];
+		double min_x = this->points[this->paths[i].indices[0]][0];
 		int min_x_point = 0;
-		for (int j = 1; j < this->paths[i].points.count(); j++) {
-			if ((*this->paths[i].points[j])[0] < min_x) {
-				min_x = (*this->paths[i].points[j])[0];
+		for (size_t j = 1; j < this->paths[i].indices.size(); j++) {
+			if (this->points[this->paths[i].indices[j]][0] < min_x) {
+				min_x = this->points[this->paths[i].indices[j]][0];
 				min_x_point = j;
 			}
 		}
 		// rotate points if the path is in non-standard rotation
 		int b = min_x_point;
-		int a = b == 0 ? this->paths[i].points.count() - 2 : b - 1;
-		int c = b == this->paths[i].points.count() - 1 ? 1 : b + 1;
-		double ax = (*this->paths[i].points[a])[0] - (*this->paths[i].points[b])[0];
-		double ay = (*this->paths[i].points[a])[1] - (*this->paths[i].points[b])[1];
-		double cx = (*this->paths[i].points[c])[0] - (*this->paths[i].points[b])[0];
-		double cy = (*this->paths[i].points[c])[1] - (*this->paths[i].points[b])[1];
+		int a = b == 0 ? this->paths[i].indices.size() - 2 : b - 1;
+		int c = b == this->paths[i].indices.size() - 1 ? 1 : b + 1;
+		double ax = this->points[this->paths[i].indices[a]][0] - this->points[this->paths[i].indices[b]][0];
+		double ay = this->points[this->paths[i].indices[a]][1] - this->points[this->paths[i].indices[b]][1];
+		double cx = this->points[this->paths[i].indices[c]][0] - this->points[this->paths[i].indices[b]][0];
+		double cy = this->points[this->paths[i].indices[c]][1] - this->points[this->paths[i].indices[b]][1];
 #if 0
 		printf("Rotate check:\n");
 		printf("  a/b/c indices = %d %d %d\n", a, b, c);
@@ -511,15 +517,17 @@ void DxfData::fixup_path_direction()
 #endif
 		// FIXME: atan2() usually takes y,x. This variant probably makes the path clockwise..
 		if (atan2(ax, ay) < atan2(cx, cy)) {
-			for (int j = 0; j < this->paths[i].points.count()/2; j++)
-				this->paths[i].points.swap(j, this->paths[i].points.count()-1-j);
+			std::reverse(this->paths[i].indices.begin(), this->paths[i].indices.end());
 		}
 	}
 }
 
-Vector2d *DxfData::addPoint(double x, double y)
+/*!
+	Adds a vertex and returns the index into DxfData::points
+ */
+int DxfData::addPoint(double x, double y)
 {
-	this->points.append(Vector2d(x, y));
-	return &this->points.last();
+	this->points.push_back(Vector2d(x, y));
+	return this->points.size()-1;
 }
 
diff --git a/src/dxfdata.h b/src/dxfdata.h
index a513edf..c467160 100644
--- a/src/dxfdata.h
+++ b/src/dxfdata.h
@@ -1,7 +1,7 @@
 #ifndef DXFDATA_H_
 #define DXFDATA_H_
 
-#include <QList>
+#include <vector>
 #include <QString>
 #include <Eigen/Dense>
 
@@ -11,7 +11,7 @@ class DxfData
 {
 public:
 	struct Path {
-		QList<Vector2d*> points;
+		std::vector<int> indices; // indices into DxfData::points
 		bool is_closed, is_inner;
 		Path() : is_closed(false), is_inner(false) { }
 	};
@@ -20,7 +20,7 @@ public:
 		double coords[7][2];
 		double angle;
 		double length;
-		QString name;
+		std::string name;
 		Dim() {
 			for (int i = 0; i < 7; i++)
 			for (int j = 0; j < 2; j++)
@@ -31,14 +31,16 @@ public:
 		}
 	};
 
-	QList<Vector2d> points;
-	QList<Path> paths;
-	QList<Dim> dims;
+	std::vector<Vector2d> points;
+	std::vector<Path> paths;
+	std::vector<Dim> dims;
 
 	DxfData();
-	DxfData(double fn, double fs, double fa, QString filename, QString layername = QString(), double xorigin = 0.0, double yorigin = 0.0, double scale = 1.0);
+	DxfData(double fn, double fs, double fa, 
+					const std::string &filename, const std::string &layername = "",
+					double xorigin = 0.0, double yorigin = 0.0, double scale = 1.0);
 
-	Vector2d *addPoint(double x, double y);
+	int addPoint(double x, double y);
 
 	void fixup_path_direction();
 };
diff --git a/src/dxfdim.cc b/src/dxfdim.cc
index 636ea6c..7b016f1 100644
--- a/src/dxfdim.cc
+++ b/src/dxfdim.cc
@@ -72,11 +72,11 @@ Value builtin_dxf_dim(const Context *ctx, const std::vector<std::string> &argnam
 	if (dxf_dim_cache.find(key) != dxf_dim_cache.end())
 		return dxf_dim_cache.find(key)->second;
 
-	DxfData dxf(36, 0, 0, QString::fromStdString(filename), QString::fromStdString(layername), xorigin, yorigin, scale);
+	DxfData dxf(36, 0, 0, filename, layername, xorigin, yorigin, scale);
 
-	for (int i = 0; i < dxf.dims.count(); i++)
+	for (size_t i = 0; i < dxf.dims.size(); i++)
 	{
-		if (!name.empty() && dxf.dims[i].name != QString::fromStdString(name))
+		if (!name.empty() && dxf.dims[i].name != name)
 			continue;
 
 		DxfData::Dim *d = &dxf.dims[i];
@@ -155,17 +155,17 @@ Value builtin_dxf_cross(const Context *ctx, const std::vector<std::string> &argn
 	if (dxf_cross_cache.find(key) != dxf_cross_cache.end())
 		return dxf_cross_cache.find(key)->second;
 
-	DxfData dxf(36, 0, 0, QString::fromStdString(filename), QString::fromStdString(layername), xorigin, yorigin, scale);
+	DxfData dxf(36, 0, 0, filename, layername, xorigin, yorigin, scale);
 
 	double coords[4][2];
 
-	for (int i = 0, j = 0; i < dxf.paths.count(); i++) {
-		if (dxf.paths[i].points.count() != 2)
+	for (size_t i = 0, j = 0; i < dxf.paths.size(); i++) {
+		if (dxf.paths[i].indices.size() != 2)
 			continue;
-		coords[j][0] = (*dxf.paths[i].points[0])[0];
-		coords[j++][1] = (*dxf.paths[i].points[0])[1];
-		coords[j][0] = (*dxf.paths[i].points[1])[0];
-		coords[j++][1] = (*dxf.paths[i].points[1])[1];
+		coords[j][0] = dxf.points[dxf.paths[i].indices[0]][0];
+		coords[j++][1] = dxf.points[dxf.paths[i].indices[0]][1];
+		coords[j][0] = dxf.points[dxf.paths[i].indices[1]][0];
+		coords[j++][1] = dxf.points[dxf.paths[i].indices[1]][1];
 
 		if (j == 4) {
 			double x1 = coords[0][0], y1 = coords[0][1];
diff --git a/src/dxftess-cgal.cc b/src/dxftess-cgal.cc
index 825132f..6585e76 100644
--- a/src/dxftess-cgal.cc
+++ b/src/dxftess-cgal.cc
@@ -106,17 +106,17 @@ void dxf_tesselate(PolySet *ps, DxfData &dxf, double rot, bool up, bool /* do_tr
 	try {
 
 	// read path data and copy all relevant infos
-	for (int i = 0; i < dxf.paths.count(); i++)
+	for (int i = 0; i < dxf.paths.size(); i++)
 	{
 		if (!dxf.paths[i].is_closed)
 			continue;
 
 		Vertex_handle first, prev;
 		struct point_info_t *first_pi = NULL, *prev_pi = NULL;
-		for (int j = 1; j < dxf.paths[i].points.count(); j++)
+		for (int j = 1; j < dxf.paths[i].indices.size(); j++)
 		{
-			double x = (*dxf.paths[i].points[j])[0];
-			double y = (*dxf.paths[i].points[j])[1];
+			double x = dxf.points[dxf.paths[i].indices[j]][0];
+			double y = dxf.points[dxf.paths[i].indices[j]][1];
 
 			if (point_info.has(x, y)) {
 				// FIXME: How can the same path set contain the same point twice?
@@ -127,7 +127,7 @@ void dxf_tesselate(PolySet *ps, DxfData &dxf, double rot, bool up, bool /* do_tr
 			}
 
 			struct point_info_t *pi = &point_info.align(x, y);
-			*pi = point_info_t(x, y, i, j, dxf.paths[i].points.count()-1);
+			*pi = point_info_t(x, y, i, j, dxf.paths[i].indices.size()-1);
 
 			Vertex_handle vh = cdt.insert(CDTPoint(x, y));
 			if (first_pi == NULL) {
diff --git a/src/dxftess-glu.cc b/src/dxftess-glu.cc
index 3132fe9..23d8a45 100644
--- a/src/dxftess-glu.cc
+++ b/src/dxftess-glu.cc
@@ -227,17 +227,17 @@ void dxf_tesselate(PolySet *ps, DxfData &dxf, double rot, bool up, bool do_trian
 
 	Grid3d< QPair<int,int> > point_to_path(GRID_COARSE);
 
-	for (int i = 0; i < dxf.paths.count(); i++) {
+	for (int i = 0; i < dxf.paths.size(); i++) {
 		if (!dxf.paths[i].is_closed)
 			continue;
 		gluTessBeginContour(tobj);
-		for (int j = 1; j < dxf.paths[i].points.count(); j++) {
-			point_to_path.data((*dxf.paths[i].points[j])[0],
-												 (*dxf.paths[i].points[j])[1],
+		for (int j = 1; j < dxf.paths[i].indices.size(); j++) {
+			point_to_path.data(dxf.points[dxf.paths[i].indices[j]][0],
+												 dxf.points[dxf.paths[i].indices[j]][1],
 												 h) = QPair<int,int>(i, j);
 			vl.append(tess_vdata());
-			vl.last().v[0] = (*dxf.paths[i].points[j])[0];
-			vl.last().v[1] = (*dxf.paths[i].points[j])[1];
+			vl.last().v[0] = dxf.points[dxf.paths[i].indices[j]][0];
+			vl.last().v[1] = dxf.points[dxf.paths[i].indices[j]][1];
 			vl.last().v[2] = h;
 			gluTessVertex(tobj, vl.last().v, vl.last().v);
 		}
@@ -248,7 +248,7 @@ void dxf_tesselate(PolySet *ps, DxfData &dxf, double rot, bool up, bool do_trian
 	gluDeleteTess(tobj);
 
 #if 0
-	for (int i = 0; i < tess_tri.count(); i++) {
+	for (int i = 0; i < tess_tri.size(); i++) {
 		printf("~~~\n");
 		printf("  %f %f %f\n", tess_tri[i].p[0][0], tess_tri[i].p[0][1], tess_tri[i].p[0][2]);
 		printf("  %f %f %f\n", tess_tri[i].p[1][0], tess_tri[i].p[1][1], tess_tri[i].p[1][2]);
@@ -258,7 +258,7 @@ void dxf_tesselate(PolySet *ps, DxfData &dxf, double rot, bool up, bool do_trian
 
 	// GLU tessing sometimes generates degenerated triangles. We must find and remove
 	// them so we can use the triangle array with CGAL..
-	for (int i = 0; i < tess_tri.count(); i++) {
+	for (int i = 0; i < tess_tri.size(); i++) {
 		if (point_on_line(tess_tri[i].p[0], tess_tri[i].p[1], tess_tri[i].p[2]) ||
 				point_on_line(tess_tri[i].p[1], tess_tri[i].p[2], tess_tri[i].p[0]) ||
 				point_on_line(tess_tri[i].p[2], tess_tri[i].p[0], tess_tri[i].p[1])) {
@@ -279,7 +279,7 @@ void dxf_tesselate(PolySet *ps, DxfData &dxf, double rot, bool up, bool do_trian
 		bool added_triangles = true;
 		typedef QPair<int,int> QPair_ii;
 		QHash<int, QPair_ii> tri_by_atan2;
-		for (int i = 0; i < tess_tri.count(); i++)
+		for (int i = 0; i < tess_tri.size(); i++)
 		for (int j = 0; j < 3; j++) {
 			int ai = (int)round(atan2(fabs(tess_tri[i].p[(j+1)%3][0] - tess_tri[i].p[j][0]),
 					fabs(tess_tri[i].p[(j+1)%3][1] - tess_tri[i].p[j][1])) / 0.001);
@@ -289,9 +289,9 @@ void dxf_tesselate(PolySet *ps, DxfData &dxf, double rot, bool up, bool do_trian
 		{
 			added_triangles = false;
 #ifdef DEBUG_TRIANGLE_SPLITTING
-			printf("*** Triangle splitting (%d) ***\n", tess_tri.count()+1);
+			printf("*** Triangle splitting (%d) ***\n", tess_tri.size()+1);
 #endif
-			for (int i = 0; i < tess_tri.count(); i++)
+			for (int i = 0; i < tess_tri.size(); i++)
 			for (int k = 0; k < 3; k++)
 			{
 				QHash<QPair_ii, QPair_ii> possible_neigh;
@@ -303,7 +303,7 @@ void dxf_tesselate(PolySet *ps, DxfData &dxf, double rot, bool up, bool do_trian
 							possible_neigh[jl] = jl;
 				}
 #ifdef DEBUG_TRIANGLE_SPLITTING
-				printf("%d/%d: %d\n", i, k, possible_neigh.count());
+				printf("%d/%d: %d\n", i, k, possible_neigh.size());
 #endif
 				foreach (const QPair_ii &jl, possible_neigh) {
 					int j = jl.first;
@@ -321,7 +321,7 @@ void dxf_tesselate(PolySet *ps, DxfData &dxf, double rot, bool up, bool do_trian
 						for (int m = 0; m < 2; m++) {
 							int ai = (int)round(atan2(fabs(tess_tri.last().p[(m+1)%3][0] - tess_tri.last().p[m][0]),
 									fabs(tess_tri.last().p[(m+1)%3][1] - tess_tri.last().p[m][1])) / 0.001 );
-							tri_by_atan2.insertMulti(ai, QPair<int,int>(tess_tri.count()-1, m));
+							tri_by_atan2.insertMulti(ai, QPair<int,int>(tess_tri.size()-1, m));
 						}
 						tess_tri[i].p[(k+1)%3] = tess_tri[j].p[l];
 						for (int m = 0; m < 2; m++) {
@@ -337,7 +337,7 @@ void dxf_tesselate(PolySet *ps, DxfData &dxf, double rot, bool up, bool do_trian
 	}
 #endif
 
-	for (int i = 0; i < tess_tri.count(); i++)
+	for (int i = 0; i < tess_tri.size(); i++)
 	{
 #if 0
 		printf("---\n");
diff --git a/src/dxftess.cc b/src/dxftess.cc
index 73d235f..d2cb172 100644
--- a/src/dxftess.cc
+++ b/src/dxftess.cc
@@ -37,17 +37,17 @@
 	without tesselating. Vertex ordering of the resulting polygons
 	will follow the paths' is_inner flag.
 */
-void dxf_border_to_ps(PolySet *ps, DxfData *dxf)
+void dxf_border_to_ps(PolySet *ps, const DxfData &dxf)
 {
-	for (int i = 0; i < dxf->paths.count(); i++) {
-		const DxfData::Path &pt = dxf->paths[i];
-		if (!pt.is_closed)
+	for (size_t i = 0; i < dxf.paths.size(); i++) {
+		const DxfData::Path &path = dxf.paths[i];
+		if (!path.is_closed)
 			continue;
 		ps->borders.push_back(PolySet::Polygon());
-		for (int j = 1; j < pt.points.count(); j++) {
-			double x = (*pt.points[j])[0], y = (*pt.points[j])[1], z = 0.0;
+		for (size_t j = 1; j < path.indices.size(); j++) {
+			double x = dxf.points[path.indices[j]][0], y = dxf.points[path.indices[j]][1], z = 0.0;
 			ps->grid.align(x, y, z);
-			if (pt.is_inner) {
+			if (path.is_inner) {
 				ps->borders.back().push_back(Vector3d(x, y, z));
 			} else {
 				ps->borders.back().insert(ps->borders.back().begin(), Vector3d(x, y, z));
diff --git a/src/dxftess.h b/src/dxftess.h
index 4aa47c2..d3af36e 100644
--- a/src/dxftess.h
+++ b/src/dxftess.h
@@ -4,6 +4,6 @@
 class DxfData;
 class PolySet;
 void dxf_tesselate(PolySet *ps, DxfData &dxf, double rot, bool up, bool do_triangle_splitting, double h);
-void dxf_border_to_ps(PolySet *ps, DxfData *dxf);
+void dxf_border_to_ps(PolySet *ps, const DxfData &dxf);
 
 #endif
diff --git a/src/export.cc b/src/export.cc
index 17a14c8..0c60ea3 100644
--- a/src/export.cc
+++ b/src/export.cc
@@ -134,11 +134,11 @@ void export_dxf(CGAL_Nef_polyhedron *root_N, QTextStream &output, QProgressDialo
 				 << "ENTITIES\n";
 
 	DxfData *dd =root_N->convertToDxfData();
-	for (int i=0; i<dd->paths.size(); i++)
+	for (size_t i=0; i<dd->paths.size(); i++)
 	{
-		for (int j=1; j<dd->paths[i].points.size(); j++) {
-			const Vector2d &p1 = *dd->paths[i].points[j-1];
-			const Vector2d &p2 = *dd->paths[i].points[j];
+		for (size_t j=1; j<dd->paths[i].indices.size(); j++) {
+			const Vector2d &p1 = dd->points[dd->paths[i].indices[j-1]];
+			const Vector2d &p2 = dd->points[dd->paths[i].indices[j]];
 			double x1 = p1[0];
 			double y1 = p1[1];
 			double x2 = p2[0];
diff --git a/src/import.cc b/src/import.cc
index 0f107f7..8354198 100644
--- a/src/import.cc
+++ b/src/import.cc
@@ -198,10 +198,10 @@ PolySet *ImportNode::evaluate_polyset(render_mode_e, class PolySetEvaluator *) c
 
 	if (this->type == TYPE_DXF)
 	{
-		DxfData dd(this->fn, this->fs, this->fa, QString::fromStdString(this->filename), QString::fromStdString(this->layername), this->origin_x, this->origin_y, this->scale);
+		DxfData dd(this->fn, this->fs, this->fa, this->filename, this->layername, this->origin_x, this->origin_y, this->scale);
 		p->is2d = true;
 		dxf_tesselate(p, dd, 0, true, false, 0);
-		dxf_border_to_ps(p, &dd);
+		dxf_border_to_ps(p, dd);
 	}
 
 	return p;
diff --git a/src/primitives.cc b/src/primitives.cc
index 1a04cad..50a197d 100644
--- a/src/primitives.cc
+++ b/src/primitives.cc
@@ -521,39 +521,37 @@ sphere_next_r2:
 				p->unlink();
 				return NULL;
 			}
-			dd.points.append(Vector2d(x, y));
+			dd.points.push_back(Vector2d(x, y));
 		}
 
 		if (this->paths.vec.size() == 0)
 		{
-			dd.paths.append(DxfData::Path());
+			dd.paths.push_back(DxfData::Path());
 			for (size_t i=0; i<this->points.vec.size(); i++) {
 				assert(i < dd.points.size()); // FIXME: Not needed, but this used to be an 'if'
-				Vector2d *p = &dd.points[i];
-				dd.paths.last().points.append(p);
+				dd.paths.back().indices.push_back(i);
 			}
-			if (dd.paths.last().points.size() > 0) {
-				dd.paths.last().points.append(dd.paths.last().points.first());
-				dd.paths.last().is_closed = true;
+			if (dd.paths.back().indices.size() > 0) {
+				dd.paths.back().indices.push_back(dd.paths.back().indices.front());
+				dd.paths.back().is_closed = true;
 			}
 		}
 		else
 		{
 			for (size_t i=0; i<this->paths.vec.size(); i++)
 			{
-				dd.paths.append(DxfData::Path());
+				dd.paths.push_back(DxfData::Path());
 				for (size_t j=0; j<this->paths.vec[i]->vec.size(); j++) {
 					int idx = this->paths.vec[i]->vec[j]->num;
 					if (idx < dd.points.size()) {
-						Vector2d *p = &dd.points[idx];
-						dd.paths.last().points.append(p);
+						dd.paths.back().indices.push_back(idx);
 					}
 				}
-				if (dd.paths.last().points.isEmpty()) {
-					dd.paths.removeLast();
+				if (dd.paths.back().indices.empty()) {
+					dd.paths.pop_back();
 				} else {
-					dd.paths.last().points.append(dd.paths.last().points.first());
-					dd.paths.last().is_closed = true;
+					dd.paths.back().indices.push_back(dd.paths.back().indices.front());
+					dd.paths.back().is_closed = true;
 				}
 			}
 		}
@@ -561,7 +559,7 @@ sphere_next_r2:
 		p->is2d = true;
 		p->convexity = convexity;
 		dxf_tesselate(p, dd, 0, true, false, 0);
-		dxf_border_to_ps(p, &dd);
+		dxf_border_to_ps(p, dd);
 	}
 
 	return p;