root / trunk / win / Bmpmenu.cpp

// BMPMenu.cpp : implementation file
//
// Based on Brent Corkum's BCMenu 2.3 class from 
// http://www.rocscience.com/~corkum/BCMenu.html
//

#include "lc_global.h"
#include "BMPMenu.h"
#include <afxpriv.h> // makes A2W and other spiffy AFX macros work
#include "resource.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define GAP 1
#ifndef OBM_CHECK
#define OBM_CHECK 32760 // from winuser.h
#endif

static CPINFO CPInfo;

typedef enum Win32Type {
    Win32s,
    Windoze95,
    WinNT3,
    WinNT4orHigher
};

static Win32Type IsShellType()
{
    Win32Type ShellType;
    DWORD winVer;
    OSVERSIONINFO *osvi;
    
    winVer = GetVersion();
    if(winVer < 0x80000000)
    {
        ShellType=WinNT3;
        osvi = (OSVERSIONINFO*)malloc(sizeof(OSVERSIONINFO));
        if (osvi != NULL)
        {
            memset(osvi, 0, sizeof(OSVERSIONINFO));
            osvi->dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
            GetVersionEx(osvi);
            if (osvi->dwMajorVersion >= 4L)
                ShellType = WinNT4orHigher; //yup, it is NT 4 or higher!
            free(osvi);
        }
    }
    else if (LOBYTE(LOWORD(winVer)) < 4)
        ShellType=Win32s;
    else
        ShellType=Windoze95;
    return ShellType;
}

static Win32Type g_Shell = IsShellType();

void CBMPMenuData::SetAnsiString(LPCSTR szAnsiString)
{
    ASSERT(szAnsiString);
    USES_CONVERSION;
    SetWideString(A2W(szAnsiString)); // see MFC Tech Note 059
}

// Returns the menu text in ANSI or UNICODE
CString CBMPMenuData::GetString(void)
{
    CString strText;
    if (m_szMenuText)
    {
#ifdef UNICODE
        strText = m_szMenuText;
#else
        USES_CONVERSION;
        strText=W2A(m_szMenuText); // see MFC Tech Note 059
#endif    
    }
    return strText;
}

/////////////////////////////////////////////////////////////////////////////
// CBMPMenu construction/destruction

CBMPMenu::CBMPMenu()
{
    disable_old_style=FALSE;
    m_iconX = 16; // Icon sizes default to 16 x 16
    m_iconY = 15;
    m_selectcheck = -1;
    m_unselectcheck = -1;
    checkmaps=NULL;
    checkmapsshare=FALSE;
    // set the color used for the transparent background in all bitmaps
    m_bitmapBackground = RGB(192,192,192); //gray
    m_bitmapBackgroundFlag=FALSE;
    GetCPInfo(CP_ACP,&CPInfo);
    if (!m_List.m_hImageList)
        m_List.Create (IDB_VIEWPORTS, 41, 0, RGB (192,192,192));
}

CBMPMenu::~CBMPMenu()
{
    DestroyMenu();
}

BOOL CBMPMenu::IsNewShell ()
{
    return (Windoze95==g_Shell || WinNT4orHigher==g_Shell);
}


CBMPMenuData::~CBMPMenuData()
{
    if(bitmap)
        delete(bitmap);

    delete[] m_szMenuText; // Need not check for NULL because ANSI X3J16 allows "delete NULL"
}

void CBMPMenuData::SetWideString(const wchar_t *szWideString)
{
    delete[] m_szMenuText; // Need not check for NULL because ANSI X3J16 allows "delete NULL"
    
    if (szWideString)
    {
        m_szMenuText = new wchar_t[sizeof(wchar_t)*(wcslen(szWideString)+1)];
        if (m_szMenuText)
            wcscpy(m_szMenuText,szWideString);
    }
    else
        m_szMenuText = NULL;
}

BOOL CBMPMenu::IsMenu(CMenu *submenu)
{
    int m;
    
    int numSubMenus = m_SubMenus.GetUpperBound();
    for(m = 0; m <= numSubMenus; ++m)
        if(submenu == m_SubMenus[m])
            return TRUE;
    return FALSE;
}

BOOL CBMPMenu::DestroyMenu()
{
    int m;

    // Destroy Sub menus:
    int numSubMenus = m_SubMenus.GetUpperBound();
    for(m = numSubMenus; m >= 0; m--)
        delete m_SubMenus[m];
    m_SubMenus.RemoveAll();

    // Destroy menu data
    int numItems = m_MenuList.GetUpperBound();
    for(m = 0; m <= numItems; m++)
        delete m_MenuList[m];
    m_MenuList.RemoveAll();
    if(checkmaps && !checkmapsshare)
    {
        delete checkmaps;
        checkmaps=NULL;
    }

    return CMenu::DestroyMenu();
};


///////////////////////////////////////////////////////////////////////////
//
// CBMPMenu message handlers

