private static bool RevertInternal (VersionControlItemList items, bool test)
		{
			try {
				if (test) {
					foreach (VersionControlItem item in items)
						if (!item.Repository.CanRevert (item.Path))
							return false;
					return true;
				}

				if (MessageService.AskQuestion (GettextCatalog.GetString ("Are you sure you want to revert the changes done in the selected files?"), 
				                                GettextCatalog.GetString ("All changes made to the selected files will be permanently lost."),
				                                AlertButton.Cancel, AlertButton.Revert) != AlertButton.Revert)
					return false;

				new RevertWorker (items).Start();
				return true;
			}
			catch (Exception ex) {
				if (test)
					LoggingService.LogError (ex.ToString ());
				else
					MessageService.ShowException (ex, GettextCatalog.GetString ("Version control command failed."));
				return false;
			}
		}

		public static void Show (VersionControlItemList items)
		{
			foreach (VersionControlItem item in items) {
				var document = IdeApp.Workbench.OpenDocument (item.Path);
				DiffView.AttachViewContents (document, item);
				document.Window.SwitchView (document.Window.FindView (typeof(BlameView)));
			}
		}

		protected VersionControlItemList GetItems ()
		{
			VersionControlItemList list = new VersionControlItemList ();
			VersionControlItem it = GetItem ();
			if (it != null)
				list.Add (it);
			return list;
		}

		public static void Show (VersionControlItemList items)
		{
			foreach (VersionControlItem item in items) {
				var document = IdeApp.Workbench.OpenDocument (item.Path, OpenDocumentOptions.Default | OpenDocumentOptions.OnlyInternalViewer);
				DiffView.AttachViewContents (document, item);
				document.Window.SwitchView (document.Window.FindView (typeof (MergeView)));
			}
		}

		public static bool Show (VersionControlItemList items, bool test)
		{
			if (!test) {
				Show (items);
				return true;
			}
			else
				return items.Count > 0 && CanShow (items[0].Repository, items[0].Path);
		}

		public static bool Revert (VersionControlItemList items, bool test)
		{
			if (RevertInternal (items, test)) {
				foreach (var itemPath in items.Paths)
					VersionControlService.SetCommitComment (itemPath, string.Empty, true);
				return true;
			}
			return false;
		}

		public static bool Show (VersionControlItemList items, bool test)
		{
			if (!test) {
				Show (items);
				return true;
			}
			else
				return items.All (i => i.VersionInfo.CanAnnotate);
		}

		public static bool CanShow (VersionControlItemList items, Revision since)
		{
			bool found = false;
			foreach (VersionControlItem item in items) {
				if (item.Repository.IsHistoryAvailable (item.Path)) {
					return true;
				}
			}
			return found;
		}

		public static bool Add (VersionControlItemList items, bool test)
		{
			if (!items.All (i => i.VersionInfo.CanAdd))
				return false;
			if (test)
				return true;
			
			new AddWorker (items).Start();
			return true;
		}

		public static bool Unlock (VersionControlItemList items, bool test)
		{
			foreach (VersionControlItem it in items)
				if (!it.Repository.CanUnlock (it.Path))
					return false;
			if (test)
				return true;
			
			new UnlockWorker (items).Start();
			return true;
		}

		public static void Show (VersionControlItemList items, Revision since)
		{
			foreach (VersionControlItem item in items) {
				if (!item.IsDirectory) {
					var document = IdeApp.Workbench.OpenDocument (item.Path);
					DiffView.AttachViewContents (document, item);
					document.Window.SwitchView (document.Window.FindView (typeof(LogView)));
				} else if (item.Repository.IsHistoryAvailable (item.Path)) {
					new Worker (item.Repository, item.Path, item.IsDirectory, since).Start ();
				}
			}
		}

		public static void Show (VersionControlItemList items, Revision since)
		{
			foreach (VersionControlItem item in items) {
				if (!item.IsDirectory) {
					var document = IdeApp.Workbench.OpenDocument (item.Path, OpenDocumentOptions.Default | OpenDocumentOptions.OnlyInternalViewer);
					DiffView.AttachViewContents (document, item);
					document.Window.SwitchView (document.Window.FindView (typeof(LogView)));
				} else if (item.VersionInfo.CanLog) {
					new Worker (item.Repository, item.Path, item.IsDirectory, since).Start ();
				}
			}
		}

		public static bool Commit (VersionControlItemList items, bool test)
		{
			int filesToCommit = 0;
			VersionControlItemList[] itemListsByRepo = items.SplitByRepository ();

			foreach (VersionControlItemList itemList in itemListsByRepo) {
				// Generate base folder path.
				FilePath basePath = itemList.FindMostSpecificParent ();
				Repository repo = itemList.First ().Repository;

				ChangeSet cset = repo.CreateChangeSet (basePath);
				cset.GlobalComment = VersionControlService.GetCommitComment (cset.BaseLocalPath);

				foreach (var item in itemList) {
					if (!item.VersionInfo.CanCommit)
						continue;

					if (item.Path.IsDirectory) {
						// We don't run checks for directories, we throw dialog if there are no changes.
						if (test)
							return true;

						foreach (VersionInfo vi in repo.GetDirectoryVersionInfo (item.Path, false, true))
							if (vi.HasLocalChanges) {
								filesToCommit++;
								cset.AddFile (vi);
							}
					} else {
						VersionInfo vi = repo.GetVersionInfo (item.Path);
						if (vi.HasLocalChanges) {
							if (test)
								return true;

							filesToCommit++;
							cset.AddFile (vi);
						}
					}
				}

				// In case of no local changes.
				if (test)
					return false;

				if (!cset.IsEmpty) {
					Commit (repo, cset, false);
				} else {
					MessageService.ShowMessage (GettextCatalog.GetString ("There are no changes to be committed."));
					continue;
				}
			}
			return filesToCommit != 0;
		}

		public static bool Show (VersionControlItemList items, bool test)
		{
			if (test)
				return items.All (CanShow);
			
			foreach (var item in items) {
				var document = IdeApp.Workbench.OpenDocument (item.Path, item.ContainerProject, OpenDocumentOptions.Default | OpenDocumentOptions.OnlyInternalViewer);
				if (document != null)
					document.Window.SwitchView (document.Window.FindView<IMergeView> ());
			}
			
			return true;
		}

		public static bool Show (VersionControlItemList items, Revision since, bool test)
		{
			bool found = false;
			foreach (VersionControlItem item in items) {
				if (item.Repository.IsHistoryAvailable (item.Path)) {
					if (test)
						return true;
					found = true;
					new Worker (item.Repository, item.Path, item.IsDirectory, since).Start ();
				}
			}
			return found;
		}

		public static bool Show (VersionControlItemList items, bool test)
		{
			if (items.Count != 1)
				return false;

			VersionControlItem item = items [0];
			if (item.VersionInfo.IsVersioned) {
				if (test) return true;
				StatusView d = new StatusView (item.Path, item.Repository);
				IdeApp.Workbench.OpenDocument (d, true);
				return true;
			}
			return false;
		}

		public static async Task<bool> ResolveConflicts (VersionControlItemList list, bool test)
		{
			if (test)
				return list.All (s => (s.VersionInfo.Status & VersionStatus.Conflicted) == VersionStatus.Conflicted);

			foreach (var item in list.Where (s => (s.VersionInfo.Status & VersionStatus.Conflicted) == VersionStatus.Conflicted)) {
				Document doc = await IdeApp.Workbench.OpenDocument (item.Path, item.ContainerProject, true);
				foreach (var view in doc.Views) {
					if (view.GetContent <MergeView> () != null)
						view.Select ();
				}
			}
			return true;
		}

		/// <summary>
		/// Creates a patch from a VersionControlItemList
		/// </summary>
		/// <param name="items">
		/// A <see cref="VersionControlItemList"/> from which to create a patch.
		/// </param>
		/// <param name="test">
		/// A <see cref="System.Boolean"/>: Whether this is a test run.
		/// </param>
		/// <returns>
		/// A <see cref="System.Boolean"/>: Whether the patch creation succeeded.
		/// </returns>
		public static bool CreatePatch (VersionControlItemList items, bool test)
		{
			bool can = CanCreatePatch (items);
			if (test || !can){ return can; }
			
			FilePath basePath = items.FindMostSpecificParent (FilePath.Null);
			if (FilePath.Empty == basePath)
				return false;
			
			ChangeSet cset = new ChangeSet (items[0].Repository, basePath);
			foreach (VersionControlItem item in items) {
				cset.AddFile (item.Path);
			}
			return CreatePatch (cset, test);
		}

		/// <summary>
		/// Creates a patch from a VersionControlItemList
		/// </summary>
		/// <param name="items">
		/// A <see cref="VersionControlItemList"/> from which to create a patch.
		/// </param>
		/// <param name="test">
		/// A <see cref="System.Boolean"/>: Whether this is a test run.
		/// </param>
		/// <returns>
		/// A <see cref="System.Boolean"/>: Whether the patch creation succeeded.
		/// </returns>
		public static bool CreatePatch (VersionControlItemList items, bool test)
		{
			if (items.Count < 1)
				return false;
				
			FilePath basePath = FindMostSpecificParent (items, FilePath.Null);
			if (FilePath.Empty == basePath)
				return false;
			
			ChangeSet cset = new ChangeSet (items[0].Repository, basePath);
			foreach (VersionControlItem item in items) {
				cset.AddFile (item.Path);
			}
			return CreatePatch (cset, test);
		}

		public VersionControlItemList GetItems ()
		{
			// Cached items are used only in the status view, not in the project pad.
			if (items != null)
				return items;

			// Don't cache node items because they can change
			VersionControlItemList nodeItems = new VersionControlItemList ();
			foreach (ITreeNavigator node in CurrentNodes) {
				VersionControlItem item = CreateItem (node.DataItem);
				if (item != null)
					nodeItems.Add (item);
			}
			return nodeItems;
		}