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

 <<   zurück
Visual Basic 2005 von Andreas Kühnel
Das umfassende Handbuch
Buch: Visual Basic 2005

Visual Basic 2005
1.233 S., mit 2 CDs, 59,90 Euro
Rheinwerk Computing
ISBN 3-89842-585-1
gp Kapitel 19 Weitere Steuerelemente
  gp 19.1 Bildlaufleisten mit »HScrollBar« und »VScrollBar«
  gp 19.2 Schieberegler mit der Klasse »TrackBar«
  gp 19.3 Das »ProgressBar«-Steuerelement
  gp 19.4 Drehfeld-Steuerelemente (»UpDown«-Steuerelemente)
    gp 19.4.1 Das »NumericUpDown«-Steuerelement
    gp 19.4.2 Das »DomainUpDown«-Steuerelement
  gp 19.5 Das »Timer«-Steuerelement
  gp 19.6 Die Klasse »ErrorProvider«
  gp 19.7 Steuerelemente für die Datums- und Zeitangabe
    gp 19.7.1 Das Steuerelement »MonthCalendar«
    gp 19.7.2 Das Steuerelement »DateTimePicker«
  gp 19.8 Das »Panel«-Steuerelement
  gp 19.9 Das Steuerelement »NotifyIcon«
  gp 19.10 Bildanzeige mit »PictureBox«
  gp 19.11 Eine Liste mit Symbolen mit »ImageList« bereitstellen
    gp 19.11.1 Die Eigenschaften der Klasse »ImageList«
    gp 19.11.2 Die Bildliste füllen
  gp 19.12 Registerkarten mit »TabControl«
    gp 19.12.1 Die Klasse »TabControl«
    gp 19.12.2 Objekte vom Typ »TabPage«
  gp 19.13 Das »TreeView«-Steuerelement
    gp 19.13.1 Knotenpunkte im »TreeView« definieren
    gp 19.13.2 Eigenschaften des »TreeView«-Steuerelements
    gp 19.13.3 Die Unterstützung der Entwicklungsumgebung
    gp 19.13.4 Die Ereignisse des »TreeView«-Steuerelements
    gp 19.13.5 Weitere Eigenschaften und Methoden des »TreeView«-Objekts
    gp 19.13.6 Eigenschaften und Methoden des »TreeNode«-Objekts
    gp 19.13.7 Beispiel zum Einlesen der Verzeichnisstruktur
  gp 19.14 Die beiden »Splitter«-Steuerelemente
    gp 19.14.1 Das Steuerelement »Splitter«
    gp 19.14.2 Das Steuerelement »SplitContainer«
  gp 19.15 Das »ListView«-Steuerelement
    gp 19.15.1 Die Klassen des »ListView«-Steuerelements
    gp 19.15.2 Die Eigenschaften der »ListView«
    gp 19.15.3 Listenelemente vom Typ »ListViewItem«
    gp 19.15.4 Das Element »ListViewSubItem«
    gp 19.15.5 Der Typ »ColumnHeader«
    gp 19.15.6 Listenelemente Gruppen zuordnen
    gp 19.15.7 Sortierung der Spalten
    gp 19.15.8 Listenelemente ändern


Galileo Computing

19.15 Das »ListView«-Steuerelement  downtop

In der linken Fensterhälfte des Windows-Explorers wird die Struktur des Dateisystems durch ein TreeView-Steuerelement angezeigt, in der rechten Hälfte die untergeordneten Elemente des ausgewählten Knotens. Hier hat der Anwender die Wahl, wie er sich die Elemente anzeigen lässt. Beispielsweise können die Elemente tabellenartig aufgelistet werden, möglicherweise auch ergänzt um die Dateigröße, das Änderungsdatum usw. Jedes Element kann auch durch ein kleines oder ein großes Symbol dargestellt werden.

Wir können diese Fähigkeiten des Explorers durch das Steuerelement ListView, das auch als Listenansicht bezeichnet wird, nachbilden. Die Programmierung ist etwas komplexer, weil bei diesem Steuerelement deutlich mehr Klassen eine Rolle spielen als bei den Steuerelementen, die wir bisher behandelt haben.


Galileo Computing

19.15.1 Die Klassen des »ListView«-Steuerelements  downtop

Verschaffen wir uns zuerst einen Überblick über die wichtigsten Klassen, die im Zusammenhang mit diesem Steuerelement stehen. Ein ListView-Objekt stellt insgesamt fünf Auflistungen bereit:

