/usr/share/doc/python-gtk2-tutorial/html/examples/cellrenderer.py is in python-gtk2-tutorial 2.4-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 | #!/usr/bin/env python
# vim: ts=4:sw=4:tw=78:nowrap
""" Demonstration using editable and activatable CellRenderers """
import pygtk
pygtk.require("2.0")
import gtk, gobject
tasks = {
"Buy groceries": "Go to Asda after work",
"Do some programming": "Remember to update your software",
"Power up systems": "Turn on the client but leave the server",
"Watch some tv": "Remember to catch ER"
}
class GUI_Controller:
""" The GUI class is the controller for our application """
def __init__(self):
# setup the main window
self.root = gtk.Window(type=gtk.WINDOW_TOPLEVEL)
self.root.set_title("CellRenderer Example")
self.root.connect("destroy", self.destroy_cb)
# Get the model and attach it to the view
self.mdl = Store.get_model()
self.view = Display.make_view( self.mdl )
# Add our view into the main window
self.root.add(self.view)
self.root.show_all()
return
def destroy_cb(self, *kw):
""" Destroy callback to shutdown the app """
gtk.main_quit()
return
def run(self):
""" run is called to set off the GTK mainloop """
gtk.main()
return
class InfoModel:
""" The model class holds the information we want to display """
def __init__(self):
""" Sets up and populates our gtk.TreeStore """
self.tree_store = gtk.TreeStore( gobject.TYPE_STRING,
gobject.TYPE_BOOLEAN )
# places the global people data into the list
# we form a simple tree.
for item in tasks.keys():
parent = self.tree_store.append( None, (item, None) )
self.tree_store.append( parent, (tasks[item],None) )
return
def get_model(self):
""" Returns the model """
if self.tree_store:
return self.tree_store
else:
return None
class DisplayModel:
""" Displays the Info_Model model in a view """
def make_view( self, model ):
""" Form a view for the Tree Model """
self.view = gtk.TreeView( model )
# setup the text cell renderer and allows these
# cells to be edited.
self.renderer = gtk.CellRendererText()
self.renderer.set_property( 'editable', True )
self.renderer.connect( 'edited', self.col0_edited_cb, model )
# The toggle cellrenderer is setup and we allow it to be
# changed (toggled) by the user.
self.renderer1 = gtk.CellRendererToggle()
self.renderer1.set_property('activatable', True)
self.renderer1.connect( 'toggled', self.col1_toggled_cb, model )
# Connect column0 of the display with column 0 in our list model
# The renderer will then display whatever is in column 0 of
# our model .
self.column0 = gtk.TreeViewColumn("Name", self.renderer, text=0)
# The columns active state is attached to the second column
# in the model. So when the model says True then the button
# will show as active e.g on.
self.column1 = gtk.TreeViewColumn("Complete", self.renderer1 )
self.column1.add_attribute( self.renderer1, "active", 1)
self.view.append_column( self.column0 )
self.view.append_column( self.column1 )
return self.view
def col0_edited_cb( self, cell, path, new_text, model ):
"""
Called when a text cell is edited. It puts the new text
in the model so that it is displayed properly.
"""
print "Change '%s' to '%s'" % (model[path][0], new_text)
model[path][0] = new_text
return
def col1_toggled_cb( self, cell, path, model ):
"""
Sets the toggled state on the toggle button to true or false.
"""
model[path][1] = not model[path][1]
print "Toggle '%s' to: %s" % (model[path][0], model[path][1],)
return
if __name__ == '__main__':
Store = InfoModel()
Display = DisplayModel()
myGUI = GUI_Controller()
myGUI.run()
|