public void TestFixtureSetUp()
		{
			if (_dummyCulture == null)
				throw new Exception("Error setting up test - dummyCulture should not be NULL");
			if (CultureInfo.InvariantCulture.Equals(_dummyCulture))
				throw new Exception("Error setting up test - dummyCulture should not be invariant");
			if (_dummyCulture2 == null)
				throw new Exception("Error setting up test - dummyCulture2 should not be NULL");
			if (CultureInfo.InvariantCulture.Equals(_dummyCulture2))
				throw new Exception("Error setting up test - dummyCulture2 should not be invariant");
			if (_dummyCulture2.Equals(_dummyCulture))
				throw new Exception("Error setting up test - dummyCulture2 should not be the same as dummyCulture");

			// for testing purposes, set up the converter for a specific culture to have a custom mapping
			// normally, you would use TypeDescriptor.GetConverter, but we want to keep the test appdomain clean of these testing mods
			XMouseButtonsConverter converter = new XMouseButtonsConverter(_dummyCulture);
			IDictionary<XMouseButtons, string> relocalizedNames = new Dictionary<XMouseButtons, string>();
			relocalizedNames[XMouseButtons.Left] = "LMouse";
			relocalizedNames[XMouseButtons.Right] = "RMouse";
			relocalizedNames[XMouseButtons.Middle] = "Mouse3";
			relocalizedNames[XMouseButtons.XButton1] = "Mouse4";
			relocalizedNames[XMouseButtons.XButton2] = XMouseButtonsConverter.ButtonSeparator.ToString();
			converter.LocalizedNames = relocalizedNames;

			_converter = converter;
		}
예제 #2
0
        /// <summary>
        /// This method retrieves a set of CDSAttribute from a class.
        /// </summary>
        /// <param name="data">The class to examine.</param>
        /// <param name="conv">A converter function to turn the value in to a string.</param>
        /// <returns>Returns an enumerable collection of attributes and values.</returns>
        public static IEnumerable<KeyValuePair<CDSAttributeAttribute, string>> CDSAttributesRetrieve(
            this IXimuraContent data, TypeConverter conv)
        {
            List<KeyValuePair<PropertyInfo, CDSAttributeAttribute>> attrList =
                AH.GetPropertyAttributes<CDSAttributeAttribute>(data.GetType());

            foreach (KeyValuePair<PropertyInfo, CDSAttributeAttribute> reference in attrList)
            {
                PropertyInfo pi = reference.Key;

                if (pi.PropertyType == typeof(string))
                {
                    yield return new KeyValuePair<CDSAttributeAttribute, string>(
                        reference.Value, pi.GetValue(data, null) as string);
                }
                else if (pi.PropertyType == typeof(IEnumerable<string>))
                {
                    IEnumerable<string> enumerator = pi.GetValue(data, null) as IEnumerable<string>;
                    foreach (string value in enumerator)
                        yield return new KeyValuePair<CDSAttributeAttribute, string>(
                            reference.Value, value);
                }
                else if (conv != null && conv.CanConvertFrom(pi.PropertyType))
                {
                    yield return new KeyValuePair<CDSAttributeAttribute, string>(
                        reference.Value, conv.ConvertToString(pi.GetValue(data, null)));
                }
            }
        }
 public LocalizedPropertyDescriptor(PropertyDescriptor basePropertyDescriptor)
     : base(basePropertyDescriptor)
 {
     this.localizedName = string.Empty;
     this.localizedDescription = string.Empty;
     this.localizedCategory = string.Empty;
     this.customTypeConverter = null;
     LocalizedPropertyAttribute attribute = null;
     foreach (Attribute attribute2 in basePropertyDescriptor.Attributes)
     {
         attribute = attribute2 as LocalizedPropertyAttribute;
         if (attribute != null)
         {
             break;
         }
     }
     if (attribute != null)
     {
         this.localizedName = attribute.Name;
         this.localizedDescription = attribute.Description;
         this.localizedCategory = attribute.Category;
     }
     else
     {
         this.localizedName = basePropertyDescriptor.Name;
         this.localizedDescription = basePropertyDescriptor.Description;
         this.localizedCategory = basePropertyDescriptor.Category;
     }
     this.basePropertyDescriptor = basePropertyDescriptor;
     if (basePropertyDescriptor.PropertyType == typeof(bool))
     {
         this.customTypeConverter = new BooleanTypeConverter();
     }
 }
예제 #4
0
        /// <summary>
        /// </summary>
        protected T ReadSetting <T>(string settingName, T defaultValue)
        {
            Hashtable settings = _controller.GetTabModuleSettings(_tabModuleId);

            T ret = default(T);

            if (settings.ContainsKey(settingName))
            {
                System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(typeof(T));
                try
                {
                    ret = (T)tc.ConvertFrom(settings[settingName]);
                }
                catch
                {
                    ret = defaultValue;
                }
            }
            else
            {
                ret = defaultValue;
            }

            return(ret);
        }
예제 #5
0
        public override object ParseFormattedValue(
            object formattedValue,
            DataGridViewCellStyle cellStyle,
            TypeConverter formattedValueTypeConverter,
            TypeConverter valueTypeConverter)
        {
            int result;

            if (int.TryParse(formattedValue.ToString(), NumberStyles.HexNumber, null, out result))
            {
                //Hex number
                return base.ParseFormattedValue(
                    "0x" + formattedValue,
                    cellStyle,
                    formattedValueTypeConverter,
                    valueTypeConverter
                    );
            }

            return base.ParseFormattedValue(
                formattedValue,
                cellStyle,
                formattedValueTypeConverter,
                valueTypeConverter
                );
        }
