void clrscr() {
HANDLE hConsole = GetStdHandle( STD_OUTPUT_HANDLE );
COORD coordScreen = { 0, 0 };
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo( hConsole, &csbi );
DWORD dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
DWORD cCharsWritten;
FillConsoleOutputCharacter( hConsole, (TCHAR) ' ', dwConSize, coordScreen, &cCharsWritten );
GetConsoleScreenBufferInfo( hConsole, &csbi );
FillConsoleOutputAttribute( hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten );
SetConsoleCursorPosition( hConsole, coordScreen );
}
// clear the console window
void Clear(HANDLE hOut)
{
CONSOLE_SCREEN_BUFFER_INFO bufInfo;
static COORD const zero = { 0, 0 };
DWORD written;
DWORD size;
GetConsoleScreenBufferInfo(hOut, &bufInfo);
size = bufInfo.dwSize.X * bufInfo.dwSize.Y;
FillConsoleOutputCharacter(hOut, 0, size, zero, &written);
FillConsoleOutputAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE, size, zero, &written);
SetConsoleCursorPosition(hOut, zero);
}
static void clearScreen(struct current *current)
{
COORD topleft = { 0, 0 };
DWORD n;
FillConsoleOutputCharacter(current->outh, ' ',
current->cols * current->rows, topleft, &n);
FillConsoleOutputAttribute(current->outh,
FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN,
current->cols * current->rows, topleft, &n);
SetConsoleCursorPosition(current->outh, topleft);
}
bool CHaloPrintStream::Write(const std::wstring& str)// str usually has endl appended
{
if (str.size() == 0) return true;
bool ready = *(bool*)UlongToPtr(ADDR_CONSOLEREADY);
if (!ready) {
std::wcout << str;
return true;
}
// Prepare for writing the string
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
DWORD written = 0;
CONSOLE_SCREEN_BUFFER_INFO info;
SHORT oldX = 0; // used to set cursor back to old position
// Get current console position info
GetConsoleScreenBufferInfo(hConsole, &info);
oldX = info.dwCursorPosition.X;
// Set cursor to start of the last row (where we want to start writing)
info.dwCursorPosition.X = 0;
info.dwCursorPosition.Y = 299;
SetConsoleCursorPosition(hConsole, info.dwCursorPosition);
FillConsoleOutputCharacterA(hConsole, ' ', 95, info.dwCursorPosition, &written);
FillConsoleOutputAttribute(hConsole, 7, 95, info.dwCursorPosition, &written);
// Write the text
WriteConsoleW(hConsole, str.c_str(), str.size(), &written, NULL);
//WriteConsoleW(hConsole, L"\n", 1, &written, NULL);
// Get the current text in the console
LPBYTE ptr = (LPBYTE)ADDR_CONSOLEINFO;
if (*ptr != 0) {
// Build current command input
std::string formatted = "halo( ";
formatted += (char*)UlongToPtr(*(DWORD*)ptr + OFFSET_CONSOLETEXT); // current text
// Rewrite the data to console
GetConsoleScreenBufferInfo(hConsole, &info);
FillConsoleOutputCharacterA(hConsole, ' ', 95, info.dwCursorPosition, &written);
WriteConsoleOutputCharacterA(hConsole, formatted.c_str(), formatted.size(), info.dwCursorPosition, &written);
// Set the cursor to its old position
GetConsoleScreenBufferInfo(hConsole, &info);
info.dwCursorPosition.X = oldX;
SetConsoleCursorPosition(hConsole, info.dwCursorPosition);
}
return true;
}
void Console::SwitchBackgroundColour( const int colour )
{
SetBackgroundColour(colour);
// Number of cells in current buffer
int console_size = mConsoleInfo.dwSize.X * mConsoleInfo.dwSize.Y;
DWORD cCharsWritten;
COORD coordScreen = { 0, 0 };
GetConsoleScreenBufferInfo(mConsoleHandle, &mConsoleInfo);
// Set buffer attributes
FillConsoleOutputAttribute( mConsoleHandle, mConsoleInfo.wAttributes,
console_size, coordScreen, &cCharsWritten );
}
// Erases everything from the cursor position to the end
bool Console::eraseFromCursorToEnd(void)
{
cout.flush();
findCursorPos();
DWORD numCharactersWritten;
COORD consoleCoords = {xPos, yPos};
FillConsoleOutputCharacter(consoleHandle, ' ', (25 - yPos) * 80 + (80 - xPos), consoleCoords, &numCharactersWritten);
FillConsoleOutputAttribute(consoleHandle, consoleInfo.wAttributes, (25 - yPos) * 80 + (80 - xPos), consoleCoords, &numCharactersWritten);
setCursorPos(xPos, yPos);
cout.flush();
return true;
}
VOID
DrawFileSystemList(
IN PFILE_SYSTEM_LIST List)
{
PLIST_ENTRY ListEntry;
PFILE_SYSTEM_ITEM Item;
COORD coPos;
DWORD Written;
ULONG Index = 0;
CHAR Buffer[70];
ListEntry = List->ListHead.Flink;
while (ListEntry != &List->ListHead)
{
Item = CONTAINING_RECORD(ListEntry, FILE_SYSTEM_ITEM, ListEntry);
coPos.X = List->Left;
coPos.Y = List->Top + (SHORT)Index;
FillConsoleOutputAttribute(StdOutput,
FOREGROUND_WHITE | BACKGROUND_BLUE,
sizeof(Buffer),
coPos,
&Written);
FillConsoleOutputCharacterA(StdOutput,
' ',
sizeof(Buffer),
coPos,
&Written);
if (Item->FileSystemName)
{
if (Item->QuickFormat)
snprintf(Buffer, sizeof(Buffer), MUIGetString(STRING_FORMATDISK1), Item->FileSystemName);
else
snprintf(Buffer, sizeof(Buffer), MUIGetString(STRING_FORMATDISK2), Item->FileSystemName);
}
else
snprintf(Buffer, sizeof(Buffer), MUIGetString(STRING_KEEPFORMAT));
if (ListEntry == &List->Selected->ListEntry)
CONSOLE_SetInvertedTextXY(List->Left,
List->Top + (SHORT)Index,
Buffer);
else
CONSOLE_SetTextXY(List->Left,
List->Top + (SHORT)Index,
Buffer);
Index++;
ListEntry = ListEntry->Flink;
}
}
void clrscr ( void ) // efface l'écran
{
HANDLE hstdout = STDOUT;
CONSOLE_SCREEN_BUFFER_INFO csbi;
if (GetConsoleScreenBufferInfo (hstdout, &csbi))
{
COORD coordScreen = { 0, 0 };
DWORD cCharsWritten;
DWORD dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
FillConsoleOutputCharacter (hstdout, ' ', dwConSize, coordScreen, &cCharsWritten);
FillConsoleOutputAttribute (hstdout, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten);
SetConsoleCursorPosition (hstdout, coordScreen);
}
}
// Clears the entire screen
bool Console::clearScreen(void)
{
cout.flush();
setCursorPos(0, 0);
DWORD numCharactersWritten;
COORD consoleCoords = {0, 0};
GetConsoleScreenBufferInfo(consoleHandle, &consoleInfo);
FillConsoleOutputCharacter(consoleHandle, ' ', consoleInfo.dwSize.X * consoleInfo.dwSize.Y, consoleCoords, &numCharactersWritten);
FillConsoleOutputAttribute(consoleHandle, consoleInfo.wAttributes, consoleInfo.dwSize.X * consoleInfo.dwSize.Y, consoleCoords, &numCharactersWritten);
setCursorPos(0, 0);
cout.flush();
return true;
}
LVAL xsetupconsole()
{
HWND mywin;
HANDLE myhandle;
COORD winsize, origin;
WORD textattrib;
DWORD n;
mywin = GetForegroundWindow();
SetConsoleTitle("Nyquist");
myhandle = GetStdHandle(STD_OUTPUT_HANDLE);
origin.X = 0;
origin.Y = 0;
winsize.X = 100;
winsize.Y = 40;
textattrib = BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_INTENSITY;
FillConsoleOutputAttribute(myhandle, textattrib, winsize.X * winsize.Y, origin, &n);
SetConsoleScreenBufferSize(myhandle, winsize);
FillConsoleOutputAttribute(myhandle, textattrib, winsize.X * winsize.Y, origin, &n);
SetConsoleTextAttribute(myhandle, textattrib);
return NIL;
}
// Erases everything from (0,0) to the cursor position
bool Console::eraseFromStartToCursor(void)
{
cout.flush();
findCursorPos();
DWORD numCharactersWritten;
COORD consoleCoords = {0, 0};
FillConsoleOutputCharacter(consoleHandle, ' ', 80 * yPos + xPos, consoleCoords, &numCharactersWritten);
FillConsoleOutputAttribute(consoleHandle, consoleInfo.wAttributes, 80 * yPos + xPos, consoleCoords, &numCharactersWritten);
setCursorPos(xPos, yPos);
cout.flush();
return true;
}
// clear console screen
void ClearScreen() {
COORD coordScreen = { 0, 0 };
DWORD cCharsWritten;
CONSOLE_SCREEN_BUFFER_INFO csbi;
DWORD dwConSize;
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
GetConsoleScreenBufferInfo(hConsole, &csbi);
dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
FillConsoleOutputCharacter(hConsole, TEXT(' '), dwConSize, coordScreen, &cCharsWritten);
GetConsoleScreenBufferInfo(hConsole, &csbi);
FillConsoleOutputAttribute(hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten);
SetConsoleCursorPosition(hConsole, coordScreen);
}
void scroll_to_top(CONSOLE_SCREEN_BUFFER_INFO &csbi)
{
COORD topLeft = { 0, 0 };
HANDLE hConsoleOut = GetStdHandle(STD_OUTPUT_HANDLE);
DWORD written;
GetConsoleScreenBufferInfo(hConsoleOut, &csbi);
FillConsoleOutputCharacterA(hConsoleOut, ' ', csbi.dwSize.X * csbi.dwSize.Y, topLeft, &written);
FillConsoleOutputAttribute(hConsoleOut, FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE,
csbi.dwSize.X * csbi.dwSize.Y, topLeft, &written);
SetConsoleCursorPosition(hConsoleOut, topLeft);
}
static inline void WCEL_Update(WCEL_Context* ctx, int beg, int len)
{
int i, last;
DWORD count;
WCHAR tmp[2];
/* bare console case is handled in CONSOLE_ReadLine (we always reprint the whole string) */
if (!ctx->shall_echo || !ctx->can_pos_cursor) return;
for (i = last = beg; i < beg + len; i++)
{
if (ctx->line[i] < ' ')
{
if (last != i)
{
WriteConsoleOutputCharacterW(ctx->hConOut, &ctx->line[last], i - last,
WCEL_GetCoord(ctx, last), &count);
FillConsoleOutputAttribute(ctx->hConOut, ctx->csbi.wAttributes, i - last,
WCEL_GetCoord(ctx, last), &count);
}
tmp[0] = '^';
tmp[1] = '@' + ctx->line[i];
WriteConsoleOutputCharacterW(ctx->hConOut, tmp, 2,
WCEL_GetCoord(ctx, i), &count);
FillConsoleOutputAttribute(ctx->hConOut, ctx->csbi.wAttributes, 2,
WCEL_GetCoord(ctx, i), &count);
last = i + 1;
}
}
if (last != beg + len)
{
WriteConsoleOutputCharacterW(ctx->hConOut, &ctx->line[last], i - last,
WCEL_GetCoord(ctx, last), &count);
FillConsoleOutputAttribute(ctx->hConOut, ctx->csbi.wAttributes, i - last,
WCEL_GetCoord(ctx, last), &count);
}
}
void Console::cls()
{
COORD coordScreen = { 0, 0 }; // home for the cursor
DWORD cCharsWritten;
CONSOLE_SCREEN_BUFFER_INFO csbi;
DWORD dwConSize;
// Get the number of character cells in the current buffer.
if( !GetConsoleScreenBufferInfo( hConsole, &csbi ))
{
return;
}
dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
// Fill the entire screen with blanks.
if( !FillConsoleOutputCharacter( hConsole, // Handle to console screen buffer
(TCHAR) ' ', // Character to write to the buffer
dwConSize, // Number of cells to write
coordScreen, // Coordinates of first cell
&cCharsWritten ))// Receive number of characters written
{
return;
}
// Get the current text attribute.
if( !GetConsoleScreenBufferInfo( hConsole, &csbi ))
{
return;
}
// Set the buffer's attributes accordingly.
if( !FillConsoleOutputAttribute( hConsole, // Handle to console screen buffer
csbi.wAttributes, // Character attributes to use
dwConSize, // Number of cells to set attribute
coordScreen, // Coordinates of first cell
&cCharsWritten )) // Receive number of characters written
{
return;
}
// Put the cursor at its home coordinates.
SetConsoleCursorPosition( hConsole, coordScreen );
}
static void
erase_at(COORD coordCursor, int length)
{
W32_CHAR blank = ' ';
DWORD written;
FillConsoleOutputCharacter(
hConsoleOutput, blank, length,
coordCursor, &written
);
FillConsoleOutputAttribute(
hConsoleOutput, currentAttribute, length,
coordCursor, &written
);
}
void Console::clear()
{
// Description: Clears the screen
COORD coordScreen = { 0, 0 };
DWORD cCharsWritten;
DWORD dwConSize;
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo(hConsole, &csbi);
dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
FillConsoleOutputCharacter(hConsole, TEXT(' '), dwConSize, coordScreen, &cCharsWritten);
GetConsoleScreenBufferInfo(hConsole, &csbi);
FillConsoleOutputAttribute(hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten);
SetConsoleCursorPosition(hConsole, coordScreen);
};
void clear_screen()
{
#ifdef _WIN32
HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
COORD c = {0, 0};
CONSOLE_SCREEN_BUFFER_INFO si;
GetConsoleScreenBufferInfo(out, &si);
DWORD n;
FillConsoleOutputCharacter(out, ' ', si.dwSize.X * si.dwSize.Y, c, &n);
FillConsoleOutputAttribute(out, 0x7, si.dwSize.X * si.dwSize.Y, c, &n);
#else
std::printf("\033[2J");
#endif
}
void MyCls(HANDLE hConsole)
{
COORD coordScreen={0,0};//设置清屏后光标返回的屏幕左上角坐标
BOOL bSuccess;
DWORD cCharsWritten;
CONSOLE_SCREEN_BUFFER_INFO csbi;//保存缓冲区信息
DWORD dwConSize;//当前缓冲区可容纳的字符数
bSuccess=GetConsoleScreenBufferInfo(hConsole,&csbi);//获得缓冲区信息
dwConSize=csbi.dwSize.X*csbi.dwSize.Y;//缓冲区容纳字符数目
bSuccess=FillConsoleOutputCharacter(hConsole,(TCHAR)' ',dwConSize,coordScreen,&cCharsWritten);
bSuccess=GetConsoleScreenBufferInfo(hConsole,&csbi);//获得缓冲区信息
bSuccess=FillConsoleOutputAttribute(hConsole,csbi.wAttributes,dwConSize,coordScreen,&cCharsWritten);
bSuccess=SetConsoleCursorPosition(hConsole,coordScreen);
return;
}
static void clear(HANDLE hConsole) {
COORD coordScreen = { 0, 0 }; // here's where we'll home the cursor
BOOL bSuccess;
DWORD cCharsWritten;
CONSOLE_SCREEN_BUFFER_INFO csbi; // to get buffer info
DWORD dwConSize; // number of character cells in the current buffer
bSuccess = GetConsoleScreenBufferInfo(hConsole, &csbi); // get the number of character cells in the current buffer
dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
bSuccess = FillConsoleOutputCharacter(hConsole, (TCHAR)' ', dwConSize, coordScreen, &cCharsWritten); // fill the entire screen with blanks
bSuccess = GetConsoleScreenBufferInfo(hConsole, &csbi); // get the current text attribute
bSuccess = FillConsoleOutputAttribute(hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten); // now set the buffer's attributes accordingly
bSuccess = SetConsoleCursorPosition(hConsole, coordScreen); // put the cursor at (0, 0)
return;
}
BOOL
WriteConsoleLine(
HANDLE OutputHandle,
WORD LineNumber,
LPSTR Text,
BOOL Highlight
)
{
COORD WriteCoord;
DWORD NumberWritten;
DWORD TextLength;
WriteCoord.X = 0;
WriteCoord.Y = LineNumber;
if (!FillConsoleOutputCharacter( OutputHandle,
' ',
NumberOfCols,
WriteCoord,
&NumberWritten
)
) {
return FALSE;
}
#if 0
if (!FillConsoleOutputAttribute( OutputHandle,
(WORD)(Highlight ? HighlightAttribute : NormalAttribute),
NumberOfCols,
WriteCoord,
&NumberWritten
)
) {
return FALSE;
}
#endif
if (Text == NULL || (TextLength = strlen( Text )) == 0) {
return TRUE;
}
else {
return WriteConsoleOutputCharacter( OutputHandle,
Text,
TextLength,
WriteCoord,
&NumberWritten
);
}
}
void clrscr(void)
{
COORD coordScreen = { 0, 0 }; // upper left corner
DWORD cCharsWritten;
DWORD dwConSize;
HANDLE hCon = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo(hCon, &csbi);
dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
// fill with spaces
FillConsoleOutputCharacter(hCon, TEXT(' '), dwConSize, coordScreen, &cCharsWritten);
GetConsoleScreenBufferInfo(hCon, &csbi);
FillConsoleOutputAttribute(hCon, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten);
// cursor to upper left corner
SetConsoleCursorPosition(hCon, coordScreen);
}
void clear_region(struct rccoord start, int num_cells) {
struct rccoord oldpos = _gettextposition();
DWORD cCharsWritten;
CONSOLE_SCREEN_BUFFER_INFO record;
GetConsoleScreenBufferInfo(STDCONSOLE, &record);
// fill with blanks
FillConsoleOutputCharacter(STDCONSOLE, ' ', num_cells, rccoord_to_COORD(start), &cCharsWritten);
// reset attributes
FillConsoleOutputAttribute(STDCONSOLE, record.wAttributes, num_cells, rccoord_to_COORD(start), &cCharsWritten);
_settextposition(oldpos.row, oldpos.col);
return;
}
static void erase_in_line(void)
{
CONSOLE_SCREEN_BUFFER_INFO sbi;
DWORD dummy; /* Needed for Windows 7 (or Vista) regression */
if (!console)
return;
GetConsoleScreenBufferInfo(console, &sbi);
FillConsoleOutputCharacterA(console, ' ',
sbi.dwSize.X - sbi.dwCursorPosition.X, sbi.dwCursorPosition,
&dummy);
FillConsoleOutputAttribute(console, plain_attr,
sbi.dwSize.X - sbi.dwCursorPosition.X, sbi.dwCursorPosition,
&dummy);
}
void clreol()
{
COORD coord = {wherex() - 1 , wherey() - 1};
DWORD dwWritten;
HANDLE hScreen=GetStdHandle(STD_OUTPUT_HANDLE) ;
CONSOLE_SCREEN_BUFFER_INFO Info;
if(GetConsoleScreenBufferInfo(hScreen, &Info))
{
FillConsoleOutputCharacter (hScreen, ' ', Info.dwSize.X-coord.X, coord,
&dwWritten);
FillConsoleOutputAttribute (hScreen, Info.wAttributes,
Info.dwSize.X-coord.X, coord, &dwWritten);
gotoxy (coord.X, coord.Y) ;
}
}
int wmain(int argc, WCHAR* argv[])
{
LARGE_INTEGER lint;
DWORD Written;
COORD Coord = { 0, 0 };
myself = GetModuleHandle(NULL);
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE),
&ScreenBufferInfo);
ScreenBufferInfo.dwSize.X = ScreenBufferInfo.srWindow.Right - ScreenBufferInfo.srWindow.Left + 1;
ScreenBufferInfo.dwSize.Y = ScreenBufferInfo.srWindow.Bottom - ScreenBufferInfo.srWindow.Top + 1;
ScreenBuffer = CreateConsoleScreenBuffer(GENERIC_WRITE,
0,
NULL,
CONSOLE_TEXTMODE_BUFFER,
NULL);
if (ScreenBuffer == INVALID_HANDLE_VALUE)
{
wprintf(L"%s: could not create a new screen buffer\n", app_name);
return EXIT_FAILURE;
}
/* Fill buffer with black background */
FillConsoleOutputAttribute(ScreenBuffer,
0,
ScreenBufferInfo.dwSize.X * ScreenBufferInfo.dwSize.Y,
Coord,
&Written);
WaitableTimer = CreateWaitableTimer(NULL, FALSE, NULL);
if (WaitableTimer == INVALID_HANDLE_VALUE)
{
wprintf(L"CreateWaitabletimer() failed\n");
return 1;
}
lint.QuadPart = -2000000;
if (!SetWaitableTimer(WaitableTimer, &lint, 200, NULL, NULL, FALSE))
{
wprintf(L"SetWaitableTimer() failed: 0x%lx\n", GetLastError());
return 2;
}
SetConsoleActiveScreenBuffer(ScreenBuffer);
MainLoop();
CloseHandle(ScreenBuffer);
return EXIT_SUCCESS;
}
void SnakeAPI::clear(bool clearAttribute, char ch)
{
getInfo();
DWORD cCharsWritten;
DWORD size = CSBI.dwSize.X * CSBI.dwSize.Y;
COORD coord = {0, 0};
FillConsoleOutputCharacterA(hSnakeAPI, ch, size, coord, &cCharsWritten);
int attrib = CSBI.wAttributes;
if (clearAttribute)
attrib = LIGHTGRAY;
FillConsoleOutputAttribute(hSnakeAPI, attrib, size, coord, &cCharsWritten);
SetConsoleCursorPosition(hSnakeAPI, coord);
getInfo();
}
VALUE
rb_FillConsoleOutputAttribute( VALUE self, VALUE hConsoleOutput,
VALUE wAttribute, VALUE nLength,
VALUE col, VALUE row )
{
HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );
DWORD numChars;
COORD dwWriteCoord;
dwWriteCoord.X = NUM2UINT(col);
dwWriteCoord.Y = NUM2UINT(row);
if (FillConsoleOutputAttribute( handle, NUM2UINT(wAttribute),
NUM2ULONG(nLength), dwWriteCoord,
&numChars ))
return ULONG2NUM(numChars);
return rb_getWin32Error();
}
void IOConsole::ClearConsole(void)
{
COORD topLeft = { 0, 0 };
HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_SCREEN_BUFFER_INFO screen;
DWORD written;
GetConsoleScreenBufferInfo(m_hOutput, &screen);
FillConsoleOutputCharacterA(
m_hOutput, ' ', screen.dwSize.X * screen.dwSize.Y, topLeft, &written
);
FillConsoleOutputAttribute(
m_hOutput, FOREGROUND_RED,
screen.dwSize.X * screen.dwSize.Y, topLeft, &written
);
SetConsoleCursorPosition(m_hOutput, topLeft);
}
void clear_console()
{
#ifdef _WIN32
COORD coordScreen = {0, 0};
DWORD charsWritten = 0;
CONSOLE_SCREEN_BUFFER_INFO csbi;
DWORD conSize = 0;
HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);
GetConsoleScreenBufferInfo(console, &csbi);
conSize = csbi.dwSize.X * csbi.dwSize.Y;
FillConsoleOutputCharacter(console, ' ', conSize, coordScreen, &charsWritten);
GetConsoleScreenBufferInfo(console, &csbi);
FillConsoleOutputAttribute(console, csbi.wAttributes, conSize, coordScreen,
&charsWritten);
SetConsoleCursorPosition(console, coordScreen);
#endif
}
