#include <MenuNode.h>

Inheritance diagram for Kwave::MenuNode:

Collaboration diagram for Kwave::MenuNode:

Signals
void	sigCommand (const QString &command)

Public Member Functions
	MenuNode (Kwave::MenuNode *parent, const QString &name, const QString &command, const QKeySequence &shortcut, const QString &uid)

virtual	~MenuNode ()

const QString	path () const

const QString &	name () const

const QString &	command () const

virtual QAction *	action ()

const QString &	uid () const

void	setUID (const QString &uid)

const QKeySequence &	shortcut () const

virtual void	setShortcut (const QKeySequence &shortcut)

virtual const QIcon	icon ()

virtual void	setIcon (const QIcon &icon)

virtual bool	isBranch () const

virtual void	clear ()

virtual Kwave::MenuNode *	parentNode () const

virtual void	setVisible (bool visible)

virtual bool	isEnabled ()

virtual void	setEnabled (bool enable)

virtual void	setChecked (bool check)

virtual void	setText (const QString &text)

Kwave::MenuNode *	findUID (const QString &uid)

Kwave::MenuNode *	findChild (const QString &name)

virtual void	removeChild (Kwave::MenuNode *child)

virtual Kwave::MenuSub *	insertBranch (const QString &name, const QString &command, const QKeySequence &shortcut, const QString &uid)

virtual Kwave::MenuNode *	insertLeaf (const QString &name, const QString &command, const QKeySequence &shortcut, const QString &uid)

virtual void	insertChild (Kwave::MenuNode node, Kwave::MenuNode before)

virtual void	insertNode (const QString &name, const QString &position, const QString &command, const QKeySequence &shortcut, const QString &uid)

virtual Kwave::MenuNode *	leafToBranch (Kwave::MenuNode *node)

virtual bool	specialCommand (const QString &command)

virtual void	actionSelected ()

virtual QHash< QString, Kwave::MenuGroup * > &	groupList ()

void	joinGroup (const QString &group, Kwave::MenuGroup::Mode mode)

void	leaveGroup (const QString &group)

Protected Member Functions
Kwave::MenuNode *	rootNode ()

void	emitCommand (const QString &command)

Protected Attributes
QList< Kwave::MenuNode * >	m_children

QStringList	m_groups

Private Attributes
QString	m_uid

QKeySequence	m_shortcut

QString	m_name

QString	m_command

Kwave::MenuNode *	m_parentNode

Detailed Description

Base class for the MenuItem, MenuSub and the MenuRoot class.

Definition at line 43 of file MenuNode.h.

Constructor & Destructor Documentation

◆ MenuNode()

Kwave::MenuNode::MenuNode	(	Kwave::MenuNode *	parent,
		const QString &	name,
		const QString &	command,
		const QKeySequence &	shortcut,
		const QString &	uid
	)

Constructor.

Parameters

parent	pointer to the node's parent (might be 0)
name	the non-localized name of the node
command	the command to be sent when the node is selected (optional, default=0)
shortcut	keyboard shortcut (optional, default=0)
uid	unique id string (optional, default=0)

Definition at line 35 of file MenuNode.cpp.

     :QObject(), m_children(), m_groups(), m_uid(uid), m_shortcut(shortcut),
      m_name(name), m_command(command), m_parentNode(parent)
 {
 }

◆ ~MenuNode()

Kwave::MenuNode::~MenuNode ( )

virtual

Destructor. Clears the menu node and cleans up.

See also: clear()

Definition at line 46 of file MenuNode.cpp.

References clear(), leaveGroup(), m_groups, m_parentNode, and removeChild().

 {
     // leave all groups
     QStringList::iterator group = m_groups.begin();
     while (group != m_groups.end()) {
         leaveGroup(*group);
         group = m_groups.begin();
     }
 
     // remove all childs
     clear();
 
     // de-register from our parent
     if (m_parentNode) m_parentNode->removeChild(this);
 }

Here is the call graph for this function:

Member Function Documentation

◆ action()

virtual QAction* Kwave::MenuNode::action ( )

inlinevirtual

Returns the corresponding menu action

Reimplemented in Kwave::MenuItem, and Kwave::MenuSub.

Definition at line 80 of file MenuNode.h.

