from engine import *
import config
from zope.interface import implements, Interface
import weakref
from util import *

class Blinker(Token):
    def InitPersistent(self, owner, setter, rgVal = [True, False], interval = 500):
        Token.InitPersistent(self, owner)
        self.setter = setter
        self.rgVal = rgVal
        self.interval = interval
    def run(self):
        while True:
            for val in self.rgVal:
                self.setter(val)
                self.wait(self.interval)

class StaticGraphic(Token):
    def InitPersistent(self, owner, ascr, pos, *rgtag):
        Token.InitPersistent(self, owner)
        self.pos = pos
        self.tag("drawable", *rgtag)
        self.ascr = ascr
    def draw(self, ascr, client):
        ascr.PutAscr(self.ascr, self.pos[0], self.pos[1])


class AnimatedGraphic(StaticGraphic):
    def InitPersistent(self, owner, rgascr, pos, interval, *rgtag):
        StaticGraphic.InitPersistent(self, owner, rgascr[0], pos, *rgtag)
        Blinker(self, self.setAscr, rgascr, interval)
    def setAscr(self, ascr):
        self.ascr = ascr

class Terminal(Token):
    def InitPersistent(self, owner, client, w = config.W, h = config.H):
        Token.InitPersistent(self, owner, "drawable", "background")
        self.client = client
        self.x = 0
        self.y = 0
        self.w = w
        self.h = h
        self.fWrapHoriz = False
        self.fWrapVert = True
        self.stLine = None
        self.xLine = None
        self.yLine = None
        self.screen = []
        self.fBlink = False
        self.colBg = ansi.BLUE
        self.chEcho = None
        for y in range(h):
            self.screen.append("")
        Blinker(self, self.setBlink)

    def setBlink(self, fBlink):
        self.fBlink = fBlink

    def getKey(self):
        return self.client.evKey.receive(self)

    def getPrintableKey(self):
        while True:
            key = self.getKey()
            if ansi.FKeyPrintable(key):
                return key

    def deleteCh(self):
        stOld = self.screen[self.y]
        self.screen[self.y] = stOld[0:self.x] + stOld[self.x + 1:]

    def printSt(self, st):
        stOld = self.screen[self.y]
        stNew = stOld[0:self.x] + st + stOld[self.x+len(st):]
        self.screen[self.y] = stNew
        self.moveTo(self.x + len(st), self.y)

    def moveTo(self, x, y):
        self.x = x
        self.y = y
        while (self.x >= self.w):
            if (self.fWrapHoriz):
                self.y = self.y + 1
                self.x = self.x - self.w
            else:
                self.x = self.w - 1
        while (self.x < 0):
            self.y = self.y - 1
            self.x = self.x + self.w
            if (self.y < 0):
                self.y = 0
        while (self.fWrapVert and self.y >= self.h):
            self.screen = self.screen[1:]
            self.screen.append("")
            self.y = self.y - 1
        self.screen[self.y] = self.screen[self.y].ljust(self.x)

    def type(self, st):
        self.client.beep()
        for iSt in range(len(st)):
            self.printSt(st[iSt:iSt + 1])
            self.wait(35)

    def typeLn(self, st):
        self.type(st)
        self.newLine()

    def centerLn(self, st):
        self.typeLn(st.rjust((self.w / 2) + (len(st) / 2)))

    def getLine(self):
        self.xLine = self.x
        self.yLine = self.y
        self.stLine = ""

        fWrapHorizStart = self.fWrapHoriz
        self.fWrapHoriz = False
        while True:
            key = self.getKey()
            fBeep = True
            if (key == ansi.K_BACKSPACE and self.x > self.xLine):
                self.stLine = self.stLine[:self.x - self.xLine - 1] + self.stLine[self.x - self.xLine:]
                self.moveTo(self.x - 1, self.y)
            elif (key == ansi.K_LEFT and self.x > self.xLine):
                self.moveTo(self.x - 1, self.y)
            elif (key == ansi.K_RIGHT):
                self.moveTo(self.x + 1, self.y)
                if (self.x - self.xLine) > len(self.stLine):
                    self.stLine = self.stLine + " "
            elif (ansi.FKeyPrintable(key)):
                self.stLine = self.stLine[:self.x - self.xLine] + key + self.stLine[(self.x + 1) - self.xLine:]
                self.moveTo(self.x + 1, self.y)
            elif key == ansi.K_RETURN or key == ansi.K_NEWLINE:
                break
            else:
                print "weird key", ansi.StrKey(key)
                fBeep = False
            if fBeep:
                self.client.beep()
            self.fWrapHoriz = fWrapHorizStart

        x,y = self.x, self.y
        self.moveTo(self.xLine, self.yLine)
        self.printSt(self.StLineDisp())
        self.moveTo(x,y)

        stLine = self.stLine.strip()
        self.stLine = None
        self.xLine = None
        self.yLine = None
        return stLine

    def StLineDisp(self):
        return self.stLine if not self.chEcho else self.chEcho * len(self.stLine)
    def draw(self, ascr, client):
        if client == self.client:
            y = 1
            for line in self.screen:
                ascr.PutSt("{0:{1}}".format(line, self.w), 1, y, ansi.WHITE | ansi.FBRIGHT, self.colBg)
                y = y + 1
            if self.stLine:
                ascr.PutSt(self.StLineDisp(), self.xLine + 1, self.yLine + 1, ansi.WHITE | ansi.FBRIGHT, self.colBg)
            if (self.fBlink):
                ascr.PutAch(ansi.MkAch(" ", ansi.WHITE | ansi.FBRIGHT, ansi.WHITE), self.x + 1, self.y + 1)
    def spin(self, stSpin):
        self.moveTo(self.x - 1, self.y)
        self.printSt(stSpin)

    def newSpinner(self):
        return Blinker(self.game, self.spin, ["/","-","\\", "|"], 100)

    def newLine(self, count = 1, wait = 0):
        for i in range(count):
            self.moveTo(0, self.y + 1)
            self.beep()
            self.wait(wait)

    def beep(self):
        self.client.beep()

    def setColBg(self, colBg):
        self.colBg = colBg

