Copiar está desconectado en la propiedad de cuadrícula

Question

Tengo un FileNameEditor dentro de una cuadrícula de propiedades, que tiene un par de entradas como

Archivo principal: "C: \ blah1"

Archivo Sec: "C: \ blah2"

y así sucesivamente.

Mi problema es que no puedo copiar y pegar desde una entrada propiedad a otra, y no puedo escribir en los campos manualmente. ¿Hay una propiedad específica que permita a la edición dentro de la FileNameEditor. Ejemplo

public class MyEditor : FileNameEditor
{
    public override bool GetPaintValueSupported(ITypeDescriptorContext context)
    {
        return false;
    }

    public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)

    {

        object e = base.EditValue(context, provider, value);

        if ((value as MyFileS) != null)
        {
            (value as MyFilesS).FileName = (String) e;
        }

        return e;
    }

    protected override void InitializeDialog(OpenFileDialog openFileDialog)
    {
        base.InitializeDialog(openFileDialog);
    }
}

Gracias

Answer 1

¿Por qué utiliza un editor personalizado? Si lo que desea es una propiedad de cadena en un objeto y luego la respuesta de Marc Gravell funciona.

Sin embargo, si el "archivo" propiedad en el objeto dentro de la cuadrícula de propiedades es una clase personalizada también es necesario para implementar un convertidor de tipo personalizado.

Por ejemplo:

namespace WindowsFormsApplication
{
    using System;
    using System.ComponentModel;
    using System.Drawing.Design;
    using System.Globalization;
    using System.Windows.Forms;
    using System.Windows.Forms.Design;

    class MyEditor : FileNameEditor
    {
        public override bool GetPaintValueSupported(ITypeDescriptorContext context)
        {
            return false;
        }

        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
        {
            string s = Environment.CurrentDirectory;
            object e = base.EditValue(context, provider, value);
            Environment.CurrentDirectory = s;

            var myFile = value as MyFile;
            if (myFile != null && e is string)
            {
                myFile.FileName = (string)e;
                return myFile;
            }

            return e;
        }
    }

    class MyFileTypeConverter : TypeConverter
    {
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
        {
            if (sourceType == typeof(string))
                return true;

            return base.CanConvertFrom(context, sourceType);
        }

        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
        {
            if (destinationType == typeof(string))
                return true;

            return base.CanConvertTo(context, destinationType);
        }

        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
        {
            if (value is string)
                return new MyFile { FileName = (string)value };

            return base.ConvertFrom(context, culture, value);
        }

        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
        {
            var myFile = value as MyFile;
            if (myFile != null && destinationType == typeof(string))
                return myFile.FileName;

            return base.ConvertTo(context, culture, value, destinationType);
        }
    }

    [TypeConverter(typeof(MyFileTypeConverter))]
    [Editor(typeof(MyEditor), typeof(UITypeEditor))]
    class MyFile
    {
        public string FileName { get; set; }
    }

    class MyFileContainer
    {
        public MyFileContainer()
        {
            File1 = new MyFile { FileName = "myFile1.txt" };
            File2 = new MyFile { FileName = "myFile2.txt" };
        }

        public MyFile File1 { get; set; }
        public MyFile File2 { get; set; }
    }

    static public class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            using (var f = new Form())
            using (var pg = new PropertyGrid())
            {
                pg.Dock = DockStyle.Fill;
                pg.SelectedObject = new MyFileContainer();
                f.Controls.Add(pg);
                Application.Run(f);
            }
        }
    }
}

Para apoyar la edición del nombre de archivo en lugar y también cortar y pegar el PropertyGrid necesita saber cómo convertir de una cadena a su tipo "Archivo" y viceversa. Si no se implementa el convertido a métodos de cadena en el TypeConverter la propiedad mostrará el resultado de ToString del objeto ().

Sugiero sacando Reflector.Net y la lectura de la fuente de algunos de los UITypeEditors y TypeConverters en el BCL, ya que puede ser muy informativa para ver cómo Microsoft admite la edición en color, TimeSpan, DateTime etc en cuadrículas de propiedades.

Además, tenga cuidado diálogos de archivos de apertura. El cuadro de diálogo estándar de Windows Forms archivo abierto puede cambiar sus aplicaciones directorio de trabajo actual si no tiene cuidado. No creo FileNameEditor tiene este problema, pero sólo he probado esto en Windows 7.

Answer 2

No se puede reproducir; esto funciona bien - se puede copiar / pegar tanto en la red y la ventana emergente (? hace su propiedad tiene un colocador):

using System;
using System.ComponentModel;
using System.Drawing.Design;
using System.Windows.Forms;
using System.Windows.Forms.Design;
class Foo
{
    [Editor(typeof(FileNameEditor), typeof(UITypeEditor))]
    public string Name { get; set; }

    [STAThread]
    static void Main()
    {
        using (Form form = new Form())
        using (PropertyGrid grid = new PropertyGrid())
        {
            grid.Dock = DockStyle.Fill;
            form.Controls.Add(grid);
            grid.SelectedObject = new Foo();
            Application.Run(form);
        }
    }
}