WidgetHotbar.cs

using System;
using System.Collections.Generic;
using DG.Tweening;
using DG.Tweening.Core;
using DG.Tweening.Plugins.Options;
using UnityEngine;
using UnityEngine.UI;
 
// Token: 0x02000600 RID: 1536
public class WidgetHotbar : Widget, IDragParent
{
    // Token: 0x06002A92 RID: 10898 RVA: 0x000EF87A File Offset: 0x000EDA7A
    public override object CreateExtra()
    {
        return new WidgetHotbar.Extra();
    }
 
    // Token: 0x17000C28 RID: 3112
    // (get) Token: 0x06002A93 RID: 10899 RVA: 0x000EF881 File Offset: 0x000EDA81
    public WidgetHotbar.Extra extra
    {
        get
        {
            return base.config.extra as WidgetHotbar.Extra;
        }
    }
 
    // Token: 0x17000C29 RID: 3113
    // (get) Token: 0x06002A94 RID: 10900 RVA: 0x000EF893 File Offset: 0x000EDA93
    public Hotbar hotbar
    {
        get
        {
            return EMono.player.hotbars.bars[this.idHotbar];
        }
    }
 
    // Token: 0x17000C2A RID: 3114
    // (get) Token: 0x06002A95 RID: 10901 RVA: 0x000EF8AB File Offset: 0x000EDAAB
    // (set) Token: 0x06002A96 RID: 10902 RVA: 0x000EF8B8 File Offset: 0x000EDAB8
    public bool Visible
    {
        get
        {
            return this.extra.visible;
        }
        set
        {
            this.extra.visible = value;
        }
    }
 
    // Token: 0x17000C2B RID: 3115
    // (get) Token: 0x06002A97 RID: 10903 RVA: 0x000EF8C6 File Offset: 0x000EDAC6
    public override bool ShowInBuildMode
    {
        get
        {
            return this.extra.alwaysShow;
        }
    }
 
    // Token: 0x17000C2C RID: 3116
    // (get) Token: 0x06002A98 RID: 10904 RVA: 0x000EF8D3 File Offset: 0x000EDAD3
    public bool IsHotbarSpeed
    {
        get
        {
            return this.idHotbar == 7;
        }
    }
 
    // Token: 0x17000C2D RID: 3117
    // (get) Token: 0x06002A99 RID: 10905 RVA: 0x000EF8DE File Offset: 0x000EDADE
    public bool CanRegisterItem
    {
        get
        {
            return this.hotbar.IsUserHotbar;
        }
    }
 
    // Token: 0x06002A9A RID: 10906 RVA: 0x000EF8EC File Offset: 0x000EDAEC
    public override bool CanShowContextMenu()
    {
        if (this.hotbar.IsUserHotbar)
        {
            ButtonHotItem componentOf = InputModuleEX.GetComponentOf<ButtonHotItem>();
            if (componentOf && componentOf.item != null)
            {
                return true;
            }
        }
        return base.CanShowContextMenu();
    }
 
    // Token: 0x06002A9B RID: 10907 RVA: 0x000EF924 File Offset: 0x000EDB24
    public override void OnActivate()
    {
        this.mold = this.layout.CreateMold(null);
        if (this.idHotbar == 2)
        {
            WidgetHotbar.HotBarMainMenu = this;
        }
        if (this.idHotbar == 3)
        {
            WidgetHotbar.HotbarBuild = this;
        }
        if (this.idHotbar == 5)
        {
            WidgetHotbar.HotbarExtra = this;
        }
        if (this.extra.rows == 0)
        {
            this.extra.rows = this.hotbar.itemsPerPage;
        }
        this.hotbar.actor = this;
        this.Rebuild();
    }
 
    // Token: 0x06002A9C RID: 10908 RVA: 0x000EF9A5 File Offset: 0x000EDBA5
    public override void OnChangeActionMode()
    {
        base.OnChangeActionMode();
        if (this.hotbar.dirty)
        {
            this.hotbar.dirty = false;
            this.Rebuild();
        }
        this.RefreshHighlight();
    }
 