gp  ListViewItemCollection: Eine Listenansicht dient dazu, Elemente anzuzeigen. Diese sind vom Typ ListViewItem. Die Auflistung ListViewItemCollection der Listenansicht verwaltet diese Objekte. Ein Element vom Typ ListViewItem kann elementspezifische Eigenschaften aufweisen, die in der Detailansicht als Spalteneinträge angezeigt werden. Jede einzelne Eigenschaft wird durch ein Objekt vom Typ ListViewSubItem beschrieben. Um den Zugriff auf die Eigenschaften zu gewährleisten, hat jedes ListViewItem-Objekt eine ListViewSubItemCollection-Auflistung.
gp  ColumnHeaderCollection: Haben Sie die Detailansicht eingeschaltet, werden im Steuer-element Spaltenköpfe angezeigt. Jede Spalte wird durch ein Objekt vom Typ ColumnHeader beschrieben, alle Spalten sind in der Auflistung ColumnHeaderCollection enthalten.
gp  SelectedIndexCollection/SelectedListViewItemCollection: Auf die in einer Listenansicht ausgewählten Elemente kann über zwei Auflistungen zugegriffen werden: SelectedListViewItemCollection liefert die Referenz der ausgewählten Listenelemente zurück, SelectedIndexCollection die Indizes.
gp  ListViewGroupCollection: Mit der Einführung von .NET Framework 2.0 wurde die Klasse ListView um ein Feature erweitert, mit dem Sie visuelle Gruppen logisch zusammengehöriger ListView-Elemente definieren können. Jede Gruppe besteht aus einem Textheader, auf den eine horizontale Linie und die dieser Gruppe zugewiesenen Elemente folgen.

Ganz am Ende sind wir jedoch noch nicht angelangt, denn wenn ein ListView-Steuerelement vollständig entwickelt werden soll, müssen Sie der Form noch zwei, unter Umständen sogar drei Instanzen des ImageList-Steuerelements hinzufügen: Eine Bilderliste enthält die Symbole für die Darstellung Kleine Symbole, die zweite die Symbole für die Darstellung Große Symbole. Die dritte würde zwei Symbole bereitstellen, um durch ein Bildchen zwischen einem ausgewählten und einem nicht ausgewählten Element eine weitere optische Unterscheidung zu schaffen.


Galileo Computing

19.15.2 Die Eigenschaften der »ListView«  downtop

Listenelemente und Spaltenbeschreibungen hinzufügen

Die Listenansicht stellt mit ColumnHeaderCollection und ListViewItemCollection zwei Auflistungsobjekte zur Verfügung, auf die über die Eigenschaften Columns bzw. Items der Zugriff möglich ist. Falls erforderlich, können Sie die beiden Auflistungen mit den schon von anderen Auflistungen her bekannten Methoden manipulieren (Add, AddRange, Contains, Insert usw.).

Markieren Sie im Eigenschaftsfenster der Entwicklungsumgebung die Eigenschaften Items bzw. Columns, werden Dialoge zum Hinzufügen von Spalten und Listenelemente geöffnet. Beide sind zwar intuitiv zu bedienen, können aber nur den Zustand der Listenansicht beim Start der Anwendung beschreiben. In den meisten Fällen wird eine Listenansicht jedoch zur Laufzeit dynamisch aufgebaut. Daher nimmt bei einer Listenansicht die Programmierung einen höheren Stellenwert ein als bei den meisten anderen Steuerelementen. In Abbildung 19.25 sehen Sie den Dialog zum Hinzufügen von ListViewItem-Objekten.

Abbildung
Hier klicken, um das Bild zu Vergrößern

Abbildung 19.25     Assistent zum Hinzufügen von Listenobjekten

Die Ansichtsmodi einer Listenansicht

Es sind zwei ImageList-Objekte notwendig, wenn eine Listenansicht vollständig entwickelt werden soll: Ein ListImage enthält die Liste der kleinen Symbole, das andere die Liste der großen. Die Listenansicht muss mit beiden Bildlisten verknüpft werden. Dazu dienen die Eigenschaften SmallImageList und LargeImageList.

Mit der Eigenschaft View legt man fest, wie die Elemente zur Laufzeit dargestellt werden. View ist vom Typ der gleichnamigen Enumeration, in der vier Konstanten vordefiniert sind, welche die uns vom Windows-Explorer her bekannten Ansichten beschreiben.


Tabelle 19.25     Die Konstanten der Enumeration »View«

Member Beschreibung
Details Jedes Element wird in einer einzelnen Zeile dargestellt. In den Spalten werden die elementspezifischen Informationen bereitgestellt. Diese Ansicht ist die einzige, in der die Spaltenköpfe angezeigt werden.
LargeIcon Jedes Element wird als großes Symbol (häufig 32 x 32 oder 48 x 48 Pixel) dargestellt. Die Bezeichnung des Elements steht unterhalb des Symbols.
List Jedes Element wird als kleines Symbol (meist 16 x 16 Pixel) und mit einem Text rechts daneben dargestellt. Die Elemente sind zeilenweise angeordnet.
SmallIcon Jedes Element wird als kleines Symbol angezeigt. Die Bezeichnung des Elements steht rechts vom Symbol.
Tile Jedes Element wird als Symbol und mit einer Elementbezeichnung sowie weiteren Informationen rechts daneben dargestellt. Diese Ansicht ist nur unter Windows XP und Windows Server 2003 verfügbar.

Die Elementaktivierung

Die Listenansicht bietet eine stattliche Anzahl Eigenschaften, um die Anzeige des Steuerelements zu gestalten und dem Benutzer bestimmte Bedienfunktionen zu ermöglichen. Mit AllowColumnRecorder=True gestatten wir einem Anwender beispielsweise, die Reihenfolge der Spalten zu verändern, HoverSelection=True erlaubt die Auswahl eines Elements ohne Mausklick, und MultiSelect=True gibt an, ob mehrere Listeneinträge gleichzeitig ausgewählt werden dürfen.

