## 20.3 Trigger Werte, die wir bisher an einen Style gebunden hatten, waren immer statisch. Der Wert wurde gesetzt und konnte nicht mehr verändert werden. Tendenziell ist jedoch eine erhöhte Erwartungshaltung hinsichtlich der Gestaltung der grafischen Benutzeroberflächen zu spüren. Das erfordert auch, dass sich die grafische Darstellung der Komponenten in Abhängigkeit vom Zustand einer Komponente ändert. Mit Ihrem bisherigen Kenntnisstand über die Styles ist das aber nicht möglich. Die Lösung heißt Trigger. Trigger werden häufig für die Reaktion auf Ereignisse, Eigenschaftsänderungen usw. verwendet. Daher werden drei Trigger-Varianten unterschieden: Eigenschaftstrigger reagieren, wenn sich eine Eigenschaft ändert. Dabei muss es sich um eine Abhängigkeitseigenschaft handeln. Ereignistrigger reagieren beim Auftreten eines Routed Events. Datentrigger reagieren, wenn sich eine herkömmliche .NET-Eigenschaft ändert. Trigger werden oft zusammen mit den Styles eingesetzt, können aber auch der Eigenschaft Triggers einer Komponente direkt zugewiesen werden. Eine Komponente kann auch mit mehreren Triggern verbunden werden, um auf verschiedene Zustandsänderungen unterschiedlich zu reagieren. ### 20.3.1 Eigenschaftstrigger In der Beispielanwendung SimpleStyle treffen wir auf ein typisches Problem, das mithilfe eines Triggers gelöst werden kann. Ziehen Sie beispielsweise mit der Maus über die Schaltflächen, ändern sich der Hintergrund und der Rahmen des Steuerelements in einer vordefinierten Weise. Vielleicht möchten Sie aber die Änderung nach eigenen Vorstellungen gestalten. Sie können das natürlich auch mit C#-Code erreichen, in dem Sie ein passendes Ereignis codieren. WPF bietet aber darüber hinaus auch die Möglichkeit, die Zustandsänderung mittels XAML-Code zu erfassen und in gewünschter Weise zu reagieren. WPF-Komponenten haben Eigenschaften, die einen bestimmten Zustand beschreiben. Mit IsMouseOver lässt sich beispielsweise feststellen, ob sich der Mauszeiger aktuell über der Komponente befindet, und mit IsPressed können Sie prüfen, ob auf die Komponente geklickt wird. Die Prüfung beschränkt sich aber nicht nur auf IsXXX-Eigenschaften. So ließe sich zum Beispiel auch die Eigenschaft Text einer TextBox auf einen bestimmten Inhalt hin untersuchen. Eigenschaftstrigger werden in einem Stil definiert. Dazu stellt Style die Eigenschaft Triggers zur Verfügung:
    <Style>
      <Style.Triggers>
        <Trigger Property="..." Value="...">
          <Setter .../>
          <Setter .../>
        </Trigger>
      </Style.Triggers>
    </Style>
