Beispiel #1
0
        protected void MenuTheme_CheckedChanged(object sender, EventArgs e)
        {
            MenuCheckBox menuCheckBox = sender as MenuCheckBox;

            if (!menuCheckBox.Checked)
            {
                // CheckedChanged会触发两次,一次是取消选中的菜单项,另一次是选中的菜单项;
                // 这里不处理取消选中的菜单项的事件,从而防止此函数重复执行两次
                return;
            }

            string themeValue = "Blue";
            string themeID    = GetSelectedMenuID(MenuTheme);

            switch (themeID)
            {
            case "MenuThemeBlue":
                themeValue = "blue";

                break;

            case "MenuThemeGray":
                themeValue = "gray";

                break;

            case "MenuThemeAccess":
                themeValue = "access";

                break;
            }

            SaveToCookieAndRefresh("Theme", themeValue);
        }
Beispiel #2
0
        protected void MenuStyle_CheckedChanged(object sender, EventArgs e)
        {
            MenuCheckBox menuCheckBox = sender as MenuCheckBox;

            if (!menuCheckBox.Checked)
            {
                // CheckedChanged会触发两次,一次是取消选中的菜单项,另一次是选中的菜单项;
                // 这里不处理取消选中的菜单项的事件,从而防止此函数重复执行两次
                return;
            }

            string menuValue   = "menu";
            string menuStyleID = GetSelectedMenuID(MenuStyle);

            switch (menuStyleID)
            {
            case "MenuStyleTree":
                menuValue = "tree";
                break;

            case "MenuStyleAccordion":
                menuValue = "accordion";
                break;
            }
            SaveToCookieAndRefresh("MenuStyle", menuValue);
        }
Beispiel #3
0
        protected void MenuLang_CheckedChanged(object sender, EventArgs e)
        {
            MenuCheckBox menuCheckBox = sender as MenuCheckBox;

            if (!menuCheckBox.Checked)
            {
                // CheckedChanged会触发两次,一次是取消选中的菜单项,另一次是选中的菜单项;
                // 这里不处理取消选中的菜单项的事件,从而防止此函数重复执行两次
                return;
            }

            string langValue = "zh_cn";
            string langID    = GetSelectedMenuID(MenuLang);

            switch (langID)
            {
            case "MenuLangZHCN":
                langValue = "zh_cn";
                break;

            case "MenuLangZHTW":
                langValue = "zh_tw";
                break;

            case "MenuLangEN":
                langValue = "en";
                break;
            }

            SaveToCookieAndRefresh("Language", langValue);
        }
Beispiel #4
0
        private void VolumeCheckBoxClicked(object sender, EventArgs e)
        {
            MenuCheckBox buttonSender = (MenuCheckBox)sender;

            buttonSender.Change();
            GameSettings._Volume = buttonSender.IsChecked;
            GameSettings.SaveSettings();
        }
Beispiel #5
0
        private void FullScreenCheckBoxClicked(object sender, EventArgs e)
        {
            MenuCheckBox buttonSender = (MenuCheckBox)sender;

            buttonSender.Change();
            GameSettings._FullScreen = buttonSender.IsChecked;
            GameSettings.SaveSettings();
            GlobalDevices._GraphicsDeviceManager.IsFullScreen = GameSettings._FullScreen;
            GlobalDevices._GraphicsDeviceManager.ApplyChanges();
        }
Beispiel #6
0
 private void SetSelectedMenuItem(MenuButton menuButton, string selectedDataTag)
 {
     foreach (FineUIPro.MenuItem item in menuButton.Menu.Items)
     {
         MenuCheckBox checkBox = (item as MenuCheckBox);
         if (checkBox != null)
         {
             checkBox.Checked = checkBox.AttributeDataTag == selectedDataTag;
         }
     }
 }
