protected override void OnLoad(EventArgs e) { base.OnLoad(e); IAnkhSolutionSettings settings = Context.GetService <IAnkhSolutionSettings>(); ISvnStatusCache cache = Context.GetService <ISvnStatusCache>(); SvnItem slnDirItem = cache[settings.SolutionFilename].Parent; SvnWorkingCopy wc = slnDirItem.WorkingCopy; if (wc != null && slnDirItem.Uri != null) { SvnItem dirItem = slnDirItem; Uri cur = dirItem.Uri; Uri setUri = settings.ProjectRootUri; while (dirItem != null && dirItem.IsBelowPath(wc.FullPath)) { UriMap value = new UriMap(cur, dirItem.FullPath); slnBindPath.Items.Add(value); if (setUri == value.Uri) { slnBindPath.SelectedItem = value; } dirItem = dirItem.Parent; cur = new Uri(cur, "../"); } } }
/// <summary> /// Gets the "project root" /// </summary> /// <param name="e"></param> /// <returns></returns> private static SvnItem GetRoot(BaseCommandEventArgs e) { SvnItem item = null; switch (e.Command) { case AnkhCommand.SolutionIssueTrackerSetup: IAnkhSolutionSettings ss = e.GetService <IAnkhSolutionSettings>(); if (ss == null) { return(null); } string root = ss.ProjectRoot; if (string.IsNullOrEmpty(root)) { return(null); } item = e.GetService <ISvnStatusCache>()[root]; break; } return(item); }
void AddRoots(bool add) { if (add == _rootsPresent) { return; } if (!_rootsPresent) { IAnkhSolutionSettings slnSettings = Context.GetService <IAnkhSolutionSettings>(); if (!string.IsNullOrEmpty(slnSettings.SolutionFilename)) { SvnItem slnItem = FileStatusCache[slnSettings.SolutionFilename]; folderTree.AddRoot(new WCSolutionNode(Context, slnItem)); } folderTree.AddRoot(new WCMyComputerNode(Context)); _rootsPresent = true; } else { folderTree.ClearRoots(); _rootsPresent = false; } }
protected override void OnVisibleChanged(EventArgs e) { base.OnVisibleChanged(e); if (DesignMode) { return; } if (!_initialized && IsHandleCreated && Visible) { _initialized = true; if (SelectedUri != null) { BrowseText(); } if (Context != null) { IAnkhSolutionSettings settings = Context.GetService <IAnkhSolutionSettings>(); if (settings != null) { foreach (Uri uri in settings.GetRepositoryUris(true)) { if (!urlBox.Items.Contains(uri)) { urlBox.Items.Add(uri); } } } } } }
public void Prepare() { ThreadHelper.ThrowIfNotOnUIThread(); if (_prepared) { return; } if (Context == null) { return; } _prepared = true; IAnkhSolutionSettings settings = Context.GetService <IAnkhSolutionSettings>(); if (settings.SolutionFilename != null) { Text += " - " + Path.GetFileName(settings.SolutionFilename); } InitializeGrid(); }
public void OnExecute(CommandEventArgs e) { IAnkhSolutionSettings slnSettings = e.GetService <IAnkhSolutionSettings>(); List <ISvnLogItem> logItems = new List <ISvnLogItem>(e.Selection.GetSelection <ISvnLogItem>()); if (logItems.Count != 1) { return; } using (EditLogMessageDialog dialog = new EditLogMessageDialog()) { dialog.Context = e.Context; dialog.LogMessage = logItems[0].LogMessage; if (dialog.ShowDialog(e.Context) == DialogResult.OK) { if (dialog.LogMessage == logItems[0].LogMessage) { return; // No changes } IAnkhConfigurationService config = e.GetService <IAnkhConfigurationService>(); if (config != null) { if (dialog.LogMessage != null && dialog.LogMessage.Trim().Length > 0) { config.GetRecentLogMessages().Add(dialog.LogMessage); } } using (SvnClient client = e.GetService <ISvnClientPool>().GetClient()) { SvnSetRevisionPropertyArgs sa = new SvnSetRevisionPropertyArgs(); sa.AddExpectedError(SvnErrorCode.SVN_ERR_REPOS_DISABLED_FEATURE); client.SetRevisionProperty(logItems[0].RepositoryRoot, logItems[0].Revision, SvnPropertyNames.SvnLog, dialog.LogMessage, sa); if (sa.LastException != null && sa.LastException.SvnErrorCode == SvnErrorCode.SVN_ERR_REPOS_DISABLED_FEATURE) { AnkhMessageBox mb = new AnkhMessageBox(e.Context); mb.Show(sa.LastException.Message, "", MessageBoxButtons.OK, MessageBoxIcon.Information); return; } } ILogControl logWindow = e.Selection.GetActiveControl <ILogControl>(); if (logWindow != null) { // TODO: Somehow repair scroll position/number of items loaded logWindow.Restart(); } } } }
private void OnSvnItemChanged(SvnItem svnItem) { IAnkhSolutionSettings slnSettings = SolutionSettings; if (slnSettings != null && slnSettings.ProjectRoot == svnItem.FullPath) { MarkDirty(); } }
public override void OnExecute(CommandEventArgs e) { IPendingChangesManager pcm = e.GetService <IPendingChangesManager>(); PendingChange.RefreshContext rc = new PendingChange.RefreshContext(e.Context); Dictionary <string, PendingChange> selectedChanges = new Dictionary <string, PendingChange>(StringComparer.OrdinalIgnoreCase); List <SvnItem> resources = new List <SvnItem>(); foreach (SvnItem item in e.Selection.GetSelectedSvnItems(true)) { PendingChange pc; if (PendingChange.CreateIfPending(rc, item, out pc)) { if (!pc.IsNoChangeForPatching()) { selectedChanges.Add(pc.FullPath, pc); resources.Add(pc.SvnItem); } } } if (resources.Count == 0) { return; } using (PendingChangeSelector pcs = new PendingChangeSelector()) { pcs.Text = CommandStrings.CreatePatchTitle; pcs.PreserveWindowPlacement = true; pcs.LoadItems(resources); DialogResult dr = pcs.ShowDialog(e.Context); if (dr != DialogResult.OK) { return; } string fileName = GetFileName(e.Context.DialogOwner); if (string.IsNullOrEmpty(fileName)) { return; } PendingChangeCreatePatchArgs pca = new PendingChangeCreatePatchArgs(); pca.FileName = fileName; IAnkhSolutionSettings ss = e.GetService <IAnkhSolutionSettings>(); pca.RelativeToPath = ss.ProjectRoot; pca.AddUnversionedFiles = true; List <PendingChange> patchChanges = new List <PendingChange>(pcs.GetSelection()); e.GetService <IPendingChangeHandler>().CreatePatch(patchChanges, pca); } }
public override void OnUpdate(CommandUpdateEventArgs e) { if (!e.State.SolutionExists || e.State.SolutionBuilding || e.State.Debugging || e.State.SolutionOpening) { e.Enabled = false; return; } switch (e.Command) { case AnkhCommand.SolutionSwitchDialog: IAnkhSolutionSettings solutionSettings = e.GetService <IAnkhSolutionSettings>(); SvnItem solutionItem = solutionSettings.ProjectRootSvnItem; if (solutionItem == null || !solutionItem.IsVersioned || solutionItem.IsNewAddition) { e.Enabled = false; return; } break; case AnkhCommand.SwitchProject: SccProject oneProject = EnumTools.GetSingle(e.Selection.GetSelectedProjects(false)); if (oneProject == null) { e.Enabled = false; return; } IProjectFileMapper pfm = e.GetService <IProjectFileMapper>(); ISccProjectInfo pi = pfm.GetProjectInfo(oneProject); if (pi == null || pi.ProjectDirectory == null) { e.Enabled = false; return; } SvnItem projectItem = e.GetService <ISvnStatusCache>()[pi.ProjectDirectory]; if (projectItem == null || !projectItem.IsVersioned || projectItem.IsNewAddition) { e.Enabled = false; } break; case AnkhCommand.SwitchItem: SvnItem oneItem = EnumTools.GetSingle(e.Selection.GetSelectedSvnItems(false)); if (oneItem == null || !oneItem.IsVersioned || oneItem.IsNewAddition) { e.Enabled = false; } break; } }
private static void AutoOpenCommand(CommandEventArgs e, SvnOrigin origin) { IAnkhCommandService svc = e.GetService <IAnkhCommandService>(); IAnkhSolutionSettings solutionSettings = e.GetService <IAnkhSolutionSettings>(); if (svc == null || solutionSettings == null) { return; } // Ok, we can assume we have a file string filename = origin.Target.FileName; string ext = Path.GetExtension(filename); if (string.IsNullOrEmpty(ext)) { // No extension -> Open as text svc.PostExecCommand(AnkhCommand.ViewInVsText); return; } foreach (string projectExt in solutionSettings.AllProjectExtensionsFilter.Split(';')) { if (projectExt.TrimStart('*').Trim().Equals(ext, StringComparison.OrdinalIgnoreCase)) { // We found a project or solution, use Open from Subversion to create a checkout svc.PostExecCommand(AnkhCommand.FileFileOpenFromSubversion, origin); return; } } bool odd = false; foreach (string block in solutionSettings.OpenFileFilter.Split('|')) { odd = !odd; if (odd) { continue; } foreach (string itemExt in block.Split(';')) { if (itemExt.TrimStart('*').Trim().Equals(ext, StringComparison.OrdinalIgnoreCase)) { svc.PostExecCommand(AnkhCommand.ViewInVsNet); return; } } } // Ultimate fallback: Just ask the user what to do (don't trust the repository!) svc.PostExecCommand(AnkhCommand.ViewInWindowsWith); }
string GetSccBaseDirectory() { ThreadHelper.ThrowIfNotOnUIThread(); string projectDir = ProjectDirectory; if (projectDir == null) { return(null); } // TODO: Insert project local settings check IAnkhSolutionSettings settings = GetService <IAnkhSolutionSettings>(); ISvnStatusCache cache = GetService <ISvnStatusCache>(); SvnItem solutionRoot = settings.ProjectRootSvnItem; if (solutionRoot == null) { return(null); // Fix the solution before we try any SCC, thanks! } SvnItem projectDirItem = cache[projectDir]; if (projectDirItem != null && projectDirItem.WorkingCopy != null) { // Project is below standard workingcopy if (projectDirItem.IsBelowPath(solutionRoot)) { if (solutionRoot.WorkingCopy == projectDirItem.WorkingCopy) { // Project is in the same working copy.. use the solution root // to automatically handle in-between directory levels return(solutionRoot.FullPath); } // Project has its own workingcopy below the solution root // -> Use the complete workingcopy (might be shared with multiple projects) return(projectDirItem.WorkingCopy.FullPath); } if (solutionRoot.WorkingCopy != projectDirItem.WorkingCopy) { // Project is below a root of its own.. use its workingcopy return(projectDirItem.WorkingCopy.FullPath); } // The user deliberately choose not to have the item in the solution root // -> Default to the project directory } return(ProjectDirectory); }
string GetRelativePath(SvnItem item) { IAnkhSolutionSettings ss = Context.GetService <IAnkhSolutionSettings>(); string path = ss.ProjectRoot; if (!string.IsNullOrEmpty(path) && item.IsBelowPath(path)) { return(SvnItem.SubPath(item.FullPath, path)); } return(item.FullPath); }
public override void OnUpdate(CommandUpdateEventArgs e) { IAnkhSolutionSettings ss = e.GetService <IAnkhSolutionSettings>(); if (ss != null && !string.IsNullOrEmpty(ss.ProjectRoot) && ss.ProjectRootSvnItem.IsVersioned) { IAnkhConfigurationService cs = e.GetService <IAnkhConfigurationService>(); if (!string.IsNullOrEmpty(cs.Instance.PatchExePath)) { return; } } e.Enabled = false; }
private void okButton_Click(object sender, EventArgs e) { IAnkhSolutionSettings settings = Context.GetService <IAnkhSolutionSettings>(); UriMap map = slnBindPath.SelectedItem as UriMap; if (map == null) { return; } if (settings.ProjectRootUri != null && map.Uri != settings.ProjectRootUri) { string dir = SvnTools.GetNormalizedDirectoryName(settings.SolutionFilename); settings.ProjectRoot = SvnTools.GetNormalizedFullPath(Path.Combine(dir, map.Value)); } }
private void Initialize() { if (_initialized) { return; } if (Context != null) { IAnkhSolutionSettings ss = Context.GetService <IAnkhSolutionSettings>(); foreach (Uri u in ss.GetRepositoryUris(true)) { repositoryUrl.Items.Add(u); } _initialized = true; } }
public override void OnExecute(CommandEventArgs e) { IAnkhPackage package = e.Context.GetService <IAnkhPackage>(); AnkhToolWindow toolWindow; switch (e.Command) { case AnkhCommand.ShowPendingChanges: toolWindow = AnkhToolWindow.PendingChanges; break; case AnkhCommand.ShowWorkingCopyExplorer: toolWindow = AnkhToolWindow.WorkingCopyExplorer; break; case AnkhCommand.ShowRepositoryExplorer: toolWindow = AnkhToolWindow.RepositoryExplorer; break; case AnkhCommand.ShowSubversionInfo: toolWindow = AnkhToolWindow.SvnInfo; break; default: return; } package.ShowToolWindow(toolWindow); if (e.Command == AnkhCommand.ShowRepositoryExplorer) { IAnkhSolutionSettings ss = e.GetService <IAnkhSolutionSettings>(); if (ss.ProjectRootUri != null) { RepositoryExplorerControl ctrl = e.Selection.ActiveDialogOrFrameControl as RepositoryExplorerControl; if (ctrl != null) { ctrl.AddRoot(ss.ProjectRootUri); } } } }
private static SvnItem GetRoot(BaseCommandEventArgs e) { SvnItem item = null; switch (e.Command) { case AnkhCommand.SolutionBranch: IAnkhSolutionSettings ss = e.GetService <IAnkhSolutionSettings>(); if (ss == null) { return(null); } string root = ss.ProjectRoot; if (string.IsNullOrEmpty(root)) { return(null); } item = e.GetService <ISvnStatusCache>()[root]; break; case AnkhCommand.ProjectBranch: SccProject p = EnumTools.GetSingle(e.Selection.GetSelectedProjects(false)); if (p == null) { break; } ISccProjectInfo info = e.GetService <IProjectFileMapper>().GetProjectInfo(p); if (info == null || info.ProjectDirectory == null) { break; } item = e.GetService <ISvnStatusCache>()[info.ProjectDirectory]; break; } return(item); }
public override void OnUpdate(CommandUpdateEventArgs e) { base.OnUpdate(e); if (e.Enabled && e.Command == AnkhCommand.ViewInVsNet) { ISvnRepositoryItem single = EnumTools.GetSingle(e.Selection.GetSelection <ISvnRepositoryItem>()); IAnkhSolutionSettings settings = e.GetService <IAnkhSolutionSettings>(); SvnOrigin origin = single.Origin; // Checked in parent string ext = Path.GetExtension(origin.Target.FileName); if (!string.IsNullOrEmpty(ext) && settings.OpenFileFilter.IndexOf("*" + ext, StringComparison.OrdinalIgnoreCase) < 0) { e.Enabled = false; } } }
protected override void ValidateAdd(object sender, CancelEventArgs e) { base.ValidateAdd(sender, e); if (e.Cancel) { return; } Debug.Assert(RepositoryAddUrl != null); IAnkhSolutionSettings ss = Context.GetService <IAnkhSolutionSettings>(); // Error if the RepositoryAddUrl is below the url of the projectroot if (ss.ProjectRootUri.IsBaseOf(RepositoryAddUrl)) { e.Cancel = true; errorProvider1.SetError(repositoryTree, "Please select a location that is not below the solution binding path, or move the project to a directory below the solution binding path on disk"); return; } }
public void DoCreatePatch(string fileName) { if (string.IsNullOrEmpty(fileName)) { return; } PendingChangeCreatePatchArgs a = new PendingChangeCreatePatchArgs(); a.FileName = fileName; IAnkhSolutionSettings ss = Context.GetService <IAnkhSolutionSettings>(); a.RelativeToPath = ss.ProjectRoot; a.AddUnversionedFiles = true; List <PendingChange> changes = new List <PendingChange>(UI.CheckedItems); if (Context.GetService <IPendingChangeHandler>().CreatePatch(changes, a)) { } }
public override void OnExecute(CommandEventArgs e) { ISvnRepositoryItem selected = EnumTools.GetSingle(e.Selection.GetSelection <ISvnRepositoryItem>()); if (selected == null) { return; } Uri uri = selected.Uri; string name = selected.Origin.Target.FileName; IAnkhSolutionSettings ss = e.GetService <IAnkhSolutionSettings>(); using (CheckoutDialog dlg = new CheckoutDialog()) { dlg.Context = e.Context; dlg.Uri = uri; dlg.RepositoryRoot = selected.Origin.RepositoryRoot; dlg.LocalPath = System.IO.Path.Combine(ss.NewProjectLocation, name); if (dlg.ShowDialog(e.Context) != DialogResult.OK) { return; } e.GetService <IProgressRunner>().RunModal(CommandStrings.CheckingOut, delegate(object sender, ProgressWorkerArgs a) { SvnCheckOutArgs args = new SvnCheckOutArgs(); args.Revision = dlg.Revision; args.Depth = dlg.Recursive ? SvnDepth.Infinity : SvnDepth.Files; args.IgnoreExternals = dlg.IgnoreExternals; a.Client.CheckOut(dlg.Uri, dlg.LocalPath, args); }); } }
public void OnExecute(CommandEventArgs e) { SvnItem firstVersioned = null; ISvnStatusCache cache = e.GetService <ISvnStatusCache>(); IAnkhSolutionSettings solutionSettings = e.GetService <IAnkhSolutionSettings>(); if (solutionSettings != null) { firstVersioned = cache[solutionSettings.ProjectRoot]; } if (firstVersioned == null) { return; // exceptional case } using (IssueTrackerConfigDialog dialog = new IssueTrackerConfigDialog(e.Context)) { if (dialog.ShowDialog(e.Context) == System.Windows.Forms.DialogResult.OK) { IIssueTrackerSettings currentSettings = e.GetService <IIssueTrackerSettings>(); IssueRepository newRepository = dialog.NewIssueRepository; if (newRepository == null || string.IsNullOrEmpty(newRepository.ConnectorName) || newRepository.RepositoryUri == null) { DeleteIssueRepositoryProperties(e.Context, firstVersioned); } else if (currentSettings == null || currentSettings.ShouldPersist(newRepository)) { SetIssueRepositoryProperties(e.Context, firstVersioned, newRepository); } } } }
public override void OnExecute(CommandEventArgs e) { IAnkhSolutionSettings ss = e.GetService <IAnkhSolutionSettings>(); IAnkhDiffHandler diff = e.GetService <IAnkhDiffHandler>(); AnkhPatchArgs args = new AnkhPatchArgs(); args.ApplyTo = ss.ProjectRoot; using (OpenFileDialog ofd = new OpenFileDialog()) { ofd.Filter = "Patch files( *.patch)|*.patch|Diff files (*.diff)|*.diff|" + "Text files (*.txt)|*.txt|All files (*.*)|*"; if (ofd.ShowDialog(e.Context.DialogOwner) != DialogResult.OK) { return; } args.PatchFile = ofd.FileName; } diff.RunPatch(args); }
public override void OnExecute(CommandEventArgs e) { List <string> toAdd = new List <string>(); List <SvnItem> items = new List <SvnItem>(); foreach (SvnItem item in e.Selection.GetSelectedSvnItems(true)) { if (item.IsVersioned) { items.Add(item); } else if (item.IsFile && item.IsVersionable && item.InSolution && !item.IsIgnored && !item.IsSccExcluded) { toAdd.Add(item.FullPath); // Add new files ### Alternative: Show them as added items.Add(item); } } if (items.Count == 0) { return; } SvnRevision start = SvnRevision.Base; SvnRevision end = SvnRevision.Working; // should we show the path selector? if (e.ShouldPrompt(true)) { using (CommonFileSelectorDialog dlg = new CommonFileSelectorDialog()) { dlg.Text = CommandStrings.UnifiedDiffTitle; dlg.Items = items; dlg.RevisionStart = start; dlg.RevisionEnd = end; if (dlg.ShowDialog(e.Context) != DialogResult.OK) { return; } items.Clear(); items.AddRange(dlg.GetCheckedItems()); start = dlg.RevisionStart; end = dlg.RevisionEnd; } } if (items.Count == 0) { return; } SvnRevisionRange revRange = new SvnRevisionRange(start, end); IAnkhTempFileManager tempfiles = e.GetService <IAnkhTempFileManager>(); string tempFile = tempfiles.GetTempFile(".patch"); IAnkhSolutionSettings ss = e.GetService <IAnkhSolutionSettings>(); string slndir = ss.ProjectRoot; using (MemoryStream stream = new MemoryStream()) { e.Context.GetService <IProgressRunner>().RunModal(CommandStrings.RunningDiff, delegate(object sender, ProgressWorkerArgs ee) { SvnAddArgs aa = new SvnAddArgs(); aa.ThrowOnError = false; aa.AddParents = false; foreach (string item in toAdd) { ee.Client.Add(item, aa); } SvnDiffArgs diffArgs = new SvnDiffArgs(); diffArgs.IgnoreAncestry = true; diffArgs.NoDeleted = false; diffArgs.ThrowOnError = false; foreach (SvnItem item in items) { SvnWorkingCopy wc; if (!string.IsNullOrEmpty(slndir) && item.IsBelowPath(slndir)) { diffArgs.RelativeToPath = slndir; } else if ((wc = item.WorkingCopy) != null) { diffArgs.RelativeToPath = wc.FullPath; } else { diffArgs.RelativeToPath = null; } if (!ee.Client.Diff(item.FullPath, revRange, diffArgs, stream)) { if (diffArgs.LastException != null) { StreamWriter sw = new StreamWriter(stream); sw.WriteLine(); sw.WriteLine(string.Format("# {0}: {1}", item.FullPath, diffArgs.LastException.Message)); sw.Flush(); // Don't dispose the writer as that might close the stream } if (diffArgs.IsLastInvocationCanceled) { break; } } } stream.Flush(); }); stream.Position = 0; using (StreamReader sr = new StreamReader(stream)) { File.WriteAllText(tempFile, sr.ReadToEnd(), Encoding.UTF8); VsShellUtilities.OpenDocument(e.Context, tempFile); } } }
public int OnAfterOpenSolution(object pUnkReserved, int fNewSolution) { ThreadHelper.ThrowIfNotOnUIThread(); _solutionLoaded = true; SccEvents.OnSolutionOpened(true); GetService <IAnkhServiceEvents>().OnSolutionOpened(EventArgs.Empty); if (!SccProvider.IsActive) { return(VSErr.S_OK); } try { VerifySolutionNaming(); IAnkhSolutionSettings ss = GetService <IAnkhSolutionSettings>(); if (ss != null && ss.ProjectRoot != null) { string rootDir = Path.GetPathRoot(ss.ProjectRoot); if (rootDir.Length == 3 && rootDir.EndsWith(":\\", StringComparison.OrdinalIgnoreCase)) { DriveInfo di = new DriveInfo(rootDir); bool oldFs = false; switch ((di.DriveFormat ?? "").ToUpperInvariant()) { case "FAT32": case "FAT": oldFs = true; break; } if (oldFs) { IAnkhConfigurationService cs = GetService <IAnkhConfigurationService>(); if (!cs.GetWarningBool(AnkhWarningBool.FatFsFound)) { using (SccFilesystemWarningDialog dlg = new SccFilesystemWarningDialog()) { dlg.Text = Path.GetFileName(ss.SolutionFilename); if (DialogResult.OK == dlg.ShowDialog(Context)) { cs.SetWarningBool(AnkhWarningBool.FatFsFound, true); } } } } } } } catch (Exception ex) { IAnkhErrorHandler handler = GetService <IAnkhErrorHandler>(); if (handler.IsEnabled(ex)) { handler.OnError(ex); } else { throw; } } return(VSErr.S_OK); }
/// <see cref="Ankh.Commands.ICommandHandler.OnUpdate" /> public void OnUpdate(CommandUpdateEventArgs e) { ISvnStatusCache statusCache; int n = 0; switch (e.Command) { case AnkhCommand.ItemMerge: foreach (SvnItem item in e.Selection.GetSelectedSvnItems(false)) { if (!item.IsVersioned) { e.Enabled = false; return; } n++; if (n > 1) { break; } } break; case AnkhCommand.ProjectMerge: statusCache = e.GetService <ISvnStatusCache>(); IProjectFileMapper pfm = e.GetService <IProjectFileMapper>(); foreach (SccProject project in e.Selection.GetSelectedProjects(false)) { ISccProjectInfo projInfo = pfm.GetProjectInfo(project); if (projInfo == null || string.IsNullOrEmpty(projInfo.ProjectDirectory)) { e.Enabled = false; return; } SvnItem projectDir = statusCache[projInfo.ProjectDirectory]; if (!projectDir.IsVersioned) { e.Enabled = false; return; } n++; if (n > 1) { break; } } break; case AnkhCommand.SolutionMerge: statusCache = e.GetService <ISvnStatusCache>(); IAnkhSolutionSettings solutionSettings = e.GetService <IAnkhSolutionSettings>(); if (solutionSettings == null || string.IsNullOrEmpty(solutionSettings.ProjectRoot)) { e.Enabled = false; return; } SvnItem solutionItem = statusCache[solutionSettings.ProjectRoot]; if (solutionItem.IsVersioned) { n = 1; } break; default: throw new InvalidOperationException(); } if (n != 1) { e.Enabled = false; } }
public override void OnExecute(CommandEventArgs e) { ThreadHelper.ThrowIfNotOnUIThread(); Uri selectedUri = null; Uri rootUri = null; bool addingProject = (e.Command == AnkhCommand.FileFileAddFromSubversion || e.Command == AnkhCommand.FileSccAddFromSubversion); if (e.Argument is string && Uri.TryCreate((string)e.Argument, UriKind.Absolute, out selectedUri)) { } else if (e.Argument is SvnOrigin) { SvnOrigin origin = (SvnOrigin)e.Argument; selectedUri = origin.Uri; rootUri = origin.RepositoryRoot; } else if (e.Argument is Uri) { selectedUri = (Uri)e.Argument; } IAnkhSolutionSettings settings = e.GetService <IAnkhSolutionSettings>(); if (e.PromptUser || selectedUri == null) { using (RepositoryOpenDialog dlg = new RepositoryOpenDialog()) { if (addingProject) { dlg.Text = CommandStrings.AddProjectFromSubversion; } dlg.Filter = settings.OpenProjectFilterName + "|" + settings.AllProjectExtensionsFilter + "|All Files (*.*)|*"; if (selectedUri != null) { dlg.SelectedUri = selectedUri; } if (dlg.ShowDialog(e.Context) != DialogResult.OK) { return; } selectedUri = dlg.SelectedUri; rootUri = dlg.SelectedRepositoryRoot; } } else if (rootUri == null) { if (!e.GetService <IProgressRunner>().RunModal(CommandStrings.RetrievingRepositoryRoot, delegate(object sender, ProgressWorkerArgs a) { rootUri = a.Client.GetRepositoryRoot(selectedUri); }).Succeeded) { return; } } string defaultPath = settings.NewProjectLocation; if (addingProject) { IAnkhSolutionSettings ss = e.GetService <IAnkhSolutionSettings>(); if (!string.IsNullOrEmpty(ss.ProjectRoot)) { defaultPath = ss.ProjectRoot; } } string name = Path.GetFileNameWithoutExtension(SvnTools.GetFileName(selectedUri)); string newPath; int n = 0; do { newPath = Path.Combine(defaultPath, name); if (n > 0) { newPath += string.Format("({0})", n); } n++; }while (File.Exists(newPath) || Directory.Exists(newPath)); using (CheckoutProject dlg = new CheckoutProject()) { dlg.Context = e.Context; if (addingProject) { dlg.Text = CommandStrings.AddProjectFromSubversion; } dlg.ProjectUri = selectedUri; dlg.RepositoryRootUri = rootUri; dlg.SelectedPath = newPath; dlg.SvnOrigin = new SvnOrigin(selectedUri, rootUri); dlg.HandleCreated += delegate { FindRoot(e.Context, selectedUri, dlg); }; if (dlg.ShowDialog(e.Context) != DialogResult.OK) { return; } if (!addingProject) { OpenSolution(e, dlg); } else { CheckOutAndOpenProject(e, dlg.ProjectTop, dlg.Revision, dlg.ProjectTop, dlg.SelectedPath, dlg.ProjectUri); } } }
private static void AddProject(CommandEventArgs e, string projectFile) { IAnkhSolutionSettings ss = e.GetService <IAnkhSolutionSettings>(); ss.AddProjectFile(projectFile); }
private static void CheckOutAndOpenProject(CommandEventArgs e, SvnUriTarget checkoutLocation, SvnRevision revision, Uri projectTop, string localDir, Uri projectUri) { IProgressRunner runner = e.GetService <IProgressRunner>(); runner.RunModal(CommandStrings.CheckingOutSolution, delegate(object sender, ProgressWorkerArgs ee) { PerformCheckout(ee, checkoutLocation, revision, localDir); }); Uri file = projectTop.MakeRelativeUri(projectUri); string projectFile = SvnTools.GetNormalizedFullPath(Path.Combine(localDir, SvnTools.UriPartToPath(file.ToString()))); AddProject(e, projectFile); using (ProjectAddInfoDialog pai = new ProjectAddInfoDialog()) { IAnkhSolutionSettings ss = e.GetService <IAnkhSolutionSettings>(); ISvnStatusCache cache = e.GetService <ISvnStatusCache>(); SvnItem rootItem; pai.EnableSlnConnection = false; if (ss == null || cache == null || string.IsNullOrEmpty(ss.ProjectRoot) || !SvnItem.IsBelowRoot(localDir, ss.ProjectRoot) || null == (rootItem = cache[localDir])) { pai.EnableExternal = false; pai.EnableCopy = false; } else { SvnItem dir = rootItem.Parent; if (ss.ProjectRootSvnItem != null && ss.ProjectRootSvnItem.IsVersioned) { HybridCollection <string> dirs = new HybridCollection <string>(); SvnItem exDir = dir; while (exDir != null && exDir.IsBelowPath(ss.ProjectRoot)) { if (exDir.IsVersioned && exDir.WorkingCopy == ss.ProjectRootSvnItem.WorkingCopy) { dirs.Add(exDir.FullPath); } exDir = exDir.Parent; } pai.SetExternalDirs(dirs); pai.EnableExternal = true; } else { pai.EnableExternal = false; } if (rootItem.WorkingCopy != null && dir.WorkingCopy != null) { pai.EnableCopy = (rootItem.WorkingCopy.RepositoryRoot == dir.WorkingCopy.RepositoryRoot) && (rootItem.WorkingCopy.RepositoryId == dir.WorkingCopy.RepositoryId); } else { pai.EnableCopy = false; } } if (pai.ShowDialog(e.Context) == DialogResult.OK) { switch (pai.SelectedMode) { case ProjectAddMode.External: if (pai.ExternalLocation != null) { using (SvnClient cl = e.GetService <ISvnClientPool>().GetNoUIClient()) { string externals; if (!cl.TryGetProperty(pai.ExternalLocation, SvnPropertyNames.SvnExternals, out externals)) { externals = ""; } SvnExternalItem sei; if (pai.ExternalLocked) { sei = new SvnExternalItem(SvnItem.SubPath(localDir, pai.ExternalLocation), checkoutLocation.Uri, revision, revision); } else { sei = new SvnExternalItem(SvnItem.SubPath(localDir, pai.ExternalLocation), checkoutLocation.Uri); } externals = sei.ToString(true) + Environment.NewLine + externals; cl.SetProperty(pai.ExternalLocation, SvnPropertyNames.SvnExternals, externals); } } break; case ProjectAddMode.Copy: using (SvnClient cl = e.GetService <ISvnClientPool>().GetClient()) { string tmpDir = localDir + "-Src-copyTmp"; Directory.CreateDirectory(tmpDir); Directory.Move(Path.Combine(localDir, SvnClient.AdministrativeDirectoryName), Path.Combine(tmpDir, SvnClient.AdministrativeDirectoryName)); SvnCopyArgs ma = new SvnCopyArgs(); ma.MetaDataOnly = true; cl.Copy(tmpDir, localDir, ma); SvnItem.DeleteDirectory(tmpDir, true); cache.MarkDirtyRecursive(localDir); } break; case ProjectAddMode.Unversioned: cache.MarkDirtyRecursive(localDir); SvnItem.DeleteDirectory(Path.Combine(localDir, SvnClient.AdministrativeDirectoryName), true); e.GetService <IFileStatusMonitor>().ScheduleGlyphUpdate(projectFile); // And everything else in the project break; } } } }
private void ShowErrorDialog(Exception ex, bool showStackTrace, bool internalError, ExceptionInfo info) { string stackTrace = ex.ToString(); string message = GetNestedMessages(ex); System.Collections.Specialized.StringDictionary additionalInfo = new System.Collections.Specialized.StringDictionary(); IAnkhSolutionSettings ss = GetService <IAnkhSolutionSettings>(); if (ss != null) { additionalInfo.Add("VS-Version", VSVersion.FullVersion.ToString()); } if (info != null && info.CommandArgs != null) { additionalInfo.Add("Command", info.CommandArgs.Command.ToString()); } IAnkhPackage pkg = GetService <IAnkhPackage>(); if (pkg != null) { additionalInfo.Add("Ankh-Version", pkg.UIVersion.ToString()); } additionalInfo.Add("SharpSvn-Version", SharpSvn.SvnClient.SharpSvnVersion.ToString()); additionalInfo.Add("Svn-Version", SharpSvn.SvnClient.Version.ToString()); additionalInfo.Add("OS-Version", Environment.OSVersion.Version.ToString()); using (ErrorDialog dlg = new ErrorDialog()) { dlg.ErrorMessage = message; dlg.ShowStackTrace = showStackTrace; dlg.StackTrace = stackTrace; dlg.InternalError = internalError; if (dlg.ShowDialog(Context) == DialogResult.Retry) { string subject = _errorReportSubject; if (info != null && info.CommandArgs != null) { subject = string.Format("Error handling {0}", info.CommandArgs.Command); } SvnException sx = ex as SvnException; SvnException ix; while (sx != null && sx.SvnErrorCode == SvnErrorCode.SVN_ERR_BASE && (null != (ix = sx.InnerException as SvnException))) { sx = ix; } if (sx != null) { SvnException rc = sx.RootCause as SvnException; if (rc == null || rc.SvnErrorCode == sx.SvnErrorCode) { subject += " (" + ErrorToString(sx) + ")"; } else { subject += " (" + ErrorToString(sx) + "-" + ErrorToString(rc) + ")"; } } AnkhErrorMessage.SendByMail(_errorReportMailAddress, subject, ex, typeof(AnkhErrorHandler).Assembly, additionalInfo); } } }