    // Token: 0x06002A9D RID: 10909 RVA: 0x000EF9D4 File Offset: 0x000EDBD4
    public void Rebuild()
    {
        this.buttons.Clear();
        this.layout.cellSize = EMono.setting.ui.iconSizes[this.extra.iconSize];
        this.layout.constraintCount = this.extra.width;
        this.layout.constraint = (this.extra.vertical ? GridLayoutGroup.Constraint.FixedColumnCount : GridLayoutGroup.Constraint.FixedRowCount);
        this.layout.startCorner = (this.extra.reverse ? GridLayoutGroup.Corner.LowerRight : GridLayoutGroup.Corner.UpperLeft);
        int num = this.extra.rows;
        if (this.extra.autoSize)
        {
            num = 0;
            int num2 = 0;
            while (num2 < this.hotbar.CurrentPage.items.Count && this.hotbar.CurrentPage.items[num2] != null)
            {
                num++;
                num2++;
            }
        }
        int num3 = (num - 1) / this.extra.width + 1;
        int num4 = this.extra.vertical ? this.extra.width : num3;
        int num5 = this.extra.vertical ? num3 : this.extra.width;
        this.imageGrid.uvRect = new Rect(1f, 1f, (float)num4, (float)num5);
        this.layout.DestroyChildren(false, true);
        for (int i = 0; i < num; i++)
        {
            ButtonHotItem buttonHotItem = Util.Instantiate<ButtonHotItem>(this.mold, this.layout);
            buttonHotItem.index = i;
            buttonHotItem.mainText.text = ((i > 10) ? "" : ((i + 1).ToString() ?? ""));
            buttonHotItem.widget = this;
            this.buttons.Add(buttonHotItem);
            if (this.useMask)
            {
                buttonHotItem.gameObject.AddComponent<RectMask2D>();
            }
        }
        this.layout.RebuildLayout(false);
        this.RebuildLayout(false);
        this.RebuildPage(-1);
    }
 
    // Token: 0x06002A9E RID: 10910 RVA: 0x000EFBD4 File Offset: 0x000EDDD4
    public void RebuildPage(int page = -1)
    {
        this.hotbar.SetPage((page == -1) ? this.hotbar.currentPage : page);
        foreach (ButtonHotItem buttonHotItem in this.buttons)
        {
            HotItem item = this.hotbar.GetItem(buttonHotItem.index, -1);
            buttonHotItem.SetItem(item);
        }
        this.SetVisible();
        this.RefreshHighlight();
    }
 
    // Token: 0x06002A9F RID: 10911 RVA: 0x000EFC64 File Offset: 0x000EDE64
    public static void RebuildPages()
    {
        foreach (Widget widget in EMono.ui.widgets.list)
        {
            WidgetHotbar widgetHotbar = widget as WidgetHotbar;
            if (widgetHotbar)
            {
                widgetHotbar.RebuildPage(-1);
            }
        }
    }
 
    // Token: 0x06002AA0 RID: 10912 RVA: 0x000EFCD0 File Offset: 0x000EDED0
    public void SwitchPage()
    {
        SE.ClickGeneral();
        this.RebuildPage((this.hotbar.currentPage == 0) ? 1 : 0);
    }
 
    // Token: 0x06002AA1 RID: 10913 RVA: 0x000EFCEE File Offset: 0x000EDEEE
    public HotItem GetItem(int index)
    {
        return this.hotbar.CurrentPage.items.TryGet(index, true);
    }
 
    // Token: 0x06002AA2 RID: 10914 RVA: 0x000EFD08 File Offset: 0x000EDF08
    public void TryUse(int index)
    {
        HotItem item = this.GetItem(index);
        if (item == null)
        {
            SE.BeepSmall();
            return;
        }
        item.OnClick(item.button, this.hotbar);
    }
 
    // Token: 0x06002AA3 RID: 10915 RVA: 0x000EFD38 File Offset: 0x000EDF38
    public void OnClickEmptyItem(ButtonHotItem b)
    {
        UIContextMenu uicontextMenu = EMono.ui.CreateContextMenu("ContextMenu");
        this.SetShortcutMenu(b, uicontextMenu);
        uicontextMenu.Show();
    }
 
