[wxWidgets.git] / wxPython / wx / py / filling.py

"""Filling is the gui tree control through which a user can navigate
the local namespace or any object."""

__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
__cvsid__ = "$Id$"
__revision__ = "$Revision$"[11:-2]

import wx

import dispatcher
import editwindow
import inspect
import introspect
import keyword
import sys
import types
from version import VERSION

try:
    True
except NameError:
    True = 1==1
    False = 1==0

COMMONTYPES = [getattr(types, t) for t in dir(types) \
               if not t.startswith('_') \
               and t not in ('ClassType', 'InstanceType', 'ModuleType')]

DOCTYPES = ('BuiltinFunctionType', 'BuiltinMethodType', 'ClassType',
            'FunctionType', 'GeneratorType', 'InstanceType',
            'LambdaType', 'MethodType', 'ModuleType',
            'UnboundMethodType', 'method-wrapper')

SIMPLETYPES = [getattr(types, t) for t in dir(types) \
               if not t.startswith('_') and t not in DOCTYPES]

del t

try:
    COMMONTYPES.append(type(''.__repr__))  # Method-wrapper in version 2.2.x.
except AttributeError:
    pass


class FillingTree(wx.TreeCtrl):
    """FillingTree based on TreeCtrl."""
    
    name = 'Filling Tree'
    revision = __revision__

    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
                 size=wx.DefaultSize, style=wx.TR_DEFAULT_STYLE,
                 rootObject=None, rootLabel=None, rootIsNamespace=False,
                 static=False):
        """Create FillingTree instance."""
        wx.TreeCtrl.__init__(self, parent, id, pos, size, style)
        self.rootIsNamespace = rootIsNamespace
        import __main__
        if rootObject is None:
            rootObject = __main__.__dict__
            self.rootIsNamespace = True
        if rootObject is __main__.__dict__ and rootLabel is None:
            rootLabel = 'locals()'
        if not rootLabel:
            rootLabel = 'Ingredients'
        rootData = wx.TreeItemData(rootObject)
        self.item = self.root = self.AddRoot(rootLabel, -1, -1, rootData)
        self.SetItemHasChildren(self.root, self.objHasChildren(rootObject))
        wx.EVT_TREE_ITEM_EXPANDING(self, self.GetId(), self.OnItemExpanding)
        wx.EVT_TREE_ITEM_COLLAPSED(self, self.GetId(), self.OnItemCollapsed)
        wx.EVT_TREE_SEL_CHANGED(self, self.GetId(), self.OnSelChanged)
        wx.EVT_TREE_ITEM_ACTIVATED(self, self.GetId(), self.OnItemActivated)
        if not static:
            dispatcher.connect(receiver=self.push, signal='Interpreter.push')

    def push(self, command, more):
        """Receiver for Interpreter.push signal."""
        self.display()

    def OnItemExpanding(self, event):
        """Add children to the item."""
        busy = wx.BusyCursor()
        item = event.GetItem()
        if self.IsExpanded(item):
            return
        self.addChildren(item)
#        self.SelectItem(item)

    def OnItemCollapsed(self, event):
        """Remove all children from the item."""
        busy = wx.BusyCursor()
        item = event.GetItem()
