SCR_EditBoxComponent.c

Go to the documentation of this file.

// Component handling interaction with text input fields (edit boxes)
 
// TODO:
// During interaction with edit boxes on pc, write mode does not disable itself if the dialog/menu is overlayed by another.
// This hasn't been a problem so far as there has never been an instance of a dialog/menu opening while an edit box interaction is allowed, but let's keep it in mind nonetheless
 
//------------------------------------------------------------------------------------------------
class SCR_EditBoxComponent : SCR_ChangeableComponentBase 
{
    [Attribute("0.1")]
    protected float m_fColorsAnimationTime;
    
    [Attribute("0")]
    protected bool m_bShowWriteIcon;
    
    [Attribute("1")]
    protected bool m_bShowInvalidInputWarning;
    
    [Attribute(UIConstants.ICONS_IMAGE_SET, UIWidgets.ResourcePickerThumbnail, "Image resource for icons")]
    protected ResourceName m_sIconImageSet;
    
    [Attribute("")]
    protected string m_sIconImageName;
    
    [Attribute("WriteIconButton")]
    protected string m_sWriteIconButtonName;
    
    [Attribute("0.1", "0 1")]
    protected float m_fOpacityDefault;
    
    [Attribute("0.4", "0 1")]
    protected float m_fOpacityFocused;
    
    [Attribute("0.022995 0.022995 0.022995 1.000000", UIWidgets.ColorPicker)]
    protected ref Color m_BackgroundDefault;
    
    [Attribute("0.108995 0.108995 0.108995 1.000000", UIWidgets.ColorPicker)]
    protected ref Color m_BackgroundInteracting;
    
    [Attribute("0.022995 0.022995 0.022995 1.000000", UIWidgets.ColorPicker)]
    protected ref Color m_BackgroundFocused;
    
    [Attribute("", UIWidgets.EditBox, "Text that should appear next to error warning on invalid input")]
    protected string m_sWarningText;
    
    Widget m_wEditBox;
    Widget m_wColorOverlay;
    Widget m_wEditBackground;
    Widget m_wWarningIcon;
    Widget m_wHorizontalLayout;
    
    Widget m_wWriteIconScale;
    ImageWidget m_wImgWriteIcon;
    
    protected SCR_ModularButtonComponent m_WriteIconButton;
    
    protected SCR_WidgetHintComponent m_Hint;
    
    protected bool m_bValidInput = true;
    protected bool m_bIsTyping;
    protected ref Color COLOR_INVALID_INPUT = UIColors.WARNING;
    protected ref Color COLOR_VALID_INPUT   = Color.White;
    
    // Arguments passed: SCR_EditBoxComponent, string (text)
    ref ScriptInvoker m_OnConfirm = new ScriptInvoker();
    ref ScriptInvoker m_OnFocusChangedEditBox = new ScriptInvoker();
    
    protected MultilineEditBoxWidget m_wMultilineEditBoxWidget;
    protected EditBoxWidget m_wEditBoxWidget;
    protected SCR_EventHandlerComponent m_EVHComponent;
    
    protected const int INTERACTION_STATE_UPDATE_FREQUENCY = 50;
    protected const int FOCUS_LOST_INTERACTION_STATE_UPDATE_DELAY = 1000 / UIConstants.FADE_RATE_DEFAULT;
    
    protected bool m_bIsFocused;
    protected bool m_bIsInWriteMode;
    protected bool m_bIsInWriteModePrevious;
    protected ref Color m_BackgroundCurrent;
    
    // TODO: protect these
    ref ScriptInvokerVoid m_OnWriteModeEnter = new ScriptInvokerVoid();
    ref ScriptInvokerString m_OnWriteModeLeave = new ScriptInvokerString();
    ref ScriptInvokerString m_OnTextChange = new ScriptInvokerString();
    
    protected string m_sTextPrevious;
    
