public CustomCommandWidget (WorkspaceObject entry, CustomCommand cmd, ConfigurationSelector configSelector, CustomCommandType[] supportedTypes)
		{
			this.Build();
			this.supportedTypes = supportedTypes;
			this.cmd = cmd;
			
			updating = true;
			
			if (cmd == null)
				comboType.AppendText (GettextCatalog.GetString ("(Select a project operation)"));
			
			foreach (var ct in supportedTypes)
				comboType.AppendText (commandNames [(int)ct]);
			
			updating = false;
			
			this.entry = entry;
			UpdateControls ();
			this.WidgetFlags |= Gtk.WidgetFlags.NoShowAll;
			
			StringTagModelDescription tagModel;
			if (entry is SolutionFolderItem)
				tagModel = ((SolutionFolderItem)entry).GetStringTagModelDescription (configSelector);
			else if (entry is WorkspaceItem)
				tagModel = ((WorkspaceItem)entry).GetStringTagModelDescription ();
			else
				tagModel = new StringTagModelDescription ();

			tagSelectorDirectory.TagModel = tagModel;
			tagSelectorDirectory.TargetEntry = workingdirEntry;
			
			tagSelectorCommand.TagModel = tagModel;
			tagSelectorCommand.TargetEntry = entryCommand;
		}

		internal protected override bool SupportsObject (WorkspaceObject item)
		{
			var p = item as SolutionItem;
			if (p == null)
				return false;

			return FlavorGuid == null || p.GetItemTypeGuids ().Any (id => id.Equals (FlavorGuid, StringComparison.OrdinalIgnoreCase));
		}

		public VersionControlItem (Repository repository, WorkspaceObject workspaceObject, FilePath path, bool isDirectory, VersionInfo versionInfo)
		{
			Path = path;
			Repository = repository;
			WorkspaceObject = workspaceObject;
			IsDirectory = isDirectory;
			this.versionInfo = versionInfo;
		}

		protected UnitTest (string name, WorkspaceObject ownerSolutionItem)
		{
			this.name = name;
			this.ownerSolutionItem = ownerSolutionItem;
			ownerSolutionEntityItem = ownerSolutionItem as SolutionItem;
			if (ownerSolutionEntityItem != null)
				ownerSolutionEntityItem.DefaultConfigurationChanged += OnConfugurationChanged;
		}

		void HandleTreeSelectionChanged (object sender, EventArgs e)
		{
			TreeIter it;
			if (tree.Selection.GetSelected (out it))
				currentSelection = (WorkspaceObject) store.GetValue (it, 2);
			else
				currentSelection = null;
			
			if (SelectionChanged != null)
				SelectionChanged (this, EventArgs.Empty);
		}

		public UnitTest CreateUnitTest (WorkspaceObject entry)
		{
			var ext = entry.GetService<MonoMakefileProjectExtension> ();
			if (ext != null) {
				var project = (DotNetProject) entry;
				if (ext.UnitTest != null)
					return (UnitTest) ext.UnitTest;
				string testFileBase = ext.GetTestFileBase ();
				UnitTest testSuite = new MonoTestSuite (project, project.Name, testFileBase);
				ext.UnitTest = testSuite;
				return testSuite;
			}
			return null;
		}

		public UnitTest CreateUnitTest (WorkspaceObject entry)
		{
			UnitTest test = null;
			
			if (entry is DotNetProject)
				test = NUnitProjectTestSuite.CreateTest ((DotNetProject)entry);
			
			UnitTestGroup grp = test as UnitTestGroup;
			if (grp != null && !grp.HasTests) {
				test.Dispose ();
				return null;
			}
			
			return test;
		}

		internal protected override bool SupportsObject (WorkspaceObject item)
		{
			var s = item as SolutionItem;
			if (s == null)
				return false;

			var res = FlavorGuid == null || s.GetItemTypeGuids ().Any (id => id.Equals (FlavorGuid, StringComparison.OrdinalIgnoreCase));

			if (!res)
				return false;

			var p = item as DotNetProject;
			if (p == null || LanguageName == null)
				return true;

			return LanguageName == p.LanguageName;
		}

		public VersionControlItem (Repository repository, WorkspaceObject workspaceObject, FilePath path, bool isDirectory, VersionInfo versionInfo)
		{
			Path = path;
			Repository = repository;
			WorkspaceObject = workspaceObject;
			IsDirectory = isDirectory;
			this.versionInfo = versionInfo;

			var obj = workspaceObject;
			while (obj != null) {
				var p = obj as Project;
				if (p != null)
					ContainerProject = p;

				obj = obj.ParentObject;
			}
		}

		public static void AddTask (string fileName, string message, int column, int line, TaskSeverity taskType, WorkspaceObject workspaceObject)
		{
			// HACK: Use a compiler error since we cannot add an error
			// task otherwise (task type property is read-only and
			// no constructors usable).
			BuildError error = new BuildError ();
			error.Column = column;
			error.Line = line;
			error.ErrorText = message;
			error.FileName = fileName;
			error.IsWarning = false;
			
			//Task task = new Task(fileName, message, column, line);
			TaskListEntry task = new TaskListEntry (error);
			task.WorkspaceObject = workspaceObject;
			task.Owner = ActiveEditor;
			TaskService.Errors.Add(task);
		}

		public UnitTest CreateUnitTest (WorkspaceObject entry)
		{
			UnitTest test = null;
			
			if (entry is SolutionFolder)
				test = SolutionFolderTestGroup.CreateTest ((SolutionFolder)entry);
			if (entry is Solution)
				test = SolutionFolderTestGroup.CreateTest (((Solution)entry).RootFolder);
			if (entry is Workspace)
				test = WorkspaceTestGroup.CreateTest ((Workspace)entry);
			
			UnitTestGroup grp = test as UnitTestGroup;
			if (grp != null && !grp.HasTests) {
				test.Dispose ();
				return null;
			}
			
			return test;
		}

		public static bool Publish (WorkspaceObject entry, FilePath localPath, bool test)
		{
			if (test)
				return VersionControlService.CheckVersionControlInstalled () && VersionControlService.GetRepository (entry) == null;

			List<FilePath> files = new List<FilePath> ();

			// Build the list of files to be checked in			
			string moduleName = entry.Name;
			if (localPath == entry.BaseDirectory) {
				GetFiles (files, entry);
			} else if (entry is Project) {
				foreach (ProjectFile file in ((Project)entry).Files.GetFilesInPath (localPath))
					if (file.Subtype != Subtype.Directory)
						files.Add (file.FilePath);
			} else
				return false;

			if (files.Count == 0)
				return false;
	
			SelectRepositoryDialog dlg = new SelectRepositoryDialog (SelectRepositoryMode.Publish);
			try {
				dlg.ModuleName = moduleName;
				dlg.Message = GettextCatalog.GetString ("Initial check-in of module {0}", moduleName);
				do {
					if (MessageService.RunCustomDialog (dlg) == (int) Gtk.ResponseType.Ok && dlg.Repository != null) {
						AlertButton publishButton = new AlertButton ("_Publish");					
						if (MessageService.AskQuestion (GettextCatalog.GetString ("Are you sure you want to publish the project?"), GettextCatalog.GetString ("The project will be published to the repository '{0}', module '{1}'.", dlg.Repository.Name, dlg.ModuleName), AlertButton.Cancel, publishButton) == publishButton) {
							PublishWorker w = new PublishWorker (dlg.Repository, dlg.ModuleName, localPath, files.ToArray (), dlg.Message);
							w.Start ();
							break;
						}
					} else
						break;
				} while (true);
			} finally {
				dlg.Destroy ();
				dlg.Dispose ();
			}
			return true;
		}

		public UnitTest CreateUnitTest (WorkspaceObject entry)
		{
			UnitTest test = null;
			
			if (entry is SolutionFolder)
				test = SolutionFolderTestGroup.CreateTest ((SolutionFolder)entry);
			if (entry is Solution)
				test = SolutionFolderTestGroup.CreateTest (((Solution)entry).RootFolder);
			if (entry is Workspace)
				test = WorkspaceTestGroup.CreateTest ((Workspace)entry);
			if (entry is DotNetProject)
				test = NUnitProjectTestSuite.CreateTest ((DotNetProject)entry);
			if (entry is NUnitAssemblyGroupProject)
				test = ((NUnitAssemblyGroupProject)entry).RootTest;
			
			UnitTestGroup grp = test as UnitTestGroup;
			if (grp != null && !grp.HasTests) {
				test.Dispose ();
				return null;
			}
			
			return test;
		}

		public bool BelongsToItem (WorkspaceObject item, bool checkHierarchy)
		{
			if (!checkHierarchy)
				return item == parentObject;
			
			WorkspaceObject cit = parentObject;
			do {
				if (cit == item)
					return true;
				if (cit is SolutionFolderItem) {
					var sfi = (SolutionFolderItem) cit;
					if (sfi.ParentFolder != null)
						cit = sfi.ParentFolder;
					else
						cit = sfi.ParentSolution;
				}
				else if (cit is WorkspaceItem) {
					cit = ((WorkspaceItem)cit).ParentWorkspace;
				}
				else
					cit = null;
			} while (cit != null);
			
			return false;
		}

		public TaskListEntry (BuildError error, object owner)
		{
			parentObject = error.SourceTarget as WorkspaceObject;
			file = error.FileName;
			this.owner = owner;
			description = error.ErrorText;
			column = error.Column;
			line = error.Line;
			if (!string.IsNullOrEmpty (error.ErrorNumber))
				description += " (" + error.ErrorNumber + ")";
			if (error.IsWarning)
				severity = error.ErrorNumber == "COMMENT" ? TaskSeverity.Information : TaskSeverity.Warning;
			else
				severity = TaskSeverity.Error;
			priority = TaskPriority.Normal;
			code = error.ErrorNumber;
			category = error.Subcategory;
			helpKeyword = error.HelpKeyword;
		}

		bool IsSelectable (WorkspaceObject item)
		{
			if (SelectableFilter != null && !SelectableFilter (item))
				return false;
			if (selectableTypes.Count > 0)
				return selectableTypes.Any (t => t.IsInstanceOfType (item));
			return true;
		}

		public void ShowOptions (WorkspaceObject entry)
		{
			ShowOptions (entry, null);
		}

		internal static bool ContainsTarget (WorkspaceObject owner, WorkspaceObject target)
		{
			if (owner == target)
				return true;
			else if (target is RootWorkspace)
				return ContainsTarget (owner, IdeApp.ProjectOperations.CurrentSelectedSolution);
			else if (owner is WorkspaceItem)
				return ((WorkspaceItem)owner).ContainsItem (target);
			return false;
		}

		public bool IsBuilding (WorkspaceObject ob)
		{
			var owner = currentBuildOperationOwner as WorkspaceObject;
			return owner != null && !currentBuildOperation.IsCompleted && ContainsTarget (ob, owner);
		}

		bool SetSelection (TreeIter it, WorkspaceObject selected, HashSet<WorkspaceObject> active)
		{
			do {
				WorkspaceObject item = (WorkspaceObject) store.GetValue (it, 2);
				if (selected != null && item == selected) {
					tree.Selection.SelectIter (it);
					tree.ExpandToPath (store.GetPath (it));
					tree.ScrollToCell (store.GetPath (it), tree.Columns[0], false, 0, 0);
					if (active == null)
						return true;
				}
				bool val = (bool) store.GetValue (it, 3);
				bool newVal = active != null ? active.Contains (item) : val;
				if (val != newVal)
					store.SetValue (it, 3, newVal);
				
				TreeIter ci;
				if (store.IterChildren (out ci, it)) {
					if (SetSelection (ci, selected, active))
						return true;
				}
				
			} while (store.IterNext (ref it));
			
			return false;
		}