ReferenceConverter.cs :  » 2.6.4-mono-.net-core » System.ComponentModel » System » ComponentModel » C# / CSharp Open Source

//
// System.ComponentModel.ReferenceConverter.cs
//
// Authors:
//   Martin Willemoes Hansen (mwh@sysrq.dk)
//   Andreas Nahr (ClassDevelopment@A-SoftTech.com)
//   Ivan N. Zlatev (contact@i-nz.net)
//
// (C) 2003 Martin Willemoes Hansen
// (C) 2003 Andreas Nahr

//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System.Globalization;
using System.Collections;
using System.ComponentModel.Design;

namespace System.ComponentModel{
  public class ReferenceConverter : TypeConverter
  {

    private Type reference_type;

    public ReferenceConverter (Type type)
    {
      reference_type = type;
    }

    public override bool CanConvertFrom (ITypeDescriptorContext context,
                 Type sourceType)
    {
      if (context != null && sourceType == typeof (string))
        return true;
      return base.CanConvertFrom (context, sourceType);
    }

    public override object ConvertFrom (ITypeDescriptorContext context,
                CultureInfo culture,
                object value)
    {
      if (!(value is string))
        return base.ConvertFrom(context, culture, value);
      
      
      if (context != null) {
        object reference = null;
        // try 1 - IReferenceService
        IReferenceService referenceService = context.GetService (typeof (IReferenceService)) as IReferenceService;
        if (referenceService != null)
          reference = referenceService.GetReference ((string)value);

        // try 2 - Component by name
        if (reference == null) {
          if (context.Container != null && context.Container.Components != null)
            reference = context.Container.Components[(string)value];
        }

        return reference;
      }

      return null;
    }

    public override object ConvertTo (ITypeDescriptorContext context,
              CultureInfo culture,
              object value,
              Type destinationType)
    {
      if (destinationType != typeof (string))
        return base.ConvertTo(context, culture, value, destinationType);
      
      if (value == null)
        return "(none)";
      
      string referenceName = String.Empty;

      if (context != null) {
        // try 1 - IReferenceService
        IReferenceService referenceService = context.GetService (typeof (IReferenceService)) as IReferenceService;
        if (referenceService != null)
          referenceName = referenceService.GetName (value);
  
        // try 2 - Component by name
        if ((referenceName == null || referenceName.Length == 0) && value is IComponent) {
          IComponent component = (IComponent) value;
          if (component.Site != null && component.Site.Name != null)
            referenceName = component.Site.Name;
        }
      }

      return referenceName;
    }

    public override StandardValuesCollection GetStandardValues (ITypeDescriptorContext context)
    {
      ArrayList values = new ArrayList ();

      if (context != null) {
        IReferenceService referenceService = context.GetService (typeof (IReferenceService)) as IReferenceService;
        if (referenceService != null) {
          foreach (object reference in referenceService.GetReferences (reference_type)) {
            if (IsValueAllowed (context, reference)) {
              values.Add (reference);
            }
          }
        } else {
          if (context.Container != null && context.Container.Components != null) {
            foreach (object component in context.Container.Components) {
              // avoid duplicate null values here
              if (component != null && 
                  IsValueAllowed (context, component) &&
                  reference_type.IsInstanceOfType (component))
                values.Add (component);
            }
          }
        }

        values.Add (null);
      }

      return new StandardValuesCollection (values);
    }

    public override bool GetStandardValuesExclusive (ITypeDescriptorContext context)
    {
      return true;
    }

    public override bool GetStandardValuesSupported (ITypeDescriptorContext context)
    {
      return true;
    }

    protected virtual bool IsValueAllowed (ITypeDescriptorContext context, object value)
    {
      return true;
    }
  }
}