Die VBA-Programmierung mit MS-Access 7 - Alpen Adria · PDF file ·...

Pädagogisches Institut des Bundes

in Oberösterreich

Die VBA-Programmierung mit MS-Access 7.0

Prof. Otmar Haring

Access 7.0 - Programmierung

Otmar Haring Seite 1

INHALTSÜBERSICHT

1. Vorbereitung...................................................................................................... 4

2. Die Entwicklungsumgebung ............................................................................. 6

3. Eigenschaften und Ereignisse............................................................................ 6 Ereignisse und ihr Auftreten ............................................................................................. 6

Ereignisprozedur und Veränderung von Eigenschaften ................................................... 7

Entscheidungen im Programmcode .................................................................................. 8

Aufruf einer allgemeinen Prozedur................................................................................... 9

Einstellungen für Programmcode ..................................................................................... 9

Programmtechnisches Öffnen eines Formulars .............................................................. 11

Datenübergabe in ein anderes Formular ......................................................................... 11

MsgBox-Befehl und Funktion ........................................................................................ 12

Abbrechen von Ereignissen ............................................................................................ 13

Filter-Ereignisse.............................................................................................................. 13

4. Auflistungen .................................................................................................... 14

5. Programmstrukturen........................................................................................ 15 DO WHILE - LOOP ....................................................................................................... 15

FOR - NEXT - FOR EACH - NEXT........................................................................ 15

6. Objekttypen ..................................................................................................... 16 Festlegen von Objektvariablen ....................................................................................... 16

Mehrere Instanzen eines Objektes öffnen....................................................................... 17

7. Variablendeklaration ....................................................................................... 17

8. Variablentypen ................................................................................................ 18

9. Globale Funktionen ......................................................................................... 18 Function - Sub................................................................................................................. 18

Optionale Argumente...................................................................................................... 19

Lokale und globale Variablendeklaration....................................................................... 19

ByVal und ByReference - Variablenübergabe ............................................................... 19

Haltepunkte, Schrittweise Programmverfolgung, Anzeige der Variableninhalte .......... 20

Array-Übergabe an Funktion .......................................................................................... 21



10. Anwendung vervollständigen........................................................................ 21 Übersichtsmanager.......................................................................................................... 21

Startoptionen einstellen .................................................................................................. 21

Menü-Editor.................................................................................................................... 22

11. Fehlerbehandlung .......................................................................................... 23 Arten von Fehlern und ihre Behandlung ........................................................................ 23

Bedingte Kompilierung................................................................................................... 24

12. Data-Access-Object (DAO) .......................................................................... 25 Das Recordset-Objekt ..................................................................................................... 25

Move-Methode und RecordCount-Eigenschaft .............................................................. 26

Move-Methode und EOF-Eigenschaft............................................................................ 27

Datensatz hinzufügen (Edit- und Update-Methode)....................................................... 27

Find-Methode.................................................................................................................. 27

Einen bestimmen Datensatz im Formular „Kunden“ suchen ......................................... 28

Hinzufügen von Daten, die in einem Kombinationsfeld eingegeben werden ................ 28

Abfrage dynamisch erstellen und Ergebnis im Testfenster ausgeben ............................ 29

Transaktionen.................................................................................................................. 30

Datenbank erstellen, Laufwerk und Verzeichnis wechseln............................................ 31

Container- und Document-Objekte................................................................................. 32

Objekte in andere Datenbank kopieren........................................................................... 33

13. Datenbank replizieren.................................................................................... 34 Desingn-Master erstellen ................................................................................................ 34

Replika erstellen ............................................................................................................. 34

Synchronisation von Datenbanken ................................................................................. 34

Konfliktlösung bei Replikation....................................................................................... 35

Abfrage der benutzerdefinierten Datenbankeigenschaften............................................. 36

14. OLE-Programmierung................................................................................... 37 OLE-Objekt im Formular ............................................................................................... 37

Datenaustausch mit Word über OLE.............................................................................. 38

Berechnungen in Excel über OLE durchführen.............................................................. 39

15. Zugriffsberechtigungen ................................................................................. 41 Grundüberlegungen ........................................................................................................ 41

Datenbank sichern, Berechtigungen vergeben ............................................................... 42



Protokollieren von Benutzeraktionen ............................................................................. 43

Erstellen einer eigenen WorkSpace ................................................................................ 43

16. Eigene Statuszeile.......................................................................................... 44 Timer-Eigenschaft von Formularen (Uhrzeit in der Statuszeile) ................................... 45

Statuszeile mit Fortschrittsanzeige ................................................................................. 45

Statusanzeige in einem eigenen Formular ...................................................................... 46

17. Liste mit Mehrfachauswahl ........................................................................... 48 Die Eigenschaft „Mehrfachauswahl“.............................................................................. 48

VBA-Eigenschaften von Multiple Choice-Listfeldern:.................................................. 48

18. VBA-Programmierung in Berichten ............................................................. 52 Seitensumme eines Feldes berechnen............................................................................. 52

19. Zusätzliche Anregungen................................................................................ 53 VB-Control-Arrays simulieren ....................................................................................... 53

Kontrollkästchen mit drei Auswahlmöglichkeiten ......................................................... 53

Unterbrechung des AUTOEXEC-Makros verhindern.................................................... 54



1. Vorbereitung Folgende fünf Tabellen sind Grundlage für dieses Skriptum. Die Tabelle „Titel“ ist normalerweise nicht sichtbar.

Aufträge Name Typ Größe Index Auf-ID AutoWert 4 Primärschlüssel Reise-ID Zahl (Long) 4 Ja (mit Duplikaten)

Datensatzherkunft: SELECT DISTINCTROW Reiseziele.ID, Reiseziele.Reiseziel FROM Reiseziele; Gebundene Spalte: 1 Herkunftstyp: Tabelle/Abfrage Spaltenanzahl: 2 Spaltenbreiten: 0;1440 Spaltenreihenfolge: Standard Steuerelement anzeigen: Kombinationsfeld

Kunden-ID Zahl (Long) 4 Ja (mit Duplikaten) Datensatzherkunft: SELECT DISTINCTROW Kunden.ID, Kunden.Nachname, Kunden.Vorname FROM Kunden; Gebundene Spalte: 1 Herkunftstyp: Tabelle/Abfrage Spaltenanzahl: 3 Spaltenbreiten: 0;1440;1440 Steuerelement anzeigen: Kombinationsfeld

gebucht am Datum/Zeit 8 Nein fällig Datum/Zeit 8 Nein Preis Währung 8 Nein bezahlt Ja/Nein 1 Nein

Kunden Name Typ Größe Index ID AutoWert 4 Primärschlüssel Nachname Text 50 Nein Vorname Text 50 Nein Titel Text 20 Nein

Datensatzherkunft: SELECT DISTINCTROW Titel from Titel order by Titel; Gebundene Spalte: 1 Herkunftstyp: Tabelle/Abfrage Spaltenanzahl: 1 Steuerelement anzeigen: Kombinationsfeld

Geschlecht Zahl (Integer) 2 Nein Straße Text 100 Nein PLZ Text 10 Nein Ort Text 50 Nein Telefon 1 Text 50 Nein Telefon 2 Text 50 Nein Anrede Text 50 Nein

Reiseziele Name Typ Größe Index ID AutoWert 4 Primärschlüssel Reiseziel Text 50 Nein Dauer Zahl (Long) 4 Nein Datum Datum/Zeit 8 Nein Reisemittel Text 20 Nein Preis Währung 8 Nein



Titel Name Typ Größe Index Titel Text 20 Nein

Protokolltabelle Name Typ Größe Index ID AutoWert 4 Primärschlüssel Benutzer Text 20 Nein Änderungsdatum Datum/Zeit 8 Nein Änderungsart Text 50 Nein bearbeitete ID Zahl (Long) 4 Ja (mit Duplikaten)

Die Beziehungen der Tabellen sehen folgendermaßen aus:

Um die OLE-Verknüpfung mit WinWord durchführen zu können, ist noch eine Datei erforderlich, die zwei Textmarken „Adresse“ und „Anrede“ enthält, wie nachfolgendes Beispiel zeigt:

Adresse

Anrede



2. Die Entwicklungsumgebung VBA-Code in Access kann in zwei Bereichen erstellt werden. Wenn der

Programmcode direkt mit dem Formular oder Bericht in Zusammenhang steht, wird er meist im Formular oder Bericht abgelegt. Allgemeine Prozeduren oder Funktionen stehen hingegen in eigenen Modulen. Egal, ob man nun den Modulteil eines Formulars/Berichts oder ein eigenes Modul betrachtet - beide besitzen einen Deklarationsteil und einen Bereich, in dem der Programmcode abgelegt ist.

DeklarationenFunktion1

Funktion2Funktion3

Prozedur1Prozedur2

Prozedur3Funktion4

Zusätzlich besitzen Formular-/Berichtsmodule noch einen Bereich, in dem die Ereignisprozeduren zu den einzelnen Objekten abgelegt werden.

DeklarationenFunktion1

Funktion2Funktion3

Prozedur1Prozedur2

Prozedur3

Ereignisproz.1

Ereignisproz.7Ereignisproz.6Ereignisproz.5Ereignisproz.4Ereignisproz.3Ereignisproz.2

Ereignisproz.8 Zusammen mit dem Modulfenster erscheint eine Symbolleiste, die den schnellen

Zugang auf die wichtigsten Fähigkeiten der Entwicklungsumgebung gestattet.

Moduleinfügen

Prozedureinfügen

Testfenster

Objekt-katalog

Programmfortsetzen

Programmbeenden

Neuinitialisieren

Haltepunktsetzen

Wertanzeigen

Aufrufe

Einzelschritt

Prozedur-schritt

Kompilieren EditorAusrücken

Einziehen

3. Eigenschaften und Ereignisse Ereignisse und ihr Auftreten Wenn mit Formularen oder Berichten gearbeitet wird, interpretiert Access

bestimmte Vorgänge in diesen Datenbankobjekten als Ereignisse. Das Wechseln von einem Steuerelement zum nächsten oder von einem Datensatz zum anderen im Formular ist zum Beispiel ein solches Ereignis.



Auf welche Ereignisse ein Objekt reagieren kann, ist in der Eigenschaftsliste des Objektes im Registerblatt „Ereignis“ ersichtlich. Die Ereignisse treten in einer bestimmten Reihenfolge auf:

Öffnen und Schließen eines Formulars: Öffnen Laden AnzeigenGrößenänderung Aktivierung

Entladen SchließenDeaktivierung Hingehen zu und Verlassen von Steuerelementen:

Hingehen Fokuserhalt

Verlassen Fokusverlust Wechsel zwischen Steuerelementen in verschiedenen Formularen:

Fokusverlust (Element1)

Fokuserhalt (Element2)

Deaktivierung (Formular1)

Aktivierung (Formular2)

Ereignisprozedur und Veränderung von Eigenschaften Klick-Prozedur für Button „Datum“ erstellen:

Zum Testen zuerst mehrere Eigenschaften von Objekten verändern Zwei Möglichkeiten zum Eintragen des Fälligkeitsdatums: - Ungebundenes Feld mit einer Berechnungsformel (=[gebucht am] + 7) - Buchungsdatum und Fälligkeitsdatum automatisch durch Programmcode eintragen lassen (Vorteil: Feldinhalte können jederzeit verändert werden!)

