path: root/Mac/Unsupported/twit/mactwit_browser.py

"""A simple Mac-only browse utility to peek at the inner data structures of Python."""
# Minor modifications by Jack to facilitate incorporation in twit.

# june 1996
# Written by Just van Rossum <just@knoware.nl>, please send comments/improvements.
# Loosely based on Jack Jansens's PICTbrowse.py, but depends on his fabulous FrameWork.py
# XXX Some parts are *very* poorly solved. Will fix. Guido has to check if all the
# XXX "python-peeking" is done correctly. I kindof reverse-engineered it ;-)

# disclaimer: although I happen to be the brother of Python's father, programming is
# not what I've been trained to do. So don't be surprised if you find anything that's not 
# as nice as it could be...

# XXX to do:
# Arrow key support
# Copy & Paste? 
# MAIN_TEXT item should not contain (type); should be below or something. 
# MAIN_TEXT item should check if a string is binary or not: convert to '/000' style
# or convert newlines. 

version = "1.0"

import FrameWork
import EasyDialogs
import Dlg
import Res
import Qd
import List
import sys
from Types import *
from QuickDraw import *
import string
import time
import os

# The initial object to start browsing with. Can be anything, but 'sys' makes kindof sense.
start_object = sys

# Resource definitions
ID_MAIN = 503
NUM_LISTS = 4	# the number of lists used. could be changed, but the dlg item numbers should be consistent
MAIN_TITLE = 3	# this is only the first text item, the other three ID's should be 5, 7 and 9
MAIN_LIST = 4	# this is only the first list, the other three ID's should be 6, 8 and 10
MAIN_TEXT = 11
MAIN_LEFT = 1
MAIN_RIGHT = 2
MAIN_RESET = 12
MAIN_CLOSE = 13
MAIN_LINE = 14

def Initialize():
	# this bit ensures that this module will also work as an applet if the resources are
	# in the resource fork of the applet
	# stolen from Jack, so it should work(?!;-)
	try:
		# if this doesn't raise an error, we are an applet containing the necessary resources
		# so we don't have to bother opening the resource file
		dummy = Res.GetResource('DLOG', ID_MAIN)
	except Res.Error:
		savewd = os.getcwd()
		ourparentdir = os.path.split(openresfile.func_code.co_filename)[0]
		os.chdir(ourparentdir)		
		try:
			Res.FSpOpenResFile("mactwit_browse.rsrc", 1)
		except Res.Error, arg:
			EasyDialogs.Message("Cannot open mactwit_browse.rsrc: "+arg[1])
			sys.exit(1)
		os.chdir(savewd)

def main():
	Initialize()
	PythonBrowse()

# this is all there is to it to make an application. 
class PythonBrowse(FrameWork.Application):
	def __init__(self):
		FrameWork.Application.__init__(self)
		VarBrowser(self).open(start_object)
		self.mainloop()
	
	def do_about(self, id, item, window, event):
		EasyDialogs.Message(self.__class__.__name__ + " version " + version + "\rby Just van Rossum")
	
	def quit(self, *args):
		raise self

