mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/cmd/winfe/quickfil.cpp

917 строки
22 KiB
C++
Executable File
Исходник Ответственный История

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
// This file contains the implementations of the various Bookmark Quick
// File classes.
/** INCLUDE **/
#include "stdafx.h"
#include "cxicon.h"
#include "quickfil.h"
#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif
typedef struct {
UINT nCommand;
int nPosition;
} MnemonicStruct;
/****************************************************************************
*
* Class: CTreeItem
*
* DESCRIPTION:
* This class provides an abstract object for representing an item
* within a hierarchical tree.
*
****************************************************************************/
/****************************************************************************
*
* CTreeItem::CTreeItem
*
* PARAMETERS:
* pImg - image to be drawn with this item (NULL if none)
* uID - unique item identifier
* strLabel - text label for this item
*
* RETURNS:
* N/A
*
* DESCRIPTION:
* Constructor.
*
****************************************************************************/
CTreeItem::CTreeItem(CBitmap * pUnselectedImg, CBitmap *pSelectedImg, const UINT uID, const CString & strLabel, CMenu *pSubMenu)
{
m_pUnselectedImg = pUnselectedImg;
m_pSelectedImg = pSelectedImg;
m_uID = uID;
m_strLabel = strLabel;
m_unselectedBitmapSize.cx = m_unselectedBitmapSize.cy = 0;
m_selectedBitmapSize.cx = m_selectedBitmapSize.cy = 0;
m_textSize.cx = m_textSize.cy = 0;
m_accelSize.cx = m_accelSize.cy =0;
m_pSubMenu = pSubMenu;
} // END OF FUNCTION CTreeItem::CTreeItem()
/****************************************************************************
*
* CTreeItem::~CTreeItem
*
* PARAMETERS:
* N/A
*
* RETURNS:
* N/A
*
* DESCRIPTION:
* Destructor.
*
****************************************************************************/
CTreeItem::~CTreeItem()
{
if(m_pSubMenu)
delete m_pSubMenu;
} // END OF FUNCTION CTreeItem::~CTreeItem()
/****************************************************************************
*
* Class: CTreeItemList
*
* DESCRIPTION:
* This is a collection class for holding CTreeItem objects.
*
****************************************************************************/
/****************************************************************************
*
* CTreeItemList::CTreeItemList
*
* PARAMETERS:
* None
*
* RETURNS:
* N/A
*
* DESCRIPTION:
* Constructor
*
****************************************************************************/
CTreeItemList::CTreeItemList()
{
} // END OF FUNCTION CTreeItemList::CTreeItemList()
/****************************************************************************
*
* CTreeItemList::~CTreeItemList
*
* PARAMETERS:
* N/A
*
* RETURNS:
* N/A
*
* DESCRIPTION:
* Destructor. We provide auto-cleanup for the objects in the collection.
*
****************************************************************************/
CTreeItemList::~CTreeItemList()
{
int nCount = GetSize();
for (int i = 0; i < nCount; i++)
{
CTreeItem * pItem = Get(i);
if (pItem != NULL)
{
delete pItem;
}
}
RemoveAll();
} // END OF FUNCTION CTreeItemList::~CTreeItemList()
/****************************************************************************
*
* Class: CTreeMenu
*
* DESCRIPTION:
* This class provides a custom, self drawing menu object for displaying
* graphics as well as text in a menu item.
*
****************************************************************************/
/****************************************************************************
*
* CONSTANTS
*
****************************************************************************/
static int nIMG_SPACE = 3; // Gap between image and text in menu item
/****************************************************************************
*
* CTreeMenu::CTreeMenu
*
* PARAMETERS:
* None
*
* RETURNS:
* N/A
*
* DESCRIPTION:
* Constructor.
*
****************************************************************************/
CTreeMenu::CTreeMenu()
{
m_WidestImage=0;
m_WidestText=0;
m_WidestAccelerator=0;
m_pParent = NULL;
} // END OF FUNCTION CTreeMenu::CTreeMenu()
CTreeMenu::~CTreeMenu()
{
m_itemList.RemoveAll();
DeleteMnemonics();
}
void CTreeMenu::DeleteMnemonics(void)
{
POSITION pos;
WORD dwKey;
MnemonicStruct *pMnemonic = NULL;
// also destroy bitmaps;
pos = m_mnemonicMap.GetStartPosition();
while(pos)
{
m_mnemonicMap.GetNextAssoc(pos, dwKey,(void *&)pMnemonic);
delete pMnemonic;
}
m_mnemonicMap.RemoveAll();
}
/****************************************************************************
*
* CTreeMenu::AddItem
*
* PARAMETERS:
* pItem - pointer to abstract item
* hSubMenu - handle of sub-menu is this item is a new node
*
* RETURNS:
* TRUE if successful.
*
* DESCRIPTION:
* This function is called to add a new menu item to the main trunk. The
* new item can also be a branch, if hSubMenu is set properly.
*****************************************************************************/
BOOL CTreeMenu::AddItem(CTreeItem * pItem, int nPosition /*=0*/, CTreeMenu *pSubMenu /*= NULL*/,
void* pIcon /* = NULL */, IconType nIconType /* = BUILTIN_BITMAP */)
{
BOOL bRtn = FALSE;
m_itemList.Add(pItem);
pItem->SetIcon(pIcon, nIconType);
if (pSubMenu != NULL)
{
bRtn = InsertMenu(nPosition, MF_BYPOSITION | MF_OWNERDRAW | MF_POPUP, (UINT)pSubMenu->GetSafeHmenu(),
(const char *)pItem);
}
else
{
bRtn = InsertMenu(nPosition, MF_BYPOSITION | MF_OWNERDRAW, pItem->GetID(), (const char *)pItem);
}
return(bRtn);
} // END OF FUNCTION CTreeMenu::AddItem()
CMenu * CTreeMenu::FindMenu(CString& menuName)
{
int nSize = m_itemList.GetSize();
for(int i = 0; i < nSize; i ++)
{
CTreeItem *pItem = (CTreeItem*)m_itemList[i];
if(pItem->GetLabel() == menuName)
return pItem->GetSubMenu();
}
return NULL;
}
/****************************************************************************
*
* CTreeMenu::ClearItems
*
* PARAMETERS:
* start: Clear all elements starting with this index
* fromEnd: Delete up until this many elements from end
* RETURNS:
* N/A
*
* DESCRIPTION:
* Removes all items from the itemList starting with start until
* fromEnd elements from the end
*
****************************************************************************/
void CTreeMenu::ClearItems(int start, int fromEnd)
{
m_itemList.RemoveAt(start, m_itemList.GetSize() - fromEnd - start);
}
void CTreeMenu::AddMnemonic(TCHAR cMnemonic, UINT nCommand, int nPosition)
{
MnemonicStruct *pMnemonic = new MnemonicStruct;
pMnemonic->nCommand = nCommand;
pMnemonic->nPosition = nPosition;
m_mnemonicMap.SetAt(toupper(cMnemonic), pMnemonic);
}
BOOL CTreeMenu::GetMnemonic(TCHAR cMnemonic, UINT &nCommand, int &nPosition)
{
MnemonicStruct *pMnemonic;
if(m_mnemonicMap.Lookup(toupper(cMnemonic), (void*&)pMnemonic) )
{
nCommand = pMnemonic->nCommand;
nPosition = pMnemonic->nPosition;
return TRUE;
}
else
return FALSE;
}
/****************************************************************************
*
* CTreeMenu::CalculateItemDimensions
*
* PARAMETERS:
* N/A
*
* RETURNS:
* N/A
*
* DESCRIPTION:
* For each item in the menu, this calculates the size of that item's
* bitmap, menuitem text, and menuitem accelerator text. In addition,
* this keeps track of the widest bitmap, text, and accelerator text in
* the menu. This is done so that the accelerator can appear in a
* reasonable position on the menu and assuring that enough space will
* given to the menu item to draw itself
*
****************************************************************************/
void CTreeMenu::CalculateItemDimensions(void)
{
CSize unselectedBitmapSize, selectedBitmapSize, textSize, acceleratorSize;
CString label;
m_WidestImage=0;
m_WidestText=0;
m_WidestAccelerator=0;
int numItems = m_itemList.GetSize();
for(int i=0; i<numItems; i++)
{
CTreeItem *item = (CTreeItem*)m_itemList.Get(i);
unselectedBitmapSize=MeasureBitmap(item->GetUnselectedImage());
item->SetUnselectedBitmapSize(unselectedBitmapSize);
selectedBitmapSize=MeasureBitmap(item->GetSelectedImage());
item->SetSelectedBitmapSize(selectedBitmapSize);
if(unselectedBitmapSize.cx > m_WidestImage)
m_WidestImage = unselectedBitmapSize.cx;
if(selectedBitmapSize.cx > m_WidestImage)
m_WidestImage = selectedBitmapSize.cx;
label = item->GetLabel();
//Figure out if there is an accelerator
int tabPos=label.Find('\t');
if(tabPos!=-1)
{
textSize = MeasureText(label.Left(tabPos));
acceleratorSize = MeasureText(label.Right(label.GetLength() - (tabPos +1)));
item->SetAcceleratorSize(acceleratorSize);
if(acceleratorSize.cx > m_WidestAccelerator)
m_WidestAccelerator = acceleratorSize.cx;
}
else
textSize = MeasureText(label);
if(textSize.cx > m_WidestText)
m_WidestText = textSize.cx;
item->SetTextSize(textSize);
}
}
/****************************************************************************
*
* CTreeMenu::MeasureBitmap
*
* PARAMETERS:
* pBitmap: The bitmap to measure
*
* RETURNS:
* The size of the bitmap
*
* DESCRIPTION:
* Given a bitmap, this returns its dimensions
*
****************************************************************************/
CSize CTreeMenu::MeasureBitmap(CBitmap *pBitmap)
{
CSize size;
if (pBitmap != NULL)
{
BITMAP bmp;
pBitmap->GetObject(sizeof(bmp), &bmp);
size.cx = bmp.bmWidth;
size.cy = bmp.bmHeight;
}
else
size.cx = size.cy = 0;
return size;
}
/****************************************************************************
*
* CTreeMenu::MeasureText
*
* PARAMETERS:
* text: The CString text to be measured
*
* RETURNS:
* Returns the size of the text in the current font
*
* DESCRIPTION:
* Given a CString this returns the dimensions of that text
*
****************************************************************************/
CSize CTreeMenu::MeasureText(CString text)
{
HFONT MenuFont;
#if defined(WIN32)
NONCLIENTMETRICS ncm;
ncm.cbSize = sizeof(NONCLIENTMETRICS);
if (::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0))
{
MenuFont = theApp.CreateAppFont( ncm.lfMenuFont );
}
else
{
MenuFont = (HFONT)::GetStockObject(SYSTEM_FONT);
}
#else // Win16
MenuFont = (HFONT)::GetStockObject(SYSTEM_FONT);
#endif // WIN32
CDC dc;
dc.CreateCompatibleDC(NULL);
CFont * pOldFont = dc.SelectObject(CFont::FromHandle(MenuFont));
CSize sizeTxt = dc.GetTabbedTextExtent((LPCSTR)text, strlen(text), 0, NULL);
dc.SelectObject(pOldFont);
return sizeTxt;
}
/****************************************************************************
*
* CTreeMenu::MeasureItem
*
* PARAMETERS:
* lpMI - pointer to LPMEASUREITEMSTRUCT
*
* RETURNS:
* void
*
* DESCRIPTION:
* We must override this function to inform the system of our menu
* item dimensions, since we're owner draw style.
*
****************************************************************************/
#define ACCELERATOR_TAB 5 //Leave some space between the text and the accelerator
#define ACCELERATOR_RIGHT 15 //Leave a right margin between end of
//menu item and end of accelerator
#define MENU_LEFT_MARGIN 7 //Leave a left margin for text with no bitmaps
void CTreeMenu::MeasureItem(LPMEASUREITEMSTRUCT lpMI)
{
CTreeItem * pItem = (CTreeItem *)(lpMI->itemData);
ASSERT(pItem != NULL);
// First, get all of the dimensions
CSize sizeUnselectedImg=pItem->GetUnselectedBitmapSize();
CSize sizeSelectedImg=pItem->GetSelectedBitmapSize();
CSize sizeText=pItem->GetTextSize();
CSize sizeAccelerator=pItem->GetAcceleratorSize();
//if there's no bitmap we need to provide a margin for the text
lpMI->itemWidth = (m_WidestImage == 0) ? MENU_LEFT_MARGIN : 0;
//Return the values depending upon whether there is an accelerator
if(sizeAccelerator.cx !=0)
{
lpMI->itemWidth += m_WidestImage + m_WidestText + sizeAccelerator.cx + ACCELERATOR_TAB + ACCELERATOR_RIGHT + (2*nIMG_SPACE);
}
else
lpMI->itemWidth += m_WidestImage + sizeText.cx + (nIMG_SPACE * 2);
int nImageHeight = max(sizeUnselectedImg.cy, sizeSelectedImg.cy);
lpMI->itemHeight = max(nImageHeight, sizeText.cy) + 4;
} // END OF FUNCTION CTreeMenu::MeasureItem()
/****************************************************************************
*
* CTreeMenu::DrawItem
*
* PARAMETERS:
* lpDI - pointer to LPDRAWITEMSTRUCT
*
* RETURNS:
* void
*
* DESCRIPTION:
* We must override this function to draw our image and text for the
* menu item, since we're owner draw style.
*
****************************************************************************/
void CTreeMenu::DrawItem(LPDRAWITEMSTRUCT lpDI)
{
// Extract the goods from lpDI
CTreeItem * pItem = (CTreeItem *)(lpDI->itemData);
ASSERT(pItem != NULL);
CDC * pDC = CDC::FromHandle(lpDI->hDC);
CRect rc(&(lpDI->rcItem));
// Get proper colors and paint the background first
CBrush brBG;
COLORREF rgbTxt;
if (lpDI->itemState & ODS_SELECTED)
{
brBG.CreateSolidBrush(::GetSysColor(COLOR_HIGHLIGHT));
rgbTxt = ::GetSysColor(COLOR_HIGHLIGHTTEXT);
}
else
{
brBG.CreateSolidBrush(::GetSysColor(COLOR_MENU));
rgbTxt = ::GetSysColor(COLOR_MENUTEXT);
}
pDC->FillRect(&rc, &brBG);
// Now paint the bitmap, left side of menu
rc.left += nIMG_SPACE;
CSize imgSize = DrawImage(pDC, rc, pItem, lpDI->itemState & ODS_SELECTED);
// And now the text
HFONT MenuFont;
#if defined(WIN32)
NONCLIENTMETRICS ncm;
ncm.cbSize = sizeof(NONCLIENTMETRICS);
if (::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0))
{
MenuFont = theApp.CreateAppFont( ncm.lfMenuFont );
}
else
{
MenuFont = (HFONT)::GetStockObject(SYSTEM_FONT);
}
#else // Win16
MenuFont = (HFONT)::GetStockObject(SYSTEM_FONT);
#endif // WIN32
CFont * pOldFont = pDC->SelectObject(CFont::FromHandle(MenuFont));
int nOldBkMode = pDC->SetBkMode(TRANSPARENT);
COLORREF rgbOldTxt = pDC->SetTextColor(rgbTxt);
//Figure out where text should go in relation to bitmaps
if(m_WidestImage == 0)
rc.left += MENU_LEFT_MARGIN;
rc.left += imgSize.cx + nIMG_SPACE + (m_WidestImage-imgSize.cx);
//Deal with the case where there is a tab for an accelerator
CString label=pItem->GetLabel();
int tabPos=label.Find('\t');
if(tabPos!=-1)
{
pDC->DrawText(label.Left(tabPos), -1, &rc, DT_LEFT | DT_VCENTER |DT_SINGLELINE);
//Give the accelerator some room on the right
rc.right-=ACCELERATOR_RIGHT + (m_WidestAccelerator - pItem->GetAcceleratorSize().cx);
pDC->DrawText(label.Right(label.GetLength()-(tabPos+1)), -1, &rc, DT_RIGHT | DT_VCENTER |DT_SINGLELINE);
}
else
{
pDC->DrawText(label, -1, &rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE |DT_EXPANDTABS);
}
pDC->SetBkMode(nOldBkMode);
pDC->SetTextColor(rgbOldTxt);
pDC->SelectObject(pOldFont);
} // END OF FUNCTION CTreeMenu::DrawItem()
/****************************************************************************
*
* CTreeMenu::DrawImage
*
* PARAMETERS:
* pDC - pointer to device context to draw on
* rect - bounding rectangle to draw in
* pItem - pointer to CTreeItem that contains the data
* bIsSelected - is this item selected
*
* RETURNS:
* width of the image, in pixels
*
* DESCRIPTION:
* Protected helper function for drawing the bitmap image in a menu
* item. We return the size of the painted image so the caller can
* position the menu text after the image.
*
****************************************************************************/
CSize CTreeMenu::DrawImage(CDC * pDC, const CRect & rect, CTreeItem * pItem,
BOOL bIsSelected)
{
CSize sizeImg;
sizeImg.cx = sizeImg.cy = 0;
CBitmap * pImg = bIsSelected ? pItem->GetSelectedImage() : pItem->GetUnselectedImage();
if (pImg != NULL)
{
HPALETTE hPalette= WFE_GetUIPalette(m_pParent);
HPALETTE hOldPalette = ::SelectPalette(pDC->m_hDC, hPalette, FALSE);
// Get image dimensions
BITMAP bmp;
pImg->GetObject(sizeof(bmp), &bmp);
sizeImg.cx = bmp.bmWidth;
sizeImg.cy = bmp.bmHeight;
// Create a scratch DC and select our bitmap into it.
CDC * pBmpDC = new CDC;
pBmpDC->CreateCompatibleDC(pDC);
CBitmap * pOldBmp = pBmpDC->SelectObject(pImg);
// Center the image horizontally and vertically
CPoint ptDst(rect.left + (m_WidestImage - sizeImg.cx)/2, rect.top +
(((rect.Height() - sizeImg.cy) + 1) / 2));
// Call the handy transparent blit function to paint the bitmap over
// the background.
if (pItem->GetIconType() == LOCAL_FILE)
{
HICON hIcon = pItem->GetLocalFileIcon();
DrawIconEx(pDC->m_hDC, ptDst.x, ptDst.y, hIcon, 0, 0, 0, NULL, DI_NORMAL);
}
else if (pItem->GetIconType() == ARBITRARY_URL)
{
CRDFImage* pImage = pItem->GetCustomIcon();
HDC hDC = pDC->m_hDC;
int left = ptDst.x;
int top = ptDst.y;
int imageWidth = 16;
int imageHeight = 16;
COLORREF bkColor = bIsSelected ?
GetSysColor(COLOR_HIGHLIGHT) : GetSysColor(COLOR_MENU);
if (pImage && pImage->FrameLoaded())
{
// Now we draw this bad boy.
if (pImage->m_BadImage)
{
// display broken icon.
HDC tempDC = ::CreateCompatibleDC(hDC);
HBITMAP hOldBmp = (HBITMAP)::SelectObject(tempDC, CRDFImage::m_hBadImageBitmap);
::StretchBlt(hDC,
left, top,
imageWidth, imageHeight,
tempDC, 0, 0,
imageWidth, imageHeight, SRCCOPY);
::SelectObject(tempDC, hOldBmp);
::DeleteDC(tempDC);
}
else if (pImage->bits )
{
// Center the image.
long width = pImage->bmpInfo->bmiHeader.biWidth;
long height = pImage->bmpInfo->bmiHeader.biHeight;
int xoffset = (imageWidth-width)/2;
int yoffset = (imageHeight-height)/2;
if (xoffset < 0) xoffset = 0;
if (yoffset < 0) yoffset = 0;
if (width > imageWidth) width = imageWidth;
if (height > imageHeight) height = imageHeight;
HPALETTE hPal = WFE_GetUIPalette(NULL);
HPALETTE hOldPal = ::SelectPalette(hDC, hPal, TRUE);
::RealizePalette(hDC);
if (pImage->maskbits)
{
WFE_StretchDIBitsWithMask(hDC, TRUE, NULL,
left+xoffset, top+xoffset,
width, height,
0, 0, width, height,
pImage->bits, pImage->bmpInfo,
pImage->maskbits, FALSE, bkColor);
}
else
{
::StretchDIBits(hDC,
left+xoffset, top+xoffset,
width, height,
0, 0, width, height, pImage->bits, pImage->bmpInfo, DIB_RGB_COLORS,
SRCCOPY);
}
::SelectPalette(hDC, hOldPal, TRUE);
}
}
}
else ::FEU_TransBlt(pBmpDC, pDC, CPoint(0, 0), ptDst, sizeImg.cx, sizeImg.cy, hPalette, PALETTERGB(255, 0, 255));
::SelectPalette(pDC->m_hDC, hOldPalette, TRUE);
// Cleanup
pBmpDC->SelectObject(pOldBmp);
pBmpDC->DeleteDC();
delete pBmpDC;
}
return(sizeImg);
} // END OF FUNCTION CTreeMenu::DrawImage()
void CTreeMenu::LoadComplete(HT_Resource r)
{
}
/****************************************************************************
*
* Class: CPopupTree
*
* DESCRIPTION:
* This class represents a hierarchical popup menu object that can be
* used for selecting from a list of sub-categorized items.
*
****************************************************************************/
/****************************************************************************
*
* CPopupTree::CPopupTree
*
* PARAMETERS:
* pItems - list of items for filling the tree
*
* RETURNS:
* N/A
*
* DESCRIPTION:
* Constructor.
*
****************************************************************************/
CPopupTree::CPopupTree(CTreeItemList * pItems)
{
m_pTree = pItems;
} // END OF FUNCTION CPopupTree::CPopupTree()
/****************************************************************************
*
* CPopupTree::~CPopupTree
*
* PARAMETERS:
* N/A
*
* RETURNS:
* N/A
*
* DESCRIPTION:
* Destructor.
*
****************************************************************************/
CPopupTree::~CPopupTree()
{
// Time to take out the trash! We maintain a list of objects that were
// dynamically allocated on the heap, but couldn't be conveniently
// deleted.
for (int i = 0; i < m_GarbageList.GetSize(); i++)
{
CObject * pObject = m_GarbageList.GetAt(i);
if (pObject != NULL)
{
delete pObject;
}
}
m_GarbageList.RemoveAll();
} // END OF FUNCTION CPopupTree::~CPopupTree()
/****************************************************************************
*
* CPopupTree::Activate
*
* PARAMETERS:
* nX - horizontal position (screen coordinates)
* nY - vertical position
* pParent - pointer to parent window
*
* RETURNS:
* TRUE if creation is successful
*
* DESCRIPTION:
* This function is called to display the popup menu, after construction.
*
****************************************************************************/
BOOL CPopupTree::Activate(int nX, int nY, CWnd * pParent)
{
CTreeMenu Menu;
BOOL bRtn = Menu.Create();
// Now construct the menu from our tree
BuildMenu(&Menu, m_pTree);
if (bRtn)
{
bRtn = Menu.TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON, nX, nY, pParent);
}
return(bRtn);
} // END OF FUNCTION CPopupTree::Activate()
/****************************************************************************
*
* CPopupTree::BuildMenu
*
* PARAMETERS:
* pMenu - pointer to the menu to be constructed
* pItems - list of item objects for building the menu
*
* RETURNS:
* void
*
* DESCRIPTION:
* This function is called to construct a custom menu from a list
* of item objects. It is recursive and can be called for each node
* that contains sub-items.
*
****************************************************************************/
void CPopupTree::BuildMenu(CTreeMenu * pMenu, CTreeItemList * pItems)
{
for (int i = 0; i < pItems->GetSize(); i++)
{
CTreeItem * pItem = pItems->Get(i);
ASSERT(pItem != NULL);
if (pItem != NULL)
{
// See if this item has sub-items
CTreeItemList * pSubItems = pItem->GetSubItems();
if (pSubItems->GetSize() > 0)
{
// It does, so create a new menu and call this function
// recursively to construct it.
CTreeMenu * pSubMenu = new CTreeMenu;
// m_GarbageList.Add(pSubMenu);
pSubMenu->Create();
BuildMenu(pSubMenu, pSubItems);
pSubMenu->CalculateItemDimensions();
// Last but not least, add the new branch to the main menu
BOOL bOk = pMenu->AddItem(pItem, 0, pSubMenu);
ASSERT(bOk);
}
else
{
// Just add top-level item
BOOL bOk = pMenu->AddItem(pItem);
ASSERT(bOk);
}
}
}
pMenu->CalculateItemDimensions();
} // END OF FUNCTION CPopupTree::BuildMenu()
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку