Merge lp:~larryprice/ubuntu-app-launch/find-theme-icons into lp:ubuntu-app-launch/16.04

[Larry Price]

Update icon search for non-click applications to search the hicolor theme directory for appropriate icons.

Update icon search for non-click applications to search the hicolor theme directory for appropriate icons.

Icon update code is based on: https://standards.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html but finds the optimal icon based on maximum size. Accessed through the registry, and caches paths that have already been considered. For only 12 Libertine apps, caching allowed the icon fetch process to take half as much time, so I'm assuming for 120 or 1200 apps it would have an even more drastic effect. Some of the various code paths are based only on what I've observed from various desktop files, such as searching the pixmaps directory when given a file with an extension but not a path.

[lp:~larryprice/ubuntu-app-launch/find-theme-icons]

287. By Larry Price on 2016-04-28

Removing commented line

288. By Larry Price on 2016-04-28

removing unnecessary env setup in CMakeList

[Ted Gould (ted)]

Overall, really cool. Love getting all of these features included into the icon searching functionality, I think you're on the right path. A couple of global comments and some inline cleanup stuff!

* Fix for ~/.local installed icons for Steam we discussed on IRC
* Please add the new Class to /docs/index.rst so it gets in the implementation documentation (doc strings are a plus as well, not everywhere yet, but trying to get more in)
* make sure to run "make format" in the lib dir, not sure if you have or not (I don't care, but lots of folks seem to, and it avoids big diffs in the future)

review: Needs Fixing

[lp:~larryprice/ubuntu-app-launch/find-theme-icons]

289. By Larry Price on 2016-04-28

pixmaps should be fallback for all icons - addresses firefox

290. By Larry Price on 2016-04-28

use g_build_filepath more often, update interface, better flow [recycle]

291. By Larry Price on 2016-04-28

sorting directories by size from highest to lowest

292. By Larry Price on 2016-04-28

using defined cmake source path for tests

293. By Larry Price on 2016-04-28

adding more test data and a few more tests

294. By Larry Price on 2016-04-28

running clang format

295. By Larry Price on 2016-04-29

Adding support for searching local icon directories

296. By Larry Price on 2016-04-29

adding forgotten steam icons

297. By Larry Price on 2016-04-29

updating documentation

298. By Larry Price on 2016-04-29

more documentation for public members of iconfinder

299. By Larry Price on 2016-04-29

Merge ~ted/ubuntu-app-launch/find-theme-icons-ted

300. By Larry Price on 2016-04-29

deleting unnecessary null check

301. By Larry Price on 2016-05-02

Allowing spaces in app names and undoing incorrect local dir stuff

302. By Larry Price on 2016-05-02

Merge with ted

303. By Larry Price on 2016-05-02

Fixing some small merge issues, correcting regex for matching dirs

304. By Larry Price on 2016-05-02

Fixing tests

305. By Larry Price on 2016-05-02

Merge with trunk

306. By Larry Price on 2016-05-02

no need for second capture group in regex

307. By Larry Price on 2016-05-03

Merge with ted

308. By Larry Price on 2016-05-03

Adding tests for root icons path

309. By Larry Price on 2016-05-03

running clang format on the test

310. By Larry Price on 2016-05-03

Adding missing app icons

[Ted Gould (ted)]

review: Approve

=== modified file 'docs/index.rst'
--- docs/index.rst	2016-04-20 21:29:37 +0000
+++ docs/index.rst	2016-05-03 14:23:08 +0000
@@ -106,6 +106,16 @@
    :private-members:
    :undoc-members:
 
+Application Icon Finder
+------------------------
+
+.. doxygenclass:: ubuntu::app_launch::app_info::IconFinder
+   :project: libubuntu-app-launch
+   :members:
+   :protected-members:
+   :private-members:
+   :undoc-members:
+
 Helper Implementation Click
 ---------------------------
 

=== modified file 'libubuntu-app-launch/CMakeLists.txt'
--- libubuntu-app-launch/CMakeLists.txt	2016-02-09 22:51:12 +0000
+++ libubuntu-app-launch/CMakeLists.txt	2016-05-03 14:23:08 +0000
@@ -1,4 +1,3 @@
-
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
@@ -40,9 +39,12 @@
 registry-impl.cpp
 application-impl-base.cpp
 application-impl-click.cpp
+application-impl-legacy.h
 application-impl-legacy.cpp
+application-impl-libertine.h
 application-impl-libertine.cpp
 application-info-desktop.cpp
+application-icon-finder.cpp
 helper-impl-click.cpp
 glib-thread.cpp
 )

