kprotocolinfo_kdecore.cpp

00001 /* This file is part of the KDE libraries
00002    Copyright (C) 1999 Torben Weis <weis@kde.org>
00003 
00004    This library is free software; you can redistribute it and/or
00005    modify it under the terms of the GNU Library General Public
00006    License version 2 as published by the Free Software Foundation.
00007 
00008    This library is distributed in the hope that it will be useful,
00009    but WITHOUT ANY WARRANTY; without even the implied warranty of
00010    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00011    Library General Public License for more details.
00012 
00013    You should have received a copy of the GNU Library General Public License
00014    along with this library; see the file COPYING.LIB.  If not, write to
00015    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00016    Boston, MA 02110-1301, USA.
00017 */
00018 
00019 #ifdef MAKE_KDECORE_LIB //needed for proper linkage (win32)
00020 #undef KIO_EXPORT
00021 #define KIO_EXPORT KDE_EXPORT
00022 #endif
00023 
00024 #include "kprotocolinfo.h"
00025 #include "kprotocolinfofactory.h"
00026 
00027 #include <kstandarddirs.h>
00028 #include <kglobal.h>
00029 #include <kapplication.h>
00030 #include <kdebug.h>
00031 #include <ksimpleconfig.h>
00032 #include <kconfig.h>
00033 #include <kstringhandler.h>
00034 
00035 class KProtocolInfo::KProtocolInfoPrivate
00036 {
00037 public:
00038   QString docPath;
00039   QString protClass;
00040   KProtocolInfo::ExtraFieldList extraFields;
00041   bool showPreviews;
00042   bool canRenameFromFile;
00043   bool canRenameToFile;
00044   bool canDeleteRecursive;
00045   bool fileNameUsedForCopying; // true if using UDS_NAME, false if using KURL::fileName() [default]
00046   KURL::URIMode uriMode;
00047   QStringList capabilities;
00048   QString proxyProtocol;
00049 };
00050 
00051 //
00052 // Internal functions:
00053 //
00054 KProtocolInfo::KProtocolInfo(const QString &path)
00055  : KSycocaEntry(path)
00056 {
00057   d = new KProtocolInfoPrivate;
00058   QString fullPath = locate("services", path);
00059 
00060   KSimpleConfig config( fullPath, true );
00061   config.setGroup( "Protocol" );
00062 
00063   m_name = config.readEntry( "protocol" );
00064   m_exec = config.readPathEntry( "exec" );
00065   m_isSourceProtocol = config.readBoolEntry( "source", true );
00066   m_isHelperProtocol = config.readBoolEntry( "helper", false );
00067   m_supportsReading = config.readBoolEntry( "reading", false );
00068   m_supportsWriting = config.readBoolEntry( "writing", false );
00069   m_supportsMakeDir = config.readBoolEntry( "makedir", false );
00070   m_supportsDeleting = config.readBoolEntry( "deleting", false );
00071   m_supportsLinking = config.readBoolEntry( "linking", false );
00072   m_supportsMoving = config.readBoolEntry( "moving", false );
00073   m_canCopyFromFile = config.readBoolEntry( "copyFromFile", false );
00074   m_canCopyToFile = config.readBoolEntry( "copyToFile", false );
00075   d->canRenameFromFile = config.readBoolEntry( "renameFromFile", false );
00076   d->canRenameToFile = config.readBoolEntry( "renameToFile", false );
00077   d->canDeleteRecursive = config.readBoolEntry( "deleteRecursive", false );
00078   d->fileNameUsedForCopying = config.readEntry( "fileNameUsedForCopying", "FromURL" ) == "Name";
00079 
00080   m_listing = config.readListEntry( "listing" );
00081   // Many .protocol files say "Listing=false" when they really mean "Listing=" (i.e. unsupported)
00082   if ( m_listing.count() == 1 && m_listing.first() == "false" )
00083     m_listing.clear();
00084   m_supportsListing = ( m_listing.count() > 0 );
00085   m_defaultMimetype = config.readEntry( "defaultMimetype" );
00086   m_determineMimetypeFromExtension = config.readBoolEntry( "determineMimetypeFromExtension", true );
00087   m_icon = config.readEntry( "Icon", "unknown" );
00088   m_config = config.readEntry( "config", m_name );
00089   m_maxSlaves = config.readNumEntry( "maxInstances", 1);
00090 
00091   QString tmp = config.readEntry( "input" );
00092   if ( tmp == "filesystem" )
00093     m_inputType = KProtocolInfo::T_FILESYSTEM;
00094   else if ( tmp == "stream" )
00095     m_inputType = KProtocolInfo::T_STREAM;
00096   else
00097     m_inputType = KProtocolInfo::T_NONE;
00098 
00099   tmp = config.readEntry( "output" );
00100   if ( tmp == "filesystem" )
00101     m_outputType = KProtocolInfo::T_FILESYSTEM;
00102   else if ( tmp == "stream" )
00103     m_outputType = KProtocolInfo::T_STREAM;
00104   else
00105     m_outputType = KProtocolInfo::T_NONE;
00106 
00107   d->docPath = config.readPathEntry( "DocPath" );
00108   d->protClass = config.readEntry( "Class" ).lower();
00109   if (d->protClass[0] != ':')
00110      d->protClass.prepend(':');
00111 
00112   QStringList extraNames = config.readListEntry( "ExtraNames" );
00113   QStringList extraTypes = config.readListEntry( "ExtraTypes" );
00114   QStringList::Iterator it = extraNames.begin();
00115   QStringList::Iterator typeit = extraTypes.begin();
00116   for( ; it != extraNames.end() && typeit != extraTypes.end(); ++it, ++typeit ) {
00117       d->extraFields.append( ExtraField( *it, *typeit ) );
00118   }
00119 
00120   d->showPreviews = config.readBoolEntry( "ShowPreviews", d->protClass == ":local" );
00121 
00122   tmp = config.readEntry( "URIMode", QString::null ).lower();
00123   if (tmp == "rawuri")
00124      d->uriMode = KURL::RawURI;
00125   else if (tmp == "mailto")
00126      d->uriMode = KURL::Mailto;
00127   else if (tmp == "url")
00128      d->uriMode = KURL::URL;
00129   else
00130      d->uriMode = KURL::Auto;
00131 
00132   d->capabilities = config.readListEntry( "Capabilities" );
00133   d->proxyProtocol = config.readEntry( "ProxiedBy" );
00134 }
00135 
00136 KProtocolInfo::KProtocolInfo( QDataStream& _str, int offset) :
00137     KSycocaEntry( _str, offset)
00138 {
00139    d = new KProtocolInfoPrivate;
00140    load( _str );
00141 }
00142 
00143 KProtocolInfo::~KProtocolInfo()
00144 {
00145    delete d;
00146 }
00147 
00148 void
00149 KProtocolInfo::load( QDataStream& _str)
00150 {
00151    // You may add new fields at the end. Make sure to update the version
00152    // number in ksycoca.h
00153    Q_INT32 i_inputType, i_outputType;
00154    Q_INT8 i_isSourceProtocol, i_isHelperProtocol,
00155           i_supportsListing, i_supportsReading,
00156           i_supportsWriting, i_supportsMakeDir,
00157           i_supportsDeleting, i_supportsLinking,
00158           i_supportsMoving, i_determineMimetypeFromExtension,
00159           i_canCopyFromFile, i_canCopyToFile, i_showPreviews,
00160           i_uriMode, i_canRenameFromFile, i_canRenameToFile,
00161           i_canDeleteRecursive, i_fileNameUsedForCopying;
00162 
00163    _str >> m_name >> m_exec >> m_listing >> m_defaultMimetype
00164         >> i_determineMimetypeFromExtension
00165         >> m_icon
00166         >> i_inputType >> i_outputType
00167         >> i_isSourceProtocol >> i_isHelperProtocol
00168         >> i_supportsListing >> i_supportsReading
00169         >> i_supportsWriting >> i_supportsMakeDir
00170         >> i_supportsDeleting >> i_supportsLinking
00171         >> i_supportsMoving
00172         >> i_canCopyFromFile >> i_canCopyToFile
00173         >> m_config >> m_maxSlaves >> d->docPath >> d->protClass
00174         >> d->extraFields >> i_showPreviews >> i_uriMode
00175         >> d->capabilities >> d->proxyProtocol
00176         >> i_canRenameFromFile >> i_canRenameToFile
00177         >> i_canDeleteRecursive >> i_fileNameUsedForCopying;
00178 
00179    m_inputType = (Type) i_inputType;
00180    m_outputType = (Type) i_outputType;
00181    m_isSourceProtocol = (i_isSourceProtocol != 0);
00182    m_isHelperProtocol = (i_isHelperProtocol != 0);
00183    m_supportsListing = (i_supportsListing != 0);
00184    m_supportsReading = (i_supportsReading != 0);
00185    m_supportsWriting = (i_supportsWriting != 0);
00186    m_supportsMakeDir = (i_supportsMakeDir != 0);
00187    m_supportsDeleting = (i_supportsDeleting != 0);
00188    m_supportsLinking = (i_supportsLinking != 0);
00189    m_supportsMoving = (i_supportsMoving != 0);
00190    m_canCopyFromFile = (i_canCopyFromFile != 0);
00191    m_canCopyToFile = (i_canCopyToFile != 0);
00192    d->canRenameFromFile = (i_canRenameFromFile != 0);
00193    d->canRenameToFile = (i_canRenameToFile != 0);
00194    d->canDeleteRecursive = (i_canDeleteRecursive != 0);
00195    d->fileNameUsedForCopying = (i_fileNameUsedForCopying != 0);
00196    m_determineMimetypeFromExtension = (i_determineMimetypeFromExtension != 0);
00197    d->showPreviews = (i_showPreviews != 0);
00198    d->uriMode = (KURL::URIMode) i_uriMode;
00199 }
00200 
00201 void
00202 KProtocolInfo::save( QDataStream& _str)
00203 {
00204    KSycocaEntry::save( _str );
00205 
00206    // You may add new fields at the end. Make sure to update the version
00207    // number in ksycoca.h
00208    Q_INT32 i_inputType, i_outputType;
00209    Q_INT8 i_isSourceProtocol, i_isHelperProtocol,
00210           i_supportsListing, i_supportsReading,
00211           i_supportsWriting, i_supportsMakeDir,
00212           i_supportsDeleting, i_supportsLinking,
00213           i_supportsMoving, i_determineMimetypeFromExtension,
00214           i_canCopyFromFile, i_canCopyToFile, i_showPreviews,
00215           i_uriMode, i_canRenameFromFile, i_canRenameToFile,
00216           i_canDeleteRecursive, i_fileNameUsedForCopying;
00217 
00218    i_inputType = (Q_INT32) m_inputType;
00219    i_outputType = (Q_INT32) m_outputType;
00220    i_isSourceProtocol = m_isSourceProtocol ? 1 : 0;
00221    i_isHelperProtocol = m_isHelperProtocol ? 1 : 0;
00222    i_supportsListing = m_supportsListing ? 1 : 0;
00223    i_supportsReading = m_supportsReading ? 1 : 0;
00224    i_supportsWriting = m_supportsWriting ? 1 : 0;
00225    i_supportsMakeDir = m_supportsMakeDir ? 1 : 0;
00226    i_supportsDeleting = m_supportsDeleting ? 1 : 0;
00227    i_supportsLinking = m_supportsLinking ? 1 : 0;
00228    i_supportsMoving = m_supportsMoving ? 1 : 0;
00229    i_canCopyFromFile = m_canCopyFromFile ? 1 : 0;
00230    i_canCopyToFile = m_canCopyToFile ? 1 : 0;
00231    i_canRenameFromFile = d->canRenameFromFile ? 1 : 0;
00232    i_canRenameToFile = d->canRenameToFile ? 1 : 0;
00233    i_canDeleteRecursive = d->canDeleteRecursive ? 1 : 0;
00234    i_fileNameUsedForCopying = d->fileNameUsedForCopying ? 1 : 0;
00235    i_determineMimetypeFromExtension = m_determineMimetypeFromExtension ? 1 : 0;
00236    i_showPreviews = d->showPreviews ? 1 : 0;
00237    i_uriMode = d->uriMode;
00238 
00239    _str << m_name << m_exec << m_listing << m_defaultMimetype
00240         << i_determineMimetypeFromExtension
00241         << m_icon
00242         << i_inputType << i_outputType
00243         << i_isSourceProtocol << i_isHelperProtocol
00244         << i_supportsListing << i_supportsReading
00245         << i_supportsWriting << i_supportsMakeDir
00246         << i_supportsDeleting << i_supportsLinking
00247         << i_supportsMoving
00248         << i_canCopyFromFile << i_canCopyToFile
00249         << m_config << m_maxSlaves << d->docPath << d->protClass
00250         << d->extraFields << i_showPreviews << i_uriMode
00251         << d->capabilities << d->proxyProtocol
00252         << i_canRenameFromFile << i_canRenameToFile
00253         << i_canDeleteRecursive << i_fileNameUsedForCopying;
00254 }
00255 
00256 
00257 //
00258 // Static functions:
00259 //
00260 
00261 QStringList KProtocolInfo::protocols()
00262 {
00263   return KProtocolInfoFactory::self()->protocols();
00264 }
00265 
00266 bool KProtocolInfo::isSourceProtocol( const QString& _protocol )
00267 {
00268   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00269   if ( !prot )
00270     return false;
00271 
00272   return prot->m_isSourceProtocol;
00273 }
00274 
00275 bool KProtocolInfo::isFilterProtocol( const QString& _protocol )
00276 {
00277   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00278   if ( !prot )
00279     return false;
00280 
00281   return !prot->m_isSourceProtocol;
00282 }
00283 
00284 bool KProtocolInfo::isHelperProtocol( const QString& _protocol )
00285 {
00286   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00287   if ( !prot )
00288     return false;
00289 
00290   return prot->m_isHelperProtocol;
00291 }
00292 
00293 bool KProtocolInfo::isKnownProtocol( const QString& _protocol )
00294 {
00295   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00296   return ( prot != 0);
00297 }
00298 
00299 bool KProtocolInfo::supportsListing( const QString& _protocol )
00300 {
00301   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00302   if ( !prot )
00303     return false;
00304 
00305   return prot->m_supportsListing;
00306 }
00307 
00308 QStringList KProtocolInfo::listing( const QString& _protocol )
00309 {
00310   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00311   if ( !prot )
00312     return QStringList();
00313 
00314   return prot->m_listing;
00315 }
00316 
00317 bool KProtocolInfo::supportsReading( const QString& _protocol )
00318 {
00319   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00320   if ( !prot )
00321     return false;
00322 
00323   return prot->m_supportsReading;
00324 }
00325 
00326 bool KProtocolInfo::supportsWriting( const QString& _protocol )
00327 {
00328   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00329   if ( !prot )
00330     return false;
00331 
00332   return prot->m_supportsWriting;
00333 }
00334 
00335 bool KProtocolInfo::supportsMakeDir( const QString& _protocol )
00336 {
00337   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00338   if ( !prot )
00339     return false;
00340 
00341   return prot->m_supportsMakeDir;
00342 }
00343 
00344 bool KProtocolInfo::supportsDeleting( const QString& _protocol )
00345 {
00346   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00347   if ( !prot )
00348     return false;
00349 
00350   return prot->m_supportsDeleting;
00351 }
00352 
00353 bool KProtocolInfo::supportsLinking( const QString& _protocol )
00354 {
00355   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00356   if ( !prot )
00357     return false;
00358 
00359   return prot->m_supportsLinking;
00360 }
00361 
00362 bool KProtocolInfo::supportsMoving( const QString& _protocol )
00363 {
00364   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00365   if ( !prot )
00366     return false;
00367 
00368   return prot->m_supportsMoving;
00369 }
00370 
00371 bool KProtocolInfo::canCopyFromFile( const QString& _protocol )
00372 {
00373   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00374   if ( !prot )
00375     return false;
00376 
00377   return prot->m_canCopyFromFile;
00378 }
00379 
00380 
00381 bool KProtocolInfo::canCopyToFile( const QString& _protocol )
00382 {
00383   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00384   if ( !prot )
00385     return false;
00386 
00387   return prot->m_canCopyToFile;
00388 }
00389 
00390 QString KProtocolInfo::icon( const QString& _protocol )
00391 {
00392   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00393   if ( !prot )
00394     return QString::fromLatin1("unknown");
00395 
00396   return prot->m_icon;
00397 }
00398 
00399 QString KProtocolInfo::config( const QString& _protocol )
00400 {
00401   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00402   if ( !prot )
00403     return QString::null;
00404 
00405   return QString("kio_%1rc").arg(prot->m_config);
00406 }
00407 
00408 int KProtocolInfo::maxSlaves( const QString& _protocol )
00409 {
00410   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00411   if ( !prot )
00412     return 1;
00413 
00414   return prot->m_maxSlaves;
00415 }
00416 
00417 QString KProtocolInfo::defaultMimetype( const QString& _protocol )
00418 {
00419   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00420   if ( !prot )
00421     return QString::null;
00422 
00423   return prot->m_defaultMimetype;
00424 }
00425 
00426 bool KProtocolInfo::determineMimetypeFromExtension( const QString &_protocol )
00427 {
00428   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol( _protocol );
00429   if ( !prot )
00430     return true;
00431 
00432   return prot->m_determineMimetypeFromExtension;
00433 }
00434 
00435 QString KProtocolInfo::exec( const QString& _protocol )
00436 {
00437   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00438   if ( !prot )
00439     return QString::null;
00440 
00441   return prot->m_exec;
00442 }
00443 
00444 KProtocolInfo::Type KProtocolInfo::inputType( const QString& _protocol )
00445 {
00446   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00447   if ( !prot )
00448     return T_NONE;
00449 
00450   return prot->m_inputType;
00451 }
00452 
00453 KProtocolInfo::Type KProtocolInfo::outputType( const QString& _protocol )
00454 {
00455   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00456   if ( !prot )
00457     return T_NONE;
00458 
00459   return prot->m_outputType;
00460 }
00461 
00462 KProtocolInfo::ExtraFieldList KProtocolInfo::extraFields( const KURL &url )
00463 {
00464   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(url.protocol());
00465   if ( !prot )
00466     return ExtraFieldList();
00467 
00468   return prot->d->extraFields;
00469 }
00470 
00471 QString KProtocolInfo::docPath( const QString& _protocol )
00472 {
00473   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00474   if ( !prot )
00475     return QString::null;
00476 
00477   return prot->d->docPath;
00478 }
00479 
00480 QString KProtocolInfo::protocolClass( const QString& _protocol )
00481 {
00482   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00483   if ( !prot )
00484     return QString::null;
00485 
00486   return prot->d->protClass;
00487 }
00488 
00489 bool KProtocolInfo::showFilePreview( const QString& _protocol )
00490 {
00491   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00492   if ( !prot )
00493     return false;
00494 
00495   return prot->d->showPreviews;
00496 }
00497 
00498 KURL::URIMode KProtocolInfo::uriParseMode( const QString& _protocol )
00499 {
00500   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00501   if ( !prot )
00502     return KURL::Auto;
00503 
00504   return prot->d->uriMode;
00505 }
00506 
00507 QStringList KProtocolInfo::capabilities( const QString& _protocol )
00508 {
00509   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00510   if ( !prot )
00511     return QStringList();
00512 
00513   return prot->d->capabilities;
00514 }
00515 
00516 QString KProtocolInfo::proxiedBy( const QString& _protocol )
00517 {
00518   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00519   if ( !prot )
00520     return QString::null;
00521 
00522   return prot->d->proxyProtocol;
00523 }
00524 
00525 bool KProtocolInfo::canRenameFromFile() const
00526 {
00527   return d->canRenameFromFile;
00528 }
00529 
00530 bool KProtocolInfo::canRenameToFile() const
00531 {
00532   return d->canRenameToFile;
00533 }
00534 
00535 bool KProtocolInfo::canDeleteRecursive() const
00536 {
00537   return d->canDeleteRecursive;
00538 }
00539 
00540 KProtocolInfo::FileNameUsedForCopying KProtocolInfo::fileNameUsedForCopying() const
00541 {
00542   return d->fileNameUsedForCopying ? Name : FromURL;
00543 }
00544 
00545 QDataStream& operator>>( QDataStream& s, KProtocolInfo::ExtraField& field )  {
00546   s >> field.name;
00547   s >> field.type;
00548   return s;
00549 }
00550 
00551 QDataStream& operator<<( QDataStream& s, const KProtocolInfo::ExtraField& field )  {
00552   s << field.name;
00553   s << field.type;
00554   return s;
00555 }
00556 
00557 // KURL based static functions are implemented in ../kio/kio/kprotocolinfo.cpp
00558 
00559 void KProtocolInfo::virtual_hook( int id, void* data )
00560 { KSycocaEntry::virtual_hook( id, data ); }
00561 
KDE Home | KDE Accessibility Home | Description of Access Keys