Fensterfeatures

  • Artikel

In dieser Übersicht werden Features von Fenstern wie Fenstertypen, Zustände, Größe und Position erläutert.

Fenstertypen

Dieser Abschnitt enthält die folgenden Themen, in denen Fenstertypen beschrieben werden.

Überlappende Fenster

Ein überlappenes Fenster ist ein Fenster auf oberster Ebene (nicht untergeordnetes Fenster), das über eine Titelleiste, einen Rahmen und einen Clientbereich verfügt. Sie dient als Standard Fenster einer Anwendung. Es kann auch über ein Fenstermenü, das Minimieren und Maximieren von Schaltflächen und Bildlaufleisten verfügen. Ein überlappende Fenster, das als Standard Fenster verwendet wird, enthält in der Regel alle diese Komponenten.

Durch Angeben des WS_OVERLAPPED oder WS_OVERLAPPEDWINDOW Stils in der CreateWindowEx-Funktion erstellt eine Anwendung ein überlappende Fenster. Wenn Sie die WS_OVERLAPPED Formatvorlage verwenden, verfügt das Fenster über eine Titelleiste und einen Rahmen. Wenn Sie die WS_OVERLAPPEDWINDOW Formatvorlage verwenden, verfügt das Fenster über eine Titelleiste, einen Größenrahmen, ein Fenstermenü sowie Schaltflächen zum Minimieren und Maximieren.

Popupfenster

Ein Popupfenster ist ein spezieller Typ von überlappendem Fenster, das für Dialogfelder, Meldungsfelder und andere temporäre Fenster verwendet wird, die außerhalb des Standard Fensters einer Anwendung angezeigt werden. Titelleisten sind für Popupfenster optional. Andernfalls sind Popupfenster identisch mit überlappenden Fenstern des WS_OVERLAPPED Stils.

Sie erstellen ein Popupfenster, indem Sie die WS_POPUP-Formatvorlage in CreateWindowEx angeben. Um eine Titelleiste einzuschließen, geben Sie die WS_CAPTION Formatvorlage an. Verwenden Sie die WS_POPUPWINDOW Stil, um ein Popupfenster mit einem Rahmen und einem Fenstermenü zu erstellen. Die WS_CAPTION-Formatvorlage muss mit der WS_POPUPWINDOW-Formatvorlage kombiniert werden, um das Fenstermenü sichtbar zu machen.

Untergeordnete Fenster

Ein untergeordnetes Fenster weist die WS_CHILD Stil auf und ist auf den Clientbereich des übergeordneten Fensters beschränkt. Eine Anwendung verwendet in der Regel untergeordnete Fenster, um den Clientbereich eines übergeordneten Fensters in Funktionsbereiche zu unterteilen. Sie erstellen ein untergeordnetes Fenster, indem Sie die WS_CHILD in der CreateWindowEx-Funktion angeben.

Ein untergeordnetes Fenster muss über ein übergeordnetes Fenster verfügen. Das übergeordnete Fenster kann ein überlappende Fenster, ein Popupfenster oder sogar ein anderes untergeordnetes Fenster sein. Sie geben das übergeordnete Fenster an, wenn Sie CreateWindowEx aufrufen. Wenn Sie in CreateWindowEx die WS_CHILD Formatvorlage angeben, aber kein übergeordnetes Fenster angeben, erstellt das System das Fenster nicht.

Ein untergeordnetes Fenster verfügt über einen Clientbereich, aber keine anderen Features, es sei denn, sie werden explizit angefordert. Eine Anwendung kann eine Titelleiste, ein Fenstermenü, Schaltflächen zum Minimieren und Maximieren, einen Rahmen und Bildlaufleisten für ein untergeordnetes Fenster anfordern, aber ein untergeordnetes Fenster kann kein Menü haben. Wenn die Anwendung ein Menühandle angibt, wenn sie entweder die untergeordnete Fensterklasse registriert oder das untergeordnete Fenster erstellt, wird das Menühandle ignoriert. Wenn kein Rahmenformat angegeben wird, erstellt das System ein rahmenloses Fenster. Eine Anwendung kann rahmenlose untergeordnete Fenster verwenden, um den Clientbereich eines übergeordneten Fensters zu teilen, während die Divisionen für den Benutzer unsichtbar bleiben.

In diesem Abschnitt werden die folgenden Aspekte untergeordneter Fenster erläutert:

Positionierung

Das System positioniert ein untergeordnetes Fenster immer relativ zur oberen linken Ecke des Clientbereichs des übergeordneten Fensters. Kein Teil eines untergeordneten Fensters wird jemals außerhalb der Rahmen des übergeordneten Fensters angezeigt. Wenn eine Anwendung ein untergeordnetes Fenster erstellt, das größer als das übergeordnete Fenster ist oder ein untergeordnetes Fenster positioniert, sodass ein Teil oder das gesamte untergeordnete Fenster über die Rahmen des übergeordneten Fensters hinaus reicht, schneidet das System das untergeordnete Fenster ab; Das heißt, der Teil außerhalb des Clientbereichs des übergeordneten Fensters wird nicht angezeigt. Aktionen, die sich auf das übergeordnete Fenster auswirken, können sich wie folgt auch auf das untergeordnete Fenster auswirken.

Übergeordnetes Fenster Untergeordnetes Fenster
Wird zerstört Zerstört, bevor das übergeordnete Fenster zerstört wird.
Ausgeblendet Ausgeblendet, bevor das übergeordnete Fenster ausgeblendet wird. Ein untergeordnetes Fenster ist nur sichtbar, wenn das übergeordnete Fenster sichtbar ist.
Verschoben Wird mit dem Clientbereich des übergeordneten Fensters verschoben. Das untergeordnete Fenster ist für das Zeichnen des Clientbereichs nach dem Verschieben verantwortlich.
Angezeigt Wird angezeigt, nachdem das übergeordnete Fenster angezeigt wurde.

 

Freistellen

Das System klammert nicht automatisch ein untergeordnetes Fenster aus dem Clientbereich des übergeordneten Fensters ab. Dies bedeutet, dass das übergeordnete Fenster über das untergeordnete Fenster gezeichnet wird, wenn es eine Zeichnung an derselben Position wie das untergeordnete Fenster ausführt. Das System klammert jedoch das untergeordnete Fenster aus dem Clientbereich des übergeordneten Fensters ab, wenn das übergeordnete Fenster den WS_CLIPCHILDREN Stil aufweist. Wenn das untergeordnete Fenster beschnitten ist, kann das übergeordnete Fenster nicht darüber zeichnen.

Ein untergeordnetes Fenster kann andere untergeordnete Fenster im selben Clientbereich überlappen. Ein untergeordnetes Fenster, das dasselbe übergeordnete Fenster wie mindestens ein anderes untergeordnetes Fenster verwendet, wird als gleichgeordnetes Fenster bezeichnet. Gleichgeordnete Fenster können sich gegenseitig im Clientbereich des anderen zeichnen, es sei denn, eines der untergeordneten Fenster weist den WS_CLIPSIBLINGS Stil auf. Wenn ein untergeordnetes Fenster diese Formatvorlage aufweist, wird jeder Teil des gleichgeordneten Fensters, der sich innerhalb des untergeordneten Fensters befindet, abgeschnitten.

Wenn ein Fenster entweder die WS_CLIPCHILDREN oder WS_CLIPSIBLINGS hat, tritt ein leichter Leistungsverlust auf. Jedes Fenster nimmt Systemressourcen in Anspruch, sodass eine Anwendung untergeordnete Fenster nicht wahllos verwenden sollte. Um eine optimale Leistung zu erzielen, sollte eine Anwendung, die ihr Standard Fenster logisch aufteilen muss, dies in der Fensterprozedur des Standard-Fensters tun, anstatt untergeordnete Fenster zu verwenden.

Beziehung zum übergeordneten Fenster

Eine Anwendung kann das übergeordnete Fenster eines vorhandenen untergeordneten Fensters ändern, indem die SetParent-Funktion aufgerufen wird. In diesem Fall entfernt das System das untergeordnete Fenster aus dem Clientbereich des alten übergeordneten Fensters und verschiebt es in den Clientbereich des neuen übergeordneten Fensters. Wenn SetParent ein NULL-Handle angibt, wird das Desktopfenster zum neuen übergeordneten Fenster. In diesem Fall wird das untergeordnete Fenster auf dem Desktop außerhalb der Rahmen eines anderen Fensters gezeichnet. Die GetParent-Funktion ruft ein Handle für das übergeordnete Fenster eines untergeordneten Fensters ab.

