Timer timer = new Timer(1000 * 1); //Every second #endregion Fields #region Constructors // Constructor public CmdJail(CommandGroup g, GroupEnum group, string name) : base(g, group, name) { blnConsoleSupported = false; timer.Elapsed += new ElapsedEventHandler(timer_Elapsed); timer.Enabled = true; }
private void AddCommandList(Document doc, CommandGroup group) { ParagraphStyle style = new ParagraphStyle { Indent = 3, Tabs = new[] { 22 } }; // TODO - add option to show ALL commands/groups const bool showHidden = false; var commands = GetExpandedCommandNodes(group, showHidden) .Select(x => new { x.Node, x.Depth, Verb = VerbPath(x.Node, x.Depth - 1) }); foreach (var entry in commands.OrderBy(x => x.Verb)) { if (entry.Node.Hidden) { continue; } var para = doc.AddParagraph(new Paragraph(style)); // TODO - highlight the command by setting span style? para.AddSpan(new Span(entry.Verb)); para.AddTab(); if (!string.IsNullOrEmpty(entry.Node.Summary)) { para.AddSpan(new Span(entry.Node.Summary)); } } }
// Constructor public Command(CommandGroup g, GroupEnum group, string name) { cmdGroup = g; accessGroup = group; strName = name; blnConsoleSupported = false; }
Lane GetLane(CommandGroup commandGroup) { Lane lane = Lane.Middle; foreach (var flag in commandGroup.flags) { if (flag == Flag.Top) lane = Lane.Top; else if (flag == Flag.Bottom) lane = Lane.Bottom; } return lane; }
public void Process(CommandGroup commandGroup, Side side) { this.side = side; this.commandGroup = commandGroup; if (commandGroup.command == Command.Attack && commandGroup.argument == Argument.Virus) { SendVirus(); } else if (commandGroup.command == Command.Defense && commandGroup.argument == Argument.Firewall) { CreateFirewall(); } }
void Behave() { int randAction = UnityEngine.Random.Range(0, 2); int randLane = UnityEngine.Random.Range(0, 3); Command command = randAction == 0 ? Command.Attack : Command.Defense; Argument argument = randAction == 0 ? Argument.Virus : Argument.Firewall; Flag[] flags = new Flag[1]; flags[0] = (Flag)randLane; var commandGroup = new CommandGroup(command, argument, flags, 0); processor.Process(commandGroup, Side.Right); }
public void LoadCommands(params Assembly[] assemblies) { _commands = assemblies .SelectMany(a => a.GetExportedTypes() .Where(t => !t.IsAbstract && t.Namespace.StartsWith("NuCmd.Commands") && typeof(ICommand).IsAssignableFrom(t)) .Select(CommandDefinition.FromType)) .ToList(); _groups = new ReadOnlyDictionary<string, CommandGroup>( _commands .GroupBy(c => c.Group ?? String.Empty) .Where(c => !String.IsNullOrEmpty(c.Key)) .Select(cs => CommandGroup.Create(cs)) .ToDictionary(g => g.Name)); _rootCommands = new CommandGroup( String.Empty, String.Empty, _commands .Where(c => String.IsNullOrEmpty(c.Group))); }
public void Evaluate(string userInput) { List<string> sections = new List<string>(); sections.AddRange(userInput.Split(' ')); Command? command = null; Argument? argument = null; List<Flag> flags = new List<Flag>(); int amountFlag = 0; foreach (var cmd in commandSymbols) { if (cmd.symbol == sections[0]) command = cmd.command; } foreach (var arg in argumentSymbols) { bool didGetArg = false; for (int i = 1; i < sections.Count; i++) { if (arg.symbol == sections[i]) { argument = arg.argument; didGetArg = true; break; } } if (didGetArg) break; } foreach (var fl in flagSymbols) { for (int i = 0; i < sections.Count; i++) { if (fl.symbol == sections[i]) { flags.Add(fl.flag); } } } foreach (var section in sections) { if (int.TryParse(section, out amountFlag)) break; } if (command != null && argument != null) { var commandGroup = new CommandGroup(command.Value, argument.Value, flags.ToArray(), amountFlag); if (CommandInvoked != null) CommandInvoked(commandGroup, Side.Left); } }
public void CannotConstructWithNonEnumCommandType() { Action a = () => { var x = new CommandGroup <NonEnumValueType>(null); }; a.Should().Throw <NotSupportedException>(); }
// Constructor public CmdReplace(CommandGroup g, GroupEnum group, string name) : base(g, group, name) { blnConsoleSupported = false; /* By default no console support*/ }
// Constructor public CmdFollow(CommandGroup g, GroupEnum group, string name) : base(g, group, name) { fTimer.Elapsed += new ElapsedEventHandler(fTimer_Elapsed); fTimer.Enabled = true; }
private Document GroupHelp(CommandGroup group) { Document doc = new Document(); var para = doc.AddParagraph(new Paragraph(new ParagraphStyle { LinesAfter = 1 })); para.AddSpan("usage: " + VerbPath(group)); AddNamed(para, group.NamedParameters); // TODO - include --help! if (group.Nodes.Any()) { para.AddSpan("<command>"); } if (group.Nodes.Any(x => x.PositionalParameters.Any())) { para.AddSpan("[<args>]"); } // TODO - add usage // TODO - add overall command description // TODO - include "Help" in the command list! AddCommandList(doc, group); // TODO - add help blurb if (group.Nodes.Any()) { var p = doc.AddParagraph(new Paragraph(new ParagraphStyle { LinesBefore = 1 })); var helpVerb = "help"; // TODO - pull from settings! p.AddSpan("See '{0} {1} <command>' to read about a specific subcommand.", VerbPath(group), helpVerb); } return doc; }
private void ReportMalformedCommand(CommandGroup group) { Dispatch(new UnknownCommandArgs($"possibly a malformed {group.ToString().ToUpper()}")); }
private void CreateCommandTabBox(CommandGroup cmdGroup, Dictionary <CommandSpec, int> commands) { m_Logger.Log($"Creating command tab box"); var tabCommands = new List <TabCommandInfo>(); foreach (var cmdData in commands) { var cmd = cmdData.Key; var cmdId = cmdData.Value; if (cmd.HasTabBox) { var docTypes = new List <swDocumentTypes_e>(); if (cmd.SupportedWorkspace.HasFlag(WorkspaceTypes_e.Part)) { docTypes.Add(swDocumentTypes_e.swDocPART); } if (cmd.SupportedWorkspace.HasFlag(WorkspaceTypes_e.Assembly)) { docTypes.Add(swDocumentTypes_e.swDocASSEMBLY); } if (cmd.SupportedWorkspace.HasFlag(WorkspaceTypes_e.Drawing)) { docTypes.Add(swDocumentTypes_e.swDocDRAWING); } tabCommands.AddRange(docTypes.Select( t => new TabCommandInfo( t, cmdId, ConvertTextDisplay(cmd.TabBoxStyle)))); } } foreach (var cmdGrp in tabCommands.GroupBy(c => c.DocType)) { var docType = cmdGrp.Key; var cmdTab = CmdMgr.GetCommandTab((int)docType, cmdGroup.Name); if (cmdTab == null) { cmdTab = CmdMgr.AddCommandTab((int)docType, cmdGroup.Name); } if (cmdTab != null) { var cmdIds = cmdGrp.Select(c => c.CmdId).ToArray(); var txtTypes = cmdGrp.Select(c => (int)c.TextType).ToArray(); var cmdBox = TryFindCommandTabBox(cmdTab, cmdIds); if (cmdBox == null) { cmdBox = cmdTab.AddCommandTabBox(); } else { if (!IsCommandTabBoxChanged(cmdBox, cmdIds, txtTypes)) { continue; } else { ClearCommandTabBox(cmdBox); } } if (!cmdBox.AddCommands(cmdIds, txtTypes)) { throw new InvalidOperationException("Failed to add commands to commands tab box"); } } else { throw new NullReferenceException("Failed to create command tab box"); } } }
public void CanConstructWithNonEnumCommandType() { Action a = () => { var group = new CommandGroup <CommandType>(null); }; a.Should().NotThrow <Exception>(); }
public void TestThreeCommandOnSubSystem() { ASubsystem subsystem = new ASubsystem(); MockCommand command1 = new MockCommand(); command1.AddRequires(subsystem); MockCommand command2 = new MockCommand(); command2.AddRequires(subsystem); MockCommand command3 = new MockCommand(); command3.AddRequires(subsystem); CommandGroup commandGroup = new CommandGroup(); commandGroup.AddSequential(command1, 1.0); commandGroup.AddSequential(command2, 2.0); commandGroup.AddSequential(command3); AssertCommandState(command1, 0, 0, 0, 0, 0); AssertCommandState(command2, 0, 0, 0, 0, 0); AssertCommandState(command3, 0, 0, 0, 0, 0); commandGroup.Start(); AssertCommandState(command1, 0, 0, 0, 0, 0); AssertCommandState(command2, 0, 0, 0, 0, 0); AssertCommandState(command3, 0, 0, 0, 0, 0); Scheduler.Instance.Run(); AssertCommandState(command1, 0, 0, 0, 0, 0); AssertCommandState(command2, 0, 0, 0, 0, 0); AssertCommandState(command3, 0, 0, 0, 0, 0); Scheduler.Instance.Run(); AssertCommandState(command1, 1, 1, 1, 0, 0); AssertCommandState(command2, 0, 0, 0, 0, 0); AssertCommandState(command3, 0, 0, 0, 0, 0); Sleep(1000);// Command 1 timeout Scheduler.Instance.Run(); AssertCommandState(command1, 1, 1, 1, 0, 1); AssertCommandState(command2, 1, 1, 1, 0, 0); AssertCommandState(command3, 0, 0, 0, 0, 0); Scheduler.Instance.Run(); AssertCommandState(command1, 1, 1, 1, 0, 1); AssertCommandState(command2, 1, 2, 2, 0, 0); AssertCommandState(command3, 0, 0, 0, 0, 0); Sleep(2000);// Command 2 timeout Scheduler.Instance.Run(); AssertCommandState(command1, 1, 1, 1, 0, 1); AssertCommandState(command2, 1, 2, 2, 0, 1); AssertCommandState(command3, 1, 1, 1, 0, 0); Scheduler.Instance.Run(); AssertCommandState(command1, 1, 1, 1, 0, 1); AssertCommandState(command2, 1, 2, 2, 0, 1); AssertCommandState(command3, 1, 2, 2, 0, 0); command3.SetHasFinished(true); AssertCommandState(command1, 1, 1, 1, 0, 1); AssertCommandState(command2, 1, 2, 2, 0, 1); AssertCommandState(command3, 1, 2, 2, 0, 0); Scheduler.Instance.Run(); AssertCommandState(command1, 1, 1, 1, 0, 1); AssertCommandState(command2, 1, 2, 2, 0, 1); AssertCommandState(command3, 1, 3, 3, 1, 0); Scheduler.Instance.Run(); AssertCommandState(command1, 1, 1, 1, 0, 1); AssertCommandState(command2, 1, 2, 2, 0, 1); AssertCommandState(command3, 1, 3, 3, 1, 0); }
// Constructor public CmdLoad(CommandGroup g, GroupEnum group, string name) : base(g, group, name) { blnConsoleSupported = true; /* By default no console support*/ }
/// <summary> /// Loading Enesy Command Method (ECM) information in this assembly /// </summary> /// <param name="markedOnly">Default value: false</param> internal void LoadingECM(bool markedOnly) { // Write message to command window Autodesk.AutoCAD.EditorInput.Editor ed = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager. MdiActiveDocument.Editor; ed.WriteMessage("\nLoading ECM Database ..."); // Just get the commands for this assembly Assembly asm = Assembly.GetExecutingAssembly(); // for command category object[] categorys = asm.GetCustomAttributes(typeof(CommandGroup), true); Type[] catTypes; int catNumtypes = categorys.Length; // Get EnesyCommandMethod attributes object[] objs = asm.GetCustomAttributes(typeof(EnesyCADCommandMethod), true); Type[] tps; int numTypes = objs.Length; if (numTypes > 0) { tps = new Type[numTypes]; for (int i = 0; i < numTypes; i++) { CommandClassAttribute cca = objs[i] as CommandClassAttribute; if (cca != null) { tps[i] = cca.Type; } } } else { // If we're only looking for specifically marked CommandClasses, then use an // empty list if (markedOnly) { tps = new Type[0]; } else { tps = asm.GetExportedTypes(); } } // Append valid value into Database foreach (Type tp in tps) { MethodInfo[] meths = tp.GetMethods(); foreach (MethodInfo meth in meths) { objs = meth.GetCustomAttributes(typeof(EnesyCADCommandMethod), true); foreach (object obj in objs) { EnesyCADCommandMethod attb = (EnesyCADCommandMethod)obj; if (!attb.IsTest) { // get command category object[] cats = meth.GetCustomAttributes(typeof(CommandGroup), true); string category = ""; int index = 0; foreach (object c in cats) { index++; CommandGroup commandCat = c as CommandGroup; //GLOBAL.WriteMessage("Command " + attb.GlobalName + " - Category: " + commandCat.Category); category = commandCat.Category; } //GLOBAL.WriteMessage("\nCategory " + index + ""); // CmdRecord cmd = new CmdRecord(attb.GlobalName, attb.Tag, attb.Description, attb.Author, attb.Email, attb.WebLink, category ); // Check if Database contains this cmd if (!this.CmdTableRecord.Contains(attb.GlobalName)) { this.CmdTableRecord.Add(attb.GlobalName, attb.Tag, !String.IsNullOrEmpty(attb.Tag) ? "[" + attb.Tag + "] " + GetCommandDescription(attb.Description) : GetCommandDescription(attb.Description), attb.Author, attb.Email, attb.WebLink, category ); //if (!String.IsNullOrEmpty(cat.Category)) //{ // GLOBAL.WriteMessage("Category: " + cat.Category); //} } } } } } // }
public static ToolStripContainer AddToolStrip(this ToolStripContainer container, CommandGroup group, params Command[] commands) { var ts = commands.Aggregate(new ToolStrip { Name = "tsp" + group.ToString() }, (b, c) => b.AddToolStripItem(c)); container.TopToolStripPanel.Controls.Add(ts); return(container); }
internal void TransformMe(TransformConfig config, Matrix4D transform, CommandGroup undoGroup) { this.TransformMe(config, Transformation3D.From(transform), undoGroup); }
public CommandAttribute(string description, CommandGroup group) { _group = group; _description = description; }
void OnCommandInvoked(CommandGroup commandGroup, Side side) { processor.Process(commandGroup, side); }
IEnumerator TransformSelected(TransformType type) { isTransforming = true; totalScaleAmount = 0; totalRotationAmount = Quaternion.identity; Vector3 originalPivot = pivotPoint; Vector3 planeNormal = (transform.position - originalPivot).normalized; Vector3 axis = GetNearAxisDirection(); Vector3 projectedAxis = Vector3.ProjectOnPlane(axis, planeNormal).normalized; Vector3 previousMousePosition = Vector3.zero; List <ICommand> transformCommands = new List <ICommand>(); for (int i = 0; i < targetRootsOrdered.Count; i++) { transformCommands.Add(new TransformCommand(this, targetRootsOrdered[i])); } while (!Input.GetMouseButtonUp(0)) { Ray mouseRay = myCamera.ScreenPointToRay(Input.mousePosition); Vector3 mousePosition = Geometry.LinePlaneIntersect(mouseRay.origin, mouseRay.direction, originalPivot, planeNormal); if (previousMousePosition != Vector3.zero && mousePosition != Vector3.zero) { if (type == TransformType.Move) { float moveAmount = ExtVector3.MagnitudeInDirection(mousePosition - previousMousePosition, projectedAxis) * moveSpeedMultiplier; Vector3 movement = axis * moveAmount; for (int i = 0; i < targetRootsOrdered.Count; i++) { Transform target = targetRootsOrdered[i]; target.Translate(movement, Space.World); } SetPivotPointOffset(movement); } else if (type == TransformType.Scale) { Vector3 projected = (nearAxis == Axis.Any) ? transform.right : projectedAxis; float scaleAmount = ExtVector3.MagnitudeInDirection(mousePosition - previousMousePosition, projected) * scaleSpeedMultiplier; //WARNING - There is a bug in unity 5.4 and 5.5 that causes InverseTransformDirection to be affected by scale which will break negative scaling. Not tested, but updating to 5.4.2 should fix it - https://issuetracker.unity3d.com/issues/transformdirection-and-inversetransformdirection-operations-are-affected-by-scale Vector3 localAxis = (space == TransformSpace.Local && nearAxis != Axis.Any) ? mainTargetRoot.InverseTransformDirection(axis) : axis; Vector3 targetScaleAmount = Vector3.one; if (nearAxis == Axis.Any) { targetScaleAmount = (ExtVector3.Abs(mainTargetRoot.localScale.normalized) * scaleAmount); } else { targetScaleAmount = localAxis * scaleAmount; } for (int i = 0; i < targetRootsOrdered.Count; i++) { Transform target = targetRootsOrdered[i]; Vector3 targetScale = target.localScale + targetScaleAmount; if (pivot == TransformPivot.Pivot) { target.localScale = targetScale; } else if (pivot == TransformPivot.Center) { if (scaleType == ScaleType.FromPoint) { target.SetScaleFrom(originalPivot, targetScale); } else if (scaleType == ScaleType.FromPointOffset) { target.SetScaleFromOffset(originalPivot, targetScale); } } } totalScaleAmount += scaleAmount; } else if (type == TransformType.Rotate) { float rotateAmount = 0; Vector3 rotationAxis = axis; if (nearAxis == Axis.Any) { Vector3 rotation = transform.TransformDirection(new Vector3(Input.GetAxis("Mouse Y"), -Input.GetAxis("Mouse X"), 0)); Quaternion.Euler(rotation).ToAngleAxis(out rotateAmount, out rotationAxis); rotateAmount *= allRotateSpeedMultiplier; } else { Vector3 projected = (nearAxis == Axis.Any || ExtVector3.IsParallel(axis, planeNormal)) ? planeNormal : Vector3.Cross(axis, planeNormal); rotateAmount = (ExtVector3.MagnitudeInDirection(mousePosition - previousMousePosition, projected) * rotateSpeedMultiplier) / GetDistanceMultiplier(); } for (int i = 0; i < targetRootsOrdered.Count; i++) { Transform target = targetRootsOrdered[i]; if (pivot == TransformPivot.Pivot) { target.Rotate(rotationAxis, rotateAmount, Space.World); } else if (pivot == TransformPivot.Center) { target.RotateAround(originalPivot, rotationAxis, rotateAmount); } } totalRotationAmount *= Quaternion.Euler(rotationAxis * rotateAmount); } } previousMousePosition = mousePosition; yield return(null); } for (int i = 0; i < transformCommands.Count; i++) { ((TransformCommand)transformCommands[i]).StoreNewTransformValues(); } CommandGroup commandGroup = new CommandGroup(); commandGroup.Set(transformCommands); UndoRedoManager.Insert(commandGroup); totalRotationAmount = Quaternion.identity; totalScaleAmount = 0; isTransforming = false; SetPivotPoint(); }
public static bool AddCommand(string[] args, CommandGroup command) { if (args == null || args.Count() < 2) { return(false); } uint objectId; uint.TryParse(args[0], out objectId); if (objectId == 0) { return(false); } uint spawntimeSecs; uint.TryParse(args[1], out spawntimeSecs); GameObjectTemplate objectInfo = ObjMgr.GetGameObjectTemplate(objectId); if (objectInfo == null) { command.SendErrorMessage(CypherStrings.GameobjectNotExist, objectId); return(false); } //if (objectInfo.displayId != 0 && !DBCStorage.sGameObjectDisplayInfoStore.LookupEntry(objectInfo->displayId)) { // report to DB errors log as in loading case //sLog->outError(LOG_FILTER_SQL, "Gameobject (Entry %u GoType: %u) have invalid displayId (%u), not spawned.", objectId, objectInfo->type, objectInfo->displayId); //handler->PSendSysMessage(LANG_GAMEOBJECT_HAVE_INVALID_DATA, objectId); //return false; } Player player = command.GetSession().GetPlayer(); float x = player.GetPositionX(); float y = player.GetPositionY(); float z = player.GetPositionZ(); float o = player.GetOrientation(); Map map = player.GetMap(); GameObject obj = new GameObject(); uint guidLow = ObjMgr.GenerateLowGuid(HighGuidType.GameObject); if (!obj.Create(guidLow, objectInfo.entry, map, 1 /*player.GetPhaseMgr().GetPhaseMaskForSpawn()*/, x, y, z, o, 0.0f, 0.0f, 0.0f, 0.0f, 0, GameObjectState.Ready)) { return(false); } //if (spawntimeSecs != 0) { //obj.SetRespawnTime(spawntimeSecs); } // fill the gameobject data and save to the db //obj.SaveToDB(map->GetId(), (1 << map->GetSpawnMode()), player->GetPhaseMgr().GetPhaseMaskForSpawn()); // this will generate a new guid if the object is in an instance if (!obj.LoadGameObjectFromDB(guidLow, map)) { return(false); } // TODO: is it really necessary to add both the real and DB table guid here ? ObjMgr.AddGameObjectToGrid(guidLow, ObjMgr.GetGOData(guidLow)); command.SendSysMessage(CypherStrings.GameobjectAdd, objectId, objectInfo.name, guidLow, x, y, z); return(true); }
internal SwCommandGroup(SwApplication app, CommandGroupSpec spec, CommandGroup cmdGroup) { Spec = spec; CommandGroup = cmdGroup; m_App = app; }
// Constructor public CmdKick(CommandGroup g, GroupEnum group, string name) : base(g, group, name) { blnConsoleSupported = true; /* By default no console support*/ }
public async Task GenerateCommandListAsync(CommandContext ctx, [RemainingText, Description("File path.")] string path = null) { if (string.IsNullOrWhiteSpace(path)) { path = "Documentation"; } DirectoryInfo current; DirectoryInfo parts; try { if (Directory.Exists(path)) { Directory.Delete(path, recursive: true); } current = Directory.CreateDirectory(path); parts = Directory.CreateDirectory(Path.Combine(current.FullName, "Parts")); } catch (IOException e) { throw new CommandFailedException("Failed to create the directories!", e); } var sb = new StringBuilder(); sb.AppendLine("# Command list"); sb.AppendLine(); IReadOnlyList <Command> commands = ctx.CommandsNext.GetAllRegisteredCommands(); var modules = commands .GroupBy(c => ModuleAttribute.ForCommand(c)) .OrderBy(g => g.Key.Module) .ToDictionary(g => g.Key, g => g.OrderBy(c => c.QualifiedName).ToList()); foreach ((ModuleAttribute mattr, List <Command> cmdlist) in modules) { sb.Append("# Module: ").Append(mattr.Module.ToString()).AppendLine().AppendLine(); foreach (Command cmd in cmdlist) { if (cmd is CommandGroup || cmd.Parent == null) { sb.Append("## ").Append(cmd is CommandGroup ? "Group: " : "").AppendLine(cmd.QualifiedName); } else { sb.Append("### ").AppendLine(cmd.QualifiedName); } sb.AppendLine("<details><summary markdown='span'>Expand for additional information</summary><p>").AppendLine(); if (cmd.IsHidden) { sb.AppendLine(Formatter.Italic("Hidden.")).AppendLine(); } sb.AppendLine(Formatter.Italic(cmd.Description ?? "No description provided.")).AppendLine(); IEnumerable <CheckBaseAttribute> execChecks = cmd.ExecutionChecks.AsEnumerable(); CommandGroup parent = cmd.Parent; while (parent != null) { execChecks = execChecks.Union(parent.ExecutionChecks); parent = parent.Parent; } IEnumerable <string> perms = execChecks .Where(chk => chk is RequirePermissionsAttribute) .Select(chk => chk as RequirePermissionsAttribute) .Select(chk => chk.Permissions.ToPermissionString()) .Union(execChecks .Where(chk => chk is RequireOwnerOrPermissionsAttribute) .Select(chk => chk as RequireOwnerOrPermissionsAttribute) .Select(chk => chk.Permissions.ToPermissionString()) ); IEnumerable <string> uperms = execChecks .Where(chk => chk is RequireUserPermissionsAttribute) .Select(chk => chk as RequireUserPermissionsAttribute) .Select(chk => chk.Permissions.ToPermissionString()); IEnumerable <string> bperms = execChecks .Where(chk => chk is RequireBotPermissionsAttribute) .Select(chk => chk as RequireBotPermissionsAttribute) .Select(chk => chk.Permissions.ToPermissionString()); if (execChecks.Any(chk => chk is RequireOwnerAttribute)) { sb.AppendLine(Formatter.Bold("Owner-only.")).AppendLine(); } if (execChecks.Any(chk => chk is RequirePrivilegedUserAttribute)) { sb.AppendLine(Formatter.Bold("Privileged users only.")).AppendLine(); } if (perms.Any()) { sb.AppendLine(Formatter.Bold("Requires permissions:")); sb.AppendLine(Formatter.InlineCode(string.Join(", ", perms))).AppendLine(); } if (uperms.Any()) { sb.AppendLine(Formatter.Bold("Requires user permissions:")); sb.AppendLine(Formatter.InlineCode(string.Join(", ", uperms))).AppendLine(); } if (bperms.Any()) { sb.AppendLine(Formatter.Bold("Requires bot permissions:")); sb.AppendLine(Formatter.InlineCode(string.Join(", ", bperms))).AppendLine(); } if (cmd.Aliases.Any()) { sb.AppendLine(Formatter.Bold("Aliases:")); sb.AppendLine(Formatter.InlineCode(string.Join(", ", cmd.Aliases))).AppendLine(); } foreach (CommandOverload overload in cmd.Overloads.OrderByDescending(o => o.Priority)) { if (!overload.Arguments.Any()) { continue; } sb.AppendLine(Formatter.Bold(cmd.Overloads.Count > 1 ? $"Overload {overload.Priority.ToString()}:" : "Arguments:")).AppendLine(); foreach (CommandArgument arg in overload.Arguments) { if (arg.IsOptional) { sb.Append("(optional) "); } string type = $"[{ctx.CommandsNext.GetUserFriendlyTypeName(arg.Type)}"; if (arg.IsCatchAll) { type += "..."; } type += "]"; sb.Append(Formatter.InlineCode(type)); sb.Append(" : "); sb.Append(string.IsNullOrWhiteSpace(arg.Description) ? "No description provided." : Formatter.Italic(arg.Description)); if (arg.IsOptional) { sb.Append(" (def: ").Append(Formatter.InlineCode(arg.DefaultValue != null ? arg.DefaultValue.ToString() : "None")).Append(")"); } sb.AppendLine().AppendLine(); } } if (cmd.CustomAttributes.FirstOrDefault(chk => chk is UsageExamplesAttribute) is UsageExamplesAttribute examples) { sb.AppendLine(Formatter.Bold("Examples:")).AppendLine().AppendLine(Formatter.BlockCode(examples.JoinExamples())); } sb.AppendLine("</p></details>").AppendLine().AppendLine("---").AppendLine(); } string filename = Path.Combine(parts.FullName, $"{mattr.Module.ToString()}.md"); try { File.WriteAllText(filename, sb.ToString()); } catch (IOException e) { throw new CommandFailedException($"IO Exception occured while saving {filename}!", e); } sb.Clear(); } sb.AppendLine("# Command modules:"); foreach ((ModuleAttribute mattr, List <Command> cmdlist) in modules) { string mname = mattr.Module.ToString(); sb.Append("* ").Append('[').Append(mname).Append(']').Append("(").Append(parts.Name).Append('/').Append(mname).Append(".md").AppendLine(")"); } try { File.WriteAllText(Path.Combine(current.FullName, $"README.md"), sb.ToString()); } catch (IOException e) { throw new CommandFailedException($"IO Exception occured while saving the main file!", e); } await this.InformAsync(ctx, $"Command list created at: {Formatter.InlineCode(current.FullName)}!", important : false); }
/// <summary> /// Attaches a CanExecute handler to the given command. /// </summary> /// <param name="commandGroup">The command group to which <paramref name="command"/> belongs.</param> /// <param name="command">The command to which an can execute handler needs to be attached.</param> static partial void AttachCanExecuteHandler(CommandGroup commandGroup, RelayCommand command);
public static bool Activate(string[] args, CommandGroup command) { return(false); }
private IEnumerable<CommandChildEntry> GetExpandedCommandNodes(CommandGroup group, bool showHidden) { // Can't use recursion here, as that prevents yielding the results, so use a stack... Stack<CommandChildEntry> stack = new Stack<CommandChildEntry>(new[] { new CommandChildEntry(group, 0) }); while (stack.Count > 0) { var entry = stack.Pop(); var command = entry.Node as Command; if ((command != null) && (showHidden || !command.Hidden)) { yield return entry; } var childGroup = entry.Node as CommandGroup; if (childGroup != null) { if ((entry.Depth == 0) || (CountChildCommands(childGroup, showHidden) <= _settings.ChildThreshold)) { foreach (var child in childGroup.Nodes) { if (showHidden || !child.Hidden) { stack.Push(new CommandChildEntry(child, entry.Depth + 1)); } } } else { yield return entry; } } } }
private void CreateMenu(CommandGroup [] groups) { _menuStrip = new MenuStrip (); _pluginMenu = new ToolStripMenuItem ("Plugins"); foreach (CommandGroup cg in groups) { var topItem = new ToolStripMenuItem (cg.Name); topItem.DropDownItems.AddRange (cg.Items.Select (x => new ToolStripMenuItem (x.Name, null, x.Event)).ToArray()); _menuStrip.Items.Add (topItem); } _menuStrip.Items.Add (_pluginMenu); CollectPlugins (); MainMenuStrip = _menuStrip; }
internal void TransformMe(TransformConfig config, Matrix3D transform, CommandGroup undoGroup) { // ISSUE: object of a compiler-generated type is created // ISSUE: variable of a compiler-generated type DxfPattern.Line.Class465 class465 = new DxfPattern.Line.Class465(); // ISSUE: reference to a compiler-generated field class465.line_0 = this; TransformConfig.HatchPatternTransform hatchPatternHandling = config.HatchPatternHandling; if (hatchPatternHandling == TransformConfig.HatchPatternTransform.DontTransform) { return; } // ISSUE: reference to a compiler-generated field class465.double_0 = this.double_0; // ISSUE: reference to a compiler-generated field class465.point2D_0 = this.point2D_0; // ISSUE: reference to a compiler-generated field class465.vector2D_0 = this.vector2D_0; // ISSUE: reference to a compiler-generated field class465.list_0 = new List <double>((IEnumerable <double>) this.list_0); Vector2D vector = new Vector2D(System.Math.Cos(this.double_0), System.Math.Sin(this.double_0)); if (hatchPatternHandling == TransformConfig.HatchPatternTransform.CompleteTransform) { Vector2D vector2D = transform.Transform(vector); // ISSUE: reference to a compiler-generated field class465.double_1 = System.Math.Atan2(vector2D.Y, vector2D.X); double length = vector2D.GetLength(); // ISSUE: reference to a compiler-generated field class465.point2D_1 = transform.Transform(this.point2D_0); // ISSUE: reference to a compiler-generated field class465.vector2D_1 = transform.Transform(this.vector2D_0); // ISSUE: reference to a compiler-generated field class465.list_1 = new List <double>(this.list_0.Count); foreach (double num in this.list_0) { // ISSUE: reference to a compiler-generated field class465.list_1.Add(length * num); } } else { // ISSUE: reference to a compiler-generated field class465.double_1 = this.double_0; // ISSUE: reference to a compiler-generated field class465.point2D_1 = this.point2D_0 + (Vector2D)transform.Transform(WW.Math.Point2D.Zero); // ISSUE: reference to a compiler-generated field class465.vector2D_1 = this.vector2D_0; // ISSUE: reference to a compiler-generated field // ISSUE: reference to a compiler-generated field class465.list_1 = class465.list_0; } // ISSUE: reference to a compiler-generated method // ISSUE: reference to a compiler-generated method undoGroup?.UndoStack.Push((ICommand) new Command((object)this, new System.Action(class465.method_0), new System.Action(class465.method_1))); // ISSUE: reference to a compiler-generated field this.double_0 = class465.double_1; // ISSUE: reference to a compiler-generated field this.point2D_0 = class465.point2D_1; // ISSUE: reference to a compiler-generated field this.vector2D_0 = class465.vector2D_1; this.list_0.Clear(); // ISSUE: reference to a compiler-generated field this.list_0.AddRange((IEnumerable <double>)class465.list_1); }
// Constructor public CmdNewLvl(CommandGroup g, GroupEnum group, string name) : base(g, group, name) { blnConsoleSupported = false; /* By default no console support*/ }
public override void TransformMe( TransformConfig config, Matrix4D matrix, CommandGroup undoGroup) { // ISSUE: object of a compiler-generated type is created // ISSUE: variable of a compiler-generated type DxfInsertBase.Class476 class476 = new DxfInsertBase.Class476(); // ISSUE: reference to a compiler-generated field class476.dxfInsertBase_0 = this; // ISSUE: reference to a compiler-generated field class476.vector3D_0 = this.vector3D_0; // ISSUE: reference to a compiler-generated field class476.point3D_0 = this.insertionPoint; // ISSUE: reference to a compiler-generated field class476.double_0 = this.rotation; // ISSUE: reference to a compiler-generated field class476.vector3D_1 = this.scaleFactor; this.vector3D_0 = matrix.Transform(this.ZAxis).GetUnit(); Matrix4D inverse = DxfUtil.GetToWCSTransform(this.ZAxis).GetInverse(); // ISSUE: reference to a compiler-generated field Matrix4D toWcsTransform = DxfUtil.GetToWCSTransform(class476.vector3D_0); // ISSUE: reference to a compiler-generated field this.insertionPoint = inverse.Transform(matrix.Transform(toWcsTransform.Transform(class476.point3D_0))); // ISSUE: reference to a compiler-generated field Vector3D vector3D = inverse.Transform(matrix.Transform(toWcsTransform.Transform(Transformation4D.RotateZ(class476.double_0).Transform(Vector3D.XAxis)))); this.rotation = System.Math.Atan2(vector3D.Y, vector3D.X); if (this.Rotation < 0.0) { this.Rotation += 2.0 * System.Math.PI; } // ISSUE: reference to a compiler-generated field // ISSUE: reference to a compiler-generated field this.scaleFactor = Transformation4D.RotateZ(-this.Rotation).Transform(inverse.Transform(matrix.Transform(toWcsTransform.Transform(Transformation4D.RotateZ(class476.double_0).Transform(class476.vector3D_1))))); CommandGroup undoGroup1 = (CommandGroup)null; if (undoGroup != null) { // ISSUE: object of a compiler-generated type is created // ISSUE: variable of a compiler-generated type DxfInsertBase.Class477 class477 = new DxfInsertBase.Class477(); // ISSUE: reference to a compiler-generated field class477.class476_0 = class476; undoGroup1 = new CommandGroup((object)this); undoGroup.UndoStack.Push((ICommand)undoGroup1); // ISSUE: reference to a compiler-generated field class477.vector3D_0 = this.vector3D_0; // ISSUE: reference to a compiler-generated field class477.point3D_0 = this.insertionPoint; // ISSUE: reference to a compiler-generated field class477.double_0 = this.rotation; // ISSUE: reference to a compiler-generated field class477.vector3D_1 = this.scaleFactor; // ISSUE: reference to a compiler-generated method // ISSUE: reference to a compiler-generated method undoGroup1.UndoStack.Push((ICommand) new Command((object)this, new System.Action(class477.method_0), new System.Action(class476.method_0))); } foreach (DxfEntity dxfEntity in (DxfHandledObjectCollection <DxfAttribute>) this.activeDxfHandledObjectCollection_0) { dxfEntity.TransformMe(config, matrix, undoGroup1); } }
public static bool Phase(string[] args, CommandGroup command) { return(false); }
/// <summary> /// Adds the specified command handler associated with the command type. /// </summary> /// <param name="commandType">The command type.</param> /// <param name="commandGroup">The command group.</param> /// <param name="handler">The command handler.</param> public void AddCommandHandler(CommandType commandType, CommandGroup commandGroup, ExecuteCommandDelegate handler) { var commandHandle = new CommandHandle(commandType, commandGroup, handler); _commandHandles.Add(commandHandle); }
protected CommandGroup[] CreateCommandGroups() { var fileOps = new CommandGroup ("File"); fileOps.Items.AddRange (new Command [] { new Command ("Open", (obj, e) => Open()), new Command ("Save", (obj, e) => Save()), }); var actions = new CommandGroup ("Actions"); actions.Items.AddRange (new Command [] { new Command ("Add", (obj, e) => _state = new Adding (_doc, this)), new Command ("Delete", (obj, e) => _state = new Deleting (_doc, this)), new Command ("Connect", (obj, e) => _state = new Connecting (_doc, this)), new Command ("Disconnect", (obj, e) => _state = new Disconnecting (_doc, this)), new Command ("Select", (obj, e) => _state = new Idle (_doc, this)), }); return new CommandGroup [] {fileOps, actions}; }
/// <summary> /// Removes all command handlers for the specified command group. /// </summary> /// <param name="commandGroup">The command group.</param> public void RemoveCommandHandlers(CommandGroup commandGroup) { _commandHandles.RemoveAll(p => p.CommandGroup == commandGroup); }
private void CreateToolbarButtons(CommandGroup [] groups) { foreach (CommandGroup cg in groups) { _toolStrip.Items.AddRange (cg.Items.Select (x => CreateButton (x)).ToArray ()); _toolStrip.Items.Add (new ToolStripSeparator ()); } }
private void CreateCommandItems(CommandGroup cmdGroup, int groupId, Enum[] cmds, Delegate callbackMethod, Delegate enableMethod) { var callbackMethodName = nameof(OnCommandClick); var enableMethodName = nameof(OnCommandEnable); for (int i = 0; i < cmds.Length; i++) { var cmd = cmds[i]; var cmdTitle = ""; var cmdToolTip = ""; swCommandItemType_e menuToolbarOpts = 0; swWorkspaceTypes_e suppWorkSpaces = 0; if (!cmd.TryGetAttribute <DisplayNameAttribute>( att => cmdTitle = att.DisplayName)) { cmdTitle = cmd.ToString(); } if (!cmd.TryGetAttribute <DescriptionAttribute>( att => cmdToolTip = att.Description)) { cmdToolTip = cmd.ToString(); } if (!cmd.TryGetAttribute <CommandItemInfoAttribute>( att => { if (att.HasMenu) { menuToolbarOpts |= swCommandItemType_e.swMenuItem; } if (att.HasToolbar) { menuToolbarOpts |= swCommandItemType_e.swToolbarItem; } suppWorkSpaces = att.SupportedWorkspaces; })) { menuToolbarOpts = swCommandItemType_e.swMenuItem | swCommandItemType_e.swToolbarItem; suppWorkSpaces = swWorkspaceTypes_e.All; } if (menuToolbarOpts == 0) { throw new InvalidMenuToolbarOptionsException(cmd); } var cmdId = Convert.ToInt32(cmd); var cmdName = $"{groupId}.{cmdId}"; m_CachedCmdsEnable.Add(cmdName, suppWorkSpaces); m_CallbacksParams.Add(cmdName, new Tuple <Delegate, Enum>(callbackMethod, cmd)); if (enableMethod != null) { m_EnableParams.Add(cmdName, new Tuple <Delegate, Enum>(enableMethod, cmd)); } var callbackFunc = $"{callbackMethodName}({cmdName})"; var enableFunc = $"{enableMethodName}({cmdName})"; cmdGroup.AddCommandItem2(cmdTitle, -1, cmdToolTip, cmdTitle, i, callbackFunc, enableFunc, cmdId, (int)menuToolbarOpts); } }
public void SetupCommands() { BitmapHandler imageManager = new BitmapHandler(); Assembly thisAssembly; int cmdIndex0, cmdIndex1, cmdIndex2, cmdIndex3, cmdIndex4, cmdIndex5; string Title = "Gazebo", ToolTip = "Tools for exporting this assembly as a robot for simulation in Gazebo"; int cmdGroupErr = 0; bool ignorePrevious = false; object registryIDs; //get the ID information stored in the registry bool getDataResult = iCmdMgr.GetGroupDataFromRegistry(cmdGroupID, out registryIDs); int[] knownIDs = new int[3] {settingsItemID, manageRobotItemID, exportItemID}; if (getDataResult) { if (!CompareIDs((int[])registryIDs, knownIDs)) //if the IDs don't match, reset the commandGroup { ignorePrevious = true; } } ignorePrevious = true; //Get a reference to the current assembly and load bitmaps form it into a new command group thisAssembly = System.Reflection.Assembly.GetAssembly(this.GetType()); cmdGroup = iCmdMgr.CreateCommandGroup2(cmdGroupID, Title, ToolTip, "", -1, ignorePrevious, ref cmdGroupErr); cmdGroup.LargeIconList = imageManager.CreateFileFromResourceBitmap("GazeboExporter.Images.ToolbarLarge.bmp", thisAssembly); cmdGroup.SmallIconList = imageManager.CreateFileFromResourceBitmap("GazeboExporter.Images.ToolbarSmall.bmp", thisAssembly); cmdGroup.LargeMainIcon = imageManager.CreateFileFromResourceBitmap("GazeboExporter.Images.MainIconLarge.bmp", thisAssembly); cmdGroup.SmallMainIcon = imageManager.CreateFileFromResourceBitmap("GazeboExporter.Images.MainIconSmall.bmp", thisAssembly); GazeboLogo = Image.FromFile(imageManager.CreateFileFromResourceBitmap("GazeboExporter.Images.Gazebo.png", thisAssembly)); MotorPic = Image.FromFile(imageManager.CreateFileFromResourceBitmap("GazeboExporter.Images.motor.png", thisAssembly)); EncoderPic = Image.FromFile(imageManager.CreateFileFromResourceBitmap("GazeboExporter.Images.QuadratureEncoder.png", thisAssembly)); PotPic = Image.FromFile(imageManager.CreateFileFromResourceBitmap("GazeboExporter.Images.AnalogPotentiometer.png", thisAssembly)); GyroPic = Image.FromFile(imageManager.CreateFileFromResourceBitmap("GazeboExporter.Images.Gyro.png", thisAssembly)); RangefinderPic = Image.FromFile(imageManager.CreateFileFromResourceBitmap("GazeboExporter.Images.Ultrasonic.png", thisAssembly)); CameraPic = Image.FromFile(imageManager.CreateFileFromResourceBitmap("GazeboExporter.Images.Camera.png", thisAssembly)); ExtLimitSwitchPic = Image.FromFile(imageManager.CreateFileFromResourceBitmap("GazeboExporter.Images.LimitSwitch_E.png", thisAssembly)); IntLimitSwitchPic = Image.FromFile(imageManager.CreateFileFromResourceBitmap("GazeboExporter.Images.LimitSwitch_I.png", thisAssembly)); PistonPic = Image.FromFile(imageManager.CreateFileFromResourceBitmap("GazeboExporter.Images.Piston.png", thisAssembly)); NewLinkPic = Image.FromFile(imageManager.CreateFileFromResourceBitmap("GazeboExporter.Images.NewLinkIcon.png", thisAssembly)); NewJointPic = Image.FromFile(imageManager.CreateFileFromResourceBitmap("GazeboExporter.Images.NewJointIcon.png", thisAssembly)); int menuToolbarOption = (int)(swCommandItemType_e.swMenuItem | swCommandItemType_e.swToolbarItem); cmdIndex3 = cmdGroup.AddCommandItem2("Exporter Settings", -1, "Change exporter plugin settings", "Exporter settings", 0, "settingsCB", "settingsEN", settingsItemID, menuToolbarOption); cmdIndex4 = cmdGroup.AddCommandItem2("Manage Robot", -1, "Manage robot paramters", "Manage Robot", 1, "manageRobotCB", "manageRobotEN", manageRobotItemID, menuToolbarOption); cmdIndex5 = cmdGroup.AddCommandItem2("Export", -1, "Save this robot as a Gazebo package", "Export", 2, "exportCB", "exportEN", exportItemID, menuToolbarOption); cmdGroup.HasToolbar = true; cmdGroup.HasMenu = true; cmdGroup.Activate(); cmdTab = iCmdMgr.GetCommandTab((int)swDocumentTypes_e.swDocASSEMBLY, Title); if (cmdTab != null & !getDataResult | ignorePrevious)//if tab exists, but we have ignored the registry info (or changed command group ID), re-create the tab. Otherwise the ids won't matchup and the tab will be blank { bool res = iCmdMgr.RemoveCommandTab(cmdTab); cmdTab = null; } //if cmdTab is null, must be first load (possibly after reset), add the commands to the tabs if (cmdTab == null) { cmdTab = iCmdMgr.AddCommandTab((int)swDocumentTypes_e.swDocASSEMBLY, Title); cmdBox = cmdTab.AddCommandTabBox(); int[] cmdIDs = new int[3]; int[] TextType = new int[3]; cmdIDs[0] = cmdGroup.get_CommandID(cmdIndex3); cmdIDs[1] = cmdGroup.get_CommandID(cmdIndex4); cmdIDs[2] = cmdGroup.get_CommandID(cmdIndex5); TextType[0] = (int)swCommandTabButtonTextDisplay_e.swCommandTabButton_TextBelow; TextType[1] = (int)swCommandTabButtonTextDisplay_e.swCommandTabButton_TextBelow; TextType[2] = (int)swCommandTabButtonTextDisplay_e.swCommandTabButton_TextBelow; /*int[] cmdIDs = new int[2]; int[] TextType = new int[2]; cmdIDs[0] = cmdGroup.get_CommandID(cmdIndex4); cmdIDs[1] = cmdGroup.get_CommandID(cmdIndex5); TextType[0] = (int)swCommandTabButtonTextDisplay_e.swCommandTabButton_TextBelow; TextType[1] = (int)swCommandTabButtonTextDisplay_e.swCommandTabButton_TextBelow;*/ cmdBox.AddCommands(cmdIDs, TextType); } thisAssembly = null; imageManager.Dispose(); }
public CommandLineParser(CommandGroup root, IReadOnlyCollection <Parameter> globalParameters) { _root = root; _globalParameters = globalParameters; }
// Constructor public CmdPermissionBuild(CommandGroup g, GroupEnum group, string name) : base(g, group, name) { blnConsoleSupported = false; /* By default no console support*/ }
private void ParseSbCommand(string line) { int depth = 0; while (line.StartsWith(" ") || line.StartsWith("_")) { ++depth; line = line.Substring(1); } if (depth < 2) { commandGroup = (lastDrawable as IHasCommands).Commands; } string[] tokens = line.Split(','); string type = tokens[0]; switch (type) { case "T": { string triggerName = tokens[1]; int startTime = Convert.ToInt32(tokens[2]); int endTime = Convert.ToInt32(tokens[3]); int groupNumber = tokens.Length > 4 ? Convert.ToInt32(tokens[4]) : 0; commandGroup = commandGroup.AddTrigger(triggerName, startTime, endTime, groupNumber).Commands; } break; case "L": { int startTime = Convert.ToInt32(tokens[1]); int loopCount = Convert.ToInt32(tokens[2]); commandGroup = commandGroup.AddLoop(startTime, loopCount).Commands; } break; default: { if (string.IsNullOrEmpty(tokens[3])) { tokens[3] = tokens[2]; } Easing easing = (Easing)Convert.ToInt32(tokens[1]); int startTime = Convert.ToInt32(tokens[2]); int endTime = Convert.ToInt32(tokens[3]); switch (type) { case "F": { float startValue = ParseHelper.ToFloat(tokens[4]); float endValue = tokens.Length > 5 ? ParseHelper.ToFloat(tokens[5]) : startValue; commandGroup.Commands.Add(new Command(CommandType.Fade, easing, startTime, endTime, startValue, endValue)); } break; case "M": { float startX = ParseHelper.ToFloat(tokens[4]); float startY = ParseHelper.ToFloat(tokens[5]); float endX = tokens.Length > 6 ? ParseHelper.ToFloat(tokens[6]) : startX; float endY = tokens.Length > 7 ? ParseHelper.ToFloat(tokens[7]) : startY; commandGroup.Commands.Add(new Command(CommandType.Movement, easing, startTime, endTime, new Tuple <float, float>(startX, startY), new Tuple <float, float>(endX, endY))); } break; case "MX": { float startValue = ParseHelper.ToFloat(tokens[4]); float endValue = tokens.Length > 5 ? ParseHelper.ToFloat(tokens[5]) : startValue; commandGroup.Commands.Add(new Command(CommandType.MovementX, easing, startTime, endTime, startValue, endValue)); } break; case "MY": { float startValue = ParseHelper.ToFloat(tokens[4]); float endValue = tokens.Length > 5 ? ParseHelper.ToFloat(tokens[5]) : startValue; commandGroup.Commands.Add(new Command(CommandType.MovementY, easing, startTime, endTime, startValue, endValue)); } break; case "S": { float startValue = ParseHelper.ToFloat(tokens[4]); float endValue = tokens.Length > 5 ? ParseHelper.ToFloat(tokens[5]) : startValue; commandGroup.Commands.Add(new Command(CommandType.Scale, easing, startTime, endTime, startValue, endValue)); } break; case "V": { float startX = ParseHelper.ToFloat(tokens[4]); float startY = ParseHelper.ToFloat(tokens[5]); float endX = tokens.Length > 6 ? ParseHelper.ToFloat(tokens[6]) : startX; float endY = tokens.Length > 7 ? ParseHelper.ToFloat(tokens[7]) : startY; commandGroup.Commands.Add(new Command(CommandType.VectorScale, easing, startTime, endTime, new Tuple <float, float>(startX, startY), new Tuple <float, float>(endX, endY))); } break; case "R": { float startValue = ParseHelper.ToFloat(tokens[4]); float endValue = tokens.Length > 5 ? ParseHelper.ToFloat(tokens[5]) : startValue; commandGroup.Commands.Add(new Command(CommandType.Rotation, easing, startTime, endTime, startValue, endValue)); } break; case "C": { float startRed = ParseHelper.ToFloat(tokens[4]); float startGreen = ParseHelper.ToFloat(tokens[5]); float startBlue = ParseHelper.ToFloat(tokens[6]); float endRed = tokens.Length > 7 ? ParseHelper.ToFloat(tokens[7]) : startRed; float endGreen = tokens.Length > 8 ? ParseHelper.ToFloat(tokens[8]) : startGreen; float endBlue = tokens.Length > 9 ? ParseHelper.ToFloat(tokens[9]) : startBlue; commandGroup.Commands.Add(new Command(easing, startTime, endTime, Color.FromArgb(255, (int)startRed, (int)startGreen, (int)startBlue), Color.FromArgb(255, (int)endRed, (int)endGreen, (int)endBlue))); } break; case "P": { string parameter = tokens[4]; switch (parameter) { case "H": commandGroup.Commands.Add(new Command(CommandType.FlipHorizontal, easing, startTime, endTime)); break; case "V": commandGroup.Commands.Add(new Command(CommandType.FlipVertical, easing, startTime, endTime)); break; case "A": commandGroup.Commands.Add(new Command(CommandType.BlendingMode, easing, startTime, endTime)); break; } } break; } } break; } }