TnbMfcDrawingMenu.h

[詳解]

#pragma once
#include "TnbMfcAbstractDrawingCtrl.h"
#include "TnbMfcBitmapDC.h"
#include "TnbSimpleVector.h"
#include "TnbPointerVector.h"
#include "TnbWindowProcedureHooker.h"
#include "TnbFontHandle.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class COwnerdrawMenuSupportProcedureHooker: public CWindowProcedureHooker
{
    DEFSUPER(CWindowProcedureHooker);
public:
 
    COwnerdrawMenuSupportProcedureHooker(void) : m_cookie(0x8000)
    {
    }
 
    DWORD RegisterMenu(CMenu* pMenu)
    {
        TParam t;
        t.pMenu = pMenu;
        t.hMenu = pMenu->m_hMenu;
        t.cookie = m_cookie;
        m_params.Add(t);
        m_cookie++;
        m_cookie |= 0x8000;
        return t.cookie * 0x10000;
    }
 
protected:
 
    LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        switch ( message )
        {
        case WM_INITMENUPOPUP:
#if 0
            {
                HMENU hMenu = reinterpret_cast<HMENU>(wParam);
                loop ( i, m_params.GetSize() )
                {
                    if ( m_params[i].hMenu == hMenu )
                    {
                        MEASUREITEMSTRUCT m = { 0 };
                        m.CtlType = ODT_MENU;
                        m.CtlID = 'TMDM';
                        m.itemData = reinterpret_cast<DWORD>(this);
                        m_params[i].pMenu->MeasureItem(&m);
                    }
                }
            }
#endif
            break;
        case WM_MEASUREITEM:
            {
                MEASUREITEMSTRUCT* P = reinterpret_cast<MEASUREITEMSTRUCT*>(lParam);
                if ( P->CtlType == ODT_MENU )
                {
                    const TParam* T = m_Search(static_cast<WORD>(P->itemData / 0x10000));
                    if ( T != NULL )
                    {
                        T->pMenu->MeasureItem(P);
                        return 0;
                    }
                }
            }
            break;
        case WM_DRAWITEM:
            {
                DRAWITEMSTRUCT* P = reinterpret_cast<DRAWITEMSTRUCT*>(lParam);
                if ( P->CtlType == ODT_MENU )
                {
                    const TParam* T = m_Search(static_cast<WORD>(P->itemData / 0x10000));
                    if ( T != NULL )
                    {
                        ASSERT( T->hMenu == reinterpret_cast<HMENU>(P->hwndItem) );
                        T->pMenu->DrawItem(P);
                        return 0;
                    }
                }
            }
            break;
        case WM_DESTROY:
            m_params.RemoveAll();
            m_cookie = 0x8000;
            break;
        default:
            break;
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
private:
    struct TParam
    {
        HMENU       hMenu;      
        CMenu*      pMenu;      
        WORD        cookie;     
    };
    CSimpleVectorT<TParam>  m_params;   
    WORD                    m_cookie;   
    const TParam* m_Search(WORD w)
    {
        for ( size_t lp = m_params.GetSize(); lp > 0; lp-- )
        {
            size_t i = lp - 1;
            const TParam& t = m_params.At(i);
            if ( ! ::IsMenu(t.hMenu) )
            {
                m_params.Remove(i);
            }
            else if ( t.cookie == w )
            {
                return &t;
            }
        }
        return NULL;
    }
};
 
 
 
class CAbstractDrawingMenu : public CMenu, public CAbstractDrawingCtrl
{
    DEFSUPER(CMenu);
    typedef CAbstractDrawingCtrl    _mark;          
public:
 
    CAbstractDrawingMenu(void) 
        : _super(), m_leftMargin(20), m_baseCookie(0), m_hWnd(NULL)
        , m_textColor(::GetSysColor(COLOR_MENUTEXT)), m_textDisableColor(CLR_INVALID)
        , m_isAllOwnerDraw(false), m_withSubMenu(false)
    {
        m_font.SetSystemMenuFont();
        m_fontBold.SetAsBold(m_font);
    }
 
    ~CAbstractDrawingMenu(void)
    {
    }
 
    HWND GetParentHwnd(void) const
    {
        return m_hWnd;
    }
 
    bool IsValid(void) const
    {
        return !! ::IsMenu(_super::m_hMenu);
    }
 
    void SetTextColor(COLORREF color1, COLORREF color2 = CLR_INVALID)
    {
        m_textColor = color1;
        m_textDisableColor = color2;
    }
 
    void SetTextFont(HFONT font)
    {
        m_font.SetClone(font);
        m_fontBold.SetAsBold(m_font);
    }
 
    void SetLeftMargin(int m)
    {
        m_leftMargin = m;
    }
 
    void SetDefaultMarkDrawer(COLORREF base = ::GetSysColor(COLOR_MENU))
    {
        _mark::SetDefaultMarkDrawer(base);
    }
 
    void CopyParameter(const CAbstractDrawingMenu& o)
    {
        CAbstractDrawingCtrl* pDC1 = this;
        const CAbstractDrawingCtrl* pDC2 = &o;
        *pDC1 = *pDC2;
        m_hWnd = o.m_hWnd;      
        m_baseCookie = o.m_baseCookie;      
        m_items = o.m_items;            
        m_font = o.m_font;              
        m_fontBold = o.m_fontBold;              
        m_textColor = o.m_textColor;        
        m_textDisableColor = o.m_textDisableColor;  
        m_leftMargin = o.m_leftMargin;
    }
 
    BOOL AppendDrawingMenu(UINT nFlags, const IDrawable& draw, LPCSTR lpszText = NULL, UINT_PTR nIDNewItem = 0)
    {
        return InsertDrawingMenu(static_cast<UINT>(-1), nFlags | MF_BYPOSITION, draw, lpszText, nIDNewItem);
    }
 
    BOOL InsertDrawingMenu(UINT nPosition, UINT nFlags, const IDrawable& draw, LPCSTR lpszText = NULL, UINT_PTR nIDNewItem = 0)
    {
        size_t l = m_items.GetSize();
        TParam p;
        p.pDraw = draw.Clone();
        p.text = lpszText;
        UINT nf = MF_OWNERDRAW | MF_SEPARATOR | MF_STRING;
        nFlags = (nFlags & ~nf);
        BOOL r = _super::InsertMenu(nPosition, nFlags | MF_OWNERDRAW, nIDNewItem, reinterpret_cast<LPCTSTR>(m_baseCookie | l));
        if ( r )
        {
            m_items.Add(p);
            m_ResetWidths();
        }
        return r;
    }
 
    virtual void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct) 
    {
        if ( lpMeasureItemStruct->CtlType != ODT_MENU )
        {
            return;
        }
        if ( (lpMeasureItemStruct->itemData & 0xFFFF0000) != m_baseCookie )
        {
            return;
        }
#if 0
        if ( lpMeasureItemStruct->CtlID == 'TMDM' )
        {
            COwnerdrawMenuSupportProcedureHooker* pProc = reinterpret_cast<COwnerdrawMenuSupportProcedureHooker*>(lpMeasureItemStruct->itemData);
            if ( m_isAllOwnerDraw )
            {
                m_AllSetOwnerDrawState(pProc, m_withSubMenu);
            }
            return;
        }
#endif
        INDEX idx = m_ItemDataToPos(lpMeasureItemStruct->itemData);
        UINT flag = _super::GetMenuState(down_cast<UINT>(idx), MF_BYPOSITION);
        if ( idx != INVALID_INDEX )
        {
            lpMeasureItemStruct->itemWidth = down_cast<UINT>(m_items[lpMeasureItemStruct->itemData & 0xFFFF].width);
        }
        if ( flag & MF_SEPARATOR ) 
        {
            lpMeasureItemStruct->itemHeight /= 2;
        }
    }
        
    virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct) 
    {
        if ( lpDrawItemStruct->CtlType != ODT_MENU )
        {
            return;
        }
        if ( (lpDrawItemStruct->itemData & 0xFFFF0000) != m_baseCookie )
        {
            return;
        }
        INDEX idx = m_ItemDataToPos(lpDrawItemStruct->itemData);
        MENUITEMINFO mii = { sizeof(MENUITEMINFO) };
        mii.fMask = MIIM_STRING;
        VERIFY( _super::GetMenuItemInfo(down_cast<UINT>(idx), &mii, TRUE) );
        CStr str;
        mii.cch++;
        mii.dwTypeData = str.GetBuffer(mii.cch);
        mii.fMask = MIIM_FTYPE | MIIM_BITMAP | MIIM_STATE | MIIM_STRING | MIIM_CHECKMARKS;
        VERIFY( _super::GetMenuItemInfo(down_cast<UINT>(idx), &mii, TRUE) );
        str.ReleaseBuffer();
        HDC dc = lpDrawItemStruct->hDC;
        const CRect& rc = lpDrawItemStruct->rcItem;
        CSize sz = rc.Size();
        if ( str.IsEmpty() )
        {
            INDEX i = lpDrawItemStruct->itemData & 0xFFFF;
            if ( m_items.IsInRange(i) )
            {
                str = m_items[i].text;
            }
        }
        CBitmapImage bi;
        if ( bi.Set(sz.cx, sz.cy) )
        {
            CBitmapDC bmpDC(&bi);
            _mark::DrawBackground(bmpDC, CRect(CPoint(0, 0), sz));
            if ( GetSelectMarkType() == BACKGROUND )
            {
                m_DrawSelectMaker(bmpDC, sz, lpDrawItemStruct->itemState);
            }
            if ( (mii.fType & MFT_SEPARATOR) == 0 )
            {
                //TTRACE3("flag=0x%X, id=0x%X, type=0x%X\n", flag, id, mii.fType);
                const IDrawable* pDraw = m_items[lpDrawItemStruct->itemData & 0xFFFF].pDraw;
                if ( pDraw != NULL )
                {
                    SIZE s;
                    pDraw->GetSize(s);
                    pDraw->Draw(bmpDC, 0, (sz.cy - s.cy) / 2);
                }
                bool isEnable = (lpDrawItemStruct->itemState & (CDIS_DISABLED | CDIS_GRAYED)) == 0;
                if ( ! str.IsEmpty() )
                {
                    COLORREF c = (isEnable ? m_textColor : m_textDisableColor);
                    CFontHandle ff = m_font;
                    if ( isEnable && (mii.fState & MFS_DEFAULT) != 0 )
                    {
                        ff = m_fontBold;
                    }
                    HGDIOBJ hOldFont = ::SelectObject(bmpDC, ff);
                    ::SetBkMode(bmpDC, TRANSPARENT);
                    DWORD st = (m_leftMargin >= 0 ? 0 : DT_CENTER);
                    int mar = max(m_leftMargin, 0);
                    m_DrawText(bmpDC, CRect(2 + mar, 0, sz.cx - 1, sz.cy), c, str, st);
                    ::SelectObject(bmpDC, hOldFont);
                }
                UINT ts = (isEnable ? 0 : DFCS_INACTIVE);
                if ( (mii.fState & MFS_CHECKED) != 0 )
                {
                    // チェック
                    if ( mii.hbmpChecked == NULL )
                    {
                        if ( (mii.fType & MFT_RADIOCHECK) == 0 )
                        {
                            m_DrawIcon(bmpDC, sz, DFC_MENU, DFCS_MENUCHECK | ts);
                        }
                        else
                        {
                            m_DrawIcon(bmpDC, sz, DFC_MENU, DFCS_MENUBULLET | ts);
                        }
                    }
                    else
                    {
                        CBitmapHandle b = mii.hbmpChecked; //動作未確認
                        b.Draw(bmpDC);
                        b.Detach();
                    }
                }
                else if ( mii.hbmpItem != NULL )
                {
                    int t = -1;
                    switch ( reinterpret_cast<INT_PTR>(mii.hbmpItem) )
                    {
                    case HBMMENU_POPUP_CLOSE:
                        t = DFCS_CAPTIONCLOSE;
                        break;
                    case HBMMENU_POPUP_RESTORE:
                        t = DFCS_CAPTIONRESTORE;
                        break;
                    case HBMMENU_POPUP_MAXIMIZE:
                        t = DFCS_CAPTIONMAX;
                        break;
                    case HBMMENU_POPUP_MINIMIZE:
                        t = DFCS_CAPTIONMIN;
                        break;
                    default:
                        break;
                    }
                    if ( t >= 0 )
                    {
                        m_DrawIcon(bmpDC, sz, DFC_CAPTION, t | DFCS_FLAT | ts);
                    }
                }
            }
            else
            {
                // セパレータ
                CRect r(0, 0, sz.cx, sz.cy);
                CPoint po = r.CenterPoint();
                r.left += 3;
                r.right -= 3;
                r.top = po.y;
                r.bottom = po.y + 2;
                ::DrawEdge(bmpDC, r, EDGE_ETCHED, BF_TOP | BF_BOTTOM);
            }
            if ( GetSelectMarkType() == OVERLAP )
            {
                m_DrawSelectMaker(bmpDC, sz, lpDrawItemStruct->itemState);
            }
            bmpDC.Draw(dc, rc.left, rc.top);
        }
    }
 
