コード例 #1
0
ファイル: liblinenoise.c プロジェクト: h3rald/ickle
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;
}
コード例 #2
0
ファイル: srvmain.cpp プロジェクト: vattay/waste
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
}
コード例 #3
0
ファイル: Console.c プロジェクト: uranosan/noplan-part58
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);// 出力スクリーンをアクティブ化
}
コード例 #4
0
ファイル: ossdos32.c プロジェクト: BPaden/garglk
/* 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);
}
コード例 #5
0
ファイル: TermConsole.c プロジェクト: ZhanlinWang/scilab
/*--------------------------------------------------------------------------*/
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 );

}
コード例 #6
0
ファイル: con_win32.c プロジェクト: raynorpat/cake
/*
==================
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));
}
コード例 #7
0
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; 
 
}
コード例 #8
0
ファイル: PequoteImpl.cpp プロジェクト: AlexS2172/IVRM
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;
}
コード例 #9
0
ファイル: ui_openssl.c プロジェクト: AlexanderPankiv/node
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;
}
コード例 #10
0
ファイル: terminal.cpp プロジェクト: gordonchaffee/expectnt
/*
 * 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
}
コード例 #11
0
ファイル: console.cpp プロジェクト: mrmoss/enano
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
}
コード例 #12
0
ファイル: os.c プロジェクト: 8l/inferno
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);
}
コード例 #13
0
ファイル: input.c プロジェクト: libaoyuan242/emacs_config
/** 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);
}
コード例 #14
0
ファイル: con_win32.c プロジェクト: mecwerks/spearmint
/*
==================
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 ) );
}
コード例 #15
0
ファイル: passphrase.c プロジェクト: KitoHo/libarchive
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);
}
コード例 #16
0
/*
==================
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';
}
コード例 #17
0
ファイル: system_win32.c プロジェクト: seem-sky/ty
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;
}
コード例 #18
0
ファイル: misc.cpp プロジェクト: ServerTech/cortex
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
}
コード例 #19
0
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);
}
コード例 #20
0
ファイル: Map.cpp プロジェクト: 88er/tutorials
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, "");
}
コード例 #21
0
ファイル: main.cpp プロジェクト: jonnyniv/rc4_encryptor
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;
}
コード例 #22
0
ファイル: apep_engine.cpp プロジェクト: rAum/asciihack
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];
}
コード例 #23
0
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);
}
コード例 #24
0
ファイル: anykey.c プロジェクト: gsmcmullin/sigrok
/* 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");
}
コード例 #25
0
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);
}
コード例 #26
0
ファイル: util.cpp プロジェクト: CMon/recipes
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;
}
コード例 #27
0
ファイル: Console.cpp プロジェクト: cwilkens/mortimer-maxwell
// 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;
}
コード例 #28
0
ファイル: console.cpp プロジェクト: inspirer/history
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);
}
コード例 #29
0
ファイル: console.c プロジェクト: mingpen/OpenNT
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 );
}
コード例 #30
0
ファイル: cui.c プロジェクト: hfiref0x/SXSEXP
/*
* 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;
}