def __init__(self): self.treestore = gtk.TreeStore( gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING) return
def __create_widgets(self): """ """ self.__cell = gtk.CellRendererText() # texteditor widgets self.__texteditor = BWTextEditor() self.__texteditor.bw_modify_font(self.__font) self.__texteditor.bw_set_editable(False) self.__texteditor.set_border_width(0) self.__select_combobox = gtk.combo_box_new_text() self.__select_combobox.connect('changed', self.__change_text_value) self.__viewer = BWVBox(spacing=6) self.__viewer.set_border_width(6) self.__viewer.bw_pack_start_noexpand_nofill(self.__select_combobox) self.__viewer.bw_pack_start_expand_fill(self.__texteditor) self.__text = list() # ports information number_of_ports = len(self.__node.get_info('ports')) self.__ports_label = BWLabel(_('Ports (%s)') % number_of_ports) self.__ports_scroll = BWScrolledWindow() self.__ports_store = gtk.TreeStore( gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_BOOLEAN) self.__ports_treeview = gtk.TreeView(self.__ports_store) for port in self.__node.get_info('ports'): color = get_service_color(port['state']['state']) service_name = port['service'].get('name', _('<unknown>')) service_method = port['service'].get('method', _('<none>')) reference = self.__ports_store.append(None, [ port['id'], port['protocol'], port['state']['state'], service_name, service_method, color, True ]) for key in port['state']: self.__ports_store.append(reference, [ port['id'], 'state', key, port['state'][key], '', 'white', True ]) for key in port['service']: if key in ['servicefp']: text = _('[%d] service: %s') % (port['id'], key) self.__select_combobox.append_text(text) self.__text.append(port['service'][key]) value = _('<special field>') else: value = port['service'][key] self.__ports_store.append( reference, [port['id'], 'service', key, value, '', 'white', True]) #for script in port['scripts']: # text = _('[%d] script: %s') % (port['id'], script['id']) # self.__select_combobox.append_text(text) # self.__text.append(script['output']) # # self.__ports_store.append(reference, # [port['id'], # 'script', # 'id', # script['id'], # _('<special field>'), # 'white', # True]) self.__ports_column = list() for i in range(len(PORTS_HEADER)): column = gtk.TreeViewColumn(PORTS_HEADER[i], self.__cell, text=i) self.__ports_column.append(column) self.__ports_column[i].set_reorderable(True) self.__ports_column[i].set_resizable(True) self.__ports_column[i].set_sort_column_id(i) self.__ports_column[i].set_attributes(self.__cell, text=i, background=5, editable=6) self.__ports_treeview.append_column(self.__ports_column[i]) self.__ports_scroll.add_with_viewport(self.__ports_treeview) # extraports information number_of_xports = 0 self.__xports_scroll = BWScrolledWindow() self.__xports_store = gtk.TreeStore(gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_BOOLEAN) self.__xports_treeview = gtk.TreeView(self.__xports_store) for xports in self.__node.get_info('extraports'): color = get_service_color(xports['state']) number_of_xports += xports['count'] reference = self.__xports_store.append(None, [ xports['count'], xports['state'], ", ".join(xports['reason']), color, True ]) for xreason in xports['all_reason']: self.__xports_store.append(reference, [ xreason['count'], xports['state'], xreason['reason'], 'white', True ]) self.__xports_column = list() for i in range(len(EXTRAPORTS_HEADER)): column = gtk.TreeViewColumn(EXTRAPORTS_HEADER[i], self.__cell, text=i) self.__xports_column.append(column) self.__xports_column[i].set_reorderable(True) self.__xports_column[i].set_resizable(True) self.__xports_column[i].set_sort_column_id(i) self.__xports_column[i].set_attributes(self.__cell, text=i, background=3, editable=4) self.__xports_treeview.append_column(self.__xports_column[i]) xports_label_text = _('Extraports (%s)') % number_of_xports self.__xports_label = BWLabel(xports_label_text) self.__xports_scroll.add_with_viewport(self.__xports_treeview) self.append_page(self.__ports_scroll, self.__ports_label) self.append_page(self.__xports_scroll, self.__xports_label) self.append_page(self.__viewer, BWLabel(_('Special fields'))) if len(self.__text) > 0: self.__select_combobox.set_active(0)
def __init__(self, policy, widgets): tree_view = widgets.get_widget('components') tree_view.set_property('has-tooltip', True) def callback(widget, x, y, keyboard_mode, tooltip): x, y = tree_view.convert_widget_to_bin_window_coords(x, y) pos = tree_view.get_path_at_pos(x, y) if pos: tree_view.set_tooltip_cell(tooltip, pos[0], pos[1], None) path = pos[0] try: col_index = column_objects.index(pos[1]) except ValueError: return False else: col = self.columns[col_index][1] row = self.model[path] iface = row[InterfaceBrowser.INTERFACE] main_feed = self.policy.config.iface_cache.get_feed( iface.uri) tooltip.set_text( get_tooltip_text(self, iface, main_feed, col)) return True else: return False tree_view.connect('query-tooltip', callback) self.policy = policy self.cached_icon = {} # URI -> GdkPixbuf self.default_icon = tree_view.style.lookup_icon_set( gtk.STOCK_EXECUTE).render_icon(tree_view.style, gtk.TEXT_DIR_NONE, gtk.STATE_NORMAL, gtk.ICON_SIZE_SMALL_TOOLBAR, tree_view, None) self.model = gtk.TreeStore(object, str, str, str, str, gtk.gdk.Pixbuf, str, bool) self.tree_view = tree_view tree_view.set_model(self.model) column_objects = [] text = gtk.CellRendererText() coloured_text = gtk.CellRendererText() for name, model_column in self.columns: if model_column == InterfaceBrowser.INTERFACE_NAME: column = gtk.TreeViewColumn(name, IconAndTextRenderer(), text=model_column, image=InterfaceBrowser.ICON) elif model_column == None: menu_column = column = gtk.TreeViewColumn( '', MenuIconRenderer()) else: if model_column == InterfaceBrowser.SUMMARY: text_ellip = gtk.CellRendererText() try: text_ellip.set_property('ellipsize', pango.ELLIPSIZE_END) except: pass column = gtk.TreeViewColumn(name, text_ellip, text=model_column) column.set_expand(True) elif model_column == InterfaceBrowser.VERSION: column = gtk.TreeViewColumn( name, coloured_text, text=model_column, background=InterfaceBrowser.BACKGROUND) else: column = gtk.TreeViewColumn(name, text, text=model_column) tree_view.append_column(column) column_objects.append(column) tree_view.set_enable_search(True) selection = tree_view.get_selection() def button_press(tree_view, bev): pos = tree_view.get_path_at_pos(int(bev.x), int(bev.y)) if not pos: return False path, col, x, y = pos if (bev.button == 3 or (bev.button < 4 and col is menu_column)) \ and bev.type == gtk.gdk.BUTTON_PRESS: selection.select_path(path) iface = self.model[path][InterfaceBrowser.INTERFACE] self.show_popup_menu(iface, bev) return True if bev.button != 1 or bev.type != gtk.gdk._2BUTTON_PRESS: return False properties.edit(policy, self.model[path][InterfaceBrowser.INTERFACE], self.compile, show_versions=True) tree_view.connect('button-press-event', button_press) tree_view.connect('destroy', lambda s: policy.watchers.remove(self.build_tree)) policy.watchers.append(self.build_tree)
def update_tree_model(self): """Construct a data model of other page data.""" sub_sect_names = self.sections.keys() sub_var_names = [] self.var_id_map = {} for section, variables in self.variables.items(): for variable in variables: self.var_id_map[variable.metadata["id"]] = variable data_rows, column_names = self.get_model_data() data_rows, column_names, rows_are_descendants = self._apply_grouping( data_rows, column_names, self.group_index) self.column_names = column_names should_redraw = self.column_names != self._last_column_names if data_rows: col_types = [str] * len(data_rows[0]) else: col_types = [] need_new_store = (should_redraw or any(rows_are_descendants)) if need_new_store: # We need to construct a new TreeModel. if self._prev_sort_model is not None: prev_sort_id = self._prev_sort_model.get_sort_column_id() store = gtk.TreeStore(*col_types) self._prev_store = store else: store = self._prev_store parent_iter = None for i, row_data in enumerate(data_rows): insert_iter = store.iter_nth_child(None, i) if insert_iter is not None: for j, value in enumerate(row_data): store.set_value(insert_iter, j, value) elif not rows_are_descendants: store.append(None, row_data) elif rows_are_descendants[i]: store.append(parent_iter, row_data) else: parent_data = [row_data[0]] + [None] * len(row_data[1:]) parent_iter = store.append(None, parent_data) store.append(parent_iter, row_data) for extra_index in range(i + 1, store.iter_n_children(None)): remove_iter = store.iter_nth_child(None, extra_index) if remove_iter is not None: store.remove(remove_iter) if need_new_store: filter_model = store.filter_new() filter_model.set_visible_func(self._filter_visible) sort_model = gtk.TreeModelSort(filter_model) for i in range(len(self.column_names)): sort_model.set_sort_func(i, self.sort_util.sort_column, i) if (self._prev_sort_model is not None and prev_sort_id[0] is not None): sort_model.set_sort_column_id(*prev_sort_id) self._prev_sort_model = sort_model sort_model.connect("sort-column-changed", self.sort_util.handle_sort_column_change) if should_redraw: self.sort_util.clear_sort_columns() for column in list(self._view.get_columns()): self._view.remove_column(column) self._view.set_model(sort_model) self._last_column_names = self.column_names return should_redraw
def emf_gentree(): # Record/Group Name Rec. Type Min. Length Template model = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_PYOBJECT) view = gtk.TreeView(model) renderer = gtk.CellRendererText() column = gtk.TreeViewColumn('Group/Record', renderer, text=0) column2 = gtk.TreeViewColumn('Length', renderer, text=2) view.append_column(column) view.append_column(column2) # Bitmap Record Types bmprec = (0x72, 0x4c, 0x4e, 0x4f, 0x50, 0x4d, 0x51, 0x74) # CLipping Record Types cliprec = (0x1a, 0x1c, 0x1d, 0x1e, 0x43, 0x4b) # Comment Record Type and Control Record Types ctrlrec = (0x46, 0x1, 0xE) # Drawing Record Types drawrec= ((0x2,28), (0x3,28), (0x4,28), (0x5,28), (0x6,28), (0x7,32), (0x8,28), (0xF,20), (0x29, 28), (0x2a, 24), (0x2b,24), (0x2c,32), (0x2d, 40), (0x2e, 40), (0x2f,40),\ (0x35,24), (0x36,16), (0x37, 40), (0x38,28), (0x3e,24), (0x3f,24), (0x40,24), (0x47,32), (0x48,40), (0x4a,28), (0x53, 36), (0x54,36), (0x55,28),\ (0x56,28),(0x57,28), (0x58,28), (0x59,28), (0x5a,32), (0x5b,32), (0x5c,28), (0x60,36), (0x61,36), (0x6c,52), (0x76,36)) # Escape Record Types escrec = (0x69, 0x6a, 0x6e) # Object Creation Record Types objcrec = ((0x5d, 32), (0x5e, 32), (0x5f, 32), (0x7a, 20), (0x26, 28), (0x27, 24), (0x31, 12), (0x52, 16), (0x63, 12)) # Object Manipulation Record Types objmrec = (0x25, 0x28, 0x30, 0x32, 0x33, 0x64, 0x65, 0x6f) # OpenGL Record Types ## 0x66, 0x67 # Path Bracket Record Types pathrec = (0x3b, 0x3c, 0x3d, 0x41, 0x42, 0x44) # State Record Types staterec = (0xa, 0xb, 0xc, 0xd, 0x17, 0x1b, 0x1f, 0x9, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,\ 0x16, 0x18, 0x19, 0x20, 0x21, 0x22, 0x34, 0x39, 0x3a, 0x49, 0x62, 0x68, 0x6d,\ 0x70, 0x71, 0x73, 0x77, 0x78, 0x79) # Transform Record Types ## 0x23, 0x24 # EMF+ Record Templates plusrec = ( (2, 0x30, "\x08\x40\x01\x02\x30\x00\x00\x00\x24\x00\x00\x00\x02\x10\xc0\xdb"+"\x00"*4+"\x80\x00\x00\x00\x02"+"\x00"*5+"\x80\x3f"+"\x00"*4+"\x02\x10\xc0\xdb"+"\x00"*8), (3, 0x28, "\x08\x40\x00\x03\xc4\x00\x00\x00\xb8\x00\x00\x00\x02\x10\xc0\xdb\x04" +"\x00"*40 + "\x01\x01\x81"), (6, 0x30, "\x08\x40\x02\x06\x30\x00\x00\x00\x24\x00\x00\x00\x02\x10\xc0\xdb\x00\x22\xbc\x3d"+"\x00"*12+"\x05\x00\x00\x00\x41\x00\x52\x00\x49\x00\x41\x00\x4c\x00\x00\x00"), (0x4001, 0x1c, "\x01\x40\x01\x00\x1c\x00\x00\x00\x10\x00\x00\x00\x02\x10\xc0\xdb\x01\x00\x00\x00"+"\x60\x00\x00\x00"*2), (0x4002, 0xc, "\x02\x40\x00\x00\x0c"+"\x00"*7), (0x4004, 0xc, "\x04\x40\x00\x00\x0c"+"\x00"*7), (0x400a, 0x24, "\x0a\x40\x00\x00\x24\x00\x00\x00\x18"+"\x00\x00\x00\x01"*2+"\x00"*13+"\x20\x41\x00\x00\x80\x40"), (0x4014, 0x10, "\x14\x40\x00\x80\x10\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\x00"), (0x4015, 0x10, "\x15\x40\x00\x00\x10\x00\x00\x00\x04"+"\x00"*7), (0x401d, 0x14, "\x1d\x40\x00\x00\x14\x00\x00\x00\x08"+"\x00"*11), (0x401e, 0xc, "\x1e\x40\x0b\x00\x0c"+"\x00"*7), (0x401f, 0xc, "\x1e\x40\x05\x00\x0c"+"\x00"*7), (0x4021, 0xc, "\x21\x40\x07\x00\x0c"+"\x00"*7), (0x4022, 0xc, "\x21\x40\x03\x00\x0c"+"\x00"*7), (0x4024, 0xc, "\x24\x40\x02\x00\x0c"+"\x00"*7), (0x4025, 0x10, "\x25\x40\x00\x00\x10\x00\x00\x00\x04"+"\x00"*7), (0x4026, 0x10, "\x29\x40\x00\x00\x10\x00\x00\x00\x04"+"\x00"*7), (0x4028, 0x10, "\x28\x40\x00\x00\x10\x00\x00\x00\x04"+"\x00"*7), (0x4029, 0x10, "\x29\x40\x00\x00\x10\x00\x00\x00\x04"+"\x00"*7), (0x402a, 0x24, "\x2a\x40\x00\x00\x24\x00\x00\x00\x18" +"\x00"*5+"x80\x3f"+"\x00"*10+"\x80\x3f"+"\x00"*8), (0x402b, 0xc, "\x2b\x40\x00\x00\x0c"+"\x00"*7), (0x402c, 0x24, "\x2c\x40\x00\x00\x24\x00\x00\x00\x18" +"\x00"*5+"x80\x3f"+"\x00"*10+"\x80\x3f"+"\x00"*8), (0x4030, 0x10, "\x30\x40\x02\x00\x10\x00\x00\x00\x04"+"\x00"*5+"\x80\x3f"), (0x4033, 0xc, "\x33\x40\x00\x01\x0c"+"\x00"*7), (0x4034, 0xc, "\x34\x40\x04\x00\x0c"+"\x00"*7), (0x4036, 0x5c, "\x36\x40\x02\x80\x5c\x00\x00\x00\x50\x00\x00\x00\xff\xff\xff\xff"+"\x01\x00\x00\x00"*2\ + "\x04\x00\x00\x00\x54\x00\x45\x00\x53\x00\x54\x00"+("\x00"*7+"\x3f"+ "\x00\x00\x80\x3f\x00\x00\xc0\x3f")*2\ +"\x00\x00\x80\x3f"+"\x00"*10+"\x80\x3f"+"\x00"*8), ) iter = model.append(None, None) model.set(iter, 0, "EMF+ Records", 1, -1, 2, "") for i in range(len(plusrec)): niter = model.append(iter, None) if plusrec[i][0] > 0x4000: model.set(niter, 0, emrplus_ids[plusrec[i][0]], 1, plusrec[i][0], 2, plusrec[i][1], 3, plusrec[i][2]) else: model.set(niter, 0, "Object %s" % emfplus.ObjectType[plusrec[i][0]], 1, 0x4008, 2, plusrec[i][1], 3, plusrec[i][2]) iter = model.append(None, None) model.set(iter, 0, "Bitmap Records", 1, -1, 2, "") for i in range(len(bmprec)): niter = model.append(iter, None) model.set(niter, 0, emr_ids[bmprec[i]], 1, bmprec[i], 2, 8) iter = model.append(None, None) model.set(iter, 0, "Clipping Records", 1, -1, 2, "") for i in range(len(cliprec)): niter = model.append(iter, None) model.set(niter, 0, emr_ids[cliprec[i]], 1, cliprec[i], 2, 8) iter = model.append(None, None) model.set(iter, 0, "Comment & Control Records", 1, -1, 2, "") for i in range(len(ctrlrec)): niter = model.append(iter, None) model.set(niter, 0, emr_ids[ctrlrec[i]], 1, ctrlrec[i], 2, 8) iter = model.append(None, None) model.set(iter, 0, "Drawing Records", 1, -1, 2, "") for i in range(len(drawrec)): niter = model.append(iter, None) model.set(niter, 0, emr_ids[drawrec[i][0]], 1, drawrec[i][0], 2, drawrec[i][1]) iter = model.append(None, None) model.set(iter, 0, "Escape Records", 1, -1, 2, "") for i in range(len(escrec)): niter = model.append(iter, None) model.set(niter, 0, emr_ids[escrec[i]], 1, escrec[i], 2, 8) iter = model.append(None, None) model.set(iter, 0, "Object Creation Records", 1, -1, 2, "") for i in range(len(objcrec)): niter = model.append(iter, None) model.set(niter, 0, emr_ids[objcrec[i][0]], 1, objcrec[i][0], 2, objcrec[i][1]) iter = model.append(None, None) model.set(iter, 0, "Object Modification Records", 1, -1, 2, "") for i in range(len(objmrec)): niter = model.append(iter, None) model.set(niter, 0, emr_ids[objmrec[i]], 1, objmrec[i], 2, 8) iter = model.append(None, None) model.set(iter, 0, "OpenGL Records", 1, -1, 2, "") niter = model.append(iter, None) model.set(niter, 0, emr_ids[0x66], 1, 0x66, 2, 8) niter = model.append(iter, None) model.set(niter, 0, emr_ids[0x67], 1, 0x67, 2, 8) iter = model.append(None, None) model.set(iter, 0, "Path Bracket Records", 1, -1, 2, "") for i in range(len(pathrec)): niter = model.append(iter, None) model.set(niter, 0, emr_ids[pathrec[i]], 1, pathrec[i], 2, 8) iter = model.append(None, None) model.set(iter, 0, "State Records", 1, -1, 2, "") for i in range(len(staterec)): niter = model.append(iter, None) model.set(niter, 0, emr_ids[staterec[i]], 1, staterec[i], 2, 8) iter = model.append(None, None) model.set(iter, 0, "Transform Records", 1, -1, 2, "") niter = model.append(iter, None) model.set(niter, 0, emr_ids[0x23], 1, 0x23, 2, 8) niter = model.append(iter, None) model.set(niter, 0, emr_ids[0x24], 1, 0x24, 2, 8) return model, view
def __init__(self, session): '''class constructor''' self._model = None pbr = extension.get_default('avatar renderer') self.pbr = pbr() gui.ContactList.__init__(self, session) gtk.TreeView.__init__(self) self.set_enable_search(False) # Enable our searching widget # with CTRL+F in MainWindow.py self.online_group_iter = None # added self.no_group_iter = None self.offline_group_iter = None self.hide_on_filtering = False self.enable_model_drag_source(gtk.gdk.BUTTON1_MASK, [('emesene-contact', 0, 0), ('text/html', 0, 1), ('text/plain', 0, 2), ('emesene-invite', 0, 3)], gtk.gdk.ACTION_COPY) self.enable_model_drag_dest([('emesene-contact', 0, 0)], gtk.gdk.ACTION_DEFAULT) self.contact_handler = gui.base.ContactHandler(session, self) self.group_handler = gui.base.GroupHandler(session, self) if self.session.config.d_weights is None: self.session.config.d_weights = {} # [0] the image (None for groups), # [1] the object (group or contact), # [2] the string to display # [3] a boolean indicating if the pixbuf should # be shown (False for groups, True for contacts) # [4] the status image # [5] an int that is used to allow ordering specified by the user # [6] a boolean indicating special groups always False for contacts, # True for special groups like "No group" # [7] a boolean indicating if the contact is offline self._model = gtk.TreeStore(gtk.Image, object, str, bool, gtk.gdk.Pixbuf, int, bool, bool) self.model = self._model.filter_new(root=None) self.model.set_visible_func(self._visible_func) self._model.set_sort_func(1, self._sort_method) self._model.set_sort_column_id(1, gtk.SORT_ASCENDING) self.set_model(self.model) self.tooltips = Tooltips.Tooltips() self.connect('motion-notify-event', self.tooltips.on_motion) self.connect('leave-notify-event', self.tooltips.on_leave) self.crt = extension.get_and_instantiate('nick renderer') self.column = gtk.TreeViewColumn() self.column.set_expand(True) self.column.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE) self.exp_column = gtk.TreeViewColumn() self.exp_column.set_max_width(16) self.append_column(self.exp_column) self.append_column(self.column) self.set_expander_column(self.exp_column) self.prepare_contactlist_column() self.set_search_column(2) self.set_headers_visible(False) self.connect('row-activated', self._on_row_activated) self.connect('button-release-event', self._on_button_press_event) self.connect('row-expanded', self._on_expand) self.connect('row-collapsed', self._on_collapse) self.connect('drag-data-get', self._on_drag_data_get) self.connect('drag-drop', self._on_drag_drop) extension.subscribe(self.on_nick_renderer_changed, 'nick renderer')
def __init__(self, w3af, style, config_panel): self.mainwin = w3af.mainwin self.w3af = w3af self.config_panel = config_panel # create the TreeStore, with the following columns: # 1. the plugin name, to show it # 2. checkbox status, active or not # 3. checkbox status, inconsistant or not # 4. the plugin name, just to store and bold it or not # 5. a image to show if the plugin is configurable self.treestore = gtk.TreeStore(str, gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN, str, gtk.gdk.Pixbuf) # decide which type in function of style if style == "standard": plugins_toshow = sorted(x for x in w3af.plugins.get_plugin_types() if x != "output") col_title = _("Plugin") elif style == "output": plugins_toshow = ("output", ) col_title = _("Plugin") else: raise ValueError("Invalid PluginTree style: %r" % style) # just build the tree with the plugin names for plugintype in plugins_toshow: # let's see if some of the children are activated or not pluginlist = w3af.plugins.get_plugin_list(plugintype) activated = set(w3af.plugins.get_enabled_plugins(plugintype)) if not activated: activ = 0 incons = 0 elif len(activated) == len(pluginlist): activ = 1 incons = 0 else: activ = 0 incons = 1 father = self.treestore.append( None, [plugintype, activ, incons, plugintype, None]) dlg = gtk.Dialog() editpixbuf = dlg.render_icon(gtk.STOCK_EDIT, gtk.ICON_SIZE_MENU) for plugin in sorted(w3af.plugins.get_plugin_list(plugintype)): activ = int(plugin in activated) if self._getEditablePlugin(plugin, plugintype): thispixbuf = editpixbuf else: thispixbuf = None self.treestore.append(father, [plugin, activ, 0, plugin, thispixbuf]) # we will not ask for the plugin instances until needed, we'll # keep them here: self.plugin_instances = {} # we'll supervise the status of all changed configurations (if it # does not exist here, never was changed) self.config_status = {} # create the TreeView using treestore super(PluginTree, self).__init__(self.treestore) self.connect('cursor-changed', self.configure_plugin) # button events self.connect('button-release-event', self.popup_menu) self.connect('button-press-event', self._doubleClick) # create a TreeViewColumn for the checkbox tvcolumn = gtk.TreeViewColumn(_('Active')) cell = gtk.CellRendererToggle() cell.set_property('activatable', True) cell.connect('toggled', self.activate_plugin) tvcolumn.pack_start(cell, False) tvcolumn.add_attribute(cell, 'active', 1) tvcolumn.add_attribute(cell, 'inconsistent', 2) self.append_column(tvcolumn) # create a TreeViewColumn for the text and icon tvcolumn = gtk.TreeViewColumn(col_title) cell = gtk.CellRendererPixbuf() tvcolumn.pack_start(cell, expand=False) tvcolumn.add_attribute(cell, "pixbuf", 4) cell = gtk.CellRendererText() tvcolumn.pack_start(cell, True) tvcolumn.add_attribute(cell, 'markup', 0) self.append_column(tvcolumn) self.show()
def __init__(self): """Setup the preferences dialog interface, loading images, adding filters to file choosers and connecting some signals. """ super(PrefsDialog, self).__init__(gladefile('prefs.glade'), root='config-window') self.add_callbacks(PrefsCallbacks()) self.client = gconf.client_get_default() # setting evtbox title bg eventbox = self.get_widget('eventbox-title') eventbox.modify_bg(gtk.STATE_NORMAL, eventbox.get_colormap().alloc_color("#ffffff")) # images ipath = pixmapfile('guake-notification.png') self.get_widget('image_logo').set_from_file(ipath) ipath = pixmapfile('quick-open.png') self.get_widget('image_quick_open').set_from_file(ipath) # the first position in tree will store the keybinding path in gconf, # and the user doesn't worry with this, let's hide that =D model = gtk.TreeStore(str, str, object, bool) treeview = self.get_widget('treeview-keys') treeview.set_model(model) treeview.set_rules_hint(True) treeview.connect('button-press-event', self.start_editing) renderer = gtk.CellRendererText() column = gtk.TreeViewColumn('keypath', renderer, text=0) column.set_visible(False) treeview.append_column(column) renderer = gtk.CellRendererText() column = gtk.TreeViewColumn(_('Action'), renderer, text=1) column.set_property('expand', True) treeview.append_column(column) renderer = gtk.CellRendererAccel() renderer.set_property('editable', True) renderer.connect('accel-edited', self.on_key_edited, model) renderer.connect('accel-cleared', self.on_key_cleared, model) column = gtk.TreeViewColumn(_('Shortcut'), renderer) column.set_cell_data_func(renderer, self.cell_data_func) column.set_property('expand', False) treeview.append_column(column) self.demo_terminal = GuakeTerminal() demo_terminal_box = self.get_widget('demo_terminal_box') demo_terminal_box.add(self.demo_terminal) default_params = {} pid = self.demo_terminal.fork_command(**default_params) self.demo_terminal.pid = pid self.populate_shell_combo() self.populate_keys_tree() self.populate_display_n() self.load_configs() self.get_widget('config-window').hide() # Preview when selecting a bgimage self.selection_preview = gtk.Image() self.file_filter = gtk.FileFilter() self.file_filter.add_pattern("*.jpg") self.file_filter.add_pattern("*.png") self.file_filter.add_pattern("*.svg") self.file_filter.add_pattern("*.jpeg") self.bgfilechooser = self.get_widget('background_image') self.bgfilechooser.set_preview_widget(self.selection_preview) self.bgfilechooser.set_filter(self.file_filter) self.bgfilechooser.connect('update-preview', self.update_preview, self.selection_preview)
def __init__(self, mainWin, VERSION): self.configs = mainWin.configs self.VERSION = VERSION self.subscribedGroups = mainWin.subscribed_groups self.win = gtk.Window(gtk.WINDOW_TOPLEVEL) self.win.connect("delete_event", self.delete_event) #self.win.connect("destroy",self.destroy) self.win.set_title(_("Outbox Manager")) self.win.set_icon(gtk.gdk.pixbuf_new_from_file("pixmaps/outbox.xpm")) vbox = gtk.VBox() #MenuBar self.create_ui() menubar = self.ui.get_widget("/OutboxMenuBar") vbox.pack_start(menubar, False, True) menubar.show() #ToolBar toolbar = self.ui.get_widget("/OutboxToolBar") vbox.pack_start(toolbar, False, True) toolbar.show() #toolbar.set_icon_size(gtk.ICON_SIZE_LARGE_TOOLBAR) toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL) toolbar.set_style(gtk.TOOLBAR_ICONS) toolbar.set_style(gtk.SHADOW_NONE) self.win.add(vbox) #HBox hpaned = gtk.HPaned() vbox.pack_start(hpaned, True, True) #Folder Tree self.folderTree = gtk.TreeView() model = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gtk.gdk.Pixbuf) self.folderTree.set_model(model) text_renderer_bold = gtk.CellRendererText() text_renderer_bold.set_property("weight", 1000) text_renderer_number = gtk.CellRendererText() text_renderer_number.set_property("xalign", .5) pix_renderer = gtk.CellRendererPixbuf() self.folderTreeColumnFolder = gtk.TreeViewColumn(_("Folder")) self.folderTreeColumnFolder.pack_start(pix_renderer) self.folderTreeColumnFolder.pack_start(text_renderer_bold) self.folderTreeColumnFolder.set_attributes(pix_renderer, pixbuf=2) self.folderTreeColumnFolder.set_attributes(text_renderer_bold, text=0) self.folderTreeColumnNumber = gtk.TreeViewColumn(_("Number"), text_renderer_number, text=1) self.folderTree.append_column(self.folderTreeColumnFolder) self.folderTree.append_column(self.folderTreeColumnNumber) #self.folderTree.set_expander_column(self.folderTreeColumn) hpaned.add(self.folderTree) #Preview Tree scrolledwin = gtk.ScrolledWindow() scrolledwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scrolledwin.set_shadow_type(gtk.SHADOW_ETCHED_IN) self.previewTree = gtk.TreeView() scrolledwin.add(self.previewTree) # 0: Subject, 1: Newsgroups/To, 2: Date, 3: Article, 4: IsMail, 5: PathToArticle, 6: Seconds model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_PYOBJECT, gobject.TYPE_BOOLEAN, gobject.TYPE_STRING, gobject.TYPE_INT) self.previewTree.set_model(model) text_renderer = gtk.CellRendererText() self.previewTreeColumnSubject = gtk.TreeViewColumn(_("Subject"), text_renderer, text=0) self.previewTreeColumnSubject.set_resizable(True) self.previewTreeColumnSubject.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED) self.previewTreeColumnSubject.set_fixed_width(300) self.previewTreeColumnSubject.set_sort_column_id(0) self.previewTreeColumnTo = gtk.TreeViewColumn(_("Newsgroups/To"), text_renderer, text=1) self.previewTreeColumnTo.set_resizable(True) self.previewTreeColumnTo.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED) self.previewTreeColumnTo.set_fixed_width(150) self.previewTreeColumnTo.set_sort_column_id(1) self.previewTreeColumnDate = gtk.TreeViewColumn(_("Date"), text_renderer, text=2) self.previewTreeColumnDate.set_sort_column_id(6) self.previewTree.append_column(self.previewTreeColumnSubject) self.previewTree.append_column(self.previewTreeColumnTo) self.previewTree.append_column(self.previewTreeColumnDate) hpaned.add(scrolledwin) model.set_sort_column_id(6, gtk.SORT_ASCENDING) self.statusbar = gtk.Statusbar() vbox.pack_start(self.statusbar, False, True) #self.win.maximize() self.wdir = get_wdir() #self.folderTree.connect("row_activated",self.openFolder) self.folderTree.get_selection().connect("changed", self.openFolder) self.previewTree.connect("row_activated", self.openArticle) self.set_sizes() self.outboxwin_width = None self.outboxwin_height = None self.populateFolderTree()
def __init__(self, parent, playlist_manager, smart_manager, collection, name): """ Intializes the playlists panel @param playlist_manager: The playlist manager """ panel.Panel.__init__(self, parent, name) BasePlaylistPanelMixin.__init__(self) self.playlist_manager = playlist_manager self.smart_manager = smart_manager self.collection = collection self.box = self.builder.get_object('playlists_box') self._refresh_id = None self.playlist_name_info = 500 self.track_target = ("text/uri-list", 0, 0) self.playlist_target = ("playlist_name", gtk.TARGET_SAME_WIDGET, self.playlist_name_info) self.deny_targets = [('',0,0)] self.tree = PlaylistDragTreeView(self) self.tree.connect('row-activated', self.open_item) self.tree.set_headers_visible(False) self.tree.connect('drag-motion', self.drag_motion) self.tree.drag_source_set( gtk.gdk.BUTTON1_MASK, [self.track_target, self.playlist_target], gtk.gdk.ACTION_COPY|gtk.gdk.ACTION_MOVE) self.scroll = gtk.ScrolledWindow() self.scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.scroll.add(self.tree) self.scroll.set_shadow_type(gtk.SHADOW_IN) self.box.pack_start(self.scroll, True, True) self.box.show_all() pb = gtk.CellRendererPixbuf() cell = gtk.CellRendererText() if settings.get_option('gui/ellipsize_text_in_panels', False): import pango cell.set_property( 'ellipsize-set', True) cell.set_property( 'ellipsize', pango.ELLIPSIZE_END) col = gtk.TreeViewColumn('Text') col.pack_start(pb, False) col.pack_start(cell, True) col.set_attributes(pb, pixbuf=0) col.set_attributes(cell, text=1) self.tree.append_column(col) self.model = gtk.TreeStore(gtk.gdk.Pixbuf, str, object) self.tree.set_model(self.model) # icons self.folder = self.tree.render_icon( gtk.STOCK_DIRECTORY, gtk.ICON_SIZE_SMALL_TOOLBAR) self.playlist_image = icons.MANAGER.pixbuf_from_icon_name( 'music-library', gtk.ICON_SIZE_SMALL_TOOLBAR) # menus self.playlist_menu = menus.PlaylistsPanelPlaylistMenu(self) self.smart_menu = menus.PlaylistsPanelPlaylistMenu(self) self.default_menu = menus.PlaylistPanelMenu(self) self.track_menu = menus.TrackPanelMenu(self) self._connect_events() self._load_playlists()
def __init__(self, hosts=None, owner=None, poll_interval=None): gobject.threads_init() set_exception_hook_dialog("cylc gscan") setup_icons() if not hosts: hosts = GLOBAL_CFG.get(["suite host scanning", "hosts"]) self.hosts = hosts if owner is None: owner = USER self.owner = owner self.window = gtk.Window() self.window.set_title("cylc gscan") self.window.set_icon(get_icon()) self.vbox = gtk.VBox() self.vbox.show() self.theme_name = gcfg.get(['use theme']) self.theme = gcfg.get(['themes', self.theme_name]) self.dots = DotMaker(self.theme) suite_treemodel = gtk.TreeStore(str, str, bool, str, int, str, str) self._prev_tooltip_location_id = None self.suite_treeview = gtk.TreeView(suite_treemodel) # Construct the host column. host_name_column = gtk.TreeViewColumn("Host") cell_text_host = gtk.CellRendererText() host_name_column.pack_start(cell_text_host, expand=False) host_name_column.set_cell_data_func(cell_text_host, self._set_cell_text_host) host_name_column.set_sort_column_id(0) host_name_column.set_visible("host" in gsfg.get(["columns"])) host_name_column.set_resizable(True) # Construct the suite name column. suite_name_column = gtk.TreeViewColumn("Suite") cell_text_name = gtk.CellRendererText() suite_name_column.pack_start(cell_text_name, expand=False) suite_name_column.set_cell_data_func(cell_text_name, self._set_cell_text_name) suite_name_column.set_sort_column_id(1) suite_name_column.set_visible("suite" in gsfg.get(["columns"])) suite_name_column.set_resizable(True) # Construct the suite title column. suite_title_column = gtk.TreeViewColumn("Title") cell_text_title = gtk.CellRendererText() suite_title_column.pack_start(cell_text_title, expand=False) suite_title_column.set_cell_data_func(cell_text_title, self._set_cell_text_title) suite_title_column.set_sort_column_id(3) suite_title_column.set_visible("title" in gsfg.get(["columns"])) suite_title_column.set_resizable(True) # Construct the update time column. time_column = gtk.TreeViewColumn("Updated") cell_text_time = gtk.CellRendererText() time_column.pack_start(cell_text_time, expand=False) time_column.set_cell_data_func(cell_text_time, self._set_cell_text_time) time_column.set_sort_column_id(4) time_column.set_visible("updated" in gsfg.get(["columns"])) time_column.set_resizable(True) self.suite_treeview.append_column(host_name_column) self.suite_treeview.append_column(suite_name_column) self.suite_treeview.append_column(suite_title_column) self.suite_treeview.append_column(time_column) # Construct the status column. status_column = gtk.TreeViewColumn("Status") status_column.set_sort_column_id(5) status_column.set_visible("status" in gsfg.get(["columns"])) status_column.set_resizable(True) status_column_info = 6 cycle_column_info = 5 cell_text_cycle = gtk.CellRendererText() status_column.pack_start(cell_text_cycle, expand=False) status_column.set_cell_data_func(cell_text_cycle, self._set_cell_text_cycle, cycle_column_info) self.suite_treeview.append_column(status_column) for i in range(len(TASK_STATUSES_ORDERED)): cell_pixbuf_state = gtk.CellRendererPixbuf() status_column.pack_start(cell_pixbuf_state, expand=False) status_column.set_cell_data_func(cell_pixbuf_state, self._set_cell_pixbuf_state, (status_column_info, i)) self.suite_treeview.show() if hasattr(self.suite_treeview, "set_has_tooltip"): self.suite_treeview.set_has_tooltip(True) try: self.suite_treeview.connect('query-tooltip', self._on_query_tooltip) except TypeError: # Lower PyGTK version. pass self.suite_treeview.connect("button-press-event", self._on_button_press_event) scrolled_window = gtk.ScrolledWindow() scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scrolled_window.add(self.suite_treeview) scrolled_window.show() self.vbox.pack_start(scrolled_window, expand=True, fill=True) self.updater = ScanAppUpdater(self.hosts, suite_treemodel, self.suite_treeview, owner=self.owner, poll_interval=poll_interval) self.updater.start() self.window.add(self.vbox) self.window.connect("destroy", self._on_destroy_event) self.window.set_default_size(300, 150) self.suite_treeview.grab_focus() self.window.show()
def ma_set_choices(self, choices): import gtk def cell_data_func(unused_column, cell, model, iterator): val = model.get_value(iterator, 1) if model.iter_children(iterator): # Windows XP... text = '%s <small><i>%s (%s)</i></small>' % \ (val['user'], val['os'], val['part']) else: # Gaim, Yahoo, etc text = model.get_value(iterator, 1) try: cell.set_property("markup", unicode(text)) except: cell.set_property("text", '%s %s (%s)' % \ (val['user'], val['os'], val['part'])) # Showing the interface for the second time. if self.matreeview.get_model(): for col in self.matreeview.get_columns(): self.matreeview.remove_column(col) # For the previous selected item. self.ma_previous_selection = None # TODO evand 2007-01-11 I'm on the fence as to whether or not skipping # the page would be better than showing the user this error. if not choices: # TODO cjwatson 2009-04-01: i18n msg = 'There were no users or operating systems suitable for ' \ 'importing from.' liststore = gtk.ListStore(str) liststore.append([msg]) self.matreeview.set_model(liststore) column = gtk.TreeViewColumn('item', gtk.CellRendererText(), text=0) self.matreeview.append_column(column) else: treestore = gtk.TreeStore(bool, object) # We save the choices list so we can preserve state, should the user # decide to move back through the interface. We cannot just put the # old list back as the options could conceivably change. For # example, the user moves back to the partitioning page, removes a # partition, and moves forward to the migration-assistant page. # TODO evand 2007-12-04: simplify. for choice in choices: kept = False for old_choice in self.ma_choices: if (old_choice['user'] == choice['user']) and \ (old_choice['part'] == choice['part']): piter = treestore.append(None, \ [old_choice['selected'], choice]) choice['selected'] = old_choice['selected'] new_items = [] for item in choice['items']: if item in old_choice['items']: treestore.append(piter, [True, item]) new_items.append(item) else: treestore.append(piter, [False, item]) choice['items'] = new_items kept = True break if not kept: piter = treestore.append(None, [False, choice]) for item in choice['items']: treestore.append(piter, [False, item]) choice['items'] = [] self.matreeview.set_model(treestore) renderer = gtk.CellRendererToggle() renderer.connect('toggled', self.ma_cb_toggle, treestore) column = gtk.TreeViewColumn('boolean', renderer, active=0) column.set_clickable(True) column.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE) self.matreeview.append_column(column) renderer = gtk.CellRendererText() column = gtk.TreeViewColumn('item', renderer) column.set_cell_data_func(renderer, cell_data_func) self.matreeview.append_column(column) self.matreeview.set_search_column(1) self.matreeview.show_all() # Save the list so we can preserve state. self.ma_choices = choices
def __init_model(self): """Initialise and return the model for the data.""" self.__model = gtk.TreeStore(*self.FIELDS) return self.__model
def getScreen(self, anaconda): # We skip the filter UI in basic storage mode if anaconda.simpleFilter: anaconda.storage.config.exclusiveDisks = [] return None (self.xml, self.vbox) = gui.getGladeWidget("filter.glade", "vbox") self.buttonBox = self.xml.get_widget("buttonBox") self.notebook = self.xml.get_widget("notebook") self.addAdvanced = self.xml.get_widget("addAdvancedButton") self.notebook.connect("switch-page", self._page_switched) self.addAdvanced.connect("clicked", self._add_advanced_clicked) self.pages = [] self.anaconda = anaconda # One common store that all the views on all the notebook tabs share. # Yes, this means a whole lot of columns that are going to be empty or # unused much of the time. Oh well. # Object, # visible, active (checked), immutable, # device, model, capacity, vendor, interconnect, serial number, wwid # paths, port, target, lun self.store = gtk.TreeStore(gobject.TYPE_PYOBJECT, gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING) self.store.set_sort_column_id(MODEL_COL, gtk.SORT_ASCENDING) # if we've already populated the device tree at least once we should # do our best to make sure any active devices get deactivated anaconda.storage.devicetree.teardownAll() # So that drives onlined by these show up in the filter UI iscsi.iscsi().startup(anaconda.intf) fcoe.fcoe().startup(anaconda.intf) zfcp.ZFCP().startup(anaconda.intf) dasd.DASD().startup(anaconda.intf, anaconda.storage.config.exclusiveDisks, anaconda.storage.config.zeroMbr) disks = self._getFilterDisks() mcw = MultipathConfigWriter() cfg = mcw.write() open("/etc/multipath.conf", "w+").write(cfg) del cfg del mcw topology = MultipathTopology(disks) # The device list could be really long, so we really only want to # iterate over it the bare minimum of times. Dividing this list up # now means fewer elements to iterate over later. singlepaths = filter(lambda info: self._device_size_is_nonzero(info), topology.singlepaths_iter()) (raids, nonraids) = self.split_list(lambda d: isRAID(d) and not isCCISS(d), singlepaths) self.pages = [self._makeBasic(), self._makeRAID(), self._makeMPath(), self._makeOther(), self._makeSearch()] self.populate(nonraids, topology.multipaths_iter(), raids) # If the "Add Advanced" button is ever clicked, we need to have a list # of what devices previously existed so we know what's new. Then we # can just add the new devices to the UI. This is going to be slow, # but the user has to click a button to get to the slow part. self._cachedDevices = NameCache(singlepaths) self._cachedRaidDevices = NameCache(raids) # Multipath is a little more complicated. Since mpaths is a list of # lists, we can't directly store that into the cache. Instead we want # to flatten it into a single list of all components of all multipaths # and store that. mpath_chain = itertools.chain(*topology.multipaths_iter()) self._cachedMPaths = NameCache(mpath_chain) # Switch to the first notebook page that displays any devices. i = 0 for pg in self.pages: if pg.getNVisible(): self.notebook.set_current_page(i) break i += 1 return self.vbox
def __init__( self, hosts=None, patterns_name=None, patterns_owner=None, comms_timeout=None, poll_interval=None): gobject.threads_init() set_exception_hook_dialog("cylc gscan") setup_icons() if not hosts: hosts = GLOBAL_CFG.get(["suite host scanning", "hosts"]) self.hosts = hosts self.window = gtk.Window() title = "cylc gscan" for opt, items, skip in [ ("-n", patterns_name, None), ("-o", patterns_owner, USER)]: if items: for pattern in items: if pattern != skip: title += " %s %s" % (opt, pattern) self.window.set_title(title) self.window.set_icon(get_icon()) self.vbox = gtk.VBox() self.vbox.show() self.warnings = {} self.theme_name = gcfg.get(['use theme']) self.theme = gcfg.get(['themes', self.theme_name]) self.dots = DotMaker(self.theme) suite_treemodel = gtk.TreeStore( str, # group str, # host str, # owner str, # suite bool, # is_stopped str, # title int, # update_time str, # states str, # states_text str) # warning_text self._prev_tooltip_location_id = None self.suite_treeview = gtk.TreeView(suite_treemodel) # Visibility of columns vis_cols = gsfg.get(["columns"]) # Doesn't make any sense without suite name column if gsfg.COL_SUITE not in vis_cols: vis_cols.append(gsfg.COL_SUITE.lower()) # In multiple host environment, add host column by default if hosts: vis_cols.append(gsfg.COL_HOST.lower()) # In multiple owner environment, add owner column by default if patterns_owner != [USER]: vis_cols.append(gsfg.COL_OWNER.lower()) # Construct the group, host, owner, suite, title, update time column. for col_title, col_id, col_cell_text_setter in [ (gsfg.COL_GROUP, self.GROUP_COLUMN, self._set_cell_text_group), (gsfg.COL_HOST, self.HOST_COLUMN, self._set_cell_text_host), (gsfg.COL_OWNER, self.OWNER_COLUMN, self._set_cell_text_owner), (gsfg.COL_SUITE, self.SUITE_COLUMN, self._set_cell_text_name), (gsfg.COL_TITLE, self.TITLE_COLUMN, self._set_cell_text_title), (gsfg.COL_UPDATED, self.UPDATE_TIME_COLUMN, self._set_cell_text_time), ]: column = gtk.TreeViewColumn(col_title) cell_text = gtk.CellRendererText() column.pack_start(cell_text, expand=False) column.set_cell_data_func(cell_text, col_cell_text_setter) column.set_sort_column_id(col_id) column.set_visible(col_title.lower() in vis_cols) column.set_resizable(True) self.suite_treeview.append_column(column) # Construct the status column. status_column = gtk.TreeViewColumn(gsfg.COL_STATUS) status_column.set_sort_column_id(self.STATUS_COLUMN) status_column.set_visible(gsfg.COL_STATUS.lower() in vis_cols) status_column.set_resizable(True) cell_text_cycle = gtk.CellRendererText() status_column.pack_start(cell_text_cycle, expand=False) status_column.set_cell_data_func( cell_text_cycle, self._set_cell_text_cycle, self.CYCLE_COLUMN) self.suite_treeview.append_column(status_column) # Warning icon. warn_icon = gtk.CellRendererPixbuf() image = gtk.Image() pixbuf = image.render_icon( gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_LARGE_TOOLBAR) self.warn_icon_colour = pixbuf.scale_simple( # colour warn icon pixbuf self.ICON_SIZE, self.ICON_SIZE, gtk.gdk.INTERP_HYPER) self.warn_icon_grey = pixbuf.scale_simple( self.ICON_SIZE, self.ICON_SIZE, gtk.gdk.INTERP_HYPER) self.warn_icon_colour.saturate_and_pixelate( self.warn_icon_grey, 0, False) # b&w warn icon pixbuf status_column.pack_start(warn_icon, expand=False) status_column.set_cell_data_func(warn_icon, self._set_error_icon_state) self.warn_icon_blank = gtk.gdk.Pixbuf( # Transparent pixbuff. gtk.gdk.COLORSPACE_RGB, True, 8, self.ICON_SIZE, self.ICON_SIZE ).fill(0x00000000) # Task status icons. for i in range(len(TASK_STATUSES_ORDERED)): cell_pixbuf_state = gtk.CellRendererPixbuf() status_column.pack_start(cell_pixbuf_state, expand=False) status_column.set_cell_data_func( cell_pixbuf_state, self._set_cell_pixbuf_state, i) self.suite_treeview.show() if hasattr(self.suite_treeview, "set_has_tooltip"): self.suite_treeview.set_has_tooltip(True) try: self.suite_treeview.connect('query-tooltip', self._on_query_tooltip) except TypeError: # Lower PyGTK version. pass self.suite_treeview.connect("button-press-event", self._on_button_press_event) scrolled_window = gtk.ScrolledWindow() scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scrolled_window.add(self.suite_treeview) scrolled_window.show() self.vbox.pack_start(scrolled_window, expand=True, fill=True) patterns = {"name": None, "owner": None} for label, items in [ ("owner", patterns_owner), ("name", patterns_name)]: if items: patterns[label] = r"\A(?:" + r")|(?:".join(items) + r")\Z" try: patterns[label] = re.compile(patterns[label]) except re.error: raise ValueError("Invalid %s pattern: %s" % (label, items)) self.updater = ScanAppUpdater( self.window, self.hosts, suite_treemodel, self.suite_treeview, comms_timeout=comms_timeout, poll_interval=poll_interval, group_column_id=self.GROUP_COLUMN, name_pattern=patterns["name"], owner_pattern=patterns["owner"]) self.updater.start() self.window.add(self.vbox) self.window.connect("destroy", self._on_destroy_event) self.window.set_default_size(300, 150) self.suite_treeview.grab_focus() self.window.show() self.warning_icon_shown = []
def getScreen (self, anaconda): # We can't just use exclusiveDisks here because of kickstart. First, # the kickstart file could have used ignoredisk --drives= in which case # exclusiveDisks would be empty. Second, ignoredisk is entirely # optional in which case neither list would be populated. Luckily, # storage.disks takes isIgnored into account and that handles both these # issues. disks = filter(lambda d: not d.format.hidden, anaconda.id.storage.disks) # Skip this screen as well if there's only one disk to use. if len(disks) == 1: anaconda.id.storage.clearPartDisks = [disks[0].name] anaconda.id.bootloader.drivelist = [disks[0].name] return None (xml, self.vbox) = gui.getGladeWidget("cleardisks.glade", "vbox") self.leftScroll = xml.get_widget("leftScroll") self.rightScroll = xml.get_widget("rightScroll") self.addButton = xml.get_widget("addButton") self.removeButton = xml.get_widget("removeButton") self.installTargetImage = xml.get_widget("installTargetImage") self.installTargetTip = xml.get_widget("installTargetTip") self.anaconda = anaconda self.leftVisible = 1 self.leftActive = 2 self.rightVisible = 4 self.rightActive = 5 # One store for both views. First the obejct, then a visible/active for # the left hand side, then a visible/active for the right hand side, then # all the other stuff. # # NOTE: the third boolean is a placeholder. DeviceSelector uses the third # slot in the store to determine whether the row is immutable or not. We # just need to put False in there for everything. self.store = gtk.TreeStore(gobject.TYPE_PYOBJECT, gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING) self.store.set_sort_column_id(6, gtk.SORT_ASCENDING) # The left view shows all the drives that will just be mounted, but # can still be moved to the right hand side. self.leftFilteredModel = self.store.filter_new() self.leftSortedModel = gtk.TreeModelSort(self.leftFilteredModel) self.leftTreeView = gtk.TreeView(self.leftSortedModel) self.leftFilteredModel.set_visible_func(lambda model, iter, view: model.get_value(iter, self.leftVisible), self.leftTreeView) self.leftScroll.add(self.leftTreeView) self.leftDS = DeviceSelector(self.store, self.leftSortedModel, self.leftTreeView, visible=self.leftVisible, active=self.leftActive) self.leftDS.createMenu() self.leftDS.addColumn(_("Model"), 6) self.leftDS.addColumn(_("Capacity"), 7) self.leftDS.addColumn(_("Vendor"), 8) self.leftDS.addColumn(_("Identifier"), 9) self.leftDS.addColumn(_("Interconnect"), 10, displayed=False) # The right view show all the drives that will be wiped during install. self.rightFilteredModel = self.store.filter_new() self.rightSortedModel = gtk.TreeModelSort(self.rightFilteredModel) self.rightTreeView = gtk.TreeView(self.rightSortedModel) self.rightFilteredModel.set_visible_func(lambda model, iter, view: model.get_value(iter, self.rightVisible), self.rightTreeView) self.rightScroll.add(self.rightTreeView) self.rightDS = DeviceSelector(self.store, self.rightSortedModel, self.rightTreeView, visible=self.rightVisible, active=self.rightActive) self.rightDS.createSelectionCol(title=_("Boot\nLoader"), radioButton=True) self.rightDS.createMenu() self.rightDS.addColumn(_("Model"), 6) self.rightDS.addColumn(_("Capacity"), 7) self.rightDS.addColumn(_("Identifier"), 9) # Store the first disk (according to our detected BIOS order) for # auto boot device selection names = map(lambda d: d.name, disks) self.bootDisk = sorted(names, self.anaconda.id.storage.compareDisks)[0] # The device filtering UI set up exclusiveDisks as a list of the names # of all the disks we should use later on. Now we need to go get those, # look up some more information in the devicetree, and set up the # selector. for d in disks: rightVisible = d.name in self.anaconda.id.storage.clearPartDisks rightActive = rightVisible and \ d.name in self.anaconda.id.bootloader.drivelist[:1] leftVisible = not rightVisible if hasattr(d, "wwid"): ident = d.wwid else: try: ident = deviceNameToDiskByPath(d.name) if ident.startswith("/dev/disk/by-path/"): ident = ident.replace("/dev/disk/by-path/", "") except DeviceNotFoundError: ident = d.name self.store.append(None, (d, leftVisible, True, False, rightVisible, rightActive, d.model, str(int(d.size)) + " MB", d.vendor, ident, d.bus)) self.addButton.connect("clicked", self._add_clicked) self.removeButton.connect("clicked", self._remove_clicked) # Also allow moving devices back and forth with double click, enter, etc. self.leftTreeView.connect("row-activated", self._add_clicked) self.rightTreeView.connect("row-activated", self._remove_clicked) # And let the user select multiple devices at a time. self.leftTreeView.get_selection().set_mode(gtk.SELECTION_MULTIPLE) self.rightTreeView.get_selection().set_mode(gtk.SELECTION_MULTIPLE) if self.anaconda.id.storage.clearPartType == CLEARPART_TYPE_LINUX: self.installTargetTip.set_markup(_("<b>Tip:</b> All Linux filesystems on install target devices will be reformatted and wiped of any data. Make sure you have backups.")) elif self.anaconda.id.storage.clearPartType == CLEARPART_TYPE_ALL: self.installTargetTip.set_markup(_("<b>Tip:</b> Install target devices will be reformatted and wiped of any data. Make sure you have backups.")) else: self.installTargetTip.set_markup(_("<b>Tip:</b> Your filesystems on install target devices will not be wiped unless you choose to do so during customization.")) return self.vbox
def __init__(self, userbrowses, user, conn, data_dir): self.data_dir = data_dir # Build the window builder = gtk.Builder() builder.set_translation_domain('nicotine') builder.add_from_file( os.path.join(os.path.dirname(os.path.realpath(__file__)), "ui", "userbrowse.ui")) self.UserBrowseTab = builder.get_object("UserBrowseTab") for i in builder.get_objects(): try: self.__dict__[gtk.Buildable.get_name(i)] = i except TypeError: pass self.UserBrowseTab.remove(self.Main) self.UserBrowseTab.destroy() builder.connect_signals(self) self.userbrowses = userbrowses self.frame = userbrowses.frame self.user = user self.conn = conn # selected_folder is the current selected folder self.selected_folder = None self.search_list = [] self.query = None self.search_position = 0 self.selected_files = [] self.shares = [] # Iters for current DirStore self.directories = {} # Iters for current FileStore self.files = {} self.totalsize = 0 self.encoding, m = EncodingsMenu(self.frame.np, "userencoding", user) # Encoding Combobox self.Elist = {} self.EncodingStore = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING) self.Encoding.set_model(self.EncodingStore) cell = gtk.CellRendererText() self.Encoding.pack_start(cell, True) self.Encoding.add_attribute(cell, 'text', 0) cell2 = gtk.CellRendererText() self.Encoding.pack_start(cell2, False) self.Encoding.add_attribute(cell2, 'text', 1) for item in m: self.Elist[item[1]] = self.EncodingStore.append([item[1], item[0]]) if self.encoding == item[1]: self.Encoding.set_active_iter(self.Elist[self.encoding]) self.DirStore = gtk.TreeStore(str, str) self.FolderTreeView.set_headers_visible(True) self.FolderTreeView.set_enable_tree_lines(True) cols = InitialiseColumns( self.FolderTreeView, [_("Directories"), -1, "text", self.CellDataFunc] # 0 ) cols[0].set_sort_column_id(0) self.popup_menu_users = PopupMenu(self.frame) self.popup_menu_users2 = PopupMenu(self.frame) for menu in [self.popup_menu_users, self.popup_menu_users2]: menu.setup(("#" + _("Send _message"), menu.OnSendMessage), ("#" + _("Show IP a_ddress"), menu.OnShowIPaddress), ("#" + _("Get user i_nfo"), menu.OnGetUserInfo), ("#" + _("Gi_ve privileges"), menu.OnGivePrivileges), ("", None), ("$" + _("_Add user to list"), menu.OnAddToList), ("$" + _("_Ban this user"), menu.OnBanUser), ("$" + _("_Ignore this user"), menu.OnIgnoreUser)) self.popup_menu_downloads_folders = PopupMenu(self.frame) self.popup_menu_downloads_folders.setup( ("#" + _("_Download directory"), self.OnDownloadDirectory), ("#" + _("Download directory _to..."), self.OnDownloadDirectoryTo), ("#" + _("Download _recursive"), self.OnDownloadDirectoryRecursive), ("#" + _("Download r_ecursive to..."), self.OnDownloadDirectoryRecursiveTo)) self.popup_menu_downloads_files = PopupMenu(self.frame) self.popup_menu_downloads_files.setup( ("#" + _("_Download file(s)"), self.OnDownloadFiles), ("#" + _("Download _to..."), self.OnDownloadFilesTo), ("", None), ("#" + _("_Download directory"), self.OnDownloadDirectory), ("#" + _("Download directory _to..."), self.OnDownloadDirectoryTo), ("#" + _("Download _recursive"), self.OnDownloadDirectoryRecursive), ("#" + _("Download r_ecursive to..."), self.OnDownloadDirectoryRecursiveTo)) self.popup_menu_uploads_folders = PopupMenu(self.frame) self.popup_menu_uploads_folders.setup( ("#" + _("Upload Directory to..."), self.OnUploadDirectoryTo), ("#" + _("Upload Directory recursive to..."), self.OnUploadDirectoryRecursiveTo)) self.popup_menu_uploads_files = PopupMenu(self.frame) self.popup_menu_uploads_files.setup( ("#" + _("Upload Directory to..."), self.OnUploadDirectoryTo), ("#" + _("Upload Directory recursive to..."), self.OnUploadDirectoryRecursiveTo), ("#" + _("Up_load file(s)"), self.OnUploadFiles)) self.folder_popup_menu = PopupMenu(self.frame) self.folder_popup_menu.set_user(user) if user == self.frame.np.config.sections["server"]["login"]: self.folder_popup_menu.setup( ("USERMENU", _("User"), self.popup_menu_users, self.OnPopupMenuFolderUser), ("", None), (1, _("Download"), self.popup_menu_downloads_folders, self.OnPopupMenuDummy), (1, _("Upload"), self.popup_menu_uploads_folders, self.OnPopupMenuDummy), ("", None), ("#" + _("Copy _URL"), self.OnCopyDirURL), ("#" + _("Open in File Manager"), self.OnFileManager)) else: self.folder_popup_menu.setup( ("USERMENU", _("User"), self.popup_menu_users, self.OnPopupMenuFolderUser), ("", None), (1, _("Download"), self.popup_menu_downloads_folders, self.OnPopupMenuDummy), ("", None), ("#" + _("Copy _URL"), self.OnCopyDirURL)) self.FolderTreeView.connect("button_press_event", self.OnFolderClicked) self.FolderTreeView.get_selection().connect("changed", self.OnSelectDir) # DecodedFilename, HSize, Bitrate, HLength, Size, Length, RawFilename self.FileStore = gtk.ListStore(str, str, str, str, gobject.TYPE_INT64, int, str) self.FileTreeView.set_model(self.FileStore) cols = InitialiseColumns( self.FileTreeView, [_("Filename"), 250, "text", self.CellDataFunc], [_("Size"), 100, "text", self.CellDataFunc], [_("Bitrate"), 70, "text", self.CellDataFunc], [_("Length"), 50, "text", self.CellDataFunc]) cols[0].set_sort_column_id(0) cols[1].set_sort_column_id(4) cols[2].set_sort_column_id(2) cols[3].set_sort_column_id(5) self.FileStore.set_sort_column_id(0, gtk.SORT_ASCENDING) for i in range(4): parent = cols[i].get_widget().get_ancestor(gtk.Button) if parent: parent.connect('button_press_event', PressHeader) # Read Show / Hide column settings from last session self.FileTreeView.get_selection().set_mode(gtk.SELECTION_MULTIPLE) self.FileTreeView.set_headers_clickable(True) self.FileTreeView.set_property("rules-hint", True) self.file_popup_menu = PopupMenu(self.frame) if user == self.frame.np.config.sections["server"]["login"]: self.file_popup_menu.setup( ("USERMENU", "User", self.popup_menu_users2, self.OnPopupMenuFileUser), ("", None), (1, _("Download"), self.popup_menu_downloads_files, self.OnPopupMenuDummy), (1, _("Upload"), self.popup_menu_uploads_files, self.OnPopupMenuDummy), ("", None), ("#" + _("Copy _URL"), self.OnCopyURL), ("#" + _("Send to _player"), self.OnPlayFiles), ("#" + _("Open in File Manager"), self.OnFileManager)) else: self.file_popup_menu.setup( ("USERMENU", "User", self.popup_menu_users2, self.OnPopupMenuFileUser), ("", None), (1, _("Download"), self.popup_menu_downloads_files, self.OnPopupMenuDummy), ("", None), ("#" + _("Copy _URL"), self.OnCopyURL)) self.FileTreeView.connect("button_press_event", self.OnFileClicked) self.ChangeColours() for name, object in self.__dict__.items(): if type(object) is PopupMenu: object.set_user(self.user)
def initModel(self): # create tree store return gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN)
def __init__(self, tv): self.trusted_keys = gtk.TreeStore(str, object) tv.set_model(self.trusted_keys) tc = gtk.TreeViewColumn(_('Trusted keys'), gtk.CellRendererText(), text=0) tv.append_column(tc) trust.trust_db.ensure_uptodate() def update_keys(): # Remember which ones are open expanded_elements = set() def add_row(tv, path, unused=None): if len(path) == 1: domain = self.trusted_keys[path][0] expanded_elements.add(domain) tv.map_expanded_rows(add_row, None) self.trusted_keys.clear() domains = {} keys = gpg.load_keys(list(trust.trust_db.keys.keys())) for fingerprint in keys: for domain in trust.trust_db.keys[fingerprint]: if domain not in domains: domains[domain] = set() domains[domain].add(keys[fingerprint]) for domain in sorted(domains): iter = self.trusted_keys.append(None, [domain, None]) for key in domains[domain]: self.trusted_keys.append(iter, [key.name, key]) def may_expand(model, path, iter, unused): if len(path) == 1: if model[iter][0] in expanded_elements: tv.expand_row(path, False) self.trusted_keys.foreach(may_expand, None) trust.trust_db.watchers.append(update_keys) tv.connect('destroy', lambda w: trust.trust_db.watchers.remove(update_keys)) update_keys() def remove_key(fingerprint, domain): trust.trust_db.untrust_key(fingerprint, domain) trust.trust_db.notify() def trusted_keys_button_press(tv, bev): if bev.type == gtk.gdk.BUTTON_PRESS and bev.button == 3: pos = tv.get_path_at_pos(int(bev.x), int(bev.y)) if not pos: return False path, col, x, y = pos if len(path) != 2: return False key = self.trusted_keys[path][1] if isinstance(path, tuple): path = path[:-1] # PyGTK else: path.up() # PyGObject domain = self.trusted_keys[path][0] global menu # Needed to stop Python 3 GCing the menu and closing it instantly menu = gtk.Menu() item = gtk.MenuItem() item.set_label(_('Remove key for "%s"') % key.get_short_name()) item.connect('activate', lambda item, fp=key.fingerprint, d=domain: remove_key(fp, d)) item.show() menu.append(item) if sys.version_info[0] > 2: menu.popup(None, None, None, None, bev.button, bev.time) else: menu.popup(None, None, None, bev.button, bev.time) return True return False tv.connect('button-press-event', trusted_keys_button_press)
def __init__(self, title, parent, tmpdir, timeout): if timeout: self.timeout = float(timeout) else: self.timeout = None self.chosen = None self.updater = None self.tmpdir = tmpdir self.gcapture_windows = [] gobject.threads_init() # self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window = gtk.Dialog( "Choose a suite", parent, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK)) # self.window.set_modal(True) self.window.set_title(title) self.window.set_size_request(750, 400) # TODO: not needed for a dialog window? self.window.set_icon(get_icon()) # self.window.set_border_width(5) self.window.connect("delete_event", self.delete_all_event) sw = gtk.ScrolledWindow() sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.regd_treeview = gtk.TreeView() self.regd_treestore = gtk.TreeStore(str, str, str, str, str, str, str) self.regd_treeview.set_model(self.regd_treestore) self.regd_treeview.set_rules_hint(True) # search column zero (Ctrl-F) self.regd_treeview.connect('key_press_event', self.on_suite_select) self.regd_treeview.connect('button_press_event', self.on_suite_select) self.regd_treeview.set_search_column(0) regd_ts = self.regd_treeview.get_selection() regd_ts.set_mode(gtk.SELECTION_SINGLE) cr = gtk.CellRendererText() # cr.set_property('cell-background', '#def') tvc = gtk.TreeViewColumn( 'Suite', cr, text=0, foreground=4, background=5) tvc.set_resizable(True) tvc.set_sort_column_id(0) self.regd_treeview.append_column(tvc) cr = gtk.CellRendererText() tvc = gtk.TreeViewColumn( 'Host:Port', cr, text=1, foreground=4, background=5) tvc.set_resizable(True) # not sure how this sorting works # tvc.set_sort_column_id(1) self.regd_treeview.append_column(tvc) cr = gtk.CellRendererText() # cr.set_property('cell-background', '#def') tvc = gtk.TreeViewColumn( 'Title', cr, markup=2, foreground=4, background=6) tvc.set_resizable(True) # vc.set_sort_column_id(2) self.regd_treeview.append_column(tvc) cr = gtk.CellRendererText() tvc = gtk.TreeViewColumn( 'Location', cr, text=3, foreground=4, background=5) tvc.set_resizable(True) # vc.set_sort_column_id(3) self.regd_treeview.append_column(tvc) vbox = self.window.vbox sw.add(self.regd_treeview) vbox.pack_start(sw, True) self.selected_label_text = ( '(double-click or OK to select; right-click for db options)') self.selected_label = gtk.Label(self.selected_label_text) filter_entry = EntryTempText() filter_entry.set_width_chars(7) # Reduce width in toolbar filter_entry.connect("activate", self.filter) filter_entry.set_temp_text("filter") filter_toolitem = gtk.ToolItem() filter_toolitem.add(filter_entry) tooltip = gtk.Tooltips() tooltip.enable() tooltip.set_tip( filter_toolitem, "Filter suites \n(enter a sub-string or regex)") expand_button = gtk.ToolButton() image = gtk.image_new_from_stock( gtk.STOCK_ADD, gtk.ICON_SIZE_SMALL_TOOLBAR) expand_button.set_icon_widget(image) expand_button.connect( 'clicked', lambda x: self.regd_treeview.expand_all()) collapse_button = gtk.ToolButton() image = gtk.image_new_from_stock( gtk.STOCK_REMOVE, gtk.ICON_SIZE_SMALL_TOOLBAR) collapse_button.set_icon_widget(image) collapse_button.connect( 'clicked', lambda x: self.regd_treeview.collapse_all()) hbox = gtk.HBox() eb = gtk.EventBox() eb.add(self.selected_label) eb.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#bbc')) hbox.pack_start(eb, True) hbox.pack_start(expand_button, False) hbox.pack_start(collapse_button, False) hbox.pack_start(filter_toolitem, False) vbox.pack_start(hbox, False) self.window.show_all() self.start_updater()
def show(self): self.builder = gtk.Builder() # The main dialog self.builder.add_from_file( deluge.common.resource_filename( "deluge.ui.gtkui", os.path.join("glade", "create_torrent_dialog.ui"))) # The remote path dialog self.builder.add_from_file( deluge.common.resource_filename( "deluge.ui.gtkui", os.path.join("glade", "create_torrent_dialog.remote_path.ui"))) # The remote save dialog self.builder.add_from_file( deluge.common.resource_filename( "deluge.ui.gtkui", os.path.join("glade", "create_torrent_dialog.remote_save.ui"))) # The progress dialog self.builder.add_from_file( deluge.common.resource_filename( "deluge.ui.gtkui", os.path.join("glade", "create_torrent_dialog.progress.ui"))) self.config = ConfigManager("gtkui.conf") self.dialog = self.builder.get_object("create_torrent_dialog") self.dialog.set_transient_for(component.get("MainWindow").window) self.builder.connect_signals({ "on_button_file_clicked": self._on_button_file_clicked, "on_button_folder_clicked": self._on_button_folder_clicked, "on_button_remote_path_clicked": self._on_button_remote_path_clicked, "on_button_cancel_clicked": self._on_button_cancel_clicked, "on_button_save_clicked": self._on_button_save_clicked, "on_button_up_clicked": self._on_button_up_clicked, "on_button_add_clicked": self._on_button_add_clicked, "on_button_remove_clicked": self._on_button_remove_clicked, "on_button_down_clicked": self._on_button_down_clicked }) # path, icon, size self.files_treestore = gtk.TreeStore(str, str, gobject.TYPE_UINT64) column = gtk.TreeViewColumn(_("Filename")) render = gtk.CellRendererPixbuf() column.pack_start(render, False) column.add_attribute(render, "stock-id", 1) render = gtk.CellRendererText() column.pack_start(render, True) column.add_attribute(render, "text", 0) column.set_expand(True) self.builder.get_object("treeview_files").append_column(column) column = gtk.TreeViewColumn(_("Size")) render = gtk.CellRendererText() column.pack_start(render) column.set_cell_data_func(render, listview.cell_data_size, 2) self.builder.get_object("treeview_files").append_column(column) self.builder.get_object("treeview_files").set_model( self.files_treestore) self.builder.get_object("treeview_files").set_show_expanders(False) # tier, url self.trackers_liststore = gtk.ListStore(int, str) self.builder.get_object("tracker_treeview").append_column( gtk.TreeViewColumn(_("Tier"), gtk.CellRendererText(), text=0)) self.builder.get_object("tracker_treeview").append_column( gtk.TreeViewColumn(_("Tracker"), gtk.CellRendererText(), text=1)) self.builder.get_object("tracker_treeview").set_model( self.trackers_liststore) self.trackers_liststore.set_sort_column_id(0, gtk.SORT_ASCENDING) if not client.is_localhost() and client.connected(): self.builder.get_object("button_remote_path").show() else: self.builder.get_object("button_remote_path").hide() self.dialog.show()
def treeview(self): import main_treeview # set up the treeview to do multiple selection tree = self.widgets['treeview'] self.treemodel = gtk.TreeStore(str, gtk.gdk.Pixbuf, str, str, str, str, bool, str, str, int, str, str) tree.set_model(self.treemodel) tree.set_headers_visible(True) tree.get_selection().set_mode(gtk.SELECTION_MULTIPLE) self.widgets['treeview'].get_selection().connect("changed", main_treeview.on_tree_selection, self) # number column renderer = gtk.CellRendererText() self.number_column = gtk.TreeViewColumn(_('No.'), renderer, text=0) self.number_column.set_name('number') self.number_column.set_resizable(True) self.number_column.set_sort_column_id(0) self.number_column.set_reorderable(True) self.widgets['treeview'].append_column(self.number_column) # pic column renderer = gtk.CellRendererPixbuf() self.image_column = gtk.TreeViewColumn(_('Image'), renderer, pixbuf=1) self.image_column.set_name('image') self.image_column.set_resizable(False) self.image_column.set_reorderable(True) self.widgets['treeview'].append_column(self.image_column) # original title column renderer = gtk.CellRendererText() self.otitle_column = gtk.TreeViewColumn(_('Original Title'), renderer, text=2) self.otitle_column.set_name('otitle') self.otitle_column.set_resizable(True) self.otitle_column.set_sort_column_id(2) self.otitle_column.set_reorderable(True) self.widgets['treeview'].append_column(self.otitle_column) # title column renderer = gtk.CellRendererText() self.title_column = gtk.TreeViewColumn(_('Title'), renderer, text=3) self.title_column.set_name('title') self.title_column.set_resizable(True) self.title_column.set_sort_column_id(3) self.title_column.set_reorderable(True) self.widgets['treeview'].append_column(self.title_column) # director column renderer = gtk.CellRendererText() self.director_column = gtk.TreeViewColumn(_('Director'), renderer, text=4) self.director_column.set_name('director') self.director_column.set_sort_column_id(4) self.director_column.set_resizable(True) self.director_column.set_reorderable(True) self.widgets['treeview'].append_column(self.director_column) # genre column renderer = gtk.CellRendererText() self.genre_column = gtk.TreeViewColumn(_('Genre'), renderer, text=5) self.genre_column.set_name('genre') self.genre_column.set_sort_column_id(5) self.genre_column.set_resizable(True) self.genre_column.set_reorderable(True) self.widgets['treeview'].append_column(self.genre_column) # seen column renderer = gtk.CellRendererToggle() self.seen_column = gtk.TreeViewColumn(_('Seen it'), renderer, active=6) self.seen_column.set_name('seen') self.seen_column.set_sort_column_id(6) self.seen_column.set_resizable(True) self.seen_column.set_reorderable(True) self.widgets['treeview'].insert_column(self.seen_column, 1) # year column renderer = gtk.CellRendererText() renderer.set_property('xalign', 0.5) self.year_column = gtk.TreeViewColumn(_('Year'), renderer, text=7) self.year_column.set_name('year') self.year_column.set_sort_column_id(7) self.year_column.set_resizable(True) self.year_column.set_alignment(0.5) self.year_column.set_reorderable(True) self.widgets['treeview'].append_column(self.year_column) # runtime column renderer = gtk.CellRendererText() renderer.set_property('xalign', 1) self.runtime_column = gtk.TreeViewColumn(_('Runtime'), renderer, text=8) self.runtime_column.set_name('runtime') self.runtime_column.set_sort_column_id(8) self.runtime_column.set_resizable(True) self.runtime_column.set_alignment(1) self.runtime_column.set_reorderable(True) self.widgets['treeview'].append_column(self.runtime_column) # rating column renderer = gtk.CellRendererText() renderer.set_property('xalign', 0.5) self.rating_column = gtk.TreeViewColumn(_('Rating'), renderer, text=9) self.rating_column.set_name('rating') self.rating_column.set_sort_column_id(9) self.rating_column.set_resizable(True) self.rating_column.set_alignment(0.5) self.rating_column.set_reorderable(True) self.widgets['treeview'].append_column(self.rating_column) # created column renderer = gtk.CellRendererText() renderer.set_property('xalign', 0.5) self.created_column = gtk.TreeViewColumn(_('Created'), renderer, text=10) self.created_column.set_name('created') self.created_column.set_sort_column_id(10) self.created_column.set_resizable(True) self.created_column.set_alignment(0.5) self.created_column.set_reorderable(True) self.widgets['treeview'].append_column(self.created_column) # updated column renderer = gtk.CellRendererText() renderer.set_property('xalign', 0.5) self.updated_column = gtk.TreeViewColumn(_('Updated'), renderer, text=11) self.updated_column.set_name('updated') self.updated_column.set_sort_column_id(11) self.updated_column.set_resizable(True) self.updated_column.set_alignment(0.5) self.updated_column.set_reorderable(True) self.widgets['treeview'].append_column(self.updated_column) # reflect saved column order and column sizes columnorder = self.config.get('columnorder', None, section='mainlist') if columnorder: columnmapping = dict([(column.get_name(), column) for column in self.widgets['treeview'].get_columns()]) currentcol = None columnordersplitted = re.split('[ \t]*,[ \t]*', columnorder) for col in columnordersplitted: if col in columnmapping: self.widgets['treeview'].move_column_after(columnmapping[col], currentcol) currentcol = columnmapping[col] columnsizes = self.config.get('columnsizes', None, section='mainlist') if columnsizes: columnsizessplitted = re.split('[ \t]*,[ \t]*', columnsizes) currentcol = 0 for columnsize in columnsizessplitted: try: columnsize = int(columnsize) self.widgets['treeview'].get_column(currentcol).set_sizing(gtk.TREE_VIEW_COLUMN_FIXED) self.widgets['treeview'].get_column(currentcol).set_fixed_width(columnsize) except: pass currentcol = currentcol + 1 # reflect saved column sorting columnsortid = self.config.get('columnsortid', None, section='mainlist') columnsortorder = self.config.get('columnsortorder', None, section='mainlist') try: if columnsortid: columnsortid = int(columnsortid) if columnsortorder: columnsortorder = gtk.SortType(int(columnsortorder)) else: columnsortorder = gtk.SORT_ASCENDING self.treemodel.set_sort_column_id(columnsortid, columnsortorder) except: log.exception('') # add data to treeview self.total = self.db.session.query(db.Movie).count() self.widgets['treeview'].set_search_equal_func(search_func_treeview) self.widgets['treeview'].show() # adding some completion fields - TODO: move it to initialize self.completion = gtk.EntryCompletion() self.widgets['add']['o_title'].set_completion(self.completion) self.completion.set_model(self.treemodel) self.completion.set_text_column(3) # ... title self.completion_t = gtk.EntryCompletion() self.widgets['add']['title'].set_completion(self.completion_t) self.completion_t.set_model(self.treemodel) self.completion_t.set_text_column(4)
def __init__(self, *args, **kwargs): super(SongListWindow, self).__init__(gtk.WINDOW_TOPLEVEL, *args, **kwargs) # Connect the basic event handlers self.connect("destroy", self.destroy) # Read the songs from the database songs = Song.objects.all() ####### Window furniture # Set up the appearance of the window self.set_default_size(300, 800) self.set_title("Jazznotate - The Jazz Parser Annotation GUI") # A box to put all the widgets in vbox = gtk.VBox() self.add(vbox) ######## The song list # Set up the tree to contain the songs and their sequences treestore = gtk.TreeStore(gobject.TYPE_STRING) # Add all the songs from the database to the store self.songs = [] for song in songs: song_pos = treestore.append(None, [song.name]) song_seqs = [] for sequence in song.chordsequence_set.all(): treestore.append(song_pos, [sequence.sequence_distinguisher]) song_seqs.append(sequence) self.songs.append((song, song_seqs)) treeview = gtk.TreeView(treestore) self.treeview = treeview # Let the list respond to clicks self.treeview.connect("button_press_event", self.list_clicked) # Add a column to the treeview to display the song names name_column = gtk.TreeViewColumn("Song name") self.treeview.append_column(name_column) # Render the song names as text name_renderer = gtk.CellRendererText() name_column.pack_start(name_renderer, True) name_column.add_attribute(name_renderer, "text", 0) # Make it possible to search the signs self.treeview.set_search_column(0) # Put the treeview in scrollbars treeview_scroll = gtk.ScrolledWindow() treeview_scroll.add_with_viewport(treeview) vbox.add(treeview_scroll) # Add buttons at the bottom button_box = gtk.HButtonBox() button_box.set_layout(gtk.BUTTONBOX_END) midi_button = gtk.Button("Midis") midi_button.connect("clicked", self.open_midis) edit_button = gtk.Button("Edit sequence") edit_button.connect("clicked", self.open_sequence) meta_edit_button = gtk.Button("Edit sequence details") meta_edit_button.connect("clicked", self.open_sequence_meta) song_edit_button = gtk.Button("Edit song details") song_edit_button.connect("clicked", self.open_song) button_box.pack_end(midi_button, expand=False, padding=5) button_box.pack_end(song_edit_button, expand=False, padding=5) button_box.pack_end(meta_edit_button, expand=False, padding=5) button_box.pack_end(edit_button, expand=False, padding=5) vbox.pack_end(button_box, expand=False, padding=5) # Prepare popup menus for right-clicking on the list # Two menus for different conditions sequence_meta_item = gtk.MenuItem("Edit sequence details") sequence_meta_item.connect("activate", self.open_sequence_meta) sequence_meta_item.show() sequence_edit_item = gtk.MenuItem("Edit sequence") sequence_edit_item.connect("activate", self.open_sequence) sequence_edit_item.show() midis_item = gtk.MenuItem("Show midi records") midis_item.connect("activate", self.open_midis) midis_item.show() song_edit_item = gtk.MenuItem("Edit song details") song_edit_item.connect("activate", self.open_song) song_edit_item.show() self.menu_sequence_and_song = gtk.Menu() self.menu_sequence_and_song.append(sequence_meta_item) self.menu_sequence_and_song.append(sequence_edit_item) self.menu_sequence_and_song.append(midis_item) self.menu_sequence_and_song.append(song_edit_item) song_edit_item2 = gtk.MenuItem("Edit song details") song_edit_item2.connect("button_press_event", self.open_song) song_edit_item2.show() self.menu_song = gtk.Menu() self.menu_song.append(song_edit_item2) self.show_all()
def lang_treeview(self): treeview = self.widgets['add']['lang_treeview'] self.lang['model'] = gtk.TreeStore(str, str, str, str, str) treeview.set_model(self.lang['model']) treeview.set_headers_visible(True) model = self.lang['lang'] = gtk.ListStore(int, str) for i in self.db.session.query(db.Lang.lang_id, db.Lang.name).all(): model.append([i.lang_id, i.name]) combo = gtk.CellRendererCombo() combo.set_property('model', model) combo.set_property('text-column', 1) combo.set_property('editable', True) combo.set_property('has-entry', False) combo.connect('edited', self.on_tv_lang_combo_edited, 0) column = gtk.TreeViewColumn(_('Language'), combo, text=0) column.set_property('min-width', 80) column.set_property('resizable', True) column.set_sort_column_id(0) treeview.append_column(column) model = self.lang['type'] = gtk.ListStore(int, str) #i = 0 #for lang_type in self._lang_types: # model.append([i, lang_type]) # i += 1 model.append([0, '']) model.append([1, _('lector')]) model.append([2, _('dubbing')]) model.append([3, _('subtitles')]) model.append([4, _("commentary")]) combo = gtk.CellRendererCombo() combo.set_property('model', model) combo.set_property('text-column', 1) combo.set_property('editable', True) combo.set_property('has-entry', False) combo.connect('edited', self.on_tv_lang_combo_edited, 1) column = gtk.TreeViewColumn(_('Type'), combo, text=1) column.set_property('min-width', 80) column.set_property('resizable', True) column.set_sort_column_id(1) treeview.append_column(column) model = self.lang['acodec'] = gtk.ListStore(int, str) for i in self.db.session.query(db.ACodec.acodec_id, db.ACodec.name).all(): model.append([i.acodec_id, i.name]) combo = gtk.CellRendererCombo() combo.set_property('model', model) combo.set_property('text-column', 1) combo.set_property('editable', True) combo.set_property('has-entry', False) combo.connect('edited', self.on_tv_lang_combo_edited, 2) column = gtk.TreeViewColumn(_('Codec'), combo, text=2) column.set_property('min-width', 80) column.set_property('resizable', True) column.set_sort_column_id(2) treeview.append_column(column) model = self.lang['achannel'] = gtk.ListStore(int, str) for i in self.db.session.query(db.AChannel.achannel_id, db.AChannel.name).all(): model.append([i.achannel_id, i.name]) combo = gtk.CellRendererCombo() combo.set_property('model', model) combo.set_property('text-column', 1) combo.set_property('editable', True) combo.set_property('has-entry', False) combo.connect('edited', self.on_tv_lang_combo_edited, 3) column = gtk.TreeViewColumn(_('Channels'), combo, text=3) column.set_property('min-width', 80) column.set_property('resizable', True) column.set_sort_column_id(3) treeview.append_column(column) model = self.lang['subformat'] = gtk.ListStore(int, str) for i in self.db.session.query(db.SubFormat.subformat_id, db.SubFormat.name).all(): model.append([i.subformat_id, i.name]) combo = gtk.CellRendererCombo() combo.set_property('model', model) combo.set_property('text-column', 1) combo.set_property('editable', True) combo.set_property('has-entry', False) combo.connect('edited', self.on_tv_lang_combo_edited, 4) column = gtk.TreeViewColumn(_('Subtitle format'), combo, text=4) column.set_property('min-width', 80) column.set_property('resizable', True) column.set_sort_column_id(4) treeview.append_column(column) treeview.show_all()
def wmf_gentree(): # Record/Group Name Rec. Type Min. Length Template model = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_PYOBJECT) view = gtk.TreeView(model) renderer = gtk.CellRendererText() column = gtk.TreeViewColumn('Group/Record', renderer, text=0) column2 = gtk.TreeViewColumn('Length', renderer, text=2) view.append_column(column) view.append_column(column2) # Drawing Record Types # 2610:ExtTextOut, drawrec = ( (0x213, 10, "\x05\x00\x00\x00\x13\x02\x00\x00\x00\x00"), #LineTo (0x214, 10, "\x05\x00\x00\x00\x14\x02\x00\x00\x00\x00"), #MoveTo (0x324, 20, "\x0a\x00\x00\x00\x24\x03\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" ), #Polygon (0x325, 20, "\x0a\x00\x00\x00\x25\x03\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" ), #Polyline (0x418, 14, "\x07\x00\x00\x00\x18\x04\x00\x00\x00\x00\x00\x00\x00\x00"), #Ellipse (0x41b, 14, "\x07\x00\x00\x00\x1b\x04\x00\x00\x00\x00\x00\x00\x00\x00" ), #Rectangle (0x538, 22, "\x0b\x00\x00\x00\x38\x05\x01\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" ), #PolyPolygon (0x61c, 18, "\x09\x00\x00\x00\x1c\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" ), #RoundRect (0x817, 22, "\x0b\x00\x00\x00\x17\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" ), #Arc (0x81a, 22, "\x0b\x00\x00\x00\x1a\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" ), #Pie (0x830, 22, "\x0b\x00\x00\x00\x30\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" ), #Chord ) # Object Creation Record Types objcrec = ((0x5d, 32), (0x5e, 32), (0x5f, 32), (0x7a, 20), (0x26, 28), (0x27, 24), (0x31, 12), (0x52, 16), (0x63, 12)) # Object Manipulation Record Types objmrec = (0x25, 0x28, 0x30, 0x32, 0x33, 0x64, 0x65, 0x6f) # State Record Types staterec = (0xa, 0xb, 0xc, 0xd, 0x17, 0x1b, 0x1f, 0x9, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,\ 0x16, 0x18, 0x19, 0x20, 0x21, 0x22, 0x34, 0x39, 0x3a, 0x49, 0x62, 0x68, 0x6d,\ 0x70, 0x71, 0x73, 0x77, 0x78, 0x79) iter = model.append(None, None) model.set(iter, 0, "Drawing Records", 1, -1, 2, "") for i in range(len(drawrec)): niter = model.append(iter, None) model.set(niter, 0, wmr_ids[drawrec[i][0]], 1, drawrec[i][0], 2, drawrec[i][1], 3, drawrec[i][2]) return model, view
def extension_preferences(self, module, enabled): # preferences window p_vbox = self.widgets['extensions']['preferences_vbox'] configwidgets = {} label = "%s v%s <i>(%s <%s>)</i>" % (module.name, module.version, module.author, module.email) expander = gtk.Expander(label=label) expander.get_label_widget().set_tooltip_markup(module.description) expander.set_use_markup(True) vbox = gtk.VBox() # extension details hbox = gtk.HBox() vbox.pack_start(hbox, expand=False) enabled_cb = gtk.CheckButton(label=_('Enable this extension')) enabled_cb.set_active(enabled) configwidgets['enabled'] = enabled_cb vbox.pack_start(enabled_cb, expand=False) for pref_name in module.preferences: name = module.preferences[pref_name].get('name', pref_name) hint = module.preferences[pref_name].get('hint') value = module.preferences[pref_name].get('default') value = self.config.get("%s_%s" % (module.name, pref_name), value, section='extensions') type_ = module.preferences[pref_name].get('type', unicode) hbox = gtk.HBox() hbox.pack_start(gtk.Label(name), expand=False, padding=4) if type_ is unicode: w = gtk.Entry() w.insert_text(value) # TODO: min, max # elif type is int: # TODO elif type_ is bool: w = gtk.CheckButton() w.set_active(bool(value)) elif isinstance(type_, (list, tuple, dict)): model = gtk.TreeStore(str, str) if isinstance(type_, dict): iterable = type_.iteritems() else: iterable = enumerate(type_) pos = None count = 0 for code, codevalue in iterable: myiter = model.append(None, None) model.set_value(myiter, 0, unicode(code)) model.set_value(myiter, 1, unicode(codevalue)) if value and value == codevalue: pos = count count = count + 1 # combobox with complex binding to a model needs cell renderer w = gtk.ComboBox(model=model) renderer = gtk.CellRendererText() w.pack_start(renderer) w.add_attribute(renderer, 'text', 1) if pos is not None: w.set_active(int(pos)) else: log.error('type not recognized %s', type(type_)) continue if hint: w.set_tooltip_markup(hint) hbox.pack_start(w) vbox.pack_start(hbox, expand=False) configwidgets[pref_name] = w expander.add(vbox) p_vbox.pack_start(expander, expand=False) p_vbox.show_all() return configwidgets
def createGamesWindow(self): ''' Create TreeView of all Games on the server. @return: gtk.VBox containing a TreeView of all Games on the server. ''' vbox = gtk.VBox(False, 1) self.gameList = gtk.TreeStore(str, str, str) self.gameView = gtk.TreeView(gtk.TreeModelSort(self.gameList)) self.gameView.set_headers_clickable(True) self.gameView.connect("button-press-event", self.gameListClicked_cb) title = _('Game') col1 = gtk.TreeViewColumn('%s' % title) col1.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE) cell1 = gtk.CellRendererText() col1.pack_start(cell1, True) col1.add_attribute(cell1, 'text', 0) col1.set_sort_column_id(0) title = _('Players') col2 = gtk.TreeViewColumn('# %s' % title) cell2 = gtk.CellRendererText() col2.pack_start(cell2, True) col2.add_attribute(cell2, 'text', 1) col2.set_sort_column_id(1) title = _('Status') col3 = gtk.TreeViewColumn('%s' % title) cell3 = gtk.CellRendererText() col3.pack_start(cell3, True) col3.add_attribute(cell3, 'text', 2) col3.set_sort_column_id(2) self.gameView.append_column(col1) self.gameView.append_column(col2) self.gameView.append_column(col3) header = gtk.Label() title = _('Game Listing') header.set_markup("<b><big>%s:</big></b>" % title) header.set_justify(gtk.JUSTIFY_LEFT) bbox = gtk.HButtonBox() self.joinButton = gtk.Button(label=_("Join Game")) self.joinButton.connect("clicked", self.joinGame_cb) bbox.add(self.joinButton) window = gtk.ScrolledWindow() window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) window.add(self.gameView) vbox.pack_start(header, False, False, 1) vbox.pack_start(window, True, True, 0) vbox.pack_start(bbox, False, False, 0) return vbox
def treeview_widgets(self): self.sort_col_num = 0 self.ttreestore = gtk.TreeStore(str, str, str, str, str, str, str, str, str, str, str, gtk.gdk.Pixbuf, int) self.ttreeview = gtk.TreeView() self.ttreeview.set_rules_hint(True) # TODO - REMOVE FILTER HERE? self.tmodelfilter = self.ttreestore.filter_new() self.tmodelsort = gtk.TreeModelSort(self.tmodelfilter) self.ttreeview.set_model(self.tmodelsort) ts = self.ttreeview.get_selection() ts.set_mode(gtk.SELECTION_SINGLE) self.ttreeview.connect('button_press_event', self.on_treeview_button_pressed) headings = [ None, 'task', 'state', 'host', 'job system', 'job ID', 'T-submit', 'T-start', 'T-finish', 'dT-mean', 'latest message', ] for n in range(1, len(headings)): # Skip first column (cycle point) tvc = gtk.TreeViewColumn(headings[n]) if n == 1: crp = gtk.CellRendererPixbuf() tvc.pack_start(crp, False) tvc.set_attributes(crp, pixbuf=11) if n == 8: # Pack in progress and text cell renderers. prog_cr = gtk.CellRendererProgress() tvc.pack_start(prog_cr, True) tvc.set_cell_data_func(prog_cr, self._set_cell_text_time, n) cr = gtk.CellRendererText() tvc.pack_start(cr, True) if n == 6 or n == 7 or n == 8: tvc.set_cell_data_func(cr, self._set_cell_text_time, n) else: tvc.set_attributes(cr, text=n) tvc.set_resizable(True) tvc.set_clickable(True) self.ttreeview.append_column(tvc) tvc.set_sort_column_id(n - 1) self.tmodelsort.set_sort_func(n - 1, self.sort_column, n - 1) sw = gtk.ScrolledWindow() sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) sw.add(self.ttreeview) vbox = gtk.VBox() vbox.pack_start(sw, True) return vbox
def parse (cmd, entry, page): if cmd[0] == "$": pos = cmd.find("@") if pos != -1: chtype = cmd[1:pos] chaddr = cmd[pos+1:] else: chtype = cmd[1:] chaddr = "0" print("Command: ",chtype,chaddr) treeSelection = page.view.get_selection() model, iter1 = treeSelection.get_selected() if iter1 == None: page.view.set_cursor_on_cell(0) treeSelection = page.view.get_selection() model, iter1 = treeSelection.get_selected() buf = model.get_value(iter1,3) if "ole" == chtype.lower(): if buf[int(chaddr,16):int(chaddr,16)+8] == "\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1": ole.ole_open (buf[int(chaddr,16):],page,iter1) else: print("OLE stream not found at ",chaddr) elif "bmp" == chtype.lower(): #try: if 1: addr,bpp,w,h = chaddr.split(":") dib_data = "\x28\x00\x00\x00"+struct.pack("<I",int(w))+struct.pack("<I",int(h))+"\x01\x00" dib_data += struct.pack("<H",int(bpp))+"\x00"*8+struct.pack("<I",160)*2+"\x00"*8 dib_data += buf[int(addr,16):] iter2 = add_pgiter (page,"[BMP]","escher","Blip",dib2bmp(dib_data),iter1) model.set_value(iter2,1,("escher","odraw","Blip")) #except: # print 'Failed to construct DIB data' elif "b64" == chtype.lower(): b64decode (page,buf[int(chaddr,16):],iter1) elif "cvx" == chtype.lower(): cvx.parse (page,buf[int(chaddr,16):],iter1) elif "esc" == chtype.lower(): escher.parse (model,buf[int(chaddr,16):],iter1) elif "cmx" == chtype.lower(): cdr.cdr_open (buf[int(chaddr,16):],page,iter1) elif "icc" == chtype.lower(): icc.parse (page,buf[int(chaddr,16):],iter1) elif "cdx" == chtype.lower(): chdraw.open (page,buf[int(chaddr,16):],iter1) elif "yep" == chtype.lower(): yep.parse (page,buf[int(chaddr,16):],iter1) elif "yep0" == chtype.lower(): yep.parse (page,buf[int(chaddr,16):],iter1,0) elif "emf" == chtype.lower(): pt = page.type page.type = "EMF" mf.mf_open (buf[int(chaddr,16):],page,iter1) page.type = pt elif "pix" == chtype.lower(): # try: off = int(chaddr,16) ntype = model.get_value(iter1,1) if off: iter2 = add_pgiter(page,"Picture","escher","Blip",buf[off:],iter1) model.set_value(iter2,1,("escher","odraw","Blip")) else: model.set_value(iter1,1,("escher","odraw","Blip")) page.hd.hv.parent.on_row_activated(page.hd.hv,model.get_path(iter1),None) # except: # print "Failed to add as a picture" elif "dump" == chtype.lower(): dlg = gtk.FileChooserDialog('Save...', action=gtk.FILE_CHOOSER_ACTION_SAVE, buttons=(gtk.STOCK_OK,gtk.RESPONSE_OK,gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL)) dlg.set_local_only(True) resp = dlg.run() fname = dlg.get_filename() dlg.hide() if resp != gtk.RESPONSE_CANCEL: nlen = model.get_value(iter1,2) if chaddr != 0: pos = chaddr.find(":") if pos != -1: endaddr = chaddr[pos+1:] chaddr = chaddr[:pos] value = model.get_value(iter1,3)[int(chaddr,16):int(endaddr,16)] else: value = model.get_value(iter1,3)[int(chaddr,16):] else: value = model.get_value(iter1,3)[int(chaddr,16):] if nlen != None: f = open(fname,'wb') f.write(value) f.close() else: print("Nothing to save") elif "wmf" == chtype.lower() or "apwmf" == chtype.lower(): pt = page.type page.type = chtype.upper() mf.mf_open (buf[int(chaddr,16):],page,iter1) page.type = pt elif "xls" == chtype.lower(): ch2 = chaddr[1] if ch2.isdigit(): coladdr = ord(chaddr[0].lower()) - 97 rowaddr = int(chaddr[1:]) - 1 else: coladdr = 26*(ord(chaddr[0].lower()) - 96)+ ord(chaddr[1].lower()) - 97 rowaddr = int(chaddr[2:]) - 1 page.search = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_INT) model.foreach(xlsfind,(page,rowaddr,coladdr)) page.show_search("XLS: cell %s"%chaddr) elif "rx2" == chtype.lower(): newL = struct.unpack('>I', buf[int(chaddr,16)+4:int(chaddr,16)+8])[0] rx2.parse (model,buf[int(chaddr,16):int(chaddr,16)+newL],0,iter1) elif "dib" == chtype.lower(): iter2 = add_pgiter (page,"[BMP]","",0,dib2bmp(buf[int(chaddr,16):]),iter1) model.set_value(iter2,1,("escher","odraw","Blip")) elif "pct" == chtype.lower(): pict.parse (page,buf,iter1) elif "pm6" == chtype.lower(): off = int(chaddr,16) pm6.open (page,buf,iter1,off) elif "vba" == chtype.lower(): # off = int(chaddr,16) vba.parse (page,buf,iter1) elif "zip" == chtype.lower(): try: print(int(chaddr,16)) decobj = zlib.decompressobj() output = decobj.decompress(buf[int(chaddr,16):]) add_pgiter (page,"[Decompressed data]","",0,output,iter1) tail = decobj.unused_data if len(tail) > 0: add_pgiter (page,"[Tail]","",0,tail,iter1) except: print("Failed to decompress as zlib") try: f = StringIO.StringIO(buf[int(chaddr,16):]) pkzip.open(f, page, iter1) f.close() except: print("Failed to decompress as pkzip") elif cmd[0] == "?": ctype = cmd[1] carg = cmd[2:] # convert line to hex or unicode if required data = arg_conv(ctype,carg) model = page.view.get_model() page.search = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_INT) if ctype == 'r' or ctype == 'R': model.foreach(recfind,(page,data)) else: model.foreach(cmdfind,(page,data)) page.show_search(carg)
def __init__(self): component.Component.__init__(self, "FilterTreeView", interval=2) self.window = component.get("MainWindow") main_builder = self.window.get_builder() self.hpaned = main_builder.get_object("main_window_hpaned") self.scrolled = main_builder.get_object("scrolledwindow_sidebar") self.sidebar = component.get("SideBar") self.config = ConfigManager("gtkui.conf") self.tracker_icons = component.get("TrackerIcons") self.label_view = gtk.TreeView() self.sidebar.add_tab(self.label_view, "filters", "Filters") #set filter to all when hidden: self.sidebar.notebook.connect("hide", self._on_hide) #menu builder = gtk.Builder() builder.add_from_file( deluge.common.resource_filename( "deluge.ui.gtkui", os.path.join("glade", "filtertree_menu.ui"))) self.menu = builder.get_object("filtertree_menu") builder.connect_signals({ "select_all": self.on_select_all, "pause_all": self.on_pause_all, "resume_all": self.on_resume_all }) self.default_menu_items = self.menu.get_children() # Create the liststore #cat, value, label, count, pixmap, visible self.treestore = gtk.TreeStore(str, str, str, int, gtk.gdk.Pixbuf, bool) # Create the column column = gtk.TreeViewColumn("Filters") column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED) render = gtk.CellRendererPixbuf() self.renderpix = render column.pack_start(render, expand=False) column.add_attribute(render, 'pixbuf', 4) render = gtk.CellRendererText() column.pack_start(render, expand=False) column.set_cell_data_func(render, self.render_cell_data, None) self.label_view.append_column(column) #style: self.label_view.set_show_expanders(True) self.label_view.set_headers_visible(False) self.label_view.set_level_indentation(-35) # Force the theme to use an expander-size of 15 so that we don't cut out # entries due to our indentation hack. gtk.rc_parse_string( 'style "treeview-style" { GtkTreeView::expander-size = 15 } class "GtkTreeView" style "treeview-style"' ) self.label_view.set_model(self.treestore) self.label_view.get_selection().connect("changed", self.on_selection_changed) self.create_model_filter() #init..... self.label_view.connect("button-press-event", self.on_button_press_event) #colors using current theme. style = self.window.window.get_style() self.colour_background = style.bg[gtk.STATE_NORMAL] self.colour_foreground = style.fg[gtk.STATE_NORMAL]