void QDesignerMenuBar::paintEvent(QPaintEvent *event)
{
QMenuBar::paintEvent(event);
QPainter p(this);
foreach (QAction *a, actions()) {
if (qobject_cast<SpecialMenuAction*>(a)) {
const QRect g = actionGeometry(a);
QLinearGradient lg(g.left(), g.top(), g.left(), g.bottom());
lg.setColorAt(0.0, Qt::transparent);
lg.setColorAt(0.7, QColor(0, 0, 0, 32));
lg.setColorAt(1.0, Qt::transparent);
p.fillRect(g, lg);
}
}
QAction *action = currentAction();
if (m_dragging || !action)
return;
if (hasFocus()) {
const QRect g = actionGeometry(action);
QDesignerMenu::drawSelection(&p, g.adjusted(1, 1, -1, -1));
} else if (action->menu() && action->menu()->isVisible()) {
const QRect g = actionGeometry(action);
p.drawRect(g.adjusted(1, 1, -1, -1));
}
}
void AcceleratorManagerPrivate::manageMenuBar(QMenuBar *mbar, Item *item)
{
QAction *maction;
QString s;
for (int i=0; i<mbar->actions().count(); ++i)
{
maction = mbar->actions()[i];
if (!maction)
continue;
// nothing to do for separators
if (maction->isSeparator())
continue;
s = maction->text();
if (!s.isEmpty())
{
Item *it = new Item;
item->addChild(it);
it->m_content =
AccelString(s,
// menu titles are important, so raise the weight
AccelManagerAlgorithm::MENU_TITLE_WEIGHT);
it->m_widget = mbar;
it->m_index = i;
}
// have a look at the popup as well, if present
if (maction->menu())
PopupAccelManager::manage(maction->menu());
}
}
void MainWindow::updateBookmarks(int folder)
{
if (m_ui->menuBookmarks->actions().count() == 3)
{
return;
}
for (int i = (m_ui->menuBookmarks->actions().count() - 1); i > 2; --i)
{
QAction *action = m_ui->menuBookmarks->actions().at(i);
if (folder == 0)
{
action->deleteLater();
m_ui->menuBookmarks->removeAction(action);
}
else if (m_ui->menuBookmarks->actions().at(i)->menu())
{
action->menu()->deleteLater();
action->setMenu(new QMenu());
connect(action->menu(), SIGNAL(aboutToShow()), this, SLOT(menuBookmarksAboutToShow()));
}
}
}
void Menu::mouseReleaseEvent(QMouseEvent* e)
{
QAction* qact = actionAt(e->pos());
Action* act = qobject_cast<Action*> (qact);
if (qact && qact->menu()) {
Menu* m = qobject_cast<Menu*> (qact->menu());
if (!m) {
QMenu::mouseReleaseEvent(e);
return;
}
if (e->button() == Qt::MiddleButton || (e->button() == Qt::LeftButton && e->modifiers() == Qt::ControlModifier)) {
closeAllMenus();
emit menuMiddleClicked(m);
}
}
if (!act) {
QMenu::mouseReleaseEvent(e);
return;
}
if (e->button() == Qt::LeftButton && e->modifiers() == Qt::NoModifier) {
closeAllMenus();
act->trigger();
e->accept();
}
else if (e->button() == Qt::MiddleButton || (e->button() == Qt::LeftButton && e->modifiers() == Qt::ControlModifier)) {
closeAllMenus();
act->triggerMiddleClick();
e->accept();
}
}
bool WidgetMenuBarMapEditor::containsMenu() const {
QAction * action = this->activeAction();
if (action != nullptr && action->menu() != nullptr) {
return action->menu()->rect().contains(action->menu()->mapFromGlobal(
QCursor::pos()));
}
return false;
}
/* private slots */
void ViewerToolBar::showMenu()
{
QAction *act = static_cast<QAction*>(sender());
if ( act->menu()->isVisible() ) act->menu()->hide();
else {
act->menu()->show();
act->menu()->move(QCursor::pos());
};
}
void ToolBar::showHoveredMenu()
{
QAction *act = static_cast<QAction*>(sender());
if ( act==itemControlAction ) {
act->menu()->show();
act->menu()->move(QCursor::pos());
} else {
if ( itemControlAction->menu()->isVisible() )
itemControlAction->menu()->hide();
}
}
QVariant pActionsModel::data( const QModelIndex& index, int role ) const
{
QAction* action = this->action( index );
if ( !action ) {
return QVariant();
}
switch ( role ) {
case Qt::DecorationRole:
switch ( index.column() ) {
case 0:
return action->icon();
default:
break;
}
break;
case Qt::DisplayRole:
case Qt::ToolTipRole:
switch ( index.column() ) {
case pActionsModel::Action:
return cleanText( action->text() );
case pActionsModel::Shortcut:
return action->shortcut().toString( QKeySequence::NativeText );
case pActionsModel::DefaultShortcut:
return defaultShortcut( action ).toString( QKeySequence::NativeText );
}
break;
case Qt::FontRole: {
QFont font = action->font();
if ( action->menu() ) {
font.setBold( true );
}
return font;
}
/*case Qt::BackgroundRole:
return action->menu() ? QBrush( QColor( 0, 0, 255, 20 ) ) : QVariant();*/
case pActionsModel::MenuRole:
return QVariant::fromValue( action->menu() );
case pActionsModel::ActionRole:
return QVariant::fromValue( action );
}
return QVariant();
}
QMenu *VerticalMenu::leafMenu()
{
QMenu *leaf = this;
while (true) {
QAction *act = leaf->activeAction();
if (act && act->menu() && act->menu()->isVisible()) {
leaf = act->menu();
continue;
}
return leaf == this ? 0 : leaf;
}
return 0; // make gcc happy
}
//search for first QuitRole in QMenuBar
static QAction* qt_wce_get_quit_action(QList<QAction *> actionItems)
{
QAction *returnAction = 0;
for (int i = 0; i < actionItems.size(); ++i) {
QAction *action = actionItems.at(i);
if (action->menuRole() == QAction::QuitRole)
returnAction = action;
else if (action->menu())
returnAction = qt_wce_get_quit_action(action->menu()->actions());
if (returnAction)
return returnAction; //return first action found
}
return 0; //nothing found;
}
void PopupMenu::mouseReleaseEvent(QMouseEvent *e)
{
DEBUG_PRST_ROUTES(stderr, "PopupMenu::mouseReleaseEvent this:%p\n", this);
if(_contextMenu && _contextMenu->isVisible())
return;
// Removed by Tim. Why not stay-open scrollable menus?
// if(MusEGlobal::config.scrollableSubMenus)
// {
// QMenu::mouseReleaseEvent(e);
// return;
// }
QAction* action = actionAt(e->pos());
if (!(action && action == activeAction() && !action->isSeparator() && action->isEnabled()))
action=NULL;
#ifdef POPUP_MENU_DISABLE_STAY_OPEN
if (action && action->menu() != NULL && action->isCheckable())
action->activate(QAction::Trigger);
QMenu::mouseReleaseEvent(e);
if (action && action->menu() != NULL && action->isCheckable())
close();
return;
#else
// Check for Ctrl to stay open.
const bool stay_open = _stayOpen && (MusEGlobal::config.popupsDefaultStayOpen || (e->modifiers() & Qt::ControlModifier));
// Stay open? Or does the action have a submenu, but also a checkbox of its own?
if(action && (stay_open || (action->isEnabled() && action->menu() && action->isCheckable())))
{
DEBUG_PRST_ROUTES(stderr, "PopupMenu::mouseReleaseEvent: stay open\n");
action->trigger(); // Trigger the action.
e->accept();
if(!stay_open)
closeUp();
return; // We handled it.
}
// Otherwise let ancestor QMenu handle it...
e->ignore();
QMenu::mouseReleaseEvent(e);
#endif // POPUP_MENU_DISABLE_STAY_OPEN
}
QMenu *QActionProto::menu() const
{
QAction *item = qscriptvalue_cast<QAction*>(thisObject());
if (item)
return item->menu();
return 0;
}
// taken from libqtxdg: XdgMenuWidget
bool XdgCachedMenu::event(QEvent* event)
{
if (event->type() == QEvent::MouseButtonPress)
{
QMouseEvent *e = static_cast<QMouseEvent*>(event);
if (e->button() == Qt::LeftButton)
mDragStartPosition = e->pos();
}
else if (event->type() == QEvent::MouseMove)
{
QMouseEvent *e = static_cast<QMouseEvent*>(event);
handleMouseMoveEvent(e);
}
else if(event->type() == QEvent::ToolTip)
{
QHelpEvent* helpEvent = static_cast<QHelpEvent*>(event);
QAction* action = actionAt(helpEvent->pos());
if(action && action->menu() == NULL)
QToolTip::showText(helpEvent->globalPos(), action->toolTip(), this);
}
return QMenu::event(event);
}
void MenuBar::dropEvent(QDropEvent *event)
{
const MimeDataObject *mimeData = qobject_cast<const MimeDataObject *>(event->mimeData());
QAction *aAction = qobject_cast<QAction *>(mimeData->object());
if (aAction && isEdited()) {
if (activeAction())
if (activeAction()->menu())
activeAction()->menu()->close();
if (aAction->menu())
if (aAction->objectName() == "actionNewMenu") {
Menu *menu = new Menu(aAction->text());
menu->setEdited(true);
aAction = menu->menuAction();
}
QAction *eAction = this->actionAt(event->pos());
QRect rect = actionGeometry(eAction);
eAction = this->actionAt(QPoint(event->pos().x()+rect.width()/2,
event->pos().y()));
if (eAction) {
if (aAction->isSeparator())
insertSeparator(eAction);
else
insertAction(eAction,aAction);
} else {
if (aAction->isSeparator())
addSeparator();
else
addAction(aAction);
}
event->acceptProposedAction();
}
}
void QDesignerMenuBar::updateCurrentAction(bool selectAction)
{
update();
if (!selectAction)
return;
QAction *action = currentAction();
if (!action || action == m_addMenu)
return;
QMenu *menu = action->menu();
if (!menu)
return;
QDesignerObjectInspector *oi = 0;
if (QDesignerFormWindowInterface *fw = formWindow())
oi = qobject_cast<QDesignerObjectInspector *>(fw->core()->objectInspector());
if (!oi)
return;
oi->clearSelection();
oi->selectObject(menu);
}
wxString wxMenuBar::GetMenuLabel(size_t pos) const
{
QAction *qtAction = GetActionAt( m_qtMenuBar, pos );
QMenu *qtMenu = qtAction->menu();
return wxQtConvertString( qtMenu->title() );
}
QAction* PopupMenu::findActionFromData(const QVariant& v) const
{
QList<QAction*> list = actions();
for(int i = 0; i < list.size(); ++i)
{
QAction* act = list[i];
if(PopupMenu* menu = qobject_cast<PopupMenu*>(act->menu()))
{
if(QAction* actm = menu->findActionFromData(v)) // Recursive.
return actm;
}
// "Operator == Compares this QVariant with v and returns true if they are equal,
// otherwise returns false. In the case of custom types, their equalness operators
// are not called. Instead the values' addresses are compared."
//
// Take care of struct Route first. Insert other future custom structures here too !
if(act->data().canConvert<MusECore::Route>() && v.canConvert<MusECore::Route>())
{
if(act->data().value<MusECore::Route>() == v.value<MusECore::Route>())
return act;
}
else
if(act->data() == v)
return act;
}
return 0;
}
void BookmarksToolBar::contextMenuRequested(const QPoint &position)
{
QAction *action = actionAt(position);
QMenu menu;
if (action) {
QVariant variant = action->data();
Q_ASSERT(variant.canConvert<QModelIndex>());
QAction *menuAction = 0;
if (!action->menu()) {
menuAction = menu.addAction(tr("Open"), this, SLOT(openBookmarkInCurrentTab()));
menuAction->setData(variant);
menuAction = menu.addAction(tr("Open in New &Tab"), this, SLOT(openBookmarkInNewTab()));
menuAction->setData(variant);
menu.addSeparator();
}
menuAction = menu.addAction(tr("Remove"), this, SLOT(removeBookmark()));
menuAction->setData(variant);
menu.addSeparator();
}
menu.addAction(tr("Add Bookmark..."), this, SLOT(newBookmark()));
menu.addAction(tr("Add Folder..."), this, SLOT(newFolder()));
menu.exec(QCursor::pos());
}
QMenu *WulforUtil::buildUserCmdMenu(const StringList& hub_list, int ctx, QWidget* parent) {
UserCommand::List userCommands = FavoriteManager::getInstance()->getUserCommands(ctx, hub_list);
if (userCommands.empty())
return nullptr;
QMenu *ucMenu = new QMenu(tr("User commands"), parent);
QMenu *menuPtr = ucMenu;
for (size_t n = 0; n < userCommands.size(); ++n) {
UserCommand *uc = &userCommands[n];
if (uc->getType() == UserCommand::TYPE_SEPARATOR) {
// Avoid double separators...
if (!menuPtr->actions().isEmpty() &&
!menuPtr->actions().last()->isSeparator())
{
menuPtr->addSeparator();
}
} else if (uc->isRaw() || uc->isChat()) {
menuPtr = ucMenu;
auto _begin = uc->getDisplayName().begin();
auto _end = uc->getDisplayName().end();
for(; _begin != _end; ++_begin) {
const QString name = _q(*_begin);
if (_begin + 1 == _end) {
menuPtr->addAction(name)->setData(uc->getId());
} else {
bool found = false;
QListIterator<QAction*> iter(menuPtr->actions());
while(iter.hasNext()) {
QAction *item = iter.next();
if (item->menu() && item->text() == name) {
found = true;
menuPtr = item->menu();
break;
}
}
if (!found)
menuPtr = menuPtr->addMenu(name);
}
}
}
}
return ucMenu;
}
void ActionEditor::slotActionChanged()
{
QAction *action = qobject_cast<QAction*>(sender());
Q_ASSERT(action != 0);
ActionModel *model = m_actionView->model();
const int row = model->findAction(action);
if (row == -1) {
if (action->menu() == 0) // action got its menu deleted, create item
model->addAction(action);
} else if (action->menu() != 0) { // action got its menu created, remove item
model->removeRow(row);
} else {
// action text or icon changed, update item
model->update(row);
}
}
void
qt_tm_widget_rep::install_main_menu () {
main_menu_widget = waiting_main_menu_widget;
QMenu* src = main_menu_widget->get_qmenu();
if (!src) return;
// REMARK: We do not want the menubar shared across windows as suggested
// in http://doc.qt.nokia.com/4.7/qmainwindow.html#menuBar
// e.g. :
//
// QMenuBar *dest = new QMenuBar(0);
// mainwindow()->setMenuBar(dest);
//
// as the default behavior on MacOS. The main reason is that in TeXmacs
// different windows can have different main menus so that it is indeed
// appropriate to change the main menu as the window focus changes.
// So we kindly ask to each window to give us its own menu and we install
// there our actions.
// So we do:
QMenuBar* dest = mainwindow()->menuBar();
// and everything is fine.
// Also please note that we have to do the replacement and not simply
// install the menu returned by get_qmenu() since the main menu there
// could contain some default items appropriate for the given OS (like the
// service menu on MacOS) which are not present in our menu widget.
// UPDATE: But replaceActions() *does remove* all actions (!?)
// It looks more like the reason is that we have to "flatten out" the first
// level of the QMenu returned... ?
replaceActions (dest, src);
QList<QAction*> list = dest->actions();
for (int i = 0; i < list.count(); i++) {
QAction* a = list[i];
if (a->menu()) {
QObject::connect (a->menu(), SIGNAL (aboutToShow()),
the_gui->gui_helper, SLOT (aboutToShowMainMenu()));
QObject::connect (a->menu(), SIGNAL (aboutToHide()),
the_gui->gui_helper, SLOT (aboutToHideMainMenu()));
}
}
}
void MenuManager::setup(MenuItem* menuItems) const
{
if (!menuItems)
return; // empty menu bar
QMenuBar* menuBar = getMainWindow()->menuBar();
//menuBar->setUpdatesEnabled(false);
QList<MenuItem*> items = menuItems->getItems();
QList<QAction*> actions = menuBar->actions();
for (QList<MenuItem*>::ConstIterator it = items.begin(); it != items.end(); ++it)
{
// search for the menu action
QAction* action = findAction(actions, QString::fromAscii((*it)->command().c_str()));
if (!action) {
// There must be not more than one separator in the menu bar, so
// we can safely remove it if available and append it at the end
if ((*it)->command() == "Separator") {
action = menuBar->addSeparator();
action->setObjectName(QLatin1String("Separator"));
}
else {
// create a new menu
std::string menuName = (*it)->command();
QMenu* menu = menuBar->addMenu(
QApplication::translate("Workbench", menuName.c_str(),
0, QApplication::UnicodeUTF8));
action = menu->menuAction();
menu->setObjectName(QString::fromAscii(menuName.c_str()));
action->setObjectName(QString::fromAscii(menuName.c_str()));
}
// set the menu user data
action->setData(QString::fromAscii((*it)->command().c_str()));
}
else {
// put the menu at the end
menuBar->removeAction(action);
menuBar->addAction(action);
action->setVisible(true);
int index = actions.indexOf(action);
actions.removeAt(index);
}
// flll up the menu
if (!action->isSeparator())
setup(*it, action->menu());
}
// hide all menus which we don't need for the moment
for (QList<QAction*>::Iterator it = actions.begin(); it != actions.end(); ++it) {
(*it)->setVisible(false);
}
// enable update again
//menuBar->setUpdatesEnabled(true);
}
void QDesignerMenuBar::hideMenu(int index)
{
if (index < 0 && m_currentIndex >= 0)
index = m_currentIndex;
if (index < 0 || index >= realActionCount())
return;
QAction *action = safeActionAt(index);
if (action && action->menu()) {
action->menu()->hide();
if (QDesignerMenu *menu = qobject_cast<QDesignerMenu*>(action->menu())) {
menu->closeMenuChain();
}
}
}
static QStringList objectNameList(QDesignerFormWindowInterface *form)
{
typedef QList<QAction*> ActionList;
typedef QList<QButtonGroup *> ButtonGroupList;
QStringList result;
QWidget *mainContainer = form->mainContainer();
if (!mainContainer)
return result;
// Add main container container pages (QStatusBar, QWizardPages) etc.
// to the list. Pages of containers on the form are not added, however.
if (const QDesignerContainerExtension *c = qt_extension<QDesignerContainerExtension *>(form->core()->extensionManager(), mainContainer)) {
const int count = c->count();
for (int i = 0 ; i < count; i++)
addWidgetToObjectList(c->widget(i), result);
}
const QDesignerFormWindowCursorInterface *cursor = form->cursor();
const int widgetCount = cursor->widgetCount();
for (int i = 0; i < widgetCount; ++i)
addWidgetToObjectList(cursor->widget(i), result);
const QDesignerMetaDataBaseInterface *mdb = form->core()->metaDataBase();
// Add managed actions and actions with managed menus
const ActionList actions = mainContainer->findChildren<QAction*>();
if (!actions.empty()) {
const ActionList::const_iterator cend = actions.constEnd();
for (ActionList::const_iterator it = actions.constBegin(); it != cend; ++it) {
QAction *a = *it;
if (!a->isSeparator()) {
if (QMenu *menu = a->menu()) {
if (mdb->item(menu))
result.push_back(menu->objectName());
} else {
if (mdb->item(a))
result.push_back(a->objectName());
}
}
}
}
// Add managed buttons groups
const ButtonGroupList buttonGroups = mainContainer->findChildren<QButtonGroup *>();
if (!buttonGroups.empty()) {
const ButtonGroupList::const_iterator cend = buttonGroups.constEnd();
for (ButtonGroupList::const_iterator it = buttonGroups.constBegin(); it != cend; ++it)
if (mdb->item(*it))
result.append((*it)->objectName());
}
result.sort();
return result;
}
void ToolBar::dragMoveEvent(QDragMoveEvent *event)
{
const MimeDataObject *mimeData
= qobject_cast<const MimeDataObject *>(event->mimeData());
QAction *eAction = this->actionAt(event->pos());
if (mimeData->hasFormat("application/x-qobject") && isEdited())
if (mimeData->object() != eAction && eAction)
if (eAction->menu() && !eAction->menu()->isVisible()) {
if (m_activeAction)
m_activeAction->menu()->close();
QToolButton *toolButton = qobject_cast<QToolButton *>(widgetForAction(eAction));
QPoint point = QPoint(toolButton->x(), toolButton->y()+toolButton->height());
eAction->menu()->popup(mapToGlobal(point));
m_activeAction = eAction;
}
event->accept();
}
void DomainToolBar::showHoveredMenu()
{
QAction *act = static_cast<QAction*>(sender());
if ( act==create_Action ) {
if ( define_Action->menu()->isVisible() )
define_Action->menu()->hide();
} else if ( act==define_Action ) {
if ( create_Action->menu()->isVisible() )
create_Action->menu()->hide();
} else {
if ( define_Action->menu()->isVisible() )
define_Action->menu()->hide();
if ( create_Action->menu()->isVisible() )
create_Action->menu()->hide();
return;
};
//act->menu()->popup(mapToGlobal(this->pos()), act);
act->menu()->show();
act->menu()->move(QCursor::pos());
}
void Menu::mouseReleaseEvent(QMouseEvent* e)
{
QAction* qact = activeAction();
Action* act = qobject_cast<Action*> (qact);
if (qact && qact->menu()) {
Menu* m = qobject_cast<Menu*> (qact->menu());
if (!m) {
QMenu::mouseReleaseEvent(e);
return;
}
if (e->button() == Qt::MiddleButton || (e->button() == Qt::LeftButton && e->modifiers() == Qt::ControlModifier)) {
closeAllMenus();
emit menuMiddleClicked(m);
}
}
if (!act) {
QMenu::mouseReleaseEvent(e);
return;
}
if ((e->button() == Qt::LeftButton || e->button() == Qt::RightButton) && e->modifiers() == Qt::NoModifier) {
closeAllMenus();
act->trigger();
e->accept();
}
else if (e->button() == Qt::MiddleButton || (e->button() == Qt::LeftButton && e->modifiers() == Qt::ControlModifier)) {
if ((e->button() == Qt::MiddleButton && m_closeOnMiddleClick) || e->button() != Qt::MiddleButton) {
closeAllMenus();
}
act->emitCtrlTriggered();
e->accept();
}
else if (e->button() == Qt::LeftButton && e->modifiers() == Qt::ShiftModifier) {
closeAllMenus();
act->emitShiftTriggered();
e->accept();
}
}
void QDesignerMenuBar::showMenu(int index)
{
if (index < 0 && m_currentIndex >= 0)
index = m_currentIndex;
if (index < 0 || index >= realActionCount())
return;
m_currentIndex = index;
QAction *action = currentAction();
if (action && action->menu()) {
if (m_lastMenuActionIndex != -1 && m_lastMenuActionIndex != index) {
hideMenu(m_lastMenuActionIndex);
}
m_lastMenuActionIndex = index;
QMenu *menu = action->menu();
const QRect g = actionGeometry(action);
if (!menu->isVisible()) {
if ((menu->windowFlags() & Qt::Popup) != Qt::Popup)
menu->setWindowFlags(Qt::Popup);
menu->adjustSize();
if (layoutDirection() == Qt::LeftToRight) {
menu->move(mapToGlobal(g.bottomLeft()));
} else {
// The position is not initially correct due to the unknown width,
// causing it to overlap a bit the first time it is invoked.
const QSize menuSize = menu->size();
QPoint point = g.bottomRight() - QPoint(menu->width(), 0);
menu->move(mapToGlobal(point));
}
menu->setFocus(Qt::MouseFocusReason);
menu->raise();
menu->show();
} else {
menu->raise();
}
}
}
void ToolBar::showHoveredMenu()
{
if ( !isEnabled() ) return;
QAction *act = static_cast<QAction*>(sender());
if ( act==itemControlAction ) {
if ( _docsUpAction->menu()->isVisible() )
_docsUpAction->menu()->hide();
} else if ( act==_docsUpAction ) {
if ( itemControlAction->menu()->isVisible() )
itemControlAction->menu()->hide();
} else {
if ( itemControlAction->menu()->isVisible() )
itemControlAction->menu()->hide();
if ( _docsUpAction->menu()->isVisible() )
_docsUpAction->menu()->hide();
return;
};
//act->menu()->popup(mapToGlobal(this->pos()), act);
act->menu()->show();
act->menu()->move(QCursor::pos());
}
void QtWebKitWebWidget::searchMenuAboutToShow()
{
QAction *searchMenuAction = getAction(SearchMenuAction);
if (searchMenuAction->isEnabled() && searchMenuAction->menu()->actions().isEmpty())
{
const QStringList engines = SearchesManager::getSearchEngines();
for (int i = 0; i < engines.count(); ++i)
{
SearchInformation *search = SearchesManager::getSearchEngine(engines.at(i));
if (search)
{
QAction *searchAction = searchMenuAction->menu()->addAction(search->icon, search->title);
searchAction->setData(search->identifier);
searchAction->setToolTip(search->description);
}
}
}
}
