Core::ActionContainer *FormEditorW::createPreviewStyleMenu(Core::ActionManager *am, QActionGroup *actionGroup) { const QString menuId = QLatin1String(M_FORMEDITOR_PREVIEW); Core::ActionContainer *menuPreviewStyle = am->createMenu(M_FORMEDITOR_PREVIEW); menuPreviewStyle->menu()->setTitle(tr("Preview in")); // The preview menu is a list of invisible actions for the embedded design // device profiles (integer data) followed by a separator and the styles // (string data). Make device profiles update their text and hide them // in the configuration dialog. const QList<QAction*> actions = actionGroup->actions(); const QString deviceProfilePrefix = QLatin1String("DeviceProfile"); const QChar dot = QLatin1Char('.'); foreach (QAction* a, actions) { QString name = menuId; name += dot; const QVariant data = a->data(); const bool isDeviceProfile = data.type() == QVariant::Int; if (isDeviceProfile) { name += deviceProfilePrefix; name += dot; } name += data.toString(); Core::Command *command = am->registerAction(a, Core::Id(name), m_contexts); bindShortcut(command, a); if (isDeviceProfile) { command->setAttribute(Core::Command::CA_UpdateText); command->setAttribute(Core::Command::CA_NonConfigurable); } menuPreviewStyle->addAction(command); }
bool ImportExportPlugin::initialize(const QStringList& args, QString *errMsg) { Q_UNUSED(args); Q_UNUSED(errMsg); // Add Menu entry Core::ActionManager* am = Core::ICore::instance()->actionManager(); Core::ActionContainer* ac = am->actionContainer(Core::Constants::M_FILE); Core::Command* cmd = am->registerAction(new QAction(this), "ImportExportPlugin.ImportExport", QList<int>() << Core::Constants::C_GLOBAL_ID); cmd->setDefaultKeySequence(QKeySequence("Ctrl+S")); cmd->action()->setText(tr("GCS Settings Import/Export...")); // ac->menu()->addSeparator(); // ac->appendGroup("ImportExport"); // ac->addAction(cmd, "ImportExport"); ac->addAction(cmd, Core::Constants::G_FILE_SAVE); connect(cmd->action(), SIGNAL(triggered(bool)), this, SLOT(importExport())); return true; }
bool ExamplePlugin::initialize(const QStringList &arguments, QString *errorString) { // Register objects in the plugin manager's object pool // Load settings // Add actions to menus // Connect to other plugins' signals // In the initialize function, a plugin can be sure that the plugins it // depends on have initialized their members. Q_UNUSED(arguments) Q_UNUSED(errorString) //! [add action] QAction *action = new QAction(tr("Example action"), this); Core::Command *cmd = Core::ActionManager::registerAction(action, Constants::ACTION_ID, Core::Context(Core::Constants::C_GLOBAL)); cmd->setDefaultKeySequence(QKeySequence(tr("Ctrl+Alt+Meta+A"))); connect(action, SIGNAL(triggered()), this, SLOT(triggerAction())); //! [add action] //! [add menu] Core::ActionContainer *menu = Core::ActionManager::createMenu(Constants::MENU_ID); menu->menu()->setTitle(tr("Example")); menu->addAction(cmd); Core::ActionManager::actionContainer(Core::Constants::M_TOOLS)->addMenu(menu); //! [add menu] return true; }
void ActionHandler::createActions() { Core::ActionContainer *medit = Core::ActionManager::actionContainer(Core::Constants::M_EDIT); d->undoAction = registerCommand(Core::Constants::UNDO, [this]() { undo(); })->action(); d->redoAction = registerCommand(Core::Constants::REDO, [this]() { redo(); })->action(); d->cutAction = registerCommand(Core::Constants::CUT, [this]() { cut(); })->action(); d->copyAction = registerCommand(Core::Constants::COPY, [this]() { copy(); })->action(); d->pasteAction = registerCommand(Core::Constants::PASTE, [this]() { paste(); })->action(); Core::Command *removeCommand = registerCommand( Constants::REMOVE_SELECTED_ELEMENTS, [this]() { removeSelectedElements(); }, true, tr("&Remove"), QKeySequence::Delete); medit->addAction(removeCommand, Core::Constants::G_EDIT_COPYPASTE); d->removeAction = removeCommand->action(); Core::Command *deleteCommand = registerCommand( Constants::DELETE_SELECTED_ELEMENTS, [this]() { deleteSelectedElements(); }, true, tr("&Delete"), QKeySequence(QStringLiteral("Ctrl+D"))); medit->addAction(deleteCommand, Core::Constants::G_EDIT_COPYPASTE); d->deleteAction = deleteCommand->action(); d->selectAllAction = registerCommand(Core::Constants::SELECTALL, [this]() { selectAll(); })->action(); registerCommand(Constants::ACTION_ADD_PACKAGE, nullptr); registerCommand(Constants::ACTION_ADD_COMPONENT, nullptr); registerCommand(Constants::ACTION_ADD_CLASS, nullptr); registerCommand(Constants::ACTION_ADD_CANVAS_DIAGRAM, nullptr); }
/** * Add Logging plugin to File menu */ bool LoggingPlugin::initialize(const QStringList& args, QString *errMsg) { Q_UNUSED(args); Q_UNUSED(errMsg); loggingThread = NULL; // Add Menu entry Core::ActionManager* am = Core::ICore::instance()->actionManager(); Core::ActionContainer* ac = am->actionContainer(Core::Constants::M_TOOLS); // Command to start logging Core::Command* cmd = am->registerAction(new QAction(this), "LoggingPlugin.Logging", QList<int>() << Core::Constants::C_GLOBAL_ID); cmd->setDefaultKeySequence(QKeySequence("Ctrl+L")); cmd->action()->setText("Start logging..."); ac->menu()->addSeparator(); ac->appendGroup("Logging"); ac->addAction(cmd, "Logging"); connect(cmd->action(), SIGNAL(triggered(bool)), this, SLOT(toggleLogging())); mf = new LoggingGadgetFactory(this); addAutoReleasedObject(mf); // Map signal from end of replay to replay stopped connect(getLogfile(),SIGNAL(replayFinished()), this, SLOT(replayStopped())); return true; }
UAVSettingsImportExportFactory::UAVSettingsImportExportFactory(QObject *parent) : QObject(parent) { // Add Menu entry Core::ActionManager *am = Core::ICore::instance()->actionManager(); Core::ActionContainer *ac = am->actionContainer(Core::Constants::M_FILE); Core::Command *cmd = am->registerAction(new QAction(this), "UAVSettingsImportExportPlugin.UAVSettingsExport", QList<int>() << Core::Constants::C_GLOBAL_ID); cmd->setDefaultKeySequence(QKeySequence("Ctrl+E")); cmd->action()->setText(tr("Export UAV Settings...")); ac->addAction(cmd, Core::Constants::G_FILE_SAVE); connect(cmd->action(), SIGNAL(triggered(bool)), this, SLOT(exportUAVSettings())); cmd = am->registerAction(new QAction(this), "UAVSettingsImportExportPlugin.UAVSettingsImport", QList<int>() << Core::Constants::C_GLOBAL_ID); cmd->setDefaultKeySequence(QKeySequence("Ctrl+I")); cmd->action()->setText(tr("Import UAV Settings...")); ac->addAction(cmd, Core::Constants::G_FILE_SAVE); connect(cmd->action(), SIGNAL(triggered(bool)), this, SLOT(importUAVSettings())); ac = am->actionContainer(Core::Constants::M_HELP); cmd = am->registerAction(new QAction(this), "UAVSettingsImportExportPlugin.UAVDataExport", QList<int>() << Core::Constants::C_GLOBAL_ID); cmd->action()->setText(tr("Export UAV Data...")); ac->addAction(cmd, Core::Constants::G_HELP_HELP); connect(cmd->action(), SIGNAL(triggered(bool)), this, SLOT(exportUAVData())); }
bool ClangFormat::initialize() { Core::ActionContainer *menu = Core::ActionManager::createMenu(Constants::ClangFormat::MENU_ID); menu->menu()->setTitle(tr("&ClangFormat")); m_formatFile = new QAction(BeautifierPlugin::msgFormatCurrentFile(), this); Core::Command *cmd = Core::ActionManager::registerAction(m_formatFile, Constants::ClangFormat::ACTION_FORMATFILE); menu->addAction(cmd); connect(m_formatFile, &QAction::triggered, this, &ClangFormat::formatFile); m_formatRange = new QAction(BeautifierPlugin::msgFormatAtCursor(), this); cmd = Core::ActionManager::registerAction(m_formatRange, Constants::ClangFormat::ACTION_FORMATATCURSOR); menu->addAction(cmd); connect(m_formatRange, &QAction::triggered, this, &ClangFormat::formatAtCursor); m_disableFormattingSelectedText = new QAction(BeautifierPlugin::msgDisableFormattingSelectedText(), this); cmd = Core::ActionManager::registerAction( m_disableFormattingSelectedText, Constants::ClangFormat::ACTION_DISABLEFORMATTINGSELECTED); menu->addAction(cmd); connect(m_disableFormattingSelectedText, &QAction::triggered, this, &ClangFormat::disableFormattingSelectedText); Core::ActionManager::actionContainer(Constants::MENU_ID)->addMenu(menu); connect(m_settings, &ClangFormatSettings::supportedMimeTypesChanged, [this] { updateActions(Core::EditorManager::currentEditor()); }); new ClangFormatOptionsPage(m_settings, this); return true; }
void FindPlugin::setupFilterMenuItems() { QList<IFindFilter*> findInterfaces = ExtensionSystem::PluginManager::getObjects<IFindFilter>(); Core::Command *cmd; Core::Context globalcontext(Core::Constants::C_GLOBAL); Core::ActionContainer *mfindadvanced = Core::ActionManager::actionContainer(Constants::M_FIND_ADVANCED); d->m_filterActions.clear(); bool haveEnabledFilters = false; const Core::Id base("FindFilter."); foreach (IFindFilter *filter, findInterfaces) { QAction *action = new QAction(QLatin1String(" ") + filter->displayName(), this); bool isEnabled = filter->isEnabled(); if (isEnabled) haveEnabledFilters = true; action->setEnabled(isEnabled); action->setData(qVariantFromValue(filter)); cmd = Core::ActionManager::registerAction(action, base.withSuffix(filter->id()), globalcontext); cmd->setDefaultKeySequence(filter->defaultShortcut()); mfindadvanced->addAction(cmd); d->m_filterActions.insert(filter, action); connect(action, SIGNAL(triggered(bool)), this, SLOT(openFindFilter())); connect(filter, SIGNAL(enabledChanged(bool)), this, SLOT(filterChanged())); }
bool Tester::Internal::Plugin::initialize(const QStringList &arguments, QString *errorString) { // Register objects in the plugin manager's object pool // Load settings // Add actions to menus // Connect to other plugins' signals // In the initialize method, a plugin can be sure that the plugins it // depends on have initialized their members. Q_UNUSED(arguments) Q_UNUSED(errorString) Core::Command *cmd = Core::ActionManager::registerAction(Controller->startAction(), Constants::ACTION_ID, Core::Context(Core::Constants::C_GLOBAL)); cmd->setDefaultKeySequence(QKeySequence(tr("Ctrl+Alt+Meta+A"))); connect(Controller->startAction(), SIGNAL(triggered()), this, SLOT(triggerAction())); Core::ActionContainer *menu = Core::ActionManager::createMenu(Constants::MENU_ID); menu->menu()->setTitle(tr("TesterPlugin")); menu->addAction(cmd); Core::ActionManager::actionContainer(Core::Constants::M_TOOLS)->addMenu(menu); MonitoringViewFactory = new Tester::Internal::MonitoringViewFactory; MonitoringViewFactory->setController(Controller); addAutoReleasedObject(MonitoringViewFactory); Mode = new Tester::Internal::Mode(this); Mode->setController(Controller); addAutoReleasedObject(Mode); return true; }
bool DoNothingPlugin::initialize(const QStringList& args, QString *errMsg) { Q_UNUSED(args); Q_UNUSED(errMsg); // Fetch the action manager Core::ActionManager* am = Core::ICore::instance()->actionManager(); // Create a DoNothing menu Core::ActionContainer* ac = am->createMenu("DoNothingPlugin.DoNothingMenu"); ac->menu()->setTitle("DoNothing"); // Create a command for "DoNothing". QAction *action = new QAction(tr("DoNothing"),this); Core::Command* cmd = am->registerAction(action, QLatin1String("DoNothingPlugin.DoNothing"), Core::Context(Core::Constants::C_GLOBAL)); // Add DoNothing menu to the menubar am->actionContainer(Core::Constants::M_TOOLS)->addMenu(ac, Core::Constants::G_DEFAULT_THREE); // Add the "DoNothing" action to the DoNothing menu ac->addAction(cmd); // Connect the action connect(action, SIGNAL(triggered(bool)), this, SLOT(performAction())); return true; }
ActionManager::ActionManager(QObject *parent) : QObject(parent), runAction(new QAction(QIcon(":/icons/images/run.png"), tr("Run tests"), this)), waitAction(new QAction(QIcon(":/icons/images/stop.png"), tr("Stop coverage execution"), this)), renderAction(new QAction(QIcon(":/icons/images/render.png"), tr("Show code coverage"), this)) { renderAction->setCheckable(true); // Add action to menu Core::ActionManager *pluginActionManager = Core::ICore::actionManager(); Core::Command *runCommand = pluginActionManager->registerAction(runAction, RUN_ACTION_ID, Core::Context(Core::Constants::C_GLOBAL)); Core::Command *renderCommand = pluginActionManager->registerAction(renderAction, RENDER_ACTION_ID, Core::Context(Core::Constants::C_GLOBAL)); runCommand->setKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_E); renderCommand->setKeySequence(Qt::CTRL + Qt::Key_H); Core::ActionContainer *menu = pluginActionManager->createMenu(MENU_ID); menu->menu()->setTitle(tr("CodeCoverage")); menu->addAction(runCommand); menu->addAction(renderCommand); pluginActionManager->actionContainer(Core::Constants::M_TOOLS)->addMenu(menu); // Add action as icon to left bar Core::ModeManager *modeManager = Core::ModeManager::instance(); modeManager->addAction(runAction, RUN_ACTION_PRIORITY); modeManager->addAction(waitAction, WAIT_ACTION_PRIORITY); }
void TfsPlugin::createMenu() { Core::Context context(Core::Constants::C_GLOBAL); // Create menu item for Mercurial tfsContainer = Core::ActionManager::createMenu("Tfs.TfsMenu"); QMenu *menu = tfsContainer->menu(); menu->setTitle(tr("&TFS")); createFileActions(context); tfsContainer->addSeparator(context); createDirectoryActions(context); tfsContainer->addSeparator(context); createRepositoryActions(context); tfsContainer->addSeparator(context); createRepositoryManagementActions(context); tfsContainer->addSeparator(context); createLessUsedActions(context); // Request the Tools menu and add the Tfs menu to it Core::ActionContainer *toolsMenu = Core::ActionManager::actionContainer(Core::Id(Core::Constants::M_TOOLS)); toolsMenu->addMenu(tfsContainer); m_menuAction = tfsContainer->menu()->menuAction(); }
/** \brief Populate recent files menu */ void MainWindow::aboutToShowRecentFiles() { Core::ActionContainer *aci = actionManager()->actionContainer(Core::Constants::M_FILE_RECENTFILES); aci->clear(); foreach (const QString &fileName, fileManager()->recentFiles()) { QAction *action = aci->menu()->addAction(fileName); action->setData(fileName); connect(action, SIGNAL(triggered()), this, SLOT(openRecentFile())); }
bool CppToolsPlugin::initialize(const QStringList &arguments, QString *error) { Q_UNUSED(arguments) Q_UNUSED(error) qRegisterMetaType<CppTools::CppCodeStyleSettings>("CppTools::CppCodeStyleSettings"); Core::ICore *core = Core::ICore::instance(); Core::ActionManager *am = core->actionManager(); m_settings = new CppToolsSettings(this); // force registration of cpp tools settings // Objects m_modelManager = new CppModelManager(this); Core::VcsManager *vcsManager = core->vcsManager(); Core::FileManager *fileManager = core->fileManager(); connect(vcsManager, SIGNAL(repositoryChanged(QString)), m_modelManager, SLOT(updateModifiedSourceFiles())); connect(fileManager, SIGNAL(filesChangedInternally(QStringList)), m_modelManager, SLOT(updateSourceFiles(QStringList))); addAutoReleasedObject(m_modelManager); addAutoReleasedObject(new CppCompletionAssistProvider); addAutoReleasedObject(new CppLocatorFilter(m_modelManager)); addAutoReleasedObject(new CppClassesFilter(m_modelManager)); addAutoReleasedObject(new CppFunctionsFilter(m_modelManager)); addAutoReleasedObject(new CppCurrentDocumentFilter(m_modelManager, core->editorManager())); addAutoReleasedObject(new CompletionSettingsPage); addAutoReleasedObject(new CppFileSettingsPage(m_fileSettings)); addAutoReleasedObject(new SymbolsFindFilter(m_modelManager)); addAutoReleasedObject(new CppCodeStyleSettingsPage); TextEditor::CodeStylePreferencesManager::instance()->registerFactory( new CppTools::CppCodeStylePreferencesFactory()); // Menus Core::ActionContainer *mtools = am->actionContainer(Core::Constants::M_TOOLS); Core::ActionContainer *mcpptools = am->createMenu(CppTools::Constants::M_TOOLS_CPP); QMenu *menu = mcpptools->menu(); menu->setTitle(tr("&C++")); menu->setEnabled(true); mtools->addMenu(mcpptools); // Actions Core::Context context(CppEditor::Constants::C_CPPEDITOR); QAction *switchAction = new QAction(tr("Switch Header/Source"), this); Core::Command *command = am->registerAction(switchAction, Constants::SWITCH_HEADER_SOURCE, context, true); command->setDefaultKeySequence(QKeySequence(Qt::Key_F4)); mcpptools->addAction(command); connect(switchAction, SIGNAL(triggered()), this, SLOT(switchHeaderSource())); return true; }
/** \brief Create the menubar and the MainWindow actions. */ bool MainWindow::initialize(const QStringList &arguments, QString *errorString) { Q_UNUSED(arguments); Q_UNUSED(errorString); // create menus createFileMenu(); Core::ActionContainer *fmenu = actionManager()->actionContainer(Core::Constants::M_FILE); connect(fmenu->menu(), SIGNAL(aboutToShow()),this, SLOT(aboutToShowRecentFiles())); createEditMenu(); createConfigurationMenu(); createHelpMenu(); Core::MainWindowActions actions; actions.setFileActions( Core::MainWindowActions::A_FileNew | Core::MainWindowActions::A_FileOpen | Core::MainWindowActions::A_FileSave | Core::MainWindowActions::A_FileSaveAs | Core::MainWindowActions::A_FilePrint | Core::MainWindowActions::A_FilePrintPreview | Core::MainWindowActions::A_FileQuit ); actions.setConfigurationActions( Core::MainWindowActions::A_AppPreferences | Core::MainWindowActions::A_LanguageChange ); actions.setHelpActions( Core::MainWindowActions::A_AppAbout | Core::MainWindowActions::A_PluginsAbout | Core::MainWindowActions::A_AppHelp | Core::MainWindowActions::A_DebugDialog | Core::MainWindowActions::A_CheckUpdate //| // Core::MainWindowActions::A_QtAbout ); actions.createEditActions(true); createActions(actions); connectFileActions(); connectConfigurationActions(); connectHelpActions(); // Creating MainWindow interface // m_ui = new Internal::Ui::MainWindow(); // m_ui->setupUi(this); // m_ui->padTextEdit->toogleToolbar(true); // resize(1024, 768); // m_ui->splitterMain->setSizes(QList<int>() << 150); // m_ui->splitterErrors->setSizes(QList<int>() << 0 << 100); return true; }
void ProFileEditorWidget::contextMenuEvent(QContextMenuEvent *e) { QMenu *menu = new QMenu(); Core::ActionManager *am = Core::ICore::actionManager(); Core::ActionContainer *mcontext = am->actionContainer(Qt4ProjectManager::Constants::M_CONTEXT); QMenu *contextMenu = mcontext->menu(); foreach (QAction *action, contextMenu->actions()) menu->addAction(action); appendStandardContextMenuActions(menu); menu->exec(e->globalPos()); delete menu; }
bool Uncrustify::initialize() { Core::ActionContainer *menu = Core::ActionManager::createMenu(Constants::Uncrustify::MENU_ID); menu->menu()->setTitle(QLatin1String(Constants::Uncrustify::DISPLAY_NAME)); m_formatFile = new QAction(BeautifierPlugin::msgFormatCurrentFile(), this); Core::Command *cmd = Core::ActionManager::registerAction(m_formatFile, Constants::Uncrustify::ACTION_FORMATFILE, Core::Context(Core::Constants::C_GLOBAL)); menu->addAction(cmd); connect(m_formatFile, SIGNAL(triggered()), this, SLOT(formatFile())); Core::ActionManager::actionContainer(Constants::MENU_ID)->addMenu(menu); return true; }
bool ap240Plugin::initialize( const QStringList &arguments, QString *errorString ) { adportable::core::debug_core::instance()->hook( adlog::logging_handler::log ); Q_UNUSED(arguments) Q_UNUSED(errorString) mainWindow_->activateWindow(); mainWindow_->createActions(); //const Core::Context gc( ( Core::Id( Core::Constants::C_GLOBAL ) ) ); const Core::Context context( ( "AP240.MainView" ) ); mode_->setContext( context ); if ( QWidget * widget = mainWindow_->createContents( mode_.get() ) ) mode_->setWidget( widget ); addObject( mode_.get() ); // this may refer from MALPIXAcquire module if ( auto iExtension = document::instance()->iSequence() ) { mainWindow_->editor_factories( *iExtension ); addObject( iExtension ); } if ( auto iExtension = document::instance()->iController() ) { addObject( iExtension ); } QAction *action = new QAction(tr("ap240 action"), this); if ( Core::ActionManager * am = Core::ActionManager::instance() ) { if ( Core::Command * cmd = am->registerAction( action, Constants::ACTION_ID, context ) ) { cmd->setDefaultKeySequence( QKeySequence( tr( "Ctrl+Alt+Meta+A" ) ) ); connect( action, SIGNAL( triggered() ), this, SLOT( triggerAction() ) ); Core::ActionContainer *menu = am->createMenu( Constants::MENU_ID ); menu->menu()->setTitle( tr( "AP240" ) ); menu->addAction( cmd ); am->actionContainer( Core::Constants::M_TOOLS )->addMenu( menu ); } } return true; }
/** * Initialize the main window: * - creates global menus and actions * - connect actions to default slots * Returns \e true if all goes fine. * \sa Core::IMainWindow, Core::MainWindowActions, Core::MainWindowActionHandler */ bool MainWindow::initialize(const QStringList &arguments, QString *errorString) { Q_UNUSED(arguments); Q_UNUSED(errorString); // create menus createFileMenu(); createFileNewSubMenu(); Core::ActionContainer *fmenu = actionManager()->createMenu(Core::Constants::M_FILE_RECENTFILES); fmenu->setOnAllDisabledBehavior(Core::ActionContainer::Show); connect(fmenu->menu(), SIGNAL(aboutToShow()),this, SLOT(aboutToShowRecentFiles())); createEditMenu(); // createFormatMenu(); createConfigurationMenu(); createHelpMenu(); Core::MainWindowActions actions; actions.setFileActions( Core::MainWindowActions::A_FileOpen | Core::MainWindowActions::A_FileSave | Core::MainWindowActions::A_FileSaveAs | Core::MainWindowActions::A_FilePrint | Core::MainWindowActions::A_FilePrintPreview | Core::MainWindowActions::A_FileQuit); actions.setConfigurationActions( Core::MainWindowActions::A_AppPreferences | Core::MainWindowActions::A_LanguageChange //| // Core::MainWindowActions::A_ConfigureMedinTux ); actions.setHelpActions( Core::MainWindowActions::A_AppAbout | Core::MainWindowActions::A_PluginsAbout | Core::MainWindowActions::A_AppHelp | Core::MainWindowActions::A_DebugDialog | Core::MainWindowActions::A_CheckUpdate //| // Core::MainWindowActions::A_QtAbout ); actions.createEditActions(false); createActions(actions); connectFileActions(); connectConfigurationActions(); connectHelpActions(); return true; }
bool CodeAtlasPlugin::initialize(const QStringList& args, QString *errMsg) { Q_UNUSED(args); Q_UNUSED(errMsg); new UIManager; new DBManager; // menu actions Core::ActionContainer* ac = Core::ActionManager::actionContainer(Core::Constants::M_HELP); QAction* getInfoAction = ac->menu()->addAction("Show Code Atlas"); connect(getInfoAction, SIGNAL(triggered()), this, SLOT(getClassInfo())); // communications between db and ui connect(DBManager::instance(), SIGNAL(dbUpdated()), UIManager::instance(), SLOT(updateScene())); return true; }
/*! Initializes the plugin. Returns true on success. Plugins want to register objects with the plugin manager here. \a errorMessage can be used to pass an error message to the plugin system, if there was any. */ bool HelloWorldPlugin::initialize(const QStringList &arguments, QString *errorMessage) { Q_UNUSED(arguments) Q_UNUSED(errorMessage) // Get the primary access point to the workbench. Core::ICore *core = Core::ICore::instance(); // Create a unique context for our own view, that will be used for the // menu entry later. Core::Context context("HelloWorld.MainView"); // Create an action to be triggered by a menu entry QAction *helloWorldAction = new QAction(tr("Say \"&Hello World!\""), this); connect(helloWorldAction, SIGNAL(triggered()), SLOT(sayHelloWorld())); // Register the action with the action manager Core::ActionManager *actionManager = core->actionManager(); Core::Command *command = actionManager->registerAction( helloWorldAction, "HelloWorld.HelloWorldAction", context); // Create our own menu to place in the Tools menu Core::ActionContainer *helloWorldMenu = actionManager->createMenu("HelloWorld.HelloWorldMenu"); QMenu *menu = helloWorldMenu->menu(); menu->setTitle(tr("&Hello World")); menu->setEnabled(true); // Add the Hello World action command to the menu helloWorldMenu->addAction(command); // Request the Tools menu and add the Hello World menu to it Core::ActionContainer *toolsMenu = actionManager->actionContainer(Core::Constants::M_TOOLS); toolsMenu->addMenu(helloWorldMenu); // Add a mode with a push button based on BaseMode. Like the BaseView, // it will unregister itself from the plugin manager when it is deleted. Core::IMode *helloMode = new HelloMode; addAutoReleasedObject(helloMode); return true; }
void MainWindow::createActions() { if ( Core::ActionManager * am = Core::ActionManager::instance() ) { Core::ActionContainer * menu = am->createMenu( Constants::MENU_ID ); // Menu ID menu->menu()->setTitle( tr("Query") ); if ( auto p = new QAction( QIcon( ":/query/images/fileopen.png" ), tr( "Open SQLite file..." ), this ) ) { am->registerAction( p, Constants::FILE_OPEN, Core::Context( Core::Constants::C_GLOBAL ) ); // Tools|Query|Open SQLite file... connect( p, &QAction::triggered, this, &MainWindow::handleOpen ); menu->addAction( am->command( Constants::FILE_OPEN ) ); am->registerAction( p, Core::Constants::OPEN, Core::Context( Constants::C_QUERY_MODE ) ); // File|Open } am->actionContainer( Core::Constants::M_TOOLS )->addMenu( menu ); } }
void DoNothingPlugin::createMenus() { // Fetch the action manager Core::ActionManager* am = Core::ICore::instance()->actionManager(); // Create a DoNothing menu Core::ActionContainer* ac = am->createMenu("DoNothingPlugin.DoNothingMenu"); ac->menu()->setTitle(tr("DoNothing")); // Create a command for "About DoNothing". Core::Command* cmd = am->registerAction(new QAction(this), "DoNothingPlugin.AboutDoNothing", QList<int>() << 0); cmd->action()->setText("About DoNothing"); // Add DoNothing menu to the beginning of the menu bar am->actionContainer(Core::Constants::MENU_BAR)->addMenu(ac); // Add the "About DoNothing" action to the DoNothing menu ac->addAction(cmd); // Connect the action connect(cmd->action(), SIGNAL(triggered(bool)), this, SLOT(about())); // Create a DoNothing2 menu Core::ActionContainer* ac2 = am->createMenu("DoNothingPlugin.DoNothing2Menu"); ac2->menu()->setTitle(tr("DoNothing2")); // Create a command for "About DoNothing 2". Core::Command* cmd2 = am->registerAction(new QAction(this), "DoNothingPlugin.AboutDoNothing2", QList<int>() << 0); cmd2->action()->setText("About DoNothing 2"); // Insert the "DoNothing" menu between "Window" and "Help". QMenu* helpMenu = am->actionContainer(Core::Constants::M_HELP)->menu(); QMenuBar* menuBar = am->actionContainer(Core::Constants::MENU_BAR)->menuBar(); menuBar->insertMenu(helpMenu->menuAction(), ac2->menu()); // Add the "About DoNothing 2" action to the DoNothing2 menu ac2->addAction(cmd2); // Connect the action connect(cmd2->action(), SIGNAL(triggered(bool)), this, SLOT(about())); }
void BazaarPlugin::createMenu() { Core::Context context(Core::Constants::C_GLOBAL); // Create menu item for Bazaar m_bazaarContainer = m_actionManager->createMenu(Core::Id("Bazaar.BazaarMenu")); QMenu *menu = m_bazaarContainer->menu(); menu->setTitle(tr("Bazaar")); createFileActions(context); createSeparator(context, Core::Id("Bazaar.FileDirSeperator")); createDirectoryActions(context); createSeparator(context, Core::Id("Bazaar.DirRepoSeperator")); createRepositoryActions(context); createSeparator(context, Core::Id("Bazaar.Repository Management")); // Request the Tools menu and add the Bazaar menu to it Core::ActionContainer *toolsMenu = m_actionManager->actionContainer(Core::Id(Core::Constants::M_TOOLS)); toolsMenu->addMenu(m_bazaarContainer); m_menuAction = m_bazaarContainer->menu()->menuAction(); }
bool DiffEditorPlugin::initialize(const QStringList &arguments, QString *errorMessage) { Q_UNUSED(arguments) Q_UNUSED(errorMessage) //register actions Core::ActionContainer *toolsContainer = Core::ActionManager::actionContainer(Core::Constants::M_TOOLS); toolsContainer->insertGroup(Core::Constants::G_TOOLS_OPTIONS, Constants::G_TOOLS_DIFF); QAction *diffAction = new QAction(tr("Diff..."), this); Core::Command *diffCommand = Core::ActionManager::registerAction(diffAction, "DiffEditor.Diff"); connect(diffAction, &QAction::triggered, this, &DiffEditorPlugin::diff); toolsContainer->addAction(diffCommand, Constants::G_TOOLS_DIFF); addAutoReleasedObject(new DiffEditorFactory(this)); new DiffEditorManager(this); return true; }
void QtTestPlugin::extensionsInitialized() { ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance(); Core::ICore *core = Core::ICore::instance(); Core::ActionManager *am = core->actionManager(); m_messageOutputWindow = new TestOutputWindow(); pm->addObject(m_messageOutputWindow); m_testResultsWindow = TestResultsWindow::instance(); connect(m_testResultsWindow, SIGNAL(stopTest()), this, SLOT(stopTesting())); connect(m_testResultsWindow, SIGNAL(retryFailedTests(QStringList)), this, SLOT(retryTests(QStringList))); connect(TestExecuter::instance(), SIGNAL(testStarted()), m_testResultsWindow, SLOT(onTestStarted())); connect(TestExecuter::instance(), SIGNAL(testStop()), m_testResultsWindow, SLOT(onTestStopped())); connect(TestExecuter::instance(), SIGNAL(testFinished()), m_testResultsWindow, SLOT(onTestFinished())); pm->addObject(m_testResultsWindow); connect(testResultsPane(), SIGNAL(defectSelected(TestCaseRec)), this, SLOT(onDefectSelected(TestCaseRec))); // Add context menu to CPP editor Core::ActionContainer *mcontext = am->actionContainer(CppEditor::Constants::M_CONTEXT); m_contextMenu->init(mcontext->menu(), 2, this); // Add context menu to JS editor mcontext = am->actionContainer(QmlJSEditor::Constants::M_CONTEXT); m_contextMenu->init(mcontext->menu(), 2, this); // Add a Test menu to the menu bar Core::ActionContainer* ac = am->createMenu("QtTestPlugin.TestMenu"); ac->menu()->setTitle(tr("&Test")); m_contextMenu->init(ac->menu(), 0, 0); // Insert the "Test" menu between "Window" and "Help". QMenu *windowMenu = am->actionContainer(Core::Constants::M_TOOLS)->menu(); QMenuBar *menuBar = am->actionContainer(Core::Constants::MENU_BAR)->menuBar(); menuBar->insertMenu(windowMenu->menuAction(), ac->menu()); ProjectExplorer::ProjectExplorerPlugin *explorer = ProjectExplorer::ProjectExplorerPlugin::instance(); connect(explorer->session(), SIGNAL(startupProjectChanged(ProjectExplorer::Project*)), this, SLOT(onStartupProjectChanged(ProjectExplorer::Project *))); connect(core->progressManager(), SIGNAL(allTasksFinished(QString)), this, SLOT(onAllTasksFinished(QString))); connect(explorer->session(), SIGNAL(aboutToRemoveProject(ProjectExplorer::Project *)), this, SLOT(onProjectRemoved(ProjectExplorer::Project *))); m_contextMenu->init(0, 3, this); }
CMakeManager::CMakeManager(CMakeSettingsPage *cmakeSettingsPage) : m_settingsPage(cmakeSettingsPage) { ProjectExplorer::ProjectExplorerPlugin *projectExplorer = ProjectExplorer::ProjectExplorerPlugin::instance(); connect(projectExplorer, SIGNAL(aboutToShowContextMenu(ProjectExplorer::Project*,ProjectExplorer::Node*)), this, SLOT(updateContextMenu(ProjectExplorer::Project*,ProjectExplorer::Node*))); Core::ActionContainer *mbuild = Core::ActionManager::actionContainer(ProjectExplorer::Constants::M_BUILDPROJECT); Core::ActionContainer *mproject = Core::ActionManager::actionContainer(ProjectExplorer::Constants::M_PROJECTCONTEXT); Core::ActionContainer *msubproject = Core::ActionManager::actionContainer(ProjectExplorer::Constants::M_SUBPROJECTCONTEXT); const Core::Context projectContext(CMakeProjectManager::Constants::PROJECTCONTEXT); m_runCMakeAction = new QAction(QIcon(), tr("Run CMake"), this); Core::Command *command = Core::ActionManager::registerAction(m_runCMakeAction, Constants::RUNCMAKE, projectContext); command->setAttribute(Core::Command::CA_Hide); mbuild->addAction(command, ProjectExplorer::Constants::G_BUILD_DEPLOY); connect(m_runCMakeAction, SIGNAL(triggered()), this, SLOT(runCMake())); m_runCMakeActionContextMenu = new QAction(QIcon(), tr("Run CMake"), this); command = Core::ActionManager::registerAction(m_runCMakeActionContextMenu, Constants::RUNCMAKECONTEXTMENU, projectContext); command->setAttribute(Core::Command::CA_Hide); mproject->addAction(command, ProjectExplorer::Constants::G_PROJECT_BUILD); msubproject->addAction(command, ProjectExplorer::Constants::G_PROJECT_BUILD); connect(m_runCMakeActionContextMenu, SIGNAL(triggered()), this, SLOT(runCMakeContextMenu())); }
bool LocatorPlugin::initialize(const QStringList &, QString *) { m_settingsPage = new SettingsPage(this); addObject(m_settingsPage); m_locatorWidget = new LocatorWidget(this); m_locatorWidget->setEnabled(false); Core::StatusBarWidget *view = new Core::StatusBarWidget; view->setWidget(m_locatorWidget); view->setContext(Core::Context("LocatorWidget")); view->setPosition(Core::StatusBarWidget::First); addAutoReleasedObject(view); QAction *action = new QAction(m_locatorWidget->windowIcon(), m_locatorWidget->windowTitle(), this); Core::Command *cmd = Core::ActionManager::registerAction(action, "QtCreator.Locate", Core::Context(Core::Constants::C_GLOBAL)); cmd->setDefaultKeySequence(QKeySequence(tr("Ctrl+K"))); connect(action, SIGNAL(triggered()), this, SLOT(openLocator())); connect(cmd, SIGNAL(keySequenceChanged()), this, SLOT(updatePlaceholderText())); updatePlaceholderText(cmd); Core::ActionContainer *mtools = Core::ActionManager::actionContainer(Core::Constants::M_TOOLS); mtools->addAction(cmd); addObject(new LocatorManager(m_locatorWidget)); m_openDocumentsFilter = new OpenDocumentsFilter(Core::ICore::editorManager()); addObject(m_openDocumentsFilter); m_fileSystemFilter = new FileSystemFilter(Core::ICore::editorManager(), m_locatorWidget); addObject(m_fileSystemFilter); m_executeFilter = new ExecuteFilter(); addObject(m_executeFilter); addAutoReleasedObject(new LocatorFiltersFilter(this, m_locatorWidget)); return true; }
bool ClangFormat::initialize() { Core::ActionContainer *menu = Core::ActionManager::createMenu(Constants::ClangFormat::MENU_ID); menu->menu()->setTitle(QLatin1String(Constants::ClangFormat::DISPLAY_NAME)); m_formatFile = new QAction(BeautifierPlugin::msgFormatCurrentFile(), this); Core::Command *cmd = Core::ActionManager::registerAction(m_formatFile, Constants::ClangFormat::ACTION_FORMATFILE); menu->addAction(cmd); connect(m_formatFile, &QAction::triggered, this, &ClangFormat::formatFile); m_formatRange = new QAction(BeautifierPlugin::msgFormatSelectedText(), this); cmd = Core::ActionManager::registerAction(m_formatRange, Constants::ClangFormat::ACTION_FORMATSELECTED); menu->addAction(cmd); connect(m_formatRange, &QAction::triggered, this, &ClangFormat::formatSelectedText); Core::ActionManager::actionContainer(Constants::MENU_ID)->addMenu(menu); return true; }
/** \brief Rebuild the patients' history menu */ void PatientActionHandler::aboutToShowRecentPatients() { // update patient history Core::ActionContainer *recentsMenu = actionManager()->actionContainer(Core::Constants::M_PATIENTS_NAVIGATION); if (!recentsMenu) return; if (!recentsMenu->menu()) return; recentsMenu->menu()->clear(); bool hasRecentFiles = false; const QStringList &uuids = m_RecentPatients->recentFiles(); const QHash<QString, QString> &names = patient()->fullPatientName(uuids); for(int i = 0; i < uuids.count(); ++i) { hasRecentFiles = true; QAction *action = recentsMenu->menu()->addAction(tkTr(Trans::Constants::_1_COLON_2).arg(i).arg(names.value(uuids.at(i)))); action->setData(uuids.at(i)); connect(action, SIGNAL(triggered()), this, SLOT(openRecentPatient())); } recentsMenu->menu()->setEnabled(hasRecentFiles); }