#        self.CollapseAndReset(item)
#        self.DeleteChildren(item)
#        self.SelectItem(item)

    def OnSelChanged(self, event):
        """Display information about the item."""
        busy = wx.BusyCursor()
        self.item = event.GetItem()
        self.display()

    def OnItemActivated(self, event):
        """Launch a DirFrame."""
        item = event.GetItem()
        text = self.getFullName(item)
        obj = self.GetPyData(item)
        frame = FillingFrame(parent=self, size=(600, 100), rootObject=obj,
                             rootLabel=text, rootIsNamespace=False)
        frame.Show()

    def objHasChildren(self, obj):
        """Return true if object has children."""
        if self.objGetChildren(obj):
            return True
        else:
            return False

    def objGetChildren(self, obj):
        """Return dictionary with attributes or contents of object."""
        busy = wx.BusyCursor()
        otype = type(obj)
        if otype is types.DictType \
        or str(otype)[17:23] == 'BTrees' and hasattr(obj, 'keys'):
            return obj
        d = {}
        if otype is types.ListType or otype is types.TupleType:
            for n in range(len(obj)):
                key = '[' + str(n) + ']'
                d[key] = obj[n]
        if otype not in COMMONTYPES:
            for key in introspect.getAttributeNames(obj):
                # Believe it or not, some attributes can disappear,
                # such as the exc_traceback attribute of the sys
                # module. So this is nested in a try block.
                try:
                    d[key] = getattr(obj, key)
                except:
                    pass
        return d

    def addChildren(self, item):
        self.DeleteChildren(item)
        obj = self.GetPyData(item)
        children = self.objGetChildren(obj)
        if not children:
            return
        keys = children.keys()
        keys.sort(lambda x, y: cmp(str(x).lower(), str(y).lower()))
        for key in keys:
            itemtext = str(key)
            # Show string dictionary items with single quotes, except
            # for the first level of items, if they represent a
            # namespace.
            if type(obj) is types.DictType \
            and type(key) is types.StringType \
            and (item != self.root \
                 or (item == self.root and not self.rootIsNamespace)):
                itemtext = repr(key)
            child = children[key]
            data = wx.TreeItemData(child)
            branch = self.AppendItem(parent=item, text=itemtext, data=data)
            self.SetItemHasChildren(branch, self.objHasChildren(child))

    def display(self):
        item = self.item
        if self.IsExpanded(item):
            self.addChildren(item)
        self.setText('')
        obj = self.GetPyData(item)
        if wx.Platform == '__WXMSW__':
            if obj is None: # Windows bug fix.
                return
        self.SetItemHasChildren(item, self.objHasChildren(obj))
        otype = type(obj)
        text = ''
        text += self.getFullName(item)
        text += '\n\nType: ' + str(otype)
        try:
            value = str(obj)
        except:
            value = ''
        if otype is types.StringType or otype is types.UnicodeType:
            value = repr(obj)
        text += '\n\nValue: ' + value
        if otype not in SIMPLETYPES:
            try:
                text += '\n\nDocstring:\n\n"""' + \
                        inspect.getdoc(obj).strip() + '"""'
            except:
                pass
        if otype is types.InstanceType:
            try:
                text += '\n\nClass Definition:\n\n' + \
                        inspect.getsource(obj.__class__)
            except:
                pass
        else:
            try:
                text += '\n\nSource Code:\n\n' + \
                        inspect.getsource(obj)
            except:
                pass
        self.setText(text)

    def getFullName(self, item, partial=''):
        """Return a syntactically proper name for item."""
        name = self.GetItemText(item)
        parent = None
        obj = None
        if item != self.root:
            parent = self.GetItemParent(item)
            obj = self.GetPyData(parent)
        # Apply dictionary syntax to dictionary items, except the root
        # and first level children of a namepace.
        if (type(obj) is types.DictType \
            or str(type(obj))[17:23] == 'BTrees' \
            and hasattr(obj, 'keys')) \
        and ((item != self.root and parent != self.root) \
            or (parent == self.root and not self.rootIsNamespace)):
            name = '[' + name + ']'
        # Apply dot syntax to multipart names.
        if partial:
            if partial[0] == '[':
                name += partial
            else:
                name += '.' + partial
        # Repeat for everything but the root item
        # and first level children of a namespace.
        if (item != self.root and parent != self.root) \
        or (parent == self.root and not self.rootIsNamespace):
            name = self.getFullName(parent, partial=name)
        return name

    def setText(self, text):
        """Display information about the current selection."""

        # This method will likely be replaced by the enclosing app to
        # do something more interesting, like write to a text control.
        print text

    def setStatusText(self, text):
        """Display status information."""

        # This method will likely be replaced by the enclosing app to
        # do something more interesting, like write to a status bar.
        print text


