public ListFileDlg(EnvDTE80.DTE2 dte,RecordHandler rec)
{
InitializeComponent();
//�����ļ���ַ
txt_FilePath.Text = RecordHandler.GetValueFromRegistry();
_manuallySettingSelection = false;
_dte = dte;
_fileNames = new System.Collections.Generic.List<ProjectItemInfo>();
foreach (EnvDTE.Project project in _dte.Solution.Projects)
{
WalkProject(project.ProjectItems);
}
LogTimer.Interval = 2000;
LogTimer.Tick += new EventHandler(LogTimer_Tick);
RecordTable = initRecordTable();
initProjectSelector();
btn_ReadRecordCurProject_Click(null, null);
de_begin.DateTime = DateTime.Today;
de_end.DateTime = DateTime.Today;
recHandler = rec;
}
private static string GetSelectedFile(EnvDTE80.DTE2 application)
{
if (application.SelectedItems.Count == 0)
return string.Empty;
foreach (SelectedItem sel in application.SelectedItems)
{
if (sel.ProjectItem != null)
{
//The try catch block belowe fixed issue 57:
//http://github.com/spdr870/gitextensions/issues/#issue/57
try
{
return sel.ProjectItem.get_FileNames(0);
}
catch (ArgumentException)
{
if (sel.ProjectItem.FileCount > 0)
{
return sel.ProjectItem.get_FileNames(1);
}
else
{
//ignore!
}
}
}
else
if (sel.Project != null)
return sel.Project.FullName;
}
return string.Empty;
}
public TFSVersionControl(ITFSConnection _tfsConnection, EnvDTE80.DTE2 _dte, ILogger _logger)
{
dte = _dte;
logger = _logger;
tfsConnection = _tfsConnection;
tfsConnection.ConnectionChanged += ResetConnection;
versionControlControlsAssembly = Assembly.Load(versionControlControlsAssemblyString);
folderDiffOptions = AccessPrivateWrapper.FromType(versionControlControlsAssembly, BindingFlags.NonPublic | BindingFlags.Instance, "FolderDiffOptions");
}
public override void OnCommand(EnvDTE80.DTE2 application, OutputWindowPane pane)
{
ThreadPool.QueueUserWorkItem(
o =>
{
string file = GitCommands.RunGitExWait("searchfile", application.Solution.FullName);
if (file == null || string.IsNullOrEmpty(file.Trim()))
return;
application.ExecuteCommand("File.OpenFile", file);
});
}
/// <param name="dte2">DTE2 Context.</param>
/// <param name="name">Name of the pane.</param>
public PaneDTE(EnvDTE80.DTE2 dte2, string name)
{
if(dte2 == null) {
throw new ArgumentNullException("dte2", "cannot be null");
}
try {
pane = dte2.ToolWindows.OutputWindow.OutputWindowPanes.Item(name);
}
catch(ArgumentException) {
pane = dte2.ToolWindows.OutputWindow.OutputWindowPanes.Add(name);
}
catch(Exception ex) {
Log.Error("Log :: inner exception: '{0}'", ex.ToString());
}
}
// http://social.msdn.microsoft.com/Forums/vstudio/en-US/36adcd56-5698-43ca-bcba-4527daabb2e3/finding-the-startup-project-in-a-complicated-solution
public static EnvDTE.Project GetProject(EnvDTE80.Solution2 solution, string uniqueName)
{
EnvDTE.Project ret = null;
if (solution != null && uniqueName != null)
{
foreach (EnvDTE.Project p in solution.Projects)
{
ret = GetSubProject(p, uniqueName);
if (ret != null)
break;
}
}
return ret;
}
private void AddBreakPoint(EnvDTE80.DTE2 dte, string filename, int line)
{
try
{
//EnvDTE80.DTE2 dte2;
// dte2 = (EnvDTE80.DTE2)System.Runtime.InteropServices.Marshal.
//GetActiveObject("VisualStudio.DTE.8.0");
dte2.Debugger.Breakpoints.Add("", filename, line, 1, "", EnvDTE.dbgBreakpointConditionType.dbgBreakpointConditionTypeWhenTrue,
"", "", 0, "", 0, EnvDTE.dbgHitCountType.dbgHitCountTypeNone);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + "\n" + ex.StackTrace);
}
finally
{
}
// dte2 = null;
}
private static string GetSelectedFile(EnvDTE80.DTE2 application)
{
foreach (SelectedItem sel in application.SelectedItems)
{
if (sel.ProjectItem != null)
{
if (sel.ProjectItem.FileCount > 0)
{
//Unfortunaly FileNames[1] is not supported by .net 3.5
return sel.ProjectItem.get_FileNames(1);
}
}
else
if (sel.Project != null)
return sel.Project.FullName;
}
if (application.Solution.IsOpen)
return application.Solution.FullName;
return string.Empty;
}
public override bool IsEnabled(EnvDTE80.DTE2 application)
{
bool enabled = base.IsEnabled(application);
string fileName = GetSelectedFile(application);
if (showCurrentBranch && (fileName != lastFile || DateTime.Now - lastBranchCheck > new TimeSpan(0, 0, 0, 1, 0)))
{
string newCaption = "Commit";
if (enabled)
{
string head = GitCommands.GetCurrentBranch(fileName);
if (!string.IsNullOrEmpty(head))
{
string headShort;
if (head.Length > 27)
headShort = "..." + head.Substring(head.Length - 23);
else
headShort = head;
newCaption = "Commit (" + headShort + ")";
}
}
// This guard required not only for perfromance, but also for prevent StackOverflowException.
// IDE.QueryStatus -> Commit.IsEnabled -> Plugin.UpdateCaption -> IDE.QueryStatus ...
if (_lastUpdatedCaption != newCaption)
{
_lastUpdatedCaption = newCaption;
// try apply new caption (operation can fail)
if (!Plugin.ChangeCommandCaption(application, "GitExtensions", "Commit changes", newCaption))
_lastUpdatedCaption = null;
}
lastBranchCheck = DateTime.Now;
lastFile = fileName;
}
return enabled;
}
public override bool IsEnabled(EnvDTE80.DTE2 application)
{
bool enabled = base.IsEnabled(application);
string fileName = GetSelectedFile(application);
if (showCurrentBranch != null && lastBranchCheck != null && showCurrentBranch.Value && (fileName != lastFile || DateTime.Now - lastBranchCheck > new TimeSpan(0, 0, 0, 1, 0)))
{
if (enabled)
{
Plugin.ChangeCommandCaption(application, "GitExtensions", "Commit changes", "Commit" + GitCommands.GetCurrentBranch(fileName));
}
else
{
Plugin.ChangeCommandCaption(application, "GitExtensions", "Commit changes", "Commit");
}
lastBranchCheck = DateTime.Now;
lastFile = fileName;
}
return enabled;
}
public static void Initialize(EnvDTE80.DTE2 dte)
{
TelemetryConfiguration config = TelemetryConfiguration.CreateDefault();
client = new TelemetryClient(config);
client.InstrumentationKey = "b59d19eb-668d-4ae3-b4c8-71536ebabbdc";
client.Context.User.Id = GetUserId();
client.Context.Session.Id = Guid.NewGuid().ToString();
client.Context.Properties.Add("Host", dte.Application.Edition);
client.Context.Properties.Add("HostVersion", dte.Version);
client.Context.Properties.Add("HostFullVersion", GetFullHostVersion());
client.Context.Component.Version = GetViasforaVersion();
client.Context.Properties.Add("AppVersion", GetFullHostVersion());
client.Context.Device.OperatingSystem = Environment.OSVersion.ToString();
dte.Events.DTEEvents.OnBeginShutdown += OnBeginShutdown;
var settings = SettingsContext.GetSettings();
Enabled = settings.TelemetryEnabled;
WriteEvent("Viasfora Started");
}
public override bool IsEnabled(EnvDTE80.DTE2 application)
{
bool enabled = base.IsEnabled(application);
string fileName = GetSelectedFile(application);
if (showCurrentBranch && (fileName != lastFile || DateTime.Now - lastBranchCheck > new TimeSpan(0, 0, 0, 1, 0)))
{
if (enabled)
{
string head = GitCommands.GetCurrentBranch(fileName);
if (!string.IsNullOrEmpty(head))
{
string headShort;
if (head.Length > 27)
headShort = "..." + head.Substring(head.Length - 23);
else
headShort = head;
Plugin.ChangeCommandCaption(application, "GitExtensions", "Commit changes", "Commit (" + headShort + ")");
}
else
{
Plugin.ChangeCommandCaption(application, "GitExtensions", "Commit changes", "Commit");
}
}
else
{
Plugin.ChangeCommandCaption(application, "GitExtensions", "Commit changes", "Commit");
}
lastBranchCheck = DateTime.Now;
lastFile = fileName;
}
return enabled;
}
public override SyntaxNode SetParameterKind(SyntaxNode node, EnvDTE80.vsCMParameterKind kind)
{
var parameter = node as ParameterSyntax;
if (parameter == null)
{
throw Exceptions.ThrowEFail();
}
// We can't do anything with "Optional", so just strip it out and ignore it.
if ((kind & EnvDTE80.vsCMParameterKind.vsCMParameterKindOptional) != 0)
{
kind -= EnvDTE80.vsCMParameterKind.vsCMParameterKindOptional;
}
SyntaxTokenList newModifiers;
switch (kind)
{
case EnvDTE80.vsCMParameterKind.vsCMParameterKindOut:
newModifiers = SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.OutKeyword));
break;
case EnvDTE80.vsCMParameterKind.vsCMParameterKindRef:
newModifiers = SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.RefKeyword));
break;
case EnvDTE80.vsCMParameterKind.vsCMParameterKindIn:
case EnvDTE80.vsCMParameterKind.vsCMParameterKindNone:
newModifiers = SyntaxFactory.TokenList();
break;
case EnvDTE80.vsCMParameterKind.vsCMParameterKindParamArray:
{
var parameterList = (ParameterListSyntax)parameter.Parent;
if (parameterList.Parameters.LastOrDefault() == parameter &&
parameter.Type is ArrayTypeSyntax)
{
newModifiers = SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ParamsKeyword));
break;
}
throw Exceptions.ThrowEInvalidArg();
}
default:
throw Exceptions.ThrowEInvalidArg();
}
return parameter.WithModifiers(newModifiers);
}
public HostProjectWindow(EnvDTE80.DTE2 dte)
{
InitializeComponent();
this.dte = dte;
}
public VisualStudio(EnvDTE80.DTE2 dte) :
base(dte, "14")
{
}
public override bool IsEnabled(EnvDTE80.DTE2 application)
{
return true;
}
private static void AppendParameterTypeName(StringBuilder b, EnvDTE80.CodeParameter2 parameter, string[] genericTypeParameters, string[] genericMethodParameters)
{
EnvDTE80.CodeTypeRef2 parameterTypeRef = (EnvDTE80.CodeTypeRef2)parameter.Type;
string parameterTypeString = parameterTypeRef.AsFullName;
int substringStart = 0;
for (int i = 0; i < parameterTypeString.Length; ++i) {
char ch = parameterTypeString[i];
switch (ch) {
case '<':
AppendParameterTypeSubstring(b, parameterTypeString, substringStart, i, genericTypeParameters, genericMethodParameters);
substringStart = i + 1;
b.Append('{');
break;
case '>':
AppendParameterTypeSubstring(b, parameterTypeString, substringStart, i, genericTypeParameters, genericMethodParameters);
substringStart = i + 1;
b.Append('}');
break;
case '[':
AppendParameterTypeSubstring(b, parameterTypeString, substringStart, i, genericTypeParameters, genericMethodParameters);
b.Append('[');
// Skip ahead to the closing bracket, counting commas to determine array rank.
int rank = 1;
do {
++i;
ch = parameterTypeString[i];
if (ch == ',') {
++rank;
}
}
while (ch != ']');
substringStart = i + 1;
// For multi-dimensional arrays, add "0:" default array bounds. Note that non-standard bounds are not possible via C# declaration.
if (rank > 1) {
for (int r = 0; r < rank; ++r) {
if (r != 0) {
b.Append(',');
}
b.Append("0:");
}
}
b.Append(']');
break;
case ',':
AppendParameterTypeSubstring(b, parameterTypeString, substringStart, i, genericTypeParameters, genericMethodParameters);
substringStart = i + 1;
// Skip space after comma if present. (e.g. System.Collections.Generic.KeyValuePair`2{System.String,System.String}.)
if (parameterTypeString[substringStart] == ' ') {
++substringStart;
}
b.Append(',');
break;
}
}
AppendParameterTypeSubstring(b, parameterTypeString, substringStart, parameterTypeString.Length, genericTypeParameters, genericMethodParameters);
// Append ref / out indicator if needed.
if ((parameter.ParameterKind == EnvDTE80.vsCMParameterKind.vsCMParameterKindRef) ||
(parameter.ParameterKind == EnvDTE80.vsCMParameterKind.vsCMParameterKindOut)) {
b.Append('@');
}
// Note there is no need to append a '*' for pointers, as this is included in the full name of the type.
// Multi-dimensional and jagged arrays are handled above during string parsing.
}
private int RuleWarningsCount(EnvDTE80.ErrorList errorList)
{
int warningsCount = 0;
for (int index = 1; index <= errorList.ErrorItems.Count; index++)
{
// check only on warnings
if (errorList.ErrorItems.Item(index).ErrorLevel ==
EnvDTE80.vsBuildErrorLevel.vsBuildErrorLevelLow)
{
if (errorList.ErrorItems.Item(index).Description.StartsWith(
RuleCheckIdPrefix, StringComparison.OrdinalIgnoreCase))
{
warningsCount++;
}
}
}
return warningsCount;
}
/// <summary>
/// Accepts the event.
/// </summary>
/// <param name="e">The e.</param>
/// <returns></returns>
protected virtual bool AcceptField(EnvDTE80.CodeElement2 e)
{
return true;
}
public override SyntaxNode SetConstKind(SyntaxNode variableNode, EnvDTE80.vsCMConstKind kind)
{
Debug.Assert(variableNode is FieldDeclarationSyntax ||
variableNode is EnumMemberDeclarationSyntax);
if (variableNode is EnumMemberDeclarationSyntax)
{
if (kind != EnvDTE80.vsCMConstKind.vsCMConstKindConst &&
kind != EnvDTE80.vsCMConstKind.vsCMConstKindReadOnly)
{
throw Exceptions.ThrowEInvalidArg();
}
return variableNode;
}
var member = (MemberDeclarationSyntax)variableNode;
var flags = member.GetModifierFlags();
flags &= ~(ModifierFlags.Const | ModifierFlags.ReadOnly);
switch (kind)
{
case EnvDTE80.vsCMConstKind.vsCMConstKindConst:
flags |= ModifierFlags.Const;
break;
case EnvDTE80.vsCMConstKind.vsCMConstKindReadOnly:
flags |= ModifierFlags.ReadOnly;
break;
}
return member.UpdateModifiers(flags);
}
public override SyntaxNode SetInheritanceKind(SyntaxNode typeNode, EnvDTE80.vsCMInheritanceKind kind)
{
Debug.Assert(typeNode is ClassDeclarationSyntax);
var member = typeNode as MemberDeclarationSyntax;
if (member == null)
{
throw Exceptions.ThrowEFail();
}
var flags = member.GetModifierFlags();
flags &= ~(ModifierFlags.Abstract | ModifierFlags.New | ModifierFlags.Sealed);
if (kind != EnvDTE80.vsCMInheritanceKind.vsCMInheritanceKindNone)
{
if ((kind & EnvDTE80.vsCMInheritanceKind.vsCMInheritanceKindAbstract) != 0)
{
flags |= ModifierFlags.Abstract;
}
else if ((kind & EnvDTE80.vsCMInheritanceKind.vsCMInheritanceKindSealed) != 0)
{
flags |= ModifierFlags.Sealed;
}
// Can have new in combination with the above flags
if ((kind & EnvDTE80.vsCMInheritanceKind.vsCMInheritanceKindNew) != 0)
{
flags |= ModifierFlags.New;
}
}
return member.UpdateModifiers(flags);
}
private static bool TryAttach(EnvDTE80.Process2 process, string[] engines)
{
try
{
process.Attach2(engines);
return true;
}
catch
{
return false;
}
}
internal void UpdateOverrideKind(SyntaxNode node, EnvDTE80.vsCMOverrideKind kind)
{
node = CodeModelService.GetNodeWithModifiers(node);
var updatedNode = CodeModelService.SetOverrideKind(node, kind);
if (node != updatedNode)
{
UpdateNode(node, updatedNode);
}
}
private void UpdateProgressBar(string filename, int currentCount, int overallCount, EnvDTE80.DTE2 dte)
{
if (string.IsNullOrEmpty(filename)) { throw new ArgumentNullException("filename"); }
if (dte == null) { throw new ArgumentNullException("dte"); }
string message = string.Format("[{1}/{2}]: Translating into file: {0}", filename, currentCount, overallCount);
dte.StatusBar.Progress(true, message, currentCount, overallCount);
if (currentCount >= overallCount) {
dte.StatusBar.Progress(false);
dte.StatusBar.Animate(false, vsStatusAnimation.vsStatusAnimationGeneral);
}
}
internal void Translate(string apiKey, Project project, ProjectItem selectedItem, EnvDTE80.DTE2 dte)
{
if (string.IsNullOrWhiteSpace(apiKey)) { throw new ArgumentNullException("apiKey"); }
if (project == null) { throw new ArgumentNullException("project"); }
if (selectedItem == null) { throw new ArgumentNullException("selectedItem"); }
if (dte == null) { throw new ArgumentNullException("dte"); }
// get the file path which should be translated
string filePath = selectedItem.Properties.Item("FullPath").Value.ToString();
dte.StatusBar.Animate(true, vsStatusAnimation.vsStatusAnimationGeneral);
ILocanTranslator bingTranslator = new BingLocanTranslator(apiKey);
IList<ILocanRow> rowsToTranslate = this.ReadResxFileForTranslation(filePath);
var stringsToTranslate = from r in rowsToTranslate
select r.StringToTranslate;
IList<ILanguage> languages = bingTranslator.GetSupportedLanguages().ToList();
int currentLanguageIndex = 1;
int totalCountOfLanguages = languages.Count;
ILanguage sourceLanguage = bingTranslator.DetectLanguage(stringsToTranslate.First());
foreach (ILanguage destLang in languages) {
if (this.PreserveUpdates) {
// TODO: Look to see if there is an existing file at {Filename}.{language}.resx.cache
this.SendTranslationUpdatesToBing(filePath, rowsToTranslate, sourceLanguage, destLang, bingTranslator);
}
ProjectItem addedResxProjectItem = null;
bingTranslator
.Translate(stringsToTranslate, destLang, sourceLanguage)
.OnTranslationComplete((payload, translations) => {
string destFile = this.GetDestFilename(filePath, payload.DestLanguage);
this.UpdateProgressBar(destFile, currentLanguageIndex++, totalCountOfLanguages, dte);
using (ILocanWriter writer = LocanReaderWriterFactory.Instance.GetWriter(new { filepath = destFile })) {
// it is not reliable to use any variables declared outside of this scope
// because this is happening async the loop may change the values outside of this scope
int currentIndex = 0;
foreach (ITranslation translation in translations) {
// get source row
ILocanRow sourceRow = rowsToTranslate[currentIndex];
ILocanRow translatedRow = new LocanRow(id: sourceRow.Id, translatedString: translation.TrnaslatedString);
writer.WriteRow(translatedRow);
// addedResxProjectItem = this.AddFileToProject(selectedItem, destFile);
addedResxProjectItem = this.AddFileToProjectAsChild(selectedItem, destFile);
currentIndex++;
}
}
if (this.PreserveUpdates) {
// now copy this file to the cache location so that we can compute difference next time.
string cacheFile = this.GetDestCacheFilename(filePath, payload.DestLanguage);
File.Copy(destFile, cacheFile, true);
this.AddFileToProjectAsChild(addedResxProjectItem, cacheFile);
}
});
}
}
internal void UpdateParameterKind(SyntaxNode node, EnvDTE80.vsCMParameterKind kind)
{
var updatedNode = CodeModelService.SetParameterKind(node, kind);
if (node != updatedNode)
{
UpdateNode(node, updatedNode);
}
}
public override SyntaxNode SetDataTypeKind(SyntaxNode typeNode, EnvDTE80.vsCMDataTypeKind kind)
{
Debug.Assert(typeNode is BaseTypeDeclarationSyntax);
var type = (BaseTypeDeclarationSyntax)typeNode;
var flags = type.GetModifierFlags();
if (kind == EnvDTE80.vsCMDataTypeKind.vsCMDataTypeKindPartial)
{
flags |= ModifierFlags.Partial;
}
else if (kind == EnvDTE80.vsCMDataTypeKind.vsCMDataTypeKindMain)
{
flags &= ~ModifierFlags.Partial;
}
return type.UpdateModifiers(flags);
}
/// <summary>
///
/// </summary>
public CodeEventInfo(BaseInfo parent, EnvDTE80.CodeEvent item)
: base(parent, item as CodeElement2)
{
this._item = item;
this.Access = ObjectFactory.Convert(this._item.Access);
}
public override SyntaxNode SetOverrideKind(SyntaxNode memberNode, EnvDTE80.vsCMOverrideKind kind)
{
Debug.Assert(memberNode is BaseMethodDeclarationSyntax ||
memberNode is BasePropertyDeclarationSyntax ||
memberNode is EventFieldDeclarationSyntax);
// The legacy C# code model sets the MustImplement property here depending on whether the Abstract kind is set
// TODO(DustinCa): VB implements MustImplement in terms of OverrideKind, should we do the same?
memberNode = SetMustImplement(memberNode, (kind & EnvDTE80.vsCMOverrideKind.vsCMOverrideKindAbstract) != 0);
var member = (MemberDeclarationSyntax)memberNode;
var flags = member.GetModifierFlags();
flags &= ~(ModifierFlags.Abstract | ModifierFlags.Virtual | ModifierFlags.Override | ModifierFlags.New | ModifierFlags.Sealed);
if (member.IsParentKind(SyntaxKind.InterfaceDeclaration))
{
if ((kind & (EnvDTE80.vsCMOverrideKind.vsCMOverrideKindOverride | EnvDTE80.vsCMOverrideKind.vsCMOverrideKindSealed)) != 0)
{
throw Exceptions.ThrowEInvalidArg();
}
else if ((kind & (EnvDTE80.vsCMOverrideKind.vsCMOverrideKindAbstract | EnvDTE80.vsCMOverrideKind.vsCMOverrideKindVirtual)) != 0)
{
// Switch these flags off
kind = kind & ~(EnvDTE80.vsCMOverrideKind.vsCMOverrideKindAbstract | EnvDTE80.vsCMOverrideKind.vsCMOverrideKindVirtual);
}
}
if (kind != EnvDTE80.vsCMOverrideKind.vsCMOverrideKindNone)
{
if ((kind & EnvDTE80.vsCMOverrideKind.vsCMOverrideKindAbstract) != 0)
{
flags |= ModifierFlags.Abstract;
}
if ((kind & EnvDTE80.vsCMOverrideKind.vsCMOverrideKindVirtual) != 0)
{
flags |= ModifierFlags.Virtual;
}
if ((kind & EnvDTE80.vsCMOverrideKind.vsCMOverrideKindOverride) != 0)
{
flags |= ModifierFlags.Override;
}
if ((kind & EnvDTE80.vsCMOverrideKind.vsCMOverrideKindSealed) != 0)
{
flags |= ModifierFlags.Sealed;
}
if ((kind & EnvDTE80.vsCMOverrideKind.vsCMOverrideKindNew) != 0)
{
flags |= ModifierFlags.New;
}
}
return member.UpdateModifiers(flags);
}
/// <summary>
/// Accepts the event.
/// </summary>
/// <param name="e">The e.</param>
/// <returns></returns>
protected virtual bool AcceptEvent(EnvDTE80.CodeEvent e)
{
return true;
}
