protected override void InitializeLanguageService(IVsTextLines textLines) { var userData = textLines as IVsUserData; if (userData == null) return; var langSid = typeof(PowerShellLanguageInfo).GUID; if (langSid == Guid.Empty) return; var vsCoreSid = new Guid("{8239bec4-ee87-11d0-8c98-00c04fc2ab22}"); Guid currentSid; ErrorHandler.ThrowOnFailure(textLines.GetLanguageServiceID(out currentSid)); // If the language service is set to the default SID, then // set it to our language if (currentSid == vsCoreSid) { ErrorHandler.ThrowOnFailure(textLines.SetLanguageServiceID(ref langSid)); } else if (currentSid != langSid) { // Some other language service has it, so return VS_E_INCOMPATIBLEDOCDATA throw new COMException("Incompatible doc data", VSConstants.VS_E_INCOMPATIBLEDOCDATA); } var bufferDetectLang = VSConstants.VsTextBufferUserDataGuid.VsBufferDetectLangSID_guid; ErrorHandler.ThrowOnFailure(userData.SetData(ref bufferDetectLang, false)); }
public int OnLoadCompleted(int fReload) { // Set language service ID as early as possible, since it may change content type of the buffer, // e.g. in a weird scenario when someone does "Open With X Editor" on an Y file. Calling this // will change content type to the one language service specifies instead of the default one for // the file extension, and will ensure that correct editor factory is used. _textLines.SetLanguageServiceID(ref _languageServiceGuid); var adapterService = _services.GetService <IVsEditorAdaptersFactoryService>(); var diskBuffer = adapterService.GetDocumentBuffer(_textLines); Debug.Assert(diskBuffer != null); try { var editorInstance = diskBuffer.GetService <IEditorViewModel>(); if (editorInstance == null) { var locator = _services.GetService <IContentTypeServiceLocator>(); var instancefactory = locator.GetService <IEditorViewModelFactory>(diskBuffer.ContentType.TypeName); Debug.Assert(instancefactory != null, "No editor factory found for the provided text buffer"); editorInstance = instancefactory.CreateEditorViewModel(diskBuffer); } Debug.Assert(editorInstance != null); adapterService.SetDataBuffer(_textLines, editorInstance.ViewBuffer.As <ITextBuffer>()); } finally { cp.Unadvise(cookie); cookie = 0; _textLines = null; _trackers.Remove(this); } return(VSConstants.S_OK); }
protected void InitializeLanguageService(IVsTextLines textLines, Guid langSid) { var userData = textLines as IVsUserData; if (userData != null) { if (langSid != Guid.Empty) { var vsCoreSid = new Guid("{8239bec4-ee87-11d0-8c98-00c04fc2ab22}"); ErrorHandler.ThrowOnFailure(textLines.GetLanguageServiceID(out var currentSid)); // If the language service is set to the default SID, then // set it to our language if (currentSid == vsCoreSid) { ErrorHandler.ThrowOnFailure(textLines.SetLanguageServiceID(ref langSid)); } else if (currentSid != langSid) { // Some other language service has it, so return VS_E_INCOMPATIBLEDOCDATA throw new COMException("Incompatible doc data", VSConstants.VS_E_INCOMPATIBLEDOCDATA); } var bufferDetectLang = VSConstants.VsTextBufferUserDataGuid.VsBufferDetectLangSID_guid; ErrorHandler.ThrowOnFailure(userData.SetData(ref bufferDetectLang, false)); } } }
public int OnLoadCompleted(int fReload) { _cp.Unadvise(_cookie); Guid langSvcGuid = typeof(NodejsLanguageInfo).GUID; _textLines.SetLanguageServiceID(ref langSvcGuid); return VSConstants.S_OK; }
public int OnLoadCompleted(int fReload) { ThreadHelper.ThrowIfNotOnUIThread(); _connectionPoint.Unadvise(_cookie); _textLines.SetLanguageServiceID(ref _languageServiceId); return(VSConstants.S_OK); }
public int OnLoadCompleted(int fReload) { _connectionPoint.Unadvise(_cookie); var languageServiceId = typeof(GaugeLanguageInfo).GUID; _textLines.SetLanguageServiceID(ref languageServiceId); return(VSConstants.S_OK); }
public int OnLoadCompleted(int fReload) { _cp.Unadvise(_cookie); Guid langSvcGuid = _editorFactory.GetLanguageInfoType().GUID; _textLines.SetLanguageServiceID(ref langSvcGuid); return(VSConstants.S_OK); }
/// <summary> /// Here we simply host the visual studio core text editor. /// </summary> public virtual void CreateEditorInstance(uint createDocFlags, string moniker, string physicalView, IVsHierarchy pHier, uint itemid, IntPtr existingDocData, out IntPtr docView, out IntPtr docData, out string editorCaption, out Guid cmdUI, out int cancelled) { string ext = Path.GetExtension(moniker).ToLower(); if (ext.StartsWith(".")) { ext = ext.Substring(1); } bool takeover = CheckAllFileTypes() && !this.IsRegisteredExtension(ext); if (takeover && !IsOurKindOfFile(moniker)) { throw new System.Runtime.InteropServices.COMException("", (int)VsConstants.VS_E_UNSUPPORTEDFORMAT); } IVsTextLines buffer = null; if (existingDocData != IntPtr.Zero) { buffer = (IVsTextLines)Marshal.GetTypedObjectForIUnknown(existingDocData, typeof(IVsTextLines)); } else { buffer = (IVsTextLines)VsShell.CreateInstance(this.site, ref VsConstants.CLSID_VsTextBuffer, ref VsConstants.IID_IVsTextLines, typeof(IVsTextLines)); } IObjectWithSite objWithSite = (IObjectWithSite)buffer; objWithSite.SetSite(this.site.Unwrap()); object window = CreateEditorView(moniker, buffer, physicalView, out editorCaption, out cmdUI); if (takeover) { Guid langSid = GetLanguageSID(); if (langSid != Guid.Empty) { buffer.SetLanguageServiceID(ref langSid); IVsUserData vud = (IVsUserData)buffer; vud.SetData(ref VsConstants.GUID_VsBufferDetectLangSID, false); } // todo: for some reason my commands are disabled when we go through this // code path... } docView = Marshal.GetIUnknownForObject(window); docData = Marshal.GetIUnknownForObject(buffer); // VS core editor is the primary command handler cancelled = 0; }
/// <summary> /// Creates a new ConsoleWindow object. /// This constructor uses the service provider passed as an argument to create and initialize /// the text buffer. /// </summary> public ConsoleWindow(IServiceProvider provider) : base(null) { if (null == provider) { throw new ArgumentNullException("provider"); } globalProvider = provider; // Create the text buffer. textLines = (IVsTextLines)CreateObject(typeof(VsTextBufferClass), typeof(IVsTextLines)); // Get a reference to the global service provider. IOleServiceProvider nativeProvider = (IOleServiceProvider)globalProvider.GetService(typeof(IOleServiceProvider)); // The text buffer must be sited with the global service provider. ((IObjectWithSite)textLines).SetSite(nativeProvider); // Set the buffer as read-only. The user should be able to change the content of the // buffer only if the engine is started. uint flags; Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure( textLines.GetStateFlags(out flags)); flags |= (uint)Microsoft.VisualStudio.TextManager.Interop.BUFFERSTATEFLAGS.BSF_USER_READONLY; Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure( textLines.SetStateFlags(flags)); // Set the GUID of the language service that will handle this text buffer Guid languageGuid = typeof(FoxProLanguage).GUID; Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure( textLines.SetLanguageServiceID(ref languageGuid)); // Initialize the history history = new HistoryBuffer(); // Create the stream on top of the text buffer. textStream = new TextBufferStream(textLines); // Initialize the engine. InitializeEngine(); // Set the title of the window. this.Caption = Resources.ToolWindowTitle; // Set the icon of the toolwindow. this.BitmapResourceID = 301; this.BitmapIndex = 0; }
public int OnLoadCompleted(int fReload) { var adapterService = VsAppShell.Current.ExportProvider.GetExport <IVsEditorAdaptersFactoryService>().Value; // Set language service ID as early as possible, since it may change content type of the buffer, // e.g. in a weird scenario when someone does "Open With X Editor" on an Y file. Calling this // will change content type to the one language service specifies instead of the default one for // the file extension, and will ensure that correct editor factory is used. _textLines.SetLanguageServiceID(ref _languageServiceGuid); ITextBuffer diskBuffer = adapterService.GetDocumentBuffer(_textLines); Debug.Assert(diskBuffer != null); try { var editorInstance = ServiceManager.GetService <IEditorInstance>(diskBuffer); if (editorInstance == null) { var importComposer = new ContentTypeImportComposer <IEditorFactory>(VsAppShell.Current.CompositionService); var instancefactory = importComposer.GetImport(diskBuffer.ContentType.TypeName); Debug.Assert(instancefactory != null); var documentFactoryImportComposer = new ContentTypeImportComposer <IVsEditorDocumentFactory>(VsAppShell.Current.CompositionService); var documentFactory = documentFactoryImportComposer.GetImport(diskBuffer.ContentType.TypeName); Debug.Assert(documentFactory != null); editorInstance = instancefactory.CreateEditorInstance(diskBuffer, documentFactory); } Debug.Assert(editorInstance != null); adapterService.SetDataBuffer(_textLines, editorInstance.ViewBuffer); } finally { cp.Unadvise(cookie); cookie = 0; _textLines = null; _hierarchy = null; _trackers.Remove(this); _trackers = null; } return(VSConstants.S_OK); }
private IVsTextLines GetTextBuffer(IntPtr docDataExisting, Guid languageServiceId) { IVsTextLines textLines = null; if (docDataExisting == IntPtr.Zero) { // Create a new IVsTextLines buffer. Type textLinesType = typeof(IVsTextLines); Guid clsid = typeof(VsTextBufferClass).GUID; textLines = CreateInstance <IVsTextLines>(ref clsid); // set the buffer's site ((IObjectWithSite)textLines).SetSite(VsServiceProvider); textLines.SetLanguageServiceID(ref languageServiceId); } else { // Use the existing text buffer object dataObject = Marshal.GetObjectForIUnknown(docDataExisting); textLines = dataObject as IVsTextLines; if (textLines == null) { // Try get the text buffer from textbuffer provider IVsTextBufferProvider textBufferProvider = dataObject as IVsTextBufferProvider; if (textBufferProvider != null) { textBufferProvider.GetTextBuffer(out textLines); } } } if (textLines == null) { // Unknown docData type then, so we have to force VS to close the other editor. ErrorHandler.ThrowOnFailure((int)VSConstants.VS_E_INCOMPATIBLEDOCDATA); } return(textLines); }
private void InitContainedLanguage() { IVsTextLines vsTextLines = EnsureBufferCoordinator(); IVsContainedLanguage vsContainedLanguage; languageFactory.GetLanguage(hierarchy, MarkdownCodeProject.FileItemId, _textBufferCoordinator, out vsContainedLanguage); if (vsContainedLanguage == null) { Logger.Log("Markdown: Couldn't get IVsContainedLanguage for " + ProjectionBuffer.IProjectionBuffer.ContentType); return; } Guid langService; vsContainedLanguage.GetLanguageServiceID(out langService); vsTextLines.SetLanguageServiceID(ref langService); containedLanguage = vsContainedLanguage; IVsContainedLanguageHost legacyContainedLanguageHost = GetLegacyContainedLanguageHost(); vsContainedLanguage.SetHost(legacyContainedLanguageHost); _legacyCommandTarget = new LegacyContainedLanguageCommandTarget(); IVsTextViewFilter textViewFilter; _legacyCommandTarget.Create(owner.Document, vsContainedLanguage, _textBufferCoordinator, ProjectionBuffer, out textViewFilter); IWebContainedLanguageHost webContainedLanguageHost = legacyContainedLanguageHost as IWebContainedLanguageHost; webContainedLanguageHost.SetContainedCommandTarget(_legacyCommandTarget.TextView, _legacyCommandTarget.ContainedLanguageTarget); containedLanguage2 = (webContainedLanguageHost as IContainedLanguageHostVs); containedLanguage2.TextViewFilter = textViewFilter; ProjectionBuffer.ResetMappings(); WebEditor.TraceEvent(1005); }
public int OnLoadCompleted(int fReload) { _cp.Unadvise(_cookie); var adapterService = _compModel.GetService <IVsEditorAdaptersFactoryService>(); ITextBuffer diskBuffer = adapterService.GetDocumentBuffer(_textLines); var contentRegistry = _compModel.GetService <IContentTypeRegistryService>(); var factService = _compModel.GetService <IProjectionBufferFactoryService>(); IContentType contentType = SniffContentType(diskBuffer) ?? contentRegistry.GetContentType("HTML"); var projBuffer = new TemplateProjectionBuffer(contentRegistry, factService, diskBuffer, _compModel.GetService <IBufferGraphFactoryService>(), contentType); diskBuffer.ChangedHighPriority += projBuffer.DiskBufferChanged; diskBuffer.Properties.AddProperty(typeof(TemplateProjectionBuffer), projBuffer); Guid langSvcGuid = typeof(DjangoLanguageInfo).GUID; _textLines.SetLanguageServiceID(ref langSvcGuid); adapterService.SetDataBuffer(_textLines, projBuffer.ProjectionBuffer); IVsTextView view; ErrorHandler.ThrowOnFailure(_window.GetPrimaryView(out view)); if (contentType != null && contentType.IsOfType("HTML")) { var editAdapter = _compModel.GetService <IVsEditorAdaptersFactoryService>(); var newView = editAdapter.GetWpfTextView(view); var intellisenseController = HtmlIntellisenseControllerProvider.GetOrCreateController(_compModel, newView); intellisenseController.AttachKeyboardFilter(); } 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) { // Initialize to null ppunkDocView = IntPtr.Zero; ppunkDocData = IntPtr.Zero; pbstrEditorCaption = null; pguidCmdUI = GuidList.guidPartEditorFactory; pgrfCDW = (int)_VSRDTFLAGS.RDT_DontSaveAs; try { // Validate inputs if ((grfCreateDoc & (VSConstants.CEF_OPENFILE | VSConstants.CEF_SILENT)) == 0) { Debug.Assert(false, "Only Open or Silent is valid"); return(VSConstants.E_INVALIDARG); } PackageEditorPane existingPackageEditor = null; if (punkDocDataExisting != IntPtr.Zero) { existingPackageEditor = Marshal.GetObjectForIUnknown(punkDocDataExisting) as PackageEditorPane; if (existingPackageEditor == null) { // The user is trying to open our editor on an existing DocData which is not our editor. // This editor does not support other editors simultaneously editing the same file. return(VSConstants.VS_E_INCOMPATIBLEDOCDATA); } } if (pszPhysicalView == null) { if (punkDocDataExisting != IntPtr.Zero) { // An XML fragment editor was already editing our DocData, and we are trying to open the main editor on it now. // Just return the existing DocData object. ppunkDocView = Marshal.GetIUnknownForObject(existingPackageEditor); ppunkDocData = Marshal.GetIUnknownForObject(existingPackageEditor); pbstrEditorCaption = string.Empty; return(VSConstants.S_OK); } // Open the main editor (the normal scenario). PackageEditorPane editor = new PackageEditorPane(myPackage); ppunkDocView = Marshal.GetIUnknownForObject(editor); ppunkDocData = Marshal.GetIUnknownForObject(editor); pbstrEditorCaption = string.Empty; return(VSConstants.S_OK); } // If physical view is non-null, create an editor window on an xml fragment. // Verify that the base document is created IVsRunningDocumentTable runningDocTable = (IVsRunningDocumentTable)this.GetService(typeof(SVsRunningDocumentTable)); int hr = runningDocTable.FindAndLockDocument( (uint)_VSRDTFLAGS.RDT_NoLock, pszMkDocument, out IVsHierarchy hierarchy, out uint itemIdFindAndLock, out IntPtr docDataFindAndLock, out uint docCookieFindAndLock ); string xml = string.Empty; if (VSConstants.S_OK != hr) // can't find document in RDT. { // We are being asked to open a sub document before the main document is open. // Let's create the main and put it in the RDT with a temporary EditLock that // we will release after the sub document window is created. using (PackageEditorPane editor = new PackageEditorPane(myPackage)) { IVsPersistDocData mainDocData = editor; mainDocData.LoadDocData(pszMkDocument); // TODO editor.TemporaryLockDocument(runningDocTable, pvHier, itemid, pszMkDocument); xml = editor.GetXml(pszPhysicalView); } } else { // get xml from open editor. if (docDataFindAndLock != IntPtr.Zero) { Marshal.Release(docDataFindAndLock); } if (existingPackageEditor != null) { xml = existingPackageEditor.GetXml(pszPhysicalView); } } // Use ILocalRegistry to create text buffer and code window ILocalRegistry localRegistry = (ILocalRegistry)this.GetService(typeof(ILocalRegistry)); Debug.Assert(null != localRegistry); // Create the document (text buffer) IntPtr vsTextLines = IntPtr.Zero; Guid guidTextLines = typeof(IVsTextLines).GUID; ErrorHandler.ThrowOnFailure( localRegistry.CreateInstance(typeof(VsTextBufferClass).GUID, null, ref guidTextLines, (uint)CLSCTX.CLSCTX_INPROC_SERVER, out vsTextLines) ); IVsTextLines textLines = (IVsTextLines)Marshal.GetObjectForIUnknown(vsTextLines); // Create the codewindow (editor) IntPtr vsCodeWindow = IntPtr.Zero; Guid guidCodeWindow = typeof(IVsCodeWindow).GUID; ErrorHandler.ThrowOnFailure( localRegistry.CreateInstance(typeof(VsCodeWindowClass).GUID, null, ref guidCodeWindow, (uint)CLSCTX.CLSCTX_INPROC_SERVER, out vsCodeWindow) ); IVsCodeWindow codeWindow = Marshal.GetObjectForIUnknown(vsCodeWindow) as IVsCodeWindow; // Site it, so it can find/query for various services IObjectWithSite textLinesWithSite = (IObjectWithSite)textLines; // Site the TextBuffer with an IOleServiceProvider IOleServiceProvider pOleSeviceProvider; pOleSeviceProvider = (IOleServiceProvider)this.vsServiceProvider.GetService(typeof(IOleServiceProvider)); textLinesWithSite.SetSite(pOleSeviceProvider); ErrorHandler.ThrowOnFailure( textLines.InitializeContent(xml, xml.Length) ); // Attach buffer to code window ErrorHandler.ThrowOnFailure( codeWindow.SetBuffer(textLines) ); // Set the language service to the XML language service to get syntax highlighting Guid xmlLanguageServiceGuid = new Guid("{f6819a78-a205-47b5-be1c-675b3c7f0b8e}"); textLines.SetLanguageServiceID(ref xmlLanguageServiceGuid); // If the project system has specified the language service clear the auto detect flag to ensure that we use the preferred service IVsUserData userData = (IVsUserData)textLines; Guid vsBufferDetectLangSIDGuid = new Guid("{17F375AC-C814-11d1-88AD-0000F87579D2}"); object flagObject = false; userData.SetData(ref vsBufferDetectLangSIDGuid, flagObject); ppunkDocView = vsCodeWindow; // refcnt from CreateEditorInstance ppunkDocData = vsTextLines; // refcnt from CreateEditorInstance pbstrEditorCaption = " (" + pszPhysicalView + ")"; pgrfCDW |= (int)__VSCREATEDOCWIN.CDW_fAltDocData; return(VSConstants.S_OK); } catch (Exception error) { System.Windows.Forms.MessageBox.Show(error.Message); } return(VSConstants.E_INVALIDARG); }
/// <include file='doc\EditorFactory.uex' path='docs/doc[@for="EditorFactory.CreateEditorInstance"]/*' /> /// <summary> /// This method checks to see if the specified file is one that your editor supports /// and if so, creates the core text editor and associated your language service /// with it. To figure out if the file is one that your editor supports it performs /// the following check: /// <list> /// <item> /// Call IsRegisteredExtension to see if the file extension is explicitly /// registered to your editor. /// </item> /// <item> /// Call GetUserDefinedEditor to see if the user has explicitly mapped the /// extension to your editor. /// </item> /// <item> /// If your editor registered the "*" extension, then it also calls /// IsFileExtensionWeShouldEditAnyway and IsOurFileFormat to let you sniff /// the file and see if you think it contains stuff that your editor recognizes /// </item> /// </list> /// If all this is true then it goes ahead with the next step which is to /// get an IVsTextLines buffer and set it up as follows: /// <list> /// <item> /// If existingDocData is non-null then it checks to see if it can get an /// IVsTextLines buffer from this docData, and if not, returns VS_E_INCOMPATIBLEDOCDATA. /// Otherwise it creates a new VsTextBufferClass. /// </item> /// Calls IVsUserData.SetData on the IVsTextLines buffer with any code page prompt /// flags you have provided via the CodePagePrompt property. /// </list> /// <list> /// Calls SetLanguageServiceID to pass in your language service Guid and /// sets the GuidVSBufferDetectLangSid IVsUserData to false to stop the core /// text editor from looking up a different language service. /// </list> /// Lastly it calls CreateEditorView to create the docView. /// </summary> public virtual int CreateEditorInstance(uint createDocFlags, string moniker, string physicalView, IVsHierarchy pHier, uint itemid, IntPtr existingDocData, out IntPtr docView, out IntPtr docData, out string editorCaption, out Guid cmdUI, out int cancelled) { docView = IntPtr.Zero; docData = IntPtr.Zero; editorCaption = null; cmdUI = Guid.Empty; cancelled = 0; int hr = VSErr.S_OK; if (this.promptFlags == __PROMPTONLOADFLAGS.codepagePrompt && existingDocData != IntPtr.Zero) { //since we are trying to open with encoding just return hr = (int)VSConstants.VS_E_INCOMPATIBLEDOCDATA; goto cleanup; } bool takeover = false; if (!string.IsNullOrEmpty(moniker)) { string ext = Path.GetExtension(moniker); docData = IntPtr.Zero; docView = IntPtr.Zero; editorCaption = null; bool openSpecific = (createDocFlags & (uint)__VSCREATEEDITORFLAGS2.CEF_OPENSPECIFIC) != 0; bool isOurs = IsRegisteredExtension(ext); bool isUserDefined = (GetUserDefinedEditor(ext) == this.GetType().GUID); // If this file extension belongs to a different language service, then we should not open it, // unless the user specifically requested our editor in the Open With... dialog. if (!isOurs && !isUserDefined && !this.IsFileExtensionWeShouldEditAnyway(ext) && !openSpecific) { return(VSConstants.VS_E_UNSUPPORTEDFORMAT); } takeover = (CheckAllFileTypes() && !isOurs); if (takeover && !isOurs && !isUserDefined && !openSpecific) { if (!IsOurFileFormat(moniker)) { return(VSConstants.VS_E_UNSUPPORTEDFORMAT); } } } IVsTextLines buffer = null; if (existingDocData != IntPtr.Zero) { object dataObject = Marshal.GetObjectForIUnknown(existingDocData); buffer = dataObject as IVsTextLines; if (buffer == null) { IVsTextBufferProvider bp = dataObject as IVsTextBufferProvider; if (bp != null) { Marshal.ThrowExceptionForHR(bp.GetTextBuffer(out buffer)); } } if (buffer == null) { // unknown docData type then, so we have to force VS to close the other editor. hr = VSConstants.VS_E_INCOMPATIBLEDOCDATA; goto cleanup; } } else { // Create a new IVsTextLines buffer. Type textLinesType = typeof(IVsTextLines); Guid riid = textLinesType.GUID; Guid clsid = typeof(VsTextBufferClass).GUID; buffer = (IVsTextLines)package.CreateInstance(ref clsid, ref riid, textLinesType); if (!string.IsNullOrEmpty(moniker)) { IVsUserData iud = buffer as IVsUserData; if (iud != null) { Guid GUID_VsBufferMoniker = typeof(IVsUserData).GUID; // Must be set in time for language service GetColorizer call in case the colorizer // is file name dependent. Marshal.ThrowExceptionForHR(iud.SetData(ref GUID_VsBufferMoniker, moniker)); } } IObjectWithSite ows = buffer as IObjectWithSite; if (ows != null) { ows.SetSite(this.site.GetService(typeof(IOleServiceProvider))); } } if (this.promptFlags == __PROMPTONLOADFLAGS.codepagePrompt && buffer is IVsUserData) { IVsUserData iud = (IVsUserData)buffer; Guid GUID_VsBufferEncodingPromptOnLoad = new Guid(0x99ec03f0, 0xc843, 0x4c09, 0xbe, 0x74, 0xcd, 0xca, 0x51, 0x58, 0xd3, 0x6c); Marshal.ThrowExceptionForHR(iud.SetData(ref GUID_VsBufferEncodingPromptOnLoad, (uint)this.CodePagePrompt)); } Guid langSid = GetLanguageServiceGuid(); if (langSid != Guid.Empty) { Guid vsCoreSid = new Guid("{8239bec4-ee87-11d0-8c98-00c04fc2ab22}"); Guid currentSid; Marshal.ThrowExceptionForHR(buffer.GetLanguageServiceID(out currentSid)); // If the language service is set to the default SID, then // set it to our language if (currentSid == vsCoreSid) { Marshal.ThrowExceptionForHR(buffer.SetLanguageServiceID(ref langSid)); } else if (currentSid != langSid) { // Some other language service has it, so return VS_E_INCOMPATIBLEDOCDATA hr = VSConstants.VS_E_INCOMPATIBLEDOCDATA; goto cleanup; } takeover = true; } if (takeover) { IVsUserData vud = (IVsUserData)buffer; Guid bufferDetectLang = GuidVSBufferDetectLangSid; Marshal.ThrowExceptionForHR(vud.SetData(ref bufferDetectLang, false)); } if (existingDocData != IntPtr.Zero) { docData = existingDocData; Marshal.AddRef(docData); } else { docData = Marshal.GetIUnknownForObject(buffer); } docView = CreateEditorView(moniker, buffer, physicalView, out editorCaption, out cmdUI); if (docView == IntPtr.Zero) { // We couldn't create the view, so return this special error code so // VS can try another editor factory. hr = VSConstants.VS_E_UNSUPPORTEDFORMAT; } cleanup: if (docView == IntPtr.Zero) { if (existingDocData != docData && docData != IntPtr.Zero) { Marshal.Release(docData); docData = IntPtr.Zero; } } return(hr); }
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 = Guids.PerspexDesignerGeneralPageGuid; pgrfCDW = 0; pbstrEditorCaption = null; // Validate inputs if ((grfCreateDoc & (VSConstants.CEF_OPENFILE | VSConstants.CEF_SILENT)) == 0) { return(VSConstants.E_INVALIDARG); } IVsTextLines documentBuffer = null; if (punkDocDataExisting == IntPtr.Zero) { // create an invisible editor var invisibleEditorManager = (IVsInvisibleEditorManager)_serviceProvider.GetService(typeof(IVsInvisibleEditorManager)); IVsInvisibleEditor invisibleEditor; ErrorHandler.ThrowOnFailure(invisibleEditorManager.RegisterInvisibleEditor(pszMkDocument, null, (uint)_EDITORREGFLAGS.RIEF_ENABLECACHING, null, out invisibleEditor)); var docDataPointer = IntPtr.Zero; var guidIVSTextLines = typeof(IVsTextLines).GUID; ErrorHandler.ThrowOnFailure(invisibleEditor.GetDocData(1, ref guidIVSTextLines, out docDataPointer)); documentBuffer = (IVsTextLines)Marshal.GetObjectForIUnknown(docDataPointer); //It is important to site the TextBuffer object var objWSite = documentBuffer as IObjectWithSite; if (objWSite != null) { var oleServiceProvider = (IOleServiceProvider)GetService(typeof(IOleServiceProvider)); objWSite.SetSite(oleServiceProvider); } } else { documentBuffer = Marshal.GetObjectForIUnknown(punkDocDataExisting) as IVsTextLines; if (documentBuffer == null) { return(VSConstants.VS_E_INCOMPATIBLEDOCDATA); } } if (documentBuffer == null) { return(VSConstants.S_FALSE); } // set xml as the language service id ErrorHandler.ThrowOnFailure(documentBuffer.SetLanguageServiceID(ref Guids.XmlLanguageServiceGuid)); var editorPane = GetDocumentView(documentBuffer, pszMkDocument); ppunkDocView = Marshal.GetIUnknownForObject(editorPane); ppunkDocData = Marshal.GetIUnknownForObject(documentBuffer); pbstrEditorCaption = ""; return(VSConstants.S_OK); }
public int SetLanguageServiceID(ref Guid guidLangService) { return(_textBuffer.SetLanguageServiceID(ref guidLangService)); }
protected void InitializeLanguageService(IVsTextLines textLines, Guid langSid) { IVsUserData userData = textLines as IVsUserData; if (userData != null) { if (langSid != Guid.Empty) { Guid vsCoreSid = Guids.DefaultLanguageService; Guid currentSid; ErrorHandler.ThrowOnFailure(textLines.GetLanguageServiceID(out currentSid)); // If the language service is set to the default SID, then // set it to our language if (currentSid == vsCoreSid) { ErrorHandler.ThrowOnFailure(textLines.SetLanguageServiceID(ref langSid)); } else if (currentSid != langSid) { // Some other language service has it, so return VS_E_INCOMPATIBLEDOCDATA throw new COMException("Incompatible doc data", VSConstants.VS_E_INCOMPATIBLEDOCDATA); } Guid bufferDetectLang = VSConstants.VsTextBufferUserDataGuid.VsBufferDetectLangSID_guid; ErrorHandler.ThrowOnFailure(userData.SetData(ref bufferDetectLang, false)); } } }
/// <summary> /// Creates a new ConsoleWindow object. /// This constructor uses the service provider passed as an argument to create and initialize /// the text buffer. /// </summary> public ConsoleWindow(IServiceProvider provider) : base(null) { if (null == provider) throw new ArgumentNullException("provider"); globalProvider = provider; // Create the text buffer. textLines = (IVsTextLines)CreateObject(typeof(VsTextBufferClass), typeof(IVsTextLines)); // Get a reference to the global service provider. IOleServiceProvider nativeProvider = (IOleServiceProvider)globalProvider.GetService(typeof(IOleServiceProvider)); // The text buffer must be sited with the global service provider. ((IObjectWithSite)textLines).SetSite(nativeProvider); // Set the buffer as read-only. The user should be able to change the content of the // buffer only if the engine is started. uint flags; Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure( textLines.GetStateFlags(out flags)); flags |= (uint)Microsoft.VisualStudio.TextManager.Interop.BUFFERSTATEFLAGS.BSF_USER_READONLY; Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure( textLines.SetStateFlags(flags)); // Set the GUID of the language service that will handle this text buffer Guid languageGuid = typeof(PythonLanguage).GUID; Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure( textLines.SetLanguageServiceID(ref languageGuid)); // Initialize the history history = new HistoryBuffer(); // Create the stream on top of the text buffer. textStream = new TextBufferStream(textLines); // Initialize the engine. InitializeEngine(); // Set the title of the window. this.Caption = Resources.ToolWindowTitle; // Set the icon of the toolwindow. this.BitmapResourceID = 301; this.BitmapIndex = 0; }