Private Sub Datum_Click() '1. Eigenschaft "aktiviert" definieren ' fällig.Enabled = False '2. Umschalten ' fällig.Enabled = Not (fällig.Enabled) '3. zugreifen auf gebundenes Formularfeld mit Leerzeichen ' im Namen [] ' -> Me![feldname] ' Me![gebucht am].Visible = Not (Me![gebucht am].Visible) '4. Hintergrundfarbe -> RGB() ' -> QBColor() ' Me!Preis.BackColor = RGB(255, 0, 0) '5. Datum-gebucht und Fälligkeitsdatum eintragen Me![gebucht am].Value = Date Me!fällig = DateAdd("d", 7, Date) End Sub



Entscheidungen im Programmcode Das Objekt „Mahnen“ soll nur sichtbar sein, wenn der Betrag noch nicht bezahlt

wurde und das Fälligkeitsdatum bereits überschritten ist.

NOT Mit Hilfe dieses Befehls kann sehr schnell eine bestimme Eigenschaft invertiert werden.

IF - THEN Mit der „IF-THEN“-Abfrage können Entscheidungen während des Programmablaufes getroffen werden. Es gibt mehrere Formen, den Befehl anzuwenden:

a) IF Bedingung THEN Aktion

b) IF Bedingung THEN Aktion(en) ELSE Aktion(en) END IF

c) IF Bedingung THEN Aktion(en) ELSEIF Bedingung THEN Aktion(en) ELSE Aktion(en) END IF

SELECT CASE Mit dieser Abfragemöglichkeit kann auf unterschiedlichste Inhalte einer bestimmten Variablen reagiert werden.

SELECT CASE Variable CASE Wert Aktion(en) CASE Wert Aktion(en) END SELECT



Aufruf einer allgemeinen Prozedur Da die Überprüfung der Anzeige des Feldes „Mahnen“ mehrmals stattfinden muß

(bei jedem Anzeigen eines neuen Datensatzes, bei jeder Änderung des „Bezahlt“-Feldes, bei Änderung des Fälligkeitsdatums, ...), empfiehlt sich der Einsatz einer allgemeinen Prozedur.

PRIVATE - PUBLIC: Prozeduren bzw. Funktionen, die nur im Formular Gültigkeit haben, werden mit PRIVATE deklariert. Sollte eine Prozedur aber auch von einem anderen Formular oder Modul aufgerufen werden können, muß sie mit PUBLIC deklariert werden.

Private Sub Form_Current() '1. NOT ' mahnen.Visible = Not bezahlt '2. IF - Then ' Abfrage, ob neuer Datensatz (Preis=0) ' If Not bezahlt And Preis > 0 Then ' mahnen.Visible = True ' Else ' mahnen.Visible = False ' End If '3. Allgem. Proz. Aufrufen TestMahnen End Sub

Public Sub TestMahnen() If Not bezahlt And Preis > 0 And fällig < Date Then mahnen.Visible = True Else mahnen.Visible = False End If End Sub

Private Sub bezahlt_AfterUpdate() '1. Aufruf der allgem. Prozedur TestMahnen End Sub

Private Sub fällig_AfterUpdate() TestMahnen End Sub

Einstellungen für Programmcode Grundeinstellung der Farben für Programmcode, Kommentarzeilen, Haltepunkte, ..

(Extras - Optionen - Modul) Volle Modulansicht (Extras - Optionen - Modul) Variablen-Deklaration erforderlich AutoSyntaxüberprüfung anzeigen Seitenansicht der Module (Datei - Seitenansicht)



Übung: Formular „Kunden“ öffnen und folgende Aufgaben erledigen:

- Optionsgruppe mit der Geschlechtsauswahl hinzufügen

- Eine allgemeine Prozedur für die Briefanrede erstellen: In das Feld „Anrede“ soll je nach Geschlecht „Sehr geehrte Frau“ oder „Sehr geehrter Herr“ gefolgt vom Titel (falls vorhanden) und dem Familiennamen eingetragen werden.

- Diese allgemeine Prozedur muß beim Klick auf den Button und - nur wenn schon eine Anrede besteht - bei jeder Änderung des Geschlechts aufgerufen werden.

Private Sub Brief_Click() SetAnrede End Sub

Private Sub Geschlechtswahl_Click() If Not IsNull(Briefanrede) Then SetAnrede End If End Sub

Public Sub SetAnrede() If Geschlecht = 1 Then Briefanrede = "Sehr geehrter Herr " Else Briefanrede = "Sehr geehrte Frau " End If If Not IsNull(Titel) Then Briefanrede = Briefanrede & Titel & " " End If Briefanrede = Briefanrede & [Nachname] End Sub



Programmtechnisches Öffnen eines Formulars Ein Formular kann programmtechnisch auf drei Arten geöffnet werden:

- durch einen Makrobefehl

- durch den VBA-Befehl „DoCmd.OpenForm“, der die gleiche Argument- reihenfolge wie der Makrobefehl benötigt (siehe in der Hilfe „OpenForm-Methode“)

- durch den VBA-Befehl „DoCmd.OpenForm“, bei dem Argumente in beliebiger Reihenfolge eingegeben werden können. (Im Objektkatalog die Bibliothek „Access“ auswählen, das Modul „DoCmd“ suchen und die Methode „OpenForm“ einfügen) ACHTUNG: Die zur Trennung eingefügten Strichpunkte durch Beistriche ersetzen!!!

Datenübergabe in ein anderes Formular Sollte im Formular „Aufträge“ ein Kunde benötigt werden, der in der

Kundentabelle noch nicht erfaßt wurde, muß durch Klick auf den Button „Neu“ das Kundenformular automatisch geöffnet werden. Dieses Formular muß zur Eingabe eines neuen Datensatzes bereit sein und die Navigationsschaltflächen müssen ausgeblendet sein.

Beim Schließen des Kundenformulars muß der eben eingegebene Datensatz in das Auftragsformular übergeben werden.

Damit kein Fehler beim Schließen des Kundenformulars auftritt, darf die Aktualisierung des Auftragsformulars nur dann stattfinden, wenn dieses auch tatsächlich offen ist.

Um diese Aufgabe zu lösen, wird die benutzerdefinierte Eigenschaft „Tag“ im Kundenformular so verändert, daß der Formularname des aufrufenden Formulars eingetragen wird.

Private Sub Neu_Click() 'Argumentreihenfolge festgelegt ' DoCmd.OpenForm "kunden", , , , acAdd 'benannte Argumente über Objektkatalog DoCmd.OpenForm Formname:="Kunden", DataMode:=acAdd 'ausblenden der Navigationsschaltflächen Forms!Kunden.NavigationButtons = False 'Eigenschaft "Tag" in Kundenformular verändern Forms!Kunden.Tag = "Aufträge" End Sub

Beim Schließen des Kundenformulars wird das vorherige Formular wieder aktiviert:

Private Sub Form_Close() If Me.Tag <> "" Then Forms(Me.Tag)![Kunden-ID].Requery Forms(Me.Tag)![Kunden-ID].Value = Me.ID End If End Sub



MsgBox-Befehl und Funktion Um dem Anwender Mitteilungen vom Programm her zu geben, wird der Befehl

oder die Funktion „MsgBox“ eingesetzt. Die Funktion „MsgBox“ muß mit mindestens einem und maximal fünf Parametern versorgt werden und liefert einen Rückgabewert. In der einfachsten Form erhält die Funktion nur den ersten Parameter, der den Meldungstext festlegt. Die allgemeine Syntax sieht folgendermaßen aus:

MsgBox (prompt [, buttons] [, title] [, helpfile, context] )

Der Befehl „MsgBox“ liefert im Gegensatz zur Funktion keinen Rückgabewert. Der zweite Unterschied ist formaler Art: Die Argumente werden nicht in Klammern gesetzt.

Das Argument „buttons“ beeinflußt die Art der Schaltflächen und der Icons im Meldungsfenster. Eine Summierung der Werte liefert das gewünschte Ergebnis:

Konstante Inhalt Schaltfläche(n) vbOKOnly 0 OK vbOKCancel 1 OK, Abbrechen vbAbortRetryIgnore 2 Beenden, Wiederholen, Ignorieren vbYesNoCancel 3 Ja, Nein, Abbrechen vbYesNo 4 Ja, Nein vbRetryCancel 5 Wiederholen, Abbrechen

Konstante Inhalt Icon vbCritical 16 Stop-Schild vbQuestion 32 Fragezeichen vbExlamation 48 Ausrufezeichen vbInformation 64 Buchstabe „i“

Konstante Inhalt Bevorzugte Schaltfläche vbDefaultButton1 0 1. Schaltfläche vbDefaultButton2 256 2. Schaltfläche vbDefaultButton3 512 3. Schaltfläche



Der Rückgabewert gibt Auskunft über die gedrückte Schaltfläche:

Konstante Inhalt Gedrückte Schaltfläche vbOK 1 OK vbCancel 2 Abbrechen vbAbort 3 Beenden vbRetry 4 Wiederholen vbIgnore 5 Ignorieren vbYes 6 Ja vbNo 7 Nein

Abbrechen von Ereignissen Manchen Ereignisprozeduren werden Parameter übergeben. Sollte in der

Argumentliste der Parameter „Cancel“ aufscheinen, kann dieses Ereignis abgebrochen werden.

Zwei Beispiele: - Wenn der Nachname vor dem Vornamen eingegeben wird, soll das Feldupdate nicht durchgeführt werden. - Das Schließen des Formulars „Kunden“ soll durch eine Abfrage bestätigt werden

Private Sub Nachname_BeforeUpdate(Cancel As Integer) If IsNull(Vorname) Then MsgBox "Bitte erst Vorname eingeben!" Cancel = True End If End Sub

Private Sub Form_Unload(Cancel As Integer) If MsgBox("Wollen Sie das Formular wirklich schließen?", _ vbYesNo + vbQuestion) = vbNo Then Cancel = True End If End Sub

Filter-Ereignisse Access 7.0 bietet eine neue Art der Datenfilterung: Den formularbasierten Filter.

Mit zwei neuen Ereignissen („Bei Filter“ und „Bei angewendetem Filter“) kann auf die Filterung von Daten reagiert werden.

Um dem Formular „Kunden“ ein neues Aussehen zu geben, wenn der formularbasierte Filter angewendet wird, sollen der Hintergrund neu eingefärbt und die Telefonfelder ausgeblendet werden, sowie die Filterung nach der PLZ nicht möglich sein. Das Fenster soll auch noch eine neue Beschriftung bekommen.

Das Filterfenster kann auf zwei Arten beendet werden: - durch Anwenden des Filters - durch Abbrechen der Filtereinstellungen

Beim Schließen sollen alle vorgenommenen Änderungen des Formularaussehens wieder zurückgenommen werden. Zusätzlich soll bei Abbrechen des Filterfensters eine Meldung am Bildschirm erscheinen.



