QCustomLineEdit.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
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/ObjectInfo.h>
#include <NDEVR/TimeSpan.h>
#include <NDEVR/Unit.h>
#include <NDEVR/ObjectInfo.h>
#include <NDEVR/RGBColor.h>
#include <QLineEdit>
 
namespace NDEVR
{
    
    class Keypad;
    /**--------------------------------------------------------------------------------------------------
    \brief A line edit allows users to enter and edit a single line of plain text with useful editing 
        functions, including undo and redo, cut and paste, and drag and drop.
 
    In touch mode, a popup Keypad will appear based on the type of data being input.
    **/
    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 String& 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 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>());
            updateHints();
        }
        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(ResourceSetter<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(ResourceSetter<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 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())
            {
                if(m_validator.unit().isNull())
                    m_current_value = String(input_value);
                else if(!IsInvalid(m_validator.unitDimension()))
                    m_current_value = m_validator.unit()->toString(input_value, false, 0, Constant<uint04>::Max, 0, false, m_validator.unitDimension());
                else
                    m_current_value = m_validator.unit()->toString(input_value, false, 0, Constant<uint04>::Max, 0, false);
                QString input = m_current_value.getAs<QString>();
                m_validator.fixup(input);
                m_fixed_up_current_value = String(input);
                int valid_pos = -1;
                if (m_validator.validate(input, valid_pos))
                    m_last_valid = m_fixed_up_current_value;
                setText(input);
            }
        }
        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 val(input_value);
                if (m_current_value != val)
                {
                    m_current_value = val;
                    QString input = TranslatedString(val).translation().getAs<QString>();
                    m_validator.fixup(input);
                    m_fixed_up_current_value = String(input);
                    int valid_pos = -1;
                    if (m_validator.validate(input, valid_pos))
                        m_last_valid = m_fixed_up_current_value;
                    setText(input);
                }
            }
        }
        void setValue(const TimeSpan& 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);
            QString input = String(input_value).getAs<QString>();
            m_validator.fixup(input);
            setPlaceholderText(input);
        }
        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 String& units);
        bool event(QEvent* event) override;
        const TranslatedString& inputHint() const;
        void updateHints();
        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 _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);
        
    signals:
        void editedSignal();
        void editingFinishedSignal();
        void inputHintChangedSignal();
    public slots:
        void onFinishedSlot();
        void updateColor();
        void updateCharColors();
        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;
        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;
    private:
        /**--------------------------------------------------------------------------------------------------
        \brief A basic class for helping convert a Value into a resource.
        **/
        template<class t_type, bool is_number>
        class ResourceSetter
        {
        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 ResourceSetter<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 ResourceSetter<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 ResourceSetter<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 ResourceSetter<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);
            }
        };
    };
}