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()