public static CommandList GetCommands(Assembly assembly) { // Any static classes containing commands for use from the // console are located in the Commands namespace. Load // references to each type in that namespace via reflection: var commands = new CommandList(); // Use reflection to load all of the classes in the Commands namespace: var current = Assembly.GetExecutingAssembly(); var q = from t in current.GetTypes() where t.IsClass && typeof(IConsoleCommand).IsAssignableFrom(t) select t; var defaultCommands = GetCommands(q, current); foreach (var command in defaultCommands.Where(command => !command.Key.Namespace.Contains("get_Info"))) { commands.Add(command.Key, command.Value); } var user = from t in assembly.GetTypes() where t.IsClass && typeof(IConsoleCommand).IsAssignableFrom(t) select t; var userCommands = GetCommands(user, assembly); foreach (var command in userCommands) { commands.Add(command.Key, command.Value); } return commands; }
protected virtual void InitMenu() { if (Menu == null) { Menu = new CommandList(); Menu.Add(new CutCommand(this)); Menu.Add(new CopyCommand(this)); Menu.Add(new PasteCommand(this)); } }
private static CommandList GetCommands(IEnumerable<Type> commandClasses, Assembly assembly) { var commands = new CommandList(); foreach (var commandClass in commandClasses) { var instance = (IConsoleCommand)Activator.CreateInstance(commandClass); // Load the method info from each class into a dictionary: var methods = commandClass.GetMethods(BindingFlags.Public | BindingFlags.Instance); var methodDictionary = new Dictionary<string, ConsoleExecutingMethod>(); foreach (var method in methods) { var commandName = method.Name; if (commandName.Contains("get_Info")) continue; if (method.ReturnParameter != null && method.DeclaringType != null && method.ReturnParameter.ParameterType.FullName.Contains("ConsoleShared.ConsoleExecuteResult")) { methodDictionary.Add(commandName, new ConsoleExecutingMethod(method.DeclaringType.Namespace, assembly, method.GetParameters(), IsAsyncMethod(method))); } } // Add the dictionary of methods for the current class into a dictionary of command classes: commands.Add(new ConsoleExecutingAssembly(commandClass.Name, instance), methodDictionary); } return commands; }
/// <inheritdoc /> partial void AddPlatformCommands() { LtoFlashGroupCommand.MenuParent = RootCommandGroup.ToolsMenuCommand; LtoFlashGroupCommand.Weight = 0.8; CommandList.Add(LtoFlashGroupCommand); CommandList.Add(LtoFlashGroupCommand.CreateSeparator(CommandLocation.Before)); CommandList.Remove(FtdiDriverVersionCommand); }
/// <summary> /// Adds the platform-specific commands. /// </summary> partial void AddPlatformCommands() { FirmwareGroupCommand.MenuParent = LtoFlashCommandGroup.LtoFlashGroupCommand; RestoreFirmwareCommand.Weight = 0.1; CommandList.Add(CheckForFirmwareUpdateCommand.CreateSeparator(CommandLocation.Before)); CommandList.Add(FirmwareGroupCommand); CommandList.Add(FirmwareGroupCommand.CreateSeparator(CommandLocation.After)); }
public void AddCommand(byte command) { command = (byte)Convert.ToInt32(command + "", 16); if (command < 0)//Make custom exception { throw new Exception("Command must be a positive number"); } CommandList.Add(command); }
public void ExecuteConfirm() { IsEnabledField = false; IsEnabledCC = false; IsInDeleteMode = false; try { switch (_selectedCommand) { case CommandType.AddMaterial: DetailedContent.Time = DateTime.Now; CommandMaterial cmd = DetailedContent.Command as CommandMaterial; if (cmd.Material != null) { _warehouse.DBService.FindMaterialID(cmd.Material.Value, true); } _warehouse.DBService.AddCommand(cmd); CommandList.Add(DetailedContent); break; case CommandType.AddSegment: DetailedContent.Time = DateTime.Now; _warehouse.DBService.AddCommand(DetailedContent.Command as CommandSegment); CommandList.Add(DetailedContent); break; case CommandType.Restart: DetailedContent.Time = DateTime.Now; DetailedContent.Status = EnumCommandStatus.Waiting; _warehouse.DBService.UpdateCommand(DetailedContent.Command); break; case CommandType.Delete: _warehouse.DBService.UpdateCommand(DetailedContent.Command); _warehouse.DBService.AddCommand(new CommandCommand { Task = Command.EnumCommandTask.CancelCommand, CommandID = DetailedContent.ID, Priority = 0, Status = Command.EnumCommandStatus.NotActive, // Reason = DetailedContent.Command.Reason, Time = DateTime.Now }); break; default: break; } DetailedContent.ValidationEnabled = false; DetailedContent = SelectedContent; } catch (Exception e) { _warehouse.AddEvent(Database.Event.EnumSeverity.Error, Database.Event.EnumType.Exception, string.Format("{0}.{1}: {2}", this.GetType().Name, (new StackTrace()).GetFrame(0).GetMethod().Name, e.Message)); } }
/// +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+= /// <summary> /// Adds a line. /// </summary> public int AddLine(string lineToAdd) { if (lineToAdd == null) { return(100); } CommandList.Add(lineToAdd); return(0); }
public void UpdateList([NotNull] List <ObservableCommand> cmdList) { // set the current commandlist to be displayed in the listview CommandList.Clear(); foreach (var x in cmdList) { CommandList.Add(x); } }
/// <summary> /// Add GTK-specific commands. /// </summary> partial void AddPlatformCommands() { CommandList.Add(FileMenuCommand); CommandList.Add(EditMenuCommand); CommandList.Add(ViewMenuCommand); CommandList.Add(ToolsMenuCommand); CommandList.Add(WindowMenuCommand); CommandList.Add(HelpMenuCommand); }
private void InitializeCommand(RoutedUICommand command, Func <bool> isVisibleHandler, Func <bool> isEnabledHandler, Func <bool> isCheckedHandler, Action commandHandler) { CommandList.Add(command); MenuHeaderTable.Add(command, command.Text); MenuIsVisibleTable.Add(command, isVisibleHandler); MenuIsEnabledTable.Add(command, isEnabledHandler); MenuIsCheckedTable.Add(command, isCheckedHandler); MenuHandlerTable.Add(command, commandHandler); }
/// <inheritdoc /> protected override void AddCommands() { UpdateDriverVersionCommandStrings(INTV.LtoFlash.Utility.FTDIUtilities.DriverVersionString); CommandList.Add(FtdiGroupCommand); CommandList.Add(FtdiDriverVersionCommand); CommandList.Add(GoToFTDIDriverPageCommand); ////CommandList.Add(LaunchFtdiDriverInstallerCommand); // Not worth it. Lots of problems on Mac (signing) and probably old. AddPlatformCommands(); }
public void SNIPE_InitCommands() { // GA CommandList.Add(new Command("ga", 0, Command.Behaviour.Normal, (sender, arguments, optarg) => { if (Call <string>("getdvar", "g_gametype") == "infect" && sender.GetTeam() == "axis") { WriteChatToPlayer(sender, "I like the way you're thinking, but nope."); return; } CMD_GiveMaxAmmo(sender); WriteChatToPlayer(sender, Command.GetString("ga", "message")); })); // HIDEBOMBICON CommandList.Add(new Command("hidebombicon", 0, Command.Behaviour.Normal, (sender, arguments, optarg) => { CMD_HideBombIconAndSmoke(sender); WriteChatToPlayer(sender, Command.GetString("hidebombicon", "message")); })); // KNIFE CommandList.Add(new Command("knife", 1, Command.Behaviour.Normal, (sender, arguments, optarg) => { bool enabled = UTILS_ParseBool(arguments[0]); CMD_knife(enabled); if (enabled) { WriteChatToAll(Command.GetString("knife", "message_on")); } else { WriteChatToAll(Command.GetString("knife", "message_off")); } })); // LETMEHARDSCOPE CommandList.Add(new Command("letmehardscope", 1, Command.Behaviour.Normal, (sender, arguments, optarg) => { bool state = UTILS_ParseBool(arguments[0]); if (state) { sender.SetField("letmehardscope", 1); WriteChatToPlayer(sender, Command.GetString("letmehardscope", "message_on")); } else { sender.SetField("letmehardscope", 0); WriteChatToPlayer(sender, Command.GetString("letmehardscope", "message_off")); } })); }
/// <inheritdoc /> protected override void AddCommands() { CommandList.Add(RootCommand); CommandList.Add(RootMenuCommand); CommandList.Add(ApplicationMenuCommand); #if DEBUG CommandList.Add(DebugCommandGroup.DebugMenuCommand); #endif // DEBUG AddPlatformCommands(); }
public IEnumerable <GameCommandBase> GetActionCommands() { CommandList.Clear(); foreach (var obj in GameObjects) { CommandList.AddRange(obj.GetActionCommands()); } CommandList.Add(new QuitGameCommand(this)); return(CommandList); }
public void can_match_commands_with_certain_text_from_a_CommandList() { var list = new CommandList(); list.Add(new Command(Method("Foo")) { Name = "foo" }); list.Add(new Command(Method("Foo")) { Name = "foot" }); list.Match("f").Select(cmd => cmd.Name).ToArray().ShouldEqual(new string[] { "foo", "foot" }); list.Match("fo").Select(cmd => cmd.Name).ToArray().ShouldEqual(new string[] { "foo", "foot" }); list.Match("foo").Select(cmd => cmd.Name).ToArray().ShouldEqual(new string[] { "foo" }); // EXACT MATCH, so we don't return foot // TODO change this ... if using Match, user can check if any of the results are a command via list.IsCommand("") ... or we need to add something like that. this result is currently unintuitive. list.Match("foot").Select(cmd => cmd.Name).ToArray().ShouldEqual(new string[] { "foot" }); list.Match("foott").Select(cmd => cmd.Name).ToArray().ShouldEqual(new string[] { }); }
public MainWindow() { InitializeComponent(); usbCon = new USBConnection("COM3"); camCon = new NikonController("Type0014.md3"); camCon.SaveToPc = true; cl = new CommandList(); cl.Add(new Command(Command.Cmdtype.PHOTO)); }
public void AddCommand(BaseCommand bc) { if (CurrentCommand < CommandList.Count - 1) { RemoveUndos(); } CommandList.Add(bc); CurrentCommand++; TrimCommandList(); }
public Sbc(byte[] sbc) { using (var er = new EndianBinaryReaderEx(new MemoryStream(sbc), Endianness.LittleEndian)) { while (er.BaseStream.Position < er.BaseStream.Length) { CommandList.Add(SbcCommand.Read(er)); } } }
/// <summary> /// 绑定命令类型 /// </summary> /// <param name="id"></param> /// <param name="commandType"></param> /// <param name="handleResult"></param> public void BindCommandModel(int id, AdvertManage.Model.Enum.CommandType commandType, AdvertManage.Model.Enum.CommandHandleResult handleResult) { CommandList.Clear(); List <AdvertManage.Model.AMS_CommandListModel> cmdList = AdvertManage.BLL.AMS_CommandBLL.GetCommandListByCondition(id, commandType, handleResult); foreach (AdvertManage.Model.AMS_CommandListModel model in cmdList) { CommandList.Add(model); } }
private void InitializeCommand(string header, Func <bool> isVisibleHandler, Func <bool> isEnabledHandler, Func <bool> isCheckedHandler, Action commandHandler) { ICommand Command = new RoutedUICommand(); CommandList.Add(Command); MenuHeaderTable.Add(Command, header); MenuIsVisibleTable.Add(Command, isVisibleHandler); MenuIsEnabledTable.Add(Command, isEnabledHandler); MenuIsCheckedTable.Add(Command, isCheckedHandler); MenuHandlerTable.Add(Command, commandHandler); }
/// <summary> /// Convert abstract command list that just references them by this commander's list of planes into a command list with specific Aircraft /// </summary> /// <param name="commander"></param> /// <param name="commands"></param> /// <returns></returns> CommandList CommandListAbstractToConcrete(CommandListAbstract commands, Commander commander) { CommandList concreteCommands = new CommandList(); for (int i = 0; i < commands.Count; i++) { Maneuver maneuver = Maneuver.BasicManeuvers[(short)commands[i]]; concreteCommands.Add(commander.unitsCommanded[i], maneuver); } return(concreteCommands); }
/// <inheritdoc/> protected override void AddCommands() { CommandList.Add(DownloadAndPlayCommand); CommandList.Add(DownloadAndPlayPromptCommand); CommandList.Add(SyncHostToDeviceCommand); CommandList.Add(SyncDeviceToHostCommand); CommandList.Add(SyncHostToDevicePreviewCommand); CommandList.Add(SyncDeviceToHostPreviewCommand); CommandList.Add(SyncClearChangesPreviewCommand); AddPlatformCommands(); }
/// <summary> /// Adds the platform-specific commands. /// </summary> partial void AddPlatformCommands() { OpenSettingsDialogCommand.MenuParent = JzIntvLauncherCommandGroup.JzIntvToolsMenuCommand; OpenSettingsDialogCommand.Weight = 0.5; ShowGettingStartedCommand.MenuParent = JzIntvLauncherCommandGroup.JzIntvToolsMenuCommand; ShowGettingStartedCommand.Weight = 0.51; ShowInstalledDocumentsCommand.MenuParent = JzIntvLauncherCommandGroup.JzIntvToolsMenuCommand; ShowInstalledDocumentsCommand.Weight = 0.52; CommandList.Add(ShowGettingStartedCommand); CommandList.Add(ShowInstalledDocumentsCommand); }
private void InitializeCommand(string header, Func <bool> isVisibleHandler, Func <bool> isEnabledHandler, Func <bool> isCheckedHandler, Action commandHandler) { string LocalizedText = Properties.Resources.ResourceManager.GetString(header, CultureInfo.CurrentCulture) !; ICommand Command = new RoutedUICommand(LocalizedText, header, GetType()); CommandList.Add(Command); MenuHeaderTable.Add(Command, LocalizedText); MenuIsVisibleTable.Add(Command, isVisibleHandler); MenuIsEnabledTable.Add(Command, isEnabledHandler); MenuIsCheckedTable.Add(Command, isCheckedHandler); MenuHandlerTable.Add(Command, commandHandler); }
public static void Run(List <_Command> cmdlist) { Debug.Log($"{PlaceholderParser.ParseTimeStamp()} [INFO] Registering commands.."); CommandList.Clear(); foreach (var command in cmdlist) { if (DebugLevel >= 1) { Debug.Log($"{PlaceholderParser.ParseTimeStamp()} [INFO] Registering command: {command.CommandName}.."); } Action <SvPlayer, string> rMethod = null; try { rMethod = (Action <SvPlayer, string>) Delegate.CreateDelegate(typeof(Action <SvPlayer, string>), Type.GetType($"BP_Essentials.Commands.{command.CommandName}") .GetMethod(nameof(Run))); } catch (ArgumentException) { rMethod = null; } if (command.CommandName == "ToggleReceiveStaffChat") { CmdStaffChatExecutableBy = command.ExecutableBy; } if (command.CommandName == "Confirm") { CmdConfirm = command.Commands[0]; } if (command.CommandName == "ToggleChat") { CmdToggleChat = command.Commands[0]; } if (command.CommandName == "TpaAccept") { CmdTpaaccept = command.Commands[0]; } CommandList.Add(CommandList.Count + 1, new _CommandList { RunMethod = rMethod, commandGroup = command.ExecutableBy ?? "everyone", commandName = command.CommandName, commandCmds = command.Commands.Select(x => $"{CmdCommandCharacter}{x}").ToList(), commandDisabled = command.Disabled ?? false, commandWantedAllowed = command.AllowWithCrimes ?? true, commandHandcuffedAllowed = command.AllowWhileCuffed ?? true, commandWhileJailedAllowed = command.AllowWhileJailed ?? true }); } Debug.Log($"{PlaceholderParser.ParseTimeStamp()} [INFO] Registered commands! ({CommandList.Count} commands loaded in.)"); }
public void AddCommand(String command) { if (System.Text.RegularExpressions.Regex.IsMatch(command, @"\A\b[0-9a-fA-F]+\b\Z")) { int hexNum = Convert.ToInt32(command, 16); CommandList.Add((byte)hexNum); } else { //Make custom exception throw new Exception("Not a valid Hex string"); } }
public ComponentPage(ComponentViewModel vm) { InitializeComponent(); BindingContext = vm; CType ctype = vm.CType.AsCType(); if (ctype.IsAny(CType.Element)) { if (ctype.IsAny(CType.Digital)) { DigitalFunctions.IsVisible = true; } if (ctype.IsAny(CType.Analog)) { AnalogFunctions.IsVisible = true; } } if (!DigitalFunctions.IsVisible) { PageStack.Children.Remove(DigitalFunctions); } if (!AnalogFunctions.IsVisible) { PageStack.Children.Remove(AnalogFunctions); } bool noCommands = true; foreach (var command in vm.Commands) { CommandList.Add(CreateLabel(command)); noCommands = false; } if (noCommands) { ArgumentList.UserControllable = false; StackLayout stack = btnSendCommand.Parent as StackLayout; if (stack != null) { stack.Children.Remove(btnSendCommand); } } else { vm.ViewGenerator = CreateEntry; } }
/// <summary> /// WPF-specific command setup. /// </summary> partial void AddPlatformCommands() { ShowJzIntvCommandLineCommand.UseXamlResource = true; ShowJzIntvCommandLineCommand.Weight = 0.5; ShowJzIntvCommandLineCommand.VisualParent = ConfigurationCommandGroup.ConfigurationRibbonGroupCommand; CommandList.Add(JzIntvRibbonTabCommand); CommandList.Add(LaunchRibbonGroupCommand); CommandList.Add(LaunchInJzIntvRibbonSplitButtonCommand); CommandList.Add(LaunchInJzIntvRibbonButtonCommand.CreateRibbonMenuSeparator(CommandLocation.Before, false)); CommandList.Add(LaunchInJzIntvRibbonButtonCommand); CommandList.Add(BrowseAndLaunchInJzIntvRibbonButtonCommand); CommandList.Add(ShowJzIntvCommandLineCommand); }
private void PhotoTestButton_Click(object sender, RoutedEventArgs e) { var clTest = new CommandList(); clTest.Add(new Command(Command.Cmdtype.TIME, 400)); if (VisButton.IsChecked == true) { clTest.Add(new Command(Command.Cmdtype.VISIBLE, 45)); } else if (IrButton.IsChecked == true) { clTest.Add(new Command(Command.Cmdtype.INFRARED, 45)); } else { clTest.Add(new Command(Command.Cmdtype.ULTRAVIOLET, 45)); } clTest.Add(new Command(Command.Cmdtype.PHOTO)); if (sendThread == null || !sendThread.IsAlive) { sendThread = new Thread(() => clTest.Send(usbCon, camCon)); sendThread.Start(); } }
private void AddButton_Click(object sender, RoutedEventArgs e) { if (time != (int.Parse(LedTimeBox.Text))) { cl.Add(new Command(Command.Cmdtype.TIME, int.Parse(LedTimeBox.Text) / 10)); time = int.Parse(LedTimeBox.Text); } if (IrButton.IsChecked == true) { cl.Add(new Command(Command.Cmdtype.INFRARED, (int)LedNumberBox.SelectedItem)); } if (VisButton.IsChecked == true) { cl.Add(new Command(Command.Cmdtype.VISIBLE, (int)LedNumberBox.SelectedItem)); } if (UvButton.IsChecked == true) { cl.Add(new Command(Command.Cmdtype.ULTRAVIOLET, (int)LedNumberBox.SelectedItem)); } CmdBox.ItemsSource = cl.ToStringList(); CmdBox.Items.Refresh(); LedNumberBox.SelectedIndex = 0; }
private void AddRange(CommandList list, IReadOnlyList <Command> commands) { if (commands == null) { return; } foreach (var command in commands) { if (command != null) { list.Add(command); } } }
/// <inheritdoc /> protected override void AddCommands() { CommandList.Add(RomListGroupCommand); CommandList.Add(AddRomFilesCommand); CommandList.Add(AddRomFoldersCommand); CommandList.Add(RemoveRomsCommand); CommandList.Add(ValidateRomsCommand); CommandList.Add(RefreshRomsCommand); CommandList.Add(CancelRomsImportCommand); CommandList.Add(ShowRomInfoCommand); CommandList.Add(EditProgramNameCommand); CommandList.Add(BackupRomListCommand); CommandList.Add(RestoreRomListCommand); CommandList.Add(EmptyRomListCommand); AddPlatformCommands(); }
/// <summary> /// Joins every user-defined function to the end of the command list. /// After calling this function you should NOT change the command list. /// </summary> public void JoinCommands() { if (!isJoined) { originalCommandList = CommandList; CommandList = new CommandList(); CommandList.AddRange(originalCommandList); if (CommandList.Count > 0 && !(CommandList.Last() is Return)) { CommandList.Add(new Return(false)); } //EntryPoints.Clear(); foreach (var udf in Functions) { //EntryPoints.Add(udf, CommandList.Count); udf.EntryPoint = CommandList.Count; CommandList.AddRange(udf.Commands); } isJoined = true; } }
public static void Add(CommandList menu, Block toDelete) { menu.Add(new DeleteCommand(toDelete)); }
public static CommandList CreateDeleteMenu(Block toDelete) { CommandList result = new CommandList(); result.Add(new DeleteCommand(toDelete)); return result; }
public HrmpProgram Parse(string filepath) { HrmpProgram program = null; using (StreamReader file = new StreamReader(filepath)) { string lastLabel = null; CommandList commandList = new CommandList(); string line; while ((line = file.ReadLine()) != null) { ICommand command = ParseLine(line); if (command == null) { // Not a command, check if it is a label for a jump. if (line.EndsWith(":")) { // If there was a previous label, save the current commandList to that ExecutionNode. if (lastLabel != null && program != null) { ExecutionNode en = new ExecutionNode(lastLabel, commandList); program.AddExecutionNode(en); } // Else, create the main ExecutionNode and create the HrmpProgram. else { ExecutionNode en = new ExecutionNode("main", commandList); program = new HrmpProgram(en); } // Clear the current commandList. commandList.Clear(); // Save the label for the next ExecutionNode. line = line.Remove(line.Count() - 1); lastLabel = line; } continue; } // Else, it is a command. else { commandList.Add(command); } } // End of file, so add the current commandList. // If there was a previous label, save the current commandList to that ExecutionNode. if (lastLabel != null && program != null) { ExecutionNode en = new ExecutionNode(lastLabel, commandList); program.AddExecutionNode(en); } // Else, create the main ExecutionNode and create the HrmpProgram. else { ExecutionNode en = new ExecutionNode("main", commandList); program = new HrmpProgram(en); } file.Close(); } return program; }
private CommandList Wrap(IEnumerable<CommandContainer> cmds) { CommandList wrapper = new CommandList(); foreach (CommandContainer cmd in cmds) { cmd.Processed = DateTime.Now; wrapper.Add(cmd); } return wrapper; }