#!/usr/bin/env python # -*- coding: utf-8 -*- """ $Id$ Copyright 2010 Lars Kruse 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 . """ import os import sys import datetime import gtk import gobject import webbrowser import ConfigParser import StringIO import pickle import logging import xml.etree.ElementTree as ET import pycam.Gui.Settings import pycam.Importers.CXFImporter import pycam.Importers.TestModel import pycam.Importers import pycam.Utils.log from pycam.Utils.locations import get_data_file_location, \ get_ui_file_location, get_external_program_location, \ get_all_program_locations import pycam.Utils import pycam.Plugins from pycam import VERSION import pycam.Physics.ode_physics import pycam.Utils.xml_handling GTKBUILD_FILE = "pycam-project.ui" GTKMENU_FILE = "menubar.xml" GTKRC_FILE_WINDOWS = "gtkrc_windows" PICKLE_PROTOCOL = 2 WINDOW_ICON_FILENAMES = ["logo_%dpx.png" % pixels for pixels in (16, 32, 48, 64, 128)] HELP_WIKI_URL = "http://sourceforge.net/apps/mediawiki/pycam/index.php?title=%s" FILTER_MODEL = (("All supported model filetypes", ("*.stl", "*.dxf", "*.svg", "*.eps", "*.ps")), ("STL models", "*.stl"), ("DXF contours", "*.dxf"), ("SVG contours", "*.svg"), ("PS contours", ("*.eps", "*.ps"))) FILTER_CONFIG = (("Config files", "*.conf"),) PREFERENCES_DEFAULTS = { "enable_ode": False, "unit": "mm", "default_task_settings_file": "", "show_model": True, "show_support_preview": True, "show_axes": True, "show_dimensions": True, "show_bounding_box": True, "show_toolpath": True, "show_drill": False, "show_directions": False, "color_background": {"red": 0.0, "green": 0.0, "blue": 0.0, "alpha": 1.0}, "color_model": {"red": 0.5, "green": 0.5, "blue": 1.0, "alpha": 1.0}, "color_support_preview": {"red": 0.8, "green": 0.8, "blue": 0.3, "alpha": 1.0}, "color_bounding_box": {"red": 0.3, "green": 0.3, "blue": 0.3, "alpha": 1.0}, "color_cutter": {"red": 1.0, "green": 0.2, "blue": 0.2, "alpha": 1.0}, "color_toolpath_cut": {"red": 1.0, "green": 0.5, "blue": 0.5, "alpha": 1.0}, "color_toolpath_return": {"red": 0.9, "green": 1.0, "blue": 0.1, "alpha": 0.4}, "color_material": {"red": 1.0, "green": 0.5, "blue": 0.0, "alpha": 1.0}, "color_grid": {"red": 0.75, "green": 1.0, "blue": 0.7, "alpha": 0.55}, "view_light": True, "view_shadow": True, "view_polygon": True, "view_perspective": True, "drill_progress_max_fps": 2, "gcode_safety_height": 25.0, "gcode_minimum_step_x": 0.0001, "gcode_minimum_step_y": 0.0001, "gcode_minimum_step_z": 0.0001, "gcode_path_mode": 0, "gcode_motion_tolerance": 0, "gcode_naive_tolerance": 0, "gcode_start_stop_spindle": True, "gcode_filename_extension": "", "gcode_spindle_delay": 3, "external_program_inkscape": "", "external_program_pstoedit": "", "touch_off_on_startup": False, "touch_off_on_tool_change": False, "touch_off_position_type": "absolute", "touch_off_position_x": 0.0, "touch_off_position_y": 0.0, "touch_off_position_z": 0.0, "touch_off_rapid_move": 0.0, "touch_off_slow_move": 1.0, "touch_off_slow_feedrate": 20, "touch_off_height": 0.0, "touch_off_pause_execution": False, } """ the listed items will be loaded/saved via the preferences file in the user's home directory on startup/shutdown""" MAX_UNDO_STATES = 10 FILENAME_DRAG_TARGETS = ("text/uri-list", "text-plain") log = pycam.Utils.log.get_logger() def get_icons_pixbuffers(): result = [] for icon_filename in WINDOW_ICON_FILENAMES: abs_filename = get_ui_file_location(icon_filename, silent=True) if abs_filename: try: result.append(gtk.gdk.pixbuf_new_from_file(abs_filename)) except gobject.GError, err_msg: # ignore icons that are not found log.debug("Failed to process window icon (%s): %s" \ % (abs_filename, err_msg)) else: log.debug("Failed to locate window icon: %s" % icon_filename) return result UI_FUNC_INDEX, UI_WIDGET_INDEX = range(2) WIDGET_NAME_INDEX, WIDGET_OBJ_INDEX, WIDGET_WEIGHT_INDEX, WIDGET_ARGS_INDEX = \ range(4) HANDLER_FUNC_INDEX, HANDLER_ARG_INDEX = range(2) EVENT_HANDLER_INDEX, EVENT_BLOCKER_INDEX = range(2) CHAIN_FUNC_INDEX, CHAIN_WEIGHT_INDEX = range(2) class EventCore(pycam.Gui.Settings.Settings): def __init__(self): super(EventCore, self).__init__() self.event_handlers = {} self.ui_sections = {} self.chains = {} self.state_dumps = [] self.namespace = {} def register_event(self, event, func, *args): if not event in self.event_handlers: assert EVENT_HANDLER_INDEX == 0 assert EVENT_BLOCKER_INDEX == 1 self.event_handlers[event] = [[], 0] assert HANDLER_FUNC_INDEX == 0 assert HANDLER_ARG_INDEX == 1 self.event_handlers[event][EVENT_HANDLER_INDEX].append((func, args)) def unregister_event(self, event, func): if event in self.event_handlers: removal_list = [] handlers = self.event_handlers[event] for index, item in enumerate(handlers[EVENT_HANDLER_INDEX]): if func == item[HANDLER_FUNC_INDEX]: removal_list.append(index) removal_list.reverse() for index in removal_list: handlers[EVENT_HANDLER_INDEX].pop(index) else: log.debug("Trying to unregister an unknown event: %s" % event) def emit_event(self, event, *args, **kwargs): log.debug2("Event emitted: %s" % str(event)) if event in self.event_handlers: if self.event_handlers[event][EVENT_BLOCKER_INDEX] != 0: return # prevent infinite recursion self.block_event(event) for handler in self.event_handlers[event][EVENT_HANDLER_INDEX]: func = handler[HANDLER_FUNC_INDEX] data = handler[HANDLER_ARG_INDEX] func(*(data + args), **kwargs) self.unblock_event(event) else: log.debug("No events registered for event '%s'" % str(event)) def block_event(self, event): if event in self.event_handlers: self.event_handlers[event][EVENT_BLOCKER_INDEX] += 1 else: log.debug("Trying to block an unknown event: %s" % str(event)) def unblock_event(self, event): if event in self.event_handlers: if self.event_handlers[event][EVENT_BLOCKER_INDEX] > 0: self.event_handlers[event][EVENT_BLOCKER_INDEX] -= 1 else: log.debug("Trying to unblock non-blocked event '%s'" % \ str(event)) else: log.debug("Trying to unblock an unknown event: %s" % str(event)) def register_ui_section(self, section, add_action, clear_action): if not section in self.ui_sections: self.ui_sections[section] = [None, None] self.ui_sections[section][UI_WIDGET_INDEX] = [] self.ui_sections[section][UI_FUNC_INDEX] = (add_action, clear_action) self._rebuild_ui_section(section) def unregister_ui_section(self, section): if section in self.ui_sections: ui_section = self.ui_sections[section] while ui_section[UI_WIDGET_INDEX]: ui_section[UI_WIDGET_INDEX].pop() del self.ui_sections[section] else: log.debug("Trying to unregister a non-existent ui section: %s" % \ str(section)) def _rebuild_ui_section(self, section): if section in self.ui_sections: ui_section = self.ui_sections[section] if ui_section[UI_FUNC_INDEX]: add_func, clear_func = ui_section[UI_FUNC_INDEX] ui_section[UI_WIDGET_INDEX].sort( key=lambda x: x[WIDGET_WEIGHT_INDEX]) clear_func() for item in ui_section[UI_WIDGET_INDEX]: if item[WIDGET_ARGS_INDEX]: args = item[WIDGET_ARGS_INDEX] else: args = {} add_func(item[WIDGET_OBJ_INDEX], item[WIDGET_NAME_INDEX], **args) else: log.debug("Failed to rebuild unknown ui section: %s" % str(section)) def register_ui(self, section, name, widget, weight=0, args_dict=None): if not section in self.ui_sections: self.ui_sections[section] = [None, None] self.ui_sections[section][UI_WIDGET_INDEX] = [] assert WIDGET_NAME_INDEX == 0 assert WIDGET_OBJ_INDEX == 1 assert WIDGET_WEIGHT_INDEX == 2 assert WIDGET_ARGS_INDEX == 3 current_widgets = [item[1] for item in self.ui_sections[section][UI_WIDGET_INDEX]] if (not widget is None) and (widget in current_widgets): log.debug("Tried to register widget twice: %s -> %s" % \ (section, name)) return self.ui_sections[section][UI_WIDGET_INDEX].append((name, widget, weight, args_dict)) self._rebuild_ui_section(section) def unregister_ui(self, section, widget): if (section in self.ui_sections) or (None in self.ui_sections): if not section in self.ui_sections: section = None ui_section = self.ui_sections[section] removal_list = [] for index, item in enumerate(ui_section[UI_WIDGET_INDEX]): if item[WIDGET_OBJ_INDEX] == widget: removal_list.append(index) removal_list.reverse() for index in removal_list: ui_section[UI_WIDGET_INDEX].pop(index) self._rebuild_ui_section(section) else: log.debug("Trying to unregister unknown ui section: %s" % section) def register_chain(self, name, func, weight=100): if not name in self.chains: self.chains[name] = [] self.chains[name].append((func, weight)) self.chains[name].sort(key=lambda item: item[CHAIN_WEIGHT_INDEX]) def unregister_chain(self, name, func): if name in self.chains: for index, data in enumerate(self.chains[name]): if data[CHAIN_FUNC_INDEX] == func: self.chains[name].pop(index) break else: log.debug("Trying to unregister unknown function from " + \ "%s: %s" % (name, func)) else: log.debug("Trying to unregister from unknown chain: %s" % name) def call_chain(self, name, *args, **kwargs): if name in self.chains: for data in self.chains[name]: data[CHAIN_FUNC_INDEX](*args, **kwargs) else: log.debug("Called an unknown chain: %s" % name) def dump_state(self): result = [] for plugin in self.get("plugin-manager").get_plugins(): if plugin.enabled: plugin.dump_state(result) root = ET.Element("pycam") for match, element in result: chain = match.split("/") if not hasattr(element, "findtext"): # not an instance of ET.Element element = pycam.Utils.xml_handling.get_xml(element, chain[-1]) parent = root if match: for component in chain[:-1]: next_item = parent.find(component) if not next_item is None: parent = next_item else: item = ET.SubElement(parent, component) parent = item parent.append(element) return os.linesep.join(pycam.Utils.xml_handling.get_xml_lines(root)) def reset_state(self): pass def register_namespace(self, name, value): if name in self.namespace: log.info("Trying to register the same key in namespace twice: " + \ str(name)) self.namespace[name] = value def unregister_namespace(self, name): if not name in self.namespace: log.info("Tried to unregister an unknown name from namespace: " + \ str(name)) def get_namespace(self): return self.namespace class ProjectGui(object): META_DATA_PREFIX = "PYCAM-META-DATA:" def __init__(self, no_dialog=False): self.settings = EventCore() self.gui_is_active = False # during initialization any dialog (e.g. "Unit change") is not allowed # we set the final value later self.no_dialog = True self._batch_queue = [] self._undo_states = [] self.gui = gtk.Builder() gtk_build_file = get_ui_file_location(GTKBUILD_FILE) if gtk_build_file is None: gtk.main_quit() self.gui.add_from_file(gtk_build_file) if pycam.Utils.get_platform() == pycam.Utils.PLATFORM_WINDOWS: gtkrc_file = get_ui_file_location(GTKRC_FILE_WINDOWS) if gtkrc_file: gtk.rc_add_default_file(gtkrc_file) gtk.rc_reparse_all_for_settings(gtk.settings_get_default(), True) self.window = self.gui.get_object("ProjectWindow") self.settings.set("main_window", self.window) # show stock items on buttons # increase the initial width of the window (due to hidden elements) self.window.set_default_size(400, -1) # initialize the RecentManager (TODO: check for Windows) if False and pycam.Utils.get_platform() == pycam.Utils.PLATFORM_WINDOWS: # The pyinstaller binary for Windows fails mysteriously when trying # to display the stock item. # Error message: Gtk:ERROR:gtkrecentmanager.c:1942:get_icon_fallback: assertion failed: (retval != NULL) self.recent_manager = None else: try: self.recent_manager = gtk.recent_manager_get_default() except AttributeError: # GTK 2.12.1 seems to have problems with "RecentManager" on # Windows. Sadly this is the version, that is shipped with the # "appunti" GTK packages for Windows (April 2010). # see http://www.daa.com.au/pipermail/pygtk/2009-May/017052.html self.recent_manager = None # file loading self.last_dirname = None self.last_task_settings_uri = None self.last_model_uri = None # define callbacks and accelerator keys for the menu actions for objname, callback, data, accel_key in ( ("LoadTaskSettings", self.load_task_settings_file, None, "t"), ("SaveTaskSettings", self.save_task_settings_file, lambda: self.last_task_settings_uri, None), ("SaveAsTaskSettings", self.save_task_settings_file, None, None), ("OpenModel", self.load_model_file, None, "o"), ("Quit", self.destroy, None, "q"), ("GeneralSettings", self.toggle_preferences_window, None, "p"), ("UndoButton", self._restore_undo_state, None, "z"), ("HelpUserManual", self.show_help, "User_Manual", "F1"), ("HelpIntroduction", self.show_help, "Introduction", None), ("HelpSupportedFormats", self.show_help, "SupportedFormats", None), ("HelpModelTransformations", self.show_help, "ModelTransformations", None), ("HelpToolTypes", self.show_help, "ToolTypes", None), ("HelpProcessSettings", self.show_help, "ProcessSettings", None), ("HelpBoundsSettings", self.show_help, "BoundsSettings", None), ("HelpTaskSetup", self.show_help, "TaskSetup", None), ("HelpGCodeExport", self.show_help, "GCodeExport", None), ("HelpTouchOff", self.show_help, "TouchOff", None), ("HelpSimulation", self.show_help, "Simulation", None), ("Help3DView", self.show_help, "3D_View", None), ("HelpServerMode", self.show_help, "ServerMode", None), ("HelpCommandLine", self.show_help, "CommandlineExamples", None), ("HelpHotkeys", self.show_help, "KeyboardShortcuts", None), ("ProjectWebsite", self.show_help, "http://pycam.sourceforge.net", None), ("DevelopmentBlog", self.show_help, "http://fab.senselab.org/pycam", None), ("Forum", self.show_help, "http://sourceforge.net/projects/pycam/forums", None), ("BugTracker", self.show_help, "http://sourceforge.net/tracker/?group_id=237831&atid=1104176", None), ("FeatureRequest", self.show_help, "http://sourceforge.net/tracker/?group_id=237831&atid=1104179", None)): item = self.gui.get_object(objname) action = "activate" if data is None: item.connect(action, callback) else: item.connect(action, callback, data) if accel_key: key, mod = gtk.accelerator_parse(accel_key) accel_path = "/%s" % objname item.set_accel_path(accel_path) gtk.accel_map_change_entry(accel_path, key, mod, True) # LinkButton does not work on Windows: https://bugzilla.gnome.org/show_bug.cgi?id=617874 if pycam.Utils.get_platform() == pycam.Utils.PLATFORM_WINDOWS: def open_url(widget, data=None): webbrowser.open(widget.get_uri()) gtk.link_button_set_uri_hook(open_url) # no undo is allowed at the beginning self.gui.get_object("UndoButton").set_sensitive(False) self.settings.register_event("model-change-before", self._store_undo_state) self.settings.register_event("model-change-after", lambda: self.settings.emit_event("visual-item-updated")) # set the availability of ODE self.enable_ode_control = self.gui.get_object("SettingEnableODE") self.settings.add_item("enable_ode", self.enable_ode_control.get_active, self.enable_ode_control.set_active) self.settings.register_event("parallel-processing-changed", self.update_ode_settings) # configure drag-n-drop for config files and models self.settings.set("configure-drag-drop-func", self.configure_drag_and_drop) self.settings.get("configure-drag-drop-func")(self.window) # other events self.window.connect("destroy", self.destroy) self.window.connect("delete-event", self.destroy) # the settings window self.gui.get_object("CloseSettingsWindow").connect("clicked", self.toggle_preferences_window, False) self.gui.get_object("ResetPreferencesButton").connect("clicked", self.reset_preferences) self.preferences_window = self.gui.get_object("GeneralSettingsWindow") self.preferences_window.connect("delete-event", self.toggle_preferences_window, False) self._preferences_window_position = None self._preferences_window_visible = False # "about" window self.about_window = self.gui.get_object("AboutWindow") self.about_window.set_version(VERSION) self.gui.get_object("About").connect("activate", self.toggle_about_window, True) # we assume, that the last child of the window is the "close" button # TODO: fix this ugly hack! self.gui.get_object("AboutWindowButtons").get_children()[-1].connect("clicked", self.toggle_about_window, False) self.about_window.connect("delete-event", self.toggle_about_window, False) # menu bar uimanager = gtk.UIManager() self.settings.set("gtk-uimanager", uimanager) self._accel_group = uimanager.get_accel_group() # send a "delete" event on "CTRL-w" for every window def handle_window_close(accel_group, window, *args): window.emit("delete-event", gtk.gdk.Event(gtk.gdk.DELETE)) self._accel_group.connect_group(ord('w'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_LOCKED, handle_window_close) self.settings.add_item("gtk-accel-group", lambda: self._accel_group) for obj in self.gui.get_objects(): if isinstance(obj, gtk.Window): obj.add_accel_group(self._accel_group) # preferences tab preferences_book = self.gui.get_object("PreferencesNotebook") def clear_preferences(): for child in preferences_book.get_children(): preferences_book.remove(child) def add_preferences_item(item, name): preferences_book.append_page(item, gtk.Label(name)) self.settings.register_ui_section("preferences", add_preferences_item, clear_preferences) for obj_name, label, priority in ( ("GeneralSettingsPrefTab", "General", -50), ("ProgramsPrefTab", "Programs", 50)): obj = self.gui.get_object(obj_name) obj.unparent() self.settings.register_ui("preferences", label, obj, priority) # general preferences general_prefs = self.gui.get_object("GeneralPreferencesBox") def clear_general_prefs(): for item in general_prefs.get_children(): general_prefs.remove(item) def add_general_prefs_item(item, name): general_prefs.pack_start(item, expand=False, padding=3) self.settings.register_ui_section("preferences_general", add_general_prefs_item, clear_general_prefs) for obj_name, priority in (("SettingEnableODE", 10), ("TaskSettingsDefaultFileBox", 30)): obj = self.gui.get_object(obj_name) obj.unparent() self.settings.register_ui("preferences_general", None, obj, priority) # set defaults self.cutter = None # add some dummies - to be implemented later ... self.settings.add_item("cutter", lambda: self.cutter) main_tab = self.gui.get_object("MainTabs") def clear_main_tab(): while main_tab.get_n_pages() > 0: main_tab.remove_page(0) def add_main_tab_item(item, name): main_tab.append_page(item, gtk.Label(name)) # TODO: move these to plugins, as well self.settings.register_ui_section("main", add_main_tab_item, clear_main_tab) main_window = self.gui.get_object("WindowBox") def clear_main_window(): main_window.foreach(lambda x: main_window.remove(x)) def add_main_window_item(item, name, **extra_args): # some widgets may want to override the defaults args = {"expand": False, "fill": False} args.update(extra_args) main_window.pack_start(item, **args) main_tab.unparent() self.settings.register_ui_section("main_window", add_main_window_item, clear_main_window) self.settings.register_ui("main_window", "Tabs", main_tab, -20, args_dict={"expand": True, "fill": True}) # autoload task settings file on startup autoload_enable = self.gui.get_object("AutoLoadTaskFile") autoload_box = self.gui.get_object("StartupTaskFileBox") autoload_source = self.gui.get_object("StartupTaskFile") # TODO: fix the extension filter #for one_filter in get_filters_from_list(FILTER_CONFIG): # autoload_source.add_filter(one_filter) # autoload_source.set_filter(one_filter) def get_autoload_task_file(autoload_source=autoload_source): if autoload_enable.get_active(): return autoload_source.get_filename() else: return "" def set_autoload_task_file(filename): if filename: autoload_enable.set_active(True) autoload_box.show() autoload_source.set_filename(filename) else: autoload_enable.set_active(False) autoload_box.hide() autoload_source.unselect_all() def autoload_enable_switched(widget, box): if not widget.get_active(): set_autoload_task_file(None) else: autoload_box.show() autoload_enable.connect("toggled", autoload_enable_switched, autoload_box) self.settings.add_item("default_task_settings_file", get_autoload_task_file, set_autoload_task_file) def disable_gui(): self.menubar.set_sensitive(False) main_tab.set_sensitive(False) def enable_gui(): self.menubar.set_sensitive(True) main_tab.set_sensitive(True) self.settings.register_event("gui-disable", disable_gui) self.settings.register_event("gui-enable", enable_gui) # configure locations of external programs for auto_control_name, location_control_name, browse_button, key in ( ("ExternalProgramInkscapeAuto", "ExternalProgramInkscapeControl", "ExternalProgramInkscapeBrowse", "inkscape"), ("ExternalProgramPstoeditAuto", "ExternalProgramPstoeditControl", "ExternalProgramPstoeditBrowse", "pstoedit")): self.gui.get_object(auto_control_name).connect("clicked", self._locate_external_program, key) location_control = self.gui.get_object(location_control_name) self.settings.add_item("external_program_%s" % key, location_control.get_text, location_control.set_text) self.gui.get_object(browse_button).connect("clicked", self._browse_external_program_location, key) # set the icons (in different sizes) for all windows gtk.window_set_default_icon_list(*get_icons_pixbuffers()) # load menu data gtk_menu_file = get_ui_file_location(GTKMENU_FILE) if gtk_menu_file is None: gtk.main_quit() uimanager.add_ui_from_file(gtk_menu_file) # make the actions defined in the GTKBUILD file available in the menu actiongroup = gtk.ActionGroup("menubar") for action in [action for action in self.gui.get_objects() if isinstance(action, gtk.Action)]: actiongroup.add_action(action) # the "pos" parameter is optional since 2.12 - we can remove it later uimanager.insert_action_group(actiongroup, pos=-1) # the "recent files" sub-menu if not self.recent_manager is None: recent_files_menu = gtk.RecentChooserMenu(self.recent_manager) recent_files_menu.set_name("RecentFilesMenu") recent_menu_filter = gtk.RecentFilter() case_converter = pycam.Utils.get_case_insensitive_file_pattern for filter_name, patterns in FILTER_MODEL: if not isinstance(patterns, (list, set, tuple)): patterns = [patterns] # convert it into a mutable list (instead of set/tuple) patterns = list(patterns) for index in range(len(patterns)): patterns[index] = case_converter(patterns[index]) for pattern in patterns: recent_menu_filter.add_pattern(pattern) recent_files_menu.add_filter(recent_menu_filter) recent_files_menu.set_show_numbers(True) # non-local files (without "file://") are not supported. yet recent_files_menu.set_local_only(False) # most recent files to the top recent_files_menu.set_sort_type(gtk.RECENT_SORT_MRU) # show only ten files recent_files_menu.set_limit(10) uimanager.get_widget("/MenuBar/FileMenu/OpenRecentModelMenu")\ .set_submenu(recent_files_menu) recent_files_menu.connect("item-activated", self.load_recent_model_file) else: self.gui.get_object("OpenRecentModel").set_visible(False) # load the menubar and connect functions to its items self.menubar = uimanager.get_widget("/MenuBar") # dict of all merge-ids menu_merges = {} def clear_menu(menu_key): for merge in menu_merges.get(menu_key, []): uimanager.remove_ui(merge) def append_menu_item(menu_key, base_path, widget, name): merge_id = uimanager.new_merge_id() if widget: action_group = widget.props.action_group if not action_group in uimanager.get_action_groups(): uimanager.insert_action_group(action_group, -1) widget_name = widget.get_name() item_type = gtk.UI_MANAGER_MENUITEM else: widget_name = name item_type = gtk.UI_MANAGER_SEPARATOR uimanager.add_ui(merge_id, base_path, name, widget_name, item_type, False) if not menu_key in menu_merges: menu_merges[menu_key] = [] menu_merges[menu_key].append(merge_id) def get_menu_funcs(menu_key, base_path): append_func = lambda widget, name: \ append_menu_item(menu_key, base_path, widget, name) clear_func = lambda: clear_menu(menu_key) return append_func, clear_func for ui_name, base_path in (("view_menu", "/MenuBar/ViewMenu"), ("file_menu", "/MenuBar/FileMenu"), ("edit_menu", "/MenuBar/EditMenu"), ("export_menu", "/MenuBar/FileMenu/ExportMenu")): append_func, clear_func = get_menu_funcs(ui_name, base_path) self.settings.register_ui_section(ui_name, append_func, clear_func) self.settings.register_ui("file_menu", "Quit", self.gui.get_object("Quit"), 100) self.settings.register_ui("file_menu", "QuitSeparator", None, 95) self.settings.register_ui("main_window", "Main", self.menubar, -100) # initialize plugins self.plugin_manager = pycam.Plugins.PluginManager(core=self.settings) self.plugin_manager.import_plugins() # some more initialization self.reset_preferences() # TODO: preferences are not loaded until the new format is stable #self.load_preferences() #self.load_task_settings() self.settings.register_event("notify-file-saved", self.add_to_recent_file_list) self.settings.register_event("notify-file-opened", self.add_to_recent_file_list) # fallback - in case of a failure when opening a model file model = pycam.Importers.TestModel.get_test_model() self.settings.get("models").add_model(model, "Tiny pyramid") # Without this "gkt.main_iteration" loop the task settings file # control would not be updated in time. while gtk.events_pending(): gtk.main_iteration() autoload_task_filename = self.settings.get("default_task_settings_file") if autoload_task_filename: self.open_task_settings_file(autoload_task_filename) self.update_all_controls() self.no_dialog = no_dialog if not self.no_dialog: # register a logging handler for displaying error messages pycam.Utils.log.add_gtk_gui(self.window, logging.ERROR) self.window.show() def update_all_controls(self): self.update_ode_settings() def update_ode_settings(self, widget=None): if pycam.Utils.threading.is_multiprocessing_enabled() \ or not pycam.Physics.ode_physics.is_ode_available(): self.enable_ode_control.set_sensitive(False) self.enable_ode_control.set_active(False) else: self.enable_ode_control.set_sensitive(True) def gui_activity_guard(func): def gui_activity_guard_wrapper(self, *args, **kwargs): if self.gui_is_active: return self.gui_is_active = True try: result = func(self, *args, **kwargs) except Exception: # Catch possible exceptions (except system-exit ones) and # report them. log.error(pycam.Utils.get_exception_report()) result = None self.gui_is_active = False while self._batch_queue: batch_func, batch_args, batch_kwargs = self._batch_queue[0] del self._batch_queue[0] batch_func(*batch_args, **batch_kwargs) return result return gui_activity_guard_wrapper def _store_undo_state(self): # for now we only store the model if not self.settings.get("models"): return # TODO: store all models self._undo_states.append(pickle.dumps( self.settings.get("models")[0].model, PICKLE_PROTOCOL)) log.debug("Stored the current state of the model for undo") while len(self._undo_states) > MAX_UNDO_STATES: self._undo_states.pop(0) self.gui.get_object("UndoButton").set_sensitive(True) def _restore_undo_state(self, widget=None, event=None): if len(self._undo_states) > 0: latest = StringIO.StringIO(self._undo_states.pop(-1)) model = pickle.Unpickler(latest).load() self.load_model(model) self.gui.get_object("UndoButton").set_sensitive( len(self._undo_states) > 0) log.info("Restored the previous state of the model") self.settings.emit_event("model-change-after") else: log.info("No previous undo state available - request ignored") def show_help(self, widget=None, page="Main_Page"): if not page.startswith("http"): url = HELP_WIKI_URL % page else: url = page webbrowser.open(url) def set_model_filename(self, filename): """ Store the given filename for a possible later "save model" action. Additionally the window's title is adjusted and the "save" buttons are updated. """ uri = pycam.Utils.URIHandler(filename) self.last_model_uri = uri if not self.last_model_uri: self.window.set_title("PyCAM") else: short_name = os.path.basename(uri.get_path()) self.window.set_title("%s - PyCAM" % short_name) self.settings.emit_event("model-change-after") def _browse_external_program_location(self, widget=None, key=None): location = self.settings.get("get_filename_func")(title="Select the executable " \ + "for '%s'" % key, mode_load=True, parent=self.preferences_window) if not location is None: self.settings.set("external_program_%s" % key, location) def _locate_external_program(self, widget=None, key=None): # the button was just activated location = get_external_program_location(key) if not location: log.error("Failed to locate the external program '%s'. " % key \ + "Please install the program and try again." \ + os.linesep \ + "Or maybe you need to specify the location manually.") else: # store the new setting self.settings.set("external_program_%s" % key, location) @gui_activity_guard def toggle_about_window(self, widget=None, event=None, state=None): # only "delete-event" uses four arguments # TODO: unify all these "toggle" functions for different windows into one single function (including storing the position) if state is None: state = event if state: self.about_window.show() else: self.about_window.hide() # don't close the window - just hide it (for "delete-event") return True @gui_activity_guard def toggle_preferences_window(self, widget=None, event=None, state=None): if state is None: # the "delete-event" issues the additional "event" argument state = event if state is None: state = not self._preferences_window_visible if state: if self._preferences_window_position: self.preferences_window.move(*self._preferences_window_position) self.preferences_window.show() else: self._preferences_window_position = self.preferences_window.get_position() self.preferences_window.hide() self._preferences_window_visible = state # don't close the window - just hide it (for "delete-event") return True @gui_activity_guard def reset_preferences(self, widget=None): """ reset all preferences to their default values """ for key, value in PREFERENCES_DEFAULTS.items(): self.settings.set(key, value) # redraw the model due to changed colors, display items ... self.settings.emit_event("model-change-after") def load_preferences(self): """ load all settings that are available in the Preferences window from a file in the user's home directory """ config_filename = pycam.Gui.Settings.get_config_filename() if config_filename is None: # failed to create the personal preferences directory return config = ConfigParser.ConfigParser() if not config.read(config_filename): # no config file was read return # report any ignored (obsolete) preference keys present in the file for item, value in config.items("DEFAULT"): if not item in PREFERENCES_DEFAULTS.keys(): log.warn("Skipping obsolete preference item: %s" % str(item)) for item in PREFERENCES_DEFAULTS.keys(): if not config.has_option("DEFAULT", item): # a new preference setting is missing in the (old) file continue value_raw = config.get("DEFAULT", item) old_value = self.settings.get(item) value_type = type(PREFERENCES_DEFAULTS[item]) if isinstance(value_type(), basestring): # keep strings as they are value = str(value_raw) else: # parse tuples, integers, bools, ... value = eval(value_raw) self.settings.set(item, value) def save_preferences(self): """ save all settings that are available in the Preferences window to a file in the user's home directory """ config_filename = pycam.Gui.Settings.get_config_filename() if config_filename is None: # failed to create the personal preferences directory log.warn("Failed to create a preferences directory in " \ + "your user's home directory.") return config = ConfigParser.ConfigParser() for item in PREFERENCES_DEFAULTS.keys(): config.set("DEFAULT", item, self.settings.get(item)) try: config_file = file(config_filename, "w") config.write(config_file) config_file.close() except IOError, err_msg: log.warn("Failed to write preferences file (%s): %s" % (config_filename, err_msg)) def destroy(self, widget=None, data=None): gtk.main_quit() self.quit() def quit(self): # TODO: disabled until the format is stable #self.save_preferences() pass def configure_drag_and_drop(self, obj): obj.connect("drag-data-received", self.handle_data_drop) flags = gtk.DEST_DEFAULT_ALL targets = [(key, gtk.TARGET_OTHER_APP, index) for index, key in enumerate(FILENAME_DRAG_TARGETS)] actions = gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_LINK | \ gtk.gdk.ACTION_DEFAULT | gtk.gdk.ACTION_PRIVATE | \ gtk.gdk.ACTION_ASK obj.drag_dest_set(flags, targets, actions) def handle_data_drop(self, widget, drag_context, x, y, selection_data, info, timestamp): if info != 0: uris = [str(selection_data.data)] elif pycam.Utils.get_platform() == pycam.Utils.PLATFORM_WINDOWS: uris = selection_data.data.splitlines() else: uris = selection_data.get_uris() if not uris: # empty selection return True for uri in uris: if not uri or (uri == chr(0)): continue uri = pycam.Utils.URIHandler(uri) file_type, importer = pycam.Importers.detect_file_type(uri, quiet=True) if importer: # looks like the file can be loaded if self.load_model_file(filename=uri): return True if len(uris) > 1: log.error("Failed to open any of the given models: %s" % \ str(uris)) else: log.error("Failed to open the model: %s" % str(uris[0])) return False def load_recent_model_file(self, widget): uri = widget.get_current_uri() self.load_model_file(filename=uri) @gui_activity_guard def load_model_file(self, widget=None, filename=None, store_filename=True): if callable(filename): filename = filename() if not filename: filename = self.settings.get("get_filename_func")("Loading model ...", mode_load=True, type_filter=FILTER_MODEL) if filename: file_type, importer = pycam.Importers.detect_file_type(filename) if file_type and callable(importer): progress = self.settings.get("progress") progress.update(text="Loading model ...") # "cancel" is not allowed progress.disable_cancel() if self.load_model(importer(filename, program_locations=get_all_program_locations(self.settings), unit=self.settings.get("unit"), fonts_cache=self.settings.get("fonts"), callback=progress.update)): if store_filename: self.set_model_filename(filename) self.add_to_recent_file_list(filename) result = True else: result = False progress.finish() return result else: log.error("Failed to detect filetype!") return False def finish_startup(self): """ This function is called by the pycam script after everything is set up properly. """ # empty the "undo" states (accumulated by loading the defualt model) while self._undo_states: self._undo_states.pop(0) def open_task_settings_file(self, filename): """ This function is used by the commandline handler """ self.last_task_settings_uri = pycam.Utils.URIHandler(filename) self.load_task_settings_file(filename=filename) @gui_activity_guard def load_task_settings_file(self, widget=None, filename=None): if callable(filename): filename = filename() if not filename: filename = self.settings.get("get_filename_func")("Loading settings ...", mode_load=True, type_filter=FILTER_CONFIG) # Only update the last_task_settings attribute if the task file was # loaded interactively. E.g. ignore the initial task file loading. if filename: self.last_task_settings_uri = pycam.Utils.URIHandler(filename) if filename: log.info("Loading task settings file: %s" % str(filename)) self.load_task_settings(filename) self.add_to_recent_file_list(filename) def load_model(self, model): # load the new model only if the import worked if model: self.settings.emit_event("model-change-before") self.settings.get("models").add_model(model) self.last_model_uri = None return True else: return False def load_task_settings(self, filename=None): settings = pycam.Gui.Settings.ProcessSettings() if not filename is None: settings.load_file(filename) # flush all tables (without re-assigning new objects) for one_list_name in ("tools", "processes", "bounds", "tasks"): one_list = self.settings.get(one_list_name) while one_list: one_list.pop() # TODO: load default tools/processes/bounds @gui_activity_guard def save_task_settings_file(self, widget=None, filename=None): if callable(filename): filename = filename() if not isinstance(filename, (basestring, pycam.Utils.URIHandler)): # we open a dialog filename = self.settings.get("get_filename_func")("Save settings to ...", mode_load=False, type_filter=FILTER_CONFIG, filename_templates=(self.last_task_settings_uri, self.last_model_uri)) if filename: self.last_task_settings_uri = pycam.Utils.URIHandler(filename) # no filename given -> exit if not filename: return settings = self.settings.dump_state() try: out_file = open(filename, "w") out_file.write(settings) out_file.close() log.info("Task settings written to %s" % filename) self.add_to_recent_file_list(filename) except IOError: log.error("Failed to save settings file") def add_to_recent_file_list(self, filename): # Add the item to the recent files list - if it already exists. # Otherwise it will be added later after writing the file. uri = pycam.Utils.URIHandler(filename) if uri.exists(): # skip this, if the recent manager is not available (e.g. GTK 2.12.1 on Windows) if self.recent_manager: if self.recent_manager.has_item(uri.get_url()): try: self.recent_manager.remove_item(uri.get_url()) except gobject.GError: pass self.recent_manager.add_item(uri.get_url()) # store the directory of the last loaded file if uri.is_local(): self.last_dirname = os.path.dirname(uri.get_local_path()) def get_meta_data(self): filename = "Filename: %s" % str(self.last_model_uri) timestamp = "Timestamp: %s" % str(datetime.datetime.now()) version = "Version: %s" % VERSION result = [] for text in (filename, timestamp, version): result.append("%s %s" % (self.META_DATA_PREFIX, text)) return os.linesep.join(result) def mainloop(self): # run the mainloop only if a GUI was requested if not self.no_dialog: gtk_settings = gtk.settings_get_default() # force the icons to be displayed gtk_settings.props.gtk_menu_images = True gtk_settings.props.gtk_button_images = True try: gtk.main() except KeyboardInterrupt: self.quit() if __name__ == "__main__": GUI = ProjectGui() if len(sys.argv) > 1: GUI.load_model_file(sys.argv[1]) GUI.mainloop()