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)
