CConsole.cpp

[詳解]

//=============================================================================
/// @file
/// コンソール入出力クラス実装コンソール
///
/// コンソール入出力クラス実装コンソールです。
///
/// $Id: CConsole.cpp 245 2019-03-20 15:03:41Z admin $
/// $Date: 2019-03-21 00:03:41 +0900 (2019/03/21 (木)) $
/// $Author: admin $
///
/// @attention なし

#pragma managed( push, off )

//=============================================================================
// インクルードファイル
#include <CConsole.h>
#include <CSyncAuto.h>
#include <CTimer.h>
#include <LibUtility.h>

//=============================================================================
// 共通ライブラリ名前空間
namespace LibCommon {
    //=========================================================================
    // コンソール入出力クラス
    //=========================================================================
    // 構築子と解体子
    //-------------------------------------------------------------------------
    // コンストラクタ
    CConsole::CConsole() noexcept
        // 基底クラスコンストラクタ
        : CMutex()
        , CStream()
        // メンバ変数初期化
        , m_szBuffer()
        , m_sRecordBuffer()
        , m_nRecordPos( 0 )
        , m_nRecordCount( 0 )
        , m_sMaxCursor()
        , m_cThreadSub()
        , m_bStopInput( false )
    {
        // コンストラクタ実行通知
        NotifyConstructor();

        // ミューテックスを作成する
        if ( !CMutex::Create() ) {
            // 致命的エラー！
            NotifyFatalError();
        }
        // サブスレッドを起動する
        else if ( !m_cThreadSub.Create( SubThreadProc, this ) ) {
            // 致命的エラー！
            NotifyFatalError();
        }
    }

    //-------------------------------------------------------------------------
    // デストラクタ
    CConsole::~CConsole() noexcept {
        // デストラクタ実行通知
        NotifyDestructor();

        // サブスレッドをクローズする
        m_cThreadSub.Close();
    }

