def __init__(self, bus):
self.bus = bus
self.action_group = Gio.SimpleActionGroup()
self.menu = Gio.Menu()
self.sub_menu = Gio.Menu()
self.current_switch_icon = 'phone-smartphone-symbolic'
self.settings = Gio.Settings.new(self.BASE_KEY)
def __init__(self):
super().__init__()
self.set_size_request(300, -1)
actions = Gio.SimpleActionGroup()
action = Gio.SimpleAction.new('section', GLib.VariantType('s'))
action.connect('activate', self._section_activate_cb)
actions.add_action(action)
self.insert_action_group('toc_popover', actions)
def _build_actions(self):
# nterm action group
self._nterm_action_group = Gio.SimpleActionGroup()
self._ui_terminal.insert_action_group("nterm", self._nterm_action_group)
copy_action = Gio.SimpleAction(name="copy")
copy_action.connect("activate", self._on_nterm_copy_action_activated)
self._nterm_action_group.add_action(copy_action)
paste_action = Gio.SimpleAction(name="paste")
paste_action.connect("activate", self._on_nterm_paste_action_activated)
self._nterm_action_group.add_action(paste_action)
# ntermwin action group
self._ntermwin_action_group = Gio.SimpleActionGroup()
terminal_visible_action = Gio.SimpleAction(name="terminal-visible")
terminal_visible_action.connect("activate", self._on_ntermwin_terminal_visible_action_activated)
self._ntermwin_action_group.add_action(terminal_visible_action)
def _create_actions(self):
self.action_group = Gio.SimpleActionGroup()
self.insert_action_group("markers", self.action_group)
self.app.shortcuts.register_group("markers", _("Markers"), position=70)
self.add_marker_action = Gio.SimpleAction.new("marker-add", GLib.VariantType("mx"))
self.add_marker_action.connect("activate", self._add_marker_cb)
self.action_group.add_action(self.add_marker_action)
self.app.shortcuts.add("markers.marker-add(@mx nothing)", ["<Primary><Shift>m"],
self.add_marker_action, _("Add a marker"))
def create_pitivi(**settings):
app = Pitivi()
app._setup()
app.gui = mock.Mock()
app.gui.editor.viewer.action_group = Gio.SimpleActionGroup()
app.settings = __create_settings(**settings)
app.gui.editor.editor_state = EditorState(app.project_manager)
return app
def __init__(self, bus):
self.get_config()
self.bus = bus
self.action_group = Gio.SimpleActionGroup()
self.menu = Gio.Menu()
self.sub_menu = Gio.Menu()
self.current_condition_icon = self.CLEAR
self.current_condition_text = 'Clear'
self.current_temperature = 75
self.error = 'No weather data yet'
def create_pitivi_mock(**settings):
app = mock.MagicMock()
app.write_action = mock.MagicMock(spec=Pitivi.write_action)
app.settings = __create_settings(**settings)
app.gui.editor.editor_state = EditorState(app.project_manager)
app.proxy_manager = ProxyManager(app)
app.gui.editor.viewer.action_group = Gio.SimpleActionGroup()
# TODO: Get rid of Zoomable.app.
Zoomable.app = app
return app
def __init__(self, search_entry):
super().__init__()
self.set_relative_to(search_entry)
self.set_size_request(360, -1)
self.set_modal(False)
self._results_menu = Gio.Menu()
self.bind_model(self._results_menu, None)
actions = Gio.SimpleActionGroup()
action = Gio.SimpleAction.new('suggestion', GLib.VariantType('s'))
action.connect('activate', self._suggestion_activate_cb)
actions.add_action(action)
self.insert_action_group('suggestions_popover', actions)
def do_load(self, workbench):
self.workbench = workbench
group = Gio.SimpleActionGroup()
self.install_action = Gio.SimpleAction(name='install-docutils', enabled=True)
self.install_action.connect('activate', lambda *_: self.install_docutils())
group.insert(self.install_action)
self.install_action = Gio.SimpleAction(name='install-sphinx', enabled=True)
self.install_action.connect('activate', lambda *_: self.install_sphinx())
group.insert(self.install_action)
self.workbench.insert_action_group('html-preview', group)
def onTaskOpened(self, plugin_api):
"""
Adds the button when a task is opened.
"""
group = Gio.SimpleActionGroup()
send_action = Gio.SimpleAction.new("send_as_email", None)
send_action.connect("activate", self._on_send_activate, plugin_api)
group.add_action(send_action)
plugin_api.get_ui().window.insert_action_group(self.ACTION_GROUP_PREF,
group)
self.menu_item = Gio.MenuItem.new(
_("Send via email"),
".".join([self.ACTION_GROUP_PREF, "send_as_email"]))
plugin_api.add_menu_item(self.menu_item)
def __set_keyboard_shortcuts(self):
group = Gio.SimpleActionGroup()
self.toplevel_widget.insert_action_group("editor", group)
self.headerbar.insert_action_group("editor", group)
self.save_action = Gio.SimpleAction.new("save", None)
self.save_action.connect("activate", self.__save_project_cb)
group.add_action(self.save_action)
self.app.shortcuts.add("editor.save", ["<Primary>s"],
_("Save the current project"),
group="win")
self.save_button.set_action_name("editor.save")
self.save_as_action = Gio.SimpleAction.new("save-as", None)
self.save_as_action.connect("activate", self.__save_project_as_cb)
group.add_action(self.save_as_action)
self.app.shortcuts.add("editor.save-as", ["<Primary><Shift>s"],
_("Save the current project as"),
group="win")
self.revert_to_saved_action = Gio.SimpleAction.new(
"revert-to-saved", None)
self.revert_to_saved_action.connect("activate",
self.__revert_to_saved_cb)
group.add_action(self.revert_to_saved_action)
self.export_project_action = Gio.SimpleAction.new(
"export-project", None)
self.export_project_action.connect("activate",
self.__export_project_cb)
group.add_action(self.export_project_action)
self.save_frame_action = Gio.SimpleAction.new("save-frame", None)
self.save_frame_action.connect("activate", self.__save_frame_cb)
group.add_action(self.save_frame_action)
self.project_settings_action = Gio.SimpleAction.new(
"project-settings", None)
self.project_settings_action.connect("activate",
self.__project_settings_cb)
group.add_action(self.project_settings_action)
self.import_asset_action = Gio.SimpleAction.new("import-asset", None)
self.import_asset_action.connect("activate", self.__import_asset_cb)
group.add_action(self.import_asset_action)
self.app.shortcuts.add("editor.import-asset", ["<Primary>i"],
_("Add media files to your project"),
group="win")
def do_workspace_added(self, workspace):
group = Gio.SimpleActionGroup()
self.install_action = Gio.SimpleAction(name='install-docutils',
enabled=True)
self.install_action.connect('activate',
lambda *_: self.install_docutils())
group.insert(self.install_action)
self.install_action = Gio.SimpleAction(name='install-sphinx',
enabled=True)
self.install_action.connect('activate',
lambda *_: self.install_sphinx())
group.insert(self.install_action)
workspace.insert_action_group('html-preview', group)
def __set_keyboard_shortcuts(self):
group = Gio.SimpleActionGroup()
self.toplevel_widget.insert_action_group("greeter", group)
self.headerbar.insert_action_group("greeter", group)
self.new_project_action = Gio.SimpleAction.new("new-project", None)
self.new_project_action.connect("activate", self.__new_project_cb)
group.add_action(self.new_project_action)
self.app.shortcuts.add("greeter.new-project", ["<Primary>n"],
_("Create a new project"), group="win")
self.open_project_action = Gio.SimpleAction.new("open-project", None)
self.open_project_action.connect("activate", self.__open_project_cb)
group.add_action(self.open_project_action)
self.app.shortcuts.add("greeter.open-project", ["<Primary>o"],
_("Open a project"), group="win")
def create_actions(self):
def add_action(name, handler, parameter_type=None, state=None):
action = Gio.SimpleAction(name=name,
parameter_type=parameter_type,
state=state)
action.connect("activate", handler)
self.application.add_action(action)
return action
# Missing override for Gtk.Application.add_action_entries():
# https://gitlab.gnome.org/GNOME/pygobject/-/issues/426
# main actions
for name, handler in self.get_main_actions():
add_action(name, handler)
# actions with parameters
for name, handler in self.get_arrow_actions():
add_action(name, handler, parameter_type=GLib.VariantType("i"))
# stateful actions
self.explorer_action, self.fullscreen_action = \
[add_action(*x, state=GLib.Variant("b", False)) for x in self.get_toggle_actions()]
# actions which are only available if we're in 4D mode
self.fourd_actiongroup = Gio.SimpleActionGroup()
for name, handler in self.get_fourd_actions():
action = add_action(name, handler)
self.fourd_actiongroup.add_action(action)
# keyboard accelerators for actions
for key in [x[0] for x in self.get_arrow_actions()]:
self.application.set_accels_for_action(f"app.{key}(0)",
[f"<Release>{key}"])
self.application.set_accels_for_action(
f"app.{key}({int(Gdk.ModifierType.SHIFT_MASK)})",
[f"<Release><Shift>{key}"])
self.application.set_accels_for_action(
f"app.{key}({int(Gdk.ModifierType.CONTROL_MASK)})",
[f"<Release><Control>{key}"])
self.application.set_accels_for_action(
f"app.{key}"
f"({int(Gdk.ModifierType.SHIFT_MASK | Gdk.ModifierType.CONTROL_MASK)})",
[f"<Release><Shift><Control>{key}"])
self.model.seq.register_callbacks(
self.application.lookup_action("EditRedoAction").set_enabled,
self.application.lookup_action("EditUndoAction").set_enabled)
def __init__(self):
assert self.group_name
assert not hasattr(self, '_instance')
self.model = None
self._actions = {}
super(BaseActions, self).__init__()
self.group = Gio.SimpleActionGroup()
# register actions that were decorated with @action('ActionName')
for key in dir(self):
callback = getattr(self, key)
if hasattr(callback, '__action_spec__'):
name, = callback.__action_spec__
self.add_action(name, callback)
self._register_action_group()
def __init__(self, shell, group_name):
'''
constructor
:param shell: `RBShell`
:param group_name: `str` unique name for the object to create
'''
self.group_name = group_name
self.shell = shell
self._actions = {}
if is_rb3(self.shell):
self.actiongroup = Gio.SimpleActionGroup()
else:
self.actiongroup = Gtk.ActionGroup(group_name)
uim = self.shell.props.ui_manager
uim.insert_action_group(self.actiongroup)
def create_action_group(self):
self.action_group = Gio.SimpleActionGroup()
self.actions = {}
actions = (
('change-directory', self.change_to_current_directory),
('copy-clipboard', self.copy_clipboard),
('paste-clipboard', self.paste_clipboard),
('paste-current-file', self.paste_current_file),
)
for name, callback in actions:
action = Gio.SimpleAction.new(name, None)
action.connect('activate', callback)
self.actions[name] = action
self.action_group.add_action(action)
def _create_actions(self):
group = Gio.SimpleActionGroup()
self.toplevel_widget.insert_action_group("editor", group)
self.headerbar.insert_action_group("editor", group)
# pylint: disable=attribute-defined-outside-init
self.save_action = Gio.SimpleAction.new("save", None)
self.save_action.connect("activate", self.__save_project_cb)
group.add_action(self.save_action)
self.app.shortcuts.add("editor.save", ["<Primary>s"], self.save_action,
_("Save the current project"), group="win")
self.save_button.set_action_name("editor.save")
self.save_as_action = Gio.SimpleAction.new("save-as", None)
self.save_as_action.connect("activate", self.__save_project_as_cb)
group.add_action(self.save_as_action)
self.app.shortcuts.add("editor.save-as", ["<Primary><Shift>s"],
self.save_as_action,
_("Save the current project as"), group="win")
self.revert_to_saved_action = Gio.SimpleAction.new("revert-to-saved", None)
self.revert_to_saved_action.connect("activate", self.__revert_to_saved_cb)
group.add_action(self.revert_to_saved_action)
self.export_project_action = Gio.SimpleAction.new("export-project", None)
self.export_project_action.connect("activate", self.__export_project_cb)
group.add_action(self.export_project_action)
self.save_frame_action = Gio.SimpleAction.new("save-frame", None)
self.save_frame_action.connect("activate", self.__save_frame_cb)
group.add_action(self.save_frame_action)
self.project_settings_action = Gio.SimpleAction.new("project-settings", None)
self.project_settings_action.connect("activate", self.__project_settings_cb)
group.add_action(self.project_settings_action)
group.add_action(self.intro.intro_action)
self.app.shortcuts.add("editor.interactive-intro", [], self.intro.intro_action,
_("Quick intros to Pitivi"), group="win")
self.import_asset_action = Gio.SimpleAction.new("import-asset", None)
self.import_asset_action.connect("activate", self.__import_asset_cb)
group.add_action(self.import_asset_action)
self.app.shortcuts.add("editor.import-asset", ["<Primary>i"],
self.import_asset_action,
_("Add media files to your project"), group="win")
def _createActionGroup(self):
'''
Create the action group for the
files view.
:return: The files view action group
:rtype: Gio.SimpleActionGroup
'''
group = Gio.SimpleActionGroup()
open_folder = Gio.SimpleAction.new("open_folder")
open_folder.connect("activate", self.openFolder)
tag_file = Gio.SimpleAction.new("tag_file")
tag_file.connect("activate", self.openTagger)
remove_file = Gio.SimpleAction.new("remove_file")
remove_file.connect("activate", self.removeFile)
group.add_action(open_folder)
group.add_action(tag_file)
group.add_action(remove_file)
return group
def __create_menu_model(self):
action_group = Gio.SimpleActionGroup()
menu_model = Gio.Menu()
self.__move_layer_top_action = Gio.SimpleAction.new(
"move-layer-to-top", None)
action = self.__move_layer_top_action
action.connect("activate", self.__move_layer_cb, -2)
action_group.add_action(action)
menu_model.append(_("Move layer to top"),
"layer.%s" % action.get_name().replace(" ", "."))
self.__move_layer_up_action = Gio.SimpleAction.new(
"move-layer-up", None)
action = self.__move_layer_up_action
action.connect("activate", self.__move_layer_cb, -1)
action_group.add_action(action)
menu_model.append(_("Move layer up"),
"layer.%s" % action.get_name().replace(" ", "."))
self.__move_layer_down_action = Gio.SimpleAction.new(
"move-layer-down", None)
action = self.__move_layer_down_action
action.connect("activate", self.__move_layer_cb, 1)
action_group.add_action(action)
menu_model.append(_("Move layer down"),
"layer.%s" % action.get_name().replace(" ", "."))
self.__move_layer_bottom_action = Gio.SimpleAction.new(
"move-layer-to-bottom", None)
action = self.__move_layer_bottom_action
action.connect("activate", self.__move_layer_cb, 2)
action_group.add_action(action)
menu_model.append(_("Move layer to bottom"),
"layer.%s" % action.get_name().replace(" ", "."))
self.delete_layer_action = Gio.SimpleAction.new("delete-layer", None)
action = self.delete_layer_action
action.connect("activate", self.__delete_layer_cb)
action_group.add_action(action)
menu_model.append(_("Delete layer"), "layer.%s" % action.get_name())
return menu_model, action_group
def _create_application_actions(self):
"""Create the actions that activate the applications.
This actions are prefixed by 'launch', followed by the app name (for
instance launch.pos)
"""
def callback(action, parameter, name):
self.switch_application(name)
group = Gio.SimpleActionGroup()
self.toplevel.insert_action_group('launch', group)
for app in self.get_available_applications():
action = Gio.SimpleAction.new(app.name, None)
action.connect('activate', callback, app.name)
group.add_action(action)
# Also add the launcher app
action = Gio.SimpleAction.new('launcher', None)
action.connect('activate', callback, 'launcher')
group.add_action(action)
def setup_menus(self, vbox):
self._action_group = Gio.SimpleActionGroup()
self._about_action = Gio.SimpleAction.new('about', None)
self._about_action.connect('activate', self.on_about)
self._help_action = Gio.SimpleAction.new('help', None)
self._help_action.connect('activate', self.on_help)
self._quit_action = Gio.SimpleAction.new('quit', None)
self._quit_action.connect('activate', self.on_quit)
self._action_group.add_action(self._about_action)
self._action_group.add_action(self._help_action)
self._action_group.add_action(self._quit_action)
self.insert_action_group('keygen', self._action_group)
builder = Gtk.Builder()
builder.add_from_string(MENU_XML)
menubar = builder.get_object('menubar')
vbox.pack_start(Gtk.MenuBar.new_from_model(menubar), False, True, 0)
def __init__(self, app, builder):
super().__init__()
self.container = builder.get_object('toc_container')
self.scrolled_window = builder.get_object('toc_scrolledwindow')
self.view = builder.get_object('toc_treeview')
self.actions = Gio.SimpleActionGroup()
self.actions.add_action_entries([
('add-row', self._on_action_add_row),
('edit-row', self._on_action_edit_row),
('create-row', self._on_action_create_row, 's'),
('move-row', self._on_action_move_row, 's'),
('delete-row', self._on_action_remove_row),
])
self.container.get_toplevel().insert_action_group('toc', self.actions)
self.sidebar = TOCSidebar(builder, self.actions)
title_cell = ActivatableCellRendererText()
column = Gtk.TreeViewColumn('Title', title_cell, text=0)
column.set_property('expand', True)
self.view.append_column(column)
page_cell = ActivatableCellRendererText()
column = Gtk.TreeViewColumn('Page', page_cell, text=1)
self.view.append_column(column)
self.view.connect('row-activated', self._on_row_activated)
self.view.connect('button-release-event',
self._on_button_release_event)
self.view.connect('popup-menu', self._on_popup_menu)
self.view.get_selection().connect('changed',
self._on_selection_changed)
self.edit_form = EditForm(builder)
self.edit_form.connect('submit', self._on_edit_form_submit)
self.context_menu = TOCContextMenu()
self.context_menu.attach_to_widget(self.view)
def __init__(self):
super().__init__()
executable_path = self._get_executable_path()
self._config = TrackerConfig()
csv_dir = os.path.dirname(self._config.get_csv_path())
self.terminal = Vte.Terminal()
self.terminal.spawn_sync(
Vte.PtyFlags.DEFAULT,
csv_dir,
[executable_path],
[],
GLib.SpawnFlags.DO_NOT_REAP_CHILD,
None,
None,
)
self.terminal.connect("child-exited", self._on_terminal_exit)
self.hb = Gtk.HeaderBar()
self.hb.set_title(_("Data Analyzer"))
self.hb.set_subtitle(_("Learn everything about your data"))
self.hb.set_show_close_button(True)
self.set_titlebar(self.hb)
self.button_menu = Gtk.MenuButton()
self.button_menu.set_tooltip_text("Open menu")
self.button_menu.set_image(Gtk.Image.new_from_icon_name("application-vnd.oasis.opendocument.chart", Gtk.IconSize.LARGE_TOOLBAR))
self.hb.pack_end(self.button_menu)
popover = Gtk.Popover.new_from_model(self.button_menu, self._build_app_menu())
self.button_menu.set_popover(popover)
self.add(self.terminal)
self.action_group = Gio.SimpleActionGroup()
self.insert_action_group("analyzer", self.action_group)
self._set_actions()
self.show_all()
def __init__(self, *args, **kwargs):
Gtk.Notebook.__init__(self, *args, **kwargs)
self.action_group = Gio.SimpleActionGroup()
actions = (
("tabmoveleft", self.on_tab_move_left),
("tabmoveright", self.on_tab_move_right),
)
for (name, callback) in actions:
action = Gio.SimpleAction.new(name, None)
action.connect('activate', callback)
self.action_group.add_action(action)
self.insert_action_group("popup", self.action_group)
builder = Gtk.Builder.new_from_string(self.ui, -1)
self.popup_menu = builder.get_object("tab-menu")
provider = Gtk.CssProvider()
provider.load_from_data(self.css)
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(), provider,
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
# Awful hacks because we can't create GtkBindingArg from Python, or
# create a BindingSet from Python, or get a set by class from Python.
bindings = Gtk.BindingSet.find('TabSwitchBindings')
for i in range(10):
key = (i + 1) % 10
Gtk.BindingEntry().add_signal_from_string(
bindings, 'bind "<Alt>%d" { "tab-switch" (%d) };' % (key, i))
self.connect('tab-switch', self.do_tab_switch)
self.connect('button-press-event', self.on_button_press_event)
self.connect('popup-menu', self.on_popup_menu)
self.connect('page-added', self.on_page_added)
self.connect('page-removed', self.on_page_removed)
def _create_actions(self):
self.action_group = Gio.SimpleActionGroup()
self.insert_action_group("viewer", self.action_group)
self.app.shortcuts.register_group("viewer", _("Viewer"), position=60)
self.toggle_guidelines_action = Gio.SimpleAction.new(
"toggle-composition-guidelines", None)
self.toggle_guidelines_action.connect("activate",
self.__toggle_guidelines_cb)
self.action_group.add_action(self.toggle_guidelines_action)
self.app.shortcuts.add(
"viewer.toggle-composition-guidelines", ["<Primary><Shift>c"],
self.toggle_guidelines_action,
_("Toggle the currently selected composition guidelines"))
self.toggle_safe_areas_action = Gio.SimpleAction.new(
"toggle-safe-areas", None)
self.toggle_safe_areas_action.connect("activate",
self.__toggle_safe_areas_cb)
self.action_group.add_action(self.toggle_safe_areas_action)
self.app.shortcuts.add("viewer.toggle-safe-areas", ["apostrophe"],
self.toggle_safe_areas_action,
_("Toggle safe areas on viewer"))
def setup_ui(self, combo, button):
# pylint: disable=attribute-defined-outside-init
self.combo = combo
self.button = button
combo.set_model(self.ordered)
combo.set_id_column(0)
combo.set_entry_text_column(0)
combo.connect("changed", self._preset_changed_cb)
entry = combo.get_child()
alter_style_class("GtkEntry.unsaved", entry, "font-style:italic;")
action_group = Gio.SimpleActionGroup()
menu_model = Gio.Menu()
action = Gio.SimpleAction.new("new", None)
action.connect("activate", self._add_preset_cb)
action_group.add_action(action)
menu_model.append(_("New"), "preset.%s" % action.get_name())
self.action_new = action
action = Gio.SimpleAction.new("remove", None)
action.connect("activate", self._remove_preset_cb)
action_group.add_action(action)
menu_model.append(_("Remove"), "preset.%s" % action.get_name())
self.action_remove = action
action = Gio.SimpleAction.new("save", None)
action.connect("activate", self._save_preset_cb)
action_group.add_action(action)
menu_model.append(_("Save"), "preset.%s" % action.get_name())
self.action_save = action
menu = Gtk.Menu.new_from_model(menu_model)
menu.insert_action_group("preset", action_group)
button.set_popup(menu)
def __init__(self, event_manager):
super().__init__(event_manager)
self._event_handlers = []
self.gui_is_active = False
self.gui = Gtk.Builder()
self._mainloop_is_running = False
self.mainloop = get_mainloop(use_gtk=True)
gtk_build_file = get_ui_file_location(GTKBUILD_FILE)
if gtk_build_file is None:
raise InitializationError(
"Failed to load GTK layout specification file: {}".format(
gtk_build_file))
self.gui.add_from_file(gtk_build_file)
if pycam.Utils.get_platform() == pycam.Utils.OSPlatform.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)
action_group = Gio.SimpleActionGroup()
self.settings.set("gtk_action_group_prefix", "pycam")
self.settings.set("gtk_action_group", action_group)
self.window = self.gui.get_object("ProjectWindow")
self.window.insert_action_group(
self.settings.get("gtk_action_group_prefix"),
self.settings.get("gtk_action_group"))
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.OSPlatform.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_model_uri = None
# define callbacks and accelerator keys for the menu actions
for objname, callback, data, accel_key in (
("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"),
("HelpIntroduction", self.show_help, "introduction", "F1"),
("HelpSupportedFormats", self.show_help, "supported-formats",
None), ("HelpModelTransformations", self.show_help,
"model-transformations", None),
("HelpProcessSettings", self.show_help, "process-settings",
None), ("HelpBoundsSettings", self.show_help, "bounding-box",
None), ("HelpTouchOff", self.show_help, "touch-off",
None), ("Help3DView", self.show_help, "3d-view",
None), ("HelpServerMode", self.show_help,
"server-mode", None),
("HelpCommandLine", self.show_help, "cli-examples",
None), ("HelpHotkeys", self.show_help, "keyboard-shortcuts",
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,
"https://github.com/SebKuzminsky/pycam/issues/",
None), ("FeatureRequest", self.show_help,
"https://github.com/SebKuzminsky/pycam/issues/",
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) FIXME
# LinkButton does not work on Windows: https://bugzilla.gnome.org/show_bug.cgi?id=617874
if pycam.Utils.get_platform() == pycam.Utils.OSPlatform.WINDOWS:
def open_url(widget, data=None):
webbrowser.open(widget.get_uri())
Gtk.link_button_set_uri_hook(open_url)
# 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.insert_action_group(
self.settings.get("gtk_action_group_prefix"),
self.settings.get("gtk_action_group"))
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.about_window.insert_action_group(
self.settings.get("gtk_action_group_prefix"),
self.settings.get("gtk_action_group"))
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!
about_window_children = self.gui.get_object(
"AboutWindowButtons").get_children()
if about_window_children:
# it seems to be possible that there are no children - weird :(
# see https://github.com/SebKuzminsky/pycam/issues/59
about_window_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
self._accel_group.connect(
ord('w'), Gdk.ModifierType.CONTROL_MASK, Gtk.AccelFlags.LOCKED,
lambda accel_group, window, *args: window.emit(
"delete-event", Gdk.Event()))
self._accel_group.connect(ord('q'), Gdk.ModifierType.CONTROL_MASK,
Gtk.AccelFlags.LOCKED,
lambda *args: self.destroy())
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, fill=False, padding=3)
self.settings.register_ui_section("preferences_general",
add_general_prefs_item,
clear_general_prefs)
# set defaults
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(main_window.remove)
def add_main_window_item(item, name, **extra_args):
# some widgets may want to override the defaults
args = {"expand": False, "fill": False, "padding": 3}
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
})
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)
# 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)
for objname, callback in (
("ResetWorkspace", lambda widget: self.reset_workspace()),
("LoadWorkspace", lambda widget: self.load_workspace_dialog()),
("SaveWorkspace",
lambda widget: self.save_workspace_dialog(self.last_workspace_uri)
), ("SaveAsWorkspace",
lambda widget: self.save_workspace_dialog())):
self.gui.get_object(objname).connect("activate", callback)
# set the icons (in different sizes) for all windows
# Gtk.window_set_default_icon_list(*get_icons_pixbuffers()) FIXME
# load menu data
gtk_menu_file = get_ui_file_location(GTKMENU_FILE)
if gtk_menu_file is None:
raise InitializationError(
"Failed to load GTK menu specification file: {}".format(
gtk_menu_file))
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 [
aobj for aobj in self.gui.get_objects()
if isinstance(aobj, Gtk.Action)
]:
actiongroup.add_action(action)
# the "pos" parameter is optional since 2.12 - we can remove it later
uimanager.insert_action_group(actiongroup)
# the "recent files" sub-menu
if self.recent_manager is not 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 action_group not in uimanager.get_action_groups():
uimanager.insert_action_group(action_group, -1)
widget_name = widget.get_name()
item_type = Gtk.UIManagerItemType.MENU
else:
widget_name = name
item_type = Gtk.UIManagerItemType.SEPARATOR
uimanager.add_ui(merge_id, base_path, name, widget_name, item_type,
False)
if menu_key not in menu_merges:
menu_merges[menu_key] = []
menu_merges[menu_key].append(merge_id)
def get_menu_funcs(menu_key, base_path):
return (lambda widget, name: append_menu_item(
menu_key, base_path, widget, name),
lambda: clear_menu(menu_key))
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)
self.settings.set("set_last_filename", self.add_to_recent_file_list)
self._event_handlers.extend((
("history-changed", self._update_undo_button),
("model-change-after", "visual-item-updated"),
("gui-disable", disable_gui),
("gui-enable", enable_gui),
("notify-file-saved", self.add_to_recent_file_list),
("notify-file-opened", self.add_to_recent_file_list),
))
for name, target in self._event_handlers:
self.settings.register_event(name, target)
# allow the task settings control to be updated
self.mainloop.update()
# register a logging handler for displaying error messages
pycam.Utils.log.add_gtk_gui(self.window, logging.ERROR)
self.window.show()
self.mainloop.update()
def _export(self, window, gtk_group):
actions = [
["Preferences", "Plugins"],
["RefreshLibrary"],
["OnlineHelp", "About", "Quit"],
]
# build the new menu
menu = Gio.Menu()
action_names = []
for group in actions:
section = Gio.Menu()
for name in group:
action = gtk_group.get_action(name)
assert action
label = action.get_label()
section.append(label, "app." + name)
action_names.append(name)
menu.append_section(None, section)
menu.freeze()
# proxy activate to the old group
def callback(action, data):
name = action.get_name()
gtk_action = gtk_group.get_action(name)
gtk_action.activate()
action_group = Gio.SimpleActionGroup()
for name in action_names:
action = Gio.SimpleAction.new(name, None)
action_group.insert(action)
action.connect("activate", callback)
# export on the bus
ag_object_path = "/net/sacredchao/QuodLibet"
am_object_path = "/net/sacredchao/QuodLibet/menus/appmenu"
app_id = "net.sacredchao.QuodLibet"
win = window.get_window()
if not hasattr(win, "set_utf8_property"):
# not a GdkX11.X11Window
print_d("Registering appmenu failed: X11 only")
return
# FIXME: this doesn't fail on Windows but takes for ages.
# Maybe remove some deps to make it fail fast?
# We don't need dbus anyway there.
try:
bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)
self._ag_id = bus.export_action_group(ag_object_path, action_group)
self._am_id = bus.export_menu_model(am_object_path, menu)
except GLib.GError as e:
print_d("Registering appmenu failed: %r" % e)
return
self._bus = bus
win.set_utf8_property("_GTK_UNIQUE_BUS_NAME", bus.get_unique_name())
win.set_utf8_property("_GTK_APPLICATION_ID", app_id)
win.set_utf8_property("_GTK_APPLICATION_OBJECT_PATH", ag_object_path)
win.set_utf8_property("_GTK_APP_MENU_OBJECT_PATH", am_object_path)
def __init__(self, app, clip_properties):
Gtk.Expander.__init__(self)
self.set_expanded(True)
self.set_label(_("Effects"))
Loggable.__init__(self)
# Global variables related to effects
self.app = app
self._project = None
self._selection = None
self.selected_effects = []
self.clips = []
self._effect_config_ui = None
self.effects_properties_manager = EffectsPropertiesManager(app)
self.clip_properties = clip_properties
# The toolbar that will go between the list of effects and properties
buttons_box = Gtk.ButtonBox()
buttons_box.set_halign(Gtk.Align.END)
buttons_box.set_margin_end(SPACING)
buttons_box.props.margin_top = SPACING / 2
remove_effect_button = Gtk.Button()
remove_icon = Gtk.Image.new_from_icon_name("list-remove-symbolic",
Gtk.IconSize.BUTTON)
remove_effect_button.set_image(remove_icon)
remove_effect_button.set_always_show_image(True)
remove_effect_button.set_label(_("Remove effect"))
buttons_box.pack_start(remove_effect_button,
expand=False,
fill=False,
padding=0)
# We need to specify Gtk.TreeDragSource because otherwise we are hitting
# bug https://bugzilla.gnome.org/show_bug.cgi?id=730740.
class EffectsListStore(Gtk.ListStore, Gtk.TreeDragSource):
"""Just a work around!"""
# pylint: disable=non-parent-init-called
def __init__(self, *args):
Gtk.ListStore.__init__(self, *args)
# Set the source index on the storemodel directly,
# to avoid issues with the selection_data API.
# FIXME: Work around
# https://bugzilla.gnome.org/show_bug.cgi?id=737587
self.source_index = None
def do_drag_data_get(self, path, unused_selection_data):
self.source_index = path.get_indices()[0]
self.storemodel = EffectsListStore(bool, str, str, str, str, object)
self.treeview = Gtk.TreeView(model=self.storemodel)
self.treeview.set_property("has_tooltip", True)
self.treeview.set_headers_visible(False)
self.treeview.props.margin_top = SPACING
self.treeview.props.margin_left = SPACING
# Without this, the treeview hides the border of its parent.
# I should file a bug about this.
self.treeview.props.margin_right = 1
activated_cell = Gtk.CellRendererToggle()
activated_cell.props.xalign = 0
activated_cell.props.xpad = 0
activated_cell.connect("toggled", self._effectActiveToggleCb)
self.treeview.insert_column_with_attributes(-1,
_("Active"),
activated_cell,
active=COL_ACTIVATED)
type_col = Gtk.TreeViewColumn(_("Type"))
type_col.set_spacing(SPACING)
type_col.set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE)
type_cell = Gtk.CellRendererText()
type_cell.props.xpad = PADDING
type_col.pack_start(type_cell, expand=True)
type_col.add_attribute(type_cell, "text", COL_TYPE)
self.treeview.append_column(type_col)
name_col = Gtk.TreeViewColumn(_("Effect name"))
name_col.set_spacing(SPACING)
name_cell = Gtk.CellRendererText()
name_cell.props.xpad = PADDING
name_cell.set_property("ellipsize", Pango.EllipsizeMode.END)
name_col.pack_start(name_cell, expand=True)
name_col.add_attribute(name_cell, "text", COL_NAME_TEXT)
self.treeview.append_column(name_col)
# Allow the treeview to accept EFFECT_TARGET_ENTRY when drag&dropping.
self.treeview.enable_model_drag_dest([EFFECT_TARGET_ENTRY],
Gdk.DragAction.COPY)
# Enable reordering by drag&drop.
self.treeview.enable_model_drag_source(Gdk.ModifierType.BUTTON1_MASK,
[EFFECT_TARGET_ENTRY],
Gdk.DragAction.MOVE)
self.treeview_selection = self.treeview.get_selection()
self.treeview_selection.set_mode(Gtk.SelectionMode.SINGLE)
self._infobar = clip_properties.createInfoBar(
_("Select a clip on the timeline to configure its associated effects"
))
self._infobar.show_all()
# Prepare the main container widgets and lay out everything
self._vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self._vbox.pack_start(self.treeview,
expand=False,
fill=False,
padding=0)
self._vbox.pack_start(buttons_box, expand=False, fill=False, padding=0)
separator = Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL)
separator.set_margin_top(SPACING)
separator.set_margin_left(SPACING)
separator.set_margin_right(SPACING)
self._vbox.pack_start(separator, expand=False, fill=False, padding=0)
self._vbox.show_all()
self.add(self._vbox)
self.hide()
effects_actions_group = Gio.SimpleActionGroup()
self.treeview.insert_action_group("clipproperties-effects",
effects_actions_group)
buttons_box.insert_action_group("clipproperties-effects",
effects_actions_group)
self.app.shortcuts.register_group("clipproperties-effects",
_("Clip Effects"),
position=60)
self.remove_effect_action = Gio.SimpleAction.new("remove-effect", None)
self.remove_effect_action.connect("activate", self._removeEffectCb)
effects_actions_group.add_action(self.remove_effect_action)
self.app.shortcuts.add("clipproperties-effects.remove-effect",
["Delete"], _("Remove the selected effect"))
self.remove_effect_action.set_enabled(False)
remove_effect_button.set_action_name(
"clipproperties-effects.remove-effect")
# Connect all the widget signals
self.treeview_selection.connect("changed",
self._treeviewSelectionChangedCb)
self.treeview.connect("drag-motion", self._dragMotionCb)
self.treeview.connect("drag-leave", self._dragLeaveCb)
self.treeview.connect("drag-data-received", self._dragDataReceivedCb)
self.treeview.connect("query-tooltip", self._treeViewQueryTooltipCb)
self.app.project_manager.connect_after("new-project-loaded",
self._newProjectLoadedCb)
self.connect('notify::expanded', self._expandedCb)