=== added file 'libubuntu-app-launch/application-icon-finder.cpp'
--- libubuntu-app-launch/application-icon-finder.cpp	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/application-icon-finder.cpp	2016-05-03 14:23:08 +0000
@@ -0,0 +1,353 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *     Larry Price <[e-mail]>
+ */
+
+#include "application-icon-finder.h"
+#include <regex>
+
+namespace ubuntu
+{
+namespace app_launch
+{
+namespace
+{
+constexpr auto ICONS_DIR = "/icons";
+constexpr auto HICOLOR_THEME_DIR = "/icons/hicolor";
+constexpr auto HICOLOR_THEME_FILE = "/icons/hicolor/index.theme";
+constexpr auto APPLICATIONS_TYPE = "Applications";
+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"};
+
+static const std::regex iconSizeDirname = std::regex("^(\\d+)x\\1$");
+}  // 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 = g_build_filename(path.c_str(), iconName.c_str(), nullptr);
+        if (g_file_test(fullpath, G_FILE_TEST_EXISTS))
+        {
+            iconPath = fullpath;
+        }
+        g_free(fullpath);
+        return iconPath;
+    }
+
+    /* Otherwise check all the valid extensions to see if they exist */
+    for (const auto& extension : ICON_TYPES)
+    {
+        auto fullpath = g_build_filename(path.c_str(), (iconName + extension).c_str(), nullptr);
+        if (g_file_test(fullpath, G_FILE_TEST_EXISTS))
+        {
+            iconPath = fullpath;
+            g_free(fullpath);
+            break;
+        }
+        g_free(fullpath);
+    }
+    return iconPath;
+}
+
+/** Create a directory item if the directory exists */
+std::list<IconFinder::ThemeSubdirectory> IconFinder::validDirectories(const std::string& basePath,
+                                                                      gchar* directory,
+                                                                      int size)
+{
+    std::list<IconFinder::ThemeSubdirectory> dirs;
+    auto globalHicolorTheme = g_build_filename(basePath.c_str(), HICOLOR_THEME_DIR, directory, nullptr);
+    if (g_file_test(globalHicolorTheme, G_FILE_TEST_EXISTS))
+    {
+        dirs.emplace_back(ThemeSubdirectory{std::string(globalHicolorTheme), size});
+    }
+    g_free(globalHicolorTheme);
+
+    return dirs;
+}
+
+/** Take the data in a directory stanza and turn it into an actual directory */
+std::list<IconFinder::ThemeSubdirectory> IconFinder::addSubdirectoryByType(std::shared_ptr<GKeyFile> themefile,
+                                                                           gchar* directory,
+                                                                           const std::string& basePath)
+{
+    GError* error = nullptr;
+    auto gType = g_key_file_get_string(themefile.get(), directory, TYPE_PROPERTY, &error);
+    if (error != nullptr)
+    {
+        g_error_free(error);
+        return std::list<ThemeSubdirectory>{};
+    }
+    std::string type(gType);
+    g_free(gType);
+
+    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(basePath, 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(basePath, 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(basePath, directory, size + threshold);
+        }
+    }
+    return std::list<ThemeSubdirectory>{};
+}
+
+/** Parse a theme file's various stanzas for each directory */
+std::list<IconFinder::ThemeSubdirectory> IconFinder::searchIconPaths(std::shared_ptr<GKeyFile> themefile,
+                                                                     gchar** directories,
+                                                                     const std::string& basePath)
+{
+    std::list<ThemeSubdirectory> subdirs;
+    for (auto i = 0; directories[i] != nullptr; ++i)
+    {
+        GError* error = nullptr;
+        auto context = g_key_file_get_string(themefile.get(), directories[i], CONTEXT_PROPERTY, &error);
+        if (error != nullptr)
+        {
+            g_error_free(error);
+            continue;
+        }
+        if (g_strcmp0(context, APPLICATIONS_TYPE) == 0)
+        {
+            auto newDirs = addSubdirectoryByType(themefile, directories[i], basePath);
+            subdirs.splice(subdirs.end(), newDirs);
+        }
+        g_free(context);
+    }
+    return subdirs;
+}
+
+/** Try to get theme subdirectories using .theme file in the hicolor theme file
+    if it exists */
+std::list<IconFinder::ThemeSubdirectory> IconFinder::themeFileSearchPaths(const std::string& basePath)
+{
+    std::string themeFilePath = basePath + HICOLOR_THEME_FILE;
+    GError* error = nullptr;
+    auto themefile = std::shared_ptr<GKeyFile>(g_key_file_new(), g_key_file_free);
+    g_key_file_load_from_file(themefile.get(), themeFilePath.c_str(), G_KEY_FILE_NONE, &error);
+    if (error != nullptr)
+    {
+        g_debug("Unable to find Hicolor theme file: %s", themeFilePath.c_str());
+        g_error_free(error);
+        return std::list<ThemeSubdirectory>();
+    }
+
+    g_key_file_set_list_separator(themefile.get(), ',');
+    auto directories =
+        g_key_file_get_string_list(themefile.get(), ICON_THEME_KEY, DIRECTORIES_PROPERTY, nullptr, &error);
+    if (error != nullptr)
+    {
+        g_debug("Hicolor theme file '%s' didn't have any directories", themeFilePath.c_str());
+        g_error_free(error);
+        return std::list<ThemeSubdirectory>();
+    }
+
+    auto iconPaths = searchIconPaths(themefile, directories, basePath);
+    g_strfreev(directories);
+    return iconPaths;
+}
+
+/** Look into a theme directory and see if we can use the subdirectories
+    as icon folders. Sadly inefficient. */
+std::list<IconFinder::ThemeSubdirectory> IconFinder::themeDirSearchPaths(const std::string& themeDir)
+{
+    std::list<IconFinder::ThemeSubdirectory> searchPaths;
+    GError* error = nullptr;
+    auto gdir = g_dir_open(themeDir.c_str(), 0, &error);
+
+    if (error != nullptr)
+    {
+        g_debug("Unable to open directory '%s' becuase: %s", themeDir.c_str(), error->message);
+        g_error_free(error);
+        return searchPaths;
+    }
+
+    const gchar* dirname = nullptr;
+    while ((dirname = g_dir_read_name(gdir)) != nullptr)
+    {
+        auto fullPath = g_build_filename(themeDir.c_str(), dirname, "apps", nullptr);
+        /* Directories only */
+        if (g_file_test(fullPath, G_FILE_TEST_IS_DIR))
+        {
+            if (g_strcmp0(dirname, "scalable") == 0)
+            {
+                /* We don't really know what to do with scalable here, let's
+                   call them 256 images */
+                searchPaths.emplace_back(IconFinder::ThemeSubdirectory{fullPath, 256});
+                continue;
+            }
+
+            std::smatch match;
+            std::string dirstr(dirname);
+            /* We want it to match and have the same values for the first and second size */
+            if (std::regex_match(dirstr, match, iconSizeDirname))
+            {
+                searchPaths.emplace_back(IconFinder::ThemeSubdirectory{fullPath, std::atoi(match[1].str().c_str())});
+            }
+        }
+        g_free(fullPath);
+    }
+
+    g_dir_close(gdir);
+    return searchPaths;
+}
+
+/** Gets all the search paths, from either a theme file or just
+    looking at the directory. And possibly pixmaps as well */
+std::list<IconFinder::ThemeSubdirectory> IconFinder::getSearchPaths(const std::string& basePath)
+{
+    std::list<IconFinder::ThemeSubdirectory> iconPaths;
+
+    auto hicolorDir = g_build_filename(basePath.c_str(), HICOLOR_THEME_DIR, nullptr);
+    if (g_file_test(hicolorDir, G_FILE_TEST_IS_DIR))
+    {
+        /* If the directory exists, it could have icons of unknown size */
+        iconPaths.emplace_back(IconFinder::ThemeSubdirectory{hicolorDir, 1});
+
+        /* Now see if we can get directories from a theme file */
+        auto themeDirs = themeFileSearchPaths(basePath);
+        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(hicolorDir);
+            iconPaths.splice(iconPaths.end(), dirPaths);
+        }
+    }
+    g_free(hicolorDir);
+
+    /* Add root icons directory as potential path */
+    auto iconsPath = g_build_filename(basePath.c_str(), ICONS_DIR, nullptr);
+    if (g_file_test(iconsPath, G_FILE_TEST_IS_DIR))
+    {
+        iconPaths.emplace_back(IconFinder::ThemeSubdirectory{iconsPath, 1});
+    }
+    g_free(iconsPath);
+
+    /* Add the pixmaps path as a fallback if it exists */
+    auto pixmapsPath = g_build_filename(basePath.c_str(), PIXMAPS_PATH, nullptr);
+    if (g_file_test(pixmapsPath, G_FILE_TEST_IS_DIR))
+    {
+        iconPaths.emplace_back(IconFinder::ThemeSubdirectory{pixmapsPath, 1});
+    }
+    g_free(pixmapsPath);
+
+    // find icons sorted by size, highest to lowest
+    iconPaths.sort([](const ThemeSubdirectory& lhs, const ThemeSubdirectory& rhs) { return lhs.size > rhs.size; });
+    return iconPaths;
+}
+
+}  // namesapce app_launch
+}  // namespace ubuntu

