Mein Einstieg in VB.NET, Kapitel 3 In diesem Kapitel geht es um die kostenlose Entwicklungsumgebung von Visual Basic 2005 Express Edition. Neben Beschreibungen der Entwicklungsumgebung sind natürlich auch wieder praktische Beispiele enthalten.
Autor:  Ralf Ehlert	Bewertung:     [ Jetzt bewerten ]	Views:  56.451

Geben Sie hier Ihre persönliche Bewertung ab! Anzahl Bewertungen bisher: 19 Bewertung insgesamt: gut Durchschnittliche Bewertung: 3.9 von 5 Sternen

sehr gut     gut     nützlich     mittelmäßig     mangelhaft

In diesem Kapitel geht es um die kostenlose Entwicklungsumgebung von Visual Basic 2005 Express Edition. Neben Beschreibungen der Entwicklungsumgebung sind natürlich auch wieder praktische Beispiele enthalten.

Und diese Themen erwarten uns:

• 3. Windows Forms
• 3.1. Installation der benötigten Komponenten
• 3.2. Erste Schritte mit VB2005
• 3.3. Die wichtigsten Controls
• 3.4. Dialoge verwenden
• 3.5. MIDI-Anwendungen

Und nun viel Spaß beim Lesen.

3. WINDOWS FORMS

In diesem Abschnitt soll behandelt werden, wie man Windowsanwendungen entwickeln kann. Neben dem Wissen, wie Windowsanwendungen unter .NET entwickelt werden, werden Sie auch lernen, mit der Express Edition von Visual Basic 2005 (ich verwende jetzt VB2005 als Abkürzung) umzugehen.

Als erstes möchte ich auf die Installation eingehen, damit wir startklar für Windows Forms sind.

3.1. Installation der benötigten Komponenten

Die Installation ist einfach. Sie können einen Web-Installer oder ein CD-Image (462 MB) herunterladen. In dem Image sind alle benötigten Komponenten enthalten, zusätzliche Komponenten müssen nicht installiert werden.

Egal für welche Variante Sie sich entscheiden (ich würde das Image bevorzugen, denn dieses können Sie auf CD brennen und so immer bequem wieder neu installieren), starten Sie einfach das Setup und folgen Sie den Anweisungen. Wenn die Installation abgeschlossen ist, sind Sie startklar. Los geht's.

3.2. Erste Schritte mit VB2005

Ihre erste Windowsanwendung haben Sie schon zu Beginn des 2. Kapitels erstellt, aber jetzt lernen Sie die Windowsprogrammierung ausführlich kennen, genauso wie VB2005. Wenn Sie VB2005 starten, werden Sie folgendes sehen:

Wir werden uns die einzelnen Fenster während des folgenden Beispielprojektes genauer ansehen. Legen wir los:

Klicken Sie auf der Startseite auf den Link ERSTELLEN: PROJEKT..., es öffnet sich der Dialog NEUES PROJEKT:

Klicken Sie als Projektvorlage auf WINDOWS-ANWENDUNG und geben Sie unter NAME den Namen des Projektes ein. Als Beispielprojekt programmieren wir eine Windowsvariante des"Hello World"-Programmes. Nachdem Sie alle Angaben gemacht haben, klicken Sie auf den Button OK und das Projekt wird erstellt. Nach der Erstellung werden Sie folgendes sehen:

Auf der rechten Seite finden Sie den Projektmappen-Explorer. Hier sehen Sie alle in einer Solution (= Projektmappe) enthaltenden Projekte und deren Dateien in Form einer Baumstruktur.

Darunter finden Sie das Eigenschaftsfenster. Hier können Sie Eigenschaften von ausgewählten Objekten setzen.

Links daneben ist der Windows Designer, wenn Sie im Designmodus sind. Wie Sie sehen, wurde ein leeres Fenster erstellt. Sie können die Anwendung jetzt schon starten. Dazu gibt es mehrere Möglichkeiten:

1. Sie klicken auf DEBUGGEN|DEBUGGEN STARTEN
2. Sie drücken auf die Taste F5
3. Sie klicken auf

Wie Sie die Anwendung starten, ist egal, denn das Resultat ist immer das Gleiche (was für ein Wunder ): eine Form, die fast nichts kann. Das werden wir jetzt aber ändern. Dafür schließen Sie zuerst die Anwendung, oder Sie klicken auf den Button . Um jetzt Steuerelemente hinzuzufügen, öffnen Sie die Toolbox. Diese finden Sie am linken Fensterrand oder rufen Sie über ANSICHT|TOOLBOX auf.
 

Beginnen wir mit dem Designen. Ziehen Sie zuerst ein LABEL in die linke obere Ecke und lassen Sie danach die Maus los. Jetzt setzen wir für dieses Steuerelement(= Control) die Eigenschaften. Dazu zählen, Schriftart, Schriftfarbe, der angezeigte Text, die Ausrichtung, Docking und vieles mehr. Sie können entscheiden, ob die Eigenschaften alphabetisch oder in Kategorien sortiert werden sollen. Ich bevorzuge die alphabetische Sortierung. Wenn Sie auf eine Eigenschaft klicken, wird ganz unten eine kurze Beschreibung angezeigt:

Ändern Sie die Text-Eigenschaft in "Ihr Name:". Ordnen Sie eine Textbox neben dem Label an und zum Schluss einen Button unterhalb. Setzen Sie die Eigenschaften wie folgt:

Passen Sie jetzt noch die Größe und Position der Controls an und der fertige Entwurf könnte so aussehen:

Sie können natürlich auch noch die Schrift anpassen, wenn Ihnen mein Entwurf zu langweilig ist, das ist Ihnen überlassen. Lassen Sie uns die Anwendung starten. Der Button ist noch ohne Funktion, das werden wir aber gleich ändern. Aber wenn Sie das Fenster in der Größe ändern, passen sich die Controls der neuen Größe nicht an. Das wollen wir noch machen.

Damit die Controls automatisch ihre Größe ändern, können zwei Eigenschaften verwendet werden. Einmal Dock, womit sich das Control an eine Seite andockt und Anchor. Anchor bedeutet zu Deutsch Anker. Mit dieser Eigenschaft geben Sie an, welche Abstände zu welcher Seite konstant bleiben sollen. Ob die Eigenschaften richtig gesetzt sind, können Sie gleich probieren. Vergrößern Sie einfach die Form und schauen, ob sich die Controls so vergrößern, wie gewünscht. In unserer Beispielanwendung setzen Sie die Eigenschaften wie folgt:

Zum Schluss setzen Sie die Eigenschaft MinimumSize auf einen Wert, der Ihnen als vernünftig erscheint.

Bis jetzt haben wir nur mit dem Designer rumgespielt. Jetzt hauchen wir dem Button Funktionalität ein. Um anzugeben, was passiert, wenn der Button angeklickt wird, müssen wir einen Ereignishandler für dasClick-Ereignis schreiben. Dazu klicken Sie doppelt auf den Button. Wie Sie sehen, generiert die IDE das Gerüst der Prozedur, vervollständigen müssen wir das aber noch selbst. Bevor ich auf den einzufügenden Code komme, gehe ich kurz auf die Parameter ein.

