def __init__(self):
try:
self.s = labvcnc.stat()
self.c = labvcnc.command()
except Exception, msg:
print "cant initialize LbvInterface: %s - LabvCNC not running?" % (
msg)
def __init__(self):
self.i = labvcnc.ini(os.environ['INI_FILE_NAME'])
self.c = labvcnc.command()
self.s = labvcnc.stat()
self.gui = self.i.find('DISPLAY', 'DISPLAY').lower()
self.configFile = '{}_wizards.cfg'.format(
self.i.find('LBV', 'MACHINE').lower())
def support_coord_buttons(self):
try:
self.stat = labvcnc.stat()
self.stat.poll()
has_x = False
for axno in range(0, 9):
axname = 'XYZABCUVW'[axno]
if self.label_to_btn.has_key(axname):
b = self.label_to_btn[axname]
if bool(self.stat.axis_mask & (1 << axno)):
b.show()
if axno == 0: has_x = True
else:
b.hide()
bdiam = None
if self.label_to_btn.has_key('D'):
bdiam = self.label_to_btn['D']
if bdiam and has_x:
bdiam.show()
elif bdiam:
bdiam.hide()
except labvcnc.error, msg:
self.stat = None
if self.coord_buttons is not None:
self.coord_buttons.hide()
print "labvcnc must be running to use coordinate keys"
def __init__(self, halcomp, builder, useropts):
self.halcomp = halcomp
self.builder = builder
self.i = labvcnc.ini(os.environ['INI_FILE_NAME'])
self.s = labvcnc.stat()
self.c = labvcnc.command()
self.prefFile = self.i.find('LBV', 'MACHINE') + '.pref'
self.set_theme()
self.maxFeed = int(
float(self.i.find("DISPLAY", "MAX_FEED_OVERRIDE") or '1') * 100)
self.maxRapid = int(
float(self.i.find("DISPLAY", "MAX_RAPID_OVERRIDE") or '1') * 100)
self.oldMode = 9
self.configure_widgets()
self.feed_override = 0
self.rapid_override = 0
self.torch_height = 0
self.builder.get_object('height-override').set_text('{:.1f} V'.format(
self.torch_height))
hal.set_p('plasmac.height-override', '{:f}'.format(self.torch_height))
self.configure_comboboxes('feed-override', 0, self.maxFeed, 1, '100')
self.feed_override = 1
self.configure_comboboxes('rapid-override', 0, self.maxRapid, 1, '100')
self.rapid_override = 1
pause_motion_init = self.i.find("PLASMAC",
"PAUSED_MOTION_SPEED") or '50'
torch_pulse_init = self.i.find("PLASMAC", "TORCH_PULSE_TIME") or '1.0'
self.configure_comboboxes('paused-motion-speed', 0, 100, 5,
pause_motion_init)
self.configure_comboboxes('torch-pulse-time', 0, 10, 0.1,
torch_pulse_init)
gobject.timeout_add(100, self.periodic)
def __init__(self, halcomp,builder,useropts):
self.W = gtk.Window()
self.i = labvcnc.ini(os.environ['INI_FILE_NAME'])
self.s = labvcnc.stat()
self.c = labvcnc.command()
self.builder = builder
self.prefFile = self.i.find('LBV', 'MACHINE') + '.pref'
self.gui = self.i.find('DISPLAY', 'DISPLAY').lower()
self.configFile = self.i.find('LBV', 'MACHINE').lower() + '_wizards.cfg'
self.builder.get_object('hbox1').connect('destroy', self.on_shutdown)
self.tmpDir = ('/tmp/plasmac_wizards')
if not os.path.isdir(self.tmpDir):
os.mkdir(self.tmpDir)
self.fWizard = '{}/wizard.ngc'.format(self.tmpDir)
self.check_settings()
self.set_theme()
for wizard in ['line', 'circle', 'triangle', 'rectangle', 'polygon', 'bolt-circle', 'slot', 'star', 'gusset']:
pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(
filename='./wizards/images/{}-thumb.png'.format(wizard),
width=60,
height=60)
image = gtk.Image()
image.set_from_pixbuf(pixbuf)
self.builder.get_object('{}'.format(wizard)).set_image(image)
self.button_setup()
self.builder.get_object('button10').connect('realize', self.set_style)
self.initialized = True
gobject.timeout_add(100, self.periodic)
def __init__(self, halcomp, widgets, paths):
self.hal = halcomp
self.w = widgets
self.stat = labvcnc.stat()
self.cmnd = labvcnc.command()
self.error = labvcnc.error_channel()
self.PATH = paths.CONFIGPATH
self.IMAGE_PATH = paths.IMAGEDIR
self.STYLE = Styles(widgets, paths)
def __init__(self):
self.i = labvcnc.ini(os.environ['INI_FILE_NAME'])
self.c = labvcnc.command()
self.s = labvcnc.stat()
self.gui = self.i.find('DISPLAY', 'DISPLAY').lower()
self.configFile = '{}_wizards.cfg'.format(
self.i.find('LBV', 'MACHINE').lower())
self.fNgc = ''
self.fCode = ''
self.previewed = False
self.data_changed = True
def __init__(self, command=None, status=None, error=None):
"""init docs"""
self.command = command
self.status = status
self.error = error
if not self.command:
self.command = labvcnc.command()
if not self.status:
self.status = labvcnc.stat()
if not self.error:
self.error = labvcnc.error_channel()
def __init__(self, halcomp, builder, useropts):
self.W = gtk.Window()
self.halcomp = halcomp
self.builder = builder
self.i = labvcnc.ini(os.environ['INI_FILE_NAME'])
self.s = labvcnc.stat()
self.c = labvcnc.command()
self.prefFile = self.i.find('LBV', 'MACHINE') + '.pref'
self.iniButtonName = ['Names']
self.iniButtonCode = ['Codes']
self.probePressed = False
self.probeTimer = 0
self.probeButton = ''
self.cutType = 0
self.inFile = ''
self.cutButton = ''
for button in range(1, 5):
bname = self.i.find('PLASMAC',
'BUTTON_' + str(button) + '_NAME') or '0'
self.iniButtonName.append(bname)
code = self.i.find('PLASMAC', 'BUTTON_' + str(button) + '_CODE')
self.iniButtonCode.append(code)
if code == 'cut-type':
self.cutButton = 'button{}'.format(button)
if bname != '0':
bname = bname.split('\\')
if len(bname) > 1:
blabel = bname[0] + '\n' + bname[1]
else:
blabel = bname[0]
self.builder.get_object('button' +
str(button)).set_label(blabel)
self.builder.get_object('button' +
str(button)).children()[0].set_justify(
gtk.JUSTIFY_CENTER)
if 'change-consumables' in code:
ccParm = self.i.find(
'PLASMAC', 'BUTTON_' + str(button) + '_CODE').replace(
'change-consumables', '').replace(' ',
'').lower() or None
if ccParm:
self.consumable_change_setup(ccParm)
else:
self.dialog_error(
'Parameters required for consumable change\n\nCheck .ini file settings\n'
)
self.set_theme()
self.builder.get_object('button1').connect('realize', self.set_style)
gobject.timeout_add(100, self.periodic)
def __init__(self, master):
global DBG_state
DBG_state = master._dbg
self.lbv = labvcnc
self.lbvstat = labvcnc.stat()
self.lbvcommand = labvcnc.command()
self.return_to_mode = -1 # if not -1 return to the mode specified
self.sb = 0
self.jog_velocity = 100.0 / 60.0
self.angular_jog_velocity = 3600 / 60
self._mdi = 0
self.isjogging = [0, 0, 0, 0, 0, 0, 0, 0, 0]
self.restart_line_number = self.restart_reset_line = 0
try:
handlers,self.handler_module,self.handler_instance = \
load_handlers([CONFIGDIR], self.lbvstat, self.lbvcommand,self, master)
except Exception, e:
print e
def __init__(self, halcomp,builder,useropts):
self.W = gtk.Window()
self.halcomp = halcomp
self.builder = builder
self.i = labvcnc.ini(os.environ['INI_FILE_NAME'])
self.upgrade_check()
self.c = labvcnc.command()
self.s = labvcnc.stat()
self.cutTypePin = hal_glib.GPin(halcomp.newpin('cut-type', hal.HAL_S32, hal.HAL_IN))
self.materialNumberPin = hal_glib.GPin(halcomp.newpin('material-change-number', hal.HAL_S32, hal.HAL_IN))
self.materialChangePin = hal_glib.GPin(halcomp.newpin('material-change', hal.HAL_S32, hal.HAL_IN))
self.firstMaterialPin = hal_glib.GPin(halcomp.newpin('first-material', hal.HAL_S32, hal.HAL_IN))
self.thcEnablePin = hal_glib.GPin(halcomp.newpin('thc-enable-out', hal.HAL_BIT, hal.HAL_OUT))
self.materialNumberPin.connect('value-changed', self.material_change_number_changed)
self.materialChangePin.connect('value-changed', self.material_change_changed)
self.firstMaterialPin.connect('value-changed', self.first_material_changed)
self.idlePin = hal_glib.GPin(halcomp.newpin('program-is-idle', hal.HAL_BIT, hal.HAL_IN))
hal.connect('plasmac_run.program-is-idle', 'plasmac:program-is-idle')
self.idlePin.connect('value-changed', self.idle_changed)
self.previewPin = hal_glib.GPin(halcomp.newpin('preview-tab', hal.HAL_BIT, hal.HAL_IN))
self.thcFeedRate = (float(self.i.find('AXIS_Z', 'MAX_VELOCITY')) * \
float(self.i.find('AXIS_Z', 'OFFSET_AV_RATIO'))) * 60
hal.set_p('plasmac.thc-feed-rate','{}'.format(self.thcFeedRate))
self.configFile = self.i.find('LBV', 'MACHINE').lower() + '_run.cfg'
self.prefFile = self.i.find('LBV', 'MACHINE') + '.pref'
self.materialFile = self.i.find('LBV', 'MACHINE').lower() + '_material.cfg'
self.materialFileDict = {}
self.materialDict = {}
self.configDict = {}
self.materialNumList = []
hal.set_p('plasmac.mode','{}'.format(int(self.i.find('PLASMAC','MODE') or '0')))
self.oldMode = 9
self.oldMaterial = -1
self.materialUpdate = False
self.autoChange = False
self.manualChange = False
self.configure_widgets()
self.load_settings()
self.check_material_file()
self.get_material()
self.set_theme()
gobject.timeout_add(100, self.periodic)
def __init__(self, halcomp, widgets, paths):
self.hal = halcomp
self.w = widgets
self.stat = labvcnc.stat()
self.cmnd = labvcnc.command()
self.error = labvcnc.error_channel()
self.jog_velocity = 10.0
self.PATH = paths.CONFIGPATH
self.IMAGE_PATH = paths.IMAGEDIR
#print paths.CONFIGPATH
# connect to GStat to catch labvcnc events
STATUS.connect('state-estop', self.say_estop)
STATUS.connect('state-on', self.on_state_on)
STATUS.connect('state-off', self.on_state_off)
STATUS.connect('jograte-changed', self.on_jograte_changed)
STATUS.connect('periodic', self.on_periodic)
# Read user preferences
self.desktop_notify = PREFS.getpref('desktop_notify', True, bool)
self.shutdown_check = PREFS.getpref('shutdown_check', True, bool)
def __init__(self, stat = None):
gobject.GObject.__init__(self)
self.stat = stat or labvcnc.stat()
self.cmd = labvcnc.command()
self._status_active = False
self.old = {}
self.old['tool-prep-number'] = 0
try:
self.stat.poll()
self.merge()
except:
pass
self.current_jog_rate = 15
self.current_angular_jog_rate = 360
self.current_jog_distance = 0
self.current_jog_distance_text =''
self.current_jog_distance_angular= 0
self.current_jog_distance_angular_text =''
self.selected_joint = -1
self.selected_axis = ''
self._is_all_homed = False
self.set_timer()
timeout = 1.0
#
# set up pins
# shell out to halcmd to net our pins to where they need to go
#
h = hal.component("python-ui")
h.ready()
#
# connect to LabvCNC
#
c = labvcnc.command()
s = labvcnc.stat()
e = labvcnc.error_channel()
l = labvcnc_util.LabvCNC(command=c, status=s, error=e)
c.state(labvcnc.STATE_ESTOP_RESET)
c.state(labvcnc.STATE_ON)
c.home(0)
c.home(1)
c.home(2)
l.wait_for_home([1, 1, 1, 0, 0, 0, 0, 0, 0])
c.mode(labvcnc.MODE_MDI)
c.mdi("O<obug> call [0]")
def __init__(self, timeout=2):
self.c = labvcnc.command()
self.e = labvcnc.error_channel()
self.s = labvcnc.stat()
self.timeout = timeout
def __init__(self, toolfile=None, *a, **kw):
super(ToolEdit, self).__init__()
self.lbvstat = labvcnc.stat()
self.hash_check = None
self.lathe_display_type = True
self.toolfile = toolfile
self.num_of_col = 1
self.font = "sans 12"
self.hide_columns = ''
self.toolinfo_num = 0
self.toolinfo = []
self.wTree = gtk.Builder()
self.wTree.set_translation_domain("labvcnc") # for locale translations
self.wTree.add_from_file(os.path.join(datadir, "tooledit_gtk.glade"))
# connect the signals from Glade
dic = {
"on_delete_clicked": self.delete,
"on_add_clicked": self.add,
"on_reload_clicked": self.reload,
"on_save_clicked": self.save,
"cell_toggled": self.toggled
}
self.wTree.connect_signals(dic)
self.treeview1 = self.wTree.get_object("treeview1")
self.treeview1.connect("key-release-event",
self.on_tree_navigate_key_press, None)
# for raw view 1:
# toggle button useable
renderer = self.wTree.get_object("cell_toggle1")
renderer.set_property('activatable', True)
# make colums editable
self.tool_cell_list = "cell_tool#","cell_pos","cell_x","cell_y","cell_z","cell_a","cell_b","cell_c","cell_u","cell_v","cell_w","cell_d", \
"cell_front","cell_back","cell_orient","cell_comments"
for col, name in enumerate(self.tool_cell_list):
#print name,col
renderer = self.wTree.get_object(name + '1')
renderer.connect('edited', self.col_editted, col + 1, None)
renderer.props.editable = True
self.all_label = self.wTree.get_object("all_label")
# for lathe wear view2:
# make columns editable
temp =[ ("cell_x2",3),("cell_z2",5),("cell_front2",13),("cell_back2",14), \
("cell_orient2",15), ("cell_comments2",16)]
for name, col in temp:
renderer = self.wTree.get_object(name)
renderer.connect('edited', self.col_editted, col, 'wear')
renderer.props.editable = True
# Hide columns we don't want to see
self.set_col_visible(list='spyabcuvwdijq', bool=False, tab='2')
self.wear_label = self.wTree.get_object("wear_label")
# for tool offsets view 3:
# make columns editable
temp =[ ("cell_x3",3),("cell_z3",5),("cell_front3",13),("cell_back3",14), \
("cell_orient3",15), ("cell_comments3",16)]
for name, col in temp:
renderer = self.wTree.get_object(name)
renderer.connect('edited', self.col_editted, col, 'tool')
renderer.props.editable = True
# Hide columns we don't want to see
self.set_col_visible(list='spyabcuvwdij', bool=False, tab='3')
self.tool_label = self.wTree.get_object("tool_label")
# global references
self.model = self.wTree.get_object("liststore1")
self.notebook = self.wTree.get_object("tool_offset_notebook")
self.all_window = self.wTree.get_object("all_window")
self.wear_window = self.wTree.get_object("wear_window")
self.tool_window = self.wTree.get_object("tool_window")
self.view1 = self.wTree.get_object("treeview1")
self.view2 = self.wTree.get_object("treeview2")
# sort routine for tool diameter
def compare(model, row1, row2, user_data=None):
sort_column, _ = model.get_sort_column_id()
value1 = model.get_value(row1, sort_column)
value2 = model.get_value(row2, sort_column)
return cmp(value1, value2)
model = self.view1.get_model()
model.set_sort_func(12, compare)
#self.view2.connect('button_press_event', self.on_treeview2_button_press_event)
self.view2.connect("key-release-event",
self.on_tree_navigate_key_press, 'wear')
self.selection = self.view2.get_selection()
self.selection.set_mode(gtk.SELECTION_SINGLE)
self.view3 = self.wTree.get_object("treeview3")
#self.view3.connect('button_press_event', self.on_treeview2_button_press_event)
self.view3.connect("key-release-event",
self.on_tree_navigate_key_press, 'tool')
self.apply = self.wTree.get_object("apply")
self.buttonbox = self.wTree.get_object("buttonbox")
self.tool_filter = self.wTree.get_object("tool_modelfilter")
self.tool_filter.set_visible_func(self.match_type, False)
self.wear_filter = self.wTree.get_object("wear_modelfilter")
self.wear_filter.set_visible_func(self.match_type, True)
# reparent tooledit box from Glades tp level window to tooledit's VBox
window = self.wTree.get_object("tooledit_box")
window.reparent(self)
# If the toolfile was specified when tooledit was created load it
if toolfile:
self.reload(None)
# check the ini file if display-type: LATHE is set
try:
self.inifile = labvcnc.ini(INIPATH)
test = self.inifile.find("DISPLAY", "LATHE")
if test == '1' or test == 'True':
self.lathe_display_type = True
self.set_lathe_display(True)
else:
self.lathe_display_type = False
self.set_lathe_display(False)
except:
pass
# check labvcnc status every second
gobject.timeout_add(1000, self.periodic_check)
def periodic_radiobuttons(self):
self.radiobutton_mask = 1
s = labvcnc.stat()
s.poll()
# Show effect of external override inputs
self.fo_val = s.feedrate * 100
self.so_val = s.spindle[0]['override'] * 100
self.mv_val = s.max_velocity * 60
am = s.axis_mask
if not self.resized_wheelbuttons:
at = self.wTree.get_widget("axis_table")
for i in range(9):
b = [
"wheelx", "wheely", "wheelz", "wheela", "wheelb", "wheelc",
"wheelu", "wheelv", "wheelw"
][i]
w = self.wTree.get_widget(b)
if not (am & (1 << i)):
at.remove(w)
if (am & 0700) == 0:
at.resize(3, 2)
if (am & 070) == 0:
at.resize(3, 1)
self.wTree.get_widget("wheel_hbox").set_homogeneous(1)
self.resized_wheelbuttons = 1
self.wTree.get_widget("scrolling").set_sensitive(self.tab == 3)
if self.tab != 3 and self.wheel == "scrolling":
self.jogsettings_activate(0)
self.wheel = "fo"
set_active(self.wTree.get_widget("wheelx"), self.wheelxyz == 0)
set_active(self.wTree.get_widget("wheely"), self.wheelxyz == 1)
set_active(self.wTree.get_widget("wheelz"), self.wheelxyz == 2)
set_active(self.wTree.get_widget("wheela"), self.wheelxyz == 3)
set_active(self.wTree.get_widget("wheelb"), self.wheelxyz == 4)
set_active(self.wTree.get_widget("wheelc"), self.wheelxyz == 5)
set_active(self.wTree.get_widget("wheelu"), self.wheelxyz == 6)
set_active(self.wTree.get_widget("wheelv"), self.wheelxyz == 7)
set_active(self.wTree.get_widget("wheelw"), self.wheelxyz == 8)
set_active(self.wTree.get_widget("wheelinc1"), self.wheelinc == 0)
set_active(self.wTree.get_widget("wheelinc2"), self.wheelinc == 1)
set_active(self.wTree.get_widget("wheelinc3"), self.wheelinc == 2)
set_active(self.wTree.get_widget("fo"), self.wheel == "fo")
set_active(self.wTree.get_widget("so"), self.wheel == "so")
set_active(self.wTree.get_widget("mv"), self.wheel == "mv")
set_active(self.wTree.get_widget("jogging"), self.wheel == "jogging")
set_active(self.wTree.get_widget("scrolling"),
self.wheel == "scrolling")
set_active(self.wTree.get_widget("pointer_show"),
not self.invisible_cursor)
set_active(self.wTree.get_widget("pointer_hide"),
self.invisible_cursor)
set_active(self.wTree.get_widget("toolset_workpiece"), not self.g10l11)
set_active(self.wTree.get_widget("toolset_fixture"), self.g10l11)
self.radiobutton_mask = 0
if self.wheel == "jogging":
self.hal.jogaxis(self.wheelxyz)
else:
# disable all
self.hal.jogaxis(-1)
if self.wheel == "scrolling":
incs = ["100", "10", "1"]
elif self.wheelxyz == 3 or self.wheelxyz == 4 or self.wheelxyz == 5:
incs = ["1.0", "0.1", "0.01"]
elif self.machine_units_mm:
incs = ["0.1", "0.01", "0.001"]
else:
incs = ["0.01", "0.001", "0.0001"]
set_label(self.wTree.get_widget("wheelinc1").child, incs[0])
set_label(self.wTree.get_widget("wheelinc2").child, incs[1])
set_label(self.wTree.get_widget("wheelinc3").child, incs[2])
self.hal.jogincrement(self.wheelinc, map(float, incs))
d = self.hal.wheel()
if self.wheel == "fo":
self.fo_val += d
if self.fo_val < 0: self.fo_val = 0
if d != 0: self.labvcnc.feed_override(self.fo_val)
if self.wheel == "so":
self.so_val += d
if self.so_val < 0: self.so_val = 0
if d != 0: self.labvcnc.spindle_override(self.so_val)
if self.wheel == "mv":
if self.machine_units_mm:
self.mv_val += 20 * d
else:
self.mv_val += d
if self.mv_val < 0: self.mv_val = 0
if d != 0:
self.labvcnc.max_velocity(self.mv_val)
self.labvcnc.continuous_jog_velocity(self.mv_val)
if self.wheel == "scrolling":
d0 = d * 10**(2 - self.wheelinc)
if d != 0: self.listing.next(None, d0)
set_label(self.wTree.get_widget("fo").child, "FO: %d%%" % self.fo_val)
set_label(self.wTree.get_widget("so").child, "SO: %d%%" % self.so_val)
set_label(self.wTree.get_widget("mv").child, "MV: %d" % self.mv_val)
return True
def __init__(self, joint_number=0):
super(Combi_DRO, self).__init__()
# we have to distinguish this, as we use the joints number to check homing
# and we do need the axis to check for the positions
# this is needed if non trivial kinematics are used or just a lathe,
# as the lathe has only two joints, but Z will be the third value in position feedback
self.axis_no = self.joint_no = joint_number
# get the necessary connections to labvcnc
self.labvcnc = labvcnc
self.status = labvcnc.stat()
self.gstat = GStat()
# set some default values'
self._ORDER = ["Rel", "Abs", "DTG"]
self.system = "Rel"
self.homed = False
self.homed_color = gtk.gdk.Color("green")
self.unhomed_color = gtk.gdk.Color("red")
self.abs_color = gtk.gdk.Color("blue")
self.rel_color = gtk.gdk.Color("black")
self.dtg_color = gtk.gdk.Color("yellow")
self.mm_text_template = "%10.3f"
self.imperial_text_template = "%9.4f"
self.font_size = 25
self.metric_units = True
self.machine_units = _MM
self.unit_convert = 1
self._auto_units = True
self.toggle_readout = True
self.cycle_time = 150
# Make the GUI and connect signals
self.eventbox = gtk.EventBox()
self.eventbox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("black"))
self.add(self.eventbox)
vbox_main = gtk.VBox(False, 0)
self.eventbox.add(vbox_main)
hbox_up = gtk.HBox(False, 0)
vbox_main.pack_start(hbox_up)
attr = self._set_attributes((0, 0, 0), (65535, 0, 0),
(self.font_size * 1000, 0, -1),
(600, 0, -1))
self.lbl_axisletter = gtk.Label(_AXISLETTERS[self.axis_no])
self.lbl_axisletter.set_attributes(attr)
hbox_up.pack_start(self.lbl_axisletter, False, False)
vbox_ref_type = gtk.VBox(False, 0)
hbox_up.pack_start(vbox_ref_type, False, False)
lbl_space = gtk.Label("")
vbox_ref_type.pack_start(lbl_space)
attr = self._set_attributes((0, 0, 0), (65535, 0, 0),
(int(self.font_size * 1000 / 2.5), 0, -1),
(600, 0, -1))
self.lbl_sys_main = gtk.Label(self.system)
vbox_ref_type.pack_start(self.lbl_sys_main, False, False)
self.lbl_sys_main.set_attributes(attr)
self.main_dro = gtk.Label("9999.999")
hbox_up.pack_start(self.main_dro)
self.main_dro.set_alignment(1.0, 0.5)
attr = self._set_attributes((0, 0, 0), (65535, 0, 0),
(self.font_size, 0, -1), (600, 0, -1))
self.main_dro.set_attributes(attr)
hbox_down = gtk.HBox(False, 5)
vbox_main.pack_start(hbox_down)
self.lbl_sys_left = gtk.Label("Abs")
hbox_down.pack_start(self.lbl_sys_left)
attr = self._set_attributes((0, 0, 0), (65535, 0, 0),
(int(self.font_size * 1000 / 2.5), 0, -1),
(600, 0, -1))
self.lbl_sys_left.set_attributes(attr)
self.dro_left = gtk.Label("-11.111")
hbox_down.pack_start(self.dro_left)
self.dro_left.set_alignment(1.0, 0.5)
self.dro_left.set_attributes(attr)
self.lbl_sys_right = gtk.Label("DTG")
hbox_down.pack_start(self.lbl_sys_right)
self.lbl_sys_right.set_attributes(attr)
self.dro_right = gtk.Label("22.222")
hbox_down.pack_start(self.dro_right)
self.dro_right.set_alignment(1.0, 0.5)
self.dro_right.set_attributes(attr)
self.eventbox.connect("button_press_event", self._on_eventbox_clicked)
self.show_all()
self.gstat.connect('not-all-homed', self._not_all_homed)
self.gstat.connect('all-homed', self._all_homed)
self.gstat.connect('homed', self._homed)
# This try is only needed because while working with glade
# labvcnc may not be working
try:
self.inifile = self.labvcnc.ini(INIPATH)
# check the ini file if UNITS are set to mm"
# first check the global settings
units = self.inifile.find("TRAJ", "LINEAR_UNITS")
if units == None:
# else then the X axis units
units = self.inifile.find("AXIS_0", "UNITS")
except:
units = "inch"
if units == "mm" or units == "metric" or units == "1.0":
self.machine_units = _MM
else:
self.machine_units = _INCH
# add the timer at a period of 100 ms
gobject.timeout_add(self.cycle_time, self._periodic)
def __init__(self, inifile):
display_mode = ( gtk.gdkgl.MODE_RGB | gtk.gdkgl.MODE_DEPTH |
gtk.gdkgl.MODE_DOUBLE )
glconfig = gtk.gdkgl.Config(mode=display_mode)
gtk.gtkgl.widget.DrawingArea.__init__(self, glconfig)
glnav.GlNavBase.__init__(self)
def C(s):
a = self.colors[s + "_alpha"]
s = self.colors[s]
return [int(x * 255) for x in s + (a,)]
self.inifile = inifile
self.logger = labvcnc.positionlogger(labvcnc.stat(),
C('backplotjog'),
C('backplottraverse'),
C('backplotfeed'),
C('backplotarc'),
C('backplottoolchange'),
C('backplotprobing'),
self.get_geometry()
)
thread.start_new_thread(self.logger.start, (.01,))
rs274.glcanon.GlCanonDraw.__init__(self, labvcnc.stat(), self.logger)
self.current_view = 'z'
self.select_primed = None
self.connect_after('realize', self.realize)
self.connect('configure_event', self.reshape)
self.connect('map_event', self.map)
self.connect('expose_event', self.expose)
self.connect('motion-notify-event', self.motion)
self.connect('button-press-event', self.pressed)
self.connect('button-release-event', self.select_fire)
self.connect('scroll-event', self.scroll)
self.add_events(gtk.gdk.POINTER_MOTION_MASK)
self.add_events(gtk.gdk.POINTER_MOTION_HINT_MASK)
self.add_events(gtk.gdk.BUTTON_MOTION_MASK)
self.add_events(gtk.gdk.BUTTON_PRESS_MASK)
self.add_events(gtk.gdk.BUTTON_RELEASE_MASK)
self.fingerprint = ()
self.lat = 0
self.minlat = -90
self.maxlat = 90
self.highlight_line = None
self.program_alpha = False
self.use_joints_mode = False
self.use_commanded = True
self.show_limits = True
self.show_extents_option = True
self.show_live_plot = True
self.show_velocity = True
self.metric_units = True
self.show_program = True
self.show_rapids = True
self.use_relative = True
self.show_tool = True
self.show_dtg = True
self.grid_size = 0.0
temp = inifile.find("DISPLAY", "LATHE")
self.lathe_option = bool(temp == "1" or temp == "True" or temp == "true" )
self.foam_option = bool(inifile.find("DISPLAY", "FOAM"))
self.show_offsets = False
self.use_default_controls = True
self.mouse_btn_mode = 0
self.a_axis_wrapped = inifile.find("AXIS_A", "WRAPPED_ROTARY")
self.b_axis_wrapped = inifile.find("AXIS_B", "WRAPPED_ROTARY")
self.c_axis_wrapped = inifile.find("AXIS_C", "WRAPPED_ROTARY")
live_axis_count = 0
for i,j in enumerate("XYZABCUVW"):
if self.stat.axis_mask & (1<<i) == 0: continue
live_axis_count += 1
self.num_joints = int(inifile.find("KINS", "JOINTS") or live_axis_count)
def __init__(self, halcomp, widgets):
self.hal = halcomp
self.w = widgets
self.stat = labvcnc.stat()
self.cmnd = labvcnc.command()
def __init__(self, parent=None):
super(Lcnc_3dGraphics, self).__init__(parent)
glnav.GlNavBase.__init__(self)
def C(s):
a = self.colors[s + "_alpha"]
s = self.colors[s]
return [int(x * 255) for x in s + (a, )]
# requires labvcnc running before laoding this widget
inifile = os.environ.get('INI_FILE_NAME', '/dev/null')
self.inifile = labvcnc.ini(inifile)
self.logger = labvcnc.positionlogger(labvcnc.stat(), C('backplotjog'),
C('backplottraverse'),
C('backplotfeed'),
C('backplotarc'),
C('backplottoolchange'),
C('backplotprobing'),
self.get_geometry())
# start tracking labvcnc position so we can plot it
thread.start_new_thread(self.logger.start, (.01, ))
glcanon.GlCanonDraw.__init__(self, labvcnc.stat(), self.logger)
# set defaults
self.current_view = 'p'
self.fingerprint = ()
self.select_primed = None
self.lat = 0
self.minlat = -90
self.maxlat = 90
self._current_file = None
self.highlight_line = None
self.program_alpha = False
self.use_joints_mode = False
self.use_commanded = True
self.show_limits = True
self.show_extents_option = True
self.gcode_properties = None
self.show_live_plot = True
self.show_velocity = True
self.metric_units = True
self.show_program = True
self.show_rapids = True
self.use_relative = True
self.show_tool = True
self.show_dtg = True
self.grid_size = 0.0
temp = self.inifile.find("DISPLAY", "LATHE")
self.lathe_option = bool(temp == "1" or temp == "True"
or temp == "true")
self.foam_option = bool(self.inifile.find("DISPLAY", "FOAM"))
self.show_offsets = False
self.show_overlay = False
self.enable_dro = False
self.use_default_controls = True
self.mouse_btn_mode = 0
self.use_gradient_background = False
self.a_axis_wrapped = self.inifile.find("AXIS_A", "WRAPPED_ROTARY")
self.b_axis_wrapped = self.inifile.find("AXIS_B", "WRAPPED_ROTARY")
self.c_axis_wrapped = self.inifile.find("AXIS_C", "WRAPPED_ROTARY")
live_axis_count = 0
for i, j in enumerate("XYZABCUVW"):
if self.stat.axis_mask & (1 << i) == 0: continue
live_axis_count += 1
self.num_joints = int(
self.inifile.find("KINS", "JOINTS") or live_axis_count)
self.object = 0
self.xRot = 0
self.yRot = 0
self.zRot = 0
# add a 100ms timer to poll labvcnc stats
self.timer = QTimer()
self.timer.timeout.connect(self.poll)
self.timer.start(100)
self.Green = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
