pesterchum/memos.py

import logging
import logging.config
import re
from string import Template
from datetime import timedelta, datetime

from PyQt6 import QtCore, QtGui, QtWidgets

import ostools
import parsetools
from dataobjs import PesterProfile, PesterHistory
from generic import PesterIcon, RightClickList, mysteryTime
from convo import PesterConvo, PesterInput, PesterText, PesterTabWindow
from parsetools import (convertTags, timeProtocol, lexMessage, colorBegin,
                        mecmd, smiledict)
from logviewer import PesterLogViewer

_datadir = ostools.getDataDir()
logging.config.fileConfig(_datadir + "logging.ini")
PchumLog = logging.getLogger('pchumLogger')

# Python 3
QString = str

def delta2txt(d, format="pc"):
    if type(d) is mysteryTime:
        return "?"
    if format == "pc":
        sign = "+" if d >= timedelta(0) else "-"
    else:
        if d == timedelta(0):
            return "i"
        sign = "F" if d >= timedelta(0) else "P"
    d = abs(d)
    totalminutes = (d.days*86400 + d.seconds) // 60
    hours = totalminutes // 60
    leftovermins = totalminutes % 60
    if hours < 100:
        if format == "pc":
            return "%s%d:%02d" % (sign, hours, leftovermins)
        else:
            return "%s%02d:%02d" % (sign, hours, leftovermins)
    else:
        if format == "pc":
            return "%s%d" % (sign, hours)
        else:
            return "%s%02d:%02d" % (sign, hours, leftovermins)

def txt2delta(txt):
    sign = 1
    if txt[0] == '?':
        return mysteryTime()
    if txt[0] == '+':
        txt = txt[1:]
    elif txt[0] == '-':
        sign = -1
        txt = txt[1:]
    l = txt.split(":")
    try:
        h = int(l[0])
        m = 0
        if len(l) > 1:
            m = int(l[1])
        timed = timedelta(0, h*3600+m*60)
    except ValueError:
        timed = timedelta(0)
    except OverflowError:
        if sign < 0:
            return timedelta.min
        else:
            return timedelta.max
    return sign*timed

def pcfGrammar(td):
    if td == timedelta(microseconds=1): # Replacement for mysteryTime </3
        when = "???"
        temporal = "???"
        pcf = "?"
    elif td > timedelta(0):
        when = "FROM NOW"
        temporal = "FUTURE"
        pcf = "F"
    elif td < timedelta(0):
        when = "AGO"
        temporal = "PAST"
        pcf = "P"
    else:
        when = "RIGHT NOW"
        temporal = "CURRENT"
        pcf = "C"
    return (temporal, pcf, when)

class TimeGrammar(object):
    def __init__(self, temporal, pcf, when, number="0"):
        self.temporal = temporal
        self.pcf = pcf
        self.when = when
        if number == "0" or number == 0:
            self.number = ""
        else:
            self.number = str(number)

class TimeTracker(list):
    def __init__(self, time=None):
        # mysteryTime breaks stuff now, so, uh
        # I'm replacing it with 1 day...
        if type(time)==mysteryTime:
            time = timedelta(microseconds=1)
        self.timerecord = {"P": [], "F": []}
        self.open = {}
        if time is not None:
            self.append(time)
            self.current=0
            self.addRecord(time)
            self.open[time] = False
        else:
            self.current=-1
    def addTime(self, timed):
        # mysteryTime </3
        if type(timed)==mysteryTime:
            timed = timedelta(microseconds=1)
        try:
            i = self.index(timed)
            self.current = i
            return True
        except ValueError:
            self.current = len(self)
            self.append(timed)
            self.open[timed] = False
            self.addRecord(timed)
            return False
    def prevTime(self):
        i = self.current
        i = (i - 1) % len(self)
        return self[i]
    def nextTime(self):
        i = self.current
        i = (i + 1) % len(self)
        return self[i]
    def setCurrent(self, timed):
        self.current = self.index(timed)
    def addRecord(self, timed):
        try:
            (temporal, pcf, when) = pcfGrammar(timed - timedelta(0))
        except TypeError:
            (temporal, pcf, when) = pcfGrammar(mysteryTime())
        if pcf == "C" or pcf == "?":
            return
        if timed in self.timerecord[pcf]:
            return
        self.timerecord[pcf].append(timed)
    def getRecord(self, timed):
        try:
            (temporal, pcf, when) = pcfGrammar(timed - timedelta(0))
        except TypeError:
            (temporal, pcf, when) = pcfGrammar(mysteryTime())
        if pcf == "C" or pcf == "?":
            return 0
        if len(self.timerecord[pcf]) > 1:
            return self.timerecord[pcf].index(timed)+1
        else:
            return 0
    def removeTime(self, timed):
        try:
            self.pop(self.index(timed))
            self.current = len(self)-1
            del self.open[timed]
            return True
        except ValueError:
            return None
    def openTime(self, time):
        if time in self.open:
            self.open[time] = True
    def openCurrentTime(self):
        timed = self.getTime()
        self.openTime(timed)
    def isFirstTime(self):
        timed = self.getTime()
        return not self.open[timed]
    def getTime(self):
        if self.current >= 0:
            return self[self.current]
        else:
            return None
    def getGrammar(self):
        timed = self.getTime()
        return self.getGrammarTime(timed)
    def getGrammarTime(self, timed):
        mytime = timedelta(0)
        try:
            (temporal, pcf, when) = pcfGrammar(timed - mytime)
        except TypeError:
            (temporal, pcf, when) = pcfGrammar(mysteryTime())
        if timed == mytime:
            return TimeGrammar(temporal, pcf, when, 0)
        return TimeGrammar(temporal, pcf, when, self.getRecord(timed))

class TimeInput(QtWidgets.QLineEdit):
    def __init__(self, timeslider, parent):
        super(TimeInput, self).__init__(parent)
        self.timeslider = timeslider
        self.setText("+0:00")
        self.timeslider.valueChanged[int].connect(self.setTime)
        self.editingFinished.connect(self.setSlider)
    @QtCore.pyqtSlot(int)
    def setTime(self, sliderval):
        self.setText(self.timeslider.getTime())
    @QtCore.pyqtSlot()
    def setSlider(self):
        value = str(self.text())
        timed = txt2delta(value)
        if type(timed) is mysteryTime:
            self.timeslider.setValue(0)
            self.setText("?")
            return
        sign = 1 if timed >= timedelta(0) else -1
        abstimed = abs(txt2delta(value))
        index = 50
        for i, td in enumerate(timedlist):
            if abstimed < td:
                index = i-1
                break
        self.timeslider.setValue(sign*index)
        text = delta2txt(timed)
        self.setText(text)

class TimeSlider(QtWidgets.QSlider):
    def __init__(self, orientation, parent):
        super(TimeSlider, self).__init__(orientation, parent)
        self.setTracking(True)
        self.setMinimum(-50)
        self.setMaximum(50)
        self.setValue(0)
        self.setPageStep(1)
    def getTime(self):
        time = timelist[abs(self.value())]
        sign = "+" if self.value() >= 0 else "-"
        return sign+time
    def mouseDoubleClickEvent(self, event):
        self.setValue(0)

class MemoTabWindow(PesterTabWindow):
    def __init__(self, mainwindow, parent=None):
        super(MemoTabWindow, self).__init__(mainwindow, parent, "memos")
    def addChat(self, convo):
        self.convos[convo.channel] = convo
        # either addTab or setCurrentIndex will trigger changed()
        newindex = self.tabs.addTab(convo.channel)
        self.tabIndices[convo.channel] = newindex
        self.tabs.setCurrentIndex(newindex)
        self.tabs.setTabIcon(newindex,
                             PesterIcon(self.mainwindow.theme["memos/memoicon"]))
    def updateBlocked(self):
        pass
    def updateMood(self):
        pass

_ctag_begin = re.compile(r'<c=(.*?)>')

