diff --git a/autotests/kiconloader_benchmark.cpp b/autotests/kiconloader_benchmark.cpp index 839364c..3e66cb1 100644 --- a/autotests/kiconloader_benchmark.cpp +++ b/autotests/kiconloader_benchmark.cpp @@ -1,132 +1,132 @@ /* This file is part of the KDE libraries Copyright 2016 Aleix Pol Gonzalez This library 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 of the License, or (at your option) any later version. 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 #include #include #include class KIconLoader_Benchmark : public QObject { Q_OBJECT private Q_SLOTS: void init() { #if 0 // Enable this code to benchmark very first startup. // Starting the application again uses the on-disk cache, so actually benchmarking -with- a cache is more relevant. // Remove icon cache const QString cacheFile = QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation) + "/icon-cache.kcache"; QFile::remove(cacheFile); // Clear SHM cache KIconLoader::global()->reconfigure(QString()); #endif } void benchmarkExistingIcons() { //icon list I get to load kwrite static QStringList icons = { QStringLiteral("accessories-text-editor"), QStringLiteral("bookmarks"), QStringLiteral("dialog-close"), QStringLiteral("edit-cut"), QStringLiteral("edit-paste"), QStringLiteral("edit-copy"), QStringLiteral("document-save"), QStringLiteral("edit-undo"), QStringLiteral("edit-redo"), QStringLiteral("code-context"), QStringLiteral("document-print"), QStringLiteral("document-print-preview"), QStringLiteral("view-refresh"), QStringLiteral("document-save-as"), QStringLiteral("preferences-other"), QStringLiteral("edit-select-all"), QStringLiteral("zoom-in"), QStringLiteral("zoom-out"), QStringLiteral("edit-find"), QStringLiteral("go-down-search"), QStringLiteral("go-up-search"), QStringLiteral("tools-check-spelling"), QStringLiteral("bookmark-new"), QStringLiteral("format-indent-more"), QStringLiteral("format-indent-less"), QStringLiteral("text-plain"), QStringLiteral("go-up"), QStringLiteral("go-down"), QStringLiteral("dialog-ok"), QStringLiteral("dialog-cancel"), QStringLiteral("window-close"), QStringLiteral("document-new"), QStringLiteral("document-open"), QStringLiteral("document-open-recent"), QStringLiteral("window-new"), QStringLiteral("application-exit"), QStringLiteral("show-menu"), QStringLiteral("configure-shortcuts"), QStringLiteral("configure-toolbars"), QStringLiteral("help-contents"), QStringLiteral("help-contextual"), QStringLiteral("tools-report-bug"), QStringLiteral("preferences-desktop-locale"), QStringLiteral("kde") }; QBENCHMARK { - foreach (const QString &iconName, icons) { + for (const QString &iconName : qAsConst(icons)) { const QIcon icon = QIcon::fromTheme(iconName); if(icon.isNull()) QSKIP("missing icons"); QVERIFY(!icon.pixmap(24, 24).isNull()); //QVERIFY(!icon.pixmap(512, 512).isNull()); } } } void benchmarkNonExistingIcon_notCached() { QBENCHMARK { // Remove icon cache const QString cacheFile = QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation) + QStringLiteral("/icon-cache.kcache"); QFile::remove(cacheFile); // Clear SHM cache KIconLoader::global()->reconfigure(QString()); QIcon icon(new KIconEngine(QStringLiteral("invalid-icon-name"), KIconLoader::global())); QVERIFY(icon.isNull()); QVERIFY2(icon.name().isEmpty(), qPrintable(icon.name())); QVERIFY(!icon.pixmap(QSize(16, 16), QIcon::Normal).isNull()); } } void benchmarkNonExistingIcon_cached() { QBENCHMARK { QIcon icon(new KIconEngine(QStringLiteral("invalid-icon-name"), KIconLoader::global())); QVERIFY(icon.isNull()); QVERIFY2(icon.name().isEmpty(), qPrintable(icon.name())); QVERIFY(!icon.pixmap(QSize(16, 16), QIcon::Normal).isNull()); } } }; QTEST_MAIN(KIconLoader_Benchmark) #include "kiconloader_benchmark.moc" diff --git a/autotests/kiconloader_unittest.cpp b/autotests/kiconloader_unittest.cpp index 8dd3409..b9a7ca8 100644 --- a/autotests/kiconloader_unittest.cpp +++ b/autotests/kiconloader_unittest.cpp @@ -1,530 +1,530 @@ /* This file is part of the KDE libraries Copyright 2008 David Faure This library 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 of the License, or (at your option) any later version. 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 #include #include #include #include #include #include #include #include extern KICONTHEMES_EXPORT void uintToHex(uint32_t colorData, QChar *buffer); class KIconLoader_UnitTest : public QObject { Q_OBJECT public: KIconLoader_UnitTest() : testSizes({ 12, 22, 32, 42, 82, 132, 243 }) {} private: QDir testDataDir; QDir testIconsDir; QString appName; QDir appDataDir; const QVector testSizes; private Q_SLOTS: void initTestCase() { QStandardPaths::setTestModeEnabled(true); const QStringList genericIconsFiles = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("mime/generic-icons")); QVERIFY(!genericIconsFiles.isEmpty()); // KIconLoader relies on fallbacks to generic icons (e.g. x-office-document), which comes from a shared-mime-info file. Make sure it's installed! KConfigGroup cg(KSharedConfig::openConfig(), "Icons"); cg.writeEntry("Theme", "breeze"); cg.sync(); testDataDir = QDir(QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation)); testIconsDir = QDir(testDataDir.absoluteFilePath(QStringLiteral("icons"))); appName = QStringLiteral("kiconloader_unittest"); appDataDir = QDir(testDataDir.absoluteFilePath(appName)); // we will be recursively deleting these, so a sanity check is in order QVERIFY(testIconsDir.absolutePath().contains(QStringLiteral("qttest"))); QVERIFY(appDataDir.absolutePath().contains(QStringLiteral("qttest"))); testIconsDir.removeRecursively(); appDataDir.removeRecursively(); QVERIFY(appDataDir.mkpath(QStringLiteral("pics"))); QVERIFY(QFile::copy(QStringLiteral(":/app-image.png"), appDataDir.filePath(QStringLiteral("pics/image1.png")))); QVERIFY(QFile::copy(QStringLiteral(":/app-image.png"), appDataDir.filePath(QStringLiteral("pics/image2.png")))); // set up a minimal Oxygen icon theme, in case it is not installed QVERIFY(testIconsDir.mkpath(QStringLiteral("oxygen/22x22/actions"))); QVERIFY(testIconsDir.mkpath(QStringLiteral("oxygen/22x22/animations"))); QVERIFY(testIconsDir.mkpath(QStringLiteral("oxygen/22x22/apps"))); QVERIFY(testIconsDir.mkpath(QStringLiteral("oxygen/22x22/mimetypes"))); QVERIFY(testIconsDir.mkpath(QStringLiteral("oxygen/32x32/apps"))); QVERIFY(QFile::copy(QStringLiteral(":/oxygen.theme"), testIconsDir.filePath(QStringLiteral("oxygen/index.theme")))); QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("oxygen/22x22/apps/kde.png")))); QVERIFY(QFile::copy(QStringLiteral(":/anim-22x22.png"), testIconsDir.filePath(QStringLiteral("oxygen/22x22/animations/process-working.png")))); QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("oxygen/22x22/mimetypes/text-plain.png")))); QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("oxygen/22x22/mimetypes/application-octet-stream.png")))); QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("oxygen/22x22/mimetypes/image-x-generic.png")))); QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("oxygen/22x22/mimetypes/video-x-generic.png")))); QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("oxygen/22x22/mimetypes/x-office-document.png")))); QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("oxygen/22x22/mimetypes/audio-x-generic.png")))); QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("oxygen/22x22/mimetypes/unknown.png")))); QVERIFY(QFile::copy(QStringLiteral(":/test-32x32.png"), testIconsDir.filePath(QStringLiteral("oxygen/32x32/apps/kde.png")))); // set up a minimal Breeze icon theme, fallback to oxygen QVERIFY(testIconsDir.mkpath(QStringLiteral("breeze/22x22/actions"))); QVERIFY(testIconsDir.mkpath(QStringLiteral("breeze/22x22/animations"))); QVERIFY(testIconsDir.mkpath(QStringLiteral("breeze/22x22/apps"))); QVERIFY(testIconsDir.mkpath(QStringLiteral("breeze/22x22/mimetypes"))); QVERIFY(testIconsDir.mkpath(QStringLiteral("breeze/22x22/appsNoContext"))); QVERIFY(testIconsDir.mkpath(QStringLiteral("breeze/22x22/appsNoType"))); QVERIFY(testIconsDir.mkpath(QStringLiteral("breeze/22x22/appsNoContextOrType"))); const QString breezeThemeFile = testIconsDir.filePath(QStringLiteral("breeze/index.theme")); QVERIFY(QFile::copy(QStringLiteral(":/breeze.theme"), breezeThemeFile)); //kde.png is missing, it should fallback to oxygen //QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("breeze/22x22/apps/kde.png")))); QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("breeze/22x22/appsNoContext/iconindirectorywithoutcontext.png")))); QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("breeze/22x22/appsNoType/iconindirectorywithouttype.png")))); QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("breeze/22x22/appsNoContextOrType/iconindirectorywithoutcontextortype.png")))); QVERIFY(QFile::copy(QStringLiteral(":/anim-22x22.png"), testIconsDir.filePath(QStringLiteral("breeze/22x22/animations/process-working.png")))); QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("breeze/22x22/mimetypes/text-plain.png")))); QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("breeze/22x22/mimetypes/application-octet-stream.png")))); QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("breeze/22x22/mimetypes/image-x-generic.png")))); QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("breeze/22x22/mimetypes/video-x-generic.png")))); QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("breeze/22x22/mimetypes/x-office-document.png")))); QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("breeze/22x22/mimetypes/audio-x-generic.png")))); QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), testIconsDir.filePath(QStringLiteral("breeze/22x22/mimetypes/unknown.png")))); QVERIFY(QFile::copy(QStringLiteral(":/coloredsvgicon.svg"), testIconsDir.filePath(QStringLiteral("breeze/22x22/apps/coloredsvgicon.svg")))); QVERIFY(QFile::setPermissions(breezeThemeFile, QFileDevice::ReadOwner|QFileDevice::WriteOwner)); KConfig configFile(breezeThemeFile); KConfigGroup iconThemeGroup = configFile.group("Icon Theme"); QVERIFY(iconThemeGroup.isValid()); QStringList dirs = iconThemeGroup.readEntry("Directories", QStringList()); - Q_FOREACH(int i, testSizes) { + for(int i : testSizes) { const QString relDir = QStringLiteral("%1x%1/emblems").arg(i); const QString dir = testIconsDir.filePath(QStringLiteral("breeze/") + relDir); QVERIFY(QDir().mkpath(dir)); QPixmap img(i, i); img.fill(Qt::red); QVERIFY(img.save(dir + QStringLiteral("/red.png"))); dirs += relDir; KConfigGroup dirGroup = configFile.group(relDir); dirGroup.writeEntry("Size", i); dirGroup.writeEntry("Context", "Emblems"); dirGroup.writeEntry("Type", "Fixed"); } iconThemeGroup.writeEntry("Directories", dirs); QVERIFY(configFile.sync()); } void cleanupTestCase() { if (testIconsDir != QDir()) { testIconsDir.removeRecursively(); } if (appDataDir != QDir()) { appDataDir.removeRecursively(); } } void init() { // Remove icon cache const QString cacheFile = QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation) + QStringLiteral("/icon-cache.kcache"); QFile::remove(cacheFile); // Clear SHM cache KIconLoader::global()->reconfigure(QString()); } void testUnknownIconNotCached() { // This is a test to ensure that "unknown" icons do not pin themselves // in the icon loader. Or in other words, if an "unknown" icon is // returned, but the appropriate icon is subsequently installed // properly, the next request for that icon should return the new icon // instead of the unknown icon. QString actionIconsSubdir = QStringLiteral("oxygen/22x22/actions"); QVERIFY(testIconsDir.mkpath(actionIconsSubdir)); QString actionIconsDir = testIconsDir.filePath(actionIconsSubdir); QString nonExistingIconName = QStringLiteral("fhqwhgads_homsar"); QString newIconPath = actionIconsDir + QLatin1String("/") + nonExistingIconName + QLatin1String(".png"); QFile::remove(newIconPath); KIconLoader iconLoader; // Find a non-existent icon, allowing unknown icon to be returned QPixmap nonExistingIcon = iconLoader.loadIcon( nonExistingIconName, KIconLoader::Toolbar); QCOMPARE(nonExistingIcon.isNull(), false); // Install the existing icon by copying. QVERIFY(QFile::copy(QStringLiteral(":/test-22x22.png"), newIconPath)); // Verify the icon can now be found. QPixmap nowExistingIcon = iconLoader.loadIcon( nonExistingIconName, KIconLoader::Toolbar); QVERIFY(nowExistingIcon.cacheKey() != nonExistingIcon.cacheKey()); QCOMPARE(iconLoader.iconPath(nonExistingIconName, KIconLoader::Toolbar), newIconPath); } void testLoadIconCanReturnNull() { // This is a test for the "canReturnNull" argument of KIconLoader::loadIcon(). // We try to load an icon that doesn't exist, first with canReturnNull=false (the default) // then with canReturnNull=true. KIconLoader iconLoader; // We expect a warning here... This doesn't work though, due to the extended debug //QTest::ignoreMessage(QtWarningMsg, "KIconLoader::loadIcon: No such icon \"this-icon-does-not-exist\""); QPixmap pix = iconLoader.loadIcon(QStringLiteral("this-icon-does-not-exist"), KIconLoader::Desktop, 16); QVERIFY(!pix.isNull()); QCOMPARE(pix.size(), QSize(16, 16)); // Try it again, to see if the cache interfers pix = iconLoader.loadIcon(QStringLiteral("this-icon-does-not-exist"), KIconLoader::Desktop, 16); QVERIFY(!pix.isNull()); QCOMPARE(pix.size(), QSize(16, 16)); // And now set canReturnNull to true pix = iconLoader.loadIcon(QStringLiteral("this-icon-does-not-exist"), KIconLoader::Desktop, 16, KIconLoader::DefaultState, QStringList(), nullptr, true); QVERIFY(pix.isNull()); // Try getting the "unknown" icon again, to see if the above call didn't put a null icon into the cache... pix = iconLoader.loadIcon(QStringLiteral("this-icon-does-not-exist"), KIconLoader::Desktop, 16); QVERIFY(!pix.isNull()); QCOMPARE(pix.size(), QSize(16, 16)); // Another one, to clear "last" cache pix = iconLoader.loadIcon(QStringLiteral("this-icon-does-not-exist-either"), KIconLoader::Desktop, 16); QVERIFY(!pix.isNull()); QCOMPARE(pix.size(), QSize(16, 16)); // Now load the initial one again - do we get the warning again? pix = iconLoader.loadIcon(QStringLiteral("this-icon-does-not-exist"), KIconLoader::Desktop, 16); QVERIFY(!pix.isNull()); QCOMPARE(pix.size(), QSize(16, 16)); pix = iconLoader.loadIcon(QStringLiteral("#crazyname"), KIconLoader::NoGroup, 1600); QVERIFY(!pix.isNull()); QCOMPARE(pix.size(), QSize(1600, 1600)); } void testAppPicsDir() { KIconLoader appIconLoader(appName); QString iconPath = appIconLoader.iconPath(QStringLiteral("image1"), KIconLoader::User); QCOMPARE(iconPath, appDataDir.filePath(QStringLiteral("pics/image1.png"))); QVERIFY(QFile::exists(iconPath)); // Load it again, to use the "last loaded" cache QString iconPath2 = appIconLoader.iconPath(QStringLiteral("image1"), KIconLoader::User); QCOMPARE(iconPath, iconPath2); // Load something else, to clear the "last loaded" cache QString iconPathTextEdit = appIconLoader.iconPath(QStringLiteral("image2"), KIconLoader::User); QCOMPARE(iconPathTextEdit, appDataDir.filePath(QStringLiteral("pics/image2.png"))); QVERIFY(QFile::exists(iconPathTextEdit)); // Now load kdialog again, to use the real kiconcache iconPath2 = appIconLoader.iconPath(QStringLiteral("image1"), KIconLoader::User); QCOMPARE(iconPath, iconPath2); } void testAppPicsDir_KDE_icon() { // #### This test is broken; it passes even if appName is set to foobar, because // QIcon::pixmap returns an unknown icon if it can't find the real icon... KIconLoader appIconLoader(appName); // Now using KDE::icon. Separate test so that KIconLoader isn't fully inited. QIcon icon = KDE::icon(QStringLiteral("image1"), &appIconLoader); { QPixmap pix = icon.pixmap(QSize(22, 22)); QVERIFY(!pix.isNull()); } QCOMPARE(icon.actualSize(QSize(96, 22)), QSize(22, 22)); QCOMPARE(icon.actualSize(QSize(22, 96)), QSize(22, 22)); QCOMPARE(icon.actualSize(QSize(22, 16)), QSize(16, 16)); // Can we ask for a really small size? { QPixmap pix8 = icon.pixmap(QSize(8, 8)); QCOMPARE(pix8.size(), QSize(8, 8)); } } void testLoadMimeTypeIcon_data() { QTest::addColumn("iconName"); QTest::addColumn("expectedFileName"); QTest::newRow("existing icon") << QStringLiteral("text-plain") << QStringLiteral("text-plain.png"); QTest::newRow("octet-stream icon") << QStringLiteral("application-octet-stream") << QStringLiteral("application-octet-stream.png"); QTest::newRow("non-existing icon") << QStringLiteral("foo-bar") << QStringLiteral("application-octet-stream.png"); // Test this again, because now we won't go into the "fast path" of loadMimeTypeIcon anymore. QTest::newRow("existing icon again") << QStringLiteral("text-plain") << QStringLiteral("text-plain.png"); QTest::newRow("generic fallback") << QStringLiteral("image-foo-bar") << QStringLiteral("image-x-generic.png"); QTest::newRow("video generic fallback") << QStringLiteral("video-foo-bar") << QStringLiteral("video-x-generic.png"); QTest::newRow("image-x-generic itself") << QStringLiteral("image-x-generic") << QStringLiteral("image-x-generic.png"); QTest::newRow("x-office-document icon") << QStringLiteral("x-office-document") << QStringLiteral("x-office-document.png"); QTest::newRow("unavailable generic icon") << QStringLiteral("application/x-font-vfont") << QStringLiteral("application-octet-stream.png"); QTest::newRow("#184852") << QStringLiteral("audio/x-tuxguitar") << QStringLiteral("audio-x-generic.png"); QTest::newRow("#178847") << QStringLiteral("image/x-compressed-xcf") << QStringLiteral("image-x-generic.png"); QTest::newRow("mimetype generic icon") << QStringLiteral("application-x-fluid") << QStringLiteral("x-office-document.png"); } void testLoadMimeTypeIcon() { QFETCH(QString, iconName); QFETCH(QString, expectedFileName); KIconLoader iconLoader; QString path; QPixmap pix = iconLoader.loadMimeTypeIcon(iconName, KIconLoader::Desktop, 24, KIconLoader::DefaultState, QStringList(), &path); QVERIFY(!pix.isNull()); QCOMPARE(path.section(QLatin1Char('/'), -1), expectedFileName); // do the same test using a global iconloader, so that // we get into the final return statement, which can only happen // if d->extraDesktopIconsLoaded becomes true first.... QString path2; pix = KIconLoader::global()->loadMimeTypeIcon(iconName, KIconLoader::Desktop, 24, KIconLoader::DefaultState, QStringList(), &path2); QVERIFY(!pix.isNull()); QCOMPARE(path2, path); } void testHasIcon() { // Do everything twice to check code paths that might use a cache QVERIFY(KIconLoader::global()->hasIcon(QStringLiteral("kde"))); QVERIFY(KIconLoader::global()->hasIcon(QStringLiteral("kde"))); KIconLoader iconLoader; QVERIFY(iconLoader.hasIcon(QStringLiteral("kde"))); QVERIFY(KIconLoader::global()->hasIcon(QStringLiteral("process-working"))); QVERIFY(KIconLoader::global()->hasIcon(QStringLiteral("process-working"))); QVERIFY(!KIconLoader::global()->hasIcon(QStringLiteral("no-such-icon-exists"))); QVERIFY(!KIconLoader::global()->hasIcon(QStringLiteral("no-such-icon-exists"))); } void testIconPath() { // Test iconPath with non-existing icon const QString path = KIconLoader::global()->iconPath(QStringLiteral("nope-no-such-icon"), KIconLoader::Desktop, true /*canReturnNull*/); QVERIFY2(path.isEmpty(), qPrintable(path)); const QString unknownPath = KIconLoader::global()->iconPath(QStringLiteral("nope-no-such-icon"), KIconLoader::Desktop, false); QVERIFY(!unknownPath.isEmpty()); QVERIFY(QFile::exists(unknownPath)); } void testPathStore() { QString path; QPixmap pix = KIconLoader::global()->loadIcon(QStringLiteral("kde"), KIconLoader::Desktop, 0, KIconLoader::DefaultState, QStringList(), &path); QVERIFY(!path.isEmpty()); QVERIFY(QFile::exists(path)); QVERIFY2(path.contains(QStringLiteral("32x32")), qPrintable(path)); QCOMPARE(pix.size(), QSize(32, 32)); // Compare with iconPath() QString path2 = KIconLoader::global()->iconPath(QStringLiteral("kde"), KIconLoader::Desktop); QCOMPARE(path2, path); // Now specify a size pix = KIconLoader::global()->loadIcon(QStringLiteral("kde"), KIconLoader::Desktop, 24, KIconLoader::DefaultState, QStringList(), &path); QVERIFY(!path.isEmpty()); QVERIFY(QFile::exists(path)); QVERIFY2(path.contains(QStringLiteral("22x22")), qPrintable(path)); QCOMPARE(pix.size(), QSize(24, 24)); QVERIFY(KIconLoader::global()->hasIcon(QStringLiteral("kde"))); path = QString(); KIconLoader::global()->loadIcon(QStringLiteral("does_not_exist"), KIconLoader::Desktop, 24, KIconLoader::DefaultState, QStringList(), &path, true /* canReturnNull */); QVERIFY2(path.isEmpty(), qPrintable(path)); path = QStringLiteral("some filler to check loadIcon() clears the variable"); KIconLoader::global()->loadIcon(QStringLiteral("does_not_exist"), KIconLoader::Desktop, 24, KIconLoader::DefaultState, QStringList(), &path, true /* canReturnNull */); QVERIFY2(path.isEmpty(), qPrintable(path)); //Test that addAppDir doesn't break loading of icons from the old known paths KIconLoader loader; //only addAppDir loader.addAppDir(QStringLiteral("kiconloader_unittest")); path = QString(); loader.loadIcon(QStringLiteral("kde"), KIconLoader::Desktop, 24, KIconLoader::DefaultState, QStringList(), &path); QVERIFY(!path.isEmpty()); path = QString(); loader.loadIcon(QStringLiteral("image1"), KIconLoader::Desktop, 24, KIconLoader::DefaultState, QStringList(), &path); QVERIFY(!path.isEmpty()); //only reconfigure KIconLoader loader2; path = QString(); loader2.reconfigure(QStringLiteral("kiconloader_unittest")); loader2.loadIcon(QStringLiteral("kde"), KIconLoader::Desktop, 24, KIconLoader::DefaultState, QStringList(), &path); QVERIFY(!path.isEmpty()); loader2.loadIcon(QStringLiteral("image1"), KIconLoader::Desktop, 24, KIconLoader::DefaultState, QStringList(), &path); QVERIFY(!path.isEmpty()); //both addAppDir and reconfigure KIconLoader loader3; path = QString(); loader3.addAppDir(QStringLiteral("kiconloader_unittest")); loader3.reconfigure(QStringLiteral("kiconloader_unittest")); loader3.loadIcon(QStringLiteral("kde"), KIconLoader::Desktop, 24, KIconLoader::DefaultState, QStringList(), &path); QVERIFY(!path.isEmpty()); path = QString(); loader3.loadIcon(QStringLiteral("image1"), KIconLoader::Desktop, 24, KIconLoader::DefaultState, QStringList(), &path); QVERIFY(!path.isEmpty()); } void testPathsNoContextType() { { QString path; KIconLoader::global()->loadIcon(QStringLiteral("iconindirectorywithoutcontext"), KIconLoader::Desktop, 24, KIconLoader::DefaultState, QStringList(), &path); QVERIFY(path.endsWith(QLatin1String("appsNoContext/iconindirectorywithoutcontext.png"))); } { QString path; KIconLoader::global()->loadIcon(QStringLiteral("iconindirectorywithouttype"), KIconLoader::Desktop, 24, KIconLoader::DefaultState, QStringList(), &path); QVERIFY(path.endsWith(QLatin1String("appsNoType/iconindirectorywithouttype.png"))); } { QString path; KIconLoader::global()->loadIcon(QStringLiteral("iconindirectorywithoutcontextortype"), KIconLoader::Desktop, 24, KIconLoader::DefaultState, QStringList(), &path); QVERIFY(path.endsWith(QLatin1String("appsNoContextOrType/iconindirectorywithoutcontextortype.png"))); } } void testLoadIconNoGroupOrSize() // #246016 { QPixmap pix = KIconLoader::global()->loadIcon(QStringLiteral("connected"), KIconLoader::NoGroup); QVERIFY(!pix.isNull()); } void testLoadPixmapSequence() { KPixmapSequence seq = KIconLoader::global()->loadPixmapSequence(QStringLiteral("process-working"), 22); QVERIFY(seq.isValid()); } void testAppropriateSizes() { const KIconLoader iconLoader; const QRegularExpression rx(QStringLiteral("/(\\d+)x\\d+/")); for(int i=1; i= i) { ts = curr; break; } } QVERIFY(ts == foundSize); } } void testColoredSvgIcon() { QPalette pal = qApp->palette(); pal.setColor(QPalette::WindowText, QColor(255, 0, 0)); qApp->setPalette(pal); QImage img = KIconLoader::global()->loadIcon(QStringLiteral("coloredsvgicon"), KIconLoader::NoGroup).toImage(); QVERIFY(!img.isNull()); //Has the image been recolored to red, //that is the color we wrote in kdeglobals as text color? QCOMPARE(img.pixel(0,0), (uint)4294901760); } void testUintToHex() { // HEX (ARGB format without the #): ff6496c8 QColor testColorNoAlpha(100, 150, 200); // The ARGB string in which the composed hex value is stored. QString argbHex(8, Qt::Uninitialized); // Verify the ARGB hex (ff6496c8) uintToHex(testColorNoAlpha.rgba(), argbHex.data()); QCOMPARE(argbHex, QStringLiteral("ff6496c8")); // HEX (ARGB format without the #): 7b6496c8 QColor testColorWithAlpha(100, 150, 200, 123); // Test uintToHex to verify its ARGB output. uintToHex(testColorWithAlpha.rgba(), argbHex.data()); QCOMPARE(argbHex, QStringLiteral("7b6496c8")); } }; QTEST_MAIN(KIconLoader_UnitTest) #include "kiconloader_unittest.moc" diff --git a/src/kicondialog.cpp b/src/kicondialog.cpp index a057242..d859b26 100644 --- a/src/kicondialog.cpp +++ b/src/kicondialog.cpp @@ -1,668 +1,668 @@ /* vi: ts=8 sts=4 sw=4 * * This file is part of the KDE project, module kfile. * Copyright (C) 2000 Geert Jansen * (C) 2000 Kurt Granroth * (C) 1997 Christoph Neerfeld * (C) 2002 Carsten Pfeiffer * * This is free software; it comes under the GNU Library General * Public License, version 2. See the file "COPYING.LIB" for the * exact licensing terms. */ #include "kicondialog.h" #include "kicondialog_p.h" #include #include #ifndef _WIN32_WCE #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include /** * Qt allocates very little horizontal space for the icon name, * even if the gridSize width is large. This delegate allocates * the gridSize width (minus some padding) for the icon and icon name. */ class KIconCanvasDelegate : public QAbstractItemDelegate { Q_OBJECT public: KIconCanvasDelegate(KIconCanvas *parent, QAbstractItemDelegate *defaultDelegate); ~KIconCanvasDelegate() override {} void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override; QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const override; private: KIconCanvas *m_iconCanvas = nullptr; QAbstractItemDelegate *m_defaultDelegate = nullptr; static const int HORIZONTAL_EDGE_PAD = 3; }; KIconCanvasDelegate::KIconCanvasDelegate(KIconCanvas *parent, QAbstractItemDelegate *defaultDelegate) : QAbstractItemDelegate(parent) { m_iconCanvas = parent; m_defaultDelegate = defaultDelegate; } void KIconCanvasDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const { const int GRID_WIDTH = m_iconCanvas->gridSize().width(); QStyleOptionViewItem newOption = option; // Manipulate the width available. newOption.rect.setX((option.rect.x() / GRID_WIDTH) * GRID_WIDTH + HORIZONTAL_EDGE_PAD); newOption.rect.setWidth(GRID_WIDTH - 2 * HORIZONTAL_EDGE_PAD); m_defaultDelegate->paint(painter, newOption, index); } QSize KIconCanvasDelegate::sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const { QSize size = m_defaultDelegate->sizeHint(option, index); const int GRID_WIDTH = m_iconCanvas->gridSize().width(); size.setWidth(GRID_WIDTH - 2 * HORIZONTAL_EDGE_PAD); return size; } /* * KIconCanvas: Iconview for the iconloader dialog. */ KIconCanvas::KIconCanvas(QWidget *parent) : QListWidget(parent), m_loading(false), m_timer(new QTimer(this)), m_delegate(new KIconCanvasDelegate(this, itemDelegate())) { setViewMode(IconMode); setUniformItemSizes(true); setMovement(Static); setIconSize(QSize(60, 60)); connect(m_timer, &QTimer::timeout, this, QOverload<>::of(&KIconCanvas::loadFiles)); connect(this, &QListWidget::currentItemChanged, this, &KIconCanvas::currentListItemChanged); setGridSize(QSize(100, 80)); setItemDelegate(m_delegate); } KIconCanvas::~KIconCanvas() { delete m_timer; delete m_delegate; } void KIconCanvas::loadFiles(const QStringList &files) { clear(); m_files = files; emit startLoading(m_files.count()); m_timer->setSingleShot(true); m_timer->start(10); m_loading = false; } void KIconCanvas::loadFiles() { setResizeMode(QListWidget::Fixed); QApplication::setOverrideCursor(Qt::WaitCursor); // disable updates to not trigger paint events when adding child items, // but force an initial paint so that we do not get garbage repaint(); setUpdatesEnabled(false); // Cache these as we will call them frequently. const int canvasIconWidth = iconSize().width(); const int canvasIconHeight = iconSize().width(); const bool uniformIconSize = uniformItemSizes(); m_loading = true; int i; QStringList::ConstIterator it; uint emitProgress = 10; // so we will emit it once in the beginning QStringList::ConstIterator end(m_files.constEnd()); for (it = m_files.constBegin(), i = 0; it != end; ++it, ++i) { if (emitProgress >= 10) { emit progress(i); emitProgress = 0; } emitProgress++; if (!m_loading) { // user clicked on a button that will load another set of icons break; } QImage img; // Use the extension as the format. Works for XPM and PNG, but not for SVG QString path = *it; QString ext = path.right(3).toUpper(); if (ext != QLatin1String("SVG") && ext != QLatin1String("VGZ")) { img.load(*it); } else { #ifndef _WIN32_WCE // Special stuff for SVG icons img = QImage(canvasIconWidth, canvasIconHeight, QImage::Format_ARGB32_Premultiplied); img.fill(0); QSvgRenderer renderer(*it); if (renderer.isValid()) { QPainter p(&img); renderer.render(&p); } #endif } if (img.isNull()) { continue; } if (img.width() > canvasIconWidth || img.height() > canvasIconHeight) { if (img.width() / (float)canvasIconWidth > img.height() / (float)canvasIconHeight) { int height = (int)(((float)canvasIconWidth / img.width()) * img.height()); img = img.scaled(canvasIconWidth, height, Qt::IgnoreAspectRatio, Qt::SmoothTransformation); } else { int width = (int)(((float)canvasIconHeight / img.height()) * img.width()); img = img.scaled(width, canvasIconHeight, Qt::IgnoreAspectRatio, Qt::SmoothTransformation); } } if (uniformIconSize && (img.width() != canvasIconWidth || img.height() != canvasIconHeight)) { // Image is smaller than desired. Draw onto a transparent QImage of the required dimensions. // (Unpleasant glitches occur if we break the uniformIconSizes() contract). QImage paddedImage = QImage(canvasIconWidth, canvasIconHeight, QImage::Format_ARGB32_Premultiplied); paddedImage.fill(0); QPainter painter(&paddedImage); painter.drawImage((canvasIconWidth - img.width()) / 2, (canvasIconHeight - img.height()) / 2, img); img = paddedImage; } QPixmap pm = QPixmap::fromImage(img); QFileInfo fi(*it); QListWidgetItem *item = new QListWidgetItem(pm, fi.completeBaseName(), this); item->setData(Qt::UserRole, *it); item->setToolTip(fi.completeBaseName()); } // enable updates since we have to draw the whole view now setUpdatesEnabled(true); QApplication::restoreOverrideCursor(); m_loading = false; emit finished(); setResizeMode(QListWidget::Adjust); } QString KIconCanvas::getCurrent() const { if (!currentItem()) { return QString(); } return currentItem()->data(Qt::UserRole).toString(); } void KIconCanvas::stopLoading() { m_loading = false; } void KIconCanvas::currentListItemChanged(QListWidgetItem *item) { emit nameChanged((item != nullptr) ? item->text() : QString()); } // TODO KF6 remove and override KIconDialog::showEvent() class ShowEventFilter : public QObject { public: explicit ShowEventFilter(QObject *parent) : QObject(parent) {} ~ShowEventFilter() override {} private: bool eventFilter(QObject *watched, QEvent *event) override { if (event->type() == QEvent::Show) { KIconDialog *q = static_cast(parent()); q->d->showIcons(); q->d->searchLine->setFocus(); } return QObject::eventFilter(watched, event); } }; /* * KIconDialog: Dialog for selecting icons. Both system and user * specified icons can be chosen. */ KIconDialog::KIconDialog(QWidget *parent) : QDialog(parent), d(new KIconDialogPrivate(this)) { setModal(true); setWindowTitle(i18n("Select Icon")); d->mpLoader = KIconLoader::global(); d->init(); installEventFilter(new ShowEventFilter(this)); } KIconDialog::KIconDialog(KIconLoader *loader, QWidget *parent) : QDialog(parent), d(new KIconDialogPrivate(this)) { setModal(true); setWindowTitle(i18n("Select Icon")); d->mpLoader = loader; d->init(); installEventFilter(new ShowEventFilter(this)); } void KIconDialog::KIconDialogPrivate::init() { mGroupOrSize = KIconLoader::Desktop; mContext = KIconLoader::Any; QVBoxLayout *top = new QVBoxLayout; q->setLayout(top); QGroupBox *bgroup = new QGroupBox(q); bgroup->setTitle(i18n("Icon Source")); QVBoxLayout *vbox = new QVBoxLayout; bgroup->setLayout(vbox); top->addWidget(bgroup); QGridLayout *grid = new QGridLayout(); vbox->addLayout(grid); mpSystemIcons = new QRadioButton(i18n("S&ystem icons:"), bgroup); connect(mpSystemIcons, &QRadioButton::clicked, q, [this]() { handleSystemIconClicked(); }); grid->addWidget(mpSystemIcons, 1, 0); mpCombo = new QComboBox(bgroup); connect(mpCombo, QOverload::of(&QComboBox::activated), q, [this](int id) { handleContext(id); }); grid->addWidget(mpCombo, 1, 1); mpOtherIcons = new QRadioButton(i18n("O&ther icons:"), bgroup); connect(mpOtherIcons, &QRadioButton::clicked, q, [this]() { handleOtherIconClicked(); }); grid->addWidget(mpOtherIcons, 2, 0); mpBrowseBut = new QPushButton(i18n("&Browse..."), bgroup); connect(mpBrowseBut, &QPushButton::clicked, q, [this]() { handleBrowseClicked(); }); grid->addWidget(mpBrowseBut, 2, 1); // // ADD SEARCHLINE // QHBoxLayout *searchLayout = new QHBoxLayout(); searchLayout->setMargin(0); top->addLayout(searchLayout); QLabel *searchLabel = new QLabel(i18n("&Search:"), q); searchLayout->addWidget(searchLabel); searchLine = new KListWidgetSearchLine(q); searchLayout->addWidget(searchLine); searchLabel->setBuddy(searchLine); QString wtstr = i18n("Search interactively for icon names (e.g. folder)."); searchLabel->setWhatsThis(wtstr); searchLine->setWhatsThis(wtstr); mpCanvas = new KIconCanvas(q); connect(mpCanvas, &KIconCanvas::itemActivated, q, [this]() { handleAcceptIcons(); }); top->addWidget(mpCanvas); searchLine->setListWidget(mpCanvas); // Compute width of canvas with 4 icons displayed in a row QStyleOption opt; opt.initFrom(mpCanvas); int width = 4 * mpCanvas->gridSize().width() + 1; width += mpCanvas->verticalScrollBar()->sizeHint().width(); width += 2 * mpCanvas->frameWidth(); if (mpCanvas->style()->styleHint(QStyle::SH_ScrollView_FrameOnlyAroundContents, &opt, mpCanvas)) { width += mpCanvas->style()->pixelMetric(QStyle::PM_ScrollView_ScrollBarSpacing, &opt, mpCanvas); } mpCanvas->setMinimumSize(width, 125); mpProgress = new QProgressBar(q); top->addWidget(mpProgress); connect(mpCanvas, &KIconCanvas::startLoading, q, [this](int steps) { handleStartLoading(steps); }); connect(mpCanvas, &KIconCanvas::progress, q, [this](int p) { handleProgress(p); }); connect(mpCanvas, &KIconCanvas::finished, q, [this]() { handleFinished(); }); // When pressing Ok or Cancel, stop loading icons connect(q, &QDialog::finished, mpCanvas, &KIconCanvas::stopLoading); static const char *const context_text[] = { I18N_NOOP("Actions"), I18N_NOOP("Applications"), I18N_NOOP("Categories"), I18N_NOOP("Devices"), I18N_NOOP("Emblems"), I18N_NOOP("Emotes"), I18N_NOOP("Mimetypes"), I18N_NOOP("Places"), I18N_NOOP("Status"), I18N_NOOP("All") }; static const KIconLoader::Context context_id[] = { KIconLoader::Action, KIconLoader::Application, KIconLoader::Category, KIconLoader::Device, KIconLoader::Emblem, KIconLoader::Emote, KIconLoader::MimeType, KIconLoader::Place, KIconLoader::StatusIcon, KIconLoader::Any }; mNumContext = 0; int cnt = sizeof(context_text) / sizeof(context_text[ 0 ]); // check all 3 arrays have same sizes Q_ASSERT(cnt == sizeof(context_id) / sizeof(context_id[ 0 ]) && cnt == sizeof(mContextMap) / sizeof(mContextMap[ 0 ])); for (int i = 0; i < cnt; ++i) { if (mpLoader->hasContext(context_id[ i ])) { mpCombo->addItem(i18n(context_text[ i ])); mContextMap[ mNumContext++ ] = context_id[ i ]; } } mpCombo->setMaxVisibleItems(cnt); mpCombo->setFixedSize(mpCombo->sizeHint()); mpBrowseBut->setFixedWidth(mpCombo->width()); QDialogButtonBox *buttonBox = new QDialogButtonBox(q); buttonBox->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel); connect(buttonBox, &QDialogButtonBox::accepted, q, &KIconDialog::slotOk); connect(buttonBox, &QDialogButtonBox::rejected, q, &QDialog::reject); top->addWidget(buttonBox); // Make the dialog a little taller q->resize(q->sizeHint() + QSize(0, 100)); q->adjustSize(); } KIconDialog::~KIconDialog() { delete d; } void KIconDialog::KIconDialogPrivate::handleAcceptIcons() { custom.clear(); q->slotOk(); } static bool sortByFileName(const QString &path1, const QString &path2) { const QString fileName1 = path1.mid(path1.lastIndexOf(QLatin1Char('/')) + 1); const QString fileName2 = path2.mid(path2.lastIndexOf(QLatin1Char('/')) + 1); return QString::compare(fileName1, fileName2, Qt::CaseInsensitive) < 0; } void KIconDialog::KIconDialogPrivate::showIcons() { mpCanvas->clear(); QStringList filelist; if (mpSystemIcons->isChecked()) { if (m_bStrictIconSize) { filelist = mpLoader->queryIcons(mGroupOrSize, mContext); } else { filelist = mpLoader->queryIconsByContext(mGroupOrSize, mContext); } } else if (!customLocation.isEmpty()) { filelist = mpLoader->queryIconsByDir(customLocation); } else { // List PNG files found directly in the kiconload search paths. const QStringList pngNameFilter(QStringLiteral("*.png")); Q_FOREACH (const QString &relDir, KIconLoader::global()->searchPaths()) { const QStringList dirs = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, relDir, QStandardPaths::LocateDirectory); for (const QString &dir : dirs) { const auto files = QDir(dir).entryList(pngNameFilter); for (const QString &fileName : files) { filelist << dir + QLatin1Char('/') + fileName; } } } } std::sort(filelist.begin(), filelist.end(), sortByFileName); // The KIconCanvas has uniformItemSizes set which really expects // all added icons to be the same size, otherwise weirdness ensues :) // Ensure all SVGs are scaled to the desired size and that as few icons // need to be padded as possible by specifying a sensible size. if (mGroupOrSize < -1) { // mGroupOrSize can be -1 if NoGroup is chosen. // Explicit size. mpCanvas->setIconSize(QSize(-mGroupOrSize, -mGroupOrSize)); } else { // Icon group. - int groupSize = mpLoader->currentSize((KIconLoader::Group)mGroupOrSize); + int groupSize = mpLoader->currentSize(static_cast(mGroupOrSize)); mpCanvas->setIconSize(QSize(groupSize, groupSize)); } mpCanvas->loadFiles(filelist); } void KIconDialog::setStrictIconSize(bool b) { d->m_bStrictIconSize = b; } bool KIconDialog::strictIconSize() const { return d->m_bStrictIconSize; } void KIconDialog::setIconSize(int size) { // see KIconLoader, if you think this is weird if (size == 0) { d->mGroupOrSize = KIconLoader::Desktop; // default Group } else { d->mGroupOrSize = -size; // yes, KIconLoader::queryIconsByContext is weird } } int KIconDialog::iconSize() const { // 0 or any other value ==> mGroupOrSize is a group, so we return 0 return (d->mGroupOrSize < 0) ? -d->mGroupOrSize : 0; } void KIconDialog::setup(KIconLoader::Group group, KIconLoader::Context context, bool strictIconSize, int iconSize, bool user, bool lockUser, bool lockCustomDir) { d->m_bStrictIconSize = strictIconSize; d->m_bLockUser = lockUser; d->m_bLockCustomDir = lockCustomDir; if (iconSize == 0) { if (group == KIconLoader::NoGroup) { // NoGroup has numeric value -1, which should // not really be used with KIconLoader::queryIcons*(...); // pick a proper group. d->mGroupOrSize = KIconLoader::Small; } else { d->mGroupOrSize = group; } } else { d->mGroupOrSize = -iconSize; } d->mpSystemIcons->setChecked(!user); d->mpSystemIcons->setEnabled(!lockUser || !user); d->mpOtherIcons->setChecked(user); d->mpOtherIcons->setEnabled(!lockUser || user); d->mpCombo->setEnabled(!user); d->mpBrowseBut->setEnabled(user && !lockCustomDir); d->setContext(context); } void KIconDialog::KIconDialogPrivate::setContext(KIconLoader::Context context) { mContext = context; for (int i = 0; i < mNumContext; ++i) { if (mContextMap[ i ] == context) { mpCombo->setCurrentIndex(i); return; } } } void KIconDialog::setCustomLocation(const QString &location) { d->customLocation = location; } QString KIconDialog::openDialog() { if (exec() == Accepted) { if (!d->custom.isEmpty()) { return d->custom; } const QString name = d->mpCanvas->getCurrent(); if (name.isEmpty() || d->mpOtherIcons->isChecked()) { return name; } QFileInfo fi(name); return fi.completeBaseName(); } return QString(); } void KIconDialog::showDialog() { setModal(false); show(); } void KIconDialog::slotOk() { QString name; if (!d->custom.isEmpty()) { name = d->custom; } else { name = d->mpCanvas->getCurrent(); if (!name.isEmpty() && d->mpSystemIcons->isChecked()) { const QFileInfo fi(name); name = fi.completeBaseName(); } } emit newIconName(name); QDialog::accept(); } QString KIconDialog::getIcon(KIconLoader::Group group, KIconLoader::Context context, bool strictIconSize, int iconSize, bool user, QWidget *parent, const QString &caption) { KIconDialog dlg(parent); dlg.setup(group, context, strictIconSize, iconSize, user); if (!caption.isEmpty()) { dlg.setWindowTitle(caption); } return dlg.openDialog(); } void KIconDialog::KIconDialogPrivate::handleBrowseClicked() { if (browseDialog) { browseDialog.data()->show(); browseDialog.data()->raise(); return; } // Create a file dialog to select an ICO, PNG, XPM or SVG file, // with the image previewer shown. QFileDialog *dlg = new QFileDialog(q, i18n("Select Icon"), QString(), i18n("*.ico *.png *.xpm *.svg *.svgz|Icon Files (*.ico *.png *.xpm *.svg *.svgz)")); dlg->setModal(false); dlg->setFileMode(QFileDialog::ExistingFile); connect(dlg, &QFileDialog::fileSelected, q, [this](const QString &path) { handleCustomFileSelected(path); }); browseDialog = dlg; dlg->show(); } void KIconDialog::KIconDialogPrivate::handleCustomFileSelected(const QString &path) { if (!path.isEmpty()) { custom = path; if (mpSystemIcons->isChecked()) { customLocation = QFileInfo(custom).absolutePath(); } q->slotOk(); } } void KIconDialog::KIconDialogPrivate::handleSystemIconClicked() { mpBrowseBut->setEnabled(false); mpCombo->setEnabled(true); showIcons(); } void KIconDialog::KIconDialogPrivate::handleOtherIconClicked() { mpBrowseBut->setEnabled(!m_bLockCustomDir); mpCombo->setEnabled(false); showIcons(); } void KIconDialog::KIconDialogPrivate::handleContext(int id) { mContext = static_cast(mContextMap[ id ]); showIcons(); } void KIconDialog::KIconDialogPrivate::handleStartLoading(int steps) { if (steps < 10) { mpProgress->hide(); } else { mNumOfSteps = steps; mpProgress->setValue(0); mpProgress->show(); } } void KIconDialog::KIconDialogPrivate::handleProgress(int p) { mpProgress->setValue(static_cast(100.0 * (double)p / (double)mNumOfSteps)); } void KIconDialog::KIconDialogPrivate::handleFinished() { mNumOfSteps = 1; mpProgress->hide(); } #include "kicondialog.moc" #include "moc_kicondialog_p.cpp" diff --git a/src/kiconloader.cpp b/src/kiconloader.cpp index e76dd56..9bb0b3a 100644 --- a/src/kiconloader.cpp +++ b/src/kiconloader.cpp @@ -1,1866 +1,1864 @@ /* 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 * Antonio Larrosa * 2010 Michael Pyne * * 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 //for readlink #include #include #include #include #include #include #include #include // % operator for QString #include #include #include #include #include #include #include #include // kdecore #include #include #include #include #include #include #include #include #include // kdeui #include "kicontheme.h" #include "kiconeffect.h" #include "debug.h" //kwidgetsaddons #include #include #include namespace { // Used to make cache keys for icons with no group. Result type is QString* QString NULL_EFFECT_FINGERPRINT() { return QStringLiteral("noeffect"); } QString STYLESHEET_TEMPLATE() { return QStringLiteral(".ColorScheme-Text {\ color:%1;\ }\ .ColorScheme-Background{\ color:%2;\ }\ .ColorScheme-Highlight{\ color:%3;\ }\ .ColorScheme-PositiveText{\ color:%4;\ }\ .ColorScheme-NeutralText{\ color:%5;\ }\ .ColorScheme-NegativeText{\ color:%6;\ }"); } } /** * 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] != QLatin1Char('/')); #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; }; /** * Function to convert an uint32_t to AARRGGBB hex values. * * W A R N I N G ! * This function is for internal use! */ KICONTHEMES_EXPORT void uintToHex(uint32_t colorData, QChar *buffer) { static const char hexLookup[] = "0123456789abcdef"; buffer += 7; uchar *colorFields = reinterpret_cast(&colorData); for (int i = 0; i < 4; i++) { *buffer-- = hexLookup[*colorFields & 0xf]; *buffer-- = hexLookup[*colorFields >> 4]; colorFields++; } } static QString paletteId(const QPalette &pal) { // 8 per color. We want 3 colors thus 8*4=32. QString buffer(32, Qt::Uninitialized); uintToHex(pal.windowText().color().rgba(), buffer.data()); uintToHex(pal.highlight().color().rgba(), buffer.data() + 8); uintToHex(pal.highlightedText().color().rgba(), buffer.data() + 16); uintToHex(pal.window().color().rgba(), buffer.data() + 24); return buffer; } /*** 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; QString findIcon(const QString &name, int size, KIconLoader::MatchType match) const; KIconTheme *theme; }; KIconThemeNode::KIconThemeNode(KIconTheme *_theme) { theme = _theme; } KIconThemeNode::~KIconThemeNode() { delete theme; } 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); } QString 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; }; extern KICONTHEMES_EXPORT int kiconloader_ms_between_checks; KICONTHEMES_EXPORT int kiconloader_ms_between_checks = 5000; /*** d pointer for KIconLoader. ***/ class KIconLoaderPrivate { public: KIconLoaderPrivate(KIconLoader *q) : q(q) - , mpGroups(nullptr) - , mIconCache(nullptr) { } ~KIconLoaderPrivate() { clear(); } void clear() { /* 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; mpGroups = nullptr; mIconCache = nullptr; mPixmapCache.clear(); appname.clear(); searchPaths.clear(); links.clear(); mIconThemeInited = false; mThemesInTree.clear(); } /** * @internal */ void init(const QString &_appname, const QStringList &extraSearchPaths = QStringList()); /** * @internal */ bool initIconThemes(); /** * @internal * tries to find an icon with the name. It tries some extension and * match strategies */ QString findMatchingIcon(const QString &name, int size, qreal scale) 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. */ QString findMatchingIconWithGenericFallbacks(const QString &name, int size, qreal scale) const; /** * @internal * Adds themes installed in the application's directory. **/ void addAppThemes(const QString &appname, const QString &themeBaseDir = QString()); /** * @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); /** * Adds all the default themes from other desktops at the end of * the list of icon themes. */ void addExtraDesktopThemes(); /** * @internal * return the path for the unknown icon in that size */ QString unknownIconPath(int size, qreal scale) 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, qreal scale, int state) const; /** * @internal * If the icon is an SVG file, process it generating a stylesheet * following the current color scheme. in this case the icon can use named colors * as text color, background color, highlight color, positive/neutral/negative color * @see KColorScheme */ QByteArray processSvg(const QString &path, KIconLoader::States 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, qreal scale = 1.0, KIconLoader::States state = KIconLoader::DefaultState); /** * @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); /** * Find the given file in the search paths. */ QString locate(const QString &fileName); /** * @internal * React to a global icon theme change */ void refreshIcons(int group); bool shouldCheckForUnknownIcons() { if (mLastUnknownIconCheck.isValid() && mLastUnknownIconCheck.elapsed() < kiconloader_ms_between_checks) { return false; } mLastUnknownIconCheck.start(); return true; } KIconLoader *const q; QStringList mThemesInTree; - KIconGroup *mpGroups; - KIconThemeNode *mpThemeRoot; + KIconGroup *mpGroups = nullptr; + KIconThemeNode *mpThemeRoot = nullptr; QStringList searchPaths; KIconEffect mpEffect; QList links; // This shares the icons across all processes - KSharedDataCache *mIconCache; + KSharedDataCache *mIconCache = nullptr; // This caches rendered QPixmaps in just this process. QCache 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); QHash mIconAvailability; // icon name -> true (known to be available) or false (known to be unavailable) QElapsedTimer mLastUnknownIconCheck; // recheck for unknown icons after kiconloader_ms_between_checks //the palette used to recolor svg icons stylesheets QPalette mPalette; //to keep track if we are using a custom palette or just falling back to qApp; bool mCustomPalette = false; }; class KIconLoaderGlobalData : public QObject { Q_OBJECT public: KIconLoaderGlobalData() { const QStringList genericIconsFiles = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("mime/generic-icons")); //qCDebug(KICONTHEMES) << genericIconsFiles; for (const QString &file : genericIconsFiles) { parseGenericIconsFiles(file); } QDBusConnection::sessionBus().connect(QString(), QStringLiteral("/KIconLoader"), QStringLiteral("org.kde.KIconLoader"), QStringLiteral("iconChanged"), this, SIGNAL(iconChanged(int))); } void emitChange(KIconLoader::Group group) { QDBusMessage message = QDBusMessage::createSignal(QStringLiteral("/KIconLoader"), QStringLiteral("org.kde.KIconLoader"), QStringLiteral("iconChanged")); message.setArguments(QList() << int(group)); QDBusConnection::sessionBus().send(message); } QString genericIconFor(const QString &icon) const { return m_genericIcons.value(icon); } Q_SIGNALS: void iconChanged(int group); private: void parseGenericIconsFiles(const QString &fileName); QHash 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] == QLatin1Char('#')) { continue; } const int pos = line.indexOf(QLatin1Char(':')); 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); //qCDebug(KICONTHEMES) << mimeIcon << "->" << genericIcon; } } } Q_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) { + for (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? QPixmap pixmap = iconLoader->loadIcon(overlay, group, overlaySize, state, QStringList(), nullptr, true); if (pixmap.isNull()) { continue; } // match the emblem's devicePixelRatio to the original pixmap's pixmap.setDevicePixelRatio(pix.devicePixelRatio()); const int margin = pixmap.devicePixelRatio() * 0.05 * iconSize; QPoint startPoint; switch (count) { case 0: // bottom right corner startPoint = QPoint(width - overlaySize - margin, height - overlaySize - margin); break; case 1: // bottom left corner startPoint = QPoint(margin, height - overlaySize - margin); break; case 2: // top left corner startPoint = QPoint(margin, margin); break; case 3: // top right corner startPoint = QPoint(width - overlaySize - margin, margin); break; } startPoint /= pix.devicePixelRatio(); painter.drawPixmap(startPoint, pixmap); ++count; if (count > 3) { break; } } } void KIconLoaderPrivate::refreshIcons(int group) { KSharedConfig::Ptr sharedConfig = KSharedConfig::openConfig(); sharedConfig->reparseConfiguration(); const QString newThemeName = sharedConfig->group("Icons") .readEntry("Theme", QString()); if (!newThemeName.isEmpty()) { // If we're refreshing icons the Qt platform plugin has probably // already cached the old theme, which will accidentally filter back // into KIconTheme unless we reset it QIcon::setThemeName(newThemeName); } q->newIconLoader(); mIconAvailability.clear(); emit q->iconChanged(group); } KIconLoader::KIconLoader(const QString &_appname, const QStringList &extraSearchPaths, QObject *parent) : QObject(parent) { setObjectName(_appname); d = new KIconLoaderPrivate(this); connect(s_globalData, &KIconLoaderGlobalData::iconChanged, this, [this](int group) { d->refreshIcons(group); }); d->init(_appname, extraSearchPaths); } void KIconLoader::reconfigure(const QString &_appname, const QStringList &extraSearchPaths) { d->mIconCache->clear(); d->clear(); d->init(_appname, extraSearchPaths); } void KIconLoaderPrivate::init(const QString &_appname, const QStringList &extraSearchPaths) { extraDesktopIconsLoaded = false; mIconThemeInited = false; mpThemeRoot = nullptr; searchPaths = extraSearchPaths; appname = _appname; if (appname.isEmpty()) { appname = QCoreApplication::applicationName(); } // Initialize icon cache mIconCache = new KSharedDataCache(QStringLiteral("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 kiconloader.h static const char *const groups[] = { "Desktop", "Toolbar", "MainToolbar", "Small", "Panel", "Dialog", nullptr }; KSharedConfig::Ptr config = KSharedConfig::openConfig(); // loading config and default sizes initIconThemes(); KIconTheme *defaultSizesTheme = links.empty() ? nullptr : links.first()->theme; mpGroups = new KIconGroup[static_cast(KIconLoader::LastGroup)]; for (KIconLoader::Group i = KIconLoader::FirstGroup; i < KIconLoader::LastGroup; ++i) { if (groups[i] == nullptr) { break; } KConfigGroup cg(config, QLatin1String(groups[i]) + QStringLiteral("Icons")); mpGroups[i].size = cg.readEntry("Size", 0); 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 != nullptr); } //qCDebug(KICONTHEMES); 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 qCDebug(KICONTHEMES) << "Couldn't find current icon theme, falling back to default."; def = new KIconTheme(KIconTheme::defaultThemeName(), appname); if (!def->isValid()) { qWarning() << "Error: standard icon theme" << KIconTheme::defaultThemeName() << "not found!"; 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. searchPaths.append(appname + QStringLiteral("/pics")); // Add legacy icon dirs. searchPaths.append(QStringLiteral("icons")); // was xdgdata-icon in KStandardDirs // These are not in the icon spec, but e.g. GNOME puts some icons there anyway. searchPaths.append(QStringLiteral("pixmaps")); // was xdgdata-pixmaps in KStandardDirs return true; } KIconLoader::~KIconLoader() { delete d; } QStringList KIconLoader::searchPaths() const { return d->searchPaths; } void KIconLoader::addAppDir(const QString &appname, const QString &themeBaseDir) { d->initIconThemes(); d->searchPaths.append(appname + QStringLiteral("/pics")); d->addAppThemes(appname, themeBaseDir); } void KIconLoaderPrivate::addAppThemes(const QString &appname, const QString &themeBaseDir) { initIconThemes(); KIconTheme *def = new KIconTheme(QStringLiteral("hicolor"), appname, themeBaseDir); if (!def->isValid()) { delete def; def = new KIconTheme(KIconTheme::defaultThemeName(), appname, themeBaseDir); } KIconThemeNode *node = new KIconThemeNode(def); bool addedToLinks = false; if (!mThemesInTree.contains(appname)) { mThemesInTree.append(appname); 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(QStringLiteral("hicolor"), appname); } void KIconLoaderPrivate::addInheritedThemes(KIconThemeNode *node, const QString &appname) { const QStringList lst = node->theme->inherits(); for (QStringList::ConstIterator it = lst.begin(), total = lst.end(); it != total; ++it) { if ((*it) == QLatin1String("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 KIconLoaderPrivate::addExtraDesktopThemes() { if (extraDesktopIconsLoaded) { return; } initIconThemes(); QStringList list; const QStringList icnlibs = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("icons"), QStandardPaths::LocateDirectory); char buf[1000]; for (QStringList::ConstIterator it = icnlibs.begin(), total = icnlibs.end(); it != total; ++it) { QDir dir(*it); if (!dir.exists()) { continue; } const QStringList lst = dir.entryList(QStringList(QStringLiteral("default.*")), QDir::Dirs); for (QStringList::ConstIterator it2 = lst.begin(), total = lst.end(); it2 != total; ++it2) { if (!QFileInfo::exists(*it + *it2 + QStringLiteral("/index.desktop")) && !QFileInfo::exists(*it + *it2 + QStringLiteral("/index.theme"))) { continue; } //TODO: Is any special handling required for NTFS symlinks? #ifndef Q_OS_WIN const int 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); } } #endif } } for (QStringList::ConstIterator it = list.constBegin(), total = list.constEnd(); it != total; ++it) { // Don't add the KDE defaults once more, we have them anyways. if (*it == QLatin1String("default.kde") || *it == QLatin1String("default.kde4")) { continue; } addThemeByName(*it, QLatin1String("")); } extraDesktopIconsLoaded = true; } 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)) { qWarning() << "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)) { qWarning() << "Illegal icon group:" << group; group = KIconLoader::Desktop; } // If size == 0, use default size for the specified group. if (size == 0) { if (group < 0) { qWarning() << "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, qreal scale, 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('@') % QString::number(scale, 'f', 1) % QLatin1Char('_') % overlays.join(QStringLiteral("_")) % (group >= 0 ? mpEffect.fingerprint(group, state) : NULL_EFFECT_FINGERPRINT()) % QLatin1Char('_') % paletteId(mCustomPalette ? mPalette : qApp->palette()) % (q->theme() && q->theme()->followsColorScheme() && state == KIconLoader::SelectedState ? QStringLiteral("_selected") : QString()); } QByteArray KIconLoaderPrivate::processSvg(const QString &path, KIconLoader::States state) const { QScopedPointer device; if (path.endsWith(QLatin1String("svgz"))) { device.reset(new KCompressionDevice(path, KCompressionDevice::GZip)); } else { device.reset(new QFile(path)); } if (!device->open(QIODevice::ReadOnly)) { return QByteArray(); } const QPalette pal = mCustomPalette ? mPalette : qApp->palette(); KColorScheme scheme(QPalette::Active, KColorScheme::Window); QString styleSheet = STYLESHEET_TEMPLATE().arg( state == KIconLoader::SelectedState ? pal.highlightedText().color().name() : pal.windowText().color().name(), state == KIconLoader::SelectedState ? pal.highlight().color().name() : pal.window().color().name(), state == KIconLoader::SelectedState ? pal.highlightedText().color().name() : pal.highlight().color().name(), scheme.foreground(KColorScheme::PositiveText).color().name(), scheme.foreground(KColorScheme::NeutralText).color().name(), scheme.foreground(KColorScheme::NegativeText).color().name()); QByteArray processedContents; QXmlStreamReader reader(device.data()); QBuffer buffer(&processedContents); buffer.open(QIODevice::WriteOnly); QXmlStreamWriter writer(&buffer); while (!reader.atEnd()) { if (reader.readNext() == QXmlStreamReader::StartElement && reader.qualifiedName() == QLatin1String("style") && reader.attributes().value(QLatin1String("id")) == QLatin1String("current-color-scheme")) { writer.writeStartElement(QStringLiteral("style")); writer.writeAttributes(reader.attributes()); writer.writeCharacters(styleSheet); writer.writeEndElement(); while (reader.tokenType() != QXmlStreamReader::EndElement) { reader.readNext(); } } else if (reader.tokenType() != QXmlStreamReader::Invalid) { writer.writeCurrentToken(reader); } } buffer.close(); return processedContents; } QImage KIconLoaderPrivate::createIconImage(const QString &path, int size, qreal scale, KIconLoader::States state) { //TODO: metadata in the theme to make it do this only if explicitly supported? QImageReader reader; QBuffer buffer; if (q->theme()->followsColorScheme() && (path.endsWith(QLatin1String("svg")) || path.endsWith(QLatin1String("svgz")))) { buffer.setData(processSvg(path, state)); reader.setDevice(&buffer); } else { reader.setFileName(path); } if (!reader.canRead()) { return QImage(); } if (size != 0) { reader.setScaledSize(QSize(size * scale, size * scale)); } return reader.read(); } 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; } QString KIconLoaderPrivate::findMatchingIconWithGenericFallbacks(const QString &name, int size, qreal scale) const { QString path = findMatchingIcon(name, size, scale); if (!path.isEmpty()) { return path; } const QString genericIcon = s_globalData()->genericIconFor(name); if (!genericIcon.isEmpty()) { path = findMatchingIcon(genericIcon, size, scale); } return path; } QString KIconLoaderPrivate::findMatchingIcon(const QString &name, int size, qreal scale) const { const_cast(this)->initIconThemes(); // Do two passes through themeNodes. // // The first pass looks for an exact match in each themeNode one after the other. // If one is found and it is an app icon then return that icon. // // In the next pass (assuming the first pass failed), it looks for // generic fallbacks in each themeNode one after the other. // In theory we should only do this for mimetype icons, not for app icons, // but that would require different APIs. The long term solution is under // development for Qt >= 5.8, QFileIconProvider calling QPlatformTheme::fileIcon, // using QMimeType::genericIconName() to get the proper -x-generic fallback. // Once everone uses that to look up mimetype icons, we can kill the fallback code // from this method. foreach (KIconThemeNode *themeNode, links) { const QString path = themeNode->theme->iconPathByName(name, size, KIconLoader::MatchBest, scale); if (!path.isEmpty()) { return path; } } if (name.endsWith(QLatin1String("-x-generic"))) { return QString(); // no further fallback } bool genericFallback = false; QString path; foreach (KIconThemeNode *themeNode, links) { QString currentName = name; while (!currentName.isEmpty()) { if (genericFallback) { // we already tested the base name break; } int rindex = currentName.lastIndexOf(QLatin1Char('-')); 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 mediaTypes = QSet() << QStringLiteral("text") << QStringLiteral("application") << QStringLiteral("image") << QStringLiteral("audio") << QStringLiteral("inode") << QStringLiteral("video") << QStringLiteral("message") << QStringLiteral("model") << QStringLiteral("multipart") << QStringLiteral("x-content") << QStringLiteral("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; } } if (currentName.isEmpty()) { break; } //qCDebug(KICONTHEMES) << "Looking up" << currentName; path = themeNode->theme->iconPathByName(currentName, size, KIconLoader::MatchBest, scale); if (!path.isEmpty()) { return path; } } } return path; } inline QString KIconLoaderPrivate::unknownIconPath(int size, qreal scale) const { QString path = findMatchingIcon(QStringLiteral("unknown"), size, scale); if (path.isEmpty()) { qCDebug(KICONTHEMES) << "Warning: could not find \"unknown\" icon for size" << size << "at scale" << scale; return QString(); } return path; } QString KIconLoaderPrivate::locate(const QString &fileName) { Q_FOREACH (const QString &dir, searchPaths) { const QString path = dir + QLatin1Char('/') + fileName; if (QDir(dir).isAbsolute()) { if (QFileInfo::exists(path)) { return path; } } else { const QString fullPath = QStandardPaths::locate(QStandardPaths::GenericDataLocation, path); if (!fullPath.isEmpty()) { return fullPath; } } } return QString(); } // Finds the absolute path to an icon. QString KIconLoader::iconPath(const QString &_name, int group_or_size, bool canReturnNull) const { return iconPath(_name, group_or_size, canReturnNull, 1 /*scale*/); } QString KIconLoader::iconPath(const QString &_name, int group_or_size, bool canReturnNull, qreal scale) 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) { path = d->locate(name + QLatin1String(".png")); if (path.isEmpty()) { path = d->locate(name + QLatin1String(".svgz")); } if (path.isEmpty()) { path = d->locate(name + QLatin1String(".svg")); } if (path.isEmpty()) { path = d->locate(name + QLatin1String(".xpm")); } return path; } if (group_or_size >= KIconLoader::LastGroup) { qCDebug(KICONTHEMES) << "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, scale); } } path = d->findMatchingIconWithGenericFallbacks(name, size, scale); if (path.isEmpty()) { // Try "User" group too. path = iconPath(name, KIconLoader::User, true); if (!path.isEmpty() || canReturnNull) { return path; } return d->unknownIconPath(size, scale); } return 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; } d->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(QStringLiteral("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 { return loadScaledIcon(_name, group, 1.0 /*scale*/, size, state, overlays, path_store, canReturnNull); } QPixmap KIconLoader::loadScaledIcon(const QString &_name, KIconLoader::Group group, qreal scale, 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 = QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation) + QLatin1Char('/') + name + QStringLiteral(".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, scale, state); QPixmap pix; bool iconWasUnknown = false; QString path; if (d->findCachedPixmapWithPath(key, pix, path)) { pix.setDevicePixelRatio(scale); if (path_store) { *path_store = path; } if (!path.isEmpty()) { return pix; } else { // path is empty for "unknown" icons, which should be searched for // anew regularly if (!d->shouldCheckForUnknownIcons()) { return canReturnNull ? QPixmap() : 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) { if (absolutePath && !favIconOverlay) { path = name; } else { path = d->findMatchingIconWithGenericFallbacks(favIconOverlay ? QStringLiteral("text-html") : name, size, scale); } } if (path.isEmpty()) { // We do have a "User" icon, or we couldn't find the non-User one. 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 (path.isEmpty() && !canReturnNull) { path = d->unknownIconPath(size, scale); iconWasUnknown = true; } QImage img; if (!path.isEmpty()) { img = d->createIconImage(path, size, scale, static_cast(state)); } if (group >= 0) { img = d->mpEffect.apply(img, group, state); } 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) { path.clear(); } d->insertCachedPixmapWithPath(key, pix, path); if (path_store) { *path_store = path; } return pix; } KPixmapSequence KIconLoader::loadPixmapSequence(const QString &xdgIconName, int size) const { return KPixmapSequence(iconPath(xdgIconName, -size), size); } QMovie *KIconLoader::loadMovie(const QString &name, KIconLoader::Group group, int size, QObject *parent) const { QString file = moviePath(name, group, size); if (file.isEmpty()) { return nullptr; } int dirLen = file.lastIndexOf(QLatin1Char('/')); const QString icon = iconPath(name, size ? -size : group, true); if (!icon.isEmpty() && file.left(dirLen) != icon.left(dirLen)) { return nullptr; } QMovie *movie = new QMovie(file, QByteArray(), parent); if (!movie->isValid()) { delete movie; return nullptr; } 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) { qCDebug(KICONTHEMES) << "Illegal icon group:" << group; group = KIconLoader::Desktop; } if (size == 0 && group < 0) { qCDebug(KICONTHEMES) << "Neither size nor group specified!"; group = KIconLoader::Desktop; } QString file = name + QStringLiteral(".mng"); if (group == KIconLoader::User) { file = d->locate(file); } else { if (size == 0) { size = d->mpGroups[group].size; } QString path; foreach (KIconThemeNode *themeNode, d->links) { path = themeNode->theme->iconPath(file, size, KIconLoader::MatchExact); if (!path.isEmpty()) { break; } } if (path.isEmpty()) { foreach (KIconThemeNode *themeNode, d->links) { path = themeNode->theme->iconPath(file, size, KIconLoader::MatchBest); if (!path.isEmpty()) { break; } } } file = path; } 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)) { qCDebug(KICONTHEMES) << "Illegal icon group: " << group; group = KIconLoader::Desktop; } if ((size == 0) && (group < 0)) { qCDebug(KICONTHEMES) << "Neither size nor group specified!"; group = KIconLoader::Desktop; } QString file = name + QStringLiteral("/0001"); if (group == KIconLoader::User) { file = d->locate(file + QStringLiteral(".png")); } else { if (size == 0) { size = d->mpGroups[group].size; } file = d->findMatchingIcon(file, size, 1); // FIXME scale } if (file.isEmpty()) { return lst; } QString path = file.left(file.length() - 8); QDir dir(QFile::encodeName(path)); if (!dir.exists()) { return lst; } foreach (const QString &entry, dir.entryList()) { if (!(entry.leftRef(4)).toUInt()) { continue; } lst += path + entry; } lst.sort(); return lst; } KIconTheme *KIconLoader::theme() const { d->initIconThemes(); if (d->mpThemeRoot) { return d->mpThemeRoot->theme; } return nullptr; } int KIconLoader::currentSize(KIconLoader::Group group) const { if (!d->mpGroups) { return -1; } if (group < 0 || group >= KIconLoader::LastGroup) { qCDebug(KICONTHEMES) << "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() << QStringLiteral("*.png") << QStringLiteral("*.xpm") << QStringLiteral("*.svg") << QStringLiteral("*.svgz"); const QStringList lst = dir.entryList(formats, QDir::Files); QStringList result; for (QStringList::ConstIterator it = lst.begin(), total = lst.end(); it != total; ++it) { result += iconsDir + QLatin1Char('/') + *it; } return result; } QStringList KIconLoader::queryIconsByContext(int group_or_size, KIconLoader::Context context) const { d->initIconThemes(); QStringList result; if (group_or_size >= KIconLoader::LastGroup) { qCDebug(KICONTHEMES) << "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(QLatin1Char('/')); 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) { qCDebug(KICONTHEMES) << "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(QLatin1Char('/')); 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; } KIconEffect *KIconLoader::iconEffect() const { return &d->mpEffect; } bool KIconLoader::alphaBlending(KIconLoader::Group group) const { if (!d->mpGroups) { return false; } if (group < 0 || group >= KIconLoader::LastGroup) { qCDebug(KICONTHEMES) << "Illegal icon group:" << group; return false; } return true; } // deprecated #ifndef KICONTHEMES_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(), nullptr, canReturnNull); iconset.addPixmap(tmp, QIcon::Active, QIcon::On); // we don't use QIconSet's resizing anyway tmp = loadIcon(name, g, s, KIconLoader::DisabledState, QStringList(), nullptr, canReturnNull); iconset.addPixmap(tmp, QIcon::Disabled, QIcon::On); tmp = loadIcon(name, g, s, KIconLoader::DefaultState, QStringList(), nullptr, 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 KICONTHEMES_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 KICONTHEMES_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 KICONTHEMES_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 KICONTHEMES_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 KICONTHEMES_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(QStringLiteral("unknown"), pix)) { //krazy:exclude=iconnames return pix; } const QString path = global()->iconPath(QStringLiteral("unknown"), KIconLoader::Small, true); //krazy:exclude=iconnames if (path.isEmpty()) { qCDebug(KICONTHEMES) << "Warning: Cannot find \"unknown\" icon."; pix = QPixmap(32, 32); } else { pix.load(path); QPixmapCache::insert(QStringLiteral("unknown"), pix); //krazy:exclude=iconnames } return pix; } bool KIconLoader::hasIcon(const QString &name) const { auto it = d->mIconAvailability.constFind(name); const auto end = d->mIconAvailability.constEnd(); if (it != end && !it.value() && !d->shouldCheckForUnknownIcons()) { return false; // known to be unavailable } bool found = it != end && it.value(); if (!found) { if (!iconPath(name, KIconLoader::Desktop, KIconLoader::MatchBest).isEmpty()) { found = true; } d->mIconAvailability.insert(name, found); // remember whether the icon is available or not } return found; } void KIconLoader::setCustomPalette(const QPalette &palette) { d->mCustomPalette = true; d->mPalette = palette; } QPalette KIconLoader::customPalette() const { return d->mPalette; } void KIconLoader::resetPalette() { d->mCustomPalette = false; d->mPalette = QPalette(); } /*** the global icon loader ***/ Q_GLOBAL_STATIC(KIconLoader, globalIconLoader) KIconLoader *KIconLoader::global() { return globalIconLoader(); } #ifndef KICONTHEMES_NO_DEPRECATED void KIconLoader::newIconLoader() { if (global() == this) { KIconTheme::reconfigure(); } reconfigure(objectName()); emit iconLoaderSettingsChanged(); } #endif void KIconLoader::emitChange(KIconLoader::Group g) { s_globalData->emitChange(g); } #include QIcon KDE::icon(const QString &iconName, KIconLoader *iconLoader) { return QIcon(new KIconEngine(iconName, iconLoader ? iconLoader : KIconLoader::global())); } QIcon KDE::icon(const QString &iconName, const QStringList &overlays, KIconLoader *iconLoader) { return QIcon(new KIconEngine(iconName, iconLoader ? iconLoader : KIconLoader::global(), overlays)); } #include "kiconloader.moc" diff --git a/src/kicontheme.cpp b/src/kicontheme.cpp index fa78796..2bae57c 100644 --- a/src/kicontheme.cpp +++ b/src/kicontheme.cpp @@ -1,815 +1,815 @@ /* vi: ts=8 sts=4 sw=4 * * kicontheme.cpp: Lowlevel icon theme handling. * * This file is part of the KDE project, module kdecore. * Copyright (C) 2000 Geert Jansen * Antonio Larrosa * * 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 "kicontheme.h" #include #include #include #include #include #include #include #include #include #include // KLocalizedString::localizedFilePath. Need such functionality in, hmm, QLocale? QStandardPaths? #include #include Q_GLOBAL_STATIC(QString, _themeOverride) // Support for icon themes in RCC files. // The intended use case is standalone apps on Windows / MacOS / etc. // For this reason we use AppDataLocation: BINDIR/data on Windows, Resources on OS X void initRCCIconTheme() { const QString iconThemeRcc = QStandardPaths::locate(QStandardPaths::AppDataLocation, QStringLiteral("icontheme.rcc")); if (!iconThemeRcc.isEmpty()) { const QString iconThemeName = QStringLiteral("kf5_rcc_theme"); const QString iconSubdir = QStringLiteral("/icons/") + iconThemeName; if (QResource::registerResource(iconThemeRcc, iconSubdir)) { if (QFileInfo::exists(QLatin1Char(':') + iconSubdir + QStringLiteral("/index.theme"))) { // Tell Qt about the theme // Note that since qtbase commit a8621a3f8, this means the QPA (i.e. KIconLoader) will NOT be used. QIcon::setThemeName(iconThemeName); // Qt looks under :/icons automatically // Tell KIconTheme about the theme, in case KIconLoader is used directly *_themeOverride() = iconThemeName; } else { qWarning() << "No index.theme found in" << iconThemeRcc; QResource::unregisterResource(iconThemeRcc, iconSubdir); } } else { qWarning() << "Invalid rcc file" << iconThemeRcc; } } } Q_COREAPP_STARTUP_FUNCTION(initRCCIconTheme) // Set the icon theme fallback to breeze // Most of our apps use "lots" of icons that most of the times // are only available with breeze, we still honour the user icon // theme but if the icon is not found there, we go to breeze // since it's almost sure it'll be there static void setBreezeFallback() { #if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0) QIcon::setFallbackThemeName("breeze"); #endif } Q_COREAPP_STARTUP_FUNCTION(setBreezeFallback) class Q_DECL_HIDDEN KIconTheme::KIconThemePrivate { public: QString example, screenshot; bool hidden; KSharedConfig::Ptr sharedConfig; int mDefSize[6]; QList mSizes[6]; int mDepth; QString mDir, mName, mInternalName, mDesc; QStringList mInherits; QStringList mExtensions; QVector mDirs; QVector mScaledDirs; bool followsColorScheme : 1; /// Searches the given dirs vector for a matching icon QString iconPath(const QVector &dirs, const QString &name, int size, qreal scale, KIconLoader::MatchType match) const; }; Q_GLOBAL_STATIC(QString, _theme) Q_GLOBAL_STATIC(QStringList, _theme_list) /** * A subdirectory in an icon theme. */ class KIconThemeDir { public: KIconThemeDir(const QString &basedir, const QString &themedir, const KConfigGroup &config); bool isValid() const { return mbValid; } QString iconPath(const QString &name) const; QStringList iconList() const; QString constructFileName(const QString &file) const { return mBaseDir + mThemeDir + QLatin1Char('/') + file; } KIconLoader::Context context() const { return mContext; } KIconLoader::Type type() const { return mType; } int size() const { return mSize; } int scale() const { return mScale; } int minSize() const { return mMinSize; } int maxSize() const { return mMaxSize; } int threshold() const { return mThreshold; } private: bool mbValid; KIconLoader::Type mType; KIconLoader::Context mContext; int mSize, mScale, mMinSize, mMaxSize; int mThreshold; const QString mBaseDir; const QString mThemeDir; }; QString KIconTheme::KIconThemePrivate::iconPath(const QVector &dirs, const QString &name, int size, qreal scale, KIconLoader::MatchType match) const { QString path; QString tempPath; // used to cache icon path if it exists int delta = -INT_MAX; // current icon size delta of 'icon' int dw = INT_MAX; // icon size delta of current directory // Rather downsample than upsample int integerScale = 1; if (scale > 1.1) { integerScale = 2; } else if (scale > 2.1) { integerScale = 3; } else if (scale > 3.1) { integerScale = 4; } // Search the directory that contains the icon which matches best to the requested // size. If there is no directory which matches exactly to the requested size, the // following criterias get applied: // - Take a directory having icons with a minimum difference to the requested size. // - Prefer directories that allow a downscaling even if the difference to // the requested size is bigger than a directory where an upscaling is required. for (KIconThemeDir *dir : dirs) { if (dir->scale() != integerScale) { continue; } if (match == KIconLoader::MatchExact) { if ((dir->type() == KIconLoader::Fixed) && (dir->size() != size)) { continue; } if ((dir->type() == KIconLoader::Scalable) && ((size < dir->minSize()) || (size > dir->maxSize()))) { continue; } if ((dir->type() == KIconLoader::Threshold) && (abs(dir->size() - size) > dir->threshold())) { continue; } } else { // dw < 0 means need to scale up to get an icon of the requested size. // Upscaling should only be done if no larger icon is available. if (dir->type() == KIconLoader::Fixed) { dw = dir->size() - size; } else if (dir->type() == KIconLoader::Scalable) { if (size < dir->minSize()) { dw = dir->minSize() - size; } else if (size > dir->maxSize()) { dw = dir->maxSize() - size; } else { dw = 0; } } else if (dir->type() == KIconLoader::Threshold) { if (size < dir->size() - dir->threshold()) { dw = dir->size() - dir->threshold() - size; } else if (size > dir->size() + dir->threshold()) { dw = dir->size() + dir->threshold() - size; } else { dw = 0; } } // Usually if the delta (= 'dw') of the current directory is // not smaller than the delta (= 'delta') of the currently best // matching icon, this candidate can be skipped. But skipping // the candidate may only be done, if this does not imply // in an upscaling of the icon (it is OK to use a directory with // smaller icons that what we've already found, however). if ((abs(dw) >= abs(delta)) && ((dw < 0) || (delta > 0))) { continue; } } // cache the result of iconPath() call which checks if file exists tempPath = dir->iconPath(name); if (tempPath.isEmpty()) { continue; } path = tempPath; // if we got in MatchExact that far, we find no better if (match == KIconLoader::MatchExact) { return path; } delta = dw; if (delta == 0) { return path; // We won't find a better match anyway } } return path; } KIconTheme::KIconTheme(const QString &name, const QString &appName, const QString &basePathHint) : d(new KIconThemePrivate) { d->mInternalName = name; QStringList themeDirs; QSet addedDirs; // Used for avoiding duplicates. // Applications can have local additions to the global "locolor" and // "hicolor" icon themes. For these, the _global_ theme description // files are used.. if (!appName.isEmpty() && (name == defaultThemeName() || name == QLatin1String("hicolor") || name == QLatin1String("locolor"))) { const QStringList icnlibs = QStandardPaths::standardLocations(QStandardPaths::GenericDataLocation); for (QStringList::ConstIterator it = icnlibs.constBegin(), total = icnlibs.constEnd(); it != total; ++it) { const QString cDir = *it + QLatin1Char('/') + appName + QStringLiteral("/icons/") + name + QLatin1Char('/'); if (QFileInfo::exists(cDir)) { themeDirs += cDir; } } if (!basePathHint.isEmpty()) { // Checks for dir existing are done below themeDirs += basePathHint + QLatin1Char('/') + name + QLatin1Char('/'); } } // Find the theme description file. These are either locally in the :/icons resource path or global. QStringList icnlibs; // local embedded icons have preference icnlibs << QStringLiteral(":/icons"); // global icons icnlibs += QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("icons"), QStandardPaths::LocateDirectory); // These are not in the icon spec, but e.g. GNOME puts some icons there anyway. icnlibs += QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("pixmaps"), QStandardPaths::LocateDirectory); QString fileName, mainSection; for (QStringList::ConstIterator it = icnlibs.constBegin(), total = icnlibs.constEnd(); it != total; ++it) { const QString cDir = *it + QLatin1Char('/') + name + QLatin1Char('/'); if (QDir(cDir).exists()) { themeDirs += cDir; if (d->mDir.isEmpty()) { if (QFileInfo::exists(cDir + QStringLiteral("index.theme"))) { d->mDir = cDir; fileName = d->mDir + QStringLiteral("index.theme"); mainSection = QStringLiteral("Icon Theme"); } else if (QFileInfo::exists(cDir + QStringLiteral("index.desktop"))) { d->mDir = cDir; fileName = d->mDir + QStringLiteral("index.desktop"); mainSection = QStringLiteral("KDE Icon Theme"); } } } } if (d->mDir.isEmpty()) { qWarning() << "Icon theme" << name << "not found."; return; } // Use KSharedConfig to avoid parsing the file many times, from each component. // Need to keep a ref to it to make this useful d->sharedConfig = KSharedConfig::openConfig(fileName, KConfig::NoGlobals); KConfigGroup cfg(d->sharedConfig, mainSection); d->mName = cfg.readEntry("Name"); d->mDesc = cfg.readEntry("Comment"); d->mDepth = cfg.readEntry("DisplayDepth", 32); d->mInherits = cfg.readEntry("Inherits", QStringList()); if (name != defaultThemeName()) { for (QStringList::Iterator it = d->mInherits.begin(), total = d->mInherits.end(); it != total; ++it) { if (*it == QLatin1String("default")) { *it = defaultThemeName(); } } } d->hidden = cfg.readEntry("Hidden", false); d->followsColorScheme = cfg.readEntry("FollowsColorScheme", false); d->example = cfg.readPathEntry("Example", QString()); d->screenshot = cfg.readPathEntry("ScreenShot", QString()); d->mExtensions = cfg.readEntry("KDE-Extensions", QStringList{ QStringLiteral(".png"), QStringLiteral(".svgz"), QStringLiteral(".svg"), QStringLiteral(".xpm") }); const QStringList dirs = cfg.readPathEntry("Directories", QStringList()) + cfg.readPathEntry("ScaledDirectories", QStringList()); for (QStringList::ConstIterator it = dirs.begin(); it != dirs.end(); ++it) { KConfigGroup cg(d->sharedConfig, *it); for (QStringList::ConstIterator itDir = themeDirs.constBegin(); itDir != themeDirs.constEnd(); ++itDir) { const QString currentDir(*itDir + *it + QLatin1Char('/')); if (!addedDirs.contains(currentDir) && QDir(currentDir).exists()) { addedDirs.insert(currentDir); KIconThemeDir *dir = new KIconThemeDir(*itDir, *it, cg); if (dir->isValid()) { if (dir->scale() > 1) { d->mScaledDirs.append(dir); } else { d->mDirs.append(dir); } } else { delete dir; } } } } QStringList groups; groups += QStringLiteral("Desktop"); groups += QStringLiteral("Toolbar"); groups += QStringLiteral("MainToolbar"); groups += QStringLiteral("Small"); groups += QStringLiteral("Panel"); groups += QStringLiteral("Dialog"); const int defDefSizes[] = { 32, 22, 22, 16, 48, 32 }; KConfigGroup cg(d->sharedConfig, mainSection); for (int i = 0; i < groups.size(); ++i) { const QString group = groups.at(i); d->mDefSize[i] = cg.readEntry(group + QStringLiteral("Default"), defDefSizes[i]); d->mSizes[i] = cg.readEntry(group + QStringLiteral("Sizes"), QList()); } } KIconTheme::~KIconTheme() { qDeleteAll(d->mDirs); qDeleteAll(d->mScaledDirs); delete d; } QString KIconTheme::name() const { return d->mName; } QString KIconTheme::internalName() const { return d->mInternalName; } QString KIconTheme::description() const { return d->mDesc; } QString KIconTheme::example() const { return d->example; } QString KIconTheme::screenshot() const { return d->screenshot; } QString KIconTheme::dir() const { return d->mDir; } QStringList KIconTheme::inherits() const { return d->mInherits; } bool KIconTheme::isValid() const { return !d->mDirs.isEmpty() || !d->mScaledDirs.isEmpty(); } bool KIconTheme::isHidden() const { return d->hidden; } int KIconTheme::depth() const { return d->mDepth; } int KIconTheme::defaultSize(KIconLoader::Group group) const { if ((group < 0) || (group >= KIconLoader::LastGroup)) { qWarning() << "Illegal icon group: " << group; return -1; } return d->mDefSize[group]; } QList KIconTheme::querySizes(KIconLoader::Group group) const { if ((group < 0) || (group >= KIconLoader::LastGroup)) { qWarning() << "Illegal icon group: " << group; return QList(); } return d->mSizes[group]; } QStringList KIconTheme::queryIcons(int size, KIconLoader::Context context) const { // Try to find exact match QStringList result; foreach (KIconThemeDir* dir, d->mDirs + d->mScaledDirs) { if ((context != KIconLoader::Any) && (context != dir->context())) { continue; } if ((dir->type() == KIconLoader::Fixed) && (dir->size() == size)) { result += dir->iconList(); continue; } if ((dir->type() == KIconLoader::Scalable) && (size >= dir->minSize()) && (size <= dir->maxSize())) { result += dir->iconList(); continue; } if ((dir->type() == KIconLoader::Threshold) && (abs(size - dir->size()) < dir->threshold())) { result += dir->iconList(); } } return result; /* int delta = 1000, dw; // Find close match KIconThemeDir *best = 0L; for(int i=0; imDirs.size(); ++i) { dir = d->mDirs.at(i); if ((context != KIconLoader::Any) && (context != dir->context())) { continue; } dw = dir->size() - size; if ((dw > 6) || (abs(dw) >= abs(delta))) continue; delta = dw; best = dir; } if (best == 0L) { return QStringList(); } return best->iconList(); */ } QStringList KIconTheme::queryIconsByContext(int size, KIconLoader::Context context) const { int dw; // We want all the icons for a given context, but we prefer icons // of size size . Note that this may (will) include duplicate icons //QStringList iconlist[34]; // 33 == 48-16+1 QStringList iconlist[128]; // 33 == 48-16+1 // Usually, only the 0, 6 (22-16), 10 (32-22), 16 (48-32 or 32-16), // 26 (48-22) and 32 (48-16) will be used, but who knows if someone // will make icon themes with different icon sizes. foreach (KIconThemeDir *dir, d->mDirs + d->mScaledDirs) { if ((context != KIconLoader::Any) && (context != dir->context())) { continue; } dw = abs(dir->size() - size); iconlist[(dw < 127) ? dw : 127] += dir->iconList(); } QStringList iconlistResult; for (int i = 0; i < 128; i++) { iconlistResult += iconlist[i]; } return iconlistResult; } bool KIconTheme::hasContext(KIconLoader::Context context) const { foreach (KIconThemeDir *dir, d->mDirs + d->mScaledDirs) { if ((context == KIconLoader::Any) || (context == dir->context())) { return true; } } return false; } QString KIconTheme::iconPathByName(const QString &iconName, int size, KIconLoader::MatchType match) const { return iconPathByName(iconName, size, match, 1 /*scale*/); } QString KIconTheme::iconPathByName(const QString &iconName, int size, KIconLoader::MatchType match, qreal scale) const { foreach(const QString ¤t, d->mExtensions) { const QString path = iconPath(iconName + current, size, match, scale); if (!path.isEmpty()) return path; } return QString(); } bool KIconTheme::followsColorScheme() const { return d->followsColorScheme; } QString KIconTheme::iconPath(const QString &name, int size, KIconLoader::MatchType match) const { return iconPath(name, size, match, 1 /*scale*/); } QString KIconTheme::iconPath(const QString &name, int size, KIconLoader::MatchType match, qreal scale) const { // first look for a scaled image at exactly the requested size QString path = d->iconPath(d->mScaledDirs, name, size, scale, KIconLoader::MatchExact); // then look for an unscaled one but request it at larger size so it doesn't become blurry if (path.isEmpty()) { path = d->iconPath(d->mDirs, name, size * scale, 1, match); } return path; } // static QString KIconTheme::current() { // Static pointers because of unloading problems wrt DSO's. if (_themeOverride && !_themeOverride->isEmpty()) { *_theme() = *_themeOverride(); } if (!_theme()->isEmpty()) { return *_theme(); } QString theme; // Check application specific config for a theme setting. KConfigGroup app_cg(KSharedConfig::openConfig(QString(), KConfig::NoGlobals), "Icons"); theme = app_cg.readEntry("Theme", QString()); if (theme.isEmpty() || theme == QLatin1String("hicolor")) { // No theme, try to use Qt's. A Platform plugin might have set // a good theme there. theme = QIcon::themeName(); } if (theme.isEmpty() || theme == QLatin1String("hicolor")) { // Still no theme, try config with kdeglobals. KConfigGroup cg(KSharedConfig::openConfig(), "Icons"); theme = cg.readEntry("Theme", QString()); } if (theme.isEmpty() || theme == QLatin1String("hicolor")) { // Still no good theme, use default. theme = defaultThemeName(); } *_theme() = theme; return *_theme(); } void KIconTheme::forceThemeForTests(const QString &themeName) { *_themeOverride() = themeName; _theme()->clear(); // ::current sets this again based on conditions } // static QStringList KIconTheme::list() { // Static pointer because of unloading problems wrt DSO's. if (!_theme_list()->isEmpty()) { return *_theme_list(); } // Find the theme description file. These are either locally in the :/icons resource path or global. QStringList icnlibs; // local embedded icons have preference icnlibs << QStringLiteral(":/icons"); // global icons icnlibs += QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("icons"), QStandardPaths::LocateDirectory); // These are not in the icon spec, but e.g. GNOME puts some icons there anyway. icnlibs += QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("pixmaps"), QStandardPaths::LocateDirectory); - Q_FOREACH (const QString &it, icnlibs) { + for (const QString &it : qAsConst(icnlibs)) { QDir dir(it); const QStringList lst = dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot); for (QStringList::ConstIterator it2 = lst.begin(), total = lst.end(); it2 != total; ++it2) { if ((*it2).startsWith(QLatin1String("default."))) { continue; } if (!QFileInfo::exists(it + QLatin1Char('/') + *it2 + QLatin1String("/index.desktop")) && !QFileInfo::exists(it + QLatin1Char('/') + *it2 + QLatin1String("/index.theme"))) { continue; } KIconTheme oink(*it2); if (!oink.isValid()) { continue; } if (!_theme_list()->contains(*it2)) { _theme_list()->append(*it2); } } } return *_theme_list(); } // static void KIconTheme::reconfigure() { _theme()->clear(); _theme_list()->clear(); } // static QString KIconTheme::defaultThemeName() { return QStringLiteral("hicolor"); } void KIconTheme::assignIconsToContextMenu(ContextMenus type, QList actions) { switch (type) { // FIXME: This code depends on Qt's action ordering. case TextEditor: enum { UndoAct, RedoAct, Separator1, CutAct, CopyAct, PasteAct, DeleteAct, ClearAct, Separator2, SelectAllAct, NCountActs }; if (actions.count() < NCountActs) { return; } actions[UndoAct]->setIcon(QIcon::fromTheme(QStringLiteral("edit-undo"))); actions[RedoAct]->setIcon(QIcon::fromTheme(QStringLiteral("edit-redo"))); actions[CutAct]->setIcon(QIcon::fromTheme(QStringLiteral("edit-cut"))); actions[CopyAct]->setIcon(QIcon::fromTheme(QStringLiteral("edit-copy"))); actions[PasteAct]->setIcon(QIcon::fromTheme(QStringLiteral("edit-paste"))); actions[ClearAct]->setIcon(QIcon::fromTheme(QStringLiteral("edit-clear"))); actions[DeleteAct]->setIcon(QIcon::fromTheme(QStringLiteral("edit-delete"))); actions[SelectAllAct]->setIcon(QIcon::fromTheme(QStringLiteral("edit-select-all"))); break; case ReadOnlyText: if (actions.count() < 1) { return; } actions[0]->setIcon(QIcon::fromTheme(QStringLiteral("edit-copy"))); break; } } /*** KIconThemeDir ***/ KIconThemeDir::KIconThemeDir(const QString &basedir, const QString &themedir, const KConfigGroup &config) : mbValid(false) , mType(KIconLoader::Fixed) , mSize(config.readEntry("Size", 0)) , mScale(config.readEntry("Scale", 1)) , mMinSize(1) // just set the variables to something , mMaxSize(50) // meaningful in case someone calls minSize or maxSize , mThreshold(2) , mBaseDir(basedir) , mThemeDir(themedir) { if (mSize == 0) { return; } QString tmp = config.readEntry(QStringLiteral("Context")); if (tmp == QLatin1String("Devices")) { mContext = KIconLoader::Device; } else if (tmp == QLatin1String("MimeTypes")) { mContext = KIconLoader::MimeType; } else if (tmp == QLatin1String("FileSystems")) { mContext = KIconLoader::FileSystem; } else if (tmp == QLatin1String("Applications")) { mContext = KIconLoader::Application; } else if (tmp == QLatin1String("Actions")) { mContext = KIconLoader::Action; } else if (tmp == QLatin1String("Animations")) { mContext = KIconLoader::Animation; } else if (tmp == QLatin1String("Categories")) { mContext = KIconLoader::Category; } else if (tmp == QLatin1String("Emblems")) { mContext = KIconLoader::Emblem; } else if (tmp == QLatin1String("Emotes")) { mContext = KIconLoader::Emote; } else if (tmp == QLatin1String("International")) { mContext = KIconLoader::International; } else if (tmp == QLatin1String("Places")) { mContext = KIconLoader::Place; } else if (tmp == QLatin1String("Status")) { mContext = KIconLoader::StatusIcon; } else if (tmp == QLatin1String("Stock")) { // invalid, but often present context, skip warning return; } else if (tmp.isEmpty()) { // do nothing. key not required } else { qWarning() << "Invalid Context=" << tmp << "line for icon theme: " << constructFileName(QString()); return; } tmp = config.readEntry(QStringLiteral("Type"), QStringLiteral("Threshold")); if (tmp == QLatin1String("Fixed")) { mType = KIconLoader::Fixed; } else if (tmp == QLatin1String("Scalable")) { mType = KIconLoader::Scalable; } else if (tmp == QLatin1String("Threshold")) { mType = KIconLoader::Threshold; } else { qWarning() << "Invalid Type=" << tmp << "line for icon theme: " << constructFileName(QString()); return; } if (mType == KIconLoader::Scalable) { mMinSize = config.readEntry(QStringLiteral("MinSize"), mSize); mMaxSize = config.readEntry(QStringLiteral("MaxSize"), mSize); } else if (mType == KIconLoader::Threshold) { mThreshold = config.readEntry(QStringLiteral("Threshold"), 2); } mbValid = true; } QString KIconThemeDir::iconPath(const QString &name) const { if (!mbValid) { return QString(); } const QString file = constructFileName(name); if (QFileInfo::exists(file)) { return KLocalizedString::localizedFilePath(file); } return QString(); } QStringList KIconThemeDir::iconList() const { const QDir icondir = constructFileName(QString()); const QStringList formats = QStringList() << QStringLiteral("*.png") << QStringLiteral("*.svg") << QStringLiteral("*.svgz") << QStringLiteral("*.xpm"); const QStringList lst = icondir.entryList(formats, QDir::Files); QStringList result; result.reserve(lst.size()); for (const QString &file : lst) { result += constructFileName(file); } return result; }