Układ dynamiczny

Artykuł
10/12/2023

Dzięki MFC w programie Visual Studio 2015 można tworzyć okna dialogowe, które użytkownik może zmienić, i kontrolować sposób dostosowywania układu do zmiany rozmiaru. Można na przykład dołączyć przyciski w dolnej części okna dialogowego, aby zawsze pozostawać u dołu. Możesz również skonfigurować niektóre kontrolki, takie jak pola listy, pola edycji i pola tekstowe, aby rozwijać się, gdy użytkownik rozwija okno dialogowe.

Określanie ustawień układu dynamicznego dla okna dialogowego MFC

Gdy użytkownik zmienia rozmiar okna dialogowego, kontrolki w oknie dialogowym mogą zmieniać rozmiar lub przenosić się w kierunkach X i Y. Zmiana rozmiaru lub położenia kontrolki, gdy użytkownik zmienia rozmiar okna dialogowego, jest nazywany układem dynamicznym. Na przykład poniżej przedstawiono okno dialogowe przed zmianą rozmiaru:

Dialog before being resized.

Po zmianie rozmiaru obszar pola listy jest zwiększany w celu wyświetlania większej liczby elementów, a przyciski są przenoszone wraz z prawym dolnym róg:

Dialog after being resized.

Układ dynamiczny można kontrolować, określając szczegóły każdej kontrolki w Edytorze zasobów w środowisku IDE. Można to zrobić programowo, korzystając z obiektu dla określonej kontrolki i ustawiając CMFCDynamicLayout właściwości.

Ustawianie właściwości układu dynamicznego w edytorze zasobów

Dynamiczne zachowanie układu okna dialogowego można ustawić bez konieczności pisania kodu przy użyciu edytora zasobów.

Aby ustawić właściwości układu dynamicznego w edytorze zasobów

Po otwarciu projektu MFC otwórz okno dialogowe, z którym chcesz pracować w edytorze okien dialogowych.
Wybierz kontrolkę i w oknie Właściwości (w widoku klasy) ustaw jego właściwości układu dynamicznego. Sekcja Układ dynamiczny w oknie Właściwości zawiera właściwości Typ przenoszenia, Typ określania rozmiaru i, w zależności od wartości wybranych dla tych właściwości, określone właściwości definiujące, ile kontrolek przenosi lub zmienia rozmiar. Przenoszenie typu określa sposób przenoszenia kontrolki w miarę zmiany rozmiaru okna dialogowego; Typ określania rozmiaru określa, jak zmienia się rozmiar kontrolki w miarę zmiany rozmiaru okna dialogowego. Przenoszenie typu i typu określania rozmiaru może być poziome, pionowe, oba lub brak w zależności od wymiarów, które mają być zmieniane dynamicznie. Poziomy jest wymiarem X; Pionowo to kierunek Y.
Jeśli chcesz, aby kontrolka, taka jak przycisk był o stałym rozmiarze i pozostać na miejscu w prawym dolnym rogu, podobnie jak w przypadku przycisków OK lub Anuluj, ustaw typ rozmiaru na None i ustaw wartość Typ przenoszenia na Wartość Oba. W przypadku wartości Przenoszenie X i Przenoszenie Y w obszarze Typ przenoszenia ustaw wartość 100%, aby kontrolka utrzymywała stałą odległość od prawego dolnego rogu.
Załóżmy, że masz również kontrolkę, którą chcesz rozwinąć w miarę rozwijania okna dialogowego. Zazwyczaj użytkownik może rozwinąć okno dialogowe w celu rozwinięcia wielowierszowego pola edycji w celu zwiększenia rozmiaru obszaru tekstowego lub rozwinąć kontrolkę listy, aby wyświetlić więcej danych. W tym przypadku ustaw wartość Typ określania rozmiaru na Wartość Oba, a dla ustawienia Typ przenoszenia ustaw wartość none. Następnie ustaw wartości rozmiaru X i Ustalanie rozmiaru Y na 100.
Poeksperymentuj z innymi wartościami, które mogą mieć sens dla kontrolek. Okno dialogowe z jednowierszowym polem tekstowym może mieć typ określania rozmiaru ustawiony tylko na poziome, na przykład.

Programowe ustawianie właściwości układu dynamicznego

Poprzednia procedura jest przydatna do określania właściwości układu dynamicznego okna dialogowego w czasie projektowania, ale jeśli chcesz sterować układem dynamicznym w czasie wykonywania, możesz programowo ustawić właściwości układu dynamicznego.

