public ProjectInfo(Guid projectGuid, Guid typeGuid, IVsHierarchy hierarchy, string name, string filename) { ProjectGuid = projectGuid; ProjectType = typeGuid; Hierarchy = hierarchy; Name = name; Filename = filename; }
public CSharpProjectShim( ICSharpProjectRoot projectRoot, VisualStudioProjectTracker projectTracker, Func<ProjectId, IVsReportExternalErrors> reportExternalErrorCreatorOpt, string projectSystemName, IVsHierarchy hierarchy, IServiceProvider serviceProvider, VisualStudioWorkspaceImpl visualStudioWorkspaceOpt, HostDiagnosticUpdateSource hostDiagnosticUpdateSourceOpt, ICommandLineParserService commandLineParserServiceOpt) : base(projectTracker, reportExternalErrorCreatorOpt, projectSystemName, hierarchy, LanguageNames.CSharp, serviceProvider, visualStudioWorkspaceOpt, hostDiagnosticUpdateSourceOpt, commandLineParserServiceOpt) { _projectRoot = projectRoot; _warningNumberArrayPointer = Marshal.AllocHGlobal(0); // Ensure the default options are set up ResetAllOptions(); UpdateOptions(); projectTracker.AddProject(this); }
internal PythonLibraryNode(ScopeNode scope, string namePrefix, IVsHierarchy hierarchy, uint itemId) : base(scope.Name) { if (scope is FunctionNode) { this.NodeType = LibraryNodeType.Members; } else if (scope is ClassNode) { this.NodeType = LibraryNodeType.Classes; this.Name = string.Format(CultureInfo.InvariantCulture, "{0}{1}", namePrefix, scope.Name); } this.ownerHierarchy = hierarchy; this.fileId = itemId; // Now check if we have all the information to navigate to the source location. if ((null != ownerHierarchy) && (VSConstants.VSITEMID_NIL != fileId)) { if ((0 != Location.Compare(Location.None, scope.Start)) && (0 != Location.Compare(Location.None, scope.End))) { sourceSpan = new TextSpan(); sourceSpan.iStartIndex = scope.Start.Column; if (scope.Start.Line > 0) { sourceSpan.iStartLine = scope.Start.Line - 1; } sourceSpan.iEndIndex = scope.End.Column; if (scope.End.Line > 0) { sourceSpan.iEndLine = scope.End.Line - 1; } this.CanGoToSource = true; } } }
internal EFModelErrorTask( string document, string errorMessage, int lineNumber, int columnNumber, TaskErrorCategory category, IVsHierarchy hierarchy, uint itemID) : base(document, errorMessage, lineNumber, columnNumber, category, hierarchy, itemID) { Navigate += EFModelErrorTaskNavigator.NavigateTo; }
public static async Task<List<IVsSccProject2>> GetLoadedControllableProjects() { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var list = new List<IVsSccProject2>(); IVsSolution sol = await GetActiveSolution(); list.Add(sol as IVsSccProject2); Guid rguidEnumOnlyThisType = new Guid(); IEnumHierarchies ppenum = null; ErrorHandler.ThrowOnFailure(sol.GetProjectEnum((uint)__VSENUMPROJFLAGS.EPF_LOADEDINSOLUTION, ref rguidEnumOnlyThisType, out ppenum)); IVsHierarchy[] rgelt = new IVsHierarchy[1]; uint pceltFetched = 0; while (ppenum.Next(1, rgelt, out pceltFetched) == VSConstants.S_OK && pceltFetched == 1) { IVsSccProject2 sccProject2 = rgelt[0] as IVsSccProject2; if (sccProject2 != null && await IsProjectInGitRepoitory(sccProject2)) { list.Add(sccProject2); } } return list; }
public HierarchyListener(IVsHierarchy hierarchy, LibraryManager manager) { Utilities.ArgumentNotNull("hierarchy", hierarchy); Utilities.ArgumentNotNull("manager", manager); _hierarchy = hierarchy; _manager = manager; }
public NodejsUwpProjectFlavorCfg(NodejsUwpProjectFlavor baseProjectNode, IVsCfg baseConfiguration, IVsProjectFlavorCfg innerConfiguration) { _baseCfg = baseConfiguration; _innerCfg = innerConfiguration; project = baseProjectNode; mapIVsCfgToNodejsUwpProjectFlavorCfg.Add(baseConfiguration, this); }
public override int OnAfterOpenProject(IVsHierarchy hierarchy, int added) { // If this is a new project and our project. We use here that it is only our project that will implemnet the "internal" IBuildDependencyOnProjectContainer. if(added != 0 && hierarchy is IBuildDependencyUpdate) { IVsUIHierarchy uiHierarchy = hierarchy as IVsUIHierarchy; Debug.Assert(uiHierarchy != null, "The ProjectNode should implement IVsUIHierarchy"); // Expand and select project node IVsUIHierarchyWindow uiWindow = UIHierarchyUtilities.GetUIHierarchyWindow(this.ServiceProvider, HierarchyNode.SolutionExplorer); if(uiWindow != null) { __VSHIERARCHYITEMSTATE state; uint stateAsInt; if(uiWindow.GetItemState(uiHierarchy, VSConstants.VSITEMID_ROOT, (uint)__VSHIERARCHYITEMSTATE.HIS_Expanded, out stateAsInt) == VSConstants.S_OK) { state = (__VSHIERARCHYITEMSTATE)stateAsInt; if(state != __VSHIERARCHYITEMSTATE.HIS_Expanded) { int hr; hr = uiWindow.ExpandItem(uiHierarchy, VSConstants.VSITEMID_ROOT, EXPANDFLAGS.EXPF_ExpandParentsToShowItem); if(ErrorHandler.Failed(hr)) Trace.WriteLine("Failed to expand project node"); hr = uiWindow.ExpandItem(uiHierarchy, VSConstants.VSITEMID_ROOT, EXPANDFLAGS.EXPF_SelectItem); if(ErrorHandler.Failed(hr)) Trace.WriteLine("Failed to select project node"); return hr; } } } } return VSConstants.S_OK; }
public static Project GetProject(IVsHierarchy hierarchy) { object project; ErrorHandler.ThrowOnFailure( hierarchy.GetProperty(VSConstants.VSITEMID_ROOT, (int)__VSHPROPID.VSHPROPID_ExtObject, out project)); return (Project)project; }
// internal for testing purposes only. internal static CPSProject CreateCPSProject(VisualStudioProjectTracker projectTracker, IServiceProvider serviceProvider, IVsHierarchy hierarchy, string projectDisplayName, string projectFilePath, Guid projectGuid, string language, ICommandLineParserService commandLineParserService, string binOutputPath) { return new CPSProject(projectTracker, reportExternalErrorCreatorOpt: null, hierarchy: hierarchy, language: language, serviceProvider: serviceProvider, visualStudioWorkspaceOpt: null, hostDiagnosticUpdateSourceOpt: null, projectDisplayName: projectDisplayName, projectFilePath: projectFilePath, projectGuid: projectGuid, binOutputPath: binOutputPath, commandLineParserServiceOpt: commandLineParserService); }
protected CommonLibraryNode(CommonLibraryNode node) : base(node) { _fileId = node._fileId; _ownerHierarchy = node._ownerHierarchy; _fileMoniker = node._fileMoniker; _sourceSpan = node._sourceSpan; }
int IVsPersistSolutionProps.WriteSolutionProps(IVsHierarchy pHierarchy, string pszKey, IPropertyBag pPropBag) { if (pHierarchy != null) return VSConstants.S_OK; // Not send by our code! else if(pPropBag == null) return VSConstants.E_POINTER; // This method is called from the VS implementation after a request from SaveSolutionProps ISccSettingsStore translate = GetService<ISccSettingsStore>(); IVisualGitSccService scc = GetService<IVisualGitSccService>(); using (IPropertyMap map = translate.GetMap(pPropBag)) { switch (pszKey) { case GitPropertyCategory: map.SetRawValue(ManagedPropertyName, true.ToString()); // BH: Don't localize this text! Changing it will change all solutions marked as managed by VisualGit map.SetRawValue(ManagerPropertyName, "VisualGit - Git Support for Visual Studio"); scc.WriteSolutionProperties(map); break; case VisualGitId.SccStructureName: translate.WriteSolutionProperties(map); break; } } return VSConstants.S_OK; }
public static object GetPropertyValue(int propid, uint itemId, IVsHierarchy vsHierarchy) { if (itemId == VSConstants.VSITEMID_NIL) { return null; } try { object o; ErrorHandler.ThrowOnFailure(vsHierarchy.GetProperty(itemId, propid, out o)); return o; } catch (System.NotImplementedException) { return null; } catch (System.Runtime.InteropServices.COMException) { return null; } catch (System.ArgumentException) { return null; } }
public int OnAfterLastDocumentUnlock(IVsHierarchy pHier, uint itemid, string pszMkDocument, int fClosedWithoutSaving) { //The close initiated in OnAfterSave will cause an additional call here for the .diagram file. if (EDMXFileTools.EdmxTools.RefreshOnSaveEnabled && !String.IsNullOrEmpty(closingDocument)) { if (pszMkDocument.Equals(closingDocument)) { try { DTE dte = Package.GetGlobalService(typeof(DTE)) as DTE; //Now the file is closed we need to iterate to find it. foreach (Project proj in dte.Solution.Projects) { foreach (ProjectItem item in proj.ProjectItems) { if (item.FileNames[0].Equals(closingDocument)) { if (!item.IsOpen) item.Open().Activate(); closingDocument = String.Empty; return VSConstants.S_OK; } } } } catch (Exception ex) { throw new Exception(String.Format("EdmxFileTools Error reactivating {0}, {1}", closingDocument, ex.Message)); } } } return VSConstants.S_OK; }
public int OnAfterOpenProject(IVsHierarchy pHierarchy, int fAdded) { uint cookie; pHierarchy.AdviseHierarchyEvents(new ProjectEventSink(pHierarchy), out cookie); projectCookies[pHierarchy] = cookie; return 0; }
/// <summary> /// Retrieves or creates a node provider for a buffer /// </summary> /// <param name="buffer"></param> /// <returns></returns> internal NodeProvider GetNodeProvider(ITextBuffer buffer, IVsHierarchy hier, string filename) { var provider = new NodeProvider(this, filename, type_resolver); buffer.Properties.AddProperty(typeof(NodeProvider), provider); template_loader.Register(filename, buffer, provider); return provider; }
public CPSProject( VisualStudioProjectTracker projectTracker, Func<ProjectId, IVsReportExternalErrors> reportExternalErrorCreatorOpt, string projectDisplayName, string projectFilePath, IVsHierarchy hierarchy, string language, Guid projectGuid, string commandLineForOptions, IServiceProvider serviceProvider, VisualStudioWorkspaceImpl visualStudioWorkspaceOpt, HostDiagnosticUpdateSource hostDiagnosticUpdateSourceOpt, ICommandLineParserService commandLineParserServiceOpt) : base(projectTracker, reportExternalErrorCreatorOpt, projectDisplayName, projectFilePath, hierarchy, language, projectGuid, serviceProvider, visualStudioWorkspaceOpt, hostDiagnosticUpdateSourceOpt, commandLineParserServiceOpt) { // Initialize the options. SetCommandLineArguments(commandLineForOptions); // We need to ensure that the bin output path for the project has been initialized before we hookup the project with the project tracker. // If we were unable to set the output path from SetCommandLineArguments (due to null output file name or directory in the given commandLineForOptions), // we set a default unique output path. if (this.TryGetBinOutputPath() == null) { var uniqueDefaultOutputPath = PathUtilities.CombinePathsUnchecked(Path.GetTempPath(), projectDisplayName + projectGuid.GetHashCode().ToString()); SetOutputPathAndRelatedData(objOutputPath: uniqueDefaultOutputPath, hasSameBinAndObjOutputPaths: true); } Contract.ThrowIfNull(this.TryGetBinOutputPath()); // Now hook up the project to the project tracker. projectTracker.AddProject(this); _lastDesignTimeBuildSucceeded = true; }
private void DoesItemMatch(IVsHierarchy item, uint id, VsProjectItemPath projectItemPath) { if (DoItemNamesComparison(_input, projectItemPath)) { _foundMatch = true; } }
public int OnRetargetingBeforeChange(string projRef, IVsHierarchy pBeforeChangeHier, string currentTargetFramework, string newTargetFramework, out bool pCanceled, out string ppReasonMsg) { pCanceled = false; ppReasonMsg = ""; return VSConstants.S_OK; }
/// <summary> /// Used by the editor factory to create an editor instance. the environment first determines the /// editor factory with the highest priority for opening the file and then calls /// IVsEditorFactory.CreateEditorInstance. If the environment is unable to instantiate the document data /// in that editor, it will find the editor with the next highest priority and attempt to so that same /// thing. /// NOTE: The priority of our editor is 32 as mentioned in the attributes on the package class. /// /// Since our editor supports opening only a single view for an instance of the document data, if we /// are requested to open document data that is already instantiated in another editor, or even our /// editor, we return a value VS_E_INCOMPATIBLEDOCDATA. /// </summary> /// <param name="grfCreateDoc">Flags determining when to create the editor. Only open and silent flags /// are valid /// </param> /// <param name="pszMkDocument">path to the file to be opened</param> /// <param name="pszPhysicalView">name of the physical view</param> /// <param name="pvHier">pointer to the IVsHierarchy interface</param> /// <param name="itemid">Item identifier of this editor instance</param> /// <param name="punkDocDataExisting">This parameter is used to determine if a document buffer /// (DocData object) has already been created /// </param> /// <param name="ppunkDocView">Pointer to the IUnknown interface for the DocView object</param> /// <param name="ppunkDocData">Pointer to the IUnknown interface for the DocData object</param> /// <param name="pbstrEditorCaption">Caption mentioned by the editor for the doc window</param> /// <param name="pguidCmdUI">the Command UI Guid. Any UI element that is visible in the editor has /// to use this GUID. This is specified in the .vsct file /// </param> /// <param name="pgrfCDW">Flags for CreateDocumentWindow</param> /// <returns></returns> public int CreateEditorInstance(uint grfCreateDoc, string pszMkDocument, string pszPhysicalView, IVsHierarchy pvHier, uint itemid, IntPtr punkDocDataExisting, out IntPtr ppunkDocView, out IntPtr ppunkDocData, out string pbstrEditorCaption, out Guid pguidCmdUI, out int pgrfCDW) { // Initialize to null ppunkDocView = IntPtr.Zero; ppunkDocData = IntPtr.Zero; pguidCmdUI = GuidList.ConfigModuleEditorFactory; pgrfCDW = 0; pbstrEditorCaption = null; // Validate inputs if ((grfCreateDoc & (VSConstants.CEF_OPENFILE | VSConstants.CEF_SILENT)) == 0) { return VSConstants.E_INVALIDARG; } if (punkDocDataExisting != IntPtr.Zero) { return VSConstants.VS_E_INCOMPATIBLEDOCDATA; } // Create the Document (editor) ConfigModuleEditorPane editor = new ConfigModuleEditorPane(); ppunkDocView = Marshal.GetIUnknownForObject(editor); ppunkDocData = Marshal.GetIUnknownForObject(editor); pbstrEditorCaption = ""; return VSConstants.S_OK; }
public static IEnumerable<string> GetProjectItems(IVsHierarchy project, uint itemId) { // Don't enumerate over nodes that have side effects // This is to prevent errors that could occur since the side affect code can do things like try to // connect to a db object hasSideEffects = GetPropertyValue((int)__VSHPROPID.VSHPROPID_HasEnumerationSideEffects, itemId, project); if (hasSideEffects != null && ((bool) hasSideEffects)) { yield break; } object pVar = GetPropertyValue((int)__VSHPROPID.VSHPROPID_FirstChild, itemId, project); uint childId = GetItemId(pVar); while (childId != VSConstants.VSITEMID_NIL) { string childPath = GetCanonicalName(childId, project); yield return childPath; foreach (var childNodePath in GetProjectItems(project, childId)) yield return childNodePath; pVar = GetPropertyValue((int)__VSHPROPID.VSHPROPID_NextSibling, childId, project); childId = GetItemId(pVar); } }
public static string GetCanonicalName(uint itemId, IVsHierarchy hierarchy) { string strRet = string.Empty; int hr = hierarchy.GetCanonicalName(itemId, out strRet); if (hr == VSConstants.E_NOTIMPL) { // Special case E_NOTIMLP to avoid perf hit to throw an exception. return string.Empty; } else { try { ErrorHandler.ThrowOnFailure(hr); } catch (System.Runtime.InteropServices.COMException) { strRet = string.Empty; } // This could be in the case of S_OK, S_FALSE, etc. return strRet; } }
private static bool IsSingleProjectItemSelection(this OleMenuCommand command, out IVsHierarchy hierarchy, out uint itemid) { hierarchy = null; itemid = VSConstants.VSITEMID_NIL; int hr = VSConstants.S_OK; var monitorSelection = Package.GetGlobalService(typeof(SVsShellMonitorSelection)) as IVsMonitorSelection; var solution = Package.GetGlobalService(typeof(SVsSolution)) as IVsSolution; if (monitorSelection == null || solution == null) { return false; } IVsMultiItemSelect multiItemSelect = null; IntPtr hierarchyPtr = IntPtr.Zero; IntPtr selectionContainerPtr = IntPtr.Zero; try { hr = monitorSelection.GetCurrentSelection(out hierarchyPtr, out itemid, out multiItemSelect, out selectionContainerPtr); if (ErrorHandler.Failed(hr) || hierarchyPtr == IntPtr.Zero || itemid == VSConstants.VSITEMID_NIL) { // there is no selection return false; } // multiple items are selected if (multiItemSelect != null) return false; // there is a hierarchy root node selected, thus it is not a single item inside a project if (itemid == VSConstants.VSITEMID_ROOT) return false; hierarchy = Marshal.GetObjectForIUnknown(hierarchyPtr) as IVsHierarchy; if (hierarchy == null) return false; Guid guidProjectID = Guid.Empty; if (ErrorHandler.Failed(solution.GetGuidOfProject(hierarchy, out guidProjectID))) { return false; // hierarchy is not a project inside the Solution if it does not have a ProjectID Guid } // if we got this far then there is a single project item selected return true; } finally { if (selectionContainerPtr != IntPtr.Zero) { Marshal.Release(selectionContainerPtr); } if (hierarchyPtr != IntPtr.Zero) { Marshal.Release(hierarchyPtr); } } }
int IVsSolutionEvents.OnQueryUnloadProject(IVsHierarchy pRealHierarchy, ref int pfCancel) { var project = VsxHelper.GetProject(pRealHierarchy); if (project != null) OnQueryUnloadProject(project); return VSConstants.S_OK; }
public int CreateEditorInstance( uint grfCreateDoc, string pszMkDocument, string pszPhysicalView, IVsHierarchy pvHier, uint itemid, IntPtr punkDocDataExisting, out IntPtr ppunkDocView, out IntPtr ppunkDocData, out string pbstrEditorCaption, out Guid pguidCmdUI, out int pgrfCdw) { ppunkDocView = IntPtr.Zero; ppunkDocData = IntPtr.Zero; pguidCmdUI = GetType().GUID; pgrfCdw = 0; pbstrEditorCaption = null; if ((grfCreateDoc & (VSConstants.CEF_OPENFILE | VSConstants.CEF_SILENT)) == 0) return VSConstants.E_INVALIDARG; if (punkDocDataExisting != IntPtr.Zero) return VSConstants.VS_E_INCOMPATIBLEDOCDATA; EditorPane newEditor = new EditorPane(_vsPackage); ppunkDocView = Marshal.GetIUnknownForObject(newEditor); ppunkDocData = Marshal.GetIUnknownForObject(newEditor); pbstrEditorCaption = ""; return VSConstants.S_OK; }
public AbstractLegacyProject( VisualStudioProjectTracker projectTracker, Func<ProjectId, IVsReportExternalErrors> reportExternalErrorCreatorOpt, string projectSystemName, IVsHierarchy hierarchy, string language, IServiceProvider serviceProvider, VisualStudioWorkspaceImpl visualStudioWorkspaceOpt, HostDiagnosticUpdateSource hostDiagnosticUpdateSourceOpt, ICommandLineParserService commandLineParserServiceOpt = null) : base(projectTracker, reportExternalErrorCreatorOpt, projectSystemName, projectFilePath: GetProjectFilePath(hierarchy), hierarchy: hierarchy, projectGuid: GetProjectIDGuid(hierarchy), language: language, serviceProvider: serviceProvider, visualStudioWorkspaceOpt: visualStudioWorkspaceOpt, hostDiagnosticUpdateSourceOpt: hostDiagnosticUpdateSourceOpt, commandLineParserServiceOpt: commandLineParserServiceOpt) { if (Hierarchy != null) { ConnectHierarchyEvents(); this.IsWebSite = GetIsWebsiteProject(Hierarchy); } // Initialize command line arguments. base.SetArguments(commandLine: string.Empty); }
private static bool TryGetOutputPathFromHierarchy(IVsHierarchy hierarchy, string containingDirectoryPathOpt, out string binOutputPath) { binOutputPath = null; var storage = hierarchy as IVsBuildPropertyStorage; if (storage == null) { return false; } if (ErrorHandler.Failed(storage.GetPropertyValue("OutDir", null, (uint)_PersistStorageType.PST_PROJECT_FILE, out var outputDirectory)) || ErrorHandler.Failed(storage.GetPropertyValue("TargetFileName", null, (uint)_PersistStorageType.PST_PROJECT_FILE, out var targetFileName))) { return false; } // web app case if (!PathUtilities.IsAbsolute(outputDirectory)) { if (containingDirectoryPathOpt == null) { return false; } outputDirectory = FileUtilities.ResolveRelativePath(outputDirectory, containingDirectoryPathOpt); } binOutputPath = FileUtilities.NormalizeAbsolutePath(Path.Combine(outputDirectory, targetFileName)); return true; }
int IVsUpdateSolutionEvents2.UpdateProjectCfg_Begin( IVsHierarchy pHierProj, IVsCfg pCfgProj, IVsCfg pCfgSln, uint dwAction, ref int pfCancel) { // // if clean project or solution, dwAction == 0x100000 // if build project or solution, dwAction == 0x010000 // if rebuild project or solution, dwAction == 0x410000 // if (dwAction == 0x010000 || dwAction == 0x410000) { var validationSuccessful = VisualStudioEdmxValidator.LoadAndValidateAllFilesInProject( pHierProj, /*doEscherValidation*/ false, ShouldValidateArtifactDuringBuild); // we cause a 'build break' for command-line builds by setting PfCancel = 1 if (PackageManager.Package.IsBuildingFromCommandLine && !validationSuccessful) { pfCancel = 1; } } return VSConstants.S_OK; }
public int OnBeforeCloseProject(IVsHierarchy pHierarchy, int fRemoved) { var project = pHierarchy as IProjectManager; if (project != null) project.FixupProject(); return VSConstants.S_OK; }
public HierarchyListener(IVsHierarchy hierarchy) { if (null == hierarchy) { throw new ArgumentNullException("hierarchy"); } this.hierarchy = hierarchy; }
public static Project GetProject(this IVsHierarchy hierarchy) { return(hierarchy.GetProperty <Project>((int)__VSHPROPID.VSHPROPID_ExtObject)); }
public virtual int OnAfterOpenProject(IVsHierarchy hierarchy, int added) { return(VSConstants.E_NOTIMPL); }
public int OnActiveProjectCfgChange(IVsHierarchy pIVsHierarchy) { return(VSConstants.S_OK); }
public static string GetDisplayName(this IVsHierarchy hierarchy) { return(hierarchy.GetProperty <string>((int)__VSHPROPID.VSHPROPID_Caption)); }
public static string GetName(this IVsHierarchy hierarchy) { return(hierarchy.GetProperty <string>((int)__VSHPROPID.VSHPROPID_Name)); }
public static string GetProjectDir(this IVsHierarchy hierarchy) { return(hierarchy.GetProperty <string>((int)__VSHPROPID.VSHPROPID_ProjectDir)); }
/// <summary> /// Returns true if the hierachy object is a Common ProjectSystem object. /// see: https://github.com/dotnet/project-system /// </summary> public static bool IsCpsProject(this IVsHierarchy hierarchy) { // see: https://github.com/Microsoft/VSProjectSystem/blob/master/doc/automation/detect_whether_a_project_is_a_CPS_project.md return(hierarchy.IsCapabilityMatch("CPS")); }
int IVsPersistDocData.RenameDocData(uint grfAttribs, IVsHierarchy pHierNew, uint itemidNew, string pszMkDocumentNew) { return(VSConstants.E_NOTIMPL); }
/// <summary> /// Shows a preview of the transformation in a temporary file. /// </summary> /// <param name="hier">Current IVsHierarchy</param> /// <param name="sourceFile">Full path to the file to be trasnformed</param> /// <param name="transformFile">Full path to the transformation file</param> private void PreviewTransform(IVsHierarchy hier, string sourceFile, string transformFile) { if (string.IsNullOrWhiteSpace(sourceFile)) { throw new ArgumentNullException(nameof(sourceFile)); } if (string.IsNullOrWhiteSpace(transformFile)) { throw new ArgumentNullException(nameof(transformFile)); } if (!File.Exists(sourceFile)) { throw new FileNotFoundException(string.Format(CultureInfo.CurrentCulture, Resources.Resources.Error_SourceFileNotFound, sourceFile), sourceFile); } if (!File.Exists(transformFile)) { throw new FileNotFoundException(string.Format(CultureInfo.CurrentCulture, Resources.Resources.Error_TransformFileNotFound, transformFile), transformFile); } // Get our options using (OptionsDialogPage optionsPage = new OptionsDialogPage()) using (AdvancedOptionsDialogPage advancedOptionsPage = new AdvancedOptionsDialogPage()) { optionsPage.LoadSettingsFromStorage(); advancedOptionsPage.LoadSettingsFromStorage(); this.LogMessageWriteLineFormat("SlowCheetah PreviewTransform"); FileInfo sourceFileInfo = new FileInfo(sourceFile); // dest file string destFile = PackageUtilities.GetTempFilename(true, sourceFileInfo.Extension); this.TempFilesCreated.Add(destFile); // perform the transform and then display the result into the diffmerge tool that comes with VS. // If for some reason we can't find it, we just open it in an editor window this.errorListProvider.Tasks.Clear(); ITransformationLogger logger = new TransformationPreviewLogger(this.errorListProvider, hier); ITransformer transformer = new XmlTransformer(logger, false); if (!transformer.Transform(sourceFile, transformFile, destFile)) { throw new TransformFailedException(Resources.Resources.TransformPreview_ErrorMessage); } // Does the customer want a preview? if (optionsPage.EnablePreview == false) { ProjectUtilities.GetDTE().ItemOperations.OpenFile(destFile); } else { // If the diffmerge service is available (dev11) and no diff tool is specified, or diffmerge.exe is specifed we use the service if (this.GetService(typeof(SVsDifferenceService)) is IVsDifferenceService diffService && (!File.Exists(advancedOptionsPage.PreviewToolExecutablePath) || advancedOptionsPage.PreviewToolExecutablePath.EndsWith("diffmerge.exe", StringComparison.OrdinalIgnoreCase))) { if (!string.IsNullOrEmpty(advancedOptionsPage.PreviewToolExecutablePath) && !File.Exists(advancedOptionsPage.PreviewToolExecutablePath)) { logger.LogWarning(string.Format(Resources.Resources.Error_CantFindPreviewTool, advancedOptionsPage.PreviewToolExecutablePath)); } string sourceName = Path.GetFileName(sourceFile); string leftLabel = string.Format(CultureInfo.CurrentCulture, Resources.Resources.TransformPreview_LeftLabel, sourceName); string rightLabel = string.Format(CultureInfo.CurrentCulture, Resources.Resources.TransformPreview_RightLabel, sourceName, Path.GetFileName(transformFile)); string caption = string.Format(CultureInfo.CurrentCulture, Resources.Resources.TransformPreview_Caption, sourceName); string tooltip = string.Format(CultureInfo.CurrentCulture, Resources.Resources.TransformPreview_ToolTip, sourceName); diffService.OpenComparisonWindow2(sourceFile, destFile, caption, tooltip, leftLabel, rightLabel, null, null, (uint)__VSDIFFSERVICEOPTIONS.VSDIFFOPT_RightFileIsTemporary); }
public int OnSelectionChanged(IVsHierarchy pHierOld, uint itemidOld, IVsMultiItemSelect pMISOld, ISelectionContainer pSCOld, IVsHierarchy pHierNew, uint itemidNew, IVsMultiItemSelect pMISNew, ISelectionContainer pSCNew) { return(VSConstants.S_OK); }
public int OnQueryUnloadProject(IVsHierarchy pRealHierarchy, ref int pfCancel) { return(VSConstants.S_OK); }
int IVsPersistDocData.OnRegisterDocData(uint docCookie, IVsHierarchy pHierNew, uint itemidNew) { return(VSConstants.S_OK); }
public int OnBeforeCloseProject(IVsHierarchy pHierarchy, int fRemoved) { return(VSConstants.S_OK); }
public int OnBeforeUnloadProject(IVsHierarchy pRealHierarchy, IVsHierarchy pStubHierarchy) { return(VSConstants.S_OK); }
public int OnAfterOpenProject(IVsHierarchy pHierarchy, int fAdded) { return(VSConstants.S_OK); }
public int OnAfterLoadProject(IVsHierarchy pStubHierarchy, IVsHierarchy pRealHierarchy) { return(VSConstants.S_OK); }
public int get_StartupProject(out IVsHierarchy ppHierarchy) { throw new NotImplementedException(); }
public int OnQueryCloseProject(IVsHierarchy pHierarchy, int fRemoving, ref int pfCancel) { return(VSConstants.S_OK); }
public int GetProjectDependencies(IVsHierarchy pHier, uint celt, IVsHierarchy[] rgpHier, uint[] pcActual = null) { throw new NotImplementedException(); }
/// <summary> /// Capability inferring that the project uses project.json to manage its source items. /// https://github.com/Microsoft/VSProjectSystem/blob/master/doc/overview/project_capabilities.md. /// </summary> private static bool IsDnxProject(this IVsHierarchy project) { return(!project.IsCapabilityMatch(ProjectCapabilities.DeclaredSourceItems)); }
public bool AddSuppressions(bool selectedErrorListEntriesOnly, bool suppressInSource, IVsHierarchy projectHierarchyOpt) { if (_tableControl == null) { return(false); } Func <Project, bool> shouldFixInProject = GetShouldFixInProjectDelegate(_workspace, projectHierarchyOpt); return(ApplySuppressionFix(shouldFixInProject, selectedErrorListEntriesOnly, isAddSuppression: true, isSuppressionInSource: suppressInSource, onlyCompilerDiagnostics: false, showPreviewChangesDialog: true)); }
public int StartSimpleUpdateProjectConfiguration(IVsHierarchy pIVsHierarchyToBuild, IVsHierarchy pIVsHierarchyDependent, string pszDependentConfigurationCanonicalName, uint dwFlags, uint dwDefQueryResults, int fSuppressUI) { throw new NotImplementedException(); }
public VsCodeDomLoader(DesignerLoader loader, IVsHierarchy hier, int itemid, CodeDomProvider provider, TextBuffer buffer, IDesignerLoaderHost host) : base(loader, provider, buffer, host) { this.vsHierarchy = hier; this.itemid = itemid; }
public int FindActiveProjectCfg(IntPtr pvReserved1, IntPtr pvReserved2, IVsHierarchy pIVsHierarchy_RequestedProject, IVsProjectCfg[] ppIVsProjectCfg_Active = null) { throw new NotImplementedException(); }
int IVsSolutionEvents.OnQueryCloseProject(IVsHierarchy pHierarchy, int fRemoving, ref int pfCancel) { return(VSConstants.S_OK); }
private static Func <Project, bool> GetShouldFixInProjectDelegate(VisualStudioWorkspaceImpl workspace, IVsHierarchy projectHierarchyOpt) { if (projectHierarchyOpt == null) { return(p => true); } else { var projectIdsForHierarchy = workspace.ProjectTracker.Projects .Where(p => p.Language == LanguageNames.CSharp || p.Language == LanguageNames.VisualBasic) .Where(p => p.Hierarchy == projectHierarchyOpt) .Select(p => workspace.CurrentSolution.GetProject(p.Id).Id) .ToImmutableHashSet(); return(p => projectIdsForHierarchy.Contains(p.Id)); } }
int IVsSolutionEvents.OnBeforeCloseProject(IVsHierarchy pHierarchy, int fRemoved) { BeforeCloseProject?.Invoke(this, new ParamEventArgs(pHierarchy, fRemoved)); return(VSConstants.S_OK); }
int IVsSolutionEvents.OnQueryUnloadProject(IVsHierarchy pRealHierarchy, ref int pfCancel) { return(VSConstants.S_OK); }
int IVsSolutionEvents.OnAfterOpenProject(IVsHierarchy pHierarchy, int fAdded) { return(VSConstants.S_OK); }
int IVsSolutionEvents.OnBeforeUnloadProject(IVsHierarchy pRealHierarchy, IVsHierarchy pStubHierarchy) { BeforeUnloadProject?.Invoke(this, new ParamEventArgs(pRealHierarchy, pStubHierarchy)); return(VSConstants.S_OK); }