public static CodeClassItem MapStruct(VisualBasicSyntax.StructureBlockSyntax member,
ICodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeClassItem>(member, member.StructureStatement.Identifier,
member.StructureStatement.Modifiers, control, semanticModel);
item.Kind = CodeItemKindEnum.Struct;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
item.BorderColor = Colors.DarkGray;
if (TriviaSummaryMapper.HasSummary(member) && SettingsHelper.UseXMLComments)
{
item.Tooltip = TriviaSummaryMapper.Map(member);
}
foreach (var structMember in member.Members)
{
item.Members.Add(SyntaxMapper.MapMember(structMember));
}
return(item);
}
private Grid CreateGridTop(IWpfTextViewHost textViewHost)
{
var grid = new Grid();
grid.RowDefinitions.Add(new RowDefinition
{
Height = new GridLength(0, Settings.Default.ShowMargin ? GridUnitType.Star : GridUnitType.Pixel)
});
grid.RowDefinitions.Add(new RowDefinition());
VSColorTheme.ThemeChanged += VSColorTheme_ThemeChanged;
_control = new CodeViewUserControlTop(_window, grid.RowDefinitions[0],
textViewHost.TextView, _outliningManagerService, _workspace, this, _dte);
Grid.SetRow(_control as UIElement, 0);
Grid.SetRow(textViewHost.HostControl, 1);
// Apply custom background color to CodeNav grid child
(_control as CodeViewUserControlTop).Background =
Settings.Default.WindowBackgroundColor.IsNamedColor && Settings.Default.WindowBackgroundColor.Name.Equals("Transparent")
? Brushes.Transparent : ColorHelper.ToBrush(Settings.Default.WindowBackgroundColor);
return(grid);
}
public static CodeImplementedInterfaceItem MapImplementedInterface(string name,
ImmutableArray <ISymbol> members, INamedTypeSymbol implementingClass, SyntaxNode currentClass,
ICodeViewUserControl control)
{
var item = new CodeImplementedInterfaceItem
{
Name = name,
FullName = name,
Id = name,
ForegroundColor = Colors.Black,
BorderColor = Colors.DarkGray,
FontSize = Settings.Default.Font.SizeInPoints - 2,
Kind = CodeItemKindEnum.ImplementedInterface,
IsExpanded = true,
Control = control
};
foreach (var member in members)
{
var implementation = implementingClass.FindImplementationForInterfaceMember(member);
if (implementation == null || !implementation.DeclaringSyntaxReferences.Any())
{
continue;
}
// Ignore interface members not directly implemented in the current class
if (implementation.ContainingSymbol != implementingClass)
{
continue;
}
// Ignore interface members not directly implemented in the current file (partial class)
if (implementation.DeclaringSyntaxReferences != null &&
implementation.DeclaringSyntaxReferences.Any() &&
implementation.DeclaringSyntaxReferences.First().SyntaxTree.FilePath != currentClass.SyntaxTree.FilePath)
{
continue;
}
var reference = implementation.DeclaringSyntaxReferences.First();
var declarationSyntax = reference.GetSyntax();
var interfaceMember = SyntaxMapper.MapMember(declarationSyntax as MemberDeclarationSyntax);
if (interfaceMember == null)
{
continue;
}
interfaceMember.OverlayMoniker = KnownMonikers.InterfacePublic;
item.Members.Add(interfaceMember);
}
if (item.Members.Any())
{
item.StartLine = item.Members.Min(i => i.StartLine);
item.EndLine = item.Members.Max(i => i.EndLine);
}
return(item);
}
public static T MapBase <T>(Node member, string id, ICodeViewUserControl control) where T : CodeItem
{
var element = Activator.CreateInstance <T>();
var name = string.IsNullOrEmpty(id) ? "anonymous" : id;
element.Name = name;
element.FullName = name;
element.Id = name;
element.Tooltip = name;
element.StartLine = GetLineNumber(member, member.NodeStart);
element.StartLinePosition = new LinePosition(GetLineNumber(member, member.NodeStart), 0);
element.EndLine = GetLineNumber(member, member.End);
element.EndLinePosition = new LinePosition(GetLineNumber(member, member.End), 0);
element.Span = new TextSpan(member.NodeStart, member.End.GetValueOrDefault() - member.NodeStart);
element.ForegroundColor = Colors.Black;
element.Access = CodeItemAccessEnum.Public;
element.FontSize = Settings.Default.Font.SizeInPoints;
element.ParameterFontSize = Settings.Default.Font.SizeInPoints - 1;
element.FontFamily = new FontFamily(Settings.Default.Font.FontFamily.Name);
element.FontStyle = FontStyleMapper.Map(Settings.Default.Font.Style);
element.Control = control;
return(element);
}
public static CodeClassItem MapEnum(EnumDeclarationSyntax member,
ICodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeClassItem>(member, member.Identifier, member.Modifiers, control, semanticModel);
item.Kind = CodeItemKindEnum.Enum;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
item.Parameters = MapMembersToString(member.Members);
item.BorderColor = Colors.DarkGray;
if (TriviaSummaryMapper.HasSummary(member) && SettingsHelper.UseXMLComments)
{
item.Tooltip = TriviaSummaryMapper.Map(member);
}
foreach (var enumMember in member.Members)
{
item.Members.Add(SyntaxMapper.MapMember(enumMember));
}
return(item);
}
public static List <CodeItem> Map(string filePath, ICodeViewUserControl control)
{
_control = control;
var jsString = File.ReadAllText(filePath);
var ast = new TypeScriptAST(jsString, filePath);
return(new List <CodeItem>
{
new CodeNamespaceItem
{
Id = "Namespace" + filePath,
Kind = CodeItemKindEnum.Namespace,
Members = new List <CodeItem>
{
new CodeClassItem
{
Id = filePath,
Kind = CodeItemKindEnum.Class,
Access = CodeItemAccessEnum.Public,
Moniker = IconMapper.MapMoniker(CodeItemKindEnum.Class, CodeItemAccessEnum.Public),
Name = Path.GetFileNameWithoutExtension(filePath),
BorderColor = Colors.DarkGray,
Members = ast.RootNode.Children?.SelectMany(MapMember)?.ToList() ?? new List <CodeItem>()
}
}
}
});
}
public static void SaveToSolutionStorage(ICodeViewUserControl control, CodeDocumentViewModel model)
{
if (string.IsNullOrEmpty(control?.Dte?.Solution?.FileName))
{
return;
}
SaveToSolutionStorage(control?.Dte?.Solution?.FileName, model);
}
private static FrameworkElement GetCodeItemsControl(ICodeViewUserControl control)
{
if (control is CodeViewUserControl)
{
return((control as CodeViewUserControl).CodeItemsControl);
}
return((control as CodeViewUserControlTop).CodeItemsControl);
}
public static CodeItem MapDelegate(VisualBasicSyntax.DelegateStatementSyntax member,
ICodeViewUserControl control, SemanticModel semanticModel)
{
var item = BaseMapper.MapBase <CodeItem>(member, member.Identifier, member.Modifiers, control, semanticModel);
item.Kind = CodeItemKindEnum.Delegate;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
return(item);
}
public static CodeItem MapField(VisualBasicSyntax.FieldDeclarationSyntax member,
ICodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
return(MapField(member, member.Declarators.First().Names.First().Identifier, member.Modifiers, control, semanticModel));
}
public static CodeItem MapEnumMember(VisualBasicSyntax.EnumMemberDeclarationSyntax member,
ICodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeItem>(member, member.Identifier, control, semanticModel);
item.Kind = CodeItemKindEnum.EnumMember;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
return(item);
}
public static CodeItem MapEvent(VisualBasicSyntax.EventBlockSyntax member,
ICodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeItem>(member, member.EventStatement.Identifier,
member.EventStatement.Modifiers, control, semanticModel);
item.Kind = CodeItemKindEnum.Event;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
return(item);
}
public static CodeItem MapEvent(EventFieldDeclarationSyntax member,
ICodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeItem>(member, member.Declaration.Variables.First().Identifier,
member.Modifiers, control, semanticModel);
item.Kind = CodeItemKindEnum.Event;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
return(item);
}
/// <summary>
/// Map the individual cases within a switch statement
/// </summary>
/// <param name="section"></param>
/// <param name="control"></param>
/// <param name="semanticModel"></param>
/// <returns></returns>
private static CodeItem MapSwitchSection(SwitchSectionSyntax section, ICodeViewUserControl control, SemanticModel semanticModel)
{
if (section == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodePropertyItem>(section, section.Labels.First().ToString(), control, semanticModel);
item.Tooltip = TooltipMapper.Map(item.Access, item.Type, item.Name, string.Empty);
item.Id = item.FullName;
item.Kind = CodeItemKindEnum.SwitchSection;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
return(item);
}
public static CodeInterfaceItem MapInterface(VisualBasicSyntax.InterfaceBlockSyntax member,
ICodeViewUserControl control, SemanticModel semanticModel, SyntaxTree tree)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeInterfaceItem>(member, member.InterfaceStatement.Identifier,
member.InterfaceStatement.Modifiers, control, semanticModel);
item.Kind = CodeItemKindEnum.Interface;
item.BorderColor = Colors.DarkGray;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
if (TriviaSummaryMapper.HasSummary(member) && SettingsHelper.UseXMLComments)
{
item.Tooltip = TriviaSummaryMapper.Map(member);
}
var regions = RegionMapper.MapRegions(tree, member.Span, control);
foreach (var interfaceMember in member.Members)
{
var memberItem = SyntaxMapper.MapMember(interfaceMember);
if (memberItem != null && !RegionMapper.AddToRegion(regions, memberItem))
{
item.Members.Add(memberItem);
}
}
// Add regions to interface if they have a region member inside them
if (regions.Any())
{
foreach (var region in regions)
{
if (region.Members.Any())
{
item.Members.Add(region);
}
}
}
return(item);
}
public static CodeNamespaceItem MapNamespace(NamespaceDeclarationSyntax member,
ICodeViewUserControl control, SemanticModel semanticModel, SyntaxTree tree)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeNamespaceItem>(member, member.Name, control, semanticModel);
item.Kind = CodeItemKindEnum.Namespace;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
item.BorderColor = Colors.DarkGray;
item.IgnoreVisibility = VisibilityHelper.GetIgnoreVisibility(item);
if (TriviaSummaryMapper.HasSummary(member) && SettingsHelper.UseXMLComments)
{
item.Tooltip = TriviaSummaryMapper.Map(member);
}
var regions = RegionMapper.MapRegions(tree, member.Span, control);
foreach (var namespaceMember in member.Members)
{
var memberItem = SyntaxMapper.MapMember(namespaceMember);
if (memberItem != null && !RegionMapper.AddToRegion(regions, memberItem))
{
item.Members.Add(memberItem);
}
}
// Add regions to namespace if they are not present in any children of the namespace
if (regions.Any())
{
foreach (var region in regions)
{
if (FindHelper.FindCodeItem(item.Members, region.Id) == null)
{
item.Members.Add(region);
}
}
}
return(item);
}
public static CodeItem MapConstructor(ConstructorDeclarationSyntax member, ICodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeFunctionItem>(member, member.Identifier, member.Modifiers, control, semanticModel);
item.Parameters = ParameterMapper.MapParameters(member.ParameterList);
item.Tooltip = TooltipMapper.Map(item.Access, item.Type, item.Name, member.ParameterList);
item.Id = IdMapper.MapId(member.Identifier, member.ParameterList);
item.Kind = CodeItemKindEnum.Constructor;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
item.OverlayMoniker = KnownMonikers.Add;
return(item);
}
public static CodePropertyItem MapProperty(VisualBasicSyntax.PropertyBlockSyntax member,
ICodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodePropertyItem>(member, member.PropertyStatement.Identifier,
member.PropertyStatement.Modifiers, control, semanticModel);
var symbol = SymbolHelper.GetSymbol <IPropertySymbol>(semanticModel, member);
item.Type = TypeMapper.Map(symbol?.Type);
if (member.Accessors != null)
{
if (member.Accessors.Any(a => a.Kind() == VisualBasic.SyntaxKind.GetAccessorBlock))
{
item.Parameters += "get";
}
if (member.Accessors.Any(a => a.Kind() == VisualBasic.SyntaxKind.SetAccessorBlock))
{
item.Parameters += string.IsNullOrEmpty(item.Parameters) ? "set" : ",set";
}
if (!string.IsNullOrEmpty(item.Parameters))
{
item.Parameters = $" {{{item.Parameters}}}";
}
}
item.Tooltip = TooltipMapper.Map(item.Access, item.Type, item.Name, item.Parameters);
item.Kind = CodeItemKindEnum.Property;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
if (TriviaSummaryMapper.HasSummary(member) && SettingsHelper.UseXMLComments)
{
item.Tooltip = TriviaSummaryMapper.Map(member);
}
return(item);
}
public static CodeItem MapMethod(VisualBasicSyntax.MethodBlockSyntax member, ICodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
CodeItem item;
var statementsCodeItems = StatementMapper.MapStatement(member.Statements, control, semanticModel);
if (VisibilityHelper.ShouldBeVisible(CodeItemKindEnum.Switch) && statementsCodeItems.Any())
{
// Map method as item containing statements
item = BaseMapper.MapBase <CodeClassItem>(member, member.SubOrFunctionStatement.Identifier,
member.SubOrFunctionStatement.Modifiers, control, semanticModel);
((CodeClassItem)item).Members.AddRange(statementsCodeItems);
((CodeClassItem)item).BorderColor = Colors.DarkGray;
}
else
{
// Map method as single item
item = BaseMapper.MapBase <CodeFunctionItem>(member, member.SubOrFunctionStatement.Identifier,
member.SubOrFunctionStatement.Modifiers, control, semanticModel);
var symbol = SymbolHelper.GetSymbol <IMethodSymbol>(semanticModel, member);
((CodeFunctionItem)item).Type = TypeMapper.Map(symbol?.ReturnType);
((CodeFunctionItem)item).Parameters = ParameterMapper.MapParameters(member.SubOrFunctionStatement.ParameterList, semanticModel);
item.Tooltip = TooltipMapper.Map(item.Access, ((CodeFunctionItem)item).Type, item.Name,
member.SubOrFunctionStatement.ParameterList, semanticModel);
}
item.Id = IdMapper.MapId(item.FullName, member.SubOrFunctionStatement.ParameterList, semanticModel);
item.Kind = CodeItemKindEnum.Method;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
if (TriviaSummaryMapper.HasSummary(member) && SettingsHelper.UseXMLComments)
{
item.Tooltip = TriviaSummaryMapper.Map(member);
}
return(item);
}
private static CodeRegionItem MapRegion(SyntaxTrivia source, ICodeViewUserControl control)
{
var name = MapRegionName(source);
return(new CodeRegionItem
{
Name = name,
FullName = name,
Id = name,
Tooltip = name,
StartLine = GetStartLine(source),
StartLinePosition = GetStartLinePosition(source),
ForegroundColor = Colors.Black,
BorderColor = Colors.DarkGray,
FontSize = Settings.Default.Font.SizeInPoints - 2,
Kind = CodeItemKindEnum.Region,
Span = source.Span,
Control = control
});
}
public static CodePropertyItem MapProperty(PropertyDeclarationSyntax member,
ICodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodePropertyItem>(member, member.Identifier, member.Modifiers, control, semanticModel);
item.Type = TypeMapper.Map(member.Type);
if (member.AccessorList != null)
{
if (member.AccessorList.Accessors.Any(a => a.Kind() == SyntaxKind.GetAccessorDeclaration))
{
item.Parameters += "get";
}
if (member.AccessorList.Accessors.Any(a => a.Kind() == SyntaxKind.SetAccessorDeclaration))
{
item.Parameters += string.IsNullOrEmpty(item.Parameters) ? "set" : ",set";
}
if (!string.IsNullOrEmpty(item.Parameters))
{
item.Parameters = $" {{{item.Parameters}}}";
}
}
item.Tooltip = TooltipMapper.Map(item.Access, item.Type, item.Name, item.Parameters);
item.Kind = CodeItemKindEnum.Property;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
if (TriviaSummaryMapper.HasSummary(member) && SettingsHelper.UseXMLComments)
{
item.Tooltip = TriviaSummaryMapper.Map(member);
}
return(item);
}
/// <summary>
/// Map the active document in the workspace
/// </summary>
/// <param name="activeDocument">active EnvDTE.document</param>
/// <param name="control">CodeNav control that will show the result</param>
/// <param name="workspace">Current Visual Studio workspace</param>
/// <returns>List of found code items</returns>
public static async Task <List <CodeItem> > MapDocumentAsync(EnvDTE.Document activeDocument, ICodeViewUserControl control,
VisualStudioWorkspace workspace)
{
_control = control;
if (workspace == null)
{
return(null);
}
try
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var filePath = DocumentHelper.GetFullName(activeDocument);
if (string.IsNullOrEmpty(filePath))
{
return(MapDocument(activeDocument));
}
var id = workspace.CurrentSolution.GetDocumentIdsWithFilePath(filePath).FirstOrDefault();
// We can not find the requested document in the current solution,
// Try and map it in a different way
if (id == null)
{
return(MapDocument(activeDocument));
}
var document = workspace.CurrentSolution.GetDocument(id);
return(await MapDocumentAsync(document));
}
catch (Exception e)
{
LogHelper.Log("Error during mapping", e, null, activeDocument.Language);
return(null);
}
}
public static CodeItem MapIndexer(IndexerDeclarationSyntax member, ICodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeFunctionItem>(member, member.ThisKeyword, member.Modifiers, control, semanticModel);
item.Type = TypeMapper.Map(member.Type);
item.Parameters = ParameterMapper.MapParameters(member.ParameterList);
item.Tooltip = TooltipMapper.Map(item.Access, item.Type, item.Name, item.Parameters);
item.Kind = CodeItemKindEnum.Indexer;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
if (TriviaSummaryMapper.HasSummary(member) && SettingsHelper.UseXMLComments)
{
item.Tooltip = TriviaSummaryMapper.Map(member);
}
return(item);
}
private Grid CreateGridTop(IWpfTextViewHost textViewHost)
{
var grid = new Grid();
grid.RowDefinitions.Add(new RowDefinition
{
Height = new GridLength(0, Settings.Default.ShowMargin ? GridUnitType.Star : GridUnitType.Pixel)
});
grid.RowDefinitions.Add(new RowDefinition());
VSColorTheme.ThemeChanged += VSColorTheme_ThemeChanged;
_control = new CodeViewUserControlTop(_window, grid.RowDefinitions[0],
textViewHost.TextView, _outliningManagerService, _workspace, this, _dte);
//grid.Children.Add(_control as UIElement);
Grid.SetRow(_control as UIElement, 0);
Grid.SetRow(textViewHost.HostControl, 1);
return(grid);
}
private static CodeItem MapField(SyntaxNode member, SyntaxToken identifier, SyntaxTokenList modifiers,
ICodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeItem>(member, identifier, modifiers, control, semanticModel);
item.Kind = IsConstant(modifiers)
? CodeItemKindEnum.Constant
: CodeItemKindEnum.Variable;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
if (TriviaSummaryMapper.HasSummary(member) && SettingsHelper.UseXMLComments)
{
item.Tooltip = TriviaSummaryMapper.Map(member);
}
return(item);
}
/// <summary>
/// Map a switch statement
/// </summary>
/// <param name="statement"></param>
/// <param name="control"></param>
/// <param name="semanticModel"></param>
/// <returns></returns>
private static CodeItem MapSwitch(SwitchStatementSyntax statement, ICodeViewUserControl control, SemanticModel semanticModel)
{
if (statement == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeClassItem>(statement, statement.Expression.ToString(), control, semanticModel);
item.Name = $"Switch {item.Name}";
item.Kind = CodeItemKindEnum.Switch;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
item.BorderColor = Colors.DarkGray;
item.Tooltip = TooltipMapper.Map(item.Access, string.Empty, item.Name, item.Parameters);
// Map switch cases
foreach (var section in statement.Sections)
{
item.Members.Add(MapSwitchSection(section, control, semanticModel));
}
return(item);
}
public static List <CodeItem> MapStatement(StatementSyntax statement, ICodeViewUserControl control, SemanticModel semanticModel)
{
if (statement == null)
{
return(new List <CodeItem>());
}
switch (statement.Kind())
{
case SyntaxKind.SwitchStatement:
return(new List <CodeItem> {
MapSwitch(statement as SwitchStatementSyntax, control, semanticModel)
});
case SyntaxKind.Block:
return(MapStatements((statement as BlockSyntax).Statements, control, semanticModel));
case SyntaxKind.TryStatement:
return(MapStatement((statement as TryStatementSyntax).Block, control, semanticModel));
default:
return(new List <CodeItem>());
}
}
/// <summary>
/// Find all regions in a file and get there start and end line
/// </summary>
/// <param name="tree">SyntaxTree for the given file</param>
/// <param name="span">Start and end line in which we search for regions</param>
/// <returns>Flat list of regions</returns>
public static List <CodeRegionItem> MapRegions(SyntaxTree tree, TextSpan span, ICodeViewUserControl control)
{
var regionList = new List <CodeRegionItem>();
if (tree == null)
{
return(regionList);
}
if (SettingsHelper.FilterRules != null)
{
var filterRule = SettingsHelper.FilterRules.LastOrDefault(f => f.Kind == CodeItemKindEnum.Region || f.Kind == CodeItemKindEnum.All);
if (filterRule != null && filterRule.Ignore)
{
return(regionList);
}
}
var root = tree.GetRoot();
// Find all start points of regions
foreach (var regionDirective in root.DescendantTrivia()
.Where(i => (i.RawKind == (int)SyntaxKind.RegionDirectiveTrivia ||
i.RawKind == (int)VisualBasic.SyntaxKind.RegionDirectiveTrivia) &&
span.Contains(i.Span)))
{
regionList.Add(MapRegion(regionDirective, control));
}
if (!regionList.Any())
{
return(regionList);
}
// Find all matching end points of regions
foreach (var endRegionDirective in root.DescendantTrivia()
.Where(j => (j.RawKind == (int)SyntaxKind.EndRegionDirectiveTrivia ||
j.RawKind == (int)VisualBasic.SyntaxKind.EndRegionDirectiveTrivia) &&
span.Contains(j.Span)))
{
var reg = regionList.LastOrDefault(x => x.StartLine < GetStartLine(endRegionDirective) && x.EndLine == 0);
if (reg != null)
{
reg.EndLine = GetEndLine(endRegionDirective);
reg.EndLinePosition = GetEndLinePosition(endRegionDirective);
}
}
var list = ToHierarchy(regionList, int.MinValue, int.MaxValue);
return(list.Select(r => r as CodeRegionItem).ToList());
}
private Grid CreateGrid(IWpfTextViewHost textViewHost)
{
var marginWidth = Settings.Default.ShowMargin ? Settings.Default.Width : 0;
var leftColumnWidth = new GridLength(marginWidth, GridUnitType.Pixel);
if (Settings.Default.MarginSide != MarginSideEnum.Left)
{
leftColumnWidth = new GridLength(0, GridUnitType.Star);
}
var rightColumnWidth = new GridLength(0, GridUnitType.Star);
if (Settings.Default.MarginSide != MarginSideEnum.Left)
{
rightColumnWidth = new GridLength(marginWidth, GridUnitType.Pixel);
}
var grid = new Grid();
grid.ColumnDefinitions.Add(new ColumnDefinition {
Width = leftColumnWidth
});
grid.ColumnDefinitions.Add(new ColumnDefinition {
Width = new GridLength(5, GridUnitType.Pixel)
});
grid.ColumnDefinitions.Add(new ColumnDefinition {
Width = rightColumnWidth
});
grid.RowDefinitions.Add(new RowDefinition());
var splitter = new GridSplitter
{
Width = 5,
ResizeDirection = GridResizeDirection.Columns,
VerticalAlignment = VerticalAlignment.Stretch,
HorizontalAlignment = HorizontalAlignment.Stretch,
Background = ColorHelper.ToBrush(EnvironmentColors.EnvironmentBackgroundColorKey),
ToolTip = "What you can do with this bar:" + Environment.NewLine +
"- double-click it to toggle CodeNav visibility" + Environment.NewLine +
"- click and drag it to adjust CodeNav width"
};
VSColorTheme.ThemeChanged += VSColorTheme_ThemeChanged;
splitter.DragCompleted += DragCompleted;
splitter.MouseDoubleClick += Splitter_MouseDoubleClick;
grid.Children.Add(splitter);
var columnIndex = Settings.Default.MarginSide == MarginSideEnum.Left ? 0 : 2;
_control = new CodeViewUserControl(_window, grid.ColumnDefinitions[columnIndex],
textViewHost.TextView, _outliningManagerService, _workspace, this, _dte);
grid.Children.Add(_control as UIElement);
Grid.SetColumn(_control as UIElement, columnIndex);
Grid.SetColumn(splitter, 1);
Grid.SetColumn(textViewHost.HostControl, Settings.Default.MarginSide == MarginSideEnum.Left ? 2 : 0);
if (Settings.Default.WindowBackgroundColor.IsNamedColor && Settings.Default.WindowBackgroundColor.Name.Equals("Transparent"))
{
grid.GetGridChildByType <CodeViewUserControl>().Background = Brushes.Transparent;
}
else
{
grid.GetGridChildByType <CodeViewUserControl>().Background = ColorHelper.ToBrush(Settings.Default.WindowBackgroundColor);
}
return(grid);
}
public static List <CodeItem> Map(Document document, ICodeViewUserControl control) => Map(document.FilePath, control);
