自学教程：C++ FillConsoleOutputAttribute函数代码示例

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 windowvoid 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 endbool 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;}

VOIDDrawFileSystemList(    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 screenbool 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;}

// clear console screenvoid 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 voiderase_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;}

BOOLWriteConsoleLine(    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();}

VALUErb_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	}