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