예제 #6
0
        private static object DoConversion(object value, Type toType, CultureInfo culture)
        {
            if ((value is IConvertible) || (value == null))
            {
                try
                {
                    return(System.Convert.ChangeType(value, toType, culture));
                }
                catch (Exception)
                {
                    return(DependencyProperty.UnsetValue);
                }
            }
            else
            {
                System.ComponentModel.TypeConverter typeConverter = TypeDescriptor.GetConverter(value);

                if (typeConverter.CanConvertTo(toType))
                {
                    return(typeConverter.ConvertTo(null, culture, value, toType));
                }
            }

            return(DependencyProperty.UnsetValue);
        }
        public override bool Execute() {
            try {
                try {
                    codeDomProvider = CodeDomProvider.CreateProvider(Language);
                } catch (ConfigurationErrorsException) {
                    LogError(classNameLineNumber, 1, "CodeDom provider for language '" + Language + "' not found.");
                    return false;
                }

                typeAttributesConverter = codeDomProvider.GetConverter(typeof(TypeAttributes));

                if (!ParseInput()) {
                    return false;
                }

                if (lambdas.Count == 0) {
                    OutputFileName = null;
                    return true;
                }

                if (className == null) {
                    LogError(classNameLineNumber, 1501, "x:Class not found on root element.");
                    return false;
                }
                if (!className.Contains(".")) {
                    LogError(classNameLineNumber, 1502, "x:Class does not include namespace name.");
                    return false;
                }

                return GenerateOutput();
            } catch (Exception ex) {
                LogError(null, 0, 0, ex.Message);
                return false;
            }
        }
예제 #8
0
    protected override void OnMouseMove(System.Windows.Forms.MouseEventArgs e)
    {
        System.ComponentModel.TypeConverter converter =
            System.ComponentModel.TypeDescriptor.GetConverter(typeof(Point));
        base.OnMouseMove(e);

        if (TopCap)
        {
            Parent.Location = MousePosition - new Size(MouseP);
        }
        if (Sizable & Drag & SizeCap)
        {
            MouseP      = e.Location;
            Parent.Size = new Size(MouseP);
            Invalidate();
        }
        if (Sizable & new Rectangle(Width - 10, Height - 10, 10, 10).Contains(e.Location))
        {
            Cursor = Cursors.SizeNWSE;
        }
        else
        {
            Cursor = Cursors.Arrow;
        }
    }
        private static bool InnerConvertObjectToType(object obj, Type type, bool throwOnError,
                                                     out object convertedObject)
        {
            Type originalType = obj.GetType();
            OriginalTypeConverter converter = TypeDescriptor.GetConverter(type);

            if (converter.CanConvertFrom(originalType))
            {
                try
                {
                    convertedObject = converter.ConvertFrom(null, CultureInfo.InvariantCulture, obj);
                    return(true);
                }
                catch
                {
                    if (throwOnError)
                    {
                        throw;
                    }

                    convertedObject = null;
                    return(false);
                }
            }

            if (converter.CanConvertFrom(typeof(string)) && !(obj is DateTime))
            {
                try
                {
                    string text = TypeDescriptor.GetConverter(originalType).ConvertToInvariantString(obj);

                    convertedObject = converter.ConvertFromInvariantString(text);
                    return(true);
                }
                catch
                {
                    if (throwOnError)
                    {
                        throw;
                    }

                    convertedObject = null;
                    return(false);
                }
            }

            if (type.IsInstanceOfType(obj))
            {
                convertedObject = obj;
                return(true);
            }

            if (throwOnError)
            {
                throw new InvalidOperationException();
            }

            convertedObject = null;
            return(false);
        }
    // ========================================================================
    // Methods

    #region === Methods

    /// <summary>
    ///   Gets the formatted value of the cell's data.
    /// </summary>
    /// <returns>
    ///   The value.
    /// </returns>
    /// <param name = "value">The value to be formatted. </param>
    /// <param name = "rowIndex">The index of the cell's parent row. </param>
    /// <param name = "cellStyle">The <see cref = "T:System.Windows.Forms.DataGridViewCellStyle" /> in effect for the cell.</param>
    /// <param name = "valueTypeConverter">A <see cref = "T:System.ComponentModel.TypeConverter" /> associated with the value type that provides custom conversion to the formatted value type, or null if no such custom conversion is needed.</param>
    /// <param name = "formattedValueTypeConverter">A <see cref = "T:System.ComponentModel.TypeConverter" /> associated with the formatted value type that provides custom conversion from the value type, or null if no such custom conversion is needed.</param>
    /// <param name = "context">A bitwise combination of <see cref = "T:System.Windows.Forms.DataGridViewDataErrorContexts" /> values describing the context in which the formatted value is needed.</param>
    /// <exception cref = "T:System.Exception">Formatting failed and either there is no handler for the <see cref = "E:System.Windows.Forms.DataGridView.DataError" /> event of the <see cref = "T:System.Windows.Forms.DataGridView" /> control or the handler set the <see cref = "P:System.Windows.Forms.DataGridViewDataErrorEventArgs.ThrowException" /> property to true. The exception object can typically be cast to type <see cref = "T:System.FormatException" /> for type conversion errors or to type <see cref = "T:System.ArgumentException" /> if <paramref name = "value" /> cannot be found in the <see cref = "P:System.Windows.Forms.DataGridViewComboBoxCell.DataSource" /> or the <see cref = "P:System.Windows.Forms.DataGridViewComboBoxCell.Items" /> collection. </exception>
    protected override object GetFormattedValue(object value, int rowIndex, ref DataGridViewCellStyle cellStyle,
                                                TypeConverter valueTypeConverter,
                                                TypeConverter formattedValueTypeConverter,
                                                DataGridViewDataErrorContexts context)
    {
      return value;
    }