class FillingText(editwindow.EditWindow):
    """FillingText based on StyledTextCtrl."""

    name = 'Filling Text'
    revision = __revision__

    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
                 size=wx.DefaultSize, style=wx.CLIP_CHILDREN,
                 static=False):
        """Create FillingText instance."""
        editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
        # Configure various defaults and user preferences.
        self.SetReadOnly(True)
        self.SetWrapMode(True)
        self.SetMarginWidth(1, 0)
        if not static:
            dispatcher.connect(receiver=self.push, signal='Interpreter.push')

    def push(self, command, more):
        """Receiver for Interpreter.push signal."""
        self.Refresh()

    def SetText(self, *args, **kwds):
        self.SetReadOnly(False)
        editwindow.EditWindow.SetText(self, *args, **kwds)
        self.SetReadOnly(True)


class Filling(wx.SplitterWindow):
    """Filling based on wxSplitterWindow."""

    name = 'Filling'
    revision = __revision__

    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
                 size=wx.DefaultSize, style=wx.SP_3D,
                 name='Filling Window', rootObject=None,
                 rootLabel=None, rootIsNamespace=False, static=False):
        """Create a Filling instance."""
        wx.SplitterWindow.__init__(self, parent, id, pos, size, style, name)
        self.tree = FillingTree(parent=self, rootObject=rootObject,
                                rootLabel=rootLabel,
                                rootIsNamespace=rootIsNamespace,
                                static=static)
        self.text = FillingText(parent=self, static=static)
        self.SplitVertically(self.tree, self.text, 130)
        self.SetMinimumPaneSize(1)
        # Override the filling so that descriptions go to FillingText.
        self.tree.setText = self.text.SetText
        # Display the root item.
##        self.tree.SelectItem(self.tree.root)
        self.tree.display()


class FillingFrame(wx.Frame):
    """Frame containing the namespace tree component."""

    name = 'Filling Frame'
    revision = __revision__

    def __init__(self, parent=None, id=-1, title='PyFilling',
                 pos=wx.DefaultPosition, size=(600, 400),
                 style=wx.DEFAULT_FRAME_STYLE, rootObject=None,
                 rootLabel=None, rootIsNamespace=False, static=False):
        """Create FillingFrame instance."""
        wx.Frame.__init__(self, parent, id, title, pos, size, style)
        intro = 'PyFilling - The Tastiest Namespace Inspector'
        self.CreateStatusBar()
        self.SetStatusText(intro)
        import images
        self.SetIcon(images.getPyIcon())
        self.filling = Filling(parent=self, rootObject=rootObject,
                               rootLabel=rootLabel,
                               rootIsNamespace=rootIsNamespace,
                               static=static)
        # Override so that status messages go to the status bar.
        self.filling.tree.setStatusText = self.SetStatusText


class App(wx.App):
    """PyFilling standalone application."""

    def OnInit(self):
        wx.InitAllImageHandlers()
        self.fillingFrame = FillingFrame()
        self.fillingFrame.Show(True)
        self.SetTopWindow(self.fillingFrame)
        return True
Commit	Line	Data
d14a1e28 RD	1	"""Filling is the gui tree control through which a user can navigate
d14a1e28 RD	2	the local namespace or any object."""
1fded56b	3
d14a1e28 RD	4	__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
	5	__cvsid__ = "$Id$"
	6	__revision__ = "$Revision$"[11:-2]
