Personalizando a janela de propriedades

Artigo
02/25/2013

Você pode personalizar a aparência e comportamento da janela properties em seu idioma específico do domínio (DSL) em Visual Studio.Em sua definição de DSL, você pode definir propriedades de domínio em cada classe de domínio.Por padrão, quando você seleciona uma instância da classe, em um diagrama ou no Gerenciador de modelos, cada propriedade de domínio está listada na janela Propriedades.Isso permite ver e editar os valores das propriedades do domínio, mesmo se você não tiver mapeado-los para campos de forma no diagrama.

Nomes, descrições e categorias

Nome e o nome de exibição.Em sua definição de uma propriedade de domínio, o nome de exibição da propriedade é o nome que aparece em tempo de execução na janela Propriedades.Por outro lado, o nome é usado quando você escreve o código de programa para atualizar a propriedade.O nome deve ser um nome alfanumérico correto do CLR, mas o nome de exibição pode conter espaços.

Quando você define o nome de uma propriedade na definição de DSL, seu nome de exibição é definida automaticamente para uma cópia do nome.Se você escrever um nome de cased de Pascal como, por exemplo, "FuelGauge", o nome de exibição conterá automaticamente um espaço: "Medidor de combustível".No entanto, você pode definir o nome de exibição explicitamente a outro valor.

Descrição.A descrição de uma propriedade de domínio aparece em dois lugares:

Na parte inferior da janela Propriedades quando o usuário seleciona a propriedade.Você pode usá-lo para explicar ao usuário o que representa a propriedade.
No código gerado do programa.Se você usar as facilidades de documentação para extrair a documentação da API, ele será exibido como a descrição desta propriedade na API.

Category.Uma categoria é um título na janela Propriedades.

Expor recursos de estilo

Alguns dos recursos dinâmicos de elementos gráficos podem ser representados ou expostos como propriedades do domínio.Um recurso que foi exposto dessa maneira pode ser atualizado pelo usuário e podem mais ser facilmente atualizada pelo código do programa.

Uma classe shape na definição de DSL com o botão direito, aponte para Adicionar expostose, em seguida, escolha um recurso.

Nas formas, você pode expor o FillColor, OutlineColor, TextColor, OutlineDashStyle, OutlineThickness e FillGradientMode propriedades.Nos conectores podem expor a cor,TextColor, DashStyle, e espessura propriedades.Em diagramas pode expor o FillColor e TextColor propriedades.

Encaminhamento: Exibindo propriedades de elementos relacionados

Quando o usuário de seu DSL seleciona um elemento em um modelo, propriedades desse elemento são exibidas na janela Propriedades.No entanto, você também pode exibir as propriedades dos elementos relacionados especificados.Isso é útil se você tiver definido um grupo de elementos que funciona em conjunto.Por exemplo, você pode definir um elemento principal e um elemento de plug-in opcional.Se o elemento principal é mapeado para uma forma e o outro não estiver, ele é útil ver todas as suas propriedades, como se estivessem em um elemento.

Esse efeito é denominado o encaminhamento de propriedade, e acontece automaticamente em vários casos.Em outros casos, você pode obter propriedade de encaminhamento, definindo um descritor de tipo de domínio.

Casos de encaminhamento de propriedade padrão

Quando o usuário seleciona um elemento ou conector ou uma forma no Explorer, as propriedades a seguir são exibidas na janela Propriedades:

As propriedades de domínio que são definidas na classe de domínio do elemento de modelo, inclusive aqueles que são definidos em classes base.Uma exceção é para o qual você tenha definido propriedades do domínio É navegável para False.
Os nomes dos elementos que estão vinculados por meio de relações que têm uma multiplicidade de 0.Isso fornece um método conveniente de ver opcionalmente vinculado elementos, mesmo se você não tiver definido um mapeamento de conector para o relacionamento.
Propriedades do domínio da relação incorporação que atinge o elemento.Porque a incorporação de relacionamentos não são normalmente exibidos explicitamente, isso permite que o usuário veja suas propriedades.
Propriedades de domínio que são definidas no conector ou forma selecionada.