Im Abschnitt Style.Triggers werden die Trigger eingefügt. Die Eigenschaften Property und Value des Trigger-Elements beschreiben die Eigenschaft und deren Wert, die überwacht werden sollen. Entspricht zur Laufzeit die Value-Einstellung des Triggers dem aktuellen Wert, wird der Trigger aktiviert, und die darin enthaltenen Setter-Elemente werden ausgewertet. Das Beispiel SimpleStyle soll nun um einen Trigger ergänzt werden, der bewirkt, dass sich die Hintergrunddarstellung der Schaltfläche ändert, sobald die Maus darüber gezogen wird.
    // ---------------------------------------------------------
    // Beispiel: ...\Kapitel 20\SimpleTrigger
    // ---------------------------------------------------------
    <Window ...>
      <Window.Resources>
        <Style x:Key="MyStyle">
          <Setter Property="Control.Height" Value="35" />
          <Setter Property="Control.FontSize" Value="18" />
          <Setter Property="Control.Background">
            <Setter.Value>
              <LinearGradientBrush StartPoint="0,0" EndPoint="0,1">
                <GradientStop Offset="0.0" Color="Red" />
                <GradientStop Offset="1.0" Color="LightCyan" />
              </LinearGradientBrush>
            </Setter.Value>
          </Setter>
          <Style.Triggers>
            <Trigger Property="Button.IsMouseOver" Value="True">
              <Setter Property="Control.FontStyle"
                      Value="Italic" />
              <Setter Property="Control.Background">
                <Setter.Value>
                  <LinearGradientBrush StartPoint="0,0"
                                       EndPoint="0,1">
                    <GradientStop Offset="0.0" Color="Yellow" />
                    <GradientStop Offset="1.0" Color="Blue" />
                  </LinearGradientBrush>
                </Setter.Value>
              </Setter>
            </Trigger>
          </Style.Triggers>
        </Style>
      </Window.Resources>
      <StackPanel>
        <Button Style="{StaticResource MyStyle}">Button1</Button>
        <Button Style="{StaticResource MyStyle}">Button2</Button>
        <Button Style="{StaticResource MyStyle}">Button3</Button>
      </StackPanel>
    </Window>
Ein Trigger nimmt Änderungen an einer oder mehreren Komponenten vor. Diese werden wieder rückgängig gemacht, wenn sich die Bedingungen erneut ändern. Verlässt in unserem Beispiel der Mauszeiger den Bereich eines Buttons, kehrt dieser wieder in seinen Ausgangszustand zurück. #### MultiTrigger Das Auslösen eines Triggers muss nicht zwangsläufig nur von einer Bedingung abhängen. WPF stellt mit MultiTrigger ein Element zur Verfügung, das es uns erlaubt, mehrere Bedingungen anzugeben, die alle erfüllt sein müssen, damit der Trigger ausgelöst wird. Das Element MultiTrigger beschreibt eine Collection, von der alle Bedingungen erfasst werden. Die Eigenschaft MultiTrigger.Conditions liefert die Referenz auf die Collection. Die einzelnen Bedingungen werden durch Condition beschrieben. Im folgenden Beispiel enthält das Window eine TextBox-Komponente mit einem Textinhalt. Wenn die TextBox leer ist und sich gleichzeitig der Mauszeiger über der TextBox befindet, wird deren Hintergrund in Rot dargestellt.
    // ---------------------------------------------------------
    // Beispiel: ...\Kapitel 20\MultiTrigger
    // ---------------------------------------------------------
    <Window ...>
      <Window.Resources>
        <Style TargetType="{x:Type TextBox}">
          <Style.Triggers>
            <MultiTrigger>
              <MultiTrigger.Conditions>
                <Condition Property="TextBox.IsMouseOver" Value="true" />
                <Condition Property="TextBox.Text" Value="" />
              </MultiTrigger.Conditions>
              <Setter Property="TextBox.Background" Value="Red" />
            </MultiTrigger>
          </Style.Triggers>
        </Style>
      </Window.Resources>
      <StackPanel>
        <TextBox Margin="20" Width="200">
          Windows Presentation Foundation WPF
        </TextBox>
      </StackPanel>
    </Window>
### 20.3.2 Ereignistrigger Ereignistrigger werden durch Ereignisse vom Typ RoutedEvent ausgelöst. Anstelle des Aufrufs eines Ereignishandlers können Ereignistrigger Animationen starten. Allerdings sollten Sie unter dem Begriff Animation nicht nur grafische Spielereien verstehen. Auch Tabellen, die sich permanent aktualisierende Daten in Diagrammen optisch ansprechend anzeigen, gehören zu der Gruppe der Animationen. Sehen wir uns zuerst an, wie Ereignistrigger in XAML definiert werden:
    <Style TargetType="{x:Type Button}">
      <Style.Triggers>
        <EventTrigger RoutedEvent="...">
          <EventTrigger.Actions>
            ...
          </EventTrigger.Actions>
        </EventTrigger>
      </Style.Triggers>
    </Style>