Private Sub Form_Filter(Cancel As Integer, _ FilterType As Integer) 'FilterType gibt die Art des Filters an '-> Formularfilter oder erweiterter Filter If FilterType = acFilterByForm Then Detailbereich.BackColor = RGB(255, 255, 0) Telefon_1.Visible = False Telefon_2.Visible = False 'Liste für PLZ ausschalten PLZ.FilterLookup = False 'Überschrift für Formular Me.Caption = "Suchen" End If End Sub

Private Sub Form_ApplyFilter(Cancel As Integer, _ ApplyType As Integer) 'ApplyType gibt das Beenden des Filterfensters an 'z.B. Abbrechen oder Anwenden If ApplyType = acCloseFilterWindow Then MsgBox "Warum haben Sie nichts ausgewählt?" Me.Filter = Null End If Detailbereich.BackColor = QBColor(7) Telefon_1.Visible = True Telefon_2.Visible = True 'Überschrift für Formular Me.Caption = "Kunden" End Sub

4. Auflistungen Auflistungen enthalten Objekte, die alle denselben Typ haben. Ein Objekt kann entweder direkt über seinen Namen oder manchmal nur über seine Auflistung angesprochen werden. Da mit einer Auflistung ein Objekt angesprochen wird, besitzt dieses natürlich auch Eigenschaften.

Folgende Beispiele sind im Textfenster auszuprobieren!

Beispiele von Auflistungen:

Forms.Auflistung:

? Forms(0).Name ? Forms(1).Name

? Forms.Count

? Forms(0).CurrentView (0 = Entwurf, 1 = Formular, 2 = Datenblatt) ? Forms!Aufträge.CurrentView ? Forms("Aufträge").CurrentView ? Forms(Variable).CurrentView ? Form_Aufträge.CurrentView



Controls.Auflistung:

? Forms(0).Controls.Count ? Forms(0).Controls(0).Name ? Forms(0)(0).Name

? Forms("Aufträge").Controls("fällig").ControlSource

5. Programmstrukturen Mit Hilfe von Schleifen kann manchmal sehr elegant mit Auflistungen gearbeitet werden. Dies ist vor allem dann nötig, wenn mit wenig Programmcode Eigenschaften von mehreren Objekten verändert oder aufgelistet werden sollen.

DO WHILE - LOOP DO WHILE Bedingung

Aktion(en) LOOP

FOR - NEXT - FOR EACH - NEXT

Sub Listforms1() Dim i As Integer For i = 0 to Forms.Count-1 Debug.Print Forms(i).Name Next End Sub

Sub Listforms2() Dim i As Variant For Each i In Forms Debug.Print i.Name Next End Sub

Sub ListControls() Dim ctrl For Each ctrl In Forms("Aufträge").Controls Debug.Print ctrl.Name Next End Sub

Sub ListProps() Dim Prop Debug.Print Forms(0).Controls(0).Name For Each Prop In Forms(0).Controls(0).Properties Debug.Print Prop.Name, Prop.Value Next End Sub



6. Objekttypen Um in einer Auflistung von Objekten nur bestimmte Typen herauszufiltern, kann mit der Abfrage „TYPEOF“ der Type des Objekts bestimmt werden.

Folgende Objekttypen sind gültig: CheckBox ComboBox CommandButton Image Label Line ListBox OptionButton OptionGroup Rectangle SubForm SubReport TextBox ToggleButton

Sub Listfelder() Dim ctrl Dim vari vari = InputBox("Welches Formular?") For Each ctrl In Forms(vari) If TypeOf ctrl Is TextBox Then Debug.Print ctrl.Name End If Next End Sub

Sub ctrlÄndern() Dim ctrl For Each ctrl In Forms("Aufträge").Controls 'Alle Buttons werden aktiviert oder deaktiviert If TypeOf ctrl Is CommandButton Then If ctrl.Enabled = True Then ctrl.Enabled = False Else ctrl.Enabled = True End If End If Next End Sub

Festlegen von Objektvariablen Um nicht immer den gesamten Objektbezug angeben zu müssen, kann einer

Variablen ein Objektverweis zugewiesen werden. Dies geschieht mit dem Befehl „SET Variable = “.

Sollte mit einem Objekt längere Zeit gearbeitet werden (z.B. weil mehrere Eigenschaften definiert werden müssen), können mit dem Befehl „WITH“, der auf dieses Objekt verweist, mehrere Anweisungen für dieses Objekt durchgeführt werden.



Public Sub KundenObjekt() Dim frm As Form 'neues Objekt definieren '-> gesamter Name braucht nicht mehr angegeben werden Set frm = Forms!Kunden 'Schnelles Setzen von Eigenschaften eines Objektes With frm.Nachname .Visible = True .Enabled = True .BackColor = QBColor(10) End With End Sub

Mehrere Instanzen eines Objektes öffnen Mit dem Befehl „NEW“ ist es möglich, eine weitere Instanz eines Objektes zu

öffnen. Dies wird zum Beispiel benötigt, wenn in einem Formular Daten bearbeitet werden, und zur gleichen Zeit mit dem gleichen Formular neue Datensätze eingegeben werden sollen.

Auf dem Kunden-Formular wird ein Button erstellt, der die allgemeine Prozedur „OpenKundenNeu“ aufruft.

Public Sub OpenKundenNeu() 'Kundenformular als neue Instanz öffnen 'z.B. zum Eingeben eines neuen Kunden, 'ohne im ersten Formular etwas zu ändern Set frm = New Form_Kunden 'Im Hinzufügemodus öffnen frm.DataEntry = True 'Neue Instanz anzeigen frm.Visible = True 'um es programmtechnisch zu schließen: '-> set frm = Nothing End Sub

7. Variablendeklaration In Funktion oder Prozedur:

Dim VarName[(Dimension)][As [New] Typ]

Static VarName[(Dimension)][As [New] Typ]

ReDim [Preserve] VarName(Dimension) [As Type]



In Moduldeklaration (allgemein)

Public VarName[(Dimension)][As [New] Typ]

Private VarName[(Dimension)][As [New] Typ]

[Private | Public] Type Varname Elementname[(Dimension)] As Typ [Elementname[(Dimension)] As Typ] ... End Type

8. Variablentypen Byte 1 Byte 0 bis 255

Boolean 2 Bytes True oder False

Integer 2 Bytes -32.768 bis 32.767

Long 4 Bytes -2.147.483.648 bis 2.147.483.647

Single 4 Bytes -3,402823E38 bis -1,401298E-45 für negative Werte 1,401298E-45 bis 3,402823E38 für positive Werte

Double 8 Bytes -1,79769313486232E308 bis -4,94065645841247E-324 (neg.) 4,94065645841247E-324 bis 1,79769313486232E308 (pos.)

Currency 8 Bytes -922.337.203.685.477,5808 bis 922.337.203.685.477,5807

Date 8 Bytes 1. Januar 100 bis 31. Dezember 9999

Object 4 Bytes Beliebiger Verweis auf ein Objekt vom Typ Object

String 10 Bytes + 2^31 = 0 bis ca. 2 Mrd. unter Win95, (variable Länge) Textlänge 2^16 = 0 bis ca. 65.400 unter Windows 3.x

String Textlänge 2^31 = 0 bis ca. 2 Mrd. unter Win95, (feste Länge) 2^16 = 0 bis ca. 65.400 unter Windows 3.x

Variant) 16 Bytes Numerische Werte im Bereich des Datentyps Double (mit Zahlen)

Variant 22 Bytes + Wie bei String mit variabler Länge (mit Zeichen) Textlänge

9. Globale Funktionen Funktionen bzw. Prozeduren, die nicht nur in einem Formular oder Bericht benötigt werden, programmiert man in globalen Modulen. Diese bestehen genauso wie der Programmteil in einem Formular (Bericht) aus Deklarationsteil und Programmcode (Funktionen oder Prozeduren). Es gibt allerdings in globalen Modulen keine Ereignisprozeduren.

Function - Sub Der Unterschied zwischen einer Prozedur (Sub) und einer Funktion (Function) ist

der, daß die Funktion einen Wert zurückliefert (z.B. SIN, MOD, INSTR, ...). Dies bedeutet, daß das Ergebnis einer Funktion immer weiterbehandelt werden muß (z.B. Zuweisen an eine Variable, Ausgeben in ein Feld, ...).

An Funktionen oder Prozeduren können auch Argumente übergeben werden. Dabei werden die Argumente beim Aufruf von Funktionen in Klammer und bei Prozeduren nicht in Klammer übergeben.



Public Function MWSt() MWST = 0.2 End Function

Public Function MWSt(Betrag) MWSt = Betrag * 0.2 End Function

Public Function MWSt(Betrag, MWStSatz) MWSt = Betrag * MWStSatz End Function

Optionale Argumente Wenn Argumente nur manchmal gebraucht werden, kann man sie als „Optional“

deklarieren:

Public Function MWSt(Betrag, Optional MWStSatz) If IsMissing(MWStSatz) Then MWStSatz = 0.2 MWSt = Betrag * MWStSatz End Function

Public Function EndPreis(Betrag, Optional Zuschlag, _ Optional MWStSatz) If IsMissing(Zuschlag) Then Zuschlag = 0.5 End If Betrag = Betrag * (1 + Zuschlag) If IsMissing(MWStSatz) Then MWStSatz = 0.2 End If EndPreis = Betrag + MWSt(Betrag, MWStSatz) End Function

Lokale und globale Variablendeklaration Abhängig vom Ort der Variablendeklaration, hat die Variable nur einen

bestimmten Gültigkeitsbereich (nur in der Funktion (Prozedur), im gesamten Modul, in der gesamten Anwendung).

Public Function Test() Dim vari vari = InputBox("Bitte Betrag eingeben!") ShowVari Test = EndPreis(vari) ShowVari End Function

Public Sub ShowVari() MsgBox "Vari := " & vari -> liefert Fehlermeldung, da nicht dekl. End Sub

ByVal und ByReference - Variablenübergabe Variablen belegen im Speicher einen bestimmten Speicherplatz. Je nachdem, ob an

eine Funktion nur der Wert der Variablen oder die Adresse des Speicherplatzes der



Variablen übergeben wird, kann sich der jeweilige Inhalt der Ursprungsvariablen ändern.

Bei der Übergabe „ByReference“ (Standard) wird die Adresse der Variablen übergeben. Verändert die Funktion den Wert der Variablen, so ändert sich auch der Wert der Ursprungsvariablen.

Bei der Übergabe „ByVal“ wird nur der Wert der Variablen übergeben. Die Funktion legt sich eine neue Variable an einem anderen Speicherplatz an. Bei Veränderung des Variableninhaltes in der Funktion wird daher der Inhalt der Ursprungsvariablen nicht verändert.

Haltepunkte, Schrittweise Programmverfolgung, Anzeige der Variableninhalte Um die folgenden Beispiele genau verfolgen zu können, sind Debuging-Tools

notwendig.

gleiche Proz wie oben, aber mit globaler Dekl. der Variablen Vari Private Vari

2 verschiedene Aufrufe der Function Endpreis: Public Function EndPreis(Betrag, Optional Zuschlag, _ Optional MWStSatz) Public Function EndPreis(ByVal Betrag, Optional _ Zuschlag, Optional MWStSatz)



