QTIconManager.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Widgets
File: QTIconManager
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/SoftwareService.h>
#include <NDEVR/Buffer.h>
#include <NDEVR/String.h>
#include <NDEVR/File.h>
#include <NDEVR/Dictionary.h>
#include <NDEVR/RGBColor.h>
#include <NDEVR/LABColor.h>
#include <NDEVR/Resource.h>
#include <NDEVR/TranslatedString.h>
#include <NDEVR/UUID.h>
#include <NDEVR/Pointer.h>
#include <qiconengine.h>
#include <QTransform>
#include <QIcon>
#include <QPointer>
class QImage;
class QPixmap;
class QIcon;
class QWidget;
namespace NDEVR
{
    class Log;
    class HSBColor;
    struct NDEVR_WIDGETS_API IconThemeDisplaySettings
    {
        TranslatedString theme_name; 
        String theme_icon; 
        String theme_icon_location; 
    };

    struct NDEVR_WIDGETS_API IconThemeSettings
    {
        IconThemeSettings();
        void setup(const TranslatedString& name, const StringView& theme_icon, const StringView& theme_icon_location);
        const IconThemeDisplaySettings& displaySettings() const;
        IconThemeDisplaySettings& displaySettings();
        UUID id = Constant<UUID>::Invalid; 
        RGBColor highlight_color; 
        RGBColor primary_color; 
        RGBColor secondary_color; 
        RGBColor accent_color; 
        RGBColor outline_color; 
        fltp08 pixel_size; 
        bool colorize_svgs; 
        bool blend_color; 
        bool operator==(const IconThemeSettings& settings) const;
        bool operator!=(const IconThemeSettings& settings) const;
    private:
        mutable DynamicPointer<IconThemeDisplaySettings> m_theme_display_settings; 
    };

    class NDEVRIconEngine : public SoftwareServiceManager
    {
    public:
        NDEVRIconEngine(const UUID& id)
            : m_id(id)
        {}

        [[nodiscard]] virtual QIcon createIcon(const StringView& icon, const IconThemeSettings& theme, QIcon::Mode mode = QIcon::Mode::Normal) = 0;
        [[nodiscard]] virtual bool canProcess(const StringView& icon, const IconThemeSettings& theme, QIcon::Mode mode) const = 0;
        [[nodiscard]] UUID id() const { return m_id; }
 
    private:
        UUID m_id; 
    };

    class NDEVR_WIDGETS_API DeferredImageIconEngine : public QIconEngine
    {
    public:
        DeferredImageIconEngine(const StringView& icon,  QIcon::Mode mode = QIcon::Mode::Normal);
        ~DeferredImageIconEngine();
        void setIconTheme(const IconThemeSettings theme);
        void setIcon(const StringView& icon);
        virtual void paint(QPainter* painter, const QRect& rect, QIcon::Mode mode, QIcon::State state) override;
        virtual QPixmap pixmap(const QSize& size, QIcon::Mode mode, QIcon::State state) override;
        virtual QIconEngine* clone(void) const override;
        QSize actualSize(const QSize& size, QIcon::Mode mode, QIcon::State state) override;
    public:
        QPixmap m_cached_pixmap; 
        String m_icon; 
        QIcon::Mode m_override_mode; 
        mutable QSize m_default_size; 
    };

    class PixmapResolver : public SoftwareService
    {
    public:
        virtual bool canPotentiallyResolve(const StringView& pixmap_resource) = 0;
        virtual QPixmap resolve(const StringView& pixmap_resource, QIcon::Mode mode, const QSize& requested_size, Dictionary<UUID, QPixmap>& pixmaps) = 0;
        virtual bool requestSet(const StringView& pixmap_resource, QPixmap map, QIcon::Mode mode) = 0;
        virtual UUID id() const = 0;
    };

