CWndList.cpp

[詳解]

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

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

//=============================================================================
// ウィンドウライブラリ名前空間
namespace LibWindow {
    //=========================================================================
    // ウィンドウリストクラス
    //=========================================================================
    // 構築子と解体子
    //-------------------------------------------------------------------------
    // コンストラクタ
    CWndList::CWndList() noexcept
        // 基底クラスコンストラクタ
        : CArray()
        // メンバ変数初期化
        , m_nCurrent( -1 )
    {}

    //-------------------------------------------------------------------------
    // ムーブコンストラクタ
    CWndList::CWndList( CWndList&& rcInstance ) noexcept
        // 基底クラスコンストラクタ
        : CArray( std::move( rcInstance ) )
        // メンバ変数初期化
        , m_nCurrent( rcInstance.m_nCurrent )
    {}

    //=========================================================================
    // 公開関数
    //-------------------------------------------------------------------------
    // クリア関数
    void CWndList::Clear() noexcept {
        // 巡回する
        for ( int nIndex = ( m_nCount - 1 ); 0 <= nIndex; --nIndex ) {
            // エレメントウィンドウポインタを取得する
            CWndElement* pcElement = m_pBuffer[ nIndex ];
            if ( nullptr != pcElement ) {
                // エレメントウィンドウインスタンスを削除する
                delete pcElement;
            }
        }

        // 基底クラスの関数を実行する
        CArray::Clear();
    }

