CWndPartition.cpp

[詳解]

//=============================================================================
/// @file
/// パーティションウィンドウクラス実装ファイル
///
/// パーティションウィンドウクラス実装ファイルです。
///
/// $Id: CWndPartition.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 <CWndPartition.h>
#include <CJsonConfigAuto.h>
#include <LibWindowUtility.h>
#include <commctrl.h>

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

//=============================================================================
// ウィンドウライブラリ名前空間
namespace LibWindow {
    //=========================================================================
    // パーティションウィンドウクラス
    //=========================================================================
    // 静的公開文字列定数
    wchar_t const* const CWndPartition::KEY_PARTITION_POS  = L"パーティション配置位置";
    wchar_t const* const CWndPartition::KEY_PARTITION_SIZE = L"パーティションサイズ";

    //=========================================================================
    // 構築子と解体子
    //-------------------------------------------------------------------------
    // コンストラクタ
    CWndPartition::CWndPartition( CWndElement* ( *pfnCreateElement )(), wchar_t const* pszElementName ) noexcept
        // 基底クラスコンストラクタ
        : CWndContainer( pfnCreateElement, pszElementName )
        // メンバ変数初期化
        , m_hSizeBarImage( nullptr )
        , m_sPoint()
        , m_pcElement( nullptr )
        , m_nSize( 0 )
        , m_nMinSize( 0 )
        , m_nMaxSize( 0 )
    {}

