def load_default(self):
self.Clear()
try:
cad.OpenXmlFile(wx.GetApp().cam_dir + "/default.tooltable", self)
except:
# no default file found, add 2 tools
cad.AddUndoably(
Tool(diameter=3.0, type=TOOL_TYPE_SLOTCUTTER, tool_number=1),
self, None)
cad.AddUndoably(
Tool(diameter=6.0, type=TOOL_TYPE_SLOTCUTTER, tool_number=2),
self, None)
return
def EditAndAddSketchOp(self, new_object, sketches):
if new_object.Edit():
cad.StartHistory('Add ' + new_object.GetTitle())
cad.AddUndoably(new_object, self.program.operations, None)
first = True
for sketch in sketches:
if first:
first = False
else:
copy = new_object.MakeACopy()
copy.sketch = sketch
cad.AddUndoably(copy, self.program.operations, None)
self.EndHistory()
def SketchOperation(self, mode):
objects_to_delete = []
area = None
for object in cad.GetSelectedObjects():
t = object.GetType()
if t == cad.OBJECT_TYPE_SKETCH:
objects_to_delete.append(object)
sketch = object
sketch.__class__ = cad.Sketch
a = sketch.GetArea()
if area == None:
area = a
else:
if mode == SKETCH_OP_UNION:
area.Union(a)
elif mode == SKETCH_OP_SUBTRACT:
area.Subtract(a)
elif mode == SKETCH_OP_INTERSECT:
area.Intersect(a)
if area != None:
cad.StartHistory()
sketch = cad.NewSketchFromArea(area)
cad.AddUndoably(sketch)
cad.DeleteObjectsUndoably(objects_to_delete)
cad.EndHistory()
def GetOwnerForDrawingObjects(self):
if self.add_to_sketch:
if self.container == None:
self.container = cad.NewSketch()
cad.AddUndoably(self.container)
return self.container
return cad.GetApp()
def AddObjectFromButton(self, new_object):
cad.StartHistory()
cad.AddUndoably(new_object, None, None)
cad.ClearSelection(True)
cad.Select(new_object)
self.SetInputMode(self.select_mode)
cad.EndHistory()
cad.Repaint()
def SplitSketch(self, object):
sketch = object
sketch.__class__ = cad.Sketch
new_sketches = sketch.Split()
cad.StartHistory()
cad.DeleteUndoably(object)
for sketch in new_sketches:
cad.AddUndoably(sketch, object.GetOwner(), None)
cad.EndHistory()
def Mirror():
if cad.GetNumSelected() == 0:
wx.GetApp().PickObjects('Pick objects to mirror')
if cad.GetNumSelected() == 0:
return
config = HeeksConfig()
selected_items = cad.GetSelectedObjects()
cad.ClearSelection(False)
copy = config.ReadBool("MirrorCopy", False)
axis = geom.Point3D(0, 0, 1)
pos = geom.Point3D(0, 0, 0)
axis.x = config.ReadFloat("MirrorAxisX", 1.0)
axis.y = config.ReadFloat("MirrorAxisY", 0.0)
axis.z = config.ReadFloat("MirrorAxisZ", 0.0)
pos.x = config.ReadFloat("MirrorPosX", 0.0)
pos.y = config.ReadFloat("MirrorPosY", 0.0)
pos.z = config.ReadFloat("MirrorPosZ", 0.0)
result, axis, pos, copy = InputMirrorPlane(axis, pos, copy, 'Mirror')
if not result:
return
config.WriteBool("MirrorCopy", copy)
config.WriteFloat("MirrorAxisX", axis.x)
config.WriteFloat("MirrorAxisY", axis.y)
config.WriteFloat("MirrorAxisZ", axis.z)
config.WriteFloat("MirrorPosX", pos.x)
config.WriteFloat("MirrorPosY", pos.y)
config.WriteFloat("MirrorPosZ", pos.z)
cad.StartHistory()
mat = geom.Matrix()
x, y = axis.ArbitraryAxes()
axis_mat = geom.Matrix(pos, x, y)
inv_mat = axis_mat.Inverse()
mat.Multiply(inv_mat) # transform so axis goes to z axis
mat.Scale3(1.0, 1.0, -1.0) # mirror in z axis
mat.Multiply(axis_mat) # transform back to where it was
for object in selected_items:
if copy:
if object.CanBeCopied():
object = object.MakeACopy()
object.Transform(mat)
cad.AddUndoably(object)
else:
cad.TransformUndoably(object, mat)
cad.EndHistory()
def FitArcs(self, object):
value = self.InputLength('Set tolerance for Fit Arcs', 'tolerance', geom.get_accuracy())
if value != None:
geom.set_accuracy(value)
sketch = object
sketch.__class__ = cad.Sketch
curve = sketch.GetCurve()
curve.FitArcs()
cad.StartHistory()
cad.DeleteUndoably(object)
cad.AddUndoably(cad.NewSketchFromCurve(curve))
cad.EndHistory()
def NewStock(self, e):
solids = []
for object in cad.GetSelectedObjects():
if object.GetIDGroupType() == cad.OBJECT_TYPE_STL_SOLID:
solids.append(object.GetID())
new_object = Stock.Stock()
new_object.solids += solids
new_object.SetID(cad.GetNextID(Stock.type))
if new_object.Edit():
cad.AddUndoably(new_object, self.program.stocks, None)
self.EndHistory()
def OnSpline(self, e):
if not self.CheckForNumberOrMore(
2, [cad.OBJECT_TYPE_POINT],
'Pick one or more points to make a spline through',
'Spline Through Points'):
return
cad.StartHistory()
points = []
for object in cad.GetSelectedObjects():
points.append(object.GetStartPoint())
new_object = step.NewSplineFromPoints(points)
cad.AddUndoably(new_object)
cad.EndHistory()
def OffsetSketch(self, object):
config = HeeksConfig()
value = config.ReadFloat('SketchOffsetValue', 1.0)
value = self.InputLength('Offset Sketch', 'Offset Value +ve for Outwards -ve for Inwards', value)
if value == None: return
sketch = object
sketch.__class__ = cad.Sketch
area = sketch.GetArea()
area.Reorder()
area.Offset(-value)
new_object = cad.NewSketchFromArea(area)
cad.AddUndoably(new_object)
cad.ClearSelection()
cad.Select(new_object)
def Scale():
centre_Pos = geom.Point3D(0, 0, 0)
if cad.GetNumSelected() == 0:
wx.GetApp().PickObjects('Pick objects to scale')
if cad.GetNumSelected() == 0:
return
config = HeeksConfig()
selected_items = cad.GetSelectedObjects()
cad.ClearSelection(False)
scale_factor = config.ReadFloat('ScaleFactor', 1.0)
copy = config.ReadBool("ScaleCopy", False)
pos = geom.Point3D(0, 0, 0)
pos.x = config.ReadFloat("ScaleAboutPosX", 0.0)
pos.y = config.ReadFloat("ScaleAboutPosY", 0.0)
pos.z = config.ReadFloat("ScaleAboutPosZ", 0.0)
result, pos, scale_factor, copy = InputScale(pos, scale_factor, copy,
'Scale')
if not result:
return
config.WriteFloat("ScaleFactor", scale_factor)
config.WriteBool("ScaleCopy", copy)
config.WriteFloat("ScaleAboutPosX", pos.x)
config.WriteFloat("ScaleAboutPosY", pos.y)
config.WriteFloat("ScaleAboutPosZ", pos.z)
cad.StartHistory()
mat = geom.Matrix()
mat.Translate(-pos)
mat.Scale(scale_factor)
mat.Translate(pos)
for object in selected_items:
if copy:
if object.CanBeCopied():
object = object.MakeACopy()
object.Transform(mat)
cad.AddUndoably(object)
else:
cad.TransformUndoably(object, mat)
cad.EndHistory()
def MakeToSketch(self):
objects_to_delete = []
sketch = cad.NewSketch()
for object in cad.GetSelectedObjects():
t = object.GetType()
if object.CanAddTo(sketch):
new_object = object.MakeACopy()
objects_to_delete.append(object)
sketch.Add(new_object)
cad.StartHistory()
cad.AddUndoably(sketch)
cad.DeleteObjectsUndoably(objects_to_delete)
cad.EndHistory()
def AddProgramIfThereIsntOne(self):
# check if there is already a program in the document
doc = cad.GetApp()
object = doc.GetFirstChild()
while object != None:
if object.GetType() == Program.type:
self.program = object
return
object = doc.GetNextChild()
# add a program
self.program = Program.Program()
programs.append(self.program)
self.program.add_initial_children()
cad.AddUndoably(self.program)
def OnSetOriginPoints(self, three_points):
mat = cad.GetDrawMatrix(False)
o = geom.Point3D(0,0,0).Transformed(mat)
x = geom.Point3D(1,0,0).Transformed(mat) - o
y = geom.Point3D(0,1,0).Transformed(mat) - o
new_object = cad.NewCoordinateSystem("Coordinate System", o, x, y)
cad.ClearSelection()
self.SetInputMode(self.select_mode)
# and pick from three points
result = self.MakeOriginFromPickPoints(new_object, three_points)
if result:
cad.AddUndoably(new_object)
cad.Select(new_object)
else:
cad.DeleteInternalObject(new_object)
def OnShadow(self, event):
if not self.CheckForNumberOrMore(
1, [step.GetSolidType(), cad.OBJECT_TYPE_STL_SOLID],
'Pick one or more solids to make a shadow sketch from',
'Shadow Sketch of Solids'):
return
accuracy = self.InputLength('Enter Shadow Accuracy', 'Accuracy',
geom.get_accuracy())
if accuracy:
cad.StartHistory()
geom.set_accuracy(accuracy)
for object in cad.GetSelectedObjects():
stl = object.GetTris(accuracy)
mat = geom.Matrix()
shadow = stl.Shadow(mat, False)
#shadow.Reorder()
sketch = cad.NewSketchFromArea(shadow)
cad.AddUndoably(sketch)
cad.EndHistory()
def EditAndAddOp(self, op):
if op.Edit():
cad.StartHistory('Add ' + op.GetTitle())
cad.AddUndoably(op, op.PreferredPasteTarget(), None)
self.EndHistory()
def OnGear(self, e):
gear = Gear.Gear(1.0, 12)
cad.AddUndoably(gear, None, None)
def OnText(self, e):
cad.AddUndoably(cad.NewText("text"))
def FaceToSketch(self, object):
sketch = step.NewSketchFromFace(object)
cad.AddUndoably(sketch)
cad.Select(sketch)
def ImportImageFile():
image = HImage.HImage(cad.GetFilePathForImportExport())
cad.AddUndoably(image)
def EditAndAddTool(self, tool):
if tool.Edit():
cad.StartHistory('Add Tool')
cad.AddUndoably(tool, self.program.tools, None)
self.EndHistory()
def FaceRadiusChange(self, object):
sketch = step.NewSketchFromFace(object)
cad.AddUndoably(sketch)
cad.Select(sketch)
def OnWing(self, e):
o = Wing()
wings.append(o)
cad.AddUndoably(o, None, None)
def OnMouse(self, event):
# to do? if(wxGetApp().m_property_grid_validation)return;
if event.Entering():
self.SetFocus() # so middle wheel works
if event.LeftDown():
button = self.HitTest(event.GetPosition())
if button:
if button.type == ButtonTypePlus or button.type == ButtonTypeMinus:
self.SetExpanded(button.obj, button.type == ButtonTypePlus)
self.SetVirtualSize(self.GetRenderSize())
self.Refresh()
else:
self.OnLabelLeftDown(button.obj, event)
self.clicked_object = button.obj
else:
cad.ClearSelection(True)
self.button_down_point = event.GetPosition()
if event.LeftUp():
if self.dragging:
self.dragging = False
# find the object to drop on to
button = self.HitTest(event.GetPosition())
if (button == None) or not cad.ObjectMarked(
button.obj
): # can only drop on to an item other than one of the items being dragged
# test drop possible
drag_possible = True
add_to = cad.GetApp()
if button and button.paste_into: add_to = button.paste_into
for object in self.dragged_list:
if not add_to.CanAdd(object) or not object.CanAddTo(
add_to):
drag_possible = False
break
if drag_possible:
cad.StartHistory()
# cut the objects
cad.DeleteObjectsUndoably(self.dragged_list)
# paste the objects
for object in self.dragged_list:
if object.OneOfAKind():
one_found = False
child = add_to.GetFirstChild()
while child:
if child.GetType() == object.GetType():
child.CopyFrom(object)
one_found = True
break
child = add_to.GetNextChild()
if not one_found:
cad.AddUndoably(
object, add_to, button.paste_before if
(button != None) else None)
else:
cad.AddUndoably(
object, add_to, button.paste_before if
(button != None) else None)
cad.EndHistory()
else:
self.Refresh()
else:
self.Refresh()
else:
if self.waiting_until_left_up:
cad.ClearSelection(False)
cad.Select(self.clicked_object, True)
self.waiting_until_left_up = False
if event.RightDown():
button = self.HitTest(event.GetPosition())
self.clicked_object = None
if (button != None) and (button.type == ButtonTypeLabelBefore
or button.type == ButtonTypeLabel):
self.clicked_object = button.obj
self.OnLabelRightDown(button.obj, event)
if event.RightUp():
if self.dragging:
self.dragging = False
else:
tools = self.GetDropDownTools(event.ControlDown())
menu = wx.Menu()
for tool in tools:
wx.GetApp().AddToolToListAndMenu(tool, menu)
self.PopupMenu(menu, event.GetPosition())
if event.Dragging():
if event.LeftIsDown() or event.RightIsDown():
if (not self.dragging) and (
math.fabs(self.button_down_point.x - event.GetX()) > 2
or math.fabs(self.button_down_point.y - event.GetY()) >
2):
self.dragging = True
self.dragged_list = cad.GetSelectedObjects()
if self.dragging:
self.drag_position = self.CalcUnscrolledPosition(
event.GetPosition())
button = self.HitTest(event.GetPosition())
self.drag_paste_rect = wx.Rect(0, 0, 0, 0)
if (button != None) and (button.type == ButtonTypeLabelBefore):
self.drag_paste_rect = button.rect
self.Refresh()
if event.LeftDClick():
if self.clicked_object:
wx.GetApp().EditUndoably(self.clicked_object)
event.Skip()
def AddObjectsMade(self):
for object in self.temp_object_in_list:
cad.AddUndoably(object, self.GetOwnerForDrawingObjects())
if self.DragDoneWithXOR():cad.DrawObjectsOnFront(self.temp_object_in_list, True)
self.temp_object_in_list = []