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 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(),
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
00129
for (
int i = 0; i < NumFlags; i++ )
00130 m_time[i] = (time_t) -1;
00131
00132
00133
if ( m_fileMode == KFileItem::Unknown || m_permissions == KFileItem::Unknown )
00134 {
00135 mode_t
mode = 0;
00136
if ( m_url.
isLocalFile() )
00137 {
00138
00139
00140
00141
00142
00143
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
00156 mode = (S_IFMT-1) | S_IRWXU | S_IRWXG | S_IRWXO;
00157 }
00158
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;
00163
if ( m_permissions == KFileItem::Unknown )
00164 m_permissions = mode & 07777;
00165 }
00166 }
00167 }
00168
00169
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
00178 _determineMimeTypeOnDemand, &accurate );
00179
00180
00181
00182 m_bMimeTypeKnown = (!_determineMimeTypeOnDemand) || accurate;
00183 }
00184 }
00185
00186 void KFileItem::readUDSEntry(
bool _urlIsDirectory )
00187 {
00188
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();
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
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
00260
00261
00262
00263 m_entry =
KIO::UDSEntry();
00264
init(
false );
00265 }
00266
00267 void KFileItem::refreshMimeType()
00268 {
00269 m_pMimeType = 0L;
00270
init(
false );
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
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
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
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
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
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
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
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);
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)
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)
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
00442 m_bMimeTypeKnown =
true;
00443 }
00444
00445
return m_pMimeType;
00446 }
00447
00448
bool KFileItem::isMimeTypeKnown()
const
00449
{
00450
00451
00452
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
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
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 )
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
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
00530
if ( !m_bMimeTypeKnown && !m_guessedMimeType.
isEmpty() )
00531 mime = KMimeType::mimeType( m_guessedMimeType );
00532
else
00533 mime = m_pMimeType;
00534
00535
00536
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
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
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
00560
00561
00562
00563
00564
00565
00566
00567
if ( !(S_IRUSR & m_permissions) && !(S_IRGRP & m_permissions) && !(S_IROTH & m_permissions) )
00568
return false;
00569
00570
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
00581
00582
00583
00584
00585
00586
00587
00588
if ( !(S_IWUSR & m_permissions) && !(S_IWGRP & m_permissions) && !(S_IWOTH & m_permissions) )
00589
return false;
00590
00591
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
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;
00612 }
00613
return (S_ISDIR(m_fileMode));
00614
00615
00616
00617
00618
00619
00620
00621
00622 }
00623
00624 bool KFileItem::acceptsDrops()
00625 {
00626
00627
if ( S_ISDIR(
mode() ) ) {
00628
return isWritable();
00629 }
00630
00631
00632
if ( !m_bIsLocalURL )
00633
return false;
00634
00635
if (
mimetype() ==
"application/x-desktop")
00636
return true;
00637
00638
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
00684
QString tip;
00685
KFileMetaInfo info =
metaInfo();
00686
00687
00688
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> </s></center></td></tr>";
00722
QStringList keys = info.
preferredKeys();
00723
00724
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
00753
00754
00755
return tip;
00756 }
00757
00758 void KFileItem::run()
00759 {
00760
bool is_local;
00761
KURL url =
mostLocalURL(is_local);
00762
00763
00764
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
00809
00810
00811
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
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 { }
00968
00969
QDataStream & operator<< (
QDataStream & s,
const KFileItem & a )
00970 {
00971
00972
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 }