Kwave::MenuManager Class Reference

Manager class for access to Kwave's menu subsystem. More...

#include <MenuManager.h>

Inheritance diagram for Kwave::MenuManager:

Collaboration diagram for Kwave::MenuManager:

Public Slots
void	setItemChecked (const QString &uid, bool check)
void	setItemEnabled (const QString &uid, bool enable)

Signals
void	sigMenuCommand (const QString &command)

Public Member Functions
	MenuManager (QWidget *parent, QMenuBar &bar)
virtual	~MenuManager ()
int	executeCommand (const QString &command)
void	clearNumberedMenu (const QString &uid)
void	addNumberedMenuEntry (const QString &uid, const QString &entry, const QString &param)
void	selectItem (const QString &group, const QString &uid)
void	setItemText (const QString &uid, const QString &text)
void	setItemVisible (const QString &uid, bool show)

Private Attributes
Kwave::MenuRoot *	m_menu_root

Static Private Attributes
static QMap< QString, QKeySequence >	m_standard_keys

Detailed Description

Manager class for access to Kwave's menu subsystem.

Note

All commands must be emitted synchronously during X11 event processing instead of immediately through normal signal handling. This avoids trouble when a signal handler within the MenuNode class causes an action that deletes that menu node. It took me one week to find that bug!

Definition at line 46 of file MenuManager.h.

Constructor & Destructor Documentation

MenuManager()

Kwave::MenuManager::MenuManager	(	QWidget *	parent,
		QMenuBar &	bar
	)

Constructor.

Parameters

parent	the menu's parent widget
bar	reference to the menu bar

Definition at line 50 of file MenuManager.cpp.

References Kwave::connect(), INS, m_menu_root, m_standard_keys, and sigMenuCommand().

    :QObject(parent)
{
    m_menu_root = new(std::nothrow) Kwave::MenuRoot(bar);
    Q_ASSERT(m_menu_root);
    if (m_menu_root) {
        connect(
            m_menu_root, SIGNAL(sigCommand(QString)),
            this, SIGNAL(sigMenuCommand(QString)),
            Qt::QueuedConnection
        );
    }

    // fill the list of standard keys if it is empty.
    //
    // HINT: I have gerated the list below through copy&paste of the
    //       description of "enum QKeySequence::StandardKey" into
    //       list.txt and then:
    //
    // cat list.txt | sed s/^\ \ //g | cut -d \  -f 1 | cut -d \: -f 3 |
    // awk '{ print "\tINS(\""$0"\", QKeySequence::"$0");"}'

    if (m_standard_keys.isEmpty()) {
        INS("UnknownKey",            QKeySequence::UnknownKey);
        INS("HelpContents",          QKeySequence::HelpContents);
        INS("WhatsThis",             QKeySequence::WhatsThis);
        INS("Open",                  QKeySequence::Open);
        INS("Close",                 QKeySequence::Close);
        INS("Save",                  QKeySequence::Save);
        INS("New",                   QKeySequence::New);
        INS("Delete",                QKeySequence::Delete);
        INS("Cut",                   QKeySequence::Cut);
        INS("Copy",                  QKeySequence::Copy);
        INS("Paste",                 QKeySequence::Paste);
        INS("Undo",                  QKeySequence::Undo);
        INS("Redo",                  QKeySequence::Redo);
        INS("Back",                  QKeySequence::Back);
        INS("Forward",               QKeySequence::Forward);
        INS("Refresh",               QKeySequence::Refresh);
        INS("ZoomIn",                QKeySequence::ZoomIn);
        INS("ZoomOut",               QKeySequence::ZoomOut);
        INS("Print",                 QKeySequence::Print);
        INS("AddTab",                QKeySequence::AddTab);
        INS("NextChild",             QKeySequence::NextChild);
        INS("PreviousChild",         QKeySequence::PreviousChild);
        INS("Find",                  QKeySequence::Find);
        INS("FindNext",              QKeySequence::FindNext);
        INS("FindPrevious",          QKeySequence::FindPrevious);
        INS("Replace",               QKeySequence::Replace);
        INS("SelectAll",             QKeySequence::SelectAll);
        INS("Bold",                  QKeySequence::Bold);
        INS("Italic",                QKeySequence::Italic);
        INS("Underline",             QKeySequence::Underline);
        INS("MoveToNextChar",        QKeySequence::MoveToNextChar);
        INS("MoveToPreviousChar",    QKeySequence::MoveToPreviousChar);
        INS("MoveToNextWord",        QKeySequence::MoveToNextWord);
        INS("MoveToPreviousWord",    QKeySequence::MoveToPreviousWord);
        INS("MoveToNextLine",        QKeySequence::MoveToNextLine);
        INS("MoveToPreviousLine",    QKeySequence::MoveToPreviousLine);
        INS("MoveToNextPage",        QKeySequence::MoveToNextPage);
        INS("MoveToPreviousPage",    QKeySequence::MoveToPreviousPage);
        INS("MoveToStartOfLine",     QKeySequence::MoveToStartOfLine);
        INS("MoveToEndOfLine",       QKeySequence::MoveToEndOfLine);
        INS("MoveToStartOfBlock",    QKeySequence::MoveToStartOfBlock);
        INS("MoveToEndOfBlock",      QKeySequence::MoveToEndOfBlock);
        INS("MoveToStartOfDocument", QKeySequence::MoveToStartOfDocument);
        INS("MoveToEndOfDocument",   QKeySequence::MoveToEndOfDocument);
        INS("SelectNextChar",        QKeySequence::SelectNextChar);
        INS("SelectPreviousChar",    QKeySequence::SelectPreviousChar);
        INS("SelectNextWord",        QKeySequence::SelectNextWord);
        INS("SelectPreviousWord",    QKeySequence::SelectPreviousWord);
        INS("SelectNextLine",        QKeySequence::SelectNextLine);
        INS("SelectPreviousLine",    QKeySequence::SelectPreviousLine);
        INS("SelectNextPage",        QKeySequence::SelectNextPage);
        INS("SelectPreviousPage",    QKeySequence::SelectPreviousPage);
        INS("SelectStartOfLine",     QKeySequence::SelectStartOfLine);
        INS("SelectEndOfLine",       QKeySequence::SelectEndOfLine);
        INS("SelectStartOfBlock",    QKeySequence::SelectStartOfBlock);
        INS("SelectEndOfBlock",      QKeySequence::SelectEndOfBlock);
        INS("SelectStartOfDocument", QKeySequence::SelectStartOfDocument);
        INS("SelectEndOfDocument",   QKeySequence::SelectEndOfDocument);
        INS("DeleteStartOfWord",     QKeySequence::DeleteStartOfWord);
        INS("DeleteEndOfWord",       QKeySequence::DeleteEndOfWord);
        INS("DeleteEndOfLine",       QKeySequence::DeleteEndOfLine);
    }
}