예제 #11
0
        public PropertyDescriptorCollection AddProperty(PropertyDescriptorCollection pdc, string propertyName, Type propertyType, TypeConverter converter,
            Attribute[] attributes)
        {
            List<PropertyDescriptor> properties = new List<PropertyDescriptor>(pdc.Count);

            for (int i = 0; i < pdc.Count; i++)
            {
                PropertyDescriptor pd = pdc[i];

                if (pd.Name != propertyName)
                {
                    properties.Add(pd);
                }
            }

            InstanceSavePropertyDescriptor ppd = new InstanceSavePropertyDescriptor(
                propertyName, propertyType, attributes);

            ppd.TypeConverter = converter;

            properties.Add(ppd);

            //PropertyDescriptor propertyDescriptor;

            return new PropertyDescriptorCollection(properties.ToArray());
        }
        /// <inheritdoc />
        public override bool TryConvert(object value, Type destinationType, out object result, ConversionArgs args)
        {
            System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(destinationType);
            if (converter.GetType() != typeof(System.ComponentModel.TypeConverter) && converter.CanConvertFrom(value.GetType()))
            {
                try {
                    result = converter.ConvertFrom(null, args.Culture, value);
                    return(true);
                }
                catch {
                }
            }

            converter = TypeDescriptor.GetConverter(value.GetType());
            if (converter.GetType() != typeof(System.ComponentModel.TypeConverter) && converter.CanConvertTo(destinationType))
            {
                try {
                    result = converter.ConvertTo(null, args.Culture, value, destinationType);
                    return(true);
                }
                catch {
                }
            }

            result = null;
            return(false);
        }
예제 #13
0
        protected override object GetFormattedValue(object value, int rowIndex, ref DataGridViewCellStyle cellStyle,
                                                    System.ComponentModel.TypeConverter valueTypeConverter, System.ComponentModel.TypeConverter formattedValueTypeConverter,
                                                    DataGridViewDataErrorContexts context)
        {
            string strValue = String.Empty;

            if (value != null && value.ToString() != String.Empty)
            {
                string[]   ids        = value.ToString().Split('.');
                DataEntity dataEntity = ServiceUnity.DataEntityComponentService.GetDataEntity(ids[0]);
                if (dataEntity != null)
                {
                    strValue = dataEntity.Name;
                    if (ids.Length == 2)
                    {
                        DataItemEntity item = dataEntity.Items.GetEntityById(ids[1]);
                        if (item != null)
                        {
                            strValue += "." + item.Name;
                        }
                        else
                        {
                            strValue = String.Empty;
                        }
                    }
                }
            }
            else
            {
                strValue = String.Empty;
            }
            return(base.GetFormattedValue(strValue, rowIndex, ref cellStyle, valueTypeConverter, formattedValueTypeConverter, context));
        }
 protected override object GetFormattedValue(object value, int rowIndex, ref DataGridViewCellStyle cellStyle, TypeConverter valueTypeConverter, TypeConverter formattedValueTypeConverter, DataGridViewDataErrorContexts context)
 {
     isVisualStyled = VisualStyleInformation.IsEnabledByUser & VisualStyleInformation.IsSupportedByOS;
     if (value == null)
     {
         return emptyImage;
     }
     float percentage = (float)((int)value);
     if (percentage == 0)
         return emptyImage;
     else
     {
         contentGraphics.Clear(Color.Transparent);
         float drawedPercentage = percentage > 100 ? 100 : percentage;
         if (isVisualStyled)
         {
             bigProgressRect.Width = (int)(66 * drawedPercentage / 100.0f);
             ProgressBarRenderer.DrawHorizontalBar(contentGraphics, bigBorderRect);
             ProgressBarRenderer.DrawHorizontalChunks(contentGraphics, bigProgressRect);
         }
         else
         {
             progressRect.Width = (int)(66 * drawedPercentage / 100.0f);
             contentGraphics.DrawRectangle(blackPen, borderRect);
             contentGraphics.FillRectangle(lightGreenBrush, progressRect);
         }
         contentGraphics.DrawString(percentage.ToString("0.00") + "%", this.DataGridView.Font, foreColor, 10, 5);
     }
     return contentImage;
 }
예제 #15
0
 private object GetValue(DateTime dateTime, Type type, TypeConverter converter)
 {
     if (type.IsAssignableFrom(typeof(DateTime)))
         return dateTime;
     else
         return converter.ConvertFrom(dateTime);
 }
        public RightHandSideExpressionVisitor(Type compareType)
        {
            _compareType = compareType;
            _toConverter = TypeDescriptor.GetConverter(_compareType);

            _value = () => { throw new InvalidOperationException("No match was found"); };
        }
        public LocalizedPropertyDescriptor(PropertyDescriptor basePropertyDescriptor)
            : base(basePropertyDescriptor)
        {
            LocalizedPropertyAttribute localizedPropertyAttribute = null;

            foreach (Attribute attr in basePropertyDescriptor.Attributes) {
                localizedPropertyAttribute = attr as LocalizedPropertyAttribute;
                if (localizedPropertyAttribute != null) {
                    break;
                }
            }

            if (localizedPropertyAttribute != null) {
                localizedName        = localizedPropertyAttribute.Name;
                localizedDescription = localizedPropertyAttribute.Description;
                localizedCategory    = localizedPropertyAttribute.Category;
            } else {
                localizedName        = basePropertyDescriptor.Name;
                localizedDescription = basePropertyDescriptor.Description;
                localizedCategory    = basePropertyDescriptor.Category;
            }

            this.basePropertyDescriptor = basePropertyDescriptor;

            // "Booleans" get a localized type converter
            if (basePropertyDescriptor.PropertyType == typeof(System.Boolean)) {
                customTypeConverter = new BooleanTypeConverter();
            }
        }