// Called by the framework when a particular item needs to be drawn.
void CBMPMenu::DrawItem (LPDRAWITEMSTRUCT lpDIS)
{
    ASSERT(lpDIS != NULL);
    CDC* pDC = CDC::FromHandle(lpDIS->hDC);

    UINT u = ((CBMPMenuData*)(lpDIS->itemData))->nID;
    if (u >= ID_VIEWPORT01 && u <= ID_VIEWPORT14)
    {
        int left = lpDIS->rcItem.left;

        if (lpDIS->itemAction & ODA_DRAWENTIRE)
            m_List.Draw (pDC, u - ID_VIEWPORT01, CPoint (left+3,lpDIS->rcItem.top+1), ILD_NORMAL);

        if ((lpDIS->itemState & ODS_SELECTED) && (lpDIS->itemAction & (ODA_SELECT | ODA_DRAWENTIRE)))
            m_List.Draw (pDC, u - ID_VIEWPORT01, CPoint (left+3,lpDIS->rcItem.top+1), ILD_SELECTED);

        if (!(lpDIS->itemState & ODS_SELECTED) && (lpDIS->itemAction & ODA_SELECT))
            m_List.Draw (pDC, u - ID_VIEWPORT01, CPoint (left+3,lpDIS->rcItem.top+1), ILD_NORMAL);

        if (lpDIS->itemState & ODS_CHECKED) 
        {
            CBrush br(RGB(0,0,0));
            pDC->FrameRect(CRect (left+2,lpDIS->rcItem.top,left+41+4,lpDIS->rcItem.bottom), &br);
        }
        return;
    }

    CRect rect;
    UINT state = (((CBMPMenuData*)(lpDIS->itemData))->nFlags);
    if(state & MF_SEPARATOR)
    {
        rect.CopyRect(&lpDIS->rcItem);
        rect.top+=rect.Height()>>1;
        pDC->DrawEdge(&rect,EDGE_ETCHED,BF_TOP);
    }
    else
    {
        CRect rect2;
        BOOL standardflag=FALSE,selectedflag=FALSE,disableflag=FALSE;
        BOOL checkflag=FALSE;
        CBitmap bitmapstandard;
        COLORREF crText = GetSysColor(COLOR_MENUTEXT);
        COLORREF m_clrBack=GetSysColor(COLOR_MENU);
        CBrush m_brBackground,m_brSelect;
        CPen m_penBack;
        int x0,y0,dy;
        int nIconNormal=-1,xoffset=-1;
        CImageList *bitmap=NULL;
        CFont m_fontMenu;
        LOGFONT m_lf;
        
        // set some colors and the font
        m_penBack.CreatePen (PS_SOLID,0,GetSysColor(COLOR_MENU));
        m_brBackground.CreateSolidBrush(GetSysColor(COLOR_MENU));
        m_brSelect.CreateSolidBrush(GetSysColor(COLOR_HIGHLIGHT));
        ZeroMemory ((PVOID) &m_lf,sizeof (LOGFONT));
        NONCLIENTMETRICS nm;
        nm.cbSize = sizeof (NONCLIENTMETRICS);
        VERIFY (SystemParametersInfo(SPI_GETNONCLIENTMETRICS,nm.cbSize,&nm,0)); 
        m_lf =  nm.lfMenuFont;
        m_fontMenu.CreateFontIndirect (&m_lf);
        
        // draw the colored rectangle portion
        rect.CopyRect(&lpDIS->rcItem);
        rect2=rect;
        
        // draw the up/down/focused/disabled state
        UINT action = lpDIS->itemAction;
        UINT state = lpDIS->itemState;
        CString strText;
        LOGFONT lf;
        lf = m_lf;
        
        CFont dispFont;
        CFont *pFont;
        
        if(lpDIS->itemData != NULL)
        {
            nIconNormal = (((CBMPMenuData*)(lpDIS->itemData))->menuIconNormal);
            xoffset = (((CBMPMenuData*)(lpDIS->itemData))->xoffset);
            bitmap = (((CBMPMenuData*)(lpDIS->itemData))->bitmap);
            strText = ((CBMPMenuData*) (lpDIS->itemData))->GetString();
            
            if(state&ODS_CHECKED && nIconNormal<0)
            {
                if(state&ODS_SELECTED && m_selectcheck>0)checkflag=TRUE;
                else if(m_unselectcheck>0) checkflag=TRUE;
            }
            else if(nIconNormal != -1)
            {
                standardflag = TRUE;
                if(state & ODS_SELECTED && !(state & ODS_GRAYED))
                    selectedflag = TRUE;
                else if(state & ODS_GRAYED) 
                    disableflag = TRUE;
            }
        }
        else
            strText.Empty();
        
        if(state&ODS_SELECTED) // draw the down edges
        {
            CPen *pOldPen = pDC->SelectObject (&m_penBack);
            
            // You need only Text highlight and thats what you get
            if(checkflag||standardflag||selectedflag||disableflag||state&ODS_CHECKED)
                rect2.SetRect(rect.left+m_iconX+4+GAP,rect.top,rect.right,rect.bottom);
            pDC->FillRect (rect2,&m_brSelect);
            
            pDC->SelectObject (pOldPen);
            if((HFONT)dispFont != NULL)dispFont.DeleteObject ();
            dispFont.CreateFontIndirect (&lf);
            crText = GetSysColor(COLOR_HIGHLIGHTTEXT);
        }
        else 
        {
            CPen *pOldPen = pDC->SelectObject (&m_penBack);
            pDC->FillRect (rect,&m_brBackground);
            pDC->SelectObject (pOldPen);
            
            // draw the up edges
            pDC->Draw3dRect (rect,m_clrBack,m_clrBack);
            if ((HFONT)dispFont != NULL) dispFont.DeleteObject ();
            dispFont.CreateFontIndirect (&lf); //Normal
        }
        
        // draw the text if there is any
        // We have to paint the text only if the image is nonexistant
        dy = (rect.Height()-4-m_iconY)/2;
        dy = dy<0 ? 0 : dy;
        
        if(checkflag||standardflag||selectedflag||disableflag){
            rect2.SetRect(rect.left+1,rect.top+1+dy,rect.left+m_iconX+3,
                rect.top+m_iconY+3+dy);
            pDC->Draw3dRect (rect2,m_clrBack,m_clrBack);
            if(checkflag && checkmaps){
                pDC->FillRect (rect2,&m_brBackground);
                rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
                    rect.top+m_iconY+4+dy);
                
                pDC->Draw3dRect (rect2,m_clrBack,m_clrBack);
                CPoint ptImage(rect.left+2,rect.top+2+dy);
                
                if(state&ODS_SELECTED)checkmaps->Draw(pDC,1,ptImage,ILD_TRANSPARENT);
                else checkmaps->Draw(pDC,0,ptImage,ILD_TRANSPARENT);
            }
            else if(disableflag){
                if(!selectedflag){
                    HBITMAP hbmp=LoadSysColorBitmap(nIconNormal);
                    if(hbmp){
                        bitmapstandard.Attach(hbmp);
                        rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
                            rect.top+m_iconY+4+dy);
                        pDC->Draw3dRect (rect2,m_clrBack,m_clrBack);
                        if(disable_old_style)
                            DitherBlt(lpDIS->hDC,rect.left+2,rect.top+2+dy,m_iconX,m_iconY,
                            (HBITMAP)(bitmapstandard),xoffset*m_iconX,0);
                        else
                            DitherBlt2(pDC,rect.left+2,rect.top+2+dy,m_iconX,m_iconY,
                            bitmapstandard,xoffset*m_iconX,0);
                        bitmapstandard.DeleteObject();
                    }
                }
            }
            else if(selectedflag){
                pDC->FillRect (rect2,&m_brBackground);
                rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
                    rect.top+m_iconY+4+dy);
                if (IsNewShell()){
                    if(state&ODS_CHECKED)
                        pDC->Draw3dRect(rect2,GetSysColor(COLOR_3DSHADOW),
                        GetSysColor(COLOR_3DHILIGHT));
                    else
                        pDC->Draw3dRect(rect2,GetSysColor(COLOR_3DHILIGHT),
                        GetSysColor(COLOR_3DSHADOW));
                }
                CPoint ptImage(rect.left+2,rect.top+2+dy);
                if(bitmap)bitmap->Draw(pDC,xoffset,ptImage,ILD_TRANSPARENT);
            }
            else{
                if(state&ODS_CHECKED){
                    CBrush brush;
                    COLORREF col =GetSysColor(COLOR_3DLIGHT);
                    brush.CreateSolidBrush(col);
                    pDC->FillRect(rect2,&brush);
                    brush.DeleteObject();
                    rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
                        rect.top+m_iconY+4+dy);
                    if (IsNewShell())
                        pDC->Draw3dRect(rect2,GetSysColor(COLOR_3DSHADOW),
                        GetSysColor(COLOR_3DHILIGHT));
                }
                else{
                    pDC->FillRect (rect2,&m_brBackground);
                    rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
                        rect.top+m_iconY+4+dy);
                    pDC->Draw3dRect (rect2,m_clrBack,m_clrBack);
                }
                CPoint ptImage(rect.left+2,rect.top+2+dy);
                if(bitmap)bitmap->Draw(pDC,xoffset,ptImage,ILD_TRANSPARENT);
            }
        }
        if(nIconNormal<0 && state&ODS_CHECKED && !checkflag){
            rect2.SetRect(rect.left+1,rect.top+2+dy,rect.left+m_iconX+1,
                rect.top+m_iconY+2+dy);
            CMenuItemInfo info;
            info.fMask = MIIM_CHECKMARKS;
      ::GetMenuItemInfo((HMENU)lpDIS->hwndItem,lpDIS->itemID,
                MF_BYCOMMAND, &info);
            if(state&ODS_CHECKED || info.hbmpUnchecked) {
                Draw3DCheckmark(pDC, rect2, state&ODS_SELECTED,
                    state&ODS_CHECKED ? info.hbmpChecked :
                info.hbmpUnchecked);
            }
        }
        
        // This is needed always so that we can have the space for check marks
        x0 = rect.left; y0 = rect.top;
        rect.left = rect.left + m_iconX + 8 + GAP; 
        
        if(!strText.IsEmpty())
        {
            CRect rectt(rect.left,rect.top-1,rect.right,rect.bottom-1);
            
            // Find tabs
            CString leftStr,rightStr;
            leftStr.Empty();rightStr.Empty();
            int tablocr=strText.ReverseFind(_T('\t'));
            if(tablocr!=-1)
            {
                rightStr=strText.Mid(tablocr+1);
                leftStr=strText.Left(strText.Find(_T('\t')));
                rectt.right-=m_iconX;
            }
            else leftStr=strText;
            
            int iOldMode = pDC->GetBkMode();
            pDC->SetBkMode( TRANSPARENT);
            
            // Draw the text in the correct colour:
            UINT nFormat  = DT_LEFT|DT_SINGLELINE|DT_VCENTER;
            UINT nFormatr = DT_RIGHT|DT_SINGLELINE|DT_VCENTER;
            if(!(lpDIS->itemState & ODS_GRAYED))
            {
                pDC->SetTextColor(crText);
                pDC->DrawText (leftStr,rectt,nFormat);
                if(tablocr!=-1) pDC->DrawText (rightStr,rectt,nFormatr);
            }
            else
            {
                // Draw the disabled text
                if(!(state & ODS_SELECTED))
                {
                    RECT offset = *rectt;
                    offset.left+=1;
                    offset.right+=1;
                    offset.top+=1;
                    offset.bottom+=1;
                    pDC->SetTextColor(GetSysColor(COLOR_BTNHILIGHT));
                    pDC->DrawText(leftStr,&offset, nFormat);
                    if(tablocr!=-1) pDC->DrawText (rightStr,&offset,nFormatr);
                    pDC->SetTextColor(GetSysColor(COLOR_GRAYTEXT));
                    pDC->DrawText(leftStr,rectt, nFormat);
                    if(tablocr!=-1) pDC->DrawText (rightStr,rectt,nFormatr);
                }
                else
                {
                    // And the standard Grey text:
                    pDC->SetTextColor(m_clrBack);
                    pDC->DrawText(leftStr,rectt, nFormat);
                    if(tablocr!=-1) pDC->DrawText (rightStr,rectt,nFormatr);
                }
            }
            pFont = pDC->SelectObject (&dispFont);
            pDC->SetBkMode( iOldMode );
            pDC->SelectObject (pFont); //set it to the old font
        }
        
        m_penBack.DeleteObject();
        m_brBackground.DeleteObject();
        m_fontMenu.DeleteObject();
        m_brSelect.DeleteObject();
        dispFont.DeleteObject ();
    }
}