Adicionando o encaminhamento de propriedade

Para encaminhar uma propriedade, você pode definir um descritor de tipo de domínio.Se você tiver uma relação de domínio entre duas classes de domínio, você pode usar um descritor de tipo de domínio para definir uma propriedade de domínio na primeira classe para o valor de uma propriedade de domínio na classe de domínio de segunda.Por exemplo, se você tiver uma relação entre uma classe de domínio do catálogo e uma classe de domínio do autor, você pode usar um descritor de tipo de domínio para fazer com que a propriedade do nome do autor de um livro são exibidos na janela Propriedades, quando o usuário seleciona o livro.

Observação
Encaminhamento de propriedade afeta somente a janela de propriedades quando o usuário está editando um modelo.Ele não define uma propriedade de domínio na classe de recebimento.Se você quiser acessar a propriedade de domínio encaminhada em outras partes da definição de DSL ou no código de programa, você deve acessar o elemento de encaminhamento.

O procedimento a seguir pressupõe que você tenha criado uma DSL.Os primeiros passos alguns resumem os pré-requisitos.

Para encaminhar uma propriedade de outro elemento

Criar um Ferramentas de Linguagem Específica do Domínio solução que contém pelo menos duas classes, que, neste exemplo, são chamadas de catálogo e autor.Deve haver uma relação de qualquer tipo entre o livro e autor.

A multiplicidade da função de origem (a função do lado do catálogo) deve ser 0 ou 1... 1, para que cada livro tem um autor.
Em Explorer DSL, a classe de domínio de catálogo com o botão direito e, em seguida, clique em Adicionar nova DomainTypeDescriptor.

Um nó chamado Caminhos de descritores de propriedade personalizada aparece sob o Descritor de tipo personalizado nó.
Com o botão direito do Descritor de tipo personalizado nó e, em seguida, clique Adicionar novo PropertyPath.

Um novo caminho de propriedade aparece sob o Caminhos de descritores de propriedade personalizada nó.
Selecione o novo caminho de propriedade e de Propriedades janela, defina caminho para a propriedade para o caminho do elemento de modelo apropriado.

Você pode editar o caminho em uma exibição em árvore, clicando na seta para baixo à direita desta propriedade.Para obter mais informações sobre caminhos de domínio, consulte Sintaxe de caminho do domínio.Quando tiver editado, o caminho deve ser semelhante BookReferencesAuthor.Author/!Autor.
Definir propriedade para o Name a propriedade domain do autor.
Definir nome de exibição para o nome do autor.
Transformar todos os modelos, construir e executar o DSL.
Em um diagrama de modelo, crie um livro, autor e vinculá-los usando a relação de referência.Selecione o elemento de livro e na janela Propriedades, você verá o nome do autor e as propriedades do livro.Alterar o nome do autor vinculado, ou vincular o livro a um autor diferente e observe que o nome do autor do livro muda.

Editores de propriedade personalizada

A janela de propriedade fornece um padrão apropriado de experiência para o tipo de cada propriedade de domínio de edição.Por exemplo, para um tipo enumerado, o usuário vê uma lista drop-down e para uma propriedade numérica, o usuário pode inserir dígitos.Isso vale apenas para os tipos internos.Se você especificar um tipo externo, o usuário poderá ver os valores da propriedade, mas não editá-lo.

No entanto, você pode especificar os editores e tipos a seguir:

Outro editor que é usado com um tipo padrão.Por exemplo, você pode especificar um editor de caminho de arquivo para uma propriedade de seqüência de caracteres.
Um tipo externo para a propriedade de domínio e um editor para ele.
R.NET editor como editor de caminho do arquivo, ou você pode criar sua própria propriedade personalizada editor.

Uma conversão entre um tipo externo e um tipo como, por exemplo, seqüência de caracteres, que tem um editor padrão.

Em uma DSL, um tipo externo é qualquer tipo que não é um dos tipos simples (como booleanas ou Int32) ou seqüência de caracteres.

Para definir uma propriedade de domínio que tem um tipo externo

