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 15 Grundlagen zum Erstellen einer Windows-Anwendung
  gp 15.1 Die Entwicklungsumgebung
  gp 15.2 Eine erste Windows-Anwendung
  gp 15.3 Die Internas einer Windowsanwendung
    gp 15.3.1 Projekteinstellungen
    gp 15.3.2 Das Anwendungsframework
    gp 15.3.3 Die Klasse »MyApplication«
    gp 15.3.4 Die Ereignisse des »MyApplication«-Objekts
  gp 15.4 Ereignisse grafischer Windows-Komponenten
    gp 15.4.1 Grundlegende Anmerkungen
    gp 15.4.2 Ereignisse mit Ereignisdaten
    gp 15.4.3 Ereignishandler mit dem Visual Studio 2005 bereitstellen
    gp 15.4.4 Ereignisbehandlung mit den »OnXxx«-Methoden
  gp 15.5 Die Basisklassen einer Form
    gp 15.5.1 Die Klasse »Control«
    gp 15.5.2 Die Klasse »ScrollableControl«
    gp 15.5.3 Die Klasse »ContainerControl«
  gp 15.6 Die Eigenschaften einer Form
    gp 15.6.1 Die Rahmendarstellung einer Form
    gp 15.6.2 Formspezifisches Symbol festlegen
    gp 15.6.3 Die Schaltflächen in der Titelleiste
    gp 15.6.4 Spielereien mit »Opacity« und »TransparencyKey«
    gp 15.6.5 Fenster, die nicht verdeckt werden können
    gp 15.6.6 Den Mauszeiger verändern
    gp 15.6.7 Farbeinstellungen mit dem Typ »Color«
    gp 15.6.8 Schriftart mit dem Typ »Font«
    gp 15.6.9 Die Abmessungen einer Form festlegen
    gp 15.6.10 Die Position eines Fensters
    gp 15.6.11 Die Anzeigezustand eines Fensters nach dem Öffnen
    gp 15.6.12 Die Arbeitsfläche des Fensters (der Clientbereich)
    gp 15.6.13 Die Auflistung »ControlsCollection«
    gp 15.6.14 Zusammenfassung der Eigenschaften des Form-Objekts
  gp 15.7 Ereignisse einer Form
    gp 15.7.1 Ereignisse beim Erzeugen eines Fenster
    gp 15.7.2 Größenänderung einer Form
    gp 15.7.3 Ereignisse beim Schließen eines Fensters
  gp 15.8 Anwendungen mit mehreren Fenstern
    gp 15.8.1 Neue Forms hinzufügen
    gp 15.8.2 Formulare laden, anzeigen, verstecken und schließen
    gp 15.8.3 Mehrere Fenster verwalten
    gp 15.8.4 Formulare in einem eigenen Thread laufen lassen
    gp 15.8.5 Splash-Fenster
  gp 15.9 Modale Dialogfenster
    gp 15.9.1 Layout eines Dialogfensters
    gp 15.9.2 Die Eigenschaft »DialogResult«
    gp 15.9.3 Eine Form modal öffnen
    gp 15.9.4 Die Weitergabe von Resultaten aus einem Dialog
    gp 15.9.5 Fokussierreihenfolge und Standardschaltflächen
  gp 15.10 Meldungsfenster mit »MessageBox«
    gp 15.10.1 Die Methode »MessageBox.Show«
    gp 15.10.2 Der Rückgabewert der Meldungsfenster
  gp 15.11 Das Speichern in der Registrierungsdatenbank
    gp 15.11.1 Die Klassen »Registry« und »RegistrKey«
    gp 15.11.2 Programmbeispiel zum Speichern in der Registrierung
  gp 15.12 Die Klasse »Application«
    gp 15.12.1 Die Datei »AssemblyInfo.vb«
    gp 15.12.2 Mit »Application.DoEvents« wartende Ereignisse abrufen
    gp 15.12.3 Zusammenfassung Eigenschaften und Methoden


Galileo Computing

15.4 Ereignisse grafischer Windows-Komponenten  downtop