// Called by the framework when it wants to know what the width and height
// of our item will be.  To accomplish this we provide the width of the
// icon plus the width of the menu text, and then the height of the icon.
void CBMPMenu::MeasureItem(LPMEASUREITEMSTRUCT lpMIS)
{
    if (lpMIS->itemID >= ID_VIEWPORT01 && lpMIS->itemID <= ID_VIEWPORT14)
    {
        lpMIS->itemWidth = 41 + 8 - GetSystemMetrics(SM_CXMENUCHECK);
        lpMIS->itemHeight = 33;
        return;
    }

    UINT state = (((CBMPMenuData*)(lpMIS->itemData))->nFlags);
    if(state & MF_SEPARATOR){
        lpMIS->itemWidth = 0;
        lpMIS->itemHeight = GetSystemMetrics(SM_CYMENU)>>1;
    }
    else{
        CFont m_fontMenu;
        LOGFONT m_lf;
        ZeroMemory ((PVOID) &m_lf,sizeof (LOGFONT));
        NONCLIENTMETRICS nm;
        nm.cbSize = sizeof (NONCLIENTMETRICS);
        VERIFY(SystemParametersInfo(SPI_GETNONCLIENTMETRICS,
            nm.cbSize,&nm,0)); 
        m_lf =  nm.lfMenuFont;
        m_fontMenu.CreateFontIndirect (&m_lf);
        
        // Obtain the width of the text:
        CWnd *pWnd = AfxGetMainWnd();            // Get main window
        CDC *pDC = pWnd->GetDC();              // Get device context
        CFont* pFont;    // Select menu font in...
        
        if (IsNewShell())
            pFont = pDC->SelectObject (&m_fontMenu);// Select menu font in...
        
        //Get pointer to text SK
        const wchar_t *lpstrText = ((CBMPMenuData*)(lpMIS->itemData))->GetWideString();//SK: we use const to prevent misuse
        
        
        SIZE size;
        
        if (Win32s!=g_Shell)
            VERIFY(::GetTextExtentPoint32W(pDC->m_hDC,lpstrText,
            wcslen(lpstrText),&size)); //SK should also work on 95
#ifndef UNICODE //can't be UNICODE for Win32s
        else{//it's Win32suckx
            RECT rect;
            rect.left=rect.top=0;
            size.cy=DrawText(pDC->m_hDC,(LPCTSTR)lpstrText,
                wcslen(lpstrText),&rect,
                DT_SINGLELINE|DT_LEFT|DT_VCENTER|DT_CALCRECT);
            //+3 makes at least three pixels space to the menu border
            size.cx=rect.right-rect.left+3;
            size.cx += 3*(size.cx/wcslen(lpstrText));
        }
#endif    
        
        CSize t = CSize(size);
        if(IsNewShell())
            pDC->SelectObject (pFont);  // Select old font in
        AfxGetMainWnd()->ReleaseDC(pDC);  // Release the DC
        
        // Set width and height:
        
        lpMIS->itemWidth = m_iconX + t.cx + m_iconX + GAP;
        int temp = GetSystemMetrics(SM_CYMENU);
        lpMIS->itemHeight = temp>m_iconY+4 ? temp : m_iconY+4;
        m_fontMenu.DeleteObject();
    }
}