예제 #18
0
		public ConfigurationProperty (
					string name, Type type, object default_value,
					TypeConverter converter,
					ConfigurationValidatorBase validation,
					ConfigurationPropertyOptions flags)
			: this (name, type, default_value, converter, validation, flags, null)
		{ }
        protected override object GetFormattedValue(object value,
           int rowIndex, ref DataGridViewCellStyle cellStyle,
           TypeConverter valueTypeConverter,
           TypeConverter formattedValueTypeConverter,
           DataGridViewDataErrorContexts context)
        {
            object returnVal = String.Empty;

            if (value != null)
            {
                if (value.GetType() == typeof(byte[]))
                    returnVal = BitConverter.ToString((byte[])value);
                else if (value.GetType() == typeof(byte))
                    returnVal = BitConverter.ToString(new byte[] { (byte)value });
                else if (value.GetType() == typeof(int))
                    returnVal = BitConverter.ToString(BitConverter.GetBytes(((int)value)),0);
                else if (value.GetType() == typeof(uint))
                    returnVal = BitConverter.ToString(BitConverter.GetBytes(((uint)value)), 0);
                else if (value.GetType() == typeof(short))
                    returnVal = BitConverter.ToString(BitConverter.GetBytes(((short)value)), 0);
                else if (value.GetType() == typeof(ushort))
                    returnVal = BitConverter.ToString(BitConverter.GetBytes(((ushort)value)), 0);
            }
            return returnVal;
        }
예제 #20
0
파일: MyForm.cs 프로젝트: gvhung/dp2
        /*
         * static void ReLayout(Control parent_control)
         * {
         *  foreach (Control control in parent_control.Controls)
         *  {
         *      ReLayout(control);
         *
         *      control.ResumeLayout(false);
         *      control.PerformLayout();
         *  }
         *
         *  parent_control.ResumeLayout(false);
         * }*/

        /// <summary>
        /// 保存字体设置信息到配置参数存储
        /// </summary>
        public void SaveFontSetting()
        {
            if (this.MainForm != null && this.MainForm.AppInfo != null)
            {
                {
                    // Create the FontConverter.
                    System.ComponentModel.TypeConverter converter =
                        System.ComponentModel.TypeDescriptor.GetConverter(typeof(Font));

                    string strFontString = converter.ConvertToString(this.Font);

                    this.MainForm.AppInfo.SetString(
                        this.FormName,
                        "default_font",
                        strFontString);
                }

                {
                    // Create the ColorConverter.
                    System.ComponentModel.TypeConverter converter =
                        System.ComponentModel.TypeDescriptor.GetConverter(typeof(Color));

                    string strFontColor = converter.ConvertToString(this.ForeColor);

                    MainForm.AppInfo.SetString(
                        this.FormName,
                        "default_font_color",
                        strFontColor);
                }
            }
        }
예제 #21
0
		public void SetUp ()
		{
			Assembly a = typeof (LogConverter).Assembly;
			Type type = a.GetType ("System.Diagnostics.Design.StringValueConverter");
			Assert.IsNotNull (type);
			converter = (TypeConverter) Activator.CreateInstance (type);
		}
예제 #22
0
 private DateTime GetDateTime(object value, TypeConverter converter)
 {
     if (typeof(DateTime).IsAssignableFrom(value.GetType()))
         return (DateTime) value;
     else
         return (DateTime) converter.ConvertTo(value, typeof(DateTime));
 }
예제 #23
0
        public bool IsForType(TypeConverter converter) {
            Contract.Requires<ArgumentNullException>(converter != null);

            Type currentConverterType = this.typeConverter.GetType();
            Type paramConverterType = converter.GetType();
            return paramConverterType.IsAssignableFrom(currentConverterType);
        }
예제 #24
0
        public HotkeyEditControl()
        {
            InitializeComponent();
            InitializeDropdown();

            converter = TypeDescriptor.GetConverter(typeof(Keys));
        }
예제 #25
0
        /// <summary>
        /// 转换简单类型
        /// </summary>
        /// <param name="value"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        private static object ConvertObj(object value, Type type)
        {
            object returnValue;

            if ((value == null) || type.IsInstanceOfType(value))
            {
                return(value);
            }
            string str = value as string;

            if ((str != null) && (str.Length == 0))
            {
                return(null);
            }
            System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type);
            bool flag = converter.CanConvertFrom(value.GetType());

            if (!flag)
            {
                converter = TypeDescriptor.GetConverter(value.GetType());
            }
            if (!flag && !converter.CanConvertTo(type))
            {
                throw new InvalidOperationException("无法转换成类型:" + value.ToString() + "==>" + type);
            }
            try
            {
                returnValue = flag ? converter.ConvertFrom(null, null, value) : converter.ConvertTo(null, null, value, type);
            }
            catch (Exception e)
            {
                throw new InvalidOperationException("类型转换出错:" + value.ToString() + "==>" + type, e);
            }
            return(returnValue);
        }