    // Token: 0x06002AA4 RID: 10916 RVA: 0x000EFD64 File Offset: 0x000EDF64
    public override void OnSetContextMenu(UIContextMenu m)
    {
        ButtonHotItem b = InputModuleEX.GetComponentOf<ButtonHotItem>();
        if (this.showThisWidget || !b || b.item == null || base.IsSealed || b.widget.hotbar.IsLocked)
        {
            this.showThisWidget = false;
            SkinSet skin = base.config.skin.Skin;
            UIContextMenu uicontextMenu = m.AddChild("setting");
            UIContextMenu uicontextMenu2 = m.AddChild("style");
            if (!base.IsSealed)
            {
                uicontextMenu.AddSlider("numSlot", (float n) => n.ToString() ?? "", (float)this.extra.rows, delegate(float a)
                {
                    this.extra.rows = (int)a;
                    this.hotbar.SetSlotNum((int)a);
                    this.Rebuild();
                    this.ClampToScreen();
                }, 1f, 20f, true, false, false);
            }
            uicontextMenu2.AddSlider("iconSize", (float n) => n.ToString() ?? "", (float)this.extra.iconSize, delegate(float a)
            {
                this.extra.iconSize = (int)a;
                this.Rebuild();
                this.ClampToScreen();
            }, 0f, (float)(EMono.setting.ui.iconSizes.Count - 1), true, true, false);
            base.SetGridContextMenu(uicontextMenu2);
            uicontextMenu.AddToggle("vertical", this.extra.vertical, delegate(bool a)
            {
                this.extra.vertical = a;
                this.Rebuild();
                this.ClampToScreen();
            });
            uicontextMenu.AddToggle("doubleBar", this.extra.width == 2, delegate(bool a)
            {
                this.extra.width = (a ? 2 : 1);
                this.Rebuild();
                this.ClampToScreen();
            });
            uicontextMenu.AddToggle("reverseOrder", this.extra.reverse, delegate(bool a)
            {
                this.extra.reverse = a;
                this.Rebuild();
                this.ClampToScreen();
            });
            if (!base.IsSealed)
            {
                uicontextMenu.AddToggle("alwaysShow2", this.extra.alwaysShow, delegate(bool a)
                {
                    this.extra.alwaysShow = a;
                });
            }
            base.SetBaseContextMenu(m);
            if (!base.IsSealed)
            {
                Action <>9__12;
                m.AddButton("resetHotbar", delegate()
                {
                    string langDetail = "dialogResetHotbar";
                    Action actionYes;
                    if ((actionYes = <>9__12) == null)
                    {
                        actionYes = (<>9__12 = delegate()
                        {
                            EMono.player.hotbars.ResetHotbar(this.hotbar.id);
                            SE.Trash();
                        });
                    }
                    Dialog.YesNo(langDetail, actionYes, null, "yes", "no");
                }, true);
                return;
            }
        }
        else
        {
            m.AddButton("removeHotItem", delegate()
            {
                this.hotbar.SetItem(null, b.index, -1, false);
                this.RebuildPage(-1);
            }, true);
            b.item.OnShowContextMenu(m);
            m.AddToggle("alwaysShow", b.item.always, delegate(bool on)
            {
                b.item.always = on;
            });
            Action <>9__13;
            m.AddButton("thisWidget", delegate()
            {
                this.showThisWidget = true;
                List<Action> actionsNextFrame = EMono.core.actionsNextFrame;
                Action item;
                if ((item = <>9__13) == null)
                {
                    item = (<>9__13 = delegate()
                    {
                        this.ShowContextMenu();
                    });
                }
                actionsNextFrame.Add(item);
            }, true);
        }
    }
 