void CBMPMenu::SetIconSize (int width, int height)
{
    m_iconX = width;
    m_iconY = height;
}

BOOL CBMPMenu::AppendODMenuA(LPCSTR lpstrText,UINT nFlags,UINT nID, int nIconNormal)
{
    ASSERT(lpstrText);
    USES_CONVERSION;
    return AppendODMenuW(A2W(lpstrText),nFlags,nID,nIconNormal);//SK: See MFC Tech Note 059
}

BOOL CBMPMenu::AppendODMenuW(wchar_t *lpstrText,UINT nFlags,UINT nID, int nIconNormal)
{
    // Add the MF_OWNERDRAW flag if not specified:
    ASSERT(lpstrText);
    if(!nID)nFlags=MF_SEPARATOR|MF_OWNERDRAW;
    else if(!(nFlags & MF_OWNERDRAW))nFlags |= MF_OWNERDRAW;
    
    CBMPMenuData *mdata = new CBMPMenuData;
    m_MenuList.Add(mdata);
    mdata->SetWideString(lpstrText);    //SK: modified for dynamic allocation
    
    mdata->menuIconNormal = nIconNormal;
    mdata->xoffset=-1;
    if(nIconNormal>=0){
        mdata->xoffset=0;
        LoadFromToolBar(nID,nIconNormal,mdata->xoffset);
        if(mdata->bitmap)mdata->bitmap->DeleteImageList();
        else mdata->bitmap=new(CImageList);
        mdata->bitmap->Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
        AddBitmapToImageList(mdata->bitmap,nIconNormal);
    }
    mdata->nFlags = nFlags;
    mdata->nID = nID;
    return(CMenu::AppendMenu(nFlags, nID, (LPCTSTR)mdata));
}