예제 #26
0
		public void TestFixtureSetUp()
		{
			if (_dummyCulture == null)
				throw new Exception("Error setting up test - dummyCulture should not be NULL");
			if (CultureInfo.InvariantCulture.Equals(_dummyCulture))
				throw new Exception("Error setting up test - dummyCulture should not be invariant");
			if (_dummyCulture2 == null)
				throw new Exception("Error setting up test - dummyCulture2 should not be NULL");
			if (CultureInfo.InvariantCulture.Equals(_dummyCulture2))
				throw new Exception("Error setting up test - dummyCulture2 should not be invariant");
			if (_dummyCulture2.Equals(_dummyCulture))
				throw new Exception("Error setting up test - dummyCulture2 should not be the same as dummyCulture");

			// for testing purposes, set up the converter for a specific culture to have the Enum.ToString() mapping
			// normally, you would use TypeDescriptor.GetConverter, but we want to keep the test appdomain clean of these testing mods
			XKeysConverter converter = new XKeysConverter(_dummyCulture);
			IDictionary<XKeys, string> relocalizedKeyNames = new Dictionary<XKeys, string>();
			foreach (KeyValuePair<XKeys, string> pair in converter.LocalizedKeyNames)
				relocalizedKeyNames.Add(pair.Key, Enum.GetName(typeof (XKeys), pair.Key));
			relocalizedKeyNames[XKeys.Control] = "Control"; // Enum.ToString() treats this as Control+None
			relocalizedKeyNames[XKeys.Shift] = "Shift"; // Enum.ToString() treats this as Shift+None
			relocalizedKeyNames[XKeys.Alt] = "Alt"; // Enum.ToString() treats this as Alt+None
			relocalizedKeyNames[XKeys.OemPlus] = XKeysConverter.KeySeparator.ToString(); // for special case test
			converter.LocalizedKeyNames = relocalizedKeyNames;

			_converter = converter;
		}
		public OptionConfigurationPropertyAttribute(string name, Type type, object defaultValue, OptionConfigurationPropertyBehavior behavior, TypeConverter converter)
		{
			_name = name == null ? string.Empty : name.Trim();
			_type = type;
			_defaultValue = defaultValue;
			_behavior = behavior;
			_converter = converter;
		}
 public ConfigurationProperty(String name,
                              Type type,
                              Object defaultValue,
                              TypeConverter typeConverter,
                              ConfigurationValidatorBase validator,
                              ConfigurationPropertyOptions options)
     : this(name, type, defaultValue, typeConverter, validator, options, null) {
 }
예제 #29
0
 private static string GetTypeConverterId(System.ComponentModel.TypeConverter typeConverter)
 {
     if (typeConverter == null)
     {
         return(string.Empty);
     }
     return(typeConverter.GetType().FullName);
 }
예제 #30
0
 protected DefaultValueConverter(TypeConverter typeConverter, Type sourceType, Type targetType, bool shouldConvertFrom, bool shouldConvertTo)
 {
     this.typeConverter = typeConverter;
     this.sourceType = sourceType;
     this.targetType = targetType;
     this.shouldConvertFrom = shouldConvertFrom;
     this.shouldConvertTo = shouldConvertTo;
 }
 protected override void FillAttributes(IList attributeList)
 {
     this.converter = null;
     this.editors = null;
     this.editorTypes = null;
     this.editorCount = 0;
     base.FillAttributes(attributeList);
 }
예제 #32
0
 protected override object GetFormattedValue(object value, int rowIndex, ref System.Windows.Forms.DataGridViewCellStyle cellStyle, TypeConverter valueTypeConverter, TypeConverter formattedValueTypeConverter, System.Windows.Forms.DataGridViewDataErrorContexts context)
 {
     if (value != null)
     {
         return TypeDescriptor.GetConverter(value).ConvertToString(value);
     }
     return "";
 }
예제 #33
0
		/// <summary>
		/// 
		/// </summary>
		/// <param name="name"></param>
		/// <param name="pi"></param>
		/// <param name="obj"></param>
		public ConfigVariable ( string prefix, string name, PropertyInfo pi, object obj )
		{
			Prefix		=	prefix;
			Name		=	name;
			Property	=	pi;
			Object		=	obj;
			converter	=	TypeDescriptor.GetConverter( Property.PropertyType );
		}
예제 #34
0
        public StringConvertibleType(TypeConverter converter, Type sourceType)
        {
            if (converter == null) throw new ArgumentNullException(nameof(converter));
            if (sourceType == null) throw new ArgumentNullException(nameof(sourceType));

            this.converter = converter;
            this.sourceType = sourceType;
        }
예제 #35
0
 /// <summary>
 /// Initializes a new instance of the <see cref="NameableConverter"/> class.
 /// </summary>
 /// <param name="type">The type.</param>
 /// <exception cref="System.ArgumentException">NameableConverterBadCtorArg;type</exception>
 public NameableConverter(Type type)
 {
     _nameableType = type;
     _simpleType = Nullable.GetUnderlyingType(type);
     if (_simpleType == null)
         throw new ArgumentException("NameableConverterBadCtorArg", "type");
     _simpleTypeConverter = TypeDescriptor.GetConverter(_simpleType);
 }
 public ShortcutKeysUI(ShortcutKeysEditor editor)
 {
     this.editor = editor;
     this.keysConverter = null;
     this.End();
     this.InitializeComponent();
     this.AdjustSize();
 }
        protected override object GetFormattedValue(object value,
            int rowIndex, ref DataGridViewCellStyle cellStyle,
            TypeConverter valueTypeConverter,
            TypeConverter formattedValueTypeConverter,
            DataGridViewDataErrorContexts context)
        {
            if (value == null)
                value = 0;

            int progressVal = (int)value;

            if (progressVal > maxVal)
                progressVal = maxVal;
            if (progressVal < minVal)
                progressVal = minVal;

            Bitmap bmp = new Bitmap(OwningColumn.Width - margin, OwningRow.Height - margin);
            Bitmap bmptxt = new Bitmap(OwningColumn.Width, OwningRow.Height);

            pb.Height = bmp.Height;
            pb.Width = bmp.Width;

            pb.BackColor = System.Drawing.Color.Transparent;
            pb.BackgroundColor = System.Drawing.Color.FromArgb(((System.Byte)(100)), ((System.Byte)(201)), ((System.Byte)(201)), ((System.Byte)(201)));
            pb.StartColor = this.startColor;
            pb.EndColor = this.endColor;
            //pb.HighlightColor = System.Drawing.Color.Orange;
            pb.TabIndex = 0;

            pb.Value = progressVal;
            pb.Update();
            pb.Invalidate();

            lbl.AutoSize = false;
            lbl.TextAlign = ContentAlignment.MiddleCenter;
            lbl.Height = bmptxt.Height;
            lbl.Width = bmptxt.Width;

            if (!this.Selected)
            {
                lbl.ForeColor = cellStyle.ForeColor;
                lbl.BackColor = cellStyle.BackColor;
            }
            else
            {
                lbl.ForeColor = cellStyle.SelectionForeColor;
                lbl.BackColor = cellStyle.SelectionBackColor;
            }

            pb.DrawToBitmap(bmp, pb.ClientRectangle);

            lbl.Text = String.Format("{0}%", progressVal);
            lbl.Image = bmp;
            lbl.ImageAlign = ContentAlignment.MiddleCenter;
            lbl.DrawToBitmap(bmptxt, lbl.ClientRectangle);

            return bmptxt;
        }
