basis.setToVector3( basis * unbuckling )
-class DistanceIndex:
+class DistanceIndex(object):
'A class to hold the distance and the index of the loop.'
def __init__(self, distance, index):
'Initialize.'
return '%s, %s' % (self.distance, self.index)
-class Endpoint:
+class Endpoint(object):
'The endpoint of a segment.'
def __repr__(self):
'Get the string representation of this Endpoint.'
return self
-class LoopLayer:
+class LoopLayer(object):
'Loops with a z.'
def __init__(self, z):
'Initialize.'
return '%s, %s' % (self.z, self.loops)
-class NestedRing:
+class NestedRing(object):
'A nested ring.'
def __init__(self):
'Initialize.'
self.infillPaths = getTransferredPaths(paths, self.boundary)
-class PathZ:
+class PathZ(object):
'Complex path with a z.'
def __init__( self, z ):
self.path = []
return '%s, %s' % ( self.z, self.path )
-class ProjectiveSpace:
+class ProjectiveSpace(object):
'Class to define a projective space.'
def __init__( self, basisX = Vector3(1.0, 0.0, 0.0), basisY = Vector3( 0.0, 1.0, 0.0 ), basisZ = Vector3(0.0, 0.0, 1.0) ):
'Initialize the basis vectors.'
unbuckleBasis( self.basisY, maximumUnbuckling, normal )
-class XIntersectionIndex:
+class XIntersectionIndex(object):
'A class to hold the x intersection position and the index of the loop which intersected.'
def __init__( self, index, x ):
'Initialize.'
print('Open office writer can then be started from the command line with the command "soffice -writer".')
-class InterpretRepository:
+class InterpretRepository(object):
"A class to handle the interpret settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
pass
-class SampleTableEntry:
+class SampleTableEntry(object):
"Sample table entry."
def __init__( self, file ):
"Read in the sampling table section. It contains a table length (byte) and the table entries."
return '%s, %s, %s' % ( self.min_z_level, self.layer_thickness, self.beam_comp )
-class SLCCarving:
+class SLCCarving(object):
"An slc carving."
def __init__(self):
"Add empty lists."
return carving
-class SVGCarving:
+class SVGCarving(object):
'An svg carving.'
def __init__(self):
'Add empty lists.'
return False
-class BoundingRectangle:
+class BoundingRectangle(object):
'A class to get the corners of a gcode text.'
def getFromGcodeLines(self, lines, radius):
'Parse gcode text and get the minimum and maximum corners.'
self.oldLocation = location
-class DistanceFeedRate:
+class DistanceFeedRate(object):
'A class to limit the z feed rate and round values.'
def __init__(self):
'Initialize.'
solid.processElementNodeByGeometry(elementNode, getGeometryOutput(None, elementNode))
-class DrillDerivation:
+class DrillDerivation(object):
"Class to hold drill variables."
def __init__(self, elementNode):
'Set defaults.'
path.convertElementNode(elementNode, getGeometryOutput(None, elementNode))
-class SVGDerivation:
+class SVGDerivation(object):
"Class to hold svg variables."
def __init__(self, elementNode):
'Set defaults.'
path.convertElementNode(elementNode, getGeometryOutput(None, elementNode))
-class CircleDerivation:
+class CircleDerivation(object):
"Class to hold circle variables."
def __init__(self, elementNode):
'Set defaults.'
path.convertElementNode(elementNode, getGeometryOutput(None, elementNode))
-class ConcatenateDerivation:
+class ConcatenateDerivation(object):
'Class to hold concatenate variables.'
def __init__(self, elementNode):
'Initialize.'
offset.setToVector3(offset + delta)
-class ExtrudeDerivation:
+class ExtrudeDerivation(object):
'Class to hold extrude variables.'
def __init__(self, elementNode):
'Initialize.'
insertTwistPortions(self, elementNode)
-class Interpolation:
+class Interpolation(object):
'Class to interpolate a path.'
def __init__(self):
'Set index.'
self.endVertex = self.path[ self.interpolationIndex + 1 ]
-class PortionDirection:
+class PortionDirection(object):
'Class to hold a portion and direction.'
def __init__( self, portion ):
'Initialize.'
solid.processElementNodeByGeometry(elementNode, geometryOutput)
-class GearDerivation:
+class GearDerivation(object):
"Class to hold gear variables."
def __init__(self, elementNode):
'Set defaults.'
path.convertElementNode(elementNode, getGeometryOutput(elementNode))
-class GridDerivation:
+class GridDerivation(object):
'Class to hold grid variables.'
def __init__(self, elementNode):
'Set defaults.'
solid.processElementNodeByGeometry(elementNode, getGeometryOutput(elementNode))
-class HeightmapDerivation:
+class HeightmapDerivation(object):
'Class to hold heightmap variables.'
def __init__(self, elementNode):
'Set defaults.'
solid.processElementNodeByGeometry(elementNode, getGeometryOutput(None, elementNode))
-class LatheDerivation:
+class LatheDerivation(object):
"Class to hold lathe variables."
def __init__(self, elementNode):
'Set defaults.'
path.convertElementNode(elementNode, getGeometryOutput(None, elementNode))
-class LineDerivation:
+class LineDerivation(object):
"Class to hold line variables."
def __init__(self, elementNode):
'Set defaults.'
solid.processElementNodeByGeometry(elementNode, getGeometryOutput(elementNode))
-class LinearBearingCageDerivation:
+class LinearBearingCageDerivation(object):
'Class to hold linear bearing cage variables.'
def __init__(self, elementNode):
'Set defaults.'
elementNode.attributes['closed'] = str(closedBoolean).lower()
-class LineationDerivation:
+class LineationDerivation(object):
'Class to hold lineation variables.'
def __init__(self, elementNode):
'Set defaults.'
self.target = evaluate.getTransformedPathsByKey([], elementNode, 'target')
-class SideLoop:
+class SideLoop(object):
'Class to handle loop, side angle and side length.'
def __init__(self, loop, sideAngle=None, sideLength=None):
'Initialize.'
self.loop.reverse()
-class Spiral:
+class Spiral(object):
'Class to add a spiral.'
def __init__(self, spiral, stepRatio):
'Initialize.'
solid.processElementNodeByGeometry(elementNode, getGeometryOutput(elementNode))
-class CellExistence:
+class CellExistence(object):
'Class to determine if a cell exists.'
def __init__(self, columns, rows, value):
'Initialize.'
return (columnIndex, rowIndex) in self.existenceSet
-class HollowPegSocket:
+class HollowPegSocket(object):
'Class to hold hollow peg socket variables.'
def __init__(self, center):
'Initialize.'
return euclidean.getDictionaryString(self.__dict__)
-class MechaslabDerivation:
+class MechaslabDerivation(object):
'Class to hold mechaslab variables.'
def __init__(self, elementNode):
'Set defaults.'
derivation.topOverBottom = cylinder.getTopOverBottom(math.radians(angleDegrees), endZ, complex(radius, radius), startZ)
-class PegDerivation:
+class PegDerivation(object):
'Class to hold peg variables.'
def __init__(self, elementNode):
'Set defaults.'
path.convertElementNode(elementNode, getGeometryOutput(None, elementNode))
-class PolygonDerivation:
+class PolygonDerivation(object):
"Class to hold polygon variables."
def __init__(self, elementNode):
'Set defaults.'
path.convertElementNode(elementNode, getGeometryOutput(None, elementNode))
-class ShaftDerivation:
+class ShaftDerivation(object):
"Class to hold shaft variables."
def __init__(self, elementNode):
'Set defaults.'
target.getXMLProcessor().convertElementNode(target, geometryOutput)
-class SolidDerivation:
+class SolidDerivation(object):
'Class to hold solid variables.'
def __init__(self, elementNode):
'Set defaults.'
path.convertElementNode(elementNode, getGeometryOutput(None, elementNode))
-class SpongeCircle:
+class SpongeCircle(object):
"Class to hold sponge circle."
def __init__(self, center, radius=0.0):
'Initialize.'
self.radius = greatestRadius
-class SpongeSliceDerivation:
+class SpongeSliceDerivation(object):
"Class to hold sponge slice variables."
def __init__(self, elementNode):
'Initialize.'
path.convertElementNode(elementNode, getGeometryOutput(None, elementNode))
-class SquareDerivation:
+class SquareDerivation(object):
"Class to hold square variables."
def __init__(self, elementNode):
'Set defaults.'
path.convertElementNode(elementNode, getGeometryOutput(None, elementNode))
-class TeardropDerivation:
+class TeardropDerivation(object):
"Class to hold teardrop variables."
def __init__(self, elementNode):
'Set defaults.'
path.convertElementNode(elementNode, getGeometryOutput(None, elementNode))
-class TextDerivation:
+class TextDerivation(object):
"Class to hold text variables."
def __init__(self, elementNode):
'Set defaults.'
evaluate.processArchivable( Dictionary, elementNode)
-class Dictionary:
+class Dictionary(object):
'A dictionary object.'
def __init__(self):
'Add empty lists.'
elementNode.parentNode.xmlObject.faces.append(face)
-class Edge:
+class Edge(object):
"An edge of a triangle mesh."
def __init__(self):
"Set the face indexes to None."
return self
-class Face:
+class Face(object):
"A face of a triangle mesh."
def __init__(self):
"Initialize."
return dictionary.getAllTransformedPaths([], self)
-class SVGFabricationCarving:
+class SVGFabricationCarving(object):
'An svg carving.'
def __init__(self, addLayerTemplate, elementNode):
'Add empty lists.'
return min(archivableMinimumZ, geometryMinimumZ)
-class BooleanGeometry:
+class BooleanGeometry(object):
'A boolean geometry scene.'
def __init__(self):
'Add empty lists.'
elementNode.xmlObject = KeyValue()
-class BaseFunction:
+class BaseFunction(object):
'Class to get equation results.'
def __init__(self, elementNode):
'Initialize.'
return self.returnValue
-class ClassObject:
+class ClassObject(object):
'Class to hold class attributes and functions.'
def __init__(self, elementNode):
'Initialize.'
self.selfDictionary[attributeName] = value
-class EmptyObject:
+class EmptyObject(object):
'An empty object.'
def __init__(self):
'Do nothing.'
pass
-class Evaluator:
+class Evaluator(object):
'Base evaluator class.'
def __init__(self, elementNode, word):
'Set value to none.'
return self.returnValue
-class FunctionVariable:
+class FunctionVariable(object):
'Class to hold class functions and variable set.'
def __init__(self, elementNode):
'Initialize.'
self.processStatement(childNode)
-class KeyValue:
+class KeyValue(object):
'Class to hold a key value.'
def __init__(self, key=None, value=None):
'Get key value.'
return self.getByCharacter('=', line )
-class ModuleElementNode:
+class ModuleElementNode(object):
'Class to get the in attribute, the index name and the value name.'
def __init__( self, elementNode):
'Initialize.'
return Creation(elementNode, pluginModule).getCreation
-class Creation:
+class Creation(object):
'Class to handle a creation.'
def __init__(self, elementNode, pluginModule):
'Initialize.'
return None
-class Document:
+class Document(object):
'Class to handle elementNodes in a document.'
def __init__(self, elementNode):
'Initialize.'
return math.radians(getTwistPrecision(elementNode))
-class Setting:
+class Setting(object):
'Class to get handle elementNodes in a setting.'
def __init__(self, elementNode):
'Initialize.'
return None
-class DictionaryAttribute:
+class DictionaryAttribute(object):
'Class to handle a dictionary.'
def __init__(self, dictionaryObject):
'Initialize.'
return None
-class ListAttribute:
+class ListAttribute(object):
'Class to handle a list.'
def __init__(self, listObject):
'Initialize.'
return None
-class StringAttribute:
+class StringAttribute(object):
'Class to handle a string.'
def __init__(self, stringObject):
'Initialize.'
return Vector3Index(index, x, y, z)
-class NestedVectorTestExample:
+class NestedVectorTestExample(object):
'Class to test local attribute.'
def __init__(self, vector3):
'Get the accessible attribute.'
transformVector3Blindly(tetragrid, vector3)
-class Matrix:
+class Matrix(object):
'A four by four matrix.'
def __init__(self, tetragrid=None):
'Add empty lists.'
point.z *= scaleVector3.z
-class ScaleDerivation:
+class ScaleDerivation(object):
"Class to hold scale variables."
def __init__(self, elementNode):
'Set defaults.'
matrix.transformVector3sByMatrix(derivation.rotateTetragrid, points)
-class RotateDerivation:
+class RotateDerivation(object):
"Class to hold rotate variables."
def __init__(self, elementNode, prefix):
'Set defaults.'
matrix.transformVector3sByMatrix(derivation.transformTetragrid, points)
-class TransformDerivation:
+class TransformDerivation(object):
"Class to hold transform variables."
def __init__(self, elementNode, prefix):
'Set defaults.'
euclidean.translateVector3Path(points, translateVector3)
-class TranslateDerivation:
+class TranslateDerivation(object):
"Class to hold translate variables."
def __init__(self, elementNode):
'Set defaults.'
elementNode.getXMLProcessor().processElementNode(elementNode)
-class ArrayDerivation:
+class ArrayDerivation(object):
"Class to hold array variables."
def __init__(self, elementNode):
'Set defaults.'
path.convertElementNode(pathElement, vector3Loops)
-class CarveDerivation:
+class CarveDerivation(object):
"Class to hold carve variables."
def __init__(self, elementNode):
'Set defaults.'
elementNode.getXMLProcessor().convertElementNode(elementNode, geometryOutput)
-class CopyDerivation:
+class CopyDerivation(object):
"Class to hold copy variables."
def __init__(self, elementNode):
'Set defaults.'
difference.processElementNode(differenceElement)
-class DisjoinDerivation:
+class DisjoinDerivation(object):
"Class to hold disjoin variables."
def __init__(self, elementNode):
'Set defaults.'
evaluate.processArchivable(group.Group, elementNode)
-class ImportDerivation:
+class ImportDerivation(object):
"Class to hold import variables."
def __init__(self, elementNode):
'Set defaults.'
archive.writeFileText(absoluteFileName, xmlObject.getFabricationText(derivation.addLayerTemplate))
-class WriteDerivation:
+class WriteDerivation(object):
"Class to hold write variables."
def __init__(self, elementNode):
'Set defaults.'
lineation.processElementNodeByFunction(elementNode, getManipulatedPaths)
-class BevelDerivation:
+class BevelDerivation(object):
"Class to hold bevel variables."
def __init__(self, elementNode, prefix, sideLength):
'Set defaults.'
lineation.processElementNodeByFunction(elementNode, getManipulatedPaths)
-class OutlineDerivation:
+class OutlineDerivation(object):
"Class to hold outline variables."
def __init__(self, elementNode, prefix, sideLength):
'Set defaults.'
lineation.processElementNodeByFunction(elementNode, getManipulatedPaths)
-class AlongAway:
+class AlongAway(object):
"Class to derive the path along the point and away from the point."
def __init__( self, loop, overhangPlaneAngle ):
"Initialize."
return self.getIsPointSupportedBySegment( self.pointIndex + 1 )
-class OverhangClockwise:
+class OverhangClockwise(object):
"Class to get the intersection up from the point."
def __init__( self, alongAway ):
"Initialize."
self.alongAway.loop[ unsupportedBeginIndex : endIndex ] = supportPoints
-class OverhangDerivation:
+class OverhangDerivation(object):
"Class to hold overhang variables."
def __init__(self, elementNode, prefix):
'Set defaults.'
self.overhangInclinationRadians = math.radians(evaluate.getEvaluatedFloat(0.0, elementNode, prefix + 'inclination'))
-class OverhangWiddershinsLeft:
+class OverhangWiddershinsLeft(object):
"Class to get the intersection from the point down to the left."
def __init__( self, alongAway ):
"Initialize."
lineation.processElementNodeByFunction(elementNode, getManipulatedPaths)
-class RoundDerivation:
+class RoundDerivation(object):
"Class to hold round variables."
def __init__(self, elementNode, prefix, sideLength):
'Set defaults.'
lineation.processElementNodeByFunction(elementNode, getManipulatedPaths)
-class SegmentDerivation:
+class SegmentDerivation(object):
"Class to hold segment variables."
def __init__(self, elementNode, prefix):
'Set defaults.'
self.path = evaluate.getPathByPrefix(elementNode, getSegmentPathDefault(), prefix)
-class StartEnd:
+class StartEnd(object):
'Class to get a start through end range.'
def __init__(self, elementNode, modulo, prefix):
"Initialize."
lineation.processElementNodeByFunction(elementNode, getManipulatedPaths)
-class WedgeDerivation:
+class WedgeDerivation(object):
"Class to hold wedge variables."
def __init__(self, elementNode, prefix):
'Set defaults.'
bottomElementNode(derivation, target)
-class BottomDerivation:
+class BottomDerivation(object):
"Class to hold bottom variables."
def __init__(self, elementNode, prefix):
'Set defaults.'
solid.processElementNodeByFunctionPair(elementNode, getManipulatedGeometryOutput, getManipulatedPaths)
-class InsetDerivation:
+class InsetDerivation(object):
"Class to hold inset variables."
def __init__(self, elementNode, prefix):
'Set defaults.'
solid.processElementNodeByFunctionPair(elementNode, getManipulatedGeometryOutput, getManipulatedPaths)
-class OutsetDerivation:
+class OutsetDerivation(object):
"Class to hold outset variables."
def __init__(self, elementNode, prefix):
'Set defaults.'
return EquationDerivation(elementNode, prefix)
-class EquationDerivation:
+class EquationDerivation(object):
"Class to hold equation variables."
def __init__(self, elementNode, prefix):
'Set defaults.'
self.equationResults.append(EquationResult(elementNode, equationFunction, prefixedEquationName))
-class EquationResult:
+class EquationResult(object):
"Class to get equation results."
def __init__(self, elementNode, equationFunction, key):
"Initialize."
solid.processElementNodeByFunctionPair(elementNode, getManipulatedGeometryOutput, getManipulatedPaths)
-class FlipDerivation:
+class FlipDerivation(object):
"Class to hold flip variables."
def __init__(self, elementNode, prefix):
'Set defaults.'
solid.processArchiveRemoveSolid(elementNode, self.getGeometryOutput())
-class CubeDerivation:
+class CubeDerivation(object):
"Class to hold cube variables."
def __init__(self, elementNode):
'Set defaults.'
solid.processArchiveRemoveSolid(elementNode, self.getGeometryOutput())
-class CylinderDerivation:
+class CylinderDerivation(object):
"Class to hold cylinder variables."
def __init__(self, elementNode):
'Set defaults.'
solid.processArchiveRemoveSolid(elementNode, self.getGeometryOutput())
-class SphereDerivation:
+class SphereDerivation(object):
"Class to hold sphere variables."
def __init__(self, elementNode):
'Set defaults.'
loops.sort(key=euclidean.getAreaLoopAbsolute, reverse=isDescending)
-class EdgePair:
+class EdgePair(object):
def __init__(self):
'Pair of edges on a face.'
self.edgeIndexes = []
return self
-class FaceGenerator:
+class FaceGenerator(object):
'A face generator.'
def __init__(self, faces, indexedLoopBottom, indexedLoopTop):
'Initialize.'
face.setEdgeIndexesToVertexIndexes( self.edges, edgeTable )
-class ZoneArrangement:
+class ZoneArrangement(object):
'A zone arrangement.'
def __init__(self, layerHeight, vertexes):
'Initialize the zone interval and the zZone table.'
processChildNodesByIndexValue( elementNode, function, inKey, elementNode.xmlObject, inValue[ inKey ] )
-class IndexValue:
+class IndexValue(object):
"Class to get the in attribute, the index name and the value name."
def __init__(self, elementNode):
"Initialize."
return
-class BoundingLoop:
+class BoundingLoop(object):
'A class to hold a bounding loop composed of a minimum complex, a maximum complex and an outset loop.'
def __eq__(self, other):
'Determine whether this bounding loop is identical to other one.'
return self.minimum.imag > anotherBoundingLoop.maximum.imag or self.minimum.real > anotherBoundingLoop.maximum.real
-class CenterOutset:
+class CenterOutset(object):
'A class to hold a center and an outset.'
def __init__(self, center, outset):
'Set the center and outset.'
return '%s\n%s' % (self.center, self.outset)
-class CircleIntersection:
+class CircleIntersection(object):
'An intersection of two complex circles.'
def __init__( self, circleNodeAhead, index, circleNodeBehind ):
self.aheadMinusBehind = 0.5 * ( circleNodeAhead.dividedPoint - circleNodeBehind.dividedPoint )
return False
-class CircleNode:
+class CircleNode(object):
'A complex node of complex circle intersections.'
def __init__(self, oneOverRadius, point):
self.actualPoint = point
## Configuration settings classes ##
####################################
-class GeneralSetting:
+class GeneralSetting(object):
"Just a basic setting subclass"
def getFromValue( self, name, repository, value ):
#print('GeneralSetting:', name, repository, value )
def setValueToString(self, value):
self.value = str(value) == "True"
-class LatentStringVar:
+class LatentStringVar(object):
"This is actually used as 'group' object for Radio buttons. (Did I mention the code is a mess?)"
"This class doesn't have a name, and isn't really used for anything. It doesn't even know which repository it belongs to"
repository.preferences.append(self)
return self
-class FileNameInput(StringSetting ):
+class FileNameInput(StringSetting):
"A class to display, read & write a fileName."
def getFromFileName( self, fileTypes, name, repository, value ):
#print('FileNameInput:getFromFileName:', self, fileTypes, name, repository, value )
self.value = value
return self
-class HelpPage:
+class HelpPage(object):
"A class to open a help page."
def getOpenFromAbsolute( self, hypertextAddress ):
return self
-class MenuButtonDisplay:
+class MenuButtonDisplay(object):
"A class to add a combo box selection."
def getFromName( self, name, repository ):
#print('MenuButtonDisplay->getFromName:', name, repository )
menuButtonDisplay.addRadio(self, value)
return self
-class LabelDisplay:
+class LabelDisplay(object):
"A class to add a label."
def getFromName( self, name, repository ):
"Initialize."
repository.preferences.append(self)
return self
-class LabelSeparator:
+class LabelSeparator(object):
"A class to add a label and menu separator."
def getFromRepository( self, repository ):
"Initialize."
# Helper classes
##########################
-class LayerCount:
+class LayerCount(object):
'A class to handle the layerIndex.'
def __init__(self):
'Initialize.'
loopLayer.loops.append(matrixSVG.getTransformedPath(translatedLoop))
-class FontReader:
+class FontReader(object):
"Class to read a font in the fonts folder."
def __init__(self, fontFamily):
"Initialize."
return self.glyphDictionary[character]
-class Glyph:
+class Glyph(object):
"Class to handle a glyph."
def __init__(self, elementNode, unitsPerEM, yAxisPointingUpward):
"Initialize."
return sizedLoops
-class MatrixSVG:
+class MatrixSVG(object):
"Two by three svg matrix."
def __init__(self, tricomplex=None):
"Initialize."
return transformedPaths
-class PathReader:
+class PathReader(object):
"Class to read svg path."
def __init__(self, elementNode, loops, yAxisPointingUpward):
"Add to path string to loops."
self.processPathWordZ()
-class SVGReader:
+class SVGReader(object):
"An svg carving."
def __init__(self):
"Add empty lists."
cornerMinimum.z -= halfLayerThickness
-class SVGWriter:
+class SVGWriter(object):
'A base class to get an svg skein from a carving.'
def __init__(self,
addLayerTemplateToSVG,
return ''
-class CDATASectionMonad:
+class CDATASectionMonad(object):
'A monad to handle a CDATASection node.'
def __init__(self, input, parentNode):
'Initialize.'
return self
-class CDATASectionNode:
+class CDATASectionNode(object):
'A CDATASection node.'
def __init__(self, parentNode, textContent=''):
'Initialize.'
nodeType = property(getNodeType)
-class DocumentNode:
+class DocumentNode(object):
'A class to parse an xml text and store the elements.'
def __init__(self, fileName, xmlText):
'Initialize.'
nodeType = property(getNodeType)
-class ElementEndMonad:
+class ElementEndMonad(object):
'A monad to look for the end of an ElementNode tag.'
def __init__(self, parentNode):
'Initialize.'
return self
-class ElementLocalNameMonad:
+class ElementLocalNameMonad(object):
'A monad to set the local name of an ElementNode.'
def __init__(self, character, parentNode):
'Initialize.'
self.elementNode.localName = self.input.getvalue().lower().strip()
-class ElementNode:
+class ElementNode(object):
'An xml element.'
def __init__(self, parentNode=None):
'Initialize.'
textContent = property(getTextContent)
-class ElementReadMonad:
+class ElementReadMonad(object):
'A monad to read the attributes of the ElementNode tag.'
def __init__(self, elementNode):
'Initialize.'
return KeyMonad(character, self.elementNode)
-class KeyMonad:
+class KeyMonad(object):
'A monad to set the key of an attribute of an ElementNode.'
def __init__(self, character, elementNode):
'Initialize.'
return self
-class TextMonad:
+class TextMonad(object):
'A monad to handle the open tag character and set the text.'
def __init__(self, parentNode):
'Initialize.'
nodeType = property(getNodeType)
-class ValueMonad:
+class ValueMonad(object):
'A monad to set the value of an attribute of an ElementNode.'
def __init__(self, elementNode, key):
'Initialize.'
return skeinforge_craft.writeOutput(fileName)
-class CraftMenuSaveListener:
+class CraftMenuSaveListener(object):
"A class to update a craft menu."
def __init__( self, menu, window ):
"Set the menu."
addToCraftMenu( self.menu )
-class CraftRadioButtonsSaveListener:
+class CraftRadioButtonsSaveListener(object):
"A class to update the craft radio buttons."
def addToDialog( self, gridPosition ):
"Add this to the dialog."
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'alteration', shouldAnalyze)
-class AlterationRepository:
+class AlterationRepository(object):
"A class to handle the alteration settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class AlterationSkein:
+class AlterationSkein(object):
"A class to alteration a skein of extrusions."
def __init__(self):
'Initialize.'
skeinforge_craft.writeSVGTextWithNounMessage(fileName, BottomRepository(), shouldAnalyze)
-class BottomRepository:
+class BottomRepository(object):
"A class to handle the bottom settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class BottomSkein:
+class BottomSkein(object):
"A class to bottom a skein of extrusions."
def getCraftedGcode(self, fileName, repository, svgText):
"Parse svgText and store the bottom svgText."
settings.openSVGPage(suffixFileName, repository.svgViewer.value)
-class CarveRepository:
+class CarveRepository(object):
"A class to handle the carve settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class CarveSkein:
+class CarveSkein(object):
"A class to carve a carving."
def getCarvedSVG(self, carving, fileName, repository):
"Parse gnu triangulated surface text and store the carved gcode."
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'chamber', shouldAnalyze)
-class ChamberRepository:
+class ChamberRepository(object):
"A class to handle the chamber settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
-class ChamberSkein:
+class ChamberSkein(object):
"A class to chamber a skein of extrusions."
def __init__(self):
'Initialize.'
settings.openSVGPage( suffixFileName, repository.svgViewer.value )
-class ChopRepository:
+class ChopRepository(object):
"A class to handle the chop settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class ChopSkein:
+class ChopSkein(object):
"A class to chop a carving."
def addExtraTopLayerIfNecessary( self, carving, layerHeight, loopLayers ):
"Add extra top layer if necessary."
settings.openSVGPage( suffixFileName, repository.svgViewer.value )
-class CleaveRepository:
+class CleaveRepository(object):
"A class to handle the cleave settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class CleaveSkein:
+class CleaveSkein(object):
"A class to cleave a carving."
def getCarvedSVG( self, carving, fileName, repository ):
"Parse gnu triangulated surface text and store the cleaved gcode."
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'clip', shouldAnalyze)
-class ClipRepository:
+class ClipRepository(object):
"A class to handle the clip settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class ClipSkein:
+class ClipSkein(object):
"A class to clip a skein of extrusions."
def __init__(self):
self.distanceFeedRate = gcodec.DistanceFeedRate()
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'coil', shouldAnalyze)
-class CoilRepository:
+class CoilRepository(object):
"A class to handle the coil settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
-class CoilSkein:
+class CoilSkein(object):
"A class to coil a skein of extrusions."
def __init__(self):
self.boundaryLayers = []
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'comb', shouldAnalyze)
-class BoundarySegment:
+class BoundarySegment(object):
'A boundary and segment.'
def __init__(self, begin):
'Initialize'
return (self.segment[0], end)
-class CombRepository:
+class CombRepository(object):
"A class to handle the comb settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class CombSkein:
+class CombSkein(object):
"A class to comb a skein of extrusions."
def __init__(self):
'Initialize'
self.distanceFeedRate.addLineCheckAlteration(line)
-class DistancePoint:
+class DistancePoint(object):
'A class to get the distance of the point along a segment inside a loop.'
def __init__(self, begin, loop, runningJumpSpace, segment):
'Initialize'
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'cool', shouldAnalyze)
-class CoolRepository:
+class CoolRepository(object):
'A class to handle the cool settings.'
def __init__(self):
'Set the default settings, execute title & settings fileName.'
writeOutput(fileName)
-class CoolSkein:
+class CoolSkein(object):
'A class to cool a skein of extrusions.'
def __init__(self):
self.boundaryLayer = None
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'dimension', shouldAnalyze)
-class DimensionRepository:
+class DimensionRepository(object):
'A class to handle the dimension settings.'
def __init__(self):
'Set the default settings, execute title & settings fileName.'
writeOutput(fileName)
-class DimensionSkein:
+class DimensionSkein(object):
'A class to dimension a skein of extrusions.'
def __init__(self):
'Initialize.'
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'drill', shouldAnalyze)
-class ThreadLayer:
+class ThreadLayer(object):
"A layer of loops and paths."
def __init__( self, z ):
"Thread layer constructor."
return '%s, %s' % ( self.z, self.points )
-class DrillRepository:
+class DrillRepository(object):
"A class to handle the drill settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class DrillSkein:
+class DrillSkein(object):
"A class to drill a skein of extrusions."
def __init__(self):
self.boundary = None
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'dwindle', shouldAnalyze)
-class DwindleRepository:
+class DwindleRepository(object):
'A class to handle the dwindle settings.'
def __init__(self):
'Set the default settings, execute title & settings fileName.'
writeOutput(fileName)
-class DwindleSkein:
+class DwindleSkein(object):
'A class to dwindle a skein of extrusions.'
def __init__(self):
'Initialize.'
self.distanceFeedRate.addLine(line)
-class ThreadSection:
+class ThreadSection(object):
'A class to handle a volumetric section of a thread.'
def __init__(self, feedRateMinute, flowRate, location, oldLocation):
'Initialize.'
return window
-class ExportRepository:
+class ExportRepository(object):
'A class to handle the export settings.'
def __init__(self):
'Set the default settings, execute title & settings fileName.'
writeOutput(fileName)
-class ExportSkein:
+class ExportSkein(object):
'A class to export a skein of extrusions.'
def __init__(self):
self.crafting = False
print('The converted file is saved as ' + archive.getSummarizedFileName(suffixFileName))
-class GcodeStepRepository:
+class GcodeStepRepository(object):
'A class to handle the export settings.'
def __init__(self):
'Set the default settings, execute title & settings fileName.'
writeOutput(fileName)
-class GcodeStepSkein:
+class GcodeStepSkein(object):
'A class to convert gcode into 16 byte binary segments.'
def __init__(self):
self.oldFeedRateString = None
print('The converted file is saved as ' + archive.getSummarizedFileName(suffixFileName) )
-class GcodeTimeSegmentRepository:
+class GcodeTimeSegmentRepository(object):
"A class to handle the export settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class GcodeTimeSegmentSkein:
+class GcodeTimeSegmentSkein(object):
"A class to convert gcode into time segments."
def __init__(self):
'Initialize.'
return text.replace('\r', '\n').split('\n')
-class GcodeSmallSkein:
+class GcodeSmallSkein(object):
"A class to remove redundant z and feed rate parameters from a skein of extrusions."
def __init__(self):
self.lastFeedRateString = None
"Feed a gcode linear move file."
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'feed', shouldAnalyze)
-
-class FeedRepository:
+class FeedRepository(object):
"A class to handle the feed settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class FeedSkein:
+class FeedSkein(object):
"A class to feed a skein of cuttings."
def __init__(self):
self.distanceFeedRate = gcodec.DistanceFeedRate()
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'fill', shouldAnalyze)
-class FillRepository:
+class FillRepository(object):
'A class to handle the fill settings.'
def __init__(self):
'Set the default settings, execute title & settings fileName.'
writeOutput(fileName)
-class FillSkein:
+class FillSkein(object):
'A class to fill a skein of extrusions.'
def __init__(self):
'Initialize.'
self.gridJunctionMiddle = halfGridMinusWidth * repository.gridJunctionSeparationOverOctogonRadiusAtMiddle.value
-class RotatedLayer:
+class RotatedLayer(object):
'A rotated layer.'
def __init__( self, z ):
'Initialize.'
return '%s, %s, %s' % ( self.z, self.rotation, self.nestedRings )
-class YIntersectionPath:
+class YIntersectionPath(object):
'A class to hold the y intersection position, the loop which it intersected and the point index of the loop which it intersected.'
def __init__( self, pathIndex, pointIndex, y ):
'Initialize from the path, point index, and y.'
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'fillet', shouldAnalyze)
-class BevelSkein:
+class BevelSkein(object):
"A class to bevel a skein of extrusions."
def __init__(self):
self.distanceFeedRate = gcodec.DistanceFeedRate()
return ' R' + ( self.distanceFeedRate.getRounded(radius) )
-class FilletRepository:
+class FilletRepository(object):
"A class to handle the fillet settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'flow', shouldAnalyze)
-class FlowRepository:
+class FlowRepository(object):
"A class to handle the flow settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class FlowSkein:
+class FlowSkein(object):
"A class to flow a skein of extrusions."
def __init__(self):
self.distanceFeedRate = gcodec.DistanceFeedRate()
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'home', shouldAnalyze)
-class HomeRepository:
+class HomeRepository(object):
"A class to handle the home settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class HomeSkein:
+class HomeSkein(object):
"A class to home a skein of extrusions."
def __init__(self):
self.distanceFeedRate = gcodec.DistanceFeedRate()
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'hop', shouldAnalyze)
-class HopRepository:
+class HopRepository(object):
"A class to handle the hop settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class HopSkein:
+class HopSkein(object):
"A class to hop a skein of extrusions."
def __init__(self):
'Initialize'
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'inset', shouldAnalyze)
-class InsetRepository:
+class InsetRepository(object):
"A class to handle the inset settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class InsetSkein:
+class InsetSkein(object):
"A class to inset a skein of extrusions."
def __init__(self):
'Initialize.'
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'jitter', shouldAnalyze)
-class JitterRepository:
+class JitterRepository(object):
'A class to handle the jitter settings.'
def __init__(self):
'Set the default settings, execute title & settings fileName.'
writeOutput(fileName)
-class JitterSkein:
+class JitterSkein(object):
'A class to jitter a skein of extrusions.'
def __init__(self):
'Initialize.'
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'joris', shouldAnalyze)
-class JorisRepository:
+class JorisRepository(object):
'A class to handle the Joris settings.'
def __init__(self):
'Set the default settings, execute title & settings fileName.'
writeOutput(fileName)
-class JorisSkein:
+class JorisSkein(object):
'A class to Joris a skein of extrusions.'
def __init__(self):
'Initialize.'
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'lash', shouldAnalyze)
-class LashRepository:
+class LashRepository(object):
"A class to handle the lash settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class LashSkein:
+class LashSkein(object):
"A class to lash a skein of extrusions."
def __init__(self):
self.distanceFeedRate = gcodec.DistanceFeedRate()
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'lift', shouldAnalyze)
-class LiftRepository:
+class LiftRepository(object):
"A class to handle the lift settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class LiftSkein:
+class LiftSkein(object):
"A class to lift a skein of extrusions."
def __init__(self):
self.distanceFeedRate = gcodec.DistanceFeedRate()
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'limit', shouldAnalyze)
-class LimitRepository:
+class LimitRepository(object):
'A class to handle the limit settings.'
def __init__(self):
'Set the default settings, execute title & settings fileName.'
writeOutput(fileName)
-class LimitSkein:
+class LimitSkein(object):
'A class to limit a skein of extrusions.'
def __init__(self):
self.distanceFeedRate = gcodec.DistanceFeedRate()
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'mill', shouldAnalyze)
-class Average:
+class Average(object):
'A class to hold values and get the average.'
def __init__(self):
self.reset()
self.total = 0.0
-class MillRepository:
+class MillRepository(object):
'A class to handle the mill settings.'
def __init__(self):
'Set the default settings, execute title & settings fileName.'
-class MillSkein:
+class MillSkein(object):
'A class to mill a skein of extrusions.'
def __init__(self):
self.aroundPixelTable = {}
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'multiply', shouldAnalyze)
-class MultiplyRepository:
+class MultiplyRepository(object):
'A class to handle the multiply settings.'
def __init__(self):
'Set the default settings, execute title & settings fileName.'
writeOutput(fileName)
-class MultiplySkein:
+class MultiplySkein(object):
'A class to multiply a skein of extrusions.'
def __init__(self):
self.distanceFeedRate = gcodec.DistanceFeedRate()
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'oozebane', shouldAnalyze)
-class OozebaneRepository:
+class OozebaneRepository(object):
"A class to handle the oozebane settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class OozebaneSkein:
+class OozebaneSkein(object):
"A class to oozebane a skein of extrusions."
def __init__(self):
self.distanceFeedRate = gcodec.DistanceFeedRate()
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'outset', shouldAnalyze)
-class OutsetRepository:
+class OutsetRepository(object):
'A class to handle the outset settings.'
def __init__(self):
'Set the default settings, execute title & settings fileName.'
writeOutput(fileName)
-class OutsetSkein:
+class OutsetSkein(object):
'A class to outset a skein of extrusions.'
def __init__(self):
self.boundary = None
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'preface', shouldAnalyze)
-class PrefaceRepository:
+class PrefaceRepository(object):
"A class to handle the preface settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class PrefaceSkein:
+class PrefaceSkein(object):
"A class to preface a skein of extrusions."
def __init__(self):
self.distanceFeedRate = gcodec.DistanceFeedRate()
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'raft', shouldAnalyze)
-class RaftRepository:
+class RaftRepository(object):
'A class to handle the raft settings.'
def __init__(self):
'Set the default settings, execute title & settings fileName.'
writeOutput(fileName)
-class RaftSkein:
+class RaftSkein(object):
'A class to raft a skein of extrusions.'
def __init__(self):
self.addLineLayerStart = True
self.supportLayers = []
-class SupportLayer:
+class SupportLayer(object):
'Support loops with segment tables.'
def __init__( self, supportLoops ):
self.supportLoops = supportLoops
skeinforge_craft.writeSVGTextWithNounMessage(fileName, ScaleRepository(), shouldAnalyze)
-class ScaleRepository:
+class ScaleRepository(object):
"A class to handle the scale settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class ScaleSkein:
+class ScaleSkein(object):
"A class to scale a skein of extrusions."
def getCraftedGcode(self, fileName, repository, svgText):
"Parse svgText and store the scale svgText."
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'skin', shouldAnalyze)
-class SkinRepository:
+class SkinRepository(object):
'A class to handle the skin settings.'
def __init__(self):
'Set the default settings, execute title & settings fileName.'
writeOutput(fileName)
-class SkinSkein:
+class SkinSkein(object):
'A class to skin a skein of extrusions.'
def __init__(self):
'Initialize.'
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'skirt', shouldAnalyze)
-class LoopCrossDictionary:
+class LoopCrossDictionary(object):
'Loop with a horizontal and vertical dictionary.'
def __init__(self):
'Initialize LoopCrossDictionary.'
return str(self.loop)
-class SkirtRepository:
+class SkirtRepository(object):
'A class to handle the skirt settings.'
def __init__(self):
'Set the default settings, execute title & settings fileName.'
writeOutput(fileName)
-class SkirtSkein:
+class SkirtSkein(object):
'A class to skirt a skein of extrusions.'
def __init__(self):
'Initialize variables.'
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'smooth', shouldAnalyze)
-class SmoothRepository:
+class SmoothRepository(object):
'A class to handle the smooth settings.'
def __init__(self):
'Set the default settings, execute title & settings fileName.'
writeOutput(fileName)
-class SmoothSkein:
+class SmoothSkein(object):
'A class to smooth a skein of extrusions.'
def __init__(self):
'Initialize.'
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'speed', shouldAnalyze)
-class SpeedRepository:
+class SpeedRepository(object):
"A class to handle the speed settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class SpeedSkein:
+class SpeedSkein(object):
"A class to speed a skein of extrusions."
def __init__(self):
'Initialize.'
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'splodge', shouldAnalyze)
-class SplodgeRepository:
+class SplodgeRepository(object):
"A class to handle the splodge settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class SplodgeSkein:
+class SplodgeSkein(object):
"A class to splodge a skein of extrusions."
def __init__(self):
self.distanceFeedRate = gcodec.DistanceFeedRate()
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'stretch', shouldAnalyze)
-class LineIteratorBackward:
+class LineIteratorBackward(object):
"Backward line iterator class."
def __init__( self, isLoop, lineIndex, lines ):
self.firstLineIndex = None
return False
-class LineIteratorForward:
+class LineIteratorForward(object):
"Forward line iterator class."
def __init__( self, isLoop, lineIndex, lines ):
self.firstLineIndex = None
raise StopIteration, "You've reached the end of the line."
-class StretchRepository:
+class StretchRepository(object):
"A class to handle the stretch settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class StretchSkein:
+class StretchSkein(object):
"A class to stretch a skein of extrusions."
def __init__(self):
self.distanceFeedRate = gcodec.DistanceFeedRate()
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'temperature', shouldAnalyze)
-class TemperatureRepository:
+class TemperatureRepository(object):
"A class to handle the temperature settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class TemperatureSkein:
+class TemperatureSkein(object):
"A class to temperature a skein of extrusions."
def __init__(self):
self.distanceFeedRate = gcodec.DistanceFeedRate()
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'tower', shouldAnalyze)
-class Island:
+class Island(object):
"A class to hold the boundary and lines."
def __init__(self):
self.boundary = []
self.boundingLoop = intercircle.BoundingLoop().getFromLoop( self.boundary )
-class ThreadLayer:
+class ThreadLayer(object):
"A layer of loops and paths."
def __init__(self):
"Thread layer constructor."
return '%s' % self.islands
-class TowerRepository:
+class TowerRepository(object):
"A class to handle the tower settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class TowerSkein:
+class TowerSkein(object):
"A class to tower a skein of extrusions."
def __init__(self):
self.afterExtrusionLines = []
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'unpause', shouldAnalyze)
-class UnpauseRepository:
+class UnpauseRepository(object):
"A class to handle the unpause settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class UnpauseSkein:
+class UnpauseSkein(object):
"A class to unpause a skein of extrusions."
def __init__(self):
self.distanceFeedRate = gcodec.DistanceFeedRate()
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'whittle', shouldAnalyze)
-class WhittleRepository:
+class WhittleRepository(object):
"A class to handle the whittle settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class WhittleSkein:
+class WhittleSkein(object):
"A class to whittle a skein of extrusions."
def __init__(self):
self.distanceFeedRate = gcodec.DistanceFeedRate()
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'widen', shouldAnalyze)
-class WidenRepository:
+class WidenRepository(object):
'A class to handle the widen settings.'
def __init__(self):
'Set the default settings, execute title & settings fileName.'
writeOutput(fileName)
-class WidenSkein:
+class WidenSkein(object):
'A class to widen a skein of extrusions.'
def __init__(self):
self.boundary = None
skeinforge_craft.writeChainTextWithNounMessage(fileName, 'wipe', shouldAnalyze)
-class WipeRepository:
+class WipeRepository(object):
"A class to handle the wipe settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
writeOutput(fileName)
-class WipeSkein:
+class WipeSkein(object):
"A class to wipe a skein of extrusions."
def __init__(self):
self.distanceFeedRate = gcodec.DistanceFeedRate()
return DescriptionRepository()
-class DescriptionRepository:
+class DescriptionRepository(object):
"A class to handle the description settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
return skeinforge_profile.ProfileRepository()
-class ProfileMenuRadio:
+class ProfileMenuRadio(object):
"A class to display a profile menu radio button."
def __init__( self, profilePluginFileName, menu, name, radioVar, value ):
"Create a profile menu radio."
skeinforge_profile.updateProfileSaveListeners()
-class ProfileMenuSaveListener:
+class ProfileMenuSaveListener(object):
"A class to update a profile menu."
def __init__( self, menu, window ):
"Set the menu."
return CuttingRepository()
-class CuttingRepository:
+class CuttingRepository(object):
"A class to handle the cutting settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
return ExtrusionRepository()
-class ExtrusionRepository:
+class ExtrusionRepository(object):
'A class to handle the export settings.'
def __init__(self):
'Set the default settings, execute title & settings fileName.'
return MillingRepository()
-class MillingRepository:
+class MillingRepository(object):
"A class to handle the milling settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
return WindingRepository()
-class WindingRepository:
+class WindingRepository(object):
"A class to handle the winding settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
return window
-class AnalyzeRepository:
+class AnalyzeRepository(object):
"A class to handle the analyze settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
settings.openSVGPage(fileNameSuffix, repository.svgViewer.value)
-class CraftRadioButtonsSaveListener:
+class CraftRadioButtonsSaveListener(object):
"A class to update the craft radio buttons."
def addToDialog( self, gridPosition ):
"Add this to the dialog."
self.repository.pluginFrame.update()
-class CraftRepository:
+class CraftRepository(object):
"A class to handle the craft settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
return HelpRepository()
-class HelpRepository:
+class HelpRepository(object):
"A class to handle the help settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
return archive.getSkeinforgePluginsPath('meta_plugins')
-class MetaRepository:
+class MetaRepository(object):
"A class to handle the meta settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
return str(fileName) == '' or str(fileName) == '()' or wasCancelled
-class PolyfileRepository:
+class PolyfileRepository(object):
"A class to handle the polyfile settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
'bottom_thickness': '0.3',
'hop_on_move': 'False',
'plugin_config': '',
+ 'object_center_x': '-1',
+ 'object_center_y': '-1',
'add_start_end_gcode': 'True',
'gcode_extension': 'gcode',
for pluginTest in pluginList:
if pluginTest['filename'] == pluginConfig['filename']:
plugin = pluginTest
- if plugin == None:
+ if plugin is None:
continue
pythonFile = None
testFilename = os.path.join(basePath, pluginConfig['filename'])
if os.path.isfile(testFilename):
pythonFile = testFilename
- if pythonFile == None:
+ if pythonFile is None:
continue
locals = {'filename': gcodefilename}
~ianmdlvl / cura.git / commitdiff