value-utils.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
#ifndef INKSCAPE_UTIL_VALUE_UTILS_H
#define INKSCAPE_UTIL_VALUE_UTILS_H
 
#include <glibmm/utility.h>
#include <glibmm/value.h>
#include <gdkmm/contentprovider.h>
 
namespace Inkscape::Util::GlibValue {
 
template <class T>
GType type()
{
    static auto const type = [] {
        auto name = std::string{"inkscape_glibvalue_"};
        Glib::append_canonical_typename(name, typeid(T).name());
 
        return g_boxed_type_register_static(
            name.c_str(),
            +[] (void *p) -> void * {
                return new (std::nothrow) T{*static_cast<T *>(p)};
            },
            +[] (void *p) {
                delete static_cast<T *>(p);
            }
        );
    }();
    return type;
}
 
template <typename T>
bool holds(GValue const *value)
{
    return G_VALUE_HOLDS(value, type<T>());
}
 
template <typename T>
bool holds(Glib::ValueBase const &value)
{
    return holds<T>(value.gobj());
}
 
template <typename T>
T *get(GValue *value)
{
    if (holds<T>(value)) {
        return static_cast<T *>(g_value_get_boxed(value));
    }
    return nullptr;
}
 
template <typename T>
T *get(Glib::ValueBase &value)
{
    return get<T>(value.gobj());
}
 
template <typename T>
T const *get(GValue const *value)
{
    if (holds<T>(value)) {
        return static_cast<T const *>(g_value_get_boxed(value));
    }
    return nullptr;
}
 
template <typename T>
T const *get(Glib::ValueBase const &value)
{
    return get<T>(value.gobj());
}
 
template <typename T>
Glib::ValueBase own(std::unique_ptr<T> t)
{
    assert(t);
    Glib::ValueBase value;
    value.init(type<T>());
    g_value_take_boxed(value.gobj(), t.release());
    return value;
}
 
template <typename T, typename... Args>
Glib::ValueBase create(Args&&... args)
{
    return own(std::make_unique<T>(std::forward<Args>(args)...));
}
 
inline GValue release(Glib::ValueBase &&value)
{
    return std::exchange(*value.gobj(), GValue(G_VALUE_INIT));
}
 
template <typename T>
std::unique_ptr<T> from_content_provider(Gdk::ContentProvider const &content_provider)
{
    Glib::ValueBase value;
    value.init(type<T>());
    // Fixme: Value inside content provider is copied rather than returned directly.
    if (!gdk_content_provider_get_value(const_cast<Gdk::ContentProvider &>(content_provider).gobj(), value.gobj(), nullptr)) {
        return {};
    }
    auto const t = static_cast<T *>(g_value_get_boxed(value.gobj()));
    *value.gobj() = G_VALUE_INIT;
    return std::unique_ptr<T>(t);
}
 
} // namespace Inkscape::Util::GlibValue
 
#endif // INKSCAPE_UTIL_VALUE_UTILS_H