begin process of unifying GLView and OffscreenView. renames, objrot, objtran

8 files changed, 154 insertions, 150 deletions

diff --git a/src/CsgInfo.h b/src/CsgInfo.h
index 889eefe..6c3e352 100644
--- a/src/CsgInfo.h
+++ b/src/CsgInfo.h
@@ -6,8 +6,8 @@
 class CsgInfo
 {
 public:
-	CsgInfo() { glview = NULL; }
-	OffscreenView *glview;
+	CsgInfo() { qglview = NULL; }
+	OffscreenView *qglview;
 };
 
 
@@ -26,7 +26,7 @@ public:
 		root_chain = NULL;
 		highlights_chain = NULL;
 		background_chain = NULL;
-		glview = NULL;
+		qglview = NULL;
 	}
 	shared_ptr<CSGTerm> root_norm_term;    // Normalized CSG products
 	class CSGChain *root_chain;
diff --git a/src/MainWindow.ui b/src/MainWindow.ui
index f71ac96..9dfc5dc 100644
--- a/src/MainWindow.ui
+++ b/src/MainWindow.ui
@@ -38,7 +38,7 @@
           <property name="orientation">
            <enum>Qt::Vertical</enum>
           </property>
-          <widget class="GLView" name="glview" native="true"/>
+          <widget class="QGLView" name="qglview" native="true"/>
           <widget class="QTextEdit" name="console">
            <property name="readOnly">
             <bool>true</bool>
@@ -679,9 +679,9 @@
  </widget>
  <customwidgets>
   <customwidget>
-   <class>GLView</class>
+   <class>QGLView</class>
    <extends>QWidget</extends>
-   <header>GLView.h</header>
+   <header>QGLView.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
diff --git a/src/OffscreenView.cc b/src/OffscreenView.cc
index 12ebf3a..ee5e296 100644
--- a/src/OffscreenView.cc
+++ b/src/OffscreenView.cc
@@ -147,7 +147,7 @@ bool OffscreenView::save(std::ostream &output)
 	return save_framebuffer(this->ctx, output);
 }
 
-std::string OffscreenView::getInfo()
+const std::string &OffscreenView::getRendererInfo()
 {
 	std::stringstream out;
 	GLint rbits, gbits, bbits, abits, dbits, sbits;
diff --git a/src/OffscreenView.h b/src/OffscreenView.h
index f401bef..c27277e 100644
--- a/src/OffscreenView.h
+++ b/src/OffscreenView.h
@@ -26,24 +26,25 @@ public:
 	void paintGL();
 	bool save(const char *filename);
 	bool save(std::ostream &output);
-	std::string getInfo();
+	const std::string &getRendererInfo();
 
-	GLint shaderinfo[11];
-	OffscreenContext *ctx;
-	size_t width;
-	size_t height;
+	GLint shaderinfo[11];  //
+
+	OffscreenContext *ctx; // not
+	size_t width;  // not
+	size_t height; // not
 private:
-	Renderer *renderer;
-	double w_h_ratio;
+	Renderer *renderer;//
+	double w_h_ratio;//
 
-	bool orthomode;
-	bool showaxes;
-	bool showfaces;
-	bool showedges;
+	bool orthomode;//
+	bool showaxes;//
+	bool showfaces;//
+	bool showedges;//
 
-	Eigen::Vector3d object_rot;
-	Eigen::Vector3d camera_eye;
-	Eigen::Vector3d camera_center;
+	Eigen::Vector3d object_rot;//
+	Eigen::Vector3d camera_eye;//
+	Eigen::Vector3d camera_center;//
 };
 
 #endif
diff --git a/src/GLView.h b/src/QGLView.h
index 5552e4b..862d751 100644
--- a/src/GLView.h
+++ b/src/QGLView.h
@@ -5,7 +5,10 @@
 #include <QGLWidget>
 #include <QLabel>
 
