kdecore Library API Documentation

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., 59 Temple Place - Suite 330,
00016    Boston, MA 02111-1307, USA.
00017 */
00018 
00019 #include "kprotocolinfo.h"
00020 #include "kprotocolinfofactory.h"
00021 
00022 #include <kstandarddirs.h>
00023 #include <kglobal.h>
00024 #include <kapplication.h>
00025 #include <kdebug.h>
00026 #include <ksimpleconfig.h>
00027 #include <kconfig.h>
00028 #include <kstringhandler.h>
00029 
00030 class KProtocolInfo::KProtocolInfoPrivate
00031 {
00032 public:
00033   QString docPath;
00034   QString protClass;
00035   KProtocolInfo::ExtraFieldList extraFields;
00036   bool showPreviews;
00037   KURL::URIMode uriMode;
00038 };
00039 
00040 //
00041 // Internal functions:
00042 //
00043 KProtocolInfo::KProtocolInfo(const QString &path)
00044  : KSycocaEntry(path)
00045 {
00046   d = new KProtocolInfoPrivate;
00047   QString fullPath = locate("services", path);
00048 
00049   KSimpleConfig config( fullPath, true );
00050   config.setGroup( "Protocol" );
00051 
00052   m_name = config.readEntry( "protocol" );
00053   m_exec = config.readPathEntry( "exec" );
00054   m_isSourceProtocol = config.readBoolEntry( "source", true );
00055   m_isHelperProtocol = config.readBoolEntry( "helper", false );
00056   m_supportsReading = config.readBoolEntry( "reading", false );
00057   m_supportsWriting = config.readBoolEntry( "writing", false );
00058   m_supportsMakeDir = config.readBoolEntry( "makedir", false );
00059   m_supportsDeleting = config.readBoolEntry( "deleting", false );
00060   m_supportsLinking = config.readBoolEntry( "linking", false );
00061   m_supportsMoving = config.readBoolEntry( "moving", false );
00062   m_canCopyFromFile = config.readBoolEntry( "copyFromFile", false );
00063   m_canCopyToFile = config.readBoolEntry( "copyToFile", false );
00064   m_listing = config.readListEntry( "listing" );
00065   // Many .protocol files say "Listing=false" when they really mean "Listing=" (i.e. unsupported)
00066   if ( m_listing.count() == 1 && m_listing.first() == "false" )
00067     m_listing.clear();
00068   m_supportsListing = ( m_listing.count() > 0 );
00069   m_defaultMimetype = config.readEntry( "defaultMimetype" );
00070   m_determineMimetypeFromExtension = config.readBoolEntry( "determineMimetypeFromExtension", true );
00071   m_icon = config.readEntry( "Icon", "mime_empty" );
00072   m_config = config.readEntry( "config", m_name );
00073   m_maxSlaves = config.readNumEntry( "maxInstances", 1);
00074 
00075   QString tmp = config.readEntry( "input" );
00076   if ( tmp == "filesystem" )
00077     m_inputType = KProtocolInfo::T_FILESYSTEM;
00078   else if ( tmp == "stream" )
00079     m_inputType = KProtocolInfo::T_STREAM;
00080   else
00081     m_inputType = KProtocolInfo::T_NONE;
00082 
00083   tmp = config.readEntry( "output" );
00084   if ( tmp == "filesystem" )
00085     m_outputType = KProtocolInfo::T_FILESYSTEM;
00086   else if ( tmp == "stream" )
00087     m_outputType = KProtocolInfo::T_STREAM;
00088   else
00089     m_outputType = KProtocolInfo::T_NONE;
00090 
00091   d->docPath = config.readPathEntry( "DocPath" );
00092   d->protClass = config.readEntry( "Class" ).lower();
00093   if (d->protClass[0] != ':')
00094      d->protClass.prepend(':');
00095 
00096   QStringList extraNames = config.readListEntry( "ExtraNames" );
00097   QStringList extraTypes = config.readListEntry( "ExtraTypes" );
00098   QStringList::Iterator it = extraNames.begin();
00099   QStringList::Iterator typeit = extraTypes.begin();
00100   for( ; it != extraNames.end() && typeit != extraTypes.end(); ++it, ++typeit ) {
00101       d->extraFields.append( ExtraField( *it, *typeit ) );
00102   }
00103 
00104   d->showPreviews = config.readBoolEntry( "ShowPreviews", d->protClass == ":local" );
00105 
00106   tmp = config.readEntry( "URIMode", QString::null ).lower();
00107   if (tmp == "rawuri")
00108      d->uriMode = KURL::RawURI;
00109   else if (tmp == "mailto")
00110      d->uriMode = KURL::Mailto;
00111   else if (tmp == "url")
00112      d->uriMode = KURL::URL;
00113   else 
00114      d->uriMode = KURL::Auto;
00115 }
00116 
00117 KProtocolInfo::KProtocolInfo( QDataStream& _str, int offset) :
00118     KSycocaEntry( _str, offset)
00119 {
00120    d = new KProtocolInfoPrivate;
00121    load( _str );
00122 }
00123 
00124 KProtocolInfo::~KProtocolInfo()
00125 {
00126    delete d;
00127 }
00128 
00129 void
00130 KProtocolInfo::load( QDataStream& _str)
00131 {
00132    Q_INT32 i_inputType, i_outputType;
00133    Q_INT8 i_isSourceProtocol, i_isHelperProtocol,
00134           i_supportsListing, i_supportsReading,
00135           i_supportsWriting, i_supportsMakeDir,
00136           i_supportsDeleting, i_supportsLinking,
00137           i_supportsMoving, i_determineMimetypeFromExtension,
00138           i_canCopyFromFile, i_canCopyToFile, i_showPreviews,
00139           i_uriMode;
00140    _str >> m_name >> m_exec >> m_listing >> m_defaultMimetype
00141         >> i_determineMimetypeFromExtension
00142         >> m_icon
00143         >> i_inputType >> i_outputType
00144         >> i_isSourceProtocol >> i_isHelperProtocol
00145         >> i_supportsListing >> i_supportsReading
00146         >> i_supportsWriting >> i_supportsMakeDir
00147         >> i_supportsDeleting >> i_supportsLinking
00148         >> i_supportsMoving
00149         >> i_canCopyFromFile >> i_canCopyToFile
00150         >> m_config >> m_maxSlaves >> d->docPath >> d->protClass >> d->extraFields >> i_showPreviews >> i_uriMode;
00151    m_inputType = (Type) i_inputType;
00152    m_outputType = (Type) i_outputType;
00153    m_isSourceProtocol = (i_isSourceProtocol != 0);
00154    m_isHelperProtocol = (i_isHelperProtocol != 0);
00155    m_supportsListing = (i_supportsListing != 0);
00156    m_supportsReading = (i_supportsReading != 0);
00157    m_supportsWriting = (i_supportsWriting != 0);
00158    m_supportsMakeDir = (i_supportsMakeDir != 0);
00159    m_supportsDeleting = (i_supportsDeleting != 0);
00160    m_supportsLinking = (i_supportsLinking != 0);
00161    m_supportsMoving = (i_supportsMoving != 0);
00162    m_canCopyFromFile = (i_canCopyFromFile != 0);
00163    m_canCopyToFile = (i_canCopyToFile != 0);
00164    m_determineMimetypeFromExtension = (i_determineMimetypeFromExtension != 0);
00165    d->showPreviews = (i_showPreviews != 0);
00166    d->uriMode = (KURL::URIMode) i_uriMode;
00167 }
00168 
00169 void
00170 KProtocolInfo::save( QDataStream& _str)
00171 {
00172    KSycocaEntry::save( _str );
00173 
00174    Q_INT32 i_inputType, i_outputType;
00175    Q_INT8 i_isSourceProtocol, i_isHelperProtocol,
00176           i_supportsListing, i_supportsReading,
00177           i_supportsWriting, i_supportsMakeDir,
00178           i_supportsDeleting, i_supportsLinking,
00179           i_supportsMoving, i_determineMimetypeFromExtension,
00180           i_canCopyFromFile, i_canCopyToFile, i_showPreviews,
00181           i_uriMode;
00182 
00183    i_inputType = (Q_INT32) m_inputType;
00184    i_outputType = (Q_INT32) m_outputType;
00185    i_isSourceProtocol = m_isSourceProtocol ? 1 : 0;
00186    i_isHelperProtocol = m_isHelperProtocol ? 1 : 0;
00187    i_supportsListing = m_supportsListing ? 1 : 0;
00188    i_supportsReading = m_supportsReading ? 1 : 0;
00189    i_supportsWriting = m_supportsWriting ? 1 : 0;
00190    i_supportsMakeDir = m_supportsMakeDir ? 1 : 0;
00191    i_supportsDeleting = m_supportsDeleting ? 1 : 0;
00192    i_supportsLinking = m_supportsLinking ? 1 : 0;
00193    i_supportsMoving = m_supportsMoving ? 1 : 0;
00194    i_canCopyFromFile = m_canCopyFromFile ? 1 : 0;
00195    i_canCopyToFile = m_canCopyToFile ? 1 : 0;
00196    i_determineMimetypeFromExtension = m_determineMimetypeFromExtension ? 1 : 0;
00197    i_showPreviews = d->showPreviews ? 1 : 0;
00198    i_uriMode = d->uriMode;
00199 
00200    _str << m_name << m_exec << m_listing << m_defaultMimetype
00201         << i_determineMimetypeFromExtension
00202         << m_icon
00203         << i_inputType << i_outputType
00204         << i_isSourceProtocol << i_isHelperProtocol
00205         << i_supportsListing << i_supportsReading
00206         << i_supportsWriting << i_supportsMakeDir
00207         << i_supportsDeleting << i_supportsLinking
00208         << i_supportsMoving
00209         << i_canCopyFromFile << i_canCopyToFile
00210         << m_config << m_maxSlaves << d->docPath << d->protClass << d->extraFields << i_showPreviews << i_uriMode;
00211 }
00212 
00213 
00214 //
00215 // Static functions:
00216 //
00217 
00218 QStringList KProtocolInfo::protocols()
00219 {
00220   return KProtocolInfoFactory::self()->protocols();
00221 }
00222 
00223 bool KProtocolInfo::isSourceProtocol( const QString& _protocol )
00224 {
00225   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00226   if ( !prot )
00227     return false;
00228 
00229   return prot->m_isSourceProtocol;
00230 }
00231 
00232 bool KProtocolInfo::isFilterProtocol( const QString& _protocol )
00233 {
00234   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00235   if ( !prot )
00236     return false;
00237 
00238   return !prot->m_isSourceProtocol;
00239 }
00240 
00241 bool KProtocolInfo::isHelperProtocol( const QString& _protocol )
00242 {
00243   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00244   if ( !prot )
00245     return false;
00246 
00247   return prot->m_isHelperProtocol;
00248 }
00249 
00250 bool KProtocolInfo::isKnownProtocol( const QString& _protocol )
00251 {
00252   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00253   return ( prot != 0);
00254 }
00255 
00256 bool KProtocolInfo::supportsListing( const QString& _protocol )
00257 {
00258   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00259   if ( !prot )
00260     return false;
00261 
00262   return prot->m_supportsListing;
00263 }
00264 
00265 QStringList KProtocolInfo::listing( const QString& _protocol )
00266 {
00267   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00268   if ( !prot )
00269     return QStringList();
00270 
00271   return prot->m_listing;
00272 }
00273 
00274 bool KProtocolInfo::supportsReading( const QString& _protocol )
00275 {
00276   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00277   if ( !prot )
00278     return false;
00279 
00280   return prot->m_supportsReading;
00281 }
00282 
00283 bool KProtocolInfo::supportsWriting( const QString& _protocol )
00284 {
00285   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00286   if ( !prot )
00287     return false;
00288 
00289   return prot->m_supportsWriting;
00290 }
00291 
00292 bool KProtocolInfo::supportsMakeDir( const QString& _protocol )
00293 {
00294   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00295   if ( !prot )
00296     return false;
00297 
00298   return prot->m_supportsMakeDir;
00299 }
00300 
00301 bool KProtocolInfo::supportsDeleting( const QString& _protocol )
00302 {
00303   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00304   if ( !prot )
00305     return false;
00306 
00307   return prot->m_supportsDeleting;
00308 }
00309 
00310 bool KProtocolInfo::supportsLinking( const QString& _protocol )
00311 {
00312   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00313   if ( !prot )
00314     return false;
00315 
00316   return prot->m_supportsLinking;
00317 }
00318 
00319 bool KProtocolInfo::supportsMoving( const QString& _protocol )
00320 {
00321   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00322   if ( !prot )
00323     return false;
00324 
00325   return prot->m_supportsMoving;
00326 }
00327 
00328 bool KProtocolInfo::canCopyFromFile( const QString& _protocol )
00329 {
00330   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00331   if ( !prot )
00332     return false;
00333 
00334   return prot->m_canCopyFromFile;
00335 }
00336 
00337 
00338 bool KProtocolInfo::canCopyToFile( const QString& _protocol )
00339 {
00340   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00341   if ( !prot )
00342     return false;
00343 
00344   return prot->m_canCopyToFile;
00345 }
00346 
00347 QString KProtocolInfo::icon( const QString& _protocol )
00348 {
00349   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00350   if ( !prot )
00351     return QString::fromLatin1("mime_empty");
00352 
00353   return prot->m_icon;
00354 }
00355 
00356 QString KProtocolInfo::config( const QString& _protocol )
00357 {
00358   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00359   if ( !prot )
00360     return QString::null;
00361 
00362   return QString("kio_%1rc").arg(prot->m_config);
00363 }
00364 
00365 int KProtocolInfo::maxSlaves( const QString& _protocol )
00366 {
00367   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00368   if ( !prot )
00369     return 1;
00370 
00371   return prot->m_maxSlaves;
00372 }
00373 
00374 QString KProtocolInfo::defaultMimetype( const QString& _protocol )
00375 {
00376   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00377   if ( !prot )
00378     return QString::null;
00379 
00380   return prot->m_defaultMimetype;
00381 }
00382 
00383 bool KProtocolInfo::determineMimetypeFromExtension( const QString &_protocol )
00384 {
00385   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol( _protocol );
00386   if ( !prot )
00387     return true;
00388 
00389   return prot->m_determineMimetypeFromExtension;
00390 }
00391 
00392 QString KProtocolInfo::exec( const QString& _protocol )
00393 {
00394   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00395   if ( !prot )
00396     return QString::null;
00397 
00398   return prot->m_exec;
00399 }
00400 
00401 KProtocolInfo::Type KProtocolInfo::inputType( const QString& _protocol )
00402 {
00403   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00404   if ( !prot )
00405     return T_NONE;
00406 
00407   return prot->m_inputType;
00408 }
00409 
00410 KProtocolInfo::Type KProtocolInfo::outputType( const QString& _protocol )
00411 {
00412   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00413   if ( !prot )
00414     return T_NONE;
00415 
00416   return prot->m_outputType;
00417 }
00418 
00419 KProtocolInfo::ExtraFieldList KProtocolInfo::extraFields( const KURL &url )
00420 {
00421   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(url.protocol());
00422   if ( !prot )
00423     return ExtraFieldList();
00424 
00425   return prot->d->extraFields;
00426 }
00427 
00428 QString KProtocolInfo::docPath( const QString& _protocol )
00429 {
00430   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00431   if ( !prot )
00432     return QString::null;
00433 
00434   return prot->d->docPath;
00435 }
00436 
00437 QString KProtocolInfo::protocolClass( const QString& _protocol )
00438 {
00439   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00440   if ( !prot )
00441     return QString::null;
00442 
00443   return prot->d->protClass;
00444 }
00445 
00446 bool KProtocolInfo::showFilePreview( const QString& _protocol )
00447 {
00448   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00449   if ( !prot )
00450     return false;
00451 
00452   return prot->d->showPreviews;
00453 }
00454 
00455 KURL::URIMode KProtocolInfo::uriParseMode( const QString& _protocol )
00456 {
00457   KProtocolInfo::Ptr prot = KProtocolInfoFactory::self()->findProtocol(_protocol);
00458   if ( !prot )
00459     return KURL::Auto;
00460 
00461   return prot->d->uriMode;
00462 }
00463 
00464 QDataStream& operator>>( QDataStream& s, KProtocolInfo::ExtraField& field )  {
00465   s >> field.name;
00466   s >> field.type;
00467   return s;
00468 }
00469 
00470 QDataStream& operator<<( QDataStream& s, const KProtocolInfo::ExtraField& field )  {
00471   s << field.name;
00472   s << field.type;
00473   return s;
00474 }
00475 
00476 // KURL based static functions are implemented in ../kio/kio/kprotocolinfo.cpp
00477 
00478 void KProtocolInfo::virtual_hook( int id, void* data )
00479 { KSycocaEntry::virtual_hook( id, data ); }
00480 
KDE Logo
This file is part of the documentation for kdecore Library Version 3.2.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Thu Mar 4 22:43:31 2004 by doxygen 1.3.6-20040222 written by Dimitri van Heesch, © 1997-2003