# kdecore Library API Documentation

Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Namespaces | Source Files

# 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 #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", "mime_empty" );
    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("mime_empty");
    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

This file is part of the documentation for kdecore Library Version 3.4.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Jun 11 20:18:10 2005 by doxygen 1.4.1 written by Dimitri van Heesch, © 1997-2003