BOOL CBMPMenu::ModifyODMenuA(const char * lpstrText,UINT nID,int nIconNormal)
{
    USES_CONVERSION;
    return ModifyODMenuW(A2W(lpstrText),nID,nIconNormal);//SK: see MFC Tech Note 059
}

BOOL CBMPMenu::ModifyODMenuW(wchar_t *lpstrText,UINT nID,int nIconNormal)
{
    int nLoc;
    CBMPMenuData *mdata;
    
    // Find the old CBMPMenuData structure:
    CBMPMenu *psubmenu = FindMenuOption(nID,nLoc);
    if(psubmenu && nLoc>=0)mdata = psubmenu->m_MenuList[nLoc];
    else{
        // Create a new CBMPMenuData structure:
        mdata = new CBMPMenuData;
        m_MenuList.Add(mdata);
    }
    ASSERT(mdata);
    if(lpstrText)
        mdata->SetWideString(lpstrText);  //SK: modified for dynamic allocation
    mdata->menuIconNormal = nIconNormal;
    mdata->xoffset=-1;
    if(nIconNormal>=0){
        mdata->xoffset=0;
        LoadFromToolBar(nID,nIconNormal,mdata->xoffset);
        if(mdata->bitmap)mdata->bitmap->DeleteImageList();
        else mdata->bitmap=new(CImageList);
        mdata->bitmap->Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
        AddBitmapToImageList(mdata->bitmap,nIconNormal);
    }
    mdata->nFlags = MF_BYCOMMAND | MF_OWNERDRAW;
    mdata->nID = nID;
    return (CMenu::ModifyMenu(nID,mdata->nFlags,nID,(LPCTSTR)mdata));
}

BOOL CBMPMenu::ModifyODMenuA(const char *lpstrText,const char *OptionText, int nIconNormal)
{
    USES_CONVERSION;
    return ModifyODMenuW(A2W(lpstrText),A2W(OptionText),nIconNormal);//SK: see MFC  Tech Note 059
}


BOOL CBMPMenu::ModifyODMenuW(wchar_t *lpstrText,wchar_t *OptionText, int nIconNormal)
{
    CBMPMenuData *mdata;
    
    // Find the old CBMPMenuData structure:
    mdata=FindMenuOption(OptionText);
    if(mdata){
        if(lpstrText)
            mdata->SetWideString(lpstrText);//SK: modified for dynamic allocation
        mdata->menuIconNormal = nIconNormal;
        mdata->xoffset=-1;
        if(nIconNormal>=0)
        {
            mdata->xoffset=0;
            if(mdata->bitmap)mdata->bitmap->DeleteImageList();
            else mdata->bitmap=new(CImageList);
            mdata->bitmap->Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
            AddBitmapToImageList(mdata->bitmap,nIconNormal);
        }
        return(TRUE);
    }
    return(FALSE);
}

