import Wbase
import Wkeys
import string
from Carbon import Evt, Events, Fm, Lists, Qd, Scrap, Win
from Carbon.List import LNew, CreateCustomList
from Carbon.Lists import kListDefUserProcType, lInitMsg, lDrawMsg, lHiliteMsg, lCloseMsg
from Carbon.QuickDraw import hilitetransfermode
from Carbon import App
from Carbon.Appearance import kThemeStateActive, kThemeStateInactive, kThemeStatePressed


class List(Wbase.SelectableWidget):
	
	"""Standard list widget."""
	
	LDEF_ID = 0
	
	def __init__(self, possize, items = None, callback = None, flags = 0, cols = 1, typingcasesens=0):
		if items is None:
			items = []
		self.items = items
		Wbase.SelectableWidget.__init__(self, possize)
		self._selected = 0
		self._enabled = 1
		self._list = None
		self._cols = cols
		self._callback = callback
		self._flags = flags
		self.typingcasesens = typingcasesens
		self.lasttyping = ""
		self.lasttime = Evt.TickCount()
		self.timelimit = 30
		self.setitems(items)
		self.drawingmode = 0
	
	def open(self):
		self.setdrawingmode(0)
		self.createlist()
		self.setdrawingmode(1)
	
	def createlist(self):
		self._calcbounds()
		self.SetPort()
		rect = self._bounds
		rect = rect[0]+1, rect[1]+1, rect[2]-16, rect[3]-1
		self._viewbounds = rect
		self._list = LNew(rect, (0, 0, self._cols, 0), (0, 0), self.LDEF_ID, self._parentwindow.wid,
					0, 1, 0, 1)
		if self.drawingmode:
			self._list.LSetDrawingMode(0)
		self._list.selFlags = self._flags
		self.setitems(self.items)
		if hasattr(self, "_sel"):
			self.setselection(self._sel)
			del self._sel
	
	def adjust(self, oldbounds):
		self.SetPort()
		# Appearance frames are drawn outside the specified bounds,
		# so we always need to outset the invalidated area.
		self.GetWindow().InvalWindowRect(Qd.InsetRect(oldbounds, -3, -3))
		self.GetWindow().InvalWindowRect(Qd.InsetRect(self._bounds, -3, -3))

		if oldbounds[:2] == self._bounds[:2]:
			# set visRgn to empty, to prevent nasty drawing side effect of LSize()
			Qd.RectRgn(self._parentwindow.wid.GetWindowPort().visRgn, (0, 0, 0, 0))
			# list still has the same upper/left coordinates, use LSize
			l, t, r, b = self._bounds
			width = r - l - 17
			height = b - t - 2
			vl, vt, vr, vb = self._viewbounds
			self._viewbounds = vl, vt, vl + width, vt + height
			self._list.LSize(width, height)
			# now *why* doesn't the list manager recalc the cellrect???
			l, t, r, b = self._list.LRect((0,0))
			cellheight = b - t
			self._list.LCellSize((width, cellheight))
			# reset visRgn
			self._parentwindow.wid.CalcVis()
		else:
			# oh well, since the list manager doesn't have a LMove call,
			# we have to make the list all over again...
			sel = self.getselection()
			topcell = self.gettopcell()
			self._list = None
			self.setdrawingmode(0)
			self.createlist()
			self.setselection(sel)
			self.settopcell(topcell)
			self.setdrawingmode(1)
	
	def close(self):
		self._list = None
		self._callback = None
		self.items = []
		Wbase.SelectableWidget.close(self)
	
	def set(self, items):
		self.setitems(items)
	
	def setitems(self, items):
		self.items = items
		the_list = self._list
		if not self._parent or not self._list:
			return
		self.setdrawingmode(0)
		topcell = self.gettopcell()
		the_list.LDelRow(0, 1)
		the_list.LAddRow(len(self.items), 0)
		self_itemrepr = self.itemrepr
		set_cell = the_list.LSetCell
		for i in range(len(items)):
			set_cell(self_itemrepr(items[i]), (0, i))
		self.settopcell(topcell)
		self.setdrawingmode(1)
	
	def click(self, point, modifiers):
		if not self._enabled:
			return
		isdoubleclick = self._list.LClick(point, modifiers)
		if self._callback:
			Wbase.CallbackCall(self._callback, 0, isdoubleclick)
		return 1
	
	def key(self, char, event):
		(what, message, when, where, modifiers) = event
		sel = self.getselection()
		newselection = []
		if char == Wkeys.uparrowkey:
			if len(sel) >= 1 and min(sel) > 0:
				newselection = [min(sel) - 1]
			else:
				newselection = [0]
		elif char == Wkeys.downarrowkey:
			if len(sel) >= 1 and max(sel) < (len(self.items) - 1):
					newselection = [max(sel) + 1]
			else:
				newselection = [len(self.items) - 1]
		else:
			modifiers = 0
			if (self.lasttime + self.timelimit) < Evt.TickCount():
				self.lasttyping = ""
			if self.typingcasesens:
				self.lasttyping = self.lasttyping + char
			else:
				self.lasttyping = self.lasttyping + string.lower(char)
			self.lasttime = Evt.TickCount()
			i = self.findmatch(self.lasttyping)
			newselection = [i]
		if modifiers & Events.shiftKey and not self._list.selFlags & Lists.lOnlyOne:
			newselection = newselection + sel
		self.setselection(newselection)
		self._list.LAutoScroll()
		self.click((-1, -1), 0)
	
	def findmatch(self, tag):
		lower = string.lower
		items = self.items
		typingcasesens = self.typingcasesens
		taglen = len(tag)
		match = '\377' * 100
		match_i = -1
		for i in range(len(items)):
			item = str(items[i])
			if not typingcasesens:
				item = lower(item)
			if tag <= item < match:
				match = item
				match_i = i
		if match_i >= 0:
			return match_i
		else:
			return len(items) - 1
	
	def domenu_copy(self, *args):
		sel = self.getselection()
		selitems = []
		for i in sel:
			selitems.append(str(self.items[i]))
		text = string.join(selitems, '\r')
		if text:
			if hasattr(Scrap, 'PutScrap'):
				Scrap.ZeroScrap()
				Scrap.PutScrap('TEXT', text)
			else:
				Scrap.ClearCurrentScrap()
				sc = Scrap.GetCurrentScrap()
				sc.PutScrapFlavor('TEXT', 0, text)
	
	def can_copy(self, *args):
		return len(self.getselection()) <> 0
	
	def domenu_selectall(self, *args):
		self.selectall()
	
	def can_selectall(self, *args):
		return not self._list.selFlags & Lists.lOnlyOne
	
	def selectall(self):
		if not self._list.selFlags & Lists.lOnlyOne:
			self.setselection(range(len(self.items)))
			self._list.LAutoScroll()
			self.click((-1, -1), 0)
	
	def getselection(self):
		if not self._parent or not self._list:
			if hasattr(self, "_sel"):
				return self._sel
			return []
		items = []
		point = (0,0)
		while 1:
			ok, point = self._list.LGetSelect(1, point)
			if not ok:
				break
			items.append(point[1])
			point = point[0], point[1]+1
		return items
	
	def setselection(self, selection):
		if not self._parent or not self._list:
			self._sel = selection
			return
		set_sel = self._list.LSetSelect
		for i in range(len(self.items)):
			if i in selection:
				set_sel(1, (0, i))
			else:
				set_sel(0, (0, i))
		self._list.LAutoScroll()
	
	def getselectedobjects(self):
		sel = self.getselection()
		objects = []
		for i in sel:
			objects.append(self.items[i])
		return objects
	
	def setselectedobjects(self, objects):
		sel = []
		for o in objects:
			try:
				sel.append(self.items.index(o))
			except:
				pass
		self.setselection(sel)
	
	def gettopcell(self):
		l, t, r, b = self._bounds
		t = t + 1
		cl, ct, cr, cb = self._list.LRect((0, 0))
		cellheight = cb - ct
		return (t - ct) / cellheight
	
	def settopcell(self, topcell):
		top = self.gettopcell()
		diff = topcell - top
		self._list.LScroll(0, diff)
	
	def draw(self, visRgn = None):
		if self._visible:
			if not visRgn:
				visRgn = self._parentwindow.wid.GetWindowPort().visRgn
			self._list.LUpdate(visRgn)
			state = [kThemeStateActive, kThemeStateInactive][not self._activated]
			App.DrawThemeListBoxFrame(Qd.InsetRect(self._bounds, 1, 1), state)
			if self._selected and self._activated:
				self.drawselframe(1)
	
	def select(self, onoff, isclick = 0):
		if Wbase.SelectableWidget.select(self, onoff):
			return
		self.SetPort()
		self.drawselframe(onoff)
	
	def activate(self, onoff):
		self._activated = onoff
		if self._visible:
			self._list.LActivate(onoff)
			#state = [kThemeStateActive, kThemeStateInactive][not onoff]
			#App.DrawThemeListBoxFrame(Qd.InsetRect(self._bounds, 1, 1), state)
			if self._selected:
				self.drawselframe(onoff)
	
	def get(self):
		return self.items
	
	def itemrepr(self, item):
		return str(item)[:255]
	
	def __getitem__(self, index):
		return self.items[index]
	
	def __setitem__(self, index, item):
		if self._parent and self._list:
			self._list.LSetCell(self.itemrepr(item), (0, index))
		self.items[index] = item
	
	def __delitem__(self, index):
		if self._parent and self._list:
			self._list.LDelRow(1, index)
		del self.items[index]
	
	def __getslice__(self, a, b):
		return self.items[a:b]
	
	def __delslice__(self, a, b):
		if b-a:
			if self._parent and self._list:
				self._list.LDelRow(b-a, a)
			del self.items[a:b]
	
	def __setslice__(self, a, b, items):
		if self._parent and self._list:
			l = len(items)
			the_list = self._list
			self.setdrawingmode(0)
			if b-a:
				if b > len(self.items):
					# fix for new 1.5 "feature" where b is sys.maxint instead of len(self)...
					# LDelRow doesn't like maxint.
					b = len(self.items)
				the_list.LDelRow(b-a, a)
			the_list.LAddRow(l, a)
			self_itemrepr = self.itemrepr
			set_cell = the_list.LSetCell
			for i in range(len(items)):
				set_cell(self_itemrepr(items[i]), (0, i + a))
			self.items[a:b] = items
			self.setdrawingmode(1)
		else:
			self.items[a:b] = items
	
	def __len__(self):
		return len(self.items)
	
	def append(self, item):
		if self._parent and self._list:
			index = len(self.items)
			self._list.LAddRow(1, index)
			self._list.LSetCell(self.itemrepr(item), (0, index))
		self.items.append(item)
	
	def remove(self, item):
		index = self.items.index(item)
		self.__delitem__(index)
	
	def index(self, item):
		return self.items.index(item)
	
	def insert(self, index, item):
		if index < 0:
			index = 0
		if self._parent and self._list:
			self._list.LAddRow(1, index)
			self._list.LSetCell(self.itemrepr(item), (0, index))
		self.items.insert(index, item)
	
	def setdrawingmode(self, onoff):
		if onoff:
			self.drawingmode = self.drawingmode - 1
			if self.drawingmode == 0 and self._list is not None:
				self._list.LSetDrawingMode(1)
				if self._visible:
					bounds = l, t, r, b = Qd.InsetRect(self._bounds, 1, 1)
					cl, ct, cr, cb = self._list.LRect((0, len(self.items)-1))
					if cb < b:
						self.SetPort()
						Qd.EraseRect((l, cb, cr, b))
					self._list.LUpdate(self._parentwindow.wid.GetWindowPort().visRgn)
					self.GetWindow().ValidWindowRect(bounds)
		else:
			if self.drawingmode == 0 and self._list is not None:
				self._list.LSetDrawingMode(0)
			self.drawingmode = self.drawingmode + 1