    //=========================================================================
    // 公開関数
    //-------------------------------------------------------------------------
    // ウィンドウ作成関数
    bool CWndPartition::Create( HWND hParent, HMENU hMenu ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 基底クラスの関数を実行する
            if ( !CWndContainer::Create( hParent, hMenu ) ) {
                // 失敗！
                break;
            }
            // サイズバーイメージコントロールを作成する
            else if ( !CreateSizeBarImageControl() ) {
                // 失敗！
                break;
            }

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

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

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

            // パーティション表示クライアント領域を取得する
            RECT sClientRect;
            if ( !GetPartitionClientRect( sClientRect ) || ( 0 != ::IsRectEmpty( &sClientRect ) ) ) {
                // 終了！
                break;
            }

            // ドキュメントタブウィンドウを取得する
            CWndDocumentTab* pcDocumentTab = GetDocumentTab();
            if ( nullptr != pcDocumentTab ) {
                // ウィンドウ表示フラグを調べる
                if ( !pcDocumentTab->IsShow() ) {
                    // ドキュメントタブウィンドウを隠す
                    ::ShowWindow( pcDocumentTab->GetHandle(), SW_HIDE );

                    // ドキュメントタブウィンドウポインタをクリアする
                    pcDocumentTab = nullptr;
                }
            }

            // 巡回する
            for ( int nIndex = 0, nCount = m_cElementList.GetCount(); nCount > nIndex; ++nIndex ) {
                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_cElementList[ nIndex ];
                if ( nullptr != pcElement ) {
                    // サイズバーコントロールを取得する
                    HWND hSizeBar = pcElement->GetSizeBar();

                    // ウィンドウ表示フラグを調べる
                    if ( !pcElement->IsShow() ) {
                        // エレメントウィンドウを隠す
                        ::ShowWindow( pcElement->GetHandle(), SW_HIDE );

                        // サイズバーコントロールを隠す
                        ::ShowWindow( hSizeBar, SW_HIDE );
                    }
                    else {
                        // パーティション配置位置を取得する
                        EPartitionPos ePos = GetPartitionPos( pcElement );

                        // ドキュメントタブウィンドウポインタを調べる
                        if ( nullptr == pcDocumentTab ) {
                            // 巡回する
                            for ( int nIndex2 = ( nIndex + 1 );; ++nIndex2 ) {
                                // インデックスを調べる
                                if ( nCount <= nIndex2 ) {
                                    // パーティション配置位置を無効化する
                                    ePos = EPartitionPos::Invalid;

                                    // サイズバーコントロールを隠す
                                    ::ShowWindow( hSizeBar, SW_HIDE );

                                    // 終了！
                                    break;
                                }

                                // エレメントウィンドウを取得する
                                CWndElement* pcElement = m_cElementList[ nIndex2 ];
                                if ( nullptr != pcElement ) {
                                    // ウィンドウ表示フラグを調べる
                                    if ( pcElement->IsShow() ) {
                                        // 終了！
                                        break;
                                    }
                                }
                            }
                        }

                        // ウィンドウ表示位置を取得する
                        int nLeft   = sClientRect.left;
                        int nTop    = sClientRect.top;
                        int nWidth  = ( sClientRect.right  - nLeft );
                        int nHeight = ( sClientRect.bottom - nTop );

                        // パーティションサイズを取得する
                        int nSize = pcElement->GetPartitionSize();

                        // 最小サイズを取得する
                        int nMinWidth  = pcElement->GetMinWidth();
                        int nMinHeight = pcElement->GetMinHeight();

                        // 残り必要最小サイズを取得する
                        SIZE sMinSize = {};
                        GetMinSize( sMinSize, ( nIndex + 1 ) );

                        // 最大サイズを取得する
                        int nMaxWidth  = ( nWidth - sMinSize.cx );
                        int nMaxHeight = ( nHeight - sMinSize.cy );

                        // パーティション配置位置を調べる
                        switch ( ePos ) {
                        case EPartitionPos::Left:   // 左側
                        case EPartitionPos::Right:  // 右側
                            // 最大水平サイズを更新する
                            nMaxWidth -= SIZEBAR_THICK;
                            break;
                        case EPartitionPos::Top:    // 上側
                        case EPartitionPos::Bottom: // 下側
                            // 最大垂直サイズを更新する
                            nMaxHeight -= SIZEBAR_THICK;
                            break;
                        }

                        // 最大水平サイズを調べる
                        if ( nMinWidth > nMaxWidth ) {
                            // 最大水平サイズを更新する
                            nMaxWidth = nMinWidth;
                        }

                        // 最大垂直サイズを調べる
                        if ( nMinHeight > nMaxHeight ) {
                            // 最大垂直サイズを更新する
                            nMaxHeight = nMinHeight;
                        }

                        // パーティション配置位置を調べる
                        switch ( ePos ) {
                        case EPartitionPos::Left:   // 左側
                        case EPartitionPos::Right:  // 右側
                            // 水平サイズを取得する
                            nWidth = nSize;

                            // 最小水平サイズを調べる
                            if ( nMinWidth > nWidth ) {
                                // 水平サイズを更新する
                                nWidth = nMinWidth;
                            }
                            // 最大水平サイズを調べる
                            else if ( nMaxWidth < nWidth ) {
                                // 水平サイズを更新する
                                nWidth = nMaxWidth;
                            }
                            break;
                        case EPartitionPos::Top:    // 上側
                        case EPartitionPos::Bottom: // 下側
                            // 垂直サイズを取得する
                            nHeight = nSize;

                            // 最小垂直サイズを調べる
                            if ( nMinHeight > nHeight ) {
                                // 垂直サイズを更新する
                                nHeight = nMinHeight;
                            }
                            // 最大垂直サイズを調べる
                            else if ( nMaxHeight < nHeight ) {
                                // 垂直サイズを更新する
                                nHeight = nMaxHeight;
                            }
                            break;
                        }

                        // パーティション配置位置を調べる
                        switch ( ePos ) {
                        case EPartitionPos::Right:  // 右側
                            // 水平座標を取得する
                            nLeft = ( sClientRect.right - nWidth );
                            break;
                        case EPartitionPos::Bottom: // 下側
                            // 垂直座標を取得する
                            nTop = ( sClientRect.bottom - nHeight );
                            break;
                        }

                        // エレメントウィンドウを表示する
                        ::SetWindowPos( pcElement->GetHandle(), HWND_TOP, nLeft, nTop, nWidth, nHeight, ( SWP_NOACTIVATE | SWP_SHOWWINDOW ) );
                        ::UpdateWindow( pcElement->GetHandle() );

                        // クライアント描画領域から減算する
                        SubtractChildRect( pcElement->GetHandle(), sClientRect );

                        // パーティション配置位置を調べる
                        if ( EPartitionPos::Invalid != ePos ) {
                            // ウィンドウ表示位置を取得する
                            int nLeft   = sClientRect.left;
                            int nTop    = sClientRect.top;
                            int nWidth  = ( sClientRect.right  - nLeft );
                            int nHeight = ( sClientRect.bottom - nTop );

                            // パーティション配置位置を調べる
                            switch ( ePos ) {
                            case EPartitionPos::Left:   // 左側
                                // 水平サイズを取得する
                                nWidth = SIZEBAR_THICK;
                                break;
                            case EPartitionPos::Top:    // 上側
                                // 垂直サイズを取得する
                                nHeight = SIZEBAR_THICK;
                                break;
                            case EPartitionPos::Right:  // 右側
                                // 水平サイズを取得する
                                nWidth = SIZEBAR_THICK;

                                // 水平座標を取得する
                                nLeft = ( sClientRect.right - nWidth );
                                break;
                            case EPartitionPos::Bottom: // 下側
                                // 垂直サイズを取得する
                                nHeight = SIZEBAR_THICK;

                                // 垂直座標を取得する
                                nTop = ( sClientRect.bottom - nHeight );
                                break;
                            }

                            // サイズバーコントロールを表示する
                            ::SetWindowPos( hSizeBar, HWND_TOP, nLeft, nTop, nWidth, nHeight, ( SWP_NOACTIVATE | SWP_SHOWWINDOW ) );
                            ::UpdateWindow( hSizeBar );

                            // クライアント描画領域から減算する
                            SubtractChildRect( hSizeBar, sClientRect );
                        }
                    }
                }
            }

            // ドキュメントタブウィンドウポインタを調べる
            if ( nullptr != pcDocumentTab ) {
                // ウィンドウ表示位置を取得する
                int nLeft   = sClientRect.left;
                int nTop    = sClientRect.top;
                int nWidth  = ( sClientRect.right  - nLeft );
                int nHeight = ( sClientRect.bottom - nTop );

                // ドキュメントタブウィンドウを表示する
                ::SetWindowPos( pcDocumentTab->GetHandle(), HWND_TOP, nLeft, nTop, nWidth, nHeight, ( SWP_NOACTIVATE | SWP_SHOWWINDOW ) );
                ::UpdateWindow( pcDocumentTab->GetHandle() );
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_SETFOCUSメッセージ処理関数
    LRESULT CWndPartition::WmSetFocus() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // キャプチャウィンドウを調べる
            if ( m_hWnd == ::GetCapture() ) {
                // 終了！
                break;
            }

            // ドキュメントタブウィンドウを取得する
            CWndDocumentTab* pcDocumentTab = GetDocumentTab();
            if ( nullptr != pcDocumentTab ) {
                // ウィンドウ表示フラグを調べる
                if ( pcDocumentTab->IsShow() ) {
                    // エレメントウィンドウフォーカス有効状態を調べる
                    if ( !m_bFocusElement ) {
                        // フォーカスウィンドウを設定する
                        ::SetFocus( pcDocumentTab->GetHandle() );

                        // 終了！
                        break;
                    }
                }
            }

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

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

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

            // 巡回する
            for ( int nIndex = 0, nCount = m_cElementList.GetCount(); nCount > nIndex; ++nIndex ) {
                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_cElementList[ nIndex ];
                if ( nullptr != pcElement ) {
                    // サイズバーコントロールを取得する
                    HWND hSizeBar = pcElement->GetSizeBar();
                    if ( hSizeBar == lpDraw->hwndItem ) {
                        // サイズバーコントロールを描画する
                        DrawSizeBar( lpDraw, GetPartitionPos( pcElement ) );

                        // 終了！
                        break;
                    }
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_SETCURSORメッセージ処理関数
    LRESULT CWndPartition::WmSetCursor() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // コントロールハンドルを取得する
            HWND hCtrl = reinterpret_cast< HWND >( m_wParam );

            // 巡回する
            for ( int nIndex = 0, nCount = m_cElementList.GetCount(); nCount > nIndex; ++nIndex ) {
                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_cElementList[ nIndex ];
                if ( nullptr != pcElement ) {
                    // コントロールハンドルを調べる
                    HWND hSizeBar = pcElement->GetSizeBar();
                    if ( hCtrl == hSizeBar ) {
                        // パーティション配置位置種別を調べる
                        EPartitionPos ePos = GetPartitionPos( pcElement );
                        switch ( ePos ) {
                        case EPartitionPos::Left:   // 左端
                        case EPartitionPos::Right:  // 右端
                            // 左右サイズ変更カーソル形状にする
                            ::SetCursor( ::LoadCursorW( nullptr, IDC_SIZEWE ) );

                            // 成功！
                            result = TRUE;
                            break;
                        case EPartitionPos::Top:    // 上端
                        case EPartitionPos::Bottom: // 下端
                            // 上下サイズ変更カーソル形状にする
                            ::SetCursor( ::LoadCursorW( nullptr, IDC_SIZENS ) );

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

                        // 終了！
                        break;
                    }
                }
            }

            // 実行結果を調べる
            if ( TRUE != result ) {
                // 基底クラスの関数を実行する
                result = CWndContainer::WmSetCursor();
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // STN_CLICKEDメッセージ処理関数
    LRESULT CWndPartition::StnClicked() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // コントロールハンドルを取得する
            HWND hCtrl = reinterpret_cast< HWND >( m_lParam );

            // 巡回する
            for ( int nIndex = 0, nCount = m_cElementList.GetCount(); nCount > nIndex; ++nIndex ) {
                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_cElementList[ nIndex ];
                if ( nullptr != pcElement ) {
                    // コントロールハンドルを調べる
                    HWND hSizeBar = pcElement->GetSizeBar();
                    if ( hCtrl == hSizeBar ) {
                        // サイズバー移動を開始する
                        BeginMoveSizeBar( pcElement );

                        // 終了！
                        break;
                    }
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // WM_LBUTTONUPメッセージ処理関数
    LRESULT CWndPartition::WmLButtonUp() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // キャプチャウィンドウを調べる
            if ( m_hWnd == ::GetCapture() ) {
                // サイズバー移動を終了する
                EndMoveSizeBar();

                // 終了！
                break;
            }

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

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

    //-------------------------------------------------------------------------
    // WM_KEYDOWNメッセージ処理関数
    LRESULT CWndPartition::WmKeyDown() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // キャプチャウィンドウを調べる
            if ( m_hWnd == ::GetCapture() ) {
                // 仮想キーコードを調べる
                int nVirtKey = static_cast< int >( m_wParam );
                if ( VK_ESCAPE == nVirtKey ) {
                    // サイズバー移動を中止する
                    CancelMoveSizeBar();

                    // 終了！
                    break;
                }
            }

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

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

    //-------------------------------------------------------------------------
    // WM_MOUSEMOVEメッセージ処理関数
    LRESULT CWndPartition::WmMouseMove() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // キャプチャウィンドウを調べる
            if ( m_hWnd == ::GetCapture() ) {
                // サイズバーを移動する
                MoveSizeBar();

                // 終了！
                break;
            }

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

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

    //-------------------------------------------------------------------------
    // ウィンドウ構成情報初期化関数
    bool CWndPartition::InitConfig( CJsonConfig& rcConfig ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 基底クラスの関数を実行する
            if ( !CWndContainer::InitConfig( rcConfig ) ) {
                // 失敗！
                break;
            }

            // ドキュメントタブウィンドウを取得する
            CWndDocumentTab* pcDocumentTab = GetDocumentTab();
            if ( nullptr != pcDocumentTab ) {
                // ドキュメントタブウィンドウセクションブロック
                CJsonConfigAuto cConfigAuto( rcConfig, pcDocumentTab->GetSectionName() );

                // ドキュメントタブウィンドウ構成情報を初期化する
                if ( !pcDocumentTab->InitConfig( rcConfig ) ) {
                    // 失敗！
                    break;
                }
            }

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

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

    //-------------------------------------------------------------------------
    // ウィンドウ構成情報復元関数
    bool CWndPartition::ResumeConfig( CJsonConfig& rcConfig ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 基底クラスの関数を実行する
            if ( !CWndContainer::ResumeConfig( rcConfig ) ) {
                // 失敗！
                break;
            }

            // ドキュメントタブウィンドウを取得する
            CWndDocumentTab* pcDocumentTab = GetDocumentTab();
            if ( nullptr != pcDocumentTab ) {
                // ドキュメントタブウィンドウセクションブロック
                CJsonConfigAuto cConfigAuto( rcConfig, pcDocumentTab->GetSectionName() );

                // ドキュメントタブウィンドウ構成情報を復元する
                if ( !pcDocumentTab->ResumeConfig( rcConfig ) ) {
                    // 失敗！
                    break;
                }
            }

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

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

    //-------------------------------------------------------------------------
    // ウィンドウ構成情報保存関数
    bool CWndPartition::SaveConfig( CJsonConfig& rcConfig ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 基底クラスの関数を実行する
            if ( !CWndContainer::SaveConfig( rcConfig ) ) {
                // 失敗！
                break;
            }

            // ドキュメントタブウィンドウを取得する
            CWndDocumentTab* pcDocumentTab = GetDocumentTab();
            if ( nullptr != pcDocumentTab ) {
                // ドキュメントタブウィンドウセクションブロック
                CJsonConfigAuto cConfigAuto( rcConfig, pcDocumentTab->GetSectionName(), true );

                // ドキュメントタブウィンドウ構成情報を保存する
                if ( !pcDocumentTab->SaveConfig( rcConfig ) ) {
                    // 失敗！
                    break;
                }
            }

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

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

    //-------------------------------------------------------------------------
    // 子ペインウィンドウ情報取得関数
    bool CWndPartition::GetChildPaneInfo( SChildPaneInfo& rsChildInfo ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 基底クラスの関数を実行する
            if ( !CWndContainer::GetChildPaneInfo( rsChildInfo ) ) {
                // 失敗！
                break;
            }

            // ドキュメントタブウィンドウを取得する
            CWndDocumentTab* pcDocumentTab = GetDocumentTab();
            if ( nullptr != pcDocumentTab ) {
                // 子ウィンドウ数をインクリメントする
                ++rsChildInfo.m_nCount;

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

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

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

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

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

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

    //-------------------------------------------------------------------------
    // ペインウィンドウオーダー番号取得関数
    int CWndPartition::GetOrderIndex( CWndPane* pcPane, int* pnOrder ) noexcept {
        // 処理ブロック
        int result = -1;
        do {
            // 基底クラスの関数を実行する
            int nOrder = CWndContainer::GetOrderIndex( pcPane, pnOrder );
            if ( 0 > nOrder ) {
                // ドキュメントタブウィンドウを取得する
                CWndDocumentTab* pcDocumentTab = GetDocumentTab();
                if ( nullptr != pcDocumentTab ) {
                    // ドキュメントタブウィンドウのオーダー番号を取得する
                    nOrder = pcDocumentTab->GetOrderIndex( pcPane, pnOrder );
                    if ( 0 > nOrder ) {
                        // 失敗！
                        break;
                    }
                }
            }

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

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

    //-------------------------------------------------------------------------
    // オーダー番号ペインウィンドウ取得関数
    CWndPane* CWndPartition::GetOrderPane( int* pnOrder ) noexcept {
        // 処理ブロック
        CWndPane* result = nullptr;
        do {
            // 基底クラスの関数を実行する
            CWndPane* pcPane = CWndContainer::GetOrderPane( pnOrder );
            if ( nullptr == pcPane ) {
                // ドキュメントタブウィンドウを取得する
                CWndDocumentTab* pcDocumentTab = GetDocumentTab();
                if ( nullptr == pcDocumentTab ) {
                    // 失敗！
                    break;
                }

                // ドキュメントタブウィンドウのオーダー番号ペインウィンドウを取得する
                pcPane = pcDocumentTab->GetOrderPane( pnOrder );
                if ( nullptr == pcPane ) {
                    // 失敗！
                    break;
                }
            }

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

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

    //-------------------------------------------------------------------------
    // 全子ウィンドウ表示関数
    bool CWndPartition::ShowChildAll( bool bShow ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 基底クラスの関数を実行する
            if ( !CWndContainer::ShowChildAll( bShow ) ) {
                // 失敗！
                break;
            }

            // ドキュメントタブウィンドウを取得する
            CWndDocumentTab* pcDocumentTab = GetDocumentTab();
            if ( nullptr != pcDocumentTab ) {
                // ドキュメントタブウィンドウを表示する
                if ( !ShowChildWindow( pcDocumentTab, bShow ) ) {
                    // 失敗！
                    break;
                }
                // ドキュメントタブウィンドウの全子ウィンドウを表示する
                else if ( !pcDocumentTab->ShowChildAll( bShow ) ) {
                    // 失敗！
                    break;
                }
            }

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

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

    //-------------------------------------------------------------------------
    // 全子ウィンドウ削除関数
    bool CWndPartition::DeleteChildAll() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ドキュメントタブウィンドウを取得する
            CWndDocumentTab* pcDocumentTab = GetDocumentTab();
            if ( nullptr != pcDocumentTab ) {
                // ドキュメントタブウィンドウの全子ウィンドウを削除する
                if ( !pcDocumentTab->DeleteChildAll() ) {
                    // 失敗！
                    break;
                }
            }

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

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

    //-------------------------------------------------------------------------
    // 子ウィンドウ削除可能状態取得関数
    bool CWndPartition::CanDeleteChildWindow( CWndPane* pcChild ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ドキュメントタブウィンドウを取得する
            CWndDocumentTab* pcDocumentTab = GetDocumentTab();
            if ( nullptr != pcDocumentTab ) {
                // 子ペインウィンドウポインタを調べる
                if ( pcDocumentTab == pcChild ) {
                    // 失敗！
                    break;
                }
            }

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

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

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

            // ドキュメントタブウィンドウを取得する
            CWndDocumentTab* pcDocumentTab = GetDocumentTab();
            if ( nullptr != pcDocumentTab ) {
                // 全ウィンドウクライアント領域を更新する
                pcDocumentTab->UpdateClientRectAll();
            }

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

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

    //-------------------------------------------------------------------------
    // クライアント描画領域取得関数
    bool CWndPartition::GetPaintRect( RECT& rsRect ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // パーティション表示クライアント領域を取得する
            RECT sClientRect;
            if ( !GetPartitionClientRect( sClientRect ) ) {
                // 失敗！
                break;
            }
            // 巡回する
            else for ( int nIndex = 0, nCount = m_cElementList.GetCount();; ++nIndex ) {
                // インデックスを調べる
                if ( nCount <= nIndex ) {
                    // ドキュメントタブウィンドウを取得する
                    CWndDocumentTab* pcDocumentTab = GetDocumentTab();
                    if ( nullptr != pcDocumentTab ) {
                        // ドキュメントタブウィンドウ表示状態を調べる
                        if ( 0 != ::IsWindowVisible( pcDocumentTab->GetHandle() ) ) {
                            // ウィンドウ表示領域を減算する
                            if ( !SubtractChildRect( pcDocumentTab->GetHandle(), sClientRect ) ) {
                                // 失敗！
                                break;
                            }
                        }
                    }

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

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

                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_cElementList[ nIndex ];
                if ( nullptr != pcElement ) {
                    // ウィンドウ表示状態を調べる
                    if ( 0 != ::IsWindowVisible( pcElement->GetHandle() ) ) {
                        // ウィンドウ表示領域を減算する
                        if ( !SubtractChildRect( pcElement->GetHandle(), sClientRect ) ) {
                            // 失敗！
                            break;
                        }

                        // サイズバーコントロールを取得する
                        HWND hSizeBar = pcElement->GetSizeBar();
                        if ( nullptr != hSizeBar ) {
                            // ウィンドウ表示状態を調べる
                            if ( 0 != ::IsWindowVisible( hSizeBar ) ) {
                                // ウィンドウ表示領域を減算する
                                if ( !SubtractChildRect( hSizeBar, sClientRect ) ) {
                                    // 失敗！
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 最小水平サイズ取得関数
    int CWndPartition::GetMinWidth() noexcept {
        // 処理ブロック
        int result = CWndContainer::GetMinWidth();
        do {
            // 最小サイズを取得する
            SIZE sSize;
            if ( GetMinSize( sSize ) ) {
                // 最小水平サイズを取得する
                result = sSize.cx;
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 最小垂直サイズ取得関数
    int CWndPartition::GetMinHeight() noexcept {
        // 処理ブロック
        int result = CWndContainer::GetMinHeight();
        do {
            // 最小サイズを取得する
            SIZE sSize;
            if ( GetMinSize( sSize ) ) {
                // 最小垂直サイズを取得する
                result = sSize.cy;
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // デバッグメニュー追加関数
    bool CWndPartition::AppendDebugMenu( HMENU hMenu ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 基底クラスの関数を実行する
            if ( !CWndContainer::AppendDebugMenu( hMenu ) ) {
                // 失敗！
                break;
            }

            // ドキュメントタブウィンドウを取得する
            CWndDocumentTab* pcDocumentTab = GetDocumentTab();
            if ( nullptr != pcDocumentTab ) {
                // サブメニューを作成する
                HMENU hSubMenu = ::CreatePopupMenu();
                if ( nullptr == hSubMenu ) {
                    // 失敗！
                    break;
                }
                // ドキュメントタブウィンドウのデバッグメニューを追加する
                else if ( !pcDocumentTab->AppendDebugMenu( hSubMenu ) ) {
                    // サブメニューを削除する
                    ::DestroyMenu( hSubMenu );

                    // 失敗！
                    break;
                }

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

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

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

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

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

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

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

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

    //-------------------------------------------------------------------------
    // 最小サイズ取得関数
    bool CWndPartition::GetMinSize( SIZE& rsSize, int nStart ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // エレメントウィンドウ数を取得する
            int nCount = m_cElementList.GetCount();

            // 開始インデックスを調べる
            if ( ( 0 > nStart ) || ( nCount < nStart ) ) {
                // 失敗！
                break;
            }

            // ドキュメントタブウィンドウを取得する
            CWndDocumentTab* pcDocumentTab = GetDocumentTab();
            if ( nullptr != pcDocumentTab ) {
                // ウィンドウ表示フラグを調べる
                if ( !pcDocumentTab->IsShow() ) {
                    // ドキュメントタブウィンドウポインタをクリアする
                    pcDocumentTab = nullptr;
                }
            }

            // 最小サイズをクリアする
            rsSize.cx = 0;
            rsSize.cy = 0;

            // パーティション直角配置位置最小サイズを初期化する
            int nMinAngleWidth  = 0;
            int nMinAngleHeight = 0;

            // 開始インデックスを調べる
            if ( 0 == nStart ) {
                // パーティション直角配置位置最小サイズを設定する
                nMinAngleWidth  = MIN_WIDTH;
                nMinAngleHeight = MIN_HEIGHT;
            }

            // 巡回する
            for ( int nIndex = nStart; nCount > nIndex; ++nIndex ) {
                // エレメントウィンドウを取得する
                CWndPane* pcElement = m_cElementList[ nIndex ];
                if ( nullptr != pcElement ) {
                    // ウィンドウ表示フラグを調べる
                    if ( pcElement->IsShow() ) {
                        // 最小サイズを取得する
                        int nMinWidth  = pcElement->GetMinWidth();
                        int nMinHeight = pcElement->GetMinHeight();

                        // パーティション配置位置を取得する
                        EPartitionPos ePos = GetPartitionPos( pcElement );

                        // ドキュメントタブウィンドウポインタを調べる
                        if ( nullptr == pcDocumentTab ) {
                            // 巡回する
                            for ( int nIndex2 = ( nIndex + 1 );; ++nIndex2 ) {
                                // インデックスを調べる
                                if ( nCount <= nIndex2 ) {
                                    // パーティション配置位置を無効化する
                                    ePos = EPartitionPos::Invalid;

                                    // 終了！
                                    break;
                                }

                                // エレメントウィンドウを取得する
                                CWndPane* pcElement2 = m_cElementList[ nIndex2 ];
                                if ( nullptr != pcElement2 ) {
                                    // ウィンドウ表示フラグを調べる
                                    if ( pcElement2->IsShow() ) {
                                        // 終了！
                                        break;
                                    }
                                }
                            }
                        }

                        // パーティション配置位置を調べる
                        switch ( ePos ) {
                        case EPartitionPos::Left:  // 左側
                        case EPartitionPos::Right: // 右側
                            // 最小水平サイズを更新する
                            rsSize.cx += ( nMinWidth + SIZEBAR_THICK );

                            // パーティション直角配置位置最小垂直サイズを更新する
                            nMinAngleHeight = max( nMinAngleHeight, ( rsSize.cy + nMinHeight ) );
                            break;
                        case EPartitionPos::Top:    // 上側
                        case EPartitionPos::Bottom: // 下側
                            // 最小垂直サイズを更新する
                            rsSize.cy += ( nMinHeight + SIZEBAR_THICK );

                            // パーティション直角配置位置最小水平サイズを更新する
                            nMinAngleWidth = max( nMinAngleWidth, ( rsSize.cx + nMinWidth ) );
                            break;
                        default:
                            // パーティション直角配置位置最小サイズを更新する
                            nMinAngleWidth  = max( nMinAngleWidth,  ( rsSize.cx + nMinWidth ) );
                            nMinAngleHeight = max( nMinAngleHeight, ( rsSize.cy + nMinHeight ) );
                            break;
                        }
                    }
                }
            }

            // ドキュメントタブウィンドウポインタを調べる
            if ( nullptr != pcDocumentTab ) {
                // 最小サイズを取得する
                int nMinWidth  = pcDocumentTab->GetMinWidth();
                int nMinHeight = pcDocumentTab->GetMinHeight();

                // パーティション直角配置位置最小サイズを更新する
                nMinAngleWidth  = max( nMinAngleWidth,  ( rsSize.cx + nMinWidth ) );
                nMinAngleHeight = max( nMinAngleHeight, ( rsSize.cy + nMinHeight ) );
            }

            // 最小サイズを更新する
            rsSize.cx = max( rsSize.cx, nMinAngleWidth );
            rsSize.cy = max( rsSize.cy, nMinAngleHeight );

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

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

    //-------------------------------------------------------------------------
    // 最小パーティション表示領域サイズ取得関数
    bool CWndPartition::GetMinPartitionSize( SIZE& rsSize ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // サイズをクリアする
            rsSize.cx = 0;
            rsSize.cy = 0;

            // ドキュメントタブウィンドウを取得する
            CWndDocumentTab* pcDocumentTab = GetDocumentTab();
            if ( nullptr != pcDocumentTab ) {
                // ウィンドウ表示フラグを調べる
                if ( !pcDocumentTab->IsShow() ) {
                    // ドキュメントタブウィンドウポインタをクリアする
                    pcDocumentTab = nullptr;
                }
            }

            // 巡回する
            int nMinAngleWidth  = 0;
            int nMinAngleHeight = 0;
            for ( int nIndex = 0, nCount = m_cElementList.GetCount();; ++nIndex ) {
                // インデックスを調べる
                if ( nCount <= nIndex ) {
                    // ドキュメントタブウィンドウポインタを調べる
                    if ( nullptr != pcDocumentTab ) {
                        // 最小サイズを取得する
                        int nMinWidth  = pcDocumentTab->GetMinWidth();
                        int nMinHeight = pcDocumentTab->GetMinHeight();

                        // 最小直角サイズを更新する
                        nMinAngleWidth  = max( nMinAngleWidth,  ( rsSize.cx + nMinWidth ) );
                        nMinAngleHeight = max( nMinAngleHeight, ( rsSize.cy + nMinHeight ) );
                    }

                    // 最小パーティション表示領域サイズを更新する
                    rsSize.cx = max( rsSize.cx, nMinAngleWidth  );
                    rsSize.cy = max( rsSize.cy, nMinAngleHeight );

                    // 終了！
                    break;
                }

                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_cElementList[ nIndex ];
                if ( nullptr != pcElement ) {
                    // ウィンドウ表示フラグを調べる
                    if ( pcElement->IsShow() ) {
                        // パーティション配置位置を取得する
                        EPartitionPos ePos = GetPartitionPos( pcElement );

                        // ドキュメントタブウィンドウポインタを調べる
                        if ( nullptr == pcDocumentTab ) {
                            // 巡回する
                            for ( int nIndex2 = ( nIndex + 1 );; ++nIndex2 ) {
                                // インデックスを調べる
                                if ( nCount <= nIndex2 ) {
                                    // パーティション配置位置を無効化する
                                    ePos = EPartitionPos::Invalid;

                                    // 終了！
                                    break;
                                }

                                // エレメントウィンドウを取得する
                                CWndElement* pcElement = m_cElementList[ nIndex2 ];
                                if ( nullptr != pcElement ) {
                                    // ウィンドウ表示フラグを調べる
                                    if ( pcElement->IsShow() ) {
                                        // 終了！
                                        break;
                                    }
                                }
                            }
                        }

                        // 最小サイズを取得する
                        int nMinWidth  = pcElement->GetMinWidth();
                        int nMinHeight = pcElement->GetMinHeight();

                        // パーティションサイズを取得する
                        int nSize = pcElement->GetPartitionSize();

                        // パーティション配置位置を調べる
                        switch ( ePos ) {
                        case EPartitionPos::Left:   // 左側
                        case EPartitionPos::Right:  // 右側
                            // 最小水平サイズを更新する
                            rsSize.cx += ( nSize + SIZEBAR_THICK );

                            // 最小直角垂直サイズを更新する
                            nMinAngleHeight = max( nMinAngleHeight, ( rsSize.cy + nMinHeight ) );
                            break;
                        case EPartitionPos::Top:    // 上側
                        case EPartitionPos::Bottom: // 下側
                            // 最小垂直サイズを更新する
                            rsSize.cy += ( nSize + SIZEBAR_THICK );

                            // 最小直角水平サイズを更新する
                            nMinAngleWidth = max( nMinAngleWidth, ( rsSize.cx + nMinWidth ) );
                            break;
                        default:
                            // 最小直角サイズを更新する
                            nMinAngleWidth  = max( nMinAngleWidth,  ( rsSize.cx + nMinWidth ) );
                            nMinAngleHeight = max( nMinAngleHeight, ( rsSize.cy + nMinHeight ) );
                            break;
                        }
                    }
                }
            }

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

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

    //-------------------------------------------------------------------------
    // パーティション配置位置取得関数
    EPartitionPos CWndPartition::GetPartitionPos( CWndElement* pcElement ) noexcept {
        // 処理ブロック
        EPartitionPos result = EPartitionPos::Invalid;
        do {
            // エレメントウィンドウポインタを調べる
            if ( nullptr == pcElement ) {
                // 失敗！
                break;
            }

            // パーティション配置位置を取得する
            EPartitionPos ePos = pcElement->GetPartitionPos();
            if ( EPartitionPos::Invalid == ePos ) {
                // 親ペインウィンドウを取得する
                CWndPane* pcParent = GetPaneWindow( ::GetParent( pcElement->GetHandle() ) );
                if ( nullptr == pcParent ) {
                    // 失敗！
                    break;
                }
                // パーティションウィンドウか調べる
                else if ( !pcParent->IsPartition() ) {
                    // 失敗！
                    break;
                }
                // パーティション配置位置を調べる
                else switch ( pcParent->GetPartitionPos() ) {
                case EPartitionPos::Left:   // 左側
                case EPartitionPos::Right:  // 右側
                    // パーティション配置位置を設定する
                    ePos = EPartitionPos::Top;
                    break;
                case EPartitionPos::Top:    // 上側
                case EPartitionPos::Bottom: // 下側
                    // パーティション配置位置を設定する
                    ePos = EPartitionPos::Left;
                    break;
                }

                // パーティション配置位置を調べる
                if ( EPartitionPos::Invalid == ePos ) {
                    // 失敗！
                    break;
                }
            }

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

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

    //-------------------------------------------------------------------------
    // サイズバー移動開始関数
    bool CWndPartition::BeginMoveSizeBar( CWndElement* pcElement ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // エレメントウィンドウポインタを調べる
            m_pcElement = pcElement;
            if ( nullptr == m_pcElement ) {
                // 失敗！
                break;
            }

            // パーティションサイズを保存する
            m_nSize = m_pcElement->GetPartitionSize();

            // 最小最大パーティションサイズを初期化する
            m_nMinSize = 0;
            m_nMaxSize = 0;

            // エレメントウィンドウ最小サイズを取得する
            int nMinWidth  = m_pcElement->GetMinWidth();
            int nMinHeight = m_pcElement->GetMinHeight();

            // パーティション配置位置を調べる
            EPartitionPos ePos = GetPartitionPos( m_pcElement );
            switch ( ePos ) {
            case EPartitionPos::Left:   // 左側
            case EPartitionPos::Right:  // 右側
                // パーティション最小サイズを更新する
                m_nMinSize = nMinWidth;
                break;
            case EPartitionPos::Top:    // 上側
            case EPartitionPos::Bottom: // 下側
                // パーティション最小サイズを更新する
                m_nMinSize = nMinHeight;
                break;
            }

            // パーティション表示クライアント領域を取得する
            RECT sClientRect;
            if ( GetPartitionClientRect( sClientRect ) ) {
                // スクリーン座標系に変換する
                ::ClientToScreen( m_hWnd, reinterpret_cast< LPPOINT >( &sClientRect.left ) );
                ::ClientToScreen( m_hWnd, reinterpret_cast< LPPOINT >( &sClientRect.right ) );

                // エレメントウィンドウ表示領域を取得する
                RECT sElementRect;
                ::GetWindowRect( m_pcElement->GetHandle(), &sElementRect );

                // パーティション配置位置を調べる
                switch ( ePos ) {
                case EPartitionPos::Left:   // 左側
                    // パーティション最大サイズを取得する
                    m_nMaxSize = ( sClientRect.right - sElementRect.left - SIZEBAR_THICK );
                    break;
                case EPartitionPos::Top:    // 上側
                    // パーティション最大サイズを取得する
                    m_nMaxSize = ( sClientRect.bottom - sElementRect.top - SIZEBAR_THICK );
                    break;
                case EPartitionPos::Right:  // 右側
                    // パーティション最大サイズを取得する
                    m_nMaxSize = ( sElementRect.right - sClientRect.left - SIZEBAR_THICK );
                    break;
                case EPartitionPos::Bottom: // 下側
                    // パーティション最大サイズを取得する
                    m_nMaxSize = ( sElementRect.bottom - sClientRect.top - SIZEBAR_THICK );
                    break;
                }

                // エレメントウィンドウインデックスを取得する
                int nElement = m_cElementList.Find( m_pcElement );

                // 巡回する
                for ( int nIndex = 0, nCount = m_cElementList.GetCount();; ++nIndex ) {
                    // インデックスを調べる
                    if ( nCount <= nIndex ) {
                        // ドキュメントタブウィンドウを取得する
                        CWndDocumentTab* pcDocumentTab = GetDocumentTab();
                        if ( nullptr != pcDocumentTab ) {
                            // ウィンドウ表示フラグを調べる
                            if ( pcDocumentTab->IsShow() ) {
                                // 最小サイズを取得する
                                int nMinWidth  = pcDocumentTab->GetMinWidth();
                                int nMinHeight = pcDocumentTab->GetMinHeight();

                                // パーティション配置位置を調べる
                                switch ( ePos ) {
                                case EPartitionPos::Left:   // 左側
                                case EPartitionPos::Right:  // 右側
                                    // 最大サイズを更新する
                                    m_nMaxSize -= nMinWidth;
                                    break;
                                case EPartitionPos::Top:    // 上側
                                case EPartitionPos::Bottom: // 下側
                                    // 最大サイズを更新する
                                    m_nMaxSize -= nMinHeight;
                                    break;
                                }
                            }
                        }

                        // 終了！
                        break;
                    }
                    // インデックスを調べる
                    else if ( nElement != nIndex ) {
                        // エレメントウィンドウを取得する
                        CWndElement* pcElement = m_cElementList[ nIndex ];
                        if ( nullptr != pcElement ) {
                            // ウィンドウ表示フラグを調べる
                            if ( pcElement->IsShow() ) {
                                // パーティション配置位置を取得する
                                EPartitionPos ePos2 = GetPartitionPos( pcElement );

                                // 最小サイズを取得する
                                int nMinWidth  = pcElement->GetMinWidth();
                                int nMinHeight = pcElement->GetMinHeight();

                                // パーティション配置位置を調べる
                                if ( ePos == ePos2 ) {
                                    // インデックスを調べる
                                    if ( nElement < nIndex ) {
                                        // パーティション配置位置を調べる
                                        switch ( ePos ) {
                                        case EPartitionPos::Left:   // 左側
                                        case EPartitionPos::Right:  // 右側
                                            // 最大サイズを更新する
                                            m_nMaxSize -= nMinWidth;
                                            break;
                                        case EPartitionPos::Top:    // 上側
                                        case EPartitionPos::Bottom: // 下側
                                            // 最大サイズを更新する
                                            m_nMaxSize -= nMinHeight;
                                            break;
                                        }
                                    }
                                }
                                // パーティション配置位置を調べる
                                else switch ( ePos ) {
                                case EPartitionPos::Left:   // 左側
                                case EPartitionPos::Right:  // 右側
                                    switch ( ePos2 ) {
                                    case EPartitionPos::Left:   // 左側
                                    case EPartitionPos::Right:  // 右側
                                        // 最大サイズを更新する
                                        m_nMaxSize -= nMinWidth;
                                        break;
                                    }
                                    break;
                                case EPartitionPos::Top:    // 上側
                                case EPartitionPos::Bottom: // 下側
                                    switch ( ePos2 ) {
                                    case EPartitionPos::Top:    // 上側
                                    case EPartitionPos::Bottom: // 下側
                                        // 最大サイズを更新する
                                        m_nMaxSize -= nMinHeight;
                                        break;
                                    }
                                    break;
                                }
                            }
                        }
                    }
                }
            }

            // サイズバーコントロールを取得する
            HWND hSizeBar = m_pcElement->GetSizeBar();

            // サイズバーコントロール表示位置を取得する
            RECT sSizeBarRect;
            ::GetWindowRect( hSizeBar, &sSizeBarRect );

            // カーソル座標としてサイズバー表示位置を取得する
            m_sPoint.x = sSizeBarRect.left;
            m_sPoint.y = sSizeBarRect.top;

            // リアルタイムパーティションサイズ変更フラグを調べる
            if ( !s_bResizePartitionRealTime ) {
                // サイズバーイメージコントロール表示位置を取得する
                int nLeft   = sSizeBarRect.left;
                int nTop    = sSizeBarRect.top;
                int nWidth  = ( sSizeBarRect.right  - nLeft );
                int nHeight = ( sSizeBarRect.bottom - nTop );

                // サイズバーイメージコントロールを表示する
                ::SetWindowPos( m_hSizeBarImage, HWND_TOP, nLeft, nTop, nWidth, nHeight, ( SWP_NOACTIVATE | SWP_SHOWWINDOW ) );
                ::UpdateWindow( m_hSizeBarImage );

                // サイズバーイメージコントロールを描画する
                HDC hDc  = ::GetDC( hSizeBar );
                HDC hDc2 = ::GetDC( m_hSizeBarImage );
                ::BitBlt( hDc2, 0, 0, nWidth, nHeight, hDc, 0, 0, SRCCOPY );
                ::ReleaseDC( m_hSizeBarImage, hDc2 );
                ::ReleaseDC( m_hSizeBarImage, hDc );
            }

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

            // マウスをキャプチャする
            ::SetCapture( m_hWnd );

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

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

    //-------------------------------------------------------------------------
    // サイズバー移動中止関数
    bool CWndPartition::CancelMoveSizeBar() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // エレメントウィンドウポインタを調べる
            if ( nullptr == m_pcElement ) {
                // 失敗！
                break;
            }

            // リアルタイムパーティションサイズ変更フラグを調べる
            if ( s_bResizePartitionRealTime ) {
                // サイズバーイメージコントロールを隠す
                ::ShowWindow( m_hSizeBarImage, SW_HIDE );

                // パーティションサイズを復元する
                m_pcElement->SetPartitionSize( m_nSize );

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

            // エレメントウィンドウポインタをクリアする
            m_pcElement = nullptr;

            // 保存パーティションサイズをクリアする
            m_nSize = 0;

            // マウスキャプチャを解放する
            ::ReleaseCapture();

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

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

    //-------------------------------------------------------------------------
    // サイズバー移動関数
    bool CWndPartition::MoveSizeBar() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // エレメントウィンドウポインタを調べる
            if ( nullptr == m_pcElement ) {
                // 失敗！
                break;
            }

            // カーソル移動量を取得する
            POINT sPoint;
            ::GetCursorPos( &sPoint );
            int dx = ( sPoint.x - m_sPoint.x );
            int dy = ( sPoint.y - m_sPoint.y );

            // パーティション配置位置を調べる
            EPartitionPos ePos  = GetPartitionPos( m_pcElement );
            int           nSize = 0;
            switch ( ePos ) {
            case EPartitionPos::Left:   // 左側
                // パーティションサイズを取得する
                nSize = ( m_nSize + dx );
                break;
            case EPartitionPos::Top:    // 上側
                // パーティションサイズを取得する
                nSize = ( m_nSize + dy );
                break;
            case EPartitionPos::Right:  // 右側
                // パーティションサイズを取得する
                nSize = ( m_nSize - dx );
                break;
            case EPartitionPos::Bottom: // 下側
                // パーティションサイズを取得する
                nSize = ( m_nSize -dy );
                break;
            }

            // 最小パーティションサイズを調べる
            if ( m_nMinSize > nSize ) {
                // パーティションサイズを更新する
                nSize = m_nMinSize;
            }
            // 最大パーティションサイズを調べる
            else if ( m_nMaxSize < nSize ) {
                // パーティションサイズを更新する
                nSize = m_nMaxSize;
            }

            // リアルタイムパーティションサイズ変更フラグを調べる
            if ( s_bResizePartitionRealTime ) {
                // パーティションサイズを設定する
                m_pcElement->SetPartitionSize( nSize );

                // WM_SIZEメッセージを送信する
                ::SendMessageW( m_hWnd, WM_SIZE, 0, 0 );
                ::UpdateWindow( m_hWnd );
            }
            else {
                // エレメントウィンドウ表示領域を取得する
                RECT sElementRect;
                ::GetWindowRect( m_pcElement->GetHandle(), &sElementRect );

                // サイズバーイメージコントロール表示位置を初期化する
                int nLeft = sElementRect.left;
                int nTop  = sElementRect.top;

                // パーティション配置位置を調べる
                switch ( ePos ) {
                case EPartitionPos::Left:   // 左側
                    // サイズバーイメージコントロール表示水平座標を取得する
                    nLeft = ( sElementRect.left + nSize );
                    break;
                case EPartitionPos::Top:    // 上側
                    // サイズバーイメージコントロール表示垂直座標を取得する
                    nTop = ( sElementRect.top + nSize );
                    break;
                case EPartitionPos::Right:  // 右側
                    // サイズバーイメージコントロール表示水平座標を取得する
                    nLeft = ( sElementRect.right - nSize - SIZEBAR_THICK );
                    break;
                case EPartitionPos::Bottom: // 下側
                    // サイズバーイメージコントロール表示垂直座標を取得する
                    nTop = ( sElementRect.bottom - nSize - SIZEBAR_THICK );
                    break;
                }

                // サイズバーイメージコントロールを移動する
                ::SetWindowPos( m_hSizeBarImage, HWND_TOP, nLeft, nTop, 0, 0, ( SWP_NOSIZE | SWP_NOACTIVATE | SWP_SHOWWINDOW ) );
                ::UpdateWindow( m_hSizeBarImage );
            }

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

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

    //-------------------------------------------------------------------------
    // サイズバー移動終了関数
    bool CWndPartition::EndMoveSizeBar() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // エレメントウィンドウポインタを調べる
            if ( nullptr == m_pcElement ) {
                // 失敗！
                break;
            }

            // リアルタイムパーティションサイズ変更フラグを調べる
            RECT sSizeBarRect;
            if ( s_bResizePartitionRealTime ) {
                // サイズバーコントロールを取得する
                HWND hSizeBar = m_pcElement->GetSizeBar();

                // サイズバーコントロール表示位置を取得する
                ::GetWindowRect( hSizeBar, &sSizeBarRect );
            }
            else {
                // サイズバーイメージコントロール表示領域を取得する
                ::GetWindowRect( m_hSizeBarImage, &sSizeBarRect );

                // サイズバーイメージコントロールを隠す
                ::ShowWindow( m_hSizeBarImage, SW_HIDE );
            }

            // エレメントウィンドウ表示領域を取得する
            RECT sElementRect;
            ::GetWindowRect( m_pcElement->GetHandle(), &sElementRect );

            // パーティション配置位置を調べる
            EPartitionPos ePos  = GetPartitionPos( m_pcElement );
            int           nSize = 0;
            switch ( ePos ) {
            case EPartitionPos::Left:   // 左側
                // パーティションサイズを取得する
                nSize = ( sSizeBarRect.left - sElementRect.left );
                break;
            case EPartitionPos::Top:    // 上側
                // パーティションサイズを取得する
                nSize = ( sSizeBarRect.top - sElementRect.top );
                break;
            case EPartitionPos::Right:  // 右側
                // パーティションサイズを取得する
                nSize = ( sElementRect.right - sSizeBarRect.right );
                break;
            case EPartitionPos::Bottom: // 下側
                // パーティションサイズを取得する
                nSize = ( sElementRect.bottom - sSizeBarRect.bottom );
                break;
            }

            // パーティションサイズを設定する
            m_pcElement->SetPartitionSize( nSize );

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

            // エレメントウィンドウポインタをクリアする
            m_pcElement = nullptr;

            // 保存パーティションサイズをクリアする
            m_nSize = 0;

            // マウスキャプチャを解放する
            ::ReleaseCapture();

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

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

    //-------------------------------------------------------------------------
    // サイズバーイメージコントロール作成関数
    bool CWndPartition::CreateSizeBarImageControl() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // サイズバーイメージコントロールを作成する
            DWORD dwStyle = ( WS_POPUP | SS_OWNERDRAW );
            m_hSizeBarImage = ::CreateWindowExW( WS_EX_LAYERED, WC_STATICW, nullptr, dwStyle, 0, 0, 0, 0, m_hWnd, nullptr, ::GetModuleHandleW( nullptr ), nullptr );
            if ( nullptr == m_hSizeBarImage ) {
                // 失敗！
                break;
            }
            // 透明度を設定する
            else if ( 0 == ::SetLayeredWindowAttributes( m_hSizeBarImage, 0, TRANS_SIZEBAR_IMAGE, LWA_ALPHA ) ) {
                // 失敗！
                break;
            }

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

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

    //-------------------------------------------------------------------------
    // サイズバーコントロール描画関数
    bool CWndPartition::DrawSizeBar( LPDRAWITEMSTRUCT lpDraw, EPartitionPos ePos ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ブラシを作成する
            HBRUSH hBrush = ::CreateSolidBrush( COLOR_SIZEBAR );

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

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

            // ペンを作成する
            HPEN hPen = ::CreatePen( PS_SOLID, 1, COLOR_SIZEBAR_BORDER );
            ::SelectObject( lpDraw->hDC, hPen );

            // パーティション配置位置を調べる
            int nLeft   = lpDraw->rcItem.left;
            int nTop    = lpDraw->rcItem.top;
            int nWidth  = ( lpDraw->rcItem.right  - nLeft );
            int nHeight = ( lpDraw->rcItem.bottom - nTop );
            switch ( ePos ) {
            case EPartitionPos::Left:   // 左側
            case EPartitionPos::Right:  // 右側
                // 上下ラインを描画する
                ::MoveToEx( lpDraw->hDC, nLeft, nTop, nullptr );
                ::LineTo( lpDraw->hDC, nLeft, ( nTop + nHeight ) );
                nLeft = ( lpDraw->rcItem.right - 1 );
                ::MoveToEx( lpDraw->hDC, nLeft, nTop, nullptr );
                ::LineTo( lpDraw->hDC, nLeft, ( nTop + nHeight ) );
                break;
            case EPartitionPos::Top:    // 上側
            case EPartitionPos::Bottom: // 下側
                // 左右ラインを描画する
                ::MoveToEx( lpDraw->hDC, nLeft, nTop, nullptr );
                ::LineTo( lpDraw->hDC, ( nLeft + nWidth ), nTop );
                nTop = ( lpDraw->rcItem.bottom - 1 );
                ::MoveToEx( lpDraw->hDC, nLeft, nTop, nullptr );
                ::LineTo( lpDraw->hDC, ( nLeft + nWidth ), nTop );
                break;
            }

            // ペンを削除する
            ::DeleteObject( hPen );

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

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

    //=========================================================================
    // 静的公開関数
    //-------------------------------------------------------------------------
    // サイズバーコントロール作成関数
    HWND CWndPartition::CreateSizeBar( HWND hParent ) noexcept {
        // 処理ブロック
        HWND result = nullptr;
        do {
            // サイズバーコントロールを作成する
            DWORD dwStyle  = ( WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | SS_NOTIFY | SS_OWNERDRAW );
            HWND  hSizeBar = ::CreateWindowExW( 0, WC_STATICW, nullptr, dwStyle, 0, 0, 0, 0, hParent, nullptr, ::GetModuleHandleW( nullptr ), nullptr );
            if ( nullptr == hSizeBar ) {
                // 失敗！
                break;
            }

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

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

#pragma managed( pop )