Array-Übergabe an Funktion Wenn die Anzahl der Argumente für eine bestimmte Funktion (z.B. Summieren

von Zahlen) sehr unterschiedlich sein kann, kann mit der Übergabe eines Arrays (Feldes) diese Aufgabe gelöst werden.

Public Function Summiere(ParamArray Werte()) Dim x Dim erg For Each x In Werte erg = erg + x Next Summiere = erg End Function

10. Anwendung vervollständigen Übersichtsmanager Mit Hilfe des Übersichts-Managers wird automatisch ein Startformular erstellt.

Startoptionen einstellen Unter diesem Menüpunkt, der im „Extras“-Menü zu finden ist, können die

Startparameter der Applikation eingestellt werden. Neben der Angabe des Startformulars können auch noch ein Anwendungstitel und ein Symbol (Grafikdatei) vergeben werden.



Menü-Editor DerApplikation kann ein eigenes Menü zugewiesen werden, das am leichtesten mit

dem Menü-Editor erstellt wird. Dabei kann ein bestehendes Menü verändert oder ein neues erstellt werden. In diesem Beispiel wird beim Anklicken eines Menüpunktes die Funktion „OpenForm“ aufgerufen, die verschiedene Formulare in unterschiedlichem Modus öffnet (0 = hinzufügen; 1 = editieren).



Public Function OpenForm(Formular, Modus) Dim frm For Each frm In Forms If frm.Name = Formular Then DoCmd.Close A_FORM, Formular End If Next DoCmd.OpenForm Formular, , , , Modus End Function

11. Fehlerbehandlung Arten von Fehlern und ihre Behandlung Syntaxfehler: Tritt bei der Programmeingabe auf:

Fehlermeldung bestätigen und Fehler ausbessern Kompilierfehler: Tritt beim Kompilieren des Programms auf: Fehlermeldung bestätigen und Fehler ausbessern Laufzeitfehler: Tritt erst beim Programmlauf auf: „On Error“-Fehlerbehandlung im Programm Art des Fehler mit den Access-Objekten „Err.Number“ und „Err.Description“ erkennbar

In den Optionen (Extras - Optionen - Modul) kann eingestellt werden, daß trotz „On Error“-Behandlung im Code bei jedem Fehler angehalten wird.

Public Sub FormÖffnen() Dim Fn Fn = InputBox("Bitte geben Sie den Namen des zu " _ & " öffnenden Formulares ein", "Formularname") If Fn <> "" Then On Error Resume Next DoCmd.OpenForm Fn Forms(Fn).Detailbereich.BackColor = RGB(200, 200, 0) Debug.Print Err.Number, Err.Description End If End Sub

Public Sub FormÖffnen() Dim Fn Fn = InputBox("Bitte geben Sie den Namen des zu " _ & " öffnenden Formulares ein", "Formularname") If Fn <> "" Then On Error Resume Next DoCmd.OpenForm Fn Forms(Fn).Detailbereich.BackColor = RGB(200, 200, 0) Forms(Fn).Controls(2).ForeColor = RGB(0, 100, 100) If Err.Number <> 0 Then MsgBox "Fehler: " & Err.Number & vbCrLf & _ "Formular " & Fn & " ist nicht vorhanden!" End If End If End Sub



Public Sub FormÖffnen() Dim Fn On Error GoTo Err_Zeile Fn = InputBox("Bitte geben Sie den Namen des zu " _ & " öffnenden Formulares ein", "Formularname") If Fn <> "" Then DoCmd.OpenForm Fn Forms(Fn).Detailbereich.BackColor = RGB(200, 200, 0) Forms(Fn).Controls(2).ForeColor = RGB(0, 100, 100) End If Exit Sub Err_Zeile: Fn = InputBox("Bitte geben Sie den Namen des zu " _ & " öffnenden Formulares ein", "Bitte neu eingeben!") If Fn <> "" Then Resume Else Exit Sub End If End Sub

Bedingte Kompilierung Access 7.0 bietet die Möglichkeit, Programmteile nur unter Zutreffen einer

bestimmten Bedingung kompilieren zu lassen. Diese Möglichkeit wird angewendet, wenn Teile des Programmcodes auf Grund verschiedener Systemvoraussetzungen anders aussehen, und daher anders kompiliert werden müssen.

Diese Möglichkeit kann aber auch angewendet werden, wenn ein Programmteil noch nicht fertig programmiert wurde, und man trotzdem einen Kompilierlauf starten möchte. Für diesen Fall setzt man eine Bedingung ein, die nicht zutreffen kann und klammert dadurch den noch fehlerhaften Programmteil von der Kompilierung aus.

Voraussetzungen für die bedingte Kompilierung: Variable muß im allgemeinen Teil mit „#Const“ deklariert werden Bedingte Kompilierung mit „#If - #End If“

#Const Version = 2

Public Sub Kompilierung() Dim x 'Bedingte Kompilierung: 'Variable muß mit #Const deklariert werden! #If Version = 1 Then If x = 4 Then x= End If #End If End Sub



12. Data-Access-Object (DAO) Folgende Abbildung zeigt die Hierarchie von Datenzugriffsobjekten (Data-Access-Object). In dieser Abbildung werden allerdings nur Auflistungen (mit Ausnahme des Objekts DBEngine auf der obersten Ebene) dargestellt. Jede Auflistung enthält jedoch wiederum Objekte. Nicht dargestellt in dieser Abbildung ist lediglich die Property-Auflistung.

Das Recordset-Objekt Das Recordset-Objekt wird zum Bearbeiten der Daten in der Datenbank verwendet.

Um ein Recordset zu öffnen, wird die Methode „Openrecordset“ verwendet: Set Variable = Datenbank.OpenRecordSet(Herkunft, Typ, Optionen)

Herkunft: Name der Tabelle/Abfrage oder SQL-Befehl

Typ: dbOpenTable: Verweist auf eine Tabelle. Einige Operationen (Sortieren, Verwenden der Methode „Seek“) sind nur für diesen Typ verfügbar.

dbOpenDynaset: Verweist auf eine Tabelle oder das Ergebnis einer Abfrage. Ermöglicht das Extrahieren und Aktualisieren von Daten aus mehreren Tabellen.

dbOpenSnapshot: Gleicht dem Typ Dynaset, ist allerdings nur eine statische Kopie der Daten zum Zeitpunkt der Erstellung. Ein Snapshot kann nicht aktualisiert werden.



Optionen: dbAppendOnly: Es können nur neue Datensätze hinzugefügt werden (Dynaset) dbSeeChanges: Es wird ein Laufzeitfehler ausgelöst, wenn ein anderer Benutzer Daten ändert, die ich bearbeite dbDenyWrite: Andere Benutzer können keine Datensätze ändern oder hinzufügen

Auf das Recordset-Objekt können mehrere Methoden angewendet werden und es besitzt auch einige Eigenschaften.

Methoden: AddNew CancelUpdate Delete Edit Find-Methoden Move-Methoden Requery Update

Eigenschaften: BOF, EOF Bookmark EditMode NoMatch RecordCount

Move-Methode und RecordCount-Eigenschaft Die folgenden zwei Beispiele liefern jeweils die Anzahl von Datensätzen. Im ersten

Fall soll die Anzahl der Datensätze in der Tabelle „Kunden“ bestimmt werden, im zweiten ist die Anzahl der in Wien lebenden Kunden gefragt.

Public Function RecCountTab() Dim rs As Recordset Set rs = CurrentDb.OpenRecordset("Kunden", dbOpenTable) rs.MoveLast Debug.Print rs.RecordCount rs.Close End Function

Public Function RecCountSQL() Dim rs As Recordset Set rs = CurrentDb.OpenRecordset("SELECT * FROM " & _ "Kunden WHERE Ort='Wien'", dbOpenDynaset) rs.MoveLast Debug.Print rs.RecordCount rs.Close End Function



Move-Methode und EOF-Eigenschaft Im Testfenster sollen die Nachnamen der Kunden der Reihe nach ausgegeben

werden.

Function ReadInfo() Dim rs As Recordset Set rs = CurrentDb.OpenRecordset("Kunden", dbOpenDynaset) While Not rs.EOF Debug.Print rs![Nachname] rs.MoveNext Wend rs.Close End Function

Datensatz hinzufügen (Edit- und Update-Methode) In der Tabelle „Aufträge“ soll ein Datensatz hinzugefügt werden. Der Kunde ist

dabei zufällig aus der Tabelle „Kunden“ und das Reiseziel aus der Tabelle „Reiseziele“ zu wählen. Das Buchungsdatum soll ein beliebiges Datum im ersten Halbjahr 1996 sein.

Public Function RecAdd() Dim rs1 As Recordset, rs2 As Recordset, rs3 As Recordset Set rs1 = CurrentDb.OpenRecordset("Aufträge", _ dbOpenTable) Set rs2 = CurrentDb.OpenRecordset("Kunden", _ dbOpenSnapshot) Set rs3 = CurrentDb.OpenRecordset("Reiseziele", _ dbOpenSnapshot) rs2.MoveLast rs3.MoveLast rs1.AddNew rs1![Kunden-ID] = Int(Rnd * rs2.RecordCount) + 1 rs1![Reise-ID] = Int(Rnd * rs3.RecordCount) + 1 rs1![gebucht am] = DateSerial(96, Int(Rnd * 6) + 1, _ Int(Rnd * 27) + 1) rs1![fällig] = rs1![gebucht am] + 14 rs1.UPDATE rs1.Close rs2.Close rs3.Close End Function

Find-Methode Nachdem im Formular „Aufträge“ eine Reise ausgewählt wurde (Ereignis

„AfterUpdate“ des Feldes „Reise-ID“), soll der Preis der Reise aus der Tabelle „Reiseziele“ übernommen und in der Tabelle „Aufträge“ eingetragen werden.

Um diese Aufgabe lösen zu können, muß der gleiche Datensatz in der Tabelle „Reiseziele“ gesucht werden, der im Feld „Reise-ID“ ausgewählt wurde.



Private Sub Reise_ID_AfterUpdate() Dim rs As Recordset Dim kriterium As String Set rs = CurrentDb.OpenRecordset("Reiseziele", _ dbOpenDynaset) kriterium = "[ID] = " & Me![Reise-ID] rs.FindFirst kriterium If Not rs.NoMatch Then Me![Preis] = rs!Preis End If rs.Close End Sub

Einen bestimmen Datensatz im Formular „Kunden“ suchen Im Formular „Kunden“ ist im Formularkopf ein Kombinationsfeld zu erstellen, mit

dessen Hilfe ein Datensatz gesucht werden kann. Das Kombinationsfeld beinhaltet alle Kunden-Datensätze. Durch Auswahl eines bestimmten Kunden soll auch im Detailbereich des Formulars dieser Kunde aufscheinen.

Private Sub Suchname_AfterUpdate() Dim rs As Recordset Dim fm As Form Set fm = Me Set rs = Me.RecordsetClone rs.FindFirst "ID = " & Me!Suchname fm.Bookmark = rs.Bookmark rs.Close End Sub

Hinzufügen von Daten, die in einem Kombinationsfeld eingegeben werden Der akademischen Grad wird in der Tabelle „Kunden“ mit Hilfe eines