    //=========================================================================
    // 公開関数
    //-------------------------------------------------------------------------
    // 文字列出力関数
    bool CConsole::OutputString( wchar_t const* pszString ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 文字列ポインタを調べる
            if ( nullptr == pszString ) {
                // 失敗！
                break;
            }

            // 標準出力ハンドルを取得する
            HANDLE hOutput = ::GetStdHandle( STD_OUTPUT_HANDLE );

            // 文字列長を取得する
            int nCount = static_cast< int >( ::wcslen( pszString ) );
            if ( BUFFER_SIZE >= nCount ) {
                // 標準出力に文字列出力する
                ::WriteConsoleW( hOutput, pszString, static_cast< DWORD >( nCount ), nullptr, nullptr );
            }
            // 巡回する
            else for ( int nIndex = 0, nSize = 0; nCount > nIndex; nIndex += nSize, nCount -= nSize ) {
                // １回に出力する文字数を取得する
                if ( BUFFER_SIZE > nCount ) {
                    nSize = nCount;
                }
                else {
                    nSize = BUFFER_SIZE;
                }

                // 文字列バッファにコピーする
                ::wcsncpy_s( m_szBuffer, &pszString[ nIndex ], nSize );

                // 終端文字コードを設定する
                m_szBuffer[ nSize ] = L'\0';

                // 標準出力に文字列出力する
                ::WriteConsoleW( hOutput, m_szBuffer, static_cast< DWORD >( nSize ), nullptr, nullptr );
            }

            // カーソル位置を取得する
            COORD sCursor;
            if ( GetCursor( sCursor ) ) {
                // 垂直位置を調べる
                if ( m_sMaxCursor.Y < sCursor.Y ) {
                    // 最大カーソル位置を更新する
                    m_sMaxCursor = sCursor;
                }
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // １文字入力関数
    bool CConsole::InputChar( wchar_t& rCh, DWORD dwTime ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // タイマを設定する
            CTimer cTimer( dwTime );

            // 巡回する
            while ( !result ) {
                // 入力中止要求フラグを調べる
                if ( m_bStopInput ) {
                    // 入力中止要求フラグをクリアする
                    m_bStopInput = false;

                    // 失敗！
                    break;
                }

                // 入力レコードを取得する
                SInputRecord sRecord;
                if ( InputRecord( sRecord, 0 ) ) {
                    // 文字コードを取得する
                    rCh = sRecord.m_sEvent.Event.KeyEvent.uChar.UnicodeChar;
                    if ( L'\0' != rCh ) {
                        // 文字コードを調べる
                        if ( L'\r' == rCh ) {
                            // 文字コードを変更する
                            rCh = L'\n';
                        }

                        // 成功！
                        result = true;
                        break;
                    }
                }
                // タイマを調べる
                else if ( cTimer.Wait( 0 ) ) {
                    // 失敗！
                    break;
                }
                // サブスレッドの状態を調べる
                else if ( m_cThreadSub.Wait( 0 ) ) {
                    // 失敗！
                    break;
                }
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 文字列入力関数
    int CConsole::InputString( wchar_t* pszBuffer, int nSize, wchar_t const* pszString, DWORD dwTime ) noexcept {
        // 処理ブロック
        int result = 0;
        do {
            // 文字列バッファポインタを調べる
            if ( nullptr == pszBuffer ) {
                // 失敗！
                break;
            }

            // スクリーンバッファサイズを取得する
            int nSizeX, nSizeY;
            GetSize( nSizeX, nSizeY);

            // 先頭カーソル位置を取得する
            COORD sCursorFirst, sCursorLast;
            GetCursor( sCursorFirst );
            sCursorLast = sCursorFirst;

            // 文字列ポインタと先頭文字を調べる
            int nCount = 0;
            int nPos   = 0;
            if ( ( nullptr != pszString ) && ( L'\0' != *pszString ) ) {
                // 巡回する
                bool bResult = true;
                for ( int nIndex = 0; bResult; ++nIndex ) {
                    // 文字コードを調べる
                    if ( L'\0' == *pszString ) {
                        // 入力位置を設定する
                        nPos = nCount;

                        // 最後尾カーソル位置を取得する
                        GetCursor( sCursorLast );

                        // 成功！
                        break;
                    }
                    // インデックスを調べる
                    else if ( ( nSize - 1 ) > nIndex ) {
                        // １文字コピーする
                        pszBuffer[ nCount++ ] = *pszString;

                        // １文字出力する
                        bResult &= OutputChar( *pszString++ );
                    }
                }

                // 実行結果を調べる
                if ( !bResult ) {
                    // 失敗！
                    break;
                }
            }

            // 巡回する
            for ( ;; ) {
                // 入力中止要求フラグを調べる
                if ( m_bStopInput ) {
                    // 入力中止要求フラグをクリアする
                    m_bStopInput = false;

                    // 失敗！
                    break;
                }

                // 入力レコードを取得する
                SInputRecord sRecord;
                if ( !InputRecord( sRecord, dwTime ) ) {
                    // 失敗！
                    break;
                }

                // 文字コードを取得する
                wchar_t ch = sRecord.m_sEvent.Event.KeyEvent.uChar.UnicodeChar;
                if ( L'\033' == ch ) {
                    // 中止！
                    break;
                }

                // 再表示開始位置を初期化する
                int nRedrawPos = -1;

                // 文字コードを調べる
                if ( L'\r' == ch ) {
                    // 終端文字コードを設定する
                    pszBuffer[ nCount ] = L'\0';

                    // 成功！
                    result = nCount;
                    break;
                }
                // 文字コードを調べる
                else if ( 0 != ::iswprint( ch ) ) {
                    // 入力文字数を調べる
                    if ( ( nSize - 1 ) > nCount ) {
                        // 入力位置を調べる
                        if ( nCount == nPos ) {
                            // １文字追加する
                            pszBuffer[ nCount++ ] = ch;
                            ++nPos;

                            // １文字出力する
                            if ( !OutputChar( ch ) ) {
                                // 失敗！
                                break;
                            }

                            // 最後尾カーソル位置を取得する
                            GetCursor( sCursorLast );
                        }
                        else {
                            // 再表示開始位置を設定する
                            nRedrawPos = static_cast< int >( nPos );

                            // １文字挿入する
                            for ( int nIndex = nCount; nPos < nIndex; --nIndex ) {
                                pszBuffer[ nIndex ] = pszBuffer[ nIndex - 1 ];
                            }
                            pszBuffer[ nPos++ ] = ch;
                            nCount++;
                        }
                    }
                }
                // 文字コードを調べる
                else if ( L'\b' == ch ) {
                    // 入力位置を調べる
                    if ( 0 < nPos ) {
                        // １文字削除する
                        for ( int nIndex = nPos; nCount > nIndex; ++nIndex ) {
                            pszBuffer[ nIndex - 1 ] = pszBuffer[ nIndex ];
                        }

                        // 再表示開始位置を設定する
                        nRedrawPos = 0;

                        // 入力文字数と入力位置をデクリメントする
                        --nCount;
                        --nPos;
                    }
                }
                else {
                    // 仮想キーコードを調べる
                    WORD wVKey = sRecord.m_sEvent.Event.KeyEvent.wVirtualKeyCode;
                    if ( VK_HOME == wVKey ) {
                        // 入力位置を設定する
                        nPos = 0;

                        // カーソル位置を設定する
                        SetCursor( sCursorFirst );
                    }
                    // 仮想キーコードを調べる
                    else if ( VK_END == wVKey ) {
                        // 入力位置を設定する
                        nPos = nCount;

                        // カーソル位置を設定する
                        SetCursor( sCursorLast );
                    }
                    // 仮想キーコードを調べる
                    else if ( VK_RIGHT == wVKey ) {
                        // 入力位置を調べる
                        if ( nCount > nPos ) {
                            // 再表示開始位置を設定する
                            nRedrawPos = nPos;

                            // 入力位置をインクリメントする
                            ++nPos;
                        }
                    }
                    // 仮想キーコードを調べる
                    else if ( VK_LEFT == wVKey ) {
                        // 入力位置を調べる
                        if ( 0 < nPos ) {
                            // 再表示開始位置を設定する
                            nRedrawPos = 0;

                            // 入力位置をデクリメントする
                            --nPos;
                        }
                    }
                    // 仮想キーコードを調べる
                    else if ( VK_DELETE == wVKey ) {
                        // 入力位置を調べる
                        if ( nCount > nPos ) {
                            // １文字削除する
                            for ( int nIndex = nPos; ( nCount - 1 ) > nIndex; ++nIndex ) {
                                pszBuffer[ nIndex ] = pszBuffer[ nIndex + 1 ];
                            }

                            // 再表示開始位置を設定する
                            nRedrawPos = nPos;

                            // 入力文字数をデクリメントする
                            --nCount;
                        }
                    }
                    // コントロールキー押下状態を調べる
                    else if ( sRecord.m_bControl ) {
                        // 仮想キーコードを調べる
                        if ( 'V' == wVKey ) {
                            // クリップボードをオープンする
                            if ( 0 != ::OpenClipboard( nullptr ) ) {
                                // クリップボードデータハンドルを取得する
                                HANDLE hClipBoard = ::GetClipboardData( CF_UNICODETEXT );
                                if ( nullptr != hClipBoard ) {
                                    // クリップボードデータをロックする
                                    LPCWSTR pszText = static_cast< LPCWSTR >( ::GlobalLock( hClipBoard ) );
                                    if ( nullptr != pszText ) {
                                        // 入力位置を調べる
                                        if ( nCount == nPos ) {
                                            // 終端文字を設定する
                                            pszBuffer[ nCount ] = L'\0';

                                            // 文字列を追加する
                                            ::wcscat_s( pszBuffer, nSize, pszText );

                                            // 文字数を取得する
                                            nCount = static_cast< int >( ::wcslen( pszBuffer ) );
                                            nPos   = nCount;

                                            // 文字列を出力する
                                            if ( !OutputString( pszText ) ) {
                                                // 失敗！
                                                break;
                                            }

                                            // 最後尾カーソル位置を取得する
                                            GetCursor( sCursorLast );
                                        }
                                        else {
                                            // 再表示開始位置を設定する
                                            nRedrawPos = nPos;

                                            // 文字列を挿入する
                                            int nLen = static_cast< int >( ::wcslen( pszText ) );
                                            if ( ( nSize - 1 ) < ( nCount + nLen ) ) {
                                                nLen = ( nSize - nCount - 1 );
                                            }
                                            wchar_t const* pszSrc = &pszBuffer[ nCount - 1 ];
                                            wchar_t*       pszDst = &pszBuffer[ nCount + nLen - 1 ];
                                            for ( int nIndex = 0, uCount2 = ( nCount - nPos ); uCount2 > nIndex; ++nIndex ) {
                                                *pszDst-- = *pszSrc--;
                                            }
                                            pszDst = &pszBuffer[ nPos ];
                                            for ( int nIndex = 0; nLen > nIndex; ++nIndex ) {
                                                *pszDst++ = *pszText++;
                                            }
                                            nCount += nLen;
                                            nPos   += nLen;
                                        }
                                    }

                                    // クリップボードデータをロック解除する
                                    ::GlobalUnlock( hClipBoard );
                                }

                                // クリップボードをクローズする
                                ::CloseClipboard();
                            }
                        }
                    }
                }

                // 再表示開始位置を調べる
                if ( 0 <= nRedrawPos ) {
                    // 再表示開始文字列ポインタを取得する
                    pszString = &pszBuffer[ nRedrawPos ];

                    // 再表示開始位置を調べる
                    if ( 0 == nRedrawPos ) {
                        // カーソル位置を設定する
                        SetCursor( sCursorFirst );
                    }

                    // 現在のカーソル位置を保存する
                    COORD sCursor;
                    GetCursor( sCursor );

                    // 巡回する
                    bool bResult = true;
                    for ( int nIndex = nRedrawPos; bResult; ++nIndex ) {
                        // インデックスを調べる
                        if ( nPos == nIndex ) {
                            // 再表示後のカーソル位置を取得する
                            GetCursor( sCursor );
                        }

                        // インデックスを調べる
                        if ( nCount <= nIndex ) {
                            // 最後尾カーソル位置を取得する
                            GetCursor( sCursorLast );

                            // 空白文字列を出力する
                            bResult &= OutputString( L"  " );

                            // カーソル位置を設定する
                            SetCursor( sCursor );

                            // 終了！
                            break;
                        }

                        // １文字出力する
                        bResult &= OutputChar( *pszString++ );
                    }

                    // 実行結果を調べる
                    if ( !bResult ) {
                        // 失敗！
                        break;
                    }
                }
            }

            // カーソル位置を設定する
            SetCursor( sCursorLast );
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 入力バッファクリア関数
    void CConsole::ClearInputBuffer() noexcept {
        // 処理ブロック
        do {
            // サブスレッド実行状態を調べる
            if ( WAIT_OBJECT_0 != ::WaitForSingleObject( m_cThreadSub.GetHandle(), 0 ) ) {
                // 同期処理ブロック
                do {
                    CSyncAuto cSyncAuto( *this );

                    // 入力レコード先頭位置をクリアする
                    m_nRecordPos = 0;

                    // 入力レコードカウントをクリアする
                    m_nRecordCount = 0;

                    // コンソール入力バッファ未読レコードを破棄する
                    ::FlushConsoleInputBuffer( GetInputHandle() );
                } while ( false );
            }
            else {
                // 入力レコード先頭位置をクリアする
                m_nRecordPos = 0;

                // 入力レコードカウントをクリアする
                m_nRecordCount = 0;

                // コンソール入力バッファ未読レコードを破棄する
                ::FlushConsoleInputBuffer( GetInputHandle() );
            }
        } while ( false );
    }

    //-------------------------------------------------------------------------
    // 入力レコード取得関数
    bool CConsole::InputRecord( SInputRecord& rsRecord, DWORD dwTime ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // タイマを設定する
            CTimer cTimer( dwTime );

            // 巡回する
            while ( !result ) {
                // 同期処理ブロック
                do {
                    CSyncAuto cSyncAuto( *this );

                    // 入力レコードカウントを調べる
                    if ( 0 < m_nRecordCount ) {
                        // 入力レコードを取得する
                        rsRecord = m_sRecordBuffer[ m_nRecordPos ];

                        // 入力レコードカウントをデクリメントする
                        if ( 0 == --m_nRecordCount ) {
                            // 入力レコード先頭位置をクリアする
                            m_nRecordPos = 0;
                        }
                        else {
                            // 入力レコード先頭位置を更新する
                            m_nRecordPos = ( ( m_nRecordPos + 1 ) % RECORD_SIZE );
                        }

                        // 成功！
                        result = true;
                    }
                } while ( false );

                // タイマを調べる
                if ( cTimer.Wait( 0 ) ) {
                    // 失敗！
                    break;
                }
                // サブスレッドの状態を調べる
                else if ( m_cThreadSub.Wait( 0 ) ) {
                    // 失敗！
                    break;
                }
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // キー入力待ち関数
    int CConsole::HitAnyKey( wchar_t const* pszString, DWORD dwTime ) noexcept {
        // 処理ブロック
        int result = -1;
        do {
            // 文字列ポインタを調べる
            if ( nullptr != pszString ) {
                // 文字列を出力する
                OutputString( pszString );
            }

            // 入力バッファをクリアする
            ClearInputBuffer();

            // １文字入力する
            wchar_t ch;
            if ( !InputChar( ch, dwTime ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = ch;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 確認入力待ち関数
    bool CConsole::YesNoKey( wchar_t const* pszString, DWORD dwTime ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 文字列ポインタを調べる
            if ( nullptr != pszString ) {
                // 文字列を出力する
                OutputString( pszString );
                OutputString( L" " );
            }

            // 入力バッファをクリアする
            ClearInputBuffer();

            // 巡回する
            for ( ;; ) {
                // １文字入力する
                wchar_t ch;
                if ( !InputChar( ch, dwTime ) ) {
                    // 失敗！
                    ConsoleNewLine();
                    ConsoleLine( L"１文字入力できませんでした。" );
                    break;
                }

                // 文字コードを調べる
                ch = ::towupper( ch );
                if ( L'\033' == ch ) {
                    // 失敗！
                    ConsoleLine( L"⇒ いや間違えました… (*^。^*)" );
                    break;
                }
                // 文字コードを調べる
                else if ( L'N' == ch ) {
                    // 失敗！
                    ConsoleLine( L"⇒ いいえ <`ヘ´>" );
                    break;
                }
                // 文字コードを調べる
                else if ( L'Y' == ch ) {
                    // 成功！
                    ConsoleLine( L"⇒ は～い！ ＼(^o^)／" );
                    result = true;
                    break;
                }
                // 文字コードを調べる
                else if ( ( L'\r' == ch ) || ( L'\n' == ch ) )  {
                    // 成功！
                    ConsoleLine( L"⇒ はい、まあなんとか (~_~メ)" );
                    result = true;
                    break;
                }
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //=========================================================================
    // 静的公開関数
    //-------------------------------------------------------------------------
    // フォントサイズ取得関数
    bool CConsole::GetFontSize( int& rnWidth, int& rnHeight ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // コンソールフォント情報を取得する
            CONSOLE_FONT_INFO sFontInfo;
            if ( 0 == ::GetCurrentConsoleFont( GetOutputHandle(), false, &sFontInfo ) ) {
                // 失敗！
                break;
            }

            // フォントサイズを取得する
            rnWidth  = sFontInfo.dwFontSize.X;
            rnHeight = sFontInfo.dwFontSize.Y;

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 出力バッファサイズ取得関数
    bool CConsole::GetSize( int& rnWidth, int& rnHeight ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // コンソールスクリーンバッファ情報を取得する
            CONSOLE_SCREEN_BUFFER_INFO sInfo;
            if ( 0 == ::GetConsoleScreenBufferInfo( GetOutputHandle(), &sInfo ) ) {
                // 失敗！
                break;
            }

            // バッファサイズを取得する
            rnWidth  = sInfo.dwSize.X;
            rnHeight = sInfo.dwSize.Y;

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 出力バッファサイズ設定関数
    bool CConsole::SetBufferSize( int nWidth, int nHeight ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // スクリーンバッファサイズを設定する
            COORD sCoord = { static_cast< SHORT >( nWidth ), static_cast< SHORT >( nHeight ) };
            if ( 0 == ::SetConsoleScreenBufferSize( GetOutputHandle(), sCoord ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 出力バッファ表示位置取得関数
    bool CConsole::GetBufferPosition( int& rnLeft, int& rnTop ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // コンソールスクリーンバッファ情報を取得する
            CONSOLE_SCREEN_BUFFER_INFO sInfo;
            if ( 0 == ::GetConsoleScreenBufferInfo( GetOutputHandle(), &sInfo ) ) {
                // 失敗！
                break;
            }

            // 表示位置を取得する
            rnLeft = sInfo.srWindow.Left;
            rnTop  = sInfo.srWindow.Top;

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 出力バッファ表示位置設定関数
    bool CConsole::SetBufferPosition( int nLeft, int nTop ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // コンソールスクリーンバッファ情報を取得する
            CONSOLE_SCREEN_BUFFER_INFO sInfo;
            if ( 0 == ::GetConsoleScreenBufferInfo( GetOutputHandle(), &sInfo ) ) {
                // 失敗！
                break;
            }

            // コンソール表示領域を設定する
            SMALL_RECT sRect = {
                static_cast< SHORT >( nLeft ),
                static_cast< SHORT >( nTop ),
                static_cast< SHORT >( nLeft + sInfo.srWindow.Right  - sInfo.srWindow.Left ),
                static_cast< SHORT >( nTop  + sInfo.srWindow.Bottom - sInfo.srWindow.Top ) };
            if ( 0 == ::SetConsoleWindowInfo( GetOutputHandle(), true, &sRect ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 出力バッファ表示領域取得関数
    bool CConsole::GetBufferArea( int& rnLeft, int& rnTop, int& rnWidth, int& rnHeight ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // コンソールスクリーンバッファ情報を取得する
            CONSOLE_SCREEN_BUFFER_INFO sInfo;
            if ( 0 == ::GetConsoleScreenBufferInfo( GetOutputHandle(), &sInfo ) ) {
                // 失敗！
                break;
            }

            // ウィンドウ表示領域を取得する
            rnLeft   = sInfo.srWindow.Left;
            rnTop    = sInfo.srWindow.Top;
            rnWidth  = ( sInfo.srWindow.Right  - rnLeft + 1 );
            rnHeight = ( sInfo.srWindow.Bottom - rnTop  + 1 );

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 出力バッファ表示領域設定関数
    bool CConsole::SetBufferArea( int nLeft, int nTop, int nWidth, int nHeight ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // コンソール表示領域を設定する
            SMALL_RECT sRect = {
                static_cast< SHORT >( nLeft ),
                static_cast< SHORT >( nTop ),
                static_cast< SHORT >( nLeft + nWidth  - 1 ),
                static_cast< SHORT >( nTop  + nHeight - 1 ) };
            if ( 0 == ::SetConsoleWindowInfo( GetOutputHandle(), true, &sRect ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // ウィンドウ表示領域取得関数
    bool CConsole::GetWindowArea( int& rnLeft, int& rnTop, int& rnWidth, int& rnHeight ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ウィンドウ情報を取得する
            WINDOWINFO sWndInfo = { sizeof( WINDOWINFO ) };
            if ( 0 == ::GetWindowInfo( GetWindowHandle(), &sWndInfo ) ) {
                // 失敗！
                break;
            }

            // ウィンドウ表示領域を取得する
            rnLeft   = sWndInfo.rcWindow.left;
            rnTop    = sWndInfo.rcWindow.top;
            rnWidth  = ( sWndInfo.rcWindow.right  - sWndInfo.rcWindow.left + 1 );
            rnHeight = ( sWndInfo.rcWindow.bottom - sWndInfo.rcWindow.top  + 1 );

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // ウィンドウ表示領域設定関数
    bool CConsole::SetWindowArea( int nLeft, int nTop, int nWidth, int nHeight ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ウィンドウ表示位置を設定する
            ::SetWindowPos( GetWindowHandle(), HWND_TOP, nLeft, nTop, nWidth, nHeight, ( SWP_NOACTIVATE | SWP_SHOWWINDOW ) );
            ::UpdateWindow( GetWindowHandle() );

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // カーソル位置取得関数
    bool CConsole::GetCursorPosition( int& rnX, int& rnY ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // コンソールスクリーンバッファ情報を取得する
            CONSOLE_SCREEN_BUFFER_INFO sInfo;
            if ( 0 == ::GetConsoleScreenBufferInfo( GetOutputHandle(), &sInfo ) ) {
                // 失敗！
                break;
            }

            // カーソル位置を取得する
            rnX = static_cast< int >( sInfo.dwCursorPosition.X );
            rnY = static_cast< int >( sInfo.dwCursorPosition.Y );

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // カーソル位置設定関数
    bool CConsole::SetCursorPosition( int nX, int nY ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // コンソールスクリーンバッファカーソル位置を設定する
            COORD sCoord = { static_cast< SHORT >( nX ), static_cast< SHORT >( nY ) };
            if ( 0 == ::SetConsoleCursorPosition( GetOutputHandle(), sCoord ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // カーソル位置取得関数
    bool CConsole::GetCursor( COORD& rsCursor ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // コンソールスクリーンバッファ情報を取得する
            CONSOLE_SCREEN_BUFFER_INFO sInfo;
            if ( 0 == ::GetConsoleScreenBufferInfo( GetOutputHandle(), &sInfo ) ) {
                // 失敗！
                break;
            }

            // カーソル位置を取得する
            rsCursor = sInfo.dwCursorPosition;

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // カーソル位置設定関数
    bool CConsole::SetCursor( COORD const& rsCursor ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // コンソールスクリーンバッファカーソル位置を設定する
            if ( 0 == ::SetConsoleCursorPosition( GetOutputHandle(), rsCursor ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // ウィンドウスクロール関数
    bool CConsole::ScrollWindow( int nX, int nY ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // コンソール表示領域を設定する
            SMALL_RECT sRect = {
                static_cast< SHORT >( nX ),
                static_cast< SHORT >( nY ),
                static_cast< SHORT >( nX ),
                static_cast< SHORT >( nY ) };
            if ( 0 == ::SetConsoleWindowInfo( GetOutputHandle(), false, &sRect ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // コンソール入力バッファ直接入力関数
    bool CConsole::InputDirect( wchar_t& rCh ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // コンソール入力イベントレコードを読み取る
            INPUT_RECORD sRecord;
            DWORD        dwCount;
            if ( 0 == ::PeekConsoleInputW( GetInputHandle(), &sRecord, 1, &dwCount ) ) {
                // 失敗！
                break;
            }
            // 入力レコード数を調べる
            else if ( 0 == dwCount ) {
                // 失敗！
                break;
            }
            // コンソール入力イベントレコードをバッファから削除する
            else if ( 0 == ::ReadConsoleInputW( GetInputHandle(), &sRecord, 1, &dwCount ) ) {
                // 失敗！
                break;
            }
            // 入力レコード数を調べる
            else if ( 0 == dwCount ) {
                // 失敗！
                break;
            }

            // 文字コードを取得する
            rCh = sRecord.Event.KeyEvent.uChar.UnicodeChar;

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // コンソール入力バッファ直接検査関数
    bool CConsole::KbHitDirect() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // コンソール入力バッファにある未読の入力レコード数を取得する
            DWORD dwCount;
            if ( 0 == ::GetNumberOfConsoleInputEvents( GetInputHandle(), &dwCount ) ) {
                // 失敗！
                break;
            }
            // 入力レコード数を調べる
            else if ( 0 == dwCount ) {
                // 失敗！
                break;
            }
            // 入力レコード数を調べる
            else if ( KBHIT_RECORD_SIZE < dwCount ) {
                // 入力レコード数を設定する
                dwCount = KBHIT_RECORD_SIZE;
            }

            // コンソール入力バッファからデータを読み取る
            INPUT_RECORD sInputRecord[ KBHIT_RECORD_SIZE ];
            if ( 0 == ::PeekConsoleInputW( GetInputHandle(), sInputRecord, dwCount, &dwCount ) ) {
                // 失敗！
                break;
            }
            // 巡回する
            else for ( DWORD dwIndex = 0; dwCount > dwIndex; ++dwIndex ) {
                // イベント種別を調べる
                if ( KEY_EVENT == sInputRecord[ dwIndex ].EventType ) {
                    // 成功！
                    result = true;
                    break;
                }
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //=========================================================================
    // 静的限定公開関数
    //-------------------------------------------------------------------------
    // サブスレッド関数
    DWORD CConsole::SubThreadProc( LPVOID lpParam ) noexcept {
        // 処理ブロック
        DWORD result = 0;
        do {
            // インスタンスポインタを取得する
            CConsole*& rpcInstance = reinterpret_cast< CConsole*& >( lpParam );
            if ( nullptr == rpcInstance ) {
                // 致命的エラー！
                NotifyFatalError();
                break;
            }
            // 巡回する
            else for ( ;; ) {
                // コンソール入力イベントを取得する
                INPUT_RECORD sEvent  = {};
                DWORD        dwCount = 0;
                if ( ( 0 == ::ReadConsoleInputW( GetInputHandle(), &sEvent, 1, &dwCount ) ) || ( 0 == dwCount ) ) {
                    // コンソール入力バッファがシグナル状態になるのを待つ
                    ::WaitForSingleObject( GetInputHandle(), INFINITE );

                    // 継続！
                    continue;
                }
                // イベント種別を調べる
                else if ( MOUSE_EVENT == sEvent.EventType ) {
                    // ホイールイベントか調べる
                    if ( MOUSE_WHEELED == sEvent.Event.MouseEvent.dwEventFlags ) {
                        // スクロール量を取得する
                        short nDelta  = HIWORD( sEvent.Event.MouseEvent.dwButtonState );
                        int   nScroll = ( -nDelta / WHEEL_DELTA );

                        // 上下方向にスクロールする
                        ScrollWindow( 0, nScroll );
                    }

                    // 継続！
                    continue;
                }
                // イベント種別を調べる
                else if ( KEY_EVENT != sEvent.EventType ) {
                    // 継続！
                    continue;
                }
                // キー押下状態を調べる
                else if ( 0 == sEvent.Event.KeyEvent.bKeyDown ) {
                    // 継続！
                    continue;
                }

                // 入力レコードを作製する
                SInputRecord sRecord = {};
                sRecord.m_sEvent   = sEvent;
                sRecord.m_bShift   = ( 0 != ( 0x8000 & ::GetKeyState( VK_SHIFT ) ) );
                sRecord.m_bControl = ( 0 != ( 0x8000 & ::GetKeyState( VK_CONTROL ) ) );
                sRecord.m_bMenu    = ( 0 != ( 0x8000 & ::GetKeyState( VK_MENU ) ) );

                // コントロールキー押下状態を調べる
                if ( sRecord.m_bControl ) {
                    // 入力レコード追加無効フラグをセットする
                    bool bInvalid = true;

                    // オルトキー押下状態を調べる
                    if ( sRecord.m_bMenu) {
                        // 仮想キーコードを調べる
                        switch ( sEvent.Event.KeyEvent.wVirtualKeyCode ) {
                        default:
                            // 入力レコード追加無効フラグをクリアする
                            bInvalid = false;
                            break;

                        case VK_LEFT:
                            // ウィンドウを左端に表示する
                            SetWindowPosition( GetWindowHandle(), EWindowPosition::Left );
                            break;

                        case VK_UP:
                            // ウィンドウを上端に表示する
                            SetWindowPosition( GetWindowHandle(), EWindowPosition::Top );
                            break;

                        case VK_RIGHT:
                            // ウィンドウを右端に表示する
                            SetWindowPosition( GetWindowHandle(), EWindowPosition::Right );
                            break;

                        case VK_DOWN:
                            // ウィンドウを下端に表示する
                            SetWindowPosition( GetWindowHandle(), EWindowPosition::Bottom );
                            break;

                        case VK_RETURN:
                            // ウィンドウをフルサイズ表示する
                            SetWindowPosition( GetWindowHandle(), EWindowPosition::Full );
                            break;
                        }
                    }
                    // 仮想キーコードを調べる
                    else switch ( sEvent.Event.KeyEvent.wVirtualKeyCode ) {
                    default:
                        // 入力レコード追加無効フラグをクリアする
                        bInvalid = false;
                        break;

                    case VK_HOME:
                        // スクリーン表示位置を設定する
                        SetBufferPosition( 0, 0 );
                        break;

                    case VK_END:
                        {
                            // スクリーン表示領域を取得する
                            int nLeft;
                            int nTop;
                            int nWidth;
                            int nHeight;
                            if ( GetBufferArea( nLeft, nTop, nWidth, nHeight ) ) {
                                // スクリーン表示位置を設定する
                                nTop = ( rpcInstance->m_sMaxCursor.Y - nHeight + 1 );
                                SetBufferPosition( nLeft, nTop );
                            }
                        }
                        break;

                    case VK_RETURN:
                        // ウィンドウ最大化状態を調べる
                        if ( ::IsZoomed( GetWindowHandle() ) ) {
                            // ウィンドウを通常表示する
                            ::ShowWindow( GetWindowHandle(), SW_SHOWNOACTIVATE );
                        }
                        else {
                            // アクティブウィンドウを取得する
                            HWND hActive = ::GetActiveWindow();

                            // ウィンドウを最大化する
                            ::ShowWindow( GetWindowHandle(), SW_SHOWMAXIMIZED );

                            // アクティブウィンドウを復元する
                            if ( hActive != ::GetActiveWindow() ) {
                                ::SetActiveWindow( hActive );
                            }
                        }
                        break;

                    case VK_UP:
                        // 下スクロールする
                        ScrollWindow( 0, -1 );
                        break;

                    case VK_DOWN:
                        // 上スクロールする
                        ScrollWindow( 0, 1 );
                        break;

                    case VK_LEFT:
                        // 右スクロールする
                        ScrollWindow( -1, 0 );
                        break;

                    case VK_RIGHT:
                        // 左スクロールする
                        ScrollWindow( 1, 0 );
                        break;

                    case VK_PRIOR:
                        // 下ページスクロールする
                        ScrollWindow( 0, -20 );
                        break;

                    case VK_NEXT:
                        // 上ページスクロールする
                        ScrollWindow( 0, 20 );
                        break;
                    }

                    // 入力レコード追加無効フラグを調べる
                    if ( bInvalid ) {
                        // 継続！
                        continue;
                    }
                }

                // 同期処理ブロック
                do {
                    CSyncAuto cSyncAuto( *rpcInstance );

                    // 入力レコードカウントを調べる
                    if ( RECORD_SIZE <= rpcInstance->m_nRecordCount ) {
                        // 入力レコード先頭位置を更新する
                        rpcInstance->m_nRecordPos = ( ( rpcInstance->m_nRecordPos + 1 ) % RECORD_SIZE );
                    }

                    // 入力レコードリングバッファ更新位置を取得する
                    int nPos = ( ( rpcInstance->m_nRecordPos + rpcInstance->m_nRecordCount ) % RECORD_SIZE );

                    // 入力レコードを設定する
                    rpcInstance->m_sRecordBuffer[ nPos ] = sRecord;

                    // 入力レコードカウントを調べる
                    if ( RECORD_SIZE > rpcInstance->m_nRecordCount ) {
                        // 入力レコードカウントをインクリメントする
                        ++rpcInstance->m_nRecordCount;
                    }
                } while ( false );
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }
}

#pragma managed( pop )