kio Library API Documentation

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