Kombinationsfeldes erfaßt. Dieses Kombinationsfeld erhält seine Daten aus der unsichtbaren Tabelle „Titel“. Wenn ein neuer Titel eingegeben wird, der noch nicht in der Tabelle gespeichert ist, soll dieser nach einer Sicherheitsabfrage hinzugefügt werden. Auch im Kombinationsfeld soll der neu dazugekommene Titel sofort aufscheinen.

Wenn Daten eingegeben werden, die nicht in der Liste vorkommen, wird die gleichnamige Ereignisprozedur („NotInList“) aufgerufen, der zwei Standard-



parameter übergeben werden: NewData: Enthält den Eintrag, der nicht in der Liste vorgekommen ist. Response: Ist eine eingebaute Konstante, die angibt, wie auf das Ereignis „NotInList“ reagiert wurde. Das Argument kann folgende Konstanten annehmen: acDataErrDisplay (Voreinstellung) Zeigt dem Benutzer die Standardmeldung an. Wird verwendet, um den Benutzer zu hindern, einen neuen Wert zum Listenfeld hinzuzufügen. acDataErrContinue Unterdrückt die Standardmeldung. Nimmt den neuen Eintrag nicht in die Liste auf. acDataErrAdded Unterdrückt die Standardmeldung. Nimmt den neuen Eintrag in die Liste auf und vergleicht durch erneutes Abfragen das Kombinationsfeld mit den Herkunfts- daten.

Private Sub Titel_NotInList(NewData As String, _ Response As Integer) If MsgBox("Titel ist nicht in der Liste!" & vbCrLf & _ "Möchten Sie ihn eintragen?", vbYesNo + vbQuestion) = _ vbYes Then AddTitel NewData Response = acDataErrAdded Else Response = acDataErrContinue End If End Sub

Public Function AddTitel(sTitel) Dim rs As Recordset Set rs = CurrentDb.OpenRecordset("Titel") rs.AddNew rs!Titel = sTitel rs.UPDATE rs.Close End Function

Abfrage dynamisch erstellen und Ergebnis im Testfenster ausgeben Durch Aufruf einer Funktion („Selgruppe“) im Testfenster sollen die

Monatssummen der Aufträge als Ergebnis tabellarisch dargestellt werden.



Dazu ist vorerst eine neue Abfrage zu erstellen, bei der die Argumente mit einer SQL-Anweisung definiert werden. Das Ergebnis dieser Abfrage wird anschließend im Testfenster ausgegeben.

Function SelGruppe() Dim rs As Recordset Dim q As QueryDef On Error GoTo Abfragefehler Set q = CurrentDb.QueryDefs("Test") q.SQL = "SELECT DISTINCTROW Format([gebucht am], " & _ "'mmmm yy') as Monat, Sum(Aufträge.Preis) AS " & _ "[Summe von Preis] FROM Aufträge GROUP BY " & _ "Format([gebucht am],'mmmm yy') " & _ "ORDER BY First(Aufträge.[gebucht am]);" Set rs = q.OpenRecordset While Not rs.EOF Debug.Print rs.Fields(0), rs.Fields(1) rs.MoveNext Wend rs.Close Exit Function Abfragefehler: Set q = CurrentDb.CreateQueryDef("Test") Resume Next End Function

Transaktionen In der Regel werden Transaktionen verwendet, um die Integrität der Daten zu

gewährleisten, wenn Datensätze in zwei oder mehr Tabellen aktualisiert werden müssen, und sichergestellt sein muß, daß alle Änderungen in allen Tabellen vollständig durchgeführt wurden.

Wenn zum Beispiel Geld von einem Konto auf ein anderes überwiesen werden soll, wird ein Betrag von einem Kontostand abgezogen und zum anderen Kontostand hinzuaddiert. Wenn eine der beiden Aktualisierungen fehlschlägt, stimmt die Bilanz der Konten nicht mehr.

Mit der „BeginTrans“-Methode wird die Transaktion eingeleitet. Um alle Änderungen zu übernehmen, bedient man sich anschließend der „CommitTrans“-Methode. Möchte man die Änderungen rückgängig machen, kann dies mit der „RollBack“-Methode durchgeführt werden.

Die Änderungen werden im Temp-Verzeichnis der Arbeitsstation zwischengespeichert. Dabei ist zu achten, daß genügend Festplattenspeicher frei ist, da sonst das Jet-Datenbankmodul einen Fehler auslöst.

Übung: Durch Aufruf einer Funktion sollen in der Tabelle „Aufträge“ zehn neue Datensätze mit Zufallsdaten hinzugefügt werden (siehe „Datensatz hinzufügen“ auf Seite 27 und „Find-Methode“ auf Seite 27). Nach jeweils 5 hinzugefügten Datensätzen soll der Anwender entscheiden können, ob die Datensätze wirklich angefügt werden sollen oder nicht.



Public Function RecAddTrans() Dim rs1 As Recordset, rs2 As Recordset, rs3 As Recordset Dim ws As Workspace Dim kriterium As String Dim i As Integer Set ws = DBEngine.Workspaces(0) Set rs1 = CurrentDb.OpenRecordset("Aufträge", _ dbOpenTable) Set rs2 = CurrentDb.OpenRecordset("Kunden", _ dbOpenSnapshot) Set rs3 = CurrentDb.OpenRecordset("Reiseziele", _ dbOpenDynaset) rs2.MoveLast rs3.MoveLast ws.BeginTrans For i = 1 to 10 rs1.AddNew rs1![Kunden-ID] = Int(Rnd * rs2.RecordCount) + 1 rs1![Reise-ID] = Int(Rnd * rs3.RecordCount) + 1 rs1![gebucht am] = DateSerial(96, Int(Rnd * 6) + 1, _ Int(Rnd * 27) + 1) rs1![fällig] = rs1![gebucht am] + 14 kriterium = "[ID] = " & rs1![Reise-ID] rs3.FindFirst kriterium If Not rs3.NoMatch Then rs1![Preis] = rs3![Preis] End If rs1.UPDATE If i = 5 or i = 10 Then If MsgBox("5 Sätze angefügt, Bestätigen?", _ vbYesNo) = vbYes Then ws.CommitTrans Else ws.Rollback End If ws.BeginTrans End If Next ws.Rollback rs1.Close rs2.Close rs3.Close ws.Close End Function

Datenbank erstellen, Laufwerk und Verzeichnis wechseln Im Verzeichnis „C:\Eigene Dateien\Access95\Programmierung“ soll eine neue

Datenbank mit dem Namen „ReisebüroCopy.mdb“ erstellt werden. (Diese Datenbank wird für anschließende Übungen mit Datenbank-Repliaktionen benötigt.)



Sollte das aktuelle Verzeichnis nicht das obengenannte sein, muß dorthin gewechselt werden. Anschließend wird nach einer Sicherheitsabfrage (ob die Datei schon besteht) die neue Datenbank mit der Methode „CreateDatabase“ angelegt, die zwei Argumente benötigt:

Datenbankname: Name der neuen Datenbank

Gebietsschema: Ein Zeichenfolgeausdruck, mit dem die Sortier- reihenfolge zum Erstellen der Datenbank angegeben wird. Nähere Hinweise in der Access-Hilfe.

Function CreateDB() Dim db As DATABASE Dim ws As Workspace Set ws = DBEngine.Workspaces(0) ChDrive "C:" If CurDir <> _ "C:\Eigene Dateien\Access95\Programmierung" Then ChDir "C:\Eigene Dateien\Access95\Programmierung" End If If Dir("ReisebüroCopy.mdb") <> "" Then Kill ("ReisebüroCopy.mdb") End If Set db = ws.CreateDatabase("ReisebüroCopy", _ dbLangGeneral) db.Close ws.Close End Function

Container- und Document-Objekte Jedes Database-Objekt besitzt eine Containers-Auflistung, die aus integrierten

Container-Objekten besteht (Databases, Forms, Tables, ...). Jedes Container-Objekt wiederum besitzt eine Documents-Auflistung, die ein Document-Objekt für jedes Vorkommen des Objekttyps enthält. Die Eigenschaften der einzelnen Objekte sind in der Hilfe von Access beschrieben.

Die Namen der Container mit den Namen der darin enthaltenen Dokumente und

deren letztes Änderungsdatum sollen in einer Liste im Testfenster ausgegeben werden.



Function ObjName() Dim db As DATABASE Dim cont As Container Dim obj As Document Dim i As Integer Set db = CurrentDb For i = 0 To db.Containers.Count - 1 Set cont = db.Containers(i) Debug.Print cont.Name For Each obj In db.Containers(i).Documents Debug.Print , obj.Name, obj.LastUpdated Next Next db.Close End Function

Objekte in andere Datenbank kopieren Alle Tabellen (mit Ausnahme der Systemtabellen) sollen in die vorhin angelegte

Datenbank „ReisebüroCopy“ kopiert werden.

Function CopyObj() Dim db As DATABASE Dim doc As Document Set db = CurrentDb For Each doc In db.Containers("Tables").Documents If Left(doc.Name, 4) <> "MSys" Then DoCmd.CopyObject "ReisebüroCopy.mdb", , acTable, _ doc.Name End If Next db.Close End Function



13. Datenbank replizieren Desingn-Master erstellen Die Datenbank „ReisebüroCopy“ soll die Eigenschaft „Design-Master“ in einem

Replica-Set bekommen. Dazu wird die Datenbank im Hintergrund exklusiv (zweiter Parameter auf „true“) geöffnet und die Eigenschaft „replizierbar“ („Replicable“) auf „true“ („T“) gesetzt.

Function RepliDB() Dim db As DATABASE Dim prop As Property Set db = DBEngine.OpenDatabase("ReisebüroCopy.mdb", True) Set prop = db.CreateProperty("Replicable", dbText, "T") db.Properties.Append prop db.Close End Function

Replika erstellen Programmtechnisch gibt es zwei Möglichkeiten, eine Replika zu erstellen.

a) Von der Datenbank „Reisebüro“ ausgehend, wird eine Replika der Datenbank „ReisebüroCopy“ mit dem Namen „ReisebüroCopy R1“ erstellt. Der zweite Parameter „Beschreibung“ ist ein String, der das zu erstellende Replikat beschreibt und ist zwingend vorgeschrieben.

Function Replica1() Dim db As DATABASE Set db = DBEngine.OpenDatabase("ReisebüroCopy.mdb", True) db.MakeReplica "ReisebüroCopy R1.mdb", "Beschreibung" db.Close End Function

b) Von einer replizierbaren Datenbank (Design-Master „ReisebüroCopy“ oder der Replika „ReisebüroCopy R1“) aus wird die Replika erstellt. Dazu ist ein Wechsel in eine der vorher angelegten Datenbanken notwendig!

Function Replica2() Dim db As DATABASE Set db = CurrentDb db.MakeReplica "ReisebüroCopy R2.mdb", "Beschreibung" db.Close End Function

Synchronisation von Datenbanken Der zweite optionale Parameter gibt die Richtung an, in die synchronisiert werden

soll:

dbRepImpExpChanges: Austausch in beide Richtungen (Voreinstellung) dbRepImportChanges: Änderung empfangen dbRepExportChanges: Änderung senden



