def __init__(self, api_port):
self.username_mappings = {}
_get_environment_vars()
self.api = api_port
Gtk.Window.__init__(self, title="Explorer Details")
self.set_border_width(5)
self.set_size_request(800, 1000)
self.notebook = Gtk.Notebook()
self.add(self.notebook)
# First tab
healths = []
myDates = []
print([
'python3', '../Sawtooth/bin/health.py', 'list', '--type', 'health',
'--url', 'http://127.0.0.1:' + str(self.api)
])
results = subprocess.check_output([
'python3', '../Sawtooth/bin/health.py', 'list', '--type', 'health',
'--url', 'http://127.0.0.1:' + str(self.api)
])
if not results:
pass
else:
results = results.decode('utf-8').replace("'", "\"").replace(
'": b"', '": "').strip()
dictionary = json.loads(results)
for value in dictionary.values():
data = value.split(
',') # transaction_name,sender_id,health,status,time
health = data[2]
date = data[6].split(
'-'
) # [data[4][0:4],data[4][5:7],data[4][8:10],data[4][11:13],data[4][14:16],data[4][17:19]]
healths.append(float(health))
print(date)
myDates.append(
datetime.datetime(int(date[0]), int(date[1]), int(date[2]),
int(date[3]), int(date[4]),
int(date[5])))
print(health, date)
fig, ax = plt.subplots()
ax.plot(myDates, healths, 'ro')
myfmt = DateFormatter("%y-%m-%d")
ax.xaxis.set_major_formatter(myfmt)
# ax.set_xlim(myDates[0], myDates[-1])
ax.set_ylim(0, 100)
## Rotate date labels automatically
fig.autofmt_xdate()
plt.xlabel("Date")
plt.ylabel("Health")
plt.title("Health per Commit")
plt.yticks(np.arange(0, 100, 10)) # TODO make dynamic
# plt.xticks(None,1)#TODO make dynamic
# plt.locator_params(axis='y',numticks=3)
# plt.show()
# plt.plot(healths,times,'ro')
# plt.axis(['Mon','Tues','Wed'])
plt.savefig('health.png')
img = Gtk.Image.new_from_file(
"health.png"
) # TODO update this periodically and check for blank
self.page1 = Gtk.Box()
self.page1.set_border_width(10)
img = Gtk.Image.new_from_file("health.png")
self.page1.add(img)
self.notebook.append_page(self.page1, Gtk.Label('Health'))
# 2nd tab
self.page2 = Gtk.ScrolledWindow()
self.page2.set_border_width(10)
# Required columns for History tab
self.historical_data = []
transactions = self.blockchain_requests(api_port, "/transactions")
suse_transactions = [] # To be used later to calculate user/suse tab
# Get the authentication token ready to increase our rate limit
_create_installation_token()
try:
for transaction in transactions['data']:
payload = str(base64.b64decode(transaction['payload']))[
2:-1] # Returns base64 encoded comma-delimited payload
payload_list = payload.split(',')
transaction_type = payload_list[
0] # Transactions type is always the first item
timestamp = payload_list[
len(payload_list) - 1] # Timestamp is always the last item
sender_id = "Anonymous"
if (transaction_type in ["commit", "health", "suse"]):
user_github_id = payload_list[1]
sender_id = self.github_user_id_to_username(user_github_id)
#sender_id = user_github_id
# Filter out transactions
if (transaction_type not in [
"code_smell", "commit", "health", "proposal", "suse",
"vote"
]):
continue
# Prepare labels for data, different transaction types have different labels
if (transaction_type == "code_smell"):
data = "Code Smell: " + payload_list[1] + "\n"
data += "Values: " + payload_list[2] + "\n"
data += "State: " + payload_list[3] + "\n"
elif (transaction_type == "commit"):
data = "GitHub ID: " + payload_list[1] + "\n"
data += "Commit URL: " + payload_list[2] + "\n"
data += "State: " + payload_list[3] + "\n"
data += "REST API URL: " + payload_list[4] + "\n"
data += "Peer IP: " + payload_list[5] + "\n"
elif (transaction_type == "health"):
data = "GitHub ID: " + payload_list[1] + "\n"
data += "Health: " + payload_list[2] + "\n"
data += "State: " + payload_list[3] + "\n"
data += "Commit URL: " + payload_list[4] + "\n"
data += "IP Peer: " + payload_list[5] + "\n"
elif (transaction_type == "proposal"):
data = "GitHub ID: " + payload_list[1] + "\n"
data += "Code Smells: " + self._beautify_code_smells(
payload_list[2]) + "\n"
data += "State: " + payload_list[3] + "\n"
elif (transaction_type == "suse"):
suse_transactions.append(
transaction) # To sum up the values
data = "GitHub ID: " + payload_list[1] + "\n"
data += "Suse: " + payload_list[2] + "\n"
data += "State: " + payload_list[3] + "\n"
elif (transaction_type == "vote"):
data = "Vote ID: " + payload_list[1] + "\n"
data += "Proposal ID: " + payload_list[2] + "\n"
active = payload_list[3]
active = active.replace('0',
'closed').replace('1', 'active')
data += "State: " + active + "\n"
else:
data = "" # Data is everything in between
i = 1
while (i < len(payload_list) - 1):
data += payload_list[i] + "\n"
i += 1
self.historical_data.append(
(sender_id, timestamp, transaction_type,
data)) # Add a tuple to the list to show in table
except:
print("Problem trying to parse the history transactions")
#self.historical_data = [("Sender ID 1", "Time stamp 1", "Type 1", "Data 1"),
# ("Sender ID 2", "Time stamp 2", "Type 2", "Data 2")]
history_list_store = Gtk.ListStore(str, str, str, str)
# # ListStore (lists that TreeViews can display) and specify data types
# history_list_store = Gtk.ListStore(str, str)
for item in self.historical_data:
history_list_store.append(list(item))
# TreeView is the item that is displayed
history_tree_view = Gtk.TreeView(history_list_store)
# Enumerate to add counter (i) to loop
for i, col_title in enumerate(["Sender ID", "Time", "Type", "Data"]):
# Render means draw or display the data (just display as normal text)
renderer = Gtk.CellRendererText()
renderer.props.wrap_width = 250
# Create columns (text is column number)
column = Gtk.TreeViewColumn(col_title, renderer, text=i)
# Make column sortable and selectable
column.set_sort_column_id(i)
# Add columns to TreeView
history_tree_view.append_column(column)
self.page2.add(history_tree_view)
self.notebook.append_page(self.page2, Gtk.Label('History'))
# 3rd Tab
self.page3 = Gtk.ScrolledWindow()
self.page3.set_border_width(10)
# Required columns for History tab
self.user_data = [
] # List of users and their suse values to be rendered
suse_sums = {} # dictionary to sum up suse values for each user
# Loop through all transactions of type suse, parse user id and suse awarded
# Sum up the suse values for each user and render them in a table
for suse_transaction in suse_transactions:
payload = str(base64.b64decode(suse_transaction['payload']))[
2:-1] # Returns base64 encoded comma-delimited payload
#print(payload)
payload_list = payload.split(',')
user_github_id = payload_list[1]
user_github_username = self.github_user_id_to_username(
user_github_id)
#user_github_username = user_github_id
suse_awarded = float(payload_list[2])
# Add suse to user in dict or create a new key-value in the dict
if user_github_username in suse_sums:
suse_sums[user_github_username] += suse_awarded
else:
suse_sums[user_github_username] = suse_awarded
# Add user and sum values to self.user_data to be rendered
for user_github_username, suse_sum in suse_sums.items():
suse_sum_formatted = str(format(suse_sum, '.2f'))
self.user_data.append(
(user_github_username, suse_sum_formatted
)) # Adds tuple to the user_data for rendering
# Adding them dynamically now
#self.user_data = [("User ID 1", "Suse 1"),
# ("User ID 2", "Suse 2")]
user_list_store = Gtk.ListStore(str, str)
self.listbox_users = Gtk.ListBox()
self.listbox_users.set_selection_mode(Gtk.SelectionMode.NONE)
# # ListStore (lists that TreeViews can display) and specify data types
# user_list_store = Gtk.ListStore(str, str)
for item in self.user_data:
#print(item)
user_list_store.append(list(item))
# TreeView is the item that is displayed
user_tree_view = Gtk.TreeView(user_list_store)
# Enumerate to add counter (i) to loop
for i, col_title in enumerate(["User ID", "Suse"]):
# Render means draw or display the data (just display as normal text)
renderer = Gtk.CellRendererText()
renderer.props.wrap_width = 250
# Create columns (text is column number)
column = Gtk.TreeViewColumn(col_title, renderer, text=i)
# Make column sortable and selectable
column.set_sort_column_id(i)
# Add columns to TreeView
user_tree_view.append_column(column)
self.page3.add(user_tree_view)
self.notebook.append_page(self.page3, Gtk.Label('Users'))
self.connect("delete-event", Gtk.main_quit)
self.set_position(Gtk.WindowPosition.CENTER)
self.show_all()
def set_text_cell():
text_cell = Gtk.CellRendererText()
text_cell.set_padding(10, 0)
text_cell.set_property("ellipsize", Pango.EllipsizeMode.END)
return text_cell
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, installer):
BasePage.__init__(self)
self.installer = installer
# Hold our pages in a stack
self.stack = Gtk.Stack()
# Disk chooser page
self.disks_page = Gtk.VBox()
self.disks_page.set_margin_top(30)
self.disks_page.set_border_width(20)
self.listbox_disks = Gtk.ListBox()
self.disks_page.pack_start(self.listbox_disks, True, True, 0)
self.listbox_disks.connect("row-activated", self._disk_selected)
self.stack.add_named(self.disks_page, "disks")
# Partitioning page
self.partition_page = Gtk.VBox()
self.treeview = Gtk.TreeView()
self.scroller = Gtk.ScrolledWindow(None, None)
self.scroller.add(self.treeview)
self.partition_page.set_border_width(12)
self.scroller.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
self.scroller.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
self.scroller.get_style_context().set_junction_sides(Gtk.JunctionSides.BOTTOM)
self.partition_page.pack_start(self.scroller, True, True, 0)
# device
ren = Gtk.CellRendererText()
self.column3 = Gtk.TreeViewColumn(_("Device"), ren)
self.column3.add_attribute(ren, "markup", INDEX_PARTITION_PATH)
self.treeview.append_column(self.column3)
# Type
ren = Gtk.CellRendererText()
self.column4 = Gtk.TreeViewColumn(_("Type"), ren)
self.column4.add_attribute(ren, "markup", INDEX_PARTITION_TYPE)
self.treeview.append_column(self.column4)
# description
ren = Gtk.CellRendererText()
self.column5 = Gtk.TreeViewColumn(_("Operating system"), ren)
self.column5.add_attribute(ren, "markup", INDEX_PARTITION_DESCRIPTION)
self.treeview.append_column(self.column5)
# mount point
ren = Gtk.CellRendererText()
self.column6 = Gtk.TreeViewColumn(_("Mount point"), ren)
self.column6.add_attribute(ren, "markup", INDEX_PARTITION_MOUNT_AS)
self.treeview.append_column(self.column6)
# format
ren = Gtk.CellRendererText()
self.column7 = Gtk.TreeViewColumn(_("Format?"), ren)
self.column7.add_attribute(ren, "markup", INDEX_PARTITION_FORMAT_AS)
self.treeview.append_column(self.column7)
# size
ren = Gtk.CellRendererText()
self.column8 = Gtk.TreeViewColumn(_("Size"), ren)
self.column8.add_attribute(ren, "markup", INDEX_PARTITION_SIZE)
self.treeview.append_column(self.column8)
# Used space
ren = Gtk.CellRendererText()
self.column9 = Gtk.TreeViewColumn(_("Free space"), ren)
self.column9.add_attribute(ren, "markup", INDEX_PARTITION_FREE_SPACE)
self.treeview.append_column(self.column9)
self.treeview.get_selection().connect("changed", self._partition_selected)
toolbar = Gtk.Toolbar()
toolbar.get_style_context().add_class(Gtk.STYLE_CLASS_INLINE_TOOLBAR)
junctions = Gtk.JunctionSides.TOP
toolbar.get_style_context().set_junction_sides(junctions)
self.root = Gtk.ToolButton()
self.root.set_label(_("Assign as root partition (ext4)"))
self.root.set_is_important(True)
self.root.set_sensitive(False)
self.root.connect("clicked", self._assign_root)
toolbar.add(self.root)
self.swap = Gtk.ToolButton()
self.swap.set_label(_("Assign as swap partition"))
self.swap.set_is_important(True)
self.swap.set_sensitive(False)
self.swap.connect("clicked", self._assign_swap)
toolbar.add(self.swap)
sep = Gtk.SeparatorToolItem()
sep.set_expand(True)
sep.set_draw(False)
toolbar.add(sep)
gparted = Gtk.ToolButton()
gparted.set_label(_("Launch Partition Editor"))
gparted.connect("clicked", self._launch_gparted)
gparted.set_is_important(True)
toolbar.add(gparted)
self.partition_page.pack_start(toolbar, False, False, 0)
self.stack.add_named(self.partition_page, "partitions")
self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_UP_DOWN)
self.pack_start(self.stack, True, True, 0)
self.root_partition = None
self.swap_partition = None
self.build_hdds()
def __init__(self, parent):
Gtk.Dialog.__init__(self, "Wifi", parent, 0)
self.maximize()
self.set_decorated(False)
gtk_style()
try:
display = Gdk.Display.get_default()
monitor = display.get_primary_monitor()
geometry = monitor.get_geometry()
scale_factor = monitor.get_scale_factor()
self.screen_width = scale_factor * geometry.width
self.screen_height = scale_factor * geometry.height
except:
self.screen_width = self.get_screen().get_width()
self.screen_height = self.get_screen().get_height()
self.treelist_height = get_treelist_height_from_screen_size(self.screen_width, self.screen_height)
self.connect("button-release-event", self.on_page_press_event)
mainvbox = self.get_content_area()
self.dev_selected = {'mac_address':'', 'name':''}
self.audio_bt_sink = []
self.list_dev_connect = []
self.current_devs = []
self.locked_devices = False
self.scan_done = False
self.previous_click_time=0
self.page_bluetooth = Gtk.VBox()
self.page_bluetooth.set_border_width(30)
self.title = Gtk.Label()
self.title.set_markup("<span font='30' color='#00000000'>Connect bluetooth headset</span>")
self.page_bluetooth.add(self.title)
self.ButtonBox = Gtk.HBox(homogeneous=True)
self.lb_button_scan = Gtk.Label()
self.lb_button_scan.set_markup("<span font='20'>start scan</span>")
self.button_scan = Gtk.Button()
self.button_scan.set_property("height-request", 60)
self.button_scan.add(self.lb_button_scan)
self.button_scan.connect("clicked", self.on_selection_scan_clicked)
self.ButtonBox.add(self.button_scan)
self.lb_button_connect = Gtk.Label()
self.lb_button_connect.set_markup("<span font='20' color='#88888888'>connect</span>")
self.button_connect = Gtk.Button()
self.button_connect.add(self.lb_button_connect)
self.button_connect.connect("clicked", self.on_selection_connect_clicked)
self.ButtonBox.add(self.button_connect)
self.page_bluetooth.add(self.ButtonBox)
self.progress_vbox = Gtk.VBox()
self.scan_progress = Gtk.ProgressBar()
self.scan_progress.set_fraction(0.0)
self.progress_vbox.pack_start(self.scan_progress, False, False, 3)
self.page_bluetooth.add(self.progress_vbox)
self.tree_list_vbox = Gtk.VBox(homogeneous=True)
self.bluetooth_liststore = Gtk.ListStore(int, str, str, str)
self.bluetooth_treeview = Gtk.TreeView(self.bluetooth_liststore)
l_col = ["n°", "name", "connected", "Audio"]
for i, column_title in enumerate(l_col):
renderer = Gtk.CellRendererText()
renderer.set_property('font', "20")
column = Gtk.TreeViewColumn(column_title, renderer, text=i)
self.bluetooth_treeview.append_column(column)
self.bluetooth_treeview.get_selection().connect("changed", self.on_changed)
self.scroll_treelist = Gtk.ScrolledWindow()
self.scroll_treelist.set_vexpand(False)
self.scroll_treelist.set_hexpand(False)
self.scroll_treelist.set_property("min-content-height", self.treelist_height)
self.scroll_treelist.add(self.bluetooth_treeview)
self.tree_list_vbox.pack_start(self.scroll_treelist, True, True, 3)
self.page_bluetooth.add(self.tree_list_vbox)
self.label_audio = Gtk.Label()
self.label_audio.set_markup("<span font='20' color='#FFFFFFFF'> </span>")
self.label_audio.set_justify(Gtk.Justification.LEFT)
self.label_audio.set_line_wrap(True)
self.page_bluetooth.add(self.label_audio)
mainvbox.pack_start(self.page_bluetooth, False, True, 3)
self.show_all()
# enable bluetooth
os.system('hciconfig hci0 up')
#self.bluetooth_state = os.system('hciconfig hci0 up')
self.bl = Bluetoothctl()
list_devices(self, paired=True)
self.audio_bt_sink = status_playback(self)
def __drives_page(self):
"""Return widget containing the drives page"""
def add_drive_cb(button):
"""Callback for adding a drive"""
title = _("Choose a folder")
pathname = GuiBasic.browse_folder(self.parent,
title,
multiple=False,
stock_button=Gtk.STOCK_ADD)
if pathname:
liststore.append([pathname])
pathnames.append(pathname)
options.set_list('shred_drives', pathnames)
def remove_drive_cb(button):
"""Callback for removing a drive"""
treeselection = treeview.get_selection()
(model, _iter) = treeselection.get_selected()
if None == _iter:
# nothing selected
return
pathname = model[_iter][0]
liststore.remove(_iter)
pathnames.remove(pathname)
options.set_list('shred_drives', pathnames)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
# TRANSLATORS: 'free' means 'unallocated'
notice = Gtk.Label(label=_(
"Choose a writable folder for each drive for which to overwrite free space."
))
notice.set_line_wrap(True)
vbox.pack_start(notice, False, True, 0)
liststore = Gtk.ListStore(str)
pathnames = options.get_list('shred_drives')
if pathnames:
pathnames = sorted(pathnames)
if not pathnames:
pathnames = []
for pathname in pathnames:
liststore.append([pathname])
treeview = Gtk.TreeView.new_with_model(liststore)
crt = Gtk.CellRendererText()
tvc = Gtk.TreeViewColumn(None, crt, text=0)
treeview.append_column(tvc)
vbox.pack_start(treeview, True, True, 0)
# TRANSLATORS: In the preferences dialog, this button adds a path to
# the list of paths
button_add = Gtk.Button.new_with_label(label=_p('button', 'Add'))
button_add.connect("clicked", add_drive_cb)
# TRANSLATORS: In the preferences dialog, this button removes a path
# from the list of paths
button_remove = Gtk.Button.new_with_label(label=_p('button', 'Remove'))
button_remove.connect("clicked", remove_drive_cb)
button_box = Gtk.ButtonBox(orientation=Gtk.Orientation.HORIZONTAL)
button_box.set_layout(Gtk.ButtonBoxStyle.START)
button_box.pack_start(button_add, True, True, 0)
button_box.pack_start(button_remove, True, True, 0)
vbox.pack_start(button_box, False, True, 0)
return vbox
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, account, jids, preselected=None):
"""
This window is used to trasform a one-to-one chat to a MUC. We do 2
things: first select the server and then make a guests list
"""
self.instances.append(self)
self.account = account
self.auto_jids = jids
self.preselected_jids = preselected
self.xml = get_builder('chat_to_muc_window.ui')
self.window = self.xml.get_object('chat_to_muc_window')
for widget_to_add in ('invite_button', 'cancel_button',
'server_list_comboboxentry', 'guests_treeview',
'guests_store', 'server_and_guests_hseparator',
'server_select_label'):
self.__dict__[widget_to_add] = self.xml.get_object(widget_to_add)
server_list = []
self.servers = Gtk.ListStore(str)
self.server_list_comboboxentry.set_model(self.servers)
cell = Gtk.CellRendererText()
self.server_list_comboboxentry.pack_start(cell, True)
self.server_list_comboboxentry.add_attribute(cell, 'text', 0)
# get the muc server of our server
if 'jabber' in app.connections[account].muc_jid:
server_list.append(app.connections[account].muc_jid['jabber'])
# add servers or recently joined groupchats
recently_groupchat = app.config.get_per('accounts', account,
'recent_groupchats').split()
for g in recently_groupchat:
server = app.get_server_from_jid(g)
if server not in server_list and not server.startswith('irc'):
server_list.append(server)
# add a default server
if not server_list:
server_list.append('conference.jabber.org')
for s in server_list:
self.servers.append([s])
self.server_list_comboboxentry.set_active(0)
# set treeview
# name, jid
self.guests_store.set_sort_column_id(1, Gtk.SortType.ASCENDING)
self.guests_treeview.get_selection().set_mode(
Gtk.SelectionMode.MULTIPLE)
# All contacts beside the following can be invited:
# transports, zeroconf contacts, minimized groupchats
def invitable(contact, contact_transport=None):
return (contact.jid not in self.auto_jids
and contact.jid != app.get_jid_from_account(account)
and contact.jid
not in app.interface.minimized_controls[account]
and not contact.is_transport()
and contact_transport in ('jabber', None))
# set jabber id and pseudos
for account_ in app.contacts.get_accounts():
if app.connections[account_].is_zeroconf:
continue
for jid in app.contacts.get_jid_list(account_):
contact = app.contacts.get_contact_with_highest_priority(
account_, jid)
contact_transport = app.get_transport_name_from_jid(jid)
# Add contact if it can be invited
if invitable(contact, contact_transport) and \
contact.show not in ('offline', 'error'):
icon_name = get_icon_name(contact.show)
name = contact.name
if name == '':
name = jid.split('@')[0]
iter_ = self.guests_store.append([icon_name, name, jid])
# preselect treeview rows
if self.preselected_jids and jid in self.preselected_jids:
path = self.guests_store.get_path(iter_)
self.guests_treeview.get_selection().select_path(path)
# show all
self.window.show_all()
self.xml.connect_signals(self)
def __init__(self):
self.builder = Gtk.Builder()
self.builder.add_from_file("amigos_manuel.glade")
self.handlers = {
"onDeleteWindow": self.onDeleteWindow,
"onCrearAmigo": self.onCrearAmigo,
"onObtenerAmigo": self.onObtenerAmigo,
"onActualizarAmigo": self.onActualizarAmigo,
"onBorrarAmigo": self.onBorrarAmigo,
"onAcercaDe": self.onAcercaDe,
"onBtnOperacionClicked": self.onBtnOperacionClicked,
"onCloseAboutDialog": self.onCloseAboutDialog,
"onCambiarSeleccion": self.onCambiarSeleccion
}
# Conectamos las señales e iniciamos la aplicación
self.builder.connect_signals(self.handlers)
self.window = self.builder.get_object("AmigosManuel")
self.btn = self.builder.get_object("btn")
self.menuOperaciones = self.builder.get_object("menuOperaciones")
self.statusbar = self.builder.get_object("statusbar")
self.idStatusBar = self.statusbar.get_context_id("statusbar")
self.btOperacion = self.builder.get_object("btOperacion")
self.edNombre = self.builder.get_object("edNombre")
self.edEnComun = self.builder.get_object("edEnComun")
self.edProcedencia = self.builder.get_object("edProcedencia")
self.edTelefono = self.builder.get_object("edTelefono")
self.edEmail = self.builder.get_object("edEmail")
self.about = self.builder.get_object("dialogoAcercaDe")
self.modeloLista = self.builder.get_object('listItems')
self.lista = self.builder.get_object('treeIds')
# Defino las columnas de la lista TreeView
column = Gtk.TreeViewColumn('Id', Gtk.CellRendererText(), text=0)
column.set_clickable(True)
column.set_resizable(True)
self.lista.append_column(column)
column = Gtk.TreeViewColumn('Nombre', Gtk.CellRendererText(), text=1)
column.set_clickable(True)
column.set_resizable(True)
self.lista.append_column(column)
self.window.show_all()
self.modoOperacion = NO_OPERACION # NO_OPERACION, OP_CREAR, OP_BORRAR ...
self.ponModoOperacion()
self.Conexion = None
self.Cursor = None
self.conectarABaseDatos()
if not self.Conexion or not self.Cursor:
self.statusbar.push(
self.idStatusBar, "ERROR al conectar a la Base de Datos. "
"Las operaciones no están disponibles")
self.builder.get_object("menuitemCrear").set_sensitive(False)
self.builder.get_object("menuitemObtener").set_sensitive(False)
self.builder.get_object("menuitemActualizar").set_sensitive(False)
self.builder.get_object("menuitemBorrar").set_sensitive(False)
else:
self.cargarLista()
self.activarCamposEdicion(False)
self.idSeleccionado = -1
def add_column(title):
cell = Gtk.CellRendererText()
names = Gtk.TreeViewColumn(title, cell, markup=self.column_i)
self.tree.append_column(names)
self.column_i += 1
def __init__(self, on_response, show=None, show_pep=True):
countdown_time = app.config.get('change_status_window_timeout')
TimeoutDialog.__init__(self, countdown_time)
self.show = show
self.pep_dict = {}
self.show_pep = show_pep
self.on_response = on_response
self.xml = get_builder('change_status_message_dialog.ui')
self.dialog = self.xml.get_object('change_status_message_dialog')
self.dialog.set_transient_for(app.interface.roster.window)
msg = None
if show:
uf_show = helpers.get_uf_show(show)
self.title_text = _('%s Status Message') % uf_show
msg = app.config.get_per('statusmsg', '_last_' + self.show,
'message')
self.pep_dict['activity'] = app.config.get_per(
'statusmsg', '_last_' + self.show, 'activity')
self.pep_dict['subactivity'] = app.config.get_per(
'statusmsg', '_last_' + self.show, 'subactivity')
self.pep_dict['activity_text'] = app.config.get_per(
'statusmsg', '_last_' + self.show, 'activity_text')
self.pep_dict['mood'] = app.config.get_per('statusmsg',
'_last_' + self.show,
'mood')
self.pep_dict['mood_text'] = app.config.get_per(
'statusmsg', '_last_' + self.show, 'mood_text')
else:
self.title_text = _('Status Message')
self.dialog.set_title(self.title_text)
message_textview = self.xml.get_object('message_textview')
self.message_buffer = message_textview.get_buffer()
if app.config.get('use_speller') and app.is_installed('GSPELL'):
lang = app.config.get('speller_language')
gspell_lang = Gspell.language_lookup(lang)
if gspell_lang is None:
AspellDictError(lang)
else:
spell_buffer = Gspell.TextBuffer.get_from_gtk_text_buffer(
self.message_buffer)
spell_buffer.set_spell_checker(Gspell.Checker.new(gspell_lang))
spell_view = Gspell.TextView.get_from_gtk_text_view(
message_textview)
spell_view.set_inline_spell_checking(True)
spell_view.set_enable_language_menu(True)
self.message_buffer.connect('changed', self.on_message_buffer_changed)
if not msg:
msg = ''
msg = helpers.from_one_line(msg)
self.message_buffer.set_text(msg)
# have an empty string selectable, so user can clear msg
self.preset_messages_dict = {'': ['', '', '', '', '', '']}
for msg_name in app.config.get_per('statusmsg'):
if msg_name.startswith('_last_'):
continue
opts = []
for opt in [
'message', 'activity', 'subactivity', 'activity_text',
'mood', 'mood_text'
]:
opts.append(app.config.get_per('statusmsg', msg_name, opt))
opts[0] = helpers.from_one_line(opts[0])
self.preset_messages_dict[msg_name] = opts
sorted_keys_list = helpers.get_sorted_keys(self.preset_messages_dict)
self.message_liststore = Gtk.ListStore(str) # msg_name
self.message_combobox = self.xml.get_object('message_combobox')
self.message_combobox.set_model(self.message_liststore)
cellrenderertext = Gtk.CellRendererText()
self.message_combobox.pack_start(cellrenderertext, True)
self.message_combobox.add_attribute(cellrenderertext, 'text', 0)
for msg_name in sorted_keys_list:
self.message_liststore.append((msg_name, ))
if show_pep:
self.draw_activity()
self.draw_mood()
else:
# remove acvtivity / mood lines
self.xml.get_object('activity_label').set_no_show_all(True)
self.xml.get_object('activity_button').set_no_show_all(True)
self.xml.get_object('mood_label').set_no_show_all(True)
self.xml.get_object('mood_button').set_no_show_all(True)
self.xml.get_object('activity_label').hide()
self.xml.get_object('activity_button').hide()
self.xml.get_object('mood_label').hide()
self.xml.get_object('mood_button').hide()
self.xml.connect_signals(self)
self.run_timeout()
self.dialog.connect('response', self.on_dialog_response)
self.dialog.set_position(Gtk.WindowPosition.CENTER_ON_PARENT)
self.dialog.show_all()
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__(self, activity):
GObject.GObject.__init__(self)
self.activity = activity
# Build the transaction list.
self.treeview = Gtk.TreeView()
self.treeview.set_rules_hint(True)
self.treeview.set_enable_search(False)
font_size = int(style.FONT_SIZE * 1.25)
font = Pango.FontDescription("Sans %d" % font_size)
self.treeview.modify_font(font)
# Note that the only thing we store in our liststore is the
# transaction id. All the actual data is in the activity
# database.
self.liststore = Gtk.ListStore(GObject.TYPE_INT)
self.treeview.set_model(self.liststore)
sep = style.DEFAULT_SPACING
theme = b"* {-GtkTreeView-vertical-separator: %d;" \
b" -GtkTreeView-horizontal-separator: %d;}" % (sep, sep)
css_provider = Gtk.CssProvider()
css_provider.load_from_data(theme)
style_context = self.treeview.get_style_context()
style_context.add_provider(css_provider,
Gtk.STYLE_PROVIDER_PRIORITY_USER)
# Construct the columns.
renderer = Gtk.CellRendererText()
renderer.props.editable = True
renderer.connect('editing-started', self.category_editing_started_cb)
renderer.connect('edited', self.category_edit_cb)
col = Gtk.TreeViewColumn(_('Category'), renderer)
col.set_cell_data_func(renderer, self.category_render_cb)
col.set_alignment(0.5)
col.set_min_width(300)
self.treeview.append_column(col)
renderer = Gtk.CellRendererText()
renderer.props.editable = True
renderer.props.ellipsize = Pango.EllipsizeMode.END
renderer.connect('editing-started',
self.description_editing_started_cb)
renderer.connect('edited', self.description_edit_cb)
col = Gtk.TreeViewColumn(_('Description'), renderer)
col.set_cell_data_func(renderer, self.description_render_cb)
col.set_expand(True)
self.treeview.append_column(col)
renderer = Gtk.CellRendererText()
renderer.props.editable = True
renderer.connect('edited', self.date_edit_cb)
col = Gtk.TreeViewColumn(_('Date'), renderer)
col.set_alignment(0.5)
col.set_cell_data_func(renderer, self.date_render_cb)
col.set_min_width(150)
self.treeview.append_column(col)
renderer = Gtk.CellRendererText()
renderer.props.editable = True
renderer.connect('edited', self.amount_edit_cb)
col = Gtk.TreeViewColumn(_('Amount'), renderer)
col.set_cell_data_func(renderer, self.amount_render_cb)
col.set_alignment(0.5)
col.set_min_width(120)
renderer.props.xpad = style.DEFAULT_SPACING
self.treeview.append_column(col)
scroll = Gtk.ScrolledWindow()
scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
scroll.add(self.treeview)
self.pack_start(scroll, True, True, 0)
import gettext
import os.path
import sys
import gi
gi.require_version('Gtk', '3.0')
gettext.install('dummy')
DIR = os.path.dirname(os.path.abspath(__file__))
BASE_DIR = os.path.dirname(DIR)
sys.path.insert(0, BASE_DIR)
from gi.repository import Gtk
cell = Gtk.CellRendererText()
cell.props.wrap_mode
from rednotebook.gui import imports
imports.ImportAssistant
imports.PlainTextImporter
imports.RedNotebookBackupImporter
imports.Importer._check_modules
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()
class ApplicationWindow(Gtk.ApplicationWindow):
ENGINE_ADVANCED_SETTINGS_WINDOW_ATTR = "advanced settings window"
def __init__(self, force_all=False, **kwargs):
Gtk.ApplicationWindow.__init__(self, **kwargs)
self._prefs: Preferences = self.get_property(
"application"
).get_preferences()
self._preflight_check_metadata: Final[
Dict[int, Dict[str, Any]]
] = dict()
self._yaml_file: str = None
self.set_default_size(1000, 1000)
action_entries = (
("save", self.on_save),
("save-as", self.on_save_as),
("close", self.on_close),
("minimize", self.on_minimize),
("play", self.on_play),
("stop", self.on_stop),
("add-operation", self.on_add_operation),
("queue-manager", self.on_open_queue_manager),
("help-queue-manager", self.on_open_queue_manager_help),
(
"status-filter-created",
self.on_status_filter,
None,
GLib.Variant.new_boolean(True),
FileStatus.CREATED,
),
(
"status-filter-saved",
self.on_status_filter,
None,
GLib.Variant.new_boolean(True),
FileStatus.SAVED,
),
(
"status-filter-queued",
self.on_status_filter,
None,
GLib.Variant.new_boolean(True),
FileStatus.QUEUED,
),
(
"status-filter-running",
self.on_status_filter,
None,
GLib.Variant.new_boolean(True),
FileStatus.RUNNING,
),
(
"status-filter-success",
self.on_status_filter,
None,
GLib.Variant.new_boolean(True),
FileStatus.SUCCESS,
),
(
"status-filter-failure",
self.on_status_filter,
None,
GLib.Variant.new_boolean(True),
FileStatus.FAILURE,
),
)
# This doesn't work, which is kind of uncool
# self.add_action_entries(action_entries)
for action_entry in action_entries:
add_action_entries(self, *action_entry)
self.set_border_width(10)
main_grid = Gtk.Grid(row_spacing=10, **EXPAND_AND_FILL)
self.add(main_grid)
controls_frame = Gtk.Frame(
label="File Monitor Controls",
halign=Gtk.Align.FILL,
valign=Gtk.Align.FILL,
hexpand=True,
vexpand=False,
)
main_grid.attach(controls_frame, 0, 0, 1, 1)
controls_grid = Gtk.Grid(
halign=Gtk.Align.FILL,
valign=Gtk.Align.FILL,
hexpand=True,
vexpand=False,
)
controls_grid_basic = Gtk.Grid(
**EXPAND_AND_FILL, border_width=10, column_spacing=5, row_spacing=5
)
controls_frame.add(controls_grid)
controls_grid.attach(controls_grid_basic, 0, 0, 1, 1)
monitor_play_button = Gtk.Button(
action_name="win.play",
image=Gtk.Image(
icon_name="media-playback-start", icon_size=Gtk.IconSize.DIALOG
),
halign=Gtk.Align.CENTER,
valign=Gtk.Align.END,
hexpand=False,
vexpand=False,
)
controls_grid_basic.attach(monitor_play_button, 0, 0, 1, 1)
monitor_stop_button = Gtk.Button(
action_name="win.stop",
image=Gtk.Image(
icon_name="media-playback-stop", icon_size=Gtk.IconSize.DIALOG
),
halign=Gtk.Align.CENTER,
valign=Gtk.Align.START,
hexpand=False,
vexpand=False,
)
controls_grid_basic.attach(monitor_stop_button, 0, 1, 1, 1)
# turn the buttons off for now
# play will become active when operations have been added
self.lookup_action("play").set_enabled(False)
self.lookup_action("stop").set_enabled(False)
# add the notebook with the engines
self._engines_notebook = Gtk.Notebook(
**EXPAND_AND_FILL,
scrollable=True,
)
controls_grid_basic.attach(self._engines_notebook, 1, 0, 6, 2)
self._engines: List[Engine] = list()
for engine_cls in self.get_property(
"application"
).known_engines.values():
if not (self._prefs.engines[engine_cls] or force_all):
continue
engine = engine_cls(appwindow=self)
engine_grid = Gtk.Grid(
**EXPAND_AND_FILL, row_spacing=5, border_width=5
)
engine_grid.attach(engine, 0, 0, 1, 1)
buttons_grid = Gtk.Grid(
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
column_spacing=5,
)
# add button and dialog for advanced settings if necessary
if (
engine_cls
in self.get_property(
"application"
).engines_advanced_settings_map
):
engine_advanced_settings = self.get_property(
"application"
).engines_advanced_settings_map[type(engine)](engine)
title = f"{engine.NAME} Advanced Settings"
dialog = ParamsWindow(engine_advanced_settings, self, title)
setattr(
engine, self.ENGINE_ADVANCED_SETTINGS_WINDOW_ATTR, dialog
)
advanced_settings_button = Gtk.Button(
label="Advanced Settings",
halign=Gtk.Align.CENTER,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
)
buttons_grid.attach(
advanced_settings_button, len(buttons_grid), 0, 1, 1
)
advanced_settings_button.connect(
"clicked",
self._engine_advanced_settings_button_clicked_cb,
engine,
)
if engine_cls in self.get_property("application").pango_docs_map:
help_button = Gtk.Button(
label="Help",
halign=Gtk.Align.CENTER,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
)
buttons_grid.attach(help_button, len(buttons_grid), 0, 1, 1)
help_button.connect(
"clicked", self._engine_help_button_clicked_cb, engine
)
# fix layout a bit. Buttons should be grouped and centered
if buttons_grid_len := len(buttons_grid):
engine_grid.attach(buttons_grid, 0, 1, 1, 1)
if buttons_grid_len >= 2:
# apparently the children of the grid are listed in LIFO order
list(buttons_grid)[0].props.halign = Gtk.Align.START
list(buttons_grid)[-1].props.halign = Gtk.Align.END
if buttons_grid_len >= 3:
for widget in list(buttons_grid)[1:-1]:
widget.props.hexpand = False
else:
del buttons_grid
self._engines_notebook.append_page(
engine_grid, Gtk.Label(label=engine_cls.NAME)
)
self._engines.append(engine)
# ensure first engine is active
self._active_engine: Engine = self._engines[0]
self._active_engine_valid_handler_id = self._active_engine.connect(
"notify::valid", self._engine_valid_changed_cb
)
self._engines_notebook.props.page = 0
self._engines_notebook.connect("switch-page", self._switch_page_cb)
# Add support for adding and removing operations
controls_grid_basic.attach(
Gtk.Separator(
orientation=Gtk.Orientation.HORIZONTAL,
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=True,
),
0,
2,
7,
1,
)
controls_grid_basic.attach(
Gtk.Label(
label="<b>Add operation: </b>",
use_markup=True,
halign=Gtk.Align.END,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
),
0,
3,
2,
1,
)
self._controls_operations_model = Gtk.ListStore(str, object)
self._controls_operations_combo = Gtk.ComboBox(
model=self._controls_operations_model,
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
)
renderer = Gtk.CellRendererText()
self._controls_operations_combo.pack_start(renderer, True)
self._controls_operations_combo.add_attribute(renderer, "text", 0)
controls_grid_basic.attach(self._controls_operations_combo, 2, 3, 2, 1)
add_operation_button = Gtk.Button(
label="Add",
action_name="win.add-operation",
halign=Gtk.Align.START,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
)
controls_grid_basic.attach(add_operation_button, 4, 3, 2, 1)
self._repopulate_available_operations()
if len(self._controls_operations_model) > 0:
self._controls_operations_combo.set_active(0)
else:
self.lookup_action("add-operation").set_enabled(False)
self._controls_operations_combo.set_sensitive(False)
paned = Gtk.Paned(
wide_handle=True,
orientation=Gtk.Orientation.VERTICAL,
halign=Gtk.Align.FILL,
valign=Gtk.Align.FILL,
hexpand=True,
vexpand=True,
)
main_grid.attach(paned, 0, 1, 1, 1)
operations_frame = Gtk.Frame(
label="List of Operations",
halign=Gtk.Align.FILL,
valign=Gtk.Align.FILL,
hexpand=True,
vexpand=True,
)
paned.pack1(operations_frame, resize=True, shrink=False)
operations_scrolled_window = Gtk.ScrolledWindow(
hscrollbar_policy=Gtk.PolicyType.NEVER,
halign=Gtk.Align.FILL,
valign=Gtk.Align.FILL,
hexpand=True,
vexpand=True,
)
operations_frame.add(operations_scrolled_window)
self._operations_box = OperationListBox(
selection_mode=Gtk.SelectionMode.NONE,
halign=Gtk.Align.FILL,
valign=Gtk.Align.FILL,
hexpand=True,
vexpand=True,
)
operations_scrolled_window.add(self._operations_box)
output_frame = Gtk.Frame(
label="Processing Queue",
halign=Gtk.Align.FILL,
valign=Gtk.Align.FILL,
hexpand=True,
vexpand=True,
)
paned.pack2(output_frame, resize=True, shrink=False)
self._files_tree_model = Gtk.TreeStore(
str, # filename, relative to monitored directory
float, # epoch time
int, # status as code
str, # operation name
float, # operation progress
str, # operation progress as string
str, # background color
str, # error message
)
self._files_tree_model_filter = Gtk.TreeModelFilter(
child_model=self._files_tree_model
)
self._files_tree_model_filter.set_visible_func(
self._files_tree_model_visible_func
)
output_grid = Gtk.Grid(**EXPAND_AND_FILL, row_spacing=2, border_width=2)
filters_grid = Gtk.Grid(
border_width=5,
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
column_spacing=5,
)
output_grid.attach(filters_grid, 0, 0, 1, 1)
label = Gtk.Label(
label="Queue Filters:",
halign=Gtk.Align.START,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
)
filters_grid.attach(label, 0, 0, 1, 1)
state_filters_button = Gtk.Button(
label="Status",
halign=Gtk.Align.START,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
)
filters_grid.attach(state_filters_button, 1, 0, 1, 1)
state_filter_popover = Gtk.Popover.new_from_model(
state_filters_button,
self.get_property("application").filter_popover_menu,
)
state_filters_button.connect(
"clicked", self._state_filters_button_clicked, state_filter_popover
)
label = Gtk.Label(
label="Name:",
halign=Gtk.Align.START,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
)
filters_grid.attach(label, 2, 0, 1, 1)
self._name_filter_entry = Gtk.Entry(
placeholder_text=PATTERN_PLACEHOLDER_TEXT,
halign=Gtk.Align.START,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
)
filters_grid.attach(self._name_filter_entry, 3, 0, 1, 1)
self._name_filter_entry.connect(
"changed", self._name_filter_entry_changed
)
queue_manager_button = Gtk.Button(
label="Queue Manager",
action_name="win.queue-manager",
halign=Gtk.Align.END,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
)
filters_grid.attach(queue_manager_button, 4, 0, 1, 1)
self._queue_manager = QueueManager(self)
self._queue_manager_window = ParamsWindow(
self._queue_manager, self, "Queue Manager"
)
help_queue_manager_button = Gtk.Button(
label="Help",
action_name="win.help-queue-manager",
halign=Gtk.Align.END,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
)
filters_grid.attach(help_queue_manager_button, 5, 0, 1, 1)
files_frame = Gtk.Frame(border_width=5)
files_scrolled_window = Gtk.ScrolledWindow(**EXPAND_AND_FILL)
files_frame.add(files_scrolled_window)
output_grid.attach(files_frame, 0, 1, 1, 1)
output_frame.add(output_grid)
files_tree_view = Gtk.TreeView(
model=self._files_tree_model_filter, border_width=5
)
files_scrolled_window.add(files_tree_view)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(
"Filename", renderer, text=0, cell_background=6
)
files_tree_view.append_column(column)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Created", renderer, cell_background=6)
column.set_cell_data_func(
renderer, self._time_cell_data_func, func_data=dict(column=1)
)
files_tree_view.append_column(column)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Status", renderer, cell_background=6)
column.set_cell_data_func(
renderer, self._status_cell_data_func, func_data=dict(column=2)
)
files_tree_view.append_column(column)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(
"Operation", renderer, text=3, cell_background=6
)
files_tree_view.append_column(column)
renderer = Gtk.CellRendererProgress()
column = Gtk.TreeViewColumn(
"Progress", renderer, value=4, text=5, cell_background=6
)
files_tree_view.append_column(column)
files_tree_view.set_tooltip_column(column=7)
# add status bar
self._status_grid = Gtk.Grid(
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
column_homogeneous=True,
column_spacing=5,
)
output_grid.attach(self._status_grid, 0, 2, 1, 1)
statuses = (
"Total",
"Created",
"Saved",
"Queued",
"Running",
"Success",
"Failure",
"Removed from list",
)
for _index, _status in enumerate(statuses):
self._status_grid.attach(
Gtk.Label(label=f"{_status}: 0"), _index, 0, 1, 1
)
# connect delete-event signal handler
self.connect("delete-event", self._delete_event_cb)
def create_columns(self, treeView):
rendererText = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(None, rendererText, text=0)
column.set_sort_indicator(False)
self.dvdtrackview.append_column(column)
def __init__(self, mac, destroy):
self.mac = mac
self.history = {}
self.sources = {}
self.time_range = 60 * 2
self.colors = [
(0, 1, 0),
(1, 0, 0),
(0, 0, 1),
(1, 1, 0),
(0, 1, 1),
(0, 0.5, 0),
(0.5, 0, 0),
(0, 0, 0.5),
]
self.gtkwin = Gtk.Window()
self.gtkwin.set_position(Gtk.WindowPosition.CENTER)
self.gtkwin.connect("destroy", destroy, mac)
self.gtkwin.set_default_size(620, 320)
self.gtkwin.set_title("Signal Graph: %s" % self.mac)
self.graph = Gtk.DrawingArea()
self.graph.connect("draw", self.on_draw_event)
button_box = Gtk.HButtonBox()
signal_button = Gtk.RadioButton(label='Signal strength')
signal_button.connect("clicked", self.on_graph_type, "signal")
signal_button.clicked()
button_box.add(signal_button)
packets_button = Gtk.RadioButton(group=signal_button,
label='Packets per second')
packets_button.connect("clicked", self.on_graph_type, "packets")
button_box.add(packets_button)
self.sources_list = Gtk.TreeView()
tvcolumn = Gtk.TreeViewColumn("Color")
cell = Gtk.CellRendererText()
tvcolumn.pack_start(cell, True)
cell.set_property('background-set', True)
tvcolumn.set_attributes(cell, text=0, background=9)
self.sources_list.append_column(tvcolumn)
num = 1
for column in ("Name", "Type", "Signal (dbm)", "Min", "Max",
"Packets/sec", "Packets", "Server"):
tvcolumn = Gtk.TreeViewColumn(column)
self.sources_list.append_column(tvcolumn)
cell = Gtk.CellRendererText()
tvcolumn.pack_start(cell, True)
tvcolumn.add_attribute(cell, 'text', num)
num += 1
self.sources_list_store = Gtk.ListStore(
GObject.TYPE_STRING,
GObject.TYPE_STRING,
GObject.TYPE_STRING,
GObject.TYPE_INT,
GObject.TYPE_INT,
GObject.TYPE_INT,
GObject.TYPE_INT,
GObject.TYPE_INT,
GObject.TYPE_INT, # server
GObject.TYPE_STRING, # bg color
)
self.sources_list.set_model(self.sources_list_store)
expander = Gtk.Expander()
expander.set_label("Sources")
expander.set_expanded(True)
expander.add(self.sources_list)
vbox = Gtk.VBox()
vbox.pack_start(button_box, expand=False, fill=False, padding=0)
vbox.add(self.graph)
vbox.pack_end(expander, expand=False, fill=False, padding=0)
self.gtkwin.add(vbox)
self.gtkwin.show_all()
def __locations_page(self, page_type):
"""Return a widget containing a list of files and folders"""
def add_whitelist_file_cb(button):
"""Callback for adding a file"""
title = _("Choose a file")
pathname = GuiBasic.browse_file(self.parent, title)
if pathname:
for this_pathname in pathnames:
if pathname == this_pathname[1]:
logger.warning("'%s' already exists in whitelist",
pathname)
return
liststore.append([_('File'), pathname])
pathnames.append(['file', pathname])
options.set_whitelist_paths(pathnames)
def add_whitelist_folder_cb(button):
"""Callback for adding a folder"""
title = _("Choose a folder")
pathname = GuiBasic.browse_folder(self.parent,
title,
multiple=False,
stock_button=Gtk.STOCK_ADD)
if pathname:
for this_pathname in pathnames:
if pathname == this_pathname[1]:
logger.warning("'%s' already exists in whitelist",
pathname)
return
liststore.append([_('Folder'), pathname])
pathnames.append(['folder', pathname])
options.set_whitelist_paths(pathnames)
def remove_whitelist_path_cb(button):
"""Callback for removing a path"""
treeselection = treeview.get_selection()
(model, _iter) = treeselection.get_selected()
if None == _iter:
# nothing selected
return
pathname = model[_iter][1]
liststore.remove(_iter)
for this_pathname in pathnames:
if this_pathname[1] == pathname:
pathnames.remove(this_pathname)
options.set_whitelist_paths(pathnames)
def add_custom_file_cb(button):
"""Callback for adding a file"""
title = _("Choose a file")
pathname = GuiBasic.browse_file(self.parent, title)
if pathname:
for this_pathname in pathnames:
if pathname == this_pathname[1]:
logger.warning("'%s' already exists in whitelist",
pathname)
return
liststore.append([_('File'), pathname])
pathnames.append(['file', pathname])
options.set_custom_paths(pathnames)
def add_custom_folder_cb(button):
"""Callback for adding a folder"""
title = _("Choose a folder")
pathname = GuiBasic.browse_folder(self.parent,
title,
multiple=False,
stock_button=Gtk.STOCK_ADD)
if pathname:
for this_pathname in pathnames:
if pathname == this_pathname[1]:
logger.warning("'%s' already exists in whitelist",
pathname)
return
liststore.append([_('Folder'), pathname])
pathnames.append(['folder', pathname])
options.set_custom_paths(pathnames)
def remove_custom_path_cb(button):
"""Callback for removing a path"""
treeselection = treeview.get_selection()
(model, _iter) = treeselection.get_selected()
if None == _iter:
# nothing selected
return
pathname = model[_iter][1]
liststore.remove(_iter)
for this_pathname in pathnames:
if this_pathname[1] == pathname:
pathnames.remove(this_pathname)
options.set_custom_paths(pathnames)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
# load data
if LOCATIONS_WHITELIST == page_type:
pathnames = options.get_whitelist_paths()
elif LOCATIONS_CUSTOM == page_type:
pathnames = options.get_custom_paths()
liststore = Gtk.ListStore(str, str)
for paths in pathnames:
type_code = paths[0]
type_str = None
if type_code == 'file':
type_str = _('File')
elif type_code == 'folder':
type_str = _('Folder')
else:
raise RuntimeError("Invalid type code: '%s'" % type_code)
path = paths[1]
liststore.append([type_str, path])
if LOCATIONS_WHITELIST == page_type:
# TRANSLATORS: "Paths" is used generically to refer to both files
# and folders
notice = Gtk.Label(
label=_("Theses paths will not be deleted or modified."))
elif LOCATIONS_CUSTOM == page_type:
notice = Gtk.Label(
label=_("These locations can be selected for deletion."))
vbox.pack_start(notice, False, False, 0)
# create treeview
treeview = Gtk.TreeView.new_with_model(liststore)
# create column views
self.renderer0 = Gtk.CellRendererText()
self.column0 = Gtk.TreeViewColumn(_("Type"), self.renderer0, text=0)
treeview.append_column(self.column0)
self.renderer1 = Gtk.CellRendererText()
# TRANSLATORS: In the tree view "Path" is used generically to refer to a
# file, a folder, or a pattern describing either
self.column1 = Gtk.TreeViewColumn(_("Path"), self.renderer1, text=1)
treeview.append_column(self.column1)
treeview.set_search_column(1)
# finish tree view
swindow = Gtk.ScrolledWindow()
swindow.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
swindow.set_size_request(300, 200)
swindow.add(treeview)
vbox.pack_start(swindow, False, True, 0)
# buttons that modify the list
button_add_file = Gtk.Button.new_with_label(
label=_p('button', 'Add file'))
if LOCATIONS_WHITELIST == page_type:
button_add_file.connect("clicked", add_whitelist_file_cb)
elif LOCATIONS_CUSTOM == page_type:
button_add_file.connect("clicked", add_custom_file_cb)
button_add_folder = Gtk.Button.new_with_label(
label=_p('button', 'Add folder'))
if LOCATIONS_WHITELIST == page_type:
button_add_folder.connect("clicked", add_whitelist_folder_cb)
elif LOCATIONS_CUSTOM == page_type:
button_add_folder.connect("clicked", add_custom_folder_cb)
button_remove = Gtk.Button.new_with_label(label=_p('button', 'Remove'))
if LOCATIONS_WHITELIST == page_type:
button_remove.connect("clicked", remove_whitelist_path_cb)
elif LOCATIONS_CUSTOM == page_type:
button_remove.connect("clicked", remove_custom_path_cb)
button_box = Gtk.ButtonBox(orientation=Gtk.Orientation.HORIZONTAL)
button_box.set_layout(Gtk.ButtonBoxStyle.START)
button_box.pack_start(button_add_file, True, True, 0)
button_box.pack_start(button_add_folder, True, True, 0)
button_box.pack_start(button_remove, True, True, 0)
vbox.pack_start(button_box, False, True, 0)
# return page
return vbox
def __init__(self, mw):
self.window = gtk.Dialog("TunesViewer Preferences",
None,
gtk.DialogFlags.DESTROY_WITH_PARENT,
(gtk.STOCK_OK, 1, gtk.STOCK_CANCEL, 0))
self.mainwin = mw
self.window.set_icon(self.window.render_icon(gtk.STOCK_PREFERENCES,
gtk.IconSize.BUTTON))
self.window.connect("response", self.response) # Ok/Cancel
self.window.connect("delete_event", self.delete_event)
dtab = gtk.VBox() # for downloads tab
vtab = gtk.VBox() # for display tab
moduletab = gtk.VBox() # for display tab
tabs = gtk.Notebook()
tabs.append_page(moduletab, gtk.Label("Modules"))
tabs.append_page(dtab, gtk.Label("Downloads"))
tabs.append_page(vtab, gtk.Label("Display"))
self.window.get_content_area().pack_start(tabs, True, True, 0)
# Start of Download tab
dhbox = gtk.HBox()
labels = gtk.ListStore(str)
labels.append(["Only Follow links"])
labels.append(["View Streaming or Follow-link"])
labels.append(["Download or Follow-link"])
self.combo = gtk.ComboBox(model=labels)
renderer_text = gtk.CellRendererText()
self.combo.pack_start(renderer_text, True)
self.combo.add_attribute(renderer_text, "text",0)
self.combo.set_active(1)
dhbox.pack_start(gtk.Label("Default action: "), False, False, 0)
dhbox.pack_start(self.combo, True, True, 0)
dtab.pack_start(dhbox, True, False, 0)
self.downloadsel = gtk.FileChooserButton("Select a folder to download to")
self.downloadsel.set_action(gtk.FileChooserAction.SELECT_FOLDER)
hbox = gtk.HBox()
hbox.pack_start(gtk.Label("Download Folder: "), False, False, 0)
hbox.pack_start(self.downloadsel, True, True, 0)
dtab.pack_start(hbox, True, False, 0)
lab = gtk.Label("Download File-name\n"
"(%p=page-title, %a=author/artist, %n=name, %c=comment, %l=length, %t=filetype)")
lab.set_alignment(0, 1)
dtab.pack_start(lab, True, True, 0)
self.filenamesel = gtk.Entry()
dtab.pack_start(self.filenamesel, True, False, 0)
self.downloadsafeCheck = gtk.CheckButton("Force safe _filenames for dos/fat filesystems")
dtab.pack_start(self.downloadsafeCheck, False, False, 0)
lab2 = gtk.Label("Default streaming applications:\n"
"Use this for each line:\n."
"filetype:/path/to/opener")
lab2.set_alignment(0, 1)
dtab.pack_start(lab2, True, False, 0)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.PolicyType.AUTOMATIC, gtk.PolicyType.AUTOMATIC)
self.viewer = gtk.TextView()
sw.add(self.viewer)
dtab.pack_start(sw, True, True, 0)
dtab.pack_start(gtk.Label("Podcast manager command: (%u is the url, %i is itpc:// url)"),True,True,0)
progs = gtk.ListStore(str)
progs.append(["amarok -l %i"])
progs.append(["gpodder -s %u"])
progs.append(["miro %u"])
progs.append(["rhythmbox %i"])
progs.append(["banshee %i"])
#Entry for custom program entry http://python-gtk-3-tutorial.readthedocs.io/en/latest/combobox.html
self.podcastprogbox = gtk.ComboBox.new_with_model_and_entry(progs)
renderer_text = gtk.CellRendererText()
#self.podcastprogbox.pack_start(renderer_text, True)
#self.podcastprogbox.add_attribute(renderer_text, "text",0)
self.podcastprogbox.set_entry_text_column(0)
dtab.pack_start(self.podcastprogbox, True, False, 0)
# End download tab
# Start of Display tab
self.homeEntry = gtk.Entry()
self.toolbarCheck = gtk.CheckButton("Show Toolbar")
self.statusbarCheck = gtk.CheckButton("Show Statusbar")
self.checkReleasedCol = gtk.CheckButton("Show release date column")
self.checkModifiedCol = gtk.CheckButton("Show modified date column")
self.checkZoomAll = gtk.CheckButton("Zoom text and images")
self.throbberCheck = gtk.CheckButton("Show Loading icon")
vtab.pack_start(gtk.Label("Home page:"), False, False, 0)
vtab.pack_start(self.homeEntry, False, False, 0)
vtab.pack_start(self.toolbarCheck, False, False, 0)
vtab.pack_start(self.statusbarCheck, False, False, 0)
vtab.pack_start(self.checkReleasedCol, False, False, 0)
vtab.pack_start(self.checkModifiedCol, False, False, 0)
vtab.pack_start(self.checkZoomAll, False, False, 0)
vtab.pack_start(self.throbberCheck, False, False, 0)
hbox = gtk.HBox()
hbox.pack_start(gtk.Label("Show download notification for "),
False, False, 0)
self.notifyEntry = gtk.Entry()
hbox.pack_start(self.notifyEntry, False, False, 0)
hbox.pack_start(gtk.Label("seconds."), False, False, 0)
vtab.pack_start(hbox, True, False, 0)
hbox = gtk.HBox()
hbox.pack_start(gtk.Label("Icon size: "), False, False, 0)
self.iconsize = gtk.Entry()
self.iconsize.set_width_chars(3)
hbox.pack_start(self.iconsize, False, False, 0)
hbox.pack_start(gtk.Label(" Image size: "), False, False, 0)
self.imagesize = gtk.Entry()
self.imagesize.set_width_chars(3)
hbox.pack_start(self.imagesize, False, False, 0)
vtab.pack_start(hbox, True, False, 0)
# default program frame:
defFrame = gtk.Frame(label="Default handler for itms, itmss, itpc protocols:")
vtab.pack_start(defFrame,True,True,0)
defv = gtk.VBox()
defFrame.add(defv)
setbutton = gtk.Button("Set TunesViewer as default opener")
setbutton.connect("clicked", firstsetup.setdefault)
defv.pack_start(setbutton, True, False, 0)
self.setOtherProg = gtk.Entry()
self.setOtherProg.set_text("rhythmbox %s")
setother = gtk.Button("Set Default")
setother.connect("clicked", self.setOtherDefault)
otherHbox = gtk.HBox()
otherHbox.pack_start(gtk.Label("Other program:"),True,True,0)
otherHbox.pack_start(self.setOtherProg,True,True,0)
otherHbox.pack_start(setother,True,True,0)
defv.pack_start(otherHbox, True, False, 0)
# End display tab
self.enableSentryCheck = gtk.CheckButton("Send crash reports to improve Tunesviewer\n - The cause of exceptions and basic system information\n such as operating system version may be sent for debugging purposes.")
moduletab.pack_start( self.enableSentryCheck,True,True,0)
self.enableAdBlockCheck = gtk.CheckButton("Block promos and advertisements\n - Hide promos and apps that do not work on Linux anyway.")
moduletab.pack_start(self.enableAdBlockCheck,True,True,0)
#Set initial configuration:
self.load_settings()
def __init__(self,
iso_path=None,
usb_path=None,
filesystem=None,
mode=None,
debug=False):
self.debug = debug
def device_added_callback(device):
#self.logger(_('Device %s was added' % (device))
self.get_devices()
def device_removed_callback(device):
#self.logger(_('Device %s has been removed' % (device))
self.get_devices()
proxy = bus.get_object("org.freedesktop.UDisks",
"/org/freedesktop/UDisks")
self.iface = dbus.Interface(proxy, "org.freedesktop.UDisks")
self.iface.connect_to_signal('DeviceAdded', device_added_callback)
self.iface.connect_to_signal('DeviceRemoved', device_removed_callback)
# get glade tree
self.gladefile = "/usr/share/usboot/usboot.ui"
self.wTree = Gtk.Builder()
APP = "usboot"
DIR = "/usr/share/chitwanix/locale"
locale.setlocale(locale.LC_ALL, '')
locale.bindtextdomain(APP, DIR)
gettext.bindtextdomain(APP, DIR)
gettext.textdomain(APP)
self.wTree.set_translation_domain(APP)
self.wTree.add_from_file(self.gladefile)
self.ddpid = 0
self.emergency_dialog = self.wTree.get_object("emergency_dialog")
self.confirm_dialog = self.wTree.get_object("confirm_dialog")
self.success_dialog = self.wTree.get_object("success_dialog")
if mode == "iso":
self.mode = "normal"
self.devicelist = self.wTree.get_object("device_combobox")
self.label = self.wTree.get_object("to_label")
self.expander = self.wTree.get_object("detail_expander")
self.go_button = self.wTree.get_object("write_button")
self.logview = self.wTree.get_object("detail_text")
self.progress = self.wTree.get_object("progressbar")
self.chooser = self.wTree.get_object("filechooserbutton")
# Devicelist model
self.devicemodel = Gtk.ListStore(str, str)
# Renderer
renderer_text = Gtk.CellRendererText()
self.devicelist.pack_start(renderer_text, True)
self.devicelist.add_attribute(renderer_text, "text", 1)
self.get_devices()
# get globally needed widgets
self.window = self.wTree.get_object("main_dialog")
self.window.connect("destroy", self.close)
# set default file filter to *.img
filt = Gtk.FileFilter()
filt.add_pattern("*.img")
filt.add_pattern("*.iso")
self.chooser.set_filter(filt)
# set callbacks
dict = {
"on_cancel_button_clicked": self.close,
"on_emergency_button_clicked": self.emergency_ok,
"on_success_button_clicked": self.success_ok,
"on_confirm_cancel_button_clicked": self.confirm_cancel
}
self.wTree.connect_signals(dict)
self.devicelist.connect("changed", self.device_selected)
self.go_button.connect("clicked", self.do_write)
self.chooser.connect("file-set", self.file_selected)
if iso_path:
if os.path.exists(iso_path):
self.chooser.set_filename(iso_path)
self.file_selected(self.chooser)
if mode == "format":
self.mode = "format"
self.devicelist = self.wTree.get_object("formatdevice_combobox")
self.label = self.wTree.get_object("formatdevice_label")
self.expander = self.wTree.get_object("formatdetail_expander")
self.go_button = self.wTree.get_object("format_formatbutton")
self.logview = self.wTree.get_object("format_detail_text")
self.window = self.wTree.get_object("format_window")
self.window.connect("destroy", self.close)
self.spinner = self.wTree.get_object("format_spinner")
self.filesystemlist = self.wTree.get_object("filesystem_combobox")
# set callbacks
dict = {
"on_cancel_button_clicked": self.close,
"on_emergency_button_clicked": self.emergency_ok,
"on_success_button_clicked": self.success_ok,
"on_confirm_cancel_button_clicked": self.confirm_cancel
}
self.wTree.connect_signals(dict)
self.go_button.connect("clicked", self.do_format)
self.filesystemlist.connect("changed", self.filesystem_selected)
self.devicelist.connect("changed", self.device_selected)
# Filesystemlist
self.fsmodel = Gtk.ListStore(str, str)
self.fsmodel.append(["fat32", "FAT32"])
self.fsmodel.append(["ntfs", "NTFS"])
self.fsmodel.append(["ext4", "EXT4"])
self.filesystemlist.set_model(self.fsmodel)
# Renderer
renderer_text = Gtk.CellRendererText()
self.filesystemlist.pack_start(renderer_text, True)
self.filesystemlist.add_attribute(renderer_text, "text", 1)
# Devicelist model
self.devicemodel = Gtk.ListStore(str, str)
# Renderer
renderer_text = Gtk.CellRendererText()
self.devicelist.pack_start(renderer_text, True)
self.devicelist.add_attribute(renderer_text, "text", 1)
self.filesystemlist.set_sensitive(True)
# Default's to fat32
self.filesystemlist.set_active(0)
if filesystem is not None:
iter = model.get_iter_first()
while iter is not None:
value = model.get_value(iter, 0)
if value == filesystem:
self.filesystemlist.set_active_iter(iter)
iter = model.iter_next(iter)
self.filesystem_selected(self.filesystemlist)
self.get_devices()
if usb_path is not None:
iter = self.devicemodel.get_iter_first()
while iter is not None:
value = self.devicemodel.get_value(iter, 0)
if usb_path in value:
self.devicelist.set_active_iter(iter)
iter = self.devicemodel.iter_next(iter)
self.window.show_all()
if self.mode == "format":
self.spinner.hide()
self.expander.hide()
self.log = self.logview.get_buffer()
def __init__(self, app, effects_properties_manager, clip_properties):
Gtk.Expander.__init__(self)
self.set_expanded(True)
self.set_label(_("Effects"))
Loggable.__init__(self)
# Global variables related to effects
self.app = app
self.settings = app.settings
self.selected_effects = []
self.clips = []
self._effect_config_ui = None
self.effects_properties_manager = effects_properties_manager
self.clip_properties = clip_properties
self._config_ui_h_pos = None
self._timeline = None
# The toolbar that will go between the list of effects and properties
self._toolbar = Gtk.Toolbar()
self._toolbar.get_style_context().add_class(
Gtk.STYLE_CLASS_INLINE_TOOLBAR)
self._toolbar.set_icon_size(Gtk.IconSize.SMALL_TOOLBAR)
removeEffectButton = Gtk.ToolButton()
removeEffectButton.set_icon_name("list-remove-symbolic")
removeEffectButton.set_label(_("Remove effect"))
removeEffectButton.set_is_important(True)
self._toolbar.insert(removeEffectButton, 0)
# Treeview to display a list of effects (checkbox, effect type and
# name)
self.treeview_scrollwin = Gtk.ScrolledWindow()
self.treeview_scrollwin.set_policy(Gtk.PolicyType.NEVER,
Gtk.PolicyType.AUTOMATIC)
self.treeview_scrollwin.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
# We need to specify Gtk.TreeDragSource because otherwise we are hitting
# bug https://bugzilla.gnome.org/show_bug.cgi?id=730740.
class EffectsListStore(Gtk.ListStore, Gtk.TreeDragSource):
def __init__(self, *args):
Gtk.ListStore.__init__(self, *args)
# Simply set the source index on the storemodrel directly
# to avoid issues with the selection_data API
# FIXME: Work around https://bugzilla.gnome.org/show_bug.cgi?id=737587
self.source_index = None
def do_drag_data_get(self, path, selection_data):
self.source_index = path.get_indices()[0]
self.storemodel = EffectsListStore(bool, str, str, str, str, object)
self.treeview = Gtk.TreeView(model=self.storemodel)
self.treeview_scrollwin.add(self.treeview)
self.treeview.set_property("has_tooltip", True)
self.treeview.set_headers_clickable(False)
self.treeview.get_selection().set_mode(Gtk.SelectionMode.SINGLE)
activatedcell = Gtk.CellRendererToggle()
activatedcell.props.xpad = PADDING
activatedcell.connect("toggled", self._effectActiveToggleCb)
activatedcol = self.treeview.insert_column_with_attributes(
-1, _("Active"), activatedcell, active=COL_ACTIVATED)
typecol = Gtk.TreeViewColumn(_("Type"))
typecol.set_spacing(SPACING)
typecol.set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE)
typecell = Gtk.CellRendererText()
typecell.props.xpad = PADDING
typecell.set_property("ellipsize", Pango.EllipsizeMode.END)
typecol.pack_start(typecell, True)
typecol.add_attribute(typecell, "text", COL_TYPE)
self.treeview.append_column(typecol)
namecol = Gtk.TreeViewColumn(_("Effect name"))
namecol.set_spacing(SPACING)
namecell = Gtk.CellRendererText()
namecell.props.xpad = PADDING
namecell.set_property("ellipsize", Pango.EllipsizeMode.END)
namecol.pack_start(namecell, True)
namecol.add_attribute(namecell, "text", COL_NAME_TEXT)
self.treeview.append_column(namecol)
# Allow the treeview to accept EFFECT_TARGET_ENTRY when drag&dropping.
self.treeview.enable_model_drag_dest([EFFECT_TARGET_ENTRY],
Gdk.DragAction.COPY)
# Enable reordering by drag&drop.
self.treeview.enable_model_drag_source(Gdk.ModifierType.BUTTON1_MASK,
[EFFECT_TARGET_ENTRY],
Gdk.DragAction.MOVE)
self.selection = self.treeview.get_selection()
self._infobar = clip_properties.createInfoBar(
_("Select a clip on the timeline to configure its associated effects"
))
# Prepare the main container widgets and lay out everything
self._vcontent = Gtk.VPaned()
self._table = Gtk.Table(n_rows=3, n_columns=1, homogeneous=False)
self._table.attach(self.treeview_scrollwin, 0, 1, 0, 1)
self._table.attach(self._toolbar,
0,
1,
2,
3,
yoptions=Gtk.AttachOptions.FILL)
self._vcontent.pack1(self._table, resize=True, shrink=False)
self.add(self._vcontent)
self._vcontent.show()
self._table.show_all()
self._infobar.show_all()
self._toolbar.hide()
self.hide()
# Connect all the widget signals
self.selection.connect("changed", self._treeviewSelectionChangedCb)
self.treeview.connect("drag-motion", self._dragMotionCb)
self.treeview.connect("drag-leave", self._dragLeaveCb)
self.treeview.connect("drag-data-received", self._dragDataReceivedCb)
self.treeview.connect("query-tooltip", self._treeViewQueryTooltipCb)
self._vcontent.connect("notify", self._vcontentNotifyCb)
removeEffectButton.connect("clicked", self._removeEffectCb)
self.app.project_manager.connect("new-project-loaded",
self._newProjectLoadedCb)
self.connect('notify::expanded', self._expandedCb)
self.connected = False
def __init__(self, library):
super(MediaDevices, self).__init__(spacing=6)
self.set_orientation(Gtk.Orientation.VERTICAL)
self._register_instance()
self.__cache = {}
# Device list on the left pane
swin = ScrolledWindow()
swin.set_shadow_type(Gtk.ShadowType.IN)
swin.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
self.pack_start(swin, True, True, 0)
self.__view = view = AllTreeView()
view.set_model(self.__devices)
view.set_rules_hint(True)
view.set_headers_visible(False)
view.get_selection().set_mode(Gtk.SelectionMode.BROWSE)
connect_obj(view.get_selection(), 'changed', self.__refresh, False)
view.connect('popup-menu', self.__popup_menu, library)
view.connect('row-activated', lambda *a: self.songs_activated())
swin.add(view)
col = Gtk.TreeViewColumn("Devices")
view.append_column(col)
render = Gtk.CellRendererPixbuf()
col.pack_start(render, False)
col.add_attribute(render, 'icon-name', 1)
self.__render = render = Gtk.CellRendererText()
render.set_property('ellipsize', Pango.EllipsizeMode.END)
render.connect('edited', self.__edited)
col.pack_start(render, True)
col.set_cell_data_func(render, MediaDevices.cell_data)
hbox = Gtk.HBox(spacing=6)
hbox.set_homogeneous(True)
self.pack_start(Align(hbox, left=3, bottom=3), False, True, 0)
# refresh button
refresh = Button(_("_Refresh"), Icons.VIEW_REFRESH, Gtk.IconSize.MENU)
self.__refresh_button = refresh
connect_obj(refresh, 'clicked', self.__refresh, True)
refresh.set_sensitive(False)
hbox.pack_start(refresh, True, True, 0)
# eject button
eject = Button(_("_Eject"), Icons.MEDIA_EJECT, Gtk.IconSize.MENU)
self.__eject_button = eject
eject.connect('clicked', self.__eject)
eject.set_sensitive(False)
hbox.pack_start(eject, True, True, 0)
# Device info on the right pane
self.__header = table = Gtk.Table()
table.set_col_spacings(8)
self.__device_icon = icon = Gtk.Image()
icon.set_size_request(48, 48)
table.attach(icon, 0, 1, 0, 2, 0)
self.__device_name = label = Gtk.Label()
label.set_ellipsize(Pango.EllipsizeMode.END)
label.set_alignment(0, 0)
table.attach(label, 1, 3, 0, 1)
self.__device_space = label = Gtk.Label()
label.set_ellipsize(Pango.EllipsizeMode.END)
label.set_alignment(0, 0.5)
table.attach(label, 1, 2, 1, 2)
self.__progress = progress = Gtk.ProgressBar()
progress.set_size_request(150, -1)
table.attach(progress, 2, 3, 1, 2, xoptions=0, yoptions=0)
self.accelerators = Gtk.AccelGroup()
key, mod = Gtk.accelerator_parse('F2')
self.accelerators.connect(key, mod, 0, self.__rename)
self.__statusbar = WaitLoadBar()
for child in self.get_children():
child.show_all()
def vdpauinfo(tab2):
def vdpauInformation():
os.system(
"cat /tmp/gpu-viewer/vdpauinfo.txt | grep -E 'API|string' > /tmp/gpu-viewer/vdpauInformation.txt"
)
with open("/tmp/gpu-viewer/vdpauInformation.txt", "r") as file:
for i, line in enumerate(file):
vdpauinfoStore.append(None, [
' '.join(line.split()[0:2]).strip('[]'), ' '.join(
line.split()[2:]).strip('[]'),
setBackgroundColor(i)
])
iter = vdpauinfoStore.append(
None, ["Supported Codecs:", ' ', Const.BGCOLOR3])
with open("/tmp/gpu-viewer/vdpauDecoder.txt", "r") as file1:
i = 1
for line in file1:
if "not" not in line:
vdpauinfoStore.append(iter, [
"",
line.split()[0].strip('\n'),
setBackgroundColor(i)
])
i = i + 1
treeVdpauInfo.expand_all()
def decoderCapabilities():
os.system(
"cat /tmp/gpu-viewer/vdpauinfo.txt | awk '/Decoder capabilities:/{flag=1;next}/Output surface:/{flag=0}flag' | awk '/------.*/{flag=1;next}/Output surface:/{flag=0}flag' | awk '/./'> /tmp/gpu-viewer/vdpauDecoder.txt"
)
with open("/tmp/gpu-viewer/vdpauDecoder.txt", "r") as file1:
for i, line in enumerate(file1):
if "not" in line:
decoderStore.append([
line.split()[0].strip('\n'), "not supported",
"not supported", "not supported", "not supported",
setBackgroundColor(i)
])
else:
decoderStore.append([
line.split()[0].strip('\n'),
line.split()[1].strip('\n'),
line.split()[2].strip('\n'),
line.split()[3].strip('\n'),
line.split()[4].strip('\n'),
setBackgroundColor(i)
])
def videoSurfaceLimits():
os.system(
"cat /tmp/gpu-viewer/vdpauinfo.txt | awk '/Video surface:/{flag=1;next}/Decoder capabilities:/{flag=0}flag' | awk '/-------.*/{flag=1;next}/Bitmap surface:/{flag=0}flag' | awk '/./' > /tmp/gpu-viewer/vdpauVideoSurfaceLimits.txt"
)
iter = surfaceVideoStore.append(
None, ["Video Surface", "", "", "", Const.BGCOLOR3])
with open("/tmp/gpu-viewer/vdpauVideoSurfaceLimits.txt", "r") as file1:
for i, line in enumerate(file1):
surfaceVideoStore.append(iter, [
line.split()[0].strip('\n'),
line.split()[1].strip('\n'),
line.split()[2].strip('\n'),
(' '.join(line.split()[3:]).strip('[]')),
setBackgroundColor(i)
])
os.system(
"cat /tmp/gpu-viewer/vdpauinfo.txt | awk '/Output surface:/{flag=1;next}/Bitmap surface:/{flag=0}flag' | awk '/-------.*/{flag=1;next}/Bitmap surface:/{flag=0}flag' | awk '/./' > /tmp/gpu-viewer/vdpauSurfaceOutputLimits.txt"
)
iter = surfaceVideoStore.append(
None, ["Output Surface", "", "", "", Const.BGCOLOR3])
with open("/tmp/gpu-viewer/vdpauSurfaceOutputLimits.txt", "r") as file:
for i, line in enumerate(file):
surfaceVideoStore.append(iter, [
line.split()[0].strip('\n'),
line.split()[1].strip('\n'),
line.split()[2], (' '.join(line.split()[4:]).strip('[]')),
setBackgroundColor(i)
])
os.system(
"cat /tmp/gpu-viewer/vdpauinfo.txt | awk '/Bitmap surface:/{flag=1;next}/Video mixer:/{flag=0}flag' | awk '/-------.*/{flag=1;next}/Video mixer:/{flag=0}flag' | awk '/./' > /tmp/gpu-viewer/vdpauSurfaceBitmapLimits.txt"
)
iter = surfaceVideoStore.append(
None, ["Bitmap Surface", "", "", "", Const.BGCOLOR3])
with open("/tmp/gpu-viewer/vdpauSurfaceBitmapLimits.txt", "r") as file:
for i, line in enumerate(file):
surfaceVideoStore.append(iter, [
line.split()[0].strip('\n'),
line.split()[1].strip('\n'),
line.split()[2].strip('\n'), "",
setBackgroundColor(i)
])
treeSurfaceVideoLimits.expand_all()
def VideoMixerFeature():
os.system(
"cat /tmp/gpu-viewer/vdpauinfo.txt | awk '/feature name/{flag=1;next}/parameter name.*/{flag=0}flag' | awk '/-------.*/{flag=1;next}/Output surface:/{flag=0}flag' | awk '/./' > /tmp/gpu-viewer/vdpauVideoMixerFeature.txt"
)
iter = videoMixerFeatureStore.append(
None, ["Features", "", Const.BGCOLOR3, ""])
with open("/tmp/gpu-viewer/vdpauVideoMixerFeature.txt", "r") as file2:
for i, line in enumerate(file2):
if 'y' in line:
text = "true"
fgcolor = Const.COLOR1
else:
text = "false"
fgcolor = Const.COLOR2
if "HIGH" in line:
videoMixerFeatureStore.append(
iter, [(' '.join(line.split()[0:5])).strip('[]'), text,
setBackgroundColor(i), fgcolor])
else:
videoMixerFeatureStore.append(iter, [
line.split()[0].strip('\n'), text,
setBackgroundColor(i), fgcolor
])
os.system(
"cat /tmp/gpu-viewer/vdpauinfo.txt | awk '/parameter name/{flag=1;next}/attribute name.*/{flag=0}flag' | awk '/-------.*/{flag=1;next}/Output surface:/{flag=0}flag' | awk '/./' > /tmp/gpu-viewer/vdpauVideoMixerParameter.txt"
)
iter = videoMixerFeatureStore.append(
None, ["Parameters", "", Const.BGCOLOR3, ""])
with open("/tmp/gpu-viewer/vdpauVideoMixerParameter.txt",
"r") as file2:
for i, line in enumerate(file2):
if line.split()[1].strip('\n') == 'y':
text = "true"
fgcolor = Const.COLOR1
else:
text = "false"
fgcolor = Const.COLOR2
videoMixerFeatureStore.append(iter, [
line.split()[0].strip('\n'), text,
setBackgroundColor(i), fgcolor
])
os.system(
"cat /tmp/gpu-viewer/vdpauinfo.txt | awk '/Video mixer:/{flag=1;next}/Output surface:/{flag=0}flag' | awk '/attribute name/{flag=1;next}/Output surface:/{flag=0}flag' | awk '/-------.*/{flag=1;next}/Output surface:/{flag=0}flag' | awk '/./' > /tmp/gpu-viewer/vdpauVideoMixerAttribute.txt"
)
iter = videoMixerFeatureStore.append(
None, ["Attributes", "", Const.BGCOLOR3, ""])
with open("/tmp/gpu-viewer/vdpauVideoMixerAttribute.txt",
"r") as file2:
for i, line in enumerate(file2):
if line.split()[1].strip('\n') == 'y':
text = "true"
fgcolor = Const.COLOR1
else:
text = "false"
fgcolor = Const.COLOR2
videoMixerFeatureStore.append(iter, [
line.split()[0].strip('\n'), text,
setBackgroundColor(i), fgcolor
])
treeVideoMixerFeature.expand_all()
grid = Gtk.Grid()
tab2.add(grid)
DevicesFrame = Gtk.Frame()
grid.add(DevicesFrame)
notebook = Gtk.Notebook()
notebook.set_property("scrollable", True)
notebook.set_property("enable-popup", True)
grid.attach(notebook, 0, 2, 1, 1)
# ------- VDPAU information -------------------------------
vdpauinfoTab = Gtk.Box(spacing=20)
vdpauinfoGrid = createSubTab(vdpauinfoTab, notebook, "VDPAU Information")
vdpauinfoStore = Gtk.TreeStore(str, str, str)
treeVdpauInfo = Gtk.TreeView(vdpauinfoStore, expand=True)
setColumns(treeVdpauInfo, vdpauinfoTitle, 300, 0.0)
vdpauinfoScrollbar = createScrollbar(treeVdpauInfo)
vdpauinfoGrid.add(vdpauinfoScrollbar)
# ------- Decoder Capabilities ----------------------------
decoderTab = Gtk.Box(spacing=20)
decoderGrid = createSubTab(decoderTab, notebook, "Decoder Capabilities")
decoderStore = Gtk.ListStore(str, str, str, str, str, str)
treeDecoder = Gtk.TreeView(decoderStore, expand=True)
setColumns(treeDecoder, decoderTitle, 300, 0.0)
decoderScrollbar = createScrollbar(treeDecoder)
decoderGrid.add(decoderScrollbar)
# -------- Surface Limits -----------------------------------
surfaceTab = Gtk.Box(spacing=20)
surfaceGrid = createSubTab(surfaceTab, notebook, "Surface Limits")
surfaceVideoStore = Gtk.TreeStore(str, str, str, str, str)
treeSurfaceVideoLimits = Gtk.TreeView(surfaceVideoStore, expand=True)
treeSurfaceVideoLimits.set_property("enable-tree-lines", True)
setColumns(treeSurfaceVideoLimits, surfaceVideoTitle, 300, 0.0)
surfaceVideoScrollbar = createScrollbar(treeSurfaceVideoLimits)
surfaceGrid.add(surfaceVideoScrollbar)
# -------- Video Mixer ---------------------------------------
videoMixerTab = Gtk.Box(spacing=20)
videoMixerGrid = createSubTab(videoMixerTab, notebook, "Video Mixer")
videoMixerGrid.set_row_spacing(20)
videoMixerFeatureStore = Gtk.TreeStore(str, str, str, str)
treeVideoMixerFeature = Gtk.TreeView(videoMixerFeatureStore, expand=True)
treeVideoMixerFeature.set_property("enable-tree-lines", True)
treeVideoMixerFeature.set_enable_search(True)
for i, column_title in enumerate(videoMixerFeatureTitle):
videoMixerrenderer = Gtk.CellRendererText()
# Queuerenderer.set_alignment(0.5, 0.5)
column = Gtk.TreeViewColumn(column_title, videoMixerrenderer, text=i)
# column.set_alignment(0.5)
column.add_attribute(videoMixerrenderer, "background", 2)
column.set_sort_column_id(i)
column.set_resizable(True)
column.set_reorderable(True)
if i > 0:
column.add_attribute(videoMixerrenderer, "foreground", 3)
treeVideoMixerFeature.set_property("can-focus", False)
treeVideoMixerFeature.append_column(column)
videoMixerFeatureScrollbar = createScrollbar(treeVideoMixerFeature)
videoMixerGrid.add(videoMixerFeatureScrollbar)
decoderCapabilities()
videoSurfaceLimits()
VideoMixerFeature()
vdpauInformation()
def _init_ui(self):
self.widget("storage-pages").set_show_tabs(False)
# These are enabled in storagebrowser.py
self.widget("browse-local").set_visible(False)
self.widget("browse-cancel").set_visible(False)
self.widget("choose-volume").set_visible(False)
# Volume list popup menu
self._volmenu = Gtk.Menu()
volCopyPath = Gtk.ImageMenuItem.new_with_label(_("Copy Volume Path"))
volCopyImage = Gtk.Image()
volCopyImage.set_from_stock(Gtk.STOCK_COPY, Gtk.IconSize.MENU)
volCopyPath.set_image(volCopyImage)
volCopyPath.show()
volCopyPath.connect("activate", self._vol_copy_path)
self._volmenu.add(volCopyPath)
# Volume list
# [key, name, sizestr, capacity, format, in use by string, sensitive]
volListModel = Gtk.ListStore(str, str, str, str, str, str, bool)
self.widget("vol-list").set_model(volListModel)
volCol = Gtk.TreeViewColumn(_("Volumes"))
vol_txt1 = Gtk.CellRendererText()
volCol.pack_start(vol_txt1, True)
volCol.add_attribute(vol_txt1, 'text', VOL_COLUMN_NAME)
volCol.add_attribute(vol_txt1, 'sensitive', VOL_COLUMN_SENSITIVE)
volCol.set_sort_column_id(VOL_COLUMN_NAME)
self.widget("vol-list").append_column(volCol)
volSizeCol = Gtk.TreeViewColumn(_("Size"))
vol_txt2 = Gtk.CellRendererText()
volSizeCol.pack_start(vol_txt2, False)
volSizeCol.add_attribute(vol_txt2, 'text', VOL_COLUMN_SIZESTR)
volSizeCol.add_attribute(vol_txt2, 'sensitive', VOL_COLUMN_SENSITIVE)
volSizeCol.set_sort_column_id(VOL_COLUMN_CAPACITY)
self.widget("vol-list").append_column(volSizeCol)
volListModel.set_sort_func(VOL_COLUMN_CAPACITY, self._cap_sort_func)
volFormatCol = Gtk.TreeViewColumn(_("Format"))
vol_txt3 = Gtk.CellRendererText()
volFormatCol.pack_start(vol_txt3, False)
volFormatCol.add_attribute(vol_txt3, 'text', VOL_COLUMN_FORMAT)
volFormatCol.add_attribute(vol_txt3, 'sensitive', VOL_COLUMN_SENSITIVE)
volFormatCol.set_sort_column_id(VOL_COLUMN_FORMAT)
self.widget("vol-list").append_column(volFormatCol)
volUseCol = Gtk.TreeViewColumn(_("Used By"))
vol_txt4 = Gtk.CellRendererText()
volUseCol.pack_start(vol_txt4, False)
volUseCol.add_attribute(vol_txt4, 'text', VOL_COLUMN_INUSEBY)
volUseCol.add_attribute(vol_txt4, 'sensitive', VOL_COLUMN_SENSITIVE)
volUseCol.set_sort_column_id(VOL_COLUMN_INUSEBY)
self.widget("vol-list").append_column(volUseCol)
volListModel.set_sort_column_id(VOL_COLUMN_NAME,
Gtk.SortType.ASCENDING)
# Init pool list
# [connkey, label, pool.is_active(), percent string]
pool_list = self.widget("pool-list")
poolListModel = Gtk.ListStore(str, str, bool, str)
pool_list.set_model(poolListModel)
poolCol = Gtk.TreeViewColumn(_("Storage Pools"))
pool_txt = Gtk.CellRendererText()
pool_per = Gtk.CellRendererText()
poolCol.pack_start(pool_per, False)
poolCol.pack_start(pool_txt, True)
poolCol.add_attribute(pool_txt, 'markup', POOL_COLUMN_LABEL)
poolCol.add_attribute(pool_txt, 'sensitive', POOL_COLUMN_ISACTIVE)
poolCol.add_attribute(pool_per, 'markup', POOL_COLUMN_PERCENT)
pool_list.append_column(poolCol)
poolListModel.set_sort_column_id(POOL_COLUMN_LABEL,
Gtk.SortType.ASCENDING)
pool_list.get_selection().connect("changed", self._pool_selected)
pool_list.get_selection().set_select_function(
(lambda *x: self._confirm_changes()), None)
# Populate list and connect conn signals
self._populate_pools()
self.conn.connect("pool-added", self._conn_pool_count_changed)
self.conn.connect("pool-removed", self._conn_pool_count_changed)
self.conn.connect("state-changed", self._conn_state_changed)
self._conn_state_changed()
def ratings_vbox(self):
"""Returns a new VBox containing all ratings widgets"""
vb = Gtk.VBox(spacing=6)
# Default Rating
model = Gtk.ListStore(float)
default_combo = Gtk.ComboBox(model=model)
default_lab = Gtk.Label(label=_("_Default rating:"))
default_lab.set_use_underline(True)
default_lab.set_alignment(0, 0.5)
def draw_rating(column, cell, model, it, data):
num = model[it][0]
text = "%0.2f: %s" % (num, util.format_rating(num))
cell.set_property('text', text)
def default_rating_changed(combo, model):
it = combo.get_active_iter()
if it is None:
return
RATINGS.default = model[it][0]
qltk.redraw_all_toplevels()
def populate_default_rating_model(combo, num):
model = combo.get_model()
model.clear()
deltas = []
default = RATINGS.default
precision = RATINGS.precision
for i in range(0, num + 1):
r = i * precision
model.append(row=[r])
deltas.append((abs(default - r), i))
active = sorted(deltas)[0][1]
print_d("Choosing #%d (%.2f), closest to current %.2f" %
(active, precision * active, default))
combo.set_active(active)
cell = Gtk.CellRendererText()
default_combo.pack_start(cell, True)
default_combo.set_cell_data_func(cell, draw_rating, None)
default_combo.connect('changed', default_rating_changed, model)
default_lab.set_mnemonic_widget(default_combo)
def refresh_default_combo(num):
populate_default_rating_model(default_combo, num)
# Rating Scale
model = Gtk.ListStore(int)
scale_combo = Gtk.ComboBox(model=model)
scale_lab = Gtk.Label(label=_("Rating _scale:"))
scale_lab.set_use_underline(True)
scale_lab.set_mnemonic_widget(scale_combo)
cell = Gtk.CellRendererText()
scale_combo.pack_start(cell, False)
num = RATINGS.number
for i in [1, 2, 3, 4, 5, 6, 8, 10]:
it = model.append(row=[i])
if i == num:
scale_combo.set_active_iter(it)
def draw_rating_scale(column, cell, model, it, data):
num_stars = model[it][0]
text = "%d: %s" % (num_stars, RATINGS.full_symbol * num_stars)
cell.set_property('text', text)
def rating_scale_changed(combo, model):
it = combo.get_active_iter()
if it is None:
return
RATINGS.number = num = model[it][0]
refresh_default_combo(num)
refresh_default_combo(RATINGS.number)
scale_combo.set_cell_data_func(cell, draw_rating_scale, None)
scale_combo.connect('changed', rating_scale_changed, model)
default_align = Align(halign=Gtk.Align.START)
default_align.add(default_lab)
scale_align = Align(halign=Gtk.Align.START)
scale_align.add(scale_lab)
grid = Gtk.Grid(column_spacing=6, row_spacing=6)
grid.add(scale_align)
grid.add(scale_combo)
grid.attach(default_align, 0, 1, 1, 1)
grid.attach(default_combo, 1, 1, 1, 1)
vb.pack_start(grid, False, False, 6)
# Bayesian Factor
bayesian_factor = config.getfloat("settings",
"bayesian_rating_factor", 0.0)
adj = Gtk.Adjustment.new(bayesian_factor, 0.0, 10.0, 0.5, 0.5, 0.0)
bayes_spin = Gtk.SpinButton(adjustment=adj, numeric=True)
bayes_spin.set_digits(1)
bayes_spin.connect('changed', self.__changed_and_signal_library,
'settings', 'bayesian_rating_factor')
bayes_spin.set_tooltip_text(
_("Bayesian Average factor (C) for aggregated ratings.\n"
"0 means a conventional average, higher values mean that "
"albums with few tracks will have less extreme ratings. "
"Changing this value triggers a re-calculation for all "
"albums."))
bayes_label = Gtk.Label(label=_("_Bayesian averaging amount:"))
bayes_label.set_use_underline(True)
bayes_label.set_mnemonic_widget(bayes_spin)
# Save Ratings
hb = Gtk.HBox(spacing=6)
hb.pack_start(bayes_label, False, True, 0)
hb.pack_start(bayes_spin, False, True, 0)
vb.pack_start(hb, True, True, 0)
cb = CCB(_("Save ratings and play _counts"),
"editing",
"save_to_songs",
populate=True)
vb.pack_start(cb, True, True, 0)
hb = Gtk.HBox(spacing=6)
lab = Gtk.Label(label=_("_Email:"))
entry = UndoEntry()
entry.set_tooltip_text(
_("Ratings and play counts will be set "
"for this email address"))
entry.set_text(config.get("editing", "save_email"))
entry.connect('changed', self.__changed, 'editing', 'save_email')
hb.pack_start(lab, False, True, 0)
hb.pack_start(entry, True, True, 0)
lab.set_mnemonic_widget(entry)
lab.set_use_underline(True)
vb.pack_start(hb, True, True, 0)
return vb
def __init__(self, parent):
if not Dialog.running:
Dialog.running = True
else:
return
self.config = None
self.parent = parent
builder = Gtk.Builder()
builder.add_from_file(UI_PATH + "/net-usage.ui")
builder.set_translation_domain("blueman")
self.dialog = builder.get_object("dialog")
self.dialog.connect("response", self.on_response)
cr1 = Gtk.CellRendererText()
cr1.props.ellipsize = Pango.EllipsizeMode.END
self.devices = {}
self._signals = [
parent.connect("monitor-added", self.monitor_added),
parent.connect("monitor-removed", self.monitor_removed),
parent.connect("stats", self.on_stats)
]
cr2 = Gtk.CellRendererText()
cr2.props.sensitive = False
cr2.props.style = Pango.Style.ITALIC
self.liststore = Gtk.ListStore(str, str, str, object)
self.e_ul = builder.get_object("e_ul")
self.e_dl = builder.get_object("e_dl")
self.e_total = builder.get_object("e_total")
self.l_started = builder.get_object("l_started")
self.l_duration = builder.get_object("l_duration")
self.b_reset = builder.get_object("b_reset")
self.b_reset.connect("clicked", self.on_reset)
self.cb_device = builder.get_object("cb_device")
self.cb_device.props.model = self.liststore
self.cb_device.connect("changed", self.on_selection_changed)
self.cb_device.pack_start(cr1, True)
self.cb_device.add_attribute(cr1, 'markup', 1)
self.cb_device.pack_start(cr2, False)
self.cb_device.add_attribute(cr2, 'markup', 2)
general_config = Config("org.blueman.general")
added = False
for d in general_config["netusage-dev-list"]:
for m in parent.monitors:
if d == m.device.Address:
iter = self.liststore.append([
d,
self.get_caption(m.device.Alias, m.device.Address),
_("Connected:") + " " + m.interface, m
])
if self.cb_device.get_active() == -1:
self.cb_device.set_active_iter(iter)
added = True
break
if not added:
name = d
if self.parent.Applet.Manager:
for a in self.parent.Applet.Manager.list_adapters():
try:
device = a.find_device(d)
device = Device(device)
name = self.get_caption(device.Alias,
device.Address)
except:
pass
self.liststore.append([d, name, _("Not Connected"), None])
added = False
if len(self.liststore) > 0:
if self.cb_device.get_active() == -1:
self.cb_device.set_active(0)
else:
d = Gtk.MessageDialog(
parent=self.dialog,
flags=Gtk.DialogFlags.MODAL,
type=Gtk.MessageType.INFO,
buttons=Gtk.ButtonsType.CLOSE,
message_format=
_("No usage statistics are available yet. Try establishing a connection first and then check this page."
))
d.props.icon_name = "blueman"
d.run()
d.destroy()
self.on_response(None, None)
return
self.dialog.show()
def __init__(self, operation, view):
Gtk.Grid.__init__(self)
self.set_orientation(Gtk.Orientation.VERTICAL)
self.set_row_spacing(style.DEFAULT_SPACING)
self.set_valign(Gtk.Align.CENTER)
self.set_halign(Gtk.Align.CENTER)
self._view = view
self._operation = operation
self._backend = None
_icon = Icon(icon_name='backup-%s' % operation,
pixel_size=style.XLARGE_ICON_SIZE)
self.add(_icon)
_icon.show()
self._message_label = Gtk.Label()
self._message_label.set_line_wrap(True)
self._message_label.set_width_chars(40)
self._message_label.set_single_line_mode(False)
align = Gtk.Alignment.new(0.5, 0.5, 0, 0)
align.set_padding(0, 0, style.GRID_CELL_SIZE * 2,
style.GRID_CELL_SIZE * 2)
align.show()
align.add(self._message_label)
self.add(align)
self._message_label.show()
self._options_combo = Gtk.ComboBox()
cell = Gtk.CellRendererText()
self._options_combo.pack_start(cell, True)
self._options_combo.add_attribute(cell, 'text', 0)
self.add(self._options_combo)
self._progress_bar = Gtk.ProgressBar()
self.add(self._progress_bar)
self._progress_bar.set_size_request(
Gdk.Screen.width() - style.GRID_CELL_SIZE * 6, -1)
self._confirm_restore_chkbtn = Gtk.CheckButton()
align = Gtk.Alignment()
align.set_padding(0, 0, style.GRID_CELL_SIZE * 2,
style.GRID_CELL_SIZE * 2)
align.show()
align.add(self._confirm_restore_chkbtn)
self.add(align)
btn_box = Gtk.ButtonBox()
btn_box.show()
self._continue_btn = Gtk.Button(_('Continue'))
btn_box.add(self._continue_btn)
self.add(btn_box)
self._continue_btn_handler_id = 0
self.show()
# check if there are activities running
# and request close them if any.
if self._view.manager.need_stop_activities():
self._message_label.set_text(
_('Please close all the activities, and start again'))
# check the backend availables, if there are more than one
# show to the user to select one
if len(self._view.manager.get_backends()) > 1:
if operation == OPERATION_BACKUP:
message = _('Select where you want create your backup')
if operation == OPERATION_RESTORE:
message = _('Select where you want retrieve your restore')
combo_options = []
for backend in self._view.manager.get_backends():
option = {}
option['description'] = backend.get_name()
option['value'] = backend
combo_options.append(option)
self._ask_options(message, combo_options, self._select_backend)
else:
self._backend = self._view.manager.get_backends()[0]
GLib.idle_add(self._start_operation)
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__(self):
super(PatternEditor, self).__init__(spacing=12)
self.__headers = headers = {}
buttons = []
group = None
for tags in self.PRESETS:
tied = "~" + "~".join([t[0] for t in tags])
group = Gtk.RadioButton(group=group,
label="_" + util.tag(tied),
use_underline=True)
headers[group] = tags
buttons.append(group)
group = Gtk.RadioButton(group=group,
label=_("_Custom"),
use_underline=True)
self.__custom = group
headers[group] = []
buttons.append(group)
button_box = Gtk.HBox(spacing=6)
self.__model = model = Gtk.ListStore(str, bool)
radio_box = Gtk.VBox(spacing=6)
for button in buttons:
radio_box.pack_start(button, False, True, 0)
button.connect('toggled', self.__toggled, button_box, model)
self.pack_start(radio_box, False, True, 0)
cb = TagsComboBoxEntry(self.COMPLETION)
view = BaseView(model=model)
view.set_reorderable(True)
view.set_headers_visible(True)
ctrl_box = Gtk.VBox(spacing=6)
add = Gtk.Button(stock=Gtk.STOCK_ADD)
ctrl_box.pack_start(add, False, True, 0)
add.connect('clicked', self.__add, model, cb)
remove = Gtk.Button(stock=Gtk.STOCK_REMOVE)
ctrl_box.pack_start(remove, False, True, 0)
remove.connect('clicked', self.__remove, view)
selection = view.get_selection()
selection.connect('changed', self.__selection_changed, remove)
selection.emit('changed')
sw = Gtk.ScrolledWindow()
sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
sw.set_shadow_type(Gtk.ShadowType.IN)
sw.add(view)
edit_box = Gtk.VBox(spacing=6)
edit_box.pack_start(cb, False, True, 0)
edit_box.pack_start(sw, True, True, 0)
button_box.pack_start(edit_box, True, True, 0)
button_box.pack_start(ctrl_box, False, True, 0)
self.pack_start(button_box, True, True, 0)
render = Gtk.CellRendererText()
render.set_property("editable", True)
def edited_cb(render, path, text, model):
model[path][0] = text
render.connect("edited", edited_cb, model)
column = Gtk.TreeViewColumn(_("Tag"), render, text=0)
column.set_expand(True)
view.append_column(column)
toggle = Gtk.CellRendererToggle()
toggle.connect("toggled", self.__toggeled, model)
toggle_column = Gtk.TreeViewColumn(_("Merge"), toggle, active=1)
view.append_column(toggle_column)