CBMPMenuData *CBMPMenu::NewODMenu(UINT pos,UINT nFlags,UINT nID,CString string)
{
    CBMPMenuData *mdata;
    
    mdata = new CBMPMenuData;
    mdata->menuIconNormal = -1;
    mdata->xoffset=-1;
#ifdef UNICODE
    mdata->SetWideString((LPCTSTR)string);//SK: modified for dynamic allocation
#else
    mdata->SetAnsiString(string);
#endif
    mdata->nFlags = nFlags;
    mdata->nID = nID;
    
    
    if (nFlags & MF_OWNERDRAW)
    {
        ASSERT(!(nFlags&MF_STRING));
        ModifyMenu(pos,nFlags,nID,(LPCTSTR)mdata);
    }
    else if (nFlags & MF_STRING)
    {
        ASSERT(!(nFlags&MF_OWNERDRAW));
        ModifyMenu(pos,nFlags,nID,mdata->GetString());
    }
    else{
        ASSERT(nFlags & MF_SEPARATOR);
        ModifyMenu(pos,nFlags,nID);
    }
    
    return(mdata);
};

BOOL CBMPMenu::LoadToolbars(const UINT *arID,int n)
{
    ASSERT(arID);
    BOOL bRet=TRUE;
    for(int i=0;i<n;++i)
        bRet |= LoadToolbar(arID[i]);
    return(bRet);
}

BOOL CBMPMenu::LoadToolbar(UINT nToolBar)
{
    UINT nID;
    BOOL returnflag=FALSE;
    CToolBar bar;
    
    bar.Create(AfxGetMainWnd());
    if(bar.LoadToolBar(nToolBar)){
        for(int i=0;i<bar.GetCount();++i){
            nID = bar.GetItemID(i); 
            if(nID && GetMenuState(nID, MF_BYCOMMAND)
                !=0xFFFFFFFF)ModifyODMenu(NULL,nID,nToolBar);
        }
        returnflag=TRUE;
    }
    return(returnflag);
}

BOOL CBMPMenu::LoadFromToolBar(UINT nID,UINT nToolBar,int& xoffset)
{
    int xset,offset;
    UINT nStyle;
    BOOL returnflag=FALSE;
    CToolBar bar;
    
    CWnd* pWnd = AfxGetMainWnd();
    if (pWnd == NULL)pWnd = CWnd::GetDesktopWindow();
    bar.Create(pWnd);
    if(bar.LoadToolBar(nToolBar)){
        offset=bar.CommandToIndex(nID);
        if(offset>=0){
            bar.GetButtonInfo(offset,nID,nStyle,xset);
            if(xset>0)xoffset=xset;
            returnflag=TRUE;
        }
    }
    return(returnflag);
}

CBMPMenu *CBMPMenu::FindMenuOption(int nId,int& nLoc)
{
    int i;
    CBMPMenu *psubmenu,*pgoodmenu;
    
    for(i=0;i<(int)(GetMenuItemCount());++i){
#ifdef _CPPRTTI 
        psubmenu=dynamic_cast<CBMPMenu *>(GetSubMenu(i));
#else
        psubmenu=(CBMPMenu *)GetSubMenu(i);
#endif
        if(psubmenu){
            pgoodmenu=psubmenu->FindMenuOption(nId,nLoc);
            if(pgoodmenu)return(pgoodmenu);
        }
        else if(nId==(int)GetMenuItemID(i)){
            nLoc=i;
            return(this);
        }
    }
    nLoc = -1;
    return(NULL);
}

CBMPMenuData *CBMPMenu::FindMenuOption(wchar_t *lpstrText)
{
    int i;
    CBMPMenu *psubmenu;
    CBMPMenuData *pmenulist;
    
    for(i=0;i<(int)(GetMenuItemCount());++i){
#ifdef _CPPRTTI 
        psubmenu=dynamic_cast<CBMPMenu *>(GetSubMenu(i));
#else
        psubmenu=(CBMPMenu *)GetSubMenu(i);
#endif
        if(psubmenu){
            pmenulist=psubmenu->FindMenuOption(lpstrText);
            if(pmenulist)return(pmenulist);
        }
        else{
            const wchar_t *szWide;//SK: we use const to prevent misuse of this Ptr
            for(i=0;i<=m_MenuList.GetUpperBound();++i){     
                szWide = m_MenuList[i]->GetWideString ();
                if(szWide && !wcscmp(lpstrText,szWide))//SK: modified for dynamic allocation
                    return(m_MenuList[i]);
            }
        }
    }
    return(NULL);
}


BOOL CBMPMenu::LoadMenu(int nResource)
{
    return(CBMPMenu::LoadMenu(MAKEINTRESOURCE(nResource)));
}

BOOL CBMPMenu::LoadMenu(LPCTSTR lpszResourceName)
{
    TRACE(_T(
        "IMPORTANT:Use CBMPMenu::DestroyMenu to destroy Loaded Menu's\n"));
    ASSERT_VALID(this);
    ASSERT(lpszResourceName != NULL);
    
    // Find the Menu Resource:
    HINSTANCE m_hInst = AfxFindResourceHandle(lpszResourceName,RT_MENU);
    HRSRC hRsrc = ::FindResource(m_hInst,lpszResourceName,RT_MENU);
    if(hRsrc == NULL)return FALSE;
    
    // Get size of resource:
    
    DWORD dwSize = SizeofResource(NULL, hRsrc);
    
    // Load the Menu Resource:
    
    HGLOBAL hGlobal = LoadResource(m_hInst, hRsrc);
    if(hGlobal == NULL)return FALSE;
    
    // Attempt to create us as a menu...
    
    if(!CMenu::CreateMenu())return FALSE;
    
    // Get Item template Header, and calculate offset of MENUITEMTEMPLATES
    
    MENUITEMTEMPLATEHEADER *pTpHdr=
        (MENUITEMTEMPLATEHEADER*)LockResource(hGlobal);
    BYTE* pTp=(BYTE*)pTpHdr + 
        (sizeof(MENUITEMTEMPLATEHEADER) + pTpHdr->offset);
    
    
    // Variables needed during processing of Menu Item Templates:
    
    int j=0;
    CBMPMenuData*  pData = NULL;              // New OD Menu Item Data
    WORD    dwFlags = 0;              // Flags of the Menu Item
    WORD    dwID  = 0;              // ID of the Menu Item
    UINT    uFlags;                  // Actual Flags.
    wchar_t *szCaption=NULL;
    int      nLen   = 0;                // Length of caption
    CTypedPtrArray<CPtrArray, CBMPMenu*>  m_Stack;    // Popup menu stack
    CArray<BOOL,BOOL>  m_StackEnd;    // Popup menu stack
    m_Stack.Add(this);                  // Add it to this...
    m_StackEnd.Add(FALSE);
    
    do{
        // Obtain Flags and (if necessary), the ID...
        memcpy(&dwFlags, pTp, sizeof(WORD));pTp+=sizeof(WORD);// Obtain Flags
        if(!(dwFlags & MF_POPUP)){
            memcpy(&dwID, pTp, sizeof(WORD)); // Obtain ID
            pTp+=sizeof(WORD);
        }
        else dwID = 0;
        
        uFlags = (UINT)dwFlags; // Remove MF_END from the flags that will
        if(uFlags & MF_END) // be passed to the Append(OD)Menu functions.
            uFlags -= MF_END;
        
        // Obtain Caption (and length)
        
        nLen = 0;
        char *ch = (char*)pTp;
        szCaption=new wchar_t[wcslen((wchar_t *)pTp)+1];
        wcscpy(szCaption,(wchar_t *)pTp);
        pTp=&pTp[(wcslen((wchar_t *)pTp)+1)*sizeof(wchar_t)];//modified SK
        
        // Handle popup menus first....
        
        //WideCharToMultiByte
        if(dwFlags & MF_POPUP){
            if(dwFlags & MF_END)m_StackEnd.SetAt(m_Stack.GetUpperBound(),TRUE);
            CBMPMenu* pSubMenu = new CBMPMenu;
            pSubMenu->m_unselectcheck=m_unselectcheck;
            pSubMenu->m_selectcheck=m_selectcheck;
            pSubMenu->checkmaps=checkmaps;
            pSubMenu->checkmapsshare=TRUE;
            pSubMenu->CreatePopupMenu();
            
            // Append it to the top of the stack:
            
            m_Stack[m_Stack.GetUpperBound()]->AppendODMenuW(szCaption,uFlags,
                (UINT)pSubMenu->m_hMenu, -1);
            m_Stack.Add(pSubMenu);
            m_StackEnd.Add(FALSE);
            m_SubMenus.Add(pSubMenu);
        }
        else {
            m_Stack[m_Stack.GetUpperBound()]->AppendODMenuW(szCaption, uFlags,
                dwID, -1);
            if(dwFlags & MF_END)m_StackEnd.SetAt(m_Stack.GetUpperBound(),TRUE);
            j = m_Stack.GetUpperBound();
            while(j>=0 && m_StackEnd.GetAt(j)){
                m_Stack[m_Stack.GetUpperBound()]->InsertSpaces();
                m_Stack.RemoveAt(j);
                m_StackEnd.RemoveAt(j);
                --j;
            }
        }
        
        delete[] szCaption;
    }while(m_Stack.GetUpperBound() != -1);
    
    for(int i=0;i<(int)GetMenuItemCount();++i){
        CString str=m_MenuList[i]->GetString();
        
        if(GetSubMenu(i)){
            m_MenuList[i]->nFlags=MF_POPUP|MF_BYPOSITION;
            ModifyMenu(i,MF_POPUP|MF_BYPOSITION,
                (UINT)GetSubMenu(i)->m_hMenu,str);
        }
        else{
            m_MenuList[i]->nFlags=MF_STRING|MF_BYPOSITION;
            ModifyMenu(i,MF_STRING|MF_BYPOSITION,m_MenuList[i]->nID,str);
        }
    }
    
    return(TRUE);
}

