648 lines
20 KiB
C++
648 lines
20 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include <vgui/IScheme.h>
|
|
#include <vgui/IVGui.h>
|
|
#include "vgui/ISurface.h"
|
|
#include <KeyValues.h>
|
|
|
|
#include <vgui_controls/Controls.h>
|
|
#include <vgui_controls/Menu.h>
|
|
#include <vgui_controls/MenuItem.h>
|
|
#include <vgui_controls/TextImage.h>
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include <tier0/memdbgon.h>
|
|
|
|
using namespace vgui;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Check box image
|
|
//-----------------------------------------------------------------------------
|
|
class MenuItemCheckImage : public TextImage
|
|
{
|
|
public:
|
|
MenuItemCheckImage(MenuItem *item) : TextImage( "g" )
|
|
{
|
|
_menuItem = item;
|
|
|
|
SetSize(20, 13);
|
|
}
|
|
|
|
virtual void Paint()
|
|
{
|
|
DrawSetTextFont(GetFont());
|
|
|
|
// draw background
|
|
DrawSetTextColor(_menuItem->GetBgColor());
|
|
DrawPrintChar(0, 0, 'g');
|
|
|
|
// draw check
|
|
if (_menuItem->IsChecked())
|
|
{
|
|
if (_menuItem->IsEnabled())
|
|
{
|
|
DrawSetTextColor(_menuItem->GetButtonFgColor());
|
|
DrawPrintChar(0, 2, 'a');
|
|
}
|
|
else if (!_menuItem->IsEnabled())
|
|
{
|
|
// draw disabled version, with embossed look
|
|
// offset image
|
|
DrawSetTextColor(_menuItem->GetDisabledFgColor1());
|
|
DrawPrintChar(1, 3, 'a');
|
|
|
|
// overlayed image
|
|
DrawSetTextColor(_menuItem->GetDisabledFgColor2());
|
|
DrawPrintChar(0, 2, 'a');
|
|
}
|
|
}
|
|
}
|
|
|
|
private:
|
|
MenuItem *_menuItem;
|
|
};
|
|
|
|
DECLARE_BUILD_FACTORY_DEFAULT_TEXT( MenuItem, MenuItem );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor
|
|
// Input: parent - the parent of this menu item, usually a menu
|
|
// text - the name of the menu item as it appears in the menu
|
|
// cascadeMenu - if this item triggers the opening of a cascading menu
|
|
// provide a pointer to it.
|
|
// MenuItems cannot be both checkable and trigger a cascade menu.
|
|
//-----------------------------------------------------------------------------
|
|
MenuItem::MenuItem(Menu *parent, const char *panelName, const char *text, Menu *cascadeMenu, bool checkable) : Button(parent, panelName, text)
|
|
{
|
|
m_pCascadeMenu = cascadeMenu;
|
|
m_bCheckable = checkable;
|
|
SetButtonActivationType(ACTIVATE_ONRELEASED);
|
|
m_pUserData = NULL;
|
|
m_pCurrentKeyBinding = NULL;
|
|
|
|
// only one arg should be passed in.
|
|
Assert (!(cascadeMenu && checkable));
|
|
|
|
Init();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor
|
|
// Input: parent - the parent of this menu item, usually a menu
|
|
// text - the name of the menu item as it appears in the menu
|
|
// cascadeMenu - if this item triggers the opening of a cascading menu
|
|
// provide a pointer to it.
|
|
// MenuItems cannot be both checkable and trigger a cascade menu.
|
|
//-----------------------------------------------------------------------------
|
|
MenuItem::MenuItem(Menu *parent, const char *panelName, const wchar_t *wszText, Menu *cascadeMenu, bool checkable) : Button(parent, panelName, wszText)
|
|
{
|
|
m_pCascadeMenu = cascadeMenu;
|
|
m_bCheckable = checkable;
|
|
SetButtonActivationType(ACTIVATE_ONRELEASED);
|
|
m_pUserData = NULL;
|
|
m_pCurrentKeyBinding = NULL;
|
|
|
|
// only one arg should be passed in.
|
|
Assert (!(cascadeMenu && checkable));
|
|
|
|
Init();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Destructor
|
|
//-----------------------------------------------------------------------------
|
|
MenuItem::~MenuItem()
|
|
{
|
|
delete m_pCascadeMenu;
|
|
delete m_pCascadeArrow;
|
|
delete m_pCheck;
|
|
if (m_pUserData)
|
|
{
|
|
m_pUserData->deleteThis();
|
|
}
|
|
delete m_pCurrentKeyBinding;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Basic initializer
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::Init( void )
|
|
{
|
|
m_pCascadeArrow = NULL;
|
|
m_pCheck = NULL;
|
|
|
|
if (m_pCascadeMenu)
|
|
{
|
|
m_pCascadeMenu->SetParent(this);
|
|
m_pCascadeArrow = new TextImage("4"); // this makes a right pointing arrow.
|
|
|
|
m_pCascadeMenu->AddActionSignalTarget(this);
|
|
}
|
|
else if (m_bCheckable)
|
|
{
|
|
// move the text image over so we have room for the check
|
|
SetTextImageIndex(1);
|
|
m_pCheck = new MenuItemCheckImage(this);
|
|
SetImageAtIndex(0, m_pCheck, CHECK_INSET);
|
|
SetChecked(false);
|
|
}
|
|
|
|
SetButtonBorderEnabled( false );
|
|
SetUseCaptureMouse( false );
|
|
SetContentAlignment( Label::a_west );
|
|
|
|
// note menus handle all the sizing of menuItem panels
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
Menu *MenuItem::GetParentMenu()
|
|
{
|
|
return (Menu *)GetParent();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Layout the Textimage and the Arrow part of the menuItem
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::PerformLayout()
|
|
{
|
|
Button::PerformLayout();
|
|
// make the arrow image match the button layout.
|
|
// this will make it brighten and dim like the menu buttons.
|
|
if (m_pCascadeArrow)
|
|
{
|
|
m_pCascadeArrow->SetColor(GetButtonFgColor());
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Close the cascading menu if we have one.
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::CloseCascadeMenu()
|
|
{
|
|
if (m_pCascadeMenu)
|
|
{
|
|
if (m_pCascadeMenu->IsVisible())
|
|
{
|
|
m_pCascadeMenu->SetVisible(false);
|
|
}
|
|
// disarm even if menu wasn't visible!
|
|
SetArmed(false);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handle cursor moving in a menuItem.
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::OnCursorMoved(int x, int y)
|
|
{
|
|
// if menu is in keymode and we moved the mouse
|
|
// highlight this item
|
|
if (GetParentMenu()->GetMenuMode() == Menu::KEYBOARD)
|
|
{
|
|
OnCursorEntered();
|
|
}
|
|
|
|
// chain up to parent
|
|
CallParentFunction(new KeyValues("OnCursorMoved", "x", x, "y", y));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handle mouse cursor entering a menuItem.
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::OnCursorEntered()
|
|
{
|
|
// post a message to the parent menu.
|
|
// forward the message on to the parent of this menu.
|
|
KeyValues *msg = new KeyValues ("CursorEnteredMenuItem");
|
|
// tell the parent this menuitem is the one that was entered so it can highlight it
|
|
msg->SetInt("VPanel", GetVPanel());
|
|
|
|
ivgui()->PostMessage(GetVParent(), msg, NULL);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handle mouse cursor exiting a menuItem.
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::OnCursorExited()
|
|
{
|
|
// post a message to the parent menu.
|
|
// forward the message on to the parent of this menu.
|
|
KeyValues *msg = new KeyValues ("CursorExitedMenuItem");
|
|
// tell the parent this menuitem is the one that was entered so it can unhighlight it
|
|
msg->SetInt("VPanel", GetVPanel());
|
|
|
|
ivgui()->PostMessage(GetVParent(), msg, NULL);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handle mouse cursor exiting a menuItem.
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::OnKeyCodeReleased(KeyCode code)
|
|
{
|
|
if (GetParentMenu()->GetMenuMode() == Menu::KEYBOARD && m_pCascadeMenu)
|
|
{
|
|
return;
|
|
}
|
|
// only disarm if we are not opening a cascading menu using keys.
|
|
Button::OnKeyCodeReleased(code);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Highlight a menu item
|
|
// Menu item buttons highlight if disabled, but won't activate.
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::ArmItem()
|
|
{
|
|
// close all other menus
|
|
GetParentMenu()->CloseOtherMenus(this);
|
|
// arm the menuItem.
|
|
Button::SetArmed(true);
|
|
|
|
// When you have a submenu with no scroll bar the menu
|
|
// border will not be drawn correctly. This fixes it.
|
|
Menu *parent = GetParentMenu();
|
|
if ( parent )
|
|
{
|
|
parent->ForceCalculateWidth();
|
|
}
|
|
|
|
Repaint();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Unhighlight a menu item
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::DisarmItem()
|
|
{
|
|
// normal behaviour is that the button becomes unarmed
|
|
// do not unarm if there is a cascading menu. CloseCascadeMenu handles this.
|
|
// and the menu handles it since we close at different times depending
|
|
// on whether menu is handling mouse or key events.
|
|
if (!m_pCascadeMenu)
|
|
{
|
|
Button::OnCursorExited();
|
|
}
|
|
|
|
// When you have a submenu with no scroll bar the menu
|
|
// border will not be drawn correctly. This fixes it.
|
|
Menu *parent = GetParentMenu();
|
|
if ( parent )
|
|
{
|
|
parent->ForceCalculateWidth();
|
|
}
|
|
Repaint();
|
|
}
|
|
|
|
bool MenuItem::IsItemArmed()
|
|
{
|
|
return Button::IsArmed();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Pass kill focus events up to parent, This will tell all panels
|
|
// in the hierarchy to hide themselves, and enables cascading menus to
|
|
// all disappear on selecting an item at the end of the tree.
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::OnKillFocus()
|
|
{
|
|
GetParentMenu()->OnKillFocus();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: fire the menu item as if it has been selected and
|
|
// Tell the owner that it is closing
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::FireActionSignal()
|
|
{
|
|
// cascading menus items don't trigger the parent menu to disappear
|
|
// (they trigger the cascading menu to open/close when cursor is moved over/off them)
|
|
if (!m_pCascadeMenu)
|
|
{
|
|
KeyValues *kv = new KeyValues("MenuItemSelected");
|
|
kv->SetPtr("panel", this);
|
|
ivgui()->PostMessage(GetVParent(), kv, GetVPanel());
|
|
|
|
// ivgui()->PostMessage(GetVParent(), new KeyValues("MenuItemSelected"), GetVPanel());
|
|
Button::FireActionSignal();
|
|
// toggle the check next to the item if it is checkable
|
|
if (m_bCheckable)
|
|
{
|
|
SetChecked( !m_bChecked );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// if we are in keyboard mode, open the child menu.
|
|
if (GetParentMenu()->GetMenuMode() == Menu::KEYBOARD)
|
|
{
|
|
OpenCascadeMenu();
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Opens the cascading menu.
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::OpenCascadeMenu()
|
|
{
|
|
if (m_pCascadeMenu)
|
|
{
|
|
// perform layout on menu, this way it will open in the right spot
|
|
// if the window's been moved
|
|
m_pCascadeMenu->PerformLayout();
|
|
m_pCascadeMenu->SetVisible(true);
|
|
m_pCascadeMenu->MoveToFront();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpse: Return true if this item triggers a cascading menu
|
|
//-----------------------------------------------------------------------------
|
|
bool MenuItem::HasMenu()
|
|
{
|
|
return (m_pCascadeMenu != NULL);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Apply the resource scheme to the menu.
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::ApplySchemeSettings(IScheme *pScheme)
|
|
{
|
|
// chain back first
|
|
Button::ApplySchemeSettings(pScheme);
|
|
|
|
// get color settings
|
|
SetDefaultColor(GetSchemeColor("Menu.TextColor", GetFgColor(), pScheme), GetSchemeColor("Menu.BgColor", GetBgColor(), pScheme));
|
|
SetArmedColor(GetSchemeColor("Menu.ArmedTextColor", GetFgColor(), pScheme), GetSchemeColor("Menu.ArmedBgColor", GetBgColor(), pScheme));
|
|
SetDepressedColor(GetSchemeColor("Menu.ArmedTextColor", GetFgColor(), pScheme), GetSchemeColor("Menu.ArmedBgColor", GetBgColor(), pScheme));
|
|
|
|
SetTextInset(atoi(pScheme->GetResourceString("Menu.TextInset")), 0);
|
|
|
|
// reload images since applyschemesettings in label wipes them out.
|
|
if ( m_pCascadeArrow )
|
|
{
|
|
m_pCascadeArrow->SetFont(pScheme->GetFont("Marlett", IsProportional() ));
|
|
m_pCascadeArrow->ResizeImageToContent();
|
|
AddImage(m_pCascadeArrow, 0);
|
|
}
|
|
else if (m_bCheckable)
|
|
{
|
|
( static_cast<MenuItemCheckImage *>(m_pCheck) )->SetFont( pScheme->GetFont("Marlett", IsProportional()));
|
|
SetImageAtIndex(0, m_pCheck, CHECK_INSET);
|
|
( static_cast<MenuItemCheckImage *>(m_pCheck) )->ResizeImageToContent();
|
|
}
|
|
|
|
if ( m_pCurrentKeyBinding )
|
|
{
|
|
m_pCurrentKeyBinding->SetFont(pScheme->GetFont("Default", IsProportional() ));
|
|
m_pCurrentKeyBinding->ResizeImageToContent();
|
|
}
|
|
|
|
// Have the menu redo the layout
|
|
// Get the parent to resize
|
|
Menu * parent = GetParentMenu();
|
|
if ( parent )
|
|
{
|
|
parent->ForceCalculateWidth();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the size of the text portion of the label.
|
|
// for normal menu items this is the same as the label size, but for
|
|
// cascading menus it gives you the size of the text portion only, without
|
|
// the arrow.
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::GetTextImageSize(int &wide, int &tall)
|
|
{
|
|
GetTextImage()->GetSize(wide, tall);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set the size of the text portion of the label.
|
|
// For normal menu items this is the same as the label size, but for
|
|
// cascading menus it sizes textImage portion only, without
|
|
// the arrow.
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::SetTextImageSize(int wide, int tall)
|
|
{
|
|
GetTextImage()->SetSize(wide, tall);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the size of the arrow portion of the label.
|
|
// If the menuItem is not a cascading menu, 0 is returned.
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::GetArrowImageSize(int &wide, int &tall)
|
|
{
|
|
wide = 0, tall = 0;
|
|
if (m_pCascadeArrow)
|
|
{
|
|
m_pCascadeArrow->GetSize(wide, tall);
|
|
return;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the size of the check portion of the label.
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::GetCheckImageSize(int &wide, int &tall)
|
|
{
|
|
wide = 0, tall = 0;
|
|
if (m_pCheck)
|
|
{
|
|
// resize the image to the contents size
|
|
( static_cast<MenuItemCheckImage *>(m_pCheck) )->ResizeImageToContent();
|
|
m_pCheck->GetSize(wide, tall);
|
|
|
|
// include the inset for the check, since nobody but us know about the inset
|
|
wide += CHECK_INSET;
|
|
return;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return a the menu that this menuItem contains
|
|
// This is useful when the parent menu's commands must be
|
|
// sent through all menus that are open as well (like hotkeys)
|
|
//-----------------------------------------------------------------------------
|
|
Menu *MenuItem::GetMenu()
|
|
{
|
|
return m_pCascadeMenu;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get the border style for the button. Menu items have no border so
|
|
// return null.
|
|
//-----------------------------------------------------------------------------
|
|
IBorder *MenuItem::GetBorder(bool depressed, bool armed, bool selected, bool keyfocus)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set the menu to key mode if a child menu goes into keymode
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::OnKeyModeSet()
|
|
{
|
|
// send the message to this parent in case this is a cascading menu
|
|
ivgui()->PostMessage(GetVParent(), new KeyValues("KeyModeSet"), GetVPanel());
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return if this menuitem is checkable or not
|
|
// This is used by menus to perform the layout properly.
|
|
//-----------------------------------------------------------------------------
|
|
bool MenuItem::IsCheckable()
|
|
{
|
|
return m_bCheckable;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return if this menuitem is checked or not
|
|
//-----------------------------------------------------------------------------
|
|
bool MenuItem::IsChecked()
|
|
{
|
|
return m_bChecked;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set the checked state of a checkable menuitem
|
|
// Does nothing if item is not checkable
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::SetChecked(bool state)
|
|
{
|
|
if (m_bCheckable)
|
|
{
|
|
m_bChecked = state;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool MenuItem::CanBeDefaultButton(void)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
KeyValues *MenuItem::GetUserData()
|
|
{
|
|
if ( HasMenu() )
|
|
{
|
|
return m_pCascadeMenu->GetItemUserData( m_pCascadeMenu->GetActiveItem() );
|
|
}
|
|
else
|
|
{
|
|
return m_pUserData;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: sets the user data
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::SetUserData(const KeyValues *kv)
|
|
{
|
|
if (m_pUserData)
|
|
{
|
|
m_pUserData->deleteThis();
|
|
m_pUserData = NULL;
|
|
}
|
|
|
|
if ( kv )
|
|
{
|
|
m_pUserData = kv->MakeCopy();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Passing in NULL removes this object
|
|
// Input : *keyName -
|
|
//-----------------------------------------------------------------------------
|
|
void MenuItem::SetCurrentKeyBinding( char const *keyName )
|
|
{
|
|
if ( !keyName )
|
|
{
|
|
delete m_pCurrentKeyBinding;
|
|
m_pCurrentKeyBinding = NULL;
|
|
return;
|
|
}
|
|
|
|
if ( !m_pCurrentKeyBinding )
|
|
{
|
|
m_pCurrentKeyBinding = new TextImage( keyName );
|
|
}
|
|
else
|
|
{
|
|
char curtext[ 256 ];
|
|
m_pCurrentKeyBinding->GetText( curtext, sizeof( curtext ) );
|
|
if ( !Q_strcmp( curtext, keyName ) )
|
|
return;
|
|
|
|
m_pCurrentKeyBinding->SetText( keyName );
|
|
}
|
|
|
|
InvalidateLayout( false, true );
|
|
}
|
|
|
|
#define KEYBINDING_INSET 5
|
|
|
|
void MenuItem::Paint()
|
|
{
|
|
BaseClass::Paint();
|
|
if ( !m_pCurrentKeyBinding )
|
|
return;
|
|
|
|
int w, h;
|
|
GetSize( w, h );
|
|
int iw, ih;
|
|
m_pCurrentKeyBinding->GetSize( iw, ih );
|
|
|
|
int x = w - iw - KEYBINDING_INSET;
|
|
int y = ( h - ih ) / 2;
|
|
|
|
if ( IsEnabled() )
|
|
{
|
|
m_pCurrentKeyBinding->SetPos( x, y );
|
|
m_pCurrentKeyBinding->SetColor( GetButtonFgColor() );
|
|
m_pCurrentKeyBinding->Paint();
|
|
}
|
|
else
|
|
{
|
|
m_pCurrentKeyBinding->SetPos( x + 1 , y + 1 );
|
|
m_pCurrentKeyBinding->SetColor( GetDisabledFgColor1() );
|
|
m_pCurrentKeyBinding->Paint();
|
|
|
|
surface()->DrawFlushText();
|
|
|
|
m_pCurrentKeyBinding->SetPos( x, y );
|
|
m_pCurrentKeyBinding->SetColor( GetDisabledFgColor2() );
|
|
m_pCurrentKeyBinding->Paint();
|
|
}
|
|
}
|
|
|
|
void MenuItem::GetContentSize( int& cw, int &ch )
|
|
{
|
|
BaseClass::GetContentSize( cw, ch );
|
|
if ( !m_pCurrentKeyBinding )
|
|
return;
|
|
|
|
int iw, ih;
|
|
m_pCurrentKeyBinding->GetSize( iw, ih );
|
|
|
|
cw += iw + KEYBINDING_INSET;
|
|
ch = max( ch, ih );
|
|
}
|