29 #include <kstaticdeleter.h> 30 #include <tdeparts/componentfactory.h> 31 #include <kuserprofile.h> 33 #include <kmimetype.h> 34 #include <kdatastream.h> 35 #include <tdelocale.h> 36 #include <tdeio/global.h> 38 #include "tdefilemetainfo.h" 41 class KFileMetaInfoItem::Data :
public TQShared
45 const TQVariant& _value )
56 Data() : mimeTypeInfo( 0L )
74 static Data* makeNull();
78 KFileMetaInfoItem::Data* KFileMetaInfoItem::Data::null = 0L;
79 static KStaticDeleter<KFileMetaInfoItem::Data> sd_KFileMetaInfoItemData;
81 KFileMetaInfoItem::Data* KFileMetaInfoItem::Data::makeNull()
90 null =
new Data(info, TQString::null, TQVariant());
91 sd_KFileMetaInfoItemData.setObject( null );
97 const TQString&
key,
const TQVariant&
value )
98 : d( new Data( mti, key, value ) )
105 d = Data::makeNull();
111 d = Data::makeNull();
114 KFileMetaInfoItem::~KFileMetaInfoItem()
137 if ( d == Data::null )
return false;
140 ! (value.canCast(d->mimeTypeInfo->type())))
142 kdDebug(7033) <<
"setting the value of " << key() <<
"failed\n";
148 if ( d->value == value )
155 d->value.cast(d->mimeTypeInfo->type());
173 if (d->mimeTypeInfo->key().isNull())
176 return i18n(d->key.utf8());
179 return d->mimeTypeInfo->translatedKey();
189 return d->mimeTypeInfo->string(d->value, mangle);
194 return d->mimeTypeInfo->type();
199 return d->mimeTypeInfo->unit();
209 return d->mimeTypeInfo->prefix();
214 return d->mimeTypeInfo->suffix();
219 return d->mimeTypeInfo->hint();
224 return d->mimeTypeInfo->attributes();
237 return d != Data::null;
240 void KFileMetaInfoItem::setAdded()
245 void KFileMetaInfoItem::setRemoved()
250 void KFileMetaInfoItem::ref()
252 if (d != Data::null) d->ref();
255 void KFileMetaInfoItem::deref()
260 if ((d != Data::null) && d->deref())
273 class KFileMetaInfo::Data :
public TQShared
276 Data(
const KURL& _url, uint _what)
288 TQMap<TQString, KFileMetaInfoGroup> groups;
290 TQStringList removedGroups;
293 static Data* makeNull();
303 init(u, mimeType, what);
309 init(url, mimeType, what);
312 void KFileMetaInfo::init(
const KURL&
url,
const TQString& mimeType,
315 d =
new Data( url, what );
318 if (mimeType.isEmpty())
328 d->mimeTypeInfo = KFileMetaInfoProvider::self()->mimeTypeInfo( mT, url.protocol() );
329 if ( d->mimeTypeInfo )
334 if ( p && !p->
readInfo( item, what) )
337 d = Data::makeNull();
344 d = Data::makeNull();
351 d = Data::makeNull();
357 d = Data::makeNull();
360 KFileMetaInfo::~KFileMetaInfo()
368 return d->mimeTypeInfo->supportedGroups();
374 return d->mimeTypeInfo->supportedKeys();
380 TQMapConstIterator<TQString, KFileMetaInfoGroup> it = d->groups.begin();
381 for ( ; it != d->groups.end(); ++it )
382 list += (*it).name();
390 TQStringList supported = supportedGroups();
391 TQStringList::ConstIterator it = supported.begin();
392 for ( ; it != supported.end(); ++it ) {
405 TQStringList list = groups();
406 TQStringList newlist;
407 TQStringList preferred = d->mimeTypeInfo->preferredGroups();
408 TQStringList::Iterator pref;
411 for ( pref = preferred.begin(); pref != preferred.end(); ++pref )
413 TQStringList::Iterator
group = list.find(*pref);
414 if ( group != list.end() )
416 newlist.append( *group );
430 TQStringList newlist;
432 TQStringList list = preferredGroups();
433 for (TQStringList::Iterator git = list.begin(); git != list.end(); ++git)
435 newlist += d->groups[*git].preferredKeys();
443 TQMapIterator<TQString,KFileMetaInfoGroup> it = d->groups.find( key );
444 if ( it != d->groups.end() )
453 if ( d->mimeTypeInfo->supportedGroups().contains(name) &&
454 ! d->groups.contains(name) )
461 if (!ginfo)
return false;
464 for (TQStringList::Iterator it = keys.begin(); it != keys.end(); ++it)
468 if (!iteminfo)
return false;
474 group.appendItem(iteminfo->
key(), TQVariant());
479 d->groups.insert(name, group);
489 TQMapIterator<TQString, KFileMetaInfoGroup> it = d->groups.find(name);
490 if ( (it==d->groups.end()) ||
494 d->groups.remove(it);
495 d->removedGroups.append(name);
501 return d->removedGroups;
520 return d != Data::null;
525 for (TQMapIterator<TQString, KFileMetaInfoGroup> it = d->groups.begin();
526 it!=d->groups.end(); ++it)
527 if (!(*it).isEmpty())
534 return applyChanges( path() );
544 TQMapConstIterator<TQString, KFileMetaInfoGroup> it;
545 for (it = d->groups.begin(); it!=d->groups.end() && !doit; ++it)
547 if ( (*it).isModified() )
552 TQStringList keys = it.data().keys();
553 for (TQStringList::Iterator it2 = keys.begin(); it2!=keys.end(); ++it2)
555 if ( (*it)[*it2].isModified() )
566 kdDebug(7033) <<
"Don't need to write, nothing changed\n";
571 if (!p)
return false;
575 KURL savedURL =
url();
577 d->url.setPath( path );
588 KFileMetaInfoProvider* prov = KFileMetaInfoProvider::self();
589 return prov->plugin( d->mimeTypeInfo->mimeType(), d->url.protocol() );
595 return d->mimeTypeInfo->mimeType();
600 TQStringList glist = groups();
601 for (TQStringList::Iterator it = glist.begin(); it != glist.end(); ++it)
611 return groups().contains(key);
616 TQStringList groups = preferredGroups();
617 for (TQStringList::Iterator it = groups.begin(); it != groups.end(); ++it)
627 TQStringList groups = preferredGroups();
628 TQStringList::ConstIterator it;
629 for (it = groups.begin(); it != groups.end(); ++it)
638 const TQString& preferredGroup,
643 if ( !preferredGroup.isEmpty() ) {
644 TQMapIterator<TQString,KFileMetaInfoGroup> it =
645 d->groups.find( preferredGroup );
648 if ( it == d->groups.end() && createGroup ) {
650 d->mimeTypeInfo->groupInfo( preferredGroup );
651 if ( groupInfo && groupInfo->
supportedKeys().contains( key ) ) {
652 if ( addGroup( preferredGroup ) )
653 it = d->groups.find( preferredGroup );
657 if ( it != d->groups.end() ) {
664 TQStringList groups = preferredGroups();
668 TQStringList::ConstIterator groupIt = groups.begin();
669 for ( ; groupIt != groups.end(); ++groupIt )
671 TQMapIterator<TQString,KFileMetaInfoGroup> it = d->groups.find( *groupIt );
672 if ( it != d->groups.end() )
675 item = findEditableItem( group, key );
682 d->mimeTypeInfo->groupInfo( *groupIt );
683 if ( groupInfo && groupInfo->
supportedKeys().contains( key ) )
685 if ( addGroup( *groupIt ) )
704 const TQString& key )
720 if ( d->mimeTypeInfo->supportedGroups().contains(name) &&
721 ! d->groups.contains(name) )
724 d->groups.insert(name, group);
729 kdWarning(7033) <<
"Someone's trying to add a KFileMetaInfoGroup which is not supported or already existing: " << name << endl;
736 return d->url.isLocalFile() ? d->url.path() : TQString::null;
744 void KFileMetaInfo::ref()
746 if (d != Data::null) d->ref();
750 void KFileMetaInfo::deref()
755 if ((d != Data::null) && d->deref())
765 KFileMetaInfo::Data* KFileMetaInfo::Data::null = 0L;
766 static KStaticDeleter<KFileMetaInfo::Data> sd_KFileMetaInfoData;
768 KFileMetaInfo::Data* KFileMetaInfo::Data::makeNull()
774 null = sd_KFileMetaInfoData.setObject(
new KFileMetaInfo::Data(KURL(), 0) );
782 const TQStringList& )
783 : TQObject( parent, name )
795 return KFileMetaInfoProvider::self()->addMimeTypeInfo( mimeType );
803 const TQString& key,
const TQString& translatedKey)
const 805 return info->addGroupInfo(key, translatedKey);
814 TQVariant::Type type, uint attr)
const 816 gi->addVariableInfo(type, attr);
821 const TQString& translatedKey,
822 TQVariant::Type type)
824 return gi->addItemInfo(key, translatedKey, type);
844 item->m_suffix = i18n(
"s");
break;
847 item->m_suffix = i18n(
"ms");
break;
850 item->m_suffix = i18n(
"bps");
break;
853 item->m_suffix = i18n(
"pixels");
break;
856 item->m_suffix = i18n(
"in");
break;
859 item->m_suffix = i18n(
"cm");
break;
862 item->m_suffix = i18n(
"B");
break;
865 item->m_suffix = i18n(
"KB");
break;
868 item->m_suffix = i18n(
"fps");
break;
871 item->m_suffix = i18n(
"dpi");
break;
874 item->m_suffix = i18n(
"bpp");
break;
877 item->m_suffix = i18n(
"Hz");
break;
880 item->m_suffix = i18n(
"mm");
886 item->m_prefix = prefix;
891 item->m_suffix = suffix;
896 return info.appendGroup(key);
901 group.appendItem(key, value);
908 KFileMetaInfoProvider * KFileMetaInfoProvider::s_self;
909 static KStaticDeleter<KFileMetaInfoProvider> sd;
911 KFileMetaInfoProvider * KFileMetaInfoProvider::self()
914 s_self = sd.setObject( s_self,
new KFileMetaInfoProvider() );
919 KFileMetaInfoProvider::KFileMetaInfoProvider()
921 m_plugins.setAutoDelete(
true );
924 KFileMetaInfoProvider::~KFileMetaInfoProvider()
930 KFilePlugin* KFileMetaInfoProvider::loadPlugin(
const TQString& mimeType,
const TQString& protocol )
935 TQString queryMimeType, query;
936 if ( !mimeType.isEmpty() ) {
937 query =
"(not exist [X-TDE-Protocol])";
938 queryMimeType = mimeType;
940 query = TQString::fromLatin1(
"[X-TDE-Protocol] == '%1'" ).arg(protocol);
942 queryMimeType =
"KFilePlugin";
946 if ( offers.isEmpty() )
948 KService::Ptr service = *(offers.begin());
949 Q_ASSERT( service && service->isValid() );
950 if ( !service || !service->isValid() )
953 KFilePlugin* plugin = KParts::ComponentFactory::createInstanceFromService<KFilePlugin>
954 ( service, TQT_TQOBJECT(
this), mimeType.local8Bit() );
956 kdWarning(7033) <<
"error loading the plugin from " << service->desktopEntryPath() << endl;
961 KFilePlugin* KFileMetaInfoProvider::loadAndRegisterPlugin(
const TQString& mimeType,
const TQString& protocol )
963 Q_ASSERT( m_pendingMimetypeInfos.isEmpty() );
964 m_pendingMimetypeInfos.clear();
966 KFilePlugin* plugin = loadPlugin( mimeType, protocol );
969 m_plugins.insert( protocol.isEmpty() ? mimeType : protocol,
new CachedPluginInfo );
973 if ( !protocol.isEmpty() ) {
975 Q_ASSERT( m_pendingMimetypeInfos.count() == 1 );
978 m_plugins.insert( protocol,
new CachedPluginInfo( plugin, info,
true ) );
982 TQDictIterator<KFileMimeTypeInfo> it( m_pendingMimetypeInfos );
983 for( ; it.current(); ++it ) {
985 m_plugins.insert( it.currentKey(),
new CachedPluginInfo( plugin, info, first ) );
989 if ( m_pendingMimetypeInfos.find( mimeType ) == 0 )
990 kdWarning(7033) << plugin->className() <<
" was created for " << mimeType <<
" but doesn't call addMimeTypeInfo for it!" << endl;
992 m_pendingMimetypeInfos.clear();
996 KFilePlugin * KFileMetaInfoProvider::plugin(
const TQString& mimeType)
998 return plugin( mimeType, TQString::null );
1001 KFilePlugin * KFileMetaInfoProvider::plugin(
const TQString& mimeType,
const TQString& protocol)
1005 if ( !protocol.isEmpty() ) {
1006 CachedPluginInfo *cache = m_plugins.find( protocol );
1007 if ( cache && cache->plugin ) {
1008 return cache->plugin;
1011 KFilePlugin* plugin = loadAndRegisterPlugin( TQString::null, protocol );
1017 CachedPluginInfo *cache = m_plugins.find( mimeType );
1019 return cache->plugin;
1022 KFilePlugin* plugin = loadAndRegisterPlugin( mimeType, TQString::null );
1025 kdDebug(7033) <<
"currently loaded plugins:\n";
1027 TQDictIterator<CachedPluginInfo> it( m_plugins );
1028 for( ; it.current(); ++it ) {
1029 CachedPluginInfo* cache = it.current();
1032 <<
" : " << (cache->plugin ? cache->plugin->className() :
"(no plugin)") << endl;
1040 TQStringList KFileMetaInfoProvider::preferredKeys(
const TQString& mimeType )
const 1042 KService::Ptr service =
1045 if ( !service || !service->isValid() )
1048 return TQStringList();
1050 return service->property(
"PreferredItems").toStringList();
1053 TQStringList KFileMetaInfoProvider::preferredGroups(
const TQString& mimeType )
const 1055 KService::Ptr service =
1058 if ( !service || !service->isValid() )
1061 return TQStringList();
1063 return service->property(
"PreferredGroups").toStringList();
1066 const KFileMimeTypeInfo * KFileMetaInfoProvider::mimeTypeInfo(
const TQString& mimeType )
1068 return mimeTypeInfo( mimeType, TQString::null );
1071 const KFileMimeTypeInfo * KFileMetaInfoProvider::mimeTypeInfo(
const TQString& mimeType,
const TQString& protocol )
1074 if ( !protocol.isEmpty() ) {
1075 CachedPluginInfo *cache = m_plugins.find( protocol );
1076 if ( cache && cache->mimeTypeInfo ) {
1077 return cache->mimeTypeInfo;
1081 loadAndRegisterPlugin( TQString::null, protocol );
1082 cache = m_plugins.find( protocol );
1083 if ( cache && cache->mimeTypeInfo ) {
1084 return cache->mimeTypeInfo;
1089 CachedPluginInfo *cache = m_plugins.find( mimeType );
1091 return cache->mimeTypeInfo;
1094 loadAndRegisterPlugin( mimeType, TQString::null );
1095 cache = m_plugins.find( mimeType );
1097 return cache->mimeTypeInfo;
1103 const TQString& mimeType )
1111 m_pendingMimetypeInfos.insert( mimeType, info );
1114 info->m_preferredKeys = preferredKeys( mimeType );
1115 info->m_preferredGroups = preferredGroups( mimeType );
1120 TQStringList KFileMetaInfoProvider::supportedMimeTypes()
const 1122 TQStringList allMimeTypes;
1123 TQString tdefilePlugin =
"KFilePlugin";
1126 TDETrader::OfferListIterator it = offers.begin();
1127 for ( ; it != offers.end(); ++it )
1129 const TQStringList mimeTypes = (*it)->serviceTypes();
1130 TQStringList::ConstIterator it2 = mimeTypes.begin();
1131 for ( ; it2 != mimeTypes.end(); ++it2 )
1132 if ( allMimeTypes.find( *it2 ) == allMimeTypes.end() &&
1133 *it2 != tdefilePlugin )
1134 allMimeTypes.append( *it2 );
1137 return allMimeTypes;
1147 class KFileMetaInfoGroup::Data :
public TQShared
1150 Data(
const TQString& _name)
1159 Data() : mimeTypeInfo(0L) {}
1162 delete mimeTypeInfo;
1166 TQMap<TQString, KFileMetaInfoItem> items;
1168 TQStringList removedItems;
1173 static Data* makeNull();
1179 : d(
new Data( name ) )
1181 d->mimeTypeInfo = info;
1187 d = Data::makeNull();
1193 d = Data::makeNull();
1196 KFileMetaInfoGroup::~KFileMetaInfoGroup()
1217 return d != Data::null;
1222 return d->items.isEmpty();
1228 TQStringList list = keys();
1229 TQStringList newlist;
1230 TQStringList preferredKeys = d->mimeTypeInfo->preferredKeys();
1231 TQStringList::Iterator pref;
1232 TQStringList::Iterator begin = preferredKeys.begin();
1233 TQStringList::Iterator end = preferredKeys.end();
1236 for ( pref = begin; pref!=end; ++pref )
1238 TQStringList::Iterator item = list.find(*pref);
1239 if ( item != list.end() )
1241 newlist.append( *item );
1255 if (d == Data::makeNull())
1256 kdWarning(7033) <<
"attempt to get the keys of " 1257 "an invalid metainfo group";
1262 TQMapConstIterator<TQString, KFileMetaInfoItem> it;
1263 for (it = d->items.begin(); it!=d->items.end(); ++it)
1265 list.append(it.data().key());
1274 return d->mimeTypeInfo->groupInfo(d->name)->translatedName();
1280 return d->mimeTypeInfo->groupInfo(d->name)->supportedKeys();
1286 return d->mimeTypeInfo->groupInfo(d->name)->supportsVariableKeys();
1291 return d->items.contains(key);
1296 TQMapIterator<TQString,KFileMetaInfoItem> it = d->items.find( key );
1297 if ( it != d->items.end() )
1305 TQMapIterator<TQString, KFileMetaInfoItem> it;
1307 for (it = d->items.begin(); it!=d->items.end(); ++it)
1308 if (it.data().hint() == hint)
1322 return d->mimeTypeInfo->groupInfo(d->name)->attributes();
1325 void KFileMetaInfoGroup::setAdded()
1335 void KFileMetaInfoGroup::ref()
1337 if (d != Data::null) d->ref();
1341 void KFileMetaInfoGroup::deref()
1346 if ((d != Data::null) && d->deref())
1359 TQMapIterator<TQString,KFileMetaInfoItem> it = d->items.find( key );
1360 if ( it != d->items.end() )
1384 d->items.insert(key, item);
1394 kdDebug(7033) <<
"trying to remove an item from an invalid group\n";
1398 TQMapIterator<TQString, KFileMetaInfoItem> it = d->items.find(key);
1399 if ( it==d->items.end() )
1401 kdDebug(7033) <<
"trying to remove the non existant item " << key <<
"\n";
1407 kdDebug(7033) <<
"trying to remove a non removable item\n";
1412 d->items.remove(it);
1413 d->removedItems.append(key);
1420 return d->removedItems;
1424 const TQVariant& value)
1430 kdWarning() <<
"Trying to append a Metadata item for a non-existant group:" << d->
name << endl;
1435 kdWarning() <<
"Trying to append a Metadata item for an unknown key (no ItemInfo): " << key << endl;
1441 if (info->
key().isNull())
1446 kdDebug(7033) <<
"KFileMetaInfogroup inserting a " << key << endl;
1448 d->items.insert(key, item);
1452 KFileMetaInfoGroup::Data* KFileMetaInfoGroup::Data::null = 0L;
1453 static KStaticDeleter<KFileMetaInfoGroup::Data> sd_KFileMetaInfoGroupData;
1455 KFileMetaInfoGroup::Data* KFileMetaInfoGroup::Data::makeNull()
1462 null =
new Data(TQString::null);
1464 sd_KFileMetaInfoGroupData.setObject( null );
1473 KFileMimeTypeInfo::KFileMimeTypeInfo(
const TQString& mimeType )
1474 : m_mimeType( mimeType )
1476 m_groups.setAutoDelete(
true );
1479 KFileMimeTypeInfo::~KFileMimeTypeInfo()
1485 return m_groups.find( group );
1489 const TQString& name,
const TQString& translatedName )
1492 m_groups.insert(name, group);
1499 TQDictIterator<GroupInfo> it( m_groups );
1500 for ( ; it.current(); ++it )
1501 list.append( it.current()->name() );
1509 TQDictIterator<GroupInfo> it( m_groups );
1510 for ( ; it.current(); ++it )
1511 list.append( it.current()->translatedName() );
1521 TQStringList::ConstIterator lit;
1522 TQDictIterator<GroupInfo> it( m_groups );
1523 for ( ; it.current(); ++it ) {
1524 TQStringList list = it.current()->supportedKeys();
1525 for ( lit = list.begin(); lit != list.end(); ++lit ) {
1526 if ( keys.find( *lit ) == keys.end() )
1527 keys.append( *lit );
1535 const TQString& key,
1537 const char *name)
const 1539 KFilePlugin* plugin = KFileMetaInfoProvider::self()->plugin(m_mimeType);
1549 KFileMimeTypeInfo::GroupInfo::GroupInfo(
const TQString& name,
1550 const TQString& translatedName )
1552 m_translatedName( translatedName ),
1554 m_variableItemInfo( 0 )
1557 m_itemDict.setAutoDelete(
true );
1560 KFileMimeTypeInfo::GroupInfo::~GroupInfo()
1562 delete m_variableItemInfo;
1567 ItemInfo* item = m_itemDict.find( key );
1571 if (!item && m_variableItemInfo)
1573 return m_variableItemInfo;
1579 const TQString& key,
const TQString& translatedKey,
1580 TQVariant::Type type)
1585 m_supportedKeys.append(key);
1586 m_itemDict.insert(key, item);
1591 void KFileMimeTypeInfo::GroupInfo::addVariableInfo( TQVariant::Type type,
1595 delete m_variableItemInfo;
1596 m_variableItemInfo =
new ItemInfo(TQString::null, TQString::null, type);
1597 m_variableItemInfo->m_attr = attr;
1607 switch (value.type())
1609 case TQVariant::Invalid :
1612 case TQVariant::Bool :
1613 s = value.toBool() ? i18n(
"Yes") : i18n(
"No");
1616 case TQVariant::Int :
1619 int seconds = value.toInt() % 60;
1620 int minutes = value.toInt() / 60 % 60;
1621 int hours = value.toInt() / 3600;
1622 s = hours ? TQString().sprintf(
"%d:%02d:%02d",hours, minutes, seconds)
1623 : TQString().sprintf(
"%02d:%02d", minutes, seconds);
1637 s = TDEGlobal::locale()->formatNumber( value.toInt() , 0);
1640 case TQVariant::LongLong :
1641 s = TDEGlobal::locale()->formatNumber( value.toLongLong(), 0 );
1644 case TQVariant::ULongLong :
1650 s = TDEGlobal::locale()->formatNumber( value.toULongLong(), 0 );
1653 case TQVariant::UInt :
1654 s = TDEGlobal::locale()->formatNumber( value.toUInt() , 0);
1657 case TQVariant::Double :
1658 s = TDEGlobal::locale()->formatNumber( value.toDouble(), 3);
1661 case TQVariant::Date :
1662 s = TDEGlobal::locale()->formatDate( value.toDate(), true );
1665 case TQVariant::Time :
1666 s = TDEGlobal::locale()->formatTime( value.toTime(), true );
1669 case TQVariant::DateTime :
1670 s = TDEGlobal::locale()->formatDateTime( value.toDateTime(),
1674 case TQVariant::Size :
1675 s = TQString(
"%1 x %2").arg(value.toSize().width())
1676 .arg(value.toSize().height());
1679 case TQVariant::Point :
1680 s = TQString(
"%1/%2").arg(value.toSize().width())
1681 .arg(value.toSize().height());
1685 s = value.toString();
1688 if (mangle && !s.isNull())
1690 s.prepend(prefix());
1691 s.append(
" " + suffix());
1708 TDEIO_EXPORT TQDataStream& operator <<(TQDataStream& s,
const KFileMetaInfoItem& item )
1711 KFileMetaInfoItem::Data* d = item.d;
1714 bool isValid = item.
isValid();
1728 TDEIO_EXPORT TQDataStream& operator >>(TQDataStream& s,
KFileMetaInfoItem& item )
1741 item.d =
new KFileMetaInfoItem::Data();
1744 bool dirty, added, removed;
1750 item.d->dirty = dirty;
1751 item.d->added = added;
1752 item.d->removed = removed;
1761 TDEIO_EXPORT TQDataStream& operator <<(TQDataStream& s,
const KFileMetaInfoGroup& group )
1763 KFileMetaInfoGroup::Data* d = group.d;
1766 bool isValid = group.
isValid();
1773 << d->mimeTypeInfo->mimeType();
1793 group.d =
new KFileMetaInfoGroup::Data();
1799 group.d->mimeTypeInfo = KFileMetaInfoProvider::self()->mimeTypeInfo(mimeType);
1802 TQMapIterator<TQString, KFileMetaInfoItem> it = group.d->items.begin();
1803 for ( ; it != group.d->items.end(); ++it)
1805 (*it).d->mimeTypeInfo = group.d->mimeTypeInfo->groupInfo(group.d->name)
1806 ->itemInfo((*it).key());
1815 TDEIO_EXPORT TQDataStream& operator <<(TQDataStream& s,
const KFileMetaInfo& info )
1817 KFileMetaInfo::Data* d = info.d;
1820 bool isValid = info.
isValid();
1828 << d->mimeTypeInfo->mimeType();
1833 TDEIO_EXPORT TQDataStream& operator >>(TQDataStream& s,
KFileMetaInfo& info )
1848 info.d =
new KFileMetaInfo::Data();
1854 info.d->mimeTypeInfo = KFileMetaInfoProvider::self()->mimeTypeInfo(mimeType);
1859 #include "tdefilemetainfo.moc" const TQString & name() const
Use this method to get the name of the group.
TDEIO_EXPORT TQString convertSize(TDEIO::filesize_t size)
Converts size from bytes to the string representation.
TQValidator * createValidator(const TQString &group, const TQString &key, TQObject *parent=0, const char *name=0) const
Creates a validator for this item.
static TDETrader * self()
This is a static pointer to a TDETrader instance.
Information about a meta information group.
KFileMetaInfoGroup appendGroup(KFileMetaInfo &info, const TQString &key)
Call this method from within readInfo() to indicate that you wish to fill meta information items of t...
const KURL & url() const
Returns the url of the file.
Hint
This enum is mainly for items that have a special meaning for some applications.
Sample rates and similar.
The value can be edited (no meaning for a group)
void setHint(KFileMimeTypeInfo::ItemInfo *item, uint hint)
Defines the meaning of the meta information item.
bool isVariableItem() const
Is this item the variable item?
TQStringList supportedKeys() const
Use this method to get a list of keys in the specified group that the plugin knows about...
void setPrefix(KFileMimeTypeInfo::ItemInfo *item, const TQString &prefix)
Sets a prefix string which is displayed before the item's value.
virtual bool writeInfo(const KFileMetaInfo &info) const
Similar to the readInfo() but for writing the info back to the file.
void init(bool _determineMimeTypeOnDemand)
Computes the text, mode, and mimetype from the UDSEntry Called by constructor, but can be called agai...
Represents the capabilities of a KFilePlugin for a given mimetype.
KFilePlugin(TQObject *parent, const char *name, const TQStringList &args)
Creates a new KFilePlugin instance.
uint attributes() const
Get the attributes of this group (see Attributes)
const ItemInfo * variableItemInfo() const
If the group supports variable keys, you can query their item info with this method.
For image dimensions and similar.
virtual TQValidator * createValidator(const TQString &mimeType, const TQString &group, const TQString &key, TQObject *parent, const char *name) const
This method should create an appropriate validator for the specified item if it's editable or return ...
Some data/file size in kilobytes.
const ItemInfo * itemInfo(const TQString &key) const
A group object can contain several item objects (of which you can get the names with supportedKeys() ...
void appendItem(KFileMetaInfoGroup &group, const TQString &key, TQVariant value)
Call this method from within readInfo() to fill the meta information item identified by key with a va...
KFileMimeTypeInfo * addMimeTypeInfo(const TQString &mimeType)
Call this from within your constructor to tell the KFile framework what mimetypes your plugin support...
void setAttributes(KFileMimeTypeInfo::GroupInfo *gi, uint attr) const
Sets attributes of the GroupInfo object returned by addGroupInfo().
Base class for a meta information plugin.
KFileMimeTypeInfo::GroupInfo * addGroupInfo(KFileMimeTypeInfo *info, const TQString &key, const TQString &translatedKey) const
Creates a meta information group for KFileMimeTypeInfo object returned by addMimeTypeInfo().
static Ptr findByURL(const KURL &_url, mode_t _mode=0, bool _is_local_file=false, bool _fast_mode=false)
Finds a KMimeType with the given _url.
TQString group() const
Returns the group of the file.
const TQString & name(bool lowerCase=false) const
Return the name of the file item (without a path).
TQStringList supportedKeys() const
Return a list of all supported keys without looking for a specific group.
TQStringList supportedGroups() const
Returns the list of all groups that the plugin for this mimetype supports.
const GroupInfo * groupInfo(const TQString &group) const
Get the group info for a specific group.
virtual bool readInfo(KFileMetaInfo &info, uint what=KFileMetaInfo::Fastest)=0
Read the info from the file in this method and insert it into the provided KFileMetaInfo object...
void setSuffix(KFileMimeTypeInfo::ItemInfo *item, const TQString &suffix)
Sets a suffix string which is displayed before the item's value.
Some data/file size in bytes.
The item represents a time in milliseconds.
const TQString & key() const
Returns the name of the item.
TQValueList< KService::Ptr > OfferList
A list of services.
virtual ~KFilePlugin()
Destructor.
static KService::Ptr preferredService(const TQString &serviceType, const TQString &genericServiceType)
Returns the preferred service for _serviceType and _genericServiceType ("Application", type of component, or null).
TQStringList translatedGroups() const
Same as the above function, but returns the strings to display to the user.
uint attributes() const
Return the attributes of the item.
virtual void virtual_hook(int id, void *data)
Helper method to allow binary compatible extensions when needing "new virtual methods".
void setUnit(KFileMimeTypeInfo::ItemInfo *item, uint unit)
Sets the unit used in the meta information item.
KFileMimeTypeInfo::ItemInfo * addItemInfo(KFileMimeTypeInfo::GroupInfo *gi, const TQString &key, const TQString &translatedKey, TQVariant::Type type)
Adds a meta information item to a GroupInfo object as returned by addGroupInfo(). ...
virtual OfferList query(const TQString &servicetype, const TQString &constraint=TQString::null, const TQString &preferences=TQString::null) const
The main function in the TDETrader class.
This is the class for one item of a KFileMimeTypeInfo.
TQString string(const TQVariant &value, bool mangle=true) const
Returns a string for the specified value, if possible.
TDEIO_EXPORT TQString convertSizeFromKB(TDEIO::filesize_t kbSize)
Converts size from kilo-bytes to the string representation.
The item or group can be added by a user.
The item represents a time in seconds.