Den Parameter sender hat jeder Ereignishandler, dieser enthält das Control, welches das Ereignis ausgelöst hat. Das ist einleuchtend. Und was verbirgt sich hinter deme? Das e steht immer für EventArgs, also für Eventargumente. Diese sind von Event zu Event unterschiedlich. Bei Mausbewegungen enthalten diese z.B. die X- und Y-Koordinate der Maus oder bei Tastatureingaben welche Taste gedrückt wurde usw. Soviel zur Bedeutung der Parameter.

Jetzt geben wir unseren Code ein. Das Ergebnis soll sein, den Namen, der in der Textbox steht, in einer Meldungsbox auszugeben. Und die Codezeile sieht so aus:

MessageBox.Show("Hallo " & txtName.Text)

Um eine Meldungsbox anzuzeigen, verwenden Sie die Show-Methode der MessageBox-Klasse. Die Show-Methode ist überladen. Zusätzlich zum Meldungstext kann man Titel, Buttons, Icon und Standardbutton (Default Button) festlegen und noch einiges mehr. Diese Überladung würde allgemein so aussehen:

MessageBox.Show(text, caption, messageBoxButtons, messageBoxIcon, messageBoxDefaultButton)

Die Parameter text und caption sind vom Typ String und geben den Meldungstext und Titel an. Die anderen Parameter sind Enumerationen, die den anklickbaren Button definieren, das Icon und den Standardbutton. Hier eine Übersicht über die verschiedenen Enumerationen mit Erklärung:

MessageBoxButtons:

MessageBoxIcon:

MessageBoxDefaultButton:

Wie Sie sehen, sind diese Enumerationen selbsterklärend. Mit der oben genannten Überladung können Sie die MessageBox an jede Situation anpassen. Allerdings woher wissen Sie, welcher Button angeklickt wurde? Dafür gibt es natürlich eine Lösung. Die MessageBox gibt nämlich etwas zurück: eine Enumeration vom Typ DialogResult. Und diese enthält alle Konstanten der möglichen Buttons. Sie können damit z. B. mit Select-Case prüfen, was der Benutzer angeklickt hat:

Dim result As DialogResult = MessageBox.Show( _
  "Möchten Sie wirklich beenden?", "Frage", MessageBoxButtons.YesNo, _
  MessageBoxIcon.Question, MessageBoxDefaultButton.Button2)
 
Select Case result
  Case DialogResult.Yes
  ' Es wurde auf Ja geklickt
  Case DialogResult.No
  ' Es wurde auf Nein geklickt
End Select

Mit so einem Konstrukt können Sie leicht auf die Eingaben des Benutzers reagieren.

So, eine Abfrage wollen wir in unserer Anwendung auch einbauen. Wir wollen den Benutzer fragen, ob er die Anwendung wirklich beenden will. Aber wann wissen wir, dass die Anwendung (oder besser gesagt, die Form), geschlossen wird? Natürlich durch Ereignisse. Dafür hat die Form zwei Stück: FormClosing und FormClosed. Was ist jetzt das richtige? FormClosing tritt auf, wenn das Fenster geschlossen wird und FormClosed wenn es geschlossen ist. Wir brauchen FormClosing, denn unsere Abfrage ist nutzlos, wenn das Fenster schon geschlossen ist.

Um den passenden EventHandler zu erzeugen, wechseln Sie in den Designmodus, wählen die Form an und klicken Sie auf den kleinen gelben Blitz , gefolgt von einem Doppelklick auf das Ereignis. Und jetzt kommt noch folgender Code rein:

If MessageBox.Show("Möchten Sie wirklich beenden?", _
  "Hello Windows", MessageBoxButtons.YesNo, MessageBoxIcon.Question, _
  MessageBoxDefaultButton.Button2) = DialogResult.No Then
    e.Cancel = True
End If

Da wir nur zwei Buttons haben und bei Nein das Beenden abbrechen wollen, reicht hier eine If-Anweisung. Wenn auf Nein geklickt wurde, brechen wir das Beenden ab, indem wir e.Cancel auf True setzen. Über die Eventargs (e) können wir auch erfahren, warum das Fenster geschlossen wird (CloseReason). Mögliche Gründe sindz. B. Klick des Benutzers, der Task-Manager beendet das Programm, das Herunterfahren des PCs, ... Auch auf die Gründe können Sie also reagieren umz. B. Dateien zu schließen oder andere Ressourcen freizugeben.

Hinweis: Die Eigenschaft CloseReason ist neu in .NET 2.0 und ist bei den Versionen 1.0 und 1.1 nicht verfügbar.

Jetzt ist unsere kleine Beispielanwendung fertig und wir werden uns jetzt die wichtigsten Controls anschauen und lernen, diese einzusetzen.

3.3. Die wichtigsten Controls

In diesem Abschnitt werden die wichtigsten Controls vorgestellt, mit denen Sie Ihre Anwendungen erstellen. Eigenschaften, die mit einem * gekennzeichnet sind, sind nur unter .NET 2.0 verfügbar.

3.3.1. Form

Auch wenn eine Form im eigentlichen Sinne kein Control ist, möchte ich es genauer beleuchten, denn es enthält einige interessante Eigenschaften.

3.3.1.1. Methoden

Die Form-Klasse bietet nur ein paar interessante Methoden, welche ich etwas genauer erläutern möchte:

Die Show()-Methode zeigt eine Form an. Allerdings kann man auch ein anderes Fenster anklicken (bezogen auf die Fenster der eigenen Anwendung). Für Dialoge ist dies nicht sonderlich nützlich.

Die Methode ShowDialog() macht dasselbe wie schon Show(), nur wird hier ein modales Fenster angezeigt. Das heißt, das Fenster muss erst geschlossen werden, bevor ein anderes Fenster verwendet werden kann. Diese Methode ist ideal, um Dialogfenster zu erstellen.

Fenster schließen geht mit Close() (wer hätte das gedacht ).

Zum Schluss möchte ich Ihnen noch die Activate()-Methode zeigen - diese aktiviert ein Fenster und gibt ihm den Fokus.

Es gibt noch mehr Methoden, aber die oben genannten sind die wichtigsten. Eine volle Referenz finden Sie online bei MSDN Online oder in der Dokumentation vom .NET FrameworkSDK.

3.3.1.2. Eigenschaften

Die Form-Klasse besitzt viele Eigenschaften, wobei ich Ihnen nur die wichtigsten näher bringen möchte. Für eine vollständige Referenz verweise ich auf die .NET Framework SDK Dokumentation (oder wenn Sie das Visual Studio besitzen auf die MSDN Library).

Sie mögen keine Fenster mit grauem Hintergrund? Kein Problem, setzen Sie die Eigenschaft BackColor auf eine Farbe, die Ihnen gefällt. Oder wollen Sie ein Bild als Hintergrund verwenden? Kein Problem, dafür gibt es dieBackgroundImage-Eigenschaft. Und mit BackgroundImageLayout* können Sie angeben, wie das Bild gestreckt werden soll (gar nicht, zentriert, vergrößert, ...).

Das Aussehen des Fensters können Sie mit FormBorderStyle angeben. Hier können Sie festlegen, ob das Fenster in der Größe veränderbar ist oder nicht. Auch können Sie festlegen. Ob das Fenster wie ein Toolfenster aussehen soll oder ob es überhaupt keinen Rahmen haben soll.

Mit Icon können Sie das Icon der Form festlegen, welches ganz links in der Titelzeile angezeigt werden soll.

Mit MaximizeBox und MinimizeBox können Sie festlegen, ob die Buttons für Maximieren bzw. Minimieren verfügbar sind. Wenn Sie ControlBox auf False setzen, werden Icon, Minimier-, Maximier- und Schließenbutton deaktiviert und werden ausgeblendet.

