Layout Dinâmico

Com o MFC no Visual Studio 2015, você pode criar caixas de diálogo que o usuário pode redimensionar e controlar a maneira como o layout se ajusta à alteração de tamanho. Por exemplo, você pode anexar botões na parte inferior de uma caixa de diálogo à borda inferior para que eles fiquem sempre na parte inferior. Você também pode configurar determinados controles, como caixas de listagem, caixas de edição e campos de texto, para expandir à medida que o usuário expande a caixa de diálogo.

Especificando configurações de layout dinâmico para uma caixa de diálogo MFC

Quando o usuário redimensiona uma caixa de diálogo, os controles na caixa de diálogo podem redimensionar ou mover-se nas direções X e Y. A alteração no tamanho ou posição de um controle quando o usuário redimensiona uma caixa de diálogo é chamada de layout dinâmico. Por exemplo, o seguinte é uma caixa de diálogo antes de ser redimensionado:

Caixa de diálogo antes de ser redimensionado.

Depois de redimensionada, a área da caixa de listagem é aumentada para mostrar mais itens e os botões são movidos junto com o canto inferior direito:

Caixa de diálogo após ser redimensionado.

Você pode controlar o layout dinâmico especificando os detalhes de cada controle no Editor de Recursos no IDE ou pode fazer isso programaticamente acessando o CMFCDynamicLayout objeto para um controle específico e definindo as propriedades.

Definindo propriedades de layout dinâmico no editor de recursos

Você pode definir o comportamento de layout dinâmico para uma caixa de diálogo sem precisar escrever nenhum código usando o editor de recursos.

Para definir propriedades de layout dinâmico no editor de recursos

Com um projeto MFC aberto, abra a caixa de diálogo com a qual você deseja trabalhar no editor de diálogo.
Selecione um controle e, na janela Propriedades (no Modo de Exibição de Classe), defina suas propriedades de layout dinâmico. A seção Layout Dinâmico na janela Propriedades contém as propriedades Tipo de Movimentação, Tipo de Dimensionamento e, dependendo dos valores selecionados para essas propriedades, propriedades específicas que definem a quantidade de controles que movem ou alteram o tamanho. O tipo de movimentação determina como um controle é movido à medida que o tamanho da caixa de diálogo é alterado; O tipo de dimensionamento determina como um controle é redimensionado à medida que o tamanho da caixa de diálogo é alterado. Mover Tipo e Tipo de Dimensionamento pode ser Horizontal, Vertical, Ambos ou Nenhum , dependendo das dimensões que você deseja alterar dinamicamente. Horizontal é a dimensão X; Vertical é a direção Y.
Se você quiser que um controle como um botão esteja em um tamanho fixo e permaneça no lugar na parte inferior direita, como é comum para os botões OK ou Cancelar , defina o Tipo de Dimensionamento como Nenhum e defina o Tipo de Movimentação como Ambos. Para os valores Movendo X e Movendo Y em Tipo móvel, defina 100% para fazer com que o controle permaneça uma distância fixa do canto inferior direito.
Suponha que você também tenha um controle que deseja expandir à medida que a caixa de diálogo se expande. Normalmente, um usuário pode expandir uma caixa de diálogo para expandir uma caixa de edição de várias linhas para aumentar o tamanho da área de texto ou pode expandir um controle de lista para ver mais dados. Para esse caso, defina o Tipo de Dimensionamento como Ambos e defina o Tipo de Movimentação como nenhum. Em seguida, defina os valores Sizing X e Sizing Y como 100.
Experimente outros valores que podem fazer sentido para seus controles. Uma caixa de diálogo com uma caixa de texto de uma linha pode ter o Tipo de Dimensionamento definido apenas como Horizontal , por exemplo.

Definir propriedades de layout dinâmico programaticamente

O procedimento anterior é útil para especificar propriedades de layout dinâmico para uma caixa de diálogo em tempo de design, mas se você quiser controlar o layout dinâmico em runtime, poderá definir propriedades de layout dinâmico programaticamente.

Para definir propriedades de layout dinâmico programaticamente

