# -*- coding: utf-8 -*-
"""
$Id$
Copyright 2011 Lars Kruse <devel@sumpfralle.de>
This file is part of PyCAM.
PyCAM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
PyCAM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with PyCAM. If not, see <http://www.gnu.org/licenses/>.
"""
import pycam.Plugins
import pycam.Gui.ControlsGTK
class GCodePreferences(pycam.Plugins.PluginBase):
DEPENDS = []
CATEGORIES = ["GCode"]
UI_FILE = "gcode_preferences.ui"
def setup(self):
if self.gui:
import gtk
notebook = self.gui.get_object("GCodePrefsNotebook")
self._pref_items = []
def clear_preferences():
for child in notebook.get_children():
notebook.remove(child)
# we need to clear the whole path down to the "real" item
parent = notebook
while not child in self._pref_items:
parent.remove(child)
parent = child
try:
child = child.get_children()[0]
except (AttributeError, IndexError):
# We encountered an invalid item (e.g. a label
# without children) or an empty item.
break
else:
# we found a valid child -> remove it
parent.remove(child)
def add_preferences_item(item, name):
if not item in self._pref_items:
self._pref_items.append(item)
item.unparent()
if not isinstance(item, gtk.Frame):
# create a simple default frame if none was given
frame = gtk.Frame(name)
frame.get_label_widget().set_markup("<b>%s</b>" % name)
frame.set_shadow_type(gtk.SHADOW_NONE)
align = gtk.Alignment()
align.set_padding(3, 0, 12, 0)
frame.add(align)
frame.show()
align.add(item)
align.show()
item.show()
item = frame
notebook.append_page(item, gtk.Label(name))
self.core.register_ui_section("gcode_preferences",
add_preferences_item, clear_preferences)
general_widget = pycam.Gui.ControlsGTK.ParameterSection()
general_widget.widget.show()
self.core.register_ui_section("gcode_general_parameters",
general_widget.add_widget, general_widget.clear_widgets)
self.core.register_ui("gcode_preferences", "General",
general_widget.widget)
self.core.register_ui("toolpath_handling", "Settings",
self.gui.get_object("PreferencesControls"))
self.gui.get_object("PreferencesButton").connect("clicked",
self._toggle_window, True)
self.gui.get_object("CloseButton").connect("clicked",
self._toggle_window, False)
self.window = self.gui.get_object("GCodePreferencesWindow")
self.window.connect("delete-event", self._toggle_window, False)
return True
def teardown(self):
if self.gui:
self._toggle_window(False)
def _toggle_window(self, *args):
status = args[-1]
if status:
self.window.show()
else:
self.window.hide()
# don't destroy the window
return True
class GCodeSafetyHeight(pycam.Plugins.PluginBase):
DEPENDS = ["GCodePreferences"]
CATEGORIES = ["GCode"]
def setup(self):
self.safety_height = pycam.Gui.ControlsGTK.InputNumber(digits=0,
change_handler=lambda *args: \
self.core.emit_event("visual-item-updated"))
# TODO: this should be done via parameter groups based on postprocessors
self.safety_height.get_widget().show()
self.core.register_ui("gcode_general_parameters", "Safety Height",
self.safety_height.get_widget(), weight=20)
self.core.add_item("gcode_safety_height",
self.safety_height.get_value, self.safety_height.set_value)
self.register_state_item("settings/gcode/gcode_safety_height",
self.safety_height.get_value, self.safety_height.set_value)
return True
def teardown(self):
self.clear_state_items()
del self.core["gcode_safety_height"]
self.safety_height.destroy()
class GCodeFilenameExtension(pycam.Plugins.PluginBase):
DEPENDS = ["GCodePreferences"]
CATEGORIES = ["GCode"]
def setup(self):
self.filename_extension = pycam.Gui.ControlsGTK.InputString(
max_length=6)
# TODO: this should be done via parameter groups based on postprocessors
self.filename_extension.get_widget().show()
self.core.register_ui("gcode_general_parameters",
"Custom GCode filename extension",
self.filename_extension.get_widget(), weight=80)
self.core.add_item("gcode_filename_extension",
self.filename_extension.get_value,
self.filename_extension.set_value)
return True
def teardown(self):
del self.core["gcode_filename_extension"]
self.filename_extension.destroy()
class GCodeStepWidth(pycam.Plugins.PluginBase):
DEPENDS = ["GCodePreferences"]
CATEGORIES = ["GCode"]
def setup(self):
table = pycam.Gui.ControlsGTK.ParameterSection()
self.core.register_ui("gcode_preferences", "Step precision",
table.widget)
self.core.register_ui_section("gcode_step_width",
table.add_widget, table.clear_widgets)
self.controls = []
for key in "xyz":
control = pycam.Gui.ControlsGTK.InputNumber(digits=8, start=0.0001,
increment=0.00005)
# TODO: this should be done via parameter groups based on postprocessors
name = "gcode_minimum_step_%s" % key
control.get_widget().show()
self.core.add_item(name, control.get_value, control.set_value)
self.core.register_ui("gcode_step_width", key.upper(),
control.get_widget(), weight="xyz".index(key))
self.register_state_item("settings/gcode/%s" % name,
control.get_value, control.set_value)
self.controls.append(control)
return True
def teardown(self):
self.clear_state_items()
while self.controls:
self.core.unregister_ui("gcode_step_width", self.controls.pop())
for key in "xyz":
del self.core["gcode_minimum_step_%s" % key]
class GCodeSpindle(pycam.Plugins.PluginBase):
DEPENDS = ["GCodePreferences"]
CATEGORIES = ["GCode"]
def setup(self):
self._table = pycam.Gui.ControlsGTK.ParameterSection()
self.core.register_ui("gcode_preferences", "Spindle control",
self._table.widget)
self.core.register_ui_section("gcode_spindle",
self._table.add_widget, self._table.clear_widgets)
self.spindle_delay = pycam.Gui.ControlsGTK.InputNumber(digits=1)
# TODO: this should be done via parameter groups based on postprocessors
self.spindle_delay.get_widget().show()
self.core.register_ui("gcode_spindle",
"Delay (in seconds) after start/stop",
self.spindle_delay.get_widget(), weight=50)
self.core.add_item("gcode_spindle_delay",
self.spindle_delay.get_value,
self.spindle_delay.set_value)
self.spindle_enable = pycam.Gui.ControlsGTK.InputCheckBox(
change_handler=self.update_widgets)
self.spindle_enable.get_widget().show()
self.core.register_ui("gcode_spindle", "Start / Stop Spindle (M3/M5)",
self.spindle_enable.get_widget(), weight=10)
self.update_widgets()
return True
def teardown(self):
del self.core["gcode_spindle_delay"]
self.core.unregister_ui("gcode_spindle",
self.spindle_delay.get_widget())
self.core.unregister_ui("gcode_spindle",
self.spindle_enable.get_widget())
self.core.unregister_ui_section("gcode_spindle")
self.core.unregister_ui("gcode_preferences", self._table.widget)
def update_widgets(self, widget=None):
widget = self.spindle_delay.get_widget()
widget.set_sensitive(self.spindle_enable.get_value())
class GCodeCornerStyle(pycam.Plugins.PluginBase):
DEPENDS = ["GCodePreferences"]
CATEGORIES = ["GCode"]
def setup(self):
table = pycam.Gui.ControlsGTK.ParameterSection()
self.core.register_ui("gcode_preferences", "Corner style",
table.widget)
self.core.register_ui_section("gcode_corner_style",
table.add_widget, table.clear_widgets)
self.motion_tolerance = pycam.Gui.ControlsGTK.InputNumber(digits=3)
# TODO: this should be done via parameter groups based on postprocessors
self.motion_tolerance.get_widget().show()
self.core.register_ui("gcode_corner_style", "Motion blending tolerance",
self.motion_tolerance.get_widget(), weight=30)
self.naive_tolerance = pycam.Gui.ControlsGTK.InputNumber(digits=3)
self.naive_tolerance.get_widget().show()
self.core.register_ui("gcode_corner_style", "Naive CAM tolerance",
self.naive_tolerance.get_widget(), weight=50)
self.path_mode = pycam.Gui.ControlsGTK.InputChoice((
("Exact path mode (G61)", "exact_path"),
("Exact stop mode (G61.1)", "exact_stop"),
("Continuous with maximum speed (G64)", "optimize_speed"),
("Continuous with tolerance (G64 P/Q)", "optimize_tolerance")))
self.path_mode.get_widget().connect("changed", self.update_widgets)
self.core.register_ui("gcode_corner_style", "Path mode",
self.path_mode.get_widget(), weight=10)
table.widget.show_all()
self.update_widgets()
return True
def teardown(self):
self.core.unregister_ui("gcode_corner_style",
self.motion_tolerance.get_widget())
self.core.unregister_ui("gcode_corner_style",
self.naive_tolerance.get_widget())
self.core.unregister_ui("gcode_corner_style",
self.path_mode.get_widget())
self.core.unregister_ui_section("gcode_corner_style")
def update_widgets(self, widget=None):
enable_tolerances = (self.path_mode.get_value() == "optimize_speed")
controls = (self.motion_tolerance, self.naive_tolerance)
for control in controls:
control.get_widget().set_sensitive(enable_tolerances)