KeybindingsContainer.c

См. документацию.

//container for various subgroups and their elements
class KeybindingsContainer extends ScriptedWidgetEventHandler
{
    protected const int                                 NO_SORTING = -1;
    protected Widget                                  m_Root;
    protected KeybindingsMenu                           m_Menu;
    protected ScrollWidget                              m_Scroll;
    
    protected ref map<int, ref ElementArray>          m_KeyWidgetElements; //<input_action_id,<KeybindingElementNew>>
    protected int                                       m_CurrentSettingKeyIndex = -1;
    protected int                                       m_CurrentSettingAlternateKeyIndex = -1;
    
    protected ref array<Widget>                        m_Subgroups;
    
    void KeybindingsContainer( int index, Input input, Widget parent, KeybindingsMenu menu )
    {
        m_KeyWidgetElements  = new map<int, ref ElementArray>;
        m_Menu            = menu;
        
        m_Root    = GetGame().GetWorkspace().CreateWidgets( GetLayoutName(), parent );
        m_Scroll = ScrollWidget.Cast(m_Root.FindAnyWidget("group_scroll"));
        Widget container  = m_Root.FindAnyWidget( "group_scroll" );
        
        CreateSubgroups(container,input);
        
        container.Update();
        
        m_Root.SetHandler( this );
    }
    
    string GetLayoutName()
    {
        return "gui/layouts/new_ui/options/keybindings_selectors/keybinding_container.layout";
    }
    
    void OnSelectKBPreset( int index )
    {
        GetUApi().PresetSelect( index );
        ReloadElements();
        GetUApi().Export();
        GetUApi().SaveInputPresetMiscData();
    }
    
    void ReloadElements()
    {
        foreach ( ElementArray elements : m_KeyWidgetElements )
        {
            foreach (KeybindingElementNew element : elements)
            {
                element.Reload();
            }
        }
    }
    
    void AddSubgroup( int sort_index, Widget parent, Input input )
    {
        Widget subgroup               = GetGame().GetWorkspace().CreateWidgets( "gui/layouts/new_ui/options/keybindings_selectors/keybinding_subgroup.layout", parent );
        Widget subgroup_content   = subgroup.FindAnyWidget( "subgroup_content" );
        
        TIntArray input_actions;
        if (sort_index != NO_SORTING)
        {
            input_actions = InputUtils.GetInputActionSortingMap().Get(sort_index);
        }
        else
        {
            input_actions = InputUtils.GetUnsortedInputActions();
        }
        
        for (int i = 0; i < input_actions.Count(); i++)
        {
            AddElement( input_actions[i], subgroup_content, input );
        }
        
        m_Subgroups.Insert(subgroup);
        
        subgroup_content.Update();
    }
    
    void CreateSubgroups( Widget parent, Input input )
    {
        m_Subgroups = new array<Widget>;
        
        int sort_count = InputUtils.GetInputActionSortingMap().Count();
        for (int i = 0; i < sort_count; i++)
        {
            if (InputUtils.GetInputActionSortingMap().GetElement(i) && InputUtils.GetInputActionSortingMap().GetElement(i).Count() > 0)
            {
                AddSubgroup(InputUtils.GetInputActionSortingMap().GetKey(i),parent,input);
            }
        }
        
        //any unssorted inputs go here
        if (InputUtils.GetUnsortedInputActions() && InputUtils.GetUnsortedInputActions().Count() > 0)
        {
            AddSubgroup(NO_SORTING,parent,input);
        }
    }
    
    void AddElement( int index, Widget parent, Input input )
    {
        //create array if needed
        if (!m_KeyWidgetElements.Get(index))
        {
            ElementArray elements = new ElementArray;
            m_KeyWidgetElements.Insert( index, elements );
        }
        
        KeybindingElementNew element = new KeybindingElementNew( index, parent, this );
        m_KeyWidgetElements.Get(index).Insert(element);
    }
    
    bool IsEnteringKeyBind()
    {
        return ( m_CurrentSettingKeyIndex != -1 || m_CurrentSettingAlternateKeyIndex != -1 );
    }
    
    void ClearKeybind( int key_index )
    {
        m_Menu.ClearKeybind( key_index );
    }
    
    void ClearAlternativeKeybind( int key_index )
    {
        m_Menu.ClearAlternativeKeybind( key_index );
    }
    
    void StartEnteringKeybind( int key_index )
    {
        m_CurrentSettingAlternateKeyIndex  = -1;
        m_CurrentSettingKeyIndex            = key_index;
        m_Menu.StartEnteringKeybind( key_index );
    }
    
    void CancelEnteringKeybind()
    {
        if ( m_CurrentSettingKeyIndex != -1 )
        {
            foreach (KeybindingElementNew element : m_KeyWidgetElements.Get( m_CurrentSettingKeyIndex ))
            {
                element.CancelEnteringKeybind();
            }
            m_CurrentSettingKeyIndex = -1;
        }
    }
    
