New project model changes.

svn path=/trunk/monodevelop/; revision=103657

4 files changed, 337 insertions, 57 deletions

diff --git a/main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Pads.ClassPad/CombineNodeBuilder.cs b/main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Pads.ClassPad/CombineNodeBuilder.cs
index 1683abdcb2..77d60c33b3 100644
--- a/main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Pads.ClassPad/CombineNodeBuilder.cs
+++ b/main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Pads.ClassPad/CombineNodeBuilder.cs
@@ -37,19 +37,15 @@ namespace MonoDevelop.Ide.Gui.Pads.ClassPad
 {
 	public class CombineNodeBuilder: TypeNodeBuilder
 	{
-		CombineEntryChangeEventHandler combineEntryAdded;
-		CombineEntryChangeEventHandler combineEntryRemoved;
-		CombineEntryRenamedEventHandler combineNameChanged;
+		SolutionItemRenamedEventHandler combineNameChanged;
 		
 		public CombineNodeBuilder ()
 		{
-			combineEntryAdded = (CombineEntryChangeEventHandler) DispatchService.GuiDispatch (new CombineEntryChangeEventHandler (OnEntryAdded));
-			combineEntryRemoved = (CombineEntryChangeEventHandler) DispatchService.GuiDispatch (new CombineEntryChangeEventHandler (OnEntryRemoved));
-			combineNameChanged = (CombineEntryRenamedEventHandler) DispatchService.GuiDispatch (new CombineEntryRenamedEventHandler (OnCombineRenamed));
+			combineNameChanged = (SolutionItemRenamedEventHandler) DispatchService.GuiDispatch (new SolutionItemRenamedEventHandler (OnCombineRenamed));
 		}
 			
 		public override Type NodeDataType {
-			get { return typeof(Combine); }
+			get { return typeof(SolutionFolder); }
 		}
 
 		public override string ContextMenuAddinPath {
@@ -58,31 +54,32 @@ namespace MonoDevelop.Ide.Gui.Pads.ClassPad
 		
 		public override string GetNodeName (ITreeNavigator thisNode, object dataObject)
 		{
-			return ((Combine)dataObject).Name;
+			return ((SolutionFolder)dataObject).Name;
 		}
 		
 		public override void BuildNode (ITreeBuilder treeBuilder, object dataObject, ref string label, ref Gdk.Pixbuf icon, ref Gdk.Pixbuf closedIcon)
 		{
-			Combine combine = dataObject as Combine;
+			SolutionFolder combine = dataObject as SolutionFolder;
 			label = GettextCatalog.GetString ("Solution {0}", combine.Name);
-			icon = Context.GetIcon (Stock.Solution);
+			icon = Context.GetIcon (Stock.SolutionFolderOpen);
+			closedIcon = Context.GetIcon (Stock.SolutionFolderClosed);
 		}
 
 		public override void BuildChildNodes (ITreeBuilder builder, object dataObject)
 		{
-			Combine combine = (Combine) dataObject;
+			SolutionFolder combine = (SolutionFolder) dataObject;
 			if (builder.Options ["ShowProjects"]) {
-				foreach (CombineEntry entry in combine.Entries)
+				foreach (SolutionItem entry in combine.Items)
 					builder.AddChild (entry);
 			} else {
 				AddClasses (builder, combine);
 			}
 		}
 
-		void AddClasses (ITreeBuilder builder, CombineEntry entry)
+		void AddClasses (ITreeBuilder builder, SolutionItem entry)
 		{
-			if (entry is Combine) {
-				foreach (CombineEntry e in ((Combine)entry).Entries)
+			if (entry is SolutionFolder) {
+				foreach (SolutionItem e in ((SolutionFolder)entry).Items)
 					AddClasses (builder, e);
 			} else if (entry is Project) {
 				ProjectNodeBuilder.BuildChildNodes (builder, entry as Project);
@@ -91,12 +88,12 @@ namespace MonoDevelop.Ide.Gui.Pads.ClassPad
 		
 		public override bool HasChildNodes (ITreeBuilder builder, object dataObject)
 		{
-			return ((Combine) dataObject).Entries.Count > 0;
+			return ((SolutionFolder) dataObject).Items.Count > 0;
 		}
 		
 		public override int CompareObjects (ITreeNavigator thisNode, ITreeNavigator otherNode)
 		{
-			if (otherNode.DataItem is Combine)
+			if (otherNode.DataItem is SolutionFolder)
 				return DefaultSort;
 			else
 				return -1;
@@ -104,44 +101,19 @@ namespace MonoDevelop.Ide.Gui.Pads.ClassPad
 
 		public override void OnNodeAdded (object dataObject)
 		{
-			Combine combine = (Combine) dataObject;
-			combine.EntryAdded += combineEntryAdded;
-			combine.EntryRemoved += combineEntryRemoved;
+			SolutionFolder combine = (SolutionFolder) dataObject;
 			combine.NameChanged += combineNameChanged;
 		}
 		
 		public override void OnNodeRemoved (object dataObject)
 		{
-			Combine combine = (Combine) dataObject;
-			combine.EntryAdded -= combineEntryAdded;
-			combine.EntryRemoved -= combineEntryRemoved;
+			SolutionFolder combine = (SolutionFolder) dataObject;
 			combine.NameChanged -= combineNameChanged;
 		}
 		
-		void OnEntryAdded (object sender, CombineEntryEventArgs e)
+		void OnCombineRenamed (object sender, SolutionItemRenamedEventArgs e)
 		{
-			DispatchService.GuiDispatch (OnAddEntry, e.CombineEntry);
-		}
-		
-		void OnAddEntry (object newEntry)
-		{
-			CombineEntry e = (CombineEntry) newEntry;
-			ITreeBuilder tb = Context.GetTreeBuilder (e.ParentCombine);
-			if (tb != null) {
-				tb.AddChild (e, true);
-				tb.Expanded = true;
-			}
-		}
-
-		void OnEntryRemoved (object sender, CombineEntryEventArgs e)
-		{
-			ITreeBuilder tb = Context.GetTreeBuilder (e.CombineEntry);
-			if (tb != null) tb.Remove ();
-		}
-		
-		void OnCombineRenamed (object sender, CombineEntryRenamedEventArgs e)
-		{
-			ITreeBuilder tb = Context.GetTreeBuilder (e.CombineEntry);
+			ITreeBuilder tb = Context.GetTreeBuilder (e.SolutionItem);
 			if (tb != null) tb.Update ();
 		}
 	}
diff --git a/main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Pads.ClassPad/NamespaceNodeBuilder.cs b/main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Pads.ClassPad/NamespaceNodeBuilder.cs
index 6e51087110..3091293224 100644
--- a/main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Pads.ClassPad/NamespaceNodeBuilder.cs
+++ b/main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Pads.ClassPad/NamespaceNodeBuilder.cs
@@ -52,12 +52,12 @@ namespace MonoDevelop.Ide.Gui.Pads.ClassPad
 		protected override void Initialize ()
 		{
 			changeClassInformationHandler = (ClassInformationEventHandler) DispatchService.GuiDispatch (new ClassInformationEventHandler (OnClassInformationChanged));
-			IdeApp.ProjectOperations.ParserDatabase.ClassInformationChanged += changeClassInformationHandler;
+			IdeApp.Workspace.ParserDatabase.ClassInformationChanged += changeClassInformationHandler;
 		}
 		
 		public override void Dispose ()
 		{
-			IdeApp.ProjectOperations.ParserDatabase.ClassInformationChanged -= changeClassInformationHandler;
+			IdeApp.Workspace.ParserDatabase.ClassInformationChanged -= changeClassInformationHandler;
 		}
 		
 		public override string GetNodeName (ITreeNavigator thisNode, object dataObject)
@@ -77,13 +77,13 @@ namespace MonoDevelop.Ide.Gui.Pads.ClassPad
 			NamespaceData nsData = dataObject as NamespaceData;
 			
 			if (nsData.Project != null) {
-				IParserContext ctx = IdeApp.ProjectOperations.ParserDatabase.GetProjectParserContext (nsData.Project);
+				IParserContext ctx = IdeApp.Workspace.ParserDatabase.GetProjectParserContext (nsData.Project);
 				LanguageItemCollection list = ctx.GetNamespaceContents (nsData.FullName, false);
 				AddProjectContent (builder, nsData.Project, nsData, list);
 			}
 			else {
-				foreach (Project p in IdeApp.ProjectOperations.CurrentOpenCombine.GetAllProjects ()) {
-					IParserContext ctx = IdeApp.ProjectOperations.ParserDatabase.GetProjectParserContext (p);
+				foreach (Project p in IdeApp.Workspace.GetAllProjects ()) {
+					IParserContext ctx = IdeApp.Workspace.ParserDatabase.GetProjectParserContext (p);
 					LanguageItemCollection list = ctx.GetNamespaceContents (nsData.FullName, false);
 					AddProjectContent (builder, p, nsData, list);
 				}
diff --git a/main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Pads.ClassPad/ProjectNodeBuilder.cs b/main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Pads.ClassPad/ProjectNodeBuilder.cs
index f527aa3e2a..3c6bbd4ab8 100644
--- a/main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Pads.ClassPad/ProjectNodeBuilder.cs
+++ b/main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Pads.ClassPad/ProjectNodeBuilder.cs
@@ -40,11 +40,11 @@ namespace MonoDevelop.Ide.Gui.Pads.ClassPad
 {
 	public class ProjectNodeBuilder: TypeNodeBuilder
 	{
-		CombineEntryRenamedEventHandler projectNameChanged;
+		SolutionItemRenamedEventHandler projectNameChanged;
 
 		public ProjectNodeBuilder ()
 		{
-			projectNameChanged = (CombineEntryRenamedEventHandler) DispatchService.GuiDispatch (new CombineEntryRenamedEventHandler (OnProjectRenamed));
+			projectNameChanged = (SolutionItemRenamedEventHandler) DispatchService.GuiDispatch (new SolutionItemRenamedEventHandler (OnProjectRenamed));
 		}
 		
 		public override Type NodeDataType {
@@ -90,7 +90,7 @@ namespace MonoDevelop.Ide.Gui.Pads.ClassPad
 		{
 			bool publicOnly = builder.Options ["PublicApiOnly"];
 			
-			IParserContext ctx = IdeApp.ProjectOperations.ParserDatabase.GetProjectParserContext (project);
+			IParserContext ctx = IdeApp.Workspace.ParserDatabase.GetProjectParserContext (project);
 			LanguageItemCollection list = ctx.GetNamespaceContents ("", false);
 			foreach (ILanguageItem ob in list) {
 				if (ob is Namespace) {
@@ -107,7 +107,7 @@ namespace MonoDevelop.Ide.Gui.Pads.ClassPad
 		
 		public static void FillNamespaces (ITreeBuilder builder, Project project, string ns)
 		{
-			IParserContext ctx = IdeApp.ProjectOperations.ParserDatabase.GetProjectParserContext (project);
+			IParserContext ctx = IdeApp.Workspace.ParserDatabase.GetProjectParserContext (project);
 			if (ctx.GetClassList (ns, false, true).Length > 0) {
 				if (builder.Options ["ShowProjects"])
 					builder.AddChild (new NamespaceData (project, ns));
@@ -127,9 +127,9 @@ namespace MonoDevelop.Ide.Gui.Pads.ClassPad
 			return true;
 		}
 		
-		void OnProjectRenamed (object sender, CombineEntryRenamedEventArgs e)
+		void OnProjectRenamed (object sender, SolutionItemRenamedEventArgs e)
 		{
-			ITreeBuilder tb = Context.GetTreeBuilder (e.CombineEntry);
+			ITreeBuilder tb = Context.GetTreeBuilder (e.SolutionItem);
 			if (tb != null) tb.Update ();
 		}
 	}
diff --git a/main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Pads.ClassPad/SolutionNodeBuilder.cs b/main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Pads.ClassPad/SolutionNodeBuilder.cs
new file mode 100644
index 0000000000..f6fe1911a5
--- /dev/null
+++ b/main/src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Pads.ClassPad/SolutionNodeBuilder.cs
@@ -0,0 +1,308 @@
+// SolutionNodeBuilder.cs
+//
+// Author:
+//   Lluis Sanchez Gual <lluis@novell.com>
+//
+// Copyright (c) 2008 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+//
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+using MonoDevelop.Projects;
+using MonoDevelop.Core;
+using MonoDevelop.Ide.Commands;
+using MonoDevelop.Ide.Gui;
+using MonoDevelop.Core.Gui;
+using MonoDevelop.Components.Commands;
+using MonoDevelop.Ide.Gui.Search;
+
+namespace MonoDevelop.Ide.Gui.Pads.ClassPad
+{
+	public class SolutionNodeBuilder: TypeNodeBuilder
+	{
+		SolutionItemEventHandler combineEntryAdded;
+		SolutionItemEventHandler combineEntryRemoved;
+		EventHandler<WorkspaceItemRenamedEventArgs> combineNameChanged;
+		EventHandler startupChanged;
+		
+		public SolutionNodeBuilder ()
+		{
+			combineEntryAdded = (SolutionItemEventHandler) DispatchService.GuiDispatch (new SolutionItemEventHandler (OnEntryAdded));
+			combineEntryRemoved = (SolutionItemEventHandler) DispatchService.GuiDispatch (new SolutionItemEventHandler (OnEntryRemoved));
+			combineNameChanged = (EventHandler<WorkspaceItemRenamedEventArgs>) DispatchService.GuiDispatch (new EventHandler<WorkspaceItemRenamedEventArgs> (OnCombineRenamed));
+			startupChanged = (EventHandler) DispatchService.GuiDispatch (new EventHandler (OnStartupChanged));
+			
+			IdeApp.Workspace.ItemAddedToSolution += combineEntryAdded;
+			IdeApp.Workspace.ItemRemovedFromSolution += combineEntryRemoved;
+			IdeApp.Workspace.StartupItemChanged += OnStartupChanged;
+		}
+		
+		public override void Dispose ()
+		{
+			base.Dispose ();
+			IdeApp.Workspace.StartupItemChanged -= OnStartupChanged;
+			IdeApp.Workspace.ItemAddedToSolution -= combineEntryAdded;
+			IdeApp.Workspace.ItemRemovedFromSolution -= combineEntryRemoved;
+		}
+
+		public override Type NodeDataType {
+			get { return typeof(Solution); }
+		}
+		
+		public override Type CommandHandlerType {
+			get { return typeof(SolutionNodeCommandHandler); }
+		}
+		
+		public override string GetNodeName (ITreeNavigator thisNode, object dataObject)
+		{
+			return ((Solution)dataObject).Name;
+		}
+		
+		public override void GetNodeAttributes (ITreeNavigator treeNavigator, object dataObject, ref NodeAttributes attributes)
+		{
+			attributes |= NodeAttributes.AllowRename;
+		}
+		
+		public override string ContextMenuAddinPath {
+			get { return "/MonoDevelop/Ide/ContextMenu/ProjectPad/Solution"; }
+		}
+		
+		public override void BuildNode (ITreeBuilder treeBuilder, object dataObject, ref string label, ref Gdk.Pixbuf icon, ref Gdk.Pixbuf closedIcon)
+		{
+			Solution solution = dataObject as Solution;
+			int count = 0;
+			foreach (SolutionItem e in solution.GetAllSolutionItems ())
+				if (!(e is SolutionFolder))
+					count++;
+			
+			switch (count) {
+				case 0:
+					label = GettextCatalog.GetString ("Solution {0}", solution.Name);
+					break;
+				case 1:
+					label = GettextCatalog.GetString ("Solution {0} (1 entry)", solution.Name);
+					break;
+				default:
+					label = GettextCatalog.GetString ("Solution {0} ({1} entries)", solution.Name, count);
+					break;
+			}
+
+			icon = Context.GetIcon (Stock.Solution);
+		}
+
+		public override void BuildChildNodes (ITreeBuilder ctx, object dataObject)
+		{
+			Solution solution = (Solution) dataObject;
+			foreach (SolutionItem entry in solution.RootFolder.Items)
+				ctx.AddChild (entry);
+		}
+
+		public override bool HasChildNodes (ITreeBuilder builder, object dataObject)
+		{
+			return ((Solution) dataObject).RootFolder.Items.Count > 0;
+		}
+		
+		public override object GetParentObject (object dataObject)
+		{
+			return ((Solution) dataObject).ParentWorkspace;
+		}
+		
+		public override void OnNodeAdded (object dataObject)
+		{
+			Solution solution = (Solution) dataObject;
+			solution.NameChanged += combineNameChanged;
+		}
+		
+		public override void OnNodeRemoved (object dataObject)
+		{
+			Solution solution = (Solution) dataObject;
+			solution.NameChanged -= combineNameChanged;
+		}
+		
+		void OnStartupChanged (object sender, EventArgs args)
+		{
+			ITreeBuilder tb = Context.GetTreeBuilder (sender);
+			if (tb != null)
+				tb.UpdateAll ();
+		}
+		
+		void OnEntryAdded (object sender, SolutionItemEventArgs e)
+		{
+			ITreeBuilder tb;
+			if (e.SolutionItem.ParentFolder == null)
+				tb = Context.GetTreeBuilder (e.SolutionItem.ParentSolution);
+			else
+				tb = Context.GetTreeBuilder (e.SolutionItem.ParentFolder);
+			
+			if (tb != null)
+				tb.AddChild (e.SolutionItem, true);
+		}
+
+		void OnEntryRemoved (object sender, SolutionItemEventArgs e)
+		{
+			ITreeBuilder tb = Context.GetTreeBuilder (e.SolutionItem);
+			if (tb != null) {
+				tb.Remove (true);
+			}
+		}
+		
+		void OnCombineRenamed (object sender, WorkspaceItemRenamedEventArgs e)
+		{
+			ITreeBuilder tb = Context.GetTreeBuilder (e.Item);
+			if (tb != null) tb.Update ();
+		}
+	}
+	
+	public class SolutionNodeCommandHandler: NodeCommandHandler
+	{
+		public override void RenameItem (string newName)
+		{
+			if (newName.IndexOfAny (new char [] { '\'', '(', ')', '"', '{', '}', '|' } ) != -1) {
+				MessageService.ShowError (GettextCatalog.GetString ("Solution name may not contain any of the following characters: {0}", "', (, ), \", {, }, |"));
+				return;
+			}
+			
+			Solution sol = (Solution) CurrentNode.DataItem;
+			sol.Name = newName;
+			IdeApp.Workspace.Save();
+		}
+		
+		public override DragOperation CanDragNode ()
+		{
+			return DragOperation.Move;
+		}
+		
+		public override bool CanDropNode (object dataObject, DragOperation operation)
+		{
+			return dataObject is SolutionItem;
+		}
+		
+		public override void OnNodeDrop (object dataObject, DragOperation operation)
+		{
+		}
+			
+		public override void ActivateItem ()
+		{
+			Solution sol = CurrentNode.DataItem as Solution;
+			IdeApp.ProjectOperations.ShowOptions (sol);
+		}
+		
+		[CommandHandler (EditCommands.Delete)]
+		public void RemoveItem ()
+		{
+			Solution solution = CurrentNode.DataItem as Solution;
+			Workspace parent = CurrentNode.GetParentDataItem (typeof(Workspace), false) as Workspace;
+			if (parent == null) return;
+			
+			AlertButton res = MessageService.AskQuestion (GettextCatalog.GetString ("Do you really want to remove solution {0} from workspace {1}?", solution.Name, parent.Name), AlertButton.Remove);
+			if (res == AlertButton.Remove) {
+				parent.Items.Remove (solution);
+				solution.Dispose ();
+				IdeApp.Workspace.Save();
+			}
+		}
+		
+		[CommandUpdateHandler (EditCommands.Delete)]
+		public void OnUpdateRemoveItem (CommandInfo info)
+		{
+			Workspace parent = CurrentNode.GetParentDataItem (typeof(Workspace), false) as Workspace;
+			info.Enabled = parent != null;
+		}
+		
+		[CommandHandler (ProjectCommands.AddNewProject)]
+		public void AddNewProjectToSolution ()
+		{
+			Solution solution = (Solution) CurrentNode.DataItem;
+			SolutionItem ce = IdeApp.ProjectOperations.CreateProject (solution.RootFolder);
+			if (ce == null) return;
+			Tree.AddNodeInsertCallback (ce, new TreeNodeCallback (OnEntryInserted));
+			CurrentNode.Expanded = true;
+		}
+		
+		[CommandHandler (ProjectCommands.AddProject)]
+		public void AddProjectToCombine()
+		{
+			Solution solution = (Solution) CurrentNode.DataItem;
+			SolutionItem ce = IdeApp.ProjectOperations.AddSolutionItem (solution.RootFolder);
+			if (ce == null) return;
+			Tree.AddNodeInsertCallback (ce, new TreeNodeCallback (OnEntryInserted));
+			CurrentNode.Expanded = true;
+		}
+		
+		[CommandHandler (ProjectCommands.AddSolutionFolder)]
+		public void AddFolder()
+		{
+			Solution solution = (Solution) CurrentNode.DataItem;
+			SolutionItem ce = new SolutionFolder ();
+			ce.Name = GettextCatalog.GetString ("New Folder");
+			solution.RootFolder.Items.Add (ce);
+			Tree.AddNodeInsertCallback (ce, OnFolderInserted);
+			CurrentNode.Expanded = true;
+		}
+		
+		[CommandHandler (ProjectCommands.Reload)]
+		public void OnReload ()
+		{
+			Solution solution = (Solution) CurrentNode.DataItem;
+			using (IProgressMonitor m = IdeApp.Workbench.ProgressMonitors.GetLoadProgressMonitor (true)) {
+				solution.ParentWorkspace.ReloadItem (m, solution);
+			}
+		}
+		
+		[CommandUpdateHandler (ProjectCommands.Reload)]
+		public void OnUpdateReload (CommandInfo info)
+		{
+			Solution solution = (Solution) CurrentNode.DataItem;
+			info.Visible = (solution.ParentWorkspace != null) && solution.NeedsReload;
+		}
+		
+		void OnEntryInserted (ITreeNavigator nav)
+		{
+			nav.Selected = true;
+			nav.Expanded = true;
+		}
+		
+		void OnFolderInserted (ITreeNavigator nav)
+		{
+			nav.Selected = true;
+			nav.Expanded = true;
+			Tree.StartLabelEdit ();
+		}
+		
+		[CommandHandler (FileCommands.OpenContainingFolder)]
+		public void OnOpenFolder ()
+		{
+			Solution solution = (Solution) CurrentNode.DataItem;
+			System.Diagnostics.Process.Start ("file://" + solution.BaseDirectory);
+		}
+		
+		[CommandHandler (SearchCommands.FindInFiles)]
+		public void OnFindInFiles ()
+		{
+			Solution solution = (Solution) CurrentNode.DataItem;
+			SearchReplaceInFilesManager.SearchOptions.SearchDirectory = solution.BaseDirectory;
+			SearchReplaceInFilesManager.ShowFindDialog ();
+		}
+	}
+}