    // Token: 0x06002AA5 RID: 10917 RVA: 0x000EFFEC File Offset: 0x000EE1EC
    public void SetShortcutMenu(ButtonHotItem b, UIContextMenu m)
    {
        Action<UIContextMenu, HotItem> action = delegate(UIContextMenu _m, HotItem i)
        {
            _m.AddButton(i.Name, delegate()
            {
                this.SetItem(b, i);
            }, true);
        };
        UIContextMenu arg = m.AddChild("layerShortcuts");
        action(arg, new HotItemLayer
        {
            id = "LayerHelp"
        });
        action(arg, new HotItemLayer
        {
            id = "stash"
        });
        action(arg, new HotItemLayer
        {
            id = "LayerAbility"
        });
        action(arg, new HotItemLayer
        {
            id = "LayerChara"
        });
        action(arg, new HotItemLayer
        {
            id = "LayerJournal"
        });
        action(arg, new HotItemWidget
        {
            id = "Roster"
        });
        action(arg, new HotItemWidget
        {
            id = "Codex"
        });
        action(arg, new HotItemWidget
        {
            id = "Search"
        });
        action(arg, new HotItemWidget
        {
            id = "Tracker"
        });
        action(arg, new HotItemWidget
        {
            id = "Memo"
        });
        action(arg, new HotItemWidget
        {
            id = "QuestTracker"
        });
        arg = m.AddChild("utilShortcuts");
        action(arg, new HotItemToggle
        {
            type = HotItemToggle.Type.ToggleNoRoof
        });
        action(arg, new HotItemToggle
        {
            type = HotItemToggle.Type.muteBGM
        });
        action(arg, new HotItemToggle
        {
            type = HotItemToggle.Type.showBalloon
        });
        action(arg, new HotItemActionAudoDump());
        if (EMono.core.config.test.unsealWidgets)
        {
            arg = m.AddChild("menuShortcuts");
            action(arg, new HotItemContext
            {
                id = "system"
            });
            if (this == this.IsHotbarSpeed)
            {
                arg = m.AddChild("uniqueShortcuts");
                action(arg, new HotItemSpeed
                {
                    id = 0
                });
                action(arg, new HotItemSpeed
                {
                    id = 1
                });
                action(arg, new HotItemSpeed
                {
                    id = 2
                });
                action(arg, new HotItemSpeed
                {
                    id = 3
                });
            }
        }
        arg = m.AddChild("specialShortcuts");
        action(arg, new HotItemTogglePage());
        action(arg, new HotItemToggleVisible());
        m.AddButton("registerPos".lang(), delegate()
        {
            this.SetItem(b, new HotItemFocusPos
            {
                zone = EMono.game.activeZone,
                x = EMono.pc.pos.x,
                y = EMono.pc.pos.z
            });
        }, true);
        m.AddButton("hotActionEQSet".lang(), delegate()
        {
            this.SetItem(b, new HotItemEQSet().Register());
        }, true);
        m.AddButton("hotActionSleep".lang(), delegate()
        {
            this.SetItem(b, new HotItemActionSleep());
        }, true);
    }
 
    // Token: 0x06002AA6 RID: 10918 RVA: 0x000F0295 File Offset: 0x000EE495
    public void SetItem(ButtonHotItem b, HotItem item)
    {
        item = this.hotbar.SetItem(item, b.index, -1, false);
        b.SetItem(item);
        this.RefreshHighlight();
        this.SetVisible();
    }
 
    // Token: 0x06002AA7 RID: 10919 RVA: 0x000F02C4 File Offset: 0x000EE4C4
    public static void RefreshHighlights()
    {
        foreach (Widget widget in EMono.ui.widgets.list)
        {
            WidgetHotbar widgetHotbar = widget as WidgetHotbar;
            if (widgetHotbar)
            {
                widgetHotbar.RefreshHighlight();
            }
        }
    }
 
    // Token: 0x06002AA8 RID: 10920 RVA: 0x000F0330 File Offset: 0x000EE530
    public static void RefreshButtons()
    {
        foreach (Widget widget in EMono.ui.widgets.list)
        {
            WidgetHotbar widgetHotbar = widget as WidgetHotbar;
            if (widgetHotbar)
            {
                foreach (ButtonHotItem buttonHotItem in widgetHotbar.buttons)
                {
                    buttonHotItem.RefreshItem();
                }
            }
        }
    }
 
    // Token: 0x06002AA9 RID: 10921 RVA: 0x000F03D4 File Offset: 0x000EE5D4
    public bool RefreshHighlight()
    {
        bool result = false;
        foreach (ButtonHotItem buttonHotItem in this.buttons)
        {
            if (buttonHotItem.item != null)
            {
                if (buttonHotItem.item.UseIconForHighlight)
                {
                    if (buttonHotItem.item.ShouldHighlight())
                    {
                        result = true;
                        buttonHotItem.icon.sprite = buttonHotItem.item.GetSprite(true);
                    }
                    else
                    {
                        buttonHotItem.icon.sprite = buttonHotItem.item.GetSprite();
                    }
                }
                else if (buttonHotItem.item.ShouldHighlight())
                {
                    result = true;
                    buttonHotItem.image.sprite = buttonHotItem.item.SpriteHighlight;
                    if (!this.Visible && buttonHotItem.item.KeepVisibleWhenHighlighted)
                    {
                        this.ToggleVisible();
                    }
                }
                else
                {
                    buttonHotItem.image.sprite = EMono.core.refs.spritesHighlight[0];
                }
            }
        }
        return result;
    }
 
    // Token: 0x06002AAA RID: 10922 RVA: 0x000F04E4 File Offset: 0x000EE6E4
    public void _OnDirtyInventory()
    {
        foreach (ButtonHotItem buttonHotItem in this.buttons)
        {
            if (buttonHotItem.item != null)
            {
                buttonHotItem.Refresh();
            }
        }
    }
 
