initial checkin of new console ui

pretty alpha code, but it works and gives an idea of the direction the ui might go

deluge/ui/console/colors.py

@@ -61,7 +61,12 @@ schemes = {
     "info": ("white", "black", "bold"),
     "error": ("red", "black", "bold"),
     "success": ("green", "black", "bold"),
-    "event": ("magenta", "black", "bold")
+    "event": ("magenta", "black", "bold"),
+    "selected": ("black", "white", "bold"),
+    "marked": ("white","blue","bold"),
+    "selectedmarked": ("blue","white","bold"),
+    "header": ("green","black","bold"),
+    "filterstatus": ("green", "blue", "bold")
 }
 
 # Colors for various torrent states

deluge/ui/console/main.py

@@ -213,7 +213,8 @@ class ConsoleUI(component.Component):
         # We want to do an interactive session, so start up the curses screen and
         # pass it the function that handles commands
         colors.init_colors()
-        self.screen = screen.Screen(stdscr, self.do_command, self.tab_completer, self.encoding)
+        from modes.alltorrents import AllTorrents
+        self.screen = AllTorrents(stdscr, self.coreconfig, self.encoding)
         self.statusbars = StatusBars()
         self.eventlog = EventLog()
 
@@ -271,7 +272,8 @@ class ConsoleUI(component.Component):
 
         """
         if self.interactive:
-            self.screen.add_line(line, not self.batch_write)
+            #self.screen.add_line(line, not self.batch_write)
+            pass
         else:
             print(colors.strip_colors(line))
 

deluge/ui/console/modes/add_util.py

@@ -0,0 +1,71 @@
+#
+# add_util.py
+#
+# Copyright (C) 2011 Nick Lanham <nick@afternight.org>
+#
+# Modified function from commands/add.py:
+# Copyright (C) 2008-2009 Ido Abramovich <ido.deluge@gmail.com>
+# Copyright (C) 2009 Andrew Resch <andrewresch@gmail.com>
+#
+# Deluge is free software.
+#
+# You may redistribute it and/or modify it under the terms of the
+# GNU General Public License, as published by the Free Software
+# Foundation; either version 3 of the License, or (at your option)
+# any later version.
+#
+# deluge 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 deluge.    If not, write to:
+# 	The Free Software Foundation, Inc.,
+# 	51 Franklin Street, Fifth Floor
+# 	Boston, MA  02110-1301, USA.
+#
+#    In addition, as a special exception, the copyright holders give
+#    permission to link the code of portions of this program with the OpenSSL
+#    library.
+#    You must obey the GNU General Public License in all respects for all of
+#    the code used other than OpenSSL. If you modify file(s) with this
+#    exception, you may extend this exception to your version of the file(s),
+#    but you are not obligated to do so. If you do not wish to do so, delete
+#    this exception statement from your version. If you delete this exception
+#    statement from all source files in the program, then also delete it here.
+#
+#
+from twisted.internet import defer
+
+from deluge.ui.client import client
+import deluge.component as component
+
+from optparse import make_option
+import os
+import base64
+
+def add_torrent(t_file, options, success_cb, fail_cb):
+    t_options = {}
+    if options["path"]:
+        t_options["download_location"] = os.path.expanduser(options["path"])
+
+    # Keep a list of deferreds to make a DeferredList
+    if not os.path.exists(t_file):
+        fail_cb("{!error!}%s doesn't exist!" % t_file)
+        return
+    if not os.path.isfile(t_file):
+        fail_cb("{!error!}%s is a directory!" % t_file)
+        return
+        
+
+    filename = os.path.split(t_file)[-1]
+    filedump = base64.encodestring(open(t_file).read())
+
+    def on_success(result):
+        success_cb("{!success!}Torrent added!")
+    def on_fail(result):
+        fail_cb("{!error!}Torrent was not added! %s" % result)
+
+    client.core.add_torrent_file(filename, filedump, t_options).addCallback(on_success).addErrback(on_fail)
+        

deluge/ui/console/modes/alltorrents.py

@@ -0,0 +1,602 @@
+# -*- coding: utf-8 -*-
+#
+# alltorrens.py
+#
+# Copyright (C) 2011 Nick Lanham <nick@afternight.org>
+#
+# Deluge is free software.
+#
+# You may redistribute it and/or modify it under the terms of the
+# GNU General Public License, as published by the Free Software
+# Foundation; either version 3 of the License, or (at your option)
+# any later version.
+#
+# deluge 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 deluge.    If not, write to:
+# 	The Free Software Foundation, Inc.,
+# 	51 Franklin Street, Fifth Floor
+# 	Boston, MA  02110-1301, USA.
+#
+#    In addition, as a special exception, the copyright holders give
+#    permission to link the code of portions of this program with the OpenSSL
+#    library.
+#    You must obey the GNU General Public License in all respects for all of
+#    the code used other than OpenSSL. If you modify file(s) with this
+#    exception, you may extend this exception to your version of the file(s),
+#    but you are not obligated to do so. If you do not wish to do so, delete
+#    this exception statement from your version. If you delete this exception
+#    statement from all source files in the program, then also delete it here.
+#
+#
+
+import deluge.component as component
+from basemode import BaseMode
+import deluge.common
+from deluge.ui.client import client
+
+from collections import deque
+
+from deluge.ui.sessionproxy import SessionProxy
+
+from popup import Popup,SelectablePopup,MessagePopup
+from add_util import add_torrent
+from input_popup import InputPopup
+
+
+try:
+    import curses
+except ImportError:
+    pass
+
+import logging
+log = logging.getLogger(__name__)
+
+
+# Big help string that gets displayed when the user hits 'h'
+HELP_STR = \
+"""This screen shows an overview of the current torrents Deluge is managing.
+The currently selected torrent is indicated by having a white background.
+You can change the selected torrent using the up/down arrows or the 
+PgUp/Pg keys.
+
+Operations can be performed on multiple torrents by marking them and
+then hitting Enter.  See below for the keys used to mark torrents.
+
+You can scroll a popup window that doesn't fit its content (like
+this one) using the up/down arrows.
+
+All popup windows can be closed/canceled by hitting the Esc key 
+(you might need to wait a second for an Esc to register)
+
+The actions you can perform and the keys to perform them are as follows:
+
+'a' - Add a torrent
+
+'h' - Show this help
+
+'f' - Show only torrents in a certain state
+      (Will open a popup where you can select the state you want to see)
+
+'i' - Show more detailed information about the current selected torrent
+
+'Q' - quit
+
+'m' - Mark a torrent
+'M' - Mark all torrents between currently selected torrent 
+      and last marked torrent
+'c' - Un-mark all torrents
+
+Enter - Show torrent actions popup.  Here you can do things like
+        pause/resume, remove, recheck and so one.  These actions
+        apply to all currently marked torrents.  The currently
+        selected torrent is automatically marked when you press enter.
+
+'q'/Esc - Close a popup
+"""
+HELP_LINES = HELP_STR.split('\n')
+
+class ACTION:
+    PAUSE=0
+    RESUME=1
+    REANNOUNCE=2
+    EDIT_TRACKERS=3
+    RECHECK=4
+    REMOVE=5
+
+class FILTER:
+    ALL=0
+    ACTIVE=1
+    DOWNLOADING=2
+    SEEDING=3
+    PAUSED=4
+    CHECKING=5
+    ERROR=6
+    QUEUED=7
+
+class StateUpdater(component.Component):
+    def __init__(self, cb, sf,tcb):
+        component.Component.__init__(self, "AllTorrentsStateUpdater", 1, depend=["SessionProxy"])
+        self._status_cb = cb
+        self._status_fields = sf
+        self.status_dict = {}
+        self._torrent_cb = tcb
+        self._torrent_to_update = None
+
+    def set_torrent_to_update(self, tid, keys):
+        self._torrent_to_update = tid
+        self._torrent_keys = keys
+
+    def start(self):
+        component.get("SessionProxy").get_torrents_status(self.status_dict, self._status_fields).addCallback(self._on_torrents_status,False)
+
+    def update(self):
+        component.get("SessionProxy").get_torrents_status(self.status_dict, self._status_fields).addCallback(self._on_torrents_status,True)
+        if self._torrent_to_update:
+            component.get("SessionProxy").get_torrent_status(self._torrent_to_update, self._torrent_keys).addCallback(self._torrent_cb)
+
+    def _on_torrents_status(self, state, refresh):
+        self._status_cb(state,refresh)
+
+
+class AllTorrents(BaseMode, component.Component):
+    def __init__(self, stdscr, coreconfig, encoding=None):
+        self.curstate = None
+        self.cursel = 1
+        self.curoff = 1
+        self.column_string = ""
+        self.popup = None
+        self.messages = deque()
+        self.marked = []
+        self.last_mark = -1
+        self._sorted_ids = None
+        self._go_top = False
+
+        self._curr_filter = None
+
+        self.coreconfig = coreconfig
+
+        BaseMode.__init__(self, stdscr, encoding)
+        curses.curs_set(0)
+        self.stdscr.notimeout(0)
+        self.sessionproxy = SessionProxy()
+
+        self._status_fields = ["queue","name","total_wanted","state","progress","num_seeds","total_seeds",
+                               "num_peers","total_peers","download_payload_rate", "upload_payload_rate"]
+
+        self.updater = StateUpdater(self.set_state,self._status_fields,self._on_torrent_status)
+
+        self.column_names = ["#", "Name","Size","State","Progress","Seeders","Peers","Down Speed","Up Speed"]
+        self._update_columns()
+
+
+        self._info_fields = [
+            ("Name",None,("name",)),
+            ("State", None, ("state",)),
+            ("Down Speed", self._format_speed, ("download_payload_rate",)),
+            ("Up Speed", self._format_speed, ("upload_payload_rate",)),
+            ("Progress", self._format_progress, ("progress",)),
+            ("ETA", deluge.common.ftime, ("eta",)),
+            ("Path", None, ("save_path",)),
+            ("Downloaded",deluge.common.fsize,("all_time_download",)),
+            ("Uploaded", deluge.common.fsize,("total_uploaded",)),
+            ("Share Ratio", lambda x:x < 0 and "∞" or "%.3f"%x, ("ratio",)),
+            ("Seeders",self._format_seeds_peers,("num_seeds","total_seeds")),
+            ("Peers",self._format_seeds_peers,("num_peers","total_peers")),
+            ("Active Time",deluge.common.ftime,("active_time",)),
+            ("Seeding Time",deluge.common.ftime,("seeding_time",)),
+            ("Date Added",deluge.common.fdate,("time_added",)),
+            ("Availability", lambda x:x < 0 and "∞" or "%.3f"%x, ("distributed_copies",)),
+            ("Pieces", self._format_pieces, ("num_pieces","piece_length")),
+            ]
+
+        self._status_keys = ["name","state","download_payload_rate","upload_payload_rate",
+                             "progress","eta","all_time_download","total_uploaded", "ratio",
+                             "num_seeds","total_seeds","num_peers","total_peers", "active_time",
+                             "seeding_time","time_added","distributed_copies", "num_pieces", 
+                             "piece_length","save_path"]
+
+    def _update_columns(self):
+        self.column_widths = [5,-1,15,13,10,10,10,15,15]
+        req = sum(filter(lambda x:x >= 0,self.column_widths))
+        if (req > self.cols): # can't satisfy requests, just spread out evenly
+            cw = int(self.cols/len(self.column_names))
+            for i in range(0,len(self.column_widths)):
+                self.column_widths[i] = cw
+        else:
+            rem = self.cols - req
+            var_cols = len(filter(lambda x: x < 0,self.column_widths))
+            vw = int(rem/var_cols)
+            for i in range(0, len(self.column_widths)):
+                if (self.column_widths[i] < 0):
+                    self.column_widths[i] = vw
+
+        self.column_string = "{!header!}%s"%("".join(["%s%s"%(self.column_names[i]," "*(self.column_widths[i]-len(self.column_names[i]))) for i in range(0,len(self.column_names))]))
+
+    def _trim_string(self, string, w):
+        return "%s... "%(string[0:w-4])
+
+    def _format_column(self, col, lim):
+        size = len(col)
+        if (size >= lim - 1):
+            return self._trim_string(col,lim)
+        else:
+            return "%s%s"%(col," "*(lim-size))
+
+    def _format_row(self, row):
+        return "".join([self._format_column(row[i],self.column_widths[i]) for i in range(0,len(row))])
+
+    def set_state(self, state, refresh):
+        self.curstate = state
+        self.numtorrents = len(state)
+        if refresh:
+            self.refresh()
+
+    def _scroll_up(self, by):
+        self.cursel = max(self.cursel - by,1)
+        if ((self.cursel - 1) < self.curoff):
+            self.curoff = max(self.cursel - 1,1)
+
+    def _scroll_down(self, by):
+        self.cursel = min(self.cursel + by,self.numtorrents)
+        if ((self.curoff + self.rows - 5) < self.cursel):
+            self.curoff = self.cursel - self.rows + 5
+
+    def _current_torrent_id(self):
+        if self._sorted_ids:
+            return self._sorted_ids[self.cursel-1]
+        else:
+            return None
+
+    def _selected_torrent_ids(self):
+        ret = []
+        for i in self.marked:
+            ret.append(self._sorted_ids[i-1])
+        return ret
+
+    def _on_torrent_status(self, state):
+        if (self.popup):
+            self.popup.clear()
+            name = state["name"]
+            off = int((self.cols/4)-(len(name)/2))
+            self.popup.set_title(name)
+            for i,f in enumerate(self._info_fields):
+                if f[1] != None:
+                    args = []
+                    try:
+                        for key in f[2]:
+                            args.append(state[key])
+                    except:
+                        log.debug("Could not get info field: %s",e)
+                        continue
+                    info = f[1](*args)
+                else:
+                    info = state[f[2][0]]
+                
+                self.popup.add_line("{!info!}%s: {!input!}%s"%(f[0],info))
+            self.refresh()
+        else:
+            self.updater.set_torrent_to_update(None,None)
+            
+
+    def on_resize(self, *args):
+        BaseMode.on_resize_norefresh(self, *args)
+        self._update_columns()
+        if self.popup:
+            self.popup.handle_resize()
+        self.refresh()
+
+    def _queue_sort(self, v1, v2):
+        if v1 == v2:
+            return 0
+        if v2 < 0:
+            return -1
+        if v1 < 0:
+            return 1
+        if v1 > v2:
+            return 1
+        if v2 > v1:
+            return -1
+
+    def _sort_torrents(self, state):
+        "sorts by queue #"
+        return sorted(state,cmp=self._queue_sort,key=lambda s:state.get(s)["queue"])
+
+    def _format_speed(self, speed):
+        if (speed > 0):
+            return deluge.common.fspeed(speed)
+        else:
+            return "-"
+
+    def _format_queue(self, qnum):
+        if (qnum >= 0):
+            return "%d"%(qnum+1)
+        else:
+            return ""
+
+    def _format_seeds_peers(self, num, total):
+        return "%d (%d)"%(num,total)
+
+    def _format_pieces(self, num, size):
+        return "%d (%s)"%(num,deluge.common.fsize(size))
+
+    def _format_progress(self, perc):
+        return "%.2f%%"%perc
+
+    def _action_error(self, error):
+        rerr = error.value
+        self.report_message("An Error Occurred","%s got error %s: %s"%(rerr.method,rerr.exception_type,rerr.exception_msg))
+        self.refresh()
+
+    def _torrent_action(self, idx, data):
+        ids = self._selected_torrent_ids()
+        if ids:
+            if data==ACTION.PAUSE:
+                log.debug("Pausing torrents: %s",ids)
+                client.core.pause_torrent(ids).addErrback(self._action_error)
+            elif data==ACTION.RESUME:
+                log.debug("Resuming torrents: %s", ids)
+                client.core.resume_torrent(ids).addErrback(self._action_error)
+            elif data==ACTION.REMOVE:
+                log.error("Can't remove just yet")
+            elif data==ACTION.RECHECK:
+                log.debug("Rechecking torrents: %s", ids)
+                client.core.force_recheck(ids).addErrback(self._action_error)
+            elif data==ACTION.REANNOUNCE:
+                log.debug("Reannouncing torrents: %s",ids)
+                client.core.force_reannounce(ids).addErrback(self._action_error)
+        if len(ids) == 1:
+            self.marked = []
+            self.last_mark = -1
+
+    def _show_torrent_actions_popup(self):
+        #cid = self._current_torrent_id()
+        if len(self.marked):
+            self.popup = SelectablePopup(self,"Torrent Actions",self._torrent_action)
+            self.popup.add_line("Pause",data=ACTION.PAUSE)
+            self.popup.add_line("Resume",data=ACTION.RESUME)
+            self.popup.add_divider()
+            self.popup.add_line("Update Tracker",data=ACTION.REANNOUNCE)
+            self.popup.add_divider()
+            self.popup.add_line("Remove Torrent",data=ACTION.REMOVE)
+            self.popup.add_line("Force Recheck",data=ACTION.RECHECK)
+
+    def _torrent_filter(self, idx, data):
+        if data==FILTER.ALL:
+            self.updater.status_dict = {}
+            self._curr_filter = None
+        elif data==FILTER.ACTIVE:
+            self.updater.status_dict = {"state":"Active"}
+            self._curr_filter = "Active"
+        elif data==FILTER.DOWNLOADING:
+            self.updater.status_dict = {"state":"Downloading"}
+            self._curr_filter = "Downloading"
+        elif data==FILTER.SEEDING:
+            self.updater.status_dict = {"state":"Seeding"}
+            self._curr_filter = "Seeding"
+        elif data==FILTER.PAUSED:
+            self.updater.status_dict = {"state":"Paused"}
+            self._curr_filter = "Paused"
+        elif data==FILTER.CHECKING:
+            self.updater.status_dict = {"state":"Checking"}
+            self._curr_filter = "Checking"
+        elif data==FILTER.ERROR:
+            self.updater.status_dict = {"state":"Error"}
+            self._curr_filter = "Error"
+        elif data==FILTER.QUEUED:
+            self.updater.status_dict = {"state":"Queued"}
+            self._curr_filter = "Queued"
+        self._go_top = True
+
+    def _show_torrent_filter_popup(self):
+        self.popup = SelectablePopup(self,"Filter Torrents",self._torrent_filter)
+        self.popup.add_line("All",data=FILTER.ALL)
+        self.popup.add_line("Active",data=FILTER.ACTIVE)
+        self.popup.add_line("Downloading",data=FILTER.DOWNLOADING,foreground="green")
+        self.popup.add_line("Seeding",data=FILTER.SEEDING,foreground="blue")
+        self.popup.add_line("Paused",data=FILTER.PAUSED)
+        self.popup.add_line("Error",data=FILTER.ERROR,foreground="red")
+        self.popup.add_line("Checking",data=FILTER.CHECKING,foreground="cyan")
+        self.popup.add_line("Queued",data=FILTER.QUEUED,foreground="yellow")
+
+    def _do_add(self, result):
+        log.debug("Doing adding %s (dl to %s)",result["file"],result["path"])
+        def suc_cb(msg):
+            self.report_message("Torrent Added",msg)
+        def fail_cb(msg):
+            self.report_message("Failed To Add Torrent",msg)
+        add_torrent(result["file"],result,suc_cb,fail_cb)
+
+    def _show_torrent_add_popup(self):
+        dl = ""
+        try:
+            dl = self.coreconfig["download_location"]
+        except KeyError:
+            pass
+        self.popup = InputPopup(self,"Add Torrent (Esc to cancel)",close_cb=self._do_add)
+        self.popup.add_text_input("Enter path to torrent file:","file")
+        self.popup.add_text_input("Enter save path:","path",dl)
+
+    def report_message(self,title,message):
+        self.messages.append((title,message))
+
+    def refresh(self):
+        # Something has requested we scroll to the top of the list
+        if self._go_top:
+            self.cursel = 1
+            self.curoff = 1
+            self._go_top = False
+
+        # show a message popup if there's anything queued
+        if self.popup == None and self.messages:
+            title,msg = self.messages.popleft()
+            self.popup = MessagePopup(self,title,msg)
+
+        self.stdscr.clear()
+
+        # Update the status bars
+        if self._curr_filter == None:
+            self.add_string(0,self.topbar)
+        else:
+            self.add_string(0,"%s    {!filterstatus!}Current filter: %s"%(self.topbar,self._curr_filter))
+        self.add_string(1,self.column_string)
+        self.add_string(self.rows - 1, self.bottombar)
+
+        # add all the torrents
+        if self.curstate == {}:
+            msg = "No torrents match filter".center(self.cols)
+            self.add_string(3, "{!info!}%s"%msg)
+        elif self.curstate != None:
+            tidx = 1
+            currow = 2
+            self._sorted_ids = self._sort_torrents(self.curstate) 
+            for torrent_id in self._sorted_ids:
+                if (tidx < self.curoff):
+                    tidx += 1
+                    continue
+                ts = self.curstate[torrent_id]
+                s = self._format_row([self._format_queue(ts["queue"]),
+                                      ts["name"],
+                                      "%s"%deluge.common.fsize(ts["total_wanted"]),
+                                      ts["state"],
+                                      self._format_progress(ts["progress"]),
+                                      self._format_seeds_peers(ts["num_seeds"],ts["total_seeds"]),
+                                      self._format_seeds_peers(ts["num_peers"],ts["total_peers"]),
+                                      self._format_speed(ts["download_payload_rate"]),
+                                      self._format_speed(ts["upload_payload_rate"])
+                                      ])
+
+                # default style
+                fg = "white"
+                bg = "black"
+                attr = None
+
+                if tidx in self.marked:
+                    bg = "blue"
+                    attr = "bold"
+
+                if tidx == self.cursel:
+                    bg = "white"
+                    attr = "bold"
+                    if tidx in self.marked:
+                        fg = "blue"
+                    else:
+                        fg = "black"
+
+                if ts["state"] == "Downloading":
+                    fg = "green"
+                elif ts["state"] == "Seeding":
+                    fg = "blue"
+                elif ts["state"] == "Error":              
+                    fg = "red"
+                elif ts["state"] == "Queued":
+                    fg = "yellow"
+                elif ts["state"] == "Checking":
+                    fg = "cyan"
+                    
+                if attr:
+                    colorstr = "{!%s,%s,%s!}"%(fg,bg,attr)
+                else:
+                    colorstr = "{!%s,%s!}"%(fg,bg)
+                self.add_string(currow,"%s%s"%(colorstr,s))
+                tidx += 1
+                currow += 1 
+                if (currow > (self.rows - 2)):
+                    break
+        else:
+            self.add_string(1, "Waiting for torrents from core...")
+
+        self.stdscr.redrawwin()
+        self.stdscr.noutrefresh()
+
+        if self.popup:
+            self.popup.refresh()
+
+        curses.doupdate()
+
+
+    def _mark_unmark(self,idx):
+        if idx in self.marked:
+            self.marked.remove(idx)
+            self.last_mark = -1
+        else:
+            self.marked.append(idx)
+            self.last_mark = idx
+
+
+    def _doRead(self):
+        # Read the character
+        c = self.stdscr.getch()
+
+        if self.popup:
+            if self.popup.handle_read(c):
+                self.popup = None
+            self.refresh()
+            return
+
+        if c > 31 and c < 256:
+            if chr(c) == 'Q':
+                from twisted.internet import reactor
+                if client.connected():
+                    def on_disconnect(result):
+                        reactor.stop()
+                    client.disconnect().addCallback(on_disconnect)
+                else:
+                    reactor.stop()            
+                return
+
+        if self.curstate==None or self.popup:
+            return
+
+        #log.error("pressed key: %d\n",c)
+        #if c == 27: # handle escape
+        #    log.error("CANCEL")
+        
+        # Navigate the torrent list
+        if c == curses.KEY_UP:
+            self._scroll_up(1)
+        elif c == curses.KEY_PPAGE:
+            self._scroll_up(int(self.rows/2))
+        elif c == curses.KEY_DOWN:
+            self._scroll_down(1)
+        elif c == curses.KEY_NPAGE:
+            self._scroll_down(int(self.rows/2))
+
+        # Enter Key
+        elif c == curses.KEY_ENTER or c == 10:
+            self.marked.append(self.cursel)
+            self.last_mark = self.cursel
+            self._show_torrent_actions_popup()
+
+        else:
+            if c > 31 and c < 256:
+                if chr(c) == 'i':
+                    cid = self._current_torrent_id()
+                    if cid:
+                        self.popup = Popup(self,"Info",close_cb=lambda:self.updater.set_torrent_to_update(None,None))
+                        self.popup.add_line("Getting torrent info...")
+                        self.updater.set_torrent_to_update(cid,self._status_keys)
+                elif chr(c) == 'm':
+                    self._mark_unmark(self.cursel)
+                elif chr(c) == 'M':
+                    if self.last_mark >= 0:
+                        self.marked.extend(range(self.last_mark,self.cursel+1))
+                    else:
+                        self._mark_unmark(self.cursel)
+                elif chr(c) == 'c':
+                    self.marked = []
+                    self.last_mark = -1
+                elif chr(c) == 'a':
+                    self._show_torrent_add_popup()
+                elif chr(c) == 'f':
+                    self._show_torrent_filter_popup()
+                elif chr(c) == 'h':
+                    self.popup = Popup(self,"Help")
+                    for l in HELP_LINES:
+                        self.popup.add_line(l)
+
+        self.refresh()

deluge/ui/console/modes/basemode.py

@@ -0,0 +1,224 @@
+#
+# basemode.py
+#
+# Copyright (C) 2011 Nick Lanham <nick@afternight.org>
+# 
+# Most code in this file taken from screen.py: 
+#  Copyright (C) 2009 Andrew Resch <andrewresch@gmail.com>
+#
+# Deluge is free software.
+#
+# You may redistribute it and/or modify it under the terms of the
+# GNU General Public License, as published by the Free Software
+# Foundation; either version 3 of the License, or (at your option)
+# any later version.
+#
+# deluge 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 deluge.    If not, write to:
+# 	The Free Software Foundation, Inc.,
+# 	51 Franklin Street, Fifth Floor
+# 	Boston, MA  02110-1301, USA.
+#
+#    In addition, as a special exception, the copyright holders give
+#    permission to link the code of portions of this program with the OpenSSL
+#    library.
+#    You must obey the GNU General Public License in all respects for all of
+#    the code used other than OpenSSL. If you modify file(s) with this
+#    exception, you may extend this exception to your version of the file(s),
+#    but you are not obligated to do so. If you do not wish to do so, delete
+#    this exception statement from your version. If you delete this exception
+#    statement from all source files in the program, then also delete it here.
+#
+#
+
+import sys
+import logging
+try:
+    import curses
+except ImportError:
+    pass
+
+import deluge.ui.console.colors as colors
+try:
+    import signal
+    from fcntl import ioctl
+    import termios
+    import struct
+except:
+    pass
+
+from twisted.internet import reactor
+
+log = logging.getLogger(__name__)
+
+class CursesStdIO(object):
+    """fake fd to be registered as a reader with the twisted reactor.
+       Curses classes needing input should extend this"""
+
+    def fileno(self):
+        """ We want to select on FD 0 """
+        return 0
+
+    def doRead(self):
+        """called when input is ready"""
+        pass
+    def logPrefix(self): return 'CursesClient'
+
+
+class BaseMode(CursesStdIO):
+    def __init__(self, stdscr, encoding=None):
+        """
+        A mode that provides a curses screen designed to run as a reader in a twisted reactor.
+        This mode doesn't do much, just shows status bars and "Base Mode" on the screen
+
+        Modes should subclass this and provide overrides for:
+
+        _doRead(self) - Handle user input
+        refresh(self) - draw the mode to the screen
+        add_string(self, row, string) - add a string of text to be displayed.  
+                                        see method for detailed info
+
+        The init method of a subclass *must* call BaseMode.__init__
+
+        Useful fields after calling BaseMode.__init__:
+        self.stdscr - the curses screen
+        self.rows - # of rows on the curses screen
+        self.cols - # of cols on the curses screen
+        self.topbar - top statusbar
+        self.bottombar - bottom statusbar
+        """
+        log.debug("BaseMode init!")
+        self.stdscr = stdscr
+        # Make the input calls non-blocking
+        self.stdscr.nodelay(1)
+
+        # Strings for the 2 status bars
+        self.topbar = ""
+        self.bottombar = ""
+
+        # Keep track of the screen size
+        self.rows, self.cols = self.stdscr.getmaxyx()
+        try:
+            signal.signal(signal.SIGWINCH, self.on_resize)
+        except Exception, e:
+            log.debug("Unable to catch SIGWINCH signal!")
+
+        if not encoding:
+            self.encoding = sys.getdefaultencoding()
+        else:
+            self.encoding = encoding
+
+        colors.init_colors()
+
+        # Do a refresh right away to draw the screen
+        self.refresh()
+
+    def on_resize_norefresh(self, *args):
+        log.debug("on_resize_from_signal")
+        # Get the new rows and cols value
+        self.rows, self.cols = struct.unpack("hhhh", ioctl(0, termios.TIOCGWINSZ ,"\000"*8))[0:2]
+        curses.resizeterm(self.rows, self.cols)
+
+    def on_resize(self, *args):
+        self.on_resize_norefresh(args)
+        self.refresh()
+
+    def connectionLost(self, reason):
+        self.close()
+
+    def add_string(self, row, string, scr=None, col = 0, pad=True, trim=True):
+        """
+        Adds a string to the desired `:param:row`.
+
+        :param row: int, the row number to write the string
+        :param string: string, the string of text to add
+        :param scr: curses.window, optional window to add string to instead of self.stdscr
+        :param col: int, optional starting column offset
+        :param pad: bool, optional bool if the string should be padded out to the width of the screen
+        :param trim: bool, optional bool if the string should be trimmed if it is too wide for the screen
+
+        The text can be formatted with color using the following format:
+
+        "{!fg, bg, attributes, ...!}"
+
+        See: http://docs.python.org/library/curses.html#constants for attributes.
+
+        Alternatively, it can use some built-in scheme for coloring.
+        See colors.py for built-in schemes.
+
+        "{!scheme!}"
+
+        Examples:
+
+        "{!blue, black, bold!}My Text is {!white, black!}cool"
+        "{!info!}I am some info text!"
+        "{!error!}Uh oh!"
+
+
+        """
+        if scr:
+            screen = scr
+        else:
+            screen = self.stdscr
+        try:
+            parsed = colors.parse_color_string(string, self.encoding)
+        except colors.BadColorString, e:
+            log.error("Cannot add bad color string %s: %s", string, e)
+            return
+
+        for index, (color, s) in enumerate(parsed):
+            if index + 1 == len(parsed) and pad:
+                # This is the last string so lets append some " " to it
+                s += " " * (self.cols - (col + len(s)) - 1)
+            if trim:
+                y,x = screen.getmaxyx()
+                if (col+len(s)) > x:
+                    s = "%s..."%s[0:x-4-col]
+            screen.addstr(row, col, s, color)
+            col += len(s)
+
+    def refresh(self):
+        """
+        Refreshes the screen.
+        Updates the lines based on the`:attr:lines` based on the `:attr:display_lines_offset`
+        attribute and the status bars.
+        """
+        self.stdscr.clear()
+
+        # Update the status bars
+        self.add_string(0, self.topbar)
+        self.add_string(self.rows - 1, self.bottombar)
+        self.add_string(1,"{!info!}Base Mode (or subclass hasn't overridden refresh)")
+
+        self.stdscr.redrawwin()
+        self.stdscr.refresh()
+
+    def doRead(self):
+        """
+        Called when there is data to be read, ie, input from the keyboard.
+        """
+        # We wrap this function to catch exceptions and shutdown the mainloop
+        try:
+            self._doRead()
+        except Exception, e:
+            log.exception(e)
+            reactor.stop()
+
+    def _doRead(self):
+        # Read the character
+        c = self.stdscr.getch()
+        self.stdscr.refresh()
+
+    def close(self):
+        """
+        Clean up the curses stuff on exit.
+        """
+        curses.nocbreak()
+        self.stdscr.keypad(0)
+        curses.echo()
+        curses.endwin()

deluge/ui/console/modes/input_popup.py

@@ -0,0 +1,244 @@
+#
+# input_popup.py
+#
+# Copyright (C) 2011 Nick Lanham <nick@afternight.org>
+#
+# Complete function from commands/add.py:
+# Copyright (C) 2008-2009 Ido Abramovich <ido.deluge@gmail.com>
+# Copyright (C) 2009 Andrew Resch <andrewresch@gmail.com>
+#
+# Deluge is free software.
+#
+# You may redistribute it and/or modify it under the terms of the
+# GNU General Public License, as published by the Free Software
+# Foundation; either version 3 of the License, or (at your option)
+# any later version.
+#
+# deluge 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 deluge.    If not, write to:
+# 	The Free Software Foundation, Inc.,
+# 	51 Franklin Street, Fifth Floor
+# 	Boston, MA  02110-1301, USA.
+#
+#    In addition, as a special exception, the copyright holders give
+#    permission to link the code of portions of this program with the OpenSSL
+#    library.
+#    You must obey the GNU General Public License in all respects for all of
+#    the code used other than OpenSSL. If you modify file(s) with this
+#    exception, you may extend this exception to your version of the file(s),
+#    but you are not obligated to do so. If you do not wish to do so, delete
+#    this exception statement from your version. If you delete this exception
+#    statement from all source files in the program, then also delete it here.
+#
+#
+
+try:
+    import curses
+except ImportError:
+    pass
+
+import logging,os.path
+
+from popup import Popup
+
+log = logging.getLogger(__name__)
+
+def complete(line):
+    line = os.path.abspath(os.path.expanduser(line))
+    ret = []
+    if os.path.exists(line):
+        # This is a correct path, check to see if it's a directory
+        if os.path.isdir(line):
+            # Directory, so we need to show contents of directory
+            #ret.extend(os.listdir(line))
+            for f in os.listdir(line):
+                # Skip hidden
+                if f.startswith("."):
+                    continue
+                f = os.path.join(line, f)
+                if os.path.isdir(f):
+                    f += "/"
+                ret.append(f)
+        else:
+            # This is a file, but we could be looking for another file that
+            # shares a common prefix.
+            for f in os.listdir(os.path.dirname(line)):
+                if f.startswith(os.path.split(line)[1]):
+                    ret.append(os.path.join( os.path.dirname(line), f))
+    else:
+        # This path does not exist, so lets do a listdir on it's parent
+        # and find any matches.
+        ret = []
+        if os.path.isdir(os.path.dirname(line)):
+            for f in os.listdir(os.path.dirname(line)):
+                if f.startswith(os.path.split(line)[1]):
+                    p = os.path.join(os.path.dirname(line), f)
+
+                    if os.path.isdir(p):
+                        p += "/"
+                    ret.append(p)
+
+    return ret
+
+
+class InputPopup(Popup):
+    def __init__(self,parent_mode,title,width_req=-1,height_req=-1,close_cb=None):
+        Popup.__init__(self,parent_mode,title,width_req,height_req,close_cb)
+        self.input_list = []
+        self.input_states = {}
+        self.current_input = 0
+        self.tab_count = 0
+        self.opts = None
+        self.opt_off = 0
+        curses.curs_set(2)
+
+    def add_text_input(self, message, name, value="", complete=True):
+        """ 
+        Add a text input field to the popup.
+        
+        :param message: string to display above the input field
+        :param name: name of the field, for the return callback
+        :param value: initial value of the field
+        :param complete: should completion be run when tab is hit and this field is active
+        """
+        self.input_list.append(name)
+        self.input_states[name] = [message,value,0,complete]
+
+    def _refresh_lines(self):
+        crow = 1
+        for i,ipt in enumerate(self.input_list):
+            msg,txt,curs,comp = self.input_states[ipt]
+            if i == self.current_input:
+                curs_row = crow+1
+                curs_col = curs
+                if self.opts:
+                    self.parent.add_string(crow+2,self.opts[self.opt_off:],self.screen,1,False,True)
+            self.parent.add_string(crow,msg,self.screen,1,False,True)
+            self.parent.add_string(crow+1,"{!selected!}%s"%txt.ljust(self.width-2),self.screen,1,False,False)
+            crow += 3
+
+        self.screen.move(curs_row,curs_col+1)
+
+    def _get_current_input_value(self):
+        return self.input_states[self.input_list[self.current_input]][1]
+
+    def _set_current_input_value(self, val):
+        self.input_states[self.input_list[self.current_input]][1] = val
+
+    def _get_current_cursor(self):
+        return self.input_states[self.input_list[self.current_input]][2]
+
+    def _move_current_cursor(self, amt):
+        self.input_states[self.input_list[self.current_input]][2] += amt
+
+    def _set_current_cursor(self, pos):
+        self.input_states[self.input_list[self.current_input]][2] = pos
+
+    # most of the cursor,input stuff here taken from ui/console/screen.py
+    def handle_read(self, c):
+        if c == curses.KEY_UP:
+            self.current_input = max(0,self.current_input-1)
+        elif c == curses.KEY_DOWN:
+            self.current_input = min(len(self.input_list)-1,self.current_input+1)
+
+        elif c == curses.KEY_ENTER or c == 10:
+            if self._close_cb:
+                vals = {}
+                for ipt in self.input_list:
+                    vals[ipt] = self.input_states[ipt][1]
+                curses.curs_set(0)
+                self._close_cb(vals)
+            return True # close the popup
+
+        elif c == 9:
+            # Keep track of tab hit count to know when it's double-hit
+            self.tab_count += 1
+            if self.tab_count > 1:
+                second_hit = True
+                self.tab_count = 0
+            else:
+                second_hit = False
+
+            # We only call the tab completer function if we're at the end of
+            # the input string on the cursor is on a space
+            cur_input = self._get_current_input_value()
+            cur_cursor = self._get_current_cursor()
+            if cur_cursor == len(cur_input) or cur_input[cur_cursor] == " ":
+                if self.opts:
+                    prev = self.opt_off
+                    self.opt_off += self.width-3
+                    # now find previous double space, best guess at a split point
+                    # in future could keep opts unjoined to get this really right
+                    self.opt_off = self.opts.rfind("  ",0,self.opt_off)+2
+                    if second_hit and self.opt_off == prev: # double tap and we're at the end
+                        self.opt_off = 0
+                else:
+                    opts = complete(cur_input)
+                    if len(opts) == 1: # only one option, just complete it
+                        self._set_current_input_value(opts[0])
+                        self._set_current_cursor(len(opts[0]))
+                        self.tab_count = 0
+                    elif len(opts) > 1 and second_hit: # display multiple options on second tab hit
+                        self.opts = "  ".join(opts)
+
+        elif c == 27: # close on esc, no action
+            return True
+
+        # Cursor movement
+        elif c == curses.KEY_LEFT:
+            if self._get_current_cursor():
+                self._move_current_cursor(-1)
+        elif c == curses.KEY_RIGHT:
+            if self._get_current_cursor() < len(self._get_current_input_value()):
+                self._move_current_cursor(1)
+        elif c == curses.KEY_HOME:
+            self._set_current_cursor(0)
+        elif c == curses.KEY_END:
+            self._set_current_cursor(len(self._get_current_input_value()))
+
+        if c != 9:
+            self.opts = None
+            self.opt_off = 0
+            self.tab_count = 0
+
+        # Delete a character in the input string based on cursor position
+        if c == curses.KEY_BACKSPACE or c == 127:
+            cur_input = self._get_current_input_value()
+            cur_cursor = self._get_current_cursor()
+            if cur_input and  cur_cursor > 0:
+                self._set_current_input_value(cur_input[:cur_cursor - 1] + cur_input[cur_cursor:])
+                self._move_current_cursor(-1)
+        elif c == curses.KEY_DC:
+            cur_input = self._get_current_input_value()
+            cur_cursor = self._get_current_cursor()
+            if cur_input and cur_cursor < len(cur_input):
+                self._set_current_input_value(cur_input[:cur_cursor] + cur_input[cur_cursor+1:])
+        elif c > 31 and c < 256:
+            cur_input = self._get_current_input_value()
+            cur_cursor = self._get_current_cursor()
+            # Emulate getwch
+            stroke = chr(c)
+            uchar = ""
+            while not uchar:
+                try:
+                    uchar = stroke.decode(self.parent.encoding)
+                except UnicodeDecodeError:
+                    c = self.parent.stdscr.getch()
+                    stroke += chr(c)
+            if uchar:
+                if cur_cursor == len(cur_input):
+                    self._set_current_input_value(cur_input+uchar)
+                else:
+                    # Insert into string
+                    self._set_current_input_value(cur_input[:cur_cursor] + uchar + cur_input[cur_cursor:])
+                # Move the cursor forward
+                self._move_current_cursor(1)
+
+        self.refresh()
+        return False
+

deluge/ui/console/modes/popup.py

@@ -0,0 +1,254 @@
+# -*- coding: utf-8 -*-
+#
+# popup.py
+#
+# Copyright (C) 2011 Nick Lanham <nick@afternight.org>
+#
+# Deluge is free software.
+#
+# You may redistribute it and/or modify it under the terms of the
+# GNU General Public License, as published by the Free Software
+# Foundation; either version 3 of the License, or (at your option)
+# any later version.
+#
+# deluge 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 deluge.    If not, write to:
+# 	The Free Software Foundation, Inc.,
+# 	51 Franklin Street, Fifth Floor
+# 	Boston, MA  02110-1301, USA.
+#
+#    In addition, as a special exception, the copyright holders give
+#    permission to link the code of portions of this program with the OpenSSL
+#    library.
+#    You must obey the GNU General Public License in all respects for all of
+#    the code used other than OpenSSL. If you modify file(s) with this
+#    exception, you may extend this exception to your version of the file(s),
+#    but you are not obligated to do so. If you do not wish to do so, delete
+#    this exception statement from your version. If you delete this exception
+#    statement from all source files in the program, then also delete it here.
+#
+#
+
+try:
+    import curses
+    import signal
+except ImportError:
+    pass
+
+import logging
+log = logging.getLogger(__name__)
+
+class Popup:
+    def __init__(self,parent_mode,title,width_req=-1,height_req=-1,close_cb=None):
+        """
+        Init a new popup.  The default constructor will handle sizing and borders and the like.
+
+        NB: The parent mode is responsible for calling refresh on any popups it wants to show.
+            This should be called as the last thing in the parents refresh method.
+
+            The parent *must* also call _doRead on the popup instead of/in addition to 
+            running its own _doRead code if it wants to have the popup handle user input.
+
+        :param parent_mode: must be a basemode (or subclass) which the popup will be drawn over
+        :parem title: string, the title of the popup window
+
+        Popups have two methods that must be implemented:
+        
+        refresh(self) - draw the popup window to screen.  this default mode simply draws a bordered window
+                        with the supplied title to the screen
+
+        add_string(self, row, string) - add string at row.  handles triming/ignoring if the string won't fit in the popup
+
+        _doRead(self) - handle user input to the popup.  
+        """
+        self.parent = parent_mode
+
+        if (height_req <= 0):
+            height_req = int(self.parent.rows/2)
+        if (width_req <= 0):
+            width_req = int(self.parent.cols/2)
+        by = (self.parent.rows/2)-(height_req/2)
+        bx = (self.parent.cols/2)-(width_req/2)
+        self.screen = curses.newwin(height_req,width_req,by,bx)
+
+        self.title = title
+        self._close_cb = close_cb
+        self.height,self.width = self.screen.getmaxyx()
+        self._divider = None
+        self._lineoff = 0
+        self._lines = []
+
+    def _refresh_lines(self):
+        crow = 1
+        for row,line in enumerate(self._lines):
+            if (crow >= self.height-1):
+                break
+            if (row < self._lineoff):
+                continue
+            self.parent.add_string(crow,line,self.screen,1,False,True)
+            crow+=1
+
+    def handle_resize(self):
+        log.debug("Resizing popup window (actually, just creating a new one)")
+        self.screen = curses.newwin((self.parent.rows/2),(self.parent.cols/2),(self.parent.rows/4),(self.parent.cols/4))
+        self.height,self.width = self.screen.getmaxyx()
+        
+
+    def refresh(self):
+        self.screen.clear()
+        self.screen.border(0,0,0,0)
+        toff = max(1,int((self.parent.cols/4)-(len(self.title)/2)))
+        self.parent.add_string(0,"{!white,black,bold!}%s"%self.title,self.screen,toff,False,True)
+
+        self._refresh_lines()
+
+        self.screen.redrawwin()
+        self.screen.noutrefresh()
+
+    def clear(self):
+        self._lines = []
+
+    def handle_read(self, c):
+        if c == curses.KEY_UP:
+            self._lineoff = max(0,self._lineoff -1)
+        elif c == curses.KEY_DOWN:
+            if len(self._lines)-self._lineoff > (self.height-2):
+                self._lineoff += 1
+
+        elif c == curses.KEY_ENTER or c == 10 or c == 27: # close on enter/esc
+            if self._close_cb:
+                self._close_cb()
+            return True # close the popup        
+
+        if c > 31 and c < 256 and chr(c) == 'q':
+            if self._close_cb:
+                self._close_cb()
+            return True # close the popup
+
+        self.refresh()
+
+        return False
+
+    def set_title(self, title):
+        self.title = title
+
+    def add_line(self, string):
+        self._lines.append(string)
+
+    def add_divider(self):
+        if not self._divider:
+            self._divider = "-"*(self.width-2)
+        self._lines.append(self._divider)
+
+    
+class SelectablePopup(Popup):
+    """
+    A popup which will let the user select from some of the lines that
+    are added.
+    """
+    def __init__(self,parent_mode,title,selection_callback,*args):
+        Popup.__init__(self,parent_mode,title)
+        self._selection_callback = selection_callback
+        self._selection_args = args
+        self._selectable_lines = []
+        self._select_data = []
+        self._line_foregrounds = []
+        self._selected = -1
+
+    def add_line(self, string, selectable=True, data=None, foreground=None):
+        Popup.add_line(self,string)
+        self._line_foregrounds.append(foreground)
+        if selectable:
+            self._selectable_lines.append(len(self._lines)-1)
+            self._select_data.append(data)
+            if self._selected < 0:
+                self._selected = (len(self._lines)-1)
+
+    def _refresh_lines(self):
+        crow = 1
+        for row,line in enumerate(self._lines):
+            if (crow >= self.height-1):
+                break
+            if (row < self._lineoff):
+                continue
+            fg = self._line_foregrounds[row]
+            if row == self._selected:
+                if fg == None: fg = "black"
+                colorstr = "{!%s,white,bold!}"%fg
+            else:
+                if fg == None: fg = "white"
+                colorstr = "{!%s,black!}"%fg
+            self.parent.add_string(crow,"- %s%s"%(colorstr,line),self.screen,1,False,True)
+            crow+=1
+
+    def add_divider(self,color="white"):
+        if not self._divider:
+            self._divider = "-"*(self.width-6)+" -"
+        self._lines.append(self._divider)
+        self._line_foregrounds.append(color)
+
+    def handle_read(self, c):
+        if c == curses.KEY_UP:
+            #self._lineoff = max(0,self._lineoff -1)
+            if (self._selected != self._selectable_lines[0] and
+                len(self._selectable_lines) > 1):
+                idx = self._selectable_lines.index(self._selected)
+                self._selected = self._selectable_lines[idx-1]
+        elif c == curses.KEY_DOWN:
+            #if len(self._lines)-self._lineoff > (self.height-2):
+            #    self._lineoff += 1
+            idx = self._selectable_lines.index(self._selected)
+            if (idx < len(self._selectable_lines)-1):
+                self._selected = self._selectable_lines[idx+1]
+        elif c == 27: # close on esc, no action
+            return True
+        elif c == curses.KEY_ENTER or c == 10:
+            idx = self._selectable_lines.index(self._selected)
+            self._selection_callback(idx,self._select_data[idx],*self._selection_args)
+            return True
+        if c > 31 and c < 256 and chr(c) == 'q':
+            return True # close the popup
+
+        self.refresh()
+
+        return False
+
+
+class MessagePopup(Popup):
+    """
+    Popup that just displays a message
+    """
+    import re
+    _strip_re = re.compile("\{!.*?!\}")
+    _min_height = 3
+
+    def __init__(self, parent_mode, title, message):
+        self.message = message
+        self.width= int(parent_mode.cols/2)
+        lns = self._split_message(self.message)
+        height = max(len(lns),self._min_height)
+        Popup.__init__(self,parent_mode,title,height_req=(height+2))
+        lft = height - len(lns)
+        if lft:
+            for i in range(0,int(lft/2)):
+                lns.insert(0,"")
+        self._lines = lns
+
+    def _split_message(self,message):
+        ret = []
+        wl = (self.width-2)
+        for i in range(0,len(self.message),wl):
+            l = self.message[i:i+wl]
+            lp = (wl-len(self._strip_re.sub('',l)))/2
+            ret.append("%s%s"%(lp*" ",l))
+        return ret
+
+    def handle_resize(self):
+        Popup.handle_resize(self)
+        self.clear()
+        self._lines = self._split_message(self.message)