CWndDocumentTab.cpp

[詳解]

//=============================================================================
/// @file
/// ドキュメントタブウィンドウクラス実装ファイル
///
/// ドキュメントタブウィンドウクラス実装ファイルです。
///
/// $Id: CWndDocumentTab.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 <CWndDocumentTab.h>
#include <LibWindowUtility.h>
#include <commctrl.h>
#include <algorithm>

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

//=============================================================================
// ウィンドウライブラリ名前空間
namespace LibWindow {
    //=========================================================================
    // ドキュメントタブウィンドウクラス
    //=========================================================================
    // 構築子と解体子
    //-------------------------------------------------------------------------
    // コンストラクタ
    CWndDocumentTab::CWndDocumentTab( CWndElement* ( *pfnCreateElement )(), wchar_t const* pszElementName ) noexcept
        // 基底クラスコンストラクタ
        : CWndContainer( *pfnCreateElement, pszElementName )
        // メンバ変数初期化
        , m_cTitleBar()
        , m_hTabControl( nullptr )
    {}

    //-------------------------------------------------------------------------
    // ムーブコンストラクタ
    CWndDocumentTab::CWndDocumentTab( CWndDocumentTab&& rcInstance ) noexcept
        // 基底クラスコンストラクタ
        : CWndContainer( std::move( rcInstance ) )
        // メンバ変数初期化
        , m_cTitleBar()
        , m_hTabControl( nullptr )
    {}

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

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

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

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

            // タブコントロールを更新する
            UpdateTabControl();

            // クライアント領域を取得する
            RECT sClientRect = {};
            ::GetClientRect( m_hWnd, &sClientRect );

            // タブ下端表示状態を調べる
            if ( IsTabBottom() ) {
                // タイトルバー表示領域を初期化する
                int nLeft   = sClientRect.left;
                int nTop    = sClientRect.top;
                int nWidth  = ( sClientRect.right  - nLeft );
                int nHeight = TITLE_BAR_HEIGHT;

                // タイトルバーを表示する
                ::SetWindowPos( m_cTitleBar.GetHandle(), HWND_TOP, nLeft, nTop, nWidth, nHeight, ( SWP_NOACTIVATE | SWP_SHOWWINDOW ) );
                ::UpdateWindow( m_cTitleBar.GetHandle() );

                // クライアント描画領域から減算する
                SubtractChildRect( m_cTitleBar.GetHandle(), sClientRect );
            }
            else {
                // タイトルバーを隠す
                ::ShowWindow( m_cTitleBar.GetHandle(), SW_HIDE );
            }

            // 表示状態カレントインデックスを取得する
            int nCurrent = m_cElementList.GetShowCurrentIndex();

            // タブ項目数を調べる
            int nTabCount = static_cast< int >( ::SendMessageW( m_hTabControl, TCM_GETITEMCOUNT, 0, 0 ) );
            if ( 0 < nTabCount ) {
                // タブコントロール矩形領域を取得する
                RECT sTabRect = sClientRect;
                ::SendMessageW( m_hTabControl, TCM_ADJUSTRECT, 0, reinterpret_cast< LPARAM >( &sTabRect ) );

                // タブ下端表示状態を調べる
                if ( !IsTabBottom() ) {
                    // タブコントロールを上端に表示する
                    int nLeft   = sClientRect.left;
                    int nTop    = sClientRect.top;
                    int nWidth  = ( sClientRect.right - nLeft );
                    int nHeight = ( sTabRect.top      - nTop );
                    ::SetWindowPos( m_hTabControl, HWND_TOP, nLeft, nTop, nWidth, nHeight, ( SWP_NOACTIVATE | SWP_SHOWWINDOW ) );
                    ::UpdateWindow( m_hTabControl );

                    // クライアント描画領域から減算する
                    SubtractChildRect( m_hTabControl, sClientRect );
                }
                // タブ項目数を調べる
                else if ( 1 < nTabCount ) {
                    // タブコントロールを下端に表示する
                    int nHeight = ( ( sClientRect.bottom - sClientRect.top ) - ( sTabRect.bottom - sTabRect.top ) );
                    int nLeft   = sClientRect.left;
                    int nTop    = ( sClientRect.bottom - nHeight );
                    int nWidth  = ( sClientRect.right  - nLeft );
                    ::SetWindowPos( m_hTabControl, HWND_TOP, nLeft, nTop, nWidth, nHeight, ( SWP_NOACTIVATE | SWP_SHOWWINDOW ) );
                    ::UpdateWindow( m_hTabControl );

                    // クライアント描画領域から減算する
                    SubtractChildRect( m_hTabControl, sClientRect );
                }
                else {
                    // タブコントロールを隠す
                    ::ShowWindow( m_hTabControl, SW_HIDE );
                }

                // カレントエレメントウィンドウを取得する
                CWndElement* pcElement = m_cElementList[ nCurrent ];
                if ( nullptr != pcElement ) {
                    // エレメントウィンドウを表示する
                    int nLeft   = sClientRect.left;
                    int nTop    = sClientRect.top;
                    int nWidth  = ( sClientRect.right  - nLeft );
                    int nHeight = ( sClientRect.bottom - nTop );
                    ::SetWindowPos( pcElement->GetHandle(), HWND_TOP, nLeft, nTop, nWidth, nHeight, ( SWP_NOACTIVATE | SWP_SHOWWINDOW ) );
                    ::UpdateWindow( pcElement->GetHandle() );
                }
            }
            else {
                // タブコントロールを隠す
                ::ShowWindow( m_hTabControl, SW_HIDE );

                // カレントインデックスを無効化する
                nCurrent = -1;
            }