Das übergeordnete Fenster übergibt einen Teil seines Clientbereichs an ein untergeordnetes Fenster, und das untergeordnete Fenster empfängt alle Eingaben aus diesem Bereich. Die Fensterklasse muss nicht für jedes der untergeordneten Fenster des übergeordneten Fensters identisch sein. Dies bedeutet, dass eine Anwendung ein übergeordnetes Fenster mit untergeordneten Fenstern füllen kann, die unterschiedlich aussehen und unterschiedliche Aufgaben ausführen. Beispielsweise kann ein Dialogfeld viele Arten von Steuerelementen enthalten, jedes ein untergeordnetes Fenster, das verschiedene Datentypen vom Benutzer akzeptiert.

Ein untergeordnetes Fenster hat nur ein übergeordnetes Fenster, aber ein übergeordnetes Fenster kann eine beliebige Anzahl von untergeordneten Fenstern haben. Jedes untergeordnete Fenster wiederum kann untergeordnete Fenster haben. In dieser Fensterkette wird jedes untergeordnete Fenster als Nachfolgerfenster des ursprünglichen übergeordneten Fensters bezeichnet. Eine Anwendung verwendet die IsChild-Funktion , um zu ermitteln, ob ein bestimmtes Fenster ein untergeordnetes Fenster oder ein Nachfolgerfenster eines bestimmten übergeordneten Fensters ist.

Die EnumChildWindows-Funktion listet die untergeordneten Fenster eines übergeordneten Fensters auf. Anschließend übergibt EnumChildWindows das Handle an jedes untergeordnete Fenster an eine anwendungsdefinierte Rückruffunktion. Nachfolgerfenster des angegebenen übergeordneten Fensters werden ebenfalls aufgezählt.

Nachrichten

Das System übergibt die Eingabenachrichten eines untergeordneten Fensters direkt an das untergeordnete Fenster. die Nachrichten werden nicht über das übergeordnete Fenster übergeben. Die einzige Ausnahme ist, wenn das untergeordnete Fenster durch die EnableWindow-Funktion deaktiviert wurde. In diesem Fall übergibt das System alle Eingabemeldungen, die in das untergeordnete Fenster gegangen wären, stattdessen an das übergeordnete Fenster. Dadurch kann das übergeordnete Fenster die Eingabemeldungen untersuchen und ggf. das untergeordnete Fenster aktivieren.

Ein untergeordnetes Fenster kann über einen eindeutigen ganzzahligen Bezeichner verfügen. Untergeordnete Fensterbezeichner sind wichtig, wenn Sie mit Steuerfenstern arbeiten. Eine Anwendung leitet die Aktivität eines Steuerelements durch Senden von Nachrichten an. Die Anwendung verwendet den untergeordneten Fensterbezeichner des Steuerelements, um die Nachrichten an das Steuerelement weiterzuleiten. Darüber hinaus sendet ein Steuerelement Benachrichtigungen an das übergeordnete Fenster. Eine Benachrichtigung enthält den bezeichner des untergeordneten Fensters des Steuerelements, den das übergeordnete Element verwendet, um zu identifizieren, welches Steuerelement die Nachricht gesendet hat. Eine Anwendung gibt den Bezeichner für untergeordnete Fenster für andere Typen von untergeordneten Fenstern an, indem der hMenu-Parameter der CreateWindowEx-Funktion auf einen Wert anstelle eines Menühandles festgelegt wird.

Mehrschichtige Fenster

Die Verwendung eines mehrstufigen Fensters kann die Leistung und die visuellen Effekte für ein Fenster erheblich verbessern, das eine komplexe Form aufweist, seine Form animiert oder Alphamischungseffekte verwenden möchte. Das System erstellt und übermalt automatisch mehrstufige Fenster und die Fenster der zugrunde liegenden Anwendungen. Als Ergebnis werden mehrstufige Fenster reibungslos gerendert, ohne das typische Flimmern komplexer Fensterbereiche. Darüber hinaus können mehrschichtige Fenster teilweise durchscheinend, d. h. alpha-gemischt sein.

Um ein mehrschichtiges Fenster zu erstellen, geben Sie beim Aufrufen der CreateWindowEx-Funktion die WS_EX_LAYERED erweiterten Fensterstil an, oder rufen Sie die SetWindowLong-Funktion auf, um WS_EX_LAYERED festzulegen, nachdem das Fenster erstellt wurde. Nach dem CreateWindowEx-Aufruf wird das mehrstufige Fenster erst sichtbar, wenn die Funktion SetLayeredWindowAttributes oder UpdateLayeredWindow für dieses Fenster aufgerufen wurde.

Hinweis

Ab Windows 8 kann WS_EX_LAYERED mit untergeordneten Fenstern und Fenstern der obersten Ebene verwendet werden. Frühere Windows-Versionen unterstützen WS_EX_LAYERED nur für Fenster der obersten Ebene.

 

Um die Deckkraftstufe oder den Transparenzfarbschlüssel für ein bestimmtes mehrstufiges Fenster festzulegen, rufen Sie SetLayeredWindowAttributes auf. Nach dem Aufruf fordert das System das Fenster möglicherweise weiterhin auf, zu malen, wenn das Fenster angezeigt oder die Größe geändert wird. Da das System jedoch das Bild eines mehrschichtigen Fensters speichert, fordert das System das Fenster nicht auf, zu zeichnen, wenn Teile davon aufgrund relativer Fensterverschiebungen auf dem Desktop angezeigt werden. Ältere Anwendungen müssen ihren Malcode nicht neu strukturieren, wenn sie Transluzenz- oder Transparenzeffekte für ein Fenster hinzufügen möchten, da das System das Zeichnen von Fenstern, die SetLayeredWindowAttributes aufgerufen haben, in off-screen-Arbeitsspeicher umleitet und neu kompensiert, um den gewünschten Effekt zu erzielen.

Rufen Sie UpdateLayeredWindow auf, um eine schnellere und effizientere Animation zu erzielen oder wenn ein Alpha pro Pixel benötigt wird. UpdateLayeredWindow sollte in erster Linie verwendet werden, wenn die Anwendung die Form und den Inhalt eines mehrschichtigen Fensters direkt bereitstellen muss, ohne den Umleitungsmechanismus zu verwenden, den das System über SetLayeredWindowAttributes bereitstellt. Darüber hinaus wird durch die direkte Verwendung von UpdateLayeredWindow der Arbeitsspeicher effizienter genutzt, da das System nicht den zusätzlichen Arbeitsspeicher benötigt, der zum Speichern des Images des umgeleiteten Fensters erforderlich ist. Um maximale Effizienz beim Animieren von Fenstern zu erzielen, rufen Sie UpdateLayeredWindow auf, um die Position und Größe eines mehrstufigen Fensters zu ändern. Beachten Sie, dass nach dem Aufruf von SetLayeredWindowAttributes nachfolgende UpdateLayeredWindow-Aufrufe fehlschlagen, bis das Layeringstilbit gelöscht und erneut festgelegt wird.

Der Treffertest eines mehrschichtigen Fensters basiert auf der Form und Transparenz des Fensters. Dies bedeutet, dass die Bereiche des Fensters, die mit Farbschlüssel versehen sind oder deren Alphawert 0 ist, die Mausnachrichten durchlassen. Wenn das mehrschichtige Fenster jedoch den WS_EX_TRANSPARENT erweiterten Fensterstil aufweist, wird die Form des mehrschichtigen Fensters ignoriert, und die Mausereignisse werden an andere Fenster unterhalb des mehrstufigen Fensters übergeben.

Message-Only Windows

In einem Fenster mit nur Nachrichten können Sie Nachrichten senden und empfangen. Sie ist nicht sichtbar, weist keine Z-Reihenfolge auf, kann nicht aufgezählt werden und empfängt keine Broadcastnachrichten. Das Fenster sendet einfach Nachrichten.

