line source
/**
* Title: tn5250J
* Copyright: Copyright (c) 2001
* 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.BOTTOM;
import static org.tn5250j.TN5250jConstants.GUI_LEFT;
import static org.tn5250j.TN5250jConstants.GUI_RIGHT;
import static org.tn5250j.TN5250jConstants.LOWER_LEFT;
import static org.tn5250j.TN5250jConstants.LOWER_RIGHT;
import static org.tn5250j.TN5250jConstants.NO_GUI;
import static org.tn5250j.TN5250jConstants.NR_REQUEST_ERROR;
import static org.tn5250j.TN5250jConstants.UPPER;
import static org.tn5250j.TN5250jConstants.UPPER_LEFT;
import static org.tn5250j.TN5250jConstants.UPPER_RIGHT;
import java.util.ArrayList;
import java.util.List;
import org.tn5250j.encoding.ICodePage;
import android.util.Log;
/**
*
* Write To Display Structured Field:
*
* This module will parse the structured field information for enhanced
* emulation mode.
*
*/
public class WTDSFParser {
private static final String TAG = "WTDSFParser";
private Screen5250 screen52;
private tnvt vt;
private ICodePage codePage;
int pos;
byte[] segment;
int length;
boolean error;
boolean guiStructsExist;
private final List<Window> guiStructs = new ArrayList<Window>(3);
private final List<ChoiceField> choices = new ArrayList<ChoiceField>(3);
WTDSFParser (tnvt vt) {
this.vt = vt;
screen52 = vt.screen52;
codePage = vt.codePage;
}
protected class ChoiceField {
int x;
int y;
int row;
int col;
int width;
int height;
char mnemonic;
int fieldId;
int selectIndex;
ChoiceField(int row, int col, int fldRow, int fldCol) {
x = row;
y = col;
row = fldRow;
col = fldCol;
}
}
protected class Window {
byte[] window;
int pos;
Window(byte[] seg, int pos) {
//Log.i(TAG,"window created at " + pos);
window = seg;
this.pos = pos;
guiStructsExist = true;
}
}
protected void addChoiceField(int row,int col,int fldRow, int fldCol, String text) {
ChoiceField cf = new ChoiceField(row,col, fldRow, fldCol);
cf.fieldId = screen52.getScreenFields().getCurrentField().getFieldId();
choices.add(cf);
}
protected boolean isGuisExists () {
return guiStructsExist;
}
protected byte[] getSegmentAtPos(int pos) {
int len = guiStructs.size();
for (int x = 0; x < len; x++) {
Window w = guiStructs.get(x);
if (w.pos == pos)
return w.window;
}
return null;
}
protected void clearGuiStructs() {
guiStructs.clear();
}
protected boolean parseWriteToDisplayStructuredField(byte[] seg) {
// bk = vt.bk;
error = false;
boolean done = false;
boolean windowDefined = false;
// int nextone;
pos = 0;
segment = seg;
// try {
length = (( segment[pos++] & 0xff )<< 8 | (segment[pos++] & 0xff));
while (!done) {
int s = segment[pos++] & 0xff;
switch (s) {
case 0xD9: // Class Type 0xD9 - Create Window
switch (segment[pos++]) {
case 0x50: // Define Selection Field
defineSelectionField(length);
done = true;
break;
case 0x51: // Create Window
guiStructs.add(new Window(segment, screen52.getLastPos()));
boolean cr = false;
int rows = 0;
int cols = 0;
// pull down not supported yet
if ((segment[pos++] & 0x80) == 0x80)
cr = true; // restrict cursor
pos++; // get reserved field pos 6
pos++; // get reserved field pos 7
rows = segment[pos++]; // get window depth rows pos 8
cols = segment[pos++]; // get window width cols pos 9
length -= 9;
if (length == 0) {
done = true;
// System.out.println("Create Window");
// System.out.println(" restrict cursor " + cr);
// System.out.println(" Depth = " + rows + " Width = " + cols);
// screen52.createWindow(rows,cols,1,true,32,58,
createWindow(rows,cols,1,true,32,58,
'.',
'.',
'.',
':',
':',
':',
'.',
':');
windowDefined = true;
break;
}
// pos 10 is Minor Structure
int ml = 0;
int type = 0;
int lastPos = screen52.getLastPos();
// if (cr)
// screen52.setPendingInsert(true,
// screen52.getCurrentRow(),
// screen52.getCurrentCol());
int mAttr = 0;
int cAttr = 0;
while (length > 0) {
// get minor length
ml = ( segment[pos++] & 0xff );
length -= ml;
// only normal windows are supported at this time
type = segment[pos++];
switch (type) {
case 0x01 : // Border presentation
boolean gui = false;
if ((segment[pos++] & 0x80) == 0x80)
gui = true;
mAttr = segment[pos++];
cAttr = segment[pos++];
char ul = '.';
char upper = '.';
char ur = '.';
char left = ':';
char right = ':';
char ll = ':';
char bottom = '.';
char lr = ':';
// if minor length is greater than 5 then
// the border characters are specified
if (ml > 5) {
ul = codePage.ebcdic2uni(segment[pos++]);
// ul = getASCIIChar(segment[pos++]);
if (ul == 0)
ul = '.';
upper = codePage.ebcdic2uni(segment[pos++]);
// upper = getASCIIChar(segment[pos++]);
if (upper == 0)
upper = '.';
ur = codePage.ebcdic2uni(segment[pos++]);
// ur = getASCIIChar(segment[pos++]);
if (ur == 0)
ur = '.';
left = codePage.ebcdic2uni(segment[pos++]);
// left = getASCIIChar(segment[pos++]);
if (left == 0)
left = ':';
right = codePage.ebcdic2uni(segment[pos++]);
// right = getASCIIChar(segment[pos++]);
if (right == 0)
right = ':';
ll = codePage.ebcdic2uni(segment[pos++]);
// ll = getASCIIChar(segment[pos++]);
if (ll == 0)
ll = ':';
bottom = codePage.ebcdic2uni(segment[pos++]);
// bottom = getASCIIChar(segment[pos++]);
if (bottom == 0)
bottom = '.';
lr = codePage.ebcdic2uni(segment[pos++]);
// lr = getASCIIChar(segment[pos++]);
if (lr == 0)
lr = ':';
}
// System.out.println("Create Window");
// System.out.println(" restrict cursor " + cr);
// System.out.println(" Depth = " + rows + " Width = " + cols);
// System.out.println(" type = " + type + " gui = " + gui);
// System.out.println(" mono attr = " + mAttr + " color attr = " + cAttr);
// System.out.println(" ul = " + ul + " upper = " + upper +
// " ur = " + ur +
// " left = " + left +
// " right = " + right +
// " ll = " + ll +
// " bottom = " + bottom +
// " lr = " + lr
// );
// screen52.createWindow(rows,cols,type,gui,mAttr,cAttr,
createWindow(rows,cols,type,gui,mAttr,cAttr,
ul,
upper,
ur,
left,
right,
ll,
bottom,
lr);
windowDefined = true;
break;
//
// The following shows the input for window with a title
//
// +0000 019A12A0 00000400 00020411 00200107 .?.?..?...?..?.
// +0010 00000018 00000011 06131500 37D95180 ........?.?..R??
// +0020 00000A24 0D018023 23404040 40404040 ..??..???
// +0030 40211000 000000D7 C2C1D9C4 C5D4D67A \uFFFD.....PBARDEMO:
// +0040 40D79996 879985A2 A2408281 99408485 Progress bar de
// +0050 94961108 1520D5A4 94828599 40968640 mo.???Number of
// +0060 8595A399 8985A24B 4B4B4B4B 4B7A2011 entries......:?.
// +0070 082E2040 404040F5 F0F06BF0 F0F02011 ?.? 500,000?.
// +0080 091520C3 A4999985 95A34085 95A399A8 \uFFFD??Current entry
// +0090 4095A494 8285994B 4B4B7A20 11092E20 number...:?.\uFFFD.?
// +00A0 40404040 4040F56B F0F0F020 110A1520 5,000?.???
// +00B0 D9859481 89958995 87408595 A3998985 Remaining entrie
// +00C0 A24B4B4B 4B4B4B7A 20110A2E 20404040 s......:?.?.?
// +00D0 40F4F9F5 6BF0F0F0 20110C15 20E2A381 495,000?..??Sta
// +00E0 99A340A3 8994854B 4B4B4B4B 4B4B4B4B rt time.........
// +00F0 4B4B4B4B 7A20110C 2F2040F7 7AF5F37A ....:?...? 7:53:
case 0x10 : // Window title/footer
if (!windowDefined) {
// screen52.createWindow(rows,cols,1,true,32,58,
guiStructs.add(new Window(segment, screen52.getLastPos()));
createWindow(rows,cols,1,true,32,58,
'.',
'.',
'.',
':',
':',
':',
'.',
':');
windowDefined = true;
}
byte orientation = segment[pos++];
mAttr = segment[pos++];
cAttr = segment[pos++];
//reserved
pos++;
ml -= 6;
StringBuffer hfBuffer = new StringBuffer(ml);
while (ml-- > 0) {
//LDC - 13/02/2003 - Convert it to unicode
hfBuffer.append(codePage.ebcdic2uni(segment[pos++]));
// hfBuffer.append(getASCIIChar(segment[pos++]));
}
Log.d(TAG,
" orientation " + Integer.toBinaryString(orientation) +
" mAttr " + mAttr +
" cAttr " + cAttr +
" Header/Footer " + hfBuffer);
screen52.writeWindowTitle(lastPos,
rows,
cols,
orientation,
mAttr,
cAttr,
hfBuffer);
break;
default:
Log.w(TAG,"Invalid Window minor structure");
length = 0;
done = true;
}
}
done = true;
break;
case 0x53: // Scroll Bar
int sblen = 15;
byte sbflag = segment[pos++]; // flag position 5
pos++; // reserved position 6
// position 7,8
int totalRowScrollable = (( segment[pos++] & 0xff )<< 8
| (segment[pos++] & 0xff));
// position 9,10
int totalColScrollable = (( segment[pos++] & 0xff )<< 8
| (segment[pos++] & 0xff));
// position 11,12
int sliderRowPos = (( segment[pos++] & 0xff )<< 8
| (segment[pos++] & 0xff));
// position 13,14
int sliderColPos = (( segment[pos++] & 0xff )<< 8
| (segment[pos++] & 0xff));
// position 15
int sliderRC = segment[pos++];
screen52.createScrollBar(sbflag,totalRowScrollable,
totalColScrollable,
sliderRowPos,
sliderColPos,
sliderRC);
length -= 15;
done = true;
break;
case 0x5B: // Remove GUI ScrollBar field
pos++; // reserved must be set to off pos 5
pos++; // reserved must be set to zero pos 6
done = true;
break;
case 0x5F: // Remove All GUI Constructs
Log.i(TAG,"remove all gui contructs");
clearGuiStructs();
guiStructsExist = false;
int len = 4;
int d = 0;
length -= s;
while (--len > 0)
d = segment[pos++];
// if (length > 0) {
// len = (segment[pos++] & 0xff )<< 8;
//
// while (--len > 0)
// d = segment[pos++];
// }
screen52.clearGuiStuff();
// per 14.6.13.4 documentation we should clear the
// format table after this command
screen52.clearTable();
done = true;
break;
case 0x59: // remove gui window
Log.i(TAG," remove window at " + screen52.getCurrentPos());
done = true;
break;
case 0x60: // Erase/Draw Grid Lines - not supported
// do not know what they are
// as of 03/11/2002 we should not be getting
// this anymore but I will leave it here
// just in case.
// System.out.println("erase/draw grid lines " + length);
len = 6;
d = 0;
length -= 9;
while (--len > 0)
d = segment[pos++];
if (length > 0) {
len = (segment[pos++] & 0xff )<< 8;
while (--len > 0) {
d = segment[pos++];
}
}
done = true;
break;
default:
vt.sendNegResponse(NR_REQUEST_ERROR,0x03,0x01,0x01,"invalid wtd structured field sub command "
+ ( pos - 1));
// + bk.getByteOffset(-1));
error = true;
break;
}
break;
default:
vt.sendNegResponse(NR_REQUEST_ERROR,0x03,0x01,0x01,
"invalid wtd structured field command "
+ (pos - 1));
// + bk.getByteOffset(-1));
error = true;
break;
}
if (error)
done = true;
}
// }
// catch (Exception e) {};
return error;
}
/**
* 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 lastPos = screen52.getLastPos();
int numCols = screen52.getColumns();
int c = screen52.getCol(lastPos);
int w = 0;
width++;
w = width;
char initChar = Screen5250.initChar;
int initAttr = Screen5250.initAttr;
// set leading attribute byte
screen52.setScreenCharAndAttr(initChar, initAttr, true);
// set upper left
if (gui) {
screen52.setScreenCharAndAttr((char) ul, colorAttr, UPPER_LEFT, false);
}
else {
screen52.setScreenCharAndAttr((char) ul, colorAttr, false);
}
// draw top row
while (w-- >= 0) {
if (gui) {
screen52.setScreenCharAndAttr((char) upper, colorAttr, UPPER,false);
}
else {
screen52.setScreenCharAndAttr((char) upper, colorAttr, false);
}
}
// set upper right
if (gui) {
screen52.setScreenCharAndAttr((char) ur, colorAttr, UPPER_RIGHT, false);
}
else {
screen52.setScreenCharAndAttr((char) ur, colorAttr, false);
}
// set ending attribute byte
screen52.setScreenCharAndAttr(initChar, initAttr, true);
lastPos = ((screen52.getRow(lastPos) + 1) * numCols) + c;
screen52.goto_XY(lastPos);
// now handle body of window
while (depth-- > 0) {
// set leading attribute byte
screen52.setScreenCharAndAttr(initChar, initAttr, true);
// set left
if (gui) {
screen52.setScreenCharAndAttr((char) left, colorAttr, GUI_LEFT, false);
}
else {
screen52.setScreenCharAndAttr((char) left, colorAttr, false);
}
w = width - 2;
screen52.setScreenCharAndAttr(initChar, initAttr, NO_GUI, true);
// fill it in
while (w-- >= 0) {
// if (!planes.isUseGui(screen52.getLastPos()))
screen52.setScreenCharAndAttr(initChar, initAttr, NO_GUI, false);
}
screen52.setScreenCharAndAttr(initChar, initAttr, NO_GUI, true);
// set right
if (gui) {
screen52.setScreenCharAndAttr((char) right, colorAttr, GUI_RIGHT, false);
}
else {
screen52.setScreenCharAndAttr((char) right, colorAttr, false);
}
screen52.setScreenCharAndAttr(initChar, initAttr, true);
lastPos = ((screen52.getRow(lastPos) + 1) * numCols) + c;
screen52.goto_XY(lastPos);
}
// set leading attribute byte
screen52.setScreenCharAndAttr(initChar, initAttr, true);
if (gui) {
screen52.setScreenCharAndAttr((char) ll, colorAttr, LOWER_LEFT, false);
}
else {
screen52.setScreenCharAndAttr((char) ll, colorAttr, false);
}
w = width;
// draw bottom row
while (w-- >= 0) {
if (gui) {
screen52.setScreenCharAndAttr((char) bottom, colorAttr, BOTTOM, false);
}
else {
screen52.setScreenCharAndAttr((char) bottom, colorAttr, false);
}
}
// set lower right
if (gui) {
screen52.setScreenCharAndAttr((char) lr, colorAttr, LOWER_RIGHT, false);
}
else {
screen52.setScreenCharAndAttr((char) lr, colorAttr, false);
}
// set ending attribute byte
screen52.setScreenCharAndAttr(initChar, initAttr, true);
}
/* *** NEVER USED LOCALLY ************************************************** */
// private void clearWindowBody(ScreenPlanes planes, int startPos, int depth, int width) {
//
// int lastPos = startPos;
// char initChar = Screen5250.initChar;
// int initAttr = Screen5250.initAttr;
//
// // 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();
//
// int 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);
// 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 = startPos;
// }
//
// }
/* *** NEVER USED LOCALLY ************************************************** */
// private void setDirty(int pos) {
//
// screen52.setDirty(pos);
//
// }
/* *** NEVER USED LOCALLY ************************************************** */
// private void advancePos() {
//
// screen52.advancePos();
// }
private void defineSelectionField(int majLen) {
// 0030: 20 00 2C 3E 00 00 00 69 12 A0 00 00 04 00 00 03 .,>...i........
// 0040: 04 40 04 11 00 28 01 07 00 00 00 19 00 00 04 11 .@...(..........
// 0050: 14 19 15 00 48 D9 50 00 60 00 11 01 84 84 00 00 ....H.P.`.......
// 0060: 05 03 01 01 00 00 00 13 01 E0 00 21 00 21 00 3B ...........!.!.;
// 0070: 22 20 20 20 20 3A 24 20 20 3A 0B 10 08 00 E0 00 " :$ :......
// 0080: D6 95 85 40 40 0B 10 08 00 E0 00 E3 A6 96 40 40 ...@@.........@@
// 0090: 0B 10 08 00 E0 00 E3 88 99 85 85 04 52 00 00 FF ............R...
// 00A0: EF .
try {
int flag1 = segment[pos++]; // Flag byte 1 - byte 5
int flag2 = segment[pos++]; // Flag byte 2 - byte 6
int flag3 = segment[pos++]; // Flag byte 3 - byte 7
int typeSelection = segment[pos++]; // Type of selection Field - byte 8
// GUI Device Characteristics:
// This byte is used if the target device is a GUI PWS or a GUI-like
// NWS. If neigher of these WS are the targets, this byte is ignored
int guiDevice = segment[pos++]; // byte 9
int withMnemonic = segment[pos++]; // byte 10
int noMnemonic = segment[pos++]; // byte 11
pos++; // Reserved - byte 12
pos++; // Reserved - byte 13
int cols = segment[pos++]; // Text Size - byte 14
int rows = segment[pos++]; // Rows - byte 15
int maxColChoice = segment[pos++]; // byte 16 num of column choices
int padding = segment[pos++]; // byte 17
int numSepChar = segment[pos++]; // byte 18
int ctySepChar = segment[pos++]; // byte 19
int cancelAID = segment[pos++]; // byte 20
int cnt = 0;
int minLen = 0;
majLen -= 21;
Log.d(TAG," row: " + screen52.getCurrentRow()
+ " col: " + screen52.getCurrentCol()
+ " type " + typeSelection
+ " gui " + guiDevice
+ " withMnemonic " + Integer.toHexString(withMnemonic & 0xf0)
+ " noMnemonic " + Integer.toHexString(noMnemonic & 0xf0)
+ " noMnemonic " + Integer.toBinaryString(noMnemonic)
+ " noMnemonicType " + Integer.toBinaryString((noMnemonic & 0xf0))
+ " noMnemonicSel " + Integer.toBinaryString((noMnemonic & 0x0f))
+ " maxcols " + maxColChoice
+ " cols " + cols
+ " rows " + rows);
int rowCtr = 0;
int colCtr = 0;
int chcRowStart = screen52.getCurrentRow();
int chcColStart = screen52.getCurrentCol();
int chcRow = chcRowStart;
int chcCol = chcColStart;
int chcPos = screen52.getPos(chcRow-1,chcCol);
// client access
//0000 00 04 ac 9e b9 35 00 01 02 32 bb 4e 08 00 45 00 .....5...2.N..E.
//0010 00 3c 4f 8e 40 00 80 06 00 00 c1 a8 33 58 c1 a8 .<O.@.......3X..
//0020 33 01 09 e4 00 17 5b bf b7 a4 c3 41 43 d1 50 18 3.....[....AC.P.
//0030 fc de e9 d8 00 00 00 12 12 a0 00 00 04 00 80 03 ................
//0040 16 18 f1 11 14 1a 00 22 ff ef ......."..
int colAvail = 0x20;
int colSelAvail = 0x20;
int fld = 0;
do {
minLen = segment[pos++]; // Minor Length byte 21
int minType = segment[pos++]; // Minor Type
switch (minType) {
case 0x01: // Choice Presentation Display
// flag
int flagCP1 = segment[pos++];
pos++; // mon select cursor avail emphasis - byte4
colSelAvail = segment[pos++]; // -byte 5
pos++; // mon select cursor - byte 6
int colSelCur = segment[pos++]; // -byte 7
pos++; // mon select cursor not avail emphasis - byte 8
int colSelNotAvail = segment[pos++]; // -byte 9
pos++; // mon avail emphasis - byte 10
colAvail = segment[pos++]; // -byte 11
pos++; // mon select emphasis - byte 12
int colSel = segment[pos++]; // -byte 13
pos++; // mon not avail emphasis - byte 14
int colNotAvail = segment[pos++]; // -byte 15
pos++; // mon indicator emphasis - byte 16
int colInd = segment[pos++]; // -byte 17
pos++; // mon indicator not avail emphasis - byte 18
int colNotAvailInd = segment[pos++]; // -byte 19
break;
case 0x10: // Choice Text minor structure
cnt = 5;
int flagCT1 = segment[pos++];
int flagCT2 = segment[pos++];
int flagCT3 = segment[pos++];
int mnemOffset = 0;
boolean aid = false;
boolean selected = false;
// is in selected state
if ((flagCT1 & 0x40) == 0x40) {
Log.d(TAG," selected ");
selected = true;
}
//System.out.println(Integer.toBinaryString((flagCT1 & 0xf0)));
// is mnemonic offset specified
if ((flagCT1 & 0x08) == 8) {
Log.d(TAG," mnemOffset " + mnemOffset);
mnemOffset = segment[pos++];
cnt++;
}
// is aid key specified
if ((flagCT1 & 0x04) == 4) {
aid = true;
Log.d(TAG," aidKey " + aid);
// cnt++;
}
// is single digit number specified
if ((flagCT1 & 0x01) == 0x01) {
Log.d(TAG," single digit " );
pos++;
cnt++;
}
// is double digint number specified
if ((flagCT1 & 0x02) == 0x02) {
Log.d(TAG," double digit " );
pos++;
cnt++;
}
String s = "";
byte byte0 = 0;
fld++;
screen52.setCursor(chcRowStart,chcColStart);
// we do not add a selection if it is marked as unavailable
if ((flagCT1 & 0x80) != 0x80) {
screen52.addField(0x26,1,0,0,0,0);
screen52.getScreenFields().getCurrentField().setFieldChar('.');
screen52.getScreenFields().getCurrentField().setSelectionFieldInfo(17,
fld,
chcPos);
screen52.setCursor(chcRowStart,chcColStart + 3);
for (;cnt < minLen; cnt++) {
byte0 = segment[pos++];
s += vt.codePage.ebcdic2uni(byte0);
screen52.setChar(vt.codePage.ebcdic2uni(byte0));
}
addChoiceField(chcRowStart,chcColStart,chcRow,chcCol,s);
}
// screen52.getScreenFields().getCurrentField().setMDT();
Log.d(TAG,s + " selected " + selected);
// chcRowStart;
//maxColChoice
colCtr++;
// rowCtr++;
if (colCtr >= maxColChoice) {
rowCtr++;
colCtr=0;
chcColStart = chcCol;
chcRowStart = chcRow + rowCtr;
if (rowCtr > rows) {
chcRowStart = chcRow;
rowCtr = 0;
chcColStart = chcColStart + 3 + cols + padding;
}
}
else {
chcColStart = chcColStart + padding + cols + 3;
//
}
break;
default:
for (cnt = 2;cnt < minLen; cnt++) {
pos++;
}
}
majLen -= minLen;
} while (majLen > 0);
}
catch (Exception exc) {
Log.w(TAG," defineSelectionField :", exc);
exc.printStackTrace();
}
}
// negotiating commands
// private static final byte IAC = (byte)-1; // 255 FF
// private static final byte DONT = (byte)-2; //254 FE
// private static final byte DO = (byte)-3; //253 FD
// private static final byte WONT = (byte)-4; //252 FC
// private static final byte WILL = (byte)-5; //251 FB
// private static final byte SB = (byte)-6; //250 Sub Begin FA
// private static final byte SE = (byte)-16; //240 Sub End F0
// private static final byte EOR = (byte)-17; //239 End of Record EF
// private static final byte TERMINAL_TYPE = (byte)24; // 18
// private static final byte OPT_END_OF_RECORD = (byte)25; // 19
// private static final byte TRANSMIT_BINARY = (byte)0; // 0
// private static final byte QUAL_IS = (byte)0; // 0
// private static final byte TIMING_MARK = (byte)6; // 6
// private static final byte NEW_ENVIRONMENT = (byte)39; // 27
// private static final byte IS = (byte)0; // 0
// private static final byte SEND = (byte)1; // 1
// private static final byte INFO = (byte)2; // 2
// private static final byte VAR = (byte)0; // 0
// private static final byte VALUE = (byte)1; // 1
// private static final byte NEGOTIATE_ESC = (byte)2; // 2
// private static final byte USERVAR = (byte)3; // 3
// miscellaneous
// private static final byte ESC = 0x04; // 04
// private static final char char0 = 0;
// private static final byte CMD_READ_IMMEDIATE_ALT = (byte)0x83; // 131
}