1fded56b	7
d14a1e28 RD	8	import wx
	9
	10	import dispatcher
	11	import editwindow
	12	import inspect
	13	import introspect
	14	import keyword
	15	import sys
	16	import types
	17	from version import VERSION
	18
	19	try:
	20	True
	21	except NameError:
	22	True = 1==1
	23	False = 1==0
	24
	25	COMMONTYPES = [getattr(types, t) for t in dir(types) \
	26	if not t.startswith('_') \
	27	and t not in ('ClassType', 'InstanceType', 'ModuleType')]
	28
	29	DOCTYPES = ('BuiltinFunctionType', 'BuiltinMethodType', 'ClassType',
	30	'FunctionType', 'GeneratorType', 'InstanceType',
	31	'LambdaType', 'MethodType', 'ModuleType',
	32	'UnboundMethodType', 'method-wrapper')
	33
	34	SIMPLETYPES = [getattr(types, t) for t in dir(types) \
	35	if not t.startswith('_') and t not in DOCTYPES]
	36
	37	del t
	38
	39	try:
	40	COMMONTYPES.append(type(''.__repr__)) # Method-wrapper in version 2.2.x.
	41	except AttributeError:
	42	pass
	43
	44
	45	class FillingTree(wx.TreeCtrl):
	46	"""FillingTree based on TreeCtrl."""
	47
	48	name = 'Filling Tree'
	49	revision = __revision__
	50
	51	def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
	52	size=wx.DefaultSize, style=wx.TR_DEFAULT_STYLE,
	53	rootObject=None, rootLabel=None, rootIsNamespace=False,
	54	static=False):
	55	"""Create FillingTree instance."""
	56	wx.TreeCtrl.__init__(self, parent, id, pos, size, style)
	57	self.rootIsNamespace = rootIsNamespace
	58	import __main__
	59	if rootObject is None:
	60	rootObject = __main__.__dict__
	61	self.rootIsNamespace = True
	62	if rootObject is __main__.__dict__ and rootLabel is None:
	63	rootLabel = 'locals()'
	64	if not rootLabel:
	65	rootLabel = 'Ingredients'
	66	rootData = wx.TreeItemData(rootObject)
	67	self.item = self.root = self.AddRoot(rootLabel, -1, -1, rootData)
	68	self.SetItemHasChildren(self.root, self.objHasChildren(rootObject))
	69	wx.EVT_TREE_ITEM_EXPANDING(self, self.GetId(), self.OnItemExpanding)
	70	wx.EVT_TREE_ITEM_COLLAPSED(self, self.GetId(), self.OnItemCollapsed)
	71	wx.EVT_TREE_SEL_CHANGED(self, self.GetId(), self.OnSelChanged)