Geben Sie zum Erstellen eines Meldungsfensters im Parameter hWndParent der CreateWindowEx-Funktion die HWND_MESSAGE-Konstante oder ein Handle für ein vorhandenes Meldungsfenster an. Sie können ein vorhandenes Fenster auch in ein reines Nachrichtenfenster ändern, indem Sie HWND_MESSAGE im Parameter hWndNewParent der SetParent-Funktion angeben.

Geben Sie HWND_MESSAGE im hwndParent-Parameter der FindWindowEx-Funktion an, um nur Nachrichtenfenster zu finden. Darüber hinaus durchsucht FindWindowEx Nur-Nachrichtenfenster sowie Fenster der obersten Ebene, wenn sowohl die Parameter hwndParent als auch hwndChildAfterNULL sind.

Fensterbeziehungen

Es gibt viele Möglichkeiten, wie ein Fenster sich auf den Benutzer oder ein anderes Fenster beziehen kann. Ein Fenster kann ein eigenes Fenster, ein Vordergrundfenster oder ein Hintergrundfenster sein. Ein Fenster hat auch eine Z-Reihenfolge im Vergleich zu anderen Fenstern. Weitere Informationen finden Sie in den folgenden Themen:

Vordergrund- und Hintergrundfenster

Jeder Prozess kann über mehrere Ausführungsthreads verfügen, und jeder Thread kann Fenster erstellen. Der Thread, der das Fenster erstellt hat, mit dem der Benutzer gerade arbeitet, wird als Vordergrundthread bezeichnet, und das Fenster wird als Vordergrundfenster bezeichnet. Alle anderen Threads sind Hintergrundthreads, und die von Hintergrundthreads erstellten Fenster werden als Hintergrundfenster bezeichnet.

Jeder Thread verfügt über eine Prioritätsebene, die die CPU-Zeit bestimmt, die der Thread empfängt. Obwohl eine Anwendung die Prioritätsebene ihrer Threads festlegen kann, hat der Vordergrundthread normalerweise eine etwas höhere Prioritätsebene als die Hintergrundthreads. Da er eine höhere Priorität hat, erhält der Vordergrundthread mehr CPU-Zeit als die Hintergrundthreads. Der Vordergrundthread hat eine normale Basispriorität von 9; Ein Hintergrundthread hat eine normale Basispriorität von 7.

Der Benutzer legt das Vordergrundfenster fest, indem er auf ein Fenster klickt oder die Tastenkombination ALT+TAB oder ALT+ESC verwendet. Verwenden Sie die GetForegroundWindow-Funktion , um ein Handle für das Vordergrundfenster abzurufen. Um zu überprüfen, ob das Anwendungsfenster das Vordergrundfenster ist, vergleichen Sie das von GetForegroundWindow zurückgegebene Handle mit dem Ihres Anwendungsfensters.

Eine Anwendung legt das Vordergrundfenster mithilfe der SetForegroundWindow-Funktion fest.

Das System schränkt ein, welche Prozesse das Vordergrundfenster festlegen können. Ein Prozess kann das Vordergrundfenster nur dann festlegen, wenn:

  • Alle folgenden Bedingungen sind erfüllt:
    • Der Prozess, der SetForegroundWindow aufruft, gehört zu einer Desktopanwendung, nicht zu einer UWP-App oder einer Windows Store-App, die für Windows 8 oder 8.1 entwickelt wurde.
    • Der Vordergrundprozess hat Aufrufe von SetForegroundWindow durch einen vorherigen Aufruf der LockSetForegroundWindow-Funktion nicht deaktiviert.
    • Das Timeout für die Vordergrundsperre ist abgelaufen (siehe SPI_GETFOREGROUNDLOCKTIMEOUT in SystemParametersInfo).
    • Es sind keine Menüs aktiv.
  • Darüber hinaus gilt mindestens eine der folgenden Bedingungen:
    • Der aufrufende Prozess ist der Vordergrundprozess.
    • Der aufrufende Prozess wurde vom Vordergrundprozess gestartet.
    • Es gibt derzeit kein Vordergrundfenster und somit keinen Vordergrundprozess.
    • Der aufrufende Prozess hat das letzte Eingabeereignis empfangen.
    • Entweder der Vordergrundprozess oder der aufrufende Prozess wird debuggt.

Es ist möglich, dass einem Prozess das Recht zum Festlegen des Vordergrundfensters verweigert wird, auch wenn er diese Bedingungen erfüllt.

Ein Prozess, der das Vordergrundfenster festlegen kann, kann es einem anderen Prozess ermöglichen, das Vordergrundfenster festzulegen, indem er die AllowSetForegroundWindow-Funktion aufruft oder die BroadcastSystemMessage-Funktion mit dem flag BSF_ALLOWSFW aufruft. Der Vordergrundprozess kann Aufrufe von SetForegroundWindow deaktivieren, indem die LockSetForegroundWindow-Funktion aufgerufen wird .

Eigenes Windows

Ein überlappende Fenster oder Popupfenster kann sich im Besitz eines anderen überlappenden Fensters oder Popupfensters befinden. Wenn sie sich im Besitz befinden, werden mehrere Einschränkungen für ein Fenster gesetzt.

  • Ein eigenes Fenster liegt immer über seinem Besitzer in der Z-Reihenfolge.
  • Das System zerstört automatisch ein eigenes Fenster, wenn sein Besitzer zerstört wird.
  • Ein eigenes Fenster wird ausgeblendet, wenn der Besitzer minimiert wird.

Nur ein überlappende oder Popupfenster kann ein Besitzerfenster sein. Ein untergeordnetes Fenster kann kein Besitzerfenster sein. Eine Anwendung erstellt ein eigenes Fenster, indem sie das Fensterhandle des Besitzers als hwndParent-Parameter von CreateWindowEx angibt, wenn sie ein Fenster mit der WS_OVERLAPPED - oder WS_POPUP-Format erstellt. Der hwndParent-Parameter muss ein überlappende oder Popupfenster identifizieren. Wenn hwndParent ein untergeordnetes Fenster identifiziert, weist das System dem übergeordneten Fenster der obersten Ebene des untergeordneten Fensters den Besitz zu. Nach dem Erstellen eines eigenen Fensters kann eine Anwendung den Besitz des Fensters nicht auf ein anderes Fenster übertragen.

Dialogfelder und Meldungsfelder gehören standardmäßig Fenster. Eine Anwendung gibt das Besitzerfenster an, wenn eine Funktion aufgerufen wird, die ein Dialogfeld oder Meldungsfeld erstellt.

Eine Anwendung kann die GetWindow-Funktion mit dem flag GW_OWNER verwenden, um ein Handle an den Besitzer eines Fensters abzurufen.

Z-Reihenfolge

Die Z-Reihenfolge eines Fensters gibt die Position des Fensters in einem Stapel überlappender Fenster an. Dieser Fensterstapel ist entlang einer imaginären Achse, der Z-Achse, ausgerichtet, die sich vom Bildschirm nach außen erstreckt. Das Fenster oben in der z-Reihenfolge überlappt alle anderen Fenster. Das Fenster am unteren Rand der Z-Reihenfolge ist mit allen anderen Fenstern überlappend.

Das System verwaltet die Z-Reihenfolge in einer einzigen Liste. Es fügt Fenster zur Z-Reihenfolge hinzu, je nachdem, ob es sich um Fenster auf oberster Ebene, Fenster der obersten Ebene oder untergeordnete Fenster handelt. Ein oberstes Fenster überlappt alle anderen Fenster, die nicht oberste Fenster sind, unabhängig davon, ob es sich um das aktive fenster oder das Vordergrundfenster handelt. Ein oberstes Fenster weist den WS_EX_TOPMOST Stil auf. Alle obersten Fenster werden in der Z-Reihenfolge vor allen Fenstern angezeigt, die nicht oberste Fenster sind. Ein untergeordnetes Fenster wird mit dem übergeordneten Fenster in z-Reihenfolge gruppiert.

Wenn eine Anwendung ein Fenster erstellt, platziert das System es an der Spitze der Z-Reihenfolge für Fenster desselben Typs. Sie können die BringWindowToTop-Funktion verwenden, um ein Fenster an den Anfang der Z-Reihenfolge für Fenster desselben Typs zu bringen. Sie können die Z-Reihenfolge mithilfe der Funktionen SetWindowPos und DeferWindowPos neu anordnen.