class MyList:
	def __init__(self, wid, rect, itemnum):
		# wid is the window (dialog) where our list is going to be in
		# rect is it's item rectangle (as in dialog item)
		# itemnum is the itemnumber in the dialog
		self.rect = rect
		rect2 = rect[0]+1, rect[1]+1, rect[2]-16, rect[3]-1		# Scroll bar space, that's 15 + 1, Jack!
		self.list = List.LNew(rect2, (0, 0, 1, 0), (0,0), 0, wid,
					0, 1, 0, 1)
		self.wid = wid
		self.active = 0
		self.itemnum = itemnum
	
	def setcontent(self, content, title = ""):
		# first, gather some stuff
		keylist = []
		valuelist = []
		thetype = type(content)
		if thetype == DictType:
			keylist = content.keys()
			keylist.sort()
			for key in keylist:
				valuelist.append(content[key])
		elif thetype == ListType:
			keylist = valuelist = content
		elif thetype == TupleType:
			
			keylist = valuelist = []
			for i in content:
				keylist.append(i)
		else:
			# XXX help me! is all this correct? is there more I should consider???
			# XXX is this a sensible way to do it in the first place????
			# XXX I'm not familiar enough with Python's guts to be sure. GUIDOOOOO!!!
			if hasattr(content, "__dict__"):
				keylist = keylist + content.__dict__.keys()
			if hasattr(content, "__methods__"):
				keylist = keylist + content.__methods__
			if hasattr(content, "__members__"):
				keylist = keylist + content.__members__
			if hasattr(content, "__class__"):
				keylist.append("__class__")
			if hasattr(content, "__bases__"):
				keylist.append("__bases__")
			if hasattr(content, "__name__"):
				title = content.__name__
				if "__name__" not in keylist:
					keylist.append("__name__")
			keylist.sort()
			for key in keylist:
				valuelist.append(getattr(content, key))
		if content <> None:
			title = title + "\r" + cleantype(content)
		# now make that list!
		tp, h, rect = self.wid.GetDialogItem(self.itemnum - 1)
		Dlg.SetDialogItemText(h, title[:255])
		self.list.LDelRow(0, 1)
		self.list.LSetDrawingMode(0)
		self.list.LAddRow(len(keylist), 0)
		for i in range(len(keylist)):
			self.list.LSetCell(str(keylist[i]), (0, i))
		self.list.LSetDrawingMode(1)
		self.list.LUpdate(self.wid.GetWindowPort().visRgn)
		self.content = content
		self.keylist = keylist
		self.valuelist = valuelist
		self.title = title
	
	# draw a frame around the list, List Manager doesn't do that
	def drawframe(self):
		Qd.SetPort(self.wid)
		Qd.FrameRect(self.rect)
		rect2 = Qd.InsetRect(self.rect, -3, -3)
		save = Qd.GetPenState()
		Qd.PenSize(2, 2)
		if self.active:
			Qd.PenPat(Qd.qd.black)
		else:
			Qd.PenPat(Qd.qd.white)
		# draw (or erase) an extra frame to indicate this is the acive list (or not)
		Qd.FrameRect(rect2)
		Qd.SetPenState(save)
		
		