protected:
 
    virtual void OnFoundSubMenu(HMENU hMenu, COwnerdrawMenuSupportProcedureHooker* pProc) = 0;
 
    void Regist(COwnerdrawMenuSupportProcedureHooker* pProc, bool isAllOwnerDraw = true, bool withSubMenu = true)
    {
        m_Regist(pProc);
        m_isAllOwnerDraw = isAllOwnerDraw;
        m_withSubMenu = withSubMenu;
        if ( isAllOwnerDraw )
        {
            m_AllSetOwnerDrawState(pProc, false);
        }
    }
 
private:
    void m_DrawIcon(HDC dc, const SIZE& sz, UINT t1, UINT t2)
    {
        CBitmapImage b;
        b.Set(sz.cy - 2, sz.cy - 2);
        ::DrawFrameControl(b.GetDC(), CRect(-1, -1, sz.cy - 1 , sz.cy - 1), t1, t2 | DFCS_TRANSPARENT);
        b.ReleaseDC();
        b.ChangePixelColor(RGB(0, 0, 0), m_textColor);
        b.TransparentBit(dc, 1, 1);
    }
    void m_DrawText(HDC dc, const CRect& rc, COLORREF color, const CStr& text, DWORD style = 0)
    {
        CStr s2;
        CStr s1 = text.FindCut('\t', &s2);
        CTextDrawer::DrawTextRect(dc, rc, DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS | style, color, s1);
        if ( ! s2.IsEmpty() )
        {
            CTextDrawer::DrawTextRect(dc, rc, DT_VCENTER | DT_RIGHT | DT_SINGLELINE | DT_END_ELLIPSIS, color, s2 + _T("   "));
        }
    }
    void m_Regist(COwnerdrawMenuSupportProcedureHooker* pProc)
    {
        m_baseCookie = pProc->RegisterMenu(this);
        m_hWnd = pProc->GetSafeHwnd();
    }
    void m_AllSetOwnerDrawState(COwnerdrawMenuSupportProcedureHooker* pProc, bool withSubMenu = true)
    {
        m_items.RemoveAll();
        int len = ::GetMenuItemCount(m_hMenu);
        if ( len >= 0 )
        {
            loop ( i, len )
            {
                MENUITEMINFO mii = { sizeof(MENUITEMINFO) };
                mii.fMask = MIIM_FTYPE | MIIM_STATE;
                VERIFY( ::GetMenuItemInfo(m_hMenu, down_cast<UINT>(i), TRUE, &mii) );
                mii.fMask = MIIM_FTYPE | MIIM_DATA;
                mii.dwItemData = (m_baseCookie | i);
                mii.fType |= MFT_OWNERDRAW;
                VERIFY( ::SetMenuItemInfo(m_hMenu, down_cast<UINT>(i), TRUE, &mii) );
                #ifdef _DEBUG
                    CString s;
                    _super::GetMenuString(down_cast<UINT>(i), s, MF_BYPOSITION);
                    TTRACE3("[%s] t=0x%X s=0x%X \n", s, mii.fType, mii.fState);
                #endif
                if ( withSubMenu )
                {
                    HMENU hSub = ::GetSubMenu(m_hMenu, ToInt(i));
                    if ( hSub != NULL )
                    {
                        OnFoundSubMenu(hSub, pProc);
                    }
                }
            }
        }
        m_ResetWidths();
    }
    INDEX m_ItemDataToPos(DWORD_PTR data)
    {
        MENUITEMINFO mif = { sizeof(MENUITEMINFO), MIIM_TYPE | MIIM_DATA };
        TCHAR tempBuf[16];
        mif.cch = 10;
        mif.dwTypeData = tempBuf;
        loop ( i, _super::GetMenuItemCount() )
        {
            if ( _super::GetMenuItemInfo(down_cast<UINT>(i), &mif, TRUE) )
            {
                if ( (mif.fType & MFT_OWNERDRAW) != 0 && mif.dwItemData == data )
                {
                    return i;
                }
            }
        }
        return INVALID_INDEX;
    }
    void m_ResetWidths(void)
    {
        HDC dc = ::GetWindowDC(NULL);
        HGDIOBJ old = ::GetCurrentObject(dc, OBJ_FONT);
        CSize size(0, 0);
        MENUITEMINFO mif = { sizeof(MENUITEMINFO), MIIM_TYPE | MIIM_DATA | MIIM_STATE };
        TCHAR tempBuf[16];
        mif.cch = 10;
        mif.dwTypeData = tempBuf;
        int len = ::GetMenuItemCount(m_hMenu);
        if ( len >= 0 )
        {
            bool hasTab = false;
            loop ( i, len )
            {
                if ( _super::GetMenuItemInfo(down_cast<UINT>(i), &mif, TRUE) )
                {
                    INDEX idx = mif.dwItemData;
                    if ( (mif.fType & MFT_OWNERDRAW) != 0 && idx != 0 )
                    {
                        idx &= 0xFFFF;
                        if ( m_items.GetSize() <= idx )
                        {
                            m_items.SetSize(idx + 1);
                        }
                        CString s = m_items[idx].text;
                        if ( s.IsEmpty() )
                        {
                            MENUITEMINFO mii = { sizeof(MENUITEMINFO) };
                            mii.fMask = MIIM_STRING;
                            VERIFY( _super::GetMenuItemInfo(down_cast<UINT>(i), &mii, TRUE) );
                            CStr str;
                            mii.cch++;
                            mii.dwTypeData = s.GetBuffer(mii.cch);
                            VERIFY( _super::GetMenuItemInfo(down_cast<UINT>(i), &mii, TRUE) );
                            s.ReleaseBuffer();
                        }
                        if ( s.Find('\t') != INVALID_INDEX )
                        {
                            hasTab = true;
                        }
                        CFontHandle ff = m_font;
                        if ( (mif.fState & MF_DEFAULT) != 0 )
                        {
                            ff = m_fontBold;
                        }
                        ::SelectObject(dc, ff);
                        CTextDrawer::CalcTextSize(size, dc, DT_LEFT, s);
                        int mar = max(m_leftMargin, 0);
                        long w = size.cx + 4 + mar;
                        const IDrawable* pDraw = m_items[idx].pDraw;
                        if ( pDraw != NULL && pDraw->GetSize(size) )
                        {
                            w = max(size.cx, w);
                        }
                        m_items[idx].width = w;
                    }
                }
            }
            if ( hasTab )
            {
                CTextDrawer::CalcTextSize(size, dc, DT_LEFT, _T("Atl+F4   "));
                loop ( i, m_items )
                {
                    m_items[i].width += size.cx;
                }
            }
        }
        ::SelectObject(dc, old);
        ::ReleaseDC(NULL, dc);
    }
    void m_DrawSelectMaker(HDC dc, const SIZE& sz, UINT itemState)
    {
        if ( (itemState & CDIS_HOT) != 0 )
        {
            _mark::DrawSelectMark(dc, CRect(CPoint(0, 0), sz), false);
        }
        else if ( (itemState & CDIS_SELECTED) != 0 )
        {
            _mark::DrawSelectMark(dc, CRect(CPoint(0, 0), sz), true);
        }
    }
 
    struct TParam
    {
        size_t          width;  
        IDrawable::Ptr  pDraw;  
        CString         text;   
    };
 
    HWND                    m_hWnd;             
    DWORD                   m_baseCookie;       
    CSimpleVectorT<TParam>  m_items;            
    CFontHandle             m_font;             
    CFontHandle             m_fontBold;             
    COLORREF                m_textColor;        
    COLORREF                m_textDisableColor; 
    int                     m_leftMargin;       
    bool                    m_isAllOwnerDraw;
    bool                    m_withSubMenu;
};
 
 
 