=== added file 'libubuntu-app-launch/application-icon-finder.h'
--- libubuntu-app-launch/application-icon-finder.h	1970-01-01 00:00:00 +0000
+++ libubuntu-app-launch/application-icon-finder.h	2016-05-03 14:23:08 +0000
@@ -0,0 +1,89 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *     Larry Price <[e-mail]>
+ */
+
+#pragma once
+
+#include "application-info-desktop.h"
+#include <glib.h>
+#include <list>
+#include <map>
+#include <memory>
+
+namespace ubuntu
+{
+namespace app_launch
+{
+/** \brief Class to search for available application icons and select the best option.
+
+    This object attempts to find the highest resolution icon based on the freedesktop icon
+    theme specification found at:
+        https://standards.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html
+    It parses the theme file for the hicolor theme and identifies all possible directories
+    in the global scope and the local scope.
+*/
+class IconFinder
+{
+public:
+    /** Create an IconFinder
+
+        \param basePath the root directory to begin searching for themes
+    */
+    explicit IconFinder(std::string basePath);
+    virtual ~IconFinder() = default;
+
+    /** Find the optimal icon for the given icon name.
+
+        \param iconName name of or path to application icon
+    */
+    virtual Application::Info::IconPath find(const std::string& iconName);
+
+private:
+    /** \private */
+    struct ThemeSubdirectory
+    {
+        std::string path;
+        int size;
+    };
+
+    /** \private */
+    std::list<ThemeSubdirectory> _searchPaths;
+    /** \private */
+    std::string _basePath;
+
+    /** \private */
+    static bool hasImageExtension(const char* filename);
+    /** \private */
+    static std::string findExistingIcon(const std::string& path, const std::string& iconName);
+    /** \private */
+    static std::list<ThemeSubdirectory> validDirectories(const std::string& basePath, gchar* directory, int size);
+    /** \private */
+    static std::list<ThemeSubdirectory> addSubdirectoryByType(std::shared_ptr<GKeyFile> themefile,
+                                                              gchar* directory,
+                                                              const std::string& basePath);
+    /** \private */
+    static std::list<ThemeSubdirectory> searchIconPaths(std::shared_ptr<GKeyFile> themefile,
+                                                        gchar** directories,
+                                                        const std::string& basePath);
+    static std::list<ThemeSubdirectory> themeFileSearchPaths(const std::string& basePath);
+    static std::list<ThemeSubdirectory> themeDirSearchPaths(const std::string& basePath);
+    static std::list<ThemeSubdirectory> getSearchPaths(const std::string& basePath);
+};
+
+}  // namespace app_launch
+}  // namesapce ubuntu

