Maximum CD 2010 November/maximum-cd-2010-11.iso/DiscContents/calibre-0.7.13.msi/file_1727

Python Compiled Bytecode | 2010-08-06 | 47.0 KB | 1,629 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.6)

import curses
import fcntl
import signal
import struct
import tty
import textwrap
import inspect
from IPython import ipapi
import astyle
import ipipe

try:
    set
except NameError:
    import sets
    set = sets.Set


try:
    sorted
except NameError:
    from ipipe import sorted


class UnassignedKeyError(Exception):
    pass


class UnknownCommandError(Exception):
    pass


class CommandError(Exception):
    pass


class Keymap(dict):

    def __init__(self):
        self._keymap = { }


    def __setitem__(self, key, command):
        if isinstance(key, str):
            for c in key:
                dict.__setitem__(self, ord(c), command)

        else:
            dict.__setitem__(self, key, command)


    def __getitem__(self, key):
        if isinstance(key, str):
            key = ord(key)

        return dict.__getitem__(self, key)


    def __detitem__(self, key):
        if isinstance(key, str):
            key = ord(key)

        dict.__detitem__(self, key)


    def register(self, command, *keys):
        for key in keys:
            self[key] = command



    def get(self, key, default = None):
        if isinstance(key, str):
            key = ord(key)

        return dict.get(self, key, default)


    def findkey(self, command, default = ipipe.noitem):
        for key, commandcandidate in self.iteritems():
            if commandcandidate == command:
                return key

        if default is ipipe.noitem:
            raise KeyError(command)
        default is ipipe.noitem
        return default



class _BrowserCachedItem(object):
    __slots__ = ('item', 'marked')

    def __init__(self, item):
        self.item = item
        self.marked = False