class CDrawingSubMenu : public CAbstractDrawingMenu
{
    DEFSUPER(CAbstractDrawingMenu);
public:
 
    CDrawingSubMenu(void) : m_pSubParameter(NULL)
    {
    }
 
    ~CDrawingSubMenu(void)
    {
        if ( m_pSubParameter != NULL )
        {
            delete m_pSubParameter;
            m_pSubParameter = NULL;
        }
    }
 
    CAbstractDrawingMenu& ReferSubParameter(void)
    {
        if ( m_pSubParameter == NULL )
        {
            m_pSubParameter = new CDrawingSubMenu;
        }
        return *m_pSubParameter;
    }
 
protected:
 
    void OnFoundSubMenu(HMENU hMenu, COwnerdrawMenuSupportProcedureHooker* pProc)
    {
        loop ( i, m_subs )
        {
            if ( m_subs[i]->m_hMenu == hMenu )
            {
                return;
            }
        }
        CDrawingSubMenu* P = new CDrawingSubMenu;
        if ( m_pSubParameter == NULL )
        {
            P->CopyParameter(*this);
        }
        else
        {
            P->CopyParameter(*m_pSubParameter);
        }
        if ( P->Attach(hMenu) )
        {
            P->Regist(pProc, true, true);
            m_subs.Add(P);
            return;
        }
        delete P;
    }
 
private:
    CPointerVectorT<CDrawingSubMenu>    m_subs;             
    CDrawingSubMenu*                    m_pSubParameter;    
};
 
 
 