Beispiel #7
0
            private void Create(AbilityInfo data)
            {
                var abilityKey   = data.AbilitySlot.ToFriendlyString();
                var champ        = data.Champion;
                var enabledCheck = new MenuCheckBox("enabled_" + data.Champion + abilityKey,
                                                    "Handle aiming for " + champ + "'s " + abilityKey + " (" + data.AbilityType.ToFriendlyString() + ")");

                enabledCheck.OnValueChange += args => Enabled = args.NewValue;
                _menuItems.Add(Skills.Add(enabledCheck));
                Enabled = enabledCheck.CurrentValue;
            }
        public static void Init()
        {
            SkillCheckBoxes = new Dictionary <string, bool>();

            HoyerMainMenu = MainMenu.GetMenu("Hoyer.MainMenu");
            VareshMenu    = HoyerMainMenu.Add(new Menu("HoyerVaresh", "Varesh", true));

            VareshMenu.Add(new MenuLabel("Varesh"));
            _enabledBox = new MenuCheckBox("Varesh_enabled", "Enabled");
            _enabledBox.OnValueChange += delegate(ChangedValueArgs <bool> args) { Main.Enabled = args.NewValue; };
            VareshMenu.Add(_enabledBox);

            VareshMenu.AddSeparator();

            _comboKey = new MenuKeybind("Varesh_combokey", "Combo key", KeyCode.V);
            _comboKey.OnValueChange += delegate(ChangedValueArgs <bool> args) { Main.SetMode(args.NewValue); };
            VareshMenu.Add(_comboKey);

            _comboToggle = new MenuCheckBox("Varesh_combotoggle", "Should Combo key be a toggle", false);
            _comboToggle.OnValueChange += delegate(ChangedValueArgs <bool> args) { _comboKey.IsToggle = args.NewValue; };
            VareshMenu.Add(_comboToggle);

            _aimUserInput = new MenuCheckBox("Varesh_aimuserinput", "Apply aim logic when combo isn't active");
            _aimUserInput.OnValueChange += delegate(ChangedValueArgs <bool> args) { AimUserInput = args.NewValue; };
            VareshMenu.Add(_aimUserInput);

            _useCursor = new MenuCheckBox("Varesh_usecursor", "Use cursor pos for target selection");
            _useCursor.OnValueChange += delegate(ChangedValueArgs <bool> args) { UseCursor = args.NewValue; };
            VareshMenu.Add(_useCursor);

            _interruptSpells = new MenuCheckBox("Varesh_interruptspells", "Interrupt spellcasts if aim logic is active and no valid targets");
            VareshMenu.Add(_interruptSpells);
            _neverInterruptE = new MenuCheckBox("Varesh_neverinterrupte", "Never interrupt E");
            _neverInterruptE.OnValueChange += delegate(ChangedValueArgs <bool> args) { NeverInterruptE = args.NewValue; };
            _interruptSpells.OnValueChange += delegate(ChangedValueArgs <bool> args)
            {
                InterruptSpells         = args.NewValue;
                _neverInterruptE.Hidden = !args.NewValue;
            };
            VareshMenu.Add(_neverInterruptE);

            InitSkillMenu();
            FirstRun();

            Base.Main.DelayAction(delegate
            {
                var drawText            = HoyerMainMenu.Get <Menu>("Hoyer.Debug").Add(new MenuCheckBox("Varesh_drawdebug", "Draw Varesh debug text"));
                drawText.OnValueChange += delegate(ChangedValueArgs <bool> args) { DrawDebugText = args.NewValue; };
                DrawDebugText           = drawText.CurrentValue;
            }, 0.8f);
        }
Beispiel #9
0
        public static void Init()
        {
            HoyerMainMenu = MainMenu.GetMenu("Hoyer.MainMenu");
            JumongMenu    = HoyerMainMenu.Add(new Menu("HoyerJumong", "Jumong", true));

            JumongMenu.Add(new MenuLabel("Jumong"));
            _enabledBox = new MenuCheckBox("jumong_enabled", "Enabled");
            _enabledBox.OnValueChange += delegate(ChangedValueArgs <bool> args) { Main.Enabled = args.NewValue; };
            JumongMenu.Add(_enabledBox);

            JumongMenu.AddSeparator();

            _comboKey = new MenuKeybind("jumong_combokey", "Combo key", KeyCode.V);
            _comboKey.OnValueChange += delegate(ChangedValueArgs <bool> args) { Main.SetMode(args.NewValue); };
            JumongMenu.Add(_comboKey);

            _comboToggle = new MenuCheckBox("jumong_combotoggle", "Should Combo key be a toggle", false);
            _comboToggle.OnValueChange += delegate(ChangedValueArgs <bool> args) { _comboKey.IsToggle = args.NewValue; };
            JumongMenu.Add(_comboToggle);

            _aimUserInput = new MenuCheckBox("jumong_aimuserinput", "Apply aim logic when combo isn't active");
            _aimUserInput.OnValueChange += delegate(ChangedValueArgs <bool> args) { AimUserInput = args.NewValue; };
            JumongMenu.Add(_aimUserInput);

            _useCursor = new MenuCheckBox("jumong_usecursor", "Use cursor pos for target selection");
            _useCursor.OnValueChange += delegate(ChangedValueArgs <bool> args) { UseCursor = args.NewValue; };
            JumongMenu.Add(_useCursor);

            _avoidStealthed = new MenuCheckBox("jumong_ignorestealthed", "Ignore stealthed enemies", false);
            _avoidStealthed.OnValueChange += delegate(ChangedValueArgs <bool> args) { AvoidStealthed = args.NewValue; };
            JumongMenu.Add(_avoidStealthed);

            _interruptSpells = new MenuCheckBox("Varesh_interruptspells", "Interrupt spellcasts if aim logic is active and no valid targets");
            _interruptSpells.OnValueChange += delegate(ChangedValueArgs <bool> args)
            {
                InterruptSpells = args.NewValue;
            };
            JumongMenu.Add(_interruptSpells);

            InitSkillMenu();

            FirstRun();
            Base.Main.DelayAction(delegate
            {
                var drawText            = HoyerMainMenu.Get <Menu>("Hoyer.Debug").Add(new MenuCheckBox("Jumong_drawdebug", "Draw Jumong debug text"));
                drawText.OnValueChange += delegate(ChangedValueArgs <bool> args) { DrawDebugText = args.NewValue; };
                DrawDebugText           = drawText.CurrentValue;
            }, 0.8f);
        }