-class GLView : public QGLWidget
+#include <Eigen/Core>
+#include <Eigen/Geometry>
+
+class QGLView : public QGLWidget
 {
 	Q_OBJECT
 	Q_PROPERTY(bool showFaces READ showFaces WRITE setShowFaces);
@@ -15,8 +18,8 @@ class GLView : public QGLWidget
 	Q_PROPERTY(bool orthoMode READ orthoMode WRITE setOrthoMode);
 
 public:
-	GLView(QWidget *parent = NULL);
-	GLView(const QGLFormat & format, QWidget *parent = NULL);
+	QGLView(QWidget *parent = NULL);
+	QGLView(const QGLFormat & format, QWidget *parent = NULL);
 	void setRenderer(class Renderer* r);
 #ifdef ENABLE_OPENCSG
 	bool hasOpenCSGSupport() { return this->opencsg_support; }
@@ -32,16 +35,16 @@ public:
 	void setShowCrosshairs(bool enabled) { this->showcrosshairs = enabled; }
 	bool orthoMode() const { return this->orthomode; }
 	void setOrthoMode(bool enabled) { this->orthomode = enabled; }
-	const QString &getRendererInfo() const { return this->rendererInfo; }
+	const std::string &getRendererInfo() const { return this->rendererInfo; }
 
 public:
 	QLabel *statusLabel;
-	double object_rot_x;
-	double object_rot_y;
-	double object_rot_z;
-	double object_trans_x;
-	double object_trans_y;
-	double object_trans_z;
+
+  Eigen::Vector3d object_rot;
+  Eigen::Vector3d object_trans;
+  Eigen::Vector3d camera_eye;
+  Eigen::Vector3d camera_center;
+
 	GLint shaderinfo[11];
 
 #ifdef ENABLE_OPENCSG
@@ -53,7 +56,7 @@ private:
 	void init();
 	Renderer *renderer;
 
-	QString rendererInfo;
+	std::string rendererInfo;
 
 	bool showfaces;
 	bool showedges;
diff --git a/src/export_png.cc b/src/export_png.cc
index 2d6a4a2..1a92fc9 100644
--- a/src/export_png.cc
+++ b/src/export_png.cc
@@ -14,7 +14,7 @@ void export_png_with_cgal(CGAL_Nef_polyhedron *root_N, std::ostream &output)
 {
 	CsgInfo csgInfo;
 	try {
-		csgInfo.glview = new OffscreenView(512,512);
+		csgInfo.qglview = new OffscreenView(512,512);
 	} catch (int error) {
 		fprintf(stderr,"Can't create OpenGL OffscreenView. Code: %i.\n", error);
 		return;
@@ -40,10 +40,10 @@ void export_png_with_cgal(CGAL_Nef_polyhedron *root_N, std::ostream &output)
 	//std::cerr << center << "\n";
 	//std::cerr << radius << "\n";
 
-	csgInfo.glview->setCamera(camerapos, center);
-	csgInfo.glview->setRenderer(&cgalRenderer);
-	csgInfo.glview->paintGL();
-	csgInfo.glview->save(output);
+	csgInfo.qglview->setCamera(camerapos, center);
+	csgInfo.qglview->setRenderer(&cgalRenderer);
+	csgInfo.qglview->paintGL();
+	csgInfo.qglview->save(output);
 }
 
 void export_png_with_opencsg(CGAL_Nef_polyhedron *root_N, std::ostream &output)
diff --git a/src/mainwin.cc b/src/mainwin.cc
index d5af643..bd17402 100644
--- a/src/mainwin.cc
+++ b/src/mainwin.cc
@@ -190,8 +190,8 @@ MainWindow::MainWindow(const QString &filename)
 	editor->setTabStopWidth(30);
 	editor->setLineWrapping(true); // Not designable
 
-	this->glview->statusLabel = new QLabel(this);
-	statusBar()->addWidget(this->glview->statusLabel);
+	this->qglview->statusLabel = new QLabel(this);
+	statusBar()->addWidget(this->qglview->statusLabel);
 
 	animate_timer = new QTimer(this);
 	connect(animate_timer, SIGNAL(timeout()), this, SLOT(updateTVal()));
@@ -291,7 +291,7 @@ MainWindow::MainWindow(const QString &filename)
 	this->viewActionOpenCSG->setVisible(false);
 #else
 	connect(this->viewActionOpenCSG, SIGNAL(triggered()), this, SLOT(viewModeOpenCSG()));
-	if (!this->glview->hasOpenCSGSupport()) {
+	if (!this->qglview->hasOpenCSGSupport()) {
 		this->viewActionOpenCSG->setEnabled(false);
 	}
 #endif
@@ -343,9 +343,9 @@ MainWindow::MainWindow(const QString &filename)
 	connect(editor->document(), SIGNAL(contentsChanged()), this, SLOT(animateUpdateDocChanged()));
 	connect(editor->document(), SIGNAL(modificationChanged(bool)), this, SLOT(setWindowModified(bool)));
 	connect(editor->document(), SIGNAL(modificationChanged(bool)), fileActionSave, SLOT(setEnabled(bool)));
-	connect(this->glview, SIGNAL(doAnimateUpdate()), this, SLOT(animateUpdate()));
+	connect(this->qglview, SIGNAL(doAnimateUpdate()), this, SLOT(animateUpdate()));
 
-	connect(Preferences::inst(), SIGNAL(requestRedraw()), this->glview, SLOT(updateGL()));
+	connect(Preferences::inst(), SIGNAL(requestRedraw()), this->qglview, SLOT(updateGL()));
 	connect(Preferences::inst(), SIGNAL(fontChanged(const QString&,uint)), 
 					this, SLOT(setFont(const QString&,uint)));
 	connect(Preferences::inst(), SIGNAL(openCSGSettingsChanged()),
@@ -595,7 +595,7 @@ bool MainWindow::compile(bool reload, bool procevents)
 	if (!compileTopLevelDocument(reload)) return false;
 
   // Invalidate renderers before we kill the CSG tree
-	this->glview->setRenderer(NULL);
+	this->qglview->setRenderer(NULL);
 	delete this->opencsgRenderer;
 	this->opencsgRenderer = NULL;
 	delete this->thrownTogetherRenderer;
@@ -759,7 +759,7 @@ void MainWindow::compileCSG(bool procevents)
 			this->opencsgRenderer = new OpenCSGRenderer(this->root_chain, 
 																									this->highlights_chain, 
 																									this->background_chain, 
-																									this->glview->shaderinfo);
+																									this->qglview->shaderinfo);
 		}
 		this->thrownTogetherRenderer = new ThrownTogetherRenderer(this->root_chain, 
 																															this->highlights_chain, 
@@ -942,7 +942,7 @@ void MainWindow::pasteViewportTranslation()
 {
 	QTextCursor cursor = editor->textCursor();
 	QString txt;
-	txt.sprintf("[ %.2f, %.2f, %.2f ]", -this->glview->object_trans_x, -this->glview->object_trans_y, -this->glview->object_trans_z);
+	txt.sprintf("[ %.2f, %.2f, %.2f ]", -this->qglview->object_trans_x, -this->qglview->object_trans_y, -this->qglview->object_trans_z);
 	cursor.insertText(txt);
 }
 
@@ -951,7 +951,7 @@ void MainWindow::pasteViewportRotation()
 	QTextCursor cursor = editor->textCursor();
 	QString txt;
 	txt.sprintf("[ %.2f, %.2f, %.2f ]",
-		fmodf(360 - this->glview->object_rot_x + 90, 360), fmodf(360 - this->glview->object_rot_y, 360), fmodf(360 - this->glview->object_rot_z, 360));
+		fmodf(360 - this->qglview->object_rot_x + 90, 360), fmodf(360 - this->qglview->object_rot_y, 360), fmodf(360 - this->qglview->object_rot_z, 360));
 	cursor.insertText(txt);
 }
 
@@ -960,15 +960,15 @@ void MainWindow::updateTemporalVariables()
 	this->root_ctx.set_variable("$t", Value(this->e_tval->text().toDouble()));
 	
 	Value::VectorType vpt;
-	vpt.push_back(Value(-this->glview->object_trans_x));
-	vpt.push_back(Value(-this->glview->object_trans_y));
-	vpt.push_back(Value(-this->glview->object_trans_z));
+	vpt.push_back(Value(-this->qglview->object_trans_x));
+	vpt.push_back(Value(-this->qglview->object_trans_y));
+	vpt.push_back(Value(-this->qglview->object_trans_z));
 	this->root_ctx.set_variable("$vpt", Value(vpt));
 	
 	Value::VectorType vpr;
-	vpr.push_back(Value(fmodf(360 - this->glview->object_rot_x + 90, 360)));
-	vpr.push_back(Value(fmodf(360 - this->glview->object_rot_y, 360)));
-	vpr.push_back(Value(fmodf(360 - this->glview->object_rot_z, 360)));
+	vpr.push_back(Value(fmodf(360 - this->qglview->object_rot_x + 90, 360)));
+	vpr.push_back(Value(fmodf(360 - this->qglview->object_rot_y, 360)));
+	vpr.push_back(Value(fmodf(360 - this->qglview->object_rot_z, 360)));
 	root_ctx.set_variable("$vpr", Value(vpr));
 }
 