    //------------------------------------------------------------------------------------------------
    override void HandlerAttached(Widget w)
    {
        super.HandlerAttached(w);
        m_wColorOverlay = w.FindAnyWidget("OverlayPanel");
        
        m_wEditBox = w.FindAnyWidget("EditBox");
        m_wWarningIcon = w.FindAnyWidget("ErrorIcon");
        m_wEditBackground = w.FindAnyWidget("EditBackground");
        m_wHorizontalLayout = w.FindAnyWidget("HorizontalLayout");
        
        m_wWriteIconScale = w.FindAnyWidget("WriteIconScale");
        m_wImgWriteIcon = ImageWidget.Cast(w.FindAnyWidget("WriteIcon"));
        
        m_Hint = SCR_WidgetHintComponent.Cast(SCR_WidgetTools.FindHandlerOnWidget(w, "Hint", SCR_WidgetHintComponent));
        
        // Setup warning 
        if (GetGame().InPlayMode() && m_wWarningIcon)
        {
            if (m_bUseLabel)
                m_wWarningIcon.SetOpacity(0);
            else
                m_wWarningIcon.SetOpacity(0); // Without label, warning icon not shown at all
        }
 
        if (m_Hint)
        {
            m_Hint.SetMessage(m_sWarningText);
            m_Hint.SetVisible(0);
        }
        
        // Setup for label-less edit boxes
        m_wBackground.SetVisible(m_bUseLabel);
        
        // Convert to transition rate
        if (m_fColorsAnimationTime <= 0)
            m_fColorsAnimationTime = 1000;
        else
            m_fColorsAnimationTime = 1 / m_fColorsAnimationTime;
        
        if (!m_wEditBox)
            return;
 
        EditBoxFilterComponent filter = EditBoxFilterComponent.Cast(m_wEditBox.FindHandler(EditBoxFilterComponent));
        if (filter)
        {
            if (m_bShowInvalidInputWarning)
            {
                filter.m_OnInvalidInput.Insert(OnInvalidInput);
                filter.m_OnTextTooLong.Insert(OnInvalidInput);
            }
 
            filter.m_OnValidInput.Insert(OnValueChanged);
        }
        
        m_EVHComponent = SCR_EventHandlerComponent.Cast(m_wEditBox.FindHandler(SCR_EventHandlerComponent));
        if (m_EVHComponent)
        {
            m_EVHComponent.GetOnFocus().Insert(OnHandlerFocus);
            m_EVHComponent.GetOnFocusLost().Insert(OnHandlerFocusLost);
            m_EVHComponent.GetOnChangeFinal().Insert(OnConfirm);
        }
        
        if (m_wEditBackground)
        {
            m_wEditBackground.SetOpacity(m_fOpacityDefault);
            m_wEditBackground.SetColor(m_BackgroundDefault);
            m_BackgroundCurrent = m_BackgroundDefault;
        }
        
        // Image 
        if (m_wImgWriteIcon && m_wWriteIconScale)
        {
            bool hasResource = !m_sIconImageSet.IsEmpty() && !m_sIconImageName.IsEmpty();
            m_wWriteIconScale.SetVisible(hasResource);
            
            if (hasResource)
                m_wImgWriteIcon.LoadImageFromSet(0, m_sIconImageSet, m_sIconImageName);
            
            ShowWriteIcon(m_bShowWriteIcon && hasResource);
        }
        
        // Write Icon button
        Widget iconButton = m_wRoot.FindAnyWidget(m_sWriteIconButtonName);
        if (iconButton)
            m_WriteIconButton = SCR_ModularButtonComponent.FindComponent(iconButton);
        
        if (m_WriteIconButton)
            m_WriteIconButton.m_OnClicked.Insert(OnInternalButtonClicked);
        
        //Type of edit box. Why aren't these derived from a common parent :(
        m_wMultilineEditBoxWidget = MultilineEditBoxWidget.Cast(m_wEditBox);
        m_wEditBoxWidget = EditBoxWidget.Cast(m_wEditBox);
        
        if (m_wMultilineEditBoxWidget)
            m_bIsInWriteMode = m_wMultilineEditBoxWidget.IsInWriteMode();
        else if (m_wEditBoxWidget)
            m_bIsInWriteMode = m_wEditBoxWidget.IsInWriteMode();
        
        m_bIsInWriteModePrevious = m_bIsInWriteMode;
        
        m_sTextPrevious = GetEditBoxText();
    }
    
    //------------------------------------------------------------------------------------------------
    override void HandlerDeattached(Widget w)
    {
        super.HandlerDeattached(w);
        
        ClearInteractionState();
    }
    
