Fix alignment default.

IPython/Extensions/ibrowse.py

@@ -1,1413 +1,1415 b''
 # -*- coding: iso-8859-1 -*-
 
 import curses, textwrap
 
 import astyle, ipipe
 
 
 _ibrowse_help = """
 down
 Move the cursor to the next line.
 
 up
 Move the cursor to the previous line.
 
 pagedown
 Move the cursor down one page (minus overlap).
 
 pageup
 Move the cursor up one page (minus overlap).
 
 left
 Move the cursor left.
 
 right
 Move the cursor right.
 
 home
 Move the cursor to the first column.
 
 end
 Move the cursor to the last column.
 
 prevattr
 Move the cursor one attribute column to the left.
 
 nextattr
 Move the cursor one attribute column to the right.
 
 pick
 'Pick' the object under the cursor (i.e. the row the cursor is on). This
 leaves the browser and returns the picked object to the caller. (In IPython
 this object will be available as the '_' variable.)
 
 pickattr
 'Pick' the attribute under the cursor (i.e. the row/column the cursor is on).
 
 pickallattrs
 Pick' the complete column under the cursor (i.e. the attribute under the
 cursor) from all currently fetched objects. These attributes will be returned
 as a list.
 
 tooglemark
 Mark/unmark the object under the cursor. Marked objects have a '!' after the
 row number).
 
 pickmarked
 'Pick' marked objects. Marked objects will be returned as a list.
 
 pickmarkedattr
 'Pick' the attribute under the cursor from all marked objects (This returns a
 list).
 
 enterdefault
 Enter the object under the cursor. (what this mean depends on the object
 itself (i.e. how it implements the '__xiter__' method). This opens a new
 browser 'level'.
 
 enter
 Enter the object under the cursor. If the object provides different enter
 modes a menu of all modes will be presented; choose one and enter it (via the
 'enter' or 'enterdefault' command).
 
 enterattr
 Enter the attribute under the cursor.
 
 leave
 Leave the current browser level and go back to the previous one.
 
 detail
 Show a detail view of the object under the cursor. This shows the name, type,
 doc string and value of the object attributes (and it might show more
 attributes than in the list view, depending on the object).
 
 detailattr
 Show a detail view of the attribute under the cursor.
 
 markrange
 Mark all objects from the last marked object before the current cursor
 position to the cursor position.
 
 sortattrasc
 Sort the objects (in ascending order) using the attribute under the cursor as
 the sort key.
 
 sortattrdesc
 Sort the objects (in descending order) using the attribute under the cursor as
 the sort key.
 
 goto
 Jump to a row. The row number can be entered at the bottom of the screen.
 
 find
 Search forward for a row. At the bottom of the screen the condition can be
 entered.
 
 findbackwards
 Search backward for a row. At the bottom of the screen the condition can be
 entered.
 
 help
 This screen.
 """
 
 
 class UnassignedKeyError(Exception):
     """
     Exception that is used for reporting unassigned keys.
     """
 
 
 class UnknownCommandError(Exception):
     """
     Exception that is used for reporting unknown command (this should never
     happen).
     """
 
 
 class CommandError(Exception):
     """
     Exception that is used for reporting that a command can't be executed.
     """
 
 
 class _BrowserCachedItem(object):
     # This is used internally by ``ibrowse`` to store a item together with its
     # marked status.
     __slots__ = ("item", "marked")
 
     def __init__(self, item):
         self.item = item
         self.marked = False
 
 
 class _BrowserHelp(object):
     style_header = astyle.Style.fromstr("red:blacK")
     # This is used internally by ``ibrowse`` for displaying the help screen.
     def __init__(self, browser):
         self.browser = browser
 
     def __xrepr__(self, mode):
         yield (-1, True)
         if mode == "header" or mode == "footer":
             yield (astyle.style_default, "ibrowse help screen")
         else:
             yield (astyle.style_default, repr(self))
 
     def __xiter__(self, mode):
         # Get reverse key mapping
         allkeys = {}
         for (key, cmd) in self.browser.keymap.iteritems():
             allkeys.setdefault(cmd, []).append(key)
 
         fields = ("key", "description")
 
         for (i, command) in enumerate(_ibrowse_help.strip().split("\n\n")):
             if i:
                 yield ipipe.Fields(fields, key="", description="")
 
             (name, description) = command.split("\n", 1)
             keys = allkeys.get(name, [])
             lines = textwrap.wrap(description, 60)
 
             yield ipipe.Fields(fields, description=astyle.Text((self.style_header, name)))
             for i in xrange(max(len(keys), len(lines))):
                 try:
                     key = self.browser.keylabel(keys[i])
                 except IndexError:
                     key = ""
                 try:
                     line = lines[i]
                 except IndexError:
                     line = ""
                 yield ipipe.Fields(fields, key=key, description=line)
 
 
 class _BrowserLevel(object):
     # This is used internally to store the state (iterator, fetch items,
     # position of cursor and screen, etc.) of one browser level
     # An ``ibrowse`` object keeps multiple ``_BrowserLevel`` objects in
     # a stack.
     def __init__(self, browser, input, iterator, mainsizey, *attrs):
         self.browser = browser
         self.input = input
         self.header = [x for x in ipipe.xrepr(input, "header") if not isinstance(x[0], int)]
         # iterator for the input
         self.iterator = iterator
 
         # is the iterator exhausted?
         self.exhausted = False
 
         # attributes to be display (autodetected if empty)
         self.attrs = attrs
 
         # fetched items (+ marked flag)
         self.items = ipipe.deque()
 
         # Number of marked objects
         self.marked = 0
 
         # Vertical cursor position
         self.cury = 0
 
         # Horizontal cursor position
         self.curx = 0
 
         # Index of first data column
         self.datastartx = 0
 
         # Index of first data line
         self.datastarty = 0
 
         # height of the data display area
         self.mainsizey = mainsizey
 
         # width of the data display area (changes when scrolling)
         self.mainsizex = 0
 
         # Size of row number (changes when scrolling)
         self.numbersizex = 0
 
         # Attribute names to display (in this order)
         self.displayattrs = []
 
         # index and name of attribute under the cursor
         self.displayattr = (None, ipipe.noitem)
 
         # Maps attribute names to column widths
         self.colwidths = {}
 
         self.fetch(mainsizey)
         self.calcdisplayattrs()
         # formatted attributes for the items on screen
         # (i.e. self.items[self.datastarty:self.datastarty+self.mainsizey])
         self.displayrows = [self.getrow(i) for i in xrange(len(self.items))]
         self.calcwidths()
         self.calcdisplayattr()
 
     def fetch(self, count):
         # Try to fill ``self.items`` with at least ``count`` objects.
         have = len(self.items)
         while not self.exhausted and have < count:
             try:
                 item = self.iterator.next()
             except StopIteration:
                 self.exhausted = True
                 break
             else:
                 have += 1
                 self.items.append(_BrowserCachedItem(item))
 
     def calcdisplayattrs(self):
         # Calculate which attributes are available from the objects that are
         # currently visible on screen (and store it in ``self.displayattrs``)
         attrnames = set()
         # If the browser object specifies a fixed list of attributes,
         # simply use it.
         if self.attrs:
             self.displayattrs = self.attrs
         else:
             self.displayattrs = []
             endy = min(self.datastarty+self.mainsizey, len(self.items))
             for i in xrange(self.datastarty, endy):
                 for attrname in ipipe.xattrs(self.items[i].item, "default"):
                     if attrname not in attrnames:
                         self.displayattrs.append(attrname)
                         attrnames.add(attrname)
 
     def getrow(self, i):
         # Return a dictinary with the attributes for the object
         # ``self.items[i]``. Attribute names are taken from
         # ``self.displayattrs`` so ``calcdisplayattrs()`` must have been
         # called before.
         row = {}
         item = self.items[i].item
         for attrname in self.displayattrs:
             try:
                 value = ipipe._getattr(item, attrname, ipipe.noitem)
             except (KeyboardInterrupt, SystemExit):
                 raise
             except Exception, exc:
                 value = exc
             # only store attribute if it exists (or we got an exception)
             if value is not ipipe.noitem:
                 parts = []
                 totallength = 0
                 align = None
