Fix loading of GCode.

diff --git a/Cura/gui/sceneView.py b/Cura/gui/sceneView.py
index f2be8bf4ee59a16f1f08b5ecee2c8c51ad88e54b..4b6d7dc89f04c8d2a4e07983b5795399b045788b 100644 (file)
--- a/Cura/gui/sceneView.py
+++ b/Cura/gui/sceneView.py
@@ -126,6 +126,8 @@ class SceneView(openglGui.glGuiPanel):
                self._engine._result = sliceEngine.EngineResult()
                with open(filename, "r") as f:
                        self._engine._result.setGCode(f.read())
+               self._engine._result.setFinished(True)
+               self._engineResultView.setResult(self._engine._result)
                self.printButton.setBottomText('')
                self.viewSelection.setValue(4)
                self.printButton.setDisabled(False)
@@ -471,6 +473,7 @@ class SceneView(openglGui.glGuiPanel):
                while len(self._scene.objects()) > 0:
                        self._deleteObject(self._scene.objects()[0])
                self._animView = openglGui.animation(self, self._viewTarget.copy(), numpy.array([0,0,0], numpy.float32), 0.5)
+               self._engineResultView.setResult(None)
 
        def OnMultiply(self, e):
                if self._focusObj is None:

diff --git a/Cura/gui/util/engineResultView.py b/Cura/gui/util/engineResultView.py
index f354088eb5a3259c4c256e44d95ef403e694389b..11bd5f0c9a08aa0d51fbc503fc8a801cdc0a09c9 100644 (file)
--- a/Cura/gui/util/engineResultView.py
+++ b/Cura/gui/util/engineResultView.py
@@ -57,10 +57,12 @@ class engineResultView(object):
                        return
 
                result = self._result
-               if result is not None and result._polygons is not None:
-                       self.layerSelect.setRange(1, len(result._polygons))
                if result is not None:
                        gcodeLayers = result.getGCodeLayers(self._gcodeLoadCallback)
+                       if result._polygons is not None and len(result._polygons) > 0:
+                               self.layerSelect.setRange(1, len(result._polygons))
+                       elif gcodeLayers is not None and len(gcodeLayers) > 0:
+                               self.layerSelect.setRange(1, len(gcodeLayers))
                else:
                        gcodeLayers = None
 
@@ -71,7 +73,7 @@ class engineResultView(object):
                glLineWidth(2)
 
                layerNr = self.layerSelect.getValue()
-               if layerNr == self.layerSelect.getMaxValue() and result is not None:
+               if layerNr == self.layerSelect.getMaxValue() and result is not None and len(result._polygons) > 0:
                        layerNr = max(layerNr, len(result._polygons))
                viewZ = (layerNr - 1) * profile.getProfileSettingFloat('layer_height') + profile.getProfileSettingFloat('bottom_thickness')
                self._parent._viewTarget[2] = viewZ
@@ -88,56 +90,57 @@ class engineResultView(object):
                ]
                n = layerNr - 1
                generatedVBO = False
