MenuItem Class Reference

#include <MenuItem.h>

Public Member Functions
	MenuItem (int type, char *pszTitleANSI, wchar_t *pszTitleUnicode, char *pszCommand, char *pszArgument, bool isSelected)
virtual	~MenuItem ()
virtual LRESULT	NcHitTest (int x, int y)
int	IsOver (int x, int y)
virtual void	Mouse (UINT nMsg, POINT pt)
virtual void	Invoke (int button)
virtual bool	Active (bool bActive)
virtual bool	IsActive ()
virtual char *	GetSortString ()
virtual void	GetItemRect (RECT *r)
virtual void	GetTitleRect (RECT *r)
virtual UINT	GetDrawTextFormat ()
virtual void	SetTitleANSI (char *pszTitleANSI)
virtual void	SetTitleUnicode (wchar_t *pszTitleUnicode)
void	AddToSelectionGroup (int group)
void	ItemSetTimer ()
virtual void	Timer (int nTimer)
void	ItemKillTimer ()
virtual void	SetWidth (int nWidth)
virtual int	GetWidth ()
virtual void	SetHeight (int nHeight)
virtual int	GetHeight ()
virtual void	SetPosition (int nLeft, int nTop)
virtual void	SetSortPriority (int nSortPriority)
virtual int	GetSortPriority ()
virtual void	Attached (Menu *pMenu)
virtual LRESULT	Command (WPARAM wParam, LPARAM lParam)
virtual bool	OnUser (int nMessage, WPARAM wParam, LPARAM lParam, LRESULT &lResult)
virtual void	Moving ()
virtual HWND	GetWindow ()
void	ToggleSelected ()

Static Public Member Functions
static bool	Compare (MenuItem *pM1, MenuItem *pM2)

Public Attributes
char *	m_pszTitleANSI
wchar_t *	m_pszTitleUnicode
int	itemType
char *	m_pszCommand
char *	m_pszArgument
char *	m_pszOriginalTitleANSI
wchar_t *	m_pszOriginalTitleUnicode
bool	m_isSelected
int	m_selectionGroup
int	m_currentValue
int	m_minValue
int	m_maxValue
POINT	m_mousePos
int	m_nSortPriority
Menu *	m_pParent
Menu *	m_pSubMenu
int	m_nLeft
int	m_nTop
int	m_nWidth
int	m_nHeight
bool	m_bActive
UINT	m_nTimerId
int	m_nLastMouseButton

Constructor & Destructor Documentation

MenuItem()

MenuItem::MenuItem	(	int	type,
		char *	pszTitleANSI,
		wchar_t *	pszTitleUnicode,
		char *	pszCommand,
		char *	pszArgument,
		bool	isSelected )