    // Token: 0x06002AAB RID: 10923 RVA: 0x000F0540 File Offset: 0x000EE740
    public void SetVisible()
    {
        UIButton componentOf = InputModuleEX.GetComponentOf<UIButton>();
        int num = 0;
        bool flag = false;
        foreach (ButtonHotItem buttonHotItem in this.buttons)
        {
            bool flag2 = buttonHotItem.item is HotItemToggleVisible;
            bool flag3 = this.Visible || flag2 || (buttonHotItem.item != null && buttonHotItem.item.always);
            buttonHotItem.image.enabled = flag3;
            buttonHotItem.mainText.enabled = flag3;
            buttonHotItem.icon.SetActive(flag3);
            if (!flag2 && buttonHotItem != componentOf)
            {
                buttonHotItem.DoNormalTransition(true);
            }
            if (flag3)
            {
                num++;
            }
            if (flag2)
            {
                flag = true;
            }
        }
        if (num == 0 && !this.Visible)
        {
            this.Visible = true;
            this.SetVisible();
        }
        base.CancelInvoke("CheckAutoHide");
        if (flag)
        {
            this.timeSinceBecomeVisible = 0f;
            base.InvokeRepeating("CheckAutoHide", 0.1f, 0.2f);
        }
        this.imageBG.enabled = (this.imageGrid.enabled = this.extra.visible);
        this.dragPanel.SetActive(this.extra.visible);
    }
 
    // Token: 0x06002AAC RID: 10924 RVA: 0x000F06A8 File Offset: 0x000EE8A8
    public void ToggleVisible()
    {
        this.extra.visible = !this.extra.visible;
        this.SetVisible();
        if (this.Visible)
        {
            this.imageBG.transform.localScale = new Vector3(0.6f, 0.6f, 1f);
            this.imageBG.transform.DOScale(1f, 0.12f).SetEase(Ease.Linear);
            this.imageGrid.transform.localScale = new Vector3(0.6f, 0.6f, 1f);
            this.imageGrid.transform.DOScale(1f, 0.12f).SetEase(Ease.Linear);
            foreach (ButtonHotItem buttonHotItem in this.buttons)
            {
                if (!(buttonHotItem.item is HotItemToggleVisible) && (buttonHotItem.item == null || !buttonHotItem.item.always))
                {
                    buttonHotItem.transform.localScale = new Vector3(0.6f, 0.6f, 1f);
                    buttonHotItem.transform.DOScale(1f, 0.12f).SetEase(Ease.Linear);
                }
            }
            this.imageBG.SetAlpha(0f);
            this.imageGrid.SetAlpha(0f);
            SkinConfig skin = base.config.skin;
            this.imageBG.DOFade(skin.bgColor.a, 0.4f).SetEase(Ease.OutQuint);
            this.imageGrid.DOFade(skin.gridColor.a, 0.4f).SetEase(Ease.OutQuint);
        }
    }
 
    // Token: 0x06002AAD RID: 10925 RVA: 0x000F0878 File Offset: 0x000EEA78
    public void CheckAutoHide()
    {
        if (!this.Visible)
        {
            return;
        }
        this.timeSinceBecomeVisible += 0.2f;
        if (this.timeSinceBecomeVisible < 1f)
        {
            return;
        }
        if (Input.GetMouseButton(0) || EMono.ui.contextMenu.currentMenu != null || WidgetHotbar.registering)
        {
            this.timeSinceBecomeVisible = 0f;
            return;
        }
        if (InputModuleEX.IsPointerOver(base.transform))
        {
            this.timeSinceBecomeVisible = 0f;
            return;
        }
        foreach (ButtonHotItem buttonHotItem in this.buttons)
        {
            if (buttonHotItem.item != null && buttonHotItem.item.KeepVisibleWhenHighlighted && buttonHotItem.item.ShouldHighlight())
            {
                return;
            }
        }
        this.ToggleVisible();
    }
 
    // Token: 0x06002AAE RID: 10926 RVA: 0x000F0964 File Offset: 0x000EEB64
    public void OnStartDrag(UIButton b)
    {
        EMono.ui.hud.SetDragImage(b.icon, null, null);
    }
 
    // Token: 0x06002AAF RID: 10927 RVA: 0x000F0980 File Offset: 0x000EEB80
    public void OnDrag(UIButton b)
    {
        string text = "";
        if (this.GetSwapButton(b))
        {
            text = "hotitemSwap";
        }
        else if (!EMono.ui.isPointerOverUI)
        {
            text = "hotitemTrash";
        }
        EMono.ui.hud.SetDragText(text, null);
    }
 
