CWndMain.cpp

[詳解]

//=============================================================================
/// @file
/// メインウィンドウクラス実装ファイル
///
/// メインウィンドウクラス実装ファイルです。
///
/// $Id: CWndMain.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 <CWndMain.h>
#include <CommandIdDef.h>
#include <CJsonConfigAuto.h>
#include <LibUtility.h>
#include <LibWindowUtility.h>
#include <algorithm>

//=============================================================================
// インクルード実装ファイル
#include <CArray.hpp>

//=============================================================================
// ウィンドウライブラリ名前空間
namespace LibWindow {
    //=========================================================================
    // メインウィンドウクラス
    //=========================================================================
    // 構築子と解体子
    //-------------------------------------------------------------------------
    // コンストラクタ
    CWndMain::CWndMain() noexcept
        // 基底クラスコンストラクタ
        : CWndOverlap()
        // メンバ変数初期化
        , m_hMenu( nullptr )
        , m_hAccel( nullptr )
        , m_hStatusBar( nullptr )
        , m_hSeparator( nullptr )
        , m_cToolBar()
        , m_cOverlapList()
        , m_cFloatingList()
        , m_hIconImageList( nullptr )
        , m_pcIconImageList( nullptr )
        , m_pcToolBarButtonList( nullptr )
        , m_bFocusOverlap( false )
        , m_bFocusFloating( false )
        , m_bMenuMouseActivate( false )
        , m_bValidMenuSelect( false )
        , m_bToolBarMouseActivate( false )
        , m_bValidToolBarSelect( false )
        , m_bPerformanceTimer( false )
        , m_nPerformanceFreq( 0 )
        , m_nPerformanceCount( 0 )
        , m_nSecondCount( 0 )
        , m_nErrorCount( 0 )
        , m_cFrameWaitTimer()
        , m_nFrameWaitTime( 0 )
        , m_nFpsCount( 0 )
        , m_nFpsValue( 0 )
        , m_nFpsMax( FPS_MAX )
        , m_bUpdatedFpsValue( false )
        , m_cOtherInfo()
    {
        // コモンコントロールを初期化する
        ::InitCommonControls();

        // 処理ブロック
        do {
            // アイコンイメージリストを作成する
            m_pcIconImageList = new CArray< SIconImageInfo >;
            if ( nullptr == m_pcIconImageList ) {
                // 致命的エラー！
                NotifyFatalError();
                break;
            }

            // ツールバーボタンリストを作成する
            m_pcToolBarButtonList = new CArray< TBBUTTON >;
            if ( nullptr == m_pcToolBarButtonList ) {
                // 致命的エラー！
                NotifyFatalError();
                break;
            }

            // メインメニューを作成する
            m_hMenu = ::CreateMenu();
            if ( nullptr == m_hMenu ) {
                // 致命的エラー！
                NotifyFatalError();
                break;
            }
        } while ( false );
    }

    //-------------------------------------------------------------------------
    // デストラクタ
    CWndMain::~CWndMain() noexcept {
        // アクセラレータテーブルを破棄する
        ::DestroyAcceleratorTable( m_hAccel );

        // メニューを破棄する
        ::DestroyMenu( m_hMenu );

        // ツールバーボタンリストを削除する
        delete m_pcToolBarButtonList;

        // アイコンイメージリストを削除する
        delete m_pcIconImageList;
    }

    //=========================================================================
    // 公開関数
    //-------------------------------------------------------------------------
    // ウィンドウ作成関数
    bool CWndMain::Create( HWND, HMENU ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 基底クラスの関数を実行する
            if ( !CWndOverlap::Create( nullptr, m_hMenu ) ) {
                // 失敗！
                break;
            }
            // アクセラレータテーブルを作成する
            else if ( !CreateAccel() ) {
                // 失敗！
                break;
            }
            // ツールバーを作成する
            else if ( !CreateToolBar() ) {
                // 失敗！
                break;
            }
            // ステータスバーを作成する
            else if ( !CreateStatusBar() ) {
                // 失敗！
                break;
            }
            // セパレータを作成する
            else if ( !CreateSeparator() ) {
                // 失敗！
                break;
            }
            // オーバーラップウィンドウリストを作成する
            else if ( !m_cOverlapList.CreateListWindow( m_hWnd ) ) {
                // 失敗！
                break;
            }
            // フローティングウィンドウリストを作成する
            else if ( !m_cFloatingList.CreateListWindow( m_hWnd ) ) {
                // 失敗！
                break;
            }

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

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

    //-------------------------------------------------------------------------
    // WM_DESTROYメッセージ処理関数
    LRESULT CWndMain::WmDestroy() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // 終了メッセージをポストする
            ::PostQuitMessage( 0 );
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_SIZEメッセージ処理関数
    LRESULT CWndMain::WmSize() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // ウィンドウ表示状態を調べる
            if ( 0 == ::IsWindowVisible( m_hWnd ) ) {
                // 終了！
                break;
            }

            // クライアント領域を調べる
            RECT sClientRect = {};
            ::GetClientRect( m_hWnd, &sClientRect );
            if ( 0 == ::IsRectEmpty( &sClientRect ) ) {
                // ツールバー表示状態を調べる
                if ( 0 != ::IsWindowVisible( m_cToolBar.GetHandle() ) ) {
                    // WM_SIZEメッセージを送信する
                    ::SendMessageW( m_cToolBar.GetHandle(), WM_SIZE, 0, 0 );
                    ::UpdateWindow( m_cToolBar.GetHandle() );

                    // ツールバー表示領域を取得する
                    RECT sRect;
                    ::GetWindowRect( m_cToolBar.GetHandle(), &sRect );

                    // クライアント座標系に変換する
                    ::ScreenToClient( m_hWnd, reinterpret_cast< LPPOINT >( &sRect.left ) );
                    ::ScreenToClient( m_hWnd, reinterpret_cast< LPPOINT >( &sRect.right ) );

                    // セパレータを表示する
                    int nLeft   = sRect.left;
                    int nTop    = sRect.bottom;
                    int nWidth  = ( sRect.right - nLeft );
                    int nHeight = SEPARATOR_HEIGHT;
                    ::SetWindowPos( m_hSeparator, HWND_TOP, nLeft, nTop, nWidth, nHeight, ( SWP_NOACTIVATE | SWP_SHOWWINDOW ) );
                    ::UpdateWindow( m_hSeparator );
                }
                else {
                    // セパレータを隠す
                    ::ShowWindow( m_hSeparator, SW_HIDE );
                }

                // ステータスバー表示状態を調べる
                if ( 0 != ::IsWindowVisible( m_hStatusBar ) ) {
                    // WM_SIZEメッセージを送信する
                    ::SendMessageW( m_hStatusBar, WM_SIZE, 0, 0 );
                    ::UpdateWindow( m_hStatusBar );
                }
            }

            // 基底クラスの関数を実行する
            result = CWndOverlap::WmSize();
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_SETFOCUSメッセージ処理関数
    LRESULT CWndMain::WmSetFocus() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // メニューマウスアクティベートフラグを調べる
            if ( m_bMenuMouseActivate ) {
                // フォーカスウィンドウを無効化する
                ::SetFocus( nullptr );

                // 終了！
                break;
            }
            // ツールバーマウスアクティベートフラグを調べる
            else if ( m_bToolBarMouseActivate ) {
                // フォーカスウィンドウを無効化する
                ::SetFocus( nullptr );

                // 終了！
                break;
            }

            // オーバーラップウィンドウフォーカス有効状態を調べる
            if ( m_bFocusOverlap ) {
                // カレントエレメントウィンドウを取得する
                CWndElement* pcElement = m_cOverlapList.GetCurrentElement();
                if ( nullptr != pcElement ) {
                    // フォーカスウィンドウを設定する
                    ::SetFocus( pcElement->GetHandle() );

                    // 終了！
                    break;
                }
            }

            // フローティングウィンドウフォーカス有効状態を調べる
            if ( m_bFocusFloating ) {
                // カレントエレメントウィンドウを取得する
                CWndElement* pcElement = m_cFloatingList.GetCurrentElement();
                if ( nullptr != pcElement ) {
                    // フォーカスウィンドウを設定する
                    ::SetFocus( pcElement->GetHandle() );

                    // 終了！
                    break;
                }
            }

            // 基底クラスの関数を実行する
            result = CWndOverlap::WmSetFocus();
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_MOUSEACTIVATEメッセージ処理関数
    LRESULT CWndMain::WmMouseActivate() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // メニューマウスアクティベートフラグをクリアする
            m_bMenuMouseActivate = false;

            // メニュー項目選択有効フラグをクリアする
            m_bValidMenuSelect = false;

            // ツールバーマウスアクティベートフラグをクリアする
            m_bToolBarMouseActivate = false;

            // ツールバーボタン選択有効フラグをクリアする
            m_bValidToolBarSelect = false;

            // ヒットテストコードを調べる
            WORD wHitTest = LOWORD( m_lParam );
            if ( HTMENU == wHitTest ) {
                // メニューマウスアクティベートフラグをセットする
                m_bMenuMouseActivate = true;

                // 終了！
                break;
            }
            // ツールバー表示状態を調べる
            else if ( 0 != ::IsWindowVisible( m_cToolBar.GetHandle() ) ) {
                // カーソル位置を取得する
                POINT sPoint;
                ::GetCursorPos( &sPoint );

                // クライアント座標系に変換する
                ::ScreenToClient( m_cToolBar.GetHandle(), &sPoint );

                // 巡回する
                for ( int nIndex = 0, nCount = m_pcToolBarButtonList->GetCount(); nCount > nIndex; ++nIndex ) {
                    // ボタン種別を調べる
                    if ( BTNS_BUTTON == ( *m_pcToolBarButtonList )[ nIndex ].fsStyle ) {
                        // ボタン表示領域を取得する
                        RECT sRect;
                        if ( TRUE == ::SendMessageW( m_cToolBar.GetHandle(), TB_GETITEMRECT, nIndex, reinterpret_cast< LPARAM >( &sRect ) ) ) {
                            // カーソル位置を調べる
                            if ( 0 != ::PtInRect( &sRect, sPoint ) ) {
                                // ツールバーマウスアクティベートフラグをセットする
                                m_bToolBarMouseActivate = true;

                                // ボタン有効状態を調べる
                                int idCommand = ( *m_pcToolBarButtonList )[ nIndex ].idCommand;
                                if ( 0 != ::SendMessageW( m_cToolBar.GetHandle(), TB_ISBUTTONENABLED, idCommand, 0 ) ) {
                                    // ツールバーボタン選択有効フラグをセットする
                                    m_bValidToolBarSelect = true;
                                }

                                // 終了！
                                break;
                            }
                        }
                    }
                }

                // ツールバーマウスアクティベートフラグを調べる
                if ( m_bToolBarMouseActivate ) {
                    // 終了！
                    break;
                }
            }

            // オーバーラップウィンドウフォーカス有効フラグをクリアする
            m_bFocusOverlap = false;

            // フローティングウィンドウフォーカス有効フラグをクリアする
            m_bFocusFloating = false;
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_MENUSELECTメッセージ処理関数
    LRESULT CWndMain::WmMenuSelect() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // メニューマウスアクティベートフラグを調べる
            if ( m_bMenuMouseActivate ) {
                // メニューハンドルを調べる
                HMENU hMenu = reinterpret_cast< HMENU >( m_lParam );
                if ( m_hMenu == hMenu ) {
                    // メニュー項目選択有効フラグをセットする
                    m_bValidMenuSelect = true;
                }
            }

            // 基底クラスの関数を実行する
            result = CWndOverlap::WmMenuSelect();
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_EXITMENULOOPメッセージ処理関数
    LRESULT CWndMain::WmExitMenuLoop() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // メニューマウスアクティベートフラグを調べる
            if ( m_bMenuMouseActivate ) {
                // メニューマウスアクティベートフラグをクリアする
                m_bMenuMouseActivate = false;

                // メニュー項目選択有効フラグを調べる
                if ( !m_bValidMenuSelect ) {
                    // メニュー項目選択有効フラグをクリアする
                    m_bValidMenuSelect = false;

                    // オーバーラップウィンドウフォーカス有効フラグをクリアする
                    m_bFocusOverlap = false;

                    // フローティングウィンドウフォーカス有効フラグをクリアする
                    m_bFocusFloating = false;
                }

                // フォーカスウィンドウを設定する
                ::SetFocus( m_hWnd );
            }

            // 基底クラスの関数を実行する
            result = CWndOverlap::WmExitMenuLoop();
        } while ( false );

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