Der Benutzer ändert die Z-Reihenfolge, indem er ein anderes Fenster aktiviert. Das System positioniert das aktive Fenster an der Spitze der Z-Reihenfolge für Fenster desselben Typs. Wenn ein Fenster an den Anfang der Z-Reihenfolge kommt, tun dies auch seine untergeordneten Fenster. Sie können die GetTopWindow-Funktion verwenden, um alle untergeordneten Fenster eines übergeordneten Fensters zu durchsuchen und ein Handle an das untergeordnete Fenster zurückzugeben, das in Z-Reihenfolge am höchsten ist. Die GetNextWindow-Funktion ruft ein Handle zum nächsten oder vorherigen Fenster in Z-Reihenfolge ab.

Fenster "Status anzeigen"

Zu einem bestimmten Zeitpunkt kann ein Fenster aktiv oder inaktiv sein. ausgeblendet oder sichtbar; und minimiert, maximiert oder wiederhergestellt. Diese Qualitäten werden zusammen als Fensteranzeigezustand bezeichnet. In den folgenden Themen wird der Status des Fensters erläutert:

Aktives Fenster

Ein aktives Fenster ist das Fenster der obersten Ebene der Anwendung, mit der der Benutzer gerade arbeitet. Damit der Benutzer das aktive Fenster leicht identifizieren kann, platziert das System es oben in der Z-Reihenfolge und ändert die Farbe der Titelleiste und des Rahmens in die systemdefiniert aktiven Fensterfarben. Nur ein Fenster der obersten Ebene kann ein aktives Fenster sein. Wenn der Benutzer mit einem untergeordneten Fenster arbeitet, aktiviert das System das übergeordnete Fenster der obersten Ebene, das dem untergeordneten Fenster zugeordnet ist.

Nur ein Fenster der obersten Ebene im System ist gleichzeitig aktiv. Der Benutzer aktiviert ein Fenster auf oberster Ebene, indem er darauf (oder eines seiner untergeordneten Fenster) klickt oder die Tastenkombination ALT+ESC oder ALT+TAB verwendet. Eine Anwendung aktiviert ein Fenster der obersten Ebene, indem die SetActiveWindow-Funktion aufgerufen wird . Andere Funktionen können dazu führen, dass das System ein anderes Fenster der obersten Ebene aktiviert, einschließlich SetWindowPos, DeferWindowPos, SetWindowPlacement und DestroyWindow. Obwohl eine Anwendung jederzeit ein anderes Fenster auf oberster Ebene aktivieren kann, sollte sie dies nur als Reaktion auf eine Benutzeraktion tun, um die Benutzer zu verwirren. Eine Anwendung verwendet die GetActiveWindow-Funktion , um ein Handle für das aktive Fenster abzurufen.

Wenn sich die Aktivierung von einem Fenster auf oberster Ebene einer Anwendung in das Fenster der obersten Ebene einer anderen ändert, sendet das System eine WM_ACTIVATEAPP Nachricht an beide Anwendungen und benachrichtigt sie über die Änderung. Wenn sich die Aktivierung in ein anderes Fenster auf oberster Ebene in derselben Anwendung ändert, sendet das System beide Fenster eine WM_ACTIVATE Meldung.

Windows deaktiviert

Ein Fenster kann deaktiviert werden. Ein deaktiviertes Fenster empfängt keine Tastatur- oder Mauseingaben vom Benutzer, kann aber Nachrichten von anderen Fenstern, von anderen Anwendungen und vom System empfangen. Eine Anwendung deaktiviert in der Regel ein Fenster, um zu verhindern, dass der Benutzer das Fenster verwendet. Beispielsweise kann eine Anwendung eine Drucktaste in einem Dialogfeld deaktivieren, um zu verhindern, dass der Benutzer sie auswählen kann. Eine Anwendung kann jederzeit ein deaktiviertes Fenster aktivieren. Durch aktivieren eines Fensters wird die normale Eingabe wiederhergestellt.

Standardmäßig ist ein Fenster beim Erstellen aktiviert. Eine Anwendung kann jedoch die WS_DISABLED Formatvorlage angeben, um ein neues Fenster zu deaktivieren. Eine Anwendung aktiviert oder deaktiviert ein vorhandenes Fenster mithilfe der EnableWindow-Funktion . Das System sendet eine WM_ENABLE-Nachricht an ein Fenster, wenn sich der aktivierte Zustand ändert. Eine Anwendung kann mithilfe der IsWindowEnabled-Funktion bestimmen, ob ein Fenster aktiviert ist.

Wenn ein untergeordnetes Fenster deaktiviert ist, übergibt das System die Mauseingabenachrichten des untergeordneten Elements an das übergeordnete Fenster. Das übergeordnete Element bestimmt anhand der Nachrichten, ob das untergeordnete Fenster aktiviert werden soll. Weitere Informationen finden Sie unter Mauseingabe.

Tastatureingaben können jeweils nur von einem Fenster empfangen werden. Dieses Fenster soll den Tastaturfokus haben. Wenn eine Anwendung die EnableWindow-Funktion verwendet, um ein Tastaturfokusfenster zu deaktivieren, verliert das Fenster zusätzlich zum Deaktivieren den Tastaturfokus. EnableWindow legt dann den Tastaturfokus auf NULL fest, d. h. kein Fenster hat den Fokus. Wenn ein untergeordnetes Fenster oder ein anderes untergeordnetes Fenster den Tastaturfokus hat, verliert das Nachfolgerfenster den Fokus, wenn das übergeordnete Fenster deaktiviert ist. Weitere Informationen finden Sie unter Tastatureingabe.

Fenstersichtbarkeit

Ein Fenster kann sichtbar oder ausgeblendet sein. Das System zeigt ein sichtbares Fenster auf dem Bildschirm an. Es blendet ein ausgeblendetes Fenster aus, indem es nicht gezeichnet wird. Wenn das Fenster sichtbar ist, kann der Benutzer im Fenster Eingaben vornehmen und sich die Fensterausgabe anzeigen lassen. Ein ausgeblendetes Fenster ist deaktiviert. Ein ausgeblendetes Fenster kann zwar Meldungen vom System oder anderen Fenstern verarbeiten, kann jedoch keine Benutzereingaben verarbeiten oder Ausgaben anzeigen. Eine Anwendung legt den Sichtbarkeitsstatus eines Fensters beim Erstellen des Fensters fest. Später kann die Anwendung den Sichtbarkeitsstatus ändern.

Ein Fenster ist sichtbar, wenn die WS_VISIBLE-Formatvorlage für das Fenster festgelegt ist. Standardmäßig erstellt die CreateWindowEx-Funktion ein ausgeblendetes Fenster, es sei denn, die Anwendung gibt den WS_VISIBLE Stil an. In der Regel legt eine Anwendung den WS_VISIBLE Stil fest, nachdem sie ein Fenster erstellt hat, um Details zum Erstellungsprozess für den Benutzer ausgeblendet zu halten. Beispielsweise kann eine Anwendung ein neues Fenster ausgeblendet lassen, während sie das Erscheinungsbild des Fensters anpasst. Wenn die WS_VISIBLE-Formatvorlage in CreateWindowEx angegeben ist, sendet das System die WM_SHOWWINDOW-Meldung an das Fenster, nachdem das Fenster erstellt wurde, aber bevor es angezeigt wird.

Eine Anwendung kann mithilfe der IsWindowVisible-Funktion bestimmen, ob ein Fenster sichtbar ist. Eine Anwendung kann ein Fenster mithilfe der Funktion ShowWindow,SetWindowPos, DeferWindowPos, SetWindowPlacement oder SetWindowLong anzeigen (sichtbar machen) oder ausblenden. Mit diesen Funktionen wird ein Fenster angezeigt oder ausgeblendet, indem sie die WS_VISIBLE Formatvorlage für das Fenster festlegen oder entfernen. Außerdem senden sie die WM_SHOWWINDOW Nachricht an das Fenster, bevor sie angezeigt oder ausgeblendet wird.