{
    itemType = type;
 
    if (pszTitleANSI == NULL) m_pszTitleANSI = _strdup("");
    else m_pszTitleANSI = _strdup(pszTitleANSI);
 
    if (pszTitleUnicode == NULL)
    {
        if (!pSettings->disableUnicodeParsing)
        {
            wchar_t itemTitleUnicode[MAX_LINE_LENGTH];
            MultiByteToWideChar(CP_UTF8, 0, pszTitleANSI, strlen(pszTitleANSI)+1, itemTitleUnicode, MAX_LINE_LENGTH);
            m_pszTitleUnicode = _wcsdup(itemTitleUnicode);
        }
        else m_pszTitleUnicode = _wcsdup(L"");
    }
    else m_pszTitleUnicode = _wcsdup(pszTitleUnicode);
 
    //====================
 
    m_pParent = NULL;
    m_nWidth = 0;
    m_nHeight = 0;
 
    m_bActive = false;
    m_nTimerId = 0;
 
    m_selectionGroup = 0; // Default -> Not part of any selection group (i.e. a group of mutually exclusive boolean items)
 
    SetSortPriority(PRIORITY_NORMAL); // Default sort priority unless defined
 
    //====================
 
    if (type == MENUITEM_COMMAND || type == MENUITEM_BOOLEAN || type == MENUITEM_EDITINT)
    {
        // Creates a command-type menu item object (being either a regular, a boolean or an integer editing item)
        // pszCommand -> The command associated with this menu item
        // pszArgument -> Optional argument to pszCommand
        // pszTitle -> The text to be drawn on the menu item
 
        m_pszCommand = pszCommand ? _strdup(pszCommand) : _strdup("");
        m_pszArgument = pszArgument ? _strdup(pszArgument) : _strdup("");
        m_pszOriginalTitleANSI = pszTitleANSI ? _strdup(pszTitleANSI) : _strdup("");
        m_pszOriginalTitleUnicode = pszTitleUnicode ? _wcsdup(pszTitleUnicode) : _wcsdup(L"");
        m_isSelected = isSelected;
 
        if (type == MENUITEM_EDITINT) // Used by MakeMenuItemInt...
        {
            char command[MAX_LINE_LENGTH], value[10], min[10], max[10];
            LPSTR tokens[3];
            tokens[0] = command;
            tokens[1] = value;
            tokens[2] = min;
            command[0] = value[0] = min[0] = max[0] = '\0';
            BBTokenize (m_pszCommand, tokens, 3, max);
 
            m_pszCommand = command ? _strdup(command) : _strdup("");
 
            m_currentValue = atoi(value);
            m_minValue = atoi(min);
            m_maxValue = atoi(max);
 
            char itemstringANSI[MAX_LINE_LENGTH];
            sprintf(itemstringANSI, "%s <%d>", m_pszOriginalTitleANSI, m_currentValue);
            SetTitleANSI(itemstringANSI);
 
            wchar_t itemStringUnicode[MAX_LINE_LENGTH];
            swprintf(itemStringUnicode, sizeof(itemStringUnicode), L"%s <%d>", m_pszOriginalTitleUnicode, m_currentValue);
            SetTitleUnicode(itemStringUnicode);
        }
    }
 
    //====================
 
    else
    {
        m_pszCommand = NULL;
        m_pszArgument = NULL;
        m_pszOriginalTitleANSI = NULL;
        m_pszOriginalTitleUnicode = NULL;
//      m_isSelected = false;
        m_isSelected = isSelected;
 
        m_currentValue = m_minValue = m_maxValue = 0;
    }
 
    //====================
 
    // Set a higher sort priority for [separator] items to make
    // sort before any regular menu items (i.e. between folders
    // regular menu items)
//  if (itemType == MENUITEM_SEPARATOR) SetSortPriority(PRIORITY_SEPARATOR);
//  else if (itemType == MENUITEM_HEADER) SetSortPriority(PRIORITY_HEADER);
}

~MenuItem()

MenuItem::~MenuItem ( )

virtual

{
    ItemKillTimer();
 
    if (m_pszTitleANSI) free(m_pszTitleANSI);
    m_pszTitleANSI = NULL;
    if (m_pszTitleUnicode) free(m_pszTitleUnicode);
    m_pszTitleUnicode = NULL;
 
    if (m_pszOriginalTitleANSI) free(m_pszOriginalTitleANSI);
    m_pszOriginalTitleANSI = NULL;
    if (m_pszOriginalTitleUnicode) free(m_pszOriginalTitleUnicode);
    m_pszOriginalTitleUnicode = NULL;
 
    if (m_pszCommand) free(m_pszCommand);
    m_pszCommand = NULL;
    if (m_pszArgument) free(m_pszArgument);
    m_pszArgument = NULL;
}

Member Function Documentation

NcHitTest()

LRESULT MenuItem::NcHitTest ( int x, int y )

virtual

{
    if (itemType == MENUITEM_HEADER || itemType == MENUITEM_FOOTER)
    {
        if (IsOver(x, y) && (!m_pParent->GetParent() || m_pParent->IsPinned())) return HTCAPTION;
    }
 
    return HTCLIENT;
}

IsOver()

int MenuItem::IsOver	(	int	x,
		int	y )

