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 no tamanho. Por exemplo, pode-se anexar botões no fundo de uma caixa de diálogo à borda inferior para que fiquem sempre na parte de baixo. 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 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, a seguir está uma caixa de diálogo antes de ser redimensionada:

Diálogo antes de ser redimensionado.

Depois de ser 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 depois de ser redimensionada.

Você pode controlar o layout dinâmico especificando os detalhes de cada controle no Editor de Recursos no IDE, ou pode fazê-lo 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 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 Móvel, Tipo de Dimensionamento e, dependendo dos valores selecionados para essas propriedades, propriedades específicas que definem a quantidade de controles que se movem ou alteram de tamanho. Moving Type determina como um controle é movido à medida que o tamanho da caixa de diálogo é alterado; Tipo de dimensionamento determina como um controle é redimensionado à medida que o tamanho da caixa de diálogo é alterado. Tipo móvel e 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 em Y.
Se você quiser que um controle, como um botão, tenha 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 em movimento como Ambos. Para os valores Moving X e Moving Y em Moving Type, defina 100% para fazer com que o controle permaneça a uma distância fixa do canto inferior direito.
Suponha que também tenhas um controlo que desejas expandir à medida que o 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. Nesse caso, defina o Tipo de dimensionamento como Ambos e defina o Tipo móvel como nenhum. Em seguida, defina os valores de Dimensionamento X e Dimensionamento Y como 100.
Experimente outros valores que possam 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 como Somente horizontal , por exemplo.

Definindo 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 tempo de execução, 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 onde pretenda especificar a disposição dinâmica para o diálogo. Por exemplo, talvez você queira adicionar um método como AdjustLayout na caixa de diálogo e chamá-lo de locais onde o layout precisa ser alterado. Você pode primeiro chamar isso do construtor ou depois de fazer alterações na caixa de diálogo.
Para o 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. Para fazer isso, primeiro escolha o método estático apropriado: CMFCDynamicLayout::MoveHorizontal, CMFCDynamicLayout::MoveVertical, CMFCDynamicLayout::MoveNone, ou CMFCDynamicLayout::MoveHorizontalAndVertical. Você passa uma porcentagem para os aspetos horizontais e/ou verticais do movimento. Todos esses métodos estáticos retornam um objeto MoveSettings recém-criado que você pode usar para especificar o comportamento de movimento de um controle.

Lembre-se de que 100 significa se mover exatamente tanto quanto a caixa de diálogo muda de tamanho, o que faz com que a borda de um controle fique 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 muda de tamanho quando a caixa de diálogo é 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 . Existem duas sobrecargas para diferentes formas de especificar o controlo desejado. Um pega o identificador de janela do controle (HWND) e o outro pega o ID do 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 dinâmicas de layout ou o método CMFCDynamicLayout::IsEmpty para determinar se há algum controle sujeito 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 utilizador redimensionar a caixa de diálogo, o método CMFCDynamicLayout::Adjust é chamado, o qual 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 a partir 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 fazer referência a uma caixa de diálogo que contém informações de layout na forma de uma entrada de 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
```

Ver também

CMFCDynamicLayout Classe
Classes de controlo
Classes de caixa de diálogo
Editor de diálogo
Layout de diálogo dinâmico para MFC no Visual C++ 2015

Feedback

Esta página foi útil?

Last updated on 2025-11-07