Widgets.cpp

Go to the documentation of this file.

#include "Widgets.h"
 
#include "Impl.h"
 
namespace armarx::RemoteGui::Client
{
 
    Widget::Widget(void* iceWidget) : impl(new WidgetImpl)
    {
        impl->desc = static_cast<RemoteGui::Widget*>(iceWidget);
 
        // Set a default name, so the client code does not need to bother
        static std::atomic<std::uint64_t> counter{0};
        std::uint64_t uniqueNumber = counter++;
        setName(std::to_string(uniqueNumber));
    }
 
    void
    Widget::setName(const std::string& name)
    {
        impl->desc->name = name;
    }
 
    const std::string&
    Widget::getName() const
    {
        return impl->desc->name;
    }
 
    Label::Label() : Widget(new RemoteGui::Label)
    {
    }
 
    Label::Label(const std::string& text) : Label()
    {
        setText(text);
    }
 
    void
    Label::setText(const std::string& text)
    {
        impl->setValue(text);
    }
 
    IntSpinBox::IntSpinBox() : Widget(new RemoteGui::IntSpinBox)
    {
        setValue(0);
    }
 
    void
    IntSpinBox::setRange(int min, int max)
    {
        auto* concrete = static_cast<RemoteGui::IntSpinBox*>(impl->desc.get());
        concrete->min = min;
        concrete->max = max;
    }
 
    void
    IntSpinBox::setValue(int newValue)
    {
        impl->setValue(newValue);
    }
 
    bool
    IntSpinBox::hasValueChanged() const
    {
        return impl->hasValueChanged();
    }
 
    int
    IntSpinBox::getValue() const
    {
        return impl->getValue<int>();
    }
 
    HBoxLayout::HBoxLayout() : ContainerWidget(new RemoteGui::HBoxLayout)
    {
    }
 
    HBoxLayout::HBoxLayout(std::initializer_list<Widget> children) : HBoxLayout()
    {
        addChildren(children);
    }
 
    VBoxLayout::VBoxLayout() : ContainerWidget(new RemoteGui::VBoxLayout)
    {
    }
 
    VBoxLayout::VBoxLayout(std::initializer_list<Widget> children) : VBoxLayout()
    {
        addChildren(children);
    }
 
    void
    ContainerWidget::addChild(const Widget& child)
    {
        impl->addChild(child.impl);
    }
 
    void
    ContainerWidget::addChildren(std::initializer_list<Widget> children)
    {
        for (auto& child : children)
        {
            addChild(child);
        }
    }
 
    VSpacer::VSpacer() : Widget(new RemoteGui::VSpacer)
    {
    }
 
    HSpacer::HSpacer() : Widget(new RemoteGui::HSpacer)
    {
    }
 
    Button::Button() : Widget(new RemoteGui::Button)
    {
        impl->desc->defaultValue = makeValue(0);
    }
 
    void
    Button::setLabel(const std::string& label)
    {
        auto* concrete = static_cast<RemoteGui::Button*>(impl->desc.get());
        concrete->label = label;
    }
 
    bool
    Button::wasClicked() const
    {
        return impl->tab->getButton(getName()).clicked();
    }
 
    LineEdit::LineEdit() : Widget(new RemoteGui::LineEdit)
    {
        setValue("");
    }
 
    std::string
    LineEdit::getValue()
    {
        return impl->getValue<std::string>();
    }
 
    void
    LineEdit::setValue(const std::string& text)
    {
        auto* concrete = static_cast<RemoteGui::LineEdit*>(impl->desc.get());
        concrete->defaultValue = makeValue(text);
    }
 
    bool
    LineEdit::hasValueChanged() const
    {
        return impl->hasValueChanged();
    }
 
    ComboBox::ComboBox() : Widget(new RemoteGui::ComboBox)
    {
    }
 
    void
    ComboBox::addOption(const std::string& option)
    {
        auto* concrete = static_cast<RemoteGui::ComboBox*>(impl->desc.get());
        concrete->options.push_back(option);
 
        // Set the default value to the first option that is set
        if (concrete->defaultValue.type == VALUE_VARIANT_EMPTY)
        {
            concrete->defaultValue = makeValue(option);
        }
    }
 
    void
    ComboBox::addOptions(std::initializer_list<std::string> options)
    {
        for (auto& option : options)
        {
            addOption(option);
        }
    }
 
    void
    ComboBox::setOptions(const std::vector<std::string>& options)
    {
        auto* concrete = static_cast<RemoteGui::ComboBox*>(impl->desc.get());
        concrete->options = options;
        if (options.size() > 0)
        {
            concrete->defaultValue = makeValue(options.front());
        }
    }
 
    void
    ComboBox::setValue(const std::string& newValue)
    {
        impl->setValue(newValue);
    }
 
    std::string
    ComboBox::getValue() const
    {
        return impl->getValue<std::string>();
    }
 
    void
    ComboBox::setIndex(int index)
    {
        auto* concrete = static_cast<RemoteGui::ComboBox*>(impl->desc.get());
        if (index < 0 || index >= (int)concrete->options.size())
        {
            throw std::runtime_error("ComboBox::setIndex(i) Index i is invalid");
        }
        setValue(concrete->options[index]);
    }
 