Ereignistrigger werden in einem Style-Element oder direkt in einer Komponente definiert. Das EventTrigger-Element beschreibt den Ereignistrigger. Als Attribut muss RoutedEvent angegeben sein. Hier wird das Ereignis angegeben, das den Trigger auslöst. Darunter wird ein EventTrigger.Actions-Element angegeben, in dem die Aktionen festgelegt werden, die beim Auslösen des Triggers ausgeführt werden sollen. Das folgende Beispiel demonstriert den Einsatz eines Ereignistriggers. Getriggert wird das Ereignis MouseEnter. Zur Laufzeit bewirkt das Ziehen der Maus über die Schaltfläche, dass diese zunächst unsichtbar wird, denn die Eigenschaft Opacity wird innerhalb der Animation zuerst auf 0 gesetzt. Bis zur vollen Wiederherstellung der Sichtbarkeit sind 10 Sekunden festgelegt.
    // ---------------------------------------------------------
    // Beispiel: ...\Kapitel 20\EreignisTrigger
    // ---------------------------------------------------------
    <Window ...>
      <Window.Resources>
        <Style TargetType="{x:Type Button}">
        <Style.Triggers>
          <EventTrigger RoutedEvent="MouseEnter">
            <EventTrigger.Actions>
              <BeginStoryboard>
                <Storyboard>
                  <DoubleAnimation From="0" To="1" Duration="0:0:10"
                       Storyboard.TargetProperty="(Opacity)" />
                </Storyboard>
              </BeginStoryboard>
            </EventTrigger.Actions>
          </EventTrigger>
        </Style.Triggers>
        </Style>
      </Window.Resources>
      <StackPanel>
        <Button Height="50">Button1</Button>
      </StackPanel>
    </Window>
Mit den Komponenten BeginStoryBoard und StopStoryBoard werden die Aktionen gestartet und beendet. Eine StoryBoard-Komponente müssen Sie sich als einen Container vorstellen, in dem die Animation über eine Zeitlinie hinweg abläuft.
Hinweis
Es ist nicht möglich, Eigenschaften in einem Ereignistrigger direkt zu ändern.
### 20.3.3 Datentrigger Datentrigger ähneln den Eigenschaftstriggern. Der Unterschied zwischen diesen beiden ist, dass Datentrigger auf die Änderung einer beliebigen, also auch einer herkömmlichen .NET-Eigenschaft reagieren. Zur Erinnerung: Ereignistrigger reagieren nur auf Änderungen abhängiger Eigenschaften (Dependency Properties). Um einen Datentrigger zu definieren, muss ein DataTrigger zur Collection Style.Triggers hinzugefügt werden. Da Datentrigger auch mit Eigenschaften umgehen können, die nicht zu den Abhängigkeitseigenschaften gezählt werden, wird anstelle des Attributs Property das Attribut Binding angegeben werden. Das folgende Beispiel zeigt den Einsatz eines Datentriggers. Im Fenster ist eine TextBox enthalten. Wird zur Laufzeit die Zeichenfolge »Weg damit« eingetragen, wird die Textbox deaktiviert.
    // ---------------------------------------------------------
    // Beispiel: ...\Kapitel 20\DatenTrigger
    // ---------------------------------------------------------
    <Window ...>
      <Window.Resources>
        <Style TargetType="{x:Type TextBox}">
          <Style.Triggers>
            <DataTrigger Binding=
                 "{Binding RelativeSource={RelativeSource Self},
                 Path=Text}" Value="Weg damit">
              <Setter Property="IsEnabled" Value="False" />
            </DataTrigger>
          </Style.Triggers>
        </Style>
      </Window.Resources>
      <StackPanel>
        <TextBox Height="23" VerticalAlignment="Center" />
      </StackPanel>
    </Window>