/// <summary> /// Initializes a new instance of the <see cref="T:CustomTypeProvider"/> class. /// </summary> /// <param name="provider">The provider.</param> public CustomTypeProvider(IServiceProvider provider) { DynamicTypeService typeService = (DynamicTypeService)provider.GetService(typeof(DynamicTypeService)); System.Diagnostics.Debug.Assert(typeService != null, "No dynamic type service registered."); IVsHierarchy hier = DteHelper2.GetCurrentSelection(provider); System.Diagnostics.Debug.Assert(hier != null, "No active hierarchy is selected."); ITypeDiscoveryService discovery = typeService.GetTypeDiscoveryService(hier); Project dteProject = VsHelper.ToDteProject(hier); availableTypes = new Dictionary <string, Type>(); LoadTypes(availableTypes, discovery.GetTypes(typeof(object), false), dteProject); // Try loading Project references LoadProjectReferenceTypesFromCurrentProject(availableTypes, provider, dteProject); // If we don't get any type loaded, try with the rest of the projects in the current sln if (availableTypes.Count == 0) { LoadTypesFromSolution(availableTypes, provider, dteProject); } EnsureKnownTypes(availableTypes); if (availableTypes.Count > 0 && TypesChanged != null) { TypesChanged(this, new EventArgs()); } }
internal static IDictionary <Type, DataControlFieldDesigner> GetCustomFieldDesigners(DesignerForm designerForm, DataBoundControl control) { Dictionary <Type, DataControlFieldDesigner> dictionary = new Dictionary <Type, DataControlFieldDesigner>(); ITypeDiscoveryService service = (ITypeDiscoveryService)control.Site.GetService(typeof(ITypeDiscoveryService)); if (service != null) { foreach (Type type in service.GetTypes(typeof(DataControlField), false)) { DesignerAttribute customAttribute = (DesignerAttribute)Attribute.GetCustomAttribute(type, typeof(DesignerAttribute)); if (customAttribute != null) { Type type2 = Type.GetType(customAttribute.DesignerTypeName, false, true); if ((type2 != null) && type2.IsSubclassOf(typeof(DataControlFieldDesigner))) { try { DataControlFieldDesigner designer = (DataControlFieldDesigner)Activator.CreateInstance(type2); if (designer.IsEnabled(control)) { designer.DesignerForm = designerForm; dictionary.Add(type, designer); } } catch { } } } } } return(dictionary); }
/// <summary> /// Uses the specified ITypeDiscoveryService service provider to discover MaskDescriptor objects from /// the referenced assemblies. /// </summary> public void DiscoverMaskDescriptors(ITypeDiscoveryService discoveryService) { if (discoveryService is null) { return; } ICollection descriptors = DesignerUtils.FilterGenericTypes(discoveryService.GetTypes(typeof(MaskDescriptor), false /* excludeGlobalTypes */)); // Note: This code assumes DesignerUtils.FilterGenericTypes return a valid ICollection (collection of MaskDescriptor types). foreach (Type t in descriptors) { if (t.IsAbstract || !t.IsPublic) { continue; } // Since mask descriptors can be provided from external sources, we need to guard against // possible exceptions when accessing an external descriptor. try { MaskDescriptor maskDescriptor = (MaskDescriptor)Activator.CreateInstance(t); InsertMaskDescriptor(0, maskDescriptor); } catch (Exception ex) { if (ClientUtils.IsCriticalException(ex)) { throw; } } } }
/// <summary> /// Returns a collection of standard values for the data type this type converter is designed for when provided with a format context. /// </summary> /// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext"></see> that provides a format context that can be used to extract additional information about the environment from which this converter is invoked. This parameter or properties of this parameter can be null.</param> /// <returns> /// A <see cref="T:System.ComponentModel.TypeConverter.StandardValuesCollection"></see> that holds a standard set of valid values, or null if the data type does not support a standard set of values. /// </returns> public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) { DynamicTypeService typeService = (DynamicTypeService)context.GetService(typeof(DynamicTypeService)); Debug.Assert(typeService != null, "No dynamic type service registered."); IVsHierarchy hier = DteHelper.GetCurrentSelection(context); Debug.Assert(hier != null, "No active hierarchy is selected."); ITypeDiscoveryService typeDiscovery = typeService.GetTypeDiscoveryService(hier); if (typeDiscovery != null) { List <string> types = new List <string>(); foreach (Type type in typeDiscovery.GetTypes(typeof(object), false)) { if (ShouldInclude(type)) { types.Add(type.FullName); } } types.Sort(StringComparer.CurrentCulture); return(new StandardValuesCollection(types)); } else { return(new StandardValuesCollection(new List <string>())); } }
private void PopulateColumnTypesCombo() { this.columnTypesCombo.Items.Clear(); IDesignerHost host = (IDesignerHost)this.liveDataGridView.Site.GetService(iDesignerHostType); if (host != null) { ITypeDiscoveryService service = (ITypeDiscoveryService)host.GetService(iTypeDiscoveryServiceType); if (service != null) { foreach (System.Type type in DesignerUtils.FilterGenericTypes(service.GetTypes(dataGridViewColumnType, false))) { if (((type != dataGridViewColumnType) && !type.IsAbstract) && (type.IsPublic || type.IsNestedPublic)) { DataGridViewColumnDesignTimeVisibleAttribute attribute = TypeDescriptor.GetAttributes(type)[dataGridViewColumnDesignTimeVisibleAttributeType] as DataGridViewColumnDesignTimeVisibleAttribute; if ((attribute == null) || attribute.Visible) { this.columnTypesCombo.Items.Add(new ComboBoxItem(type)); } } } this.columnTypesCombo.SelectedIndex = this.TypeToSelectedIndex(typeof(DataGridViewTextBoxColumn)); } } }
void InitDict(ITypeDescriptorContext context) { //sometimes happens... if (context == null) { return; } Dictionary <string, MyReferencableObject> tvalues = new Dictionary <string, MyReferencableObject>(); tvalues.Add(empty, null); ITypeDiscoveryService Service = (ITypeDiscoveryService)context.GetService(typeof(ITypeDiscoveryService)); //sometimes happens... if (Service == null) { return; } foreach (Type declaration in Service.GetTypes(ContainerType, false)) { foreach (FieldInfo fieldInfo in declaration.GetFields()) { if (context.PropertyDescriptor.PropertyType.IsAssignableFrom(fieldInfo.FieldType)) { MyReferencableObject var = (MyReferencableObject)fieldInfo.GetValue(null); var.FieldInfo = fieldInfo; tvalues.Add(var.FullName, var); } } } //in a perfect world the if should not be necessary.... if (tvalues.Count > 1 || values == null) { values = tvalues; } }
/// <summary> /// Returns the discovered types for autocomplete /// </summary> protected virtual IEnumerable <Type> DiscoverTypes() { DynamicTypeService typeService = (DynamicTypeService)DataGridView.Site.GetService(typeof(DynamicTypeService)); IVsHierarchy hier = DteHelper.GetCurrentSelection(DataGridView.Site); ITypeDiscoveryService typeDiscoveryService = typeService.GetTypeDiscoveryService(hier); return((IEnumerable <Type>)typeDiscoveryService.GetTypes(typeof(object), false)); }
public IEnumerable <ExtensibleEnumInfo <T> > GetValueInfos <T> (ExtensibleEnumDefinition <T> definition) where T : ExtensibleEnum <T> { ArgumentUtility.CheckNotNull("definition", definition); var types = _typeDiscoveryService.GetTypes(null, false).Cast <Type>(); return(GetValueInfosForTypes(definition, types)); }
public void GetTypes_WithTypeDiscoveryService_IncludeGac() { Expect.Call(_serviceProvider.GetService(typeof(ITypeDiscoveryService))).Return(_typeDiscoveryService); Expect.Call(_typeDiscoveryService.GetTypes(typeof(object), false)) .Return( new object[] { typeof(ClassWithAllDataTypes), typeof(SimpleValueType), typeof(SimpleReferenceType), typeof(ManualBusinessObject), typeof(ClassWithIdentity), typeof(ClassDerivedFromBindableObjectBase), typeof(ClassDerivedFromBindableObjectWithIdentityBase), }); _mockRepository.ReplayAll(); var finder = new BindableObjectTypeFinder(_serviceProvider); List <Type> types = finder.GetTypes(true); Assert.That(types, Is.EquivalentTo(new[] { typeof(ClassWithAllDataTypes), typeof(ClassWithIdentity), typeof(ClassDerivedFromBindableObjectBase), typeof(ClassDerivedFromBindableObjectWithIdentityBase) })); _mockRepository.VerifyAll(); }
private ICollection GetAllDesignerTypes(bool includeGac) { ITypeDiscoveryService typeDiscoveryService = (ITypeDiscoveryService)_serviceProvider.GetService(typeof(ITypeDiscoveryService)); if (typeDiscoveryService == null) { return(Type.EmptyTypes); } else { return(typeDiscoveryService.GetTypes(typeof(object), !includeGac)); } }
/// <summary> /// Создание списка возможных типов таблицы. /// </summary> public void FillTable(ITypeDiscoveryService TypeDiscoveryService, Type type) { if (TypeDiscoveryService != null) { ICollection types = TypeDiscoveryService.GetTypes(type, false); foreach (Type actionType in types) { if (actionType != type) { Add(new XPTable(actionType)); } } } }
public IEnumerable <Type> FindMixedTypes(MixinConfiguration configuration) { ArgumentUtility.CheckNotNull("configuration", configuration); var types = _typeDiscoveryService.GetTypes(null, false); s_log.InfoFormat( "Retrieving class contexts for {0} configured mixin targets and {1} loaded types.", configuration.ClassContexts.Count, types.Count); return(from t in types.Cast <Type>() where !t.IsDefined(typeof(IgnoreForMixinConfigurationAttribute), false) let context = configuration.GetContext(t) where context != null && !MixinTypeUtility.IsGeneratedConcreteMixedType(t) && ShouldProcessContext(context) select t); }
public static System.Type[] GetCustomItemTypes(IComponent component, ITypeDiscoveryService discoveryService) { if (discoveryService != null) { ICollection types = discoveryService.GetTypes(toolStripItemType, false); ToolStripItemDesignerAvailability designerVisibility = GetDesignerVisibility(GetToolStripFromComponent(component)); System.Type[] standardItemTypes = GetStandardItemTypes(component); if (designerVisibility != ToolStripItemDesignerAvailability.None) { ArrayList list = new ArrayList(types.Count); foreach (System.Type type in types) { if ((type.IsAbstract || (!type.IsPublic && !type.IsNestedPublic)) || (type.ContainsGenericParameters || (type.GetConstructor(new System.Type[0]) == null))) { continue; } ToolStripItemDesignerAvailabilityAttribute attribute = (ToolStripItemDesignerAvailabilityAttribute)TypeDescriptor.GetAttributes(type)[typeof(ToolStripItemDesignerAvailabilityAttribute)]; if ((attribute != null) && ((attribute.ItemAdditionVisibility & designerVisibility) == designerVisibility)) { bool flag = false; foreach (System.Type type2 in standardItemTypes) { if (type2 == type) { flag = true; break; } } if (!flag) { list.Add(type); } } } if (list.Count > 0) { System.Type[] array = new System.Type[list.Count]; list.CopyTo(array, 0); CustomToolStripItemCount = list.Count; return(array); } } } CustomToolStripItemCount = 0; return(new System.Type[0]); }
public esDataSourceWizard(IServiceProvider provider, DataSourceControl esDataSource) { InitializeComponent(); this.esDataSource = esDataSource; this.provider = provider; this.helper = new esReflectionHelper(); //---------------------------------------------------- // Let's see if we can load our types right up !! //---------------------------------------------------- ITypeDiscoveryService discovery = null; if (esDataSource.Site != null) { discovery = (ITypeDiscoveryService)esDataSource.Site.GetService(typeof(ITypeDiscoveryService)); } ICollection types = discovery.GetTypes(typeof(esEntityCollectionBase), true); foreach (Type type in types) { if (type.IsClass && !type.IsAbstract) { if (type.IsSubclassOf(typeof(esEntityCollectionBase))) { try { esEntityCollectionBase coll = Activator.CreateInstance(type) as esEntityCollectionBase; if (coll != null) { collections[type.Name] = coll; } } catch { } } } } foreach (string collectionName in collections.Keys) { this.lboxCollections.Items.Add(collectionName); } }
private void LoadTypesFromProjects(List <EnvDTE.Project> projects, Dictionary <string, Type> availableTypes, IServiceProvider provider, Project currentProject) { DynamicTypeService typeService = (DynamicTypeService)provider.GetService(typeof(DynamicTypeService)); foreach (Project project in projects) { if (project.UniqueName != currentProject.UniqueName) { IVsHierarchy hier = DteHelper2.GetVsHierarchy(provider, project); System.Diagnostics.Debug.Assert(hier != null, "No active hierarchy is selected."); ITypeDiscoveryService discovery = typeService.GetTypeDiscoveryService(hier); LoadTypes(availableTypes, discovery.GetTypes(typeof(object), false), project); } } }
private void AddTypes(ITypeDiscoveryService discovery, Project dteProject) { bool isWebProject = DteHelper.IsWebProject(dteProject); ICollection types = null; try { types = discovery.GetTypes(typeof(object), false); } catch { types = new ArrayList(); } foreach (Type type in types) { if (!availableTypes.ContainsKey(type.FullName)) { // Web projects do not have if (!isWebProject && type.Assembly.GetName().Name != (string)dteProject.Properties.Item("AssemblyName").Value) { availableTypes.Add(type.FullName, type); } else { availableTypes.Add(type.FullName, new ProjectType(type)); } } } if (types.Count > 0 && useProjectItemWrapper) { foreach (ProjectItem projectItem in dteProject.ProjectItems) { Type type = BuilderProjectItemWrapper.BuildWrapper(projectItem); if (type != null && !availableTypes.ContainsKey(type.FullName)) { availableTypes.Add(type.FullName, type); } } } }
private void DiscoverTypes() { // try to get a reference to the type discovery service ITypeDiscoveryService discovery = null; if (_control.Site != null) { discovery = (ITypeDiscoveryService)_control.Site.GetService(typeof(ITypeDiscoveryService)); } if (discovery != null) { // saves the cursor and sets the wait cursor Cursor previousCursor = Cursor.Current; Cursor.Current = Cursors.WaitCursor; try { // gets all types using the type discovery service ICollection types = discovery.GetTypes(typeof(object), true); TypeComboBox.BeginUpdate(); TypeComboBox.Items.Clear(); // adds the types to the list foreach (Type type in types) { if (type.Assembly.FullName.Substring(0, type.Assembly.FullName.IndexOf(",")) != "Csla" && typeof(Csla.Core.IBusinessObject).IsAssignableFrom(type)) { string name = type.AssemblyQualifiedName; if (name.Substring(name.Length - 19, 19) == "PublicKeyToken=null") { name = name.Substring(0, name.IndexOf(",", name.IndexOf(",") + 1)); } TypeComboBox.Items.Add(name); } } } finally { Cursor.Current = previousCursor; TypeComboBox.EndUpdate(); } } }
public void Start(IWindowsFormsEditorService edSvc, ITypeDiscoveryService discoveryService, System.Type defaultType) { this.edSvc = edSvc; this.typesListBox.Items.Clear(); foreach (System.Type type in DesignerUtils.FilterGenericTypes(discoveryService.GetTypes(dataGridViewColumnType, false))) { if (((type != dataGridViewColumnType) && !type.IsAbstract) && (type.IsPublic || type.IsNestedPublic)) { DataGridViewColumnDesignTimeVisibleAttribute attribute = TypeDescriptor.GetAttributes(type)[typeof(DataGridViewColumnDesignTimeVisibleAttribute)] as DataGridViewColumnDesignTimeVisibleAttribute; if ((attribute == null) || attribute.Visible) { this.typesListBox.Items.Add(new ListBoxItem(type)); } } } this.typesListBox.SelectedIndex = this.TypeToSelectedIndex(defaultType); this.selectedType = null; base.Width = Math.Max(base.Width, this.PreferredWidth + (SystemInformation.VerticalScrollBarWidth * 2)); }
public void Start(IWindowsFormsEditorService edSvc, ITypeDiscoveryService discoveryService, System.Type defaultType) { this.edSvc = edSvc; this.typesListBox.Items.Clear(); foreach (System.Type type in DesignerUtils.FilterGenericTypes(discoveryService.GetTypes(dataGridViewColumnType, false))) { if (((type != dataGridViewColumnType) && !type.IsAbstract) && (type.IsPublic || type.IsNestedPublic)) { DataGridViewColumnDesignTimeVisibleAttribute attribute = TypeDescriptor.GetAttributes(type)[typeof(DataGridViewColumnDesignTimeVisibleAttribute)] as DataGridViewColumnDesignTimeVisibleAttribute; if ((attribute == null) || attribute.Visible) { this.typesListBox.Items.Add(new ListBoxItem(type)); } } } this.typesListBox.SelectedIndex = this.TypeToSelectedIndex(defaultType); this.selectedType = null; base.Width = Math.Max(base.Width, this.PreferredWidth + (SystemInformation.VerticalScrollBarWidth * 2)); }
/// <summary> /// Using the specified type discovery service, this method locates all the possible /// context types (currently LTS and EDM only) /// </summary> /// <param name="typeDiscoveryService">The type discovery service to use. It cannot be null.</param> /// <param name="allowDbContext">A boolean indicating if DbContext is an allowable context type</param> /// <returns>A non-null (but possibly empty) list of candidate types</returns> private IEnumerable <Type> GetCandidateTypes(ITypeDiscoveryService typeDiscoveryService, bool allowDbContext, out bool foundDbContext) { foundDbContext = false; List <Type> candidates = new List <Type>(); VSProject currentProject = this.ActiveProject.Object as VSProject; if (currentProject == null || typeDiscoveryService == null) { return(candidates); } List <Reference> references = new List <Reference>(); foreach (Reference reference in currentProject.References) { if (reference != null && !string.IsNullOrEmpty(reference.Name) && reference.Type == prjReferenceType.prjReferenceTypeAssembly) { references.Add(reference); } } // Cache the value of LinqToSqlContext.EnableDataContextTypes locally since the property cannot be cached. bool dataContextEnabled = LinqToSqlContext.EnableDataContextTypes; // Get all types contained in and referenced by the project. From that list, we find the types interesting to us. foreach (Type t in typeDiscoveryService.GetTypes(typeof(object), true)) { bool typeIsDbContext; if (DomainServiceClassWizard.IsContextType(t, dataContextEnabled, allowDbContext, out typeIsDbContext)) { if (IsVisibleInCurrentProject(t, currentProject, references)) { candidates.Add(t); } } foundDbContext |= typeIsDbContext; } return(candidates); }
public IEnumerable <Type> GetProjectReferencedTypes() { if (_projectReferencedTypes != null) { return(_projectReferencedTypes); } try { _projectReferencedTypes = _discovery.GetTypes(typeof(object), true) as IEnumerable <Type>; } catch (NullReferenceException) { //Type Discovery service isn't ready yet. } catch (Exception) { throw; } return(_projectReferencedTypes); }
private Type[] getReturnedTypes(IServiceProvider provider) { List <Type> res = new List <Type>(); ITypeDiscoveryService tds = (ITypeDiscoveryService) provider.GetService(typeof(ITypeDiscoveryService)); if (tds != null) { foreach (Type actionType in tds.GetTypes(typeof(Action), false)) { if (actionType.GetCustomAttributes(typeof(StandardActionAttribute), false).Length > 0 && !res.Contains(actionType)) { res.Add(actionType); } } } return(res.ToArray()); }
/// <summary> /// Возвращает массив типов объектов, которые унаследованны от абстрактного класса /// NetworkService /// </summary> /// <param name="provider"></param> /// <returns>Массив типов сетевых устройств</returns> private Type[] GetReturnedTypes(IServiceProvider provider) { List <Type> result = new List <Type>(); // Получаем интерфейс сервиса. Насколько я понял, это работает только // В design-time. В run-time tds возвращается null !!! ITypeDiscoveryService tds = (ITypeDiscoveryService)provider. GetService(typeof(ITypeDiscoveryService)); if (tds != null) { // Для режима design-time // Нам нужны все "родственники" типа Device foreach (Type type in tds.GetTypes(typeof(NetworkService), false)) { if (!result.Contains(type)) { result.Add(type); } } } else { // Для режима run-time System.Reflection.Assembly asmbl = System.Reflection.Assembly.GetExecutingAssembly(); // Нам нужны все "родственники" типа Device foreach (Type type in asmbl.GetTypes()) { if (type.BaseType == typeof(NetworkService)) { if (!result.Contains(type)) { result.Add(type); } } } } return(result.ToArray()); }
/// <summary> /// Конвертирование из строки в тип. /// </summary> public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) { ITypeDiscoveryService discoveryService = (ITypeDiscoveryService)context.GetService(typeof(ITypeDiscoveryService)); if (discoveryService == null) { discoveryService = (ITypeDiscoveryService)((IServiceProvider)((Component)context.Instance).Site).GetService(typeof(ITypeDiscoveryService)); } if (discoveryService != null) { foreach (Type actionType in discoveryService.GetTypes(typeof(T), false)) { if (actionType.FullName == (string)value) { return(actionType); } } } return(base.ConvertFrom(context, culture, value)); }
public void DiscoverMaskDescriptors(ITypeDiscoveryService discoveryService) { if (discoveryService != null) { foreach (System.Type type in DesignerUtils.FilterGenericTypes(discoveryService.GetTypes(typeof(MaskDescriptor), false))) { if (!type.IsAbstract && type.IsPublic) { try { MaskDescriptor maskDescriptor = (MaskDescriptor)Activator.CreateInstance(type); this.InsertMaskDescriptor(0, maskDescriptor); } catch (Exception exception) { if (System.Windows.Forms.ClientUtils.IsCriticalException(exception)) { throw; } } } } } }
/// <summary> /// Создание начальных записей в выпадающем списке /// </summary> public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) { List <Type> result = new List <Type>(); ITypeDiscoveryService discoveryService = (ITypeDiscoveryService)context.GetService(typeof(ITypeDiscoveryService)); if (discoveryService == null) { discoveryService = (ITypeDiscoveryService)((IServiceProvider)((Component)context.Instance).Site).GetService(typeof(ITypeDiscoveryService)); } if (discoveryService != null) { foreach (Type actionType in discoveryService.GetTypes(typeof(T), false)) { if (!result.Contains(actionType) && actionType != typeof(T)) { result.Add(actionType); } } } return(new StandardValuesCollection(result.ToArray())); }
public static ArrayList GetCommandDescriptors(ITypeDescriptorContext context) { if (_buffer != null) { return(_buffer); } ArrayList types = new ArrayList(); try { types.Add(typeof(DCSoft.CSharpWriter.Commands.WriterCommandModuleBrowse)); types.Add(typeof(DCSoft.CSharpWriter.Commands.WriterCommandModuleEdit)); types.Add(typeof(DCSoft.CSharpWriter.Commands.WriterCommandModuleFile)); //foreach (Type t in typeof(WriterCommandModule).Assembly.GetTypes()) //{ // if (t.IsSubclassOf(typeof(WriterCommandModule))) // { // types.Add(t); // } // else if (t.IsSubclassOf(typeof(WriterCommand))) // { // types.Add(t); // } //} } catch (Exception ext) { MessageBox.Show(ext.ToString()); } //MessageBox.Show(td == null ? "null" : td.GetType().FullName); ITypeDiscoveryService td = (ITypeDiscoveryService)context.GetService(typeof(ITypeDiscoveryService)); if (td != null) { //MessageBox.Show(td.GetType().FullName + " " + td.GetType().Assembly.Location ); ICollection acts = td.GetTypes(typeof(WriterCommand), false); //MessageBox.Show(acts == null ? "-1" : acts.Count.ToString()); if (acts != null) { foreach (Type t in acts) { if (types.Contains(t) == false) { types.Add(t); } } //types.AddRange(acts); }//if acts = td.GetTypes(typeof(CSWriterCommandModule), false); //MessageBox.Show(acts == null ? "no module" : acts.Count.ToString()); if (acts != null) { foreach (Type t in acts) { if (types.Contains(t) == false) { types.Add(t); } } //types.AddRange(acts); } }//if _buffer = GetCommandDescriptors((Type[])types.ToArray(typeof(Type))); return(_buffer); }
public static System.Type[] GetCustomItemTypes(IComponent component, ITypeDiscoveryService discoveryService) { if (discoveryService != null) { ICollection types = discoveryService.GetTypes(toolStripItemType, false); ToolStripItemDesignerAvailability designerVisibility = GetDesignerVisibility(GetToolStripFromComponent(component)); System.Type[] standardItemTypes = GetStandardItemTypes(component); if (designerVisibility != ToolStripItemDesignerAvailability.None) { ArrayList list = new ArrayList(types.Count); foreach (System.Type type in types) { if ((type.IsAbstract || (!type.IsPublic && !type.IsNestedPublic)) || (type.ContainsGenericParameters || (type.GetConstructor(new System.Type[0]) == null))) { continue; } ToolStripItemDesignerAvailabilityAttribute attribute = (ToolStripItemDesignerAvailabilityAttribute) TypeDescriptor.GetAttributes(type)[typeof(ToolStripItemDesignerAvailabilityAttribute)]; if ((attribute != null) && ((attribute.ItemAdditionVisibility & designerVisibility) == designerVisibility)) { bool flag = false; foreach (System.Type type2 in standardItemTypes) { if (type2 == type) { flag = true; break; } } if (!flag) { list.Add(type); } } } if (list.Count > 0) { System.Type[] array = new System.Type[list.Count]; list.CopyTo(array, 0); CustomToolStripItemCount = list.Count; return array; } } } CustomToolStripItemCount = 0; return new System.Type[0]; }
public static Type[] GetCustomItemTypes(IComponent component, ITypeDiscoveryService discoveryService) { if (discoveryService != null) { // fish out all types which derive from toolstrip item ICollection itemTypes = discoveryService.GetTypes(s_toolStripItemType, false /*excludeGlobalTypes*/); ToolStrip toolStrip = GetToolStripFromComponent(component); // determine the value of the visibility attribute which matches the current toolstrip type. ToolStripItemDesignerAvailability currentToolStripVisibility = GetDesignerVisibility(toolStrip); Debug.Assert(currentToolStripVisibility != ToolStripItemDesignerAvailability.None, "Why is GetDesignerVisibility returning None?"); // fish out the ones we've already listed. Type[] stockItemTypeList = GetStandardItemTypes(component); if (currentToolStripVisibility != ToolStripItemDesignerAvailability.None) { ArrayList createableTypes = new ArrayList(itemTypes.Count); foreach (Type t in itemTypes) { if (t.IsAbstract) { continue; } if (!t.IsPublic && !t.IsNestedPublic) { continue; } if (t.ContainsGenericParameters) { continue; } // Check if we have public constructor... ConstructorInfo ctor = t.GetConstructor(new Type[0]); if (ctor == null) { continue; } // if the visibility matches the current toolstrip type, add it to the list of possible types to create. ToolStripItemDesignerAvailabilityAttribute visiblityAttribute = (ToolStripItemDesignerAvailabilityAttribute)TypeDescriptor.GetAttributes(t)[typeof(ToolStripItemDesignerAvailabilityAttribute)]; if (visiblityAttribute != null && ((visiblityAttribute.ItemAdditionVisibility & currentToolStripVisibility) == currentToolStripVisibility)) { bool isStockType = false; // PERF: consider a dictionary - but this list will usually be 3-7 items. foreach (Type stockType in stockItemTypeList) { if (stockType == t) { isStockType = true; break; } } if (!isStockType) { createableTypes.Add(t); } } } if (createableTypes.Count > 0) { Type[] createableTypesArray = new Type[createableTypes.Count]; createableTypes.CopyTo(createableTypesArray, 0); s_customToolStripItemCount = createableTypes.Count; return(createableTypesArray); } } } s_customToolStripItemCount = 0; return(new Type[0]); }
public void DiscoverMaskDescriptors(ITypeDiscoveryService discoveryService) { if (discoveryService != null) { foreach (System.Type type in DesignerUtils.FilterGenericTypes(discoveryService.GetTypes(typeof(MaskDescriptor), false))) { if (!type.IsAbstract && type.IsPublic) { try { MaskDescriptor maskDescriptor = (MaskDescriptor) Activator.CreateInstance(type); this.InsertMaskDescriptor(0, maskDescriptor); } catch (Exception exception) { if (System.Windows.Forms.ClientUtils.IsCriticalException(exception)) { throw; } } } } } }
private ListBox CreateListBox(ITypeDescriptorContext context, object value) { ListBox listBox = new ListBox(); listBox.SelectedValueChanged += new EventHandler(listBox_SelectedValueChanged); listBox.Dock = DockStyle.Fill; listBox.BorderStyle = BorderStyle.None; listBox.ItemHeight = 13; listBox.Items.Add("(none)"); // Load standard shapes if (context.Container != null) { ITypeDiscoveryService discoveryService = (ITypeDiscoveryService)context.GetService(typeof(ITypeDiscoveryService)); foreach (Type type in discoveryService.GetTypes(typeof(ElementShape), false)) { if (type != typeof(CustomShape) && !type.IsAbstract && type.IsPublic) { listBox.Items.Add(type.Name); shapes.Add(type); if (value != null && value.GetType() == type) { listBox.SelectedIndex = listBox.Items.Count - 1; } } } } else { foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies()) { try { if (!IsTelerikAssembly(assembly)) { continue; } foreach (Type type in assembly.GetTypes()) { if (type.IsClass && type.IsPublic && !type.IsAbstract && typeof(ElementShape).IsAssignableFrom(type) && type != typeof(CustomShape)) { listBox.Items.Add(type.Name); shapes.Add(type); if (value != null && value.GetType() == type) { listBox.SelectedIndex = listBox.Items.Count - 1; } } } } catch (ReflectionTypeLoadException e) { string message = e.Message + "\n\nLoader Exceptions:\n"; for (int i = 0; i < Math.Min(MaxLoaderExceptionsInMessageBox, e.LoaderExceptions.Length); i++) { message += e.LoaderExceptions[i].Message + "\n"; } if (e.LoaderExceptions.Length > MaxLoaderExceptionsInMessageBox) { message += "More..."; } MessageBox.Show(message, assembly.FullName); } catch (Exception ex) { MessageBox.Show(ex.Message, assembly.FullName); } } } // Load custom shape components if (context.Container != null) { foreach (IComponent component in context.Container.Components) { if (component is CustomShape) { listBox.Items.Add(component.Site.Name); shapes.Add(component); if (component == value) { listBox.SelectedIndex = listBox.Items.Count - 1; } } } listBox.Items.Add("Create new custom shape ..."); if (value != null && value is CustomShape) { listBox.Items.Add("Edit points ..."); } } else { if (value != null && value is CustomShape) { listBox.Items.Add("Edit points ..."); } else { listBox.Items.Add("Create new custom shape ..."); } } return(listBox); }
/// <summary> /// Gets the default service configuration for the types returned by the given <see cref="ITypeDiscoveryService"/>. /// </summary> /// <returns>A <see cref="ServiceConfigurationEntry"/> for each serviceType that has implementations with a <see cref="ImplementationForAttribute"/> applied. /// Types without the attribute are ignored.</returns> public IEnumerable <ServiceConfigurationEntry> GetDefaultConfiguration() { return(GetDefaultConfiguration(_typeDiscoveryService.GetTypes(null, _excludeGlobalTypesForDefaultConfiguration).Cast <Type>())); }
/// <summary> /// Using the specified type discovery service, this method locates all the possible /// context types (currently LTS and EDM only) /// </summary> /// <param name="typeDiscoveryService">The type discovery service to use. It cannot be null.</param> /// <param name="allowDbContext">A boolean indicating if DbContext is an allowable context type</param> /// <returns>A non-null (but possibly empty) list of candidate types</returns> private IEnumerable<Type> GetCandidateTypes(ITypeDiscoveryService typeDiscoveryService, bool allowDbContext, out bool foundDbContext) { foundDbContext = false; List<Type> candidates = new List<Type>(); VSProject currentProject = this.ActiveProject.Object as VSProject; if (currentProject == null || typeDiscoveryService == null) { return candidates; } List<Reference> references = new List<Reference>(); foreach (Reference reference in currentProject.References) { if (reference != null && !string.IsNullOrEmpty(reference.Name) && reference.Type == prjReferenceType.prjReferenceTypeAssembly) { references.Add(reference); } } // Cache the value of LinqToSqlContext.EnableDataContextTypes locally since the property cannot be cached. bool dataContextEnabled = LinqToSqlContext.EnableDataContextTypes; // Get all types contained in and referenced by the project. From that list, we find the types interesting to us. foreach (Type t in typeDiscoveryService.GetTypes(typeof(object), true)) { bool typeIsDbContext; if (DomainServiceClassWizard.IsContextType(t, dataContextEnabled, allowDbContext, out typeIsDbContext)) { if (IsVisibleInCurrentProject(t, currentProject, references)) { candidates.Add(t); } } foundDbContext |= typeIsDbContext; } return candidates; }
private IEnumerable <Type> GetDomainObjectTypes() { return((from type in _typeDiscoveryService.GetTypes(typeof(DomainObject), false).Cast <Type>() where !ReflectionUtility.IsTypeIgnoredForMappingConfiguration(type) select type).Distinct()); }