    //-------------------------------------------------------------------------
    // NM_CLICKメッセージ処理関数
    LRESULT CWndMain::NmClick() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // 通知メッセージヘッダ構造体を取得する
            NMHDR* psNmHdr = reinterpret_cast< LPNMHDR >( m_lParam );

            // コントロールハンドルを調べる
            if ( m_cToolBar.GetHandle() == psNmHdr->hwndFrom ) {
                // ツールバーマウスアクティベートフラグを調べる
                if ( m_bToolBarMouseActivate ) {
                    // ツールバーマウスアクティベートフラグをクリアする
                    m_bToolBarMouseActivate = false;
                }
                else {
                    // オーバーラップウィンドウフォーカス有効フラグをクリアする
                    m_bFocusOverlap = false;

                    // フローティングウィンドウフォーカス有効フラグをクリアする
                    m_bFocusFloating = false;
                }

                // フォーカスウィンドウを設定する
                ::SetFocus( m_hWnd );
            }

            // 基底クラスの関数を実行する
            result = CWndOverlap::NmClick();
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_DRAWITEMメッセージ処理関数
    LRESULT CWndMain::WmDrawItem() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // 描画アイテム構造体を取得する
            LPDRAWITEMSTRUCT lpDraw = reinterpret_cast< LPDRAWITEMSTRUCT >( m_lParam );

            // コントロールハンドルを調べる
            if ( m_hSeparator == lpDraw->hwndItem ) {
                // セパレータを描画する
                DrawSeparator( lpDraw );

                // 終了！
                break;
            }

            // 基底クラスの関数を実行する
            result = CWndOverlap::WmDrawItem();
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_COMMANDメッセージ処理関数
    LRESULT CWndMain::WmCommand() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // コンテキストメニューハンドルを調べる
            if ( nullptr == s_hContextMenu ) {
                // コマンドIDを取得する
                WORD wId = LOWORD( m_wParam );
                if ( 0 != wId ) {
                    // 通知コードを取得する
                    WORD wCode = HIWORD( m_wParam );

                    // コントロールハンドルを取得する
                    HWND hCtrl = reinterpret_cast< HWND >( m_lParam );
                    if ( nullptr != hCtrl ) {
                        // メニューコマンドを実行する
                        ExecMenuCommand( wId, wCode, hCtrl );

                        // 終了！
                        break;
                    }

                    // メニューコマンドデータを取得する
                    CWndPane* pcPane = nullptr;
                    ULONG_PTR uData;
                    if ( GetMenuCommandData( m_hMenu, static_cast< UINT >( m_wParam ), uData ) ) {
                        // コントロールハンドルを取得する
                        hCtrl = reinterpret_cast< HWND >( uData );

                        // ペインウィンドウポインタを取得する
                        pcPane = GetPaneWindow( hCtrl );
                    }

                    // ペインウィンドウポインタを調べる
                    if ( nullptr == pcPane ) {
                        // ペインウィンドウポインタを設定する
                        pcPane = this;
                    }

                    // メニューコマンドを実行する
                    pcPane->ExecMenuCommand( wId, wCode, hCtrl );

                    // 終了！
                    break;
                }
            }

            // 基底クラスの関数を実行する
            result = CWndOverlap::WmCommand();
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_NOTIFY_CHILD_SET_FOCUSメッセージ処理関数
    LRESULT CWndMain::WmNotifyChildSetFocus() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // オーバーラップウィンドウフォーカス有効フラグをクリアする
            m_bFocusOverlap = false;

            // フローティングウィンドウフォーカス有効フラグをクリアする
            m_bFocusFloating = false;

            // 子ウィンドウハンドルを取得する
            HWND hChild = reinterpret_cast< HWND >( m_lParam );

            // オーバーラップウィンドウを取得する
            CWndElement* pcElement = m_cOverlapList.GetElementWindow( hChild );
            if ( nullptr != pcElement ) {
                // カレントエレメントウィンドウを設定する
                if ( m_cOverlapList.SetCurrentElement( pcElement ) ) {
                    // オーバーラップウィンドウフォーカス有効フラグをセットする
                    m_bFocusOverlap = true;
                }
            }

            // フローティングウィンドウを取得する
            pcElement = m_cFloatingList.GetElementWindow( hChild );
            if ( nullptr != pcElement ) {
                // カレントエレメントウィンドウを設定する
                if ( m_cFloatingList.SetCurrentElement( pcElement ) ) {
                    // フローティングウィンドウフォーカス有効フラグをセットする
                    m_bFocusFloating = true;
                }
            }

            // 基底クラスの関数を実行する
            result = CWndOverlap::WmNotifyChildSetFocus();
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_NOTIFY_CHILD_LBUTTONUPメッセージ処理関数
    LRESULT CWndMain::WmNotifyChildLButtonUp() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // 子ウィンドウハンドルを調べる
            HWND hChild = reinterpret_cast< HWND >( m_lParam );
            if ( m_cToolBar.GetHandle() == hChild ) {
                // ツールバーマウスアクティベートフラグを調べる
                if ( m_bToolBarMouseActivate ) {
                    // ツールバーボタン選択有効フラグを調べる
                    if ( !m_bValidToolBarSelect ) {
                        // ツールバーマウスアクティベートフラグをクリアする
                        m_bToolBarMouseActivate = false;

                        // フォーカスウィンドウを設定する
                        ::SetFocus( m_hWnd );
                    }
                }
            }

            // 基底クラスの関数を実行する
            result = CWndOverlap::WmNotifyChildLButtonUp();
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_NOTIFY_CHILD_COMMANDメッセージ処理関数
    LRESULT CWndMain::WmNotifyChildCommand() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // メニューバーを更新する
            UpdateMenuBar();

