├── README.md
├── Blazm.VSIX
    ├── Resources
    │   └── RoutingToolWindowCommand.png
    ├── Routing
    │   ├── RoutingItem.cs
    │   ├── RoutingWindow.cs
    │   ├── RoutingWindowControl.xaml
    │   ├── ProvideToolboxControlAttribute.cs
    │   ├── RoutingWindowControl.xaml.cs
    │   └── RoutingWindowCommand.cs
    ├── Properties
    │   └── AssemblyInfo.cs
    ├── source.extension.vsixmanifest
    ├── BlazmVSIX.sln
    ├── BlazmVSIXPackage.cs
    ├── BlazmVSIXPackage.vsct
    └── BlazmVSIX.csproj
└── .gitignore


/README.md:
--------------------------------------------------------------------------------
1 | # Blazm.VSIX
2 | VS Extension 
3 | 


--------------------------------------------------------------------------------
/Blazm.VSIX/Resources/RoutingToolWindowCommand.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/EngstromJimmy/Blazm.VSIX/main/Blazm.VSIX/Resources/RoutingToolWindowCommand.png


--------------------------------------------------------------------------------
/Blazm.VSIX/Routing/RoutingItem.cs:
--------------------------------------------------------------------------------
 1 | namespace BlazmVSIX
 2 | {
 3 |     public partial class RoutingWindowControl
 4 |     {
 5 |         public class RoutingItem
 6 |         {
 7 |             public string Name { get; set; }
 8 |             public string Content { get; set; }
 9 |         }
10 |     }
11 | }


--------------------------------------------------------------------------------
/Blazm.VSIX/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using System.Runtime.InteropServices;
 4 | 
 5 | // General Information about an assembly is controlled through the following 
 6 | // set of attributes. Change these attribute values to modify the information
 7 | // associated with an assembly.
 8 | [assembly: AssemblyTitle("BlazmVSIX")]
 9 | [assembly: AssemblyDescription("")]
10 | [assembly: AssemblyConfiguration("")]
11 | [assembly: AssemblyCompany("")]
12 | [assembly: AssemblyProduct("BlazmVSIX")]
13 | [assembly: AssemblyCopyright("")]
14 | [assembly: AssemblyTrademark("")]
15 | [assembly: AssemblyCulture("")]
16 | 
17 | // Setting ComVisible to false makes the types in this assembly not visible 
18 | // to COM components.  If you need to access a type in this assembly from 
19 | // COM, set the ComVisible attribute to true on that type.
20 | [assembly: ComVisible(false)]
21 | 
22 | // Version information for an assembly consists of the following four values:
23 | //
24 | //      Major Version
25 | //      Minor Version 
26 | //      Build Number
27 | //      Revision
28 | //
29 | // You can specify all the values or you can default the Build and Revision Numbers 
30 | // by using the '*' as shown below:
31 | // [assembly: AssemblyVersion("1.0.*")]
32 | [assembly: AssemblyVersion("1.0.0.0")]
33 | [assembly: AssemblyFileVersion("1.0.0.0")]
34 | 