Wenn ein Besitzerfenster minimiert wird, blendet das System automatisch die zugeordneten eigenen Fenster aus. Ebenso zeigt das System bei der Wiederherstellung eines Besitzerfensters automatisch die zugeordneten eigenen Fenster an. In beiden Fällen sendet das System die WM_SHOWWINDOW-Nachricht an die eigenen Fenster, bevor sie ausgeblendet oder angezeigt werden. Gelegentlich muss eine Anwendung die eigenen Fenster ausblenden, ohne den Besitzer minimieren oder ausblenden zu müssen. In diesem Fall verwendet die Anwendung die ShowOwnedPopups-Funktion . Diese Funktion legt den WS_VISIBLE Stil für alle eigenen Fenster fest oder entfernt sie und sendet die WM_SHOWWINDOW Nachricht an die eigenen Fenster, bevor sie ausgeblendet oder angezeigt werden. Das Ausblenden eines Besitzerfensters hat keine Auswirkungen auf den Sichtbarkeitsstatus der eigenen Fenster.

Wenn ein übergeordnetes Fenster sichtbar ist, sind auch die zugehörigen untergeordneten Fenster sichtbar. Wenn das übergeordnete Fenster ausgeblendet ist, werden die untergeordneten Fenster ebenfalls ausgeblendet. Das Minimieren des übergeordneten Fensters hat keine Auswirkungen auf den Sichtbarkeitszustand der untergeordneten Fenster. Das heißt, die untergeordneten Fenster werden zusammen mit dem übergeordneten Fenster minimiert, aber die WS_VISIBLE Stil wird nicht geändert.

Selbst wenn ein Fenster den WS_VISIBLE Stil aufweist, kann der Benutzer das Fenster möglicherweise nicht auf dem Bildschirm sehen. Andere Fenster können es vollständig überlappen oder es wurde über den Bildschirmrand verschoben. Außerdem unterliegt ein sichtbares untergeordnetes Fenster den Beschneidungsregeln, die von seiner Über-/Untergeordneten Beziehung festgelegt werden. Wenn das übergeordnete Fenster des Fensters nicht sichtbar ist, ist es auch nicht sichtbar. Wenn sich das übergeordnete Fenster über den Bildschirmrand hinaus bewegt, wird auch das untergeordnete Fenster verschoben, da ein untergeordnetes Fenster relativ zur oberen linken Ecke des übergeordneten Fensters gezeichnet wird. Beispielsweise kann ein Benutzer das übergeordnete Fenster mit dem untergeordneten Fenster so weit vom Bildschirmrand verschieben, dass der Benutzer das untergeordnete Fenster möglicherweise nicht sehen kann, obwohl das untergeordnete Fenster und das übergeordnete Fenster beide das WS_VISIBLE Format aufweisen.

Minimierte, maximierte und wiederhergestellte Windows-Fenster

Ein maximiertes Fenster ist ein Fenster mit dem WS_MAXIMIZE Stil. In der Standardeinstellung wird ein maximiertes Fenster so vergrößert, dass es den Bildschirm oder, im Fall eines untergeordneten Fensters, den Clientbereich des übergeordneten Fensters ausfüllt. Obwohl die Größe eines Fensters auf die gleiche Größe wie ein maximiertes Fenster festgelegt werden kann, unterscheidet sich ein maximiertes Fenster geringfügig. Das System verschiebt die Titelleiste des Fensters automatisch an den oberen Rand des Bildschirms oder an den oberen Rand des Clientbereichs des übergeordneten Fensters. Außerdem deaktiviert das System den Größenrahmen des Fensters und die Fensterpositionierungsfunktion der Titelleiste (sodass der Benutzer das Fenster nicht durch Ziehen der Titelleiste verschieben kann).

Ein minimiertes Fenster ist ein Fenster mit dem WS_MINIMIZE Stil. In der Standardeinstellung wird ein minimiertes Fenster auf die Größe seiner Schaltfläche auf der Taskleiste verkleinert und auf die Taskleiste verschoben. Ein wiederhergestelltes Fenster ist ein Fenster, das auf seine vorherige Größe und Position zurückgegeben wurde, d. h. die Größe, die es hatte, bevor es minimiert oder maximiert wurde.

Wenn eine Anwendung den WS_MAXIMIZE oder WS_MINIMIZE Stil in der CreateWindowEx-Funktion angibt, wird das Fenster zunächst maximiert oder minimiert. Nach dem Erstellen eines Fensters kann eine Anwendung die CloseWindow-Funktion verwenden, um das Fenster zu minimieren. Die ArrangeIconicWindows-Funktion ordnet die Symbole auf dem Desktop an, oder sie ordnet die minimierten untergeordneten Fenster eines übergeordneten Fensters im übergeordneten Fenster an. Die OpenIcon-Funktion stellt ein minimiertes Fenster auf die vorherige Größe und Position wieder her.

Die ShowWindow-Funktion kann ein Fenster minimieren, maximieren oder wiederherstellen. Es kann auch die Sichtbarkeits- und Aktivierungszustände des Fensters festlegen. Die SetWindowPlacement-Funktion enthält dieselbe Funktionalität wie ShowWindow, kann jedoch die standardmäßigen minimierten, maximierten und wiederhergestellten Positionen des Fensters außer Kraft setzen.

Die Funktionen IsZoomed und IsIconic bestimmen, ob ein bestimmtes Fenster maximiert oder minimiert wird. Die GetWindowPlacement-Funktion ruft die minimierten, maximierten und wiederhergestellten Positionen für das Fenster ab und bestimmt auch den Anzeigestatus des Fensters.

Wenn das System einen Befehl zum Maximieren oder Wiederherstellen eines minimierten Fensters empfängt, sendet es dem Fenster eine WM_QUERYOPEN Nachricht. Wenn die Fensterprozedur FALSE zurückgibt, ignoriert das System den Befehl maximieren oder wiederherstellen.

Das System legt die Größe und Position eines maximierten Fensters automatisch auf die systemdefinierten Standardwerte für ein maximiertes Fenster fest. Um diese Standardwerte zu überschreiben, kann eine Anwendung entweder die SetWindowPlacement-Funktion aufrufen oder die WM_GETMINMAXINFO-Nachricht verarbeiten, die von einem Fenster empfangen wird, wenn das System das Fenster maximieren möchte. WM_GETMINMAXINFO enthält einen Zeiger auf eine MINMAXINFO-Struktur , die Werte enthält, die das System zum Festlegen der maximierten Größe und Position verwendet. Wenn Sie diese Werte ersetzen, werden die Standardwerte außer Kraft gesetzt.

Fenstergröße und -position

Die Größe und Position eines Fensters werden als umgebendes Rechteck ausgedrückt, das in Koordinaten relativ zum Bildschirm oder zum übergeordneten Fenster angegeben wird. Die Koordinaten eines Fensters auf oberster Ebene sind relativ zur oberen linken Ecke des Bildschirms; Die Koordinaten eines untergeordneten Fensters sind relativ zur oberen linken Ecke des übergeordneten Fensters. Eine Anwendung gibt beim Erstellen des Fensters die anfängliche Größe und Position eines Fensters an, kann aber jederzeit die Größe und Position des Fensters ändern. Weitere Informationen finden Sie unter Gefüllte Shapes.

Dieser Abschnitt enthält die folgenden Themen:

Standardgröße und -position

Eine Anwendung kann es dem System ermöglichen, die anfängliche Größe oder Position eines Fensters auf oberster Ebene zu berechnen, indem CW_USEDEFAULT in CreateWindowEx angegeben wird. Wenn die Anwendung die Koordinaten des Fensters auf CW_USEDEFAULT festlegt und keine anderen Fenster der obersten Ebene erstellt hat, legt das System die Position des neuen Fensters relativ zur oberen linken Ecke des Bildschirms fest. Andernfalls wird die Position relativ zur Position des Fensters der obersten Ebene festgelegt, das die Anwendung zuletzt erstellt hat. Wenn die Parameter breite und höhe auf CW_USEDEFAULT festgelegt sind, berechnet das System die Größe des neuen Fensters. Wenn die Anwendung weitere Fenster der obersten Ebene erstellt hat, basiert das System auf der Größe des neuen Fensters auf der Größe des zuletzt erstellten Fensters der obersten Ebene der Anwendung. Wenn Sie beim Erstellen eines untergeordneten Fensters oder Popupfensters CW_USEDEFAULT angeben, legt das System die Größe des Fensters auf die standardmäßige Mindestfenstergröße fest.

Nachverfolgungsgröße