Mit MinimumSize und MaximumSize können Sie die minimale und maximale Größe der Form angeben.

ShowInTaskbar gibt an, ob Ihre Anwendung eine Schaltfläche in der Taskbar besitzen soll.

Wollen Sie Ihr Fenster halbtransparent darstellen? Das geht mit der Opacity-Eigenschaft, wobei 100 für voll sichtbar steht und 0 für voll transparent (also unsichtbar). Als Hinweis soll hier noch gesagt werden, dass Opacity zwar nett aussieht, aber auch eine Performancebremse sein kann.

Den Titel der Form können Sie mit der Text-Eigenschaft ändern.

Mit TransparencyKey können Sie eine Form festlegen, die transparent dargestellt werden soll.

Ich denke mal, dies reicht erst mal. Ich empfehle Ihnen, in die Dokumentation zu schauen, dort finden Sie eine vollständige Referenz zu allen Member. Die Erklärung der Ereignisse lasse ich weg, da ihre Namen aussagekräftig genug sind.

3.3.2. Das Label

Das Label ist das einfachste Steuerelement von .NET und hat eigentlich nur die Aufgabe, andere Controls zu beschriften. Den anzuzeigenden Text legen Sie mit der Text-Eigenschaft fest (wie auch bei Form). Diesen können Sie noch formatieren (andere Schrift, Schriftgröße, Schriftfarbe, ...). Aber für mehr ist das Label nicht zu gebrauchen. Ach ja, Bilder können Sie ebenfalls anzeigen mittels derImage-Eigenschaft. Hier ein Screenshot, welcher die Möglichkeiten des Labels darstellt:

Diese "Anwendung" ist nur durch das Setzen von Eigenschaften entstanden. Verwendet wurdenForeColor, BackColor, Font, Image, TextAlign (Ausrichtung des Textes) und BorderStyle (gibt an, wie das Control umrandet werden soll).

3.3.3. Das LinkLabel

Mit dem LinkLabel kann man in seiner Anwendung Links mit einfügen. Mit Text legt man, wie gewohnt, den anzuzeigenden Text fest. Standardmäßig wird der komplette Text als Link angezeigt. Wenn Sie nur einen bestimmten Textbereich als Link haben wollen, klicken Sie auf den Button der LinkArea-Eigenschaft. Dadurch öffnet sich ein kleiner Editor, mit dem Sie sehr bequem den gewünschten Textbereich festlegen können.

Natürlich können Sie auch die Linkfarben festlegen für aktiven, besuchten und deaktivierten Link. Dafür gibt es die EigenschaftenLinkColor, VisitedLinkColor und DisabledLinkColor.

Interessant ist noch die Eigenschaft LinkBehavior. Damit legen Sie das Aussehen des Links fest (unterstrichen, nicht unterstrichen, unterstreichen beim Draufzeigen, Systemstandard).

Nur wann wissen wir, dass der Benutzer auf dem Link geklickt hat? Dafür gibt es dasLinkClicked-Ereignis.

Ansonsten gibt es keine nennenswerten Unterschiede zum normalen Label.

3.3.4. Der Button

Über einen Button gibt es nicht viel zu sagen. Er ist nur dafür da, dass der Benutzer eine Aktion durch einen Klick auslöst.

Einen Button kann man als Standardbutton festlegen. Es gibt zwei: einen, welcher ausgelöst werden soll, wenn man Enter drückt und einen anderen, wenn man Escape drückt. Diese legt man mit den Eigenschaften AcceptButton und CancelButton der Form fest.

Auch im grafischen Design gibt es nicht viel zu sagen. Man kann den Button "platt" machen (flatten). Das sieht so aus:

Den Style des flachen Button kann man über die Eigenschaft FlatAppearance festlegen. Diese besteht aus vier "Teilen":

Reichen Ihnen diese Gestaltungsmöglichkeiten nicht aus? Wollen Sie z.B. runde Buttons? Dann können Sie über dieBackgroundImage-Eigenschaft ein Bild auf dem Button anzeigen. In Verbindung mit den verschiedenen Ereignissen können Sie so ein interessantes Design zaubern. Hierzu soll ein kleines Beispielprojekt erstellt werden.

3.3.5. Beispielprojekt: DesignButton

Dieses Beispiel soll die Verwendung von der BackgroundImage-Eigenschaft verdeutlichen und wie man damit interessante Designs umsetzen kann. Ich werde auf die Beschreibung für das Laden der Bilder nicht näher eingehen, das wird ausführlich im4. Kapitel beschrieben.

Zuerst erstellen wir die benötigten Grafiken. Eine "Normalansicht", eine "Hoveransicht" und eine "Klickansicht". Mit welchem Programm Sie diese gestalten, ist egal. Ich verwende hierfür Paint.NET. Wichtig hingegen ist, dass alle drei Grafiken gleich groß sind (die Beispielbilder sind 70x30 Pixel groß). Als Datenformat empfehle ich eines, das Transparenz unterstützt. Im Beispiel wird PNG verwendet. Die hier verwendeten Bilder sind vom grafischen her nicht der Hammer, andere können dies sicherlich besser, aber hier geht es ja um die generelle Verwendung .

So, Bilder sind da, wie bekommen wir diese jetzt in unseren Button? Dazu erstellen Sie zuerst eine neue Windows-Anwendung. Anschließend fügen Sie Ihre Dateien hinzu. Das geht über den Menübefehl PROJEKT|VORHANDENES ELEMENT HINZUFÜGEN.

Klicken Sie danach alle Bilder an und setzen Sie die Eigenschaft "In Ausgabeverzeichnis kopieren" auf "Immer kopieren".

Jetzt bereiten wir den Button vor. Dazu ändern wir nur Eigenschaften.

Im Eigenschaftsfenster auf das Plus-Klicken vor FlatAppearence, dann findet manBorderSize, MouseDownBackColor und MouseOverBackColor. Das waren jetzt die Vorbereitungen. Jetzt geht es in den Code. Fügen Sie nach der Class-Anweisung folgenden Code ein:

Private normalImage As Bitmap = Image.FromFile("Normal.png")
Private hoverImage As Bitmap = Image.FromFile("Hover.png")
Private klickImage As Bitmap = Image.FromFile("Klick.png")

Hiermit haben Sie 3 Variablen erstellt, die die drei Bilder für den Button enthalten. In die Sub New() schreiben Sie vor End Sub noch folgendes:

Me.button1.Image = Image.FromFile("Normal.png")

Mit dieser Anweisung setzen Sie das Bild des Buttons. Jetzt müssen wir noch auf ein paar Ereignisse reagieren. Nämlich aufMouseHover, MouseLeave und Click. Hier der Code, welcher in den entsprechenden Handlern eingefügt muss.

Zum Schluss schreiben wir jetzt noch Code zum Freigeben der Ressourcen. Eine gute Gelegenheit ist im EreignisFormClosed:

normalImage.Dispose()
hoverImage.Dispose()
klickImage.Dispose()

Jetzt sind wir fertig. Probieren Sie das Beispiel aus und Sie werden sehen, wie sich der Button verhält. So können Sie mit wenig Aufwand auch nicht rechteckige Buttons erstellen oder mit speziellem Aussehen (z.B. mit Farbverläufen, ...).

 Hier können Sie das Beispielprojekt auch downloaden.
 