class LeaveJoinToken(Token):
    def run(self):
        while True:
            Event.selectDg(self, (self.game.evLeave, self.OnLeave), (self.game.evJoin, self.OnJoin))
                    
class AutoJoiner(LeaveJoinToken):
    def InitPersistent(self, owner, *rgclsTok):
        Token.InitPersistent(self, owner)
        self.rgclsTok = rgclsTok

    def InitTransient(self):
        Token.InitTransient(self)
        self.mpclient_rgtok = {}

    def OnLeave(self, client):
        for tok in self.mpclient_rgtok[client]:
            print "killing ", tok
            tok.die()
    def OnJoin(self, client):
        rgtok = []
        for clsTok in self.rgclsTok:
            if FIter(clsTok):
                tok = clsTok[0](self.game, client, *clsTok[1:])
            else:
                tok = clsTok(self.game, client)
            rgtok.append(tok)
        self.mpclient_rgtok[client] = rgtok

class AliveWithPlayers(LeaveJoinToken):
    def InitPersistent(self, owner, *rgclsTok):
        Token.InitPersistent(self, owner)
        self.rgclsTok = rgclsTok

    def InitTransient(self):
        Token.InitTransient(self)
        self.rgclient = []

    def OnLeave(self, client):
        self.rgclient.remove(client)
        if len(self.rgclient) == 0:
            for tok in [x for x in self.rgtokOwn]:
                tok.die()
    def OnJoin(self, client):
        self.rgclient.append(client)
        if len(self.rgclient) == 1:
            for clsTok in self.rgclsTok:
                if FIter(clsTok):
                    tok = clsTok[0](self, clsTok[1:])
                else:
                    tok = clsTok(self)

