BreakpointsWindow::BreakpointsWindow(running_machine* machine, QWidget* parent) : WindowQt(machine, nullptr) { setWindowTitle("Debug: All Breakpoints"); if (parent != nullptr) { QPoint parentPos = parent->pos(); setGeometry(parentPos.x()+100, parentPos.y()+100, 800, 400); } // // The main frame and its input and breakpoints widgets // QFrame* mainWindowFrame = new QFrame(this); // The main breakpoints view m_breakpointsView = new DebuggerView(DVT_BREAK_POINTS, m_machine, this); // Layout QVBoxLayout* vLayout = new QVBoxLayout(mainWindowFrame); vLayout->setObjectName("vlayout"); vLayout->setSpacing(3); vLayout->setContentsMargins(2,2,2,2); vLayout->addWidget(m_breakpointsView); setCentralWidget(mainWindowFrame); // // Menu bars // QActionGroup* typeGroup = new QActionGroup(this); typeGroup->setObjectName("typegroup"); QAction* typeBreak = new QAction("Breakpoints", this); typeBreak->setObjectName("typebreak"); QAction* typeWatch = new QAction("Watchpoints", this); typeWatch->setObjectName("typewatch"); typeBreak->setCheckable(true); typeWatch->setCheckable(true); typeBreak->setActionGroup(typeGroup); typeWatch->setActionGroup(typeGroup); typeBreak->setShortcut(QKeySequence("Ctrl+1")); typeWatch->setShortcut(QKeySequence("Ctrl+2")); typeBreak->setChecked(true); connect(typeGroup, &QActionGroup::triggered, this, &BreakpointsWindow::typeChanged); // Assemble the options menu QMenu* optionsMenu = menuBar()->addMenu("&Options"); optionsMenu->addActions(typeGroup->actions()); }
void Stack::addDocument(Document* document) { document->setSceneList(m_scenes); connect(document, SIGNAL(alert(Alert*)), m_alerts, SLOT(addAlert(Alert*))); connect(document, SIGNAL(alignmentChanged()), this, SIGNAL(updateFormatAlignmentActions())); connect(document, SIGNAL(changedName()), this, SIGNAL(updateFormatActions())); connect(document, SIGNAL(footerVisible(bool)), this, SLOT(setFooterVisible(bool))); connect(document, SIGNAL(headerVisible(bool)), this, SLOT(setHeaderVisible(bool))); connect(document, SIGNAL(scenesVisible(bool)), this, SLOT(setScenesVisible(bool))); connect(document->text(), SIGNAL(copyAvailable(bool)), this, SIGNAL(copyAvailable(bool))); connect(document->text(), SIGNAL(redoAvailable(bool)), this, SIGNAL(redoAvailable(bool))); connect(document->text(), SIGNAL(undoAvailable(bool)), this, SIGNAL(undoAvailable(bool))); connect(document->text(), SIGNAL(currentCharFormatChanged(QTextCharFormat)), this, SIGNAL(updateFormatActions())); m_documents.append(document); m_contents->addWidget(document); m_contents->setCurrentWidget(document); QAction* action = new QAction(this); action->setCheckable(true); action->setActionGroup(m_menu_group); m_document_actions.push_back(action); m_menu->addAction(action); updateMenuIndexes(); document->loadTheme(m_theme); document->text()->setFixedSize(m_foreground_size); emit documentAdded(document); emit updateFormatActions(); }
void ListView::updateSearchOptions() { IssueTypeCache* cache = dataManager->issueTypeCache( m_typeId ); QList<int> allColumns = cache->availableColumns(); QList<int> columns; foreach ( int column, allColumns ) { if ( cache->availableOperators( column ).contains( "CON" ) ) columns.append( column ); } if ( !columns.contains( m_searchColumn ) ) { m_searchColumn = Column_Name; m_model->setSearchText( m_searchColumn, m_searchBox->text() ); } m_searchMenu->clear(); ViewSettingsHelper helper( m_typeId ); foreach ( int column, columns ) { QString name = helper.columnName( column ); QAction* action = m_searchMenu->addAction( name ); action->setData( column ); action->setCheckable( true ); if ( column == m_searchColumn ) action->setChecked( true ); action->setActionGroup( m_searchActionGroup ); }
int Action::setActionGroup(lua_State * L) // ( QActionGroup * group ) { QAction* obj = QtObject<QAction>::check( L, 1); QActionGroup* rhs = QtObject<QActionGroup>::check( L, 2); obj->setActionGroup( rhs ); return 0; }
void BtMenuView::buildMenu(QMenu *parentMenu, const QModelIndex &parentIndex) { Q_ASSERT(m_model != 0); Q_ASSERT(m_actions != 0); int children = m_model->rowCount(parentIndex); for (int i = 0; i < children; i++) { QModelIndex childIndex(m_model->index(i, 0, parentIndex)); if (m_model->rowCount(childIndex) > 0) { QMenu *childMenu = newMenu(parentMenu, childIndex); if (childMenu != 0) { // Add the child menu and populate it: parentMenu->addMenu(childMenu); buildMenu(childMenu, childIndex); } } else { QAction *childAction = newAction(parentMenu, childIndex); if (childAction != 0) { // Map index m_indexMap.insert(childAction, childIndex); // Add action to action group: childAction->setActionGroup(m_actions); // Add action to menu: parentMenu->addAction(childAction); } } } }
Test4Window::Test4Window(const QString &sql) : Ui::Test4Window() { Ui::Test4Window::setupUi(this); QToolBar *toolBar = QMainWindow::addToolBar("TB"); toolBar->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed)); toolBar->setFocusPolicy(Qt::NoFocus); pushButton = new QPushButton("Oracle", toolBar); pushButton->setFlat(true); toolBar->addWidget(pushButton); connect(pushButton, SIGNAL(released()), this, SLOT(setLexer())); QAction *oracle = new QAction("Oracle", this); QAction *mysql = new QAction("MySQL", this); oracle->setCheckable(true); oracle->setChecked(true); mysql->setCheckable(true); mysql->setChecked(false); QActionGroup* group = new QActionGroup(this); oracle->setActionGroup(group); mysql->setActionGroup(group); menuGrammar->addAction(oracle); menuGrammar->addAction(mysql); editorLeft = new toSqlText(this); leftVerticalLayout->addWidget(editorLeft); editorLeft->setText(sql); editorLeft->enableToolTips(); editorRight = new toSqlText(this); editorRight->setHighlighter(toSqlText::Oracle); rightVerticalLayout->addWidget(editorRight); editorRight->setText(sql); editorRight->setMarginType(2, QsciScintilla::TextMarginRightJustified); editorRight->setMarginWidth(2, QString::fromLatin1("009")); editorRight->enableToolTips(); connect(oracle, SIGNAL(triggered()), this, SLOT(setOracle())); connect(mysql, SIGNAL(triggered()), this, SLOT(setMySQL())); connect(actionLoad, SIGNAL(triggered()), this, SLOT(load())); connect(actionQuit, SIGNAL(triggered()), this, SLOT(close())); QMainWindow::show(); }
KisPaintOpPresetsChooserPopup::KisPaintOpPresetsChooserPopup(QWidget * parent) : QWidget(parent) , m_d(new Private()) { m_d->uiWdgPaintOpPresets.setupUi(this); KMenu* menu = new KMenu(this); QActionGroup *actionGroup = new QActionGroup(this); KisPresetChooser::ViewMode mode = (KisPresetChooser::ViewMode)KisConfig().presetChooserViewMode(); bool showAll = KisConfig().presetShowAllMode(); 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); m_d->uiWdgPaintOpPresets.viewModeButton->setIcon(koIcon("view-choose")); m_d->uiWdgPaintOpPresets.viewModeButton->setMenu(menu); m_d->uiWdgPaintOpPresets.viewModeButton->setPopupMode(QToolButton::InstantPopup); m_d->uiWdgPaintOpPresets.wdgPresetChooser->setViewMode(mode); m_d->uiWdgPaintOpPresets.wdgPresetChooser->showTaggingBar(false,true); connect(m_d->uiWdgPaintOpPresets.wdgPresetChooser, SIGNAL(resourceSelected(KoResource*)), this, SIGNAL(resourceSelected(KoResource*))); connect(m_d->uiWdgPaintOpPresets.searchBar, SIGNAL(textChanged(QString)), m_d->uiWdgPaintOpPresets.wdgPresetChooser, SLOT(searchTextChanged(QString))); connect(m_d->uiWdgPaintOpPresets.searchBar, SIGNAL(textChanged(QString)), this, SLOT(setLineEditCompleter(QString))); connect(m_d->uiWdgPaintOpPresets.searchBar, SIGNAL(returnPressed(QString)), this, SLOT(returnKeyPressed(QString))); connect(m_d->uiWdgPaintOpPresets.showAllCheckBox, SIGNAL(toggled(bool)), m_d->uiWdgPaintOpPresets.wdgPresetChooser, SLOT(setShowAll(bool))); m_d->firstShown = true; m_d->uiWdgPaintOpPresets.showAllCheckBox->setChecked(showAll); }
void SimplePartWidget::buildContextMenu(const QPoint &point, QMenu &menu) const { menu.addAction(m_findAction); auto a = pageAction(QWebPage::Copy); a->setIcon(UiUtils::loadIcon(QStringLiteral("edit-copy"))); menu.addAction(a); a = pageAction(QWebPage::SelectAll); a->setIcon(UiUtils::loadIcon(QStringLiteral("edit-select-all"))); menu.addAction(a); if (!page()->mainFrame()->hitTestContent(point).linkUrl().isEmpty()) { menu.addSeparator(); a = pageAction(QWebPage::CopyLinkToClipboard); a->setIcon(UiUtils::loadIcon(QStringLiteral("edit-copy"))); menu.addAction(a); } menu.addSeparator(); menu.addAction(m_savePart); menu.addAction(m_saveMessage); if (!page()->mainFrame()->hitTestContent(point).imageUrl().isEmpty()) { a = pageAction(QWebPage::DownloadImageToDisk); a->setIcon(UiUtils::loadIcon(QStringLiteral("download"))); menu.addAction(a); } menu.addSeparator(); QMenu *colorSchemeMenu = menu.addMenu(UiUtils::loadIcon(QStringLiteral("colorneg")), tr("Color scheme")); QActionGroup *ag = new QActionGroup(colorSchemeMenu); for (auto item: supportedColorSchemes()) { QAction *a = colorSchemeMenu->addAction(item.second); connect(a, &QAction::triggered, this, [this, item](){ const_cast<SimplePartWidget*>(this)->setColorScheme(item.first); }); a->setCheckable(true); if (item.first == m_colorScheme) { a->setChecked(true); } a->setActionGroup(ag); } auto zoomMenu = menu.addMenu(UiUtils::loadIcon(QStringLiteral("zoom")), tr("Zoom")); if (m_messageView) { zoomMenu->addAction(m_messageView->m_zoomIn); zoomMenu->addAction(m_messageView->m_zoomOut); zoomMenu->addAction(m_messageView->m_zoomOriginal); } else { auto zoomIn = zoomMenu->addAction(UiUtils::loadIcon(QStringLiteral("zoom-in")), tr("Zoom In")); zoomIn->setShortcut(QKeySequence::ZoomIn); connect(zoomIn, &QAction::triggered, this, &SimplePartWidget::zoomIn); auto zoomOut = zoomMenu->addAction(UiUtils::loadIcon(QStringLiteral("zoom-out")), tr("Zoom Out")); zoomOut->setShortcut(QKeySequence::ZoomOut); connect(zoomOut, &QAction::triggered, this, &SimplePartWidget::zoomOut); auto zoomOriginal = zoomMenu->addAction(UiUtils::loadIcon(QStringLiteral("zoom-original")), tr("Original Size")); connect(zoomOriginal, &QAction::triggered, this, &SimplePartWidget::zoomOriginal); } }
void PlacesPanel::slotViewContextMenuRequested(const QPointF& pos) { QMenu menu(this); QAction* addAction = menu.addAction(QIcon::fromTheme(QStringLiteral("document-new")), i18nc("@item:inmenu", "Add Entry...")); QAction* showAllAction = nullptr; if (m_model->hiddenCount() > 0) { showAllAction = menu.addAction(i18nc("@item:inmenu", "Show All Entries")); showAllAction->setCheckable(true); showAllAction->setChecked(m_model->hiddenItemsShown()); } buildGroupContextMenu(&menu, m_controller->indexCloseToMousePressedPosition()); QMenu* iconSizeSubMenu = new QMenu(i18nc("@item:inmenu", "Icon Size"), &menu); struct IconSizeInfo { int size; const char* context; const char* text; }; const int iconSizeCount = 4; static const IconSizeInfo iconSizes[iconSizeCount] = { {KIconLoader::SizeSmall, I18N_NOOP2_NOSTRIP("Small icon size", "Small (%1x%2)")}, {KIconLoader::SizeSmallMedium, I18N_NOOP2_NOSTRIP("Medium icon size", "Medium (%1x%2)")}, {KIconLoader::SizeMedium, I18N_NOOP2_NOSTRIP("Large icon size", "Large (%1x%2)")}, {KIconLoader::SizeLarge, I18N_NOOP2_NOSTRIP("Huge icon size", "Huge (%1x%2)")} }; QMap<QAction*, int> iconSizeActionMap; QActionGroup* iconSizeGroup = new QActionGroup(iconSizeSubMenu); for (int i = 0; i < iconSizeCount; ++i) { const int size = iconSizes[i].size; const QString text = i18nc(iconSizes[i].context, iconSizes[i].text, size, size); QAction* action = iconSizeSubMenu->addAction(text); iconSizeActionMap.insert(action, size); action->setActionGroup(iconSizeGroup); action->setCheckable(true); action->setChecked(m_view->iconSize() == size); } menu.addMenu(iconSizeSubMenu); menu.addSeparator(); foreach (QAction* action, customContextMenuActions()) { menu.addAction(action); }
void KTreeWidgetSearchLine::contextMenuEvent( QContextMenuEvent *event ) { QMenu *popup = KLineEdit::createStandardContextMenu(); if ( d->canChooseColumns ) { popup->addSeparator(); QMenu *subMenu = popup->addMenu( i18n("Search Columns") ); QAction* allVisibleColumnsAction = subMenu->addAction( i18n("All Visible Columns"), this, SLOT(_k_slotAllVisibleColumns()) ); allVisibleColumnsAction->setCheckable( true ); allVisibleColumnsAction->setChecked( !d->searchColumns.count() ); subMenu->addSeparator(); bool allColumnsAreSearchColumns = true; QActionGroup* group = new QActionGroup( popup ); group->setExclusive( false ); connect( group, SIGNAL(triggered(QAction*)), SLOT(_k_slotColumnActivated(QAction*)) ); QHeaderView* const header = d->treeWidgets.first()->header(); for ( int j = 0; j < header->count(); j++ ) { int i = header->logicalIndex( j ); if ( header->isSectionHidden( i ) ) continue; QString columnText = d->treeWidgets.first()->headerItem()->text( i ); QAction* columnAction = subMenu->addAction( d->treeWidgets.first()->headerItem()->icon( i ), columnText ); columnAction->setCheckable( true ); columnAction->setChecked( d->searchColumns.isEmpty() || d->searchColumns.contains( i ) ); columnAction->setData( i ); columnAction->setActionGroup( group ); if ( d->searchColumns.isEmpty() || d->searchColumns.indexOf( i ) != -1 ) columnAction->setChecked( true ); else allColumnsAreSearchColumns = false; } allVisibleColumnsAction->setChecked( allColumnsAreSearchColumns ); // searchColumnsMenuActivated() relies on one possible "all" representation if ( allColumnsAreSearchColumns && !d->searchColumns.isEmpty() ) d->searchColumns.clear(); } popup->exec( event->globalPos() ); delete popup; }
QAction* DiagramToolBox::createAction(const QString& text, const QString& iconPath, const QString& shortcut, const QVariant& data) { QAction* action = new QAction(text, this); if (!iconPath.isEmpty()) action->setIcon(QIcon(iconPath)); if (!shortcut.isEmpty()) action->setShortcut(QKeySequence(shortcut)); action->setData(data); action->setCheckable(true); action->setActionGroup(mDiagramModeActionGroup); return action; }
void radeon_profile::setupFanProfilesMenu(const bool rebuildMode) { if (rebuildMode) delete fanProfilesMenu; fanProfilesMenu = new QMenu(this); connect(fanProfilesMenu, SIGNAL(triggered(QAction*)), this, SLOT(fanProfileMenuActionClicked(QAction*))); QActionGroup *ag = new QActionGroup(fanProfilesMenu); QAction *fanAuto = new QAction(fanProfilesMenu); fanAuto->setText(tr("Auto")); fanAuto->setCheckable(true); fanAuto->setChecked(true); fanAuto->setActionGroup(ag); connect(fanAuto, SIGNAL(triggered()), this, SLOT(on_btn_pwmAuto_clicked())); QAction *fanFixed = new QAction(fanProfilesMenu); fanFixed->setText(tr("Fixed ") + ui->labelFixedSpeed->text()+"%"); fanFixed->setCheckable(true); fanFixed->setActionGroup(ag); connect(fanFixed, SIGNAL(triggered()), this, SLOT(on_btn_pwmFixed_clicked())); fanProfilesMenu->addAction(fanAuto); fanProfilesMenu->addAction(fanFixed); fanProfilesMenu->addSeparator(); for (QString p : fanProfiles.keys()) { QAction *a = new QAction(fanProfilesMenu); a->setText(p); a->setCheckable(true); a->setActionGroup(ag); fanProfilesMenu->addAction(a); } ui->l_fanSpeed->setMenu(fanProfilesMenu); }
void MenuBar::AddStateSlotMenu(QMenu* emu_menu) { m_state_slot_menu = emu_menu->addMenu(tr("Select State Slot")); m_state_slots = new QActionGroup(this); for (int i = 1; i <= 10; i++) { QAction* action = m_state_slot_menu->addAction(QStringLiteral("")); action->setCheckable(true); action->setActionGroup(m_state_slots); if (Settings::Instance().GetStateSlot() == i) action->setChecked(true); connect(action, &QAction::triggered, this, [=]() { emit SetStateSlot(i); }); } }
QAction* AppWindow::newMenuAction( const std::string& title, QActionGroup* actionGroup, const std::string& tip, std::list<QAction*>& menuList, int shortcut) { QAction* action = new QAction(tr(title.c_str()), this); action->setStatusTip(tr(tip.c_str())); if (actionGroup) { action->setCheckable(true); action->setActionGroup(actionGroup); } shortcutActions.insert({shortcut, action}); menuList.push_back(action); return action; }
void PlaylistWidget::SetPlayModeButton () { auto playButton = new QToolButton; playButton->setIcon (Core::Instance ().GetProxy ()-> GetIconThemeManager ()->GetIcon ("view-media-playlist")); playButton->setPopupMode (QToolButton::InstantPopup); QMenu *playMode = new QMenu (tr ("Play mode")); playButton->setMenu (playMode); const std::vector<std::pair<Player::PlayMode, QString>> modes = { { Player::PlayMode::Sequential, tr ("Sequential") }, { Player::PlayMode::Shuffle, tr ("Shuffle") }, { Player::PlayMode::ShuffleAlbums, tr ("Shuffle albums") }, { Player::PlayMode::ShuffleArtists, tr ("Shuffle artists") }, { Player::PlayMode::RepeatTrack, tr ("Repeat track") }, { Player::PlayMode::RepeatAlbum, tr ("Repeat album") }, { Player::PlayMode::RepeatWhole, tr ("Repeat whole") } }; PlayModesGroup_ = new QActionGroup (this); bool hadChecked = false; for (const auto& pair : modes) { QAction *action = new QAction (pair.second, this); action->setProperty ("PlayMode", static_cast<int> (pair.first)); action->setCheckable (true); action->setChecked (hadChecked ? false : hadChecked = true); action->setActionGroup (PlayModesGroup_); playMode->addAction (action); connect (action, SIGNAL (triggered ()), this, SLOT (handleChangePlayMode ())); } connect (Player_, SIGNAL (playModeChanged (Player::PlayMode)), this, SLOT (handlePlayModeChanged (Player::PlayMode))); const int resumeMode = XmlSettingsManager::Instance () .Property ("PlayMode", static_cast<int> (Player::PlayMode::Sequential)).toInt (); Player_->SetPlayMode (static_cast<Player::PlayMode> (resumeMode)); PlaylistToolbar_->addWidget (playButton); }
void MainWindow::scanPlayers() { ui->menuSelect_Player->clear(); bool enabled = false; for (const QString &playerDir : settings->getPlayers()) { QDir dir(playerDir); QActionGroup *group = new QActionGroup(this); bool checked = false; QDirIterator it(dir); QList<QAction *> actions; while (it.hasNext()) { it.next(); if (it.fileName().endsWith(".plr")) { QString name = playerName(it.filePath()); if (!name.isNull()) { QAction *p = new QAction(this); p->setCheckable(true); p->setActionGroup(group); p->setText(name); p->setData(it.filePath()); connect(p, SIGNAL(triggered()), this, SLOT(selectPlayer())); if (!checked) { p->setChecked(true); p->trigger(); } checked = true; actions.append(p); } } } if (!actions.isEmpty()) { ui->menuOpen_World->addSection(playerDir); ui->menuSelect_Player->addActions(actions); enabled = true; } } ui->menuSelect_Player->setDisabled(!enabled); }
void PluginManager::loadMediaPlayerPlugin(MediaPlayerPlugin *mediaPlayerPlugin) { QWidget *view = mediaPlayerPlugin->providesView(); if (view != nullptr) { // Add a separator before any plugin (3 views by default: Playlist, Unique Library and Tag Editor if (_mainWindow->menuView->actions().count() == 3) { _mainWindow->menuView->addSeparator(); } QAction *actionAddViewToMenu = new QAction(mediaPlayerPlugin->name(), _mainWindow->menuView); actionAddViewToMenu->setObjectName(mediaPlayerPlugin->name()); _mainWindow->menuView->addAction(actionAddViewToMenu); _mainWindow->updateFonts(SettingsPrivate::instance()->font(SettingsPrivate::FF_Menu)); connect(actionAddViewToMenu, &QAction::triggered, this, [=]() { _mainWindow->close(); view->show(); }); // Link the view to the existing ActionGroup actionAddViewToMenu->setCheckable(true); actionAddViewToMenu->setActionGroup(_mainWindow->actionViewPlaylists->actionGroup()); _dependencies.insert(mediaPlayerPlugin->name(), actionAddViewToMenu); } mediaPlayerPlugin->setMediaPlayer(_mainWindow->mediaPlayer()); }
void JuK::setupActions() { KActionCollection *collection = ActionCollection::actions(); // Setup KDE standard actions that JuK uses. KStandardAction::quit(this, SLOT(slotQuit()), collection); KStandardAction::undo(this, SLOT(slotUndo()), collection); KStandardAction::cut(collection); KStandardAction::copy(collection); KStandardAction::paste(collection); KAction *clear = KStandardAction::clear(collection); KStandardAction::selectAll(collection); KStandardAction::keyBindings(this, SLOT(slotEditKeys()), collection); // Setup the menu which handles the random play options. KActionMenu *actionMenu = collection->add<KActionMenu>("actionMenu"); actionMenu->setText(i18n("&Random Play")); actionMenu->setIcon(KIcon( QLatin1String( "media-playlist-shuffle" ))); actionMenu->setDelayed(false); QActionGroup* randomPlayGroup = new QActionGroup(this); QAction *act = collection->add<KToggleAction>("disableRandomPlay"); act->setText(i18n("&Disable Random Play")); act->setIcon(KIcon( QLatin1String( "go-down" ))); act->setActionGroup(randomPlayGroup); actionMenu->addAction(act); m_randomPlayAction = collection->add<KToggleAction>("randomPlay"); m_randomPlayAction->setText(i18n("Use &Random Play")); m_randomPlayAction->setIcon(KIcon( QLatin1String( "media-playlist-shuffle" ))); m_randomPlayAction->setActionGroup(randomPlayGroup); actionMenu->addAction(m_randomPlayAction); act = collection->add<KToggleAction>("albumRandomPlay"); act->setText(i18n("Use &Album Random Play")); act->setIcon(KIcon( QLatin1String( "media-playlist-shuffle" ))); act->setActionGroup(randomPlayGroup); connect(act, SIGNAL(triggered(bool)), SLOT(slotCheckAlbumNextAction(bool))); actionMenu->addAction(act); act = collection->addAction("removeFromPlaylist", clear, SLOT(clear())); act->setText(i18n("Remove From Playlist")); act->setIcon(KIcon( QLatin1String( "list-remove" ))); act = collection->add<KToggleAction>("crossfadeTracks"); act->setText(i18n("Crossfade Between Tracks")); connect(act, SIGNAL(triggered(bool)), m_player, SLOT(setCrossfadeEnabled(bool))); act = collection->addAction("play", m_player, SLOT(play())); act->setText(i18n("&Play")); act->setIcon(KIcon( QLatin1String( "media-playback-start" ))); act = collection->addAction("pause", m_player, SLOT(pause())); act->setText(i18n("P&ause")); act->setIcon(KIcon( QLatin1String( "media-playback-pause" ))); act = collection->addAction("stop", m_player, SLOT(stop())); act->setText(i18n("&Stop")); act->setIcon(KIcon( QLatin1String( "media-playback-stop" ))); act = new KToolBarPopupAction(KIcon( QLatin1String( "media-skip-backward") ), i18nc("previous track", "Previous" ), collection); collection->addAction("back", act); connect(act, SIGNAL(triggered(bool)), m_player, SLOT(back())); act = collection->addAction("forward", m_player, SLOT(forward())); act->setText(i18nc("next track", "&Next")); act->setIcon(KIcon( QLatin1String( "media-skip-forward" ))); act = collection->addAction("loopPlaylist"); act->setText(i18n("&Loop Playlist")); act->setCheckable(true); act = collection->add<KToggleAction>("resizeColumnsManually"); act->setText(i18n("&Resize Playlist Columns Manually")); // the following are not visible by default act = collection->addAction("mute", m_player, SLOT(mute())); act->setText(i18nc("silence playback", "Mute")); act->setIcon(KIcon( QLatin1String( "audio-volume-muted" ))); act = collection->addAction("volumeUp", m_player, SLOT(volumeUp())); act->setText(i18n("Volume Up")); act->setIcon(KIcon( QLatin1String( "audio-volume-high" ))); act = collection->addAction("volumeDown", m_player, SLOT(volumeDown())); act->setText(i18n("Volume Down")); act->setIcon(KIcon( QLatin1String( "audio-volume-low" ))); act = collection->addAction("playPause", m_player, SLOT(playPause())); act->setText(i18n("Play / Pause")); act->setIcon(KIcon( QLatin1String( "media-playback-start" ))); act = collection->addAction("seekForward", m_player, SLOT(seekForward())); act->setText(i18n("Seek Forward")); act->setIcon(KIcon( QLatin1String( "media-seek-forward" ))); act = collection->addAction("seekBack", m_player, SLOT(seekBack())); act->setText(i18n("Seek Back")); act->setIcon(KIcon( QLatin1String( "media-seek-backward" ))); act = collection->addAction("showHide", this, SLOT(slotShowHide())); act->setText(i18n("Show / Hide")); ////////////////////////////////////////////////// // settings menu ////////////////////////////////////////////////// m_toggleSplashAction = collection->add<KToggleAction>("showSplashScreen"); m_toggleSplashAction->setText(i18n("Show Splash Screen on Startup")); m_toggleSystemTrayAction = collection->add<KToggleAction>("toggleSystemTray"); m_toggleSystemTrayAction->setText(i18n("&Dock in System Tray")); connect(m_toggleSystemTrayAction, SIGNAL(triggered(bool)), SLOT(slotToggleSystemTray(bool))); m_toggleDockOnCloseAction = collection->add<KToggleAction>("dockOnClose"); m_toggleDockOnCloseAction->setText(i18n("&Stay in System Tray on Close")); m_togglePopupsAction = collection->add<KToggleAction>("togglePopups"); m_togglePopupsAction->setText(i18n("Popup &Track Announcement")); act = collection->add<KToggleAction>("saveUpcomingTracks"); act->setText(i18n("Save &Play Queue on Exit")); act = collection->addAction("tagGuesserConfig", this, SLOT(slotConfigureTagGuesser())); act->setText(i18n("&Tag Guesser...")); act = collection->addAction("fileRenamerConfig", this, SLOT(slotConfigureFileRenamer())); act->setText(i18n("&File Renamer...")); act = collection->addAction("scrobblerConfig", this, SLOT(slotConfigureScrobbling())); act->setText(i18n("&Configure scrobbling...")); ////////////////////////////////////////////////// // just in the toolbar ////////////////////////////////////////////////// collection->addAction("trackPositionAction", new TrackPositionAction(i18n("Track Position"), this)); collection->addAction("volumeAction", new VolumeAction(i18n("Volume"), this)); ActionCollection::actions()->addAssociatedWidget(this); foreach (QAction* action, ActionCollection::actions()->actions()) action->setShortcutContext(Qt::WidgetWithChildrenShortcut); }
void KNewFileMenuPrivate::fillMenu() { QMenu* menu = q->menu(); menu->clear(); m_menuDev->menu()->clear(); m_newDirAction = 0; QSet<QString> seenTexts; // these shall be put at special positions QAction* linkURL = 0; QAction* linkApp = 0; QAction* linkPath = 0; KNewFileMenuSingleton* s = kNewMenuGlobals; int i = 1; KNewFileMenuSingleton::EntryList::iterator templ = s->templatesList->begin(); const KNewFileMenuSingleton::EntryList::iterator templ_end = s->templatesList->end(); for (; templ != templ_end; ++templ, ++i) { KNewFileMenuSingleton::Entry& entry = *templ; if (entry.entryType != KNewFileMenuSingleton::Separator) { // There might be a .desktop for that one already, if it's a kdelnk // This assumes we read .desktop files before .kdelnk files ... // In fact, we skip any second item that has the same text as another one. // Duplicates in a menu look bad in any case. const bool bSkip = seenTexts.contains(entry.text); if (bSkip) { kDebug(1203) << "skipping" << entry.filePath; } else { seenTexts.insert(entry.text); //const KNewFileMenuSingleton::Entry entry = templatesList->at(i-1); const QString templatePath = entry.templatePath; // The best way to identify the "Create Directory", "Link to Location", "Link to Application" was the template if (templatePath.endsWith("emptydir")) { QAction * act = new QAction(q); m_newDirAction = act; act->setIcon(KIcon(entry.icon)); act->setText(entry.text); act->setActionGroup(m_newMenuGroup); menu->addAction(act); QAction *sep = new QAction(q); sep->setSeparator(true); menu->addAction(sep); } else { if (!m_supportedMimeTypes.isEmpty()) { bool keep = false; // We need to do mimetype filtering, for real files. const bool createSymlink = entry.templatePath == "__CREATE_SYMLINK__"; if (createSymlink) { keep = true; } else if (!KDesktopFile::isDesktopFile(entry.templatePath)) { // Determine mimetype on demand KMimeType::Ptr mime; if (entry.mimeType.isEmpty()) { mime = KMimeType::findByPath(entry.templatePath); if (mime) { //kDebug() << entry.templatePath << "is" << mime->name(); entry.mimeType = mime->name(); } else { entry.mimeType = KMimeType::defaultMimeType(); } } else { mime = KMimeType::mimeType(entry.mimeType); } Q_FOREACH(const QString& supportedMime, m_supportedMimeTypes) { if (mime && mime->is(supportedMime)) { keep = true; break; } } } if (!keep) { //kDebug() << "Not keeping" << entry.templatePath; continue; } } QAction * act = new QAction(q); act->setData(i); act->setIcon(KIcon(entry.icon)); act->setText(entry.text); act->setActionGroup(m_newMenuGroup); //kDebug() << templatePath << entry.filePath; if (templatePath.endsWith("/URL.desktop")) { linkURL = act; } else if (templatePath.endsWith("/Program.desktop")) { linkApp = act; } else if (entry.filePath.endsWith("/linkPath.desktop")) { linkPath = act; } else if (KDesktopFile::isDesktopFile(templatePath)) { KDesktopFile df(templatePath); if (df.readType() == "FSDevice") m_menuDev->menu()->addAction(act); else menu->addAction(act); } else { menu->addAction(act); } } } } else { // Separate system from personal templates
void PlacesPanel::slotItemContextMenuRequested(int index, const QPointF& pos) { PlacesItem* item = m_model->placesItem(index); if (!item) { return; } QMenu menu(this); QAction* emptyTrashAction = 0; QAction* addAction = 0; QAction* mainSeparator = 0; QAction* editAction = 0; QAction* teardownAction = 0; QAction* ejectAction = 0; const QString label = item->text(); const bool isDevice = !item->udi().isEmpty(); if (isDevice) { ejectAction = m_model->ejectAction(index); if (ejectAction) { ejectAction->setParent(&menu); menu.addAction(ejectAction); } teardownAction = m_model->teardownAction(index); if (teardownAction) { teardownAction->setParent(&menu); menu.addAction(teardownAction); } if (teardownAction || ejectAction) { mainSeparator = menu.addSeparator(); } } else { if (item->url() == QUrl(QStringLiteral("trash:/"))) { emptyTrashAction = menu.addAction(QIcon::fromTheme(QStringLiteral("trash-empty")), i18nc("@action:inmenu", "Empty Trash")); emptyTrashAction->setEnabled(item->icon() == QLatin1String("user-trash-full")); menu.addSeparator(); } addAction = menu.addAction(QIcon::fromTheme(QStringLiteral("document-new")), i18nc("@item:inmenu", "Add Entry...")); mainSeparator = menu.addSeparator(); editAction = menu.addAction(QIcon::fromTheme(QStringLiteral("document-properties")), i18nc("@item:inmenu", "Edit '%1'...", label)); } if (!addAction) { addAction = menu.addAction(QIcon::fromTheme(QStringLiteral("document-new")), i18nc("@item:inmenu", "Add Entry...")); } QAction* openInNewTabAction = menu.addAction(i18nc("@item:inmenu", "Open '%1' in New Tab", label)); openInNewTabAction->setIcon(QIcon::fromTheme(QStringLiteral("tab-new"))); QAction* removeAction = 0; if (!isDevice && !item->isSystemItem()) { removeAction = menu.addAction(QIcon::fromTheme(QStringLiteral("edit-delete")), i18nc("@item:inmenu", "Remove '%1'", label)); } QAction* hideAction = menu.addAction(i18nc("@item:inmenu", "Hide '%1'", label)); hideAction->setCheckable(true); hideAction->setChecked(item->isHidden()); QAction* showAllAction = 0; if (m_model->hiddenCount() > 0) { if (!mainSeparator) { mainSeparator = menu.addSeparator(); } showAllAction = menu.addAction(i18nc("@item:inmenu", "Show All Entries")); showAllAction->setCheckable(true); showAllAction->setChecked(m_model->hiddenItemsShown()); } menu.addSeparator(); QMenu* iconSizeSubMenu = new QMenu(i18nc("@item:inmenu", "Icon Size"), &menu); struct IconSizeInfo { int size; const char* context; const char* text; }; const int iconSizeCount = 4; static const IconSizeInfo iconSizes[iconSizeCount] = { {KIconLoader::SizeSmall, I18N_NOOP2_NOSTRIP("Small icon size", "Small (%1x%2)")}, {KIconLoader::SizeSmallMedium, I18N_NOOP2_NOSTRIP("Medium icon size", "Medium (%1x%2)")}, {KIconLoader::SizeMedium, I18N_NOOP2_NOSTRIP("Large icon size", "Large (%1x%2)")}, {KIconLoader::SizeLarge, I18N_NOOP2_NOSTRIP("Huge icon size", "Huge (%1x%2)")} }; QHash<QAction*, int> iconSizeActionMap; QActionGroup* iconSizeGroup = new QActionGroup(iconSizeSubMenu); for (int i = 0; i < iconSizeCount; ++i) { const int size = iconSizes[i].size; const QString text = i18nc(iconSizes[i].context, iconSizes[i].text, size, size); QAction* action = iconSizeSubMenu->addAction(text); iconSizeActionMap.insert(action, size); action->setActionGroup(iconSizeGroup); action->setCheckable(true); action->setChecked(m_view->iconSize() == size); } menu.addMenu(iconSizeSubMenu); menu.addSeparator(); foreach (QAction* action, customContextMenuActions()) { menu.addAction(action); }
MemoryWindow::MemoryWindow(running_machine* machine, QWidget* parent) : WindowQt(machine, parent) { QPoint parentPos = parent->pos(); setGeometry(parentPos.x()+100, parentPos.y()+100, 800, 400); setWindowTitle("Debug: Memory View"); // // The main frame and its input and log widgets // QFrame* mainWindowFrame = new QFrame(this); // The top frame & groupbox that contains the input widgets QFrame* topSubFrame = new QFrame(mainWindowFrame); // The input edit m_inputEdit = new QLineEdit(topSubFrame); connect(m_inputEdit, SIGNAL(returnPressed()), this, SLOT(expressionSubmitted())); // The memory space combo box m_memoryComboBox = new QComboBox(topSubFrame); m_memoryComboBox->setMinimumWidth(300); connect(m_memoryComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(memoryRegionChanged(int))); // The main memory window m_memTable = new DebuggerView(DVT_MEMORY, m_machine, this); // Populate the combo box populateComboBox(); // Layout QHBoxLayout* subLayout = new QHBoxLayout(topSubFrame); subLayout->addWidget(m_inputEdit); subLayout->addWidget(m_memoryComboBox); subLayout->setSpacing(3); subLayout->setContentsMargins(2,2,2,2); QVBoxLayout* vLayout = new QVBoxLayout(mainWindowFrame); vLayout->setSpacing(3); vLayout->setContentsMargins(2,2,2,2); vLayout->addWidget(topSubFrame); vLayout->addWidget(m_memTable); setCentralWidget(mainWindowFrame); // // Menu bars // // Create a byte-chunk group QActionGroup* chunkGroup = new QActionGroup(this); QAction* chunkActOne = new QAction("1-byte chunks", this); QAction* chunkActTwo = new QAction("2-byte chunks", this); QAction* chunkActFour = new QAction("4-byte chunks", this); chunkActOne->setCheckable(true); chunkActTwo->setCheckable(true); chunkActFour->setCheckable(true); chunkActOne->setActionGroup(chunkGroup); chunkActTwo->setActionGroup(chunkGroup); chunkActFour->setActionGroup(chunkGroup); chunkActOne->setShortcut(QKeySequence("Ctrl+1")); chunkActTwo->setShortcut(QKeySequence("Ctrl+2")); chunkActFour->setShortcut(QKeySequence("Ctrl+4")); chunkActOne->setChecked(true); connect(chunkGroup, SIGNAL(triggered(QAction*)), this, SLOT(chunkChanged(QAction*))); // Create a address display group QActionGroup* addressGroup = new QActionGroup(this); QAction* addressActLogical = new QAction("Logical Addresses", this); QAction* addressActPhysical = new QAction("Physical Addresses", this); addressActLogical->setCheckable(true); addressActPhysical->setCheckable(true); addressActLogical->setActionGroup(addressGroup); addressActPhysical->setActionGroup(addressGroup); addressActLogical->setShortcut(QKeySequence("Ctrl+G")); addressActPhysical->setShortcut(QKeySequence("Ctrl+Y")); addressActLogical->setChecked(true); connect(addressGroup, SIGNAL(triggered(QAction*)), this, SLOT(addressChanged(QAction*))); // Create a reverse view radio QAction* reverseAct = new QAction("Reverse View", this); reverseAct->setCheckable(true); reverseAct->setShortcut(QKeySequence("Ctrl+R")); connect(reverseAct, SIGNAL(toggled(bool)), this, SLOT(reverseChanged(bool))); // Create increase and decrease bytes-per-line actions QAction* increaseBplAct = new QAction("Increase Bytes Per Line", this); QAction* decreaseBplAct = new QAction("Decrease Bytes Per Line", this); increaseBplAct->setShortcut(QKeySequence("Ctrl+P")); decreaseBplAct->setShortcut(QKeySequence("Ctrl+O")); connect(increaseBplAct, SIGNAL(triggered(bool)), this, SLOT(increaseBytesPerLine(bool))); connect(decreaseBplAct, SIGNAL(triggered(bool)), this, SLOT(decreaseBytesPerLine(bool))); // Assemble the options menu QMenu* optionsMenu = menuBar()->addMenu("&Options"); optionsMenu->addActions(chunkGroup->actions()); optionsMenu->addSeparator(); optionsMenu->addActions(addressGroup->actions()); optionsMenu->addSeparator(); optionsMenu->addAction(reverseAct); optionsMenu->addSeparator(); optionsMenu->addAction(increaseBplAct); optionsMenu->addAction(decreaseBplAct); }
MemoryWindow::MemoryWindow(running_machine* machine, QWidget* parent) : WindowQt(machine, nullptr) { setWindowTitle("Debug: Memory View"); if (parent != nullptr) { QPoint parentPos = parent->pos(); setGeometry(parentPos.x()+100, parentPos.y()+100, 800, 400); } // // The main frame and its input and log widgets // QFrame* mainWindowFrame = new QFrame(this); // The top frame & groupbox that contains the input widgets QFrame* topSubFrame = new QFrame(mainWindowFrame); // The input edit m_inputEdit = new QLineEdit(topSubFrame); connect(m_inputEdit, &QLineEdit::returnPressed, this, &MemoryWindow::expressionSubmitted); // The memory space combo box m_memoryComboBox = new QComboBox(topSubFrame); m_memoryComboBox->setObjectName("memoryregion"); m_memoryComboBox->setMinimumWidth(300); connect(m_memoryComboBox, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &MemoryWindow::memoryRegionChanged); // The main memory window m_memTable = new DebuggerMemView(DVT_MEMORY, m_machine, this); // Layout QHBoxLayout* subLayout = new QHBoxLayout(topSubFrame); subLayout->addWidget(m_inputEdit); subLayout->addWidget(m_memoryComboBox); subLayout->setSpacing(3); subLayout->setContentsMargins(2,2,2,2); QVBoxLayout* vLayout = new QVBoxLayout(mainWindowFrame); vLayout->setSpacing(3); vLayout->setContentsMargins(2,2,2,2); vLayout->addWidget(topSubFrame); vLayout->addWidget(m_memTable); setCentralWidget(mainWindowFrame); // // Menu bars // // Create a data format group QActionGroup* dataFormat = new QActionGroup(this); dataFormat->setObjectName("dataformat"); QAction* formatActOne = new QAction("1-byte chunks", this); QAction* formatActTwo = new QAction("2-byte chunks", this); QAction* formatActFour = new QAction("4-byte chunks", this); QAction* formatActEight = new QAction("8-byte chunks", this); QAction* formatAct32bitFloat = new QAction("32 bit floating point", this); QAction* formatAct64bitFloat = new QAction("64 bit floating point", this); QAction* formatAct80bitFloat = new QAction("80 bit floating point", this); formatActOne->setObjectName("formatActOne"); formatActTwo->setObjectName("formatActTwo"); formatActFour->setObjectName("formatActFour"); formatActEight->setObjectName("formatActEight"); formatAct32bitFloat->setObjectName("formatAct32bitFloat"); formatAct64bitFloat->setObjectName("formatAct64bitFloat"); formatAct80bitFloat->setObjectName("formatAct80bitFloat"); formatActOne->setCheckable(true); formatActTwo->setCheckable(true); formatActFour->setCheckable(true); formatActEight->setCheckable(true); formatAct32bitFloat->setCheckable(true); formatAct64bitFloat->setCheckable(true); formatAct80bitFloat->setCheckable(true); formatActOne->setActionGroup(dataFormat); formatActTwo->setActionGroup(dataFormat); formatActFour->setActionGroup(dataFormat); formatActEight->setActionGroup(dataFormat); formatAct32bitFloat->setActionGroup(dataFormat); formatAct64bitFloat->setActionGroup(dataFormat); formatAct80bitFloat->setActionGroup(dataFormat); formatActOne->setShortcut(QKeySequence("Ctrl+1")); formatActTwo->setShortcut(QKeySequence("Ctrl+2")); formatActFour->setShortcut(QKeySequence("Ctrl+4")); formatActEight->setShortcut(QKeySequence("Ctrl+8")); formatAct32bitFloat->setShortcut(QKeySequence("Ctrl+9")); formatActOne->setChecked(true); connect(dataFormat, &QActionGroup::triggered, this, &MemoryWindow::formatChanged); // Create a address display group QActionGroup* addressGroup = new QActionGroup(this); addressGroup->setObjectName("addressgroup"); QAction* addressActLogical = new QAction("Logical Addresses", this); QAction* addressActPhysical = new QAction("Physical Addresses", this); addressActLogical->setCheckable(true); addressActPhysical->setCheckable(true); addressActLogical->setActionGroup(addressGroup); addressActPhysical->setActionGroup(addressGroup); addressActLogical->setShortcut(QKeySequence("Ctrl+G")); addressActPhysical->setShortcut(QKeySequence("Ctrl+Y")); addressActLogical->setChecked(true); connect(addressGroup, &QActionGroup::triggered, this, &MemoryWindow::addressChanged); // Create a reverse view radio QAction* reverseAct = new QAction("Reverse View", this); reverseAct->setObjectName("reverse"); reverseAct->setCheckable(true); reverseAct->setShortcut(QKeySequence("Ctrl+R")); connect(reverseAct, &QAction::toggled, this, &MemoryWindow::reverseChanged); // Create increase and decrease bytes-per-line actions QAction* increaseBplAct = new QAction("Increase Bytes Per Line", this); QAction* decreaseBplAct = new QAction("Decrease Bytes Per Line", this); increaseBplAct->setShortcut(QKeySequence("Ctrl+P")); decreaseBplAct->setShortcut(QKeySequence("Ctrl+O")); connect(increaseBplAct, &QAction::triggered, this, &MemoryWindow::increaseBytesPerLine); connect(decreaseBplAct, &QAction::triggered, this, &MemoryWindow::decreaseBytesPerLine); // Assemble the options menu QMenu* optionsMenu = menuBar()->addMenu("&Options"); optionsMenu->addActions(dataFormat->actions()); optionsMenu->addSeparator(); optionsMenu->addActions(addressGroup->actions()); optionsMenu->addSeparator(); optionsMenu->addAction(reverseAct); optionsMenu->addSeparator(); optionsMenu->addAction(increaseBplAct); optionsMenu->addAction(decreaseBplAct); // // Initialize // populateComboBox(); // Set to the current CPU's memory view setToCurrentCpu(); }
void ChannelView::setupActions() { QSettings settings; sortBy = static_cast<SortBy>(settings.value(sortByKey, SortByName).toInt()); QMenu *sortMenu = new QMenu(this); QActionGroup *sortGroup = new QActionGroup(this); QAction *sortByNameAction = new QAction(tr("Name"), this); sortByNameAction->setActionGroup(sortGroup); sortByNameAction->setCheckable(true); if (sortBy == SortByName) sortByNameAction->setChecked(true); connect(sortByNameAction, SIGNAL(triggered()), SLOT(setSortByName())); sortMenu->addAction(sortByNameAction); QAction *sortByUpdatedAction = new QAction(tr("Last Updated"), this); sortByUpdatedAction->setActionGroup(sortGroup); sortByUpdatedAction->setCheckable(true); if (sortBy == SortByUpdated) sortByUpdatedAction->setChecked(true); connect(sortByUpdatedAction, SIGNAL(triggered()), SLOT(setSortByUpdated())); sortMenu->addAction(sortByUpdatedAction); QAction *sortByAddedAction = new QAction(tr("Last Added"), this); sortByAddedAction->setActionGroup(sortGroup); sortByAddedAction->setCheckable(true); if (sortBy == SortByAdded) sortByAddedAction->setChecked(true); connect(sortByAddedAction, SIGNAL(triggered()), SLOT(setSortByAdded())); sortMenu->addAction(sortByAddedAction); QAction *sortByLastWatched = new QAction(tr("Last Watched"), this); sortByLastWatched->setActionGroup(sortGroup); sortByLastWatched->setCheckable(true); if (sortBy == SortByLastWatched) sortByLastWatched->setChecked(true); connect(sortByLastWatched, SIGNAL(triggered()), SLOT(setSortByLastWatched())); sortMenu->addAction(sortByLastWatched); QAction *sortByMostWatched = new QAction(tr("Most Watched"), this); sortByMostWatched->setActionGroup(sortGroup); sortByMostWatched->setCheckable(true); if (sortBy == SortByMostWatched) sortByMostWatched->setChecked(true); connect(sortByMostWatched, SIGNAL(triggered()), SLOT(setSortByMostWatched())); sortMenu->addAction(sortByMostWatched); QToolButton *sortButton = new QToolButton(this); sortButton->setText(tr("Sort by")); sortButton->setIcon(IconUtils::icon("sort")); sortButton->setIconSize(QSize(16, 16)); sortButton->setToolButtonStyle(Qt::ToolButtonTextBesideIcon); sortButton->setPopupMode(QToolButton::InstantPopup); sortButton->setMenu(sortMenu); QWidgetAction *widgetAction = new QWidgetAction(this); widgetAction->setDefaultWidget(sortButton); widgetAction->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_O)); statusActions << widgetAction; markAsWatchedAction = new QAction( IconUtils::icon("mark-watched"), tr("Mark all as watched"), this); markAsWatchedAction->setEnabled(false); markAsWatchedAction->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_W)); connect(markAsWatchedAction, SIGNAL(triggered()), SLOT(markAllAsWatched())); statusActions << markAsWatchedAction; showUpdated = settings.value(showUpdatedKey, false).toBool(); QAction *showUpdatedAction = new QAction( IconUtils::icon("show-updated"), tr("Show Updated"), this); showUpdatedAction->setCheckable(true); showUpdatedAction->setChecked(showUpdated); showUpdatedAction->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_U)); connect(showUpdatedAction, SIGNAL(toggled(bool)), SLOT(toggleShowUpdated(bool))); statusActions << showUpdatedAction; foreach (QAction *action, statusActions) { window()->addAction(action); IconUtils::setupAction(action); }
void MainWindow::viewerInitialized() { // Only do init once disconnect(m_ui->centralWidget, SIGNAL(viewerInitialized()), this, SLOT(viewerInitialized())); m_ui->centralWidget->addToRenderList(&m_model); m_ui->centralWidget->addToAnimateList(&m_model); m_meshDock->setModel(&m_model); m_actionEnableUserShaders = new QAction("Enable external shaders", this); m_actionEnableUserShaders->setCheckable(true); m_actionEnableUserShaders->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_E)); connect(m_actionEnableUserShaders, SIGNAL(triggered(bool)), this, SLOT(actionEnableUserShaders(bool))); m_actionLocateUserShaders = new QAction("Locate external shaders...", this); m_actionLocateUserShaders->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_L)); connect(m_actionLocateUserShaders, SIGNAL(triggered()), this, SLOT(actionLocateUserShaders())); m_actionReloadUserShaders = new QAction("Reload external shaders", this); m_actionReloadUserShaders->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_R)); connect(m_actionReloadUserShaders, SIGNAL(triggered()), this, SLOT(actionReloadUserShader())); m_shaderGroup = new QActionGroup(this); for (int i = WZ_SHADER__FIRST; i < WZ_SHADER__LAST; ++i) { QString shadername = QWZM::shaderTypeToString(static_cast<wz_shader_type_t>(i)); QAction* shaderAct = new QAction(shadername, this); m_shaderSignalMapper->setMapping(shaderAct, i); shaderAct->setActionGroup(m_shaderGroup); if (i < 9) // FIXME shaderAct->setShortcut(QKeySequence(tr("Ctrl+%1").arg(i+1))); shaderAct->setCheckable(true); reloadShader(static_cast<wz_shader_type_t>(i), false); connect(shaderAct, SIGNAL(triggered()), m_shaderSignalMapper, SLOT(map())); } connect(m_shaderSignalMapper, SIGNAL(mapped(int)), this, SLOT(shaderAction(int))); QMenu* rendererMenu = new QMenu(this); rendererMenu->addActions(m_shaderGroup->actions()); // other user shader related stuff rendererMenu->addSeparator(); rendererMenu->addAction(m_actionEnableUserShaders); rendererMenu->addAction(m_actionLocateUserShaders); rendererMenu->addAction(m_actionReloadUserShaders); m_ui->actionRenderer->setMenu(rendererMenu); connect(m_ui->actionShowModelCenter, SIGNAL(triggered(bool)), &m_model, SLOT(setDrawCenterPointFlag(bool))); connect(m_ui->actionShowNormals, SIGNAL(triggered(bool)), &m_model, SLOT(setDrawNormalsFlag(bool))); connect(m_ui->actionShowNormals, SIGNAL(triggered(bool)), m_ui->actionShow_Tangent_And_Bitangent, SLOT(setEnabled(bool))); connect(m_ui->actionShow_Tangent_And_Bitangent, SIGNAL(triggered(bool)), &m_model, SLOT(setDrawTangentAndBitangentFlag(bool))); connect(m_ui->actionShow_Connectors, SIGNAL(triggered(bool)), &m_model, SLOT(setDrawConnectors(bool))); /// Load previous state m_ui->actionShowModelCenter->setChecked(m_settings->value("3DView/ShowModelCenter", false).toBool()); m_model.setDrawCenterPointFlag(m_ui->actionShowModelCenter->isChecked()); m_ui->actionShowNormals->setChecked(m_settings->value("3DView/ShowNormals", false).toBool()); m_model.setDrawNormalsFlag(m_ui->actionShowNormals->isChecked()); m_ui->actionShow_Connectors->setChecked(m_settings->value("3DView/ShowConnectors", false).toBool()); m_model.setDrawConnectors(m_ui->actionShow_Connectors->isChecked()); m_ui->actionShow_Tangent_And_Bitangent->setChecked(m_settings->value("3DView/ShowTangentAndBitangent", false).toBool()); m_model.setDrawTangentAndBitangentFlag(m_ui->actionShow_Tangent_And_Bitangent->isChecked()); m_ui->actionShow_Tangent_And_Bitangent->setEnabled(m_ui->actionShowNormals->isChecked()); m_ui->actionShowAxes->setChecked(m_settings->value("3DView/ShowAxes", true).toBool()); m_ui->actionShowGrid->setChecked(m_settings->value("3DView/ShowGrid", true).toBool()); m_ui->actionShowLightSource->setChecked(m_settings->value("3DView/ShowLightSource", true).toBool()); m_ui->actionLink_Light_Source_To_Camera->setChecked(m_settings->value("3DView/LinkLightToCamera", true).toBool()); m_actionEnableUserShaders->setChecked(m_settings->value("3DView/EnableUserShaders", false).toBool()); m_ui->actionAnimate->setChecked(m_settings->value("3DView/Animate", true).toBool()); actionEnableUserShaders(m_actionEnableUserShaders->isChecked()); // Default to 3.1 int shaderTag = m_settings->value("3DView/ShaderTag", wz_shader_type_tag[WZ_SHADER_WZ31]).toInt(); int shaderActIdx = -1; for (int i = WZ_SHADER__FIRST; i < WZ_SHADER__LAST; ++i) { if (shaderTag == wz_shader_type_tag[i]) shaderActIdx = i; } // Select any previous selection if (shaderActIdx >= 0) { if (m_shaderGroup->actions().at(shaderActIdx)->isEnabled()) m_shaderGroup->actions().at(shaderActIdx)->activate(QAction::Trigger); else shaderActIdx = -1; } // Otherwise use old approach if (shaderActIdx < 0) { for (int i = m_shaderGroup->actions().size() - 1; i >= 0; --i) { if (m_shaderGroup->actions().at(i)->isEnabled()) { m_shaderGroup->actions().at(i)->activate(QAction::Trigger); break; } } } }
/* OnSelectionChanged is registered to SelectionService, therefore no need to implement SelectionService Listener explicitly */ void QmitkControlVisualizationPropertiesView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) { m_Controls->m_BundleControlsFrame->setVisible(false); m_Controls->m_ImageControlsFrame->setVisible(false); if (nodes.size()>1) // only do stuff if one node is selected return; m_Controls->m_NumberGlyphsFrame->setVisible(false); m_Controls->m_GlyphFrame->setVisible(false); m_Controls->m_TSMenu->setVisible(false); m_SelectedNode = NULL; int numOdfImages = 0; for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it ) { mitk::DataNode::Pointer node = *it; if(node.IsNull()) continue; mitk::BaseData* nodeData = node->GetData(); if(nodeData == NULL) continue; m_SelectedNode = node; if (dynamic_cast<mitk::FiberBundle*>(nodeData)) { // handle fiber bundle property observers if (m_Color.IsNotNull()) m_Color->RemoveObserver(m_FiberBundleObserverTag); itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New(); command->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor ); m_Color = dynamic_cast<mitk::ColorProperty*>(node->GetProperty("color", NULL)); if (m_Color.IsNotNull()) m_FiberBundleObserverTag = m_Color->AddObserver( itk::ModifiedEvent(), command ); if (m_Opacity.IsNotNull()) m_Opacity->RemoveObserver(m_FiberBundleObserveOpacityTag); itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New(); command2->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SetFiberBundleOpacity ); m_Opacity = dynamic_cast<mitk::FloatProperty*>(node->GetProperty("opacity", NULL)); if (m_Opacity.IsNotNull()) m_FiberBundleObserveOpacityTag = m_Opacity->AddObserver( itk::ModifiedEvent(), command2 ); m_Controls->m_BundleControlsFrame->setVisible(true); if(m_CurrentPickingNode != 0 && node.GetPointer() != m_CurrentPickingNode) m_Controls->m_Crosshair->setEnabled(false); else m_Controls->m_Crosshair->setEnabled(true); int width; node->GetIntProperty("shape.linewidth", width); m_Controls->m_LineWidth->setValue(width); float radius; node->GetFloatProperty("shape.tuberadius", radius); m_Controls->m_TubeWidth->setValue(radius); float range; node->GetFloatProperty("Fiber2DSliceThickness",range); mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData()); mitk::BaseGeometry::Pointer geo = fib->GetGeometry(); mitk::ScalarType max = geo->GetExtentInMM(0); max = std::max(max, geo->GetExtentInMM(1)); max = std::max(max, geo->GetExtentInMM(2)); m_Controls->m_FiberThicknessSlider->setMaximum(max * 10); m_Controls->m_FiberThicknessSlider->setValue(range * 10); } else if(dynamic_cast<mitk::QBallImage*>(nodeData) || dynamic_cast<mitk::TensorImage*>(nodeData)) { m_Controls->m_ImageControlsFrame->setVisible(true); m_Controls->m_NumberGlyphsFrame->setVisible(true); m_Controls->m_GlyphFrame->setVisible(true); m_Controls->m_NormalizationFrame->setVisible(true); if(m_NodeUsedForOdfVisualization.IsNotNull()) { m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", false); m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", false); m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", false); } m_NodeUsedForOdfVisualization = node; m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S); m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C); m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T); int val; node->GetIntProperty("ShowMaxNumber", val); m_Controls->m_ShowMaxNumber->setValue(val); m_Controls->m_NormalizationDropdown-> setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("Normalization"))->GetValueAsId()); float fval; node->GetFloatProperty("Scaling",fval); m_Controls->m_ScalingFactor->setValue(fval); m_Controls->m_AdditionalScaling-> setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("ScaleBy"))->GetValueAsId()); bool switchTensorViewValue = false; node->GetBoolProperty( "DiffusionCore.Rendering.OdfVtkMapper.SwitchTensorView", switchTensorViewValue ); if( dynamic_cast<mitk::TensorImage*>(nodeData) ) { m_Controls-> m_EllipsoidViewRadioButton-> setEnabled( true ); m_Controls-> m_EllipsoidViewRadioButton-> setChecked( switchTensorViewValue ); } else { m_Controls-> m_EllipsoidViewRadioButton-> setEnabled( false ); m_Controls-> m_EllipsoidViewRadioButton-> setChecked( false ); } bool colourisationModeBit = false; node-> GetBoolProperty( "DiffusionCore.Rendering.OdfVtkMapper.ColourisationModeBit", colourisationModeBit ); m_Controls-> m_colouriseSimpleRadioButton-> setChecked( colourisationModeBit ); bool randomModeBit = false; node-> GetBoolProperty( "DiffusionCore.Rendering.OdfVtkMapper.RandomModeBit", randomModeBit ); m_Controls-> m_randomModeRadioButton-> setChecked( randomModeBit ); numOdfImages++; } else if(dynamic_cast<mitk::PlanarFigure*>(nodeData)) { PlanarFigureFocus(); } else if( dynamic_cast<mitk::Image*>(nodeData) ) { m_Controls->m_ImageControlsFrame->setVisible(true); m_Controls->m_TSMenu->setVisible(true); } } if( nodes.empty() ) return; mitk::DataNode::Pointer node = nodes.at(0); if( node.IsNull() ) return; QMenu *myMenu = m_MyMenu; myMenu->clear(); QActionGroup* thickSlicesActionGroup = new QActionGroup(myMenu); thickSlicesActionGroup->setExclusive(true); int currentTSMode = 0; { mitk::ResliceMethodProperty::Pointer m = dynamic_cast<mitk::ResliceMethodProperty*>(node->GetProperty( "reslice.thickslices" )); if( m.IsNotNull() ) currentTSMode = m->GetValueAsId(); } int maxTS = 30; for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it ) { mitk::Image* image = dynamic_cast<mitk::Image*>((*it)->GetData()); if (image) { int size = std::max(image->GetDimension(0), std::max(image->GetDimension(1), image->GetDimension(2))); if (size>maxTS) maxTS=size; } } maxTS /= 2; int currentNum = 0; { mitk::IntProperty::Pointer m = dynamic_cast<mitk::IntProperty*>(node->GetProperty( "reslice.thickslices.num" )); if( m.IsNotNull() ) { currentNum = m->GetValue(); if(currentNum < 0) currentNum = 0; if(currentNum > maxTS) currentNum = maxTS; } } if(currentTSMode==0) currentNum=0; QSlider *m_TSSlider = new QSlider(myMenu); m_TSSlider->setMinimum(0); m_TSSlider->setMaximum(maxTS-1); m_TSSlider->setValue(currentNum); m_TSSlider->setOrientation(Qt::Horizontal); connect( m_TSSlider, SIGNAL( valueChanged(int) ), this, SLOT( OnTSNumChanged(int) ) ); QHBoxLayout* _TSLayout = new QHBoxLayout; _TSLayout->setContentsMargins(4,4,4,4); _TSLayout->addWidget(m_TSSlider); _TSLayout->addWidget(m_TSLabel=new QLabel(QString::number(currentNum*2+1),myMenu)); QWidget* _TSWidget = new QWidget; _TSWidget->setLayout(_TSLayout); QActionGroup* thickSliceModeActionGroup = new QActionGroup(myMenu); thickSliceModeActionGroup->setExclusive(true); QWidgetAction *m_TSSliderAction = new QWidgetAction(myMenu); m_TSSliderAction->setDefaultWidget(_TSWidget); myMenu->addAction(m_TSSliderAction); QAction* mipThickSlicesAction = new QAction(myMenu); mipThickSlicesAction->setActionGroup(thickSliceModeActionGroup); mipThickSlicesAction->setText("MIP (max. intensity proj.)"); mipThickSlicesAction->setCheckable(true); mipThickSlicesAction->setChecked(currentThickSlicesMode==1); mipThickSlicesAction->setData(1); myMenu->addAction( mipThickSlicesAction ); QAction* sumThickSlicesAction = new QAction(myMenu); sumThickSlicesAction->setActionGroup(thickSliceModeActionGroup); sumThickSlicesAction->setText("SUM (sum intensity proj.)"); sumThickSlicesAction->setCheckable(true); sumThickSlicesAction->setChecked(currentThickSlicesMode==2); sumThickSlicesAction->setData(2); myMenu->addAction( sumThickSlicesAction ); QAction* weightedThickSlicesAction = new QAction(myMenu); weightedThickSlicesAction->setActionGroup(thickSliceModeActionGroup); weightedThickSlicesAction->setText("WEIGHTED (gaussian proj.)"); weightedThickSlicesAction->setCheckable(true); weightedThickSlicesAction->setChecked(currentThickSlicesMode==3); weightedThickSlicesAction->setData(3); myMenu->addAction( weightedThickSlicesAction ); connect( thickSliceModeActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(OnThickSlicesModeSelected(QAction*)) ); }
MainWindow::MainWindow() : mSettings(new QSettings("Cppcheck", "Cppcheck-GUI", this)), mApplications(new ApplicationList(this)), mTranslation(new TranslationHandler(this)), mLogView(NULL), mProject(NULL), mPlatformActions(new QActionGroup(this)), mExiting(false) { mUI.setupUi(this); mUI.mResults->Initialize(mSettings, mApplications); mThread = new ThreadHandler(this); mLogView = new LogView; // Filter timer to delay filtering results slightly while typing mFilterTimer = new QTimer(this); mFilterTimer->setInterval(500); mFilterTimer->setSingleShot(true); connect(mFilterTimer, SIGNAL(timeout()), this, SLOT(FilterResults())); // "Filter" toolbar mLineEditFilter = new QLineEdit(mUI.mToolBarFilter); mLineEditFilter->setPlaceholderText(tr("Quick Filter:")); mUI.mToolBarFilter->addWidget(mLineEditFilter); connect(mLineEditFilter, SIGNAL(textChanged(const QString&)), mFilterTimer, SLOT(start())); connect(mLineEditFilter, SIGNAL(returnPressed()), this, SLOT(FilterResults())); connect(mUI.mActionQuit, SIGNAL(triggered()), this, SLOT(close())); connect(mUI.mActionCheckFiles, SIGNAL(triggered()), this, SLOT(CheckFiles())); connect(mUI.mActionCheckDirectory, SIGNAL(triggered()), this, SLOT(CheckDirectory())); connect(mUI.mActionSettings, SIGNAL(triggered()), this, SLOT(ProgramSettings())); connect(mUI.mActionClearResults, SIGNAL(triggered()), this, SLOT(ClearResults())); connect(mUI.mActionOpenXML, SIGNAL(triggered()), this, SLOT(OpenXML())); connect(mUI.mActionShowStyle, SIGNAL(toggled(bool)), this, SLOT(ShowStyle(bool))); connect(mUI.mActionShowErrors, SIGNAL(toggled(bool)), this, SLOT(ShowErrors(bool))); connect(mUI.mActionShowWarnings, SIGNAL(toggled(bool)), this, SLOT(ShowWarnings(bool))); connect(mUI.mActionShowPortability, SIGNAL(toggled(bool)), this, SLOT(ShowPortability(bool))); connect(mUI.mActionShowPerformance, SIGNAL(toggled(bool)), this, SLOT(ShowPerformance(bool))); connect(mUI.mActionShowInformation, SIGNAL(toggled(bool)), this, SLOT(ShowInformation(bool))); connect(mUI.mActionCheckAll, SIGNAL(triggered()), this, SLOT(CheckAll())); connect(mUI.mActionUncheckAll, SIGNAL(triggered()), this, SLOT(UncheckAll())); connect(mUI.mActionCollapseAll, SIGNAL(triggered()), mUI.mResults, SLOT(CollapseAllResults())); connect(mUI.mActionExpandAll, SIGNAL(triggered()), mUI.mResults, SLOT(ExpandAllResults())); connect(mUI.mActionShowHidden, SIGNAL(triggered()), mUI.mResults, SLOT(ShowHiddenResults())); connect(mUI.mActionViewLog, SIGNAL(triggered()), this, SLOT(ShowLogView())); connect(mUI.mActionViewStats, SIGNAL(triggered()), this, SLOT(ShowStatistics())); connect(mUI.mActionRecheck, SIGNAL(triggered()), this, SLOT(ReCheck())); connect(mUI.mActionStop, SIGNAL(triggered()), this, SLOT(StopChecking())); connect(mUI.mActionSave, SIGNAL(triggered()), this, SLOT(Save())); // About menu connect(mUI.mActionAbout, SIGNAL(triggered()), this, SLOT(About())); connect(mUI.mActionLicense, SIGNAL(triggered()), this, SLOT(ShowLicense())); // View > Toolbar menu connect(mUI.mActionToolBarMain, SIGNAL(toggled(bool)), this, SLOT(ToggleMainToolBar())); connect(mUI.mActionToolBarView, SIGNAL(toggled(bool)), this, SLOT(ToggleViewToolBar())); connect(mUI.mActionToolBarFilter, SIGNAL(toggled(bool)), this, SLOT(ToggleFilterToolBar())); connect(mUI.mActionAuthors, SIGNAL(triggered()), this, SLOT(ShowAuthors())); connect(mThread, SIGNAL(Done()), this, SLOT(CheckDone())); connect(mUI.mResults, SIGNAL(GotResults()), this, SLOT(ResultsAdded())); connect(mUI.mResults, SIGNAL(ResultsHidden(bool)), mUI.mActionShowHidden, SLOT(setEnabled(bool))); connect(mUI.mMenuView, SIGNAL(aboutToShow()), this, SLOT(AboutToShowViewMenu())); // File menu connect(mUI.mActionNewProjectFile, SIGNAL(triggered()), this, SLOT(NewProjectFile())); connect(mUI.mActionOpenProjectFile, SIGNAL(triggered()), this, SLOT(OpenProjectFile())); connect(mUI.mActionCloseProjectFile, SIGNAL(triggered()), this, SLOT(CloseProjectFile())); connect(mUI.mActionEditProjectFile, SIGNAL(triggered()), this, SLOT(EditProjectFile())); connect(mUI.mActionHelpContents, SIGNAL(triggered()), this, SLOT(OpenHelpContents())); LoadSettings(); mThread->Initialize(mUI.mResults); FormatAndSetTitle(); EnableCheckButtons(true); mUI.mActionClearResults->setEnabled(false); mUI.mActionSave->setEnabled(false); mUI.mActionRecheck->setEnabled(false); EnableProjectOpenActions(true); EnableProjectActions(false); // Must setup MRU menu before CLI param handling as it can load a // project file and update MRU menu. for (int i = 0; i < MaxRecentProjects; ++i) { mRecentProjectActs[i] = new QAction(this); mRecentProjectActs[i]->setVisible(false); connect(mRecentProjectActs[i], SIGNAL(triggered()), this, SLOT(OpenRecentProject())); } mRecentProjectActs[MaxRecentProjects] = NULL; // The separator mUI.mActionProjectMRU->setVisible(false); UpdateMRUMenuItems(); QStringList args = QCoreApplication::arguments(); //Remove the application itself args.removeFirst(); if (!args.isEmpty()) { HandleCLIParams(args); } for (int i = 0; i < mPlatforms.getCount(); i++) { Platform plat = mPlatforms.mPlatforms[i]; QAction *act = new QAction(this); plat.mActMainWindow = act; mPlatforms.mPlatforms[i] = plat; act->setText(plat.mTitle); act->setData(plat.mType); act->setCheckable(true); act->setActionGroup(mPlatformActions); mUI.mMenuCheck->insertAction(mUI.mActionPlatforms, act); connect(act, SIGNAL(triggered()), this, SLOT(SelectPlatform())); } // For Windows platforms default to Win32 checked platform. // For other platforms default to unspecified/default which means the // platform Cppcheck GUI was compiled on. #if defined(_WIN32) Platform &plat = mPlatforms.get(Settings::Win32A); #else Platform &plat = mPlatforms.get(Settings::Unspecified); #endif plat.mActMainWindow->setChecked(true); mSettings->setValue(SETTINGS_CHECKED_PLATFORM, plat.mType); }
MainWindow::MainWindow(running_machine* machine, QWidget* parent) : WindowQt(machine, nullptr), m_historyIndex(0), m_inputHistory() { setGeometry(300, 300, 1000, 600); // // The main frame and its input and log widgets // QFrame* mainWindowFrame = new QFrame(this); // The input line m_inputEdit = new QLineEdit(mainWindowFrame); connect(m_inputEdit, &QLineEdit::returnPressed, this, &MainWindow::executeCommandSlot); m_inputEdit->installEventFilter(this); // The log view m_consoleView = new DebuggerView(DVT_CONSOLE, m_machine, mainWindowFrame); m_consoleView->setFocusPolicy(Qt::NoFocus); m_consoleView->setPreferBottom(true); QVBoxLayout* vLayout = new QVBoxLayout(mainWindowFrame); vLayout->addWidget(m_consoleView); vLayout->addWidget(m_inputEdit); vLayout->setSpacing(3); vLayout->setContentsMargins(4,0,4,2); setCentralWidget(mainWindowFrame); // // Options Menu // // Create three commands m_breakpointToggleAct = new QAction("Toggle Breakpoint at Cursor", this); m_breakpointEnableAct = new QAction("Disable Breakpoint at Cursor", this); m_runToCursorAct = new QAction("Run to Cursor", this); m_breakpointToggleAct->setShortcut(Qt::Key_F9); m_breakpointEnableAct->setShortcut(Qt::SHIFT + Qt::Key_F9); m_runToCursorAct->setShortcut(Qt::Key_F4); connect(m_breakpointToggleAct, &QAction::triggered, this, &MainWindow::toggleBreakpointAtCursor); connect(m_breakpointEnableAct, &QAction::triggered, this, &MainWindow::enableBreakpointAtCursor); connect(m_runToCursorAct, &QAction::triggered, this, &MainWindow::runToCursor); // Right bar options QActionGroup* rightBarGroup = new QActionGroup(this); rightBarGroup->setObjectName("rightbargroup"); QAction* rightActRaw = new QAction("Raw Opcodes", this); QAction* rightActEncrypted = new QAction("Encrypted Opcodes", this); QAction* rightActComments = new QAction("Comments", this); rightActRaw->setCheckable(true); rightActEncrypted->setCheckable(true); rightActComments->setCheckable(true); rightActRaw->setActionGroup(rightBarGroup); rightActEncrypted->setActionGroup(rightBarGroup); rightActComments->setActionGroup(rightBarGroup); rightActRaw->setShortcut(QKeySequence("Ctrl+R")); rightActEncrypted->setShortcut(QKeySequence("Ctrl+E")); rightActComments->setShortcut(QKeySequence("Ctrl+N")); rightActRaw->setChecked(true); connect(rightBarGroup, &QActionGroup::triggered, this, &MainWindow::rightBarChanged); // Assemble the options menu QMenu* optionsMenu = menuBar()->addMenu("&Options"); optionsMenu->addAction(m_breakpointToggleAct); optionsMenu->addAction(m_breakpointEnableAct); optionsMenu->addAction(m_runToCursorAct); optionsMenu->addSeparator(); optionsMenu->addActions(rightBarGroup->actions()); // // Images menu // image_interface_iterator imageIterTest(m_machine->root_device()); if (imageIterTest.first() != nullptr) { createImagesMenu(); } // // Dock window menu // QMenu* dockMenu = menuBar()->addMenu("Doc&ks"); setCorner(Qt::TopRightCorner, Qt::TopDockWidgetArea); setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea); // The processor dock QDockWidget* cpuDock = new QDockWidget("processor", this); cpuDock->setObjectName("cpudock"); cpuDock->setAllowedAreas(Qt::LeftDockWidgetArea); m_procFrame = new ProcessorDockWidget(m_machine, cpuDock); cpuDock->setWidget(dynamic_cast<QWidget*>(m_procFrame)); addDockWidget(Qt::LeftDockWidgetArea, cpuDock); dockMenu->addAction(cpuDock->toggleViewAction()); // The disassembly dock QDockWidget* dasmDock = new QDockWidget("dasm", this); dasmDock->setObjectName("dasmdock"); dasmDock->setAllowedAreas(Qt::TopDockWidgetArea); m_dasmFrame = new DasmDockWidget(m_machine, dasmDock); dasmDock->setWidget(m_dasmFrame); connect(m_dasmFrame->view(), &DebuggerView::updated, this, &MainWindow::dasmViewUpdated); addDockWidget(Qt::TopDockWidgetArea, dasmDock); dockMenu->addAction(dasmDock->toggleViewAction()); }
void WebView::editableContentActionPopupMenu(KParts::BrowserExtension::ActionGroupMap& partGroupMap) { QList<QAction*> editableContentActions; KActionMenu* menu = new KActionMenu(i18nc("Text direction", "Direction"), this); QActionGroup* group = new QActionGroup(this); group->setExclusive(true); QAction *action = m_actionCollection->addAction(QL1S("text-direction-default"), m_part->browserExtension(), SLOT(slotTextDirectionChanged())); action->setText(i18n("Default")); action->setCheckable(true); action->setData(QWebPage::SetTextDirectionDefault); action->setEnabled(pageAction(QWebPage::SetTextDirectionDefault)->isEnabled()); action->setCheckable(pageAction(QWebPage::SetTextDirectionDefault)->isChecked()); action->setActionGroup(group); menu->addAction(action); action = m_actionCollection->addAction(QL1S("text-direction-left-to-right"), m_part->browserExtension(), SLOT(slotTextDirectionChanged())); action->setText(i18n("Left to right")); action->setCheckable(true); action->setData(QWebPage::SetTextDirectionLeftToRight); action->setEnabled(pageAction(QWebPage::SetTextDirectionLeftToRight)->isEnabled()); action->setChecked(pageAction(QWebPage::SetTextDirectionLeftToRight)->isChecked()); action->setActionGroup(group); menu->addAction(action); action = m_actionCollection->addAction(QL1S("text-direction-right-to-left"), m_part->browserExtension(), SLOT(slotTextDirectionChanged())); action->setText(i18n("Right to left")); action->setCheckable(true); action->setData(QWebPage::SetTextDirectionRightToLeft); action->setEnabled(pageAction(QWebPage::SetTextDirectionRightToLeft)->isEnabled()); action->setChecked(pageAction(QWebPage::SetTextDirectionRightToLeft)->isChecked()); action->setActionGroup(group); menu->addAction(action); editableContentActions.append(menu); action = new QAction(m_actionCollection); action->setSeparator(true); editableContentActions.append(action); action = m_actionCollection->addAction(KStandardAction::Copy, QL1S("copy"), m_part->browserExtension(), SLOT(copy())); action->setEnabled(pageAction(QWebPage::Copy)->isEnabled()); editableContentActions.append(action); action = m_actionCollection->addAction(KStandardAction::Cut, QL1S("cut"), m_part->browserExtension(), SLOT(cut())); action->setEnabled(pageAction(QWebPage::Cut)->isEnabled()); editableContentActions.append(action); action = m_actionCollection->addAction(KStandardAction::Paste, QL1S("paste"), m_part->browserExtension(), SLOT(paste())); action->setEnabled(pageAction(QWebPage::Paste)->isEnabled()); editableContentActions.append(action); action = new QAction(m_actionCollection); action->setSeparator(true); editableContentActions.append(action); const bool hasContent = (!m_result.element().evaluateJavaScript(QL1S("this.value")).toString().isEmpty()); action = m_actionCollection->addAction(KStandardAction::SelectAll, QL1S("selectall"), m_part->browserExtension(), SLOT(slotSelectAll())); action->setEnabled((pageAction(QWebPage::SelectAll)->isEnabled() && hasContent)); editableContentActions.append(action); if (showSpellCheckAction(m_result.element())) { action = new QAction(m_actionCollection); action->setSeparator(true); editableContentActions.append(action); action = m_actionCollection->addAction(KStandardAction::Spelling, QL1S("spelling"), m_part->browserExtension(), SLOT(slotCheckSpelling())); action->setText(i18n("Check Spelling...")); action->setEnabled(hasContent); editableContentActions.append(action); const bool hasSelection = (hasContent && m_result.isContentSelected()); action = m_actionCollection->addAction(KStandardAction::Spelling, QL1S("spellcheckSelection"), m_part->browserExtension(), SLOT(slotSpellCheckSelection())); action->setText(i18n("Spellcheck selection...")); action->setEnabled(hasSelection); editableContentActions.append(action); } if (settings()->testAttribute(QWebSettings::DeveloperExtrasEnabled)) { if (!m_webInspector) { m_webInspector = new QWebInspector; m_webInspector->setPage(page()); connect(page(), SIGNAL(destroyed()), m_webInspector, SLOT(deleteLater())); } action = new QAction(m_actionCollection); action->setSeparator(true); editableContentActions.append(action); editableContentActions.append(pageAction(QWebPage::InspectElement)); } partGroupMap.insert("editactions" , editableContentActions); }
void QActionProto::setActionGroup(QActionGroup *group) { QAction *item = qscriptvalue_cast<QAction*>(thisObject()); if (item) item->setActionGroup(group); }
DasmWindow::DasmWindow(running_machine* machine, QWidget* parent) : WindowQt(machine, nullptr) { setWindowTitle("Debug: Disassembly View"); if (parent != nullptr) { QPoint parentPos = parent->pos(); setGeometry(parentPos.x()+100, parentPos.y()+100, 800, 400); } // // The main frame and its input and log widgets // QFrame* mainWindowFrame = new QFrame(this); // The top frame & groupbox that contains the input widgets QFrame* topSubFrame = new QFrame(mainWindowFrame); // The input edit m_inputEdit = new QLineEdit(topSubFrame); connect(m_inputEdit, &QLineEdit::returnPressed, this, &DasmWindow::expressionSubmitted); // The cpu combo box m_cpuComboBox = new QComboBox(topSubFrame); m_cpuComboBox->setObjectName("cpu"); m_cpuComboBox->setMinimumWidth(300); connect(m_cpuComboBox, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &DasmWindow::cpuChanged); // The main disasm window m_dasmView = new DebuggerView(DVT_DISASSEMBLY, m_machine, this); connect(m_dasmView, &DebuggerView::updated, this, &DasmWindow::dasmViewUpdated); // Force a recompute of the disassembly region downcast<debug_view_disasm*>(m_dasmView->view())->set_expression("curpc"); // Populate the combo box & set the proper cpu populateComboBox(); //const debug_view_source *source = mem->views[0]->view->source_for_device(curcpu); //gtk_combo_box_set_active(zone_w, mem->views[0]->view->source_list().indexof(*source)); //mem->views[0]->view->set_source(*source); // Layout QHBoxLayout* subLayout = new QHBoxLayout(topSubFrame); subLayout->addWidget(m_inputEdit); subLayout->addWidget(m_cpuComboBox); subLayout->setSpacing(3); subLayout->setContentsMargins(2,2,2,2); QVBoxLayout* vLayout = new QVBoxLayout(mainWindowFrame); vLayout->setSpacing(3); vLayout->setContentsMargins(2,2,2,2); vLayout->addWidget(topSubFrame); vLayout->addWidget(m_dasmView); setCentralWidget(mainWindowFrame); // // Menu bars // // Create three commands m_breakpointToggleAct = new QAction("Toggle Breakpoint at Cursor", this); m_breakpointEnableAct = new QAction("Disable Breakpoint at Cursor", this); m_runToCursorAct = new QAction("Run to Cursor", this); m_breakpointToggleAct->setShortcut(Qt::Key_F9); m_breakpointEnableAct->setShortcut(Qt::SHIFT + Qt::Key_F9); m_runToCursorAct->setShortcut(Qt::Key_F4); connect(m_breakpointToggleAct, &QAction::triggered, this, &DasmWindow::toggleBreakpointAtCursor); connect(m_breakpointEnableAct, &QAction::triggered, this, &DasmWindow::enableBreakpointAtCursor); connect(m_runToCursorAct, &QAction::triggered, this, &DasmWindow::runToCursor); // Right bar options QActionGroup* rightBarGroup = new QActionGroup(this); rightBarGroup->setObjectName("rightbargroup"); QAction* rightActRaw = new QAction("Raw Opcodes", this); QAction* rightActEncrypted = new QAction("Encrypted Opcodes", this); QAction* rightActComments = new QAction("Comments", this); rightActRaw->setCheckable(true); rightActEncrypted->setCheckable(true); rightActComments->setCheckable(true); rightActRaw->setActionGroup(rightBarGroup); rightActEncrypted->setActionGroup(rightBarGroup); rightActComments->setActionGroup(rightBarGroup); rightActRaw->setShortcut(QKeySequence("Ctrl+R")); rightActEncrypted->setShortcut(QKeySequence("Ctrl+E")); rightActComments->setShortcut(QKeySequence("Ctrl+N")); rightActRaw->setChecked(true); connect(rightBarGroup, &QActionGroup::triggered, this, &DasmWindow::rightBarChanged); // Assemble the options menu QMenu* optionsMenu = menuBar()->addMenu("&Options"); optionsMenu->addAction(m_breakpointToggleAct); optionsMenu->addAction(m_breakpointEnableAct); optionsMenu->addAction(m_runToCursorAct); optionsMenu->addSeparator(); optionsMenu->addActions(rightBarGroup->actions()); }