def __init__(self): store = gtk.ListStore(int, str, gtk.gdk.Pixbuf) gtk.ComboBox.__init__(self, store) for key, value in common.get_statusdic().items(): store.insert(key, [key, value, utils.get_status_image(key)]) pb = gtk.CellRendererPixbuf() self.pack_start(pb, expand=False) self.add_attribute(pb, "pixbuf", 2) cell = gtk.CellRendererText() self.pack_start(cell, True) self.add_attribute(cell, "text", 1) self.set_active(0) self.show()
def __init__(self, adapter=None): cr = gtk.CellRendererText() cr.props.ellipsize = pango.ELLIPSIZE_END data = [ #device picture ["found_pb", 'GdkPixbuf', gtk.CellRendererPixbuf(), {"pixbuf": 0}, None, {"spacing": 0, "sizing": gtk.TREE_VIEW_COLUMN_AUTOSIZE}], ["device_pb", 'GdkPixbuf', gtk.CellRendererPixbuf(), {"pixbuf": 1}, None], #device caption ["caption", str, cr, {"markup": 2}, None, {"expand": True}], ["bonded_icon", 'GdkPixbuf', gtk.CellRendererPixbuf(), {"pixbuf": 3}, None], ["trusted_icon", 'GdkPixbuf', gtk.CellRendererPixbuf(), {"pixbuf": 4}, None] #["connected", bool], #used for quick access instead of device.GetProperties #["bonded", bool], #used for quick access instead of device.GetProperties #["trusted", bool], #used for quick access instead of device.GetProperties #["fake", bool], #used for quick access instead of device.GetProperties, #fake determines whether device is "discovered" or a real bluez device ] DeviceList.__init__(self, adapter, data) self.props.headers_visible = False
def setColumns(self): # JobID has icon+text cellpb = gtk.CellRendererPixbuf() tvcolumn = gtk.TreeViewColumn(" %s" % self.columnNames[0], cellpb) tvcolumn.set_cell_data_func(cellpb, self.setIcon) cell = gtk.CellRendererText() tvcolumn.pack_start(cell, False) tvcolumn.set_cell_data_func(cell, self.setJobID) self.treeView.append_column(tvcolumn) # text only for other parameters for attr in self.columnNames[1:]: cell = gtk.CellRendererText() tvcolumn = gtk.TreeViewColumn(" %s" % attr, cell) tvcolumn.set_cell_data_func(cell, self.setValue, attr) self.treeView.append_column(tvcolumn)
def __init__(self): model = gtk.ListStore(str, object, gtk.gdk.Pixbuf) # NAME_COL, APP_COL, ICON_COL gtk.ComboBox.__init__(self, model) cell = gtk.CellRendererPixbuf() self.pack_start(cell, False) cell.set_property('xpad', 5) self.add_attribute(cell, 'pixbuf', self.ICON_COL) cell = gtk.CellRendererText() self.pack_start(cell, True) cell.set_property('xalign', 0.0) cell.set_property('xpad', 5) self.add_attribute(cell, 'text', self.NAME_COL)
def create_column(column_name, column_id, sort_column=None, pixbuf=False): """Helper function for treeviews, this will return a column ready to be appended.""" if pixbuf: renderer_text = gtk.CellRendererPixbuf() column = gtk.TreeViewColumn(column_name) column.pack_start(renderer_text, expand=False) column.add_attribute(renderer_text, 'pixbuf', 0) else: renderer_text = gtk.CellRendererText() column = gtk.TreeViewColumn(column_name, renderer_text, text=column_id) if sort_column != None: column.set_sort_column_id(sort_column) else: column.set_sort_column_id(column_id) return column
def __init__(self, view, attrs, protocol=None): super(Affix, self).__init__() self.attrs = attrs self.protocol = protocol self.icon = attrs.get('icon') if protocol: self.renderer = CellRendererClickablePixbuf() self.renderer.connect('clicked', self.clicked) if not self.icon: self.icon = 'tryton-web-browser' elif self.icon: self.renderer = gtk.CellRendererPixbuf() else: self.renderer = gtk.CellRendererText() self.view = view
def __create_combo_change_mode(self): liststore = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_UINT) liststore.append(["audio-x-generic", "Playlists", MODE_PLAYLIST_VIEW]) #TRANSLATE liststore.append(["folder", "Folders", MODE_FOLDER_VIEW]) #TRANSLATE combobox = self.__getWidget("combo_change_mode") combobox.set_model(liststore) cell = gtk.CellRendererPixbuf() combobox.pack_start(cell, False) combobox.set_attributes(cell, icon_name=0) cell = gtk.CellRendererText() combobox.pack_start(cell, True) combobox.add_attribute(cell, 'text', 1) combobox.connect('changed', self.on_combo_change_mode_changed)
def create_columns(cfg, treeView, list_col, visible=None): i = -1 for col in list_col: i += 1 if (col == "pixbuf"): renderer = gtk.CellRendererPixbuf() column = gtk.TreeViewColumn("", renderer, pixbuf=i) column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED) column.set_fixed_width(28) else: renderer = gtk.CellRendererText() column = gtk.TreeViewColumn(col, renderer, text=i) column.set_expand(True) column.set_visible(True) treeView.append_column(column)
def setup_providers_treeview(self): column = gtk.TreeViewColumn('') cell = gtk.CellRendererPixbuf() column.pack_start(cell, False) column.add_attribute(cell, 'pixbuf', DirectoryProvidersModel.C_ICON) cell = gtk.CellRendererText() #cell.set_property('ellipsize', pango.ELLIPSIZE_END) column.pack_start(cell) column.add_attribute(cell, 'text', DirectoryProvidersModel.C_TEXT) column.add_attribute(cell, 'weight', DirectoryProvidersModel.C_WEIGHT) self.tv_providers.append_column(column) self.tv_providers.set_row_separator_func(self.providers_model.is_row_separator) self.tv_providers.set_model(self.providers_model)
def init(self, tags): self.ltags = tags def filename(column, cell, model, iter): cell.set_property('text', model.get_value(iter, 0)) cell.set_property('foreground', model.get_value(iter, 2)) cell.set_property('xalign', 0) # ~ cell.set_property('xpad', 1) def pixbuf(column, cell, model, iter): node = model.get_value(iter, 1) if node.__class__.__name__ == "TagNode": if model.get_value(iter, 3) == 0: cell.set_property('pixbuf', Buffer.pbCheckEmpty) elif model.get_value(iter, 3) == 1: cell.set_property('pixbuf', Buffer.pbCheckInclude) elif model.get_value(iter, 3) == 2: cell.set_property('pixbuf', Buffer.pbCheckExclude) else: cell.set_property('pixbuf', Buffer.pbCheckDisabled) else: cell.set_property('pixbuf', None) cell.set_property('width', 16) cell.set_property('xalign', 0) cellpb = gtk.CellRendererPixbuf() cell = gtk.CellRendererText() column = gtk.TreeViewColumn() column.pack_start(cellpb, False) column.pack_start(cell, True) column.set_cell_data_func(cellpb, pixbuf) column.set_cell_data_func(cell, filename) self.tvTags.append_column(column) treeselection = self.tvTags.get_selection() treeselection.set_mode(gtk.SELECTION_NONE) storeTags = TreeTags() self.tvTags.set_model(storeTags) self.tvTags.set_enable_search(False) self.tvTags.set_state(gtk.CAN_FOCUS) storeTags.expander(self.tvTags) storeTags.cleanSelections() storeTags.setSelected(self.ltags) tags = ", ".join(self.ltags) self.lblTags.set_label( "Tags to be added to the selected photos:\n %s" % tags)
def __init__(self, flickr): self.flickr = flickr self.model = gtk.ListStore(gobject.TYPE_BOOLEAN, gobject.TYPE_STRING, gobject.TYPE_STRING, gtk.gdk.Pixbuf) self.model.connect("row-changed", lambda model, path, iter: self.emit("changed")) gtk.TreeView.__init__(self, self.model) # Calculate the size of thumbnails based on the size of the text # renderer, but provide a default in case style-set isn't called. self.connect("style-set", self.style_set) self.thumb_size = 24 column = gtk.TreeViewColumn('Selected') self.append_column(column) renderer = gtk.CellRendererToggle() def toggled(r, path): self.model[path][COL_SELECTED] = not r.get_active() renderer.connect("toggled", toggled) column.pack_start(renderer, False) column.add_attribute(renderer, "active", COL_SELECTED) column = gtk.TreeViewColumn('Group') self.append_column(column) renderer = gtk.CellRendererPixbuf() column.pack_start(renderer, False) column.add_attribute(renderer, "pixbuf", COL_ICON) self.text_renderer = gtk.CellRendererText() column.pack_start(self.text_renderer, True) column.add_attribute(self.text_renderer, "text", COL_NAME) self.set_size_request( -1, 24 * 3 + self.style_get_property("vertical-separator") * 6) self.set_headers_visible(False) self.set_search_column(COL_NAME) def search_func(model, column, key, iter): s = model.get_value(iter, column) # This API is braindead, false=matches return key.lower() not in s.lower() self.set_search_equal_func(search_func)
def connect_with_groupchat_control(self, chat_control): chat_control.nb_ext_renderers += 1 chat_control.columns += [gtk.gdk.Pixbuf] self.groupchats_tree_is_transformed = True self.chat_control = chat_control col = gtk.TreeViewColumn() self.muc_renderer_num = 4 + chat_control.nb_ext_renderers client_icon_rend = ('client_icon', gtk.CellRendererPixbuf(), False, 'pixbuf', self.muc_renderer_num, self.tree_cell_data_func, chat_control) # remove old column chat_control.list_treeview.remove_column( chat_control.list_treeview.get_column(0)) # add new renderer in renderers list position_list = ['name', 'avatar'] position = position_list[self.config['pos_in_list']] for renderer in chat_control.renderers_list: if renderer[0] == position: break num = chat_control.renderers_list.index(renderer) chat_control.renderers_list.insert(num, client_icon_rend) # fill and append column chat_control.fill_column(col) chat_control.list_treeview.insert_column(col, 0) # redraw roster chat_control.model = gtk.TreeStore(*chat_control.columns) chat_control.model.set_sort_func(1, chat_control.tree_compare_iters) chat_control.model.set_sort_column_id(1, gtk.SORT_ASCENDING) chat_control.list_treeview.set_model(chat_control.model) # draw roster for nick in gajim.contacts.get_nick_list(chat_control.account, chat_control.room_jid): gc_contact = gajim.contacts.get_gc_contact(chat_control.account, chat_control.room_jid, nick) iter_ = chat_control.add_contact_to_roster(nick, gc_contact.show, gc_contact.role, gc_contact.affiliation, gc_contact.status, gc_contact.jid) if not self.config['show_in_groupchats']: continue caps = gc_contact.client_caps._node self.set_icon(chat_control.model, iter_, self.muc_renderer_num, caps, gc_contact) chat_control.draw_all_roles() # Recalculate column width for ellipsizin chat_control.list_treeview.columns_autosize()
def __init__(self, window, bookmarks_store): gtk.Dialog.__init__(self, _('Edit bookmarks'), window, gtk.DIALOG_MODAL, (gtk.STOCK_REMOVE, gtk.RESPONSE_NO, gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)) self._bookmarks_store = bookmarks_store self.set_has_separator(False) self.set_resizable(True) self.set_default_response(gtk.RESPONSE_CLOSE) scrolled = gtk.ScrolledWindow() self.set_border_width(4) scrolled.set_border_width(6) scrolled.set_shadow_type(gtk.SHADOW_IN) scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.vbox.pack_start(scrolled) self._liststore = gtk.ListStore(gtk.gdk.Pixbuf, gobject.TYPE_STRING, gobject.TYPE_STRING, _Bookmark) self._treeview = gtk.TreeView(self._liststore) self._treeview.set_rules_hint(True) self._treeview.set_reorderable(True) self._selection = self._treeview.get_selection() scrolled.add(self._treeview) cellrenderer_text = gtk.CellRendererText() cellrenderer_pbuf = gtk.CellRendererPixbuf() self._icon_col = gtk.TreeViewColumn(None, cellrenderer_pbuf) self._name_col = gtk.TreeViewColumn(_('Name'), cellrenderer_text) self._page_col = gtk.TreeViewColumn(_('Page'), cellrenderer_text) self._treeview.append_column(self._icon_col) self._treeview.append_column(self._name_col) self._treeview.append_column(self._page_col) self._icon_col.set_attributes(cellrenderer_pbuf, pixbuf=0) self._name_col.set_attributes(cellrenderer_text, text=1) self._page_col.set_attributes(cellrenderer_text, text=2) self._name_col.set_expand(True) self._icon_col.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE) self._name_col.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE) self._page_col.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE) self.resize(450, 450) self.connect('response', self._response) self.connect('delete_event', self._close) self._treeview.connect('key_press_event', self._key_press_event) for bookmark in self._bookmarks_store.get_bookmarks(): self._add_bookmark(bookmark) self.show_all()
def build_dep_list (self): store = gtk.ListStore(gtk.gdk.Pixbuf, str) self.depList.set_model(store) col = gtk.TreeViewColumn() cell = gtk.CellRendererPixbuf() col.pack_start(cell, False) col.add_attribute(cell, "pixbuf", 0) cell = gtk.CellRendererText() col.pack_start(cell, True) col.add_attribute(cell, "text", 1) self.depList.append_column(col)
def set_color_attribute(self, value): self._color_attribute = value if not value: return def cell_data_func(view, renderer, model, treeiter): category = model[treeiter][ComboColumn.DATA] renderer.set_property('pixbuf', render_pixbuf(category and category.color)) renderer = gtk.CellRendererPixbuf() self.pack_start(renderer, False) self.reorder(renderer, 0) self.set_cell_data_func(renderer, cell_data_func) self._text_renderer.set_padding(6, 0)
def __init__(self): """\ Constructor. """ super(ObjectTreeView, self).__init__() col = gtk.TreeViewColumn('Object Browser') pixbuf = gtk.CellRendererPixbuf() col.pack_start(pixbuf, expand=False) col.add_attribute(pixbuf, 'pixbuf', 0) cell = gtk.CellRendererText() col.pack_start(cell, expand=True) col.add_attribute(cell, 'text', 1) col.set_sort_column_id(1) self.append_column(col) self.set_search_column(1) self.set_reorderable(True)
def __init__ (self, readonly=False): gtk.TreeView.__init__ (self) self.readonly = readonly # The icon that indicates whether we're building or failed. renderer = gtk.CellRendererPixbuf () col = gtk.TreeViewColumn ("Status", renderer) col.add_attribute (renderer, "icon-name", 4) self.append_column (col) # The message of the build. self.message_renderer = gtk.CellRendererText () self.message_column = gtk.TreeViewColumn ("Message", self.message_renderer, text=3) self.message_column.add_attribute(self.message_renderer, 'background', 5) self.message_renderer.set_property('editable', (not self.readonly)) self.append_column (self.message_column)
def setup_column(self): self.cellrenderer = gtk.CellRendererPixbuf() tot_cols = self.tree.insert_column_with_data_func( self.col_position, self.col_title, self.cellrenderer, self.cell_data_func) if self.col_position == -1: self.col_position = tot_cols - 1 if self.editable: self.cellrenderer.set_property('mode', gtk.CELL_RENDERER_MODE_EDITABLE) self.cellrenderer.set_property('xalign', 0) col = self.tree.get_column(self.col_position) col.set_sort_column_id(self.data_col) for p, v in self.properties.items(): col.set_property(p, v) self.col = col
def __init__(self, model): gtk.TreeView.__init__(self, model) self.set_headers_visible(False) self.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_NONE) cpb = gtk.CellRendererPixbuf() cpb.set_property("width", 20) ##todo: don't hardcode the width tvc = gtk.TreeViewColumn(None, cpb, pixbuf=COLUMN_PIXBUF) self.append_column(tvc) cpt = gtk.CellRendererText() tvc = gtk.TreeViewColumn(None, cpt, text=COLUMN_NAME, weight=COLUMN_FONT_WGT, foreground_set=COLUMN_FONT_COLOR_SET, foreground=COLUMN_FONT_COLOR) self.append_column(tvc)
def init_view_columns(self): col = gtk.TreeViewColumn() col.set_max_width(48) col.set_title('Icons') render_pixbuf = gtk.CellRendererPixbuf() col.pack_start(render_pixbuf, expand=False) col.add_attribute(render_pixbuf, 'pixbuf', 0) self.append_column(col) col = gtk.TreeViewColumn() col.set_title('Stock Names') render_text = gtk.CellRendererText() col.pack_start(render_text, expand=False) col.add_attribute(render_text, 'text', 1) self.append_column(col) self.set_rules_hint(True)
def __init__(self, status_column=True): self.__gobject_init__() gtk.TreeView.__init__(self) self.set_rules_hint(True) # Add a fake liststore to the packages list, so that the headers # are already seen during start up fake_store = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_PYOBJECT) fake_store.set_sort_column_id(COLUMN_PACKAGE, gtk.SORT_ASCENDING) self.set_model(fake_store) self.theme = gtk.icon_theme_get_default() self.theme.append_search_path("/usr/share/gnome-packagekit/icons") if status_column: # check boxes renderer_status = gtk.CellRendererToggle() renderer_status.connect('toggled', self._on_toggled) renderer_status.set_property("xalign", 0.5) renderer_status.set_property("yalign", 0.5) column_status = gtk.TreeViewColumn("") column_status.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED) column_status.pack_start(renderer_status, False) column_status.set_cell_data_func(renderer_status, self._toggle_cell_func) # FIXME: we need to react on theme changes width = renderer_status.get_size(self)[2] + 8 column_status.set_fixed_width(width) self.append_column(column_status) # Application column (icon, name, description) column_pkg = gtk.TreeViewColumn(_("Package")) column_pkg.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED) column_pkg.set_expand(True) column_pkg.set_sort_column_id(COLUMN_ID) # The icon renderer_icon = gtk.CellRendererPixbuf() column_pkg.pack_start(renderer_icon, False) column_pkg.set_cell_data_func(renderer_icon, self._icon_cell_func) # package name and description renderer_desc = gtk.CellRendererText() renderer_desc.set_property("ellipsize", pango.ELLIPSIZE_END) column_pkg.pack_start(renderer_desc, True) column_pkg.set_cell_data_func(renderer_desc, self._package_view_func) self.append_column(column_pkg) self.set_fixed_height_mode(True)
def __build_interface(self): """ Builds the columns for the TreeView. The columns are: Icon, Database Name, Last Modified The Icon column gets its data from column 6 of the database model. It is expecting either None, or a GTK stock icon name The Database Name column is an editable column. We connect to the 'edited' signal, so that we can change the name when the user changes the column. The last accessed column simply displays the last time famtree was opened. """ # build the database name column render = gtk.CellRendererText() render.set_property('ellipsize', pango.ELLIPSIZE_END) render.connect('edited', self.__change_name) render.connect('editing-canceled', self.__stop_edit) render.connect('editing-started', self.__start_edit) self.column = gtk.TreeViewColumn(_('Family tree name'), render, text=NAME_COL) self.column.set_sort_column_id(NAME_COL) self.column.set_resizable(True) self.column.set_min_width(275) self.dblist.append_column(self.column) self.name_renderer = render # build the icon column render = gtk.CellRendererPixbuf() icon_column = gtk.TreeViewColumn(_('Status'), render, stock_id=STOCK_COL) self.dblist.append_column(icon_column) # build the last accessed column render = gtk.CellRendererText() column = gtk.TreeViewColumn(_('Last accessed'), render, text=DATE_COL) column.set_sort_column_id(DSORT_COL) self.dblist.append_column(column) # set the rules hit self.dblist.set_rules_hint(True)
def init_gui(self): #{{{ # Text box window self.entry_window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.entry_window.set_size_request(500, 120) self.entry_window.set_position(gtk.WIN_POS_CENTER_ALWAYS) vbox = gtk.VBox() vbox.set_homogeneous(False) vbox.set_spacing(0) self.info_label = gtk.Label() vbox.pack_start(self.info_label, False, False, 4) self.entry = gtk.Entry() vbox.pack_start(self.entry, False, False, 4) self.entry_window.add(vbox) # Search results popup self.popup = gtk.Window(gtk.WINDOW_POPUP) self.popup.set_transient_for(self.entry_window) self.popup.set_size_request(500, 200) self.popup.set_position(gtk.WIN_POS_CENTER_ON_PARENT) scrolled = gtk.ScrolledWindow() scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.treeview = gtk.TreeView(self.apps_model.get_model()) self.treeview.set_headers_visible(False) self.treeview.set_enable_search(False) self.treeview.set_hover_selection(True) self.treeview.set_can_focus(True) col = gtk.TreeViewColumn() self.treeview.append_column(col) cell = gtk.CellRendererPixbuf() col.pack_start(cell, False) col.add_attribute(cell, 'pixbuf', model.COLUMN_ICON) col = gtk.TreeViewColumn() self.treeview.append_column(col) cell = gtk.CellRendererText() col.pack_start(cell, False) col.add_attribute(cell, 'text', model.COLUMN_NAME) scrolled.add(self.treeview) self.popup.add(scrolled) self.entry_window.show_all()
def create_widgets(self): self.store = gtk.ListStore(gtk.gdk.Pixbuf, str, int) self.combo = gtk.ComboBox(self.store) self.icon = None pix = gtk.CellRendererPixbuf() txt = gtk.CellRendererText() txt.set_property('font', Prefs()['gui.views.property_tab.font'].value \ or 'Monospace 8') self.combo.pack_start(pix, False) self.combo.pack_start(txt) self.combo.set_attributes(pix, pixbuf=0) self.combo.set_attributes(txt, text=1) self.odict = backend.get_field_enumeration_i2s(self.field) self.odict.sort() idx = 0 set = False for value, key in self.odict: self.store.append([self.icon, key, value]) if not set: if self.value == value: set = True continue idx += 1 if set: self.combo.set_active(idx) self.store.append([self.icon, _("Set manually"), -1]) self.int_editor = IntEditor((self.protocol, self.field)) self.undo_btn = MiniButton(stock=gtk.STOCK_UNDO) self.undo_btn.set_size_request(24, 24) self.int_editor.pack_start(self.undo_btn, False, False) self.int_editor.show()
def __init__(self, app, presenter): gtk.VBox.__init__(self, False, 0) self.mw = app.mw self.app = app self.presenter = presenter model_cid = self.presenter.doc_presenter.cid model_name = uc2const.FORMAT_EXTENSION[model_cid][0].upper() spacer = gtk.VBox() self.add(spacer) self.set_border_width(0) self.listmodel = ObjectTreeModel(self.presenter.doc_presenter.model) self.treeview = gtk.TreeView() self.column = gtk.TreeViewColumn() self.column.set_title(model_name + ' ' + _('File Format Model')) render_pixbuf = gtk.CellRendererPixbuf() self.column.pack_start(render_pixbuf, expand=False) self.column.add_attribute(render_pixbuf, 'pixbuf', 0) render_text = gtk.CellRendererText() self.column.pack_start(render_text, expand=True) self.column.add_attribute(render_text, 'text', 1) self.treeview.append_column(self.column) self.column1 = gtk.TreeViewColumn() render_text = gtk.CellRendererText() self.column1.pack_start(render_text, expand=False) self.column1.add_attribute(render_text, 'text', 2) self.column1.add_attribute(render_text, 'foreground', 3) self.treeview.append_column(self.column1) self.treeview.connect('cursor-changed', self.view_object) self.scrolledwindow = gtk.ScrolledWindow() self.scrolledwindow.add(self.treeview) self.scrolledwindow.set_shadow_type(gtk.SHADOW_ETCHED_IN) self.scrolledwindow.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) spacer.pack_end(self.scrolledwindow, True) self.treeview.set_model(self.listmodel) self.treeview.set_rules_hint(True) self.treeview.set_enable_tree_lines(True) eventloop = self.presenter.eventloop eventloop.connect(eventloop.SELECTION_CHANGED, self.reflect_selection) self.update_view()
def __init__(self): super(TargetTree, self).__init__(False, 2) sw = gtk.ScrolledWindow() sw.set_shadow_type(gtk.SHADOW_ETCHED_IN) sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) self.store = gtk.ListStore(str) self.view = gtk.TreeView(self.store) self.view.set_rules_hint(True) self.view.enable_model_drag_dest([('text/plain', 0, 0)], gtk.gdk.ACTION_DEFAULT | \ gtk.gdk.ACTION_COPY) self.view.connect("drag_data_received",self.__on_drag_data_recv) self.view.connect('button-press-event', self.__on_popup_menu) self.view.get_selection().set_mode(gtk.SELECTION_MULTIPLE) pixrenderer = gtk.CellRendererPixbuf() txtrenderer = gtk.CellRendererText() txtrenderer.set_property('editable', True) txtrenderer.connect('edited', self.__on_ip_edited) column = gtk.TreeViewColumn('Target') column.pack_start(pixrenderer, False) column.pack_end(txtrenderer) column.set_attributes(txtrenderer, text=0) column.set_cell_data_func(pixrenderer, self.__set_ip_icon) self.view.append_column(column) bbox = gtk.HButtonBox() bbox.set_layout(gtk.BUTTONBOX_END) btn = gtk.Button(stock=gtk.STOCK_ADD) btn.connect('clicked', self.__on_add_target) bbox.pack_start(btn) btn = gtk.Button(stock=gtk.STOCK_REMOVE) btn.connect('clicked', self.__on_remove_selection) bbox.pack_start(btn) sw.add(self.view) self.pack_start(sw) self.pack_start(bbox, False, False)
def __init__(self): gtk.TreeView.__init__(self) self.set_headers_visible(False) self.set_show_expanders(False) # fact (None for parent), duration, parent data (if any) self.store_model = gtk.ListStore(gobject.TYPE_PYOBJECT) self.set_model(self.store_model) fact_cell = FactCellRenderer() fact_column = gtk.TreeViewColumn("", fact_cell, data=0) fact_column.set_cell_data_func(fact_cell, parent_painter) fact_column.set_expand(True) self.append_column(fact_column) edit_cell = gtk.CellRendererPixbuf() edit_cell.set_property("ypad", 2) edit_cell.set_property("mode", gtk.CELL_RENDERER_MODE_ACTIVATABLE) self.edit_column = gtk.TreeViewColumn("", edit_cell) self.edit_column.set_cell_data_func(edit_cell, action_painter) self.append_column(self.edit_column) self.connect("row-activated", self._on_row_activated) self.connect("button-release-event", self._on_button_release_event) self.connect("key-release-event", self._on_key_released) self.connect("configure-event", lambda *args: self.fix_row_heights()) self.connect("motion-notify-event", self._on_motion) self.show() self.longest_activity_category = 0 # we will need this for the cell renderer self.longest_interval = 0 # we will need this for the cell renderer self.longest_duration = 0 # we will need this for the cell renderer self.stored_selection = [] self.box = None pixmap = gtk.gdk.Pixmap(None, 10, 10, 1) _test_context = pixmap.cairo_create() self._test_layout = _test_context.create_layout() font = pango.FontDescription(gtk.Style().font_desc.to_string()) self._test_layout.set_font_description(font) self.prev_rows = [] self.new_rows = [] self.connect("destroy", self.on_destroy)
def __add_columns__(self): ''' Создание столбца ''' model = self.get_model() column = gtk.TreeViewColumn() column.set_title('Application') renderer = gtk.CellRendererPixbuf() column.pack_start(renderer, False) column.set_attributes(renderer, pixbuf=0) #column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED) #column.expand = True renderer = gtk.CellRendererText() column.pack_start(renderer, True) column.set_attributes(renderer, text=1) self.append_column(column)
def __init__(self, text, controls, filename, all_icons=temp_list): gtk.HBox.__init__(self, False, 0) self.controls = controls self.combobox = gtk.ComboBox() self.entry = gtk.Entry() self.entry.set_size_request(300, -1) if filename: self.entry.set_text(filename) else: filename = "" self.all_icons = all_icons self.modconst = ModelConstructor(all_icons) self.combobox.set_model(self.modconst.model) if filename in self.all_icons: self.combobox.set_active(self.all_icons.index(filename)) else: self.combobox.set_active(0) self.on_change_icon() logging.warning("Icon " + filename + " is absent in list of icons") pix_render = gtk.CellRendererPixbuf() self.combobox.pack_start(pix_render) self.combobox.add_attribute(pix_render, 'pixbuf', 0) button = gtk.Button("Choose", gtk.STOCK_OPEN) button.connect("clicked", self.on_file_choose) button_2 = gtk.Button("Delete", gtk.STOCK_DELETE) button_2.connect("clicked", self.on_delete) label = gtk.Label(text) label.set_size_request(80, -1) self.pack_start(label, False, False) self.pack_start(self.combobox, False, False) self.pack_start(self.entry, True, True) self.pack_start(button, False, False) self.pack_start(button_2, False, False) self.combobox.connect("changed", self.on_change_icon)
def __init__(self, controller, data): '''Constructor''' self.liststore = gtk.ListStore(str, str, bool, str, str) self.controller = controller self.data = data gtk.TreeView.__init__(self, self.liststore) # Cells cell0 = gtk.CellRendererPixbuf() cell1 = gtk.CellRendererText() cell2 = gtk.CellRendererToggle() cell3 = gtk.CellRendererText() cell4 = gtk.CellRendererText() cell1.set_property('editable', True) cell1.connect('edited', self.onEdited, self.liststore, 1) cell2.set_property('activatable', True) cell2.connect('toggled', self.onToggled, self.liststore, 2) cell3.set_property('editable', True) cell3.connect('edited', self.onEdited, self.liststore, 3) cell4.set_property('editable', True) cell4.connect('edited', self.onEdited, self.liststore, 4) # Columns col0 = gtk.TreeViewColumn(_('Status'), cell0) col0.set_cell_data_func(cell0, self.getStatusCellPixbuf) col1 = gtk.TreeViewColumn(_('Status Name'), cell1, text=1) col2 = gtk.TreeViewColumn(_('A.R.'), cell2, active=2) col3 = gtk.TreeViewColumn(_('Autoreply message'), cell3, text=3) col4 = gtk.TreeViewColumn(_('Command'), cell4, text=4) col1.set_resizable(True) col3.set_resizable(True) col4.set_resizable(True) self.append_column(col0) self.append_column(col1) self.append_column(col2) self.append_column(col3) self.append_column(col4) # We add the data to the table for item in self.data: self.liststore.append(item)