Localize ou crie um local no código de implementação da classe de diálogo em que você deseja especificar o layout dinâmico para a caixa de diálogo. Por exemplo, talvez você queira adicionar um método, como AdjustLayout na caixa de diálogo, e chamá-lo de locais em que o layout precisa ser alterado. Você pode primeiro chamá-lo do construtor ou depois de fazer alterações na caixa de diálogo.
Para a caixa de diálogo, chame GetDynamicLayout, um método da CWnd classe. GetDynamicLayout retorna um ponteiro para um CMFCDynamicLayout objeto.
```
CMFCDynamicLayout* dynamicLayout = pDialog->GetDynamicLayout();
```
Para o primeiro controle ao qual você deseja adicionar comportamento dinâmico, use os métodos estáticos na classe de layout dinâmico para criar a estrutura MoveSettings que codifica a maneira como o controle deve ser ajustado. Você faz isso escolhendo primeiro o método estático apropriado: CMFCDynamicLayout::MoveHorizontal, CMFCDynamicLayout::MoveVertical, CMFCDynamicLayout::MoveNone ou CMFCDynamicLayout::MoveHorizontalAndVertical. Você passa uma porcentagem para os aspectos horizontais e/ou verticais da movimentação. Todos esses métodos estáticos retornam um objeto MoveSettings recém-criado que você pode usar para especificar o comportamento de movimentação de um controle.

Tenha em mente que 100 significa mover exatamente tanto quanto o diálogo muda de tamanho, o que faz com que a borda de um controle permaneça uma distância fixa da nova borda.
```
MoveSettings moveSettings = CMFCDynamicLayout::MoveHorizontal(100);
```
Faça a mesma coisa para o comportamento de tamanho, que usa o tipo SizeSettings . Por exemplo, para especificar que um controle não altere o tamanho quando a caixa de diálogo for redimensionado, use o seguinte código:
```
SizeSettings sizeSettings = CMFCDynamicLayout::SizeNone();
```
Adicione o controle ao gerenciador de layout dinâmico usando o método CMFCDynamicLayout::AddItem . Há duas sobrecargas para diferentes maneiras de especificar o controle desejado. Um usa o HWND (identificador de janela) do controle e o outro usa a ID de controle.
```
dynamicLayout->AddItem(hWndControl,
moveSettings,
sizeSettings);
```
Repita para cada controle que precisa ser movido ou redimensionado.
Se necessário, pode usar o método CMFCDynamicLayout::HasItem para determinar se um controle já está na lista de controles sujeitos a alterações de layout dinâmico ou o método CMFCDynamicLayout::IsEmpty para determinar se há controles sujeitos a alterações.
Para habilitar o layout da caixa de diálogo, chame o método CWnd::EnableDynamicLayout .
```
pDialog->EnableDynamicLayout(TRUE);
```
Na próxima vez que o usuário redimensionar a caixa de diálogo, o método CMFCDynamicLayout::Adjust será chamado, o que realmente aplica as configurações.
Se você quiser desabilitar o layout dinâmico, chame CWnd::EnableDynamicLayout com FALSE como para o parâmetro bEnabled .
```
pDialog->EnableDynamicLayout(FALSE);
```

Para definir o layout dinâmico programaticamente de um arquivo de recurso

Use o método CMFCDynamicLayout::MoveHorizontalAndVertical para especificar um nome de recurso no arquivo de script de recurso relevante (arquivo .rc) que especifica informações de layout dinâmico, como no exemplo a seguir:
```
dynamicLayout->LoadResource("IDD_DIALOG1");
```
O recurso nomeado deve referenciar uma caixa de diálogo que contenha informações de layout na forma de uma entrada AFX_DIALOG_LAYOUT no arquivo de recurso, como no exemplo a seguir:
```
/////////////////////////////////////////////////////////////////////////////
//
// AFX_DIALOG_LAYOUT
//

IDD_MFCAPPLICATION1_DIALOG AFX_DIALOG_LAYOUT
BEGIN
0x0000,
0x6400,
0x0028,
0x643c,
0x0028
END

IDD_DIALOG1 AFX_DIALOG_LAYOUT
BEGIN
0x0000,
0x6464,
0x0000,
0x6464,
0x0000,
0x0000,
0x6464,
0x0000,
0x0000

END
```

Consulte também

Classe CMFCDynamicLayout
Classes de controle
Classes da caixa de diálogo
Editor de caixa de diálogo
Layout da caixa de diálogo dinâmica para MFC no Visual C++ 2015

Comentários

Esta página foi útil?

Last updated on 2025-11-07