Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort zur 5. Auflage
1 Allgemeine Einführung in .NET
2 Grundlagen der Sprache C#
3 Klassendesign
4 Vererbung, Polymorphie und Interfaces
5 Delegates und Ereignisse
6 Weitere .NET-Datentypen
7 Weitere Möglichkeiten von C#
8 Auflistungsklassen (Collections)
9 Fehlerbehandlung und Debugging
10 LINQ to Objects
11 Multithreading und die Task Parallel Library (TPL)
12 Arbeiten mit Dateien und Streams
13 Binäre Serialisierung
14 Einige wichtige .NET-Klassen
15 Projektmanagement und Visual Studio 2010
16 XML
17 WPF – Die Grundlagen
18 WPF-Containerelemente
19 WPF-Steuerelemente
20 Konzepte der WPF
21 Datenbindung
22 2D-Grafik
23 ADO.NET – verbindungsorientierte Objekte
24 ADO.NET – Das Command-Objekt
25 ADO.NET – Der SqlDataAdapter
26 ADO.NET – Daten im lokalen Speicher
27 ADO.NET – Aktualisieren der Datenbank
28 Stark typisierte DataSets
29 LINQ to SQL
30 Weitergabe von Anwendungen
Stichwort

Buch bestellen
Ihre Meinung?

Spacer
<< zurück
Visual C# 2010 von Andreas Kühnel
Das umfassende Handbuch
Buch: Visual C# 2010

Visual C# 2010
geb., mit DVD
1295 S., 49,90 Euro
Rheinwerk Computing
ISBN 978-3-8362-1552-7
Pfeil 20 Konzepte der WPF
Pfeil 20.1 Ressourcen
Pfeil 20.1.1 Wo logische Ressourcen definiert werden können
Pfeil 20.1.2 Definition logischer Ressourcen
Pfeil 20.1.3 Statische und dynamische Ressourcen
Pfeil 20.1.4 Ressourcen in Ressourcendateien
Pfeil 20.1.5 Suche nach einer Ressource
Pfeil 20.1.6 Ressourcen mit C#-Code
Pfeil 20.1.7 Abrufen von Systemressourcen
Pfeil 20.2 Styles
Pfeil 20.2.1 Einfache Stile
Pfeil 20.2.2 Typisierte Stile
Pfeil 20.2.3 EventSetter
Pfeil 20.3 Trigger
Pfeil 20.3.1 Eigenschaftstrigger
Pfeil 20.3.2 Ereignistrigger
Pfeil 20.3.3 Datentrigger
Pfeil 20.4 Templates
Pfeil 20.4.1 Grundlagen der Templates
Pfeil 20.4.2 Verfeinerung des Entwurfs
Pfeil 20.4.3 Definition innerhalb eines Styles
Pfeil 20.4.4 Den Visual Tree ermitteln
Pfeil 20.5 Commands
Pfeil 20.5.1 Vordefinierte Commands
Pfeil 20.5.2 Beispielanwendung
Pfeil 20.5.3 Commando-Ziel festlegen
Pfeil 20.5.4 Commands an Ereignisse binden
Pfeil 20.5.5 Commands programmieren


Galileo Computing - Zum Seitenanfang

20.3 Trigger Zur nächsten ÜberschriftZur vorigen Überschrift

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.


Galileo Computing - Zum Seitenanfang

20.3.1 Eigenschaftstrigger Zur nächsten ÜberschriftZur vorigen Überschrift

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>


Galileo Computing - Zum Seitenanfang

20.3.2 Ereignistrigger Zur nächsten ÜberschriftZur vorigen Überschrift

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.



Galileo Computing - Zum Seitenanfang

20.3.3 Datentrigger topZur vorigen Überschrift

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>



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
<< zurück
  Zum Katalog
Zum Katalog: Visual C# 2010

Visual C# 2010
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchempfehlungen
Zum Katalog: Professionell entwickeln mit Visual C# 2012






 Professionell
 entwickeln mit
 Visual C# 2012


Zum Katalog: Windows Presentation Foundation






 Windows Presentation
 Foundation


Zum Katalog: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Katalog: C++ Handbuch






 C++ Handbuch


Zum Katalog: C/C++






 C/C++


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Rheinwerk Verlag GmbH 2010
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


Nutzungsbestimmungen | Datenschutz | Impressum

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de

Cookie-Einstellungen ändern