import W
import Wkeys
import struct
import string
import types
import re
from Carbon import Qd, Icn, Fm, QuickDraw
from Carbon.QuickDraw import hilitetransfermode


nullid = '\0\0'
closedid = struct.pack('h', 468)
openid = struct.pack('h', 469)
closedsolidid = struct.pack('h', 470)
opensolidid = struct.pack('h', 471)

arrows = (nullid, closedid, openid, closedsolidid, opensolidid)

has_ctlcharsRE = re.compile(r'[\000-\037\177-\377]')
def ctlcharsREsearch(str):
	if has_ctlcharsRE.search(str) is None:
		return -1
	return 1
	
def double_repr(key, value, truncvalue = 0, 
			type = type, StringType = types.StringType,
			has_ctlchars = ctlcharsREsearch, _repr = repr, str = str):
	if type(key) == StringType and has_ctlchars(key) < 0:
		key = str(key)
	else:
		key = _repr(key)
	if key == '__builtins__':
		value = "<" + type(value).__name__ + " '__builtin__'>"
	elif key == '__return__':
		# bleh, when returning from a class codeblock we get infinite recursion in repr. 
		# Use safe repr instead.
		import repr
		value = repr.repr(value)
	else:
		try:
			value = _repr(value)
			'' + value	# test to see if it is a string, in case a __repr__ method is buggy
		except:
			value = '\xa5\xa5\xa5 exception in repr()'
	if truncvalue:
		return key + '\t' + value[:255]
	return key + '\t' + value


def truncString(s, maxwid):
	if maxwid < 1:
		return 1, ""
	strlen = len(s)
	strwid = Qd.TextWidth(s, 0, strlen);
	if strwid <= maxwid:
		return 0, s
	
	Qd.TextFace(QuickDraw.condense)
	strwid = Qd.TextWidth(s, 0, strlen)
	ellipsis = Qd.StringWidth('\xc9')
	
	if strwid <= maxwid:
		Qd.TextFace(0)
		return 1, s
	if strwid < 1:
		Qd.TextFace(0)
		return 1, ""
	
	mid = int(strlen * maxwid / strwid)
	while 1:
		if mid <= 0:
			mid = 0
			break
		strwid = Qd.TextWidth(s, 0, mid) + ellipsis
		strwid2 = Qd.TextWidth(s, 0, mid + 1) + ellipsis
		if strwid <= maxwid and maxwid <= strwid2:
			if maxwid == strwid2:
				mid += 1
			break
		if strwid > maxwid:
			mid -= 1
			if mid <= 0:
				mid = 0
				break
		elif strwid2 < maxwid:
			mid += 1
	Qd.TextFace(0)
	return 1, s[:mid] + '\xc9'


def drawTextCell(text, cellRect, ascent, theList):
	l, t, r, b = cellRect
	cellwidth = r - l
	Qd.MoveTo(int(l + 2), int(t + ascent))
	condense, text = truncString(text, cellwidth - 3)
	if condense:
		Qd.TextFace(QuickDraw.condense)
	Qd.DrawText(text, 0, len(text))
	Qd.TextFace(0)


PICTWIDTH = 16


