debian/cdesktop
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c48ec3adff2ddc7c65cce07ea215fffebcfd866a
cdesktop/cde/lib/DtTerm/Term/TermBuffer.c
Patrick Georgi c48ec3adff lib/DtTerm: Remove dead assignments, initializations and increments 
This shouldn't change behavior (or even object code) at all because
those assignments are all without effect. Removing that code removes
noise which helps working with code analysis tools.
2024-01-05 18:44:19 -07:00

1336 lines
32 KiB
C
Raw Blame History

/*
* CDE - Common Desktop Environment
*
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
*
* These libraries and programs are free software; you can
* redistribute them and/or modify them under the terms of the GNU
* Lesser General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* These libraries and programs are distributed in the hope that
* they will be useful, but WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with these libraries and programs; if not, write
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
* Floor, Boston, MA 02110-1301 USA
*/
/* *
* (c) Copyright 1993, 1994, 1996 Hewlett-Packard Company *
* (c) Copyright 1993, 1994, 1996 International Business Machines Corp. *
* (c) Copyright 1993, 1994, 1996 Sun Microsystems, Inc. *
* (c) Copyright 1993, 1994, 1996 Novell, Inc. *
* (c) Copyright 1996 Digital Equipment Corporation. *
* (c) Copyright 1996 FUJITSU LIMITED. *
* (c) Copyright 1996 Hitachi. *
*/
#define USE_MEMCPY /* use memcpy for line movement... */
#include <Xm/Xm.h>
#include "TermPrim.h"
#include "TermHeader.h" /* for MIN/MAX */
#include "TermBufferP.h"
#include "TermEnhance.h"
/*
** clear "count" enhancements starting at startCol
*/
static void
clearEnhancements
(
TermBuffer tb,
short row,
short startCol,
short count
);
static void
insertEnhancements
(
TermBuffer tb,
short row,
short col,
short insertCount
);
static void
deleteEnhancement
(
TermBuffer tb,
short row,
short col
);
static void
_DtTermClearEnhancements
(
TermBuffer tb,
short row,
short col,
short count
);
static int
_DtTermSetEnhancement
(
TermBuffer tb,
short row,
short col,
unsigned char id,
enhValue value
);
static Boolean
_DtTermGetEnhancement
(
const TermBuffer tb,
const short row,
const short col,
enhValue **enhancements,
short *count,
const countSpec countWhich
);
static termChar *
_DtTermGetCharacterPointer
(
TermBuffer tb,
short row,
short col
);
static void
_DtTermInsertEnhancements
(
const TermBuffer tb,
const short row,
const short col,
short insertCount,
const Boolean insertFlag
);
static Boolean
_DtTermBufferCreateEnhancement
(
TermBuffer tb,
short row,
short col
);
static void
_DtTermBufferResize
(
TermBuffer newTb,
short *newRows,
short *newCols
);
static void
_DtTermDeleteEnhancement
(
TermBuffer tb,
short row,
short col,
short width
);
static short
_DtTermInsert
(
TermBuffer tb,
short row,
short col,
termChar *newChars,
short numChars,
Boolean insertFlag, /* if TRUE, insert, else overwrite */
termChar **returnChars, /* pointer to overflow buffer */
short *returnCount /* count of characters in overflow buffer */
);
static Boolean
_DtTermSetLineLength
(
TermBuffer tb,
short row,
short newLength
);
static short
_DtTermGetLineLength
(
TermBuffer tb,
short row
);
static Boolean
_DtTermClearLine
(
TermBuffer tb,
short row,
short newLength
);
#if (defined(TEST) || defined(__CODECENTER__) || defined(VALIDATE_ENH))
static void
validateEnhancements
(
TermBuffer tb,
short row
);
# define VALIDATE_ENHANCEMENTS(tb, row) validateEnhancements((tb), (row))
#else
# define VALIDATE_ENHANCEMENTS(tb, row)
#endif /* TEST || __CODECENTER__ || VALIDATE_ENH */
/*
** A blank enhancement structure, it will come in handy.
*/
static DtTermEnhPart blankEnh = {0, 0, 0, 0, 0};
/*
** Create and initialize the Dt-specific parts of the term buffer.
*/
TermBuffer
_DtTermBufferCreateBuffer
(
const Widget w,
const short rows,
const short cols,
const short sizeOfBuffer,
const short sizeOfLine,
const short sizeOfEnh
)
{
int i;
TermBuffer newTB;
DtLine *lines;
newTB = _DtTermPrimBufferCreateBuffer(w, rows, cols,
sizeOfBuffer, sizeOfLine, sizeOfEnh);
if (newTB)
{
VALUE_LIST(newTB) = (enhValues) malloc(NUM_ENHANCEMENT_FIELDS *
sizeof(enhValue));
if (!VALUE_LIST(newTB))
{
_DtTermPrimBufferFreeBuffer(newTB);
return((TermBuffer) NULL);
}
NUM_ENH_FIELDS(newTB) = NUM_ENHANCEMENT_FIELDS;
for (lines = DT_LINES(newTB);
lines < DT_LINES(newTB) + ROWS(newTB);
lines++)
{
DT_ENH(*lines) = (DtEnh) NULL;
}
DT_ENH_STATE(newTB) = blankEnh;
DT_ENH_DIRTY(newTB) = 0;
ENH_PROC(newTB) = _DtTermEnhProc;
BUFFER_CREATE(newTB) = _DtTermBufferCreateBuffer;
BUFFER_FREE(newTB) = _DtTermBufferFreeBuffer;
BUFFER_RESIZE(newTB) = _DtTermBufferResize;
CLEAR_ENH(newTB) = _DtTermClearEnhancements;
INSERT_ENH(newTB) = _DtTermInsertEnhancements;
DELETE_ENH(newTB) = _DtTermDeleteEnhancement;
SET_ENH(newTB) = _DtTermSetEnhancement;
GET_ENH(newTB) = _DtTermGetEnhancement;
SET_LINE_LENGTH(newTB) = _DtTermSetLineLength;
CLEAR_LINE(newTB) = _DtTermClearLine;
}
return(newTB);
}
/*
** Resize buffer, this is a helper function, if malloc fails, then the
** appropriate dimensions are forced to the current maximums
*/
static void
_DtTermBufferResize
(
TermBuffer tb,
short *newRows,
short *newCols
)
{
short i;
DtEnh enh;
DtLine *lines;
/*
** make any necessary width adjustments first...
**
** NOTE:
** We do not take any action if the new column width is less
** than the current column width. It is the responsibility of
** the rendering code to make sure that two column characters
** are handled properly if the second column falls past the last
** column in the window.
*/
if (*newCols > MAX_COLS(tb))
{
termChar *newLineBuffer;
/*
** now extend the line buffers and enhancements for all lines,
** (even lines that are not being used at the moment
** (ROWS < MAX_ROWS))...
*/
lines = DT_LINES(tb);
for (i = 0; i < MAX_ROWS(tb); i++)
{
/*
** only copy the enhancement information when it exists
*/
if (DT_ENH(lines[i]))
{
enh = (DtEnh) malloc(*newCols * sizeof(DtTermEnhPart));
if (enh)
{
/*
** copy the enhancment info for all characters on
** the line, zero out the rest
*/
(void) memcpy(enh, DT_ENH(lines[i]),
WIDTH(lines[i]) * sizeof(DtTermEnhPart));
(void) memset(&enh[WIDTH(lines[i])], 0,
(*newCols - WIDTH(lines[i])) *
sizeof(DtTermEnhPart));
free(DT_ENH(lines[i]));
DT_ENH(lines[i]) = enh;
}
else
{
/*
** the malloc failed, revert back to MAX_COLS
*/
*newCols = MAX_COLS(tb);
*newRows = MIN(*newRows, MAX_ROWS(tb));
break;
}
}
newLineBuffer = (termChar *) malloc((unsigned)
*newCols * BYTES_PER_CHAR(tb));
if (newLineBuffer == NULL)
{
/*
** line buffer malloc failed, we can only increase the
** width to the current maximum...
*/
*newCols = MAX_COLS(tb);
*newRows = MIN(*newRows, MAX_ROWS(tb));
break;
}
memcpy(newLineBuffer, BUFFER(lines[i]), LENGTH(lines[i]) *
BYTES_PER_CHAR(tb));
free(BUFFER(lines[i]));
BUFFER(lines[i]) = newLineBuffer;
WRAPPED(lines[i]) = False;
}
MAX_COLS(tb) = *newCols;
}
COLS(tb) = *newCols;
/*
** now adjust the length of the buffer as necessary...
*/
if (*newRows > MAX_ROWS(tb))
{
/*
** the number of rows is increasing
*/
lines = (DtLine *) malloc((unsigned) *newRows * sizeof(DtLine));
if (lines != NULL)
{
/*
** the malloc succeeded, copy the old information, and then
** free it...
*/
memcpy(lines, DT_LINES(tb), sizeof(DtLine) * MAX_ROWS(tb));
free(DT_LINES(tb));
LINES(tb) = (TermLine *)lines;
/*
** now initialize the new lines...
**
** NOTE:
** If we are unable to malloc any part of a line, adjust
** "newRows" and break.
*/
for (i = MAX_ROWS(tb); i < *newRows; i++)
{
lines[i] = (DtLine) malloc(SIZE_OF_LINE(tb));
if (lines[i])
{
DT_ENH(lines[i]) = NULL;
BUFFER(lines[i]) = (termChar *) malloc((unsigned) COLS(tb) *
BYTES_PER_CHAR(tb));
if (BUFFER(lines[i]))
{
LENGTH(lines[i]) = 0;
WIDTH(lines[i]) = 0;
WRAPPED(lines[i]) = False;
}
else
{
/*
** the line buffer malloc failed...
*/
*newRows = i;
break;
}
}
else
{
/*
** we couldn't malloc this line...
*/
*newRows = i;
break;
}
}
MAX_ROWS(tb) = *newRows;
}
else
{
/*
** the malloc for the row buffer failed, revert back to MAX_ROWS
*/
*newRows = MAX_ROWS(tb);
}
}
ROWS(tb) = *newRows;
}
/*
** Free the buffer.
**
** NOTE: This is a helper function, and should only be called by
** TermPrimBufferFreeBuffer.
*/
void
_DtTermBufferFreeBuffer
(
const TermBuffer tb
)
{
DtLine *lines;
/*
** Free the Dt-specific buffer info...
*/
for (lines = DT_LINES(tb); lines < DT_LINES(tb) + ROWS(tb); lines++)
{
if (DT_ENH(*lines))
{
(void) free(DT_ENH(*lines));
}
}
if (VALUE_LIST(tb))
{
(void) free(VALUE_LIST(tb));
}
}
/*
** clear all the enhancements from startCol through stopCol
*/
static void
clearEnhancements
(
TermBuffer tb,
short row,
short col,
short count
)
{
DtEnh enh;
int i;
enh = DT_ENH(DT_LINE_OF_TBUF(tb, row));
if (enh)
{
enh += col;
for(i = 0; i < count; i++)
{
/*
** Clear all of the enhancement information.
*/
*enh = blankEnh;
enh++;
}
}
}
/*
** Clear "count" enhancement blocks, starting at the specified row and column.
*/
static void
_DtTermClearEnhancements
(
TermBuffer tb,
short row,
short col,
short count
)
{
clearEnhancements(tb, row, col, count);
}
/*
** Insert the desired number of enhancements at the specified
** position...
**
** NOTE:
** We depend on the calling function to insure that insertCount
** has been properly clipped to insure that we don't go out of
** bounds.
** Results are undefined if this function is called when the specified
** column is at the end of the line.
*/
static void
_DtTermInsertEnhancements
(
const TermBuffer tb,
const short row,
const short col,
short insertCount,
const Boolean insertFlag
)
{
DtTermEnhPart fillEnh;
DtEnh enh;
DtLine line;
int i;
int copyCount;
line = DT_LINE_OF_TBUF(tb, row);
enh = DT_ENH(line);
/*
** There's nothing to do if we're past the end of the line or
** the dirty bit is clear and there are no ehancements on
** this line...
*/
if ((col < WIDTH(line)) && ((DT_ENH_DIRTY(tb)) || (enh != NULL)))
{
if ((enh == NULL))
{
/*
** there are currently no enhancements on this line,
** allocate an enhancement buffer, and reset 'enh'...
*/
_DtTermBufferCreateEnhancement(tb, row, col);
enh = DT_ENH(line);
}
/*
** get a copy of the current enhancement (we'll insert 'copyCount'
** copies of it into the enhancement buffer)
*/
fillEnh = DT_ENH_STATE(tb);
if (insertFlag)
{
/*
** we're in insert mode, move any existing enhancements...
*/
copyCount = MIN((WIDTH(line) - col),
(COLS(tb) - col - insertCount));
copyCount = MAX(0, copyCount);
memmove(enh + col + insertCount, enh + col,
copyCount * sizeof(DtTermEnhPart));
}
#ifdef NOCODE
/*
** insert insertCount copies of fillEnh into the enhancement buffer
** starting at line->enh[col + 1]...
*/
enh += col + 1;
for (i = 0; i < insertCount; i++)
{
*enh = fillEnh;
enh++;
}
#else /* NOCODE */
/*
** insert insertCount copies of fillEnh into the enhancement buffer
** starting at line->enh[col + 1]...
*/
enh += col;
for (i = 0; i < insertCount; i++)
{
*enh = fillEnh;
enh++;
}
#endif /* NOCODE */
}
}
void
_DtTermBufferDelete
(
TermBuffer tb,
short *row,
short *col,
short *count /* number of columns to delete */
)
{
_DtTermPrimBufferDelete(tb, row, col, count, NULL, NULL);
}
/*
** delete the desired enhancements starting the specified position...
*/
static void
_DtTermDeleteEnhancement
(
TermBuffer tb,
short row,
short col,
short width
)
{
DtEnh enh;
DtTermEnhPart fillEnh;
DtLine line;
int copyCount;
line = DT_LINE_OF_TBUF(tb, row);
enh = DT_ENH(line);
if ((enh == NULL) || (WIDTH(line) <= col))
{
/*
** no enhancements, or at (or past) the end of the line, return
*/
return;
}
/*
** move all of the enhancement blocks between col + width and the
** end of the line to col
*/
copyCount = WIDTH(line) - (col + width);
memmove(enh + col , enh + col + width,
copyCount * sizeof(DtTermEnhPart));
}
/*
** Create an enhancement block at the specified row and column.
**
** NOTE: For the time being, we simply allocate an entire row's worth
** of enhancement blocks if it doesn't exist already. We may
** get smarter later on.
*/
/*ARGSUSED*/
static Boolean
_DtTermBufferCreateEnhancement
(
TermBuffer tb,
short row,
short col
)
{
DtLine line;
DtEnh *enh;
if (!VALID_ROW(tb, row) || !VALID_COL(tb, col))
{
return(False);
}
line = DT_LINE_OF_TBUF(tb, row);
enh = &(DT_ENH(line));
/*
** If this row already has enhancement blocks allocated, return.
*/
if (*enh == NULL)
{
/*
** Otherwise, allocate and initialize a row of enhancement blocks.
*/
*enh = (DtEnh) malloc(MAX_COLS(tb) * sizeof(DtTermEnhPart));
if (*enh == NULL)
{
return(False);
}
/*
** Clear all the enhancements...
*/
(void) memset(*enh, 0, MAX_COLS(tb) * sizeof(DtTermEnhPart));
}
return(True);
}
/*
** Free the enhancement block at the specified row and column.
**
** NOTE: We may get smarter later on.
*/
Boolean
_DtTermBufferFreeEnhancement
(
TermBuffer tb,
short row,
short col
)
{
return(True);
}
/*
** Set the desired enhancement.
**
** This function does the right thing (as far as I can tell regarding
** propagating enhancements).
**
** Return:
** -1 : the enhancement was not set
** >= 0 : the number of characters (as opposed to character positions)
** that the enhancement affects
*/
static int
_DtTermSetEnhancement
(
TermBuffer tb,
short row,
short col,
unsigned char id,
enhValue value
)
{
int i;
DtEnh enhState;
enhState = (DtEnh) &(DT_ENH_STATE(tb));
/*
** Set the value.
*/
switch (id)
{
case enhVideo:
enhState->video = value & VIDEO_MASK;
break;
case enhField:
enhState->field = value & FIELD_MASK;
break;
case enhFgColor:
enhState->fgColor = value & COLOR_MASK;
break;
case enhBgColor:
enhState->bgColor = value & COLOR_MASK;
break;
case enhFont:
enhState->font = value & FONT_MASK;
break;
default:
return(-1);
}
/*
** We've set the value, now decide if this anything but the blank
** enhancement.
*/
DT_ENH_DIRTY(tb) = ((enhState->video != blankEnh.video ) ||
(enhState->field != blankEnh.field ) ||
(enhState->fgColor != blankEnh.fgColor) ||
(enhState->bgColor != blankEnh.bgColor) ||
(enhState->font != blankEnh.font ));
/*
** return the correct count (which in this case will always be 0)
*/
return(0);
}
/*
** Get the enhancements for the desired row and column.
**
** enhValues:
** a pointer to an array of the current enhancement values
**
** count:
** the number of columns for which the enhancements are
** valid, or the number of columns until the enhancements
** were modified by an escape sequence (see 'countWhich' below)
**
** countWhich:
** if 'countWhich' is countAll then count until any enhancement value
** changes
** if 'countAll' is countNew then count until a new enhancement value
** starts (regardless of whether it is the same or not).
**
** Return:
** True if row and col are valid
*/
static Boolean
_DtTermGetEnhancement
(
const TermBuffer tb,
const short row,
const short col,
enhValue **values,
short *count,
const countSpec countWhich
)
{
/*
** store the current enhancement values here
*/
int i;
DtLine line;
DtEnh enh;
/*
** First we do some simple bounds checking
*/
VALIDATE_ENHANCEMENTS(tb, row);
if (!VALID_ROW(tb, row) || !VALID_COL(tb, col))
{
return(False);
}
line = DT_LINE_OF_TBUF(tb, row);
/*
** point to the correct enhancement chunk.
*/
if (DT_ENH(line) == NULL || (WIDTH(line) <= col))
{
/*
** There are either no enhancements allocated for this line,
** or we're past the end of the line, in either case return
** a blank enhancement.
*/
enh = &blankEnh;
}
else
{
/*
** We're in the line get the current enhancement values
*/
enh = &(DT_ENH(line)[col]);
}
/*
** Shove the enhancement values into their correct locations...
*/
*values = (VALUE_LIST(tb));
(*values)[(int)enhVideo ] = (enh->video & VIDEO_MASK);
(*values)[(int)enhField ] = (enh->field & FIELD_MASK);
(*values)[(int)enhFgColor] = (enh->fgColor & COLOR_MASK);
(*values)[(int)enhBgColor] = (enh->bgColor & COLOR_MASK);
(*values)[(int)enhFont ] = (enh->font & FONT_MASK );
/*
** Now count how many characters are affected by the enhancements.
*/
if (DT_ENH(line) == NULL)
{
/*
** There no enhancements allocated for this line, the default
** enhancement is active for the remainder of the line.
** NOTE: Make sure count >= 0.
*/
*count = MAX(0, WIDTH(line) - col);
}
else if (WIDTH(line) <= col)
{
/*
** We're past the end of the line, count will always == 0;
*/
*count = 0;
}
else
{
/*
** We're in the line, determine the number of characters that
** these enhancements apply to.
*/
switch (countWhich)
{
case countNew:
/*
** For Vt220 emulation, countNew is the same as countAll...
** JRM 08/30/93
*/
case countAll:
/*
** count until an enhancement value changes
*/
for (i = 0; i < (WIDTH(line) - col); i++)
{
if (((*values)[(int)enhVideo ] != (enh->video & VIDEO_MASK))||
((*values)[(int)enhField ] != (enh->field & FIELD_MASK))||
((*values)[(int)enhFgColor] != (enh->fgColor & COLOR_MASK))||
((*values)[(int)enhBgColor] != (enh->bgColor & COLOR_MASK))||
((*values)[(int)enhFont ] != (enh->font & FONT_MASK )) )
{
/*
** the enhancements differ; break out
*/
break;
}
enh++;
}
break;
default:
VALIDATE_ENHANCEMENTS(tb, row);
return(False);
}
*count = i;
}
VALIDATE_ENHANCEMENTS(tb, row);
return(True);
}
/*
** This is a vt-specific helper function for setting the line length.
** By the time the function is called, termBufferSetLineLength()
** as already validated the newLength, the row, and insured that the
** new length is > the current length
**
** This function propagates the correct enhancement to the new end of line.
*/
static Boolean
_DtTermSetLineLength
(
TermBuffer tb,
short row,
short newLength
)
{
return(True);
}
/*
** _DtTermPrimBufferClearLine will reset the line width, this is
** our chance to clear any enhancements that may exist on this line...
*/
static Boolean
_DtTermClearLine
(
TermBuffer tb,
short row,
short newWidth
)
{
DtLine line;
DtEnh enh;
line = DT_LINE_OF_TBUF(tb, row);
enh = DT_ENH(line);
if (enh != NULL)
{
/*
** We have enhancements, clear all those between the current
** and the new length...
*/
(void) memset(&enh[newWidth], 0,
(WIDTH(line) - newWidth) * sizeof(DtTermEnhPart));
}
return(True);
}
/*
** Erase characters on the specified row (and clear the enhancements) with
** the appropriate semantics. For VT class emulators, there are several
** ways to erase characters:
** - from the active position to the end of line
** - erase the specified number of characters starting at the current
** cursor position
** - from the start of the line to the active position
** - erase the entire line
** - from the active position to the end of the buffer
** - erase the specified number of lines starting at the current
** cursor position
** - from the start of the buffer to the active position
** - erase the entire buffer
*/
void
_DtTermBufferErase
(
TermBuffer tb,
short row,
short col,
short count,
DtEraseMode eraseSwitch
)
{
short startCol = 0;
short lastCol = 0;
switch(eraseSwitch)
{
case eraseFromCol0:
/*
** erase from col 0 to the current cursor position
*/
startCol = 0;
lastCol = MIN(col, WIDTH(DT_LINE_OF_TBUF(tb, row)) - 1);
break;
case eraseCharCount:
/*
** erase "count" characters from the current cursor position
*/
startCol = col;
lastCol = MIN(col + count - 1, WIDTH(DT_LINE_OF_TBUF(tb, row)) - 1);
break;
case eraseLineCount:
case eraseToEOL:
case eraseLine:
case eraseBuffer:
case eraseFromRow0Col0:
case eraseToEOB:
/*
** These cases should have been handled by _DtTermFuncErase()
*/
return;
}
_DtTermPrimBufferErase(tb, row, startCol, lastCol);
/*
** now clear the corresponding enhancements...
*/
clearEnhancements(tb, row, startCol, lastCol - startCol + 1);
}
#if (defined(TEST) || defined(__CODECENTER__) || defined(VALIDATE_ENH))
static void
_DtTermValidateEnhancements
(
TermBuffer tb,
short row
)
{
DtTermEnhPart refEnh;
DtEnh thisEnh;
DtLine thisLine;
short col;
Boolean validatePassed;
validatePassed = True;
thisLine = DT_LINE_OF_TBUF(tb, row);
if (DT_ENH(thisLine))
{
/*
** Initialize the reference enhancement
*/
refEnh = blankEnh;
refEnh.videoStart = 0;
refEnh.fieldStart = 0;
refEnh.colorStart = 0;
refEnh.fontStart = 0;
for(col = 0, thisEnh = DT_ENH(thisLine);
col < WIDTH(thisLine) +
(DANGLE(thisLine) >= 0 ? 1 : 0);
col++, thisEnh++)
{
if (thisEnh->videoStart)
{
refEnh.video = thisEnh->video;
}
else if (refEnh.video != thisEnh->video)
{
fprintf(stderr, "Video enhancements don't match:");
fprintf(stderr, " row : %3.3d, col : %3.3d\n", row, col);
fprintf(stderr, " refEnh.video : %d\n", (int)(refEnh.video & VIDEO_MASK));
fprintf(stderr, " thisEnh->video: %d\n", (int)(thisEnh->video & VIDEO_MASK));
validatePassed = False;
}
if (thisEnh->fieldStart)
{
refEnh.field = thisEnh->field;
}
else if (refEnh.field != thisEnh->field)
{
fprintf(stderr, "Field enhancements don't match:");
fprintf(stderr, " row : %3.3d, col : %3.3d\n", row, col);
fprintf(stderr, " refEnh.field : %d\n", (int)(refEnh.field & FIELD_MASK));
fprintf(stderr, " thisEnh->field: %d\n", (int)(thisEnh->field & FIELD_MASK));
validatePassed = False;
}
if (thisEnh->colorStart)
{
refEnh.color = thisEnh->color;
}
else if (refEnh.color != thisEnh->color)
{
fprintf(stderr, "Color enhancements don't match:");
fprintf(stderr, " row : %3.3d, col : %3.3d\n", row, col);
fprintf(stderr, " refEnh.color : %d\n", (int)(refEnh.color & COLOR_MASK));
fprintf(stderr, " thisEnh->color: %d\n", (int)(thisEnh->color & COLOR_MASK));
validatePassed = False;
}
if (thisEnh->font <= 2)
{
if (thisEnh->fontStart)
{
refEnh.font = thisEnh->font;
}
else if (refEnh.font != thisEnh->font)
{
fprintf(stderr, "Font enhancements don't match:");
fprintf(stderr, " row : %3.3d, col : %3.3d\n", row, col);
fprintf(stderr, " refEnh.font : %d\n", (int)(refEnh.font & FONT_MASK));
fprintf(stderr, " thisEnh->font: %d\n", (int)(thisEnh->font & FONT_MASK));
validatePassed = False;
}
}
else
{
fprintf(stderr, "Font enhancement out of range:");
fprintf(stderr, " row : %3.3d, col : %3.3d\n", row, col);
fprintf(stderr, " thisEnh->font: %d\n", (int)(thisEnh->font & FONT_MASK));
validatePassed = False;
}
}
}
if (validatePassed == False)
{
fprintf(stderr, "validateEnhancement failed\n");
}
}
#endif /* TEST || __CODECENTER__ || DEBUG || VALIDATE_ENH */
#if (defined(TEST) || defined(__CODECENTER__) || defined(DEBUG))
#ifdef NOCODE
static void
_printLine
(
TermBuffer tb,
short row
)
{
DtLine line;
termChar *pChar;
short j;
printf("Line: %d\n", row);
line = tb->lines[row];
printf(" length: %3d\n", line->length);
if (line->length > 0)
{
printf(" buffer: <");
pChar = line->buffer;
for (j = 0; j < line->length; j++)
{
printf("%X", *pChar++);
}
printf(">\n");
}
}
static int
_DtTermPrintEnhancement
(
TermBuffer tb,
short row,
short col
)
{
enhValue enhancements[NUM_ENHANCEMENT_FIELDS];
short enhCount;
_DtTermPrimBufferGetEnhancement(tb, row, col, enhancements, &enhCount, countNew);
printf(" col : %d\n", col);
printf(" Count: %d\n", enhCount);
printf(" Video: '_");
printf("%s", IS_BOLD(enhancements[enhVideo]) != 0 ? "B":"b");
printf("_");
printf("%s", IS_SECURE(enhancements[enhVideo]) != 0 ? "S":"s");
printf("_");
printf("%s", IS_HALF_BRIGHT(enhancements[enhVideo]) != 0 ? "H":"h");
printf("_");
printf("%s", IS_UNDERLINE(enhancements[enhVideo]) != 0 ? "U":"u");
printf("_");
printf("%s", IS_INVERSE(enhancements[enhVideo]) != 0 ? "I":"i");
printf("_");
printf("%s", IS_BLINK(enhancements[enhVideo]) != 0 ? "B":"b");
printf("_'\n");
/*
** Field type
*/
printf(" Field: ");
switch (enhancements[enhField])
{
case FIELD_PROTECT:
printf("PROTECT");
break;
case FIELD_UNPROTECT:
printf("UNPROTECT");
break;
case FIELD_TRANSMIT:
printf("TRANSMIT");
break;
case FIELD_END:
printf("END");
break;
}
printf("\n");
/*
** Color id
*/
printf(" Color: %1d\n", enhancements[enhFont]);
/*
** Font id
*/
printf(" Font : ");
switch (enhancements[enhFont])
{
case FONT_NORMAL:
printf("NORMAL");
break;
case FONT_LINEDRAW:
printf("LINEDRAW");
break;
}
printf("\n");
return(enhCount);
}
#endif /* NOCODE */
static void
printEnh
(
DtEnh enh
)
{
printf(" video : %d\n", enh->video);
printf(" field : %d\n", enh->field);
printf(" fgColor: %d\n", enh->fgColor);
printf(" bgColor: %d\n", enh->bgColor);
printf(" font : %d\n", enh->font);
}
/*
** Print the contents of the TermBuffer.
*/
static void
_DtTermPrintBuffer
(
DtTermBuffer tb
)
{
short i;
short j;
short k;
if (tb == NULL) {
printf("TermBuffer has been freed.\n");
return;
}
printf("TermBuffer dimensions:\n");
printf(" rows: %d\n", ROWS(tb));
printf(" cols: %d\n", COLS(tb));
printf(" enhDirty: %d\n", DT_ENH_DIRTY(tb));
printf(" enhState:\n");
printEnh(&(DT_ENH_STATE(tb)));
#ifdef NOCODE
for (i = 0; i < ROWS(tb); i++)
{
_printLine(tb, i);
j = 0;
do
{
k = _termBufferPrintEnhancement(tb, i, j);
if (k == 0)
{
break;
}
j += k;
} while (j < COLS(tb));
}
#endif /* NOCODE */
}
#endif /* (defined(TEST) || defined(__CODECENTER__)) */
#ifdef TEST
/*
** Some simple tests of the termBuffer.
*/
/* the following is to allow for a single main function in the code... */
#define termBufMain main
termBufMain()
{
TermBuffer myTB;
printf("Sizeof DtTermEnhPart : %d\n", sizeof(struct _DtTermEnhPart));
printf("Sizeof termBufferRec : %d\n", sizeof(struct _TermBufferRec));
myTB = _DtTermPrimBufferCreateBuffer(12, 80);
_termBufferPrintBuffer(myTB);
printf("[0,0] %d\n", _DtTermPrimBufferSetEnhancement(myTB, 0, 0, enhVideo, BLINK));
_termBufferPrintEnhancement(myTB, 0, 0);
printf("[0,1] %d\n", _DtTermPrimBufferSetEnhancement(myTB, 0, 1, enhVideo, INVERSE));
_termBufferPrintEnhancement(myTB, 0, 0);
_termBufferPrintEnhancement(myTB, 0, 1);
printf("[0,9] %d\n", _DtTermPrimBufferSetEnhancement(myTB, 0, 9, enhVideo, UNDERLINE));
_termBufferPrintEnhancement(myTB, 0, 0);
_termBufferPrintEnhancement(myTB, 0, 1);
_termBufferPrintEnhancement(myTB, 0, 9);
printf("[0,6] %d\n", _DtTermPrimBufferSetEnhancement(myTB, 0, 6, enhVideo, HALF_BRIGHT));
_termBufferPrintEnhancement(myTB, 0, 0);
_termBufferPrintEnhancement(myTB, 0, 1);
_termBufferPrintEnhancement(myTB, 0, 6);
_termBufferPrintEnhancement(myTB, 0, 9);
_termBufferPrintBuffer(myTB);
_DtTermPrimBufferSetEnhancement(myTB, 10, 10, enhVideo, BLINK);
_DtTermPrimBufferSetEnhancement(myTB, 10, 20, enhColor, 3);
_termBufferPrintBuffer(myTB);
_DtTermPrimBufferResizeBuffer(&myTB, 6, 40);
_termBufferPrintBuffer(myTB);
_DtTermPrimBufferSetEnhancement(myTB, 10, 10, enhVideo, BLINK);
_DtTermPrimBufferResizeBuffer(&myTB, 12, 80);
_termBufferPrintBuffer(myTB);
_DtTermPrimBufferFreeBuffer(myTB);
}
#endif /* TEST */
Reference in New Issue View Git Blame Copy Permalink