def __init__(self, bus):
filename = path.join(path.dirname(__file__), "setup.glade")
self.builder = Gtk.Builder()
self.builder.set_translation_domain(DOMAINNAME)
self.builder.add_from_file(filename)
event_handler = EventHandler()
self.builder.connect_signals(event_handler)
if not self.check_instance():
dummy_service = SetupService()
# Try to figure out the config file name:
self.config_file = None
if _ARGS.config_file:
# If the config file is specified on the command line, use that:
self.config_file = _ARGS.config_file
else:
# If the config file is not specified on the command line,
# try to get it from the environment. This is necessary
# in gnome-shell on Fedora 18 because the setup tool is
# called without command line options there but the
# environment variable IBUS_ENGINE_NAME is set:
try:
ibus_engine_name = os.environ['IBUS_ENGINE_NAME']
if ibus_engine_name.startswith('typing-booster:'):
self.config_file = (
ibus_engine_name.replace('typing-booster:', '') +
'.conf')
else:
self.__run_message_dialog(
_('Unknown format of engine name: ' +
'IBUS_ENGINE_NAME=%(name)s') %
{'name': ibus_engine_name}, Gtk.MessageType.WARNING)
except:
self.__run_message_dialog(
_("IBUS_ENGINE_NAME environment variable is not set."),
Gtk.MessageType.WARNING)
if self.config_file is None:
self.__run_message_dialog(
_('Cannot determine the config file for this engine. ' +
'Please use the --config-file option.'),
Gtk.MessageType.ERROR)
sys.exit(1)
return
self.config_file_full_path = (
'/usr/share/ibus-typing-booster/hunspell-tables/' +
self.config_file)
if not os.path.isfile(self.config_file_full_path):
self.__run_message_dialog(
_("Config file %(file)s does not exist.") %
{'file': self.config_file_full_path}, Gtk.MessageType.ERROR)
sys.exit(1)
return
self.tabsqlitedb = tabsqlitedb.tabsqlitedb(
config_filename=self.config_file_full_path)
self.name = self.tabsqlitedb.ime_properties.get('name')
self.config_section = "engine/typing-booster/%s" % self.name
self.hunspell_dict_package = self.tabsqlitedb.ime_properties.get(
'hunspell_dict_package')
self.symbol = self.tabsqlitedb.ime_properties.get('symbol')
self.bus = bus
self.config = self.bus.get_config()
maindialog = self.builder.get_object("main_dialog")
maindialog.set_title(
_("Preferences for ibus-typing-booster \"%(symbol)s\"") %
{'symbol': self.symbol})
# https://tronche.com/gui/x/icccm/sec-4.html#WM_CLASS
# gnome-shell seems to use the first argument of set_wmclass()
# to find the .desktop file. If the .desktop file can be
# found, the name shown by gnome-shell in the top bar comes
# from that .desktop file and the icon to show is also read
# from that .desktop file. If the .desktop file cannot be
# found, the second argument of set_wmclass() is shown by
# gnome-shell in the top bar.
#
# It only works like this when gnome-shell runs under Xorg
# though, under Wayland things are different.
maindialog.set_wmclass('ibus-setup-typing-booster',
'Typing Booster Preferences')
maindialog.show_all()
name_version = self.builder.get_object("name_version_label")
name_version.set_markup(
'<span font_size="large"><b>ibus-typing-booster %s</b></span>' %
version.get_version())
self.shortcut_entry = self.builder.get_object("shortcut_entry")
self.shortcut_expansion_entry = self.builder.get_object(
"shortcut_expansion_entry")
shortcut_clear_button = self.builder.get_object(
"shortcut_clear_button")
shortcut_clear_button.connect('clicked',
event_handler.on_shortcut_clear_clicked)
shortcut_delete_button = self.builder.get_object(
"shortcut_delete_button")
shortcut_delete_button.connect(
'clicked', event_handler.on_shortcut_delete_clicked)
shortcut_add_button = self.builder.get_object("shortcut_add_button")
shortcut_add_button.connect('clicked',
event_handler.on_shortcut_add_clicked)
self.shortcut_treeview = self.builder.get_object("shortcut_treeview")
self.shortcut_treeview_model = Gtk.ListStore(str, str)
self.shortcut_treeview.set_model(self.shortcut_treeview_model)
current_shortcuts = self.tabsqlitedb.list_user_shortcuts()
for i, shortcut in enumerate(current_shortcuts):
self.shortcut_treeview_model.append(shortcut)
self.shortcut_treeview.append_column(
Gtk.TreeViewColumn(
# Translators: Column heading of the table listing the existing shortcuts
_('Shortcut'),
Gtk.CellRendererText(),
text=0))
self.shortcut_treeview.append_column(
Gtk.TreeViewColumn(
# Translators: Column heading of the table listing the existing shortcuts
_('Shortcut expansion'),
Gtk.CellRendererText(),
text=1))
self.shortcut_treeview.get_selection().connect(
'changed', event_handler.on_shortcut_selected)
self.install_dictionary_button = self.builder.get_object(
"install_dictionary_button")
self.install_dictionary_button.connect(
'clicked', event_handler.on_install_dictionary_clicked)
self.learn_from_file_button = self.builder.get_object(
"learn_from_file_button")
self.learn_from_file_button.connect(
'clicked', event_handler.on_learn_from_file_clicked)
self.delete_learned_data_button = self.builder.get_object(
"delete_learned_data_button")
self.delete_learned_data_button.connect(
'clicked', event_handler.on_delete_learned_data_clicked)
close_button = self.builder.get_object("close_button")
close_button.connect('clicked', event_handler.onCloseClicked)
tab_enable_checkbox = self.builder.get_object("tab_enable_checkbox")
self.tab_enable = itb_util.variant_to_value(
self.config.get_value(self.config_section, 'tabenable'))
if self.tab_enable is None:
self.tab_enable = False
if self.tab_enable is True:
tab_enable_checkbox.set_active(True)
tab_enable_checkbox.connect('clicked',
event_handler.on_tab_enable_checkbox)
show_number_of_candidates_checkbox = self.builder.get_object(
"show_number_of_candidates_checkbox")
self.show_number_of_candidates = itb_util.variant_to_value(
self.config.get_value(self.config_section,
'shownumberofcandidates'))
if self.show_number_of_candidates is None:
self.show_number_of_candidates = False
if self.show_number_of_candidates is True:
show_number_of_candidates_checkbox.set_active(True)
show_number_of_candidates_checkbox.connect(
'clicked', event_handler.on_show_number_of_candidates_checkbox)
use_digits_as_select_keys_checkbox = self.builder.get_object(
"use_digits_as_select_keys_checkbox")
self.use_digits_as_select_keys = itb_util.variant_to_value(
self.config.get_value(self.config_section,
'usedigitsasselectkeys'))
if self.use_digits_as_select_keys is None:
self.use_digits_as_select_keys = True
if self.use_digits_as_select_keys is True:
use_digits_as_select_keys_checkbox.set_active(True)
use_digits_as_select_keys_checkbox.connect(
'clicked', event_handler.on_use_digits_as_select_keys_checkbox)
emoji_predictions_checkbox = self.builder.get_object(
"emoji_predictions_checkbox")
self.emoji_predictions = itb_util.variant_to_value(
self.config.get_value(self.config_section, 'emojipredictions'))
if self.emoji_predictions is None:
self.emoji_predictions = True
if self.emoji_predictions is True:
emoji_predictions_checkbox.set_active(True)
emoji_predictions_checkbox.connect(
'clicked', event_handler.on_emoji_predictions_checkbox)
off_the_record_checkbox = self.builder.get_object(
"off_the_record_checkbox")
self.off_the_record = itb_util.variant_to_value(
self.config.get_value(self.config_section, 'offtherecord'))
if self.off_the_record is None:
self.off_the_record = False
if self.off_the_record is True:
off_the_record_checkbox.set_active(True)
off_the_record_checkbox.connect(
'clicked', event_handler.on_off_the_record_checkbox)
qt_im_module_workaround_checkbox = self.builder.get_object(
"qt_im_module_workaround_checkbox")
self.qt_im_module_workaround = itb_util.variant_to_value(
self.config.get_value(self.config_section, 'qtimmoduleworkaround'))
if self.qt_im_module_workaround is None:
self.qt_im_module_workaround = False
if self.qt_im_module_workaround is True:
qt_im_module_workaround_checkbox.set_active(True)
qt_im_module_workaround_checkbox.connect(
'clicked', event_handler.on_qt_im_module_workaround_checkbox)
arrow_keys_reopen_preedit_checkbox = self.builder.get_object(
"arrow_keys_reopen_preedit_checkbox")
self.arrow_keys_reopen_preedit = itb_util.variant_to_value(
self.config.get_value(self.config_section,
'arrowkeysreopenpreedit'))
if self.arrow_keys_reopen_preedit is None:
self.arrow_keys_reopen_preedit = False
if self.arrow_keys_reopen_preedit is True:
arrow_keys_reopen_preedit_checkbox.set_active(True)
arrow_keys_reopen_preedit_checkbox.connect(
'clicked', event_handler.on_arrow_keys_reopen_preedit_checkbox)
show_status_info_in_auxiliary_text_checkbox = self.builder.get_object(
"show_status_info_in_auxiliary_text_checkbox")
self.show_status_info_in_auxiliary_text = itb_util.variant_to_value(
self.config.get_value(self.config_section, 'showstatusinfoinaux'))
if self.show_status_info_in_auxiliary_text is None:
self.show_status_info_in_auxiliary_text = True
if self.show_status_info_in_auxiliary_text is True:
show_status_info_in_auxiliary_text_checkbox.set_active(True)
show_status_info_in_auxiliary_text_checkbox.connect(
'clicked',
event_handler.on_show_status_info_in_auxiliary_text_checkbox)
add_direct_input_checkbox = self.builder.get_object(
"add_direct_input_checkbox")
self.add_direct_input = itb_util.variant_to_value(
self.config.get_value(self.config_section, 'adddirectinput'))
if self.add_direct_input is None:
self.add_direct_input = False
if self.add_direct_input is True:
add_direct_input_checkbox.set_active(True)
add_direct_input_checkbox.connect(
'clicked', event_handler.on_add_direct_input_checkbox)
remember_last_used_preedit_ime_checkbox = self.builder.get_object(
"remember_last_used_preedit_ime_checkbox")
self.remember_last_used_predit_ime = itb_util.variant_to_value(
self.config.get_value(self.config_section,
'rememberlastusedpreeditime'))
if self.remember_last_used_predit_ime is None:
self.remember_last_used_predit_ime = False
if self.remember_last_used_predit_ime is True:
remember_last_used_preedit_ime_checkbox.set_active(True)
remember_last_used_preedit_ime_checkbox.connect(
'clicked',
event_handler.on_remember_last_used_preedit_ime_checkbox)
auto_commit_characters_entry = self.builder.get_object(
"auto_commit_characters_entry")
self.auto_commit_characters = itb_util.variant_to_value(
self.config.get_value(self.config_section, 'autocommitcharacters'))
if not self.auto_commit_characters:
self.auto_commit_characters = ''
auto_commit_characters_entry.set_text(self.auto_commit_characters)
auto_commit_characters_entry.connect(
'notify::text', event_handler.on_auto_commit_characters_entry)
self.page_size_adjustment = self.builder.get_object(
"page_size_adjustment")
self.page_size = itb_util.variant_to_value(
self.config.get_value(self.config_section, 'pagesize'))
if self.page_size:
self.page_size_adjustment.set_value(int(self.page_size))
else:
self.page_size_adjustment.set_value(6)
self.page_size_adjustment.connect(
'value-changed',
event_handler.on_page_size_adjustment_value_changed)
self.min_char_complete_adjustment = self.builder.get_object(
"min_char_complete_adjustment")
self.min_char_complete = itb_util.variant_to_value(
self.config.get_value(self.config_section, 'mincharcomplete'))
if self.min_char_complete:
self.min_char_complete_adjustment.set_value(
int(self.min_char_complete))
else:
self.min_char_complete_adjustment.set_value(1)
self.min_char_complete_adjustment.connect(
'value-changed',
event_handler.on_min_char_complete_adjustment_value_changed)
self.lookup_table_orientation_combobox = self.builder.get_object(
"lookup_table_orientation_combobox")
lookup_table_orientation_store = Gtk.ListStore(str, int)
lookup_table_orientation_store.append(
[_('Horizontal'), IBus.Orientation.HORIZONTAL])
lookup_table_orientation_store.append(
[_('Vertical'), IBus.Orientation.VERTICAL])
lookup_table_orientation_store.append(
[_('System default'), IBus.Orientation.SYSTEM])
self.lookup_table_orientation_combobox.set_model(
lookup_table_orientation_store)
renderer_text = Gtk.CellRendererText()
self.lookup_table_orientation_combobox.pack_start(renderer_text, True)
self.lookup_table_orientation_combobox.add_attribute(
renderer_text, "text", 0)
lookup_table_orientation = itb_util.variant_to_value(
self.config.get_value(self.config_section,
'lookuptableorientation'))
if lookup_table_orientation is None:
lookup_table_orientation = IBus.Orientation.VERTICAL
for i, item in enumerate(lookup_table_orientation_store):
if lookup_table_orientation == item[1]:
self.lookup_table_orientation_combobox.set_active(i)
self.lookup_table_orientation_combobox.connect(
"changed",
event_handler.on_lookup_table_orientation_combobox_changed)
self.ime_combobox = self.builder.get_object("input_method_combobox")
self.input_method_help_button = self.builder.get_object(
"input_method_help_button")
ime_store = Gtk.ListStore(str, str)
self.supported_imes = []
imes = self.tabsqlitedb.ime_properties.get('imes').split(',')
if not imes:
imes = ['Native Keyboard:NoIme']
for item in imes:
ime_store.append([item.split(':')[0], item.split(':')[1]])
self.supported_imes.append(item.split(':')[1])
self.ime_combobox.set_model(ime_store)
self.ime_combobox.pack_start(renderer_text, True)
self.ime_combobox.add_attribute(renderer_text, "text", 0)
self.current_imes = []
inputmethod = itb_util.variant_to_value(
self.config.get_value(self.config_section, 'inputmethod'))
if inputmethod:
inputmethods = [x.strip() for x in inputmethod.split(',')]
for ime in inputmethods:
self.current_imes.append(ime)
if self.current_imes == []:
# There is no ime set in dconf, use the first value from
# the combobox as the default:
self.current_imes = [ime_store[0][1]]
if self.add_direct_input and 'NoIme' not in self.current_imes:
self.current_imes.append('NoIme')
if len(self.current_imes) == 1:
self.main_ime = self.current_imes[0]
else:
self.main_ime = ([
x for x in self.current_imes if x in self.supported_imes
][0])
combobox_has_ime = False
for i, dummy_item in enumerate(ime_store):
if ime_store[i][1] == self.main_ime:
self.ime_combobox.set_active(i)
combobox_has_ime = True
if combobox_has_ime is False:
# the combobox did not have the ime from the settings
# take the ime from the first row of
# the combobox as the fallback:
self.main_ime = ime_store[0][1]
self.ime_combobox.set_active(0)
self.ime_combobox.connect("changed",
event_handler.on_ime_combobox_changed)
if len(ime_store) < 2:
self.ime_combobox.set_sensitive(False)
self.input_method_help_button.connect(
'clicked', event_handler.on_input_method_help_button_clicked)
if self.main_ime == 'NoIme':
self.input_method_help_button.set_sensitive(False)
def __init__(self, exaile):
"""
Initializes the GUI
@param exaile: The Exaile instance
"""
from xlgui import icons, main, panels, tray, progress
Gdk.set_program_class("Exaile") # For GNOME Shell
# https://www.freedesktop.org/wiki/Software/PulseAudio/Documentation/Developer/Clients/ApplicationProperties/
GLib.set_application_name("Exaile")
os.environ['PULSE_PROP_media.role'] = 'music'
self.exaile = exaile
self.first_removed = False
self.tray_icon = None
self.builder = Gtk.Builder()
self.builder.add_from_file(xdg.get_data_path('ui', 'main.ui'))
self.progress_box = self.builder.get_object('progress_box')
self.progress_manager = progress.ProgressManager(self.progress_box)
add_icon = icons.MANAGER.add_icon_name_from_directory
images_dir = xdg.get_data_path('images')
exaile_icon_path = add_icon('exaile', images_dir)
Gtk.Window.set_default_icon_name('exaile')
if xdg.local_hack:
# PulseAudio also attaches the above name to streams. However, if
# Exaile is not installed, any app trying to display the icon won't
# be able to find it just by name. The following is a hack to tell
# PA the icon file path instead of the name; this only works on
# some clients, e.g. pavucontrol.
os.environ['PULSE_PROP_application.icon_name'] = exaile_icon_path
for name in (
'exaile-pause',
'exaile-play',
'office-calendar',
'extension',
'music-library',
'artist',
'genre',
):
add_icon(name, images_dir)
for name in ('dynamic', 'repeat', 'shuffle'):
add_icon('media-playlist-' + name, images_dir)
logger.info("Loading main window...")
self.main = main.MainWindow(self, self.builder, exaile.collection)
if self.exaile.options.StartMinimized:
self.main.window.iconify()
self.play_toolbar = self.builder.get_object('play_toolbar')
panel_notebook = self.builder.get_object('panel_notebook')
self.panel_notebook = panels.PanelNotebook(exaile, self)
self.device_panels = {}
# add the device panels
for device in self.exaile.devices.list_devices():
if device.connected:
self.add_device_panel(None, None, device)
logger.info("Connecting panel events...")
self.main._connect_panel_events()
guiutil.gtk_widget_replace(panel_notebook, self.panel_notebook)
self.panel_notebook.get_parent().child_set_property(
self.panel_notebook, 'shrink', False
)
if settings.get_option('gui/use_tray', False):
if tray.is_supported():
self.tray_icon = tray.TrayIcon(self.main)
else:
settings.set_option('gui/use_tray', False)
logger.warn(
"Tray icons are not supported on your platform. Disabling tray icon."
)
from xl import event
event.add_ui_callback(self.add_device_panel, 'device_connected')
event.add_ui_callback(self.remove_device_panel, 'device_disconnected')
event.add_ui_callback(self.on_gui_loaded, 'gui_loaded')
logger.info("Done loading main window...")
Main._main = self
if sys.platform == 'darwin':
self._setup_osx()
class Handler:
def __init__(self, label, button):
self.clock = Clock(label, button)
self.clock.start()
def onDestroy(self, *args):
self.clock.quit()
Gtk.main_quit()
def onButtonToggled(self, button):
if self.clock.stopped:
self.clock.restart()
else:
self.clock.stop()
builder = Gtk.Builder()
builder.add_from_file("clock.glade")
window = builder.get_object("window")
label = builder.get_object("label")
button = builder.get_object("stop")
handler = Handler(label, button)
builder.connect_signals(handler)
window.show_all()
Gtk.main()
def __init__(self):
import gui.application
app = gui.application.get_app()
assert app is not None
super(PreferencesWindow, self).__init__(
app=app,
title=_('Preferences'),
transient_for=app.drawWindow,
destroy_with_parent=True,
)
self.add_buttons(
Gtk.STOCK_REVERT_TO_SAVED,
RESPONSE_REVERT,
Gtk.STOCK_OK,
Gtk.ResponseType.ACCEPT,
)
self.connect('response', self.on_response)
self.in_update_ui = False
# Set up widgets
builder = Gtk.Builder()
builder.set_translation_domain("mypaint")
ui_dir = os.path.dirname(os.path.abspath(__file__))
xml_path = os.path.join(ui_dir, 'preferenceswindow.glade')
builder.add_from_file(xml_path)
self._builder = builder
getobj = builder.get_object
# Notebook
nb = getobj("prefs_notebook")
self.nb = nb
self.vbox.pack_start(nb, True, True, 0)
# Curve init
curve = getobj("mapping_curve")
curve.changed_cb = self.pressure_curve_changed_cb
curve.magnetic = False
self._pressure_curve = curve
# Button mappings editor
assert "input.button_mapping" in app.preferences
reg = gui.mode.ModeRegistry
actions_possible = [
n for n in reg.get_action_names()
if issubclass(reg.get_mode_class(n), gui.mode.DragMode)
]
actions_possible += gui.mode.BUTTON_BINDING_ACTIONS
bm_ed = getobj("button_mapping_editor")
bm_ed.set_bindings(app.preferences["input.button_mapping"])
bm_ed.set_actions(actions_possible)
bm_ed.bindings_observers.append(self.button_mapping_edited_cb)
# Autosave controls
autosave_interval_spinbut = getobj("autosave_interval_spinbutton")
self._autosave_interval_spinbutton = autosave_interval_spinbut
# Signal hookup now everything is in the right initial state
self._builder.connect_signals(self)
def _setup_headerbar(self):
# define the main buttons for the headerbar
builder = Gtk.Builder()
ui = rb.find_plugin_file(self.plugin, 'ui/altlibrary.ui')
builder.add_from_file(ui)
self.load_builder_content(builder)
view_name = "Categories"
self.library_browser_radiobutton.set_label(view_name)
default = Gtk.Settings.get_default()
self.headerbar = Gtk.HeaderBar.new()
self.headerbar.set_show_close_button(True)
self.main_window.set_titlebar(
self.headerbar
) # this is needed for gnome-shell to replace the decoration
self.main_window.set_show_menubar(False)
self.plugin.rb_toolbar.hide()
self.start_box = Gtk.Box.new(Gtk.Orientation.HORIZONTAL,
0) # left side box
self.headerbar.pack_start(self.start_box)
self.headerbar.set_custom_title(self.library_box)
self._end_box_controls = Gtk.Box.new(Gtk.Orientation.HORIZONTAL,
0) # right side box
self.end_box = Gtk.Box.new(Gtk.Orientation.HORIZONTAL,
0) # any source defined controls
self._end_box_controls.add(self.end_box)
if (not default.props.gtk_shell_shows_app_menu
) or default.props.gtk_shell_shows_menubar:
# for environments that dont support app-menus
menu_button = Gtk.MenuButton.new()
# menu_button.set_relief(Gtk.ReliefStyle.NONE)
if gtk_version() >= 3.14:
symbol = "open-menu-symbolic"
menu_button.set_margin_start(3)
else:
symbol = "emblem-system-symbolic"
menu_button.set_margin_left(3)
image = Gtk.Image.new_from_icon_name(symbol,
Gtk.IconSize.SMALL_TOOLBAR)
menu_button.add(image)
menu = self.shell.props.application.get_shared_menu('app-menu')
menu_button.set_menu_model(menu)
self._end_box_controls.add(menu_button)
self.headerbar.pack_end(self._end_box_controls)
self.headerbar.show_all()
action = self.plugin.toggle_action_group.get_action('ToggleToolbar')
if not self.plugin.start_hidden:
action.set_active(True)
print("not hidden")
else:
action.set_active(False)
self.set_visible(False)
def add_from_file(self, fn):
builder = Gtk.Builder()
if self.domain is not None: builder.set_translation_domain(self.domain)
self.builders.append(builder)
builder.add_from_file(fn)
def __init__(self,
state,
uistate,
track,
categories,
msg,
label=None,
button_label=None,
tool_tip=None,
content=_REPORTS):
"""
Display the dialog box, and build up the list of available
reports. This is used to build the selection tree on the left
hand side of the dialog box.
"""
self.active = uistate.get_active('Person')
self.imap = {}
self.msg = msg
self.content = content
self._pmgr = GuiPluginManager.get_instance()
ManagedWindow.__init__(self, uistate, track, self.__class__)
self.state = state
self.uistate = uistate
self.dialog = Gtk.Builder()
self.dialog.add_from_file(PLUGINS_GLADE)
self.dialog.connect_signals({
"on_report_apply_clicked": self.on_apply_clicked,
"destroy_passed_object": self.close,
"on_delete_event": self.close,
})
self.tree = self.dialog.get_object("tree")
window = self.dialog.get_object("report")
self.title = self.dialog.get_object("title")
self.set_window(window, self.title, msg)
self.store = Gtk.TreeStore(str)
self.selection = self.tree.get_selection()
self.selection.connect('changed', self.on_node_selected)
col = Gtk.TreeViewColumn('', Gtk.CellRendererText(), text=0)
self.tree.append_column(col)
self.tree.set_model(self.store)
self.description = self.dialog.get_object("description")
if label:
self.description.set_text(label)
self.status = self.dialog.get_object("report_status")
self.author_name = self.dialog.get_object("author_name")
self.author_email = self.dialog.get_object("author_email")
self.apply_button = self.dialog.get_object("apply")
if button_label:
self.apply_button.set_label(button_label)
else:
self.apply_button.set_label(_("_Apply"))
self.apply_button.set_use_underline(True)
if tool_tip:
self.apply_button.set_tooltip_text(tool_tip)
self.item = None
if content == _REPORTS:
reg_list = self._pmgr.get_reg_reports()
elif content == _TOOLS:
reg_list = self._pmgr.get_reg_tools()
else:
reg_list = []
self.build_plugin_tree(reg_list, categories)
self.show()
def __init__(self):
if Wnck:
self.screen = Wnck.Screen.get_default()
component.Component.__init__(self, 'MainWindow', interval=2)
self.config = ConfigManager('gtk3ui.conf')
self.main_builder = Gtk.Builder()
# Patch this GtkBuilder to avoid connecting signals from elsewhere
#
# Think about splitting up mainwindow gtkbuilder file into the necessary parts
# to avoid GtkBuilder monkey patch. Those parts would then need adding to mainwindow 'by hand'.
self.gtk_builder_signals_holder = _GtkBuilderSignalsHolder()
# FIXME: The deepcopy has been removed: copy.deepcopy(self.main_builder.connect_signals)
self.main_builder.prev_connect_signals = self.main_builder.connect_signals
def patched_connect_signals(*a, **k):
raise RuntimeError(
'In order to connect signals to this GtkBuilder instance please use '
'"component.get(\'MainWindow\').connect_signals()"')
self.main_builder.connect_signals = patched_connect_signals
# Get Gtk Builder files Main Window, New release dialog, and Tabs.
ui_filenames = [
'main_window.ui',
'main_window.new_release.ui',
'main_window.tabs.ui',
'main_window.tabs.menu_file.ui',
'main_window.tabs.menu_peer.ui',
]
for filename in ui_filenames:
self.main_builder.add_from_file(
resource_filename(__package__, os.path.join('glade',
filename)))
self.window = self.main_builder.get_object('main_window')
self.window.set_icon(get_deluge_icon())
self.tabsbar_pane = self.main_builder.get_object('tabsbar_pane')
self.sidebar_pane = self.main_builder.get_object('sidebar_pane')
# Keep a list of components to pause and resume when changing window state.
self.child_components = ['TorrentView', 'StatusBar', 'TorrentDetails']
# Load the window state
self.load_window_state()
# Keep track of window minimization state so we don't update UI when it is minimized.
self.is_minimized = False
self.restart = False
self.window.drag_dest_set(
Gtk.DestDefaults.ALL,
[Gtk.TargetEntry.new(target='text/uri-list', flags=0, info=80)],
DragAction.COPY,
)
# Connect events
self.window.connect('window-state-event', self.on_window_state_event)
self.window.connect('configure-event', self.on_window_configure_event)
self.window.connect('delete-event', self.on_window_delete_event)
self.window.connect('drag-data-received',
self.on_drag_data_received_event)
self.tabsbar_pane.connect('notify::position',
self.on_tabsbar_pane_position_event)
self.sidebar_pane.connect('notify::position',
self.on_sidebar_pane_position_event)
self.window.connect('draw', self.on_expose_event)
self.config.register_set_function('show_rate_in_title',
self._on_set_show_rate_in_title,
apply_now=False)
client.register_event_handler('NewVersionAvailableEvent',
self.on_newversionavailable_event)
def __init__(self, base_codename, ppa_owner, ppa_name):
if platform.machine() == "x86_64":
architecture = "amd64"
else:
architecture = "i386"
ppa_origin = "LP-PPA-%s-%s" % (ppa_owner, ppa_name)
ppa_origin_simple = "LP-PPA-%s" % (ppa_owner)
ppa_file = "/var/lib/apt/lists/ppa.launchpad.net_%s_%s_ubuntu_dists_%s_main_binary-%s_Packages" % (ppa_owner, ppa_name, base_codename, architecture)
if not os.path.exists(ppa_file):
print ("%s not found!" % ppa_file)
sys.exit(1)
self.packages_to_install = []
self.packages_installed_from_ppa = []
glade_file = "/usr/lib/linuxmint/mintSources/mintsources.glade"
self.builder = Gtk.Builder()
self.builder.set_translation_domain("mintsources")
self.builder.add_from_file(glade_file)
self.window = self.builder.get_object("ppa_window")
self.window.set_title(_("PPA"))
self.window.set_icon_name("software-sources")
self.window.connect("destroy", Gtk.main_quit)
self.builder.get_object("button_cancel").connect("clicked", Gtk.main_quit)
self.install_button = self.builder.get_object("button_install")
self.install_button.connect("clicked", self.install)
self.install_button.set_sensitive(False)
self.builder.get_object("label_ppa_name").set_markup("%s/%s" % (ppa_owner, ppa_name))
self.model = Gtk.ListStore(object, bool, str)
treeview = self.builder.get_object("treeview_ppa_pkgs")
treeview.set_model(self.model)
self.model.set_sort_column_id(2, Gtk.SortType.ASCENDING)
r = Gtk.CellRendererToggle()
r.connect("toggled", self.toggled)
col = Gtk.TreeViewColumn("", r)
col.set_cell_data_func(r, self.datafunction_checkbox)
treeview.append_column(col)
col.set_sort_column_id(1)
r = Gtk.CellRendererText()
col = Gtk.TreeViewColumn("", r, markup = 2)
treeview.append_column(col)
col.set_sort_column_id(2)
cache = apt.Cache()
self.apt = mintcommon.aptdaemon.APT(self.window)
packages = subprocess.getoutput("grep 'Package:' %s | sort | awk {'print $2;'}" % ppa_file).split("\n")
for package in packages:
if package in cache:
pkg = cache[package]
candidate = pkg.candidate
if candidate is not None and candidate.downloadable:
for origin in candidate.origins:
if origin.origin == ppa_origin or origin.origin == ppa_origin_simple:
if pkg.is_installed:
if pkg.installed.version != candidate.version:
already_installed_str = _("version %s already installed") % pkg.installed.version
self.model.append((pkg, False, "<b>%s</b>\n%s (%s)" % (pkg.name, candidate.version, already_installed_str)))
else:
already_installed_str = _("already installed")
self.model.append((pkg, False, "<b>%s</b>\n%s (%s)" % (pkg.name, candidate.version, already_installed_str)))
self.packages_installed_from_ppa.append(pkg.name)
else:
self.model.append((pkg, False, "<b>%s</b>\n%s" % (pkg.name, candidate.version)))
break
treeview.show()
self.window.show_all()
DISPLAY = os.environ["DISPLAY"]
DisplayServer = os.getenv('XDG_SESSION_TYPE', 'xorg')
print("You are recording on: " + str(DisplayServer))
if "wayland" in DisplayServer:
DisplayServer = "gnomewayland"
global GNOMEScreencast
GNOMEScreencast = bus.get('org.gnome.Shell.Screencast',
'/org/gnome/Shell/Screencast')
else:
DisplayServer = "xorg"
# Import the glade file and its widgets.
builder = Gtk.Builder() # type: Gtk.Builder
install_prefix = prefix()
possible_ui_file_locations = []
app_indicator_icon = ''
if os.getenv('VIRTUAL_ENV'):
possible_ui_file_locations.append(
os.path.join(os.path.dirname(os.getenv('VIRTUAL_ENV')), "ui",
"ui.glade"))
app_indicator_icon = os.path.join(
os.path.dirname(os.getenv('VIRTUAL_ENV')), "data",
"green-recorder.png")
elif install_prefix:
possible_ui_file_locations.append(install_prefix +
"/share/green-recorder/ui.glade")
app_indicator_icon = install_prefix + "/share/pixmaps/green-recorder.png"
def __init__(self):
# state
self.step = 0
#Load GUI from glade file
self.builder = Gtk.Builder()
self.builder.add_from_file("client_gui.glade")
# update constants in builder
update_range([
self.builder.get_object("lift_adjustment"),
self.builder.get_object("lift_meas_adjustment")
], miro.constants.LIFT_RAD_MIN, miro.constants.LIFT_RAD_MAX)
update_range([
self.builder.get_object("yaw_adjustment"),
self.builder.get_object("yaw_meas_adjustment")
], miro.constants.YAW_RAD_MIN, miro.constants.YAW_RAD_MAX)
update_range([
self.builder.get_object("pitch_adjustment"),
self.builder.get_object("pitch_meas_adjustment")
], miro.constants.PITCH_RAD_MIN, miro.constants.PITCH_RAD_MAX)
#Connect signals to handle callbacks from event
self.builder.connect_signals(self)
#Get Windows from GUI
self.MainWindow = self.builder.get_object("MainWindow")
self.CamWindow = self.builder.get_object("CamWindow")
self.MicWindow = self.builder.get_object("MicWindow")
self.MicScrolledWindow = self.builder.get_object("MicScrolledWindow")
#Get Cam and Mic Buttons from GUI
self.DisplayCamButton = self.builder.get_object("DisplayCamButton")
self.DisplayMicButton = self.builder.get_object("DisplayMicButton")
#Get Battery objects from GUI
self.BatteryText = self.builder.get_object("BatteryText")
self.BatteryBar = self.builder.get_object("BatteryBar")
self.BatteryBar.add_offset_value(Gtk.LEVEL_BAR_OFFSET_LOW, 4.6)
self.BatteryBar.add_offset_value(Gtk.LEVEL_BAR_OFFSET_HIGH, 4.8)
#self.BatteryBar.add_offset_value(Gtk.LEVEL_BAR_OFFSET_FULL, 5.0)
#Get Sonar objects from GUI
self.SonarText = self.builder.get_object("SonarText")
self.SonarBar = self.builder.get_object("SonarBar")
#Get Light objects from GUI
self.gui_LightBarFL = self.builder.get_object("LightBarFL")
self.gui_LightBarFR = self.builder.get_object("LightBarFR")
self.gui_LightBarRL = self.builder.get_object("LightBarRL")
self.gui_LightBarRR = self.builder.get_object("LightBarRR")
#Get Touch objects from GUI
self.BodyTouchText = self.builder.get_object("BodyTouchText")
self.HeadTouchText = self.builder.get_object("HeadTouchText")
self.BodyTouchBars = []
self.HeadTouchBars = []
for i in range(14):
temp = self.builder.get_object("BT" + str(i))
self.BodyTouchBars.append(temp)
temp = self.builder.get_object("HT" + str(i))
self.HeadTouchBars.append(temp)
#Get Accelerometer objects from GUI
self.gui_AccBarBX = self.builder.get_object("AccBarBX")
self.gui_AccBarBY = self.builder.get_object("AccBarBY")
self.gui_AccBarBZ = self.builder.get_object("AccBarBZ")
self.gui_AccBarBL2 = self.builder.get_object("AccBarBL2")
self.gui_AccBarHX = self.builder.get_object("AccBarHX")
self.gui_AccBarHY = self.builder.get_object("AccBarHY")
self.gui_AccBarHZ = self.builder.get_object("AccBarHZ")
self.gui_AccBarHL2 = self.builder.get_object("AccBarHL2")
#Get Cliff objects from GUI
self.gui_CliffBarL = self.builder.get_object("CliffBarL")
self.gui_CliffBarR = self.builder.get_object("CliffBarR")
#Get Wheel Speed objects from GUI
self.gui_WheelSpeedOptoL = self.builder.get_object("WheelSpeedOptoL")
self.gui_WheelSpeedOptoR = self.builder.get_object("WheelSpeedOptoR")
self.gui_WheelSpeedEMFL = self.builder.get_object("WheelSpeedEMFL")
self.gui_WheelSpeedEMFR = self.builder.get_object("WheelSpeedEMFR")
self.VelControl = self.builder.get_object("VelControl")
self.AngVelControl = self.builder.get_object("AngVelControl")
self.UserControlVel = self.builder.get_object("UserControlVelocity")
self.YawControl = self.builder.get_object("YawControl")
self.LiftControl = self.builder.get_object("LiftControl")
self.PitchControl = self.builder.get_object("PitchControl")
self.ResetKinButton = self.builder.get_object("ResetKinButton")
self.UserControlKin = self.builder.get_object("UserControlKin")
self.LeftEyeControl = self.builder.get_object("LeftEyeControl")
self.RightEyeControl = self.builder.get_object("RightEyeControl")
self.BlinkButton = self.builder.get_object("BlinkButton")
self.WiggleButton = self.builder.get_object("WiggleButton")
self.LeftEarControl = self.builder.get_object("LeftEarControl")
self.RightEarControl = self.builder.get_object("RightEarControl")
self.WagControl = self.builder.get_object("WagControl")
self.DroopControl = self.builder.get_object("DroopControl")
self.WagRateControl = self.builder.get_object("WagRateControl")
self.CosResetButton = self.builder.get_object("CosResetButton")
self.UserControlCos = self.builder.get_object("UserControlCos")
self.VelMeasured = self.builder.get_object("VelMeasured")
self.AngVelMeasured = self.builder.get_object("AngVelMeasured")
self.LiftMeasured = self.builder.get_object("LiftMeasured")
self.YawMeasured = self.builder.get_object("YawMeasured")
self.PitchMeasured = self.builder.get_object("PitchMeasured")
self.FreqControl = self.builder.get_object("FreqControl")
self.VolControl = self.builder.get_object("VolControl")
self.DurationControl = self.builder.get_object("DurationControl")
self.Tone1Button = self.builder.get_object("Tone1Button")
self.Tone2Button = self.builder.get_object("Tone2Button")
self.Tone3Button = self.builder.get_object("Tone3Button")
self.Tone4Button = self.builder.get_object("Tone4Button")
self.SendToneButton = self.builder.get_object("SendToneButton")
self.UserControlIllum = self.builder.get_object("UserControlIllum")
self.gui_LEDBrightF = self.builder.get_object("LEDBrightF")
self.gui_LEDBrightM = self.builder.get_object("LEDBrightM")
self.gui_LEDBrightR = self.builder.get_object("LEDBrightR")
self.gui_LEDColourF = self.builder.get_object("LEDColourF")
self.gui_LEDColourM = self.builder.get_object("LEDColourM")
self.gui_LEDColourR = self.builder.get_object("LEDColourR")
self.gui_Camera = [
self.builder.get_object("CameraLeft"),
self.builder.get_object("CameraRight")
]
self.gui_ResolutionSelection = self.builder.get_object(
"ResolutionSelection")
self.gui_CapResolutionSelection = self.builder.get_object(
"CapResolutionSelection")
self.gui_CapFPSSelection = self.builder.get_object("CapFPSSelection")
self.gui_MeasuredFPS = self.builder.get_object("MeasuredFPS")
#Generate variables to store user input
self.preset = False
self.user_blink = 0
self.user_waggle = 0
self.user_wiggle = 0
self.user_wag_rate = 0
self.wag_phase = 0
#Microphone Parameters
# Number of points to display
self.x_len = 40000
# number of microphones coming through on topic
self.no_of_mics = 4
#Generate figure for plotting mics
self.fig1 = plt.figure()
self.fig1.suptitle("Microphones") # Give figure title
#LEFT EAR
self.left_ear_plot = self.fig1.add_subplot(4, 1, 1)
self.left_ear_plot.set_ylim([-33000, 33000])
self.left_ear_plot.set_xlim([0, self.x_len])
self.left_ear_xs = np.arange(0, self.x_len)
self.left_ear_plot.set_xticklabels([])
self.left_ear_plot.set_yticks([])
self.left_ear_plot.grid(which="both", axis="x")
self.left_ear_plot.set_ylabel("Left Ear", rotation=0, ha="right")
self.left_ear_ys = np.zeros(self.x_len)
self.left_ear_line, = self.left_ear_plot.plot(self.left_ear_xs,
self.left_ear_ys,
linewidth=0.5,
color="b")
#RIGHT EAR
self.right_ear_plot = self.fig1.add_subplot(4, 1, 2)
self.right_ear_plot.set_ylim([-33000, 33000])
self.right_ear_plot.set_xlim([0, self.x_len])
self.right_ear_xs = np.arange(0, self.x_len)
self.right_ear_plot.set_xticklabels([])
self.right_ear_plot.set_yticks([])
self.right_ear_plot.grid(which="both", axis="x")
self.right_ear_plot.set_ylabel("Right Ear", rotation=0, ha="right")
self.right_ear_ys = np.zeros(self.x_len)
self.right_ear_line, = self.right_ear_plot.plot(self.right_ear_xs,
self.right_ear_ys,
linewidth=0.5,
color="r")
#HEAD
self.head_plot = self.fig1.add_subplot(4, 1, 3)
self.head_plot.set_ylim([-33000, 33000])
self.head_plot.set_xlim([0, self.x_len])
self.head_xs = np.arange(0, self.x_len)
self.head_plot.set_xticklabels([])
self.head_plot.set_yticks([])
self.head_plot.grid(which="both", axis="x")
self.head_plot.set_ylabel("Head", rotation=0, ha="right")
self.head_ys = np.zeros(self.x_len)
self.head_line, = self.head_plot.plot(self.head_xs,
self.head_ys,
linewidth=0.5,
color="g")
#Tail
self.tail_plot = self.fig1.add_subplot(4, 1, 4)
self.tail_plot.set_ylim([-33000, 33000])
self.tail_plot.set_xlim([0, self.x_len])
self.tail_xs = np.arange(0, self.x_len)
self.tail_plot.set_yticks([])
self.tail_plot.set_xlabel("Samples")
self.tail_plot.grid(which="both", axis="x")
self.tail_plot.set_ylabel("Tail", rotation=0, ha="right")
self.tail_ys = np.zeros(self.x_len)
self.tail_line, = self.tail_plot.plot(self.tail_xs,
self.tail_ys,
linewidth=0.5,
color="c")
self.canvas = FigureCanvas(self.fig1)
self.ani = animation.FuncAnimation(self.fig1,
self.update_line,
fargs=(
self.left_ear_ys,
self.right_ear_ys,
self.head_ys,
self.tail_ys,
),
init_func=self.animation_init,
interval=10,
blit=False)
self.fig1.subplots_adjust(hspace=0, wspace=0)
self.MicScrolledWindow.add_with_viewport(self.canvas)
# variables to store input data
self.input_package = None
self.input_camera = [None, None]
self.t_input_camera = [[], []]
self.input_mics = np.zeros((self.x_len, self.no_of_mics))
#Create object to convert ROS images to OpenCV format
self.image_converter = CvBridge()
#Start timer to call function which updates GUI
GObject.timeout_add(20, self.update_gui)
GObject.timeout_add(20, self.update_images)
#Create objects to hold published data
self.velocity = TwistStamped()
self.kin_joints = JointState()
self.kin_joints.name = ["tilt", "lift", "yaw", "pitch"]
self.kin_joints.position = [0.0, math.radians(34.0), 0.0, 0.0]
self.cos_joints = Float32MultiArray()
self.cos_joints.data = [0.0, 0.5, 0.0, 0.0, 0.0, 0.0]
self.tone = UInt16MultiArray()
self.tone.data = [0, 0, 0]
self.illum = UInt32MultiArray()
self.illum.data = [
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
0xFFFFFFFF
]
#
self.camera_zoom = None
self.auto_camera_zoom = [0,
0] # determine zoom from first received frame
self.frame_params = [180, '180w', 15]
self.meas_fps = ["", ""]
# set initial values
self.on_ResetCosButton_clicked()
self.on_LEDReset_clicked()
# display GUI
self.MainWindow.show_all()
# robot name
topic_base = "/" + os.getenv("MIRO_ROBOT_NAME") + "/"
# publishers
self.pub_cmd_vel = rospy.Publisher(topic_base + "control/cmd_vel",
TwistStamped,
queue_size=0)
self.pub_cos = rospy.Publisher(topic_base + "control/cosmetic_joints",
Float32MultiArray,
queue_size=0)
self.pub_illum = rospy.Publisher(topic_base + "control/illum",
UInt32MultiArray,
queue_size=0)
self.pub_kin = rospy.Publisher(topic_base + "control/kinematic_joints",
JointState,
queue_size=0)
self.pub_tone = rospy.Publisher(topic_base + "control/tone",
UInt16MultiArray,
queue_size=0)
self.pub_command = rospy.Publisher(topic_base + "control/command",
String,
queue_size=0)
# subscribers
self.sub_package = rospy.Subscriber(topic_base + "sensors/package",
miro.msg.sensors_package,
self.callback_package)
self.sub_mics = rospy.Subscriber(topic_base + "sensors/mics",
Int16MultiArray, self.callback_mics)
self.sub_caml = rospy.Subscriber(
topic_base + "sensors/caml/compressed", CompressedImage,
self.callback_caml)
self.sub_camr = rospy.Subscriber(
topic_base + "sensors/camr/compressed", CompressedImage,
self.callback_camr)
def __init__(self):
self.client_tcp=None
self.operator="INV"
self.operandes="MATRICE"
self.matrix_list={}
self.builder=Gtk.Builder()
self.builder.add_from_file("./glade/LAC_Applicationwindow.glade")
self.window=self.builder.get_object("window")
self.spinner=self.builder.get_object('spinner')
self.ajouter_resultat_button=self.builder.get_object('ajouter_resultat_button')
self.sendsms_button=self.builder.get_object('sendsms_button')
self.delete_matrix_button=self.builder.get_object('delete_matrix_button')
self.edit_matrix_button=self.builder.get_object('edit_matrix_button')
self.premiere_op_box=self.builder.get_object("premiere_op_box")
self.deuxieme_op_box=self.builder.get_object("deuxieme_op_box")
self.operation_label=self.builder.get_object("operation_label")
self.premiere_op_label=self.builder.get_object("premiere_op_label")
self.comboboxtext1=self.builder.get_object("comboboxtext1")
self.famille_box1=self.builder.get_object("famille_box1")
self.deuxieme_op_label=self.builder.get_object("deuxieme_op_label")
self.comboboxtext2=self.builder.get_object("comboboxtext2")
self.famille_box2=self.builder.get_object("famille_box2")
self.spinbutton=self.builder.get_object("spinbutton")
self.treeview=self.builder.get_object("treeview")
self.combobox=self.builder.get_object("combobox")
self.resultat_matrix_box=self.builder.get_object("resultat_matrix_box")
self.liststore=Gtk.ListStore(str,int,int)
self.treeview.set_model(self.liststore)
renderer=Gtk.CellRendererText()
column=Gtk.TreeViewColumn("Nom",renderer,text=0)
self.treeview.append_column(column)
column=Gtk.TreeViewColumn("Nbr Ligne",renderer,text=1)
self.treeview.append_column(column)
column=Gtk.TreeViewColumn("Nbr Col",renderer,text=2)
self.treeview.append_column(column)
self.window.show_all()
self.error_label=self.builder.get_object("error_label")
self.resultat_label1=self.builder.get_object("resultat_label1")
self.resultat_label2=self.builder.get_object("resultat_label2")
self.textbuffer1=self.builder.get_object("textbuffer1")
self.textbuffer2=self.builder.get_object("textbuffer2")
self.ajouter_resultat_button.hide()
self.deuxieme_op_box.set_visible(False)
self.premiere_op_label.set_text("Choisir une matrice")
self.famille_box1.set_visible(False)
self.error_label.hide()
self.resultat_label2.hide()
self.resultat_label1.hide()
self.combobox1_type="MATRICE"
self.combobox2_type=""
self.builder.connect_signals(Handler(self))
def __init__(self, album_id, genre_ids, artist_ids, popover, size_group):
"""
Init detailed album widget
@param album id as int
@param genre ids as [int]
@param artist ids as [int]
@param popover as bool
@param size group as Gtk.SizeGroup
"""
Gtk.Bin.__init__(self)
AlbumWidget.__init__(self, album_id, genre_ids)
self._artist_ids = artist_ids
self._pop_allowed = not popover or Gtk.get_minor_version() > 16
builder = Gtk.Builder()
builder.add_from_resource('/org/gnome/Lollypop/%s.ui' %
type(self).__name__)
self._color = builder.get_object('color')
rating = RatingWidget(self._album)
rating.show()
builder.get_object('coverbox').add(rating)
builder.connect_signals(self)
self._artist_label = builder.get_object('artist')
if len(artist_ids) > 1:
self._artist_label.set_text(self._album.artist_name)
self._artist_label.show()
label = builder.get_object('duration')
duration = Lp().albums.get_duration(album_id, genre_ids)
hours = int(duration / 3600)
mins = int(duration / 60)
if hours > 0:
mins -= hours * 60
if mins > 0:
label.set_text(_("%s h %s m") % (hours, mins))
else:
label.set_text(_("%s h") % hours)
else:
label.set_text(_("%s m") % mins)
grid = builder.get_object('tracks')
self._discs = self._album.discs
self._tracks_left = {}
self._tracks_right = {}
show_label = len(self._discs) > 1
i = 0
for disc in self._discs:
index = disc.number
if show_label:
label = Gtk.Label()
label.set_text(_("Disc %s") % index)
label.set_property('halign', Gtk.Align.START)
label.get_style_context().add_class('dim-label')
if i:
label.set_property('margin-top', 30)
label.show()
grid.attach(label, 0, i, 2, 1)
i += 1
self._tracks_left[index] = TracksWidget(self._pop_allowed, True)
self._tracks_right[index] = TracksWidget(self._pop_allowed, True)
grid.attach(self._tracks_left[index], 0, i, 1, 1)
grid.attach(self._tracks_right[index], 1, i, 1, 1)
size_group.add_widget(self._tracks_left[index])
size_group.add_widget(self._tracks_right[index])
self._tracks_left[index].connect('activated', self._on_activated)
self._tracks_left[index].connect('button-press-event',
self._on_button_press_event)
self._tracks_right[index].connect('activated', self._on_activated)
self._tracks_right[index].connect('button-press-event',
self._on_button_press_event)
self._tracks_left[index].show()
self._tracks_right[index].show()
i += 1
self._cover = builder.get_object('cover')
self.set_cover()
self.update_state()
builder.get_object('title').set_label(self._album.name)
if self._album.year:
year = builder.get_object('year')
year.set_label(self._album.year)
year.show()
self.add(builder.get_object('widget'))
# TODO: Remove this test later
if self._pop_allowed:
self._menu = builder.get_object('menu')
self._menu.connect('clicked', self._pop_menu)
self._menu.show()
def __init__(self):
self.dbus = None
self.start_processes()
self.group = None
self.preset_name = None
css_provider = Gtk.CssProvider()
with open(get_data_path('style.css'), 'r') as file:
css_provider.load_from_data(bytes(file.read(), encoding='UTF-8'))
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(), css_provider,
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
gladefile = get_data_path('key-mapper.glade')
builder = Gtk.Builder()
builder.add_from_file(gladefile)
builder.connect_signals(self)
self.builder = builder
# set up the device selection
# https://python-gtk-3-tutorial.readthedocs.io/en/latest/treeview.html#the-view
combobox = self.get('device_selection')
self.device_store = Gtk.ListStore(str, str, str)
combobox.set_model(self.device_store)
renderer_icon = Gtk.CellRendererPixbuf()
renderer_text = Gtk.CellRendererText()
renderer_text.set_padding(5, 0)
combobox.pack_start(renderer_icon, False)
combobox.pack_start(renderer_text, False)
combobox.add_attribute(renderer_icon, 'icon-name', 1)
combobox.add_attribute(renderer_text, 'text', 2)
combobox.set_id_column(0)
self.confirm_delete = builder.get_object('confirm-delete')
self.about = builder.get_object('about-dialog')
self.about.connect('delete-event', on_close_about)
# set_position needs to be done once initially, otherwise the
# dialog is not centered when it is opened for the first time
self.about.set_position(Gtk.WindowPosition.CENTER_ON_PARENT)
self.get('version-label').set_text(
f'key-mapper {VERSION} {COMMIT_HASH[:7]}'
f'\npython-evdev {EVDEV_VERSION}' if EVDEV_VERSION else '')
window = self.get('window')
window.show()
# hide everything until stuff is populated
self.get('vertical-wrapper').set_opacity(0)
self.window = window
# if any of the next steps take a bit to complete, have the window
# already visible (without content) to make it look more responsive.
gtk_iteration()
# this is not set to invisible in glade to give the ui a default
# height that doesn't jump when a gamepad is selected
self.get('gamepad_separator').hide()
self.get('gamepad_config').hide()
self.populate_devices()
self.timeouts = []
self.setup_timeouts()
# now show the proper finished content of the window
self.get('vertical-wrapper').set_opacity(1)
self.ctrl = False
self.unreleased_warn = False
self.button_left_warn = False
if not is_helper_running():
self.show_status(CTX_ERROR, 'The helper did not start')
def __init__(self, journal):
self.journal = journal
# Load Glade file.
# TODO: Remove workaround for Windows once it is no longer needed.
self.gladefile = os.path.join(filesystem.files_dir,
'main_window.glade')
self.builder = Gtk.Builder()
# Register GtkSourceView so builder can use it when loading the file
# https://stackoverflow.com/q/10524196/434217
GObject.type_register(GtkSource.View)
if filesystem.IS_WIN:
import xml.etree.ElementTree as ET
tree = ET.parse(self.gladefile)
for node in tree.iter():
if 'translatable' in node.attrib:
node.text = _(node.text)
xml_text = ET.tostring(tree.getroot(), encoding='unicode')
self.builder = Gtk.Builder.new_from_string(xml_text, len(xml_text))
else:
self.builder.set_translation_domain('rednotebook')
self.builder.add_from_file(self.gladefile)
# Get the main window and set the icon
self.main_frame = self.builder.get_object('main_frame')
self.main_frame.set_title('RedNotebook')
icon = GdkPixbuf.Pixbuf.new_from_file(
os.path.join(filesystem.frame_icon_dir, 'rednotebook.svg'))
self.main_frame.set_icon(icon)
self.is_fullscreen = False
self.uimanager = Gtk.UIManager()
# Before fetching the menubar, add all menus and actiongroups.
# Setup the toolbar items first to avoid warnings for missing actions.
insert_menu.InsertMenu(self)
format_menu.FormatMenu(self)
self.menubar_manager = MainMenuBar(self)
self.menubar = self.menubar_manager.get_menu_bar()
main_vbox = self.builder.get_object('vbox3')
main_vbox.pack_start(self.menubar, False, False, 0)
main_vbox.reorder_child(self.menubar, 0)
self.undo_action = self.uimanager.get_action('/MainMenuBar/Edit/Undo')
self.redo_action = self.uimanager.get_action('/MainMenuBar/Edit/Redo')
self.calendar = MainCalendar(self.journal,
self.builder.get_object('calendar'))
self.day_text_field = DayEditor(
self.builder.get_object('day_text_view'))
self.day_text_field.connect('can-undo-redo-changed',
self.update_undo_redo_buttons)
self.update_undo_redo_buttons()
self.day_text_field.day_text_view.grab_focus()
can_spell_check = self.day_text_field.can_spell_check()
spell_check_enabled = bool(self.journal.config.read('spellcheck'))
for actiongroup in self.menubar_manager.uimanager.get_action_groups():
if actiongroup.get_name() == 'MainMenuActionGroup':
for action in actiongroup.list_actions():
if action.get_name() == 'CheckSpelling':
action.set_sensitive(can_spell_check)
action.set_active(spell_check_enabled
and can_spell_check)
self.day_text_field.enable_spell_check(spell_check_enabled)
self.statusbar = Statusbar(self.builder.get_object('statusbar'))
self.new_entry_dialog = NewEntryDialog(self)
self.categories_tree_view = categories.CategoriesTreeView(
self.builder.get_object('categories_tree_view'), self)
self.new_entry_dialog.categories_tree_view = self.categories_tree_view
self.back_one_day_button = self.builder.get_object(
'back_one_day_button')
self.today_button = self.builder.get_object('today_button')
self.forward_one_day_button = self.builder.get_object(
'forward_one_day_button')
self.edit_pane = self.builder.get_object('edit_pane')
self.text_vbox = self.builder.get_object('text_vbox')
if browser.WebKit2:
class Preview(browser.HtmlView):
def __init__(self, journal):
browser.HtmlView.__init__(self)
self.journal = journal
self.internal = True
def show_day(self, new_day):
html = self.journal.convert(new_day.text, 'xhtml')
self.load_html(html)
def shutdown(self):
pass
self.html_editor = Preview(self.journal)
self.html_editor.connect('button-press-event',
self.on_browser_clicked)
self.html_editor.connect('decide-policy',
self.on_browser_decide_policy)
self.text_vbox.pack_start(self.html_editor, True, True, 0)
self.html_editor.set_editable(False)
elif browser_cef.cef:
class Preview(browser_cef.HtmlView):
def __init__(self, journal):
super().__init__()
self.journal = journal
self.internal = True
def show_day(self, new_day):
html = self.journal.convert(new_day.text, 'xhtml')
self.load_html(html)
def highlight(self, text):
pass
self.html_editor = Preview(self.journal)
self.text_vbox.pack_start(self.html_editor, True, True, 0)
else:
self.html_editor = mock.MagicMock()
self.html_editor.internal = False
preview_button = self.builder.get_object('preview_button')
preview_button.set_label(_('Preview in Browser'))
self.html_editor.hide()
self.preview_mode = False
# Let the edit_paned respect its childs size requests
self.edit_pane.child_set_property(self.text_vbox, 'shrink', False)
# Add InfoBar.
self.infobar = customwidgets.Info()
self.text_vbox.pack_start(self.infobar, False, False, 0)
self.text_vbox.reorder_child(self.infobar, 1)
# Add TemplateBar.
self.template_bar = customwidgets.TemplateBar()
self.text_vbox.pack_start(self.template_bar, False, False, 0)
self.text_vbox.reorder_child(self.template_bar, 1)
self.template_bar.hide()
self.load_values_from_config()
self.main_frame.show()
self.options_manager = OptionsManager(self)
self.export_assistant = ExportAssistant(self.journal)
self.export_assistant.set_transient_for(self.main_frame)
self.setup_clouds()
self.setup_search()
# Create an event->method dictionary and connect it to the widgets
dic = {
'on_back_one_day_button_clicked':
self.on_back_one_day_button_clicked,
'on_today_button_clicked': self.on_today_button_clicked,
'on_forward_one_day_button_clicked':
self.on_forward_one_day_button_clicked,
'on_preview_button_clicked': self.on_preview_button_clicked,
'on_edit_button_clicked': self.on_edit_button_clicked,
'on_main_frame_configure_event':
self.on_main_frame_configure_event,
'on_main_frame_window_state_event':
self.on_main_frame_window_state_event,
'on_add_new_entry_button_clicked':
self.on_add_new_entry_button_clicked,
'on_main_frame_delete_event': self.on_main_frame_delete_event,
# connect_signals can only be called once, it seems
# Otherwise RuntimeWarnings are raised: RuntimeWarning: missing handler '...'
}
self.builder.connect_signals(dic)
self.set_shortcuts()
self.setup_stats_dialog()
self.template_manager = templates.TemplateManager(self)
self.template_manager.make_empty_template_files()
self.setup_template_menu()
self.set_tooltips()
self.setup_tray_icon()
# Show/hide the "tags" panel on the right.
self.builder.get_object('annotations_pane').set_visible(
self.journal.config.read('showTagsPane'))
def setup(self):
shell = self.props.shell
builder = Gtk.Builder()
builder.add_from_file(
rb.find_plugin_file(self.props.plugin, "soundcloud.ui"))
self.scrolled = builder.get_object("container-scrolled")
self.scrolled.set_no_show_all(True)
self.scrolled.hide()
self.more_containers_idle = 0
adj = self.scrolled.get_vadjustment()
adj.connect("changed", self.scroll_adjust_changed_cb)
adj.connect("value-changed", self.scroll_adjust_changed_cb)
self.search_entry = RB.SearchEntry(spacing=6)
self.search_entry.props.explicit_mode = True
self.fetch_more_button = Gtk.Button.new_with_label(
_("Fetch more tracks"))
self.fetch_more_button.connect("clicked", self.show_more_cb)
action = Gio.SimpleAction.new("soundcloud-search-type",
GLib.VariantType.new('s'))
action.connect("activate", self.search_type_action_cb)
shell.props.window.add_action(action)
m = Gio.Menu()
for st in sorted(self.search_types):
i = Gio.MenuItem()
i.set_label(self.search_types[st]['label'])
i.set_action_and_target_value("win.soundcloud-search-type",
GLib.Variant.new_string(st))
m.append_item(i)
self.search_popup = Gtk.Menu.new_from_model(m)
action.activate(GLib.Variant.new_string("tracks"))
grid = builder.get_object("soundcloud-source")
self.search_entry.connect("search", self.search_entry_cb)
self.search_entry.connect("activate", self.search_entry_cb)
self.search_entry.connect("show-popup", self.search_popup_cb)
self.search_entry.set_size_request(400, -1)
searchbox = builder.get_object("search-box")
searchbox.pack_start(self.search_entry, False, True, 0)
searchbox.pack_start(self.fetch_more_button, False, True, 0)
self.search_popup.attach_to_widget(self.search_entry, None)
self.containers = builder.get_object("container-store")
self.container_view = builder.get_object("containers")
self.container_view.set_model(self.containers)
action = Gio.SimpleAction.new("soundcloud-open-uri",
GLib.VariantType.new('s'))
action.connect("activate", self.open_uri_action_cb)
shell.props.window.add_action(action)
r = Gtk.CellRendererText()
c = Gtk.TreeViewColumn("", r, text=0)
self.container_view.append_column(c)
self.container_view.get_selection().connect('changed',
self.selection_changed_cb)
self.songs = RB.EntryView(db=shell.props.db,
shell_player=shell.props.shell_player,
is_drag_source=True,
is_drag_dest=False)
self.songs.append_column(RB.EntryViewColumn.TITLE, True)
self.songs.append_column(RB.EntryViewColumn.ARTIST, True)
self.songs.append_column(RB.EntryViewColumn.DURATION, True)
self.songs.append_column(RB.EntryViewColumn.YEAR, False)
self.songs.append_column(RB.EntryViewColumn.GENRE, False)
self.songs.append_column(RB.EntryViewColumn.BPM, False)
self.songs.append_column(RB.EntryViewColumn.FIRST_SEEN, False)
self.songs.set_model(self.props.query_model)
self.songs.connect("notify::sort-order", self.sort_order_changed_cb)
self.songs.connect("selection-changed",
self.songs_selection_changed_cb)
paned = builder.get_object("paned")
paned.pack2(self.songs)
self.bind_settings(self.songs, paned, None, True)
self.sc_button = Gtk.MenuButton()
self.sc_button.set_relief(Gtk.ReliefStyle.NONE)
img = Gtk.Image.new_from_file(
rb.find_plugin_file(self.props.plugin,
"powered-by-soundcloud.png"))
self.sc_button.add(img)
box = builder.get_object("soundcloud-button-box")
box.pack_start(self.sc_button, True, True, 0)
self.build_sc_menu()
self.pack_start(grid, expand=True, fill=True, padding=0)
grid.show_all()
self.art_store = RB.ExtDB(name="album-art")
player = shell.props.shell_player
player.connect('playing-song-changed', self.playing_entry_changed_cb)
def __init__(self, album_id, genre_ids, artist_ids, show_cover):
"""
Init detailed album widget
@param album id as int
@param genre ids as [int]
@param artist ids as [int]
@param lazy as LazyLoadingView
@param show cover as bool
"""
Gtk.Bin.__init__(self)
AlbumWidget.__init__(self, album_id, genre_ids)
self._album.set_artists(artist_ids)
self.__width = None
# Cover + rating + spacing
self.__height = ArtSize.BIG + 26
self.__orientation = None
self.__child_height = TrackRow.get_best_height(self)
# Header + separator + spacing + margin
self.__requested_height = self.__child_height + 6
# Discs to load, will be emptied
self.__discs = self._album.discs
self.__locked_widget_right = True
self._filter_ids = artist_ids
self.set_property('height-request', self.__height)
self.connect('size-allocate', self.__on_size_allocate)
builder = Gtk.Builder()
builder.add_from_resource('/org/gnome/Lollypop/AlbumDetailedWidget.ui')
self._widget = builder.get_object('widget')
self.__overlay = builder.get_object('overlay')
self._play_button = builder.get_object('play-button')
self._artwork_button = builder.get_object('artwork-button')
self._action_button = builder.get_object('action-button')
self._action_event = builder.get_object('action-event')
builder.connect_signals(self)
rating = RatingWidget(self._album)
rating.show()
artist_label = builder.get_object('artist')
if show_cover:
self._cover = builder.get_object('cover')
builder.get_object('duration').set_hexpand(True)
self._cover.get_style_context().add_class('cover-frame')
self.__coverbox = builder.get_object('coverbox')
self.__coverbox.show()
# 6 for 2*3px (application.css)
self.__coverbox.set_property('width-request', ArtSize.BIG + 6)
self.__coverbox.add(rating)
if Lp().window.get_view_width() < WindowSize.MEDIUM:
self.__coverbox.hide()
if len(artist_ids) > 1:
artist_label.set_text(", ".join(self._album.artists))
artist_label.show()
else:
builder.get_object('header').attach(rating, 4, 0, 1, 1)
rating.set_hexpand(True)
rating.set_property('halign', Gtk.Align.END)
rating.set_property('valign', Gtk.Align.CENTER)
artist_label.set_text(", ".join(self._album.artists))
artist_label.show()
self._cover = None
label = builder.get_object('duration')
duration = Lp().albums.get_duration(album_id, genre_ids)
hours = int(duration / 3600)
mins = int(duration / 60)
if hours > 0:
mins -= hours * 60
if mins > 0:
label.set_text(_("%s h %s m") % (hours, mins))
else:
label.set_text(_("%s h") % hours)
else:
label.set_text(_("%s m") % mins)
self.__box = Gtk.Grid()
self.__box.set_column_homogeneous(True)
self.__box.set_property('valign', Gtk.Align.START)
self.__box.show()
builder.get_object('albuminfo').add(self.__box)
self._tracks_left = {}
self._tracks_right = {}
self.set_cover()
self.update_state()
builder.get_object('title').set_label(self._album.name)
if self._album.year:
year = builder.get_object('year')
year.set_label(self._album.year)
year.show()
for disc in self.__discs:
self.__add_disc_container(disc.number)
self.__set_disc_height(disc)
self.add(self._widget)
# We start transparent, we switch opaque at size allocation
# This prevent artifacts
self.set_opacity(0)
self._menu = builder.get_object('menu')
self._menu.connect('clicked', self.__pop_menu)
# TODO Remove this later
if Gtk.get_minor_version() > 16:
self._menu.show()
else:
self.connect('map', self.__on_map)
if self._album.is_youtube and show_cover:
self._cover.get_style_context().add_class('cover-frame-youtube')
def __init__(self):
"""
Init dialog
"""
self.__timeout_id = None
self.__choosers = []
self.__locked = []
builder = Gtk.Builder()
builder.add_from_resource("/org/gnome/Lollypop/SettingsDialog.ui")
self.__settings_dialog = builder.get_object("settings_dialog")
self.__progress = builder.get_object("progress")
for setting in self.__BOOLEAN:
button = builder.get_object("%s_boolean" % setting)
value = App().settings.get_value(setting)
button.set_state(value)
for setting in self.__ENTRY:
entry = builder.get_object("%s_entry" % setting)
value = App().settings.get_value(setting).get_string()
entry.set_text(value)
for setting in self.__RANGE:
widget = builder.get_object("%s_range" % setting)
value = App().settings.get_value(setting).get_int32()
widget.set_value(value)
for setting in self.__COMBO:
widget = builder.get_object("%s_combo" % setting)
value = App().settings.get_enum(setting)
widget.set_active(value)
for locked in self.__LOCKED:
widget = builder.get_object(locked)
self.__locked.append(widget)
self.__update_locked()
self.__music_group = builder.get_object("music_group")
for uri in App().settings.get_value("music-uris"):
button = self.__get_new_chooser(uri)
self.__music_group.add(button)
for device in App().settings.get_value("devices"):
row = DeviceRow(device)
builder.get_object("device_group").add(row)
acl = App().settings.get_value("network-access-acl").get_int32()
for key in NetworkAccessACL.keys():
if acl & NetworkAccessACL[key]:
builder.get_object("%s_button" % key).set_state(True)
artists_count = App().artists.count()
albums_count = App().albums.count()
tracks_count = App().tracks.count()
builder.get_object("stat_artists").set_title(
_("Artists count: %s") % artists_count)
builder.get_object("stat_albums").set_title(
_("Albums count: %s") % albums_count)
builder.get_object("stat_tracks").set_title(
_("Tracks count: %s") % tracks_count)
self.__settings_dialog.set_transient_for(App().window)
self.__settings_dialog.connect("destroy", self.__on_destroy)
passwords_helper = PasswordsHelper()
passwords_helper.get("LASTFM", self.__on_get_password,
builder.get_object("lastfm_button"))
passwords_helper.get("LIBREFM", self.__on_get_password,
builder.get_object("librefm_button"))
builder.connect_signals(self)
self.__multi_press = Gtk.EventControllerKey.new(self.__settings_dialog)
self.__multi_press.connect("key-released", self.__on_key_released)
def add_from_string(self, strg):
builder = Gtk.Builder()
if self.domain is not None: builder.set_translation_domain(self.domain)
self.builders.append(builder)
builder.add_from_string(strg)
def create_headerbar(self):
"""Create the headerbar"""
hbar = Gtk.HeaderBar()
hbar.props.show_close_button = True
hbar.props.title = APP_NAME
box = Gtk.Box()
Gtk.StyleContext.add_class(box.get_style_context(), "linked")
if os.name == 'nt':
icon_size = Gtk.IconSize.BUTTON
else:
icon_size = Gtk.IconSize.LARGE_TOOLBAR
# create the preview button
self.preview_button = Gtk.Button.new_from_icon_name(
'edit-find', icon_size)
self.preview_button.set_always_show_image(True)
self.preview_button.connect(
'clicked', lambda *dummy: self.preview_or_run_operations(False))
self.preview_button.set_tooltip_text(
_("Preview files in the selected operations (without deleting any files)"
))
# TRANSLATORS: This is the preview button on the main window. It
# previews changes.
self.preview_button.set_label(_('Preview'))
box.add(self.preview_button)
# create the delete button
self.run_button = Gtk.Button.new_from_icon_name(
'edit-clear-all', icon_size)
self.run_button.set_always_show_image(True)
# TRANSLATORS: This is the clean button on the main window.
# It makes permanent changes: usually deleting files, sometimes
# altering them.
self.run_button.set_label(_('Clean'))
self.run_button.set_tooltip_text(
_("Clean files in the selected operations"))
self.run_button.connect("clicked", self.run_operations)
box.add(self.run_button)
# stop cleaning
self.stop_button = Gtk.Button.new_from_icon_name(
'process-stop', icon_size)
self.stop_button.set_always_show_image(True)
self.stop_button.set_label(_('Abort'))
self.stop_button.set_tooltip_text(
_('Abort the preview or cleaning process'))
self.stop_button.set_sensitive(False)
self.stop_button.connect('clicked', self.cb_stop_operations)
box.add(self.stop_button)
hbar.pack_start(box)
# Add hamburger menu on the right.
# This is not needed for Microsoft Windows because other code places its
# menu on the left side.
if os.name == 'nt':
return hbar
menu_button = Gtk.MenuButton()
icon = Gio.ThemedIcon(name="open-menu-symbolic")
image = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.BUTTON)
builder = Gtk.Builder()
builder.add_from_file(bleachbit.app_menu_filename)
menu_button.set_menu_model(builder.get_object('app-menu'))
menu_button.add(image)
hbar.pack_end(menu_button)
return hbar
def __init__(self, window, player):
"""Initialize
:param GtkWidget window: The main window
:param player: The main player object
"""
self._playlists_sidebar = Gd.MainView()
super().__init__('playlists', _("Playlists"), window,
Gd.MainViewType.LIST, True, self._playlists_sidebar)
self._window = window
self.player = player
style_context = self._view.get_generic_view().get_style_context()
style_context.add_class('songs-list')
style_context.remove_class('content-view')
self._add_list_renderers()
builder = Gtk.Builder()
builder.add_from_resource('/org/gnome/Music/PlaylistControls.ui')
headerbar = builder.get_object('grid')
self._name_label = builder.get_object('playlist_name')
self._songs_count_label = builder.get_object('songs_count')
self._menubutton = builder.get_object('playlist_menubutton')
playlist_play_action = Gio.SimpleAction.new('playlist_play', None)
playlist_play_action.connect('activate', self._on_play_activate)
self._window.add_action(playlist_play_action)
self._playlist_delete_action = Gio.SimpleAction.new(
'playlist_delete', None)
self._playlist_delete_action.connect('activate',
self._on_delete_activate)
self._window.add_action(self._playlist_delete_action)
self._grid.insert_row(0)
self._grid.attach(headerbar, 1, 0, 1, 1)
self._playlists_model = Gtk.ListStore(
GObject.TYPE_STRING, GObject.TYPE_STRING, GObject.TYPE_STRING,
GObject.TYPE_STRING, GdkPixbuf.Pixbuf, GObject.TYPE_OBJECT,
GObject.TYPE_BOOLEAN, GObject.TYPE_INT, GObject.TYPE_STRING,
GObject.TYPE_INT, GObject.TYPE_BOOLEAN, GObject.TYPE_INT)
self._playlists_sidebar.set_view_type(Gd.MainViewType.LIST)
self._playlists_sidebar.set_model(self._playlists_model)
self._playlists_sidebar.set_hexpand(False)
self._playlists_sidebar.get_style_context().add_class('side-panel')
self._pl_generic_view = self._playlists_sidebar.get_generic_view()
self._pl_generic_view.get_selection().set_mode(
Gtk.SelectionMode.SINGLE)
self._playlists_sidebar.connect('item-activated',
self._on_playlist_activated)
self._grid.insert_column(0)
self._grid.child_set_property(self.stack, 'top-attach', 0)
self._grid.child_set_property(self.stack, 'height', 2)
self._add_sidebar_renderers()
self._pl_generic_view.get_style_context().remove_class('content-view')
self._iter_to_clean = None
self._iter_to_clean_model = None
self.current_playlist = None
self._current_playlist_index = None
self.pl_todelete = None
self._pl_todelete_index = None
self._songs_count = 0
self._update_songs_count()
self.player.connect('playlist-item-changed', self._update_model)
playlists.connect('playlist-created', self._on_playlist_created)
playlists.connect('playlist-updated', self._on_playlist_update)
playlists.connect('song-added-to-playlist',
self._on_song_added_to_playlist)
playlists.connect('song-removed-from-playlist',
self._on_song_removed_from_playlist)
self.show_all()
def __init__(self, node_name_override = 'finderv2_testing_interface'):
rospy.init_node(node_name_override)
#self.nodename = rospy.get_name()
#rospy.loginfo("finder starting with name %s", self.nodename)
self.joy_Sub = rospy.Subscriber("joy", Joy, self.joyCb)
self.pub1 = rospy.Publisher("motor_arm_base", Int16)
self.pub2 = rospy.Publisher("motor_arm_1", Int16)
self.pub3 = rospy.Publisher("motor_arm_2", Int16)
self.pub4 = rospy.Publisher("servo_arm_1", Int16)
self.pub5 = rospy.Publisher("servo_arm_2", Int16)
self.pub6 = rospy.Publisher("servo_arm_gripper", Int16)
self.pub7 = rospy.Publisher("motor_traction_left", Int16)
self.pub8 = rospy.Publisher("motor_traction_right", Int16)
self.pub9 = rospy.Publisher("motor_traction_arm_fr", Int16)
self.pub10 = rospy.Publisher("motor_traction_arm_fl", Int16)
self.pub11 = rospy.Publisher("motor_traction_arm_br", Int16)
self.pub12 = rospy.Publisher("motor_traction_arm_bl", Int16)
self.motor_arm_base_value = 0
self.motor_arm_1_value = 0
self.motor_arm_2_value = 0
self.servo_arm_1_value = 0
self.servo_arm_2_value = 0
self.servo_arm_gripper_value = 0
self.motor_traction_left_value = 0
self.motor_traction_right_value = 0
self.motor_traction_arm_fr_value = 0
self.motor_traction_arm_fl_value = 0
self.motor_traction_arm_br_value = 0
self.motor_traction_arm_bl_value = 0
self.leftpad = 0
self.rightpad = 0
#str = roslib.packages.get_pkg_dir('finder') + "/scripts/finderv2_testing_interface.glade"
#fix for user path, fix better
str = expanduser("~") + "/workspace/catkin/src/finder/scripts/finderv2_testing_interface.glade"
self.gladefile = str
builder = Gtk.Builder()
builder.add_from_file(self.gladefile)
builder.connect_signals(self)
# self.gui_d1 = builder.get_object("d1")
self.motor_arm_base_leftpad = builder.get_object("motor_arm_base_leftpad")
self.motor_arm_1_leftpad = builder.get_object("motor_arm_1_leftpad")
self.motor_arm_2_leftpad = builder.get_object("motor_arm_2_leftpad")
self.servo_arm_1_leftpad = builder.get_object("servo_arm_1_leftpad")
self.servo_arm_2_leftpad = builder.get_object("servo_arm_2_leftpad")
self.servo_arm_gripper_leftpad = builder.get_object("servo_arm_gripper_leftpad")
self.motor_traction_arm_fr_leftpad = builder.get_object("motor_traction_arm_fr_leftpad")
self.motor_traction_arm_fl_leftpad = builder.get_object("motor_traction_arm_fl_leftpad")
self.motor_traction_arm_br_leftpad = builder.get_object("motor_traction_arm_br_leftpad")
self.motor_traction_arm_bl_leftpad = builder.get_object("motor_traction_arm_bl_leftpad")
self.motor_traction_left_leftpad = builder.get_object("motor_traction_left_leftpad")
self.motor_traction_right_leftpad = builder.get_object("motor_traction_right_leftpad")
self.motor_arm_base_rightpad = builder.get_object("motor_arm_base_rightpad")
self.motor_arm_1_rightpad = builder.get_object("motor_arm_1_rightpad")
self.motor_arm_2_rightpad = builder.get_object("motor_arm_2_rightpad")
self.servo_arm_1_rightpad = builder.get_object("servo_arm_1_rightpad")
self.servo_arm_2_rightpad = builder.get_object("servo_arm_2_rightpad")
self.servo_arm_gripper_rightpad = builder.get_object("servo_arm_gripper_rightpad")
self.motor_traction_arm_fr_rightpad = builder.get_object("motor_traction_arm_fr_rightpad")
self.motor_traction_arm_fl_rightpad = builder.get_object("motor_traction_arm_fl_rightpad")
self.motor_traction_arm_br_rightpad = builder.get_object("motor_traction_arm_br_rightpad")
self.motor_traction_arm_bl_rightpad = builder.get_object("motor_traction_arm_bl_rightpad")
self.motor_traction_left_rightpad = builder.get_object("motor_traction_left_rightpad")
self.motor_traction_right_rightpad = builder.get_object("motor_traction_right_rightpad")
self.window = builder.get_object("window1")
self.window.show_all()
def initialize_builder(self):
self.builder = Gtk.Builder()
self.builder.add_from_file('resources/glade/ui.xml')
def __init__(self):
try:
self.builder = Gtk.Builder()
self.builder.add_from_file("/usr/lib/cinnamon-settings-users/cinnamon-settings-users.ui")
self.window = self.builder.get_object("main_window")
self.window.connect("destroy", Gtk.main_quit)
self.window.set_title(_("Users and Groups"))
self.builder.get_object("label_users").set_label(_("Users"))
self.builder.get_object("label_groups").set_label(_("Groups"))
self.builder.get_object("button_add_user").connect("clicked", self.on_user_addition)
self.builder.get_object("button_delete_user").connect("clicked", self.on_user_deletion)
self.builder.get_object("button_add_group").connect("clicked", self.on_group_addition)
self.builder.get_object("button_edit_group").connect("clicked", self.on_group_edition)
self.builder.get_object("button_delete_group").connect("clicked", self.on_group_deletion)
self.users = Gtk.TreeStore(object, GdkPixbuf.Pixbuf, str)
self.users.set_sort_column_id(2, Gtk.SortType.ASCENDING)
self.groups = Gtk.TreeStore(int, str)
self.groups.set_sort_column_id(1, Gtk.SortType.ASCENDING)
self.users_treeview = self.builder.get_object("treeview_users")
self.users_treeview.set_rules_hint(True)
self.groups_treeview = self.builder.get_object("treeview_groups")
self.users_treeview.get_selection().connect("changed", self.on_user_selection)
self.groups_treeview.get_selection().connect("changed", self.on_group_selection)
column = Gtk.TreeViewColumn()
cell = Gtk.CellRendererPixbuf()
column.pack_start(cell, True)
column.add_attribute(cell, 'pixbuf', INDEX_USER_PICTURE)
cell.set_property('ypad', 1)
self.users_treeview.append_column(column)
column = Gtk.TreeViewColumn()
cell = Gtk.CellRendererText()
column.pack_start(cell, True)
column.add_attribute(cell, 'markup', INDEX_USER_DESCRIPTION)
self.users_treeview.append_column(column)
column = Gtk.TreeViewColumn()
cell = Gtk.CellRendererText()
column.pack_start(cell, True)
column.add_attribute(cell, 'text', INDEX_GROUPNAME)
column.set_sort_column_id(1)
self.groups_treeview.append_column(column)
self.builder.get_object("button_delete_user").set_sensitive(False)
self.builder.get_object("button_edit_group").set_sensitive(False)
self.builder.get_object("button_delete_group").set_sensitive(False)
self.face_button = Gtk.Button()
self.face_image = Gtk.Image()
self.face_button.set_image(self.face_image)
self.face_image.set_from_file("/usr/share/cinnamon/faces/user-generic.png")
self.face_button.set_alignment(0.0, 0.5)
self.face_button.set_tooltip_text(_("Click to change the picture"))
self.menu = Gtk.Menu()
separator = Gtk.SeparatorMenuItem()
face_browse_menuitem = Gtk.MenuItem(_("Browse for more pictures..."))
face_browse_menuitem.connect('activate', self._on_face_browse_menuitem_activated)
self.face_button.connect("button-release-event", self.menu_display)
row = 0
col = 0
num_cols = 4
face_dirs = ["/usr/share/cinnamon/faces"]
for face_dir in face_dirs:
if os.path.exists(face_dir):
pictures = sorted(os.listdir(face_dir))
for picture in pictures:
path = os.path.join(face_dir, picture)
file = Gio.File.new_for_path(path)
file_icon = Gio.FileIcon.new(file)
image = Gtk.Image.new_from_gicon (file_icon, Gtk.IconSize.DIALOG)
menuitem = Gtk.MenuItem()
menuitem.add(image)
menuitem.connect('activate', self._on_face_menuitem_activated, path)
self.menu.attach(menuitem, col, col+1, row, row+1)
col = (col+1) % num_cols
if (col == 0):
row = row + 1
row = row + 1
self.menu.attach(separator, 0, 4, row, row+1)
self.menu.attach(face_browse_menuitem, 0, 4, row+2, row+3)
self.account_type_combo = Gtk.ComboBoxText()
self.account_type_combo.append_text(_("Standard"))
self.account_type_combo.append_text(_("Administrator"))
self.account_type_combo.connect("changed", self._on_accounttype_changed)
self.realname_entry = EditableEntry()
self.realname_entry.connect("changed", self._on_realname_changed)
self.realname_entry.set_tooltip_text(_("Click to change the name"))
self.password_mask = Gtk.Label()
self.password_mask.set_alignment(0.0, 0.5)
self.password_button = Gtk.Button()
self.password_button.add(self.password_mask)
self.password_button.set_relief(Gtk.ReliefStyle.NONE)
self.password_button.set_tooltip_text(_("Click to change the password"))
self.password_button.connect('activate', self._on_password_button_clicked)
self.password_button.connect('released', self._on_password_button_clicked)
self.groups_label = Gtk.Label()
self.groups_label.set_line_wrap(True)
self.groups_label.set_alignment(0, 0.5)
self.groups_button = Gtk.Button()
self.groups_button.add(self.groups_label)
self.groups_button.set_relief(Gtk.ReliefStyle.NONE)
self.groups_button.set_tooltip_text(_("Click to change the groups"))
self.groups_button.connect("clicked", self._on_groups_button_clicked)
box = Gtk.Box()
box.pack_start(self.face_button, False, False, 0)
table = DimmedTable()
table.add_labels([_("Picture"), _("Account Type"), _("Name"), _("Password"), _("Groups")])
table.add_controls([box, self.account_type_combo, self.realname_entry, self.password_button, self.groups_button])
self.builder.get_object("box_users").add(table)
self.accountService = AccountsService.UserManager.get_default()
self.accountService.connect('notify::is-loaded', self.on_accounts_service_loaded)
self.load_groups()
self.window.show_all()
self.builder.get_object("box_users").hide()
except Exception, detail:
print detail
def initialise(self, plugin):
super(AltToolbarShared, self).initialise(plugin)
ui = rb.find_plugin_file(plugin, 'ui/alttoolbar.ui')
builder = Gtk.Builder()
builder.add_from_file(ui)
self.load_builder_content(builder)
self.connect_builder_content(builder)
self._controllers['generic'] = AltGenericController(self)
# every potential source should have its own controller - we use this to
# categorise the source and provide specific capability for inherited classes
# where a controller is not specified then a generic controller is used
# i.e. use add_controller method to add a controller
self.add_controller(AltMusicLibraryController(self))
self.add_controller(AltSoundCloudController(self))
self.add_controller(AltCoverArtBrowserController(self))
self.add_controller(AltCoverArtPlaySourceController(self))
self.add_controller(AltQueueController(self))
self.add_controller(AltStandardOnlineController(self))
self.add_controller(AltStandardLocalController(self))
self.add_controller(AltRadioController(self))
self.add_controller(AltLastFMController(self))
self.add_controller(AltPlaylistController(self))
self.add_controller(AltErrorsController(self))
self.add_controller(AltPodcastController(self))
self.add_controller(AltAndroidController(self))
# support RTL
for control, icon_name in [
(self.prev_button, 'media-skip-backward-symbolic'),
(self.play_button, 'media-playback-start-symbolic'),
(self.next_button, 'media-skip-forward-symbolic')
]:
image = control.get_child()
icon_name = self.request_rtl_icon(control, icon_name)
image.set_from_icon_name(icon_name, image.props.icon_size)
# now move current RBDisplayPageTree to listview stack
display_tree = self.shell.props.display_page_tree
self.display_tree_parent = display_tree.get_parent()
self.display_tree_parent.remove(display_tree)
self.stack = Gtk.Stack()
self.stack.set_transition_type(
Gtk.StackTransitionType.SLIDE_LEFT_RIGHT)
self.stack.set_transition_duration(1000)
image_name = 'view-list-symbolic'
box_listview = Gtk.Box()
box_listview.pack_start(display_tree, True, True, 0)
# box_listview.show_all()
self.stack.add_named(box_listview, "listview")
self.stack.child_set_property(box_listview, "icon-name", image_name)
self.stack.show_all()
self.display_tree_parent.pack1(self.stack, True, True)
#if 1==2: #self.plugin.enhanced_sidebar:
toolbar = self.find(display_tree, 'GtkToolbar', 'by_name')
#context = toolbar.get_style_context()
#context.add_class('toolbar')
box = self.find(toolbar, 'GtkBox', 'by_name')
#box.props.margin_top = 2
#box.props.margin_bottom = 0
#box.props.margin_left = 5
context = box.get_style_context()
context.add_class('linked')
#parent = box.get_parent()
#parent.remove(box)
#parent_toolbar = toolbar.get_parent()
#parent_toolbar.remove(toolbar)
#display_tree.attach(box, 0, 10, 1 ,1 )
# child, new-parent, old-parent
#self._moved_controls.append((box, display_tree, parent))
#self._moved_controls.append((toolbar, None, parent_toolbar))
# find the actual GtkTreeView in the RBDisplayTree and remove it
self.rbtree = self.find(display_tree, 'GtkTreeView', 'by_name')
self.rbtreeparent = self.rbtree.get_parent()
self.rbtreeparent.remove(self.rbtree)
self.sidebar = None
def on_programs_needed_clicked(self, b):
builder = Gtk.Builder()
builder.set_translation_domain(self.config.gettext_domain)
builder.add_from_file(os.path.join(self.config.glade, "wneeded.ui"))
window = builder.get_object("needed")
textbuf = builder.get_object("textbuffer")
window.show_all()
analizers, players, menuers, converters, burners, mkiso = self.cv.get_supported_programs()
analizers_i, players_i, menuers_i, converters_i, burners_i, mkiso_i = self.cv.get_available_programs()
text = ""
for e in analizers:
if analizers_i.count(e.display_name) == 0:
text += _("\t%(program_name)s (not installed)\n") % {
"program_name": e.display_name}
else:
text += _("\t%(program_name)s (installed)\n") % {
"program_name": e.display_name}
text1 = _("Movie identifiers (install at least one of these):\n\n%(program_list)s\n") % {
"program_list": text}
text = ""
for e in players:
if players_i.count(e.display_name) == 0:
text += _("\t%(program_name)s (not installed)\n") % {
"program_name": e.display_name}
else:
text += _("\t%(program_name)s (installed)\n") % {
"program_name": e.display_name}
text2 = _("Movie players (install at least one of these):\n\n%(program_list)s\n") % {
"program_list": text}
text = ""
for e in converters:
sup = ""
for s in e.disc_types:
if sup != "":
sup += ", "
sup += s
if converters_i.count(e.display_name) == 0:
text += _("\t%(program_name)s (not installed)\n") % {
"program_name": e.display_name + " (" + sup + ")"}
else:
text += _("\t%(program_name)s (installed)\n") % {
"program_name": e.display_name + " (" + sup + ")"}
text3 = _("Movie Converters (install at least one of these):\n\n%(program_list)s\n") % {
"program_list": text}
text = ""
for e in burners:
if burners_i.count(e.display_name) == 0:
text += _("\t%(program_name)s (not installed)\n") % {
"program_name": e.display_name}
else:
text += _("\t%(program_name)s (installed)\n") % {
"program_name": e.display_name}
text4 = _(
"CD/DVD burners (install at least one of these):\n\n%(program_list)s\n") % {"program_list": text}
text = ""
for e in mkiso:
if mkiso_i.count(e.display_name) == 0:
text += _("\t%(program_name)s (not installed)\n") % {
"program_name": e.display_name}
else:
text += _("\t%(program_name)s (installed)\n") % {
"program_name": e.display_name}
text5 = _("ISO creators (install at least one of these):\n\n%(program_list)s\n") % {
"program_list": text}
text = ""
if self.check_program(["dvdauthor", "--help"]) == False:
text += _("\t%(program_name)s (not installed)\n") % {
"program_name": "DVDAUTHOR (dvd)"}
else:
text += _("\t%(program_name)s (installed)\n") % {
"program_name": "DVDAUTHOR (dvd)"}
if self.check_program(["vcdimager", "--help"]) == False:
text += _("\t%(program_name)s (not installed)\n") % {
"program_name": "VCDIMAGER (vcd, svcd, cvd)"}
else:
text += _("\t%(program_name)s (installed)\n") % {
"program_name": "VCDIMAGER (vcd, svcd, cvd)"}
if self.check_program(["spumux", "--help"]) == False:
text += _("\t%(program_name)s (not installed)\n") % {
"program_name": "SPUMUX (dvd, vcd, svcd, cvd)"}
else:
text += _("\t%(program_name)s (installed)\n") % {
"program_name": "SPUMUX (dvd, vcd, svcd, cvd)"}
text6 = _("Other programs:\n\n%(program_list)s\n") % {
"program_list": text}
final_text = text1 + text2 + text3 + text4 + text5 + text6
textbuf.insert_at_cursor(final_text, len(final_text))
window.run()
window.destroy()
def __init__(self):
"""
Init toolbar
"""
Gtk.Bin.__init__(self)
self.set_hexpand(True)
self.__search_popover = None
self.__devices_popover = None
self.__timeout_id = None
builder = Gtk.Builder()
builder.add_from_resource("/org/gnome/Lollypop/ToolbarEnd.ui")
self.__party_submenu = builder.get_object("party_submenu")
self.add(builder.get_object("end"))
# Map some settings to actions, can't use Gio.Settings.create_action()
# because API does not support set_enabled()
self.__shuffle_action = Gio.SimpleAction.new_stateful(
"shuffle",
GLib.VariantType.new("s"),
GLib.Variant("s", "none"))
self.__shuffle_action.set_state(App().settings.get_value("shuffle"))
self.__shuffle_action.connect("change-state",
self.__on_shuffle_change_state)
self.__repeat_action = Gio.SimpleAction.new_stateful(
"repeat",
GLib.VariantType.new("s"),
GLib.Variant("s", "none"))
self.__repeat_action.set_state(App().settings.get_value("repeat"))
self.__repeat_action.connect("change-state",
self.__on_repeat_change_state)
App().add_action(self.__shuffle_action)
App().add_action(self.__repeat_action)
self.__shuffle_button = builder.get_object("shuffle_button")
self.__shuffle_button_image = builder.get_object(
"shuffle_button_image")
shuffle_button_action = Gio.SimpleAction.new("shuffle-button", None)
shuffle_button_action.connect("activate",
self.__on_shuffle_button_activate)
App().add_action(shuffle_button_action)
App().set_accels_for_action("app.shuffle-button", ["<Control>r"])
App().settings.connect("changed::shuffle", self.__on_repeat_changed)
App().settings.connect("changed::repeat", self.__on_repeat_changed)
party_action = Gio.SimpleAction.new_stateful(
"party",
None,
GLib.Variant.new_boolean(App().player.is_party))
party_action.connect("change-state", self.__on_party_mode_change_state)
App().add_action(party_action)
App().set_accels_for_action("app.party", ["<Control>p"])
scrobbling_disabled = App().settings.get_value("disable-scrobbling")
scrobbling_action = Gio.SimpleAction.new_stateful(
"scrobbling",
None,
GLib.Variant.new_boolean(not scrobbling_disabled))
scrobbling_action.connect("change-state",
self.__on_scrobbling_mode_change_state)
App().add_action(scrobbling_action)
App().set_accels_for_action("app.scrobbling", ["<Control><Shift>s"])
self.__search_button = builder.get_object("search_button")
search_action = App().lookup_action("search")
search_action.connect("activate", self.__on_search_activate)
self.__list_button = builder.get_object("list_button")
self.__list_button.set_property("has-tooltip", True)
self.__list_button.connect("query-tooltip",
self.__on_list_button_query_tooltip)
self.__home_button = builder.get_object("home_button")
App().player.connect("playlist-changed", self.__on_playlist_changed)
self.__set_shuffle_icon()
button_progress_bar = ButtonProgressBar()
overlay = builder.get_object("overlay")
overlay.add_overlay(button_progress_bar)
overlay.set_overlay_pass_through(button_progress_bar, True)
devices_button = builder.get_object("devices_button")
self.__devices_popover = DevicesPopover(button_progress_bar)
self.__devices_popover.connect(
"closed", self.__on_popover_closed, devices_button)
self.__devices_popover.connect("content-changed",
self.__on_devices_content_changed,
devices_button)
self.__devices_popover.populate()
builder.connect_signals(self)
def __init__(self):
self.config = devedeng.configuration_data.configuration.get_config()
builder = Gtk.Builder()
builder.set_translation_domain(self.config.gettext_domain)
builder.add_from_file(os.path.join(
self.config.glade, "wselect_disk.ui"))
builder.connect_signals(self)
self.wask_window = builder.get_object("wselect_disk")
self.cv = devedeng.converter.converter.get_converter()
dvd = True
vcd = True
cvd = True
svcd = True
divx = True
mkv = True
analizers, players, converters, menuers, burners, mkiso = self.cv.get_needed_programs()
if (analizers is not None) or (converters is not None):
dvd = False
vcd = False
cvd = False
svcd = False
divx = False
mkv = False
if menuers is not None:
dvd = False
if mkiso is not None:
dvd = False
if self.check_program(["dvdauthor", "--help"]) == False:
dvd = False
if self.check_program(["vcdimager", "--help"]) == False:
vcd = False
svcd = False
cvd = False
if self.check_program(["spumux", "--help"]) == False:
dvd = False
vcd = False
svcd = False
cvd = False
if self.cv.discs.count("dvd") == 0:
dvd = False
if self.cv.discs.count("vcd") == 0:
vcd = False
if self.cv.discs.count("svcd") == 0:
svcd = False
if self.cv.discs.count("cvd") == 0:
cvd = False
if self.cv.discs.count("divx") == 0:
divx = False
if self.cv.discs.count("mkv") == 0:
mkv = False
builder.get_object("button_dvd").set_sensitive(dvd)
builder.get_object("button_vcd").set_sensitive(vcd)
builder.get_object("button_svcd").set_sensitive(svcd)
builder.get_object("button_cvd").set_sensitive(cvd)
builder.get_object("button_divx").set_sensitive(divx)
builder.get_object("button_mkv").set_sensitive(mkv)
self.wask_window.show_all()
index = 0
found = txt.lower().find(new_mnemonic, start)
while found != -1:
index = found
if index == 0 or txt[index - 1] == ' ':
break
found = txt.lower().find(new_mnemonic, index + 1)
widget.set_text_with_mnemonic(txt[0:index] + '_' + txt[index:])
if __name__ == '__main__':
from gourmet import gglobals
from gi.repository import Gtk
import os.path
mm = MnemonicManager()
ui = Gtk.Builder()
ui.add_from_file(os.path.join(gglobals.uibase, 'app.ui'))
mm.add_builder(ui)
#tree = ui.get_widget('recTree')
#rend = Gtk.CellRendererText()
#cols = ['Cuisine','Rating','Preparation Time','Cooking Time','Title','Servings']
#for i,l in enumerate(cols):
# col = Gtk.TreeViewColumn('_'+l,text=i)
# tree.append_column(col)
#mod = Gtk.ListStore(*[str]*(i+1))
#for n in range(10): mod.append(cols)
#tree.set_model(mod)
#mm.add_treeview(tree)
mm.fix_conflicts_peacefully()
def show():
def __init__(self, window, player):
"""Initialize
:param GtkWidget window: The main window
:param player: The main player object
"""
self._sidebar = Gtk.ListBox()
sidebar_container = Gtk.ScrolledWindow()
sidebar_container.add(self._sidebar)
super().__init__('playlists', _("Playlists"), window, None, True,
sidebar_container)
self._window = window
self.player = player
self._view.get_style_context().add_class('songs-list')
self._add_list_renderers()
builder = Gtk.Builder()
builder.add_from_resource('/org/gnome/Music/PlaylistControls.ui')
headerbar = builder.get_object('grid')
self._name_stack = builder.get_object('stack')
self._name_label = builder.get_object('playlist_name')
self._rename_entry = builder.get_object('playlist_rename_entry')
self._rename_entry.connect('changed', self._on_rename_entry_changed)
self._rename_done_button = builder.get_object(
'playlist_rename_done_button')
self._songs_count_label = builder.get_object('songs_count')
self._menubutton = builder.get_object('playlist_menubutton')
builder = Gtk.Builder()
builder.add_from_resource('/org/gnome/Music/PlaylistContextMenu.ui')
self._popover_menu = builder.get_object('song_menu')
self._song_popover = Gtk.Popover.new_from_model(
self._view, self._popover_menu)
self._song_popover.set_position(Gtk.PositionType.BOTTOM)
play_song = Gio.SimpleAction.new('play_song', None)
play_song.connect('activate', self._play_song)
self._window.add_action(play_song)
add_song_to_playlist = Gio.SimpleAction.new('add_song_to_playlist',
None)
add_song_to_playlist.connect('activate', self._add_song_to_playlist)
self._window.add_action(add_song_to_playlist)
self._remove_song_action = Gio.SimpleAction.new('remove_song', None)
self._remove_song_action.connect('activate',
self._stage_song_for_deletion)
self._window.add_action(self._remove_song_action)
playlist_play_action = Gio.SimpleAction.new('playlist_play', None)
playlist_play_action.connect('activate', self._on_play_activate)
self._window.add_action(playlist_play_action)
self._playlist_delete_action = Gio.SimpleAction.new(
'playlist_delete', None)
self._playlist_delete_action.connect('activate',
self._stage_playlist_for_deletion)
self._window.add_action(self._playlist_delete_action)
self._playlist_rename_action = Gio.SimpleAction.new(
'playlist_rename', None)
self._playlist_rename_action.connect('activate',
self._stage_playlist_for_renaming)
self._window.add_action(self._playlist_rename_action)
self._grid.insert_row(0)
self._grid.attach(headerbar, 1, 0, 1, 1)
sidebar_container.set_size_request(220, -1)
sidebar_container.get_style_context().add_class('side-panel')
self._sidebar.get_style_context().add_class('view')
self._sidebar.set_selection_mode(Gtk.SelectionMode.SINGLE)
self._sidebar.connect('row-activated', self._on_playlist_activated)
self._grid.insert_column(0)
self._grid.child_set_property(self.stack, 'top-attach', 0)
self._grid.child_set_property(self.stack, 'height', 2)
self._iter_to_clean = None
self._iter_to_clean_model = None
self._current_playlist = None
self._current_playlist_index = None
self.pls_todelete = {}
self._songs_todelete = {}
self._songs_count = 0
self._handler_rename_done_button = 0
self._handler_rename_entry = 0
self._update_songs_count()
self.model.connect('row-inserted', self._on_song_inserted)
self.model.connect('row-deleted', self._on_song_deleted)
self.player.connect('playlist-item-changed', self._update_model)
playlists.connect('playlist-created', self._on_playlist_created)
playlists.connect('playlist-updated', self._on_playlist_update)
playlists.connect('song-added-to-playlist',
self._on_song_added_to_playlist)
playlists.connect('song-position-changed',
self._on_song_position_changed)
self.show_all()
