#pragma warning disable VSTHRD100 // Avoid async void methods - ok as an event handler
private async void Execute(object sender, EventArgs e)
#pragma warning restore VSTHRD100 // Avoid async void methods
{
System.Windows.Forms.Cursor previousCursor = System.Windows.Forms.Cursor.Current;
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.WaitCursor;
try
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
this.Logger?.RecordFeatureUsage(nameof(AnalyzeCurrentDocumentCommand));
var dte = await Instance.AsyncPackage.GetServiceAsync <DTE, DTE>();
var vs = new VisualStudioAbstraction(this.Logger, this.AsyncPackage, dte);
var filePath = vs.GetActiveDocumentFilePath();
// Ensure that the open document has been saved so get latest version
var rdt = new RunningDocumentTable(Package);
rdt.SaveFileIfDirty(filePath);
RapidXamlDocumentCache.Invalidate(filePath);
RapidXamlDocumentCache.TryUpdate(filePath);
}
catch (Exception exc)
{
this.Logger?.RecordException(exc);
}
finally
{
System.Windows.Forms.Cursor.Current = previousCursor;
}
}
#pragma warning disable CS0628 // New protected member declared in sealed class
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
#pragma warning restore CS0628 // New protected member declared in sealed class
{
// When initialized asynchronously, the current thread may be a background thread at this point.
// Do any initialization that requires the UI thread after switching to the UI thread.
await this.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
try
{
await SharedRapidXamlPackage.InitializeAsync(cancellationToken, this);
SharedRapidXamlPackage.Logger?.RecordNotice(StringRes.Info_LaunchVersionAnalysis.WithParams(CoreDetails.GetVersion()));
SharedRapidXamlPackage.Logger?.RecordNotice(string.Empty);
await FeedbackCommand.InitializeAsync(this, SharedRapidXamlPackage.Logger);
await MoveAllHardCodedStringsToResourceFileCommand.InitializeAsync(this, SharedRapidXamlPackage.Logger);
await this.SetUpRunningDocumentTableEventsAsync(cancellationToken);
RapidXamlDocumentCache.Initialize(this, SharedRapidXamlPackage.Logger);
Microsoft.VisualStudio.Shell.Events.SolutionEvents.OnAfterCloseSolution += this.HandleCloseSolution;
}
catch (Exception exc)
{
SharedRapidXamlPackage.Logger?.RecordException(exc);
}
}
public override void Execute(CancellationToken cancellationToken)
{
var vs = new VisualStudioTextManipulation(ProjectHelpers.Dte);
vs.StartSingleUndoOperation(StringRes.UI_SetBindingModeToTwoWay);
try
{
var lineNumber = this.Tag.Snapshot.GetLineNumberFromPosition(this.Tag.InsertPosition) + 1;
if (!string.IsNullOrEmpty(this.Tag.ExistingBindingMode))
{
vs.ReplaceInActiveDocOnLine(this.Tag.ExistingBindingMode, "Mode=TwoWay", lineNumber);
}
else
{
vs.ReplaceInActiveDocOnLine("}", ", Mode=TwoWay}", lineNumber);
}
RapidXamlDocumentCache.TryUpdate(this.File);
}
finally
{
vs.EndSingleUndoOperation();
}
}
public override void Execute(CancellationToken cancellationToken)
{
var resPath = this.GetResourceFilePath();
if (resPath == null)
{
return;
}
var vs = new VisualStudioTextManipulation(ProjectHelpers.Dte);
vs.StartSingleUndoOperation(StringRes.Info_UndoContextMoveStringToResourceFile);
try
{
// If the resource file is open with unsaved changes VS will prompt about data being lost.
this.AddResource(resPath, $"{this.Tag.UidValue}.{this.Tag.AttributeName}", this.Tag.Value);
if (this.Tag.AttributeType == AttributeType.Inline)
{
var currentAttribute = $"{this.Tag.AttributeName}=\"{this.Tag.Value}\"";
if (this.Tag.UidExists)
{
vs.RemoveInActiveDocOnLine(currentAttribute, this.Tag.GetDesignerLineNumber());
}
else
{
var uidTag = $"x:Uid=\"{this.Tag.UidValue}\"";
vs.ReplaceInActiveDocOnLine(currentAttribute, uidTag, this.Tag.GetDesignerLineNumber());
}
}
else if (this.Tag.AttributeType == AttributeType.Element)
{
var currentAttribute = $"<{this.Tag.ElementName}.{this.Tag.AttributeName}>{this.Tag.Value}</{this.Tag.ElementName}.{this.Tag.AttributeName}>";
vs.RemoveInActiveDocOnLine(currentAttribute, this.Tag.GetDesignerLineNumber());
if (!this.Tag.UidExists)
{
var uidTag = $"<{this.Tag.ElementName} x:Uid=\"{this.Tag.UidValue}\"";
vs.ReplaceInActiveDocOnLineOrAbove($"<{this.Tag.ElementName}", uidTag, this.Tag.GetDesignerLineNumber());
}
}
else if (this.Tag.AttributeType == AttributeType.DefaultValue)
{
var current = $">{this.Tag.Value}</{this.Tag.ElementName}>";
var replaceWith = this.Tag.UidExists ? " />" : $" x:Uid=\"{this.Tag.UidValue}\" />";
vs.ReplaceInActiveDocOnLine(current, replaceWith, this.Tag.GetDesignerLineNumber());
}
RapidXamlDocumentCache.TryUpdate(this.File);
}
finally
{
vs.EndSingleUndoOperation();
}
}
public override void Execute(CancellationToken cancellationToken)
{
this.Tag.SetAsHiddenInSettingsFile();
this.Source.Refresh();
RapidXamlDocumentCache.RemoveTags(this.Tag.FileName, this.ErrorCode);
RapidXamlDocumentCache.Invalidate(this.Tag.FileName);
RapidXamlDocumentCache.TryUpdate(this.Tag.FileName);
TableDataSource.Instance.CleanErrors(this.Tag.FileName);
}
public override void Execute(CancellationToken cancellationToken)
{
var vs = new VisualStudioTextManipulation(ProjectHelpers.Dte);
vs.StartSingleUndoOperation(this.UndoText);
try
{
vs.ReplaceInActiveDocOnLine(this.Original, this.Replace, this.LineNo);
RapidXamlDocumentCache.TryUpdate(this.File);
}
finally
{
vs.EndSingleUndoOperation();
}
}
public override void Execute(CancellationToken cancellationToken)
{
var vs = new VisualStudioTextManipulation(ProjectHelpers.Dte);
vs.StartSingleUndoOperation(StringRes.UI_AddMissingEvent);
try
{
var lineNumber = this.Tag.Snapshot.GetLineNumberFromPosition(this.Tag.InsertPosition) + 1;
string newName;
if (this.Tag.ExistingName.ToLowerInvariant().Contains("checked"))
{
if (this.Tag.ExistingIsChecked)
{
newName = this.Tag.ExistingName.Replace("Checked", "UnChecked").Replace("checked", "Unchecked");
}
else
{
newName = this.Tag.ExistingName.Replace("UnChecked", "Checked").Replace("unchecked", "checked");
}
}
else
{
if (this.Tag.ExistingIsChecked)
{
newName = "OnCheckBoxUnchecked";
}
else
{
newName = "OnCheckBoxChecked";
}
}
var newEvent = this.Tag.ExistingIsChecked
? $"Unchecked=\"{newName}\""
: $"Checked=\"{newName}\"";
vs.ReplaceInActiveDocOnLine("<CheckBox", $"<CheckBox {newEvent} ", lineNumber);
RapidXamlDocumentCache.TryUpdate(this.File);
}
finally
{
vs.EndSingleUndoOperation();
}
}
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
// When initialized asynchronously, the current thread may be a background thread at this point.
// Do any initialization that requires the UI thread after switching to the UI thread.
await this.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
var rxtLogger = new RxtLogger();
var config = new RxtSettings();
var telemLogger = TelemetryAccessor.Create(rxtLogger, config.TelemetryKey);
Logger = new RxtLoggerWithTelemtry(rxtLogger, telemLogger);
try
{
// Set the ServiceProvider of CodeParserBase as it's needed to get settings
CodeParserBase.ServiceProvider = this;
Logger.RecordInfo(StringRes.Info_ProblemsInstructionsAndLink);
Logger.RecordInfo(StringRes.Info_IntializingCommands.WithParams(CoreDetails.GetVersion()));
await CreateViewCommand.InitializeAsync(this, Logger);
await CopyToClipboardCommand.InitializeAsync(this, Logger);
await SendToToolboxCommand.InitializeAsync(this, Logger);
await OpenOptionsCommand.InitializeAsync(this, Logger);
await SetDatacontextCommand.InitializeAsync(this, Logger);
await MoveAllHardCodedStringsToResourceFileCommand.InitializeAsync(this, Logger);
await RapidXamlDropHandlerProvider.InitializeAsync(this, Logger);
await this.SetUpRunningDocumentTableEventsAsync(cancellationToken);
RapidXamlDocumentCache.Initialize(this);
}
catch (Exception exc)
{
Logger.RecordException(exc);
throw; // Remove for launch. see issue #90
}
}
public override void Execute(CancellationToken cancellationToken)
{
var vs = new VisualStudioTextManipulation(ProjectHelpers.Dte);
vs.StartSingleUndoOperation(StringRes.Info_UndoContextAddTextBoxInputScope);
try
{
var lineNumber = this.Tag.Snapshot.GetLineNumberFromPosition(this.Tag.InsertPosition) + 1;
vs.ReplaceInActiveDocOnLine("<TextBox ", "<TextBox InputScope=\"Default\" ", lineNumber);
RapidXamlDocumentCache.TryUpdate(this.File);
}
finally
{
vs.EndSingleUndoOperation();
}
}
public override void Execute(CancellationToken cancellationToken)
{
var vs = new VisualStudioTextManipulation(ProjectHelpers.Dte);
vs.StartSingleUndoOperation(StringRes.UI_UndoContextAddEntryKeyboard);
try
{
var lineNumber = this.Tag.Snapshot.GetLineNumberFromPosition(this.Tag.InsertPosition) + 1;
vs.ReplaceInActiveDocOnLine("<Entry ", $"<Entry Keyboard=\"{this.KeyBoardName}\" ", lineNumber);
RapidXamlDocumentCache.TryUpdate(this.File);
}
finally
{
vs.EndSingleUndoOperation();
}
}
public override void Execute(CancellationToken cancellationToken)
{
var vs = new VisualStudioTextManipulation(ProjectHelpers.Dte);
vs.StartSingleUndoOperation(StringRes.UI_ChangeToMediaPlayerElement);
try
{
var lineNumber = this.Tag.Snapshot.GetLineNumberFromPosition(this.Tag.InsertPosition) + 1;
vs.ReplaceInActiveDocOnLine("<MediaElement", "<MediaPlayerElement", lineNumber);
RapidXamlDocumentCache.TryUpdate(this.File);
}
finally
{
vs.EndSingleUndoOperation();
}
}
public override void Execute(CancellationToken cancellationToken)
{
var vs = new VisualStudioTextManipulation(ProjectHelpers.Dte);
vs.StartSingleUndoOperation(this.UndoOperationName);
try
{
var lineNumber = this.Tag.Snapshot.GetLineNumberFromPosition(this.Tag.InsertPosition) + 1;
string toInsert;
if (this.Tag.GridNeedsExpanding)
{
vs.RemoveInActiveDocOnLine(" />", lineNumber);
toInsert = $">{Environment.NewLine}{this.InjectedXaml}";
toInsert = toInsert.Replace("\n", "\n" + this.Tag.LeftPad);
string shortPad = this.Tag.LeftPad.EndsWith("\t")
? this.Tag.LeftPad.Substring(0, this.Tag.LeftPad.Length - 1)
: this.Tag.LeftPad.Substring(0, this.Tag.LeftPad.Length - 4);
toInsert += $"{Environment.NewLine}{shortPad}</Grid>";
}
else
{
toInsert = Environment.NewLine + this.InjectedXaml;
toInsert = toInsert.Replace("\n", "\n" + this.Tag.LeftPad);
}
vs.InsertAtEndOfLine(lineNumber, toInsert);
RapidXamlDocumentCache.TryUpdate(this.File);
}
finally
{
vs.EndSingleUndoOperation();
}
}
public override void Execute(CancellationToken cancellationToken)
{
var vs = new VisualStudioTextManipulation(ProjectHelpers.Dte);
vs.StartSingleUndoOperation(this.DisplayText);
try
{
this.InnerExecute(vs, this.Tag, cancellationToken);
foreach (var suppAction in this.Tag.SupplementaryActions)
{
var sat = this.RepurposeTagForSupplementaryAction(this.Tag, suppAction);
this.InnerExecute(vs, sat, cancellationToken);
}
RapidXamlDocumentCache.TryUpdate(this.File);
}
finally
{
vs.EndSingleUndoOperation();
}
}
public override void Execute(CancellationToken cancellationToken)
{
var vs = new VisualStudioTextManipulation(ProjectHelpers.Dte);
vs.StartSingleUndoOperation(StringRes.Info_UndoContextAddRowDefinitions);
try
{
var insert = string.Empty;
const string def = "<RowDefinition Height=\"*\" />";
var leftPad = this.Tag.LeftPad.Contains("\t") ? this.Tag.LeftPad + "\t" : this.Tag.LeftPad + " ";
for (var i = 0; i <= this.Tag.TotalDefsRequired - this.Tag.ExistingDefsCount; i++)
{
insert += $"{Environment.NewLine}{leftPad}{def}";
}
var insertLine = this.Tag.Snapshot.GetLineNumberFromPosition(this.Tag.InsertPosition);
if (!this.Tag.HasSomeDefinitions)
{
insert = $"{Environment.NewLine}{this.Tag.LeftPad}<Grid.RowDefinitions>{insert}{Environment.NewLine}{this.Tag.LeftPad}</Grid.RowDefinitions>";
// Account for different reference position - end-of-start vs start-of-end
insertLine += 1;
}
vs.InsertAtEndOfLine(insertLine, insert);
RapidXamlDocumentCache.TryUpdate(this.File);
}
finally
{
vs.EndSingleUndoOperation();
}
}
public override void Execute(CancellationToken cancellationToken)
{
this.Tag.SetAsHiddenInSettingsFile();
RapidXamlDocumentCache.RemoveTags(this.Tag.FileName, this.ErrorCode);
this.Source.Refresh();
}
public override void Execute(CancellationToken cancellationToken)
{
var resPath = this.GetResourceFilePath();
if (resPath == null)
{
return;
}
var vs = this.vstm ?? new VisualStudioTextManipulation(ProjectHelpers.Dte);
var undo = vs.StartSingleUndoOperation(StringRes.UI_UndoContextMoveStringToResourceFile);
try
{
if (this.Tag.ProjType == ProjectType.Uwp)
{
// If the resource file is open with unsaved changes VS will prompt about data being lost.
this.AddResource(resPath, $"{this.Tag.UidValue}.{this.Tag.AttributeName}", this.Tag.Value);
if (this.Tag.AttributeType == AttributeType.Inline)
{
var currentAttribute = $"{this.Tag.AttributeName}=\"{this.Tag.Value}\"";
if (this.Tag.UidExists)
{
vs.RemoveInActiveDocOnLine(currentAttribute, this.Tag.GetDesignerLineNumber());
}
else
{
var uidTag = $"x:Uid=\"{this.Tag.UidValue}\"";
vs.ReplaceInActiveDocOnLine(currentAttribute, uidTag, this.Tag.GetDesignerLineNumber());
}
}
else if (this.Tag.AttributeType == AttributeType.Element)
{
var currentAttribute = $"<{this.Tag.ElementName}.{this.Tag.AttributeName}>{this.Tag.Value}</{this.Tag.ElementName}.{this.Tag.AttributeName}>";
vs.RemoveInActiveDocOnLine(currentAttribute, this.Tag.GetDesignerLineNumber());
if (!this.Tag.UidExists)
{
var uidTag = $"<{this.Tag.ElementName} x:Uid=\"{this.Tag.UidValue}\"";
vs.ReplaceInActiveDocOnLineOrAbove($"<{this.Tag.ElementName}", uidTag, this.Tag.GetDesignerLineNumber());
}
}
else if (this.Tag.AttributeType == AttributeType.DefaultValue)
{
var current = $">{this.Tag.Value}</{this.Tag.ElementName}>";
var replaceWith = this.Tag.UidExists ? " />" : $" x:Uid=\"{this.Tag.UidValue}\" />";
vs.ReplaceInActiveDocOnLine(current, replaceWith, this.Tag.GetDesignerLineNumber());
}
}
else if (this.Tag.ProjType == ProjectType.Wpf)
{
// TODO: ISSUE#163 Implement WPF resource creation
var resourceName = "NEED TO GENERATE THIS";
this.AddResource(resPath, resourceName, this.Tag.Value);
switch (this.Tag.AttributeType)
{
case AttributeType.Inline:
break;
case AttributeType.Element:
break;
case AttributeType.DefaultValue:
break;
}
}
else if (this.Tag.ProjType == ProjectType.XamarinForms)
{
var resourceName = "NEED TO GENERATE THIS";
this.AddResource(resPath, resourceName, this.Tag.Value);
// TODO: ISSUE#163 Implement Xamarin.Forms resource creation
switch (this.Tag.AttributeType)
{
case AttributeType.Inline:
var currentAttribute = $"{this.Tag.AttributeName}=\"{this.Tag.Value}\"";
var localizedAttribute = $"{this.Tag.AttributeName}=\"{{x:Static resources:{System.IO.Path.GetFileNameWithoutExtension(resPath)}.{resourceName}}}\"";
vs.ReplaceInActiveDocOnLine(currentAttribute, localizedAttribute, this.Tag.GetDesignerLineNumber());
break;
case AttributeType.Element:
break;
case AttributeType.DefaultValue:
break;
}
}
RapidXamlDocumentCache.TryUpdate(this.File);
}
finally
{
if (undo)
{
vs.EndSingleUndoOperation();
}
}
}
#pragma warning disable CS0628 // New protected member declared in sealed class
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
#pragma warning restore CS0628 // New protected member declared in sealed class
{
// When initialized asynchronously, the current thread may be a background thread at this point.
// Do any initialization that requires the UI thread after switching to the UI thread.
await this.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
try
{
await SharedRapidXamlPackage.InitializeAsync(cancellationToken, this);
SharedRapidXamlPackage.Logger?.RecordNotice(StringRes.Info_LaunchVersionAnalysis.WithParams(CoreDetails.GetVersion()));
SharedRapidXamlPackage.Logger?.RecordNotice(string.Empty);
await FeedbackCommand.InitializeAsync(this, SharedRapidXamlPackage.Logger);
await MoveAllHardCodedStringsToResourceFileCommand.InitializeAsync(this, SharedRapidXamlPackage.Logger);
await AnalyzeCurrentDocumentCommand.InitializeAsync(this, SharedRapidXamlPackage.Logger);
await OpenAnalysisOptionsCommand.InitializeAsync(this, SharedRapidXamlPackage.Logger);
await this.SetUpRunningDocumentTableEventsAsync(cancellationToken);
RapidXamlDocumentCache.Initialize(this, SharedRapidXamlPackage.Logger);
Microsoft.VisualStudio.Shell.Events.SolutionEvents.OnAfterCloseSolution += this.HandleCloseSolution;
// Handle the ability to resolve assemblies when loading custom analyzers.
// Hat-tip: https://weblog.west-wind.com/posts/2016/dec/12/loading-net-assemblies-out-of-seperate-folders
AppDomain.CurrentDomain.AssemblyResolve += (object sender, ResolveEventArgs args) =>
{
// Ignore missing resources
if (args.Name.Contains(".resources"))
{
return(null);
}
if (args.RequestingAssembly == null)
{
return(null);
}
// check for assemblies already loaded
var assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(a => a.FullName == args.Name);
if (assembly != null)
{
return(assembly);
}
// Try to load by filename - split out the filename of the full assembly name
// and append the base path of the original assembly (ie. look in the same dir)
string filename = args.Name.Split(',')[0] + ".dll".ToLower();
var asmFile = Path.Combine(Path.GetDirectoryName(args.RequestingAssembly.CodeBase), filename);
if (asmFile.StartsWith("file:\\"))
{
asmFile = asmFile.Substring(6);
}
try
{
return(Assembly.LoadFrom(asmFile));
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex);
return(null);
}
};
// Track this so don't try and load CustomAnalyzers while VS is still starting up.
RapidXamlAnalysisPackage.IsLoaded = true;
RapidXamlAnalysisPackage.Options = (AnalysisOptionsGrid)this.GetDialogPage(typeof(AnalysisOptionsGrid));
var ass = Assembly.GetExecutingAssembly().GetName();
SharedRapidXamlPackage.Logger?.RecordFeatureUsage(StringRes.Info_PackageLoad.WithParams(ass.Name, ass.Version), quiet: true);
}
catch (Exception exc)
{
SharedRapidXamlPackage.Logger?.RecordException(exc);
}
}
public override void Execute(CancellationToken cancellationToken)
{
Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread();
var resPath = this.GetResourceFilePath();
if (resPath == null)
{
return;
}
var vs = this.vstm ?? new VisualStudioTextManipulation(ProjectHelpers.Dte);
var undo = vs.StartSingleUndoOperation(StringRes.UI_UndoContextMoveStringToResourceFile);
try
{
if (this.Tag.ProjType == ProjectType.Uwp)
{
// If the resource file is open with unsaved changes VS will prompt about data being lost.
this.AddResource(resPath, $"{this.Tag.UidValue}.{this.Tag.AttributeName}", this.Tag.Value);
if (this.Tag.AttributeType == AttributeType.Inline)
{
var currentAttribute = $"{this.Tag.AttributeName}=\"{this.Tag.Value}\"";
if (this.Tag.UidExists)
{
vs.RemoveInActiveDocOnLine(currentAttribute, this.Tag.GetDesignerLineNumber());
}
else
{
var uidTag = $"x:Uid=\"{this.Tag.UidValue}\"";
vs.ReplaceInActiveDocOnLine(currentAttribute, uidTag, this.Tag.GetDesignerLineNumber());
}
}
else if (this.Tag.AttributeType == AttributeType.Element)
{
var currentAttribute = $"<{this.Tag.ElementName}.{this.Tag.AttributeName}>{this.Tag.Value}</{this.Tag.ElementName}.{this.Tag.AttributeName}>";
vs.RemoveInActiveDocOnLine(currentAttribute, this.Tag.GetDesignerLineNumber());
if (!this.Tag.UidExists)
{
var uidTag = $"<{this.Tag.ElementName} x:Uid=\"{this.Tag.UidValue}\"";
vs.ReplaceInActiveDocOnLineOrAbove($"<{this.Tag.ElementName}", uidTag, this.Tag.GetDesignerLineNumber());
}
}
else if (this.Tag.AttributeType == AttributeType.DefaultValue)
{
var current = $">{this.Tag.Value}</{this.Tag.ElementName}>";
var replaceWith = this.Tag.UidExists ? " />" : $" x:Uid=\"{this.Tag.UidValue}\" />";
vs.ReplaceInActiveDocOnLine(current, replaceWith, this.Tag.GetDesignerLineNumber());
}
}
else if (this.Tag.ProjType == ProjectType.Wpf ||
this.Tag.ProjType == ProjectType.XamarinForms)
{
var resourceName = $"{Path.GetFileNameWithoutExtension(this.Tag.FileName)}{this.Tag.Value}".RemoveNonAlphaNumerics();
this.AddResource(resPath, resourceName, this.Tag.Value);
var resourceNs = this.GetResourceFileNamespace(resPath);
// TODO: Issue#410 determine if XMLNS already exists based on resfile folder
// TODO: Issue#410 convert this to be based on BuiltInAnalyzer so can check for existing xmlns aliases
var xmlns = "properties";
var xmlnsExists = true;
var newAttribute = $"{this.Tag.AttributeName}=\"{{x:Static {xmlns}:{Path.GetFileNameWithoutExtension(resPath)}.{resourceName}}}\"";
switch (this.Tag.AttributeType)
{
case AttributeType.Inline:
var currentAttribute = $"{this.Tag.AttributeName}=\"{this.Tag.Value}\"";
vs.ReplaceInActiveDocOnLine(currentAttribute, newAttribute, this.Tag.GetDesignerLineNumber());
break;
case AttributeType.Element:
var currentElementAttribute = $"<{this.Tag.ElementName}.{this.Tag.AttributeName}>{this.Tag.Value}</{this.Tag.ElementName}.{this.Tag.AttributeName}>";
vs.RemoveInActiveDocOnLine(currentElementAttribute, this.Tag.GetDesignerLineNumber());
var newXaml = $"<{this.Tag.ElementName} {newAttribute}";
vs.ReplaceInActiveDocOnLineOrAbove($"<{this.Tag.ElementName}", newXaml, this.Tag.GetDesignerLineNumber());
break;
case AttributeType.DefaultValue:
var current = $">{this.Tag.Value}</{this.Tag.ElementName}>";
var replaceWith = $" {newAttribute} />";
vs.ReplaceInActiveDocOnLine(current, replaceWith, this.Tag.GetDesignerLineNumber());
break;
}
if (!xmlnsExists)
{
vs.AddXmlnsAliasToActiveDoc(xmlns, $"clr-namespace:{resourceNs}");
}
}
////else if (this.Tag.ProjType == ProjectType.XamarinForms)
////{
//// var resourceName = "NEED TO GENERATE THIS";
//// this.AddResource(resPath, resourceName, this.Tag.Value);
//// // TODO: ISSUE#163 Implement Xamarin.Forms resource creation
//// switch (this.Tag.AttributeType)
//// {
//// case AttributeType.Inline:
//// var currentAttribute = $"{this.Tag.AttributeName}=\"{this.Tag.Value}\"";
//// var localizedAttribute = $"{this.Tag.AttributeName}=\"{{x:Static resources:{System.IO.Path.GetFileNameWithoutExtension(resPath)}.{resourceName}}}\"";
//// vs.ReplaceInActiveDocOnLine(currentAttribute, localizedAttribute, this.Tag.GetDesignerLineNumber());
//// break;
//// case AttributeType.Element:
//// break;
//// case AttributeType.DefaultValue:
//// break;
//// }
////}
RapidXamlDocumentCache.TryUpdate(this.File);
}
finally
{
if (undo)
{
vs.EndSingleUndoOperation();
}
}
}
#pragma warning disable VSTHRD100 // Avoid async void methods - Allowed as called from event handler.
private async void Execute(object sender, EventArgs e)
#pragma warning restore VSTHRD100 // Avoid async void methods
{
System.Windows.Forms.Cursor previousCursor = System.Windows.Forms.Cursor.Current;
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.WaitCursor;
try
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
this.Logger?.RecordFeatureUsage(nameof(MoveAllHardCodedStringsToResourceFileCommand));
var dte = await Instance.AsyncPackage.GetServiceAsync <DTE, DTE>();
var vs = new VisualStudioAbstraction(this.Logger, this.AsyncPackage, dte);
var filePath = vs.GetActiveDocumentFilePath();
// Ensure that the open document has been saved or modifications may go wrong
var rdt = new RunningDocumentTable(Package);
rdt.SaveFileIfDirty(filePath);
// Do this as don't have direct snapshot access and want any changes to be processed before making changes
RapidXamlDocumentCache.TryUpdate(filePath);
var tags = RapidXamlDocumentCache.ErrorListTags(filePath)
.OfType <HardCodedStringTag>()
.OrderByDescending(t => t.Span.Start);
var referenceUids = new Dictionary <Guid, string>();
vs.StartSingleUndoOperation(StringRes.UI_UndoContextMoveStringsToResourceFile);
try
{
foreach (var tag in tags)
{
if (!tag.UidExists && referenceUids.ContainsKey(tag.ElementGuid))
{
tag.UidExists = true;
tag.UidValue = referenceUids[tag.ElementGuid];
}
// pass in vs so have the same reference for tracking undo actions
var action = new HardCodedStringAction(filePath, null, tag, vs);
action.Execute(new CancellationTokenSource().Token);
if (tag.UidExists == false && tag.ElementGuid != Guid.Empty && !referenceUids.ContainsKey(tag.ElementGuid))
{
referenceUids.Add(tag.ElementGuid, tag.UidValue);
}
}
}
finally
{
vs.EndSingleUndoOperation();
}
// Update again to force reflecting the changes that were just made.
RapidXamlDocumentCache.TryUpdate(filePath);
}
catch (Exception exc)
{
this.Logger?.RecordException(exc);
throw;
}
finally
{
System.Windows.Forms.Cursor.Current = previousCursor;
}
}
