Layout dinâmico

Artigo
06/16/2023

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 sempre fiquem na parte inferior. Você também pode configurar determinados controles, como caixas de listagem, caixas de edição e campos de texto, para que se expandam à medida que o usuário expande a caixa de diálogo.

Como especificar as 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 se redimensionar ou se mover nas direções X e Y. A alteração no tamanho ou na 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:

Dialog before being resized.

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:

Dialog after being resized.

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 objeto CMFCDynamicLayout para um controle específico e definindo as propriedades.

Definir 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 Movendo Tipo, 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. O tipo de movimentação e o tipo de dimensionamento podem 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 no canto inferior direito, 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 a uma distância fixa do canto inferior direito.
Suponha que haja também um controle que você queira que se expanda à 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 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. Então defina os valores de Dimensionamento X e Dimensionamento 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 de modo programático

O procedimento anterior é útil para especificar propriedades de layout dinâmico para uma caixa de diálogo no momento do design, mas se você quiser controlar o layout dinâmico no runtime, poderá definir propriedades de layout dinâmico de modo programático.

Para definir propriedades de layout dinâmico de modo programático

Localize ou crie um lugar no código de implementação da classe de diálogo em que você deseja especificar o layout dinâmico da caixa de diálogo. Por exemplo, adicione um método como AdjustLayout na caixa de diálogo e chame-o de locais em que o layout precisa ser alterado. Você pode primeiro chamá-lo do construtor ou depois de fazer alterações à caixa de diálogo.
Para a caixa de diálogo, chame GetDynamicLayout, um método da classe CWnd. GetDynamicLayout retorna um ponteiro para um objeto CMFCDynamicLayout.
```
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 primeiro escolhendo o método estático apropriado: CMFCDynamicLayout::MoveHorizontal, CMFCDynamicLayout::MoveVertical, CMFCDynamicLayout::MoveNone ou CMFCDynamicLayout::MoveHorizontalAndVertical. Você passa um percentual para os aspectos horizontais e/ou verticais da movimentação. Todos esses métodos estáticos retornam um objeto MoveSettings que acaba de ser criado que você pode usar para especificar o comportamento de movimentação de um controle.

Lembre que 100 significa mover exatamente tanto quanto a caixa de diálogo altera o tamanho, o que faz com que a borda de um controle permaneça a uma distância fixa da nova borda.
```
MoveSettings moveSettings = CMFCDynamicLayout::MoveHorizontal(100);
```
Faça o mesmo para o comportamento de tamanho, que usa o tipo SizeSettings. Por exemplo, para especificar que um controle não mude de tamanho quando a caixa de diálogo for redimensionada, 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. Uma usa o identificador de janela do controle (HWND) 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, é possível usar o método CMFCDynamicLayout::HasItem para determinar se um controle já está na lista de controles submetidos 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 de fato 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 de modo programático por meio 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 seguinte exemplo:
```
dynamicLayout->LoadResource("IDD_DIALOG1");
```
O recurso nomeado deve fazer referência a 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 seguinte exemplo:
```
/////////////////////////////////////////////////////////////////////////////
//
// 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
```

Confira 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

Partilhar via