Function Synch() Dim db As DATABASE Set db = CurrentDb db.Synchronize "ReisebüroCopy R1.mdb", dbRepExportChanges db.Close End Function

Konfliktlösung bei Replikation Wenn bei einer Synchronisation in einem Replica-Set ein Konflikt auftritt, wird

automatisch der Konfliktmanager von Access aufgerufen, mit dessen Hilfe der Konflikt gelöst werden kann.

Möchte man diesen Konfliktmanager durch eine eigene Funktion ersetzen, die vielleicht die Konflikte automatisch löst, muß über den Menüpunkt „Datenbankeigenschaften“ im Datei-Menü eine neue Datenbankeigenschaft („ReplicationConflictFunction“) hinzugefügt werden, die angibt, welche Funktion (z.B. „MyConf()“) ausgeführt werden soll, wenn ein Konflikt auftritt.

Name: ReplicationConflictFunction Typ: Text Wert: MyConf()

Diese Eigenschaft kann auch programmtechnisch gesetzt werden:



Function SetConflictProp() Dim db As DATABASE Dim doc As Document Dim prop As Property Set db = CurrentDb Set doc = _ db.Containers("Databases").Documents("UserDefined") On Error GoTo Err_Handler Set prop = _ doc.CreateProperty("ReplicationConflictFunction", & _ dbText, "MyConf()") doc.Properties.Append prop On Error GoTo 0 Weiter: 'Eigenschaft könnte umbenannt werden doc.Properties("ReplicationConflictFunction") = _ "MyConf()" Exit Function Err_Handler: MsgBox "Property existiert schon, ist aber egal!" Resume Weiter End Function

Abfrage der benutzerdefinierten Datenbankeigenschaften

Function DBProps() Dim db As DATABASE Dim doc Dim prop As Property Set db = CurrentDb Set doc = _ db.Containers("Databases").Documents("UserDefined") For Each prop In doc.Properties Debug.Print prop.Name, prop.Value Next db.Close End Function

Die Funktion liefert folgendes Ergebnis:



Sollte ein Konflikt auftreten, wird die Tabelle Tabellenname_Conflict erzeugt. Beim nächsten Öffnen der Datenbank wird dann automatisch die Konflikt-Prozedur angesprungen, die in den Eigenschaften definiert wurde.

Hier kann der Konflikt programmtechnisch gelöst werden.

Function MyConf() MsgBox "Hier sollte die Konflikt-Prozedur stehen" End Function

14. OLE-Programmierung OLE-Objekt im Formular Im Formular „Aufträge“ wird ein ungebundenes Objektfeld (EXCEL-Tabelle)

eingefügt. Durch Klick auf den Button „cmdOLE“ werden in der Tabelle die Monatsumsätze eingetragen.

Die Eigenschaft „Klasse“ des Objektfeldes muß in der Prozedur „cmdOLE_Click“ im Programmcode angepaßt werden:

Function InsExcel(obj As Object) Dim rs As Recordset Dim cell As Integer Set rs = CurrentDb.OpenRecordset("SELECT DISTINCTROW " & _ "Format([gebucht am],'mmm yy') as Monat, " & _ "Sum(Aufträge.Preis) AS [Summe] FROM Aufträge " & _ "GROUP BY Format([gebucht am],'mmm yy') ORDER BY " & _ "First(Aufträge.[gebucht am])") cell = 1 While Not rs.EOF obj.Cells(cell, 1).Value = "" & rs.Fields(0) obj.Cells(cell, 2).Value = "" & rs.Fields(1) cell = cell + 1 rs.MoveNext Wend rs.Close End Function



Private Sub cmdOLE_Click() If OLE1.Class = "Excel.Sheet.5" Then InsExcel OLE1 Else MsgBox "Falsche Klasse" End If End Sub

Datenaustausch mit Word über OLE Im Formular „Kunden“ soll ein Button erstellt werden, mit dem die Kundendaten

in ein vorbereitetes Word-Dokument geschrieben werden. Anschließend soll das Dokument gespeichert und gedruckt und das im Hintergrund geöffnete Word wieder geschlossen werden.

Das ausgefüllte Word-Dokument „Reisebüro.doc“, das anschließend unter dem Namen „Test0.doc“ gespeichert wird:



Dim obj As Object Dim pfad As String On Error GoTo Pfadfehler pfad = "C:\Eigene Dateien\Access95\Programmierung\" Set obj = CreateObject("Word.Basic") obj.DateiÖffnen pfad & "Reisebüro.doc" obj.BearbeitenGeheZu "Adresse" If Me.Geschlecht = 1 Then obj.Einfügen "Herrn" Else obj.Einfügen "Frau" End If obj.Einfügen " " & Titel obj.Einfügen Chr$(11) obj.Einfügen Vorname & " " & Nachname & Chr$(11) obj.Einfügen Straße & Chr$(11) obj.Einfügen PLZ & " " & Ort obj.BearbeitenGeheZu "Anrede" obj.Einfügen "" & Briefanrede obj.DateiSpeichernUnter pfad & "Test0.doc" ' obj.DateiDrucken Set obj = Nothing Exit Sub Pfadfehler: Debug.Print Err.Number, Err.Description If Err.Number = 177 Or Err.Number = 78 Then pfad = InputBox("Die Pfadangabe für die Datei" & _ Chr$(13) & Chr$(10) & "'REISEBÜRO.DOC' ist " & _ "falsch!" & Chr$(13) & Chr$(10) & Chr$(13) & _ Chr$(10) & "Wie lautet der richtige Pfad?", _ "Pfadfehler") If IsNull(pfad) Or pfad = "" Then Exit Sub End If Resume End Sub

Berechnungen in Excel über OLE durchführen Im Formular „Reiseziele“ werden zwei ungebundene Textfelder und ein Button

eingefügt. Durch Klick auf diesen Button sollen der Tagesdurchschnittspreis der aktuellen Formularseite sowie der Tagesdurchschnittspreis von allen Angeboten berechnet werden. Dazu müssen die jeweiligen Datenfelder „Dauer“ und „Preis“ sowie die Berechnungsformeln nach Excel geschrieben werden. Die Ergebnisse der Berechnungen sollen in den ungebundenen Textfeldern ausgegeben werden.



Private Sub cmdOLEExcel_Click() Dim obj As Object Dim rs As Recordset Dim i As Integer Dim anz As Integer Set obj = CreateObject("Excel.Sheet") obj.Cells(1, 1).Value = Me!Dauer.Value obj.Cells(1, 2).Value = Me!Preis.Value obj.Cells(2, 1).Value = "Durchschnitt:" obj.Cells(2, 2).Value = "=B1/A1" Me!OLE1.Value = obj.Cells(2, 2).Value Set rs = CurrentDb.OpenRecordset("Reiseziele") rs.MoveLast rs.MoveFirst anz = rs.RecordCount For i = 1 To anz obj.Cells(i, 4).Value = rs!Dauer.Value obj.Cells(i, 5).Value = rs!Preis.Value rs.MoveNext Next obj.Cells(anz + 1, 4).Value = "=Sum(D1:D" & anz & ")" obj.Cells(anz + 1, 5).Value = "=Sum(E1:E" & anz & ")" obj.Cells(anz + 2, 4).Value = "Durchschnitt:" obj.Cells(anz + 2, 5).Value = "=E" & anz + 1 & "/D" & _ anz + 1 Me!OLE2.Value = obj.Cells(anz + 2, 5).Value ' obj.Application.Visible = True ' Stop ' obj.Application.Visible = False Set obj = Nothing End Sub



15. Zugriffsberechtigungen Grundüberlegungen Access bietet die Möglichkeit, die Datenbank vor unberechtigten Zugriffen zu

schützen. Die Informationen über Benutzer, Gruppen und Paßwörter werden dabei in einer eigenen Arbeitsgruppen-Datei (*.mdw) gespeichert. Standardmäßig verwendet Access die Datei „SYSTEM.MDW“. Da es sinnvoll ist, jede zu schützende Datenbank mit einer eigenen Arbeitsgruppen-Datei zu versehen, um unterschiedliche Benutzer und Gruppen für diese Datenbank definieren zu können, muß vorerst eine neue Arbeitsgruppe erstellt werden.

Dies geschieht mit dem Programm „WRKGADM.EXE“, das sich im Access-

Verzeichnis befindet. Anschließend können für diese Arbeitsgruppe die Benutzer und die Gruppen erstellt werden. Bei der Vergabe von Rechten ist zu beachten, daß der Eigentümer der Datenbank (standardmäßig der Administrator) alle Rechte besitzt. Dies bedeutet, daß eine Datenbank nur dann sicher geschützt werden kann, wenn dem Administrator als Standarduser alle Rechte genommen werden.



Nach dem Start von Access wird über den Befehl „Extras - Zugriffsrechte - Benutzer- und Gruppenkonten...“ vorerst das Anmeldeverfahren aktiviert, indem dem Administrator (dies ist der Standard-User) ein Kennwort zugewiesen wird. Anschießend ist ein neuer Benutzer einzufügen, der später die Datenbank administrieren wird. Er muß der Gruppe der „Administratoren“ hinzugefügt werden. Der Benutzer „Administrator“ muß aus der Gruppe der „Administratoren“ entfernt werden! Wenn anschließend Access neu gestartet wird, ist das Anmeldeverfahren bereits aktiv.

Um als neuer Eigentümer eine Datenbank erstellen zu können, muß man sich nun

mit dem vorhin definierten Namen anmelden. Da dieser neue Benutzer (der zukünftige Administrator der Datenbank) noch über kein Kennwort verfügt, muß ihm dies auf die gleiche Weise zugewiesen werden wie vorher dem Administrator. Erstellt der nun angemeldete Benutzer eine Datenbank, ist er Eigentümer und besitzt somit alle Rechte. Muß eine bereits bestehende Datenbank gesichert werden, ist diese zu laden, und mit dem Menüpunkt „Benutzer-Datensicherheitsassistent...“ eine neue Datenbank zu erstellen. Dieser Assistent weist dem neuen Benutzer alle Rechte zu und entzieht sie zugleich allen anderen.

Nun können andere Benutzer und Gruppen definiert und ihnen Rechte auf die einzelnen Objekte zugewiesen werden. Wichtig bei der Vergabe der Berechtigungen ist , daß der Benutzer „Administrator“ und die Gruppe „Benutzer“ über keinerlei Rechte verfügen.

Datenbank sichern, Berechtigungen vergeben Im folgenden Beispiel sollen alle Änderungen im Formular „Kunden“ in einer

eigenen Tabelle protokolliert werden. Dazu ist eine neue Gruppe „Demogruppe“ und ein neuer Benutzer „Demo“ anzulegen, der Mitglied dieser Gruppe ist. Die neue Gruppe erhält auf alle Formulare die Berechtigung „Öffnen/Ausführen“ und auf alle Tabellen mit Ausnahme der „Protokolltabelle“ alle Rechte außer „Entwurf ändern“ und „Verwalten“. Versucht nun der Demo-User die „Protokolltabelle“ zu öffnen oder den Entwurf anzusehen, erscheint eine der folgenden Fehlermeldungen:



