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)