int Gettext(int left, int top, int right, int bottom, void *destin)
{
int ValueReturn, x, y ;
HANDLE hScreen = GetStdHandle(STD_OUTPUT_HANDLE) ;
COORD dwBufferSize={right-left+1, bottom-top+1} ;
COORD dwBufferCoord={0,0} ;
CHAR_INFO Buffer[dwBufferSize.Y][dwBufferSize.X] ;
SMALL_RECT ReadRegion[2] ;
ReadRegion[0].Left = left-1 ;
ReadRegion[0].Right = right-1 ;
ReadRegion[0].Top = top-1 ;
ReadRegion[0].Bottom = bottom-1 ;
ValueReturn=ReadConsoleOutput(hScreen, (CHAR_INFO*) Buffer, dwBufferSize,
dwBufferCoord, ReadRegion) ;
for (x=0 ; x<dwBufferSize.X ; x++)
{
for (y=0 ; y<dwBufferSize.Y ; y++)
{
*((char*)destin+(2*(dwBufferSize.X*y+x)))=Buffer[y][x].Char.AsciiChar ;
*((char*)destin+(2*(dwBufferSize.X*y+x)+1))=Buffer[y][x].Attributes ;
}
}
return ValueReturn ;
}
JNIEXPORT jobjectArray JNICALL Java_com_yifanlu_Josh_Josh_READCONSOLEOUTPUT
(JNIEnv *env, jclass jcls, jlong pointer, jint sizeX, jint sizeY, jint coordX, jint coordY, jint readLeft, jint readTop, jint readRight, jint readBottom)
{
HANDLE hConsole = pointerToHandle(pointer);
CHAR_INFO *chiBuffer = new CHAR_INFO[sizeX * sizeY];
COORD coordBufSize;
COORD coordBufCoord;
SMALL_RECT srctReadRect;
srctReadRect.Top = readTop;
srctReadRect.Left = readLeft;
srctReadRect.Bottom = readBottom;
srctReadRect.Right = readRight;
coordBufSize.Y = sizeY;
coordBufSize.X = sizeX;
coordBufCoord.X = coordX;
coordBufCoord.Y = coordY;
ReadConsoleOutput(hConsole, chiBuffer, coordBufSize, coordBufCoord, &srctReadRect);
jintArray blank = env->NewIntArray(2);
jobjectArray jConsoleOutput = env->NewObjectArray(sizeX*sizeY, env->GetObjectClass(blank), blank);
for(int x=0; x<(sizeX*sizeY); x++)
{
jintArray info = env->NewIntArray(2);
int cInfo[2] = {(int)chiBuffer[x].Char.UnicodeChar, chiBuffer[x].Attributes};
env->SetIntArrayRegion(info, 0, 2, (jint *)cInfo);
env->SetObjectArrayElement(jConsoleOutput,x,info);
}
return jConsoleOutput;
}
void
_conio_gettext (int left, int top, int right, int bottom,
struct char_info * buf)
{
int i, j, n;
SMALL_RECT r;
CHAR_INFO* buffer;
COORD size;
__fill_text_info();
r = (SMALL_RECT) {__CONIO_LEFT + left - 1, __CONIO_TOP + top - 1,
__CONIO_LEFT + right - 1, __CONIO_TOP + bottom - 1};
size.X = right - left + 1;
size.Y = bottom - top + 1;
buffer = malloc (size.X * size.Y * sizeof(CHAR_INFO));
ReadConsoleOutput (GetStdHandle (STD_OUTPUT_HANDLE),
(PCHAR_INFO) buffer, size, (COORD) {0, 0}, &r);
for (i = n = 0; i < size.Y; i++)
for (j = 0; j < size.X; j++)
{
#ifdef UNICODE
buf[n].letter = buffer[__CALC_POS(i, j)].Char.UnicodeChar;
#else
buf[n].letter = buffer[__CALC_POS(i, j)].Char.AsciiChar;
#endif
buf[n].attr = buffer[__CALC_POS(i, j)].Attributes;
n++;
}
free (buffer);
}
void insline()
{
int y=wherey() ;
HANDLE hScreen = GetStdHandle(STD_OUTPUT_HANDLE) ;
CONSOLE_SCREEN_BUFFER_INFO Info ;
GetConsoleScreenBufferInfo(hScreen, &Info) ;
{
COORD dwBufferSize={Info.dwSize.X, Info.dwSize.Y - y} ;
COORD dwBufferCoord={0,0} ;
COORD coord={0, y-1} ; // pour FillConsoleOutputCharacter
CHAR_INFO Buffer[dwBufferSize.Y][dwBufferSize.X] ;
DWORD dwWritten;
SMALL_RECT ReadRegion[2] ;
ReadRegion[0].Left = 0 ;
ReadRegion[0].Right = Info.dwSize.X-1 ;
ReadRegion[0].Top = y-1 ;
ReadRegion[0].Bottom = Info.dwSize.Y-2 ;
ReadConsoleOutput(hScreen, (CHAR_INFO*)Buffer, dwBufferSize, dwBufferCoord, ReadRegion) ;
ReadRegion[0].Top = y ;
ReadRegion[0].Bottom = Info.dwSize.Y-1 ;
WriteConsoleOutput(hScreen, (CHAR_INFO*)Buffer, dwBufferSize, dwBufferCoord, ReadRegion) ;
FillConsoleOutputCharacter (hScreen, ' ', Info.dwSize.X, coord, &dwWritten); // Effacer ligne
FillConsoleOutputAttribute (hScreen, Info.wAttributes, Info.dwSize.X, coord, &dwWritten);
}
}
bool CheckScrollEnabled(const SMALL_RECT& rcFar)
{
bool bScrollExists = false;
#if 0
GUID FarGuid = {};
PluginSettings fs(FarGuid, psi.SettingsControl);
bScrollExists = fs.Get(FSSF_EDITOR, L"ShowScrollBar", false);
if (bScrollExists)
return true;
#endif
// Нет способа проверить через API, включена ли прокрутка в конкретном экземпляре редактора
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_SCREEN_BUFFER_INFO csbi = {};
GetConsoleScreenBufferInfo(hOut, &csbi);
CHAR_INFO ch[2]; COORD crSize = {1,2}; COORD crRead = {0,0};
int iTop = 1; // csbi.dwSize.Y - rcFar.Bottom;
SMALL_RECT srRegion = {rcFar.Right, rcFar.Top+iTop, rcFar.Right, rcFar.Top+1+iTop};
if (ReadConsoleOutput(hOut, ch, crSize, crRead, &srRegion))
{
if ((ch[0].Char.UnicodeChar == L'▲')
&& ((ch[1].Char.UnicodeChar == L'▓') || (ch[1].Char.UnicodeChar == L'░')))
{
bScrollExists = true;
}
}
return bScrollExists;
}
static VALUE rb_ReadConsoleOutput( VALUE self, VALUE hConsoleOutput,
VALUE buffer, VALUE srcwid, VALUE srcht,
VALUE startx, VALUE starty,
VALUE l, VALUE t, VALUE r, VALUE b )
{
VALUE ret = rb_ary_new();
COORD coords;
COORD size;
SMALL_RECT from;
HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );
size.X= NUM2UINT( srcwid );
size.Y= NUM2UINT( srcht );
coords.X= NUM2INT( startx );
coords.Y= NUM2INT( starty );
from.Left = NUM2INT( l );
from.Top = NUM2INT( t );
from.Right = NUM2INT( r );
from.Bottom = NUM2INT( b );
Check_Type( buffer, T_STRING );
if ( (unsigned long)RSTRING_LEN(buffer) < (sizeof(CHAR_INFO)*size.X*size.Y) )
rb_raise(rb_eArgError, "string buffer is too small for reading that many characters.");
if (!ReadConsoleOutput(handle,(CHAR_INFO *)RSTRING_PTR(buffer),size,coords,&from))
return rb_getWin32Error();
rb_ary_push( ret, INT2FIX(from.Left) );
rb_ary_push( ret, INT2FIX(from.Top) );
rb_ary_push( ret, INT2FIX(from.Right) );
rb_ary_push( ret, INT2FIX(from.Bottom) );
return ret;
}
virtual bool ReadOutput(matrix<FAR_CHAR_INFO>& Buffer, COORD BufferCoord, SMALL_RECT& ReadRegion) const override
{
bool Result=false;
int Delta=Global->Opt->WindowMode?GetDelta():0;
ReadRegion.Top+=Delta;
ReadRegion.Bottom+=Delta;
COORD BufferSize = { static_cast<SHORT>(Buffer.width()), static_cast<SHORT>(Buffer.height()) };
// skip unused region
const size_t Offset = BufferCoord.Y * BufferSize.X;
matrix<CHAR_INFO> ConsoleBuffer(BufferSize.Y - BufferCoord.Y, BufferSize.X);
BufferSize.Y-=BufferCoord.Y;
BufferCoord.Y=0;
if(BufferSize.X*BufferSize.Y*sizeof(CHAR_INFO)>MAXSIZE)
{
auto SavedY = BufferSize.Y;
BufferSize.Y = std::max(static_cast<int>(MAXSIZE/(BufferSize.X*sizeof(CHAR_INFO))),1);
size_t Height = ReadRegion.Bottom - ReadRegion.Top + 1;
int Start=ReadRegion.Top;
SMALL_RECT SavedReadRegion=ReadRegion;
for(size_t i = 0; i < Height; i += BufferSize.Y)
{
ReadRegion=SavedReadRegion;
ReadRegion.Top = static_cast<SHORT>(Start+i);
Result = ReadConsoleOutput(GetOutputHandle(), ConsoleBuffer[i].data(), BufferSize, BufferCoord, &ReadRegion) != FALSE;
}
BufferSize.Y = SavedY;
}
else
{
Result=ReadConsoleOutput(GetOutputHandle(), ConsoleBuffer.data(), BufferSize, BufferCoord, &ReadRegion)!=FALSE;
}
auto& ConsoleBufferVector = ConsoleBuffer.vector();
std::transform(ConsoleBufferVector.cbegin(), ConsoleBufferVector.cend(), Buffer.data() + Offset, [](CONST_REFERENCE(ConsoleBufferVector) i)
{
return FAR_CHAR_INFO::make(i.Char.UnicodeChar, colors::ConsoleColorToFarColor(i.Attributes));
});
void
console_widget_NT_t::update()
{
SMALL_RECT r = region;
COORD c = { 0, 0 };
if (!ReadConsoleOutput(buffer, screen, size, c, &r))
co_debug("ReadConsoleOutput() error %d \n", GetLastError());
co_console_cell_t *cell = console->screen;
CHAR_INFO *ci = screen;
int count = size.X * size.Y;
do {
cell->attr = ci->Attributes;
(cell++)->ch = (ci++)->Char.AsciiChar;
} while (--count);
}
void QConsolePrivate::grabConsoleBuffer (CHAR_INFO* buf)
{
COORD bs, bc;
SMALL_RECT r;
bs.X = m_consoleRect.width ();
bs.Y = m_consoleRect.height ();
bc.X = 0;
bc.Y = 0;
r.Left = m_consoleRect.left ();
r.Top = m_consoleRect.top ();
r.Right = m_consoleRect.right ();
r.Bottom = m_consoleRect.bottom ();
if (! ReadConsoleOutput (m_stdOut, (buf ? buf : m_buffer), bs, bc, &r))
qCritical ("cannot read console output");
}
EXTERNC
int gettext(int left, int top, int right, int bottom, void *dest) {
SMALL_RECT trg;
COORD pos, size;
CHAR_INFO *buf;
buf = (CHAR_INFO *)alloca((right - left + 1) * (bottom - top + 1) * sizeof(CHAR_INFO));
pos.X = 0; pos.Y = 0;
size.X = right - left + 1; size.Y = bottom - top + 1;
trg.Left = left - 1; trg.Top = top - 1;
trg.Right = right - 1; trg.Bottom = bottom - 1;
ReadConsoleOutput(buf, buf, size, pos, &trg);
for (int i = 0; i < (right - left + 1) * (bottom - top + 1); i++) {
((char *)dest)[i * 2] = buf[i].Char.AsciiChar;
((char *)dest)[i * 2 + 1] = FromWinAttribs(buf[i].Attributes);
};
// TODO: check return values
return 1;
};
void putASCII( int x, int y, int ch, int color )
{
if ( touched == 0) {
hOutput = (HANDLE)GetStdHandle( STD_OUTPUT_HANDLE );
ReadConsoleOutput( hOutput, (CHAR_INFO *)screen_buffer, dwBufferSize,
dwBufferCoord, &rcRegion );
touched = 1;
}
if (x<SCREEN_WIDTH && x>=0 && y<SCREEN_HEIGHT && y>=0) {
screen_buffer[y][x].Char.AsciiChar = ch;
if (color == 1)
screen_buffer[y][x].Attributes = COLOR_GREEN;
else if (color == 2)
screen_buffer[y][x].Attributes = COLOR_BLUE;
else if (color == 3)
screen_buffer[y][x].Attributes = COLOR_YELLOW;
else
screen_buffer[y][x].Attributes = COLOR_MAGENTA;
}
}
void screen_dump(char *filepath) {
FILE *fp;
int i, j, k;
SHORT currlineno;
SMALL_RECT r;
CHAR_INFO buffer[80 * 1000];
COORD dwBufferSize, dwBufferCoord;
GetConsoleScreenBufferInfo(hConsoleOutput, &coninfo);
currlineno = coninfo.dwCursorPosition.Y;
r = (SMALL_RECT) {0, tmplineno, 80, currlineno};
dwBufferSize = (COORD) {80, currlineno - tmplineno};
dwBufferCoord = (COORD) {0, 0};
ReadConsoleOutput (
hConsoleOutput,
(PCHAR_INFO) buffer,
dwBufferSize,
dwBufferCoord,
&r
);
fp = fopen(filepath,"w");
for (i = 0; i < (currlineno - tmplineno); i++) {
k = -1;
for (j = 0; j <= r.Right; j++) {
if (buffer[i*r.Right+j+i].Char.AsciiChar != ' ') {
k = j;
}
}
if (k > -1) {
for (j = 0; j <= k; j++) {
fprintf(fp, "%c", buffer[i*r.Right+j+i].Char.AsciiChar);
}
}
fprintf(fp, "\n");
}
fclose(fp);
}
int movetext(int left, int top, int right, int bottom, int destleft, int desttop)
{
int ValueReturn, x, y ;
HANDLE hScreen = GetStdHandle(STD_OUTPUT_HANDLE) ;
COORD dwBufferSize={right-left+1, bottom-top+1} ;
COORD dwBufferCoord={0,0} ;
CHAR_INFO Buffer[dwBufferSize.Y][dwBufferSize.X] ;
SMALL_RECT ReadRegion[2] ;
ReadRegion[0].Left = left-1 ;
ReadRegion[0].Right = right-1 ;
ReadRegion[0].Top = top-1 ;
ReadRegion[0].Bottom = bottom-1 ;
ReadConsoleOutput(hScreen, (CHAR_INFO*) Buffer, dwBufferSize, dwBufferCoord,
ReadRegion) ;
ReadRegion[0].Left = destleft-1 ;
ReadRegion[0].Right = destleft-1+(dwBufferSize.X-1) ;
ReadRegion[0].Top = desttop-1 ;
ReadRegion[0].Bottom = desttop-1+(dwBufferSize.Y-1) ;
return WriteConsoleOutput(hScreen, (CHAR_INFO*) Buffer, dwBufferSize,
dwBufferCoord, ReadRegion) ;
}
void delline()
{
int y=wherey() ;
HANDLE hScreen = GetStdHandle(STD_OUTPUT_HANDLE) ;
CONSOLE_SCREEN_BUFFER_INFO Info ;
GetConsoleScreenBufferInfo(hScreen, &Info) ;
{
COORD dwBufferSize={Info.dwSize.X, Info.dwSize.Y - y} ;
COORD dwBufferCoord={0, 0} ;
CHAR_INFO Buffer[dwBufferSize.Y][dwBufferSize.X] ;
SMALL_RECT ReadRegion[2] ;
ReadRegion[0].Left = 0 ;
ReadRegion[0].Right = Info.dwSize.X-1 ;
ReadRegion[0].Top = y ;
ReadRegion[0].Bottom = Info.dwSize.Y-1 ;
ReadConsoleOutput(hScreen, (CHAR_INFO*)Buffer, dwBufferSize,
dwBufferCoord, ReadRegion) ;
ReadRegion[0].Top = y-1 ;
ReadRegion[0].Bottom = Info.dwSize.Y-2 ;
WriteConsoleOutput(hScreen, (CHAR_INFO*)Buffer, dwBufferSize,
dwBufferCoord, ReadRegion) ;
}
}
/*========================================================================/
* Function - dtioMenu
* Description:
*
* Arguements:
*
* Return :
*=======================================================================*/
int dtioMenu(const char *s[], int count, int row, int column, const char *box) {
int a, i, j = 0, exit = 0; /* loop and help flags */
char defMenu[] = {'+', '-', '+', '|', '+', '-', '+', '|'}; /* default menux box */
int maxLen; /* max length of string */
/* helpers for building menu */
int cRow = row + 1, cCol = column + 1; /* current cursor position in box menu */
int cRow_Home = row + 1; /* top cursor position in box menu */
int buildRow = row; /* top cursor position */
int cursorMove; /* user current cursor */
/* settings for reading and writing console oututs */
int depth = dtioRows();
int width = dtioColumns();
int x1,y1,x2,y2;
#if PLATFORM == VSNET2K3
SMALL_RECT screenRec;
CHAR_INFO* dimension;
COORD dimensionSize;
COORD dimensionOrigin;
#elif PLATFORM == BCC32
void *buffer = NULL;
#elif PLATFORM == GCC || PLATFORM == AIXC
chtype* screen;
#endif
/* find longest character in string s array */
for (i = 0; i < (count - 1); i++) {
if ( strlen(s[i]) > strlen(s[i + 1]) ) {
maxLen = strlen(s[i]);
}
}
/**********************************************************************/
/* remember console screen */
/**********************************************************************/
#if PLATFORM == BCC32
x1 = row + 1;
y1 = column + 1;
x2 = row + maxLen + 4;
y2 = column + count + 3;
buffer = (void *) malloc(depth * width * 3);
gettext(x1, y1, x2, y2, buffer);
#elif PLATFORM == VSNET2K3
dimension = (CHAR_INFO *) malloc(sizeof(CHAR_INFO) * depth * width);
screenRec.Top = row;
screenRec.Left = column;
screenRec.Bottom = row + depth;
screenRec.Right = column + width;
dimensionSize.Y = depth;
dimensionSize.X = width;
dimensionOrigin.Y = row;
dimensionOrigin.X = column;
std_out = GetStdHandle(STD_OUTPUT_HANDLE);
ReadConsoleOutput(std_out, dimension, dimensionSize, dimensionOrigin, &screenRec);
#else
x1 = y1 = 0;
i = 0;
screen = (chtype *) malloc(sizeof(chtype) * depth * width); /* chtype screen */
for (x1 = 0; x1 < depth; x1++) {
for (y1 = 0; y1 < width; y1++)
screen[i++] = mvinch(x1,y1);
}
#endif
/******************************************************************/
/* Construct Menu */
/******************************************************************/
/************************ Print Top Border ************************/
dtioCursor(buildRow,column);
dtioPutchar(box[j++]);
for (i = 0; i <= maxLen; i++)
dtioPutchar(box[j]);
j++;
dtioPutchar(box[j++]);
dtioCursor(++buildRow,column);
/*********************** Print Menu *******************************/
for (i = 0; i < count; i++) {
dtioPutchar((int)box[j]);
dtioPutchar(KEY_SPACE);
dtioPuts(s[i]);
if (strlen(s[i]) < maxLen) {
for (a = 1; a < (maxLen - strlen(s[i])) + 1; a++)
dtioPutchar(KEY_SPACE);
}
dtioPutchar(box[8 - 1]);
dtioCursor(++buildRow,column);
}
j++;
/******************* Print Bottom Border **************************/
dtioPutchar(box[j++]);
for (i = 0; i <= maxLen; i++)
dtioPutchar(box[j]);
j++;
dtioPutchar(box[j]);
dtioCursor(column + 1,buildRow + 1);
/******************* Menu Functionality **************************/
dtioCursor(cRow,cCol);
dtioPutchar(KEY_RIGHT_ARROW);
dtioCursor(cRow,cCol);
do {
cursorMove = dtioGetchar();
if ((cRow - 1) > row && cursorMove == UP) {
dtioPutchar(KEY_SPACE);
if (!(s[ (cRow - cRow_Home) - 1 ][0])) {
do {
--cRow;
} while(!(s[ (cRow - cRow_Home) ][0]));
} else
--cRow;
dtioCursor(cRow,cCol);
dtioPutchar(KEY_RIGHT_ARROW);
dtioCursor(cRow,cCol);
} else if ((cRow + 1) < (cRow_Home + count) && cursorMove == DOWN) {
dtioPutchar(KEY_SPACE);
if (!(s[ (cRow - cRow_Home) + 1 ][0])) {
do {
++cRow;
} while(!(s[ (cRow - cRow_Home) ][0]));
} else
++cRow;
dtioCursor(cRow,cCol);
dtioPutchar(KEY_RIGHT_ARROW);
dtioCursor(cRow,cCol);
} else if (cursorMove == ENTER || cursorMove == ESCAPE) {
/************************************************************/
/* write console screen */
/************************************************************/
#if PLATFORM == BCC32
puttext(x1, y1, x2, y2, buffer);
free(buffer);
#elif PLATFORM == VSNET2K3
WriteConsoleOutput(std_out, dimension, dimensionSize, dimensionOrigin, &screenRec);
free(dimension);
#else
i = 0;
for (x1 = 0; x1 < depth; x1++)
for (y1 = 0; y1 < width; y1++) {
move(x1,y1);
addch(screen[i++]);
}
free(screen);
#endif
exit = 1;
if (cursorMove == ESCAPE)
cRow = -1;
}
} while (!exit);
return (cursorMove != ESCAPE) ? (cRow - row) : cRow;
}
int main(void)
{
HANDLE hStdout, hNewScreenBuffer;
SMALL_RECT srctReadRect;
SMALL_RECT srctWriteRect;
CHAR_INFO chiBuffer[160]; // [2][80];
COORD coordBufSize;
COORD coordBufCoord;
BOOL fSuccess;
// Get a handle to the STDOUT screen buffer to copy from and
// create a new screen buffer to copy to.
hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
hNewScreenBuffer = CreateConsoleScreenBuffer(
GENERIC_READ | // read/write access
GENERIC_WRITE,
0, // not shared
NULL, // default security attributes
CONSOLE_TEXTMODE_BUFFER, // must be TEXTMODE
NULL); // reserved; must be NULL
if (hStdout == INVALID_HANDLE_VALUE ||
hNewScreenBuffer == INVALID_HANDLE_VALUE)
{
printf("CreateConsoleScreenBuffer (%d)\n", GetLastError());
return;
}
// Make the new screen buffer the active screen buffer.
cputs("******test********\n");
getch();
if (! SetConsoleActiveScreenBuffer(hNewScreenBuffer) )
{
printf("SetConsoleActiveScreenBuffer (%d)\n", GetLastError());
return;
}
// Set the source rectangle.
srctReadRect.Top = 0; // top left: row 0, col 0
srctReadRect.Left = 0;
srctReadRect.Bottom = 1; // bot. right: row 1, col 79
srctReadRect.Right = 60;
// The temporary buffer size is 2 rows x 80 columns.
coordBufSize.Y = 2;
coordBufSize.X = 60;
// The top left destination cell of the temporary buffer is
// row 0, col 0.
coordBufCoord.X = 0;
coordBufCoord.Y = 0;
// Copy the block from the screen buffer to the temp. buffer.
fSuccess = ReadConsoleOutput(
hStdout, // screen buffer to read from
chiBuffer, // buffer to copy into
coordBufSize, // col-row size of chiBuffer
coordBufCoord, // top left dest. cell in chiBuffer
&srctReadRect); // screen buffer source rectangle
if (! fSuccess)
{
printf("ReadConsoleOutput (%d)\n", GetLastError());
return;
}
// Set the destination rectangle.
srctWriteRect.Top = 10; // top lt: row 10, col 0
srctWriteRect.Left = 0;
srctWriteRect.Bottom = 11; // bot. rt: row 11, col 79
srctWriteRect.Right = 60;
// Copy from the temporary buffer to the new screen buffer.
getchar();
fSuccess = WriteConsoleOutput(
hNewScreenBuffer, // screen buffer to write to
chiBuffer, // buffer to copy from
coordBufSize, // col-row size of chiBuffer
coordBufCoord, // top left src cell in chiBuffer
&srctWriteRect); // dest. screen buffer rectangle
if (! fSuccess)
{
printf("WriteConsoleOutput (%d)\n", GetLastError());
return;
}
Sleep(10000);
// getchar();
// Restore the original active screen buffer.
if (! SetConsoleActiveScreenBuffer(hStdout))
{
printf("SetConsoleActiveScreenBuffer (%d)\n", GetLastError());
return;
}
return 0;
}
void OutputManager::read()
{
ReadConsoleOutput(hOutput, (CHAR_INFO *)buffer, dwBufferSize,
dwBufferCoord, &rcRegion);
}
/* ************************************
* VOID UseBlockIO()
* 功能 使用Block IO
**************************************/
VOID UseBlockIO()
{
HANDLE hStdout, hNewScreenBuffer;
SMALL_RECT srctReadRect;
SMALL_RECT srctWriteRect;
CHAR_INFO chiBuffer[160]; // [2][80];
COORD coordBufSize;
COORD coordBufCoord;
BOOL fSuccess;
// 获得句柄
hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
// 新建buffer
hNewScreenBuffer = CreateConsoleScreenBuffer(
GENERIC_READ | GENERIC_WRITE,// 可读可写
0, // 不共享
NULL, // 默认安全属性
CONSOLE_TEXTMODE_BUFFER, // must be TEXTMODE
NULL);
if (hStdout == INVALID_HANDLE_VALUE ||
hNewScreenBuffer == INVALID_HANDLE_VALUE)
{
printf("CreateConsoleScreenBuffer (%d)\n", GetLastError());
return;
}
// 设置屏幕的Buffer
if (! SetConsoleActiveScreenBuffer(hNewScreenBuffer) )
{
printf("SetConsoleActiveScreenBuffer (%d)\n", GetLastError());
return;
}
// 设置源Cell矩阵
srctReadRect.Top = 0; // top left: row 0, col 0
srctReadRect.Left = 0;
srctReadRect.Bottom = 1; // bot. right: row 1, col 79
srctReadRect.Right = 79;
// 临时buffer大小 2 rows x 80 columns.
coordBufSize.Y = 2;
coordBufSize.X = 80;
// 临时buffer的起始位置
coordBufCoord.X = 0;
coordBufCoord.Y = 0;
// 从屏幕buffer复制内容到临时buffer
fSuccess = ReadConsoleOutput(
hStdout, // 源
chiBuffer, // 目的
coordBufSize, // 目的buffer大小
coordBufCoord, // 目的起始位置
&srctReadRect); // 源起始位置
if (! fSuccess)
{
printf("ReadConsoleOutput (%d)\n", GetLastError());
return;
}
// 设置目的Cells矩阵
srctWriteRect.Top = 10; // top lt: row 10, col 0
srctWriteRect.Left = 0;
srctWriteRect.Bottom = 11; // bot. rt: row 11, col 79
srctWriteRect.Right = 79;
// 从临时buffer向新的屏幕buffer复制
fSuccess = WriteConsoleOutput(
hNewScreenBuffer,
chiBuffer,
coordBufSize,
coordBufCoord,
&srctWriteRect);
if (! fSuccess)
{
printf("WriteConsoleOutput (%d)\n", GetLastError());
return;
}
// 等等一段时间
Sleep(10000);
// 恢复
if (! SetConsoleActiveScreenBuffer(hStdout))
{
printf("SetConsoleActiveScreenBuffer (%d)\n", GetLastError());
return;
}
}
static bool ReadOutputImpl(CHAR_INFO* const Buffer, COORD const BufferSize, SMALL_RECT& ReadRegion)
{
return ReadConsoleOutput(::console.GetOutputHandle(), Buffer, BufferSize, {}, &ReadRegion) != FALSE;
}
ThinConsole::list_buffer_data ThinConsole::GetBufferData(console_buffer_type const& buffer, console_window_type& window, console_location_type const& coords) const {
assert(outputHandle != NULL && "Output Handle Not Initialized");
list_buffer_data bufferData(buffer.dwSize.X * buffer.dwSize.Y);
ExceptionCheck(ReadConsoleOutput(outputHandle, bufferData.data(), buffer.dwSize, { 0 }, &window), __FUNCTION__, __LINE__);
return std::move(bufferData);
}