Protokollieren von Benutzeraktionen Wenn ein Datenbankbenutzer in der Kundentabelle Datensätze neu eingibt,

verändert oder löscht, sollen diese Aktionen in der „Protokolltabelle“ aufgezeichnet werden. Dazu wird auf die einzelnen Ereignisse mit je einer Prozedur reagiert, indem eine globale Prozedur mit der Art der Tätigkeit und der betroffenen Satznummer aufgerufen wird. Beim Löschen eines Datensatzes muß die Satznummer vor der Löschbestätigung gesichert werden.

Dim Satznummer As Long

Private Sub Form_AfterDelConfirm(Status As Integer) Protokoll "gelöscht", Satznummer End Sub

Private Sub Form_AfterInsert() Satznummer = Me.ID Protokoll "eingegeben", Satznummer End Sub

Private Sub Form_AfterUpdate() Satznummer = Me.ID Protokoll "geändert", Satznummer End Sub

Private Sub Form_Delete(Cancel As Integer) Satznummer = Me.ID End Sub

Erstellen einer eigenen WorkSpace Da außer dem Eigentümer der Datenbank die „Protokolltabelle“ niemand öffnen

darf, muß die Datenbank im Hintergrund ein zweites Mal mit einer anderen WorkSpace geöffnet werden. Das Modul, in welchem der folgende Programmcode steht, muß auf alle Fälle gegen Zugriffe von anderen Benutzern geschützt werden, da hier das Kennwort des Eigentümers eingetragen sein muß.

Da bei Anlegen eines neuen Datensatzes zwei Ereignisse (zuerst „AfterUpdate“ und anschließend „AfterInsert“) eintreten, muß im Programmcode darauf entsprechend reagiert werden.



Private Const UserName = "Otmar"

Private Const Kennwort = "password"

Sub Protokoll(Tätigkeit As String, Satznummer As Long) Dim db As DATABASE Dim db1 As DATABASE Dim rs As Recordset Dim ws As Workspace Dim pfad As String Set ws = DBEngine.CreateWorkspace("OH-Arbeitsbereich", _ UserName, Kennwort) DBEngine.Workspaces.Append ws Set db1 = CurrentDb() pfad = db1.Name db1.Close Set db = ws.OpenDatabase(pfad) Set rs = db.OpenRecordset("Protokolltabelle") If Tätigkeit = "eingegeben" Then rs.MoveLast rs.Edit rs.Änderungsart = Tätigkeit rs.UPDATE Else rs.AddNew rs.Benutzer = CurrentUser() rs.Änderungsdatum = Now rs.Änderungsart = Tätigkeit rs.[bearbeitete ID] = Satznummer rs.UPDATE End If rs.Close db.Close ws.Close End Sub

16. Eigene Statuszeile In manchen Fällen ist es notwendig, den Benutzer über den Fortschritt von bestimmten Aktionen zu informieren oder ihn mit laufenden Informationen zu versorgen. Diese Informationen können in der Statuszeile untergebracht werden.

Mit Hilfe der Funktion „SysCmd“ kann der Statusanzeiger oder ein beliebiger Text in der Statuszeile abgelegt werden. Weiters liefert diese Funktion auch noch Informationen über Access und seine dazugehörigen Daten (z.B. Versionsnummer von Access, Name der verwendeten INI-Datei, ...).

Die Funktion hat folgendes Aussehen. Weitere Informationen sind in der Hilfe nachzulesen. Rückgabewert = SysCmd(Aktion[, Text][, Wert])



Timer-Eigenschaft von Formularen (Uhrzeit in der Statuszeile) Setzt man den Parameter „Aktion“ auf „acSysCmdSetStatus“ kann ein beliebiger

Text in der Statuszeile abgelegt werden. Der Parameter „acSysCmdClearStaus“ löscht die Statuszeile wieder.

Im folgenden Beispiel sollen Uhrzeit und Datum in der Statuszeile angezeigt werden, wenn das Formular „Reiseziele“ geöffnet ist. Da sich der Zustand der Statuszeile ständig ändert, muß jede Sekunde eine Funktion aufgerufen werden, die den Inhalt der Statuszeile ändert. Die Eigenschaft „Zeitgeberintervall“ („Timer“) legt eine bestimmte Zeitspanne in Millisekunden fest, nach deren Ablauf das Ereignis „Bei Zeitgeber“ („OnTimer“) eintritt.

Private Sub Form_Open(Cancel As Integer) Me.OnTimer = "= StatusDatumZeit" Me.TimerInterval = 1000 End Sub

Private Sub Form_Close() Dim r Me.OnTimer = "" Me.TimerInterval = 0 r = SysCmd(acSysCmdClearStatus) End Sub

Function StatusDatumZeit() Dim r r = SysCmd(acSysCmdSetStatus, Format$(Time, _ "hh:mm:ss") & " " & Format$(Date, "dd.mm.yy")) End Function

Statuszeile mit Fortschrittsanzeige Wenn Access längere Operationen durchführen muß, kann in der Statuszeile der

Fortschritt der Aktion angezeigt werden.

Im folgenden Beispiel sollen im Kundenformular alle Datensätze durch Klick auf einen Button durchlaufen und angezeigt werden. In der Statuszeile ist der Benutzer über den Fortschritt der Aktion zu informieren.

Für diese Aufgabe müssen die Parameter „acSysCmdInitMeter“ (Initialisiert den Statusanzeiger), „acSysCmdUpdateMeter“ (Aktualisiert den Statusanzeiger) und „acSysCmdRemoveMeter“ (Entfernt den Statusanzeiger) verwendet werden.



Private Sub cmdFortschrittSysCmd_Click() Dim rs As recordset Dim fm As Form Dim i As Integer Dim r As Integer Dim anz As Long

Set fm = Me Set rs = fm.RecordsetClone rs.movelast anz = rs.recordcount rs.movefirst r = SysCmd(acSysCmdInitMeter, "Datensätze anzeigen", anz) For i = 1 To anz - 1 r = SysCmd(acSysCmdUpdateMeter, i) rs.movenext fm.Bookmark = rs.Bookmark Next r = SysCmd(acSysCmdRemoveMeter) rs.Close End Sub

Statusanzeige in einem eigenen Formular Da der Statuszeile manchmal zu wenig Aufmerksamkeit geschenkt wird, ist oft

eine Statusanzeige in einem eigenen Formular sinnvoller. In diesem Formular werden keine Daten verwaltet, deshalb können alle zusätzlichen Bildelemente (wie Bildlaufleisten, Datensatzmarkierer, Navigationsschaltflächen, usw.) ausgeblendet werden.



Durch Klick auf einen Button im Kundenfenster soll eine allgemeine Prozedur „Fortschrittsfenster“ aufgerufen werden, die das Fenster mit der Fortschrittsanzeige öffnet. Die Funktion soll so allgemein geschrieben werden, daß sie von jedem beliebigen Fenster gestartet werden könnte. Der Prozedur werden zwei Parameter mitgegeben: Der Prozentwert und optional der Titel. Ist der Prozentwert Null, wird das Fenster geöffnet und initialisiert, beim Wert 100 wird das Fenster wieder geschlossen.

Private Sub cmdFortschrittFenster_Click() Dim rs As recordset Dim fm As Form Dim i As Integer Dim r As Integer Dim anz As Long Set fm = Me Set rs = fm.RecordsetClone rs.movelast anz = rs.recordcount rs.movefirst 'Initialisieren der Fortschrittsanzeige Fortschrittsfenster 0, "Datensätze anzeigen" For i = 1 To anz - 1 Fortschrittsfenster Int(i / anz * 100 + 0.5) rs.movenext fm.Bookmark = rs.Bookmark Next Fortschrittsfenster 100 rs.Close End Sub

Sub Fortschrittsfenster(wert As Integer, Optional Titelzeile) Static fm1 As Form Static fm2 As Form If wert = 0 Then Set fm1 = Screen.ActiveForm DoCmd.OpenForm "Fortschrittsanzeige" Set fm2 = Screen.ActiveForm fm2.TeilRechteck.Left = fm2.GesamtRechteck.Left fm2.TeilRechteck.Top = fm2.GesamtRechteck.Top fm2.TeilRechteck.Height = fm2.GesamtRechteck.Height If Not IsMissing(Titelzeile) Then fm2.txtTitel.Caption = Titelzeile End If fm2.SetFocus End If If wert = 100 Then DoCmd.Close A_FORM, "Fortschrittsanzeige" Exit Sub End If fm2.TeilRechteck.Width = Int(wert / 100 * _ fm2.GesamtRechteck.Width) fm2.txtProzent.Caption = Str$(wert) & " %" DoCmd.RepaintObject A_FORM, "Fortschrittsanzeige" End Sub



17. Liste mit Mehrfachauswahl Die Eigenschaft „Mehrfachauswahl“ Die Eigenschaft „Mehrfachauswahl“ in einem Listenfeld gibt an, ob ein Benutzer

mehrere Zeilen in der Liste auswählen kann oder nicht. Dabei gibt es drei Einstellungen: Keine: Mehrfachauswahl ist nicht möglich

Einzeln: Mehrere Elemente können durch Mausklick oder Leertaste ausgewählt werden.

Erweitert: Mehrere Elemente können durch Mausklick mit „Shift“- bzw. „Strg“-Taste markiert werden.

Im folgenden Beispiel soll das Kombinationsfeld zur Auswahl des Reisemittels in eine Multi-Select-Liste umgewandelt werden. Die Bindung an das Tabellenfeld „Reisemittel“ wird dabei aufgehoben. Ein weiteres Textfeld „txtReisemittelGesamt“ wird angelegt und an das Tabellenfeld gebunden. Die Zeichenlänge vom Tabellenfeld sollte entsprechend erhöht werden, da der Inhalt länger werden kann.

VBA-Eigenschaften von Multiple Choice-Listfeldern: Selected: Mit dieser Eigenschaft kann die Auswahl eines Listenfeldes

abgefragt oder gesetzt werden. Beispiel: Me!Listbox.Selected(4) = True wählt das fünfte Element aus

ItemsSelected: Diese Auflistung beinhaltet nur die Indexzahlen der ausgewählten Zeilen in einem Listenfeld.

Column: Diese Eigenschaft identifiziert eindeutig einen Eintrag in einem mehrspaltigen Listenfeld: Beispiel: = Me!Listbox.Column(0, 3) wählt das Element in Spalte 1 (Parameter 0) und Zeile 4 (Parameter 3) aus

Im folgenden Beispiel wird nach dem Update der Reisemittelliste das Textfeld „txtReisemittelgesamt“ aus den einzelnen Reisemitteln zusammengestellt. Die Funktion, die diese Arbeit übernimmt, soll dabei so universell programmiert sein, daß eine beliebige Liste, ein beliebiges Trennzeichen und eine beliebige Spalte (bei mehrspaltigen Listen) ausgewertet werden können.



Private Sub Reisemittelliste_AfterUpdate() txtReisemittelGesamt = ListeAuswerten _ (Me!Reisemittelliste, ", ", 0) End Sub

