QCustomLineEdit.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: QCustomLineEdit
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/QCustomValidator.h>
#include "DLLInfo.h"
#include <NDEVR/QTTools.h>
#include <NDEVR/String.h>
#include <NDEVR/ApplicationOptions.h>
#include <NDEVR/BufferBase.h>
#include <NDEVR/TimeSpan.h>
#include <NDEVR/Unit.h>
#include <NDEVR/BufferBase.h>
#include <NDEVR/RGBColor.h>
#include <QLineEdit>
 
namespace NDEVR
{
    class PasswordString;
    template<class t_type, bool is_number>
    class LineEditResourceSetter
    {
    public:
        static fltp08 ValueToFloat(const t_type& value)
        {
            UNUSED(value);
            lib_assert(false, "Trying to convert non-number");
            return Constant<fltp08>::Invalid;
        }

        static t_type ValueFromFloat(const fltp08& value)
        {
            UNUSED(value);
            lib_assert(false, "Trying to convert non-number");
            return Constant<t_type>::Invalid;
        }
    };

    template<class t_type>
    class LineEditResourceSetter<t_type, true>
    {
    public:
        static fltp08 ValueToFloat(const t_type& value)
        {
            return cast<fltp08>(value);
        }

        static t_type ValueFromFloat(const fltp08& value)
        {
            return cast<t_type>(value);
        }
    };

    template<>
    class LineEditResourceSetter<TimeSpan, ObjectInfo<TimeSpan>::Number>
    {
    public:
        static fltp08 ValueToFloat(const TimeSpan& value)
        {
            return value.elapsedSeconds();
        }

        static TimeSpan ValueFromFloat(const fltp08& value)
        {
            return TimeSpan(value);
        }
    };

    template<>
    class LineEditResourceSetter<Angle<fltp08>, ObjectInfo<Angle<fltp08>>::Number>
    {
    public:
        static fltp08 ValueToFloat(const Angle<fltp08>& value)
        {
            return value.internal<false>();
        }

        static Angle<fltp08> ValueFromFloat(const fltp08& value)
        {
            return Angle<fltp08>(INTERNAL_ANGLE, value);
        }
    };

    template<>
    class LineEditResourceSetter<Angle<sint04>, ObjectInfo<Angle<sint04>>::Number>
    {
    public:
        static fltp08 ValueToFloat(const Angle<sint04>& value)
        {
            return value.internal<false>();
        }

        static Angle<sint04> ValueFromFloat(const fltp08& value)
        {
            return Angle<sint04>(INTERNAL_ANGLE, value);
        }
    };
    class Keypad;
    class NDEVR_WIDGETS_API QCustomLineEdit : public QLineEdit
    {
        Q_OBJECT
    public:
        friend class QCustomComboBox;
        explicit QCustomLineEdit(QWidget *parent = Q_NULLPTR);
        explicit QCustomLineEdit(const QString& value, QWidget *parent = Q_NULLPTR);
        ~QCustomLineEdit();
        virtual void setTitle(const TranslatedString& title);
        QCustomValidator& customValidator();
        const QCustomValidator& customValidator() const;
        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 setUnitType(UnitCategory unit, uint01 dimension = Constant<uint01>::Invalid);
        void setAsKeyboardFocus();
        bool isValid() const;
        void setEditable( bool editable );
        bool isEditable() const { return m_is_editable; }
        bool isEditing() const;
        bool hasUserFocus() const;
        void clearBackgroundColor();
        void setInputHint(const TranslatedString& hint);
        void clearInputHint();
        void clearValue();
        void setIsPassword(bool is_password, const StringView& encoder = StringView());
        bool isPassword() const;
        const String& passwordEncoder() const;
        void setToolTip(const TranslatedString& tooltip);
        String getValue(bool allow_placeholder) const;
        String getValue() const;
        template<class t_angle_type>
        void setUnitValue(Angle<t_angle_type> value)
        {
            setUnitValue(value.template as<INTERNAL_ANGLE>());
        }

        void setUnitValue(fltp08 value);
        void setPlaceHolderUnitValue(fltp08 value);
        template<class t_angle_type = fltp08>
        Angle<t_angle_type> getUnitAngle(bool allow_placeholder = true) const
        {
            return Angle<t_angle_type>(INTERNAL_ANGLE, getUnitValue(allow_placeholder));
        }

        fltp08 getUnitValue(bool allow_placeholder = true) const;
        template<class t_type>
        void setup(const TranslatedString& title)
        {
            setTitle(title);
            m_validator.setRegex(StringStream<t_type>::getValidRegex());
            m_validator.setTypeInfo(GetTypeInfo<t_type>());
            updateInputMethodHints();
        }

        void setRegex(const StringView& regex)
        {
            m_validator.setRegex(regex);
        }

        void setup(const TranslatedString& title, UnitCategory unit_type, uint01 dim = Constant<uint01>::Invalid);
        void setup(const TranslatedString& title, const TypeInfo& type);
        void setup(GenericOption& option);

        template<class t_type>
        void setup(ApplicationOption<t_type>& option)
        {
            setup(option.label(), option.getResource());
        }