Bei einer Listenansicht muss genau zwischen Aktivierung und Auswahl unterschieden werden. Ein Listenelement wird standardmäßig ausgewählt, wenn mit der Maus einmal auf das Element geklickt oder die Auswahl mit den Pfeiltasten verändert wird. Aktiviert wird ein Listenelement, wenn durch einen Doppelklick eine Programmaktion gestartet wird. Das ist zumindest der Standard.

Manchmal ist es wünschenswert, vom Standardverhalten abweichend eine andere Aktivierung vorzusehen. Dazu dient die Eigenschaft Activation. Drei Möglichkeiten, die der folgenden Tabelle entnommen werden können, werden von der Enumeration ItemActivation angeboten.


Tabelle 19.26     Die Mitglieder der Enumeration »ItemActivation«

Member Beschreibung
Standard Die Elemente werden durch einen Doppelklick aktiviert.
OneClick Die Elemente werden durch einfaches Klicken aktiviert. Ist ein Element ausgewählt, wird, sobald der Mauszeiger darüber geführt wird, dieser als Hand dargestellt, und die Farbe des Elementtextes ändert sich.
TwoClick Verhält sich wie Standard. Zusätzlich wird, sobald der Mauszeiger über ein gewähltes Listenelement geführt wird, dieser als Hand dargestellt und die Farbe des Elementtextes verändert.

Die wichtigsten spezifischen Eigenschaften einer Listenansicht

Die folgende Tabelle gibt einen Überblick über die wichtigsten Eigenschaften einer Listenansicht. Einige Eigenschaften werden im weiteren Verlauf des Abschnitts noch einmal erwähnt.


Tabelle 19.27     Eigenschaften des »ListView«-Steuerelements

Eigenschaft Beschreibung
Activation Gibt an, wie ein Element der Listenansicht aktiviert werden kann. Es sind Einstellungen gemäß der Enumeration ItemActivation möglich.
AllowColumnReader Die Einstellung True ermöglicht dem Anwender die Veränderung der Spaltenreihenfolge.
CheckBoxes Mit der Einstellung True kann neben jedem Element des Steuerelements eine Checkbox angezeigt werden.
Columns Liefert die Referenz auf die ColumnHeaderCollection.
FullRowSelect Bei der Einstellung True wird in der Detailansicht nicht nur das Element, sondern auch alle seine Unterelemente markiert. Der Standard ist False.
GridLines Diese Eigenschaft gibt an, ob Linien zwischen den Zeilen und Spalten mit den Elementen und Unterelementen angezeigt werden. Der Standard ist False.
Groups Liefert die Referenz auf die ListViewGroupCollection.
HeaderStyle Diese Eigenschaft legt fest, ob in der Detailansicht Spaltenköpfe angezeigt werden und ob diese angeklickt werden können. Diese Eigenschaft kann die Werte None, Clickable und Nonclickable annehmen. Der Standard ist Clickable.
HotTracking Ermöglicht das Anzeigen der Elemente als Hyperlinks, wenn die Maus darüber bewegt wird.
HoverSelection Die Einstellung True bewirkt, dass das Listenelement ausgewählt wird, wenn der Mauszeiger sich einige Sekunden über diesem Element befindet. Der Standard ist False.
Items Liefert die Referenz auf die Auflistung der angezeigten Elemente.
LabelEdit Ermöglicht die Beschriftung der Elemente durch den Benutzer.
LabelWrap Gibt an, ob die Beschriftung von Elementen umbrochen wird, wenn Elemente im Steuerelement als große Symbole angezeigt werden. Der Standard ist True.
LargeImageList Legt die ImageList fest, die verwendet werden soll, wenn die Elemente im Steuerelement als große Symbole angezeigt werden.
MultiSelect Bei der Einstellung True können mehrere Listeneinträge gleichzeitig ausgewählt werden.
ShowGroups Legt fest, ob die Listenelemente in Gruppenform angezeigt werden.
SmallImageList Legt die ImageList fest, die verwendet werden soll, wenn die Elemente im Steuerelement als kleine Symbole angezeigt werden.
Sorting Gibt an, wie die Elemente sortiert werden sollen.
StateImageList Ruft die ImageListab, die den von der Anwendung definierten Zuständen im Steuerelement zugeordnet ist.

Die Ereignisse des »ListView«-Steuerelements

Es sind nicht wenige Ereignisse, die eine ListView dem Entwickler anbietet. Ich möchte Ihnen hier nur drei steuerelementspezifische Ereignisse vorstellen, die besonders erwähnenswert sind:

gp  SelectedIndexChanged wird ausgelöst, wenn der Anwender ein anderes Element in der Listenansicht auswählt.
gp  ItemActivate wird ausgelöst, wenn der Anwender ein Element aktiviert. Welche Aktion als Aktivierung interpretiert wird, beschreibt die Einstellung der Eigenschaft Activation.
gp  ColumnClick tritt ein, wenn der Benutzer auf einen Spaltenkopf klickt. Dieses Ereignis ist insbesonders dann interessant, wenn eine Spalte sortiert werden soll.