--------------------------------------------------------------------------------
/Blazm.VSIX/Routing/RoutingWindow.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.VisualStudio.Shell;
 2 | using System;
 3 | using System.Runtime.InteropServices;
 4 | 
 5 | namespace BlazmVSIX
 6 | {
 7 |     /// <summary>
 8 |     /// This class implements the tool window exposed by this package and hosts a user control.
 9 |     /// </summary>
10 |     /// <remarks>
11 |     /// In Visual Studio tool windows are composed of a frame (implemented by the shell) and a pane,
12 |     /// usually implemented by the package implementer.
13 |     /// <para>
14 |     /// This class derives from the ToolWindowPane class provided from the MPF in order to use its
15 |     /// implementation of the IVsUIElementPane interface.
16 |     /// </para>
17 |     /// </remarks>
18 |     [Guid("eb70ef4f-9898-4e9d-91c3-419ef679d727")]
19 |     public class RoutingWindow : ToolWindowPane
20 |     {
21 |         /// <summary>
22 |         /// Initializes a new instance of the <see cref="RoutingWindow"/> class.
23 |         /// </summary>
24 |         public RoutingWindow() : base(null)
25 |         {
26 |             this.Caption = "Blazm - Routing";
27 | 
28 |             // This is the user control hosted by the tool window; Note that, even if this class implements IDisposable,
29 |             // we are not calling Dispose on this object. This is because ToolWindowPane calls Dispose on
30 |             // the object returned by the Content property.
31 |             this.Content = new RoutingWindowControl();
32 |         }
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/Blazm.VSIX/source.extension.vsixmanifest:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <PackageManifest Version="2.0.0" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2011" xmlns:d="http://schemas.microsoft.com/developer/vsx-schema-design/2011">
 3 |     <Metadata>
 4 |         <Identity Id="BlazmVSIX.dd6815f2-ff03-4609-9a7b-994eae3ce30f" Version="1.0" Language="en-US" Publisher="Johan Sköldekrans" />
 5 |         <DisplayName>Blazm Extensions</DisplayName>
 6 |         <Description xml:space="preserve">Extensions for Blazor development</Description>
 7 |     </Metadata>
 8 |     <Installation>
 9 |         <InstallationTarget Id="Microsoft.VisualStudio.Community" Version="[17.0, 18.0)">
10 |             <ProductArchitecture>amd64</ProductArchitecture>
11 |         </InstallationTarget>
12 |     </Installation>
13 |     <Dependencies>
14 |         <Dependency Id="Microsoft.Framework.NDP" DisplayName="Microsoft .NET Framework" d:Source="Manual" Version="[4.5,)" />
15 |     </Dependencies>
16 |     <Prerequisites>
17 |         <Prerequisite Id="Microsoft.VisualStudio.Component.CoreEditor" Version="[17.0,18.0)" DisplayName="Visual Studio core editor" />
18 |     </Prerequisites>
19 |     <Assets>
20 |         <Asset Type="Microsoft.VisualStudio.VsPackage" d:Source="Project" d:ProjectName="%CurrentProject%" Path="|%CurrentProject%;PkgdefProjectOutputGroup|" />
21 |       <Asset Type="Microsoft.VisualStudio.ToolboxControl" d:Source="Project" d:ProjectName="%CurrentProject%" Path="|%CurrentProject%;PkgdefProjectOutputGroup|" />
22 |   </Assets>
23 | </PackageManifest>
24 | 


--------------------------------------------------------------------------------
/Blazm.VSIX/BlazmVSIX.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 17
 4 | VisualStudioVersion = 17.0.31521.260
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BlazmVSIX", "BlazmVSIX.csproj", "{DE01275C-F8A7-40AF-AAA3-F77CDE045D62}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|Any CPU = Debug|Any CPU
11 | 		Debug|x86 = Debug|x86
12 | 		Release|Any CPU = Release|Any CPU
13 | 		Release|x86 = Release|x86
14 | 	EndGlobalSection
15 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
16 | 		{DE01275C-F8A7-40AF-AAA3-F77CDE045D62}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
17 | 		{DE01275C-F8A7-40AF-AAA3-F77CDE045D62}.Debug|Any CPU.Build.0 = Debug|Any CPU
18 | 		{DE01275C-F8A7-40AF-AAA3-F77CDE045D62}.Debug|x86.ActiveCfg = Debug|x86
19 | 		{DE01275C-F8A7-40AF-AAA3-F77CDE045D62}.Debug|x86.Build.0 = Debug|x86
20 | 		{DE01275C-F8A7-40AF-AAA3-F77CDE045D62}.Release|Any CPU.ActiveCfg = Release|Any CPU
21 | 		{DE01275C-F8A7-40AF-AAA3-F77CDE045D62}.Release|Any CPU.Build.0 = Release|Any CPU
22 | 		{DE01275C-F8A7-40AF-AAA3-F77CDE045D62}.Release|x86.ActiveCfg = Release|x86
23 | 		{DE01275C-F8A7-40AF-AAA3-F77CDE045D62}.Release|x86.Build.0 = Release|x86
24 | 	EndGlobalSection
25 | 	GlobalSection(SolutionProperties) = preSolution
26 | 		HideSolutionNode = FALSE
27 | 	EndGlobalSection
28 | 	GlobalSection(ExtensibilityGlobals) = postSolution
29 | 		SolutionGuid = {270E9D5F-8F71-470C-934A-F2109B7F0A5C}
30 | 	EndGlobalSection
31 | EndGlobal
32 | 


--------------------------------------------------------------------------------
/Blazm.VSIX/Routing/RoutingWindowControl.xaml:
--------------------------------------------------------------------------------
 1 | <UserControl x:Class="BlazmVSIX.RoutingWindowControl"
 2 |              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
 5 |              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
 6 |              xmlns:vsshell="clr-namespace:Microsoft.VisualStudio.Shell;assembly=Microsoft.VisualStudio.Shell.15.0"
 7 |              Background="{DynamicResource {x:Static vsshell:VsBrushes.WindowKey}}"
 8 |              Foreground="{DynamicResource {x:Static vsshell:VsBrushes.WindowTextKey}}"
 9 |              mc:Ignorable="d"
10 |              d:DesignHeight="300" d:DesignWidth="300"
11 |              Name="MyToolWindow">
12 |     <Grid>
13 |         <Grid.RowDefinitions>
14 |             <RowDefinition Height="60" />
15 |             <RowDefinition Height="*" />
16 |         </Grid.RowDefinitions>
17 |         <StackPanel Orientation="Vertical" Grid.Row="0">
18 |             <TextBlock Margin="10" HorizontalAlignment="Center">Blazm - Routing</TextBlock>
19 |             <Button Content="Refresh" Name="RefreshButton" Click="RefreshButton_Click"/>
20 |         </StackPanel>
21 |         <DataGrid Name="RoutingGrid" 
22 |                     AutoGenerateColumns="false" 
23 |                     ScrollViewer.CanContentScroll="True" 
24 |                     ScrollViewer.HorizontalScrollBarVisibility="Auto" 
25 |                     ScrollViewer.VerticalScrollBarVisibility="Auto"
26 |                     MouseDoubleClick="RoutingGrid_MouseDoubleClick"
27 |                     Grid.Row="1"
28 |                     >
29 |             <DataGrid.Columns>
30 |                 <DataGridTextColumn Binding="{Binding Content}" Header="Routing" IsReadOnly="True"></DataGridTextColumn>
31 |             </DataGrid.Columns>
32 |         </DataGrid>
33 |     </Grid>
34 | </UserControl>
35 | 


--------------------------------------------------------------------------------
/Blazm.VSIX/BlazmVSIXPackage.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.VisualStudio.Shell;
 2 | using System;
 3 | using System.Runtime.InteropServices;
 4 | using System.Threading;
 5 | using Task = System.Threading.Tasks.Task;
 6 | 
 7 | namespace BlazmVSIX
 8 | {
 9 |     /// <summary>
10 |     /// This is the class that implements the package exposed by this assembly.
11 |     /// </summary>
12 |     /// <remarks>
13 |     /// <para>
14 |     /// The minimum requirement for a class to be considered a valid package for Visual Studio
15 |     /// is to implement the IVsPackage interface and register itself with the shell.
16 |     /// This package uses the helper classes defined inside the Managed Package Framework (MPF)
17 |     /// to do it: it derives from the Package class that provides the implementation of the
18 |     /// IVsPackage interface and uses the registration attributes defined in the framework to
19 |     /// register itself and its components with the shell. These attributes tell the pkgdef creation
20 |     /// utility what data to put into .pkgdef file.
21 |     /// </para>
22 |     /// <para>
23 |     /// To get loaded into VS, the package must be referred by &lt;Asset Type="Microsoft.VisualStudio.VsPackage" ...&gt; in .vsixmanifest file.
24 |     /// </para>
25 |     /// </remarks>
26 |     [PackageRegistration(UseManagedResourcesOnly = true, AllowsBackgroundLoading = true)]
27 |     [Guid(BlazmVSIXPackage.PackageGuidString)]
28 |     [ProvideMenuResource("Menus.ctmenu", 1)]
29 |     [ProvideToolWindow(typeof(RoutingWindow))]
30 |     public sealed class BlazmVSIXPackage : AsyncPackage
31 |     {
32 |         /// <summary>
33 |         /// BlazmVSIXPackage GUID string.
34 |         /// </summary>
35 |         public const string PackageGuidString = "e0e3ae8f-2521-42c7-b145-9a46df34f9bc";
36 | 
37 |         #region Package Members
38 | 
39 |         /// <summary>
40 |         /// Initialization of the package; this method is called right after the package is sited, so this is the place
41 |         /// where you can put all the initialization code that rely on services provided by VisualStudio.
42 |         /// </summary>
43 |         /// <param name="cancellationToken">A cancellation token to monitor for initialization cancellation, which can occur when VS is shutting down.</param>
44 |         /// <param name="progress">A provider for progress updates.</param>
45 |         /// <returns>A task representing the async work of package initialization, or an already completed task if there is none. Do not return null from this method.</returns>
46 |         protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress<ServiceProgressData> progress)
47 |         {
48 |             // When initialized asynchronously, the current thread may be a background thread at this point.
49 |             // Do any initialization that requires the UI thread after switching to the UI thread.
50 |             await this.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
51 |             await RoutingWindowCommand.InitializeAsync(this);
52 |         }
53 | 
54 |         #endregion
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/Blazm.VSIX/Routing/ProvideToolboxControlAttribute.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.VisualStudio.Shell;
 2 | using System;
 3 | using System.Globalization;
 4 | using System.Runtime.InteropServices;
 5 | 
 6 | namespace BlazmVSIX
 7 | {
 8 |     /// <summary>
 9 |     /// This attribute adds a ToolboxControlsInstaller key for the assembly to install toolbox controls from the assembly.
10 |     /// </summary>
11 |     /// <remarks>
12 |     /// For example
13 |     ///     [$(Rootkey)\ToolboxControlsInstaller\$FullAssemblyName$]
14 |     ///         "Codebase"="$path$"
15 |     ///         "WpfControls"="1"
16 |     /// </remarks>
17 |     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
18 |     [ComVisible(false)]
19 |     public sealed class ProvideToolboxControlAttribute : RegistrationAttribute
20 |     {
21 |         private const string ToolboxControlsInstallerPath = "ToolboxControlsInstaller";
22 |         private readonly string name;
23 |         private readonly bool areWPFControls;
24 | 
25 |         /// <summary>
26 |         /// Creates a new ProvideToolboxControl attribute to register the assembly for toolbox controls installer.
27 |         /// </summary>
28 |         /// <param name="name">The name of the toolbox controls.</param>
29 |         /// <param name="areWPFControls">Indicates whether the toolbox controls are WPF controls.</param>
30 |         public ProvideToolboxControlAttribute(string name, bool areWPFControls)
31 |         {
32 |             this.name = name ?? throw new ArgumentNullException(nameof(name));
33 |             this.areWPFControls = areWPFControls;
34 |         }
35 | 
36 |         /// <summary>
37 |         /// Called to register this attribute with the given context. The context
38 |         /// contains the location where the registration information should be placed.
39 |         /// It also contains other information such as the type being registered and path information.
40 |         /// </summary>
41 |         /// <param name="context">Given context to register in.</param>
42 |         public override void Register(RegistrationContext context)
43 |         {
44 |             if (context == null)
45 |             {
46 |                 throw new ArgumentNullException(nameof(context));
47 |             }
48 | 
49 |             using (Key key = context.CreateKey(string.Format(CultureInfo.InvariantCulture, "{0}\\{1}",
50 |                                                              ToolboxControlsInstallerPath,
51 |                                                              context.ComponentType.Assembly.FullName)))
52 |             {
53 |                 key.SetValue(string.Empty, this.name);
54 |                 key.SetValue("Codebase", context.CodeBase);
55 |                 if (this.areWPFControls)
56 |                 {
57 |                     key.SetValue("WPFControls", "1");
58 |                 }
59 |             }
60 |         }
61 | 
62 |         /// <summary>
63 |         /// Called to unregister this attribute with the given context.
64 |         /// </summary>
65 |         /// <param name="context">A registration context provided by an external registration tool. 
66 |         /// The context can be used to remove registry keys, log registration activity, and obtain information
67 |         /// about the component being registered.</param>
68 |         public override void Unregister(RegistrationContext context)
69 |         {
70 |             if (context != null)
71 |             {
72 |                 context.RemoveKey(string.Format(CultureInfo.InvariantCulture, "{0}\\{1}",
73 |                                                              ToolboxControlsInstallerPath,
74 |                                                              context.ComponentType.Assembly.FullName));
75 |             }
76 |         }
77 |     }
78 | }
79 | 


--------------------------------------------------------------------------------
/Blazm.VSIX/Routing/RoutingWindowControl.xaml.cs:
--------------------------------------------------------------------------------
 1 | using EnvDTE;
 2 | using Microsoft.VisualStudio.Package;
 3 | using Microsoft.VisualStudio.Shell;
 4 | using Microsoft.VisualStudio.Shell.Interop;
 5 | using System;
 6 | using System.Collections.Generic;
 7 | using System.Collections.ObjectModel;
 8 | using System.Diagnostics.CodeAnalysis;
 9 | using System.IO;
10 | using System.Windows;
11 | using System.Windows.Controls;
12 | 
13 | namespace BlazmVSIX
14 | {
15 |     public partial class RoutingWindowControl : UserControl
16 |     {
17 |         public RoutingWindowControl()
18 |         {
19 |             InitializeComponent();
20 |             ThreadHelper.ThrowIfNotOnUIThread();
21 |             if (ServiceProvider.GlobalProvider.GetService(typeof(DTE)) is DTE service)
22 |             {
23 |                 dte = service;
24 |                 Load();
25 |             }
26 |         }
27 | 
28 |         private readonly DTE dte;
29 | 
30 |         private void Load()
31 |         {
32 |             ThreadHelper.ThrowIfNotOnUIThread();
33 |             Array _projects = dte.ActiveSolutionProjects as Array;
34 |             RoutingDataList.Clear();
35 |             if (_projects.Length != 0 && _projects != null)
36 |             {
37 |                 foreach (Project project in _projects)
38 |                 {
39 |                     //get the project path
40 |                     string _directoryPath = new FileInfo(project.FullName).DirectoryName;
41 |                     string rowText;
42 |                     string[] razorFiles = Directory.GetFiles(_directoryPath,"*.razor", SearchOption.AllDirectories);
43 | 
44 |                     foreach (string file in razorFiles)
45 |                     {
46 |                         using (StreamReader sr = new StreamReader(file))
47 |                         {
48 |                             int row = 0;
49 |                             while (sr.Peek() >= 0)
50 |                             {
51 |                                 rowText = sr.ReadLine();
52 | 
53 |                                 if (rowText.Contains("@page") && !rowText.StartsWith("@*"))
54 |                                 {
55 |                                     string content = rowText.Replace("@page", "").Replace("\"", "").Trim();
56 |                                     RoutingDataList.Add(new RoutingItem() { Name = file, Content = content });
57 |                                 }
58 |                                 else if (row > 5)
59 |                                 {
60 |                                     break;
61 |                                 }
62 | 
63 |                                 row++;
64 |                             }
65 |                         }
66 |                         
67 |                     }
68 |                 }
69 |             }
70 |             else
71 |             {
72 |                 RoutingDataList.Add(new RoutingItem() { Name = "No Project in solution or selected" });
73 |             }
74 |             RoutingGrid.ItemsSource = RoutingDataList;
75 |         }
76 | 
77 |         public ObservableCollection<RoutingItem> RoutingDataList { get; set; } = new ObservableCollection<RoutingItem>();
78 | 
79 |         private void RefreshButton_Click(object sender, RoutedEventArgs e)
80 |         {
81 |             Load();
82 |         }
83 | 
84 |         private void RoutingGrid_MouseDoubleClick(object sender, System.Windows.Input.MouseButtonEventArgs e)
85 |         {
86 |             if (!(ItemsControl.ContainerFromElement((DataGrid)sender, e.OriginalSource as DependencyObject) is DataGridRow row))
87 |             {
88 |                 return;
89 |             }
90 | 
91 |             RoutingItem item = (RoutingItem)row.DataContext;
92 |             ThreadHelper.ThrowIfNotOnUIThread();
93 |             _ = dte.ItemOperations.OpenFile(item.Name);
94 |         }
95 |     }
96 | }


--------------------------------------------------------------------------------
/Blazm.VSIX/Routing/RoutingWindowCommand.cs:
--------------------------------------------------------------------------------
  1 | using Microsoft.VisualStudio.Shell;
  2 | using Microsoft.VisualStudio.Shell.Interop;
  3 | using System;
  4 | using System.ComponentModel.Design;
  5 | using System.Globalization;
  6 | using System.Threading;
  7 | using System.Threading.Tasks;
  8 | using Task = System.Threading.Tasks.Task;
  9 | 
 10 | namespace BlazmVSIX
 11 | {
 12 |     /// <summary>
 13 |     /// Command handler
 14 |     /// </summary>
 15 |     internal sealed class RoutingWindowCommand
 16 |     {
 17 |         /// <summary>
 18 |         /// Command ID.
 19 |         /// </summary>
 20 |         public const int CommandId = 0x0100;
 21 | 
 22 |         /// <summary>
 23 |         /// Command menu group (command set GUID).
 24 |         /// </summary>
 25 |         public static readonly Guid CommandSet = new Guid("17f2c6c7-f807-45b9-95a2-8340b71128c4");
 26 | 
 27 |         /// <summary>
 28 |         /// VS Package that provides this command, not null.
 29 |         /// </summary>
 30 |         private readonly AsyncPackage package;
 31 | 
 32 |         /// <summary>
 33 |         /// Initializes a new instance of the <see cref="RoutingWindowCommand"/> class.
 34 |         /// Adds our command handlers for menu (commands must exist in the command table file)
 35 |         /// </summary>
 36 |         /// <param name="package">Owner package, not null.</param>
 37 |         /// <param name="commandService">Command service to add command to, not null.</param>
 38 |         private RoutingWindowCommand(AsyncPackage package, OleMenuCommandService commandService)
 39 |         {
 40 |             this.package = package ?? throw new ArgumentNullException(nameof(package));
 41 |             commandService = commandService ?? throw new ArgumentNullException(nameof(commandService));
 42 | 
 43 |             var menuCommandID = new CommandID(CommandSet, CommandId);
 44 |             var menuItem = new MenuCommand(this.Execute, menuCommandID);
 45 |             commandService.AddCommand(menuItem);
 46 |         }
 47 | 
 48 |         /// <summary>
 49 |         /// Gets the instance of the command.
 50 |         /// </summary>
 51 |         public static RoutingWindowCommand Instance
 52 |         {
 53 |             get;
 54 |             private set;
 55 |         }
 56 | 
 57 |         /// <summary>
 58 |         /// Gets the service provider from the owner package.
 59 |         /// </summary>
 60 |         private Microsoft.VisualStudio.Shell.IAsyncServiceProvider ServiceProvider
 61 |         {
 62 |             get
 63 |             {
 64 |                 return this.package;
 65 |             }
 66 |         }
 67 | 
 68 |         /// <summary>
 69 |         /// Initializes the singleton instance of the command.
 70 |         /// </summary>
 71 |         /// <param name="package">Owner package, not null.</param>
 72 |         public static async Task InitializeAsync(AsyncPackage package)
 73 |         {
 74 |             // Switch to the main thread - the call to AddCommand in ToolWindow1Command's constructor requires
 75 |             // the UI thread.
 76 |             await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(package.DisposalToken);
 77 | 
 78 |             OleMenuCommandService commandService = await package.GetServiceAsync(typeof(IMenuCommandService)) as OleMenuCommandService;
 79 |             Instance = new RoutingWindowCommand(package, commandService);
 80 |         }
 81 | 
 82 |         /// <summary>
 83 |         /// Shows the tool window when the menu item is clicked.
 84 |         /// </summary>
 85 |         /// <param name="sender">The event sender.</param>
 86 |         /// <param name="e">The event args.</param>
 87 |         private void Execute(object sender, EventArgs e)
 88 |         {
 89 |             ThreadHelper.ThrowIfNotOnUIThread();
 90 | 
 91 |             // Get the instance number 0 of this tool window. This window is single instance so this instance
 92 |             // is actually the only one.
 93 |             // The last flag is set to true so that if the tool window does not exists it will be created.
 94 |             ToolWindowPane window = this.package.FindToolWindow(typeof(RoutingWindow), 0, true);
 95 |             if ((null == window) || (null == window.Frame))
 96 |             {
 97 |                 throw new NotSupportedException("Cannot create tool window");
 98 |             }
 99 | 
100 |             IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame;
101 |             Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show());
102 |         }
103 |     }
104 | }
105 | 


--------------------------------------------------------------------------------
/Blazm.VSIX/BlazmVSIXPackage.vsct:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <CommandTable xmlns="http://schemas.microsoft.com/VisualStudio/2005-10-18/CommandTable" xmlns:xs="http://www.w3.org/2001/XMLSchema">
 3 | 
 4 |   <!--  This is the file that defines the actual layout and type of the commands.
 5 |         It is divided in different sections (e.g. command definition, command
 6 |         placement, ...), with each defining a specific set of properties.
 7 |         See the comment before each section for more details about how to
 8 |         use it. -->
 9 | 
10 |   <!--  The VSCT compiler (the tool that translates this file into the binary
11 |         format that VisualStudio will consume) has the ability to run a preprocessor
12 |         on the vsct file; this preprocessor is (usually) the C++ preprocessor, so
13 |         it is possible to define includes and macros with the same syntax used
14 |         in C++ files. Using this ability of the compiler here, we include some files
15 |         defining some of the constants that we will use inside the file. -->
16 | 
17 |   <!--This is the file that defines the IDs for all the commands exposed by VisualStudio. -->
18 |   <Extern href="stdidcmd.h"/>
19 | 
20 |   <!--This header contains the command ids for the menus provided by the shell. -->
21 |   <Extern href="vsshlids.h"/>
22 | 
23 |   <!--The Commands section is where commands, menus, and menu groups are defined.
24 |       This section uses a Guid to identify the package that provides the command defined inside it. -->
25 |   <Commands package="guidBlazmPackage">
26 | 
27 |     <Menus>
28 |       <Menu guid="guidBlazmPackageCmdSet" id="TopLevelMenu" priority="0x700" type="Menu">
29 |         <Parent guid="guidSHLMainMenu" id="IDG_VS_MM_TOOLSADDINS" />
30 |         <Strings>
31 |           <ButtonText>Blazm</ButtonText>
32 |           <CommandName>Blazm</CommandName>
33 |         </Strings>
34 |       </Menu>
35 |     </Menus>
36 | 
37 |     <Groups>
38 |       <Group guid="guidBlazmPackageCmdSet" id="MyMenuGroup" priority="0x0600">
39 |         <Parent guid="guidBlazmPackageCmdSet" id="TopLevelMenu" />
40 |       </Group>
41 |     </Groups>
42 | 
43 |     <!--Buttons section. -->
44 |     <!--This section defines the elements the user can interact with, like a menu command or a button
45 |         or combo box in a toolbar. -->
46 |     <Buttons>
47 |       <Button guid="guidBlazmPackageCmdSet" id="ToolWindow1CommandId" priority="0x0100" type="Button">
48 |         <Parent guid="guidBlazmPackageCmdSet" id="MyMenuGroup"/>
49 |         <Icon guid="guidImages" id="bmpPic1" />
50 |         <Strings>
51 |           <ButtonText>Blazor Routing</ButtonText>
52 |         </Strings>
53 |       </Button>
54 |       
55 |     </Buttons>
56 | 
57 |     <!--The bitmaps section is used to define the bitmaps that are used for the commands.-->
58 |     <Bitmaps>
59 |       <!--  The bitmap id is defined in a way that is a little bit different from the others:
60 |             the declaration starts with a guid for the bitmap strip, then there is the resource id of the
61 |             bitmap strip containing the bitmaps and then there are the numeric ids of the elements used
62 |             inside a button definition. An important aspect of this declaration is that the element id
63 |             must be the actual index (1-based) of the bitmap inside the bitmap strip. -->
64 |       <Bitmap guid="guidImages" href="Resources\RoutingToolWindowCommand.png" usedList="bmpPic1, bmpPic2, bmpPicSearch, bmpPicX, bmpPicArrows, bmpPicStrikethrough"/>
65 |     </Bitmaps>
66 |   </Commands>
67 | 
68 |   <Symbols>
69 |     <!-- This is the package guid. -->
70 |     <GuidSymbol name="guidBlazmPackage" value="{e0e3ae8f-2521-42c7-b145-9a46df34f9bc}" />
71 | 
72 |     <!-- This is the guid used to group the menu commands together -->
73 |     <GuidSymbol name="guidBlazmPackageCmdSet" value="{17f2c6c7-f807-45b9-95a2-8340b71128c4}">
74 |       <IDSymbol name="ToolWindow1CommandId" value="0x0100" />
75 |       <IDSymbol name="MyMenuGroup" value="0x1020" />
76 |       <IDSymbol name="TopLevelMenu" value="0x1021" />
77 |     </GuidSymbol>
78 | 
79 |     <GuidSymbol name="guidImages" value="{3bcfbdf4-ebe8-4fa3-9bcc-f5d4aff77223}" >
80 |       <IDSymbol name="bmpPic1" value="1" />
81 |       <IDSymbol name="bmpPic2" value="2" />
82 |       <IDSymbol name="bmpPicSearch" value="3" />
83 |       <IDSymbol name="bmpPicX" value="4" />
84 |       <IDSymbol name="bmpPicArrows" value="5" />
85 |       <IDSymbol name="bmpPicStrikethrough" value="6" />
86 |     </GuidSymbol>
87 |   </Symbols>
88 | </CommandTable>
89 | 


--------------------------------------------------------------------------------
/Blazm.VSIX/BlazmVSIX.csproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <PropertyGroup>
  4 |     <MinimumVisualStudioVersion>17.0</MinimumVisualStudioVersion>
  5 |     <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
  6 |   </PropertyGroup>
  7 |   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  8 |   <PropertyGroup>
  9 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
 10 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
 11 |     <SchemaVersion>2.0</SchemaVersion>
 12 |     <ProjectTypeGuids>{82b43b9b-a64c-4715-b499-d71e9ca2bd60};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
 13 |     <ProjectGuid>{DE01275C-F8A7-40AF-AAA3-F77CDE045D62}</ProjectGuid>
 14 |     <OutputType>Library</OutputType>
 15 |     <AppDesignerFolder>Properties</AppDesignerFolder>
 16 |     <RootNamespace>BlazmVSIX</RootNamespace>
 17 |     <AssemblyName>BlazmVSIX</AssemblyName>
 18 |     <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
 19 |     <GeneratePkgDefFile>true</GeneratePkgDefFile>
 20 |     <UseCodebase>true</UseCodebase>
 21 |     <IncludeAssemblyInVSIXContainer>true</IncludeAssemblyInVSIXContainer>
 22 |     <IncludeDebugSymbolsInVSIXContainer>false</IncludeDebugSymbolsInVSIXContainer>
 23 |     <IncludeDebugSymbolsInLocalVSIXDeployment>false</IncludeDebugSymbolsInLocalVSIXDeployment>
 24 |     <CopyBuildOutputToOutputDirectory>true</CopyBuildOutputToOutputDirectory>
 25 |     <CopyOutputSymbolsToOutputDirectory>true</CopyOutputSymbolsToOutputDirectory>
 26 |     <StartAction>Program</StartAction>
 27 |     <StartProgram Condition="'$(DevEnvDir)' != ''">$(DevEnvDir)devenv.exe</StartProgram>
 28 |     <StartArguments>/rootsuffix Exp</StartArguments>
 29 |   </PropertyGroup>
 30 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
 31 |     <DebugSymbols>true</DebugSymbols>
 32 |     <DebugType>full</DebugType>
 33 |     <Optimize>false</Optimize>
 34 |     <OutputPath>bin\Debug\</OutputPath>
 35 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 36 |     <ErrorReport>prompt</ErrorReport>
 37 |     <WarningLevel>4</WarningLevel>
 38 |   </PropertyGroup>
 39 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
 40 |     <DebugType>pdbonly</DebugType>
 41 |     <Optimize>true</Optimize>
 42 |     <OutputPath>bin\Release\</OutputPath>
 43 |     <DefineConstants>TRACE</DefineConstants>
 44 |     <ErrorReport>prompt</ErrorReport>
 45 |     <WarningLevel>4</WarningLevel>
 46 |   </PropertyGroup>
 47 |   <ItemGroup>
 48 |     <Compile Include="Properties\AssemblyInfo.cs" />
 49 |     <Compile Include="BlazmVSIXPackage.cs" />
 50 |     <Compile Include="Routing\ProvideToolboxControlAttribute.cs" />
 51 |     <Compile Include="Routing\RoutingItem.cs" />
 52 |     <Compile Include="Routing\RoutingWindow.cs" />
 53 |     <Compile Include="Routing\RoutingWindowCommand.cs" />
 54 |     <Compile Include="Routing\RoutingWindowControl.xaml.cs">
 55 |       <DependentUpon>RoutingWindowControl.xaml</DependentUpon>
 56 |     </Compile>
 57 |   </ItemGroup>
 58 |   <ItemGroup>
 59 |     <None Include="source.extension.vsixmanifest">
 60 |       <SubType>Designer</SubType>
 61 |     </None>
 62 |   </ItemGroup>
 63 |   <ItemGroup>
 64 |     <Reference Include="Microsoft.CSharp" />
 65 |     <Reference Include="PresentationCore" />
 66 |     <Reference Include="PresentationFramework" />
 67 |     <Reference Include="System" />
 68 |     <Reference Include="System.Data" />
 69 |     <Reference Include="System.Design" />
 70 |     <Reference Include="System.Drawing" />
 71 |     <Reference Include="System.Web" />
 72 |     <Reference Include="System.Windows.Forms" />
 73 |     <Reference Include="System.Xaml" />
 74 |     <Reference Include="System.Xml" />
 75 |     <Reference Include="WindowsBase" />
 76 |   </ItemGroup>
 77 |   <ItemGroup>
 78 |     <PackageReference Include="Microsoft.VisualStudio.SDK" Version="17.0.0-previews-1-31410-273" ExcludeAssets="runtime" />
 79 |     <PackageReference Include="Microsoft.VSSDK.BuildTools" Version="17.0.2155-preview2" />
 80 |   </ItemGroup>
 81 |   <ItemGroup>
 82 |     <Page Include="Routing\RoutingWindowControl.xaml">
 83 |       <SubType>Designer</SubType>
 84 |       <Generator>MSBuild:Compile</Generator>
 85 |     </Page>
 86 |   </ItemGroup>
 87 |   <ItemGroup>
 88 |     <VSCTCompile Include="BlazmVSIXPackage.vsct">
 89 |       <ResourceName>Menus.ctmenu</ResourceName>
 90 |     </VSCTCompile>
 91 |     <Content Include="Resources\RoutingToolWindowCommand.png" />
 92 |   </ItemGroup>
 93 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
 94 |   <Import Project="$(VSToolsPath)\VSSDK\Microsoft.VsSDK.targets" Condition="'$(VSToolsPath)' != ''" />
 95 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
 96 |        Other similar extension points exist, see Microsoft.Common.targets.
 97 |   <Target Name="BeforeBuild">
 98 |   </Target>
 99 |   <Target Name="AfterBuild">
100 |   </Target>
101 |   -->
102 | </Project>


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ## Ignore Visual Studio temporary files, build results, and
  2 | ## files generated by popular Visual Studio add-ons.
  3 | ##
  4 | ## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
  5 | 
  6 | # User-specific files
  7 | *.rsuser
  8 | *.suo
  9 | *.user
 10 | *.userosscache
 11 | *.sln.docstates
 12 | 
 13 | # User-specific files (MonoDevelop/Xamarin Studio)
 14 | *.userprefs
 15 | 
 16 | # Mono auto generated files
 17 | mono_crash.*
 18 | 
 19 | # Build results
 20 | [Dd]ebug/
 21 | [Dd]ebugPublic/
 22 | [Rr]elease/
 23 | [Rr]eleases/
 24 | x64/
 25 | x86/
 26 | [Aa][Rr][Mm]/
 27 | [Aa][Rr][Mm]64/
 28 | bld/
 29 | [Bb]in/
 30 | [Oo]bj/
 31 | [Ll]og/
 32 | [Ll]ogs/
 33 | 
 34 | # Visual Studio 2015/2017 cache/options directory
 35 | .vs/
 36 | # Uncomment if you have tasks that create the project's static files in wwwroot
 37 | #wwwroot/
 38 | 
 39 | # Visual Studio 2017 auto generated files
 40 | Generated\ Files/
 41 | 
 42 | # MSTest test Results
 43 | [Tt]est[Rr]esult*/
 44 | [Bb]uild[Ll]og.*
 45 | 
 46 | # NUnit
 47 | *.VisualState.xml
 48 | TestResult.xml
 49 | nunit-*.xml
 50 | 
 51 | # Build Results of an ATL Project
 52 | [Dd]ebugPS/
 53 | [Rr]eleasePS/
 54 | dlldata.c
 55 | 
 56 | # Benchmark Results
 57 | BenchmarkDotNet.Artifacts/
 58 | 
 59 | # .NET Core
 60 | project.lock.json
 61 | project.fragment.lock.json
 62 | artifacts/
 63 | 
 64 | # StyleCop
 65 | StyleCopReport.xml
 66 | 
 67 | # Files built by Visual Studio
 68 | *_i.c
 69 | *_p.c
 70 | *_h.h
 71 | *.ilk
 72 | *.meta
 73 | *.obj
 74 | *.iobj
 75 | *.pch
 76 | *.pdb
 77 | *.ipdb
 78 | *.pgc
 79 | *.pgd
 80 | *.rsp
 81 | *.sbr
 82 | *.tlb
 83 | *.tli
 84 | *.tlh
 85 | *.tmp
 86 | *.tmp_proj
 87 | *_wpftmp.csproj
 88 | *.log
 89 | *.vspscc
 90 | *.vssscc
 91 | .builds
 92 | *.pidb
 93 | *.svclog
 94 | *.scc
 95 | 
 96 | # Chutzpah Test files
 97 | _Chutzpah*
 98 | 
 99 | # Visual C++ cache files
100 | ipch/
101 | *.aps
102 | *.ncb
103 | *.opendb
104 | *.opensdf
105 | *.sdf
106 | *.cachefile
107 | *.VC.db
108 | *.VC.VC.opendb
109 | 
110 | # Visual Studio profiler
111 | *.psess
112 | *.vsp
113 | *.vspx
114 | *.sap
115 | 
116 | # Visual Studio Trace Files
117 | *.e2e
118 | 
119 | # TFS 2012 Local Workspace
120 | $tf/
121 | 
122 | # Guidance Automation Toolkit
123 | *.gpState
124 | 
125 | # ReSharper is a .NET coding add-in
126 | _ReSharper*/
127 | *.[Rr]e[Ss]harper
128 | *.DotSettings.user
129 | 
130 | # TeamCity is a build add-in
131 | _TeamCity*
132 | 
133 | # DotCover is a Code Coverage Tool
134 | *.dotCover
135 | 
136 | # AxoCover is a Code Coverage Tool
137 | .axoCover/*
138 | !.axoCover/settings.json
139 | 
140 | # Visual Studio code coverage results
141 | *.coverage
142 | *.coveragexml
143 | 
144 | # NCrunch
145 | _NCrunch_*
146 | .*crunch*.local.xml
147 | nCrunchTemp_*
148 | 
149 | # MightyMoose
150 | *.mm.*
151 | AutoTest.Net/
152 | 
153 | # Web workbench (sass)
154 | .sass-cache/
155 | 
156 | # Installshield output folder
157 | [Ee]xpress/
158 | 
159 | # DocProject is a documentation generator add-in
160 | DocProject/buildhelp/
161 | DocProject/Help/*.HxT
162 | DocProject/Help/*.HxC
163 | DocProject/Help/*.hhc
164 | DocProject/Help/*.hhk
165 | DocProject/Help/*.hhp
166 | DocProject/Help/Html2
167 | DocProject/Help/html
168 | 
169 | # Click-Once directory
170 | publish/
171 | 
172 | # Publish Web Output
173 | *.[Pp]ublish.xml
174 | *.azurePubxml
175 | # Note: Comment the next line if you want to checkin your web deploy settings,
176 | # but database connection strings (with potential passwords) will be unencrypted
177 | *.pubxml
178 | *.publishproj
179 | 
180 | # Microsoft Azure Web App publish settings. Comment the next line if you want to
181 | # checkin your Azure Web App publish settings, but sensitive information contained
182 | # in these scripts will be unencrypted
183 | PublishScripts/
184 | 
185 | # NuGet Packages
186 | *.nupkg
187 | # NuGet Symbol Packages
188 | *.snupkg
189 | # The packages folder can be ignored because of Package Restore
190 | **/[Pp]ackages/*
191 | # except build/, which is used as an MSBuild target.
192 | !**/[Pp]ackages/build/
193 | # Uncomment if necessary however generally it will be regenerated when needed
194 | #!**/[Pp]ackages/repositories.config
195 | # NuGet v3's project.json files produces more ignorable files
196 | *.nuget.props
197 | *.nuget.targets
198 | 
199 | # Microsoft Azure Build Output
200 | csx/
201 | *.build.csdef
202 | 
203 | # Microsoft Azure Emulator
204 | ecf/
205 | rcf/
206 | 
207 | # Windows Store app package directories and files
208 | AppPackages/
209 | BundleArtifacts/
210 | Package.StoreAssociation.xml
211 | _pkginfo.txt
212 | *.appx
213 | *.appxbundle
214 | *.appxupload
215 | 
216 | # Visual Studio cache files
217 | # files ending in .cache can be ignored
218 | *.[Cc]ache
219 | # but keep track of directories ending in .cache
220 | !?*.[Cc]ache/
221 | 
222 | # Others
223 | ClientBin/
224 | ~$*
225 | *~
226 | *.dbmdl
227 | *.dbproj.schemaview
228 | *.jfm
229 | *.pfx
230 | *.publishsettings
231 | orleans.codegen.cs
232 | 
233 | # Including strong name files can present a security risk
234 | # (https://github.com/github/gitignore/pull/2483#issue-259490424)
235 | #*.snk
236 | 
237 | # Since there are multiple workflows, uncomment next line to ignore bower_components
238 | # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
239 | #bower_components/
240 | 
241 | # RIA/Silverlight projects
242 | Generated_Code/
243 | 
244 | # Backup & report files from converting an old project file
245 | # to a newer Visual Studio version. Backup files are not needed,
246 | # because we have git ;-)
247 | _UpgradeReport_Files/
248 | Backup*/
249 | UpgradeLog*.XML
250 | UpgradeLog*.htm
251 | ServiceFabricBackup/
252 | *.rptproj.bak
253 | 
254 | # SQL Server files
255 | *.mdf
256 | *.ldf
257 | *.ndf
258 | 
259 | # Business Intelligence projects
260 | *.rdl.data
261 | *.bim.layout
262 | *.bim_*.settings
263 | *.rptproj.rsuser
264 | *- [Bb]ackup.rdl
265 | *- [Bb]ackup ([0-9]).rdl
266 | *- [Bb]ackup ([0-9][0-9]).rdl
267 | 
268 | # Microsoft Fakes
269 | FakesAssemblies/
270 | 
271 | # GhostDoc plugin setting file
272 | *.GhostDoc.xml
273 | 
274 | # Node.js Tools for Visual Studio
275 | .ntvs_analysis.dat
276 | node_modules/
277 | 
278 | # Visual Studio 6 build log
279 | *.plg
280 | 
281 | # Visual Studio 6 workspace options file
282 | *.opt
283 | 
284 | # Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
285 | *.vbw
286 | 
287 | # Visual Studio LightSwitch build output
288 | **/*.HTMLClient/GeneratedArtifacts
289 | **/*.DesktopClient/GeneratedArtifacts
290 | **/*.DesktopClient/ModelManifest.xml
291 | **/*.Server/GeneratedArtifacts
292 | **/*.Server/ModelManifest.xml
293 | _Pvt_Extensions
294 | 
295 | # Paket dependency manager
296 | .paket/paket.exe
297 | paket-files/
298 | 
299 | # FAKE - F# Make
300 | .fake/
301 | 
302 | # CodeRush personal settings
303 | .cr/personal
304 | 
305 | # Python Tools for Visual Studio (PTVS)
306 | __pycache__/
307 | *.pyc
308 | 
309 | # Cake - Uncomment if you are using it
310 | # tools/**
311 | # !tools/packages.config
312 | 
313 | # Tabs Studio
314 | *.tss
315 | 
316 | # Telerik's JustMock configuration file
317 | *.jmconfig
318 | 
319 | # BizTalk build output
320 | *.btp.cs
321 | *.btm.cs
322 | *.odx.cs
323 | *.xsd.cs
324 | 
325 | # OpenCover UI analysis results
326 | OpenCover/
327 | 
328 | # Azure Stream Analytics local run output
329 | ASALocalRun/
330 | 
331 | # MSBuild Binary and Structured Log
332 | *.binlog
333 | 
334 | # NVidia Nsight GPU debugger configuration file
335 | *.nvuser
336 | 
337 | # MFractors (Xamarin productivity tool) working folder
338 | .mfractor/
339 | 
340 | # Local History for Visual Studio
341 | .localhistory/
342 | 
343 | # BeatPulse healthcheck temp database
344 | healthchecksdb
345 | 
346 | # Backup folder for Package Reference Convert tool in Visual Studio 2017
347 | MigrationBackup/
348 | 
349 | # Ionide (cross platform F# VS Code tools) working folder
350 | .ionide/
351 | 


--------------------------------------------------------------------------------