{"id":55000029,"date":"2016-04-01T00:00:00","date_gmt":"2020-03-27T19:18:06","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=29"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"WPFControls_Kombinationsfelder","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/WPFControls_Kombinationsfelder\/","title":{"rendered":"WPF-Controls: Kombinationsfelder"},"content":{"rendered":"

In den ersten Ausgaben des DATENBANKENTWICKLERs haben Sie bereits einige Steuerelemente kurz kennen gelernt. In den folgenden Ausgaben wird sich dies ändern. Im vorliegenden Artikel schauen wir uns das ComboBox-Steuerelement an, das Sie als Access-Entwickler ja vielleicht aus dem Eff-Eff kennen. Unter WPF läuft aber gewöhnlich alles etwas anders, sodass wir hier mit den Grundlagen einsteigen und uns dann Schritt für Schritt Themen wie der Datenbindung et cetera widmen. Außerdem dürfen wir vorwegnehmen, dass sich hier einige Möglichkeiten mehr ergeben …<\/b><\/p>\n

Wenn Sie ein ComboBox<\/b>-Steuerelement zu einem Fenster hinzufügen und das Debugging starten, erhalten Sie ein einfaches Kombinationsfeld, das beim Aufklappen keine Werte anzeigt und in das Sie auch keinen Text einfügen können. Das ist der erste Unterschied im Vergleich zu einem Access-Kombinationsfeld – dort können Sie zumindest gleich einen Wert eintippen.<\/p>\n

Eine recht einfache Definition eines solchen ComboBox<\/b>-Steuerelements sieht so aus:<\/p>\n

<ComboBox x:Name=\"comboBox\" HorizontalAlignment=\"Left\" Margin=\"127,10,0,0\" VerticalAlignment=\"Top\" Width=\"120\"\/><\/pre>\n
ComboBox mit statischen Werten<\/h2>\n
Soll die ComboBox <\/b>beim Öffnen des Fensters immer die gleichen Werte anzeigen, können Sie diese ganz einfach durch eine entsprechende XAML-Definition hinzufügen. Dies ähnelt dann dem Anlegen von Einträgen in einem HTML-Select-Element, allerdings verwenden Sie für jeden neuen Eintrag ein ComboBoxItem<\/b>-Element, das Sie unterhalb des ComboBox<\/b>-Elements anlegen:<\/p>\n
<ComboBox x:Name=\"comboBox\" ... >\r\n     <ComboBoxItem>Eintrag 1<\/ComboBoxItem>\r\n     <ComboBoxItem>Eintrag 2<\/ComboBoxItem>\r\n     <ComboBoxItem>Eintrag 3<\/ComboBoxItem>\r\n     <ComboBoxItem>Eintrag 4<\/ComboBoxItem>\r\n<\/ComboBox><\/pre>\n
Während Sie diese Einträge unterhalb des ComboBox<\/b>-Elements hinzufügen, zeigt der XAML-Editor direkt die Einträge in der Vorschau an (siehe Bild 1).<\/p>\n
\"WPF-Fenster<\/p>\n
Bild 1: WPF-Fenster mit einer Schaltfläche in drei verschiedenen Designs<\/span><\/b><\/p>\n
Im Betrieb erscheint dieses Kombinationsfeld nun wie in Bild 2. Beim Aufklappen zeigt es die vier Einträge an, die Auswahl eines Eintrags trägt diesen oben in das Steuerelement ein. Nun wollen wir dies noch erweitern, und zwar erstens durch die Eingabe von Texten durch den Benutzer.<\/p>\n
\"Statisches<\/p>\n
Bild 2: Statisches Kombinationsfeld mit vier Einträgen<\/span><\/b><\/p>\n
ComboBox bedienen<\/h2>\n
Natürlich wissen Sie, dass Sie eine ComboBox mit einem Mausklick auf den Pfeil nach unten öffnen und dass Sie dort Text eingeben und Einträge auswählen können. Aber haben Sie auch schon einmal nur mit der Tastatur auf eine ComboBox zugegriffen Sie können diese nämlich auch durch Betätigen der Taste F4 <\/b>öffnen oder schließen. Auch die Tastenkombinationen Alt + Nach oben <\/b>oder Alt + Nach unten <\/b>öffnen und schließen die Liste des ComboBox<\/b>-Steuerelements. Schließlich blättern Sie auch bei nicht ausgeklappter Liste mit den Tasten Nach oben <\/b>und Nach unten <\/b>durch die Einträge, wobei Nach oben <\/b>vom obersten Element und Nach unten <\/b>vom untersten Element aus keine Auswirkungen zeigen.<\/p>\n
Eingabe von Werten aktivieren<\/h2>\n
Um das Eingabefeld des Kombinationsfeldes zu aktivieren, fügen Sie einfach nur das Attribut IsEditable <\/b>zum ComboBox<\/b>-Element hinzu und stellen es auf den Wert True <\/b>ein:<\/p>\n
<ComboBox x:Name=\"cboMitEingabe\" ... IsEditable=\"True\">\r\n     <ComboBoxItem Content=\"Eintrag 1\"\/>\r\n     ...\r\n<\/ComboBox><\/pre>\n
Damit können Sie nun Werte wie in Bild 3 eingeben. Allerdings fügt dies den Wert noch nicht zur Auswahlliste hinzu.<\/p>\n
\"Hinzufügen<\/p>\n
Bild 3: Hinzufügen eines eigenen Textes<\/span><\/b><\/p>\n
Wenn Sie den Anfangsbuchstaben eines der bereits in der Liste enthaltenen Einträge eingeben, wird dieser übrigens gleich als Eintrag vorgeschlagen (siehe Bild 4) – wie auch unter Access. Nach der Eingabe eines Wertes in das Textfeld prüft die ComboBox, ob dieser Wert bereits in der Liste enthalten ist. Falls ja, wird dieser Eintrag als markiert gekennzeichnet – später schauen wir uns an, wie wir dies nutzen können. Ist der Wert nicht vorhanden, hat die Liste keinen selektierten Eintrag. In beiden Fällen wird der Wert jedoch in die Eigenschaft Text <\/b>des ComboBox<\/b>-Steuerelements eingetragen.<\/p>\n
\"Autoergänzung<\/p>\n
Bild 4: Autoergänzung standardmäßig<\/span><\/b><\/p>\n
IsEditable und IsReadOnly<\/h2>\n
Selbst wenn Sie das Attribut IsEditable <\/b>auf True <\/b>eingestellt haben, können Sie die Eingabe von Texten in das Textfeld des Kombinationsfeldes unterbinden. Dazu stellen Sie die Eigenschaft IsReadOnly <\/b>ebenfalls auf True <\/b>ein. Der Unterschied zwischen IsEditable=False <\/b>sowie IsEditable=True <\/b>und IsReadOnly=True <\/b>ist, dass der Hintergrund des Eingabefeldes nicht grau, sondern weiß dargestellt wird.<\/p>\n
<ComboBox x:Name=\"cboMitEingabe\" ... IsEditable=\"True\" \r\n         IsReadOnly=\"True\">\r\n     ...\r\n<\/ComboBox><\/pre>\n
Ein Element vorauswählen per XAML<\/h2>\n
Unter Access\/VBA haben Sie etwa die folgende Zeile verwendet, um beispielsweise den ersten Eintrag eines Kombinationsfeldes etwa beim Öffnen des Formulars zu markieren:<\/p>\n
Me!cboEintraege = Me!cboEintraege.ItemData(0)<\/pre>\n
Unter WPF können Sie dieses Element gleich in der Definition markieren, sofern diese überhaupt per Definition festgelegt und nicht dynamisch mit einer anderen Datenherkunft gefüllt wird. Dazu fügen Sie dem zu markierenden Eintrag das Attribut IsSelected <\/b>mit dem Wert True <\/b>hinzu:<\/p>\n
<ComboBox x:Name=\"cboMitStandardwert\" ... \r\n         IsEditable=\"True\" IsReadOnly=\"True\">\r\n     <ComboBoxItem Content=\"Eintrag 1\" IsSelected=\"True\"\/>\r\n     <ComboBoxItem Content=\"Eintrag 2\"\/>\r\n     <ComboBoxItem Content=\"Eintrag 3\"\/>\r\n     <ComboBoxItem Content=\"Eintrag 4\"\/>\r\n<\/ComboBox><\/pre>\n
Das Ergebnis finden Sie in Bild 5. Der Text des gewählten Eintrags wird nicht nur im Eingabefeld angezeigt, sondern beim Ausklappen der Liste auch optisch hervorgehoben (siehe Beispiel 3a des Beispielprojekts).<\/p>\n
\"ComboBox<\/p>\n
Bild 5: ComboBox mit voreingestelltem Wert<\/span><\/b><\/p>\n
Ein Element vorauswählen per C#<\/h2>\n
Natürlich können Sie ein Element auch per Code auswählen wie unter Access\/VBA. Dazu nutzen wir die Ereignismethode, die durch das Ereignis Loaded <\/b>des Fensters ausgelöst wird. Damit diese bekannt ist, fügen wir die Eigenschaft Loaded <\/b>zum Window<\/b>-Element hinzu (dazu den Attributnamen eingeben, Tabulator-Taste drücken und den dann erscheinenden Eintrag  <\/b>auswählen, um die Methode gleich automatisch anzulegen):<\/p>\n
<Window x:Class=\"ComboBoxBeispiele.MainWindow\" ...        Title=\"MainWindow\" ... Loaded=\"Window_Loaded\"><\/pre>\n
Diese Methode füllen Sie im C#-Modul zum Fenster wie folgt mit einer einzigen Anweisung auf:<\/p>\n
private void Window_Loaded(object sender, RoutedEventArgs e) {\r\n     cboMitStandardwertCSharp.SelectedIndex = 0;\r\n}<\/pre>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t
\n\n\t\t\n\t\t