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 <ksambashare.h>
00040 #include <knfsshare.h>
00041 #include <kglobal.h>
00042 #include <kglobalsettings.h>
00043 #include <kiconloader.h>
00044 #include <klargefile.h>
00045 #include <klocale.h>
00046 #include <kmimetype.h>
00047 #include <krun.h>
00048
00049 class KFileItem::KFileItemPrivate {
00050 public:
00051 QString iconName;
00052 };
00053
00054 KFileItem::KFileItem( const KIO::UDSEntry& _entry, const KURL& _url,
00055 bool _determineMimeTypeOnDemand, bool _urlIsDirectory ) :
00056 m_entry( _entry ),
00057 m_url( _url ),
00058 m_pMimeType( 0 ),
00059 m_fileMode( KFileItem::Unknown ),
00060 m_permissions( KFileItem::Unknown ),
00061 m_bMarked( false ),
00062 m_bLink( false ),
00063 m_bIsLocalURL( _url.isLocalFile() ),
00064 m_bMimeTypeKnown( false ),
00065 m_hidden( Auto ),
00066 d(0)
00067 {
00068 readUDSEntry( _urlIsDirectory );
00069 init( _determineMimeTypeOnDemand );
00070 }
00071
00072 KFileItem::KFileItem( mode_t _mode, mode_t _permissions, const KURL& _url, bool _determineMimeTypeOnDemand ) :
00073 m_entry(),
00074 m_url( _url ),
00075 m_strName( _url.fileName() ),
00076 m_strText( KIO::decodeFileName( m_strName ) ),
00077 m_pMimeType( 0 ),
00078 m_fileMode ( _mode ),
00079 m_permissions( _permissions ),
00080 m_bMarked( false ),
00081 m_bLink( false ),
00082 m_bIsLocalURL( _url.isLocalFile() ),
00083 m_bMimeTypeKnown( false ),
00084 m_hidden( Auto ),
00085 d(0)
00086 {
00087 init( _determineMimeTypeOnDemand );
00088 }
00089
00090 KFileItem::KFileItem( const KURL &url, const QString &mimeType, mode_t mode )
00091 : m_url( url ),
00092 m_strName( url.fileName() ),
00093 m_strText( KIO::decodeFileName( m_strName ) ),
00094 m_pMimeType( 0 ),
00095 m_fileMode( mode ),
00096 m_permissions( KFileItem::Unknown ),
00097 m_bMarked( false ),
00098 m_bLink( false ),
00099 m_bIsLocalURL( url.isLocalFile() ),
00100 m_bMimeTypeKnown( !mimeType.isEmpty() ),
00101 m_hidden( Auto ),
00102 d(0)
00103 {
00104 if (m_bMimeTypeKnown)
00105 m_pMimeType = KMimeType::mimeType( mimeType );
00106
00107 init( false );
00108 }
00109
00110 KFileItem::KFileItem( const KFileItem & item ) :
00111 d(0)
00112 {
00113 assign( item );
00114 }
00115
00116 KFileItem& KFileItem::operator=( const KFileItem & item )
00117 {
00118 assign( item );
00119 return *this;
00120 }
00121
00122 KFileItem::~KFileItem()
00123 {
00124 delete d;
00125 }
00126
00127 void KFileItem::init( bool _determineMimeTypeOnDemand )
00128 {
00129 m_access = QString::null;
00130 m_size = (KIO::filesize_t) -1;
00131
00132 for ( int i = 0; i < NumFlags; i++ )
00133 m_time[i] = (time_t) -1;
00134
00135
00136 if ( m_fileMode == KFileItem::Unknown || m_permissions == KFileItem::Unknown )
00137 {
00138 mode_t mode = 0;
00139 if ( m_url.isLocalFile() )
00140 {
00141
00142
00143
00144
00145
00146
00147
00148 KDE_struct_stat buf;
00149 QCString path = QFile::encodeName(m_url.path( -1 ));
00150 if ( KDE_lstat( path.data(), &buf ) == 0 )
00151 {
00152 mode = buf.st_mode;
00153 if ( S_ISLNK( mode ) )
00154 {
00155 m_bLink = true;
00156 if ( KDE_stat( path.data(), &buf ) == 0 )
00157 mode = buf.st_mode;
00158 else
00159 mode = (S_IFMT-1) | S_IRWXU | S_IRWXG | S_IRWXO;
00160 }
00161
00162 m_time[ Modification ] = buf.st_mtime;
00163 m_time[ Access ] = buf.st_atime;
00164 if ( m_fileMode == KFileItem::Unknown )
00165 m_fileMode = mode & S_IFMT;
00166 if ( m_permissions == KFileItem::Unknown )
00167 m_permissions = mode & 07777;
00168 }
00169 }
00170 }
00171
00172
00173 if (!m_pMimeType && !m_url.isEmpty())
00174 {
00175 bool accurate = false;
00176 bool isLocalURL;
00177 KURL url = mostLocalURL(isLocalURL);
00178
00179 m_pMimeType = KMimeType::findByURL( url, m_fileMode, isLocalURL,
00180
00181 _determineMimeTypeOnDemand, &accurate );
00182
00183
00184
00185 m_bMimeTypeKnown = (!_determineMimeTypeOnDemand) || accurate;
00186 }
00187 }
00188
00189 void KFileItem::readUDSEntry( bool _urlIsDirectory )
00190 {
00191
00192 bool UDS_URL_seen = false;
00193
00194 KIO::UDSEntry::ConstIterator it = m_entry.begin();
00195 for( ; it != m_entry.end(); ++it ) {
00196 switch ((*it).m_uds) {
00197
00198 case KIO::UDS_FILE_TYPE:
00199 m_fileMode = (mode_t)((*it).m_long);
00200 break;
00201
00202 case KIO::UDS_ACCESS:
00203 m_permissions = (mode_t)((*it).m_long);
00204 break;
00205
00206 case KIO::UDS_USER:
00207 m_user = ((*it).m_str);
00208 break;
00209
00210 case KIO::UDS_GROUP:
00211 m_group = ((*it).m_str);
00212 break;
00213
00214 case KIO::UDS_NAME:
00215 m_strName = (*it).m_str;
00216 m_strText = KIO::decodeFileName( m_strName );
00217 break;
00218
00219 case KIO::UDS_URL:
00220 UDS_URL_seen = true;
00221 m_url = KURL((*it).m_str);
00222 if ( m_url.isLocalFile() )
00223 m_bIsLocalURL = true;
00224 break;
00225
00226 case KIO::UDS_MIME_TYPE:
00227 m_pMimeType = KMimeType::mimeType((*it).m_str);
00228 m_bMimeTypeKnown = true;
00229 break;
00230
00231 case KIO::UDS_GUESSED_MIME_TYPE:
00232 m_guessedMimeType = (*it).m_str;
00233 break;
00234
00235 case KIO::UDS_LINK_DEST:
00236 m_bLink = !(*it).m_str.isEmpty();
00237 break;
00238
00239 case KIO::UDS_ICON_NAME:
00240 if ( !d )
00241 d = new KFileItemPrivate();
00242 d->iconName = (*it).m_str;
00243 break;
00244
00245 case KIO::UDS_HIDDEN:
00246 if ( (*it).m_long )
00247 m_hidden = Hidden;
00248 else
00249 m_hidden = Shown;
00250 break;
00251 }
00252 }
00253
00254
00255 static const QString& dot = KGlobal::staticQString(".");
00256 if ( _urlIsDirectory && !UDS_URL_seen && !m_strName.isEmpty() && m_strName != dot )
00257 m_url.addPath( m_strName );
00258 }
00259
00260 void KFileItem::refresh()
00261 {
00262 m_fileMode = KFileItem::Unknown;
00263 m_permissions = KFileItem::Unknown;
00264 m_pMimeType = 0L;
00265 m_user = QString::null;
00266 m_group = QString::null;
00267 m_metaInfo = KFileMetaInfo();
00268 m_hidden = Auto;
00269
00270
00271
00272
00273
00274 m_entry = KIO::UDSEntry();
00275 init( false );
00276 }
00277
00278 void KFileItem::refreshMimeType()
00279 {
00280 m_pMimeType = 0L;
00281 init( false );
00282 }
00283
00284 void KFileItem::setURL( const KURL &url )
00285 {
00286 m_url = url;
00287 setName( url.fileName() );
00288 }
00289
00290 void KFileItem::setName( const QString& name )
00291 {
00292 m_strName = name;
00293 m_strText = KIO::decodeFileName( m_strName );
00294 }
00295
00296 QString KFileItem::linkDest() const
00297 {
00298
00299 KIO::UDSEntry::ConstIterator it = m_entry.begin();
00300 for( ; it != m_entry.end(); ++it )
00301 if ( (*it).m_uds == KIO::UDS_LINK_DEST )
00302 return (*it).m_str;
00303
00304 if ( m_bIsLocalURL )
00305 {
00306 char buf[1000];
00307 int n = readlink( QFile::encodeName(m_url.path( -1 )), buf, sizeof(buf)-1 );
00308 if ( n != -1 )
00309 {
00310 buf[ n ] = 0;
00311 return QFile::decodeName( buf );
00312 }
00313 }
00314 return QString::null;
00315 }
00316
00317 QString KFileItem::localPath() const
00318 {
00319 if ( m_bIsLocalURL )
00320 {
00321 return m_url.path();
00322 }
00323 else
00324 {
00325
00326 KIO::UDSEntry::ConstIterator it = m_entry.begin();
00327 const KIO::UDSEntry::ConstIterator end = m_entry.end();
00328 for( ; it != end; ++it )
00329 if ( (*it).m_uds == KIO::UDS_LOCAL_PATH )
00330 return (*it).m_str;
00331 }
00332
00333 return QString::null;
00334 }
00335
00336 KIO::filesize_t KFileItem::size(bool &exists) const
00337 {
00338 exists = true;
00339 if ( m_size != (KIO::filesize_t) -1 )
00340 return m_size;
00341
00342
00343 KIO::UDSEntry::ConstIterator it = m_entry.begin();
00344 for( ; it != m_entry.end(); ++it )
00345 if ( (*it).m_uds == KIO::UDS_SIZE ) {
00346 m_size = (*it).m_long;
00347 return m_size;
00348 }
00349
00350 if ( m_bIsLocalURL )
00351 {
00352 KDE_struct_stat buf;
00353 if ( KDE_stat( QFile::encodeName(m_url.path( -1 )), &buf ) == 0 )
00354 return buf.st_size;
00355 }
00356 exists = false;
00357 return 0L;
00358 }
00359
00360 bool KFileItem::hasExtendedACL() const
00361 {
00362 KIO::UDSEntry::ConstIterator it = m_entry.begin();
00363 for( ; it != m_entry.end(); it++ )
00364 if ( (*it).m_uds == KIO::UDS_EXTENDED_ACL ) {
00365 return true;
00366 }
00367 return false;
00368 }
00369
00370 KACL KFileItem::ACL() const
00371 {
00372 if ( hasExtendedACL() ) {
00373
00374 KIO::UDSEntry::ConstIterator it = m_entry.begin();
00375 for( ; it != m_entry.end(); ++it )
00376 if ( (*it).m_uds == KIO::UDS_ACL_STRING )
00377 return KACL((*it).m_str);
00378 }
00379
00380 return KACL( m_permissions );
00381 }
00382
00383 KACL KFileItem::defaultACL() const
00384 {
00385
00386 KIO::UDSEntry::ConstIterator it = m_entry.begin();
00387 for( ; it != m_entry.end(); ++it )
00388 if ( (*it).m_uds == KIO::UDS_DEFAULT_ACL_STRING )
00389 return KACL((*it).m_str);
00390 return KACL();
00391 }
00392
00393 KIO::filesize_t KFileItem::size() const
00394 {
00395 bool exists;
00396 return size(exists);
00397 }
00398
00399 time_t KFileItem::time( unsigned int which ) const
00400 {
00401 bool hasTime;
00402 return time(which, hasTime);
00403 }
00404 time_t KFileItem::time( unsigned int which, bool &hasTime ) const
00405 {
00406 hasTime = true;
00407 unsigned int mappedWhich = 0;
00408
00409 switch( which ) {
00410 case KIO::UDS_MODIFICATION_TIME:
00411 mappedWhich = Modification;
00412 break;
00413 case KIO::UDS_ACCESS_TIME:
00414 mappedWhich = Access;
00415 break;
00416 case KIO::UDS_CREATION_TIME:
00417 mappedWhich = Creation;
00418 break;
00419 }
00420
00421 if ( m_time[mappedWhich] != (time_t) -1 )
00422 return m_time[mappedWhich];
00423
00424
00425 KIO::UDSEntry::ConstIterator it = m_entry.begin();
00426 for( ; it != m_entry.end(); ++it )
00427 if ( (*it).m_uds == which ) {
00428 m_time[mappedWhich] = static_cast<time_t>((*it).m_long);
00429 return m_time[mappedWhich];
00430 }
00431
00432
00433 if ( m_bIsLocalURL )
00434 {
00435 KDE_struct_stat buf;
00436 if ( KDE_stat( QFile::encodeName(m_url.path(-1)), &buf ) == 0 )
00437 {
00438 if(which == KIO::UDS_CREATION_TIME) {
00439
00440 hasTime = false;
00441 m_time[mappedWhich] = static_cast<time_t>(0);
00442 return m_time[mappedWhich];
00443 }
00444 m_time[mappedWhich] = (which == KIO::UDS_MODIFICATION_TIME) ?
00445 buf.st_mtime :
00446
00447 buf.st_atime;
00448 return m_time[mappedWhich];
00449 }
00450 }
00451 hasTime = false;
00452 return static_cast<time_t>(0);
00453 }
00454
00455
00456 QString KFileItem::user() const
00457 {
00458 if ( m_user.isEmpty() && m_bIsLocalURL )
00459 {
00460 KDE_struct_stat buff;
00461 if ( KDE_lstat( QFile::encodeName(m_url.path( -1 )), &buff ) == 0)
00462 {
00463 struct passwd *user = getpwuid( buff.st_uid );
00464 if ( user != 0L )
00465 m_user = QString::fromLocal8Bit(user->pw_name);
00466 }
00467 }
00468 return m_user;
00469 }
00470
00471 QString KFileItem::group() const
00472 {
00473 #ifdef Q_OS_UNIX
00474 if (m_group.isEmpty() && m_bIsLocalURL )
00475 {
00476 KDE_struct_stat buff;
00477 if ( KDE_lstat( QFile::encodeName(m_url.path( -1 )), &buff ) == 0)
00478 {
00479 struct group *ge = getgrgid( buff.st_gid );
00480 if ( ge != 0L ) {
00481 m_group = QString::fromLocal8Bit(ge->gr_name);
00482 if (m_group.isEmpty())
00483 m_group.sprintf("%d",ge->gr_gid);
00484 } else
00485 m_group.sprintf("%d",buff.st_gid);
00486 }
00487 }
00488 #endif
00489 return m_group;
00490 }
00491
00492 QString KFileItem::mimetype() const
00493 {
00494 KFileItem * that = const_cast<KFileItem *>(this);
00495 return that->determineMimeType()->name();
00496 }
00497
00498 KMimeType::Ptr KFileItem::determineMimeType()
00499 {
00500 if ( !m_pMimeType || !m_bMimeTypeKnown )
00501 {
00502 bool isLocalURL;
00503 KURL url = mostLocalURL(isLocalURL);
00504
00505 m_pMimeType = KMimeType::findByURL( url, m_fileMode, isLocalURL );
00506
00507 m_bMimeTypeKnown = true;
00508 }
00509
00510 return m_pMimeType;
00511 }
00512
00513 bool KFileItem::isMimeTypeKnown() const
00514 {
00515
00516
00517
00518 return m_bMimeTypeKnown && m_guessedMimeType.isEmpty();
00519 }
00520
00521 QString KFileItem::mimeComment()
00522 {
00523 KMimeType::Ptr mType = determineMimeType();
00524
00525 bool isLocalURL;
00526 KURL url = mostLocalURL(isLocalURL);
00527
00528 QString comment = mType->comment( url, isLocalURL );
00529
00530 if (!comment.isEmpty())
00531 return comment;
00532 else
00533 return mType->name();
00534 }
00535
00536 QString KFileItem::iconName()
00537 {
00538 if (d && (!d->iconName.isEmpty())) return d->iconName;
00539
00540 bool isLocalURL;
00541 KURL url = mostLocalURL(isLocalURL);
00542
00543
00544 return determineMimeType()->icon(url, isLocalURL);
00545 }
00546
00547 int KFileItem::overlays() const
00548 {
00549 int _state = 0;
00550 if ( m_bLink )
00551 _state |= KIcon::LinkOverlay;
00552
00553 if ( !S_ISDIR( m_fileMode )
00554 && !isReadable())
00555 _state |= KIcon::LockOverlay;
00556
00557 if ( isHidden() )
00558 _state |= KIcon::HiddenOverlay;
00559
00560 if( S_ISDIR( m_fileMode ) && m_bIsLocalURL)
00561 {
00562 if (KSambaShare::instance()->isDirectoryShared( m_url.path() ) ||
00563 KNFSShare::instance()->isDirectoryShared( m_url.path() ))
00564 {
00565
00566 _state |= KIcon::ShareOverlay;
00567 }
00568 }
00569
00570 if ( m_pMimeType->name() == "application/x-gzip" && m_url.fileName().right(3) == ".gz" )
00571 _state |= KIcon::ZipOverlay;
00572 return _state;
00573 }
00574
00575 QPixmap KFileItem::pixmap( int _size, int _state ) const
00576 {
00577 if (d && (!d->iconName.isEmpty()))
00578 return DesktopIcon(d->iconName,_size,_state);
00579
00580 if ( !m_pMimeType )
00581 {
00582 static const QString & defaultFolderIcon =
00583 KGlobal::staticQString(KMimeType::mimeType( "inode/directory" )->KServiceType::icon());
00584
00585 if ( S_ISDIR( m_fileMode ) )
00586 return DesktopIcon( defaultFolderIcon, _size, _state );
00587
00588 return DesktopIcon( "unknown", _size, _state );
00589 }
00590
00591 _state |= overlays();
00592
00593 KMimeType::Ptr mime;
00594
00595 if ( !m_bMimeTypeKnown && !m_guessedMimeType.isEmpty() )
00596 mime = KMimeType::mimeType( m_guessedMimeType );
00597 else
00598 mime = m_pMimeType;
00599
00600
00601
00602 if ( mime->name() == "application/x-gzip" && m_url.fileName().right(3) == ".gz" )
00603 {
00604 KURL sf;
00605 sf.setPath( m_url.path().left( m_url.path().length() - 3 ) );
00606
00607 mime = KMimeType::findByURL( sf, 0, m_bIsLocalURL );
00608 }
00609
00610 bool isLocalURL;
00611 KURL url = mostLocalURL(isLocalURL);
00612
00613 QPixmap p = mime->pixmap( url, KIcon::Desktop, _size, _state );
00614
00615 if (p.isNull())
00616 kdWarning() << "Pixmap not found for mimetype " << m_pMimeType->name() << endl;
00617
00618 return p;
00619 }
00620
00621 bool KFileItem::isReadable() const
00622 {
00623
00624
00625
00626
00627
00628
00629
00630
00631
00632 if ( !(S_IRUSR & m_permissions) && !(S_IRGRP & m_permissions) && !(S_IROTH & m_permissions) )
00633 return false;
00634
00635
00636 else if ( m_bIsLocalURL && ::access( QFile::encodeName(m_url.path()), R_OK ) == -1 )
00637 return false;
00638
00639 return true;
00640 }
00641
00642 bool KFileItem::isWritable() const
00643 {
00644
00645
00646
00647
00648
00649
00650
00651
00652
00653 if ( !(S_IWUSR & m_permissions) && !(S_IWGRP & m_permissions) && !(S_IWOTH & m_permissions) )
00654 return false;
00655
00656
00657 else if ( m_bIsLocalURL && ::access( QFile::encodeName(m_url.path()), W_OK ) == -1 )
00658 return false;
00659
00660 return true;
00661 }
00662
00663 bool KFileItem::isHidden() const
00664 {
00665 if ( m_hidden != Auto )
00666 return m_hidden == Hidden;
00667
00668 if ( !m_url.isEmpty() )
00669 return m_url.fileName()[0] == '.';
00670 else
00671 return m_strName[0] == '.';
00672 }
00673
00674 bool KFileItem::isDir() const
00675 {
00676 if ( m_fileMode == KFileItem::Unknown )
00677 {
00678 kdDebug() << " KFileItem::isDir can't say -> false " << endl;
00679 return false;
00680 }
00681 return (S_ISDIR(m_fileMode));
00682
00683
00684
00685
00686
00687
00688
00689
00690 }
00691
00692 bool KFileItem::acceptsDrops()
00693 {
00694
00695 if ( S_ISDIR( mode() ) ) {
00696 return isWritable();
00697 }
00698
00699
00700 if ( !m_bIsLocalURL )
00701 return false;
00702
00703 if ( mimetype() == "application/x-desktop")
00704 return true;
00705
00706
00707 if ( ::access( QFile::encodeName(m_url.path()), X_OK ) == 0 )
00708 return true;
00709
00710 return false;
00711 }
00712
00713 QString KFileItem::getStatusBarInfo()
00714 {
00715 QString text = m_strText;
00716
00717 if ( m_bLink )
00718 {
00719 QString comment = determineMimeType()->comment( m_url, m_bIsLocalURL );
00720 QString tmp;
00721 if ( comment.isEmpty() )
00722 tmp = i18n ( "Symbolic Link" );
00723 else
00724 tmp = i18n("%1 (Link)").arg(comment);
00725 text += "->";
00726 text += linkDest();
00727 text += " ";
00728 text += tmp;
00729 }
00730 else if ( S_ISREG( m_fileMode ) )
00731 {
00732 bool hasSize;
00733 KIO::filesize_t sizeValue = size(hasSize);
00734 if(hasSize)
00735 text += QString(" (%1) ").arg( KIO::convertSize( sizeValue ) );
00736 text += mimeComment();
00737 }
00738 else if ( S_ISDIR ( m_fileMode ) )
00739 {
00740 text += "/ ";
00741 text += mimeComment();
00742 }
00743 else
00744 {
00745 text += " ";
00746 text += mimeComment();
00747 }
00748 text.replace('\n', " ");
00749 return text;
00750 }
00751
00752 QString KFileItem::getToolTipText(int maxcount)
00753 {
00754
00755 QString tip;
00756 KFileMetaInfo info = metaInfo();
00757
00758
00759
00760 const char* start = "<tr><td><nobr><font color=\"black\">";
00761 const char* mid = "</font></nobr></td><td><nobr><font color=\"black\">";
00762 const char* end = "</font></nobr></td></tr>";
00763
00764 tip = "<table cellspacing=0 cellpadding=0>";
00765
00766 tip += start + i18n("Name:") + mid + text() + end;
00767 tip += start + i18n("Type:") + mid;
00768
00769 QString type = QStyleSheet::escape(mimeComment());
00770 if ( m_bLink ) {
00771 tip += i18n("Link to %1 (%2)").arg(linkDest(), type) + end;
00772 } else
00773 tip += type + end;
00774
00775 if ( !S_ISDIR ( m_fileMode ) ) {
00776 bool hasSize;
00777 KIO::filesize_t sizeValue = size(hasSize);
00778 if(hasSize)
00779 tip += start + i18n("Size:") + mid +
00780 KIO::convertSizeWithBytes(sizeValue) + end;
00781 }
00782 QString timeStr = timeString( KIO::UDS_MODIFICATION_TIME);
00783 if(!timeStr.isEmpty())
00784 tip += start + i18n("Modified:") + mid +
00785 timeStr + end;
00786 #ifndef Q_WS_WIN //TODO: show win32-specific permissions
00787 QString userStr = user();
00788 QString groupStr = group();
00789 if(!userStr.isEmpty() || !groupStr.isEmpty())
00790 tip += start + i18n("Owner:") + mid + userStr + " - " + groupStr + end +
00791 start + i18n("Permissions:") + mid +
00792 parsePermissions(m_permissions) + end;
00793 #endif
00794
00795 if (info.isValid() && !info.isEmpty() )
00796 {
00797 tip += "<tr><td colspan=2><center><s> </s></center></td></tr>";
00798 QStringList keys = info.preferredKeys();
00799
00800
00801 QStringList::Iterator it = keys.begin();
00802 for (int count = 0; count<maxcount && it!=keys.end() ; ++it)
00803 {
00804 KFileMetaInfoItem item = info.item( *it );
00805 if ( item.isValid() )
00806 {
00807 QString s = item.string();
00808 if ( ( item.attributes() & KFileMimeTypeInfo::SqueezeText )
00809 && s.length() > 50) {
00810 s.truncate(47);
00811 s.append("...");
00812 }
00813 if ( !s.isEmpty() )
00814 {
00815 count++;
00816 tip += start +
00817 QStyleSheet::escape( item.translatedKey() ) + ":" +
00818 mid +
00819 QStyleSheet::escape( s ) +
00820 end;
00821 }
00822
00823 }
00824 }
00825 }
00826 tip += "</table>";
00827
00828
00829
00830
00831 return tip;
00832 }
00833
00834 void KFileItem::run()
00835 {
00836
00837
00838
00839 (void) new KRun( m_url, m_fileMode, m_bIsLocalURL );
00840 }
00841
00842 bool KFileItem::cmp( const KFileItem & item )
00843 {
00844 bool hasSize1,hasSize2,hasTime1,hasTime2;
00845 hasSize1 = hasSize2 = hasTime1 = hasTime2 = false;
00846 return ( m_strName == item.m_strName
00847 && m_bIsLocalURL == item.m_bIsLocalURL
00848 && m_fileMode == item.m_fileMode
00849 && m_permissions == item.m_permissions
00850 && m_user == item.m_user
00851 && m_group == item.m_group
00852 && m_bLink == item.m_bLink
00853 && m_hidden == item.m_hidden
00854 && size(hasSize1) == item.size(hasSize2)
00855 && hasSize1 == hasSize2
00856 && time(KIO::UDS_MODIFICATION_TIME, hasTime1) == item.time(KIO::UDS_MODIFICATION_TIME, hasTime2)
00857 && hasTime1 == hasTime2
00858 && (!d || !item.d || d->iconName == item.d->iconName) );
00859
00860
00861
00862 }
00863
00864 void KFileItem::assign( const KFileItem & item )
00865 {
00866 if ( this == &item )
00867 return;
00868 m_entry = item.m_entry;
00869 m_url = item.m_url;
00870 m_bIsLocalURL = item.m_bIsLocalURL;
00871 m_strName = item.m_strName;
00872 m_strText = item.m_strText;
00873 m_fileMode = item.m_fileMode;
00874 m_permissions = item.m_permissions;
00875 m_user = item.m_user;
00876 m_group = item.m_group;
00877 m_bLink = item.m_bLink;
00878 m_pMimeType = item.m_pMimeType;
00879 m_strLowerCaseName = item.m_strLowerCaseName;
00880 m_bMimeTypeKnown = item.m_bMimeTypeKnown;
00881 m_hidden = item.m_hidden;
00882 m_guessedMimeType = item.m_guessedMimeType;
00883 m_access = item.m_access;
00884 m_metaInfo = item.m_metaInfo;
00885 for ( int i = 0; i < NumFlags; i++ )
00886 m_time[i] = item.m_time[i];
00887 m_size = item.m_size;
00888
00889
00890
00891
00892 determineMimeType();
00893
00894 if ( item.d ) {
00895 if ( !d )
00896 d = new KFileItemPrivate;
00897 d->iconName = item.d->iconName;
00898 } else {
00899 delete d;
00900 d = 0;
00901 }
00902 }
00903
00904 void KFileItem::setUDSEntry( const KIO::UDSEntry& _entry, const KURL& _url,
00905 bool _determineMimeTypeOnDemand, bool _urlIsDirectory )
00906 {
00907 m_entry = _entry;
00908 m_url = _url;
00909 m_strName = QString::null;
00910 m_strText = QString::null;
00911 m_user = QString::null;
00912 m_group = QString::null;
00913 m_strLowerCaseName = QString::null;
00914 m_pMimeType = 0;
00915 m_fileMode = KFileItem::Unknown;
00916 m_permissions = KFileItem::Unknown;
00917 m_bMarked = false;
00918 m_bLink = false;
00919 m_bIsLocalURL = _url.isLocalFile();
00920 m_bMimeTypeKnown = false;
00921 m_hidden = Auto;
00922 m_guessedMimeType = QString::null;
00923 m_metaInfo = KFileMetaInfo();
00924
00925 if ( d )
00926 d->iconName = QString::null;
00927
00928 readUDSEntry( _urlIsDirectory );
00929 init( _determineMimeTypeOnDemand );
00930 }
00931
00932 void KFileItem::setFileMode( mode_t m )
00933 {
00934 m_fileMode = m;
00935 }
00936
00937 void KFileItem::setMimeType( const QString& mimetype )
00938 {
00939 m_pMimeType = KMimeType::mimeType( mimetype );
00940 }
00941
00942 void KFileItem::setExtraData( const void *key, void *value )
00943 {
00944 if ( !key )
00945 return;
00946
00947 m_extra.replace( key, value );
00948 }
00949
00950 const void * KFileItem::extraData( const void *key ) const
00951 {
00952 QMapConstIterator<const void*,void*> it = m_extra.find( key );
00953 if ( it != m_extra.end() )
00954 return it.data();
00955 return 0L;
00956 }
00957
00958 void * KFileItem::extraData( const void *key )
00959 {
00960 QMapIterator<const void*,void*> it = m_extra.find( key );
00961 if ( it != m_extra.end() )
00962 return it.data();
00963 return 0L;
00964 }
00965
00966 void KFileItem::removeExtraData( const void *key )
00967 {
00968 m_extra.remove( key );
00969 }
00970
00971 QString KFileItem::permissionsString() const
00972 {
00973 if (m_access.isNull())
00974 m_access = parsePermissions( m_permissions );
00975
00976 return m_access;
00977 }
00978
00979 QString KFileItem::parsePermissions(mode_t perm) const
00980 {
00981 char p[] = "---------- ";
00982
00983 if (isDir())
00984 p[0]='d';
00985 else if (isLink())
00986 p[0]='l';
00987
00988 if (perm & QFileInfo::ReadUser)
00989 p[1]='r';
00990 if (perm & QFileInfo::WriteUser)
00991 p[2]='w';
00992 if ((perm & QFileInfo::ExeUser) && !(perm & S_ISUID)) p[3]='x';
00993 else if ((perm & QFileInfo::ExeUser) && (perm & S_ISUID)) p[3]='s';
00994 else if (!(perm & QFileInfo::ExeUser) && (perm & S_ISUID)) p[3]='S';
00995
00996 if (perm & QFileInfo::ReadGroup)
00997 p[4]='r';
00998 if (perm & QFileInfo::WriteGroup)
00999 p[5]='w';
01000 if ((perm & QFileInfo::ExeGroup) && !(perm & S_ISGID)) p[6]='x';
01001 else if ((perm & QFileInfo::ExeGroup) && (perm & S_ISGID)) p[6]='s';
01002 else if (!(perm & QFileInfo::ExeGroup) && (perm & S_ISGID)) p[6]='S';
01003
01004 if (perm & QFileInfo::ReadOther)
01005 p[7]='r';
01006 if (perm & QFileInfo::WriteOther)
01007 p[8]='w';
01008 if ((perm & QFileInfo::ExeOther) && !(perm & S_ISVTX)) p[9]='x';
01009 else if ((perm & QFileInfo::ExeOther) && (perm & S_ISVTX)) p[9]='t';
01010 else if (!(perm & QFileInfo::ExeOther) && (perm & S_ISVTX)) p[9]='T';
01011
01012 if (hasExtendedACL())
01013 p[10]='+';
01014
01015 return QString::fromLatin1(p);
01016 }
01017
01018
01019 QString KFileItem::timeString( unsigned int which ) const
01020 {
01021 bool hasTime;
01022 time_t time_ = time(which, hasTime);
01023 if(!hasTime) return QString::null;
01024
01025 QDateTime t;
01026 t.setTime_t( time_);
01027 return KGlobal::locale()->formatDateTime( t );
01028 }
01029
01030 void KFileItem::setMetaInfo( const KFileMetaInfo & info )
01031 {
01032 m_metaInfo = info;
01033 }
01034
01035 const KFileMetaInfo & KFileItem::metaInfo(bool autoget, int) const
01036 {
01037 bool isLocalURL;
01038 KURL url = mostLocalURL(isLocalURL);
01039
01040 if ( autoget && !m_metaInfo.isValid() &&
01041 KGlobalSettings::showFilePreview(url) )
01042 {
01043 m_metaInfo = KFileMetaInfo( url, mimetype() );
01044 }
01045
01046 return m_metaInfo;
01047 }
01048
01049 KURL KFileItem::mostLocalURL(bool &local) const
01050 {
01051 QString local_path = localPath();
01052
01053 if ( !local_path.isEmpty() )
01054 {
01055 local = true;
01056 KURL url;
01057 url.setPath(local_path);
01058 return url;
01059 }
01060 else
01061 {
01062 local = m_bIsLocalURL;
01063 return m_url;
01064 }
01065 }
01066
01067 void KFileItem::virtual_hook( int, void* )
01068 { }
01069
01070 QDataStream & operator<< ( QDataStream & s, const KFileItem & a )
01071 {
01072
01073
01074 s << a.m_url;
01075 s << a.m_strName;
01076 s << a.m_strText;
01077 return s;
01078 }
01079
01080 QDataStream & operator>> ( QDataStream & s, KFileItem & a )
01081 {
01082 s >> a.m_url;
01083 s >> a.m_strName;
01084 s >> a.m_strText;
01085 a.m_bIsLocalURL = a.m_url.isLocalFile();
01086 a.m_bMimeTypeKnown = false;
01087 a.refresh();
01088 return s;
01089 }