Em Solution Explorer, adicione uma referência ao assembly (DLL) que contém o tipo externo, in a Dsl project.

O assembly pode ser um.NET assembly, ou um assembly fornecido por você.
Adicionar o tipo para o Tipos de domínio listar, a menos que você já tiver feito isso.
1. Abra o DslDefinition.dsl e em Explorer DSL, clique com o botão direito no nó raiz e, em seguida, clique em Adicionar novo tipo externo.
  
  Uma nova entrada aparece sob o Tipos de domínio nó.
  
  Cuidado
  
  O item de menu não está no nó raiz de DSL, o Tipos de domínio nó.
2. Na janela Properties, defina o nome e o espaço para nome do novo tipo.
Adicione uma propriedade de domínio para uma classe de domínio da forma usual.

Na janela Propriedades, selecione o tipo de externo da lista suspensa na tipo de campo.

Cuidado
O item de menu não está no nó raiz de DSL, o Tipos de domínio nó.

Nesse estágio, os usuários podem exibir os valores da propriedade, mas eles não é possível editá-lo.Os valores exibidos são obtidos do ToString() função.Você poderia escrever o código de programa que define o valor da propriedade, por exemplo, em um comando ou uma regra.

A definição de um Editor de propriedade

Adicione um atributo CLR para a propriedade de domínio, da seguinte forma:

[System.ComponentModel.Editor (
   typeof(AnEditor),
   typeof(System.Drawing.Design.UITypeEditor))]

Você pode definir o atributo em uma propriedade usando o Atributo personalizado a entrada na janela Propriedades.

O tipo de AnEditor deve ser derivado de tipo especificado no segundo parâmetro.O segundo parâmetro deve ser um UITypeEditor ou ComponentEditor.Para obter mais informações, consulte EditorAttribute.

Você pode especificar seu próprio editor ou um editor fornecido com o .NET Framework, como FileNameEditor ou ImageEditor.Por exemplo, use o procedimento a seguir para ter uma propriedade na qual o usuário pode digitar um nome de arquivo.

Para definir uma propriedade de domínio de nome de arquivo

Adicione uma propriedade de domínio para uma classe de domínio em sua definição de DSL.
Selecione a nova propriedade.No Atributo personalizado na janela Propriedades de campo, digite o seguinte atributo.Para inserir esse atributo, clique nas reticências [...] e, em seguida, insira o nome do atributo e os parâmetros separadamente:
```
[System.ComponentModel.Editor (
   typeof(System.Windows.Forms.Design.FileNameEditor)
   , typeof(System.Drawing.Design.UITypeEditor))]
```
Deixe o tipo da propriedade de domínio em sua configuração padrão de seqüência de caracteres.
Para testar o editor, verifique se que os usuários podem abrir o editor de nome de arquivo para editar sua propriedade de domínio.
1. Pressione CTRL + F5 ou F5.Na solução de depuração, abra um arquivo de teste.Crie um elemento da classe de domínio e selecioná-lo.
2. Na janela Properties, selecione a propriedade de domínio.O campo de valor mostra reticências [...].
3. Clique nas reticências.Uma caixa de diálogo é exibida.Selecione um arquivo e feche a caixa de diálogo.O caminho do arquivo agora é o valor da propriedade de domínio.

Definindo seu próprio editor de propriedade

Você pode definir seu próprio editor.Você faria isso para permitir ao usuário para editar um tipo que você definiu, ou editar um tipo padrão de maneira especial.Por exemplo, você pode permitir que o usuário insira uma seqüência de caracteres que representa uma fórmula.

Você define um editor, escrevendo uma classe que é derivada de UITypeEditor.Sua classe deve substituir:

EditValue, para interagir com o usuário e atualizar o valor da propriedade.
GetEditStyle, para especificar se o seu editor irá abrir uma caixa de diálogo ou fornecer um menu drop-down.

Você também pode fornecer uma representação gráfica do valor da propriedade que será exibido na grade de propriedades.Para fazer isso, substituir GetPaintValueSupported, e PaintValue.Para obter mais informações, consulte UITypeEditor.