    //------------------------------------------------------------------------------------------------
    override bool OnFocus(Widget w, int x, int y)
    {
        // Set focus to handler - super.OnFocus will be called only after the handler is focused!
        GetGame().GetWorkspace().SetFocusedWidget(m_wEditBox);
        m_bIsTyping = true;
        
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    void OnValueChanged()
    {
        if (m_Hint)
            m_Hint.SetVisible(false);
        
        m_OnChanged.Invoke(this, GetEditBoxText());
 
        if (m_bValidInput)
            return;
        
        AnimateWidget.Opacity(m_wWarningIcon, 0, m_fColorsAnimationTime, true);
        
        AnimateWidget.Color(m_wColorOverlay, COLOR_VALID_INPUT, m_fColorsAnimationTime);
        m_bValidInput = true;
        
    }
    
    //------------------------------------------------------------------------------------------------
    void OnHandlerFocus()
    {
        // Call focus event on parent class
        super.OnFocus(m_wRoot, 0, 0);
 
        m_bIsTyping = true;
        m_bIsFocused = true;
        
        // Make the widget unfocusable
        m_wRoot.SetFlags(WidgetFlags.NOFOCUS);
        m_OnFocusChangedEditBox.Invoke(this, m_wEditBox, true);
        
        UpdateBackgroundColor();
        
        //Update interaction state timer, because there are no delegates for write start and end :(
        if(m_wMultilineEditBoxWidget || m_wEditBoxWidget)
            GetGame().GetCallqueue().CallLater(UpdateInteractionState, INTERACTION_STATE_UPDATE_FREQUENCY, true, false);
    }
    
    //------------------------------------------------------------------------------------------------
    void OnHandlerFocusLost()
    {
        // Call focusLost event on parent class
        super.OnFocusLost(m_wRoot, 0, 0);
 
        m_bIsTyping = false;
        m_bIsFocused = false;
        
        // Make focusable again
        if (m_wRoot)
            m_wRoot.ClearFlags(WidgetFlags.NOFOCUS);
        
        m_OnFocusChangedEditBox.Invoke(this, m_wEditBox, false);
        
        ClearInteractionState();
    }
 
    //------------------------------------------------------------------------------------------------
    void OnInvalidInput()
    {
        // Show simple icon next to text when no message 
        if (!m_Hint || m_Hint && m_Hint.GetMessage().IsEmpty())
            AnimateWidget.Opacity(m_wWarningIcon, 1, m_fColorsAnimationTime, true);
        else if (m_Hint && !m_Hint.GetMessage().IsEmpty()) 
            m_Hint.SetVisible(true);
            
        AnimateWidget.Color(m_wColorOverlay, COLOR_INVALID_INPUT, m_fColorsAnimationTime);
        m_bValidInput = false;
    }
    
    //------------------------------------------------------------------------------------------------
    void ClearInvalidInput()
    {       
        AnimateWidget.Opacity(m_wWarningIcon, 0, m_fColorsAnimationTime, true);
        if (m_Hint) 
            m_Hint.SetVisible(false);
        
        AnimateWidget.Color(m_wColorOverlay, COLOR_VALID_INPUT, m_fColorsAnimationTime);
        m_bValidInput = false;
    }
    
    //------------------------------------------------------------------------------------------------
    void ChangeOverlayColor(Color color)
    {
        m_wColorOverlay.SetColor(color);
    }
    
    //------------------------------------------------------------------------------------------------
    void ResetOverlayColor()
    {
        AnimateWidget.Color(m_wColorOverlay, COLOR_VALID_INPUT, m_fColorsAnimationTime);
    }
    
    //------------------------------------------------------------------------------------------------
    protected void OnConfirm(Widget w)
    {
        if (m_bIsTyping)
            m_OnConfirm.Invoke(this, GetValue()); //TODO: this does not get called on gamepad!?
    }
    
    //------------------------------------------------------------------------------------------------
    protected void OnInternalButtonClicked()
    {
        ActivateWriteMode(true);
    }
    
    //------------------------------------------------------------------------------------------------
    protected string GetEditBoxText()
    {
        if (!m_wEditBox)
            return string.Empty;
 
        EditBoxWidget editBox = EditBoxWidget.Cast(m_wEditBox);
        if (editBox)
            return editBox.GetText();
 
        MultilineEditBoxWidget editMulti = MultilineEditBoxWidget.Cast(m_wEditBox);
        if (editMulti)
            return editMulti.GetText();
 
        return string.Empty;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void SetEditBoxText(string text)
    {
        if (!m_wEditBox)
            return;
 
        EditBoxWidget editBox = EditBoxWidget.Cast(m_wEditBox);
        if (editBox)
        {
            editBox.SetText(text);
            return;
        }
 
        MultilineEditBoxWidget editMulti = MultilineEditBoxWidget.Cast(m_wEditBox);
        if (editMulti)
            editMulti.SetText(text);
    }
 
    //------------------------------------------------------------------------------------------------
    protected string GetPlaceholderText()
    {
        EditBoxWidget editBox = EditBoxWidget.Cast(m_wEditBox);
        if (editBox)
            return editBox.GetPlaceholderText();
        return string.Empty;
    }
    
    //------------------------------------------------------------------------------------------------
    void SetPlaceholderText(string str)
    {
        EditBoxWidget editBox = EditBoxWidget.Cast(m_wEditBox);
        if (editBox)
            editBox.SetPlaceholderText(str);
    }
 
    //------------------------------------------------------------------------------------------------
    static SCR_EditBoxComponent GetEditBoxComponent(string name, Widget parent, bool searchAllChildren = true)
    {
        if (!parent || name == string.Empty)
            return null;
        
        Widget w;
        if (searchAllChildren)
            w = parent.FindAnyWidget(name);
        else
            w = parent.FindWidget(name);
        
        if (!w)
            return null;
        
        SCR_EditBoxComponent comp = SCR_EditBoxComponent.Cast(w.FindHandler(SCR_EditBoxComponent));
        return comp;
    }
    
    //------------------------------------------------------------------------------------------------
    void ActivateWriteMode(bool refocus = false)
    {
        if (refocus)
        {
            Widget target = m_wMultilineEditBoxWidget;
            if (!m_wMultilineEditBoxWidget)
                target = m_wEditBoxWidget;
            
            GetGame().GetWorkspace().SetFocusedWidget(target);
        }
        
        if (m_wMultilineEditBoxWidget)
            m_wMultilineEditBoxWidget.ActivateWriteMode();
 
 
        if (m_wEditBoxWidget)
            m_wEditBoxWidget.ActivateWriteMode();
    }
    
    //------------------------------------------------------------------------------------------------
    void ShowHint(bool show)
    {
        if (m_Hint)
            m_Hint.SetVisible(show);
    }
    
    //------------------------------------------------------------------------------------------------
    void ShowWriteIcon(bool show)
    {
        if (m_wWriteIconScale)
            m_wWriteIconScale.SetVisible(show);
    }
    
    //------------------------------------------------------------------------------------------------
    void UpdateInteractionState(bool forceDisabled)
    {
        int interactionStateUpdateDelay;
        if (forceDisabled)
        {
            m_bIsInWriteMode = false;
            interactionStateUpdateDelay = FOCUS_LOST_INTERACTION_STATE_UPDATE_DELAY;
        }
        else
        {
            //These don't come from a common parent :(
            if (m_wMultilineEditBoxWidget)
                m_bIsInWriteMode = m_wMultilineEditBoxWidget.IsInWriteMode();
            
            else if (m_wEditBoxWidget)
                m_bIsInWriteMode = m_wEditBoxWidget.IsInWriteMode();
        }
        
        if (m_bIsInWriteMode != m_bIsInWriteModePrevious || forceDisabled)
        {
            SCR_MenuHelper.SetActiveWidgetInteractionState(m_bIsInWriteMode, interactionStateUpdateDelay);
            
            UpdateBackgroundColor();
            
            if(m_bIsInWriteMode)
                m_OnWriteModeEnter.Invoke();
            else
                m_OnWriteModeLeave.Invoke(GetEditBoxText());
        }
        
        m_bIsInWriteModePrevious = m_bIsInWriteMode;
        
        if (GetEditBoxText() != m_sTextPrevious || forceDisabled)
        {
            m_sTextPrevious = GetEditBoxText();
            m_OnTextChange.Invoke(m_sTextPrevious);
        }
    }
    
    //------------------------------------------------------------------------------------------------
    void ClearInteractionState()
    {
        GetGame().GetCallqueue().Remove(UpdateInteractionState);
        UpdateInteractionState(true);
    }
    
    //------------------------------------------------------------------------------------------------
    protected void UpdateBackgroundColor()
    {
        if (!m_wEditBackground)
            return;
        
        Color idleColor = m_BackgroundDefault;
        if (m_bIsFocused)
            idleColor = m_BackgroundFocused;    
        
        if(m_bIsInWriteMode)
            m_BackgroundCurrent = m_BackgroundInteracting;
        else
            m_BackgroundCurrent = idleColor;
            
        AnimateWidget.Color(m_wEditBackground, m_BackgroundCurrent, m_fAnimationRate);
    }
    
    //------------------------------------------------------------------------------------------------
    void SetValue(string value) { SetEditBoxText(value); }
    string GetValue() { return GetEditBoxText(); }
    string GetPlaceHolderText() { return GetPlaceholderText(); }
    Widget GetEditBoxWidget() { return m_wEditBox; }
    bool IsValidInput() { return m_bValidInput; }
    SCR_WidgetHintComponent GetHint() { return m_Hint; }
    bool IsInWriteMode() { return m_bIsInWriteMode; }
    
    //------------------------------------------------------------------------------------------------
    SCR_EventHandlerComponent GetEVHComponent() 
    { 
        return m_EVHComponent; 
    }
    
    //------------------------------------------------------------------------------------------------
    void ConfirmValue(string value)
    {
        SetEditBoxText(value);
        OnConfirm(m_wRoot);
    }
    
};