    class NDEVR_WIDGETS_API QTIconManager
    {
        friend class NDEVRSVGIconEngine;
        friend class DeferredImageIconEngine;
    public:
        static void SetLightingTheme(const IconThemeSettings& theme);
        static void SetOverrideTheme(IconThemeSettings* theme);
        static void GetIconResource(const std::function<void(const StringView&, const QIcon&)>& on_finished, const StringView& icon, QIcon::Mode mode = QIcon::Mode::Normal);
        static void GetIconResource(const std::function<void(const StringView&, const QIcon&)>& on_finished, const StringView& icon, const IconThemeSettings& theme, QIcon::Mode mode = QIcon::Mode::Normal);
        static void GetPixmapResource(const std::function<void(const StringView&, const QPixmap&)>& on_finished, const StringView& pixmap, QIcon::Mode mode = QIcon::Mode::Normal, const QSize& requested_size = QSize());
        static QIcon GetIconResourceBlocking(const StringView& icon, QIcon::Mode mode = QIcon::Mode::Normal);
        static QIcon GetIconResourceBlocking(const StringView& icon, const IconThemeSettings& theme, QIcon::Mode mode = QIcon::Mode::Normal);
        static QPixmap LocalPixmapResource(const StringView& pixmap, QIcon::Mode mode = QIcon::Mode::Normal, const QSize& requested_size = QSize());
        static bool RequestSet(const StringView& pixmap_resource, QPixmap map, QIcon::Mode mode = QIcon::Mode::Normal);
        static void PostIconResourceLoad(const StringView& id);
        static void SetWindowIcon(const StringView& s, QWidget* widget);
        static void ClearWindowIcon(QWidget* widget);
        static Buffer<std::pair<LABColor, LABColor>> ConvertColorPalette(const Buffer<std::pair<RGBColor, RGBColor>>& palette);
        static void ConvertColorTheme(const Buffer<std::pair<RGBColor, RGBColor>>& colors, const Buffer<File>& in, const File& out_location, bool preserve_brightness, bool preserve_alpha, Log* log = nullptr);
        static void ConvertColorTheme(const Buffer<std::pair<RGBColor, RGBColor>>& colors, const File& in_location, const File& out_location, bool preserve_brightness, bool preserve_alpha, Log* log = nullptr);
        static void ConvertColorTheme(const Buffer<std::pair<LABColor, LABColor>>& color, QImage& image, bool preserve_brightness, bool preserve_alpha);
        static QImage AutoCrop(const QImage& pixmap, int margin = 0, bool preserve_ratio = false);
        static const QPixmap& disabledPixmap(const StringView& icon_name);
        static QImage FillBackground(const QImage& pixmap, RGBColor color);
        static QImage CleanupImageForIcon(const QImage& image);
        static const Buffer<IconThemeSettings>& iconThemes();
        static void addIconTheme(const IconThemeSettings& theme);
        static const IconThemeSettings& EffectiveIconTheme();
        static Resource<IconThemeSettings*> s_overide_icon_theme; 
        static Resource<IconThemeSettings> s_icon_theme; 
        static const IconThemeSettings& OutlineIconTheme();
        static const IconThemeSettings& NDEVRIconTheme();
        static constexpr const char* NDEVRThemeLocation() { return "NDEVR Icons/"; }
        static void AddIconEngine(NDEVRIconEngine* engine);
        static String GetSVGPath(const StringView& icon, const IconThemeSettings& theme);
        static String IconCacheLocation(const StringView& icon, const IconThemeSettings& theme);
        static String ImageCacheLocation(const StringView& icon);
        static void AddResolver(PixmapResolver* resolver);
    protected:
        static File GetImagePath(const StringView& icon);
        static QIcon icon(const StringView& icon, QIcon::Mode mode = QIcon::Mode::Normal);
        static QIcon icon(const StringView& icon, const IconThemeSettings& theme, QIcon::Mode mode = QIcon::Mode::Normal);
        static QPixmap pixmap(const StringView& pixmap, QIcon::Mode mode = QIcon::Mode::Normal, const QSize& requested_size = QSize());
    private:
        static Dictionary<UUID, Buffer<std::function<void(const StringView&, const QIcon&)>*>> s_download_waiters; 
        static Dictionary<UUID, PixmapResolver*> s_resolvers; 
        static Dictionary<QWidget*, String> s_window_registered; 
        static Dictionary<UUID, QIcon> s_icon_dictionary; 
        static Dictionary<UUID, QPixmap> s_pixmap_dictionary; 
        static Dictionary<UUID, QPixmap> s_disabled_pixmap_dictionary; 
        static Dictionary<UUID, NDEVRIconEngine*> s_icon_engines; 
        static Buffer<IconThemeSettings> s_icon_themes; 
    };
    NDEVR_WIDGETS_T_API template class NDEVR_WIDGETS_API StringStream<IconThemeSettings>;
}