3.3.6. Checkbox und RadioButton

Diese Controls sind einander sehr ähnlich, daher behandle ich beide gleich zusammen. Außerdem haben sie viele Ähnlichkeiten mit dem Button, da alle beide Klassen von ButtonBase erben (genau wie Button).

Checkbox und RadioButton kann man mit der Appearence-Eigenschaft das Aussehen eines Buttons geben.

Diese Abbildung zeigt eine Checkbox, wenn man Appearence auf Button setzt. Die linke Hälfte zeigt sie, wenn sie nicht ausgewählt ist, die rechte, wenn sie ausgewählt ist. So sieht auch ein entsprechender RadioButton aus.

Mit der Checked-Eigenschaft können Sie abfragen, ob die Checkbox oder der RadioButton ausgewählt ist. Der Unterschied zwischen beiden ist, dass beliebig viele Checkboxen gleichzeitig ausgewählt sein können, aber immer nur ein RadioButton. Um mehrere unabhängige RadioButton-Gruppen zu erzeugen, muss man diese in separate Container packen. Gut, aber was ist ein Container? Ein Container beherbergt andere Controls. So ist auch eine Form ein Container (logisch, man kann ja Controls hinzufügen). Andere Container wärenGroupbox, Panel, FlowLayoutPanel, TableLayoutPanel oderSplitContainer.

Die Checkbox hat noch eine Besonderheit. Sie können die Eigenschaft ThreeState aufTrue setzen und damit hat die Checkbox 3 Zustände: nicht ausgewählt (Unchecked), ausgewählt (Checked) und unbestimmt (Indeterminate). Bei 3 Zuständen müssen Sie beachten, dass die Checked-Eigenschaft auch bei Unbestimmt True zurückgibt. Abhilfe schafft die CheckState-Eigenschaft, welche die WerteUnchecked, Checked und Indeterminate aufweisen kann.

3.3.7. Gemeinsamkeiten

Bevor wir uns das nächste Steuerelement anschauen, möchte ich Ihnen ein paar Eigenschaften nennen, welche alle Controls gemeinsam haben. Mir geht es umDock, Anchor, TabIndex, TabStop, Visible undEnable.

3.3.7.1. Dock und Anchor

Mit diesen Eigenschaften können Sie festlegen, wie sich die Steuerelemente bei Größenänderungen ihres Containers verändern.

Mit Dock geben Sie an, mit welcher Seite sich das Control an seinen Container andocken soll und wie es sich in der Größe verändern soll. Bei den Einstellungen Left und Right passt es sich automatisch in der Höhe an, bei Top und Bottom in der Breite. Außerdem gibt es noch Fill, womit ein Control den gesamten Platz des Containers einnimmt.

Mit Anchor legen Sie fest, in welche Richtung sich ein Control bei Größenänderungen verändert. Standardmäßig sind Left und Top gesetzt, womit das jeweilige Steuerelement an seiner Position bleibt sich aber in der Größe nicht anpasst.

3.3.7.2. TabStop und TabIndex

Sicherlich kennen Sie die Möglichkeit mittels Tab durch ein Fenster zu "navigieren" und so den Fokus von einen Steuerelement zu einem anderen zu geben. Dies können Sie für Ihre Anwendungen auch leicht implementieren.

TabStop gibt an, ob das Steuerelement via Tab-Taste den Fokus überhaupt bekommen kann. Mit TabIndex legen Sie die Reihenfolge fest, in der die Controls nacheinander den Fokus bekommen. Das erste Control hat den Index 0, das zweite 1 usw.

3.3.7.3. Visible und Enable

Mit Visible können Sie ein Control dynamisch ein- oder ausblenden. Wenn es ein Container ist, werden alle enthaltenden Controls des Containers ebenfalls aus- bzw. eingeblendet.

Enable ermöglicht das Aktivieren bzw. Deaktivieren des Steuerelementes. Wenn es deaktiviert ist, wird es meist anders angezeigt (ausgegraut) und sendet keine Ereignisse mehr.

3.3.8. Die Textbox

Die Textbox ist eine Möglichkeit, womit der Benutzer Eingaben durchführen kann. Sie können festlegen, wie viele Zeichen eingegeben werden dürfen - dies können Sie mit MaxLength festlegen, wobei 0 theoretisch für unendlich Zeichen steht (begrenzt durch Arbeitsspeicher).

Passwörter (oder ähnliche Eingaben) sollen nicht offen lesbar sein. Sie können ein beliebiges Zeichen festlegen, welches an Stelle der eingegebenen Zeichen angezeigt werden soll. Möglich wird dies durch diePasswordChar-Eigenschaft. Intern sehen Sie noch immer den originalen Text (würde sonst ja keinen Sinn machen).

Standardmäßig ist die Textbox einzeilig. Mit der Eigenschaft MultiLine können Sie auch mehrere Zeilen erlauben. Über dieLines-Eigenschaft (ein String-Array) können Sie die einzelnen Zeilen abrufen und bearbeiten. Die Tasten ENTER und TAB haben ja schon eine Aufgabe, wenn diese aber einen Zeilenwechsel bzw. Tabulatoreinschub auslösen sollen, müssen die Eigenschaften AcceptEnter bzw. AcceptTab auf True gesetzt werden. Automatisches Umbrechen von zu langen Wörtern können Sie mit WordWrap auf True erreichen.

3.3.9. Die ListBox

Wie der Name es schon verrät, stellt die ListBox eine Liste dar. Man kann Einträge hinzufügen, verändern und entfernen. Sie ist einfach gehalten, also Bilder oder das Formatieren von Einträgen sind nicht möglich. Dies kann man erreichen, indem man die Einträge selber zeichnet, was ich Ihnen im Kapitel 4 zeigen werde.

3.3.9.1. Einträge hinzufügen, ändern und löschen

Einträge hinzufügen geht über die Add-Methode. Dies sieht im Code so aus:

lstTest.Items.Add("VB .NET")
lstTest.Items.Add("C#")
lstTest.Items.Add("C++")

Sie können sich mit der With-Anweisung etwas Tipparbeit sparen:

With lstTest.Items
  .Add("Visual Basic .NET")
  .Add("C#")
  .Add("C++")
End With

Mit der AddRange-Methode können Sie ganze Objekt-Arrays hinzufügen. Dies ist bei vielen Objekten wesentlich schneller als die Add-Methode. Wollen Sie Einträge zwischen zwei einfügen? Kein Problem für Insert:

lstTest.Items.Insert(2, "Delphi .NET")

Als erstes geben Sie den Index an, wo der Eintrag hinzugefügt werden soll (Zählung beginnt bei 0), danach kommt das Objekt (meist ein String).

Wenn Sie einen Eintrag ändern wollen, dann können Sie dies so machen:

lstTest.Items(2) = "J#"

Dies ändert den Text des 3.Eintrages (denken Sie daran, die Zählung beginnt bei 0) auf "J#". Mit der Syntax Items(index) können Sie ein beliebigen Eintrag abrufen oder ändern. Wenn Sie einen zu großen oder zu kleinen Index angeben, bekommen Sie eine ArgumentOutofRangeException geworfen.

Das Löschen ist ebenfalls einfach. Mit Clear() löschen Sie die komplette Liste, Remove() löscht ein bestimmtes Objekt und RemoveAt() entfernt eins mit dem angegebenen Index (beginnt bei 0).

