No OneTemporary
Actions

Size

85 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/experimental/libkdeclarative/CMakeLists.txt b/experimental/libkdeclarative/CMakeLists.txt
	index 5fe5ff6f1a..0db647ce49 100644
	--- a/experimental/libkdeclarative/CMakeLists.txt
	+++ b/experimental/libkdeclarative/CMakeLists.txt
	@@ -1,63 +1,54 @@
	project(kdeclarative)

	if(KDE_PLATFORM_FEATURE_BINARY_COMPATIBLE_FEATURE_REDUCTION)
	set(KDECLARATIVE_NO_KIO TRUE)
	endif(KDE_PLATFORM_FEATURE_BINARY_COMPATIBLE_FEATURE_REDUCTION)

	configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-kdeclarative.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kdeclarative.h)

	include_directories(
	${CMAKE_SOURCE_DIR}
	${CMAKE_BINARY_DIR}
	${KDE4_KIO_INCLUDES}
	${CMAKE_SOURCE_DIR}/kio
	)

	if(BUILDING_EXPERIMENTAL_SEPARATELY)
	include_directories(${KDE4_INCLUDES})
	endif()

	set(kdeclarative_LIB_SRCS
	kdeclarative.cpp
	private/engineaccess.cpp
	private/kiconprovider.cpp
	bindings/qscriptnonguibookkeeping.cpp
	bindings/i18n.cpp
	bindings/icon.cpp
	- bindings/url.cpp
	- ${CMAKE_SOURCE_DIR}/kdeui/icons/kicon.cpp
	- ${CMAKE_SOURCE_DIR}/kdeui/icons/kiconengine.cpp
	- ${CMAKE_SOURCE_DIR}/kdeui/icons/kiconloader.cpp
	- #${CMAKE_SOURCE_DIR}/kdeui/icons/kiconeffect.cpp
	- ${CMAKE_SOURCE_DIR}/kdeui/icons/kicontheme.cpp
	- ${CMAKE_SOURCE_DIR}/kdeui/kernel/kglobalsettings.cpp
	- ${CMAKE_SOURCE_DIR}/kdeui/colors/kcolorscheme.cpp
	- ${CMAKE_SOURCE_DIR}/kdeui/colors/kcolorspaces.cpp
	- ${CMAKE_SOURCE_DIR}/kdeui/colors/kcolorutils.cpp)
	+ bindings/url.cpp)

	kde4_add_library(kdeclarative SHARED ${kdeclarative_LIB_SRCS})

	set_target_properties(kdeclarative PROPERTIES VERSION ${KDE_NON_GENERIC_LIB_VERSION} SOVERSION ${KDE_NON_GENERIC_LIB_SOVERSION})

	-target_link_libraries(kdeclarative ${KDE4_KDECORE_LIBS} ${QT_QTSVG_LIBRARY} ${QT_QTGUI_LIBRARY} ${QT_QTSCRIPT_LIBRARY} ${X11_LIBRARIES} ${X11_Xcursor_LIB} ${QT_QTDECLARATIVE_LIBRARY})
	+target_link_libraries(kdeclarative ${KDE4_KDECORE_LIBS} ${KDE4_KDEUI_LIBS} ${QT_QTSCRIPT_LIBRARY} ${QT_QTDECLARATIVE_LIBRARY})


	## test
	set(kdeclarative_TEST_SRCS
	test/test.cpp)

	kde4_add_executable(kdeclarativetest ${kdeclarative_TEST_SRCS})

	target_link_libraries(kdeclarativetest kdeclarative ${KDE4_KDECORE_LIBS} ${QT_QTGUI_LIBRARY} ${QT_QTSCRIPT_LIBRARY} ${QT_QTDECLARATIVE_LIBRARY})

	## install

	set(kdeclarative_LIB_HEADERS
	kdeclarative.h
	kdeclarative_export.h)

	install(FILES ${kdeclarative_LIB_HEADERS} DESTINATION ${INCLUDE_INSTALL_DIR}/ COMPONENT Devel)

	install(TARGETS kdeclarative EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})


	diff --git a/experimental/libkdeclarative/bindings/icon.cpp b/experimental/libkdeclarative/bindings/icon.cpp
	index 892bd2145e..7188d635dd 100644
	--- a/experimental/libkdeclarative/bindings/icon.cpp
	+++ b/experimental/libkdeclarative/bindings/icon.cpp
	@@ -1,113 +1,112 @@
	/*
	* Copyright (c) 2009 Aaron J. Seigo <aseigo@kde.org>
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU Library General Public License version 2 as
	* published by the Free Software Foundation
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details
	*
	* You should have received a copy of the GNU Library General Public
	* License along with this program; if not, write to the
	* Free Software Foundation, Inc.,
	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	*/

	#include <QtScript/QScriptValue>
	#include <QtScript/QScriptEngine>
	#include <QtScript/QScriptContext>

	-#define KICONLOADER_WITHOUTEFFECTS
	#include <kicon.h>

	#include "backportglobal.h"

	Q_DECLARE_METATYPE(QIcon)
	Q_DECLARE_METATYPE(QIcon*)
	Q_DECLARE_METATYPE(KIcon)
	Q_DECLARE_METATYPE(KIcon*)

	static QScriptValue iconCtor(QScriptContext ctx, QScriptEngine eng)
	{
	if (ctx->argumentCount() > 0) {
	QScriptValue v = ctx->argument(0);
	if (v.isString()) {
	QIcon icon = KIcon(v.toString());
	return qScriptValueFromValue(eng, icon);
	} else if (v.isVariant()) {
	QVariant variant = v.toVariant();
	QPixmap p = variant.value<QPixmap>();
	if (!p.isNull()) {
	return qScriptValueFromValue(eng, QIcon(p));
	}
	}
	}
	return qScriptValueFromValue(eng, QIcon());
	}

	static QScriptValue addPixmap(QScriptContext ctx, QScriptEngine eng)
	{
	DECLARE_SELF(QIcon, addPixmap);

	if (ctx->argumentCount() > 0) {
	QScriptValue arg = ctx->argument(0);

	if (arg.isVariant()) {
	QVariant variant = arg.toVariant();
	QPixmap p = variant.value<QPixmap>();
	if (!p.isNull()) {
	self->addPixmap(p);
	}
	}
	}

	return eng->undefinedValue();
	}

	static QScriptValue addFile(QScriptContext ctx, QScriptEngine eng)
	{
	DECLARE_SELF(QIcon, addFile);

	if (ctx->argumentCount() > 0) {
	QScriptValue arg = ctx->argument(0);

	if (arg.isString()) {
	self->addFile(arg.toString());
	}
	}

	return eng->undefinedValue();
	}

	static QScriptValue isNull(QScriptContext ctx, QScriptEngine eng)
	{
	Q_UNUSED(eng)
	DECLARE_SELF(QIcon, isNull);
	return self->isNull();
	}

	QScriptValue constructIconClass(QScriptEngine *eng)
	{
	QScriptValue proto = qScriptValueFromValue(eng, QIcon());
	QScriptValue::PropertyFlags getter = QScriptValue::PropertyGetter;
	QScriptValue::PropertyFlags setter = QScriptValue::PropertySetter;
	proto.setProperty("addPixmap", eng->newFunction(addPixmap));
	proto.setProperty("addFile", eng->newFunction(addFile));
	proto.setProperty("null", eng->newFunction(isNull), getter);

	QScriptValue ctorFun = eng->newFunction(iconCtor, proto);
	ADD_ENUM_VALUE(ctorFun, QIcon, Normal);
	ADD_ENUM_VALUE(ctorFun, QIcon, Disabled);
	ADD_ENUM_VALUE(ctorFun, QIcon, Active);
	ADD_ENUM_VALUE(ctorFun, QIcon, Selected);
	ADD_ENUM_VALUE(ctorFun, QIcon, Off);
	ADD_ENUM_VALUE(ctorFun, QIcon, On);

	eng->setDefaultPrototype(qMetaTypeId<QIcon>(), proto);

	return ctorFun;
	}

	diff --git a/kdeui/icons/kiconloader.cpp b/kdeui/icons/kiconloader.cpp
	index 5310765616..d89360ca1a 100644
	--- a/kdeui/icons/kiconloader.cpp
	+++ b/kdeui/icons/kiconloader.cpp
	@@ -1,1732 +1,1722 @@
	/* vi: ts=8 sts=4 sw=4
	*
	* kiconloader.cpp: An icon loader for KDE with theming functionality.
	*
	* This file is part of the KDE project, module kdeui.
	* Copyright (C) 2000 Geert Jansen <jansen@kde.org>
	* Antonio Larrosa <larrosa@kde.org>
	* 2010 Michael Pyne <mpyne@kde.org>
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Library General Public
	* License version 2 as published by the Free Software Foundation.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Library General Public License for more details.
	*
	* You should have received a copy of the GNU Library General Public License
	* along with this library; see the file COPYING.LIB. If not, write to
	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	* Boston, MA 02110-1301, USA.
	*/

	#include "kiconloader.h"

	#include <sys/types.h>
	#include <stdlib.h> //for abs
	#include <unistd.h> //for readlink
	#include <dirent.h>
	#include <assert.h>

	#include <QtCore/QCache>
	#include <QtCore/QFileInfo>
	#include <QtCore/QDir>
	#include <QtCore/QBuffer>
	#include <QtCore/QDataStream>
	#include <QtCore/QByteArray>
	#include <QtCore/QStringBuilder> // % operator for QString
	#include <QtGui/QIcon>
	#include <QtGui/QImage>
	#include <QtGui/QMovie>
	#include <QtGui/QPainter>
	#include <QtGui/QPixmap>
	#include <QtGui/QPixmapCache>
	#ifndef _WIN32_WCE
	#include <QtSvg/QSvgRenderer>
	#endif

	// kdecore
	#include <kconfig.h>
	#include <kconfiggroup.h>
	#include <kdebug.h>
	#include <kstandarddirs.h>
	#include <kglobal.h>
	#include <kglobalsettings.h>
	#include <kcomponentdata.h>
	#include <kde_file.h>
	#include <kshareddatacache.h>

	// kdeui
	#include "kicontheme.h"
	#include "kiconeffect.h"
	#include "k3icon_p.h"

	// Used to make cache keys for icons with no group. Result type is QString*
	K_GLOBAL_STATIC_WITH_ARGS(QString, NULL_EFFECT_FINGERPRINT, (QString::fromLatin1("noeffect")))

	// Qt implements Tiny SVG specification. This specification does not cover important elements
	// that are pretty globally used on our icons, like blurring (and other filters). TT seems to have
	// no interest in supporting the full SVG specification (it would be slower, even with JS, CSS
	// support...). So, we have no chance for now. Let's disable svg rendering unconditionally.
	// (ereslibre)
	#undef KDE_QT_SVG_RENDERER_FIXED

	/**
	* Checks for relative paths quickly on UNIX-alikes, slowly on everything else.
	*/
	static bool pathIsRelative(const QString &path)
	{
	#ifdef Q_OS_UNIX
	return (!path.isEmpty() && path[0] != QChar('/'));
	#else
	return QDir::isRelativePath(path);
	#endif
	}

	/**
	* Holds a QPixmap for this process, along with its associated path on disk.
	*/
	struct PixmapWithPath
	{
	QPixmap pixmap;
	QString path;
	};

	/* KIconThemeNode: A node in the icon theme dependancy tree. */

	class KIconThemeNode
	{
	public:

	KIconThemeNode(KIconTheme *_theme);
	~KIconThemeNode();

	void queryIcons(QStringList *lst, int size, KIconLoader::Context context) const;
	void queryIconsByContext(QStringList *lst, int size, KIconLoader::Context context) const;
	K3Icon findIcon(const QString& name, int size, KIconLoader::MatchType match) const;
	void printTree(QString& dbgString) const;

	KIconTheme *theme;
	};

	KIconThemeNode::KIconThemeNode(KIconTheme *_theme)
	{
	theme = _theme;
	}

	KIconThemeNode::~KIconThemeNode()
	{
	delete theme;
	}

	void KIconThemeNode::printTree(QString& dbgString) const
	{
	/* This method doesn't have much sense anymore, so maybe it should
	be removed in the (near?) future */
	dbgString += '(';
	dbgString += theme->name();
	dbgString += ')';
	}

	void KIconThemeNode::queryIcons(QStringList *result,
	int size, KIconLoader::Context context) const
	{
	// add the icons of this theme to it
	*result += theme->queryIcons(size, context);
	}

	void KIconThemeNode::queryIconsByContext(QStringList *result,
	int size, KIconLoader::Context context) const
	{
	// add the icons of this theme to it
	*result += theme->queryIconsByContext(size, context);
	}

	K3Icon KIconThemeNode::findIcon(const QString& name, int size,
	KIconLoader::MatchType match) const
	{
	return theme->iconPath(name, size, match);
	}


	/* KIconGroup: Icon type description. */

	struct KIconGroup
	{
	int size;
	bool alphaBlending;
	};


	/* d pointer for KIconLoader. */
	class KIconLoaderPrivate
	{
	public:
	KIconLoaderPrivate(KIconLoader *q)
	: q(q)
	, mpGroups(0)
	, mIconCache(0)
	{
	}

	~KIconLoaderPrivate()
	{
	/* antlarr: There's no need to delete d->mpThemeRoot as it's already
	deleted when the elements of d->links are deleted */
	qDeleteAll(links);
	delete[] mpGroups;
	delete mIconCache;
	}

	/**
	* @internal
	*/
	void init( const QString& _appname, KStandardDirs *_dirs );

	/**
	* @internal
	*/
	bool initIconThemes();

	/**
	* @internal
	* tries to find an icon with the name. It tries some extension and
	* match strategies
	*/
	K3Icon findMatchingIcon(const QString& name, int size) const;

	/**
	* @internal
	* tries to find an icon with the name.
	* This is one layer above findMatchingIcon -- it also implements generic fallbacks
	* such as generic icons for mimetypes.
	*/
	K3Icon findMatchingIconWithGenericFallbacks(const QString& name, int size) const;

	/**
	* @internal
	* Adds themes installed in the application's directory.
	**/
	void addAppThemes(const QString& appname);

	/**
	* @internal
	* Adds all themes that are part of this node and the themes
	* below (the fallbacks of the theme) into the tree.
	*/
	void addBaseThemes(KIconThemeNode *node, const QString &appname);

	/**
	* @internal
	* Recursively adds all themes that are specified in the "Inherits"
	* property of the given theme into the tree.
	*/
	void addInheritedThemes(KIconThemeNode *node, const QString &appname);

	/**
	* @internal
	* Creates a KIconThemeNode out of a theme name, and adds this theme
	* as well as all its inherited themes into the tree. Themes that already
	* exist in the tree will be ignored and not added twice.
	*/
	void addThemeByName(const QString &themename, const QString &appname);

	/**
	* @internal
	* return the path for the unknown icon in that size
	*/
	QString unknownIconPath( int size ) const;

	/**
	* Checks if name ends in one of the supported icon formats (i.e. .png)
	* and returns the name without the extension if it does.
	*/
	QString removeIconExtension(const QString &name) const;

	/**
	* @internal
	* Used with KIconLoader::loadIcon to convert the given name, size, group,
	* and icon state information to valid states. All parameters except the
	* name can be modified as well to be valid.
	*/
	void normalizeIconMetadata(KIconLoader::Group &group, int &size, int &state) const;

	/**
	* @internal
	* Used with KIconLoader::loadIcon to get a base key name from the given
	* icon metadata. Ensure the metadata is normalized first.
	*/
	QString makeCacheKey(const QString &name, KIconLoader::Group group, const QStringList &overlays,
	int size, int state) const;

	/**
	* @internal
	* Creates the QImage for @p path, using SVG rendering as appropriate.
	* @p size is only used for scalable images, but if non-zero non-scalable
	* images will be resized anyways.
	*/
	QImage createIconImage(const QString &path, int size = 0);

	/**
	* @internal
	* Adds an QPixmap with its associated path to the shared icon cache.
	*/
	void insertCachedPixmapWithPath(const QString &key, const QPixmap &data, const QString &path);

	/**
	* @internal
	* Retrieves the path and pixmap of the given key from the shared
	* icon cache.
	*/
	bool findCachedPixmapWithPath(const QString &key, QPixmap &data, QString &path);

	KIconLoader *const q;

	QStringList mThemesInTree;
	KIconGroup *mpGroups;
	KIconThemeNode *mpThemeRoot;
	KStandardDirs *mpDirs;
	-#ifndef KICONLOADER_WITHOUTEFFECTS
	KIconEffect mpEffect;
	-#endif
	QList<KIconThemeNode *> links;

	// This shares the icons across all processes
	KSharedDataCache* mIconCache;

	// This caches rendered QPixmaps in just this process.
	QCache<QString, PixmapWithPath> mPixmapCache;

	bool extraDesktopIconsLoaded :1;
	// lazy loading: initIconThemes() is only needed when the "links" list is needed
	// mIconThemeInited is used inside initIconThemes() to init only once
	bool mIconThemeInited :1;
	QString appname;

	void drawOverlays(const KIconLoader *loader, KIconLoader::Group group, int state, QPixmap& pix, const QStringList& overlays);
	};

	class KIconLoaderGlobalData
	{
	public:
	KIconLoaderGlobalData() {
	const QStringList genericIconsFiles = KGlobal::dirs()->findAllResources("xdgdata-mime", "generic-icons");
	//kDebug() << genericIconsFiles;
	Q_FOREACH(const QString& file, genericIconsFiles) {
	parseGenericIconsFiles(file);
	}
	}

	QString genericIconFor(const QString& icon) const {
	return m_genericIcons.value(icon);
	}

	private:
	void parseGenericIconsFiles(const QString& fileName);
	QHash<QString, QString> m_genericIcons;
	};

	void KIconLoaderGlobalData::parseGenericIconsFiles(const QString& fileName)
	{
	QFile file(fileName);
	if (file.open(QIODevice::ReadOnly)) {
	QTextStream stream(&file);
	stream.setCodec("ISO 8859-1");
	while (!stream.atEnd()) {
	const QString line = stream.readLine();
	if (line.isEmpty() \|\| line[0] == '#')
	continue;
	const int pos = line.indexOf(':');
	if (pos == -1) // syntax error
	continue;
	QString mimeIcon = line.left(pos);
	const int slashindex = mimeIcon.indexOf(QLatin1Char('/'));
	if (slashindex != -1) {
	mimeIcon[slashindex] = QLatin1Char('-');
	}

	const QString genericIcon = line.mid(pos+1);
	m_genericIcons.insert(mimeIcon, genericIcon);
	//kDebug(264) << mimeIcon << "->" << genericIcon;
	}
	}
	}

	K_GLOBAL_STATIC(KIconLoaderGlobalData, s_globalData)

	void KIconLoaderPrivate::drawOverlays(const KIconLoader *iconLoader, KIconLoader::Group group, int state, QPixmap& pix, const QStringList& overlays)
	{
	if (overlays.isEmpty()) {
	return;
	}

	const int width = pix.size().width();
	const int height = pix.size().height();
	const int iconSize = qMin(width, height);
	int overlaySize;

	if (iconSize < 32) {
	overlaySize = 8;
	} else if (iconSize <= 48) {
	overlaySize = 16;
	} else if (iconSize <= 96) {
	overlaySize = 22;
	} else if (iconSize < 256) {
	overlaySize = 32;
	} else {
	overlaySize = 64;
	}

	QPainter painter(&pix);

	int count = 0;
	foreach (const QString& overlay, overlays) {
	// Ensure empty strings fill up a emblem spot
	// Needed when you have several emblems to ensure they're always painted
	// at the same place, even if one is not here
	if (overlay.isEmpty()) {
	++count;
	continue;
	}

	//TODO: should we pass in the kstate? it results in a slower
	// path, and perhaps emblems should remain in the default state
	// anyways?
	const QPixmap pixmap = iconLoader->loadIcon(overlay, group, overlaySize, state, QStringList(), 0, true);

	if (pixmap.isNull()) {
	continue;
	}

	QPoint startPoint;
	switch (count) {
	case 0:
	// bottom left corner
	startPoint = QPoint(2, height - overlaySize - 2);
	break;
	case 1:
	// bottom right corner
	startPoint = QPoint(width - overlaySize - 2,
	height - overlaySize - 2);
	break;
	case 2:
	// top right corner
	startPoint = QPoint(width - overlaySize - 2, 2);
	break;
	case 3:
	// top left corner
	startPoint = QPoint(2, 2);
	break;
	}

	painter.drawPixmap(startPoint, pixmap);

	++count;
	if (count > 3) {
	break;
	}
	}
	}

	KIconLoader::KIconLoader(const QString& _appname, KStandardDirs _dirs, QObject parent)
	: QObject(parent)
	{
	setObjectName(_appname);
	d = new KIconLoaderPrivate(this);

	connect(KGlobalSettings::self(), SIGNAL(iconChanged(int)),
	this, SLOT(newIconLoader()));
	d->init( _appname, _dirs );
	}

	KIconLoader::KIconLoader(const KComponentData &componentData, QObject* parent)
	: QObject(parent)
	{
	setObjectName(componentData.componentName());
	d = new KIconLoaderPrivate(this);

	connect(KGlobalSettings::self(), SIGNAL(iconChanged(int)),
	this, SLOT(newIconLoader()));
	d->init(componentData.componentName(), componentData.dirs());
	}

	void KIconLoader::reconfigure( const QString& _appname, KStandardDirs *_dirs )
	{
	delete d;
	d = new KIconLoaderPrivate(this);
	d->init( _appname, _dirs );
	}

	void KIconLoaderPrivate::init( const QString& _appname, KStandardDirs *_dirs )
	{
	extraDesktopIconsLoaded=false;
	mIconThemeInited = false;
	mpThemeRoot = 0;

	if (_dirs)
	mpDirs = _dirs;
	else
	mpDirs = KGlobal::dirs();

	appname = _appname;
	if (appname.isEmpty())
	appname = KGlobal::mainComponent().componentName();

	// Initialize icon cache
	mIconCache = new KSharedDataCache("icon-cache", 10 * 1024 * 1024);
	// Cost here is number of pixels, not size. So this is actually a bit
	// smaller.
	mPixmapCache.setMaxCost(10 * 1024 * 1024);

	// These have to match the order in kicontheme.h
	static const char * const groups[] = { "Desktop", "Toolbar", "MainToolbar", "Small", "Panel", "Dialog", 0L };
	KSharedConfig::Ptr config = KGlobal::config();

	// loading config and default sizes
	initIconThemes();
	KIconTheme *defaultSizesTheme = links.empty() ? 0 : links.first()->theme;
	mpGroups = new KIconGroup[(int) KIconLoader::LastGroup];
	for (KIconLoader::Group i = KIconLoader::FirstGroup; i < KIconLoader::LastGroup; ++i) {
	if (groups[i] == 0L) {
	break;
	}

	KConfigGroup cg(config, QLatin1String(groups[i]) + "Icons");
	mpGroups[i].size = cg.readEntry("Size", 0);
	if (QPixmap::defaultDepth() > 8) {
	mpGroups[i].alphaBlending = cg.readEntry("AlphaBlending", true);
	} else {
	mpGroups[i].alphaBlending = false;
	}

	if (!mpGroups[i].size && defaultSizesTheme) {
	mpGroups[i].size = defaultSizesTheme->defaultSize(i);
	}
	}
	}

	bool KIconLoaderPrivate::initIconThemes()
	{
	if (mIconThemeInited) {
	// If mpThemeRoot isn't 0 then initing has succeeded
	return (mpThemeRoot != 0);
	}
	//kDebug(264);
	mIconThemeInited = true;

	// Add the default theme and its base themes to the theme tree
	KIconTheme *def = new KIconTheme(KIconTheme::current(), appname);
	if (!def->isValid())
	{
	delete def;
	// warn, as this is actually a small penalty hit
	kDebug(264) << "Couldn't find current icon theme, falling back to default.";
	def = new KIconTheme(KIconTheme::defaultThemeName(), appname);
	if (!def->isValid())
	{
	kError(264) << "Error: standard icon theme" << KIconTheme::defaultThemeName() << "not found!" << endl;
	delete def;
	return false;
	}
	}
	mpThemeRoot = new KIconThemeNode(def);
	mThemesInTree.append(def->internalName());
	links.append(mpThemeRoot);
	addBaseThemes(mpThemeRoot, appname);

	// Insert application specific themes at the top.
	mpDirs->addResourceType("appicon", "data", appname + "/pics/");
	// ################## KDE5: consider removing the toolbar directory
	mpDirs->addResourceType("appicon", "data", appname + "/toolbar/");

	// Add legacy icon dirs.
	QStringList dirs;
	dirs += mpDirs->resourceDirs("icon");
	dirs += mpDirs->resourceDirs("pixmap");
	dirs += mpDirs->resourceDirs("xdgdata-icon");
	dirs += "/usr/share/pixmaps";
	// These are not in the icon spec, but e.g. GNOME puts some icons there anyway.
	dirs += mpDirs->resourceDirs("xdgdata-pixmap");
	for (QStringList::ConstIterator it = dirs.constBegin(); it != dirs.constEnd(); ++it)
	mpDirs->addResourceDir("appicon", *it);

	#ifndef NDEBUG
	QString dbgString = "Theme tree: ";
	mpThemeRoot->printTree(dbgString);
	kDebug(264) << dbgString;
	#endif

	return true;
	}

	KIconLoader::~KIconLoader()
	{
	delete d;
	}

	void KIconLoader::addAppDir(const QString& appname)
	{
	d->initIconThemes();

	d->mpDirs->addResourceType("appicon", "data", appname + "/pics/");
	// ################## KDE5: consider removing the toolbar directory
	d->mpDirs->addResourceType("appicon", "data", appname + "/toolbar/");
	d->addAppThemes(appname);
	}

	void KIconLoaderPrivate::addAppThemes(const QString& appname)
	{
	initIconThemes();

	KIconTheme *def = new KIconTheme(KIconTheme::current(), appname);
	if (!def->isValid()) {
	delete def;
	def = new KIconTheme(KIconTheme::defaultThemeName(), appname);
	}
	KIconThemeNode* node = new KIconThemeNode(def);
	bool addedToLinks = false;

	if (!mThemesInTree.contains(node->theme->internalName())) {
	mThemesInTree.append(node->theme->internalName());
	links.append(node);
	addedToLinks = true;
	}
	addBaseThemes(node, appname);

	if (!addedToLinks) {
	// Nodes in links are being deleted later - this one needs manual care.
	delete node;
	}
	}

	void KIconLoaderPrivate::addBaseThemes(KIconThemeNode *node, const QString &appname)
	{
	// Quote from the icon theme specification:
	// The lookup is done first in the current theme, and then recursively
	// in each of the current theme's parents, and finally in the
	// default theme called "hicolor" (implementations may add more
	// default themes before "hicolor", but "hicolor" must be last).
	//
	// So we first make sure that all inherited themes are added, then we
	// add the KDE default theme as fallback for all icons that might not be
	// present in an inherited theme, and hicolor goes last.

	addInheritedThemes(node, appname);
	addThemeByName(KIconTheme::defaultThemeName(), appname);
	addThemeByName("hicolor", appname);
	}

	void KIconLoaderPrivate::addInheritedThemes(KIconThemeNode *node, const QString &appname)
	{
	const QStringList lst = node->theme->inherits();

	for (QStringList::ConstIterator it = lst.begin(); it != lst.end(); ++it) {
	if ((*it) == "hicolor") {
	// The icon theme spec says that "hicolor" must be the very last
	// of all inherited themes, so don't add it here but at the very end
	// of addBaseThemes().
	continue;
	}
	addThemeByName(*it, appname);
	}
	}

	void KIconLoaderPrivate::addThemeByName(const QString &themename, const QString &appname)
	{
	if (mThemesInTree.contains(themename + appname)) {
	return;
	}
	KIconTheme *theme = new KIconTheme(themename, appname);
	if (!theme->isValid()) {
	delete theme;
	return;
	}
	KIconThemeNode *n = new KIconThemeNode(theme);
	mThemesInTree.append(themename + appname);
	links.append(n);
	addInheritedThemes(n, appname);
	}

	void KIconLoader::addExtraDesktopThemes()
	{
	if ( d->extraDesktopIconsLoaded ) return;

	d->initIconThemes();

	QStringList list;
	const QStringList icnlibs = KGlobal::dirs()->resourceDirs("icon");
	QStringList::ConstIterator it;
	char buf[1000];
	int r;
	for (it=icnlibs.begin(); it!=icnlibs.end(); ++it)
	{
	QDir dir(*it);
	if (!dir.exists())
	continue;
	const QStringList lst = dir.entryList(QStringList( "default.*" ), QDir::Dirs);
	QStringList::ConstIterator it2;
	for (it2=lst.begin(); it2!=lst.end(); ++it2)
	{
	if (!KStandardDirs::exists(it + it2 + "/index.desktop")
	&& !KStandardDirs::exists(it + it2 + "/index.theme"))
	continue;
	r=readlink( QFile::encodeName(it + it2) , buf, sizeof(buf)-1);
	if ( r>0 )
	{
	buf[r]=0;
	const QDir dir2( buf );
	QString themeName=dir2.dirName();

	if (!list.contains(themeName))
	list.append(themeName);
	}
	}
	}

	for (it = list.constBegin(); it != list.constEnd(); ++it)
	{
	// Don't add the KDE defaults once more, we have them anyways.
	if (*it == QLatin1String("default.kde")
	\|\| *it == QLatin1String("default.kde4")) {
	continue;
	}
	d->addThemeByName(*it, "");
	}

	d->extraDesktopIconsLoaded=true;

	}

	bool KIconLoader::extraDesktopThemesAdded() const
	{
	return d->extraDesktopIconsLoaded;
	}

	void KIconLoader::drawOverlays(const QStringList &overlays, QPixmap &pixmap, KIconLoader::Group group, int state) const
	{
	d->drawOverlays(this, group, state, pixmap, overlays);
	}

	QString KIconLoaderPrivate::removeIconExtension(const QString &name) const
	{
	if (name.endsWith(QLatin1String(".png"))
	\|\| name.endsWith(QLatin1String(".xpm"))
	\|\| name.endsWith(QLatin1String(".svg"))) {
	return name.left(name.length() - 4);
	} else if (name.endsWith(QLatin1String(".svgz"))) {
	return name.left(name.length() - 5);
	}

	return name;
	}

	void KIconLoaderPrivate::normalizeIconMetadata(KIconLoader::Group &group, int &size, int &state) const
	{
	if ((state < 0) \|\| (state >= KIconLoader::LastState))
	{
	kWarning(264) << "Illegal icon state: " << state;
	state = KIconLoader::DefaultState;
	}

	if (size < 0) {
	size = 0;
	}

	// For "User" icons, bail early since the size should be based on the size on disk,
	// which we've already checked.
	if (group == KIconLoader::User) {
	return;
	}

	if ((group < -1) \|\| (group >= KIconLoader::LastGroup))
	{
	kWarning(264) << "Illegal icon group: " << group;
	group = KIconLoader::Desktop;
	}

	// If size == 0, use default size for the specified group.
	if (size == 0)
	{
	if (group < 0)
	{
	kWarning(264) << "Neither size nor group specified!";
	group = KIconLoader::Desktop;
	}
	size = mpGroups[group].size;
	}
	}

	QString KIconLoaderPrivate::makeCacheKey(const QString &name, KIconLoader::Group group,
	const QStringList &overlays, int size, int state) const
	{
	// The KSharedDataCache is shared so add some namespacing. The following code
	// uses QStringBuilder (new in Qt 4.6)

	return (group == KIconLoader::User
	? QLatin1Literal("$kicou_")
	: QLatin1Literal("$kico_"))
	% name
	% QLatin1Char('_')
	% QString::number(size)
	% QLatin1Char('_')
	% overlays.join("_")
	-#ifndef KICONLOADER_WITHOUTEFFECTS
	% ( group >= 0 ? mpEffect.fingerprint(group, state)
	: *NULL_EFFECT_FINGERPRINT);
	-#else
	- % NULL_EFFECT_FINGERPRINT);
	-#endif
	}

	QImage KIconLoaderPrivate::createIconImage(const QString &path, int size)
	{
	// Use the extension as the format. Works for XPM and PNG, but not for SVG. The
	// "VGZ" is the last 3 characters of "SVGZ"
	QString ext = path.right(3).toUpper();
	QImage img;

	if (ext != "SVG" && ext != "VGZ")
	{
	// Not a SVG or SVGZ
	img = QImage(path, ext.toLatin1());

	if (size != 0 && !img.isNull()) {
	img = img.scaled(size, size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
	}
	}
	else
	{
	#ifndef _WIN32_WCE
	QSvgRenderer renderer(path, q);

	if (renderer.isValid()) {
	img = QImage(size, size, QImage::Format_ARGB32_Premultiplied);
	img.fill(0);
	QPainter p(&img);
	renderer.render(&p);
	}
	#endif
	}

	return img;
	}

	void KIconLoaderPrivate::insertCachedPixmapWithPath(
	const QString &key,
	const QPixmap &data,
	const QString &path = QString())
	{
	// Even if the pixmap is null, we add it to the caches so that we record
	// the fact that whatever icon led to us getting a null pixmap doesn't
	// exist.

	QBuffer output;
	output.open(QIODevice::WriteOnly);

	QDataStream outputStream(&output);
	outputStream.setVersion(QDataStream::Qt_4_6);

	outputStream << path;

	// Convert the QPixmap to PNG. This is actually done by Qt's own operator.
	outputStream << data;

	output.close();

	// The byte array contained in the QBuffer is what we want in the cache.
	mIconCache->insert(key, output.buffer());

	// Also insert the object into our process-local cache for even more
	// speed.
	PixmapWithPath *pixmapPath = new PixmapWithPath;
	pixmapPath->pixmap = data;
	pixmapPath->path = path;

	mPixmapCache.insert(key, pixmapPath, data.width() * data.height() + 1);
	}

	bool KIconLoaderPrivate::findCachedPixmapWithPath(const QString &key, QPixmap &data, QString &path)
	{
	// If the pixmap is present in our local process cache, use that since we
	// don't need to decompress and upload it to the X server/graphics card.
	const PixmapWithPath *pixmapPath = mPixmapCache.object(key);
	if (pixmapPath) {
	path = pixmapPath->path;
	data = pixmapPath->pixmap;

	return true;
	}

	// Otherwise try to find it in our shared memory cache since that will
	// be quicker than the disk, especially for SVGs.
	QByteArray result;

	if (!mIconCache->find(key, &result) \|\| result.isEmpty()) {
	return false;
	}

	QBuffer buffer;
	buffer.setBuffer(&result);
	buffer.open(QIODevice::ReadOnly);

	QDataStream inputStream(&buffer);
	inputStream.setVersion(QDataStream::Qt_4_6);

	QString tempPath;
	inputStream >> tempPath;

	if (inputStream.status() == QDataStream::Ok) {
	QPixmap tempPixmap;
	inputStream >> tempPixmap;

	if (inputStream.status() == QDataStream::Ok) {
	data = tempPixmap;
	path = tempPath;

	// Since we're here we didn't have a QPixmap cache entry, add one now.
	PixmapWithPath *newPixmapWithPath = new PixmapWithPath;
	newPixmapWithPath->pixmap = data;
	newPixmapWithPath->path = path;

	mPixmapCache.insert(key, newPixmapWithPath, data.width() * data.height() + 1);

	return true;
	}
	}

	return false;
	}

	K3Icon KIconLoaderPrivate::findMatchingIconWithGenericFallbacks(const QString& name, int size) const
	{
	K3Icon icon = findMatchingIcon(name, size);
	if (icon.isValid())
	return icon;

	const QString genericIcon = s_globalData->genericIconFor(name);
	if (!genericIcon.isEmpty()) {
	icon = findMatchingIcon(genericIcon, size);
	}
	return icon;
	}

	K3Icon KIconLoaderPrivate::findMatchingIcon(const QString& name, int size) const
	{
	const_cast<KIconLoaderPrivate*>(this)->initIconThemes();

	K3Icon icon;

	// The following code has been commented out because the Qt SVG renderer needs
	// to be improved. If you are going to change/remove some code from this part,
	// please contact me before (ereslibre@kde.org), or kde-core-devel@kde.org. (ereslibre)
	#ifdef KDE_QT_SVG_RENDERER_FIXED
	const char * ext1[4] = { ".png", ".svgz", ".svg", ".xpm" };
	const char * ext2[4] = { ".svgz", ".svg", ".png", ".xpm" };
	const char ** ext;

	if (size == KIconLoader::SizeSmall \|\|
	size == KIconLoader::SizeSmallMedium \|\|
	size == KIconLoader::SizeMedium \|\|
	size == KIconLoader::SizeLarge \|\|
	size == KIconLoader::SizeHuge \|\|
	size == KIconLoader::SizeEnormous)
	{
	ext = ext1; // size is standard, give preference to PNG over SVG when searching
	}
	else
	{
	ext = ext2; // size is non-standard, give preference to SVG over PNG when searching
	}

	/* If size parameter is a standard one, that means:

	- KIconLoader::SizeSmall
	- KIconLoader::SizeSmallMedium
	- KIconLoader::SizeMedium
	- KIconLoader::SizeLarge
	- KIconLoader::SizeHuge
	- KIconLoader::SizeEnormous

	To follow the XDG icon theme and icon naming specifications,
	the order in which we look for an icon is:

	png, svgz, svg, xpm exact match
	png, svgz, svg, xpm best match
	less specific fallback in this theme: png, svgz, svg, xpm exact match
	png, svgz, svg, xpm best match
	even less specific fallback in this theme: [same order]
	(...)

	next theme in inheritance tree: png, svgz, svg, xpm exact match
	png, svgz, svg, xpm best match
	less specific fallbacks in this next theme
	(...)

	next theme in inheritance tree: png, svgz, svg, xpm exact match
	png, svgz, svg, xpm best match
	less specific fallbacks in this next theme
	(...)

	and so on.

	If size parameter is a non-standard one, then we give more preference to
	SVG format since drawing SVG's gives better quality and despite being
	slower than resizing a PNG image, the cases where non-standard sizes are
	asked are very rare. For non-standard sizes what we have is:

	svgz, svg, png, xpm exact match
	svgz, svg, png, xpm best match
	less specific fallback in this theme: svgz, svg, png, xpm exact match
	svgz, svg, png, xpm best match
	even less specific fallback in this theme: [same order]
	(...)

	next theme in inheritance tree: svgz, svg, png, xpm exact match
	svgz, svg, png, xpm best match
	less specific fallbacks in this next theme
	(...)

	next theme in inheritance tree: svgz, svg, png, xpm exact match
	svgz, svg, png, xpm best match
	less specific fallbacks in this next theme
	(...)

	and so on.
	*/
	#else
	const char * const ext[4] = { ".png", ".svgz", ".svg", ".xpm" };
	#endif

	bool genericFallback = name.endsWith(QLatin1String("-x-generic"));

	foreach(KIconThemeNode *themeNode, links)
	{
	QString currentName = name;

	while (!currentName.isEmpty())
	{

	//kDebug(264) << "Looking up" << currentName;

	// The following code has been commented out because the Qt SVG renderer needs
	// to be improved. If you are going to change/remove some code from this part,
	// please contact me before (ereslibre@kde.org), or kde-core-devel@kde.org. (ereslibre)
	#ifdef KDE_QT_SVG_RENDERER_FIXED
	for (int i = 0 ; i < 4 ; i++)
	{
	icon = themeNode->theme->iconPath(currentName + ext[i], size, KIconLoader::MatchExact);
	if (icon.isValid())
	return icon;
	}

	for (int i = 0 ; i < 4 ; i++)
	{
	icon = themeNode->theme->iconPath(currentName + ext[i], size, KIconLoader::MatchBest);
	if (icon.isValid())
	return icon;
	}
	#else
	for (int i = 0 ; i < 4 ; i++)
	{
	icon = themeNode->theme->iconPath(currentName + ext[i], size, KIconLoader::MatchExact);
	if (icon.isValid())
	return icon;

	icon = themeNode->theme->iconPath(currentName + ext[i], size, KIconLoader::MatchBest);
	if (icon.isValid())
	return icon;
	}
	#endif
	if (genericFallback)
	// we already tested the base name
	break;

	int rindex = currentName.lastIndexOf('-');
	if (rindex > 1) { // > 1 so that we don't split x-content or x-epoc
	currentName.truncate(rindex);

	if (currentName.endsWith(QLatin1String("-x")))
	currentName.chop(2);
	} else {
	// From update-mime-database.c
	static const QSet<QString> mediaTypes = QSet<QString>()
	<< "text" << "application" << "image" << "audio"
	<< "inode" << "video" << "message" << "model" << "multipart"
	<< "x-content" << "x-epoc";
	// Shared-mime-info spec says:
	// "If [generic-icon] is not specified then the mimetype is used to generate the
	// generic icon by using the top-level media type (e.g. "video" in "video/ogg")
	// and appending "-x-generic" (i.e. "video-x-generic" in the previous example)."
	if (mediaTypes.contains(currentName)) {
	currentName += QLatin1String("-x-generic");
	genericFallback = true;
	} else {
	break;
	}
	}
	}
	}
	return icon;
	}

	inline QString KIconLoaderPrivate::unknownIconPath( int size ) const
	{
	static const QString &str_unknown = KGlobal::staticQString("unknown");

	K3Icon icon = findMatchingIcon(str_unknown, size);
	if (!icon.isValid())
	{
	kDebug(264) << "Warning: could not find \"Unknown\" icon for size = "
	<< size << endl;
	return QString();
	}
	return icon.path;
	}

	// Finds the absolute path to an icon.

	QString KIconLoader::iconPath(const QString& _name, int group_or_size,
	bool canReturnNull) const
	{
	if (!d->initIconThemes()) {
	return QString();
	}

	if (_name.isEmpty() \|\| !pathIsRelative(_name))
	{
	// we have either an absolute path or nothing to work with
	return _name;
	}

	QString name = d->removeIconExtension( _name );

	QString path;
	if (group_or_size == KIconLoader::User)
	{
	static const QString &png_ext = KGlobal::staticQString(".png");
	static const QString &xpm_ext = KGlobal::staticQString(".xpm");
	path = d->mpDirs->findResource("appicon", name + png_ext);

	static const QString &svgz_ext = KGlobal::staticQString(".svgz");
	static const QString &svg_ext = KGlobal::staticQString(".svg");
	if (path.isEmpty())
	path = d->mpDirs->findResource("appicon", name + svgz_ext);
	if (path.isEmpty())
	path = d->mpDirs->findResource("appicon", name + svg_ext);
	if (path.isEmpty())
	path = d->mpDirs->findResource("appicon", name + xpm_ext);
	return path;
	}

	if (group_or_size >= KIconLoader::LastGroup)
	{
	kDebug(264) << "Illegal icon group: " << group_or_size;
	return path;
	}

	int size;
	if (group_or_size >= 0)
	size = d->mpGroups[group_or_size].size;
	else
	size = -group_or_size;

	if (_name.isEmpty()) {
	if (canReturnNull)
	return QString();
	else
	return d->unknownIconPath(size);
	}

	K3Icon icon = d->findMatchingIconWithGenericFallbacks(name, size);

	if (!icon.isValid())
	{
	// Try "User" group too.
	path = iconPath(name, KIconLoader::User, true);
	if (!path.isEmpty() \|\| canReturnNull)
	return path;

	return d->unknownIconPath(size);
	}
	return icon.path;
	}

	QPixmap KIconLoader::loadMimeTypeIcon( const QString& _iconName, KIconLoader::Group group, int size,
	int state, const QStringList& overlays, QString *path_store ) const
	{
	QString iconName = _iconName;
	const int slashindex = iconName.indexOf(QLatin1Char('/'));
	if (slashindex != -1) {
	iconName[slashindex] = QLatin1Char('-');
	}

	if ( !d->extraDesktopIconsLoaded )
	{
	const QPixmap pixmap = loadIcon( iconName, group, size, state, overlays, path_store, true );
	if (!pixmap.isNull() ) {
	return pixmap;
	}
	const_cast<KIconLoader *>(this)->addExtraDesktopThemes();
	}
	const QPixmap pixmap = loadIcon(iconName, group, size, state, overlays, path_store, true);
	if (pixmap.isNull()) {
	// Icon not found, fallback to application/octet-stream
	return loadIcon("application-octet-stream", group, size, state, overlays, path_store, false);
	}
	return pixmap;
	}

	QPixmap KIconLoader::loadIcon(const QString& _name, KIconLoader::Group group, int size,
	int state, const QStringList& overlays,
	QString *path_store, bool canReturnNull) const
	{
	QString name = _name;
	bool favIconOverlay = false;

	if (size < 0 \|\| _name.isEmpty())
	return QPixmap();

	/*
	* This method works in a kind of pipeline, with the following steps:
	* 1. Sanity checks.
	* 2. Convert _name, group, size, etc. to a key name.
	* 3. Check if the key is already cached.
	* 4. If not, initialize the theme and find/load the icon.
	* 4a Apply overlays
	* 4b Re-add to cache.
	*/

	// Special case for absolute path icons.
	if (name.startsWith(QLatin1String("favicons/")))
	{
	favIconOverlay = true;
	name = KStandardDirs::locateLocal("cache", name+".png");
	}

	bool absolutePath = !pathIsRelative(name);
	if (!absolutePath) {
	name = d->removeIconExtension(name);
	}

	// Don't bother looking for an icon with no name.
	if (name.isEmpty()) {
	return QPixmap();
	}

	// May modify group, size, or state. This function puts them into sane
	// states.
	d->normalizeIconMetadata(group, size, state);

	// See if the image is already cached.
	QString key = d->makeCacheKey(name, group, overlays, size, state);
	QPixmap pix;
	bool iconWasUnknown = false;
	K3Icon icon;

	if (d->findCachedPixmapWithPath(key, pix, icon.path)) {
	if (path_store) {
	*path_store = icon.path;
	}

	// We cache the pixmap for the event of trying to find an unknown icon
	// with canReturnNull set to false, but if we can return null then
	// we should do so when necessary.
	if (canReturnNull && icon.path.isEmpty()) {
	return QPixmap();
	}
	return pix;
	}

	// Image is not cached... go find it and apply effects.
	if (!d->initIconThemes()) {
	return QPixmap();
	}

	favIconOverlay = favIconOverlay && size > 22;

	// First we look for non-User icons. If we don't find one we'd search in
	// the User space anyways...
	if (group != KIconLoader::User) {
	// K3Icon seems to hold some needed information.

	if (absolutePath && !favIconOverlay)
	{
	icon.context = KIconLoader::Any;
	icon.type = KIconLoader::Scalable;
	icon.path = name;
	}
	else
	{
	icon = d->findMatchingIconWithGenericFallbacks(favIconOverlay ? QString("text-html") : name, size);
	}
	}

	if (icon.path.isEmpty()) {
	// We do have a "User" icon, or we couldn't find the non-User one.
	icon.path = (absolutePath) ? name :
	iconPath(name, KIconLoader::User, canReturnNull);
	}

	// Still can't find it? Use "unknown" if we can't return null.
	// We keep going in the function so we can ensure this result gets cached.
	if (icon.path.isEmpty() && !canReturnNull) {
	icon.path = d->unknownIconPath(size);
	iconWasUnknown = true;
	}

	QImage img = d->createIconImage(icon.path, size);

	-#ifndef KICONLOADER_WITHOUTEFFECTS
	if (group >= 0)
	{
	img = d->mpEffect.apply(img, group, state);
	}
	-#endif

	if (favIconOverlay)
	{
	QImage favIcon(name, "PNG");
	if (!favIcon.isNull()) // if favIcon not there yet, don't try to blend it
	{
	QPainter p(&img);

	// Align the favicon overlay
	QRect r(favIcon.rect());
	r.moveBottomRight(img.rect().bottomRight());
	r.adjust(-1, -1, -1, -1); // Move off edge

	// Blend favIcon over img.
	p.drawImage(r, favIcon);
	}
	}

	pix = QPixmap::fromImage(img);

	// TODO: If we make a loadIcon that returns the image we can convert
	// drawOverlays to use the image instead of pixmaps as well so we don't
	// have to transfer so much to the graphics card.
	d->drawOverlays(this, group, state, pix, overlays);

	// Don't add the path to our unknown icon to the cache, only cache the
	// actual image.
	if (iconWasUnknown) {
	icon.path.clear();
	}

	d->insertCachedPixmapWithPath(key, pix, icon.path);

	if (path_store) {
	*path_store = icon.path;
	}

	return pix;
	}

	QMovie KIconLoader::loadMovie(const QString& name, KIconLoader::Group group, int size, QObject parent) const
	{
	QString file = moviePath( name, group, size );
	if (file.isEmpty())
	return 0;
	int dirLen = file.lastIndexOf('/');
	QString icon = iconPath(name, size ? -size : group, true);
	if (!icon.isEmpty() && file.left(dirLen) != icon.left(dirLen))
	return 0;
	QMovie *movie = new QMovie(file, QByteArray(), parent);
	if (!movie->isValid())
	{
	delete movie;
	return 0;
	}
	return movie;
	}

	QString KIconLoader::moviePath(const QString& name, KIconLoader::Group group, int size) const
	{
	if (!d->mpGroups) return QString();

	d->initIconThemes();

	if ( (group < -1 \|\| group >= KIconLoader::LastGroup) && group != KIconLoader::User )
	{
	kDebug(264) << "Illegal icon group: " << group;
	group = KIconLoader::Desktop;
	}
	if (size == 0 && group < 0)
	{
	kDebug(264) << "Neither size nor group specified!";
	group = KIconLoader::Desktop;
	}

	QString file = name + ".mng";
	if (group == KIconLoader::User)
	{
	file = d->mpDirs->findResource("appicon", file);
	}
	else
	{
	if (size == 0)
	size = d->mpGroups[group].size;

	K3Icon icon;

	foreach(KIconThemeNode *themeNode, d->links)
	{
	icon = themeNode->theme->iconPath(file, size, KIconLoader::MatchExact);
	if (icon.isValid())
	break;
	}

	if ( !icon.isValid() )
	{
	foreach(KIconThemeNode *themeNode, d->links)
	{
	icon = themeNode->theme->iconPath(file, size, KIconLoader::MatchBest);
	if (icon.isValid())
	break;
	}
	}

	file = icon.isValid() ? icon.path : QString();
	}
	return file;
	}


	QStringList KIconLoader::loadAnimated(const QString& name, KIconLoader::Group group, int size) const
	{
	QStringList lst;

	if (!d->mpGroups) return lst;

	d->initIconThemes();

	if ((group < -1) \|\| (group >= KIconLoader::LastGroup))
	{
	kDebug(264) << "Illegal icon group: " << group;
	group = KIconLoader::Desktop;
	}
	if ((size == 0) && (group < 0))
	{
	kDebug(264) << "Neither size nor group specified!";
	group = KIconLoader::Desktop;
	}

	QString file = name + "/0001";
	if (group == KIconLoader::User)
	{
	file = d->mpDirs->findResource("appicon", file + ".png");
	} else
	{
	if (size == 0)
	size = d->mpGroups[group].size;
	K3Icon icon = d->findMatchingIcon(file, size);
	file = icon.isValid() ? icon.path : QString();

	}
	if (file.isEmpty())
	return lst;

	QString path = file.left(file.length()-8);
	DIR* dp = opendir( QFile::encodeName(path) );
	if(!dp)
	return lst;

	KDE_struct_dirent* ep;
	while( ( ep = KDE_readdir( dp ) ) != 0L )
	{
	QString fn(QFile::decodeName(ep->d_name));
	if(!(fn.left(4)).toUInt())
	continue;

	lst += path + fn;
	}
	closedir ( dp );
	lst.sort();
	return lst;
	}

	KIconTheme *KIconLoader::theme() const
	{
	d->initIconThemes();
	if (d->mpThemeRoot) return d->mpThemeRoot->theme;
	return 0L;
	}

	int KIconLoader::currentSize(KIconLoader::Group group) const
	{
	if (!d->mpGroups) return -1;

	if (group < 0 \|\| group >= KIconLoader::LastGroup)
	{
	kDebug(264) << "Illegal icon group: " << group;
	return -1;
	}
	return d->mpGroups[group].size;
	}

	QStringList KIconLoader::queryIconsByDir( const QString& iconsDir ) const
	{
	const QDir dir(iconsDir);
	const QStringList formats = QStringList() << ".png" << ".xpm" << ".svg" << ".svgz";
	const QStringList lst = dir.entryList(formats, QDir::Files);
	QStringList result;
	QStringList::ConstIterator it;
	for (it=lst.begin(); it!=lst.end(); ++it)
	result += iconsDir + '/' + *it;
	return result;
	}

	QStringList KIconLoader::queryIconsByContext(int group_or_size,
	KIconLoader::Context context) const
	{
	d->initIconThemes();

	QStringList result;
	if (group_or_size >= KIconLoader::LastGroup)
	{
	kDebug(264) << "Illegal icon group: " << group_or_size;
	return result;
	}
	int size;
	if (group_or_size >= 0)
	size = d->mpGroups[group_or_size].size;
	else
	size = -group_or_size;

	foreach(KIconThemeNode *themeNode, d->links)
	themeNode->queryIconsByContext(&result, size, context);

	// Eliminate duplicate entries (same icon in different directories)
	QString name;
	QStringList res2, entries;
	QStringList::ConstIterator it;
	for (it=result.constBegin(); it!=result.constEnd(); ++it)
	{
	int n = (*it).lastIndexOf('/');
	if (n == -1)
	name = *it;
	else
	name = (*it).mid(n+1);
	name = d->removeIconExtension(name);
	if (!entries.contains(name))
	{
	entries += name;
	res2 += *it;
	}
	}
	return res2;

	}

	QStringList KIconLoader::queryIcons(int group_or_size, KIconLoader::Context context) const
	{
	d->initIconThemes();

	QStringList result;
	if (group_or_size >= KIconLoader::LastGroup)
	{
	kDebug(264) << "Illegal icon group: " << group_or_size;
	return result;
	}
	int size;
	if (group_or_size >= 0)
	size = d->mpGroups[group_or_size].size;
	else
	size = -group_or_size;

	foreach(KIconThemeNode *themeNode, d->links)
	themeNode->queryIcons(&result, size, context);

	// Eliminate duplicate entries (same icon in different directories)
	QString name;
	QStringList res2, entries;
	QStringList::ConstIterator it;
	for (it=result.constBegin(); it!=result.constEnd(); ++it)
	{
	int n = (*it).lastIndexOf('/');
	if (n == -1)
	name = *it;
	else
	name = (*it).mid(n+1);
	name = d->removeIconExtension(name);
	if (!entries.contains(name))
	{
	entries += name;
	res2 += *it;
	}
	}
	return res2;
	}

	// used by KIconDialog to find out which contexts to offer in a combobox
	bool KIconLoader::hasContext(KIconLoader::Context context) const
	{
	d->initIconThemes();

	foreach(KIconThemeNode *themeNode, d->links)
	if( themeNode->theme->hasContext( context ))
	return true;
	return false;
	}

	-#ifndef KICONLOADER_WITHOUTEFFECTS
	KIconEffect * KIconLoader::iconEffect() const
	{
	return &d->mpEffect;
	}
	-#endif

	bool KIconLoader::alphaBlending(KIconLoader::Group group) const
	{
	if (!d->mpGroups) return false;

	if (group < 0 \|\| group >= KIconLoader::LastGroup)
	{
	kDebug(264) << "Illegal icon group: " << group;
	return false;
	}
	return d->mpGroups[group].alphaBlending;
	}

	// deprecated
	#ifndef KDE_NO_DEPRECATED
	QIcon KIconLoader::loadIconSet( const QString& name, KIconLoader::Group g, int s,
	bool canReturnNull )
	{
	QIcon iconset;
	QPixmap tmp = loadIcon(name, g, s, KIconLoader::ActiveState, QStringList(), NULL, canReturnNull);
	iconset.addPixmap( tmp, QIcon::Active, QIcon::On );
	// we don't use QIconSet's resizing anyway
	tmp = loadIcon(name, g, s, KIconLoader::DisabledState, QStringList(), NULL, canReturnNull);
	iconset.addPixmap( tmp, QIcon::Disabled, QIcon::On );
	tmp = loadIcon(name, g, s, KIconLoader::DefaultState, QStringList(), NULL, canReturnNull);
	iconset.addPixmap( tmp, QIcon::Normal, QIcon::On );
	return iconset;
	}
	#endif

	// Easy access functions

	QPixmap DesktopIcon(const QString& name, int force_size, int state, const QStringList &overlays)
	{
	KIconLoader *loader = KIconLoader::global();
	return loader->loadIcon(name, KIconLoader::Desktop, force_size, state, overlays);
	}

	// deprecated
	#ifndef KDE_NO_DEPRECATED
	QIcon DesktopIconSet(const QString& name, int force_size)
	{
	KIconLoader *loader = KIconLoader::global();
	return loader->loadIconSet(name, KIconLoader::Desktop, force_size);
	}
	#endif

	QPixmap BarIcon(const QString& name, int force_size, int state, const QStringList &overlays)
	{
	KIconLoader *loader = KIconLoader::global();
	return loader->loadIcon(name, KIconLoader::Toolbar, force_size, state, overlays);
	}

	// deprecated
	#ifndef KDE_NO_DEPRECATED
	QIcon BarIconSet(const QString& name, int force_size)
	{
	KIconLoader *loader = KIconLoader::global();
	return loader->loadIconSet( name, KIconLoader::Toolbar, force_size );
	}
	#endif

	QPixmap SmallIcon(const QString& name, int force_size, int state, const QStringList &overlays)
	{
	KIconLoader *loader = KIconLoader::global();
	return loader->loadIcon(name, KIconLoader::Small, force_size, state, overlays);
	}

	// deprecated
	#ifndef KDE_NO_DEPRECATED
	QIcon SmallIconSet(const QString& name, int force_size)
	{
	KIconLoader *loader = KIconLoader::global();
	return loader->loadIconSet( name, KIconLoader::Small, force_size );
	}
	#endif

	QPixmap MainBarIcon(const QString& name, int force_size, int state, const QStringList &overlays)
	{
	KIconLoader *loader = KIconLoader::global();
	return loader->loadIcon(name, KIconLoader::MainToolbar, force_size, state, overlays);
	}

	// deprecated
	#ifndef KDE_NO_DEPRECATED
	QIcon MainBarIconSet(const QString& name, int force_size)
	{
	KIconLoader *loader = KIconLoader::global();
	return loader->loadIconSet( name, KIconLoader::MainToolbar, force_size );
	}
	#endif

	QPixmap UserIcon(const QString& name, int state, const QStringList &overlays)
	{
	KIconLoader *loader = KIconLoader::global();
	return loader->loadIcon(name, KIconLoader::User, 0, state, overlays);
	}

	// deprecated
	#ifndef KDE_NO_DEPRECATED
	QIcon UserIconSet(const QString& name)
	{
	KIconLoader *loader = KIconLoader::global();
	return loader->loadIconSet( name, KIconLoader::User );
	}
	#endif

	int IconSize(KIconLoader::Group group)
	{
	KIconLoader *loader = KIconLoader::global();
	return loader->currentSize(group);
	}

	QPixmap KIconLoader::unknown()
	{
	QPixmap pix;
	if ( QPixmapCache::find("unknown", pix) ) //krazy:exclude=iconnames
	return pix;

	QString path = global()->iconPath("unknown", KIconLoader::Small, true); //krazy:exclude=iconnames
	if (path.isEmpty())
	{
	kDebug(264) << "Warning: Cannot find \"unknown\" icon.";
	pix = QPixmap(32,32);
	} else
	{
	pix.load(path);
	QPixmapCache::insert("unknown", pix); //krazy:exclude=iconnames
	}

	return pix;
	}

	/* the global icon loader */
	K_GLOBAL_STATIC_WITH_ARGS(KIconLoader, globalIconLoader, (KGlobal::mainComponent(), 0))

	KIconLoader *KIconLoader::global()
	{
	return globalIconLoader;
	}

	void KIconLoader::newIconLoader()
	{
	if ( global() == this) {
	KIconTheme::reconfigure();
	}

	reconfigure( objectName(), d->mpDirs );
	emit iconLoaderSettingsChanged();
	}

	#include "kiconloader.moc"

	diff --git a/kdeui/icons/kiconloader.h b/kdeui/icons/kiconloader.h
	index 547c9beddb..6a9d1af239 100644
	--- a/kdeui/icons/kiconloader.h
	+++ b/kdeui/icons/kiconloader.h
	@@ -1,568 +1,566 @@
	/* vi: ts=8 sts=4 sw=4
	*
	* This file is part of the KDE project, module kdecore.
	* Copyright (C) 2000 Geert Jansen <jansen@kde.org>
	* Antonio Larrosa <larrosa@kde.org>
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Library General Public
	* License version 2 as published by the Free Software Foundation.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Library General Public License for more details.
	*
	* You should have received a copy of the GNU Library General Public License
	* along with this library; see the file COPYING.LIB. If not, write to
	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	* Boston, MA 02110-1301, USA.
	*/

	#ifndef KICONLOADER_H
	#define KICONLOADER_H

	#include <QtCore/QString>
	#include <QtCore/QStringList>
	#include <QtCore/QObject>

	#include <kglobal.h>
	#include <kdeui_export.h>

	class QIcon;
	class QMovie;
	class QPixmap;

	class KComponentData;
	class KIconLoaderPrivate;
	class KStandardDirs;
	class KIconEffect;
	class KIconTheme;

	/**
	* Iconloader for KDE.
	*
	* KIconLoader will load the current icon theme and all its base themes.
	* Icons will be searched in any of these themes. Additionally, it caches
	* icons and applies effects according to the user's preferences.
	*
	* In KDE, it is encouraged to load icons by "Group". An icon group is a
	* location on the screen where icons are being used. Standard groups are:
	* Desktop, Toolbar, MainToolbar, Small and Panel. Each group has some
	* centrally configured properties bound to it, including the icon size
	* and effects. This makes it possible to offer a consistent icon look in
	* all KDE applications.
	*
	* The standard groups are defined below.
	*
	* @li KIconLoader::Desktop: Icons in the iconview of konqueror, kdesktop and similar apps.
	* @li KIconLoader::Toolbar: Icons in toolbars.
	* @li KIconLoader::MainToolbar: Icons in the main toolbars.
	* @li KIconLoader::Small: Various small (typical 16x16) places: titlebars, listviews
	* and menu entries.
	* @li KIconLoader::Panel: Icons in kicker's panel
	*
	* The icons are stored on disk in an icon theme or in a standalone
	* directory. The icon theme directories contain multiple sizes and/or
	* depths for the same icon. The iconloader will load the correct one based
	* on the icon group and the current theme. Icon themes are stored globally
	* in share/icons, or, application specific in share/apps/$appdir/icons.
	*
	* The standalone directories contain just one version of an icon. The
	* directories that are searched are: $appdir/pics and $appdir/toolbar.
	* Icons in these directories can be loaded by using the special group
	* "User".
	*
	*/
	class KDEUI_EXPORT KIconLoader : public QObject
	{
	Q_OBJECT
	Q_ENUMS(Context)
	Q_ENUMS(Type)
	Q_ENUMS(MatchType)
	Q_ENUMS(Group)
	Q_ENUMS(StdSizes)
	Q_ENUMS(States)

	public:
	/**
	* Defines the context of the icon.
	*/
	enum Context {
	Any, ///< Some icon with unknown purpose.
	Action, ///< An action icon (e.g. 'save', 'print').
	Application, ///< An icon that represents an application.
	Device, ///< An icon that represents a device.
	FileSystem, ///< An icon that represents a file system. @deprecated Use Place instead.
	MimeType, ///< An icon that represents a mime type (or file type).
	Animation, ///< An icon that is animated.
	Category, ///< An icon that represents a category.
	Emblem, ///< An icon that adds information to an existing icon.
	Emote, ///< An icon that expresses an emotion.
	International, ///< An icon that represents a country's flag.
	Place, ///< An icon that represents a location (e.g. 'home', 'trash').
	StatusIcon ///< An icon that represents an event.
	};

	/**
	* The type of the icon.
	*/
	enum Type {
	Fixed, ///< Fixed-size icon.
	Scalable, ///< Scalable-size icon.
	Threshold ///< A threshold icon.
	};

	/**
	* The type of a match.
	*/
	enum MatchType {
	MatchExact, ///< Only try to find an exact match.
	MatchBest ///< Take the best match if there is no exact match.
	};

	/**
	* The group of the icon.
	*/
	enum Group {
	/// No group
	NoGroup=-1,
	/// Desktop icons
	Desktop=0,
	/// First group
	FirstGroup=0,
	/// Toolbar icons
	Toolbar,
	/// Main toolbar icons
	MainToolbar,
	/// Small icons, e.g. for buttons
	Small,
	/// Panel (Plasma Taskbar) icons
	Panel,
	/// Icons for use in dialog titles, page lists, etc
	Dialog,
	/// Last group
	LastGroup,
	/// User icons
	User
	};

	/**
	* These are the standard sizes for icons.
	*/
	enum StdSizes {
	/// small icons for menu entries
	SizeSmall=16,
	/// slightly larger small icons for toolbars, panels, etc
	SizeSmallMedium=22,
	/// medium sized icons for the desktop
	SizeMedium=32,
	/// large sized icons for the panel
	SizeLarge=48,
	/// huge sized icons for iconviews
	SizeHuge=64,
	/// enormous sized icons for iconviews
	SizeEnormous=128
	};

	/**
	* Defines the possible states of an icon.
	*/
	enum States {
	DefaultState, ///< The default state.
	ActiveState, ///< Icon is active.
	DisabledState, ///< Icon is disabled.
	LastState ///< Last state (last constant)
	};

	/**
	* Constructs an iconloader.
	* @param appname Add the data directories of this application to the
	* icon search path for the "User" group. The default argument adds the
	* directories of the current application.
	* @param dirs the KStandardDirs object to use. If null the global one is used
	*
	* Usually, you use the default iconloader, which can be accessed via
	* KIconLoader::global(), so you hardly ever have to create an
	* iconloader object yourself. That one is the current KComponentData's
	* (typically KApplication's) iconloader.
	*/
	explicit KIconLoader(const QString& appname=QString(), KStandardDirs dirs = 0, QObject parent = 0);

	/**
	* Constructs an iconloader.
	* @param componentData the KComponentData to use to create this icon loader.
	*
	* Usually, you use the default iconloader, which can be accessed via
	* KIconLoader::global(), so you hardly ever have to create an
	* iconloader object yourself. That one is the current KComponentData's
	* (typically KApplication's) iconloader.
	*/
	explicit KIconLoader(const KComponentData &componentData, QObject* parent = 0);

	/**
	* Cleanup
	*/
	~KIconLoader();

	/**
	* Returns the global icon loader initialized with the global KComponentData.
	* @return global icon loader
	*/
	static KIconLoader* global();

	/**
	* Adds @p appname to the list of application specific directories.
	* @param appname The application name.
	*/
	void addAppDir(const QString& appname);

	/**
	* Loads an icon. It will try very hard to find an icon which is
	* suitable. If no exact match is found, a close match is searched.
	* If neither an exact nor a close match is found, a null pixmap or
	* the "unknown" pixmap is returned, depending on the value of the
	* @p canReturnNull parameter.
	*
	* @param name The name of the icon, without extension.
	* @param group The icon group. This will specify the size of and effects to
	* be applied to the icon.
	* @param size If nonzero, this overrides the size specified by @p group.
	* See KIconLoader::StdSizes.
	* @param state The icon state: @p DefaultState, @p ActiveState or
	* @p DisabledState. Depending on the user's preferences, the iconloader
	* may apply a visual effect to hint about its state.
	* @param overlays a list of emblem icons to overlay, by name. the emblem
	* prefix is applied automatically to each name, e.g.
	* "zip" becomes "emblem-zip"
	* @param path_store If not null, the path of the icon is stored here,
	* if the icon was found. If the icon was not found @p path_store
	* is unaltered even if the "unknown" pixmap was returned.
	* @param canReturnNull Can return a null pixmap? If false, the
	* "unknown" pixmap is returned when no appropriate icon has been
	* found. <em>Note:</em> a null pixmap can still be returned in the
	* event of invalid parameters, such as empty names, negative sizes,
	* and etc.
	* @return the QPixmap. Can be null when not found, depending on
	* @p canReturnNull.
	*/
	QPixmap loadIcon(const QString& name, KIconLoader::Group group, int size=0,
	int state=KIconLoader::DefaultState, const QStringList &overlays = QStringList(),
	QString *path_store=0L,
	bool canReturnNull=false) const;

	/**
	* Loads an icon for a mimetype.
	* This is basically like loadIcon except that extra desktop themes are loaded if necessary.
	*
	* @param iconName The name of the icon, without extension, usually from KMimeType.
	* @param group The icon group. This will specify the size of and effects to
	* be applied to the icon.
	* @param size If nonzero, this overrides the size specified by @p group.
	* See KIconLoader::StdSizes.
	* @param state The icon state: @p DefaultState, @p ActiveState or
	* @p DisabledState. Depending on the user's preferences, the iconloader
	* may apply a visual effect to hint about its state.
	* @param path_store If not null, the path of the icon is stored here.
	* @param overlays a list of emblem icons to overlay, by name. the emblem
	* prefix is applied automatically to each name, e.g.
	* "zip" becomes "emblem-zip"
	* @return the QPixmap. Can not be null, the
	* "unknown" pixmap is returned when no appropriate icon has been found.
	*/
	QPixmap loadMimeTypeIcon( const QString& iconName, KIconLoader::Group group, int size=0,
	int state=KIconLoader::DefaultState, const QStringList &overlays = QStringList(),
	QString *path_store=0 ) const;

	/**
	* Creates an icon set, that will do on-demand loading of the icon.
	* Loading itself is done by calling loadIcon .
	*
	* @param name The name of the icon, without extension.
	* @param group The icon group. This will specify the size of and effects to
	* be applied to the icon.
	* @param size If nonzero, this overrides the size specified by @p group.
	* See KIconLoader::StdSizes.
	* @param canReturnNull Can return a null iconset? If false, iconset
	* containing the "unknown" pixmap is returned when no appropriate icon has
	* been found.
	* @return the icon set. Can be null when not found, depending on
	* @p canReturnNull.
	*
	* @deprecated use KIcon instead, which uses the iconloader internally
	*/
	#ifndef KDE_NO_DEPRECATED
	KDE_DEPRECATED QIcon loadIconSet(const QString& name, KIconLoader::Group group, int size = 0,
	bool canReturnNull = false);
	#endif

	/**
	* Returns the path of an icon.
	* @param name The name of the icon, without extension. If an absolute
	* path is supplied for this parameter, iconPath will return it
	* directly.
	* @param group_or_size If positive, search icons whose size is
	* specified by the icon group @p group_or_size. If negative, search
	* icons whose size is - @p group_or_size.
	* See KIconLoader::Group and KIconLoader::StdSizes
	* @param canReturnNull Can return a null string? If not, a path to the
	* "unknown" icon will be returned.
	* @return the path of an icon, can be null or the "unknown" icon when
	* not found, depending on @p canReturnNull.
	*/
	QString iconPath(const QString& name, int group_or_size,
	bool canReturnNull=false) const;

	/**
	* Loads an animated icon.
	* @param name The name of the icon.
	* @param group The icon group. See loadIcon().
	* @param size Override the default size for @p group.
	* See KIconLoader::StdSizes.
	* @param parent The parent object of the returned QMovie.
	* @return A QMovie object. Can be null if not found or not valid.
	* Ownership is passed to the caller.
	*/
	QMovie loadMovie(const QString& name, KIconLoader::Group group, int size=0, QObject parent=0) const;

	/**
	* Returns the path to an animated icon.
	* @param name The name of the icon.
	* @param group The icon group. See loadIcon().
	* @param size Override the default size for @p group.
	* See KIconLoader::StdSizes.
	* @return the full path to the movie, ready to be passed to QMovie's constructor.
	* Empty string if not found.
	*/
	QString moviePath(const QString& name, KIconLoader::Group group, int size=0) const;

	/**
	* Loads an animated icon as a series of still frames. If you want to load
	* a .mng animation as QMovie instead, please use loadMovie() instead.
	* @param name The name of the icon.
	* @param group The icon group. See loadIcon().
	* @param size Override the default size for @p group.
	* See KIconLoader::StdSizes.
	* @return A QStringList containing the absolute path of all the frames
	* making up the animation.
	*/
	QStringList loadAnimated(const QString& name, KIconLoader::Group group, int size=0) const;

	/**
	* Queries all available icons for a specific group, having a specific
	* context.
	* @param group_or_size If positive, search icons whose size is
	* specified by the icon group @p group_or_size. If negative, search
	* icons whose size is - @p group_or_size.
	* See KIconLoader::Group and KIconLoader::StdSizes
	* @param context The icon context.
	* @return a list of all icons
	*/
	QStringList queryIcons(int group_or_size, KIconLoader::Context context=KIconLoader::Any) const;

	/**
	* Queries all available icons for a specific context.
	* @param group_or_size The icon preferred group or size. If available
	* at this group or size, those icons will be returned, in other case,
	* icons of undefined size will be returned. Positive numbers are groups,
	* negative numbers are negated sizes. See KIconLoader::Group and
	* KIconLoader::StdSizes
	* @param context The icon context.
	* @return A QStringList containing the icon names
	* available for that context
	*/
	QStringList queryIconsByContext(int group_or_size,
	KIconLoader::Context context=KIconLoader::Any) const;

	/**
	* @internal
	*/
	bool hasContext( KIconLoader::Context context ) const;

	/**
	* Returns a list of all icons (.png or .xpm extension) in the
	* given directory.
	* @param iconsDir the directory to search in
	* @return A QStringList containing the icon paths
	*/
	QStringList queryIconsByDir( const QString& iconsDir ) const;

	/**
	* Returns the current size of the icon group.
	* Using e.g. KIconLoader::SmallIcon will retrieve the icon size
	* that is currently set from System Settings->Appearance->Icon
	* sizes. SmallIcon for instance, would typically be 16x16, but
	* the user could increase it and this setting would change as well.
	* @param group the group to check.
	* @return the current size for an icon group.
	*/
	int currentSize(KIconLoader::Group group) const;

	/**
	* Returns a pointer to the current theme. Can be used to query
	* available and default sizes for groups.
	* @note The KIconTheme will change if reconfigure() is called and
	* therefore it's not recommended to store the pointer anywhere.
	* @return a pointer to the current theme. 0 if no theme set.
	*/
	KIconTheme *theme() const;

	-#ifndef KICONLOADER_WITHOUTEFFECTS
	/**
	* Returns a pointer to the KIconEffect object used by the icon loader.
	* @return the KIconEffect.
	*/
	KIconEffect *iconEffect() const;
	-#endif;

	/**
	* Called by KComponentData::newIconLoader to reconfigure the icon loader.
	* @param _appname the new application name
	* @param _dirs the new standard directories. If 0, the directories
	* from KGlobal will be taken.
	*/
	void reconfigure( const QString& _appname, KStandardDirs *_dirs );

	/**
	* Returns the unknown icon. An icon that is used when no other icon
	* can be found.
	* @return the unknown pixmap
	*/
	static QPixmap unknown();

	/**
	* Checks whether the user wants to blend the icons with the background
	* using the alpha channel information for a given group.
	* @param group the group to check
	* @return true if alpha blending is desired
	* @obsolete
	*/
	bool alphaBlending( KIconLoader::Group group ) const;

	/**
	* Adds all the default themes from other desktops at the end of
	* the list of icon themes.
	*/
	void addExtraDesktopThemes();

	/**
	* Returns if the default icon themes of other desktops have been added
	* to the list of icon themes where icons are searched.
	*/
	bool extraDesktopThemesAdded() const;

	/**
	* Draws overlays on the specified pixmap, it takes the width and height
	* of the pixmap into consideration
	* @param overlays to draw
	* @param pixmap to draw on
	* @since 4.7
	*/
	void drawOverlays(const QStringList &overlays, QPixmap &pixmap, KIconLoader::Group group, int state = KIconLoader::DefaultState) const;

	public Q_SLOTS:
	/**
	* Re-initialize the global icon loader
	*/
	void newIconLoader();

	Q_SIGNALS:
	/**
	* Emitted by newIconLoader once the new settings have been loaded
	*/
	void iconLoaderSettingsChanged();

	private:
	// @internal the data object
	KIconLoaderPrivate *d;
	};

	/**
	* \relates KIconLoader
	* Load a desktop icon.
	*/
	KDEUI_EXPORT QPixmap DesktopIcon(const QString& name, int size=0,
	int state=KIconLoader::DefaultState, const QStringList& overlays = QStringList());

	/**
	* \relates KIconLoader
	* Load a desktop icon, and apply the necessary effects to get an IconSet.
	* @deprecated use KIcon(name) or KIcon(name,componentData.iconLoader()) instead
	*/
	#ifndef KDE_NO_DEPRECATED
	KDEUI_EXPORT_DEPRECATED QIcon DesktopIconSet(const QString& name, int size=0);
	#endif

	/**
	* \relates KIconLoader
	* Load a toolbar icon.
	*/
	KDEUI_EXPORT QPixmap BarIcon(const QString& name, int size=0, int state=KIconLoader::DefaultState,
	const QStringList& overlays = QStringList());

	/**
	* \relates KIconLoader
	* Load a toolbar icon, and apply the necessary effects to get an IconSet.
	* @deprecated use KIcon(name) or KIcon(name,componentData.iconLoader()) instead
	*/
	#ifndef KDE_NO_DEPRECATED
	KDEUI_EXPORT_DEPRECATED QIcon BarIconSet(const QString& name, int size=0);
	#endif

	/**
	* \relates KIconLoader
	* Load a small icon.
	*/
	KDEUI_EXPORT QPixmap SmallIcon(const QString& name, int size=0,
	int state=KIconLoader::DefaultState, const QStringList &overlays = QStringList());

	/**
	* \relates KIconLoader
	* Load a small icon, and apply the necessary effects to get an IconSet.
	* @deprecated use KIcon(name) or KIcon(name,componentData.iconLoader()) instead
	*/
	#ifndef KDE_NO_DEPRECATED
	KDEUI_EXPORT_DEPRECATED QIcon SmallIconSet(const QString& name, int size=0);
	#endif

	/**
	* \relates KIconLoader
	* Load a main toolbar icon.
	*/
	KDEUI_EXPORT QPixmap MainBarIcon(const QString& name, int size=0,
	int state=KIconLoader::DefaultState, const QStringList &overlays = QStringList());

	/**
	* \relates KIconLoader
	* Load a main toolbar icon, and apply the effects to get an IconSet.
	* @deprecated use KIcon(name) or KIcon(name,componentData.iconLoader()) instead
	*/
	#ifndef KDE_NO_DEPRECATED
	KDEUI_EXPORT_DEPRECATED QIcon MainBarIconSet(const QString& name, int size=0);
	#endif

	/**
	* \relates KIconLoader
	* Load a user icon. User icons are searched in $appdir/pics.
	*/
	KDEUI_EXPORT QPixmap UserIcon(const QString& name, int state=KIconLoader::DefaultState, const QStringList &overlays = QStringList());

	/**
	* \relates KIconLoader
	* Load a user icon, and apply the effects to get an IconSet.
	* @deprecated use KIcon(name) or KIcon(name,componentData.iconLoader()) instead
	*/
	#ifndef KDE_NO_DEPRECATED
	KDEUI_EXPORT_DEPRECATED QIcon UserIconSet(const QString& name);
	#endif

	/**
	* \relates KIconLoader
	* Returns the current icon size for a specific group.
	*/
	KDEUI_EXPORT int IconSize(KIconLoader::Group group);

	inline KIconLoader::Group& operator++(KIconLoader::Group& group) { group = static_cast<KIconLoader::Group>(group+1); return group; }
	inline KIconLoader::Group operator++(KIconLoader::Group& group,int) { KIconLoader::Group ret = group; ++group; return ret; }

	#endif // KICONLOADER_H
	diff --git a/plasma/servicejob.h b/plasma/servicejob.h
	index 6a975c0c76..b55b70e2fe 100644
	--- a/plasma/servicejob.h
	+++ b/plasma/servicejob.h
	@@ -1,139 +1,139 @@
	/*
	* Copyright 2008 Aaron Seigo <aseigo@kde.org>
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU Library General Public License as
	* published by the Free Software Foundation; either version 2, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details
	*
	* You should have received a copy of the GNU Library General Public
	* License along with this program; if not, write to the
	* Free Software Foundation, Inc.,
	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	*/

	#ifndef PLASMA_SERVICEJOB_H
	#define PLASMA_SERVICEJOB_H

	#include <QtCore/QVariant>

	#include <kjob.h>
	#include <kservice.h>

	#include <plasma/plasma_export.h>
	#include "credentials.h"

	namespace Plasma
	{

	class ServiceJobPrivate;

	/**
	* @class ServiceJob plasma/servicejob.h <Plasma/ServiceJob>
	*
	* @short This class provides jobs for use with Plasma::Service
	*
	* Unlike KJob, you can do the work in start(), since Plasma::Service already
	* delays the call to start() until the event loop is reached.
	*
	* If the job is quick enough that it is not worth reporting the progress,
	* you just need to implement start() to do the task, then call emitResult()
	* at the end of it. If the task does not complete successfully, you should
	* set a non-zero error code with setError(int) and an error message with
	* setErrorText(QString).
	*
	* If the job is longer (involving network access, for instance), you should
	* report the progress at regular intervals. See the KJob documentation for
	* information on how to do this.
	*/
	class PLASMA_EXPORT ServiceJob : public KJob
	{
	Q_OBJECT
	Q_PROPERTY(QString destination READ destination)
	Q_PROPERTY(QString operationName READ operationName)
	Q_PROPERTY(QVariant result READ result)


	public:
	/**
	* Default constructor
	*
	* @param destination the subject that the job is acting on
	* @param operation the action that the job is performing on the @p destination
	* @param parameters the parameters of the @p action
	* @param parent the parent object for this service
	*/
	ServiceJob(const QString &destination, const QString &operation,
	const QMap<QString, QVariant> &parameters, QObject *parent = 0);

	/**
	* Destructor
	*/
	~ServiceJob();

	/**
	* @return the subject that the job is acting on
	*/
	QString destination() const;

	/**
	* @return the operation the job is performing on the destination
	*/
	QString operationName() const;

	/**
	* @return the parameters for the operation
	*/
	QMap<QString, QVariant> parameters() const;

	/**
	* @return the identity of the caller of this operation
	*/
	Credentials identity() const;

	/**
	* Returns the result of the operation
	*
	* The result will be invalid if the job has not completed yet, or
	* if the job does not have a meaningful result.
	*
	* Note that this should not be used to find out whether the operation
	* was successful. Instead, you should check the value of error().
	*
	* @return the result of the operation
	*/
	QVariant result() const;

	/**
	* Default implementation of start, which simply sets the results to false.
	* This makes it easy to create a "failure" job.
	*/
	Q_INVOKABLE virtual void start();

	protected:
	/**
	* Sets the result for an operation.
	*/
	void setResult(const QVariant &result);

	private:
	Q_PRIVATE_SLOT(d, void autoStart())
	Q_PRIVATE_SLOT(d, void preventAutoStart())

	ServiceJobPrivate * const d;

	friend class ServiceProvider;
	friend class RemoteServiceJob;
	};

	} // namespace Plasma
	-using namespace Plasma;
	-Q_DECLARE_METATYPE(ServiceJob *)
	+
	+Q_DECLARE_METATYPE(Plasma::ServiceJob *)

	#endif // multiple inclusion guard

File Metadata

Mime Type: text/x-diff
Expires: Fri, Nov 1, 9:58 AM (1 d, 19 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 10076253
Default Alt Text: (85 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions