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