kio/kio/kurifilter.cpp

   1 /* This file is part of the KDE libraries
   2  *  Copyright (C) 2000 Yves Arrouye <yves@realnames.com>
   3  *  Copyright (C) 2000 Dawit Alemayehu <adawit at kde.org>
   4  *
   5  *  This library is free software; you can redistribute it and/or
   6  *  modify it under the terms of the GNU Library General Public
   7  *  License as published by the Free Software Foundation; either
   8  *  version 2 of the License, or (at your option) any later version.
   9  *
  10  *  This library is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  *  Library General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU Library General Public License
  16  *  along with this library; see the file COPYING.LIB.  If not, write to
  17  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  *  Boston, MA 02110-1301, USA.
  19  **/
  20
  21 #include "kurifilter.h"
  22
  23 #include <config.h>
  24 #include <QPixmap>
  25
  26 #include <kdebug.h>
  27 #include <kiconloader.h>
  28 #include <kservicetypetrader.h>
  29 #include <kmimetype.h>
  30
  31 typedef QList<KUriFilterPlugin *> KUriFilterPluginList;
  32
  33 class KUriFilterDataPrivate
  34 {
  35 public:
  36     explicit KUriFilterDataPrivate( const KUrl& url, const QString& typedUrl ) :
  37         bCheckForExecutables(true),
  38         bChanged(true),
  39         pURI(url),
  40         iType(KUriFilterData::Unknown),
  41         typedString(typedUrl)
  42     {
  43     }
  44     void setData( const KUrl& url, const QString& typedUrl )
  45     {
  46         bCheckForExecutables = true;
  47         bChanged = true;
  48         strErrMsg.clear();
  49         strIconName.clear();
  50         pURI = url;
  51         iType = KUriFilterData::Unknown;
  52         typedString = typedUrl;
  53     }
  54     KUriFilterDataPrivate( KUriFilterDataPrivate * data )
  55     {
  56         iType = data->iType;
  57         pURI = data->pURI;
  58         strErrMsg = data->strErrMsg;
  59         strIconName = data->strIconName;
  60         bChanged = data->bChanged;
  61         bCheckForExecutables = data->bCheckForExecutables;
  62         abs_path = data->abs_path;
  63         typedString = data->typedString;
  64         args = data->args;
  65     }
  66     bool bCheckForExecutables;
  67     bool bChanged;
  68
  69     QString strErrMsg;
  70     QString strIconName;
  71
  72     KUrl pURI;
  73     KUriFilterData::UriTypes iType;
  74
  75     QString abs_path;
  76     QString args;
  77     QString typedString;
  78 };
  79
  80 KUriFilterData::KUriFilterData()
  81     : d( new KUriFilterDataPrivate( KUrl(), QString() ) )
  82 {
  83 }
  84
  85 KUriFilterData::KUriFilterData( const KUrl& url )
  86     : d( new KUriFilterDataPrivate( url, url.url() ) )
  87 {
  88 }
  89
  90 KUriFilterData::KUriFilterData( const QString& url )
  91     : d( new KUriFilterDataPrivate( KUrl(url), url ) )
  92 {
  93     d->typedString = url;
  94 }
  95
  96
  97 KUriFilterData::KUriFilterData( const KUriFilterData& data )
  98     : d( new KUriFilterDataPrivate( data.d ) )
  99 {
 100 }
 101
 102 KUriFilterData::~KUriFilterData()
 103 {
 104     delete d;
 105 }
 106
 107 KUrl KUriFilterData::uri() const
 108 {
 109     return d->pURI;
 110 }
 111
 112 QString KUriFilterData::errorMsg() const
 113 {
 114     return d->strErrMsg;
 115 }
 116
 117 KUriFilterData::UriTypes KUriFilterData::uriType() const
 118 {
 119     return d->iType;
 120 }
 121
 122 void KUriFilterData::setData( const KUrl& url )
 123 {
 124     d->setData(url, url.url());
 125 }
 126
 127 void KUriFilterData::setData( const QString& url )
 128 {
 129     d->setData(KUrl(url), url);
 130 }
 131
 132 bool KUriFilterData::setAbsolutePath( const QString& absPath )
 133 {
 134     // Since a malformed URL could possibly be a relative
 135     // URL we tag it as a possible local resource...
 136     if( (d->pURI.protocol().isEmpty() || d->pURI.isLocalFile()) )
 137     {
 138         d->abs_path = absPath;
 139         return true;
 140     }
 141     return false;
 142 }
 143
 144 QString KUriFilterData::absolutePath() const
 145 {
 146     return d->abs_path;
 147 }
 148
 149 bool KUriFilterData::hasAbsolutePath() const
 150 {
 151     return !d->abs_path.isEmpty();
 152 }
 153
 154 QString KUriFilterData::argsAndOptions() const
 155 {
 156     return d->args;
 157 }
 158
 159 bool KUriFilterData::hasArgsAndOptions() const
 160 {
 161     return !d->args.isEmpty();
 162 }
 163
 164 QString KUriFilterData::iconName()
 165 {
 166     if( d->bChanged )
 167     {
 168         switch ( d->iType )
 169         {
 170             case KUriFilterData::LocalFile:
 171             case KUriFilterData::LocalDir:
 172             case KUriFilterData::NetProtocol:
 173             {
 174                 d->strIconName = KMimeType::iconNameForUrl( d->pURI );
 175                 break;
 176             }
 177             case KUriFilterData::Executable:
 178             {
 179                 QString exeName = d->pURI.url();
 180                 exeName = exeName.mid( exeName.lastIndexOf( '/' ) + 1 ); // strip path if given
 181                 KService::Ptr service = KService::serviceByDesktopName( exeName );
 182                 if (service && service->icon() != QLatin1String( "unknown" ))
 183                     d->strIconName = service->icon();
 184                 // Try to find an icon with the same name as the binary (useful for non-kde apps)
 185                 else if ( !KIconLoader::global()->loadIcon( exeName, KIconLoader::NoGroup, 16, KIconLoader::DefaultState, QStringList(), 0, true ).isNull() )
 186                     d->strIconName = exeName;
 187                 else
 188                     // not found, use default
 189                     d->strIconName = QLatin1String("system-run");
 190                 break;
 191             }
 192             case KUriFilterData::Help:
 193             {
 194                 d->strIconName = QLatin1String("khelpcenter");
 195                 break;
 196             }
 197             case KUriFilterData::Shell:
 198             {
 199                 d->strIconName = QLatin1String("konsole");
 200                 break;
 201             }
 202             case KUriFilterData::Error:
 203             case KUriFilterData::Blocked:
 204             {
 205                 d->strIconName = QLatin1String("error");
 206                 break;
 207             }
 208             default:
 209                 d->strIconName.clear();
 210                 break;
 211         }
 212         d->bChanged = false;
 213     }
 214     return d->strIconName;
 215 }
 216
 217 void KUriFilterData::setCheckForExecutables( bool check )
 218 {
 219     d->bCheckForExecutables = check;
 220 }
 221
 222 bool KUriFilterData::checkForExecutables() const
 223 {
 224     return d->bCheckForExecutables;
 225 }
 226
 227 QString KUriFilterData::typedString() const
 228 {
 229     return d->typedString;
 230 }
 231
 232 KUriFilterData& KUriFilterData::operator=( const KUrl& url )
 233 {
 234     d->setData(url, url.url());
 235     return *this;
 236 }
 237
 238 KUriFilterData& KUriFilterData::operator=( const QString& url )
 239 {
 240     d->setData(KUrl(url), url);
 241     return *this;
 242 }
 243
 244 /*************************  KUriFilterPlugin ******************************/
 245
 246 KUriFilterPlugin::KUriFilterPlugin( const QString & name, QObject *parent )
 247     : QObject( parent ), d( 0 )
 248 {
 249     setObjectName( name );
 250 }
 251
 252 KCModule *KUriFilterPlugin::configModule( QWidget*, const char* ) const
 253 {
 254     return 0;
 255 }
 256
 257 QString KUriFilterPlugin::configName() const
 258 {
 259     return objectName();
 260 }
 261
 262 void KUriFilterPlugin::setFilteredUri( KUriFilterData& data, const KUrl& uri ) const
 263 {
 264     if ( data.uri() != uri )
 265     {
 266         data.d->pURI = uri;
 267         data.d->bChanged = true;
 268     }
 269 }
 270
 271 void KUriFilterPlugin::setErrorMsg ( KUriFilterData& data,
 272                                      const QString& errmsg ) const
 273 {
 274     data.d->strErrMsg = errmsg;
 275 }
 276
 277 void KUriFilterPlugin::setUriType ( KUriFilterData& data,
 278                                     KUriFilterData::UriTypes type) const
 279 {
 280     data.d->iType = type;
 281     data.d->bChanged = true;
 282 }
 283
 284 void KUriFilterPlugin::setArguments( KUriFilterData& data,
 285                                      const QString& args ) const
 286 {
 287     data.d->args = args;
 288 }
 289
 290 /*******************************  KUriFilter ******************************/
 291
 292 class KUriFilterPrivate
 293 {
 294 public:
 295     KUriFilterPrivate() {}
 296     ~KUriFilterPrivate()
 297     {
 298         qDeleteAll(lstPlugins);
 299     }
 300     QList<KUriFilterPlugin *> lstPlugins;
 301 };
 302
 303 KUriFilter *KUriFilter::self()
 304 {
 305     K_GLOBAL_STATIC(KUriFilter, m_self)
 306     return m_self;
 307 }
 308
 309 KUriFilter::KUriFilter()
 310     : d(new KUriFilterPrivate())
 311 {
 312     loadPlugins();
 313 }
 314
 315 KUriFilter::~KUriFilter()
 316 {
 317     delete d;
 318 }
 319
 320 static KUriFilterPlugin* findPluginByName( const KUriFilterPluginList& lst, const QString& name )
 321 {
 322     for ( KUriFilterPluginList::const_iterator it = lst.begin(), end = lst.end();
 323           it != end ; ++it ) {
 324         if ( (*it)->objectName() == name )
 325             return *it;
 326     }
 327     return 0;
 328 }
 329
 330 bool KUriFilter::filterUri( KUriFilterData& data, const QStringList& filters )
 331 {
 332     KUriFilterPluginList use_plugins;
 333
 334     // If we have a filter list, only include the once
 335     // explicitly specified by it. Otherwise, use all available filters...
 336     if( filters.isEmpty() )
 337         use_plugins = d->lstPlugins;  // Use everything that is loaded...
 338     else {
 339         //kDebug() << "Named plugins requested...";
 340         for( QStringList::ConstIterator lst = filters.begin(); lst != filters.end(); ++lst ) {
 341             KUriFilterPlugin* plugin = findPluginByName( d->lstPlugins, *lst );
 342             if (plugin) {
 343                 //kDebug() << "Will use filter plugin named: " << plugin->objectName();
 344                 use_plugins.append(plugin);
 345             }
 346         }
 347     }
 348
 349     //kDebug() << "Using" << use_plugins.count() << "out of the"
 350     //          << d->lstPlugins.count() << "available plugins";
 351     bool filtered = false;
 352     for ( KUriFilterPluginList::const_iterator it = use_plugins.constBegin(), end = use_plugins.constEnd();
 353           it != end; ++it ) {
 354         //kDebug() << "Using a filter plugin named: " << (*it)->objectName();
 355         if( (*it)->filterUri( data ))
 356             filtered = true;
 357     }
 358     return filtered;
 359 }
 360
 361 bool KUriFilter::filterUri( KUrl& uri, const QStringList& filters )
 362 {
 363     KUriFilterData data(uri);
 364     bool filtered = filterUri( data, filters );
 365     if( filtered ) uri = data.uri();
 366     return filtered;
 367 }
 368
 369 bool KUriFilter::filterUri( QString& uri, const QStringList& filters )
 370 {
 371     KUriFilterData data(uri);
 372     bool filtered = filterUri( data, filters );
 373     if( filtered )  uri = data.uri().url();
 374     return filtered;
 375 }
 376
 377 KUrl KUriFilter::filteredUri( const KUrl &uri, const QStringList& filters )
 378 {
 379     KUriFilterData data(uri);
 380     filterUri( data, filters );
 381     return data.uri();
 382 }
 383
 384 QString KUriFilter::filteredUri( const QString &uri, const QStringList& filters )
 385 {
 386     KUriFilterData data(uri);
 387     filterUri( data, filters );
 388     return data.uri().url();
 389 }
 390
 391 QStringList KUriFilter::pluginNames() const
 392 {
 393     QStringList list;
 394     Q_FOREACH( KUriFilterPlugin* plugin, d->lstPlugins )
 395         list.append(plugin->objectName());
 396     return list;
 397 }
 398
 399 void KUriFilter::loadPlugins()
 400 {
 401     const KService::List offers = KServiceTypeTrader::self()->query( "KUriFilter/Plugin" );
 402
 403     foreach (const KService::Ptr &ptr, offers) {
 404         KUriFilterPlugin *plugin = ptr->createInstance<KUriFilterPlugin>();
 405         if (!plugin)
 406             continue;
 407         Q_ASSERT( !plugin->objectName().isEmpty() );
 408         d->lstPlugins.append( plugin );
 409     }
 410
 411     // NOTE: Plugin priority is determined by
 412     // the InitialPreference entry in the .desktop files,
 413     // so the trader result is already sorted.
 414
 415     // TODO: Config dialog to differentiate "system"
 416     // plugins from "user-defined" ones...
 417     // d->lstPlugins.sort();
 418 }
 419
 420 #include "kurifilter.moc"