kio Library API Documentation

kfileitem.cpp

00001 /* This file is part of the KDE project 00002 Copyright (C) 1999 David Faure <faure@kde.org> 00003 2001 Carsten Pfeiffer <pfeiffer@kde.org> 00004 00005 This library is free software; you can redistribute it and/or 00006 modify it under the terms of the GNU Library General Public 00007 License as published by the Free Software Foundation; either 00008 version 2 of the License, or (at your option) any later version. 00009 00010 This library is distributed in the hope that it will be useful, 00011 but WITHOUT ANY WARRANTY; without even the implied warranty of 00012 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00013 Library General Public License for more details. 00014 00015 You should have received a copy of the GNU Library General Public License 00016 along with this library; see the file COPYING.LIB. If not, write to 00017 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, 00018 Boston, MA 02111-1307, USA. 00019 */ 00020 // $Id: kfileitem.cpp,v 1.176.2.2 2005/03/27 15:44:52 brade Exp $ 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 d(0) 00066 { 00067 readUDSEntry( _urlIsDirectory ); 00068 init( _determineMimeTypeOnDemand ); 00069 } 00070 00071 KFileItem::KFileItem( mode_t _mode, mode_t _permissions, const KURL& _url, bool _determineMimeTypeOnDemand ) : 00072 m_entry(), // warning ! 00073 m_url( _url ), 00074 m_strName( _url.fileName() ), 00075 m_strText( KIO::decodeFileName( m_strName ) ), 00076 m_pMimeType( 0 ), 00077 m_fileMode ( _mode ), 00078 m_permissions( _permissions ), 00079 m_bMarked( false ), 00080 m_bLink( false ), 00081 m_bIsLocalURL( _url.isLocalFile() ), 00082 m_bMimeTypeKnown( false ), 00083 d(0) 00084 { 00085 init( _determineMimeTypeOnDemand ); 00086 } 00087 00088 KFileItem::KFileItem( const KURL &url, const QString &mimeType, mode_t mode ) 00089 : m_url( url ), 00090 m_strName( url.fileName() ), 00091 m_strText( KIO::decodeFileName( m_strName ) ), 00092 m_pMimeType( 0 ), 00093 m_fileMode( mode ), 00094 m_permissions( KFileItem::Unknown ), 00095 m_bMarked( false ), 00096 m_bLink( false ), 00097 m_bIsLocalURL( url.isLocalFile() ), 00098 m_bMimeTypeKnown( !mimeType.isEmpty() ), 00099 d(0) 00100 { 00101 if (m_bMimeTypeKnown) 00102 m_pMimeType = KMimeType::mimeType( mimeType ); 00103 00104 init( false ); 00105 } 00106 00107 KFileItem::KFileItem( const KFileItem & item ) : 00108 d(0) 00109 { 00110 assign( item ); 00111 } 00112 00113 KFileItem& KFileItem::operator=( const KFileItem & item ) 00114 { 00115 assign( item ); 00116 return *this; 00117 } 00118 00119 KFileItem::~KFileItem() 00120 { 00121 delete d; 00122 } 00123 00124 void KFileItem::init( bool _determineMimeTypeOnDemand ) 00125 { 00126 m_access = QString::null; 00127 m_size = (KIO::filesize_t) -1; 00128 // metaInfo = KFileMetaInfo(); 00129 for ( int i = 0; i < NumFlags; i++ ) 00130 m_time[i] = (time_t) -1; 00131 00132 // determine mode and/or permissions if unknown 00133 if ( m_fileMode == KFileItem::Unknown || m_permissions == KFileItem::Unknown ) 00134 { 00135 mode_t mode = 0; 00136 if ( m_url.isLocalFile() ) 00137 { 00138 /* directories may not have a slash at the end if 00139 * we want to stat() them; it requires that we 00140 * change into it .. which may not be allowed 00141 * stat("/is/unaccessible") -> rwx------ 00142 * stat("/is/unaccessible/") -> EPERM H.Z. 00143 * This is the reason for the -1 00144 */ 00145 KDE_struct_stat buf; 00146 QCString path = QFile::encodeName(m_url.path( -1 )); 00147 if ( KDE_lstat( path.data(), &buf ) == 0 ) 00148 { 00149 mode = buf.st_mode; 00150 if ( S_ISLNK( mode ) ) 00151 { 00152 m_bLink = true; 00153 if ( KDE_stat( path.data(), &buf ) == 0 ) 00154 mode = buf.st_mode; 00155 else // link pointing to nowhere (see kio/file/file.cc) 00156 mode = (S_IFMT-1) | S_IRWXU | S_IRWXG | S_IRWXO; 00157 } 00158 // While we're at it, store the times 00159 m_time[ Modification ] = buf.st_mtime; 00160 m_time[ Access ] = buf.st_atime; 00161 if ( m_fileMode == KFileItem::Unknown ) 00162 m_fileMode = mode & S_IFMT; // extract file type 00163 if ( m_permissions == KFileItem::Unknown ) 00164 m_permissions = mode & 07777; // extract permissions 00165 } 00166 } 00167 } 00168 00169 // determine the mimetype 00170 if (!m_pMimeType && !m_url.isEmpty()) 00171 { 00172 bool accurate = false; 00173 bool isLocalURL; 00174 KURL url = mostLocalURL(isLocalURL); 00175 00176 m_pMimeType = KMimeType::findByURL( url, m_fileMode, isLocalURL, 00177 // use fast mode if not mimetype on demand 00178 _determineMimeTypeOnDemand, &accurate ); 00179 //kdDebug() << "finding mimetype for " << url.url() << " : " << m_pMimeType->name() << endl; 00180 // if we didn't use fast mode, or if we got a result, then this is the mimetype 00181 // otherwise, determineMimeType will be able to do better. 00182 m_bMimeTypeKnown = (!_determineMimeTypeOnDemand) || accurate; 00183 } 00184 } 00185 00186 void KFileItem::readUDSEntry( bool _urlIsDirectory ) 00187 { 00188 // extract the mode and the filename from the KIO::UDS Entry 00189 bool UDS_URL_seen = false; 00190 00191 KIO::UDSEntry::ConstIterator it = m_entry.begin(); 00192 for( ; it != m_entry.end(); ++it ) { 00193 switch ((*it).m_uds) { 00194 00195 case KIO::UDS_FILE_TYPE: 00196 m_fileMode = (mode_t)((*it).m_long); 00197 break; 00198 00199 case KIO::UDS_ACCESS: 00200 m_permissions = (mode_t)((*it).m_long); 00201 break; 00202 00203 case KIO::UDS_USER: 00204 m_user = ((*it).m_str); 00205 break; 00206 00207 case KIO::UDS_GROUP: 00208 m_group = ((*it).m_str); 00209 break; 00210 00211 case KIO::UDS_NAME: 00212 m_strName = (*it).m_str; 00213 m_strText = KIO::decodeFileName( m_strName ); 00214 break; 00215 00216 case KIO::UDS_URL: 00217 UDS_URL_seen = true; 00218 m_url = KURL((*it).m_str); 00219 if ( m_url.isLocalFile() ) 00220 m_bIsLocalURL = true; 00221 break; 00222 00223 case KIO::UDS_MIME_TYPE: 00224 m_pMimeType = KMimeType::mimeType((*it).m_str); 00225 m_bMimeTypeKnown = true; 00226 break; 00227 00228 case KIO::UDS_GUESSED_MIME_TYPE: 00229 m_guessedMimeType = (*it).m_str; 00230 break; 00231 00232 case KIO::UDS_LINK_DEST: 00233 m_bLink = !(*it).m_str.isEmpty(); // we don't store the link dest 00234 break; 00235 00236 case KIO::UDS_ICON_NAME: 00237 if ( !d ) 00238 d = new KFileItemPrivate(); 00239 d->iconName = (*it).m_str; 00240 break; 00241 } 00242 } 00243 00244 // avoid creating these QStrings again and again 00245 static const QString& dot = KGlobal::staticQString("."); 00246 if ( _urlIsDirectory && !UDS_URL_seen && !m_strName.isEmpty() && m_strName != dot ) 00247 m_url.addPath( m_strName ); 00248 } 00249 00250 void KFileItem::refresh() 00251 { 00252 m_fileMode = KFileItem::Unknown; 00253 m_permissions = KFileItem::Unknown; 00254 m_pMimeType = 0L; 00255 m_user = QString::null; 00256 m_group = QString::null; 00257 m_metaInfo = KFileMetaInfo(); 00258 00259 // Basically, we can't trust any information we got while listing. 00260 // Everything could have changed... 00261 // Clearing m_entry makes it possible to detect changes in the size of the file, 00262 // the time information, etc. 00263 m_entry = KIO::UDSEntry(); 00264 init( false ); 00265 } 00266 00267 void KFileItem::refreshMimeType() 00268 { 00269 m_pMimeType = 0L; 00270 init( false ); // Will determine the mimetype 00271 } 00272 00273 void KFileItem::setURL( const KURL &url ) 00274 { 00275 m_url = url; 00276 setName( url.fileName() ); 00277 } 00278 00279 void KFileItem::setName( const QString& name ) 00280 { 00281 m_strName = name; 00282 m_strText = KIO::decodeFileName( m_strName ); 00283 } 00284 00285 QString KFileItem::linkDest() const 00286 { 00287 // Extract it from the KIO::UDSEntry 00288 KIO::UDSEntry::ConstIterator it = m_entry.begin(); 00289 for( ; it != m_entry.end(); ++it ) 00290 if ( (*it).m_uds == KIO::UDS_LINK_DEST ) 00291 return (*it).m_str; 00292 // If not in the KIO::UDSEntry, or if UDSEntry empty, use readlink() [if local URL] 00293 if ( m_bIsLocalURL ) 00294 { 00295 char buf[1000]; 00296 int n = readlink( QFile::encodeName(m_url.path( -1 )), buf, sizeof(buf)-1 ); 00297 if ( n != -1 ) 00298 { 00299 buf[ n ] = 0; 00300 return QFile::decodeName( buf ); 00301 } 00302 } 00303 return QString::null; 00304 } 00305 00306 QString KFileItem::localPath() const 00307 { 00308 if ( m_bIsLocalURL ) 00309 { 00310 return m_url.path(); 00311 } 00312 else 00313 { 00314 // Extract the local path from the KIO::UDSEntry 00315 KIO::UDSEntry::ConstIterator it = m_entry.begin(); 00316 const KIO::UDSEntry::ConstIterator end = m_entry.end(); 00317 for( ; it != end; ++it ) 00318 if ( (*it).m_uds == KIO::UDS_LOCAL_PATH ) 00319 return (*it).m_str; 00320 } 00321 00322 return QString::null; 00323 } 00324 00325 KIO::filesize_t KFileItem::size() const 00326 { 00327 if ( m_size != (KIO::filesize_t) -1 ) 00328 return m_size; 00329 00330 // Extract it from the KIO::UDSEntry 00331 KIO::UDSEntry::ConstIterator it = m_entry.begin(); 00332 for( ; it != m_entry.end(); ++it ) 00333 if ( (*it).m_uds == KIO::UDS_SIZE ) { 00334 m_size = (*it).m_long; 00335 return m_size; 00336 } 00337 // If not in the KIO::UDSEntry, or if UDSEntry empty, use stat() [if local URL] 00338 if ( m_bIsLocalURL ) 00339 { 00340 KDE_struct_stat buf; 00341 if ( KDE_stat( QFile::encodeName(m_url.path( -1 )), &buf ) == 0 ) 00342 return buf.st_size; 00343 } 00344 return 0L; 00345 } 00346 00347 time_t KFileItem::time( unsigned int which ) const 00348 { 00349 unsigned int mappedWhich = 0; 00350 00351 switch( which ) { 00352 case KIO::UDS_MODIFICATION_TIME: 00353 mappedWhich = Modification; 00354 break; 00355 case KIO::UDS_ACCESS_TIME: 00356 mappedWhich = Access; 00357 break; 00358 case KIO::UDS_CREATION_TIME: 00359 mappedWhich = Creation; 00360 break; 00361 } 00362 00363 if ( m_time[mappedWhich] != (time_t) -1 ) 00364 return m_time[mappedWhich]; 00365 00366 // Extract it from the KIO::UDSEntry 00367 KIO::UDSEntry::ConstIterator it = m_entry.begin(); 00368 for( ; it != m_entry.end(); ++it ) 00369 if ( (*it).m_uds == which ) { 00370 m_time[mappedWhich] = static_cast<time_t>((*it).m_long); 00371 return m_time[mappedWhich]; 00372 } 00373 00374 // If not in the KIO::UDSEntry, or if UDSEntry empty, use stat() [if local URL] 00375 if ( m_bIsLocalURL ) 00376 { 00377 KDE_struct_stat buf; 00378 if ( KDE_stat( QFile::encodeName(m_url.path(-1)), &buf ) == 0 ) 00379 { 00380 m_time[mappedWhich] = (which == KIO::UDS_MODIFICATION_TIME) ? 00381 buf.st_mtime : 00382 (which == KIO::UDS_ACCESS_TIME) ? buf.st_atime : 00383 static_cast<time_t>(0); // We can't determine creation time for local files 00384 return m_time[mappedWhich]; 00385 } 00386 } 00387 return static_cast<time_t>(0); 00388 } 00389 00390 00391 QString KFileItem::user() const 00392 { 00393 if ( m_user.isEmpty() && m_bIsLocalURL ) 00394 { 00395 KDE_struct_stat buff; 00396 if ( KDE_lstat( QFile::encodeName(m_url.path( -1 )), &buff ) == 0) // get uid/gid of the link, if it's a link 00397 { 00398 struct passwd *user = getpwuid( buff.st_uid ); 00399 if ( user != 0L ) 00400 m_user = QString::fromLocal8Bit(user->pw_name); 00401 } 00402 } 00403 return m_user; 00404 } 00405 00406 QString KFileItem::group() const 00407 { 00408 #ifdef Q_OS_UNIX 00409 if (m_group.isEmpty() && m_bIsLocalURL ) 00410 { 00411 KDE_struct_stat buff; 00412 if ( KDE_lstat( QFile::encodeName(m_url.path( -1 )), &buff ) == 0) // get uid/gid of the link, if it's a link 00413 { 00414 struct group *ge = getgrgid( buff.st_gid ); 00415 if ( ge != 0L ) { 00416 m_group = QString::fromLocal8Bit(ge->gr_name); 00417 if (m_group.isEmpty()) 00418 m_group.sprintf("%d",ge->gr_gid); 00419 } else 00420 m_group.sprintf("%d",buff.st_gid); 00421 } 00422 } 00423 #endif 00424 return m_group; 00425 } 00426 00427 QString KFileItem::mimetype() const 00428 { 00429 KFileItem * that = const_cast<KFileItem *>(this); 00430 return that->determineMimeType()->name(); 00431 } 00432 00433 KMimeType::Ptr KFileItem::determineMimeType() 00434 { 00435 if ( !m_pMimeType || !m_bMimeTypeKnown ) 00436 { 00437 bool isLocalURL; 00438 KURL url = mostLocalURL(isLocalURL); 00439 00440 m_pMimeType = KMimeType::findByURL( url, m_fileMode, isLocalURL ); 00441 //kdDebug() << "finding mimetype for " << url.url() << " : " << m_pMimeType->name() << endl; 00442 m_bMimeTypeKnown = true; 00443 } 00444 00445 return m_pMimeType; 00446 } 00447 00448 bool KFileItem::isMimeTypeKnown() const 00449 { 00450 // The mimetype isn't known if determineMimeType was never called (on-demand determination) 00451 // or if this fileitem has a guessed mimetype (e.g. ftp symlink) - in which case 00452 // it always remains "not fully determined" 00453 return m_bMimeTypeKnown && m_guessedMimeType.isEmpty(); 00454 } 00455 00456 QString KFileItem::mimeComment() 00457 { 00458 KMimeType::Ptr mType = determineMimeType(); 00459 00460 bool isLocalURL; 00461 KURL url = mostLocalURL(isLocalURL); 00462 00463 QString comment = mType->comment( url, isLocalURL ); 00464 //kdDebug() << "finding comment for " << url.url() << " : " << m_pMimeType->name() << endl; 00465 if (!comment.isEmpty()) 00466 return comment; 00467 else 00468 return mType->name(); 00469 } 00470 00471 QString KFileItem::iconName() 00472 { 00473 if (d && (!d->iconName.isEmpty())) return d->iconName; 00474 00475 bool isLocalURL; 00476 KURL url = mostLocalURL(isLocalURL); 00477 00478 //kdDebug() << "finding icon for " << url.url() << " : " << m_pMimeType->name() << endl; 00479 return determineMimeType()->icon(url, isLocalURL); 00480 } 00481 00482 int KFileItem::overlays() const 00483 { 00484 int _state = 0; 00485 if ( m_bLink ) 00486 _state |= KIcon::LinkOverlay; 00487 00488 if ( !S_ISDIR( m_fileMode ) // Locked dirs have a special icon, use the overlay for files only 00489 && !isReadable()) 00490 _state |= KIcon::LockOverlay; 00491 00492 if ( isHidden() ) 00493 _state |= KIcon::HiddenOverlay; 00494 00495 if( S_ISDIR( m_fileMode ) && m_bIsLocalURL) 00496 { 00497 if (KSambaShare::instance()->isDirectoryShared( m_url.path() ) || 00498 KNFSShare::instance()->isDirectoryShared( m_url.path() )) 00499 { 00500 //kdDebug()<<"KFileShare::isDirectoryShared : "<<m_url.path()<<endl; 00501 _state |= KIcon::ShareOverlay; 00502 } 00503 } 00504 00505 if ( m_pMimeType->name() == "application/x-gzip" && m_url.fileName().right(3) == ".gz" ) 00506 _state |= KIcon::ZipOverlay; 00507 return _state; 00508 } 00509 00510 QPixmap KFileItem::pixmap( int _size, int _state ) const 00511 { 00512 if (d && (!d->iconName.isEmpty())) 00513 return DesktopIcon(d->iconName,_size,_state); 00514 00515 if ( !m_pMimeType ) 00516 { 00517 static const QString & defaultFolderIcon = 00518 KGlobal::staticQString(KMimeType::mimeType( "inode/directory" )->KServiceType::icon()); 00519 00520 if ( S_ISDIR( m_fileMode ) ) 00521 return DesktopIcon( defaultFolderIcon, _size, _state ); 00522 00523 return DesktopIcon( "unknown", _size, _state ); 00524 } 00525 00526 _state |= overlays(); 00527 00528 KMimeType::Ptr mime; 00529 // Use guessed mimetype if the main one hasn't been determined for sure 00530 if ( !m_bMimeTypeKnown && !m_guessedMimeType.isEmpty() ) 00531 mime = KMimeType::mimeType( m_guessedMimeType ); 00532 else 00533 mime = m_pMimeType; 00534 00535 // Support for gzipped files: extract mimetype of contained file 00536 // See also the relevant code in overlays, which adds the zip overlay. 00537 if ( mime->name() == "application/x-gzip" && m_url.fileName().right(3) == ".gz" ) 00538 { 00539 KURL sf; 00540 sf.setPath( m_url.path().left( m_url.path().length() - 3 ) ); 00541 //kdDebug() << "KFileItem::pixmap subFileName=" << subFileName << endl; 00542 mime = KMimeType::findByURL( sf, 0, m_bIsLocalURL ); 00543 } 00544 00545 bool isLocalURL; 00546 KURL url = mostLocalURL(isLocalURL); 00547 00548 QPixmap p = mime->pixmap( url, KIcon::Desktop, _size, _state ); 00549 //kdDebug() << "finding pixmap for " << url.url() << " : " << mime->name() << endl; 00550 if (p.isNull()) 00551 kdWarning() << "Pixmap not found for mimetype " << m_pMimeType->name() << endl; 00552 00553 return p; 00554 } 00555 00556 bool KFileItem::isReadable() const 00557 { 00558 /* 00559 struct passwd * user = getpwuid( geteuid() ); 00560 bool isMyFile = (QString::fromLocal8Bit(user->pw_name) == m_user); 00561 // This gets ugly for the group.... 00562 // Maybe we want a static QString for the user and a static QStringList 00563 // for the groups... then we need to handle the deletion properly... 00564 */ 00565 00566 // No read permission at all 00567 if ( !(S_IRUSR & m_permissions) && !(S_IRGRP & m_permissions) && !(S_IROTH & m_permissions) ) 00568 return false; 00569 00570 // Or if we can't read it [using ::access()] - not network transparent 00571 else if ( m_bIsLocalURL && ::access( QFile::encodeName(m_url.path()), R_OK ) == -1 ) 00572 return false; 00573 00574 return true; 00575 } 00576 00577 bool KFileItem::isWritable() const 00578 { 00579 /* 00580 struct passwd * user = getpwuid( geteuid() ); 00581 bool isMyFile = (QString::fromLocal8Bit(user->pw_name) == m_user); 00582 // This gets ugly for the group.... 00583 // Maybe we want a static QString for the user and a static QStringList 00584 // for the groups... then we need to handle the deletion properly... 00585 */ 00586 00587 // No write permission at all 00588 if ( !(S_IWUSR & m_permissions) && !(S_IWGRP & m_permissions) && !(S_IWOTH & m_permissions) ) 00589 return false; 00590 00591 // Or if we can't read it [using ::access()] - not network transparent 00592 else if ( m_bIsLocalURL && ::access( QFile::encodeName(m_url.path()), W_OK ) == -1 ) 00593 return false; 00594 00595 return true; 00596 } 00597 00598 bool KFileItem::isHidden() const 00599 { 00600 if ( !m_url.isEmpty() ) 00601 return m_url.fileName()[0] == '.'; 00602 else // should never happen 00603 return m_strName[0] == '.'; 00604 } 00605 00606 bool KFileItem::isDir() const 00607 { 00608 if ( m_fileMode == KFileItem::Unknown ) 00609 { 00610 kdDebug() << " KFileItem::isDir can't say -> false " << endl; 00611 return false; // can't say for sure, so no 00612 } 00613 return (S_ISDIR(m_fileMode)); 00614 /* 00615 if (!S_ISDIR(m_fileMode)) { 00616 if (m_url.isLocalFile()) { 00617 KMimeType::Ptr ptr=KMimeType::findByURL(m_url,0,true,true); 00618 if ((ptr!=0) && (ptr->is("directory/inode"))) return true; 00619 } 00620 return false 00621 } else return true;*/ 00622 } 00623 00624 bool KFileItem::acceptsDrops() 00625 { 00626 // A directory ? 00627 if ( S_ISDIR( mode() ) ) { 00628 return isWritable(); 00629 } 00630 00631 // But only local .desktop files and executables 00632 if ( !m_bIsLocalURL ) 00633 return false; 00634 00635 if ( mimetype() == "application/x-desktop") 00636 return true; 00637 00638 // Executable, shell script ... ? 00639 if ( ::access( QFile::encodeName(m_url.path()), X_OK ) == 0 ) 00640 return true; 00641 00642 return false; 00643 } 00644 00645 QString KFileItem::getStatusBarInfo() 00646 { 00647 QString text = m_strText; 00648 00649 if ( m_bLink ) 00650 { 00651 QString comment = determineMimeType()->comment( m_url, m_bIsLocalURL ); 00652 QString tmp; 00653 if ( comment.isEmpty() ) 00654 tmp = i18n ( "Symbolic Link" ); 00655 else 00656 tmp = i18n("%1 (Link)").arg(comment); 00657 text += "->"; 00658 text += linkDest(); 00659 text += " "; 00660 text += tmp; 00661 } 00662 else if ( S_ISREG( m_fileMode ) ) 00663 { 00664 text += QString(" (%1)").arg( KIO::convertSize( size() ) ); 00665 text += " "; 00666 text += mimeComment(); 00667 } 00668 else if ( S_ISDIR ( m_fileMode ) ) 00669 { 00670 text += "/ "; 00671 text += mimeComment(); 00672 } 00673 else 00674 { 00675 text += " "; 00676 text += mimeComment(); 00677 } 00678 return text; 00679 } 00680 00681 QString KFileItem::getToolTipText(int maxcount) 00682 { 00683 // we can return QString::null if no tool tip should be shown 00684 QString tip; 00685 KFileMetaInfo info = metaInfo(); 00686 00687 // the font tags are a workaround for the fact that the tool tip gets 00688 // screwed if the color scheme uses white as default text color 00689 const char* start = "<tr><td><nobr><font color=\"black\">"; 00690 const char* mid = "</font></nobr></td><td><nobr><font color=\"black\">"; 00691 const char* end = "</font></nobr></td></tr>"; 00692 00693 tip = "<table cellspacing=0 cellpadding=0>"; 00694 00695 tip += start + i18n("Name:") + mid + text() + end; 00696 tip += start + i18n("Type:") + mid; 00697 00698 QString type = QStyleSheet::escape(mimeComment()); 00699 if ( m_bLink ) { 00700 tip += i18n("Link to %1 (%2)").arg(linkDest(), type) + end; 00701 } else 00702 tip += type + end; 00703 00704 if ( !S_ISDIR ( m_fileMode ) ) 00705 tip += start + i18n("Size:") + mid + 00706 QString("%1 (%2)").arg(KIO::convertSize(size())) 00707 .arg(KGlobal::locale()->formatNumber(size(), 0)) + 00708 end; 00709 00710 tip += start + i18n("Modified:") + mid + 00711 timeString( KIO::UDS_MODIFICATION_TIME) + end 00712 #ifndef Q_WS_WIN //TODO: show win32-specific permissions 00713 +start + i18n("Owner:") + mid + user() + " - " + group() + end + 00714 start + i18n("Permissions:") + mid + 00715 parsePermissions(m_permissions) + end 00716 #endif 00717 ; 00718 00719 if (info.isValid() && !info.isEmpty() ) 00720 { 00721 tip += "<tr><td colspan=2><center><s>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</s></center></td></tr>"; 00722 QStringList keys = info.preferredKeys(); 00723 00724 // now the rest 00725 QStringList::Iterator it = keys.begin(); 00726 for (int count = 0; count<maxcount && it!=keys.end() ; ++it) 00727 { 00728 KFileMetaInfoItem item = info.item( *it ); 00729 if ( item.isValid() ) 00730 { 00731 QString s = item.string(); 00732 if ( ( item.attributes() & KFileMimeTypeInfo::SqueezeText ) 00733 && s.length() > 50) { 00734 s.truncate(47); 00735 s.append("..."); 00736 } 00737 if ( !s.isEmpty() ) 00738 { 00739 count++; 00740 tip += start + 00741 QStyleSheet::escape( item.translatedKey() ) + ":" + 00742 mid + 00743 QStyleSheet::escape( s ) + 00744 end; 00745 } 00746 00747 } 00748 } 00749 } 00750 tip += "</table>"; 00751 00752 //kdDebug() << "making this the tool tip rich text:\n"; 00753 //kdDebug() << tip << endl; 00754 00755 return tip; 00756 } 00757 00758 void KFileItem::run() 00759 { 00760 bool is_local; 00761 KURL url = mostLocalURL(is_local); 00762 // When clicking on a link to e.g. $HOME from the desktop, we want to open $HOME 00763 // But when following a link on the FTP site, the target be an absolute path 00764 // that doesn't work in the URL. So we resolve links only on the local filesystem. 00765 if ( m_bLink && is_local ) 00766 url = KURL( m_url, linkDest() ); 00767 (void) new KRun( url, m_fileMode, is_local ); 00768 } 00769 00770 bool KFileItem::cmp( const KFileItem & item ) 00771 { 00772 return ( m_strName == item.m_strName 00773 && m_bIsLocalURL == item.m_bIsLocalURL 00774 && m_fileMode == item.m_fileMode 00775 && m_permissions == item.m_permissions 00776 && m_user == item.m_user 00777 && m_group == item.m_group 00778 && m_bLink == item.m_bLink 00779 && size() == item.size() 00780 && time(KIO::UDS_MODIFICATION_TIME) == item.time(KIO::UDS_MODIFICATION_TIME) 00781 && mimetype() == item.mimetype() 00782 && (!d || !item.d || d->iconName == item.d->iconName) ); 00783 } 00784 00785 void KFileItem::assign( const KFileItem & item ) 00786 { 00787 if ( this == &item ) 00788 return; 00789 m_entry = item.m_entry; 00790 m_url = item.m_url; 00791 m_bIsLocalURL = item.m_bIsLocalURL; 00792 m_strName = item.m_strName; 00793 m_strText = item.m_strText; 00794 m_fileMode = item.m_fileMode; 00795 m_permissions = item.m_permissions; 00796 m_user = item.m_user; 00797 m_group = item.m_group; 00798 m_bLink = item.m_bLink; 00799 m_pMimeType = item.m_pMimeType; 00800 m_strLowerCaseName = item.m_strLowerCaseName; 00801 m_bMimeTypeKnown = item.m_bMimeTypeKnown; 00802 m_guessedMimeType = item.m_guessedMimeType; 00803 m_access = item.m_access; 00804 m_metaInfo = item.m_metaInfo; 00805 for ( int i = 0; i < NumFlags; i++ ) 00806 m_time[i] = item.m_time[i]; 00807 m_size = item.m_size; 00808 // note: m_extra is NOT copied, as we'd have no control over who is 00809 // deleting the data or not. 00810 00811 // We had a mimetype previously (probably), so we need to re-determine it 00812 determineMimeType(); 00813 00814 if ( item.d ) { 00815 if ( !d ) 00816 d = new KFileItemPrivate; 00817 d->iconName = item.d->iconName; 00818 } else { 00819 delete d; 00820 d = 0; 00821 } 00822 } 00823 00824 void KFileItem::setUDSEntry( const KIO::UDSEntry& _entry, const KURL& _url, 00825 bool _determineMimeTypeOnDemand, bool _urlIsDirectory ) 00826 { 00827 m_entry = _entry; 00828 m_url = _url; 00829 m_strName = QString::null; 00830 m_strText = QString::null; 00831 m_user = QString::null; 00832 m_group = QString::null; 00833 m_strLowerCaseName = QString::null; 00834 m_pMimeType = 0; 00835 m_fileMode = KFileItem::Unknown; 00836 m_permissions = KFileItem::Unknown; 00837 m_bMarked = false; 00838 m_bLink = false; 00839 m_bIsLocalURL = _url.isLocalFile(); 00840 m_bMimeTypeKnown = false; 00841 m_guessedMimeType = QString::null; 00842 m_metaInfo = KFileMetaInfo(); 00843 00844 if ( d ) 00845 d->iconName = QString::null; 00846 00847 readUDSEntry( _urlIsDirectory ); 00848 init( _determineMimeTypeOnDemand ); 00849 } 00850 00851 void KFileItem::setExtraData( const void *key, void *value ) 00852 { 00853 if ( !key ) 00854 return; 00855 00856 m_extra.replace( key, value ); 00857 } 00858 00859 const void * KFileItem::extraData( const void *key ) const 00860 { 00861 QMapConstIterator<const void*,void*> it = m_extra.find( key ); 00862 if ( it != m_extra.end() ) 00863 return it.data(); 00864 return 0L; 00865 } 00866 00867 void * KFileItem::extraData( const void *key ) 00868 { 00869 QMapIterator<const void*,void*> it = m_extra.find( key ); 00870 if ( it != m_extra.end() ) 00871 return it.data(); 00872 return 0L; 00873 } 00874 00875 void KFileItem::removeExtraData( const void *key ) 00876 { 00877 m_extra.remove( key ); 00878 } 00879 00880 QString KFileItem::permissionsString() const 00881 { 00882 if (m_access.isNull()) 00883 m_access = parsePermissions( m_permissions ); 00884 00885 return m_access; 00886 } 00887 00888 QString KFileItem::parsePermissions(mode_t perm) const 00889 { 00890 char p[] = "----------"; 00891 00892 if (isDir()) 00893 p[0]='d'; 00894 else if (isLink()) 00895 p[0]='l'; 00896 00897 if (perm & QFileInfo::ReadUser) 00898 p[1]='r'; 00899 if (perm & QFileInfo::WriteUser) 00900 p[2]='w'; 00901 if (perm & QFileInfo::ExeUser) 00902 p[3]='x'; 00903 00904 if (perm & QFileInfo::ReadGroup) 00905 p[4]='r'; 00906 if (perm & QFileInfo::WriteGroup) 00907 p[5]='w'; 00908 if (perm & QFileInfo::ExeGroup) 00909 p[6]='x'; 00910 00911 if (perm & QFileInfo::ReadOther) 00912 p[7]='r'; 00913 if (perm & QFileInfo::WriteOther) 00914 p[8]='w'; 00915 if (perm & QFileInfo::ExeOther) 00916 p[9]='x'; 00917 00918 return QString::fromLatin1(p); 00919 } 00920 00921 // check if we need to cache this 00922 QString KFileItem::timeString( unsigned int which ) const 00923 { 00924 QDateTime t; 00925 t.setTime_t( time(which) ); 00926 return KGlobal::locale()->formatDateTime( t ); 00927 } 00928 00929 void KFileItem::setMetaInfo( const KFileMetaInfo & info ) 00930 { 00931 m_metaInfo = info; 00932 } 00933 00934 const KFileMetaInfo & KFileItem::metaInfo(bool autoget, int) const 00935 { 00936 bool isLocalURL; 00937 KURL url = mostLocalURL(isLocalURL); 00938 00939 if ( autoget && !m_metaInfo.isValid() && 00940 KGlobalSettings::showFilePreview(url) ) 00941 { 00942 m_metaInfo = KFileMetaInfo( url, mimetype() ); 00943 } 00944 00945 return m_metaInfo; 00946 } 00947 00948 KURL KFileItem::mostLocalURL(bool &local) const 00949 { 00950 QString local_path = localPath(); 00951 00952 if ( !local_path.isEmpty() ) 00953 { 00954 local = true; 00955 KURL url; 00956 url.setPath(local_path); 00957 return url; 00958 } 00959 else 00960 { 00961 local = m_bIsLocalURL; 00962 return m_url; 00963 } 00964 } 00965 00966 void KFileItem::virtual_hook( int, void* ) 00967 { /*BASE::virtual_hook( id, data );*/ } 00968 00969 QDataStream & operator<< ( QDataStream & s, const KFileItem & a ) 00970 { 00971 // We don't need to save/restore anything that refresh() invalidates, 00972 // since that means we can re-determine those by ourselves. 00973 s << a.m_url; 00974 s << a.m_strName; 00975 s << a.m_strText; 00976 return s; 00977 } 00978 00979 QDataStream & operator>> ( QDataStream & s, KFileItem & a ) 00980 { 00981 s >> a.m_url; 00982 s >> a.m_strName; 00983 s >> a.m_strText; 00984 a.m_bIsLocalURL = a.m_url.isLocalFile(); 00985 a.m_bMimeTypeKnown = false; 00986 a.refresh(); 00987 return s; 00988 }
KDE Logo
This file is part of the documentation for kio Library Version 3.4.0.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Thu Apr 14 00:20:24 2005 by doxygen 1.3.7 written by Dimitri van Heesch, © 1997-2003