/////////////////////////////////////////////////////////////////////////////
// Overriden Package Implementation
#region Package Members
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initilaization code that rely on services provided by VisualStudio.
/// </summary>
protected override void Initialize()
{
Trace.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString()));
base.Initialize();
// Add our command handlers for menu (commands must exist in the .vsct file)
OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (null != mcs)
{
// Create the command for the menu item.
CommandID menuCommandID = new CommandID(GuidList.guidForceVSPackageLoadCSharpCmdSet, (int)PkgCmdIDList.cmdidMyCommand);
MenuCommand menuItem = new MenuCommand(MenuItemCallback, menuCommandID);
mcs.AddCommand(menuItem);
}
//<snippet01>
IVsShell shell = GetService(typeof(SVsShell)) as IVsShell;
if (shell == null)
{
return;
}
IVsPackage package = null;
Guid PackageToBeLoadedGuid =
new Guid(Microsoft.PackageToBeLoaded.GuidList.guidPackageToBeLoadedPkgString);
shell.LoadPackage(ref PackageToBeLoadedGuid, out package);
//</snippet01>
}
public static void EnsurePackageLoaded()
{
IVsShell vsShell = ServiceProvider.GlobalProvider.GetService(typeof(SVsShell)) as IVsShell;
IVsPackage loadedPackage;
vsShell.LoadPackage(typeof(AzureLaunchProfilePackage).GUID, out loadedPackage);
}
public void SubjectBuffersConnected(IWpfTextView textView, ConnectionReason reason, Collection <ITextBuffer> subjectBuffers)
{
IVsShell shell = ServiceProvider.GetService(typeof(IVsShell)) as IVsShell;
if (shell == null)
{
return;
}
IVsPackage package = null;
Guid PackageToBeLoadedGuid =
new Guid(TabAutoCallPackage.PackageGuidString);
shell.LoadPackage(ref PackageToBeLoadedGuid, out package);
IVsTextView textViewAdapter = AdaptersFactory.GetViewAdapter(textView);
IEditorOperations operations = OperationsService.GetEditorOperations(textView);
TrackState state = textView.Properties.GetOrCreateSingletonProperty(() => new TrackState());
foreach (var item in subjectBuffers)
{
if (SupportedContentTypes.Contains(item.ContentType.TypeName, StringComparer.OrdinalIgnoreCase))
{
textView.Properties.GetOrCreateSingletonProperty(() => new CommandFilter(state, textView, textViewAdapter, operations, ServiceProvider, CompletionBroker));
textView.Properties.GetOrCreateSingletonProperty(() => new CommandFilterHighPriority(state, textView, textViewAdapter, ServiceProvider, CompletionBroker));
}
}
}
private static void LoadPackage(IVsShell shell, string guid)
{
IVsPackage package = null;
Guid PackageToBeLoadedGuid = new Guid(guid);
shell.LoadPackage(ref PackageToBeLoadedGuid, out package);
}
protected virtual void InitializePackage()
{
if (Package != null)
{
return;
}
ThreadHelper.ThrowIfNotOnUIThread();
IVsShell shellService = ServiceProvider.GlobalProvider.GetService(typeof(IVsShell)) as IVsShell;
if (shellService == null)
{
IsInitialized = false;
return;
}
Guid acuminatorGUID = Guid.Parse(AcuminatorVSPackage.PackageGuidString);
int returnCode = shellService.IsPackageLoaded(ref acuminatorGUID, out IVsPackage package);
if (returnCode != Microsoft.VisualStudio.VSConstants.S_OK)
{
shellService.LoadPackage(ref acuminatorGUID, out package);
}
Package = package as AcuminatorVSPackage;
if (Package == null)
{
throw new Exception("The Acuminator package was loaded incorrectly");
}
}
public static void AssemblyInitialize(TestContext testContext)
{
UIThreadInvoker.Invoke(new Action(() =>
{
// Load the package into the shell.
IVsShell shellService = (IVsShell)VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell));
Guid packageGuid = new Guid(PackageGuids.GuidCodeMaidPackageString);
IVsPackage package;
shellService.IsPackageLoaded(ref packageGuid, out package);
if (package == null)
{
shellService.LoadPackage(ref packageGuid, out package);
}
Assert.IsTrue(package is CodeMaidPackage);
Package = (CodeMaidPackage)package;
// Generate an empty solution.
const string projectName = "IntegrationTests";
TestUtils.CreateEmptySolution(testContext.TestDir, projectName);
Assert.AreEqual(0, TestUtils.ProjectCount());
// Generate an empty project.
TestUtils.CreateProjectFromTemplate(projectName, "ConsoleApplication.zip", "CSharp");
Assert.AreEqual(1, TestUtils.ProjectCount());
// Capture the project for later use.
Project = Package.IDE.Solution.Projects.Item(1);
Assert.IsNotNull(Project);
Assert.AreEqual(Project.Name, projectName);
}));
}
public void ExcludedNodesAreNotTracked()
{
UIThreadInvoker.Invoke((Action) delegate()
{
// Create solution and project
string projName = Utils.GetCallingFunction();
Utils.CreateEmptySolution(TestContext.TestDir, projName);
string projectPath = Utils.CreateProjectFromTemplate(projName, "Rust Library", "Rust", false);
string newFile = Path.Combine(projectPath, "src", "baz.rs");
// Add file
File.Create(newFile).Close();
// Call idle processing, this triggers creation of show all elements
IVsShell shellService = VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell)) as IVsShell;
Guid visualRust = new Guid("40c1d2b5-528b-4966-a7b1-1974e3568abe");
IVsPackage pkg;
Assert.AreEqual(VSConstants.S_OK, shellService.LoadPackage(ref visualRust, out pkg));
// It's not exact science, additions are usually triggered after 2 calls on my machine,
// so doing it 100 times will suffice, right?
for (int i = 0; i < 100; i++)
{
((IOleComponent)pkg).FDoIdle(0); // we dont check this flag anyway
}
var root = Utils.GetProject(projName);
new HierarchyCheck(root)
.Child <FolderNode>("src")
.Child <FileNode>("lib.rs")
.Sibling <TrackedFileNode>("baz.rs", n => Assert.IsInstanceOfType(n.ItemNode, typeof(AllFilesProjectElement)),
n => Assert.IsTrue(String.IsNullOrEmpty(n.ItemNode.ItemTypeName)),
n => Assert.IsFalse(n.GetModuleTracking()),
n => AssertEx.IsThrown <Exception>(() => n.SetModuleTracking(true)))
.Run();
});
}
public static T LoadPackage <T>(this IVsShell shell) where T : Package
{
Guid guid = typeof(T).GUID;
IVsPackage package;
ErrorHandler.ThrowOnFailure(shell.LoadPackage(ref guid, out package));
return((T)package);
}
public IVsPackage LoadPackage(Guid packageGuid)
{
IVsShell shellService = (IVsShell)VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell));
IVsPackage package;
shellService.LoadPackage(ref packageGuid, out package);
Assert.IsNotNull(package, "Failed to load package");
return(package);
}
public static IVsPackage LoadPackage(IServiceProvider serviceProvider, Guid packageGuid)
{
IVsShell shellService = (IVsShell)serviceProvider.GetService(typeof(SVsShell));
IVsPackage package;
shellService.LoadPackage(ref packageGuid, out package);
Assert.IsNotNull(package, "Failed to load package");
return(package);
}
public static void OnCommand(object sender, EventArgs args)
{
IVsShell shell = VsAppShell.Current.GlobalServices.GetService <IVsShell>(typeof(SVsShell));
IVsPackage package;
if (VSConstants.S_OK == shell.LoadPackage(RGuidList.RPackageGuid, out package))
{
((Microsoft.VisualStudio.Shell.Package)package).ShowOptionPage(typeof(RToolsOptionsPage));
}
}
private static IVsPackage TryLoadPackage(IVsShell vsShell, Guid packageGuid) {
IVsPackage package;
if (vsShell.IsPackageLoaded(ref packageGuid, out package) == VSConstants.S_OK && package != null)
return package;
if (vsShell.LoadPackage(ref packageGuid, out package) == VSConstants.S_OK)
return package;
return null;
}
public static MarkdownPackage ForceLoadPackage(IVsShell shell)
{
Guid packageGuid = new Guid(GuidList.guidMarkdownPackagePkgString);
IVsPackage package;
if (VSConstants.S_OK == shell.IsPackageLoaded(ref packageGuid, out package))
return package as MarkdownPackage;
else if (ErrorHandler.Succeeded(shell.LoadPackage(ref packageGuid, out package)))
return package as MarkdownPackage;
return null;
}
public static void DemandLoadPackage(out IVsPackage package)
{
package = null;
IVsShell shell = GetGlobalService(typeof(SVsShell)) as IVsShell;
if (shell != null)
{
Guid packageGuid = new Guid(GuidList.guidSqlProjPowerPackPkgString);
ErrorHandler.ThrowOnFailure(shell.LoadPackage(ref packageGuid, out package));
}
}
public void PackageLoadTest()
{
UIThreadInvoker.Invoke((ThreadInvoker) delegate()
{
//Get the Shell Service
IVsShell shellService = VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell)) as IVsShell;
Assert.IsNotNull(shellService);
//Validate package load
IVsPackage package;
Guid packageGuid = AnkhId.PackageGuid;
Assert.IsTrue(0 == shellService.LoadPackage(ref packageGuid, out package));
Assert.IsNotNull(package, "Package failed to load");
packageGuid = AnkhId.WpfPackageGuid;
Assert.IsTrue(0 == shellService.LoadPackage(ref packageGuid, out package));
Assert.IsNotNull(package, "Package failed to load");
});
}
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
await ShowModalCommand.InitializeAsync(this);
// Load installer package
IVsShell shell = await GetServiceAsync(typeof(SVsShell)) as IVsShell;
Guid guid = new Guid(InstallerPackage._packageGuid);
ErrorHandler.ThrowOnFailure(shell.LoadPackage(guid, out IVsPackage ppPackage));
}
private static IVsPackage GetRazorPackage(IVsShell shell)
{
var guid = new Guid("BEB01DDF-9D2B-435B-A9E7-76557E2B6B52");
shell.IsPackageLoaded(ref guid, out var package);
if (package == null)
{
shell.LoadPackage(ref guid, out package);
}
return(package);
}
public override CommandResult Invoke(Guid group, int id, object inputArg, ref object outputArg)
{
IVsShell shell = _services.GetService <IVsShell>(typeof(SVsShell));
IVsPackage package;
if (VSConstants.S_OK == shell.LoadPackage(RGuidList.RPackageGuid, out package))
{
((Microsoft.VisualStudio.Shell.Package)package).ShowOptionPage(typeof(REditorOptionsDialog));
}
return(CommandResult.Executed);
}
public void PackageLoad()
{
UIThreadInvoker.Invoke((Action) delegate()
{
IVsShell shellService = VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell)) as IVsShell;
Assert.IsNotNull(shellService);
IVsPackage pkg;
// TODO: refactor guid in the VisualRust project
Guid visualRust = new Guid("40c1d2b5-528b-4966-a7b1-1974e3568abe");
Assert.AreEqual(VSConstants.S_OK, shellService.LoadPackage(ref visualRust, out pkg));
Assert.IsNotNull(pkg);
});
}
private void ShowOptionsPage()
{
IVsPackage vsPackage;
Guid packageGuid = Constants.PackageGuid;
if (ErrorHandler.Succeeded(_vsShell.LoadPackage(ref packageGuid, out vsPackage)))
{
var package = vsPackage as Package;
if (package != null)
{
package.ShowOptionPage(typeof(KeyboardOptionPage));
}
}
}
public void PackageLoadTest()
{
UIThreadInvoker.Invoke((ThreadInvoker) delegate() {
//Get the Shell Service
IVsShell shellService = VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell)) as IVsShell;
Assert.IsNotNull(shellService);
//Validate package load
IVsPackage package;
Guid packageGuid = new Guid(Company.VisualStudioHaskell.GuidList.guidVisualStudioHaskellPkgString);
Assert.IsTrue(0 == shellService.LoadPackage(ref packageGuid, out package));
Assert.IsNotNull(package, "Package failed to load");
});
}
public void PackageLoadTest()
{
UIThreadInvoker.Invoke((ThreadInvoker) delegate()
{
//Get the Shell Service
IVsShell shellService = VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell)) as IVsShell;
Assert.IsNotNull(shellService);
//Validate package load
IVsPackage package;
Guid packageGuid = new Guid(Predelnik.RemoveTrailingWhitespaces.GuidList.guidRemoveTrailingWhitespacesPkgString);
Assert.IsTrue(0 == shellService.LoadPackage(ref packageGuid, out package));
Assert.IsNotNull(package, "Package failed to load");
});
}
public static MarkdownPackage ForceLoadPackage(IVsShell shell)
{
Guid packageGuid = new Guid(GuidList.guidMarkdownPackagePkgString);
IVsPackage package;
if (VSConstants.S_OK == shell.IsPackageLoaded(ref packageGuid, out package))
{
return(package as MarkdownPackage);
}
else if (ErrorHandler.Succeeded(shell.LoadPackage(ref packageGuid, out package)))
{
return(package as MarkdownPackage);
}
return(null);
}
public void PackageLoadTest()
{
UIThreadInvoker.Invoke((ThreadInvoker) delegate()
{
//Get the Shell Service
IVsShell shellService = VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell)) as IVsShell;
Assert.IsNotNull(shellService);
//Validate package load
IVsPackage package;
Guid packageGuid = new Guid(JosePedroSilva.TFSScrumExtensions.GuidList.guidTFSScrumExtensionsPkgString);
Assert.IsTrue(0 == shellService.LoadPackage(ref packageGuid, out package));
Assert.IsNotNull(package, "Package failed to load");
});
}
public void PackageLoadTest()
{
UIThreadInvoker.Invoke((ThreadInvoker) delegate()
{
//Get the Shell Service
IVsShell shellService = VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell)) as IVsShell;
Assert.IsNotNull(shellService);
//Validate package load
IVsPackage package;
Guid packageGuid = new Guid(KittyAltruistic.CPlusPlusTestRunner.GuidList.GUIDTestPackagePkgString);
Assert.IsTrue(0 == shellService.LoadPackage(ref packageGuid, out package));
Assert.IsNotNull(package, "Package failed to load");
});
}
public void PackageLoadTest()
{
UIThreadInvoker.Invoke((ThreadInvoker) delegate()
{
//Get the Shell Service
IVsShell shellService = VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell)) as IVsShell;
Assert.IsNotNull(shellService);
//Validate package load
IVsPackage package;
Guid packageGuid = new Guid("C4128D99-2000-41D1-A6C3-704E6C1A3DE2");
Assert.IsTrue(0 == shellService.LoadPackage(ref packageGuid, out package));
Assert.IsNotNull(package, "Package failed to load");
});
}
public void PackageLoadTest()
{
UIThreadInvoker.Invoke((ThreadInvoker) delegate()
{
//Get the Shell Service
IVsShell shellService = VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell)) as IVsShell;
Assert.IsNotNull(shellService);
//Validate package load
IVsPackage package;
Guid packageGuid = new Guid(SmallSharpTools.JavaScriptBrowser.VSPackage.GuidList.guidJavaScriptBrowserPkgString);
Assert.IsTrue(0 == shellService.LoadPackage(ref packageGuid, out package));
Assert.IsNotNull(package, "Package failed to load");
});
}
public void PackageLoadTest()
{
UIThreadInvoker.Invoke((ThreadInvoker) delegate()
{
//Get the Shell Service
IVsShell shellService = VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell)) as IVsShell;
Assert.IsNotNull(shellService);
//Validate package load
IVsPackage package;
Guid packageGuid = new Guid(FSharp.ProjectExtender.Constants.guidProjectExtenderPkgString);
Assert.IsTrue(0 == shellService.LoadPackage(ref packageGuid, out package));
Assert.IsNotNull(package, "Package failed to load");
});
}
public void PackageLoadTest()
{
UIThreadInvoker.Invoke((ThreadInvoker) delegate()
{
//Get the Shell Service
IVsShell shellService = VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell)) as IVsShell;
Assert.IsNotNull(shellService);
//Validate package load
IVsPackage package;
Guid packageGuid = new Guid(GeoCybernetica.CodeGenerationExtention.GuidList.guidCodeGenerationExtentionPkgString);
Assert.IsTrue(0 == shellService.LoadPackage(ref packageGuid, out package));
Assert.IsNotNull(package, "Package failed to load");
});
}
public void PackageLoadTest()
{
UIThreadInvoker.Invoke((ThreadInvoker) delegate()
{
//Get the Shell Service
IVsShell shellService = VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell)) as IVsShell;
Assert.IsNotNull(shellService);
//Validate package load
IVsPackage package;
Guid packageGuid = new Guid("f152487e-9a22-4cf9-bee6-a8f7c77f828d");
Assert.IsTrue(0 == shellService.LoadPackage(ref packageGuid, out package));
Assert.IsNotNull(package, "Package failed to load");
});
}
public void PackageLoadTest()
{
UIThreadInvoker.Invoke((ThreadInvoker) delegate()
{
//Get the Shell Service
IVsShell shellService = VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell)) as IVsShell;
Assert.IsNotNull(shellService);
//Validate package load
IVsPackage package;
Guid packageGuid = new Guid(MicrosoftCorporation.SlowCheetah.GuidList.guidSlowCheetahPkgString);
Assert.IsTrue(0 == shellService.LoadPackage(ref packageGuid, out package));
Assert.IsNotNull(package, "Package failed to load");
});
}
public void PackageLoadTest()
{
UIThreadInvoker.Invoke((ThreadInvoker) delegate()
{
//Get the Shell Service
IVsShell shellService = VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell)) as IVsShell;
Assert.IsNotNull(shellService);
//Validate package load
IVsPackage package;
Guid packageGuid = new Guid(ALMRangers.TracepointGeneratorPackage.GuidList.guidTracepointGenerator_PackagePkgString);
Assert.IsTrue(0 == shellService.LoadPackage(ref packageGuid, out package));
Assert.IsNotNull(package, "Package failed to load");
});
}
private static void LoadEDMPackage(IVsShell vsShell)
{
Debug.Assert(vsShell != null, "unexpected null value for vsShell");
IVsPackage package = null;
if (vsShell != null)
{
var packageGuid = PackageConstants.guidEscherPkg;
var hr = vsShell.IsPackageLoaded(ref packageGuid, out package);
if (NativeMethods.Failed(hr) || package == null)
{
hr = vsShell.LoadPackage(ref packageGuid, out package);
if (NativeMethods.Failed(hr))
{
var msg = String.Format(CultureInfo.CurrentCulture, Resources.PackageLoadFailureExceptionMessage, hr);
throw new InvalidOperationException(msg);
}
}
}
}
