/* * call-seq: * io.winsize = [rows, columns] * * Tries to set console size. The effect depends on the platform and * the running environment. * * You must require 'io/console' to use this method. */ static VALUE console_set_winsize(VALUE io, VALUE size) { rb_io_t *fptr; rb_console_size_t ws; #if defined _WIN32 HANDLE wh; int newrow, newcol; #endif VALUE row, col, xpixel, ypixel; const VALUE *sz; int fd; GetOpenFile(io, fptr); size = rb_Array(size); rb_check_arity(RARRAY_LENINT(size), 2, 4); sz = RARRAY_CONST_PTR(size); row = sz[0], col = sz[1], xpixel = sz[2], ypixel = sz[3]; fd = GetWriteFD(fptr); #if defined TIOCSWINSZ ws.ws_row = ws.ws_col = ws.ws_xpixel = ws.ws_ypixel = 0; #define SET(m) ws.ws_##m = NIL_P(m) ? 0 : (unsigned short)NUM2UINT(m) SET(row); SET(col); SET(xpixel); SET(ypixel); #undef SET if (!setwinsize(fd, &ws)) rb_sys_fail(0); #elif defined _WIN32 wh = (HANDLE)rb_w32_get_osfhandle(fd); #define SET(m) new##m = NIL_P(m) ? 0 : (unsigned short)NUM2UINT(m) SET(row); SET(col); #undef SET if (!NIL_P(xpixel)) (void)NUM2UINT(xpixel); if (!NIL_P(ypixel)) (void)NUM2UINT(ypixel); if (!GetConsoleScreenBufferInfo(wh, &ws)) { rb_syserr_fail(LAST_ERROR, "GetConsoleScreenBufferInfo"); } if ((ws.dwSize.X < newcol && (ws.dwSize.X = newcol, 1)) || (ws.dwSize.Y < newrow && (ws.dwSize.Y = newrow, 1))) { if (!SetConsoleScreenBufferSize(wh, ws.dwSize)) { rb_syserr_fail(LAST_ERROR, "SetConsoleScreenBufferInfo"); } } ws.srWindow.Left = 0; ws.srWindow.Top = 0; ws.srWindow.Right = newcol; ws.srWindow.Bottom = newrow; if (!SetConsoleWindowInfo(wh, FALSE, &ws.srWindow)) { rb_syserr_fail(LAST_ERROR, "SetConsoleWindowInfo"); } #endif return io; }
int main(int argc, char* argv[]) { /* char arg[200]={0}; arg[0]='\"'; strcpy(arg+1, argv[0]); int len=int(strlen(arg)); arg[len]='\"'; HWND hWnd=FindWindow(NULL, arg); //找到程序运行窗口的句柄 HDC hDC=GetDC(hWnd);//通过窗口句柄得到该窗口的设备场境句柄 HPEN hPen, hOldPen; //画笔 int j=0; for(; j<500; ++j) SetPixel(hDC, 10+j, 10+j, 0x0000ff);//用画点的办法画一根线,最后一个参数是颜色(32位) hPen=CreatePen(PS_SOLID, 2, 0x00ff00);//生成绿色画笔 hOldPen=(HPEN)SelectObject(hDC, hPen);//把画笔引入设备场境 MoveToEx(hDC, 20, 50, NULL); //设置画线起点 LineTo(hDC, 520, 550); //画到终点 Arc(hDC, 100, 100, 300, 300, 350, 500, 350, 500);//画圆 SelectObject(hDC, hOldPen); //下面是对比,表明它确实是控制台程序 printf("hello console"); system("pause"); */ HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); // 获取标准输出设备句柄 CONSOLE_SCREEN_BUFFER_INFO bInfo; // 窗口缓冲区信息 GetConsoleScreenBufferInfo(hOut, &bInfo ); // 获取窗口缓冲区信息 SetConsoleTextAttribute(hOut, FOREGROUND_GREEN); char strTitle[255]; GetConsoleTitle(strTitle, 255); // 获取窗口标题 printf("当前窗口标题是:%s\n", strTitle); _getch(); SetConsoleTitle("控制台窗口操作"); // 获取窗口标题 _getch(); COORD size = {80, 25}; SetConsoleScreenBufferSize(hOut,size); // 重新设置缓冲区大小 _getch(); SMALL_RECT rc = {0,0, 80-1, 25-1}; // 重置窗口位置和大小 SetConsoleWindowInfo(hOut,true ,&rc); CloseHandle(hOut); // 关闭标准输出设备句柄 }
void WinConsoleHelper::SetConsoleSize(int x, int y) { UpdateCSBI(); COORD windowSize = { csbi.srWindow.Right - csbi.srWindow.Left + 1, csbi.srWindow.Bottom - csbi.srWindow.Top + 1 }; if (windowSize.X > x || windowSize.Y > y) { SMALL_RECT info = { 0, 0, x < windowSize.X ? x - 1 : windowSize.X - 1, y < windowSize.Y ? y - 1 : windowSize.Y - 1 }; SetConsoleWindowInfo(hStdOut, TRUE, &info); } SMALL_RECT info = { 0, 0, x - 1, y - 1 }; SetConsoleScreenBufferSize(hStdOut, { (SHORT)x, (SHORT)y }); SetConsoleWindowInfo(hStdOut, TRUE, &info); }
void SetConsoleInfo() { HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE); COORD BufferSize = {108, 320}; SMALL_RECT WinRect = {0, 0, BufferSize.X - 1, 27}; SetConsoleScreenBufferSize(hConsole, BufferSize); SetConsoleWindowInfo(hConsole, true, &WinRect); SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN); }
/* get the display metrics */ void ossgmx(int *max_linep, int *max_columnp) { CONSOLE_SCREEN_BUFFER_INFO info; /* get the console handle */ G_out_bufhdl = GetStdHandle(STD_OUTPUT_HANDLE); /* get the size of the screen and return it to the caller's variables */ if (GetConsoleScreenBufferInfo(G_out_bufhdl, &info)) { /* * If it's scrolled down, scroll it to the top. If the screen * buffer size is larger than the window size, reduce the buffer * size to match the window size: we do all of the scrolling * ourselves, so we don't want to do that on top of a separate * scrolling canvas managed by the system. */ if (!os_f_plain && (info.srWindow.Top != 0 || info.srWindow.Left != 0 || info.dwSize.X > info.srWindow.Right + 1 || info.dwSize.Y > info.srWindow.Bottom + 1)) { COORD buf_size; /* scroll it to the top left */ info.srWindow.Bottom -= info.srWindow.Top; info.srWindow.Top = 0; info.srWindow.Right -= info.srWindow.Left; info.srWindow.Left = 0; SetConsoleWindowInfo(G_out_bufhdl, TRUE, &info.srWindow); /* remember the original buffer size */ S_orig_buffer_size = info.dwSize; /* set the window buffer size to equal the window size */ buf_size.X = info.srWindow.Right + 1; buf_size.Y = info.srWindow.Bottom + 1; SetConsoleScreenBufferSize(G_out_bufhdl, buf_size); } /* got the information - use the current window size */ *max_columnp = info.srWindow.Right - info.srWindow.Left; *max_linep = info.srWindow.Bottom - info.srWindow.Top; } else { /* failed to get info - use default sizes */ *max_columnp = 79; *max_linep = 24; } /* note the screen width for our own use */ S_scrwid = info.dwMaximumWindowSize.X; }
// sets the size of the console void setConsoleSize(unsigned short consoleWidth, unsigned short consoleHeight) { SMALL_RECT windowSize = {0, 0, consoleWidth-1, consoleHeight-1}; COORD buffSize = {consoleWidth, consoleHeight}; HANDLE hConsole = hScreenBuffer;//GetStdHandle( STD_OUTPUT_HANDLE ); BOOL bSuccess = SetConsoleWindowInfo(hConsole, TRUE, &windowSize); PERR( bSuccess, "SetConsoleWindowInfo" ); bSuccess = SetConsoleScreenBufferSize(hConsole, buffSize); PERR( bSuccess, "SetConsoleWindowInfo" ); }
void Win32EnableConsole() { int consoleHandle; long stdHandle; CONSOLE_SCREEN_BUFFER_INFO consoleInfo; FILE *file; const int bufferSize = 500; // allocate a console for this app AllocConsole(); // set the screen buffer to be big enough to let us scroll text GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &consoleInfo); consoleInfo.dwSize.Y = bufferSize; SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), consoleInfo.dwSize); // redirect unbuffered STDOUT to the console stdHandle = (long)GetStdHandle(STD_OUTPUT_HANDLE); consoleHandle = _open_osfhandle(stdHandle, _O_TEXT); file = _fdopen(consoleHandle, "w"); *stdout = *file; setvbuf(stdout, NULL, _IONBF, 0); // redirect unbuffered STDIN to the console stdHandle = (long)GetStdHandle(STD_INPUT_HANDLE); consoleHandle = _open_osfhandle(stdHandle, _O_TEXT); file = _fdopen(consoleHandle, "r"); *stdin = *file; setvbuf(stdin, NULL, _IONBF, 0); // redirect unbuffered STDERR to the console stdHandle = (long)GetStdHandle(STD_ERROR_HANDLE); consoleHandle = _open_osfhandle(stdHandle, _O_TEXT); file = _fdopen(consoleHandle, "w"); *stderr = *file; setvbuf(stderr, NULL, _IONBF, 0); // make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog point to console as well std::ios::sync_with_stdio(); GetConsoleScreenBufferInfo((HANDLE)consoleHandle, &consoleInfo); consoleInfo.srWindow.Top = 800; SetConsoleWindowInfo((HANDLE)consoleHandle, false, &consoleInfo.srWindow); /* SetWindowPos( (HWND)GetStdHandle(STD_OUTPUT_HANDLE), HWND_TOP, 1920+100, 800, 500, 200, SWP_NOSIZE | SWP_SHOWWINDOW);*/ }
/*----------------------------------------------------------------------------- Console: Static Functions ---------------------------------------------------------------------------*/ static void SetWindowSize(HANDLE hOut, int height, int width) { COORD coPos = {(SHORT)width, (SHORT)height}; SMALL_RECT sr = {0, 0, (SHORT)(width-1), (SHORT)(height-1)}; if (SetConsoleWindowInfo(hOut, TRUE, &sr) == 0) { fprintf(stderr, "error: SetConsoleWindowInfo: %ld\n", GetLastError()); } if (SetConsoleScreenBufferSize(hOut, coPos) == 0) { fprintf(stderr, "error: SetConsoleScreenBufferSize: %ld\n", GetLastError()); } }
/****************************************************************************** * SetConsoleCursorPosition [KERNEL32.@] * Sets the cursor position in console * * PARAMS * hConsoleOutput [I] Handle of console screen buffer * dwCursorPosition [I] New cursor position coordinates * * RETURNS STD */ BOOL WINAPI SetConsoleCursorPosition(HANDLE hcon, COORD pos) { BOOL ret; CONSOLE_SCREEN_BUFFER_INFO csbi; int do_move = 0; int w, h; TRACE("%x %d %d\n", hcon, pos.X, pos.Y); SERVER_START_REQ(set_console_output_info) { req->handle = hcon; req->cursor_x = pos.X; req->cursor_y = pos.Y; req->mask = SET_CONSOLE_OUTPUT_INFO_CURSOR_POS; ret = !wine_server_call_err( req ); } SERVER_END_REQ; if (!ret || !GetConsoleScreenBufferInfo(hcon, &csbi)) return FALSE; /* if cursor is no longer visible, scroll the visible window... */ w = csbi.srWindow.Right - csbi.srWindow.Left + 1; h = csbi.srWindow.Bottom - csbi.srWindow.Top + 1; if (pos.X < csbi.srWindow.Left) { csbi.srWindow.Left = min(pos.X, csbi.dwSize.X - w); do_move++; } else if (pos.X > csbi.srWindow.Right) { csbi.srWindow.Left = max(pos.X, w) - w + 1; do_move++; } csbi.srWindow.Right = csbi.srWindow.Left + w - 1; if (pos.Y < csbi.srWindow.Top) { csbi.srWindow.Top = min(pos.Y, csbi.dwSize.Y - h); do_move++; } else if (pos.Y > csbi.srWindow.Bottom) { csbi.srWindow.Top = max(pos.Y, h) - h + 1; do_move++; } csbi.srWindow.Bottom = csbi.srWindow.Top + h - 1; ret = (do_move) ? SetConsoleWindowInfo(hcon, TRUE, &csbi.srWindow) : TRUE; return ret; }
int main() { ////////// //Setup/// ////////// srand( (unsigned)time(0) ); Combat* pCombat = new Combat(); Report* pDamageReport = new Report( "damage_report.txt" ); pDamageReport->mFile.open( pDamageReport->getFilename(), ios::out | ios::app ); Report* pInitReport = new Report( "init_report.txt", false, 1 ); pDamageReport->addToReport( "Damage Report\n\n" ); pInitReport->addToReport( "Initialization Report\n\n" ); pDamageReport->mFile.close(); COORD newConsoleSize = {82,45}; //Resized the console so a more detailed output SMALL_RECT rDisplayArea = {0,0,0,0}; //of damage values, criticals, ability names, SetConsoleScreenBufferSize( pCombat->getHandle(), newConsoleSize ); //mana costs, and Damage Over Time ticks rDisplayArea.Right = newConsoleSize.X - 1; //could be seen on screen without scrolling SetConsoleWindowInfo( pCombat->getHandle(), true, &rDisplayArea ); Unit* pPlayer = pCombat->charInit(); Boss* pBoss = new Boss(); pCombat->units = pCombat->enemyInit( GameFunctions::getNumEnemies() ); pInitReport->initReport( pPlayer, pCombat->units ); //Output name, health, mana, armor, abilities and their names and values //for player and units vector of enemies pCombat->storyMsg( pPlayer->getPlayerName() ); stringstream initString; initString << "\nPrinting Story Message. Function call: storyMsg( pPlayer->getPlayerName() )" << "\nSetting up Game Loop variables..." << "\nDetermining Combat Order..." << "\nEntering Game Loop..."; pInitReport->addToReport( initString.str() ); pInitReport->addToReport( "\nStarting Combat..." ); //Final output, switching to Combat report: pDamageReport pCombat->startGameCombat( pPlayer, pBoss, pDamageReport, pCombat->units ); delete pPlayer; pPlayer= NULL; delete pBoss; pBoss = NULL; delete pCombat; pCombat = NULL; delete pDamageReport; pDamageReport = NULL; delete pInitReport; pInitReport = NULL; cin.ignore( 1000, '\n' ); cin.get(); return 0; }
static int init_buffer(HANDLE b) { /* Set console size */ COORD newSize = {W*2, H+1}; SetConsoleScreenBufferSize(b, newSize); SMALL_RECT newWinSize; newWinSize.Left = 0; newWinSize.Top = 0; newWinSize.Right = W*2-1; newWinSize.Bottom = H; return SetConsoleWindowInfo(b, TRUE, &newWinSize); }
void Setting::showWindow() { HANDLE out_handle = GetStdHandle(STD_OUTPUT_HANDLE); SMALL_RECT src = {0, 0, this->getWindowWidth() - 1, this->getWindowHeight() - 1}; SetConsoleWindowInfo (out_handle, true, &src); COORD coord = {this->getWindowWidth(), this->getWindowHeight()}; SetConsoleScreenBufferSize (out_handle, coord); SetConsoleTitle(this->windowTitle.c_str()); std::string buff; buff.append("color"); buff.append(" "); buff.append(this->windowColor); system(buff.c_str()); }
/* Have to remember where i ripped this code sometime ago. */ static void ResizeConsole( HANDLE hConsole, SHORT xSize, SHORT ySize ) { CONSOLE_SCREEN_BUFFER_INFO csbi; // Hold Current Console Buffer Info BOOL bSuccess; SMALL_RECT srWindowRect; // Hold the New Console Size COORD coordScreen; bSuccess = GetConsoleScreenBufferInfo( hConsole, &csbi ); // Get the Largest Size we can size the Console Window to coordScreen = GetLargestConsoleWindowSize( hConsole ); // Define the New Console Window Size and Scroll Position srWindowRect.Right = (SHORT)(min(xSize, coordScreen.X) - 1); srWindowRect.Bottom = (SHORT)(min(ySize, coordScreen.Y) - 1); srWindowRect.Left = srWindowRect.Top = (SHORT)0; // Define the New Console Buffer Size coordScreen.X = xSize; coordScreen.Y = ySize; // If the Current Buffer is Larger than what we want, Resize the // Console Window First, then the Buffer if( (DWORD)csbi.dwSize.X * csbi.dwSize.Y > (DWORD) xSize * ySize) { bSuccess = SetConsoleWindowInfo( hConsole, TRUE, &srWindowRect ); bSuccess = SetConsoleScreenBufferSize( hConsole, coordScreen ); } // If the Current Buffer is Smaller than what we want, Resize the // Buffer First, then the Console Window if( (DWORD)csbi.dwSize.X * csbi.dwSize.Y < (DWORD) xSize * ySize ) { bSuccess = SetConsoleScreenBufferSize( hConsole, coordScreen ); bSuccess = SetConsoleWindowInfo( hConsole, TRUE, &srWindowRect ); } // If the Current Buffer *is* the Size we want, Don't do anything! return; }
/* * call-seq: * io.winsize = [rows, columns] * * Tries to set console size. The effect depends on the platform and * the running environment. * * You must require 'io/console' to use this method. */ static VALUE console_set_winsize(VALUE io, VALUE size) { rb_io_t *fptr; rb_console_size_t ws; #if defined _WIN32 HANDLE wh; int newrow, newcol; #endif VALUE row, col, xpixel, ypixel; #if defined TIOCSWINSZ int fd; #endif GetOpenFile(io, fptr); size = rb_Array(size); rb_scan_args((int)RARRAY_LEN(size), RARRAY_PTR(size), "22", &row, &col, &xpixel, &ypixel); #if defined TIOCSWINSZ fd = GetWriteFD(fptr); ws.ws_row = ws.ws_col = ws.ws_xpixel = ws.ws_ypixel = 0; #define SET(m) ws.ws_##m = NIL_P(m) ? 0 : (unsigned short)NUM2UINT(m) SET(row); SET(col); SET(xpixel); SET(ypixel); #undef SET if (!setwinsize(fd, &ws)) rb_sys_fail(0); #elif defined _WIN32 wh = (HANDLE)rb_w32_get_osfhandle(GetReadFD(fptr)); newrow = (SHORT)NUM2UINT(row); newcol = (SHORT)NUM2UINT(col); if (!getwinsize(GetReadFD(fptr), &ws)) { rb_sys_fail("GetConsoleScreenBufferInfo"); } if ((ws.dwSize.X < newcol && (ws.dwSize.X = newcol, 1)) || (ws.dwSize.Y < newrow && (ws.dwSize.Y = newrow, 1))) { if (!(SetConsoleScreenBufferSize(wh, ws.dwSize) || SET_LAST_ERROR)) { rb_sys_fail("SetConsoleScreenBufferInfo"); } } ws.srWindow.Left = 0; ws.srWindow.Top = 0; ws.srWindow.Right = newcol; ws.srWindow.Bottom = newrow; if (!(SetConsoleWindowInfo(wh, FALSE, &ws.srWindow) || SET_LAST_ERROR)) { rb_sys_fail("SetConsoleWindowInfo"); } #endif return io; }
static void init() { SetConsoleTitleA("CONSOLE PLAYER"); COORD size = {80, 25}; SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), size); SMALL_RECT rect = {0, 0, 80, 25}; SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), false, &rect); fmodwrap::Open(); create_list(); player = fmodwrap::CreatePlayer(); player->set_endcallback(on_play_end); fmodwrap::master_volume(0.5f); current_sound = restore_list_log(); }
void Consola::setScreenSize(int nLinhas, int nCols) { COORD tam; SMALL_RECT DisplayArea; tam.X = nCols; tam.Y = nLinhas; SetConsoleScreenBufferSize(hconsola, tam); // isto muda o tamanho da matriz de caracteres DisplayArea.Top = 0; DisplayArea.Left = 0; DisplayArea.Bottom = nLinhas-1; DisplayArea.Right = nCols-1; SetConsoleWindowInfo(hconsola, TRUE, &DisplayArea); // isto muda o tamanho da area da janela em caracteres }
Console::Console() { Cursor.X = 0; Cursor.Y = 0; ::AllocConsole(); ConsoleHandle = GetStdHandle(STD_OUTPUT_HANDLE); system("mode CON: COLS=100 LINES=135");//画面サイズ設定 freopen("CONIN$","r",stdin); // 標準入力を割り当てる freopen("CONOUT$","w",stdout); // 標準出力を割り当てる SetConsoleTitle("Debug"); SMALL_RECT rect = {0,0,60,20}; SetConsoleWindowInfo(ConsoleHandle,TRUE,&rect); _Active = false; }
void update_handle() { if (_handle == nullptr || _handle == INVALID_HANDLE_VALUE) _handle = ::CreateConsoleScreenBuffer(GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CONSOLE_TEXTMODE_BUFFER, NULL); assert(_handle != INVALID_HANDLE_VALUE); DWORD dwMode = 0; GetConsoleMode(_handle, &dwMode); dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING | ENABLE_PROCESSED_OUTPUT; if (_scroll) dwMode |= ENABLE_WRAP_AT_EOL_OUTPUT; SetConsoleMode(_handle, dwMode); SMALL_RECT rect = { 0,0, short(_width - 1),short(_height - 1) }; SetConsoleWindowInfo(_handle, TRUE,&rect); GetConsoleScreenBufferInfo(_handle, &info); _screen_buffer.resize(_width*_height); }
BOOL CScreen::InitiateScreen(int X, int Y, DWORD cursor_size, BOOL cursor_visable){ m_cScreenSize.X = X; m_cScreenSize.Y = Y; CHAR_INFO tempChar; tempChar.Char.UnicodeChar = ' '; tempChar.Attributes = 0; for(int i = 0; i < X * Y; i++){ m_pDrawn.push_back(tempChar); } SMALL_RECT screenArea; screenArea.Top = 0; screenArea.Left = 0; screenArea.Right = m_cScreenSize.X - 1; screenArea.Bottom = m_cScreenSize.Y - 1; CONSOLE_CURSOR_INFO cursor = {cursor_size, cursor_visable}; m_hBuff1 = GetStdHandle(STD_OUTPUT_HANDLE); m_hBuff2 = CreateConsoleScreenBuffer(GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CONSOLE_TEXTMODE_BUFFER, NULL); SetConsoleScreenBufferSize(m_hBuff1, m_cScreenSize); SetConsoleScreenBufferSize(m_hBuff2, m_cScreenSize); SetConsoleCursorInfo(m_hBuff1, &cursor); SetConsoleCursorInfo(m_hBuff2, &cursor); SetConsoleWindowInfo(m_hBuff1, TRUE, &screenArea); SetConsoleWindowInfo(m_hBuff2, TRUE, &screenArea); m_hpBuffSwap = &m_hBuff2; return TRUE; }
/* LetterSpace: SetConsoleScreenBufferSize and SetConsoleWindowInfo are dependent on each other, that's the reason for the additional checks. */ void ConsoleListener::BufferWidthHeight(int BufferWidth, int BufferHeight, int ScreenWidth, int ScreenHeight, bool BufferFirst) { #ifdef _WIN32 BOOL SB, SW; if (BufferFirst) { // Change screen buffer size COORD Co = {BufferWidth, BufferHeight}; SB = SetConsoleScreenBufferSize(hConsole, Co); // Change the screen buffer window size SMALL_RECT coo = {0,0,ScreenWidth, ScreenHeight}; // top, left, right, bottom SW = SetConsoleWindowInfo(hConsole, TRUE, &coo); } else { // Change the screen buffer window size SMALL_RECT coo = {0,0, ScreenWidth, ScreenHeight}; // top, left, right, bottom SW = SetConsoleWindowInfo(hConsole, TRUE, &coo); // Change screen buffer size COORD Co = {BufferWidth, BufferHeight}; SB = SetConsoleScreenBufferSize(hConsole, Co); } #endif }
VALUE rb_SetConsoleWindowInfo( VALUE self, VALUE hConsoleOutput, VALUE bAbsolute, VALUE left, VALUE top, VALUE right, VALUE bottom ) { HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) ); SMALL_RECT rect; rect.Left = NUM2INT( left ); rect.Top = NUM2INT( top ); rect.Right = NUM2INT( right ); rect.Bottom = NUM2INT( bottom ); if (SetConsoleWindowInfo( handle, NUM2INT( bAbsolute ), &rect )) return UINT2NUM(1); return rb_getWin32Error(); }
void SFDebugConsole::MoveConsole(int x, int y) { Cons_Handle = FindWindow(NULL, CName); if(!Cons_Handle == NULL) MoveWindow(Cons_Handle, 500, 500, 200, 100, true); else { Cons_Handler = GetStdHandle(STD_OUTPUT_HANDLE); SMALL_RECT size = { 0, 0, 200, 100 }; SetConsoleWindowInfo(Cons_Handler, true, &size); COORD coord = { x, y }; SetConsoleCursorPosition(Cons_Handler, coord); } }
void WindowsConsole::setDimensions(short w, short h) { HANDLE hCon = GetStdHandle( STD_OUTPUT_HANDLE ); SMALL_RECT size; COORD b_size; size.Left = 0; size.Top = 0; size.Right = w - 1; size.Bottom = h - 1; b_size.X = w; b_size.Y = h; SetConsoleWindowInfo( hCon , true , & size ); SetConsoleScreenBufferSize( hCon , b_size ); }
void Console::SetWindowPosition(int16_t left, int16_t top) const { // Window position can never be negative if((left < 0) || (top < 0)) throw Exception(E_INVALIDARG); // Adjust the current window SMALL_RECT based on the new left and top SMALL_RECT window = ScreenBufferInfo(*this).srWindow; window.Bottom -= (window.Top - top); window.Right -= (window.Left - left); window.Left = left; window.Top = top; // Attempt to set the new console window position if(!SetConsoleWindowInfo(m_stdout, TRUE, &window)) throw Win32Exception(); }
/****************************************************************** * WCUSER_ApplyCurrent * * */ static void WCUSER_ApplyCurrent(struct dialog_info* di, HWND hDlg, enum WCUSER_ApplyTo apply, DWORD val) { switch (apply) { case WCUSER_ApplyToCursorSize: { CONSOLE_CURSOR_INFO cinfo; cinfo.dwSize = val; cinfo.bVisible = di->config->cursor_visible; /* this shall update (through notif) curcfg */ SetConsoleCursorInfo(di->data->hConOut, &cinfo); } break; case WCUSER_ApplyToHistorySize: di->config->history_size = val; WINECON_SetHistorySize(di->data->hConIn, val); break; case WCUSER_ApplyToHistoryMode: WINECON_SetHistoryMode(di->data->hConIn, val); break; case WCUSER_ApplyToMenuMask: di->config->menu_mask = val; break; case WCUSER_ApplyToEditMode: di->config->quick_edit = val; break; case WCUSER_ApplyToFont: { LOGFONT lf; WCUSER_FillLogFont(&lf, di->font[val].faceName, di->font[val].height, di->font[val].weight); WCUSER_SetFont(di->data, &lf); } break; case WCUSER_ApplyToAttribute: di->config->def_attr = val; SetConsoleTextAttribute(di->data->hConOut, val); break; case WCUSER_ApplyToBufferSize: /* this shall update (through notif) curcfg */ SetConsoleScreenBufferSize(di->data->hConOut, *(COORD*)val); break; case WCUSER_ApplyToWindow: /* this shall update (through notif) curcfg */ SetConsoleWindowInfo(di->data->hConOut, FALSE, (SMALL_RECT*)val); break; } }
void lConsole::ChangeWindowsize(uint16_t Width, uint16_t Height) { _COORD coord; coord.X = Width; coord.Y = Height; _SMALL_RECT Rect; Rect.Top = 0; Rect.Left = 0; Rect.Bottom = Height - 1; Rect.Right = Width - 1; HANDLE Handle = GetStdHandle(STD_OUTPUT_HANDLE); // Get handle. SetConsoleScreenBufferSize(Handle, coord); // Set buffer size. SetConsoleWindowInfo(Handle, TRUE, &Rect); // Set window size. }
//*********************************************************** // This replaces the CXL function of the same name //*********************************************************** void set_lines(int crt_lines) { // COORD dwSize = { 80, crt_lines } ; // SetConsoleScreenBufferSize(hStdOut, dwSize) ; // The preceding method changes the actual buffer size, // not the window size, which may not be what is wanted // under WinNT. This method changes the actual window // size, but positions the new window at the *top* of // the screen buffer, which may give unexpected results // if used with "don't clear screen" in a large window. // Neither method is exactly correct in all cases, // but will probably suffice most times... SMALL_RECT newwin = { 0, 0, 79, crt_lines-1 } ; SetConsoleWindowInfo(hStdOut, TRUE, &newwin) ; }
/* =============================================================================== Funktion: initi() in: - out: - Beschreibung: Initialisiert die Größe des Konsolenfensters =============================================================================== */ void initi(void) { // Konsolenfenstergröße einstellen HANDLE ConsoleHandle = GetStdHandle(STD_OUTPUT_HANDLE); BOOL Result; if (ConsoleHandle != INVALID_HANDLE_VALUE) { SMALL_RECT ConsoleRectangle; // Größe und Position der Konsole in Zeilen und Spalten ConsoleRectangle.Top = 0; ConsoleRectangle.Bottom = 60; ConsoleRectangle.Left = 0; ConsoleRectangle.Right = 75; Result = SetConsoleWindowInfo(ConsoleHandle, TRUE, &ConsoleRectangle); } }
void Config::ConsoleConfig() { //Declare variables HANDLE H; HWND hWnd; //Get handle H = GetStdHandle(STD_OUTPUT_HANDLE); //Set the coordinates for the buffer size COORD UsersCoord = {161, 51}; SetConsoleScreenBufferSize(H, UsersCoord); SMALL_RECT myWindow = {0, 0, 160, 50}; SetConsoleWindowInfo(H, TRUE, &myWindow); //hWnd = GetConsoleWindow(); //ShowWindow(hWnd,SW_SHOWMAXIMIZED); }
void changeSize(){ HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE); COORD coord; BOOL ok; coord.X = WINDOW_WIDTH; coord.Y = WINDOW_HEIGHT + 1; ok = SetConsoleScreenBufferSize(hStdout, coord); SMALL_RECT test = { 0, 0, coord.X - 1, coord.Y - 1 }; SetConsoleWindowInfo(hStdout, ok, &test); }