class CustomList(List):
	
	"""Base class for writing custom list definitions."""
	
	_cellHeight = 0
	
	def createlist(self):
		self._calcbounds()
		self.SetPort()
		rect = self._bounds
		rect = rect[0]+1, rect[1]+1, rect[2]-16, rect[3]-1
		self._viewbounds = rect
		self._list = CreateCustomList(
				rect,
				(0, 0, 1, 0),
				(0, self._cellHeight),
				(kListDefUserProcType, self.listDefinitionFunc),
				self._parentwindow.wid,
				0, 1, 0, 1)
		if self.drawingmode:
			self._list.LSetDrawingMode(0)
		self._list.selFlags = self._flags
		self.setitems(self.items)
		if hasattr(self, "_sel"):
			self.setselection(self._sel)
			del self._sel
	
	def listDefinitionFunc(self, message, selected, cellRect, theCell,
			dataOffset, dataLen, theList):
		"""The LDEF message dispatcher routine, no need to override."""
		if message == lInitMsg:
			self.listDefInit(theList)
		elif message == lDrawMsg:
			self.listDefDraw(selected, cellRect, theCell,
					dataOffset, dataLen, theList)
		elif message == lHiliteMsg:
			self.listDefHighlight(selected, cellRect, theCell,
					dataOffset, dataLen, theList)
		elif message == lCloseMsg:
			self.listDefClose(theList)
	
	def listDefInit(self, theList):
		pass
	def listDefClose(self, theList):
		pass
	def listDefDraw(self, selected, cellRect, theCell, 
			dataOffset, dataLen, theList):
		pass
	def listDefHighlight(self, selected, cellRect, theCell, 
			dataOffset, dataLen, theList):
		pass


