00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include <sys/time.h>
00023 #include <pwd.h>
00024 #include <grp.h>
00025 #include <sys/types.h>
00026
00027 #include <assert.h>
00028 #include <unistd.h>
00029
00030 #include "kfileitem.h"
00031
00032 #include <qdir.h>
00033 #include <qfile.h>
00034 #include <qmap.h>
00035 #include <qstylesheet.h>
00036
00037 #include <klargefile.h>
00038 #include <kiconloader.h>
00039 #include <kglobal.h>
00040 #include <kdebug.h>
00041 #include <klocale.h>
00042 #include <kmimetype.h>
00043 #include <krun.h>
00044 #include <kfilemetainfo.h>
00045 #include <kfileshare.h>
00046
00047 KFileItem::KFileItem( const KIO::UDSEntry& _entry, const KURL& _url,
00048 bool _determineMimeTypeOnDemand, bool _urlIsDirectory ) :
00049 m_entry( _entry ),
00050 m_url( _url ),
00051 m_pMimeType( 0 ),
00052 m_fileMode( KFileItem::Unknown ),
00053 m_permissions( KFileItem::Unknown ),
00054 m_bMarked( false ),
00055 m_bLink( false ),
00056 m_bIsLocalURL( _url.isLocalFile() ),
00057 m_bMimeTypeKnown( false ),
00058 d(0L)
00059 {
00060 bool UDS_URL_seen = false;
00061
00062 KIO::UDSEntry::ConstIterator it = m_entry.begin();
00063 for( ; it != m_entry.end(); it++ ) {
00064 switch ((*it).m_uds) {
00065
00066 case KIO::UDS_FILE_TYPE:
00067 m_fileMode = (mode_t)((*it).m_long);
00068 break;
00069
00070 case KIO::UDS_ACCESS:
00071 m_permissions = (mode_t)((*it).m_long);
00072 break;
00073
00074 case KIO::UDS_USER:
00075 m_user = ((*it).m_str);
00076 break;
00077
00078 case KIO::UDS_GROUP:
00079 m_group = ((*it).m_str);
00080 break;
00081
00082 case KIO::UDS_NAME:
00083 m_strName = (*it).m_str;
00084 m_strText = KIO::decodeFileName( m_strName );
00085 break;
00086
00087 case KIO::UDS_URL:
00088 UDS_URL_seen = true;
00089 m_url = KURL((*it).m_str);
00090 break;
00091
00092 case KIO::UDS_MIME_TYPE:
00093 m_pMimeType = KMimeType::mimeType((*it).m_str);
00094 m_bMimeTypeKnown = true;
00095 break;
00096
00097 case KIO::UDS_GUESSED_MIME_TYPE:
00098 m_guessedMimeType = (*it).m_str;
00099 break;
00100
00101 case KIO::UDS_LINK_DEST:
00102 m_bLink = !(*it).m_str.isEmpty();
00103 break;
00104 }
00105 }
00106
00107 static const QString& dot = KGlobal::staticQString(".");
00108 if ( _urlIsDirectory && !UDS_URL_seen && !m_strName.isEmpty() && m_strName != dot )
00109 m_url.addPath( m_strName );
00110 init( _determineMimeTypeOnDemand );
00111 }
00112
00113 KFileItem::KFileItem( mode_t _mode, mode_t _permissions, const KURL& _url, bool _determineMimeTypeOnDemand ) :
00114 m_entry(),
00115 m_url( _url ),
00116 m_strName( _url.fileName() ),
00117 m_strText( KIO::decodeFileName( m_strName ) ),
00118 m_pMimeType( 0 ),
00119 m_fileMode ( _mode ),
00120 m_permissions( _permissions ),
00121 m_bMarked( false ),
00122 m_bLink( false ),
00123 m_bIsLocalURL( _url.isLocalFile() ),
00124 m_bMimeTypeKnown( false ),
00125 d(0L)
00126 {
00127 init( _determineMimeTypeOnDemand );
00128 }
00129
00130 KFileItem::KFileItem( const KURL &url, const QString &mimeType, mode_t mode )
00131 : m_url( url ),
00132 m_strName( url.fileName() ),
00133 m_strText( KIO::decodeFileName( m_strName ) ),
00134 m_pMimeType( 0 ),
00135 m_fileMode( mode ),
00136 m_permissions( KFileItem::Unknown ),
00137 m_bMarked( false ),
00138 m_bLink( false ),
00139 m_bIsLocalURL( url.isLocalFile() ),
00140 m_bMimeTypeKnown( !mimeType.isEmpty() ),
00141 d(0L)
00142 {
00143 if (m_bMimeTypeKnown)
00144 m_pMimeType = KMimeType::mimeType( mimeType );
00145
00146 init( false );
00147 }
00148
00149 KFileItem::KFileItem( const KFileItem & item ) :
00150 d(0L)
00151 {
00152 assign( item );
00153 }
00154
00155 KFileItem::~KFileItem()
00156 {
00157 }
00158
00159 void KFileItem::init( bool _determineMimeTypeOnDemand )
00160 {
00161 m_access = QString::null;
00162 m_size = (KIO::filesize_t) -1;
00163
00164 for ( int i = 0; i < NumFlags; i++ )
00165 m_time[i] = (time_t) -1;
00166
00167
00168 if ( m_fileMode == KFileItem::Unknown || m_permissions == KFileItem::Unknown )
00169 {
00170 mode_t mode = 0;
00171 if ( m_url.isLocalFile() )
00172 {
00173
00174
00175
00176
00177
00178
00179
00180 KDE_struct_stat buf;
00181 QCString path = QFile::encodeName(m_url.path( -1 ));
00182 if ( KDE_lstat( path.data(), &buf ) == 0 )
00183 {
00184 mode = buf.st_mode;
00185 if ( S_ISLNK( mode ) )
00186 {
00187 m_bLink = true;
00188 if ( KDE_stat( path.data(), &buf ) == 0 )
00189 mode = buf.st_mode;
00190 else
00191 mode = (S_IFMT-1) | S_IRWXU | S_IRWXG | S_IRWXO;
00192 }
00193
00194 m_time[ Modification ] = buf.st_mtime;
00195 m_time[ Access ] = buf.st_atime;
00196 }
00197 }
00198 if ( m_fileMode == KFileItem::Unknown )
00199 m_fileMode = mode & S_IFMT;
00200 if ( m_permissions == KFileItem::Unknown )
00201 m_permissions = mode & 07777;
00202 }
00203
00204
00205 if (!m_pMimeType )
00206 {
00207 m_pMimeType = KMimeType::findByURL( m_url, m_fileMode, m_bIsLocalURL,
00208
00209 _determineMimeTypeOnDemand );
00210
00211
00212 m_bMimeTypeKnown = (!_determineMimeTypeOnDemand) || (m_pMimeType->name() != KMimeType::defaultMimeType());
00213 }
00214
00215 }
00216
00217 void KFileItem::refresh()
00218 {
00219 m_fileMode = KFileItem::Unknown;
00220 m_permissions = KFileItem::Unknown;
00221 m_user = QString::null;
00222 m_group = QString::null;
00223 m_access = QString::null;
00224 m_size = (KIO::filesize_t) -1;
00225 m_metaInfo = KFileMetaInfo();
00226 for ( int i = 0; i < NumFlags; i++ )
00227 m_time[i] = (time_t) -1;
00228
00229
00230
00231
00232
00233 m_entry = KIO::UDSEntry();
00234 init( false );
00235 }
00236
00237 void KFileItem::refreshMimeType()
00238 {
00239 m_pMimeType = 0L;
00240 init( false );
00241 }
00242
00243 void KFileItem::setURL( const KURL &url )
00244 {
00245 m_url = url;
00246 m_strName = url.fileName();
00247 m_strText = KIO::decodeFileName( m_strName );
00248 }
00249
00250 QString KFileItem::linkDest() const
00251 {
00252
00253 KIO::UDSEntry::ConstIterator it = m_entry.begin();
00254 for( ; it != m_entry.end(); it++ )
00255 if ( (*it).m_uds == KIO::UDS_LINK_DEST )
00256 return (*it).m_str;
00257
00258 if ( m_bIsLocalURL )
00259 {
00260 char buf[1000];
00261 int n = readlink( QFile::encodeName(m_url.path( -1 )), buf, sizeof(buf)-1 );
00262 if ( n != -1 )
00263 {
00264 buf[ n ] = 0;
00265 return QFile::decodeName( buf );
00266 }
00267 }
00268 return QString::null;
00269 }
00270
00271 KIO::filesize_t KFileItem::size() const
00272 {
00273 if ( m_size != (KIO::filesize_t) -1 )
00274 return m_size;
00275
00276
00277 KIO::UDSEntry::ConstIterator it = m_entry.begin();
00278 for( ; it != m_entry.end(); it++ )
00279 if ( (*it).m_uds == KIO::UDS_SIZE ) {
00280 m_size = (*it).m_long;
00281 return m_size;
00282 }
00283
00284 if ( m_bIsLocalURL )
00285 {
00286 KDE_struct_stat buf;
00287 if ( KDE_stat( QFile::encodeName(m_url.path( -1 )), &buf ) == 0 )
00288 return buf.st_size;
00289 }
00290 return 0L;
00291 }
00292
00293 time_t KFileItem::time( unsigned int which ) const
00294 {
00295 unsigned int mappedWhich = 0;
00296
00297 switch( which ) {
00298 case KIO::UDS_MODIFICATION_TIME:
00299 mappedWhich = Modification;
00300 break;
00301 case KIO::UDS_ACCESS_TIME:
00302 mappedWhich = Access;
00303 break;
00304 case KIO::UDS_CREATION_TIME:
00305 mappedWhich = Creation;
00306 break;
00307 }
00308
00309 if ( m_time[mappedWhich] != (time_t) -1 )
00310 return m_time[mappedWhich];
00311
00312
00313 KIO::UDSEntry::ConstIterator it = m_entry.begin();
00314 for( ; it != m_entry.end(); it++ )
00315 if ( (*it).m_uds == which ) {
00316 m_time[mappedWhich] = static_cast<time_t>((*it).m_long);
00317 return m_time[mappedWhich];
00318 }
00319
00320
00321 if ( m_bIsLocalURL )
00322 {
00323 KDE_struct_stat buf;
00324 if ( KDE_stat( QFile::encodeName(m_url.path(-1)), &buf ) == 0 )
00325 {
00326 m_time[mappedWhich] = (which == KIO::UDS_MODIFICATION_TIME) ?
00327 buf.st_mtime :
00328 (which == KIO::UDS_ACCESS_TIME) ? buf.st_atime :
00329 static_cast<time_t>(0);
00330 return m_time[mappedWhich];
00331 }
00332 }
00333 return static_cast<time_t>(0);
00334 }
00335
00336
00337 QString KFileItem::user() const
00338 {
00339 if ( m_user.isEmpty() && m_bIsLocalURL )
00340 {
00341 KDE_struct_stat buff;
00342 if ( KDE_lstat( QFile::encodeName(m_url.path( -1 )), &buff ) == 0)
00343 {
00344 struct passwd *user = getpwuid( buff.st_uid );
00345 if ( user != 0L )
00346 m_user = QString::fromLocal8Bit(user->pw_name);
00347 }
00348 }
00349 return m_user;
00350 }
00351
00352 QString KFileItem::group() const
00353 {
00354 if (m_group.isEmpty() && m_bIsLocalURL )
00355 {
00356 KDE_struct_stat buff;
00357 if ( KDE_lstat( QFile::encodeName(m_url.path( -1 )), &buff ) == 0)
00358 {
00359 struct group *ge = getgrgid( buff.st_gid );
00360 if ( ge != 0L ) {
00361 m_group = QString::fromLocal8Bit(ge->gr_name);
00362 if (m_group.isEmpty())
00363 m_group.sprintf("%d",ge->gr_gid);
00364 } else
00365 m_group.sprintf("%d",buff.st_gid);
00366 }
00367 }
00368 return m_group;
00369 }
00370
00371 QString KFileItem::mimetype() const
00372 {
00373 KFileItem * that = const_cast<KFileItem *>(this);
00374 return that->determineMimeType()->name();
00375 }
00376
00377 KMimeType::Ptr KFileItem::determineMimeType()
00378 {
00379 if ( !m_pMimeType || !m_bMimeTypeKnown )
00380 {
00381 m_pMimeType = KMimeType::findByURL( m_url, m_fileMode, m_bIsLocalURL );
00382
00383 m_bMimeTypeKnown = true;
00384 }
00385
00386 return m_pMimeType;
00387 }
00388
00389 bool KFileItem::isMimeTypeKnown() const
00390 {
00391
00392
00393
00394 return m_bMimeTypeKnown && m_guessedMimeType.isEmpty();
00395 }
00396
00397 QString KFileItem::mimeComment()
00398 {
00399 KMimeType::Ptr mType = determineMimeType();
00400 QString comment = mType->comment( m_url, m_bIsLocalURL );
00401 if (!comment.isEmpty())
00402 return comment;
00403 else
00404 return mType->name();
00405 }
00406
00407 QString KFileItem::iconName()
00408 {
00409 return determineMimeType()->icon(m_url, m_bIsLocalURL);
00410 }
00411
00412 int KFileItem::overlays() const
00413 {
00414 int _state = 0;
00415 if ( m_bLink )
00416 _state |= KIcon::LinkOverlay;
00417
00418 if ( !S_ISDIR( m_fileMode )
00419 && !isReadable())
00420 _state |= KIcon::LockOverlay;
00421
00422 if ( m_strName[0] == '.' )
00423 _state |= KIcon::HiddenOverlay;
00424
00425 if( S_ISDIR( m_fileMode ) && m_bIsLocalURL)
00426 {
00427 if (KFileShare::isDirectoryShared( m_url.path() ))
00428 {
00429 kdDebug()<<"KFileShare::isDirectoryShared : "<<m_url.path()<<endl;
00430 _state |= KIcon::ShareOverlay;
00431 }
00432 }
00433
00434 if ( m_pMimeType->name() == "application/x-gzip" && m_url.fileName().right(3) == ".gz" )
00435 _state |= KIcon::ZipOverlay;
00436 return _state;
00437 }
00438
00439 QPixmap KFileItem::pixmap( int _size, int _state ) const
00440 {
00441 if ( !m_pMimeType )
00442 {
00443 static const QString & defaultFolderIcon =
00444 KGlobal::staticQString(KMimeType::mimeType( "inode/directory" )->KServiceType::icon());
00445 if ( S_ISDIR( m_fileMode ) )
00446 return DesktopIcon( defaultFolderIcon, _size, _state );
00447
00448 return DesktopIcon( "unknown", _size, _state );
00449 }
00450
00451 _state |= overlays();
00452
00453 KMimeType::Ptr mime;
00454
00455 if ( !m_bMimeTypeKnown && !m_guessedMimeType.isEmpty() )
00456 mime = KMimeType::mimeType( m_guessedMimeType );
00457 else
00458 mime = m_pMimeType;
00459
00460
00461
00462 if ( mime->name() == "application/x-gzip" && m_url.fileName().right(3) == ".gz" )
00463 {
00464 QString subFileName = m_url.path().left( m_url.path().length() - 3 );
00465
00466 mime = KMimeType::findByURL( subFileName, 0, m_bIsLocalURL );
00467 }
00468
00469 QPixmap p = mime->pixmap( m_url, KIcon::Desktop, _size, _state );
00470 if (p.isNull())
00471 kdWarning() << "Pixmap not found for mimetype " << m_pMimeType->name() << endl;
00472
00473 return p;
00474 }
00475
00476 bool KFileItem::isReadable() const
00477 {
00478
00479
00480
00481
00482
00483
00484
00485
00486
00487 if ( !(S_IRUSR & m_permissions) && !(S_IRGRP & m_permissions) && !(S_IROTH & m_permissions) )
00488 return false;
00489
00490
00491 else if ( m_bIsLocalURL && ::access( QFile::encodeName(m_url.path()), R_OK ) == -1 )
00492 return false;
00493
00494 return true;
00495 }
00496
00497 bool KFileItem::isDir() const
00498 {
00499 if ( !m_bMimeTypeKnown && !m_guessedMimeType.isEmpty() )
00500 {
00501 kdDebug() << " KFileItem::isDir can't say -> false " << endl;
00502 return false;
00503 }
00504 return S_ISDIR(m_fileMode);
00505 }
00506
00507 bool KFileItem::acceptsDrops()
00508 {
00509
00510 if ( S_ISDIR( mode() ) )
00511 {
00512 if ( m_bIsLocalURL )
00513 return (::access( QFile::encodeName(m_url.path()), X_OK ) == 0);
00514 else
00515 return true;
00516 }
00517
00518
00519 if ( !m_bIsLocalURL )
00520 return false;
00521
00522 if ( mimetype() == "application/x-desktop")
00523 return true;
00524
00525
00526 if ( ::access( QFile::encodeName(m_url.path()), X_OK ) == 0 )
00527 return true;
00528
00529 return false;
00530 }
00531
00532 QString KFileItem::getStatusBarInfo()
00533 {
00534 QString comment = determineMimeType()->comment( m_url, m_bIsLocalURL );
00535 QString text = m_strText;
00536
00537 QString myLinkDest = linkDest();
00538 KIO::filesize_t mySize = size();
00539
00540 if ( m_bLink )
00541 {
00542 QString tmp;
00543 if ( comment.isEmpty() )
00544 tmp = i18n ( "Symbolic Link" );
00545 else
00546 tmp = i18n("%1 (Link)").arg(comment);
00547 text += "->";
00548 text += myLinkDest;
00549 text += " ";
00550 text += tmp;
00551 }
00552 else if ( S_ISREG( m_fileMode ) )
00553 {
00554 text += QString(" (%1)").arg( KIO::convertSize( mySize ) );
00555 text += " ";
00556 text += comment;
00557 }
00558 else if ( S_ISDIR ( m_fileMode ) )
00559 {
00560 text += "/ ";
00561 text += comment;
00562 }
00563 else
00564 {
00565 text += " ";
00566 text += comment;
00567 }
00568 return text;
00569 }
00570
00571 QString KFileItem::getToolTipText(int maxcount)
00572 {
00573
00574 QString tip;
00575 KFileMetaInfo info = metaInfo();
00576
00577
00578
00579 const char* start = "<tr><td><nobr><font color=\"black\">";
00580 const char* mid = "</font></nobr></td><td><nobr><font color=\"black\">";
00581 const char* end = "</font></nobr></td></tr>";
00582
00583 tip = "<table cellspacing=0 cellpadding=0>";
00584
00585
00586
00587 tip += start + i18n("Type:") + mid;
00588
00589 QString type = QStyleSheet::escape(determineMimeType()->comment());
00590 if ( m_bLink )
00591 tip += i18n("Link to %1").arg(type) + end;
00592 else
00593 tip += type + end;
00594
00595 if ( !S_ISDIR ( m_fileMode ) )
00596 tip += start + i18n("Size:") + mid +
00597 KIO::convertSize( size() ) + end;
00598
00599 tip += start + i18n("Modified:") + mid +
00600 timeString( KIO::UDS_MODIFICATION_TIME) + end +
00601 start + i18n("Owner:") + mid + user() + " - " + group() + end +
00602 start + i18n("Permissions:") + mid +
00603 parsePermissions(m_permissions) + end;
00604
00605 if (info.isValid() && !info.isEmpty() )
00606 {
00607 QStringList keys = info.preferredKeys();
00608
00609
00610 QStringList::Iterator it = keys.begin();
00611 for (int count = 0; count<maxcount && it!=keys.end() ; ++it)
00612 {
00613 KFileMetaInfoItem item = info.item( *it );
00614 if ( item.isValid() )
00615 {
00616 QString s = item.string();
00617 if (s.length() > 50) s = s.left(47) + "...";
00618 if ( !s.isEmpty() )
00619 {
00620 count++;
00621 tip += start +
00622 QStyleSheet::escape( item.translatedKey() ) + ":" +
00623 mid +
00624 QStyleSheet::escape( s ) +
00625 end;
00626 }
00627
00628 }
00629 }
00630 tip += "</table>";
00631 }
00632
00633
00634
00635
00636 return tip;
00637 }
00638
00639 void KFileItem::run()
00640 {
00641 KURL url( m_url );
00642
00643
00644
00645 if ( m_bLink && m_bIsLocalURL )
00646 url = KURL( m_url, linkDest() );
00647 (void) new KRun( url, m_fileMode, m_bIsLocalURL );
00648 }
00649
00650 bool KFileItem::cmp( const KFileItem & item )
00651 {
00652 return ( m_strName == item.m_strName
00653 && m_bIsLocalURL == item.m_bIsLocalURL
00654 && m_fileMode == item.m_fileMode
00655 && m_permissions == item.m_permissions
00656 && m_user == item.m_user
00657 && m_group == item.m_group
00658 && m_bLink == item.m_bLink
00659 && size() == item.size()
00660 && time(KIO::UDS_MODIFICATION_TIME) == item.time(KIO::UDS_MODIFICATION_TIME) );
00661 }
00662
00663 void KFileItem::assign( const KFileItem & item )
00664 {
00665 m_entry = item.m_entry;
00666 m_url = item.m_url;
00667 m_bIsLocalURL = item.m_bIsLocalURL;
00668 m_strName = item.m_strName;
00669 m_strText = item.m_strText;
00670 m_fileMode = item.m_fileMode;
00671 m_permissions = item.m_permissions;
00672 m_user = item.m_user;
00673 m_group = item.m_group;
00674 m_bLink = item.m_bLink;
00675 m_pMimeType = item.m_pMimeType;
00676 m_strLowerCaseName = item.m_strLowerCaseName;
00677 m_bMimeTypeKnown = item.m_bMimeTypeKnown;
00678 m_guessedMimeType = item.m_guessedMimeType;
00679 m_access = item.m_access;
00680 m_metaInfo = item.m_metaInfo;
00681 for ( int i = 0; i < NumFlags; i++ )
00682 m_time[i] = item.m_time[i];
00683 m_size = item.m_size;
00684
00685
00686
00687
00688 determineMimeType();
00689 }
00690
00691 void KFileItem::setExtraData( const void *key, void *value )
00692 {
00693 if ( !key )
00694 return;
00695
00696 m_extra.replace( key, value );
00697 }
00698
00699 const void * KFileItem::extraData( const void *key ) const
00700 {
00701 QMapConstIterator<const void*,void*> it = m_extra.find( key );
00702 if ( it != m_extra.end() )
00703 return it.data();
00704 return 0L;
00705 }
00706
00707 void * KFileItem::extraData( const void *key )
00708 {
00709 QMapIterator<const void*,void*> it = m_extra.find( key );
00710 if ( it != m_extra.end() )
00711 return it.data();
00712 return 0L;
00713 }
00714
00715 void KFileItem::removeExtraData( const void *key )
00716 {
00717 m_extra.remove( key );
00718 }
00719
00720 QString KFileItem::permissionsString() const
00721 {
00722 if (m_access.isNull())
00723 m_access = parsePermissions( m_permissions );
00724
00725 return m_access;
00726 }
00727
00728 QString KFileItem::parsePermissions(mode_t perm) const
00729 {
00730 char p[] = "----------";
00731
00732 if (isDir())
00733 p[0]='d';
00734 else if (isLink())
00735 p[0]='l';
00736
00737 if (perm & QFileInfo::ReadUser)
00738 p[1]='r';
00739 if (perm & QFileInfo::WriteUser)
00740 p[2]='w';
00741 if (perm & QFileInfo::ExeUser)
00742 p[3]='x';
00743
00744 if (perm & QFileInfo::ReadGroup)
00745 p[4]='r';
00746 if (perm & QFileInfo::WriteGroup)
00747 p[5]='w';
00748 if (perm & QFileInfo::ExeGroup)
00749 p[6]='x';
00750
00751 if (perm & QFileInfo::ReadOther)
00752 p[7]='r';
00753 if (perm & QFileInfo::WriteOther)
00754 p[8]='w';
00755 if (perm & QFileInfo::ExeOther)
00756 p[9]='x';
00757
00758 return QString::fromLatin1(p);
00759 }
00760
00761
00762 QString KFileItem::timeString( unsigned int which ) const
00763 {
00764 QDateTime t;
00765 t.setTime_t( time(which) );
00766 return KGlobal::locale()->formatDateTime( t );
00767 }
00768
00769 void KFileItem::setMetaInfo( const KFileMetaInfo & info )
00770 {
00771 m_metaInfo = info;
00772 }
00773
00774 const KFileMetaInfo & KFileItem::metaInfo(bool autoget, int) const
00775 {
00776 if ( autoget && m_url.isLocalFile() && !m_metaInfo.isValid() )
00777 {
00778 m_metaInfo = KFileMetaInfo( m_url.path(), mimetype() );
00779 }
00780
00781 return m_metaInfo;
00782 }
00783
00784 void KFileItem::virtual_hook( int, void* )
00785 { }
00786