-                full = False
+                full = True
                 # Collect parts until we have enough
                 for part in ipipe.xrepr(value, "cell"):
                     # part gives (alignment, stop)
                     # instead of (style, text)
                     if isinstance(part[0], int):
                         # only consider the first occurence
                         if align is None:
                             align = part[0]
                             full = part[1]
                     else:
                         parts.append(part)
                         totallength += len(part[1])
                         if totallength >= self.browser.maxattrlength and not full:
                             parts.append((astyle.style_ellisis, "..."))
                             totallength += 3
                             break
+                if align is None:
+                    align = -1
                 # remember alignment, length and colored parts
                 row[attrname] = (align, totallength, parts)
         return row
 
     def calcwidths(self):
         # Recalculate the displayed fields and their width.
         # ``calcdisplayattrs()'' must have been called and the cache
         # for attributes of the objects on screen (``self.displayrows``)
         # must have been filled. This returns a dictionary mapping
         # colmn names to width.
         self.colwidths = {}
         for row in self.displayrows:
             for attrname in self.displayattrs:
                 try:
                     length = row[attrname][1]
                 except KeyError:
                     length = 0
                 # always add attribute to colwidths, even if it doesn't exist
                 if attrname not in self.colwidths:
                     self.colwidths[attrname] = len(ipipe._attrname(attrname))
                 newwidth = max(self.colwidths[attrname], length)
                 self.colwidths[attrname] = newwidth
 
         # How many characters do we need to paint the item number?
         self.numbersizex = len(str(self.datastarty+self.mainsizey-1))
         # How must space have we got to display data?
         self.mainsizex = self.browser.scrsizex-self.numbersizex-3
         # width of all columns
         self.datasizex = sum(self.colwidths.itervalues()) + len(self.colwidths)
 
     def calcdisplayattr(self):
         # Find out on which attribute the cursor is on and store this
         # information in ``self.displayattr``.
         pos = 0
         for (i, attrname) in enumerate(self.displayattrs):
             if pos+self.colwidths[attrname] >= self.curx:
                 self.displayattr = (i, attrname)
                 break
             pos += self.colwidths[attrname]+1
         else:
             self.displayattr = (None, ipipe.noitem)
 
     def moveto(self, x, y, refresh=False):
         # Move the cursor to the position ``(x,y)`` (in data coordinates,
         # not in screen coordinates). If ``refresh`` is true, all cached
         # values will be recalculated (e.g. because the list has been
         # resorted, so screen positions etc. are no longer valid).
         olddatastarty = self.datastarty
         oldx = self.curx
         oldy = self.cury
         x = int(x+0.5)
         y = int(y+0.5)
         newx = x # remember where we wanted to move
         newy = y # remember where we wanted to move
 
         scrollbordery = min(self.browser.scrollbordery, self.mainsizey//2)
         scrollborderx = min(self.browser.scrollborderx, self.mainsizex//2)
 
         # Make sure that the cursor didn't leave the main area vertically
         if y < 0:
             y = 0
         self.fetch(y+scrollbordery+1) # try to get more items
         if y >= len(self.items):
             y = max(0, len(self.items)-1)
 
         # Make sure that the cursor stays on screen vertically
         if y < self.datastarty+scrollbordery:
             self.datastarty = max(0, y-scrollbordery)
         elif y >= self.datastarty+self.mainsizey-scrollbordery:
             self.datastarty = max(0, min(y-self.mainsizey+scrollbordery+1,
                                          len(self.items)-self.mainsizey))
 
         if refresh: # Do we need to refresh the complete display?
             self.calcdisplayattrs()
             endy = min(self.datastarty+self.mainsizey, len(self.items))
             self.displayrows = map(self.getrow, xrange(self.datastarty, endy))
             self.calcwidths()
         # Did we scroll vertically => update displayrows
         # and various other attributes
         elif self.datastarty != olddatastarty:
             # Recalculate which attributes we have to display
             olddisplayattrs = self.displayattrs
             self.calcdisplayattrs()
             # If there are new attributes, recreate the cache
             if self.displayattrs != olddisplayattrs:
                 endy = min(self.datastarty+self.mainsizey, len(self.items))
                 self.displayrows = map(self.getrow, xrange(self.datastarty, endy))
             elif self.datastarty<olddatastarty: # we did scroll up
                 # drop rows from the end
                 del self.displayrows[self.datastarty-olddatastarty:]
                 # fetch new items
                 for i in xrange(olddatastarty-1,
                                 self.datastarty-1, -1):
                     try:
                         row = self.getrow(i)
                     except IndexError:
                         # we didn't have enough objects to fill the screen
                         break
                     self.displayrows.insert(0, row)
             else: # we did scroll down
                 # drop rows from the start
                 del self.displayrows[:self.datastarty-olddatastarty]
                 # fetch new items
                 for i in xrange(olddatastarty+self.mainsizey,
                                 self.datastarty+self.mainsizey):
                     try:
                         row = self.getrow(i)
                     except IndexError:
                         # we didn't have enough objects to fill the screen
                         break
                     self.displayrows.append(row)
             self.calcwidths()
 
         # Make sure that the cursor didn't leave the data area horizontally
         if x < 0:
             x = 0
         elif x >= self.datasizex:
             x = max(0, self.datasizex-1)
 
         # Make sure that the cursor stays on screen horizontally
         if x < self.datastartx+scrollborderx:
             self.datastartx = max(0, x-scrollborderx)
         elif x >= self.datastartx+self.mainsizex-scrollborderx:
             self.datastartx = max(0, min(x-self.mainsizex+scrollborderx+1,
                                          self.datasizex-self.mainsizex))
 
         if x == oldx and y == oldy and (x != newx or y != newy): # couldn't move
             self.browser.beep()
         else:
             self.curx = x
             self.cury = y
             self.calcdisplayattr()
 
     def sort(self, key, reverse=False):
         """
         Sort the currently list of items using the key function ``key``. If
         ``reverse`` is true the sort order is reversed.
         """
         curitem = self.items[self.cury] # Remember where the cursor is now
 
         # Sort items
         def realkey(item):
             return key(item.item)
         self.items = ipipe.deque(sorted(self.items, key=realkey, reverse=reverse))
 
         # Find out where the object under the cursor went
         cury = self.cury
         for (i, item) in enumerate(self.items):
             if item is curitem:
                 cury = i
                 break
 
         self.moveto(self.curx, cury, refresh=True)
 
 
 class ibrowse(ipipe.Display):
     # Show this many lines from the previous screen when paging horizontally
     pageoverlapx = 1
 
     # Show this many lines from the previous screen when paging vertically
     pageoverlapy = 1
 
     # Start scrolling when the cursor is less than this number of columns
     # away from the left or right screen edge
     scrollborderx = 10
 
     # Start scrolling when the cursor is less than this number of lines
     # away from the top or bottom screen edge
     scrollbordery = 5
 
     # Accelerate by this factor when scrolling horizontally
     acceleratex = 1.05
 
     # Accelerate by this factor when scrolling vertically
     acceleratey = 1.05
 
     # The maximum horizontal scroll speed
     # (as a factor of the screen width (i.e. 0.5 == half a screen width)
     maxspeedx = 0.5
 
     # The maximum vertical scroll speed
     # (as a factor of the screen height (i.e. 0.5 == half a screen height)
     maxspeedy = 0.5
 
     # The maximum number of header lines for browser level
     # if the nesting is deeper, only the innermost levels are displayed
     maxheaders = 5
 
     # The approximate maximum length of a column entry
     maxattrlength = 200
 
     # Styles for various parts of the GUI
     style_objheadertext = astyle.Style.fromstr("white:black:bold|reverse")
     style_objheadernumber = astyle.Style.fromstr("white:blue:bold|reverse")
     style_objheaderobject = astyle.Style.fromstr("white:black:reverse")
     style_colheader = astyle.Style.fromstr("blue:white:reverse")
     style_colheaderhere = astyle.Style.fromstr("green:black:bold|reverse")
     style_colheadersep = astyle.Style.fromstr("blue:black:reverse")
     style_number = astyle.Style.fromstr("blue:white:reverse")
     style_numberhere = astyle.Style.fromstr("green:black:bold|reverse")
     style_sep = astyle.Style.fromstr("blue:black")
     style_data = astyle.Style.fromstr("white:black")
     style_datapad = astyle.Style.fromstr("blue:black:bold")
     style_footer = astyle.Style.fromstr("black:white")
     style_report = astyle.Style.fromstr("white:black")
 
     # Column separator in header
     headersepchar = "|"
 
     # Character for padding data cell entries
     datapadchar = "."
 
     # Column separator in data area
     datasepchar = "|"
 
     # Character to use for "empty" cell (i.e. for non-existing attributes)
     nodatachar = "-"
 
     # Prompts for modes that require keyboard input
     prompts = {
         "goto": "goto object #: ",
         "find": "find expression: ",
         "findbackwards": "find backwards expression: "
     }
 
     # Maps curses key codes to "function" names
     keymap = {
         ord("q"): "quit",
         curses.KEY_UP: "up",
         curses.KEY_DOWN: "down",
         curses.KEY_PPAGE: "pageup",
         curses.KEY_NPAGE: "pagedown",
         curses.KEY_LEFT: "left",
         curses.KEY_RIGHT: "right",
         curses.KEY_HOME: "home",
         curses.KEY_END: "end",
         ord("<"): "prevattr",
         0x1b:     "prevattr", # SHIFT-TAB
         ord(">"): "nextattr",
         ord("\t"):"nextattr", # TAB
         ord("p"): "pick",
         ord("P"): "pickattr",
         ord("C"): "pickallattrs",
         ord("m"): "pickmarked",
         ord("M"): "pickmarkedattr",
         ord("\n"): "enterdefault",
         # FIXME: What's happening here?
         8: "leave",
         127: "leave",
         curses.KEY_BACKSPACE: "leave",
         ord("x"): "leave",
         ord("h"): "help",
         ord("e"): "enter",
         ord("E"): "enterattr",
         ord("d"): "detail",
         ord("D"): "detailattr",
         ord(" "): "tooglemark",
         ord("r"): "markrange",
         ord("v"): "sortattrasc",
         ord("V"): "sortattrdesc",
         ord("g"): "goto",
         ord("f"): "find",
         ord("b"): "findbackwards",
     }
 
     def __init__(self, *attrs):
         """
         Create a new browser. If ``attrs`` is not empty, it is the list
         of attributes that will be displayed in the browser, otherwise
         these will be determined by the objects on screen.
         """
         self.attrs = attrs
 
         # Stack of browser levels
         self.levels = []
         # how many colums to scroll (Changes when accelerating)
         self.stepx = 1.
 
         # how many rows to scroll (Changes when accelerating)
         self.stepy = 1.
 
         # Beep on the edges of the data area? (Will be set to ``False``
         # once the cursor hits the edge of the screen, so we don't get
         # multiple beeps).
         self._dobeep = True
 
         # Cache for registered ``curses`` colors and styles.
         self._styles = {}
         self._colors = {}
         self._maxcolor = 1
 
         # How many header lines do we want to paint (the numbers of levels
         # we have, but with an upper bound)
         self._headerlines = 1
 
         # Index of first header line
         self._firstheaderline = 0
 
         # curses window
         self.scr = None
         # report in the footer line (error, executed command etc.)
         self._report = None
 
         # value to be returned to the caller (set by commands)
         self.returnvalue = None
 
         # The mode the browser is in
         # e.g. normal browsing or entering an argument for a command
         self.mode = "default"
 
         # The partially entered row number for the goto command
         self.goto = ""
 
     def nextstepx(self, step):
         """
         Accelerate horizontally.
         """
         return max(1., min(step*self.acceleratex,
                            self.maxspeedx*self.levels[-1].mainsizex))
 
     def nextstepy(self, step):
         """
         Accelerate vertically.
         """
         return max(1., min(step*self.acceleratey,
                            self.maxspeedy*self.levels[-1].mainsizey))
 
     def getstyle(self, style):
         """
         Register the ``style`` with ``curses`` or get it from the cache,
         if it has been registered before.
         """
         try:
             return self._styles[style.fg, style.bg, style.attrs]
         except KeyError:
             attrs = 0
             for b in astyle.A2CURSES:
                 if style.attrs & b:
                     attrs |= astyle.A2CURSES[b]
             try:
                 color = self._colors[style.fg, style.bg]
             except KeyError:
                 curses.init_pair(
                     self._maxcolor,
                     astyle.COLOR2CURSES[style.fg],
                     astyle.COLOR2CURSES[style.bg]
                 )
                 color = curses.color_pair(self._maxcolor)
                 self._colors[style.fg, style.bg] = color
                 self._maxcolor += 1
             c = color | attrs
             self._styles[style.fg, style.bg, style.attrs] = c
             return c
 
     def addstr(self, y, x, begx, endx, text, style):
         """
         A version of ``curses.addstr()`` that can handle ``x`` coordinates
         that are outside the screen.
         """
         text2 = text[max(0, begx-x):max(0, endx-x)]
         if text2:
             self.scr.addstr(y, max(x, begx), text2, self.getstyle(style))
         return len(text)
 
     def addchr(self, y, x, begx, endx, c, l, style):
         x0 = max(x, begx)
         x1 = min(x+l, endx)
         if x1>x0:
             self.scr.addstr(y, x0, c*(x1-x0), self.getstyle(style))
         return l
 
     def _calcheaderlines(self, levels):
         # Calculate how many headerlines do we have to display, if we have
         # ``levels`` browser levels
         if levels is None:
             levels = len(self.levels)
         self._headerlines = min(self.maxheaders, levels)
         self._firstheaderline = levels-self._headerlines
 
     def getstylehere(self, style):
         """
         Return a style for displaying the original style ``style``
         in the row the cursor is on.
         """
         return astyle.Style(style.fg, style.bg, style.attrs | astyle.A_BOLD)
 
     def report(self, msg):
         """
         Store the message ``msg`` for display below the footer line. This
         will be displayed as soon as the screen is redrawn.
         """
         self._report = msg
 
     def enter(self, item, mode, *attrs):
         """
         Enter the object ``item`` in the mode ``mode``. If ``attrs`` is
         specified, it will be used as a fixed list of attributes to display.
         """
         try:
             iterator = ipipe.xiter(item, mode)
         except (KeyboardInterrupt, SystemExit):
             raise
         except Exception, exc:
             curses.beep()
             self.report(exc)
         else:
             self._calcheaderlines(len(self.levels)+1)
             level = _BrowserLevel(
                 self,
                 item,
                 iterator,
                 self.scrsizey-1-self._headerlines-2,
                 *attrs
             )
             self.levels.append(level)
 
     def startkeyboardinput(self, mode):
         """
         Enter mode ``mode``, which requires keyboard input.
         """
         self.mode = mode
         self.keyboardinput = ""
         self.cursorpos = 0
 
     def executekeyboardinput(self, mode):
         exe = getattr(self, "exe_%s" % mode, None)
         if exe is not None:
             exe()
             self.mode = "default"
 
     def keylabel(self, keycode):
         """
         Return a pretty name for the ``curses`` key ``keycode`` (used in the
         help screen and in reports about unassigned keys).
         """
         if keycode <= 0xff:
             specialsnames = {
                 ord("\n"): "RETURN",
                 ord(" "): "SPACE",
                 ord("\t"): "TAB",
                 ord("\x7f"): "DELETE",
                 ord("\x08"): "BACKSPACE",
             }
             if keycode in specialsnames:
                 return specialsnames[keycode]
             return repr(chr(keycode))
         for name in dir(curses):
             if name.startswith("KEY_") and getattr(curses, name) == keycode:
                 return name
         return str(keycode)
 
     def beep(self, force=False):
         if force or self._dobeep:
             curses.beep()
             # don't beep again (as long as the same key is pressed)
             self._dobeep = False
 
     def cmd_quit(self):
         self.returnvalue = None
         return True
 
     def cmd_up(self):
         level = self.levels[-1]
         self.report("up")
         level.moveto(level.curx, level.cury-self.stepy)
 
     def cmd_down(self):
         level = self.levels[-1]
         self.report("down")
         level.moveto(level.curx, level.cury+self.stepy)
 
     def cmd_pageup(self):
         level = self.levels[-1]
         self.report("page up")
         level.moveto(level.curx, level.cury-level.mainsizey+self.pageoverlapy)
 
     def cmd_pagedown(self):
         level = self.levels[-1]
         self.report("page down")
         level.moveto(level.curx, level.cury+level.mainsizey-self.pageoverlapy)
 
     def cmd_left(self):
         level = self.levels[-1]
         self.report("left")
         level.moveto(level.curx-self.stepx, level.cury)
 
     def cmd_right(self):
         level = self.levels[-1]
         self.report("right")
         level.moveto(level.curx+self.stepx, level.cury)
 
     def cmd_home(self):
         level = self.levels[-1]
         self.report("home")
         level.moveto(0, level.cury)
 
     def cmd_end(self):
         level = self.levels[-1]
         self.report("end")
         level.moveto(level.datasizex+level.mainsizey-self.pageoverlapx, level.cury)
 
     def cmd_prevattr(self):
         level = self.levels[-1]
         if level.displayattr[0] is None or level.displayattr[0] == 0:
             self.beep()
         else:
             self.report("prevattr")
             pos = 0
             for (i, attrname) in enumerate(level.displayattrs):
                 if i == level.displayattr[0]-1:
                     break
                 pos += level.colwidths[attrname] + 1
             level.moveto(pos, level.cury)
 
     def cmd_nextattr(self):
         level = self.levels[-1]
         if level.displayattr[0] is None or level.displayattr[0] == len(level.displayattrs)-1:
             self.beep()
         else:
             self.report("nextattr")
             pos = 0
             for (i, attrname) in enumerate(level.displayattrs):
                 if i == level.displayattr[0]+1:
                     break
                 pos += level.colwidths[attrname] + 1
             level.moveto(pos, level.cury)
 
     def cmd_pick(self):
         level = self.levels[-1]
         self.returnvalue = level.items[level.cury].item
         return True
 
     def cmd_pickattr(self):
         level = self.levels[-1]
         attrname = level.displayattr[1]
         if attrname is ipipe.noitem:
             curses.beep()
             self.report(AttributeError(ipipe._attrname(attrname)))
             return
         attr = ipipe._getattr(level.items[level.cury].item, attrname)
         if attr is ipipe.noitem:
             curses.beep()
             self.report(AttributeError(ipipe._attrname(attrname)))
         else:
             self.returnvalue = attr
             return True
 
     def cmd_pickallattrs(self):
         level = self.levels[-1]
         attrname = level.displayattr[1]
         if attrname is ipipe.noitem:
             curses.beep()
             self.report(AttributeError(ipipe._attrname(attrname)))
             return
         result = []
         for cache in level.items:
             attr = ipipe._getattr(cache.item, attrname)
             if attr is not ipipe.noitem:
                 result.append(attr)
         self.returnvalue = result
         return True
 
     def cmd_pickmarked(self):
         level = self.levels[-1]
         self.returnvalue = [cache.item for cache in level.items if cache.marked]
         return True
 
     def cmd_pickmarkedattr(self):
         level = self.levels[-1]
         attrname = level.displayattr[1]
         if attrname is ipipe.noitem:
             curses.beep()
             self.report(AttributeError(ipipe._attrname(attrname)))
             return
         result = []
         for cache in level.items:
             if cache.marked:
                 attr = ipipe._getattr(cache.item, attrname)
                 if attr is not ipipe.noitem:
                     result.append(attr)
         self.returnvalue = result
         return True
 
     def cmd_markrange(self):
         level = self.levels[-1]
         self.report("markrange")
         start = None
         if level.items:
             for i in xrange(level.cury, -1, -1):
                 if level.items[i].marked:
                     start = i
                     break
         if start is None:
             self.report(CommandError("no mark before cursor"))
             curses.beep()
         else:
             for i in xrange(start, level.cury+1):
                 cache = level.items[i]
                 if not cache.marked:
                     cache.marked = True
                     level.marked += 1
 
     def cmd_enterdefault(self):
         level = self.levels[-1]
         try:
             item = level.items[level.cury].item
         except IndexError:
             self.report(CommandError("No object"))
             curses.beep()
         else:
             self.report("entering object (default mode)...")
             self.enter(item, "default")
 
     def cmd_leave(self):
         self.report("leave")
         if len(self.levels) > 1:
             self._calcheaderlines(len(self.levels)-1)
             self.levels.pop(-1)
         else:
             self.report(CommandError("This is the last level"))
             curses.beep()
 
     def cmd_enter(self):
         level = self.levels[-1]
         try:
             item = level.items[level.cury].item
         except IndexError:
             self.report(CommandError("No object"))
             curses.beep()
         else:
             self.report("entering object...")
             self.enter(item, None)
 
     def cmd_enterattr(self):
         level = self.levels[-1]
         attrname = level.displayattr[1]
         if attrname is ipipe.noitem:
             curses.beep()
             self.report(AttributeError(ipipe._attrname(attrname)))
             return
         try:
             item = level.items[level.cury].item
         except IndexError:
             self.report(CommandError("No object"))
             curses.beep()
         else:
             attr = ipipe._getattr(item, attrname)
             if attr is ipipe.noitem:
                 self.report(AttributeError(ipipe._attrname(attrname)))
             else:
                 self.report("entering object attribute %s..." % ipipe._attrname(attrname))
                 self.enter(attr, None)
 
     def cmd_detail(self):
         level = self.levels[-1]
         try:
             item = level.items[level.cury].item
         except IndexError:
             self.report(CommandError("No object"))
             curses.beep()
         else:
             self.report("entering detail view for object...")
             self.enter(item, "detail")
 
     def cmd_detailattr(self):
         level = self.levels[-1]
         attrname = level.displayattr[1]
         if attrname is ipipe.noitem:
             curses.beep()
             self.report(AttributeError(ipipe._attrname(attrname)))
             return
         try:
             item = level.items[level.cury].item
         except IndexError:
             self.report(CommandError("No object"))
             curses.beep()
         else:
             attr = ipipe._getattr(item, attrname)
             if attr is ipipe.noitem:
                 self.report(AttributeError(ipipe._attrname(attrname)))
             else:
                 self.report("entering detail view for attribute...")
                 self.enter(attr, "detail")
 
     def cmd_tooglemark(self):
         level = self.levels[-1]
         self.report("toggle mark")
         try:
             item = level.items[level.cury]
         except IndexError: # no items?
             pass
         else:
             if item.marked:
                 item.marked = False
                 level.marked -= 1
             else:
                 item.marked = True
                 level.marked += 1
 
     def cmd_sortattrasc(self):
         level = self.levels[-1]
         attrname = level.displayattr[1]
         if attrname is ipipe.noitem:
             curses.beep()
             self.report(AttributeError(ipipe._attrname(attrname)))
             return
         self.report("sort by %s (ascending)" % ipipe._attrname(attrname))
         def key(item):
             try:
                 return ipipe._getattr(item, attrname, None)
             except (KeyboardInterrupt, SystemExit):
                 raise
             except Exception:
                 return None
         level.sort(key)
 
     def cmd_sortattrdesc(self):
         level = self.levels[-1]
         attrname = level.displayattr[1]
         if attrname is ipipe.noitem:
             curses.beep()
             self.report(AttributeError(ipipe._attrname(attrname)))
             return
         self.report("sort by %s (descending)" % ipipe._attrname(attrname))
         def key(item):
             try:
                 return ipipe._getattr(item, attrname, None)
             except (KeyboardInterrupt, SystemExit):
                 raise
             except Exception:
                 return None
         level.sort(key, reverse=True)
 
     def cmd_goto(self):
         self.startkeyboardinput("goto")
 
     def exe_goto(self):
         level = self.levels[-1]
         if self.keyboardinput:
             level.moveto(level.curx, int(self.keyboardinput))
 
     def cmd_find(self):
         self.startkeyboardinput("find")
 
     def exe_find(self):
         level = self.levels[-1]
         if self.keyboardinput:
             while True:
                 cury = level.cury
                 level.moveto(level.curx, cury+1)
                 if cury == level.cury:
                     curses.beep()
                     break
                 item = level.items[level.cury].item
                 try:
                     if eval(self.keyboardinput, globals(), ipipe.AttrNamespace(item)):
                         break
                 except (KeyboardInterrupt, SystemExit):
                     raise
                 except Exception, exc:
                     self.report(exc)
                     curses.beep()
                     break # break on error
 
     def cmd_findbackwards(self):
         self.startkeyboardinput("findbackwards")
 
     def exe_findbackwards(self):
         level = self.levels[-1]
         if self.keyboardinput:
             while level.cury:
                 level.moveto(level.curx, level.cury-1)
                 item = level.items[level.cury].item
                 try:
                     if eval(self.keyboardinput, globals(), ipipe.AttrNamespace(item)):
                         break
                 except (KeyboardInterrupt, SystemExit):
                     raise
                 except Exception, exc:
                     self.report(exc)
                     curses.beep()
                     break # break on error
             else:
                 curses.beep()
 
     def cmd_help(self):
         """
         The help command
         """
         for level in self.levels:
             if isinstance(level.input, _BrowserHelp):
                 curses.beep()
                 self.report(CommandError("help already active"))
                 return
 
         self.enter(_BrowserHelp(self), "default")
 
     def _dodisplay(self, scr):
         """
         This method is the workhorse of the browser. It handles screen
         drawing and the keyboard.
         """
         self.scr = scr
         curses.halfdelay(1)
         footery = 2
 
         keys = []
         for (key, cmd) in self.keymap.iteritems():
             if cmd == "quit":
                 keys.append("%s=%s" % (self.keylabel(key), cmd))
         for (key, cmd) in self.keymap.iteritems():
             if cmd == "help":
                 keys.append("%s=%s" % (self.keylabel(key), cmd))
         helpmsg = " | %s" % " ".join(keys)
 
         scr.clear()
         msg = "Fetching first batch of objects..."
         (self.scrsizey, self.scrsizex) = scr.getmaxyx()
         scr.addstr(self.scrsizey//2, (self.scrsizex-len(msg))//2, msg)
         scr.refresh()
 
         lastc = -1
 
         self.levels = []
         # enter the first level
         self.enter(self.input, ipipe.xiter(self.input, "default"), *self.attrs)
 
         self._calcheaderlines(None)
 
         while True:
             level = self.levels[-1]
             (self.scrsizey, self.scrsizex) = scr.getmaxyx()
             level.mainsizey = self.scrsizey-1-self._headerlines-footery
 
             # Paint object header
             for i in xrange(self._firstheaderline, self._firstheaderline+self._headerlines):
                 lv = self.levels[i]
                 posx = 0
                 posy = i-self._firstheaderline
                 endx = self.scrsizex
                 if i: # not the first level
                     msg = " (%d/%d" % (self.levels[i-1].cury, len(self.levels[i-1].items))
                     if not self.levels[i-1].exhausted:
                         msg += "+"
                     msg += ") "
                     endx -= len(msg)+1
                 posx += self.addstr(posy, posx, 0, endx, " ibrowse #%d: " % i, self.style_objheadertext)
                 for (style, text) in lv.header:
                     posx += self.addstr(posy, posx, 0, endx, text, self.style_objheaderobject)
                     if posx >= endx:
                         break
                 if i:
                     posx += self.addstr(posy, posx, 0, self.scrsizex, msg, self.style_objheadernumber)
                 posx += self.addchr(posy, posx, 0, self.scrsizex, " ", self.scrsizex-posx, self.style_objheadernumber)
 
             if not level.items:
                 self.addchr(self._headerlines, 0, 0, self.scrsizex, " ", self.scrsizex, self.style_colheader)
                 self.addstr(self._headerlines+1, 0, 0, self.scrsizex, " <empty>", astyle.style_error)
                 scr.clrtobot()
             else:
                 # Paint column headers
                 scr.move(self._headerlines, 0)
                 scr.addstr(" %*s " % (level.numbersizex, "#"), self.getstyle(self.style_colheader))
                 scr.addstr(self.headersepchar, self.getstyle(self.style_colheadersep))
                 begx = level.numbersizex+3
                 posx = begx-level.datastartx
                 for attrname in level.displayattrs:
                     strattrname = ipipe._attrname(attrname)
                     cwidth = level.colwidths[attrname]
                     header = strattrname.ljust(cwidth)
                     if attrname == level.displayattr[1]:
                         style = self.style_colheaderhere
                     else:
                         style = self.style_colheader
                     posx += self.addstr(self._headerlines, posx, begx, self.scrsizex, header, style)
                     posx += self.addstr(self._headerlines, posx, begx, self.scrsizex, self.headersepchar, self.style_colheadersep)
                     if posx >= self.scrsizex:
                         break
                 else:
                     scr.addstr(" "*(self.scrsizex-posx), self.getstyle(self.style_colheader))
 
                 # Paint rows
                 posy = self._headerlines+1+level.datastarty
                 for i in xrange(level.datastarty, min(level.datastarty+level.mainsizey, len(level.items))):
                     cache = level.items[i]
                     if i == level.cury:
                         style = self.style_numberhere
                     else:
                         style = self.style_number
 
                     posy = self._headerlines+1+i-level.datastarty
                     posx = begx-level.datastartx
 
                     scr.move(posy, 0)
                     scr.addstr(" %*d%s" % (level.numbersizex, i, " !"[cache.marked]), self.getstyle(style))
                     scr.addstr(self.headersepchar, self.getstyle(self.style_sep))
 
                     for attrname in level.displayattrs:
                         cwidth = level.colwidths[attrname]
                         try:
                             (align, length, parts) = level.displayrows[i-level.datastarty][attrname]
                         except KeyError:
                             align = 2
                             style = astyle.style_nodata
                         padstyle = self.style_datapad
                         sepstyle = self.style_sep
                         if i == level.cury:
                             padstyle = self.getstylehere(padstyle)
                             sepstyle = self.getstylehere(sepstyle)
                         if align == 2:
                             posx += self.addchr(posy, posx, begx, self.scrsizex, self.nodatachar, cwidth, style)
                         else:
                             if align == 1:
                                 posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, cwidth-length, padstyle)
                             elif align == 0:
                                 pad1 = (cwidth-length)//2
                                 pad2 = cwidth-length-len(pad1)
                                 posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, pad1, padstyle)
                             for (style, text) in parts:
                                 if i == level.cury:
                                     style = self.getstylehere(style)
                                 posx += self.addstr(posy, posx, begx, self.scrsizex, text, style)
                                 if posx >= self.scrsizex:
                                     break
                             if align == -1:
                                 posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, cwidth-length, padstyle)
                             elif align == 0:
                                 posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, pad2, padstyle)
                         posx += self.addstr(posy, posx, begx, self.scrsizex, self.datasepchar, sepstyle)
                     else:
                         scr.clrtoeol()
 
                 # Add blank row headers for the rest of the screen
                 for posy in xrange(posy+1, self.scrsizey-2):
                     scr.addstr(posy, 0, " " * (level.numbersizex+2), self.getstyle(self.style_colheader))
                     scr.clrtoeol()
 
             posy = self.scrsizey-footery
             # Display footer
             scr.addstr(posy, 0, " "*self.scrsizex, self.getstyle(self.style_footer))
 
             if level.exhausted:
                 flag = ""
             else:
                 flag = "+"
 
             endx = self.scrsizex-len(helpmsg)-1
             scr.addstr(posy, endx, helpmsg, self.getstyle(self.style_footer))
 
             posx = 0
             msg = " %d%s objects (%d marked): " % (len(level.items), flag, level.marked)
             posx += self.addstr(posy, posx, 0, endx, msg, self.style_footer)
             try:
                 item = level.items[level.cury].item
             except IndexError: # empty
                 pass
             else:
                 for (nostyle, text) in ipipe.xrepr(item, "footer"):
                     if not isinstance(nostyle, int):
                         posx += self.addstr(posy, posx, 0, endx, text, self.style_footer)
                         if posx >= endx:
                             break
 
                 attrstyle = [(astyle.style_default, "no attribute")]
                 attrname = level.displayattr[1]
                 if attrname is not ipipe.noitem and attrname is not None:
                     posx += self.addstr(posy, posx, 0, endx, " | ", self.style_footer)
                     posx += self.addstr(posy, posx, 0, endx, ipipe._attrname(attrname), self.style_footer)
                     posx += self.addstr(posy, posx, 0, endx, ": ", self.style_footer)
                     try:
                         attr = ipipe._getattr(item, attrname)
                     except (SystemExit, KeyboardInterrupt):
                         raise
                     except Exception, exc:
                         attr = exc
                     if attr is not ipipe.noitem:
                         attrstyle = ipipe.xrepr(attr, "footer")
                     for (nostyle, text) in attrstyle:
                         if not isinstance(nostyle, int):
                             posx += self.addstr(posy, posx, 0, endx, text, self.style_footer)
                             if posx >= endx:
                                 break
 
             try:
                 # Display input prompt
                 if self.mode in self.prompts:
                     scr.addstr(self.scrsizey-1, 0,
                                self.prompts[self.mode] + self.keyboardinput,
                                self.getstyle(astyle.style_default))
                 # Display report
                 else:
                     if self._report is not None:
                         if isinstance(self._report, Exception):
                             style = self.getstyle(astyle.style_error)
                             if self._report.__class__.__module__ == "exceptions":
                                 msg = "%s: %s" % \
                                       (self._report.__class__.__name__, self._report)
                             else:
                                 msg = "%s.%s: %s" % \
                                       (self._report.__class__.__module__,
                                        self._report.__class__.__name__, self._report)
                         else:
                             style = self.getstyle(self.style_report)
                             msg = self._report
                         scr.addstr(self.scrsizey-1, 0, msg[:self.scrsizex], style)
                         self._report = None
                     else:
                         scr.move(self.scrsizey-1, 0)
             except curses.error:
                 # Protect against error from writing to the last line
                 pass
             scr.clrtoeol()
 
             # Position cursor
             if self.mode in self.prompts:
                 scr.move(self.scrsizey-1, len(self.prompts[self.mode])+self.cursorpos)
             else:
                 scr.move(
                     1+self._headerlines+level.cury-level.datastarty,
                     level.numbersizex+3+level.curx-level.datastartx
                 )
             scr.refresh()
 
             # Check keyboard
             while True:
                 c = scr.getch()
                 if self.mode in self.prompts:
                     if c in (8, 127, curses.KEY_BACKSPACE):
                         if self.cursorpos:
                             self.keyboardinput = self.keyboardinput[:self.cursorpos-1] + self.keyboardinput[self.cursorpos:]
                             self.cursorpos -= 1
                             break
                         else:
                             curses.beep()
                     elif c == curses.KEY_LEFT:
                         if self.cursorpos:
                             self.cursorpos -= 1
                             break
                         else:
                             curses.beep()
                     elif c == curses.KEY_RIGHT:
                         if self.cursorpos < len(self.keyboardinput):
                             self.cursorpos += 1
                             break
                         else:
                             curses.beep()
                     elif c in (curses.KEY_UP, curses.KEY_DOWN): # cancel
                         self.mode = "default"
                         break
                     elif c == ord("\n"):
                         self.executekeyboardinput(self.mode)
                         break
                     elif c != -1:
                         try:
                             c = chr(c)
                         except ValueError:
                             curses.beep()
                         else:
                             if (self.mode == "goto" and not "0" <= c <= "9"):
                                 curses.beep()
                             else:
                                 self.keyboardinput = self.keyboardinput[:self.cursorpos] + c + self.keyboardinput[self.cursorpos:]
                                 self.cursorpos += 1
                                 break # Redisplay
                 else:
                     # if no key is pressed slow down and beep again
                     if c == -1:
                         self.stepx = 1.
                         self.stepy = 1.
                         self._dobeep = True
                     else:
                         # if a different key was pressed slow down and beep too
                         if c != lastc:
                             lastc = c
                             self.stepx = 1.
                             self.stepy = 1.
                             self._dobeep = True
                         cmdname = self.keymap.get(c, None)
                         if cmdname is None:
                             self.report(
                                 UnassignedKeyError("Unassigned key %s" %
                                                    self.keylabel(c)))
                         else:
                             cmdfunc = getattr(self, "cmd_%s" % cmdname, None)
                             if cmdfunc is None:
                                 self.report(
                                     UnknownCommandError("Unknown command %r" %
                                                         (cmdname,)))
                             elif cmdfunc():
                                 returnvalue = self.returnvalue
                                 self.returnvalue = None
                                 return returnvalue
                         self.stepx = self.nextstepx(self.stepx)
                         self.stepy = self.nextstepy(self.stepy)
                         curses.flushinp() # get rid of type ahead
                         break # Redisplay
         self.scr = None
 
     def display(self):
         return curses.wrapper(self._dodisplay)