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