3.3.9.2. Ein paar Eigenschaften

Jedes Steuerelement hat einige eigene Eigenschaften. So kann man mit der Sorted-Eigenschaft einen Boolean übergeben und festlegen ob die ListBox automatisch alphabetisch sortiert wird.

Interessant ist SelectionMode. Hier können Sie eingreifen, wenn es um das Auswählen von Einträgen geht. Mit None geht nichts, One ermöglicht einen Eintrag (wie überraschend ) und mehrere geht mit MultiSimpel und MultiExtended. Bei MultiSimpel geht das Auswählen mehrerer Einträge nur mit der Maus, bei der erweiterten Variante können auch die Tasten STRG und UMSCHALT verwendet werden.

3.3.9.3. Markierte Objekte abrufen

Meistens müssen Sie auf die Auswahl des Benutzers reagieren und da stellt sich die Frage, wie man an die markierten Objekte rankommt.

Dafür gibt es mehrere Eigenschaften. Mit SelectedItem können Sie das ausgewählte Objekt aufrufen, wenn SelectionMode auf One steht. Wenn Ihnen das Objekt selber egal ist, sondern Sie nur den Index wollen, dann geht das mit SelectedIndex. Falls dieser -1 zurückgibt, ist nichts ausgewählt, ansonsten haben Sie den Index für den Eintrag.

Wenn mehrere Einträge möglich sind, dann bekommen Sie über SelectedItems eine Auflistung mit allen Einträgen bzw. über SelectedIndices eine Auflistung der Indizien aller Einträge.

Beachten Sie, dass SelectedItem(s) den Eintrag immer in einem Object speichert. Also müssen Sie hier eine Typumwandlung durchführen oder verwenden Sie ToString() um das Objekt in einen String umzuwandeln.

Außerdem wird ein Ereignis namens SelectedIndexChanged ausgelöst, welches aber keine weitere Informationen (Parameter e) enthält.

3.3.10. CheckedListBox - eine Erweiterung der ListBox

Wie es der Name schon andeutet, besteht diese ListBox mit CheckBoxen. Dieses Control finden Sie z.B. im Visual Studio2005. Es erbt von ListBox, wodurch viele Gemeinsamkeiten existieren. In den Methoden Add() und AddRange() können Sie jetzt noch den Status (Checked, Unchecked oder Indeterminate) der CheckBox festlegen.

SelectedItem & Co. existieren weiterhin (sind ja geerbt), sind aber nicht sinnvoll, da Sie sonst alle angeklickten Items bekommen würden. Um an die abgehakten heranzukommen (was uns ja interessiert), nutzen Sie die Eigenschaften CheckedItems oder für die Indizien CheckedIndices.

3.3.11. Das ComboBox-Control

Von den Funktionen her ist das ComboBox-Steuerelement der ListBox und der CheckedListBox ähnlich, da alle drei dieselbe Basisklasse haben, nämlich ListControl. Das Hinzufügen von Einträgen erfolgt wieder über Items.Add() usw.

Der größte Unterschied besteht im Aussehen. Die ComboBox gibt es in 3 Varianten:

In der ersten Ansicht kann man in der Textbox was eingeben und es wird immer zum nächstähnlichen Listeneintrag gesprungen. Die beiden anderen sind ähnlich. Bei DropDownList kann man nur einen Eintrag aus der Liste auswählen und DropDown ist die Platzsparvariante vonSimple. Das Aussehen lässt sich mit DropDownStyle festlegen. Und über MaxDropDownItems kann man die maximale Anzahl der Items in der Aufklappliste festlegen.

3.3.12. Das ListView

Das ListView ist ein relativ komplexes Steuerelement, was uns hier .NET anbietet (außer vielleicht das Datenkontrol DataGridView dürfte noch umfangreicher sein, das stelle ich aber später vor ).

3.3.12.1. Einträge hinzufügen

Einträge werden wieder über die Methode Add() der Eigenschaft Items hinzugefügt. Allerdings ist die ListView nicht von ListControl & Co. abgeleitet. Insgesamt gibt es 6 Überladungen von Add(). Und je nach dem, welche Ansicht Sie verwenden wollen, brauchen Sie eine von diesen. Im Gegensatz zur ListBox hält die ListView keine Items vom Typ Object bereit, sondern vom TypListViewItem. Durch ListViewItem haben Sie viele Möglichkeiten im Aussehen des Eintrages einzugreifen. So können Sie Vor- und Hintergrundfarbe ohne weiteres anpassen sowie vieles anderes.

With ListView1.Items.Add("VS 2005 Express")
  .BackColor = Color.Black
  .ForeColor = Color.White
End With
 
With ListView1.Items.Add("VS 2005 Standard")
  .BackColor = Color.Green
  .ForeColor = Color.White
End With
 
With ListView1.Items.Add("VS 2005 Professional")
  .BackColor = Color.Orange
  .ForeColor = Color.White
End With
 
With ListView1.Items.Add("VS 2005 Team System")
  .BackColor = Color.Silver
  .ForeColor = Color.Red
End With

Wie Sie sehen, gibt die Add()-Methode ein ListViewItem zurück, wodurch Sie komfortabel mit der With-Anweisung mehrereEigenschaften setzen können. Hier wurden Hinter- und Vordergrundfarben gesetzt. So sieht das Resultat aus: 
Wie Sie sehen, sollte man es nicht übertreiben, da dies sonst alles andere als gut aussieht. Aber ich will hier keinen Vortrag über das Designen der Benutzeroberfläche halten, was gut oder schlecht ist, muss jeder selber herausfinden.

3.3.12.2. Icons hinzufügen

Auch wenn das gerade Erlernte schon einige Gestaltungsmöglichkeiten bietet, möchte man die Erscheinung noch leicht aufpeppen, z.B. mit Icons. Vor allem wenn es schöne 24- bzw. 32-Bit XP-Icons sind und nicht die angestaubten Win95-Icons.

Das Hinzufügen ist recht einfach. Als erstes müssen wir ein Objekt der Klasse ImageList hinzufügen. Im VS ziehen Sie dieses ebenfalls auf die Form, allerdings wird dieses Control nicht angezeigt (bei solchen Controls redet man vonKomponenten). Daher landet es in einer extra Leiste unterhalb der Form. Sie können eine ImageList aber auch per Code erstellen:

Dim imgIcons As New ImageList()

Das Hinzufügen geht über die Add()-Methode der Images-Eigenschaft. Ich muss dem Laden von Icons oder Bilder vorgreifen, aber das kommt später ganz ausführlich.

imgIcons.Images.Add(New Icon("neu.ico"))
imgIcons.Images.Add(Image.FromFile("laden.bmp"))

Im VS fügen Sie die Bilder per Klicks hinzu. Das ist kinderleicht und bedarf keiner weiteren Erläuterung. Über dieColorDepth-Eigenschaft, legen Sie Farbtiefe fest. Zu guter Letzt legen Sie die Größe der Images unter ImageSize fest.

lsvTest.SmallImageList = imgIcons
lsvTest.LargeImageList = imgIcons
 
lsvTest.Items.Add("VS 2005 Standard", 0)
lsvTest.Items.Add("VS 2005 Professional", 1)

Mit den ersten beiden Zeilen legen Sie fest, woher das ListView die Bilder bezieht (für kleine und große Bilder). Danach werde einfach Einträge mittels Add() hinzugefügt, wobei als zweiter Parameter der Index des Bildes in der ImageList ist.

