QCustomCombobox.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants
Licensee a limited, non-exclusive, non-transferable, royalty-free license
(without the right to sublicense) to use the API solely for the purpose of
Licensee's internal development efforts to develop applications for which
the API was provided.
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Widgets
File: QCustomComboBox
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/QCustomValidator.h>
#include <NDEVR/QCustomLineEdit.h>
#include <NDEVR/QTTools.h>
#include <NDEVR/BufferBase.h>
#include <NDEVR/Dictionary.h>
#include <NDEVR/String.h>
#include <NDEVR/Resource.h>
#include <QComboBox>
namespace NDEVR
{
    class QCustomValidator;
    class QCustomLineEdit;
    class NDEVR_WIDGETS_API QCustomComboBox : public QComboBox
    {
        Q_OBJECT
    public:
        QCustomComboBox(QWidget* parent = nullptr);
        const QCustomValidator& customValidator() const;
        QCustomValidator& customValidator();
        void setCustomValidator(const QCustomValidator& validator);
        void setup(const TranslatedString& title, const Buffer<TranslatedString>& values);
        void setup(const TranslatedString& title, const Buffer<String>& values, const Buffer<TranslatedString>& display_values);
        bool isUsingCustom() const { return m_using_custom; }

        template<class t_object>
        void setup(const TranslatedString& title, const Buffer<std::pair<TranslatedString, t_object>>& items)
        {
            Buffer<String> values;
            Buffer<TranslatedString> display_values;
            for (uint04 i = 0; i < items.size(); i++)
            {
                values.add(String(items[i].second));
                display_values.add(items[i].first);
            }
            setup(title, values, display_values);
        }

        template<class t_object>
        void setup(const TranslatedString& title, const Buffer<std::pair<String, t_object>>& items)
        {
            Buffer<String> values;
            Buffer<TranslatedString> display_values;
            for (uint04 i = 0; i < items.size(); i++)
            {
                values.add(String(items[i].second));
                display_values.add(TranslatedString::DirectString(items[i].first));
            }
            setup(title, values, display_values);
        }

        template<class t_object>
        typename std::enable_if<ObjectInfo<t_object>::Enum>::type setup(const TranslatedString& title, const Buffer<t_object>& items)
        {
            Buffer<String> values;
            Buffer<TranslatedString> display_values;
            for (uint04 i = 0; i < items.size(); i++)
            {
                values.add(String(items[i]));
                display_values.add(String::DisplayString(items[i]));
            }
            setup(title, values, display_values);
        }

        template<class t_object>
        typename std::enable_if<ObjectInfo<t_object>::Number>::type setup(const TranslatedString& title, const Buffer<t_object>& items)
        {
            Buffer<String> values;
            Buffer<TranslatedString> display_values;
            for (uint04 i = 0; i < items.size(); i++)
            {
                values.add(String(items[i]));
                StringAllocatingView s = StringAllocatingView::Allocate(items[i]);
                customValidator().fixup(s, true, false);
                display_values.add(TranslatedString(s));
            }
            setup(title, values, display_values);
        }

        template<class t_enum>
        typename std::enable_if<ObjectInfo<t_enum>::Enum>::type setup(const TranslatedString& title, uint04 size)
        {
            setTitle(title);
            m_values.clear();
            index_to_enum.clear();
            for (uint04 i = 0; i < size; i++)
            {
                m_values.add(String(cast<t_enum>(i)));
                m_display_values.add(String::DisplayString(cast<t_enum>(i)));
                index_to_enum[i] = i;
                enum_to_index[i] = i;
            }
            refreshWidget();
        }

        template<class t_object>
        typename std::enable_if<!ObjectInfo<t_object>::Enum && !ObjectInfo<t_object>::Number>::type setup(const TranslatedString& title, const Buffer<t_object>& items)
        {
            Buffer<String> values;
            Buffer<TranslatedString> display_values;
            for (uint04 i = 0; i < items.size(); i++)
            {
                values.add(String(items[i]));
                display_values.add(String::DisplayString(items[i]));
            }
            setup(title, values, display_values);
        }

        template<class t_enum>
        typename std::enable_if<ObjectInfo<t_enum>::Enum>::type setup(const TranslatedString& title, t_enum first, t_enum last)
        {
            setTitle(title);
            m_values.clear();
            for (uint04 i = 0; i <= cast<uint04>(last) - cast<uint04>(first); i++)
            {
                m_values.add(String(cast<t_enum>(i + cast<uint04>(first))));
                m_display_values.add(String::DisplayString(cast<t_enum>(i + cast<uint04>(first))));
                index_to_enum[i] = i + cast<uint04>(first);
                enum_to_index[i + cast<uint04>(first)] = i;
            }
            refreshWidget();
        }

        template<class t_type>
        void add(const t_type& value, const TranslatedString& display_value, bool refresh_widget = false)
        {
            m_values.add(String(value));
            m_display_values.add(display_value);
            if (refresh_widget)
                refresh();
        }

