Allow dropping of files onto window

app/package.sh

@@ -10,5 +10,5 @@ rm empty.lproj
 cd ../../..
 cp -r fstl.app ..
 cd ..
-zip -r fstl.zip fstl.app README.md
+zip -r fstl_mac.zip fstl.app README.md
 

exe/package.sh

@@ -1,3 +1,3 @@
 cd ..
 cp build/release/fstl.exe .
-/c/Program\ Files/7-Zip/7z.exe a fstl.zip fstl.exe README.md
+/c/Program\ Files/7-Zip/7z.exe a fstl_win.zip fstl.exe README.md

src/app.cpp

@@ -8,6 +8,9 @@ App::App(int argc, char *argv[]) :
     QApplication(argc, argv), window(new Window())
 {
     window->show();
+    if (argc > 1)
+        window->load_stl(argv[1]);
+    else
         window->load_stl(":gl/sphere.stl");
 }
 

src/loader.cpp

@@ -1,23 +1,129 @@
 #include "loader.h"
-#include "mesh.h"
 
 Loader::Loader(QObject* parent, const QString& filename)
     : QThread(parent), filename(filename)
 {
+    // Nothing to do here
 }
 
 void Loader::run()
 {
-    {   // Verify that this isn't an ascii stl file
+    Mesh* mesh = load_stl();
+    if (mesh)
+    {
+        emit got_mesh(mesh);
+        emit loaded_file(filename);
+    }
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct Vec3
+{
+    GLfloat x, y, z;
+    bool operator!=(const Vec3& rhs) const
+    {
+        return x != rhs.x || y != rhs.y || z != rhs.z;
+    }
+    bool operator<(const Vec3& rhs) const
+    {
+        if      (x != rhs.x)    return x < rhs.x;
+        else if (y != rhs.y)    return y < rhs.y;
+        else if (z != rhs.z)    return z < rhs.z;
+        else                    return false;
+    }
+};
+
+typedef std::pair<Vec3, GLuint> Vec3i;
+
+////////////////////////////////////////////////////////////////////////////////
+
+Mesh* Loader::load_stl()
+{
     QFile file(filename);
     file.open(QIODevice::ReadOnly);
     if (file.read(5) == "solid")
     {
         emit error_ascii_stl();
-            return;
+        return NULL;
     }
+    // Skip the rest of the header material
+    file.read(75);
+
+    QDataStream data(&file);
+    data.setByteOrder(QDataStream::LittleEndian);
+    data.setFloatingPointPrecision(QDataStream::SinglePrecision);
+
+    // Load the triangle count from the .stl file
+    uint32_t tri_count;
+    data >> tri_count;
+
+    // Verify that the file is the right size
+    if (file.size() != 84 + tri_count*50)
+    {
+        emit error_bad_stl();
+        return NULL;
     }
 
-    emit got_mesh(Mesh::load_stl(filename));
-    emit loaded_file(filename);
+    // Extract vertices into an array of xyz, unsigned pairs
+    QVector<Vec3i> verts(tri_count*3);
+
+    // Dummy array, because readRawData is faster than skipRawData
+    char buffer[sizeof(float)*3];
+
+    // Store vertices in the array, processing one triangle at a time.
+    for (auto v=verts.begin(); v != verts.end(); v += 3)
+    {
+        // Skip face's normal vector
+        data.readRawData(buffer, 3*sizeof(float));
+
+        // Load vertex data from .stl file into vertices
+        data >> v[0].first.x >> v[0].first.y >> v[0].first.z;
+        data >> v[1].first.x >> v[1].first.y >> v[1].first.z;
+        data >> v[2].first.x >> v[2].first.y >> v[2].first.z;
+
+        // Skip face attribute
+        data.readRawData(buffer, sizeof(uint16_t));
     }
+
+    // Save indicies as the second element in the array
+    // (so that we can reconstruct triangle order after sorting)
+    for (size_t i=0; i < tri_count*3; ++i)
+    {
+        verts[i].second = i;
+    }
+
+    // Sort the set of vertices (to deduplicate)
+    std::sort(verts.begin(), verts.end());
+
+    // This vector will store triangles as sets of 3 indices
+    std::vector<GLuint> indices(tri_count*3);
+
+    // Go through the sorted vertex list, deduplicating and creating
+    // an indexed geometry representation for the triangles.
+    // Unique vertices are moved so that they occupy the first vertex_count
+    // positions in the verts array.
+    size_t vertex_count = 0;
+    for (auto v : verts)
+    {
+        if (!vertex_count || v.first != verts[vertex_count-1].first)
+        {
+            verts[vertex_count++] = v;
+        }
+        indices[v.second] = vertex_count - 1;
+    }
+    verts.resize(vertex_count);
+
+    std::vector<GLfloat> flat_verts;
+    flat_verts.reserve(vertex_count*3);
+    for (auto v : verts)
+    {
+        flat_verts.push_back(v.first.x);
+        flat_verts.push_back(v.first.y);
+        flat_verts.push_back(v.first.z);
+    }
+
+    return new Mesh(flat_verts, indices);
+}
+

src/loader.h

@@ -12,10 +12,15 @@ public:
     explicit Loader(QObject* parent, const QString& filename);
     void run();
 
+protected:
+    Mesh* load_stl();
+
 signals:
     void loaded_file(QString filename);
     void got_mesh(Mesh* m);
+
     void error_ascii_stl();
+    void error_bad_stl();
 
 private:
     const QString filename;

src/mesh.cpp

@@ -2,7 +2,6 @@
 #include <QDataStream>
 #include <QVector3D>
 
-#include <algorithm>
 #include <cmath>
 
 #include "mesh.h"
@@ -34,101 +33,3 @@ float Mesh::max(size_t start) const
     }
     return v;
 }
