def add_file_menu(self):
""" Menu item 'File'
"""
file_menu_item = Gtk.MenuItem(label=_("File"))
file_menu = Gtk.Menu()
file_menu_item.set_submenu(file_menu)
reload_item = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_REFRESH , self.agr)
reload_item.set_label(_("Reload"))
key, mod = Gtk.accelerator_parse("<Control>R")
reload_item.add_accelerator("activate", self.agr,
key, mod, Gtk.AccelFlags.VISIBLE)
reload_item.connect("activate", self.on_reload_item)
file_menu.add(reload_item)
quit_item = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_QUIT, self.agr)
quit_item.set_label(_("Quit"))
key, mod = Gtk.accelerator_parse("<Control>Q")
quit_item.add_accelerator("activate", self.agr,
key, mod, Gtk.AccelFlags.VISIBLE)
quit_item.connect("activate", self.on_quit_item)
file_menu.add(quit_item)
return file_menu_item
def __init__(self, datadir, version, argv):
self.file_path = datadir
self.version = version
self.editor = MenuEditor()
Gtk.Window.set_default_icon_name('mozo')
self.tree = Gtk.Builder()
self.tree.set_translation_domain(GETTEXT_PACKAGE)
self.tree.add_from_file(os.path.join(self.file_path, 'mozo.ui'))
self.tree.connect_signals(self)
self.setupMenuTree()
self.setupItemTree()
self.tree.get_object('edit_delete').set_sensitive(False)
self.tree.get_object('edit_revert_to_original').set_sensitive(False)
self.tree.get_object('edit_properties').set_sensitive(False)
self.tree.get_object('move_up_button').set_sensitive(False)
self.tree.get_object('move_down_button').set_sensitive(False)
self.tree.get_object('new_separator_button').set_sensitive(False)
self.tree.get_object('properties_button').set_sensitive(False)
self.tree.get_object('delete_button').set_sensitive(False)
accelgroup = Gtk.AccelGroup()
keyval, modifier = Gtk.accelerator_parse('<Ctrl>Z')
accelgroup.connect(keyval, modifier, Gtk.AccelFlags.VISIBLE, self.on_mainwindow_undo)
keyval, modifier = Gtk.accelerator_parse('<Ctrl><Shift>Z')
accelgroup.connect(keyval, modifier, Gtk.AccelFlags.VISIBLE, self.on_mainwindow_redo)
keyval, modifier = Gtk.accelerator_parse('F1')
accelgroup.connect(keyval, modifier, Gtk.AccelFlags.VISIBLE, self.on_help_button_clicked)
self.tree.get_object('mainwindow').add_accel_group(accelgroup)
def create_category_menu(self):
menuitem = Gtk.MenuItem.new_with_mnemonic('_Category')
# Menu items
self.category_add_menuitem = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_ADD, self.accel_group)
self.category_remove_menuitem = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_REMOVE, self.accel_group)
self.category_rename_menuitem = Gtk.ImageMenuItem.new_with_mnemonic('Re_name')
# Accelerators
self.category_add_menuitem.add_accelerator('activate',
self.accel_group, *Gtk.accelerator_parse('<control>e'),
accel_flags=Gtk.AccelFlags.VISIBLE)
self.category_rename_menuitem.add_accelerator('activate',
self.accel_group, *Gtk.accelerator_parse('F2'),
accel_flags=Gtk.AccelFlags.VISIBLE)
# Add to menu
menu = Gtk.Menu()
menu.append(self.category_add_menuitem)
menu.append(self.category_remove_menuitem)
menu.append(self.category_rename_menuitem)
menuitem.set_submenu(menu)
# Activate
self.category_add_menuitem.connect('activate', self.window.on_category_add, None)
self.category_remove_menuitem.connect('activate', self.window.on_category_remove, None)
self.category_rename_menuitem.connect('activate', self.window.on_category_rename, None)
return menuitem
def get_app_hotkey(self):
app_hotkey_current_accel_name = self.settings.get_property('hotkey-show-app')
try:
(key, mode) = Gtk.accelerator_parse(app_hotkey_current_accel_name)
except Exception:
logger.warning('Unable to parse accelerator "%s". Use Ctrl+Space' % app_hotkey_current_accel_name)
(key, mode) = Gtk.accelerator_parse("<Primary>space")
return Gtk.accelerator_get_label(key, mode)
def loadAccels(self): accels = Gtk.AccelGroup() accelerator = '<control>q' key, mod = Gtk.accelerator_parse(accelerator) accels.connect(key, mod, Gtk.AccelFlags.LOCKED, self.close) accelerator = '<control>0' key, mod = Gtk.accelerator_parse(accelerator) accels.connect(key, mod, Gtk.AccelFlags.LOCKED, self.forceFitImageToWindow) self.main_window.add_accel_group(accels)
def loadAccels(self): accels = Gtk.AccelGroup() accelerator = '<control>s' key, mod = Gtk.accelerator_parse(accelerator) accels.connect(key, mod, Gtk.AccelFlags.LOCKED, self.saveResized) accelerator = '<control>q' key, mod = Gtk.accelerator_parse(accelerator) accels.connect(key, mod, Gtk.AccelFlags.LOCKED, self.close) self.main_window.add_accel_group(accels)
def do_activate(self):
accelgroup = Gtk.AccelGroup()
key, modifier = Gtk.accelerator_parse("<control>t")
accelgroup.connect(key, modifier, Gtk.AccelFlags.VISIBLE, self.indent_event)
key, modifier = Gtk.accelerator_parse("<control><shift>t")
accelgroup.connect(key, modifier, Gtk.AccelFlags.VISIBLE, self.unindent_event)
self.window.add_accel_group(accelgroup)
def add_edit_menu(self):
""" Menu item 'Edit'
"""
edit_menu_item = Gtk.MenuItem(_("Edit"))
edit_menu = Gtk.Menu()
edit_menu_item.set_submenu(edit_menu)
undo_item = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_UNDO, self.agr)
undo_item.set_label(_("Undo Last Action"))
key, mod = Gtk.accelerator_parse("<Control>Z")
undo_item.add_accelerator("activate", self.agr,
key, mod, Gtk.AccelFlags.VISIBLE)
undo_item.connect("activate", self.on_undo_item)
undo_item.set_sensitive(False)
edit_menu.add(undo_item)
self.menu_items["undo"] = undo_item
redo_item = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_REDO, self.agr)
redo_item.set_label(_("Redo Last Action"))
key, mod = Gtk.accelerator_parse("<Control><Shift>Z")
redo_item.add_accelerator("activate", self.agr,
key, mod, Gtk.AccelFlags.VISIBLE)
redo_item.connect("activate", self.on_redo_item)
redo_item.set_sensitive(False)
edit_menu.add(redo_item)
self.menu_items["redo"] = redo_item
clear_item = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_CLEAR, self.agr)
clear_item.set_label(_("Clear Queued Actions"))
clear_item.connect("activate", self.on_clear_item)
clear_item.set_sensitive(False)
edit_menu.add(clear_item)
self.menu_items["clear"] = clear_item
apply_item = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_APPLY, self.agr)
apply_item.set_label(_("Apply Queued Actions"))
key, mod = Gtk.accelerator_parse("<Control>A")
apply_item.add_accelerator("activate", self.agr,
key, mod, Gtk.AccelFlags.VISIBLE)
apply_item.connect("activate", self.on_apply_item)
apply_item.set_sensitive(False)
edit_menu.add(apply_item)
self.menu_items["apply"] = apply_item
return edit_menu_item
def toggle_fullscreen(self, widget, data=None):
if widget.get_active():
self.fullscreen()
key, mod = Gtk.accelerator_parse("Escape")
self.fullscreen_button.add_accelerator("activate",
self.accel_group, key, mod, Gtk.AccelFlags.VISIBLE)
else:
self.unfullscreen()
key, mod = Gtk.accelerator_parse("Escape")
self.fullscreen_button.remove_accelerator(
self.accel_group, key, mod)
self.TextEditor.grab_focus()
def add_partition_menu(self):
""" Menu item 'Partition'
"""
partition_menu_item = Gtk.MenuItem(_("Device"))
partition_menu = Gtk.Menu()
partition_menu_item.set_submenu(partition_menu)
add_item = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_ADD, self.agr)
add_item.set_label(_("New"))
key, mod = Gtk.accelerator_parse("Insert")
add_item.add_accelerator("activate", self.agr,
key, mod, Gtk.AccelFlags.VISIBLE)
add_item.connect("activate", self.on_add_item)
add_item.set_sensitive(False)
partition_menu.add(add_item)
self.menu_items["add"] = add_item
delete_item = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_DELETE, self.agr)
delete_item.set_label(_("Delete"))
key, mod = Gtk.accelerator_parse("Delete")
delete_item.add_accelerator("activate", self.agr,
key, mod, Gtk.AccelFlags.VISIBLE)
delete_item.connect("activate", self.on_delete_item)
delete_item.set_sensitive(False)
partition_menu.add(delete_item)
self.menu_items["delete"] = delete_item
edit_item = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_EDIT, self.agr)
edit_item.set_label(_("Edit"))
edit_item.connect("activate", self.on_edit_item)
edit_item.set_sensitive(False)
partition_menu.add(edit_item)
self.menu_items["edit"] = edit_item
partition_menu.append(Gtk.SeparatorMenuItem())
umount_item = Gtk.MenuItem()
umount_item.set_label(_("Unmount"))
umount_item.connect("activate", self.on_umount_item)
umount_item.set_sensitive(False)
partition_menu.add(umount_item)
self.menu_items["umount"] = umount_item
return partition_menu_item
def __init__(self, parent):
self.ACCEL_CTRL_KEY, self.ACCEL_CTRL_MOD = Gtk.accelerator_parse("<Ctrl>")
self.ACCEL_SHFT_KEY, self.ACCEL_SHFT_MOD = Gtk.accelerator_parse("<Shift>")
self.parent = parent
self.t = 1
self.long_verse = None
self.long_tatwil = None
self.long_space = None
self.clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
Gtk.Box.__init__(self,spacing=7,orientation=Gtk.Orientation.VERTICAL)
self.vp = Gtk.VPaned()
self.view_poem = daw_customs.ViewPoem()
self.view_poem.set_justification(Gtk.Justification.CENTER)
self.view_poem.set_cursor_visible(False)
self.view_poem.set_editable(False)
self.view_poem.set_right_margin(10)
self.view_poem.set_left_margin(10)
self.view_poem_bfr = self.view_poem.get_buffer()
self.speaker_poem_tag = self.view_poem_bfr.create_tag("speaker")
self.search_poem_tag = self.view_poem_bfr.create_tag("search")
scroll = daw_customs.ScrollClass()
scroll.set_shadow_type(Gtk.ShadowType.IN)
scroll.add(self.view_poem)
self.vp.pack1(scroll, False, False)
self.vbox_charh = Gtk.VBox(False, 0)
self.lab_charh = Gtk.Label()
self.close_charh = daw_customs.tool_button(join(daw_customs.ICON_DIR, 'tab.png'),
"إخفاء", lambda *a: self.vbox_charh.hide())
self.save_charh = Gtk.Button("حفظ")
self.save_charh.connect("clicked", self.save_ta3lik)
hb = Gtk.HBox(False,7)
hb.set_border_width(7)
hb.pack_start(self.lab_charh, False, False, 0)
hb.pack_end(self.close_charh, False, False, 0)
hb.pack_end(self.save_charh, False, False, 0)
self.view_charh = daw_customs.ViewEdit()
self.view_charh.set_right_margin(5)
self.view_charh.set_left_margin(5)
self.view_charh.set_cursor_visible(False)
self.view_charh.set_editable(False)
self.view_charh_bfr = self.view_charh.get_buffer()
scroll = Gtk.ScrolledWindow()
scroll.set_shadow_type(Gtk.ShadowType.IN)
scroll.add(self.view_charh)
scroll.set_size_request(-1, 200)
self.vbox_charh.pack_start(hb, False, False, 0)
self.vbox_charh.pack_start(scroll, True, True, 0)
self.pack_start(self.vp, True, True, 0)
self.change_font()
def update_accelerator_label(self):
if self.current_node.shortcut:
key, mods = Gtk.accelerator_parse(self.current_node.shortcut)
label = Gtk.accelerator_get_label(key, mods)
self['accelerator'].set_text(label)
else:
self['accelerator'].set_text('')
def add_help_shortcut(widget, help_addr):
""" Add F1 as a shortcut for help """
agr = Gtk.AccelGroup()
widget.add_accel_group(agr)
key, modifier = Gtk.accelerator_parse('F1')
agr.connect(key, modifier, Gtk.AccelFlags.VISIBLE,
lambda *args: show_help(help_addr))
def send_key_click(widget, accel, recursive=False):
"""Send a key press and release event to a widget or
to all widgets in the hierarchy if recursive is True.
The widget has to be visible for this to work, so this is needed:
with visible(widget):
send_key_click(widget, "<ctrl>a")
Returns how often the event was handled.
"""
key, mods = Gtk.accelerator_parse(accel)
assert key is not None
assert mods is not None
assert isinstance(widget, Gtk.Widget)
handled = _send_key_click_event(widget, state=mods, keyval=key)
if recursive:
if isinstance(widget, Gtk.Container):
for child in widget.get_children():
handled += send_key_click(child, accel, recursive)
return handled
def get_cell_data_cb(self, column, cell, model, piter, user_data=None):
tool = model.get_value(piter, self.TOOL_COLUMN)
if tool == None or not isinstance(tool, Tool):
if tool == None:
label = _('All Languages')
elif not isinstance(tool, GtkSource.Language):
label = _('Plain Text')
else:
label = tool.get_name()
markup = saxutils.escape(label)
editable = False
else:
escaped = saxutils.escape(tool.name)
if tool.shortcut:
key, mods = Gtk.accelerator_parse(tool.shortcut)
label = Gtk.accelerator_get_label(key, mods)
markup = '%s (<b>%s</b>)' % (escaped, label)
else:
markup = escaped
editable = True
cell.set_properties(markup=markup, editable=editable)
def add_help_menu(self):
""" Menu item 'Help'
"""
help_menu_item = Gtk.MenuItem(_("Help"))
help_menu = Gtk.Menu()
help_menu_item.set_submenu(help_menu)
help_item = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_HELP, self.agr)
help_item.set_label(_("Contents"))
key, mod = Gtk.accelerator_parse("F1")
help_item.add_accelerator("activate", self.agr,
key, mod, Gtk.AccelFlags.VISIBLE)
help_item.connect("activate", self.on_help_item)
help_menu.add(help_item)
about_item = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_ABOUT, self.agr)
about_item.set_label(_("About"))
about_item.connect("activate", self.on_about_item)
help_menu.add(about_item)
return help_menu_item
def get_primary_accel_mod():
"""Returns the primary Gdk.ModifierType modifier.
cmd on osx, ctrl everywhere else.
"""
return Gtk.accelerator_parse("<Primary>")[1]
def reload_global(self, settings, key, user_data):
value = settings.get_string(key)
if value == 'disabled':
return
try:
self.guake.hotkeys.unbind(self.globalhotkeys[key])
except Exception as e:
pass
self.globalhotkeys[key] = value
if key == "show-hide":
log.debug("reload_global: %r", value)
if not self.guake.hotkeys.bind(value, self.guake.show_hide):
keyval, mask = Gtk.accelerator_parse(value)
label = Gtk.accelerator_get_label(keyval, mask)
filename = pixmapfile('guake-notification.png')
notifier.showMessage(
_('Guake Terminal'),
_(
'A problem happened when binding <b>%s</b> key.\n'
'Please use Guake Preferences dialog to choose another '
'key'
) % label, filename
)
elif key == "show-focus":
if not self.guake.hotkeys.bind(value, self.guake.show_focus):
log.warn("can't bind show-focus key")
return
def refresh_accel(self):
""" Refreshes the accelerator """
if not shortcut.is_gsettings_present():
self.button.set_sensitive(False)
iter1 = self.liststore.get_iter_first()
self.liststore.set_value(iter1, 1, "Disabled")
self.cell.set_sensitive(False)
if not self.gsettings_install_label_shown:
self._show_gsettings_install_label()
self.gsettings_install_label_shown = True
return
iter1 = self.liststore.get_iter_first()
self.new_task_binding = shortcut.get_saved_binding()
self.binding_backup = self.new_task_binding
if self.new_task_binding == "":
# User had set a shortcut, but has now disabled it
self.button.set_active(False)
self.liststore.set_value(iter1, 1, "Disabled")
return
elif self.new_task_binding is None:
# User hasn't set a shortcut ever
self.button.set_active(False)
self.new_task_binding = self.new_task_default_binding
self.binding_backup = self.new_task_binding
else:
# There exists a shortcut
self.button.set_active(True)
(accel_key, accel_mods) = Gtk.accelerator_parse(self.new_task_binding)
self.show_input = Gtk.accelerator_get_label(accel_key, accel_mods)
self.liststore.set_value(iter1, 1, self.show_input)
def __init__(self, drawing_area, win, uibuilder):
self.log = logging.getLogger('CompositionToolbarController')
accelerators = Gtk.AccelGroup()
win.add_accel_group(accelerators)
composites = [
'fullscreen',
'picture_in_picture',
'side_by_side_equal',
'side_by_side_preview'
]
self.composite_btns = {}
for idx, name in enumerate(composites):
key, mod = Gtk.accelerator_parse('F%u' % (idx+1))
btn = uibuilder.find_widget_recursive(drawing_area, 'composite-'+name.replace('_', '-'))
btn.set_name(name)
# Thanks to http://stackoverflow.com/a/19739855/1659732
btn.get_child().add_accelerator('clicked', accelerators, key, mod, Gtk.AccelFlags.VISIBLE)
btn.connect('toggled', self.on_btn_toggled)
self.composite_btns[name] = btn
# connect event-handler and request initial state
Connection.on('composite_mode', self.on_composite_mode)
Connection.send('get_composite_mode')
def is_accel(event, *accels):
"""Checks if the given keypress Gdk.Event matches
any of accelerator strings.
example: is_accel(event, "<shift><ctrl>z")
"""
assert accels
if event.type != Gdk.EventType.KEY_PRESS:
return False
# ctrl+shift+x gives us ctrl+shift+X and accelerator_parse returns
# lowercase values for matching, so lowercase it if possible
keyval = event.keyval
if not keyval & ~0xFF:
keyval = ord(chr(keyval).lower())
default_mod = Gtk.accelerator_get_default_mod_mask()
for accel in accels:
accel_keyval, accel_mod = Gtk.accelerator_parse(accel)
# If the accel contains non default modifiers matching will
# never work and since no one should use them, complain
non_default = accel_mod & ~default_mod
if non_default:
print_w("Accelerator '%s' contains a non default modifier '%s'." %
(accel, Gtk.accelerator_name(0, non_default) or ""))
# Remove everything except default modifiers and compare
if (accel_keyval, accel_mod) == (keyval, event.state & default_mod):
return True
return False
def try_to_show(self):
accel_name = self.read_accel_from_file()
if accel_name != "":
key, mods = Gtk.accelerator_parse(accel_name)
if Gtk.accelerator_valid(key, mods):
self.accel_name = self.accel_to_qt(accel_name)
self.entry.set_text(self.accel_name)
def add_accelerator(self, widget, accelerator, signal='activate'):
"""Adds a keyboard shortcut to widget for a given signal."""
if accelerator:
key, mod = Gtk.accelerator_parse(accelerator)
widget.add_accelerator(signal, self.accelerators, key, mod,
Gtk.AccelFlags.VISIBLE)
def initUI(self):
# initliaze and configure window
window = Gtk.Window()
window.set_title('Brightness Scale')
window.set_default_size(250, 50)
window.set_position(Gtk.WindowPosition.CENTER)
window.set_border_width(10)
# slider configuration
self.adjustment = Gtk.Adjustment(self.currB, 0, 100, 1, 10, 0)
self.scale = Gtk.HScale()
self.scale.set_adjustment(self.adjustment)
self.scale.set_digits(0)
# close Gtk thread on closing window
window.connect("destroy", lambda w: Gtk.main_quit())
# setup event handler on value-changed
self.scale.connect("value-changed", self.scale_moved)
# add the scale to window
window.add(self.scale)
# show all components in window
window.show_all()
# close window on pressing escape key
accGroup = Gtk.AccelGroup()
key, modifier = Gtk.accelerator_parse('Escape')
accGroup.connect(key, modifier, Gtk.AccelFlags.VISIBLE, Gtk.main_quit)
window.add_accel_group(accGroup)
def add(self, accel, callback, data=None):
num = len(accel.accelerators)
mapping = self.accelerators
for i in range(num):
parsed = Gtk.accelerator_parse(accel.accelerators[i])
if not Gtk.accelerator_valid(*parsed):
return
named = Gtk.accelerator_name(*parsed)
inmap = named in mapping
if i == num - 1 and inmap:
# Last one cannot be in the map
return
elif inmap and isinstance(mapping[named], AccelCallback):
# It's already mapped...
return
else:
if not inmap:
mapping[named] = {}
if i == num - 1:
mapping[named] = AccelCallback(accel, callback, data)
mapping = mapping[named]
def create_menu(item,agr):
if (type(item) == list ):
menu_item = ImageMenuItem(item[0])
menu = Gtk.Menu()
if (item[0] in icon.stock_icon_dict.keys()):
image = Gtk.Image()
image.set_from_icon_name(icon.stock_icon_dict[item[0]],10)
menu_item.set_image(image)
menu_item.set_always_show_image(True)
for i in item[1:]:
sub_menu = create_menu(i,agr)
menu.append(sub_menu)
menu_item.set_submenu(menu)
return menu_item
else:
if(item == SEPARATOR):
terminal_menu_item = SeparatorMenuItem()
return (terminal_menu_item)
else:
terminal_menu_item = ImageMenuItem(item[0])
if (item[0] in icon.stock_icon_dict.keys()):
image = Gtk.Image()
image.set_from_icon_name(icon.stock_icon_dict[item[0]],10)
terminal_menu_item.set_image(image)
terminal_menu_item.set_always_show_image(True)
terminal_menu_item.connect("activate",item[1])
if(item[2] != "None"):
key, mod = Gtk.accelerator_parse(item[2])
terminal_menu_item.add_accelerator("activate", agr, key,
mod, Gtk.AccelFlags.VISIBLE)
return (terminal_menu_item)
def get_conflicting_action(self, action, keyval, mask):
"""Looks for a conflicting action using the specified accelerator.
If an accelerator is used by another action in the same group or
in the "win" and "app" global groups, it is not clear which of them
will trigger when the accelerator is pressed.
Args:
action (str): The "prefix.name" identifying the action for which
the accelerator will be set if there is no conflict.
keyval (int): The key value of the accelerator.
mask (int): The mask value of the accelerator.
Returns:
str: The name of the conflicting action using the accelerator, or None.
"""
group_name = action.split(".")[0]
for group in {group_name, "app", "win"}:
for neighbor_action, unused_title in self.group_actions[group]:
if neighbor_action == action:
continue
for accel in self.app.get_accels_for_action(neighbor_action):
if (keyval, mask) == Gtk.accelerator_parse(accel):
return neighbor_action
return None
def factory(menu_, parent, context):
item = None
dt = (datetime.now() - close_time)
if dt.seconds > 60:
display_name = _('{playlist_name} ({track_count} tracks, closed {minutes} min ago)').format(
playlist_name=playlist.name,
track_count=len(playlist),
minutes=dt.seconds // 60
)
else:
display_name = _('{playlist_name} ({track_count} tracks, closed {seconds} sec ago)').format(
playlist_name=playlist.name,
track_count=len(playlist),
seconds=dt.seconds
)
item = Gtk.ImageMenuItem.new_with_mnemonic(display_name)
item.set_image(Gtk.Image.new_from_icon_name('music-library', Gtk.IconSize.MENU))
# Add accelerator to top item
if self.tab_history[0][1].name == item_name:
key, mods = Gtk.accelerator_parse(self.accelerator.keys)
item.add_accelerator('activate', menu.FAKEACCELGROUP, key, mods,
Gtk.AccelFlags.VISIBLE)
item.connect('activate', lambda w: self.restore_closed_tab(item_name=item_name))
return item
def grab(self, key):
accelerator = key
accelerator = accelerator.replace("<Super>", "<Mod4>")
keyval, modifiers = Gtk.accelerator_parse(accelerator)
if not accelerator or (not keyval and not modifiers):
self.keycode = None
self.modifiers = None
return False
self.keytext = key
try:
self.keycode = self.keymap.get_entries_for_keyval(keyval).keys[0].keycode
except:
# In Betsy, the get_entries_for_keyval() returns an unamed tuple...
self.keycode = self.keymap.get_entries_for_keyval(keyval)[1][0].keycode
self.modifiers = int(modifiers)
catch = error.CatchError(error.BadAccess)
for ignored_mask in self.ignored_masks:
mod = modifiers | ignored_mask
result = self.window.grab_key(self.keycode, mod, True, X.GrabModeAsync, X.GrabModeAsync, onerror=catch)
self.display.flush()
# sync has been blocking. Don't know why.
#self.display.sync()
if catch.get_error():
return False
return True
def add_to_menu(self, menu, items):
""" Add items to menu
:param menu: menu
:type menu: Gtk.Menu
:param items: list of items to add
:type items: list of Gtk.MenuItem
"""
for item in items:
if item[0] == "separator":
menu.append(Gtk.SeparatorMenuItem())
continue
menu_item = Gtk.MenuItem()
menu_item.set_label(item[1])
menu_item.connect("activate", item[3])
if item[2]:
key, mod = Gtk.accelerator_parse(item[2])
menu_item.add_accelerator("activate", self.agr, key, mod, Gtk.AccelFlags.VISIBLE)
if item[0]:
menu_item.set_sensitive(False)
self.menu_items[item[0]] = menu_item
menu.add(menu_item)
def load_accelerators(self):
"""Reads all gconf paths under /apps/guake/keybindings/local
and adds to the main accel_group.
"""
def getk(x):
return self.guake.settings.keybindingsLocal.get_string(x)
key, mask = Gtk.accelerator_parse(getk('reset-terminal'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_reset_terminal
)
key, mask = Gtk.accelerator_parse(getk('quit'))
if key > 0:
self.accel_group.connect(key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_quit)
key, mask = Gtk.accelerator_parse(getk('new-tab'))
if key > 0:
self.accel_group.connect(key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_add)
key, mask = Gtk.accelerator_parse(getk('new-tab-home'))
if key > 0:
self.accel_group.connect(key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_add_home)
key, mask = Gtk.accelerator_parse(getk('close-tab'))
if key > 0:
def x(*args):
prompt_cfg = self.guake.settings.general.get_int('prompt-on-close-tab')
self.guake.get_notebook().delete_page_current(prompt=prompt_cfg)
self.accel_group.connect(key, mask, Gtk.AccelFlags.VISIBLE, x)
key, mask = Gtk.accelerator_parse(getk('previous-tab'))
if key > 0:
self.accel_group.connect(key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_prev)
key, mask = Gtk.accelerator_parse(getk('next-tab'))
if key > 0:
self.accel_group.connect(key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_next)
key, mask = Gtk.accelerator_parse(getk('move-tab-left'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_move_tab_left
)
key, mask = Gtk.accelerator_parse(getk('move-tab-right'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_move_tab_right
)
key, mask = Gtk.accelerator_parse(getk('rename-current-tab'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_rename_current_tab
)
key, mask = Gtk.accelerator_parse(getk('clipboard-copy'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_copy_clipboard
)
key, mask = Gtk.accelerator_parse(getk('clipboard-paste'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_paste_clipboard
)
key, mask = Gtk.accelerator_parse(getk('toggle-fullscreen'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_toggle_fullscreen
)
key, mask = Gtk.accelerator_parse(getk('toggle-hide-on-lose-focus'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_toggle_hide_on_lose_focus
)
key, mask = Gtk.accelerator_parse(getk('zoom-in'))
if key > 0:
self.accel_group.connect(key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_zoom_in)
key, mask = Gtk.accelerator_parse(getk('zoom-in-alt'))
if key > 0:
self.accel_group.connect(key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_zoom_in)
key, mask = Gtk.accelerator_parse(getk('zoom-out'))
if key > 0:
self.accel_group.connect(key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_zoom_out)
key, mask = Gtk.accelerator_parse(getk('increase-height'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_increase_height
)
key, mask = Gtk.accelerator_parse(getk('decrease-height'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_decrease_height
)
key, mask = Gtk.accelerator_parse(getk('increase-transparency'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_increase_transparency
)
key, mask = Gtk.accelerator_parse(getk('decrease-transparency'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_decrease_transparency
)
key, mask = Gtk.accelerator_parse(getk('toggle-transparency'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_toggle_transparency
)
for tab in range(1, 11):
key, mask = Gtk.accelerator_parse(getk('switch-tab%d' % tab))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, self.guake.gen_accel_switch_tabN(tab - 1)
)
key, mask = Gtk.accelerator_parse(getk('switch-tab-last'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, self.guake.accel_switch_tab_last
)
try:
key, mask = Gtk.accelerator_parse(getk('search-on-web'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, self.guake.search_on_web
)
except Exception:
log.exception("Exception occured")
key, mask = Gtk.accelerator_parse(getk('split-tab-vertical'))
if key > 0:
self.accel_group.connect(
key,
mask,
Gtk.AccelFlags.VISIBLE,
(
lambda *args: # keep make style from concat this lines
self.guake.get_notebook().get_current_terminal().get_parent().split_v() or True
)
)
key, mask = Gtk.accelerator_parse(getk('split-tab-horizontal'))
if key > 0:
self.accel_group.connect(
key,
mask,
Gtk.AccelFlags.VISIBLE,
(
lambda *args: # keep make style from concat this lines
self.guake.get_notebook().get_current_terminal().get_parent().split_h() or True
)
)
key, mask = Gtk.accelerator_parse(getk('close-terminal'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE,
(lambda *args: self.guake.get_notebook().get_current_terminal().kill() or True)
)
key, mask = Gtk.accelerator_parse(getk('focus-terminal-up'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, (
lambda *args:
FocusMover(self.guake.window).move_up(
self.guake.get_notebook().get_current_terminal()
) or True)
)
key, mask = Gtk.accelerator_parse(getk('focus-terminal-down'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, (
lambda *args:
FocusMover(self.guake.window).move_down(
self.guake.get_notebook().get_current_terminal()
) or True)
)
key, mask = Gtk.accelerator_parse(getk('focus-terminal-right'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, (
lambda *args:
FocusMover(self.guake.window).move_right(
self.guake.get_notebook().get_current_terminal()
) or True)
)
key, mask = Gtk.accelerator_parse(getk('focus-terminal-left'))
if key > 0:
self.accel_group.connect(
key, mask, Gtk.AccelFlags.VISIBLE, (
lambda *args:
FocusMover(self.guake.window).move_left(
self.guake.get_notebook().get_current_terminal()
) or True)
)
key, mask = Gtk.accelerator_parse(getk('move-terminal-split-up'))
if key > 0:
self.accel_group.connect(
key,
mask,
Gtk.AccelFlags.VISIBLE,
(
lambda *args: # keep make style from concat this lines
SplitMover.move_up(self.guake.get_notebook().get_current_terminal()) or True
)
)
key, mask = Gtk.accelerator_parse(getk('move-terminal-split-down'))
if key > 0:
self.accel_group.connect(
key,
mask,
Gtk.AccelFlags.VISIBLE,
(
lambda *args: # keep make style from concat this lines
SplitMover.move_down(self.guake.get_notebook().get_current_terminal()) or True
)
)
key, mask = Gtk.accelerator_parse(getk('move-terminal-split-left'))
if key > 0:
self.accel_group.connect(
key,
mask,
Gtk.AccelFlags.VISIBLE,
(
lambda *args: # keep make style from concat this lines
SplitMover.move_left(self.guake.get_notebook().get_current_terminal()) or True
)
)
key, mask = Gtk.accelerator_parse(getk('move-terminal-split-right'))
if key > 0:
self.accel_group.connect(
key,
mask,
Gtk.AccelFlags.VISIBLE,
(
lambda *args: # keep make style from concat this lines
SplitMover.move_right(self.guake.get_notebook().get_current_terminal()) or True
)
)
def __init__(self, application):
self.application = application
self.settings = Gio.Settings(schema_id="org.x.webapp-manager")
self.manager = WebAppManager()
self.selected_webapp = None
self.icon_theme = Gtk.IconTheme.get_default()
# Set the Glade file
gladefile = "/usr/share/webapp-manager/webapp-manager.ui"
self.builder = Gtk.Builder()
self.builder.set_translation_domain(APP)
self.builder.add_from_file(gladefile)
self.window = self.builder.get_object("main_window")
self.window.set_title(_("Web Apps"))
self.window.set_icon_name("webapp-manager")
self.stack = self.builder.get_object("stack")
self.icon_chooser = XApp.IconChooserButton()
self.builder.get_object("icon_button_box").pack_start(self.icon_chooser, 0, True, True)
self.icon_chooser.set_icon("webapp-manager")
self.icon_chooser.show()
# Create variables to quickly access dynamic widgets
self.headerbar = self.builder.get_object("headerbar")
self.favicon_button = self.builder.get_object("favicon_button")
self.add_button = self.builder.get_object("add_button")
self.remove_button = self.builder.get_object("remove_button")
self.edit_button = self.builder.get_object("edit_button")
self.run_button = self.builder.get_object("run_button")
self.ok_button = self.builder.get_object("ok_button")
self.name_entry = self.builder.get_object("name_entry")
self.url_entry = self.builder.get_object("url_entry")
self.url_label = self.builder.get_object("url_label")
self.isolated_switch = self.builder.get_object("isolated_switch")
self.isolated_label = self.builder.get_object("isolated_label")
self.navbar_switch = self.builder.get_object("navbar_switch")
self.navbar_label = self.builder.get_object("navbar_label")
self.spinner = self.builder.get_object("spinner")
self.favicon_stack = self.builder.get_object("favicon_stack")
self.browser_combo = self.builder.get_object("browser_combo")
self.browser_label = self.builder.get_object("browser_label")
# Widgets which are in the add page but not the edit page
self.add_specific_widgets = [self.url_label, self.url_entry, self.favicon_button,
self.browser_label, self.browser_combo,
self.isolated_label, self.isolated_switch,
self.navbar_label, self.navbar_switch]
# Widget signals
self.add_button.connect("clicked", self.on_add_button)
self.builder.get_object("cancel_button").connect("clicked", self.on_cancel_button)
self.builder.get_object("cancel_favicon_button").connect("clicked", self.on_cancel_favicon_button)
self.remove_button.connect("clicked", self.on_remove_button)
self.edit_button.connect("clicked", self.on_edit_button)
self.run_button.connect("clicked", self.on_run_button)
self.ok_button.connect("clicked", self.on_ok_button)
self.favicon_button.connect("clicked", self.on_favicon_button)
self.name_entry.connect("changed", self.on_name_entry)
self.url_entry.connect("changed", self.on_url_entry)
self.window.connect("key-press-event",self.on_key_press_event)
# Menubar
accel_group = Gtk.AccelGroup()
self.window.add_accel_group(accel_group)
menu = self.builder.get_object("main_menu")
item = Gtk.ImageMenuItem()
item.set_image(Gtk.Image.new_from_icon_name("preferences-desktop-keyboard-shortcuts-symbolic", Gtk.IconSize.MENU))
item.set_label(_("Keyboard Shortcuts"))
item.connect("activate", self.open_keyboard_shortcuts)
key, mod = Gtk.accelerator_parse("<Control>K")
item.add_accelerator("activate", accel_group, key, mod, Gtk.AccelFlags.VISIBLE)
menu.append(item)
item = Gtk.ImageMenuItem()
item.set_image(Gtk.Image.new_from_icon_name("help-about-symbolic", Gtk.IconSize.MENU))
item.set_label(_("About"))
item.connect("activate", self.open_about)
key, mod = Gtk.accelerator_parse("F1")
item.add_accelerator("activate", accel_group, key, mod, Gtk.AccelFlags.VISIBLE)
menu.append(item)
item = Gtk.ImageMenuItem(label=_("Quit"))
image = Gtk.Image.new_from_icon_name("application-exit-symbolic", Gtk.IconSize.MENU)
item.set_image(image)
item.connect('activate', self.on_menu_quit)
key, mod = Gtk.accelerator_parse("<Control>Q")
item.add_accelerator("activate", accel_group, key, mod, Gtk.AccelFlags.VISIBLE)
key, mod = Gtk.accelerator_parse("<Control>W")
item.add_accelerator("activate", accel_group, key, mod, Gtk.AccelFlags.VISIBLE)
menu.append(item)
menu.show_all()
# Treeview
self.treeview = self.builder.get_object("webapps_treeview")
renderer = Gtk.CellRendererPixbuf()
column = Gtk.TreeViewColumn("", renderer, pixbuf=COL_ICON)
column.set_cell_data_func(renderer, self.data_func_surface)
self.treeview.append_column(column)
column = Gtk.TreeViewColumn("", Gtk.CellRendererText(), text=COL_NAME)
column.set_sort_column_id(COL_NAME)
column.set_resizable(True)
self.treeview.append_column(column)
self.treeview.show()
self.model = Gtk.TreeStore(GdkPixbuf.Pixbuf, str, object) # icon, name, webapp
self.model.set_sort_column_id(COL_NAME, Gtk.SortType.ASCENDING)
self.treeview.set_model(self.model)
self.treeview.get_selection().connect("changed", self.on_webapp_selected)
self.treeview.connect("row-activated", self.on_webapp_activated)
# Combox box
category_model = Gtk.ListStore(str,str) # CATEGORY_ID, CATEGORY_NAME
category_model.append(["Network",_("Internet")])
category_model.append(["WebApps",_("Web")])
category_model.append(["Utility",_("Accessories")])
category_model.append(["Game",_("Games")])
category_model.append(["Graphics",_("Graphics")])
category_model.append(["Office",_("Office")])
category_model.append(["AudioVideo",_("Sound & Video")])
category_model.append(["Development",_("Programming")])
category_model.append(["Education",_("Education")])
self.category_combo = self.builder.get_object("category_combo")
renderer = Gtk.CellRendererText()
self.category_combo.pack_start(renderer, True)
self.category_combo.add_attribute(renderer, "text", CATEGORY_NAME)
self.category_combo.set_model(category_model)
self.category_combo.set_active(0) # Select 1st category
browser_model = Gtk.ListStore(object, str) # BROWSER_OBJ, BROWSER_NAME
num_browsers = 0
for browser in self.manager.get_supported_browsers():
if os.path.exists(browser.test_path):
browser_model.append([browser, browser.name])
num_browsers += 1
renderer = Gtk.CellRendererText()
self.browser_combo.pack_start(renderer, True)
self.browser_combo.add_attribute(renderer, "text", BROWSER_NAME)
self.browser_combo.set_model(browser_model)
self.browser_combo.set_active(0) # Select 1st browser
if (num_browsers < 2):
self.browser_label.hide()
self.browser_combo.hide()
self.browser_combo.connect("changed", self.on_browser_changed)
self.load_webapps()
# Used by the OK button, indicates whether we're editing a web-app or adding a new one.
self.edit_mode = False
def __init__(self, library):
super(MediaDevices, self).__init__(spacing=6)
self.set_orientation(Gtk.Orientation.VERTICAL)
self._register_instance()
self.__cache = {}
# Device list on the left pane
swin = ScrolledWindow()
swin.set_shadow_type(Gtk.ShadowType.IN)
swin.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
self.pack_start(swin, True, True, 0)
self.__view = view = AllTreeView()
view.set_model(self.__devices)
view.set_rules_hint(True)
view.set_headers_visible(False)
view.get_selection().set_mode(Gtk.SelectionMode.BROWSE)
connect_obj(view.get_selection(), 'changed', self.__refresh, False)
view.connect('popup-menu', self.__popup_menu, library)
view.connect('row-activated', lambda *a: self.songs_activated())
swin.add(view)
col = Gtk.TreeViewColumn("Devices")
view.append_column(col)
render = Gtk.CellRendererPixbuf()
col.pack_start(render, False)
col.add_attribute(render, 'icon-name', 1)
self.__render = render = Gtk.CellRendererText()
render.set_property('ellipsize', Pango.EllipsizeMode.END)
render.connect('edited', self.__edited)
col.pack_start(render, True)
col.set_cell_data_func(render, MediaDevices.cell_data)
hbox = Gtk.HBox(spacing=6)
hbox.set_homogeneous(True)
self.pack_start(Align(hbox, left=3, bottom=3), False, True, 0)
# refresh button
refresh = Button(_("_Refresh"), Icons.VIEW_REFRESH, Gtk.IconSize.MENU)
self.__refresh_button = refresh
connect_obj(refresh, 'clicked', self.__refresh, True)
refresh.set_sensitive(False)
hbox.pack_start(refresh, True, True, 0)
# eject button
eject = Button(_("_Eject"), Icons.MEDIA_EJECT, Gtk.IconSize.MENU)
self.__eject_button = eject
eject.connect('clicked', self.__eject)
eject.set_sensitive(False)
hbox.pack_start(eject, True, True, 0)
# Device info on the right pane
self.__header = table = Gtk.Table()
table.set_col_spacings(8)
self.__device_icon = icon = Gtk.Image()
icon.set_size_request(48, 48)
table.attach(icon, 0, 1, 0, 2, 0)
self.__device_name = label = Gtk.Label()
label.set_ellipsize(Pango.EllipsizeMode.END)
label.set_alignment(0, 0)
table.attach(label, 1, 3, 0, 1)
self.__device_space = label = Gtk.Label()
label.set_ellipsize(Pango.EllipsizeMode.END)
label.set_alignment(0, 0.5)
table.attach(label, 1, 2, 1, 2)
self.__progress = progress = Gtk.ProgressBar()
progress.set_size_request(150, -1)
table.attach(progress, 2, 3, 1, 2, xoptions=0, yoptions=0)
self.accelerators = Gtk.AccelGroup()
key, mod = Gtk.accelerator_parse('F2')
self.accelerators.connect(key, mod, 0, self.__rename)
self.__statusbar = WaitLoadBar()
for child in self.get_children():
child.show_all()
def install_mac_additions(self):
#header_bar = Gtk.Template.Child()
self.maximize_button = Gtk.Template.Child()
# Manually handle GAction additions
actions = (
("close-window", self.action_close_window),
("minimize-window", self.action_minimize_window),
("maximize-window", self.action_maximize_window),
)
for name, callback in actions:
action = Gio.SimpleAction.new(name, None)
action.connect('activate', callback)
self.add_action(action)
# Menu actions
actions = (
("FileMenu", None, _("_File")),
("New", Gtk.STOCK_NEW, _("_New Comparison…"), "<Primary>N",
_("Start a new comparison"), self.on_menu_file_new_activate),
("Save", Gtk.STOCK_SAVE, None, None, _("Save the current file"),
self.on_menu_save_activate),
("SaveAs", Gtk.STOCK_SAVE_AS, _("Save As…"), "<Primary><shift>S",
_("Save the current file with a different name"),
self.on_menu_save_as_activate),
("Close", Gtk.STOCK_CLOSE, None, None, _("Close the current file"),
self.on_menu_close_activate),
("EditMenu", None, _("_Edit")),
("Undo", Gtk.STOCK_UNDO, None, "<Primary>Z",
_("Undo the last action"), self.on_menu_undo_activate),
("Redo", Gtk.STOCK_REDO, None, "<Primary><shift>Z",
_("Redo the last undone action"), self.on_menu_redo_activate),
("Cut", Gtk.STOCK_CUT, None, None, _("Cut the selection"),
self.on_menu_cut_activate),
("Copy", Gtk.STOCK_COPY, None, None, _("Copy the selection"),
self.on_menu_copy_activate),
("Paste", Gtk.STOCK_PASTE, None, None, _("Paste the clipboard"),
self.on_menu_paste_activate),
("Find", Gtk.STOCK_FIND, _("Find…"), None, _("Search for text"),
self.on_menu_find_activate),
("FindNext", None, _("Find Ne_xt"), "<Primary>G",
_("Search forwards for the same text"),
self.on_menu_find_next_activate),
("FindPrevious", None, _("Find _Previous"), "<Primary><shift>G",
_("Search backwards for the same text"),
self.on_menu_find_previous_activate),
("Replace",
Gtk.STOCK_FIND_AND_REPLACE, _("_Replace…"), "<Primary>H",
_("Find and replace text"), self.on_menu_replace_activate),
("GoToLine", None, _("Go to _Line"), "<Primary>I",
_("Go to a specific line"), self.on_menu_go_to_line_activate),
("ChangesMenu", None, _("_Changes")),
("NextChange", Gtk.STOCK_GO_DOWN, _("Next Change"), "<Alt>Down",
_("Go to the next change"), self.on_menu_edit_down_activate),
("PrevChange", Gtk.STOCK_GO_UP, _("Previous Change"), "<Alt>Up",
_("Go to the previous change"), self.on_menu_edit_up_activate),
("OpenExternal", None, _("Open Externally"), None,
_("Open selected file or directory in the default external "
"application"), self.on_open_external),
("ViewMenu", None, _("_View")),
("FileStatus", None, _("File Status")),
("VcStatus", None, _("Version Status")),
("FileFilters", None, _("File Filters")),
("Stop", Gtk.STOCK_STOP, None, "Escape",
_("Stop the current action"), self.on_toolbar_stop_clicked),
("Refresh", Gtk.STOCK_REFRESH, None, "<Primary>R",
_("Refresh the view"), self.on_menu_refresh_activate),
)
self.actiongroup = Gtk.ActionGroup(name='MainActions')
self.actiongroup.set_translation_domain("meld")
self.actiongroup.add_actions(actions)
recent_action = Gtk.RecentAction(name="Recent",
label=_("Open Recent"),
tooltip=_("Open recent files"),
stock_id=None)
recent_action.set_show_private(True)
recent_action.set_filter(recent_comparisons.recent_filter)
recent_action.set_sort_type(Gtk.RecentSortType.MRU)
recent_action.connect("item-activated", self.on_action_recent)
self.actiongroup.add_action(recent_action)
self.ui = Gtk.UIManager()
self.ui.insert_action_group(self.actiongroup, 0)
self.ui.add_ui_from_file(ui_file("meldapp-ui.xml"))
for menuitem in ("Save", "Undo"):
self.actiongroup.get_action(menuitem).props.is_important = True
self.add_accel_group(self.ui.get_accel_group())
self.menubar = self.ui.get_widget('/Menubar')
self.menubar.hide()
self.quartz_ready = False
# Alternate keybindings for a few commands.
extra_accels = (
("<Primary>D", self.on_menu_edit_down_activate),
("<Primary>E", self.on_menu_edit_up_activate),
("<Alt>KP_Down", self.on_menu_edit_down_activate),
("<Alt>KP_Up", self.on_menu_edit_up_activate),
("F5", self.on_menu_refresh_activate),
)
accel_group = self.ui.get_accel_group()
for accel, callback in extra_accels:
keyval, mask = Gtk.accelerator_parse(accel)
accel_group.connect(keyval, mask, 0, callback)
self.connect('window-state-event', self.on_window_state_event)
def __init__(self):
gnomeglade.Component.__init__(self, "meldapp.ui", "meldapp")
self.widget.set_name("meldapp")
actions = (
("FileMenu", None, _("_File")),
("New", Gtk.STOCK_NEW, _("_New Comparison..."), "<Primary>N",
_("Start a new comparison"), self.on_menu_file_new_activate),
("Save", Gtk.STOCK_SAVE, None, None, _("Save the current file"),
self.on_menu_save_activate),
("SaveAs", Gtk.STOCK_SAVE_AS, _("Save As..."), "<Primary><shift>S",
_("Save the current file with a different name"),
self.on_menu_save_as_activate),
("Close", Gtk.STOCK_CLOSE, None, None, _("Close the current file"),
self.on_menu_close_activate),
("EditMenu", None, _("_Edit")),
("Undo", Gtk.STOCK_UNDO, None, "<Primary>Z",
_("Undo the last action"), self.on_menu_undo_activate),
("Redo", Gtk.STOCK_REDO, None, "<Primary><shift>Z",
_("Redo the last undone action"), self.on_menu_redo_activate),
("Cut", Gtk.STOCK_CUT, None, None, _("Cut the selection"),
self.on_menu_cut_activate),
("Copy", Gtk.STOCK_COPY, None, None, _("Copy the selection"),
self.on_menu_copy_activate),
("Paste", Gtk.STOCK_PASTE, None, None, _("Paste the clipboard"),
self.on_menu_paste_activate),
("Find", Gtk.STOCK_FIND, _("Find..."), None, _("Search for text"),
self.on_menu_find_activate),
("FindNext", None, _("Find Ne_xt"), "<Primary>G",
_("Search forwards for the same text"),
self.on_menu_find_next_activate),
("FindPrevious", None, _("Find _Previous"), "<Primary><shift>G",
_("Search backwards for the same text"),
self.on_menu_find_previous_activate),
("Replace",
Gtk.STOCK_FIND_AND_REPLACE, _("_Replace..."), "<Primary>H",
_("Find and replace text"), self.on_menu_replace_activate),
("ChangesMenu", None, _("_Changes")),
("NextChange", Gtk.STOCK_GO_DOWN, _("Next Change"), "<Alt>Down",
_("Go to the next change"), self.on_menu_edit_down_activate),
("PrevChange", Gtk.STOCK_GO_UP, _("Previous Change"), "<Alt>Up",
_("Go to the previous change"), self.on_menu_edit_up_activate),
("OpenExternal", None, _("Open Externally"), None,
_("Open selected file or directory in the default external "
"application"), self.on_open_external),
("ViewMenu", None, _("_View")),
("FileStatus", None, _("File Status")),
("VcStatus", None, _("Version Status")),
("FileFilters", None, _("File Filters")),
("Stop", Gtk.STOCK_STOP, None, "Escape",
_("Stop the current action"), self.on_toolbar_stop_clicked),
("Refresh", Gtk.STOCK_REFRESH, None, "<Primary>R",
_("Refresh the view"), self.on_menu_refresh_activate),
("TabMenu", None, _("_Tabs")),
("PrevTab", None, _("_Previous Tab"), "<Ctrl><Alt>Page_Up",
_("Activate previous tab"), self.on_prev_tab),
("NextTab", None, _("_Next Tab"), "<Ctrl><Alt>Page_Down",
_("Activate next tab"), self.on_next_tab),
("MoveTabPrev", None,
_("Move Tab _Left"), "<Ctrl><Alt><Shift>Page_Up",
_("Move current tab to left"), self.on_move_tab_prev),
("MoveTabNext", None,
_("Move Tab _Right"), "<Ctrl><Alt><Shift>Page_Down",
_("Move current tab to right"), self.on_move_tab_next),
)
toggleactions = (
("Fullscreen", None, _("Fullscreen"), "F11",
_("View the comparison in fullscreen"),
self.on_action_fullscreen_toggled, False),
("ToolbarVisible", None, _("_Toolbar"), None,
_("Show or hide the toolbar"), None, True),
)
ui_file = gnomeglade.ui_file("meldapp-ui.xml")
self.actiongroup = Gtk.ActionGroup(name='MainActions')
self.actiongroup.set_translation_domain("meld")
self.actiongroup.add_actions(actions)
self.actiongroup.add_toggle_actions(toggleactions)
recent_action = Gtk.RecentAction(name="Recent",
label=_("Open Recent"),
tooltip=_("Open recent files"),
stock_id=None)
recent_action.set_show_private(True)
recent_action.set_filter(recent_comparisons.recent_filter)
recent_action.set_sort_type(Gtk.RecentSortType.MRU)
recent_action.connect("item-activated", self.on_action_recent)
self.actiongroup.add_action(recent_action)
self.ui = Gtk.UIManager()
self.ui.insert_action_group(self.actiongroup, 0)
self.ui.add_ui_from_file(ui_file)
# Manually handle shells that don't show an application menu
gtk_settings = Gtk.Settings.get_default()
if not gtk_settings.props.gtk_shell_shows_app_menu or is_darwin():
from meldapp import app
def make_app_action(name):
def app_action(*args):
app.lookup_action(name).activate(None)
return app_action
app_actions = (
("AppMenu", None, _("_Meld")),
("Quit", Gtk.STOCK_QUIT, None, None, _("Quit the program"),
make_app_action('quit')),
("Preferences", Gtk.STOCK_PREFERENCES, _("Prefere_nces"), None,
_("Configure the application"),
make_app_action('preferences')),
("Help", Gtk.STOCK_HELP, _("_Contents"), "F1",
_("Open the Meld manual"), make_app_action('help')),
("About", Gtk.STOCK_ABOUT, None, None,
_("About this application"), make_app_action('about')),
)
app_actiongroup = Gtk.ActionGroup(name="AppActions")
app_actiongroup.set_translation_domain("meld")
app_actiongroup.add_actions(app_actions)
self.ui.insert_action_group(app_actiongroup, 0)
ui_file = gnomeglade.ui_file("appmenu-fallback.xml")
self.ui.add_ui_from_file(ui_file)
self.widget.set_show_menubar(False)
self.tab_switch_actiongroup = None
self.tab_switch_merge_id = None
for menuitem in ("Save", "Undo"):
self.actiongroup.get_action(menuitem).props.is_important = True
self.widget.add_accel_group(self.ui.get_accel_group())
self.menubar = self.ui.get_widget('/Menubar')
self.toolbar = self.ui.get_widget('/Toolbar')
self.toolbar.get_style_context().add_class(
Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)
settings.bind('toolbar-visible',
self.actiongroup.get_action('ToolbarVisible'), 'active',
Gio.SettingsBindFlags.DEFAULT)
settings.bind('toolbar-visible', self.toolbar, 'visible',
Gio.SettingsBindFlags.DEFAULT)
interface_settings.bind('toolbar-style', self.toolbar, 'toolbar-style',
Gio.SettingsBindFlags.DEFAULT)
# Add alternate keybindings for Prev/Next Change
accels = self.ui.get_accel_group()
(keyval, mask) = Gtk.accelerator_parse("<Primary>D")
accels.connect(keyval, mask, 0, self.on_menu_edit_down_activate)
(keyval, mask) = Gtk.accelerator_parse("<Primary>E")
accels.connect(keyval, mask, 0, self.on_menu_edit_up_activate)
(keyval, mask) = Gtk.accelerator_parse("F5")
accels.connect(keyval, mask, 0, self.on_menu_refresh_activate)
# Initialise sensitivity for important actions
self.actiongroup.get_action("Stop").set_sensitive(False)
self._update_page_action_sensitivity()
self.appvbox.pack_start(self.menubar, False, True, 0)
self.toolbar_holder.pack_start(self.toolbar, True, True, 0)
# Double toolbars to work around UIManager integration issues
self.secondary_toolbar = Gtk.Toolbar()
self.secondary_toolbar.get_style_context().add_class(
Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)
self.toolbar_holder.pack_end(self.secondary_toolbar, False, True, 0)
toolbutton = Gtk.ToolItem()
self.spinner = Gtk.Spinner()
toolbutton.add(self.spinner)
self.secondary_toolbar.insert(toolbutton, -1)
# Set a minimum size because the spinner requests nothing
self.secondary_toolbar.set_size_request(30, -1)
self.secondary_toolbar.show_all()
self.widget.drag_dest_set(
Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT
| Gtk.DestDefaults.DROP, None, Gdk.DragAction.COPY)
self.widget.drag_dest_add_uri_targets()
self.widget.connect("drag_data_received",
self.on_widget_drag_data_received)
self.should_close = False
self.idle_hooked = 0
self.scheduler = task.LifoScheduler()
self.scheduler.connect("runnable", self.on_scheduler_runnable)
window_size = settings.get_value('window-size')
self.widget.set_default_size(window_size[0], window_size[1])
window_state = settings.get_string('window-state')
if window_state == 'maximized':
self.widget.maximize()
self.ui.ensure_update()
self.diff_handler = None
self.undo_handlers = tuple()
self.widget.connect('focus_in_event', self.on_focus_change)
self.widget.connect('focus_out_event', self.on_focus_change)
if is_darwin():
self.osx_ready = False
self.widget.connect('window_state_event', self.osx_menu_setup)
# Set tooltip on map because the recentmenu is lazily created
rmenu = self.ui.get_widget('/Menubar/FileMenu/Recent').get_submenu()
rmenu.connect("map", self._on_recentmenu_map)
try:
builder = meld.ui.util.get_builder("shortcuts.ui")
shortcut_window = builder.get_object("shortcuts-meld")
self.widget.set_help_overlay(shortcut_window)
except GLib.Error:
# GtkShortcutsWindow is new in GTK+ 3.20
pass
def __init__(self, library, dir=None):
super().__init__(dialog=False)
self.set_title("Ex Falso")
self.set_default_size(750, 475)
self.enable_window_tracking("exfalso")
self.__library = library
hp = ConfigRHPaned("memory", "exfalso_paned_position", 1.0)
hp.set_border_width(0)
hp.set_position(250)
hp.show()
self.add(hp)
vb = Gtk.VBox()
bbox = Gtk.HBox(spacing=6)
def prefs_cb(*args):
window = PreferencesWindow(self)
window.show()
def plugin_window_cb(*args):
window = PluginWindow(self)
window.show()
def about_cb(*args):
about = AboutDialog(self, app)
about.run()
about.destroy()
def update_cb(*args):
d = UpdateDialog(self)
d.run()
d.destroy()
menu = Gtk.Menu()
about_item = MenuItem(_("_About"), Icons.HELP_ABOUT)
about_item.connect("activate", about_cb)
menu.append(about_item)
check_item = MenuItem(_("_Check for Updates…"), Icons.NETWORK_SERVER)
check_item.connect("activate", update_cb)
menu.append(check_item)
menu.append(SeparatorMenuItem())
plugin_item = MenuItem(_("_Plugins"), Icons.SYSTEM_RUN)
plugin_item.connect("activate", plugin_window_cb)
menu.append(plugin_item)
pref_item = MenuItem(_("_Preferences"), Icons.PREFERENCES_SYSTEM)
pref_item.connect("activate", prefs_cb)
menu.append(pref_item)
menu.show_all()
menu_button = MenuButton(SymbolicIconImage(Icons.EMBLEM_SYSTEM,
Gtk.IconSize.BUTTON),
arrow=True,
down=False)
menu_button.set_menu(menu)
bbox.pack_start(menu_button, False, True, 0)
l = Gtk.Label()
l.set_alignment(1.0, 0.5)
l.set_ellipsize(Pango.EllipsizeMode.END)
bbox.pack_start(l, True, True, 0)
self._fs = fs = MainFileSelector()
vb.pack_start(fs, True, True, 0)
vb.pack_start(Align(bbox, border=6), False, True, 0)
vb.show_all()
hp.pack1(vb, resize=True, shrink=False)
nb = qltk.Notebook()
nb.props.scrollable = True
nb.show()
for Page in [EditTags, TagsFromPath, RenameFiles, TrackNumbers]:
page = Page(self, self.__library)
page.show()
nb.append_page(page)
hp.pack2(nb, resize=True, shrink=False)
fs.connect('changed', self.__changed, l)
if dir:
fs.go_to(dir)
connect_destroy(self.__library, 'changed', self.__library_changed, fs)
self.__save = None
connect_obj(self, 'changed', self.set_pending, None)
for c in fs.get_children():
c.get_child().connect('button-press-event',
self.__pre_selection_changed, fs, nb)
c.get_child().connect('focus', self.__pre_selection_changed, fs,
nb)
fs.get_children()[1].get_child().connect('popup-menu',
self.__popup_menu, fs)
self.emit('changed', [])
self.get_child().show()
self.__ag = Gtk.AccelGroup()
key, mod = Gtk.accelerator_parse("<Primary>Q")
self.__ag.connect(key, mod, 0, lambda *x: self.destroy())
self.add_accel_group(self.__ag)
# GtkosxApplication assumes the menu bar is mapped, so add
# it but don't show it.
self._dummy_osx_menu_bar = Gtk.MenuBar()
vb.pack_start(self._dummy_osx_menu_bar, False, False, 0)
def __init__(self, preview_box, win, uibuilder):
self.log = logging.getLogger('VideoPreviewsController')
self.preview_box = preview_box
self.win = win
self.sources = Config.getlist('mix', 'sources')
self.preview_players = {}
self.previews = {}
self.a_btns = {}
self.b_btns = {}
self.volume_sliders = {}
self.current_source = {'a': None, 'b': None}
try:
width = Config.getint('previews', 'width')
self.log.debug('Preview-Width configured to %u', width)
except NoOptionError:
width = 320
self.log.debug('Preview-Width selected as %u', width)
try:
height = Config.getint('previews', 'height')
self.log.debug('Preview-Height configured to %u', height)
except NoOptionError:
height = int(width * 9 / 16)
self.log.debug('Preview-Height calculated to %u', height)
# Accelerators
accelerators = Gtk.AccelGroup()
win.add_accel_group(accelerators)
group_a = None
group_b = None
# Check if there is a fixed audio source configured.
# If so, we will remove the volume sliders entirely
# instead of setting them up.
volume_control = \
Config.getboolean('audio', 'volumecontrol', fallback=True) or \
Config.getboolean('audio', 'forcevolumecontrol', fallback=False)
for idx, source in enumerate(self.sources):
self.log.info('Initializing Video Preview %s', source)
preview = uibuilder.get_check_widget('widget_preview', clone=True)
video = uibuilder.find_widget_recursive(preview, 'video')
video.set_size_request(width, height)
preview_box.pack_start(preview,
fill=False,
expand=False,
padding=0)
player = VideoDisplay(video,
port=13000 + idx,
width=width,
height=height)
uibuilder.find_widget_recursive(preview, 'label').set_label(source)
btn_a = uibuilder.find_widget_recursive(preview, 'btn_a')
btn_b = uibuilder.find_widget_recursive(preview, 'btn_b')
btn_a.set_name("%c %u" % ('a', idx))
btn_b.set_name("%c %u" % ('b', idx))
if not group_a:
group_a = btn_a
else:
btn_a.join_group(group_a)
if not group_b:
group_b = btn_b
else:
btn_b.join_group(group_b)
btn_a.connect('toggled', self.btn_toggled)
btn_b.connect('toggled', self.btn_toggled)
key, mod = Gtk.accelerator_parse('%u' % (idx + 1))
btn_a.add_accelerator('activate', accelerators, key, mod,
Gtk.AccelFlags.VISIBLE)
tooltip = Gtk.accelerator_get_label(key, mod)
btn_a.set_tooltip_text(tooltip)
key, mod = Gtk.accelerator_parse('<Ctrl>%u' % (idx + 1))
btn_b.add_accelerator('activate', accelerators, key, mod,
Gtk.AccelFlags.VISIBLE)
tooltip = Gtk.accelerator_get_label(key, mod)
btn_b.set_tooltip_text(tooltip)
btn_fullscreen = uibuilder.find_widget_recursive(
preview, 'btn_fullscreen')
btn_fullscreen.set_name("%c %u" % ('f', idx))
btn_fullscreen.connect('clicked', self.btn_fullscreen_clicked)
key, mod = Gtk.accelerator_parse('<Alt>%u' % (idx + 1))
btn_fullscreen.add_accelerator('activate', accelerators, key, mod,
Gtk.AccelFlags.VISIBLE)
tooltip = Gtk.accelerator_get_label(key, mod)
btn_fullscreen.set_tooltip_text(tooltip)
volume_slider = uibuilder.find_widget_recursive(
preview, 'audio_level')
if not volume_control:
box = uibuilder.find_widget_recursive(preview, 'box')
box.remove(volume_slider)
else:
volume_slider.set_name("volume {}".format(source))
volume_signal = volume_slider.connect('value-changed',
self.slider_changed)
def slider_format(scale, value):
if value == -20.0:
return "-\u221e\u202fdB"
else:
return "{:.{}f}\u202fdB".format(
value, scale.get_digits())
volume_slider.connect('format-value', slider_format)
self.volume_sliders[source] = (volume_slider, volume_signal)
self.preview_players[source] = player
self.previews[source] = preview
self.a_btns[source] = btn_a
self.b_btns[source] = btn_b
# connect event-handler and request initial state
Connection.on('video_status', self.on_video_status)
Connection.send('get_video')
if volume_control:
Connection.on('audio_status', self.on_audio_status)
Connection.send('get_audio')
def start(self):
if setproctitle:
setproctitle('vkplayer')
self.ipc.start()
self.ipc.broadcast('state_changed', [
self.player.is_downloading, self.player.is_playing,
self.current_title_string
])
self.window = Gtk.Window()
self.window.resize(600, 400)
self.window.set_title('VK audio player')
self.window.set_icon_from_file(os.path.join(DIR, 'icons/icon128.png'))
self.accels = Gtk.AccelGroup()
self.vbox = Gtk.VBox()
self.window.add(self.vbox)
# self.window.modify_bg(Gtk.StateFlags.NORMAL, Gdk.color_parse('#CCCCCC'))
self.header = Gtk.HBox()
# self.header.override_background_color(Gtk.StateFlags.NORMAL | Gtk.StateFlags.ACTIVE | Gtk.StateFlags.INSENSITIVE, color)
self.header_left = Gtk.HBox()
self.header_right = Gtk.VBox()
self.header.pack_start(self.header_left, False, True, 0)
self.header.pack_start(self.header_right, True, True, 0)
self.vbox.pack_start(self.header, False, True, 0)
self.controls = Gtk.HBox(spacing=8)
self.controls.set_border_width(8)
self.header_right.pack_start(self.controls, False, True, 0)
img = Gtk.Image()
img.set_from_pixbuf(
GdkPixbuf.Pixbuf.new_from_file_at_scale(
os.path.join(DIR, 'icons/icon-play-128.png'),
width=48,
height=48,
preserve_aspect_ratio=False))
self.play = Gtk.Button('', image=img)
self.play.set_always_show_image(True)
self.play.set_relief(Gtk.ReliefStyle.NONE)
self.play.connect('clicked', self._on_play_clicked)
self.controls.pack_start(self.play, False, True, 0)
img = Gtk.Image()
img.set_from_pixbuf(
GdkPixbuf.Pixbuf.new_from_file_at_scale(
os.path.join(DIR, 'icons/icon-pause-128.png'),
width=48,
height=48,
preserve_aspect_ratio=False))
self.pause = Gtk.Button('', image=img)
self.pause.set_always_show_image(True)
self.pause.set_relief(Gtk.ReliefStyle.NONE)
self.pause.connect('clicked', self._on_pause_clicked)
self.controls.pack_start(self.pause, False, True, 0)
img = Gtk.Image()
img.set_from_pixbuf(
GdkPixbuf.Pixbuf.new_from_file_at_scale(
os.path.join(DIR, 'icons/icon-shuffle-128.png'),
width=48,
height=48,
preserve_aspect_ratio=False))
self.random = Gtk.Button('', image=img)
self.random.set_always_show_image(True)
self.random.set_relief(Gtk.ReliefStyle.NONE)
self.random.connect('clicked', self._on_random_clicked)
self.controls.pack_start(self.random, False, True, 0)
self.controls.pack_start(Gtk.HSeparator(), False, True, 0)
self.cover = Gtk.Image()
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale(
os.path.join(DIR, 'icons/cover512.jpg'),
width=144,
height=144,
preserve_aspect_ratio=False)
self.cover.set_from_pixbuf(pixbuf)
# self.cover.connect('clicked', self._on_random_clicked)
self.cover.set_size_request(144, 144)
self.header_left.pack_start(self.cover, False, True, 0)
self.seek_panel = Gtk.VBox()
self.controls.pack_start(self.seek_panel, True, True, 0)
self.seek_labels = Gtk.HBox()
self.seek_panel.pack_start(self.seek_labels, True, True, 10)
self.track_title = Gtk.Label('',
halign=Gtk.Align.START,
valign=Gtk.Align.END)
self.track_title.set_use_markup(True)
self.track_title.set_markup(
'<span font="Roboto 24" weight="300">Idle</span>')
self.seek_labels.pack_start(self.track_title, True, True, 0)
self.track_time = Gtk.Label('05:00',
halign=Gtk.Align.END,
valign=Gtk.Align.END)
self.track_time.set_use_markup(True)
self.track_time.set_markup(
'<span font="Roboto 24" weight="100">05:00</span>')
self.seek_labels.pack_start(self.track_time, True, True, 0)
self.seek_bar = Gtk.Scale(orientation=Gtk.Orientation.HORIZONTAL,
adjustment=Gtk.Adjustment(0, 0, 1, 1, 0, 0))
self.seek_bar.set_draw_value(False)
self.seek_bar.set_sensitive(True)
# self.seek_bar.connect('value_changed', lambda *args: self.player.seek(self.seek_bar.get_value()))
self.seek_panel.pack_start(self.seek_bar, True, True, 0)
self.seek_bar.connect('button-press-event', self._on_seek_start)
self.seek_bar.connect('button-release-event', self._on_seek_end)
self.precache_progress = Gtk.ProgressBar()
self.seek_panel.pack_start(self.precache_progress, True, True, 0)
self.volume_scale = Gtk.Scale(orientation=Gtk.Orientation.VERTICAL,
adjustment=Gtk.Adjustment(
1, 0, 1, 0.05, 0.05, 0.05),
valign=Gtk.Align.CENTER)
self.volume_scale.set_inverted(True)
self.volume_scale.connect(
'value_changed', lambda *args: self.player.set_volume(
self.volume_scale.get_value()))
self.volume_scale.set_draw_value(False)
self.volume_scale.set_size_request(-1, 64)
self.volume_scale.set_value(self.last_volume)
self.controls.pack_start(self.volume_scale, False, True, 0)
# self.vbox.pack_start(Gtk.VSeparator(), False, True, 0)
#
self.search_panel = Gtk.HBox(spacing=8)
self.search_panel.set_border_width(8)
self.header_right.pack_start(self.search_panel, False, True, 0)
self.refresh = Gtk.Button('My audio')
self.refresh.connect('clicked', self._on_refresh_clicked)
accelerator = '<Ctrl>m'
key, mod = Gtk.accelerator_parse(accelerator)
self.refresh.add_accelerator('activate', self.accels, key, mod,
Gtk.AccelFlags.VISIBLE)
self.search_panel.pack_start(self.refresh, False, True, 0)
self.search_panel.pack_start(Gtk.HSeparator(), False, True, 0)
self.query = Gtk.Entry(placeholder_text='Search music')
self.query.connect('activate', self._on_search_clicked)
accelerator = '<Ctrl>f'
key, mod = Gtk.accelerator_parse(accelerator)
self.query.add_accelerator('grab-focus', self.accels, key, mod,
Gtk.AccelFlags.VISIBLE)
self.search_panel.pack_start(self.query, True, True, 0)
self.performer_only_cb = Gtk.CheckButton.new_with_label(
'By artist only')
self.search_panel.pack_start(self.performer_only_cb, False, True, 0)
self.search = Gtk.Button('Search')
self.search.connect('clicked', self._on_search_clicked)
self.search_panel.pack_start(self.search, False, True, 0)
#
self.scroll = Gtk.ScrolledWindow()
self.scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.ALWAYS)
self.vbox.pack_start(self.scroll, True, True, 0)
self.spinner = Gtk.Spinner()
self.vbox.pack_start(self.spinner, True, False, 0)
self.playlist = Gtk.TreeView()
self.scroll.add(self.playlist)
self.playlist.connect('row-activated', self._on_row_activated)
self.playlist_store = Gtk.ListStore(str, str, str, str, int, int, int,
bool)
self.playlist.set_model(self.playlist_store)
img = Gtk.Image()
img.set_from_stock(Gtk.STOCK_MEDIA_PLAY, 32)
col = Gtk.TreeViewColumn(
"",
Gtk.CellRendererPixbuf(icon_name='media-playback-start'),
visible=7)
col.set_expand(False)
self.playlist.append_column(col)
col = Gtk.TreeViewColumn("Artist",
Gtk.CellRendererText(
ellipsize=True,
family='Roboto, DejaVu Sans',
weight=500),
text=1)
# col.set_expand(True)
col.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
col.set_fixed_width(250)
self.playlist.append_column(col)
col = Gtk.TreeViewColumn("Title",
Gtk.CellRendererText(
ellipsize=True,
family='Roboto, DejaVu Sans'),
text=0)
col.set_expand(True)
self.playlist.append_column(col)
col = Gtk.TreeViewColumn("Duration", Gtk.CellRendererText(), text=2)
col.set_expand(False)
self.playlist.append_column(col)
self.playlist.connect('button-press-event', self.show_context_menu)
self.vbox.show_all()
self.window.add_accel_group(self.accels)
self.window.maximize()
self.window.show_all()
seek_height = max(self.seek_bar.get_allocation().height,
self.precache_progress.get_allocation().height)
self.seek_bar.set_size_request(-1, seek_height)
self.precache_progress.set_size_request(-1, seek_height)
self.window.connect('delete-event', self._show_or_hide)
get_token(self.window, self._on_token_ready)
self.set_busy(False)
self._update()
self._on_download_finished()
Keybinder.init()
Keybinder.bind('<Ctrl><Alt>Return', self._on_random_clicked)
Keybinder.bind(
'<Ctrl><Alt>space', lambda *args:
(self._on_pause_clicked
if self.player.is_playing else self._on_play_clicked)())
Keybinder.bind('XF86AudioPlay', self._on_play_clicked)
Keybinder.bind('XF86AudioPause', self._on_pause_clicked)
Keybinder.bind('XF86AudioNext', self._on_random_clicked)
Keybinder.bind('<Ctrl><Alt>Down', lambda *args: self.play_next())
Keybinder.bind('<Ctrl><Alt>Up', lambda *args: self.play_prev())
self.status_icon = Gtk.StatusIcon()
self.status_icon.set_from_file(os.path.join(DIR, 'icons/play.png'))
self.status_icon.connect('popup-menu', self._on_popup_menu)
self.status_icon.connect('activate', self._show_or_hide)
Gtk.main()
self.player.stop()
def __init__(self, parent):
""" Set up all menu items and connect to the various functions.
:arg parent: The parent Gtk window.
"""
logging.debug("New Menu instance created!")
# First let's call the constructor of the super class (Gtk.MenuBar)
Gtk.MenuBar.__init__(self)
logging.debug("Setting up the menu bar...")
agrp = Gtk.AccelGroup()
parent.add_accel_group(agrp)
self.items = {}
# LOGBOOK ######
mitem_logbook = Gtk.MenuItem("Logbook")
self.append(mitem_logbook)
subm_logbook = Gtk.Menu()
mitem_logbook.set_submenu(subm_logbook)
# Create logbook
mitem_connect = Gtk.ImageMenuItem("Create a New Logbook...")
icon = Gtk.Image()
icon.set_from_stock(Gtk.STOCK_NEW, Gtk.IconSize.MENU)
mitem_connect.set_image(icon)
mitem_connect.connect("activate", parent.logbook.new)
subm_logbook.append(mitem_connect)
self.items["NEW_LOGBOOK"] = mitem_connect
# Open logbook
mitem_connect = Gtk.ImageMenuItem("Open an Existing Logbook...")
icon = Gtk.Image()
icon.set_from_stock(Gtk.STOCK_OPEN, Gtk.IconSize.MENU)
mitem_connect.set_image(icon)
mitem_connect.connect("activate", parent.logbook.open)
key, mod = Gtk.accelerator_parse("<Control>O")
mitem_connect.add_accelerator("activate", agrp, key, mod, Gtk.AccelFlags.VISIBLE)
subm_logbook.append(mitem_connect)
self.items["OPEN_LOGBOOK"] = mitem_connect
# Close logbook
mitem_disconnect = Gtk.ImageMenuItem("Close Logbook")
mitem_disconnect.connect("activate", parent.logbook.close)
icon = Gtk.Image()
icon.set_from_stock(Gtk.STOCK_CLOSE, Gtk.IconSize.MENU)
mitem_disconnect.set_image(icon)
key, mod = Gtk.accelerator_parse("<Control>W")
mitem_disconnect.add_accelerator("activate", agrp, key, mod, Gtk.AccelFlags.VISIBLE)
subm_logbook.append(mitem_disconnect)
self.items["CLOSE_LOGBOOK"] = mitem_disconnect
subm_logbook.append(Gtk.SeparatorMenuItem())
# New log
mitem_new = Gtk.ImageMenuItem("New Log")
icon = Gtk.Image()
icon.set_from_stock(Gtk.STOCK_ADD, Gtk.IconSize.MENU)
mitem_new.set_image(icon)
mitem_new.connect("activate", parent.logbook.new_log)
key, mod = Gtk.accelerator_parse("<Control>N")
mitem_new.add_accelerator("activate", agrp, key, mod, Gtk.AccelFlags.VISIBLE)
subm_logbook.append(mitem_new)
self.items["NEW_LOG"] = mitem_new
# Delete the current log
mitem_delete = Gtk.ImageMenuItem("Delete Selected Log")
icon = Gtk.Image()
icon.set_from_stock(Gtk.STOCK_DELETE, Gtk.IconSize.MENU)
mitem_delete.set_image(icon)
mitem_delete.connect("activate", parent.logbook.delete_log)
subm_logbook.append(mitem_delete)
self.items["DELETE_LOG"] = mitem_delete
# Rename the current log
mitem_rename = Gtk.ImageMenuItem("Rename Selected Log")
icon = Gtk.Image()
icon.set_from_stock(Gtk.STOCK_EDIT, Gtk.IconSize.MENU)
mitem_rename.set_image(icon)
mitem_rename.connect("activate", parent.logbook.rename_log)
subm_logbook.append(mitem_rename)
self.items["RENAME_LOG"] = mitem_rename
subm_logbook.append(Gtk.SeparatorMenuItem())
# Import log
mitem_import = Gtk.ImageMenuItem("Import Log")
icon = Gtk.Image()
icon.set_from_stock(Gtk.STOCK_GO_FORWARD, Gtk.IconSize.MENU)
mitem_import.set_image(icon)
mitem_import.connect("activate", parent.logbook.import_log)
subm_logbook.append(mitem_import)
self.items["IMPORT_LOG"] = mitem_import
# Export the current log
mitem_export = Gtk.ImageMenuItem("Export Log")
icon = Gtk.Image()
icon.set_from_stock(Gtk.STOCK_GO_BACK, Gtk.IconSize.MENU)
mitem_export.set_image(icon)
mitem_export.connect("activate", parent.logbook.export_log)
subm_logbook.append(mitem_export)
self.items["EXPORT_LOG"] = mitem_export
subm_logbook.append(Gtk.SeparatorMenuItem())
# Print log
mitem_print = Gtk.ImageMenuItem("Print Log")
icon = Gtk.Image()
icon.set_from_stock(Gtk.STOCK_PRINT, Gtk.IconSize.MENU)
mitem_print.set_image(icon)
mitem_print.connect("activate", parent.logbook.print_log)
key, mod = Gtk.accelerator_parse("<Control>P")
mitem_print.add_accelerator("activate", agrp, key, mod, Gtk.AccelFlags.VISIBLE)
subm_logbook.append(mitem_print)
self.items["PRINT_LOG"] = mitem_print
subm_logbook.append(Gtk.SeparatorMenuItem())
# Quit
mitem_quit = Gtk.ImageMenuItem("Quit")
icon = Gtk.Image()
icon.set_from_stock(Gtk.STOCK_QUIT, Gtk.IconSize.MENU)
mitem_quit.set_image(icon)
mitem_quit.connect("activate", Gtk.main_quit)
key, mod = Gtk.accelerator_parse("<Control>Q")
mitem_quit.add_accelerator("activate", agrp, key, mod, Gtk.AccelFlags.VISIBLE)
subm_logbook.append(mitem_quit)
self.items["QUIT"] = mitem_quit
# RECORDS ######
mitem_records = Gtk.MenuItem("Records")
self.append(mitem_records)
subm_records = Gtk.Menu()
mitem_records.set_submenu(subm_records)
mitem_addrecord = Gtk.ImageMenuItem("Add Record...")
icon = Gtk.Image()
icon.set_from_stock(Gtk.STOCK_ADD, Gtk.IconSize.MENU)
mitem_addrecord.set_image(icon)
mitem_addrecord.connect("activate", parent.logbook.add_record_callback)
key, mod = Gtk.accelerator_parse("<Control>R")
mitem_addrecord.add_accelerator("activate", agrp, key, mod, Gtk.AccelFlags.VISIBLE)
subm_records.append(mitem_addrecord)
self.items["ADD_RECORD"] = mitem_addrecord
mitem_editrecord = Gtk.ImageMenuItem("Edit Selected Record...")
icon = Gtk.Image()
icon.set_from_stock(Gtk.STOCK_EDIT, Gtk.IconSize.MENU)
mitem_editrecord.set_image(icon)
mitem_editrecord.connect("activate", parent.logbook.edit_record_callback, None, None)
key, mod = Gtk.accelerator_parse("<Control>E")
mitem_editrecord.add_accelerator("activate", agrp, key, mod, Gtk.AccelFlags.VISIBLE)
subm_records.append(mitem_editrecord)
self.items["EDIT_RECORD"] = mitem_editrecord
mitem_deleterecord = Gtk.ImageMenuItem("Delete Selected Record...")
icon = Gtk.Image()
icon.set_from_stock(Gtk.STOCK_DELETE, Gtk.IconSize.MENU)
mitem_deleterecord.set_image(icon)
mitem_deleterecord.connect("activate", parent.logbook.delete_record_callback)
key, mod = Gtk.accelerator_parse("Delete")
mitem_deleterecord.add_accelerator("activate", agrp, key, mod, Gtk.AccelFlags.VISIBLE)
subm_records.append(mitem_deleterecord)
self.items["DELETE_RECORD"] = mitem_deleterecord
mitem_removeduplicates = Gtk.ImageMenuItem("Remove Duplicate Records")
icon = Gtk.Image()
icon.set_from_stock(Gtk.STOCK_FIND_AND_REPLACE, Gtk.IconSize.MENU)
mitem_removeduplicates.set_image(icon)
mitem_removeduplicates.connect("activate", parent.logbook.remove_duplicates_callback)
subm_records.append(mitem_removeduplicates)
self.items["REMOVE_DUPLICATES"] = mitem_removeduplicates
# VIEW ######
mitem_view = Gtk.MenuItem("View")
self.append(mitem_view)
subm_view = Gtk.Menu()
mitem_view.set_submenu(subm_view)
mitem_toolbox = Gtk.CheckMenuItem("Toolbox")
config = configparser.ConfigParser()
have_config = (config.read(os.path.expanduser('~/.config/pyqso/preferences.ini')) != [])
(section, option) = ("general", "show_toolbox")
if(have_config and config.has_option(section, option)):
mitem_toolbox.set_active(config.get(section, option) == "True")
else:
mitem_toolbox.set_active(False) # Don't show the toolbox by default
mitem_toolbox.connect("activate", parent.toolbox.toggle_visible_callback)
subm_view.append(mitem_toolbox)
self.items["TOOLBOX"] = mitem_toolbox
mitem_preferences = Gtk.ImageMenuItem("Preferences...")
icon = Gtk.Image()
icon.set_from_stock(Gtk.STOCK_PREFERENCES, Gtk.IconSize.MENU)
mitem_preferences.set_image(icon)
mitem_preferences.connect("activate", parent.show_preferences)
subm_view.append(mitem_preferences)
self.items["PREFERENCES"] = mitem_preferences
# HELP ######
mitem_help = Gtk.MenuItem("Help")
self.append(mitem_help)
subm_help = Gtk.Menu()
mitem_help.set_submenu(subm_help)
# About
mitem_about = Gtk.ImageMenuItem("About PyQSO")
icon = Gtk.Image()
icon.set_from_stock(Gtk.STOCK_ABOUT, Gtk.IconSize.MENU)
mitem_about.set_image(icon)
mitem_about.connect("activate", parent.show_about)
subm_help.append(mitem_about)
self.set_logbook_item_sensitive(True)
self.set_log_items_sensitive(False)
self.set_record_items_sensitive(False)
logging.debug("Menu bar ready!")
return
def ReorderKeyString(self, accel):
key, mods = Gtk.accelerator_parse(accel)
return GetAcceleratorName(key, mods)
def RunKeySelector(self, widget):
def ShowHideBox(button, box, dialog):
if button.get_active():
box.show()
else:
box.hide()
dialog.resize(1, 1)
def HandleGrabberChanged(grabber, key, mods, label, selector):
new = GetAcceleratorName(key, mods)
mods = ""
for mod in KeyModifier:
if "%s_L" % mod in new:
new = new.replace("%s_L" % mod, "<%s>" % mod)
if "%s_R" % mod in new:
new = new.replace("%s_R" % mod, "<%s>" % mod)
if "<%s>" % mod in new:
mods += "%s|" % mod
mods.rstrip("|")
label.set_text(self.GetLabelText(new))
selector.current = mods
def HandleModifierAdded(selector, modifier, label):
current = label.get_text()
if current == _("Disabled"):
current = "<%s>" % modifier
else:
current = ("<%s>" % modifier) + current
label.set_text(self.ReorderKeyString(current))
def HandleModifierRemoved(selector, modifier, label):
current = label.get_text()
if "<%s>" % modifier in current:
new = current.replace("<%s>" % modifier, "")
elif "%s_L" % modifier in current:
new = current.replace("%s_L" % modifier, "")
elif "%s_R" % modifier in current:
new = current.replace("%s_R" % modifier, "")
label.set_text(self.GetLabelText(new))
dlg = Gtk.Dialog(title=_("Edit %s") % self.Setting.ShortDesc)
dlg.set_position(Gtk.WindowPosition.CENTER_ALWAYS)
dlg.set_transient_for(self.Widget.get_toplevel())
dlg.set_icon(self.Widget.get_toplevel().get_icon())
dlg.set_modal(True)
dlg.add_button(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL)
dlg.add_button(Gtk.STOCK_OK, Gtk.ResponseType.OK).grab_default()
dlg.set_default_response(Gtk.ResponseType.OK)
mainBox = Gtk.VBox()
alignment = Gtk.Alignment()
alignment.set_padding(10, 10, 10, 10)
alignment.add(mainBox)
dlg.vbox.pack_start(alignment, True, True, 0)
checkButton = Gtk.CheckButton(label=_("Enabled"))
active = len (self.current) \
and self.current.lower () not in ("disabled", "none")
checkButton.set_active(active)
checkButton.set_tooltip_text(self.Setting.LongDesc)
mainBox.pack_start(checkButton, True, True, 0)
box = Gtk.VBox()
checkButton.connect("toggled", ShowHideBox, box, dlg)
mainBox.pack_start(box, True, True, 0)
currentMods = ""
for mod in KeyModifier:
if "<%s>" % mod in self.current:
currentMods += "%s|" % mod
currentMods.rstrip("|")
modifierSelector = ModifierSelector(currentMods)
modifierSelector.set_tooltip_text(self.Setting.LongDesc)
alignment = Gtk.Alignment(xalign=0.5)
alignment.add(modifierSelector)
box.pack_start(alignment, True, True, 0)
key, mods = Gtk.accelerator_parse(self.current)
grabber = KeyGrabber(key=key,
mods=mods,
label=_("Grab key combination"))
grabber.set_tooltip_text(self.Setting.LongDesc)
box.pack_start(grabber, True, True, 0)
label = Gtk.Label(label=self.current)
label.set_tooltip_text(self.Setting.LongDesc)
alignment = Gtk.Alignment(xalign=0.5, yalign=0.5)
alignment.set_padding(15, 0, 0, 0)
alignment.add(label)
box.pack_start(alignment, True, True, 0)
modifierSelector.connect("added", HandleModifierAdded, label)
modifierSelector.connect("removed", HandleModifierRemoved, label)
grabber.connect("changed", HandleGrabberChanged, label,
modifierSelector)
grabber.connect("current-changed", HandleGrabberChanged, label,
modifierSelector)
dlg.vbox.show_all()
ShowHideBox(checkButton, box, dlg)
ret = dlg.run()
dlg.destroy()
if ret != Gtk.ResponseType.OK:
return
if not checkButton.get_active():
self.BindingEdited("Disabled")
return
new = label.get_text()
new = self.ReorderKeyString(new)
self.BindingEdited(new)
def _make_listboxrow_doc_widget(self, doc, rowbox, selected=False):
globalbox = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 10)
# thumbnail
if doc.docid in self.model['thumbnails']:
thumbnail = self.model['thumbnails'][doc.docid]
thumbnail = Gtk.Image.new_from_pixbuf(thumbnail)
else:
thumbnail = Gtk.Image.new_from_pixbuf(self.default_thumbnail)
thumbnail.set_size_request(
JobDocThumbnailer.SMALL_THUMBNAIL_WIDTH,
JobDocThumbnailer.SMALL_THUMBNAIL_HEIGHT)
globalbox.add(thumbnail)
internalbox = Gtk.Box.new(Gtk.Orientation.VERTICAL, 3)
globalbox.add(internalbox)
# doc name
docname = Gtk.Label.new(doc.name)
docname.set_justify(Gtk.Justification.LEFT)
docname.set_halign(Gtk.Align.START)
internalbox.add(docname)
# doc labels
labels = LabelWidget(doc.labels)
labels.set_size_request(170, 10)
internalbox.add(labels)
# buttons
button_box = Gtk.Box.new(Gtk.Orientation.VERTICAL, 5)
button_box.set_size_request(20, 40)
button_box.set_homogeneous(True)
globalbox.pack_start(button_box, False, True, 0)
edit_button = Gtk.Button.new_from_icon_name(
"document-properties-symbolic", Gtk.IconSize.MENU)
edit_button.set_relief(Gtk.ReliefStyle.NONE)
edit_button.connect(
"clicked", lambda _: GLib.idle_add(self.__main_win.switch_leftpane,
'doc_properties'))
# shortcut
(key, mod) = Gtk.accelerator_parse('<Primary>e')
edit_button.add_accelerator('clicked', self.accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
button_box.add(edit_button)
delete_button = Gtk.Button.new_from_icon_name("edit-delete-symbolic",
Gtk.IconSize.MENU)
delete_button.set_relief(Gtk.ReliefStyle.NONE)
delete_button.connect(
"clicked",
lambda _: GLib.idle_add(ActionDeleteDoc(self.__main_win, doc).do))
button_box.add(delete_button)
for child in rowbox.get_children():
rowbox.remove(child)
rowbox.add(globalbox)
rowbox.show_all()
if not selected:
delete_button.set_visible(False)
edit_button.set_visible(False)
def bind_accelerator(accelerators, widget, accelerator, signal='clicked'):
key, mod = Gtk.accelerator_parse(accelerator)
widget.add_accelerator(signal, accelerators, key, mod, Gtk.AccelFlags.VISIBLE)
def valid_for_item(self, leaf):
text = leaf.object
keys, mods = Gtk.accelerator_parse(text)
return keys
def bindHotkey(accelerators, widget, accelerator, signal='clicked'):
'''thanks to ThorSummoner at https://askubuntu.com/a/722649'''
key, mod = Gtk.accelerator_parse(accelerator)
widget.add_accelerator(signal, accelerators, key, mod,
Gtk.AccelFlags.VISIBLE)
def __init__(self):
super(PyApp, self).__init__()
self.set_title('Menu')
self.set_position(Gtk.WindowPosition.CENTER_ALWAYS)
self.set_size_request(250, 150)
accel_group = Gtk.AccelGroup()
self.add_accel_group(accel_group)
vbox = Gtk.VBox()
menubar = Gtk.MenuBar()
vbox.pack_start(menubar, False, False, 0)
self.label = Gtk.Label(label='Activa un item del menu')
vbox.pack_start(self.label, True, True, 0)
menu_file = Gtk.Menu()
item_file = Gtk.MenuItem.new_with_mnemonic('_Archivo')
item_file.set_submenu(menu_file)
menubar.append(item_file)
item_new = Gtk.MenuItem.new_with_mnemonic('_Nuevo')
key, mod = Gtk.accelerator_parse('<Ctrl>N')
item_new.add_accelerator('activate', accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
item_new.connect('activate', self._activate_cb, 'Nuevo')
menu_file.append(item_new)
item_open = Gtk.MenuItem.new_with_mnemonic('_Abrir')
key, mod = Gtk.accelerator_parse('<Ctrl>O')
item_open.add_accelerator('activate', accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
item_open.connect('activate', self._activate_cb, 'Abrir')
menu_file.append(item_open)
menu_recents = Gtk.Menu()
item_recents = Gtk.MenuItem.new_with_mnemonic('Abrir _reciente')
item_recents.set_submenu(menu_recents)
menu_file.append(item_recents)
for recent_file in range(1, 6):
item_recent = Gtk.MenuItem.new_with_mnemonic(
'_%d: Archivo reciente %d' % (recent_file, recent_file))
item_recent.connect('activate', self._activate_cb,
'Archivo reciente %d' % recent_file)
menu_recents.append(item_recent)
separator = Gtk.SeparatorMenuItem()
menu_file.append(separator)
item_exit = Gtk.MenuItem.new_with_mnemonic('_Salir')
key, mod = Gtk.accelerator_parse('<Ctrl>Q')
item_exit.add_accelerator('activate', accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
item_exit.connect('activate', self._activate_cb, 'Salir')
menu_file.append(item_exit)
menu_edit = Gtk.Menu()
item_edit = Gtk.MenuItem.new_with_mnemonic('_Editar')
item_edit.set_submenu(menu_edit)
menubar.append(item_edit)
item_undo = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_UNDO, None)
key, mod = Gtk.accelerator_parse('<Ctrl>Z')
item_undo.add_accelerator('activate', accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
item_undo.connect('activate', self._activate_cb, 'Deshacer')
menu_edit.append(item_undo)
item_redo = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_REDO, None)
key, mod = Gtk.accelerator_parse('<Ctrl><Shift>Z')
item_redo.add_accelerator('activate', accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
item_redo.connect('activate', self._activate_cb, 'Reahacer')
menu_edit.append(item_redo)
separator = Gtk.SeparatorMenuItem()
menu_edit.append(separator)
item_copy = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_COPY, None)
key, mod = Gtk.accelerator_parse('<Ctrl>C')
item_copy.add_accelerator('activate', accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
item_copy.connect('activate', self._activate_cb, 'Copiar')
menu_edit.append(item_copy)
item_cut = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_CUT, None)
key, mod = Gtk.accelerator_parse('<Ctrl>X')
item_cut.add_accelerator('activate', accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
item_cut.connect('activate', self._activate_cb, 'Cortar')
menu_edit.append(item_cut)
item_paste = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_PASTE, None)
key, mod = Gtk.accelerator_parse('<Ctrl>V')
item_paste.add_accelerator('activate', accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
item_paste.connect('activate', self._activate_cb, 'Pegar')
menu_edit.append(item_paste)
separator = Gtk.SeparatorMenuItem()
menu_edit.append(separator)
label = 'Pagina vertical'
item_vertical = Gtk.RadioMenuItem(label=label)
item_vertical.set_active(True)
item_vertical.connect('toggled', self._toggled_cb, label)
menu_edit.append(item_vertical)
label = 'Pagina horizontal'
item_horizontal = Gtk.RadioMenuItem.new_with_label((item_vertical, ),
label)
item_horizontal.connect('toggled', self._toggled_cb, label)
menu_edit.append(item_horizontal)
menu_view = Gtk.Menu()
item_view = Gtk.MenuItem.new_with_mnemonic('_Ver')
item_view.set_submenu(menu_view)
menubar.append(item_view)
item_hides = Gtk.CheckMenuItem.new_with_mnemonic('_Archivos ocultos')
key, mod = Gtk.accelerator_parse('<Ctrl>H')
item_hides.add_accelerator('activate', accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
item_hides.connect('toggled', self._toggled_cb, 'Archivos ocultos',
True)
menu_view.append(item_hides)
menu_help = Gtk.Menu()
item_help = Gtk.MenuItem(label='Ayuda')
item_help.set_submenu(menu_help)
menubar.append(item_help)
item_about = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_ABOUT, None)
item_about.add_accelerator('activate', accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
item_about.connect('activate', self._activate_cb, 'Acerca de')
menu_help.append(item_about)
self.add(vbox)
self.show_all()
self.connect('destroy', Gtk.main_quit)
def show_info(device: Device, parent: Gtk.Window) -> None:
def format_boolean(x: bool) -> str:
return _('yes') if x else _('no')
def format_rssi(rssi: int) -> str:
if rssi in [0x99, 0x7f]:
return f'invalid (0x{rssi:02x})'
else:
return f'{rssi} dBm (0x{rssi:02x})'
def format_uuids(uuids: Iterable[str]) -> str:
return "\n".join(
[uuid + ' ' + ServiceUUID(uuid).name for uuid in uuids])
store = Gtk.ListStore(str, str)
view = Gtk.TreeView(model=store, headers_visible=False)
view_selection = view.get_selection()
view_selection.set_mode(Gtk.SelectionMode.MULTIPLE)
def on_accel_activated(_group: Gtk.AccelGroup, _dialog: GObject, key: int,
_modifier: Gdk.ModifierType) -> bool:
if key != 99:
logging.warning(f"Ignoring key {key}")
return False
store, paths = view_selection.get_selected_rows()
text = []
for path in paths:
row = store[path]
text.append(row[-1])
logging.info("\n".join(text))
clipboard.set_text("\n".join(text), -1)
return False
clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
dialog = Gtk.Dialog(icon_name="blueman", title="blueman")
dialog.set_transient_for(parent)
dialog_content_area = dialog.get_content_area()
label = Gtk.Label()
label.set_markup(
_("<big>Select row(s) and use <i>Control + C</i> to copy</big>"))
label.show()
dialog_content_area.pack_start(label, True, False, 0)
accelgroup = Gtk.AccelGroup()
dialog.add_accel_group(accelgroup)
key, mod = Gtk.accelerator_parse("<Control>C")
accelgroup.connect(key, mod, Gtk.AccelFlags.MASK, on_accel_activated)
for i in range(2):
column = Gtk.TreeViewColumn()
cell = Gtk.CellRendererText()
column.pack_start(cell, True)
column.add_attribute(cell, 'text', i)
view.append_column(column)
dialog_content_area.pack_start(view, True, False, 0)
view.show_all()
properties: Iterable[Tuple[str, Optional[Callable[[Any], str]]]] = (
('Address', None),
('AddressType', None),
('Name', None),
('Alias', None),
('Class', lambda x: f"0x{x:06x}"),
('Appearance', lambda x: f"0x{x:04x}"),
('Icon', None),
('Paired', format_boolean),
('Trusted', format_boolean),
('Blocked', format_boolean),
('LegacyPairing', format_boolean),
('RSSI', format_rssi),
('Connected', format_boolean),
('UUIDs', format_uuids),
('Modalias', None),
('Adapter', None),
# FIXME below 3 we need some sample data to decode and display properly
('ManufacturerData', str),
('ServiceData', str),
('AdvertisingData', str))
for name, func in properties:
try:
if func is None:
store.append((name, device.get(name)))
else:
store.append((name, func(device.get(name))))
except BluezDBusException:
logging.info(f"Could not get property {name}")
pass
except ValueError:
logging.info(f"Could not add property {name}")
pass
dialog.run()
dialog.destroy()
def _create_accel_group(self):
self._accel_group = Gtk.AccelGroup()
shortcut = self._gsettings.get_string(GSETTINGS_KEYBINDINGS)
key, mod = Gtk.accelerator_parse(shortcut)
self._accel_group.connect(key, mod, Gtk.AccelFlags.VISIBLE,
self._open_terminal)
def __init__(self, Prototype, values, filename, title):
if self.is_not_unique():
return
super(JSONBasedEditor, self).__init__()
self.Prototype = Prototype
self.current = None
self.filename = filename
self.name = Prototype.NAME or Prototype.__name__
self.input_entries = {}
self.set_border_width(12)
self.set_title(title)
self.set_default_size(self._WIDTH, self._HEIGHT)
self.add(Gtk.HBox(spacing=6))
self.get_child().set_homogeneous(True)
self.accels = Gtk.AccelGroup()
# Set up the model for this widget
self.model = Gtk.ListStore(object)
self._fill_values(values)
# The browser for existing data
self.view = view = RCMHintedTreeView(model=self.model)
view.set_headers_visible(False)
view.set_reorderable(True)
view.set_rules_hint(True)
render = Gtk.CellRendererText()
render.set_padding(3, 6)
render.props.ellipsize = Pango.EllipsizeMode.END
column = Gtk.TreeViewColumn("", render)
column.set_cell_data_func(render, self.__cdf)
view.append_column(column)
sw = Gtk.ScrolledWindow()
sw.set_shadow_type(Gtk.ShadowType.IN)
sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
sw.add(view)
self.get_child().pack_start(sw, True, True, 0)
vbox = Gtk.VBox(spacing=6)
# Input for new ones.
frame = self.__build_input_frame()
vbox.pack_start(frame, False, True, 0)
# Add context menu
menu = Gtk.Menu()
rem = MenuItem(_("_Remove"), Icons.LIST_REMOVE)
keyval, mod = Gtk.accelerator_parse("Delete")
rem.add_accelerator('activate', self.accels, keyval, mod,
Gtk.AccelFlags.VISIBLE)
connect_obj(rem, 'activate', self.__remove, view)
menu.append(rem)
menu.show_all()
view.connect('popup-menu', self.__popup, menu)
view.connect('key-press-event', self.__view_key_press)
connect_obj(self, 'destroy', Gtk.Menu.destroy, menu)
# New and Close buttons
bbox = Gtk.HButtonBox()
self.remove_but = Button(_("_Remove"), Icons.LIST_REMOVE)
self.remove_but.set_sensitive(False)
self.new_but = Button(_("_New"), Icons.DOCUMENT_NEW)
self.new_but.connect('clicked', self._new_item)
bbox.pack_start(self.new_but, True, True, 0)
close = Button(_("_Close"), Icons.WINDOW_CLOSE)
connect_obj(close, 'clicked', qltk.Window.destroy, self)
bbox.pack_start(close, True, True, 0)
vbox.pack_end(bbox, False, True, 0)
self.get_child().pack_start(vbox, True, True, 0)
# Initialise
self.selection = view.get_selection()
self.selection.connect('changed', self.__select)
self.connect('destroy', self.__finish)
self.get_child().show_all()
def run(self):
self.window = Gtk.Window(Gtk.WindowType.TOPLEVEL)
self.window.set_title("Melange")
self.window.set_icon_name("system-search")
self.window.set_default_size(1000, 400)
self.window.set_position(Gtk.WindowPosition.MOUSE)
# I can't think of a way to reliably detect if the window
# is active to determine if we need to present or hide
# in show(). Since the window briefly loses focus during
# shortcut press we'd be unable to detect it at that time.
# Keeping the window on top ensures the window is never
# obscured so we can just hide if visible.
self.window.set_keep_above(True)
self.window.connect("delete_event", self.onDelete)
self.window.connect("key-press-event", self.onKeyPress)
self._minimized = False
self.window.connect("window-state-event", self.onWindowState)
numRows = 3
numColumns = 6
table = Gtk.Table(numRows, numColumns, False)
table.set_margin_start(6)
table.set_margin_end(6)
table.set_margin_top(6)
table.set_margin_bottom(6)
self.window.add(table)
self.notebook = Gtk.Notebook()
self.notebook.set_tab_pos(Gtk.PositionType.BOTTOM)
self.notebook.show()
self.notebook.set_show_border(True)
self.notebook.set_show_tabs(True)
label = Gtk.Label("Melange")
label.set_markup("<u>Melange - Cinnamon Debugger</u> ")
label.show()
self.notebook.set_action_widget(label, Gtk.PackType.END)
self.pages = {}
self.customPages = {}
self.createPage("Results", "results")
self.createPage("Inspect", "inspect")
# self.createPage("Memory", "memory") - TODO: re-implement get_memory_info from cjs
self.createPage("Windows", "windows")
self.createPage("Extensions", "extensions")
self.createPage("Log", "log")
table.attach(self.notebook, 0, numColumns, 0, 1)
column = 0
pickerButton = pageutils.ImageButton("color-select-symbolic")
pickerButton.set_tooltip_text("Select an actor to inspect")
pickerButton.connect("clicked", self.onPickerClicked)
table.attach(pickerButton, column, column+1, 1, 2, 0, 0, 2)
column += 1
fullGc = pageutils.ImageButton("user-trash-full-symbolic")
fullGc.set_tooltip_text("Invoke garbage collection")
# ignore signal arg
fullGc.connect ('clicked', lambda source: lookingGlassProxy.FullGc())
table.attach(fullGc, column, column+1, 1, 2, 0, 0, 2)
column += 1
self.commandline = CommandLine()
self.commandline.set_tooltip_text("Evaluate javascript")
table.attach(self.commandline, column, column+1, 1, 2, Gtk.AttachOptions.EXPAND|Gtk.AttachOptions.FILL, 0, 3, 2)
column += 1
self.statusLabel = Gtk.Label("Status")
self.statusLabel.set_markup(" <span foreground='red'>[ Cinnamon is OFFLINE! ]</span> ")
self.statusLabel.set_tooltip_text("The connection to cinnamon is broken")
self.statusLabel.set_no_show_all(True)
table.attach(self.statusLabel, column, column+1, 1, 2, 0, 0, 1)
column += 1
box = Gtk.HBox()
settings = Gio.Settings("org.cinnamon.desktop.keybindings")
arr = settings.get_strv("looking-glass-keybinding")
if len(arr) > 0:
# only the first mapped keybinding
[accelKey, mask] = Gtk.accelerator_parse(arr[0])
if accelKey == 0 and mask == 0:
# failed to parse, fallback to plain accel string
label = Gtk.Label(arr[0])
else:
label = Gtk.Label(Gtk.accelerator_get_label(accelKey, mask))
label.set_tooltip_text("Toggle shortcut")
box.pack_start(label, False, False, 3)
actionButton = self.createActionButton()
box.pack_start(actionButton, False, False, 3)
table.attach(box, column, column+1, 1, 2, 0, 0, 1)
self.activatePage("results")
self.statusLabel.hide()
self.window.set_focus(self.commandline)
def __init__(self, base):
self.base = base
self.has_gui = self.base.has_gui # pour appeler display_info
self.base.GUI = self
self.root = Gtk.Window(Gtk.WindowType.TOPLEVEL)
self.root.set_title(self.base.TITLE)
self.root.set_size_request(800, 600)
self.root.set_border_width(5)
#self.root.set_has_frame(True) ## f**k the resize
self.root.connect("destroy", self.destroy_cb)
self.root.connect("show", self.show_window_cb)
self.header_bar = Gtk.HeaderBar()
self.header_bar.set_title(self.base.TITLE)
self.header_bar.set_show_close_button (True)
# Quitter par Escape
self.accelgroup = Gtk.AccelGroup()
key, modifier = Gtk.accelerator_parse('Escape')
self.accelgroup.connect(key, modifier,
Gtk.AccelFlags.VISIBLE,
self.destroy_cb)
self.root.add_accel_group(self.accelgroup)
# Création des modèles et des treeview
self.StoreEmissions = EmissionsModel()
self.DisplayEmissions = DisplayEmissionsModel(self)
self.StoreDownloads = DownloadsModel()
self.DisplayDownloads = DisplayDownloadsModel(self)
self.StoreInfos = InfosModel()
self.DisplayInfos = DisplayInfosModel()
self.main_paned = Gtk.Paned.new(Gtk.Orientation.VERTICAL)
self.main_paned.set_position( int(0.75* self.root.get_size()[1]) )
# Top Pane
self.vpaned = Gtk.Paned.new(Gtk.Orientation.VERTICAL)
self.vpaned.set_position( int(0.5* self.root.get_size()[1]) )
# top box = view_emi + command bar
self.top_box = Gtk.VBox(homogeneous = False, spacing = 0)
# cmd_box = controls
self.cmd_box = Gtk.HBox(homogeneous = False, spacing = 0)
# pour avoir les deux boutons DL Cancel avec la même taille
self.btn_box = Gtk.HBox(homogeneous = True, spacing = 5)
#self.btn_download.set_use_stock(False)
##Gtk.stock_add([(Gtk.STOCK_GO_DOWN, "_Télécharger", 0, 0, "")])
#Gtk.stock_add([Gtk.STOCK_GO_DOWN, "_Télécharger"])
#self.btn_download.new_from_stock( Gtk.STOCK_GO_DOWN) # = Gtk.Button("_Open")
#self.btn_download.set_label('Gtk.STOCK_GO_DOWN')
#self.btn_download = Gtk.Button( stock = Gtk.STOCK_GO_DOWN, use_underline=True)
#self.btn_download = Gtk.Button("_Open", stock=Gtk.STOCK_SAVE, use_stock=False, use_underline = True)
box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
# image and label are defined elsewhere
box.add(Gtk.Image.new_from_icon_name(Gtk.STOCK_SAVE, Gtk.IconSize.BUTTON))
box.add(Gtk.Label("_Télécharger", use_underline=True))
self.btn_download = Gtk.Button(use_underline=True, always_show_image=True)
self.btn_download.add(box)
#button.show_all()
#self.btn_download = Gtk.Button("_Save", use_stock=True, use_underline = True)
self.btn_download.set_sensitive(False)
self.btn_download.connect("clicked", self.download_cb)
self.btn_cancel = Gtk.Button(stock = Gtk.STOCK_CANCEL, use_underline = True)
self.btn_cancel.set_sensitive(False)
self.btn_cancel.connect("clicked", self.cancel_download_cb)
self.btn_quit = Gtk.Button( stock=Gtk.STOCK_QUIT, use_underline=True)
self.btn_quit.connect("clicked", self.destroy_cb, self.root )
# scrolled window pour émissions
self.scrol_win_emi = Gtk.ScrolledWindow()
self.scrol_win_emi.set_policy(Gtk.PolicyType.AUTOMATIC,Gtk.PolicyType.AUTOMATIC)
self.scrol_win_emi.set_shadow_type(Gtk.ShadowType.IN)
# scrolled window pour downloads
self.scrol_win_dl = Gtk.ScrolledWindow()
self.scrol_win_dl.set_policy(Gtk.PolicyType.AUTOMATIC,Gtk.PolicyType.AUTOMATIC)
self.scrol_win_dl.set_shadow_type(Gtk.ShadowType.IN)
# scrolled window pour informations
self.scrol_win_info = Gtk.ScrolledWindow()
self.scrol_win_info.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
self.scrol_win_info.set_shadow_type(Gtk.ShadowType.IN)
self.scrol_win_info.set_min_content_height(125)
# Get the model and attach it to the view
self.mdl_emi = self.StoreEmissions.get_model()
self.view_emi = self.DisplayEmissions.make_view( self.mdl_emi )
self.mdl_dl = self.StoreDownloads.get_model()
self.view_dl = self.DisplayDownloads.make_view(self.mdl_dl)
self.view_dl.connect('size-allocate', self.view_info_changed)
self.mdl_dl.connect('row-inserted', self.model_dl_inserted)
self.mdl_dl.connect('row-deleted', self.model_dl_deleted)
self.mdl_info = self.StoreInfos.get_model()
self.view_info = self.DisplayInfos.make_view( self.mdl_info )
self.view_info.connect('size-allocate', self.view_info_changed)
# packing
self.scrol_win_emi.add(self.view_emi)
self.scrol_win_dl.add(self.view_dl)
self.scrol_win_info.add(self.view_info)
self.btn_box.pack_start(self.btn_download, True, True, 0)
self.header_bar.pack_start(self.btn_download)
self.btn_box.pack_start(self.btn_cancel, True, True, 0)
self.cmd_box.pack_start(self.btn_box, False, False, 0)
self.cmd_box.pack_end(self.btn_quit, False, False, 0)
self.top_box.pack_start(self.scrol_win_emi, True, True, 0)
self.top_box.pack_start(self.cmd_box, False, False, 5)
self.vpaned.pack1(self.top_box, shrink = False)
self.top_box.set_size_request(-1, 150)
self.vpaned.pack2(self.scrol_win_dl, shrink = False)
self.scrol_win_dl.set_size_request(-1, 100)
self.vpaned.set_wide_handle = 30
self.main_paned.pack1(self.vpaned, shrink = False) #_start(self.vpaned, True, True, 0)
self.main_paned.pack2(self.scrol_win_info) #_end(self.scrol_win_info, False, True, 0)
self.root.add(self.main_paned)
self.root.show_all()
return
def __view_key_press(self, view, event):
if event.keyval == Gtk.accelerator_parse("Delete")[0]:
self.__remove(view)
def setup_ui(self):
self.set_title(self.DEFAULT_TITLE)
self.logo = GdkPixbuf.Pixbuf.new_from_file(os.path.join(self.settings.app_dir, 'devdocs.png'))
self.set_icon(self.logo)
# WebKit2 WebView setup.
# TODO: after https://bugs.webkit.org/show_bug.cgi?id=127410
# make database to be stored in app config dir
self.web_view = WebKit2.WebView()
self.web_view.get_context().\
get_cookie_manager().\
set_persistent_storage(
self.settings.cookie_path,
WebKit2.CookiePersistentStorage.SQLITE
)
self.web_view.show()
layout = Gtk.VBox()
toolbar = Gtk.Toolbar()
button = Gtk.ToolButton(Gtk.STOCK_HOME)
button.connect('clicked', self.on_home)
tool_item = Gtk.ToolItem()
tool_item.add(button)
toolbar.insert(tool_item, -1)
button = Gtk.ToolButton(Gtk.STOCK_COPY)
button.connect('clicked', self.on_copy)
tool_item = Gtk.ToolItem()
tool_item.add(button)
toolbar.insert(tool_item, -1)
self.address = Gtk.Entry()
self.address.set_editable(False)
tool_item = Gtk.ToolItem()
tool_item.set_expand(True)
tool_item.add(self.address)
toolbar.insert(tool_item, -1)
self.back = Gtk.ToolButton(Gtk.STOCK_GO_BACK)
self.back.connect('clicked', self.on_back)
self.back.set_sensitive(False)
tool_item = Gtk.ToolItem()
tool_item.add(self.back)
toolbar.insert(tool_item, -1)
self.forward = Gtk.ToolButton(Gtk.STOCK_GO_FORWARD)
self.forward.connect('clicked', self.on_forward)
self.forward.set_sensitive(False)
tool_item = Gtk.ToolItem()
tool_item.add(self.forward)
toolbar.insert(tool_item, -1)
button = Gtk.ToolButton(Gtk.STOCK_REFRESH)
button.connect('clicked', self.on_refresh)
tool_item = Gtk.ToolItem()
tool_item.add(button)
toolbar.insert(tool_item, -1)
accel = Gtk.AccelGroup()
self.add_accel_group(accel)
button = Gtk.ToolButton(Gtk.STOCK_FIND)
button.connect('clicked', self.on_search)
key, mod = Gtk.accelerator_parse("<control>f")
button.add_accelerator('clicked', accel, key, mod, Gtk.AccelFlags.VISIBLE)
tool_item = Gtk.ToolItem()
tool_item.add(button)
toolbar.insert(tool_item, -1)
button = Gtk.ToolButton(Gtk.STOCK_ABOUT)
button.connect('clicked', self.on_about)
tool_item = Gtk.ToolItem()
tool_item.add(button)
toolbar.insert(tool_item, -1)
toolbar.show_all()
layout.pack_start(toolbar, False, True, 0)
overlay = Gtk.Overlay()
overlay.add(self.web_view)
self.link_address = Gtk.Label()
self.link_address.set_halign(Gtk.Align.START)
self.link_address.set_valign(Gtk.Align.END)
self.link_address.show()
overlay.add_overlay(self.link_address)
self.search = Search(self.web_view.get_find_controller())
self.search.set_halign(Gtk.Align.END)
self.search.set_valign(Gtk.Align.START)
self.search.set_margin_right(50)
overlay.add_overlay(self.search)
overlay.show()
layout.pack_start(overlay, True, True, 0)
layout.show()
self.add(layout)
self.set_default_size(self.settings.width, self.settings.height)
self.move(self.settings.left, self.settings.top)
if self.settings.maximized:
self.maximize()
if self.settings.fullscreen:
self.fullscreen()
self.show()
self.connect('delete-event', self.on_exit)
self.web_view.connect('decide-policy', self.on_navigate, False)
self.web_view.connect('create', self.on_create)
self.web_view.connect('mouse-target-changed', self.on_link_url)
self.web_view.connect_after('notify::title', self.on_title)
self.web_view.connect_after('notify::uri', self.on_uri)
def __init__(self, app):
super().__init__()
self.app = app
self.play_type = PlayType.NONE
self.adj_timeout = 0
self.recommend_imgs = None
self.curr_song = None
self.fullscreen_sid = 0
self.fullscreen_timestamp = 0
self.default_cursor = None
self.blank_cursor = Gdk.Cursor.new(Gdk.CursorType.BLANK_CURSOR)
# use this to keep Net.AsyncSong object
self.async_song = None
self.async_next_song = None
event_pic = Gtk.EventBox()
event_pic.connect('button-press-event', self.on_pic_pressed)
self.pack_start(event_pic, False, False, 0)
self.artist_pic = Gtk.Image.new_from_pixbuf(Config.ANONYMOUS_PIXBUF)
event_pic.add(self.artist_pic)
control_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.pack_start(control_box, True, True, 0)
toolbar = Gtk.Toolbar()
toolbar.set_style(Gtk.ToolbarStyle.ICONS)
toolbar.get_style_context().add_class(Gtk.STYLE_CLASS_MENUBAR)
toolbar.set_show_arrow(False)
toolbar.set_icon_size(ICON_SIZE)
control_box.pack_start(toolbar, False, False, 0)
prev_button = Gtk.ToolButton()
prev_button.set_label(_('Previous'))
prev_button.set_icon_name('media-skip-backward-symbolic')
prev_button.connect('clicked', self.on_prev_button_clicked)
toolbar.insert(prev_button, 0)
self.playback_action = Gtk.ToggleAction('playback-action', _('Play'),
_('Play'), None)
self.playback_action.set_icon_name('media-playback-start-symbolic')
self.playback_action.set_label(_('Play'))
self.playback_action.set_active(False)
self.playback_action.connect('toggled', self.on_playback_action_toggled)
play_button = Gtk.ToolButton()
play_button.props.related_action = self.playback_action
toolbar.insert(play_button, 1)
next_button = Gtk.ToolButton()
next_button.set_label(_('Next'))
next_button.set_icon_name('media-skip-forward-symbolic')
next_button.connect('clicked', self.on_next_button_clicked)
toolbar.insert(next_button, 2)
self.shuffle_btn = Gtk.ToggleToolButton()
self.shuffle_btn.set_label(_('Shuffle'))
self.shuffle_btn.set_icon_name('media-playlist-shuffle-symbolic')
self.shuffle_btn.props.margin_left = 10
toolbar.insert(self.shuffle_btn, 3)
self.repeat_type = RepeatType.NONE
self.repeat_btn = Gtk.ToggleToolButton()
self.repeat_btn.set_label(_('Repeat'))
self.repeat_btn.set_icon_name('media-playlist-repeat-symbolic')
self.repeat_btn.connect('clicked', self.on_repeat_button_clicked)
toolbar.insert(self.repeat_btn, 4)
self.use_audio_btn = Gtk.RadioToolButton()
self.use_audio_btn.set_label(_('Play audio'))
self.use_audio_btn.set_icon_name('audio-x-generic-symbolic')
self.use_audio_btn.props.margin_left = 10
self.use_audio_btn.set_active(True)
self.use_audio_sid = self.use_audio_btn.connect('toggled',
self.on_play_type_toggled, PlayType.SONG)
toolbar.insert(self.use_audio_btn, 5)
self.use_mtv_btn = Gtk.RadioToolButton()
self.use_mtv_btn.set_label(_('Play MTV'))
self.use_mtv_btn.set_tooltip_text(_('Play MTV'))
self.use_mtv_btn.set_icon_name('video-x-generic-symbolic')
self.use_mtv_btn.set_sensitive(False)
self.use_mtv_btn.props.group = self.use_audio_btn
self.use_mtv_sid = self.use_mtv_btn.connect('toggled',
self.on_play_type_toggled, PlayType.MV)
toolbar.insert(self.use_mtv_btn, 6)
self.fullscreen_btn = Gtk.ToggleToolButton()
self.fullscreen_btn.set_label(_('Fullscreen'))
self.fullscreen_btn.set_icon_name('view-fullscreen-symbolic')
self.fullscreen_btn.props.margin_left = 10
self.fullscreen_btn.connect('toggled',
self.on_fullscreen_button_toggled)
toolbar.insert(self.fullscreen_btn, 7)
self.app.window.connect('key-press-event', self.on_window_key_pressed)
self.favorite_btn = Gtk.ToolButton()
self.favorite_btn.set_label(_('Favorite'))
self.favorite_btn.set_icon_name('emblem-favorite-symbolic')
self.favorite_btn.set_tooltip_text(_('Add to Favorite playlist'))
self.favorite_btn.props.margin_left = 10
self.favorite_btn.connect('clicked', self.on_favorite_btn_clicked)
toolbar.insert(self.favorite_btn, 8)
osd_lrc_btn = Gtk.ToggleToolButton()
osd_lrc_btn.props.related_action = self.app.osdlrc.show_window_action
toolbar.insert(osd_lrc_btn, 9)
# control menu
menu_tool_item = Gtk.ToolItem()
toolbar.insert(menu_tool_item, 10)
toolbar.child_set_property(menu_tool_item, 'expand', True)
main_menu = Gtk.Menu()
pref_item = Gtk.MenuItem(label=_('Preferences'))
pref_item.connect('activate', self.on_main_menu_pref_activate)
main_menu.append(pref_item)
sep_item = Gtk.SeparatorMenuItem()
main_menu.append(sep_item)
show_osd_item = Gtk.MenuItem()
show_osd_item.props.related_action = self.app.osdlrc.show_window_action
main_menu.append(show_osd_item)
lock_osd_item = Gtk.MenuItem()
lock_osd_item.props.related_action = self.app.osdlrc.lock_window_action
main_menu.append(lock_osd_item)
sep_item = Gtk.SeparatorMenuItem()
main_menu.append(sep_item)
about_item = Gtk.MenuItem(label=_('About'))
about_item.connect('activate', self.on_main_menu_about_activate)
main_menu.append(about_item)
quit_item = Gtk.MenuItem(label=_('Quit'))
key, mod = Gtk.accelerator_parse('<Ctrl>Q')
quit_item.add_accelerator('activate', app.accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
quit_item.connect('activate', self.on_main_menu_quit_activate)
main_menu.append(quit_item)
main_menu.show_all()
menu_image = Gtk.Image()
menu_image.set_from_icon_name('view-list-symbolic', ICON_SIZE)
if Config.GTK_LE_36:
menu_btn = Gtk.Button()
menu_btn.connect('clicked', self.on_main_menu_button_clicked,
main_menu)
else:
menu_btn = Gtk.MenuButton()
menu_btn.set_popup(main_menu)
menu_btn.set_always_show_image(True)
menu_btn.props.halign = Gtk.Align.END
menu_btn.props.relief = Gtk.ReliefStyle.NONE
menu_btn.set_image(menu_image)
menu_tool_item.add(menu_btn)
self.label = Gtk.Label(
'<b>{0}</b> <small>{0}</small>'.format(_('Unknown')))
self.label.props.use_markup = True
self.label.props.xalign = 0
self.label.props.margin_left = 10
control_box.pack_start(self.label, False, False, 0)
scale_box = Gtk.Box(spacing=3)
scale_box.props.margin_left = 5
control_box.pack_start(scale_box, True, False, 0)
self.scale = Gtk.Scale()
self.adjustment = Gtk.Adjustment(0, 0, 100, 1, 10, 0)
self.adjustment.connect('changed', self.on_adjustment_changed)
self.scale.set_adjustment(self.adjustment)
self.scale.set_show_fill_level(False)
self.scale.set_restrict_to_fill_level(False)
self.scale.props.draw_value = False
self.scale.connect('change-value', self.on_scale_change_value)
scale_box.pack_start(self.scale, True, True, 0)
self.time_label = Gtk.Label('0:00/0:00')
scale_box.pack_start(self.time_label, False, False, 0)
self.volume = Gtk.VolumeButton()
self.volume.props.use_symbolic = True
self.volume.set_value(app.conf['volume'] ** 0.33)
self.volume_sid = self.volume.connect('value-changed',
self.on_volume_value_changed)
scale_box.pack_start(self.volume, False, False, 0)
# init playbin and dbus
self.playbin = PlayerBin()
self.playbin.set_volume(self.app.conf['volume'] ** 0.33)
self.playbin.connect('eos', self.on_playbin_eos)
self.playbin.connect('error', self.on_playbin_error)
self.playbin.connect('mute-changed', self.on_playbin_mute_changed)
self.playbin.connect('volume-changed', self.on_playbin_volume_changed)
self.dbus = PlayerDBus(self)
self.notify = PlayerNotify(self)
def __init__(self, application):
self.application = application
self.settings = Gio.Settings(schema_id="org.x.quickly-web-manager")
self.manager = QuicklyWebManager()
self.selected_webapp = None
self.icon_theme = Gtk.IconTheme.get_default()
# Glade dosyasını ayarlayalım
gladefile = "/usr/share/web-manager/web-manager.ui"
self.builder = Gtk.Builder()
self.builder.set_translation_domain(APP)
self.builder.add_from_file(gladefile)
self.window = self.builder.get_object("main_window")
self.window.set_title(_("Quickly"))
self.window.set_icon_name("web-manager")
self.stack = self.builder.get_object("stack")
self.icon_chooser = ThemedIconChooser.IconChooserButton()
self.builder.get_object("icon_button_box").pack_start(self.icon_chooser, 0, True, True)
self.icon_chooser.set_icon_contexts(["Applications"])
self.icon_chooser.show_all()
# Widget'lara hızlıca ulaşmak için değişkenleri oluşturalım
self.headerbar = self.builder.get_object("headerbar")
self.favicon_button = self.builder.get_object("favicon_button")
self.add_button = self.builder.get_object("add_button")
self.remove_button = self.builder.get_object("remove_button")
self.edit_button = self.builder.get_object("edit_button")
self.run_button = self.builder.get_object("run_button")
self.ok_button = self.builder.get_object("ok_button")
self.name_entry = self.builder.get_object("name_entry")
self.url_entry = self.builder.get_object("url_entry")
self.url_label = self.builder.get_object("url_label")
self.spinner = self.builder.get_object("spinner")
self.favicon_stack = self.builder.get_object("favicon_stack")
self.browser_combo = self.builder.get_object("browser_combo")
self.browser_label = self.builder.get_object("browser_label")
# ekleme ssayfasında bulunan düzenleme sayfasında olmayan widgetlar
self.add_specific_widgets = [self.browser_label, self.browser_combo]
# Widget sinyali
self.add_button.connect("clicked", self.on_add_button)
self.builder.get_object("cancel_button").connect("clicked", self.on_cancel_button)
self.builder.get_object("cancel_favicon_button").connect("clicked", self.on_cancel_favicon_button)
self.remove_button.connect("clicked", self.on_remove_button)
self.edit_button.connect("clicked", self.on_edit_button)
self.run_button.connect("clicked", self.on_run_button)
self.ok_button.connect("clicked", self.on_ok_button)
self.favicon_button.connect("clicked", self.on_favicon_button)
self.name_entry.connect("changed", self.on_name_entry)
self.url_entry.connect("changed", self.on_url_entry)
self.window.connect("key-press-event",self.on_key_press_event)
# Menü çubuğu
accel_group = Gtk.AccelGroup()
self.window.add_accel_group(accel_group)
menu = self.builder.get_object("main_menu")
item = Gtk.ImageMenuItem()
item.set_image(Gtk.Image.new_from_icon_name("preferences-desktop-keyboard-shortcuts-symbolic", Gtk.IconSize.MENU))
item.set_label(_("Klavye kısayolları"))
item.connect("activate", self.open_keyboard_shortcuts)
key, mod = Gtk.accelerator_parse("<Control>K")
item.add_accelerator("activate", accel_group, key, mod, Gtk.AccelFlags.VISIBLE)
menu.append(item)
item = Gtk.ImageMenuItem()
item.set_image(Gtk.Image.new_from_icon_name("help-about-symbolic", Gtk.IconSize.MENU))
item.set_label(_("Hakkında"))
item.connect("activate", self.open_about)
key, mod = Gtk.accelerator_parse("F1")
item.add_accelerator("activate", accel_group, key, mod, Gtk.AccelFlags.VISIBLE)
menu.append(item)
item = Gtk.ImageMenuItem(label=_("Çıkış"))
image = Gtk.Image.new_from_icon_name("application-exit-symbolic", Gtk.IconSize.MENU)
item.set_image(image)
item.connect('activate', self.on_menu_quit)
key, mod = Gtk.accelerator_parse("<Control>Q")
item.add_accelerator("activate", accel_group, key, mod, Gtk.AccelFlags.VISIBLE)
key, mod = Gtk.accelerator_parse("<Control>W")
item.add_accelerator("activate", accel_group, key, mod, Gtk.AccelFlags.VISIBLE)
menu.append(item)
menu.show_all()
#Ağaç görünümü
self.treeview = self.builder.get_object("webapps_treeview")
renderer = Gtk.CellRendererPixbuf()
column = Gtk.TreeViewColumn("", renderer, pixbuf=COL_ICON)
column.set_cell_data_func(renderer, self.data_func_surface)
self.treeview.append_column(column)
column = Gtk.TreeViewColumn("", Gtk.CellRendererText(), text=COL_NAME)
column.set_sort_column_id(COL_NAME)
column.set_resizable(True)
self.treeview.append_column(column)
self.treeview.show()
self.model = Gtk.TreeStore(GdkPixbuf.Pixbuf, str, object)
self.model.set_sort_column_id(COL_NAME, Gtk.SortType.ASCENDING)
self.treeview.set_model(self.model)
self.treeview.get_selection().connect("changed", self.on_webapp_selected)
self.treeview.connect("row-activated", self.on_webapp_activated)
#Kategori kutusu
category_model = Gtk.ListStore(str,str)
category_model.append(["Network",_("Internet")])
category_model.append(["WebApps",_("Web uygulamaları")])
category_model.append(["Utility",_("Donatılar")])
category_model.append(["Game",_("Oyunlar")])
category_model.append(["Graphics",_("Grafikler")])
category_model.append(["Office",_("Ofis")])
category_model.append(["AudioVideo",_("Ses & Video")])
category_model.append(["Development",_("Programlama")])
category_model.append(["Education",_("Eğitim")])
self.category_combo = self.builder.get_object("category_combo")
renderer = Gtk.CellRendererText()
self.category_combo.pack_start(renderer, True)
self.category_combo.add_attribute(renderer, "text", CATEGORY_NAME)
self.category_combo.set_model(category_model)
self.category_combo.set_active(0) # Kategori seçimi
browser_model = Gtk.ListStore(object, str)
num_browsers = 0
for browser in self.manager.get_supported_browsers():
if os.path.exists(browser.test_path):
browser_model.append([browser, browser.name])
num_browsers += 1
renderer = Gtk.CellRendererText()
self.browser_combo.pack_start(renderer, True)
self.browser_combo.add_attribute(renderer, "text", BROWSER_NAME)
self.browser_combo.set_model(browser_model)
self.browser_combo.set_active(0) # Tarayıcı seçimi
if num_browsers == 0:
print ("Desteklenen tarayıcı bulunamadı.")
self.add_button.set_sensitive(False)
self.add_button.set_tooltip_text(_("Desteklenen tarayıcı bulunamadı."))
if (num_browsers < 2):
self.browser_label.hide()
self.browser_combo.hide()
self.browser_combo.connect("changed", self.on_browser_changed)
self.load_webapps()
# Tamam düğmesi ile kullanılır. Bir web uygulaması düzenlediğimizi yada yeni bir uygulama eklediğimizi gösterir.
self.edit_mode = False
def get_primary_accel_mod():
"""
Returns the primary Gdk.ModifierType modifier.
cmd on osx, ctrl everywhere else.
"""
return Gtk.accelerator_parse("<Primary>")[1]
def __init__(self):
Gtk.MenuBar.__init__(self)
self.set_hexpand(True)
menuitem = uigtk.widgets.MenuItem("_File")
self.add(menuitem)
menu = Gtk.Menu()
menuitem.set_submenu(menu)
menuitemNew = uigtk.widgets.MenuItem("_New Game...")
key, modifier = Gtk.accelerator_parse("<Control>N")
menuitemNew.add_accelerator("activate", data.window.accelgroup, key,
modifier, Gtk.AccelFlags.VISIBLE)
menuitemNew.connect("activate", self.on_new_clicked)
menu.append(menuitemNew)
menuitemLoad = uigtk.widgets.MenuItem("_Load Game...")
key, modifier = Gtk.accelerator_parse("<Control>L")
menuitemLoad.add_accelerator("activate", data.window.accelgroup, key,
modifier, Gtk.AccelFlags.VISIBLE)
menuitemLoad.connect("activate", uigtk.filedialog.LoadDialog)
menu.append(menuitemLoad)
menuitemSave = uigtk.widgets.MenuItem("_Save Game...")
key, modifier = Gtk.accelerator_parse("<Control>S")
menuitemSave.add_accelerator("activate", data.window.accelgroup, key,
modifier, Gtk.AccelFlags.VISIBLE)
menuitemSave.connect("activate", self.on_save_clicked)
menu.append(menuitemSave)
menuitemDelete = uigtk.widgets.MenuItem("_Delete Game...")
menuitemDelete.connect("activate", uigtk.deletedialog.DeleteDialog)
menu.append(menuitemDelete)
separator = Gtk.SeparatorMenuItem()
menu.append(separator)
menuitemPrint = uigtk.widgets.MenuItem("_Print...")
key, modifier = Gtk.accelerator_parse("<Control>P")
menuitemPrint.add_accelerator("activate", data.window.accelgroup, key,
modifier, Gtk.AccelFlags.VISIBLE)
menuitemPrint.connect("activate", self.on_print_clicked)
menu.append(menuitemPrint)
separator = Gtk.SeparatorMenuItem()
menu.append(separator)
menuitemQuit = uigtk.widgets.MenuItem("_Quit Game")
key, modifier = Gtk.accelerator_parse("<Control>Q")
menuitemQuit.add_accelerator("activate", data.window.accelgroup, key,
modifier, Gtk.AccelFlags.VISIBLE)
menuitemQuit.connect("activate", self.on_quit_clicked)
menu.append(menuitemQuit)
menuitem = uigtk.widgets.MenuItem("_Edit")
self.add(menuitem)
menu = Gtk.Menu()
menuitem.set_submenu(menu)
menuitemSetManagerName = uigtk.widgets.MenuItem("_Set Manager Name...")
menuitemSetManagerName.connect("activate",
uigtk.managername.ManagerName)
menu.append(menuitemSetManagerName)
separator = Gtk.SeparatorMenuItem()
menu.append(separator)
menuitemPreferences = uigtk.widgets.MenuItem("_Preferences")
menuitemPreferences.connect("activate", uigtk.preferences.Dialog)
menu.append(menuitemPreferences)
menuitem = uigtk.widgets.MenuItem("_Screen")
self.add(menuitem)
menu = Gtk.Menu()
menuitem.set_submenu(menu)
menuitemBack = uigtk.widgets.MenuItem("_Back")
key, modifier = Gtk.accelerator_parse("<Alt>Left")
menuitemBack.add_accelerator("activate", data.window.accelgroup, key,
modifier, Gtk.AccelFlags.VISIBLE)
menuitemBack.connect("activate", self.on_back_clicked)
menu.append(menuitemBack)
menuitem = uigtk.widgets.MenuItem("_View")
self.add(menuitem)
menu = Gtk.Menu()
menuitem.set_submenu(menu)
menuitem = uigtk.widgets.MenuItem("_Search")
menu.append(menuitem)
menuSearch = Gtk.Menu()
menuitem.set_submenu(menuSearch)
menuitemPlayerSearch = uigtk.widgets.MenuItem("_Players")
menuitemPlayerSearch.name = "playersearch"
key, modifier = Gtk.accelerator_parse("<Control>1")
menuitemPlayerSearch.add_accelerator("activate",
data.window.accelgroup, key,
modifier, Gtk.AccelFlags.VISIBLE)
menuitemPlayerSearch.connect("activate", self.on_screen_clicked)
menuSearch.append(menuitemPlayerSearch)
menuitemClubSearch = uigtk.widgets.MenuItem("_Clubs")
menuitemClubSearch.name = "clubsearch"
key, modifier = Gtk.accelerator_parse("<Control>2")
menuitemClubSearch.add_accelerator("activate", data.window.accelgroup,
key, modifier,
Gtk.AccelFlags.VISIBLE)
menuitemClubSearch.connect("activate", self.on_screen_clicked)
menuSearch.append(menuitemClubSearch)
menuitemNationSearch = uigtk.widgets.MenuItem("_Nations")
menuitemNationSearch.name = "nationsearch"
key, modifier = Gtk.accelerator_parse("<Control>3")
menuitemNationSearch.add_accelerator("activate",
data.window.accelgroup, key,
modifier, Gtk.AccelFlags.VISIBLE)
menuitemNationSearch.connect("activate", self.on_screen_clicked)
menuSearch.append(menuitemNationSearch)
separator = Gtk.SeparatorMenuItem()
menu.append(separator)
menuitemNews = uigtk.widgets.MenuItem("_News")
menuitemNews.name = "news"
menuitemNews.connect("activate", self.on_screen_clicked)
menu.append(menuitemNews)
menuitemShortlist = uigtk.widgets.MenuItem("_Shortlist")
menuitemShortlist.name = "shortlist"
menuitemShortlist.connect("activate", self.on_screen_clicked)
menu.append(menuitemShortlist)
menuitemNegotiations = uigtk.widgets.MenuItem("_Negotiations")
menuitemNegotiations.name = "negotiations"
menuitemNegotiations.connect("activate", self.on_screen_clicked)
menu.append(menuitemNegotiations)
menuitemFixtures = uigtk.widgets.MenuItem("_Fixtures")
menuitemFixtures.name = "fixtures"
menuitemFixtures.connect("activate", self.on_screen_clicked)
menu.append(menuitemFixtures)
menuitemStandings = uigtk.widgets.MenuItem("_Standings")
menuitemStandings.name = "standings"
menuitemStandings.connect("activate", self.on_screen_clicked)
menu.append(menuitemStandings)
separator = Gtk.SeparatorMenuItem()
menu.append(separator)
menuitemCharts = uigtk.widgets.MenuItem("_Charts")
menuitemCharts.name = "charts"
menuitemCharts.connect("activate", self.on_screen_clicked)
menu.append(menuitemCharts)
menuitemEvaluation = uigtk.widgets.MenuItem("_Evaluation")
menuitemEvaluation.name = "evaluation"
menuitemEvaluation.connect("activate", self.on_screen_clicked)
menu.append(menuitemEvaluation)
separator = Gtk.SeparatorMenuItem()
menu.append(separator)
menuitemComparison = uigtk.widgets.MenuItem("_Comparison")
menuitemComparison.connect("activate", self.on_comparison_clicked)
menu.append(menuitemComparison)
menuitem = uigtk.widgets.MenuItem("_Business")
self.add(menuitem)
menu = Gtk.Menu()
menuitem.set_submenu(menu)
menuitemStadium = uigtk.widgets.MenuItem("_Stadium")
menuitemStadium.name = "stadium"
menuitemStadium.connect("activate", self.on_screen_clicked)
menu.append(menuitemStadium)
menuitemBuildings = uigtk.widgets.MenuItem("_Buildings")
menuitemBuildings.name = "buildings"
menuitemBuildings.connect("activate", self.on_screen_clicked)
menu.append(menuitemBuildings)
separator = Gtk.SeparatorMenuItem()
menu.append(separator)
menuitemTickets = uigtk.widgets.MenuItem("_Tickets")
menuitemTickets.name = "tickets"
menuitemTickets.connect("activate", self.on_screen_clicked)
menu.append(menuitemTickets)
menuitemSponsorship = uigtk.widgets.MenuItem("_Sponsorship")
menuitemSponsorship.connect("activate", self.on_sponsorship_clicked)
menu.append(menuitemSponsorship)
menuitemAdvertising = uigtk.widgets.MenuItem("_Advertising")
menuitemAdvertising.name = "advertising"
menuitemAdvertising.connect("activate", self.on_screen_clicked)
menu.append(menuitemAdvertising)
menuitemMerchandise = uigtk.widgets.MenuItem("_Merchandise")
menuitemMerchandise.name = "merchandise"
menuitemMerchandise.connect("activate", self.on_screen_clicked)
menu.append(menuitemMerchandise)
menuitemCatering = uigtk.widgets.MenuItem("_Catering")
menuitemCatering.name = "catering"
menuitemCatering.connect("activate", self.on_screen_clicked)
menu.append(menuitemCatering)
separator = Gtk.SeparatorMenuItem()
menu.append(separator)
menuitemAccounts = uigtk.widgets.MenuItem("_Accounts")
menuitemAccounts.name = "accounts"
menuitemAccounts.connect("activate", self.on_screen_clicked)
menu.append(menuitemAccounts)
menuitemFinances = uigtk.widgets.MenuItem("_Finances")
menuitemFinances.name = "finances"
menuitemFinances.connect("activate", self.on_screen_clicked)
menu.append(menuitemFinances)
menuitem = uigtk.widgets.MenuItem("_Team")
self.add(menuitem)
menu = Gtk.Menu()
menuitem.set_submenu(menu)
menuitemSquad = uigtk.widgets.MenuItem("_Squad")
menuitemSquad.name = "squad"
menuitemSquad.connect("activate", self.on_screen_clicked)
menu.append(menuitemSquad)
menuitemTactics = uigtk.widgets.MenuItem("_Tactics")
menuitemTactics.name = "tactics"
menuitemTactics.connect("activate", self.on_screen_clicked)
menu.append(menuitemTactics)
menuitemTraining = uigtk.widgets.MenuItem("_Training")
menu.append(menuitemTraining)
menuTraining = Gtk.Menu()
menuitemTraining.set_submenu(menuTraining)
menuitemTeamTraining = uigtk.widgets.MenuItem("_Team Training")
menuitemTeamTraining.name = "teamtraining"
menuitemTeamTraining.connect("activate", self.on_screen_clicked)
menuTraining.append(menuitemTeamTraining)
menuitemIndividualTraining = uigtk.widgets.MenuItem(
"_Individual Training")
menuitemIndividualTraining.name = "individualtraining"
menuitemIndividualTraining.connect("activate", self.on_screen_clicked)
menuTraining.append(menuitemIndividualTraining)
menuitemTrainingCamp = uigtk.widgets.MenuItem("Training _Camp")
menuitemTrainingCamp.name = "trainingcamp"
menuitemTrainingCamp.connect("activate", self.on_screen_clicked)
menuTraining.append(menuitemTrainingCamp)
menuitemStaff = uigtk.widgets.MenuItem("_Staff")
menuitemStaff.name = "staff"
menuitemStaff.connect("activate", self.on_screen_clicked)
menu.append(menuitemStaff)
separator = Gtk.SeparatorMenuItem()
menu.append(separator)
menuitemUnavailable = uigtk.widgets.MenuItem("_Unavailable")
menuitemUnavailable.name = "unavailable"
menuitemUnavailable.connect("activate", self.on_screen_clicked)
menu.append(menuitemUnavailable)
menuitem = uigtk.widgets.MenuItem("_Help")
self.add(menuitem)
menu = Gtk.Menu()
menuitem.set_submenu(menu)
menuitemContents = uigtk.widgets.MenuItem("_Contents")
key, modifier = Gtk.accelerator_parse("F1")
menuitemContents.add_accelerator("activate", data.window.accelgroup,
key, modifier, Gtk.AccelFlags.VISIBLE)
menuitemContents.connect("activate", self.on_help_clicked)
menu.append(menuitemContents)
menuitemVersions = uigtk.widgets.MenuItem("_Versions")
menuitemVersions.connect("activate", uigtk.version.VersionDialog)
menu.append(menuitemVersions)
separator = Gtk.SeparatorMenuItem()
menu.append(separator)
menuitemAbout = uigtk.widgets.MenuItem("_About")
menuitemAbout.connect("activate", uigtk.aboutdialog.AboutDialog)
menu.append(menuitemAbout)
def make_item(accel, combo):
name = Gtk.accelerator_get_label(*Gtk.accelerator_parse(accel))
item = Gtk.MenuItem(name)
item.connect("activate", on_send_key_fn, combo)
menu.add(item)
def compile_keymap(self):
new_keymap = {}
for (combo, action) in self.keymap.items():
accel = Gtk.accelerator_parse(combo)
new_keymap[accel] = {'accel': accel, 'action': action}
self.keymap = new_keymap
def __init__(self):
super().__init__(Gtk.WindowType.TOPLEVEL, 'News')
self.set_title('News')
self._progress_dialog = None
self.connect('destroy', self._on_destroy)
self._wait_dlg = WaitDialog(self)
# otworzenie / utworzenie pliku bazy danych
database_file = os.path.join(os.path.expanduser('~'), '.config/news',
'news.sqlite3')
self._db = com.bps.news.database.Database()
if not os.path.isfile(database_file):
self._db.create_new(database_file)
self._db.open_file(database_file)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
# menubar
accel_group = Gtk.AccelGroup()
self.add_accel_group(accel_group)
menubar = Gtk.MenuBar()
vbox.pack_start(menubar, False, False, 0)
# News menu
app_menu_item = Gtk.MenuItem('News')
app_menu = Gtk.Menu()
app_menu_item.set_submenu(app_menu)
menubar.append(app_menu_item)
self._update_all_item = Gtk.MenuItem('Update all')
key, mod = Gtk.accelerator_parse("<Control>U")
self._update_all_item.add_accelerator("activate", accel_group, key,
mod, Gtk.AccelFlags.VISIBLE)
self._update_all_item.connect('activate', self._on_update_all_item)
app_menu.append(self._update_all_item)
quit_item = Gtk.MenuItem('Quit')
quit_item.connect('activate', self._on_quit_menu_item)
key, mod = Gtk.accelerator_parse("<Control>Q")
quit_item.add_accelerator("activate", accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
app_menu.append(quit_item)
# channel menu
channel_menu_item = Gtk.MenuItem('Channel')
channel_menu = Gtk.Menu()
channel_menu_item.set_submenu(channel_menu)
menubar.append(channel_menu_item)
channel_add_item = Gtk.MenuItem('Add channel')
channel_add_item.connect('activate', self._on_channel_add_item)
key, mod = Gtk.accelerator_parse('<Control>N')
channel_add_item.add_accelerator('activate', accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
channel_menu.append(channel_add_item)
folder_add_item = Gtk.MenuItem('Add folder')
folder_add_item.connect('activate', self._on_folder_add_item)
key, mod = Gtk.accelerator_parse('<Control><Shift>N')
folder_add_item.add_accelerator('activate', accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
channel_menu.append(folder_add_item)
# news menu
news_menu_item = Gtk.MenuItem('News')
news_menu = Gtk.Menu()
news_menu_item.set_submenu(news_menu)
menubar.append(news_menu_item)
news_next_item = Gtk.MenuItem('Next')
news_next_item.connect('activate', self._on_news_next_item)
key, mod = Gtk.accelerator_parse('N')
news_next_item.add_accelerator('activate', accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
news_menu.append(news_next_item)
news_goto_item = Gtk.MenuItem('Goto')
news_goto_item.connect('activate', self._on_news_goto_item)
key, mod = Gtk.accelerator_parse('G')
news_goto_item.add_accelerator('activate', accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
news_menu.append(news_goto_item)
news_streamlink_worst = Gtk.MenuItem('Streamlink worst')
news_streamlink_worst.connect('activate',
self._on_news_streamlink_worst)
key, mod = Gtk.accelerator_parse('1')
news_streamlink_worst.add_accelerator('activate', accel_group, key,
mod, Gtk.AccelFlags.VISIBLE)
news_menu.append(news_streamlink_worst)
news_streamlink_360p = Gtk.MenuItem('Streamlink 360p')
news_streamlink_360p.connect('activate', self._on_news_streamlink_360p)
key, mod = Gtk.accelerator_parse('2')
news_streamlink_360p.add_accelerator('activate', accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
news_menu.append(news_streamlink_360p)
news_mark_read_all = Gtk.MenuItem('Mark all as read')
news_mark_read_all.connect('activate', self._on_mark_all_read)
key, mod = Gtk.accelerator_parse('<Control>M')
news_mark_read_all.add_accelerator('activate', accel_group, key, mod,
Gtk.AccelFlags.VISIBLE)
news_menu.append(news_mark_read_all)
# help menu
help_menu_item = Gtk.MenuItem('Help')
help_menu = Gtk.Menu()
help_menu_item.set_submenu(help_menu)
menubar.append(help_menu_item)
about_menu_item = Gtk.MenuItem('About')
about_menu_item.connect('activate', self._on_about_item)
help_menu.append(about_menu_item)
paned = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)
vbox.pack_start(paned, True, True, 0)
# lewy panel
self._channel_viewer = com.bps.news.ui.ChannelViewer(
self._on_channel_activate, self._on_delete_channel_item,
self._on_dragdrop_channel, self._on_folder_toggle)
paned.pack1(self._channel_viewer, False, False)
# prawy panel
l_paned = Gtk.Paned(orientation=Gtk.Orientation.VERTICAL)
self._news_list_box = com.bps.news.ui.NewsListView(
self._on_note_activated)
l_paned.pack1(self._news_list_box, False, False)
self._news_viewer = com.bps.news.ui.NewsViewer(
on_click=self._on_news_view, on_like=self._on_like_click)
l_paned.pack2(self._news_viewer, True, False)
paned.pack2(l_paned, True, False)
self.add(vbox)
# załaduj dane i ustawienia
folders = self._db.get_folders()
for folder in folders:
self._channel_viewer.add_folder(folder['title'])
for id, title, url, channel_type, unread_count, folder_title in self._db.get_channels(
):
# wybierz ikonę odpowiednią do źródła newsów
icon = 'rss'
if 'youtube' in url:
icon = 'youtube'
elif 'twitch' in url:
icon = 'twitch'
self._channel_viewer.add_channel(title,
unread_count,
folder_title,
icon_name=icon)
# rozwin katalogi jeśli trzeba
for folder in folders:
self._channel_viewer.toggle_folder(folder['title'],
folder['expanded'])
self.show_all()
# załadowanie konfiguracji i styli
self._load_config()