3.3.12.3. Die Ansichten des ListView

Das ListView besitzt mehrere Ansichten, genauso wie der Windows Explorer (Liste, Details, kleine Symbole, ...). Und diese Problematik der Ansichten des ListViews wollen wir uns jetzt anschauen.

In diesem Bild habe ich die verschiedenen Ansichten mit einem Grafikprogramm zusammen geschnitten. Die erste Reihe zeigt die EinstellungLargeIcon, die mittlere SmallIcon und die untere List. Die verschiedenen Icon-Größen sind durch zwei ImageLists entstanden, eine für die kleinen Icons und eine für die großen. Außer diesen 3 Ansichten, die übrigens über die View-Eigenschaft festgelegt werden, gibt es noch 2 weitere. DieDetails-Ansicht und die s. g. Tile. Diese ist eine Kombination aus LargeIcon und Detail, allerdings steht Tile nur unter Windows XP, Server 2003 und dem kommenden Vista zur Verfügung. Bei allen anderen wird für Tile LargeIcon verwendet.

3.3.12.4. Die View Details

Mit der View Details können mehrere Spalten erstellt werden und so verschiedeneZusatzinformationen angezeigt werden. Für diese Ansicht werden zuerst die Spalten (Columns) erstellt und danach die Zusatzinformationen (SubItems) zu den einzelnen Items hinzugefügt. Der Code für obiges Beispiel würde so aussehen: 

With lsvDetails
  ' View festlegen
  .View = View.Details
 
  ' Spalten erstellen
  .Columns.Add("Produkt", 180, HorizontalAlignment.Left)
  .Columns.Add("Zielgruppe", 120, HorizontalAlignment.Left)
  .Columns.Add("Preis", 60, HorizontalAlignment.Right)
 
  ' Items hinzufügen
  With .Items.Add("VS 2005 Standard", 0)
    .SubItems.Add("Entwickler")
    .SubItems.Add("ca. 300€")
  End With
 
  With .Items.Add("VS 2005 Professional", 1)
    .SubItems.Add("Profientwickler")
    .SubItems.Add("ca. 900€")
  End With
 
  With .Items.Add("VS 2005 Team System", 2)
    .SubItems.Add("Teamentwickler")
    .SubItems.Add("ca. 6000€")
  End With
End With

Als erstes wird die View-Eigenschaft auf Details gesetzt. Spalten erstellen geht über die Add()-Methode derColumns-Eigenschaft. Die hier verwendete Überladung nimmt drei Parameter entgegen. Der erste legt die Beschriftung fest, der zweite die Breite und der letzte, wie der Text ausgerichtet werden soll (linksbündig, zentriert oder rechtsbündig).

Anschließend werden die Items hinzugefügt. Items.Add() gibt ein Objekt vom Typ ListViewItem zurück. Dieses brauchen wir gleich für SubItems, daher habe ich dies in einen eigenenWith-Block gepackt um keine Variable zum Zwischenspeichern zu erstellen. Möglich wäre dies natürlich ohne weiteres. Der erste Parameter legt den Text fest, der zweite ist derImageIndex.

Mit SubItems.Add() werden die SubItems (die Zusatzinformationen festgelegt). Einmal wird die Zielgruppe angegeben und einmal der ungefähre Preis.

Ich habe oben die Ansicht Tile erwähnt. Die Erzeugung dieser View erfolgt wie bei Details, nur dass dieView-Eigenschaft halt auf Tile gesetzt wird. Bei Tile würde unser Beispiel so aussehen, wie auf dem Bild zu sehen ist. Ich finde es persönlich schade, dass Tile nur bei Windows XP, Server 2003 und dem kommenden Vista funktioniert. Diese Ansicht finde ich recht interessant und nicht so "abgedroschen" wie Details, aber was soll's. 

Hiermit beende ich die Behandlung des ListViews. Es gibt noch mehr, zum Beispiel Gruppen zu erzeugen und so mehrere Items zu gruppieren. Das hier erlangte Wissen reicht abererst mal um das ListView verwenden zu können. Wen die weiteren Möglichkeiten interessieren, der möge einen Blick in das SDK werfen.

3.3.13. Menüs, Toolbars und Statusleisten

In diesem Abschnitt dreht sich alles um Menüs, Toolbars und Statusleisten, alles, was jede Anwendung besitzt. Und mit .NET 2.0 wurden diese Controls komplett erneuert und funktional stark erweitert. Wir werden uns anschauen, wie wir Menüs, Toolbars und Statusleisten mit dem Form Editor von VB 2005 Express erstellen können.

3.3.13.1. (Kontext-)Menüs

Los geht es mit den Menüs und Kontextmenüs. 

Als erstes ziehen Sie aus der Kategorie Menüs & Symbolleisten ein MenuStrip auf die Form. Klicken Sie anschließend auf das kleine weiße Dreieck und wählen Sie unterMenuStrip-Aufgaben die Aufgabe Standardelemente einfügen. Daraufhin werden die Standardmenüpunkte eingefügt inkl. Bilder.

Eigene Menüpunkte können Sie ganz einfach erstellen, indem Sie in die Felder "Hier eingeben" Ihre Menüpunkte eingeben. Sie können auch ComboBoxen und TextBoxen hinzufügen, dies halte ich aber für Menüs nicht sinnvoll, sinnvoller erscheint mir da eher der Seperator, um Menüeinträge zu gruppieren. ComboBoxen und TextBoxen sind bei Symbolleisten, zu denen wir gleich kommen, eher angebracht. Dort findet man Sie auch in bekannten Programmen wie Word oder Outlook.

So, wenn Sie Ihr Menü fertig haben, kommt der Feinschliff, die Bilder und die Shortcuts.

Das Bild wird über die Image-Eigenschaft festgelegt. Die Eigenschaft ImageTransparentColor legt eine Farbe, die transparent dargestellt werden soll fest, falls Ihr Bild in einem Format ohne Alphakanal-Unterstützung vorliegt, eine nützliche Eigenschaft.