=== modified file 'libubuntu-app-launch/application-impl-legacy.cpp'
--- libubuntu-app-launch/application-impl-legacy.cpp	2016-03-03 20:48:24 +0000
+++ libubuntu-app-launch/application-impl-legacy.cpp	2016-05-03 14:23:08 +0000
@@ -27,7 +27,7 @@
 namespace app_impls
 {
 
-std::shared_ptr<GKeyFile> keyfileForApp(const AppID::AppName& name);
+std::pair<std::string, std::shared_ptr<GKeyFile>> keyfileForApp(const AppID::AppName& name);
 
 void clear_keyfile(GKeyFile* keyfile)
 {
@@ -38,10 +38,12 @@
 }
 
 Legacy::Legacy(const AppID::AppName& appname,
+               const std::string& basedir,
                const std::shared_ptr<GKeyFile>& keyfile,
                const std::shared_ptr<Registry>& registry)
     : Base(registry)
     , _appname(appname)
+    , _basedir(basedir)
     , _keyfile(keyfile)
 {
     if (!_keyfile)
@@ -49,15 +51,20 @@
 }
 
 Legacy::Legacy(const AppID::AppName& appname, const std::shared_ptr<Registry>& registry)
-    : Legacy(appname, keyfileForApp(appname), registry)
+    : Base(registry)
+    , _appname(appname)
 {
+    std::tie(_basedir, _keyfile) = keyfileForApp(appname);
+
+    if (!_keyfile)
+        throw std::runtime_error{"Unable to find keyfile for legacy application: " + appname.value()};
 }
 
-std::shared_ptr<GKeyFile> keyfileForApp(const AppID::AppName& name)
+std::pair<std::string, std::shared_ptr<GKeyFile>> keyfileForApp(const AppID::AppName& name)
 {
     std::string desktopName = name.value() + ".desktop";
-    auto keyfilecheck = [desktopName](const gchar* dir) -> std::shared_ptr<GKeyFile> {
-        auto fullname = g_build_filename(dir, "applications", desktopName.c_str(), nullptr);
+    auto keyfilecheck = [desktopName](const std::string& dir) -> std::shared_ptr<GKeyFile> {
+        auto fullname = g_build_filename(dir.c_str(), "applications", desktopName.c_str(), nullptr);
         if (!g_file_test(fullname, G_FILE_TEST_EXISTS))
         {
             g_free(fullname);
@@ -80,20 +87,22 @@
         return keyfile;
     };
 
-    auto retval = keyfilecheck(g_get_user_data_dir());
+    std::string basedir = g_get_user_data_dir();
+    auto retval = keyfilecheck(basedir);
 
     auto systemDirs = g_get_system_data_dirs();
     for (auto i = 0; !retval && systemDirs[i] != nullptr; i++)
     {
-        retval = keyfilecheck(systemDirs[i]);
+        basedir = systemDirs[i];
+        retval = keyfilecheck(basedir);
     }
 
-    return retval;
+    return std::make_pair(basedir, retval);
 }
 
 std::shared_ptr<Application::Info> Legacy::info()
 {
-    return std::make_shared<app_info::Desktop>(_keyfile, "/usr/share/icons/");
+    return std::make_shared<app_info::Desktop>(_keyfile, _basedir, _registry, true);
 }
 
 std::list<std::shared_ptr<Application>> Legacy::list(const std::shared_ptr<Registry>& registry)

=== modified file 'libubuntu-app-launch/application-impl-legacy.h'
--- libubuntu-app-launch/application-impl-legacy.h	2016-02-10 15:27:10 +0000
+++ libubuntu-app-launch/application-impl-legacy.h	2016-05-03 14:23:08 +0000
@@ -35,6 +35,7 @@
 public:
     Legacy(const AppID::AppName& appname, const std::shared_ptr<Registry>& registry);
     Legacy(const AppID::AppName& appname,
+           const std::string& basedir,
            const std::shared_ptr<GKeyFile>& keyfile,
            const std::shared_ptr<Registry>& registry);
 
@@ -45,10 +46,11 @@
 
     std::shared_ptr<Info> info() override;
 
-    static std::list<std::shared_ptr<Application>> list(const std::shared_ptr<Registry> &registry);
+    static std::list<std::shared_ptr<Application>> list(const std::shared_ptr<Registry>& registry);
 
 private:
     AppID::AppName _appname;
+    std::string _basedir;
     std::shared_ptr<GKeyFile> _keyfile;
 };
 

=== modified file 'libubuntu-app-launch/application-impl-libertine.cpp'
--- libubuntu-app-launch/application-impl-libertine.cpp	2016-03-03 20:48:24 +0000
+++ libubuntu-app-launch/application-impl-libertine.cpp	2016-05-03 14:23:08 +0000
@@ -41,10 +41,17 @@
     {
         auto container_path = libertine_container_path(container.value().c_str());
         auto container_app_path = g_build_filename(container_path, "usr", "share", "applications",
-                                                   (appname.value() + ".desktop").c_str(), NULL);
+                                                   (appname.value() + ".desktop").c_str(), nullptr);
 
         _keyfile = keyfileFromPath(container_app_path);
 
+        if (_keyfile)
+        {
+            auto gbasedir = g_build_filename(container_path, "usr", "share", nullptr);
+            _basedir = gbasedir;
+            g_free(gbasedir);
+        }
+
         g_free(container_app_path);
         g_free(container_path);
     }
@@ -57,6 +64,13 @@
 
         _keyfile = keyfileFromPath(home_app_path);
 
+        if (_keyfile)
+        {
+            auto gbasedir = g_build_filename(home_path, ".local", "share", nullptr);
+            _basedir = gbasedir;
+            g_free(gbasedir);
+        }
+
         g_free(home_app_path);
         g_free(home_path);
     }
@@ -119,7 +133,7 @@
 
 std::shared_ptr<Application::Info> Libertine::info()
 {
-    return std::make_shared<app_info::Desktop>(_keyfile, libertine_container_path(_container.value().c_str()));
+    return std::make_shared<app_info::Desktop>(_keyfile, _basedir, _registry);
 }
 
 };  // namespace app_impls

=== modified file 'libubuntu-app-launch/application-impl-libertine.h'
--- libubuntu-app-launch/application-impl-libertine.h	2016-02-10 15:38:21 +0000
+++ libubuntu-app-launch/application-impl-libertine.h	2016-05-03 14:23:08 +0000
@@ -36,7 +36,7 @@
               const AppID::AppName& appname,
               const std::shared_ptr<Registry>& registry);
 
-    static std::list<std::shared_ptr<Application>> list(const std::shared_ptr<Registry> &registry);
+    static std::list<std::shared_ptr<Application>> list(const std::shared_ptr<Registry>& registry);
 
     AppID appId() override
     {
@@ -49,6 +49,7 @@
     AppID::Package _container;
     AppID::AppName _appname;
     std::shared_ptr<GKeyFile> _keyfile;
+    std::string _basedir;
 };
 
 };  // namespace app_impls

=== modified file 'libubuntu-app-launch/application-info-desktop.cpp'
--- libubuntu-app-launch/application-info-desktop.cpp	2016-05-03 14:23:08 +0000
+++ libubuntu-app-launch/application-info-desktop.cpp	2016-05-03 14:23:08 +0000
@@ -18,6 +18,8 @@
  */
 
 #include "application-info-desktop.h"
+#include "application-icon-finder.h"
+#include "registry-impl.h"
 #include <cstdlib>
 
 namespace ubuntu
@@ -38,7 +40,7 @@
 
 struct NoDisplayTag;
 typedef TypeTagger<NoDisplayTag, bool> NoDisplay;
-} // anonymous namespace
+}  // anonymous namespace
 
 template <typename T>
 auto stringFromKeyfile(std::shared_ptr<GKeyFile> keyfile, const std::string& key, const std::string& exceptionText = {})
@@ -134,8 +136,8 @@
     auto results = g_key_file_get_string_list(keyfile.get(), DESKTOP_GROUP, key, nullptr, &error);
     if (error != nullptr)
     {
-      g_error_free(error);
-      return defaultValue;
+        g_error_free(error);
+        return defaultValue;
     }
 
     bool result = false;
@@ -152,8 +154,11 @@
     return result;
 }
 
