KService::Ptr ArkViewer::getViewer(const QString &mimeType)
{
// No point in even trying to find anything for application/octet-stream
if (mimeType == QStringLiteral("application/octet-stream")) {
return KService::Ptr();
}
// Try to get a read-only kpart for the internal viewer
KService::List offers = KMimeTypeTrader::self()->query(mimeType, QStringLiteral("KParts/ReadOnlyPart"));
auto arkPartIt = std::find_if(offers.begin(), offers.end(), [](KService::Ptr service) {
return service->storageId() == QLatin1String("ark_part.desktop");
});
// Use the Ark part only when the mime type matches an archive type directly.
// Many file types (e.g. Open Document) are technically just archives
// but browsing their internals is typically not what the user wants.
if (arkPartIt != offers.end()) {
// Not using hasMimeType() as we're explicitly not interested in inheritance.
if (!(*arkPartIt)->mimeTypes().contains(mimeType)) {
offers.erase(arkPartIt);
}
}
// If we can't find a kpart, try to get an external application
if (offers.isEmpty()) {
offers = KMimeTypeTrader::self()->query(mimeType, QStringLiteral("Application"));
}
if (!offers.isEmpty()) {
return offers.first();
} else {
return KService::Ptr();
}
}
void KJiebaRunner::match(Plasma::RunnerContext &context)
{
const QString term = context.query();
QList<Plasma::QueryMatch> matches;
QSet<QString> seen;
if (term.length() > 1) {
#if DEBUG
qDebug() << "DEBUG:" << __PRETTY_FUNCTION__ << term;
#endif
KService::List services = KServiceTypeTrader::self()->query("Application");
services.erase(std::remove_if(services.begin(),
services.end(),
[=](QExplicitlySharedDataPointer<KService> it) {
return it->exec().isEmpty() ||
(!kjiebaPtr->query(it->genericName()).contains(term) &&
!kjiebaPtr->topinyin(it->genericName()).contains(term) &&
!kjiebaPtr->topinyin(it->genericName(), false).contains(term) &&
!kjiebaPtr->query(it->name()).contains(term) &&
!kjiebaPtr->topinyin(it->name()).contains(term) &&
!kjiebaPtr->topinyin(it->name(), false).contains(term));
}), services.end());
if (!services.isEmpty()) {
Q_FOREACH (const KService::Ptr &service, services) {
if (!service->noDisplay() &&
service->property(QStringLiteral("NotShowIn"), QVariant::String) != "KDE") {
Plasma::QueryMatch match(this);
match.setType(Plasma::QueryMatch::ExactMatch);
const QString name = service->name();
#if DEBUG
qDebug() << "DEBUG:" << name;
#endif
match.setText(name);
match.setData(service->storageId());
if (!service->genericName().isEmpty() && service->genericName() != name)
match.setSubtext(service->genericName());
else if (!service->comment().isEmpty())
match.setSubtext(service->comment());
if (!service->icon().isEmpty())
match.setIcon(QIcon::fromTheme(service->icon()));
match.setRelevance(1);
matches << match;
seen.insert(service->storageId());
seen.insert(service->exec());
}
}
}
void CfgComponent::load(KConfig *cfg) {
ComponentSelector->clear();
m_lookupDict.clear();
m_revLookupDict.clear();
const KConfigGroup mainGroup = cfg->group(QByteArray());
const QString serviceTypeToConfigure = mainGroup.readEntry("ServiceTypeToConfigure");
const KService::List offers = KServiceTypeTrader::self()->query(serviceTypeToConfigure);
for (KService::List::const_iterator tit = offers.begin(); tit != offers.end(); ++tit) {
ComponentSelector->addItem((*tit)->name());
m_lookupDict.insert((*tit)->name(), (*tit)->desktopEntryName());
m_revLookupDict.insert((*tit)->desktopEntryName(), (*tit)->name());
}
KConfig store(mainGroup.readPathEntry("storeInFile","null"));
const KConfigGroup group(&store, mainGroup.readEntry("valueSection"));
QString setting = group.readEntry(mainGroup.readEntry("valueName","kcm_componenchooser_null"), QString());
if (setting.isEmpty())
setting = mainGroup.readEntry("defaultImplementation", QString());
QString tmp = m_revLookupDict.value(setting);
if (!tmp.isEmpty()) {
for (int i=0;i<ComponentSelector->count();i++)
if (tmp==ComponentSelector->itemText(i))
{
ComponentSelector->setCurrentIndex(i);
break;
}
}
emit changed(false);
}
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());
}
KServiceSelectDlg::KServiceSelectDlg(const QString & /*serviceType*/, const QString & /*value*/, QWidget *parent)
: KDialogBase(parent, "serviceSelectDlg", true, i18n("Add Service"), Ok | Cancel, Ok)
{
QVBox *vbox = new QVBox(this);
vbox->setSpacing(KDialog::spacingHint());
new QLabel(i18n("Select service:"), vbox);
m_listbox = new KListBox(vbox);
// Can't make a KTrader query since we don't have a servicetype to give,
// we want all services that are not applications.......
// So we have to do it the slow way
// ### Why can't we query for KParts/ReadOnlyPart as the servicetype? Should work fine!
KService::List allServices = KService::allServices();
QValueListIterator< KService::Ptr > it(allServices.begin());
for(; it != allServices.end(); ++it)
if((*it)->hasServiceType("KParts/ReadOnlyPart"))
{
m_listbox->insertItem(new KServiceListItem((*it), KServiceListWidget::SERVICELIST_SERVICES));
}
m_listbox->sort();
m_listbox->setMinimumHeight(350);
m_listbox->setMinimumWidth(300);
connect(m_listbox, SIGNAL(doubleClicked(QListBoxItem *)), SLOT(slotOk()));
setMainWidget(vbox);
}
void KIMProxy::registeredToDCOP( const TQCString& appId )
{
//kdDebug( 790 ) << k_funcinfo << " appId '" << appId << "'" << endl;
// check that appId implements our service
// if the appId ends with a number, i.e. a pid like in foobar-12345,
if ( appId.isEmpty() )
return;
bool newApp = false;
// get an up to date list of offers in case a new app was installed
// and check each of the offers that implement the service type we're looking for,
// to see if any of them are the app that just registered
const KService::List offers = KServiceType::offers( IM_SERVICE_TYPE );
KService::List::const_iterator it;
for ( it = offers.begin(); it != offers.end(); ++it )
{
TQCString dcopObjectId = "KIMIface";
TQCString dcopService = (*it)->property("X-DCOP-ServiceName").toString().latin1();
if ( appId.left( dcopService.length() ) == dcopService )
{
// if it's not already known, insert it
if ( !m_im_client_stubs.find( appId ) )
{
newApp = true;
kdDebug( 790 ) << "App: " << appId << ", dcopService: " << dcopService << " started, using it for presence info."<< endl;
m_im_client_stubs.insert( appId, new KIMIface_stub( d->dc, appId, dcopObjectId ) );
}
}
//else
// kdDebug( 790 ) << "App doesn't implement our ServiceType" << endl;
}
//if ( newApp )
// emit sigPresenceInfoExpired();
}
ToggleViewGUIClient::ToggleViewGUIClient( KonqMainWindow *mainWindow )
: QObject( mainWindow )
{
m_mainWindow = mainWindow;
KService::List offers = KServiceTypeTrader::self()->query( "Browser/View" );
KService::List::Iterator it = offers.begin();
while ( it != offers.end() )
{
QVariant prop = (*it)->property( "X-KDE-BrowserView-Toggable" );
QVariant orientation = (*it)->property( "X-KDE-BrowserView-ToggableView-Orientation" );
if ( !prop.isValid() || !prop.toBool() ||
!orientation.isValid() || orientation.toString().isEmpty() )
{
offers.erase( it );
it = offers.begin();
}
else
++it;
}
m_empty = ( offers.count() == 0 );
if ( m_empty )
return;
KService::List::ConstIterator cIt = offers.constBegin();
KService::List::ConstIterator cEnd = offers.constEnd();
for (; cIt != cEnd; ++cIt )
{
QString description = i18n( "Show %1" , (*cIt)->name() );
QString name = (*cIt)->desktopEntryName();
//kDebug() << "ToggleViewGUIClient: name=" << name;
KToggleAction *action = new KToggleAction( description, this );
mainWindow->actionCollection()->addAction( name.toLatin1(), action );
// HACK
if ( (*cIt)->icon() != "unknown" )
action->setIcon( KIcon((*cIt)->icon()) );
connect( action, SIGNAL(toggled(bool)),
this, SLOT(slotToggleView(bool)) );
m_actions.insert( name, action );
QVariant orientation = (*cIt)->property( "X-KDE-BrowserView-ToggableView-Orientation" );
bool horizontal = orientation.toString().toLower() == "horizontal";
m_mapOrientation.insert( name, horizontal );
}
connect( m_mainWindow, SIGNAL(viewAdded(KonqView*)),
this, SLOT(slotViewAdded(KonqView*)) );
connect( m_mainWindow, SIGNAL(viewRemoved(KonqView*)),
this, SLOT(slotViewRemoved(KonqView*)) );
}
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;
}
}
}
QList<KPluginInfo> KPluginInfo::fromServices(const KService::List &services, const KConfigGroup &config)
{
QList<KPluginInfo> infolist;
for( KService::List::ConstIterator it = services.begin();
it != services.end(); ++it )
{
KPluginInfo info(*it);
info.setConfig(config);
infolist += info;
}
return infolist;
}
DataObjectPtr DataObject::createPlugin(const QString& name) {
#if 0
KService::List sl = KServiceTypeTrader::self()->query("Kst Data Object");
for (KService::List::ConstIterator it = sl.begin(); it != sl.end(); ++it) {
if ((*it)->name() != name) {
continue;
} else if (DataObjectPtr object = createPlugin(*it)) {
return object;
}
}
#endif
return 0L;
}
MainWindow::OfferType MainWindow::ExternalPopup::appInfos(const DB::FileNameList& files )
{
StringSet types = mimeTypes( files );
OfferType res;
for ( StringSet::const_iterator mimeTypeIt = types.begin(); mimeTypeIt != types.end(); ++mimeTypeIt ) {
KService::List offers = KMimeTypeTrader::self()->query( *mimeTypeIt, QLatin1String( "Application" ));
for(KService::List::Iterator offerIt = offers.begin(); offerIt != offers.end(); ++offerIt) {
res.insert( qMakePair( (*offerIt)->name(), (*offerIt)->icon() ) );
_appToMimeTypeMap[(*offerIt)->name()].insert( *mimeTypeIt );
}
}
return res;
}
static void addUnique(KService::List &lst, QDict< KService > &dict, const KService::List &newLst, bool lowPrio)
{
QValueListConstIterator< KService::Ptr > it = newLst.begin();
for(; it != newLst.end(); ++it)
{
KService *service = static_cast< KService * >(*it);
if(dict.find(service->desktopEntryPath()))
continue;
dict.insert(service->desktopEntryPath(), service);
lst.append(service);
if(lowPrio)
service->setInitialPreference(0);
}
}
bool KIMProxy::initialize()
{
if ( !m_initialized )
{
m_initialized = true; // we should only do this once, as registeredToDCOP() will catch any new starts
// So there is no error from a failed query when using tdelibs 3.2, which don't have this servicetype
if ( KServiceType::serviceType( IM_SERVICE_TYPE ) )
{
//kdDebug( 790 ) << k_funcinfo << endl;
TQCString dcopObjectId = "KIMIface";
// see what apps implementing our service type are out there
KService::List offers = KServiceType::offers( IM_SERVICE_TYPE );
KService::List::iterator offer;
typedef TQValueList<TQCString> QCStringList;
QCStringList registeredApps = d->dc->registeredApplications();
QCStringList::iterator app;
const QCStringList::iterator end = registeredApps.end();
// for each registered app
for ( app = registeredApps.begin(); app != end; ++app )
{
//kdDebug( 790 ) << " considering: " << *app << endl;
//for each offer
for ( offer = offers.begin(); offer != offers.end(); ++offer )
{
TQCString dcopService = (*offer)->property("X-DCOP-ServiceName").toString().latin1();
if ( !dcopService.isEmpty() )
{
//kdDebug( 790 ) << " is it: " << dcopService << "?" << endl;
// get the application name ( minus any process ID )
TQCString instanceName = (*app).left( dcopService.length() );
// if the application implements the dcop service, add it
if ( instanceName == dcopService )
{
m_apps_available = true;
//kdDebug( 790 ) << " app name: " << (*offer)->name() << ", has instance " << *app << ", dcopService: " << dcopService << endl;
if ( !m_im_client_stubs.find( dcopService ) )
{
kdDebug( 790 ) << "App " << *app << ", dcopObjectId " << dcopObjectId << " found, using it for presence info." << endl;
m_im_client_stubs.insert( *app, new KIMIface_stub( d->dc, *app, dcopObjectId ) );
pollApp( *app );
}
}
}
}
}
}
}
return !m_im_client_stubs.isEmpty();
}
KService::List FileOperation::servicesForOpenWith(const QList<QUrl>& urls)
{
// This code is inspired by KonqMenuActions:
// kdebase/apps/lib/konq/konq_menuactions.cpp
QStringList mimeTypes;
KService::List offers;
foreach(const QUrl& item, urls)
{
const QString mimeType = QMimeDatabase().mimeTypeForFile(item.path(), QMimeDatabase::MatchExtension).name();
if (!mimeTypes.contains(mimeType))
{
mimeTypes << mimeType;
}
}
if (!mimeTypes.isEmpty())
{
// Query trader
const QString firstMimeType = mimeTypes.takeFirst();
const QString constraintTemplate = QLatin1String("'%1' in ServiceTypes");
QStringList constraints;
foreach(const QString& mimeType, mimeTypes)
{
constraints << constraintTemplate.arg(mimeType);
}
offers = KMimeTypeTrader::self()->query(firstMimeType, QLatin1String("Application"), constraints.join(QLatin1String(" and ")));
// remove duplicate service entries
QSet<QString> seenApps;
for (KService::List::iterator it = offers.begin(); it != offers.end();)
{
const QString appName((*it)->name());
if (!seenApps.contains(appName))
{
seenApps.insert(appName);
++it;
}
else
{
it = offers.erase(it);
}
}
}
void KonqPopupMenuPrivate::addPlugins()
{
QString commonMimeType = m_popupItemProperties.mimeType();
if (commonMimeType.isEmpty()) {
commonMimeType = QLatin1String("application/octet-stream");
}
const KService::List konqPlugins = KMimeTypeTrader::self()->query(commonMimeType, "KonqPopupMenu/Plugin", "exist Library");
if (!konqPlugins.isEmpty()) {
m_popupMenuInfo.setItemListProperties(m_popupItemProperties);
m_popupMenuInfo.setParentWidget(m_parentWidget);
KService::List::ConstIterator iterator = konqPlugins.begin();
const KService::List::ConstIterator end = konqPlugins.end();
for(; iterator != end; ++iterator) {
//kDebug() << (*iterator)->name() << (*iterator)->library();
KonqPopupMenuPlugin *plugin = (*iterator)->createInstance<KonqPopupMenuPlugin>(q);
if (!plugin)
continue;
plugin->setParent(q);
plugin->setup(&m_ownActionCollection, m_popupMenuInfo, q);
}
}
const KService::List fileItemPlugins = KMimeTypeTrader::self()->query(commonMimeType, "KFileItemAction/Plugin", "exist Library");
if (!fileItemPlugins.isEmpty()) {
const KConfig config("kservicemenurc", KConfig::NoGlobals);
const KConfigGroup showGroup = config.group("Show");
foreach (const KSharedPtr<KService>& service, fileItemPlugins) {
if (!showGroup.readEntry(service->desktopEntryName(), true)) {
// The plugin has been disabled
continue;
}
// Old API (kdelibs-4.6.0 only)
KFileItemActionPlugin* plugin = service->createInstance<KFileItemActionPlugin>();
if (plugin) {
plugin->setParent(q);
q->addActions(plugin->actions(m_popupItemProperties, m_parentWidget));
}
// New API (kdelibs >= 4.6.1)
KAbstractFileItemActionPlugin* abstractPlugin = service->createInstance<KAbstractFileItemActionPlugin>();
if (abstractPlugin) {
abstractPlugin->setParent(q);
q->addActions(abstractPlugin->actions(m_popupItemProperties, m_parentWidget));
}
}
}
}
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 );
}
}
}
void BackendSelection::loadServices(const KService::List &offers)
{
m_services.clear();
m_select->clear();
KService::List::const_iterator it = offers.begin();
const KService::List::const_iterator end = offers.end();
for (; it != end; ++it)
{
KService::Ptr service = *it;
m_select->addItem(service->name());
m_services[service->name()] = service;
}
m_select->setItemSelected(m_select->item(0), true);
}
// Helper method for all the trader tests
static bool offerListHasService(const KService::List &offers,
const QString &entryPath)
{
bool found = false;
KService::List::const_iterator it = offers.begin();
for (; it != offers.end(); ++it) {
if ((*it)->entryPath() == entryPath) {
if (found) { // should be there only once
qWarning("ERROR: %s was found twice in the list", qPrintable(entryPath));
return false; // make test fail
}
found = true;
}
}
return found;
}
PopupMenuGUIClient::PopupMenuGUIClient( const KService::List &embeddingServices,
KParts::BrowserExtension::ActionGroupMap& actionGroups,
QAction* showMenuBar, QAction* stopFullScreen )
: m_actionCollection(this),
m_embeddingServices(embeddingServices)
{
QList<QAction *> topActions;
if (showMenuBar) {
topActions.append(showMenuBar);
KAction* separator = new KAction(&m_actionCollection);
separator->setSeparator(true);
topActions.append(separator);
}
if (stopFullScreen) {
topActions.append(stopFullScreen);
KAction* separator = new KAction(&m_actionCollection);
separator->setSeparator(true);
topActions.append(separator);
}
if (!embeddingServices.isEmpty()) {
QList<QAction *> previewActions;
if (embeddingServices.count() == 1) {
KService::Ptr service = embeddingServices.first();
QAction* act = addEmbeddingService( 0, i18n( "Preview &in %1", service->name() ), service );
previewActions.append(act);
} else if (embeddingServices.count() > 1) {
KService::List::ConstIterator it = embeddingServices.begin();
const KService::List::ConstIterator end = embeddingServices.end();
int idx = 0;
for (; it != end; ++it, ++idx ) {
QAction* act = addEmbeddingService( idx, (*it)->name(), *it );
previewActions.append(act);
}
}
actionGroups.insert("preview", previewActions);
}
actionGroups.insert("topactions", topActions);
}
void KInetD::loadServiceList()
{
m_portListeners.clear();
KService::List kinetdModules =
KServiceType::offers("KInetDModule");
for(KService::List::ConstIterator it = kinetdModules.begin();
it != kinetdModules.end();
it++) {
KService::Ptr s = *it;
PortListener *pl = new PortListener(s, m_config, m_srvreg);
if (pl->isValid())
m_portListeners.append(pl);
else
delete pl;
}
setExpirationTimer();
setPortRetryTimer(true);
setReregistrationTimer();
}
// Scans for plugins and stores the information for them in "pluginInfo"
static void scanPlugins() {
KST::PluginInfoList tmpList;
KstDebug::self()->log(i18n("Scanning for data-source plugins."));
KService::List sl = KServiceType::offers("Kst Data Source");
for (KService::List::ConstIterator it = sl.begin(); it != sl.end(); ++it) {
for (KST::PluginInfoList::ConstIterator i2 = pluginInfo.begin(); i2 != pluginInfo.end(); ++i2) {
if ((*i2)->service == *it) {
tmpList.append(*i2);
continue;
}
}
KstSharedPtr<KST::Plugin> p = new KST::Plugin(*it);
tmpList.append(p);
}
// This cleans up plugins that have been uninstalled and adds in new ones.
// Since it is a shared pointer it can't dangle anywhere.
pluginInfo = tmpList;
}
void RecordItNowPluginManager::loadInfos(const QString &type)
{
KConfig cfg("recorditnowrc");
KConfigGroup pCfg(&cfg, "Plugins");
KService::List offers = KServiceTypeTrader::self()->query(type);
KService::List::const_iterator iter;
for (iter = offers.begin(); iter < offers.end(); ++iter) {
KService::Ptr service = *iter;
KPluginInfo info(service);
if (!info.isValid()) {
kWarning() << "invalid plugin info:" << service->entryPath();
continue;
} else {
info.setConfig(pCfg);
info.load(pCfg);
m_plugins[info] = 0;
}
}
}
void KateProjectTreeViewContextMenu::exec(const QString &filename, const QPoint &pos, QWidget *parent)
{
/**
* create context menu
*/
QMenu menu;
QAction *copyAction = menu.addAction(QIcon::fromTheme(QStringLiteral("edit-copy")), i18n("Copy Filename"));
/**
* handle "open with"
* find correct mimetype to query for possible applications
*/
QMenu *openWithMenu = menu.addMenu(i18n("Open With"));
QMimeType mimeType = QMimeDatabase().mimeTypeForFile(filename);
KService::List offers = KMimeTypeTrader::self()->query(mimeType.name(), QStringLiteral("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() == QStringLiteral("Kate")) {
continue; // omit Kate
}
QAction *action = openWithMenu->addAction(QIcon::fromTheme(service->icon()), service->name());
action->setData(service->entryPath());
}
/**
* perhaps disable menu, if no entries!
*/
openWithMenu->setEnabled(!openWithMenu->isEmpty());
KMoreToolsMenuFactory menuFactory(QLatin1String("kate/addons/project/git-tools"));
QMenu gitMenu; // must live as long as the maybe filled menu items should live
if (isGit(filename)) {
menuFactory.fillMenuFromGroupingNames(&gitMenu, { QLatin1String("git-clients-and-actions") },
QUrl::fromLocalFile(filename));
menu.addSection(i18n("Git:"));
Q_FOREACH(auto action, gitMenu.actions()) {
menu.addAction(action);
}
}
/**
* run menu and handle the triggered action
*/
if (QAction *action = menu.exec(pos)) {
// handle apps
if (copyAction == action) {
QApplication::clipboard()->setText(filename);
} else {
// handle "open with"
const QString openWith = action->data().toString();
if (KService::Ptr app = KService::serviceByDesktopPath(openWith)) {
QList<QUrl> list;
list << QUrl::fromLocalFile(filename);
KRun::runService(*app, list, parent);
}
}
}
}
void ConnectionEditor::initializeMenu()
{
m_menu = new KActionMenu(QIcon::fromTheme(QStringLiteral("list-add")), i18n("Add"), this);
m_menu->menu()->setSeparatorsCollapsible(false);
m_menu->setDelayed(false);
m_menu->menu()->addSection(i18n("Hardware"));
// TODO Adsl
QAction * action = new QAction(i18n("DSL"), this);
action->setData(NetworkManager::ConnectionSettings::Pppoe);
m_menu->addAction(action);
action = new QAction(i18n("InfiniBand"), this);
action->setData(NetworkManager::ConnectionSettings::Infiniband);
m_menu->addAction(action);
#if WITH_MODEMMANAGER_SUPPORT
action = new QAction(i18n("Mobile Broadband..."), this);
action->setData(NetworkManager::ConnectionSettings::Gsm);
m_menu->addAction(action);
#endif
action = new QAction(i18n("Wired Ethernet"), this);
action->setData(NetworkManager::ConnectionSettings::Wired);
action->setProperty("shared", false);
m_menu->addAction(action);
action = new QAction(i18n("Wired Ethernet (shared)"), this);
action->setData(NetworkManager::ConnectionSettings::Wired);
action->setProperty("shared", true);
m_menu->addAction(action);
action = new QAction(i18n("Wi-Fi"), this);
action->setData(NetworkManager::ConnectionSettings::Wireless);
action->setProperty("shared", false);
m_menu->addAction(action);
action = new QAction(i18n("Wi-Fi (shared)"), this);
action->setData(NetworkManager::ConnectionSettings::Wireless);
action->setProperty("shared", true);
m_menu->addAction(action);
action = new QAction(i18n("WiMAX"), this);
action->setData(NetworkManager::ConnectionSettings::Wimax);
m_menu->addAction(action);
m_menu->menu()->addSection(i18nc("Virtual hardware devices, eg Bridge, Bond", "Virtual"));
action = new QAction(i18n("Bond"), this);
action->setData(NetworkManager::ConnectionSettings::Bond);
m_menu->addAction(action);
action = new QAction(i18n("Bridge"), this);
action->setData(NetworkManager::ConnectionSettings::Bridge);
m_menu->addAction(action);
action = new QAction(i18n("VLAN"), this);
action->setData(NetworkManager::ConnectionSettings::Vlan);
m_menu->addAction(action);
#if NM_CHECK_VERSION(0, 9, 10)
action = new QAction(i18n("Team"), this);
action->setData(NetworkManager::ConnectionSettings::Team);
m_menu->addAction(action);
#endif
m_menu->menu()->addSection(i18n("VPN"));
KService::List services = KServiceTypeTrader::self()->query("PlasmaNetworkManagement/VpnUiPlugin");
std::sort(services.begin(), services.end(), [] (const KService::Ptr &left, const KService::Ptr &right)
{
return QString::localeAwareCompare(left->name(), right->name()) <= 0;
});
Q_FOREACH (const KService::Ptr & service, services) {
qCDebug(PLASMA_NM) << "Found VPN plugin" << service->name() << ", type:" << service->property("X-NetworkManager-Services", QVariant::String).toString();
const QString vpnSubType = service->property("X-NetworkManager-Services-Subtype", QVariant::String).toString();
action = new QAction(service->name(), this);
action->setData(NetworkManager::ConnectionSettings::Vpn);
action->setProperty("type", service->property("X-NetworkManager-Services", QVariant::String));
if (!vpnSubType.isEmpty()) {
action->setProperty("subtype", vpnSubType);
}
m_menu->addAction(action);
}
KstApp::KstApp(QWidget *parent, const char* name)
: KMainWindow(parent, name) {
clearWFlags(WDestructiveClose);
stopping = false;
config = kapp->config();
initStatusBar();
initDocument();
initView();
/* create dialogs */
debugDialog = new KstDebugDialogI(this);
plotDialog = new KstPlotDialogI(doc, this);
dataManager = new KstDataManagerI(doc, this);
filterListEditor = new FilterListEditor(this);
viewScalarsDialog = new KstViewScalarsDialogI(this);
viewVectorsDialog = new KstViewVectorsDialogI(this);
changeFileDialog = new KstChangeFileDialogI(this);
changeNptsDialog = new KstChangeNptsDialogI(this);
quickCurvesDialog = new KstQuickCurvesDialogI(this);
quickPSDDialog = new KstQuickPSDDialogI(this);
graphFileDialog = new KstGraphFileDialogI(this);
vectorSaveDialog = new VectorSaveDialog(this);
connect(KstVectorDialogI::globalInstance(), SIGNAL(modified()), doc, SLOT(wasModified()));
connect(KstCurveDialogI::globalInstance(), SIGNAL(modified()), doc, SLOT(wasModified()));
connect(KstEqDialogI::globalInstance(), SIGNAL(modified()), doc, SLOT(wasModified()));
connect(KstHsDialogI::globalInstance(), SIGNAL(modified()), doc, SLOT(wasModified()));
connect(KstPsdDialogI::globalInstance(), SIGNAL(modified()), doc, SLOT(wasModified()));
connect(KstPluginDialogI::globalInstance(), SIGNAL(modified()), doc, SLOT(wasModified()));
connect(KstEventMonitorI::globalInstance(), SIGNAL(modified()), doc, SLOT(wasModified()));
initActions();
readOptions();
_updateThread = new UpdateThread(doc);
_updateThread->setUpdateTime(KstSettings::globalSettings()->plotUpdateTimer);
_updateThread->start();
connect(doc, SIGNAL(newFrameMsg(int)),
this, SLOT(slotUpdateFrameMsg(int)));
connect(view, SIGNAL(newStatusMsg(const QString &)),
this, SLOT(slotUpdateStatusMsg(const QString &)));
connect(view, SIGNAL(newDataMsg(const QString &)),
this, SLOT(slotUpdateDataMsg(const QString &)));
/*** Plot Dialog signals */
connect(changeFileDialog, SIGNAL(docChanged()),
this, SLOT(registerDocChange()));
connect(changeNptsDialog, SIGNAL(docChanged()),
this, SLOT(registerDocChange()));
connect(quickCurvesDialog,SIGNAL(docChanged()),
this, SLOT(registerDocChange()));
connect(quickPSDDialog, SIGNAL(docChanged()),
this, SLOT(registerDocChange()));
connect(filterListEditor, SIGNAL(docChanged()),
this, SLOT(registerDocChange()));
connect(graphFileDialog, SIGNAL(graphFileReq(const QString &,int,int)),
view, SLOT(printToGraphicsFile(const QString &,int,int)));
/*** label dialog ***/
connect(view->labelDialog, SIGNAL(applied()),
this, SLOT(registerDocChange()));
/*** plot dialog ***/
connect(plotDialog, SIGNAL(docChanged()), this, SLOT(registerDocChange()));
/*** ***/
connect(doc, SIGNAL(dataChanged()), this, SLOT(updateDialogs()));
connect(dataManager, SIGNAL(editDataVector(const QString &)),
KstVectorDialogI::globalInstance(), SLOT(show_I(const QString &)));
connect(dataManager->OpenPlotDialog, SIGNAL(clicked()),
this, SLOT(showPlotDialog()));
setAutoSaveSettings("KST-KMainWindow", true);
_dcopIface = new KstIfaceImpl(doc, this);
view->forceUpdate();
connect(this, SIGNAL(settingsChanged()), this, SLOT(slotSettingsChanged()));
QTimer::singleShot(0, this, SLOT(updateActions()));
// Load any extensions
ExtensionMgr *mgr = ExtensionMgr::self();
mgr->setWindow(this);
KService::List sl = KServiceType::offers("Kst Extension");
for (KService::List::ConstIterator it = sl.begin(); it != sl.end(); ++it) {
KService::Ptr service = *it;
QString name = service->property("Name").toString();
if (!mgr->enabled(name) && !service->property("X-Kst-Enabled").toBool()) {
continue;
}
mgr->loadExtension(service);
}
}