private void CreateControllersTreeFromBinding(ExplorerNode parent, Binding binding) { foreach (Bistro.Methods.Controller item in binding.Controllers) { new ControllerNode(parent, item.Type, ControllerNode.ControllerNodeType.None); } }
internal void ReportError(ExplorerNode node, Errors error) { ErrorNode parent = (ErrorNode)this[error.ToString()]; if (parent == null) parent = new ErrorNode(this, error.ToString(), getMessage(error)); Activator.CreateInstance(node.GetType(), (ExplorerNode)parent, node); }
public static bool Delete(ExplorerNode node, bool PernamentDelete) { string path = node.GetFullPathString(); if (PernamentDelete)//delete { FileInfo info = new FileInfo(path); if (info.Exists) { info.Delete(); return(true); } else { DirectoryInfo dinfo = new DirectoryInfo(path); if (dinfo.Exists) { dinfo.Delete(true); return(true); } } return(false); } else//trash { return(FileOperationAPIWrapper.SendRecycleBin(path)); } }
static void GetItems(MegaApiClient client, INode node, ExplorerNode Enode) { foreach (INode child in client.GetNodes(node)) { ExplorerNode c = new ExplorerNode(); c.Info.ID = child.Id; c.Info.Name = child.Name; c.Info.DateMod = child.LastModificationDate; c.Info.MegaCrypto = new MegaKeyCrypto(child as INodeCrypto); switch (child.Type) { case NodeType.File: c.Info.Size = child.Size; Enode.AddChild(c); break; case NodeType.Directory: c.Info.Size = -1; Enode.AddChild(c); break; default: break; } } }
public LabelNode(ExplorerNode node) : base() { this.Node = node; this.MouseEnter += C_MouseEnter; this.MouseLeave += C_MouseLeave; C_MouseLeave(null, EventArgs.Empty); }
public ExplorerNode GetCloudRootNode(string Email, CloudType cloudname) { foreach (XmlNode node in GetCloudDataList()) { TypeNode root = new TypeNode(); root.Email = node.Attributes["Email"].Value; root.Type = (CloudType)Enum.Parse(typeof(CloudType), node.Attributes["CloudName"].Value); if (root.Email == Email && root.Type == cloudname) { NodeInfo info = new NodeInfo(); try { info.ID = node.Attributes["RootID"].Value; } catch { #if DEBUG Console.WriteLine("{Settings} Can't Get RootID [" + root.Type.ToString() + ":" + root.Email + "]"); #endif } ExplorerNode e_node = new ExplorerNode(); e_node.NodeType = root; e_node.Info = info; return(e_node); } } return(null); }
public static ExplorerNode GetListFileFolder(ExplorerNode node) { string path = node.GetFullPathString(); node.Child.Clear(); foreach (string item in Directory.GetDirectories(path)) { DirectoryInfo info = new DirectoryInfo(item); if (CheckAttribute(info.Attributes, FileAttributes.System) | CheckAttribute(info.Attributes, FileAttributes.Offline)) { continue; } ExplorerNode f = new ExplorerNode(); f.Info.Name = info.Name; f.Info.Size = -1; f.Info.DateMod = info.LastWriteTime; node.AddChild(f); } foreach (string item in Directory.GetFiles(path)) { FileInfo info = new FileInfo(item); if (CheckAttribute(info.Attributes, FileAttributes.System) | CheckAttribute(info.Attributes, FileAttributes.Offline)) { continue; } ExplorerNode f = new ExplorerNode(); f.Info.Name = info.Name; f.Info.Size = info.Length; f.Info.DateMod = info.LastWriteTime; node.AddChild(f); } return(node); }
public static ExplorerNode GetListFileFolder(ExplorerNode node) { node.Child.Clear(); ExplorerNode root = node.GetRoot; MegaApiClient client = GetClient(root.NodeType.Email); if (root == node) { string ID = node.Info.ID; INode n = null; if (!string.IsNullOrEmpty(ID)) { n = new MegaNzNode(ID); } else { n = GetRoot(root.NodeType.Email, NodeType.Root); AppSetting.settings.SetRootID(root.NodeType.Email, CloudType.Mega, n.Id); } GetItems(client, n, node); } else { if (node.Info.Size != -1) { throw new Exception("Can't explorer,this item is not folder."); } MegaNzNode inode = new MegaNzNode(node.Info.Name, node.Info.ID, node.Parent.Info.ID, -1, NodeType.Directory, node.Info.DateMod); GetItems(client, inode, node); } return(node); }
private void uploadFolderToHereToolStripMenuItem_Click(object sender, EventArgs e) { FolderBrowserDialog fbd = new FolderBrowserDialog(); fbd.RootFolder = Environment.SpecialFolder.MyComputer; fbd.ShowNewFolderButton = true; DialogResult result = fbd.ShowDialog(MainForm); if (result == DialogResult.OK | result == DialogResult.Yes) { List <ExplorerNode> list_item_from = new List <ExplorerNode>(); ExplorerNode node = ExplorerNode.GetNodeFromDiskPath(fbd.SelectedPath.TrimEnd('\\')); list_item_from.Add(node); ExplorerNode rootto = managerexplorernodes.NodeWorking(); if (LV_item.SelectedItems.Count == 1) { ExplorerNode find = FindNodeLV(LV_item.SelectedItems[0]); if (find != null && find.Info.Size <= 0) { rootto = find; } } Setting_UI.reflection_eventtocore.ExplorerAndManagerFile.TransferItems(list_item_from, node.Parent, rootto, false); } }
public void AddNewCloudToTV(ExplorerNode newnode) { Dispatcher.Invoke(new Action(() => TreeObservableCollection.Add(new TreeViewDataModel(null) { DisplayData = new TreeviewDataItem(newnode) }))); }
public void ShowDataToLV(ExplorerNode parent) { lv_data.Clear(); foreach (ExplorerNode item in parent.Child) { LV_data dt = new LV_data(); dt.Node = item; if (item.Info.DateMod != time_default) { dt.d_mod = item.Info.DateMod.ToString(timeformat); } if (item.Info.Size >= 0) { dt.SizeString = UnitConventer.ConvertSize(item.Info.Size, 2, UnitConventer.unit_size); string extension = item.GetExtension(); dt.ImgSource = Setting_UI.GetImage( item.GetRoot.NodeType.Type == CloudType.LocalDisk ? IconReader.GetFileIcon(item.GetFullPathString(), IconReader.IconSize.Small, false) : //some large file make slow. IconReader.GetFileIcon("." + extension, IconReader.IconSize.Small, false) ).Source; } else { dt.SizeString = "-1"; dt.ImgSource = Setting_UI.GetImage(IconReader.GetFolderIcon(IconReader.IconSize.Small, IconReader.FolderType.Closed)).Source; } lv_data.Add(dt); } }
public void CreateFolder(ExplorerNode node) { CheckThread(false); switch (node.GetRoot.NodeType.Type) { case CloudType.Dropbox: Dropbox.CreateFolder(node); break; case CloudType.GoogleDrive: GoogleDrive.CreateFolder(node); break; case CloudType.LocalDisk: LocalDisk.CreateFolder(node); break; case CloudType.Mega: MegaNz.CreateFolder(node); break; default: throw new UnknowCloudNameException("Error Unknow Cloud Type: " + node.GetRoot.NodeType.Type.ToString()); } }
public async Task PrepareLightningAsync() { // Activate segwit var blockCount = ExplorerNode.GetBlockCountAsync(); // Fetch node info, but that in cache var merchantInfo = MerchantCharge.Client.GetInfoAsync(); var customer = CustomerEclair.GetNodeInfoAsync(); var channels = CustomerEclair.RPC.ChannelsAsync(); var info = await merchantInfo; var clightning = new NodeInfo(info.Id, MerchantCharge.P2PHost, info.Port); var connect = CustomerEclair.RPC.ConnectAsync(clightning); await Task.WhenAll(blockCount, customer, channels, connect); // Mine until segwit is activated if (blockCount.Result <= 432) { ExplorerNode.Generate(433 - blockCount.Result); } if (channels.Result.Length == 0) { await CustomerEclair.RPC.OpenAsync(clightning, Money.Satoshis(16777215)); while ((await CustomerEclair.RPC.ChannelsAsync())[0].State != "NORMAL") { ExplorerNode.Generate(1); } } }
public List <ExplorerNode> GetListAccountCloud() { #if DEBUG //Console.WriteLine("Check event handle multi?"); #endif List <ExplorerNode> list = new List <ExplorerNode>(); foreach (XmlNode node in GetCloudDataList()) { TypeNode root = new TypeNode(); root.Email = node.Attributes["Email"].Value; root.Type = (CloudType)Enum.Parse(typeof(CloudType), node.Attributes["CloudName"].Value); NodeInfo info = new NodeInfo(); try { info.ID = node.Attributes["RootID"].Value; } catch { #if DEBUG Console.WriteLine("{Settings} Can't Get RootID [" + root.Type.ToString() + ":" + root.Email + "]"); #endif } ExplorerNode e_node = new ExplorerNode(); e_node.NodeType = root; e_node.Info = info; list.Add(e_node); } return(list); }
public bool MoveItem(ExplorerNode node, ExplorerNode newparent, string newname = null, bool Copy = false) { CheckThread(false); if (node.GetRoot == newparent.GetRoot) { bool flag = false; switch (node.GetRoot.NodeType.Type) { case CloudType.Dropbox: flag = Dropbox.Move(node, newparent, newname); break; case CloudType.GoogleDrive: GoogleDrive.MoveItem(node, newparent, newname).parents.ForEach(s => { if (!flag && s.id == newparent.Info.ID) { flag = true; } }); break; case CloudType.LocalDisk: flag = LocalDisk.Move(node, newparent, newname); break; case CloudType.Mega: default: throw new Exception("CloudType not support (" + node.GetRoot.NodeType.Type.ToString() + ")."); } if (flag) { node.Parent.RemoveChild(node); newparent.AddChild(node); } return(flag); } else { throw new Exception("Root not match."); } }
public void CreateTreeNodes(Bistro.Methods.Binding binding) { root = new BistroNode(root, binding); this.PaintTreeNode(root); }
private void deleteToolStripMenuItem_Click(object sender, EventArgs e) { string item = ""; List <ExplorerNode> item_arr = new List <ExplorerNode>(); for (int i = 0; i < LV_item.SelectedItems.Count; i++) { ExplorerNode find = FindNodeLV(LV_item.SelectedItems[i]); if (find != null) { item_arr.Add(find); item += find.Info.Name + "\r\n"; } } DeleteConfirmForm f = new DeleteConfirmForm(); f.TB.Text = item; f.ShowDialog(this); if (f.Delete) { DeleteItems items = new DeleteItems() { Items = item_arr, PernamentDelete = f.CB_pernament.Checked }; Setting_UI.reflection_eventtocore.ExplorerAndManagerFile.DeletePath(items); } }
void uploadfile() { OpenFileDialog ofd = new OpenFileDialog(); ofd.Multiselect = true; ofd.Filter = PCPath.FilterAllFiles; ofd.InitialDirectory = PCPath.Mycomputer; DialogResult result = ofd.ShowDialog(); if (result != DialogResult.OK | result != DialogResult.Yes) { return; } List <ExplorerNode> items = new List <ExplorerNode>(); ExplorerNode root = ExplorerNode.GetNodeFromDiskPath(System.IO.Path.GetDirectoryName(ofd.FileNames[0])); foreach (string s in ofd.SafeFileNames) { ExplorerNode n = new ExplorerNode(); n.Info.Name = s; root.AddChild(n); FileInfo info = new FileInfo(n.GetFullPathString()); n.Info.Size = info.Length; n.Info.DateMod = info.LastWriteTime; items.Add(n); } Setting_UI.reflection_eventtocore.ExplorerAndManagerFile.TransferItems(items, root, managerexplorernodes.NodeWorking(), false); }
public static ExplorerNode GetListFileFolder(ExplorerNode node) { DropboxRequestAPIv2 client = GetAPIv2(node.GetRoot.NodeType.Email); IDropbox_Response_ListFolder response = client.ListFolder(new Dropbox_Request_ListFolder(node.GetFullPathString(false))); node.Child.Clear(); foreach (IDropbox_Response_MetaData metadata in response.entries) { if (metadata.tag == "folder") { new ExplorerNode( new NodeInfo() { Name = metadata.name, Size = -1, ID = metadata.id }, node); } } foreach (IDropbox_Response_MetaData metadata in response.entries) { if (metadata.tag == "file") { new ExplorerNode( new NodeInfo() { Name = metadata.name, Size = metadata.size, ID = metadata.id, DateMod = DateTime.Parse(metadata.client_modified) }, node); } } return(node); }
void ListAllItemInFolder(ExplorerNode node) { ExplorerNode list; try { list = AppSetting.ManageCloud.GetItemsList(node); } catch (UnauthorizedAccessException ex) { Console.WriteLine(ex.Message); return; } if (list.Child.Count == 0)//create empty folder { } else { foreach (ExplorerNode ffitem in list.Child) { if (ffitem.Info.Size <= 0) { ListAllItemInFolder(ffitem); } else { LoadFile(ffitem); } } } }
public List <ExplorerNode> Convert(ExplorerNode parent) { List <ExplorerNode> list = new List <ExplorerNode>(); foreach (GD_item item in items) { bool add = true; GoogleDrive.mimeTypeGoogleRemove.ForEach(m => { if (item.mimeType == m) { add = false; } }); if (add) { list.Add( new ExplorerNode( new NodeInfo() { Name = item.title, MimeType = item.mimeType, ID = item.id, Size = item.fileSize, DateMod = DateTime.Parse(item.modifiedDate) }, parent) ); } } return(list); }
private void OpenItemLV() { if (LV_item.SelectedItems.Count != 1) { return; } ExplorerNode find = FindNodeLV(LV_item.SelectedItems[0]); if (find != null) { if (find.Info.Size > 0) //file { if (find.GetRoot.NodeType.Type != CloudType.LocalDisk) //cloud { MessageBox.Show("Not support now.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Stop); } else//disk { System.Diagnostics.Process.Start(find.GetFullPathString()); } } else//folder { managerexplorernodes.Next(find); ExplorerCurrentNode(); } } }
public static void AutoCreateFolder(ExplorerNode node) { List <ExplorerNode> list = node.GetFullPath(); if (list[0].NodeType.Type != CloudType.Mega) { throw new Exception("Mega only."); } MegaApiClient client = GetClient(list[0].NodeType.Email); list.RemoveAt(0); foreach (ExplorerNode child in list) { if (string.IsNullOrEmpty(child.Info.ID)) { MegaNzNode m_p_node = new MegaNzNode(child.Parent.Info.ID); INode c_node = client.GetNodes(m_p_node).Where(n => n.Name == child.Info.Name).First();//find if (c_node == null) { c_node = client.CreateFolder(child.Info.Name, m_p_node); //if not found -> create } child.Info.ID = c_node.Id; } } }
private void uploadFileToHereToolStripMenuItem_Click(object sender, EventArgs e) { OpenFileDialog ofd = new OpenFileDialog(); ofd.Multiselect = true; ofd.Filter = PCPath.FilterAllFiles; ofd.InitialDirectory = PCPath.Mycomputer; DialogResult result = ofd.ShowDialog(); if (result == DialogResult.OK | result == DialogResult.Yes) { List <ExplorerNode> list_item_from = new List <ExplorerNode>(); string root = Path.GetDirectoryName(ofd.FileNames[0]); ExplorerNode rootnode = ExplorerNode.GetNodeFromDiskPath(root); foreach (string a in ofd.SafeFileNames) { FileInfo info = new FileInfo(root + "\\" + a); ExplorerNode n = new ExplorerNode(); n.Info.Name = a; n.Info.Size = info.Length; rootnode.AddChild(n); list_item_from.Add(n); } Setting_UI.reflection_eventtocore.ExplorerAndManagerFile.TransferItems(list_item_from, rootnode, ((UC_LVitem)tabControl1.SelectedTab.Controls[0]).managerexplorernodes.NodeWorking(), false); } }
/// <summary> /// Creates a controller node for a resource dependency as a child of the resource node /// </summary> /// <param name="parent"></param> /// <param name="type"></param> public ControllerNode(ExplorerNode parent, ControllerType type, ControllerNodeType nodeType) : base(parent, type.Name, ACTIVITY_ICON, ACTIVITY_ICON) { //this.type = type; //type.Register(this); //this.nodeType = nodeType; }
public static void CreateFolder(ExplorerNode node) { MegaNzNode parent_meganode = new MegaNzNode(node.Parent.Info.ID); MegaApiClient client = GetClient(node.GetRoot.NodeType.Email); INode folder_meganode = client.CreateFolder(node.Info.Name, parent_meganode); node.Info.ID = folder_meganode.Id; }
public FolderNode(ExplorerNode parent, string fileName) : base(parent, fileName) { this.Text = fileName; this.ImageIndex = 1; this.SelectedImageIndex = this.ImageIndex; this.NodeFont = new Font(ProjectExplorer.DefaultFont, FontStyle.Regular); }
public static ExplorerNode GetItem(ExplorerNode node) { MegaApiClient client = GetClient(node.GetRoot.NodeType.Email); MegaNzNode inode = new MegaNzNode(node.Info.ID); GetItems(client, inode, node); return(node); }
void CreateFolder() { ExplorerNode node = new ExplorerNode(); node.Info.Name = textBox1.Text; this.parentnode.AddChild(node); Setting_UI.reflection_eventtocore.ExplorerAndManagerFile.CreateFolder(node); Invoke(new Action(() => this.Close())); }
void CreateFolder(object obj) { ExplorerNode n = new ExplorerNode(); n.Info.Name = (string)obj; parent.AddChild(n); Setting_UI.reflection_eventtocore.ExplorerAndManagerFile.CreateFolder(n); Dispatcher.Invoke(new Action(() => this.Close())); }
internal void SetSelected(ExplorerNode node) { foreach (TreeNode treeNode in ControllerView.Nodes.Find(node.Name, true)) if (treeNode == node.TreeNode) { treeNode.Expand(); ControllerView.SelectedNode = treeNode; } }
public static void CreateFolder(ExplorerNode node) { DirectoryInfo dinfo = new DirectoryInfo(node.GetFullPathString()); if (!dinfo.Exists) { dinfo.Create(); } }
public ProjectNode(ExplorerNode parent, string title, string fileName) : base(parent, fileName) { this.Text = title; this.ImageIndex = 0; this.NodeFont = new Font(ProjectExplorer.DefaultFont, FontStyle.Bold); this.Nodes.Add("*DUMMY*"); this.Expand(); }
public void AddItems(List <ExplorerNode> items, ExplorerNode fromfolder, ExplorerNode savefolder, bool AreCut) { ItemsTransferManager gr = new ItemsTransferManager(items, fromfolder, savefolder, AreCut); GroupsWork.Add(gr); Thread thr = new Thread(GroupsWork[GroupsWork.IndexOf(gr)].LoadListItems); thr.Start(); LoadGroupThreads.Add(thr); }
public BindingNode(ExplorerNode parent, string verb, string methodUrl) : base(parent, buildBindingName(parent, verb, methodUrl), BINDERS_ICON, OPEN_FOLDER_ICON) { this.methodUrl = methodUrl; fullMethodUrl = methodUrl; if (parent is BindingNode && !(parent is MethodsNode)) fullMethodUrl = ((BindingNode)parent).fullMethodUrl + fullMethodUrl; this.verb = verb; }
public static ExplorerNode GetMetaData(ExplorerNode node) { DropboxRequestAPIv2 client = GetAPIv2(node.GetRoot.NodeType.Email); IDropbox_Response_MetaData metadata = client.GetMetadata( new Dropbox_Request_Metadata(string.IsNullOrEmpty(node.Info.ID) ? node.GetFullPathString(false, true) : "id:" + node.Info.ID)); node.Info.Name = metadata.name; node.Info.DateMod = DateTime.Parse(metadata.server_modified); node.Info.Size = metadata.size; return(node); }
public static void CreateFolder(ExplorerNode node) { if (node == node.GetRoot) { throw new Exception("Node is root."); } DropboxRequestAPIv2 client = GetAPIv2(node.GetRoot.NodeType.Email); IDropbox_Response_MetaData metadata = client.create_folder(new Dropbox_path(node.GetFullPathString(false))); node.Info.ID = metadata.id; }
public void AddNewCloudToTV(ExplorerNode newnode) { if (InvokeRequired) { Invoke(new Action(() => AddNewCloudToTV_(newnode))); } else { AddNewCloudToTV_(newnode); } }
private static string buildBindingName(ExplorerNode parent, string verb, string methodUrl) { if (parent is MethodsNode) if (verb == "*") return "[ANY] " + methodUrl; else return "[" + verb + "] " + methodUrl; else return methodUrl; }
private void CreateMethodsTreeFromBinding(ExplorerNode parent, Binding binding) { foreach (Bistro.Methods.Binding item in binding.Bindings) { BindingNode newParent = new BindingNode(parent, item.Verb, item.BindingUrl); if (item.Bindings.Count > 0) { CreateMethodsTreeFromBinding(new BindingNode(parent, item.Verb, item.BindingUrl), item); } if (item.Controllers.Count > 0) { CreateControllersTreeFromBinding(newParent, item); } } }
private void CreateControllersTreeFromBinding(ExplorerNode parent, Binding binding) { foreach (Bistro.Methods.Controller item in binding.Controllers) { ControllerNode parent1 = new ControllerNode(parent, item.Type, ControllerNode.ControllerNodeType.None); if (parent1.Name.CompareTo("DataAccessControl")== 0){ new ResourceNode(parent1, "Resource1", ControllerNode.ControllerNodeType.Consumer); new ResourceNode(parent1, "Resource2", ControllerNode.ControllerNodeType.Provider); } if (parent1.Name.CompareTo("AdDisplay") == 0) { new ResourceNode(parent1, "Resource3", ControllerNode.ControllerNodeType.Consumer); new ResourceNode(parent1, "Resource1", ControllerNode.ControllerNodeType.Provider); } if (parent1.Name.CompareTo("AdUpdate") == 0) { new ResourceNode(parent1, "Resource5", ControllerNode.ControllerNodeType.Consumer); new ResourceNode(parent1, "Resource1", ControllerNode.ControllerNodeType.Provider); } } }
public void CreateRootNode(TestDescriptor td) { this.Root = new Controls.Nodes.ApplicationNode(td); this.PaintTreeNode(root); }
public ExpandableNode(ExplorerNode parent, string name, string imageKey) : base(parent, name, imageKey) { }
public ExpandableNode(ExplorerNode parent, ExplorerNode source, string imageKey, string expandedImageKey) : base(parent, source, imageKey, expandedImageKey) { }
public ReferenceNode(ExplorerNode parent) : base(parent, "reference", ERROR_ICON) { }
/// <summary> /// Checks the file name to see if it is valid. /// </summary> /// <param name="filename">File name to check.</param> /// <returns>The error, if any.</returns> private string CheckFileName(string filename, ExplorerNode editedNode) { char[] invalidChars = System.IO.Path.GetInvalidFileNameChars(); if (filename.IndexOfAny(invalidChars) > -1) { return string.Concat("Filename contains invalid characters!"); } else if (filename.Length > 255) { return "Filename to long."; } else if (editedNode is FileNode & Path.GetExtension(filename) != ".prg") { return "Invaild RPGCode Program file extension!"; } else { return null; } }
/// <summary> /// Renames a file. /// </summary> /// <param name="e">Event information.</param> /// <param name="editedNode">The parentNode that was edited.</param> private void RenameNode(NodeLabelEditEventArgs e, ExplorerNode editedNode) { try { string oldFile = editedNode.AbsolutePath; string newFile = System.IO.Path.Combine(editedNode.ParentNode.AbsolutePath, e.Label); if (editedNode is FileNode) { File.Move(oldFile, newFile); } else if (editedNode is FolderNode) { Directory.Move(oldFile, newFile); if (editedNode.Children.Count > 0) { UpdateChildren(editedNode.Children, oldFile + @"\", newFile + @"\"); } } editedNode.File = e.Label; NodeLabelRenameEventArgs args2 = new NodeLabelRenameEventArgs(oldFile, newFile); this.OnNodeRename(args2); } catch (Exception ex) { MessageBox.Show(ex.Message, Application.ExecutablePath, MessageBoxButtons.OK, MessageBoxIcon.Error); e.CancelEdit = true; } }
public ResourceNode(ExplorerNode parent, string name, Controls.Nodes.ControllerNode.ControllerNodeType nodeType) : base(parent, name, GetControllerNodeType(nodeType)) { }
/// <summary> /// required constructor for nodes displaying errors <see cref="M:ErrorsNode.ReportError"/> /// </summary> /// <param name="parent"></param> /// <param name="source"></param> public ResourceNode(ExplorerNode parent, ResourceNode source) : base(parent, source, RESOURCE_ICON, RESOURCE_ICON) { }
public void PaintTreeNode(ExplorerNode node) { node.Paint(ControllerView); }
public BistroNode(ExplorerNode root, Binding binding) : base(root, BISTRO_NODE_NAME, BINDERS_ICON, OPEN_FOLDER_ICON) { methods = new MethodsNode(this); CreateMethodsTreeFromBinding(methods, binding); }
protected BindingNode(ExplorerNode parent, string name, string imageKey, string expandedImageKey) : base(parent, name, imageKey, expandedImageKey) { verb = "*"; }