Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-06 06:33:08 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/rossubsys/posix/apps/posixw32/console.c
Hermès Bélusca-Maïto 2ca9fcd3b0 Resuscitate POSIX subsystem from revision 21378. 
svn path=/trunk/; revision=65460
2014-11-23 15:23:36 +00:00

1243 lines
30 KiB
C
Raw Blame History

/* console.c
*
* AUTHOR: John L. Miller, johnmil@cs.cmu.edu / johnmil@jprc.com
* DATE: 8/4/96
*
* Copyright (c) 1996 John L. Miller
*
* Full permission is granted to use, modify and distribute
* this code, provided:
* 1) This comment field is included in its entirity
* 2) No money is charged for any work including or based on
* portions of this code.
*
* If you're a nice person and find this useful, I'd appreciate a
* note letting me know about it. e-mail is usually what spurs me
* on to improve and support software I've written.
*
* This file contains functions intended to provide the back
* end to a console window for my semi-vt100 emulator.
*/
/* Note - one HUGE difference between console windows and terminal
* windows. Console windows displays start at (0,0). Terminal displays
* start at (1,1). YUCK!
*/
#include <windows.h>
#include "vt100.h"
int topScrollRow=TOP_EDGE;
int bottomScrollRow=BOTTOM_EDGE;
/* This variable will contain terminal configuration flags, such as
* reverse/standard video, whether wrapping is enabled, and so on.
*/
int conTermMode;
/* Variable to hold the cursor position for save/restore cursor calls */
COORD cursorPosSave={1,1};
/* Handles to the current console for input and output */
HANDLE hConIn, hConOut;
/* Array of all the tabs which are currently set. Ironically, I think the
* primary emulator can CLEAR tags, but not set them.
*/
int tabSet[132]={0};
int numTabs = 0;
/* This section contains console-specific color information. NT consoles can
* have Red, blue, green, and intensity flags set. Hence, 4 con_colors.
*/
#define NUM_CON_COLORS 4
/* Foreground and background colors are separated out */
int conForeColors, conBackColors;
/* mapping between foreground and background console colors: needed
* when reverse video is being used
*/
int conColorMapping[NUM_CON_COLORS][2] =
{
{FOREGROUND_RED, BACKGROUND_RED},
{FOREGROUND_BLUE, BACKGROUND_BLUE},
{FOREGROUND_GREEN, BACKGROUND_GREEN},
{FOREGROUND_INTENSITY, BACKGROUND_INTENSITY}
};
/* Device-independant foreground and background flags stored here.
* probably a bad division of labor, but hey, since we don't use
* all of their flags in our console stuff (and hence can't retrieve
* them), the information has to live SOMEWHERE.
*/
int scForeFlags, scBackFlags;
/* Defines for array indexing for translation of flags */
#define SC_FLAG 0
#define CONSOLE_FLAG 1
/* Color mapping between SC (the vt-100 emulator device independant
* flags) and NT console character specific flags. Flags which have no analog
* are set to 0. Note that all global character attributes (character set
* underline, bold, reverse) are all stored in foreground only
*/
const int scForeMapping[NUM_SC_ATTRIBUTES][2] =
{
{SC_RED,FOREGROUND_RED},
{SC_GREEN,FOREGROUND_GREEN},
{SC_BLUE,FOREGROUND_BLUE},
{SC_BOLD,FOREGROUND_INTENSITY},
{SC_UL,0},
{SC_BL,0},
{SC_RV,0},
{SC_ASCII,0},
{SC_G0,0},
{SC_G1,0},
{SC_GRAPHICS,0}
};
/* Background color mapping between SC and console */
const int scBackMapping[NUM_SC_ATTRIBUTES][2] =
{
{SC_RED,BACKGROUND_RED},
{SC_GREEN,BACKGROUND_GREEN},
{SC_BLUE,BACKGROUND_BLUE},
{SC_BOLD,BACKGROUND_INTENSITY},
{SC_UL,0},
{SC_BL,0},
{SC_RV,0},
{SC_ASCII,0},
{SC_G0,0},
{SC_G1,0},
{SC_GRAPHICS,0}
};
/* These arrays map character vals 0-255 to new values.
* Since the G0 and G1 character sets don't have a direct analog in
* NT, I'm settling for replacing the ones I know what to set them
* to.
*/
char G0Chars[256];
char G1Chars[256];
/* These four sets of variables are just precomputed combinations of
* all the possible flags to save time for masking.
*/
int allFore[2], allBack[2];
int bothFore[2], bothBack[2];
/* FORWARD DECLARATIONS */
int
RawPrintLine(
char *text,
int len,
int scrollAtEnd
);
int
Scroll(
int row
);
/* END FORWARD DECLARATIONS */
/* beInitVT100Terminal() -
*
* This function is called by the VT100 emulator as soon as the
* front-end terminal is initialized. It's responsible for setting
* initial state of the terminal, and initing our many wacky variables.
*/
int
beInitVT100Terminal()
{
int i;
CONSOLE_SCREEN_BUFFER_INFO csbi;
/* Set tabs to every 8 spaces initially */
numTabs = 0;
for (numTabs=0; numTabs < 132/8; numTabs++)
tabSet[numTabs] = (numTabs+1)*8;
/* Init the cursor save position to HOME */
cursorPosSave.X = 1;
cursorPosSave.Y = 1;
/* Disable scrolling window limits */
topScrollRow=TOP_EDGE;
bottomScrollRow=BOTTOM_EDGE;
conTermMode = ANSI_MODE|WRAP_MODE|REPEAT_MODE;
hConIn = GetStdHandle(STD_INPUT_HANDLE);
hConOut = GetStdHandle(STD_OUTPUT_HANDLE);
/* Init our time-saving mask variables */
allFore[SC_FLAG] = allBack[SC_FLAG] = 0;
allFore[CONSOLE_FLAG] = allBack[CONSOLE_FLAG] = 0;
bothFore[SC_FLAG] = bothBack[SC_FLAG] = 0;
bothFore[CONSOLE_FLAG] = bothBack[CONSOLE_FLAG] = 0;
for (i=0; i<NUM_SC_ATTRIBUTES; i++)
{
allFore[SC_FLAG] |= scForeMapping[i][SC_FLAG];
allFore[CONSOLE_FLAG] |= scForeMapping[i][CONSOLE_FLAG];
allBack[SC_FLAG] |= scBackMapping[i][SC_FLAG];
allBack[CONSOLE_FLAG] |= scBackMapping[i][CONSOLE_FLAG];
if (scForeMapping[i][SC_FLAG] && scForeMapping[i][CONSOLE_FLAG])
{
bothFore[SC_FLAG] |= scForeMapping[i][SC_FLAG];
bothFore[CONSOLE_FLAG] |= scForeMapping[i][CONSOLE_FLAG];
}
if (scBackMapping[i][SC_FLAG] && scBackMapping[i][CONSOLE_FLAG])
{
bothBack[SC_FLAG] |= scBackMapping[i][SC_FLAG];
bothBack[CONSOLE_FLAG] |= scBackMapping[i][CONSOLE_FLAG];
}
}
conForeColors = conBackColors = 0;
for (i=0; i<NUM_CON_COLORS; i++)
{
conForeColors |= conColorMapping[i][0];
conBackColors |= conColorMapping[i][1];
}
/* Do initial settings for device-independant flags */
scForeFlags = SC_ASCII;
scBackFlags = 0;
GetConsoleScreenBufferInfo(hConOut, &csbi);
for (i=0; i<NUM_SC_ATTRIBUTES; i++)
{
if (csbi.wAttributes & scForeMapping[i][CONSOLE_FLAG])
scForeFlags |= scForeMapping[i][SC_FLAG];
if (csbi.wAttributes & scBackMapping[i][CONSOLE_FLAG])
scBackFlags |= scBackMapping[i][SC_FLAG];
}
/* Since the G0/G1 character sets don't really map to
* USASCII, So come as close as we can. By default, it'll
* just print the ascii character. For the graphics characters
* I was able to identify, change that mapping.
*/
for (i=0; i<256; i++)
{
G0Chars[i] = i;
G1Chars[i] = i;
}
G1Chars['a']=(char)177;
G1Chars['f']=(char)248;
G1Chars['g']=(char)241;
G1Chars['j']=(char)217;
G1Chars['k']=(char)191;
G1Chars['l']=(char)218;
G1Chars['m']=(char)192;
G1Chars['n']=(char)197;
G1Chars['o']=(char)196;
G1Chars['p']=(char)196;
G1Chars['q']=(char)196;
G1Chars['r']=(char)196;
G1Chars['s']=(char)196;
G1Chars['t']=(char)195;
G1Chars['u']=(char)180;
G1Chars['v']=(char)193;
G1Chars['w']=(char)194;
G1Chars['x']=(char)179;
G1Chars['y']=(char)243;
G1Chars['z']=(char)242;
return(0);
}
/* beAbsoluteCursor -
*
* Given an input row and column, move the cursor to the
* absolute screen coordinates requested. Note that if the
* display window has scrollbars, the column is adjusted
* to take that into account, but the row is not. This allows
* for large scrollback in terminal windows.
*
* ROW must be able to accept CUR_ROW, TOP_EDGE, BOTTOM_EDGE,
* or a row number.
*
* COLUMN must be able to accept CUR_COL, LEFT_EDGE, RIGHT_EDGE,
* or a column number.
*/
int
beAbsoluteCursor(
int row,
int col
)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
COORD cursorPos;
GetConsoleScreenBufferInfo(hConOut, &csbi);
if (row == CUR_ROW)
row = csbi.dwCursorPosition.Y;
else if (row == TOP_EDGE)
row = csbi.srWindow.Top;
else if (row == BOTTOM_EDGE)
row = csbi.srWindow.Bottom;
else
row += csbi.srWindow.Top - 1;
if (col == CUR_COL)
col = csbi.dwCursorPosition.X;
else if (col == LEFT_EDGE)
col = 0;
else if (col == RIGHT_EDGE)
col = csbi.dwSize.X-1;
else
col -= 1;
cursorPos.X = col;
cursorPos.Y = row;
SetConsoleCursorPosition(hConOut, cursorPos);
return(0);
}
/* beOffsetCursor -
*
* Given an input row and column offset, move the cursor by that
* many positions. For instance, row=0 and column=-1 would move
* the cursor left a single column.
*
* If the cursor can't move the requested amount, results are
* unpredictable.
*/
int
beOffsetCursor(
int row,
int column
)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
COORD cursorPos;
GetConsoleScreenBufferInfo(hConOut, &csbi);
cursorPos = csbi.dwCursorPosition;
cursorPos.X += column;
cursorPos.Y += row;
if (cursorPos.X < 0)
cursorPos.X = 0;
if (cursorPos.X >= csbi.dwSize.X)
{
cursorPos.X -= csbi.dwSize.X;
cursorPos.Y += 1;
}
if (cursorPos.Y < 0)
cursorPos.Y = 0;
SetConsoleCursorPosition(hConOut, cursorPos);
return(0);
}
/* beRestoreCursor -
*
* Saved cursor position should be stored in a static
* variable in the back end. This function restores the
* cursor to the position stored in that variable.
*/
int
beRestoreCursor(void)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
COORD cursorPos;
GetConsoleScreenBufferInfo(hConOut, &csbi);
cursorPos = csbi.dwCursorPosition;
cursorPos.Y += cursorPosSave.Y;
SetConsoleCursorPosition(hConOut, cursorPos);
return(0);
}
/* beSaveCursor -
*
* The back-end should maintain a static variable with the
* last STORED cursor position in it. This function replaces
* the contents of that variable with the current cursor position.
* The cursor may be restored to this position by using the
* beRestoreCursor function.
*/
int
beSaveCursor(void)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo(hConOut, &csbi);
cursorPosSave = csbi.dwCursorPosition;
cursorPosSave.Y -= csbi.srWindow.Top;
return(0);
}
/* beGetTextAttributes -
*
* given a pointer to 'fore'ground and 'back'ground ints,
* fill them with a device-independant description of the
* current foreground and background colors, as well as any
* font information in the foreground variable.
*/
int
beGetTextAttributes(
int *fore,
int *back
)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
int i;
/* Since it's entirely possible that the text attributes were
* changed without our terminal being notified, we might as well
* make sure they're accurate.
*/
/* First, strip out everything in the screen buffer variables
* that we can detect
*/
scForeFlags &= ~bothFore[SC_FLAG];
scBackFlags &= ~bothBack[SC_FLAG];
/* Now, find out what the real settings are, and set the
* flag values accordingly.
*/
GetConsoleScreenBufferInfo(hConOut, &csbi);
/* If reverse video is set, we need to reverse our color mappings
* before any calculations get made.
*/
if (scForeFlags & SC_RV)
{
int tmpFore, tmpBack;
tmpFore = csbi.wAttributes & conForeColors;
tmpBack = csbi.wAttributes & conBackColors;
csbi.wAttributes &= ~(conForeColors | conBackColors);
for (i=0; i<NUM_CON_COLORS; i++)
{
if (tmpFore & conColorMapping[i][0])
csbi.wAttributes |= conColorMapping[i][1];
if (tmpBack & conColorMapping[i][1])
csbi.wAttributes |= conColorMapping[i][0];
}
}
/* Now, do the actual translation between our detectable
* console text attributes and the corresponding device-independant
* attributes.
*/
for (i=0; i<NUM_SC_ATTRIBUTES; i++)
{
if (csbi.wAttributes & scForeMapping[i][CONSOLE_FLAG])
scForeFlags |= scForeMapping[i][SC_FLAG];
if (csbi.wAttributes & scBackMapping[i][CONSOLE_FLAG])
scBackFlags |= scBackMapping[i][SC_FLAG];
}
/* Finally, copy our updated sc flags into the variables
* passed in
*/
if (fore != NULL)
*fore = scForeFlags;
if (back != NULL)
*back = scBackFlags;
return(0);
}
/* beSetTextAttributes -
*
* Given a foreground and a background device independant (SC) color and font
* specification, apply these to the display, and save the state in the
* static screen variables.
*
* Note that many font-specific constants (bold/underline/reverse, G0/G1/ASCII)
* are stored ONLY in the foreground specification.
*/
int
beSetTextAttributes(
int fore,
int back
)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
int i;
WORD wAttributes;
/* First off, let's assign these settings into our
* device-independant holder.
*/
scForeFlags = fore;
scBackFlags = back;
/* Next, determine the console's actual current settings */
GetConsoleScreenBufferInfo(hConOut, &csbi);
/* Mask out any of the attributes which can be set via
* our device-independant options. Since the console settings
* have additional options, we need to retain those so we don't
* do something unpleasant to our I/O abilities, for instance.
*/
wAttributes = csbi.wAttributes;
wAttributes &= ~(bothFore[CONSOLE_FLAG] | bothBack[CONSOLE_FLAG]);
/* Now, loop through the device-independant possibilities for
* flags, and modify our console flags as appropriate.
*/
for (i=0; i<NUM_SC_ATTRIBUTES; i++)
{
if (scForeFlags & scForeMapping[i][SC_FLAG])
wAttributes |= scForeMapping[i][CONSOLE_FLAG];
if (scBackFlags & scBackMapping[i][SC_FLAG])
wAttributes |= scBackMapping[i][CONSOLE_FLAG];
}
/* One last unpleasantry: if reverse video is set, then we should
* reverse the foreground and background colors
*/
if (scForeFlags & SC_RV)
{
int tmpFore, tmpBack;
tmpFore = wAttributes & conForeColors;
tmpBack = wAttributes & conBackColors;
wAttributes &= ~(conForeColors | conBackColors);
for (i=0; i<NUM_CON_COLORS; i++)
{
if (tmpFore & conColorMapping[i][0])
wAttributes |= conColorMapping[i][1];
if (tmpBack & conColorMapping[i][1])
wAttributes |= conColorMapping[i][0];
}
}
/* The appropriate colors, etc. should be set in
* the wAttributes variable now. Apply them to the
* current console.
*/
SetConsoleTextAttribute(hConOut, wAttributes);
return(0);
}
/* beRawTextOut-
*
* The name of this function is misleading. Given a pointer to
* ascii text and a count of bytes to print, print them to the
* display device. If wrapping is enabled, wrap text. If there is a
* scrolling region set and the cursor is in it,
* scroll only within that region. 'beRawTextOut' means that it's guaranteed
* not to have control sequences within the text.
*/
int
beRawTextOut(
char *text,
int len
)
{
int i,j;
/* If there's no work to do, return immediately. */
if ((text == NULL)||(len == 0))
return(0);
i=0;
/* Otherwise, loop through the text until all of it has been output */
while (i < len)
{
/* This inner loop serves to divide the raw text to output into
* explicit lines. While the 'RawPrintLine' may still have to
* break lines to do text wrapping, explicit line breaks are
* handled right here.
*/
j=i;
while ((text[j] != '\n')&&(j<len))
{
j++;
}
RawPrintLine(text+i, j-i, (text[j] == '\n'));
i = j+1;
}
return(0);
}
/* RawPrintLine -
*
* This routine is a helper for beRawTextOut. It is given a
* line of text which is guaranteed not to have any newlines
* or control characters (which need to be interpreted) in it.
* It prints out the text, wrapping if necessary, and handles
* scrolling or truncation.
*
* If scrollAtEnd is true, an extra carriage return (scroll) is
* performed after the text has been printed out.
*/
int
RawPrintLine(
char *text,
int len,
int scrollAtEnd
)
{
int i, end;
CONSOLE_SCREEN_BUFFER_INFO csbi;
DWORD dwWritten;
if ((scrollAtEnd == FALSE) && ((text == NULL)||(len == 0)))
return(0);
GetConsoleScreenBufferInfo(hConOut, &csbi);
/* find out how far to the first tab or end of text */
if (text != NULL)
{
for (end=0; end<len; end++)
{
if (text[end] == '\t')
break;
}
if (end > (csbi.dwSize.X - csbi.dwCursorPosition.X))
end = (csbi.dwSize.X - csbi.dwCursorPosition.X);
/* If we're in non-ascii mode, we need to do a little
* magic to get the right characters out.
*/
if (scForeFlags & SC_G1)
{
for (i=0; i<end; i++)
{
text[i] = G1Chars[text[i]];
}
}
/* actually print out the text. */
WriteConsole(hConOut,text,(DWORD)end,&dwWritten,NULL);
if (end == (csbi.dwSize.X - csbi.dwCursorPosition.X))
Scroll(CUR_ROW);
if ( (!(conTermMode & WRAP_MODE))
&& (end == (csbi.dwSize.X - csbi.dwCursorPosition.X))
)
end = len;
if (end != len)
{
if (text[end] == '\t')
{
beAdvanceToTab();
RawPrintLine(text+end+1,len - (end+1), FALSE);
}
else
{
RawPrintLine(text+end, len-end, FALSE);
beAbsoluteCursor(CUR_ROW,1);
beOffsetCursor(1,0);
}
}
}
/* Now that we've printed this line, scroll if we need to.
* Note that a scroll implies a newline.
*/
if (scrollAtEnd)
{
Scroll(CUR_ROW);
beAbsoluteCursor(CUR_ROW,1);
beOffsetCursor(1,0);
}
return(0);
}
/* Scroll -
*
* Given a row specification, calculate a scroll executed in that
* row. It could be within a scroll range, or outside of it.
*
* For some ungodly reason, I made this routine handle the TOP_EDGE,
* BOTTOM_EDGE, and CUR_ROW specifiers as well as a real row.
*/
int
Scroll(
int row
)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
SMALL_RECT scrollRect;
COORD dest;
CHAR_INFO fillChar;
GetConsoleScreenBufferInfo(hConOut, &csbi);
if (row == TOP_EDGE)
row = csbi.srWindow.Top;
else if (row == BOTTOM_EDGE)
row = csbi.srWindow.Bottom;
else if (row == CUR_ROW)
row = csbi.dwCursorPosition.Y;
else
row += csbi.srWindow.Top;
/* Escape out if we don't really need to scroll */
if ( (row < (csbi.dwSize.Y-1))
&& ((row-csbi.srWindow.Top + 1) < bottomScrollRow)
)
return(0);
/* NT console requires a fill character for scrolling. */
fillChar.Char.AsciiChar=' ';
fillChar.Attributes = csbi.wAttributes;
/* Determine the rectangle of text to scroll. Under NT this
* is actually an overlap-safe block-copy.
*/
scrollRect.Left = 0;
scrollRect.Top = 1;
scrollRect.Right = csbi.dwSize.X;
scrollRect.Bottom = row;
if (topScrollRow != TOP_EDGE)
{
scrollRect.Top = csbi.srWindow.Top + topScrollRow + 1;
}
if ( (bottomScrollRow != BOTTOM_EDGE)
&& ((csbi.srWindow.Top+bottomScrollRow) < scrollRect.Bottom)
)
{
scrollRect.Bottom = csbi.srWindow.Top + bottomScrollRow;
}
dest.X = 0;
dest.Y = scrollRect.Top - 1;
ScrollConsoleScreenBuffer(hConOut,&scrollRect,NULL,
dest, &fillChar);
return(0);
}
/* beEraseText -
*
* Given a 'from' and a 'to' position in display coordinates,
* this function will fill in all characters between the two
* (inclusive) with spaces. Note that the coordinates do NOT
* specify a rectangle. erasing from (1,1) to (2,2) erases
* all of the first row, and the first two characters of the
* second.
*
* Note that this routine must be able to handle TOP_EDGE,
* BOTTOM_EDGE, LEFT_EDGE, RIGHT_EDGE, CUR_ROW, and CUR_COL
* in the appropriate parameters.
*/
int
beEraseText(
int rowFrom,
int colFrom,
int rowTo,
int colTo
)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
COORD dest, saveCursor;
DWORD nLength, dwWritten;
GetConsoleScreenBufferInfo(hConOut, &csbi);
saveCursor = csbi.dwCursorPosition;
/* Convert the row and column specifications into
* buffer coordinates
*/
if (rowFrom == CUR_ROW)
rowFrom = csbi.dwCursorPosition.Y;
else if (rowFrom == TOP_EDGE)
rowFrom = csbi.srWindow.Top;
else
rowFrom += csbi.srWindow.Top -1;
if (colFrom == CUR_COL)
colFrom = csbi.dwCursorPosition.X;
else if (colFrom == LEFT_EDGE)
colFrom = 0;
else
colFrom -= 1;
if (rowTo == CUR_ROW)
rowTo = csbi.dwCursorPosition.Y;
else if (rowTo == BOTTOM_EDGE)
rowTo = csbi.srWindow.Bottom;
else
rowTo += csbi.srWindow.Top-1;
if (colTo == CUR_COL)
colTo = csbi.dwCursorPosition.X;
else if (colTo == RIGHT_EDGE)
colTo = csbi.dwSize.X;
else
colTo -= 1;
/* We're going to erase by filling a continuous range of
* character cells with spaces. Note that this has displeasing
* asthetics under NT, as highlighting appears to be immune.
*/
nLength = (rowTo - rowFrom)*csbi.dwSize.X;
nLength += colTo - colFrom;
dest.X = colFrom;
dest.Y = rowFrom;
FillConsoleOutputCharacter(hConOut, ' ', nLength, dest, &dwWritten);
FillConsoleOutputAttribute(hConOut, csbi.wAttributes, nLength, dest, &dwWritten);
SetConsoleCursorPosition(hConOut, saveCursor);
return(0);
}
/* beDeleteText -
*
* Given a screen cursor 'from' and 'to' position, this function
* will delete all text between the two. Text will be scrolled
* up as appropriate to fill the deleted space. Note that, as in
* beEraseText, the two coordinates don't specify a rectangle, but
* rather a starting position and ending position. In other words,
* deleting from (1,1) to (2,2) should move the text from (2,3) to the
* end of the second row to (1,1), move line 3 up to line 2, and so on.
*
* This function must be able to process TOP_EDGE, BOTTOM_EDGE, LEFT_EDGE,
* RIGHT_EDGE, CUR_ROW, and CUR_COL specifications in the appropriate
* variables as well as regular row and column specifications.
*/
int
beDeleteText(
int rowFrom,
int colFrom,
int rowTo,
int colTo
)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
COORD dest, saveCursor;
CHAR_INFO fillChar;
GetConsoleScreenBufferInfo(hConOut, &csbi);
saveCursor = csbi.dwCursorPosition;
if (rowFrom == CUR_ROW)
rowFrom = csbi.dwCursorPosition.Y;
else if (rowFrom == TOP_EDGE)
rowFrom = csbi.srWindow.Top;
else
rowFrom += csbi.srWindow.Top -1;
if (colFrom == CUR_COL)
colFrom = csbi.dwCursorPosition.X;
else if (colFrom == LEFT_EDGE)
colFrom = 0;
else
colFrom -= 1;
if (rowTo == CUR_ROW)
rowTo = csbi.dwCursorPosition.Y;
else if (rowTo == BOTTOM_EDGE)
rowTo = csbi.srWindow.Bottom;
else
rowTo += csbi.srWindow.Top-1;
if (colTo == CUR_COL)
colTo = csbi.dwCursorPosition.X;
else if (colTo == RIGHT_EDGE)
colTo = csbi.dwSize.X;
else
colTo -= 1;
fillChar.Char.AsciiChar=' ';
fillChar.Attributes = csbi.wAttributes;
/* Now that we've got the from and to positions
* set correctly, we need to delete appropriate
* rows and columns.
*/
dest.X = colFrom;
dest.Y = rowFrom;
/* BUGBUG - need to implement this. What can I say, I'm lazy :) */
return(0);
}
/* beInsertRow -
*
* Given a row number or CUR_ROW, TOP_EDGE or BOTTOM_EDGE as an input,
* this function will scroll all text from the current row down down by one,
* and create a blank row under the cursor.
*/
int
beInsertRow(
int row
)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
COORD dest;
CHAR_INFO fillChar;
SMALL_RECT scrollRect;
GetConsoleScreenBufferInfo(hConOut, &csbi);
fillChar.Char.AsciiChar=' ';
fillChar.Attributes = csbi.wAttributes;
if (row == CUR_ROW)
row = csbi.dwCursorPosition.Y;
else if (row == TOP_EDGE)
row = csbi.srWindow.Top;
else if (row == BOTTOM_EDGE)
row = csbi.srWindow.Bottom;
else
row += csbi.srWindow.Top-1;
dest.X = 0;
dest.Y = row+1;
scrollRect.Top = row;
scrollRect.Left = 0;
scrollRect.Right = csbi.dwSize.X;
scrollRect.Bottom = csbi.srWindow.Bottom;
ScrollConsoleScreenBuffer(hConOut, &scrollRect, NULL, dest, &fillChar);
return(0);
}
/* beTransmitText -
*
* Given a pointer to text and byte count, this routine should transmit data
* to whatever host made the request it's responding to. Typically this routin
* should transmit data as though the user had typed it in.
*/
int
beTransmitText(
char *text,
int len
)
{
if ((text == NULL) || (len < 1))
return(0);
/* BUGBUG - need to implement this. */
return(0);
}
/* beAdvanceToTab -
*
* This routine will destructively advance the cursor to the
* next set tab, or to the end of the line if there are no
* more tabs to the right of the cursor.
*/
int
beAdvanceToTab(void)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
int i, col, tocol;
COORD dest;
DWORD dwWritten;
GetConsoleScreenBufferInfo(hConOut,&csbi);
col = csbi.dwCursorPosition.X+1;
dest = csbi.dwCursorPosition;
for(i=0; i<numTabs; i++)
{
if (col < tabSet[i])
{
tocol = tabSet[i];
break;
}
}
if (i == numTabs)
{
tocol = csbi.dwSize.X;
}
FillConsoleOutputCharacter(hConOut, ' ', tocol-col,
dest, &dwWritten);
beOffsetCursor(0,tocol-col);
return(0);
}
/* beClearTab -
*
* This function accepts a constant, and will try to clear tabs
* appropriately. Its argument is either
* ALL_TABS, meaning all tabs should be removed
* CUR_COL, meaning the tab in the current column should be wiped, or
* a column value, meaning if there's a tab there it should be wiped.
*
*/
int
beClearTab(
int col
)
{
int i, j;
CONSOLE_SCREEN_BUFFER_INFO csbi;
if (col == ALL_TABS)
{
tabSet[0] = 0;
numTabs = 0;
return(0);
}
if (col == CUR_COL)
{
GetConsoleScreenBufferInfo(hConOut,&csbi);
col = csbi.dwCursorPosition.X+1;
}
for (i=0; i<numTabs; i++)
{
if (tabSet[i] == col)
{
numTabs -= 1;
for (j=i; j<numTabs; j++)
tabSet[j]=tabSet[j+1];
break;
}
}
return(0);
}
/* beSetScrollingRows -
*
* Given a pair of row numbers, this routine will set the scrolling
* rows to those values. Note that this routine will accept
* TOP_ROW and BOTTOM_ROW as values, meaning that scrolling should
* be enabled for the entire display, regardless of resizing.
*/
int
beSetScrollingRows(
int fromRow,
int toRow
)
{
if (fromRow > toRow)
return(-1);
topScrollRow = fromRow;
bottomScrollRow = toRow;
return(0);
}
/* beRingBell -
*
* Ring the system bell once.
*/
int
beRingBell(void)
{
MessageBeep((UINT)-1);
return(0);
}
/* beGetTermMode -
*
* Return the value of conTermMode, which is the terminal settings which
* can be queried/set by <esc>[?#h/l.
*/
int
beGetTermMode()
{
return(conTermMode);
}
/* beSetTermMode -
*
* Set the terminal as requested, assuming we can. Right now we only handle a
* couple of the possible flags, but we store many of the others.
*/
int beSetTermMode(
int newMode
)
{
int i, changes;
CONSOLE_SCREEN_BUFFER_INFO csbi;
COORD newSize;
SMALL_RECT newWindowRect;
DWORD dwConMode;
changes = conTermMode ^ newMode;
/* For each bit set in 'changes', determine the
* appropriate course of action.
*/
for (i=0; i < NUM_TERM_ATTR_MODES; i++)
{
if (termAttrMode[i] & changes)
{
switch(termAttrMode[i])
{
case COL132_MODE:
GetConsoleScreenBufferInfo(hConOut, &csbi);
newSize.Y = csbi.dwSize.Y;
newSize.X = (newMode & COL132_MODE) ? 132 : 80;
if (newSize.X != csbi.dwSize.X)
{
newWindowRect.Top = csbi.srWindow.Top;
newWindowRect.Bottom = csbi.srWindow.Bottom;
newWindowRect.Left = 0;
newWindowRect.Right = csbi.dwSize.X - 1;
SetConsoleScreenBufferSize(hConOut, newSize);
SetConsoleWindowInfo(hConOut, TRUE, &newWindowRect);
}
break;
case WRAP_MODE:
GetConsoleMode(hConOut,&dwConMode);
if ( (newMode & WRAP_MODE)
&& (! (dwConMode & ENABLE_WRAP_AT_EOL_OUTPUT))
)
{
dwConMode |= ENABLE_WRAP_AT_EOL_OUTPUT;
SetConsoleMode(hConOut, dwConMode);
}
if ( (!(newMode & WRAP_MODE))
&& (dwConMode & ENABLE_WRAP_AT_EOL_OUTPUT)
)
{
dwConMode &= ~ENABLE_WRAP_AT_EOL_OUTPUT;
SetConsoleMode(hConOut, dwConMode);
}
break;
case CURSORAPPL_MODE:
case ANSI_MODE:
case SMOOTHSCROLL_MODE:
case REVSCREEN_MODE:
case ORIGINREL_MODE:
case REPEAT_MODE:
/* bugbug - we don't handle any of these. */
break;
}
}
}
conTermMode = newMode;
return(0);
}
Reference in a new issue View git blame Copy permalink