class AutoKiller(LeaveJoinToken):
    def InitTransient(self):
        Token.InitTransient(self)
        self.rgclient = []
    def OnLeave(self, client):
        self.rgclient.remove(client)
        if len(self.rgclient) == 0:
            self.game.finish()
    def OnJoin(self, client):
        self.rgclient.append(client)

#selection oracle
class Selor(TPrs):
    NONE = 0
    PRI = 1
    SEC = 2

    def __init__(self, mi, selorParent, rgmiSec, fPri):
       self.selorParent = selorParent
       self.mi = mi
       self.rgmiSec = rgmiSec
       self.fPri = fPri

    def MiParent(self):
        if self.selorParent != None:
            return self.selorParent.mi
        return None

    def KSel(self):
        if self.fPri:
            return self.PRI
        elif self.mi in self.rgmiSec:
            return self.SEC
        else:
            return self.NONE

    def SelorChild(self, miChild, fPri):
        return Selor(miChild, self, self.rgmiSec, self.fPri and fPri)

    def SelorDeselect(self):
        return Selor(self.mi, self.selorParent, self.rgmiSec, False)
class Mi(TPrs):
    def InitPersistent(self):
        self.miParent = None
        self.fNotice = False
        self.rgmiNotice = [self]
    def Height(self, w):
        return 1

    def StName(self):
        return "Unnamed"

    def StKey(self):
        return self.StName()
    def HandleKey(self, key):
        return False
    def FIgnoreParent(self):
        return False

    def DrawWithParent(self, selorParent, ascr, x, y, w, fPri):
        self.Draw(ascr, x, y, w, selorParent.SelorChild(self, fPri))

    def ColBgDefault(self):
        return ansi.BLUE
    def ColBgSelected(self, fPri):
        return ansi.YELLOW if fPri else ansi.CYAN
    def ColBgNotice(self):
        return ansi.CYAN

    def ColBg(self, selor):
        if selor != None and selor.KSel() != Selor.NONE:
            if selor.KSel() == Selor.PRI:
                for mi in self.rgmiNotice:
                    if mi != self and mi.fNotice:
                        print "Notice cleared for ", mi.StName(), "by ", self.StName()
                    mi.fNotice = False
                return self.ColBgSelected(True)
            else:
                return self.ColBgSelected(False)
        elif self.FNoticeFlagged():
            return self.ColBgNotice()
        elif not self.FIgnoreParent() and selor != None and selor.MiParent() != None:
            return selor.MiParent().ColBg(selor.selorParent.SelorDeselect())
        else:
            return self.ColBgDefault()

    def ColFg(self):
        return ansi.WHITE | ansi.FBRIGHT
    def FlagNotice(self):
        self.fNotice = True

    def ListenForNotice(self, mi):
        self.rgmiNotice.append(mi)

    def FNoticeFlagged(self):
        for mi in self.rgmiNotice:
            if mi.fNotice:
                return True
        return False
    def FSelectable(self):
        return True
class MiInvisible(Mi):
    def Height(self, w):
        return 0
    def Draw(self, *rgarg):
        pass
    def FSelectable(self):
        return False

miInvisible = MiInvisible()
class MiStatic(Mi):
    def InitPersistent(self, stText):
        Mi.InitPersistent(self)
        self.stText = stText
    def StName(self):
        return self.stText
    def FSelectable(self):
        return False
    def Height(self, w):
        return len(RgstWrapped(self.StName(), w, 0))
    def Draw(self, ascr, x, y, w, selor):
        for st in RgstWrapped(self.StName(), w, 0):
            ascr.PutSt("{0:^{1}}".format(st, w), x, y, self.ColFg(), self.ColBg(selor))
            y = y + 1

