c9f71b0c64
addch() and addstr() throw an exception if text has to be printed outside of the window. This may occur if the terminal is very small. Such erroneous prints are no-ops now. Signed-off-by: Mart Lubbers <mart@martlubbers.net> Signed-off-by: Nicolas Sebrecht <nicolas.s-dev@laposte.net> Github-ref: https://github.com/OfflineIMAP/offlineimap/issues/595
674 lines
23 KiB
Python
674 lines
23 KiB
Python
# Curses-based interfaces
|
|
# Copyright (C) 2003-2018 John Goerzen & contributors.
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
from threading import RLock, currentThread, Lock, Event
|
|
from collections import deque
|
|
import time
|
|
import sys
|
|
import os
|
|
import curses
|
|
import logging
|
|
|
|
from offlineimap.ui.UIBase import UIBase
|
|
from offlineimap.threadutil import ExitNotifyThread
|
|
import offlineimap
|
|
|
|
|
|
class CursesUtil:
|
|
def __init__(self, *args, **kwargs):
|
|
# iolock protects access to the
|
|
self.iolock = RLock()
|
|
self.tframe_lock = RLock()
|
|
# tframe_lock protects the self.threadframes manipulation to
|
|
# only happen from 1 thread.
|
|
self.colormap = {}
|
|
"""dict, translating color string to curses color pair number"""
|
|
|
|
def curses_colorpair(self, col_name):
|
|
"""Return the curses color pair, that corresponds to the color."""
|
|
|
|
return curses.color_pair(self.colormap[col_name])
|
|
|
|
def init_colorpairs(self):
|
|
"""Initialize the curses color pairs available."""
|
|
|
|
# set special colors 'gray' and 'banner'
|
|
self.colormap['white'] = 0 #hardcoded by curses
|
|
curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLUE)
|
|
self.colormap['banner'] = 1 # color 'banner' for bannerwin
|
|
|
|
bcol = curses.COLOR_BLACK
|
|
colors = ( # name, color, bold?
|
|
('black', curses.COLOR_BLACK, False),
|
|
('blue', curses.COLOR_BLUE,False),
|
|
('red', curses.COLOR_RED, False),
|
|
('purple', curses.COLOR_MAGENTA, False),
|
|
('cyan', curses.COLOR_CYAN, False),
|
|
('green', curses.COLOR_GREEN, False),
|
|
('orange', curses.COLOR_YELLOW, False))
|
|
#set the rest of all colors starting at pair 2
|
|
i = 1
|
|
for name, fcol, bold in colors:
|
|
i += 1
|
|
self.colormap[name] = i
|
|
curses.init_pair(i, fcol, bcol)
|
|
|
|
def lock(self, block=True):
|
|
"""Locks the Curses ui thread.
|
|
|
|
Can be invoked multiple times from the owning thread. Invoking
|
|
from a non-owning thread blocks and waits until it has been
|
|
unlocked by the owning thread."""
|
|
|
|
return self.iolock.acquire(block)
|
|
|
|
def unlock(self):
|
|
"""Unlocks the Curses ui thread.
|
|
|
|
Decrease the lock counter by one and unlock the ui thread if the
|
|
counter reaches 0. Only call this method when the calling
|
|
thread owns the lock. A RuntimeError is raised if this method is
|
|
called when the lock is unlocked."""
|
|
|
|
self.iolock.release()
|
|
|
|
def exec_locked(self, target, *args, **kwargs):
|
|
"""Perform an operation with full locking."""
|
|
|
|
self.lock()
|
|
try:
|
|
target(*args, **kwargs)
|
|
finally:
|
|
self.unlock()
|
|
|
|
def refresh(self):
|
|
def lockedstuff():
|
|
curses.panel.update_panels()
|
|
curses.doupdate()
|
|
self.exec_locked(lockedstuff)
|
|
|
|
def isactive(self):
|
|
return hasattr(self, 'stdscr')
|
|
|
|
|
|
class CursesAccountFrame:
|
|
"""Notable instance variables:
|
|
|
|
- account: corresponding Account()
|
|
- children
|
|
- ui
|
|
- key
|
|
- window: curses window associated with an account
|
|
"""
|
|
|
|
def __init__(self, ui, account):
|
|
"""
|
|
:param account: An Account() or None (for eg SyncrunnerThread)"""
|
|
|
|
self.children = []
|
|
self.account = account if account else '*Control'
|
|
self.ui = ui
|
|
self.window = None
|
|
# Curses window associated with this acc.
|
|
self.acc_num = None
|
|
# Account number (& hotkey) associated with this acc.
|
|
self.location = 0
|
|
# length of the account prefix string
|
|
|
|
def drawleadstr(self, secs = 0):
|
|
"""Draw the account status string.
|
|
|
|
secs tells us how long we are going to sleep."""
|
|
|
|
sleepstr = '%3d:%02d'% (secs // 60, secs % 60) if secs else 'active'
|
|
accstr = '%s: [%s] %12.12s: '% (self.acc_num, sleepstr, self.account)
|
|
|
|
def addstr():
|
|
try:
|
|
self.window.addstr(0, 0, accstr)
|
|
except curses.error as e: # Occurs when the terminal is very small
|
|
pass
|
|
self.ui.exec_locked(addstr);
|
|
|
|
self.location = len(accstr)
|
|
|
|
def setwindow(self, curses_win, acc_num):
|
|
"""Register an curses win and a hotkey as Account window.
|
|
|
|
:param curses_win: the curses window associated with an account
|
|
:param acc_num: int denoting the hotkey associated with this account."""
|
|
|
|
self.window = curses_win
|
|
self.acc_num = acc_num
|
|
self.drawleadstr()
|
|
self.ui.exec_locked(self.window.noutrefresh)
|
|
# Update the child ThreadFrames
|
|
for child in self.children:
|
|
child.update(curses_win, self.location, 0)
|
|
self.location += 1
|
|
|
|
def get_new_tframe(self):
|
|
"""Create a new ThreadFrame and append it to self.children.
|
|
|
|
:returns: The new ThreadFrame"""
|
|
|
|
tf = CursesThreadFrame(self.ui, self.window, self.location, 0)
|
|
self.location += 1
|
|
self.children.append(tf)
|
|
return tf
|
|
|
|
def sleeping(self, sleepsecs, remainingsecs):
|
|
"""Show how long we are going to sleep and sleep.
|
|
|
|
:returns: Boolean, whether we want to abort the sleep"""
|
|
|
|
self.drawleadstr(remainingsecs)
|
|
self.ui.exec_locked(self.window.refresh)
|
|
time.sleep(sleepsecs)
|
|
return self.account.get_abort_event()
|
|
|
|
def syncnow(self):
|
|
"""Request that we stop sleeping asap and continue to sync."""
|
|
|
|
# if this belongs to an Account (and not *Control), set the
|
|
# skipsleep pref
|
|
if isinstance(self.account, offlineimap.accounts.Account):
|
|
self.ui.info("Requested synchronization for acc: %s"% self.account)
|
|
self.account.config.set('Account %s'% self.account.name,
|
|
'skipsleep', '1')
|
|
|
|
class CursesThreadFrame:
|
|
"""curses_color: current color pair for logging."""
|
|
|
|
def __init__(self, ui, acc_win, x, y):
|
|
"""
|
|
:param ui: is a Blinkenlights() instance
|
|
:param acc_win: curses Account window"""
|
|
|
|
self.ui = ui
|
|
self.window = acc_win
|
|
self.x = x
|
|
self.y = y
|
|
self.curses_color = curses.color_pair(0) #default color
|
|
|
|
def setcolor(self, color, modifier=0):
|
|
"""Draw the thread symbol '@' in the specified color
|
|
|
|
:param modifier: Curses modified, such as curses.A_BOLD
|
|
"""
|
|
|
|
self.curses_color = modifier | self.ui.curses_colorpair(color)
|
|
self.colorname = color
|
|
self.display()
|
|
|
|
def display(self):
|
|
def locked_display():
|
|
try:
|
|
self.window.addch(self.y, self.x, '@', self.curses_color)
|
|
except curses.error: # Occurs when the terminal is very small
|
|
pass
|
|
self.window.refresh()
|
|
# lock the curses IO while fudging stuff
|
|
self.ui.exec_locked(locked_display)
|
|
|
|
def update(self, acc_win, x, y):
|
|
"""Update the xy position of the '.' (and possibly the aframe)."""
|
|
|
|
self.window = acc_win
|
|
self.y = y
|
|
self.x = x
|
|
self.display()
|
|
|
|
def std_color(self):
|
|
self.setcolor('black')
|
|
|
|
|
|
class InputHandler(ExitNotifyThread):
|
|
"""Listens for input via the curses interfaces"""
|
|
|
|
#TODO, we need to use the ugly exitnotifythread (rather than simply
|
|
#threading.Thread here, so exiting this thread via the callback
|
|
#handler, kills off all parents too. Otherwise, they would simply
|
|
#continue.
|
|
def __init__(self, ui):
|
|
super(InputHandler, self).__init__()
|
|
self.char_handler = None
|
|
self.ui = ui
|
|
self.enabled = Event()
|
|
# We will only parse input if we are enabled.
|
|
self.inputlock = RLock()
|
|
# denotes whether we should be handling the next char.
|
|
self.start() #automatically start the thread
|
|
|
|
def get_next_char(self):
|
|
"""Return the key pressed or -1.
|
|
|
|
Wait until `enabled` and loop internally every stdscr.timeout()
|
|
msecs, releasing the inputlock.
|
|
:returns: char or None if disabled while in here"""
|
|
|
|
self.enabled.wait()
|
|
while self.enabled.is_set():
|
|
with self.inputlock:
|
|
char = self.ui.stdscr.getch()
|
|
if char != -1: yield char
|
|
|
|
def run(self):
|
|
while True:
|
|
char_gen = self.get_next_char()
|
|
for char in char_gen:
|
|
self.char_handler(char)
|
|
#curses.ungetch(char)
|
|
|
|
def set_char_hdlr(self, callback):
|
|
"""Sets a character callback handler.
|
|
|
|
If a key is pressed it will be passed to this handler. Keys
|
|
include the curses.KEY_RESIZE key.
|
|
|
|
callback is a function taking a single arg -- the char pressed.
|
|
If callback is None, input will be ignored."""
|
|
|
|
with self.inputlock:
|
|
self.char_handler = callback
|
|
# start or stop the parsing of things
|
|
if callback is None:
|
|
self.enabled.clear()
|
|
else:
|
|
self.enabled.set()
|
|
|
|
def input_acquire(self):
|
|
"""Call this method when you want exclusive input control.
|
|
|
|
Make sure to call input_release afterwards! While this lockis
|
|
held, input can go to e.g. the getpass input."""
|
|
|
|
self.enabled.clear()
|
|
self.inputlock.acquire()
|
|
|
|
def input_release(self):
|
|
"""Call this method when you are done getting input."""
|
|
|
|
self.inputlock.release()
|
|
self.enabled.set()
|
|
|
|
|
|
class CursesLogHandler(logging.StreamHandler):
|
|
"""self.ui has been set to the UI class before anything is invoked"""
|
|
|
|
def emit(self, record):
|
|
log_str = logging.StreamHandler.format(self, record)
|
|
color = self.ui.gettf().curses_color
|
|
# We must acquire both locks. Otherwise, deadlock can result.
|
|
# This can happen if one thread calls _msg (locking curses, then
|
|
# tf) and another tries to set the color (locking tf, then curses)
|
|
#
|
|
# By locking both up-front here, in this order, we prevent deadlock.
|
|
self.ui.tframe_lock.acquire()
|
|
self.ui.lock()
|
|
try:
|
|
y,x = self.ui.logwin.getyx()
|
|
if y or x: self.ui.logwin.addch(10) # no \n before 1st item
|
|
self.ui.logwin.addstr(log_str, color)
|
|
self.ui.logwin.noutrefresh()
|
|
self.ui.stdscr.refresh()
|
|
finally:
|
|
self.ui.unlock()
|
|
self.ui.tframe_lock.release()
|
|
|
|
class Blinkenlights(UIBase, CursesUtil):
|
|
"""Curses-cased fancy UI.
|
|
|
|
Notable instance variables self. ....:
|
|
|
|
- stdscr: THe curses std screen
|
|
- bannerwin: The top line banner window
|
|
- width|height: The total curses screen dimensions
|
|
- logheight: Available height for the logging part
|
|
- log_con_handler: The CursesLogHandler()
|
|
- threadframes:
|
|
- accframes[account]: 'Accountframe'"""
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super(Blinkenlights, self).__init__(*args, **kwargs)
|
|
CursesUtil.__init__(self)
|
|
|
|
################################################## UTILS
|
|
def setup_consolehandler(self):
|
|
"""Backend specific console handler.
|
|
|
|
Sets up things and adds them to self.logger.
|
|
:returns: The logging.Handler() for console output"""
|
|
|
|
# create console handler with a higher log level
|
|
ch = CursesLogHandler()
|
|
#ch.setLevel(logging.DEBUG)
|
|
# create formatter and add it to the handlers
|
|
self.formatter = logging.Formatter("%(message)s")
|
|
ch.setFormatter(self.formatter)
|
|
# add the handlers to the logger
|
|
self.logger.addHandler(ch)
|
|
# the handler is not usable yet. We still need all the
|
|
# intialization stuff currently done in init_banner. Move here?
|
|
return ch
|
|
|
|
def isusable(s):
|
|
"""Returns true if the backend is usable ie Curses works."""
|
|
|
|
# Not a terminal? Can't use curses.
|
|
if not sys.stdout.isatty() and sys.stdin.isatty():
|
|
return False
|
|
# No TERM specified? Can't use curses.
|
|
if not os.environ.get('TERM', None):
|
|
return False
|
|
# Test if ncurses actually starts up fine. Only do so for
|
|
# python>=2.6.6 as calling initscr() twice messing things up.
|
|
# see http://bugs.python.org/issue7567 in python 2.6 to 2.6.5
|
|
if sys.version_info[0:3] < (2,6) or sys.version_info[0:3] >= (2,6,6):
|
|
try:
|
|
curses.initscr()
|
|
curses.endwin()
|
|
except:
|
|
return False
|
|
return True
|
|
|
|
def init_banner(self):
|
|
self.availablethreadframes = {}
|
|
self.threadframes = {}
|
|
self.accframes = {}
|
|
self.aflock = Lock()
|
|
|
|
self.stdscr = curses.initscr()
|
|
# turn off automatic echoing of keys to the screen
|
|
curses.noecho()
|
|
# react to keys instantly, without Enter key
|
|
curses.cbreak()
|
|
# return special key values, eg curses.KEY_LEFT
|
|
self.stdscr.keypad(1)
|
|
# wait 1s for input, so we don't block the InputHandler infinitely
|
|
self.stdscr.timeout(1000)
|
|
curses.start_color()
|
|
# turn off cursor and save original state
|
|
self.oldcursor = None
|
|
try:
|
|
self.oldcursor = curses.curs_set(0)
|
|
except:
|
|
pass
|
|
|
|
self.stdscr.clear()
|
|
self.stdscr.refresh()
|
|
self.init_colorpairs()
|
|
# set log handlers ui to ourself
|
|
self._log_con_handler.ui = self
|
|
self.setupwindows()
|
|
# Settup keyboard handler
|
|
self.inputhandler = InputHandler(self)
|
|
self.inputhandler.set_char_hdlr(self.on_keypressed)
|
|
|
|
self.gettf().setcolor('red')
|
|
self.info(offlineimap.banner)
|
|
|
|
def acct(self, *args):
|
|
"""Output that we start syncing an account (and start counting)."""
|
|
|
|
self.gettf().setcolor('purple')
|
|
super(Blinkenlights, self).acct(*args)
|
|
|
|
def connecting(self, *args):
|
|
self.gettf().setcolor('white')
|
|
super(Blinkenlights, self).connecting(*args)
|
|
|
|
def syncfolders(self, *args):
|
|
self.gettf().setcolor('blue')
|
|
super(Blinkenlights, self).syncfolders(*args)
|
|
|
|
def syncingfolder(self, *args):
|
|
self.gettf().setcolor('cyan')
|
|
super(Blinkenlights, self).syncingfolder(*args)
|
|
|
|
def skippingfolder(self, *args):
|
|
self.gettf().setcolor('cyan')
|
|
super(Blinkenlights, self).skippingfolder(*args)
|
|
|
|
def loadmessagelist(self, *args):
|
|
self.gettf().setcolor('green')
|
|
super(Blinkenlights, self).loadmessagelist(*args)
|
|
|
|
def syncingmessages(self, *args):
|
|
self.gettf().setcolor('blue')
|
|
super(Blinkenlights, self).syncingmessages(*args)
|
|
|
|
def ignorecopyingmessage(self, *args):
|
|
self.gettf().setcolor('red')
|
|
super(Blinkenlights, self).ignorecopyingmessage(*args)
|
|
|
|
def copyingmessage(self, *args):
|
|
self.gettf().setcolor('orange')
|
|
super(Blinkenlights, self).copyingmessage(*args)
|
|
|
|
def deletingmessages(self, *args):
|
|
self.gettf().setcolor('red')
|
|
super(Blinkenlights, self).deletingmessages(*args)
|
|
|
|
def addingflags(self, *args):
|
|
self.gettf().setcolor('blue')
|
|
super(Blinkenlights, self).addingflags(*args)
|
|
|
|
def deletingflags(self, *args):
|
|
self.gettf().setcolor('blue')
|
|
super(Blinkenlights, self).deletingflags(*args)
|
|
|
|
def callhook(self, *args):
|
|
self.gettf().setcolor('white')
|
|
super(Blinkenlights, self).callhook(*args)
|
|
|
|
############ Generic logging functions #############################
|
|
def warn(self, msg, minor=0):
|
|
self.gettf().setcolor('red', curses.A_BOLD)
|
|
super(Blinkenlights, self).warn(msg)
|
|
|
|
def threadExited(self, thread):
|
|
acc = self.getthreadaccount(thread)
|
|
with self.tframe_lock:
|
|
if thread in self.threadframes[acc]:
|
|
tf = self.threadframes[acc][thread]
|
|
tf.setcolor('black')
|
|
self.availablethreadframes[acc].append(tf)
|
|
del self.threadframes[acc][thread]
|
|
super(Blinkenlights, self).threadExited(thread)
|
|
|
|
def gettf(self):
|
|
"""Return the ThreadFrame() of the current thread."""
|
|
|
|
cur_thread = currentThread()
|
|
acc = self.getthreadaccount() #Account() or None
|
|
|
|
with self.tframe_lock:
|
|
# Ideally we already have self.threadframes[accountname][thread]
|
|
try:
|
|
if cur_thread in self.threadframes[acc]:
|
|
return self.threadframes[acc][cur_thread]
|
|
except KeyError:
|
|
# Ensure threadframes already has an account dict
|
|
self.threadframes[acc] = {}
|
|
self.availablethreadframes[acc] = deque()
|
|
|
|
# If available, return a ThreadFrame()
|
|
if len(self.availablethreadframes[acc]):
|
|
tf = self.availablethreadframes[acc].popleft()
|
|
tf.std_color()
|
|
else:
|
|
tf = self.getaccountframe(acc).get_new_tframe()
|
|
self.threadframes[acc][cur_thread] = tf
|
|
return tf
|
|
|
|
def on_keypressed(self, key):
|
|
# received special KEY_RESIZE, resize terminal
|
|
if key == curses.KEY_RESIZE:
|
|
self.resizeterm()
|
|
return
|
|
|
|
if key < 1 or key > 255:
|
|
return
|
|
if chr(key) == 'q':
|
|
# Request to quit completely.
|
|
self.warn("Requested shutdown via 'q'")
|
|
offlineimap.accounts.Account.set_abort_event(self.config, 3)
|
|
try:
|
|
index = int(chr(key))
|
|
except ValueError:
|
|
return # Key not a valid number: exit.
|
|
if index >= len(self.hotkeys):
|
|
# Not in our list of valid hotkeys.
|
|
return
|
|
# Trying to end sleep somewhere.
|
|
self.getaccountframe(self.hotkeys[index]).syncnow()
|
|
|
|
def sleep(self, sleepsecs, account):
|
|
self.gettf().setcolor('red')
|
|
self.info("Next sync in %d:%02d"% (sleepsecs / 60, sleepsecs % 60))
|
|
return super(Blinkenlights, self).sleep(sleepsecs, account)
|
|
|
|
def sleeping(self, sleepsecs, remainingsecs):
|
|
if not sleepsecs:
|
|
# reset color to default if we are done sleeping.
|
|
self.gettf().setcolor('white')
|
|
accframe = self.getaccountframe(self.getthreadaccount())
|
|
return accframe.sleeping(sleepsecs, remainingsecs)
|
|
|
|
def resizeterm(self):
|
|
"""Resize the current windows."""
|
|
|
|
self.exec_locked(self.setupwindows, True)
|
|
|
|
def mainException(self):
|
|
UIBase.mainException(self)
|
|
|
|
def getpass(self, username, config, errmsg=None):
|
|
# disable the hotkeys inputhandler
|
|
self.inputhandler.input_acquire()
|
|
|
|
# See comment on _msg for info on why both locks are obtained.
|
|
self.lock()
|
|
try:
|
|
#s.gettf().setcolor('white')
|
|
self.warn(" *** Input Required")
|
|
self.warn(" *** Please enter password for user '%s': " % \
|
|
username)
|
|
self.logwin.refresh()
|
|
password = self.logwin.getstr()
|
|
finally:
|
|
self.unlock()
|
|
self.inputhandler.input_release()
|
|
return password
|
|
|
|
def setupwindows(self, resize=False):
|
|
"""Setup and draw bannerwin and logwin.
|
|
|
|
If `resize`, don't create new windows, just adapt size. This
|
|
function should be invoked with CursesUtils.locked()."""
|
|
|
|
self.height, self.width = self.stdscr.getmaxyx()
|
|
self.logheight = self.height - len(self.accframes) - 1
|
|
if resize:
|
|
if curses.is_term_resized(self.height, self.width):
|
|
curses.resizeterm(self.height, self.width)
|
|
self.bannerwin.resize(1, self.width)
|
|
self.logwin.resize(self.logheight, self.width)
|
|
self.stdscr.clear()
|
|
self.stdscr.noutrefresh()
|
|
else:
|
|
self.bannerwin = curses.newwin(1, self.width, 0, 0)
|
|
self.logwin = curses.newwin(self.logheight, self.width, 1, 0)
|
|
|
|
self.draw_bannerwin()
|
|
self.logwin.idlok(True) # needed for scrollok below
|
|
self.logwin.scrollok(True) # scroll window when too many lines added
|
|
self.draw_logwin()
|
|
self.accounts = reversed(sorted(self.accframes.keys()))
|
|
pos = self.height - 1
|
|
index = 0
|
|
self.hotkeys = []
|
|
for account in self.accounts:
|
|
acc_win = curses.newwin(1, self.width, pos, 0)
|
|
self.accframes[account].setwindow(acc_win, index)
|
|
self.hotkeys.append(account)
|
|
index += 1
|
|
pos -= 1
|
|
curses.doupdate()
|
|
|
|
def draw_bannerwin(self):
|
|
"""Draw the top-line banner line."""
|
|
|
|
if curses.has_colors():
|
|
color = curses.A_BOLD | self.curses_colorpair('banner')
|
|
else:
|
|
color = curses.A_REVERSE
|
|
self.bannerwin.clear() # Delete old content (eg before resizes)
|
|
self.bannerwin.bkgd(' ', color) # Fill background with that color
|
|
string = "%s %s" % (offlineimap.__productname__,
|
|
offlineimap.__version__)
|
|
spaces = " " * max(1, (self.width - len(offlineimap.__copyright__)
|
|
- len(string) - 1))
|
|
string = "%s%s%s" % (string, spaces, offlineimap.__copyright__)
|
|
self.bannerwin.addnstr(0, 0, string, self.width - 1, color)
|
|
self.bannerwin.noutrefresh()
|
|
|
|
def draw_logwin(self):
|
|
"""(Re)draw the current logwindow."""
|
|
|
|
if curses.has_colors():
|
|
color = curses.color_pair(0) #default colors
|
|
else:
|
|
color = curses.A_NORMAL
|
|
self.logwin.move(0, 0)
|
|
self.logwin.clear()
|
|
self.logwin.bkgd(' ', color)
|
|
self.logwin.noutrefresh()
|
|
|
|
def getaccountframe(self, acc_name):
|
|
"""Return an AccountFrame() corresponding to acc_name.
|
|
|
|
Note that the *control thread uses acc_name `None`."""
|
|
|
|
with self.aflock:
|
|
# 1) Return existing or 2) create a new CursesAccountFrame.
|
|
if acc_name in self.accframes: return self.accframes[acc_name]
|
|
self.accframes[acc_name] = CursesAccountFrame(self, acc_name)
|
|
# update the window layout
|
|
self.setupwindows(resize= True)
|
|
return self.accframes[acc_name]
|
|
|
|
def terminate(self, *args, **kwargs):
|
|
curses.nocbreak();
|
|
self.stdscr.keypad(0);
|
|
curses.echo()
|
|
curses.endwin()
|
|
# need to remove the Curses console handler now and replace with
|
|
# basic one, so exceptions and stuff are properly displayed
|
|
self.logger.removeHandler(self._log_con_handler)
|
|
UIBase.setup_consolehandler(self)
|
|
# reset the warning method, we do not have curses anymore
|
|
self.warn = super(Blinkenlights, self).warn
|
|
# finally call parent terminate which prints out exceptions etc
|
|
super(Blinkenlights, self).terminate(*args, **kwargs)
|
|
|
|
def threadException(self, thread):
|
|
#self._log_con_handler.stop()
|
|
UIBase.threadException(self, thread)
|
|
|