            // 基底クラスの関数を実行する
            result = CWndOverlap::WmNotifyChildCommand();
        } while ( false );

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

    //-------------------------------------------------------------------------
    // ウィンドウ構成情報初期化関数
    bool CWndMain::InitConfig( CJsonConfig& rcConfig ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 基底クラスの関数を実行する
            if ( !CWndOverlap::InitConfig( rcConfig ) ) {
                // 失敗！
                break;
            }
            // オーバーラップウィンドウリスト構成情報を初期化する
            else if ( !m_cOverlapList.InitElementListConfig( rcConfig, &CreateOverlapWindow, SECTION_OVERLAP_LIST ) ) {
                // 失敗！
                break;
            }
            // フローティングウィンドウリスト構成情報を初期化する
            else if ( !m_cFloatingList.InitElementListConfig( rcConfig, &CreateFloatingWindow, SECTION_FLOATING_LIST ) ) {
                // 失敗！
                break;
            }

            // オーバーラップウィンドウフォーカス有効フラグを取得する
            rcConfig.Get( m_bFocusOverlap, KEY_FOCUS_OVERLAP );

            // フローティングウィンドウフォーカス有効フラグを取得する
            rcConfig.Get( m_bFocusFloating, KEY_FOCUS_FLOATING );

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

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

    //-------------------------------------------------------------------------
    // ウィンドウ構成情報復元関数
    bool CWndMain::ResumeConfig( CJsonConfig& rcConfig ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ツールバー表示状態を復元する
            bool bView = true;
            rcConfig.Get( bView, KEY_VIEW_TOOLBAR );
            ::ShowWindow( m_cToolBar.GetHandle(), ( bView? SW_SHOWNOACTIVATE: SW_HIDE ) );

            // ステータスバー表示状態を復元する
            bView = true;
            rcConfig.Get( bView, KEY_VIEW_STATUSBAR );
            ::ShowWindow( m_hStatusBar, ( bView? SW_SHOWNOACTIVATE: SW_HIDE ) );

            // フォーカスウィンドウオーダー番号を取得する
            int nOrder = 0;
            if ( rcConfig.Get( nOrder, KEY_FOCUS_ORDER ) ) {
                // オーダー番号ペインウィンドウを取得する
                CWndPane* pcPane = GetOrderPane( &nOrder );
                if ( nullptr != pcPane ) {
                    // フォーカスウィンドウ保存ハンドルを設定する
                    s_hFocus = pcPane->GetHandle();
                }
            }

            // 基底クラスの関数を実行する
            if ( !CWndOverlap::ResumeConfig( rcConfig ) ) {
                // 失敗！
                break;
            }
            // オーバーラップウィンドウリスト構成情報を復元する
            else if ( !m_cOverlapList.ResumeElementListConfig( rcConfig, SECTION_OVERLAP_LIST ) ) {
                // 失敗！
                break;
            }
            // フローティングウィンドウリスト構成情報を復元する
            else if ( !m_cFloatingList.ResumeElementListConfig( rcConfig, SECTION_FLOATING_LIST ) ) {
                // 失敗！
                break;
            }

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

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

    //-------------------------------------------------------------------------
    // ウィンドウ構成情報保存関数
    bool CWndMain::SaveConfig( CJsonConfig& rcConfig ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 基底クラスの関数を実行する
            if ( !CWndOverlap::SaveConfig( rcConfig ) ) {
                // 失敗！
                break;
            }
            // オーバーラップウィンドウリスト構成情報を保存する
            else if ( !m_cOverlapList.SaveElementListConfig( rcConfig, SECTION_OVERLAP_LIST ) ) {
                // 失敗！
                break;
            }
            // フローティングウィンドウリスト構成情報を保存する
            else if ( !m_cFloatingList.SaveElementListConfig( rcConfig, SECTION_FLOATING_LIST ) ) {
                // 失敗！
                break;
            }

            // オーバーラップウィンドウフォーカス有効状態を調べる
            if ( m_bFocusOverlap ) {
                // オーバーラップウィンドウフォーカス有効状態を保存する
                if ( !rcConfig.Set( true, KEY_FOCUS_OVERLAP ) ) {
                    // 失敗！
                    break;
                }
            }

            // フローティングウィンドウフォーカス有効状態を調べる
            if ( m_bFocusFloating ) {
                // フローティングウィンドウフォーカス有効状態を保存する
                if ( !rcConfig.Set( true, KEY_FOCUS_FLOATING ) ) {
                    // 失敗！
                    break;
                }
            }

            // フォーカス保存ペインウィンドウを取得する
            CWndPane* pcFocus = GetPaneWindow( s_hFocus );
            if ( nullptr != pcFocus ) {
                // オーダー番号を取得する
                int nOrder = pcFocus->GetOrderIndex();
                if ( 0 <= nOrder ) {
                    // フォーカスウィンドウオーダー番号を保存する
                    if ( !rcConfig.Set( nOrder, KEY_FOCUS_ORDER ) ) {
                        // 失敗！
                        break;
                    }
                }
            }

            // ツールバー表示状態を調べる
            if ( 0 == ::IsWindowVisible( m_cToolBar.GetHandle() ) ) {
                // ツールバー表示状態を保存する
                if ( !rcConfig.Set( false, KEY_VIEW_TOOLBAR ) ) {
                    // 失敗！
                    break;
                }
            }

            // ステータスバー表示状態を調べる
            if ( 0 == ::IsWindowVisible( m_hStatusBar ) ) {
                // ステータスバー表示状態を保存する
                if ( !rcConfig.Set( false, KEY_VIEW_STATUSBAR ) ) {
                    // 失敗！
                    break;
                }
            }

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

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

    //-------------------------------------------------------------------------
    // 子ペインウィンドウ情報取得関数
    bool CWndMain::GetChildPaneInfo( SChildPaneInfo& rsChildInfo ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 基底クラスの関数を実行する
            if ( !CWndOverlap::GetChildPaneInfo( rsChildInfo ) ) {
                // 失敗！
                break;
            }
            // オーバーラップウィンドウリスト情報を取得する
            else if ( !m_cOverlapList.GetChildElementListInfo( this, rsChildInfo ) ) {
                // 失敗！
                break;
            }
            // フローティングウィンドウリスト情報を取得する
            else if ( !m_cFloatingList.GetChildElementListInfo( this, rsChildInfo ) ) {
                // 失敗！
                break;
            }

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

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

    //-------------------------------------------------------------------------
    // ペインウィンドウオーダー番号取得関数
    int CWndMain::GetOrderIndex( CWndPane* pcPane, int* pnOrder ) noexcept {
        // 処理ブロック
        int result = -1;
        do {
            // 基底クラスの関数を実行する
            int nOrder = CWndOverlap::GetOrderIndex( pcPane, pnOrder );
            if ( 0 > nOrder ) {
                // オーバーラップウィンドウリストオーダー番号を取得する
                nOrder = m_cOverlapList.GetElementListOrderIndex( pcPane, pnOrder );
                if ( 0 > nOrder ) {
                    // フローティングウィンドウリストオーダー番号を取得する
                    nOrder = m_cFloatingList.GetElementListOrderIndex( pcPane, pnOrder );
                    if ( 0 > nOrder ) {
                        // 失敗！
                        break;
                    }
                }
            }

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

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

    //-------------------------------------------------------------------------
    // オーダー番号ペインウィンドウ取得関数
    CWndPane* CWndMain::GetOrderPane( int* pnOrder ) noexcept {
        // 処理ブロック
        CWndPane* result = nullptr;
        do {
            // 基底クラスの関数を実行する
            CWndPane* pcPane = CWndOverlap::GetOrderPane( pnOrder );
            if ( nullptr == pcPane ) {
                // オーバーラップウィンドウリストオーダー番号ペインウィンドウを取得する
                pcPane = m_cOverlapList.GetElementListOrderPane( pnOrder );
                if ( nullptr == pcPane ) {
                    // フローティングウィンドウリストオーダー番号ペインウィンドウを取得する
                    pcPane = m_cFloatingList.GetElementListOrderPane( pnOrder );
                    if ( nullptr == pcPane ) {
                        // 失敗！
                        break;
                    }
                }
            }

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

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

    //-------------------------------------------------------------------------
    // 子ウィンドウ削除関数
    bool CWndMain::DeleteChildWindow( CWndPane* pcChild ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 子ペインウィンドウポインタを調べる
            if ( nullptr == pcChild ) {
                // 失敗！
                break;
            }

            // フォーカスウィンドウ保存ハンドルを調べる
            bool bFocus = ( IsOwnOrChild( m_hWnd, s_hFocus ) );

            // オーバーラップウィンドウリストから削除する
            if ( m_cOverlapList.RemoveElementWindow( pcChild ) ) {
                // 子ウィンドウインスタンスを削除する
                delete pcChild;

                // フォーカス状態を調べる
                if ( bFocus ) {
                    // フォーカスウィンドウをクリアする
                    ::SetFocus( nullptr );

                    // フォーカスウィンドウを設定する
                    ::SetFocus( m_hWnd );
                }

                // 成功！
                result = true;
                break;
            }
            // フローティングウィンドウリストから削除する
            else if ( m_cFloatingList.RemoveElementWindow( pcChild ) ) {
                // 子ウィンドウインスタンスを削除する
                delete pcChild;

                // フォーカス状態を調べる
                if ( bFocus ) {
                    // フォーカスウィンドウをクリアする
                    ::SetFocus( nullptr );

                    // フォーカスウィンドウを設定する
                    ::SetFocus( m_hWnd );
                }

                // 成功！
                result = true;
                break;
            }

            // 基底クラスの関数を実行する
            result = CWndOverlap::DeleteChildWindow( pcChild );
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 全子ウィンドウ表示関数
    bool CWndMain::ShowChildAll( bool bShow ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 基底クラスの関数を実行する
            if ( !CWndOverlap::ShowChildAll( bShow ) ) {
                // 失敗！
                break;
            }
            // 全オーバーラップウィンドウリストを表示する
            else if ( !m_cOverlapList.ShowElementListAll( this, bShow ) ) {
                // 失敗！
                break;
            }
            // 全フローティングウィンドウリストを表示する
            else if ( !m_cFloatingList.ShowElementListAll( this, bShow ) ) {
                // 失敗！
                break;
            }

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

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

    //-------------------------------------------------------------------------
    // 全子ウィンドウ削除関数
    bool CWndMain::DeleteChildAll() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 全フローティングウィンドウリストを削除する
            if ( !m_cFloatingList.DeleteElementListAll( this ) ) {
                // 失敗！
                break;
            }
            // 全オーバーラップウィンドウリストを削除する
            else if ( !m_cOverlapList.DeleteElementListAll( this ) ) {
                // 失敗！
                break;
            }

            // 基底クラスの関数を実行する
            result = CWndOverlap::DeleteChildAll();
        } while ( false );

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

    //-------------------------------------------------------------------------
    // メニューコマンド実行関数
    bool CWndMain::ExecMenuCommand( WORD wId, WORD wCode, HWND hCtrl ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // コマンドIDを調べる
            switch ( wId ) {
            case ID_FILE_EXIT: // ファイル::終了
                // クローズメッセージをポストする
                ::PostMessageW( m_hWnd, WM_CLOSE, 0, 0 );

                // 成功！
                result = true;
                break;
            case ID_VIEW_TOOLBAR: // 表示::ツールバー
                // ツールバー表示状態を調べる
                if ( 0 == ::IsWindowVisible( m_cToolBar.GetHandle() ) ) {
                    // ツールバーを表示する
                    ::ShowWindow( m_cToolBar.GetHandle(), SW_SHOWNA );
                }
                else {
                    // ツールバーを隠す
                    ::ShowWindow( m_cToolBar.GetHandle(), SW_HIDE );
                }

                // WM_SIZEメッセージを送信する
                ::SendMessageW( m_hWnd, WM_SIZE, 0, 0 );
                ::UpdateWindow( m_hWnd );

                // 成功！
                result = true;
                break;
            case ID_VIEW_STATUSBAR: // 表示::ステータスバー
                // ステータスバー表示状態を調べる
                if ( 0 == ::IsWindowVisible( m_hStatusBar ) ) {
                    // ステータスバーを表示する
                    ::ShowWindow( m_hStatusBar, SW_SHOWNA );
                }
                else {
                    // ステータスバーを隠す
                    ::ShowWindow( m_hStatusBar, SW_HIDE );
                }

                // WM_SIZEメッセージを送信する
                ::SendMessageW( m_hWnd, WM_SIZE, 0, 0 );
                ::UpdateWindow( m_hWnd );

                // 成功！
                result = true;
                break;
            case ID_WINDOW_FLOATING: // ウィンドウ::フローティング
                // ドッキングウィンドウをフローティング表示する
                DockingToFloating( hCtrl );

                // 成功！
                result = true;
                break;
            case ID_WINDOW_DOCKING: // ウィンドウ::ドッキング
                // フローティングウィンドウをドッキング表示する
                FloatingToDocking( hCtrl );

                // 成功！
                result = true;
                break;
            case ID_WINDOW_POS_LEFT: // ウィンドウ::表示位置::左側
                // ウィンドウを左端に表示する
                SetWindowPosition( m_hWnd, EWindowPosition::Left );

                // 成功！
                result = true;
                break;
            case ID_WINDOW_POS_RIGHT: // ウィンドウ::表示位置::右側
                // ウィンドウを右端に表示する
                SetWindowPosition( m_hWnd, EWindowPosition::Right );

                // 成功！
                result = true;
                break;
            case ID_WINDOW_POS_TOP: // ウィンドウ::表示位置::上側
                // ウィンドウを上端に表示する
                SetWindowPosition( m_hWnd, EWindowPosition::Top );

                // 成功！
                result = true;
                break;
            case ID_WINDOW_POS_BOTTOM: // ウィンドウ::表示位置::下側
                // ウィンドウを下端に表示する
                SetWindowPosition( m_hWnd, EWindowPosition::Bottom );

                // 成功！
                result = true;
                break;
            case ID_WINDOW_POS_FULL: // ウィンドウ::表示位置::フルサイズ
                // ウィンドウをフルサイズ表示する
                SetWindowPosition( m_hWnd, EWindowPosition::Full );

                // 成功！
                result = true;
                break;
            case ID_WINDOW_POS_MAXIMIZE: // ウィンドウ::表示位置::最大化
                // ウィンドウ最大化状態を調べる
                if ( ::IsZoomed( m_hWnd ) ) {
                    // ウィンドウを通常表示する
                    ::ShowWindow( m_hWnd, SW_SHOWNOACTIVATE );
                }
                else {
                    // ウィンドウを最大化する
                    ::ShowWindow( m_hWnd, SW_SHOWMAXIMIZED );
                }

                // 成功！
                result = true;
                break;
            case ID_HELP_ABOUT: // ヘルプ::バージョン情報
                // メッセージを表示する
                ShowMessage( L"こんにちわ！世界" );

                // 成功！
                result = true;
                break;
            case ID_DEBUG_SHOW_ALL: // デバッグ::すべて表示
                // 全子ウィンドウを表示する
                ShowChildAll( true );

                // 成功！
                result = true;
                break;
            case ID_DEBUG_HIDE_ALL: // デバッグ::すべて隠す
                // 全子ウィンドウを隠す
                ShowChildAll( false );

                // 成功！
                result = true;
                break;
            case ID_DEBUG_DELETE_ALL: // デバッグ::すべて削除
                {
                    // 確認する
                    int nResult = ShowMessage( L"この操作は元に戻せません。\r\n本当に削除しても良いですか？", m_hWnd, MB_OKCANCEL );
                    if ( IDOK == nResult ) {
                        // 全子ウィンドウを削除する
                        DeleteChildAll();
                    }
                }

                // 成功！
                result = true;
                break;
            case ID_DEBUG_SHOW_DENUG_INFO: // デバッグ::デバッグ情報表示
                // デバッグ情報を表示する
                ShowDebugInfo();

                // 成功！
                result = true;
                break;
            case ID_DEBUG_DRAW_DOUBLE_BUFFER: // デバッグ::ダブルバッファリング描画
                // ダブルバッファリング描画フラグを反転する
                s_bDrawDoubleBuffer = !s_bDrawDoubleBuffer;

                // 成功！
                result = true;
                break;
            case ID_DEBUG_REALTIME_RESIZE_PARTITION: // デバッグ::リアルタイムパーティションサイズ変更
                // リアルタイムパーティションサイズ変更フラグを反転する
                s_bResizePartitionRealTime = !s_bResizePartitionRealTime;

                // 成功！
                result = true;
                break;
            case ID_DEBUG_NEW_OVERLAP: // デバッグ::新規オーバーラップウィンドウ
                // 新規オーバーラップウィンドウを追加する
                AppendNewOverlapWindow();

                // 成功！
                result = true;
                break;
            case ID_DEBUG_NEW_FLOATING: // デバッグ::新規フローティングウィンドウ
                // 新規フローティングウィンドウを追加する
                AppendNewFloatingWindow();

                // 成功！
                result = true;
                break;
            default:
                // 基底クラスの関数を実行する
                result = CWndOverlap::ExecMenuCommand( wId, wCode, hCtrl );
                break;
            }

            // 実行結果を調べる
            if ( result ) {
                // メニューバーを更新する
                UpdateMenuBar();
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // コンテキストメニュー作成関数
    HMENU CWndMain::CreateContextMenu() noexcept {
        // 処理ブロック
        HMENU result = nullptr;
        do {
            // ポップアップメニューを作成する
            HMENU hMenu = ::CreatePopupMenu();
            if ( nullptr == hMenu ) {
                // 失敗！
                break;
            }

            // サブメニューを作成する
            HMENU hSubMenu = ::CreatePopupMenu();
            if ( nullptr != hSubMenu ) {
                // 共通デバッグメニューを追加する
                AppendCommonDebugMenu( hSubMenu );

                // サブメニューを追加する
                ::AppendMenuW( hMenu, MF_POPUP, reinterpret_cast< UINT_PTR >( hSubMenu ), L"共通" );
                if ( 0 >= GetEnableMenuCommandCount( hSubMenu ) ) {
                    // サブメニューを無効化する
                    ::EnableMenuItem( hMenu, ( ::GetMenuItemCount( hMenu ) - 1 ), ( MF_BYPOSITION | MFS_DISABLED ) );
                }

                // セパレータを追加する
                ::AppendMenuW( hMenu, MF_SEPARATOR, 0, nullptr );
            }

            // ウィンドウタイトルを取得する
            wchar_t szBuffer[ MAX_PATH ];
            ::GetWindowTextW( m_hWnd, szBuffer, MAX_PATH );

            // メニュー見出しを追加する
            ::AppendMenuW( hMenu, MF_STRING, 0, szBuffer );
            ::EnableMenuItem( hMenu, ( ::GetMenuItemCount( hMenu ) - 1 ), ( MF_BYPOSITION | MFS_GRAYED ) );

            // デバッグメニューを追加する
            AppendDebugMenu( hMenu );

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

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

    //-------------------------------------------------------------------------
    // デバッグメニュー追加関数
    bool CWndMain::AppendDebugMenu( HMENU hMenu ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 基底クラスの関数を実行する
            if ( !CWndOverlap::AppendDebugMenu( hMenu ) ) {
                // 失敗！
                break;
            }
            // オーバーラップウィンドウリストデバッグサブメニューを追加する
            else if ( !m_cOverlapList.AppendElementListDebugSubMenu( hMenu, this, L"オーバーラップウィンドウ", ID_DEBUG_NEW_OVERLAP ) ) {
                // 失敗！
                break;
            }
            // フローティングウィンドウリストデバッグサブメニューを追加する
            else if ( !m_cFloatingList.AppendElementListDebugSubMenu( hMenu, this, L"フローティングウィンドウ", ID_DEBUG_NEW_FLOATING ) ) {
                // 失敗！
                break;
            }

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

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

    //-------------------------------------------------------------------------
    // パーティション表示クライアント領域取得関数
    bool CWndMain::GetPartitionClientRect( RECT& rsRect ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // クライアント領域を取得する
            RECT sClientRect;
            if ( 0 == ::GetClientRect( m_hWnd, &sClientRect ) ) {
                // 失敗！
                break;
            }

            // ツールバー表示状態を調べる
            if ( 0 != ::IsWindowVisible( m_cToolBar.GetHandle() ) ) {
                // クライアント領域から減算する
                if ( !SubtractChildRect( m_cToolBar.GetHandle(), sClientRect ) ) {
                    // 失敗！
                    break;
                }
            }

            // セパレータ表示状態を調べる
            if ( 0 != ::IsWindowVisible( m_hSeparator ) ) {
                // クライアント領域から減算する
                if ( !SubtractChildRect( m_hSeparator, sClientRect ) ) {
                    // 失敗！
                    break;
                }
            }

            // ステータスバー表示状態を調べる
            if ( 0 != ::IsWindowVisible( m_hStatusBar ) ) {
                // クライアント領域から減算する
                if ( !SubtractChildRect( m_hStatusBar, sClientRect ) ) {
                    // 失敗！
                    break;
                }
            }

            // 子ウィンドウ表示領域を取得する
            rsRect = sClientRect;

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

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

    //-------------------------------------------------------------------------
    // 全ウィンドウクライアント領域更新関数
    bool CWndMain::UpdateClientRectAll() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 基底クラスの関数を実行する
            if ( !CWndOverlap::UpdateClientRectAll() ) {
                // 失敗！
                break;
            }

            // 巡回する
            for ( int nIndex = 0, nCount = m_cOverlapList.GetCount(); nCount > nIndex; ++nIndex ) {
                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_cOverlapList[ nIndex ];
                if ( nullptr != pcElement ) {
                    // 全ウィンドウクライアント領域を更新する
                    pcElement->UpdateClientRectAll();
                }
            }

            // 巡回する
            for ( int nIndex = 0, nCount = m_cFloatingList.GetCount(); nCount > nIndex; ++nIndex ) {
                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_cFloatingList[ nIndex ];
                if ( nullptr != pcElement ) {
                    // 全ウィンドウクライアント領域を更新する
                    pcElement->UpdateClientRectAll();
                }
            }

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

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

    //-------------------------------------------------------------------------
    // デバッグ情報表示関数
    bool CWndMain::ShowDebugInfo() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // デバッグ情報表示フラグを反転する
            s_bShowDebugInfo = !s_bShowDebugInfo;

            // 全ウィンドウクライアント領域を更新する
            UpdateClientRectAll();

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

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

    //-------------------------------------------------------------------------
    // 新規オーバーラップウィンドウ追加関数
    bool CWndMain::AppendNewOverlapWindow() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 新規オーバーラップウィンドウを追加する
            CWndElement* pcElement = m_cOverlapList.AppendNewElementWindow( m_hWnd, &CreateOverlapWindow );
            if ( nullptr == pcElement ) {
                // 失敗！
                break;
            }

            // ウィンドウを表示する
            ::ShowWindow( pcElement->GetHandle(), SW_SHOWNA );

            // WM_SIZEメッセージを送信する
            ::SendMessageW( pcElement->GetHandle(), WM_SIZE, 0, 0 );
            ::UpdateWindow( pcElement->GetHandle() );

            // フォーカスウィンドウを設定する
            ::SetFocus( pcElement->GetHandle() );

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

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

    //-------------------------------------------------------------------------
    // 新規フローティングウィンドウ追加関数
    bool CWndMain::AppendNewFloatingWindow() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 新規フローティングウィンドウを追加する
            CWndElement* pcElement = m_cFloatingList.AppendNewElementWindow( m_hWnd, &CreateFloatingWindow );
            if ( nullptr == pcElement ) {
                // 失敗！
                break;
            }

            // ウィンドウを表示する
            ::ShowWindow( pcElement->GetHandle(), SW_SHOWNA );

            // WM_SIZEメッセージを送信する
            ::SendMessageW( pcElement->GetHandle(), WM_SIZE, 0, 0 );
            ::UpdateWindow( pcElement->GetHandle() );

            // フォーカスウィンドウを設定する
            ::SetFocus( pcElement->GetHandle() );

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

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

    //-------------------------------------------------------------------------
    // ドッキングウィンドウフローティング表示関数
    bool CWndMain::DockingToFloating( HWND hWnd ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ドッキングウィンドウを取得する
            CWndDocking* pcDocking = reinterpret_cast< CWndDocking* >( GetPaneWindow( hWnd ) );
            if ( nullptr == pcDocking ) {
                // 失敗！
                break;
            }

            // 親パーティションウィンドウを取得する
            CWndPartition* pcPartition = reinterpret_cast< CWndPartition* >( GetPaneWindow( ::GetParent( pcDocking->GetHandle() ) ) );
            if ( nullptr == pcPartition ) {
                // 失敗！
                break;
            }

            // エレメントウィンドウリストを取得する
            CWndList* pcElementList = pcPartition->GetElementList();
            if ( nullptr == pcElementList ) {
                // 失敗！
                break;
            }
            // エレメントウィンドウリストから削除する
            else if ( !pcElementList->RemoveElementWindow( pcDocking ) ) {
                // 失敗！
                break;
            }

            // フローティングウィンドウを作成する
            CWndFloating* pcFloating = new CWndFloating( std::move( *pcDocking ) );
            if ( nullptr != pcFloating ) {
                // フローティングウィンドウを追加する
                if ( m_cFloatingList.AppendElementWindow( m_hWnd, pcFloating ) ) {
                    // エレメントウィンドウリストを取得する
                    pcElementList = pcFloating->GetElementList();
                    if ( nullptr != pcElementList ) {
                        // 巡回する
                        for ( int nIndex = 0, nCount = pcElementList->GetCount(); nCount > nIndex; ++nIndex ) {
                            // エレメントウィンドウを取得する
                            CWndElement* pcElement = ( *pcElementList )[ nIndex ];
                            if ( nullptr != pcElement ) {
                                // 親ウィンドウを設定する
                                ::SetParent( pcElement->GetHandle(), pcFloating->GetHandle() );
                            }
                        }
                    }

                    // ウィンドウを表示する
                    ::ShowWindow( pcFloating->GetHandle(), SW_SHOWNA );

                    // WM_SIZEメッセージを送信する
                    ::SendMessageW( pcFloating->GetHandle(), WM_SIZE, 0, 0 );
                    ::UpdateWindow( pcFloating->GetHandle() );

                    // フォーカスウィンドウを設定する
                    ::SetFocus( pcFloating->GetHandle() );

                    // 成功！
                    result = true;
                }
                else {
                    // フローティングウィンドウを削除する
                    delete pcFloating;
                }
            }

            // ドッキングウィンドウを削除する
            delete pcDocking;

            // パーティションウィンドウにWM_SIZEメッセージを送信する
            ::SendMessageW( pcPartition->GetHandle(), WM_SIZE, 0, 0 );
            ::UpdateWindow( pcPartition->GetHandle() );
        } while ( false );

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

    //-------------------------------------------------------------------------
    // フローティングウィンドウドッキング表示関数
    bool CWndMain::FloatingToDocking( HWND hWnd ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 共通デバッグメニュー追加関数
    bool CWndMain::AppendCommonDebugMenu( HMENU hMenu ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // メニューハンドルを調べる
            if ( nullptr == hMenu ) {
                // 失敗！
                break;
            }

            // 子ペインウィンドウ数を取得する
            int nCount = GetChildCount();

            // 表示状態子ペインウィンドウ数を取得する
            int nShow = GetShowChildCount();

            // 非表示状態子ペインウィンドウ数を取得する
            int nHide = GetHideChildCount();

            // 非表示可能子ペインウィンドウ数を取得する
            int nHideable = GetHideableChildCount();

            // 削除可能子ペインウィンドウ数を取得する
            int nDeletable = GetDeletableChildCount();

            // 子ペインウィンドウを列挙する
            bool bShow   = ( nCount > nShow );
            bool bHide   = ( nHideable > nHide ) ;
            bool bDelete = ( 0 < nDeletable );

            // 共通メニューコマンドを追加する
            ::AppendMenuW( hMenu, MF_STRING, ID_DEBUG_SHOW_ALL,   L"すべて表示" );
            ::AppendMenuW( hMenu, MF_STRING, ID_DEBUG_HIDE_ALL,   L"すべて非表示" );
            ::AppendMenuW( hMenu, MF_STRING, ID_DEBUG_DELETE_ALL, L"すべて削除" );
            EnableMenuCommand ( hMenu, ID_DEBUG_SHOW_ALL,   bShow );
            EnableMenuCommand ( hMenu, ID_DEBUG_HIDE_ALL,   bHide );
            EnableMenuCommand ( hMenu, ID_DEBUG_DELETE_ALL, bDelete );
            CheckMenuCommand  ( hMenu, ID_DEBUG_SHOW_ALL,   !bShow );
            CheckMenuCommand  ( hMenu, ID_DEBUG_HIDE_ALL,   !bHide );
            SetMenuCommandData( hMenu, ID_DEBUG_SHOW_ALL,   reinterpret_cast< ULONG_PTR >( m_hWnd ) );
            SetMenuCommandData( hMenu, ID_DEBUG_HIDE_ALL,   reinterpret_cast< ULONG_PTR >( m_hWnd ) );
            SetMenuCommandData( hMenu, ID_DEBUG_DELETE_ALL, reinterpret_cast< ULONG_PTR >( m_hWnd ) );
            ::AppendMenuW( hMenu, MF_SEPARATOR, 0, nullptr );
            ::AppendMenuW( hMenu, MF_STRING, ID_DEBUG_SHOW_DENUG_INFO,           L"デバッグ情報表示" );
            ::AppendMenuW( hMenu, MF_STRING, ID_DEBUG_DRAW_DOUBLE_BUFFER,        L"ダブルバッファリング描画" );
            ::AppendMenuW( hMenu, MF_STRING, ID_DEBUG_REALTIME_RESIZE_PARTITION, L"リアルタイムパーティションサイズ変更" );
            CheckMenuCommand  ( hMenu, ID_DEBUG_SHOW_DENUG_INFO,           s_bShowDebugInfo );
            CheckMenuCommand  ( hMenu, ID_DEBUG_DRAW_DOUBLE_BUFFER,        s_bDrawDoubleBuffer );
            CheckMenuCommand  ( hMenu, ID_DEBUG_REALTIME_RESIZE_PARTITION, s_bResizePartitionRealTime );
            SetMenuCommandData( hMenu, ID_DEBUG_SHOW_DENUG_INFO,           reinterpret_cast< ULONG_PTR >( m_hWnd ) );
            SetMenuCommandData( hMenu, ID_DEBUG_DRAW_DOUBLE_BUFFER,        reinterpret_cast< ULONG_PTR >( m_hWnd ) );
            SetMenuCommandData( hMenu, ID_DEBUG_REALTIME_RESIZE_PARTITION, reinterpret_cast< ULONG_PTR >( m_hWnd ) );

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

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

    //-------------------------------------------------------------------------
    // メニューバー更新関数
    bool CWndMain::UpdateMenuBar() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 巡回する
            for ( int nCount = ::GetMenuItemCount( m_hMenu ), nIndex = ( nCount - 1 ); 0 <= nIndex; --nIndex ) {
                // メニューを削除する
                ::DeleteMenu( m_hMenu, nIndex, MF_BYPOSITION );
            }

            // メインメニューを追加する
            if ( !AppendMainMenu( m_hMenu ) ) {
                // 失敗！
                break;
            }

            // メニューバーを再描画する
            ::DrawMenuBar( m_hWnd );

            // ツールバーを更新する
            UpdateToolBar();

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

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

    //-------------------------------------------------------------------------
    // メインメニュー追加関数
    bool CWndMain::AppendMainMenu( HMENU hMenu ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // メニューハンドルを調べる
            if ( nullptr == hMenu ) {
                // 失敗！
                break;
            }

            // サブメニューを作成する
            HMENU hSubMenu = ::CreatePopupMenu();
            if ( nullptr == hSubMenu ) {
                // 失敗！
                break;
            }

            // ファイルメニューコマンドを追加する
            ::AppendMenuW( hSubMenu, MF_STRING, ID_FILE_NEW,         L"新規作成(&N)\tCtrl+N" );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_FILE_OPEN,        L"開く(&O)...\tCtrl+O" );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_FILE_CLOSE,       L"閉じる(&C)\tCtrl+W,Ctrl+F4" );
            ::AppendMenuW( hSubMenu, MF_SEPARATOR, 0, nullptr );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_FILE_SAVE,        L"保存(&S)\tCtrl+S" );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_FILE_SAVE_AS,     L"名前を付けて保存(&A)...\tCtrl+Shift+S" );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_FILE_SAVE_ALL,    L"すべて保存(&L)" );
            ::AppendMenuW( hSubMenu, MF_SEPARATOR, 0, nullptr );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_FILE_PRINT,       L"印刷(&P)...\tCtrl+P" );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_FILE_RECENT_FILE, L"最近使ったファイル(&F)..." );
            ::AppendMenuW( hSubMenu, MF_SEPARATOR, 0, nullptr );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_FILE_EXIT,        L"終了(&X)\tAlt+F4" );
            ::AppendMenuW( hSubMenu, MF_SEPARATOR, 0, nullptr );
            EnableMenuCommand( hSubMenu, ID_FILE_NEW,         false );
            EnableMenuCommand( hSubMenu, ID_FILE_OPEN,        false );
            EnableMenuCommand( hSubMenu, ID_FILE_CLOSE,       false );
            EnableMenuCommand( hSubMenu, ID_FILE_SAVE,        false );
            EnableMenuCommand( hSubMenu, ID_FILE_SAVE_AS,     false );
            EnableMenuCommand( hSubMenu, ID_FILE_SAVE_ALL,    false );
            EnableMenuCommand( hSubMenu, ID_FILE_PRINT,       false );
            EnableMenuCommand( hSubMenu, ID_FILE_RECENT_FILE, false );

            // サブメニューを追加する
            ::AppendMenuW( hMenu, MF_POPUP, reinterpret_cast< UINT_PTR >( hSubMenu ), L"ファイル(&F)" );
            if ( 0 >= GetEnableMenuCommandCount( hSubMenu ) ) {
                // サブメニューを無効化する
                ::EnableMenuItem( hMenu, ( ::GetMenuItemCount( hMenu ) - 1 ), ( MF_BYPOSITION | MFS_DISABLED ) );
            }

            // サブメニューを作成する
            hSubMenu = ::CreatePopupMenu();
            if ( nullptr == hSubMenu ) {
                // 失敗！
                break;
            }

            // 編集メニューコマンドを追加する
            ::AppendMenuW( hSubMenu, MF_STRING, ID_EDIT_UNDO,       L"元に戻す(&U)\tCtrl+Z" );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_EDIT_REDO,       L"やり直し(&R)\tCtrl+Y" );
            ::AppendMenuW( hSubMenu, MF_SEPARATOR, 0, nullptr );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_EDIT_CUT,        L"切り取り(&T)\tCtrl+X" );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_EDIT_COPY,       L"コピー(&C)\tCtrl+C" );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_EDIT_PASTE,      L"貼り付け(&P)\tCtrl+V" );
            ::AppendMenuW( hSubMenu, MF_SEPARATOR, 0, nullptr );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_EDIT_DELETE,     L"削除(&D)\tDel" );
            ::AppendMenuW( hSubMenu, MF_SEPARATOR, 0, nullptr );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_EDIT_SELECT_ALL, L"すべて選択(&A)\tCtrl+A" );
            EnableMenuCommand( hSubMenu, ID_EDIT_UNDO,       false );
            EnableMenuCommand( hSubMenu, ID_EDIT_REDO,       false );
            EnableMenuCommand( hSubMenu, ID_EDIT_CUT,        false );
            EnableMenuCommand( hSubMenu, ID_EDIT_COPY,       false );
            EnableMenuCommand( hSubMenu, ID_EDIT_PASTE,      false );
            EnableMenuCommand( hSubMenu, ID_EDIT_DELETE,     false );
            EnableMenuCommand( hSubMenu, ID_EDIT_SELECT_ALL, false );

            // サブメニューを追加する
            ::AppendMenuW( hMenu, MF_POPUP, reinterpret_cast< UINT_PTR >( hSubMenu ), L"編集(&E)" );
            if ( 0 >= GetEnableMenuCommandCount( hSubMenu ) ) {
                // サブメニューを無効化する
                ::EnableMenuItem( hMenu, ( ::GetMenuItemCount( hMenu ) - 1 ), ( MF_BYPOSITION | MFS_DISABLED ) );
            }

            // サブメニューを作成する
            hSubMenu = ::CreatePopupMenu();
            if ( nullptr == hSubMenu ) {
                // 失敗！
                break;
            }

            // 表示メニューコマンドを追加する
            ::AppendMenuW( hSubMenu, MF_STRING, ID_VIEW_TOOLBAR,   L"ツールバー(&T)" );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_VIEW_STATUSBAR, L"ステータスバー(&S)" );
            CheckMenuCommand( hSubMenu, ID_VIEW_TOOLBAR,   ( 0 != ::IsWindowVisible( m_cToolBar.GetHandle() ) ) );
            CheckMenuCommand( hSubMenu, ID_VIEW_STATUSBAR, ( 0 != ::IsWindowVisible( m_hStatusBar ) ) );

            // サブメニューを追加する
            ::AppendMenuW( hMenu, MF_POPUP, reinterpret_cast< UINT_PTR >( hSubMenu ), L"表示(&V)" );
            if ( 0 >= GetEnableMenuCommandCount( hSubMenu ) ) {
                // サブメニューを無効化する
                ::EnableMenuItem( hMenu, ( ::GetMenuItemCount( hMenu ) - 1 ), ( MF_BYPOSITION | MFS_DISABLED ) );
            }

            // サブメニューを作成する
            hSubMenu = ::CreatePopupMenu();
            if ( nullptr == hSubMenu ) {
                // 失敗！
                break;
            }

            // ツールメニュー項目を追加する
            ::AppendMenuW( hSubMenu, MF_STRING, ID_TOOL_CUSTOMIZE, L"カスタマイズ(&C)..." );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_TOOL_OPTION,    L"オプション(&O)..." );
            EnableMenuCommand( hSubMenu, ID_TOOL_CUSTOMIZE, false );
            EnableMenuCommand( hSubMenu, ID_TOOL_OPTION,    false );

            // サブメニューを追加する
            ::AppendMenuW( hMenu, MF_POPUP, reinterpret_cast< UINT_PTR >( hSubMenu ), L"ツール(&T)" );
            if ( 0 >= GetEnableMenuCommandCount( hSubMenu ) ) {
                // サブメニューを無効化する
                ::EnableMenuItem( hMenu, ( ::GetMenuItemCount( hMenu ) - 1 ), ( MF_BYPOSITION | MFS_DISABLED ) );
            }

            // サブメニューを作成する
            hSubMenu = ::CreatePopupMenu();
            if ( nullptr == hSubMenu ) {
                // 失敗！
                break;
            }

            // ウィンドウメニューを追加する
            ::AppendMenuW( hSubMenu, MF_STRING, ID_WINDOW_NEW,      L"新規ウィンドウ(&N)" );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_WINDOW_FLOATING, L"フローティング(&F)" );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_WINDOW_DOCKING,  L"ドッキング(&K)" );
            ::AppendMenuW( hSubMenu, MF_STRING, ID_WINDOW_LIST,     L"ウィンドウ(&W)..." );
            EnableMenuCommand( hSubMenu, ID_WINDOW_NEW,      false );
            EnableMenuCommand( hSubMenu, ID_WINDOW_FLOATING, false );
            EnableMenuCommand( hSubMenu, ID_WINDOW_DOCKING,  false );
            EnableMenuCommand( hSubMenu, ID_WINDOW_LIST,     false );

            // サブサブメニューを作成する
            HMENU hSubMenu2 = ::CreatePopupMenu();
            if ( nullptr == hSubMenu2 ) {
                // 失敗！
                break;
            }

            // ウィンドウ表示位置メニューコマンドを追加する
            ::AppendMenuW( hSubMenu2, MF_STRING, ID_WINDOW_POS_LEFT,     L"左側(&L)\tCtrl+Alt+Left" );
            ::AppendMenuW( hSubMenu2, MF_STRING, ID_WINDOW_POS_RIGHT,    L"右側(&R)\tCtrl+Alt+Right" );
            ::AppendMenuW( hSubMenu2, MF_STRING, ID_WINDOW_POS_TOP,      L"上側(&T)\tCtrl+Alt+Up" );
            ::AppendMenuW( hSubMenu2, MF_STRING, ID_WINDOW_POS_BOTTOM,   L"下側(&B)\tCtrl+Alt+Down" );
            ::AppendMenuW( hSubMenu2, MF_STRING, ID_WINDOW_POS_FULL,     L"フルサイズ(&F)\tCtrl+Alt+Enter" );
            ::AppendMenuW( hSubMenu2, MF_STRING, ID_WINDOW_POS_MAXIMIZE, L"最大化(&M)\tCtrl+Enter" );

            // サブサブメニューを追加する
            ::AppendMenuW( hSubMenu, MF_POPUP, reinterpret_cast< UINT_PTR >( hSubMenu2 ), L"表示位置(&P)" );
            if ( 0 >= GetEnableMenuCommandCount( hSubMenu2 ) ) {
                // サブサブメニューを無効化する
                ::EnableMenuItem( hMenu, ( ::GetMenuItemCount( hMenu ) - 1 ), ( MF_BYPOSITION | MFS_DISABLED ) );
            }

            // サブメニューを追加する
            ::AppendMenuW( hMenu, MF_POPUP, reinterpret_cast< UINT_PTR >( hSubMenu ), L"ウィンドウ(&W)" );
            if ( 0 >= GetEnableMenuCommandCount( hSubMenu ) ) {
                // サブメニューを無効化する
                ::EnableMenuItem( hMenu, ( ::GetMenuItemCount( hMenu ) - 1 ), ( MF_BYPOSITION | MFS_DISABLED ) );
            }

            // サブメニューを作成する
            hSubMenu = ::CreatePopupMenu();
            if ( nullptr == hSubMenu ) {
                // 失敗！
                break;
            }

            // ヘルプメニューを追加する
            ::AppendMenuW( hSubMenu, MF_STRING, ID_HELP_ABOUT, L"バージョン情報(&A)" );

            // サブメニューを追加する
            ::AppendMenuW( hMenu, MF_POPUP, reinterpret_cast< UINT_PTR >( hSubMenu ), L"ヘルプ(&H)" );
            if ( 0 >= GetEnableMenuCommandCount( hSubMenu ) ) {
                // サブメニューを無効化する
                ::EnableMenuItem( hMenu, ( ::GetMenuItemCount( hMenu ) - 1 ), ( MF_BYPOSITION | MFS_DISABLED ) );
            }

            // サブメニューを作成する
            hSubMenu = ::CreatePopupMenu();
            if ( nullptr == hSubMenu ) {
                // 失敗！
                break;
            }

            // サブサブメニューを作成する
            hSubMenu2 = ::CreatePopupMenu();
            if ( nullptr == hSubMenu2 ) {
                // 失敗！
                break;
            }

            // 共通デバッグメニューを追加する
            AppendCommonDebugMenu( hSubMenu2 );

            // サブサブメニューを追加する
            ::AppendMenuW( hSubMenu, MF_POPUP, reinterpret_cast< UINT_PTR >( hSubMenu2 ), L"共通" );
            if ( 0 >= GetEnableMenuCommandCount( hSubMenu2 ) ) {
                // サブサブメニューを無効化する
                ::EnableMenuItem( hMenu, ( ::GetMenuItemCount( hMenu ) - 1 ), ( MF_BYPOSITION | MFS_DISABLED ) );
            }

            // デバッグメニューを追加する
            AppendDebugMenu( hSubMenu );

            // サブメニューを追加する
            ::AppendMenuW( hMenu, MF_POPUP, reinterpret_cast< UINT_PTR >( hSubMenu ), L"デバッグ(&D)" );
            if ( 0 >= GetEnableMenuCommandCount( hSubMenu ) ) {
                // サブメニューを無効化する
                ::EnableMenuItem( hMenu, ( ::GetMenuItemCount( hMenu ) - 1 ), ( MF_BYPOSITION | MFS_DISABLED ) );
            }

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

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

    //-------------------------------------------------------------------------
    // アクセラレータテーブル作成関数
    bool CWndMain::CreateAccel() noexcept {
        // アクセラレータリスト
        static ACCEL sAccels[] = {
            { FVIRTKEY | FCONTROL,          L'N',      ID_FILE_NEW },
            { FVIRTKEY | FCONTROL,          L'O',      ID_FILE_OPEN },
            { FVIRTKEY | FCONTROL,          L'W',      ID_FILE_CLOSE },
            { FVIRTKEY | FCONTROL,          VK_F4,     ID_FILE_CLOSE },
            { FVIRTKEY | FCONTROL,          L'S',      ID_FILE_SAVE },
            { FVIRTKEY | FCONTROL | FSHIFT, L'S',      ID_FILE_SAVE_AS },
            { FVIRTKEY,                     VK_F1,     ID_HELP_ABOUT },
            { FVIRTKEY | FCONTROL | FALT,   VK_LEFT,   ID_WINDOW_POS_LEFT },
            { FVIRTKEY | FCONTROL | FALT,   VK_RIGHT,  ID_WINDOW_POS_RIGHT },
            { FVIRTKEY | FCONTROL | FALT,   VK_UP,     ID_WINDOW_POS_TOP },
            { FVIRTKEY | FCONTROL | FALT,   VK_DOWN,   ID_WINDOW_POS_BOTTOM },
            { FVIRTKEY | FCONTROL | FALT,   VK_RETURN, ID_WINDOW_POS_FULL },
            { FVIRTKEY | FCONTROL,          VK_RETURN, ID_WINDOW_POS_MAXIMIZE },
        };

        // 処理ブロック
        bool result = false;
        do {
            // アクセラレータテーブルを作成する
            int nCount = ( sizeof sAccels / sizeof( ACCEL ) );
            m_hAccel = ::CreateAcceleratorTableW( sAccels, nCount );
            if ( nullptr == m_hAccel ) {
                // 失敗！
                break;
            }

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

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

    //-------------------------------------------------------------------------
    // ツールバー作成関数
    bool CWndMain::CreateToolBar() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // アイコンイメージリストを作成する
            if ( !CreateIconImageList() ) {
                // 失敗！
                break;
            }
            // ツールバーボタンリストを作成する
            else if ( !CreateToolBarButtonList() ) {
                // 失敗！
                break;
            }
            // ツールバーを作成する
            else if ( !m_cToolBar.Create( m_hWnd ) ) {
                // 失敗！
                break;
            }

            // ツールバーの設定をする
            ::SendMessageW( m_cToolBar.GetHandle(), TB_BUTTONSTRUCTSIZE, sizeof( TBBUTTON ), 0 );
            ::SendMessageW( m_cToolBar.GetHandle(), TB_SETEXTENDEDSTYLE, 0, TBSTYLE_EX_MIXEDBUTTONS );
            ::SendMessageW( m_cToolBar.GetHandle(), TB_SETIMAGELIST,     0, reinterpret_cast< LPARAM >( m_hIconImageList ) );

            // ツールバーボタンを追加する
            ::SendMessageW( m_cToolBar.GetHandle(), TB_ADDBUTTONS, m_pcToolBarButtonList->GetCount(), reinterpret_cast< LPARAM >( m_pcToolBarButtonList->GetBuffer() ) );

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

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

    //-------------------------------------------------------------------------
    // ツールバー更新関数
    bool CWndMain::UpdateToolBar() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 巡回する
            for ( int nIndex = 0, nCount = m_pcToolBarButtonList->GetCount(); nCount > nIndex; ++nIndex ) {
                // ボタン種別を調べる
                if ( BTNS_BUTTON == ( *m_pcToolBarButtonList )[ nIndex ].fsStyle ) {
                    // ボタン有効状態を設定する
                    int idCommand = ( *m_pcToolBarButtonList )[ nIndex ].idCommand;
                    ::SendMessageW( m_cToolBar.GetHandle(), TB_ENABLEBUTTON, idCommand, IsEnableMenuCommand( m_hMenu, idCommand ) );
                }
            }

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

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

    //-------------------------------------------------------------------------
    // アイコンイメージリスト作成関数
    bool CWndMain::CreateIconImageList() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // アイコンイメージ情報リスト
            static SIconImageInfo const sIconImageInfoList[] = {
                { ID_FILE_NEW,    L"新規作成",       L"Generic_Document.ico", },
                { ID_FILE_OPEN,   L"開く",           L"folder_open.ico", },
                { ID_FILE_SAVE,   L"保存",           L"FloppyDisk.ico", },
                { ID_TOOL_OPTION, L"オプション",     L"1381_cog.ico", },
                { ID_HELP_ABOUT,  L"バージョン情報", L"help.ico", },
            };

            // 巡回する
            for ( int nIndex = 0, nCount = ( sizeof( sIconImageInfoList ) / sizeof( SIconImageInfo ) );; ++nIndex ) {
                // インデックスを調べる
                if ( nCount <= nIndex ) {
                    // 成功！
                    result = true;
                    break;
                }
                // アイコンイメージリストを追加する
                else if ( !m_pcIconImageList->Append( sIconImageInfoList[ nIndex ] ) ) {
                    // 失敗！
                    break;
                }
            }

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

            // 実行結果をクリアする
            result = false;

            // イメージリストを作成する
            m_hIconImageList = ::ImageList_Create( 16, 15, ILC_COLOR32 | ILC_MASK, m_pcIconImageList->GetCount(), 0 );
            if ( nullptr == m_hIconImageList ) {
                // 失敗！
                break;
            }
            // 巡回する
            else for ( int nIndex = 0, nCount = m_pcIconImageList->GetCount();; ++nIndex ) {
                // インデックスを調べる
                if ( nCount <= nIndex ) {
                    // 成功！
                    result = true;
                    break;
                }

                // アイコンファイルパスを作成する
                CString cPath;
                cPath  = PATH_ICON_IMAGE;
                cPath += ( *m_pcIconImageList )[ nIndex ].m_pszIconFileName;

                // アイコンをロードする
                HICON hIcon = reinterpret_cast< HICON >( ::LoadImageW( ::GetModuleHandleW( nullptr ), cPath, IMAGE_ICON, 0, 0, LR_LOADFROMFILE ) );
                if ( nullptr == hIcon ) {
                    // 失敗！
                    break;
                }

                // アイコンをイメージリストに追加する
                ::ImageList_AddIcon( m_hIconImageList, hIcon );

                // アイコンを削除する
                ::DeleteObject( hIcon );
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // ツールバーボタンリスト作成関数
    bool CWndMain::CreateToolBarButtonList() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ツールバーボタンリスト
            static TBBUTTON const sButtons[] = {
                { 0, ID_FILE_NEW,    TBSTATE_ENABLED, BTNS_BUTTON },
                { 0, ID_FILE_OPEN,   TBSTATE_ENABLED, BTNS_BUTTON },
                { 0, ID_FILE_SAVE,   TBSTATE_ENABLED, BTNS_BUTTON },
                { 0, 0, 0, BTNS_SEP },
                { 0, ID_TOOL_OPTION, TBSTATE_ENABLED, BTNS_BUTTON },
                { 0, 0, 0, BTNS_SEP },
                { 0, ID_HELP_ABOUT,  TBSTATE_ENABLED, BTNS_BUTTON },
            };

            // 巡回する
            for ( int nIndex = 0, nCount = ( sizeof( sButtons ) / sizeof( TBBUTTON ) );; ++nIndex ) {
                // インデックスを調べる
                if ( nCount <= nIndex ) {
                    // 成功！
                    result = true;
                    break;
                }

                // コマンドIDを調べる
                TBBUTTON sButton = sButtons[ nIndex ];
                if ( 0 != sButton.idCommand ) {
                    // 巡回する
                    for ( int nIndex2 = 0, nCount2 = m_pcIconImageList->GetCount(); nCount2 > nIndex2; ++nIndex2 ) {
                        // コマンドIDを調べる
                        if ( sButton.idCommand == ( *m_pcIconImageList )[ nIndex2 ].m_wId ) {
                            // イメージリストインデックスを設定する
                            sButton.iBitmap = nIndex2;

                            // ボタン名を設定する
                            sButton.iString = reinterpret_cast< INT_PTR >( ( *m_pcIconImageList )[ nIndex2 ].m_pszButtonName );
                            break;
                        }
                    }
                }

                // ツールバーボタンリストを追加する
                if ( !m_pcToolBarButtonList->Append( sButton ) ) {
                    // 失敗！
                    break;
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // ステータスバー作成関数
    bool CWndMain::CreateStatusBar() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ステータスバーコントロールを作成する
            DWORD dwStyle = ( WS_VISIBLE | WS_CHILD | SBARS_SIZEGRIP | CCS_BOTTOM );
            m_hStatusBar = ::CreateWindowExW( 0, STATUSCLASSNAMEW, nullptr, dwStyle, 0, 0, 0, 0, m_hWnd, nullptr, ::GetModuleHandleW( nullptr ), nullptr );
            if ( nullptr == m_hStatusBar ) {
                // 失敗！
                break;
            }

            // ステータスバー分割サイズ配列を初期化する
            int nSizeList[ STATUSBAR_PARTS_COUNT ] = {};
            nSizeList[ STATUSBAR_PARTS_COUNT - 1 ] = -1;

            // ステータスバーのデバイスコンテキストハンドルを取得する
            HDC hDc = ::GetDC( m_hStatusBar );

            // 固定文字列の描画サイズを取得して分割サイズを設定する
            int  nPos = 0;
            SIZE sSize;
            ::GetTextExtentPoint32W( hDc, STATUSBAR_TITLE_FPS, static_cast< int >( ::wcslen( STATUSBAR_TITLE_FPS ) ), &sSize );
            nPos = nSizeList[ STATUSBAR_INDEX_FPS_TITLE ] = ( nPos + sSize.cx + 4 );
            nPos = nSizeList[ STATUSBAR_INDEX_FPS_VALUE ] = ( nPos + STATUSBAR_INDEX_FPS_WIDTH );
            ::GetTextExtentPoint32W( hDc, STATUSBAR_TITLE_ERROR, static_cast< int >( ::wcslen( STATUSBAR_TITLE_ERROR ) ), &sSize );
            nPos = nSizeList[ STATUSBAR_INDEX_ERROR_TITLE ] = ( nPos + sSize.cx + 4 );
            nPos = nSizeList[ STATUSBAR_INDEX_ERROR_VALUE ] = ( nPos + STATUSBAR_INDEX_ERROR_WIDTH );

            // デバイスコンテキストハンドルを解放する
            ReleaseDC( m_hStatusBar, hDc );

            // ステータスバーコントロールを分割する
            ::SendMessageW( m_hStatusBar, SB_SETPARTS, STATUSBAR_PARTS_COUNT, reinterpret_cast< LPARAM >( nSizeList ) );

            // 固定文字列を設定する
            ::SendMessageW( m_hStatusBar, SB_SETTEXT, ( STATUSBAR_INDEX_FPS_TITLE   | SBT_POPOUT ), reinterpret_cast< LPARAM >( STATUSBAR_TITLE_FPS ) );
            ::SendMessageW( m_hStatusBar, SB_SETTEXT, ( STATUSBAR_INDEX_ERROR_TITLE | SBT_POPOUT ), reinterpret_cast< LPARAM >( STATUSBAR_TITLE_ERROR ) );

            // その他の情報を初期化する
            m_cOtherInfo = STATUSBAR_OTHERS;

            // ステータスバーを更新する
            UpdateStatusBar();

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

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

    //-------------------------------------------------------------------------
    // ステータスバー更新関数
    bool CWndMain::UpdateStatusBar() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 高精度タイマ有効フラグを調べる
            if ( m_bPerformanceTimer ) {
                // FPS測定値を表示する
                CString cString;
                cString.Format( L"%d/%d", m_nFpsValue, m_nFpsMax );
                ::SendMessageW( m_hStatusBar, SB_SETTEXT, ( STATUSBAR_INDEX_FPS_VALUE | 0 ), reinterpret_cast< LPARAM >( cString.GetBuffer() ) );

                // 積算誤差を表示する
                LONGLONG nWaitTime = ( 1000 * 1000 * m_nErrorCount / m_nPerformanceFreq );
                cString.Format( L"%.3f ms", ( nWaitTime / 1000.0 ) );
                ::SendMessageW( m_hStatusBar, SB_SETTEXT, ( STATUSBAR_INDEX_ERROR_VALUE | 0 ), reinterpret_cast< LPARAM >( cString.GetBuffer() ) );
            }

            // その他の情報を表示する
            ::SendMessageW( m_hStatusBar, SB_SETTEXT, ( STATUSBAR_INDEX_OTHERS | 0 ), reinterpret_cast< LPARAM >( m_cOtherInfo.GetBuffer() ) );

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

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

    //-------------------------------------------------------------------------
    // セパレータ作成関数
    bool CWndMain::CreateSeparator() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // スタティックコントロールを作成する
            DWORD dwStyle = ( WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | SS_OWNERDRAW );
            m_hSeparator = ::CreateWindowExW( 0, WC_STATICW, nullptr, dwStyle, 0, 0, 0, 0, m_hWnd, nullptr, ::GetModuleHandleW( nullptr ), nullptr );
            if ( nullptr == m_hSeparator ) {
                // 失敗！
                break;
            }

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

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

    //-------------------------------------------------------------------------
    // セパレータ描画関数
    bool CWndMain::DrawSeparator( LPDRAWITEMSTRUCT lpDraw ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 背景色ブラシを作成する
            HBRUSH hBrush = ::CreateSolidBrush( COLOR_SEPARATOR );

            // 塗りつぶす
            ::FillRect( lpDraw->hDC, &lpDraw->rcItem, hBrush );

            // 背景色ブラシを削除する
            ::DeleteObject( hBrush );

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

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

    //-------------------------------------------------------------------------
    // ウィンドウアプリケーション実行関数
    bool CWndMain::Run() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ウィンドウハンドルを調べる
            if ( nullptr == m_hWnd ) {
                // ウィンドウを作成する
                if ( !Create() ) {
                    // 失敗！
                    break;
                }
            }

            // ウィンドウ表示状態を調べる
            if ( 0 == ::IsWindowVisible( m_hWnd ) ) {
                // ウィンドウを表示する
                ::ShowWindow( m_hWnd, SW_SHOWNOACTIVATE );
            }

            // メニューバーを更新する
            UpdateMenuBar();

            // フレーム管理処理を初期化する
            if ( !InitFrame() ) {
                // 失敗！
                break;
            }

            // 巡回する
            MSG sMsg;
            for ( ;; ) {
                // フレーム開始処理を実行する
                StartFrame();

                // ウィンドウメッセージをピークする
                if ( 0 != ::PeekMessageW( &sMsg, nullptr, 0, 0, PM_REMOVE ) ) {
                    // 終了メッセージか調べる
                    if ( WM_QUIT == sMsg.message ) {
                        // 終了！
                        break;
                    }
                    // アクセラレータキーを処理する
                    else if ( 0 == ::TranslateAcceleratorW( sMsg.hwnd, m_hAccel, &sMsg ) ) {
                        // 仮想キーメッセージを文字メッセージへ変換する
                        ::TranslateMessage( &sMsg );

                        // ウィンドウプロシージャへメッセージをディスパッチする
                        ::DispatchMessageW( &sMsg );
                    }
                }
                // アイドル処理コールバック関数を実行する
                else if ( !IdleCallBackProc() ) {
                    // 終了！
                    break;
                }

                // フレーム終了処理を実行する
                EndFrame();

                // FPS測定値更新フラグを調べる
                if ( m_bUpdatedFpsValue ) {
                    // FPS測定値更新フラグをクリアする
                    m_bUpdatedFpsValue = false;

                    // ステータスバーを更新する
                    UpdateStatusBar();
                }
            }

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

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

    //-------------------------------------------------------------------------
    // フレーム管理初期化関数
    bool CWndMain::InitFrame() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // フレーム更新待機タイマを作成する
            if ( !m_cFrameWaitTimer.Create() ) {
                // 失敗！
                break;
            }

            // パフォーマンスカウンタ周波数を取得する
            LARGE_INTEGER sFrequency = {};
            if ( 0 != ::QueryPerformanceFrequency( &sFrequency ) ) {
                // 高精度タイマ有効フラグをセットする
                m_bPerformanceTimer = true;

                // パフォーマンスカウンタ周波数を設定する
                m_nPerformanceFreq = sFrequency.QuadPart;

                // パフォーマンスカウントを取得する
                LARGE_INTEGER sPerformanceCount = {};
                ::QueryPerformanceCounter( &sPerformanceCount );
                m_nPerformanceCount = sPerformanceCount.QuadPart;

                // １秒待ちカウントを設定する
                m_nSecondCount = m_nPerformanceFreq;
            }

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

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

    //-------------------------------------------------------------------------
    // フレーム開始関数
    bool CWndMain::StartFrame() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 高精度タイマ有効フラグを調べる
            if ( !m_bPerformanceTimer ) {
                // 終了！
                break;
            }
            // 積算誤差を調べる
            else if ( 0 < m_nErrorCount ) {
                // 待機時間を取得する
                m_nFrameWaitTime = ( 10LL * 1000 * 1000 * m_nErrorCount / m_nPerformanceFreq );

                // 100ナノ待機タイマをセットする
                m_cFrameWaitTimer.SetNano100( -m_nFrameWaitTime );
            }
            else {
                // フレーム更新待機時間をクリアする
                m_nFrameWaitTime = 0;
            }

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

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

    //-------------------------------------------------------------------------
    // フレーム終了関数
    bool CWndMain::EndFrame() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 高精度タイマ有効フラグを調べる
            if ( !m_bPerformanceTimer ) {
                // 終了！
                break;
            }
            // フレーム更新待機時間を調べる
            else if ( 0 < m_nFrameWaitTime ) {
                // フレーム更新待機タイマがシグナル状態になるまで最大100ms待つ
                m_cFrameWaitTimer.Wait( 100 );
            }

            // パフォーマンスカウントを取得する
            LARGE_INTEGER sPerformanceCount = {};
            ::QueryPerformanceCounter( &sPerformanceCount );

            // １フレーム経過時間を取得する
            LONGLONG nFrameTime = ( sPerformanceCount.QuadPart - m_nPerformanceCount );

            // FPS最大値を調べる
            if ( 0 < m_nFpsMax ) {
                // 積算誤差カウントを更新する
                m_nErrorCount += ( m_nPerformanceFreq / m_nFpsMax - nFrameTime );
            }
            else {
                // 積算誤差カウントをクリアする
                m_nErrorCount = 0;
            }

            // FPSカウントをインクリメントする
            ++m_nFpsCount;

            // １秒待ちカウントを更新する
            m_nSecondCount -= nFrameTime;
            if ( 0 > m_nSecondCount ) {
                // FPS測定値を更新する
                m_nFpsValue = m_nFpsCount;
                m_nFpsCount = 0;

                // １秒待ちカウントを設定する
                m_nSecondCount += m_nPerformanceFreq;

                // FPS測定値更新フラグをセットする
                m_bUpdatedFpsValue = true;
            }

            // パフォーマンスカウントを更新する
            m_nPerformanceCount = sPerformanceCount.QuadPart;

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

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

    //=========================================================================
    // 静的公開関数
    //-------------------------------------------------------------------------
    // 静的構成情報復元関数
    bool CWndMain::ResumeConfigStatic( CJsonConfig& rcConfig ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // デバッグ情報表示フラグを取得する
            rcConfig.Get( s_bShowDebugInfo, KEY_SHOW_DEBUG_INFO );

            // ダブルバッファリング描画フラグを取得する
            rcConfig.Get( s_bDrawDoubleBuffer, KEY_DRAW_DOUBLE_BUFFER );

            // リアルタイムパーティションサイズ変更フラグを取得する
            rcConfig.Get( s_bResizePartitionRealTime, KEY_RESIZE_PARTITION_REALTIME );

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

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

    //-------------------------------------------------------------------------
    // 静的構成情報保存関数
    bool CWndMain::SaveConfigStatic( CJsonConfig& rcConfig ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // デバッグ情報表示フラグを調べる
            if ( s_bShowDebugInfo ) {
                // デバッグ情報表示フラグを保存する
                if ( !rcConfig.Set( s_bShowDebugInfo, KEY_SHOW_DEBUG_INFO ) ) {
                    // 失敗！
                    break;
                }
            }

            // ダブルバッファリング描画フラグを調べる
            if ( s_bDrawDoubleBuffer ) {
                // ダブルバッファリング描画フラグを取得する
                if ( !rcConfig.Set( s_bDrawDoubleBuffer, KEY_DRAW_DOUBLE_BUFFER ) ) {
                    // 失敗！
                    break;
                }
            }

            // リアルタイムパーティションサイズ変更フラグを調べる
            if ( s_bResizePartitionRealTime ) {
                // リアルタイムパーティションサイズ変更フラグを取得する
                if ( !rcConfig.Set( s_bResizePartitionRealTime, KEY_RESIZE_PARTITION_REALTIME ) ) {
                    // 失敗！
                    break;
                }
            }

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

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

    //=========================================================================
    // 静的限定公開文字列定数
    wchar_t const* const CWndMain::PATH_ICON_IMAGE               = ( _SOLUTION_DIR L"Image\\" );
    wchar_t const* const CWndMain::STATUSBAR_TITLE_FPS           = L"FPS ";
    wchar_t const* const CWndMain::STATUSBAR_TITLE_ERROR         = L"積算誤差 ";
    wchar_t const* const CWndMain::STATUSBAR_OTHERS              = L"その他の情報";
    wchar_t const* const CWndMain::KEY_SHOW_DEBUG_INFO           = L"デバッグ情報表示";
    wchar_t const* const CWndMain::KEY_DRAW_DOUBLE_BUFFER        = L"ダブルバッファリング描画";
    wchar_t const* const CWndMain::KEY_RESIZE_PARTITION_REALTIME = L"リアルタイムパーティションサイズ変更";
    wchar_t const* const CWndMain::KEY_VIEW_TOOLBAR              = L"ツールバー表示状態";
    wchar_t const* const CWndMain::KEY_VIEW_STATUSBAR            = L"ステータスバー表示状態";
    wchar_t const* const CWndMain::SECTION_OVERLAP_LIST          = L"オーバーラップウィンドウリスト";
    wchar_t const* const CWndMain::SECTION_FLOATING_LIST         = L"フローティングウィンドウリスト";
    wchar_t const* const CWndMain::KEY_FOCUS_OVERLAP             = L"オーバーラップウィンドウフォーカス有効";
    wchar_t const* const CWndMain::KEY_FOCUS_FLOATING            = L"フローティングウィンドウフォーカス有効";

    //=========================================================================
    // テンプレートクラス明示的インスタンス生成宣言
    template class LIB_WINDOW_API CArray< CWndMain::SIconImageInfo >;
    template class LIB_WINDOW_API CArray< TBBUTTON >;
}

#pragma managed( pop )