Here is the call graph for this function:

~MenuManager()

Kwave::MenuManager::~MenuManager ( )

virtual

Destructor.

Definition at line 337 of file MenuManager.cpp.

References m_menu_root.

{
    delete m_menu_root;
    m_menu_root = Q_NULLPTR;
}

Member Function Documentation

addNumberedMenuEntry()

void Kwave::MenuManager::addNumberedMenuEntry	(	const QString &	uid,
		const QString &	entry,
		const QString &	param
	)

Add an entry to a numbered menu

Parameters

uid	unique id string of the numbered menu
entry	name of the new entry (non-localized)
param	a parameter to use when the entry is activated (optional, pass QString() when using the text of the menu entry as parameter)

Definition at line 225 of file MenuManager.cpp.

References _, Kwave::MenuNode::command(), DBG, Kwave::Parser::escape(), Kwave::MenuNode::findUID(), Kwave::MenuNode::insertLeaf(), m_menu_root, and Kwave::MenuNode::parentNode().

Referenced by Kwave::TopWidget::updateMenu(), and Kwave::TopWidget::updateRecentFiles().

{
    Q_ASSERT(entry.length());
    if (!entry.length()) return;

    Q_ASSERT(m_menu_root);
    Kwave::MenuNode *node = (m_menu_root) ? m_menu_root->findUID(uid) : Q_NULLPTR;
    Kwave::MenuNode *parent = (node) ? node->parentNode() : Q_NULLPTR;
    if (parent) {
        QString cmd = node->command();
        if (cmd.contains(_("%1"))) {
            QString p = (param.length()) ? param : entry;
            cmd = cmd.arg(Kwave::Parser::escape(p));
        }
        node->insertLeaf(entry, cmd, 0, uid);
    } else
        qWarning("MenuManager: could not find numbered Menu '%s'", DBG(uid));

}

Here is the call graph for this function:

Here is the caller graph for this function:

clearNumberedMenu()

void Kwave::MenuManager::clearNumberedMenu

(

const QString &

uid

)

Deletes all entries of a numbered menu

Parameters

uid	unique id string of the numbered menu

Definition at line 217 of file MenuManager.cpp.

References Kwave::MenuNode::clear(), Kwave::MenuNode::findUID(), and m_menu_root.

Referenced by Kwave::TopWidget::updateMenu(), and Kwave::TopWidget::updateRecentFiles().