    //-------------------------------------------------------------------------
    // エレメントウィンドウリスト作成関数
    bool CWndList::CreateListWindow( HWND hParent, HMENU hMenu ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 巡回する
            for ( int nIndex = 0;; ++nIndex ) {
                // インデックスを調べる
                if ( m_nCount <= nIndex ) {
                    // 成功！
                    result = true;
                    break;
                }

                // エレメントウィンドウポインタを取得する
                CWndElement* pcElement = m_pBuffer[ nIndex ];
                if ( nullptr == pcElement ) {
                    // 失敗！
                    break;
                }
                // エレメントウィンドウを作成する
                else if ( !pcElement->Create( hParent, hMenu ) ) {
                    // 失敗！
                    break;
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // カレントインデックス取得関数
    int CWndList::GetCurrentIndex() const noexcept {
        // 処理ブロック
        int result = -1;
        do {
            // 巡回する
            for ( int nIndex = 0; m_nCount > nIndex; ++nIndex ) {
                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_pBuffer[ nIndex ];
                if ( nullptr != pcElement ) {
                    // インデックスを調べる
                    if ( m_nCurrent == nIndex ) {
                        // 成功！
                        result = nIndex;
                        break;
                    }
                    // 実行結果を調べる
                    else if ( 0 > result ) {
                        // 実行結果を取得する
                        result = nIndex;
                    }
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // カレントインデックス設定関数
    bool CWndList::SetCurrentIndex( int nIndex ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // インデックスを調べる
            if ( ( 0 > nIndex ) || ( m_nCount <= nIndex ) ) {
                // 失敗！
                break;
            }

            // カレントインデックスを設定する
            m_nCurrent = nIndex;

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

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

    //-------------------------------------------------------------------------
    // 表示状態カレントインデックス取得関数
    int CWndList::GetShowCurrentIndex() const noexcept {
        // 処理ブロック
        int result = -1;
        do {
            // 巡回する
            for ( int nIndex = 0; m_nCount > nIndex; ++nIndex ) {
                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_pBuffer[ nIndex ];
                if ( nullptr != pcElement ) {
                    // 表示フラグを調べる
                    if ( pcElement->IsShow() ) {
                        // インデックスを調べる
                        if ( m_nCurrent == nIndex ) {
                            // 成功！
                            result = nIndex;
                            break;
                        }
                        // 実行結果を調べる
                        else if ( 0 > result ) {
                            // 実行結果を取得する
                            result = nIndex;
                        }
                    }
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 表示状態カレントエレメントウィンドウ取得関数
    CWndElement* CWndList::GetShowCurrentElement() const noexcept {
        // 処理ブロック
        CWndElement* result = nullptr;
        do {
            // 表示状態カレントインデックスを取得する
            int nIndex = GetShowCurrentIndex();
            if ( 0 > nIndex ) {
                // 失敗！
                break;
            }

            // 成功！
            result = m_pBuffer[ nIndex ];
        } while ( false );

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

    //-------------------------------------------------------------------------
    // カレントエレメントウィンドウ取得関数
    CWndElement* CWndList::GetCurrentElement() const noexcept {
        // 処理ブロック
        CWndElement* result = nullptr;
        do {
            // カレントインデックスを取得する
            int nIndex = GetCurrentIndex();
            if ( 0 > nIndex ) {
                // 失敗！
                break;
            }

            // 成功！
            result = m_pBuffer[ nIndex ];
        } while ( false );

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

    //-------------------------------------------------------------------------
    // エレメントウィンドウ取得関数
    CWndElement* CWndList::GetElementWindow( HWND hWnd ) const noexcept {
        // 処理ブロック
        CWndElement* result = nullptr;
        do {
            // 巡回する
            for ( int nIndex = 0; m_nCount > nIndex; ++nIndex ) {
                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_pBuffer[ nIndex ];
                if ( nullptr != pcElement ) {
                    // ウィンドウハンドルを調べる
                    if ( hWnd == pcElement->GetHandle() ) {
                        // 成功！
                        result = pcElement;
                        break;
                    }
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // エレメントウィンドウリスト構成情報初期化関数
    bool CWndList::InitElementListConfig( CJsonConfig& rcConfig, CWndElement* ( *pfnCreateElement )(), wchar_t const* pszElementName ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // エレメントウィンドウ名文字列ポインタを調べる
            if ( nullptr == pszElementName ) {
                // 失敗！
                break;
            }
            // 新規エレメントウィンドウ作成関数ポインタを調べる
            else if ( nullptr == pfnCreateElement ) {
                // 失敗！
                break;
            }
            else {
                // エレメントウィンドウリストセクションブロック
                CJsonConfigAuto cConfigAuto( rcConfig, CString().Format( L"%sリスト", pszElementName ) );

                // エレメントウィンドウ数を取得する
                int nCount = 0;
                rcConfig.Get( nCount, KEY_ELEMENT_COUNT );

                // 巡回する
                for ( int nIndex = 0;; ++nIndex ) {
                    // インデックスを調べる
                    if ( nCount <= nIndex ) {
                        // カレントインデックスを取得する
                        int nIndex = 0;
                        if ( rcConfig.Get( nIndex, KEY_CURRENT_INDEX ) ) {
                            // インデックスを調べる
                            if ( ( 0 <= nIndex ) && ( m_nCount > nIndex ) ) {
                                // カレントインデックスを設定する
                                m_nCurrent = nIndex;
                            }
                        }

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

                    // 新規エレメントウィンドウを作成する
                    CWndElement* pcElement = ( *pfnCreateElement )();
                    if ( nullptr != pcElement ) {
                        // エレメントウィンドウ情報セクション処理ブロック
                        CJsonConfigAuto cConfigAuto( rcConfig, SECTION_ELEMENT_INFO, nIndex );

                        // ウィンドウ構成情報を初期化する
                        if ( pcElement->InitConfig( rcConfig ) ) {
                            // エレメントウィンドウリストに追加する
                            if ( Append( pcElement ) ) {
                                // 継続！
                                continue;
                            }
                        }
                    }

                    // エレメントウィンドウを削除する
                    delete pcElement;

                    // 失敗！
                    break;
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // エレメントウィンドウリスト構成情報復元関数
    bool CWndList::ResumeElementListConfig( CJsonConfig& rcConfig, wchar_t const* pszElementName ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // エレメントウィンドウ名文字列ポインタを調べる
            if ( nullptr == pszElementName ) {
                // 失敗！
                break;
            }
            else {
                // エレメントウィンドウリストセクションブロック
                CJsonConfigAuto cConfigAuto( rcConfig, CString().Format( L"%sリスト", pszElementName ) );

                // エレメントウィンドウ名文字列ポインタを調べる
                if ( nullptr == pszElementName ) {
                    // 失敗！
                    break;
                }
                // 巡回する
                else for ( int nIndex = 0;; ++nIndex ) {
                    // インデックスを調べる
                    if ( m_nCount <= nIndex ) {
                        // 成功！
                        result = true;
                        break;
                    }

                    // エレメントウィンドウを取得する
                    CWndElement* pcElement = m_pBuffer[ nIndex ];
                    if ( nullptr != pcElement ) {
                        // エレメントウィンドウ情報セクション処理ブロック
                        CJsonConfigAuto cConfigAuto( rcConfig, SECTION_ELEMENT_INFO, nIndex );

                        // ウィンドウ構成情報を復元する
                        if ( !pcElement->ResumeConfig( rcConfig ) ) {
                            // 失敗！
                            break;
                        }
                    }
                }

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

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

    //-------------------------------------------------------------------------
    // エレメントウィンドウリスト構成情報保存関数
    bool CWndList::SaveElementListConfig( CJsonConfig& rcConfig, wchar_t const* pszElementName ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // エレメントウィンドウ名文字列ポインタを調べる
            if ( nullptr == pszElementName ) {
                // 失敗！
                break;
            }
            else {
                // エレメントウィンドウリストセクションブロック
                CJsonConfigAuto cConfigAuto( rcConfig, CString().Format( L"%sリスト", pszElementName ), true );

                // エレメントウィンドウ名文字列ポインタを調べる
                if ( nullptr == pszElementName ) {
                    // 失敗！
                    break;
                }
                // エレメントウィンドウ数を調べる
                else if ( 0 >= m_nCount ) {
                    // 成功！
                    result = true;
                }
                // エレメントウィンドウ数を保存する
                else if ( rcConfig.Set( m_nCount, KEY_ELEMENT_COUNT ) ) {
                    // カレントインデックスを調べる
                    if ( 0 <= m_nCurrent  ) {
                        // カレントインデックスを保存する
                        if ( !rcConfig.Set( m_nCurrent, KEY_CURRENT_INDEX ) ) {
                            // 失敗！
                            break;
                        }
                    }

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

                        // エレメントウィンドウを取得する
                        CWndElement* pcElement = m_pBuffer[ nIndex ];
                        if ( nullptr != pcElement ) {
                            // エレメントウィンドウ情報セクション処理ブロック
                            CJsonConfigAuto cConfigAuto( rcConfig, SECTION_ELEMENT_INFO, nIndex, true );

                            // ウィンドウ構成情報を保存する
                            if ( !pcElement->SaveConfig( rcConfig ) ) {
                                // 失敗！
                                break;
                            }
                        }
                    }
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 子エレメントウィンドウリスト情報取得関数
    bool CWndList::GetChildElementListInfo( CWndPane* pcParent, SChildPaneInfo& rsChildInfo ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 親ペインウィンドウポインタを調べる
            if ( nullptr == pcParent ) {
                // 失敗！
                break;
            }

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

                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_pBuffer[ nIndex ];
                if ( nullptr != pcElement ) {
                    // 子ウィンドウ数をインクリメントする
                    ++rsChildInfo.m_nCount;

                    // 表示フラグを調べる
                    if ( pcElement->IsShow() ) {
                        // 表示状態子ウィンドウ数をインクリメントする
                        ++rsChildInfo.m_nShow;
                    }
                    else {
                        // 非表示状態子ウィンドウ数をインクリメントする
                        ++rsChildInfo.m_nHide;
                    }

                    // 非表示可能状態を調べる
                    if ( pcParent->CanHideChildWindow( pcElement ) ) {
                        // 非表示可能状態子ウィンドウ数をインクリメントする
                        ++rsChildInfo.m_nHideable;
                    }

                    // 削除可能状態を調べる
                    if ( pcParent->CanDeleteChildWindow( pcElement ) ) {
                        // 削除可能状態子ウィンドウ数をインクリメントする
                        ++rsChildInfo.m_nDeletable;
                    }

                    // 子ペインウィンドウ情報を取得する
                    if ( !pcElement->GetChildPaneInfo( rsChildInfo ) ) {
                        // 失敗！
                        break;
                    }
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // エレメントウィンドウリストオーダー番号取得関数
    int CWndList::GetElementListOrderIndex( CWndPane* pcPane, int* pnOrder ) noexcept {
        // 処理ブロック
        int result = -1;
        do {
            // 巡回する
            for ( int nIndex = 0; m_nCount > nIndex; ++nIndex ) {
                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_pBuffer[ nIndex ];
                if ( nullptr != pcElement ) {
                    // ペインウィンドウオーダー番号を取得する
                    int nOrder = pcElement->GetOrderIndex( pcPane, pnOrder );
                    if ( 0 <= nOrder ) {
                        // 成功！
                        result = nOrder;
                        break;
                    }
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // エレメントウィンドウリストオーダー番号ペインウィンドウ取得関数
    CWndPane* CWndList::GetElementListOrderPane( int* pnOrder ) noexcept {
        // 処理ブロック
        CWndPane* result = nullptr;
        do {
            // 巡回する
            for ( int nIndex = 0; m_nCount > nIndex; ++nIndex ) {
                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_pBuffer[ nIndex ];
                if ( nullptr != pcElement ) {
                    // オーダー番号ペインウィンドウを取得する
                    CWndPane* pcPane = pcElement->GetOrderPane( pnOrder );
                    if ( nullptr != pcPane ) {
                        // 成功！
                        result = pcPane;
                        break;
                    }
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 全エレメントウィンドウリスト表示関数
    bool CWndList::ShowElementListAll( CWndPane* pcParent, bool bShow ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 親ペインウィンドウポインタを調べる
            if ( nullptr == pcParent ) {
                // 失敗！
                break;
            }

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

                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_pBuffer[ nIndex ];
                if ( nullptr != pcElement ) {
                    // 子ウィンドウを表示する
                    if ( !pcParent->ShowChildWindow( pcElement, bShow ) ) {
                        // 失敗！
                        break;
                    }
                    // 全子ウィンドウを表示する
                    else if ( !pcElement->ShowChildAll( bShow ) ) {
                        // 失敗！
                        break;
                    }
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 全エレメントウィンドウリスト削除関数
    bool CWndList::DeleteElementListAll( CWndPane* pcParent ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 親ペインウィンドウポインタを調べる
            if ( nullptr == pcParent ) {
                // 失敗！
                break;
            }

            // 巡回する
            for ( int nIndex = m_nCount;; --nIndex ) {
                // インデックスを調べる
                if ( 0 >= nIndex ) {
                    // 成功！
                    result = true;
                    break;
                }

                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_pBuffer[ nIndex - 1 ];
                if ( nullptr != pcElement ) {
                    // 全子ウィンドウを削除する
                    if ( !pcElement->DeleteChildAll() ) {
                        // 失敗！
                        break;
                    }
                    // 子ウィンドウを削除する
                    else if ( !pcParent->DeleteChildWindow( pcElement ) ) {
                        // 失敗！
                        break;
                    }
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // エレメントウィンドウ追加関数
    bool CWndList::AppendElementWindow( HWND hParent, CWndElement* pcElement ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // エレメントウィンドウポインタを調べる
            if ( nullptr == pcElement ) {
                // 失敗！
                break;
            }
            // エレメントウィンドウリストに追加する
            else if ( Append( pcElement ) ) {
                // ウィンドウを作成する
                if ( pcElement->Create( hParent ) ) {
                    // カレントエレメントウィンドウを設定する
                    if ( SetCurrentIndex( m_nCount - 1 ) ) {
                        // 成功！
                        result = pcElement;
                        break;
                    }
                }

                // エレメントウィンドウリストから削除する
                RemoveElementWindow( pcElement );
            }

            // エレメントウィンドウを削除する
            delete pcElement;
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 新規エレメントウィンドウ追加関数
    CWndElement* CWndList::AppendNewElementWindow( HWND hParent, CWndElement* ( *pfnCreateElement )() ) noexcept {
        // 処理ブロック
        CWndElement* result = nullptr;
        do {
            // 親ウィンドウを調べる
            if ( 0 == ::IsWindow( hParent ) ) {
                // 失敗！
                break;
            }
            // 新規エレメントウィンドウ作成関数ポインタを調べる
            else if ( nullptr == pfnCreateElement ) {
                // 失敗！
                break;
            }

            // 新規エレメントウィンドウを作成する
            CWndElement* pcElement = pfnCreateElement();
            if ( nullptr == pcElement ) {
                // 失敗！
                break;
            }
            // エレメントウィンドウを追加する
            else if ( AppendElementWindow( hParent, pcElement ) ) {
                // 成功！
                result = pcElement;
                break;
            }

            // エレメントウィンドウを削除する
            delete pcElement;
        } while ( false );

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

    //-------------------------------------------------------------------------
    // エレメントウィンドウリストデバッグサブメニュー追加関数
    bool CWndList::AppendElementListDebugSubMenu( HMENU hMenu, CWndPane* pcParent, wchar_t const* pszElementName, WORD wIdNew ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // メニューハンドルを調べる
            if ( nullptr == hMenu ) {
                // 失敗！
                break;
            }
            // 親ペインウィンドウポインタを調べる
            else if ( nullptr == pcParent ) {
                // 失敗！
                break;
            }
            // エレメントウィンドウ名文字列ポインタを調べる
            else if ( nullptr == pszElementName ) {
                // 失敗！
                break;
            }

            // ペインウィンドウオーダー番号を取得する
            int nOrder = pcParent->GetOrderIndex();
            if ( 0 > nOrder ) {
                // 失敗！
                break;
            }

            // 通知コードを取得する
            WORD wCode = static_cast< WORD >( nOrder );

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

            // 巡回する
            for ( int nIndex = 0;; ++nIndex ) {
                // インデックスを調べる
                if ( m_nCount <= nIndex ) {
                    // 新規追加コマンドを調べる
                    if ( 0 != wIdNew ) {
                        // メニュー項目数を調べる
                        if ( 0 < ::GetMenuItemCount( hSubMenu ) ) {
                            // セパレータを追加する
                            ::AppendMenuW( hSubMenu, MF_SEPARATOR, 0, nullptr );
                        }

                        // 新規追加コマンドを追加する
                        UINT uId = MAKELONG( wIdNew, wCode );
                        ::AppendMenuW( hSubMenu, MF_STRING, uId, CString().Format( L"新規%s", pszElementName ) );
                        SetMenuCommandData( hSubMenu, uId, reinterpret_cast< ULONG_PTR >( pcParent->GetHandle() ) );
                    }

                    // メニュー項目数を調べる
                    if ( 0 < ::GetMenuItemCount( hMenu ) ) {
                        // セパレータを追加する
                        ::AppendMenuW( hMenu, MF_SEPARATOR, 0, nullptr );
                    }

                    // サブメニューを追加する
                    ::AppendMenuW( hMenu, MF_POPUP, reinterpret_cast< UINT_PTR >( hSubMenu ), CString().Format( L"%sリスト", pszElementName ) );
                    if ( 0 >= GetEnableMenuCommandCount( hSubMenu ) ) {
                        // サブメニュー項目を無効化する
                        ::EnableMenuItem( hMenu, ( ::GetMenuItemCount( hMenu ) - 1 ), ( MF_BYPOSITION | MFS_DISABLED ) );
                    }

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

                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_pBuffer[ nIndex ];
                if ( nullptr != pcElement ) {
                    // サブサブメニューを作成する
                    HMENU hSubSubMenu = ::CreatePopupMenu();
                    if ( nullptr == hSubSubMenu ) {
                        // 失敗！
                        break;
                    }
                    // デバッグメニューを追加する
                    else if ( pcElement->AppendDebugMenu( hSubSubMenu ) ) {
                        // サブサブメニュー項目数を調べる
                        if ( 0 < ::GetMenuItemCount( hSubSubMenu ) ) {
                            // ウィンドウタイトルを取得する
                            wchar_t szBuffer[ MAX_PATH ];
                            ::GetWindowTextW( pcElement->GetHandle(), szBuffer, MAX_PATH );

                            // メニュー項目数を調べる
                            if ( 0 < ::GetMenuItemCount( hSubMenu ) ) {
                                // セパレータを追加する
                                ::AppendMenuW( hSubMenu, MF_SEPARATOR, 0, nullptr );
                            }

                            // サブサブメニューを追加する
                            ::AppendMenuW( hSubMenu, MF_POPUP, reinterpret_cast< UINT_PTR >( hSubSubMenu ), szBuffer );
                            if ( 0 >= GetEnableMenuCommandCount( hSubMenu ) ) {
                                // サブサブメニュー項目を無効化する
                                ::EnableMenuItem( hSubMenu, ( ::GetMenuItemCount( hSubMenu ) - 1 ), ( MF_BYPOSITION | MFS_DISABLED ) );
                            }
                        }
                        else {
                            // サブサブメニューを削除する
                            ::DestroyMenu( hSubSubMenu );
                        }
                    }
                    else {
                        // サブサブメニューを削除する
                        ::DestroyMenu( hSubSubMenu );
                    }
                }
            }

            // 実行結果を調べる
            if ( !result ) {
                // サブメニューを削除する
                ::DestroyMenu( hSubMenu );
            }
        } while ( false );

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

    //=========================================================================
    // 静的限定公開文字列定数
    wchar_t const* const CWndList::SECTION_ELEMENT_INFO = L"ウィンドウ情報";
    wchar_t const* const CWndList::KEY_ELEMENT_COUNT    = L"ウィンドウ数";
    wchar_t const* const CWndList::KEY_CURRENT_INDEX    = L"カレントインデックス";

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

#pragma managed( pop )