Programme mit grafischer Benutzeroberfläche (GUI – Graphical User Interface) verwenden ein ereignisorientiertes Eingabemodell, bei dem nach der Initialisierung des Programms sämtliche Operationen nur noch als Reaktionen auf Ereignisse ausgeführt werden. Jeder Eingabe ist mindestens ein Ereignis zugeordnet, das wiederum mit einer Methode, dem Ereignishandler, verknüpft sein kann, aber nicht unbedingt verbunden sein muss.

Kommt es zur Auslösung des Ereignisses, wird die registrierte Methode aufgerufen und ausgeführt. Erst wenn die Ausführung des Ereignishandlers beendet ist, kann das nächste anstehende Ereignis seinen Ereignishandler aufrufen. Solange kein Ereignis ausgelöst wird, das es zu verarbeiten gilt, verharrt die Laufzeit im Ruhezustand und wartet auf das nächste. Verantwortlich für den scheinbaren Ruhezustand ist die Nachrichtenschleife, die beim Aufruf der Methode Application.Run eingerichtet wird und ohne Ermüdungserscheinungen zu zeigen permanent auf Ereignisse wartet.


Galileo Computing

15.4.1 Grundlegende Anmerkungen  downtop

Rufen wir uns noch einmal ganz allgemein in Erinnerung, wie wir mit Visual Basic 2005 eine Methode an ein bestimmtes Ereignis eines Objekts binden. Sie haben zwei Alternativen. Nehmen wir als Grundlage unserer Betrachtung eine Schaltfläche (Typ Button).


Friend WithEvents Button1 As Button
Private Sub Button1_Click(ByVal sender As Object, _
ByVal e As EventArgs) Handles Button1.Click
End Sub

Sie deklarieren die Objektvariable mit WithEvents und geben hinter dem entsprechenden Ereignishandler mit der Handles-Klausel an, auf welches Ereignis der Ereignishandler ausgeführt werden soll. So generiert das Visual Studio den Code.

Bei der zweiten Variante können Sie auf WithEvents verzichten und müssen dann allerdings die Bindung eines Ereignisses an eine Methode ausdrücklich mir AddHandler einstellen. Sie können, beispielsweise im Load-Éreignis der Form.


Friend Button1 As System.Windows.Forms.Button
Private Sub Button1_Click(ByVal sender As Object, _
ByVal e As EventArgs)
End Sub
Private Sub Form1_Load(ByVal sender As Object, _
ByVal e As EventArgs) Handles MyBase.Load
AddHandler Me.Button1.Click, AddressOf Button1_Click
End Sub

Ein Ereignis ist immer vom Typ eines Delegaten. Bei einem Click-Ereignis ist das immer der Delegat EventHandler, andere Ereignisse sind oft von einem anderen Delegat-Typ. Die Definition des Delegaten EventHandler lautet wie folgt:


Public Delegate Sub EventHandler(Object, EventArgs)

Eine Methode, die das Ereignis behandeln soll, muss dementsprechend eine Parameterliste bestehend aus zwei Parametern definieren. Dabei ist der erste Parameter vom Typ Object, der zweite vom Typ EventArgs. Eine akzeptable Methodensignatur könnte in diesem Fall demnach


Private Sub MeineMethode(ByVal sender As Object, _
ByVal e As EventArgs)

Nun müssen wir die Parameterliste des Delegaten genauer unter die Lupe nehmen. Der erste Parameter beschreibt die Referenz auf ein Objekt. Der Typ ist mit Object so allgemein gehalten, dass hier jeder Typ des .NET Frameworks in Frage kommt. Der Name des Parameters lautet per Vorgabe sender und deutet damit schon an, dass hier die Referenz auf das ereignisauslösende Objekt übergeben wird. Das ist durchaus sinnvoll, denn der Ereignishandler steht zu dem auslösenden Objekt in einer 1:n-Beziehung, da verschiedene Objekte mit demselben Ereignishandler verknüpft werden können. Über den ersten Parameter erhält die ereignisbehandelnde Methode also direkten Kontakt zur Ereignisquelle, kann sie möglicherweise abfragen und sogar manipulieren.

