terminalwin.java

一个非常好的ssh客户端实现

				     visTop + windowTop, (windowHeight - n));
		    System.arraycopy(autowraps, visTop + windowTop + n, autowraps,
				     visTop + windowTop, (windowHeight - n));
		}
		for(i = j; i < windowBottom; i++) {
		    screen[visTop + i]     = new char[cols];
		    attributes[visTop + i] = new int[cols];
		    autowraps[visTop + i]  = false;
		}
	    }
	}

	updateDirtyArea(windowTop, windowLeft, windowBottom, windowRight);
    }

    public synchronized void scrollDown(int n) {
	int windowHeight = windowBottom - windowTop;
	int i, j = windowBottom;

	if(DEBUG) System.out.println("scrollDown: " + n);

	if(complexScroll) {
	    // !!! TODO: This is untested...
	    if(n < windowHeight) {
		j = windowTop + n;
		for(i = windowBottom - 1; i >= j; i--) {
		    System.arraycopy(screen[visTop + i - n], windowLeft, screen[visTop + i], windowLeft, windowRight - windowLeft);
		    System.arraycopy(attributes[visTop + i - n], windowLeft,
				     attributes[visTop + i], windowLeft, (windowRight - windowLeft));
		}
	    }
	    for(i = windowTop; i < j; i++) {
		System.arraycopy(spacerow, 0, screen[visTop + i], windowLeft, windowRight - windowLeft);
		System.arraycopy(zerorow, 0, attributes[visTop + i], windowLeft, (windowRight - windowLeft));
	    }
	} else {
	    if(n < windowHeight) {
		j = windowTop + n;
		System.arraycopy(screen, visTop + windowTop, screen, visTop + windowTop + n,
				 windowHeight - n);
		System.arraycopy(attributes, visTop + windowTop, attributes, visTop + windowTop + n,
				 windowHeight - n);
		System.arraycopy(autowraps, visTop + windowTop, autowraps, visTop + windowTop + n,
				 windowHeight - n);
	    }
	    for(i = windowTop; i < j; i++) {
		screen[visTop + i]     = new char[cols];
		attributes[visTop + i] = new int[cols];
		autowraps[visTop + i]  = false;
	    }
	}
	updateDirtyArea(windowTop, 0, windowBottom, cols);
    }

    public synchronized void clearBelow() {
	if(DEBUG) System.out.println("clearBelow");
	clearRight();
	int[] attrLine = new int[cols];
	int i;
	for(i = 0; i < cols; i++)
	    attrLine[i] = (curAttr & (MASK_BGCOL | MASK_FGCOL | ATTR_BGCOLOR | ATTR_FGCOLOR));
	for(i = curRow + 1; i < windowBottom; i++) {
	    screen[visTop + i]     = new char[cols];
	    attributes[visTop + i] = new int[cols];
	    autowraps[visTop + i]  = false;
	    System.arraycopy(attrLine, 0, attributes[visTop + i], 0, cols);
	}
	updateDirtyArea(curRow, 0, windowBottom, cols);
    }
    public synchronized void clearAbove() {
	if(DEBUG) System.out.println("clearAbove");
	clearLeft();
	int[] attrLine = new int[cols];
	int i;
	for(i = 0; i < cols; i++)
	    attrLine[i] = (curAttr & (MASK_BGCOL | MASK_FGCOL | ATTR_BGCOLOR | ATTR_FGCOLOR));
	for(i = windowTop; i < curRow; i++) {
	    screen[visTop + i]     = new char[cols];
	    attributes[visTop + i] = new int[cols];
	    autowraps[visTop + i]  = false;
	    System.arraycopy(attrLine, 0, attributes[visTop + i], 0, cols);
	}
	updateDirtyArea(windowTop, 0, curRow, cols);
    }
    public synchronized void clearScreen() {
	if(DEBUG) System.out.println("clearScreen");
	int i;
	int[] attrLine = new int[cols];

	for(i = 0; i < cols; i++)
	    attrLine[i] = (curAttr & (MASK_BGCOL | MASK_FGCOL | ATTR_BGCOLOR | ATTR_FGCOLOR));
	for(i = windowTop; i < windowBottom; i++) {
	    screen[saveVisTop + i]     = new char[cols];
	    attributes[saveVisTop + i] = new int[cols];
	    autowraps[saveVisTop + i]  = false;
	    System.arraycopy(attrLine, 0, attributes[saveVisTop + i], 0, cols);
	}

	// Don't call updateDirtyArea(0, 0, rows, cols);
	// we want the values reset instead of updated
	//
	dirtyTop = 0;
	dirtyBottom = rows;
	dirtyLeft = 0;
	dirtyRight = cols;
	repaint();
    }
    public void clearRight() {
	if(DEBUG) System.out.println("clearRight");
	System.arraycopy(spacerow, 0, screen[visTop + curRow], curCol, cols - curCol);
	for(int i = curCol; i < cols; i++) {
	    attributes[visTop + curRow][i] =
		(curAttr & (MASK_BGCOL | MASK_FGCOL | ATTR_BGCOLOR | ATTR_FGCOLOR));
	}
	updateDirtyArea(curRow, curCol, curRow + 1, cols);
    }
    public void clearLeft() {
	if(DEBUG) System.out.println("clearLeft");
	System.arraycopy(spacerow, 0, screen[visTop + curRow], 0, curCol);
	for(int i = 0; i < curCol; i++) {
	    attributes[visTop + curRow][i] =
		(curAttr & (MASK_BGCOL | MASK_FGCOL | ATTR_BGCOLOR | ATTR_FGCOLOR));
	}
	dirtyLeft   = 0;
	updateDirtyArea(curRow, 0, curRow + 1, curCol);
    }
    public synchronized void clearLine() {
	if(DEBUG) System.out.println("clearLine");
	screen[visTop + curRow]     = new char[cols];
	attributes[visTop + curRow] = new int[cols];
	autowraps[visTop + curRow]  = false;
	for(int i = 0; i < cols; i++)
	    attributes[visTop + curRow][i] =
		(curAttr & (MASK_BGCOL | MASK_FGCOL | ATTR_BGCOLOR | ATTR_FGCOLOR));
	dirtyLeft   = 0;
	dirtyRight  = cols;
	updateDirtyArea(curRow, 0, curRow + 1, cols);
    }

    public void eraseChars(int n) {
	if(DEBUG) System.out.println("eraseChars");
	if(n > cols - curCol)
	    n = cols - curCol;
	System.arraycopy(spacerow, 0, screen[visTop + curRow], curCol, n);
	for(int i = 0; i < n; i++) {
	    attributes[visTop + curRow][curCol + i] =
		(curAttr & (MASK_BGCOL | MASK_FGCOL | ATTR_BGCOLOR | ATTR_FGCOLOR));
	}
	updateDirtyArea(curRow, curCol, curRow, curCol + n);
    }
    public void insertChars(int n) {
	int edge = windowRight;
	if(DEBUG) System.out.println("inserChars: " + n);
	if(curCol < windowLeft || curCol > windowRight)
	    return;
	if((curCol + n) < windowRight) {
	    edge = curCol +  n;
	    System.arraycopy(screen[visTop + curRow], curCol, screen[visTop + curRow], edge,
			     windowRight - edge);
	    System.arraycopy(attributes[visTop + curRow], curCol,
			     attributes[visTop + curRow], edge, (windowRight - edge));
	}
	System.arraycopy(spacerow, 0, screen[visTop + curRow], curCol, edge - curCol);
	for(int i = curCol; i < edge; i++) {
	    attributes[visTop + curRow][i] =
		(curAttr & (MASK_BGCOL | MASK_FGCOL | ATTR_BGCOLOR | ATTR_FGCOLOR));
	}
	updateDirtyArea(curRow, curCol, curRow + 1, windowRight);
    }
    public void deleteChars(int n) {
	int edge = curCol;
	if(DEBUG) System.out.println("deleteChars: " + n);
	if(curCol < windowLeft || curCol > windowRight)
	    return;
	if((curCol + n) < windowRight) {
	    edge = windowRight - n;
	    System.arraycopy(screen[visTop + curRow], curCol + n, screen[visTop + curRow], curCol,
			     edge - curCol);
	    System.arraycopy(attributes[visTop + curRow], (curCol + n), attributes[visTop + curRow],
			     curCol, (edge - curCol));
	}
	System.arraycopy(spacerow, 0, screen[visTop + curRow], edge, windowRight - edge);
	for(int i = edge; i < windowRight; i++) {
	    attributes[visTop + curRow][i] =
		(curAttr & (MASK_BGCOL | MASK_FGCOL | ATTR_BGCOLOR | ATTR_FGCOLOR));
	}
	updateDirtyArea(curRow, curCol, curRow + 1, windowRight);
    }
    public synchronized void insertLines(int n) {
	int i, edge = windowBottom;
	if(DEBUG) System.out.println("insertLines: " + n);

	if(curRow < windowTop || curRow > windowBottom)
	    return;

	if(complexScroll) {
	    // !!! TODO: This is untested...
	    if(curRow + n < windowBottom) {
		edge = curRow  + n;
		for(i = windowBottom - 1; i >= edge; i--) {
		    System.arraycopy(screen[visTop + i - n], windowLeft, screen[visTop + i], windowLeft,
				     windowRight - windowLeft);
		    System.arraycopy(attributes[visTop + i - n], windowLeft, attributes[visTop + i],
				     windowLeft, (windowRight - windowLeft));
		}
	    }
	    for(i = curRow; i < edge; i++) {
		System.arraycopy(spacerow, 0, screen[visTop + i], windowLeft, windowRight - windowLeft);
		System.arraycopy(zerorow, 0, attributes[visTop + i], windowLeft, (windowRight - windowLeft));
	    }
	} else {
	    if(curRow + n < windowBottom) {
		edge = curRow + n;
		System.arraycopy(screen, visTop + curRow, screen, visTop + edge, windowBottom - edge);
		System.arraycopy(attributes, visTop + curRow, attributes, visTop + edge,
				 windowBottom - edge);
		System.arraycopy(autowraps, visTop + curRow, autowraps, visTop + edge,
				 windowBottom - edge);
	    }
	    int[] attrLine = new int[cols];
	    for(i = 0; i < cols; i++)
		attrLine[i] = (curAttr & (MASK_BGCOL | MASK_FGCOL | ATTR_BGCOLOR | ATTR_FGCOLOR));
	    for(i = curRow; i < edge; i++) {
		screen[visTop + i]     = new char[cols];
		attributes[visTop + i] = new int[cols];
		autowraps[visTop + i]  = false;
		System.arraycopy(attrLine, 0, attributes[visTop + i], 0, cols);
	    }
	}

	updateDirtyArea(curRow, 0, windowBottom, cols);
    }
    public synchronized void deleteLines(int n) {
	int i, edge = curRow;
	if(DEBUG) System.out.println("deleteLines: " + n);

	if(curRow < windowTop || curRow > windowBottom)
	    return;

	if(complexScroll) {
	    // !!! TODO: This is untested...
	    if(curRow + n < windowBottom) {
		edge = windowBottom - n - 1;
		for(i = curRow; i <= edge; i++) {
		    System.arraycopy(screen[visTop + i + n], windowLeft, screen[visTop + i], windowLeft,
				     windowRight - windowLeft);
		    System.arraycopy(attributes[visTop + i + n], windowLeft, attributes[visTop + i],
				     windowLeft, (windowRight - windowLeft));
		}
	    }
	    for(i = edge; i < windowBottom; i++) {
		System.arraycopy(spacerow, 0, screen[visTop + i], windowLeft, windowRight - windowLeft);
		System.arraycopy(zerorow, 0, attributes[visTop + i], windowLeft, (windowRight - windowLeft));
	    }
	} else {
	    if(curRow + n < windowBottom) {
		edge = windowBottom - n;
		System.arraycopy(screen, visTop + curRow + n, screen, visTop + curRow,
				 edge - curRow);
		System.arraycopy(attributes, visTop + curRow + n, attributes, visTop + curRow,
				 edge - curRow);
		System.arraycopy(autowraps, visTop + curRow + n, autowraps, visTop + curRow,
				 edge - curRow);
	    }
	    int[] attrLine = new int[cols];
	    for(i = 0; i < cols; i++)
		attrLine[i] = (curAttr & (MASK_BGCOL | MASK_FGCOL | ATTR_BGCOLOR | ATTR_FGCOLOR));
	    for(i = edge; i < windowBottom; i++) {
		screen[visTop + i]     = new char[cols];
		attributes[visTop + i] = new int[cols];
		autowraps[visTop + i]  = false;
		System.arraycopy(attrLine, 0, attributes[visTop + i], 0, cols);
	    }
	}

	updateDirtyArea(curRow, 0, windowBottom, cols);
    }

    public void printScreen() {
	if(DEBUG) System.out.println("printScreen");
	if(printer != null && termOptions[OPT_PASSTHRU_PRN]) {
	    printer.printScreen();
	}
    }

    public void startPrinter() {
	if(DEBUG) System.out.println("startPrinter");
	if(printer != null && termOptions[OPT_PASSTHRU_PRN]) {
	    printer.startPrinter();
	    printerActive = true;
	}
    }

    public void stopPrinter() {
	if(DEBUG) System.out.println("stopPrinter");
	if(printer != null && termOptions[OPT_PASSTHRU_PRN]) {
	    printerActive = false;
	    printer.stopPrinter();
	}
    }

    public void setOption(int opt, boolean val) {
	if(DEBUG) System.out.println("setOption " + opt + "=" + val);

	if(opt > termOptions.length || opt < 0)
	    return;

	props.put(TerminalDefProps.defaultPropDesc[opt][0], String.valueOf(val));

	switch(opt) {
	case OPT_REV_VIDEO:
	    Color swap;
	    if(val != termOptions[opt]) {
		termOptions[opt] = val;
		swap             = origBgColor;
		origBgColor      = origFgColor;
		origFgColor      = swap;
		makeAllDirty(true);
	    }
	    break;
	case OPT_VIS_CURSOR:
	    repaint();
	    break;
	case OPT_AUTO_WRAP:
	case OPT_REV_WRAP:
	case OPT_INSERTMODE:
	case OPT_AUTO_LF:
	case OPT_SCROLL_SK:
	case OPT_SCROLL_SI:
	case OPT_LOCAL_PGKEYS:
	case OPT_COPY_CRNL:
	case OPT_ASCII_LDC:
	case OPT_LOCAL_ECHO:
	case OPT_VIS_BELL:
	case OPT_MAP_CTRLSP:
	case OPT_COPY_SEL:
	case OPT_PASSTHRU_PRN:
	    break;
	case OPT_DECCOLM:
	    if(termOptions[opt] != val && termOptions[OPT_DEC132COLS]) {
		setProperty("gm", ((val ? 132 : 80) + "x" + rows + savedGeomPos));
		cursorSetPos(0, 0, false);
	    }
	    break;
	case OPT_DEC132COLS:
	    if(menuHandler != null)
		menuHandler.setEnabledOpt(OPT_DECCOLM, val);
	    break;
	}
	termOptions[opt] = val;
	if(menuHandler != null && opt < Terminal.OPT_LAST_MENU)
	    menuHandler.setStateOpt(opt, val);
    }
    public boolean getOption(int opt) {
	if(DEBUG) System.out.println("getOption " + opt);
	if(opt > termOptions.length || opt < 0)
	    return false;
	return termOptions[opt];
    }

    public void setAttribute(int attr, boolean val) {
	if(DEBUG) System.out.println("setAttr " + attr + "=" + val);
	if(val)
	    curAttr |= attr;
	else
	    curAttr &= ~attr;
    }
    public boolean getAttribute(int attr) {
	if(DEBUG) System.out.println("getAttr " + attr);
	if((curAttr & attr) == attr)
	    return true;
	return false;
    }
    public void setForegroundColor(int c) {
	if(DEBUG) System.out.println("setForegroundColor: " + c);
	if(c >= 0 && c < 8) {
	    if((curAttr & ATTR_BOLD) != 0)
		c += 8;
	    curAttr &= ~(ATTR_FGCOLOR | MASK_FGCOL);
	    curAttr |= (ATTR_FGCOLOR | (c << SHIFT_FGCOL));
	} else {
	    curAttr &= ~ATTR_FGCOLOR;
	}
    }
    public void setBackgroundColor(int c) {
	if(DEBUG) System.out.println("setBackgroundColor: " + c);
	if(c >= 0 && c < 8) {
	    curAttr &= ~(ATTR_BGCOLOR | MASK_BGCOL);
	    curAttr |= (ATTR_BGCOLOR | (c << SHIFT_BGCOL));
	} else {
	    curAttr &= ~ATTR_BGCOLOR;
	}
    }
    public void clearAllAttributes() {
	if(DEBUG) System.out.println("clearAllAttributes");
	curAttr = ATTR_CHARDRAWN;
    }

    private void kludgeProcessKeyEvent(KeyEvent e) {
	int    virtKey = e.getKeyCode();
	int    mod     = e.getModifiers();
	char   c       = e.getKeyChar();

	// Consume TAB to be sure no one uses it so we lose focus
	//
	if(virtKey == KeyEvent.VK_TAB || virtKey == KeyEvent.VK_F10) {
	    e.consume();
	}

	if(specialKeyHandler(c, virtKey, mod))
	    return;

	interpreter.keyHandler(virtKey, mod);

	if(c != KeyEvent.CHAR_UNDEFINED && c != (char)0) {
	    int transC;
	    // If keyKludgeFilter return -1 we should not process the char
	    //
	    if((transC = keyKludgeFilter(c, virtKey, mod)) == -1)
		return;

	    c = (char)transC;

	    if(termOptions[OPT_LOCAL_ECHO])
		write(c);

	    if((c == 0x0a || c == 0x0d) && termOptions[OPT_AUTO_LF]) {
		c = 0x0a;
		typedChar((char)0x0d);
	    }
	    typedChar(c);

	    // Reset window to bottom on keypress option
	    //
	    if(visTop != saveVisTop && termOptions[OPT_SCROLL_SK]) {
		visTop = saveVisTop;
		if(haveScrollbar)
		    scrollbar.setValue(visTop);
		makeAllDirty(false);
	    }
	}
    }

    private boolean isNewEvent(KeyEvent e, boolean byPressed) {
	int ch = (int) e.getKeyChar();

        if(lastKeyWasPressed != byPressed) {
            if(ch == lastKeyKludge)
                return false;
            // XXX: Are there any more cases like this?
            //
            if((lastKeyKludge == 0x0a && ch == 0x0d) || 
                (lastKeyKludge == 0x0d && ch == 0x0a)) {
                return false;
            }
        }
        lastKeyKludge     = ch;
        lastKeyWasPressed = byPressed;
        return true;
    }

    //
    // KeyListener interface
    //
    public void keyTyped(KeyEvent e) {
	char c = e.getKeyChar();

	if(DEBUGKEYEVENT) {
	    int virtKey = e.getKeyCode();
	    System.out.println("typed: " + c + " (" + ((int)c) + ") code=" + virtKey);
	}

        if(isNewEvent(e, false))
            kludgeProcessKeyEvent(e);
    }

    public void keyPressed(KeyEvent e) {
	int    virtKey = e.getKeyCode();
	char   c       = e.getKeyChar();

	if(DEBUGKEYEVENT) {
	    System.out.println("pressed: " + c + " (" + ((int)c) + ") code=" + virtKey);
	}

        if(isNewEvent(e, true))
            kludgeProcessKeyEvent(e);
    }

    public void keyReleased(KeyEvent e) {