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/self._cols, 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(int(left + 4), int(top + ascent))
            Qd.DrawText(line1, 0, len(line1))
            if line2:
                Qd.MoveTo(int(left + 4), int(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)):
            for j in range(len(self.items[i])):
                if i in selection:
                    set_sel(1, (j, i))
                else:
                    set_sel(0, (j, i))
        #self._list.LAutoScroll()