Aby programowo ustawić właściwości układu dynamicznego

Znajdź lub utwórz miejsce w kodzie implementacji klasy okna dialogowego, w którym chcesz określić dynamiczny układ okna dialogowego. Na przykład możesz dodać metodę, taką jak AdjustLayout w oknie dialogowym, i wywołać ją z miejsc, w których należy zmienić układ. Możesz najpierw wywołać to z konstruktora lub po wprowadzeniu zmian w oknie dialogowym.
W oknie dialogowym wywołaj metodę GetDynamicLayout, czyli metodę CWnd klasy . GetDynamicLayout Zwraca wskaźnik do CMFCDynamicLayout obiektu.
```
CMFCDynamicLayout* dynamicLayout = pDialog->GetDynamicLayout();
```
Dla pierwszej kontrolki, do której chcesz dodać zachowanie dynamiczne, użyj metod statycznych w klasie układu dynamicznego, aby utworzyć strukturę Move Ustawienia która koduje sposób dostosowania kontrolki. W tym celu należy najpierw wybrać odpowiednią metodę statyczną: CMFCDynamicLayout::MoveHorizontal, CMFCDynamicLayout::MoveVertical, CMFCDynamicLayout::MoveNone lub CMFCDynamicLayout::MoveHorizontalAndVertical. Należy przekazać wartość procentową dla aspektów ruchu poziomego i/lub pionowego. Te metody statyczne zwracają nowo utworzony obiekt Move Ustawienia którego można użyć do określenia zachowania przenoszenia kontrolki.

Należy pamiętać, że 100 oznacza przejście dokładnie tak samo, jak zmienia rozmiar okna dialogowego, co powoduje, że krawędź kontrolki pozostanie stałą odległość od nowego obramowania.
```
MoveSettings moveSettings = CMFCDynamicLayout::MoveHorizontal(100);
```
Wykonaj to samo w przypadku zachowania rozmiaru, które używa typu Size Ustawienia. Aby na przykład określić, że kontrolka nie zmienia rozmiaru po zmianie rozmiaru okna dialogowego, użyj następującego kodu:
```
SizeSettings sizeSettings = CMFCDynamicLayout::SizeNone();
```
Dodaj kontrolkę do menedżera układu dynamicznego przy użyciu metody CMFCDynamicLayout::AddItem . Istnieją dwa przeciążenia dla różnych sposobów określania żądanej kontrolki. Jeden przyjmuje uchwyt okna kontrolki (HWND), a drugi przejmuje identyfikator kontrolki.
```
dynamicLayout->AddItem(hWndControl,
moveSettings,
sizeSettings);
```
Powtórz dla każdej kontrolki, która musi zostać przeniesiona lub zmieniona.
W razie potrzeby można użyć metody CMFCDynamicLayout::HasItem , aby określić, czy kontrolka znajduje się już na liście kontrolek podlegających zmianom układu dynamicznego, lub metody CMFCDynamicLayout::IsEmpty , aby określić, czy istnieją kontrolki, które podlegają zmianom.
Aby włączyć układ okna dialogowego, wywołaj metodę CWnd::EnableDynamicLayout .
```
pDialog->EnableDynamicLayout(TRUE);
```
Następnym razem, gdy użytkownik zmienia rozmiar okna dialogowego, wywoływana jest metoda CMFCDynamicLayout::Adjust , która faktycznie stosuje ustawienia.
Jeśli chcesz wyłączyć układ dynamiczny, wywołaj metodę CWnd::EnableDynamicLayout z wartością FALSE jako parametru bEnabled .
```
pDialog->EnableDynamicLayout(FALSE);
```

Aby programowo ustawić układ dynamiczny z pliku zasobu

Użyj metody CMFCDynamicLayout::MoveHorizontalAndVertical, aby określić nazwę zasobu w odpowiednim pliku skryptu zasobu (plik rc), który określa informacje o układzie dynamicznym, jak w poniższym przykładzie:
```
dynamicLayout->LoadResource("IDD_DIALOG1");
```
Nazwany zasób musi odwoływać się do okna dialogowego zawierającego informacje o układzie w postaci wpisu AFX_DIALOG_LAYOUT w pliku zasobu, jak w poniższym przykładzie:
```
/////////////////////////////////////////////////////////////////////////////
//
// 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
```

Zobacz też

Klasa CMFCDynamicLayout
Klasy kontrolek
Klasy okien dialogowych
Edytor okien dialogowych
Dynamiczny układ okna dialogowego dla MFC w programie Visual C++ 2015