Shortcuts werden über die Eigenschaft ShortcutKeys festgelegt. Über den erscheinenden Dialog kann man sehr schön die Tasten festlegen. Mittels ShortcutDisplayString können Sie den Text festlegen, der angezeigt wird, falls Sie eine andere Darstellung haben wollen (z.B. wenn Sie mit einem englischen Visual Studio oder Windows arbeiten, Sie aber deutsche Beschriftungen haben wollen, dann können Sie diese mit dieser Eigenschaft festlegen.

Kontextmenüs werden analog zu normalen Menüs erstellt, man muss aber als Control ein oder mehrere ContextMenuStrip auf die Form ziehen. Danach designen Sie Ihr Kontextmenü und müssen zum Schluss noch eine Eigenschaft ändern. Jedes Control besitzt die Eigenschaft ContextMenuStrip, welche das anzuzeigende Kontextmenü festlegt, hier müssen Sie noch das entsprechende ContextMenuStrip zuweisen und fertig.

3.3.13.2. Toolbars

In diesem Abschnitt geht es um die Erstellung von Toolbars. Sie kennen es sicherlich von den Office-Programmen die Toolbars beliebig zu verschieben und sie z.B. auch an der Fensterseite anzudocken. Dies geht mit dem .NET Framework (FW) 2.0 jetzt auch endlich. Dazu ziehen Sie einen ToolstripContainer auf Ihre Form, setzen Sie die Dock-Eigenschaft auf Fill, um den ganzen Platz einzunehmen. Sie sehen solche kleinen anklickbaren Schaltflächen, mit denen sich s.g. ToolstripPanel an den Fensterseiten erzeugen lassen. In diesen Bereichen können Sie beliebig Toolbars hinzufügen und darüber verfügen.

Toolbars werden durch das Control Toolstrip repräsentiert. Ziehen Sie eins in so ein Panel, über die Toolstrip-Aufgaben können Sie die Standardeinträge hinzufügen.

Sie können, im Gegensatz zu VB6 & Co, neben normalen Buttons auch DropDown-Menüs, Textboxen, Fortschrittsleisten und anderes einfügen. Dazu klicken Sie auf den nach unten weisenden Pfeil und es öffnet sich das links abgebildete Auswahlmenü. Die Verwendung der einzelnen Elemente ist einfach und bedarf keiner Erläuterung. All die erzeugten Controls sind über Code änderbar (z.B. die Text-Eigenschaft einer Textbox ändern, ...).

3.3.13.3. Statusleisten

Statusleisten können Sie natürlich auch erzeugen. Dazu ziehen Sie ein StatusStrip auf die Form und setzen Sie die Dock-Eigenschaft auf Bottom, damit sich die Statusleiste immer am unteren Fensterrand befindet. Mit derRenderMode-Eigenschaft können Sie auch ein Office2003-Style zaubern (diese Eigenschaft gibt es für die anderen Menüs auch).

Bei StatusLabel können Sie mittels Spring-Eigenschaft auf True festlegen, dass es den verbleibenden Platz in der Statusleiste einnimmt.

Ansonsten spielen Sie mit den verschiedenen Eigenschaften der einzelnen Controls und schauen Sie sich die entsprechende Dokumentation an, denn weitere Erläuterungen folgen meinerseits nicht.

Die Steuerung der Controls erfolgt mittels Eigenschaften, Methoden und auf das Reagieren von Ereignissen. Dies unterscheidet sich auch nicht von den anderen Windows Controls wie Textbox, Button u.s.w. Eine Beispielanwendung folgt im 4.Kapitel, da es mit Bildern arbeiten wird, welche erst im nächsten Kapitel erläutert werden.

3.4. DIALOGE VERWENDEN

Die meisten Anwendungen verwenden Dialoge um Benutzerangaben abzufragen. In diesem Abschnitt geht es darum, vordefinierte Dialoge und selbst erstellte Dialoge zu verwenden.

3.4.1. OpenFileDialog

Wie aus dem Namen ersichtlich ist, dient dieser Dialog zum Öffnen von Dateien. Alle vordefinierten Dialoge kann man auf zwei Weisen verwenden: entweder man zieht sich die entsprechende Komponente aus der Toolbox auf die Form oder man deklariert lokal den entsprechenden Dialog mittels Code, wo man den Dialog benötigt. Ist im Endeffekt egal, da es für alles eine Codeentsprechung gibt. Ich demonstriere dies am Beispiel der 2. Möglichkeit, der Aufruf funktioniert bei beiden gleich. Naja, lange Rede, kurzer Sinn, hier der Code:

' Dialog instanzieren
Dim dlg As New OpenFileDialog()
 
' Eigenschaften setzen
With dlg
  .Title = "Eine Datei öffnen..."
  .InitialDirectory = Environment.GetFolderPath( _
    Environment.SpecialFolder.MyDocuments)
  .Filter = "RTF-Dateien|*.rtf|Test-Dateien|*.txt|Alle Dateien|*.*"
  .Multiselect = False
  .SupportMultiDottedExtensions = True
End With
 
' Anzeigen und den Rückgabewert speichern
Dim result As DialogResult = dlg.ShowDialog()
If result = Windows.Forms.DialogResult.OK Then
  MessageBox.Show("Sie haben OK gedrückt.")
ElseIf result = Windows.Forms.DialogResult.Cancel Then
  MessageBox.Show("Sie haben Abbrechen gedrückt.")
End If
 
' Ressourcen freigeben
dlg.Dispose()

Scheint viel Code zu sein, aber jeder Dialog folgt diesem Muster:

1. Dialoginstanz anlegen
2. Eigenschaften setzen
3. Dialog anzeigen und Rückgabewert auswerten
4. Ressourcen freigeben

Das Instanzieren dürfte kein Verständnisproblem sein. Kommen wir zu den Eigenschaften.

Mit Title legen Sie den Fenstertitel fest, InitialDirectory legt das Startverzeichnis fest. Ich habe mich für die Eigenen Dateien entschieden. Da dieser Pfad bei jedem Rechner anders lautet, hole ich ihn mir mittels der Methode GetFolderPath() der Environment-Klasse. Dieser Methode übergibt man einen Enum-Wert vom Typ SpecialFolder, welche solche "variablen" Ordner enthalten (Eigenen Dateien, Eigene Musik, Systemverzeichnis, ...). Dateifilter legt man mit der Filter-Eigenschaft fest, wobei der String immer folgendes Layout hat:

Name1|*.typ1|Name2|*.typ2

Ich hoffe, Sie haben das Muster erkannt, ansonsten, wenn Sie den Code ausführen, dürfte es klar sein.

Mittels MultiSelect legen Sie fest, ob eine oder mehrere Dateien ausgewählt werden können. SupportMultiDottedExtensions legt fest, ob Dateinamen mit mehreren Dateierweiterungen unterstützt werden.

Das Anzeigen des Dialoges erfolgt mittels ShowDialog()-Methode. Diese liefert einen Enum-Wert vom Typ DialogResult zurück. Durch diesen können Sie abfragen, welchen Button der Benutzer angeklickt hat (OK, Abbrechen, ...). Dieser wird danach abgefragt und je nach Button eine MessageBox angezeigt.

Der Dialog wird mittels Dispose()-Methode "recycled", d.h. die benötigten Ressourcen werden freigegeben.

Mit der Eigenschaft FileName greifen Sie auf den ausgewählten Dateinamen zu, FileNames liefert ein String-Array mit den ausgewählten Dateinamen, nützlich bei MultiSelect = True.

3.4.2. SaveFileDialog

Der SaveFileDialog dient zum Speichern von Dateien und die Verwendung erfolgt analog zum OpenFileDialog. Hier ein Codebeispiel:

Dim dlg As New SaveFileDialog()
 
With dlg
  .Title = "Eine Datei speichern..."
  .InitialDirectory = Environment.GetFolderPath( _
    Environment.SpecialFolder.MyDocuments)
  .Filter = "RTF-Dateien|*.rtf|Test-Dateien|*.txt|Alle Dateien|*.*"
  .CreatePrompt = False
  .OverwritePrompt = True
  .ValidateNames = True
End With
 
If dlg.ShowDialog() = Windows.Forms.DialogResult.OK Then
  MessageBox.Show("Datei wird gespeichert in " & dlg.FileName)
End If
 
dlg.Dispose()

Einige Eigenschaften kennen Sie schon durch den OpenFileDialog, aber es sind auch ein paar neue dabei. Mit CreatePrompt legen Sie fest, ob für das Anlegen einer neuen Datei ein Dialog angezeigt wird, um die Aktion zu bestätigen. OverwritePrompt ist ähnlich, nur dass hier festgelegt wird, ob eine Warnung beim Überschreiben einer Datei angezeigt werden soll. ValidateNames sorgt dafür, dass der Dateiname nur gültige Zeichen enthält. Damit können wir uns eine eigene Prüfung auf Korrektheit sparen. Diese Eigenschaft sollten Sie auf True setzen.

3.4.3. FolderBrowserDialog

Dieser Dialog dient dazu, einen Ordner zu suchen und festzulegen. Diesen Dialog finden Sie meistens, wenn Sie irgendwelche Verzeichnisse festlegenwollen / müssen. Die Verwendung ist auch recht einfach.

Dim dlg As New FolderBrowserDialog()
 
With dlg
  .Description = "Legen Sie einen Speicherort für Projekte fest."
  .ShowNewFolderButton = True
  .RootFolder = Environment.SpecialFolder.MyComputer
End With
 
If dlg.ShowDialog() = Windows.Forms.DialogResult.OK Then
  MessageBox.Show("Ihre Auswahl: " & dlg.SelectedPath)
End If
 
dlg.Dispose()

Mit Description setzen Sie die anzuzeigende Beschreibung fest. Mit ShowNewFolderButton können Sie die Möglichkeit einräumen, über den Dialog neue Ordner anzulegen oder ob nur existierende wählbar sind. RootFolder legt fest, ab wo die Ordner angezeigt werden. Hier empfehle ich, dies bei MyComputer zu lassen, wenn Sie z.B. MyDocuments wählen für Eigene Dateien, dann sind Ordner außerhalb davon nicht wählbar. Oder anders ausgedrückt, ein Ordner wie C:\Programme wäre dann nicht wählbar. Mittels SelectedPath können Sie den ausgewählten Pfad abfragen.

3.4.4. FontDialog

Auch wenn das Thema Zeichen & Co. später kommt, möchte ich diesen Dialog nicht aufschieben. Er bietet schon mehr Einstellmöglichkeiten als die anderen.

Dim dlg As New FontDialog()
 
With dlg
  .AllowSimulations = True
  .AllowVectorFonts = True
  .AllowVerticalFonts = True
  .FixedPitchOnly = False
  .FontMustExist = True
  .MinSize = 8
  .MaxSize = 100
  .ShowApply = False
  .ShowColor = True
  .ShowEffects = True
End With
 
If dlg.ShowDialog() = Windows.Forms.DialogResult.OK Then
  MessageBox.Show("Ihre gewählte Schrift: " & dlg.Font.Name)
End If
 
dlg.Dispose()

AllowSimulations legt fest, ob der Dialog eine Vorschau anzeigt. AllowVectorFonts legt fest, ob auch Vektorschriftarten gewählt werden können, ähnlich ist auch AllowVerticalFonts, ob auch vertikale Schriftarten möglich sind. Mittels FixedPitchOnly legen Sie fest, ob nur Schriften mit fester Zeichenbreite (so was wie Courier New) möglich sind. FontMustExist dürfte klar sein. Die zulässige minimale und maximale Größe in Punkt können Sie mittels MinSize und MaxSize festlegen. Das Anzeigen eines Übernehmen-Buttons ist mit ShowApply möglich. Mittels ShowColor können auch einige Farben für die Schrift gewählt werden und ShowEffects legt fest, ob Effekte wie Durch- oder Unterstreichen möglich sind.

Über die Font-Eigenschaft rufen Sie das Font-Objekt mit den gewählten Attributen ab. Im Beispiel wird nur der Name ausgegeben.

3.4.5. ColorDialog

Jeder kennt den ColorDialog, wie er z.B. bei Paint mit verwendet wird. So können Sie ihn für eigene Anwendungen verwenden:

Dim dlg As New ColorDialog()
 
With dlg
  .AllowFullOpen = True
  .FullOpen = True
End With
 
If dlg.ShowDialog() = Windows.Forms.DialogResult.OK Then
  MessageBox.Show("Ihre gewählte Farbe: " & dlg.Color.ToString())
End If
 
dlg.Dispose()

AllowFullOpen erlaubt benutzerdefinierte Farben und mit FullOpen machen Sie diesen "Farbmischer" sichtbar. Über die Eigenschaft Color können Sie auf die gewählte Farbe zugreifen.

3.4.6. Eigene Dialoge

Eigene Dialoge sind auch nicht sonderlich schwierig. Als erstes muss eine zusätzliche Form hinzugefügt werden. Diese wird Ihr Dialog. Fügen Sie die benötigten Controls dazu und setzen Sie die benötigten Eigenschaften. Um auf die Benutzereingaben zugreifen zu können, definieren Sie öffentliche Felder oder Eigenschaften. Die OK und Abbrechen-Buttons legen Sie über die AcceptButton und CancelButton-Eigenschaften der Form fest. Der Aufruf erfolgt so:

Dim dlg As New AboutBox1()
 
If dlg.ShowDialog() = Windows.Forms.DialogResult.OK Then
  MessageBox.Show("OK")
End If
 
dlg.Dispose()

Wichtig ist, dass Sie in Ihren Buttons die Eigenschaft DialogResult festlegen. In den OK-Button schreiben Sie alsoz. B. folgendes rein:

' Benutzereingaben speichern
Me.Close()
Me.DialogResult = Windows.Forms.DialogResult.OK

Mehr gibt es dazu nicht zu sagen.

3.5. MDI-ANWENDUNGEN

MDI-Anwendungen findet man heute zwar nicht mehr so häufig, aber ich möchte sie Ihnen nicht vorenthalten. 

Als erstes definieren Sie Ihr MDI-Client Fenster, meist Dokumentfenster. Wie dieses aussieht, ist Ihnen überlassen, spielt aber auch keine Rolle. Wenn Ihr Child steht, müssen Sie im Parent (also das Fenster, welches die Childs dann anzeigen soll), die Eigenschaft IsMdiParent auf True setzen. Danach definieren wir eine Methode zum Hinzufügen der Childs:

Private Sub AddChild()
  Dim child As New Child()
  child.MdiParent = Me
  child.Show()
End Sub

Hier passiert nichts wirklich spannendes, wichtig ist, dass Sie die MdiParent-Eigenschaft setzen.

Diese Methode können Sie dann immer aufrufen, wenn Sie ein neues Fenster hinzufügen wollen. Das Anordnen von den Fenstern geht auch einfach:

Me.LayoutMdi(MdiLayout.Cascade)

In diesem Beispiel werden die Fenster überlappend angezeigt. Schauen Sie sich auch die anderen Möglichkeiten an.

Das aktive Child bekommen Sie über die Eigenschaft ActiveMdiChild, hier bekommen Sie aber nur ein Form-Objekt zurückgeliefert, dieses müssen Sie in Ihren Typ casten:

Dim activeC As Child = CType(Me.ActiveMdiChild, Child)

Wollen Sie in einem Menüpunkt alle Fenster auflisten? Kein Problem, das übernimmt das Framework für Sie, Sie müssen nur die Eigenschaft MdiWindowListItem auf einen Menüpunkt setzen und am Ende dieses Punktes werden dann alle Childs aufgelistet.

Über die Methode ActivateMdiChild() können Sie ein Form-Objekt, welches ein bereits geöffnetes MDI-Child ist, aktivieren und so in den Vordergrund holen.

Das Schließen geht über die Close()-Methode des entsprechenden Childs.

Das war soweit das wichtigste zu MDI-Anwendungen. Unsere Beispielentwicklung wird im Kapitel 4 entwickelt und zeigt die hier besprochenen Themen aus diesem Kapitel live in action.