SniffWindow::SniffWindow(QWidget* parent) : QMainWindow(parent), ui(new Ui::SniffWindow), model(), statsTable(new PacketStats(this)), toNotStop(true), isNotExiting(true), manageThread(&SniffWindow::managePacketsList, this), filterTree(nullptr) { SniffWindow::window = this; ui->setupUi(this); connect(ui->actionAbout_Qt, SIGNAL(triggered()), qApp, SLOT(aboutQt())); ui->table_packets->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents); ui->table_packets->horizontalHeader()->setStretchLastSection(true); ui->table_packets->verticalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents); m_sortFilterProxy = new QSortFilterProxyModel(this); m_sortFilterProxy->setSourceModel(&model); ui->table_packets->setModel(m_sortFilterProxy); connect(ui->table_packets->selectionModel(), SIGNAL(currentRowChanged(QModelIndex, QModelIndex)), this, SLOT(model_currentRowChanged(QModelIndex, QModelIndex))); connect(ui->action_preferences, SIGNAL(triggered()), this, SLOT(open_preference_window())); ui->tree_packet->setHeaderLabels(QStringList({QStringLiteral("Key"), QStringLiteral("Value")})); ui->tree_packet->setColumnCount(2); loadStatsFunctions(HungrySniffer_Core::core->stats, *ui->menuStats); #ifdef PYTHON_CMD QWidget* verticalLayoutWidget = new QWidget(ui->splitter); QVBoxLayout* panel_python = new QVBoxLayout(verticalLayoutWidget); panel_python->setContentsMargins(0, 0, 0, 0); lb_cmd = new QPlainTextEdit(verticalLayoutWidget); lb_cmd->setReadOnly(true); panel_python->addWidget(lb_cmd); QHBoxLayout* horizontalLayout = new QHBoxLayout(); horizontalLayout->setContentsMargins(0, 0, 0, 0); QLabel* img_python = new QLabel(verticalLayoutWidget); QSizePolicy sizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed); sizePolicy.setHeightForWidth(img_python->sizePolicy().hasHeightForWidth()); img_python->setSizePolicy(sizePolicy); img_python->setMaximumSize(QSize(32, 32)); img_python->setPixmap(QPixmap(QStringLiteral(":/icons/python.png"))); #ifndef QT_NO_TOOLTIP img_python->setToolTip(PythonThread::getVersionString()); #endif horizontalLayout->addWidget(img_python); tb_command = new History_Line_Edit(verticalLayoutWidget); connect(tb_command, SIGNAL(returnPressed()), this, SLOT(tb_command_returnPressed())); horizontalLayout->addWidget(tb_command); panel_python->addLayout(horizontalLayout); ui->splitter->addWidget(verticalLayoutWidget); this->py_checkCommand.reset(); connect(this, SIGNAL(sig_appendToCmd(QString)), this, SLOT(lb_cmd_appendString(QString))); connect(this, SIGNAL(sig_clearCmd()), this, SLOT(lb_cmd_clear())); #ifndef QT_NO_DEBUG python_thread.setObjectName(QStringLiteral("Python Interpreter")); #endif python_thread.start(); #else ui->action_Python->setVisible(false); #endif setAcceptDrops(true); if(HungrySniffer_Core::core->preferences.empty()) ui->action_preferences->setVisible(false); { // settings block QSettings& settings = *Preferences::settings; QVariant var; settings.beginGroup(QStringLiteral("General")); settings.beginGroup(QStringLiteral("UI")); bool flag = settings.value(QStringLiteral("splitter_sizes"), false).toBool(); default_open_location = settings.value(QStringLiteral("default_dir")).toString(); max_recent_files = settings.value(QStringLiteral("max_recent_files"), 10).toInt(); model.showColors = settings.value(QStringLiteral("colored_packets"), true).toBool(); settings.endGroup(); settings.endGroup(); settings.beginGroup(QStringLiteral("SniffWindow")); if(flag) { var = settings.value(QStringLiteral("splitter_sizes")); if(!var.isNull()) { QList<int> sizes; QVariantList list = var.value<QVariantList>(); for(const auto& i : list) sizes << i.toInt(); ui->splitter->setSizes(sizes); } } var = settings.value(QStringLiteral("recent_files")); if(!var.isNull()) { this->recentFiles_paths = var.toStringList(); } settings.endGroup(); } { // recent files recentFiles_actions.resize(max_recent_files, nullptr); for(int i = 0; i < max_recent_files; i++) { QAction* temp = recentFiles_actions[i] = new QAction(ui->menu_recent_files); temp->setData(i); connect(temp, SIGNAL(triggered(bool)), this, SLOT(recentFile_triggered())); ui->menu_recent_files->addAction(temp); } updateRecentsMenu(); } }
TaskFemConstraintForce::TaskFemConstraintForce(ViewProviderFemConstraintForce *ConstraintView,QWidget *parent) : TaskFemConstraint(ConstraintView, parent, "fem-constraint-force") { // we need a separate container widget to add all controls to proxy = new QWidget(this); ui = new Ui_TaskFemConstraintForce(); ui->setupUi(proxy); QMetaObject::connectSlotsByName(this); // Create a context menu for the listview of the references QAction* action = new QAction(tr("Delete"), ui->listReferences); action->connect(action, SIGNAL(triggered()), this, SLOT(onReferenceDeleted())); ui->listReferences->addAction(action); ui->listReferences->setContextMenuPolicy(Qt::ActionsContextMenu); connect(ui->spinForce, SIGNAL(valueChanged(double)), this, SLOT(onForceChanged(double))); connect(ui->buttonReference, SIGNAL(pressed()), this, SLOT(onButtonReference())); connect(ui->buttonDirection, SIGNAL(pressed()), this, SLOT(onButtonDirection())); connect(ui->checkReverse, SIGNAL(toggled(bool)), this, SLOT(onCheckReverse(bool))); this->groupLayout()->addWidget(proxy); // Temporarily prevent unnecessary feature recomputes ui->spinForce->blockSignals(true); ui->listReferences->blockSignals(true); ui->buttonReference->blockSignals(true); ui->buttonDirection->blockSignals(true); ui->checkReverse->blockSignals(true); // Get the feature data Fem::ConstraintForce* pcConstraint = static_cast<Fem::ConstraintForce*>(ConstraintView->getObject()); double f = pcConstraint->Force.getValue(); std::vector<App::DocumentObject*> Objects = pcConstraint->References.getValues(); std::vector<std::string> SubElements = pcConstraint->References.getSubValues(); std::vector<std::string> dirStrings = pcConstraint->Direction.getSubValues(); QString dir; if (!dirStrings.empty()) dir = makeRefText(pcConstraint->Direction.getValue(), dirStrings.front()); bool reversed = pcConstraint->Reversed.getValue(); // Fill data into dialog elements ui->spinForce->setMinimum(0); ui->spinForce->setMaximum(FLOAT_MAX); ui->spinForce->setValue(f); ui->listReferences->clear(); for (std::size_t i = 0; i < Objects.size(); i++) ui->listReferences->addItem(makeRefText(Objects[i], SubElements[i])); if (Objects.size() > 0) ui->listReferences->setCurrentRow(0, QItemSelectionModel::ClearAndSelect); ui->lineDirection->setText(dir.isEmpty() ? tr("") : dir); ui->checkReverse->setChecked(reversed); ui->spinForce->blockSignals(false); ui->listReferences->blockSignals(false); ui->buttonReference->blockSignals(false); ui->buttonDirection->blockSignals(false); ui->checkReverse->blockSignals(false); updateUI(); }
void ViewProviderLoft::setupContextMenu(QMenu* menu, QObject* receiver, const char* member) { QAction* act; act = menu->addAction(QObject::tr("Edit loft"), receiver, member); act->setData(QVariant((int)ViewProvider::Default)); }
void setupUi(QMainWindow *MainWindow) { if (MainWindow->objectName().isEmpty()) MainWindow->setObjectName(QString::fromUtf8("MainWindow")); MainWindow->resize(999, 913); actionAbout = new QAction(MainWindow); actionAbout->setObjectName(QString::fromUtf8("actionAbout")); actionAtlas = new QAction(MainWindow); actionAtlas->setObjectName(QString::fromUtf8("actionAtlas")); actionMapping = new QAction(MainWindow); actionMapping->setObjectName(QString::fromUtf8("actionMapping")); actionLibrary = new QAction(MainWindow); actionLibrary->setObjectName(QString::fromUtf8("actionLibrary")); actionToolbox = new QAction(MainWindow); actionToolbox->setObjectName(QString::fromUtf8("actionToolbox")); centralwidget = new QWidget(MainWindow); centralwidget->setObjectName(QString::fromUtf8("centralwidget")); gridLayout = new QGridLayout(centralwidget); gridLayout->setObjectName(QString::fromUtf8("gridLayout")); mainSizer = new QGridLayout(); mainSizer->setObjectName(QString::fromUtf8("mainSizer")); mainSizer->setVerticalSpacing(14); mainSizer->setContentsMargins(0, -1, -1, -1); renderFrame = new QFrame(centralwidget); renderFrame->setObjectName(QString::fromUtf8("renderFrame")); renderFrame->setMinimumSize(QSize(800, 600)); renderFrame->setFrameShape(QFrame::Box); renderFrame->setFrameShadow(QFrame::Raised); mainSizer->addWidget(renderFrame, 0, 0, 1, 1); gridLayout->addLayout(mainSizer, 0, 0, 1, 1); MainWindow->setCentralWidget(centralwidget); menubar = new QMenuBar(MainWindow); menubar->setObjectName(QString::fromUtf8("menubar")); menubar->setGeometry(QRect(0, 0, 999, 21)); menuFile = new QMenu(menubar); menuFile->setObjectName(QString::fromUtf8("menuFile")); menuTools = new QMenu(menubar); menuTools->setObjectName(QString::fromUtf8("menuTools")); menuAbout = new QMenu(menubar); menuAbout->setObjectName(QString::fromUtf8("menuAbout")); menuWindows = new QMenu(menubar); menuWindows->setObjectName(QString::fromUtf8("menuWindows")); MainWindow->setMenuBar(menubar); statusbar = new QStatusBar(MainWindow); statusbar->setObjectName(QString::fromUtf8("statusbar")); MainWindow->setStatusBar(statusbar); menubar->addAction(menuFile->menuAction()); menubar->addAction(menuTools->menuAction()); menubar->addAction(menuWindows->menuAction()); menubar->addAction(menuAbout->menuAction()); menuTools->addAction(actionAtlas); menuTools->addAction(actionMapping); menuAbout->addAction(actionAbout); menuWindows->addAction(actionLibrary); menuWindows->addAction(actionToolbox); retranslateUi(MainWindow); QMetaObject::connectSlotsByName(MainWindow); } // setupUi
void PlotDataGroupWidget::tableContextMenu(const QPoint& pos) { PlotDataGroup* plotDataGroup = dynamic_cast<PlotDataGroup*>(processor_); QModelIndex index = table_->indexAt(pos); contextMenuTable_->clear(); addFunctionMenu_->clear(); averageFunctionMenu_->clear(); histogramFunctionMenu_->clear(); PlotData* data = const_cast<PlotData*>(plotDataGroup->getPlotData()); QAction* newAct; QList<QVariant>* qlist = new QList<QVariant>(); std::string s; s = "Reset All"; newAct = new QAction(QString::fromStdString(s),this); contextMenuTable_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(selectResetAll())); s = "Reset Last"; newAct = new QAction(QString::fromStdString(s),this); contextMenuTable_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(selectResetLast())); contextMenuTable_->addSeparator(); bool found = false; s = "Delete Function"; newAct = new QAction(QString::fromStdString(s),this); qlist->push_back(0); qlist->push_back(index.column()); newAct->setData(QVariant(*qlist)); addFunctionMenu_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(addFunction())); qlist->clear(); for(size_t i=0; i< aggregatedcolumns.size(); ++i){ if(index.column() == aggregatedcolumns.at(i).first){ found = true; break; } } if (!found || aggregatedcolumns.size() == 0 || data->getColumnType(index.column()) == PlotBase::EMPTY) { newAct->setEnabled(false); } else { newAct->setEnabled(true); } qlist->clear(); addFunctionMenu_->addSeparator(); s = "Arithmetic"; newAct = new QAction(QString::fromStdString(s),this); qlist->push_back(static_cast<int>(AggregationFunction::AVERAGE)); qlist->push_back(index.column()); newAct->setData(QVariant(*qlist)); averageFunctionMenu_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(addFunction())); qlist->clear(); s = "Geometric"; newAct = new QAction(QString::fromStdString(s),this); qlist->push_back(static_cast<int>(AggregationFunction::GEOMETRICMEAN)); qlist->push_back(index.column()); newAct->setData(QVariant(*qlist)); averageFunctionMenu_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(addFunction())); qlist->clear(); s = "Harmonic"; newAct = new QAction(QString::fromStdString(s),this); qlist->push_back(static_cast<int>(AggregationFunction::HARMONICMEAN)); qlist->push_back(index.column()); newAct->setData(QVariant(*qlist)); averageFunctionMenu_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(addFunction())); qlist->clear(); addFunctionMenu_->addMenu(averageFunctionMenu_); s = "Count"; newAct = new QAction(QString::fromStdString(s),this); qlist->push_back(static_cast<int>(AggregationFunction::COUNT)); qlist->push_back(index.column()); newAct->setData(QVariant(*qlist)); addFunctionMenu_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(addFunction())); qlist->clear(); s = "Max"; newAct = new QAction(QString::fromStdString(s),this); qlist->push_back(static_cast<int>(AggregationFunction::MAX)); qlist->push_back(index.column()); newAct->setData(QVariant(*qlist)); addFunctionMenu_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(addFunction())); qlist->clear(); s = "Median"; newAct = new QAction(QString::fromStdString(s),this); qlist->push_back(static_cast<int>(AggregationFunction::MEDIAN)); qlist->push_back(index.column()); newAct->setData(QVariant(*qlist)); addFunctionMenu_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(addFunction())); qlist->clear(); s = "Min"; newAct = new QAction(QString::fromStdString(s),this); qlist->push_back(static_cast<int>(AggregationFunction::MIN)); qlist->push_back(index.column()); newAct->setData(QVariant(*qlist)); addFunctionMenu_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(addFunction())); qlist->clear(); s = "Mode"; newAct = new QAction(QString::fromStdString(s),this); qlist->push_back(static_cast<int>(AggregationFunction::MODE)); qlist->push_back(index.column()); newAct->setData(QVariant(*qlist)); addFunctionMenu_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(addFunction())); qlist->clear(); s = "Standard Deviation"; newAct = new QAction(QString::fromStdString(s),this); qlist->push_back(static_cast<int>(AggregationFunction::STANDARDDEVIATION)); qlist->push_back(index.column()); newAct->setData(QVariant(*qlist)); addFunctionMenu_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(addFunction())); qlist->clear(); s = "Sum"; newAct = new QAction(QString::fromStdString(s),this); qlist->push_back(static_cast<int>(AggregationFunction::SUM)); qlist->push_back(index.column()); newAct->setData(QVariant(*qlist)); addFunctionMenu_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(addFunction())); qlist->clear(); s = "Variance"; newAct = new QAction(QString::fromStdString(s),this); qlist->push_back(static_cast<int>(AggregationFunction::VARIANCE)); qlist->push_back(index.column()); newAct->setData(QVariant(*qlist)); addFunctionMenu_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(addFunction())); qlist->clear(); addFunctionMenu_->addSeparator(); //Histogramm-Menu s = "Count"; newAct = new QAction(QString::fromStdString(s),this); qlist->push_back(static_cast<int>(AggregationFunction::COUNTHISTOGRAM)); qlist->push_back(index.column()); newAct->setData(QVariant(*qlist)); histogramFunctionMenu_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(addFunction())); qlist->clear(); s = "Min"; newAct = new QAction(QString::fromStdString(s),this); qlist->push_back(static_cast<int>(AggregationFunction::MINHISTOGRAM)); qlist->push_back(index.column()); newAct->setData(QVariant(*qlist)); histogramFunctionMenu_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(addFunction())); qlist->clear(); s = "Max"; newAct = new QAction(QString::fromStdString(s),this); qlist->push_back(static_cast<int>(AggregationFunction::MAXHISTOGRAM)); qlist->push_back(index.column()); newAct->setData(QVariant(*qlist)); histogramFunctionMenu_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(addFunction())); qlist->clear(); s = "Median"; newAct = new QAction(QString::fromStdString(s),this); qlist->push_back(static_cast<int>(AggregationFunction::MEDIANHISTOGRAM)); qlist->push_back(index.column()); newAct->setData(QVariant(*qlist)); histogramFunctionMenu_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(addFunction())); qlist->clear(); s = "Sum"; newAct = new QAction(QString::fromStdString(s),this); qlist->push_back(static_cast<int>(AggregationFunction::SUMHISTOGRAM)); qlist->push_back(index.column()); newAct->setData(QVariant(*qlist)); histogramFunctionMenu_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(addFunction())); qlist->clear(); addFunctionMenu_->addMenu(histogramFunctionMenu_); if (data->getColumnType(index.column()) != PlotBase::NUMBER) { addFunctionMenu_->setEnabled(false); } else { addFunctionMenu_->setEnabled(true); } contextMenuTable_->addMenu(addFunctionMenu_); s = "Group By"; newAct = new QAction(QString::fromStdString(s),this); newAct->setData(QVariant(index.column())); contextMenuTable_->addAction(newAct); QObject::connect(newAct,SIGNAL(triggered()),this,SLOT(groupby())); for(size_t i=0; i< aggregatedcolumns.size(); ++i){ if(index.column() == aggregatedcolumns.at(i).first){ found = true; break; } } if (found || aggregatedcolumns.size() == 0 || data->getColumnType(index.column()) == PlotBase::EMPTY) { newAct->setEnabled(false); } else { newAct->setEnabled(true); } qlist->clear(); contextMenuTable_->popup(table_->mapToGlobal(pos)); delete qlist; }
BlockingClient::BlockingClient(QWidget *parent) : QWidget(parent) { hostLabel = new QLabel(tr("&Server name:")); portLabel = new QLabel(tr("S&erver port:")); // find out which IP to connect to QString ipAddress; QList<QHostAddress> ipAddressesList = QNetworkInterface::allAddresses(); // use the first non-localhost IPv4 address for (int i = 0; i < ipAddressesList.size(); ++i) { if (ipAddressesList.at(i) != QHostAddress::LocalHost && ipAddressesList.at(i).toIPv4Address()) { ipAddress = ipAddressesList.at(i).toString(); break; } } // if we did not find one, use IPv4 localhost if (ipAddress.isEmpty()) ipAddress = QHostAddress(QHostAddress::LocalHost).toString(); hostLineEdit = new QLineEdit(ipAddress); portLineEdit = new QLineEdit; portLineEdit->setValidator(new QIntValidator(1, 65535, this)); #if defined(Q_OS_SYMBIAN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_SIMULATOR) Qt::InputMethodHint hints = Qt::ImhDigitsOnly; portLineEdit->setInputMethodHints(hints); #endif hostLabel->setBuddy(hostLineEdit); portLabel->setBuddy(portLineEdit); statusLabel = new QLabel(tr("This examples requires that you run the " "Fortune Server example as well.")); statusLabel->setWordWrap(true); #ifdef Q_OS_SYMBIAN QMenu *menu = new QMenu(this); fortuneAction = menu->addAction(tr("Get Fortune")); fortuneAction->setVisible(false); QAction *optionsAction = new QAction(tr("Options"), this); optionsAction->setMenu(menu); optionsAction->setSoftKeyRole(QAction::PositiveSoftKey); addAction(optionsAction); exitAction = new QAction(tr("Exit"), this); exitAction->setSoftKeyRole(QAction::NegativeSoftKey); addAction(exitAction); connect(fortuneAction, SIGNAL(triggered()), this, SLOT(requestNewFortune())); connect(exitAction, SIGNAL(triggered()), this, SLOT(close())); #else getFortuneButton = new QPushButton(tr("Get Fortune")); getFortuneButton->setDefault(true); getFortuneButton->setEnabled(false); quitButton = new QPushButton(tr("Quit")); buttonBox = new QDialogButtonBox; buttonBox->addButton(getFortuneButton, QDialogButtonBox::ActionRole); buttonBox->addButton(quitButton, QDialogButtonBox::RejectRole); connect(getFortuneButton, SIGNAL(clicked()), this, SLOT(requestNewFortune())); connect(quitButton, SIGNAL(clicked()), this, SLOT(close())); #endif connect(hostLineEdit, SIGNAL(textChanged(QString)), this, SLOT(enableGetFortuneButton())); connect(portLineEdit, SIGNAL(textChanged(QString)), this, SLOT(enableGetFortuneButton())); //! [0] connect(&thread, SIGNAL(newFortune(QString)), this, SLOT(showFortune(QString))); //! [0] //! [1] connect(&thread, SIGNAL(error(int,QString)), this, SLOT(displayError(int,QString))); //! [1] QGridLayout *mainLayout = new QGridLayout; mainLayout->addWidget(hostLabel, 0, 0); mainLayout->addWidget(hostLineEdit, 0, 1); mainLayout->addWidget(portLabel, 1, 0); mainLayout->addWidget(portLineEdit, 1, 1); mainLayout->addWidget(statusLabel, 2, 0, 1, 2); #ifndef Q_OS_SYMBIAN mainLayout->addWidget(buttonBox, 3, 0, 1, 2); #endif setLayout(mainLayout); setWindowTitle(tr("Blocking Fortune Client")); portLineEdit->setFocus(); }
void GUIManager::showEvent(QShowEvent * /*event*/) { QAction *a = KStars::Instance()->actionCollection()->action( "show_control_panel" ); a->setEnabled(true); a->setChecked(true); }
void TestGui::testSearch() { QAction* searchAction = m_mainWindow->findChild<QAction*>("actionSearch"); QVERIFY(searchAction->isEnabled()); QToolBar* toolBar = m_mainWindow->findChild<QToolBar*>("toolBar"); QWidget* searchActionWidget = toolBar->widgetForAction(searchAction); EntryView* entryView = m_dbWidget->findChild<EntryView*>("entryView"); QLineEdit* searchEdit = m_dbWidget->findChild<QLineEdit*>("searchEdit"); QToolButton* clearSearch = m_dbWidget->findChild<QToolButton*>("clearButton"); QVERIFY(!searchEdit->hasFocus()); // Enter search QTest::mouseClick(searchActionWidget, Qt::LeftButton); QTRY_VERIFY(searchEdit->hasFocus()); // Search for "ZZZ" QTest::keyClicks(searchEdit, "ZZZ"); QTRY_COMPARE(entryView->model()->rowCount(), 0); // Escape QTest::keyClick(m_mainWindow, Qt::Key_Escape); QTRY_VERIFY(!searchEdit->hasFocus()); // Enter search again QTest::mouseClick(searchActionWidget, Qt::LeftButton); QTRY_VERIFY(searchEdit->hasFocus()); // Input and clear QTest::keyClicks(searchEdit, "ZZZ"); QTRY_COMPARE(searchEdit->text(), QString("ZZZ")); QTest::mouseClick(clearSearch, Qt::LeftButton); QTRY_COMPARE(searchEdit->text(), QString("")); // Triggering search should select the existing text QTest::keyClicks(searchEdit, "ZZZ"); QTest::mouseClick(searchActionWidget, Qt::LeftButton); QTRY_VERIFY(searchEdit->hasFocus()); // Search for "some" QTest::keyClicks(searchEdit, "some"); QTRY_COMPARE(entryView->model()->rowCount(), 4); clickIndex(entryView->model()->index(0, 1), entryView, Qt::LeftButton); QAction* entryEditAction = m_mainWindow->findChild<QAction*>("actionEntryEdit"); QVERIFY(entryEditAction->isEnabled()); QWidget* entryEditWidget = toolBar->widgetForAction(entryEditAction); QVERIFY(entryEditWidget->isVisible()); QVERIFY(entryEditWidget->isEnabled()); QTest::mouseClick(entryEditWidget, Qt::LeftButton); QCOMPARE(m_dbWidget->currentMode(), DatabaseWidget::EditMode); EditEntryWidget* editEntryWidget = m_dbWidget->findChild<EditEntryWidget*>("editEntryWidget"); QDialogButtonBox* editEntryWidgetButtonBox = editEntryWidget->findChild<QDialogButtonBox*>("buttonBox"); QTest::mouseClick(editEntryWidgetButtonBox->button(QDialogButtonBox::Ok), Qt::LeftButton); QCOMPARE(m_dbWidget->currentMode(), DatabaseWidget::ViewMode); clickIndex(entryView->model()->index(1, 0), entryView, Qt::LeftButton); QAction* entryDeleteAction = m_mainWindow->findChild<QAction*>("actionEntryDelete"); QWidget* entryDeleteWidget = toolBar->widgetForAction(entryDeleteAction); QVERIFY(entryDeleteWidget->isVisible()); QVERIFY(entryDeleteWidget->isEnabled()); QVERIFY(!m_db->metadata()->recycleBin()); QTest::mouseClick(entryDeleteWidget, Qt::LeftButton); QCOMPARE(entryView->model()->rowCount(), 3); QCOMPARE(m_db->metadata()->recycleBin()->entries().size(), 1); clickIndex(entryView->model()->index(1, 0), entryView, Qt::LeftButton); clickIndex(entryView->model()->index(2, 0), entryView, Qt::LeftButton, Qt::ControlModifier); QCOMPARE(entryView->selectionModel()->selectedRows().size(), 2); MessageBox::setNextAnswer(QMessageBox::No); QTest::mouseClick(entryDeleteWidget, Qt::LeftButton); QCOMPARE(entryView->model()->rowCount(), 3); QCOMPARE(m_db->metadata()->recycleBin()->entries().size(), 1); MessageBox::setNextAnswer(QMessageBox::Yes); QTest::mouseClick(entryDeleteWidget, Qt::LeftButton); QCOMPARE(entryView->model()->rowCount(), 1); QCOMPARE(m_db->metadata()->recycleBin()->entries().size(), 3); QWidget* closeSearchButton = m_dbWidget->findChild<QToolButton*>("closeSearchButton"); QTest::mouseClick(closeSearchButton, Qt::LeftButton); QCOMPARE(entryView->model()->rowCount(), 1); }
void TabBarWidget::contextMenuEvent(QContextMenuEvent *event) { if (event->reason() == QContextMenuEvent::Mouse) { event->accept(); return; } m_clickedTab = tabAt(event->pos()); hidePreview(); MainWindow *mainWindow = MainWindow::findMainWindow(this); QVariantMap parameters; QMenu menu(this); menu.addAction(ActionsManager::getAction(ActionsManager::NewTabAction, this)); menu.addAction(ActionsManager::getAction(ActionsManager::NewTabPrivateAction, this)); if (m_clickedTab >= 0) { Window *window = getWindow(m_clickedTab); if (window) { parameters[QLatin1String("window")] = window->getIdentifier(); } const int amount = (count() - getPinnedTabsAmount()); const bool isPinned = getTabProperty(m_clickedTab, QLatin1String("isPinned"), false).toBool(); Action *cloneTabAction = new Action(ActionsManager::CloneTabAction, &menu); cloneTabAction->setEnabled(getTabProperty(m_clickedTab, QLatin1String("canClone"), false).toBool()); cloneTabAction->setData(parameters); Action *pinTabAction = new Action(ActionsManager::PinTabAction, &menu); pinTabAction->setOverrideText(isPinned ? QT_TRANSLATE_NOOP("actions", "Unpin Tab") : QT_TRANSLATE_NOOP("actions", "Pin Tab")); pinTabAction->setData(parameters); Action *detachTabAction = new Action(ActionsManager::DetachTabAction, &menu); detachTabAction->setEnabled(count() > 1); detachTabAction->setData(parameters); Action *closeTabAction = new Action(ActionsManager::CloseTabAction, &menu); closeTabAction->setEnabled(!isPinned); closeTabAction->setData(parameters); Action *closeOtherTabsAction = new Action(ActionsManager::CloseOtherTabsAction, &menu); closeOtherTabsAction->setEnabled(amount > 0 && !(amount == 1 && !isPinned)); closeOtherTabsAction->setData(parameters); menu.addAction(cloneTabAction); menu.addAction(pinTabAction); menu.addSeparator(); menu.addAction(detachTabAction); menu.addSeparator(); menu.addAction(closeTabAction); menu.addAction(closeOtherTabsAction); menu.addAction(ActionsManager::getAction(ActionsManager::ClosePrivateTabsAction, this)); connect(cloneTabAction, SIGNAL(triggered()), mainWindow, SLOT(triggerAction())); connect(pinTabAction, SIGNAL(triggered()), mainWindow, SLOT(triggerAction())); connect(detachTabAction, SIGNAL(triggered()), mainWindow, SLOT(triggerAction())); connect(closeTabAction, SIGNAL(triggered()), mainWindow, SLOT(triggerAction())); connect(closeOtherTabsAction, SIGNAL(triggered()), mainWindow, SLOT(triggerAction())); } menu.addSeparator(); QMenu *arrangeMenu = menu.addMenu(tr("Arrange")); Action *restoreTabAction = new Action(ActionsManager::RestoreTabAction, &menu); restoreTabAction->setEnabled(m_clickedTab >= 0); restoreTabAction->setData(parameters); Action *minimizeTabAction = new Action(ActionsManager::MinimizeTabAction, &menu); minimizeTabAction->setEnabled(m_clickedTab >= 0); minimizeTabAction->setData(parameters); Action *maximizeTabAction = new Action(ActionsManager::MaximizeTabAction, &menu); maximizeTabAction->setEnabled(m_clickedTab >= 0); maximizeTabAction->setData(parameters); arrangeMenu->addAction(restoreTabAction); arrangeMenu->addAction(minimizeTabAction); arrangeMenu->addAction(maximizeTabAction); arrangeMenu->addSeparator(); arrangeMenu->addAction(ActionsManager::getAction(ActionsManager::RestoreAllAction, this)); arrangeMenu->addAction(ActionsManager::getAction(ActionsManager::MaximizeAllAction, this)); arrangeMenu->addAction(ActionsManager::getAction(ActionsManager::MinimizeAllAction, this)); arrangeMenu->addSeparator(); arrangeMenu->addAction(ActionsManager::getAction(ActionsManager::CascadeAllAction, this)); arrangeMenu->addAction(ActionsManager::getAction(ActionsManager::TileAllAction, this)); QAction *cycleAction = new QAction(tr("Switch tabs using the mouse wheel"), this); cycleAction->setCheckable(true); cycleAction->setChecked(!SettingsManager::getValue(QLatin1String("TabBar/RequireModifierToSwitchTabOnScroll")).toBool()); connect(cycleAction, SIGNAL(toggled(bool)), this, SLOT(setCycle(bool))); connect(restoreTabAction, SIGNAL(triggered()), mainWindow, SLOT(triggerAction())); connect(minimizeTabAction, SIGNAL(triggered()), mainWindow, SLOT(triggerAction())); connect(maximizeTabAction, SIGNAL(triggered()), mainWindow, SLOT(triggerAction())); ToolBarWidget *toolBar = qobject_cast<ToolBarWidget*>(parentWidget()); if (toolBar) { QList<QAction*> actions; actions.append(cycleAction); menu.addMenu(ToolBarWidget::createCustomizationMenu(ToolBarsManager::TabBar, actions, &menu)); } else { QMenu *customizationMenu = menu.addMenu(tr("Customize")); customizationMenu->addAction(cycleAction); customizationMenu->addSeparator(); customizationMenu->addAction(ActionsManager::getAction(ActionsManager::LockToolBarsAction, this)); } menu.exec(event->globalPos()); cycleAction->deleteLater(); m_clickedTab = -1; if (underMouse()) { m_previewTimer = startTimer(250); } }
FileRenamerDlgImpl::FileRenamerDlgImpl(QWidget* pParent, CommonData* pCommonData, bool bUseCurrentView) : QDialog(pParent, getDialogWndFlags()), Ui::FileRenamerDlg(), m_pCommonData(pCommonData), m_bUseCurrentView(bUseCurrentView), m_pEditor(0) { setupUi(this); resizeIcons(); m_pHndlrListModel = new HndlrListModel(m_pCommonData, this, bUseCurrentView); { m_pCurrentAlbumG->verticalHeader()->setResizeMode(QHeaderView::Interactive); m_pCurrentAlbumG->verticalHeader()->setMinimumSectionSize(CELL_HEIGHT + 1); m_pCurrentAlbumG->verticalHeader()->setDefaultSectionSize(CELL_HEIGHT + 1);//*/ m_pCurrentAlbumG->setModel(m_pHndlrListModel); CurrentAlbumDelegate* pDel (new CurrentAlbumDelegate(this, m_pHndlrListModel)); m_pCurrentAlbumG->setItemDelegate(pDel); m_pCurrentAlbumG->viewport()->installEventFilter(this); } m_pButtonGroup = new QButtonGroup(this); loadPatterns(); updateButtons(); { int nWidth, nHeight; bool bKeepOriginal, bUnratedAsDuplicate; m_pCommonData->m_settings.loadRenamerSettings(nWidth, nHeight, m_nSaButton, m_nVaButton, bKeepOriginal, bUnratedAsDuplicate); if (nWidth > 400 && nHeight > 400) { resize(nWidth, nHeight); } else { defaultResize(*this); } if (m_nVaButton >= cSize(m_vstrPatterns) || m_nVaButton <= 0) { m_nVaButton = 0; } if (m_nSaButton >= cSize(m_vstrPatterns) || m_nSaButton <= 0) { m_nSaButton = 0; } m_pKeepOriginalCkB->setChecked(bKeepOriginal); m_pMarkUnratedAsDuplicatesCkB->setChecked(bUnratedAsDuplicate); } { m_pModifRenameB = new ModifInfoToolButton(m_pRenameB); connect(m_pModifRenameB, SIGNAL(clicked()), this, SLOT(on_m_pRenameB_clicked())); m_pRenameB = m_pModifRenameB; } { QAction* p (new QAction(this)); p->setShortcut(QKeySequence("F1")); connect(p, SIGNAL(triggered()), this, SLOT(onHelp())); addAction(p); } if (m_bUseCurrentView) { m_pCrtDirTagEdtE->setEnabled(false); m_pPrevB->setEnabled(false); m_pNextB->setEnabled(false); } if (!m_pCommonData->m_bShowCustomCloseButtons) { m_pCloseB->hide(); } QTimer::singleShot(1, this, SLOT(onShow())); // just calls reloadTable(); !!! needed to properly resize the table columns; album and file tables have very small widths until they are actually shown, so calling resizeTagEditor() earlier is pointless; calling update() on various layouts seems pointless as well; (see also DoubleList::resizeEvent() ) }
void TitleWidget::initAction() { m_menu = new QMenu(this); m_menu->setObjectName("MainMenu"); QAction *searchAction = new QAction("搜索", m_menu); searchAction->setIcon(QIcon(":/menu_icon/search")); searchAction->setShortcut(tr("Ctrl+S")); searchAction->setStatusTip("搜索单曲,歌单..."); connect(searchAction, SIGNAL(triggered()), this, SIGNAL(search())); QAction *logOutAction = new QAction("注销", m_menu); logOutAction->setIcon(QIcon(":/menu_icon/logout")); logOutAction->setShortcut(tr("Ctrl+E")); logOutAction->setStatusTip("退出登录..."); connect(logOutAction, SIGNAL(triggered()), this, SIGNAL(logOut())); allLoopAction = new QAction("列表循环", m_menu); //allLoopAction->setIcon(QIcon(":/menu_icon/list_loop")); allLoopAction->setShortcut(tr("Ctrl+A")); allLoopAction->setCheckable(true); allLoopAction->setChecked(true); allLoopAction->setStatusTip("列表循环播放歌曲..."); connect(allLoopAction, SIGNAL(triggered()), this, SLOT(setAllLoopChecked())); oneLoopAction = new QAction("单曲循环", m_menu); //oneLoopAction->setIcon(QIcon(":/menu_icon/one_loop")); oneLoopAction->setShortcut(tr("Ctrl+O")); oneLoopAction->setCheckable(true); oneLoopAction->setChecked(false); oneLoopAction->setStatusTip("单曲循环播放歌曲..."); connect(oneLoopAction, SIGNAL(triggered()), this, SLOT(setOneLoopChecked())); randomLoopAction = new QAction("随机循环", m_menu); //randomLoopAction->setIcon(QIcon(":/menu_icon/random_loop")); randomLoopAction->setCheckable(true); randomLoopAction->setChecked(false); randomLoopAction->setShortcut(tr("Ctrl+R")); randomLoopAction->setStatusTip("随机循环播放歌曲..."); connect(randomLoopAction, SIGNAL(triggered()), this, SLOT(setRandomLoopChecked())); QAction *exitAction = new QAction("退出软件", m_menu); exitAction->setIcon(QIcon(":/menu_icon/exit")); exitAction->setShortcut(tr("Ctrl+Q")); connect(exitAction, SIGNAL(triggered()), this, SIGNAL(exitWidget())); m_menu->addAction(searchAction); m_menu->addSeparator(); m_menu->addAction(oneLoopAction); m_menu->addAction(allLoopAction); m_menu->addAction(randomLoopAction); m_menu->addSeparator(); m_menu->addAction(logOutAction); m_menu->addSeparator(); m_menu->addAction(exitAction); m_menu->adjustSize(); m_menu->setVisible(false); }
// main tab slots void MainWindow::mainTabContextualMenu(const QPoint &pos) { if (debug) qDebug() << PDEBUG; if (ui->tableWidget_main->currentItem() == nullptr) return; // create menu QMenu menu(this); QAction *refreshTable = menu.addAction(QApplication::translate("MainWindow", "Refresh")); refreshTable->setIcon(QIcon::fromTheme("view-refresh")); menu.addSeparator(); QAction *startProfile = menu.addAction(QApplication::translate("MainWindow", "Start profile")); QAction *restartProfile = menu.addAction(QApplication::translate("MainWindow", "Restart profile")); restartProfile->setIcon(QIcon::fromTheme("view-refresh")); QAction *enableProfile = menu.addAction(QApplication::translate("MainWindow", "Enable profile")); menu.addSeparator(); QAction *editProfile = menu.addAction(QApplication::translate("MainWindow", "Edit profile")); editProfile->setIcon(QIcon::fromTheme("document-edit")); QAction *removeProfile = menu.addAction(QApplication::translate("MainWindow", "Remove profile")); removeProfile->setIcon(QIcon::fromTheme("edit-delete")); // set text if (!ui->tableWidget_main->item(ui->tableWidget_main->currentItem()->row(), 2)->text().isEmpty()) { restartProfile->setVisible(true); startProfile->setText(QApplication::translate("MainWindow", "Stop profile")); startProfile->setIcon(QIcon::fromTheme("process-stop")); } else { restartProfile->setVisible(false); startProfile->setText(QApplication::translate("MainWindow", "Start profile")); startProfile->setIcon(QIcon::fromTheme("system-run")); } if (!ui->tableWidget_main->item(ui->tableWidget_main->currentItem()->row(), 3)->text().isEmpty()) { enableProfile->setText(QApplication::translate("MainWindow", "Disable profile")); enableProfile->setIcon(QIcon::fromTheme("edit-remove")); } else { enableProfile->setText(QApplication::translate("MainWindow", "Enable profile")); enableProfile->setIcon(QIcon::fromTheme("edit-add")); } // actions QAction *action = menu.exec(ui->tableWidget_main->viewport()->mapToGlobal(pos)); if (action == refreshTable) { if (debug) qDebug() << PDEBUG << ":" << "Refresh table"; updateMainTab(); } else if (action == startProfile) { if (debug) qDebug() << PDEBUG << ":" << "Start profile"; mainTabStartProfile(); } else if (action == restartProfile) { if (debug) qDebug() << PDEBUG << ":" << "Restart profile"; mainTabRestartProfile(); } else if (action == enableProfile) { if (debug) qDebug() << PDEBUG << ":" << "Enable profile"; mainTabEnableProfile(); } else if (action == editProfile) { if (debug) qDebug() << PDEBUG << ":" << "Edit profile"; mainTabEditProfile(); } else if (action == removeProfile) { if (debug) qDebug() << PDEBUG << ":" << "Remove profile"; mainTabRemoveProfile(); } }
void tst_QActionGroup::enabledPropagation() { QActionGroup testActionGroup( 0 ); QAction* childAction = new QAction( &testActionGroup ); QAction* anotherChildAction = new QAction( &testActionGroup ); QAction* freeAction = new QAction(0); QVERIFY( testActionGroup.isEnabled() ); QVERIFY( childAction->isEnabled() ); testActionGroup.setEnabled( false ); QVERIFY( !testActionGroup.isEnabled() ); QVERIFY( !childAction->isEnabled() ); QVERIFY( !anotherChildAction->isEnabled() ); childAction->setEnabled(true); QVERIFY( !childAction->isEnabled()); anotherChildAction->setEnabled( false ); testActionGroup.setEnabled( true ); QVERIFY( testActionGroup.isEnabled() ); QVERIFY( childAction->isEnabled() ); QVERIFY( !anotherChildAction->isEnabled() ); testActionGroup.setEnabled( false ); QAction *lastChildAction = new QAction(&testActionGroup); QVERIFY(!lastChildAction->isEnabled()); testActionGroup.setEnabled( true ); QVERIFY(lastChildAction->isEnabled()); freeAction->setEnabled(false); testActionGroup.addAction(freeAction); QVERIFY(!freeAction->isEnabled()); delete freeAction; }
void tst_QActionGroup::exclusive() { QActionGroup group(0); group.setExclusive(false); QVERIFY( !group.isExclusive() ); QAction* actOne = new QAction( &group ); actOne->setCheckable( true ); QAction* actTwo = new QAction( &group ); actTwo->setCheckable( true ); QAction* actThree = new QAction( &group ); actThree->setCheckable( true ); group.setExclusive( true ); QVERIFY( !actOne->isChecked() ); QVERIFY( !actTwo->isChecked() ); QVERIFY( !actThree->isChecked() ); actOne->setChecked( true ); QVERIFY( actOne->isChecked() ); QVERIFY( !actTwo->isChecked() ); QVERIFY( !actThree->isChecked() ); actTwo->setChecked( true ); QVERIFY( !actOne->isChecked() ); QVERIFY( actTwo->isChecked() ); QVERIFY( !actThree->isChecked() ); }
void Kiten::setupActions() { /* Add the basic quit/print/prefs actions, use the gui factory for keybindings */ (void) KStandardAction::quit( this, SLOT(close()), actionCollection() ); //Why the heck is KSA:print adding it's own toolbar!? // (void) KStandardAction::print(this, SLOT(print()), actionCollection()); (void) KStandardAction::preferences( this, SLOT(slotConfigure()), actionCollection() ); //old style cast seems needed here, (const QObject*) KStandardAction::keyBindings( (const QObject*)guiFactory() , SLOT(configureShortcuts()) , actionCollection() ); /* Setup the Go-to-learn-mode actions */ /* TODO: put back when Dictionary Editor is reorganised */ // (void) new KAction( i18n( "&Dictionary Editor..." ) // , "document-properties" // , 0 // , this // , SLOT(createEEdit()) // , actionCollection() // , "dict_editor"); QAction *radselect = actionCollection()->addAction( "radselect" ); radselect->setText( i18n( "Radical Selector" ) ); // radselect->setIcon( "edit-find" ); actionCollection()->setDefaultShortcut(radselect, Qt::CTRL+Qt::Key_R ); connect(radselect, &QAction::triggered, this, &Kiten::radicalSearch); QAction *kanjibrowser = actionCollection()->addAction( "kanjibrowser" ); kanjibrowser->setText( i18n( "Kanji Browser" ) ); actionCollection()->setDefaultShortcut(kanjibrowser, Qt::CTRL+Qt::Key_K ); connect(kanjibrowser, &QAction::triggered, this, &Kiten::kanjiBrowserSearch); /* Setup the Search Actions and our custom Edit Box */ _inputManager = new SearchStringInput( this ); QAction *searchButton = actionCollection()->addAction( "search" ); searchButton->setText( i18n( "S&earch" ) ); // Set the search button to search connect(searchButton, &QAction::triggered, this, &Kiten::searchFromEdit); searchButton->setIcon( KStandardGuiItem::find().icon() ); // That's not it, that's "find as you type"... // connect( Edit, SIGNAL(completion(QString)), // this, SLOT(searchFromEdit()) ); /* Setup our widgets that handle preferences */ // deinfCB = new KToggleAction( i18n( "&Deinflect Verbs in Regular Search" ) // , 0 // , this // , SLOT(kanjiDictChange()) // , actionCollection() // , "deinf_toggle" ); _autoSearchToggle = actionCollection()->add<KToggleAction>( "autosearch_toggle" ); _autoSearchToggle->setText( i18n( "&Automatically Search Clipboard Selections" ) ); _irAction = actionCollection()->add<QAction>( "search_in_results" ); _irAction->setText( i18n( "Search &in Results" ) ); connect(_irAction, &QAction::triggered, this, &Kiten::searchInResults); QAction *actionFocusResultsView; actionFocusResultsView = actionCollection()->addAction( "focusresultview" , this , SLOT(focusResultsView()) ); actionCollection()->setDefaultShortcut(actionFocusResultsView, Qt::Key_Escape ); actionFocusResultsView->setText( i18n( "Focus result view" ) ); (void) KStandardAction::configureToolbars( this , SLOT(configureToolBars()) , actionCollection() ); //TODO: this should probably be a standard action /* globalShortcutsAction = actionCollection()->addAction( "options_configure_global_keybinding" ); globalShortcutsAction->setText( i18n( "Configure &Global Shortcuts..." ) ); connect( globalShortcutsAction, SIGNAL(triggered()), this, SLOT(configureGlobalKeys()) ); */ //TODO: implement this //_globalSearchAction = actionCollection()->add<KToggleAction>( "search_on_the_spot" ); //_globalSearchAction->setText( i18n( "On The Spo&t Search" ) ); //KAction *temp = qobject_cast<KAction*>( _globalSearchAction ); //KShortcut shrt( "Ctrl+Alt+S" ); //globalSearchAction->setGlobalShortcut(shrt); //FIXME: Why does this take ~50 seconds to return!? //connect(globalSearchAction, SIGNAL(triggered()), this, SLOT(searchOnTheSpot())); _backAction = KStandardAction::back( this, SLOT(back()), actionCollection() ); _forwardAction = KStandardAction::forward( this, SLOT(forward()), actionCollection() ); _backAction->setEnabled( false ); _forwardAction->setEnabled( false ); }
// Local context menu handler. void qtractorTimeSpinBox::contextMenuEvent ( QContextMenuEvent *pContextMenuEvent ) { // QAbstractSpinBox::contextMenuEvent(pContextMenuEvent); if (m_pTimeScale == NULL) return; QMenu menu(this); QAction *pAction; pAction = menu.addAction(tr("&Frames")); pAction->setCheckable(true); pAction->setChecked(m_displayFormat == qtractorTimeScale::Frames); pAction->setData(int(qtractorTimeScale::Frames)); pAction = menu.addAction(tr("&Time")); pAction->setCheckable(true); pAction->setChecked(m_displayFormat == qtractorTimeScale::Time); pAction->setData(int(qtractorTimeScale::Time)); pAction = menu.addAction(tr("&BBT")); pAction->setCheckable(true); pAction->setChecked(m_displayFormat == qtractorTimeScale::BBT); pAction->setData(int(qtractorTimeScale::BBT)); pAction = menu.exec(pContextMenuEvent->globalPos()); if (pAction == NULL) return; const qtractorTimeScale::DisplayFormat displayFormat = qtractorTimeScale::DisplayFormat(pAction->data().toInt()); if (displayFormat != m_displayFormat) { setDisplayFormat(displayFormat); emit displayFormatChanged(int(displayFormat)); } }
void LatchManager::playlistChanged( Tomahawk::playlistinterface_ptr ) { // If we were latched on and changed, send the listening along stop if ( m_latchedOnTo.isNull() ) { if ( m_waitingForLatch.isNull() ) return; // Neither latched on nor waiting to be latched on, no-op m_latchedOnTo = m_waitingForLatch; m_latchedInterface = m_waitingForLatch->playlistInterface(); m_waitingForLatch.clear(); m_state = Latched; DatabaseCommand_SocialAction* cmd = new DatabaseCommand_SocialAction(); cmd->setSource( SourceList::instance()->getLocal() ); cmd->setAction( "latchOn"); cmd->setComment( m_latchedOnTo->nodeId() ); cmd->setTimestamp( QDateTime::currentDateTime().toTime_t() ); Database::instance()->enqueue( QSharedPointer< DatabaseCommand >( cmd ) ); QAction *latchOnAction = ActionCollection::instance()->getAction( "latchOn" ); latchOnAction->setText( tr( "&Catch Up" ) ); latchOnAction->setIcon( QIcon() ); // If not, then keep waiting return; } // We're current latched, and the user changed playlist, so stop SourcePlaylistInterface* origsourcepi = dynamic_cast< SourcePlaylistInterface* >( m_latchedInterface.data() ); Q_ASSERT( origsourcepi ); const source_ptr source = SourceList::instance()->get( origsourcepi->source()->id() ); DatabaseCommand_SocialAction* cmd = new DatabaseCommand_SocialAction(); cmd->setSource( SourceList::instance()->getLocal() ); cmd->setAction( "latchOff"); cmd->setComment( source->nodeId() ); cmd->setTimestamp( QDateTime::currentDateTime().toTime_t() ); Database::instance()->enqueue( QSharedPointer< DatabaseCommand >( cmd ) ); if ( !m_waitingForLatch.isNull() && m_waitingForLatch != m_latchedOnTo ) { // We are asked to latch on immediately to another source m_latchedOnTo.clear(); m_latchedInterface.clear(); // call ourselves to hit the "create latch" condition playlistChanged( Tomahawk::playlistinterface_ptr() ); return; } m_latchedOnTo.clear(); m_waitingForLatch.clear(); m_latchedInterface.clear(); m_state = NotLatched; QAction *latchOnAction = ActionCollection::instance()->getAction( "latchOn" ); latchOnAction->setText( tr( "&Listen Along" ) ); latchOnAction->setIcon( QIcon( RESPATH "images/headphones-sidebar.png" ) ); }
KisPaletteManager::KisPaletteManager(KoFavoriteResourceManager *manager, KisPaintopBox *paintOpBox) : QDialog(paintOpBox) , m_saveButton(0) , m_removeButton(0) , m_resourceManager(manager) , m_paintOpBox(paintOpBox) { setWindowTitle(i18n("Palette Manager")); m_allPresetsView = new KisPresetChooser(this); m_allPresetsView->showButtons(false); m_allPresetsView->showTaggingBar(false,false); m_palettePresetsView = new KisPresetChooser(this); m_palettePresetsView->showButtons(false); m_palettePresetsView->showTaggingBar(false,false); /*LEFT COMPONENTS*/ QFrame *HSeparator = new QFrame(); HSeparator->setFrameStyle(QFrame::HLine | QFrame::Sunken); m_saveButton = new QPushButton (i18n("Add to Palette")); m_saveButton->setSizePolicy(QSizePolicy::Fixed , QSizePolicy::Fixed); m_saveButton->setEnabled(false); /*LEFT LAYOUT*/ QVBoxLayout *leftLayout = new QVBoxLayout (); leftLayout->addWidget(new QLabel(i18n("Available Presets"))); leftLayout->addWidget(m_allPresetsView); leftLayout->addWidget(m_saveButton); m_allPresetsView->updateViewSettings(); /*CENTER COMPONENT : Divider*/ QFrame *VSeparator = new QFrame(); VSeparator->setFrameStyle(QFrame::VLine | QFrame::Sunken); /*RIGHT COMPONENTS*/ m_removeButton = new QPushButton(i18n("Remove Preset")); m_removeButton->setSizePolicy(QSizePolicy::Fixed , QSizePolicy::Fixed); m_removeButton->setEnabled(false);//set the button to center /*RIGHT LAYOUT*/ QVBoxLayout *rightLayout = new QVBoxLayout(); rightLayout->addWidget(new QLabel(i18n("Favorite Presets"))); rightLayout->addWidget(m_palettePresetsView); /*RIGHT BOTTOM LAYOUT*/ QHBoxLayout *rightBottomLayout = new QHBoxLayout(); rightBottomLayout->addWidget(m_removeButton); rightBottomLayout->addSpacerItem(new QSpacerItem(0, 0, QSizePolicy::Expanding)); QToolButton* viewButton = new QToolButton(); viewButton->setPopupMode(QToolButton::InstantPopup); rightBottomLayout->addWidget(viewButton); rightLayout->addLayout(rightBottomLayout); QMenu* menu = new QMenu(this); QActionGroup *actionGroup = new QActionGroup(this); KConfigGroup group(KGlobal::config(), "favoriteList"); KisPresetChooser::ViewMode mode = (KisPresetChooser::ViewMode)group.readEntry("presetChooserViewMode", 0); m_allPresetsView->setViewMode(mode); m_palettePresetsView->setViewMode(mode); QAction* action = menu->addAction(koIcon("view-preview"), i18n("Thumbnails"), this, SLOT(slotThumbnailMode())); action->setCheckable(true); action->setChecked(mode == KisPresetChooser::THUMBNAIL); action->setActionGroup(actionGroup); action = menu->addAction(koIcon("view-list-details"), i18n("Details"), this, SLOT(slotDetailMode())); action->setCheckable(true); action->setChecked(mode == KisPresetChooser::DETAIL); action->setActionGroup(actionGroup); viewButton->setIcon(koIcon("view-choose")); viewButton->setMenu(menu); /*MAIN LAYOUT*/ QHBoxLayout *mainLayout = new QHBoxLayout(); mainLayout->addLayout(leftLayout); mainLayout->addWidget(VSeparator); mainLayout->addLayout(rightLayout); setLayout(mainLayout); /*SIGNALS AND SLOTS*/ connect(m_allPresetsView, SIGNAL(resourceSelected(KoResource*)), this, SLOT(slotUpdateAddButton()) ); connect(m_palettePresetsView, SIGNAL(resourceSelected(KoResource*)), this, SLOT(slotEnableRemoveButton()) ); connect(m_removeButton, SIGNAL(clicked()), this, SLOT(slotDeleteBrush())); connect(m_saveButton, SIGNAL(clicked()), this, SLOT(slotAddBrush())); updatePaletteView(); }
void ResultsTree::contextMenuEvent(QContextMenuEvent * e) { QModelIndex index = indexAt(e->pos()); if (index.isValid()) { bool multipleSelection = false; mSelectionModel = selectionModel(); if (mSelectionModel->selectedRows().count() > 1) multipleSelection = true; mContextItem = mModel.itemFromIndex(index); //Create a new context menu QMenu menu(this); //Store all applications in a list QList<QAction*> actions; //Create a signal mapper so we don't have to store data to class //member variables QSignalMapper *signalMapper = new QSignalMapper(this); if (mContextItem && mApplications->GetApplicationCount() > 0 && mContextItem->parent()) { //Go through all applications and add them to the context menu for (int i = 0; i < mApplications->GetApplicationCount(); i++) { //Create an action for the application const Application app = mApplications->GetApplication(i); QAction *start = new QAction(app.getName(), &menu); if (multipleSelection) start->setDisabled(true); //Add it to our list so we can disconnect later on actions << start; //Add it to context menu menu.addAction(start); //Connect the signal to signal mapper connect(start, SIGNAL(triggered()), signalMapper, SLOT(map())); //Add a new mapping signalMapper->setMapping(start, i); } connect(signalMapper, SIGNAL(mapped(int)), this, SLOT(Context(int))); } // Add menuitems to copy full path/filename to clipboard if (mContextItem) { if (mApplications->GetApplicationCount() > 0) { menu.addSeparator(); } //Create an action for the application QAction *copyfilename = new QAction(tr("Copy filename"), &menu); QAction *copypath = new QAction(tr("Copy full path"), &menu); QAction *copymessage = new QAction(tr("Copy message"), &menu); QAction *hide = new QAction(tr("Hide"), &menu); if (multipleSelection) { copyfilename->setDisabled(true); copypath->setDisabled(true); copymessage->setDisabled(true); } menu.addAction(copyfilename); menu.addAction(copypath); menu.addAction(copymessage); menu.addAction(hide); connect(copyfilename, SIGNAL(triggered()), this, SLOT(CopyFilename())); connect(copypath, SIGNAL(triggered()), this, SLOT(CopyFullPath())); connect(copymessage, SIGNAL(triggered()), this, SLOT(CopyMessage())); connect(hide, SIGNAL(triggered()), this, SLOT(HideResult())); } //Start the menu menu.exec(e->globalPos()); if (mContextItem && mApplications->GetApplicationCount() > 0 && mContextItem->parent()) { //Disconnect all signals for (int i = 0; i < actions.size(); i++) { disconnect(actions[i], SIGNAL(triggered()), signalMapper, SLOT(map())); } disconnect(signalMapper, SIGNAL(mapped(int)), this, SLOT(Context(int))); //And remove the signal mapper delete signalMapper; } }
void KviWindow::createSystemTextEncodingPopup() { if(!g_pMdiWindowSystemTextEncodingPopup) { // first time called, create the menu g_pMdiWindowSystemTextEncodingPopup = new QMenu(); g_pMdiWindowSystemTextEncodingPopupStandard = new QMenu(); g_pMdiWindowSystemTextEncodingPopupSmart = new QMenu(); g_pMdiWindowSystemTextEncodingPopupSmartUtf8 = new QMenu(); g_pMdiWindowSystemTextEncodingActionGroup = new QActionGroup(g_pMdiWindowSystemTextEncodingPopup); //default action QTextCodec * pCodec = defaultTextCodec(); QString szTmp = __tr2qs("Use Default Encoding"); if(pCodec) { szTmp += " ("; szTmp += pCodec->name(); szTmp += ")"; } g_pMdiWindowSystemTextEncodingDefaultAction = g_pMdiWindowSystemTextEncodingPopup->addAction(szTmp); g_pMdiWindowSystemTextEncodingActionGroup->addAction(g_pMdiWindowSystemTextEncodingDefaultAction); g_pMdiWindowSystemTextEncodingDefaultAction->setData(-1); if(m_szTextEncoding.isEmpty()) { g_pMdiWindowSystemTextEncodingDefaultAction->setCheckable(true); g_pMdiWindowSystemTextEncodingDefaultAction->setChecked(true); } //current action g_pMdiWindowSystemTextEncodingCurrentAction = g_pMdiWindowSystemTextEncodingPopup->addAction(__tr2qs("Current: ")); g_pMdiWindowSystemTextEncodingActionGroup->addAction(g_pMdiWindowSystemTextEncodingCurrentAction); g_pMdiWindowSystemTextEncodingCurrentAction->setVisible(false); // other first level menus g_pMdiWindowSystemTextEncodingPopup->addSeparator(); QAction * pAction = g_pMdiWindowSystemTextEncodingPopup->addAction(__tr2qs("Standard")); pAction->setMenu(g_pMdiWindowSystemTextEncodingPopupStandard); pAction = g_pMdiWindowSystemTextEncodingPopup->addAction(__tr2qs("Smart (Send Local)")); pAction->setMenu(g_pMdiWindowSystemTextEncodingPopupSmart); pAction = g_pMdiWindowSystemTextEncodingPopup->addAction(__tr2qs("Smart (Send UTF-8)")); pAction->setMenu(g_pMdiWindowSystemTextEncodingPopupSmartUtf8); // second level menus (encoding groups) QMenu * pPopupStandard[KVI_NUM_ENCODING_GROUPS]; QMenu * pPopupSmart[KVI_NUM_ENCODING_GROUPS]; QMenu * pPopupSmartUtf8[KVI_NUM_ENCODING_GROUPS]; uint u = 0; const char * pcEncodingGroup = KviLocale::instance()->encodingGroup(u); while(pcEncodingGroup) { pPopupStandard[u] = g_pMdiWindowSystemTextEncodingPopupStandard->addMenu(pcEncodingGroup); if(u) //only standard popup contains unicode menu { pPopupSmart[u] = g_pMdiWindowSystemTextEncodingPopupSmart->addMenu(pcEncodingGroup); pPopupSmartUtf8[u] = g_pMdiWindowSystemTextEncodingPopupSmartUtf8->addMenu(pcEncodingGroup); } pcEncodingGroup = KviLocale::instance()->encodingGroup(++u); } // third level menus (encodings) uint i = 0; KviLocale::EncodingDescription * pDesc = KviLocale::instance()->encodingDescription(i); while(pDesc->pcName) { szTmp = QString("%1 (%2)").arg(pDesc->pcName, pDesc->pcDescription); if(KviQString::equalCI(m_szTextEncoding, pDesc->pcName)) { g_pMdiWindowSystemTextEncodingCurrentAction->setText(__tr2qs("Current: ") + szTmp); g_pMdiWindowSystemTextEncodingCurrentAction->setCheckable(true); g_pMdiWindowSystemTextEncodingCurrentAction->setChecked(true); g_pMdiWindowSystemTextEncodingCurrentAction->setVisible(true); g_pMdiWindowSystemTextEncodingCurrentAction->setData(i); } QMenu * pMenu = pDesc->bSmart ? (pDesc->bSendUtf8 ? pPopupSmartUtf8[pDesc->uGroup] : pPopupSmart[pDesc->uGroup]) : pPopupStandard[pDesc->uGroup]; QAction * pAction = pMenu->addAction(szTmp); pAction->setData(i); g_pMdiWindowSystemTextEncodingActionGroup->addAction(pAction); pDesc = KviLocale::instance()->encodingDescription(++i); } } else { //default action: refresh the name QTextCodec * pCodec = defaultTextCodec(); QString szTmp = __tr2qs("Use Default Encoding"); if(pCodec) { szTmp += " ("; szTmp += pCodec->name(); szTmp += ")"; } disconnect(g_pMdiWindowSystemTextEncodingActionGroup, SIGNAL(triggered(QAction *)), nullptr, nullptr); connect(g_pMdiWindowSystemTextEncodingActionGroup, SIGNAL(triggered(QAction *)), this, SLOT(systemTextEncodingPopupActivated(QAction *))); g_pMdiWindowSystemTextEncodingDefaultAction->setText(szTmp); //menu already exists, choose the right item if(m_szTextEncoding.isEmpty()) { //default action; hide the current action g_pMdiWindowSystemTextEncodingCurrentAction->setVisible(false); g_pMdiWindowSystemTextEncodingDefaultAction->setCheckable(true); g_pMdiWindowSystemTextEncodingDefaultAction->setChecked(true); } else { int i = 0; KviLocale::EncodingDescription * pDesc = KviLocale::instance()->encodingDescription(i); while(pDesc->pcName) { if(KviQString::equalCI(m_szTextEncoding, pDesc->pcName)) { szTmp = QString("%1 (%2)").arg(pDesc->pcName, pDesc->pcDescription); g_pMdiWindowSystemTextEncodingCurrentAction->setText(__tr2qs("Current: ") + szTmp); g_pMdiWindowSystemTextEncodingCurrentAction->setCheckable(true); g_pMdiWindowSystemTextEncodingCurrentAction->setChecked(true); g_pMdiWindowSystemTextEncodingCurrentAction->setVisible(true); g_pMdiWindowSystemTextEncodingCurrentAction->setData(i); break; } pDesc = KviLocale::instance()->encodingDescription(++i); } } } disconnect(g_pMdiWindowSystemTextEncodingActionGroup, SIGNAL(triggered(QAction *)), nullptr, nullptr); connect(g_pMdiWindowSystemTextEncodingActionGroup, SIGNAL(triggered(QAction *)), this, SLOT(systemTextEncodingPopupActivated(QAction *))); }
void TextCanvas::menu(const QPoint &) { QMenu m(0); QMenu fontsubm(0); MenuFactory::createTitle(m, QObject::tr("Text")); m.addSeparator(); MenuFactory::addItem(m, QObject::tr("Upper"), 0); MenuFactory::addItem(m, QObject::tr("Lower"), 1); MenuFactory::addItem(m, QObject::tr("Go up"), 6); MenuFactory::addItem(m, QObject::tr("Go down"), 7); m.addSeparator(); MenuFactory::addItem(m, QObject::tr("Edit"), 2); m.addSeparator(); MenuFactory::addItem(m, QObject::tr("Color"), 5); MenuFactory::insertItem(m, QObject::tr("Font"), &fontsubm); init_font_menu(fontsubm, the_canvas(), 10); if (linked()) { m.addSeparator(); MenuFactory::addItem(m, QObject::tr("Select linked items"), 3); } m.addSeparator(); MenuFactory::addItem(m, QObject::tr("Remove from diagram"), 4); QAction* retAction = m.exec(QCursor::pos()); if(retAction) { int index = retAction->data().toInt(); switch (index) { case 0: upper(); // force son reaffichage hide(); show(); canvas()->update(); break; case 1: lower(); // force son reaffichage hide(); show(); canvas()->update(); break; case 6: z_up(); // force son reaffichage hide(); show(); canvas()->update(); break; case 7: z_down(); // force son reaffichage hide(); show(); canvas()->update(); break; case 2: open(); return; // call package_modified case 3: the_canvas()->unselect_all(); select_associated(); return; case 4: // delete the_canvas()->del(this); break; case 5: for (;;) { ColorSpecVector co(2); co[0].set( QObject::tr("foreground"), &fg_c); co[1].set( QObject::tr("background"), &bg_c); SettingsDialog dialog(0, &co, TRUE, FALSE, QObject::tr("Text color dialog")); dialog.raise(); if (dialog.exec() != QDialog::Accepted) return; // force son reaffichage hide(); show(); canvas()->update(); if (!dialog.redo()) break; else package_modified(); } break; default: if (index >= 10) { itsfont = (UmlFont)(index - 10); // force son reaffichage hide(); show(); canvas()->update(); break; } else return; } } package_modified(); }
void BrailleMusicEditor::setupFileActions() { auto tb = new QToolBar(this); tb->setWindowTitle(tr("File Actions")); addToolBar(tb); auto menu = new QMenu(tr("&File"), this); menuBar()->addMenu(menu); QAction *a; auto newIcon = QIcon::fromTheme("document-new"); a = new QAction(newIcon, tr("&New"), this); a->setPriority(QAction::LowPriority); a->setShortcut(QKeySequence::New); connect(a, &QAction::triggered, this, &BrailleMusicEditor::fileNew); tb->addAction(a); menu->addAction(a); a = new QAction(QIcon::fromTheme("document-open"), tr("&Open..."), this); a->setShortcut(QKeySequence::Open); connect(a, &QAction::triggered, this, &BrailleMusicEditor::fileOpen); tb->addAction(a); menu->addAction(a); menu->addSeparator(); actionSave = a = new QAction(QIcon::fromTheme("document-save"), tr("&Save"), this); a->setShortcut(QKeySequence::Save); connect(a, &QAction::triggered, this, &BrailleMusicEditor::fileSave); a->setEnabled(false); tb->addAction(a); menu->addAction(a); a = new QAction(tr("Save &As..."), this); a->setPriority(QAction::LowPriority); connect(a, &QAction::triggered, this, &BrailleMusicEditor::fileSaveAs); menu->addAction(a); menu->addSeparator(); a = new QAction(tr("&Compile"), this); a->setPriority(QAction::LowPriority); a->setShortcut(Qt::Key_F8); connect(a, &QAction::triggered, this, &BrailleMusicEditor::fileCompile); menu->addAction(a); a = new QAction(tr("Export &MusicXML"), this); a->setPriority(QAction::LowPriority); connect(a, &QAction::triggered, this, &BrailleMusicEditor::fileExportMusicXML); a->setEnabled(false); connect(this, &BrailleMusicEditor::scoreAvailable, a, &QAction::setEnabled); menu->addAction(a); a = new QAction(tr("Export &LilyPond"), this); a->setPriority(QAction::LowPriority); connect(a, &QAction::triggered, this, &BrailleMusicEditor::fileExportLilyPond); a->setEnabled(false); connect(this, &BrailleMusicEditor::scoreAvailable, a, &QAction::setEnabled); menu->addAction(a); menu->addSeparator(); a = new QAction(tr("&Quit"), this); a->setShortcut(Qt::CTRL + Qt::Key_Q); connect(a, &QAction::triggered, this, &BrailleMusicEditor::close); menu->addAction(a); connect(this, &BrailleMusicEditor::scoreAvailable, this, &BrailleMusicEditor::runLilyPond); }
XmlConsole::XmlConsole(Client* client, QWidget *parent) : QWidget(parent), m_ui(new Ui::XmlConsole), m_client(client), m_filter(0x1f) { m_ui->setupUi(this); m_client->addXmlStreamHandler(this); QPalette pal = palette(); pal.setColor(QPalette::Base, Qt::black); pal.setColor(QPalette::Text, Qt::white); m_ui->xmlBrowser->viewport()->setPalette(pal); QTextDocument *doc = m_ui->xmlBrowser->document(); doc->setDocumentLayout(new QPlainTextDocumentLayout(doc)); doc->clear(); QTextFrameFormat format = doc->rootFrame()->frameFormat(); format.setBackground(QColor(Qt::black)); format.setMargin(0); doc->rootFrame()->setFrameFormat(format); QMenu *menu = new QMenu(m_ui->filterButton); menu->setSeparatorsCollapsible(false); menu->addSeparator()->setText(tr("Filter")); QActionGroup *group = new QActionGroup(menu); QAction *disabled = group->addAction(menu->addAction(tr("Disabled"))); disabled->setCheckable(true); disabled->setData(Disabled); QAction *jid = group->addAction(menu->addAction(tr("By JID"))); jid->setCheckable(true); jid->setData(ByJid); QAction *xmlns = group->addAction(menu->addAction(tr("By namespace uri"))); xmlns->setCheckable(true); xmlns->setData(ByXmlns); QAction *attrb = group->addAction(menu->addAction(tr("By all attributes"))); attrb->setCheckable(true); attrb->setData(ByAllAttributes); disabled->setChecked(true); connect(group, SIGNAL(triggered(QAction*)), this, SLOT(onActionGroupTriggered(QAction*))); menu->addSeparator()->setText(tr("Visible stanzas")); group = new QActionGroup(menu); group->setExclusive(false); QAction *iq = group->addAction(menu->addAction(tr("Information query"))); iq->setCheckable(true); iq->setData(XmlNode::Iq); iq->setChecked(true); QAction *message = group->addAction(menu->addAction(tr("Message"))); message->setCheckable(true); message->setData(XmlNode::Message); message->setChecked(true); QAction *presence = group->addAction(menu->addAction(tr("Presence"))); presence->setCheckable(true); presence->setData(XmlNode::Presence); presence->setChecked(true); QAction *custom = group->addAction(menu->addAction(tr("Custom"))); custom->setCheckable(true); custom->setData(XmlNode::Custom); custom->setChecked(true); connect(group, SIGNAL(triggered(QAction*)), this, SLOT(onActionGroupTriggered(QAction*))); m_ui->filterButton->setMenu(menu); m_stackBracketsColor = QColor(0x666666); m_stackIncoming.bodyColor = QColor(0xbb66bb); m_stackIncoming.tagColor = QColor(0x006666); m_stackIncoming.attributeColor = QColor(0x009933); m_stackIncoming.paramColor = QColor(0xcc0000); m_stackOutgoing.bodyColor = QColor(0x999999); m_stackOutgoing.tagColor = QColor(0x22aa22); m_stackOutgoing.attributeColor = QColor(0xffff33); m_stackOutgoing.paramColor = QColor(0xdd8811); QAction *action = new QAction(tr("Close"),this); action->setSoftKeyRole(QAction::NegativeSoftKey); connect(action, SIGNAL(triggered()), SLOT(close())); addAction(action); }
void BrailleMusicEditor::setupEditActions() { auto tb = new QToolBar(this); tb->setWindowTitle(tr("Edit Actions")); addToolBar(tb); auto menu = new QMenu(tr("&Edit"), this); menuBar()->addMenu(menu); QAction *a; a = actionUndo = new QAction(QIcon::fromTheme("edit-undo"), tr("&Undo"), this); a->setShortcut(QKeySequence::Undo); tb->addAction(a); menu->addAction(a); a = actionRedo = new QAction(QIcon::fromTheme("edit-redo"), tr("&Redo"), this); a->setPriority(QAction::LowPriority); a->setShortcut(QKeySequence::Redo); tb->addAction(a); menu->addAction(a); menu->addSeparator(); a = actionCut = new QAction(QIcon::fromTheme("edit-cut"), tr("Cu&t"), this); a->setPriority(QAction::LowPriority); a->setShortcut(QKeySequence::Cut); tb->addAction(a); menu->addAction(a); a = actionCopy = new QAction(QIcon::fromTheme("edit-copy"), tr("&Copy"), this); a->setPriority(QAction::LowPriority); a->setShortcut(QKeySequence::Copy); tb->addAction(a); menu->addAction(a); a = actionPaste = new QAction(QIcon::fromTheme("edit-paste"), tr("&Paste"), this); a->setPriority(QAction::LowPriority); a->setShortcut(QKeySequence::Paste); tb->addAction(a); menu->addAction(a); #ifndef QT_NO_CLIPBOARD if (const QMimeData *md = QApplication::clipboard()->mimeData()) actionPaste->setEnabled(md->hasText()); #endif menu->addSeparator(); a = new QAction(tr("&Reformat"), this); a->setPriority(QAction::LowPriority); a->setShortcut(Qt::Key_F9); a->setEnabled(false); connect(this, &BrailleMusicEditor::scoreAvailable, a, &QAction::setEnabled); connect(a, &QAction::triggered, this, &BrailleMusicEditor::editReformat); tb->addAction(a); menu->addAction(a); }
void ScoreView::createElementPropertyMenu(Element* e, QMenu* popup) { if (e->type() == BAR_LINE) { genPropertyMenu1(e, popup); } else if (e->type() == ARTICULATION) { genPropertyMenu1(e, popup); popup->addAction(tr("Articulation Properties..."))->setData("a-props"); } else if (e->type() == BEAM) { popup->addAction(getAction("flip")); } else if (e->type() == STEM) { popup->addAction(getAction("flip")); } else if (e->type() == HOOK) { popup->addAction(getAction("flip")); } else if (e->type() == BEND) { genPropertyMenu1(e, popup); popup->addAction(tr("Bend Properties..."))->setData("b-props"); } else if (e->type() == TREMOLOBAR) { genPropertyMenu1(e, popup); popup->addAction(tr("TremoloBar Properties..."))->setData("tr-props"); } else if (e->type() == HBOX) { QMenu* textMenu = popup->addMenu(tr("Add")); textMenu->addAction(getAction("frame-text")); textMenu->addAction(getAction("picture")); popup->addAction(tr("Frame Properties..."))->setData("f-props"); } else if (e->type() == VBOX) { QMenu* textMenu = popup->addMenu(tr("Add")); textMenu->addAction(getAction("frame-text")); textMenu->addAction(getAction("title-text")); textMenu->addAction(getAction("subtitle-text")); textMenu->addAction(getAction("composer-text")); textMenu->addAction(getAction("poet-text")); textMenu->addAction(getAction("insert-hbox")); textMenu->addAction(getAction("picture")); popup->addAction(tr("Frame Properties..."))->setData("f-props"); } else if (e->type() == TBOX) { popup->addAction(tr("Frame Properties..."))->setData("f-props"); } else if (e->type() == TUPLET) { genPropertyMenu1(e, popup); popup->addAction(tr("Tuplet Properties..."))->setData("tuplet-props"); } else if (e->type() == VOLTA_SEGMENT) { genPropertyMenu1(e, popup); popup->addAction(tr("Volta Properties..."))->setData("v-props"); } else if (e->type() == TIMESIG) { genPropertyMenu1(e, popup); TimeSig* ts = static_cast<TimeSig*>(e); int _track = ts->track(); // if the time sig. is not generated (= not courtesy) and is in track 0 // add the specific menu item QAction* a; if (!ts->generated() && !_track) { a = popup->addAction(ts->showCourtesySig() ? QT_TRANSLATE_NOOP("TimeSig", "Hide Courtesy Time Signature") : QT_TRANSLATE_NOOP("TimeSig", "Show Courtesy Time Signature") ); a->setData("ts-courtesy"); } popup->addSeparator(); popup->addAction(tr("Time Signature Properties..."))->setData("ts-props"); } else if (e->type() == ACCIDENTAL) { Accidental* acc = static_cast<Accidental*>(e); genPropertyMenu1(e, popup); QAction* a = popup->addAction(QT_TRANSLATE_NOOP("Properties", "small")); a->setCheckable(true); a->setChecked(acc->small()); a->setData("smallAcc"); } else if (e->type() == CLEF) { genPropertyMenu1(e, popup); // if the clef is not generated (= not courtesy) add the specific menu item if (!e->generated()) { QAction* a = popup->addAction(static_cast<Clef*>(e)->showCourtesy() ? QT_TRANSLATE_NOOP("Clef", "Hide courtesy clef") : QT_TRANSLATE_NOOP("Clef", "Show courtesy clef") ); a->setData("clef-courtesy"); } } else if (e->type() == DYNAMIC) { popup->addSeparator(); if (e->visible()) popup->addAction(tr("Set Invisible"))->setData("invisible"); else popup->addAction(tr("Set Visible"))->setData("invisible"); popup->addAction(tr("MIDI Properties..."))->setData("d-dynamics"); popup->addAction(tr("Text Properties..."))->setData("d-props"); } else if (e->type() == TEXTLINE_SEGMENT || e->type() == OTTAVA_SEGMENT) { if (e->visible()) popup->addAction(tr("Set Invisible"))->setData("invisible"); else popup->addAction(tr("Set Visible"))->setData("invisible"); popup->addAction(tr("Line Properties..."))->setData("l-props"); } else if (e->type() == STAFF_TEXT) { genPropertyMenuText(e, popup); popup->addAction(tr("Staff Text Properties..."))->setData("st-props"); } else if (e->type() == TEXT || e->type() == FINGERING || e->type() == LYRICS) { genPropertyMenuText(e, popup); } else if (e->type() == TEMPO_TEXT) { genPropertyMenu1(e, popup); popup->addAction(tr("Tempo Properties..."))->setData("tempo-props"); popup->addAction(tr("Text Properties..."))->setData("text-props"); } else if (e->type() == KEYSIG) { genPropertyMenu1(e, popup); KeySig* ks = static_cast<KeySig*>(e); if (!e->generated()) { QAction* a = popup->addAction(ks->showCourtesy() ? QT_TRANSLATE_NOOP("KeySig", "Hide Courtesy Key Signature") : QT_TRANSLATE_NOOP("KeySig", "Show Courtesy Key Signature") ); a->setData("key-courtesy"); a = popup->addAction(ks->showNaturals() ? QT_TRANSLATE_NOOP("KeySig", "Hide Naturals") : QT_TRANSLATE_NOOP("KeySig", "Show Naturals") ); a->setData("key-naturals"); } } else if (e->type() == STAFF_STATE && static_cast<StaffState*>(e)->subtype() == STAFF_STATE_INSTRUMENT) { popup->addAction(tr("Change Instrument Properties..."))->setData("ss-props"); } else if (e->type() == SLUR_SEGMENT) { genPropertyMenu1(e, popup); popup->addAction(tr("Edit Mode"))->setData("edit"); popup->addAction(tr("Slur Properties..."))->setData("slur-props"); } else if (e->type() == REST) { Rest* rest = static_cast<Rest*>(e); genPropertyMenu1(e, popup); if (rest->tuplet()) { popup->addSeparator(); QMenu* menuTuplet = popup->addMenu(tr("Tuplet...")); menuTuplet->addAction(tr("Tuplet Properties..."))->setData("tuplet-props"); menuTuplet->addAction(tr("Delete Tuplet"))->setData("tupletDelete"); } } else if (e->type() == NOTE) { Note* note = static_cast<Note*>(e); QAction* b = popup->actions()[0]; QAction* a = popup->insertSeparator(b); a->setText(tr("Staff")); a = new QAction(tr("Staff Properties..."), 0); a->setData("staff-props"); popup->insertAction(b, a); a = popup->insertSeparator(b); a->setText(tr("Measure")); a = new QAction(tr("Measure Properties..."), 0); a->setData("measure-props"); popup->insertAction(b, a); genPropertyMenu1(e, popup); popup->addSeparator(); popup->addAction(tr("Style..."))->setData("style"); if (note->chord()->tuplet()) { QMenu* menuTuplet = popup->addMenu(tr("Tuplet...")); menuTuplet->addAction(tr("Tuplet Properties..."))->setData("tuplet-props"); menuTuplet->addAction(tr("Delete Tuplet"))->setData("tupletDelete"); } popup->addAction(tr("Chord Articulation..."))->setData("articulation"); } else if (e->type() == MARKER) { genPropertyMenu1(e, popup); popup->addAction(tr("Marker Properties..."))->setData("marker-props"); } else if (e->type() == JUMP) { genPropertyMenu1(e, popup); popup->addAction(tr("Jump Properties..."))->setData("jump-props"); } else if (e->type() == LAYOUT_BREAK && static_cast<LayoutBreak*>(e)->subtype() == LAYOUT_BREAK_SECTION) { popup->addAction(tr("Section Break Properties..."))->setData("break-props"); } else if (e->type() == INSTRUMENT_CHANGE) { genPropertyMenu1(e, popup); popup->addAction(tr("Change Instrument..."))->setData("ch-instr"); } else if (e->type() == FRET_DIAGRAM) { if (e->visible()) popup->addAction(tr("Set Invisible"))->setData("invisible"); else popup->addAction(tr("Set Visible"))->setData("invisible"); popup->addAction(tr("Color..."))->setData("color"); popup->addAction(tr("Fret Diagram Properties..."))->setData("fret-props"); } else if (e->type() == GLISSANDO) { genPropertyMenu1(e, popup); popup->addAction(tr("Glissando Properties..."))->setData("gliss-props"); } else if (e->type() == HAIRPIN_SEGMENT) { QAction* a = popup->addSeparator(); a->setText(tr("Dynamics")); if (e->visible()) a = popup->addAction(tr("Set Invisible")); else a = popup->addAction(tr("Set Visible")); a->setData("invisible"); popup->addAction(tr("Hairpin Properties..."))->setData("hp-props"); } else if (e->type() == HARMONY) { genPropertyMenu1(e, popup); popup->addSeparator(); popup->addAction(tr("Harmony Properties..."))->setData("ha-props"); popup->addAction(tr("Text Properties..."))->setData("text-props"); } else if (e->type() == INSTRUMENT_NAME) { popup->addAction(tr("Staff Properties..."))->setData("staff-props"); } else genPropertyMenu1(e, popup); }
void QuickOpenPlugin::createActionsForMainWindow(Sublime::MainWindow* /*window*/, QString& xmlFile, KActionCollection& actions) { xmlFile = QStringLiteral("kdevquickopen.rc"); QAction* quickOpen = actions.addAction(QStringLiteral("quick_open")); quickOpen->setText( i18n("&Quick Open") ); quickOpen->setIcon( QIcon::fromTheme(QStringLiteral("quickopen")) ); actions.setDefaultShortcut( quickOpen, Qt::CTRL | Qt::ALT | Qt::Key_Q ); connect(quickOpen, &QAction::triggered, this, &QuickOpenPlugin::quickOpen); QAction* quickOpenFile = actions.addAction(QStringLiteral("quick_open_file")); quickOpenFile->setText( i18n("Quick Open &File") ); quickOpenFile->setIcon( QIcon::fromTheme(QStringLiteral("quickopen-file")) ); actions.setDefaultShortcut( quickOpenFile, Qt::CTRL | Qt::ALT | Qt::Key_O ); connect(quickOpenFile, &QAction::triggered, this, &QuickOpenPlugin::quickOpenFile); QAction* quickOpenClass = actions.addAction(QStringLiteral("quick_open_class")); quickOpenClass->setText( i18n("Quick Open &Class") ); quickOpenClass->setIcon( QIcon::fromTheme(QStringLiteral("quickopen-class")) ); actions.setDefaultShortcut( quickOpenClass, Qt::CTRL | Qt::ALT | Qt::Key_C ); connect(quickOpenClass, &QAction::triggered, this, &QuickOpenPlugin::quickOpenClass); QAction* quickOpenFunction = actions.addAction(QStringLiteral("quick_open_function")); quickOpenFunction->setText( i18n("Quick Open &Function") ); quickOpenFunction->setIcon( QIcon::fromTheme(QStringLiteral("quickopen-function")) ); actions.setDefaultShortcut( quickOpenFunction, Qt::CTRL | Qt::ALT | Qt::Key_M ); connect(quickOpenFunction, &QAction::triggered, this, &QuickOpenPlugin::quickOpenFunction); QAction* quickOpenAlreadyOpen = actions.addAction(QStringLiteral("quick_open_already_open")); quickOpenAlreadyOpen->setText( i18n("Quick Open &Already Open File") ); quickOpenAlreadyOpen->setIcon( QIcon::fromTheme(QStringLiteral("quickopen-file")) ); connect(quickOpenAlreadyOpen, &QAction::triggered, this, &QuickOpenPlugin::quickOpenOpenFile); QAction* quickOpenDocumentation = actions.addAction(QStringLiteral("quick_open_documentation")); quickOpenDocumentation->setText( i18n("Quick Open &Documentation") ); quickOpenDocumentation->setIcon( QIcon::fromTheme(QStringLiteral("quickopen-documentation")) ); actions.setDefaultShortcut( quickOpenDocumentation, Qt::CTRL | Qt::ALT | Qt::Key_D ); connect(quickOpenDocumentation, &QAction::triggered, this, &QuickOpenPlugin::quickOpenDocumentation); QAction* quickOpenActions = actions.addAction(QStringLiteral("quick_open_actions")); quickOpenActions->setText( i18n("Quick Open &Actions") ); actions.setDefaultShortcut( quickOpenActions, Qt::CTRL | Qt::ALT | Qt::Key_A); connect(quickOpenActions, &QAction::triggered, this, &QuickOpenPlugin::quickOpenActions); m_quickOpenDeclaration = actions.addAction(QStringLiteral("quick_open_jump_declaration")); m_quickOpenDeclaration->setText( i18n("Jump to Declaration") ); m_quickOpenDeclaration->setIcon( QIcon::fromTheme(QStringLiteral("go-jump-declaration") ) ); actions.setDefaultShortcut( m_quickOpenDeclaration, Qt::CTRL | Qt::Key_Period ); connect(m_quickOpenDeclaration, &QAction::triggered, this, &QuickOpenPlugin::quickOpenDeclaration, Qt::QueuedConnection); m_quickOpenDefinition = actions.addAction(QStringLiteral("quick_open_jump_definition")); m_quickOpenDefinition->setText( i18n("Jump to Definition") ); m_quickOpenDefinition->setIcon( QIcon::fromTheme(QStringLiteral("go-jump-definition") ) ); actions.setDefaultShortcut( m_quickOpenDefinition, Qt::CTRL | Qt::Key_Comma ); connect(m_quickOpenDefinition, &QAction::triggered, this, &QuickOpenPlugin::quickOpenDefinition, Qt::QueuedConnection); QWidgetAction* quickOpenLine = new QWidgetAction(this); quickOpenLine->setText( i18n("Embedded Quick Open") ); // actions.setDefaultShortcut( quickOpenLine, Qt::CTRL | Qt::ALT | Qt::Key_E ); // connect(quickOpenLine, SIGNAL(triggered(bool)), this, SLOT(quickOpenLine(bool))); quickOpenLine->setDefaultWidget(createQuickOpenLineWidget()); actions.addAction(QStringLiteral("quick_open_line"), quickOpenLine); QAction* quickOpenNextFunction = actions.addAction(QStringLiteral("quick_open_next_function")); quickOpenNextFunction->setText( i18n("Next Function") ); actions.setDefaultShortcut( quickOpenNextFunction, Qt::CTRL| Qt::ALT | Qt::Key_PageDown ); connect(quickOpenNextFunction, &QAction::triggered, this, &QuickOpenPlugin::nextFunction); QAction* quickOpenPrevFunction = actions.addAction(QStringLiteral("quick_open_prev_function")); quickOpenPrevFunction->setText( i18n("Previous Function") ); actions.setDefaultShortcut( quickOpenPrevFunction, Qt::CTRL| Qt::ALT | Qt::Key_PageUp ); connect(quickOpenPrevFunction, &QAction::triggered, this, &QuickOpenPlugin::previousFunction); QAction* quickOpenNavigateFunctions = actions.addAction(QStringLiteral("quick_open_outline")); quickOpenNavigateFunctions->setText( i18n("Outline") ); actions.setDefaultShortcut( quickOpenNavigateFunctions, Qt::CTRL| Qt::ALT | Qt::Key_N ); connect(quickOpenNavigateFunctions, &QAction::triggered, this, &QuickOpenPlugin::quickOpenNavigateFunctions); }
MainStatusBar::MainStatusBar(QWidget *parent) : QStatusBar(parent), cap_file_(NULL), edit_action_(NULL), delete_action_(NULL) { QSplitter *splitter = new QSplitter(this); #ifdef HAVE_LIBPCAP QString ready_msg(tr("Ready to load or capture")); #else QString ready_msg(tr("Ready to load file")); #endif QWidget *info_progress = new QWidget(this); QHBoxLayout *info_progress_hb = new QHBoxLayout(info_progress); QAction *action; #if defined(Q_OS_WIN) // Handles are the same color as widgets, at least on Windows 7. splitter->setHandleWidth(3); splitter->setStyleSheet(QString( "QSplitter::handle {" " border-left: 1px solid palette(mid);" " border-right: 1px solid palette(mid);" "}" )); #elif defined(Q_OS_MAC) expert_status_.setAttribute(Qt::WA_MacSmallSize, true); #endif expert_status_.setTextFormat(Qt::RichText); expert_status_.hide(); // XXX Add the comment icon info_progress_hb->setContentsMargins(0, 0, 0, 0); info_status_.setTemporaryContext(STATUS_CTX_TEMPORARY); info_progress_hb->addWidget(&expert_status_); info_progress_hb->addWidget(&info_status_); info_progress_hb->addWidget(&progress_bar_); info_progress_hb->addStretch(10); splitter->addWidget(info_progress); splitter->addWidget(&packet_status_); splitter->addWidget(&profile_status_); splitter->setStretchFactor(0, 3); splitter->setStretchFactor(1, 3); splitter->setStretchFactor(2, 1); addWidget(splitter, 1); cur_main_status_bar_ = this; splitter->hide(); info_status_.pushText(ready_msg, STATUS_CTX_MAIN); packets_bar_update(); action = ctx_menu_.addAction(tr("Manage Profiles...")); action->setData(ProfileDialog::ShowProfiles); connect(action, SIGNAL(triggered()), this, SLOT(manageProfile())); ctx_menu_.addSeparator(); action = ctx_menu_.addAction(tr("New...")); action->setData(ProfileDialog::NewProfile); connect(action, SIGNAL(triggered()), this, SLOT(manageProfile())); edit_action_ = ctx_menu_.addAction(tr("Edit...")); edit_action_->setData(ProfileDialog::EditCurrentProfile); connect(edit_action_, SIGNAL(triggered()), this, SLOT(manageProfile())); delete_action_ = ctx_menu_.addAction(tr("Delete")); delete_action_->setData(ProfileDialog::DeleteCurrentProfile); connect(delete_action_, SIGNAL(triggered()), this, SLOT(manageProfile())); ctx_menu_.addSeparator(); profile_menu_.setTitle(tr("Switch to")); ctx_menu_.addMenu(&profile_menu_); connect(wsApp, SIGNAL(appInitialized()), splitter, SLOT(show())); connect(wsApp, SIGNAL(appInitialized()), this, SLOT(pushProfileName())); connect(&info_status_, SIGNAL(toggleTemporaryFlash(bool)), this, SLOT(toggleBackground(bool))); connect(wsApp, SIGNAL(captureCaptureUpdateContinue(capture_session*)), this, SLOT(updateCaptureStatistics(capture_session*))); connect(wsApp, SIGNAL(configurationProfileChanged(const gchar *)), this, SLOT(pushProfileName())); connect(&profile_status_, SIGNAL(mousePressedAt(QPoint,Qt::MouseButton)), this, SLOT(showProfileMenu(QPoint,Qt::MouseButton))); }
/****************************************************************************** * Invokes the command action with the given ID. ******************************************************************************/ void ActionManager::invokeAction(const QString& actionId) { QAction* action = getAction(actionId); if(!action) throw Exception(tr("Action with id '%1' is not defined.").arg(actionId)); action->trigger(); }
void MainWindow::openRecentFile() { QAction *action = qobject_cast<QAction *>(sender()); if (action) loadFile(action->data().toString()); }
void DiveHandler::changeGas() { QAction *action = qobject_cast<QAction *>(sender()); QModelIndex index = plannerModel->index(parentIndex(), DivePlannerPointsModel::GAS); plannerModel->setData(index, action->text()); }