/* * Copyright © 2016 Canonical Ltd. * * This program is free software: you can redistribute it and/or modify it * under the terms of the GNU General Public License version 3, as published * by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranties of * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program. If not, see . * * Authors: * Larry Price */ #include "application-icon-finder.h" #include "string-util.h" #include #include using namespace lomiri::util; namespace lomiri { namespace app_launch { namespace { constexpr auto ICONS_DIR = "/icons"; constexpr auto ICON_THEMES = {"suru", "Humanity", "Adwaita", "gnome", "hicolor"}; constexpr auto THEME_INDEX_FILE = "index.theme"; constexpr auto SIZE_PROPERTY = "Size"; constexpr auto MAXSIZE_PROPERTY = "MaxSize"; constexpr auto THRESHOLD_PROPERTY = "Threshold"; constexpr auto FIXED_CONTEXT = "Fixed"; constexpr auto SCALABLE_CONTEXT = "Scalable"; constexpr auto THRESHOLD_CONTEXT = "Threshold"; constexpr auto CONTEXT_PROPERTY = "Context"; constexpr auto TYPE_PROPERTY = "Type"; constexpr auto DIRECTORIES_PROPERTY = "Directories"; constexpr auto ICON_THEME_KEY = "Icon Theme"; constexpr auto PIXMAPS_PATH = "/pixmaps/"; constexpr auto ICON_TYPES = {".png", ".svg", ".xpm"}; constexpr auto METAGUI_PATH = "/meta/gui"; static const std::regex ICON_SIZE_DIRNAME = std::regex("^(\\d+)x\\1$"); static const std::regex SCALABLE_WITH_REGEX = std::regex("^scalable-up-to-(\\d+)$"); } // anonymous namespace IconFinder::IconFinder(std::string basePath) : _searchPaths(getSearchPaths(basePath)) , _basePath(basePath) { } /** Finds an icon in the search paths that we have for this path */ Application::Info::IconPath IconFinder::find(const std::string& iconName) { if (iconName[0] == '/') // explicit icon path received { return Application::Info::IconPath::from_raw(iconName); } /* Look in each directory slowly decreasing the size until we find an icon */ auto size = 0; std::string iconPath; for (const auto& path : _searchPaths) { if (path.size > size) { auto foundIcon = findExistingIcon(path.path, iconName); if (!foundIcon.empty()) { size = path.size; iconPath = foundIcon; } } } return Application::Info::IconPath::from_raw(iconPath); } /** Check to see if this is an icon name or an icon filename */ bool IconFinder::hasImageExtension(const char* filename) { for (const auto& extension : ICON_TYPES) { if (g_str_has_suffix(filename, extension)) { return true; } } return false; } /** Check in a given path if there is an existing file in it that satifies our name */ std::string IconFinder::findExistingIcon(const std::string& path, const std::string& iconName) { std::string iconPath; /* If it already has an extension, only check that one */ if (hasImageExtension(iconName.c_str())) { auto fullpath = unique_gchar(g_build_filename(path.c_str(), iconName.c_str(), nullptr)); if (g_file_test(fullpath.get(), G_FILE_TEST_EXISTS)) { iconPath = fullpath.get(); } return iconPath; } /* Otherwise check all the valid extensions to see if they exist */ for (const auto& extension : ICON_TYPES) { auto fullpath = unique_gchar(g_build_filename(path.c_str(), (iconName + extension).c_str(), nullptr)); if (g_file_test(fullpath.get(), G_FILE_TEST_EXISTS)) { iconPath = fullpath.get(); break; } } return iconPath; } /** Create a directory item if the directory exists */ std::list IconFinder::validDirectories(const std::string& themePath, gchar* directory, int size) { std::list dirs; auto globalHicolorTheme = unique_gchar(g_build_filename(themePath.c_str(), directory, nullptr)); if (g_file_test(globalHicolorTheme.get(), G_FILE_TEST_EXISTS)) { dirs.emplace_back(ThemeSubdirectory{std::string(globalHicolorTheme.get()), size}); } return dirs; } /** Take the data in a directory stanza and turn it into an actual directory */ std::list IconFinder::addSubdirectoryByType(std::shared_ptr themefile, gchar* directory, const std::string& themePath) { GError* error = nullptr; auto gType = unique_gchar(g_key_file_get_string(themefile.get(), directory, TYPE_PROPERTY, &error)); if (error != nullptr) { g_error_free(error); return std::list{}; } std::string type(gType.get()); if (type == FIXED_CONTEXT) { auto size = g_key_file_get_integer(themefile.get(), directory, SIZE_PROPERTY, &error); if (error != nullptr) { g_error_free(error); } else { return validDirectories(themePath, directory, size); } } else if (type == SCALABLE_CONTEXT) { auto size = g_key_file_get_integer(themefile.get(), directory, MAXSIZE_PROPERTY, &error); if (error != nullptr) { g_error_free(error); } else { return validDirectories(themePath, directory, size); } } else if (type == THRESHOLD_CONTEXT) { auto size = g_key_file_get_integer(themefile.get(), directory, SIZE_PROPERTY, &error); if (error != nullptr) { g_error_free(error); } else { auto threshold = g_key_file_get_integer(themefile.get(), directory, THRESHOLD_PROPERTY, &error); if (error != nullptr) { threshold = 2; // threshold defaults to 2 g_error_free(error); } return validDirectories(themePath, directory, size + threshold); } } return std::list{}; } /** Parse a theme file's various stanzas for each directory */ std::list IconFinder::searchIconPaths(std::shared_ptr themefile, gchar** directories, const std::string& themePath) { std::list subdirs; for (auto i = 0; directories[i] != nullptr; ++i) { GError* error = nullptr; auto context = unique_gchar(g_key_file_get_string(themefile.get(), directories[i], CONTEXT_PROPERTY, &error)); if (error != nullptr) { g_error_free(error); continue; } auto newDirs = addSubdirectoryByType(themefile, directories[i], themePath); subdirs.splice(subdirs.end(), newDirs); } return subdirs; } /** Try to get theme subdirectories using .theme file in the given theme path if it exists */ std::list IconFinder::themeFileSearchPaths(const std::string& themePath) { auto themeFilePath = unique_gchar(g_build_filename(themePath.c_str(), THEME_INDEX_FILE, nullptr)); GError* error = nullptr; auto themefile = share_glib(g_key_file_new()); g_key_file_load_from_file(themefile.get(), themeFilePath.get(), G_KEY_FILE_NONE, &error); if (error != nullptr) { g_debug("Unable to find theme file: %s", themeFilePath.get()); g_error_free(error); return std::list(); } g_key_file_set_list_separator(themefile.get(), ','); auto directories = unique_gcharv( g_key_file_get_string_list(themefile.get(), ICON_THEME_KEY, DIRECTORIES_PROPERTY, nullptr, &error)); if (error != nullptr) { g_debug("Theme file '%s' didn't have any directories", themeFilePath.get()); g_error_free(error); return std::list(); } auto iconPaths = searchIconPaths(themefile, directories.get(), themePath); return iconPaths; } /** Look into a theme directory and see if we can use the subdirectories as icon folders. This is a fallback, and is sadly inefficient. */ std::list IconFinder::themeDirSearchPaths(const std::string& themeDir) { std::list searchPaths; GError* error = nullptr; auto gdir = unique_glib(g_dir_open(themeDir.c_str(), 0, &error)); if (error != nullptr) { g_debug("Unable to open directory '%s' because: %s", themeDir.c_str(), error->message); g_error_free(error); return searchPaths; } const gchar* dirname = nullptr; while ((dirname = g_dir_read_name(gdir.get())) != nullptr) { /* Iterate over size-based directories */ auto sizePath = unique_gchar(g_build_filename(themeDir.c_str(), dirname, nullptr)); if (g_file_test(sizePath.get(), G_FILE_TEST_IS_DIR)) { std::smatch match; std::string dirstr(dirname); int size; if (std::regex_match(dirstr, match, ICON_SIZE_DIRNAME)) { size = std::atoi(match[1].str().c_str()); } else if (g_strcmp0(dirname, "scalable") == 0) { /* We don't really know what to do with scalable icons, let's call them 256 images */ size = 256; } else { /* Some directories are "scalable with", meaning that they are meant to be used up to a certain size */ std::smatch scalablewith; if (std::regex_match(dirstr, scalablewith, SCALABLE_WITH_REGEX)) { size = std::atoi(scalablewith[1].str().c_str()); } else { /* Otherwise we don't know what to do with this dir, ignore for now */ continue; } } auto subdir = unique_glib(g_dir_open(sizePath.get(), 0, &error)); const gchar* subdirname = nullptr; while ((subdirname = g_dir_read_name(subdir.get())) != nullptr) { auto fullPath = unique_gchar(g_build_filename(sizePath.get(), subdirname, nullptr)); if (g_file_test(fullPath.get(), G_FILE_TEST_IS_DIR)) { searchPaths.emplace_back(IconFinder::ThemeSubdirectory{fullPath.get(), size}); } } } } return searchPaths; } /** Gets all search paths from a given theme directory via theme file or manually scanning the directory. */ std::list IconFinder::iconsFromThemePath(const gchar* themeDir) { std::list iconPaths; if (g_file_test(themeDir, G_FILE_TEST_IS_DIR)) { /* If the directory exists, it could have icons of unknown size */ iconPaths.emplace_back(IconFinder::ThemeSubdirectory{themeDir, 1}); /* Now see if we can get directories from a theme file */ auto themeDirs = themeFileSearchPaths(themeDir); if (themeDirs.size() > 0) { iconPaths.splice(iconPaths.end(), themeDirs); } else { /* If we didn't get from a theme file, we need to manually scan the directories */ auto dirPaths = themeDirSearchPaths(themeDir); iconPaths.splice(iconPaths.end(), dirPaths); } } return iconPaths; } /** Gets search paths based on common icon directories including themes and pixmaps. */ std::list IconFinder::getSearchPaths(const std::string& basePath) { std::list iconPaths; for (const auto& theme : ICON_THEMES) { auto dir = unique_gchar(g_build_filename(basePath.c_str(), ICONS_DIR, theme, nullptr)); auto icons = iconsFromThemePath(dir.get()); iconPaths.splice(iconPaths.end(), icons); } /* Add root icons directory as potential path */ auto iconsPath = unique_gchar(g_build_filename(basePath.c_str(), ICONS_DIR, nullptr)); if (g_file_test(iconsPath.get(), G_FILE_TEST_IS_DIR)) { iconPaths.emplace_back(IconFinder::ThemeSubdirectory{iconsPath.get(), 1}); } /* Add the pixmaps path as a fallback if it exists */ auto pixmapsPath = unique_gchar(g_build_filename(basePath.c_str(), PIXMAPS_PATH, nullptr)); if (g_file_test(pixmapsPath.get(), G_FILE_TEST_IS_DIR)) { iconPaths.emplace_back(IconFinder::ThemeSubdirectory{pixmapsPath.get(), 1}); } /* Add the snap meta/gui path as a fallback if it exists */ auto snapMetaGuiPath = unique_gchar(g_build_filename(basePath.c_str(), METAGUI_PATH, nullptr)); if (g_file_test(snapMetaGuiPath.get(), G_FILE_TEST_IS_DIR)) { iconPaths.emplace_back(IconFinder::ThemeSubdirectory{snapMetaGuiPath.get(), 1}); } /* Add the base directory itself as a fallback, for "foo.png" icon names */ iconPaths.emplace_back(IconFinder::ThemeSubdirectory{basePath, 1}); // find icons sorted by size, highest to lowest iconPaths.sort([](const ThemeSubdirectory& lhs, const ThemeSubdirectory& rhs) { return lhs.size > rhs.size; }); return iconPaths; } } // namespace app_launch } // namespace lomiri