private IntegrationTestServiceCommands(Package package)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
_package = package;
var commandService = ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
var startServiceMenuCmdId = new CommandID(GrpIdIntegrationTestServiceCommands, CmdIdStartIntegrationTestService);
_startServiceMenuCmd = new MenuCommand(StartServiceCallback, startServiceMenuCmdId) {
Enabled = true,
Supported = true,
Visible = true
};
commandService.AddCommand(_startServiceMenuCmd);
var stopServiceMenuCmdId = new CommandID(GrpIdIntegrationTestServiceCommands, CmdIdStopIntegrationTestService);
_stopServiceMenuCmd = new MenuCommand(StopServiceCallback, stopServiceMenuCmdId) {
Enabled = false,
Supported = true,
Visible = false
};
commandService.AddCommand(_stopServiceMenuCmd);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LocatorWindowCommand"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
/// <param name="package">Owner package, not null.</param>
private LocatorWindowCommand(Package package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
this.package = package;
OleMenuCommandService commandService = ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new MenuCommand(this.ShowToolWindow, menuCommandID);
commandService.AddCommand(menuItem);
}
// Get the instance number 0 of this tool window. This window is single instance so this instance
// is actually the only one.
// The last flag is set to true so that if the tool window does not exists it will be created.
_locatorWindow = package.FindToolWindow(typeof(LocatorWindow), 0, true) as LocatorWindow;
if ((null == _locatorWindow) || (null == _locatorWindow.Frame))
{
throw new NotSupportedException("Cannot create tool window");
}
_locator = new Locator();
_solution = ServiceProvider.GetService(typeof(SVsSolution)) as IVsSolution;
_solution.AdviseSolutionEvents(_locator, out _cookie);
_locatorWindow.SetLocator(_locator);
_locator.StartWorkerThread();
}
/// <summary>
/// Initializes a new instance of the <see cref="AliaserCommand"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
/// <param name="package">Owner package, not null.</param>
private AliaserCommand(Package package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
this.package = package;
this.MainService = new AliaserService();
OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
CommandID menuToAliasCommandID = new CommandID(MenuGroup, ALIASER_TO_ALIAS_COMMAND_ID);
CommandID menuToInstanceCommandID = new CommandID(MenuGroup, ALIASER_TO_INSTANCE_COMMAND_ID);
EventHandler transformAliasToInstace = this.TransformAliasToInstace;
EventHandler transformInstaceToAlias = this.TransformInstaceToAlias;
MenuCommand menuItemToInstace = new MenuCommand(transformAliasToInstace, menuToInstanceCommandID);
MenuCommand menuItemToAlias = new MenuCommand(transformInstaceToAlias, menuToAliasCommandID);
commandService.AddCommand(menuItemToInstace);
commandService.AddCommand(menuItemToAlias);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PoorMansTSqlFormatterCommand"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
/// <param name="package">Owner package, not null.</param>
private PoorMansTSqlFormatterCommand(Package package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
this.package = package;
OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
_applicationObject = Package.GetGlobalService(typeof(DTE)) as DTE;
_formattingManager = PoorMansTSqlFormatterPluginShared.Utils.GetFormattingManager(Properties.Settings.Default);
//Command cmd = _applicationObject.Commands.Item("Tools.FormatTSQLCode", -1);
//cmd.Bindings = "Text Editor::Ctrl+Shift+D";
var menuFormatCommandID = new CommandID(CommandSet, FormatCommandId);
var menuFormatItem = new MenuCommand(this.MenuFormatCallback, menuFormatCommandID);
commandService.AddCommand(menuFormatItem);
var menuOptionsCommandID = new CommandID(CommandSet, OptionsCommandId);
var menuOptionsItem = new MenuCommand(this.MenuOptionsCallback, menuOptionsCommandID);
commandService.AddCommand(menuOptionsItem);
_formatCommand = _applicationObject.Commands.Item("Tools.FormatTSQLCode", -1);
SetFormatHotkey();
}
}
private AddInheritDocCommand(Package package)
{
this.package = package;
OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
var menuCommandId = new CommandID(CommandSet, CommandId);
var menuItem = new OleMenuCommand(MenuItemCallback, menuCommandId);
commandService.AddCommand(menuItem);
menuItem.BeforeQueryStatus += (sender, e) =>
{
bool visible = false;
var dte = (DTE)Package.GetGlobalService(typeof(SDTE));
var classElem = SearchService.FindClass(dte);
if (classElem != null)
{
List<CodeElement> codeElements = SearchService.FindCodeElements(dte);
if (classElem.ImplementedInterfaces.Count > 0)
{
visible = true;
}
else
{
visible = codeElements.Any(elem => elem.IsInherited() || elem.OverridesSomething());
}
}
((OleMenuCommand)sender).Visible = visible;
};
}
}
private OptionsCommand(Microsoft.VisualStudio.Shell.Package package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
_package = package;
OleMenuCommandService commandService = ServiceProvider.GetService(
typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService == null)
{
throw new ArgumentNullException("OleMenuCommandService");
}
{
// Set up hook for context menu.
CommandID menuCommandID = new CommandID(new Guid(LspAntlr.Constants.guidMenuAndCommandsCmdSet), 0x7007);
_menu_item1 = new MenuCommand(MenuItemCallback, menuCommandID)
{
Enabled = true,
Visible = true
};
commandService.AddCommand(_menu_item1);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindow"/> class.
/// </summary>
public MainWindow()
: base(null)
{
this.Caption = "AskTheCode: Control Panel";
var dte2 = ShellPackageAlias.GetGlobalService(typeof(SDTE)) as EnvDTE80.DTE2;
var highlightService = ShellPackageAlias.GetGlobalService(typeof(SHighlightService)) as IHighlightService;
var componentModel = ShellPackageAlias.GetGlobalService(typeof(SComponentModel)) as IComponentModel;
// TODO: Avoid throwing InvalidCastException if the user has the LanguageServices library of version 1.1.0.0
// (It corresponds to Visual Studio Update 1)
var workspace = componentModel?.GetService <VisualStudioWorkspace>();
Contract.Assert(dte2 != null);
Contract.Assert(highlightService != null);
Contract.Assert(workspace != null);
var ideServices = new VisualStudioIdeServices(dte2, highlightService, workspace);
this.ViewModel = new ToolView(ideServices);
// This is the user control hosted by the tool window; Note that, even if this class implements IDisposable,
// we are not calling Dispose on this object. This is because ToolWindowPane calls Dispose on
// the object returned by the Content property.
this.Content = new ToolPanel()
{
DataContext = this.ViewModel
};
}
public Factory(Package package)
: base()
{
this.package = package;
var solution = (IVsSolution)Package.GetGlobalService(typeof(SVsSolution));
ErrorHandler.ThrowOnFailure(solution.AdviseSolutionEvents(this, out solutionCookie));
}
private CommandWithArguments(Package package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
this.package = package;
OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
var menuCommandID = new CommandID(CommandSet, CommandId);
// Step 1: Add the <CommandFlag>AllowParams</CommandFlag> in the .vsct file for the command
// Step 2: Use an OleMenuCommand, not a MenuCommand
var oleMenuCommand = new OleMenuCommand(this.MenuItemCallback, menuCommandID);
// Step 3: Initialize the ParametersDescription property to the "$" value.
// That magical value means that the command accepts any kind of values
oleMenuCommand.ParametersDescription = "$";
commandService.AddCommand(oleMenuCommand);
}
}
private AboutCommand(Microsoft.VisualStudio.Shell.Package package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
_package = package;
OleMenuCommandService commandService = this.ServiceProvider.GetService(
typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService == null)
{
throw new ArgumentNullException("OleMenuCommandService");
}
{
// Set up hook for context menu.
var menuCommandID = new CommandID(new Guid(AntlrVSIX.Constants.guidVSPackageCommandCodeWindowContextMenuCmdSet), 0x7010);
_menu_item1 = new MenuCommand(this.MenuItemCallback, menuCommandID);
_menu_item1.Enabled = true;
_menu_item1.Visible = true;
commandService.AddCommand(_menu_item1);
}
{
// Set up hook for context menu.
var menuCommandID = new CommandID(new Guid(AntlrVSIX.Constants.guidMenuAndCommandsCmdSet), 0x7010);
_menu_item2 = new MenuCommand(this.MenuItemCallback, menuCommandID);
_menu_item2.Enabled = true;
_menu_item2.Visible = true;
commandService.AddCommand(_menu_item2);
}
}
/// <summary>
/// Open a URL within Visual Studio using the <see cref="IVsWebBrowsingService"/> service
/// </summary>
/// <param name="url">The URL to display</param>
public static void OpenUrl(string url)
{
ThreadHelper.ThrowIfNotOnUIThread();
bool useExternalBrowser = false;
if (String.IsNullOrEmpty(url))
{
return;
}
var options = SandcastleBuilderPackage.Instance.GeneralOptions;
if (options != null)
{
useExternalBrowser = options.UseExternalWebBrowser;
}
if (!useExternalBrowser && MsVsShellPackage.GetGlobalService(typeof(SVsWebBrowsingService)) is IVsWebBrowsingService webBrowsingService)
{
ErrorHandler.ThrowOnFailure(webBrowsingService.Navigate(url, 0, out IVsWindowFrame frame));
if (frame != null)
{
frame.Show();
}
}
else
{
System.Diagnostics.Process.Start(url);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BuildStartProject"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
/// <param name="package">Owner package, not null.</param>
private BuildStartProject(Package package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
this.package = package;
// Add a menu item.
OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new MenuCommand(this.MenuItemCallback, menuCommandID);
commandService.AddCommand(menuItem);
}
// Register as an advisory interface.
var solutionService = ServiceProvider.GetService(typeof(SVsSolution)) as IVsSolution;
if (solutionService != null)
{
solutionService.AdviseSolutionEvents(this, out m_EventSinkCookie);
}
}
private void Init()
{
ThreadHelper.ThrowIfNotOnUIThread();
dte = Package.GetGlobalService(typeof(DTE)) as DTE2;
if (dte != null)
{
events = dte.Events as Events2;
if (events != null)
{
dteEvents = events.DTEEvents;
solutionEvents = events.SolutionEvents;
dteEvents.OnBeginShutdown += ShutDown;
solutionEvents.Opened += () => SwitchStartupDir("\n====== Solution opening Detected ======\n");
}
}
terminalController.SetShell(OptionMgr.Shell);
bool createSuccess = terminalController.Init(GetProjectPath());
if (!createSuccess)
{
VsShellUtilities.ShowMessageBox(
ServiceProvider.GlobalProvider,
"Can not create console process, check your configuration and reopen this window",
"Can not create process",
OLEMSGICON.OLEMSGICON_CRITICAL,
OLEMSGBUTTON.OLEMSGBUTTON_OK,
OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST);
}
terminalController.InvokeCmd("\n[Global Init Script ...]\n", OptionMgr.GetGlobalScript());
}
/// <summary>
/// Initializes a new instance of the <see cref="SerializeThisCommand"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
/// <param name="package">Owner package, not null.</param>
/// <param name="serializerFactory"></param>
/// <param name="outputHandlers"></param>
private SerializeThisCommand(Microsoft.VisualStudio.Shell.Package package, ISerializerFactory serializerFactory, IEnumerable <IOutputHandler> outputHandlers)
{
_outputHandlers = outputHandlers.OrderByDescending(o => o.Priority).ToArray();
_serializerFactory = serializerFactory ?? throw new ArgumentNullException(nameof(serializerFactory));
_package = package ?? throw new ArgumentNullException(nameof(package));
if (ServiceProvider.GetService(typeof(IMenuCommandService)) is IMenuCommandService commandService)
{
var menuCommandId = new CommandID(CommandSet, JsonCommandId);
var menuItem = new MenuCommand(MenuItemCallback, menuCommandId);
commandService.AddCommand(menuItem);
menuCommandId = new CommandID(CommandSet, XmlCommandId);
menuItem = new MenuCommand(MenuItemCallback, menuCommandId);
commandService.AddCommand(menuItem);
menuCommandId = new CommandID(CommandSet, CSharpCommandId);
menuItem = new MenuCommand(MenuItemCallback, menuCommandId);
commandService.AddCommand(menuItem);
// TODO: let other plugins add their own menu item to this plugin's context menu.
}
InitializeOutputHandlers();
}
public static void ProvideToolWindowCommand <TToolWindowPane>(VsPackage package, Guid menuGroup, int commandId)
where TToolWindowPane : WpfToolWindowPane
{
EventHandler handler =
(object sender, EventArgs e) =>
{
try
{
ToolWindowPane pane = package.FindToolWindow(typeof(TToolWindowPane), 0, true);
if (pane != null)
{
ErrorHandler.ThrowOnFailure(((IVsWindowFrame)pane.Frame).Show());
}
}
catch (Exception ex) when(!ErrorHandler.IsCriticalException(ex))
{
}
};
OleMenuCommandService commandService = (OleMenuCommandService)((IServiceProvider)package).GetService(typeof(IMenuCommandService));
if (commandService != null)
{
CommandID toolWindowCommandId = new CommandID(menuGroup, commandId);
MenuCommand command = new MenuCommand(handler, toolWindowCommandId);
commandService.AddCommand(command);
}
}
public PasteCommandHandler(IVsTextView adapter, ITextView textView, DTE2 dte)
{
_textView = textView;
_dte = dte;
adapter.AddCommandFilter(this, out _nextCommandTarget);
this.package = package;
}
protected override void Initialize()
{
_dte = GetService(typeof(DTE)) as DTE2;
Package = this;
Telemetry.SetDeviceName(_dte.Edition);
Logger.Initialize(this, Constants.VSIX_NAME);
Events2 events = (Events2)_dte.Events;
_solutionEvents = events.SolutionEvents;
_solutionEvents.AfterClosing += () => { TableDataSource.Instance.CleanAllErrors(); };
_solutionEvents.ProjectRemoved += (project) => { TableDataSource.Instance.CleanAllErrors(); };
_buildEvents = events.BuildEvents;
_buildEvents.OnBuildBegin += OnBuildBegin;
CreateConfig.Initialize(this);
Recompile.Initialize(this);
CompileOnBuild.Initialize(this);
RemoveConfig.Initialize(this);
CompileAllFiles.Initialize(this);
CleanOutputFiles.Initialize(this);
base.Initialize();
}
/// <include file='doc\ViewFilter.uex' path='docs/doc[@for="TextTipData.TextTipData"]/*' />
public TextTipData(IServiceProvider site)
{
if (site == null)
{
throw new System.ArgumentNullException("site");
}
//this.textView = view;
// Create our method tip window (through the local registry)
Type t = typeof(IVsTextTipWindow);
Guid riid = t.GUID;
Guid clsid = typeof(VsTextTipWindowClass).GUID;
Microsoft.VisualStudio.Shell.Package pkg = (Microsoft.VisualStudio.Shell.Package)site.GetService(typeof(Microsoft.VisualStudio.Shell.Package));
if (pkg == null)
{
throw new NullReferenceException(typeof(Microsoft.VisualStudio.Shell.Package).FullName);
}
this.textTipWindow = (IVsTextTipWindow)pkg.CreateInstance(ref clsid, ref riid, t);
if (this.textTipWindow == null)
{
NativeHelpers.RaiseComError(NativeMethods.E_FAIL);
}
NativeMethods.ThrowOnFailure(textTipWindow.SetTextTipData(this));
}
public EditorFactory(Package package, IComponentContext context)
{
Trace.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering {0} constructor", this));
this.editorPackage = package;
this.context = context;
}
public void Run(EnvDTE80.DTE2 DTE, Microsoft.VisualStudio.Shell.Package package)
{
EnvDTE.TextSelection ts = DTE.ActiveWindow.Selection as EnvDTE.TextSelection;
if (ts == null)
{
throw new Exception("No Selection");
}
EnvDTE.CodeParameter codeParam = ts.ActivePoint.CodeElement[vsCMElement.vsCMElementParameter] as EnvDTE.CodeParameter;
if (codeParam == null)
{
throw new Exception("Not Parameter");
}
System.Type tClass = GetTypeByName(DTE, package, codeParam.Type.AsFullName);
string properties = System.Environment.NewLine;
foreach (var p in tClass.GetProperties())
{
properties += codeParam.Name + "." + p.Name + System.Environment.NewLine;
}
// Move into the method and dump the properties there
ts.FindText("{");
ts.Insert("{" + properties);
}
} // Convinient accessor to data.
#endregion Members
#region Initialize
/// <summary>
///
/// </summary>
/// <param name="package">Owner package, not null.</param>
public static void Initialize(Microsoft.VisualStudio.Shell.Package package)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (package == null)
{
return;
}
if (Package != null)
{
return; // Protection against double initialization (double subscription to events, double menus etc)
}
Package = package;
Dte = ServiceProvider.GetService(typeof(DTE)) as EnvDTE80.DTE2;
Assumes.Present(Dte);
var svc = ServiceProvider.GetService(typeof(SVsSolution)) as IVsSolution;
Assumes.Present(svc);
SolutionEvents = new ParallelBuildsMonitor.Events.SolutionEvents();
svc.AdviseSolutionEvents(SolutionEvents, out _);
var svb = ServiceProvider.GetService(typeof(SVsSolutionBuildManager)) as IVsSolutionBuildManager;
Assumes.Present(svb);
BuildEvents = new ParallelBuildsMonitor.Events.BuildEvents();
svb.AdviseUpdateSolutionEvents(BuildEvents, out _);
CreateMenu();
}
protected ProjectFactory(Microsoft.VisualStudio.Shell.Package package)
{
this.package = package;
this.site = package;
// Please be aware that this methods needs that ServiceProvider is valid, thus the ordering of calls in the ctor matters.
this.buildEngine = Utilities.InitializeMsBuildEngine(this.buildEngine, this.site);
}
protected ProjectFactory(Microsoft.VisualStudio.Shell.Package package)
{
this.package = package;
this.site = package;
// Please be aware that this methods needs that ServiceProvider is valid, thus the ordering of calls in the ctor matters.
this.buildEngine = Utilities.InitializeMsBuildEngine(this.buildEngine, this.site);
}
private SolutionEventsListener(Package package)
{
if (package == null)
throw new ArgumentNullException(nameof(package));
this.package = package;
}
public BooLangProjectFactory(Package package)
: base(package)
{
string booBinPath = (string)Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\VisualStudio\9.0Exp\Configuration\Packages\{55663be2-a969-4279-82c5-a6f27936f4f7}").GetValue("BooBinPath");
this.package = (ProjectPackage)package;
this.BuildEngine.GlobalProperties["BoocToolPath"] = new BuildProperty("BoocToolPath", booBinPath);
this.BuildEngine.GlobalProperties["BooBinPath"] = new BuildProperty("BooBinPath",booBinPath);
}
public DexterFileAnalysisCommand(Package package, int commandId, Guid commandSet, ConfigurationProvider configurationProvider)
: base(package, commandId, commandSet, configurationProvider)
{
WindowEvents events = ((Events2)Dte.Events).WindowEvents;
events.WindowActivated += OnDocumentWindowActivated;
events.WindowClosing += OnDocumentWindowClosed;
}
public VisualStudioConnection(Package package)
{
_package = package;
_dte = (DTE2)Package.GetGlobalService(typeof(DTE));
_solutionEvents = ((Events2)_dte.Events).SolutionEvents;
_buildEvents = ((Events2)_dte.Events).BuildEvents;
_subject = new Subject<EventType>();
}
/// <summary>
/// Initializes a new instance of the <see cref = "ClojureProjectNode" /> class.
/// </summary>
/// <param name = "package">Value of the project package for initialize internal package field.</param>
public ClojureProjectNode(Package package)
{
this.package = package;
InitializeImageList();
CanProjectDeleteItems = true;
}
public AttachToAnythingController(Package package, DTE dte, AttachTargetOptionPage options, ProcessWaitSource waitSource, IDiagnosticLogger logger)
{
_package = package;
_dte = dte;
_options = options;
_waitSource = waitSource;
_logger = logger;
}
protected ProjectFactory(Package package)
{
Package = package;
Site = package;
// Please be aware that this methods needs that ServiceProvider is valid, thus the ordering of calls in the ctor matters.
buildEngine = Utilities.InitializeMsBuildEngine(buildEngine, Site);
}
public MenuCommandController(Package package)
{
_package = package;
_statusController = new StatusController
{
StatusBar = Package.GetGlobalService(typeof(SVsStatusbar)) as IVsStatusbar,
OutputWindow = _package.GetOutputPane(VSConstants.GUID_OutWindowGeneralPane, "Lonestar"),
};
}
public SQLanguageServiceEX(Microsoft.VisualStudio.Shell.Package sp)
{
Trace.WriteLine(
"Constructing a new instance of SQLanguangeService");
oleserviceProvider = sp;
_serviceProvider = sp;
_errorHandler = new VSQNErrorHandler(sp);
}
public void Run(EnvDTE80.DTE2 DTE, Microsoft.VisualStudio.Shell.Package package)
{
string className = Microsoft.VisualBasic.Interaction.InputBox("Class name", "Create tests",
"VATRate", -1, -1);
EnvDTE.ProjectItem f = DTE.ItemOperations.AddNewItem("Visual C# Items\\Code\\Class", className + "RepositoryTests.cs");
EnvDTE.CodeClass c = FirstClass(FirstNamespace(f.FileCodeModel.CodeElements).Children);
c.AddFunction("Insert" + className, vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefVoid);
}
EnableReloadCommand(Package package, OleMenuCommandService commandService)
{
_package = package;
var id = new CommandID(PackageGuids.guidBrowserReloadCmdSet, PackageIds.EnableReloadCommandId);
var cmd = new OleMenuCommand(Execute, id);
cmd.BeforeQueryStatus += BeforeQueryStatus;
commandService.AddCommand(cmd);
}
protected AbstractEditorFactory(Package package)
{
_package = package ?? throw new ArgumentNullException(nameof(package));
_componentModel = (IComponentModel)ServiceProvider.GetService(typeof(SComponentModel));
_editorAdaptersFactoryService = _componentModel.GetService<IVsEditorAdaptersFactoryService>();
_contentTypeRegistryService = _componentModel.GetService<IContentTypeRegistryService>();
_waitIndicator = _componentModel.GetService<IWaitIndicator>();
}
/// <summary>
/// Initializes a new instance of the <see cref="SolutionManager"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
/// <param name="package">Owner package, not null.</param>
private SolutionManager(Package package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
this._package = package;
}
/// <summary>
/// Initializes a new instance of the <see cref="DexterAnalysisCommand"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
/// <param name="package">Owner package, not null.</param>
/// <param name="commandId">Command ID.</param>
/// <param name="commandSet">Command menu group (command set GUID).</param>
public DexterAnalysisCommand(Package package, int commandId, Guid commandSet, ConfigurationProvider configurationProvider)
: base(package,commandId,commandSet)
{
AutoEnabled = true;
dexterInfoValidator = new DexterInfoValidator();
projectInfoValidator = new ProjectInfoValidator();
ConfigurationProvider = configurationProvider;
Refresh();
}
public static void Initialize(Package package)
{
if (Instance != null)
Instance.Dispose(false);
Instance = new SolutionEventsListener(package);
Instance.AdivseSolutionUpdates();
}
private ResetConfigFilesCommand(Package package)
{
_package = package;
OleMenuCommandService commandService = ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
var menuCommandID = new CommandID(PackageGuids.ConfigFileCmdSet, PackageIds.ResetConfigFiles);
var menuItem = new OleMenuCommand(ResetConfigurationFiles, menuCommandID);
commandService.AddCommand(menuItem);
}
public static void Initialize(Package package)
{
Instance = new MainWindowCommand(package);
ToolWindowPane window = package.FindToolWindow(typeof(MainWindow), 0, true);
if ((null == window) || (null == window.Frame))
{
throw new NotSupportedException("Cannot create tool window");
}
((MainWindow)window).Initialize(((MainWindowPackage)package).Options);
}
protected override void Initialize()
{
Dte = GetService(typeof(DTE)) as DTE2;
Dispatcher = Dispatcher.CurrentDispatcher;
Package = this;
Logger.Initialize(this, Constants.VSIX_NAME);
base.Initialize();
}
public VsUIServices(ICoreShell coreShell)
{
ProgressDialog = new VsProgressDialog(coreShell.Services);
FileDialog = new VsFileDialog(coreShell);
_coreShell = coreShell;
_vsShell = VsPackage.GetGlobalService(typeof(SVsShell)) as IVsShell;
_vsShell.AdviseBroadcastMessages(this, out _vsShellBroadcastEventsCookie);
_uiShell = VsPackage.GetGlobalService(typeof(SVsUIShell)) as IVsUIShell;
}
/// <summary>
/// Retrieves Visual Studio global service from global VS service provider.
/// This method is not thread safe and should not be called from async methods.
/// </summary>
/// <typeparam name="T">Service interface type such as IVsUiShell</typeparam>
/// <param name="type">Service type if different from T, such as typeof(SVSUiShell)</param>
/// <returns>Service instance of null if not found.</returns>
public T GetGlobalService <T>(Type type = null) where T : class
{
this.AssertIsOnMainThread();
if (IsUnitTestEnvironment)
{
System.IServiceProvider sp = RPackage.Current;
return(sp.GetService(type ?? typeof(T)) as T);
}
return(VsPackage.GetGlobalService(type ?? typeof(T)) as T);
}
public ToolchainHelper(Package package)
{
if (package == null)
throw new ArgumentNullException(nameof(package));
this.package = package;
this.listener = SolutionEventsListener.Instance;
listener.BuildStartedEvent += Listener_BuildStartedEvent;
listener.BuildFinishedEvent += Listener_BuildFinishedEvent;
}
public WpfToolWindowPane()
: base(null)
{
GlobalServiceProvider = (IServiceProvider)VsPackage.GetGlobalService(typeof(IServiceProvider));
if (GlobalServiceProvider == null)
{
GlobalServiceProvider = new ServiceProvider((IOleServiceProvider)VsPackage.GetGlobalService(typeof(IOleServiceProvider)));
}
this._toolWindowControl = CreateToolWindowControl();
}
GraphProviderCommand(Package package)
{
ServiceProvider = _package = package;
var service = (OleMenuCommandService)ServiceProvider.GetService(typeof(IMenuCommandService));
var cmdId = new CommandID(PackageGuids.guidToggleFeaturesCmdSet, PackageIds.ToggleGraphProvider);
var button = new OleMenuCommand(ToggleFeature, cmdId);
button.BeforeQueryStatus += BeforeQueryStatus;
service.AddCommand(button);
}
private void Initialize()
{
_vsShell = (IVsShell)VsPackage.GetGlobalService(typeof(SVsShell));
VsWpfOverrides.Apply();
var oleCm = (IOleComponentManager)VsPackage.GetGlobalService(typeof(SOleComponentManager));
ConfigureIdleSource(oleCm);
ConfigurePackageServices();
CheckVsStarted();
}
public FSharpEditorFactory(ShellPackage parentPackage)
{
if (parentPackage == null)
{
throw new ArgumentNullException(nameof(parentPackage));
}
_parentPackage = parentPackage;
_componentModel = (IComponentModel)ServiceProvider.GetService(typeof(SComponentModel));
_editorAdaptersFactoryService = _componentModel.GetService <IVsEditorAdaptersFactoryService>();
_contentTypeRegistryService = _componentModel.GetService <IContentTypeRegistryService>();
}
public void Run(EnvDTE80.DTE2 DTE, Microsoft.VisualStudio.Shell.Package package)
{
EnvDTE.TextSelection ts = DTE.ActiveWindow.Selection as EnvDTE.TextSelection;
if (ts == null)
{
return;
}
var codeClass = ts.ActivePoint.CodeElement[vsCMElement.vsCMElementClass]
as EnvDTE.CodeClass;
if (codeClass == null)
{
return;
}
EnvDTE.Project project = DTE.ActiveWindow.Project;
var resolutor = GetResolutionService(project, Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider);
var a = project.
var type = resolutor.GetType(codeClass.FullName, true);
var bases = new List <Type>();
var baseType = type.BaseType;
while (baseType != typeof(object) && baseType != null)
{
bases.Add(baseType);
baseType = baseType.BaseType;
}
bases.Insert(0, type);
var fields_list = new List <PropertyInfo>();
foreach (var type_base in bases)
{
var tmp = type_base.GetProperties(
BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.Default | BindingFlags.Instance);
foreach (var fieldInfo in tmp)
{
fields_list.Add(fieldInfo);
}
}
var text = "//numero di fields = ' " + fields_list.Count + " '" + System.Environment.NewLine;
foreach (var fieldInfo in fields_list)
{
if (text.Contains("public " + fieldInfo.PropertyType + " " + fieldInfo.Name + ";"))
{
continue;
}
text += "public " + fieldInfo.PropertyType + " " + fieldInfo.Name + ";" + System.Environment.NewLine + System.Environment.NewLine;
}
text = text.Replace("+", ".");
System.Windows.Clipboard.SetText(text);
}
//=====================================================================
/// <summary>
/// Get a service from the Sandcastle Help File Builder package
/// </summary>
/// <param name="throwOnError">True to throw an exception if the service cannot be obtained,
/// false to return null.</param>
/// <typeparam name="TInterface">The interface to obtain</typeparam>
/// <typeparam name="TService">The service used to get the interface</typeparam>
/// <returns>The service or null if it could not be obtained</returns>
public static TInterface GetServiceFromPackage <TInterface, TService>(bool throwOnError)
where TInterface : class
where TService : class
{
TInterface service = MsVsShellPackage.GetGlobalService(typeof(TService)) as TInterface;
if (service == null && throwOnError)
{
throw new InvalidOperationException("Unable to obtain service of type " + typeof(TService).Name);
}
return(service);
}
CopyRefCommand(Microsoft.VisualStudio.Shell.Package package)
{
this.package = package;
var commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new MenuCommand(this.OnMenuInvoked, menuCommandID);
commandService.AddCommand(menuItem);
}
}
private static VsAppShell GetInstance()
{
if (_instance != null)
{
return(_instance);
}
ThreadHelper.ThrowIfNotOnUIThread();
var componentModel = (IComponentModel)VsPackage.GetGlobalService(typeof(SComponentModel));
var instance = (VsAppShell)componentModel.DefaultExportProvider.GetExportedValue <ICoreShell>();
return(Interlocked.CompareExchange(ref _instance, instance, null) ?? instance);
}
public static IVsPackage EnsurePackageLoaded(Guid guidPackage)
{
var shell = (IVsShell)VsPackage.GetGlobalService(typeof(IVsShell));
var guid = guidPackage;
IVsPackage package;
int hr = ErrorHandler.ThrowOnFailure(shell.IsPackageLoaded(ref guid, out package), VSConstants.E_FAIL);
guid = guidPackage;
if (hr != VSConstants.S_OK)
{
ErrorHandler.ThrowOnFailure(shell.LoadPackage(ref guid, out package), VSConstants.E_FAIL);
}
return(package);
}
private Command1(Microsoft.VisualStudio.Shell.Package package)
{
this.package = package ?? throw new ArgumentNullException("package");
OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new OleMenuCommand(MenuItemCallback, menuCommandID);
menuItem.BeforeQueryStatus += MenuItem_BeforeQueryStatus;
menuItem.Visible = false;
commandService.AddCommand(menuItem);
}
}
private static VsAppShell GetInstance()
{
if (_instance != null)
{
return(_instance);
}
var componentModel = (IComponentModel)VsPackage.GetGlobalService(typeof(SComponentModel));
var instance = (VsAppShell)componentModel.DefaultExportProvider.GetExportedValue <IApplicationShell>();
instance.CompositionService = componentModel.DefaultCompositionService;
instance.ExportProvider = componentModel.DefaultExportProvider;
return(Interlocked.CompareExchange(ref _instance, instance, null) ?? instance);
}
private System.Type GetTypeByName(EnvDTE80.DTE2 DTE, Microsoft.VisualStudio.Shell.Package package, string name)
{
System.IServiceProvider serviceProvider = package as System.IServiceProvider;
Microsoft.VisualStudio.Shell.Design.DynamicTypeService typeService =
serviceProvider.GetService(typeof(Microsoft.VisualStudio.Shell.Design.DynamicTypeService)) as
Microsoft.VisualStudio.Shell.Design.DynamicTypeService;
Microsoft.VisualStudio.Shell.Interop.IVsSolution sln = serviceProvider.GetService(typeof(Microsoft.VisualStudio.Shell.Interop.IVsSolution)) as
Microsoft.VisualStudio.Shell.Interop.IVsSolution;
Microsoft.VisualStudio.Shell.Interop.IVsHierarchy hier;
sln.GetProjectOfUniqueName(DTE.ActiveDocument.ProjectItem.ContainingProject.UniqueName, out hier);
return(typeService.GetTypeResolutionService(hier).GetType(name, true));
}
private OptionsCommand(Microsoft.VisualStudio.Shell.Package package)
{
_package = package ?? throw new ArgumentNullException(nameof(package));
OleMenuCommandService commandService = ((IServiceProvider)ServiceProvider).GetService(
typeof(IMenuCommandService)) as OleMenuCommandService ?? throw new Exception("Command service not found.");
{
CommandID menuCommandID = new CommandID(new Guid(LspAntlr.Constants.guidMenuAndCommandsCmdSet), 0x7007);
_menu_item1 = new MenuCommand(MenuItemCallback, menuCommandID)
{
Enabled = true,
Visible = true
};
commandService.AddCommand(_menu_item1);
}
}
private void CheckVsStarted()
{
_vsShell = (IVsShell)VsPackage.GetGlobalService(typeof(SVsShell));
_vsShell.GetProperty((int)__VSSPROPID4.VSSPROPID_ShellInitialized, out var value);
if (value is bool)
{
if ((bool)value)
{
_application.FireStarted();
}
else
{
_vsShell.AdviseShellPropertyChanges(this, out _vsShellEventsCookie);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AddNuSpecCommand"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
/// <param name="package">Owner package, not null.</param>
private AddNuSpecCommand(Package package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
this.package = package;
OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new MenuCommand(this.MenuItemCallback, menuCommandID);
commandService.AddCommand(menuItem);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SetILPathCommand"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
/// <param name="package">Owner package, not null.</param>
private SetILPathCommand(Microsoft.VisualStudio.Shell.Package package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
this.package = package;
OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new MenuCommand(this.MenuItemCallback, menuCommandID);
commandService.AddCommand(menuItem);
}
}