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 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 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 int CompareObjects (ITreeNavigator thisNode, ITreeNavigator otherNode)
		{
			if (otherNode.DataItem is Enumeration)
				return 1;
			else
				return -1;
		}

		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.DataItem is ProjectReferenceCollection) {
         return 1;
     }
     return -1;
 }

        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 string GetNodeName (ITreeNavigator thisNode, object dataObject)
		{
			if (thisNode.Options["NestedNamespaces"])
				return ((Namespace)dataObject).Name;
			else
				return ((Namespace)dataObject).FullName;
		}

		public override int CompareObjects (ITreeNavigator thisNode, ITreeNavigator otherNode)
		{
			if (otherNode.DataItem is SolutionFolderFileNode)
				return DefaultSort;
			else
				return -1;
		}

    /// <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 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 int CompareObjects(ITreeNavigator thisNode, ITreeNavigator otherNode)
        {
            if (thisNode.Options ["GroupByType"]) {

            }
            return DefaultSort;
        }

		public override int CompareObjects (ITreeNavigator thisNode, ITreeNavigator otherNode)
		{
			if (otherNode.DataItem is ProjectFolder)
				return 1;
			else
				return DefaultSort;
		}

		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 (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 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 string GetNodeName (ITreeNavigator thisNode, object dataObject)
		{
			RegistryInfo reg = (RegistryInfo) dataObject;
			string name = reg.ApplicationName;
			if (string.IsNullOrEmpty (name))
				name = reg.ApplicationPath;
			return name;
		}

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