"""Simple textbox editing widget with Emacs-like keybindings."""

import curses

import curses.ascii

def rectangle(win, uly, ulx, lry, lrx):

    """Draw a rectangle with corners at the provided upper-left

    and lower-right coordinates.

    """

    win.vline(uly+1, ulx, curses.ACS_VLINE, lry - uly - 1)

    win.hline(uly, ulx+1, curses.ACS_HLINE, lrx - ulx - 1)

    win.hline(lry, ulx+1, curses.ACS_HLINE, lrx - ulx - 1)

    win.vline(uly+1, lrx, curses.ACS_VLINE, lry - uly - 1)

    win.addch(uly, ulx, curses.ACS_ULCORNER)

    win.addch(uly, lrx, curses.ACS_URCORNER)

    win.addch(lry, lrx, curses.ACS_LRCORNER)

    win.addch(lry, ulx, curses.ACS_LLCORNER)

class Textbox:

    """Editing widget using the interior of a window object.

     Supports the following Emacs-like key bindings:

    Ctrl-A      Go to left edge of window.

    Ctrl-B      Cursor left, wrapping to previous line if appropriate.

    Ctrl-D      Delete character under cursor.

    Ctrl-E      Go to right edge (stripspaces off) or end of line (stripspaces on).

    Ctrl-F      Cursor right, wrapping to next line when appropriate.

    Ctrl-G      Terminate, returning the window contents.

    Ctrl-H      Delete character backward.

    Ctrl-J      Terminate if the window is 1 line, otherwise insert newline.

    Ctrl-K      If line is blank, delete it, otherwise clear to end of line.

    Ctrl-L      Refresh screen.

    Ctrl-N      Cursor down; move down one line.

    Ctrl-O      Insert a blank line at cursor location.

    Ctrl-P      Cursor up; move up one line.

    Move operations do nothing if the cursor is at an edge where the movement

    is not possible.  The following synonyms are supported where possible:

    KEY_LEFT = Ctrl-B, KEY_RIGHT = Ctrl-F, KEY_UP = Ctrl-P, KEY_DOWN = Ctrl-N

    KEY_BACKSPACE = Ctrl-h

    """

    def __init__(self, win, insert_mode=False):

        self.win = win

        self.insert_mode = insert_mode

        (self.maxy, self.maxx) = win.getmaxyx()

        self.maxy = self.maxy - 1

        self.maxx = self.maxx - 1

        self.stripspaces = 1

        self.lastcmd = None

        win.keypad(1)

    def _end_of_line(self, y):

        """Go to the location of the first blank on the given line,

        returning the index of the last non-blank character."""

        last = self.maxx

        while True:

            if curses.ascii.ascii(self.win.inch(y, last)) != curses.ascii.SP:

                last = min(self.maxx, last+1)

                break

            elif last == 0:

                break

            last = last - 1

        return last

    def _insert_printable_char(self, ch):

        (y, x) = self.win.getyx()

        if y < self.maxy or x < self.maxx:

            if self.insert_mode:

                oldch = self.win.inch()

            # The try-catch ignores the error we trigger from some curses

            # versions by trying to write into the lowest-rightmost spot

            # in the window.

            try:

                self.win.addch(ch)

            except curses.error:

                pass

            if self.insert_mode:

                (backy, backx) = self.win.getyx()

                if curses.ascii.isprint(oldch):

                    self._insert_printable_char(oldch)

                    self.win.move(backy, backx)

    def do_command(self, ch):

        "Process a single editing command."

        (y, x) = self.win.getyx()

        self.lastcmd = ch

        if curses.ascii.isprint(ch):

            if y < self.maxy or x < self.maxx:

                self._insert_printable_char(ch)

        elif ch == curses.ascii.SOH:                           # ^a

            self.win.move(y, 0)

        elif ch in (curses.ascii.STX,curses.KEY_LEFT, curses.ascii.BS,curses.KEY_BACKSPACE):

            if x > 0:

                self.win.move(y, x-1)

            elif y == 0:

                pass

            elif self.stripspaces:

                self.win.move(y-1, self._end_of_line(y-1))

            else:

                self.win.move(y-1, self.maxx)

            if ch in (curses.ascii.BS, curses.KEY_BACKSPACE):

                self.win.delch()

        elif ch == curses.ascii.EOT:                           # ^d

            self.win.delch()

        elif ch == curses.ascii.ENQ:                           # ^e

            if self.stripspaces:

                self.win.move(y, self._end_of_line(y))

            else:

                self.win.move(y, self.maxx)

        elif ch in (curses.ascii.ACK, curses.KEY_RIGHT):       # ^f

            if x < self.maxx:

                self.win.move(y, x+1)

            elif y == self.maxy:

                pass

            else:

                self.win.move(y+1, 0)

        elif ch == curses.ascii.BEL:                           # ^g

            return 0

        elif ch == curses.ascii.NL:                            # ^j

            if self.maxy == 0:

                return 0

            elif y < self.maxy:

                self.win.move(y+1, 0)

        elif ch == curses.ascii.VT:                            # ^k

            if x == 0 and self._end_of_line(y) == 0:

                self.win.deleteln()

            else:

                # first undo the effect of self._end_of_line

                self.win.move(y, x)

                self.win.clrtoeol()

        elif ch == curses.ascii.FF:                            # ^l

            self.win.refresh()

        elif ch in (curses.ascii.SO, curses.KEY_DOWN):         # ^n

            if y < self.maxy:

                self.win.move(y+1, x)

                if x > self._end_of_line(y+1):

                    self.win.move(y+1, self._end_of_line(y+1))

        elif ch == curses.ascii.SI:                            # ^o

            self.win.insertln()

        elif ch in (curses.ascii.DLE, curses.KEY_UP):          # ^p

            if y > 0:

                self.win.move(y-1, x)

                if x > self._end_of_line(y-1):

                    self.win.move(y-1, self._end_of_line(y-1))

        return 1

    def gather(self):

        "Collect and return the contents of the window."

        result = ""

        for y in range(self.maxy+1):

            self.win.move(y, 0)

            stop = self._end_of_line(y)

            if stop == 0 and self.stripspaces:

                continue

            for x in range(self.maxx+1):

                if self.stripspaces and x > stop:

                    break

                result = result + chr(curses.ascii.ascii(self.win.inch(y, x)))

            if self.maxy > 0:

                result = result + "\n"

        return result

    def edit(self, validate=None):

        "Edit in the widget window and collect the results."

        while 1:

            ch = self.win.getch()

            if validate:

                ch = validate(ch)

            if not ch:

                continue

            if not self.do_command(ch):

                break

            self.win.refresh()

        return self.gather()

if __name__ == '__main__':

    def test_editbox(stdscr):

        ncols, nlines = 9, 4

        uly, ulx = 15, 20

        stdscr.addstr(uly-2, ulx, "Use Ctrl-G to end editing.")

        win = curses.newwin(nlines, ncols, uly, ulx)

        rectangle(stdscr, uly-1, ulx-1, uly + nlines, ulx + ncols)

        stdscr.refresh()

        return Textbox(win).edit()

    str = curses.wrapper(test_editbox)

    print 'Contents of text box:', repr(str)