protected static bool SaveFile(CommandEventArgs e, ISvnRepositoryItem ri, string toFile)
{
ProgressRunnerResult r = e.GetService <IProgressRunner>().RunModal(CommandStrings.RetrievingFileForComparison,
delegate(object sender, ProgressWorkerArgs ee)
{
using (FileStream fs = File.Create(toFile))
{
SvnWriteArgs args = new SvnWriteArgs();
if (ri.Revision != null)
{
args.Revision = ri.Revision;
}
ee.Client.Write(ri.Origin.Target, fs, args);
}
});
return(r.Succeeded);
}
public string GetTempFile(SharpSvn.SvnTarget target, SharpSvn.SvnRevision revision, bool withProgress)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
else if (revision == null)
{
throw new ArgumentNullException("revision");
}
string file = GetTempPath(target.FileName, revision);
bool unrelated = false;
ProgressRunnerResult r = GetService <IProgressRunner>().RunModal(ServiceStrings.RetrievingFileForComparison,
delegate(object sender, ProgressWorkerArgs aa)
{
SvnWriteArgs wa = new SvnWriteArgs();
wa.Revision = revision;
wa.AddExpectedError(SvnErrorCode.SVN_ERR_CLIENT_UNRELATED_RESOURCES);
using (Stream s = File.Create(file))
if (!aa.Client.Write(target, s, wa))
{
if (wa.LastException.SvnErrorCode == SvnErrorCode.SVN_ERR_CLIENT_UNRELATED_RESOURCES)
{
unrelated = true;
}
}
});
if (!r.Succeeded || unrelated)
{
return(null); // User canceled
}
if (File.Exists(file))
{
File.SetAttributes(file, FileAttributes.ReadOnly); // A readonly file does not allow editting from many diff tools
}
return(file);
}
public override void OnExecute(CommandEventArgs e)
{
ISvnRepositoryItem selected = EnumTools.GetSingle(e.Selection.GetSelection <ISvnRepositoryItem>());
string directoryName = "";
using (CreateDirectoryDialog dlg = new CreateDirectoryDialog())
{
DialogResult result = dlg.ShowDialog(e.Context);
directoryName = dlg.NewDirectoryName;
if (result != DialogResult.OK || string.IsNullOrEmpty(directoryName))
{
return;
}
string log = dlg.LogMessage;
// Handle special characters like on local path
Uri uri = SvnTools.AppendPathSuffix(selected.Uri, directoryName);
ProgressRunnerResult prResult =
e.GetService <IProgressRunner>().RunModal(
CommandStrings.CreatingDirectories,
delegate(object sender, ProgressWorkerArgs ee)
{
SvnCreateDirectoryArgs args = new SvnCreateDirectoryArgs();
args.ThrowOnError = false;
args.CreateParents = true;
args.LogMessage = log;
ee.Client.RemoteCreateDirectory(uri, args);
}
);
if (prResult.Succeeded)
{
selected.RefreshItem(false);
}
}
}
public string GetTempFile(SvnItem target, SharpSvn.SvnRevision revision, bool withProgress)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
else if (revision == null)
{
throw new ArgumentNullException("revision");
}
string file = GetTempPath(target.Name, revision);
if (target.NodeKind != SvnNodeKind.File)
{
throw new InvalidOperationException("Can't create a tempfile from a directory");
}
ProgressRunnerResult r = GetService <IProgressRunner>().RunModal(ServiceStrings.RetrievingFileForComparison,
delegate(object sender, ProgressWorkerArgs aa)
{
SvnWriteArgs wa = new SvnWriteArgs();
wa.Revision = revision;
using (Stream s = File.Create(file))
aa.Client.Write(target.FullPath, s, wa);
});
if (!r.Succeeded)
{
return(null); // User canceled
}
if (File.Exists(file))
{
File.SetAttributes(file, FileAttributes.ReadOnly); // A readonly file does not allow editting from many diff tools
}
return(file);
}
public string[] GetTempFiles(SvnTarget target, SvnRevision from, SvnRevision to, bool withProgress)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
else if (from == null)
{
throw new ArgumentNullException("from");
}
else if (to == null)
{
throw new ArgumentNullException("to");
}
string f1;
string f2;
if (from.RevisionType == SvnRevisionType.Number && to.RevisionType == SvnRevisionType.Number && from.Revision + 1 == to.Revision)
{
f1 = GetTempPath(target.FileName, from);
f2 = GetTempPath(target.FileName, to);
int n = 0;
ProgressRunnerResult r = Context.GetService <IProgressRunner>().RunModal(ServiceStrings.RetrievingMultipleVersionsOfFile,
delegate(object sender, ProgressWorkerArgs e)
{
SvnFileVersionsArgs ea = new SvnFileVersionsArgs();
ea.Start = from;
ea.End = to;
ea.AddExpectedError(SvnErrorCode.SVN_ERR_UNSUPPORTED_FEATURE); // Github
e.Client.FileVersions(target, ea,
delegate(object sender2, SvnFileVersionEventArgs e2)
{
if (n++ == 0)
{
e2.WriteTo(f1);
}
else
{
e2.WriteTo(f2);
}
});
});
if (!r.Succeeded)
{
return(null);
}
if (n != 2)
{
// Sloooooow workaround for SvnBridge / Codeplex
f1 = GetTempFile(target, from, withProgress);
if (f1 == null)
{
return(null); // Canceled
}
f2 = GetTempFile(target, to, withProgress);
}
}
else
{
f1 = GetTempFile(target, from, withProgress);
if (f1 == null)
{
return(null); // Canceled
}
f2 = GetTempFile(target, to, withProgress);
}
if (string.IsNullOrEmpty(f1) || string.IsNullOrEmpty(f2))
{
return(null);
}
string[] files = new string[] { f1, f2 };
foreach (string f in files)
{
if (File.Exists(f))
{
File.SetAttributes(f, FileAttributes.ReadOnly);
}
}
return(files);
}
public override void OnExecute(CommandEventArgs e)
{
SvnItem root = GetRoot(e);
if (root == null)
{
return;
}
using (CreateBranchDialog dlg = new CreateBranchDialog())
{
if (e.Command == AnkhCommand.ProjectBranch)
{
dlg.Text = CommandStrings.BranchProject;
}
dlg.SrcFolder = root.FullPath;
dlg.SrcUri = root.Uri;
dlg.EditSource = false;
dlg.Revision = root.Status.Revision;
RepositoryLayoutInfo info;
if (RepositoryUrlUtils.TryGuessLayout(e.Context, root.Uri, out info))
{
dlg.NewDirectoryName = new Uri(info.BranchesRoot, ".");
}
while (true)
{
if (DialogResult.OK != dlg.ShowDialog(e.Context))
{
return;
}
string msg = dlg.LogMessage;
bool retry = false;
bool ok = false;
ProgressRunnerResult rr =
e.GetService <IProgressRunner>().RunModal(CommandStrings.CreatingBranch,
delegate(object sender, ProgressWorkerArgs ee)
{
SvnInfoArgs ia = new SvnInfoArgs();
ia.ThrowOnError = false;
if (ee.Client.Info(dlg.NewDirectoryName, ia, null))
{
DialogResult dr = DialogResult.Cancel;
ee.Synchronizer.Invoke((AnkhAction)
delegate
{
AnkhMessageBox mb = new AnkhMessageBox(ee.Context);
dr = mb.Show(string.Format("The Branch/Tag at Url '{0}' already exists.", dlg.NewDirectoryName),
"Path Exists", MessageBoxButtons.RetryCancel);
}, null);
if (dr == DialogResult.Retry)
{
// show dialog again to let user modify the branch URL
retry = true;
}
}
else
{
SvnCopyArgs ca = new SvnCopyArgs();
ca.CreateParents = true;
ca.LogMessage = msg;
ok = dlg.CopyFromUri ?
ee.Client.RemoteCopy(new SvnUriTarget(dlg.SrcUri, dlg.SelectedRevision), dlg.NewDirectoryName, ca) :
ee.Client.RemoteCopy(dlg.SrcFolder, dlg.NewDirectoryName, ca);
}
});
if (rr.Succeeded && ok && dlg.SwitchToBranch)
{
e.GetService <IAnkhCommandService>().PostExecCommand(AnkhCommand.SolutionSwitchDialog, dlg.NewDirectoryName);
}
if (!retry)
{
break;
}
}
}
}
public override void OnExecute(CommandEventArgs e)
{
// TODO: Choose which conflict to edit if we have more than one!
SvnItem conflict = null;
if (e.Command == AnkhCommand.DocumentConflictEdit)
{
conflict = e.Selection.ActiveDocumentSvnItem;
if (conflict == null || !conflict.IsConflicted)
{
return;
}
}
else
{
foreach (SvnItem item in e.Selection.GetSelectedSvnItems(false))
{
if (item.IsConflicted)
{
conflict = item;
break;
}
}
}
if (conflict == null)
{
return;
}
conflict.MarkDirty();
if (conflict.Status.LocalTextStatus != SvnStatus.Conflicted)
{
AnkhMessageBox mb = new AnkhMessageBox(e.Context);
mb.Show(string.Format(CommandStrings.TheConflictInXIsAlreadyResolved, conflict.FullPath), CommandStrings.EditConflictTitle,
System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Information);
return;
}
SvnInfoEventArgs conflictInfo = null;
bool ok = false;
ProgressRunnerResult r = e.GetService <IProgressRunner>().RunModal(CommandStrings.RetrievingConflictDetails,
delegate(object sender, ProgressWorkerArgs a)
{
ok = a.Client.GetInfo(conflict.FullPath, out conflictInfo);
});
if (!ok || !r.Succeeded || conflictInfo == null)
{
return;
}
AnkhMergeArgs da = new AnkhMergeArgs();
string dir = conflict.Directory;
da.BaseFile = Path.Combine(dir, conflictInfo.ConflictOld ?? conflictInfo.ConflictNew);
da.TheirsFile = Path.Combine(dir, conflictInfo.ConflictNew ?? conflictInfo.ConflictOld);
if (!string.IsNullOrEmpty(conflictInfo.ConflictWork))
{
da.MineFile = Path.Combine(dir, conflictInfo.ConflictWork);
}
else
{
da.MineFile = conflict.FullPath;
}
da.MergedFile = conflict.FullPath;
da.BaseTitle = "Base";
da.TheirsTitle = "Theirs";
da.MineTitle = "Mine";
da.MergedTitle = conflict.Name;
e.GetService <IAnkhDiffHandler>().RunMerge(da);
}
public void DoBlame(CommandEventArgs e,
SvnOrigin origin,
SvnRevision revisionStart,
SvnRevision revisionEnd,
bool ignoreEols,
SvnIgnoreSpacing ignoreSpacing,
bool retrieveMergeInfo)
{
// There are two SVN related operations:
// [1] Getting the file at revisionEnd, which will be displayed in the editor
// [2] Getting the blame information, which will be displayed in the margin
// This is the parameter structure for [1] getting the file
SvnWriteArgs wa = new SvnWriteArgs();
wa.Revision = revisionEnd;
// This is the parameter structure for [2] getting the blame information
SvnBlameArgs ba = new SvnBlameArgs();
ba.Start = revisionStart;
ba.End = revisionEnd;
ba.IgnoreLineEndings = ignoreEols;
ba.IgnoreSpacing = ignoreSpacing;
ba.RetrieveMergedRevisions = retrieveMergeInfo;
SvnTarget target = origin.Target;
// Can we make this an MEF service?
IAnkhTempFileManager tempMgr = e.GetService <IAnkhTempFileManager>();
string tempFile = tempMgr.GetTempFileNamed(target.FileName);
Collection <SvnBlameEventArgs> blameResult = null;
bool retry = false;
ProgressRunnerResult r = e.GetService <IProgressRunner>().RunModal("Annotating", delegate(object sender, ProgressWorkerArgs ee)
{
// Here we [1] get the file at revisionEnd
using (FileStream fs = File.Create(tempFile))
{
ee.Client.Write(target, fs, wa);
}
// Here we [2] get the blame information
ba.SvnError +=
delegate(object errorSender, SvnErrorEventArgs errorEventArgs)
{
if (errorEventArgs.Exception is SvnClientBinaryFileException)
{
retry = true;
errorEventArgs.Cancel = true;
}
};
ee.Client.GetBlame(target, ba, out blameResult);
});
if (retry)
{
using (AnkhMessageBox mb = new AnkhMessageBox(e.Context))
{
// Move to resources later :)
if (DialogResult.Yes != mb.Show("You are trying to annotate a binary file. Are you sure you want to continue?",
"Binary file detected",
MessageBoxButtons.YesNo, MessageBoxIcon.Information))
{
return;
}
r = e.GetService <IProgressRunner>()
.RunModal("Annotating",
delegate(object sender, ProgressWorkerArgs ee)
{
ba.IgnoreMimeType = true;
ee.Client.GetBlame(target, ba, out blameResult);
});
}
}
if (!r.Succeeded)
{
return;
}
// Create a parameter struture and add it to our internal map.
// Creating the actual view model class is now deferred to the GetModel method.
var annParam = new AnnotateMarginParameters {
Context = e.Context, Origin = origin, BlameResult = blameResult
};
_ViewModelMap.Add(tempFile, annParam);
// Open the editor.
// ToDo: Open files like resx as code.
var dte = e.GetService <DTE> (typeof(SDTE));
dte.ItemOperations.OpenFile(tempFile, EnvDTE.Constants.vsViewKindTextView);
}
public void OnExecute(CommandEventArgs e)
{
ISvnLogItem selectedLog = EnumTools.GetSingle(e.Selection.GetSelection <ISvnLogItem>());
if (selectedLog == null)
{
return;
}
using (PropertyEditorDialog dialog = new PropertyEditorDialog(selectedLog.RepositoryRoot, selectedLog.Revision, true))
{
SvnRevisionPropertyListArgs args = new SvnRevisionPropertyListArgs();
args.ThrowOnError = false;
SvnPropertyCollection properties = null;
if (!e.GetService <IProgressRunner>().RunModal(LogStrings.RetrievingRevisionProperties,
delegate(object sender, ProgressWorkerArgs wa)
{
if (!wa.Client.GetRevisionPropertyList(selectedLog.RepositoryRoot, selectedLog.Revision, args, out properties))
{
properties = null;
}
}).Succeeded)
{
return;
}
else if (properties != null)
{
List <PropertyEditItem> propItems = new List <PropertyEditItem>();
foreach (SvnPropertyValue prop in properties)
{
PropertyEditItem pi = new PropertyEditItem(dialog.ListView, prop.Key);
pi.OriginalValue = pi.Value = pi.BaseValue = prop;
propItems.Add(pi);
}
dialog.PropertyValues = propItems.ToArray();
}
if (dialog.ShowDialog(e.Context) != DialogResult.OK)
{
return;
}
PropertyEditItem[] finalItems = dialog.PropertyValues;
bool hasChanges = false;
foreach (PropertyEditItem ei in finalItems)
{
if (ei.ShouldPersist)
{
hasChanges = true;
break;
}
}
if (!hasChanges)
{
return;
}
IProgressRunner progressRunner = e.GetService <IProgressRunner>();
ProgressRunnerResult result = progressRunner.RunModal(LogStrings.UpdatingRevisionProperties,
delegate(object sender, ProgressWorkerArgs ee)
{
foreach (PropertyEditItem ei in finalItems)
{
if (!ei.ShouldPersist)
{
continue;
}
if (ei.IsDeleted)
{
ee.Client.DeleteRevisionProperty(selectedLog.RepositoryRoot, selectedLog.Revision, ei.PropertyName);
}
else if (ei.Value.StringValue != null)
{
ee.Client.SetRevisionProperty(selectedLog.RepositoryRoot, selectedLog.Revision, ei.PropertyName, ei.Value.StringValue);
}
else
{
ee.Client.SetRevisionProperty(selectedLog.RepositoryRoot, selectedLog.Revision, ei.PropertyName, ei.Value.RawValue);
}
}
});
if (result.Succeeded)
{
ILogControl logWindow = e.Selection.GetActiveControl <ILogControl>();
if (logWindow != null)
{
logWindow.Restart();
}
}
} // using
}
/*private void TryObtainBlock(CommandEventArgs e)
* {
* ISelectionContextEx ex = e.GetService<ISelectionContextEx>(typeof(ISelectionContext));
*
* if (ex == null)
* return;
*
* IVsTextView view = ex.ActiveDocumentFrameTextView;
* IVsTextLines lines;
* Guid languageService;
* IVsLanguageInfo info;
*
* if (view != null
* && VSErr.Succeeded(view.GetBuffer(out lines))
* && VSErr.Succeeded(lines.GetLanguageServiceID(out languageService))
* && null != (info = e.QueryService<IVsLanguageInfo>(languageService)))
* {
* GC.KeepAlive(info);
* IVsLanguageBlock b = info as IVsLanguageBlock;
* if (b != null)
* {
* GC.KeepAlive(b);
* }
* }
* //IVsLanguageBlock
*
*
* GC.KeepAlive(ex);
* }*/
static void DoBlame(CommandEventArgs e, SvnOrigin item, SvnRevision revisionStart, SvnRevision revisionEnd, bool ignoreEols, SvnIgnoreSpacing ignoreSpacing, bool retrieveMergeInfo)
{
SvnWriteArgs wa = new SvnWriteArgs();
wa.Revision = revisionEnd;
SvnBlameArgs ba = new SvnBlameArgs();
ba.Start = revisionStart;
ba.End = revisionEnd;
ba.IgnoreLineEndings = ignoreEols;
ba.IgnoreSpacing = ignoreSpacing;
ba.RetrieveMergedRevisions = retrieveMergeInfo;
SvnTarget target = item.Target;
IAnkhTempFileManager tempMgr = e.GetService <IAnkhTempFileManager>();
string tempFile = tempMgr.GetTempFileNamed(target.FileName);
Collection <SvnBlameEventArgs> blameResult = null;
bool retry = false;
ProgressRunnerResult r = e.GetService <IProgressRunner>().RunModal(CommandStrings.Annotating, delegate(object sender, ProgressWorkerArgs ee)
{
using (FileStream fs = File.Create(tempFile))
{
ee.Client.Write(target, fs, wa);
}
ba.SvnError +=
delegate(object errorSender, SvnErrorEventArgs errorEventArgs)
{
if (errorEventArgs.Exception is SvnClientBinaryFileException)
{
retry = true;
errorEventArgs.Cancel = true;
}
};
ee.Client.GetBlame(target, ba, out blameResult);
});
if (retry)
{
using (AnkhMessageBox mb = new AnkhMessageBox(e.Context))
{
if (DialogResult.Yes != mb.Show(
CommandStrings.AnnotateBinaryFileContinueAnywayText,
CommandStrings.AnnotateBinaryFileContinueAnywayTitle,
MessageBoxButtons.YesNo, MessageBoxIcon.Information))
{
return;
}
r = e.GetService <IProgressRunner>()
.RunModal(CommandStrings.Annotating,
delegate(object sender, ProgressWorkerArgs ee)
{
ba.IgnoreMimeType = true;
ee.Client.GetBlame(target, ba, out blameResult);
});
}
}
if (!r.Succeeded)
{
return;
}
AnnotateEditorControl annEditor = new AnnotateEditorControl();
IAnkhEditorResolver er = e.GetService <IAnkhEditorResolver>();
annEditor.Create(e.Context, tempFile);
annEditor.LoadFile(tempFile);
annEditor.AddLines(item, blameResult);
// Detect and set the language service
Guid language;
if (er.TryGetLanguageService(Path.GetExtension(target.FileName), out language))
{
// Extension is mapped -> user
annEditor.SetLanguageService(language);
}
else if (blameResult != null && blameResult.Count > 0 && blameResult[0].Line != null)
{
// Extension is not mapped -> Check if this is xml (like project files)
string line = blameResult[0].Line.Trim();
if (line.StartsWith("<?xml") ||
(line.StartsWith("<") && line.Contains("xmlns=\"http://schemas.microsoft.com/developer/msbuild/")))
{
if (er.TryGetLanguageService(".xml", out language))
{
annEditor.SetLanguageService(language);
}
}
}
}
public override void OnFinish(System.ComponentModel.CancelEventArgs e)
{
WizardMessage newMsg = null;
this.resultUri = null;
EnablePageAndButtons(false);
ScmUserNamePasswordEventArgs credentialsArgs = null;
try
{
Uri uri = this.providerSelectionPage.Uri;
if (uri == null && this.repositorySelectionPages != null)
{
ScmRepositoryProvider repoProvider = this.providerSelectionPage.SelectedRepositoryProvider;
if (repoProvider != null)
{
RepositorySelectionPage repoSelectionPage;
if (this.repositorySelectionPages.TryGetValue(repoProvider.Id, out repoSelectionPage))
{
uri = repoSelectionPage.Uri;
if (uri != null)
{
credentialsArgs = new ScmUserNamePasswordEventArgs(uri.AbsoluteUri);
repoSelectionPage.FillUsernamePassword(credentialsArgs);
if (credentialsArgs.Cancel)
{
credentialsArgs = null;
}
}
}
}
}
bool cancel = false;
if (uri == null)
{
cancel = true;
}
else
{
Exception exc = null;
if (credentialsArgs != null)
{
try
{
ProgressRunnerArgs runnerArgs = new ProgressRunnerArgs();
runnerArgs.CreateLog = false;
// Make sure username and password is saved for future use
ProgressRunnerResult result = Context.GetService <IProgressRunner>().RunModal("Checking repository",
runnerArgs,
delegate(object sender, ProgressWorkerArgs ee)
{ EnsureCredentials(credentialsArgs); });
cancel = !(result.Succeeded || result.Exception == null);
exc = result.Exception;
}
catch (Exception runnere)
{
cancel = true;
exc = runnere.InnerException == null ? runnere : runnere.InnerException;
}
}
// TODO (BA) Should we validate here?
/*
* try
* {
* ProgressRunnerArgs runnerArgs = new ProgressRunnerArgs();
* runnerArgs.CreateLog = false;
* // Check the validity of the specified repository location using IProgressRunner
* ProgressRunnerResult result = Context.GetService<IProgressRunner>().RunModal("Checking URI",
* runnerArgs,
* delegate(object sender, ProgressWorkerArgs ee)
* { CheckResult(uri); });
* cancel = !(result.Succeeded || result.Exception == null);
* exc = result.Exception;
* }
* catch (Exception runnere)
* {
* cancel = true;
* exc = runnere.InnerException == null ? runnere : runnere.InnerException;
* }
*/
if (cancel && exc != null)
{
newMsg = new WizardMessage(exc.Message, WizardMessage.MessageType.Error);
}
}
this.resultUri = cancel ? null : uri;
DialogResult = cancel ? System.Windows.Forms.DialogResult.None : System.Windows.Forms.DialogResult.OK;
if (CurrentPage.Message != newMsg)
{
CurrentPage.Message = newMsg;
UpdateMessage();
}
e.Cancel = cancel;
}
finally
{
EnablePageAndButtons(true);
}
}
