diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index 63578c78a7..2d15e7fc58 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -1623,20 +1623,7 @@ void Application::importVoxelsToClipboard() {
     
     _clipboardTree.eraseAllVoxels();
     if (fileNameString.endsWith(".png", Qt::CaseInsensitive)) {
-        QImage pngImage = QImage(fileName);
-        if (pngImage.height() != pngImage.width()) {
-            qDebug("ERROR: Bad PNG size: height != width.\n");
-            return;
-        }
-        
-        const uint32_t* pixels;
-        if (pngImage.format() == QImage::Format_ARGB32) {
-            pixels = reinterpret_cast<const uint32_t*>(pngImage.constBits());
-        } else {
-            QImage tmp = pngImage.convertToFormat(QImage::Format_ARGB32);
-            pixels = reinterpret_cast<const uint32_t*>(tmp.constBits());
-        }
-        _clipboardTree.readFromSquareARGB32Pixels(pixels, pngImage.height());
+        _clipboardTree.readFromSquareARGB32Pixels(fileName);
     } else if (fileNameString.endsWith(".svo", Qt::CaseInsensitive)) {
         _clipboardTree.readFromSVOFile(fileName);
     } else if (fileNameString.endsWith(".schematic", Qt::CaseInsensitive)) {
@@ -1696,7 +1683,7 @@ void Application::importVoxels() {
                 pixels = reinterpret_cast<const uint32_t*>(tmp.constBits());
             }
         
-            importVoxels.readFromSquareARGB32Pixels(pixels, pngImage.height());        
+            importVoxels.readFromSquareARGB32Pixels(fileName);
         } else if (fileNameString.endsWith(".svo", Qt::CaseInsensitive)) {
             extension = QString(".svo");
             importVoxels.readFromSVOFile(fileName);
@@ -1963,8 +1950,7 @@ void Application::initMenu() {
     (_destructiveAddVoxel = voxelMenu->addAction("Create Voxel is Destructive"))->setCheckable(true);
     
     voxelMenu->addAction("Export Voxels", this, SLOT(exportVoxels()), Qt::CTRL | Qt::Key_E);
-    voxelMenu->addAction("Import Voxels", &_voxelImporter, SLOT(exec()), Qt::CTRL | Qt::Key_I);
-    voxelMenu->addAction("Import Voxels to Clipboard", this, SLOT(importVoxelsToClipboard()), Qt::SHIFT | Qt::CTRL | Qt::Key_I);
+    voxelMenu->addAction("Import Voxels", &_voxelImporter, SLOT(import()), Qt::CTRL | Qt::Key_I);
     voxelMenu->addAction("Cut Voxels",    this, SLOT(cutVoxels()),    Qt::CTRL | Qt::Key_X);
     voxelMenu->addAction("Copy Voxels",   this, SLOT(copyVoxels()),   Qt::CTRL | Qt::Key_C);
     voxelMenu->addAction("Paste Voxels",  this, SLOT(pasteVoxels()),  Qt::CTRL | Qt::Key_V);
diff --git a/interface/src/VoxelImporter.cpp b/interface/src/VoxelImporter.cpp
index 4c389540d2..488dd4b907 100644
--- a/interface/src/VoxelImporter.cpp
+++ b/interface/src/VoxelImporter.cpp
@@ -6,71 +6,85 @@
 //  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
 //
 
-#include "VoxelImporter.h"
+#include <VoxelImporter.h>
 
-#include <QObject>
-#include <QStandardPaths>
-#include <QGridLayout>
+#include <QFileInfo>
+#include <QThreadPool>
 
-const QString WINDOW_NAME                     = QObject::tr("Import Voxels");
-const QString PREVIEW_CHECKBOX_STRING         = QObject::tr("Load preview");
-const QString IMPORT_BUTTON_NAME              = QObject::tr("Import");
-const QString IMPORT_TO_CLIPBOARD_BUTTON_NAME = QObject::tr("Import into clipboard");
-const QString IMPORT_FILE_TYPES               = QObject::tr("Sparse Voxel Octree Files, "
-                                                            "Square PNG, "
-                                                            "Schematic Files "
-                                                            "(*.svo *.png *.schematic)");
+class LocalVoxelSystem : public VoxelSystem {
+public:
+    LocalVoxelSystem() : VoxelSystem(1) {};
 
-const QString DESKTOP_LOCATION = QStandardPaths::writableLocation(QStandardPaths::DesktopLocation);
+    virtual void removeOutOfView() {};
+};
 
 VoxelImporter::VoxelImporter(QWidget* parent)
-    : QFileDialog(parent, WINDOW_NAME, DESKTOP_LOCATION, IMPORT_FILE_TYPES),
-      _importButton         (IMPORT_BUTTON_NAME             , this),
-      _clipboardImportButton(IMPORT_TO_CLIPBOARD_BUTTON_NAME, this),
-      _previewBox           (PREVIEW_CHECKBOX_STRING        , this),
-      _previewBar           (this),
-      _glPreview            (this) {
+    : QObject(parent),
+      _voxelSystem(new LocalVoxelSystem()),
+      _importDialog(parent, _voxelSystem),
+      _currentTask(NULL),
+      _nextTask(NULL) {
 
-    setOption(QFileDialog::DontUseNativeDialog, true);
-    setFileMode(QFileDialog::ExistingFile);
-    setViewMode(QFileDialog::Detail);
-    _previewBar.setVisible(false);
-    _glPreview.setVisible(false);
-
-    QGridLayout* gridLayout = (QGridLayout*) layout();
-    gridLayout->addWidget(&_importButton         , 2, 2);
-    gridLayout->addWidget(&_clipboardImportButton, 2, 3);
-    gridLayout->addWidget(&_previewBox           , 3, 3);
-    gridLayout->addWidget(&_previewBar           , 0, 3);
-    gridLayout->addWidget(&_glPreview            , 1, 3);
-
-
-    connect(&_importButton         , SIGNAL(pressed()), this, SLOT(importVoxels()));
-    connect(&_clipboardImportButton, SIGNAL(pressed()), this, SLOT(importVoxelsToClipboard()));
-    connect(&_previewBox, SIGNAL(toggled(bool)), &_previewBar, SLOT(setVisible(bool)));
-    connect(&_previewBox, SIGNAL(toggled(bool)), &_glPreview , SLOT(setVisible(bool)));
+    connect(&_importDialog, SIGNAL(previewActivated(QString)), SLOT(preImport(QString)));
+    connect(&_importDialog, SIGNAL(currentChanged(QString))  , SLOT(preImport(QString)));
 }
 
-int VoxelImporter::exec() {
-    _previewBox.setChecked(false);
-    _previewBar.setVisible(false);
-    _glPreview.setVisible(false);
+void VoxelImporter::import(const QString &filename) {
+    _importDialog.reset();
+    _filename = filename;
+    _currentTask = NULL;
+    _nextTask = NULL;
 
-    return exec();
-}
+    if (_filename == "") {
+        _importDialog.exec();
+    }
 
 
-void VoxelImporter::importVoxels() {
-    accept();
-    qDebug("Congratulation, you imported a file.\n");
-}
-
-void VoxelImporter::importVoxelsToClipboard() {
-    accept();
-    qDebug("Congratulation, you imported a file to the clipboard.\n");
-
 }
 
-void VoxelImporter::preview(bool) {
+void VoxelImporter::preImport(const QString &filename) {
+    if (_importDialog.getWantPreview() && QFileInfo(filename).isFile()) {
+        _filename = filename;
+
+        _nextTask = new ImportTask(_voxelSystem, _filename);
+        connect(_nextTask, SIGNAL(destroyed()), SLOT(launchTask()));
+
+        _importDialog.reset();
+
+        if (_currentTask != NULL) {
+            _voxelSystem->getVoxelTree()->cancelImport();
+        } else {
+            launchTask();
+        }
+    }
+}
+
+void VoxelImporter::launchTask() {
+    if (_nextTask != NULL) {
+        _voxelSystem->killLocalVoxels();
+        _currentTask = _nextTask;
+        _nextTask = NULL;
+        QThreadPool::globalInstance()->start(_currentTask);
+    } else {
+        _currentTask = NULL;
+    }
+}
+
+ImportTask::ImportTask(VoxelSystem* voxelSystem, const QString &filename)
+    : _voxelSystem(voxelSystem),
+      _filename(filename) {
 
 }
+
+void ImportTask::run() {
+    if (_filename.endsWith(".png", Qt::CaseInsensitive)) {
+        _voxelSystem->readFromSquareARGB32Pixels(_filename.toLocal8Bit().data());
+    } else if (_filename.endsWith(".svo", Qt::CaseInsensitive)) {
+        _voxelSystem->readFromSVOFile(_filename.toLocal8Bit().data());
+    } else if (_filename.endsWith(".schematic", Qt::CaseInsensitive)) {
+        qDebug("[DEBUG] %d.\n",
+               _voxelSystem->readFromSchematicFile(_filename.toLocal8Bit().data()));
+    } else {
+        qDebug("[ERROR] Invalid file extension.\n");
+    }
+}
diff --git a/interface/src/VoxelImporter.h b/interface/src/VoxelImporter.h
index a664788a82..1e8f1a14ae 100644
--- a/interface/src/VoxelImporter.h
+++ b/interface/src/VoxelImporter.h
@@ -9,29 +9,45 @@
 #ifndef __hifi__VoxelImporter__
 #define __hifi__VoxelImporter__
 
-#include <QFileDialog>
-#include <QPushButton>
-#include <QCheckBox>
-#include <QProgressBar>
-#include <QGLWidget>
+#include <VoxelSystem.h>
+#include <ImportDialog.h>
 
-class VoxelImporter : public QFileDialog {
+#include <QThread>
+#include <QRunnable>
+
+class ImportTask : public QObject, public QRunnable {
+    Q_OBJECT
+public:
+    ImportTask(VoxelSystem* voxelSystem, const QString &filename);
+    void run();
+
+private:
+    VoxelSystem*  _voxelSystem;
+    QString       _filename;
+};
+
+class VoxelImporter : public QObject {
     Q_OBJECT
 public:
     VoxelImporter(QWidget* parent = NULL);
 
+    void init();
+
 public slots:
-    int exec();
-    void importVoxels();
-    void importVoxelsToClipboard();
-    void preview(bool);
+    void import(const QString &filename = "");
+    void preImport(const QString &filename);
+
+private slots:
+    void launchTask();
 
 private:
-    QPushButton  _importButton;
-    QPushButton  _clipboardImportButton;
-    QCheckBox    _previewBox;
-    QProgressBar _previewBar;
-    QGLWidget    _glPreview;
+    VoxelSystem* _voxelSystem;
+    ImportDialog _importDialog;
+
+    QString      _filename;
+
+    ImportTask* _currentTask;
+    ImportTask* _nextTask;
 };
 
 #endif /* defined(__hifi__VoxelImporter__) */
diff --git a/interface/src/VoxelSystem.cpp b/interface/src/VoxelSystem.cpp
index becf9f868f..5509ca3a72 100644
--- a/interface/src/VoxelSystem.cpp
+++ b/interface/src/VoxelSystem.cpp
@@ -139,6 +139,22 @@ bool VoxelSystem::readFromSVOFile(const char* filename) {
     return result;
 }
 
+bool VoxelSystem::readFromSquareARGB32Pixels(const char *filename) {
+    bool result = _tree->readFromSquareARGB32Pixels(filename);
+    if (result) {
+        setupNewVoxelsForDrawing();
+    }
+    return result;
+}
+
+bool VoxelSystem::readFromSchematicFile(const char* filename) {
+    bool result = _tree->readFromSchematicFile(filename);
+    if (result) {
+        setupNewVoxelsForDrawing();
+    }
+    return result;
+}
+
 long int VoxelSystem::getVoxelsCreated() {
     return _tree->voxelsCreated;
 }
diff --git a/interface/src/VoxelSystem.h b/interface/src/VoxelSystem.h
index 94e2d42e5e..56c22dc02c 100644
--- a/interface/src/VoxelSystem.h
+++ b/interface/src/VoxelSystem.h
@@ -42,12 +42,16 @@ public:
     void simulate(float deltaTime) { };
     void render(bool texture);
 
-    unsigned long  getVoxelsUpdated() const {return _voxelsUpdated;};
+
+    VoxelTree*     getVoxelTree     () const {return _tree;}
+    unsigned long  getVoxelsUpdated () const {return _voxelsUpdated;};
     unsigned long  getVoxelsRendered() const {return _voxelsInReadArrays;};
 
     void loadVoxelsFile(const char* fileName,bool wantColorRandomizer);
     void writeToSVOFile(const char* filename, VoxelNode* node) const;
     bool readFromSVOFile(const char* filename);
+    bool readFromSquareARGB32Pixels(const char* filename);
+    bool readFromSchematicFile(const char* filename);
 
     long int getVoxelsCreated();
     long int getVoxelsColored();
diff --git a/libraries/voxels/src/Tags.cpp b/libraries/voxels/src/Tags.cpp
index 7df6f227ad..914606ce07 100644
--- a/libraries/voxels/src/Tags.cpp
+++ b/libraries/voxels/src/Tags.cpp
@@ -159,14 +159,19 @@ int retrieveData(std::string filename, std::stringstream &ss) {
 
     int type = file.peek();
     if (type == 0x0A) {
+        std::cerr << "[DEBUG] Unzipped\n";
         ss.flush();
         ss << file;
         return 0;
     }
+
     if (type == 0x1F) {
-        return ungzip(file, ss);
+        std::cerr << "[DEBUG] Zipped\n";
+        int ret = ungzip(file, ss);
+        return ret;
     }
 
+    std::cerr << "[DEBUG] Neither\n";
     return 1;
 }
 
@@ -242,3 +247,156 @@ int ungzip(std::ifstream &file, std::stringstream &ss) {
 }
 
 
+void computeBlockColor(int id, int data, int& red, int& green, int& blue, int& create) {
+
+    switch (id) {
+        case   1:
+        case  14:
+        case  15:
+        case  16:
+        case  21:
+        case  56:
+        case  73:
+        case  74:
+        case  97:
+        case 129: red = 128; green = 128; blue = 128; break;
+        case   2: red =  77; green = 117; blue =  66; break;
+        case   3:
+        case  60: red = 116; green =  83; blue =  56; break;
+        case   4: red =  71; green =  71; blue =  71; break;
+        case   5:
+        case 125: red = 133; green =  94; blue =  62; break;
+        case   7: red =  35; green =  35; blue =  35; break;
+        case   8:
+        case   9: red = 100; green = 109; blue = 185; break;
+        case  10:
+        case  11: red = 192; green =  64; blue =   8; break;
+        case  12: red = 209; green = 199; blue = 155; break;
+        case  13: red =  96; green =  94; blue =  93; break;
+        case  17: red =  71; green =  56; blue =  35; break;
+        case  18: red =  76; green = 104; blue =  64; break;
+        case  19: red = 119; green = 119; blue =  37; break;
+        case  22: red =  22; green =  44; blue =  86; break;
+        case  23:
+        case  29:
+        case  33:
+        case  61:
+        case  62:
+        case 158: red =  61; green =  61; blue =  61; break;
+        case  24: red = 209; green = 202; blue = 156; break;
+        case  25:
+        case  58:
+        case  84:
+        case 137: red =  57; green =  38; blue =  25; break;
+        case  35:
+            switch (data) {
+                case  0: red = 234; green = 234; blue = 234; break;
+                case  1: red = 224; green = 140; blue =  84; break;
+                case  2: red = 185; green =  90; blue = 194; break;
+                case  3: red = 124; green = 152; blue = 208; break;
+                case  4: red = 165; green = 154; blue =  35; break;
+                case  5: red =  70; green = 187; blue =  61; break;
+                case  6: red = 206; green = 124; blue = 145; break;
+                case  7: red =  66; green =  66; blue =  66; break;
+                case  8: red = 170; green = 176; blue = 176; break;
+                case  9: red =  45; green = 108; blue =  35; break;
+                case 10: red = 130; green =  62; blue =   8; break;
+                case 11: red =  43; green =  51; blue =  29; break;
+                case 12: red =  73; green =  47; blue =  29; break;
+                case 13: red =  57; green =  76; blue =  36; break;
+                case 14: red = 165; green =  58; blue =  53; break;
+                case 15: red =  24; green =  24; blue =  24; break;
+                default:
+                    create = 0;
+                    break;
+            }
+            break;
+        case  41: red = 239; green = 238; blue = 105; break;
+        case  42: red = 146; green = 146; blue = 146; break;
+        case  43:
+        case  98: red = 161; green = 161; blue = 161; break;
+        case  44:
+            create = 3;
+
+            switch (data) {
+                case 0: red = 161; green = 161; blue = 161; break;
+                case 1: red = 209; green = 202; blue = 156; break;
+                case 2: red = 133; green =  94; blue =  62; break;
+                case 3: red =  71; green =  71; blue =  71; break;
+                case 4: red = 121; green =  67; blue =  53; break;
+                case 5: red = 161; green = 161; blue = 161; break;
+                case 6: red =  45; green =  22; blue =  26; break;
+                case 7: red = 195; green = 192; blue = 185; break;
+                default:
+                    create = 0;
+                    break;
+            }
+            break;
+        case  45: red = 121; green =  67; blue =  53; break;
+        case  46: red = 118; green =  36; blue =  13; break;
+        case  47: red = 155; green = 127; blue =  76; break;
+        case  48: red =  61; green =  79; blue =  61; break;
+        case  49: red =  52; green =  41; blue =  74; break;
+        case  52: red =  12; green =  66; blue =  71; break;
+        case  53:
+        case  67:
+        case 108:
+        case 109:
+        case 114:
+        case 128:
+        case 134:
+        case 135:
+        case 136:
+        case 156:
+            create = 2;
+
+            switch (id) {
+                case  53:
+                case 134:
+                case 135:
+                case 136: red = 133; green =  94; blue =  62; break;
+                case  67: red =  71; green =  71; blue =  71; break;
+                case 108: red = 121; green =  67; blue =  53; break;
+                case 109: red = 161; green = 161; blue = 161; break;
+                case 114: red =  45; green =  22; blue =  26; break;
+                case 128: red = 209; green = 202; blue = 156; break;
+                case 156: red = 195; green = 192; blue = 185; break;
+                default:
+                    create = 0;
+                    break;
+            }
+            break;
+        case  54:
+        case  95:
+        case 146: red = 155; green = 105; blue =  32; break;
+        case  57: red = 145; green = 219; blue = 215; break;
+        case  79: red = 142; green = 162; blue = 195; break;
+        case  80: red = 255; green = 255; blue = 255; break;
+        case  81: red =   8; green =  64; blue =  15; break;
+        case  82: red = 150; green = 155; blue = 166; break;
+        case  86:
+        case  91: red = 179; green = 108; blue =  17; break;
+        case  87:
+        case 153: red =  91; green =  31; blue =  30; break;
+        case  88: red =  68; green =  49; blue =  38; break;
+        case  89: red = 180; green = 134; blue =  65; break;
+        case 103: red = 141; green = 143; blue =  36; break;
+        case 110: red = 103; green =  92; blue =  95; break;
+        case 112: red =  45; green =  22; blue =  26; break;
+        case 121: red = 183; green = 178; blue = 129; break;
+        case 123: red = 101; green =  59; blue =  31; break;
+        case 124: red = 213; green = 178; blue = 123; break;
+        case 130: red =  38; green =  54; blue =  56; break;
+        case 133: red =  53; green =  84; blue =  85; break;
+        case 152: red = 131; green =  22; blue =   7; break;
+        case 155: red = 195; green = 192; blue = 185; break;
+        case 159: red = 195; green = 165; blue = 150; break;
+        case 170: red = 168; green = 139; blue =  15; break;
+        case 172: red = 140; green =  86; blue =  61; break;
+        case 173: red =   9; green =   9; blue =   9; break;
+        default:
+            create = 0;
+            break;
+    }
+}
+
diff --git a/libraries/voxels/src/Tags.h b/libraries/voxels/src/Tags.h
index a005095142..9888190b14 100644
--- a/libraries/voxels/src/Tags.h
+++ b/libraries/voxels/src/Tags.h
@@ -29,8 +29,9 @@
 #define TAG_Compound  10
 #define TAG_Int_Array 11
 
-int retrieveData(std::string filename, std::stringstream &ss);
-int ungzip(std::ifstream &file, std::stringstream &ss);
+int  retrieveData(std::string filename, std::stringstream &ss);
+int  ungzip(std::ifstream &file, std::stringstream &ss);
+void computeBlockColor(int id, int data, int& r, int& g, int& b, int& create);
 
 class Tag {
 public:
diff --git a/libraries/voxels/src/VoxelTree.cpp b/libraries/voxels/src/VoxelTree.cpp
index c0fcee02dd..146e013cf6 100644
--- a/libraries/voxels/src/VoxelTree.cpp
+++ b/libraries/voxels/src/VoxelTree.cpp
@@ -18,6 +18,7 @@
 #include <glm/gtc/noise.hpp>
 
 #include <QtCore/QDebug>
+#include <QImage>
 
 #include "CoverageMap.h"
 #include "GeometryUtil.h"
@@ -48,7 +49,8 @@ VoxelTree::VoxelTree(bool shouldReaverage) :
     voxelsColoredStats(100),
     voxelsBytesReadStats(100),
     _isDirty(true),
-    _shouldReaverage(shouldReaverage) {
+    _shouldReaverage(shouldReaverage),
+    _stopImport(false) {
     rootNode = new VoxelNode();
 }
 
@@ -1576,15 +1578,29 @@ bool VoxelTree::readFromSVOFile(const char* fileName) {
     return false;
 }
 
-bool VoxelTree::readFromSquareARGB32Pixels(const uint32_t* pixels, int dimension) {
-    SquarePixelMap pixelMap = SquarePixelMap(pixels, dimension);
+bool VoxelTree::readFromSquareARGB32Pixels(const char* filename) {
+    QImage pngImage = QImage(filename);
+    if (pngImage.height() != pngImage.width()) {
+        qDebug("ERROR: Bad PNG size: height != width.\n");
+        return false;
+    }
+
+    const uint32_t* pixels;
+    if (pngImage.format() == QImage::Format_ARGB32) {
+        pixels = reinterpret_cast<const uint32_t*>(pngImage.constBits());
+    } else {
+        QImage tmp = pngImage.convertToFormat(QImage::Format_ARGB32);
+        pixels = reinterpret_cast<const uint32_t*>(tmp.constBits());
+    }
+
+    SquarePixelMap pixelMap = SquarePixelMap(pixels, pngImage.height());
     pixelMap.addVoxelsToVoxelTree(this);
     return true;
 }
 
 bool VoxelTree::readFromSchematicFile(const char *fileName) {
     std::stringstream ss;
-    int err = retrieveData(fileName, ss);
+    int err = retrieveData(std::string(fileName), ss);
     if (err && ss.get() != TAG_Compound) {
         qDebug("[ERROR] Invalid schematic file.\n");
         return false;
@@ -1593,10 +1609,12 @@ bool VoxelTree::readFromSchematicFile(const char *fileName) {
     ss.get();
     TagCompound schematics(ss);
     if (!schematics.getBlocksId() || !schematics.getBlocksData()) {
-        qDebug("[ERROR] Invalid schematic file.\n");
+        qDebug("[ERROR] Invalid schematic data.\n");
         return false;
     }
 
+    _stopImport = false;
+
     int max = (schematics.getWidth() > schematics.getLength()) ? schematics.getWidth() : schematics.getLength();
     max = (max > schematics.getHeight()) ? max : schematics.getHeight();
 
@@ -1608,9 +1626,21 @@ bool VoxelTree::readFromSchematicFile(const char *fileName) {
     int red = 128, green = 128, blue = 128;
     int count = 0;
 
+    emit importSize(size * schematics.getWidth(),
+                    size * schematics.getHeight(),
+                    size * schematics.getLength());
+
     for (int y = 0; y < schematics.getHeight(); ++y) {
         for (int z = 0; z < schematics.getLength(); ++z) {
+            emit importProgress((int) 100 * (y * schematics.getLength() + z) / (schematics.getHeight() * schematics.getLength()));
+
             for (int x = 0; x < schematics.getWidth(); ++x) {
+                if (_stopImport) {
+                    qDebug("[DEBUG] Canceled import at %d voxels.\n", count);
+                    _stopImport = false;
+                    return true;
+                }
+
                 int pos  = ((y * schematics.getLength()) + z) * schematics.getWidth() + x;
                 int id   = schematics.getBlocksId()[pos];
                 int data = schematics.getBlocksData()[pos];
@@ -1656,6 +1686,7 @@ bool VoxelTree::readFromSchematicFile(const char *fileName) {
         }
     }
 
+    emit importProgress(100);
     qDebug("Created %d voxels from minecraft import.\n", count);
 
     return true;
@@ -1747,155 +1778,6 @@ void VoxelTree::copyFromTreeIntoSubTree(VoxelTree* sourceTree, VoxelNode* destin
     }
 }
 
-void VoxelTree::computeBlockColor(int id, int data, int& red, int& green, int& blue, int& create) {
-
-    switch (id) {
-        case   1:
-        case  14:
-        case  15:
-        case  16:
-        case  21:
-        case  56:
-        case  73:
-        case  74:
-        case  97:
-        case 129: red = 128; green = 128; blue = 128; break;
-        case   2: red =  77; green = 117; blue =  66; break;
-        case   3:
-        case  60: red = 116; green =  83; blue =  56; break;
-        case   4: red =  71; green =  71; blue =  71; break;
-        case   5:
-        case 125: red = 133; green =  94; blue =  62; break;
-        case   7: red =  35; green =  35; blue =  35; break;
-        case   8:
-        case   9: red = 100; green = 109; blue = 185; break;
-        case  10:
-        case  11: red = 192; green =  64; blue =   8; break;
-        case  12: red = 209; green = 199; blue = 155; break;
-        case  13: red =  96; green =  94; blue =  93; break;
-        case  17: red =  71; green =  56; blue =  35; break;
-        case  18: red =  76; green = 104; blue =  64; break;
-        case  19: red = 119; green = 119; blue =  37; break;
-        case  22: red =  22; green =  44; blue =  86; break;
-        case  23:
-        case  29:
-        case  33:
-        case  61:
-        case  62:
-        case 158: red =  61; green =  61; blue =  61; break;
-        case  24: red = 209; green = 202; blue = 156; break;
-        case  25:
-        case  58:
-        case  84:
-        case 137: red =  57; green =  38; blue =  25; break;
-        case  35:
-            switch (data) {
-                case  0: red = 234; green = 234; blue = 234; break;
-                case  1: red = 224; green = 140; blue =  84; break;
-                case  2: red = 185; green =  90; blue = 194; break;
-                case  3: red = 124; green = 152; blue = 208; break;
-                case  4: red = 165; green = 154; blue =  35; break;
-                case  5: red =  70; green = 187; blue =  61; break;
-                case  6: red = 206; green = 124; blue = 145; break;
-                case  7: red =  66; green =  66; blue =  66; break;
-                case  8: red = 170; green = 176; blue = 176; break;
-                case  9: red =  45; green = 108; blue =  35; break;
-                case 10: red = 130; green =  62; blue =   8; break;
-                case 11: red =  43; green =  51; blue =  29; break;
-                case 12: red =  73; green =  47; blue =  29; break;
-                case 13: red =  57; green =  76; blue =  36; break;
-                case 14: red = 165; green =  58; blue =  53; break;
-                case 15: red =  24; green =  24; blue =  24; break;
-                default:
-                    create = 0;
-                    break;
-            }
-            break;
-        case  41: red = 239; green = 238; blue = 105; break;
-        case  42: red = 146; green = 146; blue = 146; break;
-        case  43:
-        case  98: red = 161; green = 161; blue = 161; break;
-        case  44:
-            create = 3;
-
-            switch (data) {
-                case 0: red = 161; green = 161; blue = 161; break;
-                case 1: red = 209; green = 202; blue = 156; break;
-                case 2: red = 133; green =  94; blue =  62; break;
-                case 3: red =  71; green =  71; blue =  71; break;
-                case 4: red = 121; green =  67; blue =  53; break;
-                case 5: red = 161; green = 161; blue = 161; break;
-                case 6: red =  45; green =  22; blue =  26; break;
-                case 7: red = 195; green = 192; blue = 185; break;
-                default:
-                    create = 0;
-                    break;
-            }
-            break;
-        case  45: red = 121; green =  67; blue =  53; break;
-        case  46: red = 118; green =  36; blue =  13; break;
-        case  47: red = 155; green = 127; blue =  76; break;
-        case  48: red =  61; green =  79; blue =  61; break;
-        case  49: red =  52; green =  41; blue =  74; break;
-        case  52: red =  12; green =  66; blue =  71; break;
-        case  53:
-        case  67:
-        case 108:
-        case 109:
-        case 114:
-        case 128:
-        case 134:
-        case 135:
-        case 136:
-        case 156:
-            create = 2;
-
-            switch (id) {
-                case  53:
-                case 134:
-                case 135:
-                case 136: red = 133; green =  94; blue =  62; break;
-                case  67: red =  71; green =  71; blue =  71; break;
-                case 108: red = 121; green =  67; blue =  53; break;
-                case 109: red = 161; green = 161; blue = 161; break;
-                case 114: red =  45; green =  22; blue =  26; break;
-                case 128: red = 209; green = 202; blue = 156; break;
-                case 156: red = 195; green = 192; blue = 185; break;
-                default:
-                    create = 0;
-                    break;
-            }
-            break;
-        case  54:
-        case  95:
-        case 146: red = 155; green = 105; blue =  32; break;
-        case  57: red = 145; green = 219; blue = 215; break;
-        case  79: red = 142; green = 162; blue = 195; break;
-        case  80: red = 255; green = 255; blue = 255; break;
-        case  81: red =   8; green =  64; blue =  15; break;
-        case  82: red = 150; green = 155; blue = 166; break;
-        case  86:
-        case  91: red = 179; green = 108; blue =  17; break;
-        case  87:
-        case 153: red =  91; green =  31; blue =  30; break;
-        case  88: red =  68; green =  49; blue =  38; break;
-        case  89: red = 180; green = 134; blue =  65; break;
-        case 103: red = 141; green = 143; blue =  36; break;
-        case 110: red = 103; green =  92; blue =  95; break;
-        case 112: red =  45; green =  22; blue =  26; break;
-        case 121: red = 183; green = 178; blue = 129; break;
-        case 123: red = 101; green =  59; blue =  31; break;
-        case 124: red = 213; green = 178; blue = 123; break;
-        case 130: red =  38; green =  54; blue =  56; break;
-        case 133: red =  53; green =  84; blue =  85; break;
-        case 152: red = 131; green =  22; blue =   7; break;
-        case 155: red = 195; green = 192; blue = 185; break;
-        case 159: red = 195; green = 165; blue = 150; break;
-        case 170: red = 168; green = 139; blue =  15; break;
-        case 172: red = 140; green =  86; blue =  61; break;
-        case 173: red =   9; green =   9; blue =   9; break;
-        default:
-            create = 0;
-            break;
-    }
-}
\ No newline at end of file
+void VoxelTree::cancelImport() {
+    _stopImport = true;
+}
diff --git a/libraries/voxels/src/VoxelTree.h b/libraries/voxels/src/VoxelTree.h
index f27543caa8..7bdfcc68af 100644
--- a/libraries/voxels/src/VoxelTree.h
+++ b/libraries/voxels/src/VoxelTree.h
@@ -19,6 +19,8 @@
 #include "VoxelNodeBag.h"
 #include "VoxelSceneStats.h"
 
+#include <QObject>
+
 // Callback function, for recuseTreeWithOperation
 typedef bool (*RecurseVoxelTreeOperation)(VoxelNode* node, void* extraData);
 typedef enum {GRADIENT, RANDOM, NATURAL} creationMode;
@@ -112,7 +114,8 @@ public:
     {}
 };
 
-class VoxelTree {
+class VoxelTree : public QObject {
+    Q_OBJECT
 public:
     // when a voxel is created in the tree (object new'd)
     long voxelsCreated;
@@ -172,9 +175,8 @@ public:
     void writeToSVOFile(const char* filename, VoxelNode* node = NULL) const;
     bool readFromSVOFile(const char* filename);
     // reads voxels from square image with alpha as a Y-axis
-    bool readFromSquareARGB32Pixels(const uint32_t* pixels, int dimension);
+    bool readFromSquareARGB32Pixels(const char *filename);
     bool readFromSchematicFile(const char* filename);
-    void computeBlockColor(int id, int data, int& r, int& g, int& b, int& create);
 
     unsigned long getVoxelCount();
 
@@ -192,6 +194,13 @@ public:
                                                             RecurseVoxelTreeOperation operation, 
                                                             const glm::vec3& point, void* extraData);
 
+signals:
+    void importSize(float x, float y, float z);
+    void importProgress(int progress); // emit an int between 0 and 100 reflecting the progress of the import
+
+public slots:
+    void cancelImport();
+
 
 private:
     void deleteVoxelCodeFromTreeRecursion(VoxelNode* node, void* extraData);
@@ -209,6 +218,7 @@ private:
     bool _isDirty;
     unsigned long int _nodesChangedFromBitstream;
     bool _shouldReaverage;
+    bool _stopImport;
 };
 
 float boundaryDistanceForRenderLevel(unsigned int renderLevel);