예제 #38
0
        public TypeConverterWrapper(TypeConverter converter, Type resultType, Action<object, object> objectGenerator = null) {
            this.typeConverter = converter;
            this.objectGenerator = objectGenerator;

            MethodInfo method = typeof(Enumerable).GetMethod("OfType");
            MethodInfo generic = method.MakeGenericMethod(new Type[] { resultType });

            ConvertEnumerable = o => generic.Invoke(null, new[] { o });
        }
예제 #39
0
        public SimpleTypeModelBinder(Type type)
        {
            if (type == null)
            {
                throw new ArgumentNullException(nameof(type));
            }

            _typeConverter = TypeDescriptor.GetConverter(type);
        }
예제 #40
0
        /// <summary>
        ///构造函数
        /// </summary>
        /// <exception cref="InvalidOperationException">类型不存在类型转换器 " + typeof(T).FullName</exception>
        public GenericListTypeConverter()
        {
            typeConverter = SysComponentModel.TypeDescriptor.GetConverter(typeof(T));

            if (typeConverter == null)
            {
                throw new InvalidOperationException("类型不存在类型转换器 " + typeof(T).FullName);
            }
        }
예제 #41
0
        void radListControl1_VisualItemFormatting(object sender, Telerik.WinControls.UI.VisualItemFormattingEventArgs args)
        {
            RadListVisualItem item = args.VisualItem;
            int rowIndex           = item.Data.RowIndex;

            System.ComponentModel.TypeConverter typeConverter = TypeDescriptor.GetConverter(typeof(Color));
            item.DrawFill      = true;
            item.BackColor     = (Color)typeConverter.ConvertFromString(null, CultureInfo.InvariantCulture, bgColors[rowIndex % 7]);
            item.GradientStyle = Telerik.WinControls.GradientStyles.Solid;
        }
예제 #42
0
    void TypeConverters()
    {
        System.ComponentModel.TypeConverter testConverter
            = System.ComponentModel.TypeDescriptor.GetConverter(typeof(System.Drawing.Color));

        System.Drawing.Color result = (System.Drawing.Color)testConverter.ConvertFrom("cyan");
        var alt = System.Drawing.Color.FromName("cyan");

        Console.WriteLine(result);
        Console.WriteLine(alt == result);
    }
예제 #43
0
        /// <summary>
        ///     Gets the localized description for given value and specified CultureInfo.
        /// </summary>
        /// <param name="enumValue">The given value.</param>
        /// <param name="ci">The CultureInfo.</param>
        /// <returns>The localized value.</returns>
        public static string GetLocalizedDescription(this Enum enumValue, CultureInfo ci)
        {
            if (enumValue != null)
            {
                System.ComponentModel.TypeConverter tc = TypeDescriptor.GetConverter(enumValue.GetType());
                return(tc != null
                           ? tc.ConvertToString(null, ci, enumValue)
                           : enumValue.ToString());
            }

            return(string.Empty);
        }
예제 #44
0
        protected override void OnLoadingValueType()
        {
            base.OnLoadingValueType();

            if (ValueType != null)
            {
                TypeConverter = System.ComponentModel.TypeDescriptor.GetConverter(ValueType);
            }
            else
            {
                TypeConverter = null;
            }
        }
예제 #45
0
 public static System.Drawing.Font StringToFont(string fontString)
 {
     try
     {
         System.ComponentModel.TypeConverter converter =
             System.ComponentModel.TypeDescriptor.GetConverter(typeof(System.Drawing.Font));
         return((System.Drawing.Font)converter.ConvertFromString(fontString));
     }
     catch
     {
         return(null);
     }
 }
예제 #46
0
 /// <summary>
 /// 构造函数
 /// </summary>
 /// <exception cref="InvalidOperationException">
 /// 类型不存在类型转换器" + typeof(K).FullName
 /// or
 /// 类型不存在类型转换器" + typeof(V).FullName
 /// </exception>
 public GenericDictionaryTypeConverter()
 {
     typeConverterKey = TypeDescriptor.GetConverter(typeof(K));
     if (typeConverterKey == null)
     {
         throw new InvalidOperationException("类型不存在类型转换器" + typeof(K).FullName);
     }
     typeConverterValue = TypeDescriptor.GetConverter(typeof(V));
     if (typeConverterValue == null)
     {
         throw new InvalidOperationException("类型不存在类型转换器" + typeof(V).FullName);
     }
 }
예제 #47
0
    //</snippet1>

    // The following code example demonstrates how to use the
    // ColorConverter.ConvertToString method. This example
    // is designed to be used with Windows Forms. Paste this code
    // into a form and call the ShowColorConverter method when
    // handling the form's Paint event, passing e as PaintEventArgs.
    //<snippet2>

    private void ShowColorConverter(PaintEventArgs e)
    {
        Color myColor = Color.PaleVioletRed;

        // Create the ColorConverter.
        System.ComponentModel.TypeConverter converter =
            System.ComponentModel.TypeDescriptor.GetConverter(myColor);

        string colorAsString = converter.ConvertToString(Color.PaleVioletRed);

        e.Graphics.DrawString(colorAsString, this.Font,
                              Brushes.PaleVioletRed, 50.0F, 50.0F);
    }