Das System behält eine minimale und maximale Nachverfolgungsgröße für ein Fenster des WS_THICKFRAME Stils bei. ein Fenster mit diesem Format hat einen Größenrahmen. Die minimale Nachverfolgungsgröße ist die kleinste Fenstergröße, die Sie durch Ziehen des Größenrahmens des Fensters erzeugen können. Ebenso ist die maximale Nachverfolgungsgröße die größte Fenstergröße, die Sie durch Ziehen des Größenrahmens erzeugen können.

Die mindesten und maximalen Nachverfolgungsgrößen eines Fensters werden auf systemdefinierte Standardwerte festgelegt, wenn das System das Fenster erstellt. Eine Anwendung kann die Standardwerte ermitteln und überschreiben, indem sie die WM_GETMINMAXINFO Nachricht verarbeitet. Weitere Informationen finden Sie unter Größe und Position von Nachrichten.

Systembefehle

Eine Anwendung mit einem Fenstermenü kann die Größe und Position dieses Fensters ändern, indem Systembefehle gesendet werden. Systembefehle werden generiert, wenn der Benutzer Befehle aus dem Fenstermenü auswäht. Eine Anwendung kann die Benutzeraktion emulieren, indem sie eine WM_SYSCOMMAND Nachricht an das Fenster sendet. Die folgenden Systembefehle wirken sich auf die Größe und Position eines Fensters aus.

Get-Help BESCHREIBUNG
SC_CLOSE Schließt das Fenster. Dieser Befehl sendet eine WM_CLOSE Nachricht an das Fenster. Das Fenster führt alle Schritte aus, die erforderlich sind, um sich selbst zu sauber und zu zerstören.
SC_MAXIMIZE Maximiert das Fenster.
SC_MINIMIZE Minimiert das Fenster.
SC_MOVE Verschiebt das Fenster.
SC_RESTORE Stellt ein minimiertes oder maximiertes Fenster auf seine vorherige Größe und Position wieder her.
SC_SIZE Startet einen Size-Befehl. Um die Größe des Fensters zu ändern, verwenden Sie die Maus oder Tastatur.

 

Größen- und Positionsfunktionen

Nach dem Erstellen eines Fensters kann eine Anwendung die Größe oder Position des Fensters festlegen, indem sie eine von mehreren verschiedenen Funktionen aufruft, einschließlich SetWindowPlacement, MoveWindow,SetWindowPos und DeferWindowPos. SetWindowPlacement legt die minimierte Position eines Fensters, die maximierte Position, die wiederhergestellte Größe und Position sowie den Status anzeigen fest. Die Funktionen MoveWindow und SetWindowPos sind ähnlich. Beide legen die Größe oder Position eines einzelnen Anwendungsfensters fest. Die SetWindowPos-Funktion enthält eine Reihe von Flags, die sich auf den Anzeigezustand des Fensters auswirken. MoveWindow enthält diese Flags nicht. Verwenden Sie die Funktionen BeginDeferWindowPos, DeferWindowPos und EndDeferWindowPos , um gleichzeitig die Position einer Reihe von Fenstern festzulegen, einschließlich Größe, Position, Position in der Z-Reihenfolge und Anzeigezustand.

Eine Anwendung kann die Koordinaten des begrenzungsenden Rechtecks eines Fensters mithilfe der GetWindowRect-Funktion abrufen. GetWindowRect füllt eine RECT-Struktur mit den Koordinaten der oberen linken und unteren rechten Ecken des Fensters aus. Die Koordinaten sind relativ zur oberen linken Ecke des Bildschirms, auch für ein untergeordnetes Fenster. Die Funktion ScreenToClient oder MapWindowPoints ordnet die Bildschirmkoordinaten des umgebenden Rechtecks eines untergeordneten Fensters Koordinaten relativ zum Clientbereich des übergeordneten Fensters zu.

Die GetClientRect-Funktion ruft die Koordinaten des Clientbereichs eines Fensters ab. GetClientRect füllt eine RECT-Struktur mit den Koordinaten der oberen linken und unteren rechten Ecke des Clientbereichs, die Koordinaten sind jedoch relativ zum Clientbereich selbst. Dies bedeutet, dass die Koordinaten der oberen linken Ecke eines Clientbereichs immer (0,0) und die Koordinaten der unteren rechten Ecke die Breite und Höhe des Clientbereichs sind.

Die CascadeWindows-Funktion kaskadiert die Fenster auf dem Desktop oder kaskadiert die untergeordneten Fenster des angegebenen übergeordneten Fensters. Die TileWindows-Funktion kachelt die Fenster auf dem Desktop oder die untergeordneten Fenster des angegebenen übergeordneten Fensters.

Größe und Position von Nachrichten

Das System sendet die WM_GETMINMAXINFO Nachricht an ein Fenster, dessen Größe oder Position sich ändern wird. Die Nachricht wird beispielsweise gesendet, wenn der Benutzer im Fenstermenü auf Verschieben oder Größe klickt oder auf den Größenrahmen oder die Titelleiste klickt. Die Nachricht wird auch gesendet, wenn eine Anwendung SetWindowPos aufruft , um das Fenster zu verschieben oder zu vergrößern. WM_GETMINMAXINFO enthält einen Zeiger auf eine MINMAXINFO-Struktur , die die standardmaximierte Größe und Position für das Fenster sowie die standardmäßigen minimalen und maximalen Nachverfolgungsgrößen enthält. Eine Anwendung kann die Standardwerte überschreiben, indem sie WM_GETMINMAXINFO verarbeitet und die entsprechenden Member von MINMAXINFO festlegt. Ein Fenster muss über die WS_THICKFRAME - oder WS_CAPTION-Formatvorlage verfügen, um WM_GETMINMAXINFO zu empfangen. Ein Fenster mit dem WS_THICKFRAME Stil empfängt diese Meldung sowohl während des Fenstererstellungsprozesses als auch beim Verschieben oder Der Größe.

Das System sendet die WM_WINDOWPOSCHANGING Nachricht an ein Fenster, dessen Größe, Position, Position in der Z-Reihenfolge oder der Anzeigezustand sich ändern wird. Diese Nachricht enthält einen Zeiger auf eine WINDOWPOS-Struktur , die die neue Größe, Position, Position in der z-Reihenfolge und den Anzeigezustand des Fensters angibt. Durch Festlegen der Elemente von WINDOWPOS kann sich eine Anwendung auf die neue Größe, Position und Darstellung des Fensters auswirken.

Nach dem Ändern der Größe, Position, Position eines Fensters in der Z-Reihenfolge oder des Anzeigezustands sendet das System die WM_WINDOWPOSCHANGED Nachricht an das Fenster. Diese Nachricht enthält einen Zeiger auf WINDOWPOS , der das Fenster über seine neue Größe, Position, Position in der z-Reihenfolge und Anzeigezustand informiert. Das Festlegen der Member der WINDOWPOS-Struktur , die mit WM_WINDOWPOSCHANGED übergeben wird, hat keine Auswirkungen auf das Fenster. Ein Fenster, das WM_SIZE - und WM_MOVE-Nachrichten verarbeiten muss , muss WM_WINDOWPOSCHANGED an die DefWindowProc-Funktion übergeben. Andernfalls sendet das System keine WM_SIZE und WM_MOVE Nachrichten an das Fenster.

Das System sendet die WM_NCCALCSIZE Meldung an ein Fenster, wenn das Fenster erstellt oder dimensioniert wird. Das System verwendet die Meldung, um die Größe des Clientbereichs eines Fensters und die Position des Clientbereichs relativ zur oberen linken Ecke des Fensters zu berechnen. Ein Fenster übergibt diese Meldung in der Regel an die Standardfensterprozedur. Diese Meldung kann jedoch in Anwendungen nützlich sein, die den Nichtclientbereich eines Fensters anpassen oder Teile des Clientbereichs beibehalten, wenn das Fenster dimensioniert ist. Weitere Informationen finden Sie unter Zeichnen und Zeichnen.

Fensteranimation

Sie können Spezialeffekte beim Ein- oder Ausblenden von Fenstern erzeugen, indem Sie die AnimateWindow-Funktion verwenden. Wenn das Fenster auf diese Weise animiert wird, wird das Fenster entweder rollt, geschoben oder ausgeblendet, abhängig von den Flags, die Sie in einem Aufruf von AnimateWindow angeben.

