# ListView Ein `ListView` ist ein Steuerelement zur Darstellung einer Sammlung von Elementen. Je nach Einstellung können die Elemente als große oder kleine Symbole, als einfache Liste oder als Tabelle mit mehreren Spalten dargestellt werden. Im Gegensatz zu einer `ListBox` kann ein `ListView` zusätzliche Informationen zu jedem Eintrag darstellen und eignet sich dadurch besonders für Datei- und Datenübersichten. --- ## **Grundlagen** Ein `ListView` besteht im Wesentlichen aus drei Komponenten: - `ListView` → stellt die Liste dar - `ListViewItem` → repräsentiert einen einzelnen Eintrag - `ListViewSubItem` → enthält zusätzliche Spaltenwerte eines Eintrags Beispielsweise kann eine Dateiliste so aufgebaut werden:
NameTypGröße
`Dokument.txt`Textdatei12 KB
`Bild.png`Bild1,4 MB
`Programm.exe`Anwendung8 MB
Dabei entspricht jede Zeile einem `ListViewItem` und jede zusätzliche Spalte einem `ListViewSubItem`. --- #### ListView erstellen ```powershell # Klassisch $listView = New-Object System.Windows.Forms.ListView # .NET-Style $listView = [System.Windows.Forms.ListView]::new() ``` --- #### ListView hinzufügen Ein `ListView` wird wie jedes andere Control der `Controls`-Collection seines Parent-Containers hinzugefügt. ```powershell $form.Controls.Add($listView) # oder $tabPage.Controls.Add($listView) ``` --- #### Einfache Einträge hinzufügen Ein einzelner Eintrag kann direkt über die `Items`-Collection hinzugefügt werden. ```powershell $listView.Items.Add("Dokument.txt") $listView.Items.Add("Bild.png") $listView.Items.Add("Programm.exe") ``` --- ## **Eigenschaften**
EigenschaftBeschreibung
`Activation`Bestimmt, wie Listenelemente durch den Mauszeiger aktiviert werden.
`Alignment`Bestimmt die Anordnung der Elemente bei Symbolansichten.
`AutoArrange`Ordnet Elemente bei Symbolansichten automatisch an.
`BackColor`Legt die Hintergrundfarbe fest.
`CheckBoxes`Zeigt neben jedem Eintrag eine Checkbox an.
`Columns`Enthält die Spalten des `ListView`.
`Dock`Dockt das `ListView` am Parent-Container an.
`Enabled`Legt fest, ob das `ListView` verwendet werden kann.
`Font`Legt Schriftart, -größe und -stil fest.
`ForeColor`Legt die Textfarbe fest.
`FullRowSelect`Markiert bei `Details` die gesamte Zeile eines ausgewählten Eintrags.
`GridLines`Zeigt bei `Details` Gitternetzlinien zwischen Zeilen und Spalten an.
`Groups`Enthält die Gruppen des `ListView`.
`HeaderStyle`Bestimmt die Darstellung der Spaltenüberschriften.
`HideSelection`Legt fest, ob eine Auswahl beim Verlust des Fokus sichtbar bleibt.
`HoverSelection`Wählt ein Element automatisch aus, wenn der Mauszeiger darüber bewegt wird.
`Items`Enthält alle `ListViewItem` des `ListView`.
`LabelEdit`Erlaubt das direkte Bearbeiten der Beschriftung eines Eintrags.
`LabelWrap`Legt fest, ob Beschriftungen in Symbolansichten umgebrochen werden.
`LargeImageList`Enthält die Bilder für die große Symbolansicht.
`Location`Bestimmt die Position im Parent-Container.
`Margin`Legt den äußeren Abstand fest.
`MultiSelect`Legt fest, ob mehrere Einträge gleichzeitig ausgewählt werden können.
`OwnerDraw`Legt fest, ob die Darstellung der ListView-Elemente vollständig oder teilweise selbst gezeichnet werden soll.
`Scrollable`Aktiviert bzw. deaktiviert Scrollleisten.
`SelectedItems`Enthält die aktuell ausgewählten Einträge.
`ShowGroups`Legt fest, ob Gruppen angezeigt werden.
`ShowItemToolTips`Aktiviert Tooltips für einzelne Einträge.
`Size`Bestimmt Breite und Höhe.
`SmallImageList`Enthält die Bilder für kleine Symbole.
`Sorting`Bestimmt die automatische Sortierung der Einträge.
`StateImageList`Enthält Statusbilder, beispielsweise für Checkbox-Zustände.
`TileSize`Bestimmt die Größe von Elementen in der `Tile`-Ansicht.
`View`Bestimmt die Darstellungsart des `ListView`.
`Visible`Legt fest, ob das `ListView` sichtbar ist.
---
CheckBoxes ### CheckBoxes **Typ** = `[System.Boolean]` Der Wert von `CheckBoxes` legt fest, ob neben jedem Eintrag eine Checkbox angezeigt wird. ```powershell $listView.CheckBoxes = $true ``` Der Zustand einer Checkbox wird über die Eigenschaft `Checked` des jeweiligen `ListViewItem` gesteuert. ```powershell $listView.Items[0].Checked = $true ``` > 💡 **Hinweis** Die Checkbox gehört zum jeweiligen `ListViewItem` und wird nicht über eine separate Collection verwaltet.
Columns ### Columns **Typ** = `[System.Windows.Forms.ListView.ColumnHeaderCollection]` Die Eigenschaft `Columns` enthält die Spalten des `ListView`. Spalten werden hauptsächlich in der `Details`-Ansicht verwendet. ```powershell $listView.View = "Details" $listView.Columns.Add("Name", 200) $listView.Columns.Add("Typ", 100) $listView.Columns.Add("Größe", 100) ``` Die zweite Angabe bestimmt dabei die Breite der Spalte in Pixeln. > 💡 **Hinweis** Die Spaltenüberschriften werden nur sichtbar, wenn `View` auf `Details` gesetzt ist.
FullRowSelect ### FullRowSelect **Typ** = `[System.Boolean]` Der Wert von `FullRowSelect` legt fest, ob bei einer Auswahl in der `Details`-Ansicht die gesamte Zeile markiert wird. Standardmäßig ist diese Eigenschaft deaktiviert. ```powershell $listView.FullRowSelect = $true ``` Ohne `FullRowSelect` wird bei der Auswahl hauptsächlich das erste Feld des Eintrags hervorgehoben. > 💡 **Hinweis** Die Eigenschaft ist insbesondere bei tabellarischen Darstellungen sinnvoll, da dadurch deutlich erkennbar ist, welche komplette Zeile ausgewählt wurde.
GridLines ### GridLines **Typ** = `[System.Boolean]` Der Wert von `GridLines` legt fest, ob zwischen den Zeilen und Spalten Gitternetzlinien angezeigt werden. ```powershell $listView.GridLines = $true ``` Die Gitternetzlinien werden nur in der `Details`-Ansicht angezeigt.
Groups ### Groups **Typ** = `[System.Windows.Forms.ListViewGroupCollection]` Die Eigenschaft `Groups` enthält die Gruppen des `ListView`. Eine Gruppe kann beispielsweise so erstellt werden: ```powershell $group = [System.Windows.Forms.ListViewGroup]::new("Dokumente") $listView.Groups.Add($group) ``` Ein `ListViewItem` kann anschließend einer Gruppe zugewiesen werden: ```powershell $item = [System.Windows.Forms.ListViewItem]::new("Dokument.txt") $item.Group = $group $listView.Items.Add($item) ```
Items ### Items **Typ** = `[System.Windows.Forms.ListViewItemCollection]` Die Eigenschaft `Items` enthält alle Einträge des `ListView`. Über die Collection können neue Einträge hinzugefügt, vorhandene Einträge entfernt oder einzelne Einträge abgerufen werden. ```powershell $listView.Items.Add("Dokument.txt") ``` Ein `ListViewItem` kann auch explizit erstellt werden: ```powershell $item = [System.Windows.Forms.ListViewItem]::new("Dokument.txt") $listView.Items.Add($item) ``` Die Collection enthält ausschließlich die Haupteinträge. Zusätzliche Spalten werden über die `SubItems` des jeweiligen `ListViewItem` verwaltet.
LabelEdit ### LabelEdit **Typ** = `[System.Boolean]` Der Wert von `LabelEdit` legt fest, ob der Benutzer die Beschriftung eines `ListViewItem` direkt im `ListView` bearbeiten kann. ```powershell $listView.LabelEdit = $true ``` Wird die Bearbeitung aktiviert, kann der Benutzer beispielsweise durch langsames Doppelklicken auf einen Eintrag dessen Text ändern. Die Ereignisse `BeforeLabelEdit` und `AfterLabelEdit` ermöglichen es, die Bearbeitung zu kontrollieren.
LargeImageList ### LargeImageList **Typ** = `[System.Windows.Forms.ImageList]` `LargeImageList` legt die `ImageList` für große Symbole fest. Sie wird insbesondere bei der Darstellungsart `LargeIcon` verwendet. ```powershell $listView.LargeImageList = $imageList $listView.View = "LargeIcon" ```
MultiSelect ### MultiSelect **Typ** = `[System.Boolean]` Der Wert von `MultiSelect` legt fest, ob mehrere Einträge gleichzeitig ausgewählt werden können. Standardmäßig ist `MultiSelect` auf `True` gesetzt. ```powershell $listView.MultiSelect = $false ``` Ist `MultiSelect` deaktiviert, kann immer nur ein `ListViewItem` ausgewählt werden.
OwnerDraw ### OwnerDraw **Typ** = `[System.Boolean]` Der Wert von `OwnerDraw` legt fest, ob die Darstellung des `ListView` vom Entwickler selbst gezeichnet werden soll. Standardmäßig besitzt diese Eigenschaft den Wert `False`, wodurch das `ListView` seine Elemente automatisch anhand der festgelegten Eigenschaften darstellt. Wird `OwnerDraw` auf `True` gesetzt, können die einzelnen Bereiche des `ListView` über die entsprechenden Zeichen-Events individuell gezeichnet werden. Dazu gehören unter anderem `DrawColumnHeader`, `DrawItem` und `DrawSubItem`. ```powershell $listView.OwnerDraw = $true ``` > 💡 **Hinweis** > Bei aktiviertem `OwnerDraw` müssen die entsprechenden `Draw...`-Events behandelt werden, wenn die Darstellung individuell angepasst werden soll. Andernfalls bleibt die Darstellung je nach verwendetem View und behandelten Events unvollständig.
SelectedItems ### SelectedItems **Typ** = `[System.Windows.Forms.ListView.SelectedListViewItemCollection]` Die Eigenschaft `SelectedItems` enthält alle aktuell ausgewählten `ListViewItem`. ```powershell $listView.SelectedItems ``` Der erste ausgewählte Eintrag kann beispielsweise so abgerufen werden: ```powershell $item = $listView.SelectedItems[0] Write-Host $item.Text ``` Bei aktiviertem `MultiSelect` kann die Collection mehrere Einträge enthalten. > ⚠️ **Hinweis** Vor dem Zugriff auf `[0]` sollte geprüft werden, ob überhaupt ein Eintrag ausgewählt wurde. ```powershell if ($listView.SelectedItems.Count -gt 0) { $item = $listView.SelectedItems[0] } ```
ShowGroups ### ShowGroups **Typ** = `[System.Boolean]` Der Wert von `ShowGroups` legt fest, ob die im `Groups`-Container definierten Gruppen angezeigt werden. ```powershell $listView.ShowGroups = $true ``` Gruppen werden hauptsächlich verwendet, um größere Mengen von Einträgen logisch zu unterteilen.
SmallImageList ### SmallImageList **Typ** = `[System.Windows.Forms.ImageList]` `SmallImageList` legt die `ImageList` fest, aus der das `ListView` kleine Symbole für seine Einträge bezieht. ```powershell $listView.SmallImageList = $imageList ``` Welches Bild für einen bestimmten Eintrag verwendet wird, wird über `ImageIndex` oder `ImageKey` des `ListViewItem` festgelegt. ```powershell $item.ImageKey = "document" ```
Sorting ### Sorting **Typ** = `[System.Windows.Forms.SortOrder]` Der Wert von `Sorting` bestimmt, ob und wie die Einträge automatisch sortiert werden. Folgende Werte stehen zur Verfügung:
WertBeschreibung
`None`Keine automatische Sortierung
`Ascending`Aufsteigende Sortierung
`Descending`Absteigende Sortierung
```powershell $listView.Sorting = "Ascending" ``` > 💡 **Hinweis** Die automatische Sortierung orientiert sich standardmäßig am Text des `ListViewItem`.
StateImageList ### StateImageList **Typ** = `[System.Windows.Forms.ImageList]` `StateImageList` enthält Bilder, die den Status eines `ListViewItem` darstellen. Sie kann beispielsweise verwendet werden, um unterschiedliche Zustände eines Eintrags visuell darzustellen. ```powershell $listView.StateImageList = $stateImageList ``` Der verwendete Zustand wird über `StateImageIndex` des jeweiligen `ListViewItem` festgelegt.
View ### View **Typ** = `[System.Windows.Forms.View]` Der Wert von `View` bestimmt, wie die Elemente des `ListView` dargestellt werden. Folgende Darstellungsarten stehen zur Verfügung:
WertBeschreibung
`Details`Tabellarische Darstellung mit Spalten
`LargeIcon`Große Symbole mit Beschriftung
`SmallIcon`Kleine Symbole mit Beschriftung
`List`Einfache Liste mit kleinen Symbolen
`Tile`Kachelansicht
Für eine tabellarische Darstellung muss `View` auf `Details` gesetzt werden. ```powershell $listView.View = "Details" ``` Beispiel für eine einfache Dateiliste: ```powershell $listView.View = "Details" $listView.Columns.Add("Name", 200) $listView.Columns.Add("Typ", 100) $listView.Columns.Add("Größe", 100) ``` > 💡 **Hinweis** Eigenschaften wie `Columns`, `GridLines` und `FullRowSelect` sind insbesondere für die `Details`-Ansicht relevant.
--- # ListViewItem Ein `ListViewItem` repräsentiert einen einzelnen Eintrag innerhalb eines `ListView`. Ein Eintrag besitzt mindestens einen sichtbaren Haupttext. Zusätzlich können weitere Werte über `SubItems` hinzugefügt werden. ### Eintrag mit mehreren Spalten ```powershell $item = [System.Windows.Forms.ListViewItem]::new("Dokument.txt") $item.SubItems.Add("Textdatei") $item.SubItems.Add("12 KB") $listView.Items.Add($item) ``` Bei folgendem `ListView`: ```powershell $listView.View = "Details" $listView.Columns.Add("Name", 200) $listView.Columns.Add("Typ", 100) $listView.Columns.Add("Größe", 100) ``` entsteht daraus:
NameTypGröße
Dokument.txtTextdatei12 KB
Dabei gilt: ```text ListViewItem ├── Text ├── SubItems[1] ├── SubItems[2] └── ... ``` Das erste `SubItem` entspricht dabei dem Haupttext des `ListViewItem`. --- ## **Methoden** ## Übersicht
MethodeBeschreibung
`ArrangeIcons()`Ordnet Symbole im `ListView` an.
`BeginUpdate()`Verhindert während einer Änderung die Aktualisierung der Darstellung.
`Clear()`Entfernt alle Einträge und Spalten.
`EndUpdate()`Aktiviert nach `BeginUpdate()` wieder die Aktualisierung.
`EnsureVisible()`Stellt sicher, dass ein bestimmter Eintrag sichtbar ist.
`FindItemWithText()`Sucht nach einem Eintrag anhand seines Textes.
`GetItemAt()`Ermittelt den Eintrag an einer bestimmten Position.
`HitTest()`Ermittelt, welches Element sich an einer Mausposition befindet.
`Sort()`Sortiert die Einträge.
---
BeginUpdate() ### BeginUpdate() Die Methode `BeginUpdate()` verhindert, dass das `ListView` während umfangreicher Änderungen nach jeder einzelnen Änderung neu gezeichnet wird. ```powershell $listView.BeginUpdate() foreach ($file in $files) { $listView.Items.Add($file.Name) } $listView.EndUpdate() ``` Dies ist besonders bei vielen Einträgen sinnvoll. > 💡 **Hinweis** `BeginUpdate()` sollte immer zusammen mit `EndUpdate()` verwendet werden. Andernfalls kann die Aktualisierung des Controls ausbleiben. Menschliche Softwareentwicklung hat also auch hier einen „vergessen, wieder einzuschalten“-Modus.
EndUpdate() ### EndUpdate() Die Methode `EndUpdate()` beendet die mit `BeginUpdate()` begonnene Aktualisierungssperre. ```powershell $listView.BeginUpdate() $listView.Items.Clear() $listView.Items.Add("Eintrag 1") $listView.Items.Add("Eintrag 2") $listView.EndUpdate() ``` Nach `EndUpdate()` wird das `ListView` wieder aktualisiert.
Clear() ### Clear() Die Methode `Clear()` entfernt alle Einträge und Spalten aus dem `ListView`. ```powershell $listView.Clear() ``` > ⚠️ **Hinweis** `Clear()` entfernt nicht nur die `Items`, sondern auch die `Columns`. Soll ausschließlich der Inhalt entfernt werden, sollte stattdessen `Items.Clear()` verwendet werden. ```powershell $listView.Items.Clear() ```
EnsureVisible() ### EnsureVisible() Die Methode `EnsureVisible()` sorgt dafür, dass ein bestimmter Eintrag im sichtbaren Bereich des `ListView` liegt. ```powershell $listView.EnsureVisible(10) ``` Der angegebene Parameter ist der Index des Eintrags. **Syntax** ```powershell $listView.EnsureVisible(Index) ```
FindItemWithText() ### FindItemWithText() Die Methode `FindItemWithText()` sucht nach einem `ListViewItem`, dessen Text mit dem angegebenen Suchtext übereinstimmt. ```powershell $item = $listView.FindItemWithText("Dokument.txt") ``` Wird kein passender Eintrag gefunden, wird `$null` zurückgegeben. ```powershell if ($item) { Write-Host "Eintrag gefunden: $($item.Text)" } ```
GetItemAt() ### GetItemAt() Die Methode `GetItemAt()` ermittelt das `ListViewItem`, das sich an einer bestimmten Position befindet. ```powershell $item = $listView.GetItemAt(50, 30) ``` Die Koordinaten beziehen sich auf das `ListView`. Wird an der angegebenen Position kein Eintrag gefunden, wird `$null` zurückgegeben.
Sort() ### Sort() Die Methode `Sort()` führt eine Sortierung der Einträge durch. ```powershell $listView.Sort() ``` Die Sortierreihenfolge wird durch die Eigenschaft `Sorting` bestimmt. ```powershell $listView.Sorting = "Ascending" $listView.Sort() ```
--- ## **Events** ## Übersicht
EventBeschreibung
`AfterLabelEdit`Wird ausgelöst, nachdem die Beschriftung eines Eintrags bearbeitet wurde.
`BeforeLabelEdit`Wird ausgelöst, bevor die Beschriftung eines Eintrags bearbeitet wird.
`ColumnClick`Wird ausgelöst, wenn auf eine Spaltenüberschrift geklickt wird.
`ItemActivate`Wird ausgelöst, wenn ein Eintrag aktiviert wird.
`ItemCheck`Wird ausgelöst, bevor sich der Checkbox-Zustand eines Eintrags ändert.
`ItemChecked`Wird ausgelöst, nachdem sich der Checkbox-Zustand geändert hat.
`ItemDrag`Wird ausgelöst, wenn ein Eintrag mit der Maus gezogen wird.
`ItemSelectionChanged`Wird ausgelöst, wenn sich der Auswahlzustand eines Eintrags ändert.
`SelectedIndexChanged`Wird ausgelöst, wenn sich die Auswahl im `ListView` ändert.
---
ItemSelectionChanged ### ItemSelectionChanged Das Event `ItemSelectionChanged` wird ausgelöst, wenn sich der Auswahlzustand eines `ListViewItem` verändert. ```powershell $listView.Add_ItemSelectionChanged({ param($sender, $e) Write-Host "Auswahl geändert: $($e.Item.Text)" }) ``` Über das Event-Argument `$e` kann unter anderem auf das betroffene `Item` zugegriffen werden. ```powershell $e.Item ``` Der neue Auswahlzustand kann über `IsSelected` ermittelt werden. ```powershell if ($e.IsSelected) { Write-Host "$($e.Item.Text) wurde ausgewählt." } ```
SelectedIndexChanged ### SelectedIndexChanged Das Event `SelectedIndexChanged` wird ausgelöst, wenn sich die Auswahl des `ListView` verändert. ```powershell $listView.Add_SelectedIndexChanged({ param($sender, $e) Write-Host "Auswahl geändert." }) ``` Das Event eignet sich insbesondere, wenn nach einer Änderung der Auswahl mit den aktuell ausgewählten Elementen gearbeitet werden soll. ```powershell $listView.Add_SelectedIndexChanged({ if ($this.SelectedItems.Count -gt 0) { Write-Host $this.SelectedItems[0].Text } }) ``` > 💡 **Hinweis** Wenn das konkrete betroffene `ListViewItem` benötigt wird, ist `ItemSelectionChanged` meist geeigneter.
ItemActivate ### ItemActivate Das Event `ItemActivate` wird ausgelöst, wenn ein `ListViewItem` aktiviert wird. Je nach `Activation`-Einstellung kann dies beispielsweise durch einen einfachen oder doppelten Mausklick erfolgen. ```powershell $listView.Add_ItemActivate({ param($sender, $e) if ($this.SelectedItems.Count -gt 0) { Write-Host "Aktiviert: $($this.SelectedItems[0].Text)" } }) ```
ItemChecked ### ItemChecked Das Event `ItemChecked` wird ausgelöst, nachdem sich der Checkbox-Zustand eines `ListViewItem` geändert hat. ```powershell $listView.Add_ItemChecked({ param($sender, $e) if ($e.Item.Checked) { Write-Host "$($e.Item.Text) aktiviert" } else { Write-Host "$($e.Item.Text) deaktiviert" } }) ``` Im Gegensatz zu `ItemCheck` findet die Änderung zu diesem Zeitpunkt bereits statt.
ItemCheck ### ItemCheck Das Event `ItemCheck` wird ausgelöst, bevor sich der Checkbox-Zustand eines `ListViewItem` ändert. ```powershell $listView.Add_ItemCheck({ param($sender, $e) Write-Host "Checkbox wird geändert." }) ``` Das Event eignet sich insbesondere, wenn die Änderung geprüft oder verhindert werden soll. Der geplante neue Zustand steht in `NewValue`. ```powershell $listView.Add_ItemCheck({ param($sender, $e) Write-Host "Neuer Zustand: $($e.NewValue)" }) ```
ColumnClick ### ColumnClick Das Event `ColumnClick` wird ausgelöst, wenn der Benutzer auf eine Spaltenüberschrift klickt. ```powershell $listView.Add_ColumnClick({ param($sender, $e) Write-Host "Spalte $($e.Column) wurde angeklickt." }) ``` `Column` enthält den Index der angeklickten Spalte. Das Event eignet sich beispielsweise, um beim Klick auf eine Spaltenüberschrift die Sortierreihenfolge zu ändern.
BeforeLabelEdit ### BeforeLabelEdit Das Event `BeforeLabelEdit` wird ausgelöst, bevor die Beschriftung eines `ListViewItem` bearbeitet wird. ```powershell $listView.Add_BeforeLabelEdit({ param($sender, $e) Write-Host "Bearbeitung wird gestartet." }) ``` Die Bearbeitung kann über `CancelEdit` verhindert werden. ```powershell $listView.Add_BeforeLabelEdit({ param($sender, $e) $e.CancelEdit = $true }) ```
AfterLabelEdit ### AfterLabelEdit Das Event `AfterLabelEdit` wird ausgelöst, nachdem die Beschriftung eines `ListViewItem` bearbeitet wurde. ```powershell $listView.Add_AfterLabelEdit({ param($sender, $e) Write-Host "Neuer Text: $($e.Label)" }) ``` Über `Label` kann der neu eingegebene Text abgerufen werden.
--- # Beispiel Das folgende Beispiel erstellt ein einfaches `ListView` zur Darstellung einer Dateiliste. ```powershell $listView = [System.Windows.Forms.ListView]::new() $listView.View = "Details" $listView.FullRowSelect = $true $listView.GridLines = $true $listView.MultiSelect = $false $listView.Dock = "Fill" $listView.Columns.Add("Name", 250) $listView.Columns.Add("Typ", 120) $listView.Columns.Add("Größe", 100) $item = [System.Windows.Forms.ListViewItem]::new("Dokument.txt") $item.SubItems.Add("Textdatei") $item.SubItems.Add("12 KB") $listView.Items.Add($item) $form.Controls.Add($listView) ``` Das Ergebnis entspricht konzeptionell: ```text ┌────────────────────────────────────────────────────────────┐ │ Name │ Typ │ Größe │ ├─────────────────────────┼─────────────┼────────────────────┤ │ Dokument.txt │ Textdatei │ 12 KB │ └─────────────────────────┴─────────────┴────────────────────┘ ``` --- # Häufige Kombinationen Für die praktische Verwendung sind einige Eigenschaftskombinationen besonders relevant: ### Tabellenansicht ```powershell $listView.View = "Details" $listView.FullRowSelect = $true $listView.GridLines = $true ``` ### Einzelauswahl ```powershell $listView.MultiSelect = $false ``` ### Checkbox-Liste ```powershell $listView.CheckBoxes = $true $listView.View = "Details" ``` ### Liste mit Symbolen ```powershell $listView.View = "SmallIcon" $listView.SmallImageList = $imageList ``` ### Große Symbolansicht ```powershell $listView.View = "LargeIcon" $listView.LargeImageList = $imageList ``` --- # Hinweise - `ListView` ist besonders für strukturierte Listen und tabellarische Darstellungen geeignet. - Für einfache Listen ohne zusätzliche Spalten ist `ListBox` meist einfacher. - `Columns` werden hauptsächlich in der `Details`-Ansicht verwendet. - Ein `ListViewItem` repräsentiert eine komplette Zeile. - Zusätzliche Spalten eines Eintrags werden über `SubItems` definiert. - `SelectedItems` enthält nur die aktuell ausgewählten Einträge. - Bei großen Datenmengen sollte `BeginUpdate()` und `EndUpdate()` verwendet werden, um unnötige Neudarstellungen zu vermeiden. - Für Bilder können `SmallImageList`, `LargeImageList` und `StateImageList` getrennt verwendet werden. - `FullRowSelect` und `GridLines` haben ihre wesentliche Bedeutung in der `Details`-Ansicht. - Mit `Groups` können Einträge zusätzlich logisch gruppiert werden. - Über `LabelEdit` können Benutzer Einträge direkt im `ListView` umbenennen. # Siehe auch - `ListBox` - `ImageList` - `ListViewItem` - `ListViewGroup` - `ColumnHeader` - `TableLayoutPanel` - `FlowLayoutPanel`