void PluginManager::loadPlugins()
{
KService::List offers = KServiceTypeTrader::self()->query(QLatin1String("KTpAccountsKCM/AccountUiPlugin"));
KService::List::const_iterator iter;
for (iter = offers.constBegin(); iter < offers.constEnd(); ++iter) {
QString error;
KService::Ptr service = *iter;
KPluginFactory *factory = KPluginLoader(service->library()).factory();
if (!factory) {
qWarning() << "KPluginFactory could not load the plugin:" << service->library();
continue;
}
AbstractAccountUiPlugin *plugin = factory->create<AbstractAccountUiPlugin>(this);
if (plugin) {
qDebug() << "Loaded plugin:" << service->name();
m_plugins.append(plugin);
} else {
qDebug() << error;
}
}
}
void SyncTaskListItem::clickedMenu(int item)
{
KTrader::OfferList::Iterator it;
if (offers.begin() != offers.end()) {
for (it = offers.begin(); it != offers.end(); ++it) {
KService::Ptr service = *it;
kdDebug(2120) << i18n("Select Name:") << " "
<< service->name() + "; " << i18n("Library:") << " " <<
service->library() << endl;
if (service->name() == itemMenu.text(item)) {
if (preferedOffer != service->name() ||
preferedLibrary != service->library()) {
preferedOfferTemp = service->name();
preferedLibraryTemp = service->library();
itemMenu.setItemChecked(item, true);
}
} else {
itemMenu.setItemChecked(item, false);
}
}
}
createSyncPlugin(QCheckListItem::isOn());
emit serviceChanged();
}
PluginData PluginLoader::instantiatePluginForDevice(const QString& name, Device* device) const
{
PluginData ret;
KService::Ptr service = plugins[name];
if (!service) {
kDebug(kdeconnect_kded()) << "Plugin unknown" << name;
return ret;
}
KPluginFactory *factory = KPluginLoader(service->library()).factory();
if (!factory) {
kDebug(kdeconnect_kded()) << "KPluginFactory could not load the plugin:" << service->library();
return ret;
}
ret.interfaces = service->property("X-KdeConnect-SupportedPackageType", QVariant::StringList).toStringList();
QVariant deviceVariant = QVariant::fromValue<Device*>(device);
//FIXME any reason to use QObject in template param instead KdeConnectPlugin?
ret.plugin = factory->create<KdeConnectPlugin>(device, QVariantList() << deviceVariant);
if (!ret.plugin) {
kDebug(kdeconnect_kded()) << "Error loading plugin";
return ret;
}
kDebug(kdeconnect_kded()) << "Loaded plugin:" << service->name();
return ret;
}
KexiMigrate* MigrateManagerInternal::driver(const QString& name)
{
if (!lookupDrivers())
return 0;
clearError();
KexiDBDbg << "loading" << name;
KexiMigrate *drv = name.isEmpty() ? 0 : m_drivers.value(name.toLatin1().toLower());
if (drv)
return drv; //cached
if (!m_services_lcase.contains(name.toLower())) {
setError(ERR_DRIVERMANAGER,
i18n("Could not find import/export database driver \"%1\".", name));
return 0;
}
KService::Ptr ptr = *(m_services_lcase.find(name.toLower()));
QString srv_name = ptr->property("X-Kexi-MigrationDriverName").toString();
KexiDBDbg << "library:" << ptr->library();
KPluginLoader loader(ptr->library());
const uint foundMajor = (loader.pluginVersion() >> 16) & 0xff;
const uint foundMinor = (loader.pluginVersion() >> 8) & 0xff;
if (!KexiMigration::version().matches(foundMajor, foundMinor)) {
setError(ERR_INCOMPAT_DRIVER_VERSION,
i18n(
"Incompatible migration driver's \"%1\" version: found version %2, expected version %3.",
name,
QString("%1.%2").arg(foundMajor).arg(foundMinor),
QString("%1.%2").arg(KexiMigration::version().major).arg(KexiMigration::version().minor))
);
return 0;
}
KPluginFactory *factory = loader.factory();
if (factory)
drv = factory->create<KexiMigrate>(this);
if (!drv) {
setError(ERR_DRIVERMANAGER,
i18n("Could not load import/export database driver \"%1\".", name));
return 0;
}
KexiDBDbg << "loading succeeded:" << name;
KexiDBDbg << "drv=" << (long)drv;
drv->setObjectName(srv_name);
m_drivers.insert(name.toLatin1().toLower(), drv); //cache it
return drv;
}
KTextEditor::Editor *EditorChooser::createEditor(QWidget *parentWidget, QObject *parent, const char *widgetName, const char *name,
const QString &postfix, bool fallBackToKatePart)
{
KTextEditor::Editor *tmpEd = 0;
KConfig *cfg = kapp->config();
QString previousGroup = cfg->group();
cfg->setGroup("KTEXTEDITOR:" + postfix);
QString editor = cfg->readPathEntry("editor");
cfg->setGroup(previousGroup);
if(editor.isEmpty())
{
KConfig *config = new KConfig("default_components");
config->setGroup("KTextEditor");
editor = config->readPathEntry("embeddedEditor", "katepart");
delete config;
}
KService::Ptr serv = KService::serviceByDesktopName(editor);
if(serv)
{
tmpEd = KTextEditor::createEditor(serv->library().latin1(), parentWidget, widgetName, parent, name);
if(tmpEd)
return tmpEd;
}
if(fallBackToKatePart)
return KTextEditor::createEditor("libkatepart", parentWidget, widgetName, parent, name);
return 0;
}
KParts::Factory* IPartController::findPartFactory ( const QString& mimetype, const QString& parttype, const QString& preferredName )
{
// parttype may be a interface type not derived from KParts/ReadOnlyPart
const KService::List offers = KMimeTypeTrader::self()->query( mimetype,
QString::fromLatin1( "KParts/ReadOnlyPart" ),
QString::fromLatin1( "'%1' in ServiceTypes" ).arg( parttype ) );
if ( ! offers.isEmpty() )
{
KService::Ptr ptr;
// if there is a preferred plugin we'll take it
if ( !preferredName.isEmpty() )
{
KService::List::ConstIterator it;
for ( it = offers.constBegin(); it != offers.constEnd(); ++it )
{
if ( ( *it ) ->desktopEntryName() == preferredName )
{
ptr = ( *it );
break;
}
}
}
// else we just take the first in the list
if ( !ptr )
{
ptr = offers.first();
}
KPluginLoader loader( QFile::encodeName( ptr->library() ) );
return static_cast<KParts::Factory*>( loader.factory() );
}
return 0;
}
void SettingsBase::initApplication()
{
// Prepare the menu of all modules
categories = KServiceTypeTrader::self()->query("SystemSettingsCategory");
modules = KServiceTypeTrader::self()->query("KCModule", "[X-KDE-System-Settings-Parent-Category] != ''");
modules += KServiceTypeTrader::self()->query("SystemSettingsExternalApp");
rootModule = new MenuItem( true, 0 );
initMenuList(rootModule);
// Handle lost+found modules...
if (lostFound) {
for (int i = 0; i < modules.size(); ++i) {
const KService::Ptr entry = modules.at(i);
MenuItem * infoItem = new MenuItem(false, lostFound);
infoItem->setService( entry );
qDebug() << "Added " << entry->name();
}
}
// Prepare the Base Data
BaseData::instance()->setMenuItem( rootModule );
// Load all possible views
const KService::List pluginObjects = KServiceTypeTrader::self()->query( "SystemSettingsView" );
const int nbPlugins = pluginObjects.count();
for( int pluginsDone = 0; pluginsDone < nbPlugins ; ++pluginsDone ) {
KService::Ptr activeService = pluginObjects.at( pluginsDone );
QString error;
BaseMode * controller = activeService->createInstance<BaseMode>(this, QVariantList(), &error);
if( error.isEmpty() ) {
possibleViews.insert( activeService->library(), controller );
controller->init( activeService );
connect(controller, SIGNAL(changeToolBarItems(BaseMode::ToolBarItems)), this, SLOT(changeToolBar(BaseMode::ToolBarItems)));
connect(controller, SIGNAL(actionsChanged()), this, SLOT(updateViewActions()));
connect(searchText, SIGNAL(textChanged(QString)), controller, SLOT(searchChanged(QString)));
connect(controller, SIGNAL(viewChanged(bool)), this, SLOT(viewChange(bool)));
} else {
void AdminDatabase::queryButtonClicked()
{
if ( ! m_listView->currentItem() )
return;
QVBox *widget = new QVBox(this);
KTrader::OfferList offers = KTrader::self()->query("text/plain", "'KParts/ReadOnlyPart' in ServiceTypes");
KLibFactory *factory = 0;
KTrader::OfferList::Iterator it(offers.begin());
for( ; it != offers.end(); ++it)
{
KService::Ptr ptr = (*it);
factory = KLibLoader::self()->factory( ptr->library() );
if (factory)
{
m_part = static_cast<KParts::ReadOnlyPart *>(factory->create(widget, ptr->name(), "KParts::ReadOnlyPart"));
m_part->openURL("file://"+m_dumpDir->absPath()+"/"+m_listView->getText(0)+".sql");
break;
}
}
if (!factory)
{
KMessageBox::error(this, i18n("Could not find a suitable component"));
return;
}
emit sendWidget(widget,i18n("View dump"));
}
void
PluginManager::showAbout( const QString &constraint )
{
KTrader::OfferList offers = query( constraint );
if ( offers.isEmpty() )
return;
KService::Ptr s = offers.front();
const QString body = "<tr><td>%1</td><td>%2</td></tr>";
QString str = "<html><body><table width=\"100%\" border=\"1\">";
str += body.arg( i18n( "Name" ), s->name() );
str += body.arg( i18n( "Library" ), s->library() );
str += body.arg( i18n( "Authors" ), s->property( "X-KDE-amaroK-authors" ).toStringList().join( "\n" ) );
str += body.arg( i18n( "Email" ), s->property( "X-KDE-amaroK-email" ).toStringList().join( "\n" ) );
str += body.arg( i18n( "Version" ), s->property( "X-KDE-amaroK-version" ).toString() );
str += body.arg( i18n( "Framework Version" ), s->property( "X-KDE-amaroK-framework-version" ).toString() );
str += "</table></body></html>";
KMessageBox::information( 0, str, i18n( "Plugin Information" ) );
}
MainWindow::MainWindow(KTextEditor::Document* doc)
: document(0),
view(0)
{
if(!doc) {
KTextEditor::Editor* editor = NULL;
KService::Ptr serv = KService::serviceByDesktopName("yzispart");
if(!serv) {
KMessageBox::error(this, "Could not find yzispart!");
kapp->exit(-1);
} else {
editor = KTextEditor::editor(serv->library().toLatin1());
if(!editor) {
KMessageBox::error(this, "Could not create yziskpart editor component");
kapp->exit(-1);
}
}
document = editor->createDocument(0);
} else {
document = doc;
}
view = qobject_cast< KTextEditor::View* >(document->createView(this));
setCentralWidget(view);
guiFactory()->addClient(view);
show();
}
PluginLoader::PluginLoader()
{
KService::List offers = KServiceTypeTrader::self()->query("KdeConnect/Plugin");
for(KService::List::const_iterator iter = offers.constBegin(); iter != offers.constEnd(); ++iter) {
KService::Ptr service = *iter;
plugins[service->library()] = service;
}
}
ksimoptsView::ksimoptsView(QWidget *parent)
: QWidget(parent),
DCOPObject("ksimoptsIface")
{
// setup our layout manager to automatically add our widgets
QHBoxLayout *top_layout = new QHBoxLayout(this);
top_layout->setAutoAdd(true);
// we want to look for all components that satisfy our needs. the
// trader will actually search through *all* registered KDE
// applications and components -- not just KParts. So we have to
// specify two things: a service type and a constraint
//
// the service type is like a mime type. we say that we want all
// applications and components that can handle HTML -- 'text/html'
//
// however, by itself, this will return such things as Netscape..
// not what we wanted. so we constrain it by saying that the
// string 'KParts/ReadOnlyPart' must be found in the ServiceTypes
// field. with this, only components of the type we want will be
// returned.
KTrader::OfferList offers = KTrader::self()->query("text/html", "'KParts/ReadWritePart' in ServiceTypes");
KLibFactory *factory = 0;
// in theory, we only care about the first one.. but let's try all
// offers just in case the first can't be loaded for some reason
KTrader::OfferList::Iterator it(offers.begin());
for( ; it != offers.end(); ++it)
{
KService::Ptr ptr = (*it);
// we now know that our offer can handle HTML and is a part.
// since it is a part, it must also have a library... let's try to
// load that now
factory = KLibLoader::self()->factory( ptr->library() );
if (factory)
{
m_html = static_cast<KParts::ReadWritePart *>(factory->create(this, ptr->name(), "KParts::ReadWritePart"));
break;
}
}
// if our factory is invalid, then we never found our component
// and we might as well just exit now
if (!factory)
{
KMessageBox::error(this, i18n("Could not find a suitable HTML component"));
return;
}
connect(m_html, SIGNAL(setWindowCaption(const QString&)),
this, SLOT(slotSetTitle(const QString&)));
connect(m_html, SIGNAL(setStatusBarText(const QString&)),
this, SLOT(slotOnURL(const QString&)));
}
RecordItNowPlugin *RecordItNowPluginManager::loadPlugin(const QString &name)
{
QHashIterator<KPluginInfo, RecordItNowPlugin*> it(m_plugins);
KPluginInfo info;
while (it.hasNext()) {
it.next();
if (it.key().name().toLower() == name.toLower()) {
if (it.value()) { // already loaded?
return it.value();
} else { // get info and load
info = it.key();
break;
}
}
}
if (!info.isValid()) {
return 0;
}
kDebug() << "load plugin:" << name;
KService::Ptr service = info.service();
KPluginLoader loader(service->library());
KPluginFactory *factory = loader.factory();
if (!factory) {
kWarning() << "KPluginFactory could not load the plugin:" << service->library() <<
"Reason:" << loader.errorString();
return 0;
}
RecordItNowPlugin *plugin = factory->create<RecordItNowPlugin>(this);
delete factory;
if (!plugin) {
kWarning() << "factory::create<>() failed " << service->library();
return 0;
}
return (m_plugins[info] = plugin);
}
void MessageProcessor::Private::loadFilter(const KPluginInfo &pluginInfo)
{
KService::Ptr service = pluginInfo.service();
KPluginFactory *factory = KPluginLoader(service->library()).factory();
if (factory) {
qCDebug(KTP_COMMONINTERNALS) << "loaded factory :" << factory;
AbstractMessageFilter *filter = factory->create<AbstractMessageFilter>(q);
if (filter) {
qCDebug(KTP_COMMONINTERNALS) << "loaded message filter : " << filter;
filters << FilterPlugin(pluginInfo, filter);
}
} else {
qCWarning(KTP_COMMONINTERNALS) << "error loading plugin :" << service->library();
}
// Re-sort filters by weight
qSort(filters);
}
void PluginManager::loadPlugins()
{
DEBUG_FUNC_NAME
KConfigGroup group = KGlobal::config()->group( "Plugins" );
KService::List offers = KServiceTypeTrader::self()->query(
QString::fromLatin1( "GluonCreator/Plugin" ),
QString( "[X-KDE-GluonCreatorPluginVersion] == %1" ).arg( GLUONCREATOR_PLUGIN_VERSION ) );
KService::List::const_iterator iter;
for( iter = offers.begin(); iter < offers.end(); ++iter )
{
QString error;
KService::Ptr service = *iter;
QString serviceName = service->desktopEntryName();
bool loadPlugin = group.readEntry<bool>( QString( "%1Enabled" ).arg( serviceName ), true );
if( !d->loadedPlugins.contains( serviceName ) && loadPlugin )
{
KPluginFactory* factory = KPluginLoader( service->library() ).factory();
if( !factory )
{
DEBUG_TEXT( QString( "KPluginFactory could not load the plugin: %1" ).arg( service->library() ) );
continue;
}
Plugin* plugin = factory->create<Plugin>( this );
if( plugin )
{
DEBUG_TEXT( QString( "Load plugin: %1" ).arg( service->name() ) );
plugin->load( d->mainWindow );
d->loadedPlugins.insert( serviceName, plugin );
}
else
{
DEBUG_TEXT( error );
}
}
else if( !loadPlugin && d->loadedPlugins.contains( serviceName ) )
{
Plugin* plugin = d->loadedPlugins.value( serviceName );
plugin->unload( d->mainWindow );
delete plugin;
d->loadedPlugins.remove( serviceName );
}
}
}
static KonqViewFactory tryLoadingService(KService::Ptr service)
{
KPluginLoader pluginLoader(*service);
pluginLoader.setLoadHints(QLibrary::ExportExternalSymbolsHint); // #110947
KPluginFactory* factory = pluginLoader.factory();
if (!factory) {
KMessageBox::error(0,
i18n("There was an error loading the module %1.\nThe diagnostics is:\n%2",
service->name(), pluginLoader.errorString()));
return KonqViewFactory();
}
else {
return KonqViewFactory(service->library(), factory);
}
}
DVBevents::~DVBevents()
{
int i;
isRunning = false;
if ( !wait(2000) ) {
terminate();
wait();
}
for ( i=0; i<(int)plugs.count(); ++i ) {
plugs.at(i)->stop();
KService::Ptr service = KService::serviceByDesktopName( plugNames[i] );
KLibLoader::self()->unloadLibrary( service->library().ascii() );
}
}
void SyncTaskListItem::openPopup()
{
bool preferedFound = false;
offers = getOffers();
KTrader::OfferList::ConstIterator it;
itemMenu.clear();
itemMenu.setCaption(i18n("Services for") + " " + text());
itemMenu.insertTitle(i18n("Services for") + " " + text());
itemMenu.setCheckable(true);
itemMenu.setEnabled(true);
if (offers.begin() != offers.end()) {
for (it = offers.begin(); it != offers.end(); ++it) {
KService::Ptr service = *it;
kdDebug(2120) << i18n("Open Name:") << " "
<< service->name() << "; " << i18n("Library:") << " "
<< service->library() << endl;
int item = itemMenu.insertItem(service->name());
if (service->name() == preferedOfferTemp) {
itemMenu.setItemChecked(item, true);
preferedFound = true;
}
}
if (!preferedFound) {
preferedOffer = "";
preferedLibrary = "";
}
itemMenu.move(-1000,-1000);
itemMenu.show();
itemMenu.hide();
QPoint g = QCursor::pos();
if (itemMenu.height() < g.y()) {
itemMenu.popup(QPoint( g.x(), g.y() - itemMenu.height()));
} else {
itemMenu.popup(QPoint(g.x(), g.y()));
}
}
}
static KDevCompilerOptions *createCompilerOptions( const QString &name, QObject *parent )
{
KService::Ptr service = KService::serviceByDesktopName( name );
if ( !service )
{
kdDebug( 9020 ) << "Can't find service " << name << endl;
return 0;
}
KLibFactory *factory = KLibLoader::self()->factory(QFile::encodeName(service->library()));
if (!factory) {
QString errorMessage = KLibLoader::self()->lastErrorMessage();
kdDebug(9020) << "There was an error loading the module " << service->name() << endl <<
"The diagnostics is:" << endl << errorMessage << endl;
exit(1);
}
QStringList args;
QVariant prop = service->property("X-KDevelop-Args");
if (prop.isValid())
args = QStringList::split(" ", prop.toString());
QObject *obj = factory->create(parent, service->name().latin1(),
"KDevCompilerOptions", args);
if (!obj->inherits("KDevCompilerOptions")) {
kdDebug(9020) << "Component does not inherit KDevCompilerOptions" << endl;
return 0;
}
KDevCompilerOptions *dlg = (KDevCompilerOptions*) obj;
return dlg;
/*
QStringList args;
QVariant prop = service->property( "X-KDevelop-Args" );
if ( prop.isValid() )
args = QStringList::split( " ", prop.toString() );
return KParts::ComponentFactory
::createInstanceFromService<KDevCompilerOptions>( service, parent,
service->name().latin1(), args );*/
}
// static factory method
KOCRDialog * KOCRDialog::getOCRDialog( QWidget *parent, const char *name,
bool modal )
{
KTrader::OfferList offers = KTrader::self()->query("KScan/KOCRDialog");
if ( offers.isEmpty() )
return 0L;
KService::Ptr ptr = *(offers.begin());
KLibFactory *factory = KLibLoader::self()->factory( QFile::encodeName(ptr->library()) );
if ( !factory )
return 0;
QStringList args;
args << QString::number( (int)modal );
QObject *res = factory->create( parent, name, "KOCRDialog", args );
return dynamic_cast<KOCRDialog *>( res );
}
void KCMInit::runModules( int phase )
{
for(KService::List::Iterator it = list.begin();
it != list.end();
++it) {
KService::Ptr service = (*it);
QVariant tmp = service->property("X-KDE-Init-Library", QVariant::String);
QString library;
if( tmp.isValid() )
{
library = tmp.toString();
if( !library.startsWith( QLatin1String( "kcminit_" ) ) )
library = QLatin1String( "kcminit_" ) + library;
}
else
{
library = service->library();
}
if (library.isEmpty()) {
continue; // Skip
}
// see ksmserver's README for the description of the phases
QVariant vphase = service->property("X-KDE-Init-Phase", QVariant::Int );
int libphase = 1;
if( vphase.isValid() )
libphase = vphase.toInt();
if( phase != -1 && libphase != phase )
continue;
// try to load the library
if (!alreadyInitialized.contains(library)) {
runModule(library, service);
alreadyInitialized.append(library);
}
}
}
void PhotoLayoutsEditor::loadEffects()
{
StandardEffectsFactory * stdEffects = new StandardEffectsFactory( PhotoEffectsLoader::instance() );
PhotoEffectsLoader::registerEffect( stdEffects );
const KService::List offers = KServiceTypeTrader::self()->query("PhotoLayoutsEditor/EffectPlugin");
foreach(const KService::Ptr& service, offers)
{
if (service)
d->effectsServiceMap[service->name()] = service;
}
foreach(const QString& name, d->effectsServiceMap.keys())
{
KService::Ptr service = d->effectsServiceMap.value(name);
AbstractPhotoEffectFactory * plugin;
if ( d->effectsMap.contains(name) )
continue;
else
{
QString error;
plugin = service->createInstance<AbstractPhotoEffectFactory>( PhotoEffectsLoader::instance(), QVariantList(), &error);
if (plugin)
{
d->effectsMap[name] = plugin;
PhotoEffectsLoader::registerEffect(plugin);
kDebug() << "PhotoLayoutsEditor: Loaded effect " << service->name();
}
else
{
kWarning() << "PhotoLayoutsEditor: createInstance returned 0 for "
<< service->name()
<< " (" << service->library() << ")"
<< " with error: "
<< error;
}
}
}
}
void PhotoLayoutsEditor::loadBorders()
{
StandardBordersFactory * stdBorders = new StandardBordersFactory( BorderDrawersLoader::instance() );
BorderDrawersLoader::registerDrawer( stdBorders );
const KService::List offers = KServiceTypeTrader::self()->query("PhotoLayoutsEditor/BorderPlugin");
foreach(const KService::Ptr& service, offers)
{
if (service)
d->bordersServiceMap[service->name()] = service;
}
foreach(const QString& name, d->bordersServiceMap.keys())
{
KService::Ptr service = d->bordersServiceMap.value(name);
BorderDrawerFactoryInterface * plugin;
if ( d->bordersMap.contains(name) )
continue;
else
{
QString error;
plugin = service->createInstance<BorderDrawerFactoryInterface>(this, QVariantList(), &error);
if (plugin)
{
d->bordersMap[name] = plugin;
BorderDrawersLoader::registerDrawer(plugin);
kDebug() << "PhotoLayoutsEditor: Loaded border:" << service->name();
}
else
{
kWarning() << "PhotoLayoutsEditor: createInstance returned 0 for "
<< service->name()
<< " (" << service->library() << ")"
<< " with error: "
<< error;
}
}
}
}
bool ArkViewer::viewInInternalViewer(const QString& fileName, const QMimeType &mimeType)
{
setWindowFilePath(fileName);
// Set icon and comment for the mimetype.
m_iconLabel->setPixmap(QIcon::fromTheme(mimeType.iconName()).pixmap(IconSize(KIconLoader::Small), IconSize(KIconLoader::Small)));
m_commentLabel->setText(mimeType.comment());
// Create the ReadOnlyPart instance.
m_part = KMimeTypeTrader::self()->createPartInstanceFromQuery<KParts::ReadOnlyPart>(mimeType.name(), this, this);
// Drop the KHTMLPart, if necessary.
const KService::Ptr service = KMimeTypeTrader::self()->preferredService(mimeType.name(), QStringLiteral("KParts/ReadOnlyPart"));
qCDebug(ARK) << "Preferred service for mimetype" << mimeType.name() << "is" << service->library();
if (service.constData()->desktopEntryName() == QLatin1String("khtml")) {
KService::List offers = KMimeTypeTrader::self()->query(mimeType.name(), QStringLiteral("KParts/ReadOnlyPart"));
offers.removeFirst();
qCDebug(ARK) << "Removed KHTMLPart from the offers for mimetype" << mimeType.name()
<< ". Using" << offers.first().constData()->desktopEntryName() << "instead.";
m_part = offers.first().constData()->createInstance<KParts::ReadOnlyPart>(this, this);
}
if (!m_part.data()) {
return false;
}
// Insert the KPart into its placeholder.
centralWidget()->layout()->replaceWidget(m_partPlaceholder, m_part.data()->widget());
createGUI(m_part.data());
setAutoSaveSettings(QStringLiteral("Viewer"), true);
m_part.data()->openUrl(QUrl::fromLocalFile(fileName));
m_part.data()->widget()->setFocus();
m_fileName = fileName;
return true;
}
void
PluginManager::dump( const KService::Ptr service )
{
#define ENDLI endl << Debug::indent()
kdDebug()
<< ENDLI
<< "PluginManager Service Info:" << ENDLI
<< "---------------------------" << ENDLI
<< "name : " << service->name() << ENDLI
<< "library : " << service->library() << ENDLI
<< "desktopEntryPath : " << service->desktopEntryPath() << ENDLI
<< "X-KDE-amaroK-plugintype : " << service->property( "X-KDE-amaroK-plugintype" ).toString() << ENDLI
<< "X-KDE-amaroK-name : " << service->property( "X-KDE-amaroK-name" ).toString() << ENDLI
<< "X-KDE-amaroK-authors : " << service->property( "X-KDE-amaroK-authors" ).toStringList() << ENDLI
<< "X-KDE-amaroK-rank : " << service->property( "X-KDE-amaroK-rank" ).toString() << ENDLI
<< "X-KDE-amaroK-version : " << service->property( "X-KDE-amaroK-version" ).toString() << ENDLI
<< "X-KDE-amaroK-framework-version: " << service->property( "X-KDE-amaroK-framework-version" ).toString()
<< endl
<< endl;
#undef ENDLI
}
void Konsole::spawn()
{
KILE_DEBUG_MAIN << "void Konsole::spawn()";
KPluginFactory *factory = Q_NULLPTR;
KService::Ptr service = KService::serviceByDesktopName("konsolepart");
if(!service) {
KILE_DEBUG_MAIN << "No service for konsolepart";
return;
}
factory = KPluginLoader(service->library()).factory();
if(!factory) {
KILE_DEBUG_MAIN << "No factory for konsolepart";
return;
}
// the catalog for translations is added by the Konsole part constructor already
m_part = static_cast<KParts::ReadOnlyPart*>(factory->create<QObject>(this, this));
if(!m_part) {
return;
}
if(!qobject_cast<TerminalInterface*>(m_part)){
KILE_DEBUG_MAIN << "Did not find the TerminalInterface";
delete m_part;
m_part = Q_NULLPTR;
return;
}
layout()->addWidget(m_part->widget());
setFocusProxy(m_part->widget());
connect(m_part, SIGNAL(destroyed()), this, SLOT(slotDestroyed()));
// necessary as older versions of Konsole (4.5) might not show a proper prompt otherwise
qobject_cast<TerminalInterface*>(m_part)->showShellInDir(QDir::currentPath());
}
void BackendSelection::showBackendKcm(const KService::Ptr &backendService)
{
const QString parentComponent = backendService->library();
if (!m_kcms.contains(parentComponent)) {
const KService::List offers = KServiceTypeTrader::self()->query("KCModule",
QString("'%1' in [X-KDE-ParentComponents]").arg(parentComponent));
if (offers.isEmpty()) {
m_kcms.insert(parentComponent, 0);
} else {
KCModuleProxy *proxy = new KCModuleProxy(offers.first());
connect(proxy, SIGNAL(changed(bool)), SIGNAL(changed()));
m_kcms.insert(parentComponent, proxy);
stackedWidget->addWidget(proxy);
}
}
QWidget *w = m_kcms.value(parentComponent);
if (w) {
stackedWidget->show();
stackedWidget->setCurrentWidget(w);
} else {
stackedWidget->hide();
stackedWidget->setCurrentIndex(m_emptyPage);
}
}
QString ThumbnailProtocol::pluginForMimeType(const QString& mimeType) {
KService::List offers = KMimeTypeTrader::self()->query( mimeType, QLatin1String("ThumbCreator"));
if (!offers.isEmpty()) {
KService::Ptr serv;
serv = offers.first();
return serv->library();
}
//Match group mimetypes
///@todo Move this into some central location together with the related matching code in previewjob.cpp. This doesn't handle inheritance and such
const KService::List plugins = KServiceTypeTrader::self()->query("ThumbCreator");
foreach(KService::Ptr plugin, plugins) {
const QStringList mimeTypes = plugin->serviceTypes();
foreach(QString mime, mimeTypes) {
if(mime.endsWith('*')) {
mime = mime.left(mime.length()-1);
if(mimeType.startsWith(mime))
return plugin->library();
}
}
}
return QString();
}
KCMInit::KCMInit( KCmdLineArgs* args )
{
QDBusConnection::sessionBus().registerObject("/kcminit", this,
QDBusConnection::ExportScriptableSlots|QDBusConnection::ExportScriptableSignals);
QString arg;
if (args->count() == 1) {
arg = args->arg(0);
}
if (args->isSet("list"))
{
list = KServiceTypeTrader::self()->query( "KCModuleInit" );
for(KService::List::Iterator it = list.begin();
it != list.end();
++it)
{
KService::Ptr service = (*it);
if (service->library().isEmpty())
continue; // Skip
printf("%s\n", QFile::encodeName(service->desktopEntryName()).data());
}
return;
}
if (!arg.isEmpty()) {
QString module = arg;
if (!module.endsWith(".desktop"))
module += ".desktop";
KService::Ptr serv = KService::serviceByStorageId( module );
if ( !serv || serv->library().isEmpty() ) {
kError(1208) << i18n("Module %1 not found", module) << endl;
return;
} else
list.append(serv);
} else {
// locate the desktop files
list = KServiceTypeTrader::self()->query( "KCModuleInit" );
}
// This key has no GUI apparently
KConfig _config( "kcmdisplayrc" );
KConfigGroup config(&_config, "X11");
#ifdef Q_WS_X11
bool multihead = !config.readEntry( "disableMultihead", false) &&
(ScreenCount(QX11Info::display()) > 1);
#else
bool multihead = false;
#endif
// Pass env. var to kdeinit.
QString name = "KDE_MULTIHEAD";
QString value = multihead ? "true" : "false";
KToolInvocation::klauncher()->setLaunchEnv(name, value);
setenv( name.toLatin1().constData(), value.toLatin1().constData(), 1 ); // apply effect also to itself
if( startup )
{
runModules( 0 );
XEvent e;
e.xclient.type = ClientMessage;
e.xclient.message_type = XInternAtom( QX11Info::display(), "_KDE_SPLASH_PROGRESS", False );
e.xclient.display = QX11Info::display();
e.xclient.window = QX11Info::appRootWindow();
e.xclient.format = 8;
strcpy( e.xclient.data.b, "kcminit" );
XSendEvent( QX11Info::display(), QX11Info::appRootWindow(), False, SubstructureNotifyMask, &e );
sendReady();
QTimer::singleShot( 300 * 1000, qApp, SLOT(quit())); // just in case
qApp->exec(); // wait for runPhase1() and runPhase2()
}
else
runModules( -1 ); // all phases
}
bool MigrateManagerInternal::lookupDrivers()
{
if (!lookupDriversNeeded)
return true;
if (qApp) {
connect(qApp, SIGNAL(aboutToQuit()), this, SLOT(slotAppQuits()));
}
//! @todo for Qt-only version check for KComponentData wrapper
// KexiDBWarn << "cannot work without KComponentData (KGlobal::mainComponent()==0)!";
// setError("Driver Manager cannot work without KComponentData (KGlobal::mainComponent()==0)!");
lookupDriversNeeded = false;
clearError();
KService::List tlist = KServiceTypeTrader::self()->query("Kexi/MigrationDriver");
KService::List::ConstIterator it(tlist.constBegin());
for (; it != tlist.constEnd(); ++it) {
KService::Ptr ptr = (*it);
QString srv_name = ptr->property("X-Kexi-MigrationDriverName").toString();
if (srv_name.isEmpty()) {
KexiDBWarn << "X-Kexi-MigrationDriverName must be set for migration driver"
<< ptr->property("Name").toString() << "service!\n -- skipped!";
continue;
}
if (m_services_lcase.contains(srv_name.toLower())) {
continue;
}
//! @todo could be merged. Copied from KexiDB::DriverManager.
//<COPIED>
QString srv_ver_str = ptr->property("X-Kexi-KexiMigrationVersion").toString();
QStringList lst(srv_ver_str.split('.'));
int minor_ver, major_ver;
bool ok = (lst.count() == 2);
if (ok)
major_ver = lst[0].toUInt(&ok);
if (ok)
minor_ver = lst[1].toUInt(&ok);
#if 0 //temp. disable
if (!ok) {
KexiDBWarn << "problem with detecting" << srv_name.toLower() << "driver's version -- skipping it!";
possibleProblems += QString("\"%1\" migration driver has unrecognized version; "
"required driver version is \"%2.%3\"")
.arg(srv_name.toLower())
.arg(KexiMigration::version().major).arg(KexiMigration::version().minor);
continue;
}
if (!KexiMigration::version().matches(major_ver, minor_ver)) {
KexiDBWarn << QString("'%1' driver"
" has version '%2' but required migration driver version is '%3.%4'\n"
" -- skipping this driver!").arg(srv_name.toLower()).arg(srv_ver_str)
.arg(KexiMigration::version().major).arg(KexiMigration::version().minor);
possibleProblems += QString("\"%1\" migration driver has version \"%2\" "
"but required driver version is \"%3.%4\"")
.arg(srv_name.toLower()).arg(srv_ver_str)
.arg(KexiMigration::version().major).arg(KexiMigration::version().minor);
continue;
}
#endif
//</COPIED>
QString mime = ptr->property("X-Kexi-FileDBDriverMime").toString().toLower();
QString drvType = ptr->property("X-Kexi-MigrationDriverType").toString().toLower();
if (drvType == "file") {
if (!mime.isEmpty()) {
if (!m_services_by_mimetype.contains(mime)) {
m_services_by_mimetype.insert(mime, ptr);
} else {
KexiDBWarn << "more than one driver for" << mime << "mime type!";
}
}
}
m_services.insert(srv_name, ptr);
m_services_lcase.insert(srv_name.toLower(), ptr);
KexiDBDbg << "registered driver:" << ptr->name() << '(' << ptr->library() << ")";
}
if (tlist.isEmpty()) {
setError(ERR_DRIVERMANAGER, i18n("Could not find any import/export database drivers."));
return false;
}
return true;
}