Beispiel #10
0
 private void SetSelectedMenuID(MenuButton menuButton, string selectedMenuID)
 {
     foreach (MenuItem item in menuButton.Menu.Items)
     {
         MenuCheckBox menu = (item as MenuCheckBox);
         if (menu != null && menu.ID == selectedMenuID)
         {
             menu.Checked = true;
         }
         else
         {
             menu.Checked = false;
         }
     }
 }
		public ToolStripItem[] BuildSubmenu(Codon codon, object owner)
		{
			control = (TextEditorControl)owner;
			
			ArrayList menuItems = new ArrayList();
			
			foreach (DictionaryEntry entry in HighlightingManager.Manager.HighlightingDefinitions) {
				MenuCheckBox item = new MenuCheckBox(entry.Key.ToString());
				item.Click    += new EventHandler(ChangeSyntax);
				item.Checked = control.Document.HighlightingStrategy.Name == entry.Key.ToString();
				menuItems.Add(item);
			}
			menuCommands = (ToolStripItem[])menuItems.ToArray(typeof(ToolStripItem));
			return menuCommands;
		}
Beispiel #12
0
        public ToolStripItem[] BuildSubmenu(Codon codon, object owner)
        {
            control = (TextEditorControl)owner;

            ArrayList menuItems = new ArrayList();

            foreach (DictionaryEntry entry in HighlightingManager.Manager.HighlightingDefinitions)
            {
                MenuCheckBox item = new MenuCheckBox(entry.Key.ToString());
                item.Click  += new EventHandler(ChangeSyntax);
                item.Checked = control.Document.HighlightingStrategy.Name == entry.Key.ToString();
                menuItems.Add(item);
            }
            menuCommands = (ToolStripItem[])menuItems.ToArray(typeof(ToolStripItem));
            return(menuCommands);
        }
Beispiel #13
0
 public static void SetStatus(this DodgeAbilityInfo info, bool newValue)
 {
     if (newValue && _activeSpell == null)
     {
         _activeSpell = (MenuCheckBox)EvadeStatusMenuByChampion[info.Champion]
                        .FirstOrDefault(s => s.Name == "isActive_" + info.Champion + info.AbilitySlot.ToFriendlyString());
         if (_activeSpell != null)
         {
             _activeSpell.CurrentValue = true;
         }
     }
     else if (!newValue && _activeSpell != null)
     {
         _activeSpell.CurrentValue = false;
         _activeSpell = null;
     }
 }