class BrowserWidget(W.CustomList):
	
	def __init__(self, possize, object = None, col = 100, closechildren = 0):
		W.List.__init__(self, possize, callback = self.listhit)
		self.object = (None,)
		self.indent = 16
		self.lastmaxindent = 0
		self.closechildren = closechildren
		self.children = []
		self.mincol = 64
		self.setcolumn(col)
		self.bind('return', self.openselection)
		self.bind('enter', self.openselection)
		if object is not None:
			self.set(object)
	
	def set(self, object):
		if self.object[0] is not object:
			self.object = object,
			self[:] = self.unpack(object, 0)
		elif self._parentwindow is not None and self._parentwindow.wid:
			self.update()
	
	def unpack(self, object, indent):
		return unpack_object(object, indent)
	
	def update(self):
		# for now...
		W.SetCursor('watch')
		self.setdrawingmode(0)
		sel = self.getselectedobjects()
		fold = self.getunfoldedobjects()
		topcell = self.gettopcell()
		self[:] = self.unpack(self.object[0], 0)
		self.unfoldobjects(fold)
		self.setselectedobjects(sel)
		self.settopcell(topcell)
		self.setdrawingmode(1)
	
	def setcolumn(self, col):
		self.col = col
		self.colstr = struct.pack('h', col)
		if self._list:
			sel = self.getselection()
			self.setitems(self.items)
			self.setselection(sel)
	
	def key(self, char, event):
		if char in (Wkeys.leftarrowkey, Wkeys.rightarrowkey):
			sel = self.getselection()
			sel.reverse()
			self.setdrawingmode(0)
			for index in sel:
				self.fold(index, char == Wkeys.rightarrowkey)
			self.setdrawingmode(1)
		else:
			W.List.key(self, char, event)
	
	def rollover(self, (x, y), onoff):
		if onoff:
			if self.incolumn((x, y)):
				W.SetCursor('hmover')
			else:
				W.SetCursor('arrow')
	
	def inarrow(self, (x, y)):
		cl, ct, cr, cb = self._list.LRect((0, 0))
		l, t, r, b = self._bounds
		if (x - cl) < 16:
			cellheight = cb - ct
			index = (y - ct) / cellheight
			if index < len(self.items):
				return 1, index
		return None, None
	
	def incolumn(self, (x, y)):
		l, t, r, b = self._list.LRect((0, 0))
		abscol = l + self.col
		return abs(abscol - x) < 3
	
	def trackcolumn(self, (x, y)):
		from Carbon import Qd, QuickDraw, Evt
		self.SetPort()
		l, t, r, b = self._bounds
		bounds = l, t, r, b = l + 1, t + 1, r - 16, b - 1
		abscol = l + self.col
		mincol = l + self.mincol
		maxcol = r - 10
		diff = abscol - x
		Qd.PenPat('\000\377\000\377\000\377\000\377')
		Qd.PenMode(QuickDraw.srcXor)
		rect = abscol - 1, t, abscol, b
		Qd.PaintRect(rect)
		lastpoint = (x, y)
		newcol = -1
		#W.SetCursor('fist')
		while Evt.Button():
			Evt.WaitNextEvent(0, 1, None)  # needed for OSX
			(x, y) = Evt.GetMouse()
			if (x, y) <> lastpoint:
				newcol = x + diff
				newcol = max(newcol, mincol)
				newcol = min(newcol, maxcol)
				Qd.PaintRect(rect)
				rect = newcol - 1, t, newcol, b
				Qd.PaintRect(rect)
				lastpoint = (x, y)
		Qd.PaintRect(rect)
		Qd.PenPat(Qd.GetQDGlobalsBlack())
		Qd.PenNormal()
		if newcol > 0 and newcol <> abscol:
			self.setcolumn(newcol - l)
	
	def click(self, point, modifiers):
		if point == (-1, -1):	# gross.
			W.List.click(self, point ,modifiers)
			return
		hit, index = self.inarrow(point)
		if hit:
			(key, value, arrow, indent) = self.items[index]
			self.fold(index, arrow == 1)
		elif self.incolumn(point):
			self.trackcolumn(point)
		else:
			W.List.click(self, point, modifiers)
	
	# for W.List.key
	def findmatch(self, tag):
		lower = string.lower
		items = self.items
		taglen = len(tag)
		match = '\377' * 100
		match_i = -1
		for i in range(len(items)):
			item = lower(str(items[i][0]))
			if tag <= item < match:
				match = item
				match_i = i
		if match_i >= 0:
			return match_i
		else:
			return len(items) - 1
	
	def close(self):
		if self.closechildren:
			for window in self.children:
				window.close()
		self.children = []
		W.List.close(self)
	
	def fold(self, index, onoff):
		(key, value, arrow, indent) = self.items[index]
		if arrow == 0 or (onoff and arrow == 2) or (not onoff and arrow == 1):
			return
		W.SetCursor('watch')
		topcell = self.gettopcell()
		if onoff:
			self[index] = (key, value, 4, indent)
			self.setdrawingmode(0)
			self[index+1:index+1] = self.unpack(value, indent + 1)
			self[index] = (key, value, 2, indent)
		else:
			self[index] = (key, value, 3, indent)
			self.setdrawingmode(0)
			count = 0
			for i in range(index + 1, len(self.items)):
				(dummy, dummy, dummy, subindent) = self.items[i]
				if subindent <= indent:
					break
				count = count + 1
			self[index+1:index+1+count] = []
			self[index] = (key, value, 1, indent)
		maxindent = self.getmaxindent()
		if maxindent <> self.lastmaxindent:
			newabsindent = self.col + (maxindent - self.lastmaxindent) * self.indent
			if newabsindent >= self.mincol:
				self.setcolumn(newabsindent)
			self.lastmaxindent = maxindent
		self.settopcell(topcell)
		self.setdrawingmode(1)
	
	def unfoldobjects(self, objects):
		for obj in objects:
			try:
				index = self.items.index(obj)
			except ValueError:
				pass
			else:
				self.fold(index, 1)
	
	def getunfoldedobjects(self):
		curindent = 0
		objects = []
		for index in range(len(self.items)):
			(key, value, arrow, indent) = self.items[index]
			if indent > curindent:
				(k, v, a, i) = self.items[index - 1]
				objects.append((k, v, 1, i))
				curindent = indent
			elif indent < curindent:
				curindent = indent
		return objects
	
	def listhit(self, isdbl):
		if isdbl:
			self.openselection()
	
	def openselection(self):
		import os
		sel = self.getselection()
		for index in sel:
			(key, value, arrow, indent) = self[index]
			if arrow:
				self.children.append(Browser(value))
			elif type(value) == types.StringType and '\0' not in value:
				editor = self._parentwindow.parent.getscript(value)
				if editor:
					editor.select()
					return
				elif os.path.exists(value) and os.path.isfile(value):
					if MacOS.GetCreatorAndType(value)[1] in ('TEXT', '\0\0\0\0'):
						W.getapplication().openscript(value)
	
	def itemrepr(self, (key, value, arrow, indent), str = str, double_repr = double_repr, 
			arrows = arrows, pack = struct.pack):
		arrow = arrows[arrow]
		return arrow + pack('h', self.indent * indent) + self.colstr + \
				double_repr(key, value, 1)
	
	def getmaxindent(self, max = max):
		maxindent = 0
		for item in self.items:
			maxindent = max(maxindent, item[3])
		return maxindent
	
	def domenu_copy(self, *args):
		sel = self.getselectedobjects()
		selitems = []
		for key, value, dummy, dummy in sel:
			selitems.append(double_repr(key, value))
		text = string.join(selitems, '\r')
		if text:
			from Carbon import Scrap
			if hasattr(Scrap, 'PutScrap'):
				Scrap.ZeroScrap()
				Scrap.PutScrap('TEXT', text)
			else:
				Scrap.ClearCurrentScrap()
				sc = Scrap.GetCurrentScrap()
				sc.PutScrapFlavor('TEXT', 0, text)

	def listDefDraw(self, selected, cellRect, theCell, 
			dataOffset, dataLen, theList):
		self.myDrawCell(0, selected, cellRect, theCell, 
			dataOffset, dataLen, theList)
	
	def listDefHighlight(self, selected, cellRect, theCell, 
			dataOffset, dataLen, theList):
		self.myDrawCell(1, selected, cellRect, theCell, 
			dataOffset, dataLen, theList)
	
	def myDrawCell(self, onlyHilite, selected, cellRect, theCell, 
			dataOffset, dataLen, theList):
		savedPort = Qd.GetPort()
		Qd.SetPort(theList.GetListPort())
		savedClip = Qd.NewRgn()
		Qd.GetClip(savedClip)
		Qd.ClipRect(cellRect)
		savedPenState = Qd.GetPenState()
		Qd.PenNormal()
		
		l, t, r, b = cellRect
		
		if not onlyHilite:
			Qd.EraseRect(cellRect)
			
			ascent, descent, leading, size, hm = Fm.FontMetrics()
			linefeed = ascent + descent + leading
			
			if dataLen >= 6:
				data = theList.LGetCell(dataLen, theCell)
				iconId, indent, tab = struct.unpack("hhh", data[:6])
				try:
					key, value = data[6:].split("\t", 1)
				except ValueError:
					# bogus data, at least don't crash.
					indent = 0
					tab = 0
					iconId = 0
					key = ""
					value = data[6:]
				
				if iconId:
					try:
						theIcon = Icn.GetCIcon(iconId)
					except Icn.Error:
						pass
					else:
						rect = (0, 0, 16, 16)
						rect = Qd.OffsetRect(rect, l, t)
						rect = Qd.OffsetRect(rect, 0, (theList.cellSize[1] - (rect[3] - rect[1])) / 2)
						Icn.PlotCIcon(rect, theIcon)
				
				if len(key) >= 0:
					cl, ct, cr, cb = cellRect
					vl, vt, vr, vb = self._viewbounds
					cl = vl + PICTWIDTH + indent
					cr = vl + tab
					if cr > vr:
						cr = vr
					if cl < cr:
						drawTextCell(key, (cl, ct, cr, cb), ascent, theList)
					cl = vl + tab
					cr = vr
					if cl < cr:
						drawTextCell(value, (cl, ct, cr, cb), ascent, theList)
			#elif dataLen != 0:
			#	drawTextCell("???", 3, cellRect, ascent, theList)
			else:
				return  # we have bogus data
			
			# draw nice dotted line
			l, t, r, b = cellRect
			l = self._viewbounds[0] + tab
			r = l + 1;
			if not (theList.cellSize[1] & 0x01) or (t & 0x01):
				myPat = "\xff\x00\xff\x00\xff\x00\xff\x00"
			else:
				myPat = "\x00\xff\x00\xff\x00\xff\x00\xff"
			Qd.PenPat(myPat)
			Qd.PenMode(QuickDraw.srcCopy)
			Qd.PaintRect((l, t, r, b))
			Qd.PenNormal()
		
		if selected or onlyHilite:
			l, t, r, b = cellRect
			l = self._viewbounds[0] + PICTWIDTH
			r = self._viewbounds[2]
			Qd.PenMode(hilitetransfermode)
			Qd.PaintRect((l, t, r, b))
		
		# restore graphics environment
		Qd.SetPort(savedPort)
		Qd.SetClip(savedClip)
		Qd.DisposeRgn(savedClip)
		Qd.SetPenState(savedPenState)