class MiDgText(MiStatic):
    def InitPersistent(self, dgText):
        MiStatic.InitPersistent(self, None)
        self.dgText = dgText
    def StName(self):
        return self.dgText()
class MiButton(MiStatic):
    def InitPersistent(self, stName, dgCmd, value = None):
        MiStatic.InitPersistent(self, stName)
        self.dgCmd = dgCmd
        self.value = value

    def StName(self):
        if self.stText == None and self.value != None:
            return self.value.StName()
        return self.stText

    def Exec(self):
        return self.dgCmd()

    def FSelectable(self):
        return True
    def HandleKey(self, key):
        if ansi.FEnter(key) or key == ' ':
            return self.Exec()
        return False

    def Value(self):
        return self.value

class MiToggle(MiButton):
    def InitPersistent(self, stName, fInitial = False):
        MiButton.InitPersistent(self, stName, None, fInitial)

    def Exec(self):
        self.value = not self.value
        return True

    def StName(self):
        stPre = "[X] " if self.value else "[ ] "
        return stPre + self.stText

    def StKey(self):
        return self.stText
class MiList(Mi):
    def InitPersistent(self, rgval, ival = 0):
        Mi.InitPersistent(self)
        self.rgval = rgval
        self.ival = ival

    def Value(self):
        return self.rgval[self.ival]

    def Inc(self):
        if self.ival < len(self.rgval) - 1:
            self.ival = self.ival + 1

    def Dec(self):
        if self.ival > 0:
            self.ival = self.ival - 1

    def HandleKey(self, key):
        if key == ansi.K_LEFT:
            self.Dec()
        elif key == ansi.K_RIGHT:
            self.Inc()
        else:
            return False
        return True

    def Draw(self, ascr, x, y, w, selor):
        xText = w / 4
        xVal = w / 2
        ascr.PutSt(self.StName() + ":", xText, y, self.ColFg(), self.ColBg(selor))
        self.DrawValue(ascr, xVal, y, selor.SelorDeselect())
class MiTypein(Mi):
    def InitPersistent(self, dgEnter, stName = "Typein", pctW = 100):
        Mi.InitPersistent(self)
        self.stedit = Stedit(dgEnter)
        self.stName = stName
        self.pctW = pctW
        assert pctW > 0 and pctW <= 100

    def StName(self):
        return self.stName

    def Value(self):
        return self.stedit.GetValue()

    def SetValue(self, st):
        self.stedit.SetValue(st)
    def HandleKey(self, key):
        return self.stedit.HandleKey(key)

    def ColBgDefault(self):
        return ansi.BLACK
    def ColBgSelected(self, fPri):
        return ansi.WHITE if fPri else ansi.BLUE
    def ColFg(self):
        return ansi.WHITE

    def FIgnoreParent(self):
        return True
    def Height(self, wT):
        return len(RgstWrapped(self.GetStToWrap(), self.GetW(wT)))
    def GetW(self, wT):
        return int(wT * (self.pctW / 100.0))
    def GetStToWrap(self):
        return self.stedit.StForSize()
    def Draw(self, ascr, xT, y, wT, selor):
        w = self.GetW(wT)
        x = xT + ((wT - w) / 2)
        if selor.KSel() != Selor.NONE:
            stToWrap = self.GetStToWrap()
        else:
            stToWrap = self.stedit.GetValue()
        for snippet in RgSnippetWrapped(stToWrap, w):
            ascr.PutSt("{0:{1}}".format(snippet.st, w), x, y, self.ColFg(), self.ColBg(selor.SelorDeselect()))
            if selor.KSel() != Selor.NONE:
                self.stedit.DrawCursor(ascr, x, y, self.ColFg(), self.ColBg(selor), snippet)
            y = y + 1