    int
    ComboBox::getIndex() const
    {
        auto* concrete = static_cast<RemoteGui::ComboBox*>(impl->desc.get());
        std::string value = getValue();
        for (int i = 0; i < (int)concrete->options.size(); ++i)
        {
            if (concrete->options[i] == value)
            {
                return i;
            }
        }
        return -1;
    }
 
    bool
    ComboBox::hasValueChanged() const
    {
        return impl->hasValueChanged();
    }
 
    CheckBox::CheckBox() : Widget(new RemoteGui::CheckBox)
    {
        setValue(false);
    }
 
    bool
    CheckBox::getValue() const
    {
        return impl->getValue<bool>();
    }
 
    void
    CheckBox::setValue(bool newValue)
    {
        impl->setValue(newValue);
    }
 
    bool
    CheckBox::hasValueChanged() const
    {
        return impl->hasValueChanged();
    }
 
    ToggleButton::ToggleButton() : Widget(new RemoteGui::ToggleButton)
    {
        setValue(false);
    }
 
    void
    ToggleButton::setLabel(const std::string& label)
    {
        auto* concrete = static_cast<RemoteGui::ToggleButton*>(impl->desc.get());
        concrete->label = label;
    }
 
    bool
    ToggleButton::getValue() const
    {
        return impl->getValue<bool>();
    }
 
    void
    ToggleButton::setValue(bool newValue)
    {
        impl->setValue(newValue);
    }
 
    bool
    ToggleButton::hasValueChanged() const
    {
        return impl->hasValueChanged();
    }
 
    IntSlider::IntSlider() : Widget(new RemoteGui::IntSlider)
    {
        setValue(0);
    }
 
    void
    IntSlider::setRange(int min, int max)
    {
        auto* concrete = static_cast<RemoteGui::IntSlider*>(impl->desc.get());
        concrete->min = min;
        concrete->max = max;
    }
 
    int
    IntSlider::getValue() const
    {
        return impl->getValue<int>();
    }
 
    void
    IntSlider::setValue(int newValue)
    {
        impl->setValue(newValue);
    }
 
    bool
    IntSlider::hasValueChanged() const
    {
        return impl->hasValueChanged();
    }
 
    FloatSpinBox::FloatSpinBox() : Widget(new RemoteGui::FloatSpinBox)
    {
        setValue(0.0f);
    }
 
    void
    FloatSpinBox::setRange(float min, float max)
    {
        auto* concrete = static_cast<RemoteGui::FloatSpinBox*>(impl->desc.get());
        concrete->min = min;
        concrete->max = max;
    }
 
    void
    FloatSpinBox::setSteps(int steps)
    {
        auto* concrete = static_cast<RemoteGui::FloatSpinBox*>(impl->desc.get());
        concrete->steps = steps;
    }
 
    void
    FloatSpinBox::setDecimals(int decimals)
    {
        auto* concrete = static_cast<RemoteGui::FloatSpinBox*>(impl->desc.get());
        concrete->decimals = decimals;
    }
 
    float
    FloatSpinBox::getValue() const
    {
        return impl->getValue<float>();
    }
 
    void
    FloatSpinBox::setValue(float newValue)
    {
        impl->setValue(newValue);
    }
 
    bool
    FloatSpinBox::hasValueChanged() const
    {
        return impl->hasValueChanged();
    }
 
    FloatSlider::FloatSlider() : Widget(new RemoteGui::FloatSlider)
    {
        setValue(0.0f);
    }
 
    void
    FloatSlider::setRange(float min, float max)
    {
        auto* concrete = static_cast<RemoteGui::FloatSlider*>(impl->desc.get());
        concrete->min = min;
        concrete->max = max;
    }
 
    void
    FloatSlider::setSteps(int steps)
    {
        auto* concrete = static_cast<RemoteGui::FloatSlider*>(impl->desc.get());
        concrete->steps = steps;
    }
 
    float
    FloatSlider::getValue() const
    {
        return impl->getValue<float>();
    }
 
    void
    FloatSlider::setValue(float newValue)
    {
        impl->setValue(newValue);
    }
 
    bool
    FloatSlider::hasValueChanged() const
    {
        return impl->hasValueChanged();
    }
 
    GroupBox::GroupBox() : ContainerWidget(new RemoteGui::GroupBox)
    {
    }
 
    GroupBox::GroupBox(std::initializer_list<Widget> children) : GroupBox()
    {
        for (auto& child : children)
        {
            addChild(child);
        }
    }
 
    void
    GroupBox::setLabel(const std::string& text)
    {
        auto* concrete = static_cast<RemoteGui::GroupBox*>(impl->desc.get());
        concrete->label = text;
    }
 
    void
    GroupBox::setCollapsed(bool collapsed)
    {
        auto* concrete = static_cast<RemoteGui::GroupBox*>(impl->desc.get());
        concrete->collapsed = collapsed;
    }
 
    GridLayout::GridLayout() : Widget(new RemoteGui::GridLayout)
    {
    }
 
    GridLayout&
    GridLayout::add(const Widget& child, Pos pos, Span span)
    {
        impl->addChild(child.impl);
 
        auto* concrete = static_cast<RemoteGui::GridLayout*>(impl->desc.get());
        concrete->childrenLayoutInfo.push_back({pos.row, pos.column, span.rows, span.columns});
 
        return *this;
    }
 
} // namespace armarx::RemoteGui::Client