public static IVsWindowFrame OpenDocument(string filePath, Action<IVsWindowFrame> creationCallback) { if (string.IsNullOrEmpty(filePath) || !File.Exists(filePath)) return null; var dte2 = (EnvDTE80.DTE2)Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(EnvDTE.DTE)) as EnvDTE80.DTE2; Microsoft.VisualStudio.OLE.Interop.IServiceProvider sp = (Microsoft.VisualStudio.OLE.Interop.IServiceProvider)dte2; Microsoft.VisualStudio.Shell.ServiceProvider serviceProvider = new Microsoft.VisualStudio.Shell.ServiceProvider(sp); IVsUIHierarchy hierarchy; uint itemId; IVsWindowFrame frame = null; if (!VsShellUtilities.IsDocumentOpen(serviceProvider, filePath, VSConstants.LOGVIEWID_Primary, out hierarchy, out itemId, out frame)) { VsShellUtilities.OpenDocument(serviceProvider, filePath, VSConstants.LOGVIEWID_Primary, out hierarchy, out itemId, out frame); if (creationCallback != null) creationCallback(frame); } if (frame != null) frame.Show(); return frame; }
internal static ErrorTask CreateErrorTask( string document, string errorMessage, TextSpan textSpan, TaskErrorCategory taskErrorCategory, IVsHierarchy hierarchy, uint itemID, MARKERTYPE markerType) { ErrorTask errorTask = null; IOleServiceProvider oleSp = null; hierarchy.GetSite(out oleSp); IServiceProvider sp = new ServiceProvider(oleSp); // see if Document is open IVsTextLines buffer = null; var docData = VSHelpers.GetDocData(sp, document); if (docData != null) { buffer = VSHelpers.GetVsTextLinesFromDocData(docData); } if (buffer != null) { errorTask = new EFModelDocumentTask(sp, buffer, markerType, textSpan, document, itemID, errorMessage, hierarchy); errorTask.ErrorCategory = taskErrorCategory; } else { errorTask = new EFModelErrorTask( document, errorMessage, textSpan.iStartLine, textSpan.iEndLine, taskErrorCategory, hierarchy, itemID); } return errorTask; }
///////////////////////////////////////////////////////////////////////////// // Overridden 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 initialization code that rely on services provided by VisualStudio. /// </summary> protected override void Initialize() { Debug.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 ) { DTE dte = (DTE)GetService(typeof(DTE)); migrator = new Migrator(dte); var serviceProvider = new ServiceProvider((IServiceProvider)dte); solutionLoadEvents = new SolutionLoadEvents(serviceProvider); synchronizationContext = SynchronizationContext.Current; solutionLoadEvents.BeforeSolutionLoaded += () => { synchronizationContext.Post(_ => migrator.OnBeforeSolutionLoaded(), null); }; solutionLoadEvents.AfterSolutionLoaded += () => { synchronizationContext.Post(_ => migrator.OnAfterSolutionLoaded(), null); }; // Create the command for the menu item. CommandID menuCommandID = new CommandID(GuidList.guidTargetFrameworkMigratorCmdSet, (int)PkgCmdIDList.cmdidTargetFrameworkMigrator); MenuCommand menuItem = new MenuCommand(MenuItemCallback, menuCommandID ); mcs.AddCommand( menuItem ); } }
/// <summary> /// Get the hierarchy corresponding to a Project /// </summary> /// <param name="project"></param> /// <returns></returns> public static IVsHierarchy ToHierarchy(EnvDTE.Project project) { if (project == null) throw new ArgumentNullException("project"); string projectGuid = null; // DTE does not expose the project GUID that exists at in the msbuild project file. // Cannot use MSBuild object model because it uses a static instance of the Engine, // and using the Project will cause it to be unloaded from the engine when the // GC collects the variable that we declare. using (XmlReader projectReader = XmlReader.Create(project.FileName)) { projectReader.MoveToContent(); object nodeName = projectReader.NameTable.Add("ProjectGuid"); while (projectReader.Read()) { if (Object.Equals(projectReader.LocalName, nodeName)) { // projectGuid = projectReader.ReadContentAsString(); projectGuid = projectReader.ReadElementContentAsString(); break; } } } Debug.Assert(!String.IsNullOrEmpty(projectGuid)); System.IServiceProvider serviceProvider = new ServiceProvider(project.DTE as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); return VsShellUtilities.GetHierarchy(serviceProvider, new Guid(projectGuid)); }
private string Transform(string fileName, string source) { var sp = new ServiceProvider(_site as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); var vsproj = ((EnvDTE.ProjectItem)(sp.GetService(typeof(EnvDTE.ProjectItem)))).ContainingProject; var cm = (IComponentModel)(Package.GetGlobalService(typeof(SComponentModel))); var workspace = cm.GetService<VisualStudioWorkspace>(); var solution = workspace.CurrentSolution; var project = solution.Projects.FirstOrDefault(p => p.FilePath == vsproj.FileName); var syntaxTrees = Enumerable.Empty<SyntaxTree>(); if (project != null) { var c = project.GetCompilationAsync().Result; syntaxTrees = c.SyntaxTrees; } var syntaxTree = CSharpSyntaxTree.ParseText(source); var compilation = CSharpCompilation.Create("temp", syntaxTrees.Concat(new[] { syntaxTree })); var rewriter = new NotifyPropertyChangedRewriter(fileName, compilation.GetSemanticModel(syntaxTree, true)); var result = rewriter.Visit(syntaxTree.GetRoot()); return result.ToFullString(); }
private void CommandInvoke(object sender, EventArgs e) { OleMenuCmdEventArgs oOleMenuCmdEventArgs = (OleMenuCmdEventArgs)e; DTE2 Application = (DTE2)GetService(typeof(DTE)); ProjectItem oProjectItem = Application.SelectedItems.Item(1).ProjectItem; IServiceProvider oServiceProvider = new ServiceProvider((Microsoft.VisualStudio.OLE.Interop.IServiceProvider)Application); Microsoft.Build.Evaluation.Project oBuildProject = Microsoft.Build.Evaluation.ProjectCollection.GlobalProjectCollection.GetLoadedProjects(oProjectItem.ContainingProject.FullName).SingleOrDefault(); Microsoft.Build.Evaluation.ProjectProperty oGUID = oBuildProject.AllEvaluatedProperties.SingleOrDefault(oProperty => oProperty.Name == "ProjectGuid"); Microsoft.VisualStudio.Shell.Interop.IVsHierarchy oVsHierarchy = VsShellUtilities.GetHierarchy(oServiceProvider, new Guid(oGUID.EvaluatedValue)); Microsoft.VisualStudio.Shell.Interop.IVsBuildPropertyStorage oVsBuildPropertyStorage = (Microsoft.VisualStudio.Shell.Interop.IVsBuildPropertyStorage)oVsHierarchy; string szItemPath = (string)oProjectItem.Properties.Item("FullPath").Value; uint nItemId; oVsHierarchy.ParseCanonicalName(szItemPath, out nItemId); if (oOleMenuCmdEventArgs.OutValue != IntPtr.Zero) { string szOut; oVsBuildPropertyStorage.GetItemAttribute(nItemId, "ItemColor", out szOut); Marshal.GetNativeVariantForObject(szOut, oOleMenuCmdEventArgs.OutValue); } else if (oOleMenuCmdEventArgs.InValue != null) { oVsBuildPropertyStorage.SetItemAttribute(nItemId, "ItemColor", Convert.ToString(oOleMenuCmdEventArgs.InValue)); } }
/// <summary> /// Executes when the wizard starts. /// </summary> public override void RunStarted(object automationObject, Dictionary<string, string> replacementsDictionary, Microsoft.VisualStudio.TemplateWizard.WizardRunKind runKind, object[] customParams) { base.RunStarted(automationObject, replacementsDictionary, runKind, customParams); var wizardData = this.TemplateSchema.WizardData.FirstOrDefault(); if (wizardData != null) { LoadWizards(wizardData); using (var services = new ServiceProvider((Microsoft.VisualStudio.OLE.Interop.IServiceProvider)automationObject)) { var components = services.GetService<SComponentModel, IComponentModel>(); foreach (var wizard in wizards) { TryOrDispose(() => AttributedModelServices.SatisfyImportsOnce(components.DefaultCompositionService, wizard)); } } } foreach (var wizard in wizards) { TryOrDispose(() => wizard.RunStarted(automationObject, replacementsDictionary, runKind, customParams)); } }
/// <summary> /// Returns an IVsTextView for the given file path, if the given file is open in Visual Studio. /// </summary> /// <param name="serviceProvider">The package Service Provider.</param> /// <param name="filePath">Full Path of the file you are looking for.</param> /// <returns> /// The IVsTextView for this file, if it is open, null otherwise. /// </returns> internal static async Task <IWpfTextView> GetWpfTextViewByFilePathAsync(this Shell.IAsyncServiceProvider serviceProvider, string filePath) { if (filePath.IsNullOrWhiteSpace() || serviceProvider == null) { return(null); } if (!Shell.ThreadHelper.CheckAccess()) { await Shell.ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); } DTE2 dte2 = await serviceProvider.GetServiceAsync <Shell.Interop.SDTE, DTE2>(); var oleServiceProvider = dte2 as Microsoft.VisualStudio.OLE.Interop.IServiceProvider; if (dte2 == null || oleServiceProvider == null) { return(null); } Shell.ServiceProvider shellServiceProvider = new Shell.ServiceProvider(oleServiceProvider); if (Shell.VsShellUtilities.IsDocumentOpen(shellServiceProvider, filePath, Guid.Empty, out var uiHierarchy, out var itemID, out var windowFrame)) { IVsTextView textView = Shell.VsShellUtilities.GetTextView(windowFrame); // Get the IVsTextView from the windowFrame return(await serviceProvider.GetWpfTextViewFromTextViewAsync(textView)); } return(null); }
public Context(object automationObject, IDictionary<string, string> values) { _replacementValues = values; _environment = (DTE)automationObject; ServiceProvider = new ServiceProvider(_environment as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); TemplateService = new TemplateService(this); }
private static void CleanupFields() { if (container != null) { container.Dispose(); container = null; } if (serviceProvider != null) { serviceProvider.Dispose(); serviceProvider = null; } if (composition != null) { composition.Dispose(); composition = null; } if (globalCatalog != null) { globalCatalog.Dispose(); globalCatalog = null; } componentHost = null; catalogProvider = null; localComponentModel = null; }
/// <summary> /// Initializes VisualStudioHelper class. /// </summary> /// <param name="objDTE">DTE object.</param> public static void Initialize(DTE2 objDTE) { if (VisualStudioHelper._initialized == false) { VisualStudioHelper._initialized = true; // Set DTE reference VisualStudioHelper._DTE = objDTE; // Set event handlers VisualStudioHelper._DTE.Events.SolutionEvents.BeforeClosing += VisualStudioHelper.SolutionEvents_BeforeClosing; VisualStudioHelper._DTE.Events.SolutionEvents.ProjectRemoved += VisualStudioHelper.SolutionEvents_ProjectRemoved; // Get ServiceProvider Microsoft.VisualStudio.Shell.ServiceProvider sp = new Microsoft.VisualStudio.Shell.ServiceProvider( (Microsoft.VisualStudio.OLE.Interop.IServiceProvider)objDTE); // Get the Solution service from the ServiceProvider VisualStudioHelper._solutionService = (sp.GetService(typeof(IVsSolution)) as IVsSolution); // Get the ErrorList provider VisualStudioHelper._errorListProvider = new Microsoft.VisualStudio.Shell.ErrorListProvider(sp); VisualStudioHelper._errorListProvider.ProviderName = Resources.ErrorList_ProviderName; VisualStudioHelper._errorListProvider.ProviderGuid = new Guid(Resources.ErrorList_ProviderGUID); } }
private void CreateErrorListProvider() { IServiceProvider serviceProvider = new ServiceProvider((Microsoft.VisualStudio.OLE.Interop.IServiceProvider)mApplication); mErrorListProvider = new ErrorListProvider(serviceProvider); mErrorListProvider.ProviderName = "CppCheck Errors"; mErrorListProvider.ProviderGuid = new Guid("5A10E43F-8D1D-4026-98C0-E6B502058901"); }
/// <summary> /// The process record. /// </summary> /// <exception cref="PSInvalidOperationException"> /// An error occured /// </exception> protected override void ProcessRecord() { var project = this.Project as VSProject; if (project == null) { throw new PSInvalidOperationException("Cannot cast the Project object to a VSProject"); } var sp = new ServiceProvider((IOleServiceProvider)project.DTE); // Get the toolbox var svsToolbox = sp.GetService(typeof(SVsToolbox)); if (svsToolbox == null) { throw new PSInvalidOperationException("Cannot get global Toolbox Service (SVsToolbox)"); } var toolbox = svsToolbox as IVsToolbox; if (toolbox == null) { throw new PSInvalidOperationException("Cannot cast Toolbox Service to IVsToolbox"); } toolbox.RemoveTab(this.Category); }
public PropertiesEditorLauncher(ServiceProvider serviceProvider) { if(serviceProvider == null) throw new ArgumentNullException("serviceProvider"); this.serviceProvider = serviceProvider; }
public static void ShowContextMenu(ContextMenuStrip contextMenu, DTE dte) { try { var serviceProvider = new ServiceProvider(dte as IServiceProvider); IVsUIShellOpenDocument sod = (IVsUIShellOpenDocument)serviceProvider.GetService(typeof(SVsUIShellOpenDocument)); IVsUIHierarchy targetHier; uint[] targetId = new uint[1]; IVsWindowFrame targetFrame; int isOpen; Guid viewId = new Guid(LogicalViewID.Primary); sod.IsDocumentOpen(null, 0, dte.ActiveWindow.Document.FullName, ref viewId, 0, out targetHier, targetId, out targetFrame, out isOpen); IVsTextView textView = VsShellUtilities.GetTextView(targetFrame); TextSelection selection = (TextSelection)dte.ActiveWindow.Document.Selection; Microsoft.VisualStudio.OLE.Interop.POINT[] interopPoint = new Microsoft.VisualStudio.OLE.Interop.POINT[1]; textView.GetPointOfLineColumn(selection.ActivePoint.Line, selection.ActivePoint.LineCharOffset, interopPoint); POINT p = new POINT(interopPoint[0].x, interopPoint[0].y); ClientToScreen(textView.GetWindowHandle(), p); contextMenu.Show(new Point(p.x, p.y)); } catch (Exception) { contextMenu.Show(); } }
private IVsTextManager GetTextManager(DTE2 application) { using (ServiceProvider wrapperSP = new ServiceProvider((Microsoft.VisualStudio.OLE.Interop.IServiceProvider)application)) { return (IVsTextManager)wrapperSP.GetService(typeof(SVsTextManager)); } }
/// <summary> /// Creates a plugin instance when a new text editor is opened /// </summary> public void VsTextViewCreated(IVsTextView adapter) { IWpfTextView view = adapterFactory.GetWpfTextView(adapter); if (view == null) return; ITextDocument document; if (!docFactory.TryGetTextDocument(view.TextDataModel.DocumentBuffer, out document)) return; IObjectWithSite iows = adapter as IObjectWithSite; if (iows == null) return; System.IntPtr p; iows.GetSite(typeof(IServiceProvider).GUID, out p); if (p == System.IntPtr.Zero) return; IServiceProvider isp = Marshal.GetObjectForIUnknown(p) as IServiceProvider; if (isp == null) return; ServiceProvider sp = new ServiceProvider(isp); DTE dte = sp.GetService(typeof(DTE)) as DTE; sp.Dispose(); new Plugin(view, document, dte); }
internal SqlEditor(ServiceProvider sp, SqlEditorPane pane ) : this() { Pane = pane; serviceProvider = sp; codeEditor.Init(sp, this); }
public SqlEditorPane(ServiceProvider sp, SqlEditorFactory factory) : base(sp) { Factory = factory; DocumentPath = factory.LastDocumentPath; editor = new SqlEditor(sp, this); }
// Add Silverlight app to the Web project and create test web pages public void RunFinished() { Project silverlightProject = GetSilverlightProject(); Project webProject = GetWebProject(); if (webProject != null) { _dte2.Solution.SolutionBuild.StartupProjects = webProject.UniqueName; Properties properties = webProject.Properties; ProjectItem aspxTestPage = this.GetAspxTestPage(webProject); if (aspxTestPage != null) { properties.Item("WebApplication.StartPageUrl").Value = aspxTestPage.Name; properties.Item("WebApplication.DebugStartAction").Value = 1; } if (silverlightProject != null) { IVsHierarchy hierarchy; IVsHierarchy hierarchy2; silverlightProject.Properties.Item("SilverlightProject.LinkedServerProject").Value = webProject.FullName; var sp = _dte2 as Microsoft.VisualStudio.OLE.Interop.IServiceProvider; IVsSolution service = null; using (var provider2 = new ServiceProvider(sp)) { service = provider2.GetService(typeof(IVsSolution)) as IVsSolution; } if (((service.GetProjectOfUniqueName(webProject.UniqueName, out hierarchy) == 0) && (hierarchy != null)) && (service.GetProjectOfUniqueName(silverlightProject.UniqueName, out hierarchy2) == 0)) { ((IVsSilverlightProjectConsumer)hierarchy).LinkToSilverlightProject("ClientBin", true, false, hierarchy2 as IVsSilverlightProject); } } } }
public void RunStarted(object automationObject, Dictionary <string, string> replacementsDictionary, WizardRunKind runKind, object[] customParams) { Replacements = replacementsDictionary; string projName; if (replacementsDictionary.TryGetValue("$safeprojectname$", out projName)) { ProjectName = projName; } string tname; if (replacementsDictionary.TryGetValue("TemplateName", out tname)) { TemplateName = tname; } string tsource; if (replacementsDictionary.TryGetValue("TemplateSource", out tsource)) { TemplateSource = tsource; } string tbranch; if (replacementsDictionary.TryGetValue("TemplateSourceBranch", out tbranch)) { TemplateSourceBranch = tbranch; } string slndir; if (replacementsDictionary.TryGetValue("$destinationdirectory$", out slndir)) { SolutionDirectory = slndir; } string extensionId; if (replacementsDictionary.TryGetValue("ExtensionId", out extensionId)) { ExtensionId = extensionId; } Dte = automationObject as DTE2; var _oleServiceProvider = automationObject as Microsoft.VisualStudio.OLE.Interop.IServiceProvider; var _serviceProvider = new Microsoft.VisualStudio.Shell.ServiceProvider(_oleServiceProvider); var extManager = (IVsExtensionManager)_serviceProvider.GetService(typeof(SVsExtensionManager)); ExtensionInstallDir = GetExtensionInstallDir(ExtensionId, extManager); string pwModsFolder = Path.Combine(ExtensionInstallDir, "PwModules"); EnsurePecanWaffleExtracted(pwModsFolder, ExtensionInstallDir); PowerShellInvoker.Instance.EnsureInstallPwScriptInvoked(ExtensionInstallDir); }
public static IWpfTextView GetWpfTextView(EnvDTE.DTE dte, IVsTextView viewAdapter) { using (ServiceProvider sp = new ServiceProvider((Microsoft.VisualStudio.OLE.Interop.IServiceProvider)dte)) { var svc = (IVsEditorAdaptersFactoryService)sp.GetService(typeof(IVsEditorAdaptersFactoryService)); return svc.GetWpfTextView(viewAdapter); } }
protected ProjectDocumentsListener(ServiceProvider serviceProviderParameter) { Utilities.ArgumentNotNull("serviceProviderParameter", serviceProviderParameter); this.serviceProvider = serviceProviderParameter; this.projectDocTracker = this.serviceProvider.GetService(typeof(SVsTrackProjectDocuments)) as IVsTrackProjectDocuments2; Utilities.CheckNotNull(this.projectDocTracker, "Could not get the IVsTrackProjectDocuments2 object from the services exposed by this project"); }
public ErrorListHelper(object dte2) { _serviceProvider = new ServiceProvider(dte2 as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); _errorProvider = new ErrorListProvider(_serviceProvider);//this implementing IServiceProvider _errorProvider.ProviderName = "JS Lint"; _errorProvider.ProviderGuid = new Guid(); // should be package guid _errorProvider.Show(); }
/// <summary> /// Constructor that calls the Microsoft.VisualStudio.Shell.WindowPane constructor then /// our initialization functions. /// </summary> /// <param name="package">Our Package instance.</param> public EditorPane(ServiceProvider service, VSNDK_PackagePackage package, string fileName, IVsTextLines textBuffer) : base(null) { _thisPackage = package; _fileName = fileName; _textBuffer = textBuffer; _service = service; }
/// <summary> /// Overloaded Constructor /// </summary> /// <param name="viewModel"></param> public VsDesignerControl(ServiceProvider serviceProvider, IViewModel viewModel) { _serviceProvider = serviceProvider; DataContext = viewModel; InitializeComponent(); // wait until we're initialized to handle events viewModel.ViewModelChanged += new EventHandler(ViewModelChanged); }
/// <summary> /// Initializes a new instance of the <see cref="OutliningSynchronizationManager" /> class. /// </summary> /// <param name="package">The hosting package.</param> public OutliningSynchronizationManager(CodeMaidPackage package) { _package = package; // Retrieve services needed for outlining from the package. _editorAdaptersFactoryService = _package.ComponentModel.GetService<IVsEditorAdaptersFactoryService>(); _outliningManagerService = _package.ComponentModel.GetService<IOutliningManagerService>(); _serviceProvider = new ServiceProvider((IServiceProvider)_package.IDE); }
public void SetSite(object pUnkSite) { // Save away the site object for later use _site = pUnkSite; // These are initialized on demand via our private CodeProvider and SiteServiceProvider properties _codeDomProvider = null; _serviceProvider = null; }
public VsOutputWindow(DTE2 dte2) { using ( var sp = new ServiceProvider( (IServiceProvider) dte2)) { _output = (IVsOutputWindow) sp.GetService(typeof (SVsOutputWindow)); } }
///------------------------------------------------------------------------------------------------------------- /// <summary> /// Initializes the generator state. /// </summary> ///------------------------------------------------------------------------------------------------------------- void IVsCodeBehindCodeGenerator.Initialize(IVsHierarchy hierarchy) { IOleServiceProvider serviceProvider = null; _hierarchy = hierarchy; _hierarchy.GetSite(out serviceProvider); _serviceProvider = new ServiceProvider(serviceProvider); _codeGeneratorOptions = new CodeGeneratorOptions(); _codeGeneratorOptions.BlankLinesBetweenMembers = false; }
public VisualStudioAutomation(DTE dte) { this.dteInternal = dte; ServiceProvider serviceProvider = new ServiceProvider(dte as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); this.solutionEventsListener = new SolutionEventsListener(serviceProvider); this.QuitVisualStudioOnDispose = true; }
protected SelectionListener(ServiceProvider serviceProvider) { this.serviceProvider = serviceProvider; this.monSel = serviceProvider.GetService(typeof(SVsShellMonitorSelection)) as IVsMonitorSelection; if(this.monSel == null) { throw new InvalidOperationException(); } }
public void RunStarted(object automationObject, Dictionary<string, string> replacementsDictionary, WizardRunKind runKind, object[] customParams) { try { Directory.Delete(replacementsDictionary["$destinationdirectory$"]); Directory.Delete(replacementsDictionary["$solutiondirectory$"]); } catch { // If it fails (doesn't exist/contains files/read-only), let the directory stay. } var dte = automationObject as DTE; if (dte == null) { var provider = automationObject as Microsoft.VisualStudio.OLE.Interop.IServiceProvider; if (provider != null) { dte = new ServiceProvider(provider).GetService(typeof(DTE)) as DTE; } } bool addingNewProject = false; if (dte == null) { MessageBox.Show("Unable to start wizard: no automation object available.", "Node.js Tools for Visual Studio"); } else { // https://nodejstools.codeplex.com/workitem/462 // we need to make sure our package is loaded before invoking our command Guid packageGuid = new Guid(Guids.NodejsPackageString); IVsPackage package; ((IVsShell)Package.GetGlobalService(typeof(SVsShell))).LoadPackage( ref packageGuid, out package ); System.Threading.Tasks.Task.Factory.StartNew(() => { string projName = replacementsDictionary["$projectname$"]; string solnName = replacementsDictionary["$specifiedsolutionname$"]; string directory; if (String.IsNullOrWhiteSpace(solnName)) { // Create directory is unchecked, destinationdirectory is the // directory name the user entered plus the project name, we want // to remove the project name. directory = Path.GetDirectoryName(replacementsDictionary["$destinationdirectory$"]); } else { // Create directory is checked, the destinationdirectory is the // directory the user entered plus the project name plus the // solution name - we want to remove both extra folders directory = Path.GetDirectoryName(Path.GetDirectoryName(replacementsDictionary["$destinationdirectory$"])); } var context = addingNewProject ? (int)VSConstants.VSStd97CmdID.AddExistingProject : (int)VSConstants.VSStd97CmdID.OpenProject; object inObj = projName + "|" + directory + "|" + context, outObj = null; dte.Commands.Raise(Guids.NodejsCmdSet.ToString("B"), (int)PkgCmdId.cmdidImportWizard, ref inObj, ref outObj); }); } addingNewProject = IsAddNewProjectCmd; throw new WizardCancelledException(); }
public FileSystemNavigateToTarget(string fileName, int line, int column, ServiceProvider serviceProvider) { Contract.Requires<ArgumentNullException>(fileName != null, "fileName"); Contract.Requires<ArgumentNullException>(serviceProvider != null, "serviceProvider"); Contract.Requires<ArgumentException>(!string.IsNullOrEmpty(fileName)); FileName = fileName; Line = line; Column = column; ServiceProvider = serviceProvider; }
/// <summary> /// Retrieves the <see cref="IServiceLocator"/> for the given project. /// </summary> /// <exception cref="ArgumentNullException">The <paramref name="project"/> parameter was null.</exception> /// <exception cref="InvalidOperationException">The required <see cref="IComponentModel"/> service was not found.</exception> public static IServiceLocator GetServiceLocator(this Project project) { Guard.NotNull(nameof(project), project); var components = new Microsoft.VisualStudio.Shell.ServiceProvider((Ole.IServiceProvider)project.DTE).GetService <SComponentModel, IComponentModel>(); try { return(components.GetService <IServiceLocatorProvider> ().GetServiceLocator(project)); } catch (ImportCardinalityMismatchException ex) { throw new MissingDependencyException(Strings.ServiceLocator.MissingDependency(typeof(IServiceLocatorProvider)), ex); } }
private ITypeResolutionService GetResolutionService(EnvDTE.Project project, Microsoft.VisualStudio.Shell.ServiceProvider provider) { var typeService = ( DynamicTypeService )provider.GetService(typeof(DynamicTypeService)); IVsSolution sln = provider.GetService(typeof(IVsSolution)) as IVsSolution; IVsHierarchy hier; sln.GetProjectOfUniqueName(project.UniqueName, out hier); return(typeService.GetTypeResolutionService(hier)); }
private void Dispose(bool dispose) { ThreadHelper.ThrowIfNotOnUIThread(); if (dispose) { if (_serviceProvider != null) { _serviceProvider.Dispose(); _serviceProvider = null; } } }
public static HelpContext2 GetHelpContext(DTE2 dte) { // Get a reference to the current active window (presumably a code editor). Window activeWindow = dte.ActiveWindow; // make a few gnarly COM-interop calls in order to get Help Context Microsoft.VisualStudio.OLE.Interop.IServiceProvider sp = (Microsoft.VisualStudio.OLE.Interop.IServiceProvider)activeWindow.DTE; Microsoft.VisualStudio.Shell.ServiceProvider serviceProvider = new Microsoft.VisualStudio.Shell.ServiceProvider(sp); IVsMonitorUserContext contextMonitor = (IVsMonitorUserContext)serviceProvider.GetService(typeof(IVsMonitorUserContext)); IVsUserContext userContext; int hresult = contextMonitor.get_ApplicationContext(out userContext); HelpContext2 attrs = new HelpContext2(userContext); return(attrs); }
/// <summary> /// Attach to a process. /// </summary> /// <param name="sProcessName"></param> private void AttachDebugTarget(string sProcessName) { Microsoft.VisualStudio.Shell.ServiceProvider sp = new Microsoft.VisualStudio.Shell.ServiceProvider((Microsoft.VisualStudio.OLE.Interop.IServiceProvider)_applicationObject); IVsDebugger dbg = (IVsDebugger)sp.GetService(typeof(SVsShellDebugger)); foreach (Process lLocalProcess in _applicationObject.Debugger.LocalProcesses) { if (lLocalProcess.Name.IndexOf(sProcessName) >= 0) { (lLocalProcess as Process2).Attach2("NPL Debug Engine"); break; } } }
public override bool Execute() { System.Diagnostics.Debugger.Launch(); //CoInitializeEx(NULL, COINIT_MULTITHREADED); //enum comEnum = {COINIT_MULTITHREADED=0}; //CoInitializeEx((IntPtr)null, (uint)0); _applicationObject = (EnvDTE80.DTE2)System.Runtime.InteropServices.Marshal.GetActiveObject("VisualStudio.DTE.10.0"); Microsoft.VisualStudio.Shell.ServiceProvider sp = new Microsoft.VisualStudio.Shell.ServiceProvider((Microsoft.VisualStudio.OLE.Interop.IServiceProvider)_applicationObject); IVsDebugger dbg = (IVsDebugger)sp.GetService(typeof(SVsShellDebugger)); VsDebugTargetInfo info = new VsDebugTargetInfo(); info.cbSize = (uint)System.Runtime.InteropServices.Marshal.SizeOf(info); info.dlo = Microsoft.VisualStudio.Shell.Interop.DEBUG_LAUNCH_OPERATION.DLO_CreateProcess; info.bstrExe = _filePath; info.bstrCurDir = System.IO.Path.GetDirectoryName(info.bstrExe); info.bstrArg = null; // no command line parameters info.bstrRemoteMachine = null; // debug locally info.fSendStdoutToOutputWindow = 0; // Let stdout stay with the application. info.clsidCustom = new Guid("{D951924A-4999-42a0-9217-1EB5233D1D5A}"); // Set the launching engine the sample engine guid info.grfLaunch = 0; IntPtr pInfo = System.Runtime.InteropServices.Marshal.AllocCoTaskMem((int)info.cbSize); System.Runtime.InteropServices.Marshal.StructureToPtr(info, pInfo, false); try { dbg.LaunchDebugTargets(1, pInfo); } finally { if (pInfo != IntPtr.Zero) { System.Runtime.InteropServices.Marshal.FreeCoTaskMem(pInfo); } } return(true); }
public static IVsTextView GetVsTextViewFrompPath(string filePath) { var dte2 = (EnvDTE80.DTE2)Package.GetGlobalService(typeof(SDTE)); var sp = (Microsoft.VisualStudio.OLE.Interop.IServiceProvider)dte2; var serviceProvider = new Microsoft.VisualStudio.Shell.ServiceProvider(sp); IVsUIHierarchy uiHierarchy; uint itemID; IVsWindowFrame windowFrame; if (VsShellUtilities.IsDocumentOpen(serviceProvider, filePath, Guid.Empty, out uiHierarchy, out itemID, out windowFrame)) { // Get the IVsTextView from the windowFrame. return(VsShellUtilities.GetTextView(windowFrame)); } return(null); }
public IServiceLocator GetServiceLocator(IVsHierarchy hierarchy) { Guard.NotNull(nameof(hierarchy), hierarchy); IServiceProvider services; Ole.IServiceProvider site; if (ErrorHandler.Failed(hierarchy.GetSite(out site))) { services = Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider; } else { services = new Microsoft.VisualStudio.Shell.ServiceProvider(site); } return(new ServiceLocatorImpl(services)); }
//http://stackoverflow.com/a/2427368/4574 internal static Microsoft.VisualStudio.TextManager.Interop.IVsTextView GetIVsTextView(string filePath) { var dte2 = (EnvDTE80.DTE2)Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(Microsoft.VisualStudio.Shell.Interop.SDTE)); Microsoft.VisualStudio.OLE.Interop.IServiceProvider sp = (Microsoft.VisualStudio.OLE.Interop.IServiceProvider)dte2; Microsoft.VisualStudio.Shell.ServiceProvider serviceProvider = new Microsoft.VisualStudio.Shell.ServiceProvider(sp); Microsoft.VisualStudio.Shell.Interop.IVsUIHierarchy uiHierarchy; uint itemID; Microsoft.VisualStudio.Shell.Interop.IVsWindowFrame windowFrame; //Microsoft.VisualStudio.Text.Editor.IWpfTextView wpfTextView = null; if (Microsoft.VisualStudio.Shell.VsShellUtilities.IsDocumentOpen(serviceProvider, filePath, Guid.Empty, out uiHierarchy, out itemID, out windowFrame)) { // Get the IVsTextView from the windowFrame. return(Microsoft.VisualStudio.Shell.VsShellUtilities.GetTextView(windowFrame)); } return(null); }
public void SpotClient_OnTrackChange(object sender, SpotifyAPI.Local.TrackChangeEventArgs e) { if (!UserPreferences.Default.showTrackArtistOnChange) { Console.WriteLine("ShowTrackArtist is disabled in user preferences."); return; } if (e.NewTrack == null || e.NewTrack.TrackResource == null || e.NewTrack.TrackResource.Name == null || e.NewTrack.AlbumResource.Name == null) { return; } string trackName = e.NewTrack.TrackResource.Name; string artistName = e.NewTrack.ArtistResource.Name; Console.WriteLine("Show New track name: " + trackName); myOleCommand.Text = String.Format("{0} - {1}", trackName, artistName); Microsoft.VisualStudio.Shell.ServiceProvider serviceProvider = new Microsoft.VisualStudio.Shell.ServiceProvider(((EnvDTE.DTE)Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider.GetService(typeof(EnvDTE.DTE))) as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); IVsUIShell uiShell = serviceProvider.GetService(typeof(SVsUIShell)) as IVsUIShell; uiShell.UpdateCommandUI(0); if (timer != null) { timer.Stop(); timer.Start(); } else { timer = new System.Timers.Timer() { Interval = kSHOW_TRACK_INTERVAL }; //timer.AutoReset = false; timer.Elapsed += TrackChangeTimerTick; timer.Start(); } }
public static IVsWindowFrame IsDocumentOpened(string filePath) { if (string.IsNullOrEmpty(filePath) || !File.Exists(filePath)) { return(null); } var dte2 = (EnvDTE80.DTE2)Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(EnvDTE.DTE)) as EnvDTE80.DTE2; Microsoft.VisualStudio.OLE.Interop.IServiceProvider sp = (Microsoft.VisualStudio.OLE.Interop.IServiceProvider)dte2; Microsoft.VisualStudio.Shell.ServiceProvider serviceProvider = new Microsoft.VisualStudio.Shell.ServiceProvider(sp); IVsUIHierarchy hierarchy; uint itemId; IVsWindowFrame frame = null; if (VsShellUtilities.IsDocumentOpen(serviceProvider, filePath, VSConstants.LOGVIEWID_Primary, out hierarchy, out itemId, out frame)) { return(frame); } return(null); }
/// <summary> /// Attach to a process. /// </summary> /// <param name="sProcessName"></param> public void AttachDebugTarget(int nProcessID) { Microsoft.VisualStudio.Shell.ServiceProvider sp = new Microsoft.VisualStudio.Shell.ServiceProvider((Microsoft.VisualStudio.OLE.Interop.IServiceProvider)_applicationObject); IVsDebugger dbg = (IVsDebugger)sp.GetService(typeof(SVsShellDebugger)); foreach (Process lLocalProcess in _applicationObject.Debugger.LocalProcesses) { if (lLocalProcess.ProcessID == nProcessID) { try { if (true) { var myThread = new System.Threading.Thread(() => { (lLocalProcess as Process2).Attach2("NPLDebugEngineV2"); Console.Write("NPLDebugEngineV2 attached"); }); myThread.Start(); } else { //strange: this function hangs // In VS, TOOLS -> Options... -> Debugging -> General and checked Use Managed Compatibility Mode option: (lLocalProcess as Process2).Attach2("NPLDebugEngineV2"); } } catch (Exception err) { Console.Write(err.ToString()); MessageBox.Show(String.Format("failed to attach to process {0}. because {1}. You many need to register the debug engine.", nProcessID, err.ToString())); } break; } } }
/// <summary> /// Retrieves the <see cref="IServiceLocator"/> for the given hierarchy. /// </summary> /// <exception cref="ArgumentNullException">The <paramref name="hierarchy"/> parameter was null.</exception> /// <exception cref="InvalidOperationException">The required <see cref="IComponentModel"/> service was not found.</exception> public static IServiceLocator GetServiceLocator(this IVsHierarchy hierarchy) { Guard.NotNull(nameof(hierarchy), hierarchy); IServiceProvider services; Ole.IServiceProvider site; if (ErrorHandler.Failed(hierarchy.GetSite(out site))) { services = Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider; } else { services = new Microsoft.VisualStudio.Shell.ServiceProvider(site); } var components = services.GetService <SComponentModel, IComponentModel>(); try { return(components.GetService <IServiceLocatorProvider> ().GetServiceLocator(hierarchy)); } catch (ImportCardinalityMismatchException ex) { throw new MissingDependencyException(Strings.ServiceLocator.MissingDependency(typeof(IServiceLocatorProvider)), ex); } }
/// <summary> /// Launch an executable using the sample debug engine. /// </summary> public void LaunchDebugTarget(string command, string arguments, string workingDir) { Microsoft.VisualStudio.Shell.ServiceProvider sp = new Microsoft.VisualStudio.Shell.ServiceProvider((Microsoft.VisualStudio.OLE.Interop.IServiceProvider)_applicationObject); IVsDebugger dbg = (IVsDebugger)sp.GetService(typeof(SVsShellDebugger)); VsDebugTargetInfo info = new VsDebugTargetInfo(); info.cbSize = (uint)System.Runtime.InteropServices.Marshal.SizeOf(info); info.dlo = Microsoft.VisualStudio.Shell.Interop.DEBUG_LAUNCH_OPERATION.DLO_CreateProcess; info.bstrExe = command; info.bstrCurDir = String.IsNullOrEmpty(workingDir) ? System.IO.Path.GetDirectoryName(info.bstrExe) : workingDir; info.bstrArg = arguments; // command line parameters info.bstrRemoteMachine = null; // debug locally info.fSendStdoutToOutputWindow = 0; // Let stdout stay with the application. info.clsidCustom = new Guid("{0B18F022-A5F5-41EA-8532-4CF3B894A7C6}"); // Set the launching engine the sample engine guid info.grfLaunch = 0; IntPtr pInfo = System.Runtime.InteropServices.Marshal.AllocCoTaskMem((int)info.cbSize); System.Runtime.InteropServices.Marshal.StructureToPtr(info, pInfo, false); try { dbg.LaunchDebugTargets(1, pInfo); } finally { if (pInfo != IntPtr.Zero) { System.Runtime.InteropServices.Marshal.FreeCoTaskMem(pInfo); } } }
/// <summary> /// Launch an executible using the sample debug engine. /// </summary> private void LaunchDebugTarget(string filePath, Guid engineGuid) { Microsoft.VisualStudio.Shell.ServiceProvider sp = new Microsoft.VisualStudio.Shell.ServiceProvider((Microsoft.VisualStudio.OLE.Interop.IServiceProvider)_applicationObject); IVsDebugger dbg = (IVsDebugger)sp.GetService(typeof(SVsShellDebugger)); VsDebugTargetInfo info = new VsDebugTargetInfo(); info.cbSize = (uint)System.Runtime.InteropServices.Marshal.SizeOf(info); info.dlo = Microsoft.VisualStudio.Shell.Interop.DEBUG_LAUNCH_OPERATION.DLO_CreateProcess; info.bstrExe = filePath; info.bstrCurDir = System.IO.Path.GetDirectoryName(info.bstrExe); info.bstrArg = null; // no command line parameters info.bstrRemoteMachine = null; // debug locally info.fSendStdoutToOutputWindow = 0; // Let stdout stay with the application. info.clsidCustom = engineGuid; info.grfLaunch = 0; IntPtr pInfo = IntPtr.Zero; try { pInfo = System.Runtime.InteropServices.Marshal.AllocCoTaskMem((int)info.cbSize); System.Runtime.InteropServices.Marshal.StructureToPtr(info, pInfo, false); dbg.LaunchDebugTargets(1, pInfo); } finally { if (pInfo != IntPtr.Zero) { System.Runtime.InteropServices.Marshal.FreeCoTaskMem(pInfo); } } }
/// <summary> /// Initializes a new instance of the <see cref="Command4"/> 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 Command4(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); myOleCommand = new OleMenuCommand(this.MenuItemCallback, menuCommandID); //if (null != myOleCommand) //{ // myOleCommand.Text = "New Text"; // //} if (IsSpotifyProcessRunning()) { if (Command1Package.SpotifyCommandShouldShowText()) { myOleCommand.Text = kSpotifyOpenString; } else { myOleCommand.Text = " "; } } else { if (UserPreferences.Default.HideButtonTextOnInactive) { myOleCommand.Text = " "; } else { myOleCommand.Text = kSpotifyStartString; } } Microsoft.VisualStudio.Shell.ServiceProvider serviceProvider = new Microsoft.VisualStudio.Shell.ServiceProvider(((EnvDTE.DTE)Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider.GetService(typeof(EnvDTE.DTE))) as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); IVsUIShell uiShell = serviceProvider.GetService(typeof(SVsUIShell)) as IVsUIShell; uiShell.UpdateCommandUI(0); if (IsSpotifyProcessRunning()) { SpotClientRegisterTrackChange(); } commandService.AddCommand(myOleCommand); gCommand4Instance = this; } }
/// <summary> /// Launch an executable using the VSNDK debug engine. /// </summary> /// <param name="pidString"> Process ID in string format. </param> /// <returns> TRUE if successful, False if not. </returns> private bool LaunchDebugTarget(string pidString) { Microsoft.VisualStudio.Shell.ServiceProvider sp = new Microsoft.VisualStudio.Shell.ServiceProvider((Microsoft.VisualStudio.OLE.Interop.IServiceProvider)_dte); IVsDebugger dbg = (IVsDebugger)sp.GetService(typeof(SVsShellDebugger)); VsDebugTargetInfo info = new VsDebugTargetInfo(); info.cbSize = (uint)System.Runtime.InteropServices.Marshal.SizeOf(info); info.dlo = Microsoft.VisualStudio.Shell.Interop.DEBUG_LAUNCH_OPERATION.DLO_CreateProcess; // Read debugger args from a file (it is set when the Deploy task is run) System.IO.StreamReader argsFile = null; try { string localAppData = Environment.GetEnvironmentVariable("AppData"); argsFile = new System.IO.StreamReader(localAppData + @"\BlackBerry\vsndk-args-file.txt"); } catch (Exception e) { Debug.Fail("Unexpected exception in LaunchDebugTarget"); } // Store all debugger arguments in a string var nvc = new NameValueCollection(); nvc.Add("pid", pidString); nvc.Add("targetIP", argsFile.ReadLine()); // The device (IP address) info.bstrExe = argsFile.ReadLine(); // The executable path nvc.Add("isSimulator", argsFile.ReadLine()); nvc.Add("ToolsPath", argsFile.ReadLine()); nvc.Add("PublicKeyPath", argsFile.ReadLine()); // Decrypt stored password. byte[] data = Convert.FromBase64String(argsFile.ReadLine()); if (data.Length > 0) { byte[] decrypted = ProtectedData.Unprotect(data, null, DataProtectionScope.LocalMachine); nvc.Add("Password", Encoding.Unicode.GetString(decrypted)); } info.bstrArg = NameValueCollectionHelper.DumpToString(nvc); argsFile.Close(); info.bstrRemoteMachine = null; // debug locally info.fSendStdoutToOutputWindow = 0; // Let stdout stay with the application. info.clsidCustom = new Guid("{E5A37609-2F43-4830-AA85-D94CFA035DD2}"); // Set the launching engine the VSNDK engine guid info.grfLaunch = 0; IntPtr pInfo = System.Runtime.InteropServices.Marshal.AllocCoTaskMem((int)info.cbSize); System.Runtime.InteropServices.Marshal.StructureToPtr(info, pInfo, false); try { int result = dbg.LaunchDebugTargets(1, pInfo); if (result != VSConstants.S_OK) { string msg; IVsUIShell sh = (IVsUIShell)sp.GetService(typeof(SVsUIShell)); sh.GetErrorInfo(out msg); Debug.WriteLine("LaunchDebugTargets: " + msg); return(true); } } finally { if (pInfo != IntPtr.Zero) { System.Runtime.InteropServices.Marshal.FreeCoTaskMem(pInfo); } } return(false); }
/// <summary> /// Creates the MVC item and add it to the MVC project. /// </summary> /// <param name="vsProj">The Visual Studio project.</param> private void GenerateMVCItems(VSProject vsProj) { if (string.IsNullOrEmpty(_connectionString)) { return; } if (_selectedTables == null || _selectedTables.Count == 0) { return; } #if CLR4 || NET_40_OR_GREATER IServiceProvider serviceProvider = new Microsoft.VisualStudio.Shell.ServiceProvider((Microsoft.VisualStudio.OLE.Interop.IServiceProvider)dte); Microsoft.VisualStudio.TextTemplating.VSHost.ITextTemplating t4 = serviceProvider.GetService(typeof(STextTemplating)) as ITextTemplating; ITextTemplatingSessionHost sessionHost = t4 as ITextTemplatingSessionHost; var controllerClassPath = string.Empty; var IndexFilePath = string.Empty; var fileExtension = string.Empty; Version productVersion = Assembly.GetExecutingAssembly().GetName().Version; var version = String.Format("{0}.{1}.{2}", productVersion.Major, productVersion.Minor, productVersion.Build); double visualStudioVersion; double.TryParse(ItemTemplateUtilities.GetVisualStudioVersion(dte), out visualStudioVersion); if (_language == LanguageGenerator.CSharp) { controllerClassPath = Path.GetFullPath(string.Format("{0}{1}{2}", T4Templates_Path, version, cSharpControllerClass_FileName)); IndexFilePath = Path.GetFullPath(string.Format("{0}{1}{2}", T4Templates_Path, version, cSharpIndexFile_FileName)); fileExtension = "cs"; } else { controllerClassPath = Path.GetFullPath(string.Format("{0}{1}{2}", T4Templates_Path, version, vbControllerClass_FileName)); IndexFilePath = Path.GetFullPath(string.Format("{0}{1}{2}", T4Templates_Path, version, vbIndexFile_FileName)); fileExtension = "vb"; } StringBuilder catalogs = new StringBuilder(); catalogs = new StringBuilder("<h3> Catalog list</h3>"); catalogs.AppendLine(); foreach (var table in TablesIncludedInModel) { catalogs.AppendLine(string.Format(@"<div> @Html.ActionLink(""{0}"",""Index"", ""{0}"")</div>", table.Key[0].ToString().ToUpperInvariant() + table.Key.Substring(1))); } try { foreach (var table in TablesIncludedInModel) { // creating controller file sessionHost.Session = sessionHost.CreateSession(); sessionHost.Session["namespaceParameter"] = string.Format("{0}.Controllers", _projectNamespace); sessionHost.Session["applicationNamespaceParameter"] = string.Format("{0}.Models", _projectNamespace); sessionHost.Session["controllerClassParameter"] = string.Format("{0}Controller", table.Key[0].ToString().ToUpperInvariant() + table.Key.Substring(1)); if ((_dataAccessTechnology == DataAccessTechnology.EntityFramework6 && _language == LanguageGenerator.VBNET) || _language == LanguageGenerator.CSharp) { sessionHost.Session["modelNameParameter"] = _connectionName; } else if (_dataAccessTechnology == DataAccessTechnology.EntityFramework5 && _language == LanguageGenerator.VBNET) { sessionHost.Session["modelNameParameter"] = string.Format("{1}.{0}", _connectionName, _projectNamespace); } sessionHost.Session["classNameParameter"] = table.Key; sessionHost.Session["entityNameParameter"] = table.Key[0].ToString().ToUpperInvariant() + table.Key.Substring(1); sessionHost.Session["entityClassNameParameter"] = table.Key; if ((visualStudioVersion < 12.0 && _language == LanguageGenerator.VBNET) || _language == LanguageGenerator.CSharp) { sessionHost.Session["entityClassNameParameterWithNamespace"] = string.Format("{0}.{1}", _projectNamespace, table.Key); } else if (_language == LanguageGenerator.VBNET && visualStudioVersion >= 12.0) { if (_dataAccessTechnology == DataAccessTechnology.EntityFramework5) { sessionHost.Session["entityClassNameParameterWithNamespace"] = string.Format("{0}.{0}.{1}", _projectNamespace, table.Key); } else if (_dataAccessTechnology == DataAccessTechnology.EntityFramework6) { sessionHost.Session["entityClassNameParameterWithNamespace"] = string.Format("{0}.{1}", _projectNamespace, table.Key); } } T4Callback cb = new T4Callback(); StringBuilder resultControllerFile = new StringBuilder(t4.ProcessTemplate(controllerClassPath, File.ReadAllText(controllerClassPath), cb)); string controllerFilePath = string.Format(@"{0}\Controllers\{1}Controller.{2}", _projectPath, table.Key[0].ToString().ToUpperInvariant() + table.Key.Substring(1), fileExtension); File.WriteAllText(controllerFilePath, resultControllerFile.ToString()); if (cb.errorMessages.Count > 0) { File.AppendAllLines(controllerFilePath, cb.errorMessages); } vsProj.Project.ProjectItems.AddFromFile(controllerFilePath); var viewPath = Path.GetFullPath(_projectPath + string.Format(@"\Views\{0}", table.Key[0].ToString().ToUpperInvariant() + table.Key.Substring(1))); Directory.CreateDirectory(viewPath); string resultViewFile = t4.ProcessTemplate(IndexFilePath, File.ReadAllText(IndexFilePath), cb); File.WriteAllText(string.Format(viewPath + @"\Index.{0}html", fileExtension), resultViewFile); if (cb.errorMessages.Count > 0) { File.AppendAllLines(controllerFilePath, cb.errorMessages); } vsProj.Project.ProjectItems.AddFromFile(string.Format(viewPath + @"\Index.{0}html", fileExtension)); } } catch (Exception ex) { SendToGeneralOutputWindow(string.Format("An error occurred: {0}\n\n {1}", ex.Message, ex.StackTrace)); InfoDialog.ShowDialog(InfoDialogProperties.GetErrorDialogProperties(Resources.ErrorTitle, Resources.ItemTemplatesBaseWebWizard_GenerateMvcItemsError)); } #endif }
public virtual int SetSite(IOleServiceProvider psp) { _serviceProvider = new ServiceProvider(psp); return(VSConstants.S_OK); }
/// <summary>Implements the OnConnection method of the IDTExtensibility2 interface. Receives notification that the Add-in is being loaded.</summary> /// <param term='application'>Root object of the host application.</param> /// <param term='connectMode'>Describes how the Add-in is being loaded.</param> /// <param term='addInInst'>Object representing this Add-in.</param> /// <seealso class='IDTExtensibility2' /> public void OnConnection(object application, ext_ConnectMode connectMode, object addInInst, ref Array custom) { _applicationObject = (DTE2)application; _addInInstance = (AddIn)addInInst; try { // ctlProgID - the ProgID for your user control. asmPath - the path to your user control DLL. guidStr - a unique GUID for the user control. string ctlProgID, asmPath, guidStr; // Variables for the new tool window that will hold // your user control. EnvDTE80.Windows2 toolWins; EnvDTE.Window toolWin; object objTemp = null; _applicationObject = (DTE2)application; _addInInstance = (AddIn)addInInst; ctlProgID = "Hobbisoft.Slam.Tools.Analyzers.VisualizerHost"; // Replace the <Path to VS Project> with the path to // the folder where you created the WindowsCotrolLibrary. // Remove the line returns from the path before // running the add-in. asmPath = @"D:\inetpub\Core\Core\Hobbisoft.Slam.Tools.Analyzers\bin\Debug\Hobbisoft.Slam.Tools.Analyzers.exe"; guidStr = "{9ED54F84-A89D-4fcd-A854-44251E922109}"; toolWins = (Windows2)_applicationObject.Windows; // Create the new tool window, adding your user control. toolWin = toolWins.CreateToolWindow2(_addInInstance, asmPath, ctlProgID, "Salesforce Analyzers", guidStr, ref objTemp); // The tool window must be visible before you do anything // with it, or you will get an error. if (toolWin != null) { toolWin.Visible = true; } toolWin.Height = 500; toolWin.Width = 400; // Get the service provider on the object Microsoft.VisualStudio.Shell.ServiceProvider serviceProvider = new Microsoft.VisualStudio.Shell.ServiceProvider(this._applicationObject as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); // Get the shell service var vsUIShell = (IVsUIShell)serviceProvider.GetService(typeof(SVsUIShell)); Guid slotGuid = new Guid("63ed935d-eac2-4b8f-9208-f28f48d49f6b"); // Find the associated window frame on this toolwindow IVsWindowFrame wndFrame; vsUIShell.FindToolWindow((uint)__VSFINDTOOLWIN.FTW_fFrameOnly, ref slotGuid, out wndFrame); // Set the text on the window tab name wndFrame.SetProperty((int)__VSFPROPID.VSFPROPID_Caption, "Salesforce"); } catch (Exception ex) { //System.Windows.Forms.MessageBox.Show("Exception: " // + ex.Message); } }
/// <summary> /// Implements <see cref="IWizard.RunStarted"/> /// </summary> protected void RunStarted(object automationObject, Dictionary <string, string> replacementsDictionary, WizardRunKind runKind, object[] customParams) { IOleServiceProvider oleServiceProvider = automationObject as IOleServiceProvider; ServiceProvider serviceProvider = (oleServiceProvider != null) ? new ServiceProvider(oleServiceProvider) : null; DataConnectionDialogFactory dialogFactory = GetService <DataConnectionDialogFactory>(serviceProvider); Debug.Assert(dialogFactory != null, "Can't get DataConnectionDialogFactory!"); System.Data.IDbConnection dbConn; DataConnectionDialog dialog = dialogFactory.CreateConnectionDialog(); dialog.AddAllSources(); DataConnection dataConn = dialog.ShowDialog(false); if (dataConn != null) { if ((dbConn = dataConn.ConnectionSupport.ProviderObject as System.Data.IDbConnection) == null) { // show error return; } DataProviderManager manager = GetService <DataProviderManager>(serviceProvider); if (manager != null) { DataProvider provider = manager.GetDataProvider(dataConn.Provider); string invariantName = provider.GetProperty("InvariantName") as string; IList <string> schemaList = DcilSchema.GetAvailableSchemaNames(dbConn, invariantName); string selectedSchema = null; switch (schemaList.Count) { case 1: selectedSchema = schemaList[0]; break; default: // Allow this for an empty list selectedSchema = SchemaSelector.SelectSchema(serviceProvider, schemaList); break; } if (!string.IsNullOrEmpty(selectedSchema)) { DcilSchema schema = DcilSchema.FromSchemaName(selectedSchema, dbConn, invariantName); StringBuilder stringBuilder = new StringBuilder(); string replacementString = null; using (MemoryStream ms = new MemoryStream()) { DcilSchema.Serialize(schema, ms); ms.Seek(0, SeekOrigin.Begin); StreamReader sr = new StreamReader(ms); replacementString = sr.ReadToEnd(); } replacementsDictionary.Add("$DcilFile$", replacementString); myAddToProject = true; } } } }