class VarBrowser(FrameWork.DialogWindow):
	def open(self, start_object, title = ""):
		FrameWork.DialogWindow.open(self, ID_MAIN)
		if title <> "":
			windowtitle = self.wid.GetWTitle()
			self.wid.SetWTitle(windowtitle + " >> " + title)
		else:
			if hasattr(start_object, "__name__"):
				windowtitle = self.wid.GetWTitle()
				self.wid.SetWTitle(windowtitle + " >> " + str(getattr(start_object, "__name__")) )
				
		self.SetPort()
		Qd.TextFont(3)
		Qd.TextSize(9)
		self.lists = []
		self.listitems = []
		for i in range(NUM_LISTS):
			self.listitems.append(MAIN_LIST + 2 * i)	# dlg item numbers... have to be consistent
		for i in self.listitems:
			tp, h, rect = self.wid.GetDialogItem(i)
			list = MyList(self.wid, rect, i)
			self.lists.append(list)
		self.leftover = []
		self.rightover = []
		self.setup(start_object, title)
		
	def close(self):
		self.lists = []
		self.listitems = []
		self.do_postclose()
	
	def setup(self, start_object, title = ""):
		# here we set the starting point for our expedition
		self.start = start_object
		self.lists[0].setcontent(start_object, title)
		for list in self.lists[1:]:
			list.setcontent(None)
		
	def do_listhit(self, event, item):
		(what, message, when, where, modifiers) = event
		Qd.SetPort(self.wid)
		where = Qd.GlobalToLocal(where)
		for list in self.lists:
			list.active = 0
		list = self.lists[self.listitems.index(item)]
		list.active = 1
		for l in self.lists:
			l.drawframe()
		
		point = (0,0)
		ok, point = list.list.LGetSelect(1, point)
		if ok:
			oldsel = point[1]
		else:
			oldsel = -1
		# This should be: list.list.LClick(where, modifiers)
		# Since the selFlags field of the list is not accessible from Python I have to do it like this.
		# The effect is that you can't select more items by using shift or command.
		list.list.LClick(where, 0)
		
		index = self.listitems.index(item) + 1
		point = (0,0)
		ok, point = list.list.LGetSelect(1, point)
		if oldsel == point[1]:
			return	# selection didn't change, do nothing.
		if not ok:
			for i in range(index, len(self.listitems)):
				self.lists[i].setcontent(None)
			self.rightover = []
			return
			
		if point[1] >= len(list.keylist):
			return		# XXX is this still necessary? is ok really true?
		key = str(list.keylist[point[1]])
		value = list.valuelist[point[1]]
		
		self.settextitem("")
		thetype = type(value)
		if thetype == ListType or 				\
				thetype == TupleType or 		\
				thetype == DictType or 			\
				hasattr(value, "__dict__") or 		\
				hasattr(value, "__methods__") or	\
				hasattr(value, "__members__"):	# XXX or, or... again: did I miss something?
			if index >= len(self.listitems):
				# we've reached the right side of our dialog. move everything to the left
				# (by pushing the rightbutton...)
				self.do_rightbutton(1)
				index = index - 1
			newlist = self.lists[index]
			newlist.setcontent(value, key)
		else:
			index = index - 1
			self.settextitem( str(value) + "\r" + cleantype(value))
		for i in range(index + 1, len(self.listitems)):
			self.lists[i].setcontent(None)
		self.rightover = []
	
	# helper to set the big text item at the bottom of the dialog.
	def settextitem(self, text):
		tp, h, rect = self.wid.GetDialogItem(MAIN_TEXT)
		Dlg.SetDialogItemText(h, text[:255])
	
	def do_rawupdate(self, window, event):
		Qd.SetPort(self.wid)
		iType, iHandle, iRect = window.GetDialogItem(MAIN_LINE)
		Qd.FrameRect(iRect)
		for list in self.lists:
			Qd.FrameRect(list.rect)
			if list.active:
				# see MyList.drawframe
				rect2 = Qd.InsetRect(list.rect, -3, -3)
				save = Qd.GetPenState()
				Qd.PenSize(2, 2)
				Qd.FrameRect(rect2)
				Qd.SetPenState(save)
		for list in self.lists:
			list.list.LUpdate(self.wid.GetWindowPort().visRgn)
		
	def do_activate(self, activate, event):
		for list in self.lists:
			list.list.LActivate(activate)
		
	# scroll everything one 'unit' to the left
	# XXX I don't like the way this works. Too many 'manual' assignments
	def do_rightbutton(self, force = 0):
		if not force and self.rightover == []:
			return
		self.scroll(-1)
		point = (0, 0)
		ok, point = self.lists[0].list.LGetSelect(1, point)
		self.leftover.append((point, self.lists[0].content, self.lists[0].title, self.lists[0].active))
		for i in range(len(self.lists)-1):
			point = (0, 0)
			ok, point = self.lists[i+1].list.LGetSelect(1, point)
			self.lists[i].setcontent(self.lists[i+1].content, self.lists[i+1].title)
			self.lists[i].list.LSetSelect(ok, point)
			self.lists[i].list.LAutoScroll()
			self.lists[i].active = self.lists[i+1].active
			self.lists[i].drawframe()
		if len(self.rightover) > 0:
			point, content, title, active = self.rightover[-1]
			self.lists[-1].setcontent(content, title)
			self.lists[-1].list.LSetSelect(1, point)
			self.lists[-1].list.LAutoScroll()
			self.lists[-1].active = active
			self.lists[-1].drawframe()
			del self.rightover[-1]
		else:
			self.lists[-1].setcontent(None)
			self.lists[-1].active = 0
		for list in self.lists:
			list.drawframe()
	
	# scroll everything one 'unit' to the right
	def do_leftbutton(self):
		if self.leftover == []:
			return
		self.scroll(1)
		if self.lists[-1].content <> None:
			point = (0, 0)
			ok, point = self.lists[-1].list.LGetSelect(1, point)
			self.rightover.append((point, self.lists[-1].content, self.lists[-1].title, self.lists[-1].active ))
		for i in range(len(self.lists)-1, 0, -1):
			point = (0, 0)
			ok, point = self.lists[i-1].list.LGetSelect(1, point)
			self.lists[i].setcontent(self.lists[i-1].content, self.lists[i-1].title)
			self.lists[i].list.LSetSelect(ok, point)
			self.lists[i].list.LAutoScroll()
			self.lists[i].active = self.lists[i-1].active
			self.lists[i].drawframe()
		if len(self.leftover) > 0:
			point, content, title, active = self.leftover[-1]
			self.lists[0].setcontent(content, title)
			self.lists[0].list.LSetSelect(1, point)
			self.lists[0].list.LAutoScroll()
			self.lists[0].active = active
			self.lists[0].drawframe()
			del self.leftover[-1]
		else:
			self.lists[0].setcontent(None)
			self.lists[0].active = 0
	
	# create some visual feedback when 'scrolling' the lists to the left or to the right
	def scroll(self, leftright):	# leftright should be 1 or -1
		# first, build a region containing all list rectangles
		myregion = Qd.NewRgn()
		mylastregion = Qd.NewRgn()
		for list in self.lists:
			AddRect2Rgn(list.rect, myregion)
			AddRect2Rgn(list.rect, mylastregion)
		# set the pen, but save it's state first
		self.SetPort()
		save = Qd.GetPenState()
		Qd.PenPat(Qd.qd.gray)
		Qd.PenMode(srcXor)
		# how far do we have to scroll?
		distance = self.lists[1].rect[0] - self.lists[0].rect[0]
		step = 30
		lasttime = time.clock()	# for delay
		# do it
		for i in range(0, distance, step):
			if i <> 0:
				Qd.FrameRgn(mylastregion)	# erase last region
				Qd.OffsetRgn(mylastregion, step * leftright, 0)
			# draw gray region
			Qd.FrameRgn(myregion)
			Qd.OffsetRgn(myregion, step * leftright, 0)
			while time.clock() - lasttime < 0.05:
				pass	# delay
			lasttime = time.clock()
		# clean up after your dog
		Qd.FrameRgn(mylastregion)
		Qd.SetPenState(save)
	
	def reset(self):
		for list in self.lists:
			point = (0,0)
			ok, point = list.list.LGetSelect(1, point)
			if ok:
				sel = list.keylist[point[1]]
			list.setcontent(list.content, list.title)
			if ok:
				list.list.LSetSelect(1, (0, list.keylist.index(sel)))
				list.list.LAutoScroll()
	
	def do_itemhit(self, item, event):
		if item in self.listitems:
			self.do_listhit(event, item)
		elif item == MAIN_LEFT:
			self.do_leftbutton()
		elif item == MAIN_RIGHT:
			self.do_rightbutton()
		elif item == MAIN_CLOSE:
			self.close()
		elif item == MAIN_RESET:
			self.reset()

# helper function that returns a short string containing the type of an arbitrary object
# eg: cleantype("wat is dit nu weer?") -> '(string)'
def cleantype(obj):
	# type() typically returns something like: <type 'string'>
	items = string.split(str(type(obj)), "'")
	if len(items) == 3:
		return '(' + items[1] + ')'
	else:
		# just in case, I don't know.
		return str(type(obj))
	
# helper for VarBrowser.scroll
def AddRect2Rgn(theRect, theRgn):
	rRgn = Qd.NewRgn()
	Qd.RectRgn(rRgn, theRect)
	Qd.UnionRgn(rRgn, theRgn, theRgn)


if __name__ == "__main__":
	main()