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 return text;
00749 }
00750
00751 QString KFileItem::getToolTipText(int maxcount)
00752 {
00753
00754 QString tip;
00755 KFileMetaInfo info = metaInfo();
00756
00757
00758
00759 const char* start = "<tr><td><nobr><font color=\"black\">";
00760 const char* mid = "</font></nobr></td><td><nobr><font color=\"black\">";
00761 const char* end = "</font></nobr></td></tr>";
00762
00763 tip = "<table cellspacing=0 cellpadding=0>";
00764
00765 tip += start + i18n("Name:") + mid + text() + end;
00766 tip += start + i18n("Type:") + mid;
00767
00768 QString type = QStyleSheet::escape(mimeComment());
00769 if ( m_bLink ) {
00770 tip += i18n("Link to %1 (%2)").arg(linkDest(), type) + end;
00771 } else
00772 tip += type + end;
00773
00774 if ( !S_ISDIR ( m_fileMode ) ) {
00775 bool hasSize;
00776 KIO::filesize_t sizeValue = size(hasSize);
00777 if(hasSize)
00778 tip += start + i18n("Size:") + mid +
00779 KIO::convertSizeWithBytes(sizeValue) + end;
00780 }
00781 QString timeStr = timeString( KIO::UDS_MODIFICATION_TIME);
00782 if(!timeStr.isEmpty())
00783 tip += start + i18n("Modified:") + mid +
00784 timeStr + end;
00785 #ifndef Q_WS_WIN //TODO: show win32-specific permissions
00786 QString userStr = user();
00787 QString groupStr = group();
00788 if(!userStr.isEmpty() || !groupStr.isEmpty())
00789 tip += start + i18n("Owner:") + mid + userStr + " - " + groupStr + end +
00790 start + i18n("Permissions:") + mid +
00791 parsePermissions(m_permissions) + end;
00792 #endif
00793
00794 if (info.isValid() && !info.isEmpty() )
00795 {
00796 tip += "<tr><td colspan=2><center><s> </s></center></td></tr>";
00797 QStringList keys = info.preferredKeys();
00798
00799
00800 QStringList::Iterator it = keys.begin();
00801 for (int count = 0; count<maxcount && it!=keys.end() ; ++it)
00802 {
00803 KFileMetaInfoItem item = info.item( *it );
00804 if ( item.isValid() )
00805 {
00806 QString s = item.string();
00807 if ( ( item.attributes() & KFileMimeTypeInfo::SqueezeText )
00808 && s.length() > 50) {
00809 s.truncate(47);
00810 s.append("...");
00811 }
00812 if ( !s.isEmpty() )
00813 {
00814 count++;
00815 tip += start +
00816 QStyleSheet::escape( item.translatedKey() ) + ":" +
00817 mid +
00818 QStyleSheet::escape( s ) +
00819 end;
00820 }
00821
00822 }
00823 }
00824 }
00825 tip += "</table>";
00826
00827
00828
00829
00830 return tip;
00831 }
00832
00833 void KFileItem::run()
00834 {
00835
00836
00837
00838 (void) new KRun( m_url, m_fileMode, m_bIsLocalURL );
00839 }
00840
00841 bool KFileItem::cmp( const KFileItem & item )
00842 {
00843 bool hasSize1,hasSize2,hasTime1,hasTime2;
00844 hasSize1 = hasSize2 = hasTime1 = hasTime2 = false;
00845 return ( m_strName == item.m_strName
00846 && m_bIsLocalURL == item.m_bIsLocalURL
00847 && m_fileMode == item.m_fileMode
00848 && m_permissions == item.m_permissions
00849 && m_user == item.m_user
00850 && m_group == item.m_group
00851 && m_bLink == item.m_bLink
00852 && m_hidden == item.m_hidden
00853 && size(hasSize1) == item.size(hasSize2)
00854 && hasSize1 == hasSize2
00855 && time(KIO::UDS_MODIFICATION_TIME, hasTime1) == item.time(KIO::UDS_MODIFICATION_TIME, hasTime2)
00856 && hasTime1 == hasTime2
00857 && (!d || !item.d || d->iconName == item.d->iconName) );
00858
00859
00860
00861 }
00862
00863 void KFileItem::assign( const KFileItem & item )
00864 {
00865 if ( this == &item )
00866 return;
00867 m_entry = item.m_entry;
00868 m_url = item.m_url;
00869 m_bIsLocalURL = item.m_bIsLocalURL;
00870 m_strName = item.m_strName;
00871 m_strText = item.m_strText;
00872 m_fileMode = item.m_fileMode;
00873 m_permissions = item.m_permissions;
00874 m_user = item.m_user;
00875 m_group = item.m_group;
00876 m_bLink = item.m_bLink;
00877 m_pMimeType = item.m_pMimeType;
00878 m_strLowerCaseName = item.m_strLowerCaseName;
00879 m_bMimeTypeKnown = item.m_bMimeTypeKnown;
00880 m_hidden = item.m_hidden;
00881 m_guessedMimeType = item.m_guessedMimeType;
00882 m_access = item.m_access;
00883 m_metaInfo = item.m_metaInfo;
00884 for ( int i = 0; i < NumFlags; i++ )
00885 m_time[i] = item.m_time[i];
00886 m_size = item.m_size;
00887
00888
00889
00890
00891 determineMimeType();
00892
00893 if ( item.d ) {
00894 if ( !d )
00895 d = new KFileItemPrivate;
00896 d->iconName = item.d->iconName;
00897 } else {
00898 delete d;
00899 d = 0;
00900 }
00901 }
00902
00903 void KFileItem::setUDSEntry( const KIO::UDSEntry& _entry, const KURL& _url,
00904 bool _determineMimeTypeOnDemand, bool _urlIsDirectory )
00905 {
00906 m_entry = _entry;
00907 m_url = _url;
00908 m_strName = QString::null;
00909 m_strText = QString::null;
00910 m_user = QString::null;
00911 m_group = QString::null;
00912 m_strLowerCaseName = QString::null;
00913 m_pMimeType = 0;
00914 m_fileMode = KFileItem::Unknown;
00915 m_permissions = KFileItem::Unknown;
00916 m_bMarked = false;
00917 m_bLink = false;
00918 m_bIsLocalURL = _url.isLocalFile();
00919 m_bMimeTypeKnown = false;
00920 m_hidden = Auto;
00921 m_guessedMimeType = QString::null;
00922 m_metaInfo = KFileMetaInfo();
00923
00924 if ( d )
00925 d->iconName = QString::null;
00926
00927 readUDSEntry( _urlIsDirectory );
00928 init( _determineMimeTypeOnDemand );
00929 }
00930
00931 void KFileItem::setFileMode( mode_t m )
00932 {
00933 m_fileMode = m;
00934 }
00935
00936 void KFileItem::setMimeType( const QString& mimetype )
00937 {
00938 m_pMimeType = KMimeType::mimeType( mimetype );
00939 }
00940
00941 void KFileItem::setExtraData( const void *key, void *value )
00942 {
00943 if ( !key )
00944 return;
00945
00946 m_extra.replace( key, value );
00947 }
00948
00949 const void * KFileItem::extraData( const void *key ) const
00950 {
00951 QMapConstIterator<const void*,void*> it = m_extra.find( key );
00952 if ( it != m_extra.end() )
00953 return it.data();
00954 return 0L;
00955 }
00956
00957 void * KFileItem::extraData( const void *key )
00958 {
00959 QMapIterator<const void*,void*> it = m_extra.find( key );
00960 if ( it != m_extra.end() )
00961 return it.data();
00962 return 0L;
00963 }
00964
00965 void KFileItem::removeExtraData( const void *key )
00966 {
00967 m_extra.remove( key );
00968 }
00969
00970 QString KFileItem::permissionsString() const
00971 {
00972 if (m_access.isNull())
00973 m_access = parsePermissions( m_permissions );
00974
00975 return m_access;
00976 }
00977
00978 QString KFileItem::parsePermissions(mode_t perm) const
00979 {
00980 char p[] = "---------- ";
00981
00982 if (isDir())
00983 p[0]='d';
00984 else if (isLink())
00985 p[0]='l';
00986
00987 if (perm & QFileInfo::ReadUser)
00988 p[1]='r';
00989 if (perm & QFileInfo::WriteUser)
00990 p[2]='w';
00991 if ((perm & QFileInfo::ExeUser) && !(perm & S_ISUID)) p[3]='x';
00992 else if ((perm & QFileInfo::ExeUser) && (perm & S_ISUID)) p[3]='s';
00993 else if (!(perm & QFileInfo::ExeUser) && (perm & S_ISUID)) p[3]='S';
00994
00995 if (perm & QFileInfo::ReadGroup)
00996 p[4]='r';
00997 if (perm & QFileInfo::WriteGroup)
00998 p[5]='w';
00999 if ((perm & QFileInfo::ExeGroup) && !(perm & S_ISGID)) p[6]='x';
01000 else if ((perm & QFileInfo::ExeGroup) && (perm & S_ISGID)) p[6]='s';
01001 else if (!(perm & QFileInfo::ExeGroup) && (perm & S_ISGID)) p[6]='S';
01002
01003 if (perm & QFileInfo::ReadOther)
01004 p[7]='r';
01005 if (perm & QFileInfo::WriteOther)
01006 p[8]='w';
01007 if ((perm & QFileInfo::ExeOther) && !(perm & S_ISVTX)) p[9]='x';
01008 else if ((perm & QFileInfo::ExeOther) && (perm & S_ISVTX)) p[9]='t';
01009 else if (!(perm & QFileInfo::ExeOther) && (perm & S_ISVTX)) p[9]='T';
01010
01011 if (hasExtendedACL())
01012 p[10]='+';
01013
01014 return QString::fromLatin1(p);
01015 }
01016
01017
01018 QString KFileItem::timeString( unsigned int which ) const
01019 {
01020 bool hasTime;
01021 time_t time_ = time(which, hasTime);
01022 if(!hasTime) return QString::null;
01023
01024 QDateTime t;
01025 t.setTime_t( time_);
01026 return KGlobal::locale()->formatDateTime( t );
01027 }
01028
01029 void KFileItem::setMetaInfo( const KFileMetaInfo & info )
01030 {
01031 m_metaInfo = info;
01032 }
01033
01034 const KFileMetaInfo & KFileItem::metaInfo(bool autoget, int) const
01035 {
01036 bool isLocalURL;
01037 KURL url = mostLocalURL(isLocalURL);
01038
01039 if ( autoget && !m_metaInfo.isValid() &&
01040 KGlobalSettings::showFilePreview(url) )
01041 {
01042 m_metaInfo = KFileMetaInfo( url, mimetype() );
01043 }
01044
01045 return m_metaInfo;
01046 }
01047
01048 KURL KFileItem::mostLocalURL(bool &local) const
01049 {
01050 QString local_path = localPath();
01051
01052 if ( !local_path.isEmpty() )
01053 {
01054 local = true;
01055 KURL url;
01056 url.setPath(local_path);
01057 return url;
01058 }
01059 else
01060 {
01061 local = m_bIsLocalURL;
01062 return m_url;
01063 }
01064 }
01065
01066 void KFileItem::virtual_hook( int, void* )
01067 { }
01068
01069 QDataStream & operator<< ( QDataStream & s, const KFileItem & a )
01070 {
01071
01072
01073 s << a.m_url;
01074 s << a.m_strName;
01075 s << a.m_strText;
01076 return s;
01077 }
01078
01079 QDataStream & operator>> ( QDataStream & s, KFileItem & a )
01080 {
01081 s >> a.m_url;
01082 s >> a.m_strName;
01083 s >> a.m_strText;
01084 a.m_bIsLocalURL = a.m_url.isLocalFile();
01085 a.m_bMimeTypeKnown = false;
01086 a.refresh();
01087 return s;
01088 }