예제 #48
0
    //</snippet2>

    // The following code example demonstrates how to use the
    // ConvertToInvariantString and ConvertToString methods.
    // This example is designed to be used with Windows Forms.
    // Paste this code into a form and call the ShowFontStringConversion
    // method when handling the form's Paint event, passing e
    // as PaintEventArgs.
    //<snippet3>
    private void ShowFontStringConversion(PaintEventArgs e)
    {
        // Create the FontConverter.
        System.ComponentModel.TypeConverter converter =
            System.ComponentModel.TypeDescriptor.GetConverter(typeof(Font));

        Font font1 = (Font)converter.ConvertFromString("Arial, 12pt");

        string fontName1 = converter.ConvertToInvariantString(font1);
        string fontName2 = converter.ConvertToString(font1);

        e.Graphics.DrawString(fontName1, font1, Brushes.Red, 10, 10);
        e.Graphics.DrawString(fontName2, font1, Brushes.Blue, 10, 30);
    }
예제 #49
0
    // The following code example demonstrates how to use the
    // PointConverter.ConvertFromString and the Point.op_Subtraction
    // methods. This example is designed to be used with Windows
    // Forms. Paste this code into a form and call the
    // ShowPointConverter method when handling the form's Paint
    // event, passing e as PaintEventArgs.
    //<snippet1>
    private void ShowPointConverter(PaintEventArgs e)
    {
        // Create the PointConverter.
        System.ComponentModel.TypeConverter converter =
            System.ComponentModel.TypeDescriptor.GetConverter(typeof(Point));

        Point point1 = (Point)converter.ConvertFromString("200, 200");

        // Use the subtraction operator to get a second point.
        Point point2 = point1 - new Size(190, 190);

        // Draw a line between the two points.
        e.Graphics.DrawLine(Pens.Black, point1, point2);
    }
예제 #50
0
        public void test1()
        {
            Rectangle rect = new Rectangle(10, 12, 14, 16);

            // Wrong
            System.ComponentModel.TypeConverter baseConverter = new System.ComponentModel.TypeConverter();
            string sample1 = baseConverter.ConvertToString(rect);

            // Right
            System.ComponentModel.TypeConverter rectSpecificConverter = TypeDescriptor.GetConverter(rect);
            string sample2 = rectSpecificConverter.ConvertToString(rect);

            log.DebugFormat("From new TypeConverter() {0}\r\n", sample1);
            log.DebugFormat("From TypeDescriptor.GetConverter() {0}\r\n", sample2);
            log.DebugFormat("From rect.ToString() {0}\r\n", rect.ToString());
        }
예제 #51
0
파일: MyForm.cs 프로젝트: gvhung/dp2
        /// <summary>
        /// 从配置参数存储中装载字体设置信息
        /// </summary>
        public void LoadFontSetting()
        {
            if (this.MainForm == null)
            {
                return;
            }

            if (this.MainForm != null && this.MainForm.AppInfo != null)
            {
                string strFontString = MainForm.AppInfo.GetString(
                    this.FormName,
                    "default_font",
                    "");  // "Arial Unicode MS, 12pt"

                if (String.IsNullOrEmpty(strFontString) == false)
                {
                    // Create the FontConverter.
                    System.ComponentModel.TypeConverter converter =
                        System.ComponentModel.TypeDescriptor.GetConverter(typeof(Font));

                    this.Font = (Font)converter.ConvertFromString(strFontString);
                }
                else
                {
                    // 沿用系统的缺省字体
                    if (this.MainForm != null)
                    {
                        MainForm.SetControlFont(this, this.MainForm.DefaultFont);
                    }
                }

                string strFontColor = MainForm.AppInfo.GetString(
                    this.FormName,
                    "default_font_color",
                    "");

                if (String.IsNullOrEmpty(strFontColor) == false)
                {
                    // Create the ColorConverter.
                    System.ComponentModel.TypeConverter converter =
                        System.ComponentModel.TypeDescriptor.GetConverter(typeof(Color));

                    this.ForeColor = (Color)converter.ConvertFromString(strFontColor);
                }
                this.PerformLayout();
            }
        }
예제 #52
0
        //-------------------------------------------------------------------------------------------------
        public static object ConvertType(string value, Type type)
        {
            if (type.IsEnum)
            {
                return(Enum.Parse(type, value));
            }

            System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type);
            if (converter != null && converter.CanConvertFrom(value.GetType()))
            {
                return(converter.ConvertFrom(value));
            }
            else
            {
                return(Convert.ChangeType(value, type));
            }
        }
예제 #53
0
        public static T ConvertType <T>(string value)
        {
            if (typeof(T).IsEnum)
            {
                return((T)Enum.Parse(typeof(T), value));
            }

            System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(typeof(T));
            if (converter != null && converter.CanConvertFrom(value.GetType()))
            {
                return((T)converter.ConvertFrom(value));
            }
            else
            {
                return((T)Convert.ChangeType(value, typeof(T)));
            }
        }
예제 #54
0
 // this and next method taken from
 // http://stackoverflow.com/questions/1940127/how-to-xmlserialize-system-drawing-font-class
 public static string FontToString(System.Drawing.Font font)
 {
     if (font == null)
     {
         return(null);
     }
     try
     {
         System.ComponentModel.TypeConverter converter =
             System.ComponentModel.TypeDescriptor.GetConverter(typeof(System.Drawing.Font));
         return(converter.ConvertToString(font));
     }
     catch
     {
         return(null);
     }
 }
예제 #55
0
            private static void Label_set(Label l, Color c, int x, int y, int w, int h)
            {
                System.ComponentModel.TypeConverter converter =
                    System.ComponentModel.TypeDescriptor.GetConverter(typeof(Font));
                Font f = (Font)converter.ConvertFromString("Cambria, 18pt, style=Bold, Italic");

                l.Font      = f;
                l.BackColor = Color.Black;
                l.Visible   = false;

                l.ForeColor = c;
                l.Top       = x;
                l.Left      = y;

                l.Width  = w;
                l.Height = h;
            }
