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