class Browser:
	
	def __init__(self, object = None, title = None, closechildren = 0):
		if hasattr(object, '__name__'):
			name = object.__name__
		else:
			name = ''
		if title is None:
			title = 'Object browser'
			if name:
				title = title + ': ' + name
		self.w = w = W.Window((300, 400), title, minsize = (100, 100))
		w.info = W.TextBox((18, 8, -70, 15))
		w.updatebutton = W.BevelButton((-64, 4, 50, 16), 'Update', self.update)
		w.browser = BrowserWidget((-1, 24, 1, -14), None)
		w.bind('cmdu', w.updatebutton.push)
		w.open()
		self.set(object, name)
	
	def close(self):
		if self.w.wid:
			self.w.close()
	
	def set(self, object, name = ''):
		W.SetCursor('watch')
		tp = type(object).__name__
		try:
			length = len(object)
		except:
			length = -1
		if not name and hasattr(object, '__name__'):
			name = object.__name__
		if name:
			info = name + ': ' + tp
		else:
			info = tp
		if length >= 0:
			if length == 1:
				info = info + ' (%d element)' % length
			else:
				info = info + ' (%d elements)' % length
		self.w.info.set(info)
		self.w.browser.set(object)
	
	def update(self):
		self.w.browser.update()


SIMPLE_TYPES = (
	type(None),
	int,
	long,
	float,
	complex,
	str,
	unicode,
)

