public void GetStandardValues() { ReferenceConverter converter = new ReferenceConverter(typeof(TestComponent)); TestComponent component1 = new TestComponent(); TestComponent component2 = new TestComponent(); TestReferenceService referenceService = new TestReferenceService(); referenceService.AddReference("reference name 1", component1); referenceService.AddReference("reference name 2", component2); ITypeDescriptorContext context = new TestTypeDescriptorContext(referenceService); TypeConverter.StandardValuesCollection values = converter.GetStandardValues(context); Assert.IsNotNull(values, "#1"); // 2 components + 1 null value Assert.AreEqual(3, values.Count, "#2"); }
public static void Unload() { foreach (var watch in _watchers) { watch.Dispose(); } _watchers.Clear(); _importers = null; Importers = null; _processors = null; Processors = null; ImportersStandardValuesCollection = null; ProcessorsStandardValuesCollection = null; }
/// <summary> /// /// </summary> /// <param name="context"></param> /// <returns></returns> public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) { //ListAttribute listAttribute = (ListAttribute)context.PropertyDescriptor.Attributes[typeof(ListAttribute)]; //StandardValuesCollection vals = new TypeConverter.StandardValuesCollection(listAttribute._lst); //Dictionary<object, string> dic = GetEnumValueDesDic(typeof(PKGenerator)); //StandardValuesCollection vals = new TypeConverter.StandardValuesCollection(dic.Keys); if (dic == null || dic.Count <= 0) { LoadDic(context); } StandardValuesCollection vals = new TypeConverter.StandardValuesCollection(dic.Keys); return(vals); }
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) { if (this.values == null) { FontFamily[] families = FontFamily.Families; Hashtable hashtable = new Hashtable(); for (int i = 0; i < families.Length; i++) { string name = families[i].Name; hashtable[name.ToLower(CultureInfo.InvariantCulture)] = name; } object[] array = new object[hashtable.Values.Count]; hashtable.Values.CopyTo(array, 0); Array.Sort(array, Comparer.Default); this.values = new TypeConverter.StandardValuesCollection(array); } return(this.values); }
//scanning for RadItems //RadControl --> RootElement --> Children --> RootElement --> RadItemCollection Items public static List <IComponent> DiscoverCommandsSources(ICommand command, TypeConverter.StandardValuesCollection collection) { List <IComponent> commandSources = DiscoverCommandsSources(collection); List <IComponent> filteredCommandSources = new List <IComponent>(1); for (int i = 0; i < commandSources.Count; i++) { if ((commandSources[i].GetType()).IsAssignableFrom(command.ContextType)) { filteredCommandSources.Add(commandSources[i]); } } if (filteredCommandSources.Count > 0) { return(filteredCommandSources); } return(null); }
public SqlFileConnectionProperties(string defaultInstanceName) { _defaultDataSource = "."; if (defaultInstanceName != null && defaultInstanceName.Length > 0) { _defaultDataSource += "\\" + defaultInstanceName; } else { DataSourceConverter conv = new DataSourceConverter(); TypeConverter.StandardValuesCollection coll = conv.GetStandardValues(null); if (coll.Count > 0) { _defaultDataSource = coll[0] as string; } } LocalReset(); }
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) { if (this.values == null) { object[] objArray; if (types != null) { objArray = new object[types.Length]; Array.Copy(types, objArray, types.Length); } else { objArray = null; } this.values = new TypeConverter.StandardValuesCollection(objArray); } return(this.values); }
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) { //if (this.simpleTypeConverter != null) //{ // TypeConverter.StandardValuesCollection standardValues = this.simpleTypeConverter.GetStandardValues(context); // if (this.GetStandardValuesSupported(context) && standardValues != null) // { // object[] objArray1 = new object[standardValues.Count + 1]; // int num1 = 0; // object[] objArray2 = objArray1; // int index = num1; // int num2 = 1; // int num3 = index + num2; // // ISSUE: variable of the null type // __Null local = null; // objArray2[index] = (object)local; // foreach (object obj in standardValues) // objArray1[num3++] = obj; // return new TypeConverter.StandardValuesCollection((ICollection)objArray1); // } //} //return base.GetStandardValues(context); if (this.simpleTypeConverter != null) { TypeConverter.StandardValuesCollection standardValues = this.simpleTypeConverter.GetStandardValues(context); if (this.GetStandardValuesSupported(context) && standardValues != null) { object[] objArray = new object[standardValues.Count + 1]; int num = 0; int num1 = num; num = num1 + 1; objArray[num1] = null; foreach (object standardValue in standardValues) { int num2 = num; num = num2 + 1; objArray[num2] = standardValue; } return(new TypeConverter.StandardValuesCollection(objArray)); } } return(base.GetStandardValues(context)); }
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) { TypeConverter.StandardValuesCollection standardValues = base.GetStandardValues(context); object instance = context.Instance; int num = 0; int index = 0; object[] values = new object[standardValues.Count - 1]; while (num < standardValues.Count) { if (standardValues[num] != instance) { values[index] = standardValues[num]; index++; } num++; } return(new TypeConverter.StandardValuesCollection(values)); }
public override TypeConverter.StandardValuesCollection GetStandardValuesCore( ITypeDescriptorContext context, TypeConverter.StandardValuesCollection collection) { List <IComponent> componentList = CommandBaseConverter.DiscoverCommandsContexts(collection); if (context != null && componentList != null && context.GetService(typeof(IDesignerHost)) != null) { for (int index = componentList.Count - 1; index >= 0; --index) { if (componentList[index].Site == null) { componentList.RemoveAt(index); } } componentList.Insert(0, (IComponent)null); } return(new TypeConverter.StandardValuesCollection((ICollection)componentList)); }
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) { TypeConverter.StandardValuesCollection result = null; if (context.PropertyDescriptor.Name == "Parameterization") { ResourceManager manager = new ResourceManager("Microsoft.SqlTools.ServiceLayer.Localization.SR", typeof(DatabasePrototype).GetAssembly()); List <string> standardValues = new List <string>(); standardValues.Add(manager.GetString("prototype_db_prop_parameterization_value_forced")); standardValues.Add(manager.GetString("prototype_db_prop_parameterization_value_simple")); result = new TypeConverter.StandardValuesCollection(standardValues); } else { result = base.GetStandardValues(context); } return(result); }
public void GetStandardValues_IReferenceService_ReturnsExpected() { var converter = new ReferenceConverter(typeof(TestComponent)); var component1 = new TestComponent(); var component2 = new TestComponent(); var component3 = new Component(); var referenceService = new TestReferenceService(); referenceService.AddReference("reference name 1", component1); referenceService.AddReference("reference name 2", component2); referenceService.AddReference("reference name 3", component3); var context = new TestTypeDescriptorContext(referenceService); TypeConverter.StandardValuesCollection values = converter.GetStandardValues(context); Assert.Equal(new object[] { component1, component2, null }, values.Cast <object>()); }
public override TypeConverter.StandardValuesCollection GetStandardValues( ITypeDescriptorContext context) { ArrayList arrayList = new ArrayList(); TypeConverter.StandardValuesCollection standardValues = base.GetStandardValues(context); if (standardValues != null) { for (int index = 0; index < standardValues.Count; ++index) { if (index > 0) { object obj = standardValues[index]; arrayList.Add(obj); } } } return(new TypeConverter.StandardValuesCollection((ICollection)arrayList)); }
public static List <IComponent> DiscoverCommandsContexts(TypeConverter.StandardValuesCollection collection) { List <IComponent> tempList = new List <IComponent>(1); List <IComponent> returnList = new List <IComponent>(1); for (int i = 0; i < collection.Count; i++) { IComponent component = collection[i] as IComponent; if (component != null) { tempList.Add(component); } } returnList = DiscoverCommandsContexts(tempList); if (returnList != null && returnList.Count > 0) { return(returnList); } return(null); }
private void changeService_ComponentAdded(object sender, ComponentEventArgs e) { Control control = e.Component as Control; if (control is IDetailsTemplateControlBound) { DetailsTemplateControl detailsTemplateControl = (control as IDetailsTemplateControlBound).DetailsTemplateControl; PropertyDescriptor propertyDescriptor = TypeDescriptor.GetProperties(control)["AttributeName"]; if (propertyDescriptor != null) { TypeDescriptorContext context = new TypeDescriptorContext(this, control, propertyDescriptor); TypeConverter.StandardValuesCollection standardValues = propertyDescriptor.Converter.GetStandardValues(context); if (standardValues != null && standardValues.Count > 0) { propertyDescriptor.SetValue(control, standardValues[0]); } } } this.DataContext.IsDirty = true; }
public virtual void SetKeyValue(Dictionary <string, string> keyValue) { Key2Value = keyValue; if (Key2Value != null) { Values = new TypeConverter.StandardValuesCollection(Key2Value.Values); Value2Key = new Dictionary <string, string>(Key2Value.Count); foreach (KeyValuePair <string, string> kvp in Key2Value) { Value2Key[kvp.Value] = kvp.Key; } } else { Values = new TypeConverter.StandardValuesCollection(new ArrayList()); Value2Key = null; } }
public void GetStandardValues_ITypeDescriptorContext_ReturnEnumValues() { // Setup var mockRepository = new MockRepository(); var typeDescriptorContext = mockRepository.Stub <ITypeDescriptorContext>(); mockRepository.ReplayAll(); var converter = new NullableEnumConverter(typeof(SimpleEnum?)); // Call TypeConverter.StandardValuesCollection result = converter.GetStandardValues(typeDescriptorContext); // Assert Assert.IsNotNull(result); Assert.AreEqual(2, result.Count); Assert.AreEqual(SimpleEnum.FirstValue, result[0]); Assert.AreEqual(SimpleEnum.SecondValue, result[1]); mockRepository.VerifyAll(); }
public static List <IComponent> DiscoverCommandsSources( ICommand command, TypeConverter.StandardValuesCollection collection) { List <IComponent> componentList1 = CommandBaseConverter.DiscoverCommandsSources(collection); List <IComponent> componentList2 = new List <IComponent>(1); for (int index = 0; index < componentList1.Count; ++index) { if (componentList1[index].GetType().IsAssignableFrom(command.ContextType)) { componentList2.Add(componentList1[index]); } } if (componentList2.Count > 0) { return(componentList2); } return((List <IComponent>)null); }
public void GetStandardValues_IContainer_ReturnsExpected() { var component1 = new TestComponent(); var component2 = new TestComponent(); var component3 = new Component(); var container = new Container(); container.Add(component1); container.Add(component2); container.Add(component3); var converter = new ReferenceConverter(typeof(TestComponent)); var context = new TestTypeDescriptorContext { Container = container }; TypeConverter.StandardValuesCollection values = converter.GetStandardValues(context); Assert.Equal(new object[] { component1, component2, null }, values.Cast <object>()); }
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) { TypeConverter.StandardValuesCollection supportedCultures = null; if (context.PropertyDescriptor != null) { ExtenderProvidedPropertyAttribute attribute = context.PropertyDescriptor.Attributes[typeof(ExtenderProvidedPropertyAttribute)] as ExtenderProvidedPropertyAttribute; if (attribute != null) { CodeDomLocalizationProvider.LanguageExtenders provider = attribute.Provider as CodeDomLocalizationProvider.LanguageExtenders; if (provider != null) { supportedCultures = provider.SupportedCultures; } } } if (supportedCultures == null) { supportedCultures = base.GetStandardValues(context); } return(supportedCultures); }
public static List <IComponent> DiscoverCommandsSources( TypeConverter.StandardValuesCollection collection) { List <IComponent> list = new List <IComponent>(1); for (int index = 0; index < collection.Count; ++index) { IComponent component = collection[index] as IComponent; if (component != null) { list.Add(component); } } List <IComponent> componentList = CommandBaseConverter.DiscoverCommandsSources(list); if (componentList != null && componentList.Count > 0) { return(componentList); } return((List <IComponent>)null); }
public void GetStandardValues_IReferenceServiceInvalid_ReturnsExpected(object referenceService) { var converter = new ReferenceConverter(typeof(TestComponent)); int callCount = 0; var context = new MockTypeDescriptorContext { GetServiceAction = (serviceType) => { callCount++; Assert.Equal(typeof(IReferenceService), serviceType); return(referenceService); } }; TypeConverter.StandardValuesCollection values1 = converter.GetStandardValues(context); Assert.Equal(1, callCount); Assert.Equal(new object[] { null }, values1.Cast <object>()); // Call again to test caching behavior. TypeConverter.StandardValuesCollection values2 = converter.GetStandardValues(context); Assert.Equal(2, callCount); Assert.NotSame(values1, values2); }
/// <summary> /// /// </summary> /// <param name="context"></param> /// <returns></returns> public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) { if (this.values == null) { this.values = new TypeConverter.StandardValuesCollection(new string[] { "AbsoluteLayout", "AccordionLayout", "AnchorLayout", "BorderLayout", "CardLayout", "ColumnLayout", "AutoLayout", "FitLayout", "HBoxLayout", "MenuLayout", "TableLayout", "ToolbarLayout", "VBoxLayout" }); } return(this.values); }
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) { ArrayList list = new ArrayList(base.GetStandardValues(context)); TypeConverter.StandardValuesCollection standardValues = this.listConverter.GetStandardValues(context); ArrayList values = new ArrayList(); BindingSource instance = context.Instance as BindingSource; foreach (object obj2 in list) { if (obj2 != null) { ListBindableAttribute attribute = (ListBindableAttribute)TypeDescriptor.GetAttributes(obj2)[typeof(ListBindableAttribute)]; if (((attribute == null) || attribute.ListBindable) && ((instance == null) || (instance != obj2))) { DataTable table = obj2 as DataTable; if ((table == null) || !list.Contains(table.DataSet)) { values.Add(obj2); } } } } foreach (object obj3 in standardValues) { if (obj3 != null) { ListBindableAttribute attribute2 = (ListBindableAttribute)TypeDescriptor.GetAttributes(obj3)[typeof(ListBindableAttribute)]; if (((attribute2 == null) || attribute2.ListBindable) && ((instance == null) || (instance != obj3))) { values.Add(obj3); } } } values.Add(null); return(new TypeConverter.StandardValuesCollection(values)); }
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) { INuGenCounter counter = (context == null) ? null : (context.Instance as INuGenCounter); String machineName = "."; if (context != null) { machineName = counter.MachineName; } if (machineName != _previousMachineName) { _previousMachineName = machineName; try { PerformanceCounter.CloseSharedResources(); PerformanceCounterCategory[] categories = PerformanceCounterCategory.GetCategories(machineName); String[] categoryNames = new String[categories.Length]; for (Int32 categoryIndex = 0; categoryIndex < categories.Length; categoryIndex++) { categoryNames[categoryIndex] = categories[categoryIndex].CategoryName; } Array.Sort(categoryNames, Comparer.Default); _previousStandardValues = new TypeConverter.StandardValuesCollection(categoryNames); } catch { _previousStandardValues = null; } } return(_previousStandardValues); }
public void GetStandardValues_IContainerNullType_ReturnsExpected() { var component1 = new TestComponent(); var component2 = new TestComponent(); var component3 = new Component(); var container = new Container(); container.Add(component1); container.Add(component2); container.Add(component3); var converter = new ReferenceConverter(null); var context = new MockTypeDescriptorContext { Container = container }; TypeConverter.StandardValuesCollection values1 = converter.GetStandardValues(context); Assert.Equal(new object[] { null }, values1.Cast <object>()); // Call again to test caching behavior. TypeConverter.StandardValuesCollection values2 = converter.GetStandardValues(context); Assert.NotSame(values1, values2); }
public override TypeConverter.StandardValuesCollection GetStandardValuesCore(ITypeDescriptorContext context, TypeConverter.StandardValuesCollection collection) { List <IComponent> list = CommandBaseConverter.DiscoverCommandsSources(collection); list.Insert(0, null); return(new TypeConverter.StandardValuesCollection(list)); }
public void TestGetStandardValues() { TypeConverter.StandardValuesCollection stdVals = ic.GetStandardValues(null); Assert.AreEqual(1, stdVals.Count, "StandardValues count must be 1."); Assert.AreEqual(-1, stdVals [0], "Standard Value count must be -1."); }
public override TypeConverter.StandardValuesCollection GetStandardValuesCore(ITypeDescriptorContext context, TypeConverter.StandardValuesCollection collection) { List <CommandBase> list = CommandBaseConverter.DiscoverCommands(collection); if (list != null) { list.Insert(0, null); } return(new TypeConverter.StandardValuesCollection(list)); }
public static void Load(PipelineProject project) { Unload(); var assemblyPaths = new List <string>(); var projectRoot = project.Location; foreach (var i in project.References) { var path = Path.Combine(projectRoot, i); if (string.IsNullOrEmpty(path)) { throw new ArgumentException("assemblyFilePath cannot be null!"); } if (!Path.IsPathRooted(path)) { throw new ArgumentException("assemblyFilePath must be absolute!"); } // Make sure we're not adding the same assembly twice. path = PathHelper.Normalize(path); if (!assemblyPaths.Contains(path)) { assemblyPaths.Add(path); } } ResolveAssemblies(assemblyPaths); var importerDescriptions = new ImporterTypeDescription[_importers.Count]; var cur = 0; foreach (var item in _importers) { // Find the abstract base class ContentImporter<T>. var baseType = item.Type.BaseType; while (!baseType.IsAbstract) { baseType = baseType.BaseType; } var outputType = baseType.GetGenericArguments()[0]; var name = item.Attribute.DisplayName; if (string.IsNullOrEmpty(name)) { name = item.GetType().Name; } var desc = new ImporterTypeDescription() { TypeName = item.Type.Name, DisplayName = name, DefaultProcessor = item.Attribute.DefaultProcessor, FileExtensions = item.Attribute.FileExtensions, OutputType = outputType, }; importerDescriptions[cur] = desc; cur++; } Importers = importerDescriptions; ImportersStandardValuesCollection = new TypeConverter.StandardValuesCollection(Importers); var processorDescriptions = new ProcessorTypeDescription[_processors.Count]; const BindingFlags bindings = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static; cur = 0; foreach (var item in _processors) { var obj = Activator.CreateInstance(item.Type); var typeProperties = item.Type.GetProperties(bindings); var properties = new List <ProcessorTypeDescription.Property>(); foreach (var i in typeProperties) { var attrs = i.GetCustomAttributes(true); var name = i.Name; var browsable = true; var defvalue = i.GetValue(obj, null); foreach (var a in attrs) { if (a is BrowsableAttribute) { browsable = (a as BrowsableAttribute).Browsable; } else if (a is DisplayNameAttribute) { name = (a as DisplayNameAttribute).DisplayName; } } var p = new ProcessorTypeDescription.Property() { Name = i.Name, DisplayName = name, Type = i.PropertyType, DefaultValue = defvalue, Browsable = browsable }; properties.Add(p); } var inputType = (obj as IContentProcessor).InputType; var desc = new ProcessorTypeDescription() { TypeName = item.Type.Name, DisplayName = item.Attribute.DisplayName, Properties = new ProcessorTypeDescription.ProcessorPropertyCollection(properties), InputType = inputType, }; if (string.IsNullOrEmpty(desc.DisplayName)) { desc.DisplayName = desc.TypeName; } processorDescriptions[cur] = desc; cur++; } Processors = processorDescriptions; ProcessorsStandardValuesCollection = new TypeConverter.StandardValuesCollection(Processors); }