int erase_to_eol( FILE* confp )
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
HANDLE hStdErr;
DWORD dwCellsWritten;
COORD ptConsole;
int cons_fd;
if ( !confp )
{
errno = EINVAL;
return -1;
}
if ( ! _isatty( cons_fd = fileno( confp ) ) )
{
errno = EBADF;
return -1;
}
hStdErr = (HANDLE) _get_osfhandle( cons_fd );
ASSERT( hStdErr && INVALID_HANDLE_VALUE != hStdErr );
VERIFY( GetConsoleScreenBufferInfo( hStdErr, &csbi ) );
ptConsole = csbi.dwCursorPosition;
VERIFY( FillConsoleOutputAttribute( hStdErr, csbi.wAttributes, csbi.dwSize.X - ptConsole.X, ptConsole, &dwCellsWritten ) );
VERIFY( FillConsoleOutputCharacter( hStdErr, ' ', csbi.dwSize.X - ptConsole.X, ptConsole, &dwCellsWritten ) );
return 0;
}
void
console_widget_NT_t::draw()
{
if (console == NULL) {
COORD c = {0, 0};
DWORD z;
if (!FillConsoleOutputCharacter
(buffer, blank.Char.AsciiChar, size.X * size.Y, c, &z))
co_debug("FillConsoleOutputCharacter() error 0x%lx",
GetLastError());
if (!FillConsoleOutputAttribute
(buffer, blank.Attributes, size.X * size.Y, c, &z))
co_debug("FillConsoleOutputAttribute() error 0x%lx",
GetLastError());
return;
}
co_console_cell_t *cell = console->screen;
CHAR_INFO *ci = screen;
int count = size.X * size.Y;
do {
ci->Attributes = cell->attr;
(ci++)->Char.AsciiChar = (cell++)->ch;
} while (--count);
SMALL_RECT r = region;
COORD c = {0, 0};
if (!WriteConsoleOutput(buffer, screen, size, c, &r))
co_debug("WriteConsoleOutput() error 0x%lx", GetLastError());
}
void clear_console(void)
{
#if !defined WINCE
HANDLE Hand;
CONSOLE_SCREEN_BUFFER_INFO Info;
unsigned long Written;
static COORD Home = { 0, 0 };
Hand = GetStdHandle(STD_OUTPUT_HANDLE);
if (Hand == INVALID_HANDLE_VALUE)
return;
if(!GetConsoleScreenBufferInfo(Hand, &Info))
return;
if(!FillConsoleOutputCharacter(Hand, ' ',
Info.dwSize.X * Info.dwSize.Y, Home,
&Written))
return;
if(!FillConsoleOutputAttribute(Hand, Info.wAttributes,
Info.dwSize.X * Info.dwSize.Y, Home,
&Written))
return;
SetConsoleCursorPosition(Hand, Home);
#endif
}
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);
}
}
// Initializes windows console.
bool CSimWindow::InitWindow()
{
// Set up console window
WORD wAttributes;
COORD pos;
SMALL_RECT consoleWindowDim;
CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
unsigned long int temp;
// Get console handles
hSimOutput = GetStdHandle(STD_OUTPUT_HANDLE);
hSimInput = GetStdHandle(STD_INPUT_HANDLE);
if(hSimOutput == INVALID_HANDLE_VALUE || hSimInput == INVALID_HANDLE_VALUE) {
printf("ERROR: Couldn't get console I/O handles.\n");
return false;
}
// Save current console info
GetConsoleScreenBufferInfo(hSimOutput, &bufferInfo);
oldBufferSize = bufferInfo.dwSize;
oldWindowSize = bufferInfo.srWindow;
oldAttributes = bufferInfo.wAttributes;
// Set console title
SetConsoleTitle("Emu86 Simulator");
// Set console to small size for buffer change:
consoleWindowDim.Bottom = 0;
consoleWindowDim.Top = 0;
consoleWindowDim.Left = 0;
consoleWindowDim.Right = 0;
SetConsoleWindowInfo(hSimOutput, TRUE, &consoleWindowDim);
// Set buffer size
pos.X = SIM_CONSOLE_BUFFER_WIDTH;
pos.Y = SIM_CONSOLE_BUFFER_HEIGHT;
SetConsoleScreenBufferSize(hSimOutput, pos);
// Set console size
consoleWindowDim.Bottom = SIM_CONSOLE_HEIGHT - 1;
consoleWindowDim.Top = 0;
consoleWindowDim.Left = 0;
consoleWindowDim.Right = SIM_CONSOLE_WIDTH - 1;
SetConsoleWindowInfo(hSimOutput, TRUE, &consoleWindowDim);
// Clear console, set to black, white text
pos.X = 0;
pos.Y = 0;
wAttributes = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
FillConsoleOutputAttribute(hSimOutput, wAttributes, SIM_CONSOLE_BUFFER_WIDTH * SIM_CONSOLE_BUFFER_HEIGHT, pos, &temp);
FillConsoleOutputCharacter(hSimOutput, ' ', SIM_CONSOLE_BUFFER_WIDTH * SIM_CONSOLE_BUFFER_HEIGHT, pos, &temp);
// Move curor to top left
SetConsoleCursorPosition(hSimOutput, pos);
return true;
}
void RefreshScreen(void)
{
DWORD dummy;
COORD Home = {0, 0};
FillConsoleOutputCharacter(hConsoleOut, ' ',
csbiInfo.dwSize.X * csbiInfo.dwSize.Y,
Home, &dummy);
}
void mp_hal_erase_line_from_cursor(uint n_chars_to_erase) {
assure_conout_handle();
CONSOLE_SCREEN_BUFFER_INFO info;
GetConsoleScreenBufferInfo(con_out, &info);
DWORD written;
FillConsoleOutputCharacter(con_out, ' ', n_chars_to_erase, info.dwCursorPosition, &written);
FillConsoleOutputAttribute(con_out, info.wAttributes, n_chars_to_erase, info.dwCursorPosition, &written);
}
JNIEXPORT void JNICALL Java_com_yifanlu_Josh_Josh_FILLCONSOLEOUTPUTCHARACTER
(JNIEnv *env, jclass jcls, jlong pointer, jchar character, jint length, jint x, jint y)
{
HANDLE hConsole = pointerToHandle(pointer);
COORD location = { x , y };
FillConsoleOutputCharacter(hConsole, character, length, location, NULL);
}
int main(int argc, char *argv[])
{
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_SCREEN_BUFFER_INFO bInfo;
GetConsoleScreenBufferInfo(hOut, &bInfo);
COORD pos = {0, 0};
FillConsoleOutputCharacter(hOut, '@', bInfo.dwSize.X / 2 * bInfo.dwSize.Y, pos, NULL);
CloseHandle(hOut);
}
void mp_hal_erase_line_from_cursor() {
assure_conout_handle();
CONSOLE_SCREEN_BUFFER_INFO info;
GetConsoleScreenBufferInfo(con_out, &info);
const short len = info.dwSize.X - info.dwCursorPosition.X;
DWORD written;
FillConsoleOutputCharacter(con_out, ' ', len, info.dwCursorPosition, &written);
FillConsoleOutputAttribute(con_out, info.wAttributes, len, info.dwCursorPosition, &written);
}
void Graphics::clearScreen()
{
DWORD d;
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo(_console, &csbi);
auto size = csbi.dwSize.X * csbi.dwSize.Y;
FillConsoleOutputAttribute(_console, csbi.wAttributes, size, { 0, 0 }, &d);
FillConsoleOutputCharacter(_console, L' ', size, { 0, 0 }, &d);
}
void Console::Clear(void) const
{
ScreenBufferInfo info(*this); // Screen buffer information
DWORD result; // Result from fill operation
// Fill the console with space characters using the current attibutes; move cursor to 0,0 afterwards
if(!FillConsoleOutputCharacter(m_stdout, _T(' '), info.dwSize.X * info.dwSize.Y, { 0, 0 }, &result)) throw Win32Exception();
if(!FillConsoleOutputAttribute(m_stdout, info.wAttributes, info.dwSize.X * info.dwSize.Y, { 0, 0 }, &result)) throw Win32Exception();
if(!SetConsoleCursorPosition(m_stdout, { 0, 0 })) throw Win32Exception();
}
static void eraseEol(struct current *current)
{
COORD pos;
DWORD n;
pos.X = (SHORT) current->x;
pos.Y = (SHORT) current->y;
FillConsoleOutputCharacter(current->outh, ' ', current->cols - current->x, pos, &n);
}
void clib::cls()
{
_COORD st;
unsigned long bw;
st.X = 0;
st.Y = 0;
FillConsoleOutputAttribute(screen_,fgc_|bgc_,80*50,st,&bw);
FillConsoleOutputCharacter(screen_,32,80*50,st,&bw);
SetConsoleCursorPosition(screen_,st);
}
void ClearLine(void) {
CONSOLE_SCREEN_BUFFER_INFO s;
HANDLE out = GetTermInfo(&s);
COORD pos = { 0, s.dwCursorPosition.Y };
DWORD n;
FillConsoleOutputCharacter(out, ' ', s.dwSize.X, pos, (LPDWORD)(&n));
SetConsoleCursorPosition(out, pos);
}
/* Cleans the screen with the given start point and len. */
VOID ClsXYXCount(INT x,INT y,INT Width,INT Count){
INT i;
DWORD cCharsWritten;
// Start point of cleaning the screen.
COORD coordScreen = {x,y};
// Filling the given position with blanks.
for(i=0;i < Count;i++){
FillConsoleOutputCharacter( hConsole, (WCHAR) ' ',(Width), coordScreen, &cCharsWritten );
++coordScreen.Y;
}
}
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);
}
void Screen::fillChar (int x, int y, int c, int count)
{
DWORD charsWritten;
if (count <= 0)
throw AppException (WHERE, ERR_INTERNAL);
COORD coord;
coord.X = (SHORT) x;
coord.Y = (SHORT) y;
if (FillConsoleOutputCharacter (mScreenBuf, c, count, coord, &charsWritten) != TRUE)
throw AppException (WHERE, ERR_WINDOWS_FMT, "FillConsoleOutputCharacter", GetLastError ());
}
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 );
}
void
ClearScreen (void)
{
COORD coordOrg = {0, 0};
DWORD dwWritten = 0;
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
if (INVALID_HANDLE_VALUE != hConsole)
FillConsoleOutputCharacter(hConsole, ' ', 80 * 50, coordOrg, &dwWritten);
MoveCursor(0, 0);
return;
}
void clearScreen()
{
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo(hConsole, &csbi);
DWORD dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
COORD upperLeft = { 0, 0 };
DWORD dwCharsWritten;
FillConsoleOutputCharacter(hConsole, TCHAR(' '), dwConSize, upperLeft,
&dwCharsWritten);
SetConsoleCursorPosition(hConsole, upperLeft);
}
// 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);
}
NTSTATUS kuhl_m_standard_cls(int argc, wchar_t * argv[])
{
HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
COORD coord = {0, 0};
DWORD count;
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo(hStdOut, &csbi);
FillConsoleOutputCharacter(hStdOut, L' ', csbi.dwSize.X * csbi.dwSize.Y, coord, &count);
SetConsoleCursorPosition(hStdOut, coord);
return STATUS_SUCCESS;
}
// draw the field
// argument - width and height of the field
// resizes console window for no reason
// prints instructions how to interact
void drawTable(COORD size)
{
DWORD cWritten;
HANDLE con = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_CURSOR_INFO cursorInfo;
GetConsoleCursorInfo(con, &cursorInfo);
cursorInfo.bVisible = false;
SetConsoleCursorInfo(con, &cursorInfo);
HWND console = GetConsoleWindow();
RECT r;
GetWindowRect(console, &r);
MoveWindow(console, r.left, r.top, 800, 480, TRUE);
FillConsoleOutputCharacter(con, '+', 1, { 0, 3 }, &cWritten);
FillConsoleOutputCharacter(con, '+', 1, { size.X, 3 }, &cWritten);
FillConsoleOutputCharacter(con, '-', size.X - 1, { 1, 3 }, &cWritten);
FillConsoleOutputCharacter(con, '_', 4, { 3, 1 }, &cWritten);
for (int i = 0; i < size.Y; ++i)
{
if (i != 3)
{
FillConsoleOutputCharacter(con, '|', 1, { 0, i }, &cWritten);
FillConsoleOutputCharacter(con, '|', 1, { size.X, i }, &cWritten);
}
}
print({size.X + 2, 1}, "COWS AND BULLS");
print({size.X + 2, 3}, "0-9 - add digit");
print({size.X + 2, 4}, "Backspace - remove last digit");
print({size.X + 2, 5}, "Enter - confirm");
print({size.X + 2, 6}, "Esc - quit");
}
// 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;
}
static void clrscr_impl(CPCHANDLE handle)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
BOOL bOK = GetConsoleScreenBufferInfo(handle->impl->hConOut, &csbi);
if (bOK)
{
const COORD coordScreen = {0, 0}; /* location to start the attribute fill */
DWORD dw = 0;
bOK = SetConsoleCursorPosition(handle->impl->hConOut, coordScreen);
FillConsoleOutputCharacter(handle->impl->hConOut, ' ', csbi.dwSize.X * csbi.dwSize.Y, coordScreen, &dw);
SetConsoleCursorPosition(handle->impl->hConOut, coordScreen);
}
}
void clrscr()
{
HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
COORD coord = {0, 0};
DWORD count;
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo(hStdOut, &csbi);
FillConsoleOutputCharacter(hStdOut, ' ', csbi.dwSize.X * csbi.dwSize.Y, coord, &count);
SetConsoleCursorPosition(hStdOut, coord);
}
/*--------------------------------------------------------------------------*/
void clrscr_nw(void)
{
COORD coord;
DWORD written;
CONSOLE_SCREEN_BUFFER_INFO info;
coord.X = 0;
coord.Y = 0;
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);
FillConsoleOutputCharacter (GetStdHandle(STD_OUTPUT_HANDLE), ' ',
info.dwSize.X * info.dwSize.Y, coord, &written);
TermSetPosition(0, 0);
}
// 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);
}
static void sdEraseEOL( void )
{
if( GetConsoleScreenBufferInfo( sConsoleHandle, &sScreenInfo ) )
{
COORD savedXY;
int numNeeded;
DWORD count;
savedXY.X = sScreenInfo.dwCursorPosition.X;
savedXY.Y = sScreenInfo.dwCursorPosition.Y;
numNeeded = sScreenInfo.dwSize.X - savedXY.X;
FillConsoleOutputCharacter(
sConsoleHandle, ' ', numNeeded, savedXY, &count );
}
}