class MiTab(MiStatic):
    def InitPersistent(self, stText, mi):
        MiStatic.InitPersistent(self, stText)
        self.mi = mi
        self.ListenForNotice(mi)
    def Value(self):
        return self.mi
    def FSelectable(self):
        return True

    @staticmethod
    def MiTabbed(*rgstTab_mi):
        miTabRow = MiMenuHoriz([MiTab(*stTab_mi) for stTab_mi in rgstTab_mi])
        return MiMenu([miTabRow, MiTabBody(miTabRow)])
class MiTabBody(Mi):
    def InitPersistent(self, miMenu):
        Mi.InitPersistent(self)
        self.miMenu = miMenu
    def Mi(self):
        return self.miMenu.Value()
    def HandleKey(self, key):
        return self.Mi().HandleKey(key)
    def Draw(self, ascr, x, y, w, selor):
        self.Mi().Draw(ascr, x, y, w, selor)
    def Height(self,w):
        return self.Mi().Height(w)
class MiValue(Mi):
    def InitPersistent(self, mi):
        Mi.InitPersistent(self)
        self.mi = mi
    def StName(self):
        return self.mi.StName()
    def Value(self):
        return self.mi.Value()
    def Height(self,w):
        return self.mi.Height(w)
    def Draw(self, ascr, x, y, w, selor):
        self.mi.DrawValue(ascr, x, y, selor.SelorChild(self.mi, False))

class Selection(TPrs):
    def InitPersistent(self, rgo, o = None, io = 0):
        self.rgo = rgo
        self.o = o
        self.io = -1 if o == None else io
        self.Validate()

    def Invalidate(self):
        self.o = None
        self.io = -1

    def Validate(self):
        # aw hell, selection only handles inserts, not deletes :(
        if self.o == None or self.io < 0:
            self.Invalidate()
        elif len(self.rgo) <= self.io or self.rgo[self.io] != self.o:
            try:
                self.io = self.rgo.index(self.o)
            except Exception:
                self.Invalidate()
        if self.o == None and not self.FEmpty():
            self.io = IoInc(self.rgo, self.io, self.FSelectableI)
            self.o = self.rgo[self.io]

    def GetSelected(self):
        self.Validate()
        return self.o

    def SetSelected(self, o):
        self.o = o
        self.Validate()
    def ITopScroll(self, h, dgHeight):
        # requirements:
        # selection must be visible
        # if possible, selection should be centered
        if self.io < 0:
            return 0
        iotop = self.io
        iobot = self.io
        hCurr = dgHeight(self.o)
        yobot = hCurr
        fGrowUp = False
        while hCurr < h:
            fDoneUp = iotop == 0
            fDoneDown = iobot == len(self.rgo) - 1
            if (fGrowUp or fDoneDown) and not fDoneUp:
                ho = dgHeight(self.rgo[iotop - 1])
                if (yobot + ho >= h): # handle case where thing above selected thing is huge and pushes the selection off the screen
                    break
                iotop = iotop - 1
                yobot = yobot + ho
            elif not fDoneDown:
                ho = dgHeight(self.rgo[iobot + 1])
                iobot = iobot + 1
            else:
                break
            hCurr = hCurr + ho
            fGrowUp = not fGrowUp
        return iotop

    def Inc(self):
        return self.ChangeI(IoInc)

    def Dec(self):
        return self.ChangeI(IoDec)

    def FEmpty(self):
        for o in self.rgo:
            if self.FSelectableI(o):
                return False
        return True

    def ChangeI(self, fnChange):
        self.Validate()
        if self.o != None:
            ioT = self.io
            self.io = fnChange(self.rgo, self.io, self.FSelectableI)
            self.o = self.rgo[self.io]
            return ioT != self.io

    def FSelectableI(self, o):
        return o != None and o.FSelectable()
    