{
    if ((x >= 0) && (x <= GetWidth()) && (y >= m_nTop) &&  (y <= m_nTop + GetHeight()))
        return true;
    else
        return false;
}

Mouse()

void MenuItem::Mouse ( UINT nMsg, POINT pt )

virtual

{
    // Save the mouse position...
    // (this may be used by MenuCommon to detect where on the
    // item you clicked, e.g. for integer editing items)
    m_mousePos.x = pt.x;
    m_mousePos.y = pt.y;
 
    //====================
 
    RECT r;
    GetItemRect(&r);
 
    if (PtInRect(&r, pt))
    {
        m_nLastMouseButton = nMsg;
 
        switch (nMsg)
        {
            case WM_LBUTTONDOWN:
            case WM_RBUTTONDOWN:
            {
                if (itemType == MENUITEM_EDITINT) ItemSetTimer();
                break;
            }
 
            case WM_LBUTTONUP:
            case WM_NCLBUTTONUP:
            {
                ItemKillTimer();
                Invoke(1);
                break;
            }
 
            case WM_RBUTTONUP:
            case WM_NCRBUTTONUP:
            {
                ItemKillTimer();
//              if ((itemType == MENUITEM_HEADER) && (GetAsyncKeyState(VK_MENU) & 0x8000)) m_pParent->TogglePinned();
                if ((itemType == MENUITEM_HEADER || itemType == MENUITEM_FOOTER) && (GetAsyncKeyState(VK_MENU) & 0x8000)) m_pParent->TogglePinned();
                else Invoke(2);
                break;
            }
 
            case WM_MBUTTONUP:
            case WM_NCMBUTTONUP:
            case WM_LBUTTONDBLCLK:
            case WM_NCLBUTTONDBLCLK:
            {
                // Mid click or left doubleclick on menu title or grip
                // -> Toggle pinned state for the menu...
//              if (itemType == MENUITEM_HEADER) m_pParent->TogglePinned();
                if (itemType == MENUITEM_HEADER || itemType == MENUITEM_FOOTER) m_pParent->TogglePinned();
                else Invoke(3);
                break;
            }
 
            case WM_MOUSEMOVE:
            case WM_NCMOUSEMOVE:
            {
                Active(true);
                break;
            }
 
            default:
                break;
        }
    }
    else Active(false);
}

Invoke()

void MenuItem::Invoke ( int button )

virtual

Reimplemented in SpecialFolder, and StringItem.

{
    if ((itemType == MENUITEM_HEADER) && (button == 2))
    {
//      if (!m_pParent->IsPinned()) pMenuCommon->Hide();
//      else if (m_pParent->m_pszFolderPath != NULL)
        if (m_pParent->m_pszFolderPath != NULL)
        {
            // ##### TODO: Move to MenuCommon along with similar code in SpecialFolder.cpp #####
            char folder[MAX_LINE_LENGTH], arg[MAX_LINE_LENGTH];
            strcpy(folder, m_pParent->m_pszFolderPath);
 
            if (strchr(folder, '|'))
            {
                // If this is a merged [path] item we use
                // the first path when right clicking on it...
                Tokenize(folder, arg, "|");
                strcpy(folder, arg); // Note: Just using arg as a temp variable here...
            }
 
            if (folder[0] == '\"') StrRemoveEncap(folder);
            strcpy(arg, "/e,");
            strcat(arg, folder);
 
            BBExecute(GetDesktopWindow(), NULL, "explorer.exe", arg, folder, SW_SHOWNORMAL, false);
            PlaySoundFX(SFX_MENU_CLICK);
        }
    }
    else if (itemType == MENUITEM_COMMAND || itemType == MENUITEM_BOOLEAN || itemType == MENUITEM_EDITINT) pMenuCommon->Invoke(this, button);
}

Active()

bool MenuItem::Active ( bool bActive )

virtual

Reimplemented in BroamMenu, ConsoleMenu, DesktopMenu, DockMenu, FolderItem, GlobalConfig, HotkeysMenu, MenuConfig, PluginBroamList, PluginMenu, SpecialFolder, StringItem, TaskbarMenu, ToolbarMenu, UnloadPluginMenu, and WorkspacesMenuItem.