class MemoText(PesterText):
    def __init__(self, theme, parent=None):
        super(MemoText, self).__init__(theme, parent)
        if hasattr(self.parent(), 'mainwindow'):
            self.mainwindow = self.parent().mainwindow
        else:
            self.mainwindow = self.parent()
        if type(parent.parent) is PesterTabWindow:
            self.tabobject = parent.parent()
            self.hasTabs = True
        else:
            self.hasTabs = False
        self.initTheme(theme)
        self.setReadOnly(True)
        self.setMouseTracking(True)
        self.textSelected = False
        self.copyAvailable[bool].connect(self.textReady)
        self.urls = {}
        for k in smiledict:
            self.addAnimation(QtCore.QUrl("smilies/%s" % (smiledict[k])),
                              "smilies/%s" % (smiledict[k]))
        #self.mainwindow.animationSetting[bool].connect(self.animateChanged)

    def initTheme(self, theme):
        if "memos/scrollbar" in theme:
            self.setStyleSheet("QTextEdit { %s }"
                               "QScrollBar:vertical { %s }"
                               "QScrollBar::handle:vertical { %s }"
                               "QScrollBar::add-line:vertical { %s }"
                               "QScrollBar::sub-line:vertical { %s }"
                               "QScrollBar:up-arrow:vertical { %s }"
                               "QScrollBar:down-arrow:vertical { %s }"
                               % (theme["memos/textarea/style"],
                                  theme["memos/scrollbar/style"],
                                  theme["memos/scrollbar/handle"],
                                  theme["memos/scrollbar/downarrow"],
                                  theme["memos/scrollbar/uparrow"],
                                  theme["memos/scrollbar/uarrowstyle"],
                                  theme["memos/scrollbar/darrowstyle"] ))
        else:
            self.setStyleSheet("QTextEdit { %s }" % theme["memos/textarea/style"])

        # So it doesn't inherit the memo's background image.
        # Fixes floating "PESTERLOG:"
        try:
            self.setStyleSheet(self.styleSheet()
                               + ("QMenu{ %s }"
                                  % theme["main/defaultwindow/style"]))
        except:
            pass

    def addMessage(self, msg, chum):
        if type(msg) in [str, str]:
            lexmsg = lexMessage(msg)
        else:
            lexmsg = msg
        parent = self.parent()
        window = parent.mainwindow
        me = window.profile()
        if self.mainwindow.config.animations():
            for m in self.urls:
                if convertTags(lexmsg).find(self.urls[m].toString()) != -1:
                    if m.state() == QtGui.QMovie.MovieState.NotRunning:
                        m.start()
        chumdb = window.chumdb
        if chum is not me: # SO MUCH WH1T3SP4C3 >:]
            if type(lexmsg[0]) is colorBegin: # get color tag
                colortag = lexmsg[0]
                try:
                    color = QtGui.QColor(*[int(c) for c in colortag.color.split(",")])
                except ValueError:
                    color = QtGui.QColor("black")
                else:
                    chumdb.setColor(chum.handle, color)
                    parent.updateColor(chum.handle, color)
            else:
                color = chumdb.getColor(chum.handle)
        else:
            color = me.color

        chum.color = color
        systemColor = QtGui.QColor(window.theme["memos/systemMsgColor"])
        if chum is not me:
            if chum.handle in parent.times:
                time = parent.times[chum.handle]
                if time.getTime() is None:
                    # MY WAY OR THE HIGHWAY
                    time.addTime(timedelta(0))
            else:
                # new chum! time current
                newtime = timedelta(0)
                time = TimeTracker(newtime)

                # 'handle' undefined?
                try:
                    parent.times[handle] = time
                except:
                    parent.times[chum.handle] = time
        else:
            time = parent.time

        if time.isFirstTime():
            grammar = time.getGrammar()
            joinmsg = chum.memojoinmsg(systemColor,
                                       time.getTime(),
                                       grammar,
                                       window.theme["convo/text/joinmemo"])
            self.append(convertTags(joinmsg))
            parent.mainwindow.chatlog.log(parent.channel, joinmsg)
            time.openCurrentTime()

        def makeSafe(msg):
            if msg.count("<c") > msg.count("</c>"):
                for i in range(msg.count("<c") - msg.count("</c>")):
                    msg = msg + "</c>"
            return "<span style=\"color:#000000\">" + msg + "</span>"
        if type(lexmsg[0]) is mecmd:
            memsg = chum.memsg(systemColor, lexmsg, time=time.getGrammar())
            window.chatlog.log(parent.channel, memsg)
            self.append(convertTags(memsg))
        else:
            self.append(makeSafe(convertTags(lexmsg)))
            window.chatlog.log(parent.channel, lexmsg)

    def changeTheme(self, theme):
        self.initTheme(theme)

class MemoInput(PesterInput):
    stylesheet_path = "memos/input/style"
    # karxi: Because of the use of stylesheet_path, we don't have to rewrite
    # this code.
    # Neat, huh?

class PesterMemo(PesterConvo):
    # TODO: Clean up inheritance between these!! The inits are ugly.
    def __init__(self, channel, timestr, mainwindow, parent=None):
        QtWidgets.QFrame.__init__(self, parent)
        self.setAttribute(QtCore.Qt.WidgetAttribute.WA_QuitOnClose, False)
        self.channel = channel
        self.setObjectName(self.channel)
        self.mainwindow = mainwindow
        self.time = TimeTracker(txt2delta(timestr))
        self.setWindowTitle(channel)
        self.channelLabel = QtWidgets.QLabel(self)
        self.channelLabel.setSizePolicy(QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.MinimumExpanding,
                                                              QtWidgets.QSizePolicy.Policy.Expanding))

        self.textArea = MemoText(self.mainwindow.theme, self)
        self.textInput = MemoInput(self.mainwindow.theme, self)
        print(self.textInput)
        self.textInput.setFocus()

        self.miniUserlist = QtWidgets.QPushButton(">\n>", self)
        #self.miniUserlist.setStyleSheet("border:1px solid #a68168; border-width: 2px 0px 2px 2px; height: 90px; width: 10px; color: #cd8f9d; font-family: 'Arial'; background: white; margin-left: 2px;")
        self.miniUserlist.clicked.connect(self.toggleUserlist)


        self.userlist = RightClickList(self)
        self.userlist.setSizePolicy(QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Fixed,
                                                          QtWidgets.QSizePolicy.Policy.Expanding))
        self.userlist.optionsMenu = QtWidgets.QMenu(self)
        self.pesterChumAction = QtGui.QAction(self.mainwindow.theme["main/menus/rclickchumlist/pester"], self)
        self.pesterChumAction.triggered.connect(self.newPesterSlot)
        self.addchumAction = QtGui.QAction(self.mainwindow.theme["main/menus/rclickchumlist/addchum"], self)
        self.addchumAction.triggered.connect(self.addChumSlot)
        self.banuserAction = QtGui.QAction(self.mainwindow.theme["main/menus/rclickchumlist/banuser"], self)
        self.banuserAction.triggered.connect(self.banSelectedUser)
        self.opAction = QtGui.QAction(self.mainwindow.theme["main/menus/rclickchumlist/opuser"], self)
        self.opAction.triggered.connect(self.opSelectedUser)
        self.voiceAction = QtGui.QAction(self.mainwindow.theme["main/menus/rclickchumlist/voiceuser"], self)
        self.voiceAction.triggered.connect(self.voiceSelectedUser)
        self.quirkDisableAction = QtGui.QAction(self.mainwindow.theme["main/menus/rclickchumlist/quirkkill"], self)
        self.quirkDisableAction.triggered.connect(self.killQuirkUser)
        self.userlist.optionsMenu.addAction(self.pesterChumAction)
        self.userlist.optionsMenu.addAction(self.addchumAction)
        # ban & op list added if we are op

        self.optionsMenu = QtWidgets.QMenu(self)
        self.optionsMenu.setStyleSheet(self.mainwindow.theme["main/defaultwindow/style"]) # So it doesn't inherit the memo's background image.
                                                                                          # Fixes floating "PESTERLOG:"
        self.oocToggle = QtGui.QAction(self.mainwindow.theme["main/menus/rclickchumlist/ooc"], self)
        self.oocToggle.setCheckable(True)
        self.oocToggle.toggled[bool].connect(self.toggleOOC)
        self.quirksOff = QtGui.QAction(self.mainwindow.theme["main/menus/rclickchumlist/quirksoff"], self)
        self.quirksOff.setCheckable(True)
        self.quirksOff.toggled[bool].connect(self.toggleQuirks)
        self.logchum = QtGui.QAction(self.mainwindow.theme["main/menus/rclickchumlist/viewlog"], self)
        self.logchum.triggered.connect(self.openChumLogs)
        self.invitechum = QtGui.QAction(self.mainwindow.theme["main/menus/rclickchumlist/invitechum"], self)
        self.invitechum.triggered.connect(self.inviteChums)

        #if self.mainwindow.theme.has_key("main/menus/rclickchumlist/beeponmessage"):
        try:
            self._beepToggle = QtGui.QAction(self.mainwindow.theme["main/menus/rclickchumlist/beeponmessage"], self)
        except:
            self._beepToggle = QtGui.QAction("BEEP ON MESSAGE", self)
        self._beepToggle.setCheckable(True)
        self._beepToggle.toggled[bool].connect(self.toggleBeep)

        #if self.mainwindow.theme.has_key("main/menus/rclickchumlist/flashonmessage"):
        try:
            self._flashToggle = QtGui.QAction(self.mainwindow.theme["main/menus/rclickchumlist/flashonmessage"], self)
        except:
            self._flashToggle = QtGui.QAction("FLASH ON MESSAGE", self)
        self._flashToggle.setCheckable(True)
        self._flashToggle.toggled[bool].connect(self.toggleFlash)

        #if self.mainwindow.theme.has_key("main/menus/rclickchumlist/mutenotifications"):
        try:
            self._muteToggle = QtGui.QAction(self.mainwindow.theme["main/menus/rclickchumlist/mutenotifications"], self)
        except:
            self._muteToggle = QtGui.QAction("MUTE NOTIFICATIONS", self)
        self._muteToggle.setCheckable(True)
        self._muteToggle.toggled[bool].connect(self.toggleMute)

        self.optionsMenu.addAction(self.quirksOff)
        self.optionsMenu.addAction(self.oocToggle)

        self.optionsMenu.addAction(self._beepToggle)
        self.optionsMenu.addAction(self._flashToggle)
        self.optionsMenu.addAction(self._muteToggle)

        self.optionsMenu.addAction(self.logchum)
        self.optionsMenu.addAction(self.invitechum)

        self.chanModeMenu = QtWidgets.QMenu(self.mainwindow.theme["main/menus/rclickchumlist/memosetting"], self)
        self.chanNoquirks = QtGui.QAction(self.mainwindow.theme["main/menus/rclickchumlist/memonoquirk"], self)
        self.chanNoquirks.setCheckable(True)
        self.chanNoquirks.toggled[bool].connect(self.noquirksChan)
        self.chanHide = QtGui.QAction(self.mainwindow.theme["main/menus/rclickchumlist/memohidden"], self)
        self.chanHide.setCheckable(True)
        self.chanHide.toggled[bool].connect(self.hideChan)
        self.chanInvite = QtGui.QAction(self.mainwindow.theme["main/menus/rclickchumlist/memoinvite"], self)
        self.chanInvite.setCheckable(True)
        self.chanInvite.toggled[bool].connect(self.inviteChan)
        self.chanMod = QtGui.QAction(self.mainwindow.theme["main/menus/rclickchumlist/memomute"], self)
        self.chanMod.setCheckable(True)
        self.chanMod.toggled[bool].connect(self.modChan)
        self.chanModeMenu.addAction(self.chanNoquirks)
        self.chanModeMenu.addAction(self.chanHide)
        self.chanModeMenu.addAction(self.chanInvite)
        self.chanModeMenu.addAction(self.chanMod)
        self.chanModeMenu.setStyleSheet(self.mainwindow.theme["main/defaultwindow/style"]) # BWAH BWAH FLOATING "PESTERLOG:"

        self.timeslider = TimeSlider(QtCore.Qt.Orientation.Horizontal, self)
        self.timeinput = TimeInput(self.timeslider, self)
        self.timeinput.setText(timestr)
        self.timeinput.setSlider()
        self.timetravel = QtWidgets.QPushButton("GO", self)
        self.timeclose = QtWidgets.QPushButton("CLOSE", self)
        self.timeswitchl = QtWidgets.QPushButton(self)
        self.timeswitchr = QtWidgets.QPushButton(self)

        self.timetravel.clicked.connect(self.sendtime)
        self.timeclose.clicked.connect(self.smashclock)
        self.timeswitchl.clicked.connect(self.prevtime)
        self.timeswitchr.clicked.connect(self.nexttime)

        self.times = {}

        self.initTheme(self.mainwindow.theme)

        # connect
        self.textInput.returnPressed.connect(self.sentMessage)

        layout_0 = QtWidgets.QVBoxLayout()
        layout_0.addWidget(self.textArea)
        layout_0.addWidget(self.textInput)

        layout_1 = QtWidgets.QHBoxLayout()
        layout_1.addLayout(layout_0)
        layout_1.addWidget(self.miniUserlist)
        layout_1.addWidget(self.userlist)

