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);
}
