line source
+ − /*
+ − * Title: Screen5250.java
+ − * Copyright: Copyright (c) 2001 - 2004
+ − * Company:
+ − * @author Kenneth J. Pouncey
+ − * @version 0.5
+ − *
+ − * Description:
+ − *
+ − * 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, 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 software; see the file COPYING. If not, write to
+ − * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ − * Boston, MA 02111-1307 USA
+ − *
+ − */
+ − package org.tn5250j.framework.tn5250;
+ −
+ − import static org.tn5250j.TN5250jConstants.*;
+ −
+ − import java.text.DecimalFormat;
+ − import java.text.DecimalFormatSymbols;
+ − import java.text.NumberFormat;
+ − import java.text.ParseException;
+ − import java.util.Vector;
+ −
+ − import org.tn5250j.TN5250jConstants;
+ −
+ − import android.util.Log;
+ − import de.mud.terminal.VDUBuffer;
+ − import de.mud.terminal.vt320;
+ − import com.five_ten_sg.connectbot.service.FontSizeChangedListener;
+ −
+ −
+ − public class Screen5250 implements FontSizeChangedListener {
+ − private static final String TAG = "Screen5250";
+ − private ScreenFields screenFields;
+ − private int lastAttr;
+ − private int lastPos;
+ − private int lenScreen;
+ − private KeyStrokenizer strokenizer;
+ − private tnvt sessionVT;
+ − private vt320 buffer; // used to draw the screen
+ − private int numRows = 0;
+ − private int numCols = 0;
+ − protected static final int initAttr = 32;
+ − protected static final char initChar = 0;
+ − public boolean cursorActive = false;
+ − public boolean cursorShown = false;
+ − protected boolean insertMode = false;
+ − private boolean keyProcessed = false;
+ − private Rect dirtyScreen = new Rect();
+ −
+ − public int homePos = 0;
+ − public int saveHomePos = 0;
+ − private String bufferedKeys;
+ − public boolean pendingInsert = false;
+ −
+ − public final static byte STATUS_SYSTEM = 1;
+ − public final static byte STATUS_ERROR_CODE = 2;
+ − public final static byte STATUS_VALUE_ON = 1;
+ − public final static byte STATUS_VALUE_OFF = 2;
+ −
+ − private StringBuffer hsMore = new StringBuffer("More...");
+ − private StringBuffer hsBottom = new StringBuffer("Bottom");
+ −
+ − // error codes to be sent to the host on an error
+ − private final static int ERR_CURSOR_PROTECTED = 0x05;
+ − private final static int ERR_INVALID_SIGN = 0x11;
+ − private final static int ERR_NO_ROOM_INSERT = 0x12;
+ − private final static int ERR_NUMERIC_ONLY = 0x09;
+ − private final static int ERR_DUP_KEY_NOT_ALLOWED = 0x19;
+ − private final static int ERR_NUMERIC_09 = 0x10;
+ − private final static int ERR_FIELD_MINUS = 0x16;
+ − private final static int ERR_FIELD_EXIT_INVALID = 0x18;
+ − private final static int ERR_ENTER_NO_ALLOWED = 0x20;
+ − private final static int ERR_MANDITORY_ENTER = 0x21;
+ −
+ − private boolean guiInterface = false;
+ − private boolean resetRequired = false;
+ − private boolean backspaceError = true;
+ − private boolean feError;
+ −
+ − // Operator Information Area
+ − private ScreenOIA oia;
+ −
+ − // screen planes
+ − protected ScreenPlanes planes;
+ −
+ −
+ −
+ − public Screen5250() {
+ − try {
+ − jbInit();
+ − }
+ − catch (Exception ex) {
+ − Log.w(TAG, "In constructor: ", ex);
+ − }
+ − }
+ −
+ − void jbInit() throws Exception {
+ − lastAttr = 32;
+ − // default number of rows and columns
+ − numRows = 24;
+ − numCols = 80;
+ − setCursor(1, 1); // set initial cursor position
+ − oia = new ScreenOIA(this);
+ − oia.setKeyBoardLocked(true);
+ − lenScreen = numRows * numCols;
+ − planes = new ScreenPlanes(this, numRows);
+ − screenFields = new ScreenFields(this);
+ − strokenizer = new KeyStrokenizer();
+ − }
+ −
+ − protected ScreenPlanes getPlanes() {
+ − return planes;
+ − }
+ −
+ − public final ScreenOIA getOIA() {
+ − return oia;
+ − }
+ −
+ − protected final void setRowsCols(int rows, int cols) {
+ − int oldRows = numRows;
+ − int oldCols = numCols;
+ − // default number of rows and columns
+ − numRows = rows;
+ − numCols = cols;
+ − lenScreen = numRows * numCols;
+ − planes.setSize(rows);
+ −
+ − // If they are not the same then we need to inform the listeners that
+ − // the size changed.
+ − if (oldRows != numRows || oldCols != numCols)
+ − fireScreenSizeChanged();
+ − }
+ −
+ −
+ − public boolean isCursorActive() {
+ − return cursorActive;
+ − }
+ −
+ − public boolean isCursorShown() {
+ − return cursorShown;
+ − }
+ −
+ − public void setUseGUIInterface(boolean gui) {
+ − guiInterface = gui;
+ − }
+ −
+ − public void toggleGUIInterface() {
+ − guiInterface = !guiInterface;
+ − }
+ −
+ − public void setResetRequired(boolean reset) {
+ − resetRequired = reset;
+ − }
+ −
+ − public void setBackspaceError(boolean onError) {
+ − backspaceError = onError;
+ − }
+ −
+ − /**
+ − * Copy & Paste support
+ − *
+ − * @see {@link #pasteText(String, boolean)}
+ − * @see {@link #copyTextField(int)}
+ − */
+ − public final String copyText(Rect area) {
+ − StringBuilder sb = new StringBuilder();
+ − Rect workR = new Rect();
+ − workR.setBounds(area);
+ − Log.d(TAG, "Copying " + workR);
+ − // loop through all the screen characters to send them to the clip board
+ − int m = workR.x;
+ − int i = 0;
+ − int t = 0;
+ −
+ − while (workR.height-- > 0) {
+ − t = workR.width;
+ − i = workR.y;
+ −
+ − while (t-- > 0) {
+ − // only copy printable characters (in this case >= ' ')
+ − char c = planes.getChar(getPos(m - 1, i - 1));
+ −
+ − if (c >= ' ' && (planes.screenExtended[getPos(m - 1, i - 1)] & EXTENDED_5250_NON_DSP)
+ − == 0)
+ − sb.append(c);
+ − else
+ − sb.append(' ');
+ −
+ − i++;
+ − }
+ −
+ − sb.append('\n');
+ − m++;
+ − }
+ −
+ − return sb.toString();
+ − }
+ −
+ − /**
+ − * Copy & Paste support
+ − *
+ − * @param content
+ − * @see {@link #copyText(Rectangle)}
+ − */
+ − public final void pasteText(String content, boolean special) {
+ − Log.d(TAG, "Pasting, special:" + special);
+ − setCursorActive(false);
+ − StringBuilder sb = new StringBuilder(content);
+ − StringBuilder pd = new StringBuilder();
+ − // character counters within the string to be pasted.
+ − int nextChar = 0;
+ − int nChars = sb.length();
+ − int lr = getRow(lastPos);
+ − int lc = getCol(lastPos);
+ − resetDirty(lastPos);
+ − int cpos = lastPos;
+ − int length = getScreenLength();
+ − char c = 0;
+ − boolean setIt;
+ − // save our current place within the FFT.
+ − screenFields.saveCurrentField();
+ −
+ − for (int x = nextChar; x < nChars; x++) {
+ − c = sb.charAt(x);
+ −
+ − if ((c == '\n') || (c == '\r')) {
+ − Log.i(TAG, "pasted cr-lf>" + pd + "<");
+ − pd.setLength(0);
+ − // if we read in a cr lf in the data stream we need to go
+ − // to the starting column of the next row and start from there
+ − cpos = getPos(getRow(cpos) + 1, lc);
+ −
+ − // If we go paste the end of the screen then let's start over from
+ − // the beginning of the screen space.
+ − if (cpos > length)
+ − cpos = 0;
+ − }
+ − else {
+ − // we will default to set the character always.
+ − setIt = true;
+ −
+ − // If we are in a special paste scenario then we check for valid
+ − // characters to paste.
+ − if (special && (!Character.isLetter(c) && !Character.isDigit(c)))
+ − setIt = false;
+ −
+ − // we will only push a character to the screen space if we are in
+ − // a field
+ − if (isInField(cpos) && setIt) {
+ − planes.setChar(cpos, c);
+ − setDirty(cpos);
+ − screenFields.setCurrentFieldMDT();
+ − }
+ −
+ − // If we placed a character then we go to the next position.
+ − if (setIt)
+ − cpos++;
+ −
+ − // we will append the information to our debug buffer.
+ − pd.append(c);
+ − }
+ − }
+ −
+ − // if we have anything else not logged then log it out.
+ − if (pd.length() > 0)
+ − Log.i(TAG, "pasted >" + pd + "<");
+ −
+ − // restore out position within the FFT.
+ − screenFields.restoreCurrentField();
+ − updateDirty();
+ − // restore our cursor position.
+ − setCursor(lr + 1, lc + 1);
+ − setCursorActive(true);
+ − }
+ −
+ − /**
+ − * Copy & Paste support
+ − *
+ − * @param position
+ − * @return
+ − * @see {@link #copyText(int)}
+ − */
+ − public final String copyTextField(int position) {
+ − screenFields.saveCurrentField();
+ − isInField(position);
+ − String result = screenFields.getCurrentFieldText();
+ − screenFields.restoreCurrentField();
+ − return result;
+ − }
+ −
+ − /**
+ − *
+ − * Copy & Paste end code
+ − *
+ − */
+ −
+ − /**
+ − * Sum them
+ − *
+ − * @param which
+ − * formatting option to use
+ − * @return vector string of numberic values
+ − */
+ − public final Vector<Double> sumThem(boolean which, Rect area) {
+ − StringBuilder sb = new StringBuilder();
+ − Rect workR = new Rect();
+ − workR.setBounds(area);
+ − // gui.rubberband.reset();
+ − // gui.repaint();
+ − Log.d(TAG, "Summing");
+ − // obtain the decimal format for parsing
+ − DecimalFormat df = (DecimalFormat) NumberFormat.getInstance();
+ − DecimalFormatSymbols dfs = df.getDecimalFormatSymbols();
+ −
+ − if (which) {
+ − dfs.setDecimalSeparator('.');
+ − dfs.setGroupingSeparator(',');
+ − }
+ − else {
+ − dfs.setDecimalSeparator(',');
+ − dfs.setGroupingSeparator('.');
+ − }
+ −
+ − df.setDecimalFormatSymbols(dfs);
+ − Vector<Double> sumVector = new Vector<Double>();
+ − // loop through all the screen characters to send them to the clip board
+ − int m = workR.x;
+ − int i = 0;
+ − int t = 0;
+ − double sum = 0.0;
+ −
+ − while (workR.height-- > 0) {
+ − t = workR.width;
+ − i = workR.y;
+ −
+ − while (t-- > 0) {
+ − // only copy printable numeric characters (in this case >= ' ')
+ − // char c = screen[getPos(m - 1, i - 1)].getChar();
+ − char c = planes.getChar(getPos(m - 1, i - 1));
+ − // if (((c >= '0' && c <= '9') || c == '.' || c == ',' || c == '-')
+ − // && !screen[getPos(m - 1, i - 1)].nonDisplay) {
+ −
+ − // TODO: update me here to implement the nonDisplay check as well
+ − if (((c >= '0' && c <= '9') || c == '.' || c == ',' || c == '-')) {
+ − sb.append(c);
+ − }
+ −
+ − i++;
+ − }
+ −
+ − if (sb.length() > 0) {
+ − if (sb.charAt(sb.length() - 1) == '-') {
+ − sb.insert(0, '-');
+ − sb.deleteCharAt(sb.length() - 1);
+ − }
+ −
+ − try {
+ − Number n = df.parse(sb.toString());
+ − // System.out.println(s + " " + n.doubleValue());
+ − sumVector.add(new Double(n.doubleValue()));
+ − sum += n.doubleValue();
+ − }
+ − catch (ParseException pe) {
+ − Log.w(TAG, pe.getMessage() + " at "
+ − + pe.getErrorOffset());
+ − }
+ − }
+ −
+ − sb.setLength(0);
+ − m++;
+ − }
+ −
+ − Log.d(TAG, "" + sum);
+ − return sumVector;
+ − }
+ −
+ − /**
+ − * This will move the screen cursor based on the mouse event.
+ − *
+ − * I do not think the checks here for the gui characters should be here but
+ − * will leave them here for now until we work out the interaction. This
+ − * should be up to the gui frontend in my opinion.
+ − *
+ − * @param pos
+ − */
+ − public boolean moveCursor(int pos) {
+ − if (!oia.isKeyBoardLocked()) {
+ − if (pos < 0)
+ − return false;
+ −
+ − // because getRowColFromPoint returns offset of 1,1 we need to
+ − // translate to offset 0,0
+ − // pos -= (numCols + 1);
+ − int g = planes.getWhichGUI(pos);
+ −
+ − // lets check for hot spots
+ − if (g >= BUTTON_LEFT && g <= BUTTON_LAST) {
+ − StringBuffer aid = new StringBuffer();
+ − boolean aidFlag = true;
+ −
+ − switch (g) {
+ − case BUTTON_RIGHT:
+ − case BUTTON_MIDDLE:
+ − while (planes.getWhichGUI(--pos) != BUTTON_LEFT) {
+ − }
+ −
+ − case BUTTON_LEFT:
+ − if (planes.getChar(pos) == 'F') {
+ − pos++;
+ − }
+ − else
+ − aidFlag = false;
+ −
+ − if (planes.getChar(pos + 1) != '='
+ − && planes.getChar(pos + 1) != '.'
+ − && planes.getChar(pos + 1) != '/') {
+ − Log.d(TAG, " Hotspot clicked!!! we will send characters "
+ − + planes.getChar(pos) + " " + planes.getChar(pos + 1));
+ − aid.append(planes.getChar(pos));
+ − aid.append(planes.getChar(pos + 1));
+ − }
+ − else {
+ − Log.d(TAG, " Hotspot clicked!!! we will send character "
+ − + planes.getChar(pos));
+ − aid.append(planes.getChar(pos));
+ − }
+ −
+ − break;
+ − }
+ −
+ − if (aidFlag) {
+ − switch (g) {
+ − case BUTTON_LEFT_UP:
+ − case BUTTON_MIDDLE_UP:
+ − case BUTTON_RIGHT_UP:
+ − case BUTTON_ONE_UP:
+ − case BUTTON_SB_UP:
+ − case BUTTON_SB_GUIDE:
+ − sessionVT.sendAidKey(AID_ROLL_UP);
+ − break;
+ −
+ − case BUTTON_LEFT_DN:
+ − case BUTTON_MIDDLE_DN:
+ − case BUTTON_RIGHT_DN:
+ − case BUTTON_ONE_DN:
+ − case BUTTON_SB_DN:
+ − case BUTTON_SB_THUMB:
+ − sessionVT.sendAidKey(AID_ROLL_DOWN);
+ − break;
+ −
+ − case BUTTON_LEFT_EB:
+ − case BUTTON_MIDDLE_EB:
+ − case BUTTON_RIGHT_EB:
+ − StringBuffer eb = new StringBuffer();
+ −
+ − while (planes.getWhichGUI(pos--) != BUTTON_LEFT_EB)
+ − ;
+ −
+ − while (planes.getWhichGUI(pos++) != BUTTON_RIGHT_EB) {
+ − eb.append(planes.getChar(pos));
+ − }
+ −
+ − sessionVT.showURL(eb.toString());
+ − // take out the log statement when we are sure it is
+ − // working
+ − Log.i(TAG, "Send to external Browser: " + eb.toString());
+ − break;
+ −
+ − default:
+ − int aidKey = Integer.parseInt(aid.toString());
+ −
+ − if (aidKey >= 1 && aidKey <= 12)
+ − sessionVT.sendAidKey(0x30 + aidKey);
+ −
+ − if (aidKey >= 13 && aidKey <= 24)
+ − sessionVT.sendAidKey(0xB0 + (aidKey - 12));
+ − }
+ − }
+ − else {
+ − if (screenFields.getCurrentField() != null) {
+ − int xPos = screenFields.getCurrentField().startPos();
+ −
+ − for (int x = 0; x < aid.length(); x++) {
+ − // System.out.println(sr + "," + (sc + x) + " " +
+ − // aid.charAt(x));
+ − planes.setChar(xPos + x , aid.charAt(x));
+ − }
+ −
+ − // System.out.println(aid);
+ − screenFields.setCurrentFieldMDT();
+ − sessionVT.sendAidKey(AID_ENTER);
+ − }
+ − }
+ −
+ − // return back to the calling routine that the cursor was not moved
+ − // but something else here was done like aid keys or the such
+ − return false;
+ − }
+ −
+ − // this is a note to not execute this code here when we
+ − // implement
+ − // the remain after edit function option.
+ − // if (gui.rubberband.isAreaSelected()) {
+ − // gui.rubberband.reset();
+ − // gui.repaint();
+ − // } else {
+ − goto_XY(pos);
+ − isInField();
+ − // return back to the calling object that the cursor was indeed
+ − // moved with in the screen object
+ − return true;
+ − // }
+ − }
+ −
+ − return false;
+ − }
+ −
+ − public void setVT(tnvt v) {
+ − sessionVT = v;
+ − }
+ −
+ − public void setBuffer(vt320 buffer) {
+ − this.buffer = buffer;
+ − }
+ −
+ − /**
+ − * converts mnemonic string values into aid integers
+ − *
+ − * @see #sendKeys
+ − * @param mnem string mnemonic value
+ − * @return key value of Mnemonic
+ − */
+ − private int getMnemonicValue(String mnem) {
+ − if (mnemonicMap.containsKey(mnem)) return mnemonicMap.get(mnem);
+ −
+ − return 0;
+ − }
+ −
+ − protected void setPrehelpState(boolean setErrorCode, boolean lockKeyboard,
+ − boolean unlockIfLocked) {
+ − if (oia.isKeyBoardLocked() && unlockIfLocked)
+ − oia.setKeyBoardLocked(false);
+ − else
+ − oia.setKeyBoardLocked(lockKeyboard);
+ −
+ − bufferedKeys = null;
+ − oia.setKeysBuffered(false);
+ − }
+ −
+ − /**
+ − * Activate the cursor on screen
+ − *
+ − * @param activate
+ − */
+ − public void setCursorActive(boolean activate) {
+ − // System.out.println("cursor active " + updateCursorLoc + " " +
+ − // cursorActive + " " + activate);
+ − if (cursorActive && !activate) {
+ − setCursorOff();
+ − cursorActive = activate;
+ − }
+ − else {
+ − if (!cursorActive && activate) {
+ − cursorActive = activate;
+ − setCursorOn();
+ − }
+ − }
+ − }
+ −
+ − /**
+ − * Set the cursor on
+ − */
+ − public void setCursorOn() {
+ − cursorShown = true;
+ − updateCursorLoc();
+ − }
+ −
+ − /**
+ − * Set the cursor off
+ − */
+ − public void setCursorOff() {
+ − cursorShown = false;
+ − updateCursorLoc();
+ − // System.out.println("cursor off " + updateCursorLoc + " " +
+ − // cursorActive);
+ − }
+ −
+ − /**
+ − *
+ − */
+ − private void updateCursorLoc() {
+ − if (cursorActive) {
+ − fireCursorChanged();
+ − }
+ − }
+ −
+ − /**
+ − * The sendKeys method sends a string of keys to the virtual screen. This
+ − * method acts as if keystrokes were being typed from the keyboard. The
+ − * keystrokes will be sent to the location given. The string being passed
+ − * can also contain mnemonic values such as [enter] enter key,[tab] tab key,
+ − * [pf1] pf1 etc...
+ − *
+ − * These will be processed as if you had pressed these keys from the
+ − * keyboard. All the valid special key values are contained in the MNEMONIC
+ − * enumeration:
+ − *
+ − * <table BORDER COLS=2 WIDTH="50%" >
+ − *
+ − * <tr>
+ − * <td>MNEMONIC_CLEAR</td>
+ − * <td>[clear]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_ENTER</td>
+ − * <td>[enter]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_HELP</td>
+ − * <td>[help]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PAGE_DOWN</td>
+ − * <td>[pgdown]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PAGE_UP</td>
+ − * <td>[pgup]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PRINT</td>
+ − * <td>[print]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF1</td>
+ − * <td>[pf1]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF2</td>
+ − * <td>[pf2]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF3</td>
+ − * <td>[pf3]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF4</td>
+ − * <td>[pf4]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF5</td>
+ − * <td>[pf5]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF6</td>
+ − * <td>[pf6]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF7</td>
+ − * <td>[pf7]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF8</td>
+ − * <td>[pf8]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF9</td>
+ − * <td>[pf9]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF10</td>
+ − * <td>[pf10]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF11</td>
+ − * <td>[pf11]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF12</td>
+ − * <td>[pf12]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF13</td>
+ − * <td>[pf13]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF14</td>
+ − * <td>[pf14]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF15</td>
+ − * <td>[pf15]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF16</td>
+ − * <td>[pf16]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF17</td>
+ − * <td>[pf17]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF18</td>
+ − * <td>[pf18]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF19</td>
+ − * <td>[pf19]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF20</td>
+ − * <td>[pf20]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF21</td>
+ − * <td>[pf21]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF22</td>
+ − * <td>[pf22]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF23</td>
+ − * <td>[pf23]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PF24</td>
+ − * <td>[pf24]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_BACK_SPACE</td>
+ − * <td>[backspace]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_BACK_TAB</td>
+ − * <td>[backtab]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_UP</td>
+ − * <td>[up]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_DOWN</td>
+ − * <td>[down]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_LEFT</td>
+ − * <td>[left]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_RIGHT</td>
+ − * <td>[right]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_DELETE</td>
+ − * <td>[delete]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_TAB</td>
+ − * <td>"[tab]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_END_OF_FIELD</td>
+ − * <td>[eof]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_ERASE_EOF</td>
+ − * <td>[eraseeof]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_ERASE_FIELD</td>
+ − * <td>[erasefld]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_INSERT</td>
+ − * <td>[insert]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_HOME</td>
+ − * <td>[home]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_KEYPAD0</td>
+ − * <td>[keypad0]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_KEYPAD1</td>
+ − * <td>[keypad1]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_KEYPAD2</td>
+ − * <td>[keypad2]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_KEYPAD3</td>
+ − * <td>[keypad3]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_KEYPAD4</td>
+ − * <td>[keypad4]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_KEYPAD5</td>
+ − * <td>[keypad5]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_KEYPAD6</td>
+ − * <td>[keypad6]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_KEYPAD7</td>
+ − * <td>[keypad7]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_KEYPAD8</td>
+ − * <td>[keypad8]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_KEYPAD9</td>
+ − * <td>[keypad9]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_KEYPAD_PERIOD</td>
+ − * <td>[keypad.]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_KEYPAD_COMMA</td>
+ − * <td>[keypad,]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_KEYPAD_MINUS</td>
+ − * <td>[keypad-]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_FIELD_EXIT</td>
+ − * <td>[fldext]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_FIELD_PLUS</td>
+ − * <td>[field+]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_FIELD_MINUS</td>
+ − * <td>[field-]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_BEGIN_OF_FIELD</td>
+ − * <td>[bof]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PA1</td>
+ − * <td>[pa1]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PA2</td>
+ − * <td>[pa2]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_PA3</td>
+ − * <td>[pa3]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_SYSREQ</td>
+ − * <td>[sysreq]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_RESET</td>
+ − * <td>[reset]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_ATTN</td>
+ − * <td>[attn]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_MARK_LEFT</td>
+ − * <td>[markleft]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_MARK_RIGHT</td>
+ − * <td>[markright]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_MARK_UP</td>
+ − * <td>[markup]</td>
+ − * </tr>
+ − * <tr>
+ − * <td>MNEMONIC_MARK_DOWN</td>
+ − * <td>[markdown]</td>
+ − * </tr>
+ − *
+ − * </table>
+ − *
+ − * @param text
+ − * The string of characters to be sent
+ − *
+ − * @see #sendAid
+ − *
+ − */
+ −
+ − public synchronized void sendKeys(String text) {
+ − if (isStatusErrorCode() && !resetRequired) {
+ − setCursorActive(false);
+ − simulateMnemonic(getMnemonicValue("[reset]"));
+ − setCursorActive(true);
+ − }
+ −
+ − if (oia.isKeyBoardLocked()) {
+ − if (text.equals("[reset]") || text.equals("[sysreq]")
+ − || text.equals("[attn]")) {
+ − setCursorActive(false);
+ − simulateMnemonic(getMnemonicValue(text));
+ − setCursorActive(true);
+ − }
+ − else {
+ − if (isStatusErrorCode()) {
+ − sessionVT.signalBell();
+ − return;
+ − }
+ −
+ − oia.setKeysBuffered(true);
+ −
+ − if (bufferedKeys == null) bufferedKeys = text;
+ − else bufferedKeys += text;
+ −
+ − return;
+ − }
+ − }
+ − else {
+ − if (oia.isKeysBuffered()) {
+ − if (bufferedKeys != null) {
+ − text = bufferedKeys + text;
+ − }
+ −
+ − oia.setKeysBuffered(false);
+ − bufferedKeys = null;
+ − }
+ −
+ − isInField();
+ −
+ − if (text.length() == 1 && !text.equals("[") && !text.equals("]")) {
+ − setCursorActive(false);
+ − simulateKeyStroke(text.charAt(0));
+ − setCursorActive(true);
+ − }
+ − else {
+ − strokenizer.setKeyStrokes(text);
+ − String s;
+ − boolean done = false;
+ − // setCursorOff2();
+ − setCursorActive(false);
+ −
+ − while (!done) {
+ − if (strokenizer.hasMoreKeyStrokes()) {
+ − isInField();
+ − s = strokenizer.nextKeyStroke();
+ −
+ − if (s.length() == 1) {
+ − simulateKeyStroke(s.charAt(0));
+ − }
+ − else {
+ − simulateMnemonic(getMnemonicValue(s));
+ − }
+ −
+ − if (oia.isKeyBoardLocked()) {
+ − bufferedKeys = strokenizer
+ − .getUnprocessedKeyStroked();
+ −
+ − if (bufferedKeys != null) {
+ − oia.setKeysBuffered(true);
+ − }
+ −
+ − done = true;
+ − }
+ − }
+ − else {
+ − done = true;
+ − }
+ − }
+ −
+ − setCursorActive(true);
+ − }
+ − }
+ − }
+ −
+ − /**
+ − * The sendAid method sends an "aid" keystroke to the virtual screen. These
+ − * aid keys can be thought of as special keystrokes, like the Enter key,
+ − * PF1-24 keys or the Page Up key. All the valid special key values are
+ − * contained in the AID_ enumeration:
+ − *
+ − * @param aidKey
+ − * The aid key to be sent to the host
+ − *
+ − * @see #sendKeys
+ − * @see TN5250jConstants#AID_CLEAR
+ − * @see #AID_ENTER
+ − * @see #AID_HELP
+ − * @see #AID_ROLL_UP
+ − * @see #AID_ROLL_DOWN
+ − * @see #AID_ROLL_LEFT
+ − * @see #AID_ROLL_RIGHT
+ − * @see #AID_PRINT
+ − * @see #AID_PF1
+ − * @see #AID_PF2
+ − * @see #AID_PF3
+ − * @see #AID_PF4
+ − * @see #AID_PF5
+ − * @see #AID_PF6
+ − * @see #AID_PF7
+ − * @see #AID_PF8
+ − * @see #AID_PF9
+ − * @see #AID_PF10
+ − * @see #AID_PF11
+ − * @see #AID_PF12
+ − * @see #AID_PF13
+ − * @see #AID_PF14
+ − * @see #AID_PF15
+ − * @see #AID_PF16
+ − * @see #AID_PF17
+ − * @see #AID_PF18
+ − * @see #AID_PF19
+ − * @see #AID_PF20
+ − * @see #AID_PF21
+ − * @see #AID_PF22
+ − * @see #AID_PF23
+ − * @see #AID_PF24
+ − */
+ − public void sendAid(int aidKey) {
+ − sessionVT.sendAidKey(aidKey);
+ − }
+ −
+ − /**
+ − * Restores the error line and sets the error mode off.
+ − *
+ − */
+ − protected void resetError() {
+ − restoreErrorLine();
+ − setStatus(STATUS_ERROR_CODE, STATUS_VALUE_OFF, "");
+ − }
+ −
+ − protected boolean simulateMnemonic(int mnem) {
+ − boolean simulated = false;
+ −
+ − switch (mnem) {
+ − case AID_CLEAR:
+ − case AID_ENTER:
+ − case AID_PF1:
+ − case AID_PF2:
+ − case AID_PF3:
+ − case AID_PF4:
+ − case AID_PF5:
+ − case AID_PF6:
+ − case AID_PF7:
+ − case AID_PF8:
+ − case AID_PF9:
+ − case AID_PF10:
+ − case AID_PF11:
+ − case AID_PF12:
+ − case AID_PF13:
+ − case AID_PF14:
+ − case AID_PF15:
+ − case AID_PF16:
+ − case AID_PF17:
+ − case AID_PF18:
+ − case AID_PF19:
+ − case AID_PF20:
+ − case AID_PF21:
+ − case AID_PF22:
+ − case AID_PF23:
+ − case AID_PF24:
+ − case AID_ROLL_DOWN:
+ − case AID_ROLL_UP:
+ − case AID_ROLL_LEFT:
+ − case AID_ROLL_RIGHT:
+ − if (!screenFields.isCanSendAid()) {
+ − displayError(ERR_ENTER_NO_ALLOWED);
+ − }
+ − else
+ − sendAid(mnem);
+ −
+ − simulated = true;
+ − break;
+ −
+ − case AID_HELP:
+ − sessionVT.sendHelpRequest();
+ − simulated = true;
+ − break;
+ −
+ − case AID_PRINT:
+ − sessionVT.hostPrint(1);
+ − simulated = true;
+ − break;
+ −
+ − case BACK_SPACE:
+ − if (screenFields.getCurrentField() != null
+ − && screenFields.withinCurrentField(lastPos)
+ − && !screenFields.isCurrentFieldBypassField()) {
+ − if (screenFields.getCurrentField().startPos() == lastPos) {
+ − if (backspaceError)
+ − displayError(ERR_CURSOR_PROTECTED);
+ − else {
+ − gotoFieldPrev();
+ − goto_XY(screenFields.getCurrentField().endPos());
+ − updateDirty();
+ − }
+ − }
+ − else {
+ − screenFields.getCurrentField().getKeyPos(lastPos);
+ − screenFields.getCurrentField().changePos(-1);
+ − resetDirty(screenFields.getCurrentField().getCurrentPos());
+ − shiftLeft(screenFields.getCurrentField().getCurrentPos());
+ − updateDirty();
+ − screenFields.setCurrentFieldMDT();
+ − simulated = true;
+ − }
+ − }
+ − else {
+ − displayError(ERR_CURSOR_PROTECTED);
+ − }
+ −
+ − break;
+ −
+ − case BACK_TAB:
+ − if (screenFields.getCurrentField() != null
+ − && screenFields.isCurrentFieldHighlightedEntry()) {
+ − resetDirty(screenFields.getCurrentField().startPos);
+ − gotoFieldPrev();
+ − updateDirty();
+ − }
+ − else
+ − gotoFieldPrev();
+ −
+ − if (screenFields.isCurrentFieldContinued()) {
+ − do {
+ − gotoFieldPrev();
+ − }
+ − while (screenFields.isCurrentFieldContinuedMiddle()
+ − || screenFields.isCurrentFieldContinuedLast());
+ − }
+ −
+ − isInField();
+ − simulated = true;
+ − break;
+ −
+ − case UP:
+ − case MARK_UP:
+ − process_XY(lastPos - numCols);
+ − simulated = true;
+ − break;
+ −
+ − case DOWN:
+ − case MARK_DOWN:
+ − process_XY(lastPos + numCols);
+ − simulated = true;
+ − break;
+ −
+ − case LEFT:
+ − case MARK_LEFT:
+ − process_XY(lastPos - 1);
+ − simulated = true;
+ − break;
+ −
+ − case RIGHT:
+ − case MARK_RIGHT:
+ − process_XY(lastPos + 1);
+ − simulated = true;
+ − break;
+ −
+ − case NEXTWORD:
+ − gotoNextWord();
+ − simulated = true;
+ − break;
+ −
+ − case PREVWORD:
+ − gotoPrevWord();
+ − simulated = true;
+ − break;
+ −
+ − case DELETE:
+ − if (screenFields.getCurrentField() != null
+ − && screenFields.withinCurrentField(lastPos)
+ − && !screenFields.isCurrentFieldBypassField()) {
+ − resetDirty(lastPos);
+ − screenFields.getCurrentField().getKeyPos(lastPos);
+ − shiftLeft(screenFields.getCurrentFieldPos());
+ − screenFields.setCurrentFieldMDT();
+ − updateDirty();
+ − simulated = true;
+ − }
+ − else {
+ − displayError(ERR_CURSOR_PROTECTED);
+ − }
+ −
+ − break;
+ −
+ − case TAB:
+ − if (screenFields.getCurrentField() != null
+ − && !screenFields.isCurrentFieldContinued()) {
+ − if (screenFields.isCurrentFieldHighlightedEntry()) {
+ − resetDirty(screenFields.getCurrentField().startPos);
+ − gotoFieldNext();
+ − updateDirty();
+ − }
+ − else
+ − gotoFieldNext();
+ − }
+ − else {
+ − do {
+ − gotoFieldNext();
+ − }
+ − while (screenFields.getCurrentField() != null
+ − && (screenFields.isCurrentFieldContinuedMiddle() || screenFields
+ − .isCurrentFieldContinuedLast()));
+ − }
+ −
+ − isInField();
+ − simulated = true;
+ − break;
+ −
+ − case EOF:
+ − if (screenFields.getCurrentField() != null
+ − && screenFields.withinCurrentField(lastPos)
+ − && !screenFields.isCurrentFieldBypassField()) {
+ − int where = endOfField(screenFields.getCurrentField()
+ − .startPos(), true);
+ −
+ − if (where > 0) {
+ − setCursor((where / numCols) + 1, (where % numCols) + 1);
+ − }
+ −
+ − simulated = true;
+ − }
+ − else {
+ − displayError(ERR_CURSOR_PROTECTED);
+ − }
+ −
+ − resetDirty(lastPos);
+ − break;
+ −
+ − case ERASE_EOF:
+ − if (screenFields.getCurrentField() != null
+ − && screenFields.withinCurrentField(lastPos)
+ − && !screenFields.isCurrentFieldBypassField()) {
+ − int where = lastPos;
+ − resetDirty(lastPos);
+ −
+ − if (fieldExit()) {
+ − screenFields.setCurrentFieldMDT();
+ −
+ − if (!screenFields.isCurrentFieldContinued()) {
+ − gotoFieldNext();
+ − }
+ − else {
+ − do {
+ − gotoFieldNext();
+ −
+ − if (screenFields.isCurrentFieldContinued())
+ − fieldExit();
+ − }
+ − while (screenFields.isCurrentFieldContinuedMiddle()
+ − || screenFields.isCurrentFieldContinuedLast());
+ − }
+ − }
+ −
+ − updateDirty();
+ − goto_XY(where);
+ − simulated = true;
+ − }
+ − else {
+ − displayError(ERR_CURSOR_PROTECTED);
+ − }
+ −
+ − break;
+ −
+ − case ERASE_FIELD:
+ − if (screenFields.getCurrentField() != null
+ − && screenFields.withinCurrentField(lastPos)
+ − && !screenFields.isCurrentFieldBypassField()) {
+ − int where = lastPos;
+ − lastPos = screenFields.getCurrentField().startPos();
+ − resetDirty(lastPos);
+ −
+ − if (fieldExit()) {
+ − screenFields.setCurrentFieldMDT();
+ −
+ − if (!screenFields.isCurrentFieldContinued()) {
+ − gotoFieldNext();
+ − }
+ − else {
+ − do {
+ − gotoFieldNext();
+ −
+ − if (screenFields.isCurrentFieldContinued())
+ − fieldExit();
+ − }
+ − while (screenFields.isCurrentFieldContinuedMiddle()
+ − || screenFields.isCurrentFieldContinuedLast());
+ − }
+ − }
+ −
+ − updateDirty();
+ − goto_XY(where);
+ − simulated = true;
+ − }
+ − else {
+ − displayError(ERR_CURSOR_PROTECTED);
+ − }
+ −
+ − break;
+ −
+ − case INSERT:
+ − // we toggle it
+ − oia.setInsertMode(oia.isInsertMode() ? false : true);
+ − break;
+ −
+ − case HOME:
+ − // position to the home position set
+ − if (lastPos + numCols + 1 != homePos) {
+ − goto_XY(homePos - numCols - 1);
+ − isInField();
+ − }
+ − else
+ − gotoField(1);
+ −
+ − break;
+ −
+ − case KEYPAD_0:
+ − simulated = simulateKeyStroke('0');
+ − break;
+ −
+ − case KEYPAD_1:
+ − simulated = simulateKeyStroke('1');
+ − break;
+ −
+ − case KEYPAD_2:
+ − simulated = simulateKeyStroke('2');
+ − break;
+ −
+ − case KEYPAD_3:
+ − simulated = simulateKeyStroke('3');
+ − break;
+ −
+ − case KEYPAD_4:
+ − simulated = simulateKeyStroke('4');
+ − break;
+ −
+ − case KEYPAD_5:
+ − simulated = simulateKeyStroke('5');
+ − break;
+ −
+ − case KEYPAD_6:
+ − simulated = simulateKeyStroke('6');
+ − break;
+ −
+ − case KEYPAD_7:
+ − simulated = simulateKeyStroke('7');
+ − break;
+ −
+ − case KEYPAD_8:
+ − simulated = simulateKeyStroke('8');
+ − break;
+ −
+ − case KEYPAD_9:
+ − simulated = simulateKeyStroke('9');
+ − break;
+ −
+ − case KEYPAD_PERIOD:
+ − simulated = simulateKeyStroke('.');
+ − break;
+ −
+ − case KEYPAD_COMMA:
+ − simulated = simulateKeyStroke(',');
+ − break;
+ −
+ − case KEYPAD_MINUS:
+ − if (screenFields.getCurrentField() != null
+ − && screenFields.withinCurrentField(lastPos)
+ − && !screenFields.isCurrentFieldBypassField()) {
+ − int s = screenFields.getCurrentField().getFieldShift();
+ −
+ − if (s == 3 || s == 5 || s == 7) {
+ − planes.setChar(lastPos, '-');
+ − resetDirty(lastPos);
+ − advancePos();
+ −
+ − if (fieldExit()) {
+ − screenFields.setCurrentFieldMDT();
+ −
+ − if (!screenFields.isCurrentFieldContinued()) {
+ − gotoFieldNext();
+ − }
+ − else {
+ − do {
+ − gotoFieldNext();
+ − }
+ − while (screenFields
+ − .isCurrentFieldContinuedMiddle()
+ − || screenFields
+ − .isCurrentFieldContinuedLast());
+ − }
+ −
+ − simulated = true;
+ − updateDirty();
+ −
+ − if (screenFields.isCurrentFieldAutoEnter())
+ − sendAid(AID_ENTER);
+ − }
+ − }
+ − else {
+ − displayError(ERR_FIELD_MINUS);
+ − }
+ − }
+ − else {
+ − displayError(ERR_CURSOR_PROTECTED);
+ − }
+ −
+ − break;
+ −
+ − case FIELD_EXIT:
+ − if (screenFields.getCurrentField() != null
+ − && screenFields.withinCurrentField(lastPos)
+ − && !screenFields.isCurrentFieldBypassField()) {
+ − resetDirty(lastPos);
+ − boolean autoFE = screenFields.isCurrentFieldAutoEnter();
+ −
+ − if (fieldExit()) {
+ − screenFields.setCurrentFieldMDT();
+ −
+ − if (!screenFields.isCurrentFieldContinued() &&
+ − !screenFields.isCurrentFieldAutoEnter()) {
+ − gotoFieldNext();
+ − }
+ − else {
+ − do {
+ − gotoFieldNext();
+ −
+ − if (screenFields.isCurrentFieldContinued())
+ − fieldExit();
+ − }
+ − while (screenFields.isCurrentFieldContinuedMiddle()
+ − || screenFields.isCurrentFieldContinuedLast());
+ − }
+ − }
+ −
+ − updateDirty();
+ − simulated = true;
+ −
+ − if (autoFE)
+ − sendAid(AID_ENTER);
+ − }
+ − else {
+ − displayError(ERR_CURSOR_PROTECTED);
+ − }
+ −
+ − break;
+ −
+ − case FIELD_PLUS:
+ − if (screenFields.getCurrentField() != null
+ − && screenFields.withinCurrentField(lastPos)
+ − && !screenFields.isCurrentFieldBypassField()) {
+ − resetDirty(lastPos);
+ − boolean autoFE = screenFields.isCurrentFieldAutoEnter();
+ −
+ − if (fieldExit()) {
+ − screenFields.setCurrentFieldMDT();
+ −
+ − if (!screenFields.isCurrentFieldContinued() &&
+ − !screenFields.isCurrentFieldAutoEnter()) {
+ − gotoFieldNext();
+ − }
+ − else {
+ − do {
+ − gotoFieldNext();
+ − }
+ − while (screenFields.isCurrentFieldContinuedMiddle()
+ − || screenFields.isCurrentFieldContinuedLast());
+ − }
+ − }
+ −
+ − updateDirty();
+ − simulated = true;
+ −
+ − if (autoFE)
+ − sendAid(AID_ENTER);
+ − }
+ − else {
+ − displayError(ERR_CURSOR_PROTECTED);
+ − }
+ −
+ − break;
+ −
+ − case FIELD_MINUS:
+ − if (screenFields.getCurrentField() != null
+ − && screenFields.withinCurrentField(lastPos)
+ − && !screenFields.isCurrentFieldBypassField()) {
+ − int s = screenFields.getCurrentField().getFieldShift();
+ −
+ − if (s == 3 || s == 5 || s == 7) {
+ − planes.setChar(lastPos, '-');
+ − resetDirty(lastPos);
+ − advancePos();
+ − boolean autoFE = screenFields.isCurrentFieldAutoEnter();
+ −
+ − if (fieldExit()) {
+ − screenFields.setCurrentFieldMDT();
+ −
+ − if (!screenFields.isCurrentFieldContinued()
+ − && !screenFields.isCurrentFieldAutoEnter()) {
+ − gotoFieldNext();
+ − }
+ − else {
+ − do {
+ − gotoFieldNext();
+ − }
+ − while (screenFields.isCurrentFieldContinuedMiddle()
+ − || screenFields.isCurrentFieldContinuedLast());
+ − }
+ − }
+ −
+ − updateDirty();
+ − simulated = true;
+ −
+ − if (autoFE)
+ − sendAid(AID_ENTER);
+ − }
+ − else {
+ − displayError(ERR_FIELD_MINUS);
+ − }
+ − }
+ − else {
+ − displayError(ERR_CURSOR_PROTECTED);
+ − }
+ −
+ − break;
+ −
+ − case BOF:
+ − if (screenFields.getCurrentField() != null
+ − && screenFields.withinCurrentField(lastPos)
+ − && !screenFields.isCurrentFieldBypassField()) {
+ − int where = screenFields.getCurrentField().startPos();
+ −
+ − if (where > 0) {
+ − goto_XY(where);
+ − }
+ −
+ − simulated = true;
+ − }
+ − else {
+ − displayError(ERR_CURSOR_PROTECTED);
+ − }
+ −
+ − resetDirty(lastPos);
+ − break;
+ −
+ − case SYSREQ:
+ − sessionVT.systemRequest();
+ − simulated = true;
+ − break;
+ −
+ − case RESET:
+ − if (isStatusErrorCode()) {
+ − resetError();
+ − isInField();
+ − updateDirty();
+ − }
+ − else {
+ − setPrehelpState(false, oia.isKeyBoardLocked(), false);
+ − }
+ −
+ − simulated = true;
+ − break;
+ −
+ − case ATTN:
+ − sessionVT.sendAttentionKey();
+ − simulated = true;
+ − break;
+ −
+ − case DUP_FIELD:
+ − if (screenFields.getCurrentField() != null
+ − && screenFields.withinCurrentField(lastPos)
+ − && !screenFields.isCurrentFieldBypassField()) {
+ − if (screenFields.isCurrentFieldDupEnabled()) {
+ − resetDirty(lastPos);
+ − screenFields.getCurrentField().setFieldChar(lastPos,
+ − (char) 0x1C);
+ − screenFields.setCurrentFieldMDT();
+ − gotoFieldNext();
+ − updateDirty();
+ − simulated = true;
+ − }
+ − else {
+ − displayError(ERR_DUP_KEY_NOT_ALLOWED);
+ − }
+ − }
+ − else {
+ − displayError(ERR_CURSOR_PROTECTED);
+ − }
+ −
+ − break;
+ −
+ − case NEW_LINE:
+ − if (screenFields.getSize() > 0) {
+ − int startRow = getRow(lastPos) + 1;
+ − int startPos = lastPos;
+ −
+ − if (startRow == getRows())
+ − startRow = 0;
+ −
+ − setCursor(++startRow, 1);
+ −
+ − if (!isInField() && screenFields.getCurrentField() != null
+ − && !screenFields.isCurrentFieldBypassField()) {
+ − while (!isInField()
+ − && screenFields.getCurrentField() != null
+ − && !screenFields.isCurrentFieldBypassField()) {
+ − // lets keep going
+ − advancePos();
+ −
+ − // Have we looped the screen?
+ − if (lastPos == startPos) {
+ − // if so then go back to starting point
+ − goto_XY(startPos);
+ − break;
+ − }
+ − }
+ − }
+ − }
+ −
+ − simulated = true;
+ − break;
+ −
+ − case FAST_CURSOR_DOWN:
+ − int rowNow = (getCurrentRow() - 1) + 3;
+ −
+ − if (rowNow > getRows() - 1)
+ − rowNow = rowNow - getRows();
+ −
+ − this.goto_XY(getPos(rowNow, getCurrentCol() - 1));
+ − simulated = true;
+ − break;
+ −
+ − case FAST_CURSOR_UP:
+ − rowNow = (getCurrentRow() - 1) - 3;
+ −
+ − if (rowNow < 0)
+ − rowNow = (getRows()) + rowNow;
+ −
+ − this.goto_XY(getPos(rowNow, getCurrentCol() - 1));
+ − simulated = true;
+ − break;
+ −
+ − case FAST_CURSOR_LEFT:
+ − int colNow = (getCurrentCol() - 1) - 3;
+ − rowNow = getCurrentRow() - 1;
+ −
+ − if (colNow <= 0) {
+ − colNow = getColumns() + colNow;
+ − rowNow--;
+ − }
+ −
+ − if (rowNow < 0)
+ − rowNow = getRows() - 1;
+ −
+ − process_XY(getPos(rowNow, colNow));
+ − simulated = true;
+ − break;
+ −
+ − case FAST_CURSOR_RIGHT:
+ − colNow = (getCurrentCol() - 1) + 3;
+ − rowNow = getCurrentRow() - 1;
+ −
+ − if (colNow >= getColumns()) {
+ − colNow = colNow - getColumns();
+ − rowNow++;
+ − }
+ −
+ − if (rowNow > getRows() - 1)
+ − rowNow = getRows() - rowNow;
+ −
+ − process_XY(getPos(rowNow, colNow));
+ − simulated = true;
+ − break;
+ −
+ − default:
+ − Log.i(TAG, " Mnemonic not supported " + mnem);
+ − break;
+ − }
+ −
+ − return simulated;
+ − }
+ −
+ − protected boolean simulateKeyStroke(char c) {
+ − if (isStatusErrorCode() && !Character.isISOControl(c) && !keyProcessed) {
+ − if (resetRequired) return false;
+ −
+ − resetError();
+ − }
+ −
+ − boolean updateField = false;
+ − boolean numericError = false;
+ − boolean updatePos = false;
+ − boolean autoEnter = false;
+ −
+ − if (!Character.isISOControl(c)) {
+ − if (screenFields.getCurrentField() != null
+ − && screenFields.withinCurrentField(lastPos)
+ − && !screenFields.isCurrentFieldBypassField()) {
+ − if (screenFields.isCurrentFieldFER()
+ − && !screenFields.withinCurrentField(screenFields
+ − .getCurrentFieldPos())
+ − && lastPos == screenFields.getCurrentField().endPos()
+ − && screenFields.getCurrentFieldPos() > screenFields
+ − .getCurrentField().endPos()) {
+ − displayError(ERR_FIELD_EXIT_INVALID);
+ − feError = true;
+ − return false;
+ − }
+ −
+ − switch (screenFields.getCurrentFieldShift()) {
+ − case 0: // Alpha shift
+ − case 2: // Numeric Shift
+ − case 4: // Kakana Shift
+ − updateField = true;
+ − break;
+ −
+ − case 1: // Alpha Only
+ − if (Character.isLetter(c) || c == ',' || c == '-'
+ − || c == '.' || c == ' ')
+ − updateField = true;
+ −
+ − break;
+ −
+ − case 3: // Numeric only
+ − if (Character.isDigit(c) || c == '+' || c == ','
+ − || c == '-' || c == '.' || c == ' ')
+ − updateField = true;
+ − else
+ − numericError = true;
+ −
+ − break;
+ −
+ − case 5: // Digits only
+ − if (Character.isDigit(c))
+ − updateField = true;
+ − else
+ − displayError(ERR_NUMERIC_09);
+ −
+ − break;
+ −
+ − case 7: // Signed numeric
+ − if (Character.isDigit(c) || c == '+' || c == '-')
+ − if (lastPos == screenFields.getCurrentField().endPos()
+ − && (c != '+' && c != '-'))
+ − displayError(ERR_INVALID_SIGN);
+ − else
+ − updateField = true;
+ − else
+ − displayError(ERR_NUMERIC_09);
+ −
+ − break;
+ − }
+ −
+ − if (updateField) {
+ − if (screenFields.isCurrentFieldToUpper())
+ − c = Character.toUpperCase(c);
+ −
+ − updatePos = true;
+ − resetDirty(lastPos);
+ −
+ − if (oia.isInsertMode()) {
+ − if (endOfField(false) != screenFields.getCurrentField()
+ − .endPos())
+ − shiftRight(lastPos);
+ − else {
+ − displayError(ERR_NO_ROOM_INSERT);
+ − updatePos = false;
+ − }
+ − }
+ −
+ − if (updatePos) {
+ − screenFields.getCurrentField().getKeyPos(
+ − getRow(lastPos), getCol(lastPos));
+ − screenFields.getCurrentField().changePos(1);
+ − planes.setChar(lastPos, c);
+ − screenFields.setCurrentFieldMDT();
+ −
+ − // if we have gone passed the end of the field then goto
+ − // the next field
+ − if (!screenFields.withinCurrentField(screenFields
+ − .getCurrentFieldPos())) {
+ − if (screenFields.isCurrentFieldAutoEnter()) {
+ − autoEnter = true;
+ − }
+ − else if (!screenFields.isCurrentFieldFER())
+ − gotoFieldNext();
+ − else {
+ − // screenFields.getCurrentField().changePos(1);
+ − //
+ − // if (screenFields.
+ − // cursorPos == endPos)
+ − // System.out.println("end of field");
+ − //
+ − // feError != feError;
+ − // if (feError)
+ − // displayError(ERR_FIELD_EXIT_INVALID);
+ − }
+ − }
+ − else
+ − setCursor(screenFields.getCurrentField()
+ − .getCursorRow() + 1, screenFields
+ − .getCurrentField().getCursorCol() + 1);
+ − }
+ −
+ − fireScreenChanged();
+ −
+ − if (autoEnter)
+ − sendAid(AID_ENTER);
+ − }
+ − else {
+ − if (numericError) {
+ − displayError(ERR_NUMERIC_ONLY);
+ − }
+ − }
+ − }
+ − else {
+ − displayError(ERR_CURSOR_PROTECTED);
+ − }
+ − }
+ −
+ − return updatePos;
+ − }
+ −
+ − /**
+ − * Method: endOfField
+ − * <p>
+ − *
+ − * convenience method that call endOfField with lastRow lastCol and passes
+ − * the posSpace to that method
+ − *
+ − * @param posSpace
+ − * value of type boolean - specifying to return the position of
+ − * the the last space or not
+ − * @return a value of type int - the screen postion (row * columns) + col
+ − *
+ − */
+ − private int endOfField(boolean posSpace) {
+ − return endOfField(lastPos, posSpace);
+ − }
+ −
+ − /**
+ − * Method: endOfField
+ − * <p>
+ − *
+ − * gets the position of the last character of the current field posSpace
+ − * parameter tells the routine whether to return the position of the last
+ − * space ( <= ' ') or the last non space posSpace == true last occurrence of
+ − * char <= ' ' posSpace == false last occurrence of char > ' '
+ − *
+ − * @param pos
+ − * value of type int - position to start from
+ − * @param posSpace
+ − * value of type boolean - specifying to return the position of
+ − * the the last space or not
+ − * @return a value of type int - the screen postion (row * columns) + col
+ − *
+ − */
+ − private int endOfField(int pos, boolean posSpace) {
+ − int endPos = screenFields.getCurrentField().endPos();
+ − int fePos = endPos;
+ − // get the number of characters to the right
+ − int count = endPos - pos;
+ −
+ − // first lets get the real ending point without spaces and the such
+ − while (planes.getChar(endPos) <= ' ' && count-- > 0) {
+ − endPos--;
+ − }
+ −
+ − if (endPos == fePos) {
+ − return endPos;
+ − }
+ −
+ − screenFields.getCurrentField().getKeyPos(endPos);
+ −
+ − if (posSpace) screenFields.getCurrentField().changePos(+1);
+ −
+ − return screenFields.getCurrentFieldPos();
+ − }
+ −
+ − private boolean fieldExit() {
+ − int pos = lastPos;
+ − boolean mdt = false;
+ − int end = endOfField(false); // get the ending position of the first
+ − // non blank character in field
+ − ScreenField sf = screenFields.getCurrentField();
+ −
+ − if (sf.isMandatoryEnter() && end == sf.startPos()) {
+ − displayError(ERR_MANDITORY_ENTER);
+ − return false;
+ − }
+ −
+ − // save off the current pos of the field for checking field exit required
+ − // positioning. the getKeyPos resets this information so it is useless
+ − // for comparing if we are positioned passed the end of field.
+ − // Maybe this should be changed to not update the current cursor position
+ − // of the field.
+ − int currentPos = sf.getCurrentPos();
+ − // get the number of characters to the right
+ − int count = (end - sf.startPos()) - sf.getKeyPos(pos);
+ −
+ − if (count == 0 && sf.isFER()) {
+ − if (currentPos > sf.endPos()) {
+ − mdt = true;
+ − return mdt;
+ − }
+ − }
+ −
+ − for (; count >= 0; count--) {
+ − planes.setChar(pos, initChar);
+ − setDirty(pos);
+ − pos++;
+ − mdt = true;
+ − }
+ −
+ − // This checks for a field minus because a field minus places
+ − // a negative sign and then advances a position. If it is the
+ − // end of the field where the minus is placed then this offset will
+ − // place the count as -1.
+ − if (count == -1) {
+ − int s = sf.getFieldShift();
+ −
+ − if (s == 3 || s == 5 || s == 7) {
+ − mdt = true;
+ − }
+ − }
+ −
+ − int adj = sf.getAdjustment();
+ −
+ − if (adj != 0) {
+ − switch (adj) {
+ − case 5:
+ − rightAdjustField('0');
+ − sf.setRightAdjusted();
+ − break;
+ −
+ − case 6:
+ − rightAdjustField(' ');
+ − sf.setRightAdjusted();
+ − break;
+ −
+ − case 7:
+ − sf.setManditoryEntered();
+ − break;
+ − }
+ − }
+ − else {
+ − // we need to right adjust signed numeric fields as well.
+ − if (sf.isSignedNumeric()) {
+ − rightAdjustField(' ');
+ − }
+ − }
+ −
+ − return mdt;
+ − }
+ −
+ − private void rightAdjustField(char fill) {
+ − int end = endOfField(false); // get the ending position of the first
+ − // non blank character in field
+ − // get the number of characters to the right
+ − int count = screenFields.getCurrentField().endPos() - end;
+ −
+ − // subtract 1 from count for signed numeric - note for later
+ − if (screenFields.getCurrentField().isSignedNumeric()) {
+ − if (planes.getChar(end - 1) != '-')
+ − count--;
+ − }
+ −
+ − int pos = screenFields.getCurrentField().startPos();
+ −
+ − while (count-- >= 0) {
+ − shiftRight(pos);
+ − planes.setChar(pos, fill);
+ − setDirty(pos);
+ − }
+ − }
+ −
+ − private void shiftLeft(int sPos) {
+ − int endPos = 0;
+ − int pos = sPos;
+ − int pPos = sPos;
+ − ScreenField sf = screenFields.getCurrentField();
+ − int end;
+ − int count;
+ −
+ − do {
+ − end = endOfField(pPos, false); // get the ending position of the
+ − // first
+ − // non blank character in field
+ − count = (end - screenFields.getCurrentField().startPos())
+ − - screenFields.getCurrentField().getKeyPos(pPos);
+ −
+ − // now we loop through and shift the remaining characters to the
+ − // left
+ − while (count-- > 0) {
+ − pos++;
+ − planes.setChar(pPos, planes.getChar(pos));
+ − setDirty(pPos);
+ − pPos = pos;
+ − }
+ −
+ − if (screenFields.isCurrentFieldContinued()) {
+ − gotoFieldNext();
+ −
+ − if (screenFields.getCurrentField().isContinuedFirst())
+ − break;
+ −
+ − pos = screenFields.getCurrentField().startPos();
+ − planes.setChar(pPos, planes.getChar(pos));
+ − setDirty(pPos);
+ − pPos = pos;
+ − }
+ − }
+ − while (screenFields.isCurrentFieldContinued()
+ − && !screenFields.getCurrentField().isContinuedFirst());
+ −
+ − if (end >= 0 && count >= -1) {
+ − endPos = end;
+ − }
+ − else {
+ − endPos = sPos;
+ − }
+ −
+ − screenFields.setCurrentField(sf);
+ − planes.setChar(endPos, initChar);
+ − setDirty(endPos);
+ − goto_XY(screenFields.getCurrentFieldPos());
+ − sf = null;
+ − }
+ −
+ − private void shiftRight(int sPos) {
+ − int end = endOfField(true); // get the ending position of the first
+ − // non blank character in field
+ − int pos = end;
+ − int pPos = end;
+ − int count = end - sPos;
+ −
+ − // now we loop through and shift the remaining characters to the right
+ − while (count-- > 0) {
+ − pos--;
+ − planes.setChar(pPos, planes.getChar(pos));
+ − setDirty(pPos);
+ − pPos = pos;
+ − }
+ − }
+ −
+ − public int getRow(int pos) {
+ − // if (pos == 0)
+ − // return 1;
+ − int row = pos / numCols;
+ −
+ − if (row < 0) {
+ − row = lastPos / numCols;
+ − }
+ −
+ − if (row > (lenScreen / numCols) - 1)
+ − row = (lenScreen / numCols) - 1;
+ −
+ − return row;
+ − }
+ −
+ − public int getCol(int pos) {
+ − int col = pos % (getColumns());
+ −
+ − if (col > 0) return col;
+ −
+ − return 0;
+ − }
+ −
+ − /**
+ − * This routine is 0 based offset. So to get row 20,1 then pass row 19,0
+ − *
+ − * @param row
+ − * @param col
+ − * @return
+ − */
+ − public int getPos(int row, int col) {
+ − return (row * numCols) + col;
+ − }
+ −
+ − /**
+ − * Current position is based on offsets of 1,1 not 0,0 of the current
+ − * position of the screen
+ − *
+ − * @return int
+ − */
+ − public int getCurrentPos() {
+ − // return lastPos + numCols + 1;
+ − return lastPos + 1;
+ − }
+ −
+ − /**
+ − * I got this information from a tcp trace of each error. I could not find
+ − * any documenation for this. Maybe there is but I could not find it. If
+ − * anybody finds this documention could you please send me a copy. Please
+ − * note that I did not look that hard either.
+ − * <p>
+ − * 0000: 00 50 73 1D 89 81 00 50 DA 44 C8 45 08 00 45 00 .Ps....P.D.E..E.
+ − * </p>
+ − * <p>
+ − * 0010: 00 36 E9 1C 40 00 80 06 9B F9 C1 A8 33 58 C0 A8 .6..@...k....3X..
+ − * </p>
+ − * <p>
+ − * 0020: C0 02 06 0E 00 17 00 52 6E 88 73 40 DE CB 50 18 .......Rn.s@..P.
+ − * </p>
+ − * <p>
+ − * 0030: 20 12 3C 53 00 00 00 0C 12 A0 00 00 04 01 00 00 . <S............
+ − * </p>
+ − * <p>
+ − * 0040: 00 05 FF EF .... ----------|| The 00 XX is the code to be sent. I
+ − * found the following <table BORDER COLS=2 WIDTH="50%" >
+ − * <tr>
+ − * <td>ERR_CURSOR_PROTECTED</td>
+ − * <td>0x05</td>
+ − * </tr>
+ − * <tr>
+ − * <td>ERR_INVALID_SIGN</td>
+ − * <td>0x11</td>
+ − * </tr>
+ − * <tr>
+ − * <td>ERR_NO_ROOM_INSERT</td>
+ − * <td>0x12</td>
+ − * </tr>
+ − * <tr>
+ − * <td>ERR_NUMERIC_ONLY</td>
+ − * <td>0x09</td>
+ − * </tr>
+ − * <tr>
+ − * <td>ERR_NUMERIC_09</td>
+ − * <td>0x10</td>
+ − * </tr>
+ − * <tr>
+ − * <td>ERR_FIELD_MINUS</td>
+ − * <td>0x16</td>
+ − * </tr>
+ − * <tr>
+ − * <td>ERR_ENTER_NOT_ALLOWED</td>
+ − * <td>0x20</td>
+ − * </tr>
+ − * <tr>
+ − * <td>ERR_MANDITORY_ENTER</td>
+ − * <td>0x21</td>
+ − * </tr>
+ − * <tr>
+ − * <td>ERR_ENTER_NOT_ALLOWED</td>
+ − * <td>0x20</td>
+ − * </tr>
+ − * </table> I am tired of typing and they should be self explanitory. Finding
+ − * them in the first place was the pain.
+ − * </p>
+ − *
+ − * @param ec error code
+ − */
+ − private void displayError(int ec) {
+ − saveHomePos = homePos;
+ − homePos = lastPos + numCols + 1;
+ − pendingInsert = true;
+ − sessionVT.sendNegResponse2(ec);
+ − }
+ −
+ − private void process_XY(int pos) {
+ − if (pos < 0)
+ − pos = lenScreen + pos;
+ −
+ − if (pos > lenScreen - 1)
+ − pos = pos - lenScreen;
+ −
+ − // if there was a field exit error then we need to treat the movement
+ − // of the cursor in a special way that equals that of Client Access.
+ − // If the cursor is moved from the field then we need to reset the
+ − // position within the field so that the last character can be typed
+ − // over again instead of sending the field exit error again.
+ − // We also need to reset the field exit error flag.
+ − //
+ − // How we know we have a field exit error is when the field position is
+ − // set beyond the end of the field and a character is then typed we can
+ − // not position that character. To reset this we need to set the next
+ − // position of the field to not be beyond the end of field but to the
+ − // last character.
+ − //
+ − // Now to make it work like Client Access if the cursor is a back space
+ − // then do not move the cursor but place it on the last field. All
+ − // other keys will reset the field position so that entering over the
+ − // last character will not cause an error but replace that character or
+ − // just plain move the cursor if the key was to do that.
+ − ScreenField sf = screenFields.getCurrentField();
+ −
+ − if (feError) {
+ − feError = false;
+ − sf.changePos(-1);
+ − }
+ − else {
+ − if (sf != null && sf.isFER()) {
+ − if ((sf.getCurrentPos()
+ − > sf.endPos())) {
+ − if (sf.withinField(pos)) {
+ − sf.getKeyPos(pos);
+ − return;
+ − }
+ −
+ − sf.getKeyPos(sf.endPos());
+ − }
+ − }
+ −
+ − goto_XY(pos);
+ − }
+ − }
+ −
+ − public boolean isUsingGuiInterface() {
+ − return guiInterface;
+ − }
+ −
+ − /**
+ − * Convinience class to return if the cursor is in a field or not.
+ − *
+ − * @return true or false
+ − */
+ −
+ − protected boolean isInField() {
+ − return isInField(lastPos, true);
+ − }
+ −
+ − /**
+ − *
+ − * Convinience class to return if the position that is passed is in a field
+ − * or not. If it is then the chgToField parameter will change the current
+ − * field to this field where the position indicates
+ − *
+ − * @param pos
+ − * @param chgToField
+ − * @return true or false
+ − */
+ − public boolean isInField(int pos, boolean chgToField) {
+ − return screenFields.isInField(pos, chgToField);
+ − }
+ −
+ − /**
+ − *
+ − * Convinience class to return if the position that is passed is in a field
+ − * or not. If it is then the field at this position becomes the current
+ − * working field
+ − *
+ − * @param pos
+ − * @return true or false
+ − */
+ − public boolean isInField(int pos) {
+ − return screenFields.isInField(pos, true);
+ − }
+ −
+ − /**
+ − * Convinience class to return if the position at row and column that is
+ − * passed is in a field or not. If it is then the field at this position
+ − * becomes the current working field.
+ − *
+ − * @param row
+ − * @param col
+ − * @return true or false
+ − */
+ − public boolean isInField(int row, int col) {
+ − return isInField(row, col, true);
+ − }
+ −
+ − /**
+ − *
+ − * Convinience class to return if the position at row and column that is
+ − * passed is in a field or not. If it is then the chgToField parameter will
+ − * change the current field to this field where the row and column
+ − * indicates.
+ − *
+ − * @param row
+ − * @param col
+ − * @param chgToField
+ − * @return true or false
+ − */
+ − public boolean isInField(int row, int col, boolean chgToField) {
+ − return screenFields.isInField((row * numCols) + col, chgToField);
+ − }
+ −
+ − /**
+ − * Gets the length of the screen - number of rows times number of columns
+ − *
+ − * @return int value of screen length
+ − */
+ − public int getScreenLength() {
+ − return lenScreen;
+ − }
+ −
+ − /**
+ − * Get the number or rows available.
+ − *
+ − * @return number of rows
+ − */
+ − public int getRows() {
+ − return numRows;
+ − }
+ −
+ − /**
+ − * Get the number of columns available.
+ − *
+ − * @return number of columns
+ − */
+ − public int getColumns() {
+ − return numCols;
+ − }
+ −
+ − /**
+ − * Get the current row where the cursor is
+ − *
+ − * @return the cursor current row position 1,1 based
+ − */
+ − public int getCurrentRow() {
+ − return (lastPos / numCols) + 1;
+ − }
+ −
+ − /**
+ − * Get the current column where the cursor is
+ − *
+ − * @return the cursor current column position 1,1 based
+ − */
+ − public int getCurrentCol() {
+ − return (lastPos % numCols) + 1;
+ − }
+ −
+ − /**
+ − * The last position of the cursor on the screen - Note - position is based
+ − * 0,0
+ − *
+ − * @return last position
+ − */
+ − protected int getLastPos() {
+ − return lastPos;
+ − }
+ −
+ − /**
+ − * Hotspot More... string
+ − *
+ − * @return string literal of More...
+ − */
+ − public StringBuffer getHSMore() {
+ − return hsMore;
+ − }
+ −
+ − /**
+ − * Hotspot Bottom string
+ − *
+ − * @return string literal of Bottom
+ − */
+ − public StringBuffer getHSBottom() {
+ − return hsBottom;
+ − }
+ −
+ − /**
+ − *
+ − * Return the screen represented as a character array
+ − *
+ − * @return character array containing the text
+ − */
+ − public char[] getScreenAsChars() {
+ − char[] sac = new char[lenScreen];
+ − char c;
+ −
+ − for (int x = 0; x < lenScreen; x++) {
+ − c = planes.getChar(x);
+ −
+ − // only draw printable characters (in this case >= ' ')
+ − if ((c >= ' ') && (!planes.isAttributePlace(x))) {
+ − sac[x] = c;
+ − // TODO: implement the underline check here
+ − // if (screen[x].underLine && c <= ' ')
+ − // sac[x] = '_';
+ − }
+ − else
+ − sac[x] = ' ';
+ − }
+ −
+ − return sac;
+ − }
+ −
+ − public char[] getData(int startRow, int startCol, int endRow, int endCol, int plane) {
+ − try {
+ − int from = getPos(startRow, startCol);
+ − int to = getPos(endRow, endCol);
+ −
+ − if (from > to) {
+ − int f = from;
+ − to = f;
+ − from = f;
+ − }
+ −
+ − return planes.getPlaneData(from, to, plane);
+ − }
+ − catch (Exception oe) {
+ − return null;
+ − }
+ − }
+ −
+ − /**
+ − * <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)
+ − // throws OhioException {
+ − {
+ − return GetScreen(buffer, bufferLength, 0, lenScreen, 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
+ − */
+ −
+ − public synchronized int GetScreen(char buffer[], int bufferLength, int from,
+ − int length, int plane)
+ − // throws OhioException {
+ − {
+ − return planes.GetScreen(buffer, bufferLength, from, length, 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 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 planes.GetScreen(buffer, bufferLength, 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
+ − */
+ −
+ − public synchronized int GetScreenRect(char buffer[], int bufferLength,
+ − int startPos, int endPos, int plane)
+ − // throws OhioException {
+ − {
+ − return planes.GetScreenRect(buffer, bufferLength, startPos, endPos, 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
+ − */
+ −
+ − public synchronized int GetScreenRect(char buffer[], int bufferLength,
+ − int startRow, int startCol,
+ − int endRow, int endCol, int plane)
+ − // throws OhioException {
+ − {
+ − return planes.GetScreenRect(buffer, bufferLength, startRow, startCol, endRow,
+ − endCol, plane);
+ − }
+ −
+ − public synchronized boolean[] getActiveAidKeys() {
+ − return sessionVT.getActiveAidKeys();
+ − }
+ −
+ − protected synchronized void setScreenData(String text, int location) {
+ − // throws OhioException {
+ − if (location < 0 || location > lenScreen) {
+ − return;
+ − // throw new OhioException(sessionVT.getSessionConfiguration(),
+ − // OhioScreen5250.class.getName(), "osohio.screen.ohio00300", 1);
+ − }
+ −
+ − int pos = location;
+ − int l = text.length();
+ − boolean updated = false;
+ − boolean flag = false;
+ − int x = 0;
+ −
+ − for (; x < l; x++) {
+ − if (isInField(pos + x, true)) {
+ − if (!screenFields.getCurrentField().isBypassField()) {
+ − if (!flag) {
+ − screenFields.getCurrentField().setMDT();
+ − updated = true;
+ − resetDirty(pos + x);
+ − screenFields.setMasterMDT();
+ − flag = true;
+ − }
+ −
+ − planes.screen[pos + x] = text.charAt(x);
+ − setDirty(pos + x);
+ − }
+ − }
+ − }
+ −
+ − lastPos = pos + x;
+ −
+ − if (updated) {
+ − fireScreenChanged();
+ − }
+ − }
+ −
+ − /**
+ − * This routine is based on offset 1,1 not 0,0 it will translate to offset
+ − * 0,0 and call the goto_XY(int pos) it is mostly used from external classes
+ − * that use the 1,1 offset
+ − *
+ − * @param row
+ − * @param col
+ − */
+ − public void setCursor(int row, int col) {
+ − goto_XY(((row - 1) * numCols) + (col - 1));
+ − }
+ −
+ − // this routine is based on offset 0,0 not 1,1
+ − protected void goto_XY(int pos) {
+ − lastPos = pos;
+ − updateCursorLoc();
+ − }
+ −
+ − /*
+ − * set the content of the field at (l,c) to data
+ − * if l == -1, set the current field contents to data
+ − */
+ − public void setField(int l, int c, char [] data) {
+ − ScreenField cf;
+ −
+ − if (l >= 0) {
+ − lastPos = l * numCols + c;
+ − while (!isInField()) advancePos();
+ − setDirty(lastPos);
+ − fireCursorChanged();
+ − }
+ −
+ − if ((data != null) && (data.length > 0)) {
+ − cf = screenFields.getCurrentField();
+ − cf.setString(new String(data));
+ − lastPos = cf.getStartPos();
+ − setDirty(lastPos);
+ − setDirty(lastPos + cf.getLength());
+ − lastPos += data.length;
+ − if (!isInField()) {
+ − gotoFieldNext();
+ − isInField();
+ − cf = screenFields.getCurrentField();
+ − lastPos = cf.getStartPos();
+ − }
+ − setDirty(lastPos);
+ − fireCursorChanged();
+ − }
+ −
+ − updateDirty();
+ − }
+ −
+ − /**
+ − * Set the current working field to the field number specified.
+ − *
+ − * @param f -
+ − * numeric field number on the screen
+ − * @return true or false whether it was sucessful
+ − */
+ − public boolean gotoField(int f) {
+ − int sizeFields = screenFields.getSize();
+ −
+ − if (f > sizeFields || f <= 0)
+ − return false;
+ −
+ − screenFields.setCurrentField(screenFields.getField(f - 1));
+ −
+ − while (screenFields.isCurrentFieldBypassField() && f < sizeFields) {
+ − screenFields.setCurrentField(screenFields.getField(f++));
+ − }
+ −
+ − return gotoField(screenFields.getCurrentField());
+ − }
+ −
+ − /**
+ − * Convenience method to set the field object passed as the currect working
+ − * screen field
+ − *
+ − * @param f
+ − * @return true or false whether it was sucessful
+ − * @see org.tn5250j.ScreenField
+ − */
+ − protected boolean gotoField(ScreenField f) {
+ − if (f != null) {
+ − goto_XY(f.startPos());
+ − return true;
+ − }
+ −
+ − return false;
+ − }
+ −
+ − /**
+ − * Convenience class to position the cursor to the next word on the screen
+ − *
+ − */
+ − private void gotoNextWord() {
+ − int pos = lastPos;
+ −
+ − if (planes.getChar(lastPos) > ' ') {
+ − advancePos();
+ −
+ − // get the next space character
+ − while (planes.getChar(lastPos) > ' ' && pos != lastPos) {
+ − advancePos();
+ − }
+ − }
+ − else
+ − advancePos();
+ −
+ − // now that we are positioned on the next space character get the
+ − // next none space character
+ − while (planes.getChar(lastPos) <= ' ' && pos != lastPos) {
+ − advancePos();
+ − }
+ − }
+ −
+ − /**
+ − * Convenience class to position the cursor to the previous word on the
+ − * screen
+ − *
+ − */
+ − private void gotoPrevWord() {
+ − int pos = lastPos;
+ − changePos(-1);
+ −
+ − // position previous white space character
+ − while (planes.getChar(lastPos) <= ' ') {
+ − changePos(-1);
+ −
+ − if (pos == lastPos)
+ − break;
+ − }
+ −
+ − changePos(-1);
+ −
+ − // get the previous space character
+ − while (planes.getChar(lastPos) > ' ' && pos != lastPos) {
+ − changePos(-1);
+ − }
+ −
+ − // and position one position more should give us the beginning of word
+ − advancePos();
+ − }
+ −
+ − /**
+ − * Convinience class to position to the next field on the screen.
+ − *
+ − * @see org.tn5250j.ScreenFields
+ − */
+ − private void gotoFieldNext() {
+ − if (screenFields.isCurrentFieldHighlightedEntry())
+ − unsetFieldHighlighted(screenFields.getCurrentField());
+ −
+ − screenFields.gotoFieldNext();
+ −
+ − if (screenFields.isCurrentFieldHighlightedEntry())
+ − setFieldHighlighted(screenFields.getCurrentField());
+ − }
+ −
+ − /**
+ − * Convinience class to position to the previous field on the screen.
+ − *
+ − * @see org.tn5250j.ScreenFields
+ − */
+ − private void gotoFieldPrev() {
+ − if (screenFields.isCurrentFieldHighlightedEntry())
+ − unsetFieldHighlighted(screenFields.getCurrentField());
+ −
+ − screenFields.gotoFieldPrev();
+ −
+ − if (screenFields.isCurrentFieldHighlightedEntry())
+ − setFieldHighlighted(screenFields.getCurrentField());
+ − }
+ −
+ − /* *** NEVER USED LOCALLY ************************************************** */
+ − // /**
+ − // * Used to restrict the cursor to a particular position on the screen. Used
+ − // * in combination with windows to restrict the cursor to the active window
+ − // * show on the screen.
+ − // *
+ − // * Not supported yet. Please implement me :-(
+ − // *
+ − // * @param depth
+ − // * @param width
+ − // */
+ − // protected void setRestrictCursor(int depth, int width) {
+ − //
+ − // restrictCursor = true;
+ − // // restriction
+ − //
+ − // }
+ −
+ − /**
+ − * Creates a window on the screen
+ − *
+ − * @param depth
+ − * @param width
+ − * @param type
+ − * @param gui
+ − * @param monoAttr
+ − * @param colorAttr
+ − * @param ul
+ − * @param upper
+ − * @param ur
+ − * @param left
+ − * @param right
+ − * @param ll
+ − * @param bottom
+ − * @param lr
+ − */
+ − protected void createWindow(int depth, int width, int type, boolean gui,
+ − int monoAttr, int colorAttr, int ul, int upper, int ur, int left,
+ − int right, int ll, int bottom, int lr) {
+ − int c = getCol(lastPos);
+ − int w = 0;
+ − width++;
+ − w = width;
+ − // set leading attribute byte
+ − // screen[lastPos].setCharAndAttr(initChar, initAttr, true);
+ − planes.setScreenCharAndAttr(lastPos, initChar, initAttr, true);
+ − setDirty(lastPos);
+ − advancePos();
+ − // set upper left
+ − // screen[lastPos].setCharAndAttr((char) ul, colorAttr, false);
+ − planes.setScreenCharAndAttr(lastPos, (char) ul, colorAttr, false);
+ −
+ − if (gui) {
+ − // screen[lastPos].setUseGUI(UPPER_LEFT);
+ − planes.setUseGUI(lastPos, UPPER_LEFT);
+ − }
+ −
+ − setDirty(lastPos);
+ − advancePos();
+ −
+ − // draw top row
+ −
+ − while (w-- >= 0) {
+ − // screen[lastPos].setCharAndAttr((char) upper, colorAttr, false);
+ − planes.setScreenCharAndAttr(lastPos, (char) upper, colorAttr, false);
+ −
+ − if (gui) {
+ − // screen[lastPos].setUseGUI(UPPER);
+ − planes.setUseGUI(lastPos, UPPER);
+ − }
+ −
+ − setDirty(lastPos);
+ − advancePos();
+ − }
+ −
+ − // set upper right
+ − // screen[lastPos].setCharAndAttr((char) ur, colorAttr, false);
+ − planes.setScreenCharAndAttr(lastPos, (char) ur, colorAttr, false);
+ −
+ − if (gui) {
+ − // screen[lastPos].setUseGUI(UPPER_RIGHT);
+ − planes.setUseGUI(lastPos, UPPER_RIGHT);
+ − }
+ −
+ − setDirty(lastPos);
+ − advancePos();
+ − // set ending attribute byte
+ − planes.setScreenCharAndAttr(lastPos, initChar, initAttr, true);
+ − setDirty(lastPos);
+ − lastPos = ((getRow(lastPos) + 1) * numCols) + c;
+ −
+ − // now handle body of window
+ − while (depth-- > 0) {
+ − // set leading attribute byte
+ − planes.setScreenCharAndAttr(lastPos, initChar, initAttr, true);
+ − setDirty(lastPos);
+ − advancePos();
+ − // set left
+ − planes.setScreenCharAndAttr(lastPos, (char) left, colorAttr, false);
+ −
+ − if (gui) {
+ − planes.setUseGUI(lastPos, GUI_LEFT);
+ − }
+ −
+ − setDirty(lastPos);
+ − advancePos();
+ − w = width;
+ −
+ − // fill it in
+ − while (w-- >= 0) {
+ − // screen[lastPos].setCharAndAttr(initChar, initAttr, true);
+ − planes.setScreenCharAndAttr(lastPos, initChar, initAttr, true);
+ − // screen[lastPos].setUseGUI(NO_GUI);
+ − planes.setUseGUI(lastPos, NO_GUI);
+ − setDirty(lastPos);
+ − advancePos();
+ − }
+ −
+ − // set right
+ − // screen[lastPos].setCharAndAttr((char) right, colorAttr, false);
+ − planes.setScreenCharAndAttr(lastPos, (char) right, colorAttr, false);
+ −
+ − if (gui) {
+ − // screen[lastPos].setUseGUI(RIGHT);
+ − planes.setUseGUI(lastPos, GUI_RIGHT);
+ − }
+ −
+ − setDirty(lastPos);
+ − advancePos();
+ − // set ending attribute byte
+ − // screen[lastPos].setCharAndAttr(initChar, initAttr, true);
+ − planes.setScreenCharAndAttr(lastPos, initChar, initAttr, true);
+ − setDirty(lastPos);
+ − lastPos = ((getRow(lastPos) + 1) * numCols) + c;
+ − }
+ −
+ − // set leading attribute byte
+ − // screen[lastPos].setCharAndAttr(initChar, initAttr, true);
+ − planes.setScreenCharAndAttr(lastPos, initChar, initAttr, true);
+ − setDirty(lastPos);
+ − advancePos();
+ − // set lower left
+ − // screen[lastPos].setCharAndAttr((char) ll, colorAttr, false);
+ − planes.setScreenCharAndAttr(lastPos, (char) ll, colorAttr, false);
+ −
+ − if (gui) {
+ − // screen[lastPos].setUseGUI(LOWER_LEFT);
+ − planes.setUseGUI(lastPos, LOWER_LEFT);
+ − }
+ −
+ − setDirty(lastPos);
+ − advancePos();
+ − w = width;
+ −
+ − // draw bottom row
+ − while (w-- >= 0) {
+ − planes.setScreenCharAndAttr(lastPos, (char) bottom, colorAttr, false);
+ −
+ − if (gui) {
+ − planes.setUseGUI(lastPos, BOTTOM);
+ − }
+ −
+ − setDirty(lastPos);
+ − advancePos();
+ − }
+ −
+ − // set lower right
+ − planes.setScreenCharAndAttr(lastPos, (char) lr, colorAttr, false);
+ −
+ − if (gui) {
+ − planes.setUseGUI(lastPos, LOWER_RIGHT);
+ − }
+ −
+ − setDirty(lastPos);
+ − advancePos();
+ − // set ending attribute byte
+ − planes.setScreenCharAndAttr(lastPos, initChar, initAttr, true);
+ − setDirty(lastPos);
+ − }
+ −
+ − /**
+ − * Creates a scroll bar on the screen using the parameters provided.
+ − * ** we only support vertical scroll bars at the time.
+ − *
+ − * @param flag -
+ − * type to draw - vertical or horizontal
+ − * @param totalRowScrollable
+ − * @param totalColScrollable
+ − * @param sliderRowPos
+ − * @param sliderColPos
+ − * @param sbSize
+ − */
+ − protected void createScrollBar(int flag, int totalRowScrollable,
+ − int totalColScrollable, int sliderRowPos, int sliderColPos,
+ − int sbSize) {
+ − // System.out.println("Scrollbar flag: " + flag +
+ − // " scrollable Rows: " + totalRowScrollable +
+ − // " scrollable Cols: " + totalColScrollable +
+ − // " thumb Row: " + sliderRowPos +
+ − // " thumb Col: " + sliderColPos +
+ − // " size: " + sbSize +
+ − // " row: " + getRow(lastPos) +
+ − // " col: " + getCol(lastPos));
+ − int sp = lastPos;
+ − int size = sbSize - 2;
+ − int thumbPos = (int)(size * ((float) sliderColPos / (float) totalColScrollable));
+ − // System.out.println(thumbPos);
+ − planes.setScreenCharAndAttr(sp, ' ', 32, false);
+ − planes.setUseGUI(sp, BUTTON_SB_UP);
+ − int ctr = 0;
+ −
+ − while (ctr < size) {
+ − sp += numCols;
+ − planes.setScreenCharAndAttr(sp, ' ', 32, false);
+ −
+ − if (ctr == thumbPos)
+ − planes.setUseGUI(sp, BUTTON_SB_THUMB);
+ − else
+ − planes.setUseGUI(sp, BUTTON_SB_GUIDE);
+ −
+ − ctr++;
+ − }
+ −
+ − sp += numCols;
+ − planes.setScreenCharAndAttr(sp, ' ', 32, false);
+ − planes.setUseGUI(sp, BUTTON_SB_DN);
+ − }
+ −
+ − /**
+ − * Write the title of the window that is on the screen
+ − *
+ − * @param pos
+ − * @param depth
+ − * @param width
+ − * @param orientation
+ − * @param monoAttr
+ − * @param colorAttr
+ − * @param title
+ − */
+ − protected void writeWindowTitle(int pos, int depth, int width,
+ − byte orientation, int monoAttr, int colorAttr, StringBuffer title) {
+ − int len = title.length();
+ −
+ − // get bit 0 and 1 for interrogation
+ − switch (orientation & 0xc0) {
+ − case 0x40: // right
+ − pos += (4 + width - len);
+ − break;
+ −
+ − case 0x80: // left
+ − pos += 2;
+ − break;
+ −
+ − default: // center
+ − // this is to place the position to the first text position of the
+ − // window
+ − // the position passed in is the first attribute position, the next
+ − // is the border character and then there is another attribute after
+ − // that.
+ − pos += (3 + ((width / 2) - (len / 2)));
+ − break;
+ − }
+ −
+ − // if bit 2 is on then this is a footer
+ − if ((orientation & 0x20) == 0x20)
+ − pos += ((depth + 1) * numCols);
+ −
+ − // System.out.println(pos + "," + width + "," + len+ "," + getRow(pos)
+ − // + "," + getCol(pos) + "," + ((orientation >> 6) & 0xf0));
+ −
+ − for (int x = 0; x < len; x++) {
+ − planes.setChar(pos, title.charAt(x));
+ − planes.setUseGUI(pos++, NO_GUI);
+ − }
+ − }
+ −
+ − /**
+ − * Roll the screen up or down.
+ − *
+ − * Byte 1: Bit 0 0 = Roll up 1 = Roll down Bits 1-2 Reserved Bits 3-7 Number
+ − * of lines that the designated area is to be rolled Byte 2: Bits 0-7 Line
+ − * number defining the top line of the area that will participate in the
+ − * roll. Byte 3: Bits 0-7 Line number defining the bottom line of the area
+ − * that will participate in the roll.
+ − *
+ − * @param direction
+ − * @param topLine
+ − * @param bottomLine
+ − */
+ − protected void rollScreen(int direction, int topLine, int bottomLine) {
+ − // get the number of lines which are the last 5 bits
+ − /* int lines = direction & 0x7F; */
+ − // get the direction of the roll which is the first bit
+ − // 0 - up
+ − // 1 - down
+ − int updown = direction & 0x80;
+ − final int lines = direction & 0x7F;
+ − // calculate the reference points for the move.
+ − int start = this.getPos(topLine - 1, 0);
+ − int end = this.getPos(bottomLine - 1, numCols - 1);
+ − int len = end - start;
+ −
+ − // System.out.println(" starting roll");
+ − // dumpScreen();
+ − switch (updown) {
+ − case 0:
+ −
+ − // Now round em up and head em UP.
+ − for (int x = start; x < end + numCols; x++) {
+ − if (x + lines * numCols >= lenScreen) {
+ − //Clear at the end
+ − planes.setChar(x, ' ');
+ − }
+ − else {
+ − planes.setChar(x, planes.getChar(x + lines * numCols));
+ − }
+ − }
+ −
+ − break;
+ −
+ − case 1:
+ −
+ − // Now round em up and head em DOWN.
+ − for (int x = end + numCols; x > 0; x--) {
+ − if ((x - lines * numCols) < 0) {
+ − //Do nothing ... tooo small!!!
+ − }
+ − else {
+ − planes.setChar(x - lines * numCols, planes.getChar(x));
+ − //and clear
+ − planes.setChar(x, ' ');
+ − }
+ − }
+ −
+ − break;
+ −
+ − default:
+ − Log.w(TAG, " Invalid roll parameter - please report this");
+ − }
+ −
+ − // System.out.println(" end roll");
+ − // dumpScreen();
+ − }
+ −
+ − public void dumpScreen() {
+ − StringBuffer sb = new StringBuffer();
+ − char[] s = getScreenAsChars();
+ − int c = getColumns();
+ − int l = getRows() * c;
+ − int col = 0;
+ −
+ − for (int x = 0; x < l; x++, col++) {
+ − sb.append(s[x]);
+ −
+ − if (col == c) {
+ − sb.append('\n');
+ − col = 0;
+ − }
+ − }
+ −
+ − Log.i(TAG, sb.toString());
+ − }
+ −
+ − /**
+ − * Add a field to the field format table.
+ − *
+ − * @param attr - Field attribute
+ − * @param len - length of field
+ − * @param ffw1 - Field format word 1
+ − * @param ffw2 - Field format word 2
+ − * @param fcw1 - Field control word 1
+ − * @param fcw2 - Field control word 2
+ − */
+ − protected void addField(int attr, int len, int ffw1, int ffw2, int fcw1,
+ − int fcw2) {
+ − lastAttr = attr;
+ − planes.setScreenCharAndAttr(lastPos, initChar, lastAttr, true);
+ − setDirty(lastPos);
+ − advancePos();
+ − ScreenField sf = null;
+ −
+ − // from 14.6.12 for Start of Field Order 5940 function manual
+ − // examine the format table for an entry that begins at the current
+ − // starting address plus 1.
+ − if (screenFields.existsAtPos(lastPos)) {
+ − screenFields.setCurrentFieldFFWs(ffw1, ffw2);
+ − }
+ − else {
+ − sf = screenFields.setField(attr, getRow(lastPos), getCol(lastPos),
+ − len, ffw1, ffw2, fcw1, fcw2);
+ − lastPos = sf.startPos();
+ − int x = len;
+ − boolean gui = guiInterface;
+ −
+ − if (sf.isBypassField())
+ − gui = false;
+ −
+ − while (x-- > 0) {
+ − if (planes.getChar(lastPos) == 0)
+ − planes.setScreenCharAndAttr(lastPos, ' ', lastAttr, false);
+ − else
+ − planes.setScreenAttr(lastPos, lastAttr);
+ −
+ − if (gui) {
+ − planes.setUseGUI(lastPos, FIELD_MIDDLE);
+ − }
+ −
+ − // now we set the field plane attributes
+ − planes.setScreenFieldAttr(lastPos, ffw1);
+ − advancePos();
+ − }
+ −
+ − if (gui)
+ − if (len > 1) {
+ − planes.setUseGUI(sf.startPos(), FIELD_LEFT);
+ −
+ − if (lastPos > 0)
+ − planes.setUseGUI(lastPos - 1, FIELD_RIGHT);
+ − else
+ − planes.setUseGUI(lastPos, FIELD_RIGHT);
+ − }
+ − else {
+ − planes.setUseGUI(lastPos - 1, FIELD_ONE);
+ − }
+ −
+ − // screen[lastPos].setCharAndAttr(initChar,initAttr,true);
+ − setEndingAttr(initAttr);
+ − lastPos = sf.startPos();
+ − }
+ −
+ − // if (fcw1 != 0 || fcw2 != 0) {
+ − // System.out.println("lr = " + lastRow + " lc = " + lastCol + " " +
+ − // sf.toString());
+ − // }
+ − sf = null;
+ − }
+ −
+ −
+ − // public void addChoiceField(int attr, int len, int ffw1, int ffw2, int
+ − // fcw1, int fcw2) {
+ − //
+ − // lastAttr = attr;
+ − //
+ − // screen[lastPos].setCharAndAttr(initChar,lastAttr,true);
+ − // setDirty(lastPos);
+ − //
+ − // advancePos();
+ − //
+ − // boolean found = false;
+ − // ScreenField sf = null;
+ − //
+ − // // from 14.6.12 for Start of Field Order 5940 function manual
+ − // // examine the format table for an entry that begins at the current
+ − // // starting address plus 1.
+ − // for (int x = 0;x < sizeFields; x++) {
+ − // sf = screenFields[x];
+ − //
+ − // if (lastPos == sf.startPos()) {
+ − // screenFields.getCurrentField() = sf;
+ − // screenFields.getCurrentField().setFFWs(ffw1,ffw2);
+ − // found = true;
+ − // }
+ − //
+ − // }
+ − //
+ − // if (!found) {
+ − // sf =
+ − // setField(attr,getRow(lastPos),getCol(lastPos),len,ffw1,ffw2,fcw1,fcw2);
+ − //
+ − // lastPos = sf.startPos();
+ − // int x = len;
+ − //
+ − // boolean gui = guiInterface;
+ − // if (sf.isBypassField())
+ − // gui = false;
+ − //
+ − // while (x-- > 0) {
+ − //
+ − // if (screen[lastPos].getChar() == 0)
+ − // screen[lastPos].setCharAndAttr(' ',lastAttr,false);
+ − // else
+ − // screen[lastPos].setAttribute(lastAttr);
+ − //
+ − // if (gui)
+ − // screen[lastPos].setUseGUI(FIELD_MIDDLE);
+ − //
+ − // advancePos();
+ − //
+ − // }
+ − //
+ − // if (gui)
+ − // if (len > 1) {
+ − // screen[sf.startPos()].setUseGUI(FIELD_LEFT);
+ − // if (lastPos > 0)
+ − // screen[lastPos-1].setUseGUI(FIELD_RIGHT);
+ − // else
+ − // screen[lastPos].setUseGUI(FIELD_RIGHT);
+ − //
+ − // }
+ − // else
+ − // screen[lastPos-1].setUseGUI(FIELD_ONE);
+ − //
+ − // setEndingAttr(initAttr);
+ − //
+ − // lastPos = sf.startPos();
+ − // }
+ − //
+ − // // if (fcw1 != 0 || fcw2 != 0) {
+ − // //
+ − // // System.out.println("lr = " + lastRow + " lc = " + lastCol + " " +
+ − // sf.toString());
+ − // // }
+ − // sf = null;
+ − //
+ − // }
+ −
+ − /**
+ − * Return the fields that are contained in the Field Format Table
+ − *
+ − * @return ScreenFields object
+ − * @see org.tn5250j.ScreenFields
+ − */
+ − public ScreenFields getScreenFields() {
+ − return screenFields;
+ − }
+ −
+ − /**
+ − * Redraw the fields on the screen. Used for gui enhancement to redraw the
+ − * fields when toggling
+ − *
+ − */
+ − protected void drawFields() {
+ − ScreenField sf;
+ − int sizeFields = screenFields.getSize();
+ −
+ − for (int x = 0; x < sizeFields; x++) {
+ − sf = screenFields.getField(x);
+ −
+ − if (!sf.isBypassField()) {
+ − int pos = sf.startPos();
+ − int l = sf.length;
+ − boolean f = true;
+ −
+ − if (l >= lenScreen)
+ − l = lenScreen - 1;
+ −
+ − if (l > 1) {
+ − while (l-- > 0) {
+ − if (guiInterface && f) {
+ − planes.setUseGUI(pos, FIELD_LEFT);
+ − f = false;
+ − }
+ − else {
+ − planes.setUseGUI(pos, FIELD_MIDDLE);
+ − }
+ −
+ − if (guiInterface && l == 0) {
+ − planes.setUseGUI(pos, FIELD_RIGHT);
+ − }
+ −
+ − setDirty(pos++);
+ − }
+ − }
+ − else {
+ − planes.setUseGUI(pos, FIELD_ONE);
+ − }
+ − }
+ − }
+ −
+ − //updateDirty();
+ − }
+ −
+ − /**
+ − * Draws the field on the screen. Used to redraw or change the attributes of
+ − * the field.
+ − *
+ − * @param sf -
+ − * Field to be redrawn
+ − * @see org.tn5250j.ScreenField.java
+ − */
+ − protected void drawField(ScreenField sf) {
+ − int pos = sf.startPos();
+ − int x = sf.length;
+ −
+ − while (x-- > 0) {
+ − setDirty(pos++);
+ − }
+ −
+ − updateDirty();
+ − }
+ −
+ − /**
+ − * Set the field to be displayed as highlighted.
+ − *
+ − * @param sf -
+ − * Field to be highlighted
+ − */
+ − protected void setFieldHighlighted(ScreenField sf) {
+ − int pos = sf.startPos();
+ − int x = sf.length;
+ − int na = sf.getHighlightedAttr();
+ −
+ − while (x-- > 0) {
+ − planes.setScreenAttr(pos, na);
+ − setDirty(pos++);
+ − }
+ −
+ − fireScreenChanged();
+ − }
+ −
+ − /**
+ − * Draw the field as un higlighted. This is used to reset the field
+ − * presentation on the screen after the field is exited.
+ − *
+ − * @param sf -
+ − * Field to be unhighlighted
+ − */
+ − protected void unsetFieldHighlighted(ScreenField sf) {
+ − int pos = sf.startPos();
+ − int x = sf.length;
+ − int na = sf.getAttr();
+ −
+ − while (x-- > 0) {
+ − planes.setScreenAttr(pos, na);
+ − setDirty(pos++);
+ − }
+ −
+ − fireScreenChanged();
+ − }
+ −
+ − protected void setChar(int cByte) {
+ − if (lastPos > 0) {
+ − lastAttr = planes.getCharAttr(lastPos - 1);
+ − }
+ −
+ − if (cByte > 0 && (char)cByte < ' ') {
+ − planes.setScreenCharAndAttr(lastPos, (char) 0x00, 33, false);
+ − setDirty(lastPos);
+ − advancePos();
+ − }
+ − else {
+ − planes.setScreenCharAndAttr(lastPos, (char) cByte, lastAttr, false);
+ − setDirty(lastPos);
+ −
+ − if (guiInterface && !isInField(lastPos, false)) {
+ − planes.setUseGUI(lastPos, NO_GUI);
+ − }
+ −
+ − advancePos();
+ − }
+ − }
+ −
+ − protected void setEndingAttr(int cByte) {
+ − int attr = lastAttr;
+ − setAttr(cByte);
+ − lastAttr = attr;
+ − }
+ −
+ − protected void setAttr(int cByte) {
+ − lastAttr = cByte;
+ − // int sattr = screen[lastPos].getCharAttr();
+ − // System.out.println("changing from " + sattr + " to attr " + lastAttr
+ − // +
+ − // " at " + (this.getRow(lastPos) + 1) + "," + (this.getCol(lastPos) +
+ − // 1));
+ − planes.setScreenCharAndAttr(lastPos, initChar, lastAttr, true);
+ − setDirty(lastPos);
+ − advancePos();
+ − int pos = lastPos;
+ − int times = 0;
+ − // sattr = screen[lastPos].getCharAttr();
+ − // System.out.println(" next position after change " + sattr + " last
+ − // attr " + lastAttr +
+ − // " at " + (this.getRow(lastPos) + 1) + "," + (this.getCol(lastPos) +
+ − // 1) +
+ − // " attr place " + screen[lastPos].isAttributePlace());
+ −
+ − while (planes.getCharAttr(lastPos) != lastAttr
+ − && !planes.isAttributePlace(lastPos)) {
+ − planes.setScreenAttr(lastPos, lastAttr);
+ −
+ − if (guiInterface && !isInField(lastPos, false)) {
+ − int g = planes.getWhichGUI(lastPos);
+ −
+ − if (g >= FIELD_LEFT && g <= FIELD_ONE)
+ − planes.setUseGUI(lastPos, NO_GUI);
+ − }
+ −
+ − setDirty(lastPos);
+ − times++;
+ − advancePos();
+ − }
+ −
+ − // sanity check for right now
+ − // if (times > 200)
+ − // System.out.println(" setAttr = " + times + " start = " + (sr + 1) +
+ − // "," + (sc + 1));
+ − lastPos = pos;
+ − }
+ −
+ − protected void setScreenCharAndAttr(char right, int colorAttr, boolean isAttr) {
+ − planes.setScreenCharAndAttr(lastPos, right, colorAttr, isAttr);
+ − setDirty(lastPos);
+ − advancePos();
+ − }
+ −
+ − protected void setScreenCharAndAttr(char right, int colorAttr,
+ − int whichGui, boolean isAttr) {
+ − planes.setScreenCharAndAttr(lastPos, right, colorAttr, isAttr);
+ − planes.setUseGUI(lastPos, whichGui);
+ − setDirty(lastPos);
+ − advancePos();
+ − }
+ −
+ − /**
+ − * Draw or redraw the dirty parts of the screen and display them.
+ − *
+ − * Rectangle dirty holds the dirty area of the screen to be updated.
+ − *
+ − * If you want to change the screen in anyway you need to set the screen
+ − * attributes before calling this routine.
+ − */
+ − protected void updateDirty() {
+ − fireScreenChanged();
+ − }
+ −
+ − protected void setDirty(int pos) {
+ − int minr = Math.min(getRow(pos), getRow(dirtyScreen.x));
+ − int minc = Math.min(getCol(pos), getCol(dirtyScreen.x));
+ − int maxr = Math.max(getRow(pos), getRow(dirtyScreen.y));
+ − int maxc = Math.max(getCol(pos), getCol(dirtyScreen.y));
+ − int x1 = getPos(minr, minc);
+ − int x2 = getPos(maxr, maxc);
+ − dirtyScreen.setBounds(x1, x2, 0, 0);
+ − }
+ −
+ − private void resetDirty(int pos) {
+ − dirtyScreen.setBounds(pos, pos, 0, 0);
+ − }
+ −
+ − /**
+ − * Change the screen position by one column
+ − */
+ − protected void advancePos() {
+ − changePos(1);
+ − }
+ −
+ − /**
+ − * Change position of the screen by the increment of parameter passed.
+ − *
+ − * If the position change is under the minimum of the first screen position
+ − * then the position is moved to the last row and column of the screen.
+ − *
+ − * If the position change is over the last row and column of the screen then
+ − * cursor is moved to first position of the screen.
+ − *
+ − * @param i
+ − */
+ − protected void changePos(int i) {
+ − lastPos += i;
+ − while (lastPos < 0) lastPos += lenScreen;
+ − while (lastPos >= lenScreen) lastPos -= lenScreen;
+ − }
+ −
+ −
+ − protected void goHome() {
+ − // now we try to move to first input field according to
+ − // 14.6 WRITE TO DISPLAY Command
+ − // ? If the WTD command is valid, after the command is processed,
+ − // the cursor moves to one of three locations:
+ − // - The location set by an insert cursor order (unless control
+ − // character byte 1, bit 1 is equal to B'1'.)
+ − // - The start of the first non-bypass input field defined in the
+ − // format table
+ − // - A default starting address of row 1 column 1.
+ − if (pendingInsert && homePos > 0) {
+ − setCursor(getRow(homePos), getCol(homePos));
+ − isInField();
+ − }
+ − else {
+ − if (!gotoField(1)) {
+ − homePos = getPos(1, 1);
+ − setCursor(1, 1);
+ − isInField(0, 0);
+ − }
+ − else {
+ − homePos = getPos(getCurrentRow(), getCurrentCol());
+ − }
+ − }
+ − }
+ −
+ − protected void setPendingInsert(boolean flag, int icX, int icY) {
+ − pendingInsert = flag;
+ −
+ − if (pendingInsert) {
+ − homePos = getPos(icX, icY);
+ − }
+ −
+ − if (!isStatusErrorCode()) {
+ − setCursor(icX, icY);
+ − }
+ − }
+ −
+ − protected void setPendingInsert(boolean flag) {
+ − if (homePos != -1)
+ − pendingInsert = flag;
+ − }
+ −
+ − /**
+ − * Set the error line number to that of number passed.
+ − *
+ − * @param line
+ − */
+ − protected void setErrorLine(int line) {
+ − planes.setErrorLine(line);
+ − }
+ −
+ − /**
+ − * Returns the current error line number
+ − *
+ − * @return current error line number
+ − */
+ − protected int getErrorLine() {
+ − return planes.getErrorLine();
+ − }
+ −
+ − /**
+ − * Saves off the current error line characters to be used later.
+ − *
+ − */
+ − protected void saveErrorLine() {
+ − planes.saveErrorLine();
+ − }
+ −
+ − /**
+ − * Restores the error line characters from the save buffer.
+ − *
+ − * @see #saveErrorLine()
+ − */
+ − protected void restoreErrorLine() {
+ − if (planes.isErrorLineSaved()) {
+ − planes.restoreErrorLine();
+ − fireScreenChanged(planes.getErrorLine() - 1, 0, planes.getErrorLine() - 1, numCols - 1);
+ − }
+ − }
+ −
+ − protected void setStatus(byte attr, byte value, String s) {
+ − // set the status area
+ − switch (attr) {
+ − case STATUS_SYSTEM:
+ − if (value == STATUS_VALUE_ON) {
+ − oia.setInputInhibited(ScreenOIA.INPUTINHIBITED_SYSTEM_WAIT, ScreenOIA.OIA_LEVEL_INPUT_INHIBITED, s);
+ − }
+ − else {
+ − oia.setInputInhibited(ScreenOIA.INPUTINHIBITED_NOTINHIBITED, ScreenOIA.OIA_LEVEL_NOT_INHIBITED, s);
+ − }
+ −
+ − break;
+ −
+ − case STATUS_ERROR_CODE:
+ − if (value == STATUS_VALUE_ON) {
+ − setPrehelpState(true, true, false);
+ − oia.setInputInhibited(ScreenOIA.INPUTINHIBITED_SYSTEM_WAIT,
+ − ScreenOIA.OIA_LEVEL_INPUT_ERROR, s);
+ − sessionVT.signalBell();
+ − }
+ − else {
+ − oia.setInputInhibited(ScreenOIA.INPUTINHIBITED_NOTINHIBITED,
+ − ScreenOIA.OIA_LEVEL_NOT_INHIBITED);
+ − setPrehelpState(false, true, true);
+ − homePos = saveHomePos;
+ − saveHomePos = 0;
+ − pendingInsert = false;
+ − }
+ −
+ − break;
+ − }
+ − }
+ −
+ − protected boolean isStatusErrorCode() {
+ − return oia.getLevel() == ScreenOIA.OIA_LEVEL_INPUT_ERROR;
+ − }
+ −
+ − /**
+ − * This routine clears the screen, resets row and column to 0, resets the
+ − * last attribute to 32, clears the fields, turns insert mode off,
+ − * clears/initializes the screen character array.
+ − */
+ − protected void clearAll() {
+ − lastAttr = 32;
+ − lastPos = 0;
+ − clearTable();
+ − clearScreen();
+ − planes.setScreenAttr(0, initAttr);
+ − oia.setInsertMode(false);
+ − }
+ −
+ − /**
+ − * Clear the fields table
+ − */
+ − protected void clearTable() {
+ − oia.setKeyBoardLocked(true);
+ − screenFields.clearFFT();
+ − planes.initalizeFieldPlanes();
+ − pendingInsert = false;
+ − homePos = -1;
+ − }
+ −
+ − /**
+ − * Clear the gui constructs
+ − *
+ − */
+ − protected void clearGuiStuff() {
+ − for (int x = 0; x < lenScreen; x++) {
+ − planes.setUseGUI(x, NO_GUI);
+ − }
+ −
+ − dirtyScreen.setBounds(0, lenScreen - 1, 0, 0);
+ − }
+ −
+ − /**
+ − * Clear the screen by setting the initial character and initial attribute
+ − * to all the positions on the screen
+ − */
+ − protected void clearScreen() {
+ − planes.initalizePlanes();
+ − dirtyScreen.setBounds(0, lenScreen - 1, 0, 0);
+ − oia.clearScreen();
+ − }
+ −
+ − protected void restoreScreen() {
+ − lastAttr = 32;
+ − dirtyScreen.setBounds(0, lenScreen - 1, 0, 0);
+ − updateDirty();
+ − }
+ −
+ − public void onFontSizeChanged(float size) {
+ − fireScreenChanged(0, 0, numRows-1, numCols-1);
+ − }
+ −
+ − /**
+ − * repaint part of the screen
+ − *
+ − */
+ − private void fireScreenChanged(int startRow, int startCol, int endRow, int endCol) {
+ − int [] vt320color = {0x0, // black
+ − 0x4, // blue
+ − 0x2, // green
+ − 0x6, // cyan
+ − 0x1, // red
+ − 0x5, // magenta/purple
+ − 0xb, // yellow
+ − 0x7, // light gray/white
+ − 0x8, // dark gray
+ − 0xc, // light blue
+ − 0xa, // light green
+ − 0xe, // light cyan
+ − 0x9, // light red
+ − 0xd, // light magenta/purple
+ − 0x3, // brown
+ − 0xf // bright white
+ − };
+ −
+ − for (int r = startRow; r <= endRow; r++) {
+ − for (int c = startCol; c <= endCol; c++) {
+ − int p = getPos(r, c);
+ − char ch = planes.getChar(p);
+ − char co = planes.getCharColor(p);
+ − char at = planes.getCharExtended(p);
+ − boolean ia = planes.isAttributePlace(p);
+ −
+ − if (ch < ' ') ch = ' ';
+ −
+ − int bg = vt320color[(co >> 8) & 0x0f] + 1;
+ − int fg = vt320color[co & 0x0f] + 1;
+ − int ul = at & EXTENDED_5250_UNDERLINE;
+ − int nd = at & EXTENDED_5250_NON_DSP;
+ − int vt_attr = (fg << VDUBuffer.COLOR_FG_SHIFT) + (bg << VDUBuffer.COLOR_BG_SHIFT);
+ −
+ − if (ul > 0) vt_attr |= VDUBuffer.UNDERLINE;
+ −
+ − if (ia || (nd > 0)) vt_attr |= VDUBuffer.INVISIBLE;
+ −
+ − buffer.putChar(c, r, ch, vt_attr);
+ − }
+ − }
+ −
+ − buffer.redrawPassthru();
+ − dirtyScreen.setBounds(lenScreen, 0, 0, 0);
+ − }
+ −
+ − /**
+ − * repaint the dirty part of the screen
+ − *
+ − */
+ −
+ − private synchronized void fireScreenChanged() {
+ − if (dirtyScreen.x > dirtyScreen.y) {
+ − Log.i(TAG, " x < y " + dirtyScreen);
+ − return;
+ − }
+ −
+ − fireScreenChanged(getRow(dirtyScreen.x), getCol(dirtyScreen.x),
+ − getRow(dirtyScreen.y), getCol(dirtyScreen.y));
+ − }
+ −
+ − /**
+ − * update the cursor position
+ − *
+ − */
+ −
+ − private synchronized void fireCursorChanged() {
+ − int l = getRow(lastPos);
+ − int c = getCol(lastPos);
+ − buffer.setCursorPosition(c, l);
+ − }
+ −
+ − /**
+ − * update the screen size.
+ − */
+ − private void fireScreenSizeChanged() {
+ − buffer.setScreenSize(numCols, numRows, true);
+ − }
+ −
+ − /**
+ − * This method does a complete refresh of the screen.
+ − */
+ − public final void updateScreen() {
+ − repaintScreen();
+ − setCursorActive(false);
+ − setCursorActive(true);
+ − }
+ −
+ − /**
+ − * Utility method to share the repaint behaviour between setBounds() and
+ − * updateScreen.
+ − */
+ − public void repaintScreen() {
+ − setCursorOff();
+ − dirtyScreen.setBounds(0, lenScreen - 1, 0, 0);
+ − updateDirty();
+ −
+ − // restore statuses that were on the screen before resize
+ − if (oia.getLevel() == ScreenOIA.OIA_LEVEL_INPUT_ERROR) {
+ − oia.setInputInhibited(ScreenOIA.INPUTINHIBITED_SYSTEM_WAIT,
+ − ScreenOIA.OIA_LEVEL_INPUT_ERROR);
+ − }
+ −
+ − if (oia.getLevel() == ScreenOIA.OIA_LEVEL_INPUT_INHIBITED) {
+ − oia.setInputInhibited(ScreenOIA.INPUTINHIBITED_SYSTEM_WAIT,
+ − ScreenOIA.OIA_LEVEL_INPUT_INHIBITED);
+ − }
+ −
+ − if (oia.isMessageWait())
+ − oia.setMessageLightOn();
+ −
+ − setCursorOn();
+ − }
+ −
+ − // ADDED BY BARRY - changed by Kenneth to use the character plane
+ − // This should be replaced with the getPlane methods when they are implemented
+ − public char[] getCharacters() {
+ − return planes.screen;
+ − }
+ −
+ − }