chiark / gitweb /
Fix loading of GCode.
[cura.git] / Cura / gui / util / engineResultView.py
index f354088eb5a3259c4c256e44d95ef403e694389b..11bd5f0c9a08aa0d51fbc503fc8a801cdc0a09c9 100644 (file)
@@ -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()