Program Listing for File slint_image_internal.h
↰ Return to documentation for file (cppdocs/generated_include/slint_image_internal.h
)
#pragma once
/* Generated with cbindgen:0.24.3 */
#include <cstdarg>
#include <cstdint>
#include <cstdlib>
#include <ostream>
#include <new>
#include "slint_enums_internal.h"
namespace slint::cbindgen_private { struct ParsedSVG{}; struct HTMLImage{}; using namespace vtable; }
namespace slint {
namespace cbindgen_private {
namespace types {
enum class PixelFormat : uint8_t {
Rgb,
Rgba,
RgbaPremultiplied,
AlphaMap,
};
struct ImageCacheKey {
enum class Tag {
Invalid,
Path,
URL,
EmbeddedData,
};
struct Path_Body {
SharedString _0;
bool operator==(const Path_Body& other) const {
return _0 == other._0;
}
bool operator!=(const Path_Body& other) const {
return _0 != other._0;
}
};
struct URL_Body {
SharedString _0;
bool operator==(const URL_Body& other) const {
return _0 == other._0;
}
bool operator!=(const URL_Body& other) const {
return _0 != other._0;
}
};
struct EmbeddedData_Body {
uintptr_t _0;
bool operator==(const EmbeddedData_Body& other) const {
return _0 == other._0;
}
bool operator!=(const EmbeddedData_Body& other) const {
return _0 != other._0;
}
};
Tag tag;
union {
Path_Body path;
URL_Body url;
EmbeddedData_Body embedded_data;
};
static ImageCacheKey Invalid() {
ImageCacheKey result;
result.tag = Tag::Invalid;
return result;
}
bool IsInvalid() const {
return tag == Tag::Invalid;
}
static ImageCacheKey Path(const SharedString &_0) {
ImageCacheKey result;
::new (&result.path._0) (SharedString)(_0);
result.tag = Tag::Path;
return result;
}
bool IsPath() const {
return tag == Tag::Path;
}
static ImageCacheKey URL(const SharedString &_0) {
ImageCacheKey result;
::new (&result.url._0) (SharedString)(_0);
result.tag = Tag::URL;
return result;
}
bool IsURL() const {
return tag == Tag::URL;
}
static ImageCacheKey EmbeddedData(const uintptr_t &_0) {
ImageCacheKey result;
::new (&result.embedded_data._0) (uintptr_t)(_0);
result.tag = Tag::EmbeddedData;
return result;
}
bool IsEmbeddedData() const {
return tag == Tag::EmbeddedData;
}
bool operator==(const ImageCacheKey& other) const {
if (tag != other.tag) {
return false;
}
switch (tag) {
case Tag::Path: return path == other.path;
case Tag::URL: return url == other.url;
case Tag::EmbeddedData: return embedded_data == other.embedded_data;
default: break;
}
return true;
}
bool operator!=(const ImageCacheKey& other) const {
return !(*this == other);
}
private:
ImageCacheKey() {
}
public:
~ImageCacheKey() {
switch (tag) {
case Tag::Path: path.~Path_Body(); break;
case Tag::URL: url.~URL_Body(); break;
case Tag::EmbeddedData: embedded_data.~EmbeddedData_Body(); break;
default: break;
}
}
ImageCacheKey(const ImageCacheKey& other)
: tag(other.tag) {
switch (tag) {
case Tag::Path: ::new (&path) (Path_Body)(other.path); break;
case Tag::URL: ::new (&url) (URL_Body)(other.url); break;
case Tag::EmbeddedData: ::new (&embedded_data) (EmbeddedData_Body)(other.embedded_data); break;
default: break;
}
}
ImageCacheKey& operator=(const ImageCacheKey& other) {
if (this != &other) {
this->~ImageCacheKey();
new (this) ImageCacheKey(other);
}
return *this;
}
};
struct Rgb8Pixel {
uint8_t r;
uint8_t g;
uint8_t b;
bool operator==(const Rgb8Pixel& other) const {
return r == other.r &&
g == other.g &&
b == other.b;
}
bool operator!=(const Rgb8Pixel& other) const {
return r != other.r ||
g != other.g ||
b != other.b;
}
};
template<typename Pixel>
struct SharedPixelBuffer {
uint32_t width;
uint32_t height;
uint32_t stride;
SharedVector<Pixel> data;
bool operator==(const SharedPixelBuffer& other) const {
return width == other.width &&
height == other.height &&
stride == other.stride &&
data == other.data;
}
bool operator!=(const SharedPixelBuffer& other) const {
return width != other.width ||
height != other.height ||
stride != other.stride ||
data != other.data;
}
};
struct Rgba8Pixel {
uint8_t r;
uint8_t g;
uint8_t b;
bool operator==(const Rgba8Pixel& other) const {
return r == other.r &&
g == other.g &&
b == other.b;
}
bool operator!=(const Rgba8Pixel& other) const {
return r != other.r ||
g != other.g ||
b != other.b;
}
};
struct SharedImageBuffer {
enum class Tag {
RGB8,
RGBA8,
RGBA8Premultiplied,
};
struct RGB8_Body {
SharedPixelBuffer<Rgb8Pixel> _0;
bool operator==(const RGB8_Body& other) const {
return _0 == other._0;
}
bool operator!=(const RGB8_Body& other) const {
return _0 != other._0;
}
};
struct RGBA8_Body {
SharedPixelBuffer<Rgba8Pixel> _0;
bool operator==(const RGBA8_Body& other) const {
return _0 == other._0;
}
bool operator!=(const RGBA8_Body& other) const {
return _0 != other._0;
}
};
struct RGBA8Premultiplied_Body {
SharedPixelBuffer<Rgba8Pixel> _0;
bool operator==(const RGBA8Premultiplied_Body& other) const {
return _0 == other._0;
}
bool operator!=(const RGBA8Premultiplied_Body& other) const {
return _0 != other._0;
}
};
Tag tag;
union {
RGB8_Body rgb8;
RGBA8_Body rgba8;
RGBA8Premultiplied_Body rgba8_premultiplied;
};
static SharedImageBuffer RGB8(const SharedPixelBuffer<Rgb8Pixel> &_0) {
SharedImageBuffer result;
::new (&result.rgb8._0) (SharedPixelBuffer<Rgb8Pixel>)(_0);
result.tag = Tag::RGB8;
return result;
}
bool IsRGB8() const {
return tag == Tag::RGB8;
}
static SharedImageBuffer RGBA8(const SharedPixelBuffer<Rgba8Pixel> &_0) {
SharedImageBuffer result;
::new (&result.rgba8._0) (SharedPixelBuffer<Rgba8Pixel>)(_0);
result.tag = Tag::RGBA8;
return result;
}
bool IsRGBA8() const {
return tag == Tag::RGBA8;
}
static SharedImageBuffer RGBA8Premultiplied(const SharedPixelBuffer<Rgba8Pixel> &_0) {
SharedImageBuffer result;
::new (&result.rgba8_premultiplied._0) (SharedPixelBuffer<Rgba8Pixel>)(_0);
result.tag = Tag::RGBA8Premultiplied;
return result;
}
bool IsRGBA8Premultiplied() const {
return tag == Tag::RGBA8Premultiplied;
}
bool operator==(const SharedImageBuffer& other) const {
if (tag != other.tag) {
return false;
}
switch (tag) {
case Tag::RGB8: return rgb8 == other.rgb8;
case Tag::RGBA8: return rgba8 == other.rgba8;
case Tag::RGBA8Premultiplied: return rgba8_premultiplied == other.rgba8_premultiplied;
}
return true;
}
bool operator!=(const SharedImageBuffer& other) const {
return !(*this == other);
}
private:
SharedImageBuffer() {
}
public:
~SharedImageBuffer() {
switch (tag) {
case Tag::RGB8: rgb8.~RGB8_Body(); break;
case Tag::RGBA8: rgba8.~RGBA8_Body(); break;
case Tag::RGBA8Premultiplied: rgba8_premultiplied.~RGBA8Premultiplied_Body(); break;
}
}
SharedImageBuffer(const SharedImageBuffer& other)
: tag(other.tag) {
switch (tag) {
case Tag::RGB8: ::new (&rgb8) (RGB8_Body)(other.rgb8); break;
case Tag::RGBA8: ::new (&rgba8) (RGBA8_Body)(other.rgba8); break;
case Tag::RGBA8Premultiplied: ::new (&rgba8_premultiplied) (RGBA8Premultiplied_Body)(other.rgba8_premultiplied); break;
}
}
SharedImageBuffer& operator=(const SharedImageBuffer& other) {
if (this != &other) {
this->~SharedImageBuffer();
new (this) SharedImageBuffer(other);
}
return *this;
}
};
using IntSize = Size2D<uint32_t>;
struct OpaqueImageVTable {
Layout (*drop_in_place)(VRefMut<OpaqueImageVTable>);
void (*dealloc)(const OpaqueImageVTable*, uint8_t *ptr, Layout layout);
IntSize (*size)(VRef<OpaqueImageVTable>);
ImageCacheKey (*cache_key)(VRef<OpaqueImageVTable>);
bool operator==(const OpaqueImageVTable& other) const {
return drop_in_place == other.drop_in_place &&
dealloc == other.dealloc &&
size == other.size &&
cache_key == other.cache_key;
}
bool operator!=(const OpaqueImageVTable& other) const {
return drop_in_place != other.drop_in_place ||
dealloc != other.dealloc ||
size != other.size ||
cache_key != other.cache_key;
}
};
struct IntRect {
int32_t x;
int32_t y;
int32_t width;
int32_t height;
bool operator==(const IntRect& other) const {
return x == other.x &&
y == other.y &&
width == other.width &&
height == other.height;
}
bool operator!=(const IntRect& other) const {
return x != other.x ||
y != other.y ||
width != other.width ||
height != other.height;
}
};
struct StaticTexture {
IntRect rect;
PixelFormat format;
Color color;
uintptr_t index;
bool operator==(const StaticTexture& other) const {
return rect == other.rect &&
format == other.format &&
color == other.color &&
index == other.index;
}
bool operator!=(const StaticTexture& other) const {
return rect != other.rect ||
format != other.format ||
color != other.color ||
index != other.index;
}
};
struct StaticTextures {
IntSize size;
IntSize original_size;
Slice<uint8_t> data;
Slice<StaticTexture> textures;
bool operator==(const StaticTextures& other) const {
return size == other.size &&
original_size == other.original_size &&
data == other.data &&
textures == other.textures;
}
bool operator!=(const StaticTextures& other) const {
return size != other.size ||
original_size != other.original_size ||
data != other.data ||
textures != other.textures;
}
};
union ImageInner {
enum class Tag : uint8_t {
ImageInner_None,
ImageInner_EmbeddedImage,
ImageInner_Svg,
ImageInner_StaticTextures,
ImageInner_HTMLImage,
ImageInner_BackendStorage,
};
struct ImageInner_EmbeddedImage_Body {
Tag tag;
ImageCacheKey cache_key;
SharedImageBuffer buffer;
bool operator==(const ImageInner_EmbeddedImage_Body& other) const {
return cache_key == other.cache_key &&
buffer == other.buffer;
}
bool operator!=(const ImageInner_EmbeddedImage_Body& other) const {
return cache_key != other.cache_key ||
buffer != other.buffer;
}
};
struct ImageInner_Svg_Body {
Tag tag;
VRc<OpaqueImageVTable, ParsedSVG> _0;
bool operator==(const ImageInner_Svg_Body& other) const {
return _0 == other._0;
}
bool operator!=(const ImageInner_Svg_Body& other) const {
return _0 != other._0;
}
};
struct ImageInner_StaticTextures_Body {
Tag tag;
const StaticTextures *_0;
bool operator==(const ImageInner_StaticTextures_Body& other) const {
return _0 == other._0;
}
bool operator!=(const ImageInner_StaticTextures_Body& other) const {
return _0 != other._0;
}
};
struct ImageInner_HTMLImage_Body {
Tag tag;
VRc<OpaqueImageVTable, HTMLImage> _0;
bool operator==(const ImageInner_HTMLImage_Body& other) const {
return _0 == other._0;
}
bool operator!=(const ImageInner_HTMLImage_Body& other) const {
return _0 != other._0;
}
};
struct ImageInner_BackendStorage_Body {
Tag tag;
VRc<OpaqueImageVTable> _0;
bool operator==(const ImageInner_BackendStorage_Body& other) const {
return _0 == other._0;
}
bool operator!=(const ImageInner_BackendStorage_Body& other) const {
return _0 != other._0;
}
};
struct {
Tag tag;
};
ImageInner_EmbeddedImage_Body embedded_image;
ImageInner_Svg_Body svg;
ImageInner_StaticTextures_Body static_textures;
ImageInner_HTMLImage_Body html_image;
ImageInner_BackendStorage_Body backend_storage;
static ImageInner ImageInner_None() {
ImageInner result;
result.tag = Tag::ImageInner_None;
return result;
}
bool IsImageInner_None() const {
return tag == Tag::ImageInner_None;
}
static ImageInner ImageInner_EmbeddedImage(const ImageCacheKey &cache_key,
const SharedImageBuffer &buffer) {
ImageInner result;
::new (&result.embedded_image.cache_key) (ImageCacheKey)(cache_key);
::new (&result.embedded_image.buffer) (SharedImageBuffer)(buffer);
result.tag = Tag::ImageInner_EmbeddedImage;
return result;
}
bool IsImageInner_EmbeddedImage() const {
return tag == Tag::ImageInner_EmbeddedImage;
}
static ImageInner ImageInner_Svg(const VRc<OpaqueImageVTable, ParsedSVG> &_0) {
ImageInner result;
::new (&result.svg._0) (VRc<OpaqueImageVTable, ParsedSVG>)(_0);
result.tag = Tag::ImageInner_Svg;
return result;
}
bool IsImageInner_Svg() const {
return tag == Tag::ImageInner_Svg;
}
static ImageInner ImageInner_StaticTextures(const StaticTextures *const &_0) {
ImageInner result;
::new (&result.static_textures._0) (const StaticTextures*)(_0);
result.tag = Tag::ImageInner_StaticTextures;
return result;
}
bool IsImageInner_StaticTextures() const {
return tag == Tag::ImageInner_StaticTextures;
}
static ImageInner ImageInner_HTMLImage(const VRc<OpaqueImageVTable, HTMLImage> &_0) {
ImageInner result;
::new (&result.html_image._0) (VRc<OpaqueImageVTable, HTMLImage>)(_0);
result.tag = Tag::ImageInner_HTMLImage;
return result;
}
bool IsImageInner_HTMLImage() const {
return tag == Tag::ImageInner_HTMLImage;
}
static ImageInner ImageInner_BackendStorage(const VRc<OpaqueImageVTable> &_0) {
ImageInner result;
::new (&result.backend_storage._0) (VRc<OpaqueImageVTable>)(_0);
result.tag = Tag::ImageInner_BackendStorage;
return result;
}
bool IsImageInner_BackendStorage() const {
return tag == Tag::ImageInner_BackendStorage;
}
bool operator==(const ImageInner& other) const {
if (tag != other.tag) {
return false;
}
switch (tag) {
case Tag::ImageInner_EmbeddedImage: return embedded_image == other.embedded_image;
case Tag::ImageInner_Svg: return svg == other.svg;
case Tag::ImageInner_StaticTextures: return static_textures == other.static_textures;
case Tag::ImageInner_HTMLImage: return html_image == other.html_image;
case Tag::ImageInner_BackendStorage: return backend_storage == other.backend_storage;
default: break;
}
return true;
}
bool operator!=(const ImageInner& other) const {
return !(*this == other);
}
private:
ImageInner() {
}
public:
~ImageInner() {
switch (tag) {
case Tag::ImageInner_EmbeddedImage: embedded_image.~ImageInner_EmbeddedImage_Body(); break;
case Tag::ImageInner_Svg: svg.~ImageInner_Svg_Body(); break;
case Tag::ImageInner_StaticTextures: static_textures.~ImageInner_StaticTextures_Body(); break;
case Tag::ImageInner_HTMLImage: html_image.~ImageInner_HTMLImage_Body(); break;
case Tag::ImageInner_BackendStorage: backend_storage.~ImageInner_BackendStorage_Body(); break;
default: break;
}
}
ImageInner(const ImageInner& other)
: tag(other.tag) {
switch (tag) {
case Tag::ImageInner_EmbeddedImage: ::new (&embedded_image) (ImageInner_EmbeddedImage_Body)(other.embedded_image); break;
case Tag::ImageInner_Svg: ::new (&svg) (ImageInner_Svg_Body)(other.svg); break;
case Tag::ImageInner_StaticTextures: ::new (&static_textures) (ImageInner_StaticTextures_Body)(other.static_textures); break;
case Tag::ImageInner_HTMLImage: ::new (&html_image) (ImageInner_HTMLImage_Body)(other.html_image); break;
case Tag::ImageInner_BackendStorage: ::new (&backend_storage) (ImageInner_BackendStorage_Body)(other.backend_storage); break;
default: break;
}
}
ImageInner& operator=(const ImageInner& other) {
if (this != &other) {
this->~ImageInner();
new (this) ImageInner(other);
}
return *this;
}
};
using Image = ImageInner;
using Size = Size2D<float>;
extern "C" {
void slint_image_load_from_path(const SharedString *path, Image *image);
void slint_image_load_from_embedded_data(Slice<uint8_t> data, Slice<uint8_t> format, Image *image);
IntSize slint_image_size(const Image *image);
const SharedString *slint_image_path(const Image *image);
} // extern "C"
} // namespace types
} // namespace cbindgen_private
} // namespace slint