bool QtScriptEditorPlugin::initialize(const QStringList & /*arguments*/, QString *error_message)
{
typedef SharedTools::QScriptHighlighter QScriptHighlighter;
Core::ICore *core = ExtensionSystem::PluginManager::instance()->getObject<Core::ICore>();
if (!core->mimeDatabase()->addMimeTypes(QLatin1String(":/qtscripteditor/QtScriptEditor.mimetypes.xml"), error_message))
return false;
m_scriptcontext << core->uniqueIDManager()->uniqueIdentifier(QtScriptEditor::Constants::C_QTSCRIPTEDITOR);
m_context = m_scriptcontext;
m_context << core->uniqueIDManager()->uniqueIdentifier(TextEditor::Constants::C_TEXTEDITOR);
registerActions(core);
m_editor = new QtScriptEditorFactory(core, m_context, this);
addObject(m_editor);
Core::BaseFileWizardParameters wizardParameters(Core::IWizard::FileWizard);
wizardParameters.setDescription(tr("Qt Script file"));
wizardParameters.setName(tr("Qt Script file"));
wizardParameters.setCategory(QLatin1String("Qt"));
wizardParameters.setTrCategory(tr("Qt"));
m_wizard = new TextEditor::TextFileWizard(QLatin1String(QtScriptEditor::Constants::C_QTSCRIPTEDITOR_MIMETYPE),
QLatin1String(QtScriptEditor::Constants::C_QTSCRIPTEDITOR),
QLatin1String("qtscript$"),
wizardParameters, core, this);
addObject(m_wizard);
error_message->clear();
return true;
}
bool ResourceEditorPlugin::initialize(const QStringList &arguments, QString *errorMessage)
{
Q_UNUSED(arguments)
Core::ICore *core = Core::ICore::instance();
if (!core->mimeDatabase()->addMimeTypes(QLatin1String(":/resourceeditor/ResourceEditor.mimetypes.xml"), errorMessage))
return false;
m_editor = new ResourceEditorFactory(this);
addObject(m_editor);
Core::BaseFileWizardParameters wizardParameters(Core::IWizard::FileWizard);
wizardParameters.setDescription(tr("Creates a Qt Resource file (.qrc)."));
wizardParameters.setName(tr("Qt Resource file"));
wizardParameters.setCategory(QLatin1String("Qt"));
wizardParameters.setTrCategory(tr("Qt"));
m_wizard = new ResourceWizard(wizardParameters, this);
addObject(m_wizard);
errorMessage->clear();
// Register undo and redo
Core::ActionManager * const actionManager = core->actionManager();
int const pluginId = core->uniqueIDManager()->uniqueIdentifier(
Constants::C_RESOURCEEDITOR);
const QList<int> idList = QList<int>() << pluginId;
m_undoAction = new QAction(tr("&Undo"), this);
m_redoAction = new QAction(tr("&Redo"), this);
actionManager->registerAction(m_undoAction, Core::Constants::UNDO, idList);
actionManager->registerAction(m_redoAction, Core::Constants::REDO, idList);
connect(m_undoAction, SIGNAL(triggered()), this, SLOT(onUndo()));
connect(m_redoAction, SIGNAL(triggered()), this, SLOT(onRedo()));
return true;
}
/*! Initializes the plugin. Returns true on success.
Plugins want to register objects with the plugin manager here.
\a error_message can be used to pass an error message to the plugin system,
if there was any.
*/
bool HelloWorldPlugin::initialize(const QStringList &arguments, QString *error_message)
{
Q_UNUSED(arguments)
Q_UNUSED(error_message)
// Get the primary access point to the workbench.
Core::ICore *core = ExtensionSystem::PluginManager::instance()->getObject<Core::ICore>();
// Create a unique context id for our own view, that will be used for the
// menu entry later.
QList<int> context = QList<int>()
<< core->uniqueIDManager()->uniqueIdentifier(
QLatin1String("HelloWorld.MainView"));
// Create an action to be triggered by a menu entry
QAction *helloWorldAction = new QAction("Say \"&Hello World!\"", this);
connect(helloWorldAction, SIGNAL(triggered()), SLOT(sayHelloWorld()));
// Register the action with the action manager
Core::ActionManagerInterface *actionManager = core->actionManager();
Core::ICommand *command =
actionManager->registerAction(
helloWorldAction, "HelloWorld.HelloWorldAction", context);
// Create our own menu to place in the Tools menu
Core::IActionContainer *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::IActionContainer *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::BaseMode *baseMode = new Core::BaseMode;
baseMode->setUniqueModeName("HelloWorld.HelloWorldMode");
baseMode->setName(tr("Hello world!"));
baseMode->setIcon(QIcon());
baseMode->setPriority(0);
baseMode->setWidget(new QPushButton(tr("Hello World PushButton!")));
addAutoReleasedObject(baseMode);
// Add the Hello World action command to the mode manager (with 0 priority)
Core::ModeManager *modeManager = core->modeManager();
modeManager->addAction(command, 0);
return true;
}
OutputWindow::OutputWindow(QWidget *parent)
: QPlainTextEdit(parent)
, m_enforceNewline(false)
, m_scrollToBottom(false)
{
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
//setCenterOnScroll(false);
setWindowTitle(tr("Application Output Window"));
setWindowIcon(QIcon(":/qt4projectmanager/images/window.png"));
setFrameShape(QFrame::NoFrame);
setMouseTracking(true);
static uint usedIds = 0;
Core::ICore *core = Core::ICore::instance();
QList<int> context;
context << core->uniqueIDManager()->uniqueIdentifier(QString(Constants::C_APP_OUTPUT) + QString().setNum(usedIds++));
m_outputWindowContext = new Core::BaseContext(this, context);
core->addContextObject(m_outputWindowContext);
QAction *undoAction = new QAction(this);
QAction *redoAction = new QAction(this);
QAction *cutAction = new QAction(this);
QAction *copyAction = new QAction(this);
QAction *pasteAction = new QAction(this);
QAction *selectAllAction = new QAction(this);
Core::ActionManager *am = core->actionManager();
am->registerAction(undoAction, Core::Constants::UNDO, context);
am->registerAction(redoAction, Core::Constants::REDO, context);
am->registerAction(cutAction, Core::Constants::CUT, context);
am->registerAction(copyAction, Core::Constants::COPY, context);
am->registerAction(pasteAction, Core::Constants::PASTE, context);
am->registerAction(selectAllAction, Core::Constants::SELECTALL, context);
connect(undoAction, SIGNAL(triggered()), this, SLOT(undo()));
connect(redoAction, SIGNAL(triggered()), this, SLOT(redo()));
connect(cutAction, SIGNAL(triggered()), this, SLOT(cut()));
connect(copyAction, SIGNAL(triggered()), this, SLOT(copy()));
connect(pasteAction, SIGNAL(triggered()), this, SLOT(paste()));
connect(selectAllAction, SIGNAL(triggered()), this, SLOT(selectAll()));
connect(this, SIGNAL(undoAvailable(bool)), undoAction, SLOT(setEnabled(bool)));
connect(this, SIGNAL(redoAvailable(bool)), redoAction, SLOT(setEnabled(bool)));
connect(this, SIGNAL(copyAvailable(bool)), cutAction, SLOT(setEnabled(bool))); // OutputWindow never read-only
connect(this, SIGNAL(copyAvailable(bool)), copyAction, SLOT(setEnabled(bool)));
undoAction->setEnabled(false);
redoAction->setEnabled(false);
cutAction->setEnabled(false);
copyAction->setEnabled(false);
}
////////////////////////////////////////////////////
//
// INHERITED FROM ExtensionSystem::Plugin
//
////////////////////////////////////////////////////
bool FormEditorPlugin::initialize(const QStringList &arguments, QString *error)
{
Q_UNUSED(arguments)
Q_UNUSED(error)
Core::ICore *core = Core::ICore::instance();
if (!core->mimeDatabase()->addMimeTypes(QLatin1String(":/formeditor/Designer.mimetypes.xml"), error))
return false;
initializeTemplates();
const int uid = core->uniqueIDManager()->uniqueIdentifier(QLatin1String(C_FORMEDITOR));
const QList<int> context = QList<int>() << uid;
addAutoReleasedObject(new FormEditorFactory);
// Ensure that loading designer translations is done before FormEditorW is instantiated
const QString locale = qApp->property("qtc_locale").toString();
if (!locale.isEmpty()) {
QTranslator *qtr = new QTranslator(this);
const QString &creatorTrPath =
Core::ICore::instance()->resourcePath() + QLatin1String("/translations");
const QString &qtTrPath = QLibraryInfo::location(QLibraryInfo::TranslationsPath);
const QString &trFile = QLatin1String("designer_") + locale;
if (qtr->load(trFile, qtTrPath) || qtr->load(trFile, creatorTrPath))
qApp->installTranslator(qtr);
}
if (qgetenv("KDE_SESSION_VERSION") == QByteArray("4")) {
// KDE 4, possibly dangerous...
// KDE 4.2.0 had a nasty bug, which resulted in the File/Open Dialog crashing
// so check for that an fully load the plugins
QProcess proc;
proc.start(QLatin1String("kde4-config"), QStringList(QLatin1String("--version")));
proc.waitForFinished();
const QByteArray output = proc.readAll();
if (output.contains("KDE: 4.2.0"))
FormEditorW::ensureInitStage(FormEditorW::FullyInitialized);
} else {
FormEditorW::ensureInitStage(FormEditorW::RegisterPlugins);
}
error->clear();
return true;
}
bool QuickOpenPlugin::initialize(const QStringList &, QString *)
{
Core::ICore *core = ExtensionSystem::PluginManager::instance()->getObject<Core::ICore>();
m_settingsPage = new SettingsPage(core, this);
addObject(m_settingsPage);
m_quickOpenToolWindow = new QuickOpenToolWindow(this);
m_quickOpenToolWindow->setEnabled(false);
Core::BaseView *view = new Core::BaseView("QuickOpen.ToolWindow",
m_quickOpenToolWindow,
QList<int>() << core->uniqueIDManager()->uniqueIdentifier(QLatin1String("QuickOpenToolWindow")),
Core::IView::First);
addAutoReleasedObject(view);
const QString actionId = QLatin1String("QtCreator.View.QuickOpen.ToolWindow");
QAction *action = new QAction(m_quickOpenToolWindow->windowIcon(), m_quickOpenToolWindow->windowTitle(), this);
Core::ICommand *cmd = core->actionManager()->registerAction(action, actionId, QList<int>() << Core::Constants::C_GLOBAL_ID);
cmd->setDefaultKeySequence(QKeySequence("Ctrl+K"));
connect(action, SIGNAL(triggered()), this, SLOT(openQuickOpen()));
Core::IActionContainer *mtools = core->actionManager()->actionContainer(Core::Constants::M_TOOLS);
mtools->addAction(cmd);
addObject(new QuickOpenManager(m_quickOpenToolWindow));
m_openDocumentsFilter = new OpenDocumentsFilter(core->editorManager());
addObject(m_openDocumentsFilter);
m_fileSystemFilter = new FileSystemFilter(core->editorManager(), m_quickOpenToolWindow);
addObject(m_fileSystemFilter);
addAutoReleasedObject(new QuickOpenFiltersFilter(this, m_quickOpenToolWindow));
connect(core, SIGNAL(coreOpened()), this, SLOT(startSettingsLoad()));
return true;
}
bool QmlJSEditorPlugin::initialize(const QStringList & /*arguments*/, QString *error_message)
{
Core::ICore *core = Core::ICore::instance();
if (!core->mimeDatabase()->addMimeTypes(QLatin1String(":/qmljseditor/QmlJSEditor.mimetypes.xml"), error_message))
return false;
m_modelManager = new ModelManager(this);
addAutoReleasedObject(m_modelManager);
QList<int> context;
context << core->uniqueIDManager()->uniqueIdentifier(QmlJSEditor::Constants::C_QMLJSEDITOR_ID);
m_editor = new QmlJSEditorFactory(this);
addObject(m_editor);
Core::BaseFileWizardParameters wizardParameters(Core::IWizard::FileWizard);
wizardParameters.setCategory(QLatin1String(Core::Constants::WIZARD_CATEGORY_QT));
wizardParameters.setDisplayCategory(QCoreApplication::translate("Core", Core::Constants::WIZARD_TR_CATEGORY_QT));
wizardParameters.setDescription(tr("Creates a Qt QML file."));
wizardParameters.setDisplayName(tr("Qt QML File"));
wizardParameters.setId(QLatin1String("Q.Qml"));
addAutoReleasedObject(new QmlFileWizard(wizardParameters, core));
m_actionHandler = new TextEditor::TextEditorActionHandler(QmlJSEditor::Constants::C_QMLJSEDITOR_ID,
TextEditor::TextEditorActionHandler::Format
| TextEditor::TextEditorActionHandler::UnCommentSelection
| TextEditor::TextEditorActionHandler::UnCollapseAll);
m_actionHandler->initializeActions();
Core::ActionManager *am = core->actionManager();
Core::ActionContainer *contextMenu = am->createMenu(QmlJSEditor::Constants::M_CONTEXT);
Core::Command *cmd;
QAction *followSymbolUnderCursorAction = new QAction(tr("Follow Symbol Under Cursor"), this);
cmd = am->registerAction(followSymbolUnderCursorAction, Constants::FOLLOW_SYMBOL_UNDER_CURSOR, context);
cmd->setDefaultKeySequence(QKeySequence(Qt::Key_F2));
connect(followSymbolUnderCursorAction, SIGNAL(triggered()), this, SLOT(followSymbolUnderCursor()));
contextMenu->addAction(cmd);
cmd = am->command(TextEditor::Constants::AUTO_INDENT_SELECTION);
contextMenu->addAction(cmd);
cmd = am->command(TextEditor::Constants::UN_COMMENT_SELECTION);
contextMenu->addAction(cmd);
CodeCompletion *completion = new CodeCompletion(m_modelManager);
addAutoReleasedObject(completion);
addAutoReleasedObject(new HoverHandler);
// Set completion settings and keep them up to date
TextEditor::TextEditorSettings *textEditorSettings = TextEditor::TextEditorSettings::instance();
completion->setCompletionSettings(textEditorSettings->completionSettings());
connect(textEditorSettings, SIGNAL(completionSettingsChanged(TextEditor::CompletionSettings)),
completion, SLOT(setCompletionSettings(TextEditor::CompletionSettings)));
error_message->clear();
Core::FileIconProvider *iconProvider = Core::FileIconProvider::instance();
iconProvider->registerIconOverlayForSuffix(QIcon(":/qmljseditor/images/qmlfile.png"), "qml");
return true;
}
TaskWindowContext::TaskWindowContext(QWidget *widget)
: m_taskList(widget)
{
Core::ICore *core = ExtensionSystem::PluginManager::instance()->getObject<Core::ICore>();
m_context << core->uniqueIDManager()->uniqueIdentifier(Core::Constants::C_PROBLEM_PANE);
}
bool
ServantPlugin::initialize(const QStringList &arguments, QString *error_message)
{
Q_UNUSED(arguments);
int nErrors = 0;
do { adportable::debug(__FILE__, __LINE__) << "<----- ServantPlugin::initialize() ..."; } while(0);
OutputWindow * outputWindow = new OutputWindow;
addAutoReleasedObject( outputWindow );
pImpl_ = new internal::ServantPluginImpl( outputWindow );
///////////////////////////////////
Core::ICore * core = Core::ICore::instance();
QList<int> context;
if ( core ) {
Core::UniqueIDManager * uidm = core->uniqueIDManager();
if ( uidm ) {
context.append( uidm->uniqueIdentifier( QLatin1String("Servant.MainView") ) );
context.append( uidm->uniqueIdentifier( Core::Constants::C_NAVIGATION_PANE ) );
}
} else
return false;
// ACE initialize
// acewrapper::instance_manager::initialize();
// <------
boost::filesystem::path plugindir;
do {
std::wstring apppath = qtwrapper::application::path( L".." ); // := "~/qtplatz/bin/.."
std::wstring configFile = adplugin::loader::config_fullpath( apppath, L"/MS-Cheminformatics/does-not-exist.adplugin" );
plugindir = boost::filesystem::path( configFile ).branch_path();
} while(0);
// populate .adplugin files under given folder.
adplugin::loader::populate( plugindir.generic_wstring().c_str() );
std::vector< adplugin::plugin_ptr > spectrometers;
if ( adplugin::loader::select_iids( ".*\\.adplugins\\.massSpectrometer\\..*", spectrometers ) ) {
std::for_each( spectrometers.begin(), spectrometers.end(), []( const adplugin::plugin_ptr& d ){
adcontrols::massspectrometer_factory * factory = d->query_interface< adcontrols::massspectrometer_factory >();
if ( factory )
adcontrols::massSpectrometerBroker::register_factory( factory, factory->name() );
});
}
// ------------ Broker::Manager initialize first --------------------
adorbmgr::orbmgr * pMgr = adorbmgr::orbmgr::instance();
if ( pMgr ) {
pMgr->init( 0, 0 );
pMgr->spawn();
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
Broker::Manager_var bmgr;
adplugin::plugin_ptr adbroker = adplugin::loader::select_iid( ".*\\.orbfactory\\.adbroker" );
if ( adbroker ) {
internal::orbServantCreator broker_creator;
adplugin::orbServant * adBroker = broker_creator( adbroker, orbServants_ );
if ( adBroker ) {
bmgr = Broker::Manager::_narrow( broker_creator.obj );
if ( CORBA::is_nil( bmgr ) ) {
*error_message = "Broker::Manager cannot be created";
return false;
}
} else {
*error_message = broker_creator.errmsg.str().empty() ?
"adplugin for Broker::Manager did not loaded." : broker_creator.errmsg.str().c_str();
return false;
}
adorbmgr::orbmgr::instance()->setBrokerManager( bmgr );
size_t nTrial = 3;
while ( nTrial-- ) {
try {
bmgr->register_ior( adBroker->object_name(), broker_creator.ior.c_str() );
} catch ( CORBA::Exception& ex ) {
if ( /* ex.get_id() == CORBA::TRANSIENT && */ nTrial )
std::this_thread::sleep_for( std::chrono::milliseconds(10) );
else {
*error_message = QString( "CORBA::Exception : " ) + ex._info().c_str();
return false;
}
}
}
}
pImpl_->init_debug_adbroker( bmgr );
// ----------------------- initialize corba servants ------------------------------
std::vector< adplugin::plugin_ptr > factories;
adplugin::loader::select_iids( ".*\\.adplugins\\.orbfactory\\..*", factories );
for ( const adplugin::plugin_ptr& ptr: factories ) {
if ( ptr->iid() == adbroker->iid() )
continue;
internal::orbServantCreator creator;
adplugin::orbServant * servant = creator( ptr, orbServants_ );
if ( servant ) {
BrokerClient::Accessor_var accessor = BrokerClient::Accessor::_narrow( creator.obj );
if ( !CORBA::is_nil( accessor ) ) {
accessor->setBrokerManager( bmgr.in() );
accessor->adpluginspec( ptr->clsid(), ptr->adpluginspec() );
}
try {
bmgr->register_ior( servant->object_name(), creator.ior.c_str() );
bmgr->register_object( servant->object_name(), creator.obj );
} catch ( CORBA::Exception& ex ) {
*error_message = ex._info().c_str();
return false;
}
}
}
using namespace acewrapper::constants;
ControlServer::Manager_var cmgr ( internal::findObject< ControlServer::Manager >::find( bmgr.in(), adcontroller::manager::_name() ) );
if ( ! CORBA::is_nil( cmgr ) ) {
ControlServer::Session_var session = cmgr->getSession( L"debug" );
if ( ! CORBA::is_nil( session ) )
pImpl_->init_debug_adcontroller( session );
}
//
ControlServer::Session_var session;
std::vector< Instrument::Session_var > i8t_sessions;
do { adportable::debug(__FILE__, __LINE__) << "<-- ServantPlugin::initialize() ### 3 ##"; } while(0);
if ( ! CORBA::is_nil( session ) )
session->configComplete();
Logger log;
log( ( nErrors ? L"Servant iitialized with errors" : L"Servernt initialized successfully") );
do { adportable::debug() << "----> ServantPlugin::initialize() completed."; } while(0);
return true;
}