예제 #56
0
        private static object ConvertSimpleType(CultureInfo culture, object value, Type destinationType)
        {
            if (value == null || destinationType.IsInstanceOfType(value))
            {
                return(value);
            }

            // if this is a user-input value but the user didn't type anything, return no value
            string valueAsString = value as string;

            if (valueAsString != null && valueAsString.Trim().Length == 0)
            {
                return(null);
            }

            //modified by Yang Li
            //TypeConverter converter = TypeDescriptor.GetConverter(destinationType);
            System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(destinationType);
            bool canConvertFrom = converter.CanConvertFrom(value.GetType());

            if (!canConvertFrom)
            {
                converter = TypeDescriptor.GetConverter(value.GetType());
            }
            if (!(canConvertFrom || converter.CanConvertTo(destinationType)))
            {
                string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ValueProviderResult_NoConverterExists,
                                               value.GetType().FullName, destinationType.FullName);
                throw new InvalidOperationException(message);
            }

            try
            {
                object convertedValue = (canConvertFrom) ?
                                        converter.ConvertFrom(null /* context */, culture, value) :
                                        converter.ConvertTo(null /* context */, culture, value, destinationType);
                return(convertedValue);
            }
            catch (Exception ex)
            {
                string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ValueProviderResult_ConversionThrew,
                                               value.GetType().FullName, destinationType.FullName);
                throw new InvalidOperationException(message, ex);
            }
        }
예제 #57
0
        protected override object GetFormattedValue(object value, int rowIndex, ref DataGridViewCellStyle cellStyle,
                                                    System.ComponentModel.TypeConverter valueTypeConverter, System.ComponentModel.TypeConverter formattedValueTypeConverter,
                                                    DataGridViewDataErrorContexts context)
        {
            string strValue = String.Empty;

            if (value != null)
            {
                if ((bool)value)
                {
                    strValue = CommonLanguage.Current.BooleanTrue;
                }
                else
                {
                    strValue = CommonLanguage.Current.BooleanFalse;
                }
            }
            return(base.GetFormattedValue(strValue, rowIndex, ref cellStyle, valueTypeConverter, formattedValueTypeConverter, context));
        }
예제 #58
0
        protected void OnMouseMove(object sender, MouseEventArgs e)
        {
            Point x = e.GetPosition(this);

            Matrix transform = Transform;

            foreach (Circuit.Terminal i in Symbol.Terminals)
            {
                Circuit.Coord tx = layout.MapTerminal(i);
                Point         tp = new Point(tx.x, tx.y);
                tp = transform.Transform(tp);
                if ((tp - x).Length < 5.0)
                {
                    ToolTip = "Terminal '" + i.ToString() + "'";
                    return;
                }
            }

            TextBlock text = new TextBlock();

            Circuit.Component component = Symbol.Component;

            text.Inlines.Add(new Bold(new Run(component.ToString())));

            foreach (PropertyInfo i in component.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public).Where(j =>
                                                                                                                            j.CustomAttribute <Circuit.Serialize>() != null &&
                                                                                                                            (j.CustomAttribute <BrowsableAttribute>() == null || j.CustomAttribute <BrowsableAttribute>().Browsable)))
            {
                object value = i.GetValue(component, null);
                DefaultValueAttribute def = i.CustomAttribute <DefaultValueAttribute>();
                if (def == null || !Equals(def.Value, value))
                {
                    System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(i.PropertyType);
                    text.Inlines.Add(new Run("\n" + i.Name + " = "));
                    text.Inlines.Add(new Bold(new Run(tc.ConvertToString(value))));
                }
            }

            ToolTip = new ToolTip()
            {
                Content = text
            };
        }
예제 #59
0
 private static void setPropertyValue(PropertyInfo pi, Type propertyType, object oObj, string value)
 {
     if (propertyType == typeof(string))
     {
         pi.SetValue(oObj, value, null);
         return;
     }
     object[] attributes = propertyType.GetCustomAttributes(typeof(System.ComponentModel.TypeConverterAttribute), false);
     foreach (System.ComponentModel.TypeConverterAttribute converterAttribute in attributes)
     {
         System.ComponentModel.TypeConverter converter = (System.ComponentModel.TypeConverter)Activator.CreateInstance(Type.GetType(converterAttribute.ConverterTypeName));
         if (converter.CanConvertFrom(value.GetType()))
         {
             // good - use the converter to restore the value
             pi.SetValue(oObj, converter.ConvertFromString(value), null);
             break;
         }
     }
 }
예제 #60
0
        protected override Resources.PDFImageXObject InitImageXObject(PDFContextBase context, Style style)
        {
            Document doc = this.Document;

            if (null == doc)
            {
                throw new NullReferenceException(Errors.ParentDocumentCannotBeNull);
            }

            if (null != this.Data)
            {
                _xobj = null;
                if (!string.IsNullOrEmpty(this.ImageKey))
                {
                    _xobj = this.Document.GetImageResource(this.ImageKey, this, false);
                }

                if (null == _xobj)
                {
                    string name;
                    if (string.IsNullOrEmpty(this.ImageKey))
                    {
                        name = "DataImage_" + this.Document.GetIncrementID(PDFObjectTypes.ImageXObject);
                    }
                    else
                    {
                        name = this.ImageKey;
                    }

                    System.ComponentModel.TypeConverter BitmapConverter = TypeDescriptor.GetConverter(typeof(Bitmap));
                    Bitmap img = (Bitmap)BitmapConverter.ConvertFrom(this.Data.Raw);


                    PDFImageData data = PDFImageData.LoadImageFromBitmap(name, img, this.Compress);

                    _xobj = PDFImageXObject.Load(data, name);
                    this.Document.SharedResources.Add(_xobj);
                }
            }

            return(_xobj);
        }