def __init__(self, o=None):
self.xml = x = gtk.glade.XML(sibpath(__file__, "inspectro.glade"))
self.tree_view = x.get_widget("treeview")
colnames = ["Name", "Value"]
for i in range(len(colnames)):
self.tree_view.append_column(
gtk.TreeViewColumn(
colnames[i], gtk.CellRendererText(), text=i))
d = {}
for m in reflect.prefixedMethods(self, "on_"):
d[m.im_func.__name__] = m
self.xml.signal_autoconnect(d)
if o is not None:
self.inspect(o)
self.ns = {'inspect': self.inspect}
iwidget = x.get_widget('input')
self.input = ConsoleInput(iwidget)
self.input.toplevel = self
iwidget.connect("key_press_event", self.input._on_key_press_event)
self.output = ConsoleOutput(x.get_widget('output'))
python类TreeViewColumn()的实例源码
def __init__(self):
super(ShowLastPackets.PacketList, self).__init__()
self.set_properties(hscrollbar_policy=gtk.POLICY_AUTOMATIC,
vscrollbar_policy=gtk.POLICY_AUTOMATIC)
self.table_model = gtk.ListStore(*([str]*4))
treeview = gtk.TreeView(self.table_model)
treeview.show()
self.add(treeview)
def add_column(descr, colid):
column = gtk.TreeViewColumn(descr, gtk.CellRendererText(), text=colid)
treeview.append_column(column)
add_column("Time", self.COLUMN_TIME)
add_column("Interface", self.COLUMN_INTERFACE)
add_column("Size", self.COLUMN_SIZE)
add_column("Contents", self.COLUMN_CONTENTS)
def create_list_view(col_label,):
# create list widget
list_ = gtk.ListStore(str)
list_view = gtk.TreeView(model=list_)
list_view.set_rules_hint(True)
list_view.get_selection().set_mode(gtk.SELECTION_SINGLE)
# Add Colums
renderer = gtk.CellRendererText()
renderer.set_data("column", COLUMN_SUGGESTION)
column = gtk.TreeViewColumn(col_label, renderer,text=COLUMN_SUGGESTION)
list_view.append_column(column)
return list_view
def __init__(self, index, ui):
self.index = index
self.ui = ui
self.current_tag = None
self.model = gtk.ListStore(str, int, str) # PAGE_COL, TAGS_COL
SingleClickTreeView.__init__(self, self.model)
cells = (('Page', self.PAGE_COL, True),
('N', self.TAGS_N_COL, False),
('Tags', self.TAGS_COL, True))
for name, col_id, expand in (cells):
cell = gtk.CellRendererText()
cell.set_property('ellipsize', pango.ELLIPSIZE_END)
cell.set_property('cell-background', 'white')
col = gtk.TreeViewColumn(name, cell)
col.set_attributes(cell, text = col_id)
col.set_resizable(expand)
col.set_expand(expand)
col.set_sort_column_id(col_id)
self.append_column(col)
self.connect('row-activated', lambda treeview, path, column:
self.row_activated(path, column))
self.refill_model()
def __init__(self, index, ui):
self.tagview = TagsView.new_from_index(index)
self.ui = ui
self.current_tag = None
self.model = gtk.ListStore(str, int, str) # PAGE_COL, TAGS_COL
SingleClickTreeView.__init__(self, self.model)
cells = (('Page', self.PAGE_COL, True),
('N', self.TAGS_N_COL, False),
('Tags', self.TAGS_COL, True))
for name, col_id, expand in cells:
cell = gtk.CellRendererText()
cell.set_property('ellipsize', pango.ELLIPSIZE_END)
cell.set_property('cell-background', 'white')
col = gtk.TreeViewColumn(name, cell)
col.set_attributes(cell, text = col_id)
col.set_resizable(expand)
col.set_expand(expand)
col.set_sort_column_id(col_id)
self.append_column(col)
self.connect('row-activated', lambda treeview, path, column:
self.row_activated(path, column))
self.refill_model()
def __init__(self, o=None):
self.xml = x = gtk.glade.XML(sibpath(__file__, "inspectro.glade"))
self.tree_view = x.get_widget("treeview")
colnames = ["Name", "Value"]
for i in range(len(colnames)):
self.tree_view.append_column(
gtk.TreeViewColumn(
colnames[i], gtk.CellRendererText(), text=i))
d = {}
for m in reflect.prefixedMethods(self, "on_"):
d[m.im_func.__name__] = m
self.xml.signal_autoconnect(d)
if o is not None:
self.inspect(o)
self.ns = {'inspect': self.inspect}
iwidget = x.get_widget('input')
self.input = ConsoleInput(iwidget)
self.input.toplevel = self
iwidget.connect("key_press_event", self.input._on_key_press_event)
self.output = ConsoleOutput(x.get_widget('output'))
def load_page(self):
self.frontend.builder.connect_signals({"on_btn_unmount_clicked" : self.on_btn_unmount_clicked})
self.trv_mounted = self.frontend.builder.get_object("trv_mounted")
self.trv_mounted_model = gtk.ListStore(str, str)
self.trv_mounted.set_model(self.trv_mounted_model)
column_0 = gtk.TreeViewColumn('Device')
cell_renderer_0 = gtk.CellRendererText()
column_0.pack_start(cell_renderer_0, True)
column_0.add_attribute(cell_renderer_0, 'text', 0)
self.trv_mounted.append_column(column_0)
column_1 = gtk.TreeViewColumn('Mountpoint')
cell_renderer_1 = gtk.CellRendererText()
column_1.pack_start(cell_renderer_1, True)
column_1.add_attribute(cell_renderer_1, 'text', 1)
self.trv_mounted.append_column(column_1)
self.trv_mounted_tree_selection = self.trv_mounted.get_selection()
def load_page(self):
self.trv_drives = self.frontend.builder.get_object("trv_drives")
self.frontend.builder.connect_signals({"on_trv_drives_cursor_changed" : self.on_trv_drives_cursor_changed})
self.trv_drives_model = gtk.ListStore(str, str)
self.trv_drives.set_model(self.trv_drives_model)
column_0 = gtk.TreeViewColumn('Device')
cell_renderer_0 = gtk.CellRendererText()
column_0.pack_start(cell_renderer_0, True)
column_0.add_attribute(cell_renderer_0, 'text', 0)
self.trv_drives.append_column(column_0)
column_1 = gtk.TreeViewColumn('Size (GB)')
cell_renderer_1 = gtk.CellRendererText()
column_1.pack_start(cell_renderer_1, True)
column_1.add_attribute(cell_renderer_1, 'text', 1)
self.trv_drives.append_column(column_1)
self.trv_drives_tree_selection = self.trv_drives.get_selection()
def loans_treeview(self):
self.loans_treemodel = gtk.TreeStore(str, str, str) # move to self.widgets
self.widgets['movie']['loan_history'].set_model(self.loans_treemodel)
self.widgets['movie']['loan_history'].set_headers_visible(True)
# loan date
renderer = gtk.CellRendererText()
self.date_column = gtk.TreeViewColumn(_('Loan Date'), renderer, text=0)
self.date_column.set_resizable(True)
self.widgets['movie']['loan_history'].append_column(self.date_column)
self.date_column.set_sort_column_id(0)
# return date
renderer = gtk.CellRendererText()
self.return_column = gtk.TreeViewColumn(_('Return Date'), renderer, text=1)
self.return_column.set_resizable(True)
self.widgets['movie']['loan_history'].append_column(self.return_column)
# loan to
renderer = gtk.CellRendererText()
self.loaner_column = gtk.TreeViewColumn(_('Loaned To'), renderer, text=2)
self.loaner_column.set_resizable(True)
self.widgets['movie']['loan_history'].append_column(self.loaner_column)
def show(self, articles):
treestore = gtk.TreeStore(str, str, str, int)
for article in articles:
entry = [article['title'], article['link'], article['id'], 700]
treestore.append(None, entry)
treeview = gtk.TreeView(treestore)
tvcolumn = gtk.TreeViewColumn('Articles: {}'.format(len(articles)))
treeview.append_column(tvcolumn)
cell = gtk.CellRendererText()
tvcolumn.pack_start(cell, True)
tvcolumn.add_attribute(cell, 'text', 0)
tvcolumn.add_attribute(cell, 'weight', 3)
self.window.add(treeview)
self.window.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
treeview.connect("row-activated", self.open_article, treestore)
treeview.connect("cursor-changed", self.skip_article, treestore)
self.window.show_all()
gnome_connection_manager.py 文件源码
项目:gnome-connection-manager
作者: mjun
项目源码
文件源码
阅读 23
收藏 0
点赞 0
评论 0
def __init__(self, path="gnome-connection-manager.glade",
root="wHost",
domain=domain_name, **kwargs):
path = os.path.join(glade_dir, path)
SimpleGladeApp.__init__(self, path, root, domain, **kwargs)
self.treeModel = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING)
self.treeTunel.set_model(self.treeModel)
column = gtk.TreeViewColumn(_("Local"), gtk.CellRendererText(), text=0)
self.treeTunel.append_column( column )
column = gtk.TreeViewColumn(_("Host"), gtk.CellRendererText(), text=1)
self.treeTunel.append_column( column )
column = gtk.TreeViewColumn(_("Remoto"), gtk.CellRendererText(), text=2)
self.treeTunel.append_column( column )
#-- Whost.new {
def __init__(self, fontfile):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title("%s - pyftinspect" % fontfile)
self.window.connect("delete_event", self._delete_event)
self.window.set_size_request(400, 600)
self.scrolled_window = gtk.ScrolledWindow()
self.window.add(self.scrolled_window)
self.font = ttLib.TTFont(fontfile, lazy=True)
self.treemodel = FontTreeModel(self.font)
self.treeview = gtk.TreeView(self.treemodel)
#self.treeview.set_reorderable(True)
for i in range(2):
col_name = ('Key', 'Value')[i]
col = gtk.TreeViewColumn(col_name)
col.set_sort_column_id(-1)
self.treeview.append_column(col)
cell = gtk.CellRendererText()
col.pack_start(cell, True)
col.add_attribute(cell, 'text', i)
self.treeview.set_search_column(1)
self.scrolled_window.add(self.treeview)
self.window.show_all()
def __init__(self, p):
self.p = p
vals = [time.time()]
if p.inLog:
vals.append(p.inLog[0][0])
if p.outLog:
vals.append(p.outLog[0][0])
self.startTime = min(vals)
p.logViewer = self
self.xml = x = gtk.glade.XML(sibpath(__file__, "logview.glade"))
self.xml.signal_autoconnect(self)
self.loglist = self.xml.get_widget("loglist")
# setup model, connect it to my treeview
self.model = gtk.ListStore(str, str, str)
self.loglist.set_model(self.model)
self.loglist.set_reorderable(1)
self.loglist.set_headers_clickable(1)
# self.servers.set_headers_draggable(1)
# add a column
for col in [
gtk.TreeViewColumn('Time',
gtk.CellRendererText(),
text=0),
gtk.TreeViewColumn('D',
gtk.CellRendererText(),
text=1),
gtk.TreeViewColumn('Data',
gtk.CellRendererText(),
text=2)]:
self.loglist.append_column(col)
col.set_resizable(1)
r = []
for t, data in p.inLog:
r.append(((str(t - self.startTime), "R", repr(data)[1:-1])))
for t, data in p.outLog:
r.append(((str(t - self.startTime), "S", repr(data)[1:-1])))
r.sort()
for i in r:
self.model.append(i)
def __init__(self):
self.xml = gtk.glade.XML(util.sibpath(__file__,"gladereactor.glade"))
d = {}
for m in reflect.prefixedMethods(self, "on_"):
d[m.im_func.__name__] = m
self.xml.signal_autoconnect(d)
self.xml.get_widget('window1').connect('destroy',
lambda w: self.stop())
self.servers = self.xml.get_widget("servertree")
sel = self.servers.get_selection()
sel.set_mode(gtk.SELECTION_SINGLE)
sel.connect("changed",
self.servers_selection_changed)
## argh coredump: self.servers_selection_changed(sel)
self.xml.get_widget('suspend').set_sensitive(0)
self.xml.get_widget('disconnect').set_sensitive(0)
# setup model, connect it to my treeview
self.model = gtk.ListStore(str, object, gobject.TYPE_BOOLEAN,
gobject.TYPE_BOOLEAN)
self.servers.set_model(self.model)
self.servers.set_reorderable(1)
self.servers.set_headers_clickable(1)
# self.servers.set_headers_draggable(1)
# add a column
for col in [
gtk.TreeViewColumn('Server',
gtk.CellRendererText(),
text=0),
gtk.TreeViewColumn('Reading',
gtk.CellRendererToggle(),
active=2),
gtk.TreeViewColumn('Writing',
gtk.CellRendererToggle(),
active=3)]:
self.servers.append_column(col)
col.set_resizable(1)
sup.__init__(self)
def __init__(self, visualizer, node_index, statistics_collector):
InformationWindow.__init__(self)
self.win = gtk.Dialog(parent=visualizer.window,
flags=gtk.DIALOG_DESTROY_WITH_PARENT|gtk.DIALOG_NO_SEPARATOR,
buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE))
self.win.connect("response", self._response_cb)
self.win.set_title("Statistics for node %i" % node_index)
self.visualizer = visualizer
self.statistics_collector = statistics_collector
self.node_index = node_index
self.viz_node = visualizer.get_node(node_index)
self.table_model = gtk.ListStore(*([str]*13))
treeview = gtk.TreeView(self.table_model)
treeview.show()
self.win.vbox.add(treeview)
def add_column(descr, colid):
column = gtk.TreeViewColumn(descr, gtk.CellRendererText(), text=colid)
treeview.append_column(column)
add_column("Interface", self.COLUMN_INTERFACE)
add_column("Tx Packets", self.COLUMN_TX_PACKETS)
add_column("Tx Bytes", self.COLUMN_TX_BYTES)
add_column("Tx pkt/1s", self.COLUMN_TX_PACKET_RATE)
add_column("Tx bit/1s", self.COLUMN_TX_BIT_RATE)
add_column("Rx Packets", self.COLUMN_RX_PACKETS)
add_column("Rx Bytes", self.COLUMN_RX_BYTES)
add_column("Rx pkt/1s", self.COLUMN_RX_PACKET_RATE)
add_column("Rx bit/1s", self.COLUMN_RX_BIT_RATE)
self.visualizer.add_information_window(self)
self.win.show()
def __init__(self, index, preferences):
self.index = index
# Icons corresponding to tags, prevent unnecessary changing.
self.icons_for_tags = preferences.copy()
self.model = gtk.ListStore(str, gtk.gdk.Pixbuf, str, int) # TAG_COL, ICON_COL, ICON_NAME, N_PAGES_COL
SingleClickTreeView.__init__(self, self.model)
cells = (('Tags', self.TAG_COL, True),
('Pages', self.N_PAGES_COL, False))
for name, col_id, expand in (cells):
cell = gtk.CellRendererText()
cell.set_property('ellipsize', pango.ELLIPSIZE_END)
cell.set_property('cell-background', 'white')
col = gtk.TreeViewColumn(name, cell)
col.set_attributes(cell, text = col_id)
col.set_resizable(expand)
col.set_expand(expand)
col.set_sort_column_id(col_id)
self.append_column(col)
cell = gtk.CellRendererPixbuf()
cell.set_property('cell-background', 'white')
col = gtk.TreeViewColumn('Icon', cell)
col.set_attributes(cell, pixbuf = self.ICON_COL)
col.set_resizable(False)
col.set_expand(False)
col.set_sort_column_id(self.ICON_NAME)
self.append_column(col)
self.refill_model()
def __init__(self, index, preferences):
self.index = index
# Icons corresponding to tags, prevent unnecessary changing.
self.icons_for_tags = preferences.copy()
self.model = gtk.ListStore(str, gtk.gdk.Pixbuf, str, int) # TAG_COL, ICON_COL, ICON_NAME, N_PAGES_COL
SingleClickTreeView.__init__(self, self.model)
cells = (('Tags', self.TAG_COL, True),
('Pages', self.N_PAGES_COL, False))
for name, col_id, expand in cells:
cell = gtk.CellRendererText()
cell.set_property('ellipsize', pango.ELLIPSIZE_END)
cell.set_property('cell-background', 'white')
col = gtk.TreeViewColumn(name, cell)
col.set_attributes(cell, text = col_id)
col.set_resizable(expand)
col.set_expand(expand)
col.set_sort_column_id(col_id)
self.append_column(col)
cell = gtk.CellRendererPixbuf()
cell.set_property('cell-background', 'white')
col = gtk.TreeViewColumn('Icon', cell)
col.set_attributes(cell, pixbuf = self.ICON_COL)
col.set_resizable(False)
col.set_expand(False)
col.set_sort_column_id(self.ICON_NAME)
self.append_column(col)
self.refill_model()
def __init__(self, p):
self.p = p
vals = [time.time()]
if p.inLog:
vals.append(p.inLog[0][0])
if p.outLog:
vals.append(p.outLog[0][0])
self.startTime = min(vals)
p.logViewer = self
self.xml = x = gtk.glade.XML(sibpath(__file__, "logview.glade"))
self.xml.signal_autoconnect(self)
self.loglist = self.xml.get_widget("loglist")
# setup model, connect it to my treeview
self.model = gtk.ListStore(str, str, str)
self.loglist.set_model(self.model)
self.loglist.set_reorderable(1)
self.loglist.set_headers_clickable(1)
# self.servers.set_headers_draggable(1)
# add a column
for col in [
gtk.TreeViewColumn('Time',
gtk.CellRendererText(),
text=0),
gtk.TreeViewColumn('D',
gtk.CellRendererText(),
text=1),
gtk.TreeViewColumn('Data',
gtk.CellRendererText(),
text=2)]:
self.loglist.append_column(col)
col.set_resizable(1)
r = []
for t, data in p.inLog:
r.append(((str(t - self.startTime), "R", repr(data)[1:-1])))
for t, data in p.outLog:
r.append(((str(t - self.startTime), "S", repr(data)[1:-1])))
r.sort()
for i in r:
self.model.append(i)
def __init__(self):
self.xml = gtk.glade.XML(util.sibpath(__file__,"gladereactor.glade"))
d = {}
for m in reflect.prefixedMethods(self, "on_"):
d[m.im_func.__name__] = m
self.xml.signal_autoconnect(d)
self.xml.get_widget('window1').connect('destroy',
lambda w: self.stop())
self.servers = self.xml.get_widget("servertree")
sel = self.servers.get_selection()
sel.set_mode(gtk.SELECTION_SINGLE)
sel.connect("changed",
self.servers_selection_changed)
## argh coredump: self.servers_selection_changed(sel)
self.xml.get_widget('suspend').set_sensitive(0)
self.xml.get_widget('disconnect').set_sensitive(0)
# setup model, connect it to my treeview
self.model = gtk.ListStore(str, object, gobject.TYPE_BOOLEAN,
gobject.TYPE_BOOLEAN)
self.servers.set_model(self.model)
self.servers.set_reorderable(1)
self.servers.set_headers_clickable(1)
# self.servers.set_headers_draggable(1)
# add a column
for col in [
gtk.TreeViewColumn('Server',
gtk.CellRendererText(),
text=0),
gtk.TreeViewColumn('Reading',
gtk.CellRendererToggle(),
active=2),
gtk.TreeViewColumn('Writing',
gtk.CellRendererToggle(),
active=3)]:
self.servers.append_column(col)
col.set_resizable(1)
sup.__init__(self)
def people_treeview(self, create=True):
row = None
self.p_treemodel = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING)
self.widgets['preferences']['treeview'].set_model(self.p_treemodel)
self.widgets['preferences']['treeview'].set_headers_visible(True)
if create is True:
# name column
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(_('Name'), renderer, text=0)
column.set_resizable(True)
column.set_sort_column_id(0)
self.widgets['preferences']['treeview'].append_column(column)
# email column
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(_('E-mail'), renderer, text=1)
column.set_resizable(True)
column.set_sort_column_id(1)
self.widgets['preferences']['treeview'].append_column(column)
# add data to treeview
self.p_treemodel.clear()
for i in self.db.session.query(db.Person.name, db.Person.email).order_by(db.Person.name.asc()):
myiter = self.p_treemodel.insert_before(None, None)
self.p_treemodel.set_value(myiter, 0, i.name)
self.p_treemodel.set_value(myiter, 1, i.email)
self.widgets['preferences']['treeview'].show()
def web_results(self):
self.treemodel_results = gtk.TreeStore(str, str)
self.widgets['results']['treeview'].set_model(self.treemodel_results)
self.widgets['results']['treeview'].set_headers_visible(False)
# column ids
renderer = gtk.CellRendererText()
column1 = gtk.TreeViewColumn(None, renderer, text=0)
column1.set_visible(False)
self.widgets['results']['treeview'].append_column(column1)
# column titles
renderer = gtk.CellRendererText()
column2 = gtk.TreeViewColumn(None, renderer, text=1)
column2.set_resizable(True)
column2.set_sort_column_id(1)
self.widgets['results']['treeview'].append_column(column2)
def create_treelist(self):
"""create_treelist
Create list of options
"""
# Add some messages to the window
self.liststore = gtk.ListStore(str,str,'gboolean')
# we'll add some data now
self.liststore.append(['Kernel', gtk.STOCK_OPEN, True])
self.liststore.append(['CPU', gtk.STOCK_OPEN, True])
self.liststore.append(['RAM', gtk.STOCK_OPEN, True])
self.liststore.append(['Sound Modules', gtk.STOCK_OPEN, True])
self.liststore.append(['Sound Devices', gtk.STOCK_OPEN, True])
self.liststore.append(['Asound', gtk.STOCK_OPEN, True])
# create the TreeViewColumn to display the data
self.tvcolumn = gtk.TreeViewColumn('Categories')
# Append liststore model to treeview
self.treeview1.set_model(model=self.liststore)
# add tvcolumn to treeview
self.treeview1.append_column(self.tvcolumn)
# create a CellRendererText to render the data
self.cell = gtk.CellRendererText()
self.cell0 = gtk.CellRendererPixbuf()
# add the cell to the tvcolumn and allow it to expand
self.tvcolumn.pack_start(self.cell0, True)
self.tvcolumn.pack_start(self.cell, True)
# set the cell "text" attribute to column 0 - retrieve text
# from that column in treestore
self.tvcolumn.set_cell_data_func(self.cell0, self.make_pixbuf)
self.tvcolumn.add_attribute(self.cell, 'text', 0)
return
gnome_connection_manager.py 文件源码
项目:gnome-connection-manager
作者: mjun
项目源码
文件源码
阅读 18
收藏 0
点赞 0
评论 0
def initLeftPane(self):
global groups
self.treeModel = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_PYOBJECT, gtk.gdk.Pixbuf)
self.treeServers.set_model(self.treeModel)
self.treeServers.set_level_indentation(5)
#Force the alternating row colors, by default it's off with one column
self.treeServers.set_property('rules-hint', True)
gtk.rc_parse_string( """
style "custom-treestyle"{
GtkTreeView::allow-rules = 1
}
widget "*treeServers*" style "custom-treestyle"
""")
column = gtk.TreeViewColumn()
column.set_title('Servers')
self.treeServers.append_column( column )
renderer = gtk.CellRendererPixbuf()
column.pack_start(renderer, expand=False)
column.add_attribute(renderer, 'pixbuf', 2)
renderer = gtk.CellRendererText()
column.pack_start(renderer, expand=True)
column.add_attribute(renderer, 'text', 0)
self.treeServers.set_has_tooltip(True)
self.treeServers.connect('query-tooltip', self.on_treeServers_tooltip)
self.loadConfig()
self.updateTree()
gnome_connection_manager.py 文件源码
项目:gnome-connection-manager
作者: mjun
项目源码
文件源码
阅读 18
收藏 0
点赞 0
评论 0
def new(self):
self.treeHosts = self.get_widget('treeHosts')
self.treeStore = gtk.TreeStore( gobject.TYPE_BOOLEAN, gobject.TYPE_STRING, gobject.TYPE_OBJECT )
for x in self.terms:
self.treeStore.append( None, (False, x[0], x[1]) )
self.treeHosts.set_model( self.treeStore )
crt = gtk.CellRendererToggle()
crt.set_property('activatable', True)
crt.connect('toggled', self.on_active_toggled)
col = gtk.TreeViewColumn(_("Activar"), crt, active=0)
self.treeHosts.append_column( col )
self.treeHosts.append_column(gtk.TreeViewColumn(_("Host"), gtk.CellRendererText(), text=1 ))
self.get_widget("txtCommands").history = []
#-- Wcluster.new }
#-- Wcluster custom methods {
# Write your own methods here
def _create_treeview(self, model):
cell_text = gtk.CellRendererText()
cell_icon = gtk.CellRendererPixbuf()
column = gtk.TreeViewColumn()
column.pack_start(cell_icon, False)
column.add_attribute(cell_icon, 'stock_id', 1)
column.pack_start(cell_text, True)
column.set_cell_data_func(cell_text, self.render_name_cell)
treeview = gtk.TreeView(model)
treeview.append_column(column)
treeview.set_headers_visible(False)
treeview.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
treeview.connect('key_press_event', self.on_treeview_key_press)
return treeview
def __init__(self, parent, notebook):
Dialog.__init__(self, parent,
_('Pages By Number Of Links'), # T: dialog title
buttons=gtk.BUTTONS_CLOSE
)
self.notebook = notebook
self.direction_input = gtk.combo_box_new_text()
for dir in sorted(self.LABELS):
self.direction_input.append_text(self.LABELS[dir])
self.uistate.setdefault('link_direction', LINK_DIR_BACKWARD, self.LABELS.keys())
gtk_combobox_set_active_text(
self.direction_input,
self.LABELS[self.uistate['link_direction']]
)
self.direction_input.connect('changed', self.on_direction_input_changed)
hbox = gtk.HBox()
hbox.pack_start(gtk.Label(_('Trace Links')+':'), False)
hbox.add(self.direction_input)
self.vbox.pack_start(hbox, False)
self.listview = SingleClickTreeView(gtk.ListStore(int, str))
self.listview.set_reorderable(True)
for i, label in enumerate((_('#'), _('Page'))):
column = gtk.TreeViewColumn(label, gtk.CellRendererText(), text=i)
column.set_sort_column_id(i)
self.listview.append_column(column)
# TODO: self.listview.connect('row-activated', self.on_row_activated())
self.vbox.add(ScrolledWindow(self.listview))
self.populate_listview()
def _build_ui(self):
self._display = gtk.Table(20, 2)
self._store = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_PYOBJECT)
self._tree = gtk.TreeView(self._store)
rend = gtk.CellRendererText()
tvc = gtk.TreeViewColumn('Element', rend, text=0)
self._tree.append_column(tvc)
self._tree.connect('button_press_event', self._tree_click)
self._tree.set_size_request(200, -1)
self.root = gtk.HBox(False, 3)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.add(self._tree)
sw.show()
self.root.pack_start(sw, 0, 0, 0)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.add_with_viewport(self._display)
sw.show()
self.root.pack_start(sw, 1, 1, 1)
self._tree.show()
self._display.show()
self.root.show()
def _make_view(self):
colnum = -1
for typ, cap in self.columns:
colnum += 1
if colnum == 0:
continue # Key column
if typ in [gobject.TYPE_STRING, gobject.TYPE_INT,
gobject.TYPE_FLOAT]:
rend = gtk.CellRendererText()
rend.set_property("ellipsize", pango.ELLIPSIZE_END)
column = gtk.TreeViewColumn(cap, rend, text=colnum)
elif typ in [gobject.TYPE_BOOLEAN]:
rend = gtk.CellRendererToggle()
rend.connect("toggled", self._toggle, colnum)
column = gtk.TreeViewColumn(cap, rend, active=colnum)
else:
raise Exception("Unsupported type %s" % typ)
column.set_sort_column_id(colnum)
self.__view.append_column(column)
self.__view.connect("button_press_event", self._mouse)
def make_view(self, columns):
self._view = gtk.TreeView(self._store)
for _type, _col in columns:
if _col.startswith("__"):
continue
index = columns.index((_type, _col))
if _type == gobject.TYPE_STRING or \
_type == gobject.TYPE_INT or \
_type == gobject.TYPE_FLOAT:
rend = gtk.CellRendererText()
column = gtk.TreeViewColumn(_col, rend, text=index)
column.set_resizable(True)
rend.set_property("ellipsize", pango.ELLIPSIZE_END)
elif _type == gobject.TYPE_BOOLEAN:
rend = gtk.CellRendererToggle()
rend.connect("toggled", self._toggle, index)
column = gtk.TreeViewColumn(_col, rend, active=index)
else:
raise Exception("Unknown column type (%i)" % index)
column.set_sort_column_id(index)
self._view.append_column(column)
self._view.connect("button_press_event", self.mouse_cb)
def __init__(self, rthread):
super(SettingsEditor, self).__init__(rthread)
# The main box
self.root = gtk.HBox(False, 0)
# The pane
paned = gtk.HPaned()
paned.show()
self.root.pack_start(paned, 1, 1, 0)
# The selection tree
self._store = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_INT)
self._view = gtk.TreeView(self._store)
self._view.get_selection().connect("changed", self._view_changed_cb)
self._view.append_column(
gtk.TreeViewColumn("", gtk.CellRendererText(), text=0))
self._view.show()
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_window.add_with_viewport(self._view)
scrolled_window.set_size_request(200, -1)
scrolled_window.show()
paned.pack1(scrolled_window)
# The settings notebook
self._notebook = gtk.Notebook()
self._notebook.set_show_tabs(False)
self._notebook.set_show_border(False)
self._notebook.show()
paned.pack2(self._notebook)
self._changed = False
self._settings = None
job = common.RadioJob(self._get_settings_cb, "get_settings")
job.set_desc("Getting radio settings")
self.rthread.submit(job)