class CDrawingMenu : public CDrawingSubMenu
{
    DEFSUPER(CDrawingSubMenu);
public:
 
    BOOL Attach(COwnerdrawMenuSupportProcedureHooker* pProc, HMENU hMenu, bool isAllOwnerDraw = false, bool withSubMenu = false)
    {
        if ( _super::Attach(hMenu) )
        {
            Regist(pProc, isAllOwnerDraw, withSubMenu);
            return TRUE;
        }
        return FALSE;
    }
 
    BOOL TrackPopupMenu(UINT nFlags, int x, int y, CWnd* pWnd = NULL, LPCRECT lpRect = 0)
    {
        pWnd->SetForegroundWindow();
        return ::TrackPopupMenu(m_hMenu, nFlags, x, y, 0, pWnd->GetSafeHwnd(), lpRect);
    }
 
    BOOL TrackPopupMenu(UINT nFlags = TPM_LEFTALIGN | TPM_RIGHTBUTTON)
    {
        POINT po;
        if ( ::GetCursorPos(&po) )
        {
            HWND hWnd = _super::GetParentHwnd();
            ::SetForegroundWindow(hWnd);
            return ::TrackPopupMenu(m_hMenu, nFlags, po.x, po.y, 0, hWnd, NULL);
        }
        return FALSE;
    }
 
private:
    BOOL LoadMenu(LPCTSTR lpszResourceName);
    BOOL LoadMenu(UINT nIDResource);
    BOOL LoadMenuIndirect(const void* lpMenuTemplate);
 
};
 
 
 
