# -*- Python -*-
# Twisted, the Framework of Your Internet
# $Id: spelunk_gnome.py,v 1.10 2002/09/21 08:16:49 acapnotic Exp $
# Copyright (C) 2001 Matthew W. Lefkowitz
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of version 2.1 of the GNU Lesser General Public
# License as published by the Free Software Foundation.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""Object browser GUI, GnomeCanvas implementation.
"""
from twisted.python import log
# TODO:
# gzigzag-style navigation
class SillyModule:
def __init__(self, module, prefix):
self.__module = module
self.__prefix = prefix
def __getattr__(self, attr):
try:
return getattr(self.__module, self.__prefix + attr)
except AttributeError:
return getattr(self.__module, attr)
# We use gnome.ui because that's what happens to have Python bindings
# for the Canvas. I think this canvas widget is available seperately
# in "libart", but nobody's given me Python bindings for just that.
# The Gnome canvas is said to be modeled after the Tk canvas, so we
# could probably write this in Tk too. But my experience is with GTK,
# not with Tk, so this is what I use.
import gnome.ui
gnome = SillyModule(gnome.ui, 'Gnome')
import gtk
(True, False) = (gtk.TRUE, gtk.FALSE)
gtk = SillyModule(gtk, 'Gtk')
import GDK
from twisted.python import reflect,text
from twisted.spread import pb
from twisted.manhole import explorer
import string, sys, types
import UserList
_PIXELS_PER_UNIT=10
#### Support class.
class PairList(UserList.UserList):
"""An ordered list of key, value pairs.
Kinda like an ordered dictionary. Made with small data sets
in mind, as get() does a linear search, not hashing.
"""
def get(self, key):
i = 0
for k, v in self.data:
if key == k:
return (i, v)
i = i + 1
else:
return (None, None)
def keys(self):
return map(lambda x: x[0], self.data)
#### Public
class SpelunkDisplay(gnome.Canvas):
"""Spelunk widget.
The top-level widget for this module. This gtk.Widget is where the
explorer display will be, and this object is also your interface to
creating new visages.
"""
def __init__(self, aa=False):
gnome.Canvas.__init__(self, aa)
self.set_pixels_per_unit(_PIXELS_PER_UNIT)
self.visages = {}
def makeDefaultCanvas(self):
"""Make myself the default canvas which new visages are created on.
"""
# XXX: For some reason, the 'canvas' and 'parent' properties
# of CanvasItems aren't accessible thorugh pygnome.
Explorer.canvas = self
def receiveExplorer(self, xplorer):
if self.visages.has_key(xplorer.id):
log.msg("Using cached visage for %d" % (xplorer.id, ))
# Ikk. Just because we just received this explorer, that
# doesn't necessarily mean its attributes are fresh. Fix
# that, either by having this side pull or the server
# side push.
visage = self.visages[xplorer.id]
#xplorer.give_properties(visage)
#xplorer.give_attributes(visage)
else:
log.msg("Making new visage for %d" % (xplorer.id, ))
self.visages[xplorer.id] = xplorer.newVisage(self.root(),
self)
#### Base classes
class Explorer(pb.RemoteCache):
"""Base class for all RemoteCaches of explorer.Explorer cachables.
Meaning that when an Explorer comes back over the wire, one of
these is created. From this, you can make a Visage for the
SpelunkDisplay, or a widget to display as an Attribute.
"""
canvas = None
# From our cache:
id = None
identifier = None
explorerClass = None
attributeGroups = None
def newVisage(self, group, canvas=None):
"""Make a new visage for the object I explore.
Returns a Visage.
"""
canvas = canvas or self.canvas
klass = spelunkerClassTable.get(self.explorerClass, None)
if (not klass) or (klass[0] is None):
log.msg("%s not in table, using generic" % self.explorerClass)
klass = GenericVisage
else:
klass = klass[0]
spelunker = klass(self, group, canvas)
if hasattr(canvas, "visages") \
and not canvas.visages.has_key(self.id):
canvas.visages[self.id] = spelunker
self.give_properties(spelunker)
self.give_attributes(spelunker)
return spelunker
def newAttributeWidget(self, group):
"""Make a new attribute item for my object.
Returns a gtk.Widget.
"""
klass = spelunkerClassTable.get(self.explorerClass, None)
if (not klass) or (klass[1] is None):
log.msg("%s not in table, using generic" % self.explorerClass)
klass = GenericAttributeWidget
else:
klass = klass[1]
return klass(self, group)
def give_properties(self, spelunker):
"""Give a spelunker my properties in an ordered list.
"""
valuelist = PairList()
for p in spelunker.propertyLabels.keys():
value = getattr(self, p, None)
valuelist.append((p,value))
spelunker.fill_properties(valuelist)
def give_attributes(self, spelunker):
for a in spelunker.groupLabels.keys():
things = getattr(self, a)
spelunker.fill_attributeGroup(a, things)
class _LooseBoxBorder:
box = None
color = 'black'
width = 1
def __init__(self, box):
self.box = box
class LooseBox(gnome.CanvasGroup):
def __init__(self):
self.border = _LooseBoxBorder(self)
class Visage(gnome.CanvasGroup):
"""A \"face\" of an object under exploration.
A Visage is a representation of an object presented to the user.
The \"face\" in \"interface\".
'propertyLabels' and 'groupLabels' are lists of (key, name)
2-ples, with 'key' being the string the property or group is
denoted by in the code, and 'name' being the pretty human-readable
string you want me to show on the Visage. These attributes are
accumulated from base classes as well.
I am a gnome.CanvasItem (more specifically, CanvasGroup).
"""
color = {'border': '#006644'}
border_width = 8
detail_level = 0
# These are mappings from the strings the code calls these by
# and the pretty names you want to see on the screen.
# (e.g. Capitalized or localized)
propertyLabels = []
groupLabels = []
drag_x0 = 0
drag_y0 = 0
def __init__(self, explorer, rootGroup, canvas):
"""Place a new Visage of an explorer in a canvas group.
I also need a 'canvas' reference is for certain coordinate
conversions, and pygnome doesn't give access to my GtkObject's
.canvas attribute. :(
"""
# Ugh. PyGtk/GtkObject/GnomeCanvas interfacing grits.
gnome.CanvasGroup.__init__(self,
_obj = rootGroup.add('group')._o)
self.propertyLabels = PairList()
reflect.accumulateClassList(self.__class__, 'propertyLabels',
self.propertyLabels)
self.groupLabels = PairList()
reflect.accumulateClassList(self.__class__, 'groupLabels',
self.groupLabels)
self.explorer = explorer
self.identifier = explorer.identifier
self.objectId = explorer.id
self.canvas = canvas
self.rootGroup = rootGroup
self.ebox = gtk.EventBox()
self.ebox.set_name("Visage")
self.frame = gtk.Frame(self.identifier)
self.container = gtk.VBox()
self.ebox.add(self.frame)
self.frame.add(self.container)
self.canvasWidget = self.add('widget', widget=self.ebox,
x=0, y=0, anchor=gtk.ANCHOR_NW,
size_pixels=0)
self.border = self.add('rect', x1=0, y1=0,
x2=1, y2=1,
fill_color=None,
outline_color=self.color['border'],
width_pixels=self.border_width)
self.subtable = {}
self._setup_table()
# TODO:
# Collapse me
# Movable/resizeable me
# Destroy me
# Set my detail level
self.frame.connect("size_allocate", self.signal_size_allocate,
None)
self.connect("destroy", self.signal_destroy, None)
self.connect("event", self.signal_event)
self.ebox.show_all()
# Our creator will call our fill_ methods when she has the goods.
def _setup_table(self):
"""Called by __init__ to set up my main table.
You can easily override me instead of clobbering __init__.
"""
table = gtk.Table(len(self.propertyLabels), 2)
self.container.add(table)
table.set_name("PropertyTable")
self.subtable['properties'] = table
row = 0
for p, name in self.propertyLabels:
label = gtk.Label(name)
label.set_name("PropertyName")
label.set_data("property", p)
table.attach(label, 0, 1, row, row + 1)
label.set_alignment(0, 0)
row = row + 1
# XXX: make these guys collapsable
for g, name in self.groupLabels:
table = gtk.Table(1, 2)
self.container.add(table)
table.set_name("AttributeGroupTable")
self.subtable[g] = table
label = gtk.Label(name)
label.set_name("AttributeGroupTitle")
table.attach(label, 0, 2, 0, 1)
def fill_properties(self, propValues):
"""Fill in values for my properites.
Takes a list of (name, value) pairs. 'name' should be one of
the keys in my propertyLabels, and 'value' either an Explorer
or a string.
"""
table = self.subtable['properties']
table.resize(len(propValues), 2)
# XXX: Do I need to destroy previously attached children?
for name, value in propValues:
self.fill_property(name, value)
table.show_all()
def fill_property(self, property, value):
"""Set a value for a particular property.
'property' should be one of the keys in my propertyLabels.
"""
row, name = self.propertyLabels.get(property)
if type(value) is not types.InstanceType:
widget = gtk.Label(str(value))
widget.set_alignment(0, 0)
else:
widget = value.newAttributeWidget(self)
widget.set_name("PropertyValue")
self.subtable['properties'].attach(widget, 1, 2, row, row+1)
def fill_attributeGroup(self, group, attributes):
"""Provide members of an attribute group.
'group' should be one of the keys in my groupLabels, and
'attributes' a list of (name, value) pairs, with each value as
either an Explorer or string.
"""
# XXX: How to indicate detail level of members?
table = self.subtable[group]
if not attributes:
table.hide()
return
table.resize(len(attributes)+1, 2)
# XXX: Do I need to destroy previously attached children?
row = 1 # 0 is title
for name, value in attributes.items():
label = gtk.Label(name)
label.set_name("AttributeName")
label.set_alignment(0, 0)
if type(value) is types.StringType:
widget = gtk.Label(value)
widget.set_alignment(0, 0)
else:
widget = value.newAttributeWidget(self)
table.attach(label, 0, 1, row, row + 1)
table.attach(widget, 1, 2, row, row + 1)
row = row + 1
table.show_all()
def signal_event(self, widget, event=None):
if not event:
log.msg("Huh? got event signal with no event.")
return
if event.type == GDK.BUTTON_PRESS:
if event.button == 1:
self.drag_x0, self.drag_y0 = event.x, event.y
return True
elif event.type == GDK.MOTION_NOTIFY:
if event.state & GDK.BUTTON1_MASK:
self.move(event.x - self.drag_x0, event.y - self.drag_y0)
self.drag_x0, self.drag_y0 = event.x, event.y
return True
return False
def signal_size_allocate(self, frame_widget,
unusable_allocation, unused_data):
(x, y, w, h) = frame_widget.get_allocation()
# XXX: allocation PyCObject is apparently unusable!
# (w, h) = allocation.width, allocation.height
w, h = (float(w)/_PIXELS_PER_UNIT, float(h)/_PIXELS_PER_UNIT)
x1, y1 = (self.canvasWidget['x'], self.canvasWidget['y'])
b = self.border
(b['x1'], b['y1'], b['x2'], b['y2']) = (x1, y1, x1+w, y1+h)
def signal_destroy(self, unused_object, unused_data):
del self.explorer
del self.canvasWidget
del self.border
del self.ebox
del self.frame
del self.container
self.subtable.clear()
class AttributeWidget(gtk.Widget):
"""A widget briefly describing an object.
This is similar to a Visage, but has far less detail. This should
display only essential identifiying information, a gtk.Widget
suitable for including in a single table cell.
(gtk.Widgets are used here instead of the more graphically
pleasing gnome.CanvasItems because I was too lazy to re-write
gtk.table for the canvas. A new table widget/item would be great
though, not only for canvas prettiness, but also because we could
use one with a mone pythonic API.)
"""
def __init__(self, explorer, parent):
"""A new AttributeWidget describing an explorer.
"""
self.parent = parent
self.explorer = explorer
self.identifier = explorer.identifier
self.id = explorer.id
widgetObj = self._makeWidgetObject()
gtk.Widget.__init__(self, _obj=widgetObj)
self.set_name("AttributeValue")
self.connect("destroy", self.signal_destroy, None)
self.connect("button-press-event", self.signal_buttonPressEvent,
None)
def getTextForLabel(self):
"""Returns text for my label.
The default implementation of AttributeWidget is a gtk.Label
widget. You may override this method to change the text which
appears in the label. However, if you don't want to be a
label, override _makeWidgetObject instead.
"""
return self.identifier
def _makeWidgetObject(self):
"""Make the GTK widget object that is me.
Called by __init__ to construct the GtkObject I wrap-- the ._o
member of a pygtk GtkObject. Isn't subclassing GtkObjects in
Python fun?
"""
ebox = gtk.EventBox()
label = gtk.Label(self.getTextForLabel())
label.set_alignment(0,0)
ebox.add(label)
return ebox._o
def signal_destroy(self, unused_object, unused_data):
del self.explorer
def signal_buttonPressEvent(self, widget, eventButton, unused_data):
if eventButton.type == GDK._2BUTTON_PRESS:
if self.parent.canvas.visages.has_key(self.explorer.id):
visage = self.parent.canvas.visages[self.explorer.id]
else:
visage = self.explorer.newVisage(self.parent.rootGroup,
self.parent.canvas)
(x, y, w, h) = self.get_allocation()
wx, wy = self.parent.canvas.c2w(x, y)
x1, y1, x2, y2 = self.parent.get_bounds()
v_x1, v_y1, v_x2, v_y2 = visage.get_bounds()
visage.move(x2 - v_x1, wy + y1 - v_y1)
#### Widget-specific subclasses of Explorer, Visage, and Attribute
# Instance
class ExplorerInstance(Explorer):
pass
class InstanceVisage(Visage):
# Detail levels:
# Just me
# me and my class
# me and my whole class heirarchy
propertyLabels = [('klass', "Class")]
groupLabels = [('data', "Data"),
('methods', "Methods")]
detail = 0
def __init__(self, explorer, group, canvas):
Visage.__init__(self, explorer, group, canvas)
class_identifier = self.explorer.klass.name
# XXX: include partial module name in class?
self.frame.set_label("%s (%s)" % (self.identifier,
class_identifier))
class InstanceAttributeWidget(AttributeWidget):
def getTextForLabel(self):
return "%s instance" % (self.explorer.klass.name,)
# Class
class ExplorerClass(Explorer):
pass
class ClassVisage(Visage):
propertyLabels = [("name", "Name"),
("module", "Module"),
("bases", "Bases")]
groupLabels = [('data', "Data"),
('methods', "Methods")]
def fill_properties(self, propValues):
Visage.fill_properties(self, propValues)
basesExplorer = propValues.get('bases')[1]
basesExplorer.view.callRemote("get_elements").addCallback(self.fill_bases)
def fill_bases(self, baseExplorers):
box = gtk.HBox()
for b in baseExplorers:
box.add(b.newAttributeWidget(self))
row = self.propertyLabels.get('bases')[0]
self.subtable["properties"].attach(box, 1, 2, row, row+1)
box.show_all()
class ClassAttributeWidget(AttributeWidget):
def getTextForLabel(self):
return self.explorer.name
# Function
class ExplorerFunction(Explorer):
pass
class FunctionAttributeWidget(AttributeWidget):
def getTextForLabel(self):
signature = self.explorer.signature
arglist = []
for arg in xrange(len(signature)):
name = signature.name[arg]
hasDefault, default = signature.get_default(arg)
if hasDefault:
if default.explorerClass == "ExplorerImmutable":
default = default.value
else:
# XXX
pass
a = "%s=%s" % (name, default)
elif signature.is_varlist(arg):
a = "*%s" % (name,)
elif signature.is_keyword(arg):
a = "**%s" % (name,)
else:
a = name
arglist.append(a)
return string.join(arglist, ", ")
# Method
class ExplorerMethod(ExplorerFunction):
pass
class MethodAttributeWidget(FunctionAttributeWidget):
pass
class ExplorerBulitin(Explorer):
pass
class ExplorerModule(Explorer):
pass
class ExplorerSequence(Explorer):
pass
# Sequence
class SequenceVisage(Visage):
propertyLabels = [('len', 'length')]
# XXX: add elements group
class SequenceAttributeWidget(AttributeWidget):
def getTextForLabel(self):
# XXX: Differentiate between lists and tuples.
if self.explorer.len:
txt = "list of length %d" % (self.explorer.len,)
else:
txt = "[]"
return txt
# Mapping
class ExplorerMapping(Explorer):
pass
class MappingVisage(Visage):
propertyLabels = [('len', 'length')]
# XXX: add items group
class MappingAttributeWidget(AttributeWidget):
def getTextForLabel(self):
if self.explorer.len:
txt = "dict with %d elements" % (self.explorer.len,)
else:
txt = "{}"
return txt
class ExplorerImmutable(Explorer):
pass
# Immutable
class ImmutableVisage(Visage):
def __init__(self, explorer, rootGroup, canvas):
Visage.__init__(self, explorer, rootGroup, canvas)
widget = explorer.newAttributeWidget(self)
self.container.add(widget)
self.container.show_all()
class ImmutableAttributeWidget(AttributeWidget):
def getTextForLabel(self):
return repr(self.explorer.value)
#### misc. module definitions
spelunkerClassTable = {
"ExplorerInstance": (InstanceVisage, InstanceAttributeWidget),
"ExplorerFunction": (None, FunctionAttributeWidget),
"ExplorerMethod": (None, MethodAttributeWidget),
"ExplorerImmutable": (ImmutableVisage, ImmutableAttributeWidget),
"ExplorerClass": (ClassVisage, ClassAttributeWidget),
"ExplorerSequence": (SequenceVisage, SequenceAttributeWidget),
"ExplorerMapping": (MappingVisage, MappingAttributeWidget),
}
GenericVisage = Visage
GenericAttributeWidget = AttributeWidget
pb.setCopierForClassTree(sys.modules[__name__],
Explorer, 'twisted.manhole.explorer')
|