    // Token: 0x06002AB0 RID: 10928 RVA: 0x000F09CC File Offset: 0x000EEBCC
    public ButtonHotItem GetSwapButton(UIButton b)
    {
        foreach (Widget widget in EMono.ui.widgets.list)
        {
            WidgetHotbar widgetHotbar = widget as WidgetHotbar;
            if (!(widgetHotbar == null))
            {
                foreach (ButtonHotItem buttonHotItem in widgetHotbar.buttons)
                {
                    if (InputModuleEX.IsPointerOver(buttonHotItem) && b != buttonHotItem)
                    {
                        return buttonHotItem;
                    }
                }
            }
        }
        return null;
    }
 
    // Token: 0x06002AB1 RID: 10929 RVA: 0x000F0A84 File Offset: 0x000EEC84
    public void OnEndDrag(UIButton b, bool cancel = false)
    {
        EMono.ui.hud.imageDrag.SetActive(false);
        ButtonHotItem swapButton = this.GetSwapButton(b);
        if (swapButton)
        {
            SE.SelectHotitem();
            ButtonHotItem buttonHotItem = b as ButtonHotItem;
            HotItem hotItem = (HotItem)swapButton.item;
            HotItem hotItem2 = (HotItem)buttonHotItem.item;
            Hotbar hotbar = swapButton.widget.hotbar;
            Hotbar hotbar2 = buttonHotItem.widget.hotbar;
            hotbar.actor.SetItem(swapButton, hotItem2);
            hotbar2.actor.SetItem(buttonHotItem, hotItem);
            if (hotItem != null)
            {
                hotItem.button = buttonHotItem;
                hotItem.hotbar = hotbar2;
            }
            if (hotItem2 != null)
            {
                hotItem2.button = swapButton;
                hotItem2.hotbar = hotbar;
            }
            UIInventory.RefreshAllList();
            return;
        }
        if (EMono.ui.isPointerOverUI)
        {
            SE.Beep();
            return;
        }
        SE.Trash();
        this.SetItem(b as ButtonHotItem, null);
        UIInventory.RefreshAllList();
    }
 
    // Token: 0x04001804 RID: 6148
    public static bool registering;
 
    // Token: 0x04001805 RID: 6149
    public static bool dirtyCurrentItem;
 
    // Token: 0x04001806 RID: 6150
    public static HotItem registeringItem;
 
    // Token: 0x04001807 RID: 6151
    public static WidgetHotbar HotbarBuild;
 
    // Token: 0x04001808 RID: 6152
    public static WidgetHotbar HotBarMainMenu;
 
    // Token: 0x04001809 RID: 6153
    public static WidgetHotbar HotbarExtra;
 
    // Token: 0x0400180A RID: 6154
    public int idHotbar;
 
    // Token: 0x0400180B RID: 6155
    public GridLayoutGroup layout;
 
    // Token: 0x0400180C RID: 6156
    public ButtonHotItem mold;
 
    // Token: 0x0400180D RID: 6157
    public RawImage imageGrid;
 
    // Token: 0x0400180E RID: 6158
    public Image imageSelect;
 
    // Token: 0x0400180F RID: 6159
    public Hotbar.Type type;
 
    // Token: 0x04001810 RID: 6160
    public bool useMask;
 
    // Token: 0x04001811 RID: 6161
    [NonSerialized]
    public List<ButtonHotItem> buttons = new List<ButtonHotItem>();
 
    // Token: 0x04001812 RID: 6162
    private bool showThisWidget;
 
    // Token: 0x04001813 RID: 6163
    private float timeSinceBecomeVisible;
 
    // Token: 0x02000B6F RID: 2927
    public class Extra
    {
        // Token: 0x04002DE6 RID: 11750
        public int iconSize = 2;
 
        // Token: 0x04002DE7 RID: 11751
        public int width = 1;
 
        // Token: 0x04002DE8 RID: 11752
        public int rows;
 
        // Token: 0x04002DE9 RID: 11753
        public bool showShortcut;
 
        // Token: 0x04002DEA RID: 11754
        public bool vertical;
 
        // Token: 0x04002DEB RID: 11755
        public bool visible;
 
        // Token: 0x04002DEC RID: 11756
        public bool alwaysShow;
 
        // Token: 0x04002DED RID: 11757
        public bool reverse;
 
        // Token: 0x04002DEE RID: 11758
        public bool autoSize;
    }
}