72	wx.EVT_TREE_ITEM_ACTIVATED(self, self.GetId(), self.OnItemActivated)
73	if not static:
74	dispatcher.connect(receiver=self.push, signal='Interpreter.push')
75
76	def push(self, command, more):
77	"""Receiver for Interpreter.push signal."""
78	self.display()
79
80	def OnItemExpanding(self, event):
81	"""Add children to the item."""
82	busy = wx.BusyCursor()
83	item = event.GetItem()
84	if self.IsExpanded(item):
85	return
86	self.addChildren(item)
87	# self.SelectItem(item)
88
89	def OnItemCollapsed(self, event):
90	"""Remove all children from the item."""
91	busy = wx.BusyCursor()
92	item = event.GetItem()
93	# self.CollapseAndReset(item)
94	# self.DeleteChildren(item)
95	# self.SelectItem(item)
96
97	def OnSelChanged(self, event):
98	"""Display information about the item."""
99	busy = wx.BusyCursor()
100	self.item = event.GetItem()
101	self.display()
102
103	def OnItemActivated(self, event):
104	"""Launch a DirFrame."""
105	item = event.GetItem()
106	text = self.getFullName(item)
107	obj = self.GetPyData(item)
108	frame = FillingFrame(parent=self, size=(600, 100), rootObject=obj,
109	rootLabel=text, rootIsNamespace=False)
110	frame.Show()
111
112	def objHasChildren(self, obj):
113	"""Return true if object has children."""
114	if self.objGetChildren(obj):
115	return True
116	else:
117	return False
118
119	def objGetChildren(self, obj):
120	"""Return dictionary with attributes or contents of object."""
121	busy = wx.BusyCursor()
122	otype = type(obj)
123	if otype is types.DictType \
124	or str(otype)[17:23] == 'BTrees' and hasattr(obj, 'keys'):
125	return obj
126	d = {}
127	if otype is types.ListType or otype is types.TupleType:
128	for n in range(len(obj)):
129	key = '[' + str(n) + ']'
130	d[key] = obj[n]
131	if otype not in COMMONTYPES:
132	for key in introspect.getAttributeNames(obj):
133	# Believe it or not, some attributes can disappear,
134	# such as the exc_traceback attribute of the sys
135	# module. So this is nested in a try block.
136	try:
137	d[key] = getattr(obj, key)
138	except:
139	pass
140	return d
141
142	def addChildren(self, item):
143	self.DeleteChildren(item)
144	obj = self.GetPyData(item)
145	children = self.objGetChildren(obj)
146	if not children:
147	return
148	keys = children.keys()
149	keys.sort(lambda x, y: cmp(str(x).lower(), str(y).lower()))
150	for key in keys:
151	itemtext = str(key)
152	# Show string dictionary items with single quotes, except
153	# for the first level of items, if they represent a
154	# namespace.
155	if type(obj) is types.DictType \
156	and type(key) is types.StringType \
157	and (item != self.root \
158	or (item == self.root and not self.rootIsNamespace)):
159	itemtext = repr(key)
160	child = children[key]
161	data = wx.TreeItemData(child)
162	branch = self.AppendItem(parent=item, text=itemtext, data=data)
163	self.SetItemHasChildren(branch, self.objHasChildren(child))
164
165	def display(self):
166	item = self.item
167	if self.IsExpanded(item):
168	self.addChildren(item)
169	self.setText('')
170	obj = self.GetPyData(item)
171	if wx.Platform == '__WXMSW__':
172	if obj is None: # Windows bug fix.
173	return
174	self.SetItemHasChildren(item, self.objHasChildren(obj))
175	otype = type(obj)
176	text = ''
177	text += self.getFullName(item)
178	text += '\n\nType: ' + str(otype)
179	try:
180	value = str(obj)
181	except:
182	value = ''
183	if otype is types.StringType or otype is types.UnicodeType:
184	value = repr(obj)
185	text += '\n\nValue: ' + value
186	if otype not in SIMPLETYPES:
187	try:
188	text += '\n\nDocstring:\n\n"""' + \
189	inspect.getdoc(obj).strip() + '"""'
190	except:
191	pass
192	if otype is types.InstanceType:
193	try:
194	text += '\n\nClass Definition:\n\n' + \
195	inspect.getsource(obj.__class__)
196	except:
197	pass
198	else:
199	try:
200	text += '\n\nSource Code:\n\n' + \
201	inspect.getsource(obj)
202	except:
203	pass
204	self.setText(text)
205
206	def getFullName(self, item, partial=''):
207	"""Return a syntactically proper name for item."""
208	name = self.GetItemText(item)
209	parent = None
210	obj = None
211	if item != self.root:
212	parent = self.GetItemParent(item)
213	obj = self.GetPyData(parent)
214	# Apply dictionary syntax to dictionary items, except the root
215	# and first level children of a namepace.
216	if (type(obj) is types.DictType \
217	or str(type(obj))[17:23] == 'BTrees' \
218	and hasattr(obj, 'keys')) \
219	and ((item != self.root and parent != self.root) \
220	or (parent == self.root and not self.rootIsNamespace)):
221	name = '[' + name + ']'
222	# Apply dot syntax to multipart names.
223	if partial:
224	if partial[0] == '[':
225	name += partial
226	else:
227	name += '.' + partial
228	# Repeat for everything but the root item
229	# and first level children of a namespace.
230	if (item != self.root and parent != self.root) \
231	or (parent == self.root and not self.rootIsNamespace):
232	name = self.getFullName(parent, partial=name)
233	return name
234
235	def setText(self, text):
236	"""Display information about the current selection."""
237
238	# This method will likely be replaced by the enclosing app to
239	# do something more interesting, like write to a text control.
240	print text
241
242	def setStatusText(self, text):
243	"""Display status information."""
244
245	# This method will likely be replaced by the enclosing app to
246	# do something more interesting, like write to a status bar.
247	print text
248
249
250	class FillingText(editwindow.EditWindow):
251	"""FillingText based on StyledTextCtrl."""
252
253	name = 'Filling Text'
254	revision = __revision__
255
256	def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
257	size=wx.DefaultSize, style=wx.CLIP_CHILDREN,
258	static=False):
259	"""Create FillingText instance."""
260	editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
261	# Configure various defaults and user preferences.
262	self.SetReadOnly(True)
263	self.SetWrapMode(True)
264	self.SetMarginWidth(1, 0)
265	if not static:
266	dispatcher.connect(receiver=self.push, signal='Interpreter.push')
267
268	def push(self, command, more):
269	"""Receiver for Interpreter.push signal."""
270	self.Refresh()
271
272	def SetText(self, args, *kwds):
273	self.SetReadOnly(False)
274	editwindow.EditWindow.SetText(self, args, *kwds)
275	self.SetReadOnly(True)
276
277
278	class Filling(wx.SplitterWindow):
279	"""Filling based on wxSplitterWindow."""
280
281	name = 'Filling'
282	revision = __revision__
283
284	def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
285	size=wx.DefaultSize, style=wx.SP_3D,
286	name='Filling Window', rootObject=None,
287	rootLabel=None, rootIsNamespace=False, static=False):
288	"""Create a Filling instance."""
289	wx.SplitterWindow.__init__(self, parent, id, pos, size, style, name)
290	self.tree = FillingTree(parent=self, rootObject=rootObject,
291	rootLabel=rootLabel,
292	rootIsNamespace=rootIsNamespace,
293	static=static)
294	self.text = FillingText(parent=self, static=static)
295	self.SplitVertically(self.tree, self.text, 130)
296	self.SetMinimumPaneSize(1)
297	# Override the filling so that descriptions go to FillingText.
298	self.tree.setText = self.text.SetText
299	# Display the root item.
300	## self.tree.SelectItem(self.tree.root)
301	self.tree.display()
302
303
304	class FillingFrame(wx.Frame):
305	"""Frame containing the namespace tree component."""
306
307	name = 'Filling Frame'
308	revision = __revision__
309
310	def __init__(self, parent=None, id=-1, title='PyFilling',
311	pos=wx.DefaultPosition, size=(600, 400),
312	style=wx.DEFAULT_FRAME_STYLE, rootObject=None,
313	rootLabel=None, rootIsNamespace=False, static=False):
314	"""Create FillingFrame instance."""
315	wx.Frame.__init__(self, parent, id, title, pos, size, style)
316	intro = 'PyFilling - The Tastiest Namespace Inspector'
317	self.CreateStatusBar()
318	self.SetStatusText(intro)
319	import images
320	self.SetIcon(images.getPyIcon())
321	self.filling = Filling(parent=self, rootObject=rootObject,
322	rootLabel=rootLabel,
323	rootIsNamespace=rootIsNamespace,
324	static=static)
325	# Override so that status messages go to the status bar.
326	self.filling.tree.setStatusText = self.SetStatusText
327
328
329	class App(wx.App):
330	"""PyFilling standalone application."""
331
332	def OnInit(self):
333	wx.InitAllImageHandlers()
334	self.fillingFrame = FillingFrame()
335	self.fillingFrame.Show(True)
336	self.SetTopWindow(self.fillingFrame)
337	return True