class TwoLineList(CustomList):
	
	_cellHeight = 28
	
	def listDefDraw(self, 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()
		Qd.EraseRect(cellRect)
		
		#draw the cell if it contains data
		ascent, descent, leading, size, hm = Fm.FontMetrics()
		linefeed = ascent + descent + leading
		
		if dataLen:
			left, top, right, bottom = cellRect
			data = theList.LGetCell(dataLen, theCell)
			lines = data.split("\r")
			line1 = lines[0]
			if len(lines) > 1:
				line2 = lines[1]
			else:
				line2 = ""
			Qd.MoveTo(left + 4, top + ascent)
			Qd.DrawText(line1, 0, len(line1))
			if line2:
				Qd.MoveTo(left + 4, top + ascent + linefeed)
				Qd.DrawText(line2, 0, len(line2))
			Qd.PenPat("\x11\x11\x11\x11\x11\x11\x11\x11")
			bottom = top + theList.cellSize[1]
			Qd.MoveTo(left, bottom - 1)
			Qd.LineTo(right, bottom - 1)
		if selected:
			self.listDefHighlight(selected, cellRect, theCell,
					dataOffset, dataLen, theList)
		#restore graphics environment
		Qd.SetPort(savedPort)
		Qd.SetClip(savedClip)
		Qd.DisposeRgn(savedClip)
		Qd.SetPenState(savedPenState)
	
	def listDefHighlight(self, 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()
		Qd.PenMode(hilitetransfermode)
		Qd.PaintRect(cellRect)
		
		#restore graphics environment
		Qd.SetPort(savedPort)
		Qd.SetClip(savedClip)
		Qd.DisposeRgn(savedClip)
		Qd.SetPenState(savedPenState)
	

class ResultsWindow:
	
	"""Simple results window. The user cannot make this window go away completely:
	closing it will just hide it. It will remain in the windows list. The owner of this window
	should call the done() method to indicate it's done with it.
	"""
	
	def __init__(self, possize=None, title="Results", callback=None):
		import W
		if possize is None:
			possize = (500, 200)
		self.w = W.Window(possize, title, minsize=(200, 100))
		self.w.results = W.TwoLineList((-1, -1, 1, -14), callback=None)
		self.w.bind("<close>", self.hide)
		self.w.open()
		self._done = 0
	
	def done(self):
		self._done = 1
		if not self.w.isvisible():
			self.w.close()
	
	def hide(self):
		if not self._done:
			self.w.show(0)
			return -1
	
	def append(self, msg):
		if not self.w.isvisible():
			self.w.show(1)
			self.w.select()
		msg = string.replace(msg, '\n', '\r')
		self.w.results.append(msg)
		self.w.results.setselection([len(self.w.results)-1])
	
	def __getattr__(self, attr):
		return getattr(self.w.results, attr)


class MultiList(List):
	
	"""XXX Experimantal!!!"""
	
	def setitems(self, items):
		self.items = items
		if not self._parent or not self._list:
			return
		self._list.LDelRow(0, 1)
		self.setdrawingmode(0)
		self._list.LAddRow(len(self.items), 0)
		self_itemrepr = self.itemrepr
		set_cell = self._list.LSetCell
		for i in range(len(items)):
			row = items[i]
			for j in range(len(row)):
				item = row[j]
				set_cell(self_itemrepr(item), (j, i))
		self.setdrawingmode(1)
	
	def getselection(self):
		if not self._parent or not self._list:
			if hasattr(self, "_sel"):
				return self._sel
			return []
		items = []
		point = (0,0)
		while 1:
			ok, point = self._list.LGetSelect(1, point)
			if not ok:
				break
			items.append(point[1])
			point = point[0], point[1]+1
		return items
	
	def setselection(self, selection):
		if not self._parent or not self._list:
			self._sel = selection
			return
		set_sel = self._list.LSetSelect
		for i in range(len(self.items)):
			if i in selection:
				set_sel(1, (0, i))
			else:
				set_sel(0, (0, i))
		#self._list.LAutoScroll()