/// <summary>
 /// Determines whether the specified object can be converted into a <see cref="String"/>.
 /// </summary>
 /// <param name="value">The object to evaluate for conversion.</param>
 /// <param name="context">Context information that is used for conversion.</param>
 /// <returns>
 /// <see langword="true"/> if the <paramref name="value"/> can be converted into a 
 /// <see cref="String"/>; otherwise, <see langword="false"/>.
 /// </returns>
 public override bool CanConvertToString(object value, IValueSerializerContext context)
 {
     var gesture = value as MultiKeyGesture;
     return gesture != null
            && ModifierKeysConverter.IsDefinedModifierKeys(gesture.Modifiers)
            && MultiKeyGestureConverter.IsDefinedKey(gesture.Key);
 }

		public XamlObjectNodeIterator (object root, XamlSchemaContext schemaContext, IValueSerializerContext vctx, XamlObjectReaderSettings settings)
		{
			ctx = schemaContext;
			this.root = root;
			value_serializer_ctx = vctx;
			this.settings = settings;
		}

 /// <summary>
 /// Returns true if the given transform can be converted into a string
 /// </summary>
 public override bool CanConvertToString(object value, IValueSerializerContext context)
 {
     ImageSource imageSource = value as ImageSource;
     #pragma warning disable 6506
     return imageSource != null && imageSource.CanSerializeToString();
     #pragma warning restore 6506
 }

 /// <summary>
 /// Converts a font family to a string.
 /// </summary>
 public override string ConvertToString(object value, IValueSerializerContext context)
 {
     FontFamily fontFamily = value as FontFamily;
     if (fontFamily == null || fontFamily.Source == null)
         throw GetConvertToException(value, typeof(string));
     return fontFamily.Source;
 }

		public override bool CanConvertToString (object value, IValueSerializerContext context)
		{
			if (!(value is DateTime))
				throw new ArgumentException ("Can only convert objects of type 'DateTime'");

			return true;
		}

 /// <summary>
 /// CanConvertToString()
 /// </summary>
 /// <param name="value"></param>
 /// <param name="context"></param>
 /// <returns></returns>
 /// <ExternalAPI/> 
 public override bool CanConvertToString(object value, IValueSerializerContext context) 
 {
     if (!(value is Key))
         return false;
     Key key = (Key)value;
     return ((int)key >= (int)Key.None && (int)key <= (int)Key.OemClear);
 }

 /// <summary>
 /// ConvertToString()
 /// </summary>
 /// <param name="value"></param>
 /// <param name="context"></param>
 /// <returns></returns>
 public override string ConvertToString(object value, IValueSerializerContext context) 
 {
     TypeConverter converter = TypeDescriptor.GetConverter(typeof(Key));
     if (converter != null)
         return converter.ConvertToInvariantString(value);
     else
         return base.ConvertToString(value, context);
 }

		public override object ConvertFromString (string value, IValueSerializerContext context)
		{
			if (value == null)
				throw new NotSupportedException ();
			if (value.Length == 0)
				return DateTime.MinValue;
			return DateTime.Parse (value, CultureInfo.InvariantCulture, styles);
		}

        /// <summary>
        /// Converts a <see cref="String"/> to an instance of the type that the implementation of
        /// <see cref="ValueSerializer"/> supports.
        /// </summary>
        /// <param name="value">The string to convert.</param>
        /// <param name="context">Context information that is used for conversion.</param>
        /// <returns>
        /// A new instance of the type that the implementation of <see cref="ValueSerializer"/>
        /// supports based on the supplied <paramref name="value"/>.
        /// </returns>
        /// <exception cref="NotSupportedException">
        /// <paramref name="value"/> cannot be converted.
        /// </exception>
        public override object ConvertFromString(string value, IValueSerializerContext context)
        {
            var converter = TypeDescriptor.GetConverter(typeof(KeyGesture));
            if (converter != null)
                return converter.ConvertFromString(value);

            return base.ConvertFromString(value, context);
        }

 public override bool CanConvertToString(object value, IValueSerializerContext context)
 {
     if (AttachablePropertyServices.GetAttachedPropertyCount(value) > 0)
     {
         return false;
     }
     return (((value != null) && (value is IValueSerializableExpression)) && ((IValueSerializableExpression) value).CanConvertToString(context));
 }

 /// <summary>
 /// Creates a FontFamily from a string
 /// </summary>
 public override object ConvertFromString(string value, IValueSerializerContext context)
 {
     if (string.IsNullOrEmpty(value))
     {
         throw GetConvertFromException(value);
     }
     return new FontFamily(value);
 }

 /// <summary>
 /// ConvertFromString()
 /// </summary>
 /// <param name="value"></param>
 /// <param name="context"></param>
 /// <returns></returns>
 public override object ConvertFromString(string value, IValueSerializerContext context) 
 {
     TypeConverter converter = TypeDescriptor.GetConverter(typeof(MouseAction));
     if (converter != null)
         return converter.ConvertFromString(value);
     else
         return base.ConvertFromString(value, context);
 }

 internal static string ConvertToStringWrapper(object value, IValueSerializerContext context)
 {
     if (valueSerializer == null)
     {
         valueSerializer = new ActivityWithResultValueSerializer();
     }
     return valueSerializer.ConvertToString(value, context);
 }

		public override object ConvertFromString(string value, IValueSerializerContext context)
		{
			if (value != null)
			{
				return DataRect.Parse(value);
			}
			return base.ConvertFromString(value, context);
		}

 /// <summary>
 /// Converts a transform into a string.
 /// </summary>
 public override string ConvertToString(object value, IValueSerializerContext context)
 {
     ImageSource imageSource = value as ImageSource;
     if (imageSource != null)
         return imageSource.ConvertToString(null,  System.Windows.Markup.TypeConverterHelper.InvariantEnglishUS);
     else
         return base.ConvertToString(value, context);
 }

		public override string ConvertToString(object value, IValueSerializerContext context)
		{
			if (value is DataRect)
			{
				DataRect rect = (DataRect)value;
				return rect.ConvertToString(null, CultureInfo.GetCultureInfo("en-us"));
			}
			return base.ConvertToString(value, context);
		}

        /// <summary>
        /// Returns true if the FontFamily is a named font family.
        /// </summary>
        public override bool CanConvertToString(object value, IValueSerializerContext context)
        {
            FontFamily fontFamily = value as FontFamily;

            // Suppress PRESharp warning that fontFamily can be null; apparently PRESharp
            // doesn't understand short circuit evaluation of operator &&.
#pragma warning suppress 56506
            return fontFamily != null && fontFamily.Source != null && fontFamily.Source.Length != 0;           
        }

 public override string ConvertToString(object value, IValueSerializerContext context)
 {
     IValueSerializableExpression expression = value as IValueSerializableExpression;
     if (expression == null)
     {
         throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.CannotSerializeExpression(value.GetType())));
     }
     return expression.ConvertToString(context);
 }

 public static ValueSerializer GetSerializerFor(PropertyDescriptor descriptor, IValueSerializerContext context)
 {
     ValueSerializer s = context.GetValueSerializerFor (descriptor);
     if (s == null) {
         DefaultValueSerializerContext defaultContext = new DefaultValueSerializerContext();
         s = defaultContext.GetValueSerializerFor (descriptor);
     }
     return s;
 }

 public override bool CanConvertToString(object value, IValueSerializerContext context)
 {
     Argument argument = value as Argument;
     if (argument == null)
     {
         return false;
     }
     return argument.CanConvertToString(context);
 }