#        layout_1 = QtGui.QGridLayout()
#        layout_1.addWidget(self.timeslider, 0, 1, QtCore.Qt.AlignmentFlag.AlignHCenter)
#        layout_1.addWidget(self.timeinput, 1, 0, 1, 3)
        layout_2 = QtWidgets.QHBoxLayout()
        layout_2.addWidget(self.timeslider)
        layout_2.addWidget(self.timeinput)
        layout_2.addWidget(self.timetravel)
        layout_2.addWidget(self.timeclose)
        layout_2.addWidget(self.timeswitchl)
        layout_2.addWidget(self.timeswitchr)
        self.layout = QtWidgets.QVBoxLayout()

        self.layout.addWidget(self.channelLabel)
        self.layout.addLayout(layout_1)
        self.layout.addLayout(layout_2)
        self.layout.setSpacing(0)
        margins = self.mainwindow.theme["memos/margins"]
        self.layout.setContentsMargins(margins["left"], margins["top"],
                                  margins["right"], margins["bottom"])

        self.setLayout(self.layout)

        if parent:
            parent.addChat(self)

        p = self.mainwindow.profile()
        timeGrammar = self.time.getGrammar()
        systemColor = QtGui.QColor(self.mainwindow.theme["memos/systemMsgColor"])
        msg = p.memoopenmsg(systemColor,
                            self.time.getTime(),
                            timeGrammar,
                            self.mainwindow.theme["convo/text/openmemo"],
                            self.channel)
        self.time.openCurrentTime()
        self.textArea.append(convertTags(msg))
        self.mainwindow.chatlog.log(self.channel, msg)

        self.op = False
        self.newmessage = False
        self.history = PesterHistory()
        self.applyquirks = True
        self.ooc = False

        self.always_beep = False
        self.always_flash = False
        self.notifications_muted = False

    @QtCore.pyqtSlot()
    def toggleUserlist(self):
        if self.userlist.isHidden():
            self.userlist.show()
            self.miniUserlist.setText(">\n>")
            self.miniUserlist.setStyleSheet("%s border-width: 2px 0px 2px 2px;"
                                            % self.miniUserlist.styleSheet())
        else:
            self.userlist.hide()
            self.miniUserlist.setText("<\n<")
            self.miniUserlist.setStyleSheet("%s border-width: 2px;"
                                            % self.miniUserlist.styleSheet())

    def title(self):
        return self.channel
    def icon(self):
        return PesterIcon(self.mainwindow.theme["memos/memoicon"])

    def sendTimeInfo(self, newChum=False):
        if newChum:
            self.messageSent.emit("PESTERCHUM:TIME>%s" % (delta2txt(self.time.getTime(), "server")+"i"),
                                  self.title())
        else:
            self.messageSent.emit("PESTERCHUM:TIME>%s" % (delta2txt(self.time.getTime(), "server")),
                                  self.title())

    def updateMood(self):
        pass
    def updateBlocked(self):
        pass
    def updateColor(self, handle, color):
        chums = self.userlist.findItems(handle, QtCore.Qt.MatchFlag.MatchExactly)
        for c in chums:
            c.setForeground(QtGui.QBrush(color))
    def addMessage(self, text, handle):
        if type(handle) is bool:
            chum = self.mainwindow.profile()
        else:
            chum = PesterProfile(handle)
            self.notifyNewMessage()
        self.textArea.addMessage(text, chum)

    def initTheme(self, theme):
        self.resize(*theme["memos/size"])
        self.setStyleSheet("QtWidgets.QFrame { %s };" % (theme["memos/style"]))
        self.setWindowIcon(PesterIcon(theme["memos/memoicon"]))
        t = Template(theme["memos/label/text"])
        if self.mainwindow.advanced and hasattr(self, 'modes'):
            self.channelLabel.setText(t.safe_substitute(channel=self.channel) + "(%s)" % (self.modes))
        else:
            self.channelLabel.setText(t.safe_substitute(channel=self.channel))
        self.channelLabel.setStyleSheet(theme["memos/label/style"])
        self.channelLabel.setAlignment(self.aligndict["h"][theme["memos/label/align/h"]]
                                       | self.aligndict["v"][theme["memos/label/align/v"]])
        self.channelLabel.setMaximumHeight(theme["memos/label/maxheight"])
        self.channelLabel.setMinimumHeight(theme["memos/label/minheight"])

        self.userlist.optionsMenu.setStyleSheet(theme["main/defaultwindow/style"])
        scrolls = "width: 12px; height: 12px; border: 0; padding: 0;"
        if "main/chums/scrollbar" in theme:
            self.userlist.setStyleSheet("QListWidget { %s }"
                                        "QScrollBar { %s }"
                                        "QScrollBar::handle { %s }"
                                        "QScrollBar::add-line { %s }"
                                        "QScrollBar::sub-line { %s }"
                                        "QScrollBar:up-arrow { %s }"
                                        "QScrollBar:down-arrow { %s }"
                                        % (theme["memos/userlist/style"],
                                           theme["main/chums/scrollbar/style"] + scrolls,
                                           theme["main/chums/scrollbar/handle"],
                                           theme["main/chums/scrollbar/downarrow"],
                                           theme["main/chums/scrollbar/uparrow"],
                                           theme["main/chums/scrollbar/uarrowstyle"],
                                           theme["main/chums/scrollbar/darrowstyle"]))
        elif "convo/scrollbar" in theme:
            self.userlist.setStyleSheet("QListWidget { %s }"
                                        "QScrollBar { %s }"
                                        "QScrollBar::handle { %s }"
                                        "QScrollBar::add-line { %s }"
                                        "QScrollBar::sub-line { %s }"
                                        "QScrollBar:up-arrow { %s }"
                                        "QScrollBar:down-arrow { %s }"
                                        % (theme["memos/userlist/style"],
                                           theme["convo/scrollbar/style"] + scrolls,
                                           theme["convo/scrollbar/handle"],
                                           "display: none;",
                                           "display: none;",
                                           "display: none;",
                                           "display: none;"))
        else:
            self.userlist.setStyleSheet("QListWidget { %s }"
                                        "QScrollBar { %s }"
                                        "QScrollBar::handle { %s }"
                                        % (theme["memos/userlist/style"],
                                           scrolls,
                                           "background-color: black;"))
        self.userlist.setFixedWidth(theme["memos/userlist/width"])

        if self.userlist.isHidden():
            borders = "border-width: 2px;"
        else:
            borders = "border-width: 2px 0px 2px 2px;"
        self.miniUserlist.setStyleSheet("padding: 0px;"
                                        "margin: 0px;"
                                        "margin-left: 5px;"
                                        "width: 10px;"
                                        "height: 90px;"
                                        + borders
                                        + theme["memos/userlist/style"])

        self.addchumAction.setText(theme["main/menus/rclickchumlist/addchum"])
        self.banuserAction.setText(theme["main/menus/rclickchumlist/banuser"])
        self.opAction.setText(theme["main/menus/rclickchumlist/opuser"])
        self.voiceAction.setText(theme["main/menus/rclickchumlist/voiceuser"])
        self.quirkDisableAction.setText(theme["main/menus/rclickchumlist/quirkkill"])
        self.quirksOff.setText(theme["main/menus/rclickchumlist/quirksoff"])
        self.logchum.setText(theme["main/menus/rclickchumlist/viewlog"])
        self.invitechum.setText(theme["main/menus/rclickchumlist/invitechum"])
        self.chanModeMenu.setTitle(theme["main/menus/rclickchumlist/memosetting"])
        self.chanNoquirks.setText(theme["main/menus/rclickchumlist/memonoquirk"])
        self.chanHide.setText(theme["main/menus/rclickchumlist/memohidden"])
        self.chanInvite.setText(theme["main/menus/rclickchumlist/memoinvite"])
        self.chanMod.setText(theme["main/menus/rclickchumlist/memomute"])

        self.timeinput.setFixedWidth(theme["memos/time/text/width"])
        self.timeinput.setStyleSheet(theme["memos/time/text/style"])
        slidercss = ("QSlider { %s }"
                    "Slider::groove { %s }"
                    "QSlider::handle { %s }"
                     % (theme["memos/time/slider/style"],
                        theme["memos/time/slider/groove"],
                        theme["memos/time/slider/handle"]))
        self.timeslider.setStyleSheet(slidercss)

        larrow = PesterIcon(self.mainwindow.theme["memos/time/arrows/left"])
        self.timeswitchl.setIcon(larrow)
        self.timeswitchl.setIconSize(larrow.realsize())
        self.timeswitchl.setStyleSheet(self.mainwindow.theme["memos/time/arrows/style"])
        self.timetravel.setStyleSheet(self.mainwindow.theme["memos/time/buttons/style"])
        self.timeclose.setStyleSheet(self.mainwindow.theme["memos/time/buttons/style"])

        rarrow = PesterIcon(self.mainwindow.theme["memos/time/arrows/right"])
        self.timeswitchr.setIcon(rarrow)
        self.timeswitchr.setIconSize(rarrow.realsize())
        self.timeswitchr.setStyleSheet(self.mainwindow.theme["memos/time/arrows/style"])

        #if self.mainwindow.theme.has_key("main/menus/rclickchumlist/beeponmessage"):
        try:
            self._beepToggle.setText(self.mainwindow.theme["main/menus/rclickchumlist/beeponmessage"])
        except:
            self._beepToggle.setText("BEEP ON MESSAGE")

        #if self.mainwindow.theme.has_key("main/menus/rclickchumlist/flashonmessage"):
        try:
            self._flashToggle.setText(self.mainwindow.theme["main/menus/rclickchumlist/flashonmessage"])
        except:
            self._flashToggle.setText("FLASH ON MESSAGE")

        #if self.mainwindow.theme.has_key("main/menus/rclickchumlist/mutenotifications"):
        try:
            self._muteToggle.setText(self.mainwindow.theme["main/menus/rclickchumlist/mutenotifications"])
        except:
            self._muteToggle.setText("MUTE NOTIFICATIONS")

        #if self.mainwindow.theme.has_key("main/menus/rclickchumlist/pester"):
        try:
            self.pesterChumAction.setText(self.mainwindow.theme["main/menus/rclickchumlist/pester"])
        except:
            pass

    def changeTheme(self, theme):
        self.initTheme(theme)
        self.textArea.changeTheme(theme)
        self.textInput.changeTheme(theme)
        margins = theme["memos/margins"]
        self.layout.setContentsMargins(margins["left"], margins["top"],
                                  margins["right"], margins["bottom"])
        for item in [self.userlist.item(i) for i in range(0,self.userlist.count())]:
            self.iconCrap(item)

    def addUser(self, handle):
        chumdb = self.mainwindow.chumdb
        defaultcolor = QtGui.QColor("black")
        founder = False
        op =      False
        halfop =  False
        admin =   False
        voice =   False
        if handle[0] == '@':
            op = True
            handle = handle[1:]
            if handle == self.mainwindow.profile().handle:
                self.userlist.optionsMenu.addAction(self.opAction)
                self.userlist.optionsMenu.addAction(self.banuserAction)
                self.optionsMenu.addMenu(self.chanModeMenu)
                self.op = True
        elif handle[0] == '%':
            halfop = True
            handle = handle[1:]
            if handle == self.mainwindow.profile().handle:
                self.userlist.optionsMenu.addAction(self.opAction)
                self.userlist.optionsMenu.addAction(self.banuserAction)
                self.optionsMenu.addMenu(self.chanModeMenu)
                self.halfop = True
        elif handle[0] == '+':
            voice = True
            handle = handle[1:]
        elif handle[0] == '~':
            founder = True
            handle = handle[1:]
        elif handle[0] == '&':
            admin = True
            handle = handle[1:]
        item = QtWidgets.QListWidgetItem(handle)
        if handle == self.mainwindow.profile().handle:
            color = self.mainwindow.profile().color
        else:
            color = chumdb.getColor(handle, defaultcolor)
        item.box = (handle == "evacipatedBox")
        item.setForeground(QtGui.QBrush(color))
        item.founder = founder
        item.op = op
        item.halfop = halfop
        item.admin = admin
        item.voice = voice
        self.umodes = ["box", "founder", "admin", "op", "halfop", "voice"]
        self.iconCrap(item)
        self.userlist.addItem(item)
        self.sortUsers()

    def sortUsers(self):
        users = []
        listing = self.userlist.item(0)
        while listing is not None:
            users.append(self.userlist.takeItem(0))
            listing = self.userlist.item(0)
        users.sort(key=lambda x: ((-1 if x.box else (0 if x.founder else (1 if x.admin else (2 if x.op else (3 if x.halfop else (4 if x.voice else 5)))))), x.text()))
        for u in users:
            self.userlist.addItem(u)

    def updateChanModes(self, modes, op):
        if not hasattr(self, 'modes'): self.modes = ""
        chanmodes = list(str(self.modes))
        if chanmodes and chanmodes[0] == "+": chanmodes = chanmodes[1:]
        modes = str(modes)
        if op:
            systemColor = QtGui.QColor(self.mainwindow.theme["memos/systemMsgColor"])
            chum = self.mainwindow.profile()
            opchum = PesterProfile(op)
            if op in self.times:
                opgrammar = self.times[op].getGrammar()
            elif op == self.mainwindow.profile().handle:
                opgrammar = self.time.getGrammar()
            else:
                opgrammar = TimeGrammar("CURRENT", "C", "RIGHT NOW")
        if modes[0] == "+":
            for m in modes[1:]:
                if m not in chanmodes:
                    chanmodes.extend(m)
            # Make +c (disable ANSI colours) disable quirks.
            if modes.find("c") >= 0:
                self.chanNoquirks.setChecked(True)
                self.quirksOff.setChecked(True)
                self.applyquirks = False
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "A No-Quirk zone", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("s") >= 0:
                self.chanHide.setChecked(True)
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Secret", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("i") >= 0:
                self.chanInvite.setChecked(True)
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Invite-Only", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("m") >= 0:
                self.chanMod.setChecked(True)
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Muted", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)

            #New
            if modes.find("C") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "No-CTCP", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("D") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Join Delayed", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("f") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Flood Protected", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("G") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Censored", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("H") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Remembering Chat History", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("k") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Key-only", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("K") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "No-Knock", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("L") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Redirecting", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("K") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "No-Knock", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("l") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Limiting maximum amount of users", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("M") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Non-Auth muted", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("N") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Handle-locked", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("O") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "An Oper-Only channel", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("P") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Permanent", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("Q") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "No-kick", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("R") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Registered users only", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("r") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Registered", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("z") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Secure-only", True)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
        elif modes[0] == "-":
            for i in modes[1:]:
                try:
                    chanmodes.remove(i)
                except ValueError:
                    pass
            if modes.find("c") >= 0:
                self.chanNoquirks.setChecked(False)
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "A No-Quirk zone", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("s") >= 0:
                self.chanHide.setChecked(False)
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Secret", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("i") >= 0:
                self.chanInvite.setChecked(False)
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Invite-Only", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("m") >= 0:
                self.chanMod.setChecked(False)
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Muted", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)

            #New
            if modes.find("C") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "No-CTCP", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("D") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Join Delayed", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("f") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Flood Protected", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("G") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Censored", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("H") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Remembering Chat History", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("k") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Key-only", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("K") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "No-Knock", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("L") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Redirecting", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("K") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "No-Knock", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("l") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Limiting maximum amount of users", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("M") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Non-Auth muted", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("N") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Handle-locked", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("O") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "An Oper-Only channel", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("P") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Permanent", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("Q") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "No-kick", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("R") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Registered users only", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("r") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Registered", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            if modes.find("z") >= 0:
                if op:
                    msg = chum.memomodemsg(opchum, opgrammar, systemColor, "Secure-only", False)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
        chanmodes.sort()
        self.modes = "+" + "".join(chanmodes)
        if self.mainwindow.advanced:
            t = Template(self.mainwindow.theme["memos/label/text"])
            self.channelLabel.setText(t.safe_substitute(channel=self.channel)
                                      + "(%s)" % (self.modes))

    def timeUpdate(self, handle, cmd):
        window = self.mainwindow
        chum = PesterProfile(handle)
        systemColor = QtGui.QColor(window.theme["memos/systemMsgColor"])
        close = None
        # old TC command?
        try:
            secs = int(cmd)
            time = datetime.fromtimestamp(secs)
            timed = time - datetime.now()
            s = (timed.seconds // 60)*60
            timed = timedelta(timed.days, s)
        except OverflowError:
            if secs < 0:
                timed = timedelta.min
            else:
                timed = timedelta.max
        except (OSError, ValueError) as e:
            try:
                if cmd == "i":
                    timed = timedelta(0)
                else:
                    if cmd[len(cmd)-1] == 'c':
                        close = timeProtocol(cmd)
                        timed = None
                    else:
                        timed = timeProtocol(cmd)
            except:
                PchumLog.warning("Invalid PESTERCHUM:TIME> " + str(cmd))
                timed = timedelta(0)

        if handle in self.times:
            if close is not None:
                if close in self.times[handle]:
                    self.times[handle].setCurrent(close)
                    grammar = self.times[handle].getGrammar()
                    self.times[handle].removeTime(close)
                    msg = chum.memoclosemsg(systemColor,
                                            grammar,
                                            window.theme["convo/text/closememo"])
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
            elif timed not in self.times[handle]:
                self.times[handle].addTime(timed)
            else:
                self.times[handle].setCurrent(timed)
        else:
            if timed is not None:
                ttracker = TimeTracker(timed)
                self.times[handle] = ttracker

    @QtCore.pyqtSlot()
    def sentMessage(self):
        text = str(self.textInput.text())
        
        return parsetools.kxhandleInput(self, text, flavor="memos")
        
    @QtCore.pyqtSlot(QString)
    def namesUpdated(self, channel):
        c = str(channel)
        if c.lower() != self.channel.lower(): return
        # get namesdb (unused)
        #namesdb = self.mainwindow.namesdb
        # reload names
        self.userlist.clear()
        for n in self.mainwindow.namesdb[self.channel]:
            self.addUser(n)
    @QtCore.pyqtSlot(QString, QString)
    def modesUpdated(self, channel, modes):
        c = str(channel)
        if c.lower() == self.channel.lower():
            self.updateChanModes(modes, None)

    @QtCore.pyqtSlot(QString)
    def closeInviteOnly(self, channel):
        c = str(channel)
        if c.lower() == self.channel.lower():
            self.mainwindow.inviteOnlyChan['QString'].disconnect(self.closeInviteOnly)
            if self.parent():
                PchumLog.info(self.channel)
                i = self.parent().tabIndices[self.channel]
                self.parent().tabClose(i)
            else:
                self.close()
            msgbox = QtWidgets.QMessageBox()
            msgbox.setStyleSheet("QMessageBox{ %s }"
                                 % self.mainwindow.theme["main/defaultwindow/style"])
            msgbox.setText("%s: Invites only!" % (c))
            msgbox.setInformativeText("This channel is invite-only. "
                                      "You must get an invitation from someone on the inside before entering.")
            msgbox.setStandardButtons(QtWidgets.QMessageBox.StandardButton.Ok)
            msgbox.exec()

    @QtCore.pyqtSlot(QString, QString)
    def closeForbidden(self, channel, reason):
        c = str(channel)
        if c.lower() == self.channel.lower():
            self.mainwindow.forbiddenChan['QString', 'QString'].disconnect(self.closeForbidden)
            if self.parent():
                PchumLog.info(self.channel)
                i = self.parent().tabIndices[self.channel]
                self.parent().tabClose(i)
            else:
                self.close()
            msgbox = QtWidgets.QMessageBox()
            msgbox.setStyleSheet("QMessageBox{ %s }"
                                 % self.mainwindow.theme["main/defaultwindow/style"])
            msgbox.setText("%s: D: CANT JOIN MEMO!!!" % (c))
            msgbox.setInformativeText(reason)
            msgbox.setStandardButtons(QtWidgets.QMessageBox.StandardButton.Ok)
            msgbox.exec()

    def quirkDisable(self, op, msg):
        chums = self.userlist.findItems(op, QtCore.Qt.MatchFlag.MatchExactly) 
        for c in chums:
            if c.op:
                if msg == self.mainwindow.profile().handle:
                    self.quirksOff.setChecked(True)
                    self.applyquirks = False
                    systemColor = QtGui.QColor(self.mainwindow.theme["memos/systemMsgColor"])
                    chum = self.mainwindow.profile()
                    opchum = PesterProfile(op)
                    if op in self.times:
                        opgrammar = self.times[op].getGrammar()
                    elif op == self.mainwindow.profile().handle:
                        opgrammar = self.time.getGrammar()
                    else:
                        opgrammar = TimeGrammar("CURRENT", "C", "RIGHT NOW")
                    msg = chum.memoquirkkillmsg(opchum, opgrammar, systemColor)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)

    def chumOPstuff(self, h, op):
        chum = PesterProfile(h)
        if h == self.mainwindow.profile().handle:
            chum = self.mainwindow.profile()
            #ttracker = self.time
            #curtime = self.time.getTime()
        #elif h in self.times:
        #    ttracker = self.times[h]
        #else:
        #    ttracker = TimeTracker(timedelta(0))
        opchum = PesterProfile(op)
        PchumLog.debug("op = " + op)
        PchumLog.debug("opchum = " + opchum.handle)
        if op in self.times:
            opgrammar = self.times[op].getGrammar()
        elif op == self.mainwindow.profile().handle:
            opgrammar = self.time.getGrammar()
        else:
            opgrammar = TimeGrammar("CURRENT", "C", "RIGHT NOW")
        return (chum, opchum, opgrammar)
    def iconCrap(self, c, down=True):
        for m in (self.umodes if down else reversed(self.umodes)):
            if eval("c."+m):
                if m == "box":
                    icon = PesterIcon("smilies/box.png")
                else:
                    icon = PesterIcon(self.mainwindow.theme["memos/"+m+"/icon"])
                c.setIcon(icon)
                return
        icon = QtGui.QIcon()
        c.setIcon(icon)

    @QtCore.pyqtSlot()
    def dumpNetsplit(self):
        if (len(self.netsplit) > 0):
            chum = self.mainwindow.profile()
            systemColor = QtGui.QColor(self.mainwindow.theme["memos/systemMsgColor"])
            msg = chum.memonetsplitmsg(systemColor, self.netsplit)
            self.textArea.append(convertTags(msg))
            self.mainwindow.chatlog.log(self.channel, msg)
        del self.netsplit

    @QtCore.pyqtSlot(QString, QString, QString)
    def userPresentChange(self, handle, channel, update):
        #print("handle: %s, channel: %s, update: %s" % (handle, channel, update))
        h = str(handle)
        c = str(channel)
        update = str(update)
        #PchumLog.debug("h=%s\nc=%s\nupdate=%s" % (h,c,update))
        if update[0:4] == "kick": # yeah, i'm lazy.
            l = update.split(":")
            update = l[0]
            op = l[1]
            reason = ":".join(l[2:])
        if update == "nick":
            l = h.split(":")
            oldnick = l[0]
            newnick = l[1]
            h = oldnick
        if update[0:1] in ["+", "-"]:
            l = update.split(":")
            update = l[0]
            op = l[1]
        if (update in ["join","left", "kick", \
                       "+q", "-q", "+o", "-o", "+h", "-h", \
                       "+a", "-a", "+v", "-v"]) \
                and c.lower() != self.channel.lower():
            return
        chums = self.userlist.findItems(h, QtCore.Qt.MatchFlag.MatchExactly) 
        systemColor = QtGui.QColor(self.mainwindow.theme["memos/systemMsgColor"])
        # print exit
        if update in ("quit", "left", "nick", "netsplit"):
            if update == "netsplit":
                if not hasattr(self, "netsplit"):
                    self.netsplit = []
                    QtCore.QTimer.singleShot(1500,
                                             self,
                                             QtCore.SLOT('dumpNetsplit()'))
            for c in chums:
                chum = PesterProfile(h)
                self.userlist.takeItem(self.userlist.row(c))
                if h not in self.times:
                    self.times[h] = TimeTracker(timedelta(0))
                allinitials = []
                while self.times[h].getTime() is not None:
                    t = self.times[h]
                    grammar = t.getGrammar()
                    allinitials.append("%s%s%s" % (grammar.pcf,
                                                   chum.initials(),
                                                   grammar.number))
                    self.times[h].removeTime(t.getTime())
                if update == "netsplit":
                    self.netsplit.extend(allinitials)
                else:
                    msg = chum.memoclosemsg(systemColor,
                                            allinitials,
                                            self.mainwindow.theme["convo/text/closememo"])
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
                if update == "nick":
                    self.addUser(newnick)
                    newchums = self.userlist.findItems(newnick,
                                                       QtCore.Qt.MatchFlag.MatchExactly)
                    for nc in newchums:
                        for c in chums:
                            nc.founder = c.founder
                            nc.op      = c.op
                            nc.halfop  = c.halfop
                            nc.admin   = c.admin
                            self.iconCrap(nc)
                    self.sortUsers()
        elif update == "kick":
            if len(chums) == 0:
                return
            c = chums[0]
            chum = PesterProfile(h)
            if h == self.mainwindow.profile().handle:
                chum = self.mainwindow.profile()
                ttracker = self.time
                curtime = self.time.getTime()
            elif h in self.times:
                ttracker = self.times[h]
            else:
                ttracker = TimeTracker(timedelta(0))
            allinitials = []
            opchum = PesterProfile(op)
            if op in self.times:
                opgrammar = self.times[op].getGrammar()
            elif op == self.mainwindow.profile().handle:
                opgrammar = self.time.getGrammar()
            else:
                opgrammar = TimeGrammar("CURRENT", "C", "RIGHT NOW")
            while ttracker.getTime() is not None:
                grammar = ttracker.getGrammar()
                allinitials.append("%s%s%s" % (grammar.pcf, chum.initials(), grammar.number))
                ttracker.removeTime(ttracker.getTime())
            msg = chum.memobanmsg(opchum, opgrammar, systemColor, allinitials, reason)
            self.textArea.append(convertTags(msg))
            self.mainwindow.chatlog.log(self.channel, msg)

            if chum is self.mainwindow.profile():
                # are you next?
                msgbox = QtWidgets.QMessageBox()
                msgbox.setStyleSheet("QMessageBox{ %s }"
                                     % self.mainwindow.theme["main/defaultwindow/style"])
                msgbox.setText(self.mainwindow.theme["convo/text/kickedmemo"])

                # Add ban(kick) reason
                # l = split update
                kick_msg = ("press 0k to rec0nnect or cancel to absc0nd")
                if len(l) >= 3:
                    try:
                        if l[1] != l[2]: # If there's no reason then reason is set to handle
                            # Process spare ':' characters (this might not be safe?)
                            aggrievocation = l[1] + ": " + l[2]
                            if len(l) > 3:
                                aggrievocation += ':'
                                for x in range(3, len(l)):
                                    aggrievocation += l[x]
                                    # Not for last slice
                                    if x != (len(l)-1):
                                        aggrievocation += ':'
                            kick_msg = ("%s\n\npress 0k to rec0nnect or cancel to absc0nd" % aggrievocation)
                    except IndexError as e:
                        # This shouldn't happen
                        PchumLog.warning("kickmsg IndexError: %s" % e)
                msgbox.setInformativeText(kick_msg)
                msgbox.setStandardButtons(QtWidgets.QMessageBox.StandardButton.Ok | QtWidgets.QMessageBox.StandardButton.Cancel)
                # Find the OK button and make it default
                for b in msgbox.buttons():
                    if msgbox.buttonRole(b) == QtWidgets.QMessageBox.ButtonRole.AcceptRole:
                        # We found the 'OK' button, set it as the default
                        b.setDefault(True)
                        b.setAutoDefault(True)
                        # Actually set it as the selected option, since we're
                        # already stealing focus
                        b.setFocus()
                        break
                ret = msgbox.exec()
                if ret == QtWidgets.QMessageBox.StandardButton.Ok:
                    self.userlist.clear()
                    self.time = TimeTracker(curtime)
                    self.resetSlider(curtime)
                    self.mainwindow.joinChannel.emit(self.channel)
                    me = self.mainwindow.profile()
                    self.time.openCurrentTime()
                    msg = me.memoopenmsg(systemColor,
                                         self.time.getTime(),
                                         self.time.getGrammar(),
                                         self.mainwindow.theme["convo/text/openmemo"],
                                         self.channel)
                    self.textArea.append(convertTags(msg))
                    self.mainwindow.chatlog.log(self.channel, msg)
                elif ret == QtWidgets.QMessageBox.StandardButton.Cancel:
                    if self.parent():
                        i = self.parent().tabIndices[self.channel]
                        self.parent().tabClose(i)
                    else:
                        self.close()
            else:
                # i warned you about those stairs bro
                self.userlist.takeItem(self.userlist.row(c))
        elif update == "join":
            self.addUser(h)
            time = self.time.getTime()
            serverText = "PESTERCHUM:TIME>"+delta2txt(time, "server")
            self.messageSent.emit(serverText, self.title())
        elif update == "+q":
            for c in chums:
                c.founder = True
                self.iconCrap(c)
            self.sortUsers()
        elif update == "-q":
            for c in chums:
                c.founder = False
                self.iconCrap(c)
            self.sortUsers()
        elif update == "+o":
            if self.mainwindow.config.opvoiceMessages():
                (chum, opchum, opgrammar) = self.chumOPstuff(h, op)
                #PchumLog.debug("chum.handle = %s\nopchum.handle = %s\nopgrammar = %s\n systemColor = %s\n"
                #               % (chum.handle, opchum.handle, opgrammar, systemColor))
                msg = chum.memoopmsg(opchum, opgrammar, systemColor)
                #PchumLog.debug("post memoopmsg")
                self.textArea.append(convertTags(msg))
                self.mainwindow.chatlog.log(self.channel, msg)
            for c in chums:
                c.op = True
                self.iconCrap(c)
                if str(c.text()) == self.mainwindow.profile().handle:
                    self.userlist.optionsMenu.addAction(self.opAction)
                    self.userlist.optionsMenu.addAction(self.voiceAction)
                    self.userlist.optionsMenu.addAction(self.banuserAction)
                    self.userlist.optionsMenu.addAction(self.quirkDisableAction)
                    self.optionsMenu.addMenu(self.chanModeMenu)
            self.sortUsers()
        elif update == "-o":
            self.mainwindow.channelNames.emit(self.channel)
            if self.mainwindow.config.opvoiceMessages():
                (chum, opchum, opgrammar) = self.chumOPstuff(h, op)
                msg = chum.memodeopmsg(opchum, opgrammar, systemColor)
                self.textArea.append(convertTags(msg))
                self.mainwindow.chatlog.log(self.channel, msg)
            for c in chums:
                c.op = False
                self.iconCrap(c)
                if str(c.text()) == self.mainwindow.profile().handle:
                    self.userlist.optionsMenu.removeAction(self.opAction)
                    self.userlist.optionsMenu.removeAction(self.voiceAction)
                    self.userlist.optionsMenu.removeAction(self.banuserAction)
                    self.userlist.optionsMenu.removeAction(self.quirkDisableAction)
                    self.optionsMenu.removeAction(self.chanModeMenu.menuAction())
            self.sortUsers()
        elif update == "+h":
            if self.mainwindow.config.opvoiceMessages():
                (chum, opchum, opgrammar) = self.chumOPstuff(h, op)
                msg = chum.memoopmsg(opchum, opgrammar, systemColor)
                self.textArea.append(convertTags(msg))
                self.mainwindow.chatlog.log(self.channel, msg)
            for c in chums:
                c.halfop = True
                self.iconCrap(c)
                if str(c.text()) == self.mainwindow.profile().handle:
                    self.userlist.optionsMenu.addAction(self.opAction)
                    self.userlist.optionsMenu.addAction(self.voiceAction)
                    self.userlist.optionsMenu.addAction(self.banuserAction)
                    self.userlist.optionsMenu.addAction(self.quirkDisableAction)
                    self.optionsMenu.addMenu(self.chanModeMenu)
            self.sortUsers()
        elif update == "-h":
            self.mainwindow.channelNames.emit(self.channel)
            if self.mainwindow.config.opvoiceMessages():
                (chum, opchum, opgrammar) = self.chumOPstuff(h, op)
                msg = chum.memodeopmsg(opchum, opgrammar, systemColor)
                self.textArea.append(convertTags(msg))
                self.mainwindow.chatlog.log(self.channel, msg)
            for c in chums:
                c.halfop = False
                self.iconCrap(c)
                if str(c.text()) == self.mainwindow.profile().handle:
                    self.userlist.optionsMenu.removeAction(self.opAction)
                    self.userlist.optionsMenu.removeAction(self.voiceAction)
                    self.userlist.optionsMenu.removeAction(self.banuserAction)
                    self.userlist.optionsMenu.removeAction(self.quirkDisableAction)
                    self.optionsMenu.removeAction(self.chanModeMenu.menuAction())
            self.sortUsers()
        elif update == "+a":
            for c in chums:
                c.admin = True
                self.iconCrap(c)
            self.sortUsers()
        elif update == "-a":
            for c in chums:
                c.admin = False
                self.iconCrap(c)
            self.sortUsers()
        elif c.lower() == self.channel.lower() and h == "" and update[0] in ["+","-"]:
            self.updateChanModes(update, op)
        elif update == "+v":
            if self.mainwindow.config.opvoiceMessages():
                (chum, opchum, opgrammar) = self.chumOPstuff(h, op)
                msg = chum.memovoicemsg(opchum, opgrammar, systemColor)
                self.textArea.append(convertTags(msg))
                self.mainwindow.chatlog.log(self.channel, msg)
            for c in chums:
                c.voice = True
                self.iconCrap(c)
            self.sortUsers()
        elif update == "-v":
            if self.mainwindow.config.opvoiceMessages():
                (chum, opchum, opgrammar) = self.chumOPstuff(h, op)
                msg = chum.memodevoicemsg(opchum, opgrammar, systemColor)
                self.textArea.append(convertTags(msg))
                self.mainwindow.chatlog.log(self.channel, msg)
            for c in chums:
                c.voice = False
                self.iconCrap(c)
            self.sortUsers()
        elif c.lower() == self.channel.lower() and h == "" and update[0] in ["+","-"]:
            self.updateChanModes(update, op)

    @QtCore.pyqtSlot()
    def newPesterSlot(self):
        # We're opening a pester with someone in our user list.
        user = self.userlist.currentItem()
        if not user:
            return
        user = str(user.text())
        self.mainwindow.newConversation(user)

    @QtCore.pyqtSlot()
    def addChumSlot(self):
        if not self.userlist.currentItem():
            return
        currentChum = PesterProfile(str(self.userlist.currentItem().text()))
        self.mainwindow.addChum(currentChum)
    @QtCore.pyqtSlot()
    def banSelectedUser(self):
        if not self.userlist.currentItem():
            return
        currentHandle = str(self.userlist.currentItem().text())
        (reason, ok) = QtWidgets.QInputDialog.getText(self,
                                                      "Ban User",
                                                      "Enter the reason you are banning this user (optional):")
        if ok:
            self.mainwindow.kickUser.emit("%s:%s" % (currentHandle, reason), self.channel)
    @QtCore.pyqtSlot()
    def opSelectedUser(self):
        if not self.userlist.currentItem():
            return
        currentHandle = str(self.userlist.currentItem().text())
        self.mainwindow.setChannelMode.emit(self.channel, "+o", currentHandle)
    @QtCore.pyqtSlot()
    def voiceSelectedUser(self):
        if not self.userlist.currentItem():
            return
        currentHandle = str(self.userlist.currentItem().text())
        self.mainwindow.setChannelMode.emit(self.channel, "+v", currentHandle)
    @QtCore.pyqtSlot()
    def killQuirkUser(self):
        if not self.userlist.currentItem():
            return
        currentHandle = str(self.userlist.currentItem().text())
        self.mainwindow.killSomeQuirks.emit(self.channel, currentHandle)

    def resetSlider(self, time, send=True):
        self.timeinput.setText(delta2txt(time))
        self.timeinput.setSlider()
        if send:
            self.sendtime()

    @QtCore.pyqtSlot()
    def openChumLogs(self):
        currentChum = self.channel
        self.mainwindow.chumList.pesterlogviewer = PesterLogViewer(currentChum,
                                                                   self.mainwindow.config,
                                                                   self.mainwindow.theme,
                                                                   self.mainwindow)
        self.mainwindow.chumList.pesterlogviewer.rejected.connect(self.mainwindow.chumList.closeActiveLog)
        self.mainwindow.chumList.pesterlogviewer.show()
        self.mainwindow.chumList.pesterlogviewer.raise_()
        self.mainwindow.chumList.pesterlogviewer.activateWindow()

    @QtCore.pyqtSlot()
    def inviteChums(self):
        if not hasattr(self, 'invitechums'):
            self.invitechums = None
        if not self.invitechums:
            (chum, ok) = QtWidgets.QInputDialog.getText(self,
                                                        "Invite to Chat",
                                                        "Enter the chumhandle of the user you'd like to invite:")
            if ok:
                chum = str(chum)
                self.mainwindow.inviteChum.emit(chum, self.channel)
            self.invitechums = None

    @QtCore.pyqtSlot(bool)
    def noquirksChan(self, on):
        x = ["-","+"][on]
        self.mainwindow.setChannelMode.emit(self.channel, x+"c", "")
    @QtCore.pyqtSlot(bool)
    def hideChan(self, on):
        x = ["-","+"][on]
        self.mainwindow.setChannelMode.emit(self.channel, x+"s", "")
    @QtCore.pyqtSlot(bool)
    def inviteChan(self, on):
        x = ["-","+"][on]
        self.mainwindow.setChannelMode.emit(self.channel, x+"i", "")
    @QtCore.pyqtSlot(bool)
    def modChan(self, on):
        x = ["-","+"][on]
        self.mainwindow.setChannelMode.emit(self.channel, x+"m", "")

    @QtCore.pyqtSlot()
    def sendtime(self):
        #me = self.mainwindow.profile()
        #systemColor = QtGui.QColor(self.mainwindow.theme["memos/systemMsgColor"])
        time = txt2delta(self.timeinput.text())
        #present = self.time.addTime(time)
        self.time.addTime(time)

        serverText = "PESTERCHUM:TIME>"+delta2txt(time, "server")
        self.messageSent.emit(serverText, self.title())
    @QtCore.pyqtSlot()
    def smashclock(self):
        me = self.mainwindow.profile()
        time = txt2delta(self.timeinput.text())
        removed = self.time.removeTime(time)
        if removed:
            grammar = self.time.getGrammarTime(time)
            systemColor = QtGui.QColor(self.mainwindow.theme["memos/systemMsgColor"])
            msg = me.memoclosemsg(systemColor, grammar, self.mainwindow.theme["convo/text/closememo"])
            self.textArea.append(convertTags(msg))
            self.mainwindow.chatlog.log(self.channel, msg)

        newtime = self.time.getTime()
        if newtime is None:
            newtime = timedelta(0)
            self.resetSlider(newtime, send=False)
        else:
            self.resetSlider(newtime)
    @QtCore.pyqtSlot()
    def prevtime(self):
        time = self.time.prevTime()
        self.time.setCurrent(time)
        self.resetSlider(time)
        self.textInput.setFocus()
    @QtCore.pyqtSlot()
    def nexttime(self):
        time = self.time.nextTime()
        self.time.setCurrent(time)
        self.resetSlider(time)
        self.textInput.setFocus()
    def closeEvent(self, event):
        self.mainwindow.waitingMessages.messageAnswered(self.channel)
        self.windowClosed.emit(self.title())

    windowClosed = QtCore.pyqtSignal('QString')