{
    Kwave::MenuNode *node = (m_menu_root) ?
        m_menu_root->findUID(uid) : Q_NULLPTR;
    if (node) node->clear();
}

Here is the call graph for this function:

Here is the caller graph for this function:

executeCommand()

int Kwave::MenuManager::executeCommand

(

const QString &

command

)

Executes menu commands.

Parameters

command

string with the command

Return values

0	if succeeded
-EINVAL	if failed

Definition at line 138 of file MenuManager.cpp.

References _, DBG, Kwave::Parser::firstParam(), Kwave::MenuRoot::insertNode(), m_menu_root, m_standard_keys, and Kwave::Parser::nextParam().

Referenced by Kwave::TopWidget::executeCommand().

{

    Q_ASSERT(command.length());
    if (!m_menu_root) return -EINVAL; // makes no sense if no menu root

    Kwave::Parser parser(command);

    QKeySequence shortcut;  // keyboard shortcut (optional)
    QString id ;            // string id (optional)
    QString param;

    // --- 1st parameter: command to be sent when selected ---
    QString com = parser.firstParam();

    // --- 2nd parameter: position in the menu structure ---
    QString pos = parser.nextParam();

    // bail out if no menu position is found
    if (!pos.length()) {
        qWarning("no position field !");
        return -EINVAL;
    }

    // --- 3rd parameter: bitmask for the key shortcut (optional) ---
    param = parser.nextParam();
    if (param.length()) {
        // replace "::<StandardKeyName>" with the key sequence as string
        QRegExp rx(_("::(\\w+)"), Qt::CaseInsensitive);
        int p = 0;
        while ((p = rx.indexIn(param, 0)) >= 0) {
            QString stdname = rx.cap(1);
            if (m_standard_keys.contains(stdname)) {
                // translate into a key sequence
                QKeySequence sequence = m_standard_keys[stdname];
                QString expanded = sequence.toString();
                param = param.replace(p, stdname.length() + 2, expanded);
            } else {
                // unknown standard key sequence name?
                qWarning("MenuManager::executeCommand: pos=%d, stdname='%s' "
                         "-> UNKNOWN ???", p, DBG(stdname));
                break;
            }
        }

        // default case: direct specification of a key sequence
        shortcut = QKeySequence::fromString(i18n(param.toLatin1()));
    }

    // --- 4rth parameter: parse the string id of the node (optional) ---
    param = parser.nextParam();
    if (param.length()) id = param;

#ifdef DEBUG
//     qDebug("MenuManager: insertNode('', '%s', '%s', %s, '%s')",
//         DBG(pos), DBG(com), DBG(shortcut.toString()), DBG(id));
    if (!shortcut.isEmpty()) {
        static QMap<QString, QString> used_shortcuts;

        QString sc = shortcut.toString();
        QString m  = pos.left(pos.indexOf(_("/#")));

        if (used_shortcuts.contains(sc) && (used_shortcuts[sc] != m)) {
            qWarning("MenuManager: insertNode('%s')", DBG(m));
            qWarning("    shortcut %s already in use for '%s'",
                     DBG(sc), DBG(used_shortcuts[sc]));
        } else {
            used_shortcuts[sc] = m;
        }
    }
#endif /* DEBUG */

    // --- insert the new node into the menu structure ---
    m_menu_root->insertNode(QString(), pos, com, shortcut, id);

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

selectItem()

void Kwave::MenuManager::selectItem	(	const QString &	group,
		const QString &	uid
	)

Selects an menu item within a group of menu items. All other items will be deselected and the new one will become the only selected one. (exclusive one-of-n-selection)

Parameters

group	name of the menu group
uid	unique id string specifying the new selection

Definition at line 248 of file MenuManager.cpp.

References DBG, Kwave::MenuRoot::groupList(), m_menu_root, and Kwave::MenuGroup::selectItem().

Referenced by Kwave::TopWidget::updateMenu().

{
    if (!m_menu_root)
        return;

    if (!group.length()) {
        qWarning("MenuManager::selectItem('','%s'): no group!?", DBG(uid));
        return;
    }

    if (group[0] != QLatin1Char('@')) {
        qWarning("MenuManager::selectItem('%s','%s'): "
                "invalid group name, does not start with '@'!",
                DBG(group), DBG(uid));
        return;
    }

    QHash<QString, Kwave::MenuGroup *> &groups = m_menu_root->groupList();
    if (!groups.contains(group)) {
        qWarning("MenuManager::selectItem(): group '%s' not found!",
                 DBG(group));
        return;
    }

    Kwave::MenuGroup *group_node = groups[group];
    Q_ASSERT(group_node);
    if (group_node) group_node->selectItem(uid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

setItemChecked

void Kwave::MenuManager::setItemChecked ( const QString &  uid, bool  check  )

slot

Checks/unchecks a menu node.

Parameters

uid	unique id string of the menu node
check	true to set a checkmark, false to remove

Definition at line 278 of file MenuManager.cpp.

References Kwave::MenuNode::findUID(), m_menu_root, and Kwave::MenuNode::setChecked().

{
    Kwave::MenuNode *node = (m_menu_root) ?
        m_menu_root->findUID(uid) : Q_NULLPTR;
    if (node) node->setChecked(check);
}

Here is the call graph for this function:

setItemEnabled

void Kwave::MenuManager::setItemEnabled ( const QString &  uid, bool  enable  )

slot

Enables/disables a menu node.

Parameters

uid	unique id string of the menu node
enable	true to enable, false to disable

Definition at line 309 of file MenuManager.cpp.

References DBG, Kwave::MenuNode::findUID(), Kwave::MenuRoot::groupList(), m_menu_root, Kwave::MenuGroup::setEnabled(), and Kwave::MenuNode::setEnabled().

Referenced by Kwave::TopWidget::clipboardChanged(), Kwave::TopWidget::selectionChanged(), Kwave::TopWidget::setUndoRedoInfo(), Kwave::TopWidget::updateMenu(), Kwave::TopWidget::updateRecentFiles(), and Kwave::PlayerToolBar::updateState().

{
    if (!m_menu_root) return;

    bool found = false;
    Kwave::MenuNode *node = m_menu_root->findUID(uid);
    if (node) {
        /* enable/disable a single menu node */
        node->setEnabled(enable);
        found = true;
    } else {
        /* enable/disable a group */
        QHash<QString, Kwave::MenuGroup *> &groups = m_menu_root->groupList();
        if (groups.contains(uid)) {
            Kwave::MenuGroup *group = groups[uid];
            if (group) {
                group->setEnabled(enable);
                found = true;
            }
        }
    }

    if (!found)
        qWarning("MenuManager::setItemEnabled('%s', '%d'): uid not found!",
                 DBG(uid), enable);
}

Here is the call graph for this function:

Here is the caller graph for this function:

setItemText()

void Kwave::MenuManager::setItemText	(	const QString &	uid,
		const QString &	text
	)

Sets the text of a menu entry to a new value.

Parameters

uid	unique id string of the menu node
text	the new text of the item

Definition at line 286 of file MenuManager.cpp.

References Kwave::MenuNode::findUID(), m_menu_root, and Kwave::MenuNode::setText().

Referenced by Kwave::TopWidget::setUndoRedoInfo().

{
    Kwave::MenuNode *node = (m_menu_root) ?
        m_menu_root->findUID(uid) : Q_NULLPTR;
    if (node) node->setText(text);
}

Here is the call graph for this function:

Here is the caller graph for this function:

setItemVisible()

void Kwave::MenuManager::setItemVisible	(	const QString &	uid,
		bool	show
	)

Shows/hides a menu entry identified by an ID. Groups are not supported.

Parameters

uid	unique id string of the menu node
show	true to show, false to hide

Definition at line 294 of file MenuManager.cpp.

References DBG, Kwave::MenuNode::findUID(), m_menu_root, and Kwave::MenuNode::setVisible().

Referenced by Kwave::TopWidget::updateMenu().

{
    if (!m_menu_root) return;

    Kwave::MenuNode *node = m_menu_root->findUID(uid);
    if (node) {
        /* show/hide a single menu node */
        node->setVisible(show);
    } else {
        qWarning("MenuManager::setItemVisible('%s', '%d'): uid not found!",
                 DBG(uid), show);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

sigMenuCommand

void Kwave::MenuManager::sigMenuCommand ( const QString &  command )

signal

Will be emitted if the command of a menu node should be executed.

See also

MenuNode.sigCommand()

Referenced by MenuManager().

Here is the caller graph for this function:

Member Data Documentation

m_menu_root

Kwave::MenuRoot* Kwave::MenuManager::m_menu_root

private

root node of the menu structure

Definition at line 137 of file MenuManager.h.

Referenced by addNumberedMenuEntry(), clearNumberedMenu(), executeCommand(), MenuManager(), selectItem(), setItemChecked(), setItemEnabled(), setItemText(), setItemVisible(), and ~MenuManager().

m_standard_keys

QMap< QString, QKeySequence > Kwave::MenuManager::m_standard_keys

staticprivate

map of standard key names / key sequences

static map with standard keys

Definition at line 140 of file MenuManager.h.

Referenced by executeCommand(), and MenuManager().

---

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

• libgui/MenuManager.h
• libgui/MenuManager.cpp