{
    if (itemType != MENUITEM_COMMAND && bActive) pPreviewItem->Hide();
 
    if (itemType == MENUITEM_HEADER || itemType == MENUITEM_SEPARATOR || itemType == MENUITEM_NOP
        || itemType == MENUITEM_MARGINPAD || itemType == MENUITEM_FOOTER)
    {
        return false;
    }
 
    //====================
 
    // Has the menu item active state changed?
    if (m_bActive != bActive)
    {
        if (bActive)
        {
            // We only redraw the window when a new item becomes *active*...
            // (i.e. to avoid double redraws as active state moves from one item to another)
            pMenuCommon->FindActiveAndDeactivate(m_pParent, false);
            m_bActive = true;
            m_pParent->UpdateMenuWindow();
 
            // Should we also display an image preview for the new active item?
            if (bActive && (itemType == MENUITEM_COMMAND) && !_stricmp(m_pszCommand, "[exec]"))
            {
                char path[MAX_PATH];
                strcpy(path, m_pszArgument);
                if (strchr(path, '\"')) StrRemoveEncap(path);
                if (strchr(path, '$')) ReplaceShellFolders(path);
                if (strchr(path, '%')) ReplaceEnvVars(path);
                int pointer = strlen(path) - 4;
 
                if ((path[1] == ':') && (pointer > 0))
                {
                    if (!_stricmp(&path[pointer], ".jpg") || !_stricmp(&path[pointer], ".png") || !_stricmp(&path[pointer], ".bmp") || !_stricmp(&path[pointer], "jpeg"))
                    {
                        int screenWidth = GetSystemMetrics(SM_CXSCREEN);
                        int previewItemWidth = pPreviewItem->GetWidth();
 
                        RECT parentRect;
                        GetWindowRect(m_pParent->GetWindow(), &parentRect);
 
                        int gap = 2 * pSettings->scalingFactorHiDPI;
 
                        int x = parentRect.right + gap;
                        int y = parentRect.top + m_nTop + (m_nHeight / 2);
 
                        // If there isn't enough space for the preview item on the right hand
                        // side of the parent menu, we move it to the left hand side instead...
                        if ((x + previewItemWidth) > screenWidth) x = parentRect.left - gap - previewItemWidth;
 
                        pPreviewItem->Show(x, y, path);
                    }
                    else pPreviewItem->Hide();
                }
                else pPreviewItem->Hide();
            }
        }
        else m_bActive = false;
    }
 
    //====================
 
    if (!m_bActive) ItemKillTimer();
 
    //====================
 
    return m_bActive;
}

IsActive()

virtual bool MenuItem::IsActive ( )

virtual

{ return m_bActive; };

GetSortString()

virtual char * MenuItem::GetSortString ( )

virtual

{ return m_pszTitleANSI; };

GetItemRect()

void MenuItem::GetItemRect ( RECT * r )

virtual

{
    r->left = m_nLeft;
    r->top = m_nTop;
    r->right = m_nLeft + m_nWidth;
    r->bottom = m_nTop + m_nHeight;
}

GetTitleRect()

void MenuItem::GetTitleRect ( RECT * r )

virtual

{
    if (itemType == MENUITEM_HEADER || itemType == MENUITEM_FOOTER) // Header and grip items
    {
//      r->left = m_nLeft + pSettings->MenuTitle->borderWidth + pSettings->bevelWidth + 2;
        r->left = m_nLeft + pSettings->MenuTitle->borderWidth + 3;
        r->top = m_nTop;
//      r->right = m_nLeft + m_nWidth - pSettings->MenuTitle->borderWidth - pSettings->bevelWidth - 2;
        r->right = m_nLeft + m_nWidth - pSettings->MenuTitle->borderWidth - 3;
        r->bottom = m_nTop + m_nHeight;
        if (!_stricmp(pSettings->MenuTitle->Font, "nu")) r->bottom--;
    }
    else // Normal items
    {
        r->left = m_nLeft + pMenuCommon->m_nLeftIndent;
        r->top = m_nTop;
        r->right = m_nLeft + m_nWidth - pMenuCommon->m_nRightIndent;
        r->bottom = m_nTop + m_nHeight;
    }
}

