--- a/src/org/tn5250j/framework/tn5250/ScreenPlanes.java	Wed Jun 18 13:00:19 2014 -0700
+++ b/src/org/tn5250j/framework/tn5250/ScreenPlanes.java	Wed Jun 18 13:03:01 2014 -0700
@@ -31,794 +31,775 @@
 
 public class ScreenPlanes {
 
-	private final Screen5250 scr;
-	private int screenSize;
-	private int numRows;
-	private int numCols;
-	private int errorLineNum;
+    private final Screen5250 scr;
+    private int screenSize;
+    private int numRows;
+    private int numCols;
+    private int errorLineNum;
 
-	private static final int initAttr = 32;
-	private static final char initChar = 0;
+    private static final int initAttr = 32;
+    private static final char initChar = 0;
 
-	protected char[] screen;   // text plane
-	private char[] screenAttr;   // attribute plane
-	private char[] screenGUI;   // gui plane
-	private char[] screenIsAttr;
-	private char[] fieldExtended;
-	private char[] screenField;
-	private char[] screenColor;   // color plane
-	protected char[] screenExtended;   // extended plane
-	private char[] screenIsChanged;
+    protected char[] screen;   // text plane
+    private char[] screenAttr;   // attribute plane
+    private char[] screenGUI;   // gui plane
+    private char[] screenIsAttr;
+    private char[] fieldExtended;
+    private char[] screenField;
+    private char[] screenColor;   // color plane
+    protected char[] screenExtended;   // extended plane
+    private char[] screenIsChanged;
 
-	private char[] initArray;
+    private char[] initArray;
 
-	private char[] errorLine;
-	private char[] errorLineAttr;
-	private char[] errorLineIsAttr;
-	private char[] errorLineGui;
-
-	public ScreenPlanes(Screen5250 s5250, int size) {
+    private char[] errorLine;
+    private char[] errorLineAttr;
+    private char[] errorLineIsAttr;
+    private char[] errorLineGui;
 
-		scr = s5250;
-		setSize(size);
-	}
-
-	protected void setSize(int newSize) {
-
-		screenSize = newSize;
+    public ScreenPlanes(Screen5250 s5250, int size) {
+        scr = s5250;
+        setSize(size);
+    }
 
-		numCols = 80;
-		switch (newSize) {
-		case 24:
-			numRows = 24;
-			break;
-		case 27:
-			numRows = 27;
-			numCols = 132;
-			break;
+    protected void setSize(int newSize) {
+        screenSize = newSize;
+        numCols = 80;
 
-		}
+        switch (newSize) {
+            case 24:
+                numRows = 24;
+                break;
 
-		// this is used here when size changes
-		setErrorLine(numRows);
+            case 27:
+                numRows = 27;
+                numCols = 132;
+                break;
+        }
 
-		screenSize = numRows * numCols;
-		screen = new char[screenSize];
-		screenAttr = new char[screenSize];
-		screenIsAttr = new char[screenSize];
-		screenGUI = new char[screenSize];
-		screenColor = new char[screenSize];
-		screenExtended = new char[screenSize];
-		fieldExtended = new char[screenSize];
-		screenIsChanged = new char[screenSize];
-		screenField = new char[screenSize];
-
-		initArray = new char[screenSize];
+        // this is used here when size changes
+        setErrorLine(numRows);
+        screenSize = numRows * numCols;
+        screen = new char[screenSize];
+        screenAttr = new char[screenSize];
+        screenIsAttr = new char[screenSize];
+        screenGUI = new char[screenSize];
+        screenColor = new char[screenSize];
+        screenExtended = new char[screenSize];
+        fieldExtended = new char[screenSize];
+        screenIsChanged = new char[screenSize];
+        screenField = new char[screenSize];
+        initArray = new char[screenSize];
+        initalizePlanes();
+    }
 
-		initalizePlanes();
-	}
-
-	protected void setErrorLine (int line) {
-
-		// * NOTE * for developers I have changed the send qry to pass different
-		//    parameters to the host so check setsize for setting error line as well.
-		//
-		if (line == 0 || line > numRows)
-			errorLineNum = numRows;
-		else
-			errorLineNum = line;
-	}
+    protected void setErrorLine(int line) {
+        // * NOTE * for developers I have changed the send qry to pass different
+        //    parameters to the host so check setsize for setting error line as well.
+        //
+        if (line == 0 || line > numRows)
+            errorLineNum = numRows;
+        else
+            errorLineNum = line;
+    }
 
-	/**
-	 * Returns the current error line number
-	 *
-	 * @return current error line number
-	 */
-	protected int getErrorLine() {
-		return errorLineNum;
-	}
-
-	protected void saveErrorLine() {
-
-		// if there is already an error line saved then do not save it again
-		//  This signifies that there was a previous error and the original error
-		//  line was not restored yet.
-		if (errorLine == null) {
-			errorLine = new char[numCols];
-			errorLineAttr = new char[numCols];
-			errorLineIsAttr = new char[numCols];
-			errorLineGui = new char[numCols];
+    /**
+     * Returns the current error line number
+     *
+     * @return current error line number
+     */
+    protected int getErrorLine() {
+        return errorLineNum;
+    }
 
-			int r = scr.getPos(errorLineNum-1,0);
+    protected void saveErrorLine() {
+        // if there is already an error line saved then do not save it again
+        //  This signifies that there was a previous error and the original error
+        //  line was not restored yet.
+        if (errorLine == null) {
+            errorLine = new char[numCols];
+            errorLineAttr = new char[numCols];
+            errorLineIsAttr = new char[numCols];
+            errorLineGui = new char[numCols];
+            int r = scr.getPos(errorLineNum - 1, 0);
 
-			for (int x = 0;x < numCols; x++) {
-				errorLine[x] = screen[r+x];
-				errorLineAttr[x] = screenAttr[r+x];
-				errorLineIsAttr[x] = screenIsAttr[r+x];
-				errorLineGui[x] = screenGUI[r+x];
-			}
-		}
-	}
+            for (int x = 0; x < numCols; x++) {
+                errorLine[x] = screen[r + x];
+                errorLineAttr[x] = screenAttr[r + x];
+                errorLineIsAttr[x] = screenIsAttr[r + x];
+                errorLineGui[x] = screenGUI[r + x];
+            }
+        }
+    }
 
-	/**
-	 * Restores the error line characters from the save buffer.
-	 *
-	 * @see #saveErrorLine()
-	 */
-	protected void restoreErrorLine() {
-
-		if (errorLine != null) {
-			int r = scr.getPos(errorLineNum - 1, 0);
+    /**
+     * Restores the error line characters from the save buffer.
+     *
+     * @see #saveErrorLine()
+     */
+    protected void restoreErrorLine() {
+        if (errorLine != null) {
+            int r = scr.getPos(errorLineNum - 1, 0);
 
-			for (int x = 0; x < numCols - 1; x++) {
-				setScreenCharAndAttr(r+x,errorLine[x],errorLineAttr[x],
-						(errorLineIsAttr[x] == '1' ? true : false));
-				screenGUI[x] = errorLineGui[x];
-			}
-
-			errorLine = null;
-			errorLineAttr = null;
-			errorLineIsAttr = null;
-			errorLineGui = null;
-		}
-	}
+            for (int x = 0; x < numCols - 1; x++) {
+                setScreenCharAndAttr(r + x, errorLine[x], errorLineAttr[x],
+                                     (errorLineIsAttr[x] == '1' ? true : false));
+                screenGUI[x] = errorLineGui[x];
+            }
 
-	protected boolean isErrorLineSaved() {
-		return errorLine == null ? false : true;
-	}
-
-	protected void setScreenCharAndAttr(int pos, char c, int attr, boolean isAttr) {
+            errorLine = null;
+            errorLineAttr = null;
+            errorLineIsAttr = null;
+            errorLineGui = null;
+        }
+    }
 
-		screen[pos] = c;
-		screenAttr[pos] = (char)attr;
-		disperseAttribute(pos,attr);
-		screenIsAttr[pos] = (isAttr ? (char)1 : (char)0);
-		screenGUI[pos] = NO_GUI;
+    protected boolean isErrorLineSaved() {
+        return errorLine == null ? false : true;
+    }
 
-	}
-
-	protected void setScreenAttr(int pos, int attr, boolean isAttr) {
+    protected void setScreenCharAndAttr(int pos, char c, int attr, boolean isAttr) {
+        screen[pos] = c;
+        screenAttr[pos] = (char)attr;
+        disperseAttribute(pos, attr);
+        screenIsAttr[pos] = (isAttr ? (char)1 : (char)0);
+        screenGUI[pos] = NO_GUI;
+    }
 
-		screenAttr[pos] = (char)attr;
-		screenIsAttr[pos] = isAttr ? (char)1 : (char)0;
-		disperseAttribute(pos,attr);
-		screenGUI[pos] = initChar;
+    protected void setScreenAttr(int pos, int attr, boolean isAttr) {
+        screenAttr[pos] = (char)attr;
+        screenIsAttr[pos] = isAttr ? (char)1 : (char)0;
+        disperseAttribute(pos, attr);
+        screenGUI[pos] = initChar;
+    }
 
-	}
-
-	protected void setScreenAttr(int pos, int attr) {
-
-		screenAttr[pos] = (char)attr;
-		//screenGUI[pos] = initChar;
-		disperseAttribute(pos,attr);
+    protected void setScreenAttr(int pos, int attr) {
+        screenAttr[pos] = (char)attr;
+        //screenGUI[pos] = initChar;
+        disperseAttribute(pos, attr);
+    }
 
-	}
-
-	protected void setScreenFieldAttr(int pos, int attr) {
+    protected void setScreenFieldAttr(int pos, int attr) {
+        screenField[pos] = (char)attr;
+    }
 
-		screenField[pos] = (char)attr;
-
-	}
+    protected final void setChar(int pos, char c) {
+        screenIsChanged[pos] = screen[pos] == c ? '0' : '1';
+        screen[pos] = c;
 
-	protected final void setChar(int pos, char c) {
-		screenIsChanged[pos] = screen[pos] == c ? '0' : '1';
-		screen[pos] = c;
-		if (screenIsAttr[pos] == 1)
-			setScreenCharAndAttr(pos,c,32,false);
+        if (screenIsAttr[pos] == 1)
+            setScreenCharAndAttr(pos, c, 32, false);
+    }
 
-	}
+    protected final char getChar(int pos) {
+        return screen[pos];
+    }
+
+    protected final char getCharColor(int pos) {
+        return screenColor[pos];
+    }
 
-	protected final char getChar(int pos) {
-		return screen[pos];
-	}
+    protected final int getCharAttr(int pos) {
+        return screenAttr[pos];
+    }
 
-	protected final char getCharColor(int pos) {
-		return screenColor[pos];
-	}
+    protected final char getCharExtended(int pos) {
+        return screenExtended[pos];
+    }
 
-	protected final int getCharAttr(int pos) {
-		return screenAttr[pos];
-	}
+    protected final boolean isAttributePlace(int pos) {
+        return screenIsAttr[pos] == 1 ? true : false;
+    }
 
-	protected final char getCharExtended(int pos) {
-		return screenExtended[pos];
-	}
-
-	protected final boolean isAttributePlace(int pos) {
-		return screenIsAttr[pos] == 1 ? true : false;
-	}
+    public final void setUseGUI(int pos, int which) {
+        screenIsChanged[pos] = screenGUI[pos] == which ? '0' : '1';
+        screenGUI[pos] = (char)which;
+    }
 
-	public final void setUseGUI(int pos, int which) {
+    private void disperseAttribute(int pos, int attr) {
+        char c = 0;
+        char cs = 0;
+        char ul = 0;
+        char nd = 0;
 
-		screenIsChanged[pos] = screenGUI[pos] == which ? '0' : '1';
-		screenGUI[pos] = (char)which;
-	}
+        if (attr == 0)
+            return;
 
-	private void disperseAttribute(int pos, int attr) {
+        switch (attr) {
+            case 32: // green normal
+                c = ATTR_32;
+                break;
 
-		char c = 0;
-		char cs = 0;
-		char ul = 0;
-		char nd = 0;
-
-		if(attr == 0)
-			return;
+            case 33: // green/revers
+                c = ATTR_33;
+                break;
 
-		switch(attr) {
-		case 32: // green normal
-			c = ATTR_32;
-			break;
+            case 34: // white normal
+                c = ATTR_34;
+                break;
 
-		case 33: // green/revers
-			c = ATTR_33;
-			break;
+            case 35: // white/reverse
+                c = ATTR_35;
+                break;
 
-		case 34: // white normal
-			c = ATTR_34;
-			break;
-
-		case 35: // white/reverse
-			c = ATTR_35;
-			break;
+            case 36: // green/underline
+                c = ATTR_36;
+                ul = EXTENDED_5250_UNDERLINE;
+                break;
 
-		case 36: // green/underline
-			c = ATTR_36;
-			ul = EXTENDED_5250_UNDERLINE;
-			break;
+            case 37: // green/reverse/underline
+                c = ATTR_37;
+                ul = EXTENDED_5250_UNDERLINE;
+                break;
 
-		case 37: // green/reverse/underline
-			c = ATTR_37;
-			ul = EXTENDED_5250_UNDERLINE;
-			break;
+            case 38: // white/underline
+                c = ATTR_38;
+                ul = EXTENDED_5250_UNDERLINE;
+                break;
+
+            case 39:
+                nd = EXTENDED_5250_NON_DSP;
+                break;
 
-		case 38: // white/underline
-			c = ATTR_38;
-			ul = EXTENDED_5250_UNDERLINE;
-			break;
+            case 40:
+            case 42: // red/normal
+                c = ATTR_40;
+                break;
 
-		case 39:
-			nd = EXTENDED_5250_NON_DSP;
-			break;
-
-		case 40:
-		case 42: // red/normal
-			c = ATTR_40;
-			break;
+            case 41:
+            case 43: // red/reverse
+                c = ATTR_41;
+                break;
 
-		case 41:
-		case 43: // red/reverse
-			c = ATTR_41;
-			break;
+            case 44:
+            case 46: // red/underline
+                c = ATTR_44;
+                ul = EXTENDED_5250_UNDERLINE;
+                break;
 
-		case 44:
-		case 46: // red/underline
-			c = ATTR_44;
-			ul = EXTENDED_5250_UNDERLINE;
-			break;
+            case 45: // red/reverse/underline
+                c = ATTR_45;
+                ul = EXTENDED_5250_UNDERLINE;
+                break;
 
-		case 45: // red/reverse/underline
-			c = ATTR_45;
-			ul = EXTENDED_5250_UNDERLINE;
-			break;
+            case 47:
+                nd = EXTENDED_5250_NON_DSP;
+                break;
 
-		case 47:
-			nd = EXTENDED_5250_NON_DSP;
-			break;
+            case 48:
+                c = ATTR_48;
+                cs = EXTENDED_5250_COL_SEP;
+                break;
 
-		case 48:
-			c = ATTR_48;
-			cs = EXTENDED_5250_COL_SEP;
-			break;
-
-		case 49:
-			c = ATTR_49;
-			cs = EXTENDED_5250_COL_SEP;
-			break;
+            case 49:
+                c = ATTR_49;
+                cs = EXTENDED_5250_COL_SEP;
+                break;
 
-		case 50:
-			c = ATTR_50;
-			cs = EXTENDED_5250_COL_SEP;
-			break;
+            case 50:
+                c = ATTR_50;
+                cs = EXTENDED_5250_COL_SEP;
+                break;
 
-		case 51:
-			c = ATTR_51;
-			cs = EXTENDED_5250_COL_SEP;
-			break;
+            case 51:
+                c = ATTR_51;
+                cs = EXTENDED_5250_COL_SEP;
+                break;
 
-		case 52:
-			c = ATTR_52;
-			//            colSep = true;
-			ul = EXTENDED_5250_UNDERLINE;
-			break;
+            case 52:
+                c = ATTR_52;
+                //            colSep = true;
+                ul = EXTENDED_5250_UNDERLINE;
+                break;
 
-		case 53:
-			c = ATTR_53;
-			//            colSep = true;
-			ul = EXTENDED_5250_UNDERLINE;
-			break;
+            case 53:
+                c = ATTR_53;
+                //            colSep = true;
+                ul = EXTENDED_5250_UNDERLINE;
+                break;
 
-		case 54:
-			c = ATTR_54;
-			//            colSep = true;
-			ul = EXTENDED_5250_UNDERLINE;
-			break;
+            case 54:
+                c = ATTR_54;
+                //            colSep = true;
+                ul = EXTENDED_5250_UNDERLINE;
+                break;
 
-		case 55:
-			nd = EXTENDED_5250_NON_DSP;
-			break;
+            case 55:
+                nd = EXTENDED_5250_NON_DSP;
+                break;
 
-		case 56: // pink
-			c = ATTR_56;
-			break;
+            case 56: // pink
+                c = ATTR_56;
+                break;
 
-		case 57: // pink/reverse
-			c = ATTR_57;
-			break;
+            case 57: // pink/reverse
+                c = ATTR_57;
+                break;
 
-		case 58: // blue/reverse
-			c = ATTR_58;
-			break;
+            case 58: // blue/reverse
+                c = ATTR_58;
+                break;
 
-		case 59: // blue
-			c = ATTR_59;
-			break;
+            case 59: // blue
+                c = ATTR_59;
+                break;
 
-		case 60: // pink/underline
-			c = ATTR_60;
-			ul = EXTENDED_5250_UNDERLINE;
-			break;
+            case 60: // pink/underline
+                c = ATTR_60;
+                ul = EXTENDED_5250_UNDERLINE;
+                break;
 
-		case 61: // pink/reverse/underline
-			c = ATTR_61;
-			ul = EXTENDED_5250_UNDERLINE;
-			break;
+            case 61: // pink/reverse/underline
+                c = ATTR_61;
+                ul = EXTENDED_5250_UNDERLINE;
+                break;
 
-		case 62: // blue/underline
-			c = ATTR_62;
-			ul = EXTENDED_5250_UNDERLINE;
-			break;
+            case 62: // blue/underline
+                c = ATTR_62;
+                ul = EXTENDED_5250_UNDERLINE;
+                break;
+
+            case 63:  // nondisplay
+                nd = EXTENDED_5250_NON_DSP;
+                cs = EXTENDED_5250_COL_SEP;
+                break;
 
-		case 63:  // nondisplay
-			nd = EXTENDED_5250_NON_DSP;
-			cs = EXTENDED_5250_COL_SEP;
-			break;
-		default:
-			c = ( COLOR_BG_BLACK << 8 & 0xff00) |
-			( COLOR_FG_YELLOW & 0xff);
-			break;
+            default:
+                c = (COLOR_BG_BLACK << 8 & 0xff00) |
+                    (COLOR_FG_YELLOW & 0xff);
+                break;
+        }
 
-		}
-
-		screenColor[pos] = c;
-		screenExtended[pos] = (char)(ul | cs | nd);
-	}
+        screenColor[pos] = c;
+        screenExtended[pos] = (char)(ul | cs | nd);
+    }
 
-	protected void initalizePlanes () {
-
-		char c = (COLOR_BG_BLACK << 8 & 0xff00) |
-		(COLOR_FG_GREEN & 0xff);
+    protected void initalizePlanes() {
+        char c = (COLOR_BG_BLACK << 8 & 0xff00) |
+                 (COLOR_FG_GREEN & 0xff);
 
-		for (int y = 0;y < screenSize; y++) {
-
-			screenAttr[y] = initAttr;
-			screenColor[y] = c;
+        for (int y = 0; y < screenSize; y++) {
+            screenAttr[y] = initAttr;
+            screenColor[y] = c;
+        }
 
-		}
-
-		// here we will just copy the initialized plane onto the other planes
-		// using arraycopy which will be faster.  I hope.
+        // here we will just copy the initialized plane onto the other planes
+        // using arraycopy which will be faster.  I hope.
+        System.arraycopy(initArray, 0, screen, 0, screenSize);
+        System.arraycopy(initArray, 0, screenGUI, 0, screenSize);
+        System.arraycopy(initArray, 0, screenIsAttr, 0, screenSize);
+        System.arraycopy(initArray, 0, screenExtended, 0, screenSize);
+        System.arraycopy(initArray, 0, fieldExtended, 0, screenSize);
+        System.arraycopy(initArray, 0, screenField, 0, screenSize);
+    }
 
-		System.arraycopy(initArray,0,screen,0,screenSize);
-		System.arraycopy(initArray,0,screenGUI,0,screenSize);
-		System.arraycopy(initArray,0,screenIsAttr,0,screenSize);
-		System.arraycopy(initArray,0,screenExtended,0,screenSize);
-		System.arraycopy(initArray,0,fieldExtended,0,screenSize);
-		System.arraycopy(initArray,0,screenField,0,screenSize);
-	}
+    protected void initalizeFieldPlanes() {
+        System.arraycopy(initArray, 0, fieldExtended, 0, screenSize);
+        System.arraycopy(initArray, 0, screenField, 0, screenSize);
+    }
+
+    protected final int getWhichGUI(int pos) {
+        return screenGUI[pos];
+    }
 
-	protected void initalizeFieldPlanes () {
-		System.arraycopy(initArray,0,fieldExtended,0,screenSize);
-		System.arraycopy(initArray,0,screenField,0,screenSize);
-	}
-
-	protected final int getWhichGUI(int pos) {
+    protected final boolean isChanged(int pos) {
+        return screenIsChanged[pos] == 0 ? false : true;
+    }
 
-		return screenGUI[pos];
-	}
-
-	protected final boolean isChanged(int pos) {
-		return screenIsChanged[pos] == 0 ? false : true;
-	}
+    protected final boolean isUseGui(int pos) {
+        return screenGUI[pos] == NO_GUI ? false : true;
+    }
 
-	protected final boolean isUseGui(int pos) {
-		return screenGUI[pos] == NO_GUI ? false : true;
-	}
+    /**
+     * Return the data associated with the plane that is passed.
+     *
+     * @param from Position from which to start
+     * @param to Position to end
+     * @param plane From which plane to obtain the data
+     * @return Character array containing the data requested
+     */
 
-	/**
-	 * Return the data associated with the plane that is passed.
-	 *
-	 * @param from Position from which to start
-	 * @param to Position to end
-	 * @param plane From which plane to obtain the data
-	 * @return Character array containing the data requested
-	 */
-	protected synchronized char[] getPlaneData(int from, int to, int plane) {
+    protected synchronized char[] getPlaneData(int from, int to, int plane) {
+        int len = (to - from);
+        char[] planeChars = new char[len + 1];
 
-		int len = (to - from);
+        switch (plane) {
+            case PLANE_TEXT:
+                System.arraycopy(screen, from, planeChars, 0, len);
+                break;
 
-		char[] planeChars = new char[len + 1];
+            case PLANE_ATTR:
+                System.arraycopy(screenAttr, from, planeChars, 0, len);
+                break;
 
-		switch (plane) {
-		case PLANE_TEXT:
-			System.arraycopy(screen, from, planeChars, 0, len);
-			break;
-		case PLANE_ATTR:
-			System.arraycopy(screenAttr, from, planeChars, 0, len);
-			break;
-		case PLANE_COLOR:
-			System.arraycopy(screenColor, from, planeChars, 0, len);
-			break;
-		case PLANE_EXTENDED:
-			System.arraycopy(screenExtended, from, planeChars, 0, len);
-			break;
-		case PLANE_EXTENDED_GRAPHIC:
-			System.arraycopy(screenGUI, from, planeChars, 0, len);
-			break;
-		case PLANE_FIELD:
-			System.arraycopy(screenField, from, planeChars, 0, len);
-			break;
-		case PLANE_IS_ATTR_PLACE:
-			System.arraycopy(screenIsAttr, from, planeChars, 0, len);
-			break;
-		default:
-			System.arraycopy(screen, from, planeChars, 0, len);
+            case PLANE_COLOR:
+                System.arraycopy(screenColor, from, planeChars, 0, len);
+                break;
+
+            case PLANE_EXTENDED:
+                System.arraycopy(screenExtended, from, planeChars, 0, len);
+                break;
+
+            case PLANE_EXTENDED_GRAPHIC:
+                System.arraycopy(screenGUI, from, planeChars, 0, len);
+                break;
 
-		}
-		return planeChars;
+            case PLANE_FIELD:
+                System.arraycopy(screenField, from, planeChars, 0, len);
+                break;
 
-	}
+            case PLANE_IS_ATTR_PLACE:
+                System.arraycopy(screenIsAttr, from, planeChars, 0, len);
+                break;
+
+            default:
+                System.arraycopy(screen, from, planeChars, 0, len);
+        }
+
+        return planeChars;
+    }
 
-	/**
-	 * Converts a linear presentation space position to its corresponding row.
-	 *
-	 * @param pos The position to be converted
-	 * @return The row which corresponds to the position given
-	 * @throws OhioException
-	 */
-	private int convertPosToRow(int pos) {
-
-		return (pos / numCols) + 1;
-
-	}
+    /**
+     * Converts a linear presentation space position to its corresponding row.
+     *
+     * @param pos The position to be converted
+     * @return The row which corresponds to the position given
+     * @throws OhioException
+     */
+    private int convertPosToRow(int pos) {
+        return (pos / numCols) + 1;
+    }
 
-	/**
-	 * Converts a linear presentation space position to its corresponding column.
-	 *
-	 * @param pos The position to be converted
-	 * @return The column which corresponds to the position given
-	 * @throws OhioException
-	 */
-	private int convertPosToColumn(int pos) {
-
-		return (pos % numCols) + 1;
+    /**
+     * Converts a linear presentation space position to its corresponding column.
+     *
+     * @param pos The position to be converted
+     * @return The column which corresponds to the position given
+     * @throws OhioException
+     */
+    private int convertPosToColumn(int pos) {
+        return (pos % numCols) + 1;
+    }
 
-	}
-
-	/**
-	 *
-	 * Converts a row and column coordinate to its corresponding linear position.
-	 *
-	 * @param row - The row of the coordinate
-	 * @param col - The column of the coordinate
-	 * @return The linear position which corresponds to the coordinate given.
-	 * @throws OhioException
-	 */
-	private int convertRowColToPos(int row, int col) {
+    /**
+     *
+     * Converts a row and column coordinate to its corresponding linear position.
+     *
+     * @param row - The row of the coordinate
+     * @param col - The column of the coordinate
+     * @return The linear position which corresponds to the coordinate given.
+     * @throws OhioException
+     */
+    private int convertRowColToPos(int row, int col) {
+        return (row - 1) * numCols + col - 1;
+    }
 
 
-		return (row - 1) * numCols + col -1;
-
-	}
-
+    /**
+     * <p>
+     *  GetScreen retrieves the various planes associated with the presentation
+     *  space. The data is returned as a linear array of character values in the
+     *  array provided. The array is not terminated by a null character except
+     *  when data is retrieved from the text plane, in which case a single null
+     *  character is appended.
+     *  </p>
+     *  <p>
+     *  The application must supply a buffer for the returned data and the length
+     *  of the buffer. Data is returned starting from the beginning of the
+     *  presentation space and continuing until the buffer is full or the entire
+     *  plane has been copied. For text plane data, the buffer must include one
+     *  extra position for the terminating null character.
+     *  <p>
+     *
+     * @param buffer
+     * @param bufferLength
+     * @param plane
+     * @return The number of characters copied to the buffer
+     * @throws OhioException
+     */
 
-	/**
-	 * <p>
-	 *  GetScreen retrieves the various planes associated with the presentation
-	 *  space. The data is returned as a linear array of character values in the
-	 *  array provided. The array is not terminated by a null character except
-	 *  when data is retrieved from the text plane, in which case a single null
-	 *  character is appended.
-	 *  </p>
-	 *  <p>
-	 *  The application must supply a buffer for the returned data and the length
-	 *  of the buffer. Data is returned starting from the beginning of the
-	 *  presentation space and continuing until the buffer is full or the entire
-	 *  plane has been copied. For text plane data, the buffer must include one
-	 *  extra position for the terminating null character.
-	 *  <p>
-	 *
-	 * @param buffer
-	 * @param bufferLength
-	 * @param plane
-	 * @return The number of characters copied to the buffer
-	 * @throws OhioException
-	 */
-	public synchronized int GetScreen(char buffer[], int bufferLength, int plane) {
+    public synchronized int GetScreen(char buffer[], int bufferLength, int plane) {
+        return GetScreen(buffer, bufferLength, 0, screenSize, plane);
+    }
 
-		return GetScreen(buffer,bufferLength,0,screenSize,plane);
-
-	}
+    /**
+     * <p>
+     *  GetScreen retrieves the various planes associated with the presentation
+     *  space. The data is returned as a linear array of character values in the
+     *  array provided. The array is not terminated by a null character except
+     *  when data is retrieved from the text plane, in which case a single null
+     *  character is appended.
+     * </p>
+     * <p>
+     * The application must supply a buffer for the returned data and the length
+     * of the buffer. Data is returned starting from the given position and
+     * continuing until the specified number of characters have been copied, the
+     * buffer is full or the entire plane has been copied. For text plane data,
+     * the buffer must include one extra position for the terminating null character.
+     * </p>
+     *
+     * @param buffer
+     * @param bufferLength
+     * @param from
+     * @param length
+     * @param plane
+     * @return The number of characters copied to the buffer
+     * @throws OhioException
+     */
 
-	/**
-	 * <p>
-	 *  GetScreen retrieves the various planes associated with the presentation
-	 *  space. The data is returned as a linear array of character values in the
-	 *  array provided. The array is not terminated by a null character except
-	 *  when data is retrieved from the text plane, in which case a single null
-	 *  character is appended.
-	 * </p>
-	 * <p>
-	 * The application must supply a buffer for the returned data and the length
-	 * of the buffer. Data is returned starting from the given position and
-	 * continuing until the specified number of characters have been copied, the
-	 * buffer is full or the entire plane has been copied. For text plane data,
-	 * the buffer must include one extra position for the terminating null character.
-	 * </p>
-	 *
-	 * @param buffer
-	 * @param bufferLength
-	 * @param from
-	 * @param length
-	 * @param plane
-	 * @return The number of characters copied to the buffer
-	 * @throws OhioException
-	 */
-	public synchronized int GetScreen(char buffer[], int bufferLength, int from,
-			int length, int plane)
-	{
-		//      if(buffer == null)
-		//         throw new OhioException(sessionVT.getSessionConfiguration(),
-		//                     OhioScreen.class.getName(), "osohio.screen.ohio00300", 1);
-		if(buffer == null)
-			return 0;
+    public synchronized int GetScreen(char buffer[], int bufferLength, int from,
+                                      int length, int plane) {
+        //      if(buffer == null)
+        //         throw new OhioException(sessionVT.getSessionConfiguration(),
+        //                     OhioScreen.class.getName(), "osohio.screen.ohio00300", 1);
+        if (buffer == null)
+            return 0;
+
+        int min = Math.min(Math.min(buffer.length, bufferLength), screenSize);
 
-		int min = Math.min(Math.min(buffer.length, bufferLength), screenSize);
-		if ((from + min) > screenSize) {
-			min = screenSize - from;
-		}
+        if ((from + min) > screenSize) {
+            min = screenSize - from;
+        }
+
+        char[] pd = getPlaneData(from, from + min, plane);
+
+        if (pd != null) {
+            System.arraycopy(pd, 0, buffer, 0, min);
+            return pd.length;
+        }
+
+        return 0;
+    }
 
-		char[] pd = getPlaneData(from,from + min,plane);
-		if(pd != null) {
-			System.arraycopy(pd, 0, buffer, 0, min);
-			return pd.length;
-		}
-
-		return 0;
-	}
+    /**
+     * <p>
+     *  GetScreen retrieves the various planes associated with the presentation
+     *  space. The data is returned as a linear array of character values in the
+     *  array provided. The array is not terminated by a null character except
+     *  when data is retrieved from the text plane, in which case a single null
+     *  character is appended.
+     *  </p>
+     *  <p>
+     *  The application must supply a buffer for the returned data and the length
+     *  of the buffer. Data is returned starting from the given coordinates and
+     *  continuing until the specified number of characters have been copied,
+     *  the buffer is full, or the entire plane has been copied. For text plane
+     *  data, the buffer must include one extra position for the terminating null
+     *  character.
+     *  </p>
+     *
+     * @param buffer
+     * @param bufferLength
+     * @param row
+     * @param col
+     * @param length
+     * @param plane
+     * @return The number of characters copied to the buffer.
+     * @throws OhioException
+     */
 
-	/**
-	 * <p>
-	 *  GetScreen retrieves the various planes associated with the presentation
-	 *  space. The data is returned as a linear array of character values in the
-	 *  array provided. The array is not terminated by a null character except
-	 *  when data is retrieved from the text plane, in which case a single null
-	 *  character is appended.
-	 *  </p>
-	 *  <p>
-	 *  The application must supply a buffer for the returned data and the length
-	 *  of the buffer. Data is returned starting from the given coordinates and
-	 *  continuing until the specified number of characters have been copied,
-	 *  the buffer is full, or the entire plane has been copied. For text plane
-	 *  data, the buffer must include one extra position for the terminating null
-	 *  character.
-	 *  </p>
-	 *
-	 * @param buffer
-	 * @param bufferLength
-	 * @param row
-	 * @param col
-	 * @param length
-	 * @param plane
-	 * @return The number of characters copied to the buffer.
-	 * @throws OhioException
-	 */
-	public synchronized int GetScreen(char buffer[], int bufferLength, int row,
-			int col, int length, int plane)
-	//                                       throws OhioException {
-	{
-		// Call GetScreen function after converting row and column to
-		// a position.
-		return GetScreen(buffer,bufferLength, convertRowColToPos(row,col),
-				length, plane);
-	}
+    public synchronized int GetScreen(char buffer[], int bufferLength, int row,
+                                      int col, int length, int plane)
+    //                                       throws OhioException {
+    {
+        // Call GetScreen function after converting row and column to
+        // a position.
+        return GetScreen(buffer, bufferLength, convertRowColToPos(row, col),
+                         length, plane);
+    }
 
-	/**
-	 * <p>
-	 *  GetScreenRect retrieves data from the various planes associated with the
-	 *  presentation space. The data is returned as a linear array of character
-	 *  values in the buffer provided.
-	 *  </p>
-	 *
-	 * <p>
-	 * The application supplies two positions that represent opposing corners of
-	 * a rectangle within the presentation space. The starting and ending
-	 * positions can have any spatial relationship to each other. The data
-	 * returned starts from the row containing the upper-most point to the row
-	 * containing the lower-most point, and from the left-most column to the
-	 * right-most column.
-	 * </p>
-	 * <p>
-	 * The specified buffer must be at least large enough to contain the number
-	 * of characters in the rectangle. If the buffer is too small, no data is
-	 * copied and zero is returned by the method. Otherwise, the method returns
-	 * the number of characters copied.
-	 * </p>
-	 *
-	 * @param buffer
-	 * @param bufferLength
-	 * @param startPos
-	 * @param endPos
-	 * @param plane
-	 * @return The number of characters copied to the buffer
-	 * @throws OhioException
-	 */
-	protected int GetScreenRect(char buffer[], int bufferLength,
-			int startPos, int endPos, int plane)
-	//                                             throws OhioException {
-	{
-		// We will use the row,col routine here because it is easier to use
-		// row colum than it is for position since I wrote the other first and
-		// am to lazy to implement it here
-		// Maybe it would be faster to do it the other way?
-		int startRow = convertPosToRow(startPos);
-		int startCol = convertPosToColumn(startPos);
-		int endRow = convertPosToRow(endPos);
-		int endCol = convertPosToColumn(endPos);
-		return GetScreenRect(buffer, bufferLength, startRow, startCol,
-				endRow, endCol, plane);
+    /**
+     * <p>
+     *  GetScreenRect retrieves data from the various planes associated with the
+     *  presentation space. The data is returned as a linear array of character
+     *  values in the buffer provided.
+     *  </p>
+     *
+     * <p>
+     * The application supplies two positions that represent opposing corners of
+     * a rectangle within the presentation space. The starting and ending
+     * positions can have any spatial relationship to each other. The data
+     * returned starts from the row containing the upper-most point to the row
+     * containing the lower-most point, and from the left-most column to the
+     * right-most column.
+     * </p>
+     * <p>
+     * The specified buffer must be at least large enough to contain the number
+     * of characters in the rectangle. If the buffer is too small, no data is
+     * copied and zero is returned by the method. Otherwise, the method returns
+     * the number of characters copied.
+     * </p>
+     *
+     * @param buffer
+     * @param bufferLength
+     * @param startPos
+     * @param endPos
+     * @param plane
+     * @return The number of characters copied to the buffer
+     * @throws OhioException
+     */
+    protected int GetScreenRect(char buffer[], int bufferLength,
+                                int startPos, int endPos, int plane)
+    //                                             throws OhioException {
+    {
+        // We will use the row,col routine here because it is easier to use
+        // row colum than it is for position since I wrote the other first and
+        // am to lazy to implement it here
+        // Maybe it would be faster to do it the other way?
+        int startRow = convertPosToRow(startPos);
+        int startCol = convertPosToColumn(startPos);
+        int endRow = convertPosToRow(endPos);
+        int endCol = convertPosToColumn(endPos);
+        return GetScreenRect(buffer, bufferLength, startRow, startCol,
+                             endRow, endCol, plane);
+    }
 
-	}
+    /**
+     * <p>
+     *  GetScreenRect retrieves data from the various planes associated with the
+     *  presentation space. The data is returned as a linear array of character
+     *  values in the buffer provided. The buffer is not terminated by a null
+     *  character.
+     * </p>
+     * <p>
+     * The application supplies two coordinates that represent opposing corners
+     * of a rectangle within the presentation space. The starting and ending
+     * coordinates can have any spatial relationship to each other. The data
+     * returned starts from the row containing the upper-most point to the row
+     * containing the lower-most point, and from the left-most column to the
+     * right-most column.
+     * </p>
+     * <p>
+     * The specified buffer must be at least large enough to contain the number
+     * of characters in the rectangle. If the buffer is too small, no data is
+     * copied and zero is returned by the method. Otherwise, the method returns
+     * the number of characters copied.
+     * </p>
+     *
+     * @param buffer
+     * @param bufferLength
+     * @param startRow
+     * @param startCol
+     * @param endRow
+     * @param endCol
+     * @param plane
+     * @return The number characters copied to the buffer
+     * @throws OhioException
+     */
+    protected int GetScreenRect(char buffer[], int bufferLength,
+                                int startRow, int startCol,
+                                int endRow, int endCol, int plane)
+    //                                             throws OhioException {
+    {
+        // number of bytes obtained
+        int numBytes = 0;
 
-	/**
-	 * <p>
-	 *  GetScreenRect retrieves data from the various planes associated with the
-	 *  presentation space. The data is returned as a linear array of character
-	 *  values in the buffer provided. The buffer is not terminated by a null
-	 *  character.
-	 * </p>
-	 * <p>
-	 * The application supplies two coordinates that represent opposing corners
-	 * of a rectangle within the presentation space. The starting and ending
-	 * coordinates can have any spatial relationship to each other. The data
-	 * returned starts from the row containing the upper-most point to the row
-	 * containing the lower-most point, and from the left-most column to the
-	 * right-most column.
-	 * </p>
-	 * <p>
-	 * The specified buffer must be at least large enough to contain the number
-	 * of characters in the rectangle. If the buffer is too small, no data is
-	 * copied and zero is returned by the method. Otherwise, the method returns
-	 * the number of characters copied.
-	 * </p>
-	 *
-	 * @param buffer
-	 * @param bufferLength
-	 * @param startRow
-	 * @param startCol
-	 * @param endRow
-	 * @param endCol
-	 * @param plane
-	 * @return The number characters copied to the buffer
-	 * @throws OhioException
-	 */
-	protected int GetScreenRect(char buffer[], int bufferLength,
-			int startRow, int startCol,
-			int endRow, int endCol, int plane)
-	//                                             throws OhioException {
-	{
-		// number of bytes obtained
-		int numBytes = 0;
+        // lets check the row range.  If they are reversed then we need to
+        // place them in the correct order.
+        if (startRow > endRow) {
+            int r = startRow;
+            startRow = endRow;
+            endRow = r;
+        }
 
-		// lets check the row range.  If they are reversed then we need to
-		// place them in the correct order.
-		if(startRow > endRow) {
-			int r = startRow;
-			startRow = endRow;
-			endRow = r;
-		}
-		// lets check the column range.  If they are reversed then we need to
-		// place them in the correct order.
-		if(startCol > endCol) {
-			int c = startCol;
-			startCol = endCol;
-			endCol = c;
-		}
-		int numCols = (endCol - startCol) + 1;
-		int numRows = (endRow - startRow) + 1;
+        // lets check the column range.  If they are reversed then we need to
+        // place them in the correct order.
+        if (startCol > endCol) {
+            int c = startCol;
+            startCol = endCol;
+            endCol = c;
+        }
 
-		// lets make sure it is within the bounds of the character array passed
-		//  if not the return as zero bytes where read as per documentation.
-		if(numCols * numRows <= bufferLength) {
+        int numCols = (endCol - startCol) + 1;
+        int numRows = (endRow - startRow) + 1;
+
+        // lets make sure it is within the bounds of the character array passed
+        //  if not the return as zero bytes where read as per documentation.
+        if (numCols * numRows <= bufferLength) {
+            // make sure it is one larger.  I guess for other languanges to
+            // reference like in C which is terminated by a zero byte at the end
+            // of strings.
+            char cb[] = new char[numCols + 1];
+            int charOffset = 0;
+            int bytes = 0;
 
-			// make sure it is one larger.  I guess for other languanges to
-			// reference like in C which is terminated by a zero byte at the end
-			// of strings.
-			char cb[] = new char[numCols + 1];
-			int charOffset = 0;
-			int bytes = 0;
+            // now let's loop through and get the screen information for
+            //  each row;
+            for (int row = startRow; row <= endRow;) {
+                if ((bytes = GetScreen(cb, cb.length, row, startCol, numCols, plane)) != 0) {
+                    System.arraycopy(cb, 0, buffer, charOffset, numCols);
+                }
 
-			// now let's loop through and get the screen information for
-			//  each row;
-			for(int row = startRow; row <= endRow;) {
-				if((bytes = GetScreen(cb, cb.length, row, startCol, numCols, plane)) != 0) {
-					System.arraycopy(cb, 0, buffer, charOffset, numCols);
-				}
-				row++;
-				charOffset += numCols;
-				// make sure we count the number of bytes returned
-				numBytes += bytes;
-			}
+                row++;
+                charOffset += numCols;
+                // make sure we count the number of bytes returned
+                numBytes += bytes;
+            }
+        }
+
+        return numBytes;
+    }
 
-		}
-
-		return numBytes;
-	}
+    private int isOption(char[] screen,
+                         int x,
+                         int lenScreen,
+                         int numPref,
+                         int numSuff,
+                         char suff) {
+        boolean hs = true;
+        int sp = x;
+        int os = 0;
 
-	private int isOption(char[] screen,
-			int x,
-			int lenScreen,
-			int numPref,
-			int numSuff,
-			char suff) {
-		boolean hs =true;
-		int sp = x;
-		int os = 0;
-		// check to the left for option
-		while (--sp >=0 &&  screen[sp] <= ' ' ) {
+        // check to the left for option
+        while (--sp >= 0 &&  screen[sp] <= ' ') {
+            if (x - sp > numPref || screen[sp] == suff ||
+                    screen[sp] == '.' ||
+                    screen[sp] == '*') {
+                hs = false;
+                break;
+            }
+        }
+
+        // now lets check for how long the option is it has to be numPref or less
+        os = sp;
 
-			if (x - sp > numPref || screen[sp] == suff||
-					screen[sp] == '.' ||
-					screen[sp] == '*') {
-				hs =false;
-				break;
-			}
-		}
+        while (hs && --os > 0 && screen[os] > ' ') {
+            if (sp - os >= numPref || screen[os] == suff ||
+                    screen[os] == '.' ||
+                    screen[os] == '*') {
+                hs = false;
+                break;
+            }
+        }
 
-		// now lets check for how long the option is it has to be numPref or less
-		os = sp;
-		while (hs && --os > 0 && screen[os] > ' ' ) {
+        if (sp - os > 1 && !Character.isDigit(screen[os + 1])) {
+            hs = false;
+        }
 
-			if (sp - os >= numPref || screen[os] == suff ||
-					screen[os] == '.' ||
-					screen[os] == '*') {
-				hs = false;
-				break;
-			}
-		}
-		if (sp - os > 1 && !Character.isDigit(screen[os+1])) {
-			hs = false;
-		}
+        sp = x;
 
-		sp = x;
+        if (Character.isDigit(screen[sp + 1]))
+            hs = false;
 
-		if (Character.isDigit(screen[sp+1]))
-			hs = false;
-		// now lets make sure there are no more than numSuff spaces after option
-		while (hs && (++sp < lenScreen && screen[sp] <= ' '
-			|| screen[sp] == suff )) {
-			if (sp - x >= numSuff || screen[sp] == suff ||
-					screen[sp] == '.' ||
-					screen[sp] == '*') {
-				hs =false;
-				break;
-			}
-		}
-		if (hs && !Character.isLetterOrDigit(screen[sp]))
-			hs = false;
-		if (hs) {
-			return os;
-		}
-		return -1;
-	}
+        // now lets make sure there are no more than numSuff spaces after option
+        while (hs && (++sp < lenScreen && screen[sp] <= ' '
+                      || screen[sp] == suff)) {
+            if (sp - x >= numSuff || screen[sp] == suff ||
+                    screen[sp] == '.' ||
+                    screen[sp] == '*') {
+                hs = false;
+                break;
+            }
+        }
+
+        if (hs && !Character.isLetterOrDigit(screen[sp]))
+            hs = false;
+
+        if (hs) {
+            return os;
+        }
+
+        return -1;
+    }
 
 }
\ No newline at end of file