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