GetDrawTextFormat()

UINT MenuItem::GetDrawTextFormat ( )

virtual

{
    if (itemType == MENUITEM_HEADER) // Header items
        return pSettings->MenuTitle->Justify | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_END_ELLIPSIS | DT_NOCLIP;
    if (itemType == MENUITEM_FOOTER) // Grip items
        return pSettings->MenuGrip->Justify | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_END_ELLIPSIS | DT_NOCLIP;
    else // Normal items
        return pSettings->MenuFrame->Justify | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_END_ELLIPSIS | DT_NOCLIP;
}

SetTitleANSI()

void MenuItem::SetTitleANSI ( char * pszTitleANSI )

virtual

{
    if (m_pszTitleANSI) free(m_pszTitleANSI);
    m_pszTitleANSI = NULL;
    m_pszTitleANSI = pszTitleANSI ? _strdup(pszTitleANSI) : _strdup("");;
}

SetTitleUnicode()

void MenuItem::SetTitleUnicode ( wchar_t * pszTitleUnicode )

virtual

{
    if (m_pszTitleUnicode) free(m_pszTitleUnicode);
    m_pszTitleUnicode = NULL;
    m_pszTitleUnicode = pszTitleUnicode ? _wcsdup(pszTitleUnicode) : _wcsdup(L"");;
}

AddToSelectionGroup()

void MenuItem::AddToSelectionGroup

(

int

group

)

{
    m_selectionGroup = group;
}

ItemSetTimer()

void MenuItem::ItemSetTimer

(

)

{
    if (m_nTimerId == 0)
    {
        // Wait 500 milliseconds until we start changing the value...
//      SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_WARNING_MESSAGE, (LPARAM)"Setting timer...");
        m_nTimerId = (UINT)this;
        SetTimer(GetWindow(), m_nTimerId, 500, NULL);
    }
}

Timer()

void MenuItem::Timer ( int nTimer )

virtual

Reimplemented in FolderItem, and WorkspacesMenuItem.

{
    // Execute timer messages...
    if ((UINT)nTimer == m_nTimerId)
    {
        // Update value and reset timer to 100 milliseconds... 
//      SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_WARNING_MESSAGE, (LPARAM)this->m_pszTitle);
        KillTimer(GetWindow(), m_nTimerId);
        if (m_nLastMouseButton == WM_RBUTTONDOWN) pMenuCommon->Invoke(this, 2);
        else pMenuCommon->Invoke(this, 1);
        SetTimer(GetWindow(), m_nTimerId, 100, NULL);
    }
}

ItemKillTimer()

void MenuItem::ItemKillTimer

(

)

{
    if (m_nTimerId != 0)
    {
//      SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_WARNING_MESSAGE, (LPARAM)"Killing timer...");
        KillTimer(GetWindow(), m_nTimerId);
        m_nTimerId = 0;
    }
}

SetWidth()

virtual void MenuItem::SetWidth ( int nWidth )

virtual

{ m_nWidth = nWidth; };

GetWidth()

virtual int MenuItem::GetWidth ( )

virtual

{ return m_nWidth; };

SetHeight()

virtual void MenuItem::SetHeight ( int nHeight )

virtual

{ m_nHeight = nHeight; };

GetHeight()

virtual int MenuItem::GetHeight ( )

virtual

{ return m_nHeight; };

SetPosition()

virtual void MenuItem::SetPosition ( int nLeft, int nTop )

virtual

{ m_nLeft = nLeft; m_nTop = nTop; };

SetSortPriority()

virtual void MenuItem::SetSortPriority ( int nSortPriority )

virtual

{ m_nSortPriority = nSortPriority; };

GetSortPriority()

virtual int MenuItem::GetSortPriority ( )