-////////////////////////////////////////////////////////////////////////////////
-
-struct Vec3
-{
-    GLfloat x, y, z;
-    bool operator!=(const Vec3& rhs) const
-    {
-        return x != rhs.x || y != rhs.y || z != rhs.z;
-    }
-    bool operator<(const Vec3& rhs) const
-    {
-        if      (x != rhs.x)    return x < rhs.x;
-        else if (y != rhs.y)    return y < rhs.y;
-        else if (z != rhs.z)    return z < rhs.z;
-        else                    return false;
-    }
-};
-
-typedef std::pair<Vec3, GLuint> Vec3i;
-
-////////////////////////////////////////////////////////////////////////////////
-
-Mesh* Mesh::load_stl(const QString& filename)
-{
-    QFile file(filename);
-    file.open(QIODevice::ReadOnly);
-
-    QDataStream data(&file);
-    data.setByteOrder(QDataStream::LittleEndian);
-    data.setFloatingPointPrecision(QDataStream::SinglePrecision);
-
-    // Skip .stl file header
-    data.skipRawData(80);
-
-    // Load the triangle count from the .stl file
-    uint32_t tri_count;
-    data >> tri_count;
-
-    // Extract vertices into an array of xyz, unsigned pairs
-    QVector<Vec3i> verts(tri_count*3);
-
-    // Dummy array, because readRawData is faster than skipRawData
-    char buffer[sizeof(float)*3];
-
-    // Store vertices in the array, processing one triangle at a time.
-    for (auto v=verts.begin(); v != verts.end(); v += 3)
-    {
-        // Skip face's normal vector
-        data.readRawData(buffer, 3*sizeof(float));
-
-        // Load vertex data from .stl file into vertices
-        data >> v[0].first.x >> v[0].first.y >> v[0].first.z;
-        data >> v[1].first.x >> v[1].first.y >> v[1].first.z;
-        data >> v[2].first.x >> v[2].first.y >> v[2].first.z;
-
-        // Skip face attribute
-        data.readRawData(buffer, sizeof(uint16_t));
-    }
-
-    // Save indicies as the second element in the array
-    // (so that we can reconstruct triangle order after sorting)
-    for (size_t i=0; i < tri_count*3; ++i)
-    {
-        verts[i].second = i;
-    }
-
-    // Sort the set of vertices (to deduplicate)
-    std::sort(verts.begin(), verts.end());
-
-    // This vector will store triangles as sets of 3 indices
-    std::vector<GLuint> indices(tri_count*3);
-
-    // Go through the sorted vertex list, deduplicating and creating
-    // an indexed geometry representation for the triangles.
-    // Unique vertices are moved so that they occupy the first vertex_count
-    // positions in the verts array.
-    size_t vertex_count = 0;
-    for (auto v : verts)
-    {
-        if (!vertex_count || v.first != verts[vertex_count-1].first)
-        {
-            verts[vertex_count++] = v;
-        }
-        indices[v.second] = vertex_count - 1;
-    }
-    verts.resize(vertex_count);
-
-    std::vector<GLfloat> flat_verts;
-    flat_verts.reserve(vertex_count*3);
-    for (auto v : verts)
-    {
-        flat_verts.push_back(v.first.x);
-        flat_verts.push_back(v.first.y);
-        flat_verts.push_back(v.first.z);
-    }
-
-    return new Mesh(flat_verts, indices);
-}

src/mesh.h

@@ -10,7 +10,6 @@ class Mesh
 {
 public:
     Mesh(std::vector<GLfloat> vertices, std::vector<GLuint> indices);
-    static Mesh* load_stl(const QString& filename);
 
     float min(size_t start) const;
     float max(size_t start) const;

src/window.cpp

@@ -14,6 +14,7 @@ Window::Window(QWidget *parent) :
 
 {
     setWindowTitle("fstl");
+    setAcceptDrops(true);
 
     QFile styleFile(":/qt/style.qss");
     styleFile.open( QFile::ReadOnly );
@@ -77,6 +78,14 @@ void Window::on_ascii_stl()
                           "Please convert to binary <code>.stl</code> and retry");
 }
 
+void Window::on_bad_stl()
+{
+    QMessageBox::critical(this, "Error",
+                          "<b>Error:</b><br>"
+                          "This <code>.stl</code> file is invalid or corrupted.<br>"
+                          "Please export it from the original source, verify, and retry.");
+}
+
 void Window::enable_open()
 {
     open_action->setEnabled(true);
@@ -101,6 +110,8 @@ bool Window::load_stl(const QString& filename)
             canvas, &Canvas::load_mesh);
     connect(loader, &Loader::error_ascii_stl,
               this, &Window::on_ascii_stl);
+    connect(loader, &Loader::error_bad_stl,
+              this, &Window::on_bad_stl);
 
     connect(loader, &Loader::finished,
             loader, &Loader::deleteLater);
@@ -118,3 +129,18 @@ bool Window::load_stl(const QString& filename)
     loader->start();
     return true;
 }
+
+void Window::dragEnterEvent(QDragEnterEvent *event)
+{
+    if (event->mimeData()->hasUrls())
+    {
+        auto urls = event->mimeData()->urls();
+        if (urls.size() == 1 && urls.front().path().endsWith(".stl"))
+            event->acceptProposedAction();
+    }
+}
+
+void Window::dropEvent(QDropEvent *event)
+{
+    load_stl(event->mimeData()->urls().front().toLocalFile());
+}

src/window.h

@@ -12,10 +12,15 @@ public:
     explicit Window(QWidget* parent=0);
     bool load_stl(const QString& filename);
 
+protected:
+    void dragEnterEvent(QDragEnterEvent* event);
+    void dropEvent(QDropEvent* event);
+
 public slots:
     void on_open();
     void on_about();
     void on_ascii_stl();
+    void on_bad_stl();
 
     void enable_open();
     void disable_open();