void CBMPMenu::InsertSpaces(void)
{
    int i,j,numitems,maxlength;
    CString string,newstring;
    CSize t;
    CFont m_fontMenu;
    LOGFONT m_lf;
    
    ZeroMemory ((PVOID) &m_lf,sizeof (LOGFONT));
    NONCLIENTMETRICS nm;
    nm.cbSize = sizeof (NONCLIENTMETRICS);
    VERIFY (SystemParametersInfo (SPI_GETNONCLIENTMETRICS,nm.cbSize,&nm,0)); 
    m_lf =  nm.lfMenuFont;
    m_fontMenu.CreateFontIndirect (&m_lf);
    
    CWnd *pWnd = AfxGetMainWnd();  
    if (pWnd == NULL)pWnd = CWnd::GetDesktopWindow();
    CDC *pDC = pWnd->GetDC();
    CFont* pFont = pDC->SelectObject (&m_fontMenu);
    
    numitems=GetMenuItemCount();
    maxlength = -1;
    for(i=0;i<numitems;++i){
        string=m_MenuList[i]->GetString();
        j=string.Find((char)9);
        newstring.Empty();
        if(j!=-1)newstring.Left(j);
        else newstring=string;
        newstring+=_T(" ");//SK: modified for Unicode correctness. 
        LPCTSTR lpstrText = (LPCTSTR)newstring;
        t=pDC->GetTextExtent(lpstrText,_tcslen(lpstrText));
        if(t.cx>maxlength)maxlength = t.cx;
    }
    for(i=0;i<numitems;++i){
        string=m_MenuList[i]->GetString();
        
        j=string.Find((char)9);
        if(j!=-1){
            newstring.Empty();
            newstring=string.Left(j);
            LPCTSTR lpstrText = (LPCTSTR)(newstring);
            t=pDC->GetTextExtent(lpstrText,_tcslen(lpstrText));
            while(t.cx<maxlength){
                newstring+=_T(' ');//SK: modified for Unicode correctness
                LPCTSTR lpstrText = (LPCTSTR)(newstring);
                t=pDC->GetTextExtent(lpstrText,_tcslen(lpstrText));
            }
            newstring+=string.Mid(j);
#ifdef UNICODE      
            m_MenuList[i]->SetWideString(newstring);//SK: modified for dynamic allocation
#else
            m_MenuList[i]->SetAnsiString(newstring);
#endif
        }
    }
    pDC->SelectObject (pFont);              // Select old font in
    pWnd->ReleaseDC(pDC);       // Release the DC
    m_fontMenu.DeleteObject();
}

void CBMPMenu::LoadCheckmarkBitmap(int unselect, int select)
{
    if(unselect>=0 && select>=0){
        m_selectcheck=select;
        m_unselectcheck=unselect;
        if(checkmaps)checkmaps->DeleteImageList();
        else checkmaps=new(CImageList);
        checkmaps->Create(m_iconX,m_iconY,TRUE,2,1);
        AddBitmapToImageList(checkmaps,unselect);
        AddBitmapToImageList(checkmaps,select);
    }
}

BOOL CBMPMenu::GetMenuText(UINT id, CString& string)
{
    BOOL returnflag=FALSE;
    
    UINT numMenuItems = m_MenuList.GetUpperBound();
    if(id<=numMenuItems){
        string=m_MenuList[id]->GetString();
        returnflag=TRUE;
    }
    return(returnflag);
}

void CBMPMenu::DrawRadioDot(CDC *pDC,int x,int y,COLORREF color)
{
    CRect rcDot(x,y,x+6,y+6);
    CBrush brush;
    CPen pen;
    brush.CreateSolidBrush(color);
    pen.CreatePen(PS_SOLID,0,color);
    pDC->SelectObject(&brush);
    pDC->SelectObject(&pen);
    pDC->Ellipse(&rcDot);
    pen.DeleteObject();
    brush.DeleteObject();
}

void CBMPMenu::DrawCheckMark(CDC* pDC,int x,int y,COLORREF color)
{
    pDC->SetPixel(x,y+2,color);
    pDC->SetPixel(x,y+3,color);
    pDC->SetPixel(x,y+4,color);
    
    pDC->SetPixel(x+1,y+3,color);
    pDC->SetPixel(x+1,y+4,color);
    pDC->SetPixel(x+1,y+5,color);
    
    pDC->SetPixel(x+2,y+4,color);
    pDC->SetPixel(x+2,y+5,color);
    pDC->SetPixel(x+2,y+6,color);
    
    pDC->SetPixel(x+3,y+3,color);
    pDC->SetPixel(x+3,y+4,color);
    pDC->SetPixel(x+3,y+5,color);
    
    pDC->SetPixel(x+4,y+2,color);
    pDC->SetPixel(x+4,y+3,color);
    pDC->SetPixel(x+4,y+4,color);
    
    pDC->SetPixel(x+5,y+1,color);
    pDC->SetPixel(x+5,y+2,color);
    pDC->SetPixel(x+5,y+3,color);
    
    pDC->SetPixel(x+6,y,color);
    pDC->SetPixel(x+6,y+1,color);
    pDC->SetPixel(x+6,y+2,color);
}

CBMPMenuData *CBMPMenu::FindMenuList(UINT nID)
{
    for(int i=0;i<=m_MenuList.GetUpperBound();++i){
        if(m_MenuList[i]->nID==nID && !m_MenuList[i]->syncflag){
            m_MenuList[i]->syncflag=1;
            return(m_MenuList[i]);
        }
    }
    return(NULL);
}

void CBMPMenu::InitializeMenuList(int value)
{
    for(int i=0;i<=m_MenuList.GetUpperBound();++i)
        m_MenuList[i]->syncflag=value;
}

void CBMPMenu::DeleteMenuList(void)
{
    for(int i = 0;i <= m_MenuList.GetUpperBound(); ++i)
        if(!m_MenuList[i]->sy