timelist = ["0:00",
            "0:01",
            "0:02",
            "0:04",
            "0:06",
            "0:10",
            "0:14",
            "0:22",
            "0:30",
            "0:41",
            "1:00",
            "1:34",
            "2:16",
            "3:14",
            "4:13",
            "4:20",
            "5:25",
            "6:12",
            "7:30",
            "8:44",
            "10:25",
            "11:34",
            "14:13",
            "16:12",
            "17:44",
            "22:22",
            "25:10",
            "33:33",
            "42:00",
            "43:14",
            "50:00",
            "62:12",
            "75:00",
            "88:44",
            "100",
            "133",
            "143",
            "188",
            "200",
            "222",
            "250",
            "314",
            "333",
            "413",
            "420",
            "500",
            "600",
            "612",
            "888",
            "1000",
            "1025"]

timedlist = [timedelta(0),
             timedelta(0, 60),
             timedelta(0, 120),
             timedelta(0, 240),
             timedelta(0, 360),
             timedelta(0, 600),
             timedelta(0, 840),
             timedelta(0, 1320),
             timedelta(0, 1800),
             timedelta(0, 2460),
             timedelta(0, 3600),
             timedelta(0, 5640),
             timedelta(0, 8160),
             timedelta(0, 11640),
             timedelta(0, 15180),
             timedelta(0, 15600),
             timedelta(0, 19500),
             timedelta(0, 22320),
             timedelta(0, 27000),
             timedelta(0, 31440),
             timedelta(0, 37500),
             timedelta(0, 41640),
             timedelta(0, 51180),
             timedelta(0, 58320),
             timedelta(0, 63840),
             timedelta(0, 80520),
             timedelta(1, 4200),
             timedelta(1, 34380),
             timedelta(1, 64800),
             timedelta(1, 69240),
             timedelta(2, 7200),
             timedelta(2, 51120),
             timedelta(3, 10800),
             timedelta(3, 60240),
             timedelta(4, 14400),
             timedelta(5, 46800),
             timedelta(5, 82800),
             timedelta(7, 72000),
             timedelta(8, 28800),
             timedelta(9, 21600),
             timedelta(10, 36000),
             timedelta(13, 7200),
             timedelta(13, 75600),
             timedelta(17, 18000),
             timedelta(17, 43200),
             timedelta(20, 72000),
             timedelta(25),
             timedelta(25, 43200),
             timedelta(37),
             timedelta(41, 57600),
             timedelta(42, 61200)]