CWndPane.cpp

[詳解]

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

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

    //-------------------------------------------------------------------------
    // ムーブコンストラクタ
    CWndPane::CWndPane( CWndPane&& rcInstance ) noexcept
        // 基底クラスコンストラクタ
        : CWndBase()
        // メンバ変数初期化
        , m_bShow( rcInstance.m_bShow )
    {}

    //=========================================================================
    // 公開関数
    //-------------------------------------------------------------------------
    // ウィンドウ作成関数
    bool CWndPane::Create( HWND hParent, HMENU hMenu ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 基底クラスの関数を実行する
            if ( !CWndBase::Create( hParent, hMenu ) ) {
                // 失敗！
                break;
            }

            // ペインウィンドウオーダー番号を取得する
            int nOrder = GetOrderIndex();

            // ウィンドウタイトルを設定する
            CString cString;
            cString.Format( L"%s#%d", GetSectionName(), nOrder );
            ::SetWindowTextW( m_hWnd, cString.GetBuffer() );

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

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

    //-------------------------------------------------------------------------
    // WM_APPメッセージ処理関数
    LRESULT CWndPane::WmApp() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // メッセージIDを調べる
            switch ( m_uMsg ) {
            case WM_NOTIFY_CHILD_SET_FOCUS:   // 子ウィンドウフォーカス取得通知
                result = WmNotifyChildSetFocus();
                break;
            case WM_NOTIFY_CHILD_KILL_FOCUS:  // 子ウィンドウフォーカス喪失通知
                result = WmNotifyChildKillFocus();
                break;
            case WM_NOTIFY_CHILD_LBUTTONDOWN: // 子ウィンドウ左ボタンダウン通知
                result = WmNotifyChildLButtonDown();
                break;
            case WM_NOTIFY_CHILD_LBUTTONUP:   // 子ウィンドウ左ボタンアップ通知
                result = WmNotifyChildLButtonUp();
                break;
            case WM_NOTIFY_CHILD_COMMAND:     // 子ウィンドウコマンド実行通知
                result = WmNotifyChildCommand();
                break;
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_PAINTメッセージ処理関数
    LRESULT CWndPane::WmPaint() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // ペイントを開始する
            PAINTSTRUCT sPaint;
            HDC         hDc = ::BeginPaint( m_hWnd, &sPaint );

            // クライアント描画領域を取得する
            RECT sPaintRect;
            if ( GetPaintRect( sPaintRect ) ) {
                // 矩形領域を調べる
                if ( 0 == ::IsRectEmpty( &sPaintRect ) ) {
                    // ダブルバッファリング描画フラグを調べる
                    if ( !s_bDrawDoubleBuffer ) {
                        // クライアント領域を描画する
                        DrawPaintRect( hDc, sPaintRect );
                    }
                    else {
                        // デバイスコンテキストをコピーする
                        HDC hDc2 = ::CreateCompatibleDC( hDc );

                        // クライアント描画領域をゼロ基点描画領域に変換する
                        int nLeft   = sPaintRect.left;
                        int nTop    = sPaintRect.top;
                        int nWidth  = ( sPaintRect.right  - nLeft );
                        int nHeight = ( sPaintRect.bottom - nTop );
                        sPaintRect.left   = 0;
                        sPaintRect.top    = 0;
                        sPaintRect.right  = nWidth;
                        sPaintRect.bottom = nHeight;

                        // ビットマップを作成する
                        HBITMAP hBitMap = ::CreateCompatibleBitmap( hDc, nWidth, nHeight );

                        // ビットマップを選択する
                        ::SelectObject( hDc2, hBitMap );

                        // クライアント描画領域を描画する
                        DrawPaintRect( hDc2, sPaintRect );

                        // ビットマップをコピーする
                        ::BitBlt( hDc, nLeft, nTop, nWidth, nHeight, hDc2, 0, 0, SRCCOPY );

                        // ビットマップを削除する
                        ::DeleteObject( hBitMap );

                        // デバイスコンテキストを削除する
                        ::DeleteDC( hDc2 );
                    }
                }
            }

            // ペイントを終了する
            ::EndPaint( m_hWnd, &sPaint );
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_SETFOCUSメッセージ処理関数
    LRESULT CWndPane::WmSetFocus() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // フォーカスウィンドウ保存ハンドルを更新する
            s_hFocus = m_hWnd;

            // クライアント領域を更新する
            UpdateClientRect();

            // 親またはオーナーウィンドウを取得する
            HWND hParent = GetParentOrOwner( m_hWnd );
            if ( nullptr != hParent ) {
                // WM_NOTIFY_CHILD_SET_FOCUSメッセージを送信する
                ::SendMessageW( hParent, WM_NOTIFY_CHILD_SET_FOCUS, 0, reinterpret_cast< LPARAM >( m_hWnd ) );
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_KILLFOCUSメッセージ処理関数
    LRESULT CWndPane::WmKillFocus() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // クライアント領域を更新する
            UpdateClientRect();

            // 親またはオーナーウィンドウを取得する
            HWND hParent = GetParentOrOwner( m_hWnd );
            if ( nullptr != hParent ) {
                // WM_NOTIFY_CHILD_KILL_FOCUSメッセージを送信する
                ::SendMessageW( hParent, WM_NOTIFY_CHILD_KILL_FOCUS, 0, reinterpret_cast< LPARAM >( m_hWnd ) );
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_LBUTTONDOWNメッセージ処理関数
    LRESULT CWndPane::WmLButtonDown() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // フォーカスウィンドウを設定する
            ::SetFocus( m_hWnd );
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_CONTEXTMENUメッセージ処理関数
    LRESULT CWndPane::WmContextMenu() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // シフトキー押下状態を調べる
            CWndPane* pcPane = this;
            SHORT     nState = ::GetKeyState( VK_SHIFT );
            if ( 0x8000 == ( 0x8000 & nState ) ) {
                // 最上位ペインウィンドウを取得する
                pcPane = GetTopLevelPane();
                if ( nullptr == pcPane ) {
                    // 失敗！
                    break;
                }
            }

            // コンテキストメニューを作成する
            s_hContextMenu = pcPane->CreateContextMenu();
            if ( nullptr == s_hContextMenu ) {
                // 失敗！
                break;
            }

            // ショートカットメニューを表示する
            int  xPos = LOWORD( m_lParam );
            int  yPos = HIWORD( m_lParam );
            UINT uId  = ::TrackPopupMenu( s_hContextMenu, ( TPM_NONOTIFY | TPM_RETURNCMD ), xPos, yPos, 0, pcPane->GetHandle(), nullptr );
            if ( 0 != uId ) {
                // メニューコマンドデータを取得する
                ULONG_PTR uData = 0;
                GetMenuCommandData( s_hContextMenu, uId, uData );

                // コマンドIDを調べる
                WORD wId = LOWORD( uId );
                if ( ( ID_DEBUG_PARENT_MENU <= wId ) && ( ID_DEBUG_PARENT_MENU_END >= wId ) ) {
                    // ペインウィンドウを取得する
                    pcPane = GetPaneWindow( reinterpret_cast< HWND >( uData ) );
                    if ( nullptr != pcPane ) {
                        // WM_CONTEXTMENUメッセージを送信する
                        ::SendMessageW( pcPane->GetHandle(), WM_CONTEXTMENU, m_wParam, m_lParam );
                    }
                }
                else {
                    // WM_COMMANDメッセージを送信する
                    ::SendMessageW( pcPane->GetHandle(), WM_COMMAND, uId, static_cast< LPARAM >( uData ) );
                }
            }

            // コンテキストメニューを破棄する
            ::DestroyMenu( s_hContextMenu );
            s_hContextMenu = nullptr;
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_COMMANDメッセージ処理関数
    LRESULT CWndPane::WmCommand() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // コマンドIDを取得する
            WORD wId = LOWORD( m_wParam );
            if ( 0 != wId ) {
                // 通知コードを取得する
                WORD wCode = HIWORD( m_wParam );

                // メニューコマンドデータを取得する
                HWND      hCtrl = nullptr;
                ULONG_PTR uData;
                if ( GetMenuCommandData( s_hContextMenu, static_cast< UINT >( m_wParam ), uData ) ) {
                    // コントロールハンドルを取得する
                    hCtrl = reinterpret_cast< HWND >( uData );
                    if ( nullptr != hCtrl ) {
                        // ペインウィンドウポインタを取得する
                        CWndPane* pcPane = GetPaneWindow( hCtrl );
                        if ( nullptr != pcPane ) {
                            // メニューコマンドを実行する
                            pcPane->ExecMenuCommand( wId, wCode, hCtrl );

                            // 終了！
                            break;
                        }
                    }
                }

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

                // 終了！
                break;
            }

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

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

    //-------------------------------------------------------------------------
    // WM_NOTIFY_CHILD_SET_FOCUSメッセージ処理関数
    LRESULT CWndPane::WmNotifyChildSetFocus() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // クライアント領域を更新する
            UpdateClientRect();

            // 親またはオーナーウィンドウを取得する
            HWND hParent = GetParentOrOwner( m_hWnd );
            if ( nullptr != hParent ) {
                // WM_NOTIFY_CHILD_SET_FOCUSメッセージを送信する
                ::SendMessageW( hParent, WM_NOTIFY_CHILD_SET_FOCUS, 0, reinterpret_cast< LPARAM >( m_hWnd ) );
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_NOTIFY_CHILD_KILL_FOCUSメッセージ処理関数
    LRESULT CWndPane::WmNotifyChildKillFocus() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // クライアント領域を更新する
            UpdateClientRect();

            // 親またはオーナーウィンドウを取得する
            HWND hParent = GetParentOrOwner( m_hWnd );
            if ( nullptr != hParent ) {
                // WM_NOTIFY_CHILD_KILL_FOCUSメッセージを送信する
                ::SendMessageW( hParent, WM_NOTIFY_CHILD_KILL_FOCUS, 0, reinterpret_cast< LPARAM >( m_hWnd ) );
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_NOTIFY_CHILD_COMMANDメッセージ処理関数
    LRESULT CWndPane::WmNotifyChildCommand() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // 親またはオーナーウィンドウを取得する
            HWND hParent = GetParentOrOwner( m_hWnd );
            if ( nullptr != hParent ) {
                // WM_NOTIFY_CHILD_COMMANDメッセージを送信する
                ::SendMessageW( hParent, WM_NOTIFY_CHILD_COMMAND, 0, reinterpret_cast< LPARAM >( m_hWnd ) );
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // ウィンドウ構成情報復元関数
    bool CWndPane::ResumeConfig( CJsonConfig& rcConfig ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ウィンドウタイトルを取得する
            CString cString;
            if ( rcConfig.Get( cString, KEY_WINDOW_TITLE ) ) {
                // ウィンドウタイトルを設定する
                ::SetWindowTextW( m_hWnd, cString );
            }

            // ウィンドウ表示フラグを取得する
            rcConfig.Get( m_bShow, KEY_SHOW );

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

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

    //-------------------------------------------------------------------------
    // ウィンドウ構成情報保存関数
    bool CWndPane::SaveConfig( CJsonConfig& rcConfig ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ウィンドウタイトルを取得する
            wchar_t szBuffer[ MAX_PATH ];
            ::GetWindowTextW( m_hWnd, szBuffer, MAX_PATH );

            // ウィンドウタイトルを保存する
            if ( !rcConfig.Set( szBuffer, KEY_WINDOW_TITLE ) ) {
                // 失敗！
                break;
            }
            // ウィンドウ表示フラグを保存する
            else if ( !rcConfig.Set( m_bShow, KEY_SHOW ) ) {
                // 失敗！
                break;
            }

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

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

    //-------------------------------------------------------------------------
    // 親ペインウィンドウ取得関数
    CWndPane* CWndPane::GetParentPane() noexcept {
        // 処理ブロック
        CWndPane* result = nullptr;
        do {
            // 親またはオーナーウィンドウを取得する
            HWND hParent = GetParentOrOwner( m_hWnd );

            // 親またはオーナーペインウィンドウを取得する
            CWndPane* pcParent = GetPaneWindow( hParent );
            if ( nullptr == pcParent ) {
                // 失敗！
                break;
            }

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

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

    //-------------------------------------------------------------------------
    // 最上位ペインウィンドウ取得関数
    CWndPane* CWndPane::GetTopLevelPane() noexcept {
        // 処理ブロック
        CWndPane* result = nullptr;
        do {
            // 巡回する
            for ( CWndPane* pcPane = this;; ) {
                // 親ペインウィンドウを取得する
                CWndPane* pcParent = pcPane->GetParentPane();
                if ( nullptr == pcParent ) {
                    // 成功！
                    result = pcPane;
                    break;
                }

                // ペインウィンドウポインタを更新する
                pcPane = pcParent;
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 子ペインウィンドウ情報取得関数
    bool CWndPane::GetChildPaneInfo( SChildPaneInfo& rsChildInfo ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 成功！
            result = true;
        } while ( false );

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

    //-------------------------------------------------------------------------
    // ペインウィンドウオーダー番号取得関数
    int CWndPane::GetOrderIndex( CWndPane* pcPane, int* pnOrder ) noexcept {
        // 処理ブロック
        int result = -1;
        do {
            // ペインウィンドウポインタを調べる
            if ( nullptr == pcPane ) {
                // 最上位ペインウィンドウを取得する
                CWndPane* pcTopLevel = GetTopLevelPane();
                if ( nullptr == pcTopLevel ) {
                    // 失敗！
                    break;
                }

                // ペインウィンドウオーダー番号を取得する
                int nOrder = 0;
                result = pcTopLevel->GetOrderIndex( this, &nOrder );
                break;
            }
            // オーダー番号ポインタを調べる
            else if ( nullptr == pnOrder ) {
                // 失敗！
                break;
            }
            // ペインウィンドウポインタを調べる
            else if ( this == pcPane ) {
                // 成功！
                result = *pnOrder;
                break;
            }

            // オーダー番号をインクリメントする
            ++*pnOrder;
        } while ( false );

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

    //-------------------------------------------------------------------------
    // オーダー番号ペインウィンドウ取得関数
    CWndPane* CWndPane::GetOrderPane( int* pnOrder ) noexcept {
        // 処理ブロック
        CWndPane* result = nullptr;
        do {
            // オーダー番号ポインタを調べる
            if ( nullptr == pnOrder ) {
                // 失敗！
                break;
            }
            // オーダー番号を調べる
            else if ( 0 == *pnOrder ) {
                // 成功！
                result = this;
                break;
            }

            // オーダー番号をデクリメントする
            --*pnOrder;
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 子ペインウィンドウ数取得関数
    int CWndPane::GetChildCount() noexcept {
        // 処理ブロック
        int result = 0;
        do {
            // 子ペインウィンドウ情報を取得する
            SChildPaneInfo sChildInfo = {};
            if ( !GetChildPaneInfo( sChildInfo ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = sChildInfo.m_nCount;
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 表示状態子ペインウィンドウ数取得関数
    int CWndPane::GetShowChildCount() noexcept {
        // 処理ブロック
        int result = 0;
        do {
            // 子ペインウィンドウ情報を取得する
            SChildPaneInfo sChildInfo = {};
            if ( !GetChildPaneInfo( sChildInfo ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = sChildInfo.m_nShow;
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 非表示状態子ペインウィンドウ数取得関数
    int CWndPane::GetHideChildCount() noexcept {
        // 処理ブロック
        int result = 0;
        do {
            // 子ペインウィンドウ情報を取得する
            SChildPaneInfo sChildInfo = {};
            if ( !GetChildPaneInfo( sChildInfo ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = sChildInfo.m_nHide;
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 非表示可能子ペインウィンドウ数取得関数
    int CWndPane::GetHideableChildCount() noexcept {
        // 処理ブロック
        int result = 0;
        do {
            // 子ペインウィンドウ情報を取得する
            SChildPaneInfo sChildInfo = {};
            if ( !GetChildPaneInfo( sChildInfo ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = sChildInfo.m_nHideable;
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 削除可能子ペインウィンドウ数取得関数
    int CWndPane::GetDeletableChildCount() noexcept {
        // 処理ブロック
        int result = 0;
        do {
            // 子ペインウィンドウ情報を取得する
            SChildPaneInfo sChildInfo = {};
            if ( !GetChildPaneInfo( sChildInfo ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = sChildInfo.m_nDeletable;
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 子ウィンドウ表示状態設定関数
    bool CWndPane::ShowChildWindow( CWndPane* pcChild, bool bShow ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 子ペインウィンドウポインタを調べる
            if ( nullptr == pcChild ) {
                // 失敗！
                break;
            }
            // 表示状態を設定する
            else if ( !pcChild->SetShow( bShow ) ) {
                // 失敗！
                break;
            }

            // ウィンドウ表示フラグを調べる
            if ( bShow ) {
                // ウィンドウを表示する
                ::ShowWindow( pcChild->GetHandle(), SW_SHOWNA );
            }
            else {
                // ウィンドウを隠す
                ::ShowWindow( pcChild->GetHandle(), SW_HIDE );
            }

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

            // フォーカスウィンドウ保存ハンドルを調べる
            if ( IsOwnOrChild( m_hWnd, s_hFocus ) ) {
                // フォーカスウィンドウをクリアする
                ::SetFocus( nullptr );

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

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

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

    //-------------------------------------------------------------------------
    // クライアント領域更新関数
    bool CWndPane::UpdateClientRect() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // クライアント描画領域を取得する
            RECT sPaintRect;
            if ( !GetPaintRect( sPaintRect ) ) {
                // 失敗！
                break;
            }

            // クライアント描画領域を無効化する
            ::InvalidateRect( m_hWnd, &sPaintRect, false );

            // ウィンドウを更新する
            ::UpdateWindow( m_hWnd );

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

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

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

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

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

    //-------------------------------------------------------------------------
    // クライアント描画領域取得関数
    bool CWndPane::GetPaintRect( RECT& rsRect ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // クライアント領域を取得する
            RECT sClientRect;
            if ( 0 == ::GetClientRect( m_hWnd, &sClientRect ) ) {
                // 失敗！
                break;
            }

            // クライアント描画領域を取得する
            rsRect = sClientRect;

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

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

    //-------------------------------------------------------------------------
    // クライアント領域描画関数
    bool CWndPane::DrawPaintRect( HDC hDc, RECT& rsRect ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // クライアント描画領域背景色を取得する
            COLORREF dwBkColor = GetBackColor();

            // 背景色ブラシを作成する
            HBRUSH hBrush = ::CreateSolidBrush( dwBkColor );

            // 描画領域を塗りつぶす
            ::FillRect( hDc, &rsRect, hBrush );

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

            // フォントを作成する
            HFONT hFont = static_cast< HFONT >( ::GetStockObject( DEFAULT_GUI_FONT ) );
            ::SelectObject( hDc, hFont );

            // クライアント描画領域文字色を取得する
            COLORREF dwTextColor = GetTextColor();

            // フォーカスウィンドウ保存ハンドルを調べる
            if ( m_hWnd == s_hFocus ) {
                // フォーカスウィンドウを調べる
                if ( m_hWnd == ::GetFocus() ) {
                    // フォーカス所有文字色を取得する
                    dwTextColor = GetFocusTextColor();
                }
                else {
                    // フォーカスウィンドウ文字色を取得する
                    dwTextColor = GetFocusWindowTextColor();
                }
            }

            // 文字色を設定する
            ::SetTextColor( hDc, dwTextColor );

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

            // ウィンドウタイトルを表示する
            ::SetBkMode( hDc, TRANSPARENT );
            ::DrawTextW( hDc, szBuffer, -1, &rsRect, ( DT_CENTER | DT_VCENTER | DT_SINGLELINE ) );

            // デバッグ情報表示フラグを調べる
            if ( s_bShowDebugInfo ) {
                // デバッグ情報を表示する
                CString cString;

                // ウィンドウサイズを取得する
                RECT sWindowRect;
                ::GetWindowRect( m_hWnd, &sWindowRect );
                int nLeft   = sWindowRect.left;
                int nTop    = sWindowRect.top;
                int nWidth  = ( sWindowRect.right  - nLeft );
                int nHeight = ( sWindowRect.bottom - nTop );
                cString.Format( L"%d x %d", nWidth, nHeight );

                // 巡回する
                cString += L", (";
                for ( CWndPane* pcPane = this;; ) {
                    // 最小サイズを取得する
                    nWidth  = pcPane->GetMinWidth();
                    nHeight = pcPane->GetMinHeight();
                    cString += CString().Format( L"%d x %d", nWidth, nHeight );

                    // ウィンドウスタイルを調べる
                    LONG_PTR dwStyle = ::GetWindowLongPtrW( pcPane->GetHandle(), GWL_STYLE );
                    if ( WS_CHILD != ( WS_CHILD & dwStyle ) ) {
                        // 終了！
                        break;
                    }

                    // 親ペインウィンドウを取得する
                    pcPane = GetPaneWindow( ::GetParent( pcPane->GetHandle() ) );
                    if ( nullptr == pcPane ) {
                        // 終了！
                        break;
                    }
                    cString += L" => ";
                }
                cString += L")";

                // 描画領域サイズを取得する
                nLeft   = rsRect.left;
                nTop    = rsRect.top;
                nWidth  = ( rsRect.right  - nLeft );
                nHeight = ( rsRect.bottom - nTop );
                cString += CString().Format( L"\r\n%d x %d", nWidth, nHeight );

                // 子ペインウィンドウ数を取得する
                int nCount = GetChildCount();
                cString += CString().Format( L"\r\n子ウィンドウ数：%d", nCount );

                // 表示状態子ペインウィンドウ数を取得する
                int nShow = GetShowChildCount();
                cString += CString().Format( L"\r\n表示状態子ウィンドウ数：%d", nShow );

                // 非表示状態子ペインウィンドウ数を取得する
                int nHide = GetHideChildCount();
                cString += CString().Format( L"\r\n非表示状態子ウィンドウ数：%d", nHide );

                // 非表示可能子ペインウィンドウ数を取得する
                int nHideable = GetHideableChildCount();
                cString += CString().Format( L"\r\n非表示可能子ウィンドウ数：%d", nHideable );

                // 削除可能子ペインウィンドウ数を取得する
                int nDeletable = GetDeletableChildCount();
                cString += CString().Format( L"\r\n削除可能子ウィンドウ数：%d", nDeletable );

                // 文字色を取得する
                COLORREF dwTextColor = GetTextColor();

                // 文字色を設定する
                ::SetTextColor( hDc, dwTextColor );

                // 文字列を描画する
                wchar_t const* pszBuffer = cString.GetBuffer();
                ::DrawTextW( hDc, pszBuffer, -1, &rsRect, ( DT_LEFT | DT_TOP ) );
            }

            // フォントを削除する
            ::DeleteObject( hFont );

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

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

    //-------------------------------------------------------------------------
    // メニューコマンド実行関数
    bool CWndPane::ExecMenuCommand( WORD wId, WORD wCode, HWND hCtrl ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 親またはオーナーウィンドウを取得する
            HWND hParent = GetParentOrOwner( m_hWnd );

            // ペインウィンドウを取得する
            CWndPane* pcParent = GetPaneWindow( hParent );
            if ( nullptr != pcParent ) {
                // コマンドIDを調べる
                switch ( wId ) {
                case ID_DEBUG_SHOW: // デバッグ::表示
                    // 子ウィンドウ表示状態を設定する
                    pcParent->ShowChildWindow( this, true );

                    // 成功！
                    result = true;
                    break;
                case ID_DEBUG_HIDE: // デバッグ::非表示
                    // 子ウィンドウ表示状態を設定する
                    pcParent->ShowChildWindow( this, false );

                    // 成功！
                    result = true;
                    break;
                case ID_DEBUG_DELETE: // デバッグ::削除
                    // 子ウィンドウを削除する
                    pcParent->DeleteChildWindow( this );

                    // 成功！
                    result = true;
                    break;
                default:
                    // 親またはオーナーウィンドウにWM_COMMANDメッセージを送信する
                    ::SendMessageW( pcParent->GetHandle(), WM_COMMAND, m_wParam, m_lParam );
                    break;
                }

                // 実行結果を調べる
                if ( result ) {
                    // WM_NOTIFY_CHILD_COMMANDメッセージを送信する
                    ::SendMessageW( hParent, WM_NOTIFY_CHILD_COMMAND, 0, reinterpret_cast< LPARAM >( m_hWnd ) );
                }
            }
        } while ( false );

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

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

            // ウィンドウタイトルを取得する
            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 );

            // 親またはオーナーペインウィンドウを取得する
            CWndPane* pcParent = GetPaneWindow( GetParentOrOwner( m_hWnd ) );
            if ( nullptr != pcParent ) {
                // メニュー項目数を調べる
                if ( 0 < ::GetMenuItemCount( hMenu ) ) {
                    // セパレータを追加する
                    ::AppendMenuW( hMenu, MF_SEPARATOR, 0, nullptr );
                }

                // メニューコマンドを追加する
                ::AppendMenuW   ( hMenu, MF_STRING, 0, L"親ウィンドウリスト" );
                ::EnableMenuItem( hMenu, ( ::GetMenuItemCount( hMenu ) - 1 ), ( MF_BYPOSITION | MFS_DISABLED ) );
                ::AppendMenuW   ( hMenu, MF_SEPARATOR, 0, nullptr );

                // 巡回する
                for ( int nIndex = 0; ( nullptr != pcParent ) && ( 256 > nIndex ); ++nIndex ) {
                    // ウィンドウタイトルを取得する
                    wchar_t szBuffer[ MAX_PATH ];
                    ::GetWindowTextW( pcParent->GetHandle(), szBuffer, MAX_PATH );

                    // メニューコマンドIDを取得する
                    UINT uId = MAKELONG( ( ID_DEBUG_PARENT_MENU + nIndex ), 0 );

                    // メニューコマンドを追加する
                    ::AppendMenuW     ( hMenu, MF_STRING, uId, szBuffer );
                    SetMenuCommandData( hMenu, uId, reinterpret_cast< ULONG_PTR >( pcParent->GetHandle() ) );

                    // 親またはオーナーペインウィンドウを取得する
                    pcParent = GetPaneWindow( GetParentOrOwner( pcParent->GetHandle() ) );
                }
            }

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

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

    //-------------------------------------------------------------------------
    // デバッグメニュー追加関数
    bool CWndPane::AppendDebugMenu( HMENU hMenu ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 表示削除メニューを追加する
            if ( !AppendShowDeleteMenu( hMenu ) ) {
                // 失敗！
                break;
            }

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

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

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

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

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

            // 親またはオーナーペインウィンドウを取得する
            CWndPane* pcParent = GetPaneWindow( GetParentOrOwner( m_hWnd ) );
            bool bHide   = false;
            bool bDelete = false;
            if ( nullptr != pcParent ) {
                // 子ウィンドウを非表示可能か親ペインに確認する
                bHide = pcParent->CanHideChildWindow( this );

                // 子ウィンドウを削除可能か親ペインに確認する
                bDelete = pcParent->CanDeleteChildWindow( this );
            }

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

            // メニューコマンドを追加する
            ::AppendMenuW     ( hMenu, MF_STRING, MAKELONG( ID_DEBUG_SHOW,   wCode ), L"表示" );
            ::AppendMenuW     ( hMenu, MF_STRING, MAKELONG( ID_DEBUG_HIDE,   wCode ), L"非表示" );
            ::AppendMenuW     ( hMenu, MF_STRING, MAKELONG( ID_DEBUG_DELETE, wCode ), L"削除" );
            SetMenuCommandData( hMenu, MAKELONG( ID_DEBUG_SHOW,   wCode ), reinterpret_cast< ULONG_PTR >( m_hWnd ) );
            SetMenuCommandData( hMenu, MAKELONG( ID_DEBUG_HIDE,   wCode ), reinterpret_cast< ULONG_PTR >( m_hWnd ) );
            SetMenuCommandData( hMenu, MAKELONG( ID_DEBUG_DELETE, wCode ), reinterpret_cast< ULONG_PTR >( m_hWnd ) );
            EnableMenuCommand ( hMenu, MAKELONG( ID_DEBUG_SHOW,   wCode ), !m_bShow );
            EnableMenuCommand ( hMenu, MAKELONG( ID_DEBUG_HIDE,   wCode ), ( bHide && m_bShow ) );
            EnableMenuCommand ( hMenu, MAKELONG( ID_DEBUG_DELETE, wCode ), bDelete );
            CheckMenuCommand  ( hMenu, MAKELONG( ID_DEBUG_SHOW,   wCode ), m_bShow );
            CheckMenuCommand  ( hMenu, MAKELONG( ID_DEBUG_HIDE,   wCode ), !m_bShow );

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

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

    //=========================================================================
    // 静的限定公開変数
    bool  CWndPane::s_bShowDebugInfo           = false;
    bool  CWndPane::s_bDrawDoubleBuffer        = false;
    bool  CWndPane::s_bResizePartitionRealTime = false;
    HMENU CWndPane::s_hContextMenu             = nullptr;
    HWND  CWndPane::s_hFocus                   = nullptr;

    //=========================================================================
    // 静的限定公開文字列定数
    wchar_t const* const CWndPane::KEY_WINDOW_TITLE = L"ウィンドウタイトル";
    wchar_t const* const CWndPane::KEY_SHOW         = L"ウィンドウ表示フラグ";
    wchar_t const* const CWndPane::KEY_FOCUS_ORDER  = L"フォーカスウィンドウオーダー番号";
}

#pragma managed( pop )