class CDrawingMenuBar : public CDrawingSubMenu
{
    DEFSUPER(CDrawingSubMenu);
public:
 
    BOOL Attach(COwnerdrawMenuSupportProcedureHooker* pProc, bool withSubMenu = false)
    {
        HWND hWnd = pProc->GetSafeHwnd();
        HMENU hMenu = ::GetMenu(hWnd);
        if ( _super::Attach(hMenu) )
        {
            Regist(pProc, true, withSubMenu);
            return TRUE;
        }
        return FALSE;
    }
 
    void Draw(HDC dc)
    {
        if ( IsValid() )
        {
            RECT rc;
            ::GetWindowRect(_super::GetParentHwnd(), &rc);
            MENUBARINFO mbi = { sizeof(MENUBARINFO) };          // WINVER が 0x0501 じゃないとエラーになる
            MENUITEMINFO mif = { sizeof(MENUITEMINFO), MIIM_TYPE | MIIM_DATA };
            TCHAR tempBuf[16];
            mif.cch = 10;
            mif.dwTypeData = tempBuf;
            loop ( i, _super::GetMenuItemCount() )
            {
                if ( ::GetMenuBarInfo(_super::GetParentHwnd(), OBJID_MENU, down_cast<LONG>(i + 1), &mbi) )
                {
                    UINT st = ::GetMenuState(mbi.hMenu, down_cast<UINT>(i), MF_BYPOSITION);
                    DRAWITEMSTRUCT dis = { 0 };
                    dis.CtlType = ODT_MENU;
                    dis.rcItem = mbi.rcBar;
                    ::OffsetRect(&dis.rcItem, -rc.left, -rc.top);
                    if ( _super::GetMenuItemInfo(down_cast<UINT>(i), &mif, TRUE) )
                    {
                        if ( (mif.fType & MFT_OWNERDRAW) != 0 )
                        {
                            dis.itemData = mif.dwItemData;
                        }
                    }
                    dis.hDC = dc;
                    if ( (st & MF_DISABLED) != 0 )
                    {
                        dis.itemState |= CDIS_DISABLED;
                    }
                    if ( (st & MF_GRAYED) != 0 )
                    {
                        dis.itemState |= CDIS_GRAYED;
                    }
                    if ( (st & MF_HILITE) != 0 )
                    {
                        dis.itemState |= CDIS_SELECTED;
                    }
                    DrawItem(&dis);
                }
            }
        }
    }
 
    void Draw(void)
    {
        HWND hWnd = _super::GetParentHwnd();
        HDC dc = ::GetWindowDC(hWnd);
        Draw(dc);
        ::ReleaseDC(hWnd, dc);
    }
};
 
 
 
class CDrawingLoadMenu : public CDrawingMenu
{
    DEFSUPER(CDrawingMenu);
public:
 
    CDrawingLoadMenu(void)
    {
    }
 
    BOOL LoadMenu(COwnerdrawMenuSupportProcedureHooker* pProc, UINT nIDResource, int pos = -1, bool isAllOwnerDraw = false, bool withSubMenu = false)
    {
        m_topMenu.DestroyMenu();
        if ( m_topMenu.LoadMenu(nIDResource) )
        {
            CMenu* pMenu = &m_topMenu;
            if ( pos >= 0 )
            {
                pMenu = m_topMenu.GetSubMenu(pos);
            }
            if ( pMenu != NULL )
            {
                return _super::Attach(pProc, pMenu->GetSafeHmenu(), isAllOwnerDraw, withSubMenu);
            }
        }
        return FALSE;
    }
 
private:
    CMenu m_topMenu;
};
 
 
 
}; // MFC
}; // TNB