29#include <kstaticdeleter.h>
30#include <tdeparts/componentfactory.h>
31#include <kuserprofile.h>
34#include <kdatastream.h>
36#include <tdeio/global.h>
38#include "tdefilemetainfo.h"
41class KFileMetaInfoItem::Data :
public TQShared
45 const TQVariant& _value )
56 Data() : mimeTypeInfo( 0L )
74 static Data* makeNull();
78KFileMetaInfoItem::Data* KFileMetaInfoItem::Data::null = 0L;
79static KStaticDeleter<KFileMetaInfoItem::Data> sd_KFileMetaInfoItemData;
81KFileMetaInfoItem::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();
114KFileMetaInfoItem::~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;
240void KFileMetaInfoItem::setAdded()
245void KFileMetaInfoItem::setRemoved()
250void KFileMetaInfoItem::ref()
252 if (d != Data::null) d->ref();
255void KFileMetaInfoItem::deref()
260 if ((d != Data::null) && d->deref())
273class KFileMetaInfo::Data :
public TQShared
276 Data(
const KURL& _url, uint _what)
288 TQMap<TQString, KFileMetaInfoGroup> groups;
290 TQStringList removedGroups;
293 static Data* makeNull();
312void KFileMetaInfo::init(
const KURL& url,
const TQString& mimeType,
315 d =
new Data(
url, what );
328 d->mimeTypeInfo = KFileMetaInfoProvider::self()->mimeTypeInfo( mT,
url.protocol() );
329 if ( d->mimeTypeInfo )
337 d = Data::makeNull();
344 d = Data::makeNull();
351 d = Data::makeNull();
357 d = Data::makeNull();
360KFileMetaInfo::~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();
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;
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())
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);
617 for (TQStringList::Iterator it =
groups.begin(); it !=
groups.end(); ++it)
628 TQStringList::ConstIterator 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 ) ) {
653 it = d->groups.find( preferredGroup );
657 if ( it != d->groups.end() ) {
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() )
682 d->mimeTypeInfo->groupInfo( *groupIt );
683 if ( groupInfo && groupInfo->
supportedKeys().contains( key ) )
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;
744void KFileMetaInfo::ref()
746 if (d != Data::null) d->ref();
750void KFileMetaInfo::deref()
755 if ((d != Data::null) && d->deref())
765KFileMetaInfo::Data* KFileMetaInfo::Data::null = 0L;
766static KStaticDeleter<KFileMetaInfo::Data> sd_KFileMetaInfoData;
768KFileMetaInfo::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);
908KFileMetaInfoProvider * KFileMetaInfoProvider::s_self;
909static KStaticDeleter<KFileMetaInfoProvider> sd;
911KFileMetaInfoProvider * KFileMetaInfoProvider::self()
914 s_self = sd.setObject( s_self,
new KFileMetaInfoProvider() );
919KFileMetaInfoProvider::KFileMetaInfoProvider()
921 m_plugins.setAutoDelete(
true );
924KFileMetaInfoProvider::~KFileMetaInfoProvider()
930KFilePlugin* 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,
this, mimeType.local8Bit() );
956 kdWarning(7033) <<
"error loading the plugin from " << service->desktopEntryPath() << endl;
961KFilePlugin* 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();
996KFilePlugin * KFileMetaInfoProvider::plugin(
const TQString& mimeType)
998 return plugin( mimeType, TQString::null );
1001KFilePlugin * 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;
1040TQStringList KFileMetaInfoProvider::preferredKeys(
const TQString& mimeType )
const
1042 KService::Ptr service =
1045 if ( !service || !service->isValid() )
1048 return TQStringList();
1050 return service->property(
"PreferredItems").toStringList();
1053TQStringList KFileMetaInfoProvider::preferredGroups(
const TQString& mimeType )
const
1055 KService::Ptr service =
1058 if ( !service || !service->isValid() )
1061 return TQStringList();
1063 return service->property(
"PreferredGroups").toStringList();
1066const KFileMimeTypeInfo * KFileMetaInfoProvider::mimeTypeInfo(
const TQString& mimeType )
1068 return mimeTypeInfo( mimeType, TQString::null );
1071const 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 );
1120TQStringList 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;
1147class 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();
1196KFileMetaInfoGroup::~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;
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();
1325void KFileMetaInfoGroup::setAdded()
1335void KFileMetaInfoGroup::ref()
1337 if (d != Data::null) d->ref();
1341void 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);
1452KFileMetaInfoGroup::Data* KFileMetaInfoGroup::Data::null = 0L;
1453static KStaticDeleter<KFileMetaInfoGroup::Data> sd_KFileMetaInfoGroupData;
1455KFileMetaInfoGroup::Data* KFileMetaInfoGroup::Data::makeNull()
1462 null =
new Data(TQString::null);
1464 sd_KFileMetaInfoGroupData.setObject( null );
1473KFileMimeTypeInfo::KFileMimeTypeInfo(
const TQString& mimeType )
1474 : m_mimeType( mimeType )
1476 m_groups.setAutoDelete(
true );
1479KFileMimeTypeInfo::~KFileMimeTypeInfo()
1485 return m_groups.find( group );
1489 const TQString& name,
const TQString& translatedName )
1491 GroupInfo* group =
new GroupInfo( name, 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);
1549KFileMimeTypeInfo::GroupInfo::GroupInfo(
const TQString& name,
1550 const TQString& translatedName )
1552 m_translatedName( translatedName ),
1554 m_variableItemInfo( 0 )
1557 m_itemDict.setAutoDelete(
true );
1560KFileMimeTypeInfo::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);
1591void 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());
1708TDEIO_EXPORT TQDataStream& operator <<(TQDataStream& s,
const KFileMetaInfoItem& item )
1711 KFileMetaInfoItem::Data* d = item.d;
1714 bool isValid = item.
isValid();
1728TDEIO_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;
1761TDEIO_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());
1815TDEIO_EXPORT TQDataStream& operator <<(TQDataStream& s,
const KFileMetaInfo& info )
1817 KFileMetaInfo::Data* d = info.d;
1820 bool isValid = info.
isValid();
1828 << d->mimeTypeInfo->mimeType();
1833TDEIO_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"
Information about a meta information group.
const ItemInfo * variableItemInfo() const
If the group supports variable keys, you can query their item info with this method.
TQStringList supportedKeys() const
Use this method to get a list of keys in the specified group that the plugin knows about.
uint attributes() const
Get the attributes of this group (see Attributes)
const ItemInfo * itemInfo(const TQString &key) const
A group object can contain several item objects (of which you can get the names with supportedKeys() ...
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.
uint attributes() const
Return the attributes of the item.
const TQString & key() const
Returns the name of the item.
bool isVariableItem() const
Is this item the variable item?
Represents the capabilities of a KFilePlugin for a given mimetype.
const GroupInfo * groupInfo(const TQString &group) const
Get the group info for a specific group.
@ Removable
It can be removed.
@ Modifiable
The value can be edited (no meaning for a group)
@ Addable
The item or group can be added by a user.
TQStringList translatedGroups() const
Same as the above function, but returns the strings to display to the user.
@ Seconds
The item represents a time in seconds.
@ Pixels
For image dimensions and similar.
@ FramesPerSecond
A frame rate.
@ DotsPerInch
Resolution in DPI.
@ BitsPerSecond
A bit rate.
@ Bytes
Some data/file size in bytes.
@ KiloBytes
Some data/file size in kilobytes.
@ Hertz
Sample rates and similar.
@ MilliSeconds
The item represents a time in milliseconds.
@ BitsPerPixel
A bit depth.
TQString mimeType() const
Returns the mimetype to which this info belongs.
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.
Hint
This enum is mainly for items that have a special meaning for some applications.
TQValidator * createValidator(const TQString &group, const TQString &key, TQObject *parent=0, const char *name=0) const
Creates a validator for this item.
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().
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().
void setPrefix(KFileMimeTypeInfo::ItemInfo *item, const TQString &prefix)
Sets a prefix string which is displayed before the item's value.
virtual void virtual_hook(int id, void *data)
Helper method to allow binary compatible extensions when needing "new virtual methods".
KFileMimeTypeInfo * addMimeTypeInfo(const TQString &mimeType)
Call this from within your constructor to tell the KFile framework what mimetypes your plugin support...
void setUnit(KFileMimeTypeInfo::ItemInfo *item, uint unit)
Sets the unit used in the meta information item.
virtual ~KFilePlugin()
Destructor.
virtual bool writeInfo(const KFileMetaInfo &info) const
Similar to the readInfo() but for writing the info back to the file.
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...
void setAttributes(KFileMimeTypeInfo::GroupInfo *gi, uint attr) const
Sets attributes of the GroupInfo object returned by addGroupInfo().
void setHint(KFileMimeTypeInfo::ItemInfo *item, uint hint)
Defines the meaning of the meta information item.
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...
KFilePlugin(TQObject *parent, const char *name, const TQStringList &args)
Creates a new KFilePlugin instance.
void setSuffix(KFileMimeTypeInfo::ItemInfo *item, const TQString &suffix)
Sets a suffix string which is displayed before the item's value.
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.
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 ...
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.
static KService::Ptr preferredService(const TQString &serviceType, const TQString &genericServiceType)
Returns the preferred service for _serviceType and _genericServiceType ("Application",...
virtual OfferList query(const TQString &servicetype, const TQString &constraint=TQString::null, const TQString &preferences=TQString::null) const
The main function in the TDETrader class.
static TDETrader * self()
This is a static pointer to a TDETrader instance.
TQValueList< KService::Ptr > OfferList
A list of services.
TDEIO_EXPORT TQString convertSizeFromKB(TDEIO::filesize_t kbSize)
Converts size from kilo-bytes to the string representation.
TDEIO_EXPORT TQString convertSize(TDEIO::filesize_t size)
Converts size from bytes to the string representation.