        template<class t_type>
        void remove(const t_type& value, bool refresh_widget = false)
        {
            uint04 index = m_values.indexOf(String(value));
            if (IsValid(index))
            {
                m_values.removeIndex(index);
                m_display_values.removeIndex(index);
                if (refresh_widget)
                    refresh();
            }
        }

        void refresh()
        {
            refreshWidget();
            updateGeometry();
        }

        template<class t_type>
        void setupResource(const TranslatedString& title, Resource<t_type>& resource)
        {
            setTitle(title);
            connect(this, &QCustomComboBox::edited, this, [this, &resource]
            {
                if (!customValidator().unit().isNull())
                    resource.set(LineEditResourceSetter<t_type, ObjectInfo<t_type>::Number>::ValueFromFloat(getUnitValue()));
                else
                    resource.set(getAs<t_type>());
            });
            if (m_resource_changed_listener)
                delete m_resource_changed_listener;
            m_resource_changed_listener = new QTResourceListener([this, &resource]
            {
                if (!customValidator().unit().isNull())
                    setUnitValue(LineEditResourceSetter<t_type, ObjectInfo<t_type>::Number>::ValueToFloat(resource.get()));
                else
                    setValue(resource.get());
            }, this);
            resource.addListener(m_resource_changed_listener);
        }

        void setAutoFormat(bool auto_format) { m_auto_format = auto_format; }
        template<class t_enum>
        typename std::enable_if<ObjectInfo<t_enum>::Enum>::type set(t_enum value)
        {
            setCurrentIndex(enum_to_index[cast<uint04>(value)]);
        }

        template<class t_type>
        t_type getAs() const
        {
            if(m_using_custom || currentIndex() == -1 || m_values.size() <= cast<uint04>(currentIndex()))
                return m_current_custom.template getAs<t_type>();
            return m_values[currentIndex()].template getAs<t_type>();
        }

        template<class t_type>
        t_type getAs(uint04 index) const
        {
            return m_values[index].template getAs<t_type>();
        }

        template<class t_type>
        void setValue(const t_type& t_value)
        {
            setValue(String(t_value));
        }

        void setValue(const TranslatedString& t_value)
        {
            setValue(String(t_value));
            lib_assert(!isUsingCustom() || t_value == _t("Custom"), "unexpect custom translated string");
        }

        TranslatedString currentDisplayValue() const;
        void setTitle(const TranslatedString& title);
        void clearValue();
        QSize minimumSizeHint() const override;
        QSize sizeHint() const override;
        fltp08 getUnitValue() const;
        Angle<fltp08> getUnitAngle() const;
        void setValue(const String& value);
        void setToolTip(const TranslatedString& tooltip);
        void setUnitType(UnitCategory unit, uint01 dimension = Constant<uint01>::Invalid);
        void setConstantUnit(const ConstPointer<Unit>& unit, uint01 dimension = Constant<uint01>::Invalid);
        void setCustomUnit(const StringView& unit, UnitCategory fallback_unit, uint01 dimension = Constant<uint01>::Invalid);
        void setUnitValue(fltp08 value, uint01 unit_dimension = 0);
        void setAllowCustom(bool allow_custom) { m_allow_custom = allow_custom; refreshWidget(); }
        void setSuffix(const TranslatedString& suffix) { m_suffix = suffix; refreshWidget(); }
        const TranslatedString& suffix() const { return m_suffix; }
        void focusInEvent(QFocusEvent* e) override;
        void updateFontSize();
        bool event(QEvent* event) override;
        void sortAlphabetically(uint04 start = 0, uint04 size = Constant<uint04>::Invalid);
        const Buffer<String>& values() const { return m_values; }
        const Buffer<TranslatedString>& displayValues() const { return m_display_values; }
        void showPopup() override;
        void hidePopup() override;
        void resizeEvent(QResizeEvent* event) override;
        void paintEvent(QPaintEvent*) override;
        void wheelEvent(QWheelEvent* e) override;
        void lockInCustomValue();
    protected:
        void refreshWidget();
        void adjustLineEditSize();
        virtual void onSorted(const Buffer<uint04>& swap_indices);
    protected slots:
        void onEdit();
        void onEditTextChangedSlot();
        void onChange();
    signals:
        void edited();
    private:
        void _updateTooltip();
    protected:
        bool m_is_refreshing = false; 
        bool m_is_changing = false; 
        bool m_allow_custom; 
        bool m_using_custom; 
        bool m_auto_format; 
        bool m_sort_alphabetically = false; 
        bool m_is_showing_popup = false; 
        uint04 m_custom_index; 
        uint04 m_sort_offset = 0; 
        uint04 m_last_index; 
        Buffer<String> m_values; 
        TranslatedString m_title; 
        TranslatedString m_tooltip; 
        Buffer<TranslatedString> m_display_values; 
        String m_current_custom; 
        TranslatedString m_suffix; 
        QCustomLineEdit* m_line_edit; 
        Dictionary<uint04, uint04> enum_to_index; 
        Dictionary<uint04, uint04> index_to_enum; 
        QTResourceListener* m_resource_changed_listener; 
    };
}