List<ReferenceSegment> IAssemblyBrowserNodeBuilder.Disassemble (TextEditorData data, ITreeNavigator navigator) { if (DomMethodNodeBuilder.HandleSourceCodeEntity (navigator, data)) return null; var field = CecilLoader.GetCecilObject ((IUnresolvedField)navigator.DataItem); return DomMethodNodeBuilder.Disassemble (data, rd => rd.DisassembleField (field)); }
public override int CompareObjects (ITreeNavigator thisNode, ITreeNavigator otherNode) { if (otherNode.DataItem is ProjectFolder) return 1; else return DefaultSort; }
public override int CompareObjects(ITreeNavigator thisNode, ITreeNavigator otherNode) { if (otherNode.DataItem is ProjectReferenceCollection) { return 1; } return -1; }
public override int CompareObjects (ITreeNavigator thisNode, ITreeNavigator otherNode) { if (otherNode.DataItem is SolutionFolderFileNode) return DefaultSort; else return -1; }
public void Fill (Extension ext, ITreeNavigator nav) { labelName.Markup = "<small>Extension</small>\n<big><b>" + GLib.Markup.EscapeText (Util.GetDisplayName (ext)) + "</b></big>"; object parent = ext.GetExtendedObject (); if (parent is ExtensionPoint) { ExtensionPoint ep = (ExtensionPoint) parent; string txt = "<small>Extension Point</small>\n<b>" + GLib.Markup.EscapeText (Util.GetDisplayName (ep)) + "</b>"; if (!string.IsNullOrEmpty (ep.Description)) txt += "\n" + GLib.Markup.EscapeText (ep.Description); Gtk.Label lab = new Gtk.Label (); lab.Xalign = lab.Yalign = 0; lab.Markup = txt; lab.WidthRequest = 400; lab.Wrap = true; Gtk.Image img = new Gtk.Image (ImageService.GetPixbuf ("md-extension-point", Gtk.IconSize.Menu)); img.Yalign = 0; Gtk.HBox box = new Gtk.HBox (false, 6); box.PackStart (img, false, false, 0); box.PackStart (lab, true, true, 0); buttonExt.Add (box); buttonExt.ShowAll (); buttonExt.Clicked += delegate { if (nav.MoveToObject (ext)) { nav.MoveToParent (typeof(Solution)); nav.Expanded = true; if (nav.MoveToObject (ep.ParentAddinDescription)) { nav.Expanded = true; if (nav.MoveToObject (ep)) nav.Selected = true; } } }; } }
public override string GetNodeName (ITreeNavigator thisNode, object dataObject) { var method = (IUnresolvedMethod)dataObject; if (method.EntityType == EntityType.Constructor || method.EntityType == EntityType.Destructor) return method.DeclaringTypeDefinition.Name; return method.Name; }
public override int CompareObjects (ITreeNavigator thisNode, ITreeNavigator otherNode) { if (otherNode.DataItem is Enumeration) return 1; else return -1; }
public override string GetNodeName (ITreeNavigator thisNode, object dataObject) { if (thisNode.Options["NestedNamespaces"]) return ((Namespace)dataObject).Name; else return ((Namespace)dataObject).FullName; }
public override string GetNodeName (ITreeNavigator thisNode, object dataObject) { TranslationProject project = dataObject as TranslationProject; if (project == null) return "TranslationProject"; return project.Name; }
public override int CompareObjects(ITreeNavigator thisNode, ITreeNavigator otherNode) { if (thisNode.Options ["GroupByType"]) { } return DefaultSort; }
/// <summary> /// Checks if it's necessary to parse and cache the current selection. /// </summary> /// <param name="currentTreeSelection">Current tree selection.</param> /// <param name="forceCaching">Overrides the current logic and forces the caching of the current selection.</param> /// <returns>True if it's necessary to parse and cache the current selection, false otherwise.</returns> private bool MustParseAndCacheCurrentSelection(ITreeNavigator[] currentTreeSelection, bool forceCaching) { bool parseAndCacheCurrentSelection = false; // Check if the cached tree selection and the current one are still the same. if (cachedTreeSelection != null && currentTreeSelection != null && cachedTreeSelection.Length == currentTreeSelection.Length && !forceCaching) { // Check if the selection is still the same. for (int i = 0; i < cachedTreeSelection.Length; i++) { if (!cachedTreeSelection[i].DataItem.Equals(currentTreeSelection[i].DataItem)) { cachedTreeSelection = currentTreeSelection; parseAndCacheCurrentSelection = true; break; } } } else { cachedTreeSelection = currentTreeSelection; parseAndCacheCurrentSelection = true; } return parseAndCacheCurrentSelection; }
public static void MoveCopyFile(Project project, ITreeNavigator nav, string filename, bool move, bool alreadyInPlace) { if (Runtime.FileUtilityService.IsDirectory (filename)) return; ProjectFolder folder = nav.GetParentDataItem (typeof(ProjectFolder), true) as ProjectFolder; string name = System.IO.Path.GetFileName (filename); string baseDirectory = folder != null ? folder.Path : project.BaseDirectory; string newfilename = alreadyInPlace ? filename : Path.Combine (baseDirectory, name); if (filename != newfilename) { if (File.Exists (newfilename)) { if (!Runtime.MessageService.AskQuestion (string.Format (GettextCatalog.GetString ("The file '{0}' already exists. Do you want to replace it?"), newfilename), "MonoDevelop")) return; } File.Copy (filename, newfilename, true); if (move) Runtime.FileService.RemoveFile (filename); } if (project.IsCompileable (newfilename)) { project.AddFile (newfilename, BuildAction.Compile); } else { project.AddFile (newfilename, BuildAction.Nothing); } Runtime.ProjectService.SaveCombine(); }
public override void GetNodeAttributes (ITreeNavigator parentNode, object dataObject, ref NodeAttributes attributes) { Project p = parentNode.DataItem as Project; if (p is CProject) attributes |= NodeAttributes.Hidden; }
public override string GetNodeName (ITreeNavigator thisNode, object dataObject) { Translation translation = dataObject as Translation; if (translation == null) return "Translation"; return translation.IsoCode; }
public override int CompareObjects (ITreeNavigator thisNode, ITreeNavigator otherNode) { if (otherNode.NodeName == ".NET Portable Subset") { return 1; } return -1; }
public AddinData GetAddinData (ITreeNavigator nav) { DotNetProject p = (DotNetProject) nav.GetParentDataItem (typeof(DotNetProject), true); if (p == null) return null; return p.GetAddinData (); }
public override int CompareObjects (ITreeNavigator thisNode, ITreeNavigator otherNode) { AddinDescription ad1 = thisNode.DataItem as AddinDescription; AddinDescription ad2 = otherNode.DataItem as AddinDescription; if (ad1 != null && ad2 != null) return Util.GetDisplayName (ad1).CompareTo (Util.GetDisplayName (ad2)); return base.CompareObjects (thisNode, otherNode); }
public override string GetNodeName (ITreeNavigator thisNode, object dataObject) { RegistryInfo reg = (RegistryInfo) dataObject; string name = reg.ApplicationName; if (string.IsNullOrEmpty (name)) name = reg.ApplicationPath; return name; }
public override int CompareObjects (ITreeNavigator thisNode, ITreeNavigator otherNode) { if (otherNode.DataItem is ProjectReferenceCollection) return 1; if (otherNode.DataItem is Ide.Gui.Pads.ProjectPad.GettingStartedNode) return 1; return -1; }
public override void GetNodeAttributes (ITreeNavigator treeNavigator, object dataObject, ref NodeAttributes attributes) { ProjectFile file = (ProjectFile) dataObject; attributes |= NodeAttributes.AllowRename; if (!file.Visible && !treeNavigator.Options ["ShowAllFiles"]) attributes |= NodeAttributes.Hidden; }
public override string GetNodeName (ITreeNavigator thisNode, object dataObject) { PythonFunction pyNode = dataObject as PythonFunction; List<string> args = new List<string> (); foreach (PythonArgument pyArg in pyNode.Arguments) args.Add (pyArg.Name); return pyNode.Name + "(" + String.Join (", ", args.ToArray ()) + ")"; }
public override void GetNodeAttributes (ITreeNavigator parentNode, object dataObject, ref NodeAttributes attributes) { Solution sol = (Solution) dataObject; foreach (DotNetProject p in sol.GetAllSolutionItems<DotNetProject> ()) { if (p.GetAddinData () != null) return; } attributes |= NodeAttributes.Hidden; }
/// <summary> /// Gets the attributes of the given node. In this case, sets the hidden attribute if the node matches the Connected Services folder in the project root /// </summary> public override void GetNodeAttributes (ITreeNavigator parentNode, object dataObject, ref NodeAttributes attributes) { var folder = (ProjectFolder)dataObject; if (parentNode != null && parentNode.DataItem is DotNetProject && folder.Path.FileName == ConnectedServices.ProjectStateFolderName) { attributes |= NodeAttributes.Hidden; } }
internal static void PrintDeclaringType (StringBuilder result, ITreeNavigator navigator) { var type = (IType)navigator.GetParentDataItem (typeof (IType), false); if (type == null) return; result.Append (String.Format (GettextCatalog.GetString ("<b>Declaring Type:</b>\t{0}"), type.FullName)); result.AppendLine (); }
public override int CompareObjects (ITreeNavigator thisNode, ITreeNavigator otherNode) { if (otherNode.DataItem is BaseTypeFolder) return 1; if (otherNode.DataItem is IMethod) return ((IMethod)thisNode.DataItem).Name.CompareTo (((IMethod)otherNode.DataItem).Name); return -1; }
public override int CompareObjects (ITreeNavigator thisNode, ITreeNavigator otherNode) { object o1 = thisNode.DataItem; object o2 = otherNode.DataItem; if ((o1 is AddinCategoryGroup) && !(o2 is AddinCategoryGroup)) return -1; if ((o2 is AddinCategoryGroup) && !(o1 is AddinCategoryGroup)) return 1; return base.CompareObjects (thisNode, otherNode); }
public override int CompareObjects (ITreeNavigator thisNode, ITreeNavigator otherNode) { PythonNode x = thisNode.DataItem as PythonNode; PythonNode y = otherNode.DataItem as PythonNode; if (x == null || y == null) return 1; return x.Region.Start.Line.CompareTo (y.Region.Start.Line); }
public AddinRegistry GetRegistry (ITreeNavigator nav) { Solution sol = (Solution) nav.GetParentDataItem (typeof(Solution), true); if (sol != null) return sol.GetAddinData ().Registry; RegistryInfo reg = (RegistryInfo) nav.GetParentDataItem (typeof(RegistryInfo), true); if (reg != null) return reg.CachedRegistry; return null; }
public override string GetNodeName (ITreeNavigator thisNode, object dataObject) { Solution sol = (Solution) dataObject; if (forBrowser) { SolutionAddinData data = sol.GetAddinData (); if (data != null && data.ApplicationName != null) return data.ApplicationName; } return sol.Name; }
public override void GetNodeAttributes (ITreeNavigator treeNavigator, object dataObject, ref NodeAttributes attributes) { ProjectFile file = (ProjectFile) dataObject; if (file.DependsOnFile != null) { attributes = NodeAttributes.None; } else { attributes |= NodeAttributes.AllowRename; } if (!file.Visible && !treeNavigator.Options ["ShowAllFiles"]) attributes |= NodeAttributes.Hidden; }
public override string GetNodeName(ITreeNavigator thisNode, object dataObject) { var file = (ProjectFile)dataObject; return(file.Link.IsNullOrEmpty ? file.FilePath.FileName : file.Link.FileName); }
public override string GetNodeName(ITreeNavigator thisNode, object dataObject) { var reference = dataObject as ITypeReference; return(reference.ToString()); }
List <ReferenceSegment> IAssemblyBrowserNodeBuilder.Decompile(TextEditor data, ITreeNavigator navigator, DecompileFlags flags) { if (MethodDefinitionNodeBuilder.HandleSourceCodeEntity(navigator, data)) { return(null); } var evt = navigator.DataItem as IEvent; if (evt == null) { return(null); } return(MethodDefinitionNodeBuilder.Decompile(data, MethodDefinitionNodeBuilder.GetAssemblyLoader(navigator), b => b.Decompile(evt.MetadataToken), flags: flags)); }
public override string GetNodeName(ITreeNavigator thisNode, object dataObject) { return(((Union)dataObject).Name); }
void OnEntryInserted(ITreeNavigator nav) { nav.Selected = true; nav.Expanded = true; }
public override string GetNodeName(ITreeNavigator thisNode, object dataObject) { return("Dependencies"); }
List <ReferenceSegment> IAssemblyBrowserNodeBuilder.Decompile(TextEditorData data, ITreeNavigator navigator, bool publicOnly) { if (DomMethodNodeBuilder.HandleSourceCodeEntity(navigator, data)) { return(null); } var evt = CecilLoader.GetCecilObject((IUnresolvedEvent)navigator.DataItem); return(DomMethodNodeBuilder.Decompile(data, DomMethodNodeBuilder.GetModule(navigator), evt.DeclaringType, b => b.AddEvent(evt))); }
public string GetDocumentationMarkup(ITreeNavigator navigator) { DomCecilCompilationUnit.Module module = (DomCecilCompilationUnit.Module)navigator.DataItem; return("<big>" + String.Format(GettextCatalog.GetString("Module <b>{0}</b>"), module.ModuleDefinition.Name) + "</big>"); }
public List <ReferenceSegment> Decompile(TextEditorData data, ITreeNavigator navigator) { return(Disassemble(data, navigator)); }
public override string GetNodeName(ITreeNavigator thisNode, object dataObject) { return(((UnknownSolutionItem)dataObject).Name); }
public override string GetNodeName(ITreeNavigator thisNode, object dataObject) { return(dataObject != null?dataObject.ToString() : "null module"); }
List <ReferenceSegment> IAssemblyBrowserNodeBuilder.Disassemble(TextEditorData data, ITreeNavigator navigator) { var method = (IUnresolvedMethod)navigator.DataItem; if (HandleSourceCodeEntity(navigator, data)) { return(null); } var cecilMethod = CecilLoader.GetCecilObject(method); if (cecilMethod == null) { return(null); } return(Disassemble(data, rd => rd.DisassembleMethod(cecilMethod))); }
public override int CompareObjects(ITreeNavigator thisNode, ITreeNavigator otherNode) { return -1; }
public override string GetNodeName(ITreeNavigator thisNode, object dataObject) { return "References"; }
public override string GetNodeName(ITreeNavigator thisNode, object dataObject) { var dependency = (AddinFile)dataObject; return(dependency.File); }
public override string GetNodeName (ITreeNavigator thisNode, object dataObject) { return ((ProjectFolder)dataObject).Name; }
public override string GetNodeName(ITreeNavigator thisNode, object dataObject) { return("UserInterface"); }
public override void GetNodeAttributes(ITreeNavigator treeNavigator, object dataObject, ref NodeAttributes attributes) { attributes |= NodeAttributes.AllowRename; }
public override string GetNodeName(ITreeNavigator thisNode, object dataObject) { var evt = (IUnresolvedEvent)dataObject; return(evt.Name); }
public override string GetNodeName(ITreeNavigator thisNode, object dataObject) { return(Path.GetFileName(((SystemFile)dataObject).Name)); }
List <ReferenceSegment> IAssemblyBrowserNodeBuilder.Disassemble(TextEditorData data, ITreeNavigator navigator) { if (DomMethodNodeBuilder.HandleSourceCodeEntity(navigator, data)) { return(null); } var evt = CecilLoader.GetCecilObject((IUnresolvedEvent)navigator.DataItem); return(DomMethodNodeBuilder.Disassemble(data, rd => rd.DisassembleEvent(evt))); }
public override string GetNodeName(ITreeNavigator thisNode, object dataObject) { var type = (IUnresolvedTypeDefinition)dataObject; return(type.Name); }
void OnFolderInserted(ITreeNavigator nav) { nav.Selected = true; nav.Expanded = true; Tree.StartLabelEdit(); }
public override string GetNodeName(ITreeNavigator thisNode, object dataObject) { Namespace ns = (Namespace)dataObject; return(ns.Name); }
public override string GetNodeName(ITreeNavigator thisNode, object dataObject) { ProcedureNode node = dataObject as ProcedureNode; return(node.Procedure.Name); }
string IAssemblyBrowserNodeBuilder.GetDocumentationMarkup(ITreeNavigator navigator) { return(null); }
public override string GetNodeName(ITreeNavigator thisNode, object dataObject) { return(((PackagingProject)dataObject).Name); }
public override string GetNodeName(ITreeNavigator thisNode, object dataObject) { return(GettextCatalog.GetString("Rules")); }
public override string GetNodeName(ITreeNavigator thisNode, object dataObject) { return("Base Types"); }
List <ReferenceSegment> IAssemblyBrowserNodeBuilder.Disassemble(TextEditor data, ITreeNavigator navigator) { if (MethodDefinitionNodeBuilder.HandleSourceCodeEntity(navigator, data)) { return(null); } var evt = (IEvent)navigator.DataItem; return(MethodDefinitionNodeBuilder.Disassemble(data, rd => rd.DisassembleEvent(evt.ParentModule.PEFile, (System.Reflection.Metadata.EventDefinitionHandle)evt.MetadataToken))); }