/*===========================================================================*/
/* Copyright (c) 1987 - 1988, Future Soft Engineering, Inc. */
/* Houston, Texas */
/*===========================================================================*/
#define NOLSTRING TRUE /* jtf win3 mod */
#include <windows.h>
#include "port1632.h"
#include "dcrc.h"
#include "dynacomm.h"
#include "task.h"
#include "video.h"
#include "printfil.h"
static BOOL decPrivate; /* True if ? in set mode string */
static BOOL heathPrivate; /* True if > in set mode string */
#define MAXANSIARGS 10
static INT argNdx;
static INT argCount;
static INT ansiArg;
static INT argList[MAXANSIARGS+1];
static INT vidFG;
static INT p1;
static INT p2;
static INT saveCol = 0;
static INT saveLin = 0;
/*---------------------------------------------------------------------------*/
/* valIndex() - Return index into buffer given current line & column. [scf] */
/*---------------------------------------------------------------------------*/
INT valIndex ()
{
return ((curLin + savTopLine) * (maxChars + 2) + curCol);
}
/*---------------------------------------------------------------------------*/
/* cleanRect() - Erase nLines starting at line */
/*---------------------------------------------------------------------------*/
VOID cleanRect(INT line, INT nLines)
{
RECT eraseRect;
INT eraseLine;
eraseRect = hTE.viewRect;
eraseRect.top = (line + (savTopLine - curTopLine)) * chrHeight;
if((eraseLine = eraseRect.top + (nLines * chrHeight)) < eraseRect.bottom)
eraseRect.bottom = eraseLine;
if(eraseRect.top < eraseRect.bottom)
{
eraseColorRect((HDC) getPort(), (LPRECT) &eraseRect, ANORMAL);
releasePort();
}
}
/*---------------------------------------------------------------------------*/
/* scrollBuffer() - [scf] */
/*---------------------------------------------------------------------------*/
proc scrollBuffer ()
{
register INT line; // sdj: was unref- count;
INT buffLines;
RECT scrollRect, notScrollRect;
buffLines = savTopLine - curTopLine;
buffLines = min (buffLines, visScreenLine + 1);
if (buffLines > 0)
{
scrollRect = notScrollRect = hTE.viewRect;
if (lineFeeds < buffLines)
{
scrollRect.bottom = buffLines * chrHeight;
ScrollWindow (hTermWnd, 0, -(lineFeeds * chrHeight),
(LPRECT) &scrollRect, (LPRECT) &scrollRect);
}
lineFeeds = min (buffLines, lineFeeds);
line = -lineFeeds;
if(curTopLine == 0)
line += (visScreenLine+1) - savTopLine;
reDrawTermScreen(0, lineFeeds, line);
notScrollRect.top = scrollRect.bottom; /* Only validate our */
ValidateRect (hTermWnd, (LPRECT) ¬ScrollRect); /* stuff that we */
} /* repaint */
lineFeeds = 0;
}
/*---------------------------------------------------------------------------*/
/* doScroll() - */
/*---------------------------------------------------------------------------*/
proc doScroll ()
{
INT top, bottom, line, nLines; //sdj: was unref- buffLines;
RECT scrollRect, uncoveredRect;
top = savTopLine - curTopLine + scrollBegin;
bottom = top + (scrollEnd + 1 - scrollBegin);
top = max (top, 0);
bottom = min (bottom, visScreenLine + 1);
scrollRect.top = top * chrHeight;
scrollRect.bottom = bottom * chrHeight;
scrollRect.right = hTE.viewRect.right;
scrollRect.left = hTE.viewRect.left;
getPort ();
clipRect (&hTE.viewRect);
if (scrollRect.bottom > scrollRect.top)
{
hideTermCursor ();
if (abs(nScroll) < bottom - top)
{
ScrollWindow (hTermWnd, 0, -(nScroll * chrHeight),
(LPRECT) &scrollRect, (LPRECT) &scrollRect);
uncoveredRect.right = hTE.viewRect.right;
uncoveredRect.left = hTE.viewRect.left;
if (nScroll < 0) /* Inserting lines */
{
uncoveredRect.top = scrollRect.top;
uncoveredRect.bottom = scrollRect.top + ((-nScroll) * chrHeight);
} else /* Line feeds or deleting lines */
{
uncoveredRect.top = scrollRect.bottom - nScroll * chrHeight;
uncoveredRect.bottom = scrollRect.bottom;
}
ValidateRect (hTermWnd, (LPRECT) &uncoveredRect);
}
nLines = min (abs(nScroll), bottom - top);
if (nScroll > 0)
top = bottom - nLines + curTopLine - savTopLine;
else
top = top + curTopLine - savTopLine;
for (line = top; line < top + nLines; line++)
attrib[line][LFLAGS] = (LDIRTY | LCLEAR);
showTermCursor ();
}
releasePort ();
nScroll = 0;
}
/*---------------------------------------------------------------------------*/
/* termCleanUp() - */
/*---------------------------------------------------------------------------*/
VOID termCleanUp ()
{
register INT line, lin2;
BYTE lattr;
// sdj: was unref local - BYTE *attr;
checkSelect();
if(nScroll != 0)
doScroll();
if(lineFeeds != 0)
scrollBuffer();
for(line = 0; line <= maxScreenLine+1; )
{
lattr = attrib[line][LFLAGS];
if(lattr & LDIRTY)
{
updateLine(line);
line++;
}
else if(lattr & LCLEAR)
{
attrib[line][LFLAGS] = 0;
for(lin2 = line+1; lin2 <= maxScreenLine; lin2++)
{
if (lattr != attrib[lin2][LFLAGS])
break;
attrib[lin2][LFLAGS] = 0;
}
cleanRect (line, lin2 - line);
line = lin2;
}
else
line++;
}
termDirty = FALSE; /* mbbx: termLine -> termDirty */
}
/*---------------------------------------------------------------------------*/
/* putChar() - Put received characters into buffer [scf] */
/*---------------------------------------------------------------------------*/
proc putChar(BYTE ch)
{
INT ndx;
LPBYTE txtPtr;
LPBYTE txtSrc;
LPBYTE txtDst;
INT theLine;
INT len;
BYTE *attr;
txtPtr = GlobalLock(hTE.hText);
if(!statusLine)
{
ndx = (curLin + savTopLine) * (maxChars + 2) + curCol;
theLine = curLin;
}
else
{
ndx = curCol;
txtPtr = (LPBYTE) line25;
theLine = maxScreenLine + 1;
}
attr = attrib[theLine];
// if (attr[curCol] & ADIRTY)
// termCleanUp();
if (chInsMode)
{
len = maxChars - curCol - 2;
if (len > 0)
{
txtSrc = txtPtr + ndx;
txtDst = txtSrc + 1;
blockMove (txtSrc, txtDst, len);
txtSrc = (LPBYTE) attrib + theLine * ATTRROWLEN + curCol;
txtDst = txtSrc + 1;
blockMove (txtSrc, txtDst, len);
attr[LFLAGS] = LCLEAR;
}
}
if(!(termData.flags & TF_DIM))
txtPtr[ndx] = ch;
GlobalUnlock (hTE.hText);
attr[curCol] = curAttrib | ADIRTY;
attr[LFLAGS] |= LDIRTY;
termDirty = TRUE;
termCleanUp();
}
/*---------------------------------------------------------------------------*/
/* checkSelect() - [scf] */
/*---------------------------------------------------------------------------*/
VOID checkSelect()
{
LONG savTopNdx;
if (activSelect)
{
noSelect = FALSE;
savTopNdx = savTopLine*(maxChars + 2);
if (hTE.selEnd > savTopNdx)
if (savTopNdx <= hTE.selStart)
{
termSetSelect (MAXINTL, MAXINTL);
activSelect = FALSE;
}
else
termSetSelect (hTE.selStart, savTopNdx);
}
else
if(!noSelect)
{
termSetSelect (MAXINTL, MAXINTL);
noSelect = TRUE;
}
}
/*---------------------------------------------------------------------------*/
/* clrAttrib() - [scf] */
/*---------------------------------------------------------------------------*/
VOID clrAttrib (INT startLin, INT endLin, INT startCol, INT endCol)
{
INT lin, col;
for (lin = startLin; lin <= endLin; lin++)
for (col = startCol; col <= endCol; col++)
attrib[lin][col] = 0;
}
/*---------------------------------------------------------------------------*/
/* clrLines() - */
/*---------------------------------------------------------------------------*/
proc clrLines (INT lin1, INT lin2)
{
LPBYTE txt, attr;
register INT line;
txt = (LPBYTE)GlobalLock (hTE.hText) + (savTopLine + lin1) * (maxChars + 2);
if(lin1 == 24)
txt = (LPBYTE) line25;
for(line = lin1; line <= lin2; line++)
{
if(!protectMode) /* mbbx: protected fields */
{
attr = attrib[line];
if(attr[LFLAGS])
termCleanUp();
lsetmem(txt, CHFILL, maxChars);
lsetmem(attr, 0, maxChars);
attr[LFLAGS] = LCLEAR;
attr[LATTRIB] = LNORMAL; /* mbbx: mac version */
txt += maxChars + 2;
attr += ATTRROWLEN;
}
else
clrChars(line, 0, maxChars-1);
}
GlobalUnlock (hTE.hText);
termDirty = TRUE; /* mbbx: set dirty flag */
}
/*---------------------------------------------------------------------------*/
/* clrChars() - */
/*---------------------------------------------------------------------------*/
proc clrChars (INT line, INT col1, INT col2)
{
LPBYTE txt, attr;
register INT col;
txt = (LPBYTE)GlobalLock(hTE.hText) + (savTopLine + line) * (maxChars + 2) + col1;
if(line == 24)
txt = (LPBYTE) line25 + col1;
attr = attrib[line] + col1;
for(col = col1; col <= col2; col++)
{
if(*attr & ADIRTY)
termCleanUp();
if(!protectMode || !(*attr & APROTECT)) /* mbbx: protected fields */
{
*txt = CHFILL;
*attr |= ADIRTY;
}
txt += 1;
attr += 1;
}
attrib[line][LFLAGS] = LDIRTY;
GlobalUnlock (hTE.hText);
termDirty = TRUE; /* mbbx: set dirty flag */
}
/*---------------------------------------------------------------------------*/
/* getUnprot() - [mbb] */
/*---------------------------------------------------------------------------*/
VOID getUnprot(INT begLin, INT begCol, INT *lin, INT *col)
{
INT iLin;
INT iCol;
*lin = 0;
*col = 0;
for(iLin = begLin; iLin < maxScreenLine; iLin++) /* MBBX: TEST LIMITS!!! */
for(iCol = begCol; iCol < maxChars; iCol++)
if(!(attrib[iLin][iCol] & APROTECT))
{
*lin = iLin;
*col = iCol;
break;
}
}
/*---------------------------------------------------------------------------*/
/* getProtCol() - [mbb] */
/*---------------------------------------------------------------------------*/
INT getProtCol()
{
INT col;
for(col = curCol; col+1 < maxChars; col++)
if(attrib[curLin][col+1] & APROTECT)
break;
return(col);
}
/*---------------------------------------------------------------------------*/
/* pCursToggle() - [scf] */
/*---------------------------------------------------------------------------*/
proc pCursToggle ()
{
if (cursorOn == 1)
offCursor ();
else if (cursorOn == 0)
onCursor ();
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pCursOn() - [scf] */
/*---------------------------------------------------------------------------*/
proc pCursOn ()
{
onCursor ();
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pCursOff() - [scf] */
/*---------------------------------------------------------------------------*/
proc pCursOff ()
{
offCursor ();
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pCursRC() - [scf] */
/*---------------------------------------------------------------------------*/
proc pCursRC ()
{
INT maxWide;
if (escLin == -1)
{
escLin = ch - ' ';
if ((escLin < 0) || (escLin > maxScreenLine))
termState = NULL;
}
else
{
escCol = ch - ' ';
if ((escCol >= 0) && (escCol < maxChars))
{
curLin = escLin;
curCol = escCol;
maxWide = maxChars / 2 - 1;
if (attrib[curLin][LATTRIB] != LNORMAL)
if (curCol > maxWide)
curCol = maxWide;
}
termState = NULL;
}
if (termState == NULL)
escLin = -1;
}
/*---------------------------------------------------------------------------*/
/* pSetStatusLine() - */
/*---------------------------------------------------------------------------*/
proc pSetStatusLine() /* mbbx 1.03: TV925 ... */
{
curLin = 24;
curCol = 0;
statusLine = TRUE;
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pCursHome() - Home the terminal emulation cursor [scf] */
/*---------------------------------------------------------------------------*/
proc pCursHome ()
{
curLin = 0;
curCol = 0;
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pVideo() - [scf] */
/*---------------------------------------------------------------------------*/
proc pVideo(BYTE attr)
{
if(attr == 0)
curAttrib = 0;
else
curAttrib |= attr;
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pCursRelative() - Move cursor relative to current position [scf] */
/*---------------------------------------------------------------------------*/
proc pCursRelative (INT dh, INT dv)
{
INT maxWide;
curLin += dv;
curCol += dh;
if (curLin < 0)
curLin = 0;
else if (curLin > maxScreenLine)
curLin = maxScreenLine;
if (curCol < 0)
curCol = 0;
else if (curCol > (maxChars - 1))
curCol = maxChars - 1;
if (attrib[curLin][LATTRIB] != LNORMAL)
{
maxWide = maxChars / 2 - 1;
if (curCol > maxWide)
curCol = maxWide;
}
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pCursUp() - Move terminal emulation cursor up one relative to curr [scf] */
/*---------------------------------------------------------------------------*/
proc pCursUp ()
{
pCursRelative (0, -1);
}
/*---------------------------------------------------------------------------*/
/* pCursDn() - Move terminal emulation cursor down one relative to curr [scf]*/
/*---------------------------------------------------------------------------*/
proc pCursDn ()
{
pCursRelative (0, 1);
}
/*---------------------------------------------------------------------------*/
/* pCursRt() - Move terminal emulation cursor right one relative to curr[scf]*/
/*---------------------------------------------------------------------------*/
proc pCursRt ()
{
pCursRelative (1, 0);
}
/*---------------------------------------------------------------------------*/
/* pCursLt() - Move terminal emulation cursor left one relative to curr [scf]*/
/*---------------------------------------------------------------------------*/
proc pCursLt ()
{
pCursRelative (-1, 0);
}
/*---------------------------------------------------------------------------*/
/* pVPosAbsolute() - [scf] */
/*---------------------------------------------------------------------------*/
proc pVPosAbsolute ()
{
INT vPos;
vPos = chAscii & 0x1f;
curLin = vPos % (maxScreenLine + 1);
escSeq = FALSE;
escExtend = EXNONE;
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pHPosAbsolute() -- [scf] */
/*---------------------------------------------------------------------------*/
proc pHPosAbsolute ()
{
INT hPos;
hPos = ((chAscii & 0x70) / 16) * 10; /* to BCD! */
hPos += chAscii & 0x0f;
curCol = hPos % 80;
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pClrScr() - Clear the screen including attributes. */
/*---------------------------------------------------------------------------*/
VOID NEAR pClrScr()
{
pCursHome();
clrLines(0, maxScreenLine);
termState = NULL;
}
VOID FAR fpClrScr() /* mbbx: called from aFAR ... */
{
pClrScr();
}
/*---------------------------------------------------------------------------*/
/* pClrBol() - Clear terminal emulation video from current to beg. of line. */
/*---------------------------------------------------------------------------*/
proc pClrBol ()
{
if (curCol == maxChars-1)
clrLines (curLin, curLin);
else
clrChars (curLin, 0, curCol);
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pClrBop() - Clear terminal emulation video from curr to beg. of page. */
/*---------------------------------------------------------------------------*/
proc pClrBop ()
{
pClrBol ();
if (curLin > 0)
clrLines (0, curLin-1);
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pClrEol() - Clear logical IT video from present to end of line. [scf] */
/*---------------------------------------------------------------------------*/
proc pClrEol ()
{
if (curCol == 0)
clrLines (curLin, curLin);
else
clrChars (curLin, curCol, maxChars-1);
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pClrEop() - Clear the logical IT video from present to end of page. [scf] */
/*---------------------------------------------------------------------------*/
proc pClrEop ()
{
pClrEol ();
if (curLin < maxScreenLine)
clrLines (curLin + 1, maxScreenLine);
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pClrLine () Clear logical IT video from beginning to end of line. [scf] */
/*---------------------------------------------------------------------------*/
proc pClrLine ()
{
clrLines (curLin, curLin);
}
/*---------------------------------------------------------------------------*/
/* scrollAttrib () - [scf] */
/*---------------------------------------------------------------------------*/
proc scrollAttrib (INT startLin, INT endLin, INT nLines, BOOL up)
{
LPBYTE txtSrc;
LPBYTE txtDst;
INT len;
// sdj: was unref local - INT lin;
// sdj: was unref local - INT col;
if ((endLin - startLin) >= nLines)
{
txtSrc = (LPBYTE) attrib[0] + startLin*ATTRROWLEN;
txtDst = txtSrc + nLines*ATTRROWLEN;
len = (endLin - startLin + 1 - nLines)*ATTRROWLEN;
if (up)
blockMove(txtDst, txtSrc, len);
else
blockMove(txtSrc, txtDst, len);
}
}
/*---------------------------------------------------------------------------*/
/* pLF() - */
/*---------------------------------------------------------------------------*/
proc pLF()
{
LPBYTE txtDst, txtSrc;
// sdj: was unref local - LONG newStart, newEnd;
INT len; // sdj: was unref local - maxLin, savLin, bottomLine;
// sdj: was unref local - INT width, height;
checkSelect ();
UpdateWindow(hTermWnd); /* jtf 3.30 */
if(curLin == scrRgnEnd)
{
if(savTopLine == (maxLines - (maxScreenLine + 2))) /* no buffer left */
{
if(savTopLine > 0) /* mbbx 1.01: (maxLines == 25) */
{
txtDst = GlobalLock (hTE.hText);
txtSrc = txtDst + maxChars + 2;
len = (savTopLine - 1) * (maxChars + 2);
blockMove(txtSrc, txtDst, len);
txtSrc = txtDst + (savTopLine + scrRgnBeg) * (maxChars + 2);
txtDst = txtDst + len;
blockMove(txtSrc, txtDst, (DWORD) maxChars);
GlobalUnlock(hTE.hText);
if(curTopLine + visScreenLine < savTopLine)
{
if (curTopLine > 0)
curTopLine--;
else
lineFeeds++;
}
else
lineFeeds++;
}
pDelLin(scrRgnBeg, scrRgnEnd, 1);
}
else /* plenty of buffer */
{
if (scrRgnBeg != 0 || scrRgnEnd != maxScreenLine)
{
txtSrc = (LPBYTE)GlobalLock (hTE.hText) + savTopLine * (maxChars + 2);
txtDst = txtSrc + maxChars + 2;
blockMove (txtSrc, txtDst,
(DWORD) (maxScreenLine + 1) * (maxChars + 2));
txtDst = txtSrc;
txtSrc += (scrRgnBeg + 1) * (maxChars + 2);
blockMove (txtSrc, txtDst, (DWORD) maxChars);
GlobalUnlock (hTE.hText);
if (curTopLine + visScreenLine >= savTopLine)
{
curTopLine++;
lineFeeds++;
}
savTopLine++;
pDelLin (scrRgnBeg, scrRgnEnd, 1);
}
else
{
if(nScroll > 0)
{
if(((scrollBegin == scrRgnBeg) && (scrollEnd == scrRgnEnd)) &&
((nScroll + 1) < ((scrRgnEnd + 1 - scrRgnBeg) >> 2)))
{
nScroll++;
}
else
termCleanUp();
}
else if(nScroll < 0)
termCleanUp ();
if(nScroll == 0)
{
scrollBegin = scrRgnBeg;
scrollEnd = scrRgnEnd;
nScroll = 1;
}
if (curTopLine + visScreenLine >= savTopLine)
{
curTopLine++;
lineFeeds++;
}
savTopLine++;
scrollAttrib (scrRgnBeg, scrRgnEnd, 1, TRUE);
attrib[scrRgnEnd][LFLAGS] = 0;
clrLines (scrRgnEnd, scrRgnEnd);
}
}
nScrollPos.y = curTopLine;
updateTermScrollBars(FALSE);
termDirty = TRUE;
}
else
{
pCursRelative(0, 1);
if((curLin - savTopLine) - nScrollPos.y == visScreenLine+1) /* mbbx: TEST */
scrollDown(SB_VERT, SB_LINEDOWN, 1);
}
}
/*---------------------------------------------------------------------------*/
/* pInsLin() - Insert a line into the logical video screen. [scf] */
/*---------------------------------------------------------------------------*/
proc pInsLin (INT maxLin, INT nLines)
{
INT line, lin1;
INT len;
LPBYTE txtSrc;
LPBYTE txtDst;
if (statusLine)
clrLines (24,24);
else
{
if(nScroll < 0)
{
if(((scrollBegin == curLin) && (scrollEnd == maxLin)) &&
((abs(nScroll) + nLines) <= ((maxLin + 1 - curLin) >> 1)))
{
nScroll -= nLines;
}
else
termCleanUp();
}
else if(nScroll > 0)
termCleanUp();
if(nScroll == 0)
{
scrollBegin = curLin;
scrollEnd = maxLin;
nScroll = -nLines;
}
for(line = maxLin - nLines + 1; line <= maxLin; line++)
if(attrib[line][LFLAGS])
{
termCleanUp();
break;
}
scrollAttrib (curLin, maxLin, nLines, FALSE);
txtSrc = (LPBYTE)GlobalLock (hTE.hText) +
(curLin + savTopLine) * (maxChars + 2);
txtDst = txtSrc + nLines * (maxChars + 2);
len = (maxLin + 1 - curLin - nLines) * (maxChars + 2);
if (len > 0)
blockMove (txtSrc, txtDst, (DWORD) len);
line = curLin + nLines - 1;
for (lin1 = curLin; lin1 <= line; lin1++)
attrib[lin1][LFLAGS] = 0;
clrLines (curLin, line);
GlobalUnlock (hTE.hText);
}
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pDelLin() - Delete a line */
/*---------------------------------------------------------------------------*/
proc pDelLin (INT curLin, INT maxLin, INT nLines)
{
INT line, lin1;
INT len;
LPBYTE txtSrc;
LPBYTE txtDst;
if(statusLine)
clrLines(24, 24);
else
{
if(nScroll > 0)
{
if(((scrollBegin == curLin) && (scrollEnd == maxLin)) &&
((nScroll + nLines) <= ((maxLin + 1 - curLin) >> 2)))
{
nScroll += nLines;
}
else
termCleanUp();
}
else if(nScroll < 0)
termCleanUp();
if(nScroll == 0)
{
scrollBegin = curLin;
scrollEnd = maxLin;
nScroll = nLines;
}
for(line = curLin; line < curLin + nLines; line++)
if(attrib[line][LFLAGS])
{
termCleanUp();
break;
}
scrollAttrib (curLin, maxLin, nLines, TRUE);
txtDst = (LPBYTE)GlobalLock (hTE.hText) +
(curLin + savTopLine) * (maxChars + 2);
txtSrc = txtDst + nLines * (maxChars + 2);
len = (maxLin + 1 - curLin - nLines) * (maxChars + 2);
if (len > 0)
blockMove (txtSrc, txtDst, (DWORD) len);
line = maxLin - nLines + 1;
for (lin1 = line; lin1 <= maxLin; lin1++)
attrib[lin1][LFLAGS] = 0;
clrLines (line, maxLin);
GlobalUnlock (hTE.hText);
}
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pDelChar() - Delete a char from the terminal emulation video. [scf] */
/*---------------------------------------------------------------------------*/
proc pDelChar(INT nChars)
{
INT ndx;
// sdj: was unref local - INT savCol;
INT theLine;
DWORD len;
LPBYTE txtSrc;
LPBYTE txtDst;
// sdj: was unref local - LPBYTE txtPtr;
LPBYTE globalHeap;
globalHeap = GlobalLock(hTE.hText);
if(!protectMode) /* mbbx: protected fields */
len = maxChars - nChars - curCol;
else
len = getProtCol() - nChars - (curCol+1);
if(statusLine)
{
theLine = maxScreenLine + 1;
txtDst = (LPBYTE) line25 + curCol;
}
else
{
theLine = curLin;
txtDst = globalHeap + valIndex ();
}
if (len > 0)
{
txtSrc = txtDst + nChars;
blockMove (txtSrc, txtDst, len);
}
else
{
nChars = maxChars - curCol;
len = 0;
}
txtSrc = txtDst + len;
for (ndx = 0; ndx <= (nChars - 1); ndx++)
txtSrc[ndx] = CHFILL;
GlobalUnlock (hTE.hText);
attrib[theLine][LFLAGS] = LCLEAR | LDIRTY;
}
/*---------------------------------------------------------------------------*/
/* begGraphics() - [scf] */
/*---------------------------------------------------------------------------*/
VOID begGraphics () /* macx */
{
termCleanUp ();
offCursor ();
}
/*---------------------------------------------------------------------------*/
/* endGraphics() - [scf] */
/*---------------------------------------------------------------------------*/
VOID endGraphics () /* macx */
{
onCursor ();
}
/*---------------------------------------------------------------------------*/
/* pGrChar () - */
/*---------------------------------------------------------------------------*/
static HDC graphicsPort;
#define GRCOLBEG 48
#define GRLINBEG 0
#define MAXGRCOL 512
proc pGrSemi ()
{
/* jtfterm */
}
/*---------------------------------------------------------------------------*/
/* pGrDoIt() - */
/*---------------------------------------------------------------------------*/
proc pGrDoIt (INT len, HBRUSH p)
{
/* jtfterm */
}
/*---------------------------------------------------------------------------*/
/* pGrFill() - [scf] */
/*---------------------------------------------------------------------------*/
proc pGrFill ()
{
ch = theChar;
if (ch == 7)
{
sysBeep ();
vidGraphics = GRNONE;
termState = NULL;
chrWidth = stdChrWidth;
chrHeight = stdChrHeight;
endGraphics ();
}
else if (ch != CR && ch != LF)
{
if (vidBG == -1)
vidBG = (ch - ' ')*chrWidth;
else
{
vidFG = (ch - ' ')*chrWidth;
if (vidBG > 0)
pGrDoIt(vidBG, blackBrush);
if (vidFG > 0)
pGrDoIt(vidFG, theBrush);
vidBG = -1;
}
}
else
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pGrChar() */
/*---------------------------------------------------------------------------*/
proc pGrChar ()
{
HRGN hClipRgn;
RECT clpRect;
getPort ();
graphicsPort = thePort;
GetClientRect (hTermWnd, (LPRECT) &clpRect);
hClipRgn = CreateRectRgnIndirect ((LPRECT) &clpRect);
SelectClipRgn(thePort, hClipRgn);
DeleteObject (hClipRgn);
ch = the8Char;
if (vidGraphics == GRSEMI)
if ((the8Char & 0x80) != 0)
pGrSemi ();
else
termState = NULL;
else
pGrFill ();
releasePort ();
}
/*---------------------------------------------------------------------------*/
/* pSetGrMode() - [scf] */
/*---------------------------------------------------------------------------*/
proc pSetGrMode()
{
/* jtfterm */
}
/*---------------------------------------------------------------------------*/
/* pSetMode() - [scf] */
/*---------------------------------------------------------------------------*/
proc pSetMode ()
{
BYTE chSet;
termState = NULL;
if((trmParams.emulate >= ITMVT52) && (trmParams.emulate <= ITMVT220)) /* mbbx: why VT52??? */
switch (ch)
{
case 0x0e:
case 0x0f:
if (ch == 0x0e)
shiftCharSet = 1;
else
shiftCharSet = 0;
chSet = charSet[shiftCharSet];
if ((chSet == '0') || (chSet == '2'))
curAttrib |= AGRAPHICS;
else
curAttrib &= ANOTGRAPHICS;
break;
case 'x': /* VT52/Heath*/
escExtend = EXSETMODE;
termState = pSetMode;
break;
case 'y': /* VT52/Heath */
escExtend = EXRESETMODE;
termState = pSetMode;
break;
case '=':
keyPadAppMode = TRUE;
break;
case '>':
keyPadAppMode = FALSE;
break;
case '<':
trmParams.emulate = ITMVT100;
resetEmul ();
break;
case '5': /* VT52/Heath */
if (escExtend == EXSETMODE)
pCursOff ();
else
pCursOn ();
break;
case '7': /* VT52/Heath */
keyPadAppMode = (escExtend == EXSETMODE);
break;
case '@':
chInsMode = TRUE;
break;
case 'O':
chInsMode = FALSE;
break;
}
}
/*---------------------------------------------------------------------------*/
/* pDecScs() - VT-100 character set selection. [scf] */
/*---------------------------------------------------------------------------*/
proc pDecScs ()
{
BYTE chSet;
termState = NULL;
switch (ch)
{
case '(':
decScs = 0;
termState = pDecScs;
break;
case ')':
decScs = 1;
termState = pDecScs;
break;
case 'A':
case 'B':
case '0':
case '1':
case '2':
charSet[decScs] = ch;
chSet = charSet[shiftCharSet];
if ((chSet == '0') || (chSet == '2'))
curAttrib |= AGRAPHICS;
else
curAttrib &= ANOTGRAPHICS;
break;
}
}
/*---------------------------------------------------------------------------*/
/* getArg() - */
/*---------------------------------------------------------------------------*/
#define getArg ((argNdx < argCount) ? argList[argNdx++] : 0)
/*---------------------------------------------------------------------------*/
/* getParms () */
/*---------------------------------------------------------------------------*/
proc getParms ()
{
p1 = getArg;
p2 = getArg;
}
/*---------------------------------------------------------------------------*/
/* pInquire() - [scf] */
/*---------------------------------------------------------------------------*/
proc pInquire() /* mbbx 1.04: VT220... */
{
STRING respStr[32];
*respStr = 0;
switch(trmParams.emulate)
{
case ITMVT100:
getParms();
if(p1 == 0)
memcpy(respStr, "\7\033[?1;2c", 9);
break;
case ITMVT52:
memcpy(respStr, "\3\033/Z", 5);
break;
}
if(*respStr)
termStr(respStr, 0, FALSE);
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pTab() - [scf] */
/*---------------------------------------------------------------------------*/
proc pTab()
{
INT ndx;
INT savCol;
INT lin, col;
if(!protectMode)
{
savCol = curCol;
ndx = curCol + 1;
while (ndx <= 131)
if(tabs[ndx] == 1)
{
curCol = ndx;
ndx = 133;
}
else
ndx++;
}
else /* mbbx: tab for protected mode */
{
lin = 0;
col = 0;
repeat
getUnprot(lin, col, &lin, &col);
until((lin >= curLin) && (col >= curCol));
ndx = 0;
curLin = lin;
curCol = col;
}
if((ndx == 132) || (curCol >= maxChars))
curCol = maxChars - 1;
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pClearAllTabs() - [scf] */
/*---------------------------------------------------------------------------*/
proc pClearAllTabs ()
{
INT ndx;
for (ndx = 0; ndx <= 131; ndx++)
tabs[ndx] = 0;
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pSetTab() - [scf] */
/*---------------------------------------------------------------------------*/
proc pSetTab ()
{
tabs[curCol] = 1;
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pClearTab() - [scf] */
/*---------------------------------------------------------------------------*/
proc pClearTab ()
{
tabs[curCol] = 0;
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pCmpSrvResponse() - [scf] */
/*---------------------------------------------------------------------------*/
proc pCmpSrvResponse ()
{
/* jtfterm */
}
/*---------------------------------------------------------------------------*/
/* pSndCursor() - [scf] */
/*---------------------------------------------------------------------------*/
proc pSndCursor()
{
LONG finalTicks;
termState = NULL;
switch(trmParams.emulate)
{
case ITMVT52:
modemWr (0x1b); delay (5, &finalTicks);
modemWr ('Y'); delay (5, &finalTicks);
modemWr ((BYTE) curLin + ' '); delay (5, &finalTicks);
modemWr ((BYTE) curCol + ' '); delay (5, &finalTicks);
break;
}
}
/*---------------------------------------------------------------------------*/
/* pIndex() - */
/*---------------------------------------------------------------------------*/
proc pIndex ()
{
if (curLin == scrRgnEnd)
pDelLin (scrRgnBeg, scrRgnEnd, 1);
else
pCursRelative (0, 1);
}
/*---------------------------------------------------------------------------*/
/* pRevIndex() - [scf] */
/*---------------------------------------------------------------------------*/
proc pRevIndex ()
{
if (curLin == scrRgnBeg)
pInsLin (scrRgnEnd, 1);
else
pCursRelative (0, -1);
}
/*---------------------------------------------------------------------------*/
/* pSetLineAttrib() - [scf] */
/*---------------------------------------------------------------------------*/
proc pSetLineAttrib ()
{
BYTE lAttr;
INT theLin;
INT savCol;
INT ndx;
INT half;
LPBYTE txtPtr;
LPBYTE globalHeap;
lAttr = -1;
switch (ch)
{
case '3':
lAttr = LHIGHTOP;
break;
case '4':
lAttr = LHIGHBOTTOM;
break;
case '5':
lAttr = LNORMAL;
break;
case '6':
lAttr = LWIDE;
break;
}
if (statusLine)
theLin = 24;
else
theLin = curLin;
if (lAttr != -1)
if (lAttr != attrib[theLin][LATTRIB])
{
savCol = curCol;
curCol = 0;
half = maxChars;
if (lAttr != LNORMAL)
{
half = maxChars / 2;
globalHeap = GlobalLock (hTE.hText);
txtPtr = globalHeap + valIndex ();
for (ndx = half; ndx <= (maxChars - 1); ndx++)
{
txtPtr[ndx] = ' ';
attrib[theLin][ndx] = 0;
}
GlobalUnlock (hTE.hText);
}
attrib[theLin][LATTRIB] = lAttr;
attrib[theLin][LFLAGS] = LCLEAR | LDIRTY; /* mbbx: mac version */
reDrawTermLine (theLin, 0, half);
curCol = savCol;
}
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pInsChar() - [scf] */
/*---------------------------------------------------------------------------*/
proc pInsChar ()
{
BOOL savMode;
if(!protectMode)
{
savMode = chInsMode;
chInsMode = TRUE;
putChar (' ');
chInsMode = savMode;
termState = NULL;
}
else
pDelChar(1);
}
/*---------------------------------------------------------------------------*/
/* pSaveCursorPos() - */
/*---------------------------------------------------------------------------*/
proc pSaveCursorPos ()
{
saveCol = curCol;
saveLin = curLin;
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pRestoreCursorPos() - */
/*---------------------------------------------------------------------------*/
proc pRestoreCursorPos ()
{
curCol = saveCol;
curLin = saveLin;
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pEscSkip */
/*---------------------------------------------------------------------------*/
proc pEscSkip ()
{
escSkip--;
if (escSkip <= 0)
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* Some change of state procedures */
/*---------------------------------------------------------------------------*/
proc pNullState ()
{
termState = NULL;
}
proc pCursorState ()
{
termState = pCursRC;
}
proc pVPosState ()
{
termState = pVPosAbsolute;
}
proc pHPosState ()
{
termState = pHPosAbsolute;
}
proc pLAttrState ()
{
termState = pSetLineAttrib;
}
/*---------------------------------------------------------------------------*/
/* pAnsi() - [scf] */
/*---------------------------------------------------------------------------*/
proc pAnsi()
{
if((chAscii >= '0') && (chAscii <= '?'))
(*ansiParseTable[chAscii-'0'])();
else
{
if(ansiArg)
argList[argCount++] = ansiArg;
(*aEscTable[chAscii &= 0x7F])(); /* mbbx 1.06: modemInp() not masking 8th bit */
if(termState != aEscTable[chAscii]) /* mbbx 1.10: VT220 8BIT patch !!! */
termState = NULL;
}
}
proc pAnsiState ()
{
termState = pAnsi;
argNdx = 0;
argCount = 0;
ansiArg = 0;
decPrivate = FALSE;
heathPrivate = FALSE;
}
proc pGrState ()
{
termState = pSetGrMode;
}
proc pSkipState ()
{
escSkip = emulInfo[chAscii] - 128;
termState = pEscSkip;
}
proc pReverseOff() /* mbbx: pProtOff -> pReverseOff */
{
pVideo(0);
}
proc pReverseOn() /* mbbx: pProtOn -> pReverseOn */
{
pVideo(ABOLD); /* mbbx per jtfx */
}
proc pProtOff() /* mbbx */
{
protectMode = FALSE;
termState = NULL;
}
proc pProtOn() /* mbbx */
{
protectMode = TRUE;
termState = NULL;
}
proc pBegProtect() /* mbbx 1.03: TV925... */
{
pVideo(APROTECT);
pVideo(ABOLD);
}
proc pEndProtect() /* mbbx 1.03: TV925... */
{
pVideo(ANORMAL);
}
proc pBegGraphics() /* mbbx 1.03: TV925... */
{
curAttrib |= AGRAPHICS;
termState = NULL;
}
proc pEndGraphics() /* mbbx 1.03: TV925... */
{
curAttrib &= ANOTGRAPHICS;
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* Some patches */
/*---------------------------------------------------------------------------*/
proc pLinDel ()
{
pDelLin(curLin, maxScreenLine, 1); /* mbbx per slcx */
}
proc pCharDel ()
{
pDelChar(1);
}
proc pLinIns ()
{
pInsLin(maxScreenLine, 1);
}
proc pNextLine ()
{
pLF ();
curCol = 0;
}
proc pClrAll()
{
protectMode = FALSE;
pClrScr();
}
proc pPrintOn()
{
PrintFileComm(TRUE); /* mbbx 1.03: prAction(!prtFlag); */
termState = NULL;
}
proc pPrintOff()
{
// sdj: was unref local - BYTE work[STR255];
PrintFileComm(FALSE); /* mbbx 1.03: prAction(!prtFlag); */
termState = NULL;
}
/*---------------------------------------------------------------------------*/
#define TRANS_PRINT_BUFFER 4
STRING transPrtBuf[TRANS_PRINT_BUFFER+1];
proc pTransPrint() /* mbbx 2.01.32 ... */
{
if(trmParams.emulate == ITMVT100)
{
getParms();
switch(p1)
{
case 5:
transPrintFlag = TRUE;
*transPrtBuf = 0; /* slc gold 017 */
break;
case 4:
PrintFileComm(FALSE);
transPrintFlag = FALSE;
break;
case 1:
/* print cursor line */
break;
case 0:
/* print screen */
break;
}
}
else
transPrintFlag = TRUE;
if(transPrintFlag)
PrintFileComm(TRUE);
termState = NULL;
}
/*---------------------------------------------------------------------------*/
proc pVideoAttrib() /* mbbx 1.03: added breaks !!! */
{
switch(trmParams.emulate)
{
/* jtfterm */
}
termState = NULL;
}
proc pVideoAttribState()
{
termState = pVideoAttrib;
}
proc pCursorOnOff()
{
if(chAscii != '0')
pCursOn();
else
pCursOff();
}
proc pCursorOnOffState()
{
termState = pCursorOnOff;
}
/*---------------------------------------------------------------------------*/
/* pAnswerBack() - [mbb] */
/*---------------------------------------------------------------------------*/
proc pAnswerBack()
{
#ifdef ORGCODE
INT i;
#else
DWORD i;
#endif
BYTE saveEcho;
LONG finalTicks;
STRING temp[DCS_ANSWERBACKSZ+1]; /* rkhx 2.00 */
saveEcho = trmParams.localEcho;
trmParams.localEcho = FALSE; /* mbbx 1.10: CUA */
strcpy(temp+1, trmParams.answerBack); /* rkhx 2.00 */
*temp = strlen(temp+1);
stripControl(temp);
for(i = 1; i <= *temp; i++)
{
modemWr(temp[i]);
delay(2, &finalTicks);
}
trmParams.localEcho = saveEcho;
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pEchoOff() - [mbb] */
/*---------------------------------------------------------------------------*/
proc pEchoOff()
{
trmParams.localEcho = FALSE; /* mbbx 1.10: CUA */
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pEchoOn() - [mbb] */
/*---------------------------------------------------------------------------*/
proc pEchoOn()
{
trmParams.localEcho = TRUE; /* mbbx 1.10: CUA */
termState = NULL;
}
/* mbbx: added to make the TABLE handling consistent 1/6/88 */
proc pCR()
{
if((trmParams.emulate == ITMDELTA) && (curCol > 0))
{
while(curCol < maxChars)
{
putChar(SP);
curCol++;
}
}
curCol = 0;
if(statusLine) /* mbbx 1.03: TV925 per slcx... */
{
curLin = 0;
statusLine = FALSE;
}
}
proc pBackSpace()
{
if(curCol > 0) /* jtf 3.14 */
curCol--;
/* jtf 3.33 putChar(SP); */ /* desctructive backspace 3.17 */
}
proc pBeep()
{
if(trmParams.sound) /* mbbx 1.04: synch */
sysBeep();
}
/*---------------------------------------------------------------------------*/
/* pEscSequence */
/*---------------------------------------------------------------------------*/
proc pEscSequence()
{
(*pEscTable[chAscii & 0x7F])(); /* mbbx 2.00: modemInp() not masking 8th bit */
}
/*------------------ >>> pAnsi() Global Declarations <<< ------------------*/
/* Procedure pAnsi () */
/*---------------------------------------------------------------------------*/
/* aSetCompLevel() - set VT220 Compatibility Level [mbb/rkh] */
/*---------------------------------------------------------------------------*/
VOID NEAR aSetCompLevel() /* mbbx 1.10: VT220 8BIT... */
{
BYTE newEmul;
termState = NULL;
switch(ch)
{
case '"':
termState = aSetCompLevel;
break;
case 'p':
switch(getArg)
{
case 61:
newEmul = ITMVT100;
break;
case 62:
newEmul = ITMVT220;
trmParams.fCtrlBits = !(getArg == 1);
break;
default:
return;
}
if(newEmul != trmParams.emulate)
{
trmParams.emulate = newEmul;
resetEmul();
}
break;
}
}
VOID NEAR pSetCtrlBits() /* mbbx 2.00: VT220 8BIT... */
{
termState = NULL;
switch(ch)
{
case ' ':
termState = pSetCtrlBits;
break;
case 'F':
trmParams.fCtrlBits = FALSE;
break;
case 'G':
trmParams.fCtrlBits = TRUE;
break;
}
}
/*---------------------------------------------------------------------------*/
/* aCursor() [scf] */
/*---------------------------------------------------------------------------*/
proc aCursor()
{
register INT lin, col;
getParms ();
if (p1 == 0)
p1 = 1;
if (p2 == 0)
p2 = 1;
lin = p1 - 1;
col = p2 - 1;
if (originMode)
{
lin += scrRgnBeg;
if (lin < scrRgnEnd)
curLin = lin;
else
curLin = scrRgnEnd;
}
else
if (lin <= maxScreenLine)
{
if (statusLine)
{
statusLine = FALSE;
}
curLin = lin;
}
else
{
if (!statusLine)
{
statusLine = TRUE;
}
curLin = maxScreenLine;
}
if (col < maxChars)
curCol = col;
}
/*---------------------------------------------------------------------------*/
/* aClrEol() - [scf] */
/*---------------------------------------------------------------------------*/
proc aClrEol ()
{
getParms ();
if (p1 == 0)
pClrEol ();
else if (p1 == 1)
pClrBol ();
else if (p1 == 2)
{
pClrBol ();
pClrEol ();
}
}
/*---------------------------------------------------------------------------*/
/* aClrEop() - [scf] */
/*---------------------------------------------------------------------------*/
proc aClrEop ()
{
getParms ();
if (p1 == 0)
pClrEop ();
else if (p1 == 2)
pClrScr ();
else if (p1 == 1)
pClrBop ();
}
/*---------------------------------------------------------------------------*/
/* aCursUp() - [scf] */
/*---------------------------------------------------------------------------*/
proc aCursUp ()
{
getParms ();
if (p1 == 0)
p1 = 1;
pCursRelative (0, (INT) -p1);
}
/*---------------------------------------------------------------------------*/
/* aCursDn() - [scf] */
/*---------------------------------------------------------------------------*/
proc aCursDn ()
{
getParms ();
if (p1 == 0)
p1 = 1;
pCursRelative (0, (INT) p1);
}
/*---------------------------------------------------------------------------*/
/* aCursRt() - [scf] */
/*---------------------------------------------------------------------------*/
proc aCursRt ()
{
getParms ();
if (p1 == 0)
p1 = 1;
pCursRelative ((INT) p1, 0);
}
/*---------------------------------------------------------------------------*/
/* aCursLt() - [scf] */
/*---------------------------------------------------------------------------*/
proc aCursLt ()
{
getParms ();
if (p1 == 0)
p1 = 1;
pCursRelative ((INT) -p1, 0);
}
/*---------------------------------------------------------------------------*/
/* aClearTabs() - [scf] */
/*---------------------------------------------------------------------------*/
proc aClearTabs ()
{
getParms ();
if (p1 == 3)
pClearAllTabs ();
else if (p1 == 0)
pClearTab ();
}
/*---------------------------------------------------------------------------*/
/* aVideo() - [scf] */
/*---------------------------------------------------------------------------*/
proc aVideo ()
{
repeat
{
switch ((WORD) getArg)
{
case 0:
curAttrib &= AGRAPHICS;
break;
case 1:
curAttrib |= ABOLD;
break;
case 4:
curAttrib |= AUNDERLINE;
break;
case 5:
curAttrib |= ABLINK;
break;
case 7:
curAttrib |= AREVERSE;
break;
}
}
until (argNdx == argCount);
}
/*---------------------------------------------------------------------------*/
/* aSetMode() - [mbb] */
/*---------------------------------------------------------------------------*/
proc aSetMode() /* mbbx 2.00: cleanup... */
{
while(argNdx < argCount)
{
switch(ch)
{
case 'h':
if(decPrivate) /* SET DEC private modes */
{
switch(getArg)
{
case 1:
cursorKeyMode = TRUE;
break;
case 6:
originMode = TRUE;
curLin = scrRgnBeg;
curCol = 0;
break;
case 7:
trmParams.lineWrap = TRUE; /* mbbx 1.10: CUA... */
break;
}
}
else if(heathPrivate) /* RESET heath private modes */
{
switch(getArg)
{
case 5:
pCursOn();
break;
case 7:
keyPadAppMode = FALSE;
break;
}
}
else
{
switch(getArg)
{
case 4:
chInsMode = TRUE;
break;
}
}
break;
case 'l':
if(decPrivate) /* RESET DEC private modes */
{
switch(getArg)
{
case 1:
cursorKeyMode = FALSE;
break;
case 2:
trmParams.emulate = ITMVT52;
resetEmul ();
break;
case 6:
originMode = FALSE;
pCursHome();
break;
case 7:
trmParams.lineWrap = FALSE; /* mbbx 1.10: CUA... */
break;
}
}
else if(heathPrivate)
{
switch(getArg) /* SET HEATH private modes */
{
case 5:
pCursOff();
break;
case 7:
keyPadAppMode = TRUE;
break;
}
}
else
{
switch(getArg)
{
case 4:
chInsMode = FALSE;
break;
}
}
break;
}
}
}
/*---------------------------------------------------------------------------*/
/* aReport() - [scf] */
/*---------------------------------------------------------------------------*/
proc aReport() /* mbbx 1.04: cleanup... */
{
STRING respStr[16];
getParms();
switch(p1)
{
case 6:
sprintf(respStr+1, "\033[%d;%dR", curLin+1, curCol+1);
*respStr = strlen(respStr+1);
break;
case 5:
memcpy(respStr, "\4\033[0n", 5);
break;
}
if(*respStr != 0)
termStr(respStr, 0, FALSE);
}
/*---------------------------------------------------------------------------*/
/* aSetScrRgn() - [scf] */
/*---------------------------------------------------------------------------*/
proc aSetScrRgn ()
{
getParms ();
if (p1 == 0)
p1 = 1;
if (p2 == 0)
p2 = 1;
if ((p2 > p1) && (p2 <= (maxScreenLine + 1)))
{
scrRgnBeg = p1 - 1;
scrRgnEnd = p2 - 1;
}
else if (p2 == 1)
{
scrRgnBeg = 0;
scrRgnEnd = maxScreenLine;
}
if (originMode)
curLin = scrRgnBeg;
else
curLin = 0;
curCol = 0;
}
/*---------------------------------------------------------------------------*/
/* aDelLin() - [scf] */
/*---------------------------------------------------------------------------*/
proc aDelLin ()
{
INT len;
getParms ();
if (p1 == 0)
p1 = 1;
if ((curLin >= scrRgnBeg) && (curLin <= scrRgnEnd))
{
len = scrRgnEnd - curLin + 1;
if (p1 > len)
p1 = len;
pDelLin(curLin, scrRgnEnd, (INT) p1); /* mbbx per slcx */
curCol = 0;
}
}
/*---------------------------------------------------------------------------*/
/* aInsLin() - [scf] */
/*---------------------------------------------------------------------------*/
proc aInsLin ()
{
INT len;
getParms ();
if (p1 == 0)
p1 = 1;
if ((curLin >= scrRgnBeg) && (curLin <= scrRgnEnd))
{
len = scrRgnEnd - curLin + 1;
if (p1 > len)
p1 = len;
pInsLin (scrRgnEnd, (INT) p1);
curCol = 0;
}
}
/*---------------------------------------------------------------------------*/
/* aDelChar() - [scf] */
/*---------------------------------------------------------------------------*/
proc aDelChar ()
{
getParms ();
if (p1 == 0)
p1 = 1;
pDelChar ((INT) p1);
}
/*---------------------------------------------------------------------------*/
/* VT-100 exceptions (same terminator for ANSI and non-Ansi sequence) */
/*---------------------------------------------------------------------------*/
proc pVT100H ()
{
if (termState == pAnsi)
aCursor ();
else
pSetTab ();
termState = NULL;
}
proc pVT100D ()
{
if (termState == pAnsi)
aCursLt ();
else
pLF ();
termState = NULL;
}
proc pVT100M ()
{
if (termState == pAnsi)
aDelLin ();
else
pRevIndex ();
termState = NULL;
}
proc pVT100c()
{
if(termState == pAnsi)
pInquire(); /* mbbx 1.10: aReport() was wrong! */
else
{
resetEmul();
pClrScr();
}
termState = NULL;
}
proc pVT100P() /* mbbx: new routine */
{
if(termState == pAnsi)
aDelChar();
else
termState = pDCS; /* mbbx: yterm */
}
/*---------------------------------------------------------------------------*/
/* pDCS() - */
/*---------------------------------------------------------------------------*/
proc pDCS()
{
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* pDCSTerminate() - */
/*---------------------------------------------------------------------------*/
proc pDCSTerminate()
{
termState = NULL;
}
/*---------------------------------------------------------------------------*/
/* Ansi Parser Routines */
/*---------------------------------------------------------------------------*/
proc ansiArgument () /* chAscii IN ['0' .. '9'] */
{
ansiArg = (ansiArg*10) + chAscii - '0';
}
proc ansiDelimiter () /* chAscii == ';' */
{
if (argCount < MAXANSIARGS)
argList[argCount++] = ansiArg;
ansiArg = 0;
}
proc ansiHeathPrivate () /* chAscii == '>' */
{
heathPrivate = TRUE;
}
proc ansiDecPrivate () /* chAscii == '?' */
{
decPrivate = TRUE;
}
/*---------------------------------------------------------------------------*/
/* putRcvChar() - [mbb] */
/*---------------------------------------------------------------------------*/
BOOL NEAR writeRcvChar(BYTE theChar)
{
LPSTR lpBuffer; /* rjs bugs 016 */
lpBuffer = GlobalLock(xferBufferHandle); /* rjs bugs 016 */
if((!xferSaveCtlChr) && ((theChar == BS) || (theChar == DEL))) /* rjs bugs 016 */
{
// sdj: if the very first character in the 1k pkt happens to
// sdj: be BS or DEL, then --xferBufferCount is going to be
// sdj: 64K! causing the access violation.
// sdj: lets not write the BS,DEL into the text file in these
// sdj: cases because what needs to be changed is the last byte
// sdj: of the last pkt which was written to the file! forget
// sdj: that for the time being and avoid the access violation.
if (xferBufferCount)
lpBuffer[--xferBufferCount] = 0x00; /* rjs bugs 016 */
}
else /* rjs bugs 016 */
lpBuffer[xferBufferCount++] = theChar; /* rjs bugs 016 */
if (xferBufferCount == 1024) /* rjs bugs 016 */
if (_lwrite((INT)xferRefNo, (LPSTR)lpBuffer,(INT) 1024) != 1024) /* rjs bugs 016 */
{
GlobalUnlock(xferBufferHandle); /* rjs bugs 016 */
xferEnd();
TF_ErrProc(STREWRERR, MB_OK | MB_ICONHAND, 999);
return(FALSE);
}
GlobalUnlock(xferBufferHandle); /* rjs bugs 016 */
if (xferBufferCount==1024) xferBufferCount = 0; /* rjs bugs 016 */
if(( (xferLength += 1) % 0x0400 ) == 0L ) /* rjs bugs 016 */
showBBytes(xferLength, FALSE);
return(TRUE);
}
VOID NEAR putRcvChar(BYTE theChar)
{
BYTE the7Char = theChar & 0x7F;
if(xferTableSave)
{
switch(the7Char)
{
case CR:
tblPos = TBLBEGINLINE;
break;
case TAB:
tblPos = TBLSPACES;
return;
case SP:
if(tblPos < TBLSPACES)
tblPos += 1;
return;
default:
if(xferSaveCtlChr || (the7Char == FF) || (the7Char == LF) ||
((the7Char >= 0x20) && (the7Char <= 0x7E)))
{
switch(tblPos)
{
case TBLONESPACE:
if(!writeRcvChar(SP))
return;
break;
case TBLSPACES:
if(!writeRcvChar(TAB))
return;
break;
}
tblPos = TBLNONSPACE;
}
break;
}
}
if(xferSaveCtlChr || (the7Char == TAB) || (the7Char == FF) || (the7Char == LF) ||
(the7Char == CR) || (the7Char == BS) || (the7Char == DEL) || /* rjs bugs 016 -> add BS and DEL */
((the7Char >= 0x20) && (the7Char <= 0x7E)))
{
writeRcvChar(theChar);
}
}
/*---------------------------------------------------------------------------*/
/* checkTransPrint() - [mbb] */
/*---------------------------------------------------------------------------*/
#define TRANS_PRINT_BUFFER 4
STRING transPrtBuf[TRANS_PRINT_BUFFER+1];
VOID NEAR checkTransPrint(BYTE theChar)
{
switch(theChar)
{
case 0x14:
if((trmParams.emulate == ITMADDS) || (trmParams.emulate == ITMTVI925))
transPrintFlag |= 0x8000;
break;
case '4':
if((trmParams.emulate == ITMADDS) && (*transPrtBuf == 1))
transPrintFlag = FALSE;
break;
case 'a':
if((trmParams.emulate == ITMTVI925) && (*transPrtBuf == 1))
transPrintFlag = FALSE;
break;
case 'i':
if(((trmParams.emulate == ITMVT220) || (trmParams.emulate == ITMVT100)) &&
(*transPrtBuf == 3) && (transPrtBuf[2] == '[') && (transPrtBuf[3] == '4'))
{
if(transPrintFlag)
{
transPrintFlag = FALSE;
PrintFileComm(FALSE);
}
}
break;
}
if(transPrintFlag || (prtFlag && !prtPause))
{
if(((theChar & 0x7F) != ESC) && !(transPrintFlag & 0x8000))
transPrtBuf[++(*transPrtBuf)] = theChar;
if(((theChar & 0x7F) == ESC) || (transPrintFlag & 0x8000) || (*transPrtBuf == 1) || (*transPrtBuf >= TRANS_PRINT_BUFFER))
{
if(*transPrtBuf > 0)
{
PrintFileString((LPSTR) transPrtBuf+1, (LONG) *transPrtBuf, FALSE);
*transPrtBuf = 0;
}
if((theChar & 0x7F) == ESC)
{
transPrtBuf[++(*transPrtBuf)] = ESC;
if((theChar == 0x9B) && (trmParams.emulate == ITMVT220))
transPrtBuf[++(*transPrtBuf)] = '[';
}
if(transPrintFlag & 0x8000)
transPrintFlag = FALSE;
}
}
if(transPrintFlag && !prtFlag)
PrintFileComm(TRUE);
}
/*---------------------------------------------------------------------------*/
/* modemInp () - [mbb] */
/*---------------------------------------------------------------------------*/
VOID modemInp(INT theChar, BOOL bRcvComm)
{
cursorValid = FALSE;
the8Char = (BYTE) theChar;
if(bRcvComm) /* mbbx 2.00: not restricted... */
{
if((xferFlag == XFRRCV) && !xferPaused)
putRcvChar(the8Char);
}
if(transPrintFlag || (prtFlag && !prtPause))
checkTransPrint(the8Char);
chAscii = the8Char; /* ... mbbx 2.00: mask done in getMdmChar() */
ch = chAscii; /* mbbx: patch */
if((chAscii & 0x7F) == ESC) /* mbbx 2.00: not masking 8th bit... */
{
if((the8Char & 0x80) && (trmParams.emulate == ITMVT220)) /* mbbx 1.10: CSI = ESC + '[' */
pAnsiState();
else
termState = escHandler;
}
else if(termState) /* mbbx 2.00: do this AFTER checking for ESC... */
(*termState)();
else if((chAscii >= 0x20) && (chAscii != 0x7F)) /* mbbx 1.04: ics... */
{
putChar(chAscii);
if(curCol < maxChars-1)
curCol += 1;
else if(trmParams.lineWrap) /* mbbx 1.10: CUA... */
{
curCol = 0;
pLF();
}
}
else
(*escHandler)();
}