void Configuration::setServiceMenu()
{
KMenu *menu = qobject_cast<KMenu*>(sender());
if (menu->actions().count() > 1)
{
return;
}
KServiceGroup::Ptr rootGroup = KServiceGroup::group(menu->actions()[0]->data().toString());
if (!rootGroup || !rootGroup->isValid() || rootGroup->noDisplay())
{
return;
}
KServiceGroup::List list = rootGroup->entries(true, true, true, true);
QAction *action = menu->addAction(KIcon("list-add"), i18n("Add This Menu"));
action->setData(rootGroup->relPath());
menu->addSeparator();
for (int i = 0; i < list.count(); ++i)
{
if (list.at(i)->isType(KST_KService))
{
const KService::Ptr service = KService::Ptr::staticCast(list.at(i));
action = menu->addAction(KIcon(service->icon()), service->name());
action->setEnabled(false);
}
else if (list.at(i)->isType(KST_KServiceGroup))
{
const KServiceGroup::Ptr group = KServiceGroup::Ptr::staticCast(list.at(i));
if (group->noDisplay() || group->childCount() == 0)
{
continue;
}
KMenu *subMenu = new KMenu(menu);
QAction *action = subMenu->addAction(QString());
action->setData(group->relPath());
action->setVisible(false);
action = menu->addAction(KIcon(group->icon()), group->caption());
action->setMenu(subMenu);
connect(subMenu, SIGNAL(aboutToShow()), this, SLOT(setServiceMenu()));
}
else if (list.at(i)->isType(KST_KServiceSeparator))
{
menu->addSeparator();
}
}
}
void
KCustomMenuEditor::load(KConfigBase *cfg)
{
cfg->setGroup(QString::null);
int count = cfg->readNumEntry("NrOfItems");
QListViewItem *last = 0;
for(int i = 0; i < count; i++)
{
QString entry = cfg->readPathEntry(QString("Item%1").arg(i+1));
if (entry.isEmpty())
continue;
// Try KSycoca first.
KService::Ptr menuItem = KService::serviceByDesktopPath( entry );
if (!menuItem)
menuItem = KService::serviceByDesktopName( entry );
if (!menuItem)
menuItem = new KService( entry );
if (!menuItem->isValid())
continue;
QListViewItem *item = new Item(m_listView, menuItem);
item->moveItem(last);
last = item;
}
}
void BasicTab::slotCapturedShortcut(const KShortcut &cut)
{
if(signalsBlocked())
return;
if(KKeyChooser::checkGlobalShortcutsConflict(cut, true, topLevelWidget())
|| KKeyChooser::checkStandardShortcutsConflict(cut, true, topLevelWidget()))
return;
if(KHotKeys::present())
{
if(!_menuEntryInfo->isShortcutAvailable(cut))
{
KService::Ptr service;
emit findServiceShortcut(cut, service);
if(!service)
service = KHotKeys::findMenuEntry(cut.toString());
if(service)
{
KMessageBox::sorry(this, i18n("<qt>The key <b>%1</b> can not be used here because it is already used to activate <b>%2</b>.")
.arg(cut.toString(), service->name()));
return;
}
else
{
KMessageBox::sorry(this, i18n("<qt>The key <b>%1</b> can not be used here because it is already in use.").arg(cut.toString()));
return;
}
}
_menuEntryInfo->setShortcut(cut);
}
_keyEdit->setShortcut(cut, false);
if(_menuEntryInfo)
emit changed(_menuEntryInfo);
}
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;
}
DVBevents::DVBevents( QString devType, int anum, int tnum, const QString &charset, EventTable *table )
: KaffeineDVBsection( anum, tnum, charset )
{
events = table;
KaffeineEpgPlugin *plug;
QString plugName;
int error;
KTrader::OfferList offers = KTrader::self()->query("KaffeineEpgPlugin");
KTrader::OfferList::Iterator end( offers.end() );
for ( KTrader::OfferList::Iterator it=offers.begin(); it!=end; ++it ) {
error = 0;
KService::Ptr ptr = (*it);
if ( !ptr->name().contains(devType) )
continue;
plug = KParts::ComponentFactory::createPartInstanceFromService<KaffeineEpgPlugin>(ptr, 0, ptr->name().ascii(), 0, 0, 0, &error );
plugName = ptr->desktopEntryName();
if (error > 0) {
fprintf( stderr, "Loading of EPG plugin %s failed: %s\n", plugName.ascii(), KLibLoader::self()->lastErrorMessage().ascii() );
plug = NULL;
}
else {
plugs.append( plug );
plug->setTable( table );
plug->initSection( anum, tnum, charset );
plugNames.append( plugName );
}
}
fprintf( stderr, "%d EPG plugins loaded for device %d:%d.\n", plugs.count(), anum, tnum );
}
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::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;
}
}
}
bool
EngineController::installDistroCodec()
{
KService::List services = KServiceTypeTrader::self()->query( "Amarok/CodecInstall"
, QString( "[X-KDE-Amarok-codec] == 'mp3' and [X-KDE-Amarok-engine] == 'phonon-%1'").arg( "xine" ) );
//todo - figure out how to query Phonon for the current backend loaded
if( !services.isEmpty() )
{
KService::Ptr service = services.first(); //list is not empty
QString installScript = service->exec();
if( !installScript.isNull() ) //just a sanity check
{
KGuiItem installButton( i18n( "Install MP3 Support" ) );
if(KMessageBox::questionYesNo( The::mainWindow()
, i18n("Amarok currently cannot play MP3 files. Do you want to install support for MP3?")
, i18n( "No MP3 Support" )
, installButton
, KStandardGuiItem::no()
, "codecInstallWarning" ) == KMessageBox::Yes )
{
KRun::runCommand(installScript, 0);
return true;
}
}
}
return false;
}
void addRecentApplication(KService::Ptr service, bool append) {
// remove existing item if any
if (removeExistingItem(service->entryPath())) {
--recentApplicationCount;
}
QStandardItem *appItem = StandardItemFactory::createItemForService(service, displayOrder);
appItem->setData(applicationTitle, Kickoff::GroupNameRole);
itemsByPath.insert(service->entryPath(), appItem);
if (append) {
q->insertRow(recentApplicationCount, appItem);
} else {
q->insertRow(0, appItem);
}
++recentApplicationCount;
while (recentApplicationCount > maxRecentApps) {
--recentApplicationCount;
QList<QStandardItem*> row = q->takeRow(recentApplicationCount);
//don't leave pending stuff in itemsByPath
if (!row.isEmpty()) {
itemsByPath.remove(row.first()->data(UrlRole).toString());
qDeleteAll(row.begin(), row.end());
}
}
}
QVariant RecentAppsModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid() || index.row() >= m_recentApps.count()) {
return QVariant();
}
const QString storageId = m_recentApps.at(index.row());
KService::Ptr service = KService::serviceByStorageId(storageId);
if (!service) {
return QVariant();
}
if (role == Qt::DisplayRole) {
return service->name();
} else if (role == Qt::DecorationRole) {
return QIcon::fromTheme(service->icon(), QIcon::fromTheme("unknown"));
} else if (role == Kicker::FavoriteIdRole) {
return QVariant("app:" + storageId);
} else if (role == Kicker::HasActionListRole) {
return true;
} else if (role == Kicker::ActionListRole) {
QVariantList actionList;
const QVariantMap &forgetAction = Kicker::createActionItem(i18n("Forget Application"), "forget");
actionList.append(forgetAction);
const QVariantMap &forgetAllAction = Kicker::createActionItem(i18n("Forget All Applications"), "forgetAll");
actionList.append(forgetAllAction);
return actionList;
}
return QVariant();
}
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();
}
bool DocumentationViewer::urlSelected(const QString &url, int button, int state, const QString &_target, const KParts::OpenUrlArguments &args, const KParts::BrowserArguments & /* browserArgs */)
{
KUrl cURL = completeURL(url);
QString mime = KMimeType::findByUrl(cURL).data()->name();
//load this URL in the embedded viewer if KHTML can handle it, or when mimetype detection failed
KService::Ptr service = KService::serviceByDesktopName("khtml");
if(( mime == KMimeType::defaultMimeType() ) || (service && service->hasServiceType(mime))) {
KHTMLPart::urlSelected(url, button, state, _target, args);
openUrl(cURL);
addToHistory(cURL.url());
}
//KHTML can't handle it, look for an appropriate application
else {
KService::List offers = KMimeTypeTrader::self()->query(mime, "Type == 'Application'");
if(offers.isEmpty()) {
KMessageBox::error(view(), i18n("No KDE service found for the MIME type \"%1\".", mime));
return false;
}
KUrl::List lst;
lst.append(cURL);
KRun::run(*(offers.first()), lst, view());
}
return true;
}
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 {
bool Helper::handleAppsDialog()
{
if( !readArguments( 1 ))
return false;
QString title = getArgument();
long wid = getArgumentParent();
if( !allArgumentsUsed())
return false;
KOpenWithDialog dialog( NULL );
if( !title.isEmpty())
dialog.setWindowTitle( title );
dialog.hideNoCloseOnExit();
dialog.hideRunInTerminal(); // TODO
if( wid != 0 )
KWindowSystem::setMainWindow( &dialog, wid );
if( dialog.exec())
{
KService::Ptr service = dialog.service();
QString command;
if( service )
command = service->exec();
else if( !dialog.text().isEmpty())
command = dialog.text();
else
return false;
command = command.split( " " ).first(); // only the actual command
command = QStandardPaths::findExecutable(command);
if( command.isEmpty())
return false;
outputLine( QUrl::fromUserInput( command ).url());
return true;
}
return false;
}
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;
}
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;
}
void FavoriteAppsModel::addFavorite(const QString &favoriteId)
{
QString serviceId = serviceIdFromFavoriteId(favoriteId);
if (serviceId.isEmpty()) {
return;
}
KService::Ptr service = KService::serviceByStorageId(serviceId);
if (service.isNull()) {
kWarning() << "Could not find a service for" << serviceId;
return;
}
int rank;
if (!m_favoriteList.isEmpty()) {
rank = m_favoriteList.last().rank + 1;
} else {
rank = 0;
}
FavoriteInfo info = { rank, service };
int row = m_favoriteList.count();
beginInsertRows(QModelIndex(), row, row);
m_favoriteList << info;
endInsertRows();
countChanged();
KConfigGroup baseGroup(m_config, "favorites");
KConfigGroup group(&baseGroup, QString("favorite-%1").arg(rank));
group.writeEntry("serviceId", serviceId);
baseGroup.sync();
}
void FavoriteAppsModel::setConfig(const KSharedConfig::Ptr &ptr)
{
m_config = ptr;
KConfigGroup baseGroup(m_config, "favorites");
// get all the favorites
QMap<int, KService::Ptr> favoriteMap;
foreach (const QString &favoriteGroup, baseGroup.groupList()) {
if (favoriteGroup.startsWith("favorite-")) {
KConfigGroup favoriteConfig(&baseGroup, favoriteGroup);
int rank = favoriteGroup.split("-").last().toInt();
QString id = favoriteConfig.readEntry("serviceId");
KService::Ptr service = KService::serviceByStorageId(id);
if (!service.isNull()) {
favoriteMap.insert(rank, service);
}
}
}
beginResetModel();
m_favoriteList.clear();
auto it = favoriteMap.constBegin(), end = favoriteMap.constEnd();
for (; it != end; ++it) {
FavoriteInfo info = { it.key(), it.value() };
m_favoriteList << info;
}
endResetModel();
countChanged();
}
QString KProtocolInfo::exec(const QString& protocol)
{
KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(protocol);
// We have up to two sources of data:
// 1) the exec line of the .protocol file, if there's one (could be a kioslave or a helper app)
// 2) the application associated with x-scheme-handler/<protocol> if there's one
// If both exist, then:
// A) if the .protocol file says "launch an application", then the new-style handler-app has priority
// B) but if the .protocol file is for a kioslave (e.g. kio_http) then this has priority over
// firefox or chromium saying x-scheme-handler/http. Gnome people want to send all HTTP urls
// to a webbrowser, but we want mimetype-determination-in-calling-application by default
// (the user can configure a BrowserApplication though)
QString helperExe;
const KService::Ptr service = KMimeTypeTrader::self()->preferredService(QString::fromLatin1("x-scheme-handler/") + protocol);
if (service) {
helperExe = service->exec();
if (prot && prot->m_isHelperProtocol)
return helperExe; // for helper protocols, the handler app has priority over the hardcoded one (see A above)
}
if (prot) {
return prot->m_exec;
}
// If there's no protocol file, then return the handler app if any, otherwise empty string
return helperExe;
}
void KateFileTree::slotFixOpenWithMenu()
{
QMenu *menu = (QMenu*)sender();
menu->clear();
KTextEditor::Document *doc = model()->data(m_indexContextMenu, KateFileTreeModel::DocumentRole).value<KTextEditor::Document *>();
if (!doc) return;
// get a list of appropriate services.
KMimeType::Ptr mime = KMimeType::mimeType(doc->mimeType());
//kDebug(13001) << "mime type: " << mime->name();
QAction *a = 0;
KService::List offers = KMimeTypeTrader::self()->query(mime->name(), "Application");
// for each one, insert a menu item...
for(KService::List::Iterator it = offers.begin(); it != offers.end(); ++it)
{
KService::Ptr service = *it;
if (service->name() == "Kate") continue;
a = menu->addAction(KIcon(service->icon()), service->name());
a->setData(service->entryPath());
}
// append "Other..." to call the KDE "open with" dialog.
a = menu->addAction(i18n("&Other..."));
a->setData(QString());
}
void ApplicationsProtocol::stat(const KUrl& url)
{
KIO::UDSEntry entry;
QString servicePath( url.path( KUrl::AddTrailingSlash ) );
servicePath.remove(0, 1); // remove starting '/'
KServiceGroup::Ptr grp = KServiceGroup::group(servicePath);
if (grp && grp->isValid()) {
createDirEntry(entry, ((m_runMode==ApplicationsMode) ? i18n("Applications") : i18n("Programs")),
url.url(), "inode/directory",grp->icon() );
} else {
KService::Ptr service = KService::serviceByDesktopName( url.fileName() );
if (service && service->isValid()) {
createFileEntry(entry, service, url );
} else {
error(KIO::ERR_SLAVE_DEFINED,i18n("Unknown application folder"));
return;
}
}
statEntry(entry);
finished();
}
DesktopBehaviorPreviewItem(DesktopBehavior *rootOpts, QListView *parent,
const KService::Ptr &plugin, bool on)
: QCheckListItem(parent, plugin->name(), CheckBox),
m_rootOpts(rootOpts)
{
m_pluginName = plugin->desktopEntryName();
setOn(on);
}
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;
}
}
void NavigatorAppItem::populate(bool recursive)
{
if(mPopulated)
return;
KServiceGroup::Ptr root = KServiceGroup::group(mRelpath);
if(!root)
{
kdWarning() << "No Service groups\n";
return;
}
KServiceGroup::List list = root->entries();
for(KServiceGroup::List::ConstIterator it = list.begin(); it != list.end(); ++it)
{
KSycocaEntry *e = *it;
KService::Ptr s;
NavigatorItem *item;
KServiceGroup::Ptr g;
QString url;
switch(e->sycocaType())
{
case KST_KService:
{
s = static_cast< KService * >(e);
url = documentationURL(s);
if(!url.isEmpty())
{
DocEntry *entry = new DocEntry(s->name(), url, s->icon());
item = new NavigatorItem(entry, this);
item->setAutoDeleteDocEntry(true);
item->setExpandable(true);
}
break;
}
case KST_KServiceGroup:
{
g = static_cast< KServiceGroup * >(e);
if((g->childCount() == 0) || g->name().startsWith("."))
continue;
DocEntry *entry = new DocEntry(g->caption(), "", g->icon());
NavigatorAppItem *appItem;
appItem = new NavigatorAppItem(entry, this, g->relPath());
appItem->setAutoDeleteDocEntry(true);
if(recursive)
appItem->populate(recursive);
break;
}
default:
break;
}
}
sortChildItems(0, true /* ascending */);
mPopulated = true;
}
bool FavoriteAppsModel::trigger(int row)
{
KService::Ptr service = m_favoriteList.value(row).service;
if (service.isNull()) {
kWarning() << "Invalid row";
return false;
}
return KRun::run(*service, KUrl::List(), 0);
}
SearchProvider::SearchProvider(const KService::Ptr service)
: m_dirty(false)
{
m_desktopEntryName = service->desktopEntryName();
m_name = service->name();
m_query = service->property("Query").toString();
m_keys = service->property("Keys").toStringList();
m_charset = service->property("Charset").toString();
}
void FileManager::openFile( const QString& fileName, const QString& name, const QString& title, const QString& partName, const QVariantList& partParams )
{
if( fileName.isEmpty() )
return;
QString fullName = name.isEmpty() ? KUrl( fileName ).fileName() : name;
QString fullTitle = title.isEmpty() ? fullName : title;
if( d->parts.contains( fullName ) )
{
emit newPart( fullName, fullTitle );
return;
}
KMimeType::Ptr mime = KMimeType::findByPath( fileName );
KParts::ReadOnlyPart* part = 0;
KService::List parts;
if( !partName.isEmpty() )
{
KService::Ptr service = KService::serviceByDesktopName( partName );
if( !service.isNull() )
parts.append( service );
}
if( parts.count() == 0 )
{
parts.append( KMimeTypeTrader::self()->query( mime->name(), "KParts/ReadWritePart" ) );
parts.append( KMimeTypeTrader::self()->query( mime->name(), "KParts/ReadOnlyPart" ) );
if( mime->name().contains( "audio" ) && parts.count() == 0 )
parts.append( KService::serviceByStorageId( "dragonplayer_part.desktop" ) );
}
if( parts.count() > 0 )
{
part = parts.first()->createInstance<KParts::ReadWritePart>( 0, partParams );
if( !part )
part = parts.first()->createInstance<KParts::ReadOnlyPart>( 0, partParams );
}
if( part )
{
// Add the part if it is found
KUrl url( fileName );
part->openUrl( url );
d->parts.insert( fullName, part );
d->partManager->addPart( part, true );
emit newPart( fullName, fullTitle );
return;
}
// There really is no part that can be used.
// Instead, just open it in an external application.
// KRun* runner = new KRun( KUrl( fileName ), qApp->activeWindow() );
}
void KMimeTypeTest::testPreferredService()
{
// The "NotShowIn=KDE" service should not be the preferred one!
KService::Ptr serv = KMimeTypeTrader::self()->preferredService("text/plain");
QVERIFY(serv);
qDebug() << serv->entryPath();
QVERIFY(serv->entryPath() != m_nonKdeApp);
QCOMPARE(serv->entryPath(), m_textPlainApp);
}
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&)));
}
void ExtensionMgr::loadExtension(const QString& name) {
KService::List sl = KServiceType::offers("Kst Extension");
for (KService::List::ConstIterator it = sl.begin(); it != sl.end(); ++it) {
KService::Ptr service = *it;
if (name == service->property("Name").toString()) {
loadExtension(service);
return;
}
}
}