Der zweite Parameter im Delegaten EventHandler ist vom Typ EventArgs,. Dabei handelt es sich um eine Klasse, die dem Namespace System zugeordnet ist. Grundsätzlich dient der zweite Parameter dazu, dem Ereignisempfänger im Zusammenhang mit dem Ereignis Zustandsinformationen zu übermitteln. EventArgs enthält selbst keine spezifischen Ereignisdaten, weil solche von einem Click-Ereignis nicht übergeben werden. Im Grunde genommen ist EventArgs nichts anderes als ein Dummy. Andere Ereignisse können dem Ereignishandler aber durchaus Dateninformationen zur Verfügung stellen. Dann muss der zweite Parameter konventionsgemäß ein von EventArgs abgeleiteter Typ sein. Die ereignisspezifischen Daten sind die Eigenschaften des zweiten Parameters.


Hinweis

Das .NET Framework folgt bei den Ereignissen der Steuerelemente einer einheitlichen Namenskonvention. Jeder Delegat wird mit EventHandler bezeichnet, der Bezeichner des zweiten Parameters tauscht das Suffix Handler gegen Args aus. Wie Sie gesehen haben, liefert der Parameter EventArgs keine ereignisspezifischen Daten. Das ist aber nicht immer so. Werden dem Ereignishandler über dem zweiten Parameter Informationen übergeben, muss der Delegat und folglich auch das Ereignis von einem anderen Typ sein. Im .NET Framework wird der Typbezeichnung des Delegaten und der des Args-Parameters dazu ein beschreibendes Präfix vorangestellt. Beispielsweise sind die Mausereignisse vom Typ des Delegaten Mouse-EventHandler, der Parameter ist dann analog vom Typ MouseEventArgs.


Den Namen des Ereignishandlers kann man beliebig festlegen. Nutzen wir den Automatismus der Entwicklungsumgebung, setzt sich der Bezeichner des Ereignishandlers aus dem Namen des Steuerelements und – durch einen Unterstrich getrennt – dem Bezeichner des Ereignisses zusammen, beispielsweise


Private Sub button1_Click(...)

Diese automatische Namensvergabe von .NET dient eher einer guten Les- und Wartbarkeit des Programmcodes, sie ist aber keine Festlegung, an die Sie sich halten müssen. Auch wenn durch den Bezeichner des Ereignishandlers suggeriert wird, dass die Methode nur das Click-Ereignis des Objekts button1 bedient, kann die Methode mit jedem x-beliebigen Ereignis verknüpft werden – sogar unabhängig vom zweiten Parameter, denn dieser ist vom Typ Event-Args deklariert, der selbst Basisklasse aller anderen Klassen ist, die Ereignisdaten bereit stellen.


Galileo Computing

15.4.2 Ereignisse mit Ereignisdaten  downtop

Click hat keine spezifischen Ereignisdaten, andere Ereignisse durchaus. Bewegen Sie zum Beispiel den Mauszeiger über den Clientbereich eines Formulars oder eines Steuerelements, werden in sehr schneller Abfolge MouseMove-Ereignisse ausgelöst, die wie folgt deklariert sind:


Public Event MouseMove As MouseEventHandler

Der Typ des Ereignisses ist jetzt nicht mehr der Delegat EventHandler, sondern MouseEventHandler. Sehen wir uns dessen Definition an:


Public Delegate Sub MouseEventHandler(Object, MouseEventArgs)

Eine Methode, die MouseMove-Ereignisse behandeln soll, empfängt im ersten Parameter die Referenz auf das ereignisauslösende Objekt, im zweiten die Referenz auf ein Objekt vom Typ der Klasse MouseEventArgs, das ereignisspezifische Zustandsdaten enthält.

Mit einem Ereignishandler auf dieses Ereignis zu reagieren ist dann sinnvoll, wenn die aktuelle Position des Mauszeigers ausgewertet werden muss. Eine MouseEventArgs-Instanz veröffentlicht zwei Eigenschaften, die die aktuelle Position wiedergeben: X und Y.


Tabelle 15.3     Eigenschaften der Klasse »MouseEventArgs«

Eigenschaft Beschreibung
X Liefert die x-Koordinate des Mauszeigers.
Y Liefert die y-Koordinate des Mauszeigers.