        template<class t_type>
        void setup(const TranslatedString& title, Resource<t_type>& resource)
        {
            setup<t_type>(title);
            connect(this, &QCustomLineEdit::editingFinishedSignal, this, [this, &resource]
            {
                if constexpr(ObjectInfo<t_type>::Number)
                {
                    if (!customValidator().unit().isNull())
                        resource.set(LineEditResourceSetter<t_type, ObjectInfo<t_type>::Number>::ValueFromFloat(getUnitValue()));
                    else
                        resource.set(getAs<t_type>());
                }
                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 constexpr(ObjectInfo<t_type>::Number)
                {
                    if (!customValidator().unit().isNull())
                        setUnitValue(LineEditResourceSetter<t_type, ObjectInfo<t_type>::Number>::ValueToFloat(resource.get()));
                    else
                        setValue(resource.get());
                }
                else
                {
                    setValue(resource.get());
                }
            }, this);
            resource.addListener(m_resource_changed_listener);
        }

        void setup(const TranslatedString& title, Resource<String>& resource);
        void setup(Resource<String>& resource);
        void setAllowPlaceholderAsValue(bool allow);
        template<class t_type>
        t_type getAs(bool allow_placeholder) const
        {
            return getValue(allow_placeholder).getAs<t_type>();
        }

        template<class t_type>
        t_type getAs() const
        {
            return getValue(m_allow_placeholder_as_value).getAs<t_type>();
        }

        template<class t_type>
        typename std::enable_if<ObjectInfo<t_type>::Number, void>::type setValue(const t_type& input_value)
        {
            if (m_ignore_focus_lock || !hasUserFocus())
            {
                String value;
                if(m_validator.unit().isNull())
                    value = String(input_value);
                else if(IsValid(m_validator.unitDimension()))
                    value = m_validator.unit()->toString(input_value, false, 0, Constant<uint04>::Max, 0, false, m_validator.unitDimension());
                else
                    value = m_validator.unit()->toString(input_value, false, 0, Constant<uint04>::Max, 0, false);
                _setText(value, false);
            }
        }

        void setValue(const PasswordString& input_value);
        void setValue(const StringView& input_value);
        void setValue(const TimeSpan& input_value);
        void setValue(const TranslatedString& input_value);
        void setValue(const Angle<sint04>& input_value)
        {
            setValue(String(input_value));
        }

        void setValue(const Angle<fltp08>& input_value)
        {
            setValue(String(input_value));
        }

        void setBackgroundColor(const RGBColor& color);
        RGBColor backgroundColor() const;
        template<class t_type>
        void setPlaceholderValue(const t_type& input_value, bool allow_placeholder_as_value = true)
        {
            setAllowPlaceholderAsValue(allow_placeholder_as_value);
            StringAllocatingView input = StringAllocatingView::Allocate(input_value);
            m_validator.fixup(input);
            setPlaceholderText(input.getAs<QString>());
        }

        void setPlaceholderValue(const TranslatedString& input_value, bool allow_placeholder_as_value = true);
        QSize sizeHint() const override;
        QSize minimumSizeHint() const override;
        void wheelEvent(QWheelEvent *event) override;
        void forceValue(const StringView& forced_value);
        bool event(QEvent* event) override;
        const TranslatedString& inputHint() const;
        void setStep(fltp08 step);
        void setAutoShowTooltip(bool auto_show_tooltip) { m_auto_show_tooltip = auto_show_tooltip; }
        static bool UseKeypad();
        void setPlaceholderText(const QString& value);
        void startUserEdit(bool select_all = true);
        void setFontMultiplier(fltp04 font_multiplier);
        void setBold(bool is_bold);
    private:
        void updateInputMethodHints();
        void _setText(StringView text, bool translate);
        void _setInputHint(const TranslatedString& hint);
        void paintEvent(QPaintEvent *event) override;
        void setupForUnit(const ConstPointer<Unit>& unit, uint01 dimension = Constant<uint01>::Invalid);
        virtual void mousePressEvent(QMouseEvent *e) override;
        virtual void focusInEvent(QFocusEvent *e) override;
        virtual void focusOutEvent(QFocusEvent *e) override;
        virtual void creatUnitLister();
        void updateFont();
        void _setBackgroundColor(const RGBColor& color);
        void _updateTooltip();
        void init();
        void updateCharColors(const QCustomValidator::InvalidProperties& props);
    signals:
        void editedSignal();
        void editingFinishedSignal();
        void inputHintChangedSignal();
    public slots:
        void onFinishedSlot();
        void updateColor();
        void onEdited();
    protected:
        TranslatedString m_title; 
        TranslatedString m_tooltip; 
    private:
        String m_current_value; 
        String m_fixed_up_current_value; 
        String m_last_valid; 
        String m_custom_unit; 
        String m_password_encoder; 
        TranslatedString m_input_hint; 
        TranslatedString m_custom_input_hint; 
        RGBColor m_background_color = Constant<RGBColor>::Invalid; 
        QTResourceListener* m_resource_changed_listener = nullptr; 
        QTResourceListener* m_unit_changed_listener = nullptr; 
        QCustomValidator m_validator; 
        fltp04 m_font_multiplier = 1.0f; 
        bool m_is_editable = true; 
        bool m_auto_show_tooltip = true; 
        bool m_suppress_focus_out = false; 
        bool m_allow_placeholder_as_value = true; 
        bool m_is_bold = false; 
        bool m_ignore_focus_lock = false; 
        bool m_has_edited = false; 
        bool m_hint_resolve_links = false; 
        bool m_is_password = false; 
    private:
 
    };
}