Standardmäßig verwendet das System Rollanimation. Mit diesem Effekt wird das Fenster als rolloffen (das Fenster wird angezeigt) oder geschlossen (das Fenster wird ausgeblendet). Sie können den dwFlags-Parameter verwenden, um anzugeben, ob das Fenster horizontal, vertikal oder diagonal rollt.

Wenn Sie das flag AW_SLIDE angeben, verwendet das System Folienanimation. Mit diesem Effekt wird das Fenster angezeigt, um in die Ansicht zu gleiten (das Fenster zeigt) oder aus der Ansicht zu gleiten (das Fenster wird ausgeblendet). Sie können den dwFlags-Parameter verwenden, um anzugeben, ob das Fenster horizontal, vertikal oder diagonal verschoben wird.

Wenn Sie das AW_BLEND-Flag angeben, verwendet das System eine Alphablendung.

Sie können auch das flag AW_CENTER verwenden, damit ein Fenster nach innen reduziert oder nach außen erweitert wird.

Fensterlayout und Spiegelung

Das Fensterlayout definiert, wie Text und GDI-Objekte (Windows Graphics Device Interface) in einem Fenster oder gerätekontext (Device Context, DC) angeordnet werden. Für einige Sprachen, z. B. Englisch, Französisch und Deutsch, ist ein Layout von links nach rechts (LTR) erforderlich. Andere Sprachen, z. B. Arabisch und Hebräisch, erfordern ein Rechts-nach-Links-Layout (RTL). Das Fensterlayout gilt für Text, wirkt sich aber auch auf die anderen GDI-Elemente des Fensters aus, z. B. Bitmaps, Symbole, Die Position des Ursprungs, Schaltflächen, kaskadierende Struktursteuerelemente und ob die horizontale Koordinate zunimmt, wenn Sie nach links oder rechts gehen. Nachdem beispielsweise eine Anwendung das RTL-Layout festgelegt hat, wird der Ursprung am rechten Rand des Fensters oder Geräts positioniert, und die Zahl, die die horizontale Koordinate darstellt, erhöht sich, wenn Sie nach links bewegen. Allerdings sind nicht alle Objekte vom Layout eines Fensters betroffen. Beispielsweise muss das Layout für Dialogfelder, Meldungsfelder und Gerätekontexte, die nicht einem Fenster zugeordnet sind, wie z. B. Metadatei und Drucker-DCs, separat behandelt werden. Einzelheiten dazu werden weiter unten in diesem Thema erwähnt.

Mit den Fensterfunktionen können Sie das Fensterlayout in den arabischen und hebräischen Versionen von Windows angeben oder ändern. Beachten Sie, dass das Wechseln zu einem RTL-Layout (auch als Spiegelung bezeichnet) für Fenster mit dem Stil CS_OWNDC oder für einen DC mit dem GM_ADVANCED Grafikmodus nicht unterstützt wird.

Standardmäßig ist das Fensterlayout von links nach rechts (LTR) festgelegt. Um das RTL-Fensterlayout festzulegen, rufen Sie CreateWindowEx mit der Formatvorlage WS_EX_LAYOUTRTL auf. Standardmäßig weist ein untergeordnetes Fenster (d. h. ein fenster, das mit der WS_CHILD Stil und einem gültigen übergeordneten hWnd-Parameter im Aufruf von CreateWindow oder CreateWindowEx erstellt wurde) das gleiche Layout wie sein übergeordnetes Fenster auf. Um die Vererbung der Spiegelung auf alle untergeordneten Fenster zu deaktivieren, geben Sie im Aufruf von CreateWindowExWS_EX_NOINHERITLAYOUT an. Beachten Sie, dass die Spiegelung nicht von eigenen Fenstern (die ohne den WS_CHILD-Stil erstellt wurden) oder von Solchen geerbt wird, die mit dem übergeordneten hWnd-Parameter in CreateWindowEx erstellt wurden, der auf NULL festgelegt ist. Um die Vererbung der Spiegelung für ein einzelnes Fenster zu deaktivieren, verarbeiten Sie die WM_NCCREATE Meldung mit GetWindowLong und SetWindowLong , um das flag WS_EX_LAYOUTRTL zu deaktivieren. Diese Verarbeitung erfolgt zusätzlich zu allen anderen erforderlichen Verarbeitungen. Das folgende Codefragment zeigt, wie dies geschieht.

SetWindowLong (hWnd, 
               GWL_EXSTYLE, 
               GetWindowLong(hWnd,GWL_EXSTYLE) & ~WS_EX_LAYOUTRTL))

Sie können das Standardlayout auf RTL festlegen, indem Sie SetProcessDefaultLayout(LAYOUT_RTL) aufrufen. Alle Fenster, die nach dem Aufruf erstellt wurden, werden gespiegelt, aber vorhandene Fenster sind nicht betroffen. Um die Standardspiegelung zu deaktivieren, rufen Sie SetProcessDefaultLayout(0) auf.

Hinweis: SetProcessDefaultLayout spiegelt nur die DCs von gespiegelten Fenstern. Um einen beliebigen DC zu Spiegel, rufen Sie SetLayout(hdc, LAYOUT_RTL) auf. Weitere Informationen finden Sie in der Diskussion zum Spiegeln von Gerätekontexten, die nicht Fenstern zugeordnet sind, weiter unten in diesem Thema.

Bitmaps und Symbole in einem gespiegelten Fenster werden ebenfalls standardmäßig gespiegelt. Allerdings sollten nicht alle gespiegelt werden. Beispielsweise sollten Solche mit Text, einem Unternehmenslogo oder einer analogen Uhr nicht gespiegelt werden. Um die Spiegelung von Bitmaps zu deaktivieren, rufen Sie SetLayout auf, wobei das LAYOUT_BITMAPORIENTATIONPRESERVED Bit in dwLayout festgelegt ist. Um die Spiegelung in einem DC zu deaktivieren, rufen Sie SetLayout(hdc, 0) auf.

Rufen Sie GetProcessDefaultLayout auf, um das aktuelle Standardlayout abzufragen. Nach erfolgreicher Rückgabe enthält pdwDefaultLayout LAYOUT_RTL oder 0. Rufen Sie GetLayout auf, um die Layouteinstellungen des Gerätekontexts abzufragen. Nach erfolgreicher Rückgabe gibt GetLayout ein DWORD zurück, das die Layouteinstellungen anhand der Einstellungen der LAYOUT_RTL und der LAYOUT_BITMAPORIENTATIONPRESERVED Bits angibt.

Nachdem ein Fenster erstellt wurde, ändern Sie das Layout mithilfe der SetWindowLong-Funktion . Dies ist beispielsweise erforderlich, wenn der Benutzer die Sprache der Benutzeroberfläche eines vorhandenen Fensters von Arabisch oder Hebräisch in Deutsch ändert. Wenn Sie jedoch das Layout eines vorhandenen Fensters ändern, müssen Sie das Fenster für ungültig erklären und aktualisieren, um sicherzustellen, dass alle Inhalte des Fensters im selben Layout gezeichnet werden. Das folgende Codebeispiel stammt aus Beispielcode, der das Fensterlayout nach Bedarf ändert:

// Using ANSI versions of GetWindowLong and SetWindowLong because Unicode
// is not needed for these calls

lExStyles = GetWindowLongA(hWnd, GWL_EXSTYLE);

// Check whether new layout is opposite the current layout
if (!!(pLState -> IsRTLLayout) != !!(lExStyles & WS_EX_LAYOUTRTL))
{
    // the following lines will update the window layout

    lExStyles ^= WS_EX_LAYOUTRTL;        // toggle layout
    SetWindowLongA(hWnd, GWL_EXSTYLE, lExStyles);
    InvalidateRect(hWnd, NULL, TRUE);    // to update layout in the client area
}

Bei der Spiegelung sollten Sie in den Begriffen "nah" und "weit" anstelle von "links" und "rechts" denken. Andernfalls kann dies zu Problemen führen. Eine gängige Programmierpraxis, die Probleme in einem gespiegelten Fenster verursacht, tritt auf, wenn die Zuordnung zwischen Bildschirmkoordinaten und Clientkoordinaten erfolgt. Beispielsweise verwenden Anwendungen häufig Code ähnlich dem folgenden, um ein Steuerelement in einem Fenster zu positionieren:

// DO NOT USE THIS IF APPLICATION MIRRORS THE WINDOW