Beispiel #14
0
        public static void Init()
        {
            HoyerMenu = MainMenu.AddMenu("Hoyer.MainMenu", "Hoyer");
            BaseMenu  = HoyerMenu.Add(new Menu("Hoyer.Base", "Base", true));
            BaseMenu.AddLabel("Common Utils");

            var hideNames = new MenuCheckBox("hide_names", "Hide all names (Video Mode)", false);

            hideNames.OnValueChange += delegate(ChangedValueArgs <bool> args)
            {
                HideNames.Active = args.NewValue;
                if (!args.NewValue)
                {
                    foreach (var label in Object.FindObjectsOfType(typeof(TextMeshProUGUI)))
                    {
                        var component = ((MonoBehaviour)label).GetComponent <TextMeshProUGUI>();
                        if (label.name == "Name" || label.name == "NameText")
                        {
                            component.enabled = true;
                        }
                    }
                }
            };
            BaseMenu.Add(hideNames);

            var showStealth = new MenuCheckBox("show_stealth", "Show predicted stealth positions");

            showStealth.OnValueChange += delegate(ChangedValueArgs <bool> args) { StealthPrediction.DrawStealthed = args.NewValue; };
            BaseMenu.Add(showStealth);

            BaseMenu.AddSeparator();

            InitPredMenu();

            InitHumanizerMenu();

            LoadValues();

            Initialize.Invoke();
            Main.DelayAction(delegate
            {
                Update.Invoke();
            }, 1);
            Game.OnMatchStart += MatchUpdate;
            Game.OnMatchEnd   += MatchUpdate;
        }
Beispiel #15
0
 void ChangeSyntax(object sender, EventArgs e)
 {
     if (control != null)
     {
         MenuCheckBox item = (MenuCheckBox)sender;
         foreach (MenuCheckBox i in menuCommands)
         {
             i.Checked = false;
         }
         item.Checked = true;
         try {
             control.SetHighlighting(item.Text);
         } catch (HighlightingDefinitionInvalidException ex) {
             MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
         }
         control.Refresh();
     }
 }