@@ -1147,7 +1147,7 @@ void MainWindow::actionCompile()
 	}
 
 	if (viewActionAnimate->isChecked() && e_dump->isChecked()) {
-		QImage img = this->glview->grabFrameBuffer();
+		QImage img = this->qglview->grabFrameBuffer();
 		QString filename;
 		double s = this->e_fsteps->text().toDouble();
 		double t = this->e_tval->text().toDouble();
@@ -1176,7 +1176,7 @@ void MainWindow::actionRenderCGAL()
 		return;
 	}
 
-	this->glview->setRenderer(NULL);
+	this->qglview->setRenderer(NULL);
 	delete this->cgalRenderer;
 	this->cgalRenderer = NULL;
 	if (this->root_N) {
@@ -1452,7 +1452,7 @@ void MainWindow::actionExportCSG()
 
 void MainWindow::actionExportImage()
 {
-	QImage img = this->glview->grabFrameBuffer();
+	QImage img = this->qglview->grabFrameBuffer();
 	setCurrentOutput();
 
 	QString img_filename = QFileDialog::getSaveFileName(this,
@@ -1497,10 +1497,10 @@ void MainWindow::viewModeActionsUncheck()
 */
 void MainWindow::viewModeOpenCSG()
 {
-	if (this->glview->hasOpenCSGSupport()) {
+	if (this->qglview->hasOpenCSGSupport()) {
 		viewModeActionsUncheck();
 		viewActionOpenCSG->setChecked(true);
-		this->glview->setRenderer(this->opencsgRenderer ? (Renderer *)this->opencsgRenderer : (Renderer *)this->thrownTogetherRenderer);
+		this->qglview->setRenderer(this->opencsgRenderer ? (Renderer *)this->opencsgRenderer : (Renderer *)this->thrownTogetherRenderer);
 	} else {
 		viewModeThrownTogether();
 	}
@@ -1514,17 +1514,17 @@ void MainWindow::viewModeCGALSurface()
 {
 	viewModeActionsUncheck();
 	viewActionCGALSurfaces->setChecked(true);
-	this->glview->setShowFaces(true);
-	this->glview->setRenderer(this->cgalRenderer);
-	this->glview->updateGL();
+	this->qglview->setShowFaces(true);
+	this->qglview->setRenderer(this->cgalRenderer);
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewModeCGALGrid()
 {
 	viewModeActionsUncheck();
 	viewActionCGALGrid->setChecked(true);
-	this->glview->setShowFaces(false);
-	this->glview->setRenderer(this->cgalRenderer);
+	this->qglview->setShowFaces(false);
+	this->qglview->setRenderer(this->cgalRenderer);
 }
 
 #endif /* ENABLE_CGAL */
@@ -1533,31 +1533,31 @@ void MainWindow::viewModeThrownTogether()
 {
 	viewModeActionsUncheck();
 	viewActionThrownTogether->setChecked(true);
-	this->glview->setRenderer(this->thrownTogetherRenderer);
+	this->qglview->setRenderer(this->thrownTogetherRenderer);
 }
 
 void MainWindow::viewModeShowEdges()
 {
 	QSettings settings;
 	settings.setValue("view/showEdges",viewActionShowEdges->isChecked());
-	this->glview->setShowEdges(viewActionShowEdges->isChecked());
-	this->glview->updateGL();
+	this->qglview->setShowEdges(viewActionShowEdges->isChecked());
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewModeShowAxes()
 {
 	QSettings settings;
 	settings.setValue("view/showAxes",viewActionShowAxes->isChecked());
-	this->glview->setShowAxes(viewActionShowAxes->isChecked());
-	this->glview->updateGL();
+	this->qglview->setShowAxes(viewActionShowAxes->isChecked());
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewModeShowCrosshairs()
 {
 	QSettings settings;
 	settings.setValue("view/showCrosshairs",viewActionShowCrosshairs->isChecked());
-	this->glview->setShowCrosshairs(viewActionShowCrosshairs->isChecked());
-	this->glview->updateGL();
+	this->qglview->setShowCrosshairs(viewActionShowCrosshairs->isChecked());
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewModeAnimate()
@@ -1595,66 +1595,66 @@ void MainWindow::animateUpdate()
 
 void MainWindow::viewAngleTop()
 {
-	this->glview->object_rot_x = 90;
-	this->glview->object_rot_y = 0;
-	this->glview->object_rot_z = 0;
-	this->glview->updateGL();
+	this->qglview->object_rot_x = 90;
+	this->qglview->object_rot_y = 0;
+	this->qglview->object_rot_z = 0;
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewAngleBottom()
 {
-	this->glview->object_rot_x = 270;
-	this->glview->object_rot_y = 0;
-	this->glview->object_rot_z = 0;
-	this->glview->updateGL();
+	this->qglview->object_rot_x = 270;
+	this->qglview->object_rot_y = 0;
+	this->qglview->object_rot_z = 0;
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewAngleLeft()
 {
-	this->glview->object_rot_x = 0;
-	this->glview->object_rot_y = 0;
-	this->glview->object_rot_z = 90;
-	this->glview->updateGL();
+	this->qglview->object_rot_x = 0;
+	this->qglview->object_rot_y = 0;
+	this->qglview->object_rot_z = 90;
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewAngleRight()
 {
-	this->glview->object_rot_x = 0;
-	this->glview->object_rot_y = 0;
-	this->glview->object_rot_z = 270;
-	this->glview->updateGL();
+	this->qglview->object_rot_x = 0;
+	this->qglview->object_rot_y = 0;
+	this->qglview->object_rot_z = 270;
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewAngleFront()
 {
-	this->glview->object_rot_x = 0;
-	this->glview->object_rot_y = 0;
-	this->glview->object_rot_z = 0;
-	this->glview->updateGL();
+	this->qglview->object_rot_x = 0;
+	this->qglview->object_rot_y = 0;
+	this->qglview->object_rot_z = 0;
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewAngleBack()
 {
-	this->glview->object_rot_x = 0;
-	this->glview->object_rot_y = 0;
-	this->glview->object_rot_z = 180;
-	this->glview->updateGL();
+	this->qglview->object_rot_x = 0;
+	this->qglview->object_rot_y = 0;
+	this->qglview->object_rot_z = 180;
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewAngleDiagonal()
 {
-	this->glview->object_rot_x = 35;
-	this->glview->object_rot_y = 0;
-	this->glview->object_rot_z = -25;
-	this->glview->updateGL();
+	this->qglview->object_rot_x = 35;
+	this->qglview->object_rot_y = 0;
+	this->qglview->object_rot_z = -25;
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewCenter()
 {
-	this->glview->object_trans_x = 0;
-	this->glview->object_trans_y = 0;
-	this->glview->object_trans_z = 0;
-	this->glview->updateGL();
+	this->qglview->object_trans_x = 0;
+	this->qglview->object_trans_y = 0;
+	this->qglview->object_trans_z = 0;
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewPerspective()
@@ -1663,8 +1663,8 @@ void MainWindow::viewPerspective()
 	settings.setValue("view/orthogonalProjection",false);
 	viewActionPerspective->setChecked(true);
 	viewActionOrthogonal->setChecked(false);
-	this->glview->setOrthoMode(false);
-	this->glview->updateGL();
+	this->qglview->setOrthoMode(false);
+	this->qglview->updateGL();
 }
 
 void MainWindow::viewOrthogonal()
@@ -1673,8 +1673,8 @@ void MainWindow::viewOrthogonal()
 	settings.setValue("view/orthogonalProjection",true);
 	viewActionPerspective->setChecked(false);
 	viewActionOrthogonal->setChecked(true);
-	this->glview->setOrthoMode(true);
-	this->glview->updateGL();
+	this->qglview->setOrthoMode(true);
+	this->qglview->updateGL();
 }
 
 void MainWindow::hideConsole()
@@ -1751,7 +1751,7 @@ void MainWindow::helpLibrary()
 		
 	}
 
-	this->openglbox->setDetailedText(libinfo + this->glview->getRendererInfo());
+	this->openglbox->setDetailedText(libinfo + QString(this->qglview->getRendererInfo()));
 	this->openglbox->show();
 }
 
diff --git a/src/glview.cc b/src/qglview.cc
index 859bf82..a359a68 100644
--- a/src/glview.cc
+++ b/src/qglview.cc
@@ -24,7 +24,7 @@
  *
  */
 
-#include "GLView.h"
+#include "QGLView.h"
 #include "Preferences.h"
 #include "renderer.h"
 #include "rendersettings.h"
@@ -59,27 +59,27 @@
 
 #define FAR_FAR_AWAY 100000.0
 
-GLView::GLView(QWidget *parent) : QGLWidget(parent), renderer(NULL)
+QGLView::QGLView(QWidget *parent) : QGLWidget(parent), renderer(NULL)
 {
 	init();
 }
 
-GLView::GLView(const QGLFormat & format, QWidget *parent) : QGLWidget(format, parent)
+QGLView::QGLView(const QGLFormat & format, QWidget *parent) : QGLWidget(format, parent)
 {
 	init();
 }
 
 static bool running_under_wine = false;
 
-void GLView::init()
+void QGLView::init()
 {
 	this->viewer_distance = 500;
-	this->object_rot_x = 35;
-	this->object_rot_y = 0;
-	this->object_rot_z = -25;
-	this->object_trans_x = 0;
-	this->object_trans_y = 0;
-	this->object_trans_z = 0;
+	this->object_rot.x() = 35;
+	this->object_rot.y() = 0;
+	this->object_rot.z() = -25;
+	this->object_trans.x() = 0;
+	this->object_trans.y() = 0;
+	this->object_trans.z() = 0;
 
 	this->mouse_drag_active = false;
 
@@ -113,13 +113,13 @@ void GLView::init()
 #endif
 }
 
-void GLView::setRenderer(Renderer *r)
+void QGLView::setRenderer(Renderer *r)
 {
 	this->renderer = r;
 	if (r) updateGL(); // Let the last image stay, e.g. to avoid animation flickering
 }
 
-void GLView::initializeGL()
+void QGLView::initializeGL()
 {
 	glEnable(GL_DEPTH_TEST);
 	glDepthRange(-FAR_FAR_AWAY, +FAR_FAR_AWAY);
@@ -320,7 +320,7 @@ void GLView::initializeGL()
 }
 
 #ifdef ENABLE_OPENCSG
-void GLView::display_opencsg_warning()
+void QGLView::display_opencsg_warning()
 {
 	OpenCSGWarningDialog *dialog = new OpenCSGWarningDialog(this);
 
@@ -352,7 +352,7 @@ void GLView::display_opencsg_warning()
 }
 #endif
 
-void GLView::resizeGL(int w, int h)
+void QGLView::resizeGL(int w, int h)
 {
 #ifdef ENABLE_OPENCSG
 	shaderinfo[9] = w;
@@ -364,7 +364,7 @@ void GLView::resizeGL(int w, int h)
 	setupPerspective();
 }
 
-void GLView::setupPerspective()
+void QGLView::setupPerspective()
 {
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
@@ -372,7 +372,7 @@ void GLView::setupPerspective()
 	gluLookAt(0.0, -viewer_distance, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0);
 }
 
-void GLView::setupOrtho(double distance, bool offset)
+void QGLView::setupOrtho(double distance, bool offset)
 {
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
@@ -385,7 +385,7 @@ void GLView::setupOrtho(double distance, bool offset)
 	gluLookAt(0.0, -viewer_distance, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0);
 }
 
-void GLView::paintGL()
+void QGLView::paintGL()
 {
 	glEnable(GL_LIGHTING);
 
@@ -400,9 +400,9 @@ void GLView::paintGL()
 
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 
-	glRotated(object_rot_x, 1.0, 0.0, 0.0);
-	glRotated(object_rot_y, 0.0, 1.0, 0.0);
-	glRotated(object_rot_z, 0.0, 0.0, 1.0);
+	glRotated(object_rot.x(), 1.0, 0.0, 0.0);
+	glRotated(object_rot.y(), 0.0, 1.0, 0.0);
+	glRotated(object_rot.z(), 0.0, 0.0, 1.0);
 
   // FIXME: Crosshairs and axes are lighted, this doesn't make sense and causes them
   // to change color based on view orientation.
@@ -421,7 +421,7 @@ void GLView::paintGL()
 		glEnd();
 	}
 
-	glTranslated(object_trans_x, object_trans_y, object_trans_z);
+	glTranslated(object_trans.x(), object_trans.y(), object_trans.z());
 
 	// Large gray axis cross inline with the model
   // FIXME: This is always gray - adjust color to keep contrast with background
@@ -464,9 +464,9 @@ void GLView::paintGL()
 
 		glMatrixMode(GL_MODELVIEW);
 		glLoadIdentity();
-		glRotated(object_rot_x, 1.0, 0.0, 0.0);
-		glRotated(object_rot_y, 0.0, 1.0, 0.0);
-		glRotated(object_rot_z, 0.0, 0.0, 1.0);
+		glRotated(object_rot.x(), 1.0, 0.0, 0.0);
+		glRotated(object_rot.y(), 0.0, 1.0, 0.0);
+		glRotated(object_rot.z(), 0.0, 0.0, 1.0);
 
 		glLineWidth(1);
 		glBegin(GL_LINES);
@@ -535,15 +535,15 @@ void GLView::paintGL()
 	if (statusLabel) {
 		QString msg;
 		msg.sprintf("Viewport: translate = [ %.2f %.2f %.2f ], rotate = [ %.2f %.2f %.2f ], distance = %.2f",
-			-object_trans_x, -object_trans_y, -object_trans_z,
-			fmodf(360 - object_rot_x + 90, 360), fmodf(360 - object_rot_y, 360), fmodf(360 - object_rot_z, 360), viewer_distance);
+			-object_trans.x(), -object_trans.y(), -object_trans.z(),
+			fmodf(360 - object_rot.x() + 90, 360), fmodf(360 - object_rot.y(), 360), fmodf(360 - object_rot.z(), 360), viewer_distance);
 		statusLabel->setText(msg);
 	}
 
 	if (running_under_wine) swapBuffers();
 }
 
-void GLView::keyPressEvent(QKeyEvent *event)
+void QGLView::keyPressEvent(QKeyEvent *event)
 {
 	if (event->key() == Qt::Key_Plus) {
 		viewer_distance *= 0.9;
@@ -557,19 +557,19 @@ void GLView::keyPressEvent(QKeyEvent *event)
 	}
 }
 
-void GLView::wheelEvent(QWheelEvent *event)
+void QGLView::wheelEvent(QWheelEvent *event)
 {
 	viewer_distance *= pow(0.9, event->delta() / 120.0);
 	updateGL();
 }
 
-void GLView::mousePressEvent(QMouseEvent *event)
+void QGLView::mousePressEvent(QMouseEvent *event)
 {
 	mouse_drag_active = true;
 	last_mouse = event->globalPos();
 }
 
-void GLView::normalizeAngle(GLdouble& angle)
+void QGLView::normalizeAngle(GLdouble& angle)
 {
 	while(angle < 0)
 		angle += 360;
@@ -577,7 +577,7 @@ void GLView::normalizeAngle(GLdouble& angle)
 		angle -= 360;
 }
 
-void GLView::mouseMoveEvent(QMouseEvent *event)
+void QGLView::mouseMoveEvent(QMouseEvent *event)
 {
 	QPoint this_mouse = event->globalPos();
 	double dx = (this_mouse.x()-last_mouse.x()) * 0.7;
@@ -590,15 +590,15 @@ void GLView::mouseMoveEvent(QMouseEvent *event)
 			) {
 			// Left button rotates in xz, Shift-left rotates in xy
 			// On Mac, Ctrl-Left is handled as right button on other platforms
-			object_rot_x += dy;
+			object_rot.x() += dy;
 			if ((QApplication::keyboardModifiers() & Qt::ShiftModifier) != 0)
-				object_rot_y += dx;
+				object_rot.y() += dx;
 			else
-				object_rot_z += dx;
+				object_rot.z() += dx;
 
-			normalizeAngle(object_rot_x);
-			normalizeAngle(object_rot_y);
-			normalizeAngle(object_rot_z);
+			normalizeAngle(object_rot.x());
+			normalizeAngle(object_rot.y());
+			normalizeAngle(object_rot.z());
 		} else {
 			// Right button pans in the xz plane
 			// Middle button pans in the xy plane
@@ -624,9 +624,9 @@ void GLView::mouseMoveEvent(QMouseEvent *event)
 			}
 
 			Matrix3d aax, aay, aaz, tm3;
-			aax = Eigen::AngleAxisd(-(object_rot_x/180) * M_PI, Vector3d::UnitX());
-			aay = Eigen::AngleAxisd(-(object_rot_y/180) * M_PI, Vector3d::UnitY());
-			aaz = Eigen::AngleAxisd(-(object_rot_z/180) * M_PI, Vector3d::UnitZ());
+			aax = Eigen::AngleAxisd(-(object_rot.x()/180) * M_PI, Vector3d::UnitX());
+			aay = Eigen::AngleAxisd(-(object_rot.y()/180) * M_PI, Vector3d::UnitY());
+			aaz = Eigen::AngleAxisd(-(object_rot.z()/180) * M_PI, Vector3d::UnitZ());
 			tm3 = Matrix3d::Identity();
 			tm3 = aaz * (aay * (aax * tm3));
 
@@ -642,9 +642,9 @@ void GLView::mouseMoveEvent(QMouseEvent *event)
         0,  0,  0,  1
 			;
       tm = tm * vec;
-      object_trans_x += tm(0,3);
-      object_trans_y += tm(1,3);
-      object_trans_z += tm(2,3);
+      object_trans.x() += tm(0,3);
+      object_trans.y() += tm(1,3);
+      object_trans.z() += tm(2,3);
 			}
 		}
 		updateGL();
@@ -653,7 +653,7 @@ void GLView::mouseMoveEvent(QMouseEvent *event)
 	last_mouse = this_mouse;
 }
 
-void GLView::mouseReleaseEvent(QMouseEvent*)
+void QGLView::mouseReleaseEvent(QMouseEvent*)
 {
 	mouse_drag_active = false;
 	releaseMouse();