| /* |
| * This file is part of "JTA - Telnet/SSH for the JAVA(tm) platform". |
| * |
| * (c) Matthias L. Jugel, Marcus Mei�ner 1996-2005. All Rights Reserved. |
| * |
| * Please visit http://javatelnet.org/ for updates and contact. |
| * |
| * --LICENSE NOTICE-- |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License |
| * as published by the Free Software Foundation; either version 2 |
| * of the License, or (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| * --LICENSE NOTICE-- |
| * |
| */ |
| |
| package de.mud.terminal; |
| |
| import java.util.Arrays; |
| |
| /** |
| * Implementation of a Video Display Unit (VDU) buffer. This class contains all methods to |
| * manipulate the buffer that stores characters and their attributes as well as the regions |
| * displayed. |
| * |
| * @author Matthias L. Jugel, Marcus Meißner |
| * @version $Id: VDUBuffer.java 503 2005-10-24 07:34:13Z marcus $ |
| */ |
| public class VDUBuffer { |
| |
| /** The current version id tag */ |
| public final static String ID = "$Id: VDUBuffer.java 503 2005-10-24 07:34:13Z marcus $"; |
| |
| /** Enable debug messages. */ |
| public final static int debug = 0; |
| |
| public int height, width; /* rows and columns */ |
| public boolean[] update; /* contains the lines that need update */ |
| public char[][] charArray; /* contains the characters */ |
| public int[][] charAttributes; /* contains character attrs */ |
| public int bufSize; |
| public int maxBufSize; /* buffer sizes */ |
| public int screenBase; /* the actual screen start */ |
| public int windowBase; /* where the start displaying */ |
| public int scrollMarker; /* marks the last line inserted */ |
| |
| private int topMargin; /* top scroll margin */ |
| private int bottomMargin; /* bottom scroll margin */ |
| |
| // cursor variables |
| protected boolean showcursor = true; |
| protected int cursorX, cursorY; |
| |
| /** Scroll up when inserting a line. */ |
| public final static boolean SCROLL_UP = false; |
| /** Scroll down when inserting a line. */ |
| public final static boolean SCROLL_DOWN = true; |
| |
| /* |
| * Attributes bit-field usage: |
| * |
| * 8421 8421 8421 8421 8421 8421 8421 8421 |||| |||| |||| |||| |||| |||| |||| |||`- Bold |||| |||| |
| * |||| |||| |||| |||| |||| ||`-- Underline |||| |||| |||| |||| |||| |||| |||| |`--- Invert |||| |
| * |||| |||| |||| |||| |||| |||| `---- Low |||| |||| |||| |||| |||| |||| |||`------ Invisible |||| |
| * |||| |||| |||| ||`+-++++-+++------- Foreground Color |||| |||| |`++-++++-++------------------ |
| * Background Color |||| |||| `----------------------------- Fullwidth character |
| * `+++-++++------------------------------- Reserved for future use |
| */ |
| |
| /** Make character normal. */ |
| public final static int NORMAL = 0x00; |
| /** Make character bold. */ |
| public final static int BOLD = 0x01; |
| /** Underline character. */ |
| public final static int UNDERLINE = 0x02; |
| /** Invert character. */ |
| public final static int INVERT = 0x04; |
| /** Lower intensity character. */ |
| public final static int LOW = 0x08; |
| /** Invisible character. */ |
| public final static int INVISIBLE = 0x10; |
| /** Unicode full-width character (CJK, et al.) */ |
| public final static int FULLWIDTH = 0x8000000; |
| |
| /** how much to left shift the foreground color */ |
| public final static int COLOR_FG_SHIFT = 5; |
| /** how much to left shift the background color */ |
| public final static int COLOR_BG_SHIFT = 14; |
| /** color mask */ |
| public final static int COLOR = 0x7fffe0; /* 0000 0000 0111 1111 1111 1111 1110 0000 */ |
| /** foreground color mask */ |
| public final static int COLOR_FG = 0x3fe0; /* 0000 0000 0000 0000 0011 1111 1110 0000 */ |
| /** background color mask */ |
| public final static int COLOR_BG = 0x7fc000; /* 0000 0000 0111 1111 1100 0000 0000 0000 */ |
| |
| /** |
| * Create a new video display buffer with the passed width and height in characters. |
| * |
| * @param width |
| * the length of the character lines |
| * @param height |
| * the amount of lines on the screen |
| */ |
| public VDUBuffer(int width, int height) { |
| // set the display screen size |
| setScreenSize(width, height, false); |
| } |
| |
| /** |
| * Create a standard video display buffer with 80 columns and 24 lines. |
| */ |
| public VDUBuffer() { |
| this(80, 24); |
| } |
| |
| /** |
| * Put a character on the screen with normal font and outline. The character previously on that |
| * position will be overwritten. You need to call redraw() to update the screen. |
| * |
| * @param c |
| * x-coordinate (column) |
| * @param l |
| * y-coordinate (line) |
| * @param ch |
| * the character to show on the screen |
| * @see #insertChar |
| * @see #deleteChar |
| * @see #redraw |
| */ |
| public void putChar(int c, int l, char ch) { |
| putChar(c, l, ch, NORMAL); |
| } |
| |
| /** |
| * Put a character on the screen with specific font and outline. The character previously on that |
| * position will be overwritten. You need to call redraw() to update the screen. |
| * |
| * @param c |
| * x-coordinate (column) |
| * @param l |
| * y-coordinate (line) |
| * @param ch |
| * the character to show on the screen |
| * @param attributes |
| * the character attributes |
| * @see #BOLD |
| * @see #UNDERLINE |
| * @see #INVERT |
| * @see #INVISIBLE |
| * @see #NORMAL |
| * @see #LOW |
| * @see #insertChar |
| * @see #deleteChar |
| * @see #redraw |
| */ |
| |
| public void putChar(int c, int l, char ch, int attributes) { |
| charArray[screenBase + l][c] = ch; |
| charAttributes[screenBase + l][c] = attributes; |
| if (l < height) { |
| update[l + 1] = true; |
| } |
| } |
| |
| /** |
| * Get the character at the specified position. |
| * |
| * @param c |
| * x-coordinate (column) |
| * @param l |
| * y-coordinate (line) |
| * @see #putChar |
| */ |
| public char getChar(int c, int l) { |
| return charArray[screenBase + l][c]; |
| } |
| |
| /** |
| * Get the attributes for the specified position. |
| * |
| * @param c |
| * x-coordinate (column) |
| * @param l |
| * y-coordinate (line) |
| * @see #putChar |
| */ |
| public int getAttributes(int c, int l) { |
| return charAttributes[screenBase + l][c]; |
| } |
| |
| /** |
| * Insert a character at a specific position on the screen. All character right to from this |
| * position will be moved one to the right. You need to call redraw() to update the screen. |
| * |
| * @param c |
| * x-coordinate (column) |
| * @param l |
| * y-coordinate (line) |
| * @param ch |
| * the character to insert |
| * @param attributes |
| * the character attributes |
| * @see #BOLD |
| * @see #UNDERLINE |
| * @see #INVERT |
| * @see #INVISIBLE |
| * @see #NORMAL |
| * @see #LOW |
| * @see #putChar |
| * @see #deleteChar |
| * @see #redraw |
| */ |
| public void insertChar(int c, int l, char ch, int attributes) { |
| System.arraycopy(charArray[screenBase + l], c, charArray[screenBase + l], c + 1, width - c - 1); |
| System.arraycopy(charAttributes[screenBase + l], c, charAttributes[screenBase + l], c + 1, |
| width - c - 1); |
| putChar(c, l, ch, attributes); |
| } |
| |
| /** |
| * Delete a character at a given position on the screen. All characters right to the position will |
| * be moved one to the left. You need to call redraw() to update the screen. |
| * |
| * @param c |
| * x-coordinate (column) |
| * @param l |
| * y-coordinate (line) |
| * @see #putChar |
| * @see #insertChar |
| * @see #redraw |
| */ |
| public void deleteChar(int c, int l) { |
| if (c < width - 1) { |
| System.arraycopy(charArray[screenBase + l], c + 1, charArray[screenBase + l], c, width - c |
| - 1); |
| System.arraycopy(charAttributes[screenBase + l], c + 1, charAttributes[screenBase + l], c, |
| width - c - 1); |
| } |
| putChar(width - 1, l, (char) 0); |
| } |
| |
| /** |
| * Put a String at a specific position. Any characters previously on that position will be |
| * overwritten. You need to call redraw() for screen update. |
| * |
| * @param c |
| * x-coordinate (column) |
| * @param l |
| * y-coordinate (line) |
| * @param s |
| * the string to be shown on the screen |
| * @see #BOLD |
| * @see #UNDERLINE |
| * @see #INVERT |
| * @see #INVISIBLE |
| * @see #NORMAL |
| * @see #LOW |
| * @see #putChar |
| * @see #insertLine |
| * @see #deleteLine |
| * @see #redraw |
| */ |
| public void putString(int c, int l, String s) { |
| putString(c, l, s, NORMAL); |
| } |
| |
| /** |
| * Put a String at a specific position giving all characters the same attributes. Any characters |
| * previously on that position will be overwritten. You need to call redraw() to update the |
| * screen. |
| * |
| * @param c |
| * x-coordinate (column) |
| * @param l |
| * y-coordinate (line) |
| * @param s |
| * the string to be shown on the screen |
| * @param attributes |
| * character attributes |
| * @see #BOLD |
| * @see #UNDERLINE |
| * @see #INVERT |
| * @see #INVISIBLE |
| * @see #NORMAL |
| * @see #LOW |
| * @see #putChar |
| * @see #insertLine |
| * @see #deleteLine |
| * @see #redraw |
| */ |
| public void putString(int c, int l, String s, int attributes) { |
| for (int i = 0; i < s.length() && c + i < width; i++) { |
| putChar(c + i, l, s.charAt(i), attributes); |
| } |
| } |
| |
| /** |
| * Insert a blank line at a specific position. The current line and all previous lines are |
| * scrolled one line up. The top line is lost. You need to call redraw() to update the screen. |
| * |
| * @param l |
| * the y-coordinate to insert the line |
| * @see #deleteLine |
| * @see #redraw |
| */ |
| public void insertLine(int l) { |
| insertLine(l, 1, SCROLL_UP); |
| } |
| |
| /** |
| * Insert blank lines at a specific position. You need to call redraw() to update the screen |
| * |
| * @param l |
| * the y-coordinate to insert the line |
| * @param n |
| * amount of lines to be inserted |
| * @see #deleteLine |
| * @see #redraw |
| */ |
| public void insertLine(int l, int n) { |
| insertLine(l, n, SCROLL_UP); |
| } |
| |
| /** |
| * Insert a blank line at a specific position. Scroll text according to the argument. You need to |
| * call redraw() to update the screen |
| * |
| * @param l |
| * the y-coordinate to insert the line |
| * @param scrollDown |
| * scroll down |
| * @see #deleteLine |
| * @see #SCROLL_UP |
| * @see #SCROLL_DOWN |
| * @see #redraw |
| */ |
| public void insertLine(int l, boolean scrollDown) { |
| insertLine(l, 1, scrollDown); |
| } |
| |
| /** |
| * Insert blank lines at a specific position. The current line and all previous lines are scrolled |
| * one line up. The top line is lost. You need to call redraw() to update the screen. |
| * |
| * @param l |
| * the y-coordinate to insert the line |
| * @param n |
| * number of lines to be inserted |
| * @param scrollDown |
| * scroll down |
| * @see #deleteLine |
| * @see #SCROLL_UP |
| * @see #SCROLL_DOWN |
| * @see #redraw |
| */ |
| public synchronized void insertLine(int l, int n, boolean scrollDown) { |
| char cbuf[][] = null; |
| int abuf[][] = null; |
| int offset = 0; |
| int oldBase = screenBase; |
| |
| int newScreenBase = screenBase; |
| int newWindowBase = windowBase; |
| int newBufSize = bufSize; |
| |
| if (l > bottomMargin) { |
| return; |
| } |
| int top = |
| (l < topMargin ? 0 : (l > bottomMargin ? (bottomMargin + 1 < height ? bottomMargin + 1 |
| : height - 1) : topMargin)); |
| int bottom = |
| (l > bottomMargin ? height - 1 : (l < topMargin ? (topMargin > 0 ? topMargin - 1 : 0) |
| : bottomMargin)); |
| |
| // System.out.println("l is "+l+", top is "+top+", bottom is "+bottom+", bottomargin is "+bottomMargin+", topMargin is "+topMargin); |
| |
| if (scrollDown) { |
| if (n > (bottom - top)) { |
| n = (bottom - top); |
| } |
| int size = bottom - l - (n - 1); |
| if (size < 0) { |
| size = 0; |
| } |
| cbuf = new char[size][]; |
| abuf = new int[size][]; |
| |
| System.arraycopy(charArray, oldBase + l, cbuf, 0, bottom - l - (n - 1)); |
| System.arraycopy(charAttributes, oldBase + l, abuf, 0, bottom - l - (n - 1)); |
| System.arraycopy(cbuf, 0, charArray, oldBase + l + n, bottom - l - (n - 1)); |
| System.arraycopy(abuf, 0, charAttributes, oldBase + l + n, bottom - l - (n - 1)); |
| cbuf = charArray; |
| abuf = charAttributes; |
| } else { |
| try { |
| if (n > (bottom - top) + 1) { |
| n = (bottom - top) + 1; |
| } |
| if (bufSize < maxBufSize) { |
| if (bufSize + n > maxBufSize) { |
| offset = n - (maxBufSize - bufSize); |
| scrollMarker += offset; |
| newBufSize = maxBufSize; |
| newScreenBase = maxBufSize - height - 1; |
| newWindowBase = screenBase; |
| } else { |
| scrollMarker += n; |
| newScreenBase += n; |
| newWindowBase += n; |
| newBufSize += n; |
| } |
| |
| cbuf = new char[newBufSize][]; |
| abuf = new int[newBufSize][]; |
| } else { |
| offset = n; |
| cbuf = charArray; |
| abuf = charAttributes; |
| } |
| // copy anything from the top of the buffer (+offset) to the new top |
| // up to the screenBase. |
| if (oldBase > 0) { |
| System.arraycopy(charArray, offset, cbuf, 0, oldBase - offset); |
| System.arraycopy(charAttributes, offset, abuf, 0, oldBase - offset); |
| } |
| // copy anything from the top of the screen (screenBase) up to the |
| // topMargin to the new screen |
| if (top > 0) { |
| System.arraycopy(charArray, oldBase, cbuf, newScreenBase, top); |
| System.arraycopy(charAttributes, oldBase, abuf, newScreenBase, top); |
| } |
| // copy anything from the topMargin up to the amount of lines inserted |
| // to the gap left over between scrollback buffer and screenBase |
| if (oldBase >= 0) { |
| System.arraycopy(charArray, oldBase + top, cbuf, oldBase - offset, n); |
| System.arraycopy(charAttributes, oldBase + top, abuf, oldBase - offset, n); |
| } |
| // copy anything from topMargin + n up to the line linserted to the |
| // topMargin |
| System |
| .arraycopy(charArray, oldBase + top + n, cbuf, newScreenBase + top, l - top - (n - 1)); |
| System.arraycopy(charAttributes, oldBase + top + n, abuf, newScreenBase + top, l - top |
| - (n - 1)); |
| // |
| // copy the all lines next to the inserted to the new buffer |
| if (l < height - 1) { |
| System.arraycopy(charArray, oldBase + l + 1, cbuf, newScreenBase + l + 1, (height - 1) |
| - l); |
| System.arraycopy(charAttributes, oldBase + l + 1, abuf, newScreenBase + l + 1, |
| (height - 1) - l); |
| } |
| } catch (ArrayIndexOutOfBoundsException e) { |
| // this should not happen anymore, but I will leave the code |
| // here in case something happens anyway. That code above is |
| // so complex I always have a hard time understanding what |
| // I did, even though there are comments |
| System.err.println("*** Error while scrolling up:"); |
| System.err.println("--- BEGIN STACK TRACE ---"); |
| e.printStackTrace(); |
| System.err.println("--- END STACK TRACE ---"); |
| System.err.println("bufSize=" + bufSize + ", maxBufSize=" + maxBufSize); |
| System.err.println("top=" + top + ", bottom=" + bottom); |
| System.err.println("n=" + n + ", l=" + l); |
| System.err.println("screenBase=" + screenBase + ", windowBase=" + windowBase); |
| System.err.println("newScreenBase=" + newScreenBase + ", newWindowBase=" + newWindowBase); |
| System.err.println("oldBase=" + oldBase); |
| System.err.println("size.width=" + width + ", size.height=" + height); |
| System.err.println("abuf.length=" + abuf.length + ", cbuf.length=" + cbuf.length); |
| System.err.println("*** done dumping debug information"); |
| } |
| } |
| |
| // this is a little helper to mark the scrolling |
| scrollMarker -= n; |
| |
| for (int i = 0; i < n; i++) { |
| cbuf[(newScreenBase + l) + (scrollDown ? i : -i)] = new char[width]; |
| Arrays.fill(cbuf[(newScreenBase + l) + (scrollDown ? i : -i)], ' '); |
| abuf[(newScreenBase + l) + (scrollDown ? i : -i)] = new int[width]; |
| } |
| |
| charArray = cbuf; |
| charAttributes = abuf; |
| screenBase = newScreenBase; |
| windowBase = newWindowBase; |
| bufSize = newBufSize; |
| |
| if (scrollDown) { |
| markLine(l, bottom - l + 1); |
| } else { |
| markLine(top, l - top + 1); |
| } |
| |
| display.updateScrollBar(); |
| } |
| |
| /** |
| * Delete a line at a specific position. Subsequent lines will be scrolled up to fill the space |
| * and a blank line is inserted at the end of the screen. |
| * |
| * @param l |
| * the y-coordinate to insert the line |
| * @see #deleteLine |
| */ |
| public void deleteLine(int l) { |
| int bottom = (l > bottomMargin ? height - 1 : (l < topMargin ? topMargin : bottomMargin + 1)); |
| int numRows = bottom - l - 1; |
| |
| char[] discardedChars = charArray[screenBase + l]; |
| int[] discardedAttributes = charAttributes[screenBase + l]; |
| |
| if (numRows > 0) { |
| System.arraycopy(charArray, screenBase + l + 1, charArray, screenBase + l, numRows); |
| System.arraycopy(charAttributes, screenBase + l + 1, charAttributes, screenBase + l, numRows); |
| } |
| |
| int newBottomRow = screenBase + bottom - 1; |
| charArray[newBottomRow] = discardedChars; |
| charAttributes[newBottomRow] = discardedAttributes; |
| Arrays.fill(charArray[newBottomRow], ' '); |
| Arrays.fill(charAttributes[newBottomRow], 0); |
| |
| markLine(l, bottom - l); |
| } |
| |
| /** |
| * Delete a rectangular portion of the screen. You need to call redraw() to update the screen. |
| * |
| * @param c |
| * x-coordinate (column) |
| * @param l |
| * y-coordinate (row) |
| * @param w |
| * with of the area in characters |
| * @param h |
| * height of the area in characters |
| * @param curAttr |
| * attribute to fill |
| * @see #deleteChar |
| * @see #deleteLine |
| * @see #redraw |
| */ |
| public void deleteArea(int c, int l, int w, int h, int curAttr) { |
| int endColumn = c + w; |
| int targetRow = screenBase + l; |
| for (int i = 0; i < h && l + i < height; i++) { |
| Arrays.fill(charAttributes[targetRow], c, endColumn, curAttr); |
| Arrays.fill(charArray[targetRow], c, endColumn, ' '); |
| targetRow++; |
| } |
| markLine(l, h); |
| } |
| |
| /** |
| * Delete a rectangular portion of the screen. You need to call redraw() to update the screen. |
| * |
| * @param c |
| * x-coordinate (column) |
| * @param l |
| * y-coordinate (row) |
| * @param w |
| * with of the area in characters |
| * @param h |
| * height of the area in characters |
| * @see #deleteChar |
| * @see #deleteLine |
| * @see #redraw |
| */ |
| public void deleteArea(int c, int l, int w, int h) { |
| deleteArea(c, l, w, h, 0); |
| } |
| |
| /** |
| * Sets whether the cursor is visible or not. |
| * |
| * @param doshow |
| */ |
| public void showCursor(boolean doshow) { |
| showcursor = doshow; |
| } |
| |
| /** |
| * Check whether the cursor is currently visible. |
| * |
| * @return visibility |
| */ |
| public boolean isCursorVisible() { |
| return showcursor; |
| } |
| |
| /** |
| * Puts the cursor at the specified position. |
| * |
| * @param c |
| * column |
| * @param l |
| * line |
| */ |
| public void setCursorPosition(int c, int l) { |
| cursorX = c; |
| cursorY = l; |
| } |
| |
| /** |
| * Get the current column of the cursor position. |
| */ |
| public int getCursorColumn() { |
| return cursorX; |
| } |
| |
| /** |
| * Get the current line of the cursor position. |
| */ |
| public int getCursorRow() { |
| return cursorY; |
| } |
| |
| /** |
| * Set the current window base. This allows to view the scrollback buffer. |
| * |
| * @param line |
| * the line where the screen window starts |
| * @see #setBufferSize |
| * @see #getBufferSize |
| */ |
| public void setWindowBase(int line) { |
| if (line > screenBase) { |
| line = screenBase; |
| } else if (line < 0) { |
| line = 0; |
| } |
| windowBase = line; |
| update[0] = true; |
| redraw(); |
| } |
| |
| /** |
| * Get the current window base. |
| * |
| * @see #setWindowBase |
| */ |
| public int getWindowBase() { |
| return windowBase; |
| } |
| |
| /** |
| * Set the scroll margins simultaneously. If they're out of bounds, trim them. |
| * |
| * @param l1 |
| * line that is the top |
| * @param l2 |
| * line that is the bottom |
| */ |
| public void setMargins(int l1, int l2) { |
| if (l1 > l2) { |
| return; |
| } |
| |
| if (l1 < 0) { |
| l1 = 0; |
| } |
| if (l2 >= height) { |
| l2 = height - 1; |
| } |
| |
| topMargin = l1; |
| bottomMargin = l2; |
| } |
| |
| /** |
| * Set the top scroll margin for the screen. If the current bottom margin is smaller it will |
| * become the top margin and the line will become the bottom margin. |
| * |
| * @param l |
| * line that is the margin |
| */ |
| public void setTopMargin(int l) { |
| if (l > bottomMargin) { |
| topMargin = bottomMargin; |
| bottomMargin = l; |
| } else { |
| topMargin = l; |
| } |
| if (topMargin < 0) { |
| topMargin = 0; |
| } |
| if (bottomMargin >= height) { |
| bottomMargin = height - 1; |
| } |
| } |
| |
| /** |
| * Get the top scroll margin. |
| */ |
| public int getTopMargin() { |
| return topMargin; |
| } |
| |
| /** |
| * Set the bottom scroll margin for the screen. If the current top margin is bigger it will become |
| * the bottom margin and the line will become the top margin. |
| * |
| * @param l |
| * line that is the margin |
| */ |
| public void setBottomMargin(int l) { |
| if (l < topMargin) { |
| bottomMargin = topMargin; |
| topMargin = l; |
| } else { |
| bottomMargin = l; |
| } |
| if (topMargin < 0) { |
| topMargin = 0; |
| } |
| if (bottomMargin >= height) { |
| bottomMargin = height - 1; |
| } |
| } |
| |
| /** |
| * Get the bottom scroll margin. |
| */ |
| public int getBottomMargin() { |
| return bottomMargin; |
| } |
| |
| /** |
| * Set scrollback buffer size. |
| * |
| * @param amount |
| * new size of the buffer |
| */ |
| public void setBufferSize(int amount) { |
| if (amount < height) { |
| amount = height; |
| } |
| if (amount < maxBufSize) { |
| char cbuf[][] = new char[amount][width]; |
| int abuf[][] = new int[amount][width]; |
| int copyStart = bufSize - amount < 0 ? 0 : bufSize - amount; |
| int copyCount = bufSize - amount < 0 ? bufSize : amount; |
| if (charArray != null) { |
| System.arraycopy(charArray, copyStart, cbuf, 0, copyCount); |
| } |
| if (charAttributes != null) { |
| System.arraycopy(charAttributes, copyStart, abuf, 0, copyCount); |
| } |
| charArray = cbuf; |
| charAttributes = abuf; |
| bufSize = copyCount; |
| screenBase = bufSize - height; |
| windowBase = screenBase; |
| } |
| maxBufSize = amount; |
| |
| update[0] = true; |
| redraw(); |
| } |
| |
| /** |
| * Retrieve current scrollback buffer size. |
| * |
| * @see #setBufferSize |
| */ |
| public int getBufferSize() { |
| return bufSize; |
| } |
| |
| /** |
| * Retrieve maximum buffer Size. |
| * |
| * @see #getBufferSize |
| */ |
| public int getMaxBufferSize() { |
| return maxBufSize; |
| } |
| |
| /** |
| * Change the size of the screen. This will include adjustment of the scrollback buffer. |
| * |
| * @param w |
| * of the screen |
| * @param h |
| * of the screen |
| */ |
| @SuppressWarnings("unused") |
| public void setScreenSize(int w, int h, boolean broadcast) { |
| char cbuf[][]; |
| int abuf[][]; |
| int maxSize = bufSize; |
| |
| if (w < 1 || h < 1) { |
| return; |
| } |
| |
| if (debug > 0) { |
| System.err.println("VDU: screen size [" + w + "," + h + "]"); |
| } |
| |
| if (h > maxBufSize) { |
| maxBufSize = h; |
| } |
| |
| if (h > bufSize) { |
| bufSize = h; |
| screenBase = 0; |
| windowBase = 0; |
| } |
| |
| if (windowBase + h >= bufSize) { |
| windowBase = bufSize - h; |
| } |
| |
| if (screenBase + h >= bufSize) { |
| screenBase = bufSize - h; |
| } |
| |
| cbuf = new char[bufSize][w]; |
| abuf = new int[bufSize][w]; |
| |
| for (int i = 0; i < bufSize; i++) { |
| Arrays.fill(cbuf[i], ' '); |
| } |
| |
| if (bufSize < maxSize) { |
| maxSize = bufSize; |
| } |
| |
| int rowLength; |
| if (charArray != null && charAttributes != null) { |
| for (int i = 0; i < maxSize && charArray[i] != null; i++) { |
| rowLength = charArray[i].length; |
| System.arraycopy(charArray[i], 0, cbuf[i], 0, w < rowLength ? w : rowLength); |
| System.arraycopy(charAttributes[i], 0, abuf[i], 0, w < rowLength ? w : rowLength); |
| } |
| } |
| |
| int C = getCursorColumn(); |
| if (C < 0) { |
| C = 0; |
| } else if (C >= width) { |
| C = width - 1; |
| } |
| |
| int R = getCursorRow(); |
| if (R < 0) { |
| R = 0; |
| } else if (R >= height) { |
| R = height - 1; |
| } |
| |
| setCursorPosition(C, R); |
| |
| charArray = cbuf; |
| charAttributes = abuf; |
| width = w; |
| height = h; |
| topMargin = 0; |
| bottomMargin = h - 1; |
| update = new boolean[h + 1]; |
| update[0] = true; |
| /* |
| * FIXME: ??? if(resizeStrategy == RESIZE_FONT) setBounds(getBounds()); |
| */ |
| } |
| |
| /** |
| * Get amount of rows on the screen. |
| */ |
| public int getRows() { |
| return height; |
| } |
| |
| /** |
| * Get amount of columns on the screen. |
| */ |
| public int getColumns() { |
| return width; |
| } |
| |
| /** |
| * Mark lines to be updated with redraw(). |
| * |
| * @param l |
| * starting line |
| * @param n |
| * amount of lines to be updated |
| * @see #redraw |
| */ |
| public void markLine(int l, int n) { |
| for (int i = 0; (i < n) && (l + i < height); i++) { |
| update[l + i + 1] = true; |
| } |
| } |
| |
| // private static int checkBounds(int value, int lower, int upper) { |
| // if (value < lower) |
| // return lower; |
| // else if (value > upper) |
| // return upper; |
| // else |
| // return value; |
| // } |
| |
| /** a generic display that should redraw on demand */ |
| protected VDUDisplay display; |
| |
| public void setDisplay(VDUDisplay display) { |
| this.display = display; |
| } |
| |
| /** |
| * Trigger a redraw on the display. |
| */ |
| protected void redraw() { |
| if (display != null) { |
| display.redraw(); |
| } |
| } |
| } |