Observação
Adicione o código em um arquivo de código separados na Dsl project.

Por exemplo:

internal class TextFileNameEditor : System.Windows.Forms.Design.FileNameEditor
{
  protected override void InitializeDialog(System.Windows.Forms.OpenFileDialog openFileDialog)
  {
    base.InitializeDialog(openFileDialog);
    openFileDialog.Filter = "Text files(*.txt)|*.txt|All files (*.*)|*.*";
    openFileDialog.Title = "Select a text file";
  }
}

Para usar este editor, defina a Atributo personalizado de uma propriedade de domínio para:

[System.ComponentModel.Editor (
   typeof(MyNamespace.TextFileNameEditor)
   , typeof(System.Drawing.Design.UITypeEditor))]

Para obter mais informações, consulte UITypeEditor.

Fornecendo uma lista suspensa de valores

Você pode fornecer uma lista de valores para um usuário para serem escolhidos.

Observação
Essa técnica fornece uma lista de valores que podem ser alteradas em tempo de execução.Se você desejar fornecer uma lista que não se altera, em vez disso, considere usar um tipo enumerado como o tipo de propriedade de seu domínio.

Para definir uma lista de valores padrão, você adiciona à sua propriedade de domínio um atributo CLR que tem a seguinte forma:

[System.ComponentModel.TypeConverter 
(typeof(MyTypeConverter))]

Definir uma classe que deriva de TypeConverter.Adicione o código em um arquivo separado na Dsl project.Por exemplo:

/// <summary>
/// Type converter that provides a list of values 
/// to be displayed in the property grid.
/// </summary>
/// <remarks>This type converter returns a list 
/// of the names of all "ExampleElements" in the 
/// current store.</remarks>
public class MyTypeConverter : System.ComponentModel.TypeConverter
{
  /// <summary>
  /// Return true to indicate that we return a list of values to choose from
  /// </summary>
  /// <param name="context"></param>
  public override bool GetStandardValuesSupported
    (System.ComponentModel.ITypeDescriptorContext context)
  {
    return true;
  }

  /// <summary>
  /// Returns true to indicate that the user has 
  /// to select a value from the list
  /// </summary>
  /// <param name="context"></param>
  /// <returns>If we returned false, the user would 
  /// be able to either select a value from 
  /// the list or type in a value that is not in the list.</returns>
  public override bool GetStandardValuesExclusive
      (System.ComponentModel.ITypeDescriptorContext context)
  {
    return true;
  }

  /// <summary>
  /// Return a list of the values to display in the grid
  /// </summary>
  /// <param name="context"></param>
  /// <returns>A list of values the user can choose from</returns>
  public override StandardValuesCollection GetStandardValues
      (System.ComponentModel.ITypeDescriptorContext context)
  {
    // Try to get a store from the current context
    // "context.Instance"  returns the element(s) that 
    // are currently selected i.e. whose values are being
    // shown in the property grid. 
    // Note that the user could have selected multiple objects, 
    // in which case context.Instance will be an array.
    Store store = GetStore(context.Instance);

    List<string> values = new List<string>();

    if (store != null)
    {
      values.AddRange(store.ElementDirectory
        .FindElements<ExampleElement>()
        .Select<ExampleElement, string>(e => 
      {
        return e.Name;
      }));
    }
    return new StandardValuesCollection(values);
  }

  /// <summary>
  /// Attempts to get to a store from the currently selected object(s)
  /// in the property grid.
  /// </summary>
  private Store GetStore(object gridSelection)
  {
    // We assume that "instance" will either be a single model element, or 
    // an array of model elements (if multiple items are selected).

    ModelElement currentElement = null;

    object[] objects = gridSelection as object[];
    if (objects != null && objects.Length > 0)
    {
      currentElement = objects[0] as ModelElement;
    }
    else
    {
        currentElement = gridSelection as ModelElement;
    }

    return (currentElement == null) ? null : currentElement.Store;
  }

}

Consulte também

Conceitos

Navegando e atualizando um modelo de código de programa

Partilhar via