void SGSelectionTool::createContextMenu(const QList<QSGItem *> &items, QPoint pos) { QMenu contextMenu; connect(&contextMenu, SIGNAL(hovered(QAction*)), this, SLOT(contextMenuElementHovered(QAction*))); const QList<QSGItem*> selectedItems = inspector()->selectedItems(); int shortcutKey = Qt::Key_1; foreach (QSGItem *item, items) { const QString title = inspector()->titleForItem(item); QAction *elementAction = contextMenu.addAction(title); elementAction->setData(QVariant::fromValue(item)); connect(elementAction, SIGNAL(triggered()), this, SLOT(contextMenuElementSelected())); if (selectedItems.contains(item)) { QFont font = elementAction->font(); font.setBold(true); elementAction->setFont(font); } if (shortcutKey <= Qt::Key_9) { elementAction->setShortcut(QKeySequence(shortcutKey)); shortcutKey++; } } contextMenu.exec(pos); }
void NMainMenuBar::createThemeMenu(QMenu *parentMenu) { QMenu *menu = parentMenu->addMenu(tr("Theme")); QStringList list = global.getThemeNames(); QFont f = global.getGuiFont(QFont()); global.settings->beginGroup(INI_GROUP_APPEARANCE); QString userTheme = global.settings->value("themeName", DEFAULT_THEME_NAME).toString(); global.settings->endGroup(); // Setup themes (we expect to find the DEFAULT_THEME_NAME theme as first one) for (int i = 0; i < list.size(); i++) { QString themeName(list[i]); if ((i == 0) && (QString::compare(themeName, DEFAULT_THEME_NAME, Qt::CaseInsensitive) != 0)) { QLOG_ERROR() << "First theme is expected to be " << DEFAULT_THEME_NAME; } QAction *themeAction = new QAction(themeName, this); themeAction->setData(themeName); themeAction->setCheckable(true); themeAction->setFont(f); connect(themeAction, SIGNAL(triggered()), parent, SLOT(reloadIcons())); if (themeName == userTheme) { themeAction->setChecked(true); } themeActions.append(themeAction); } menu->addActions(themeActions); menu->setFont(f); }
void LiveSelectionTool::createContextMenu(const QList<QGraphicsItem*> &itemList, QPoint globalPos) { QMenu contextMenu; connect(&contextMenu, SIGNAL(hovered(QAction*)), this, SLOT(contextMenuElementHovered(QAction*))); m_contextMenuItemList = itemList; contextMenu.addAction(tr("Items")); contextMenu.addSeparator(); int shortcutKey = Qt::Key_1; int i = 0; foreach (QGraphicsItem * const item, itemList) { QString itemTitle = titleForItem(item); QAction *elementAction = contextMenu.addAction(itemTitle, this, SLOT(contextMenuElementSelected())); if (inspector()->selectedItems().contains(item)) { QFont boldFont = elementAction->font(); boldFont.setBold(true); elementAction->setFont(boldFont); } elementAction->setData(i); if (shortcutKey <= Qt::Key_9) { elementAction->setShortcut(QKeySequence(shortcutKey)); shortcutKey++; } ++i; }
/** Creates a new action associated with a config page. */ QAction* ApplicationWindow::createPageAction(QIcon img, QString text, QActionGroup *group) { QAction *action = new QAction(img, text, group); action->setCheckable(true); action->setFont(FONT); return action; }
QAction* ActionResource::toQAction() const { Log log( Log::LT_TRACE, Log::MOD_MAIN, "QAction* ActionResource::toQAction() const" ); if( !( m_Type == AT_ITEM || m_Type == AT_SEPARATOR ) ) { return NULL; }; log.write( Log::LT_TRACE, "Produce item %s", getText() ); QAction* act = new QAction( getText(), NULL ); act->setAutoRepeat( getAutoRepeat() ); act->setCheckable( getCheckable() ); act->setChecked( getChecked() ); act->setData( getData() ); act->setFont( getFont() ); act->setIcon( getIcon() ); act->setIconVisibleInMenu( getIconVisibleInMenu() ); act->setMenuRole( getMenuRole() ); act->setSeparator( m_Type == AT_SEPARATOR ); act->setShortcut( getShortcut() ); act->setShortcutContext( getShortcutContext() ); act->setStatusTip( getStatusTip() ); act->setToolTip( getTooltip() ); act->setVisible( getVisible() ); act->setWhatsThis( getWhatsThis() ); return act; };
void Pane::on_list_customContextMenuRequested(const QPoint &pos) { File_info file = file_list_model.get_file_info(ui->list->indexAt(pos)); App_info_list apps = main_window->get_apps(file.mime_type); QMenu* menu = new QMenu(this); if (file.is_folder()) { menu->addAction(tr("Browse"))->setEnabled(false); } if (file.is_file) { menu->addAction(main_window->get_ui()->action_view); menu->addAction(main_window->get_ui()->action_edit); } if (file.is_executable) { menu->addAction(main_window->get_ui()->action_execute); } if (menu->actions().count() > 0) menu->addSeparator(); foreach(App_info app, apps) { QAction* a = menu->addAction(tr("Open with %1 (%2)").arg(app.name()).arg(app.command()), this, SLOT(action_launch_triggered())); QVariantList data; data << QVariant::fromValue(app) << QVariant::fromValue(file); a->setData(data); if (app == apps.default_app) { QFont f = a->font(); f.setBold(true); a->setFont(f); } }
void SessionListWidget::contextMenuEvent(QContextMenuEvent *event) { QModelIndex index = indexAt(event->pos()); if (index.isValid()) { JobDefinition &job = sessions[index.row()]; qDebug() << job; QMenu *menu = new QMenu(this); QAction *action; switch(job.status) { case JobDefinition::QUEUED: { action = new QAction("Delete session", this); action->setData(qVariantFromValue(&job)); connect(action, SIGNAL(triggered()), this, SLOT(removeSessionSlot())); menu->addAction(action); break; } case JobDefinition::HELD: { action = new QAction("Resume session", this); action->setData(qVariantFromValue(&job)); connect(action, SIGNAL(triggered()), this, SLOT(releaseSessionSlot())); menu->addAction(action); action = new QAction("Delete session", this); action->setData(qVariantFromValue(&job)); connect(action, SIGNAL(triggered()), this, SLOT(removeSessionSlot())); menu->addAction(action); break; } case JobDefinition::RUNNING: { action = new QAction("View session", this); QFont f = action->font(); f.setBold(true); action->setFont(f); action->setData(qVariantFromValue(&job)); connect(action, SIGNAL(triggered()), this, SLOT(viewSessionSlot())); menu->addAction(action); action = new QAction("Delete session", this); action->setData(qVariantFromValue(&job)); connect(action, SIGNAL(triggered()), this, SLOT(removeSessionSlot())); menu->addAction(action); break; } case JobDefinition::FINISHED: { menu->addAction("Resume session [TODO]"); break; } } menu->exec(QCursor::pos()); } }
static QAction* italicTextItem(const QString& s) { QAction* act = new QAction(s, NULL); QFont italicFont = act->font(); italicFont.setItalic(true); act->setFont(italicFont); return act; }
static QAction* boldTextItem(const QString& s) { QAction* act = new QAction(s, NULL); QFont boldFont = act->font(); boldFont.setBold(true); act->setFont(boldFont); return act; }
void MenuFactory::createTitle( QMenu& menu, const QString& title ) { QAction* pItem = menu.addAction( title ); QFont font = menu.font(); font.setBold( true ); pItem->setFont( font ); pItem->setEnabled( false ); }
// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- // helpers // ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- void FileSystemBrowser::addGroupMarkToMenu( QString text ) { QFont font; font.setBold( true ); font.setStyle( QFont::StyleOblique ); QAction* action = 0; action = _fileBrowserMenu.addAction( QString("~~~~~ %1 ~~~~~").arg(text) ); action->setFont( font ); }
/** Constructor */ FeedReaderFeedItem::FeedReaderFeedItem(RsFeedReader *feedReader, FeedReaderNotify *notify, FeedHolder *parent, const FeedInfo &feedInfo, const FeedMsgInfo &msgInfo) : QWidget(NULL), mFeedReader(feedReader), mNotify(notify), mParent(parent), ui(new Ui::FeedReaderFeedItem) { /* Invoke the Qt Designer generated object setup routine */ ui->setupUi(this); setAttribute(Qt::WA_DeleteOnClose, true); connect(ui->expandButton, SIGNAL(clicked(void)), this, SLOT(toggle(void))); connect(ui->clearButton, SIGNAL(clicked(void)), this, SLOT(removeItem(void))); connect(ui->readAndClearButton, SIGNAL(clicked()), this, SLOT(readAndClearItem())); connect(ui->linkButton, SIGNAL(clicked()), this, SLOT(openLink())); connect(mNotify, SIGNAL(msgChanged(QString,QString,int)), this, SLOT(msgChanged(QString,QString,int)), Qt::QueuedConnection); ui->expandFrame->hide(); mFeedId = feedInfo.feedId; mMsgId = msgInfo.msgId; if (feedInfo.icon.empty()) { ui->feedIconLabel->hide(); } else { /* use icon from feed */ QPixmap pixmap; if (pixmap.loadFromData(QByteArray::fromBase64(feedInfo.icon.c_str()))) { ui->feedIconLabel->setPixmap(pixmap.scaled(16, 16, Qt::IgnoreAspectRatio, Qt::SmoothTransformation)); } else { ui->feedIconLabel->hide(); } } ui->titleLabel->setText(QString::fromUtf8(feedInfo.name.c_str())); ui->msgTitleLabel->setText(QString::fromUtf8(msgInfo.title.c_str())); ui->descriptionLabel->setText(QString::fromUtf8((msgInfo.descriptionTransformed.empty() ? msgInfo.description : msgInfo.descriptionTransformed).c_str())); ui->dateTimeLabel->setText(DateTime::formatLongDateTime(msgInfo.pubDate)); /* build menu for link button */ mLink = QString::fromUtf8(msgInfo.link.c_str()); if (mLink.isEmpty()) { ui->linkButton->setEnabled(false); } else { QMenu *menu = new QMenu(this); QAction *action = menu->addAction(tr("Open link in browser"), this, SLOT(openLink())); menu->addAction(tr("Copy link to clipboard"), this, SLOT(copyLink())); QFont font = action->font(); font.setBold(true); action->setFont(font); ui->linkButton->setMenu(menu); } }
void Favorites::markCurrent() { for (int n = FIRST_MENU_ENTRY; n < _menu->actions().count(); n++) { QAction * a = _menu->actions()[n]; QString file = a->data().toString(); QFont f = a->font(); if (file == current_file) { f.setBold(true); a->setFont( f ); } else { f.setBold(false); a->setFont( f ); } } }
QAction * QMenuViewPrivate::makeAction(const QModelIndex &index) { QIcon icon = qvariant_cast<QIcon>(index.data(Qt::DecorationRole)); QAction * action = new QAction(icon, index.data().toString(), this); action->setEnabled(index.flags().testFlag(Qt::ItemIsEnabled)); // improvements for Qlipper (petr vanek <*****@*****.**> action->setFont(qvariant_cast<QFont>(index.data(Qt::FontRole))); action->setToolTip(index.data(Qt::ToolTipRole).toString()); // end of qlipper improvements QVariant v; v.setValue(index); action->setData(v); return action; }
void NMainMenuBar::addSortAction(QMenu *menu, QActionGroup *menuActionGroup, const QFont &f, QString name, QString code) { QString currentSortOrder = global.getSortOrder(); QAction *action = new QAction(name, this); action->setData(code); action->setCheckable(true); if (QString::compare(code, currentSortOrder) == 0) { action->setChecked(true); } action->setFont(f); menuActionGroup->addAction(action); connect(action, SIGNAL(triggered()), this, SLOT(onSortMenuTriggered())); menu->addAction(action); }
void ComboBox::addItemNew() { if (_cascading) { qDebug() << "ComboBox::addItemNew unsupported when in cascading mode"; return; } QAction* action = new QAction(this); action->setText( QString::fromUtf8("New") ); action->setData( QString::fromUtf8("New") ); QFont f = QFont(appFont, appFontSize); f.setItalic(true); action->setFont(f); addActionPrivate(action); }
void Speller::populateContextMenu(QMenu* menu, const QWebHitTestResult &hitTest) { m_element = hitTest.element(); if (!m_enabled || m_element.isNull() || m_element.attribute(QLatin1String("type")) == QLatin1String("password")) { return; } const QString text = m_element.evaluateJavaScript("this.value").toString(); const int pos = m_element.evaluateJavaScript("this.selectionStart").toInt() + 1; QTextBoundaryFinder finder = QTextBoundaryFinder(QTextBoundaryFinder::Word, text); finder.setPosition(pos); m_startPos = finder.toPreviousBoundary(); m_endPos = finder.toNextBoundary(); const QString &word = text.mid(m_startPos, m_endPos - m_startPos).trimmed(); if (!isValidWord(word) || !isMisspelled(word)) { return; } const int limit = 6; QStringList suggests = suggest(word); int count = suggests.count() > limit ? limit : suggests.count(); QFont boldFont = menu->font(); boldFont.setBold(true); for (int i = 0; i < count; ++i) { QAction* act = menu->addAction(suggests.at(i), this, SLOT(replaceWord())); act->setData(suggests.at(i)); act->setFont(boldFont); } if (count == 0) { menu->addAction(tr("No suggestions"))->setEnabled(false); } menu->addAction(tr("Add to dictionary"), this, SLOT(addToDictionary()))->setData(word); menu->addSeparator(); }
void TabWidget::updateTabsMenu() { TabsMenu->clear(); for (int i = 0; i < count(); i++) { QAction *action = new QAction(QIcon(), tabText(i), this); action->setData(QVariant(i)); if (i == tabBar()->currentIndex()) { QFont font = action->font(); font.setBold(true); action->setFont(font); } TabsMenu->addAction(action); } }
/* Create individual actions */ QAction* QMenuView::createActionFromIndex( QModelIndex index ) { QIcon icon = qvariant_cast<QIcon>( index.data( Qt::DecorationRole ) ); QAction * action = new QAction( icon, index.data().toString(), this ); /* Display in bold the active element */ if( index.data( VLCModel::CURRENT_ITEM_ROLE ).toBool() ) { QFont font; font.setBold ( true ); action->setFont( font ); } /* Some items could be hypothetically disabled */ action->setEnabled( index.flags().testFlag( Qt::ItemIsEnabled ) ); /* */ QVariant variant; variant.setValue( QPersistentModelIndex( index ) ); action->setData( variant ); return action; }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent) { setupUi(this); m_dict = 0; translationView->setDict(m_dict); QFont font; font.setPointSize(16); menu_File->insertActions(actionQuit, translationView->toolBar()->actions()); QAction *actionWordsListDock = wordsListDock->toggleViewAction(); menu_Options->insertAction(menu_Options->actions().first(), actionWordsListDock); actionWordsListDock->setFont(font); //wordsList->setProperty("FingerScrollable", true); //translationView->setProperty("FingerScrollable", true); createConnections(); loadSettings(); }
QAction* KMenu::addTitle(const QIcon &icon, const QString &text, QAction* before) { QAction *buttonAction = new QAction(this); QFont font = buttonAction->font(); font.setBold(true); buttonAction->setFont(font); buttonAction->setText(text); buttonAction->setIcon(icon); QWidgetAction *action = new QWidgetAction(this); action->setObjectName(KMENU_TITLE); QToolButton *titleButton = new QToolButton(this); titleButton->installEventFilter(d); // prevent clicks on the title of the menu titleButton->setDefaultAction(buttonAction); titleButton->setDown(true); // prevent hover style changes in some styles titleButton->setToolButtonStyle(Qt::ToolButtonTextBesideIcon); action->setDefaultWidget(titleButton); insertAction(before, action); return action; }
void MainStatusBar::showProfileMenu(const QPoint &global_pos, Qt::MouseButton button) { const gchar *profile_name = get_profile_name(); bool separator_added = false; GList *fl_entry; profile_def *profile; QAction *pa; init_profile_list(); fl_entry = current_profile_list(); profile_menu_.clear(); while (fl_entry && fl_entry->data) { profile = (profile_def *) fl_entry->data; if (!profile->is_global || !profile_exists(profile->name, false)) { if (profile->is_global && !separator_added) { profile_menu_.addSeparator(); separator_added = true; } pa = profile_menu_.addAction(profile->name); if (strcmp(profile->name, profile_name) == 0) { /* Bold current profile */ QFont pa_font = pa->font(); pa_font.setBold(true); pa->setFont(pa_font); pa->setCheckable(true); pa->setChecked(true); } connect(pa, SIGNAL(triggered()), this, SLOT(switchToProfile())); } fl_entry = g_list_next(fl_entry); } if (button == Qt::LeftButton) { profile_menu_.exec(global_pos); } else { ctx_menu_.exec(global_pos); } }
// Read in all of the data and build the menu. void NotebookMenuButton::loadData() { rootMenu.clear(); NotebookTable notebookTable; QList<qint32> lids; notebookTable.getAll(lids); if (notebookTable.findByName(currentNotebookName) <= 0) currentNotebookName = ""; for (qint32 i=0; i<lids.size(); i++) { Notebook book; if (notebookTable.get(book, lids[i])) { QAction *action = new QAction(this); actions.append(action); action->setText(QString::fromStdString(book.name)); action->setCheckable(true); connect(action, SIGNAL(triggered()), this, SLOT(notebookSelected())); QFont f = action->font(); f.setPixelSize(10); action->setFont(f); QMenu *currentMenu = findStack(book); addNotebookMenuItem(currentMenu, action); if (currentNotebookName == "" && book.__isset.defaultNotebook && book.defaultNotebook) { currentNotebookName = QString::fromStdString(book.name); setText(currentNotebookName); currentAction = actions.size()-1; } if (QString::fromStdString(book.name) == currentNotebookName) { action->setChecked(true); } } } }
void LiveSelectionTool::createContextMenu(QList<QGraphicsItem*> itemList, QPoint globalPos) { if (!QDeclarativeViewObserverPrivate::get(observer())->mouseInsideContextItem()) return; QMenu contextMenu; connect(&contextMenu, SIGNAL(hovered(QAction*)), this, SLOT(contextMenuElementHovered(QAction*))); m_contextMenuItemList = itemList; contextMenu.addAction("Items"); contextMenu.addSeparator(); int shortcutKey = Qt::Key_1; bool addKeySequence = true; int i = 0; foreach (QGraphicsItem * const item, itemList) { QString itemTitle = titleForItem(item); QAction *elementAction = contextMenu.addAction(itemTitle, this, SLOT(contextMenuElementSelected())); if (observer()->selectedItems().contains(item)) { QFont boldFont = elementAction->font(); boldFont.setBold(true); elementAction->setFont(boldFont); } elementAction->setData(i); if (addKeySequence) elementAction->setShortcut(QKeySequence(shortcutKey)); shortcutKey++; if (shortcutKey > Qt::Key_9) addKeySequence = false; ++i; }
void NewsButton::showNewsMenu() { auto newsFeedMenu = new QMenu; auto &feed = NewsFeed::instance(); for (const NewsItem &newsItem : feed.newsItems()) { QAction *action = newsFeedMenu->addAction(newsItem.title); if (feed.isUnread(newsItem)) { QFont f = action->font(); f.setBold(true); action->setFont(f); action->setIcon(mUnreadIcon); } else { action->setIcon(mReadIcon); } connect(action, &QAction::triggered, [=] { QDesktopServices::openUrl(newsItem.link); NewsFeed::instance().markRead(newsItem); }); } newsFeedMenu->addSeparator(); QAction *action = newsFeedMenu->addAction(tr("News Archive")); connect(action, &QAction::triggered, [] { QDesktopServices::openUrl(QUrl(QLatin1String(newsArchiveUrl))); NewsFeed::instance().markAllRead(); }); auto size = newsFeedMenu->sizeHint(); auto rect = QRect(mapToGlobal(QPoint(width() - size.width(), -size.height())), size); newsFeedMenu->setGeometry(rect); newsFeedMenu->exec(); setDown(false); }
ToolBar::ToolBar(const QString &title, QWidget *parent) : QToolBar(parent), spinbox(0), spinboxAction(0) { tip = 0; setWindowTitle(title); setObjectName(title); setIconSize(QSize(32, 32)); QColor bg(palette().background().color()); menu = new QMenu("One", this); menu->setIcon(genIcon(iconSize(), 1, Qt::black)); menu->addAction(genIcon(iconSize(), "A", Qt::blue), "A"); menu->addAction(genIcon(iconSize(), "B", Qt::blue), "B"); menu->addAction(genIcon(iconSize(), "C", Qt::blue), "C"); addAction(menu->menuAction()); QAction *two = addAction(genIcon(iconSize(), 2, Qt::white), "Two"); QFont boldFont; boldFont.setBold(true); two->setFont(boldFont); addAction(genIcon(iconSize(), 3, Qt::red), "Three"); addAction(genIcon(iconSize(), 4, Qt::green), "Four"); addAction(genIcon(iconSize(), 5, Qt::blue), "Five"); addAction(genIcon(iconSize(), 6, Qt::yellow), "Six"); orderAction = new QAction(this); orderAction->setText(tr("Order Items in Tool Bar")); connect(orderAction, SIGNAL(triggered()), SLOT(order())); randomizeAction = new QAction(this); randomizeAction->setText(tr("Randomize Items in Tool Bar")); connect(randomizeAction, SIGNAL(triggered()), SLOT(randomize())); addSpinBoxAction = new QAction(this); addSpinBoxAction->setText(tr("Add Spin Box")); connect(addSpinBoxAction, SIGNAL(triggered()), SLOT(addSpinBox())); removeSpinBoxAction = new QAction(this); removeSpinBoxAction->setText(tr("Remove Spin Box")); removeSpinBoxAction->setEnabled(false); connect(removeSpinBoxAction, SIGNAL(triggered()), SLOT(removeSpinBox())); movableAction = new QAction(tr("Movable"), this); movableAction->setCheckable(true); connect(movableAction, SIGNAL(triggered(bool)), SLOT(changeMovable(bool))); allowedAreasActions = new QActionGroup(this); allowedAreasActions->setExclusive(false); allowLeftAction = new QAction(tr("Allow on Left"), this); allowLeftAction->setCheckable(true); connect(allowLeftAction, SIGNAL(triggered(bool)), SLOT(allowLeft(bool))); allowRightAction = new QAction(tr("Allow on Right"), this); allowRightAction->setCheckable(true); connect(allowRightAction, SIGNAL(triggered(bool)), SLOT(allowRight(bool))); allowTopAction = new QAction(tr("Allow on Top"), this); allowTopAction->setCheckable(true); connect(allowTopAction, SIGNAL(triggered(bool)), SLOT(allowTop(bool))); allowBottomAction = new QAction(tr("Allow on Bottom"), this); allowBottomAction->setCheckable(true); connect(allowBottomAction, SIGNAL(triggered(bool)), SLOT(allowBottom(bool))); allowedAreasActions->addAction(allowLeftAction); allowedAreasActions->addAction(allowRightAction); allowedAreasActions->addAction(allowTopAction); allowedAreasActions->addAction(allowBottomAction); areaActions = new QActionGroup(this); areaActions->setExclusive(true); leftAction = new QAction(tr("Place on Left") , this); leftAction->setCheckable(true); connect(leftAction, SIGNAL(triggered(bool)), SLOT(placeLeft(bool))); rightAction = new QAction(tr("Place on Right") , this); rightAction->setCheckable(true); connect(rightAction, SIGNAL(triggered(bool)), SLOT(placeRight(bool))); topAction = new QAction(tr("Place on Top") , this); topAction->setCheckable(true); connect(topAction, SIGNAL(triggered(bool)), SLOT(placeTop(bool))); bottomAction = new QAction(tr("Place on Bottom") , this); bottomAction->setCheckable(true); connect(bottomAction, SIGNAL(triggered(bool)), SLOT(placeBottom(bool))); areaActions->addAction(leftAction); areaActions->addAction(rightAction); areaActions->addAction(topAction); areaActions->addAction(bottomAction); toolBarBreakAction = new QAction(tr("Insert break"), this); connect(toolBarBreakAction, SIGNAL(triggered(bool)), this, SLOT(insertToolBarBreak())); connect(movableAction, SIGNAL(triggered(bool)), areaActions, SLOT(setEnabled(bool))); connect(movableAction, SIGNAL(triggered(bool)), allowedAreasActions, SLOT(setEnabled(bool))); menu = new QMenu(title, this); menu->addAction(toggleViewAction()); menu->addSeparator(); menu->addAction(orderAction); menu->addAction(randomizeAction); menu->addSeparator(); menu->addAction(addSpinBoxAction); menu->addAction(removeSpinBoxAction); menu->addSeparator(); menu->addAction(movableAction); menu->addSeparator(); menu->addActions(allowedAreasActions->actions()); menu->addSeparator(); menu->addActions(areaActions->actions()); menu->addSeparator(); menu->addAction(toolBarBreakAction); connect(menu, SIGNAL(aboutToShow()), this, SLOT(updateMenu())); randomize(); }
QMenu *TikzCommandInserter::getMenu(const TikzCommandList &commandList) { QMenu *menu = new QMenu(commandList.title, m_parentWidget); const int numOfCommands = commandList.commands.size(); QAction *action = new QAction("test", menu); int whichSection = 0; // get left margin of the menu (to be added to the minimum width of the menu) menu->addAction(action); QFont actionFont = action->font(); actionFont.setPointSize(actionFont.pointSize() - 1); QFontMetrics actionFontMetrics(actionFont); int menuLeftMargin = menu->width() - actionFontMetrics.boundingRect(action->text()).width(); menu->removeAction(action); int menuMinimumWidth = 0; for (int i = 0; i < numOfCommands; ++i) { const QString name = commandList.commands.at(i).name; if (name.isEmpty()) // add separator or submenu { if (commandList.commands.at(i).type == 0) { action = new QAction(menu); action->setSeparator(true); menu->addAction(action); } else // type == -1, so add submenu; this assumes that the i-th command with type == -1 corresponds with the i-th submenu (see getCommands()) { menu->addMenu(getMenu(commandList.children.at(whichSection))); ++whichSection; } } else // add command { action = new QAction(name, menu); action->setData(commandList.commands.at(i).number); // link to the corresponding item in m_tikzCommandsList action->setStatusTip(commandList.commands.at(i).description); menuMinimumWidth = qMax(menuMinimumWidth, actionFontMetrics.boundingRect(commandList.commands.at(i).description).width()); connect(action, SIGNAL(triggered()), this, SLOT(insertTag())); connect(action, SIGNAL(hovered()), this, SLOT(updateDescriptionMenuItem())); menu->addAction(action); } } // if the menu does not only contain submenus, then we add a menu item // at the bottom of the menu which shows the description of the currently // highlighted menu item if (whichSection < menu->actions().size()) { action = new QAction(this); action->setSeparator(true); menu->addAction(action); action = new QAction(this); QFont actionFont = action->font(); actionFont.setPointSize(actionFont.pointSize() - 1); action->setFont(actionFont); connect(action, SIGNAL(triggered()), this, SLOT(insertTag())); menu->addAction(action); // make sure that the menu width does not change when the content // of the above menu item changes menu->setMinimumWidth(menuMinimumWidth + menuLeftMargin); } return menu; }
void WindowList::showMenu(bool onlyCurrentDesktop) { QList<WId> windows = KWindowSystem::windows(); QList<QAction*> actionList; QList< QList<QAction*> > windowList; int amount = 0; int number = 0; qDeleteAll(m_listMenu->actions()); //m_listMenu->clear(); if (!onlyCurrentDesktop) { m_listMenu->addTitle(i18n("Actions")); QAction *unclutterAction = m_listMenu->addAction(i18n("Unclutter Windows")); QAction *cascadeAction = m_listMenu->addAction(i18n("Cascade Windows")); connect(unclutterAction, SIGNAL(triggered()), m_listMenu, SLOT(slotUnclutterWindows())); connect(cascadeAction, SIGNAL(triggered()), m_listMenu, SLOT(slotCascadeWindows())); } for (int i = 0; i <= KWindowSystem::numberOfDesktops(); ++i) { windowList.append(QList<QAction*>()); } for (int i = 0; i < windows.count(); ++i) { KWindowInfo window = KWindowSystem::windowInfo(windows.at(i), (NET::WMGeometry | NET::WMFrameExtents | NET::WMWindowType | NET::WMDesktop | NET::WMState | NET::XAWMState | NET::WMVisibleName)); NET::WindowType type = window.windowType(NET::NormalMask | NET::DialogMask | NET::OverrideMask | NET::UtilityMask | NET::DesktopMask | NET::DockMask | NET::TopMenuMask | NET::SplashMask | NET::ToolbarMask | NET::MenuMask); if ((onlyCurrentDesktop && !window.isOnDesktop(KWindowSystem::currentDesktop())) || type == NET::Desktop || type == NET::Dock || type == NET::TopMenu || type == NET::Splash || type == NET::Menu || type == NET::Toolbar || window.hasState(NET::SkipPager)) { windows.removeAt(i); --i; continue; } ++amount; QAction *action = new QAction(QIcon(KWindowSystem::icon(windows.at(i))), window.visibleName(), this); action->setData((unsigned long long) windows.at(i)); QString window_title = QString(action->text()); window_title.truncate(55); action->setText(window_title); QFont font = QFont(action->font()); if (window.isMinimized()) { font.setItalic(true); } else if (KWindowSystem::activeWindow() == windows.at(i)) { font.setUnderline(true); font.setBold(true); } action->setFont(font); number = ((onlyCurrentDesktop || window.onAllDesktops()) ? 0 : window.desktop()); QList<QAction*> subList = windowList.value(number); subList.append(action); windowList.replace(number, subList); } const bool useSubMenus = (!onlyCurrentDesktop && KWindowSystem::numberOfDesktops() > 1 && (amount / KWindowSystem::numberOfDesktops()) > 5); if (amount && useSubMenus) { m_listMenu->addTitle(i18n("Desktops")); } for (int i = 0; i <= KWindowSystem::numberOfDesktops(); ++i) { if (windowList.value(i).isEmpty()) { continue; } KMenu *subMenu = NULL; QAction *subMenuAction = NULL; QString title = (i ? KWindowSystem::desktopName(i) : (onlyCurrentDesktop ? i18n("Current desktop") : i18n("On all desktops"))); if (useSubMenus) { subMenuAction = m_listMenu->addAction(title); subMenu = new KMenu(m_listMenu); subMenu->installEventFilter(this); } else { m_listMenu->addTitle(title); } for (int j = 0; j < windowList.value(i).count(); ++j) { if (useSubMenus) { subMenu->addAction(windowList.value(i).value(j)); } else { m_listMenu->addAction(windowList.value(i).value(j)); } } if (useSubMenus) { subMenuAction->setMenu(subMenu); } } if (!amount) { qDeleteAll(m_listMenu->actions()); m_listMenu->clear(); QAction *noWindows = m_listMenu->addAction(i18n("No windows")); noWindows->setEnabled(false); } if (formFactor() == Plasma::Vertical || formFactor() == Plasma::Horizontal) { m_listMenu->popup(popupPosition(m_listMenu->sizeHint())); } else { m_listMenu->popup(QCursor::pos()); } }
void QgsDataDefinedButton::aboutToShowMenu() { mDefineMenu->clear(); bool hasExp = !getExpression().isEmpty(); bool hasField = !getField().isEmpty(); QString ddTitle = tr( "Data defined override" ); QAction* ddTitleAct = mDefineMenu->addAction( ddTitle ); QFont titlefont = ddTitleAct->font(); titlefont.setItalic( true ); ddTitleAct->setFont( titlefont ); ddTitleAct->setEnabled( false ); bool addActiveAction = false; if ( useExpression() && hasExp ) { QgsExpression exp( getExpression() ); // whether expression is parse-able addActiveAction = !exp.hasParserError(); } else if ( !useExpression() && hasField ) { // whether field exists addActiveAction = mFieldNameList.contains( getField() ); } if ( addActiveAction ) { ddTitleAct->setText( ddTitle + " (" + ( useExpression() ? tr( "expression" ) : tr( "field" ) ) + ")" ); mDefineMenu->addAction( mActionActive ); mActionActive->setText( isActive() ? tr( "Deactivate" ) : tr( "Activate" ) ); mActionActive->setData( QVariant( isActive() ? false : true ) ); } if ( !mFullDescription.isEmpty() ) { mDefineMenu->addAction( mActionDescription ); } mDefineMenu->addSeparator(); if ( !mDataTypesString.isEmpty() ) { QAction* fieldTitleAct = mDefineMenu->addAction( tr( "Attribute field" ) ); fieldTitleAct->setFont( titlefont ); fieldTitleAct->setEnabled( false ); mDefineMenu->addAction( mActionDataTypes ); mFieldsMenu->clear(); if ( mFieldNameList.size() > 0 ) { for ( int j = 0; j < mFieldNameList.count(); ++j ) { QString fldname = mFieldNameList.at( j ); QAction* act = mFieldsMenu->addAction( fldname + " (" + mFieldTypeList.at( j ) + ")" ); act->setData( QVariant( fldname ) ); if ( getField() == fldname ) { act->setCheckable( true ); act->setChecked( !useExpression() ); } } } else { QAction* act = mFieldsMenu->addAction( tr( "No matching field types found" ) ); act->setEnabled( false ); } mDefineMenu->addSeparator(); } QAction* exprTitleAct = mDefineMenu->addAction( tr( "Expression" ) ); exprTitleAct->setFont( titlefont ); exprTitleAct->setEnabled( false ); if ( hasExp ) { QString expString = getExpression(); if ( expString.length() > 35 ) { expString.truncate( 35 ); expString.append( "..." ); } expString.prepend( tr( "Current: " ) ); if ( !mActionExpression ) { mActionExpression = new QAction( expString, this ); mActionExpression->setCheckable( true ); } else { mActionExpression->setText( expString ); } mDefineMenu->addAction( mActionExpression ); mActionExpression->setChecked( useExpression() ); mDefineMenu->addAction( mActionExpDialog ); mDefineMenu->addAction( mActionCopyExpr ); mDefineMenu->addAction( mActionPasteExpr ); mDefineMenu->addAction( mActionClearExpr ); } else { mDefineMenu->addAction( mActionExpDialog ); mDefineMenu->addAction( mActionPasteExpr ); } }
void MainWindow::editorContextMenuRequested ( const QPoint & pos ) { QString guid = getCurrentNoteGuid(); if (guid == "main") return; QWebHitTestResult element = ui->editor->page()->mainFrame()->hitTestContent(pos); if (element.isNull()) return; QStringList classes = allClasses(element.element()); if (classes.contains("pdfarea")) return; QMenu * menu = new QMenu(ui->editor); menu->addAction(ui->editor->pageAction(QWebPage::SelectAll)); if (element.isContentSelected()) { if (!menu->isEmpty()) menu->addSeparator(); menu->addAction(ui->editor->pageAction(QWebPage::Copy)); if (element.isContentEditable()) { menu->addAction(ui->editor->pageAction(QWebPage::Cut)); menu->addAction(ui->editor->pageAction(QWebPage::Paste)); menu->addSeparator(); menu->addAction(ui->editor->pageAction(QWebPage::ToggleBold)); menu->addAction(ui->editor->pageAction(QWebPage::ToggleItalic)); menu->addAction(ui->editor->pageAction(QWebPage::ToggleUnderline)); } } if(!element.imageUrl().isEmpty() && (element.imageUrl().scheme() != "qrc")) { if (!menu->isEmpty()) menu->addSeparator(); menu->addAction(ui->editor->pageAction(QWebPage::DownloadImageToDisk)); menu->addAction(ui->editor->pageAction(QWebPage::CopyImageToClipboard)); if (element.imageUrl().scheme() == "http" || element.imageUrl().scheme() == "https") menu->addAction(ui->editor->pageAction(QWebPage::CopyImageUrlToClipboard)); QAction * openImage = new QAction(this); openImage->setText("Open Image"); openImage->setObjectName("openImage"); menu->addAction(openImage); if (JS("editMode").toBool()) { menu->addSeparator(); QAction * deleteImage = new QAction(this); deleteImage->setText("Delete Image"); deleteImage->setObjectName("deleteImage"); deleteImage->setIcon(QIcon::fromTheme("edit-delete")); menu->addAction(deleteImage); if (element.imageUrl().scheme() != "resource") { QAction * saveLocally = new QAction(this); saveLocally->setText("Save Locally"); saveLocally->setObjectName("saveLocally"); menu->addAction(saveLocally); } } } if (!element.linkUrl().isEmpty()) { if (!menu->isEmpty()) menu->addSeparator(); menu->addAction(ui->editor->pageAction(QWebPage::CopyLinkToClipboard)); if (element.isContentEditable()) { QAction * deleteURL = new QAction(this); deleteURL->setText("Remove Link"); deleteURL->setObjectName("deleteURL"); menu->addAction(deleteURL); } } if (element.isContentEditable() && !element.isContentSelected() && element.imageUrl().isEmpty()) { Speller *speller = Speller::GetInstance(); if (speller->initialized()) { QHash<QString, QString> languages = speller->availableLanguages(); if (!languages.isEmpty()) { if (!menu->isEmpty()) menu->addSeparator(); QAction* act = menu->addAction(tr("Check &Spelling")); act->setCheckable(true); act->setChecked(speller->isEnabled()); connect(act, SIGNAL(triggered(bool)), speller, SLOT(setEnabled(bool))); if (speller->isEnabled()) { QString word = JS(QString("getSpellingWord(%1,%2);").arg(pos.x()).arg(pos.y())).toString(); if (!word.isEmpty() && speller->isMisspelled(word)) { QStringList wordsList = speller->suggest(word); QFont boldFont = menu->font(); boldFont.setBold(true); QActionGroup *suggestGroup = new QActionGroup(menu); QString suggest; foreach(suggest, wordsList) { QAction* act = menu->addAction(suggest); act->setFont(boldFont); act->setData(suggest); suggestGroup->addAction(act); } connect(suggestGroup, SIGNAL(triggered(QAction*)), this, SLOT(replaceWord(QAction*))); }