Das folgende Codefragment zeigt, wie Sie diese Daten auswerten können. Es handelt sich bei der Methode um den Ereignishandler des MouseMove-Ereignisses der Form. Zur Laufzeit bewirkt dieser Code, dass während des Ziehens des Mauszeigers über der Form in der Titelleiste permanent die aktuelle X- und Y-Position angezeigt wird.


Private Sub Form1_MouseMove(ByVal sender As Object, _
ByVal e As MouseEventArgs) Handles Me.MouseMove
Dim xPosition As Integer = e.X
Dim yPosition As Integer = e.Y
Me.Text = "X=" & yPosition & " / Y=" & yPosition
End Sub


Galileo Computing

15.4.3 Ereignishandler mit dem Visual Studio 2005 bereitstellen  downtop

Grundsätzlich können Sie Ereignisse an jeder Stelle im Programmcode an Ereignishandler binden oder, wenn erforderlich, diese auch wieder lösen. In den meisten Fällen werden Sie aber die Fähigkeiten der Entwicklungsumgebung nutzen wollen, die Ihnen alle denkbaren Möglichkeiten bietet.

Ein Doppelklick im Forms Designer bewirkt, dass das Visual Studio eine Methode für das Standardereignis der angeklickten Komponente erstellt. Um abweichend vom Standardereignis ein anderes zu behandeln, können Sie auch das Eigenschaftsfenster einsetzen, nachdem Sie in der Symbolleiste auf die Ereignisliste umgeschaltet haben (siehe Abbildung 15.7).

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

Abbildung 15.7     Ereignisauswahl im Eigenschaftsfenster

Klicken Sie auf ein Ereignis in der Ereignisliste, das Sie behandeln wollen, doppelt, wird automatische ein Ereignishandler erstellt, dessen Bezeichner sich aus Objektnamen und Ereignis zusammensetzt. Sie können dem Ereignishandler auch eine Bezeichnung geben, die von der üblichen Vergabe abweicht. Dazu tragen Sie nur den von Ihnen gewünschten manuell ein.

Möchten Sie einen Ereignishandler gleichzeitig für mehrere Ereignisse registrieren, ist das auch sehr einfach zu lösen. Aktivieren Sie die Wertespalte zu einem Ereignis in der Ereignisliste, sehen Sie eine Schaltfläche mit einem Pfeilsymbol. Sie können darüber eine Liste öffnen in der alle Ereignishandler aufgeführt sind, die im Args-Parameter denselben Typ haben. Wählen Sie daraus den Ereignishandler aus, der das markierte Ereignis verarbeiten soll.

Beispielprogramm

Unsere oben entwickelt Windowsanwendung soll nun um die Verarbeitung von Mausereignissen, ähnlich wie oben schon gezeigt, erweitert werden. Programmiert werden die MouseMove-Ereignisse der Form und der beiden Buttons. Dabei soll in der Titelleiste der Form angezeigt werden, welche Komponente die Koordinaten x und y liefert, die ebenfalls mit angezeigt werden. Da das Verhalten der Anwendung bei allen drei Mausereignissen identisch ist, drängt sich ein gemeinsamer Ereignishandler förmlich auf.


' ----------------------------------------------------------
' Beispiel: ...\Kapitel 15\MausereignisDemo
' ----------------------------------------------------------
Private Sub Form1_MouseMove(ByVal sender As Object, _
ByVal e As MouseEventArgs) Handles MyBase.MouseMove, _
btnKopieren.MouseMove, btnBeenden.MouseMove
Dim koordinate As String = "x = " & e.X & ", y = " & e.Y
If sender Is Me Then
Me.Text = "Form / " & koordinate
ElseIf sender Is btnKopieren Then
Me.Text = "Kopieren / " & koordinate
Else
Me.Text = "Beenden / " & koordinate
End If
End Sub

Über sender können wir auswerten, welche Komponente das Ereignis ausgelöst hat. Dazu wird der erste Parameter mit Me beziehungsweise den Referenzen btnKopieren und btnBeenden mit dem Is-Operator verglichen.

Als Ursprung der Koordinatenmessung ist standardmäßig der linke obere Eckpunkt des Clientbereichs der jeweiligen Komponente festgelegt. Deshalb macht bei der Ausführung des Programms die Koordinatenanzeige auch einen Zahlensprung, sobald der Mauszeiger aus dem Clientbereich der Form in den Clientbereich der Schaltfläche oder umgekehrt wechselt.


