/// <summary> /// Adds the specified service to the service container, and optionally promotes the /// service to parent service containers. /// </summary> /// <param name="serviceType">The type of service to add.</param> /// <param name="serviceInstanceOrCallback"> /// <para>An instance of the service type to add. This object must implement or inherit /// from the type indicated by the <paramref name="serviceType"/> parameter.</para> /// <para>- or -</para> /// <para>A callback object that is used to create the service. This allows a service /// to be declared as available, but delays the creation of the object until the /// service is requested.</para> /// </param> /// <param name="promote"> /// <see langword="true"/> to promote this request to any parent service containers; /// otherwise, <see langword="false"/>. /// </param> private void AddServiceHelper(Type serviceType, object serviceInstanceOrCallback, bool promote) { Tracer.Assert(serviceType != null && serviceInstanceOrCallback != null, "Shouldn't have null parameters."); // Create the services table if necessary. if (this.services == null) { this.services = new Hashtable(); } bool isCallback = (serviceInstanceOrCallback is ServiceCreatorCallback); Type serviceInstanceType = serviceInstanceOrCallback.GetType(); if (!isCallback && !serviceInstanceType.IsCOMObject && !serviceType.IsAssignableFrom(serviceInstanceType)) { string message = this.Context.NativeResources.GetString(ResId.IDS_E_INVALIDSERVICEINSTANCE, serviceType.FullName); Tracer.Fail(message); throw new ArgumentException(message); } // Disallow the addition of duplicate services. if (this.services.ContainsKey(serviceType)) { string message = this.Context.NativeResources.GetString(ResId.IDS_E_DUPLICATESERVICE, serviceType.FullName); Tracer.Fail(message); throw new InvalidOperationException(message); } if (promote) { // If we're promoting, we need to store this guy in a promoted service // object because we need to manage additional state. We attempt // to proffer at this time if we have a service provider. If we don't, // we will proffer when we get one. ProfferedService service = new ProfferedService(); service.Instance = serviceInstanceOrCallback; if (isCallback) { this.services[serviceType] = service; } if (this.Context.ServiceProvider != null) { IProfferService ps = (IProfferService)GetService(typeof(IProfferService)); if (ps != null) { uint cookie; Guid serviceGuid = serviceType.GUID; int hr = ps.ProfferService(ref serviceGuid, this, out cookie); service.Cookie = cookie; if (NativeMethods.Failed(hr)) { string message = this.Context.NativeResources.GetString(ResId.IDS_E_FAILEDTOPROFFERSERVICE, serviceType.FullName); Tracer.Fail(message); throw new COMException(message, hr); } } } } if (!isCallback || (isCallback && !promote)) { this.services[serviceType] = serviceInstanceOrCallback; } }
/// <summary> /// Event handler for the bound object's <see cref="PropertyPageSettings.PropertyChanged">PropertyChanged</see> event. /// </summary> /// <param name="sender">The bound object.</param> /// <param name="e">The <see cref="PropertyChangedEventArgs"/> object that contains the event data.</param> private void HandlePropertyChanged(object sender, PropertyChangedEventArgs e) { Tracer.Assert(sender as PropertyPageSettings == this.BoundObject, "The sender should be the cached bound object."); this.NotifyPageSiteOnDirtyStateChange(); this.Refresh(); }
int IVsProjectFactory.CreateProject(string pszFilename, string pszLocation, string pszName, uint grfCreateFlags, ref Guid iidProject, out IntPtr ppvProject, out int pfCanceled) { IntPtr pUnk = IntPtr.Zero; pfCanceled = 0; ppvProject = IntPtr.Zero; bool loadedSuccessfully = false; try { Tracer.VerifyStringArgument(pszFilename, "pszFilename"); __VSCREATEPROJFLAGS createFlags = (__VSCREATEPROJFLAGS)grfCreateFlags; // Get the right version of the project serializer. ProjectSerializer serializer = this.CreateSerializer(pszFilename); // Do we need to suppress any load failures from being reported to the end user. serializer.SilentFailures = ((createFlags & __VSCREATEPROJFLAGS.CPF_SILENT) == __VSCREATEPROJFLAGS.CPF_SILENT); // Now we need to load the project, either from a template file or from an existing file. bool openExisting = ((createFlags & __VSCREATEPROJFLAGS.CPF_OPENFILE) == __VSCREATEPROJFLAGS.CPF_OPENFILE); bool openFromTemplate = ((createFlags & __VSCREATEPROJFLAGS.CPF_CLONEFILE) == __VSCREATEPROJFLAGS.CPF_CLONEFILE); Tracer.Assert((openExisting && !openFromTemplate) || (!openExisting && openFromTemplate), "The grfCreateFlags are incorrect. You can't have both opening existing and opening from template. Flags={0}", createFlags); if (openExisting) { Tracer.WriteLineInformation(classType, "IVsProjectFactory.CreateProject", "Attempting to load project: File name={0} Location={1} Name={2} GUID={3}.", pszFilename, pszLocation, pszName, iidProject.ToString("B").ToUpper(CultureInfo.InvariantCulture)); loadedSuccessfully = serializer.Load(pszFilename); if (loadedSuccessfully) { Tracer.WriteLineInformation(classType, "IVsProjectFactory.CreateProject", "Successfully loaded project '{0}'.", pszFilename); } else { Tracer.WriteLineInformation(classType, "IVsProjectFactory.CreateProject", "There were errors in loading project '{0}'.", pszFilename); } } else { Tracer.WriteLineInformation(classType, "IVsProjectFactory.CreateProject", "Attempting to create a new project from a template: File name={0} Location={1} Name={2} GUID={3}.", pszFilename, pszLocation, pszName, iidProject.ToString("B").ToUpper(CultureInfo.InvariantCulture)); Tracer.VerifyStringArgument(pszLocation, "pszLocation"); Tracer.VerifyStringArgument(pszName, "pszName"); string destinationFile = Path.Combine(pszLocation, pszName); loadedSuccessfully = serializer.LoadFromTemplate(pszFilename, destinationFile); if (loadedSuccessfully) { Tracer.WriteLineInformation(classType, "IVsProjectFactory.CreateProject", "Successfully loaded project '{0}'.", pszFilename); } else { Tracer.WriteLineInformation(classType, "IVsProjectFactory.CreateProject", "There were errors in loading project '{0}'.", pszFilename); } } if (loadedSuccessfully) { // Once we've loaded the project, we need to return the COM object that the environment is requesting. pUnk = Marshal.GetIUnknownForObject(serializer.Project); int hr = Marshal.QueryInterface(pUnk, ref iidProject, out ppvProject); Tracer.Assert(NativeMethods.Succeeded(hr), "Cannot get the requested project interface ({0}): returned {1}", iidProject.ToString("B").ToUpper(CultureInfo.InvariantCulture), hr); NativeMethods.ThrowOnFailure(hr); } } catch (Exception e) { Package.Instance.Context.NotifyInternalError(e.ToString()); } finally { if (pUnk != IntPtr.Zero) { Marshal.Release(pUnk); } } return(loadedSuccessfully ? NativeMethods.S_OK : NativeMethods.E_FAIL); }
/// <summary> /// Opens the standard editor for this file type in Visual Studio. /// </summary> /// <param name="logicalView">The type of view in which to open the document.</param> /// <param name="existingDocumentData"> /// Passed through to the IVsUIShellOpenDocument.OpenStandardEditor or OpenSpecificEditor, which /// will then determine if the document is already opened and reused the open window. /// </param> /// <param name="physicalView"> /// Name of the physical view if we're opening with a specific editor. Not used if opening with a standard editor. /// </param> /// <param name="specificEditor">The GUID of the specific registered editor to use to open this node.</param> /// <returns>The <see cref="IVsWindowFrame"/> object that contains the opened document.</returns> private IVsWindowFrame Open(VsLogicalView logicalView, IntPtr existingDocumentData, Guid specificEditor, string physicalView) { Tracer.VerifyNonNullArgument(logicalView, "logicalView"); // Check to see if the file exists before we try to open it. if (!File.Exists(this.AbsolutePath)) { Context.ShowErrorMessageBox(SconceStrings.FileDoesNotExist(this.AbsolutePath)); return(null); } IVsWindowFrame windowFrame; Guid logicalViewGuid = logicalView.Value; Guid editorTypeGuid = specificEditor; bool useSpecificEditor = (specificEditor != Guid.Empty); int hr; // Get a IVsUIShellOpenDocument object so that we can use it to open the document. IVsUIShellOpenDocument vsUIShellOpenDocument = (IVsUIShellOpenDocument)this.ServiceProvider.GetServiceOrThrow(typeof(SVsUIShellOpenDocument), typeof(IVsUIShellOpenDocument), classType, "Open"); // Open the document. if (useSpecificEditor) { hr = vsUIShellOpenDocument.OpenSpecificEditor( 0, this.CanonicalName, ref editorTypeGuid, physicalView, ref logicalViewGuid, this.Caption, (IVsUIHierarchy)this.Hierarchy, this.HierarchyId, existingDocumentData, (Microsoft.VisualStudio.OLE.Interop.IServiceProvider)Package.Instance, out windowFrame); } else { hr = vsUIShellOpenDocument.OpenStandardEditor( unchecked ((uint)__VSOSEFLAGS.OSE_ChooseBestStdEditor), this.CanonicalName, ref logicalViewGuid, this.Caption, (IVsUIHierarchy)this.Hierarchy, this.HierarchyId, existingDocumentData, (Microsoft.VisualStudio.OLE.Interop.IServiceProvider)Package.Instance, out windowFrame); } string editorTypeName = useSpecificEditor ? "specific" : "standard"; if (NativeMethods.Succeeded(hr)) { Tracer.WriteLineInformation(classType, "Open", "Succeeded in opening '{0}' with a {1} editor.", this.AbsolutePath, editorTypeName); if (windowFrame != null) { // Get the document cookie and cache it. object pvar; hr = windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocCookie, out pvar); NativeMethods.ThrowOnFailure(hr); // pvar is an int, but we need a uint. We get an error if we try to immediately cast to uint // without first casting to an int. uint cookie = unchecked ((uint)(int)pvar); this.SetDocumentCookie(cookie); Tracer.WriteLineInformation(classType, "Open", "Document '{0}' has a cookie value of {1}", this.AbsolutePath, cookie); // Show the window frame of the open document. The documentation says we don't need to do this, but the reality is different. hr = windowFrame.Show(); Tracer.Assert(NativeMethods.Succeeded(hr), "Error in IVsWindowFrame.Show(): 0x{0:x}", hr); // Trace the running documents. VsHelperMethods.TraceRunningDocuments(); } else { Tracer.Fail("Open succeeded but we were returned a null IVsWindowFrame so we can't show the document."); } } else if (hr == NativeMethods.OLE_E_PROMPTSAVECANCELLED) { Tracer.WriteLineInformation(classType, "Open", "The user canceled out of the open dialog box."); } else { Tracer.Fail("Failed to open '{0}' with a {1} editor. Hr=0x{2:x}", this.AbsolutePath, editorTypeName, hr); NativeMethods.ThrowOnFailure(hr); } return(windowFrame); }