static int enableRawMode(struct current *current) { DWORD n; INPUT_RECORD irec; current->outh = GetStdHandle(STD_OUTPUT_HANDLE); current->inh = GetStdHandle(STD_INPUT_HANDLE); if (!PeekConsoleInput(current->inh, &irec, 1, &n)) { return -1; } if (getWindowSize(current) != 0) { return -1; } if (GetConsoleMode(current->inh, &orig_consolemode)) { SetConsoleMode(current->inh, ENABLE_PROCESSED_INPUT); } return 0; }
static void installsighandler() { #ifndef _WIN32 signal(SIGHUP,sighandler); signal(SIGUSR1,sighandler); signal(SIGPIPE,sighandler); #endif signal(SIGINT,sighandler); #ifdef _WIN32 SetConsoleCtrlHandler(ConsoleCtrlHandler,true); HANDLE hs=GetStdHandle(STD_INPUT_HANDLE); DWORD mode; if (GetConsoleMode(hs,&mode)) { mode|=ENABLE_PROCESSED_INPUT; SetConsoleMode(hs,mode); }; #endif }
extern void ConsoleInit(void) { CONSOLE_CURSOR_INFO cci; int i; /* コンソール標準出力画面のハンドルを取得。プログラム終了時にアクティブ化 */ m_hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); if (m_hStdOut == INVALID_HANDLE_VALUE) { fprintf(stderr, "error: Console: InitConsole: hStdOut: %ld\n", GetLastError()); } /* コンソールスクリーンの作成と初期化 */ for (i=0; i<NUM_SCREEN_MAX; i++) { m_hScreen[i] = CreateConsoleScreenBuffer( GENERIC_READ | GENERIC_WRITE, 0, NULL, CONSOLE_TEXTMODE_BUFFER, NULL ); if (m_hScreen[i] == INVALID_HANDLE_VALUE) { fprintf(stderr, "error: Console: InitConsole: %ld\n", GetLastError()); } /* カーソル情報の初期化 */ GetConsoleCursorInfo(m_hScreen[i], &cci); cci.bVisible = FALSE;// カーソルの非表示 SetConsoleCursorInfo(m_hScreen[i], &cci); /* ウィンドウサイズの初期化 */ SetWindowSize(m_hScreen[i], NUM_WINDOW_HEIGHT, NUM_WINDOW_WIDTH); /* コンソールモードの初期化 */ SetConsoleMode(m_hScreen[i], ENABLE_PROCESSED_OUTPUT); } m_hScreenIndex = 0; m_hOut = m_hScreen[1]; m_hWork = m_hScreen[0]; SetConsoleActiveScreenBuffer(m_hOut);// 出力スクリーンをアクティブ化 }
/* initialize console */ void oss_con_init(void) { DWORD new_console_mode; OSVERSIONINFO ver_info; /* get the console input and output handles */ G_out_bufhdl = GetStdHandle(STD_OUTPUT_HANDLE); G_in_bufhdl = GetStdHandle(STD_INPUT_HANDLE); /* get the original console mode so we can restore it when we're done */ GetConsoleMode(G_out_bufhdl, &S_orig_console_out_mode); GetConsoleMode(G_in_bufhdl, &S_orig_console_in_mode); /* if we're in 'plain' mode, don't change the console mode */ if (os_f_plain) return; /* start with the original console mode bits */ new_console_mode = S_orig_console_out_mode; /* * Turn off wrapping when writing at the end of the line - the * automatic wrapping screws up our scrolling, and we don't need it * anyway since we keep track of all of our cursor positioning * ourselves, hence it's easier if we just turn this feature off */ new_console_mode &= ~ENABLE_WRAP_AT_EOL_OUTPUT; /* * If we're on a 95 derivative (95, 98, ME), also clear the "processed * output" flag. This flag is necessary on NT for proper character * set handling, but is not on 95/98/ME; and if that flag isn't * cleared on 95/98/ME, clearing the wrap-at-eol flag has no effect. * So, we must clear this flag on 95/98/ME, but we must leave it * enabled on NT. (What a pain.) */ ver_info.dwOSVersionInfoSize = sizeof(ver_info); GetVersionEx(&ver_info); if (ver_info.dwPlatformId != VER_PLATFORM_WIN32_NT) new_console_mode &= ~ENABLE_PROCESSED_OUTPUT; /* set the new console mode */ SetConsoleMode(G_out_bufhdl, new_console_mode); }
/*--------------------------------------------------------------------------*/ void InitializeTerminal(void) { if (!Win32InputStream) { Win32InputStream = GetStdHandle(STD_INPUT_HANDLE); GetConsoleMode(Win32InputStream, &OldWin32Mode); SetConsoleMode(Win32InputStream, ENABLE_PROCESSED_INPUT); } if (!Win32OutputStream) { Win32OutputStream = GetStdHandle(STD_OUTPUT_HANDLE); } setFocusOnConsole(); SetConsoleCtrlHandler( (PHANDLER_ROUTINE) CtrlHandler, TRUE ); }
/* ================== CON_Init ================== */ void CON_Init (void) { CONSOLE_CURSOR_INFO curs; CONSOLE_SCREEN_BUFFER_INFO info; int i; // handle Ctrl-C or other console termination SetConsoleCtrlHandler(CON_CtrlHandler, TRUE); qconsole_hin = GetStdHandle(STD_INPUT_HANDLE); if (qconsole_hin == INVALID_HANDLE_VALUE) return; qconsole_hout = GetStdHandle(STD_OUTPUT_HANDLE); if (qconsole_hout == INVALID_HANDLE_VALUE) return; GetConsoleMode(qconsole_hin, &qconsole_orig_mode); // allow mouse wheel scrolling SetConsoleMode(qconsole_hin, qconsole_orig_mode & ~ENABLE_MOUSE_INPUT); FlushConsoleInputBuffer(qconsole_hin); GetConsoleScreenBufferInfo(qconsole_hout, &info); qconsole_attrib = info.wAttributes; qconsole_backgroundAttrib = qconsole_attrib & (BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_INTENSITY); SetConsoleTitle("Dedicated Server Console"); // make cursor invisible GetConsoleCursorInfo(qconsole_hout, &qconsole_orig_cursorinfo); curs.dwSize = 1; curs.bVisible = FALSE; SetConsoleCursorInfo(qconsole_hout, &curs); // initialize history for (i = 0; i < QCONSOLE_HISTORY; i++) qconsole_history[i][0] = '\0'; // set text color to white SetConsoleTextAttribute(qconsole_hout, CON_ColorCharToAttrib(COLOR_WHITE)); }
WindowsInputController::WindowsInputController() { HANDLE hStdin; DWORD fdwMode, fdwSaveOldMode; // Get the standard input handle. hStdin = GetStdHandle( STD_INPUT_HANDLE ); if( hStdin == INVALID_HANDLE_VALUE ) return; // Save the current input mode, to be restored on exit. if( !GetConsoleMode(hStdin, &fdwSaveOldMode) ) return; // Enable the window and mouse input events. fdwMode = ENABLE_WINDOW_INPUT | ENABLE_MOUSE_INPUT; if( !SetConsoleMode(hStdin, fdwMode) ) return; }
DWORD CPequote::Start() { //CEgRegKey key; CModuleVersion ver; TCHAR pModName [1024] = { 0 }; TCHAR pVer[100] = { 0 }; //detecting the module version ::GetModuleFileName( NULL, pModName, sizeof(pModName)/sizeof(TCHAR)); ver.GetModuleVersionInfo(pModName); ver.GetValue(_T("ProductVersion"), pVer); DWORD dwFlags; if(GetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), &dwFlags)) { dwFlags &= ~(ENABLE_QUICK_EDIT | ENABLE_INSERT_MODE); SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), dwFlags); } m_hStopApplication = ::CreateEvent(NULL, TRUE, FALSE, NULL); if (!m_hStopApplication) { return TraceError(); } if (!::SetConsoleCtrlHandler(HandlerRoutine, TRUE)) return TraceError(); CTracer::TraceMessage(CTracer::enMtInformation, NULL, _T("Starting Pequote connector...")); DWORD dwRes = m_PequoteConnector.Start(NULL); if (dwRes) { CTracer::TraceMessage(CTracer::enMtError, NULL, _T("Failed to start Pequote connector.")); return dwRes; } CTracer::TraceMessage(CTracer::enMtInformation, NULL, _T("Pequote connector started.")); CTracer::TraceMessage(CTracer::enMtInformation, NULL, _T("Server started.")); return 0; }
static int noecho_console(UI *ui) { #ifdef TTY_FLAGS memcpy(&(tty_new), &(tty_orig), sizeof(tty_orig)); tty_new.TTY_FLAGS &= ~ECHO; #endif #if defined(TTY_set) && !defined(OPENSSL_SYS_VMS) if (is_a_tty && (TTY_set(fileno(tty_in), &tty_new) == -1)) return 0; #endif #ifdef OPENSSL_SYS_VMS if (is_a_tty) { tty_new[0] = tty_orig[0]; tty_new[1] = tty_orig[1] | TT$M_NOECHO; tty_new[2] = tty_orig[2]; status = sys$qiow(0, channel, IO$_SETMODE, &iosb, 0, 0, tty_new, 12, 0, 0, 0, 0); if ((status != SS$_NORMAL) || (iosb.iosb$w_value != SS$_NORMAL)) { char tmp_num[2][12]; BIO_snprintf(tmp_num[0], sizeof(tmp_num[0]) - 1, "%%X%08X", status); BIO_snprintf(tmp_num[1], sizeof(tmp_num[1]) - 1, "%%X%08X", iosb.iosb$w_value); UIerr(UI_F_NOECHO_CONSOLE, UI_R_SYSQIOW_ERROR); ERR_add_error_data(5, "status=", tmp_num[0], ",", "iosb.iosb$w_value=", tmp_num[1]); return 0; } } #endif #if defined(_WIN32) && !defined(_WIN32_WCE) if (is_a_tty) { tty_new = tty_orig; tty_new &= ~ENABLE_ECHO_INPUT; SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), tty_new); } #endif return 1; }
/* * initialize the terminal data structures. */ void init_terminal(void) { if (ttyoring.init(2*BUFSIZ, ttysink, NULL) != 1) { exit(1); } if (ttyiring.init(BUFSIZ, NULL, ttysrc) != 1) { exit(1); } autoflush = TerminalAutoFlush(); #ifdef __WIN32__ /* * Set the console mode. This will only have an effect if the * handle is a console handle */ HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); #if 0 printf("1. Calling SetConsoleMode(0x%08x, 0x%08x)\n", hOut, ENABLE_PROCESSED_OUTPUT|ENABLE_WRAP_AT_EOL_OUTPUT); #endif SetConsoleMode(hOut, ENABLE_PROCESSED_OUTPUT|ENABLE_WRAP_AT_EOL_OUTPUT); #endif }
void stdin_echo(bool enable) { #ifdef WIN32 HANDLE hStdin=GetStdHandle(STD_INPUT_HANDLE); DWORD mode; GetConsoleMode(hStdin,&mode); if(!enable) mode&=~ENABLE_ECHO_INPUT; else mode|=ENABLE_ECHO_INPUT; SetConsoleMode(hStdin, mode ); #else struct termios tty; tcgetattr(STDIN_FILENO,&tty); if(!enable) tty.c_lflag&=~ECHO; else tty.c_lflag|=ECHO; tcsetattr(STDIN_FILENO,TCSANOW,&tty); #endif }
static void termset(void) { DWORD flag; if(donetermset) return; donetermset = 1; conh = GetStdHandle(STD_OUTPUT_HANDLE); kbdh = GetStdHandle(STD_INPUT_HANDLE); errh = GetStdHandle(STD_ERROR_HANDLE); if(errh == INVALID_HANDLE_VALUE) errh = conh; // The following will fail if kbdh not from console (e.g. a pipe) // in which case we don't care GetConsoleMode(kbdh, &consolestate); flag = consolestate; flag = flag & ~(ENABLE_PROCESSED_INPUT|ENABLE_LINE_INPUT|ENABLE_ECHO_INPUT); SetConsoleMode(kbdh, flag); }
/** get a character from the terminal */ int mygetch(void) { #if !defined(_WIN32) || !defined(__CYGWIN__) /* longjmp won't work, it's in a different thread */ sighandler_t savesig; /* old value of signal */ #endif int c; /* change an interrupt signal to a break key character */ if (setjmp(env) == 0) { #if defined(_WIN32) && !defined(__CYGWIN__) /* turn off Ctrl+C handling (PDCurses does this, but it gets turned on again by CMD during system) */ SetConsoleMode( GetStdHandle( STD_INPUT_HANDLE ), 0 ); #else savesig = signal(SIGINT, catchint); #endif refresh(); /* update the display */ mousereinit(); /* curses can change the menu number */ if(prevchar) { c = prevchar; prevchar = 0; } else { c = -1; while (c == -1) { /* get a character from the terminal */ c = getch(); if ((c == -1) && (errno != EINTR)) break; } } } else { /* longjmp to here from signal handler */ c = KEY_BREAK; } #if !defined(_WIN32) || !defined(__CYGWIN__) signal(SIGINT, savesig); #endif return(c); }
/* ================== CON_Init ================== */ void CON_Init( void ) { CONSOLE_SCREEN_BUFFER_INFO info; char consoleTitle[128]; int i; // handle Ctrl-C or other console termination SetConsoleCtrlHandler( CON_CtrlHandler, TRUE ); qconsole_hin = GetStdHandle( STD_INPUT_HANDLE ); if( qconsole_hin == INVALID_HANDLE_VALUE ) return; qconsole_hout = GetStdHandle( STD_OUTPUT_HANDLE ); if( qconsole_hout == INVALID_HANDLE_VALUE ) return; GetConsoleMode( qconsole_hin, &qconsole_orig_mode ); // allow mouse wheel scrolling SetConsoleMode( qconsole_hin, qconsole_orig_mode & ~ENABLE_MOUSE_INPUT ); FlushConsoleInputBuffer( qconsole_hin ); GetConsoleScreenBufferInfo( qconsole_hout, &info ); qconsole_attrib = info.wAttributes; qconsole_backgroundAttrib = qconsole_attrib & (BACKGROUND_BLUE|BACKGROUND_GREEN|BACKGROUND_RED|BACKGROUND_INTENSITY); // ZTM: FIXME: com_productName isn't initialized or set to game title yet. Com_sprintf( consoleTitle, sizeof (consoleTitle), "%s Dedicated Server Console", com_productName ? com_productName->string : PRODUCT_NAME ); SetConsoleTitle( consoleTitle ); // initialize history for( i = 0; i < QCONSOLE_HISTORY; i++ ) qconsole_history[ i ][ 0 ] = '\0'; // set text color to white SetConsoleTextAttribute( qconsole_hout, CON_ColorCharToAttrib( COLOR_WHITE ) ); }
static char * readpassphrase(const char *prompt, char *buf, size_t bufsiz, int flags) { HANDLE hStdin, hStdout; DWORD mode, rbytes; BOOL success; (void)flags; hStdin = GetStdHandle(STD_INPUT_HANDLE); if (hStdin == INVALID_HANDLE_VALUE) return (NULL); hStdout = GetStdHandle(STD_OUTPUT_HANDLE); if (hStdout == INVALID_HANDLE_VALUE) return (NULL); success = GetConsoleMode(hStdin, &mode); if (!success) return (NULL); mode &= ~ENABLE_ECHO_INPUT; mode |= ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT; success = SetConsoleMode(hStdin, mode); if (!success) return (NULL); success = WriteFile(hStdout, prompt, (DWORD)strlen(prompt), NULL, NULL); if (!success) return (NULL); success = ReadFile(hStdin, buf, (DWORD)bufsiz - 1, &rbytes, NULL); if (!success) return (NULL); WriteFile(hStdout, "\r\n", 2, NULL, NULL); buf[rbytes] = '\0'; /* Remove trailing carriage return(s). */ if (rbytes > 2 && buf[rbytes - 2] == '\r' && buf[rbytes - 1] == '\n') buf[rbytes - 2] = '\0'; return (buf); }
/* ================== CON_Init ================== */ void CON_Init( void ) { CONSOLE_CURSOR_INFO curs; CONSOLE_SCREEN_BUFFER_INFO info; int i; // handle Ctrl-C or other console termination SetConsoleCtrlHandler( CON_CtrlHandler, TRUE ); qconsole_hin = GetStdHandle( STD_INPUT_HANDLE ); if( qconsole_hin == INVALID_HANDLE_VALUE ) return; qconsole_hout = GetStdHandle( STD_OUTPUT_HANDLE ); if( qconsole_hout == INVALID_HANDLE_VALUE ) return; GetConsoleMode( qconsole_hin, &qconsole_orig_mode ); // allow mouse wheel scrolling SetConsoleMode( qconsole_hin, qconsole_orig_mode & ~ENABLE_MOUSE_INPUT ); FlushConsoleInputBuffer( qconsole_hin ); GetConsoleScreenBufferInfo( qconsole_hout, &info ); qconsole_attrib = info.wAttributes; SetConsoleTitle("ioquake3 Dedicated Server Console"); // make cursor invisible GetConsoleCursorInfo( qconsole_hout, &qconsole_orig_cursorinfo ); curs.dwSize = 1; curs.bVisible = FALSE; SetConsoleCursorInfo( qconsole_hout, &curs ); // initialize history for( i = 0; i < QCONSOLE_HISTORY; i++ ) qconsole_history[ i ][ 0 ] = '\0'; }
int ty_terminal_setup(int flags) { HANDLE handle; DWORD mode; BOOL r; handle = GetStdHandle(STD_INPUT_HANDLE); if (handle == INVALID_HANDLE_VALUE) return ty_error(TY_ERROR_SYSTEM, "GetStdHandle(STD_INPUT_HANDLE) failed"); r = GetConsoleMode(handle, &mode); if (!r) { if (GetLastError() == ERROR_INVALID_HANDLE) return ty_error(TY_ERROR_UNSUPPORTED, "Not a terminal"); return ty_error(TY_ERROR_SYSTEM, "GetConsoleMode(STD_INPUT_HANDLE) failed: %s", ty_win32_strerror(0)); } if (!saved_console_mode) { orig_console_mode = mode; saved_console_mode = true; atexit(ty_terminal_restore); } mode |= ENABLE_PROCESSED_INPUT; mode &= (DWORD)~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT); if (!(flags & TY_TERMINAL_RAW)) mode |= ENABLE_LINE_INPUT; if (!(flags & TY_TERMINAL_SILENT)) mode |= ENABLE_ECHO_INPUT; r = SetConsoleMode(handle, mode); if (!r) return ty_error(TY_ERROR_SYSTEM, "SetConsoleMode(STD_INPUT_HANDLE) failed: %s", ty_win32_strerror(0)); return 0; }
bool input_waiting() { #ifndef WIN32 fd_set readfds; struct timeval tv; FD_ZERO(&readfds); FD_SET(fileno(stdin), &readfds); tv.tv_sec = 0; tv.tv_usec = 0; select(16, &readfds, nullptr, nullptr, &tv); return (FD_ISSET(fileno(stdin), &readfds)); #else static int init = 0, pipe; static HANDLE inh; DWORD dw; if(!init) { init = 1; inh = GetStdHandle(STD_INPUT_HANDLE); pipe = !GetConsoleMode(inh, &dw); if(!pipe) { SetConsoleMode(inh, dw & ~(ENABLE_MOUSE_INPUT|ENABLE_WINDOW_INPUT)); FlushConsoleInputBuffer(inh); } } if(pipe) { if(!PeekNamedPipe(inh, NULL, 0, NULL, &dw, NULL)) return 1; return dw; } else { GetNumberOfConsoleInputEvents(inh, &dw); return dw <= 1 ? 0 : dw; } #endif // WIN32 }
void FileTests::TestReadFileBasicSync() { HANDLE const hIn = GetStdInputHandle(); VERIFY_IS_NOT_NULL(hIn, L"Verify we have the standard input handle."); DWORD dwMode = 0; VERIFY_WIN32_BOOL_SUCCEEDED(SetConsoleMode(hIn, dwMode), L"Set input mode for test."); VERIFY_WIN32_BOOL_SUCCEEDED(FlushConsoleInputBuffer(hIn), L"Flush input buffer in preparation for test."); char const chExpected = 'a'; Log::Comment(L"Send a key into the console."); SendFullKeyStrokeHelper(hIn, chExpected); char ch = '\0'; Log::Comment(L"Read with synchronous blocking read."); DWORD dwRead = 0; VERIFY_WIN32_BOOL_SUCCEEDED(ReadFile(hIn, &ch, 1, &dwRead, nullptr), L"Read file was successful."); VERIFY_ARE_EQUAL(1u, dwRead, L"Verify we read 1 character."); VERIFY_ARE_EQUAL(chExpected, ch); }
void CMap::SetDefault() { // This is the desired size of our window SMALL_RECT newSize = {0, 0, kMapWidth - 1, kMapHeight - 1}; HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE); // Get a OUTPUT handle to our screen. HANDLE hInput = GetStdHandle(STD_INPUT_HANDLE); // Get a INPUT handle to our screen. // We actually change our window size from the normal size of (80, 15} to {80, 45}. SetConsoleWindowInfo(hOutput, TRUE, &newSize); // Next we want to be able to have mouse input and other keyboard input SetConsoleMode(hInput, ENABLE_PROCESSED_INPUT | ENABLE_MOUSE_INPUT); // Make sure we clear and release all the data with our global lists m_vTiles.clear(); m_vItems.clear(); m_vMonsters.clear(); m_vNpcs.clear(); m_vExits.clear(); // Reset the current map's name strcpy(m_szMapName, ""); }
int main(int argc, char const *argv[]) { if(argc < 3) { cout << "Usage: encryptor InputFileName OutputFileName" << endl << "Terminating..." << endl; return 0; } //Text hiding method by guestgulkan on cplusplus forum HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE); DWORD mode = 0; GetConsoleMode(hStdin, &mode); SetConsoleMode(hStdin, mode & (~ENABLE_ECHO_INPUT)); string key; string input; string output; FileHandler inputFile(true); if(!inputFile.setFileName(argv[1])) { return 0; } FileHandler outputFile(false); outputFile.setFileName(argv[2]); cout << "Please enter your session key:" << endl; getline(cin, key); input = *inputFile.get(); Encryptor enc(key, input); output = enc.crypt(); outputFile.write(output); return 0; }
void Apep::initialize(std::string name, int width_ = 80, int height_ = 60) { tin = GetStdHandle(STD_INPUT_HANDLE); tout = GetStdHandle(STD_OUTPUT_HANDLE); SetConsoleTitle(name.c_str()); { // hide console cursor CONSOLE_CURSOR_INFO cci; GetConsoleCursorInfo(tout, &cci); cci.bVisible = false; cci.dwSize = 1; SetConsoleCursorInfo(tout, &cci); } width = width_; height = height_; assert("width must be > 1!" && width > 1); assert("height must be > 1!" && height > 1); // resizing console window { SMALL_RECT cs = { 0, 0, width - 1, height - 1 }; consoleSize = cs; COORD bs = { width, height }; buffSize = bs; SetConsoleWindowInfo(tout, TRUE, &consoleSize); SetConsoleScreenBufferSize(tout, buffSize); } { // turning off showing keys being pressed DWORD mode; GetConsoleMode(tin, &mode); SetConsoleMode(tin, mode & ~ENABLE_ECHO_INPUT); } // allocating back buffer total_size = width * height; back_buffer = new CHAR_INFO[total_size]; }
void FileTests::TestReadFileLine() { HANDLE const hIn = GetStdInputHandle(); VERIFY_IS_NOT_NULL(hIn, L"Verify we have the standard input handle."); DWORD dwMode = ENABLE_LINE_INPUT; VERIFY_WIN32_BOOL_SUCCEEDED(SetConsoleMode(hIn, dwMode), L"Set input mode for test."); VERIFY_WIN32_BOOL_SUCCEEDED(FlushConsoleInputBuffer(hIn), L"Flush input buffer in preparation for test."); char ch = '\0'; Log::Comment(L"Queue background blocking read file operation."); auto BackgroundRead = std::async([&] { DWORD dwRead = 0; VERIFY_WIN32_BOOL_SUCCEEDED(ReadFile(hIn, &ch, 1, &dwRead, nullptr), L"Read file was successful."); VERIFY_ARE_EQUAL(1u, dwRead, L"Verify we read 1 character."); }); char const chExpected = 'a'; Log::Comment(L"Send a key into the console."); SendFullKeyStrokeHelper(hIn, chExpected); auto status = BackgroundRead.wait_for(std::chrono::milliseconds(250)); VERIFY_ARE_EQUAL(std::future_status::timeout, status, L"We should still be waiting for a result."); VERIFY_ARE_EQUAL('\0', ch, L"Character shouldn't be filled by background read yet."); Log::Comment(L"Send a line feed character, we should stay blocked."); SendFullKeyStrokeHelper(hIn, '\n'); status = BackgroundRead.wait_for(std::chrono::milliseconds(250)); VERIFY_ARE_EQUAL(std::future_status::timeout, status, L"We should still be waiting for a result."); VERIFY_ARE_EQUAL('\0', ch, L"Character shouldn't be filled by background read yet."); Log::Comment(L"Now send a carriage return into the console to signify the end of the input line."); SendFullKeyStrokeHelper(hIn, '\r'); Log::Comment(L"Wait for background thread to unblock."); BackgroundRead.wait(); VERIFY_ARE_EQUAL(chExpected, ch); }
/* Turn off buffering on stdin. */ void add_anykey(void) { #ifdef _WIN32 stdin_handle = GetStdHandle(STD_INPUT_HANDLE); if (!GetConsoleMode(stdin_handle, &stdin_mode)) { /* TODO: Error handling. */ } SetConsoleMode(stdin_handle, 0); #else struct termios term; tcgetattr(STDIN_FILENO, &term); memcpy(&term_orig, &term, sizeof(struct termios)); term.c_lflag &= ~(ECHO | ICANON | ISIG); tcsetattr(STDIN_FILENO, TCSADRAIN, &term); #endif sr_session_source_add(STDIN_FILENO, G_IO_IN, -1, received_anykey, NULL); printf("Press any key to stop acquisition.\n"); }
void FileTests::TestReadFileLineSync() { HANDLE const hIn = GetStdInputHandle(); VERIFY_IS_NOT_NULL(hIn, L"Verify we have the standard input handle."); DWORD dwMode = ENABLE_LINE_INPUT; VERIFY_WIN32_BOOL_SUCCEEDED(SetConsoleMode(hIn, dwMode), L"Set input mode for test."); VERIFY_WIN32_BOOL_SUCCEEDED(FlushConsoleInputBuffer(hIn), L"Flush input buffer in preparation for test."); char const chExpected = 'a'; Log::Comment(L"Send a key into the console followed by a carriage return."); SendFullKeyStrokeHelper(hIn, chExpected); SendFullKeyStrokeHelper(hIn, '\r'); char ch = '\0'; Log::Comment(L"Read back the input with a synchronous blocking read."); DWORD dwRead = 0; VERIFY_WIN32_BOOL_SUCCEEDED(ReadFile(hIn, &ch, 1, nullptr, nullptr), L"Read file was successful."); VERIFY_ARE_EQUAL(0u, dwRead, L"Verify we read 0 characters."); VERIFY_ARE_EQUAL(chExpected, ch); }
bool Util::enableConsoleEcho(const bool enable) { bool originalValue = true; #ifdef Q_OS_WIN DWORD mode; HANDLE hConIn = GetStdHandle( STD_INPUT_HANDLE ); GetConsoleMode( hConIn, &mode ); originalValue = (mode & (ENABLE_ECHO_INPUT)); mode = enable ? (mode | ENABLE_ECHO_INPUT ) : (mode & ~(ENABLE_ECHO_INPUT)); SetConsoleMode( hConIn, mode ); #else struct termios settings; tcgetattr( STDIN_FILENO, &settings ); originalValue = (settings.c_lflag & (ECHO)); settings.c_lflag = enable ? (settings.c_lflag | ECHO ) : (settings.c_lflag & ~(ECHO)); tcsetattr( STDIN_FILENO, TCSANOW, &settings ); #endif return originalValue; }
// returns a char of the current key pressed char Console::InputChar() { SetConsoleMode(hInput, ENABLE_PROCESSED_INPUT); // check to see if there are any input records GetNumberOfConsoleInputEvents(hInput,&charsRead); // get input if (charsRead > 0) { ReadConsoleInput(hInput,&InputRecords[0],255,&charsRead); for(int Count = charsRead; Count >= 0; --Count) { if (InputRecords[Count].EventType == KEY_EVENT) { if (InputRecords[Count].Event.KeyEvent.bKeyDown != 0) return InputRecords[Count].Event.KeyEvent.uChar.AsciiChar; } } // if we didn't get anything return 0; } else return 0; }
void CConsole::initconsole() { conin = GetStdHandle(STD_INPUT_HANDLE); conout = GetStdHandle(STD_OUTPUT_HANDLE); ZeroMemory(&ovc,sizeof(ovc)); ovc.hEvent = CreateEvent(NULL,FALSE,FALSE,NULL); if(ovc.hEvent == INVALID_HANDLE_VALUE) { throw errors("CreateEvent error"); } SetConsoleMode(conin,ENABLE_MOUSE_INPUT); GetConsoleScreenBufferInfo(conout,&csb); if (csb.dwSize.X<80||csb.dwSize.Y<25){ CloseHandle(ovc.hEvent); throw errors("console size is too small"); } FlushConsoleInputBuffer(conin); head=tail=0; cci.bVisible=0;cci.dwSize=10; SetConsoleCursorInfo(conout,&cci); SetConsoleTitle(jmail); }
BOOL consoleSetMode ( KBDMODE Mode ) /*++ Routine Description: Sets the console mode. Arguments: Mode - Supplies the mode flags. Return Value: TRUE if success, FALSE otherwise --*/ { return SetConsoleMode( hInput, Mode ); }
/* * cuiInitialize * * Purpose: * * Initialize console input/output. * */ VOID cuiInitialize( _In_ BOOL InitInput, _Out_opt_ PBOOL IsConsoleOutput ) { ULONG dummy; g_ConOut = GetStdHandle(STD_OUTPUT_HANDLE); if (InitInput) g_ConIn = GetStdHandle(STD_INPUT_HANDLE); SetConsoleMode(g_ConOut, ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT | ENABLE_PROCESSED_OUTPUT); g_ConsoleOutput = TRUE; if (!GetConsoleMode(g_ConOut, &dummy)) { g_ConsoleOutput = FALSE; WriteFile(g_ConOut, &g_BE, sizeof(WCHAR), &dummy, NULL); } if (IsConsoleOutput) *IsConsoleOutput = g_ConsoleOutput; return; }