// get coordinates of the window in screen coordinates
GetWindowRect(hControl, (LPRECT) &rControlRect);  

// map screen coordinates to client coordinates in dialog
ScreenToClient(hDialog, (LPPOINT) &rControlRect.left); 
ScreenToClient(hDialog, (LPPOINT) &rControlRect.right);

Dies verursacht Probleme bei der Spiegelung, da der linke Rand des Rechtecks zum rechten Rand in einem gespiegelten Fenster wird und umgekehrt. Um dieses Problem zu vermeiden, ersetzen Sie die ScreenToClient-Aufrufe wie folgt durch einen Aufruf von MapWindowPoints :

// USE THIS FOR MIRRORING

GetWindowRect(hControl, (LPRECT) &rControlRect);
MapWindowPoints(NULL, hDialog, (LPPOINT) &rControlRect, 2)

Dieser Code funktioniert, da MapWindowPoints auf Plattformen, die die Spiegelung unterstützen, so geändert wird, dass die linken und rechten Punktkoordinaten ausgetauscht werden, wenn das Clientfenster gespiegelt wird. Weitere Informationen finden Sie im Abschnitt Hinweise von MapWindowPoints.

Eine weitere gängige Vorgehensweise, die probleme in gespiegelten Fenstern verursachen kann, ist das Positionieren von Objekten in einem Clientfenster mithilfe von Offsets in Bildschirmkoordinaten anstelle von Clientkoordinaten. Der folgende Code verwendet beispielsweise den Unterschied in den Bildschirmkoordinaten als x-Position in Clientkoordinaten, um ein Steuerelement in einem Dialogfeld zu positionieren.

// OK if LTR layout and mapping mode of client is MM_TEXT,
// but WRONG for a mirrored dialog 

RECT rdDialog;
RECT rcControl;

HWND hControl = GetDlgItem(hDlg, IDD_CONTROL);
GetWindowRect(hDlg, &rcDialog);             // gets rect in screen coordinates
GetWindowRect(hControl, &rcControl);
MoveWindow(hControl,
           rcControl.left - rcDialog.left,  // uses x position in client coords
           rcControl.top - rcDialog.top,
           nWidth,
           nHeight,
           FALSE);

Dieser Code ist in Ordnung, wenn das Dialogfeld von links nach rechts (LTR) layout hat und der Zuordnungsmodus des Clients MM_TEXT ist, da die neue x-Position in Clientkoordinaten dem Unterschied in den linken Rändern des Steuerelements und dem Dialogfeld in Bildschirmkoordinaten entspricht. In einem gespiegelten Dialogfeld sind links und rechts jedoch umgekehrt, sodass Sie stattdessen MapWindowPoints wie folgt verwenden sollten:

RECT rcDialog;
RECT rcControl;

HWND hControl - GetDlgItem(hDlg, IDD_CONTROL);
GetWindowRect(hControl, &rcControl);

// MapWindowPoints works correctly in both mirrored and non-mirrored windows.
MapWindowPoints(NULL, hDlg, (LPPOINT) &rcControl, 2);

// Now rcControl is in client coordinates.
MoveWindow(hControl, rcControl.left, rcControl.top, nWidth, nHeight, FALSE)

Spiegelungsdialogfelder und Meldungsfelder

Dialogfelder und Meldungsfelder erben kein Layout, sodass Sie das Layout explizit festlegen müssen. Um ein Meldungsfeld zu Spiegel, rufen Sie MessageBox oder MessageBoxEx mit der Option MB_RTLREADING auf. Verwenden Sie zum Layout eines Dialogfelds von rechts nach links die erweiterte Formatvorlage WS_EX_LAYOUTRTL in der Dialogvorlagenstruktur DLGTEMPLATEEX. Eigenschaftenblätter sind ein Sonderfall von Dialogfeldern. Jede Registerkarte wird als separates Dialogfeld behandelt, sodass Sie die WS_EX_LAYOUTRTL Formatvorlage in jede Registerkarte einfügen müssen, die Gespiegelt werden soll.

Spiegelung von Gerätekontexten, die nicht einem Fenster zugeordnet sind

DCs, die keinem Fenster zugeordnet sind, z. B. Metafile- oder Drucker-DCs, erben kein Layout, sodass Sie das Layout explizit festlegen müssen. Verwenden Sie die SetLayout-Funktion , um das Layout des Gerätekontexts zu ändern.

Die SetLayout-Funktion wird nur selten mit Fenstern verwendet. In der Regel erhalten Fenster einen zugeordneten Domänencontroller nur bei der Verarbeitung einer WM_PAINT-Nachricht . Gelegentlich erstellt ein Programm einen DC für ein Fenster, indem Es GetDC aufruft. In beiden Richtungen wird das anfängliche Layout für den DC von BeginPaint oder GetDC gemäß dem WS_EX_LAYOUTRTL-Flag des Fensters festgelegt.

Die von GetWindowOrgEx, GetWindowExtEx, GetViewportOrgEx und GetViewportEx zurückgegebenen Werte sind vom Aufruf von SetLayout nicht betroffen.

Wenn das Layout RTL ist, gibt GetMapMode anstelle von MM_TEXT MM_ANISOTROPIC zurück. Das Aufrufen von SetMapMode mit MM_TEXT funktioniert ordnungsgemäß. nur der Rückgabewert von GetMapMode ist betroffen. Ebenso bewirkt der Aufruf von SetLayout(hdc, LAYOUT_RTL), wenn der Zuordnungsmodus MM_TEXT ist, dass sich der gemeldete Zuordnungsmodus in MM_ANISOTROPIC ändert.

Fensterzerstörung

Im Allgemeinen muss eine Anwendung alle fenster zerstören, die sie erstellt. Dazu wird die DestroyWindow-Funktion verwendet. Wenn ein Fenster zerstört wird, blendet das System das Fenster aus, sofern es sichtbar ist, und entfernt dann alle internen Daten, die dem Fenster zugeordnet sind. Dadurch wird das Fensterhandle ungültig, das von der Anwendung nicht mehr verwendet werden kann.

Eine Anwendung zerstört viele der Fenster, die sie erstellt, kurz nachdem sie erstellt wurde. Beispielsweise zerstört eine Anwendung in der Regel ein Dialogfeldfenster, sobald die Anwendung über ausreichende Eingaben vom Benutzer verfügt, um ihre Aufgabe fortzusetzen. Eine Anwendung zerstört schließlich das Standard Fenster der Anwendung (vor dem Beenden).

Vor dem Zerstören eines Fensters sollte eine Anwendung alle dem Fenster zugeordneten Daten speichern oder entfernen und alle systemressourcen freigeben, die dem Fenster zugeordnet sind. Wenn die Anwendung die Ressourcen nicht freigibt, gibt das System alle Ressourcen frei, die nicht von der Anwendung freigegeben wurden.

Das Zerstören eines Fensters wirkt sich nicht auf die Fensterklasse aus, aus der das Fenster erstellt wird. Neue Fenster können weiterhin mit dieser Klasse erstellt werden, und alle vorhandenen Fenster dieser Klasse werden weiterhin ausgeführt. Durch das Zerstören eines Fensters werden auch die Nachfolgerfenster des Fensters zerstört. Die DestroyWindow-Funktion sendet eine WM_DESTROY Nachricht zuerst an das Fenster, dann an die untergeordneten Fenster und nachfolgerfähigen Fenster. Auf diese Weise werden auch alle Nachkommafenster des zerstörten Fensters zerstört.

Ein Fenster mit einem Fenstermenü erhält eine WM_CLOSE Meldung, wenn der Benutzer auf Schließen klickt. Durch die Verarbeitung dieser Nachricht kann eine Anwendung den Benutzer zur Bestätigung auffordern, bevor das Fenster zerstört wird. Wenn der Benutzer bestätigt, dass das Fenster zerstört werden soll, kann die Anwendung die DestroyWindow-Funktion aufrufen, um das Fenster zu zerstören.

Wenn das zerstörte Fenster das aktive Fenster ist, werden sowohl der aktive als auch der Fokuszustand in ein anderes Fenster übertragen. Das Fenster, das zum aktiven Fenster wird, ist das nächste Fenster, wie durch die Tastenkombination ALT+ESC bestimmt. Das neue aktive Fenster bestimmt dann, welches Fenster den Tastaturfokus erhält.