Beispiel #1
0
        private void BuildControllerSet()
        {
            var controllerFactories = ComponentLocatorForOrderedContentType <IControllerFactory> .ImportMany(_shell.CompositionService, TextBuffer.ContentType);

            if (controllerFactories != null)
            {
                foreach (var factory in controllerFactories)
                {
                    _controllers.AddRange(factory.Value.GetControllers(TextView, TextBuffer));
                }
            }
        }
        /// <summary>
        /// Retrives contained language host. Typically called from text view connection listener.
        /// </summary>
        /// <param name="textView">Primary text view</param>
        /// <param name="textBuffer">Contained language buffer</param>
        /// <param name="services"></param>
        /// <returns>Contained language host for this buffer and language, <seealso cref="IContainedLanguageHost"/></returns>
        public static IContainedLanguageHost GetHost(ITextView textView, ITextBuffer textBuffer, IServiceContainer services)
        {
            var containedLanguageHost = TryGetHost(textBuffer);

            if (containedLanguageHost == null)
            {
                var containedLanguageHostProvider =
                    ComponentLocatorForOrderedContentType <IContainedLanguageHostProvider> .
                    FindFirstOrderedComponent(services.GetService <ICompositionCatalog>(), textView.TextDataModel.DocumentBuffer.ContentType.TypeName);

                containedLanguageHost = containedLanguageHostProvider?.GetContainedLanguageHost(textView.ToEditorView(), textBuffer.ToEditorBuffer());
            }
            return(containedLanguageHost);
        }
        /// <summary>
        /// Retrives contained language host. Typically called from text view connection listener.
        /// </summary>
        /// <param name="textView">Primary text view</param>
        /// <param name="textBuffer">Contained language buffer</param>
        /// <param name="shell"></param>
        /// <returns>Contained language host for this buffer and language, <seealso cref="IContainedLanguageHost"/></returns>
        public static IContainedLanguageHost GetHost(ITextView textView, ITextBuffer textBuffer, ICoreShell shell)
        {
            IContainedLanguageHost containedLanguageHost = TryGetHost(textBuffer);

            if (containedLanguageHost == null)
            {
                var containedLanguageHostProvider =
                    ComponentLocatorForOrderedContentType <IContainedLanguageHostProvider> .
                    FindFirstOrderedComponent(shell, textView.TextDataModel.DocumentBuffer.ContentType.TypeName);

                if (containedLanguageHostProvider != null)
                {
                    containedLanguageHost = containedLanguageHostProvider.GetContainedLanguageHost(textView, textBuffer);
                }
            }

            return(containedLanguageHost);
        }
Beispiel #4
0
        public static ISettingsStorage GetSettings(ICompositionCatalog compositionCatalog, string contentTypeName)
        {
            ISettingsStorage settingsStorage = null;

            lock (_settingsLock) {
                if (_settingStorageMap.TryGetValue(contentTypeName, out settingsStorage))
                {
                    return(settingsStorage);
                }

                // Need to find the settings using MEF (don't use MEF inside of other locks, that can lead to deadlock)

                var contentTypeRegistry = compositionCatalog.ExportProvider.GetExportedValue <IContentTypeRegistryService>();

                var contentType = contentTypeRegistry.GetContentType(contentTypeName);
                Debug.Assert(contentType != null, "Cannot find content type object for " + contentTypeName);

                settingsStorage = ComponentLocatorForOrderedContentType <IWritableSettingsStorage> .FindFirstOrderedComponent(compositionCatalog.CompositionService, contentType);

                if (settingsStorage == null)
                {
                    settingsStorage = ComponentLocatorForOrderedContentType <ISettingsStorage> .FindFirstOrderedComponent(compositionCatalog.CompositionService, contentType);
                }

                if (settingsStorage == null)
                {
                    var storages = ComponentLocatorForContentType <IWritableSettingsStorage, IComponentContentTypes> .ImportMany(compositionCatalog.CompositionService, contentType);

                    if (storages.Any())
                    {
                        settingsStorage = storages.First().Value;
                    }
                }

                if (settingsStorage == null)
                {
                    var readonlyStorages = ComponentLocatorForContentType <ISettingsStorage, IComponentContentTypes> .ImportMany(compositionCatalog.CompositionService, contentType);

                    if (readonlyStorages.Any())
                    {
                        settingsStorage = readonlyStorages.First().Value;
                    }
                }

                Debug.Assert(settingsStorage != null, String.Format(CultureInfo.CurrentCulture,
                                                                    "Cannot find settings storage export for content type '{0}'", contentTypeName));

                if (_settingStorageMap.ContainsKey(contentTypeName))
                {
                    // some other thread came along and loaded settings already
                    settingsStorage = _settingStorageMap[contentTypeName];
                }
                else
                {
                    _settingStorageMap[contentTypeName] = settingsStorage;
                    settingsStorage.LoadFromStorage();
                }
            }

            return(settingsStorage);
        }
        /// <summary>
        /// Retrieves all services of a particular type available for the content type.
        /// Services are ordered in a way they should be accessed. This applies, for example,
        /// to command controller factories so controllers are called in a specific order.
        /// </summary>
        /// <typeparam name="T">Service type</typeparam>
        /// <param name="contentType">Content (file) type such as 'R' or 'Markdown'</param>
        /// <returns>Collection of service instances, if any</returns>
        public IEnumerable <Lazy <T> > GetAllOrderedServices <T>(string contentType) where T : class
        {
            var ct = _ctrs.GetContentType(contentType);

            return(ct != null ? ComponentLocatorForOrderedContentType <T> .ImportMany(_compositionService, ct) : Enumerable.Empty <Lazy <T> >());
        }