class MiMenuI(Mi):
    def InitPersistent(self, rgmi):
        Mi.InitPersistent(self)
        self.selMi = Selection(rgmi)
        self.mpstName_mi = {}
        for mi in rgmi:
            if mi != None:
                self.mpstName_mi[mi.StKey().lower()] = mi
    def Value(self, stKey = None):
        if stKey == None:
            return self.selMi.GetSelected().Value()
        return self.mpstName_mi[stKey.lower()].Value()
    def MiByName(self, stKey):
        return self.mpstName_mi[stKey.lower()]
    def HeightMi(self, mi, w):
        if mi == None:
            return 1
        return mi.Height(w)
    def ColBgSelected(self, fPri):
        return self.ColBgDefault()

class MiMenu(MiMenuI):
    def InitPersistent(self, rgmi, hMax = -1):
        MiMenuI.InitPersistent(self, rgmi)
        self.hMax = hMax
    def HandleKey(self, key):
        mi = self.selMi.GetSelected()
        if mi == None or not mi.HandleKey(key):
            if key == ansi.K_DOWN:
                return self.selMi.Inc()
            elif key == ansi.K_UP:
                return self.selMi.Dec()
            return False
        return True

    def HMax(self, ascr, y):
        if self.hMax < 0:
            return (ascr.H() - y) + 1
        return self.hMax

    def Height(self, w):
        return sum([self.HeightMi(mi,w) for mi in self.selMi.rgo])

    def Draw(self, ascr, x, y, w, selor):
        ascr.Fill(ansi.MkAch(' ', self.ColFg(), self.ColBg(selor)), w, self.Height(w), x, y)
        miSelected = self.selMi.GetSelected()
        h = 0
        hMax = self.HMax(ascr, y)
        itop = self.selMi.ITopScroll(hMax, lambda mi: self.HeightMi(mi, w))
        for imi, mi in enumerate(self.selMi.rgo):
            if imi < itop:
                continue
            if mi != None:
                mi.DrawWithParent(selor, ascr, x, y + h, w, miSelected == mi)
            h = h + self.HeightMi(mi, w)
            if h >= hMax:
                break
class MiMenuHoriz(MiMenuI):
    def InitPersistent(self, rgmi, rgsize = None):
        MiMenuI.InitPersistent(self, rgmi)
        if rgsize == None:
            rgsize = [1 for mi in rgmi]
        self.rgsize = rgsize
        self.sizeMax = float(sum(rgsize))

    def Width(self, imi, w):
        return int((self.rgsize[imi] / self.sizeMax) * w)

    def HandleKey(self, key):
        mi = self.selMi.GetSelected()
        if mi == None or not mi.HandleKey(key):
            if key == ansi.K_RIGHT:
                return self.selMi.Inc()
            elif key == ansi.K_LEFT:
                return self.selMi.Dec()
            return False
        return True

    def Height(self, w):
        return max([self.HeightMi(mi, w) for mi in self.selMi.rgo])
    def Draw(self, ascr, x, y, w, selor):
        ascr.Fill(ansi.MkAch(' ', self.ColFg(), self.ColBg(selor)), w, self.Height(w), x, y)
        miSelected = self.selMi.GetSelected()
        for imi, mi in enumerate(self.selMi.rgo):
            wT = self.Width(imi, w)
            if mi != None:
                mi.DrawWithParent(selor, ascr, x, y, wT, miSelected == mi)
            x = x + wT

def DgProjectMiButton(dgExec):
    def DgProject(value):
        return MiButton(None, lambda: dgExec(value), value)
    return DgProject

class RgmiProjected(TPrs):
    def InitPersistent(self, rgvalue, dgProject):
        self.rgvalue = rgvalue
        self.dgProject = dgProject

    def InitTransient(self):
        self.mpvalue_wrmi = weakref.WeakKeyDictionary()

    def __getitem__(self, i):
        return self.MiFromValue(self.rgvalue[i])

    def MiFromValue(self, value):
        if value in self.mpvalue_wrmi:
            mi = self.mpvalue_wrmi[value]()
            if mi != None:
                return mi
        mi = self.dgProject(value)
        mi._valueProjected = value
        self.mpvalue_wrmi[value] = weakref.ref(mi) # this probably gc's much more than is necessary ... :/
        return mi

    def __len__(self):
        return len(self.rgvalue)

    def index(self, mi):
        return self.rgvalue.index(mi._valueProjected)