def get_ivars(obj):
	"""Return a list the names of all (potential) instance variables."""
	# __mro__ recipe from Guido
	slots = {}
	# old-style C objects
	if hasattr(obj, "__members__"):
		for name in obj.__members__:
			slots[name] = None
	if hasattr(obj, "__methods__"):
		for name in obj.__methods__:
			slots[name] = None
	# generic type
	if hasattr(obj, "__dict__"):
		slots.update(obj.__dict__)
	cls = type(obj)
	if hasattr(cls, "__mro__"):
		# new-style class, use descriptors
		for base in cls.__mro__:
			for name, value in base.__dict__.items():
				# XXX using callable() is a heuristic which isn't 100%
				# foolproof.
				if hasattr(value, "__get__") and not callable(value):
					slots[name] = None
	if "__dict__" in slots:
		del slots["__dict__"]
	slots = slots.keys()
	slots.sort()
	return slots

def unpack_object(object, indent = 0):
	tp = type(object)
	if isinstance(object, SIMPLE_TYPES) and object is not None:
		raise TypeError, "can't browse simple type: %s" % tp.__name__
	elif isinstance(object, dict):
		return unpack_dict(object, indent)
	elif isinstance(object, (tuple, list)):
		return unpack_sequence(object, indent)
	elif isinstance(object, types.ModuleType):
		return unpack_dict(object.__dict__, indent)
	else:
		return unpack_other(object, indent)