    void StartEnteringAlternateKeybind( int key_index )
    {
        m_CurrentSettingKeyIndex            = -1;
        m_CurrentSettingAlternateKeyIndex  = key_index;
        m_Menu.StartEnteringAlternateKeybind( key_index );
    }
    
    void CancelEnteringAlternateKeybind()
    {
        if ( m_CurrentSettingAlternateKeyIndex != -1 )
        {
            foreach (KeybindingElementNew element : m_KeyWidgetElements.Get( m_CurrentSettingAlternateKeyIndex ))
            {
                element.CancelEnteringKeybind();
            }
            m_CurrentSettingAlternateKeyIndex = -1;
        }
    }
    
    bool IsChanged()
    {
        foreach (ElementArray elements : m_KeyWidgetElements)
        {
            foreach (KeybindingElementNew element : elements)
            {
                if (element.IsChanged() || element.IsAlternateChanged())
                {
                    return true;
                }
            }
        }
        return false;
    }
    
    void Apply()
    {
        UAInputAPI ua_api = GetUApi();
        int input_index = 0;
        
        foreach (ElementArray elements : m_KeyWidgetElements)
        {
            foreach (int element_index, KeybindingElementNew element : elements)
            {
                if (element_index == 0)
                {
                    UAInput input = ua_api.GetInputByID( m_KeyWidgetElements.GetKey(input_index) );
                    int i;
                    if ( element.IsChanged() )
                    {
                        array<int> new_keys       = element.GetChangedBinds();
                        input.ClearDeviceBind(EUAINPUT_DEVICE_KEYBOARDMOUSE);
                        if ( new_keys.Count() > 0 )
                        {
                            input.BindComboByHash( new_keys.Get( 0 ) );
                            for( i = 1; i < new_keys.Count(); i++ )
                            {
                                input.BindComboByHash( new_keys.Get( i ) );
                            }
                        }
                    }
                    
                    if ( element.IsAlternateChanged() )
                    {
                        array<int> new_alt_keys = element.GetChangedAlternateBinds();
                        
                        if ( input.AlternativeCount() == 0 )
                        {
                            input.AddAlternative();               
                        }
                        
                        input.ClearDeviceBind(EUAINPUT_DEVICE_CONTROLLER);
                        
                        if ( new_alt_keys.Count() > 0 )
                        {
                            input.BindComboByHash( new_alt_keys.Get( 0 ) );
                            for( i = 1; i < new_alt_keys.Count(); i++ )
                            {
                                input.BindComboByHash( new_alt_keys.Get( i ) );
                            }
                        }
                    }
                }
                element.Reload();
            }
            input_index++;
        }
    }
    
    void Reset(bool forced = false)
    {
        foreach ( ElementArray elements : m_KeyWidgetElements )
        {
            foreach (KeybindingElementNew element : elements)
            {
                if ( element.IsChanged() || element.IsAlternateChanged() || forced )
                {
                    element.Reload();
                }
            }
        }
    }
    
    void Update( float timeslice )
    {
        if ( m_CurrentSettingKeyIndex != -1 || m_CurrentSettingAlternateKeyIndex != -1 )
        {
            UAInputAPI ua_api = GetUApi();
            if ( ua_api.DeterminePressedButton() != 0 )
            {
                string name;
                string text;
                ref array<int> new_keybinds = new array<int>;
                
                // remove previous backlit
                GetDayZGame().GetBacklit().KeybindingClear();
 
                for( int i = 0; i < ua_api.DeterminedCount(); ++i )
                {
                    int kb_id = ua_api.GetDetermined( i );
                    new_keybinds.Insert( kb_id );
                    
                    // light up specific key
                    GetDayZGame().GetBacklit().KeybindingShow(kb_id);
                }
                
                if ( m_CurrentSettingKeyIndex != -1 )
                {
                    m_Menu.ConfirmKeybindEntry( new_keybinds );
                    foreach (KeybindingElementNew element : m_KeyWidgetElements.Get( m_CurrentSettingKeyIndex ))
                    {
                        element.Reload( new_keybinds, false );
                    }
                    m_CurrentSettingKeyIndex = -1;
                }
                else if ( m_CurrentSettingAlternateKeyIndex != -1 )
                {
                    m_Menu.ConfirmAlternateKeybindEntry( new_keybinds );
                    foreach (KeybindingElementNew elementAlternate : m_KeyWidgetElements.Get( m_CurrentSettingAlternateKeyIndex ))
                    {
                        elementAlternate.Reload( new_keybinds, true );
                    }
                    m_CurrentSettingAlternateKeyIndex = -1;
                }
            }
        }
    }
    
    void SwitchSubgroup(int index)
    {
        Widget w;
        for (int i = 0; i < m_Subgroups.Count(); i++)
        {
            w = m_Subgroups[i];
            w.Show(index == i);
        }
        
        m_Scroll.VScrollToPos01(0);
    }
}
 
typedef array<ref KeybindingElementNew> ElementArray;