Beispiel #16
0
        public static void Init()
        {
            try
            {
                EvadeSkillsMenuByChampion     = new Dictionary <string, List <MenuItem> >();
                DodgeableSkillsMenuByChampion = new Dictionary <string, List <MenuItem> >();
                EvadeStatusMenuByChampion     = new Dictionary <string, List <MenuItem> >();
                EvadeOverrideMenuByChampion   = new Dictionary <string, List <MenuItem> >();

                HoyerMain = MainMenu.GetMenu("Hoyer.MainMenu");
                EvadeMain = HoyerMain.Add(new Menu("Evade.MainMenu", "Evade", true));

                EvadeMain.Add(new MenuLabel("Evade"));
                _enabledSkillsBox = new MenuCheckBox("evade_skills", "Use skills to dodge dangerous skillshots");
                _enabledSkillsBox.OnValueChange += delegate(ChangedValueArgs <bool> args) { Evade.UseSkills = args.NewValue; };
                EvadeMain.Add(_enabledSkillsBox);

                _enabledWalkBox = new MenuCheckBox("evade_walk", "Try to walk out of skillshots (doesnt work well enough yet)", false);
                _enabledWalkBox.OnValueChange += delegate(ChangedValueArgs <bool> args) { Evade.UseWalk = args.NewValue; };
                _enabledWalkBox.Hidden         = true;
                EvadeMain.Add(_enabledWalkBox);

                _enabledDrawings = new MenuCheckBox("evade_draw", "Draw Evade Drawings", false);
                _enabledDrawings.OnValueChange += delegate(ChangedValueArgs <bool> args) { DrawEvade.Active = args.NewValue; };
                EvadeMain.Add(_enabledDrawings);

                _jumpMode = EvadeMain.Add(new MenuComboBox("evade_jumpmode", "Jump Logic", 1, new[] { "Mouse Cursor", "DaPip's BestJumpPos" }));
                _jumpMode.OnValueChange += delegate(ChangedValueArgs <int> args) { JumpMode = args.NewValue; };

                EvadeStatusInit();
                EvadeSkillsInit();
                EvadeEnemySkillsInit();
                EvadeOverrideInit();

                AddDodgeableEntries();
                AddEvadeEntries();
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }

            FirstRun();
        }
 void ChangeSyntax(object sender, EventArgs e)
 {
     if (control != null)
     {
         MenuCheckBox item = (MenuCheckBox)sender;
         foreach (MenuCheckBox i in menuCommands)
         {
             i.Checked = false;
         }
         item.Checked = true;
         IHighlightingStrategy strat = HighlightingStrategyFactory.CreateHighlightingStrategy(item.Text);
         if (strat == null)
         {
             throw new Exception("Strategy can't be null");
         }
         control.Document.HighlightingStrategy = strat;
         if (control is SharpDevelopTextAreaControl)
         {
             ((SharpDevelopTextAreaControl)control).InitializeAdvancedHighlighter();
         }
         control.Refresh();
     }
 }
        protected override void RegisterEvaluationUnits(EvaluationUnitManager mngr)
        {
            EvaluationUnit evaluationUnit = new EvaluationUnit("Get Results", "Get Results", "Gets Results from the RFEM Model.", Properties.Resources.icon_GetResults);

            mngr.RegisterUnit(evaluationUnit);

            // Deformation

            evaluationUnit.RegisterInputParam(new Param_Number(), "Scale Factor", "Scale Factor", "Scale Factor applied to the deformed shape.", GH_ParamAccess.item, new GH_Number(1));
            evaluationUnit.Inputs[0].Parameter.Optional = true;

            evaluationUnit.RegisterOutputParam(new Param_Curve(), "Crv", "Curves", "Deformed shape of the linear elemnents of the RFEM Model.");
            evaluationUnit.RegisterOutputParam(new Param_Integer(), "Member No", "No", "Member Number related to deformed curve.");
            evaluationUnit.RegisterOutputParam(new Param_Mesh(), "Msh", "Meshes", "Deformed shape of the surface elemnents of the RFEM Model.");
            evaluationUnit.RegisterOutputParam(new Param_Integer(), "Surface No", "No", "Surface Number related to deformed mesh.");

            GH_ExtendableMenu gH_ExtendableMenu0 = new GH_ExtendableMenu(0, "Deformation");

            gH_ExtendableMenu0.Name = "Deformation";
            gH_ExtendableMenu0.Expand();
            evaluationUnit.AddMenu(gH_ExtendableMenu0);
            gH_ExtendableMenu0.RegisterInputPlug(evaluationUnit.Inputs[0]);
            for (int i = 0; i < 4; i++)
            {
                gH_ExtendableMenu0.RegisterOutputPlug(evaluationUnit.Outputs[i]);
            }

            // Load Cases and Combos
            GH_ExtendableMenu gH_ExtendableMenu1 = new GH_ExtendableMenu(1, "Load Cases and Combos");

            gH_ExtendableMenu1.Name = "Load Cases and Combos";
            gH_ExtendableMenu1.Expand();
            evaluationUnit.AddMenu(gH_ExtendableMenu1);
            MenuPanel menuPanel = new MenuPanel(1, "panel_load");

            menuPanel.Header = "Set here the load case for display.\n";
            MenuStaticText menuStaticText0 = new MenuStaticText();

            menuStaticText0.Text   = "Select Load Case or Combo";
            menuStaticText0.Header = "Load Case";
            menuPanel.AddControl(menuStaticText0);
            _loadDrop = new MenuDropDown(1, "dropdown_loads_1", "loading type");
            _loadDrop.ValueChanged += _loadDrop__valueChanged;
            _loadDrop.Header        = "Set here the loading type for display.\n";
            menuPanel.AddControl(_loadDrop);
            MenuStaticText menuStaticText1 = new MenuStaticText();

            menuStaticText1.Text   = "Select Result Type";
            menuStaticText1.Header = "Result Type";
            menuPanel.AddControl(menuStaticText1);
            _resulttypeDrop = new MenuDropDown(2, "dropdown_result_1", "result type");
            _resulttypeDrop.ValueChanged += _loadDrop__valueChanged2;
            _resulttypeDrop.Header        = "Set here the loading type for display.\n";
            menuPanel.AddControl(_resulttypeDrop);
            gH_ExtendableMenu1.AddControl(menuPanel);

            // Overwrite
            GH_ExtendableMenu gH_ExtendableMenu2 = new GH_ExtendableMenu(2, "Overwrite");

            gH_ExtendableMenu2.Name = "Overwrite";
            evaluationUnit.RegisterInputParam(new Param_String(), "Overwrite Load Case or Combo", "Load Case", "Overwrite selected load case or combo from the dropdown menu.", GH_ParamAccess.item);
            evaluationUnit.Inputs[1].Parameter.Optional = true;
            gH_ExtendableMenu2.RegisterInputPlug(evaluationUnit.Inputs[1]);
            evaluationUnit.RegisterInputParam(new Param_Integer(), "Overwrite Result type", "Result Type", UtilLibrary.DescriptionRFTypes(typeof(ResultsValueType)), GH_ParamAccess.item);
            evaluationUnit.Inputs[2].Parameter.Optional = true;
            evaluationUnit.Inputs[2].EnumInput          = UtilLibrary.ListRFTypes(typeof(ResultsValueType));
            gH_ExtendableMenu2.RegisterInputPlug(evaluationUnit.Inputs[2]);
            evaluationUnit.AddMenu(gH_ExtendableMenu2);

            // Select results
            GH_ExtendableMenu gH_ExtendableMenu3 = new GH_ExtendableMenu(3, "Select Results");

            gH_ExtendableMenu3.Name = "Select Results";
            gH_ExtendableMenu3.Expand();
            evaluationUnit.AddMenu(gH_ExtendableMenu3);
            MenuPanel menuPanel2 = new MenuPanel(2, "panel_results");

            menuPanel2.Header = "Select output results.\n";

            _tagGrp               = new MenuRadioButtonGroup(0, "radiogrp_tags");
            _tagGrp.Direction     = MenuRadioButtonGroup.LayoutDirection.Vertical;
            _tagGrp.ValueChanged += _tagGrp__valueChanged;
            _tagGrp.MaxActive     = 1;
            _tagGrp.MinActive     = 1;
            buttonLocal           = new MenuRadioButton(0, "radio_local", "Local", MenuRadioButton.Alignment.Horizontal)
            {
                Name   = "Local",
                Active = true
            };
            buttonGlobal = new MenuRadioButton(1, "radio_global", "Global", MenuRadioButton.Alignment.Horizontal)
            {
                Name   = "Global",
                Active = false
            };
            _tagGrp.AddButton(buttonLocal);
            _tagGrp.AddButton(buttonGlobal);
            menuPanel2.AddControl(_tagGrp);

            _deformationsCheck = new MenuCheckBox(0, "deformations", "Deformation");
            _deformationsCheck.ValueChanged += _deformationsCheck__valueChanged;
            _deformationsCheck.Active        = true;
            _deformationsCheck.Header        = "Display deformed shape.";
            _memberForcesCheck = new MenuCheckBox(1, "check member forces", "Member Forces");
            _memberForcesCheck.ValueChanged   += _memberForcesCheck__valueChanged;
            _memberForcesCheck.Active          = true;
            _memberForcesCheck.Header          = "Add member forces to output results.";
            _surfaceForcesCheck                = new MenuCheckBox(2, "check surface forces", "Surface Forces");
            _surfaceForcesCheck.ValueChanged  += _surfaceForcesCheck__valueChanged;
            _surfaceForcesCheck.Active         = true;
            _surfaceForcesCheck.Header         = "Add surface forces to output results.";
            _nodalReactionsCheck               = new MenuCheckBox(3, "check nodal reactions", "Nodal Reactions");
            _nodalReactionsCheck.ValueChanged += _nodalReactionsCheck__valueChanged;
            _nodalReactionsCheck.Active        = true;
            _nodalReactionsCheck.Header        = "Add nodal reactions to output results.";
            _lineReactionsCheck                = new MenuCheckBox(4, "check line reactions", "Line Reactions");
            _lineReactionsCheck.ValueChanged  += _lineReactionsCheck__valueChanged;
            _lineReactionsCheck.Active         = true;
            _lineReactionsCheck.Header         = "Add line reactions to output results.";
            menuPanel2.AddControl(_deformationsCheck);
            menuPanel2.AddControl(_memberForcesCheck);
            menuPanel2.AddControl(_surfaceForcesCheck);
            menuPanel2.AddControl(_nodalReactionsCheck);
            menuPanel2.AddControl(_lineReactionsCheck);



            gH_ExtendableMenu3.AddControl(menuPanel2);

            // Advanced
            evaluationUnit.RegisterInputParam(new Param_RFEM(), "Trigger", "Trigger", "Input to trigger the optimization", GH_ParamAccess.tree);
            evaluationUnit.Inputs[3].Parameter.Optional = true;
            evaluationUnit.RegisterInputParam(new Param_String(), "Model Name", "Model Name", "Segment of the name of the RFEM Model to get information from", GH_ParamAccess.item);
            evaluationUnit.Inputs[4].Parameter.Optional = true;
            GH_ExtendableMenu gH_ExtendableMenu4 = new GH_ExtendableMenu(4, "Advanced");

            gH_ExtendableMenu4.Name = "Advanced";
            gH_ExtendableMenu4.Collapse();
            evaluationUnit.AddMenu(gH_ExtendableMenu4);
            for (int i = 3; i < 3 + 2; i++)
            {
                gH_ExtendableMenu4.RegisterInputPlug(evaluationUnit.Inputs[i]);
            }
        }
Beispiel #19
0
 //Sets up the event for when evade is active on this spell
 private void SetupStatus(Menu evadeStatusMenu)
 {
     _activeCheckBox = evadeStatusMenu.Get <MenuCheckBox>("isActive_" + _abilityString);
     _activeCheckBox.OnValueChange += ActiveCheckBox_OnValueChange;
 }