class _BrowserHelp(object):
    style_header = astyle.Style.fromstr('yellow:black:bold')

    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 __iter__(self):
        allkeys = { }
        for key, cmd in self.browser.keymap.iteritems():
            allkeys.setdefault(cmd, []).append(key)

        fields = ('key', 'description')
        commands = []
        for name in dir(self.browser):
            if name.startswith('cmd_'):
                command = getattr(self.browser, name)
                commands.append((inspect.getsourcelines(command)[-1], name[4:], command))
                continue

        commands.sort()
        commands = [ (c[1], c[2]) for c in commands ]
        for name, command in enumerate(commands):
            description = command.__doc__
            keys = allkeys.get(name, [])
            yield ipipe.Fields(fields, key = '', description = astyle.Text((self.style_header, name)))
            [] if description is None else []
            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):

    def __init__(self, browser, input, mainsizey, *attrs):
        self.browser = browser
        self.input = input
        self.header = _[1]
        self.iterator = ipipe.xiter(input)
        self.exhausted = False
        self.attrs = attrs
        self.items = ipipe.deque()
        self.marked = 0
        self.cury = 0
        self.curx = 0
        self.datastartx = 0
        self.datastarty = 0
        self.mainsizey = mainsizey
        self.mainsizex = 0
        self.numbersizex = 0
        self.displayattrs = []
        self.displayattr = (None, ipipe.noitem)
        self.colwidths = { }
        self.hiddenattrs = set()
        self.moveto(0, 0, refresh = True)


    def fetch(self, count):
        have = len(self.items)
        while not (self.exhausted) and have < count:

            try:
                item = self.iterator.next()
            except StopIteration:
                self.exhausted = True
                break
                continue
                except (KeyboardInterrupt, SystemExit):
                    raise
                    continue
                    except Exception:
                        exc = None
                        have += 1
                        self.items.append(_BrowserCachedItem(exc))
                        self.exhausted = True
                        break
                        continue
                    else:
                        have += 1
                        self.items.append(_BrowserCachedItem(item))
                    None<EXCEPTION MATCH>Exception
                return None



    def calcdisplayattrs(self):
        attrs = set()
        self.displayattrs = []
        if self.attrs:
            for attr in self.attrs:
                attr = ipipe.upgradexattr(attr)
                if attr not in attrs and attr not in self.hiddenattrs:
                    self.displayattrs.append(attr)
                    attrs.add(attr)
                    continue

        else:
            endy = min(self.datastarty + self.mainsizey, len(self.items))
            for i in xrange(self.datastarty, endy):
                for attr in ipipe.xattrs(self.items[i].item, 'default'):
                    if attr not in attrs and attr not in self.hiddenattrs:
                        self.displayattrs.append(attr)
                        attrs.add(attr)
                        continue




    def getrow(self, i):
        row = { }
        item = self.items[i].item
        for attr in self.displayattrs:

            try:
                value = attr.value(item)
            except (KeyboardInterrupt, SystemExit):
                raise
            except Exception:
                exc = None
                value = exc

            if value is not ipipe.noitem:
                row[attr] = ipipe.xformat(value, 'cell', self.browser.maxattrlength)
                continue

        return row


    def calcwidths(self):
        self.colwidths = { }
        for row in self.displayrows:
            for attr in self.displayattrs:

                try:
                    length = row[attr][1]
                except KeyError:
                    length = 0

                if attr not in self.colwidths:
                    self.colwidths[attr] = len(attr.name())

                newwidth = max(self.colwidths[attr], length)
                self.colwidths[attr] = newwidth


        self.numbersizex = len(str(self.datastarty + self.mainsizey - 1))
        self.mainsizex = self.browser.scrsizex - self.numbersizex - 3
        self.datasizex = sum(self.colwidths.itervalues()) + len(self.colwidths)


    def calcdisplayattr(self):
        pos = 0
        for i, attr in enumerate(self.displayattrs):
            if pos + self.colwidths[attr] >= self.curx:
                self.displayattr = (i, attr)
                break

            pos += self.colwidths[attr] + 1
        else:
            self.displayattr = (None, ipipe.noitem)


    def moveto(self, x, y, refresh = False):
        olddatastarty = self.datastarty
        oldx = self.curx
        oldy = self.cury
        x = int(x + 0.5)
        y = int(y + 0.5)
        newx = x
        newy = y
        scrollbordery = min(self.browser.scrollbordery, self.mainsizey // 2)
        scrollborderx = min(self.browser.scrollborderx, self.mainsizex // 2)
        if y < 0:
            y = 0

        self.fetch(max(y + scrollbordery + 1, self.mainsizey))
        if y >= len(self.items):
            y = max(0, len(self.items) - 1)

        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:
            self.calcdisplayattrs()
            endy = min(self.datastarty + self.mainsizey, len(self.items))
            self.displayrows = map(self.getrow, xrange(self.datastarty, endy))
            self.calcwidths()
        elif self.datastarty != olddatastarty:
            olddisplayattrs = self.displayattrs
            self.calcdisplayattrs()
            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:
                del self.displayrows[self.datastarty - olddatastarty:]
                for i in xrange(min(olddatastarty, self.datastarty + self.mainsizey) - 1, self.datastarty - 1, -1):

                    try:
                        row = self.getrow(i)
                    except IndexError:
                        break

                    self.displayrows.insert(0, row)

            else:
                del self.displayrows[:self.datastarty - olddatastarty]
                for i in xrange(max(olddatastarty + self.mainsizey, self.datastarty), self.datastarty + self.mainsizey):

                    try:
                        row = self.getrow(i)
                    except IndexError:
                        break

                    self.displayrows.append(row)

            self.calcwidths()

        if x < 0:
            x = 0
        elif x >= self.datasizex:
            x = max(0, self.datasizex - 1)

        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:
            if x != newx or y != newy:
                self.browser.beep()
            else:
                self.curx = x
                self.cury = y
                self.calcdisplayattr()


    def sort(self, key, reverse = False):
        curitem = self.items[self.cury]

        def realkey(item):
            return key(item.item)

        self.items = ipipe.deque(sorted(self.items, key = realkey, reverse = reverse))
        cury = self.cury
        for i, item in enumerate(self.items):
            if item is curitem:
                cury = i
                break
                continue
            (None,)

        self.moveto(self.curx, cury, refresh = True)


    def refresh(self):
        self.iterator = ipipe.xiter(self.input)
        self.items.clear()
        self.exhausted = False
        self.datastartx = self.datastarty = 0
        self.moveto(0, 0, refresh = True)


    def refreshfind(self):

        try:
            oldobject = self.items[self.cury].item
        except IndexError:
            oldobject = ipipe.noitem

        self.iterator = ipipe.xiter(self.input)
        self.items.clear()
        self.exhausted = False
        while True:
            self.fetch(len(self.items) + 1)
            if self.exhausted:
                curses.beep()
                self.datastartx = self.datastarty = 0
                self.moveto(self.curx, 0, refresh = True)
                break

            if self.items[-1].item == oldobject:
                self.datastartx = self.datastarty = 0
                self.moveto(self.curx, len(self.items) - 1, refresh = True)
                break
                continue



class _CommandInput(object):
    keymap = Keymap()
    keymap.register('left', curses.KEY_LEFT)
    keymap.register('right', curses.KEY_RIGHT)
    keymap.register('home', curses.KEY_HOME, '\x01')
    keymap.register('end', curses.KEY_END, '\x05')
    keymap.register('backspace', curses.KEY_BACKSPACE, '\x08\x7f')
    keymap.register('delete', curses.KEY_DC)
    keymap.register('delend', 11)
    keymap.register('execute', '\r\n')
    keymap.register('up', curses.KEY_UP)
    keymap.register('down', curses.KEY_DOWN)
    keymap.register('incsearchup', curses.KEY_PPAGE)
    keymap.register('incsearchdown', curses.KEY_NPAGE)
    (keymap.register('exit', '\x18'),)

    def __init__(self, prompt):
        self.prompt = prompt
        self.history = []
        self.maxhistory = 100
        self.input = ''
        self.curx = 0
        self.cury = -1


    def start(self):
        self.input = ''
        self.curx = 0
        self.cury = -1


    def handlekey(self, browser, key):
        cmdname = self.keymap.get(key, None)
        if cmdname is not None:
            cmdfunc = getattr(self, 'cmd_%s' % cmdname, None)
            if cmdfunc is not None:
                return cmdfunc(browser)
            curses.beep()
        elif key != -1:

            try:
                char = chr(key)
            except ValueError:
                curses.beep()

            return self.handlechar(browser, char)



    def handlechar(self, browser, char):
        self.input = self.input[:self.curx] + char + self.input[self.curx:]
        self.curx += 1
        return True


    def dohistory(self):
        self.history.insert(0, self.input)
        del self.history[:-(self.maxhistory)]


    def cmd_backspace(self, browser):
        if self.curx:
            self.input = self.input[:self.curx - 1] + self.input[self.curx:]
            self.curx -= 1
            return True
        curses.beep()


    def cmd_delete(self, browser):
        if self.curx < len(self.input):
            self.input = self.input[:self.curx] + self.input[self.curx + 1:]
            return True
        curses.beep()


    def cmd_delend(self, browser):
        if self.curx < len(self.input):
            self.input = self.input[:self.curx]
            return True


    def cmd_left(self, browser):
        if self.curx:
            self.curx -= 1
            return True
        curses.beep()


    def cmd_right(self, browser):
        if self.curx < len(self.input):
            self.curx += 1
            return True
        curses.beep()


    def cmd_home(self, browser):
        if self.curx:
            self.curx = 0
            return True
        curses.beep()


    def cmd_end(self, browser):
        if self.curx < len(self.input):
            self.curx = len(self.input)
            return True
        curses.beep()


    def cmd_up(self, browser):
        if self.cury < len(self.history) - 1:
            self.cury += 1
            self.input = self.history[self.cury]
            self.curx = len(self.input)
            return True
        curses.beep()


    def cmd_down(self, browser):
        if self.cury >= 0:
            self.cury -= 1
            if self.cury >= 0:
                self.input = self.history[self.cury]
            else:
                self.input = ''
            self.curx = len(self.input)
            return True
        curses.beep()


    def cmd_incsearchup(self, browser):
        prefix = self.input[:self.curx]
        cury = self.cury
        while True:
            cury += 1
            if cury >= len(self.history):
                break

            if self.history[cury].startswith(prefix):
                self.input = self.history[cury]
                self.cury = cury
                return True
            continue
            self.history[cury].startswith(prefix)
        curses.beep()


    def cmd_incsearchdown(self, browser):
        prefix = self.input[:self.curx]
        cury = self.cury
        while True:
            cury -= 1
            if cury <= 0:
                break

            if self.history[cury].startswith(prefix):
                self.input = self.history[self.cury]
                self.cury = cury
                return True
            continue
            self.history[cury].startswith(prefix)
        curses.beep()


    def cmd_exit(self, browser):
        browser.mode = 'default'
        return True


    def cmd_execute(self, browser):
        raise NotImplementedError



class _CommandGoto(_CommandInput):

    def __init__(self):
        _CommandInput.__init__(self, 'goto object #')


    def handlechar(self, browser, char):
        if char <= char:
            pass
        elif not char <= '9':
            curses.beep()
        else:
            return _CommandInput.handlechar(self, browser, char)
        return char <= '9'


    def cmd_execute(self, browser):
        level = browser.levels[-1]
        if self.input:
            self.dohistory()
            level.moveto(level.curx, int(self.input))

        browser.mode = 'default'
        return True



class _CommandFind(_CommandInput):

    def __init__(self):
        _CommandInput.__init__(self, 'find expression')


    def cmd_execute(self, browser):
        level = browser.levels[-1]
        if self.input:
            self.dohistory()
            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:
                    globals = ipipe.getglobals(None)
                    if eval(self.input, globals, ipipe.AttrNamespace(item)):
                        break
                continue
                except (KeyboardInterrupt, SystemExit):
                    raise
                    continue
                    except Exception:
                        exc = None
                        browser.report(exc)
                        curses.beep()
                        break
                        continue

                    None<EXCEPTION MATCH>Exception
                except:
                    None<EXCEPTION MATCH>(KeyboardInterrupt, SystemExit)
                    browser.mode = 'default'
                    return True




class _CommandFindBackwards(_CommandInput):

    def __init__(self):
        _CommandInput.__init__(self, 'find backwards expression')


    def cmd_execute(self, browser):
        level = browser.levels[-1]
        if self.input:
            self.dohistory()
            while level.cury:
                level.moveto(level.curx, level.cury - 1)
                item = level.items[level.cury].item

                try:
                    globals = ipipe.getglobals(None)
                    if eval(self.input, globals, ipipe.AttrNamespace(item)):
                        break
                continue
                except (KeyboardInterrupt, SystemExit):
                    raise
                    continue
                    except Exception:
                        exc = None
                        browser.report(exc)
                        curses.beep()
                        break
                        continue

                    None<EXCEPTION MATCH>Exception
                except:
                    None<EXCEPTION MATCH>(KeyboardInterrupt, SystemExit)
                    browser.mode = 'default'
                    return True




class ibrowse(ipipe.Display):
    pageoverlapx = 1
    pageoverlapy = 1
    scrollborderx = 10
    scrollbordery = 5
    acceleratex = 1.05
    acceleratey = 1.05
    maxspeedx = 0.5
    maxspeedy = 0.5
    maxheaders = 5
    maxattrlength = 200
    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')
    headersepchar = '|'
    datapadchar = '.'
    datasepchar = '|'
    nodatachar = '-'
    prompts = {
        'goto': _CommandGoto(),
        'find': _CommandFind(),
        'findbackwards': _CommandFindBackwards() }
    keymap = Keymap()
    keymap.register('quit', 'q')
    keymap.register('up', curses.KEY_UP)
    keymap.register('down', curses.KEY_DOWN)
    keymap.register('pageup', curses.KEY_PPAGE)
    keymap.register('pagedown', curses.KEY_NPAGE)
    keymap.register('left', curses.KEY_LEFT)
    keymap.register('right', curses.KEY_RIGHT)
    keymap.register('home', curses.KEY_HOME, '\x01')
    keymap.register('end', curses.KEY_END, '\x05')
    keymap.register('prevattr', '<\x1b')
    keymap.register('nextattr', '>\t')
    keymap.register('pick', 'p')
    keymap.register('pickattr', 'P')
    keymap.register('pickallattrs', 'C')
    keymap.register('pickmarked', 'm')
    keymap.register('pickmarkedattr', 'M')
    keymap.register('pickinput', 'i')
    keymap.register('pickinputattr', 'I')
    keymap.register('hideattr', 'h')
    keymap.register('unhideattrs', 'H')
    keymap.register('help', '?')
    keymap.register('enter', '\r\n')
    keymap.register('enterattr', 'E')
    keymap.register('leave', curses.KEY_BACKSPACE, 'x\x08\x7f')
    keymap.register('detail', 'd')
    keymap.register('detailattr', 'D')
    keymap.register('tooglemark', ' ')
    keymap.register('markrange', '%')
    keymap.register('sortattrasc', 'v')
    keymap.register('sortattrdesc', 'V')
    keymap.register('goto', 'g')
    keymap.register('find', 'f')
    keymap.register('findbackwards', 'b')
    keymap.register('refresh', 'r')
    keymap.register('refreshfind', 'R')

    def __init__(self, input = None, *attrs):
        ipipe.Display.__init__(self, input)
        self.attrs = attrs
        self.levels = []
        self.stepx = 1
        self.stepy = 1
        self._dobeep = True
        self._styles = { }
        self._colors = { }
        self._maxcolor = 1
        self._headerlines = 1
        self._firstheaderline = 0
        self.scr = None
        self._report = None
        self.returnvalue = None
        self.mode = 'default'
        self.resized = False


    def nextstepx(self, step):
        return max(1, min(step * self.acceleratex, self.maxspeedx * self.levels[-1].mainsizex))


    def nextstepy(self, step):
        return max(1, min(step * self.acceleratey, self.maxspeedy * self.levels[-1].mainsizey))


    def getstyle(self, style):

        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]
                    continue


            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
            except:
                self

            c = color | attrs
            self._styles[(style.fg, style.bg, style.attrs)] = c
            return c
            self



    def addstr(self, y, x, begx, endx, text, style):
        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):
        if levels is None:
            levels = len(self.levels)

        self._headerlines = min(self.maxheaders, levels)
        self._firstheaderline = levels - self._headerlines


    def getstylehere(self, style):
        return astyle.Style(style.fg, astyle.COLOR_BLUE, style.attrs | astyle.A_BOLD)


    def report(self, msg):
        self._report = msg


    def enter(self, item, *attrs):
        if self.levels and item is self.levels[-1].input:
            curses.beep()
            self.report(CommandError('Recursion on input object'))
        else:
            oldlevels = len(self.levels)
            self._calcheaderlines(oldlevels + 1)

            try:
                level = _BrowserLevel(self, item, self.scrsizey - 1 - self._headerlines - 2, *attrs)
            except (KeyboardInterrupt, SystemExit):
                raise
            except Exception:
                exc = None
                if not self.levels:
                    raise
                self.levels
                self._calcheaderlines(oldlevels)
                curses.beep()
                self.report(exc)

            self.levels.append(level)


    def startkeyboardinput(self, mode):
        self.mode = mode
        self.prompts[mode].start()


    def keylabel(self, keycode):
        if keycode <= 255:
            specialsnames = {
                ord('\n'): 'RETURN',
                ord(' '): 'SPACE',
                ord('\t'): 'TAB',
                ord('\x7f'): 'DELETE',
                ord('\x08'): 'BACKSPACE' }
            if keycode in specialsnames:
                return specialsnames[keycode]
            if keycode < keycode:
                pass
            elif keycode < 32:
                return 'CTRL-%s' % chr(keycode + 64)
            keycode in specialsnames
            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()
            self._dobeep = False



    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]
        attr = level.displayattr[1]
        if attr is ipipe.noitem:
            curses.beep()
            self.report(CommandError('no column under cursor'))
            return None
        value = attr.value(level.items[level.cury].item)
        if value is ipipe.noitem:
            curses.beep()
            self.report(AttributeError(attr.name()))
        else:
            self.returnvalue = value
            return True
        return attr is ipipe.noitem


    def cmd_pickallattrs(self):
        level = self.levels[-1]
        attr = level.displayattr[1]
        if attr is ipipe.noitem:
            curses.beep()
            self.report(CommandError('no column under cursor'))
            return None
        result = []
        for cache in level.items:
            value = attr.value(cache.item)
            if value is not ipipe.noitem:
                result.append(value)
                continue
            attr is ipipe.noitem

        self.returnvalue = result
        return True


    def cmd_pickmarked(self):
        level = self.levels[-1]
        self.returnvalue = _[1]
        return True


    def cmd_pickmarkedattr(self):
        level = self.levels[-1]
        attr = level.displayattr[1]
        if attr is ipipe.noitem:
            curses.beep()
            self.report(CommandError('no column under cursor'))
            return None
        result = []
        for cache in level.items:
            if cache.marked:
                value = attr.value(cache.item)
                if value is not ipipe.noitem:
                    result.append(value)

            value is not ipipe.noitem

        self.returnvalue = result
        return True


    def cmd_pickinput(self):
        level = self.levels[-1]
        value = level.items[level.cury].item
        self.returnvalue = None
        api = ipapi.get()
        api.set_next_input(str(value))
        return True


    def cmd_pickinputattr(self):
        level = self.levels[-1]
        attr = level.displayattr[1]
        if attr is ipipe.noitem:
            curses.beep()
            self.report(CommandError('no column under cursor'))
            return None
        value = attr.value(level.items[level.cury].item)
        if value is ipipe.noitem:
            curses.beep()
            self.report(AttributeError(attr.name()))

        self.returnvalue = None
        api = ipapi.get()
        api.set_next_input(str(value))
        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
                    continue


        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
                    continue
                level



    def cmd_enter(self):
        level = self.levels[-1]

        try:
            item = level.items[level.cury].item
        except IndexError:
            self.report(CommandError('No object'))
            curses.beep()

        self.report('entering object...')
        self.enter(item)


    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_enterattr(self):
        level = self.levels[-1]
        attr = level.displayattr[1]
        if attr is ipipe.noitem:
            curses.beep()
            self.report(CommandError('no column under cursor'))
            return None

        try:
            item = level.items[level.cury].item
        except IndexError:
            attr is ipipe.noitem
            attr is ipipe.noitem
            self.report(CommandError('No object'))
            curses.beep()
        except:
            attr is ipipe.noitem

        value = attr.value(item)
        name = attr.name()
        if value is ipipe.noitem:
            self.report(AttributeError(name))
        else:
            self.report('entering object attribute %s...' % name)
            self.enter(value)


    def cmd_detail(self):
        level = self.levels[-1]

        try:
            item = level.items[level.cury].item
        except IndexError:
            self.report(CommandError('No object'))
            curses.beep()

        self.report('entering detail view for object...')
        attrs = [ ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, 'detail') ]
        self.enter(attrs)


    def cmd_detailattr(self):
        level = self.levels[-1]
        attr = level.displayattr[1]
        if attr is ipipe.noitem:
            curses.beep()
            self.report(CommandError('no attribute'))
            return None

        try:
            item = level.items[level.cury].item
        except IndexError:
            attr is ipipe.noitem
            attr is ipipe.noitem
            self.report(CommandError('No object'))
            curses.beep()
        except:
            attr is ipipe.noitem


        try:
            item = attr.value(item)
        except (KeyboardInterrupt, SystemExit):
            attr is ipipe.noitem
            attr is ipipe.noitem
            raise
        except Exception:
            exc = None
            self.report(exc)
        except:
            attr is ipipe.noitem

        self.report('entering detail view for attribute %s...' % attr.name())
        attrs = [ ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, 'detail') ]
        self.enter(attrs)


    def cmd_tooglemark(self):
        level = self.levels[-1]
        self.report('toggle mark')

        try:
            item = level.items[level.cury]
        except IndexError:
            pass



    def cmd_sortattrasc(self):
        level = self.levels[-1]
        attr = level.displayattr[1]
        if attr is ipipe.noitem:
            curses.beep()
            self.report(CommandError('no column under cursor'))
            return None
        self.report('sort by %s (ascending)' % attr.name())

        def key(item):

            try:
                return attr.value(item)
            except (KeyboardInterrupt, SystemExit):
                raise
            except Exception:
                return None


        level.sort(key)


    def cmd_sortattrdesc(self):
        level = self.levels[-1]
        attr = level.displayattr[1]
        if attr is ipipe.noitem:
            curses.beep()
            self.report(CommandError('no column under cursor'))
            return None
        self.report('sort by %s (descending)' % attr.name())

        def key(item):

            try:
                return attr.value(item)
            except (KeyboardInterrupt, SystemExit):
                raise
            except Exception:
                return None


        level.sort(key, reverse = True)


    def cmd_hideattr(self):
        level = self.levels[-1]
        if level.displayattr[0] is None:
            self.beep()
        else:
            self.report('hideattr')
            level.hiddenattrs.add(level.displayattr[1])
            level.moveto(level.curx, level.cury, refresh = True)


    def cmd_unhideattrs(self):
        level = self.levels[-1]
        self.report('unhideattrs')
        level.hiddenattrs.clear()
        level.moveto(level.curx, level.cury, refresh = True)


    def cmd_goto(self):
        self.startkeyboardinput('goto')


    def cmd_find(self):
        self.startkeyboardinput('find')


    def cmd_findbackwards(self):
        self.startkeyboardinput('findbackwards')


    def cmd_refresh(self):
        level = self.levels[-1]
        self.report('refresh')
        level.refresh()


    def cmd_refreshfind(self):
        level = self.levels[-1]
        self.report('refreshfind')
        level.refreshfind()


    def cmd_help(self):
        for level in self.levels:
            if isinstance(level.input, _BrowserHelp):
                curses.beep()
                self.report(CommandError('help already active'))
                return None

        self.enter(_BrowserHelp(self))


    def cmd_quit(self):
        self.returnvalue = None
        return True


    def sigwinchhandler(self, signal, frame):
        self.resized = True


    def _dodisplay(self, scr):
        self.scr = scr
        curses.halfdelay(1)
        footery = 2
        keys = []
        for cmd in ('quit', 'help'):
            key = self.keymap.findkey(cmd, None)
            if key is not None:
                keys.append('%s=%s' % (self.keylabel(key), cmd))
                continue

        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 = []
        self.enter(self.input, *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
            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:
                    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
                        continue

                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:
                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 attr in level.displayattrs:
                    attrname = attr.name()
                    cwidth = level.colwidths[attr]
                    header = attrname.ljust(cwidth)
                    if attr is 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
                        continue

                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
                            if i == level.cury:
                                style = self.getstylehere(style)

                        except:
                            i == level.cury

                        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)
                        elif 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
                                continue

                        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)


                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
            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:
                pass

            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

                posx >= endx

            attrstyle = [
                (astyle.style_default, 'no attribute')]
            attr = level.displayattr[1]
            if attr is not ipipe.noitem and not isinstance(attr, ipipe.SelfDescriptor):
                posx += self.addstr(posy, posx, 0, endx, ' | ', self.style_footer)
                posx += self.addstr(posy, posx, 0, endx, attr.name(), self.style_footer)
                posx += self.addstr(posy, posx, 0, endx, ': ', self.style_footer)

                try:
                    value = attr.value(item)
                except (SystemExit, KeyboardInterrupt):
                    raise
                except Exception:
                    exc = None
                    value = exc

                if value is not ipipe.noitem:
                    attrstyle = ipipe.xrepr(value, '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

                    posx >= endx



            try:
                if self.mode in self.prompts:
                    history = self.prompts[self.mode]
                    posx = 0
                    posy = self.scrsizey - 1
                    posx += self.addstr(posy, posx, 0, endx, history.prompt, astyle.style_default)
                    posx += self.addstr(posy, posx, 0, endx, ' [', astyle.style_default)
                    if history.cury == -1:
                        text = 'new'
                    else:
                        text = str(history.cury + 1)
                    posx += self.addstr(posy, posx, 0, endx, text, astyle.style_type_number)
                    if history.history:
                        posx += self.addstr(posy, posx, 0, endx, '/', astyle.style_default)
                        posx += self.addstr(posy, posx, 0, endx, str(len(history.history)), astyle.style_type_number)

                    posx += self.addstr(posy, posx, 0, endx, ']: ', astyle.style_default)
                    inputstartx = posx
                    posx += self.addstr(posy, posx, 0, endx, history.input, astyle.style_default)
                elif 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:
                pass

            scr.clrtoeol()
            if self.mode in self.prompts:
                history = self.prompts[self.mode]
                scr.move(self.scrsizey - 1, inputstartx + history.curx)
            else:
                scr.move(1 + self._headerlines + level.cury - level.datastarty, level.numbersizex + 3 + level.curx - level.datastartx)
            scr.refresh()
            while True:
                c = scr.getch()
                if self.resized:
                    size = fcntl.ioctl(0, tty.TIOCGWINSZ, '12345678')
                    size = struct.unpack('4H', size)
                    oldsize = scr.getmaxyx()
                    scr.erase()
                    curses.resize_term(size[0], size[1])
                    newsize = scr.getmaxyx()
                    scr.erase()
                    for l in self.levels:
                        l.mainsizey += newsize[0] - oldsize[0]
                        l.moveto(l.curx, l.cury, refresh = True)

                    scr.refresh()
                    self.resized = False
                    break

                if self.mode in self.prompts:
                    if self.prompts[self.mode].handlekey(self, c):
                        break

                self.prompts[self.mode].handlekey(self, c)
                if c == -1:
                    self.stepx = 1
                    self.stepy = 1
                    self._dobeep = True
                    continue
                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()
                break
        self.scr = None


    def display(self):
        if hasattr(curses, 'resize_term'):
            oldhandler = signal.signal(signal.SIGWINCH, self.sigwinchhandler)

            try:
                return curses.wrapper(self._dodisplay)
            finally:
                signal.signal(signal.SIGWINCH, oldhandler)

        else:
            return curses.wrapper(self._dodisplay)
        return hasattr(curses, 'resize_term')