def show_recent(self, sender=None):
dialog = gtk.RecentChooserDialog(
_("Recent Files"), self, None,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN,
gtk.RESPONSE_OK))
filter = gtk.RecentFilter()
filter.set_name("playitslowly")
filter.add_application("playitslowly")
dialog.add_filter(filter)
filter2 = gtk.RecentFilter()
filter2.set_name(_("All"))
filter2.add_mime_type("audio/*")
dialog.add_filter(filter2)
dialog.set_local_only(False)
dialog.set_filter(filter)
if dialog.run() == gtk.RESPONSE_OK and dialog.get_current_item():
uri = dialog.get_current_item().get_uri()
self.filedialog.set_uri(dialog.get_current_item().get_uri())
self.filechanged(uri=uri)
dialog.destroy()
def __init__(self, ui, window):
self._window = window
self._manager = gtk.recent_manager_get_default()
gtk.RecentChooserMenu.__init__(self, self._manager)
self.set_sort_type(gtk.RECENT_SORT_MRU)
self.set_show_tips(True)
# Missing icons crash GTK on Win32
if sys.platform == 'win32':
self.set_show_icons(False)
self.set_show_numbers(True)
rfilter = gtk.RecentFilter()
rfilter.add_pixbuf_formats()
mimetypes, patterns = itertools.izip(constants.ZIP_FORMATS,
constants.RAR_FORMATS,
constants.TAR_FORMATS,
constants.SZIP_FORMATS)
for mimetype in itertools.chain.from_iterable(mimetypes):
rfilter.add_mime_type(mimetype)
# Win32 prefers file patterns instead of MIME types
for pattern in itertools.chain.from_iterable(patterns):
rfilter.add_pattern(pattern)
self.add_filter(rfilter)
self.connect('item_activated', self._load)
def welcome(self, action=None):
"""
display a welcome window
"""
page = gtk.Label()
# welcome text
text = """<span size="x-large" weight="bold">Welcome to odML-Editor</span>\n\nNow go ahead and <a href="#new">create a new document</a>."""
for action in self.welcome_disabled_actions:
self.enable_action(action, False)
# display recently used files
recent_filter = gtk.RecentFilter()
odMLChooserDialog._setup_file_filter(recent_filter)
files = filter(lambda i: recent_filter.filter(
{'display_name': i.get_display_name(),
'uri': i.get_uri(),
'mime_type': i.get_mime_type()}),
gtk.recent_manager_get_default().get_items())
if files:
text += """\n\nOr open a <b>recently used file</b>:\n"""
text += "\n".join([u"""\u2022 <a href="%s">%s</a>""" % (i.get_uri(), i.get_display_name()) for i in files])
page.set_markup(text)
page.connect("activate-link", self.welcome_action)
page.show()
self.notebook.set_show_tabs(False)
self.notebook.append_page(page)
def __create_action_group(self):
# entry: name, stock id, label
entries = [
("FileMenu", None, "_File"),
("EditMenu", None, "_Edit"),
("AddMenu", gtk.STOCK_ADD),
("HelpMenu", gtk.STOCK_HELP),
]
for (key, val) in self.__class__.__dict__.items():
if hasattr(val, "stock_id"):
entries.append(
(val.name, val.stock_id, val.label, val.accelerator,
val.tooltip, getattr(self, key)))
recent_action = gtk.RecentAction(name="OpenRecent",
label="Open Recent",
tooltip="Open Recent Files",
stock_id=gtk.STOCK_OPEN)
recent_action.connect("item-activated", self.open_recent)
recent_filter = gtk.RecentFilter()
OdmlChooserDialog.setup_file_filter(recent_filter)
recent_action.set_sort_type(gtk.RECENT_SORT_MRU)
recent_action.add_filter(recent_filter)
recent_action.set_show_not_found(False)
action_group = gtk.ActionGroup(name="EditorActions")
self.editor_actions = action_group
action_group.add_actions(entries)
action_group.add_action(recent_action)
return action_group
def __init__(self, app):
self.app = app
#NOTE: filehandling and drawwindow are very tightly coupled
self.save_dialog = None
ag = app.builder.get_object('FileActions')
rf = gtk.RecentFilter()
rf.add_application('mypaint')
ra = app.find_action("OpenRecent")
ra.add_filter(rf)
for action in ag.list_actions():
self.app.kbm.takeover_action(action)
self._filename = None
self.current_file_observers = []
self.file_opened_observers = []
self.active_scrap_filename = None
self.lastsavefailed = False
self.set_recent_items()
self.file_filters = [
# (name, patterns)
(_("All Recognized Formats"), ("*.ora", "*.png", "*.jpg", "*.jpeg")
),
(_("OpenRaster (*.ora)"), ("*.ora", )),
(_("PNG (*.png)"), ("*.png", )),
(_("JPEG (*.jpg; *.jpeg)"), ("*.jpg", "*.jpeg")),
]
self.saveformats = [
# (name, extension, options)
(_("By extension (prefer default format)"), None, {}), # 0
(_("OpenRaster (*.ora)"), '.ora', {}), # 1
(_("PNG solid with background (*.png)"), '.png', {
'alpha': False
}), # 2
(_("PNG transparent (*.png)"), '.png', {
'alpha': True
}), # 3
(_("Multiple PNG transparent (*.XXX.png)"), '.png', {
'multifile': True
}), # 4
(_("JPEG 90% quality (*.jpg; *.jpeg)"), '.jpg', {
'quality': 90
}), # 5
]
self.ext2saveformat = {
".ora": (SAVE_FORMAT_ORA, "image/openraster"),
".png": (SAVE_FORMAT_PNGSOLID, "image/png"),
".jpeg": (SAVE_FORMAT_JPEG, "image/jpeg"),
".jpg": (SAVE_FORMAT_JPEG, "image/jpeg"),
}
self.config2saveformat = {
'openraster': SAVE_FORMAT_ORA,
'jpeg-90%': SAVE_FORMAT_JPEG,
'png-solid': SAVE_FORMAT_PNGSOLID,
}
def welcome(self, action=None):
"""
display a welcome window
"""
page = gtk.Label()
# welcome text
text = """<span size="x-large" weight="bold">Welcome to odML-Editor</span>\n\n"""
# show python 2 deprecation warning
if not sys.version_info > (3, 0):
text += """<span foreground="red">DeprecationWarning: Python 2 has been deprecated.\n"""
text += """odML support for Python 2 will be dropped August 2020.</span>\n\n"""
text += """Now go ahead and <a href="#new">create a new document</a>."""
for curr_action in self.welcome_disabled_actions:
self.enable_action(curr_action, False)
# display recently used files
recent_filter = gtk.RecentFilter()
OdmlChooserDialog.setup_file_filter(recent_filter)
# Now, we need to pass in a separate struct 'gtk.RecentFilterInfo',
# for each recently used file, for the filtering process by the
# recent_filter.filter() method. If the 'filter' return True,
# the file is included, else not included.
recent_odml_files = []
max_recent_items = 12
all_recent_files = gtk.RecentManager.get_default().get_items()
filter_info = gtk.RecentFilterInfo()
filter_info.contains = recent_filter.get_needed()
for i in all_recent_files:
if not i.exists():
continue
filter_info.display_name = i.get_display_name()
filter_info.uri = i.get_uri()
filter_info.mime_type = i.get_mime_type()
if recent_filter.filter(filter_info):
recent_odml_files.append(i)
recent_odml_files.sort(key=lambda x: x.get_age())
recent_odml_files = recent_odml_files[:max_recent_items]
if recent_odml_files:
text += "\n\nOr open a <b>recently used file</b>:\n"
text += "\n".join([
u"\u2022 <a href='%s'>%s</a>" %
(i.get_uri(), i.get_display_name()) for i in recent_odml_files
])
page.set_markup(text)
page.connect("activate-link", self.welcome_action)
page.show()
self.notebook.set_show_tabs(False)
self.notebook.append_page(page)
def __init__(self, app):
self.app = app
#NOTE: filehandling and drawwindow are very tightly coupled
self.save_dialog = None
ag = app.builder.get_object('FileActions')
ra = gtk.RecentAction('OpenRecent', _('Open Recent'), _('Open Recent files'), None)
ra.set_show_tips(True)
ra.set_show_numbers(True)
rf = gtk.RecentFilter()
rf.add_application('mypaint')
ra.add_filter(rf)
ra.set_sort_type(gtk.RECENT_SORT_MRU)
ra.connect('item-activated', self.open_recent_cb)
ag.add_action(ra)
for action in ag.list_actions():
self.app.kbm.takeover_action(action)
self._filename = None
self.current_file_observers = []
self.file_opened_observers = []
self.active_scrap_filename = None
self.lastsavefailed = False
self.set_recent_items()
self.file_filters = [ #(name, patterns)
(_("All Recognized Formats"), ("*.ora", "*.png", "*.jpg", "*.jpeg")),
(_("OpenRaster (*.ora)"), ("*.ora",)),
(_("PNG (*.png)"), ("*.png",)),
(_("JPEG (*.jpg; *.jpeg)"), ("*.jpg", "*.jpeg")),
]
self.saveformats = [ #(name, extension, options)
(_("By extension (prefer default format)"), None, {}), #0
(_("OpenRaster (*.ora)"), '.ora', {}), #1
(_("PNG solid with background (*.png)"), '.png', {'alpha': False}), #2
(_("PNG transparent (*.png)"), '.png', {'alpha': True}), #3
(_("Multiple PNG transparent (*.XXX.png)"), '.png', {'multifile': True}), #4
(_("JPEG 90% quality (*.jpg; *.jpeg)"), '.jpg', {'quality': 90}), #5
(_("One PNG image for animation frame (*-XXX.png)"), '.png', {'animation': True}), #6
(_("Animation video (*.avi)"), '.avi', {}), #7
]
self.ext2saveformat = {
'.ora': SAVE_FORMAT_ORA,
'.png': SAVE_FORMAT_PNGSOLID,
'.jpeg': SAVE_FORMAT_JPEG,
'.jpg': SAVE_FORMAT_JPEG}
self.config2saveformat = {
'openraster': SAVE_FORMAT_ORA,
'jpeg-90%': SAVE_FORMAT_JPEG,
'png-solid': SAVE_FORMAT_PNGSOLID,
}
def __create_filter(self):
"""
Create a filter for the recent menu.
@param self: Reference to the RecentMenu instance.
@type self: A RecentMenu object.
@return: A filter for the recent menu.
@rtype: A gtk.RecentFilter object.
"""
recent_filter = gtk.RecentFilter()
recent_filter.add_application("gedit")
return recent_filter
def _get_recent_menu(self, limit=None, recent_menu=None):
"""Return a recent file menu."""
if recent_menu is None:
recent_menu = gtk.RecentChooserMenu(self.app.recent_manager)
filter_ = gtk.RecentFilter()
filter_.add_mime_type("text/x-sql")
recent_menu.add_filter(filter_)
recent_menu.set_filter(filter_)
recent_menu.set_show_not_found(False)
recent_menu.set_sort_type(gtk.RECENT_SORT_MRU)
recent_menu.connect("item-activated", self.on_recent_item_activated)
if limit is not None:
recent_menu.set_limit(limit)
return recent_menu
def __init__(self, exec_path=None):
self.recent_manager = gtk.recent_manager_get_default()
self.recent_filter = gtk.RecentFilter()
self.recent_filter.add_application(self.app_name)
self._stored_comparisons = []
# Should be argv[0] to support roundtripping in uninstalled use
if exec_path:
self.app_exec = os.path.abspath(exec_path)
if not os.path.exists(self.recent_path):
os.makedirs(self.recent_path)
self._clean_recent_files()
self._update_recent_files()
self.recent_manager.connect("changed", self._update_recent_files)
def createRecentMenu():
"""purge nonexistant (NA moved) items"""
for i in recentmanager.get_items():
if str(i.get_applications()[0]) == 'gnoduino':
file = urlparse.urlparse(i.get_uri()).path
if os.path.exists(file) is False:
recentmanager.remove_item(i.get_uri())
menuRecent = gtk.RecentChooserMenu(recentmanager)
menuRecent.set_limit(10)
menuRecent.set_sort_type(gtk.RECENT_SORT_MRU)
filter = gtk.RecentFilter()
filter.add_application("gnoduino")
menuRecent.set_filter(filter)
mi = gtk.MenuItem(_("Open Recent"), use_underline=True)
mi.set_submenu(menuRecent)
gui.get_object("filemenu").insert(mi, 2)
menuRecent.connect("item_activated", recentMenuActivated)
def on_open_file(self, *args):
dlg = gtk.FileChooserDialog(_(u"Select file"), self,
gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN, gtk.RESPONSE_OK))
dlg.set_current_folder(self.app.config.get("editor.recent_folder", ""))
dlg.set_select_multiple(True)
filter = gtk.FileFilter()
filter.set_name(_(u"All files (*)"))
filter.add_pattern("*")
dlg.add_filter(filter)
filter = gtk.FileFilter()
filter.set_name(_(u"SQL files (*.sql)"))
filter.add_pattern("*.sql")
dlg.add_filter(filter)
dlg.set_filter(filter)
recent_chooser = gtk.RecentChooserWidget(self.app.recent_manager)
filter = gtk.RecentFilter()
filter.add_mime_type("text/x-sql")
filter.set_name(_(u"SQL files (*.sql)"))
recent_chooser.add_filter(filter)
recent_chooser.set_filter(filter)
recent_chooser.set_show_not_found(False)
recent_chooser.set_sort_type(gtk.RECENT_SORT_MRU)
recent_chooser.set_show_icons(True)
recent_chooser.set_show_tips(True)
def dlg_set_uri(chooser, dlg):
if chooser.get_current_uri():
dlg.set_uri(chooser.get_current_uri())
recent_chooser.connect("selection-changed", dlg_set_uri, dlg)
recent_chooser.connect("item-activated",
lambda chooser: dlg.response(gtk.RESPONSE_OK))
exp = gtk.Expander(_(u"_Recent files:"))
exp.add(recent_chooser)
exp.set_use_underline(True)
dlg.set_extra_widget(exp)
recent_chooser.show()
if dlg.run() == gtk.RESPONSE_OK:
[self.editor_create(fname) for fname in dlg.get_filenames()]
self.app.config.set("editor.recent_folder",
dlg.get_current_folder())
dlg.destroy()
def __init__(self, ui, window):
self._window = window
self._manager = gtk.recent_manager_get_default()
gtk.RecentChooserMenu.__init__(self, self._manager)
self.set_sort_type(gtk.RECENT_SORT_MRU)
self.set_show_tips(True)
rfilter = gtk.RecentFilter()
rfilter.add_pixbuf_formats()
rfilter.add_mime_type('application/x-zip')
rfilter.add_mime_type('application/zip')
rfilter.add_mime_type('application/x-rar')
rfilter.add_mime_type('application/x-tar')
rfilter.add_mime_type('application/x-gzip')
rfilter.add_mime_type('application/x-bzip2')
rfilter.add_mime_type('application/x-cbz')
rfilter.add_mime_type('application/x-cbr')
rfilter.add_mime_type('application/x-cbt')
self.add_filter(rfilter)
self.connect('item_activated', self._load)
def __init__(self, app):
self.app = app
self.builder = gtk.Builder()
self.builder.add_from_file(
os.path.join(get_ui_dir(), "startupwizard.ui"))
self.builder.connect_signals(self)
self.window = self.builder.get_object("window1")
self.recent_chooser = self.builder.get_object("recentchooser2")
# FIXME: gtk creates a combo box with only one item, but there is no
# simple way to hide it.
filter = gtk.RecentFilter()
filter.set_name(_("Projects"))
filter.add_pattern("*.xptv")
self.recent_chooser.add_filter(filter)
self.app.projectManager.connect("new-project-failed",
self._projectFailedCb)
self.app.projectManager.connect("new-project-loaded",
self._projectLoadedCb)
self.app.projectManager.connect("new-project-loading",
self._projectLoadingCb)
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,
"<Control>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,
"<Control>o"), ("Quit", self.destroy, None, "<Control>q"),
("GeneralSettings", self.toggle_preferences_window, None,
"<Control>p"), ("UndoButton", self._restore_undo_state, None,
"<Control>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 = "<pycam>/%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()
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program 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 this program; if not, see <http://www.gnu.org/licenses/>.
from translate.storage import factory
import gtk
rf = gtk.RecentFilter()
for name, extensions, mimetypes in factory.supported_files():
if extensions:
for extension in extensions:
if extension in ("txt"):
continue
rf.add_pattern("*.%s" % extension)
for compress_extension in factory.decompressclass.keys():
rf.add_pattern("*.%s.%s" % (extension, compress_extension))
if mimetypes:
for mimetype in mimetypes:
rf.add_mime_type(mimetype)
for app in ("virtaal", "poedit", "kbabel", "lokalize", "gtranslator"):
rf.add_application(app)
rm = gtk.recent_manager_get_default()
def __init__(self, app):
self.app = app
self.save_dialog = None
# File filters definitions, for dialogs
self.file_filters = [
# (name, patterns)
(_("All Recognized Formats"), ("*.ora", "*.png", "*.jpg", "*.jpeg")
),
(_("OpenRaster (*.ora)"), ("*.ora", )),
(_("PNG (*.png)"), ("*.png", )),
(_("JPEG (*.jpg; *.jpeg)"), ("*.jpg", "*.jpeg")),
]
# Recent filter, for the menu.
# Better to use a regex with re.IGNORECASE than
# .upper()==.upper() hacks since internally, filenames are
# Unicode and capitalization rules like Turkish's dotless "i"
# exist. One day we want all the formats GdkPixbuf can load to
# be supported in the dialog.
file_regex_exts = set()
for name, patts in self.file_filters:
for p in patts:
e = p.replace("*.", "", 1)
file_regex_exts.add(re.escape(e))
file_re = r'[.](?:' + ('|'.join(file_regex_exts)) + r')$'
logger.debug("Using regex /%s/i for filtering recent files", file_re)
self._file_extension_regex = re.compile(file_re, re.IGNORECASE)
rf = gtk.RecentFilter()
rf.add_pattern('')
# The blank-string pattern is eeded so the custom func will
# get URIs at all, despite the needed flags below.
rf.add_custom(func=self._recentfilter_func,
needed=(gtk.RecentFilterFlags.APPLICATION
| gtk.RecentFilterFlags.URI))
ra = app.find_action("OpenRecent")
ra.add_filter(rf)
ag = app.builder.get_object('FileActions')
for action in ag.list_actions():
self.app.kbm.takeover_action(action)
self._filename = None
self.current_file_observers = []
self.file_opened_observers = []
self.active_scrap_filename = None
self.lastsavefailed = False
self._update_recent_items()
saveformat_keys = [
SAVE_FORMAT_ANY,
SAVE_FORMAT_ORA,
SAVE_FORMAT_PNGSOLID,
SAVE_FORMAT_PNGTRANS,
SAVE_FORMAT_PNGMULTI,
SAVE_FORMAT_JPEG,
]
saveformat_values = [
# (name, extension, options)
(_("By extension (prefer default format)"), None, {}),
(_("OpenRaster (*.ora)"), '.ora', {}),
(_("PNG solid with background (*.png)"), '.png', {
'alpha': False
}),
(_("PNG transparent (*.png)"), '.png', {
'alpha': True
}),
(_("Multiple PNG transparent (*.XXX.png)"), '.png', {
'multifile': True
}),
(_("JPEG 90% quality (*.jpg; *.jpeg)"), '.jpg', {
'quality': 90
}),
]
self.saveformats = OrderedDict(zip(saveformat_keys, saveformat_values))
self.ext2saveformat = {
".ora": (SAVE_FORMAT_ORA, "image/openraster"),
".png": (SAVE_FORMAT_PNGAUTO, "image/png"),
".jpeg": (SAVE_FORMAT_JPEG, "image/jpeg"),
".jpg": (SAVE_FORMAT_JPEG, "image/jpeg"),
}
self.config2saveformat = {
'openraster': SAVE_FORMAT_ORA,
'jpeg-90%': SAVE_FORMAT_JPEG,
'png-solid': SAVE_FORMAT_PNGSOLID,
}
self.__statusbar_context_id = None
def __init__(self):
"""initialise a new puzzle"""
#Set the environment variables and default display settings
self.local_path = os.path.realpath(os.path.dirname(sys.argv[0]))
self.gladefile = os.path.join(self.local_path, 'assets',
"findthatword.glade")
self.show_title = True
self.show_grid = True
self.show_words = True
self.show_solution = True
#Initialise the Glade GUI environment
self.widget_tree = gtk.glade.XML(self.gladefile, "MainWindow")
self.widget_tree.signal_autoconnect(self)
self.main_window = self.widget_tree.get_widget("MainWindow")
#Draw the icon. Unofortunately, not all operating systems can accept SVGs
if os.name == 'posix':
icon_file = os.path.join(self.local_path, 'assets',
"ftw_small.svg")
self.main_window.set_icon_from_file(icon_file)
else:
icon_file = os.path.join(self.local_path, 'assets' "ftw_small.ico")
self.main_window.set_icon_from_file(icon_file)
#Disable printing support on Windows - the GTK page setup dialogue doesn't
#work so the printed puzzle is incorrectly scaled to the page
if os.name == 'nt' or os.name == 'ce':
self.widget_tree.get_widget("PrintIcon").hide()
self.widget_tree.get_widget("FilePageSetupMenuItem").hide()
self.widget_tree.get_widget("FilePrintMenuItem").hide()
self.widget_tree.get_widget("separatormenuitem2").hide()
#Setup the Recent Files menu if the modules are available
recent_widget = self.widget_tree.get_widget("FileRecentMenuItem")
if RECENT_CHOOSER:
recent_manager = gtk.recent_manager_get_default()
recent_chooser = gtk.RecentChooserMenu(recent_manager)
recent_filter = gtk.RecentFilter()
recent_filter.add_pattern("*.ftw")
recent_chooser.add_filter(recent_filter)
recent_chooser.set_show_not_found(False)
recent_chooser.connect("item-activated",
self.on_RecentChooser_activate)
recent_widget.set_submenu(recent_chooser)
else:
recent_widget.hide()
#Create a permanent reference to frequently used widgets
self.new_word_entry_widget = self.widget_tree.get_widget(
"NewWordEntry")
self.new_description_entry_widget = self.widget_tree.get_widget(
"NewDescriptionEntry")
self.words_view_widget = self.widget_tree.get_widget("WordsView")
#Initialise the WordsView widget
for i in range(0, 2):
column = gtk.TreeViewColumn("Word", gtk.CellRendererText(), text=i)
column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
self.words_view_widget.append_column(column)
column.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
self.words_list = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_STRING)
self.words_view_widget.set_model(self.words_list)
self.words_view_widget_selection = self.words_view_widget.get_selection(
)
#Manually connect signals where Glade provides no options
self.widget_tree.get_widget("NarrativeEntry").get_buffer().connect(
"changed", self.on_NarrativeWidget_changed)
self.words_view_widget_selection.connect(
'changed', self.on_WordsListWidgetSelection_changed)
#Initialise print settings
self.print_settings = None
self.print_settings = gtk.PrintSettings()
self.page_setup = gtk.PageSetup()
#Create and display a new puzzle
self.dirty = False
#Let's celelebrate being Welsh
if datetime.date.today().month == 3 and datetime.date.today().day == 1:
self.st_davids_day = True
else:
self.st_davids_day = False
self.new_puzzle()
#Find the name of a file passed on the command line
if len(sys.argv) >= 2:
self.load_file(sys.argv[len(sys.argv) - 1], "Filename")
def __init__(self, main):
super(Toolbar, self).__init__(False, 1)
self.main = main
self.toolbox = self
self.main_tb = gtk.Toolbar()
self.main_tb.set_style(gtk.TOOLBAR_ICONS)
# New KB button
self.new_tb = gtk.ToolButton(gtk.STOCK_NEW)
self.new_tb.set_tooltip_text('Create new KB')
self.new_tb.connect("clicked", self._miau)
self.main_tb.insert(self.new_tb, 0)
self.new_tb.set_sensitive(False)
# Load KB button
self.load_tb = gtk.MenuToolButton(gtk.STOCK_OPEN)
self.load_tb.set_tooltip_text('Load KB')
self.load_tb.connect("clicked", self.load_kb)
self.main_tb.insert(self.load_tb, 1)
# Rcent files menu
self.manager = gtk.recent_manager_get_default()
self.recent_menu = gtk.RecentChooserMenu(self.manager)
filter = gtk.RecentFilter()
filter.add_pattern("*.kb")
self.recent_menu.add_filter(filter)
self.load_tb.set_menu(self.recent_menu)
self.load_tb.set_arrow_tooltip_text('Recent opened KB')
self.recent_menu.connect('item-activated', self.recent_kb)
# Save KB button
self.save_tb = gtk.ToolButton(gtk.STOCK_SAVE)
self.save_tb.set_tooltip_text('Save current KB')
self.save_tb.connect("clicked", self.save_kb)
self.main_tb.insert(self.save_tb, 2)
# Import button
self.import_tb = gtk.ToolButton(gtk.STOCK_CONVERT)
self.import_tb.set_tooltip_text('Import Nmap/CSV file')
self.import_tb.connect("clicked", self.import_scan)
self.main_tb.insert(self.import_tb, 3)
# Editor button
self.edit_tb = gtk.ToolButton(gtk.STOCK_EDIT)
self.edit_tb.set_tooltip_text('Open editor')
self.edit_tb.connect("clicked", self.load_editor)
self.main_tb.insert(self.edit_tb, 4)
# Separator
self.sep = gtk.SeparatorToolItem()
self.main_tb.insert(self.sep, 5)
# Proxy button
self.proxy_tb = gtk.ToolButton(gtk.STOCK_CONNECT)
self.proxy_tb.set_tooltip_text('Start TCP proxy')
self.proxy_tb.connect("clicked", self._miau)
self.proxy_tb.set_sensitive(False)
self.main_tb.insert(self.proxy_tb, 6)
# Web server button
self.wserver_tb = gtk.ToolButton(gtk.STOCK_CONVERT)
self.wserver_tb.set_tooltip_text('Run web server')
self.wserver_tb.connect("clicked", self._miau)
self.wserver_tb.set_sensitive(False)
self.main_tb.insert(self.wserver_tb, 7)
# Sniffer button
self.sniffer_tb = gtk.ToolButton(gtk.STOCK_NETWORK)
self.sniffer_tb.set_tooltip_text('Open network sniffer')
self.sniffer_tb.connect("clicked", self.run_sniffer)
self.main_tb.insert(self.sniffer_tb, 8)
# Separator
self.sep = gtk.SeparatorToolItem()
self.main_tb.insert(self.sep, 9)
# Scapy button
self.scapy_tb = gtk.ToolButton(gtk.STOCK_MEDIA_PLAY)
self.scapy_tb.set_tooltip_text('Start Scapy')
self.scapy_tb.connect("clicked", self.show_term)
self.main_tb.insert(self.scapy_tb, 10)
self.scapy_logo = gtk.Image()
self.scapy_logo.set_from_file('lib' + os.sep + 'ui' + os.sep + 'data' +
os.sep + 'python-icon.png')
self.scapy_tb.set_icon_widget(self.scapy_logo)
# Separator
self.sep = gtk.SeparatorToolItem()
self.main_tb.insert(self.sep, 11)
# Add target button
self.add_tb = gtk.ToolButton(gtk.STOCK_ADD)
self.add_tb.set_tooltip_text('Add a new target')
self.add_tb.connect("clicked", self.add_target)
self.main_tb.insert(self.add_tb, 12)
# Preferences button
self.prefs_tb = gtk.ToolButton(gtk.STOCK_PREFERENCES)
self.prefs_tb.set_tooltip_text('Open preferences dialog')
self.prefs_tb.connect("clicked", self.show_pref)
self.main_tb.insert(self.prefs_tb, 13)
# Log button
self.log_tb = gtk.ToggleToolButton(gtk.STOCK_LEAVE_FULLSCREEN)
self.log_tb.set_tooltip_text('Show/Hide Log panel')
self.log_tb.connect("toggled", self.show_log)
self.main_tb.insert(self.log_tb, 14)
# KB button
self.kb_tb = gtk.ToggleToolButton(gtk.STOCK_LEAVE_FULLSCREEN)
self.kb_tb.set_tooltip_text('Show/Hide KB panel')
self.kb_tb.connect("toggled", self.show_kb)
self.main_tb.insert(self.kb_tb, 15)
# Separator
self.sep = gtk.SeparatorToolItem()
self.main_tb.insert(self.sep, 16)
# Report button
self.report_tb = gtk.ToolButton(gtk.STOCK_INDEX)
self.report_tb.set_tooltip_text('Show KB report')
self.report_tb.connect("clicked", self.report)
self.main_tb.insert(self.report_tb, 17)
# Exit button
self.exit_tb = gtk.ToolButton(gtk.STOCK_QUIT)
self.exit_tb.connect("clicked", self._bye)
self.exit_tb.set_tooltip_text('Have a nice day ;-)')
self.main_tb.insert(self.exit_tb, 18)
# Separator
self.sep = gtk.SeparatorToolItem()
self.sep.set_expand(True)
self.sep.set_draw(False)
self.main_tb.insert(self.sep, 19)
# About button
self.about_tb = gtk.ToolButton(gtk.STOCK_ABOUT)
self.about_tb.connect("clicked", self.create_about_dialog)
self.about_tb.set_tooltip_text('About Inguma')
self.main_tb.insert(self.about_tb, 20)
# Throbber
self.throbber = throbber.Throbber()
self.throbber_tb = gtk.ToolItem()
self.throbber_tb.add(self.throbber)
self.main_tb.insert(self.throbber_tb, 21)
self.toolbox.pack_start(self.main_tb, True, True)
self.show_all()
