image.hpp

Go to the documentation of this file.

/*
    Copyright 2019 WerWolv
    Copyright 2019 p-sam
    Copyright 2020-2021 natinusala
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
 
        http://www.apache.org/licenses/LICENSE-2.0
 
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/
 
#pragma once
 
#include <memory>
#include <aurore/core/event.hpp>
#include <aurore/core/theme.hpp>
#include <aurore/core/view.hpp>
 
namespace aurore
{
 
enum class ImageScalingType
{
    FIT,
    FILL,
    STRETCH,
    CENTER,
};
 
enum class ImageInterpolation
{
    LINEAR,
    NEAREST
};
 
enum class ImageAlignment
{
    TOP,
    RIGHT,
    BOTTOM,
    LEFT,
    CENTER,
};
 
class Image : public View
{
  public:
    Image();
    ~Image();
 
    void draw(NVGcontext* vg, float x, float y, float width, float height, Style style, FrameContext* ctx) override;
    void onLayout() override;
 
    void setInterpolation(ImageInterpolation interpolation);
 
    void setImageFromRes(const std::string& name);
 
    void setImageFromFile(const std::string& path);
 
    void setImageFromFileAsync(const std::string& path);
 
    void setImageFromMem(const unsigned char* data, int size);
 
    void setImageFromRGBA(const unsigned char* pixels, int width, int height);
 
    void setThemeImage(const std::string& key);
    const std::string& getThemeImage() const { return this->themeImageKey; }
 
    virtual void innerSetImage(int texture);
 
    void setImageAsync(std::function<void(std::function<void(const std::string&, size_t length)>)> cb);
 
    void clear();
 
    void setScalingType(ImageScalingType scalingType);
 
    ImageScalingType getScalingType();
 
    void setImageAlign(ImageAlignment align);
 
    void setFreeTexture(bool value);
    bool getFreeTexture();
 
    int getTexture();
    float getOriginalImageWidth();
    float getOriginalImageHeight();
 
    static View* create();
 
  protected:
    ImageScalingType scalingType     = ImageScalingType::FIT;
    ImageAlignment align             = ImageAlignment::CENTER;
    ImageInterpolation interpolation = ImageInterpolation::LINEAR;
 
    int texture = 0;
 
    NVGpaint paint;
 
    void invalidateImageBounds();
    int getImageFlags();
    size_t checkCache(const std::string& path);
 
    float originalImageWidth  = 0;
    float originalImageHeight = 0;
 
    float imageX      = 0;
    float imageY      = 0;
    float imageHeight = 0;
    float imageWidth  = 0;
 
    bool freeTexture = true;
 
    unsigned asyncGeneration = 0;
 
    void releaseTexture();
 
  private:
    std::string themeImageKey;
    std::shared_ptr<ThemeImage> themeImage;
    std::shared_ptr<ThemeImage> themeImagePending;
    bool settingThemeImage = false;
    bool followingTheme    = false;
    std::shared_ptr<char> themeToken;
    Event<ThemeVariant>::Subscription themeChanged;
    Event<const ThemeImage*>::Subscription themeImageLoaded;
    void refreshThemeImage();
    void stopFollowingTheme();
};
 
} // namespace aurore