Function ListeAuswerten(Liste As Control, _ Trennzeichen As String, Spalte As Integer) As Variant 'Liste: Gibt den Namen der Liste an 'Trennzeichen: Gibt das/die Zeichen an, mit dem/denen _ die einzelnen Inhalte getrennt werden 'Spalte: Gibt die Spalte an, aus der der Inhalt _ genommen werden soll Dim varReturn As Variant Dim Zeile As Variant varReturn = Null For Each Zeile In Liste.ItemsSelected If IsNull(varReturn) Then varReturn = Liste.Column(Spalte, Zeile) Else varReturn = varReturn & Trennzeichen & _ Liste.Column(Spalte, Zeile) End If Next ListeAuswerten = varReturn End Function

Beim Anzeigen eines neuen Datensatzes soll zuerst von allen Zeilen im Listenfeld die Markierung entfernt werden. Anschließend wird das Feld „txtReisemittelGesamt“ ausgewertet und die entsprechenden Zeilen im Listenfeld wieder markiert.

Der Funktion „ListeEinzelnAuswählen“ werden folgende Parameter übergeben: - der Listenname als Control - ein Boolescher Wert, der angibt, ob das Feld markiert werden soll oder nicht - ein Array von Variantfeldern, die den Inhalt der auszuwählenden Zeilen beinhalten. Da das Array unterschiedlich groß sein kann, wird dieser Parameter in der Funktion als „ParamArray“ definiert.

Private Sub Form_Current() Dim ret As Boolean ret = ListeAllesAuswählen(Me!Reisemittelliste, False) ret = ListeEinzelnAuswählen(Me!Reisemittelliste, True, _ WerteBestimmen(Me!txtReisemittelGesamt, ", ", 1), _ WerteBestimmen(Me!txtReisemittelGesamt, ", ", 2), _ WerteBestimmen(Me!txtReisemittelGesamt, ", ", 3), _ WerteBestimmen(Me!txtReisemittelGesamt, ", ", 4)) End Sub



Function ListeAllesAuswählen(Liste As Control, _ Wert As Boolean) As Boolean 'Liste: Gibt den Namen der Liste an 'Wert: Bestimmt, ob Zeilen ausgewählt oder nicht _ ausgewählt werden sollen On Error GoTo ListeAllesAuswählen_Fehler Dim i As Integer For i = 0 To Liste.ListCount - 1 Liste.Selected(i) = Wert Next ListeAllesAuswählen = True Exit Function ListeAllesAuswählen_Fehler: ListeAllesAuswählen = False Exit Function End Function

Function ListeEinzelnAuswählen(Liste As Control, Wert As _ Boolean, ParamArray Inhalte()) As Boolean 'Liste: Gibt den Namen der Liste an 'Wert: Bestimmt, ob Zeilen ausgewählt oder nicht _ ausgewählt werden sollen 'Inhalte: Array von Inhalten, die ausgewählt werden _ sollen On Error GoTo ListeEinzelnAuswählen_Fehler Dim i As Integer Dim Element As Variant For i = 0 To Liste.ListCount - 1 For Each Element In Inhalte If Element = Liste.ItemData(i) Then Liste.Selected(i) = Wert Exit For End If Next Element Next i ListeEinzelnAuswählen = True Exit Function ListeEinzelnAuswählen_Fehler: ListeEinzelnAuswählen = False Exit Function End Function



Die Funktion „WerteBestimmen“ soll ebenfalls so allgemein programmiert werden, daß sie mehrfach eingesetzt werden kann. Dazu werden ihr drei Parameter übergeben:

- der Name des Textfeldes als Control

- das Trennzeichen mit dem die Einträge getrennt wurden

- eine Zahl, die angibt, der wievielte Eintrag im Textfeld gefiltert werden soll. Existiert dieser Eintrag nicht, muß der Wert „Null“ zurückgeliefert werden.

Function WerteBestimmen(Textfeld As Control, Trennzeichen _ As Variant, Index As Integer) As Variant 'Textfeld: Gibt den Namen des Textfeldes an, das _ die Werte beinhaltet 'Trennzeichen: Gibt das/die Zeichen an, mit dem/denen _ die einzelnen Inhalte getrennt werden 'Index: Gibt die an, der wievielte Eintrag _ genommen werden soll Dim varReturn As Variant Dim Position1 As Variant Dim Position2 As Variant Dim i As Integer If IsNull(Textfeld) Then Exit Function Position2 = 1 For i = 1 To Index Position1 = Position2 Position2 = InStr(Position1 + 1, Textfeld, _ Trennzeichen) If Position1 = 0 Then Exit For End If Next If Position1 = 0 Then varReturn = Null ElseIf Position2 = 0 Then varReturn = Mid(Textfeld, Position1) Else varReturn = Mid(Textfeld, Position1, _ Position2 - Position1) End If If InStr(varReturn, Trennzeichen) > 0 Then varReturn = Mid(varReturn, 1 + Len(Trennzeichen)) End If WerteBestimmen = varReturn End Function



18. VBA-Programmierung in Berichten Seitensumme eines Feldes berechnen Um im Seitenfuß die Gesamtsumme des Preises darzustellen, müssen die einzelnen

Preise beim Ereignis „Drucken“ in einer Variablen summiert werden. Beim Ausdrucken des Seitenfußes wird einem ungebundenen Feld der Inhalt der Variablen zugewiesen.

Dim Gesamt As Double

Private Sub Detailbereich_Print(Cancel As Integer, _ PrintCount As Integer) Gesamt = Gesamt + Me.Preis End Sub

Private Sub Seitenfuß_Print(Cancel As Integer, _ PrintCount As Integer) Me.Gesamtsumme = Gesamt End Sub

Private Sub Seitenkopf_Print(Cancel As Integer, _ PrintCount As Integer) If Gesamt = 0 Then Me.Übertrag = "" Me.Übertragtext.Caption = "" Else Me.Übertrag = Gesamt Me.Übertragtext.Caption = "Übertrag:" End If End Sub



19. Zusätzliche Anregungen VB-Control-Arrays simulieren Visual Basic bietet mit Arrays (Feldern) die Möglichkeit, gleiche Objekttypen in

einer Schleife zu behandeln. Da in Access keine Möglichkeit besteht, solche Arrays zu definieren, kann man diese mit einem kleinen Trick simulieren.

Angenommen auf einem Formular befinden sich einige Kontrollkästchen (Checkboxes), die alle bei Eintreten eines bestimmten Ereignisses (z.B. Öffnen des Formulars, Klick auf einen Button, ...) auf den Wert 0 gesetzt werden sollen.

Um ein Array zu simulieren, müssen alle Objekte den gleichen Namen mit einer fortlaufenden Nummer haben (z.B. „Schultyp1“, „Schultyp2“, ...). zusätzlich muß ein unsichtbares Bezeichnungsfeld (z.B. „AnzahlCheckBoxes“) mit der Anzahl der Objekte als Beschriftung auf dem Formular plaziert werden.

Der folgende Programmcode löscht alle Häkchen in den Kontrollkästchen:

Private Sub cmdClear_Click() Dim i As Integer For i = 1 To Val(AnzahlCheckboxes.Caption) Me("Schultyp" & i).Value = 0 Next End Sub

Kontrollkästchen mit drei Auswahlmöglichkeiten Normalerweise bietet ein Kontrollkästchen zwei Auswahlmöglichkeiten

(ausgewählt oder nicht ausgewählt). Unter manchen Umständen ist es aber notwendig, eine dritte Auswahlmöglichkeit zuzulassen (z.B.: Teilnahme an einer Schulveranstaltung: „Macht mit“, „Macht nicht mit“, „Ist noch unschlüssig“). Die dritte Möglichkeit wird durch ein graues Kästchen repräsentiert.



Um dies zu erreichen, darf das Kontrollkästchen nicht mit einem „Ja/Nein“-Feld

belegt sein, sondern mit einem Zahlenfeld vom Typ „Integer“. Die dritte Option (graues Kästchen) wird dann angezeigt, wenn das Datenfeld den Inhalt „Null“ besitzt.

Um bei jedem Klick auf das Kästchen einen anderen Inhalt zu erzeugen, muß als erstes der aktuelle Inhalt in einer Variablen („Alterwert“) gesichert werden. Daraufhin wird der Inhalt zyklisch gewechselt.

Dim Alterwert As String

Private Sub Teilnahme_Enter() If IsNull(Teilnahme.Value) Then Alterwert = "" Else Alterwert = Trim$(Str$(Teilnahme.Value)) End If End Sub

Private Sub Teilnahme_Click() If Alterwert = "-1" Then Me!Teilnahme.Value = 0 Alterwert = "0" ElseIf Alterwert = "0" Then Me!Teilnahme.Value = Null Alterwert = "" Else Me!Teilnahme.Value = -1 Alterwert = "-1" End If End Sub

Unterbrechung des AUTOEXEC-Makros verhindern Normalerweise kann die Ausführung eines AUTOEXEC-Makros durch Drücken

der „Shift“-Taste beim Laden der Applikation verhindert werden. Diese Möglichkeit kann in Access 7.0 durch Setzen einer entsprechenden Datenbankeigenschaft mit dem Namen „AllowByBassKey“ verhindert werden. Die Eigenschaft kann die Werte „True“ oder „False“ annehmen. Ist „AllowByBassKey“ auf „True“ gesetzt, ist die Unterbrechung mit der „Shift“-Taste möglich, bei „False“ nicht möglich.



Im folgenden Beispiel soll eine Funktion „Start“ vom „Autoexec“-Makro aufgerufen werden. Nach Überprüfung des momentanen Benutzers soll nur der Datenbankeigentümer die Möglichkeit haben, die Startoption zu ändern.

Es ist auch darauf zu achten, daß beim ersten Start (wenn die Eigenschaft noch

nicht besteht) kein Programmfehler auftritt.

Function Start() Dim db As DATABASE Dim antwort As Integer Dim Zustand As Boolean Dim Startzustand As String On Error GoTo Start_Error If CurrentUser() = "otmar" Then Set db = CurrentDb() Zustand = db.Properties!AllowBypassKey If Zustand Then Startzustand = "IST MÖGLICH" Else Startzustand = "IST NICHT MÖGLICH" End If antwort = MsgBox("Die momentane Starteinstellung" & _ " lautet: " & vbCrLf & vbCrLf & _ "Unterbrechung des 'AUTOEXEC-Makros' " & _ vbCrLf & Startzustand & vbCrLf & vbCrLf & _ "Soll diese Einstellung geändert werden?" _ , 4 + 32, "Startoption einstellen!") If antwort = 6 Then SetByPass Not Zustand End If End If Start_Exit: Exit Function Start_Error: If Err = 3270 Then 'Eigenschaft existiert nicht db.Properties.append _ db.Createproperty("AllowByPassKey", _ dbBoolean, True) Resume Else 'Ein anderer Fehler ist aufgetreten MsgBox "Unerwarteter Fehler: " & Error$ _ & " (" & Err & ")" Resume Start_Exit End If End Function



Sub SetByPass(Flag As Boolean) Dim db As DATABASE Set db = CurrentDb() db.Properties!AllowBypassKey = Flag End Sub

Die VBA-Programmierung mit MS-Access 7 - Alpen Adria · PDF file ·...

Documents

Transcript of Die VBA-Programmierung mit MS-Access 7 - Alpen Adria · PDF file ·...