def show(self): """ Show the ConnectionManager dialog. """ # Get the glade file for the connection manager self.glade = Gtk.Builder() self.glade.add_from_file( pkg_resources.resource_filename("deluge.ui.gtkui", "builder/connection_manager.ui")) self.window = component.get("MainWindow") # Setup the ConnectionManager dialog self.connection_manager = self.glade.get_object("connection_manager") self.connection_manager.set_transient_for(self.window.window) self.connection_manager.set_icon(common.get_deluge_icon()) self.glade.get_object("image1").set_from_pixbuf(common.get_logo(32)) self.hostlist = self.glade.get_object("hostlist") # Create status pixbufs if not HOSTLIST_PIXBUFS: for stock_id in (Gtk.STOCK_NO, Gtk.STOCK_YES, Gtk.STOCK_CONNECT): HOSTLIST_PIXBUFS.append( self.connection_manager.render_icon( stock_id, Gtk.IconSize.MENU)) # Create the host list gtkliststore # id-hash, hostname, port, status, username, password, version self.liststore = Gtk.ListStore(str, str, int, str, str, str, str) # Setup host list treeview self.hostlist.set_model(self.liststore) render = Gtk.CellRendererPixbuf() column = Gtk.TreeViewColumn(_("Status"), render) column.set_cell_data_func(render, cell_render_status, 3) self.hostlist.append_column(column) render = Gtk.CellRendererText() column = Gtk.TreeViewColumn(_("Host"), render, text=HOSTLIST_COL_HOST) column.set_cell_data_func(render, cell_render_host, (1, 2, 4)) column.set_expand(True) self.hostlist.append_column(column) render = Gtk.CellRendererText() column = Gtk.TreeViewColumn(_("Version"), render, text=HOSTLIST_COL_VERSION) self.hostlist.append_column(column) # Load any saved host entries self.__load_hostlist() self.__load_options() # Select the first host if possible if len(self.liststore) > 0: self.hostlist.get_selection().select_path("0") # Connect the signals to the handlers self.glade.connect_signals(self) self.hostlist.get_selection().connect( "changed", self.on_hostlist_selection_changed) self.__update_list() self.running = True response = self.connection_manager.run() self.running = False # Save the toggle options self.__save_options() self.__save_hostlist() self.connection_manager.destroy() del self.glade del self.window del self.connection_manager del self.liststore del self.hostlist
def on_module_selected(self): if not self.loaded: print "Loading Keyboard module" self.tabs = [] self.notebook = Gtk.Notebook() self.notebook.expand = True tab = NotebookPage(_("Typing"), False) tab.add_widget( GSettingsCheckButton( _("Enable key repeat"), "org.cinnamon.settings-daemon.peripherals.keyboard", "repeat", None)) box = IndentedHBox() slider = GSettingsRange( _("Repeat delay:"), _("Short"), _("Long"), 100, 2000, False, "uint", False, "org.cinnamon.settings-daemon.peripherals.keyboard", "delay", "org.cinnamon.settings-daemon.peripherals.keyboard/repeat", adjustment_step=10) box.pack_start(slider, True, True, 0) tab.add_widget(box) box = IndentedHBox() slider = GSettingsRange( _("Repeat speed:"), _("Slow"), _("Fast"), 20, 2000, True, "uint", True, "org.cinnamon.settings-daemon.peripherals.keyboard", "repeat-interval", "org.cinnamon.settings-daemon.peripherals.keyboard/repeat", adjustment_step=1) box.pack_start(slider, True, True, 0) tab.add_widget(box) tab.add_widget(Gtk.Separator.new(Gtk.Orientation.HORIZONTAL)) tab.add_widget( GSettingsCheckButton(_("Text cursor blinks"), "org.cinnamon.desktop.interface", "cursor-blink", None)) box = IndentedHBox() slider = GSettingsRange( _("Blink speed:"), _("Slow"), _("Fast"), 100, 2500, True, "int", False, "org.cinnamon.desktop.interface", "cursor-blink-time", "org.cinnamon.desktop.interface/cursor-blink", adjustment_step=10) box.pack_start(slider, True, True, 0) tab.add_widget(box) tab.add_widget(Gtk.Separator.new(Gtk.Orientation.HORIZONTAL)) tab.add_widget(Gtk.Label.new(_("Test Box"))) tab.add_widget(Gtk.Entry()) self.addNotebookTab(tab) tab = NotebookPage(_("Keyboard shortcuts"), True) headingbox = Gtk.Box.new(Gtk.Orientation.VERTICAL, 2) mainbox = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 2) headingbox.pack_start(mainbox, True, True, 2) headingbox.pack_end( Gtk.Label.new( _("To edit a keyboard binding, click it and press the new keys, or press backspace to clear it." )), False, False, 1) paned = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL) left_vbox = Gtk.Box.new(Gtk.Orientation.VERTICAL, 2) right_vbox = Gtk.Box.new(Gtk.Orientation.VERTICAL, 2) paned.add1(left_vbox) right_scroller = Gtk.ScrolledWindow.new(None, None) right_scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER) right_scroller.add(right_vbox) paned.add2(right_scroller) category_scroller = Gtk.ScrolledWindow.new(None, None) category_scroller.set_shadow_type(Gtk.ShadowType.IN) kb_name_scroller = Gtk.ScrolledWindow.new(None, None) kb_name_scroller.set_shadow_type(Gtk.ShadowType.IN) entry_scroller = Gtk.ScrolledWindow.new(None, None) entry_scroller.set_shadow_type(Gtk.ShadowType.IN) right_vbox.pack_start(kb_name_scroller, False, False, 2) right_vbox.pack_start(entry_scroller, False, False, 2) kb_name_scroller.set_property('min-content-height', 150) entry_scroller.set_property('min-content-height', 100) self.cat_tree = Gtk.TreeView.new() self.kb_tree = Gtk.TreeView.new() self.entry_tree = Gtk.TreeView.new() self.kb_tree.connect('row-activated', self.onCustomKeyBindingEdited) self.kb_tree.connect('button-press-event', self.onContextMenuPopup) self.kb_tree.connect('popup-menu', self.onContextMenuPopup) left_vbox.pack_start(category_scroller, True, True, 2) category_scroller.add(self.cat_tree) category_scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) kb_name_scroller.add(self.kb_tree) kb_name_scroller.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) entry_scroller.add(self.entry_tree) entry_scroller.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.NEVER) buttonbox = Gtk.ButtonBox.new(Gtk.Orientation.HORIZONTAL) self.add_custom_button = Gtk.Button.new_with_label( _("Add custom shortcut")) self.add_custom_button.connect('clicked', self.onAddCustomButtonClicked) self.remove_custom_button = Gtk.Button.new_with_label( _("Remove custom shortcut")) self.remove_custom_button.connect('clicked', self.onRemoveCustomButtonClicked) self.remove_custom_button.set_property('sensitive', False) buttonbox.pack_start(self.add_custom_button, False, False, 2) buttonbox.pack_start(self.remove_custom_button, False, False, 2) right_vbox.pack_end(buttonbox, False, False, 2) mainbox.pack_start(paned, True, True, 2) left_vbox.set_border_width(2) right_vbox.set_border_width(2) self.cat_store = Gtk.TreeStore( str, # Icon name or None str, # The category name object) # The category object self.kb_store = Gtk.ListStore( str, # Keybinding name object) # The keybinding object self.entry_store = Gtk.ListStore( str, # Keybinding entry object) # Keybinding object cell = Gtk.CellRendererText() cell.set_alignment(0, 0) pb_cell = Gtk.CellRendererPixbuf() cat_column = Gtk.TreeViewColumn(_("Categories")) cat_column.pack_start(pb_cell, False) cat_column.pack_start(cell, True) cat_column.add_attribute(pb_cell, "icon-name", 0) cat_column.add_attribute(cell, "text", 1) cat_column.set_alignment(0) cat_column.set_property('min-width', 200) self.cat_tree.append_column(cat_column) self.cat_tree.connect("cursor-changed", self.onCategoryChanged) kb_name_cell = Gtk.CellRendererText() kb_name_cell.set_alignment(.5, .5) kb_column = Gtk.TreeViewColumn(_("Keyboard shortcuts"), kb_name_cell, text=0) kb_column.set_alignment(.5) self.kb_tree.append_column(kb_column) self.kb_tree.connect("cursor-changed", self.onKeyBindingChanged) entry_cell = CellRendererKeybinding(self.entry_tree) entry_cell.set_alignment(.5, .5) entry_cell.connect('accel-edited', self.onEntryChanged, self.entry_store) entry_cell.connect('accel-cleared', self.onEntryCleared, self.entry_store) entry_cell.set_property('editable', True) entry_column = Gtk.TreeViewColumn(_("Keyboard bindings"), entry_cell, text=0) entry_column.set_alignment(.5) self.entry_tree.append_column(entry_column) self.entry_tree.set_tooltip_text( "%s\n%s\n%s" % (_("Click to set a new accelerator key."), _("Press Escape or click again to cancel the operation."), _("Press Backspace to clear the existing keybinding."))) self.main_store = [] for cat in CATEGORIES: self.main_store.append( KeyBindingCategory(cat[0], cat[1], cat[2], cat[3])) for binding in KEYBINDINGS: for category in self.main_store: if category.int_name == binding[3]: category.add( KeyBinding(binding[0], binding[1], binding[2], binding[3])) cat_iters = {} longest_cat_label = " " for category in self.main_store: if category.parent == None: cat_iters[category.int_name] = self.cat_store.append(None) else: cat_iters[category.int_name] = self.cat_store.append( cat_iters[category.parent]) if category.icon: self.cat_store.set_value(cat_iters[category.int_name], 0, category.icon) self.cat_store.set_value(cat_iters[category.int_name], 1, category.label) self.cat_store.set_value(cat_iters[category.int_name], 2, category) if len(category.label) > len(longest_cat_label): longest_cat_label = category.label layout = self.cat_tree.create_pango_layout(longest_cat_label) w, h = layout.get_pixel_size() paned.set_position(max(w, 200)) self.loadCustoms() self.cat_tree.set_model(self.cat_store) self.kb_tree.set_model(self.kb_store) self.entry_tree.set_model(self.entry_store) tab.add_widget(headingbox) self.addNotebookTab(tab) tab = NotebookPage(_("Keyboard layouts"), True) try: widget = self.sidePage.content_box.c_manager.get_c_widget( "region") except: widget = None if widget is not None: cheat_box = Gtk.Box.new(Gtk.Orientation.VERTICAL, 2) cheat_box.pack_start(widget, True, True, 2) cheat_box.set_vexpand(False) widget.show() tab.add_widget(cheat_box) self.addNotebookTab(tab) self.sidePage.add_widget(self.notebook) for tab in self.tabs: tab.build()
def __init__(self, docmodel): super(RootStackTreeView, self).__init__() self._docmodel = docmodel treemodel = RootStackTreeModelWrapper(docmodel) self.set_model(treemodel) target1 = Gtk.TargetEntry.new( target="GTK_TREE_MODEL_ROW", flags=Gtk.TargetFlags.SAME_WIDGET, info=1, ) self.drag_source_set( start_button_mask=Gdk.ModifierType.BUTTON1_MASK, targets=[target1], actions=Gdk.DragAction.MOVE, ) self.drag_dest_set( flags=Gtk.DestDefaults.MOTION | Gtk.DestDefaults.DROP, targets=[target1], actions=Gdk.DragAction.MOVE, ) self.connect("button-press-event", self._button_press_cb) # Motion and modifier keys during drag self.connect("drag-begin", self._drag_begin_cb) self.connect("drag-motion", self._drag_motion_cb) self.connect("drag-leave", self._drag_leave_cb) self.connect("drag-drop", self._drag_drop_cb) self.connect("drag-end", self._drag_end_cb) # Track updates from the model self._processing_model_updates = False root = docmodel.layer_stack root.current_path_updated += self._current_path_updated_cb root.expand_layer += self._expand_layer_cb root.collapse_layer += self._collapse_layer_cb root.layer_content_changed += self._layer_content_changed_cb root.current_layer_solo_changed += lambda *a: self.queue_draw() # View behaviour and appearance self.set_headers_visible(False) selection = self.get_selection() selection.set_mode(Gtk.SelectionMode.SINGLE) self.set_size_request(100, 100) # Type column cell = Gtk.CellRendererPixbuf() col = Gtk.TreeViewColumn(_("Type")) col.pack_start(cell, expand=False) datafunc = layer_type_pixbuf_datafunc col.set_cell_data_func(cell, datafunc) col.set_sizing(Gtk.TreeViewColumnSizing.FIXED) self._type_col = col # Name column cell = Gtk.CellRendererText() cell.set_property("ellipsize", Pango.EllipsizeMode.END) col = Gtk.TreeViewColumn(_("Name")) col.pack_start(cell, expand=True) datafunc = layer_name_text_datafunc col.set_cell_data_func(cell, datafunc) col.set_expand(True) col.set_min_width(48) col.set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE) self._name_col = col # Visibility column cell = Gtk.CellRendererPixbuf() col = Gtk.TreeViewColumn(_("Visible")) col.pack_start(cell, expand=False) datafunc = layer_visible_pixbuf_datafunc col.set_cell_data_func(cell, datafunc) col.set_sizing(Gtk.TreeViewColumnSizing.FIXED) self._visible_col = col # Locked column cell = Gtk.CellRendererPixbuf() col = Gtk.TreeViewColumn(_("Locked")) col.pack_start(cell, expand=False) datafunc = layer_locked_pixbuf_datafunc col.set_cell_data_func(cell, datafunc) col.set_sizing(Gtk.TreeViewColumnSizing.FIXED) self._locked_col = col # Column order on screen self.append_column(self._visible_col) self.append_column(self._locked_col) self.append_column(self._name_col) self.append_column(self._type_col) # View appearance self.set_show_expanders(True) self.set_enable_tree_lines(True) self.set_expander_column(self._name_col)
def on_module_selected(self): if not self.loaded: print "Loading Backgrounds module" self.sidePage.stack = SettingsStack() self.sidePage.add_widget(self.sidePage.stack) self.shown_collection = None # Which collection is displayed in the UI self._background_schema = Gio.Settings( schema="org.cinnamon.desktop.background") self._slideshow_schema = Gio.Settings( schema="org.cinnamon.desktop.background.slideshow") self._slideshow_schema.connect("changed::slideshow-enabled", self.on_slideshow_enabled_changed) self.add_folder_dialog = Gtk.FileChooserDialog( title=_("Add Folder"), action=Gtk.FileChooserAction.SELECT_FOLDER, buttons=(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, Gtk.ResponseType.OK)) self.xdg_pictures_directory = os.path.expanduser("~/Pictures") xdg_config = os.path.expanduser("~/.config/user-dirs.dirs") if os.path.exists(xdg_config) and os.path.exists( "/usr/bin/xdg-user-dir"): path = subprocess.check_output(["xdg-user-dir", "PICTURES"]).rstrip("\n") if os.path.exists(path): self.xdg_pictures_directory = path self.get_user_backgrounds() # Images mainbox = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 2) mainbox.expand = True mainbox.set_border_width(8) self.sidePage.stack.add_titled(mainbox, "images", _("Images")) left_vbox = Gtk.Box.new(Gtk.Orientation.VERTICAL, 0) right_vbox = Gtk.Box.new(Gtk.Orientation.VERTICAL, 0) folder_scroller = Gtk.ScrolledWindow.new(None, None) folder_scroller.set_shadow_type(Gtk.ShadowType.IN) folder_scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) folder_scroller.set_property("min-content-width", 150) self.folder_tree = Gtk.TreeView.new() self.folder_tree.set_headers_visible(False) folder_scroller.add(self.folder_tree) button_toolbar = Gtk.Toolbar.new() button_toolbar.set_icon_size(1) Gtk.StyleContext.add_class( Gtk.Widget.get_style_context(button_toolbar), "inline-toolbar") self.add_folder_button = Gtk.ToolButton.new(None, None) self.add_folder_button.set_icon_name("list-add-symbolic") self.add_folder_button.set_tooltip_text(_("Add new folder")) self.add_folder_button.connect("clicked", lambda w: self.add_new_folder()) self.remove_folder_button = Gtk.ToolButton.new(None, None) self.remove_folder_button.set_icon_name("list-remove-symbolic") self.remove_folder_button.set_tooltip_text( _("Remove selected folder")) self.remove_folder_button.connect("clicked", lambda w: self.remove_folder()) button_toolbar.insert(self.add_folder_button, 0) button_toolbar.insert(self.remove_folder_button, 1) image_scroller = Gtk.ScrolledWindow.new(None, None) image_scroller.set_shadow_type(Gtk.ShadowType.IN) image_scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) self.icon_view = ThreadedIconView() image_scroller.add(self.icon_view) self.icon_view.connect("selection-changed", self.on_wallpaper_selection_changed) right_vbox.pack_start(image_scroller, True, True, 0) left_vbox.pack_start(folder_scroller, True, True, 0) left_vbox.pack_start(button_toolbar, False, False, 0) mainbox.pack_start(left_vbox, False, False, 2) mainbox.pack_start(right_vbox, True, True, 2) left_vbox.set_border_width(2) right_vbox.set_border_width(2) self.collection_store = Gtk.ListStore( bool, # is separator str, # Icon name str, # Display name str, # Path str) # Type of collection cell = Gtk.CellRendererText() cell.set_alignment(0, 0) pb_cell = Gtk.CellRendererPixbuf() self.folder_column = Gtk.TreeViewColumn() self.folder_column.pack_start(pb_cell, False) self.folder_column.pack_start(cell, True) self.folder_column.add_attribute(pb_cell, "icon-name", 1) self.folder_column.add_attribute(cell, "text", 2) self.folder_column.set_alignment(0) self.folder_tree.append_column(self.folder_column) self.folder_tree.connect("cursor-changed", self.on_folder_source_changed) self.get_system_backgrounds() tree_separator = [True, None, None, None, None] self.collection_store.append(tree_separator) if len(self.user_backgrounds) > 0: for item in self.user_backgrounds: self.collection_store.append(item) self.folder_tree.set_model(self.collection_store) self.folder_tree.set_row_separator_func(self.is_row_separator, None) self.get_initial_path() # Settings page = SettingsPage() settings = page.add_section(_("Background Settings")) size_group = Gtk.SizeGroup.new(Gtk.SizeGroupMode.HORIZONTAL) self.sidePage.stack.add_titled(page, "settings", _("Settings")) widget = GSettingsSwitch( _("Play backgrounds as a slideshow"), "org.cinnamon.desktop.background.slideshow", "slideshow-enabled") settings.add_row(widget) widget = GSettingsSpinButton( _("Delay"), "org.cinnamon.desktop.background.slideshow", "delay", _("minutes"), 1, 1440) settings.add_reveal_row( widget, "org.cinnamon.desktop.background.slideshow", "slideshow-enabled") widget = GSettingsSwitch( _("Play images in random order"), "org.cinnamon.desktop.background.slideshow", "random-order") settings.add_reveal_row( widget, "org.cinnamon.desktop.background.slideshow", "slideshow-enabled") widget = GSettingsComboBox(_("Picture aspect"), "org.cinnamon.desktop.background", "picture-options", BACKGROUND_PICTURE_OPTIONS, size_group=size_group) settings.add_row(widget) widget = GSettingsComboBox(_("Background gradient"), "org.cinnamon.desktop.background", "color-shading-type", BACKGROUND_COLOR_SHADING_TYPES, size_group=size_group) settings.add_reveal_row(widget, "org.cinnamon.desktop.background", "picture-options", PICTURE_OPTIONS_NEEDS_COLOR) widget = GSettingsColorChooser(_("Gradient start color"), "org.cinnamon.desktop.background", "primary-color", legacy_string=True, size_group=size_group) settings.add_reveal_row(widget, "org.cinnamon.desktop.background", "picture-options", PICTURE_OPTIONS_NEEDS_COLOR) self._background_schema.connect("changed::picture-options", self.update_secondary_revealer) self._background_schema.connect("changed::color-shading-type", self.update_secondary_revealer) widget = GSettingsColorChooser(_("Gradient end color"), "org.cinnamon.desktop.background", "secondary-color", legacy_string=True, size_group=size_group) self.secondary_color_revealer = settings.add_reveal_row(widget) self.update_secondary_revealer(self._background_schema, None)
def init_vmlist(self): vmlist = self.widget("vm-list") self.widget("vm-notebook").set_show_tabs(False) rowtypes = [] rowtypes.insert(ROW_HANDLE, object) # backing object rowtypes.insert(ROW_SORT_KEY, str) # object name rowtypes.insert(ROW_MARKUP, str) # row markup text rowtypes.insert(ROW_STATUS_ICON, str) # status icon name rowtypes.insert(ROW_HINT, str) # row tooltip rowtypes.insert(ROW_IS_CONN, bool) # if object is a connection rowtypes.insert(ROW_IS_CONN_CONNECTED, bool) # if conn is connected rowtypes.insert(ROW_IS_VM, bool) # if row is VM rowtypes.insert(ROW_IS_VM_RUNNING, bool) # if VM is running rowtypes.insert(ROW_COLOR, str) # row markup color string rowtypes.insert(ROW_INSPECTION_OS_ICON, GdkPixbuf.Pixbuf) # OS icon model = Gtk.TreeStore(*rowtypes) vmlist.set_model(model) vmlist.set_tooltip_column(ROW_HINT) vmlist.set_headers_visible(True) vmlist.set_level_indentation( -(_style_get_prop(vmlist, "expander-size") + 3)) nameCol = Gtk.TreeViewColumn(_("Name")) nameCol.set_expand(True) nameCol.set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE) nameCol.set_spacing(6) nameCol.set_sort_column_id(COL_NAME) vmlist.append_column(nameCol) status_icon = Gtk.CellRendererPixbuf() status_icon.set_property("stock-size", Gtk.IconSize.DND) nameCol.pack_start(status_icon, False) nameCol.add_attribute(status_icon, 'icon-name', ROW_STATUS_ICON) nameCol.add_attribute(status_icon, 'visible', ROW_IS_VM) inspection_os_icon = Gtk.CellRendererPixbuf() nameCol.pack_start(inspection_os_icon, False) nameCol.add_attribute(inspection_os_icon, 'pixbuf', ROW_INSPECTION_OS_ICON) nameCol.add_attribute(inspection_os_icon, 'visible', ROW_IS_VM) name_txt = Gtk.CellRendererText() nameCol.pack_start(name_txt, True) nameCol.add_attribute(name_txt, 'markup', ROW_MARKUP) nameCol.add_attribute(name_txt, 'foreground', ROW_COLOR) self.spacer_txt = Gtk.CellRendererText() self.spacer_txt.set_property("ypad", 4) self.spacer_txt.set_property("visible", False) nameCol.pack_end(self.spacer_txt, False) def make_stats_column(title, colnum): col = Gtk.TreeViewColumn(title) col.set_min_width(140) txt = Gtk.CellRendererText() txt.set_property("ypad", 4) col.pack_start(txt, True) col.add_attribute(txt, 'visible', ROW_IS_CONN) img = CellRendererSparkline() img.set_property("xpad", 6) img.set_property("ypad", 12) img.set_property("reversed", True) col.pack_start(img, True) col.add_attribute(img, 'visible', ROW_IS_VM) col.set_sort_column_id(colnum) vmlist.append_column(col) return col self.guestcpucol = make_stats_column(_("CPU usage"), COL_GUEST_CPU) self.hostcpucol = make_stats_column(_("Host CPU usage"), COL_HOST_CPU) self.memcol = make_stats_column(_("Memory usage"), COL_MEM) self.diskcol = make_stats_column(_("Disk I/O"), COL_DISK) self.netcol = make_stats_column(_("Network I/O"), COL_NETWORK) model.set_sort_func(COL_NAME, self.vmlist_name_sorter) model.set_sort_func(COL_GUEST_CPU, self.vmlist_guest_cpu_usage_sorter) model.set_sort_func(COL_HOST_CPU, self.vmlist_host_cpu_usage_sorter) model.set_sort_func(COL_MEM, self.vmlist_memory_usage_sorter) model.set_sort_func(COL_DISK, self.vmlist_disk_io_sorter) model.set_sort_func(COL_NETWORK, self.vmlist_network_usage_sorter) model.set_sort_column_id(COL_NAME, Gtk.SortType.ASCENDING)
def build_columns(self): """ Builds the columns and inserts them into the TreeView. Any previous columns exist, they will be in the self.columns array, and removed. """ # remove any existing columns, which would be stored in # self.columns list(map(self.tree.remove_column, self.columns)) self.columns = [] self.setup_editable_col() # loop through the values returned by column_order for pair in self.column_order(): # if the first value isn't 1, then we skip the values if not pair[0]: continue # extract the name from the _column_names variable, and # assign it to the column name. The text value is extracted # from the model column specified in pair[1] name = self._column_names[pair[1]][0] col_icon = self._column_names[pair[1]][5] model_col = self._column_names[pair[1]][1] type_col = self._column_names[pair[1]][3] if (type_col in [TEXT_COL, MARKUP_COL, TEXT_EDIT_COL]): renderer = Gtk.CellRendererText() renderer.set_property('ellipsize', Pango.EllipsizeMode.END) if type_col == TEXT_COL or type_col == TEXT_EDIT_COL: column = Gtk.TreeViewColumn(name, renderer, text=pair[1]) else: column = Gtk.TreeViewColumn(name, renderer, markup=pair[1]) if not self._column_names[pair[1]][4] == -1: #apply weight attribute column.add_attribute(renderer, "weight", self._column_names[pair[1]][4]) #set up editable if type_col == TEXT_EDIT_COL: #model col must have functions defined callbacks = self.edit_col_funcs[model_col] for renderer in column.get_cells(): renderer.set_property('editable', not self.dbstate.db.readonly) renderer.connect('editing_started', callbacks['edit_start'], model_col) renderer.connect('edited', callbacks['edited'], model_col) elif self._column_names[pair[1]][3] == ICON_COL: self.col_icons[pair[1]] = col_icon self.pb_renderer = Gtk.CellRendererPixbuf() column = Gtk.TreeViewColumn(name, self.pb_renderer) column.set_cell_data_func(self.pb_renderer, self.icon_func, pair[1]) else: raise NotImplementedError( 'Unknown column type: %s, with column name %s' % (type_col, self._column_names[pair[1]][3])) if col_icon is not None: image = Gtk.Image() image.set_from_stock(col_icon, Gtk.IconSize.MENU) image.set_tooltip_text(name) image.show() column.set_widget(image) column.set_resizable(False) else: # insert the colum into the tree column.set_resizable(True) column.set_clickable(True) column.set_sizing(Gtk.TreeViewColumnSizing.FIXED) #column.set_min_width(self._column_names[pair[1]][2]) column.set_fixed_width(self._column_names[pair[1]][2]) column.set_sort_column_id(self._column_names[pair[1]][1]) self.columns.append(column) self.tree.append_column(column) self.track_ref_for_deletion("columns")
def __init__(self, basePath): Gtk.Window.__init__(self, title=(_("Search")), icon_name="edit-find", default_height=400, default_width=650) self.connect("destroy", self.quit) self.search = None self.results = Gtk.ListStore(str, str, str) mainBox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, border_width=10) self.add(mainBox) contentBox = Gtk.Box(border_width=0) mainBox.pack_start(contentBox, True, True, 0) ## left pane leftPane = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, border_width=10) contentBox.pack_start(leftPane, False, False, 0) # search box self.searchBox = SearchBox(self.startSearch) leftPane.pack_start(self.searchBox, False, False, 5) # location selector leftPane.pack_start(Gtk.Label(_("Start in"), halign=Gtk.Align.START), False, False, 5) self.location = Gtk.FileChooserButton.new( _("Select a folder"), Gtk.FileChooserAction.SELECT_FOLDER) leftPane.add(self.location) if not basePath is None: self.location.set_filename(basePath) # follow symlinks self.symlinks = Gtk.CheckButton.new_with_label(_("Follow symlinks")) leftPane.add(self.symlinks) # display hidden files/folders self.hidden = Gtk.CheckButton.new_with_label(_("Search hidden")) leftPane.add(self.hidden) # use regex self.regex = Gtk.CheckButton.new_with_label( _("Use regular expressions")) leftPane.add(self.regex) # stop button self.stopButton = Gtk.Button(label=(_("Stop")), sensitive=False) leftPane.pack_end(self.stopButton, False, False, 5) self.stopButton.connect("clicked", self.stopSearch) ## right pane rightPane = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, border_width=10) contentBox.pack_start(rightPane, True, True, 0) # results display tree scrollBox = Gtk.ScrolledWindow() rightPane.pack_start(scrollBox, True, True, 5) tree = Gtk.TreeView(self.results) scrollBox.add(tree) fileNameColumn = Gtk.TreeViewColumn() fileNameColumn.set_title(_("File")) fileNameColumn.set_resizable(True) fileNameColumn.set_sizing(Gtk.TreeViewColumnSizing.FIXED) fileNameColumn.set_fixed_width(200) fileNameColumn.set_min_width(200) tree.append_column(fileNameColumn) iconRenderer = Gtk.CellRendererPixbuf() fileNameColumn.pack_start(iconRenderer, expand=False) fileNameColumn.add_attribute(iconRenderer, "icon-name", 0) fileNameRenderer = Gtk.CellRendererText( ellipsize=Pango.EllipsizeMode.END) fileNameColumn.pack_start(fileNameRenderer, expand=False) fileNameColumn.add_attribute(fileNameRenderer, "text", 1) pathRenderer = Gtk.CellRendererText() pathColumn = Gtk.TreeViewColumn(_("Path"), pathRenderer, text=2) pathColumn.set_resizable(True) tree.append_column(pathColumn) # context menu Context(tree) tree.connect("row-activated", self.launchItem) # status text hbox = Gtk.Box() mainBox.pack_start(hbox, False, False, 0) self.currentLabel = Gtk.Label() self.currentLabel.set_ellipsize(Pango.EllipsizeMode.END) hbox.pack_start(self.currentLabel, False, False, 5) self.show_all()
def __init__(self, adapter=None, inst=None): cr = Gtk.CellRendererText() cr.props.ellipsize = Pango.EllipsizeMode.END tabledata = [ # device picture { "id": "device_surface", "type": str, "renderer": Gtk.CellRendererPixbuf(), "render_attrs": {}, "celldata_func": (self._set_device_cell_data, None) }, # device caption { "id": "caption", "type": str, "renderer": cr, "render_attrs": { "markup": 1 }, "view_props": { "expand": True } }, { "id": "rssi_pb", "type": GdkPixbuf.Pixbuf, "renderer": Gtk.CellRendererPixbuf(), "render_attrs": { "pixbuf": 2 }, "view_props": { "spacing": 0 } }, { "id": "lq_pb", "type": GdkPixbuf.Pixbuf, "renderer": Gtk.CellRendererPixbuf(), "render_attrs": { "pixbuf": 3 }, "view_props": { "spacing": 0 } }, { "id": "tpl_pb", "type": GdkPixbuf.Pixbuf, "renderer": Gtk.CellRendererPixbuf(), "render_attrs": { "pixbuf": 4 }, "view_props": { "spacing": 0 } }, { "id": "alias", "type": str }, # used for quick access instead of device.GetProperties { "id": "connected", "type": bool }, # used for quick access instead of device.GetProperties { "id": "paired", "type": bool }, # used for quick access instead of device.GetProperties { "id": "trusted", "type": bool }, # used for quick access instead of device.GetProperties { "id": "objpush", "type": bool }, # used to set Send File button { "id": "rssi", "type": float }, { "id": "lq", "type": float }, { "id": "tpl", "type": float }, { "id": "icon_info", "type": Gtk.IconInfo }, { "id": "cell_fader", "type": GObject.TYPE_PYOBJECT }, { "id": "row_fader", "type": GObject.TYPE_PYOBJECT }, { "id": "levels_visible", "type": bool }, { "id": "initial_anim", "type": bool }, ] super().__init__(adapter, tabledata) self.set_name("ManagerDeviceList") self.set_headers_visible(False) self.props.has_tooltip = True self.Blueman = inst self.Config = Config("org.blueman.general") self.Config.connect('changed', self._on_settings_changed) # Set the correct sorting self._on_settings_changed(self.Config, "sort-by") self._on_settings_changed(self.Config, "sort-type") self.connect("query-tooltip", self.tooltip_query) self.tooltip_row = None self.tooltip_col = None self.connect("button_press_event", self.on_event_clicked) self.connect("button_release_event", self.on_event_clicked) self.menu = None self.connect("drag_data_received", self.drag_recv) self.connect("drag-motion", self.drag_motion) Gtk.Widget.drag_dest_set(self, Gtk.DestDefaults.ALL, [], Gdk.DragAction.COPY | Gdk.DragAction.DEFAULT) Gtk.Widget.drag_dest_add_uri_targets(self) self.set_search_equal_func(self.search_func, None) self._faderhandler: Optional[int] = None
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 _init_widgets(self): # Preload the images self._preload_icons() # Top label ui_label = self._create_label( _T("List of available translators:\n(click on the second column to change the loading state of the translators)" )) self._insert_row(ui_label, None, False) # List of translators self._ui_translator_list = Gtk.ListStore(GdkPixbuf.Pixbuf.__gtype__, GdkPixbuf.Pixbuf.__gtype__, str, str) self._ui_translator_list_widget = Gtk.TreeView() self._ui_translator_list_widget.set_model(self._ui_translator_list) if self._is_document_level: label1 = _T('usr') self._clickable_column_label = _T('doc') else: label1 = 'sys' self._clickable_column_label = _T('usr') column = Gtk.TreeViewColumn(label1, Gtk.CellRendererPixbuf(), pixbuf=0) self._ui_translator_list_widget.append_column(column) column = Gtk.TreeViewColumn(self._clickable_column_label, Gtk.CellRendererPixbuf(), pixbuf=1) self._ui_translator_list_widget.append_column(column) column = Gtk.TreeViewColumn(_T("name"), Gtk.CellRendererText(), text=2) self._ui_translator_list_widget.append_column(column) column = Gtk.TreeViewColumn(_T("description"), Gtk.CellRendererText(), text=3) self._ui_translator_list_widget.append_column(column) self._ui_translator_list_widget.set_headers_clickable(False) self._ui_translator_list_widget.set_headers_visible(True) # Scrolling pane for translator list ui_translator_list_scroll = self._create_scroll_for( self._ui_translator_list_widget) # Management buttons ui_right_toolbar = Gtk.Box(False, 5) ui_right_toolbar.set_property('orientation', Gtk.Orientation.VERTICAL) ui_right_toolbar.set_property('hexpand', False) ui_right_toolbar.set_property('vexpand', True) # Button "New" self._ui_button_new_translator = Gtk.Button.new_from_stock( Gtk.STOCK_NEW) ui_right_toolbar.add(self._ui_button_new_translator) # Button "Import" self._ui_button_import_translator = Gtk.Button(_T("Import")) ui_right_toolbar.add(self._ui_button_import_translator) # Button "Delete" self._ui_button_delete_translator = Gtk.Button.new_from_stock( Gtk.STOCK_DELETE) self._ui_button_delete_translator.set_sensitive(False) ui_right_toolbar.add(self._ui_button_delete_translator) # Separator ui_separator = Gtk.Separator() ui_separator.set_orientation(Gtk.Orientation.HORIZONTAL) ui_right_toolbar.add(ui_separator) # Help - Part 1 if self._is_document_level: label1 = _T('Current user') label2 = _T('Current document') else: label1 = _T('All users') label2 = _T('Current user') ui_right_toolbar.add(self._make_legend(self._get_level_icon(0), label1)) ui_right_toolbar.add(self._make_legend(self._get_level_icon(1), label2)) # Separator ui_separator = Gtk.Separator() ui_separator.set_orientation(Gtk.Orientation.HORIZONTAL) ui_right_toolbar.add(ui_separator) # Help - Part 2 ui_right_toolbar.add( self._make_legend(self._get_level_icon(1), _T('Loaded, no conflict'))) ui_right_toolbar.add( self._make_legend(self._get_level_icon(1, _IconType.CONFLICT), _T('Loaded, conflict'))) ui_right_toolbar.add( self._make_legend(self._get_level_icon(1, _IconType.EXCLUDED), _T('Not loaded'))) ui_right_toolbar.add( self._make_legend(self._get_level_icon(1, _IconType.INHERITED), _T('Unspecified, no conflict'))) ui_right_toolbar.add( self._make_legend( self._get_level_icon(1, _IconType.INHERITED_CONFLICT), _T('Unspecified, conflict'))) # Add the list and the toolbar self._insert_row(ui_translator_list_scroll, ui_right_toolbar, False)
def new_view(cls, coltypes, colparams, islist=True, withscroll=False): """Создаёт Gtk.TreeView, Gtk.ListStore|TreeStore и т.п. динамически. coltypes - список или кортеж типов значений для Gtk.ListStore; cols - список или кортеж параметров столбцов, где элементы - экземпляры TreeViewer.Column; withscroll - булевское значение, True, если нужно создать экземпляр Gtk.ScrolledWindow и поместить TreeView туда.""" store = (Gtk.ListStore if islist else Gtk.TreeStore)(*coltypes) tv = Gtk.TreeView.new_with_model(store) tvsh = cls(tv) if withscroll: tvsh.scroll = Gtk.ScrolledWindow() tvsh.scroll.add(tv) tvsh.scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) tvsh.scroll.set_overlay_scrolling(False) tvsh.scroll.set_shadow_type(Gtk.ShadowType.IN) tvsh.widget = tvsh.scroll ncols = len(coltypes) for colparam in colparams: col = Gtk.TreeViewColumn.new() #self.columns.append(col) for cix, cell in enumerate(colparam.cells, 1): if cell.index < 0 or cell.index >= ncols: raise IndexError('%s.new_list(): Cell.index out of range' % cls.__class__.__name__) ctype = coltypes[cell.index] if ctype == GObject.TYPE_BOOLEAN: crt = Gtk.CellRendererToggle() crtpar = 'active' elif ctype == GObject.TYPE_STRING: crt = Gtk.CellRendererText() #!!! crt.props.xalign = cell.align if cell.expand: crt.props.ellipsize = Pango.EllipsizeMode.END else: crt.props.ellipsize = Pango.EllipsizeMode.NONE crt.props.editable = cell.editable crtpar = 'text' if not cell.markup else 'markup' elif ctype == Pixbuf: crt = Gtk.CellRendererPixbuf() crt.props.xalign = cell.align crtpar = 'pixbuf' else: raise ValueError('%s.new_list(): unsupported Gtk.%s column #%d data type' % ( cls.__class__.__name__, store.__class__.__name__, cix)) col.pack_start(crt, cell.expand) col.add_attribute(crt, crtpar, cell.index) tvsh.view.append_column(col) col.set_title(colparam.title) col.set_sizing(Gtk.TreeViewColumnSizing.GROW_ONLY) col.set_resizable(colparam.expand) col.set_expand(colparam.expand) #tvsh.colmap[col] = colparam.tooltip return tvsh
def __init__(self, library): super(InternetRadio, self).__init__(spacing=12) self.set_orientation(Gtk.Orientation.VERTICAL) if not self.instances(): self._init(library) self._register_instance() self.connect('destroy', self.__destroy) completion = LibraryTagCompletion(self.__stations) self.accelerators = Gtk.AccelGroup() self.__searchbar = search = SearchBarBox(completion=completion, accel_group=self.accelerators) search.connect('query-changed', self.__filter_changed) menu = Gtk.Menu() new_item = MenuItem(_(u"_New Station…"), Icons.LIST_ADD) new_item.connect('activate', self.__add) menu.append(new_item) update_item = MenuItem(_("_Update Stations"), Icons.VIEW_REFRESH) update_item.connect('activate', self.__update) menu.append(update_item) menu.show_all() button = MenuButton(SymbolicIconImage(Icons.EMBLEM_SYSTEM, Gtk.IconSize.MENU), arrow=True) button.set_menu(menu) def focus(widget, *args): qltk.get_top_parent(widget).songlist.grab_focus() search.connect('focus-out', focus) # treeview scrolled_window = ScrolledWindow() scrolled_window.show() scrolled_window.set_shadow_type(Gtk.ShadowType.IN) self.view = view = AllTreeView() view.show() view.set_headers_visible(False) scrolled_window.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) scrolled_window.add(view) model = Gtk.ListStore(int, str, str, str) model.append( row=[self.TYPE_ALL, Icons.FOLDER, "__all", _("All Stations")]) model.append(row=[self.TYPE_SEP, Icons.FOLDER, "", ""]) #Translators: Favorite radio stations model.append( row=[self.TYPE_FAV, Icons.FOLDER, "__fav", _("Favorites")]) model.append(row=[self.TYPE_SEP, Icons.FOLDER, "", ""]) filters = self.filters for text, k in sorted([(filters.text(k), k) for k in filters.keys()]): model.append(row=[self.TYPE_FILTER, Icons.EDIT_FIND, k, text]) model.append( row=[self.TYPE_NOCAT, Icons.FOLDER, "nocat", _("No Category")]) def separator(model, iter, data): return model[iter][self.TYPE] == self.TYPE_SEP view.set_row_separator_func(separator, None) def search_func(model, column, key, iter, data): return key.lower() not in model[iter][column].lower() view.set_search_column(self.NAME) view.set_search_equal_func(search_func, None) column = Gtk.TreeViewColumn("genres") column.set_sizing(Gtk.TreeViewColumnSizing.FIXED) renderpb = Gtk.CellRendererPixbuf() renderpb.props.xpad = 3 column.pack_start(renderpb, False) column.add_attribute(renderpb, "icon-name", self.ICON_NAME) render = Gtk.CellRendererText() render.set_property('ellipsize', Pango.EllipsizeMode.END) view.append_column(column) column.pack_start(render, True) column.add_attribute(render, "text", self.NAME) view.set_model(model) # selection selection = view.get_selection() selection.set_mode(Gtk.SelectionMode.MULTIPLE) self.__changed_sig = connect_destroy( selection, 'changed', util.DeferredSignal(lambda x: self.activate())) box = Gtk.HBox(spacing=6) box.pack_start(search, True, True, 0) box.pack_start(button, False, True, 0) self._searchbox = Align(box, left=0, right=6, top=6) self._searchbox.show_all() def qbar_response(infobar, response_id): if response_id == infobar.RESPONSE_LOAD: self.__update() self.qbar = QuestionBar() self.qbar.connect("response", qbar_response) if self._is_library_empty(): self.qbar.show() pane = qltk.ConfigRHPaned("browsers", "internetradio_pos", 0.4) pane.show() pane.pack1(scrolled_window, resize=False, shrink=False) songbox = Gtk.VBox(spacing=6) songbox.pack_start(self._searchbox, False, True, 0) self._songpane_container = Gtk.VBox() self._songpane_container.show() songbox.pack_start(self._songpane_container, True, True, 0) songbox.pack_start(self.qbar, False, True, 0) songbox.show() pane.pack2(songbox, resize=True, shrink=False) self.pack_start(pane, True, True, 0) self.show()
def _init_ui(self): # pylint: disable=redefined-variable-type blue = Gdk.color_parse("#0072A8") self.widget("header").modify_bg(Gtk.StateType.NORMAL, blue) self.widget("snapshot-notebook").set_show_tabs(False) buf = Gtk.TextBuffer() buf.connect("changed", self._description_changed) self.widget("snapshot-description").set_buffer(buf) buf = Gtk.TextBuffer() self.widget("snapshot-new-description").set_buffer(buf) # [name, row label, tooltip, icon name, sortname, current] model = Gtk.ListStore(str, str, str, str, str, bool) model.set_sort_column_id(4, Gtk.SortType.ASCENDING) col = Gtk.TreeViewColumn("") col.set_min_width(150) col.set_spacing(6) img = Gtk.CellRendererPixbuf() img.set_property("stock-size", Gtk.IconSize.LARGE_TOOLBAR) col.pack_start(img, False) col.add_attribute(img, 'icon-name', 3) txt = Gtk.CellRendererText() txt.set_property("ellipsize", Pango.EllipsizeMode.END) col.pack_start(txt, False) col.add_attribute(txt, 'markup', 1) img = Gtk.CellRendererPixbuf() img.set_property("stock-size", Gtk.IconSize.MENU) img.set_property("icon-name", Gtk.STOCK_APPLY) img.set_property("xalign", 0.0) col.pack_start(img, False) col.add_attribute(img, "visible", 5) def _sep_cb(_model, _iter, ignore): return not bool(_model[_iter][0]) slist = self.widget("snapshot-list") slist.set_model(model) slist.set_tooltip_column(2) slist.append_column(col) slist.set_row_separator_func(_sep_cb, None) # Snapshot popup menu menu = Gtk.Menu() item = Gtk.ImageMenuItem.new_with_label(_("_Start snapshot")) item.set_use_underline(True) img = Gtk.Image() img.set_from_stock(Gtk.STOCK_MEDIA_PLAY, Gtk.IconSize.MENU) item.set_image(img) item.show() item.connect("activate", self._on_start_clicked) menu.add(item) item = Gtk.ImageMenuItem.new_with_label(_("_Delete snapshot")) item.set_use_underline(True) img = Gtk.Image() img.set_from_stock(Gtk.STOCK_DELETE, Gtk.IconSize.MENU) item.set_image(img) item.show() item.connect("activate", self._on_delete_clicked) menu.add(item) self._snapmenu = menu
def __init__(self): Tab.__init__(self) window = component.get("MainWindow") glade = window.get_glade() self._name = "Files" self._child_widget = glade.get_object("files_tab") self._tab_label = glade.get_object("files_tab_label") self.listview = glade.get_object("files_listview") # filename, size, progress string, progress value, priority, file index, icon id self.treestore = Gtk.TreeStore(str, GObject.TYPE_UINT64, str, float, int, int, str) # We need to store the row that's being edited to prevent updating it until # it's been done editing self._editing_index = None # Filename column self.filename_column_name = _("Filename") column = Gtk.TreeViewColumn(self.filename_column_name) render = Gtk.CellRendererPixbuf() column.pack_start(render, False) column.add_attribute(render, "stock-id", 6) render = Gtk.CellRendererText() render.set_property("editable", True) render.connect("edited", self._on_filename_edited) render.connect("editing-started", self._on_filename_editing_start) render.connect("editing-canceled", self._on_filename_editing_canceled) column.pack_start(render, True) column.add_attribute(render, "text", 0) column.set_sort_column_id(0) column.set_clickable(True) column.set_resizable(True) column.set_expand(False) column.set_min_width(200) column.set_reorderable(True) self.listview.append_column(column) # Size column column = Gtk.TreeViewColumn(_("Size")) render = Gtk.CellRendererText() column.pack_start(render, False) column.set_cell_data_func(render, deluge.ui.gtkui.listview.cell_data_size, 1) column.set_sort_column_id(1) column.set_clickable(True) column.set_resizable(True) column.set_expand(False) column.set_min_width(50) column.set_reorderable(True) self.listview.append_column(column) # Progress column column = Gtk.TreeViewColumn(_("Progress")) render = Gtk.CellRendererProgress() column.pack_start(render, True) column.set_cell_data_func(render, cell_progress, (2, 3)) column.set_sort_column_id(3) column.set_clickable(True) column.set_resizable(True) column.set_expand(False) column.set_min_width(100) column.set_reorderable(True) self.listview.append_column(column) # Priority column column = Gtk.TreeViewColumn(_("Priority")) render = Gtk.CellRendererPixbuf() column.pack_start(render, False) column.set_cell_data_func(render, cell_priority_icon, 4) render = Gtk.CellRendererText() column.pack_start(render, False) column.set_cell_data_func(render, cell_priority, 4) column.set_sort_column_id(4) column.set_clickable(True) column.set_resizable(True) column.set_expand(False) column.set_min_width(100) # Bugfix: Last column needs max_width set to stop scrollbar appearing column.set_max_width(200) column.set_reorderable(True) self.listview.append_column(column) self.listview.set_model(self.treestore) self.listview.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE) self.file_menu = glade.get_object("menu_file_tab") self.file_menu_priority_items = [ glade.get_object("menuitem_donotdownload"), glade.get_object("menuitem_normal"), glade.get_object("menuitem_high"), glade.get_object("menuitem_highest"), glade.get_object("menuitem_priority_sep") ] self.localhost_widgets = [ glade.get_object("menuitem_open_file"), glade.get_object("menuitem3") ] self.listview.connect("row-activated", self._on_row_activated) self.listview.connect("key-press-event", self._on_key_press_event) self.listview.connect("button-press-event", self._on_button_press_event) self.listview.enable_model_drag_source( Gdk.ModifierType.BUTTON1_MASK, [('text/plain', 0, 0)], Gdk.DragAction.DEFAULT | Gdk.DragAction.MOVE) self.listview.enable_model_drag_dest([('text/plain', 0, 0)], Gdk.DragAction.DEFAULT) self.listview.connect("drag_data_get", self._on_drag_data_get_data) self.listview.connect("drag_data_received", self._on_drag_data_received_data) window.insert_signals({ "on_menuitem_open_file_activate": self._on_menuitem_open_file_activate, "on_menuitem_donotdownload_activate": self._on_menuitem_donotdownload_activate, "on_menuitem_normal_activate": self._on_menuitem_normal_activate, "on_menuitem_high_activate": self._on_menuitem_high_activate, "on_menuitem_highest_activate": self._on_menuitem_highest_activate, "on_menuitem_expand_all_activate": self._on_menuitem_expand_all_activate }) # Connect to various events from the daemon client.register_event_handler("TorrentFileRenamedEvent", self._on_torrentfilerenamed_event) client.register_event_handler("TorrentFolderRenamedEvent", self._on_torrentfolderrenamed_event) client.register_event_handler("TorrentRemovedEvent", self._on_torrentremoved_event) # Attempt to load state self.load_state() # torrent_id: (filepath, size) self.files_list = {} self.torrent_id = None
def __init__(self, demoapp): self.demoapp = demoapp self.window = Gtk.Window() self.window.set_title('Combo boxes') self.window.set_border_width(10) self.window.connect('destroy', lambda w: Gtk.main_quit()) vbox = Gtk.VBox(homogeneous=False, spacing=2) self.window.add(vbox) frame = Gtk.Frame(label='Some stock icons') vbox.pack_start(frame, False, False, 0) box = Gtk.VBox(homogeneous=False, spacing=0) box.set_border_width(5) frame.add(box) model = self.create_stock_icon_store() combo = Gtk.ComboBox(model=model) box.add(combo) renderer = Gtk.CellRendererPixbuf() combo.pack_start(renderer, False) # FIXME: override set_attributes combo.add_attribute(renderer, 'pixbuf', PIXBUF_COL) combo.set_cell_data_func(renderer, self.set_sensitive, None) renderer = Gtk.CellRendererText() combo.pack_start(renderer, True) combo.add_attribute(renderer, 'text', TEXT_COL) combo.set_cell_data_func(renderer, self.set_sensitive, None) combo.set_row_separator_func(self.is_separator, None) combo.set_active(0) # a combobox demonstrating trees frame = Gtk.Frame(label='Where are we ?') vbox.pack_start(frame, False, False, 0) box = Gtk.VBox(homogeneous=False, spacing=0) box.set_border_width(5) frame.add(box) model = self.create_capital_store() combo = Gtk.ComboBox(model=model) box.add(combo) renderer = Gtk.CellRendererText() combo.pack_start(renderer, True) combo.add_attribute(renderer, 'text', 0) combo.set_cell_data_func(renderer, self.is_capital_sensistive, None) path = Gtk.TreePath('0:8') treeiter = model.get_iter(path) combo.set_active_iter(treeiter) # A GtkComboBoxEntry with validation. frame = Gtk.Frame(label='Editable') vbox.pack_start(frame, False, False, 0) box = Gtk.VBox(homogeneous=False, spacing=0) box.set_border_width(5) frame.add(box) combo = Gtk.ComboBoxText.new_with_entry() self.fill_combo_entry(combo) box.add(combo) entry = MaskEntry(mask='^([0-9]*|One|Two|2\302\275|Three)$') Gtk.Container.remove(combo, combo.get_child()) combo.add(entry) # A combobox with string IDs frame = Gtk.Frame(label='String IDs') vbox.pack_start(frame, False, False, 0) box = Gtk.VBox(homogeneous=False, spacing=0) box.set_border_width(5) frame.add(box) # FIXME: model is not setup when constructing Gtk.ComboBoxText() # so we call new() - Gtk should fix this to setup the model # in __init__, not in the constructor combo = Gtk.ComboBoxText.new() combo.append('never', 'Not visible') combo.append('when-active', 'Visible when active') combo.append('always', 'Always visible') box.add(combo) entry = Gtk.Entry() # FIXME: a bug in PyGObject does not allow us to access dynamic # methods on GObject.Object, so bind properties the hard way # GObject.Object.bind_property(combo, 'active-id', # entry, 'text', # GObject.BindingFlags.BIDIRECTIONAL) self.combo_notify_id = \ combo.connect('notify::active-id', self.combo_active_id_changed, entry) self.entry_notify_id = \ entry.connect('notify::text', self.entry_text_changed, combo) box.add(entry) self.window.show_all()
def __init__(self, application, config, wd_history): self.application = application self.config = config self.treeview = sftp_utilities.get_object( 'SFTPClient.notebook.page_stfp.' + self.treeview_name) self.notebook = sftp_utilities.get_object('SFTPClient.notebook') self.wd_history = collections.deque(wd_history, maxlen=3) self.cwd = None self.col_name = Gtk.CellRendererText() self.col_name.connect('edited', self.signal_text_edited) col_text = Gtk.CellRendererText() col_img = Gtk.CellRendererPixbuf() col = Gtk.TreeViewColumn('Files') col.pack_start(col_img, False) col.pack_start(self.col_name, True) col.add_attribute(self.col_name, 'text', 0) col.add_attribute(col_img, 'pixbuf', 1) col.set_property('resizable', True) col.set_sort_column_id(0) self.treeview.append_column(col) self.treeview.append_column( sftp_utilities.get_treeview_column('Permissions', col_text, 3, m_col_sort=3, resizable=True)) self.treeview.append_column( sftp_utilities.get_treeview_column('Size', col_text, 4, m_col_sort=5, resizable=True)) self.treeview.append_column( sftp_utilities.get_treeview_column('Date Modified', col_text, 6, m_col_sort=6, resizable=True)) self.treeview.connect('button_press_event', self.signal_tv_button_press) self.treeview.connect('key-press-event', self.signal_tv_key_press) self.treeview.connect('row-expanded', self.signal_tv_expand_row) self.treeview.connect('row-collapsed', self.signal_tv_collapse_row) self._tv_model = Gtk.TreeStore( str, # 0 base name GdkPixbuf.Pixbuf, # 1 icon str, # 2 full path str, # 3 permissions str, # 4 human readable size GTYPE_LONG, # 5 size in bytes str # 6 modified timestamp ) self._tv_model.set_sort_column_id(0, Gtk.SortType.ASCENDING) self._tv_model_filter = self._tv_model.filter_new() self._tv_model_filter.set_visible_func(self._filter_entries) self.refilter = self._tv_model_filter.refilter self._tv_model_sort = Gtk.TreeModelSort(model=self._tv_model_filter) self.treeview.set_model(self._tv_model_sort) self._wdcb_model = Gtk.ListStore(str) # working directory combobox self.wdcb_dropdown = sftp_utilities.get_object( self.working_directory_combobox_name) self.wdcb_dropdown.set_model(self._wdcb_model) self.wdcb_dropdown.set_entry_text_column(0) self.wdcb_dropdown.connect( 'changed', sftp_utilities.DelayedChangedSignal(self.signal_combo_changed)) self.show_hidden = False self._get_popup_menu()
def __init__(self, *args, **kwargs): Gtk.ApplicationWindow.__init__(self, *args, **kwargs) self.set_default_size(1024, 500) self.set_icon_name('package-x-generic') self.sfs_store = Gtk.ListStore( *map(lambda c: c[1], self.sfs_store_cols)) sw = Gtk.ScrolledWindow() vbox = Gtk.Box() vbox.set_orientation(Gtk.Orientation.VERTICAL) vbox.pack_start(sw, True, True, 0) self.add(vbox) self.tv = Gtk.TreeView(self.sfs_store) name_render = Gtk.CellRendererText() file_icon_render = Gtk.CellRendererPixbuf() update_icon_render = Gtk.CellRendererPixbuf() update_text_render = Gtk.CellRendererText() tvc = Gtk.TreeViewColumn("Mount") tvc.pack_start(file_icon_render, False) tvc.pack_start(name_render, True) tvc.set_attributes(name_render, text=self.store_col_idx('mnt')) tvc.set_attributes(file_icon_render, icon_name=self.store_col_idx('icon-name')) self.tv.append_column(tvc) self.tv.append_column( Gtk.TreeViewColumn("Backend", Gtk.CellRendererText(), text=self.store_col_idx('file-path'))) self.upd_tvc = tvc = Gtk.TreeViewColumn("Up to date") tvc.pack_start(update_icon_render, False) tvc.pack_start(update_text_render, True) update_text_render.set_property("ellipsize", Pango.EllipsizeMode.MIDDLE) tvc.set_attributes(update_icon_render, icon_name=self.store_col_idx('update-icon')) tvc.set_attributes(update_text_render, text=self.store_col_idx('update-reason')) tvc.set_resizable(True) tvc.set_min_width(300) self.tv.connect("query-tooltip", self.on_query_tooltip) self.tv.set_has_tooltip(True) self.tv.append_column(tvc) self.tv.append_column( Gtk.TreeViewColumn("Stamp", Gtk.CellRendererText(), text=self.store_col_idx('stamp'))) src_rndr = Gtk.CellRendererText() src_rndr.set_property("editable", True) src_rndr.connect("edited", self.on_store_edited, 'git-source', 'git-source-save') src_col = Gtk.TreeViewColumn("Source") src_icon_rndr = Gtk.CellRendererPixbuf() src_col.pack_start(src_icon_rndr, False) src_col.pack_start(src_rndr, True) src_col.set_attributes(src_rndr, text=self.store_col_idx('git-source')) src_col.set_cell_data_func(src_icon_rndr, self.on_render_source_icon) self.tv.append_column(src_col) self.tv.append_column( Gtk.TreeViewColumn("Commit", Gtk.CellRendererText(), text=self.store_col_idx('git-commit'))) sw.add(self.tv) buttonbox = Gtk.Box() vbox.pack_start(buttonbox, False, True, 0) self.refresh_button = Gtk.Button.new_with_label("Refresh") buttonbox.pack_start(self.refresh_button, False, False, 0) self.show_all()
def init_gui(self): self.top = Glade() window = self.top.toplevel self.set_window(window, self.top.get_object('title'), self.title) self.setup_configs('interface.removeunused', 400, 520) self.events_box = self.top.get_object('events_box') self.sources_box = self.top.get_object('sources_box') self.citations_box = self.top.get_object('citations_box') self.places_box = self.top.get_object('places_box') self.media_box = self.top.get_object('media_box') self.repos_box = self.top.get_object('repos_box') self.notes_box = self.top.get_object('notes_box') self.find_button = self.top.get_object('find_button') self.remove_button = self.top.get_object('remove_button') self.events_box.set_active(self.options.handler.options_dict['events']) self.sources_box.set_active( self.options.handler.options_dict['sources']) self.citations_box.set_active( self.options.handler.options_dict['citations']) self.places_box.set_active( self.options.handler.options_dict['places']) self.media_box.set_active(self.options.handler.options_dict['media']) self.repos_box.set_active(self.options.handler.options_dict['repos']) self.notes_box.set_active(self.options.handler.options_dict['notes']) self.warn_tree = self.top.get_object('warn_tree') self.warn_tree.connect('button_press_event', self.double_click) self.selection = self.warn_tree.get_selection() self.mark_button = self.top.get_object('mark_button') self.mark_button.connect('clicked', self.mark_clicked) self.unmark_button = self.top.get_object('unmark_button') self.unmark_button.connect('clicked', self.unmark_clicked) self.invert_button = self.top.get_object('invert_button') self.invert_button.connect('clicked', self.invert_clicked) self.real_model = Gtk.ListStore(GObject.TYPE_BOOLEAN, GObject.TYPE_STRING, GObject.TYPE_STRING, GObject.TYPE_STRING, GObject.TYPE_STRING) # a short term Gtk introspection means we need to try both ways: if hasattr(self.real_model, "sort_new_with_model"): self.sort_model = self.real_model.sort_new_with_model() else: self.sort_model = Gtk.TreeModelSort.new_with_model(self.real_model) self.warn_tree.set_model(self.sort_model) self.renderer = Gtk.CellRendererText() self.img_renderer = Gtk.CellRendererPixbuf() self.bool_renderer = Gtk.CellRendererToggle() self.bool_renderer.connect('toggled', self.selection_toggled) # Add mark column mark_column = Gtk.TreeViewColumn(_('Mark'), self.bool_renderer, active=RemoveUnused.MARK_COL) mark_column.set_sort_column_id(RemoveUnused.MARK_COL) self.warn_tree.append_column(mark_column) # Add image column img_column = Gtk.TreeViewColumn(None, self.img_renderer) img_column.set_cell_data_func(self.img_renderer, self.get_image) self.warn_tree.append_column(img_column) # Add column with object gramps_id id_column = Gtk.TreeViewColumn(_('ID'), self.renderer, text=RemoveUnused.OBJ_ID_COL) id_column.set_sort_column_id(RemoveUnused.OBJ_ID_COL) self.warn_tree.append_column(id_column) # Add column with object name name_column = Gtk.TreeViewColumn(_('Name'), self.renderer, text=RemoveUnused.OBJ_NAME_COL) name_column.set_sort_column_id(RemoveUnused.OBJ_NAME_COL) self.warn_tree.append_column(name_column) self.top.connect_signals({ "destroy_passed_object" : self.close, "on_remove_button_clicked": self.do_remove, "on_find_button_clicked" : self.find, "on_delete_event" : self.close, }) self.dc_label = self.top.get_object('dc_label') self.sensitive_list = [self.warn_tree, self.mark_button, self.unmark_button, self.invert_button, self.dc_label, self.remove_button] for item in self.sensitive_list: item.set_sensitive(False) self.show()
def procInit(self): # self.processTree=self.builder.get_object('processtree') self.processTree=g.TreeView() self.process_tab_box.add(self.processTree) self.process_tab_box.show_all() self.processTree_background=self.builder.get_object('processtreeBackground') self.process_kill_button=self.builder.get_object('processKillButton') self.process_kill_button.connect('clicked',self.kill_process) # self.data=[['chrome',30,50,0,1],['firefox',10,20,0,2],['sysmon',1,0,3,1]] # 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 self.processTreeStore=g.TreeStore(int,str,str,str,str,str,str,str,str,str,str,str,str,str,GdkPixbuf.Pixbuf) # self.processTreeStore=self.builder.get_object('processTreeStore') # for data in self.data: # self.processTreeStore.append(None,data) # self.processTreeStore.set_sort_func(4,sorting_func,None) pids=ps.pids() # self.di={} self.procDiskprev={} self.processList={} self.processTreeIterList={} self.processChildList={} self.columnList={} self.procT1={} ### total disk io counter calculation are done in proc.py self.diskTotalT1=0 diskio=ps.disk_io_counters() self.diskTotalState1=[diskio[2],diskio[3]] self.systemdId=[] self.processSystemd=[] # get systemd process sys_procs = [] for proc in ps.process_iter(): if proc.name() == "systemd" and len(proc.children())>1: sys_procs.append(proc) if len(sys_procs)>1: # process fork under user systemd for proc in sys_procs: if proc.username()!="root": self.systemdId.append(proc.pid) self.processSystemd.append(proc) searcher(self,proc,None) ## for multiple user view break elif len(sys_procs)==1: # process fork under root systemd self.systemdId.append(sys_procs[0].pid) self.processSystemd.append(sys_procs[0]) searcher(self,sys_procs[0],None) ## for multiple user view # for pi in pids: # procs=ps.Process(pi) # if(procs.username()!='root'): # if procs.name()=='systemd': # self.systemdId.append(pi) # self.processSystemd.append(procs) # searcher(self,procs,None) ## for multiple user view # # break # self.processSystemd=ps.Process(self.systemdId) # searcher(self,self.processSystemd,None) self.processTree.set_model(self.processTreeStore) # 0 1 2 3 4 5 6 7 8 9 10 11 12 13 self.column_header_list=['pid','Name','rCPU','CPU','rMemory','Memory','rDiskRead','DiskRead','rDiskWrite','DiskWrite','Resident\nMemory','Shared','Owner','Command'] self.column_select_popover_check_buttons={} self.column_header_labels=[] self.column_select_popover=g.Menu() for i,col in enumerate(self.column_header_list): renderer=g.CellRendererText() if col=='Command': renderer.props.wrap_width=-1 if col=='Name': icon_renderer=g.CellRendererPixbuf() column=g.TreeViewColumn(col) column.pack_start(icon_renderer,False) column.add_attribute(icon_renderer,'pixbuf',14) column.pack_start(renderer,False) column.add_attribute(renderer,'text',1) else: column=g.TreeViewColumn(col,renderer,text=i) ## forcing the column header to have the widget to get the button label = g.Label(col) label.show() self.column_header_labels.append(label) column.set_widget(label) widget = column.get_widget() while not isinstance(widget, g.Button): widget = widget.get_parent() widget.connect('button-press-event',self.column_button_press) column.set_sort_column_id(i) column.set_resizable(True) column.set_reorderable(True) column.set_expand(True) column.set_alignment(0) column.set_sort_indicator(True) self.processTree.append_column(column) self.columnList[i]=column popover_check_button=g.CheckMenuItem(label=col) popover_check_button.set_name(str(i)) popover_check_button.connect('toggled',self.column_header_selection) popover_check_button.set_active(True) self.column_select_popover.append(popover_check_button) self.column_select_popover_check_buttons[i]=popover_check_button if i!=1: self.processTreeStore.set_sort_func(i,sorting_func,None) self.column_select_popover.show_all() selected_row=self.processTree.get_selection() selected_row.connect("changed",self.row_selected) # self.processTree.connect('button-press-event',self.column_button_press) # self.processTree.connect(popover=self.column_select_popover) self.column_select_popover_check_buttons[6].set_active(False) self.column_select_popover_check_buttons[8].set_active(False) self.column_select_popover_check_buttons[10].set_active(False) self.column_select_popover_check_buttons[11].set_active(False)
def __init__(self): uipath = ABSPATH + '/data/hdd.ui' builder = Gtk.Builder() builder.set_translation_domain('ddu') builder.add_from_file(uipath) self.browse_dlg = builder.get_object('Browser_dlg') self.browse_dlg.connect("destroy", self.kill) self.devtreeview = builder.get_object('treeview_mounted') self.devtreemodel = Gtk.ListStore(GdkPixbuf.Pixbuf, GObject.TYPE_STRING,GObject.TYPE_STRING) self.devtreeview.set_model(self.devtreemodel) self.devtreeview.set_headers_visible(True) col0 = Gtk.TreeViewColumn() col0.set_title(_('Removable Device')) col0.set_property("alignment", 0) render_pixbuf0 = Gtk.CellRendererPixbuf() col0.pack_start(render_pixbuf0, expand = False) col0.add_attribute(render_pixbuf0, 'pixbuf', 0) render_text0 = Gtk.CellRendererText() col0.pack_start(render_text0, expand = True) col0.add_attribute(render_text0, 'text', 1) col0.set_resizable(True) self.devtreeview.append_column(col0) self.devtreeview.expand_all() self.scrolledwindow_dev = builder.get_object('scrolledwindow4') self.devtreeview.show() self.scrolledwindow_dev.show() self.devtreeview_sub = builder.get_object('treeview_sub') self.devtreemodel_sub = Gtk.ListStore(GdkPixbuf.Pixbuf, GObject.TYPE_STRING, GObject.TYPE_STRING, GObject.TYPE_STRING) self.devtreeview_sub.set_model(self.devtreemodel_sub) self.devtreeview_sub.set_headers_visible(True) col0 = Gtk.TreeViewColumn() col0.set_title(_('Name')) col0.set_property("alignment", 0) render_pixbuf0 = Gtk.CellRendererPixbuf() col0.pack_start(render_pixbuf0, expand = False) col0.add_attribute(render_pixbuf0, 'pixbuf', 0) render_text0 = Gtk.CellRendererText() col0.pack_start(render_text0, expand = True) col0.add_attribute(render_text0, 'text', 1) render_text1 = Gtk.CellRendererText() render_text1.set_property('visible', False) col0.pack_start(render_text1, expand = True) col0.add_attribute(render_text1, 'text', 2) col0.set_resizable(True) self.devtreeview_sub.append_column(col0) self.devtreeview_sub.expand_all() self.scrolledwindow_sub = builder.get_object('scrolledwindow7') self.devtreeview_sub.show() self.scrolledwindow_sub.show() self.entry_path = builder.get_object('entry_path') self.entry_path.set_activates_default(True) self.cancel_button = builder.get_object('cancel_button') self.cancel_button.connect("clicked", \ lambda w:self.kill(self)) self.ok_button = builder.get_object('ok_button') self.ok_button.connect("clicked", self.finish_media) self.up_button = builder.get_object('button_up') self.up_button.connect("clicked", self.up_media) self.button_eject = builder.get_object("button_eject") self.button_eject.connect("clicked", self.eject_media) ag = Gtk.AccelGroup() self.browse_dlg.add_accel_group(ag) self.ok_button.add_accelerator("clicked", ag, ord('o'), Gdk.ModifierType.MOD1_MASK,Gtk.AccelFlags.VISIBLE) self.cancel_button.add_accelerator("clicked", ag, ord('c'), Gdk.ModifierType.MOD1_MASK,Gtk.AccelFlags.VISIBLE) self.button_eject.add_accelerator("clicked", ag, ord('e'), Gdk.ModifierType.MOD1_MASK,Gtk.AccelFlags.VISIBLE) self.up_button.add_accelerator("clicked", ag, ord('u'), Gdk.ModifierType.MOD1_MASK,Gtk.AccelFlags.VISIBLE) selection = self.devtreeview.get_selection() selection.set_mode(Gtk.SelectionMode.SINGLE) selection.connect('changed', self.on_selection_first) self.devtreeview.connect('button-press-event', self.on_selection_changed) self.devtreeview_sub.connect('row-activated', self.list_selection) signal.signal(signal.SIGUSR2, self.signal_handler) output = subprocess.getoutput('/sbin/uname -p') bindir = ABSPATH + '/bin/' + output self.myproc = subprocess.Popen("%s/media_event %s" % (bindir,str(os.getpid())), shell=True) self.reload_media() self.fs_root = '' self.result = None
def __init__(self): #{{{ self.lockTreeViewEvents = False np.seterr(all='ignore') ## Plotting initialization self.fig = matplotlib.figure.Figure(figsize=(8, 8), dpi=96, facecolor='#eeeeee', tight_layout=1) # (figure is static, axes clear on every replot) self.canvas = FigureCanvas(self.fig) self.canvas.set_size_request(300, 300) self.toolbar = matplotlib.backends.backend_gtk3.NavigationToolbar2GTK3( self.canvas, w('box4').get_parent_window()) self.xlim, self.ylim = None, None self.sw = Gtk.ScrolledWindow() self.sw.add_with_viewport(self.canvas) w('box4').pack_start(self.toolbar, False, True, 0) #self.toolbar.append_item(Gtk.Button('tetet')) ## TODO find out how to modify the NavigationToolbar... w('box4').pack_start(self.sw, True, True, 0) self.toolbar.pan() #TODO - define global shortcuts as a superset of the Matplotlib-GUI's internal, include also: #toolbar.zoom() #toolbar.home() #toolbar.back() #toolbar.forward() #toolbar.save_figure(toolbar) #TODO http://stackoverflow.com/questions/26433169/personalize-matplotlib-toolbar-with-log-feature #TODO http://dalelane.co.uk/blog/?p=778 self.opj_file_cache = {} ## TreeStore and ListStore initialization self.tsFiles = Gtk.TreeStore(str, Pixbuf, str, Pixbuf, int, int, str) self.treeStoreColumns = { 'filepath': 0, 'icon': 1, 'name': 2, 'plotstyleicon': 3, 'column': 4, 'spreadsheet': 5, 'rowtype': 6 } self.dummy_treestore_row = [None for x in self.treeStoreColumns.keys()] treeViewCol0 = Gtk.TreeViewColumn("Plot") # Create a TreeViewColumn colCellPlot = Gtk.CellRendererPixbuf( ) # Create a column cell to display text treeViewCol0.pack_start(colCellPlot, expand=True) treeViewCol0.add_attribute(colCellPlot, "pixbuf", 3) # set params for icon w('treeview1').append_column( treeViewCol0) # Append the columns to the TreeView treeViewCol = Gtk.TreeViewColumn("File") # Create a TreeViewColumn colCellImg = Gtk.CellRendererPixbuf( ) # Create a column cell to display an image colCellText = Gtk.CellRendererText( ) # Create a column cell to display text treeViewCol.pack_start(colCellImg, expand=False) # Add the cells to the column treeViewCol.pack_start(colCellText, expand=True) treeViewCol.add_attribute( colCellImg, "pixbuf", 1) # Bind the image cell to column 1 of the tree's model treeViewCol.add_attribute( colCellText, "text", 2) # Bind the text cell to column 0 of the tree's model w('treeview1').append_column( treeViewCol) # Append the columns to the TreeView w('treeview1').set_expander_column(treeViewCol) w('treeview1').set_model( self.tsFiles) # Append the columns to the TreeView w('treeview1').get_selection().set_select_function( self.treeview1_selectmethod, data=None) # , full=True ## TODO: If files are specified as arguments, select these at start, and plot them at once ## If a directory is specified, just set it as the root of the file list. If none, use current working dir. self.populateTreeStore( self.tsFiles, reset_path=os.getcwd() if len(sys.argv) <= 1 else sys.argv[1]) self.plot_reset() self.plot_all_sel_records() ## Initialize the default plotting commands w('txt_rc').get_buffer().set_text(line_plot_command) w('txt_rc').modify_font(Pango.FontDescription("monospace 10"))
def on_app_startup(self, app): GLib.set_application_name(Config.APPNAME) self.icon_theme = Gtk.IconTheme.get_default() self.icon_theme.append_search_path(Config.ICON_PATH) self.mime = MimeProvider(self) self.color_schema = Config.load_color_schema() self.set_dark_theme(True) self.window = Gtk.ApplicationWindow.new(application=app) self.window.set_default_size(*gutil.DEFAULT_PROFILE['window-size']) self.window.set_default_icon_name(Config.NAME) self.window.props.window_position = Gtk.WindowPosition.CENTER self.window.props.hide_titlebar_when_maximized = True self.window.connect('check-resize', self.on_main_window_resized) self.window.connect('delete-event', self.on_main_window_deleted) app.add_window(self.window) self.window.drag_dest_set(Gtk.DestDefaults.ALL, DROP_TARGET_LIST, Gdk.DragAction.COPY) self.window.connect('drag-data-received', self.on_main_window_drag_data_received) app_menu = Gio.Menu.new() app_menu.append(_('Preferences'), 'app.preferences') app_menu.append(_('Sign out'), 'app.signout') app_menu.append(_('About'), 'app.about') app_menu.append(_('Quit'), 'app.quit') app.set_app_menu(app_menu) preferences_action = Gio.SimpleAction.new('preferences', None) preferences_action.connect('activate', self.on_preferences_action_activated) app.add_action(preferences_action) signout_action = Gio.SimpleAction.new('signout', None) signout_action.connect('activate', self.on_signout_action_activated) app.add_action(signout_action) about_action = Gio.SimpleAction.new('about', None) about_action.connect('activate', self.on_about_action_activated) app.add_action(about_action) quit_action = Gio.SimpleAction.new('quit', None) quit_action.connect('activate', self.on_quit_action_activated) app.add_action(quit_action) paned = Gtk.Paned() self.window.add(paned) left_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=5) left_box.get_style_context().add_class(Gtk.STYLE_CLASS_SIDEBAR) paned.add1(left_box) paned.child_set_property(left_box, 'shrink', False) paned.child_set_property(left_box, 'resize', False) nav_window = Gtk.ScrolledWindow() nav_window.props.hscrollbar_policy = Gtk.PolicyType.NEVER left_box.pack_start(nav_window, True, True, 0) # icon_name, disname, tooltip, color self.nav_liststore = Gtk.ListStore(str, str, str, Gdk.RGBA) nav_treeview = Gtk.TreeView(model=self.nav_liststore) nav_treeview.get_style_context().add_class(Gtk.STYLE_CLASS_SIDEBAR) self.nav_selection = nav_treeview.get_selection() nav_treeview.props.headers_visible = False nav_treeview.set_tooltip_column(TOOLTIP_COL) icon_cell = Gtk.CellRendererPixbuf() icon_cell.props.xalign = 1 icon_col = Gtk.TreeViewColumn('Icon', icon_cell, icon_name=ICON_COL) icon_col.props.fixed_width = 40 nav_treeview.append_column(icon_col) name_cell = Gtk.CellRendererText() name_col = Gtk.TreeViewColumn('Places', name_cell, text=NAME_COL, foreground_rgba=COLOR_COL) nav_treeview.append_column(name_col) nav_selection = nav_treeview.get_selection() nav_selection.connect('changed', self.on_nav_selection_changed) nav_window.add(nav_treeview) self.progressbar = Gtk.ProgressBar() self.progressbar.set_show_text(True) self.progressbar.set_text(_('Unknown')) left_box.pack_end(self.progressbar, False, False, 0) self.img_avatar = Gtk.Image() self.img_avatar.props.halign = Gtk.Align.CENTER left_box.pack_end(self.img_avatar, False, False, 5) self.notebook = Gtk.Notebook() self.notebook.props.show_tabs = False paned.add2(self.notebook)
def create_history_tab(self): self.history_list = Gtk.ListStore(str, str, str, str, 'gboolean', str, str, str, str) treeview = Gtk.TreeView(model=self.history_list) self.history_treeview = treeview treeview.set_tooltip_column(7) treeview.show() treeview.connect('key-press-event', self.treeview_key_press) treeview.connect('button-press-event', self.treeview_button_press) tvcolumn = Gtk.TreeViewColumn('') treeview.append_column(tvcolumn) cell = Gtk.CellRendererPixbuf() tvcolumn.pack_start(cell, False) tvcolumn.set_attributes(cell, stock_id=1) tvcolumn = Gtk.TreeViewColumn('Date') treeview.append_column(tvcolumn) cell = Gtk.CellRendererText() tvcolumn.pack_start(cell, False) tvcolumn.add_attribute(cell, 'text', 2) tvcolumn = Gtk.TreeViewColumn('Description') treeview.append_column(tvcolumn) cell = Gtk.CellRendererText() cell.set_property('foreground', 'grey') cell.set_property('family', MONOSPACE_FONT) cell.set_property('editable', True) def edited_cb(cell, path, new_text, h_list): tx = h_list.get_value( h_list.get_iter(path), 0) self.wallet.set_label(tx,new_text) self.update_history_tab() cell.connect('edited', edited_cb, self.history_list) def editing_started(cell, entry, path, h_list): tx = h_list.get_value( h_list.get_iter(path), 0) if not self.wallet.labels.get(tx): entry.set_text('') cell.connect('editing-started', editing_started, self.history_list) tvcolumn.set_expand(True) tvcolumn.pack_start(cell, True) tvcolumn.set_attributes(cell, text=3, foreground_set = 4) tvcolumn = Gtk.TreeViewColumn('Amount') treeview.append_column(tvcolumn) cell = Gtk.CellRendererText() cell.set_alignment(1, 0.5) cell.set_property('family', MONOSPACE_FONT) tvcolumn.pack_start(cell, False) tvcolumn.add_attribute(cell, 'text', 5) tvcolumn = Gtk.TreeViewColumn('Balance') treeview.append_column(tvcolumn) cell = Gtk.CellRendererText() cell.set_alignment(1, 0.5) cell.set_property('family', MONOSPACE_FONT) tvcolumn.pack_start(cell, False) tvcolumn.add_attribute(cell, 'text', 6) tvcolumn = Gtk.TreeViewColumn('Tooltip') treeview.append_column(tvcolumn) cell = Gtk.CellRendererText() tvcolumn.pack_start(cell, False) tvcolumn.add_attribute(cell, 'text', 7) tvcolumn.set_visible(False) scroll = Gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) scroll.add(treeview) self.add_tab(scroll, 'History') self.update_history_tab()
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 __init__(self): super(ResultView, self).__init__() self._release_ids = {} render = Gtk.CellRendererPixbuf() column = Gtk.TreeViewColumn(_("Write"), render) style = self.get_style() pixbufs = [] for state in [Gtk.StateType.INSENSITIVE, Gtk.StateType.NORMAL]: pb = style.lookup_icon_set(Gtk.STOCK_EDIT).render_icon( style, Gtk.TextDirection.NONE, state, Gtk.IconSize.MENU, self, None) pixbufs.append(pb) def cell_data(column, cell, model, iter_, data): entry = model.get_value(iter_) cell.set_property('pixbuf', pixbufs[entry.can_write]) column.set_cell_data_func(render, cell_data) self.append_column(column) self.connect('button-press-event', self.__button_press, column) render = Gtk.CellRendererText() render.set_property('ellipsize', Pango.EllipsizeMode.END) column = Gtk.TreeViewColumn(util.tag("~basename"), render) def cell_data(column, cell, model, iter_, data): entry = model.get_value(iter_) cell.set_property('text', entry.song("~basename")) column.set_cell_data_func(render, cell_data) column.set_resizable(True) column.set_expand(False) self.append_column(column) render = Gtk.CellRendererText() render.set_property('ellipsize', Pango.EllipsizeMode.END) column = Gtk.TreeViewColumn(_("Status"), render) def cell_data(column, cell, model, iter_, data): entry = model.get_value(iter_) cell.set_property('text', Status.to_string(entry.status)) column.set_cell_data_func(render, cell_data) column.set_resizable(False) column.set_expand(False) self.append_column(column) render = Gtk.CellRendererText() render.set_property('ellipsize', Pango.EllipsizeMode.END) # Translators: album release ID column = Gtk.TreeViewColumn(_("Release"), render) self._release_column = column def cell_data(column, cell, model, iter_, data): entry = model.get_value(iter_) release = entry.release if not release: cell.set_property("text", "-") else: id_ = self.get_release_id(release) cell.set_property("text", str(id_)) column.set_cell_data_func(render, cell_data) column.set_resizable(False) column.set_expand(False) self.append_column(column) for tag in ["tracknumber", "artist", "title"]: render = Gtk.CellRendererText() render.set_property('ellipsize', Pango.EllipsizeMode.END) column = Gtk.TreeViewColumn(util.tag(tag), render) def cell_data(column, cell, model, iter_, data, tag=tag): entry = model.get_value(iter_) release = entry.release if not release: cell.set_property("text", "-") else: value = release.tags.get(tag, "-") value = ", ".join(value.split("\n")) cell.set_property("text", value) column.set_cell_data_func(render, cell_data) column.set_resizable(True) column.set_expand(True) self.append_column(column) if tag == "tracknumber": self._track_column = column
def __build_interface(self): """ Builds the columns for the TreeView. The columns are: Icon, Database Name, Last Modified, Backend Type The Icon column gets its data from column 6 of the database model. It is expecting either None, or a GTK stock icon name The Database Name column is an editable column. We connect to the 'edited' signal, so that we can change the name when the user changes the column. The last accessed column simply displays the last time famtree was opened. The Backend Type column is a string based on database backend. """ # Put some help on the buttons: dbid = config.get('database.backend') backend_type = self.get_backend_name_from_dbid(dbid) self.new_btn.set_tooltip_text(backend_type) # build the database name column render = Gtk.CellRendererText() render.set_property('ellipsize', Pango.EllipsizeMode.END) render.connect('edited', self.__change_name) render.connect('editing-canceled', self.__stop_edit) render.connect('editing-started', self.__start_edit) self.column = Gtk.TreeViewColumn(_('Family Tree name'), render, text=NAME_COL) self.column.set_sort_column_id(NAME_COL) self.column.set_sort_indicator(True) self.column.set_resizable(True) self.column.set_min_width(250) self.dblist.append_column(self.column) self.name_renderer = render # build the icon column render = Gtk.CellRendererPixbuf() #icon_column = Gtk.TreeViewColumn(_('Status'), render, #icon_name=ICON_COL) icon_column = Gtk.TreeViewColumn(_('Status'), render) icon_column.set_cell_data_func(render, bug_fix) icon_column.set_sort_column_id(ICON_COL) self.dblist.append_column(icon_column) # build the backend column render = Gtk.CellRendererText() column = Gtk.TreeViewColumn(_('Database Type'), render, text=BACKEND_COL) column.set_sort_column_id(BACKEND_COL) column.set_sort_indicator(True) column.set_resizable(True) self.dblist.append_column(column) # build the last accessed column render = Gtk.CellRendererText() column = Gtk.TreeViewColumn(_('Last accessed'), render, text=DATE_COL) column.set_sort_column_id(DSORT_COL) self.dblist.append_column(column)
def __init__(self, library): super().__init__(spacing=6) self.set_orientation(Gtk.Orientation.VERTICAL) self._register_instance() if self.__model is None: self._init_model(library) self._cover_cancel = Gio.Cancellable() sw = ScrolledWindow() sw.set_shadow_type(Gtk.ShadowType.IN) self.view = view = AllTreeView() view.set_headers_visible(False) model_sort = AlbumSortModel(model=self.__model) model_filter = AlbumFilterModel(child_model=model_sort) self.__bg_filter = background_filter() self.__filter = None model_filter.set_visible_func(self.__parse_query) render = Gtk.CellRendererPixbuf() self.__cover_column = column = Gtk.TreeViewColumn("covers", render) column.set_visible(config.getboolean("browsers", "album_covers")) column.set_sizing(Gtk.TreeViewColumnSizing.FIXED) column.set_fixed_width(get_cover_size() + 12) render.set_property('height', get_cover_size() + 8) render.set_property('width', get_cover_size() + 8) def cell_data_pb(column, cell, model, iter_, no_cover): item = model.get_value(iter_) if item.album is None: surface = None elif item.cover: pixbuf = item.cover pixbuf = add_border_widget(pixbuf, self.view) surface = get_surface_for_pixbuf(self, pixbuf) # don't cache, too much state has an effect on the result self.__last_render_surface = None else: surface = no_cover if self.__last_render_surface == surface: return self.__last_render_surface = surface cell.set_property("surface", surface) column.set_cell_data_func(render, cell_data_pb, self._no_cover) view.append_column(column) render = Gtk.CellRendererText() column = Gtk.TreeViewColumn("albums", render) column.set_sizing(Gtk.TreeViewColumnSizing.FIXED) if view.supports_hints(): render.set_property('ellipsize', Pango.EllipsizeMode.END) def cell_data(column, cell, model, iter_, data): album = model.get_album(iter_) if album is None: text = "<b>%s</b>\n" % _("All Albums") text += numeric_phrase("%d album", "%d albums", len(model) - 1) markup = text else: markup = self.display_pattern % album if self.__last_render == markup: return self.__last_render = markup cell.markup = markup cell.set_property('markup', markup) column.set_cell_data_func(render, cell_data) view.append_column(column) view.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE) view.set_rules_hint(True) view.set_search_equal_func(self.__search_func, None) view.set_search_column(0) view.set_model(model_filter) sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) sw.add(view) view.connect('row-activated', self.__play_selection) self.__sig = view.connect( 'selection-changed', util.DeferredSignal(self.__update_songs, owner=view)) targets = [("text/x-quodlibet-songs", Gtk.TargetFlags.SAME_APP, 1), ("text/uri-list", 0, 2)] targets = [Gtk.TargetEntry.new(*t) for t in targets] view.drag_source_set(Gdk.ModifierType.BUTTON1_MASK, targets, Gdk.DragAction.COPY) view.connect("drag-data-get", self.__drag_data_get) connect_obj(view, 'popup-menu', self.__popup, view, library) self.accelerators = Gtk.AccelGroup() search = SearchBarBox(completion=AlbumTagCompletion(), accel_group=self.accelerators) search.connect('query-changed', self.__update_filter) connect_obj(search, 'focus-out', lambda w: w.grab_focus(), view) self.__search = search prefs = PreferencesButton(self, model_sort) search.pack_start(prefs, False, True, 0) self.pack_start(Align(search, left=6, top=6), False, True, 0) self.pack_start(sw, True, True, 0) self.connect("destroy", self.__destroy) self.enable_row_update(view, sw, self.__cover_column) self.connect('key-press-event', self.__key_pressed, library.librarian) if app.cover_manager: connect_destroy(app.cover_manager, "cover-changed", self._cover_changed) self.show_all()
def prepCategory(self, category): self.storeFilter[category["id"]].refilter() if not self.anyVisibleInCategory(category): return if self.first_category_done: widget = Gtk.Separator.new(Gtk.Orientation.HORIZONTAL) self.side_view_container.pack_start(widget, False, False, 10) box = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 4) img = Gtk.Image.new_from_icon_name(category["icon"], Gtk.IconSize.BUTTON) box.pack_start(img, False, False, 4) widget = Gtk.Label() widget.set_use_markup(True) widget.set_markup('<span size="12000">%s</span>' % category["label"]) widget.set_alignment(.5, .5) box.pack_start(widget, False, False, 1) self.side_view_container.pack_start(box, False, False, 0) widget = Gtk.IconView.new_with_model(self.storeFilter[category["id"]]) area = widget.get_area() widget.set_item_width(self.min_pix_length) widget.set_item_padding(0) widget.set_column_spacing(18) widget.set_row_spacing(18) widget.set_margin(20) pixbuf_renderer = Gtk.CellRendererPixbuf() text_renderer = Gtk.CellRendererText( ellipsize=Pango.EllipsizeMode.NONE, wrap_mode=Pango.WrapMode.WORD_CHAR, wrap_width=0, width_chars=self.min_label_length, alignment=Pango.Alignment.CENTER) text_renderer.set_alignment(.5, 0) area.pack_start(pixbuf_renderer, True, True, False) area.pack_start(text_renderer, True, True, False) area.add_attribute(pixbuf_renderer, "icon-name", 1) pixbuf_renderer.set_property("stock-size", Gtk.IconSize.DIALOG) pixbuf_renderer.set_property("follow-state", True) area.add_attribute(text_renderer, "text", 0) self.side_view[category["id"]] = widget self.side_view_container.pack_start(self.side_view[category["id"]], False, False, 0) self.first_category_done = True self.side_view[category["id"]].connect("item-activated", self.side_view_nav, category["id"]) self.side_view[category["id"]].connect("button-release-event", self.button_press, category["id"]) self.side_view[category["id"]].connect("keynav-failed", self.on_keynav_failed, category["id"]) self.side_view[category["id"]].connect("selection-changed", self.on_selection_changed, category["id"])
def __init__(self, msg,stay,att,titulo="",w="",h=""): Gtk.Window.__init__(self, title="Contact List") self.set_default_size(250, 100) hb = Gtk.HeaderBar() hb.props.show_close_button = True hb.props.title = "Contact List" box2 = Gtk.VBox(orientation=Gtk.Orientation.HORIZONTAL) Gtk.StyleContext.add_class(box2.get_style_context(), "linked") self.set_titlebar(hb) self.set_position(Gtk.WindowPosition.CENTER) self.set_border_width(15) self.set_icon_from_file("/usr/share/cinnamon/applets/[email protected]/icons/turbo.png") self.set_wmclass ("TurboNote Gnome", "TurboNote Gnome") grid = Gtk.Grid() assignNewValueToAtt(att) assignNewValueTotitulo(titulo) assignNewValueToStay(stay) assignNewValueToH(h) assignNewValueToW(w) scroller = Gtk.ScrolledWindow(hexpand=True, vexpand=True) scroller.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) scroller.set_min_content_height(300) scroller.set_shadow_type(2) scroller.set_border_width(border_width=1) scroller.set_min_content_width(150) grid.attach(scroller, 0, 0, 4, 1) view = Gtk.TreeView() pix = Gtk.CellRendererPixbuf() cell = Gtk.CellRendererText(weight=300) cell2 = Gtk.CellRendererText(weight=300) cell.set_fixed_size(200, -1) cell2.set_fixed_size(200, -1) col = Gtk.TreeViewColumn("Name") col2 = Gtk.TreeViewColumn("IP Adress") col2.pack_start(cell2,self) col.pack_start(pix,self) col.pack_start(cell,self) col2.set_attributes( cell2, text=2) col.set_attributes( pix, pixbuf=0) col.set_attributes( cell, text=1) view.append_column(col) view.append_column(col2) scroller.add(view) self.listmodel = Gtk.ListStore(GdkPixbuf.Pixbuf,str,str) view.set_model(self.listmodel) view.set_search_column(1) col.set_sort_column_id(1) col2.set_sort_column_id(2) for i in range(len(lista_contatos)): self.listmodel.append(lista_contatos[i]) self.selection = view.get_selection() view.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE) self.selection.connect("changed", self.on_changed) self.label = Gtk.Label() self.label.set_text(" ") self.labelb = Gtk.Label() self.labelb.set_text(" ") self.label2 = Gtk.Label() self.label2.set_text(" ") self.sendto = Gtk.Label() self.sendto.set_text("Send To ") self.labelNome = Gtk.Label() self.labelNome.set_text("") self.button_add = Gtk.Button() self.button_add.connect("clicked", self.add_cb) self.button_send = Gtk.Button() self.button_send.connect("clicked", self.send_turbo,msg) self.nometxt = Gtk.SearchEntry() self.nometxt.set_text("Name") self.nometxt.set_tooltip_text("Add contact name in entry [You can just press Enter in entry]") self.button_remove = Gtk.Button() self.button_remove.connect("clicked", self.remove_cb) self.button_remove_all = Gtk.Button() self.button_remove_all.connect("clicked", self.remove_all_cb) self.add(grid) self.connect('key-press-event',on_button_clicked2,msg,col,self.listmodel) view.connect("button-press-event", treeview_clicked,self.selection,msg) self.label3 = Gtk.Label() self.label3.set_text(" ") self.nomeAvul = Gtk.Entry() self.nomeAvul.set_tooltip_text("Add contact name in entry") self.nomeAvul.set_text("Name") self.ipAvul = Gtk.Entry() self.ipAvul.set_tooltip_text("Add ip in entry") self.ipAvul.set_text("IP Adress") self.button_add2 = Gtk.Button() self.button_add2.connect("clicked", self.add_cb_avul,self.nomeAvul,self.ipAvul,self.listmodel) self.addcontact2 = Gtk.Image() self.addcontact2.set_from_file("/usr/share/cinnamon/applets/[email protected]/icons/ic_action_add_person" + config_note.getColor() + ".png") self.button_add2.add(self.addcontact2) self.addcontact = Gtk.Image() if config_note.getColorRevertTitle(): self.addcontact.set_from_file("/usr/share/cinnamon/applets/[email protected]/icons/ic_action_add_person" + config_note.getColorOver() + ".png") else: self.addcontact.set_from_file("/usr/share/cinnamon/applets/[email protected]/icons/ic_action_add_person" + config_note.getColor() + ".png") self.button_add.add(self.addcontact) self.rmvcontact = Gtk.Image() if config_note.getColorRevertTitle(): self.rmvcontact.set_from_file("/usr/share/cinnamon/applets/[email protected]/icons/ic_action_rmv_person" + config_note.getColorOver() + ".png") else: self.rmvcontact.set_from_file("/usr/share/cinnamon/applets/[email protected]/icons/ic_action_rmv_person" + config_note.getColor() + ".png") self.button_remove.add(self.rmvcontact) self.rmvall = Gtk.Image() if config_note.getColorRevertTitle(): self.rmvall.set_from_file("/usr/share/cinnamon/applets/[email protected]/icons/ic_action_rmv_group" + config_note.getColorOver() + ".png") else: self.rmvall.set_from_file("/usr/share/cinnamon/applets/[email protected]/icons/ic_action_rmv_group" + config_note.getColor() + ".png") self.button_remove_all.add(self.rmvall) self.sending = Gtk.Image() self.sending.set_from_file("/usr/share/cinnamon/applets/[email protected]/icons/ic_action_send_now" + config_note.getColor() + ".png") self.button_send.add(self.sending) grid.attach(self.label2, 0, 2, 4, 1) grid.attach(self.sendto, 0, 3, 4, 1) grid.attach(self.labelNome, 0, 4, 4, 1) grid.attach(self.label, 0, 5, 4, 1) grid.attach(self.nometxt, 0, 6, 4, 1) grid.attach(self.labelb, 0, 7, 4, 1) box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL) Gtk.StyleContext.add_class(box.get_style_context(), "linked") box.add(self.button_add) box.add(self.button_remove) box.add(self.button_remove_all) self.button_add.set_tooltip_text("Add contact name in entry [You can just press Enter in entry]") self.button_remove.set_tooltip_text("Remove selected contacts") self.button_remove_all.set_tooltip_text("Remove all contacts") self.button_send.set_tooltip_text("Send [You can just press CTRL+Enter after the selected contact or double click in contact name]") hb.pack_start(box) grid.attach(self.button_send, 0, 8, 4, 1) grid.attach(self.label3, 0, 9, 4, 1) grid2 = Gtk.Grid() grid2.attach(self.nomeAvul, 0, 0, 1, 1) grid2.attach(self.ipAvul, 0, 1, 1, 1) grid2.attach(self.button_add2, 0, 2, 1, 1) scroller2 = Gtk.ScrolledWindow(hexpand=True, vexpand=True) scroller2.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) grid2.attach(scroller2, 0, 2, 1, 1) self.exp = Gtk.Expander() self.exp.set_label("Add contact loose") self.exp.set_resize_toplevel(True) self.exp.add(grid2) grid.attach(self.exp, 0, 10, 4, 1)
def __init__(self, parent, library): super(EditTags, self).__init__(spacing=12) self.title = _("Edit Tags") self.set_border_width(12) model = ObjectStore() view = RCMHintedTreeView(model=model) self._view = view selection = view.get_selection() render = Gtk.CellRendererPixbuf() column = TreeViewColumn() column.pack_start(render, True) column.set_fixed_width(24) column.set_expand(False) def cdf_write(col, rend, model, iter_, *args): entry = model.get_value(iter_) rend.set_property('sensitive', entry.edited or entry.deleted) if entry.canedit or entry.deleted: if entry.deleted: rend.set_property('icon-name', Icons.EDIT_DELETE) else: rend.set_property('icon-name', Icons.EDIT) else: rend.set_property('icon-name', Icons.CHANGES_PREVENT) column.set_cell_data_func(render, cdf_write) view.append_column(column) render = Gtk.CellRendererText() column = TreeViewColumn(title=_('Tag')) column.pack_start(render, True) def cell_data_tag(column, cell, model, iter_, data): entry = model.get_value(iter_) cell.set_property("text", entry.tag) cell.set_property("strikethrough", entry.deleted) column.set_cell_data_func(render, cell_data_tag) column.set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE) render.set_property('editable', True) render.connect('edited', self.__edit_tag_name, model) render.connect('editing-started', self.__tag_editing_started, model, library) view.append_column(column) render = Gtk.CellRendererText() render.set_property('ellipsize', Pango.EllipsizeMode.END) render.set_property('editable', True) render.connect('edited', self.__edit_tag, model) render.connect('editing-started', self.__value_editing_started, model, library) column = TreeViewColumn(title=_('Value')) column.pack_start(render, True) def cell_data_value(column, cell, model, iter_, data): entry = model.get_value(iter_) markup = entry.value.get_markup() cell.markup = markup cell.set_property("markup", markup) cell.set_property("editable", entry.canedit) cell.set_property("strikethrough", entry.deleted) column.set_cell_data_func(render, cell_data_value) column.set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE) view.append_column(column) sw = Gtk.ScrolledWindow() sw.set_shadow_type(Gtk.ShadowType.IN) sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) sw.add(view) self.pack_start(sw, True, True, 0) cb = ConfigCheckButton( _("Show _programmatic tags"), 'editing', 'alltags', populate=True, tooltip=_("Access all tags, including machine-generated " "ones e.g. MusicBrainz or Replay Gain tags")) cb.connect('toggled', self.__all_tags_toggled) self.pack_start(cb, False, True, 0) # Add and Remove [tags] buttons buttonbox = Gtk.HBox(spacing=18) bbox1 = Gtk.HButtonBox() bbox1.set_spacing(6) bbox1.set_layout(Gtk.ButtonBoxStyle.START) add = qltk.Button(_("_Add"), Icons.LIST_ADD) add.set_focus_on_click(False) self._add = add add.connect('clicked', self.__add_tag, model, library) bbox1.pack_start(add, True, True, 0) # Remove button remove = qltk.Button(_("_Remove"), Icons.LIST_REMOVE) remove.set_focus_on_click(False) remove.connect('clicked', self.__remove_tag, view) remove.set_sensitive(False) self._remove = remove bbox1.pack_start(remove, True, True, 0) # Revert and save buttons # Both can have customised translated text (and thus accels) bbox2 = Gtk.HButtonBox() bbox2.set_spacing(6) bbox2.set_layout(Gtk.ButtonBoxStyle.END) # Translators: Revert button in the tag editor revert = Button(C_("edittags", "_Revert"), Icons.DOCUMENT_REVERT) self._revert = revert revert.set_sensitive(False) # Translators: Save button in the tag editor save = Button(C_("edittags", "_Save"), Icons.DOCUMENT_SAVE) save.set_sensitive(False) self._save = save bbox2.pack_start(revert, True, True, 0) bbox2.pack_start(save, True, True, 0) buttonbox.pack_start(bbox1, True, True, 0) buttonbox.pack_start(bbox2, True, True, 0) self.pack_start(buttonbox, False, True, 0) self._buttonbox = buttonbox parent.connect('changed', self.__parent_changed) revert.connect('clicked', lambda *x: self._update()) connect_obj(revert, 'clicked', parent.set_pending, None) save.connect('clicked', self.__save_files, revert, model, library) connect_obj(save, 'clicked', parent.set_pending, None) for sig in ['row-inserted', 'row-deleted', 'row-changed']: model.connect(sig, self.__enable_save, [save, revert]) connect_obj(model, sig, parent.set_pending, save) view.connect('popup-menu', self.__popup_menu, parent) view.connect('button-press-event', self.__button_press) view.connect('key-press-event', self.__view_key_press_event) selection.connect('changed', self.__tag_select, remove) selection.set_mode(Gtk.SelectionMode.MULTIPLE) self._parent = parent for child in self.get_children(): child.show_all()