public CommandNode DisplayCommandAsNode(Command command) { GameObject nodeObject = Instantiate(GetNodePrefab(command), background.transform); CommandNode node = nodeObject.GetComponent <CommandNode>(); nodes.Add(node); node.attachedCommand = command; command.SetConnectedNode(node); RectTransform rect = node.transform as RectTransform; rect.anchoredPosition = command.connectedNodePosition; if (node is PrintNode) { ((PrintNode)node).SetInputField(); } if (node is IfSeeNode) { ((IfSeeNode)node).SetInputField(); } if (node is IfInfrontNode) { ((IfInfrontNode)node).SetInputField(); } return(node); }
private void trackBar_Scroll(object sender, EventArgs e) { Guid channelId = _commands[trackBar.Value].Item1; CommandNode commandNode = _commands[trackBar.Value].Item2; //TODO //VixenSystem.Channels.GetChannel(channelId).AddData(commandNode); }
public bool AddCommand(Command command) { var root = command.Path.First(); if (!_root.ContainsKey(root)) { _root.Add(root, new CommandNode(root)); } var node = _root[root]; for (var i = 1; i < command.Path.Count; i++) { var current = command.Path[i]; if (node.Subcommands.ContainsKey(current)) { node = node.Subcommands[current]; continue; } var newNode = new CommandNode(current); node.AddNode(newNode); node = newNode; } if (!node.IsEmpty) { return(false); } node.Command = command; return(true); }
private void GetAllUsage(CommandNode <TSource> node, TSource source, List <string> result, string prefix, bool restricted) { if (restricted && !node.CanUse(source)) { return; } if (node.Command != null) { result.Add(prefix); } if (node.Redirect != null) { var redirect = node.Redirect == _root ? "..." : "-> " + node.Redirect.UsageText; result.Add(prefix.Length == 0 ? node.UsageText + ArgumentSeparator + redirect : prefix + ArgumentSeparator + redirect); } else if (node.Children.Count > 0) { foreach (var child in node.Children) { GetAllUsage(child, source, result, prefix.Length == 0 ? child.UsageText : prefix + ArgumentSeparator + child.UsageText, restricted); } } }
/// <summary> /// Get a command node from the tree. /// </summary> /// <param name="path">Path to the command node.</param> /// <param name="commandNode"></param> /// <returns>The index of the first argument in the path or -1 if the node doesn't exist.</returns> public int GetNode(List <string> path, out CommandNode commandNode) { commandNode = null; var root = path.FirstOrDefault(); if (root == null) { return(-1); } if (!_root.ContainsKey(root)) { return(-1); } var node = _root[root]; var i = 1; for (; i < path.Count; i++) { var current = path[i]; if (node.Subcommands.ContainsKey(current)) { node = node.Subcommands[current]; } else { break; } } commandNode = node; return(i); }
public void GetLinearNodesTest() { var node = new CommandNode(); var command1 = new Command { Name = "show config" }; var command2 = new Command { Name = "show" }; var command3 = new Command { Name = "show test" }; var command4 = new Command { Name = "linear" }; node.Add(command1); node.Add(command2); node.Add(command3); node.Add(command4); int count = 0; foreach (var n in node.LinearNodes) { count++; } Assert.IsTrue(count == 4); }
/// <summary> /// Loads previously stored projects and existing commands /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Home_Load(object sender, EventArgs e) { this.Text = Constants.FORM_TITLE; if (File.Exists(Constants.PROJECT_LIST)) { // try loading each project foreach (string proj in File.ReadAllLines(Constants.PROJECT_LIST)) { try { Analysis analysis = Analysis.Load(proj); AnalysisNode analysisNode = new AnalysisNode(analysis); analysisNode.Control = new AnalysisOverview(analysisNode); tree.Nodes.Add(analysisNode); // try loading all commands string memoryImage = analysis.MemoryImage; foreach (string file in Directory.GetFiles(Path.GetDirectoryName(memoryImage), Path.GetFileName(memoryImage) + "-*.command")) { Command cmd = Command.Load(file); CommandNode commandNode = new CommandNode(analysisNode, cmd); commandNode.Control = new AnalysisCommand(commandNode); analysisNode.Nodes.Add(commandNode); } analysisNode.ExpandAll(); } catch (Exception ex) { MessageBox.Show("Failed to open project:" + Environment.NewLine + ex.Message, Constants.MEMORY_ANALYZER_TITLE, MessageBoxButtons.OK, MessageBoxIcon.Error); } } } }
/// <summary> /// 注册以字面量打头的指令 /// </summary> /// <param name="head">指令头</param> /// <returns>注册的第一个节点</returns> public CommandNode <TEnv> Register(string head) { CommandNode <TEnv> n = PresetNodes.Literal <TEnv>(head); Root.AddChild(n); return(n); }
/** * Gets all possible executable commands following the given node. * * <p>You may use {@link #getRoot()} as a target to get all usage data for the entire command tree.</p> * * <p>The returned syntax will be in "simple" form: {@code <param>} and {@code literal}. "Optional" nodes will be * listed as multiple entries: the parent node, and the child nodes. * For example, a required literal "foo" followed by an optional param "int" will be two nodes:</p> * <ul> * <li>{@code foo}</li> * <li>{@code foo <int>}</li> * </ul> * * <p>The path to the specified node will <b>not</b> be prepended to the output, as there can theoretically be many * ways to reach a given node. It will only give you paths relative to the specified node, not absolute from root.</p> * * @param node target node to get child usage strings for * @param source a custom "source" object, usually representing the originator of this command * @param restricted if true, commands that the {@code source} cannot access will not be mentioned * @return array of full usage strings under the target node */ public string[] GetAllUsage(CommandNode <TSource> node, TSource source, bool restricted) { var result = new List <string>(); GetAllUsage(node, source, result, "", restricted); return(result.ToArray()); }
internal void UpdateNode(CommandNode node) { Color color = Color.Black; // default switch (node.Command.Status) { case Command.CommandStatus.CREATED: color = Color.LightGray; break; case Command.CommandStatus.QUEUED: Interlocked.Increment(ref jobCounter); color = Color.LightGray; break; case Command.CommandStatus.RUNNING: color = Color.Blue; break; case Command.CommandStatus.ABORTED: Interlocked.Decrement(ref jobCounter); color = Color.Red; break; case Command.CommandStatus.COMPLETED: Interlocked.Decrement(ref jobCounter); color = Color.Green; break; } node.ForeColor = color; lblStatus.Text = jobCounter == 0 ? "Idle" : string.Format("{0} job{1}", jobCounter, jobCounter > 1 ? "s" : ""); }
public void CommandEquality() { string rawLine = "::from ./bsinstalldir.txt"; CommandNode.CommandType commandType = CommandNode.CommandType.From; string commandData = "./bsinstalldir.txt"; CommandNode node1 = new CommandNode(rawLine); CommandNode node2 = new CommandNode(commandType, commandData); Assert.AreEqual(node1.RawLine, node2.RawLine); rawLine = "::startopt"; commandType = CommandNode.CommandType.OptionalBlock; commandData = ""; node1 = new CommandNode(rawLine); node2 = new CommandNode(commandType, commandData); Assert.AreEqual(node1.RawLine, node2.RawLine); //rawLine = "::endopt"; //commandType = CommandNode.CommandType.EndOptionalBlock; //commandData = ""; node1 = new CommandNode(rawLine); node2 = new CommandNode(commandType, commandData); Assert.AreEqual(node1.RawLine, node2.RawLine); }
/** * Finds a valid path to a given node on the command tree. * * <p>There may theoretically be multiple paths to a node on the tree, especially with the use of forking or redirecting. * As such, this method makes no guarantees about which path it finds. It will not look at forks or redirects, * and find the first instance of the target node on the tree.</p> * * <p>The only guarantee made is that for the same command tree and the same version of this library, the result of * this method will <b>always</b> be a valid input for {@link #findNode(Collection)}, which should return the same node * as provided to this method.</p> * * @param target the target node you are finding a path for * @return a path to the resulting node, or an empty list if it was not found */ public List <string> GetPath(CommandNode <TSource> target) { var nodes = new List <List <CommandNode <TSource> > >(); AddPaths(_root, nodes, new List <CommandNode <TSource> >()); foreach (var list in nodes) { if (list[list.Count - 1] == target) { var result = new List <string>(list.Count); foreach (var node in list) { if (node != _root) { result.Add(node.Name); } } return(result); } } return(new List <string>()); }
private CommandNode.CommandFlags GetFlags(CommandNode n) { CommandNode.CommandFlags v; if (n is RootCommandNode) { v = CommandNode.CommandFlags.Type_Root; } else if (n is ArgumentCommandNode) { v = CommandNode.CommandFlags.Type_Argument; } else if (n is LiteralCommandNode) { v = CommandNode.CommandFlags.Type_Literal; } //this wont happen else { throw new Exception(); } if (n.RedirectNode != null) { v |= CommandNode.CommandFlags.HasRedirect; } if (n.CommandNodes.All(x => x.GetType() == typeof(FunctionCommandNode))) { v |= CommandNode.CommandFlags.IsExecutable; } return(v); }
private void WriteNode(CommandNode v, CommandNode[] Other) { var flags = GetFlags(v); Write((byte)flags); Write((VarInt)v.CommandNodes.ToArray().Length); if ((flags & CommandNode.CommandFlags.IsExecutable) != 0) { List <int> Indices = new List <int>(); foreach (var v2 in v.CommandNodes) { Indices.Add(Array.IndexOf(Other, v2)); //lets just assume its there } WriteArray(Indices.ToArray()); } if ((flags & CommandNode.CommandFlags.HasRedirect) != 0) { Write(Array.IndexOf(Other, v.RedirectNode)); } if (v is LiteralCommandNode) { Write((v as LiteralCommandNode).name); } if (v is ArgumentCommandNode) { var x2 = v as ArgumentCommandNode; Write(x2.name); Write(x2.parser.ID); //TODO: properties of parser } /*if ((flags & CommandNode.CommandFlags.HasCustomSuggestions) != 0) * Write(SuggestionType);*///TODO: Suggestion Type }
public OptionNode( Token token, Option option, CommandNode parent) : base(token, parent) { Option = option; }
public override Node visitCommand(JuliarParser.CommandContext ctx) { CommandNode commandNode = new CommandNode(); new IterateOverContext(this, ctx, this, commandNode); return(commandNode); }
public int CalculatePages(Cairo.Context cr) { _cr = cr; // Determine certain extents for all fonts for the current context. foreach (FontInfo font in _appSettings.Fonts) { font.SetExtents(_cr); } // Generate page nodes int pageNumber = 0; PageNode currentPage = CreateNewPage(pageNumber++); foreach (BaseNode line in _rawLineNodes) { if (line is CommandNode) { CommandNode command = (CommandNode)line; switch (command.CommandType) { case CommandType.NewPage: currentPage = CreateNewPage(pageNumber++); break; case CommandType.BeginRegion: currentPage.BeginRegion(command.RegionType); break; case CommandType.EndRegion: currentPage.EndRegion(); break; } } else { if (!currentPage.TryAddLine(cr, line)) { currentPage = CreateNewPage(pageNumber++); currentPage.TryAddLine(cr, line); } } } if (_renderOption == RenderOption.ScreenView) { //_displayHeightExtent = ((Y_DISPLAY_MARGIN + _paperHeight) * _pages.Count) + Y_DISPLAY_MARGIN; _displayHeightExtent = ((Constants.Y_DISPLAY_MARGIN + _paperHeight) * _pages.Count) + Constants.Y_DISPLAY_MARGIN; _displayWidthExtent = (Constants.X_DISPLAY_MARGIN * 2) + _paperWidth; } // Now update the total count for each page to render their header/footer information foreach (PageNode page in _pages) { page.SetTotalPageCount(_pages.Count); } return(_pages.Count); }
public CommandContextBuilder <TSource> WithNode(CommandNode <TSource> node, StringRange range) { Nodes.Add(new ParsedCommandNode <TSource>(node, range)); Range = StringRange.Encompassing(Range, range); _modifier = node.RedirectModifier; _forks = node.IsFork; return(this); }
public DeclareCommands() : base(0x11, new byte[0]) { this.RootNode = new CommandNode() { Type = CommandNodeType.Root, Owner = this, }; }
public void AddFactory(IResourceFactory factory) { factories.Add(factory); // register factory command node var playCommand = new PlayCommand(factory.FactoryFor); CommandNode.AddCommand(factory.SubCommandName, playCommand.Command); }
public CommandContextBuilder(CommandDispatcher <TSource> dispatcher, TSource source, CommandNode <TSource> rootNode, StringRange range, IDictionary <string, IParsedArgument> arguments, List <ParsedCommandNode <TSource> > nodes) { Dispatcher = dispatcher; Source = source; RootNode = rootNode; Range = range; _arguments = new Dictionary <string, IParsedArgument>(arguments); Nodes = new List <ParsedCommandNode <TSource> >(nodes); }
public override void OnRegister(CmdDispatcher <DMEnv> dispatcher) { IDictionary <object, object> hardnessMap = new Dictionary <object, object> { ["普通"] = CheckResult.NormalSuccess, ["困难"] = CheckResult.HardSuccess, ["极难"] = CheckResult.ExtremeSuccess, }; IDictionary <object, object> twiceMap = new Dictionary <object, object> { ["奖励"] = true, ["惩罚"] = false, }; dispatcher.Register("检定").Then( MainAction = PresetNodes.String <DMEnv>("数值名") .Handles(Extensions.ExistSelfValue) .Executes((DMEnv env, Args args, Args dict) => SimpleCheck(env, env.Inv, args.GetStr("数值名"), CheckResult.NormalSuccess)) .Then( PresetNodes.Or <DMEnv>("难度", "普通", "困难", "极难") .Handles(PreProcesses.MapArg <DMEnv>(hardnessMap)) .Executes((DMEnv env, Args args, Args dict) => SimpleCheck(env, env.Inv, args.GetStr("数值名"), args.GetInt("难度"))) .Then( PresetNodes.Or <DMEnv>("奖惩", "奖励", "惩罚") .Handles(PreProcesses.MapArg <DMEnv>(twiceMap)) .Executes((DMEnv env, Args args, Args dict) => TwiceCheck(env, env.Inv, args.GetStr("数值名"), args.GetBool("奖惩"), args.GetInt("难度"))) ) ).Then( PresetNodes.Or <DMEnv>("奖惩", "奖励", "惩罚") .Handles(PreProcesses.MapArg <DMEnv>(twiceMap)) .Executes((DMEnv env, Args args, Args dict) => TwiceCheck(env, env.Inv, args.GetStr("数值名"), args.GetBool("奖惩"), CheckResult.NormalSuccess)) ).Then( PresetNodes.Literal <DMEnv>("对抗").Then( PresetNodes.String <DMEnv>("对手名") .Handles(Extensions.ExistInv) .Executes((DMEnv env, Args args, Args dict) => CheckAgainst(env, env.Inv, args.GetStr("数值名"), args.GetInv("对手名"), args.GetStr("数值名"), false)) .Then( PresetNodes.String <DMEnv>("对抗数值名") .Executes((DMEnv env, Args args, Args dict) => CheckAgainst(env, env.Inv, args.GetStr("数值名"), args.GetInv("对手名"), args.GetStr("对抗数值名"), false)) ) ) ).Then( PresetNodes.Literal <DMEnv>("等级对抗").Then( PresetNodes.String <DMEnv>("对手名") .Handles(Extensions.ExistInv) .Executes((DMEnv env, Args args, Args dict) => CheckAgainst(env, env.Inv, args.GetStr("数值名"), args.GetInv("对手名"), args.GetStr("数值名"), true)) .Then( PresetNodes.String <DMEnv>("对抗数值名") .Executes((DMEnv env, Args args, Args dict) => CheckAgainst(env, env.Inv, args.GetStr("数值名"), args.GetInv("对手名"), args.GetStr("对抗数值名"), true)) ) ) ).Then( PresetNodes.String <DMEnv>("目标") .Executes((DMEnv env, Args args, Args dict) => SimpleCheckTo(env, env.Inv, args.GetStr("数值名"), args.GetStr("目标"))) ) ); dispatcher.SetAlias("ch", "检定"); }
private CommandNode ResolveCommand(Dictionary <string, string> variables, XmlElement element) { var cmd = new CommandNode(); foreach (XmlNode item in element.ChildNodes) { if (item.NodeType == XmlNodeType.Text) { var text = ReplaceVariable(variables, item.Value); cmd.Nodes.Add(new TextNode { Value = text }); } else if (item.NodeType == XmlNodeType.Element && item.Name == "where") { var whereNode = new WhereNode(); foreach (XmlNode iitem in item.ChildNodes) { if (iitem.NodeType == XmlNodeType.Text) { var text = ReplaceVariable(variables, iitem.Value); whereNode.Nodes.Add(new TextNode { Value = text }); } else if (iitem.NodeType == XmlNodeType.Element && iitem.Name == "if") { var test = iitem.Attributes["test"].Value; var value = string.IsNullOrEmpty(iitem.InnerText) ? (iitem.Attributes["value"]?.Value ?? string.Empty) : iitem.InnerText; value = ReplaceVariable(variables, value); whereNode.Nodes.Add(new IfNode { Test = test, Value = value }); } } cmd.Nodes.Add(whereNode); } else if (item.NodeType == XmlNodeType.Element && item.Name == "if") { var test = item.Attributes["test"].Value; var value = string.IsNullOrEmpty(item.InnerText) ? (item.Attributes["value"]?.Value ?? string.Empty) : item.InnerText; value = ReplaceVariable(variables, value); cmd.Nodes.Add(new IfNode { Test = test, Value = value }); } } return(cmd); }
public CommandContextBuilder(CommandDispatcher <TSource> dispatcher, TSource source, CommandNode <TSource> rootNode, int start) { RootNode = rootNode; Dispatcher = dispatcher; Source = source; Range = StringRange.At(start); _arguments = new Dictionary <string, IParsedArgument>(); Nodes = new List <ParsedCommandNode <TSource> >(); }
private CommandNode ResolveCommand(XmlElement element) { var cmd = new CommandNode(); foreach (XmlNode item in element.ChildNodes) { if (item.Name == "var" || item.NodeType == XmlNodeType.Comment) { continue; } if (item.NodeType == XmlNodeType.Text) { cmd.Nodes.Add(new TextNode { Value = item.Value }); } else if (item.NodeType == XmlNodeType.Element && item.Name == "where") { var whereNode = new WhereNode(); foreach (XmlNode iitem in item.ChildNodes) { if (iitem.NodeType == XmlNodeType.Text) { whereNode.Nodes.Add(new TextNode { Value = iitem.Value }); } else if (iitem.NodeType == XmlNodeType.Element && iitem.Name == "if") { var test = iitem.Attributes["test"].Value; var value = string.IsNullOrEmpty(iitem.InnerText) ? (iitem.Attributes["value"]?.Value ?? string.Empty) : iitem.InnerText; whereNode.Nodes.Add(new IfNode { Test = test, Value = value }); } } cmd.Nodes.Add(whereNode); } else if (item.NodeType == XmlNodeType.Element && item.Name == "if") { var test = item.Attributes["test"].Value; var value = string.IsNullOrEmpty(item.InnerText) ? (item.Attributes["value"]?.Value ?? string.Empty) : item.InnerText; cmd.Nodes.Add(new IfNode { Test = test, Value = value }); } } return(cmd); }
/// <summary> /// Generates a full tree from a CommandeNode tree. /// </summary> /// <param name="node"></param> public RemoteCommand(CommandNode node) : base(null, node.name, node.description) { this.isLeaf = node.IsLeaf; for (int i = 0; i < node.children.Count; i++) { this.AddChild(new RemoteCommand(node.children[i])); } }
public void AddNode(CommandNode node) { this.Nodes.Add(node); foreach (var child in node.Children) { this.AddNode(child); } }
public TThis Then(CommandNode <TSource> argument) { if (RedirectTarget != null) { throw new InvalidOperationException("Cannot add children to a redirected node"); } _arguments.AddChild(argument); return(This); }
public static void PrintHelp(DMEnv env, string head) { CommandNode <DMEnv> node = null; if ((node = Global.Dispatcher[head]) != null) { env.Next = string.Join("\n", node.GetHelp()); } env.Next = $"未找到指令:{head}"; }
public AnalysisCommand(CommandNode node) { InitializeComponent(); this.node = node; this.Dock = DockStyle.Fill; txtOutput.Control.DataBindings.Add("Text", node.Command, "LastLog"); lblStatus.Text = node.Command.Status.ToString(); node.Command.PropertyChanged += Command_PropertyChanged; node.Control = this; }
public ChannelData Render(CommandNode commandNode, TimeSpan commandTimeSpan, TimeSpan renderStartTime, TimeSpan renderTimeSpan) { // We're adding only the parameter values. ChannelData data = _effect.Render(commandNode.TargetNodes.ToArray(), commandTimeSpan, ParameterValues); // And then restricting by time. TimeSpan renderEndTime = renderStartTime + renderTimeSpan; data = ChannelData.Restrict(data, renderStartTime, renderEndTime); return data; }
bool Instance_OnExecutionStopped(CommandNode cmd, bool isCompleted = false, CommandResult rlt = null) { if (cmd is ValidateDbCommand) { ValidateDbCommand v = (ValidateDbCommand)cmd; if (v.IsNoException) { if (MessageBox.Show(v.ErrorMsg, "Validation failed", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == System.Windows.Forms.DialogResult.Yes) { rlt.ShouldStop = false; return false; } } } RemoveEvents(); Wizard.UpdateStatus("1000"); return true; }
void State_OnExecCmd(CommandNode cmd, bool isCompleted = false, CommandResult rlt = null) { this.Invoke((MethodInvoker)delegate { if (isCompleted && !rlt.IsSuccessful) { cmd.ExecStatus = CommandStatus.Error; cmd.Error = rlt.LastError; } else if (isCompleted && rlt.IsSuccessful) { cmd.ExecStatus = CommandStatus.Success; } lvCmd.Update(); lvCmd.Invalidate(); }); }
void Instance_OnRunCompleted(CommandNode run2Cmd, CommandNode runFromCmd, bool isStopOnError = false) { ExceptionHandler.IsFullHandling = isFullHandling; ExceptionHandler.Handlers.Remove(OutputError); OutputHandler.Handlers.Remove(Output); RemoveEvents(); if (isStopOnError) { MessageBox.Show("Execution stopped by an error. Please select the item with error status to view the details.", "Stop on Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } Wizard.UpdateStatus("1000"); }
void Instance_OnRun(CommandNode run2Cmd, CommandNode runFromCmd) { if (run2Cmd == null && runFromCmd == null) { InitCmdStatus(); } isFullHandling = ExceptionHandler.IsFullHandling; ExceptionHandler.IsFullHandling = false; ExceptionHandler.Handlers.Add(OutputError); OutputHandler.Handlers.Add(Output); }
void PreviewCmdCallback(CommandNode cmd, bool isComplete, CommandResult rlt) { if (!(cmd is IfCommand) && !(cmd is DescriptionsCommand) && !(cmd is SetCommand)) { cmds.Add(cmd); } }
public void RecordCallStatus(CommandNode node, string description) { _log[node].Add(description); LastLogEntry = description; }
private void LoadAvailableFieldsTree() { IDataSourceFieldSchema[] fieldSchemas = this.GetFieldSchemas(); if ((fieldSchemas != null) && (fieldSchemas.Length > 0)) { this._selectedDataSourceNode = new DataSourceNode(); this._availableFieldsTree.Nodes.Add(this._selectedDataSourceNode); this._selectedCheckBoxDataSourceNode = new BoolDataSourceNode(); this._availableFieldsTree.Nodes.Add(this._selectedCheckBoxDataSourceNode); } HyperLinkNode node = new HyperLinkNode(this); this._availableFieldsTree.Nodes.Add(node); ImageNode node2 = new ImageNode(this); this._availableFieldsTree.Nodes.Add(node2); ButtonNode node3 = new ButtonNode(this); this._availableFieldsTree.Nodes.Add(node3); CommandNode node4 = new CommandNode(this); this._availableFieldsTree.Nodes.Add(node4); CommandNode node5 = new CommandNode(this, 0, System.Design.SR.GetString("DCFEditor_Node_Edit"), 6); node4.Nodes.Add(node5); if (this.Control is GridView) { CommandNode node6 = new CommandNode(this, 2, System.Design.SR.GetString("DCFEditor_Node_Select"), 5); node4.Nodes.Add(node6); } CommandNode node7 = new CommandNode(this, 3, System.Design.SR.GetString("DCFEditor_Node_Delete"), 7); node4.Nodes.Add(node7); if (this.Control is DetailsView) { CommandNode node8 = new CommandNode(this, 1, System.Design.SR.GetString("DCFEditor_Node_Insert"), 11); node4.Nodes.Add(node8); } TemplateNode node9 = new TemplateNode(this); this._availableFieldsTree.Nodes.Add(node9); }
public SettingTag AddCmdItem(string name, CommandNode target, string field, int editorType = 0, bool isReadonly = false) { if (target == null) { return null; } UICommandNode ucmd = null; if (target is UICommandNode) { ucmd = (UICommandNode)target; } PathBrowser pb = new PathBrowser(); ComboBox rd = new ComboBox(); TextBox editor = new TextBox(); CheckBox ck = new CheckBox(); Label lb = new Label { Text = name, AutoSize = true }; if (!string.IsNullOrEmpty(target.Editor) && editors.ContainsKey(target.Editor)) { editorType = editors[target.Editor]; } editor.AllowDrop = true; editor.MouseDoubleClick += new MouseEventHandler(editor_MouseDoubleClick); ck.Enabled = !isReadonly; editor.Enabled = !isReadonly; rd.Enabled = !isReadonly; lb.MouseDown += new MouseEventHandler(lb_MouseDown); SettingTag rlt = null; FieldInfo f = target.GetType().GetField(field); if (f != null) { rlt = new SettingTag { FieldInfo = f, Target = target }; lb.Tag = rlt; object value = f.GetValue(target); rlt.EditorType = editorType; rlt.LabelControl = lb; if (editorType == 1) { rlt.EditControl = ck; ck.Tag = rlt; ck.Checked = value != null ? bool.Parse(value.ToString()) : false; ck.CheckedChanged += new EventHandler(ck_CheckedChanged); UpdatePos(lb, ck); NotifyUINode(ucmd, ck, lb); } else if (editorType == 2) { ArrayCommand arr = target as ArrayCommand; if (arr != null) { //rd.DataSource = null; rd.Items.Clear(); rlt.EditControl = rd; rd.Tag = rlt; //rd.DataSource = arr.GetList(); rd.Items.AddRange(arr.GetList()); rd.SelectedIndex = arr.SelectedIndex; rd.SelectedIndexChanged += new EventHandler(rd_SelectedIndexChanged); UpdatePos(lb, rd); NotifyUINode(ucmd, rd, lb); } } else if (editorType == 3) { rlt.EditControl = pb; pb.Tag = rlt; if (value != null) { pb.StartupPath = value.ToString(); } pb.OnTextChanged+=new Action<PathBrowser>(pb_OnTextChanged); UpdatePos(lb, pb); NotifyUINode(ucmd, pb, lb); } else { if (lb.Text.IndexOf("pwd", StringComparison.OrdinalIgnoreCase) >= 0 || lb.Text.IndexOf("password", StringComparison.OrdinalIgnoreCase) >= 0) { editor.PasswordChar = '*'; } editor.DragEnter += new DragEventHandler(editor_DragEnter); editor.DragDrop += new DragEventHandler(editor_DragDrop); if (editorType == 4) { editor.WordWrap = false; editor.ScrollBars = ScrollBars.Both; editor.Multiline = true; editor.Height = 100; } rlt.EditControl = editor; rlt.Id = lb.Text; rlt.EditorType = 0; editor.Tag = rlt; editor.Text = value != null ? value.ToString() : string.Empty; editor.TextChanged += new EventHandler(editor_TextChanged); UpdatePos(lb, editor); NotifyUINode(ucmd, editor, lb); } } return rlt; }
public void Generate(CommandNode cmd, bool isReadonly = false) { Controls.Clear(); CurtTop = ItemMarginTop; if (cmd != null) { FieldInfo[] list = cmd.GetType().GetFields(); foreach (FieldInfo i in list) { AddCmdItem(i.Name, cmd, i.Name, i.FieldType.Name.IndexOf("bool", StringComparison.OrdinalIgnoreCase) >= 0 ? 1 : 0, isReadonly); } } }
protected Command(CommandNode parent, string verb) : base(parent, verb) { }
public void PreRender(CommandNode commandNode, TimeSpan commandTimeSpan) { _effect.PreRender(commandNode.TargetNodes.ToArray(), commandTimeSpan, ParameterValues); }
private void AddCommandTreeviewNode(CommandNode cmd) { CommandTreeViewNode node = cmd.CreateTreeviewNode(); InsertTreeViewNode(node); }
public UnusedCommandViolation(CommandNode commandNode) { Node = commandNode; }
public IEnumerable<string> GetLog(CommandNode node) { return _log[node]; }