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)));
}