Referenced by Kwave::MenuRoot::hideChild(), Kwave::MenuSub::insertLeaf(), Kwave::MenuGroup::join(), Kwave::MenuGroup::leave(), Kwave::MenuSub::removeChild(), Kwave::MenuRoot::removeChild(), and Kwave::MenuRoot::showChild().

80 { return Q_NULLPTR; }

Here is the caller graph for this function:

◆ actionSelected()

void Kwave::MenuNode::actionSelected ( )

virtual

Called to notify the node that it has been selected.

Reimplemented in Kwave::MenuItem.

Definition at line 87 of file MenuNode.cpp.

References emitCommand(), and m_command.

Referenced by Kwave::MenuItem::actionSelected(), and isBranch().

 {
     if (m_command.length()) emitCommand(m_command);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear()

void Kwave::MenuNode::clear ( )

virtual

Removes all child entries from the menu node (gui) and deletes the MenuNode objects (memory).

Reimplemented in Kwave::MenuList.

Definition at line 93 of file MenuNode.cpp.

References m_children.

Referenced by Kwave::MenuManager::clearNumberedMenu(), isBranch(), ~MenuNode(), and Kwave::MenuRoot::~MenuRoot().

 {
     // remove all children
     while (!m_children.isEmpty()) {
         Kwave::MenuNode *child = m_children.takeLast();
         delete child;
     }
 }

Here is the caller graph for this function:

◆ command()

const QString& Kwave::MenuNode::command ( ) const

inline

Returns the command of the node.

Definition at line 77 of file MenuNode.h.

References m_command.

Referenced by Kwave::MenuManager::addNumberedMenuEntry(), and leafToBranch().

77 { return m_command; }

Kwave::MenuNode::m_command

QString m_command

Definition: MenuNode.h:334

Here is the caller graph for this function:

◆ emitCommand()

void Kwave::MenuNode::emitCommand ( const QString & command )

protected

Emits a command if the node is the root node. If it is a client node it will call the root node's emitCommand() function.

See also: emitCommand(); rootNode()

Definition at line 70 of file MenuNode.cpp.

References emitCommand(), parentNode(), rootNode(), and sigCommand().

Referenced by actionSelected(), emitCommand(), and isBranch().

 {
     Q_ASSERT(command.length());
     if (!command.length()) return ;
 
     if (!parentNode()) {
         // no parent -> we are the root node -> we have to emit
         emit sigCommand(command);
     } else {
         // tell the root node to emit
         Kwave::MenuNode *root = rootNode();
         Q_ASSERT(root);
         if (root) root->emitCommand(command);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ findChild()

Kwave::MenuNode * Kwave::MenuNode::findChild ( const QString & name )

Tries to find a child node by it's name.

Parameters

name	non-localized name of the child node

Returns: pointer to the found node or 0 if not found

Definition at line 211 of file MenuNode.cpp.

References m_children, and name().

Referenced by insertNode(), and isBranch().

 {
     Q_ASSERT(name.length());
 
     foreach (Kwave::MenuNode *child, m_children) {
         if (child && (name == child->name()))
             return child;
     }
     return Q_NULLPTR;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ findUID()

Kwave::MenuNode * Kwave::MenuNode::findUID ( const QString & uid )

Tries to find a menu node by it's unique id string. It descends recursively through all child nodes if necessary.

Parameters

uid	the unique id string to be searched

Returns: pointer to the found node or 0 if not found

Definition at line 198 of file MenuNode.cpp.

References findUID(), m_children, and m_uid.

Referenced by Kwave::MenuManager::addNumberedMenuEntry(), Kwave::MenuList::clear(), Kwave::MenuManager::clearNumberedMenu(), findUID(), isBranch(), Kwave::MenuManager::setItemChecked(), Kwave::MenuManager::setItemEnabled(), Kwave::MenuManager::setItemText(), Kwave::MenuManager::setItemVisible(), and specialCommand().

 {
     if (m_uid == uid) return this;    // found ourself
 
     foreach (Kwave::MenuNode *child, m_children) {
         Kwave::MenuNode *node = (child) ? child->findUID(uid) : Q_NULLPTR;
         if (node) return node;    // found in child
     }
 
     return Q_NULLPTR;    // nothing found :-(
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ groupList()

QHash< QString, Kwave::MenuGroup * > & Kwave::MenuNode::groupList ( )

virtual

Returns a reference to the list of groups. It recursively calls all parent node's groupList() function until it reaches the root node of the menu structure that holds the list of groups and overwrites this function.

Returns: reference to the list of groups

Reimplemented in Kwave::MenuRoot.

Definition at line 370 of file MenuNode.cpp.

References groupList(), and m_parentNode.

Referenced by groupList(), isBranch(), isEnabled(), joinGroup(), leaveGroup(), Kwave::MenuGroup::MenuGroup(), and Kwave::MenuGroup::~MenuGroup().

 {
     static QHash<QString, Kwave::MenuGroup *> _empty_list;
     Q_ASSERT(m_parentNode);
     return (m_parentNode) ? m_parentNode->groupList() : _empty_list;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ icon()

const QIcon Kwave::MenuNode::icon ( )

virtual

Returns the menu nodes' icon.

Reimplemented in Kwave::MenuSub, and Kwave::MenuItem.

Definition at line 115 of file MenuNode.cpp.

Referenced by leafToBranch(), setShortcut(), and specialCommand().

 {
     static QIcon dummy;
     Q_ASSERT(dummy.isNull());
     return dummy;
 }

Here is the caller graph for this function:

◆ insertBranch()

Kwave::MenuSub * Kwave::MenuNode::insertBranch	(	const QString &	name,
		const QString &	command,
		const QKeySequence &	shortcut,
		const QString &	uid
	)

virtual

Inserts a new branch node into the menu structure. The new node normally is (derived from) MenuSub.

Parameters

name	non-localized name of the node
command	the command template used for creating commands of submenus (leafes) that don't have an own command but contain data for their parent's command. Should contain a s that will be replaced by some data from a child entry. (this is used for menus with data selection lists like "recent files) If not used, pass 0.
shortcut	keyboard shortcut, 0 if unused
uid	unique id string (might be 0)

Returns: pointer to the new branch node

Reimplemented in Kwave::MenuRoot, and Kwave::MenuSub.

Definition at line 230 of file MenuNode.cpp.

Referenced by insertNode(), isBranch(), and leafToBranch().

 {
     Q_UNUSED(name);
     Q_UNUSED(command);
     Q_UNUSED(shortcut);
     Q_UNUSED(uid);
     return Q_NULLPTR;
 }

Here is the caller graph for this function:

◆ insertChild()

void Kwave::MenuNode::insertChild	(	Kwave::MenuNode *	node,
		Kwave::MenuNode *	before
	)

virtual

Registers a node as a child of the current node.

Parameters

node	pointer to the child node
before	the node before which the node should be inserted (optional, can be null for "append")

Definition at line 181 of file MenuNode.cpp.

References m_children.

Referenced by Kwave::MenuSub::insertBranch(), Kwave::MenuRoot::insertBranch(), Kwave::MenuSub::insertLeaf(), Kwave::MenuRoot::insertLeaf(), isBranch(), and specialCommand().

 {
     if (!node) return;
     if (before && m_children.contains(before))
         m_children.insert(m_children.indexOf(before), node);
     else
         m_children.append(node);
 }

Here is the caller graph for this function:

◆ insertLeaf()

Kwave::MenuNode * Kwave::MenuNode::insertLeaf	(	const QString &	name,
		const QString &	command,
		const QKeySequence &	shortcut,
		const QString &	uid
	)

virtual

Inserts a new leaf node into the menu structure. The new node normally is (derived from) MenuItem.

Parameters

name	non-localized name of the node
command	the command to be sent when the node is selected (might be 0)
shortcut	keyboard shortcut, 0 if unused
uid	unique id string (might be 0)

Returns: pointer to the new leaf node

Reimplemented in Kwave::MenuRoot, Kwave::MenuSub, and Kwave::MenuList.

Definition at line 243 of file MenuNode.cpp.

Referenced by Kwave::MenuManager::addNumberedMenuEntry(), Kwave::MenuList::insertLeaf(), insertNode(), and isBranch().

 {
     Q_UNUSED(name);
     Q_UNUSED(command);
     Q_UNUSED(shortcut);
     Q_UNUSED(uid);
     return Q_NULLPTR;
 }

Here is the caller graph for this function:

◆ insertNode()

void Kwave::MenuNode::insertNode	(	const QString &	name,
		const QString &	position,
		const QString &	command,
		const QKeySequence &	shortcut,
		const QString &	uid
	)

virtual

Inserts a new child node into the structure. If the specified position contains a path that doesn't completely exist, all missing branches will be appended.

Parameters

name	non-localized name of the first node (might be 0)
position	path consiting of several node names separated by a '/'. All strings are non-localized.
command	the command to be sent when the node is selected (might be 0)
shortcut	keyboard shortcut, 0 if unused
uid	unique id string (might be 0)

Reimplemented in Kwave::MenuRoot.

Definition at line 256 of file MenuNode.cpp.

References findChild(), insertBranch(), insertLeaf(), insertNode(), isBranch(), leafToBranch(), setShortcut(), setUID(), and specialCommand().

Referenced by Kwave::MenuRoot::insertNode(), insertNode(), and isBranch().

 {
     int pos = 0;
 
     if (!position.length()) {
         qWarning("MenuNode::insertNode: no position!");
         return;
     }
 
     // at start of the parsing process ?
     if (!name.length()) {
         // split off the first token, separated by a slash
         pos = position.indexOf(QLatin1Char('/'));
         if (pos < 0) pos = position.length();
     }
 
     QString n = position.left(pos);
     QString p = position;
     p.remove(0, pos + 1);
 
     if ((n.length()) && (specialCommand(n))) {
         // no new branch, only a special command
         return;
     }
 
     if ((!p.length()) || (p[0] == QLatin1Char('#'))) {
         // end of the tree
         Kwave::MenuNode *sub = findChild(n);
         if (sub) {
             // a leaf with this name already exists
             // -> maybe we want to set new properties
             if (!shortcut.isEmpty()) sub->setShortcut(shortcut);
 
             if (uid.length()) sub->setUID(uid);
 
         } else {
             // insert a new leaf
             sub = insertLeaf(n, command, shortcut, uid);
             if (!sub) return;
         }
 
         if (p[0] == QLatin1Char('#')) sub->specialCommand(p);
 
     } else {
         // somewhere in the tree
         Kwave::MenuNode *sub = findChild(n);
         if (!sub) {
             sub = insertBranch(n, command, shortcut, uid);
         } else if ( !sub->isBranch() && (p[0] != QLatin1Char('#'))) {
             // remove the "leaf" and insert a branch with
             // the same properties
             sub = leafToBranch(sub);
         } else if (!p.length() || (p[0] == QLatin1Char('#')) ) {
             // branch already exists and we are at the end of parsing
             // -> maybe we want to set new properties
             if (!shortcut.isEmpty()) sub->setShortcut(shortcut);
             if (uid.length()) sub->setUID(uid);
         }
 
         if (sub) {
             sub->insertNode(QString(), p, command, shortcut, uid);
         } else {
             qDebug("MenuNode::insertNode: branch failed!");
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isBranch()

virtual bool Kwave::MenuNode::isBranch ( ) const

inlinevirtual

Returns true if the node is a branch, false if it is a leaf. (overwritten in MenuSub etc.)

Reimplemented in Kwave::MenuSub, and Kwave::MenuList.

Definition at line 119 of file MenuNode.h.

References actionSelected(), clear(), emitCommand(), findChild(), findUID(), groupList(), insertBranch(), insertChild(), insertLeaf(), insertNode(), isEnabled(), joinGroup(), leafToBranch(), leaveGroup(), parentNode(), removeChild(), rootNode(), setChecked(), setEnabled(), setText(), setVisible(), sigCommand(), and specialCommand().

Referenced by insertNode(), and specialCommand().

119 { return false; }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isEnabled()

bool Kwave::MenuNode::isEnabled ( )

virtual

Returns true if the node is enabled.

Reimplemented in Kwave::MenuSub, and Kwave::MenuItem.

Definition at line 130 of file MenuNode.cpp.

References DBG, groupList(), Kwave::MenuGroup::isEnabled(), isEnabled(), m_groups, m_parentNode, name(), and rootNode().

Referenced by isBranch(), Kwave::MenuItem::isEnabled(), Kwave::MenuSub::isEnabled(), isEnabled(), and leafToBranch().

 {
     // evaluate our own (individual) enable and our parent's enable state
     if (m_parentNode && !m_parentNode->isEnabled())
         return false;
 
     // find  out if all our groups are enabled
     QHash<QString, Kwave::MenuGroup *> &groups = groupList();
     Kwave::MenuNode *root = rootNode();
     if (root) {
         foreach (const QString &group_name, m_groups) {
             if (groups.contains(group_name)) {
                 Kwave::MenuGroup *group = groups[group_name];
                 if (group && !group->isEnabled()) {
                     qDebug("MenuNode(%s).isEnabled(): group %s is disabled",
                            DBG(name()), DBG(group_name));
                     return false;
                 }
             }
         }
     }
 
     // if we get here, everything is enabled
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ joinGroup()

void Kwave::MenuNode::joinGroup	(	const QString &	group,
		Kwave::MenuGroup::Mode	mode
	)

Adds the node to a group. If it is already a member of the group this function will do nothing.

Parameters

group	name of the group
mode	the mode of the group (normal or exclusive)

Definition at line 378 of file MenuNode.cpp.

References groupList(), Kwave::MenuGroup::join(), m_groups, and rootNode().

Referenced by isBranch(), leafToBranch(), Kwave::MenuItem::specialCommand(), and specialCommand().

 {
     if (m_groups.contains(group))
         return;    // already joined
 
     QHash<QString, Kwave::MenuGroup *> &group_list = groupList();
     Kwave::MenuGroup *grp = Q_NULLPTR;
     if (group_list.contains(group)) {
         grp = group_list[group];
     } else {
         // group does not already exist, create a new one
         grp = new(std::nothrow) Kwave::MenuGroup(rootNode(), group, mode);
         if (grp) group_list.insert(group, grp);
     }
 
     // remember that we now belong to the given group
     m_groups.append(group);
 
     // register this node as a child of the group
     if (grp) grp->join(this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ leafToBranch()

Kwave::MenuNode * Kwave::MenuNode::leafToBranch ( Kwave::MenuNode * node )

virtual

Converts a child node from leaf to branch type by removing the leaf and inserting a branch with the same properties instead.

Parameters

node	the child node to be converted

Returns: pointer to the new branch node

Definition at line 328 of file MenuNode.cpp.

References command(), Kwave::MenuRoot::deleteLater(), icon(), insertBranch(), isEnabled(), joinGroup(), m_groups, name(), Kwave::MenuGroup::NORMAL, removeChild(), Kwave::MenuSub::setEnabled(), Kwave::MenuSub::setIcon(), shortcut(), and uid().

Referenced by insertNode(), isBranch(), and specialCommand().

 {
     Q_ASSERT(node);
     Q_ASSERT(node != this);
 
     if (!node || (node == this)) return Q_NULLPTR;
 
     // get the old properties
     bool old_enable           = node->isEnabled();
     QKeySequence old_shortcut = node->shortcut();
     QString old_uid           = node->uid();
     QIcon old_icon            = node->icon();
     QString name              = node->name();
     QString command           = node->command();
     QStringList old_groups    = node->m_groups;
 
     // remove the old child node
     removeChild(node);
 
     // insert the new branch
     Kwave::MenuSub *sub = insertBranch(name, command, old_shortcut, old_uid);
     if (sub) {
         // join it to the same groups
         foreach (const QString &group, old_groups)
             sub->joinGroup(group, Kwave::MenuGroup::NORMAL);
 
         // set the old icon
         if (!old_icon.isNull()) sub->setIcon(old_icon);
 
         // set the "enable"
         sub->setEnabled(old_enable);
     }
 
     // free the old node later.
     // IMPORTANT: we must not call "delete node" now, because we get called
     //            through leafToBranch(this) !
     Kwave::MenuRoot::deleteLater(node);
 
     return sub;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ leaveGroup()

void Kwave::MenuNode::leaveGroup ( const QString & group )

Removes the node from a group (opposite of joinGroup).

Parameters

group name of the group

Definition at line 402 of file MenuNode.cpp.

References groupList(), Kwave::MenuGroup::isEmpty(), Kwave::MenuGroup::leave(), and m_groups.

Referenced by isBranch(), and ~MenuNode().

 {
     QHash<QString, Kwave::MenuGroup *> &group_list = groupList();
     Kwave::MenuGroup *grp = (group_list.contains(group)) ?
         group_list.value(group) : Q_NULLPTR;
 
     // remove the group from our list
     m_groups.removeAll(group);
 
     // remove ourself from the group
     if (grp) {
         grp->leave(this);
 
         // clean up the group if nobody uses it any more
         if (grp->isEmpty()) delete grp;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ name()

const QString& Kwave::MenuNode::name ( ) const

inline

Returns the (non-localized) name of the node.

Definition at line 74 of file MenuNode.h.

References m_name.

Referenced by Kwave::MenuList::clear(), findChild(), Kwave::MenuRoot::hideChild(), Kwave::MenuList::insertLeaf(), Kwave::MenuSub::insertLeaf(), Kwave::MenuList::isBranch(), isEnabled(), leafToBranch(), Kwave::MenuRoot::removeChild(), setIcon(), Kwave::MenuRoot::showChild(), Kwave::MenuItem::specialCommand(), and specialCommand().

74 { return m_name; }

Kwave::MenuNode::m_name

QString m_name

Definition: MenuNode.h:331

Here is the caller graph for this function:

◆ parentNode()

Kwave::MenuNode * Kwave::MenuNode::parentNode ( ) const

virtual

returns a pointer to the menu's parent node

Definition at line 103 of file MenuNode.cpp.

References m_parentNode.

Referenced by Kwave::MenuManager::addNumberedMenuEntry(), Kwave::MenuList::clear(), emitCommand(), Kwave::MenuList::insertLeaf(), isBranch(), Kwave::MenuSub::setVisible(), and specialCommand().

 {
     return m_parentNode;
 }

Here is the caller graph for this function:

◆ path()

const QString Kwave::MenuNode::path ( ) const

Returns the path of this menu entry

Definition at line 63 of file MenuNode.cpp.

References _, m_name, m_parentNode, and path().

Referenced by Kwave::MenuItem::MenuItem(), Kwave::MenuSub::MenuSub(), and path().

 {
     return (m_parentNode) ?
         (m_parentNode->path() + _("/") + m_name) : QString();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ removeChild()

void Kwave::MenuNode::removeChild ( Kwave::MenuNode * child )

virtual

Removes a child node of the current node. If the child was not found or is already removed this does nothing.

Parameters

child pointer to the child node

Reimplemented in Kwave::MenuRoot, and Kwave::MenuSub.

Definition at line 223 of file MenuNode.cpp.

References m_children.

Referenced by Kwave::MenuList::clear(), isBranch(), leafToBranch(), Kwave::MenuSub::removeChild(), Kwave::MenuRoot::removeChild(), and ~MenuNode().

 {
     if (child && !m_children.isEmpty())
         m_children.removeAll(child);
 }

Here is the caller graph for this function:

◆ rootNode()

Kwave::MenuNode * Kwave::MenuNode::rootNode ( )

protected

Returns the address of the root node of the menu structure.

Definition at line 109 of file MenuNode.cpp.

References m_parentNode, and rootNode().

Referenced by emitCommand(), isBranch(), isEnabled(), joinGroup(), rootNode(), and Kwave::MenuSub::setVisible().

 {
     return (m_parentNode) ? m_parentNode->rootNode() : this;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setChecked()

void Kwave::MenuNode::setChecked ( bool check )

virtual

Sets/removes the checkmark from the current menu node.

Parameters

check true to set the mark, false to remove

Reimplemented in Kwave::MenuItem.

Definition at line 169 of file MenuNode.cpp.

Referenced by isBranch(), Kwave::MenuGroup::selectItem(), and Kwave::MenuManager::setItemChecked().

 {
     Q_UNUSED(check);
 }

Here is the caller graph for this function:

◆ setEnabled()

void Kwave::MenuNode::setEnabled ( bool enable )

virtual

Enables/disables the current menu node.

Parameters

enable true to enable the item, false to disable

Reimplemented in Kwave::MenuSub, and Kwave::MenuItem.

Definition at line 163 of file MenuNode.cpp.

Referenced by isBranch(), Kwave::MenuGroup::setEnabled(), Kwave::MenuManager::setItemEnabled(), and specialCommand().

 {
     Q_UNUSED(enable);
 }

Here is the caller graph for this function:

◆ setIcon()

void Kwave::MenuNode::setIcon ( const QIcon & icon )

virtual

Sets a new icon of a menu node.

Parameters

icon	QIcon with the icon

Reimplemented in Kwave::MenuSub, and Kwave::MenuItem.

Definition at line 123 of file MenuNode.cpp.

References DBG, and name().

Referenced by setShortcut(), and specialCommand().

 {
     qWarning("MenuNode(%s)::setIcon(%p)",
         DBG(name()), reinterpret_cast<const void *>(&icon));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setShortcut()

virtual void Kwave::MenuNode::setShortcut ( const QKeySequence & shortcut )

inlinevirtual

Sets the bitmask of the keyboard shortcut.

Definition at line 100 of file MenuNode.h.

References icon(), m_shortcut, setIcon(), and shortcut().

Referenced by insertNode().

                                                                {
             m_shortcut = shortcut;
         }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setText()

void Kwave::MenuNode::setText ( const QString & text )

virtual

Sets the visible text of an item to a new value. (Only useful for a MenuItem)

Parameters

text	the new text

Reimplemented in Kwave::MenuItem.

Definition at line 175 of file MenuNode.cpp.

Referenced by isBranch(), and Kwave::MenuManager::setItemText().

 {
     Q_UNUSED(text);
 }

Here is the caller graph for this function:

◆ setUID()

void Kwave::MenuNode::setUID ( const QString & uid )

Sets the unique id string of the node

Definition at line 192 of file MenuNode.cpp.

References m_uid, and uid().

Referenced by insertNode(), and uid().

 {
     m_uid = uid;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setVisible()

void Kwave::MenuNode::setVisible ( bool visible )

virtual

Shows/hides the current menu node.

Parameters

visible true to show the item, false to hide

Reimplemented in Kwave::MenuSub, and Kwave::MenuItem.

Definition at line 157 of file MenuNode.cpp.

Referenced by isBranch(), and Kwave::MenuManager::setItemVisible().

 {
     Q_UNUSED(visible);
 }

Here is the caller graph for this function:

◆ shortcut()

const QKeySequence& Kwave::MenuNode::shortcut ( ) const

inline

Returns the bitmask of the keyboard shortcut.

Definition at line 95 of file MenuNode.h.

References m_shortcut.

Referenced by Kwave::MenuList::isBranch(), leafToBranch(), and setShortcut().

95 { return m_shortcut; }

Kwave::MenuNode::m_shortcut

QKeySequence m_shortcut

Definition: MenuNode.h:328

Here is the caller graph for this function:

◆ sigCommand

void Kwave::MenuNode::sigCommand ( const QString & command )

signal

Will be emitted if the command of the menu node should be executed. It will only be emitted by the root node, client nodes call the root node's emitCommand() function.

See also: emitCommand(); rootNode()

Referenced by emitCommand(), and isBranch().

Here is the caller graph for this function:

◆ specialCommand()

bool Kwave::MenuNode::specialCommand ( const QString & command )

virtual

Handles/interpretes special menu commands.

Parameters

command name of a menu node or command

Returns: true if the name was recognized as a command and handled

Reimplemented in Kwave::MenuRoot, Kwave::MenuSub, and Kwave::MenuItem.

Definition at line 421 of file MenuNode.cpp.

References _, Kwave::Parser::command(), DBG, findUID(), Kwave::Parser::firstParam(), icon(), insertChild(), isBranch(), joinGroup(), leafToBranch(), name(), Kwave::Parser::nextParam(), Kwave::MenuGroup::NORMAL, parentNode(), setEnabled(), setIcon(), and uid().

Referenced by insertNode(), isBranch(), Kwave::MenuItem::specialCommand(), Kwave::MenuSub::specialCommand(), and Kwave::MenuRoot::specialCommand().

 {
     Kwave::Parser parser(command);
 
     if (parser.command() == _("#icon")) {
         // --- give the item an icon ---
         const QString &icon_name = parser.firstParam();
         if ( icon_name.length()) {
             // try to load from standard dirs
             QIcon icon = QIcon::fromTheme( icon_name );
             if (!icon.isNull()) {
                 setIcon(icon);
             } else {
                 qWarning("MenuNode '%s': icon '%s' not found !",
                     DBG(name()), DBG( icon_name ));
             }
         }
         return true;
     }
 
     if (parser.command() == _("#listmenu")) {
         // make sure that the current node is a sub menu
         Kwave::MenuNode *parent = parentNode();
         Kwave::MenuNode *sub = (parent && !isBranch()) ?
             parent->leafToBranch(this) : this;
         if (!sub) return false;
 
         // append a placeholder for inserting the list
         // (if it does not already exist)
         const QString uid = parser.firstParam();
         const QString cmd = parser.nextParam();
         if (!sub->findUID(uid)) {
             Kwave::MenuList *placeholder =
                 new(std::nothrow) Kwave::MenuList(sub, cmd, uid);
             Q_ASSERT(placeholder);
             if (!placeholder) return false;
 
             sub->insertChild(placeholder, Q_NULLPTR);
         }
         return true;
     }
 
     if (parser.command() == _("#group")) {
         QString group = parser.firstParam();
         while (group.length()) {
             joinGroup(group, Kwave::MenuGroup::NORMAL);
             group = parser.nextParam();
         }
         return true;
     }
 
     if (command == _("#disabled")) {
         // disable the node
         setEnabled(false);
         return true;
     }
 
     if (command == _("#enabled")) {
         // enable the node
         setEnabled(true);
         return true;
     }
 
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ uid()

const QString& Kwave::MenuNode::uid ( ) const

inline

Returns the unique id string of the node.

Definition at line 85 of file MenuNode.h.

References m_uid, and setUID().

Referenced by Kwave::MenuSub::insertLeaf(), leafToBranch(), Kwave::MenuGroup::selectItem(), setUID(), and specialCommand().

85 { return m_uid; }

Kwave::MenuNode::m_uid

QString m_uid

Definition: MenuNode.h:325

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ m_children

QList<Kwave::MenuNode *> Kwave::MenuNode::m_children

protected

list with pointers to child menus

Definition at line 317 of file MenuNode.h.

Referenced by clear(), findChild(), findUID(), Kwave::MenuRoot::hideChild(), insertChild(), Kwave::MenuSub::insertLeaf(), Kwave::MenuRoot::removeChild(), removeChild(), and Kwave::MenuRoot::showChild().

◆ m_command

QString Kwave::MenuNode::m_command

private

command to be sent when the node is activated (optional)

Definition at line 334 of file MenuNode.h.

Referenced by actionSelected(), and command().

◆ m_groups

QStringList Kwave::MenuNode::m_groups

protected

list of group names the item belongs to

Definition at line 320 of file MenuNode.h.

Referenced by isEnabled(), joinGroup(), leafToBranch(), leaveGroup(), and ~MenuNode().

◆ m_name

QString Kwave::MenuNode::m_name

private

name of the node (non-localized)

Definition at line 331 of file MenuNode.h.

Referenced by name(), and path().

◆ m_parentNode

Kwave::MenuNode* Kwave::MenuNode::m_parentNode

private

parent of this entry

Definition at line 337 of file MenuNode.h.

Referenced by groupList(), isEnabled(), parentNode(), path(), rootNode(), and ~MenuNode().

◆ m_shortcut

QKeySequence Kwave::MenuNode::m_shortcut

private

bitmask of the keyboard shortcut

Definition at line 328 of file MenuNode.h.

Referenced by setShortcut(), and shortcut().

◆ m_uid

QString Kwave::MenuNode::m_uid

private

unique id string

Definition at line 325 of file MenuNode.h.

Referenced by findUID(), setUID(), and uid().

The documentation for this class was generated from the following files:

libgui/MenuNode.h
libgui/MenuNode.cpp

Signals

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MenuNode()

◆ ~MenuNode()

Member Function Documentation

◆ action()

◆ actionSelected()

◆ clear()

◆ command()

◆ emitCommand()

◆ findChild()

◆ findUID()

◆ groupList()

◆ icon()

◆ insertBranch()

◆ insertChild()

◆ insertLeaf()

◆ insertNode()

◆ isBranch()

◆ isEnabled()

◆ joinGroup()

◆ leafToBranch()

◆ leaveGroup()

◆ name()

◆ parentNode()

◆ path()

◆ removeChild()

◆ rootNode()

◆ setChecked()

◆ setEnabled()

◆ setIcon()

◆ setShortcut()

◆ setText()

◆ setUID()

◆ setVisible()

◆ shortcut()

◆ sigCommand

◆ specialCommand()

◆ uid()

Member Data Documentation

◆ m_children

◆ m_command

◆ m_groups

◆ m_name

◆ m_parentNode

◆ m_shortcut

◆ m_uid