// Move cursor to column zero at the start of the line.
	t.move(t.cursorY, 0, t.cursorX, 0)
	t.cursorX, t.cursorY = 0, 0
	t.clearLineToRight()
	for t.cursorY < numPrevLines {
		// Move down a line
		t.move(0, 1, 0, 0)
		t.cursorY++
		t.clearLineToRight()
	}
	// Move back to beginning.
	t.move(t.cursorY, 0, 0, 0)
	t.cursorX, t.cursorY = 0, 0

	t.queue(t.prompt)

    }

    public static Cursor at(int row, int col) {
        Cursor result = new Cursor();
        result.row = row;
        result.col = col;
        return result;
    }

    public static Cursor newBottomLeft() {
        Cursor result = new Cursor();
        result.bottomLeft();
        return result;
    }

    public static Cursor from(Cursor position) {
        Cursor result = new Cursor();

        writeCursor.col = 0;

        // On any line except the bottom most one, a new line simply move the cursor to the next row.
        // Note: the next row has a lower index.
        if (writeCursor.row > 0) {
            writeCursor.row--;
        } else {
            writeCursor.row = 0;
        }
        cursor.copyFrom(writeCursor);
    }

    private void positionCursorAt(Cursor position, Ansi ansi) {

    // 2 lines: 1 for BuildStatus and 1 for Cursor parking space
    private final List<DefaultRedrawableLabel> entries = new ArrayList<DefaultRedrawableLabel>(2);
    private final DefaultRedrawableLabel progressBarLabel;

    private final List<StyledLabel> buildProgressLabels = new ArrayList<StyledLabel>();
    private final DefaultRedrawableLabel parkingLabel;
    private final Cursor statusAreaPos = new Cursor();
    private boolean isVisible;

    }

    def "doesn't move the write cursor when progress area was never visible"() {
        given:
        progressArea.visible = false
        writeCursor.row = 4  // Not on origin row

        when:
        redraw()

        then:
        writeCursor.row == 4
        0 * ansi._

    }

    def "doesn't move the write cursor when progress area turn invisible while out of bound"() {

        this.spans = spans;
    }

    public Cursor getWritePosition() {
        return writePos;
    }

    public void setVisible(boolean isVisible) {
        this.isVisible = isVisible;
    }

    public boolean isOverlappingWith(Cursor cursor) {
        return cursor.row == writePos.row && writePos.col > cursor.col;
    }

    @Override
    public void redraw(AnsiContext ansi) {

     */
    AnsiContext eraseAll();

    /**
     * @return the current context moved to the specified position.
     */
    AnsiContext cursorAt(Cursor cursor);

    /**
     * @return a new context at the specified write position.
     */
    AnsiContext writeAt(Cursor writePos);

     *
     * @param y the number of lines to move up
     * @return this Ansi instance
     */
    public Ansi cursorUp(final int y) {
        return y > 0 ? appendEscapeSequence('A', y) : y < 0 ? cursorDown(-y) : this;
    }

    /**
     * Moves the cursor down. If the parameter y is negative it moves the cursor up.
     *
     * @param y the number of lines to move down
     * @return this Ansi instance

            }
        }

        @Override
        public void beforeLineWrap(AnsiContext ansi, Cursor writeCursor) {
            if (writeCursor.row == 0) {
                buildStatusArea.newLineAdjustment();
            }
        }

        @Override
        public void afterLineWrap(AnsiContext ansi, Cursor writeCursor) {
            if (buildStatusArea.isOverlappingWith(writeCursor)) {

	if err != nil {
		return false, err
	}
	// Complete the timestamp from the cursor's last timestamp.
	b.ev.time = freq.mul(tsdiff) + b.lastTs

	// Move the cursor's timestamp forward.
	b.lastTs = b.ev.time

	// Move the cursor forward.
	b.dataOff += n
	return true, nil
}

func (b *batchCursor) compare(a *batchCursor) int {