Die beiden zuerst angeführten Ereignisse sind vom Typ EventHandler. Das bedeutet, dass dem Ereignishandler keine weiteren Informationen zur Verfügung gestellt werden. ColumnClick ist dagegen schon mitteilungsbedürftiger: Der Typ ColumnClickEventArgs liefert in der Eigenschaft Column den Index der angeklickten Spalte.


Galileo Computing

19.15.3 Listenelemente vom Typ »ListViewItem«  downtop

Hinzufügen und Verwalten der Listenelemente

Die in einer Listenansicht enthaltenen Elemente sind vom Typ ListViewItem und werden in der Ansicht Detail in der linken Spalte angezeigt oder in den Ansichten Kleine Symbole bzw. Große Symbole als Symbol. Ist die Detailansicht aktiviert, werden in weiteren Spalten die Eigenschaften des Elements angezeigt. Handelt es sich bei den Elementen um Dateien, könnten das beispielsweise die Dateigröße und der Typ sein.

Ein ListViewItem-Objekt ist immer eine Zeichenfolge. Das drückt sich auch in den Konstruktoren aus, die bis auf den parameterlosen alle eine Zeichenfolge oder ein Zeichenfolgen-Array erwarten. Mit der Methode Add der ListViewItemCollection der Listenansicht wird ein Listenelement dem Steuerelement hinzugefügt:


lvwPerson.Items.Add(New ListViewItem("Abel"))
lvwPerson.Items.Add(New ListViewItem("Müller"))
lvwPerson.Items.Add(New ListViewItem("Rosnick"))
lvwPerson.Items.Add(New ListViewItem(“Berenbach"))
lvwPerson.Items.Add(New ListViewItem("Keser"))

Hier ist lvwPerson das ListView-Objekt. Sie müssen nicht unbedingt ausdrücklich die Klasse ListViewItem instanziieren. Sie können als Argument auch eine Zeichenfolge übergeben:


listView1.Items.Add("Müller")

Ein Listenelement kann durch spezifische Eigenschaften beschrieben werden. Jede Eigenschaft, auch als Unterelemente bezeichnet, wird durch ein Objekt vom Typ ListViewSubItem beschrieben. Alle Unterelemente sind ebenfalls nur Zeichenfolgen und werden von der Auflistung ListViewSubItemCollection des Listenelements verwaltet. Durch den Aufruf der Methode SubItems auf die Referenz eines Listenelements erhält man die Referenz auf die untergeordnete ListViewSubItemCollection. Die folgende Anweisung schreibt beispielsweise Bonn in die Zeichenfolgevariable item:


Dim item As String = lvwPerson.Items(2).SubItems(3).Text

Listeneinträge mit Bildchen

In den beiden Ansichten Große Symbole und Kleine Symbole können die Listenelemente über die entsprechende Einstellung der Eigenschaft View zur Laufzeit optisch ansprechend und übersichtlich dargestellt werden. Dazu sind der Form zwei ImageList-Steuerelemente hinzuzufügen, welche die gewünschten Symbole enthalten.

Außerdem kann ein Listenelement, unabhängig von der gewählten Ansicht, zur Laufzeit auch ein Bildchen anzeigen, das den ausgewählten bzw. nicht ausgewählten Zustand symbolisieren soll. Um Zustandssymbole anzubieten, sind einige Vorgaben einzuhalten. Zunächst müssen Sie der Form eine weitere Bildliste hinzufügen, in der nur zwei Symbole enthalten sein sollten: Das erste Bild mit dem Index 0 wird vor den nicht ausgewählten Listenelementen angezeigt, das Bild mit dem Index 1 vor den ausgewählten. Anschließend weisen Sie der Eigenschaft StateImageList des ListView-Objekts die Referenz auf diese Bildliste zu. Im letzten Schritt muss die Eigenschaft CheckBoxes=True gesetzt werden, denn Zustandssymbole ersetzen die Checkboxen.

Damit sind aber möglicherweise noch nicht alle Anforderungen erfüllt. Jedes ListViewItem-Objekt hat eine Eigenschaft StateImageIndex, die den aktuellen Index des angezeigten Symbols in der Bildliste beschreibt. Wenn Sie möchten, können Sie hier auch die Reihenfolge in der Bilderliste umkehren. Zur Laufzeit steht der Index des Bildes in direktem Zusammenhang zur Eigenschaft Checked des Listenelements.

Zur Laufzeit genügt ein Klick auf das Symbol, um ein Listenelement auszuwählen beziehungsweise in den ausgewählten Zustand zurückzuversetzen. Dabei wechselt das Symbol automatisch.

Die Auswahl der Listenelemente

In einer Listenansicht kann per Vorgabe entweder ein Element oder auch mehrere ausgewählt werden. Mit der Eigenschaft MultiSelect der Listenansicht wird das festgelegt. Die Standard-einstellung ist True.

Die Eigenschaft Selected eines Listenelements beschreibt den Auswahlzustand und kann nicht nur gelesen, sondern auch gesetzt werden, beispielsweise um bei der ersten Anzeige der Listenansicht bereits eine Vorauswahl getroffen zu haben.

Insbesondere wenn eine Mehrfachauswahl möglich ist, müssen zu einem bestimmten Zeitpunkt alle ausgewählten Listenelemente mittels Programmcode ermittelt werden, um darauf die erforderlichen Operationen ausführen zu können. ListView stellt daher, ähnlich wie eine ListBox, zwei Auflistungen bereit:

gp  SelectedIndexCollection
gp  SelectedListViewItemCollection

Beide Auflistungsklassen unterscheiden sich untereinander nur darin, wie die ausgewählten Listenelemente verwaltet werden.

gp  SelectedIndexCollection enthält die Indizes der ausgewählten Listenelemente.
gp  SelectedListViewItemCollection enthält die Referenzen auf die ausgewählten Listenelemente.

Um die beiden Auflistungen auszuwerten, bedarf es jeweils einer Eigenschaft: SelectedIndices und SelectedItems. Über welche Auflistung man auf ein ausgewähltes Listenelement zugreift (dafür gibt es in beiden Auflistungen einen Indexer), dürfte wohl eher eine Geschmacksfrage sein als auf einer Notwendigkeit basieren. Sie bekommen in jedem Fall die Referenzen auf die ausgewählten Listenelemente zurückgeliefert, um damit die erforderlichen Operationen auszuführen.

Die folgende Anweisung liest die Text-Eigenschaft des ersten ausgewählten Elements über den Indexer ein und gibt sie in einem Meldungsfenster aus:


MessageBox.Show(listView1.SelectedItems(0).Text)


Galileo Computing

19.15.4 Das Element »ListViewSubItem«  downtop

Die Unterelemente eines ListViewItem-Objekts werden durch die innere Klasse ListViewSubItem beschrieben. Jedes Unterelement wird durch eine Zeichenfolge beschrieben. Verwaltet werden die Unterelemente in der Auflistung ListViewSubItemCollection. An dieser Stelle muss noch einmal darauf hingewiesen werden, dass das erste Unterelement mit der In-dexposition 0 in der ListViewSubItemCollection immer das Element ist, das die Unterelemente besitzt. Wenn Sie alle Unterelemente abfragen wollen, müssen Sie demnach die Auflistung vom Index 1 an durchlaufen und nicht vom Index 0.

Unterelemente können Sie durch Aufruf des Konstruktors der Klasse erzeugen. Am geeignetsten ist dazu der Konstruktor, dem neben der beschreibenden Zeichenfolge im ersten Argument die Referenz auf das Listenelement übergeben wird, dem das neue Unterelement zugeordnet werden soll.


Public Sub New (ListViewItem, String)

Sie können bei der Erzeugung eines Listenelements auch sofort die Eigenschaften, also Unterelemente, festlegen. Benutzen Sie dazu bei der Instanziierung der Klasse ListViewItem einen Konstruktor, der ein Zeichenfolgen-Array entgegennimmt, werden alle Array-Elemente automatisch der Auflistung der Unterelemente hinzugefügt.

Etwas ungewöhnlich ist die Tatsache, dass sich jedes ListViewItem-Objekt nicht nur in die Auflistung ListViewItemCollection der Listenansicht einträgt, sondern gleichzeitig auch das erste Element in seiner eigenen ListViewSubItemCollection ist.


lvwPerson.Items.Add(new ListViewItem(New String() _
{"Abel","Rainer", "30", "Essen"}))
lvwPerson.Items.Add(new ListViewItem(New String() _
{"Müller", "Uwe", "25", "Berlin"}))
lvwPerson.Items.Add(new ListViewItem(New String() _
{"Rosnick", "Bernd", "44", "Bonn"}))
lvwPerson.Items.Add(new ListViewItem(New String() _
{"Berenbach", "Peter", "35", "Köln"}))
lvwPerson.Items.Add(new ListViewItem(New String() _
{"Keser", "Wolfgang", "48", "Düren"}))

Die Eigenschaften der Unterelemente

Mit spezifischen Eigenschaften ist der Typ ListViewSubItem-Klasse nicht besonders reichlich gesegnet. Neben der Eigenschaft Text, welche die textuelle Beschreibung des Unterelements enthält, gibt es nur noch die Eigenschaften BackColor, ForeColor und Font, um der Anzeige zur Laufzeit ein anderes oder vielleicht auch nur ansprechendes Aussehen zu verleihen.


Galileo Computing

19.15.5 Der Typ »ColumnHeader«  downtop

Neben der internen Auflistung ListViewItemCollection verfügt die ListView-Klasse über die schon weiter oben erwähnte Auflistung ColumnHeaderCollection, in der alle Spaltenköpfe vom Typ ColumnHeader aufgelistet sind. Diese werden nur in der Detailansicht angezeigt. Die Referenz auf die interne Auflistung liefert die Eigenschaft Columns. Auch für die Spaltendefinitionen stellt Visual Studio 2005 einen intuitiv zu bedienenden Assistenten zur Verfügung, der Ihnen das einfache Hinzufügen und Beschreiben der Spalten ermöglicht.

Ein Spaltenkopf wird nur durch wenige Eigenschaften beschrieben: Text legt die Beschriftung der Spalte fest, Width die Breite der Spalte und TextAlign die Ausrichtung der Spaltenüberschrift in der Spalte. Sie können im Spaltenkopf auch Symbole zeigen lassen. Dazu wertet das Objekt die Eigenschaft SmallImageList der ListView aus. Das einer Spalte zuzuordnende Bildchen tragen Sie in einer der beiden Eigenschaften ImageIndex oder ImageKey ein.

Über die schreibgeschützte Eigenschaft Index lässt sich die Position der Spalte innerhalb der ColumnHeaderCollection ermitteln. Der Wert entspricht nicht zwangsläufig der sichtbaren Position des Spaltenkopfes, denn wenn die Eigenschaft AllowColumnReorder der Listenansicht auf True eingestellt ist, kann der Anwender die Anzeigereihenfolge nach eigenem Ermessen festlegen.


Tabelle 19.28     Eigenschaften des »ColumnHeader«-Objekts

Eigenschaft Beschreibung
ImageIndex Ruft den Index des in der Spalte angezeigten Bilds ab oder legt diesen fest.
ImageKey Ruft den Schlüssel des in der Spalte angezeigten Bilds ab oder legt diesen fest.
Index Liefert die Position innerhalb der ColumnHeaderCollection zurück.
Text Legt den im Spaltenkopf angezeigten Text fest oder ruft ihn ab.
TextAlign Legt die horizontale Ausrichtung des in ColumnHeader angezeigten Textes fest oder ruft sie ab.
Width Legt die Breite der Spalte fest oder ruft sie ab.


Galileo Computing

19.15.6 Listenelemente Gruppen zuordnen  downtop

Im .NET Framework 2.0 wurde das Steuerelement ListView um ein sehr interessantes Feature ergänzt. Sie können nun alle angezeigten Elemente visuell logischen Gruppen zuordnen. Jede einzelne Gruppe wird durch einen Text beschrieben, der beliebig ausgerichtet werden kann. Gruppen sind vom Typ der Klasse ListViewGroup.

Die Gruppen eines ListView-Steuerelements werden, da es sich in der Regel um mehrere handelt, von einer Auflistung verwaltet, deren Referenz die Eigenschaft Groups des Steuerelements bereitstellt. Ein Assistent erleichtert Ihnen auch hier die Arbeit. Jedes Listenelement muss nach spezifischen Kriterien einer Gruppe zugeordnet werden, die Sie selbst festlegen können.

Sie weisen ein Element einer Gruppe zu, indem Sie die Gruppe im ListViewItem-Konstruktor angeben, die ListViewItem.Group-Eigenschaft festlegen oder das Element direkt der Items-Auflistung einer Gruppe hinzufügen. Alle Elemente, die keiner Gruppe zugewiesen sind, werden in der Standardgruppe angezeigt, welche die Headerbezeichnung Default trägt.


Tabelle 19.29     Eigenschaften des Gruppierungselements »ListViewGroup«

Eigenschaft Beschreibung
Header Legt die Beschriftung der Gruppe fest.
HeaderAlignment Legt die Ausrichtung der Beschriftung fest.
Items Ruft eine Auflistung mit allen Elementen ab, die dieser Gruppe zugeordnet sind.
Name Legt den Namen der Gruppe fest.

Entwickeln wir die Personenauflistung, die weiter oben begonnen wurde, weiter, wäre eine Gruppierung nach Altersklassen denkbar. Um jede Person einer Altersgruppe zuzuordnen, könnte man mit


For Each item As ListViewItem In lvwPerson.Items
setGroup(item)
Next

alle Listenelemente abgreifen und in der benutzerdefinierten Methode setGroup über die Gruppenzugehörigkeit entscheiden.


Private Sub setGroup(ByVal item As ListViewItem)
If (Convert.ToInt32(item.SubItems(2).Text) < 31) Then
item.Group = lvwPerson.Groups(0)
ElseIf (Convert.ToInt32(item.SubItems(2).Text) < 41) Then
item.Group = lvwPerson.Groups(1)
Else
item.Group = lvwPerson.Groups(2)
End If
End Sub

Abbildung
Hier klicken, um das Bild zu Vergrößern

Abbildung 19.26     Ausgabe von Gruppierungen

Sie können dem Benutzer auch die Entscheidung darüber, ob er die Gruppierung der Listen-elemente bevorzugt oder nicht, auch selbst überlassen. Die Anzeige lässt sich nämlich mit der Eigenschaft ShowGroups der Listenansicht beeinflussen. Per Vorgabe ist True eingestellt.


Galileo Computing

19.15.7 Sortierung der Spalten  downtop

ListView ermöglicht die Sortierung der Listeneinträge. Dazu müssen Sie der Eigenschaft Sorting, die vom Typ der Enumeration SortOrder ist, einen Wert zuweisen, der von der Vorgabe None abweicht. Alternativ können Sie eine aufsteigende Sortierreihenfolge mit Ascending und eine absteigende mit Descending erreichen. Das Kriterium der Sortierung sind dabei immer die Listenelemente, nicht die Unterelemente.

Wenn Sie sich den Windows-Explorer vor Augen halten, wissen Sie, dass bei einem Klick auf einen Spaltenkopf die Sortierreihenfolge der Listeneinträge anhand der Unterelemente in der angeklickten Spalte erfolgt. Das ist auch in einer ListView sehr einfach zu realisieren und braucht nur wenig Programmcode. Voraussetzung dafür ist, dass die Einstellung der Eigenschaft HeaderStyle= Clickable ist. Das ist gleichzeitig auch der Standard.

Zuständig für eine vom Standard abweichende Sortierung ist die Eigenschaft ListViewItemSorter, die nicht im Eigenschaftsfenster der Entwicklungsumgebung angezeigt wird:


Public Property ListViewItemSorter As IComparer

Wir müssen der Eigenschaft ein Objekt übergeben, das die Schnittstelle IComparer implementiert. Uns kommt dabei entgegen, dass alle Einträge in der Listenansicht vom Typ String sind. Daher benötigen wir nicht für jede Spalte eine eigene Vergleichsklasse, sondern kommen, wenn wir es geschickt anstellen, mit einer einzigen aus. In der Vergleichsklasse sollten wir auch noch eine übliche Verhaltensweise berücksichtigen: Wird ein Spaltenkopf ein zweites Mal angeklickt, kehrt sich die Sortierreihenfolge der Listenelemente um.

Ein Klasse, die alle Ansprüche erfüllt, kann wie folgt codiert werden:


Public Class ListViewComparer
Implements IComparer
Private col As Integer
Private order As SortOrder
Public Sub New(ByVal col As Integer, _
ByVal order As SortOrder)
Me.col = col
Me.order = order
End Sub
Public Function Compare(ByVal x As Object, _
ByVal y As Object) As Integer _
Implements System.Collections.IComparer.Compare
Dim item1, item2 As ListViewItem
item1 = x
item2 = y
If Me.order = SortOrder.Ascending Then
Return item1.SubItems(col).Text.CompareTo( _
item2.SubItems(col).Text)
Else
Return item2.SubItems(col).Text.CompareTo( _
item1.SubItems(col).Text)
End If
End Function
End Class

Um die Allgemeingültigkeit der Klasse zu gewährleisten, übergeben wir dem Konstruktor sowohl den Index der angeklickten Spalte als auch die gewünschte Sortierreihenfolge. Diese Informationen werden von der Methode Compare als Grundlage des Vergleichs benötigt, der zwei Objekte vom Typ ListViewItem übergeben werden. Es stellt sich nun positiv heraus, dass das etwas eigenartige Verhalten eines ListViewItem-Objekts, sich in seine eigene ListViewSubItemCollection einzutragen, nun für uns von großem Nutzen ist. Auch die konstante Indizierung der Spaltenköpfe, die nicht zwangsläufig der sichtbaren Reihenfolge entspricht (wenn AllowColumnReorder=True eingestellt ist), macht die Vergleichsoperation denkbar einfach.

Bei genauer Betrachtung hat die Klassendefinition sogar einen allgemeinen Charakter und kann, wenn keine besonderen Vergleichskriterien eine Rolle spielen, praktisch von jeder Listenansicht benutzt werden.

Wir wollen jetzt die Liste der Personen, der wir uns im Laufe des Abschnitts schon einige Male bedient haben, vervollständigen und im ListView auch die Spaltensortierung vorsehen.


' ----------------------------------------------------------
' Beispiel: ...\Kapitel 19\SortedColumns
' ----------------------------------------------------------
Public Class Form1
Private Sub Form1_Load(...) Handles MyBase.Load
lvwPerson.Items.Add(New ListViewItem(New String() _
{"Abel", "Rainer", "30", "Essen"}))
lvwPerson.Items.Add(New ListViewItem(New String() _
{"Müller", "Uwe", "25", "Berlin"}))
lvwPerson.Items.Add(New ListViewItem(New String() _
{"Rosnick", "Bernd", "44", "Bonn"}))
lvwPerson.Items.Add(New ListViewItem(New String() _
{"Berenbach", "Peter", "35", "Köln"}))
lvwPerson.Items.Add(New ListViewItem(New String() _
{"Keser", "Wolfgang", "48", "Düren"}))
For Each item As ListViewItem In lvwPerson.Items
setGroup(item)
Next
End Sub
Private Sub setGroup(ByVal item As ListViewItem)
If (Convert.ToInt32(item.SubItems(2).Text) < 31) Then
item.Group = lvwPerson.Groups(0)
ElseIf (Convert.ToInt32(item.SubItems(2).Text) < 41) Then
item.Group = lvwPerson.Groups(1)
Else
item.Group = lvwPerson.Groups(2)
End If
End Sub
Private Sub btnAddPerson_Click(...) _
Handles btnAddPerson.Click
Dim newPerson() As String = {"Hamster", "Karl", "34", "Bremen"}
lvwPerson.Items.Add(New ListViewItem(newPerson))
setGroup(lvwPerson.Items(lvwPerson.Items.Count – 1))
btnAddPerson.Enabled = False
End Sub
Private Sub lvwPerson_ColumnClick(ByVal sender As Object, _
ByVal e As ColumnClickEventArgs) _
Handles lvwPerson.ColumnClick
If lvwPerson.Sorting = SortOrder.Ascending Then
lvwPerson.Sorting = SortOrder.Descending
lvwPerson.ListViewItemSorter = _
New ListViewComparer(e.Column, SortOrder.Descending)
Else
lvwPerson.Sorting = SortOrder.Ascending
lvwPerson.ListViewItemSorter = _
New ListViewComparer(e.Column, SortOrder.Ascending)
End If
End Sub
End Class

Um die Sortierreihenfolge zu ändern, klickt der Anwender auf einen Spaltenkopf. Dabei wird das Ereignis ColumnClick ausgelöst, das in der Eigenschaft Column des Args-Parameters den Index des angeklickten Spaltenkopfs bereitstellt. Weil die Sortierreihenfolge bei jedem Anklicken umgekehrt werden soll, muss die aktuelle Einstellung der Eigenschaft Sorting zunächst überprüft und danach negiert werden. Anschließend kann die Vergleichsklasse unter Übergabe der entsprechenden Parameter instanziiert und der Eigenschaft ListViewItemSorter übergeben werden.

Um zu testen, wie sich das Hinzufügen eines weiteren Listenelements auf die Sortierreihenfolge auswirkt, enthält die Form außerdem noch eine Schaltfläche, die den entsprechenden Code aufweist. Sie werden feststellen, dass das neue Listenelement an der richtigen Position eingefügt wird. Sehr erfreulich ist auch, dass in der Gruppierungsansicht innerhalb einer Gruppe sich die Sortierreihenfolge richtig einstellt.


Hinweis

Ergänzen Sie die Listenansicht mit vielen Elementen unter Aufruf der Add-Methode, wird das Steuerelement jedes Mal neu gezeichnet. Möglicherweise kann das zum Flackern der Anzeige führen. Sie können das vermeiden, wenn Sie vor dem Hinzufügen der neuen Listenelemente mit der Methode BeginUpdate das wiederholte Neuzeichnen unterdrücken. Nach dem Hinzufügen des letzten Listenelements müssen Sie das ListView-Objekt mit EndUpdate jedoch neu aufbauen.



Galileo Computing

19.15.8 Listenelemente ändern  toptop

Standardmäßig werden die Listenelemente nur angezeigt und können nicht verändert werden. Mit der Eigenschaft LabelEdit=True der Listenansicht können Sie einem Anwender jedoch einräumen, den Text des Listenelements zu editieren. Zur Laufzeit muss dazu das zu ändernde Listenelement zunächst mit einem Klick markiert werden. Beim nächsten Klick befindet sich der Eingabecursor am Ende des Textes. Eine Möglichkeit, auch den Inhalt der Unterelemente zu verändern, gibt es nicht.

Eine Änderung hat nicht zur Folge, dass auch die zugrunde liegenden Daten geändert werden, wenn eine ListView beispielsweise die Listenelemente aus einer Datenbank bezogen hat. Im Kontext mit dem Zurückschreiben von Änderungen bieten sich zwei Ereignisse an: Before-LabelEdit und AfterLabelEdit. Das erste wird ausgelöst, sobald das Listenelement das zweite Click-Ereignis registriert hat und editierfähig geworden ist, das zweite Ereignis wird beim Verlassen der Eingabebox ausgelöst.

Beide Ereignisse stellen dem Ereignishandler im zweiten Parameter ein Objekt vom Typ LabelEditEventArgs zur Verfügung. Mit der Eigenschaft CancelEdit kann die Operation abgebrochen werden, Item ruft den Index des zur Änderung anstehenden ListViewItem-Objekts ab, und Label beinhaltet die Zeichenfolge, die der Text-Eigenschaft des Listenelements zugewiesen werden soll.

Um Daten in die Originaldatenquelle zurückzuschreiben, werden Sie den AfterLabelEdit-Ereignishandler codieren. Hier bietet es sich an, beispielsweise eine Eingabeüberprüfung vorzunehmen. Die Eigenschaft Label liefert die zur Überprüfung notwendige Information. Brechen Sie die Operation mit CancelEdit=True ab, wird der ursprüngliche Inhalt automatisch wiederhergestellt.

 <<   zurück
  
 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchtipps
Zum Katalog: Visual Basic 2012






 Visual Basic 2012


Zum Katalog: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Katalog: IT-Handbuch für Fachinformatiker






 IT-Handbuch für
 Fachinformatiker


Zum Katalog: Professionell entwickeln mit Visual C# 2012






 Professionell
 entwickeln mit
 Visual C# 2012


Zum Katalog: Windows Presentation Foundation






 Windows Presentation
 Foundation


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo





Copyright © Rheinwerk Verlag GmbH 2007
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.


[Rheinwerk Computing]

Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de