def unpack_sequence(seq, indent = 0):
	return [(i, v, not isinstance(v, SIMPLE_TYPES), indent)
	         for i, v in enumerate(seq)]

def unpack_dict(dict, indent = 0):
	items = dict.items()
	return pack_items(items, indent)

def unpack_instance(inst, indent = 0):
	if hasattr(inst, '__pybrowse_unpack__'):
		return unpack_object(inst.__pybrowse_unpack__(), indent)
	else:
		items = [('__class__', inst.__class__)] + inst.__dict__.items()
		return pack_items(items, indent)

def unpack_class(clss, indent = 0):
	items = [('__bases__', clss.__bases__), ('__name__', clss.__name__)] + clss.__dict__.items()
	return pack_items(items, indent)

def unpack_other(object, indent = 0):
	attrs = get_ivars(object)
	items = []
	for attr in attrs:
		try:
			value = getattr(object, attr)
		except:
			pass
		else:
			items.append((attr, value))
	return pack_items(items, indent)

def pack_items(items, indent = 0):
	items = [(k, v, not isinstance(v, SIMPLE_TYPES), indent)
	         for k, v in items]
	return tuple_caselesssort(items)

def caselesssort(alist):
	"""Return a sorted copy of a list. If there are only strings in the list, 
	it will not consider case"""
	
	try:
		# turn ['FOO',  'aaBc', 'ABcD'] into [('foo', 'FOO'), ('aabc', 'aaBc'), ('abcd', 'ABcD')], if possible
		tupledlist = map(lambda item, lower = string.lower: (lower(item), item), alist)
	except TypeError:
		# at least one element in alist is not a string, proceed the normal way...
		alist = alist[:]
		alist.sort()
		return alist
	else:
		tupledlist.sort()
		# turn [('aabc', 'aaBc'), ('abcd', 'ABcD'), ('foo', 'FOO')] into ['aaBc', 'ABcD', 'FOO']
		return map(lambda x: x[1], tupledlist)

def tuple_caselesssort(items):
	try:
		tupledlist = map(lambda tuple, lower = string.lower: (lower(tuple[0]), tuple), items)
	except (AttributeError, TypeError):
		items = items[:]
		items.sort()
		return items
	else:
		tupledlist.sort()
		return map(lambda (low, tuple): tuple, tupledlist)