def updateGhost(self,obj,idx,pt):
if Draft.getType(obj) in ["Wire"]:
self.ghost.on()
pointList = self.applyPlacement(obj.Points)
pointList[idx] = pt
if obj.Closed: pointList.append(pointList[0])
self.ghost.updateFromPointlist(pointList)
elif Draft.getType(obj) == "BSpline":
self.ghost.on()
pointList = self.applyPlacement(obj.Points)
pointList[idx] = pt
if obj.Closed: pointList.append(pointList[0])
self.ghost.update(pointList)
elif Draft.getType(obj) == "BezCurve":
self.ghost.on()
plist = self.applyPlacement(obj.Points)
pointList = self.recomputePointsBezier(plist,idx,pt,obj.Degree,moveTrackers=True)
self.ghost.update(pointList,obj.Degree)
elif Draft.getType(obj) == "Circle":
self.ghost.on()
if self.arc3Pt == False:
self.ghost.setCenter(obj.Placement.Base)
self.ghost.setRadius(obj.Radius)
self.ghost.setStartAngle(math.radians(obj.FirstAngle))
self.ghost.setEndAngle(math.radians(obj.LastAngle))
if self.editing == 0:
self.ghost.setCenter(pt)
elif self.editing == 1:
self.ghost.setStartPoint(pt)
elif self.editing == 2:
self.ghost.setEndPoint(pt)
elif self.editing == 3:
self.ghost.setRadius(self.invpl.multVec(pt).Length)
elif self.arc3Pt == True:
if self.editing == 0:#center point
import DraftVecUtils
p1 = self.invpl.multVec(self.obj.Shape.Vertexes[0].Point)
p2 = self.invpl.multVec(self.obj.Shape.Vertexes[1].Point)
p0 = DraftVecUtils.project(self.invpl.multVec(pt),self.invpl.multVec(self.getArcMid()))
self.ghost.autoinvert=False
self.ghost.setRadius(p1.sub(p0).Length)
self.ghost.setStartPoint(self.obj.Shape.Vertexes[1].Point)
self.ghost.setEndPoint(self.obj.Shape.Vertexes[0].Point)
self.ghost.setCenter(self.pl.multVec(p0))
return
else:
p1=self.obj.Shape.Vertexes[0].Point
p2=self.getArcMid()
p3=self.obj.Shape.Vertexes[1].Point
if self.editing == 1: p1=pt
elif self.editing == 3: p2=pt
elif self.editing == 2: p3=pt
self.ghost.setBy3Points(p1,p2,p3)
DraftTools.redraw3DView()
def action(self, arg):
"""Scene event handler. CURRENTLY NOT USED.
Here the displaying of the trackers (previews)
should be implemented by considering the current value of the
`ui.radiusValue`.
"""
if arg["Type"] == "SoKeyboardEvent":
if arg["Key"] == "ESCAPE":
self.finish()
elif arg["Type"] == "SoLocation2Event":
self.point, ctrlPoint, info = DraftTools.getPoint(self, arg)
DraftTools.redraw3DView()
def button_action(self, arg):
"""
Button click trapping
"""
_p = self.view.getCursorPos()
self.mouse.update(arg, _p)
#manage selection
if self.mouse.button1.pressed:
self.on_selection(arg, _p)
DraftTools.redraw3DView()
def __init__(self, doc):
self.ui_path = resources.__path__[0] + '/ui/'
self.ui = self.ui_path + 'sprite_splitter_task_panel.ui'
self.form = None
self.subtask = None
self.panel = None
self.doc = doc
self.plane = None
self.names = ['FreeCAD', self.doc.Name, 'Sprite Splitter']
self.image = QtGui.QImage()
self.cursor_trackers = [
WireTracker(self.names),
WireTracker(self.names[:2] + ['CURSOR'])
]
self.rubberband_tracker = BoxTracker(self.names[:2] + ['RUBBERBAND'])
self.rubberband_tracker.set_selectability(False)
self.node = BaseTracker(self.names)
self.node.insert_node(self.cursor_trackers[0].switch)
self.node.insert_node(self.cursor_trackers[1].switch)
self.node.insert_node(self.rubberband_tracker.switch)
#deselect existing selections
Gui.Selection.clearSelection()
self.callbacks = {
'SoLocation2Event':
ViewState().view.addEventCallback('SoLocation2Event',
self.mouse_event),
'SoMouseButtonEvent':
ViewState().view.addEventCallback('SoMouseButtonEvent',
self.button_event)
}
self.grid_tracker = GridTracker(self.names)
DraftTools.redraw3DView()
def __init__(self):
super().__init__('PivyTrackerTask', Gui.ActiveDocument.ActiveView)
#self.panel = None
_camera = self.view_state.view.getCameraNode()
self.camera_state = self.CameraState(position=(0.0, 0.0, 0.0),
height=0.0,
box_corners=(-120.0, -120.0,
120.0, 120.0))
self.pivy_tracker = PivyTracker()
self.pivy_tracker.insert_into_scenegraph(True)
DraftTools.redraw3DView()
self._zoom_camera()
def updateGhost(self,obj,idx,pt):
if Draft.getType(obj) in ["Wire"]:
self.ghost.on()
pointList = self.applyPlacement(obj.Points)
pointList[idx] = pt
if obj.Closed: pointList.append(pointList[0])
self.ghost.updateFromPointlist(pointList)
elif Draft.getType(obj) == "BSpline":
self.ghost.on()
pointList = self.applyPlacement(obj.Points)
pointList[idx] = pt
if obj.Closed: pointList.append(pointList[0])
self.ghost.update(pointList)
elif Draft.getType(obj) == "BezCurve":
self.ghost.on()
plist = self.applyPlacement(obj.Points)
pointList = self.recomputePointsBezier(plist,idx,pt,obj.Degree,moveTrackers=True)
self.ghost.update(pointList,obj.Degree)
DraftTools.redraw3DView()
def action(self, arg):
"scene event handler"
if arg["Type"] == "SoKeyboardEvent":
if arg["Key"] == "ESCAPE":
self.finish()
elif arg["Type"] == "SoLocation2Event": #mouse movement detection
self.point, ctrlPoint, info = DraftTools.getPoint(self,
arg,
mobile=True,
noTracker=True)
self.rect.update(self.point)
DraftTools.redraw3DView()
elif arg["Type"] == "SoMouseButtonEvent":
if (arg["State"] == "DOWN") and (arg["Button"] == "BUTTON1"):
if (arg["Position"] == self.pos):
self.finish()
else:
if (not self.node) and (not self.support):
DraftTools.getSupport(arg)
self.point, ctrlPoint, info = DraftTools.getPoint(
self, arg, mobile=True, noTracker=True)
if self.point:
self.ui.redraw()
self.appendPoint(self.point)
def action(self, arg):
"""
Coin SoEvent callback for mouse / keyboard handling
"""
#trap mouse movement
if arg['Type'] == 'SoLocation2Event':
_p = self.view.getCursorPos()
_pt = self.view.getPoint(_p)
info = self.view.getObjectInfo(_p)
if info:
print(info)
return
if not self.button_states['BUTTON1']:
self.handle_mouseover_tracker(info)
else:
self.handle_drag_tracker(self.view.getPoint(_p))
#trap button clicks
elif arg['Type'] == 'SoMouseButtonEvent':
self.get_button_states(arg)
_p = self.view.getCursorPos()
info = self.view.getObjectInfo(_p)
multi_select = arg['AltDown']
_key, _it = self.get_current_tracker(info)
#empty the arry and reset the trackers
if self.selected_trackers:
for _tracker in self.selected_trackers:
_tracker.set_style(self.STYLES.ENABLED)
self.selected_trackers = []
#current defined? add it to the selection.
if _it:
#Clear the button states so dragging won't work unles
for _v in self.button_states.values():
_v = False
while True:
_current = self.trackers[_key]
_current.set_style(self.STYLES.SELECTED)
self.active_tracker = _current
self.selected_trackers.append(_current)
if not multi_select:
break
try:
_key = next(_it)
except StopIteration:
break
self.doc.recompute()
DraftTools.redraw3DView()
def __init__(self, doc, alignment_data, obj, is_linked):
super().__init__()
# '.'.join([doc.Name, 'BASE_TRACKER_TEST_TASK', 'TASK']))
self.view_state = ViewState(Gui.ActiveDocument.ActiveView)
self.panel = None
self.doc = doc
self.Object = obj
self.alignment = alignment.create(alignment_data, 'TEMP', True, False)
self.pi_tracker = None
self.drag_tracker = None
self.alignment_tracker = None
#self.callbacks = {}
self.camera_state = {
'position': None,
'height': None,
'bound box': None
}
self.view_state.view_objects = {
'selectables': [],
'line_colors': [],
}
#disable selection entirely
self.view_state.sg_root.getField("selectionRole").setValue(0)
#get all objects with LineColor and set them all to gray
self.view_state.view_objects['line_colors'] = [
(_v.ViewObject, _v.ViewObject.LineColor)
for _v in self.doc.findObjects() if hasattr(_v, 'ViewObject')
if hasattr(_v.ViewObject, 'LineColor')
]
for _v in self.view_state.view_objects['line_colors']:
self.set_vobj_style(_v[0], self.STYLES.DISABLED)
#get all objects in the scene that are selectable.
self.view_state.view_objects['selectable'] = [
(_v.ViewObject, _v.ViewObject.Selectable)
for _v in self.doc.findObjects() if hasattr(_v, 'ViewObject')
if hasattr(_v.ViewObject, 'Selectable')
]
for _v in self.view_state.view_objects['selectable']:
_v[0].Selectable = False
#deselect existing selections
Gui.Selection.clearSelection()
self.task_tracker = TaskTracker()
self.alignment_tracker = TrackerTester(self.doc, self.Object.Name,
self.alignment, is_linked,
self.task_tracker.base)
#self.task_tracker.insert_group(self.alignment_tracker.base)
#save camera state
_camera = self.view_state.view.getCameraNode()
self.camera_state['position'] = _camera.position.getValue().getValue()
self.camera_state['height'] = _camera.height.getValue()
self.camera_state['bound box'] = self.Object.Shape.BoundBox
#add mouse callbacks for updating mouse state
#ViewState().add_mouse_event(self.mouse_event)
#ViewState().add_button_event(self.button_event)
self._zoom_camera()
self.task_tracker.insert_into_scenegraph(True)
DraftTools.redraw3DView()
def __init__(self, doc, view, alignment_data, obj):
self.panel = None
self.view = view
self.doc = doc
self.obj = obj
self.alignment = alignment_model.AlignmentModel()
self.alignment.data = alignment_data
self.pi_tracker = None
self.drag_tracker = None
self.callbacks = {}
self.mouse = MouseState()
self.view_objects = {
'selectables': [],
'line_colors': [],
}
#disable selection entirely
self.view.getSceneGraph().getField("selectionRole").setValue(0)
#get all objects with LineColor and set them all to gray
self.view_objects['line_colors'] = [
(_v.ViewObject, _v.ViewObject.LineColor)
for _v in self.doc.findObjects()
if hasattr(_v, 'ViewObject')
if hasattr(_v.ViewObject, 'LineColor')
]
for _v in self.view_objects['line_colors']:
self.set_vobj_style(_v[0], self.STYLES.DISABLED)
#get all objects in the scene that are selecctable.
self.view_objects['selectable'] = [
(_v.ViewObject, _v.ViewObject.Selectable)
for _v in self.doc.findObjects()
if hasattr(_v, 'ViewObject')
if hasattr(_v.ViewObject, 'Selectable')
]
for _v in self.view_objects['selectable']:
_v[0].Selectable = False
#deselect existing selections
Gui.Selection.clearSelection()
_points = self.alignment.get_pi_coords()
self.pi_tracker = PiTracker(
self.doc, self.view, self.obj.Name, 'PI_TRACKER', _points
)
self.callbacks = {
'SoKeyboardEvent': self.key_action,
'SoMouseButtonEvent': self.button_action,
'SoLocation2Event': self.mouse_action
}
for _k, _v in self.callbacks.items():
self.view.addEventCallback(_k, _v)
panel = DraftAlignmentTask(self.clean_up)
Gui.Control.showDialog(panel)
#panel.setup()
self.doc.recompute()
DraftTools.redraw3DView()
def action(self, arg):
"""
Event handling for alignment drawing
"""
#trap the escape key to quit
if arg['Type'] == 'SoKeyboardEvent':
if arg['Key'] == 'ESCAPE':
self.finish()
return
#trap mouse movement
if arg['Type'] == 'SoLocation2Event':
_p = Gui.ActiveDocument.ActiveView.getCursorPos()
info = Gui.ActiveDocument.ActiveView.getObjectInfo(_p)
curve_hash = None
#test to see which curve is under the cursor
if info:
if info['Object'] == self.alignment_draft.Name:
curve_hash = self.select_curve_edges(info['Component'])
#matching hashes? nothing to do for mouseover
if self.curve_hash == curve_hash:
return
#hashes do not match. Deselect last selected curve
if Gui.Selection.getSelection():
Gui.Selection.clearSelection()
if self.active_curve != self.curve_hash:
self.hide_control_geometry()
#if self.active_curve != curve_hash:
if curve_hash:
self.show_control_geometry(curve_hash)
self.curve_hash = curve_hash
#if this is a new curve, hide the prev geometry if not active
# if self.curve_hash:
#trap button clicks
elif arg['Type'] == 'SoMouseButtonEvent':
_p = Gui.ActiveDocument.ActiveView.getCursorPos()
info = Gui.ActiveDocument.ActiveView.getObjectInfo(_p)
curve_hash = None
if self.active_curve:
self.hide_control_geometry(self.active_curve)
self.hide_curve(self.active_curve)
if info:
if info['Object'] == self.alignment_draft.Name:
curve_hash = info['Component']
self.show_curve(self.curve_hash)
self.active_curve = self.curve_hash
else:
self.active_curve = None
if Gui.Selection.getSelection():
Gui.Selection.clearSelection()
if self.curve_hash:
self.hide_control_geometry()
self.curve_hash = None
# self.alignment_tracker.update(self.node + [self.point])
else:
return
App.ActiveDocument.recompute()
DraftTools.redraw3DView()
def action(self,arg):
"scene event handler"
if arg["Type"] == "SoKeyboardEvent" and arg["State"] == "DOWN":
if arg["Key"] == "ESCAPE":
self.finish()
elif arg["Key"] == "a":
self.finish()
elif arg["Key"] == "o":
self.finish(closed=True)
elif arg["Key"] == "i":
if Draft.getType(self.obj) == "Circle": self.arcInvert()
elif arg["Type"] == "SoLocation2Event": #mouse movement detection
self.point,ctrlPoint,info = DraftTools.getPoint(self,arg)# causes problems when mouseover bezcurves
if self.editing != None:
self.trackers[self.editing].set(self.point)
#FreeCAD.Console.PrintMessage(self.ghost)
self.updateGhost(obj=self.obj,idx=self.editing,pt=self.point)
if hasattr(self.obj.ViewObject,"Selectable"):
if self.ui.addButton.isChecked():
self.obj.ViewObject.Selectable = True
else:
self.obj.ViewObject.Selectable = False
DraftTools.redraw3DView()
elif arg["Type"] == "SoMouseButtonEvent" and arg["State"] == "DOWN":
if arg["Button"] == "BUTTON1":
self.ui.redraw()
if self.editing == None:
# USECASE: User click on one of the editpoints or another object
ep = None
selobjs = self.getSelection()
if selobjs == None: return
if self.ui.addButton.isChecked():# still quite raw
# USECASE: User add a new point to the object
for info in selobjs:
if Draft.getType(self.obj) == "Wire" and 'Edge' in info["Component"]:
pt = FreeCAD.Vector(info["x"],info["y"],info["z"])
self.addPointToWire(pt, int(info["Component"][4:]))
elif self.point:
pt = self.point
if "x" in info:# prefer "real" 3D location over working-plane-driven one if possible
pt = FreeCAD.Vector(info["x"],info["y"],info["z"])
self.addPointToCurve(pt,info)
self.removeTrackers()
self.editpoints = []
self.setEditPoints(self.obj)
self.resetTrackers()
return
ep = self.lookForClickedNode(selobjs,tolerance=20)
if ep == None: return
if self.ui.delButton.isChecked(): # still quite raw
# USECASE: User delete a point of the object
self.delPoint(ep)
# don't do tan/sym on DWire/BSpline!
self.removeTrackers()
self.editpoints = []
self.setEditPoints(self.obj)
self.resetTrackers()
return
if Draft.getType(self.obj) == "BezCurve":
# USECASE: User change the continuity of a Bezcurve point
if self.ui.sharpButton.isChecked():
return self.smoothBezPoint(ep, 'Sharp')
elif self.ui.tangentButton.isChecked():
return self.smoothBezPoint(ep, 'Tangent')
elif self.ui.symmetricButton.isChecked():
return self.smoothBezPoint(ep, 'Symmetric')
if self.ui.arc3PtButton.isChecked():
self.arc3Pt = False
else:
self.arc3Pt = True
self.ui.pointUi()
self.ui.isRelative.show()
self.editing = ep
self.trackers[self.editing].off()
self.finalizeGhost()
self.ghost = self.initGhost(self.obj)
'''if hasattr(self.obj.ViewObject,"Selectable"):
self.obj.ViewObject.Selectable = False'''
self.node.append(self.trackers[self.editing].get())
FreeCADGui.Snapper.setSelectMode(False)
else: #if self.editing != None:
# USECASE: Destination point of editing is clicked
self.finalizeGhost()
self.trackers[self.editing].on()
#if hasattr(self.obj.ViewObject,"Selectable"):
# self.obj.ViewObject.Selectable = True
FreeCADGui.Snapper.setSelectMode(True)
self.numericInput(self.trackers[self.editing].get())
def __init__(self, doc, alignment_data, obj):
self.name = 'Edit Alignment Task'
self.panel = None
self.doc = doc
self.Object = obj
self.alignment = alignment.create(alignment_data, 'TEMP', True, False)
self.alignment_tracker = None
self.terminator_tracker = None
self.callbacks = {}
self.mouse = MouseState()
self.form = None
self.ui_path = resources.__path__[0] + '/ui/'
self.ui = self.ui_path + 'edit_alignment_task.ui'
self.unit_scale = units.scale_factor()
self.masks = {
'float': '#90000.99',
'degree_float': '900.99\u00b0',
'station_imp_float': '00009+99.99',
'station_eng_float': '00009+999.99',
}
self.camera_state = {
'position': None,
'height': None,
'bound box': None
}
ViewState().view_objects = {
'selectables': [],
'line_colors': [],
}
super().__init__("Edit Alignment Task")
#disable selection entirely
ViewState().sg_root.getField("selectionRole").setValue(0)
#get all objects with LineColor and set them all to gray
ViewState().view_objects['line_colors'] = [
(_v.ViewObject, _v.ViewObject.LineColor)
for _v in self.doc.findObjects() if hasattr(_v, 'ViewObject')
if hasattr(_v.ViewObject, 'LineColor')
]
for _v in ViewState().view_objects['line_colors']:
self.set_vobj_style(_v[0], self.STYLES.DISABLED)
#get all objects in the scene that are selectable.
ViewState().view_objects['selectable'] = [
(_v.ViewObject, _v.ViewObject.Selectable)
for _v in self.doc.findObjects() if hasattr(_v, 'ViewObject')
if hasattr(_v.ViewObject, 'Selectable')
]
for _v in ViewState().view_objects['selectable']:
_v[0].Selectable = False
#deselect existing selections
Gui.Selection.clearSelection()
self.callbacks = {
'SoLocation2Event':
ViewState().view.addEventCallback('SoLocation2Event',
self.mouse_event),
'SoMouseButtonEvent':
ViewState().view.addEventCallback('SoMouseButtonEvent',
self.button_event)
}
self.alignment_tracker = AlignmentTracker(self.doc, self.Object.Name,
self.alignment)
self.terminator_tracker = TerminatorTracker()
#subscribe the alignment tracker to all events from the task
#and subscribe the task to task events from the tracker
self.alignment_tracker.register(self, Events.ALIGNMENT.UPDATED)
self.register(self.alignment_tracker, Events.ALIGNMENT.UPDATE)
self.terminator_tracker.register(self, Events.TASK.EVENTS)
#save camera state
_camera = ViewState().view.getCameraNode()
self.camera_state['position'] = _camera.position.getValue().getValue()
self.camera_state['height'] = _camera.height.getValue()
self.camera_state['bound box'] = self.Object.Shape.BoundBox
self._zoom_camera, self
DraftTools.redraw3DView()