virtual

{ return m_nSortPriority; };

Compare()

bool MenuItem::Compare ( MenuItem * pM1, MenuItem * pM2 )

static

{
    // Menu item priorities:
    // MENUITEM_HEADER              -> 255
    // MENUITEM_MARGINPAD (top)     -> 254
    // MENUITEM_FOLDER              -> 4
    // MENUITEM_SEPARATOR           -> 3
    // === Regular items ===        -> 2
    // MENUITEM_MARGINPAD (bottom)  -> 1
    // MENUITEM_FOOTER              -> 0
 
    int m1_sort = m1->GetSortPriority();
    int m2_sort = m2->GetSortPriority();
 
    if (m1_sort == m2_sort)
    {
        if (m1->m_pszTitleUnicode != NULL)
        {
            if (m2->m_pszTitleUnicode != NULL) return _wcsicmp(m1->m_pszTitleUnicode, m2->m_pszTitleUnicode) < 0; // -> Both m1 and m2 are Unicode items, do a regular string compare...
            else return true; // -> m1 being a Unicode item is sorted before m2 being an ANSI item...
        }
        else if (m2->m_pszTitleUnicode != NULL) return false;
        else return _stricmp(m1->GetSortString(), m2->GetSortString()) < 0; // -> Both m1 and m2 are ANSI items, do a regular string compare...
    }
    else return m1_sort > m2_sort;
}

Attached()

void MenuItem::Attached ( Menu * pMenu )

virtual

Reimplemented in BroamMenu, ConsoleMenu, DesktopMenu, DockMenu, FolderItem, GlobalConfig, HotkeysMenu, MenuConfig, PluginBroamList, PluginMenu, SpecialFolder, TaskbarMenu, ToolbarMenu, UnloadPluginMenu, and WorkspacesMenuItem.

{
    m_pParent = pMenu;
}

Command()

LRESULT MenuItem::Command ( WPARAM wParam, LPARAM lParam )

virtual

{
    return 0;
}

OnUser()

virtual bool MenuItem::OnUser ( int nMessage, WPARAM wParam, LPARAM lParam, LRESULT & lResult )

virtual

{ return false; }

Moving()

virtual void MenuItem::Moving ( )

virtual

{;};

GetWindow()

HWND MenuItem::GetWindow ( )

virtual

{
    if (m_pParent) return m_pParent->GetWindow();
    else return NULL;
}

ToggleSelected()

void MenuItem::ToggleSelected

(

)

{
    if (m_isSelected) m_isSelected = false;
    else m_isSelected = true;
}

Member Data Documentation

m_pszTitleANSI

char* MenuItem::m_pszTitleANSI

m_pszTitleUnicode

wchar_t* MenuItem::m_pszTitleUnicode

itemType

int MenuItem::itemType

m_pszCommand

char* MenuItem::m_pszCommand

m_pszArgument

char* MenuItem::m_pszArgument

m_pszOriginalTitleANSI

char* MenuItem::m_pszOriginalTitleANSI

m_pszOriginalTitleUnicode

wchar_t* MenuItem::m_pszOriginalTitleUnicode

m_isSelected

bool MenuItem::m_isSelected

m_selectionGroup

int MenuItem::m_selectionGroup

m_currentValue

int MenuItem::m_currentValue

m_minValue

int MenuItem::m_minValue

m_maxValue

int MenuItem::m_maxValue

m_mousePos

POINT MenuItem::m_mousePos

m_nSortPriority

int MenuItem::m_nSortPriority

m_pParent

Menu* MenuItem::m_pParent

m_pSubMenu

Menu* MenuItem::m_pSubMenu

m_nLeft

int MenuItem::m_nLeft

m_nTop

int MenuItem::m_nTop

m_nWidth

int MenuItem::m_nWidth

m_nHeight

int MenuItem::m_nHeight

m_bActive

bool MenuItem::m_bActive

m_nTimerId

UINT MenuItem::m_nTimerId

m_nLastMouseButton

int MenuItem::m_nLastMouseButton