void PDC_reset_prog_mode(void)
{
PDC_LOG(("PDC_reset_prog_mode() - called.\n"));
if (pdc_con_out != std_con_out)
SetConsoleActiveScreenBuffer(pdc_con_out);
else if (is_nt)
{
COORD bufsize;
SMALL_RECT rect;
bufsize.X = orig_scr.srWindow.Right - orig_scr.srWindow.Left + 1;
bufsize.Y = orig_scr.srWindow.Bottom - orig_scr.srWindow.Top + 1;
rect.Top = rect.Left = 0;
rect.Bottom = bufsize.Y - 1;
rect.Right = bufsize.X - 1;
SetConsoleScreenBufferSize(pdc_con_out, bufsize);
SetConsoleWindowInfo(pdc_con_out, TRUE, &rect);
SetConsoleScreenBufferSize(pdc_con_out, bufsize);
SetConsoleActiveScreenBuffer(pdc_con_out);
}
PDC_mouse_set();
}
void DblBuffer::swap()
{
if( (m_swapped = !m_swapped) ) {
SetConsoleActiveScreenBuffer(m_hCons2);
} else {
SetConsoleActiveScreenBuffer(m_hCons1);
}
}
void putASCII2( int x, int y, int ch, int fgcolor, int bgcolor )
{
if ( Touched_Global == 0) {
hOutput[0] = (HANDLE) GetStdHandle( STD_OUTPUT_HANDLE );
SetConsoleScreenBufferSize(hOutput[0], dwBufferSize);
hOutput[1] = CreateConsoleScreenBuffer(
GENERIC_READ | // read/write access
GENERIC_WRITE,
FILE_SHARE_READ |
FILE_SHARE_WRITE, // shared
NULL, // default security attributes
CONSOLE_TEXTMODE_BUFFER, // must be TEXTMODE
NULL); // reserved; must be NULL
SetConsoleScreenBufferSize(hOutput[1], dwBufferSize);
SetConsoleActiveScreenBuffer(hOutput[0]);
Double_Buffer_Switch = 1;
Touched_Global = 1;
}
if (x<SCREEN_WIDTH && x>=0 && y<SCREEN_HEIGHT && y>=0) {
screen_buffer[y][x].Char.AsciiChar = ch;
screen_buffer[y][x].Attributes = fgcolor | bgcolor<<4;
}
}
CL_ConsoleWindow_Generic::CL_ConsoleWindow_Generic(
const CL_StringRef &title,
int width,
int height)
{
#ifdef WIN32
AllocConsole();
SetConsoleTitle(CL_StringHelp::utf8_to_ucs2(title).c_str());
COORD coord;
coord.X = width;
coord.Y = height;
scrbuf =
CreateConsoleScreenBuffer(
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
CONSOLE_TEXTMODE_BUFFER,
NULL);
if(scrbuf == INVALID_HANDLE_VALUE)
throw CL_Exception("Unable to allocate console screen buffer");
SetStdHandle(STD_OUTPUT_HANDLE, scrbuf);
SetConsoleActiveScreenBuffer(scrbuf);
SetConsoleScreenBufferSize(scrbuf, coord);
#endif
}
void print()
{
std::ostringstream out;
for (int y = 0; y < HEIGHT; y++)
{
out << chars[y] << std::endl;
chars[y][0] = '\0';
}
auto str = out.str();
//１、cmd.exeのcls命令を使う方法
//system("cls");
//２、Win32APIでカーソル位置を操作する方法
//COORD coord = { 0, 0 };
//SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
//std::cout << str;
//３、Win32APIでスクリーンバッファを切り替える方法
DWORD cell;
WriteConsoleA(hSrc, str.c_str(), str.length(), &cell, NULL);
SetConsoleActiveScreenBuffer(hSrc);
hSrc = (hSrc == hSrc0) ? hSrc1 : hSrc0;
}
void createConsole(void)
{
if (AllocConsole())
{
COORD size = {80, 1000};
SMALL_RECT rect = {0, 0, 79, 24};
// HANDLE hOrigStdOut;
HANDLE hStdOut;
SECURITY_ATTRIBUTES securityAttributes;
securityAttributes.nLength = sizeof SECURITY_ATTRIBUTES;
securityAttributes.lpSecurityDescriptor = NULL;
securityAttributes.bInheritHandle = TRUE;
hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
// hStdOut = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
// FILE_SHARE_READ | FILE_SHARE_WRITE, &securityAttributes,
// CONSOLE_TEXTMODE_BUFFER, NULL);
SetConsoleScreenBufferSize(hStdOut, size);
SetConsoleWindowInfo(hStdOut, TRUE, &rect);
SetConsoleActiveScreenBuffer(hStdOut);
// SetStdHandle(STD_OUTPUT_HANDLE, hStdOut);
freopen("CONOUT$", "w", stdout);
freopen("CONIN$", "r", stdin);
}
}
void ConsoleImpl::setup(int rows, int cols)
{
SetConsoleActiveScreenBuffer(hndOutput_);
COORD xy = { cols, rows };
SMALL_RECT sr = { 0, 0, cols - 1, rows - 1 };
resize(hndOutput_, xy, sr);
}
static void
ntconio_close(void)
{
TRACE(("ntconio_close\n"));
if (chgd_cursor) {
/* restore cursor */
show_cursor(TRUE, origcci.dwSize);
}
scflush();
ntconio_move(term.rows - 1, 0);
currentAttribute = originalAttribute;
ntconio_eeol();
ntconio_flush();
set_current_attr();
SetConsoleTextAttribute(hConsoleOutput, originalAttribute);
if (hOldConsoleOutput) {
TRACE(("...restoring screen buffer\n"));
SetConsoleActiveScreenBuffer(hOldConsoleOutput);
CloseHandle(hConsoleOutput);
}
SetConsoleCtrlHandler(nthandler, FALSE);
SetConsoleMode(hConsoleInput, ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT | ENABLE_PROCESSED_INPUT);
keyboard_open = FALSE;
}
/*
* コンストラクタ。
* @return なし
*/
ScreenControl::ScreenControl() :
mHandle(),
mInfo()
{
// 初期ハンドルの取得
mInitHandle = GetStdHandle(STD_OUTPUT_HANDLE);
// スクリーン情報設定
infoUpdate();
// カラー情報の初期値退避
mInitColor = mInfo.wAttributes;
// バッファサイズの初期値退避
mInitBufferSize.X = mInfo.dwSize.X;
mInitBufferSize.Y = mInfo.dwSize.Y;
// 画面バッファ表示サイズの初期値退避
mInitWindow.Bottom = mInfo.srWindow.Bottom - mInfo.srWindow.Top;
mInitWindow.Top = 0;
mInitWindow.Left = 0;
mInitWindow.Right = mInfo.srWindow.Right - mInfo.srWindow.Left;
// スクリーンバッファを作成
mHandle = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, 0, NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
if (INVALID_HANDLE_VALUE == mHandle) {
std::cerr << "Error" << std::endl;
}
// 対象のスクリーンバッファをアクティブ化
SetConsoleActiveScreenBuffer(mHandle);
}
ConsoleImpl::~ConsoleImpl()
{
SetConsoleActiveScreenBuffer(hndSavedOutput_);
SetConsoleTextAttribute(hndSavedOutput_, csbiSaved_.wAttributes);
SetConsoleCursorInfo(hndSavedOutput_, &cciSaved_);
resize(hndSavedOutput_, csbiSaved_.dwSize, csbiSaved_.srWindow);
CloseHandle(hndOutput_);
}
void Console_Flip()
{
g_console.hOut = g_console.hWork; // 仕事を終えたハンドルを表示用ハンドルに
g_console.hScreenIndex = (g_console.hScreenIndex + 1) % CONSOLE_SCREEN_MAX;
g_console.hWork = g_console.hScreen[g_console.hScreenIndex]; // 次の仕事用バッファ
SetConsoleActiveScreenBuffer(g_console.hOut); // 表示用のバッファをアクティブ化
}
void PDC_reset_shell_mode(void)
{
PDC_LOG(("PDC_reset_shell_mode() - called.\n"));
if (pdc_con_out != std_con_out)
SetConsoleActiveScreenBuffer(std_con_out);
else if (is_nt)
{
SetConsoleScreenBufferSize(pdc_con_out, orig_scr.dwSize);
SetConsoleWindowInfo(pdc_con_out, TRUE, &orig_scr.srWindow);
SetConsoleScreenBufferSize(pdc_con_out, orig_scr.dwSize);
SetConsoleWindowInfo(pdc_con_out, TRUE, &orig_scr.srWindow);
SetConsoleActiveScreenBuffer(pdc_con_out);
}
SetConsoleMode(pdc_con_in, old_console_mode | 0x0080);
}
extern void ConsoleFlip(void)
{
m_hOut = m_hWork;// 仕事を終えたハンドルを、表示用のハンドルに
m_hScreenIndex = (m_hScreenIndex + 1) % NUM_SCREEN_MAX;// スクリーンインデックスを進める
m_hWork = m_hScreen[m_hScreenIndex];// 次の仕事用バッファ
SetConsoleActiveScreenBuffer(m_hOut);// 表示用のハンドルをアクティブ化
}
void RestoreConsole()
{
SetConsoleMode(hStdin, inConMode);
SetConsoleMode(hStdout, outConMode);
#ifdef NEW_CONSOLE
SetConsoleActiveScreenBuffer(GetStdHandle(STD_OUTPUT_HANDLE));
#endif
}
VALUE
rb_SetConsoleActiveScreenBuffer( VALUE self, VALUE hConsoleOutput )
{
HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );
if ( !SetConsoleActiveScreenBuffer( handle ) )
return rb_getWin32Error();
return INT2FIX(1);
}
int
main(
int argc,
char *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 (INVALID_HANDLE_VALUE == ScreenBuffer)
{
_ftprintf(
stderr,
_TEXT("%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 )
{
printf( "CreateWaitabletimer() failed\n" );
return 1;
}
lint.QuadPart = -2000000;
if( SetWaitableTimer( WaitableTimer, &lint, 200, NULL, NULL, FALSE ) == FALSE )
{
printf( "SetWaitableTimer() failed: 0x%lx\n", GetLastError() );
return 2;
}
SetConsoleActiveScreenBuffer(ScreenBuffer);
MainLoop();
CloseHandle(ScreenBuffer);
return EXIT_SUCCESS;
}
void drawCmdWindow()
{
if (Touched_Global) {
WriteConsoleOutput( hOutput[Double_Buffer_Switch], (CHAR_INFO *)screen_buffer, dwBufferSize,
dwBufferCoord, &rcRegion );
SetConsoleActiveScreenBuffer(hOutput[Double_Buffer_Switch]);
SetConsoleCursorPosition( hOutput[Double_Buffer_Switch], dwBufferSize );
Double_Buffer_Switch = !Double_Buffer_Switch;
}
}
void WindowManager::refresh() {
if(mSwitch) {
for(WindowIt it = mWindows.begin(); it != mWindows.end(); ++it) {
(*it)->update(mConsoleA);
}
SetConsoleActiveScreenBuffer(mConsoleA->getHandle());
::clear(mConsoleB->getHandle());
mSwitch = false;
}
else {
for(WindowIt it = mWindows.begin(); it != mWindows.end(); ++it) {
(*it)->update(mConsoleB);
}
SetConsoleActiveScreenBuffer(mConsoleB->getHandle());
::clear(mConsoleA->getHandle());
mSwitch = true;
}
}
// 활성화 하려는 Screen buffer로 전환
BOOL CCommonConsole::SwitchingOfActiveScreenBuffer( HANDLE /*in_*/hConsoleOutput )
{
BOOL lResult = FALSE;
lResult = SetConsoleActiveScreenBuffer( hConsoleOutput );
if( lResult == FALSE )
g_Log.PrintErrorMsg( TEXT( __FUNCTION__ ), true, GetLastError() );
return lResult;
}
static long doExec( const char *std_in, const char *std_out, const char *cmd )
{
HANDLE cp;
long st;
HANDLE old_in;
HANDLE new_in;
HANDLE old_out;
HANDLE new_out;
old_in = INVALID_HANDLE_VALUE;
new_in = INVALID_HANDLE_VALUE;
old_out = INVALID_HANDLE_VALUE;
new_out = INVALID_HANDLE_VALUE;
preSpawn();
cp = GetCurrentProcess();
if( std_in != NULL ) {
old_in = GetStdHandle( STD_INPUT_HANDLE );
new_in = CreateFile( std_in, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
if( new_in == INVALID_HANDLE_VALUE ) {
return( -1L );
}
SetStdHandle( STD_INPUT_HANDLE, new_in );
}
if( std_out != NULL ) {
old_out = GetStdHandle( STD_INPUT_HANDLE );
new_out = CreateFile( std_out, GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING | CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL );
if( new_out == INVALID_HANDLE_VALUE ) {
if( std_in != NULL ) {
SetStdHandle( STD_INPUT_HANDLE, old_in );
CloseHandle( new_in );
}
return( -1L );
}
SetStdHandle( STD_OUTPUT_HANDLE, new_out );
}
if( cmd == NULL ) {
st = MySpawn( Comspec );
} else {
SetConsoleActiveScreenBuffer( GetStdHandle( STD_OUTPUT_HANDLE ) );
st = system( cmd );
}
if( std_in != NULL ) {
CloseHandle( new_in );
SetStdHandle( STD_INPUT_HANDLE, old_in );
}
if( std_out != NULL ) {
CloseHandle( new_out );
SetStdHandle( STD_OUTPUT_HANDLE, old_out );
}
postSpawn( st );
return( st );
}
void Console_Init()
{
int i;
for (i = 0; i < CONSOLE_SCREEN_MAX; i++) {
g_console.hScreen[i] = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, 0, NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
}
g_console.hScreenIndex = 0;
g_console.hOut = g_console.hWork = g_console.hScreen[g_console.hScreenIndex];
SetConsoleActiveScreenBuffer(g_console.hOut);
g_console.hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
}
/*
* デストラクタ。
* @return なし
*/
ScreenControl::~ScreenControl()
{
setDefaultColor();
setWindow(mInitWindow.Left, mInitWindow.Top, mInitWindow.Right, mInitWindow.Bottom);
setBufferSize(mInitBufferSize.X, mInitBufferSize.Y);
// 初期ハンドルの再設定
SetConsoleActiveScreenBuffer(mInitHandle);
// スクリーンバッファを解放
CloseHandle(mHandle);
mHandle = NULL;
}
void Console_Close()
{
int i;
for (i = 0; i < CONSOLE_SCREEN_MAX; i++) {
CloseHandle(g_console.hScreen[i]);
g_console.hScreen[i] = NULL;
}
g_console.hOut = g_console.hWork = NULL;
SetConsoleActiveScreenBuffer(g_console.hStdOut);
CloseHandle(g_console.hStdOut);
g_console.hStdOut = NULL;
}
int ConsoleInit(void)
{
//create debug console
AllocConsole();
//initial screen buffer so console commands will work
HANDLE hStdout=CreateConsoleScreenBuffer(GENERIC_WRITE|GENERIC_READ,FILE_SHARE_WRITE, NULL,CONSOLE_TEXTMODE_BUFFER, NULL);
//error check
if(hStdout==0)
return 1;
SetConsoleActiveScreenBuffer(hStdout);
//lets text formating (ie newlines, etc) work with writeconsole()
SetConsoleMode(hStdout, ENABLE_PROCESSED_OUTPUT);
//redirects std output to console buffer, so that printf works
//freopen( "CON", "w", stdout ); //redirects stdout to console, but
//doesn"t work after SetConsoleActiveScreenBuffer issued
freopen("CONOUT$", "wta", stdout);
//freopen("CONOUT$", "wta+", stdout);
//Also let us read from console with c library, since I can"t get
//ReadConsole to work
freopen("CONIN$","r",stdin);
//set console title
char *title="Console";
#ifdef UNICODE
// Convert to a wchar_t*
size_t origsize = strlen(title) + 1;
const size_t newsize = 128;
size_t convertedChars = 0;
wchar_t wcstring[newsize];
mbstowcs(wcstring, title, newsize);
// wcscat_s(wcstring, L" (wchar_t *)");
SetConsoleTitle(wcstring);
#endif
#ifndef UNICODE
SetConsoleTitle(title);
#endif
//set buffer size
COORD crd;
crd.X=80;
crd.Y=3000;
SetConsoleScreenBufferSize(hStdout, crd);
}
static void ScreenBuffer_CreatePort(SIOPCB * cb)
{
cb->Handle = CreateConsoleScreenBuffer(GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
/* cb->Handle should not be compared with NULL because CreateConsoleScreenBuffer returns INVALID_HANDLE_VALUE if it failed */
FatalAssertion(cb->Handle != INVALID_HANDLE_VALUE && cb->Handle != NULL,
"ScreenBuffer_CreatePort failed to allocate its own console.");
SetConsoleActiveScreenBuffer(cb->Handle);
SetConsoleTitle("TOPPERS/JSP SerialConsole");
/* 受信バッファ監視用スレッドを作成 */
CreateThread(NULL,0,ScreenBuffer_ReceiverThread,(LPVOID)cb,0,NULL);
}
int PDC_resize_screen(int nlines, int ncols)
{
SMALL_RECT rect;
COORD size, max;
bool prog_resize = nlines || ncols;
if (!prog_resize)
{
nlines = PDC_get_rows();
ncols = PDC_get_columns();
}
if (nlines < 2 || ncols < 2)
return ERR;
max = GetLargestConsoleWindowSize(pdc_con_out);
rect.Left = rect.Top = 0;
rect.Right = ncols - 1;
if (rect.Right > max.X)
rect.Right = max.X;
rect.Bottom = nlines - 1;
if (rect.Bottom > max.Y)
rect.Bottom = max.Y;
size.X = rect.Right + 1;
size.Y = rect.Bottom + 1;
_fit_console_window(pdc_con_out, &rect);
SetConsoleScreenBufferSize(pdc_con_out, size);
if (prog_resize)
{
_fit_console_window(pdc_con_out, &rect);
SetConsoleScreenBufferSize(pdc_con_out, size);
}
SetConsoleActiveScreenBuffer(pdc_con_out);
PDC_flushinp();
SP->resized = FALSE;
SP->cursrow = SP->curscol = 0;
return OK;
}
static void
ntconio_open(void)
{
CONSOLE_CURSOR_INFO newcci;
BOOL newcci_ok;
TRACE(("ntconio_open\n"));
set_colors(NCOLORS);
set_palette(initpalettestr);
hOldConsoleOutput = 0;
hConsoleOutput = GetStdHandle(STD_OUTPUT_HANDLE);
origcci_ok = GetConsoleCursorInfo(hConsoleOutput, &origcci);
GetConsoleScreenBufferInfo(hConsoleOutput, &csbi);
if (csbi.dwMaximumWindowSize.Y !=
csbi.srWindow.Bottom - csbi.srWindow.Top + 1
|| csbi.dwMaximumWindowSize.X !=
csbi.srWindow.Right - csbi.srWindow.Left + 1) {
TRACE(("..creating alternate screen buffer\n"));
hOldConsoleOutput = hConsoleOutput;
hConsoleOutput = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
0, NULL,
CONSOLE_TEXTMODE_BUFFER, NULL);
SetConsoleActiveScreenBuffer(hConsoleOutput);
GetConsoleScreenBufferInfo(hConsoleOutput, &csbi);
newcci_ok = GetConsoleCursorInfo(hConsoleOutput, &newcci);
if (newcci_ok && origcci_ok && newcci.dwSize != origcci.dwSize) {
/*
* Ensure that user's cursor size prefs are carried forward
* in the newly created console.
*/
show_cursor(TRUE, origcci.dwSize);
}
}
originalAttribute = csbi.wAttributes;
crow = csbi.dwCursorPosition.Y;
ccol = csbi.dwCursorPosition.X;
nfcolor = cfcolor = gfcolor;
nbcolor = cbcolor = gbcolor;
set_current_attr();
newscreensize(csbi.dwMaximumWindowSize.Y, csbi.dwMaximumWindowSize.X);
hConsoleInput = GetStdHandle(STD_INPUT_HANDLE);
SetConsoleCtrlHandler(nthandler, TRUE);
}
static void
ntconio_kclose(void)
{ /* close the keyboard */
TRACE(("ntconio_kclose\n"));
if (!keyboard_open)
return;
keyboard_open = FALSE;
keyboard_was_closed = TRUE;
if (hOldConsoleOutput) {
SetConsoleActiveScreenBuffer(hOldConsoleOutput);
}
#ifdef DONT_USE_ON_WIN95
SetConsoleCtrlHandler(NULL, FALSE);
#endif
}
static void
ntconio_kopen(void)
{ /* open the keyboard */
TRACE(("ntconio_kopen (open:%d, was-closed:%d)\n", keyboard_open, keyboard_was_closed));
if (keyboard_open)
return;
if (hConsoleOutput) {
SetConsoleActiveScreenBuffer(hConsoleOutput);
}
keyboard_open = TRUE;
#ifdef DONT_USE_ON_WIN95
SetConsoleCtrlHandler(NULL, TRUE);
#endif
SetConsoleMode(hConsoleInput, ENABLE_MOUSE_INPUT | ENABLE_WINDOW_INPUT);
}
extern void ConsoleClose(void)
{
int i;
for (i=0; i<NUM_SCREEN_MAX; i++)
{
CloseHandle(m_hScreen[i]);
m_hScreen[i] = NULL;
}
m_hOut = m_hWork = NULL;
SetConsoleActiveScreenBuffer(m_hStdOut);
CloseHandle(m_hStdOut);
m_hStdOut = NULL;
}