            // 巡回する
            for ( int nIndex = 0, nCount = m_cElementList.GetCount(); nCount > nIndex; ++nIndex ) {
                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_cElementList[ nIndex ];
                if ( nullptr != pcElement ) {
                    // カレントインデックスを調べる
                    if ( nCurrent != nIndex ) {
                        // エレメントウィンドウを隠す
                        ::ShowWindow( pcElement->GetHandle(), SW_HIDE );
                    }
                }
            }
        } while ( false );

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

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

            // コントロールハンドルを調べる
            if ( m_cTitleBar.GetHandle() == lpDraw->hwndItem ) {
                // タイトルバーを描画する
                DrawTitleBar( lpDraw );

                // 終了！
                break;
            }
            // コントロールハンドルを調べる
            else if ( m_hTabControl == lpDraw->hwndItem ) {
                // タブコントロールを描画する
                DrawTabControl( lpDraw );

                // 終了！
                break;
            }

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

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

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

            // コントロールハンドルを調べる
            if ( m_hTabControl == psNmHdr->hwndFrom ) {
                // 選択タブ項目インデックスを取得する
                int nIndex = static_cast< int >( ::SendMessageW( m_hTabControl, TCM_GETCURSEL, 0, 0 ) );
                if ( 0 <= nIndex ) {
                    // タブ項目情報を取得する
                    TCITEMW sTcItem = {};
                    sTcItem.mask = TCIF_PARAM;
                    if ( TRUE == ::SendMessageW( m_hTabControl, TCM_GETITEM, nIndex, reinterpret_cast< LPARAM >( &sTcItem ) ) ) {
                        // エレメントウィンドウを取得する
                        HWND         hElement  = reinterpret_cast< HWND >( sTcItem.lParam );
                        CWndElement* pcElement = m_cElementList.GetElementWindow( hElement );
                        if ( nullptr != pcElement ) {
                            // カレントエレメントウィンドウを設定する
                            if ( m_cElementList.SetCurrentElement( pcElement ) ) {
                                // WM_SIZEメッセージを送信する
                                ::SendMessageW( m_hWnd, WM_SIZE, 0, 0 );
                                ::UpdateWindow( m_hWnd );

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

                                // 終了！
                                break;
                            }
                        }
                    }
                }

                // 終了！
                break;
            }

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

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

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

            // コントロールハンドルを調べる
            if ( m_hTabControl == psNmHdr->hwndFrom ) {
                // フォーカスウィンドウを設定する
                ::SetFocus( m_hWnd );

                // 終了！
                break;
            }

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

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

    //-------------------------------------------------------------------------
    // STN_CLICKEDメッセージ処理関数
    LRESULT CWndDocumentTab::StnClicked() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // コントロールハンドルを調べる
            HWND hCtrl = reinterpret_cast< HWND >( m_lParam );
            if ( m_cTitleBar.GetHandle() == hCtrl ) {
                // フォーカスウィンドウを設定する
                ::SetFocus( m_hWnd );

                // 終了！
                break;
            }

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

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

    //-------------------------------------------------------------------------
    // WM_CONTEXTMENUメッセージ処理関数
    LRESULT CWndDocumentTab::WmContextMenu() noexcept {
        // 処理ブロック
        LRESULT result = 0;
        do {
            // カーソル位置を取得する
            POINT sPoint = { LOWORD( m_lParam ), HIWORD( m_lParam ) };

            // タブコントロールのクライアント座標系に変換する
            ::ScreenToClient( m_hTabControl, &sPoint );

            // タブ項目数を取得する
            int nTabCount = static_cast< int >( ::SendMessageW( m_hTabControl, TCM_GETITEMCOUNT, 0, 0 ) );

            // 巡回する
            for ( int nIndex = 0;; ++nIndex ) {
                // インデックスを調べる
                if ( nTabCount <= nIndex ) {
                    // 基底クラスの関数を実行する
                    result = CWndContainer::WmContextMenu();
                    break;
                }

                // タブ項目矩形領域を取得する
                RECT sRect;
                if ( TRUE == ::SendMessageW( m_hTabControl, TCM_GETITEMRECT, nIndex, reinterpret_cast< LPARAM >( &sRect ) ) ) {
                    // カーソル座標を調べる
                    if ( 0 != ::PtInRect( &sRect, sPoint ) ) {
                        // タブ項目情報を取得する
                        TCITEMW sTcItem = {};
                        sTcItem.mask = TCIF_PARAM;
                        if ( TRUE == ::SendMessageW( m_hTabControl, TCM_GETITEM, nIndex, reinterpret_cast< LPARAM >( &sTcItem ) ) ) {
                            // エレメントウィンドウを取得する
                            HWND         hElement  = reinterpret_cast< HWND >( sTcItem.lParam );
                            CWndElement* pcElement = m_cElementList.GetElementWindow( hElement );
                            if ( nullptr != pcElement ) {
                                // WM_CONTEXTMENUメッセージを送信する
                                ::SendMessageW( pcElement->GetHandle(), WM_CONTEXTMENU, reinterpret_cast< WPARAM >( hElement ), m_lParam );
                            }
                        }

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

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

    //-------------------------------------------------------------------------
    // クライアント領域更新関数
    bool CWndDocumentTab::UpdateClientRect() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // タイトルバーを無効化する
            ::InvalidateRect( m_cTitleBar.GetHandle(), nullptr, false );

            // ウィンドウを更新する
            ::UpdateWindow( m_cTitleBar.GetHandle() );

            // タブコントロールを無効化する
            ::InvalidateRect( m_hTabControl, nullptr, false );

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

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

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

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

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

            // タブコントロール表示状態を調べる
            if ( 0 != ::IsWindowVisible( m_hTabControl ) ) {
                // クライアント領域から減算する
                if ( !SubtractChildRect( m_hTabControl, rsRect ) ) {
                    // 失敗！
                    break;
                }
            }

            // 表示状態カレントインデックスを取得する
            int nIndex = m_cElementList.GetShowCurrentIndex();
            if ( 0 <= nIndex ) {
                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_cElementList[ nIndex ];
                if ( nullptr != pcElement ) {
                    // クライアント領域から減算する
                    if ( !SubtractChildRect( pcElement->GetHandle(), rsRect ) ) {
                        // 失敗！
                        break;
                    }
                }
            }

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

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

    //-------------------------------------------------------------------------
    // 最小水平サイズ取得関数
    int CWndDocumentTab::GetMinWidth() noexcept {
        // 処理ブロック
        int result = 0;
        do {
            // 基底クラスの関数を実行する
            result = CWndContainer::GetMinWidth();

            // 表示状態カレントインデックスを取得する
            int nIndex = m_cElementList.GetShowCurrentIndex();
            if ( 0 <= nIndex ) {
                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_cElementList[ nIndex ];
                if ( nullptr != pcElement ) {
                    // ウィンドウ表示フラグを調べる
                    if ( !pcElement->IsShow() ) {
                        // 最小水平サイズを取得する
                        int nMinWidth = pcElement->GetMinWidth();

                        // 最小水平サイズを更新する
                        result = max( result, nMinWidth );
                    }
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 最小垂直サイズ取得関数
    int CWndDocumentTab::GetMinHeight() noexcept {
        // 処理ブロック
        int result = 0;
        do {
            // 基底クラスの関数を実行する
            result = CWndContainer::GetMinHeight();

            // 表示状態カレントインデックスを取得する
            int nIndex = m_cElementList.GetShowCurrentIndex();
            if ( 0 <= nIndex ) {
                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_cElementList[ nIndex ];
                if ( nullptr != pcElement ) {
                    // ウィンドウ表示フラグを調べる
                    if ( !pcElement->IsShow() ) {
                        // 最小垂直サイズを取得する
                        int nMinHeight = pcElement->GetMinHeight();

                        // 最小垂直サイズを更新する
                        result = max( result, nMinHeight );
                    }
                }
            }

            // タイトルバー表示状態を調べる
            if ( 0 != ::IsWindowVisible( m_cTitleBar.GetHandle() ) ) {
                // タイトルバー表示領域を取得する
                RECT sRect;
                ::GetWindowRect( m_cTitleBar.GetHandle(), &sRect );

                // 最小垂直サイズを更新する
                result += ( sRect.bottom - sRect.top );
            }

            // タブコントロール表示状態を調べる
            if ( 0 != ::IsWindowVisible( m_hTabControl ) ) {
                // タブコントロール表示領域を取得する
                RECT sRect;
                ::GetWindowRect( m_hTabControl, &sRect );

                // 最小垂直サイズを更新する
                result += ( sRect.bottom - sRect.top );
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // タイトルバー描画関数
    bool CWndDocumentTab::DrawTitleBar( LPDRAWITEMSTRUCT lpDraw ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 表示状態カレントインデックスを取得する
            wchar_t szBuffer[ MAX_PATH ];
            int     nCurrent = m_cElementList.GetShowCurrentIndex();
            if ( 0 <= nCurrent ) {
                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_cElementList[ nCurrent ];
                if ( nullptr != pcElement ) {
                    // ウィンドウタイトルを取得する
                    ::GetWindowTextW( pcElement->GetHandle(), szBuffer, MAX_PATH );

                    // ウィンドウタイトルを設定する
                    ::SetWindowTextW( m_hWnd, szBuffer );
                }
            }

            // フォーカスウィンドウを調べる
            UINT uFlags = DC_SMALLCAP | DC_TEXT | DC_GRADIENT;
            if ( IsOwnOrChild( m_hWnd, ::GetFocus() ) ) {
                // アクティブフラグをセットする
                uFlags |= DC_ACTIVE;
            }

            // キャプションバーを描画する
            ::DrawCaption( lpDraw->hwndItem, lpDraw->hDC, &lpDraw->rcItem, uFlags );

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

            // 境界を描画する
            int nLeft  = lpDraw->rcItem.left;
            int nTop   = ( lpDraw->rcItem.bottom - 1 );
            int nWidth = ( lpDraw->rcItem.right - nLeft );
            ::MoveToEx( lpDraw->hDC, nLeft, nTop, nullptr );
            ::LineTo( lpDraw->hDC, ( nLeft + nWidth ), nTop );

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

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

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

    //-------------------------------------------------------------------------
    // タブコントロール作成関数
    bool CWndDocumentTab::CreateTabControl() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // タブ下端表示状態を調べる
            DWORD dwStyle = ( WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_FOCUSNEVER | TCS_OWNERDRAWFIXED );

            // タブコントロールを作成する
            m_hTabControl = ::CreateWindowExW( 0, WC_TABCONTROLW, nullptr, dwStyle, 0, 0, 0, 0, m_hWnd, nullptr, ::GetModuleHandleW( nullptr ), nullptr );
            if ( nullptr == m_hTabControl ) {
                // 失敗！
                break;
            }

            // フォントを設定する
            ::SendMessageW( m_hTabControl, WM_SETFONT, reinterpret_cast< WPARAM >( ::GetStockObject( DEFAULT_GUI_FONT ) ), 0 );

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

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

    //-------------------------------------------------------------------------
    // タブコントロール更新関数
    bool CWndDocumentTab::UpdateTabControl() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ウィンドウスタイルを取得する
            LONG_PTR nStyle = ::GetWindowLongPtrW( m_hTabControl, GWL_STYLE );

            // タブ下端表示状態を調べる
            if ( IsTabBottom() ) {
                // タブコントロールスタイルを設定する
                nStyle |= TCS_BOTTOM;
            }
            else {
                // タブコントロールスタイルを設定する
                nStyle &= ~TCS_BOTTOM;
            }

            // ウィンドウスタイルを設定する
            ::SetWindowLongPtrW( m_hTabControl, GWL_STYLE, nStyle );

            // タイトルバー文字列を初期化する
            wchar_t szTitle[ MAX_PATH ];
            ::wcscpy_s( szTitle, GetSectionName() );

            // エレメントウィンドウ数を取得する
            int nCount = m_cElementList.GetCount();

            // 表示状態カレントインデックスを取得する
            int nCurrent = m_cElementList.GetShowCurrentIndex();

            // タブ項目数を取得する
            int nTabCount = static_cast< int >( ::SendMessageW( m_hTabControl, TCM_GETITEMCOUNT, 0, 0 ) );

            // 表示状態エレメントウィンドウ数をクリアする
            int nShowCount = 0;

            // 巡回する
            for ( int nIndex = 0; nCount > nIndex; ++nIndex ) {
                // エレメントウィンドウを取得する
                CWndElement* pcElement = m_cElementList[ nIndex ];
                if ( nullptr != pcElement ) {
                    // ウィンドウ表示フラグを調べる
                    if ( pcElement->IsShow() ) {
                        // ウィンドウタイトルを取得する
                        wchar_t szBuffer[ MAX_PATH ];
                        ::GetWindowTextW( pcElement->GetHandle(), szBuffer, MAX_PATH );

                        // タブ項目情報を作成する
                        TCITEMW sTcItem = {};
                        sTcItem.mask    = ( TCIF_TEXT | TCIF_PARAM );
                        sTcItem.pszText = szBuffer;
                        sTcItem.lParam  = reinterpret_cast< LPARAM >( pcElement->GetHandle() );

                        // インデックスを調べる
                        if ( nTabCount > nShowCount ) {
                            // タブ項目情報を設定する
                            ::SendMessageW( m_hTabControl, TCM_SETITEM, nShowCount, reinterpret_cast< LPARAM >( &sTcItem ) );
                        }
                        else {
                            // タブ項目を追加する
                            ::SendMessageW( m_hTabControl, TCM_INSERTITEMW, nShowCount, reinterpret_cast< LPARAM >( &sTcItem ) );

                            // タブ項目数をインクリメントする
                            ++nTabCount;
                        }

                        // カレントインデックスを調べる
                        if ( nCurrent == nIndex ) {
                            // エレメントウィンドウタイトルを取得する
                            ::wcscpy_s( szTitle, szBuffer );

                            // タブ項目を選択する
                            ::SendMessageW( m_hTabControl, TCM_SETCURSEL, nShowCount, 0 );
                        }

                        // 表示状態エレメントウィンドウ数をインクリメントする
                        ++nShowCount;
                    }
                }
            }

            // 巡回する
            for ( ; nShowCount < nTabCount; --nTabCount ) {
                // タブ項目を削除する
                ::SendMessageW( m_hTabControl, TCM_DELETEITEM, ( nTabCount - 1 ), 0 );
            }

            // タイトルバー文字列を設定する
            ::SetWindowTextW( m_cTitleBar.GetHandle(), szTitle );

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

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

    //-------------------------------------------------------------------------
    // タブコントロール描画関数
    bool CWndDocumentTab::DrawTabControl( LPDRAWITEMSTRUCT lpDraw ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // タブ項目情報を取得する
            TCITEMW sTcItem = {};
            wchar_t szBuffer[ MAX_PATH ];
            sTcItem.mask       = ( TCIF_TEXT | TCIF_PARAM );
            sTcItem.pszText    = szBuffer;
            sTcItem.cchTextMax = MAX_PATH;
            if ( TRUE != ::SendMessageW( lpDraw->hwndItem, TCM_GETITEM, lpDraw->itemID, reinterpret_cast< LPARAM >( &sTcItem ) ) ) {
                // 失敗！
                break;
            }

            // エレメントウィンドウハンドルを取得する
            HWND hElement = reinterpret_cast< HWND >( sTcItem.lParam );

            // フォーカスウィンドウ保存ハンドルを調べる
            COLORREF dwColor = COLOR_TAB_NORMAL;
            if ( IsOwnOrChild( hElement, s_hFocus ) ) {
                // 背景色を取得する
                dwColor = COLOR_TAB_FOCUS;
            }

            // ブラシを作成する
            HBRUSH hBrush = ::CreateSolidBrush( dwColor );

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

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

            // タブ項目タイトルを表示する
            lpDraw->rcItem.left += 4;
            ::SetTextColor( lpDraw->hDC, ::GetSysColor( COLOR_WINDOWTEXT ) );
            ::SetBkMode( lpDraw->hDC, TRANSPARENT );
            ::DrawTextW( lpDraw->hDC, szBuffer, -1, &lpDraw->rcItem, ( DT_LEFT | DT_SINGLELINE | DT_VCENTER ) );

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

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

#pragma managed( pop )