Galileo Computing

15.4.4 Ereignisbehandlung mit den »OnXxx«-Methoden  toptop

Ein Ereignis kann durch die Installation einer Ereignisbehandlungsroutine behandelt werden. Alternativ dazu gibt es aber auch noch eine weitere Möglichkeit. Sehen Sie sich dazu den Code der Klasse Form1 an:


Public Class Form1
Protected Overrides Sub OnClick(ByVal e As EventArgs)
Me.Text = "In Form1"
End Sub
End Class

Jede grafische Windows-Komponente beerbt die Klasse Control. Dazu gehören auch Methoden, die einem Ereignisnamen entsprechen, ergänzt um das Präfix On. In der Basisklasse Control ist die Methode OnClick folgendermaßen definiert:


Protected Overridable Sub OnClick(EventArgs)

Interessant ist die Parameterliste, die nur ein Argument aufweist, nämlich das, um spezifische Zustandsinformationen des Ereignisses bereitzustellen. Was fehlt, ist das Argument, das die Referenz auf den Auslöser liefert. Daraus lässt sich schlussfolgern, dass alle OnXxx-Methoden immer auf die aktuelle Komponente aufgerufen werden. Es sind Ereignisempfänger, die spezifisch für ein ganz bestimmtes Objekt sind und nicht von einer anderen Komponente gleichzeitig zur Behandlung eines ausgelösten Ereignisses benutzt werden können. In der Basisklasse Control sind alle OnXxx-Methoden Overridable deklariert und müssen deshalb mit Overrides überschrieben werden.

Doch wozu dienen die OnXxx-Methoden? Diese Frage kann mit einem Satz beantwortet werden:


Methoden, deren Bezeichner vor dem Ereignisnamen das Präfix On aufweisen, sind für den Aufruf aller installierten Ereignishandler zuständig.


Das ist eine Behauptung, die natürlich auch bewiesen werden muss. Deshalb entwickeln wir eine Klasse, die aus Form abgeleitet ist, die OnClick-Methode der Basisklasse überschreibt und beim Klicken auf den Clientbereich in die Titelleiste des Formulars den Text »... in der OnClick-Methode« schreibt. Außerdem wird ein Ereignishandler installiert, der zusätzlich mit einer ergänzenden Titelleistenanzeige auf das Ereignis Click reagieren soll.


' ----------------------------------------------------------
' Beispiel: ...\Kapitel 15\OnClickDemo
' ----------------------------------------------------------
Public Class Form1
Private Sub Form1_Click(ByVal sender As Object, _
ByVal e As EventArgs) Handles MyBase.Click
sender.Text = "Im Ereignishandler "
End Sub
Protected Overrides Sub OnClick(ByVal e As EventArgs)
' MyBase.OnClick(e)
Me.Text &= " ... in der OnClick-Methode"
End Sub
End Class

Beachten Sie bitte, dass eine Anweisung in OnClick auskommentiert ist.

Starten Sie diese Anwendung, wird in die Titelleiste zwar der Text »... in der OnClick-Methode« geschrieben, aber der Text, der aus dem Click-Ereignishandler ebenfalls in Titelleiste geschrieben werden soll, wird definitiv nicht angezeigt. Der Ereignishandler wird also überhaupt nicht aufgerufen.

Heben Sie die Kommentierung in OnClick auf, wird die Anzeige in der Titelleiste »Im Ereignishandler ... in der OnClick-Methode« lauten. Mit MyBasee.OnClick() wird die ursprüngliche Methode in der Basisklasse aufgerufen. Damit ist die Aufgabe, die der virtuell deklarierten OnClick-Methode zukommt, nachgewiesen: Sie hat dafür gesorgt, dass unser installierter Ereignishandler ausgeführt wird.


Der Aufruf der überschriebenen Methode in der Basisklasse garantiert die ursprüngliche Funktionalität. Um keine Einbußen durch das Überschreiben einer OnXxx-Methode in Kauf nehmen zu müssen, sollte daher grundsätzlich in der überschreibenden Methode mit base die überschriebene ausgeführt werden.


 <<   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