class OvStatic(TokenClient):
    TOP = 1
    MIDDLE = 2
    BOTTOM = 3
    FILL = 4

    def InitPersistent(self, owner, client, miMenu, kplace, *rgtag):
        TokenClient.InitPersistent(self, owner, client, "drawable", "menu", *rgtag)
        self.miMenu = miMenu
        self.kplace = kplace
        self.mpst_miSel = {}
    def SetSelection(self, stSel, mi):
        self.mpst_miSel[stSel] = mi

    def GetSelection(self, stSel):
        try:
            return self.mpst_miSel[stSel]
        except KeyError:
            return None
    def draw(self, ascr, client):
        self.drawI(ascr, client, False)

    def drawI(self, ascr, client, fSelected):
        if client == self.client:
            selor = Selor(self.miMenu, None, self.mpst_miSel.values(), fSelected)
            if self.kplace & self.FILL:
                h = ascr.H()
                y = 1
                dh = h - self.miMenu.Height(ascr.W())
                if dh > 0:
                    ascr.Fill(ansi.MkAch(' ', self.miMenu.ColFg(), self.miMenu.ColBg(selor)), ascr.W(), dh, 1, ascr.H() - dh + 1)
            else:
                h = self.miMenu.Height(ascr.W())
                if self.kplace == self.TOP:
                    y = 1
                elif self.kplace == self.MIDDLE:
                    y = (ascr.H() / 2) - (h / 2)
                else: # BOTTOM
                    y = ascr.H() - h + 1
            self.miMenu.Draw(ascr, 1, y, ascr.W(), selor)

    def Value(self, stName = None):
        return self.miMenu.Value(stName)
class OvMenu(OvStatic):
    def run(self):
        while True:
            self.miMenu.HandleKey(self.client.evKey.receive(self))

    def draw(self, ascr, client):
        self.drawI(ascr, client, True)
class OvPopup(OvStatic):
    def InitPersistent(self, owner, client, miMenu):
        OvStatic.InitPersistent(self, owner, client, miMenu, self.MIDDLE, "drawable", "menu")
        self.evShow = Event(self.game)
        self.evDone = Event(self.game)
        self.fAwake = False

    def run(self):
        while True:
            self.evShow.receive(self)
            self.fAwake = True
            while self.fAwake:
                key = self.client.evKey.receive(self)
                if not self.miMenu.HandleKey(key):
                    if key == ansi.K_TAB or key == ansi.K_DEL or key == ' ' or ansi.FEnter(key):
                        self.fAwake = False
            self.evDone.fire()

    def draw(self, ascr, client):
        if self.fAwake:
            self.drawI(ascr, client, True)
class MsgScroller(Token):
    def InitPersistent(self, owner, colFg=ansi.BLUE, colBg=ansi.BLACK, y=config.H):
        Token.InitPersistent(self, owner, "drawable", "msgscroller", "overlay")
        self.colFg = colFg
        self.colBg = colBg
        self.rgmsg = []
        self.msg = None
        self.evPost = Event(self.game)
        self.y = y

    def postI(self, msg):
        self.rgmsg.append(msg)

    def run(self):
        while True:
            self.postI(self.evPost.receive(self))
            with self.evPost.oob(self, self.postI):
                while len(self.rgmsg) > 0:
                    self.msg = self.rgmsg[0]
                    self.rgmsg = self.rgmsg[1:]
                    self.x = config.W
                    while self.x > -len(self.msg):
                        self.x = self.x - 1
                        self.wait(30)
                    self.msg = None

    def draw(self, ascr, client):
        if self.msg:
            ascr.PutSt(self.msg, self.x, self.y, self.colFg, self.colBg)