Program Listing for File slint-testing.h

↰ Return to documentation for file (/home/runner/work/slint/slint/api/cpp/include/slint-testing.h)

// Copyright © SixtyFPS GmbH <info@slint.dev>
// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-1.2 OR LicenseRef-Slint-commercial

#include "slint.h"
#include "slint_testing_internal.h"
#include <optional>
#include <string_view>

#ifdef SLINT_FEATURE_TESTING
#    ifdef SLINT_FEATURE_EXPERIMENTAL

namespace slint::testing {
inline void init()
{
    cbindgen_private::slint_testing_init_backend();
}

class ElementHandle
{
    cbindgen_private::ItemWeak inner;

public:
    template<typename T>
    static SharedVector<ElementHandle> find_by_accessible_label(const ComponentHandle<T> &component,
                                                                std::string_view label)
    {
        cbindgen_private::Slice<uint8_t> label_view {
            const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(label.data())),
            label.size()
        };
        auto vrc = component.into_dyn();
        SharedVector<ElementHandle> result;
        cbindgen_private::slint_testing_element_find_by_accessible_label(
                &vrc, &label_view,
                reinterpret_cast<SharedVector<cbindgen_private::ItemWeak> *>(&result));
        return result;
    }

    bool is_valid() const { return private_api::upgrade_item_weak(inner).has_value(); }

    std::optional<SharedString> accessible_label() const
    {
        if (auto item = private_api::upgrade_item_weak(inner)) {
            SharedString result;
            if (item->item_tree.vtable()->accessible_string_property(
                        item->item_tree.borrow(), item->index,
                        cbindgen_private::AccessibleStringProperty::Label, &result)) {
                return result;
            }
        }
        return std::nullopt;
    }

    std::optional<SharedString> accessible_value() const
    {
        if (auto item = private_api::upgrade_item_weak(inner)) {
            SharedString result;
            if (item->item_tree.vtable()->accessible_string_property(
                        item->item_tree.borrow(), item->index,
                        cbindgen_private::AccessibleStringProperty::Value, &result)) {
                return result;
            }
        }
        return std::nullopt;
    }

    std::optional<SharedString> accessible_description() const
    {
        if (auto item = private_api::upgrade_item_weak(inner)) {
            SharedString result;
            if (item->item_tree.vtable()->accessible_string_property(
                        item->item_tree.borrow(), item->index,
                        cbindgen_private::AccessibleStringProperty::Description, &result)) {
                return result;
            }
        }
        return std::nullopt;
    }

    std::optional<float> accessible_value_maximum() const
    {
        if (auto item = private_api::upgrade_item_weak(inner)) {
            SharedString result;
            if (item->item_tree.vtable()->accessible_string_property(
                        item->item_tree.borrow(), item->index,
                        cbindgen_private::AccessibleStringProperty::ValueMaximum, &result)) {
                float value = 0.0;
                if (cbindgen_private::slint_string_to_float(&result, &value)) {
                    return value;
                }
            }
        }
        return std::nullopt;
    }

    std::optional<float> accessible_value_minimum() const
    {
        if (auto item = private_api::upgrade_item_weak(inner)) {
            SharedString result;
            if (item->item_tree.vtable()->accessible_string_property(
                        item->item_tree.borrow(), item->index,
                        cbindgen_private::AccessibleStringProperty::ValueMinimum, &result)) {
                float value = 0.0;
                if (cbindgen_private::slint_string_to_float(&result, &value)) {
                    return value;
                }
            }
        }
        return std::nullopt;
    }

    std::optional<float> accessible_value_step() const
    {
        if (auto item = private_api::upgrade_item_weak(inner)) {
            SharedString result;
            if (item->item_tree.vtable()->accessible_string_property(
                        item->item_tree.borrow(), item->index,
                        cbindgen_private::AccessibleStringProperty::ValueStep, &result)) {
                float value = 0.0;
                if (cbindgen_private::slint_string_to_float(&result, &value)) {
                    return value;
                }
            }
        }
        return std::nullopt;
    }

    std::optional<bool> accessible_checked() const
    {
        if (auto item = private_api::upgrade_item_weak(inner)) {
            SharedString result;
            if (item->item_tree.vtable()->accessible_string_property(
                        item->item_tree.borrow(), item->index,
                        cbindgen_private::AccessibleStringProperty::Checked, &result)) {
                if (result == "true")
                    return true;
                else if (result == "false")
                    return false;
            }
        }
        return std::nullopt;
    }

    std::optional<bool> accessible_checkable() const
    {
        if (auto item = private_api::upgrade_item_weak(inner)) {
            SharedString result;
            if (item->item_tree.vtable()->accessible_string_property(
                        item->item_tree.borrow(), item->index,
                        cbindgen_private::AccessibleStringProperty::Checkable, &result)) {
                if (result == "true")
                    return true;
                else if (result == "false")
                    return false;
            }
        }
        return std::nullopt;
    }

    void set_accessible_value(SharedString value) const
    {
        if (auto item = private_api::upgrade_item_weak(inner)) {
            union SetValueHelper {
                cbindgen_private::AccessibilityAction action;
                SetValueHelper(SharedString value)
                {
                    new (&action.set_value) cbindgen_private::AccessibilityAction::SetValue_Body {
                        cbindgen_private::AccessibilityAction::Tag::SetValue, std::move(value)
                    };
                }
                ~SetValueHelper() { action.set_value.~SetValue_Body(); }

            } action(std::move(value));
            item->item_tree.vtable()->accessibility_action(item->item_tree.borrow(), item->index,
                                                           &action.action);
        }
    }

    void invoke_accessible_default_action() const
    {
        if (auto item = private_api::upgrade_item_weak(inner)) {
            union DefaultActionHelper {
                cbindgen_private::AccessibilityAction action;
                DefaultActionHelper()
                {
                    action.tag = cbindgen_private::AccessibilityAction::Tag::Default;
                }
                ~DefaultActionHelper() { }

            } action;
            item->item_tree.vtable()->accessibility_action(item->item_tree.borrow(), item->index,
                                                           &action.action);
        }
    }

    LogicalSize size() const
    {
        if (auto item = private_api::upgrade_item_weak(inner)) {
            auto rect =
                    item->item_tree.vtable()->item_geometry(item->item_tree.borrow(), item->index);
            return LogicalSize({ rect.width, rect.height });
        }
        return LogicalSize({ 0, 0 });
    }

    LogicalPosition absolute_position() const
    {
        if (auto item = private_api::upgrade_item_weak(inner)) {
            cbindgen_private::LogicalRect rect =
                    item->item_tree.vtable()->item_geometry(item->item_tree.borrow(), item->index);
            cbindgen_private::LogicalPoint abs =
                    slint::cbindgen_private::slint_item_absolute_position(&item->item_tree,
                                                                          item->index);
            return LogicalPosition({ abs.x + rect.x, abs.y + rect.y });
        }
        return LogicalPosition({ 0, 0 });
    }
};

}

#    endif // SLINT_FEATURE_EXPERIMENTAL
#endif // SLINT_FEATURE_TESTING