00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
#include <assert.h>
00024
00025
#include <qshared.h>
00026
#include <qdict.h>
00027
00028
#include <ktrader.h>
00029
#include <kstaticdeleter.h>
00030
#include <kparts/componentfactory.h>
00031
#include <kuserprofile.h>
00032
#include <kdebug.h>
00033
#include <kmimetype.h>
00034
#include <kdatastream.h>
00035
#include <klocale.h>
00036
#include <kio/global.h>
00037
00038
#include "kfilemetainfo.h"
00039
00040
00041
class KFileMetaInfoItem::Data :
public QShared
00042 {
00043
public:
00044 Data(
const KFileMimeTypeInfo::ItemInfo* mti,
const QString& _key,
00045
const QVariant& _value )
00046 : QShared(),
00047 mimeTypeInfo( mti ),
00048
key( _key ),
00049 value( _value ),
00050 dirty( false ),
00051 added( false ),
00052 removed( false )
00053 {}
00054
00055
00056 Data() : mimeTypeInfo( 0L )
00057 {}
00058
00059 ~Data()
00060 {
00061
if (
this == null )
00062
delete mimeTypeInfo;
00063 }
00064
00065
const KFileMimeTypeInfo::ItemInfo* mimeTypeInfo;
00066
00067
QString key;
00068
QVariant value;
00069
bool dirty :1;
00070
bool added :1;
00071
bool removed :1;
00072
00073
static Data* null;
00074
static Data* makeNull();
00075 };
00076
00077
00078 KFileMetaInfoItem::Data* KFileMetaInfoItem::Data::null = 0L;
00079
static KStaticDeleter<KFileMetaInfoItem::Data> sd_KFileMetaInfoItemData;
00080
00081 KFileMetaInfoItem::Data* KFileMetaInfoItem::Data::makeNull()
00082 {
00083
if (!null)
00084 {
00085
00086
00087
00088
00089
KFileMimeTypeInfo::ItemInfo* info =
new KFileMimeTypeInfo::ItemInfo();
00090 null =
new Data(info, QString::null,
QVariant());
00091 sd_KFileMetaInfoItemData.setObject( null );
00092 }
00093
return null;
00094 }
00095
00096
KFileMetaInfoItem::KFileMetaInfoItem(
const KFileMimeTypeInfo::ItemInfo* mti,
00097
const QString& key,
const QVariant& value )
00098 : d( new Data( mti,
key, value ) )
00099 {
00100 }
00101
00102 KFileMetaInfoItem::KFileMetaInfoItem(
const KFileMetaInfoItem& item )
00103 {
00104
00105 d = Data::makeNull();
00106 *
this = item;
00107 }
00108
00109 KFileMetaInfoItem::KFileMetaInfoItem()
00110 {
00111 d = Data::makeNull();
00112 }
00113
00114 KFileMetaInfoItem::~KFileMetaInfoItem()
00115 {
00116 deref();
00117 }
00118
00119
const KFileMetaInfoItem& KFileMetaInfoItem::operator=
00120 (
const KFileMetaInfoItem & item )
00121 {
00122
if (d != item.d)
00123 {
00124
00125 deref();
00126 d = item.d;
00127
00128 ref();
00129 }
00130
00131
return *
this;
00132 }
00133
00134 bool KFileMetaInfoItem::setValue(
const QVariant& value )
00135 {
00136
00137
if ( d == Data::null )
return false;
00138
00139
if ( ! (d->mimeTypeInfo->attributes() & KFileMimeTypeInfo::Modifiable ) ||
00140 ! (value.canCast(d->mimeTypeInfo->type())))
00141 {
00142
kdDebug(7033) <<
"setting the value of " <<
key() <<
"failed\n";
00143
return false;
00144 }
00145
00146
00147
00148
if ( d->value == value )
00149
return true;
00150
00151 d->dirty =
true;
00152 d->value = value;
00153
00154
00155 d->value.cast(d->mimeTypeInfo->type());
00156
00157
return true;
00158 }
00159
00160 bool KFileMetaInfoItem::isRemoved()
const
00161
{
00162
return d->removed;
00163 }
00164
00165 QString KFileMetaInfoItem::key()
const
00166
{
00167
return d->key;
00168 }
00169
00170 QString KFileMetaInfoItem::translatedKey()
const
00171
{
00172
00173
if (d->mimeTypeInfo->key().isNull())
00174 {
00175
00176
return i18n(d->key.utf8());
00177 }
00178
00179
return d->mimeTypeInfo->translatedKey();
00180 }
00181
00182 const QVariant&
KFileMetaInfoItem::value()
const
00183
{
00184
return d->value;
00185 }
00186
00187 QString KFileMetaInfoItem::string(
bool mangle )
const
00188
{
00189
return d->mimeTypeInfo->string(d->value, mangle);
00190 }
00191
00192 QVariant::Type
KFileMetaInfoItem::type()
const
00193
{
00194
return d->mimeTypeInfo->type();
00195 }
00196
00197 uint
KFileMetaInfoItem::unit()
const
00198
{
00199
return d->mimeTypeInfo->unit();
00200 }
00201
00202 bool KFileMetaInfoItem::isModified()
const
00203
{
00204
return d->dirty;
00205 }
00206
00207 QString KFileMetaInfoItem::prefix()
const
00208
{
00209
return d->mimeTypeInfo->prefix();
00210 }
00211
00212 QString KFileMetaInfoItem::suffix()
const
00213
{
00214
return d->mimeTypeInfo->suffix();
00215 }
00216
00217 uint
KFileMetaInfoItem::hint()
const
00218
{
00219
return d->mimeTypeInfo->hint();
00220 }
00221
00222 uint
KFileMetaInfoItem::attributes()
const
00223
{
00224
return d->mimeTypeInfo->attributes();
00225 }
00226
00227 bool KFileMetaInfoItem::isEditable()
const
00228
{
00229
return d->mimeTypeInfo->attributes() & KFileMimeTypeInfo::Modifiable;
00230 }
00231
00232 bool KFileMetaInfoItem::isValid()
const
00233
{
00234
00235
00236
00237
return d != Data::null;
00238 }
00239
00240
void KFileMetaInfoItem::setAdded()
00241 {
00242 d->added =
true;
00243 }
00244
00245
void KFileMetaInfoItem::setRemoved()
00246 {
00247 d->removed =
true;
00248 }
00249
00250
void KFileMetaInfoItem::ref()
00251 {
00252
if (d != Data::null) d->ref();
00253 }
00254
00255
void KFileMetaInfoItem::deref()
00256 {
00257
00258
00259
00260
if ((d != Data::null) && d->deref())
00261 {
00262
00263
00264
delete d;
00265 d = 0;
00266 }
00267 }
00268
00271
00272
00273
class KFileMetaInfo::Data :
public QShared
00274 {
00275
public:
00276 Data(
const KURL& _url, uint _what)
00277 : QShared(),
00278 url(_url),
00279 what(_what),
00280 mimeTypeInfo( 0L )
00281 {}
00282
00283
00284 Data() {};
00285
00286
KURL url;
00287 uint what;
00288
QMap<QString, KFileMetaInfoGroup> groups;
00289
const KFileMimeTypeInfo* mimeTypeInfo;
00290
QStringList removedGroups;
00291
00292
static Data* null;
00293
static Data* makeNull();
00294
00295 };
00296
00297 KFileMetaInfo::KFileMetaInfo(
const QString& path,
const QString& mimeType,
00298 uint what )
00299 {
00300
KURL u;
00301
00302 u.
setPath(path);
00303 init(u, mimeType, what);
00304 }
00305
00306 KFileMetaInfo::KFileMetaInfo(
const KURL& url,
const QString& mimeType,
00307 uint what )
00308 {
00309 init(url, mimeType, what);
00310 }
00311
00312
void KFileMetaInfo::init(
const KURL& url,
const QString& mimeType,
00313 uint what )
00314 {
00315 d =
new Data( url, what );
00316
00317
QString mT;
00318
if (mimeType.isEmpty())
00319 mT = KMimeType::findByURL(url)->name();
00320
else
00321 mT = mimeType;
00322
00323
00324
KFileMetaInfo item(*
this);
00325
00326
00327
00328 d->mimeTypeInfo = KFileMetaInfoProvider::self()->mimeTypeInfo( mT, url.
protocol() );
00329
if ( d->mimeTypeInfo )
00330 {
00331
00332
KFilePlugin *p =
plugin();
00333 Q_ASSERT( p );
00334
if ( p && !p->
readInfo( item, what) )
00335 d = Data::makeNull();
00336 }
00337
else
00338 {
00339
00340 d = Data::makeNull();
00341 }
00342 }
00343
00344 KFileMetaInfo::KFileMetaInfo(
const KFileMetaInfo& original )
00345 {
00346
00347 d = Data::makeNull();
00348 *
this = original;
00349 }
00350
00351 KFileMetaInfo::KFileMetaInfo()
00352 {
00353 d = Data::makeNull();
00354 }
00355
00356 KFileMetaInfo::~KFileMetaInfo()
00357 {
00358 deref();
00359 }
00360
00361 QStringList KFileMetaInfo::supportedGroups()
const
00362
{
00363 assert(
isValid());
00364
return d->mimeTypeInfo->supportedGroups();
00365 }
00366
00367 QStringList KFileMetaInfo::supportedKeys()
const
00368
{
00369 assert(
isValid());
00370
return d->mimeTypeInfo->supportedKeys();
00371 }
00372
00373 QStringList KFileMetaInfo::groups()
const
00374
{
00375
QStringList list;
00376
QMapConstIterator<QString, KFileMetaInfoGroup> it = d->groups.begin();
00377
for ( ; it != d->groups.end(); ++it )
00378 list += (*it).name();
00379
00380
return list;
00381 }
00382
00383 QStringList KFileMetaInfo::editableGroups()
const
00384
{
00385
QStringList list;
00386
QStringList supported =
supportedGroups();
00387 QStringList::ConstIterator it = supported.begin();
00388
for ( ; it != supported.end(); ++it ) {
00389
const KFileMimeTypeInfo::GroupInfo * groupInfo = d->mimeTypeInfo->groupInfo( *it );
00390
if ( groupInfo && groupInfo->
attributes() &
00391 (KFileMimeTypeInfo::Addable | KFileMimeTypeInfo::Removable) )
00392 list.append( *it );
00393 }
00394
00395
return list;
00396 }
00397
00398 QStringList KFileMetaInfo::preferredGroups()
const
00399
{
00400 assert(
isValid());
00401
QStringList list =
groups();
00402
QStringList newlist;
00403
QStringList preferred = d->mimeTypeInfo->preferredGroups();
00404 QStringList::Iterator pref;
00405
00406
00407
for ( pref = preferred.begin(); pref != preferred.end(); pref++ )
00408 {
00409 QStringList::Iterator
group = list.find(*pref);
00410
if ( group != list.end() )
00411 {
00412 newlist.append( *group );
00413 list.remove(group);
00414 }
00415 }
00416
00417
00418
00419 newlist += list;
00420
00421
return newlist;
00422 }
00423
00424 QStringList KFileMetaInfo::preferredKeys()
const
00425
{
00426
QStringList newlist;
00427
00428
QStringList list =
preferredGroups();
00429
for (QStringList::Iterator git = list.begin(); git != list.end(); ++git)
00430 {
00431 newlist += d->groups[*git].preferredKeys();
00432 }
00433
00434
return newlist;
00435 }
00436
00437 KFileMetaInfoGroup KFileMetaInfo::group(
const QString& key)
const
00438
{
00439
QMapIterator<QString,KFileMetaInfoGroup> it = d->groups.find( key );
00440
if ( it != d->groups.end() )
00441
return it.data();
00442
else
00443
return KFileMetaInfoGroup();
00444 }
00445
00446 bool KFileMetaInfo::addGroup(
const QString& name )
00447 {
00448 assert(
isValid());
00449
if ( d->mimeTypeInfo->supportedGroups().contains(name) &&
00450 ! d->groups.contains(name) )
00451 {
00452
KFileMetaInfoGroup group( name, d->mimeTypeInfo );
00453
00454
00455
const KFileMimeTypeInfo::GroupInfo* ginfo = d->mimeTypeInfo->groupInfo(name);
00456 Q_ASSERT(ginfo);
00457
if (!ginfo)
return false;
00458
00459
QStringList keys = ginfo->
supportedKeys();
00460
for (QStringList::Iterator it = keys.begin(); it != keys.end(); ++it)
00461 {
00462
const KFileMimeTypeInfo::ItemInfo* iteminfo = ginfo->
itemInfo(*it);
00463 Q_ASSERT(ginfo);
00464
if (!iteminfo)
return false;
00465
00466
if ( !(iteminfo->
attributes() & KFileMimeTypeInfo::Addable) &&
00467 (iteminfo->
attributes() & KFileMimeTypeInfo::Modifiable))
00468 {
00469
00470 group.
appendItem(iteminfo->
key(),
QVariant());
00471 }
00472
00473 }
00474
00475 d->groups.insert(name, group);
00476 group.
setAdded();
00477
return true;
00478 }
00479
00480
return false;
00481 }
00482
00483 bool KFileMetaInfo::removeGroup(
const QString& name )
00484 {
00485
QMapIterator<QString, KFileMetaInfoGroup> it = d->groups.find(name);
00486
if ( (it==d->groups.end()) ||
00487 !((*it).attributes() & KFileMimeTypeInfo::Removable))
00488
return false;
00489
00490 d->groups.remove(it);
00491 d->removedGroups.append(name);
00492
return true;
00493 }
00494
00495 QStringList KFileMetaInfo::removedGroups()
00496 {
00497
return d->removedGroups;
00498 }
00499
00500 const KFileMetaInfo& KFileMetaInfo::operator= (
const KFileMetaInfo& info )
00501 {
00502
if (d != info.
d)
00503 {
00504 deref();
00505
00506 d = info.
d;
00507
00508 ref();
00509 }
00510
return *
this;
00511 }
00512
00513 bool KFileMetaInfo::isValid()
const
00514
{
00515
00516
return d != Data::null;
00517 }
00518
00519 bool KFileMetaInfo::isEmpty()
const
00520
{
00521
for (
QMapIterator<QString, KFileMetaInfoGroup> it = d->groups.begin();
00522 it!=d->groups.end(); ++it)
00523
if (!(*it).isEmpty())
00524
return false;
00525
return true;
00526 }
00527
00528 bool KFileMetaInfo::applyChanges()
00529 {
00530
bool doit =
false;
00531
00532
00533
00534
00535
QMapConstIterator<QString, KFileMetaInfoGroup> it;
00536
for (it = d->groups.begin(); it!=d->groups.end() && !doit; ++it)
00537 {
00538
if ( (*it).isModified() )
00539 doit =
true;
00540
00541
else
00542 {
00543
QStringList keys = it.data().keys();
00544
for (QStringList::Iterator it2 = keys.begin(); it2!=keys.end(); ++it2)
00545 {
00546
if ( (*it)[*it2].isModified() )
00547 {
00548 doit =
true;
00549
break;
00550 }
00551 }
00552 }
00553 }
00554
00555
if (!doit)
00556 {
00557
kdDebug(7033) <<
"Don't need to write, nothing changed\n";
00558
return true;
00559 }
00560
00561
KFilePlugin* p =
plugin();
00562
if (!p)
return false;
00563
00564
00565
00566
return p->
writeInfo(*
this);
00567 }
00568
00569 KFilePlugin *
const KFileMetaInfo::plugin()
const
00570
{
00571 assert(
isValid());
00572 KFileMetaInfoProvider* prov = KFileMetaInfoProvider::self();
00573
return prov->plugin( d->mimeTypeInfo->mimeType(), d->url.protocol() );
00574 }
00575
00576 QString KFileMetaInfo::mimeType()
const
00577
{
00578 assert(
isValid());
00579
return d->mimeTypeInfo->mimeType();
00580 }
00581
00582 bool KFileMetaInfo::contains(
const QString& key)
const
00583
{
00584
QStringList glist =
groups();
00585
for (QStringList::Iterator it = glist.begin(); it != glist.end(); ++it)
00586 {
00587
KFileMetaInfoGroup g = d->groups[*it];
00588
if (g.
contains(key))
return true;
00589 }
00590
return false;
00591 }
00592
00593 bool KFileMetaInfo::containsGroup(
const QString& key)
const
00594
{
00595
return groups().contains(key);
00596 }
00597
00598 KFileMetaInfoItem KFileMetaInfo::item(
const QString& key)
const
00599
{
00600
QStringList groups =
preferredGroups();
00601
for (QStringList::Iterator it = groups.begin(); it != groups.end(); ++it)
00602 {
00603
KFileMetaInfoItem i = d->groups[*it][key];
00604
if (i.
isValid())
return i;
00605 }
00606
return KFileMetaInfoItem();
00607 }
00608
00609 KFileMetaInfoItem KFileMetaInfo::item(
const KFileMetaInfoItem::Hint hint)
const
00610
{
00611
QStringList groups =
preferredGroups();
00612 QStringList::ConstIterator it;
00613
for (it = groups.begin(); it != groups.end(); ++it)
00614 {
00615
KFileMetaInfoItem i = d->groups[*it].item(hint);
00616
if (i.
isValid())
return i;
00617 }
00618
return KFileMetaInfoItem();
00619 }
00620
00621 KFileMetaInfoItem KFileMetaInfo::saveItem(
const QString& key,
00622
const QString& preferredGroup,
00623
bool createGroup )
00624 {
00625 assert(
isValid());
00626
00627
if ( !preferredGroup.isEmpty() ) {
00628
QMapIterator<QString,KFileMetaInfoGroup> it =
00629 d->groups.find( preferredGroup );
00630
00631
00632
if ( it == d->groups.end() && createGroup ) {
00633
const KFileMimeTypeInfo::GroupInfo *groupInfo =
00634 d->mimeTypeInfo->groupInfo( preferredGroup );
00635
if ( groupInfo && groupInfo->
supportedKeys().contains( key ) ) {
00636
if (
addGroup( preferredGroup ) )
00637 it = d->groups.find( preferredGroup );
00638 }
00639 }
00640
00641
if ( it != d->groups.end() ) {
00642
KFileMetaInfoItem item = it.data().addItem( key );
00643
if ( item.
isValid() )
00644
return item;
00645 }
00646 }
00647
00648
QStringList groups =
preferredGroups();
00649
00650
KFileMetaInfoItem item;
00651
00652 QStringList::ConstIterator groupIt = groups.begin();
00653
for ( ; groupIt != groups.end(); ++groupIt )
00654 {
00655
QMapIterator<QString,KFileMetaInfoGroup> it = d->groups.find( *groupIt );
00656
if ( it != d->groups.end() )
00657 {
00658
KFileMetaInfoGroup group = it.data();
00659 item = findEditableItem( group, key );
00660
if ( item.
isValid() )
00661
return item;
00662 }
00663
else
00664 {
00665
const KFileMimeTypeInfo::GroupInfo *groupInfo =
00666 d->mimeTypeInfo->groupInfo( *groupIt );
00667
if ( groupInfo && groupInfo->
supportedKeys().contains( key ) )
00668 {
00669
if (
addGroup( *groupIt ) )
00670 {
00671
KFileMetaInfoGroup group = d->groups[*groupIt];
00672
KFileMetaInfoItem item = group.
addItem( key );
00673
if ( item.
isValid() )
00674
return item;
00675
00676
00677 }
00678 }
00679 }
00680 }
00681
00682
00683
00684
return item;
00685 }
00686
00687
KFileMetaInfoItem KFileMetaInfo::findEditableItem(
KFileMetaInfoGroup& group,
00688
const QString& key )
00689 {
00690 assert(
isValid());
00691
KFileMetaInfoItem item = group.
addItem( key );
00692
if ( item.
isValid() && item.
isEditable() )
00693
return item;
00694
00695
if ( (d->mimeTypeInfo->groupInfo( group.
name() )->attributes() & KFileMimeTypeInfo::Addable) )
00696
return item;
00697
00698
return KFileMetaInfoItem();
00699 }
00700
00701
KFileMetaInfoGroup KFileMetaInfo::appendGroup(
const QString& name)
00702 {
00703 assert(
isValid());
00704
if ( d->mimeTypeInfo->supportedGroups().contains(name) &&
00705 ! d->groups.contains(name) )
00706 {
00707
KFileMetaInfoGroup group( name, d->mimeTypeInfo );
00708 d->groups.insert(name, group);
00709
return group;
00710 }
00711
00712
else {
00713
kdWarning(7033) <<
"Someone's trying to add a KFileMetaInfoGroup which is not supported or already existing: " <<
name <<
endl;
00714
return KFileMetaInfoGroup();
00715 }
00716 }
00717
00718 QString KFileMetaInfo::path()
const
00719
{
00720
return d->url.isLocalFile() ? d->url.path() : QString::null;
00721 }
00722
00723 KURL KFileMetaInfo::url()
const
00724
{
00725
return d->url;
00726 }
00727
00728
void KFileMetaInfo::ref()
00729 {
00730
if (d != Data::null) d->ref();
00731
00732 }
00733
00734
void KFileMetaInfo::deref()
00735 {
00736
00737
00738
00739
if ((d != Data::null) && d->deref())
00740 {
00741
00742
delete d;
00743 d = 0;
00744 }
00745
00746 }
00747
00748
00749 KFileMetaInfo::Data* KFileMetaInfo::Data::null = 0L;
00750
static KStaticDeleter<KFileMetaInfo::Data> sd_KFileMetaInfoData;
00751
00752 KFileMetaInfo::Data* KFileMetaInfo::Data::makeNull()
00753 {
00754
if (!null)
00755
00756
00757
00758 null = sd_KFileMetaInfoData.setObject(
new KFileMetaInfo::Data(
KURL(), 0) );
00759
return null;
00760 }
00761
00764
00765 KFilePlugin::KFilePlugin(
QObject *parent,
const char *name,
00766
const QStringList& )
00767 :
QObject( parent, name )
00768 {
00769
00770 }
00771
00772 KFilePlugin::~KFilePlugin()
00773 {
00774
00775 }
00776
00777 KFileMimeTypeInfo *
KFilePlugin::addMimeTypeInfo(
const QString& mimeType )
00778 {
00779
return KFileMetaInfoProvider::self()->addMimeTypeInfo( mimeType );
00780 }
00781
00782
void KFilePlugin::virtual_hook(
int,
void* )
00783 { }
00784
00785
00786
KFileMimeTypeInfo::GroupInfo* KFilePlugin::addGroupInfo(
KFileMimeTypeInfo* info,
00787
const QString& key,
const QString& translatedKey)
const
00788
{
00789
return info->
addGroupInfo(key, translatedKey);
00790 }
00791
00792
void KFilePlugin::setAttributes(
KFileMimeTypeInfo::GroupInfo* gi, uint attr)
const
00793
{
00794 gi->
m_attr = attr;
00795 }
00796
00797
void KFilePlugin::addVariableInfo(
KFileMimeTypeInfo::GroupInfo* gi,
00798 QVariant::Type type, uint attr)
const
00799
{
00800 gi->
addVariableInfo(type, attr);
00801 }
00802
00803
KFileMimeTypeInfo::ItemInfo* KFilePlugin::addItemInfo(
KFileMimeTypeInfo::GroupInfo* gi,
00804
const QString& key,
00805
const QString& translatedKey,
00806 QVariant::Type type)
00807 {
00808
return gi->
addItemInfo(key, translatedKey, type);
00809 }
00810
00811
void KFilePlugin::setAttributes(
KFileMimeTypeInfo::ItemInfo* item, uint attr)
00812 {
00813 item->
m_attr = attr;
00814 }
00815
00816
void KFilePlugin::setHint(
KFileMimeTypeInfo::ItemInfo* item, uint hint)
00817 {
00818 item->
m_hint = hint;
00819 }
00820
00821
void KFilePlugin::setUnit(
KFileMimeTypeInfo::ItemInfo* item, uint unit)
00822 {
00823 item->
m_unit = unit;
00824
00825
switch (unit)
00826 {
00827
case KFileMimeTypeInfo::Seconds:
00828 item->
m_suffix = i18n(
"s");
break;
00829
00830
case KFileMimeTypeInfo::MilliSeconds:
00831 item->
m_suffix = i18n(
"ms");
break;
00832
00833
case KFileMimeTypeInfo::BitsPerSecond:
00834 item->
m_suffix = i18n(
"bps");
break;
00835
00836
case KFileMimeTypeInfo::Pixels:
00837 item->
m_suffix = i18n(
"pixels");
break;
00838
00839
case KFileMimeTypeInfo::Inches:
00840 item->
m_suffix = i18n(
"in");
break;
00841
00842
case KFileMimeTypeInfo::Centimeters:
00843 item->
m_suffix = i18n(
"cm");
break;
00844
00845
case KFileMimeTypeInfo::Bytes:
00846 item->
m_suffix = i18n(
"B");
break;
00847
00848
case KFileMimeTypeInfo::KiloBytes:
00849 item->
m_suffix = i18n(
"KB");
break;
00850
00851
case KFileMimeTypeInfo::FramesPerSecond:
00852 item->
m_suffix = i18n(
"fps");
break;
00853
00854
case KFileMimeTypeInfo::DotsPerInch:
00855 item->
m_suffix = i18n(
"dpi");
break;
00856
00857
case KFileMimeTypeInfo::BitsPerPixel:
00858 item->
m_suffix = i18n(
"bpp");
break;
00859
00860
case KFileMimeTypeInfo::Hertz:
00861 item->
m_suffix = i18n(
"Hz");
break;
00862
00863
case KFileMimeTypeInfo::Millimeters:
00864 item->
m_suffix = i18n(
"mm");
00865 }
00866 }
00867
00868
void KFilePlugin::setPrefix(
KFileMimeTypeInfo::ItemInfo* item,
const QString& prefix)
00869 {
00870 item->
m_prefix = prefix;
00871 }
00872
00873
void KFilePlugin::setSuffix(
KFileMimeTypeInfo::ItemInfo* item,
const QString& suffix)
00874 {
00875 item->
m_suffix = suffix;
00876 }
00877
00878
KFileMetaInfoGroup KFilePlugin::appendGroup(
KFileMetaInfo& info,
const QString& key)
00879 {
00880
return info.
appendGroup(key);
00881 }
00882
00883
void KFilePlugin::appendItem(
KFileMetaInfoGroup& group,
const QString& key,
QVariant value)
00884 {
00885 group.
appendItem(key, value);
00886 }
00887
00890
00891
00892 KFileMetaInfoProvider * KFileMetaInfoProvider::s_self;
00893
static KStaticDeleter<KFileMetaInfoProvider> sd;
00894
00895 KFileMetaInfoProvider * KFileMetaInfoProvider::self()
00896 {
00897
if ( !s_self )
00898 s_self = sd.setObject( s_self,
new KFileMetaInfoProvider() );
00899
00900
return s_self;
00901 }
00902
00903 KFileMetaInfoProvider::KFileMetaInfoProvider()
00904 {
00905 m_plugins.setAutoDelete(
true );
00906 }
00907
00908 KFileMetaInfoProvider::~KFileMetaInfoProvider()
00909 {
00910 m_plugins.clear();
00911 sd.setObject( 0 );
00912 }
00913
00914
KFilePlugin* KFileMetaInfoProvider::loadPlugin(
const QString& mimeType,
const QString& protocol )
00915 {
00916
00917
00918
00919
QString queryMimeType, query;
00920
if ( !mimeType.isEmpty() ) {
00921 query =
"(not exist [X-KDE-Protocol])";
00922 queryMimeType = mimeType;
00923 }
else {
00924 query = QString::fromLatin1(
"[X-KDE-Protocol] == '%1'" ).arg(protocol);
00925
00926 queryMimeType =
"KFilePlugin";
00927
00928 }
00929
const KTrader::OfferList offers = KTrader::self()->query( queryMimeType,
"KFilePlugin", query, QString::null );
00930
if ( offers.isEmpty() )
00931
return 0;
00932 KService::Ptr service = *(offers.begin());
00933 Q_ASSERT( service && service->isValid() );
00934
if ( !service || !service->isValid() )
00935
return 0;
00936
00937
KFilePlugin* plugin = KParts::ComponentFactory::createInstanceFromService<KFilePlugin>
00938 ( service,
this, mimeType.local8Bit() );
00939
if (!plugin)
00940
kdWarning(7033) <<
"error loading the plugin from " << service->desktopEntryPath() <<
endl;
00941
00942
return plugin;
00943 }
00944
00945
KFilePlugin* KFileMetaInfoProvider::loadAndRegisterPlugin(
const QString& mimeType,
const QString& protocol )
00946 {
00947 Q_ASSERT( m_pendingMimetypeInfos.isEmpty() );
00948 m_pendingMimetypeInfos.clear();
00949
00950
KFilePlugin* plugin = loadPlugin( mimeType, protocol );
00951
if ( !plugin ) {
00952
00953 m_plugins.insert( protocol.isEmpty() ? mimeType : protocol,
new CachedPluginInfo );
00954
return 0;
00955 }
00956
00957
if ( !protocol.isEmpty() ) {
00958
00959 Q_ASSERT( m_pendingMimetypeInfos.count() == 1 );
00960
KFileMimeTypeInfo* info = m_pendingMimetypeInfos[ protocol ];
00961 Q_ASSERT( info );
00962 m_plugins.insert( protocol,
new CachedPluginInfo( plugin, info,
true ) );
00963 }
else {
00964
00965
bool first =
true;
00966
QDictIterator<KFileMimeTypeInfo> it( m_pendingMimetypeInfos );
00967
for( ; it.current(); ++it ) {
00968
KFileMimeTypeInfo* info = it.current();
00969 m_plugins.insert( it.currentKey(),
new CachedPluginInfo( plugin, info, first ) );
00970 first =
false;
00971 }
00972
00973
if ( m_pendingMimetypeInfos.find( mimeType ) == 0 )
00974
kdWarning(7033) << plugin->className() <<
" was created for " << mimeType <<
" but doesn't call addMimeTypeInfo for it!" <<
endl;
00975 }
00976 m_pendingMimetypeInfos.clear();
00977
return plugin;
00978 }
00979
00980
KFilePlugin * KFileMetaInfoProvider::plugin(
const QString& mimeType)
00981 {
00982
return plugin( mimeType, QString::null );
00983 }
00984
00985
KFilePlugin * KFileMetaInfoProvider::plugin(
const QString& mimeType,
const QString& protocol)
00986 {
00987
00988
00989
if ( !protocol.isEmpty() ) {
00990 CachedPluginInfo *cache = m_plugins.find( protocol );
00991
if ( cache && cache->plugin ) {
00992
return cache->plugin;
00993 }
00994
if ( !cache ) {
00995
KFilePlugin* plugin = loadAndRegisterPlugin( QString::null, protocol );
00996
if ( plugin )
00997
return plugin;
00998 }
00999 }
01000
01001 CachedPluginInfo *cache = m_plugins.find( mimeType );
01002
if ( cache ) {
01003
return cache->plugin;
01004 }
01005
01006
KFilePlugin* plugin = loadAndRegisterPlugin( mimeType, QString::null );
01007
01008
#if 0
01009
kdDebug(7033) <<
"currently loaded plugins:\n";
01010
01011
QDictIterator<CachedPluginInfo> it( m_plugins );
01012
for( ; it.current(); ++it ) {
01013 CachedPluginInfo* cache = it.current();
01014
kdDebug(7033)
01015 << it.currentKey()
01016 <<
" : " << (cache->plugin ? cache->plugin->className() : "(no plugin)") <<
endl;
01017
01018 }
01019
#endif
01020
01021
return plugin;
01022 }
01023
01024
QStringList KFileMetaInfoProvider::preferredKeys(
const QString& mimeType )
const
01025
{
01026 KService::Ptr service =
01027
KServiceTypeProfile::preferredService( mimeType,
"KFilePlugin");
01028
01029
if ( !service || !service->isValid() )
01030 {
01031
01032
return QStringList();
01033 }
01034
return service->property(
"PreferredItems").toStringList();
01035 }
01036
01037
QStringList KFileMetaInfoProvider::preferredGroups(
const QString& mimeType )
const
01038
{
01039 KService::Ptr service =
01040
KServiceTypeProfile::preferredService( mimeType,
"KFilePlugin");
01041
01042
if ( !service || !service->isValid() )
01043 {
01044
01045
return QStringList();
01046 }
01047
return service->property(
"PreferredGroups").toStringList();
01048 }
01049
01050
const KFileMimeTypeInfo * KFileMetaInfoProvider::mimeTypeInfo(
const QString& mimeType )
01051 {
01052
return mimeTypeInfo( mimeType, QString::null );
01053 }
01054
01055
const KFileMimeTypeInfo * KFileMetaInfoProvider::mimeTypeInfo(
const QString& mimeType,
const QString& protocol )
01056 {
01057
01058
if ( !protocol.isEmpty() ) {
01059 CachedPluginInfo *cache = m_plugins.find( protocol );
01060
if ( cache && cache->mimeTypeInfo ) {
01061
return cache->mimeTypeInfo;
01062 }
01063
01064
if ( !cache ) {
01065 loadAndRegisterPlugin( QString::null, protocol );
01066 cache = m_plugins.find( protocol );
01067
if ( cache && cache->mimeTypeInfo ) {
01068
return cache->mimeTypeInfo;
01069 }
01070 }
01071 }
01072
01073 CachedPluginInfo *cache = m_plugins.find( mimeType );
01074
if ( cache ) {
01075
return cache->mimeTypeInfo;
01076 }
01077
01078 loadAndRegisterPlugin( mimeType, QString::null );
01079 cache = m_plugins.find( mimeType );
01080
if ( cache ) {
01081
return cache->mimeTypeInfo;
01082 }
01083
return 0;
01084 }
01085
01086
KFileMimeTypeInfo * KFileMetaInfoProvider::addMimeTypeInfo(
01087
const QString& mimeType )
01088 {
01089
01090
KFileMimeTypeInfo *info = m_pendingMimetypeInfos.find( mimeType );
01091 Q_ASSERT( !info );
01092
if ( !info )
01093 {
01094 info =
new KFileMimeTypeInfo( mimeType );
01095 m_pendingMimetypeInfos.insert( mimeType, info );
01096 }
01097
01098 info->
m_preferredKeys = preferredKeys( mimeType );
01099 info->
m_preferredGroups = preferredGroups( mimeType );
01100
01101
return info;
01102 }
01103
01104
QStringList KFileMetaInfoProvider::supportedMimeTypes()
const
01105
{
01106
QStringList allMimeTypes;
01107
QString kfilePlugin =
"KFilePlugin";
01108
01109
KTrader::OfferList offers = KTrader::self()->query(
"KFilePlugin" );
01110
KTrader::OfferListIterator it = offers.begin();
01111
for ( ; it != offers.end(); ++it )
01112 {
01113
const QStringList mimeTypes = (*it)->serviceTypes();
01114 QStringList::ConstIterator it2 = mimeTypes.begin();
01115
for ( ; it2 != mimeTypes.end(); ++it2 )
01116
if ( allMimeTypes.find( *it2 ) == allMimeTypes.end() &&
01117 *it2 != kfilePlugin )
01118 allMimeTypes.append( *it2 );
01119 }
01120
01121
return allMimeTypes;
01122 }
01123
01128
01129
01130
01131
class KFileMetaInfoGroup::Data :
public QShared
01132 {
01133
public:
01134 Data(
const QString& _name)
01135 : QShared(),
01136
name(_name),
01137 mimeTypeInfo(0L),
01138 dirty( false ),
01139 added( false )
01140 {}
01141
01142
01143 Data() : mimeTypeInfo(0L) {}
01144 ~Data() {
01145
if (
this == null )
01146
delete mimeTypeInfo;
01147 };
01148
01149
QString name;
01150
QMap<QString, KFileMetaInfoItem> items;
01151
const KFileMimeTypeInfo* mimeTypeInfo;
01152
QStringList removedItems;
01153
bool dirty :1;
01154
bool added :1;
01155
01156
static Data* null;
01157
static Data* makeNull();
01158
01159 };
01160
01161
KFileMetaInfoGroup::KFileMetaInfoGroup(
const QString& name,
01162
const KFileMimeTypeInfo* info )
01163 : d(new Data(
name ) )
01164 {
01165 d->mimeTypeInfo = info;
01166 }
01167
01168 KFileMetaInfoGroup::KFileMetaInfoGroup(
const KFileMetaInfoGroup& original )
01169 {
01170
01171 d = Data::makeNull();
01172 *
this = original;
01173 }
01174
01175 KFileMetaInfoGroup::KFileMetaInfoGroup()
01176 {
01177 d = Data::makeNull();
01178 }
01179
01180 KFileMetaInfoGroup::~KFileMetaInfoGroup()
01181 {
01182 deref();
01183 }
01184
01185 const KFileMetaInfoGroup& KFileMetaInfoGroup::operator= (
const KFileMetaInfoGroup& info )
01186 {
01187
if (d != info.
d)
01188 {
01189 deref();
01190
01191 d = info.
d;
01192
01193 ref();
01194 }
01195
return *
this;
01196 }
01197
01198 bool KFileMetaInfoGroup::isValid()
const
01199
{
01200
01201
return d != Data::null;
01202 }
01203
01204 bool KFileMetaInfoGroup::isEmpty()
const
01205
{
01206
return d->items.isEmpty();
01207 }
01208
01209 QStringList KFileMetaInfoGroup::preferredKeys()
const
01210
{
01211 assert(
isValid());
01212
QStringList list =
keys();
01213
QStringList newlist;
01214
QStringList preferredKeys = d->mimeTypeInfo->preferredKeys();
01215 QStringList::Iterator pref;
01216 QStringList::Iterator begin = preferredKeys.begin();
01217 QStringList::Iterator end = preferredKeys.end();
01218
01219
01220
for ( pref = begin; pref!=end; pref++ )
01221 {
01222 QStringList::Iterator
item = list.find(*pref);
01223
if ( item != list.end() )
01224 {
01225 newlist.append( *item );
01226 list.remove(item);
01227 }
01228 }
01229
01230
01231
01232 newlist += list;
01233
01234
return newlist;
01235 }
01236
01237 QStringList KFileMetaInfoGroup::keys()
const
01238
{
01239
if (d == Data::makeNull())
01240
kdWarning(7033) <<
"attempt to get the keys of "
01241
"an invalid metainfo group";
01242
01243
QStringList list;
01244
01245
01246
QMapConstIterator<QString, KFileMetaInfoItem> it;
01247
for (it = d->items.begin(); it!=d->items.end(); ++it)
01248 {
01249 list.append(it.data().key());
01250
01251 }
01252
return list;
01253 }
01254
01255 QString KFileMetaInfoGroup::translatedName()
const
01256
{
01257 assert(
isValid());
01258
return d->mimeTypeInfo->groupInfo(d->name)->translatedName();
01259 }
01260
01261 QStringList KFileMetaInfoGroup::supportedKeys()
const
01262
{
01263 assert(
isValid());
01264
return d->mimeTypeInfo->groupInfo(d->name)->supportedKeys();
01265 }
01266
01267 bool KFileMetaInfoGroup::supportsVariableKeys()
const
01268
{
01269 assert(
isValid());
01270
return d->mimeTypeInfo->groupInfo(d->name)->supportsVariableKeys();
01271 }
01272
01273 bool KFileMetaInfoGroup::contains(
const QString& key )
const
01274
{
01275
return d->items.contains(key);
01276 }
01277
01278 KFileMetaInfoItem KFileMetaInfoGroup::item(
const QString& key)
const
01279
{
01280
QMapIterator<QString,KFileMetaInfoItem> it = d->items.find( key );
01281
if ( it != d->items.end() )
01282
return it.data();
01283
01284
return KFileMetaInfoItem();
01285 }
01286
01287 KFileMetaInfoItem KFileMetaInfoGroup::item(uint hint)
const
01288
{
01289
QMapIterator<QString, KFileMetaInfoItem> it;
01290
01291
for (it = d->items.begin(); it!=d->items.end(); ++it)
01292
if (it.data().hint() == hint)
01293
return it.data();
01294
01295
return KFileMetaInfoItem();
01296 }
01297
01298 QString KFileMetaInfoGroup::name()
const
01299
{
01300
return d->name;
01301 }
01302
01303 uint
KFileMetaInfoGroup::attributes()
const
01304
{
01305 assert(
isValid());
01306
return d->mimeTypeInfo->groupInfo(d->name)->attributes();
01307 }
01308
01309
void KFileMetaInfoGroup::setAdded()
01310 {
01311 d->added =
true;
01312 }
01313
01314 bool KFileMetaInfoGroup::isModified()
const
01315
{
01316
return d->dirty;
01317 }
01318
01319
void KFileMetaInfoGroup::ref()
01320 {
01321
if (d != Data::null) d->ref();
01322
01323 }
01324
01325
void KFileMetaInfoGroup::deref()
01326 {
01327
01328
01329
01330
if ((d != Data::null) && d->deref())
01331 {
01332
01333
01334
delete d;
01335 d = 0;
01336 }
01337
01338 }
01339
01340 KFileMetaInfoItem KFileMetaInfoGroup::addItem(
const QString& key )
01341 {
01342 assert(
isValid());
01343
QMapIterator<QString,KFileMetaInfoItem> it = d->items.find( key );
01344
if ( it != d->items.end() )
01345
return it.data();
01346
01347
const KFileMimeTypeInfo::GroupInfo* ginfo = d->mimeTypeInfo->groupInfo(d->name);
01348
01349
if ( !ginfo ) {
01350 Q_ASSERT( ginfo );
01351
return KFileMetaInfoItem();
01352 }
01353
01354
const KFileMimeTypeInfo::ItemInfo* info = ginfo->
itemInfo(key);
01355
01356
if ( !info ) {
01357 Q_ASSERT( info );
01358
return KFileMetaInfoItem();
01359 }
01360
01361
KFileMetaInfoItem item;
01362
01363
if (info->
isVariableItem())
01364 item =
KFileMetaInfoItem(ginfo->
variableItemInfo(), key,
QVariant());
01365
else
01366 item = KFileMetaInfoItem(info, key, QVariant());
01367
01368 d->items.insert(key, item);
01369 item.
setAdded();
01370 d->dirty =
true;
01371
return item;
01372 }
01373
01374 bool KFileMetaInfoGroup::removeItem(
const QString& key )
01375 {
01376
if (!
isValid())
01377 {
01378
kdDebug(7033) <<
"trying to remove an item from an invalid group\n";
01379
return false;
01380 }
01381
01382
QMapIterator<QString, KFileMetaInfoItem> it = d->items.find(key);
01383
if ( it==d->items.end() )
01384 {
01385
kdDebug(7033) <<
"trying to remove the non existant item " << key <<
"\n";
01386
return false;
01387 }
01388
01389
if (!((*it).attributes() & KFileMimeTypeInfo::Removable))
01390 {
01391
kdDebug(7033) <<
"trying to remove a non removable item\n";
01392
return false;
01393 }
01394
01395 (*it).setRemoved();
01396 d->items.remove(it);
01397 d->removedItems.append(key);
01398 d->dirty =
true;
01399
return true;
01400 }
01401
01402 QStringList KFileMetaInfoGroup::removedItems()
01403 {
01404
return d->removedItems;
01405 }
01406
01407
KFileMetaInfoItem KFileMetaInfoGroup::appendItem(
const QString& key,
01408
const QVariant& value)
01409 {
01410
01411 assert(
isValid());
01412
const KFileMimeTypeInfo::GroupInfo* ginfo = d->mimeTypeInfo->groupInfo(d->name);
01413
if ( !ginfo ) {
01414
kdWarning() <<
"Trying to append a Metadata item for a non-existant group:" << d->name <<
endl;
01415
return KFileMetaInfoItem();
01416 }
01417
const KFileMimeTypeInfo::ItemInfo* info = ginfo->
itemInfo(key);
01418
if ( !info ) {
01419
kdWarning() <<
"Trying to append a Metadata item for an unknown key (no ItemInfo): " <<
key <<
endl;
01420
return KFileMetaInfoItem();
01421 }
01422
01423
KFileMetaInfoItem item;
01424
01425
if (info->
key().isNull())
01426 item =
KFileMetaInfoItem(ginfo->
variableItemInfo(),
key, value);
01427
else
01428 item = KFileMetaInfoItem(info, key, value);
01429
01430
kdDebug(7033) <<
"KFileMetaInfogroup inserting a " <<
key <<
endl;
01431
01432 d->items.insert(key, item);
01433
return item;
01434 }
01435
01436 KFileMetaInfoGroup::Data* KFileMetaInfoGroup::Data::null = 0L;
01437
static KStaticDeleter<KFileMetaInfoGroup::Data> sd_KFileMetaInfoGroupData;
01438
01439 KFileMetaInfoGroup::Data* KFileMetaInfoGroup::Data::makeNull()
01440 {
01441
if (!null)
01442 {
01443
01444
01445
01446 null =
new Data(QString::null);
01447 null->mimeTypeInfo =
new KFileMimeTypeInfo();
01448 sd_KFileMetaInfoGroupData.setObject( null );
01449 }
01450
return null;
01451 }
01452
01453
01456
01457 KFileMimeTypeInfo::KFileMimeTypeInfo(
const QString& mimeType )
01458 : m_mimeType( mimeType )
01459 {
01460 m_groups.setAutoDelete(
true );
01461 }
01462
01463 KFileMimeTypeInfo::~KFileMimeTypeInfo()
01464 {
01465 }
01466
01467 const KFileMimeTypeInfo::GroupInfo *
KFileMimeTypeInfo::groupInfo(
const QString& group )
const
01468
{
01469
return m_groups.find( group );
01470 }
01471
01472
KFileMimeTypeInfo::GroupInfo * KFileMimeTypeInfo::addGroupInfo(
01473
const QString& name,
const QString& translatedName )
01474 {
01475 GroupInfo* group =
new GroupInfo( name, translatedName );
01476 m_groups.insert(name, group);
01477
return group;
01478 }
01479
01480 QStringList KFileMimeTypeInfo::supportedGroups()
const
01481
{
01482
QStringList list;
01483
QDictIterator<GroupInfo> it( m_groups );
01484
for ( ; it.current(); ++it )
01485 list.append( it.current()->name() );
01486
01487
return list;
01488 }
01489
01490 QStringList KFileMimeTypeInfo::translatedGroups()
const
01491
{
01492
QStringList list;
01493
QDictIterator<GroupInfo> it( m_groups );
01494
for ( ; it.current(); ++it )
01495 list.append( it.current()->translatedName() );
01496
01497
return list;
01498 }
01499
01500 QStringList KFileMimeTypeInfo::supportedKeys()
const
01501
{
01502
01503
01504
QStringList keys;
01505 QStringList::ConstIterator lit;
01506
QDictIterator<GroupInfo> it( m_groups );
01507
for ( ; it.current(); ++it ) {
01508
QStringList list = it.current()->supportedKeys();
01509
for ( lit = list.begin(); lit != list.end(); ++lit ) {
01510
if ( keys.find( *lit ) == keys.end() )
01511 keys.append( *lit );
01512 }
01513 }
01514
01515
return keys;
01516 }
01517
01518 QValidator *
KFileMimeTypeInfo::createValidator(
const QString& group,
01519
const QString& key,
01520
QObject *parent,
01521
const char *name)
const
01522
{
01523
KFilePlugin* plugin = KFileMetaInfoProvider::self()->plugin(m_mimeType);
01524
if (plugin)
return plugin->
createValidator(
mimeType(), group, key,
01525 parent, name);
01526
return 0;
01527 }
01528
01529
01532
01533 KFileMimeTypeInfo::GroupInfo::GroupInfo(
const QString& name,
01534
const QString& translatedName )
01535 : m_name( name ),
01536 m_translatedName( translatedName ),
01537 m_attr( 0 ),
01538 m_variableItemInfo( 0 )
01539
01540 {
01541 m_itemDict.setAutoDelete(
true );
01542 }
01543
01544 const KFileMimeTypeInfo::ItemInfo *
KFileMimeTypeInfo::GroupInfo::itemInfo(
const QString& key )
const
01545
{
01546
ItemInfo* item = m_itemDict.find( key );
01547
01548
01549
01550
if (!item && m_variableItemInfo)
01551 {
01552
return m_variableItemInfo;
01553 }
01554
return item;
01555 }
01556
01557
KFileMimeTypeInfo::ItemInfo* KFileMimeTypeInfo::GroupInfo::addItemInfo(
01558
const QString& key,
const QString& translatedKey,
01559 QVariant::Type type)
01560 {
01561
01562
01563
ItemInfo* item =
new ItemInfo(key, translatedKey, type);
01564 m_supportedKeys.append(key);
01565 m_itemDict.insert(key, item);
01566
return item;
01567 }
01568
01569
01570
void KFileMimeTypeInfo::GroupInfo::addVariableInfo( QVariant::Type type,
01571 uint attr )
01572 {
01573
01574
delete m_variableItemInfo;
01575 m_variableItemInfo =
new ItemInfo(QString::null, QString::null, type);
01576 m_variableItemInfo->m_attr = attr;
01577 }
01578
01581
01582 QString KFileMimeTypeInfo::ItemInfo::string(
const QVariant& value,
bool mangle)
const
01583
{
01584
QString s;
01585
01586
switch (value.type())
01587 {
01588
case QVariant::Invalid :
01589
return "---";
01590
01591
case QVariant::Bool :
01592 s = value.toBool() ? i18n(
"Yes") : i18n(
"No");
01593
break;
01594
01595
case QVariant::Int :
01596
if (
unit() ==
KFileMimeTypeInfo::Seconds)
01597 {
01598
int seconds = value.toInt() % 60;
01599
int minutes = value.toInt() / 60 % 60;
01600
int hours = value.toInt() / 3600;
01601 s = hours ?
QString().sprintf(
"%d:%02d:%02d",hours, minutes, seconds)
01602 : QString().sprintf(
"%02d:%02d", minutes, seconds);
01603
return s;
01604 }
01605
else if (
unit() ==
KFileMimeTypeInfo::Bytes)
01606 {
01607
01608
return KIO::convertSize(value.toInt());
01609 }
01610
else if (
unit() ==
KFileMimeTypeInfo::KiloBytes)
01611 {
01612
01613
return KIO::convertSizeFromKB(value.toInt());
01614 }
01615
else
01616 s =
KGlobal::locale()->
formatNumber( value.toInt() , 0);
01617
break;
01618
01619
#if QT_VERSION >= 0x030200
01620
case QVariant::LongLong :
01621 s =
KGlobal::locale()->
formatNumber( value.toLongLong(), 0 );
01622
break;
01623
01624
case QVariant::ULongLong :
01625
if (
unit() ==
KFileMimeTypeInfo::Bytes )
01626
return KIO::convertSize( value.toULongLong() );
01627
else if (
unit() ==
KFileMimeTypeInfo::KiloBytes )
01628
return KIO::convertSizeFromKB( value.toULongLong() );
01629
else
01630 s =
KGlobal::locale()->
formatNumber( value.toULongLong(), 0 );
01631
break;
01632
#endif
01633
case QVariant::UInt :
01634 s =
KGlobal::locale()->
formatNumber( value.toUInt() , 0);
01635
break;
01636
01637
case QVariant::Double :
01638 s =
KGlobal::locale()->
formatNumber( value.toDouble(), 3);
01639
break;
01640
01641
case QVariant::Date :
01642 s =
KGlobal::locale()->
formatDate( value.toDate(),
true );
01643
break;
01644
01645
case QVariant::Time :
01646 s =
KGlobal::locale()->
formatTime( value.toTime(),
true );
01647
break;
01648
01649
case QVariant::DateTime :
01650 s =
KGlobal::locale()->
formatDateTime( value.toDateTime(),
01651
true,
true );
01652
break;
01653
01654
case QVariant::Size :
01655 s =
QString(
"%1 x %2").arg(value.toSize().width())
01656 .arg(value.toSize().height());
01657
break;
01658
01659
case QVariant::Point :
01660 s = QString(
"%1/%2").arg(value.toSize().width())
01661 .arg(value.toSize().height());
01662
break;
01663
01664
default:
01665 s = value.toString();
01666 }
01667
01668
if (mangle && !s.isNull())
01669 {
01670 s.prepend(
prefix());
01671 s.append(
" " +
suffix());
01672 }
01673
return s;
01674 }
01675
01676
01679
01680
01681
01682
01683
01684
01685
01686
01687
01688 KIO_EXPORT
QDataStream& operator <<(
QDataStream& s,
const KFileMetaInfoItem& item )
01689 {
01690
01691 KFileMetaInfoItem::Data* d = item.
d;
01692
01693
01694
bool isValid = item.
isValid();
01695 s << isValid;
01696
01697
if (isValid)
01698 s << d->key
01699 << d->value
01700 << d->dirty
01701 << d->added
01702 << d->removed;
01703
01704
return s;
01705 }
01706
01707
01708 KIO_EXPORT
QDataStream& operator >>(
QDataStream& s,
KFileMetaInfoItem& item )
01709 {
01710
bool isValid;
01711 s >> isValid;
01712
01713
if (!isValid)
01714 {
01715 item =
KFileMetaInfoItem();
01716
return s;
01717 }
01718
01719
01720 item.
deref();
01721 item.
d =
new KFileMetaInfoItem::Data();
01722
01723
01724
bool dirty, added, removed;
01725 s >> item.
d->key
01726 >> item.
d->value
01727 >> dirty
01728 >> added
01729 >> removed;
01730 item.
d->dirty = dirty;
01731 item.
d->added = added;
01732 item.
d->removed = removed;
01733
01734
return s;
01735 }
01736
01737
01738
01739
01740
01741 KIO_EXPORT
QDataStream& operator <<(
QDataStream& s,
const KFileMetaInfoGroup& group )
01742 {
01743 KFileMetaInfoGroup::Data* d = group.
d;
01744
01745
01746
bool isValid = group.
isValid();
01747
01748 s << isValid;
01749
if (isValid)
01750 {
01751 s << d->name
01752 << d->items
01753 << d->mimeTypeInfo->mimeType();
01754 }
01755
return s;
01756 }
01757
01758 KIO_EXPORT
QDataStream& operator >>(
QDataStream& s,
KFileMetaInfoGroup& group )
01759 {
01760
QString mimeType;
01761
bool isValid;
01762 s >> isValid;
01763
01764
01765
if (!isValid)
01766 {
01767 group =
KFileMetaInfoGroup();
01768
return s;
01769 }
01770
01771
01772 group.
deref();
01773 group.
d =
new KFileMetaInfoGroup::Data();
01774
01775 s >> group.
d->name
01776 >> group.
d->items
01777 >> mimeType;
01778
01779 group.
d->mimeTypeInfo = KFileMetaInfoProvider::self()->mimeTypeInfo(mimeType);
01780
01781
01782
QMapIterator<QString, KFileMetaInfoItem> it = group.
d->items.begin();
01783
for ( ; it != group.
d->items.end(); ++it)
01784 {
01785 (*it).d->mimeTypeInfo = group.
d->mimeTypeInfo->groupInfo(group.
d->name)
01786 ->itemInfo((*it).key());
01787 }
01788
01789
return s;
01790 }
01791
01792
01793
01794
01795 KIO_EXPORT
QDataStream& operator <<(
QDataStream& s,
const KFileMetaInfo& info )
01796 {
01797 KFileMetaInfo::Data* d = info.
d;
01798
01799
01800
bool isValid = info.
isValid();
01801
01802 s << isValid;
01803
if (isValid)
01804 {
01805 s << d->url
01806 << d->what
01807 << d->groups
01808 << d->mimeTypeInfo->mimeType();
01809 }
01810
return s;
01811 }
01812
01813 KIO_EXPORT
QDataStream& operator >>(
QDataStream& s,
KFileMetaInfo& info )
01814 {
01815
QString mimeType;
01816
bool isValid;
01817 s >> isValid;
01818
01819
01820
if (!isValid)
01821 {
01822 info =
KFileMetaInfo();
01823
return s;
01824 }
01825
01826
01827 info.
deref();
01828 info.
d =
new KFileMetaInfo::Data();
01829
01830 s >> info.
d->url
01831 >> info.
d->what
01832 >> info.
d->groups
01833 >> mimeType;
01834 info.
d->mimeTypeInfo = KFileMetaInfoProvider::self()->mimeTypeInfo(mimeType);
01835
01836
return s;
01837 }
01838
01839
#include "kfilemetainfo.moc"