-Desktop::Desktop(std::shared_ptr<GKeyFile> keyfile, const std::string& basePath)
-    : _keyfile([keyfile]() {
+Desktop::Desktop(std::shared_ptr<GKeyFile> keyfile,
+                 const std::string& basePath,
+                 std::shared_ptr<Registry> registry,
+                 bool allowNoDisplay)
+    : _keyfile([keyfile, allowNoDisplay]() {
         if (!keyfile)
         {
             throw std::runtime_error("Can not build a desktop application info object with a null keyfile");
@@ -162,7 +167,7 @@
         {
             throw std::runtime_error("Keyfile does not represent application type");
         }
-        if (boolFromKeyfile<NoDisplay>(keyfile, "NoDisplay", false).value())
+        if (boolFromKeyfile<NoDisplay>(keyfile, "NoDisplay", false).value() && !allowNoDisplay)
         {
             throw std::runtime_error("Application is not meant to be displayed");
         }
@@ -171,10 +176,13 @@
             throw std::runtime_error("Application keyfile is hidden");
         }
         auto xdg_current_desktop = getenv("XDG_CURRENT_DESKTOP");
-        if (stringlistFromKeyfileContains(keyfile, "NotShowIn", xdg_current_desktop, false)
-                 || !stringlistFromKeyfileContains(keyfile, "OnlyShowIn", xdg_current_desktop, true))
+        if (xdg_current_desktop != nullptr)
         {
-            throw std::runtime_error("Application is not shown in Unity");
+            if (stringlistFromKeyfileContains(keyfile, "NotShowIn", xdg_current_desktop, false) ||
+                !stringlistFromKeyfileContains(keyfile, "OnlyShowIn", xdg_current_desktop, true))
+            {
+                throw std::runtime_error("Application is not shown in Unity");
+            }
         }
 
         return keyfile;
@@ -182,8 +190,15 @@
     , _basePath(basePath)
     , _name(stringFromKeyfile<Application::Info::Name>(keyfile, "Name", "Unable to get name from keyfile"))
     , _description(stringFromKeyfile<Application::Info::Description>(keyfile, "Comment"))
-    , _iconPath(
-          fileFromKeyfile<Application::Info::IconPath>(keyfile, basePath, "Icon", "Missing icon for desktop file"))
+    , _iconPath([keyfile, basePath, registry]() {
+        if (registry != nullptr)
+        {
+            auto iconName =
+                stringFromKeyfile<Application::Info::IconPath>(keyfile, "Icon", "Missing icon for desktop file");
+            return registry->impl->getIconFinder(basePath)->find(iconName);
+        }
+        return fileFromKeyfile<Application::Info::IconPath>(keyfile, basePath, "Icon", "Missing icon for desktop file");
+    }())
     , _splashInfo({
         title : stringFromKeyfile<Application::Info::Splash::Title>(keyfile, "X-Ubuntu-Splash-Title"),
         image : fileFromKeyfile<Application::Info::Splash::Image>(keyfile, basePath, "X-Ubuntu-Splash-Image"),

=== modified file 'libubuntu-app-launch/application-info-desktop.h'
--- libubuntu-app-launch/application-info-desktop.h	2016-02-10 22:04:00 +0000
+++ libubuntu-app-launch/application-info-desktop.h	2016-05-03 14:23:08 +0000
@@ -33,7 +33,10 @@
 class Desktop : public Application::Info
 {
 public:
-    Desktop(std::shared_ptr<GKeyFile> keyfile, const std::string& basePath);
+    Desktop(std::shared_ptr<GKeyFile> keyfile,
+            const std::string& basePath,
+            std::shared_ptr<Registry> registry = nullptr,
+            bool allowNoDisplay = false);
 
     const Application::Info::Name& name() override
     {

=== modified file 'libubuntu-app-launch/application.cpp'
--- libubuntu-app-launch/application.cpp	2016-04-27 14:22:39 +0000
+++ libubuntu-app-launch/application.cpp	2016-05-03 14:23:08 +0000
@@ -75,10 +75,8 @@
 {
 }
 
-/* These are the Regex's taken from the Click Reviewer Tools
-   on Jan 16, 2016 revision 566 */
 #define REGEX_PKGNAME "([a-z0-9][a-z0-9+.-]+)"
-#define REGEX_APPNAME "([A-Za-z0-9+-.:~-]+)"
+#define REGEX_APPNAME "([A-Za-z0-9+-.:~-][\\sA-Za-z0-9+-.:~-]+)"
 #define REGEX_VERSION "([\\d+:]?[A-Za-z0-9.+:~-]+?(?:-[A-Za-z0-9+.~]+)?)"
 
 const std::regex full_appid_regex("^" REGEX_PKGNAME "_" REGEX_APPNAME "_" REGEX_VERSION "$");

=== modified file 'libubuntu-app-launch/application.h'
--- libubuntu-app-launch/application.h	2016-04-19 02:14:03 +0000
+++ libubuntu-app-launch/application.h	2016-05-03 14:23:08 +0000
@@ -38,7 +38,7 @@
 /** \brief Class to represent an application, whether running or not, and
         query more information about it.
 
-    Generally the Application object represnts an Application in the system. It
+    Generally the Application object represents an Application in the system. It
     hooks up all of it's signals, finds out information about it and controls
     whether it is running or not. This class is what most users of Ubuntu App
     Launch will do the majority of their work.

=== modified file 'libubuntu-app-launch/registry-impl.cpp'
--- libubuntu-app-launch/registry-impl.cpp	2016-03-03 20:48:24 +0000
+++ libubuntu-app-launch/registry-impl.cpp	2016-05-03 14:23:08 +0000
@@ -18,6 +18,7 @@
  */
 
 #include "registry-impl.h"
+#include "application-icon-finder.h"
 
 namespace ubuntu
 {
@@ -34,6 +35,7 @@
                  _dbus.reset();
              })
     , _registry(registry)
+    , _iconFinders()
 // _manager(nullptr)
 {
     auto cancel = thread.getCancellable();
@@ -162,6 +164,15 @@
     });
 }
 
+std::shared_ptr<IconFinder> Registry::Impl::getIconFinder(std::string basePath)
+{
+    if (_iconFinders.find(basePath) == _iconFinders.end())
+    {
+        _iconFinders[basePath] = std::make_shared<IconFinder>(basePath);
+    }
+    return _iconFinders[basePath];
+}
+
 #if 0
 void
 Registry::Impl::setManager (Registry::Manager* manager)

=== modified file 'libubuntu-app-launch/registry-impl.h'
--- libubuntu-app-launch/registry-impl.h	2016-04-18 18:29:32 +0000
+++ libubuntu-app-launch/registry-impl.h	2016-05-03 14:23:08 +0000
@@ -17,12 +17,12 @@
  *     Ted Gould <[e-mail]>
  */
 
+#include "glib-thread.h"
 #include "registry.h"
-#include "glib-thread.h"
-
-#include <json-glib/json-glib.h>
 #include <click.h>
 #include <gio/gio.h>
+#include <json-glib/json-glib.h>
+#include <unordered_map>
 
 #pragma once
 
@@ -31,6 +31,8 @@
 namespace app_launch
 {
 
+class IconFinder;
+
 /** \private
     \brief Private implementation of the Registry object
 
@@ -55,6 +57,8 @@
 
     GLib::ContextThread thread;
 
+    std::shared_ptr<IconFinder> getIconFinder(std::string basePath);
+
 private:
     Registry* _registry;
 #if 0
@@ -67,6 +71,8 @@
     std::shared_ptr<GDBusConnection> _dbus;
 
     void initClick();
+
+    std::unordered_map<std::string, std::shared_ptr<IconFinder>> _iconFinders;
 };
 
 };  // namespace app_launch

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2016-02-17 21:56:34 +0000
+++ tests/CMakeLists.txt	2016-05-03 14:23:08 +0000
@@ -1,4 +1,3 @@
-
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
 
 configure_file ("click-db-dir/test.conf.in" "${CMAKE_CURRENT_BINARY_DIR}/click-db-dir/test.conf" @ONLY)
@@ -60,12 +59,32 @@
 # Application Info Desktop
 
 add_executable (application-info-desktop-test
-	application-info-desktop.cpp
-	${CMAKE_SOURCE_DIR}/libubuntu-app-launch/application-info-desktop.cpp)
+  # test
+  application-info-desktop.cpp
+
+  # sources
+  ${CMAKE_SOURCE_DIR}/libubuntu-app-launch/application-info-desktop.cpp
+  ${CMAKE_SOURCE_DIR}/libubuntu-app-launch/application-icon-finder.cpp
+  ${CMAKE_SOURCE_DIR}/libubuntu-app-launch/glib-thread.cpp
+  ${CMAKE_SOURCE_DIR}/libubuntu-app-launch/registry-impl.cpp)
 target_link_libraries (application-info-desktop-test gtest ${GTEST_LIBS} ubuntu-launcher)
 
 add_test (NAME application-info-desktop-test COMMAND application-info-desktop-test)
 
+# Application Icon Finder
+
+add_executable (application-icon-finder-test
+  # test
+  application-icon-finder.cpp
+
+  #sources
+  ${CMAKE_SOURCE_DIR}/libubuntu-app-launch/application-icon-finder.cpp)
+target_link_libraries (application-icon-finder-test gtest ${GTEST_LIBS} ubuntu-launcher)
+
+add_test (NAME application-icon-finder-test COMMAND application-icon-finder-test)
+
+file(COPY data DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+
 # Failure Test
 
 add_definitions ( -DAPP_FAILED_TOOL="${CMAKE_BINARY_DIR}/application-failed" )

=== added file 'tests/application-icon-finder.cpp'
--- tests/application-icon-finder.cpp	1970-01-01 00:00:00 +0000
+++ tests/application-icon-finder.cpp	2016-05-03 14:23:08 +0000
@@ -0,0 +1,93 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *     Larry Price <[e-mail]>
+ */
+
+#include "application-icon-finder.h"
+#include <gtest/gtest.h>
+
+using namespace ubuntu::app_launch;
+
+TEST(ApplicationIconFinder, ReturnsEmptyWhenNoThemeFileAvailable)
+{
+    IconFinder finder("/tmp/please/dont/put/stuff/here");
+    EXPECT_TRUE(finder.find("app").value().empty());
+}
+
+TEST(ApplicationIconFinder, ReturnsEmptyWhenNoAppIconFound)
+{
+    auto basePath = std::string(CMAKE_SOURCE_DIR) + "/data";
+    IconFinder finder(basePath);
+    EXPECT_TRUE(finder.find("app_unknown").value().empty());
+}
+
+TEST(ApplicationIconFinder, ReturnsLargestAvailableIcon)
+{
+    auto basePath = std::string(CMAKE_SOURCE_DIR) + "/data/usr/share";
+    IconFinder finder(basePath);
+    EXPECT_EQ(basePath + "/icons/hicolor/24x24/apps/app.xpm", finder.find("app").value());
+}
+
+TEST(ApplicationIconFinder, ReturnsLargestAvailableIconIncludingLocalIcons)
+{
+    auto basePath = std::string(CMAKE_SOURCE_DIR) + "/data/home/test/.local/share";
+    IconFinder finder(basePath);
+    EXPECT_EQ(basePath + "/icons/hicolor/32x32/apps/steam_123456.png", finder.find("steam_123456").value());
+}
+
+TEST(ApplicationIconFinder, ReturnsIconAsDirectlyGiven)
+{
+    auto basePath = std::string(CMAKE_SOURCE_DIR) + "/data/usr/share";
+    IconFinder finder(basePath);
+    EXPECT_EQ(basePath + "/icons/hicolor/scalable/apps/app.svg",
+              finder.find(basePath + "/icons/hicolor/scalable/apps/app.svg").value());
+}
+
+TEST(ApplicationIconFinder, ReturnsIconFromPixmapAsFallback)
+{
+    auto basePath = std::string(CMAKE_SOURCE_DIR) + "/data/usr/share";
+    IconFinder finder(basePath);
+    EXPECT_EQ(basePath + "/pixmaps/app2.png", finder.find("app2.png").value());
+}
+
+TEST(ApplicationIconFinder, ReturnsIconFromRootThemeDirectory)
+{
+    auto basePath = std::string(CMAKE_SOURCE_DIR) + "/data/usr/share";
+    IconFinder finder(basePath);
+    EXPECT_EQ(basePath + "/icons/hicolor/app4.png", finder.find("app4.png").value());
+}
+
+TEST(ApplicationIconFinder, ReturnsIconFromRootIconsDirectory)
+{
+    auto basePath = std::string(CMAKE_SOURCE_DIR) + "/data/usr/share";
+    IconFinder finder(basePath);
+    EXPECT_EQ(basePath + "/icons/app5.png", finder.find("app5.png").value());
+}
+
+TEST(ApplicationIconFinder, ReturnsThresholdIconBasedOnGap)
+{
+    auto basePath = std::string(CMAKE_SOURCE_DIR) + "/data/usr/share";
+    IconFinder finder(basePath);
+    EXPECT_EQ(basePath + "/icons/hicolor/22x22/apps/app1.png", finder.find("app1.png").value());
+}
+
+TEST(ApplicationIconFinder, IgnoresDirectoriesWithJunkSize)
+{
+    auto basePath = std::string(CMAKE_SOURCE_DIR) + "/data/usr/share";
+    IconFinder finder(basePath);
+    EXPECT_EQ(basePath + "/icons/hicolor/16x16/apps/app3.png", finder.find("app3.png").value());
+}

=== added directory 'tests/data'
=== added directory 'tests/data/home'
=== added directory 'tests/data/home/test'
=== added directory 'tests/data/home/test/.local'
=== added directory 'tests/data/home/test/.local/share'
=== added directory 'tests/data/home/test/.local/share/icons'
=== added directory 'tests/data/home/test/.local/share/icons/hicolor'
=== added directory 'tests/data/home/test/.local/share/icons/hicolor/32x32'
=== added directory 'tests/data/home/test/.local/share/icons/hicolor/32x32/apps'
=== added file 'tests/data/home/test/.local/share/icons/hicolor/32x32/apps/steam_123456.png'
=== added directory 'tests/data/usr'
=== added directory 'tests/data/usr/share'
=== added directory 'tests/data/usr/share/icons'
=== added file 'tests/data/usr/share/icons/app5.png'
=== added directory 'tests/data/usr/share/icons/hicolor'
=== added directory 'tests/data/usr/share/icons/hicolor/16x16'
=== added directory 'tests/data/usr/share/icons/hicolor/16x16/actions'
=== added file 'tests/data/usr/share/icons/hicolor/16x16/actions/app.png'
=== added directory 'tests/data/usr/share/icons/hicolor/16x16/apps'
=== added file 'tests/data/usr/share/icons/hicolor/16x16/apps/app.png'
=== added file 'tests/data/usr/share/icons/hicolor/16x16/apps/app3.png'
=== added file 'tests/data/usr/share/icons/hicolor/16x16/apps/steam_123456.png'
=== added directory 'tests/data/usr/share/icons/hicolor/20x20'
=== added directory 'tests/data/usr/share/icons/hicolor/20x20/apps'
=== added file 'tests/data/usr/share/icons/hicolor/20x20/apps/app3.png'
=== added directory 'tests/data/usr/share/icons/hicolor/22x22'
=== added directory 'tests/data/usr/share/icons/hicolor/22x22/apps'
=== added file 'tests/data/usr/share/icons/hicolor/22x22/apps/app1.png'
=== added directory 'tests/data/usr/share/icons/hicolor/23x23'
=== added directory 'tests/data/usr/share/icons/hicolor/23x23/apps'
=== added directory 'tests/data/usr/share/icons/hicolor/24x24'
=== added directory 'tests/data/usr/share/icons/hicolor/24x24/apps'
=== added file 'tests/data/usr/share/icons/hicolor/24x24/apps/app.xpm'
=== added directory 'tests/data/usr/share/icons/hicolor/25x25'
=== added directory 'tests/data/usr/share/icons/hicolor/25x25/apps'
=== added file 'tests/data/usr/share/icons/hicolor/25x25/apps/app.png'
=== added directory 'tests/data/usr/share/icons/hicolor/32x32'
=== added directory 'tests/data/usr/share/icons/hicolor/32x32/apps'
=== added file 'tests/data/usr/share/icons/hicolor/32x32/apps/app1.png'
=== added file 'tests/data/usr/share/icons/hicolor/app4.png'
=== added file 'tests/data/usr/share/icons/hicolor/index.theme'
--- tests/data/usr/share/icons/hicolor/index.theme	1970-01-01 00:00:00 +0000
+++ tests/data/usr/share/icons/hicolor/index.theme	2016-05-03 14:23:08 +0000
@@ -0,0 +1,48 @@
+[Icon Theme]
+Directories=16x16/actions,16x16/apps,16x16/stock,20x20/apps,22x22/apps,23x23/apps,scalable/apps,24x24/apps,25x25/apps,32x32/apps
+
+[16x16/actions]
+Size=16
+Context=Actions
+Type=Threshold
+
+[16x16/apps]
+Size=16
+Context=Applications
+Type=Threshold
+
+[20x20/apps]
+Size=junk
+Context=Applications
+Type=Fixed
+
+[22x22/apps]
+Size=22
+Threshold=10
+Type=Threshold
+Context=Applications
+
+[23x23/apps]
+MaxSize=junk
+Context=Applications
+Type=scalable
+
+[scalable/apps]
+MaxSize=24
+Context=Applications
+Type=Scalable
+
+[24x24/apps]
+Size=24
+Context=Applications
+Type=Threshold
+
+[25x25/apps]
+Size=25
+Context=Applications
+Type=Fixed
+
+[32x32/apps]
+Size=32
+Context=Applications
+Type=Fixed

=== added directory 'tests/data/usr/share/icons/hicolor/scalable'
=== added directory 'tests/data/usr/share/icons/hicolor/scalable/apps'
=== added file 'tests/data/usr/share/icons/hicolor/scalable/apps/app.svg'
=== added directory 'tests/data/usr/share/pixmaps'
=== added file 'tests/data/usr/share/pixmaps/app2.png'