-               while n >= 0:
-                       if layerNr - n > 30 and n % 20 == 0:
-                               idx = n / 20
-                               while len(self._layer20VBOs) < idx + 1:
-                                       self._layer20VBOs.append({})
-                               if result is not None and result._polygons is not None and n + 20 < len(result._polygons):
-                                       layerVBOs = self._layer20VBOs[idx]
-                                       for typeName, typeNameGCode, color in lineTypeList:
-                                               if (typeName in result._polygons[n + 19]) or (typeName == 'skirt' and typeName in result._polygons[n]):
-                                                       if typeName not in layerVBOs:
-                                                               if generatedVBO:
-                                                                       continue
-                                                               polygons = []
-                                                               for i in xrange(0, 20):
-                                                                       if typeName in result._polygons[n + i]:
-                                                                               polygons += result._polygons[n + i][typeName]
-                                                               layerVBOs[typeName] = self._polygonsToVBO_lines(polygons)
-                                                               generatedVBO = True
-                                                       glColor4f(color[0]*0.5,color[1]*0.5,color[2]*0.5,color[3])
-                                                       layerVBOs[typeName].render()
-                               n -= 20
-                       else:
-                               c = 1.0 - ((layerNr - n) - 1) * 0.05
-                               c = max(0.5, c)
-                               while len(self._layerVBOs) < n + 1:
-                                       self._layerVBOs.append({})
-                               layerVBOs = self._layerVBOs[n]
-                               if gcodeLayers is not None and layerNr - 10 < n < (len(gcodeLayers) - 1):
-                                       for typeNamePolygons, typeName, color in lineTypeList:
-                                               if typeName is None:
-                                                       continue
-                                               if 'GCODE-' + typeName not in layerVBOs:
-                                                       layerVBOs['GCODE-' + typeName] = self._gcodeToVBO_quads(gcodeLayers[n+1:n+2], typeName)
-                                               glColor4f(color[0]*c,color[1]*c,color[2]*c,color[3])
-                                               layerVBOs['GCODE-' + typeName].render()
-
-                                       if n == layerNr - 1:
-                                               if 'GCODE-MOVE' not in layerVBOs:
-                                                       layerVBOs['GCODE-MOVE'] = self._gcodeToVBO_lines(gcodeLayers[n+1:n+2])
-                                               glColor4f(0,0,c,1)
-                                               layerVBOs['GCODE-MOVE'].render()
-                               elif result is not None and result._polygons is not None and n < len(result._polygons):
-                                       polygons = result._polygons[n]
-                                       for typeName, typeNameGCode, color in lineTypeList:
-                                               if typeName in polygons:
-                                                       if typeName not in layerVBOs:
-                                                               layerVBOs[typeName] = self._polygonsToVBO_lines(polygons[typeName])
+               if result is not None:
+                       while n >= 0:
+                               if layerNr - n > 30 and n % 20 == 0 and len(result._polygons) > 0:
+                                       idx = n / 20
+                                       while len(self._layer20VBOs) < idx + 1:
+                                               self._layer20VBOs.append({})
+                                       if result._polygons is not None and n + 20 < len(result._polygons):
+                                               layerVBOs = self._layer20VBOs[idx]
+                                               for typeName, typeNameGCode, color in lineTypeList:
+                                                       if (typeName in result._polygons[n + 19]) or (typeName == 'skirt' and typeName in result._polygons[n]):
+                                                               if typeName not in layerVBOs:
+                                                                       if generatedVBO:
+                                                                               continue
+                                                                       polygons = []
+                                                                       for i in xrange(0, 20):
+                                                                               if typeName in result._polygons[n + i]:
+                                                                                       polygons += result._polygons[n + i][typeName]
+                                                                       layerVBOs[typeName] = self._polygonsToVBO_lines(polygons)
+                                                                       generatedVBO = True
+                                                               glColor4f(color[0]*0.5,color[1]*0.5,color[2]*0.5,color[3])
+                                                               layerVBOs[typeName].render()
+                                       n -= 20
+                               else:
+                                       c = 1.0 - ((layerNr - n) - 1) * 0.05
+                                       c = max(0.5, c)
+                                       while len(self._layerVBOs) < n + 1:
+                                               self._layerVBOs.append({})
+                                       layerVBOs = self._layerVBOs[n]
+                                       if gcodeLayers is not None and ((layerNr - 10 < n < (len(gcodeLayers) - 1)) or len(result._polygons) < 1):
+                                               for typeNamePolygons, typeName, color in lineTypeList:
+                                                       if typeName is None:
+                                                               continue
+                                                       if 'GCODE-' + typeName not in layerVBOs:
+                                                               layerVBOs['GCODE-' + typeName] = self._gcodeToVBO_quads(gcodeLayers[n+1:n+2], typeName)
                                                        glColor4f(color[0]*c,color[1]*c,color[2]*c,color[3])
-                                                       layerVBOs[typeName].render()
-                               n -= 1
+                                                       layerVBOs['GCODE-' + typeName].render()
+
+                                               if n == layerNr - 1:
+                                                       if 'GCODE-MOVE' not in layerVBOs:
+                                                               layerVBOs['GCODE-MOVE'] = self._gcodeToVBO_lines(gcodeLayers[n+1:n+2])
+                                                       glColor4f(0,0,c,1)
+                                                       layerVBOs['GCODE-MOVE'].render()
+                                       elif n < len(result._polygons):
+                                               polygons = result._polygons[n]
+                                               for typeName, typeNameGCode, color in lineTypeList:
+                                                       if typeName in polygons:
+                                                               if typeName not in layerVBOs:
+                                                                       layerVBOs[typeName] = self._polygonsToVBO_lines(polygons[typeName])
+                                                               glColor4f(color[0]*c,color[1]*c,color[2]*c,color[3])
+                                                               layerVBOs[typeName].render()
+                                       n -= 1
                glPopMatrix()
                if generatedVBO:
                        self._parent._queueRefresh()

diff --git a/Cura/util/sliceEngine.py b/Cura/util/sliceEngine.py
index 66e2fcc4b753839488afda69febb7100f9cf300f..2d06bb21cf9b7ff3cac8cc7cb0cf9b1e9a6f6d78 100644 (file)
--- a/Cura/util/sliceEngine.py
+++ b/Cura/util/sliceEngine.py
@@ -80,6 +80,8 @@ class EngineResult(object):
                return None
 
        def getPrintTime(self):
+               if self._printTimeSeconds is None:
+                       return ''
                if int(self._printTimeSeconds / 60 / 60) < 1:
                        return '%d minutes' % (int(self._printTimeSeconds / 60) % 60)
                if int(self._printTimeSeconds / 60 / 60) == 1: