Ein VBA-Programm in Excel

Inhaltsverzeichnis
1 Vorwort .................................................................................................................................. 3
1.1 Wie alles begann ........................................................................................................ 3
1.2 Was leistet das Programm ......................................................................................... 4
1.3 Inhalt und Ziele der Ausarbeitung .............................................................................. 5
1.4 Programm-Umgebung ............................................................................................... 6
1.5 Weitere (persönliche) Anmerkungen ......................................................................... 6
2 Das Programm ...................................................................................................................... 6
2.1 Grundsätzliches zur Programmierung in VBA ............................................................ 6
2.1.1 Variablendeklarationen ......................................................................................... 6
2.1.2 Makros ................................................................................................................... 8
2.1.3 Unterprogrammtechnik ....................................................................................... 10
2.1.4 Objekte, Eigenschaften und Methoden ............................................................... 10
2.1.4.1 Objekte und ihre Hierarchie ........................................................................ 11
2.1.4.2 Eigenschaften ............................................................................................. 13
2.1.4.3 Methoden ................................................................................................... 13
2.2 Die Gäste kommen ................................................................................................... 14
2.3 Die Entwicklungsumgebung von VBA ...................................................................... 16
2.4 Ereignisse in VBA ...................................................................................................... 17
2.5 Der Kern des Programms: die Auslosung ................................................................. 20
2.5.1 Eigene Dialoge entwerfen und programmieren................................................. 23
2.5.2 Die neuen Tabellenblätter ................................................................................... 32
2.5.2.1 Das Tabellenblatt "Liste" ........................................................................... 32
2.5.2.2 Pro Durchgang je ein Tabellenblatt ............................................................ 33
2.5.2.3 Das Tabellenblatt "Ergebnis" ...................................................................... 34
2.5.3 Das Mischprogramm: wer kommt in welchem Durchgang an welchem Tisch an
welchem Platz? ................................................................................................................. 36
2.5.4 Zusatzfunktionen ................................................................................................. 41
3 Ausblick/Nachbetrachtung ................................................................................................ 49
3.1 Neuralgische Punkte ................................................................................................ 49
3.2 Mögliche Weiterentwicklungen ............................................................................... 51
4 Literatur- und Quellenverzeichnis ..................................................................................... 52
2

1 Vorwort
1.1 Wie alles begann
Jedes Jahr zwischen Weihnachten und Silvester findet bei meinem
Schwager ein privates Doppelkopfturnier statt. Seit ca. 20 Jahren erfreut
es sich einer immer größeren Beliebtheit; es ist zur Tradition geworden.
Die ersten Jahre fand das Turnier noch in einem kleinen
Rahmen – jeder kannte jeden – statt. In der Zwischenzeit hat es sich
zu einer Mammutveranstaltung ausgeweitet - das Turnier zählte im
letzten Jahr genau 101 Teilnehmer. Da bei einer Tischanzahl von maximal
25 die räumlichen Kapazitäten restlos ausgeschöpft sind, ist damit
dann wohl auch das Ende der Fahnenstange erreicht. Die einladende
Raumatmosphäre sowie die ausgezeichnete Organisation (als
ein Beispiel sei nur die erstklassige Verpflegung mit Speisen und Getränken
genannt) haben dafür gesorgt, dass sich der Teilnehmerkreis
Jahr für Jahr erweitert hat. Dieser permanente Zuwachs an Teilnehmern
hat aber auch dazu geführt, dass der manuelle Aufwand für die
anfallenden Tätigkeiten - von der Auslosung über die Erfassung der
Punktzahlen bis hin zur Auswertung der Spielergebnisse - immer größer
wurde. Das wiederum veranlasste meinen Schwager als Ausrichter
des Turniers nach möglichen Alternativen im PC-Bereich Ausschau zu
halten, um diese manuellen Tätigkeiten durch Automatismen zu ersetzen.
So kam es, dass er vor 10 Jahren auf mich zukam mit der Bitte,
mir hierüber mal Gedanken zu machen.
Als spontane Idee, per Programm eine Verbesserung zu erzielen, fielen
mir - wie konnte es auch anders sein - die Möglichkeiten von Microsoft
Excel ein. Das, was mir dabei zunächst vorschwebte, war allerdings
noch recht rudimentär. Der einzige Fortschritt, den Excel mir in meinen
ersten Überlegungen bot, schien darin zu bestehen,
‣ eine Liste mit allen Teilnehmern zu erstellen,
‣ diese Liste zu einer Tabelle zu erweitern, indem pro Durchgang eine
zusätzliche Spalte genutzt wurde, in der die Punktzahlen der
Teilnehmer pro Durchgang eingetragen wurden,
‣ um Excel danach diese Punktzahlen für jeden Teilnehmer addieren
zu lassen,
‣ und die Liste anschließend nach erreichter Gesamtpunktzahl zu
sortieren.
Nun hätte ich es natürlich auch dabei bewenden lassen können. Die
Umsetzung in Excel wäre in wenigen Minuten fertig gewesen. Der
größte Aufwand hätte wohl noch darin bestanden, die Teilnehmerliste
einzutippen. Das kam mir aber alles ein bisschen "zu mager" vor. Eine
deutliche Verbesserung gegenüber Bleistift und Papier hätte das zudem
auch nicht bedeutet.
Hinweis/Bemerkung 1
Die gute Stimmung der Teilnehmer
sorgt für eine hohe
Spendenbereitschaft. Das an
den Tischen eingespielte
Geld wandert - neben zusätzlichen
freiwilligen Beiträgen -
als Spende in einen gemeinsamen
Topf und wird einer
gemeinnützigen
humanitären
Organisation in Afrika
zugeführt.
3

Ich beschäftigte mich nun fortan intensiver mit den Möglichkeiten von
Excel und deren Programmiermöglichkeiten und kam letztendlich zu
dem Entschluss, es nicht bei dieser einfachen Liste bewenden zu lassen.
Ich kannte zwar weder die VBA-Umgebung für Excel (VBA = Visual
Basic for Applications), noch dessen Sprachkern Visual Basic,
hatte aber zumindest Programmiererfahrung in prozeduraler Programmiertechnik.
Außerdem bot mir Excel ja bekanntermaßen die
Möglichkeit, viele Tätigkeiten durch den Einsatz des Makrorekorders
zu automatisieren. Der dabei erzeugte Quellcode der Makros half mir
zudem beim Einstig in VBA. Zusätzliche Literatur sowie Recherchen
im Internet trugen zusätzlich dazu bei, mich recht schnell in der Umgebung
zurechtzufinden.
Fortan machte ich mich an die Arbeit; herausgekommen ist dabei ein
komplettes Turnierprogramm, 2002 erstmalig erstellt und 2010 verbessert
und um einige Funktionen erweitert. Das Programm wird mittlerweile
nicht nur einmal im Jahr bei dem besagten Turnier eingesetzt,
sondern auch immer dann, wenn im Freundes- und Bekanntenkreis
eine derartige Veranstaltung angesagt ist.
1.2 Was leistet das Programm
Kurz zusammengefasst bietet das Programm folgende Funktionen:
‣ Mischprogramm bei der Auslosung: die Teilnehmer bekommen per
Zufallsgenerator einen Tischplatz zugewiesen
‣ Anzahl der Durchgänge sowie Anzahl der Runden pro Durchgang
jeweils zwischen 1 und 10 frei wählbar
‣ die Gesamtanzahl der Tische kann durch eine vermehrte Anzahl an
5er-Tischen reduziert werden (für den Fall, dass die Räumlichkeiten
keine weiteren Tische mehr zulassen)
‣ Generierung neuer Excel-Tabellenblätter nach der Auslosung:
eine alphabetisch sortierte Liste aller Teilnehmer zum Ausdrucken,
aus der jeder für sich ablesen kann, in welchem Durchgang
er an welchem Tisch an welchem Platz spielt
pro Durchgang ein Tabellenblatt für die Eintragung der erreichten
Punktzahl pro Spieler; die Tische (mit ihren Teilnehmern)
werden nach Tisch-Nr sortiert aufgelistet
ein Ergebnis-Tabellenblatt mit einer Liste aller Teilnehmer, in
der nach Spielende (oder auch schon früher, um Zwischenstände
abzurufen) per Knopfdruck die Ergebnisse aus den einzelnen
Durchgängen übernommen werden
4

‣ die Spielzettel sind komplett vorformatiert und enthalten bereits die
Namen der Spieler. Für den Ausdruck stehen zwei Varianten zur
Auswahl:
einfache Version für den Privatgebrauch und
offizielle Spielzettel-Version vom Deutschen Doppelkopf Verband
für gehobene Ansprüche
1.3 Inhalt und Ziele der Ausarbeitung
Bei der vorliegenden Arbeit stehen die folgenden drei Aspekte im Vordergrund:
‣ Darstellung der Bestandteile des Turnierprogramms
‣ Kurzeinweisung in VBA
‣ Workshop-Charakter
Im Focus steht dabei natürlich die Absicht, die wesentlichen
Bestandteile des Programms vorzustellen, verbunden mit dem Ziel,
deren Implementierung in VBA herauszuarbeiten. Auf ein komplettes
Code-Listing wird allerdings verzichtet (ein Workshop soll auch ein
Workshop bleiben); bei Interesse kann es aber natürlich auf Anfrage
(email: hehrenbrink@yahoo.de) von mir bezogen werden.
Denjenigen Lesern, die bisher noch keinerlei Erfahrungen in VBA gesammelt
haben, aber Interesse daran haben, das Programm nachzuvollziehen,
soll der Einstieg dadurch erleichtert werden, dass in groben Zügen
die wesentlichen Sprachelemente und Programmiertechniken in
VBA vorgestellt werden, (Kapitel 2.1) und dass auch auf die Bedienung
der Entwicklungsumgebung (Kapitel 2.3) sowie auf den Einsatz von
Dialogtechniken (Kapitel 2.5.1) eingegangen wird.
Den Hauptteil dieser Abhandlung bildet zwangsläufig das Main-
Programm Sub Auslosung(): Struktur und wesentliche Bestandteile
werden thematisiert.
Abschließend werden noch einige interessante Zusatzfunktionen des
Programms vorgestellt.
Der Intention eines Workshops entsprechend, sind für diejenigen Leser,
die Interesse an dem Programm gefunden haben und sich mit der Materie
vertraut machen wollen, am Ende einiger Kapitel/Abschnitte einige
Übungen (ohne Lösungen) eingestreut.
5

1.4 Programm-Umgebung
Die erste Version des Programms wurde von mir in VBE Office XP erstellt.
Lauffähig war das Programm auch – ohne jegliche Anpassungen
– in den Nachfolge-Versionen Office Excel 2003 und 2007. Unter Office
Excel 2007 erfolgte im Jahr 2010 eine Ergänzung/Verbesserung. Auf
diese Office-Version beziehen sich auch alle in diesem Workshop verwendeten
VBA-/Excel-Elemente.
Als Betriebssystemumgebungen des Turnier-Programms wurden bisher
Windows XP und Microsoft Windows 7 Professional eingesetzt.
Hinweis 2
VBE (= Visual Basic Editor) ist
das Entwicklertool der VBA-
Programmierung. Mit der
Tastenkombination
gelangt man in
die Entwicklungsumgebung
(und wieder zurück).
1.5 Weitere (persönliche) Anmerkungen
Wenn im Folgenden von "den Spielern" oder "den Teilnehmern" die
Rede ist, so ist damit natürlich das weibliche Geschlecht implizit immer
mit eingeschlossen. Würde ich stattdessen jedesmal von "den SpielerInnen"
oder "den Spielern und Spielerinnen" bzw. von "den TeilnehmerInnen"
oder "den Teilnehmern und Teilnehmerinnen" sprechen, so
hätte darunter die Lesbarkeit des Dokumentes zu leiden. Eine Diskriminierung
des weiblichen Personenkreises bzgl. des Doppelkopfspiels
liegt mir absolut fern.
Zusätzlich sei noch angemerkt, dass alle Namen der in diesem Dokument
erwähnten Personen frei erfunden sind.
2 Das Programm
2.1 Grundsätzliches zur Programmierung in VBA
2.1.1 Variablendeklarationen
Eine Variablendeklaration beginnt mit der Anweisung Dim, gefolgt von
dem frei wählbaren Variablen-Namen. Danach gibt man mit dem
Schlüsselwort As an, welchen Datentyp die Variable enthalten soll.
Konstante Größen lassen sich noch einfacher deklarieren, da sie keinen
Datentyp besitzen. Statt mit der Anweisung Dim beginnen sie mit
Const.
6

Möchte man einen array anlegen, so geschieht das ebenfalls mit Dim,
gefolgt von dem Variablennamen und anschließender Klammerung ().
Damit lässt man sich aber die Dimensionierung und die Länge des
arrays noch offen.
Beispiele:
Dim Zahl1 As Integer 'Integer-Variable namens Zahl
Const Zahl2 = 10 'Speicherplatz Zahl2 mit festem Wert 10
Dim Zahl() As Integer 'Integer-array ohne Dimension und ohne Länge
Es gibt drei mögliche Gültigkeitsbereiche für eine Variable:
a) Wird die Variable nur innerhalb einer Prozedur benötigt, handelt es
sich um eine lokale Variable. Die Deklaration steht dann am Anfang
einer Prozedur.
Sub Test()
Dim MeineVariable As Long
gültig
Anweisung
...
Anweisung
End Sub
'MeineVariable ist nur innerhalb der Prozedur Test()
b) Wird die Variable in mehreren Prozeduren eines Moduls benötigt, so
muss sie als globale Variable am Anfang des Moduls deklariert werden
mit Dim oder Private als Anweisung. Unter dem Begriff "Modul"
muss man sich einfach einen Container vorstellen, der Quellcode
enthält – der Code muss ja schließlich irgendwo untergebracht sein. Je
nachdem, wofür so ein Modul genutzt wird, wird unterschieden z.B.
zwischen einem Modul für Userformen (siehe 2.5.1 Eigene Dialoge entwerfen
und programmieren) oder einem Modul für ein Tabellenblatt
(siehe 2.5 Der Kern des Programms: die Auslosung) oder einem Modul
für die Ereignissteuerung (siehe 2.4 Ereignisse in VBE) oder ...
Dim MeineVariable As Long 'MeineVariable ist auf Modulebene gültig
Private MeineVariable1 As Long 'ebenso MeineVariable1
Sub Test()
Anweisung
...
Anweisung
End Sub
c) Soll die Variable auch in anderen Modulen des Projektes Gültigkeit
haben, muss sie als öffentliche Variable mit Public deklariert werden.
Public MeineVariable As Long 'MeineVariable ist im ganzen Projekt gültig
Sub Test()
Anweisung
...
Anweisung
End Sub
7

2.1.2 Makros
Der einfachste Weg, sich einen ersten Einblick in die VBA-
Programmierung zu verschaffen, ist der, dass man sich die Makro-
Programmierung einmal näher anschaut.
Im folgenden Beispiel wird per Makro-Recorder (Aufruf über
"ENTWICKLERTOOLS/MAKRO AUFZEICHNEN") der Zellenbereich
"A1:C2" mit Inhalt gefüllt:
Abbildung 1
Makro MwSt
Die Schaltfläche Bearbeiten
öffnet die Entwicklungsumgebung
und man gelangt
direkt in den Quellcode des
Makros
Das aufgezeichnete Makro lässt sich nun nachträglich weiter bearbeiten.
Durch den Aufruf der Schaltfläche Bearbeiten erscheint allerdings
nicht mehr der Makro-Recorder, sondern man hat den VBA-Quellcode
in der Entwicklungsumgebung vor sich. Für obiges Beispiel wurden folgende
Zeilen generiert:
Sub MwSt()
Range("A1").Select
ActiveCell.FormulaR1C1 = "MwSt"
Range("B1").Select
ActiveCell.FormulaR1C1 = "Brutto"
Range("C1").Select
ActiveCell.FormulaR1C1 = "Netto"
Range("A2").Select
ActiveCell.FormulaR1C1 = "0.19"
Range("B2").Select
ActiveCell.FormulaR1C1 = "50"
Range("C2").Select
ActiveCell.FormulaR1C1 = "=RC[-1]*(1+RC[-2])"
Range("A1:C1").Select
'Name des Makros
'Netto-Berechnung in
Zelle C2
Listing 1
Makro MwSt
Die in grün gehaltenen Bemerkungen
sind Kommentare
8

2.1.3 Unterprogrammtechnik
Um den Programmcode in kleine unabhängige und überschaubare Einheiten
zu unterteilen, stehen in VBA zwei Varianten zur Verfügung –
Prozeduren und Funktionen.
Prozeduren beginnen, wie im vorherigen Beispiel eines Makros zu sehen,
immer mit Sub, gefolgt von dem Prozedurnamen, und enden immer
mit End Sub.
Sub Prozedurname [(Argumente)]
Anweisung
...
Anweisung
End Sub
Die (optionalen) Argumente können Referenzen (nicht der Wert selber
wird übergeben, sondern der Zeiger, also die Adresse im Arbeitsspeicher)
oder Werte sein. Zudem kann ihnen der Datentyp mitgegeben
werden.
Beispiel:
Sub TestProzedur (ByRef Argument1 As Integer, ByVal Argument2 As Long)
Zeiger = Argument1
Wert = Argument2
End Sub
Der Aufruf dieser Prozedur sieht dann entweder so aus:
TestProzedur Parameter1, Parameter2 oder so:
Call TestProzedur(Parameter1, Parameter2)
Prozeduren können Aktionen unterschiedlicher Art ausführen, sie können
aber keine Werte zurückgeben. Hierzu bedarf es einer Funktion.
Die Syntax einer Funktion ist ähnlich wie bei einer Sub: sie beginnen
mit Function und enden mit End Function:
[Public] [Private] [Static] Function Funktionsname [(Argumente)] [As
Typ]
Anweisung
...
Anweisung
End Function
2.1.4 Objekte, Eigenschaften und Methoden
An dieser Stelle möchte ich die Gelegenheit nutzen, herauszustellen,
warum VBA für viele Anwendungen eine gute Alternative zu den etab-
10

lierten Sprachen wie etwa C++ oder Java ist. Hierfür gibt es i.w. zwei
handfeste Gründe:
‣ Zum einen sind es die Makros, die dem Programmierer nicht nur
viel Arbeit abnehmen können, sondern die auch – wie bereits erwähnt
– die Möglichkeit bieten, sich der Skriptsprache VBA Schritt
für Schritt zu nähern.
‣ Der zweite Grund ist der, dass in vielen Anwendungen – wie z.B. in
diesem Programm – fast ausschließlich mit Tabellen gearbeitet
wird. Da bietet eine Tabellenverarbeitung wie Excel, die etwa die
200 wichtigsten Objekte mit ihren Eigenschaften und Methoden für
jedermann frei zugänglich macht, eine ideale Plattform für eigene
Entwicklungen. Ein Großteil der Arbeit, die bei der Software-
Entwicklung anfällt, nämlich die Planung der Objekte (Tabellenblätter,
Zellen etc.), ist bereits erledigt, bevor man überhaupt damit angefangen
hat, da sie bereits vorhanden sind und genutzt werden
können.
Nun aber zum Thema - Objekte, Eigenschaften und Methoden in VBA.
Was verbirgt sich eigentlich hinter diesen Begriffen und – noch wichtiger
- wie kann man diese Bausteine für sich nutzen? Für den in der Objektorientierung
erfahrenen Entwickler sind die Begrifflichkeiten natürlich
klar, dennoch profitiert auch der unerfahrene Programmierer
von den folgenden Ausführungen, da er praktisch gar keine Klassen
und Objekte selbst definieren muss, weil ja alle notwendigen Bauteile
bereits vorhanden sind.
2.1.4.1 Objekte und ihre Hierarchie
Da VBA eine - zumindest teilweise - objektorientierte Programmiersprache
(fehlende Implementierungsvererbung) ist, lassen sich natürlich
eigene Klassen definieren und somit eigene Objekte erstellen. In
den allerhäufigsten Fällen (so auch in diesem Programm) sind es jedoch
die MS-Office eigenen Objekte mit ihren Eigenschaften und Methoden,
die in der Anwendung zum Einsatz kommen. Sie sollen hier in Kurzform
dargestellt werden.
Zu den wichtigsten Objekten zählen:
APPLICATION Excel selbst / Excel – Fenster
WORKBOOK Die Excel – Arbeitsmappe
WORKSHEET Ein Tabellenblatt
RANGE
Zellenbereich , bestehend aus einer oder mehrerer
Zellen
11

Die Objekte stehen in hierarchischer Abhängigkeit zueinander. Objekte
höherer Stufe beinhalten Objekte untergeordneter Stufe(n). Für o.g.
Objekte gilt die Hierarchieordnung.
Application
Workbook
Worksheet
Range
Die gesamte Objekthierarchie ist natürlich wesentlich komplizierter und
umfangreicher. Für die Programmierung ist es wichtig zu wissen, dass
die Objekthierarchie nicht nur ein willkürliches Ordnungsschema ist.
Die Kenntnis der festgelegten Position eines Objektes in der Hierarchie
ist nötig, um das Objekt zu referenzieren – darauf zuzugreifen.
Beispiel: Worksheets(list).Range("A1").EntireColumn.ColumnWidth = 22
Der Objektkatalog enthält eine Übersicht aller Excel-Objekte, ihrer Eigenschaften
und Methoden. So rufen Sie den Objektkatalog auf:
1. Öffnen Sie den VBA-Editor über die Tastenkombination
.
2. Drücken Sie die Taste , um den Objektkatalog aufzurufen.
3. Stellen Sie in der oberen Auswahlliste den Eintrag Excel ein.
Hinweis 3
In dem Tabellenblatt Liste
(Const list = "Liste") wird für
die Spalte der Zelle "A1" die
Spaltenbreite auf den Wert
22 gesetzt.
Abbildung 2
Der Objektkatalog
12

2.1.4.2 Eigenschaften
Eigenschaften sind die Attribute, die das Objekt beschreiben. Sie legen
z.B. fest, wie das Objekt aussieht, welche Farbe oder welchen Wert es
hat, ob es sichtbar ist oder nicht, usw. Es gibt Eigenschaften, die lesbar
und veränderbar sind, z.B. Value (Wert) oder Name (Name), andere
lassen sich nur abfragen, aber nicht verändern.
Beispiel:
Sp_Name = Worksheets(1).Range("M" & (Zuf_Nr(d, n))).Value
2.1.4.3 Methoden
Zu den Objekten gehören neben Eigenschaften auch METHODEN. Über
Methoden lässt sich das Verhalten von Objekten steuern / verändern.
Eine Methode ist eine Aktion, die eine Operation auf einem Objekt ausführen
kann. Zu den am häufigsten benutzten Methoden gehören:
‣ OPEN öffnet eine Arbeitsmappe
‣ CLOSE schließt eine Arbeitsmappe (ein Workbook-Objekt)
oder Excel (ein Application-Objekt).
‣ CLEAR löscht einen Zellbereich oder ein Diagramm.
‣ ACTIVATE
‣ SELECT
aktiviert ein Objekt
wählt ein Objekt aus
Hinweis 4
Der Variablen Sp_Name wird
der Wert zugewiesen, der
sich in Spalte "M" in der Zeile
Zuf_Nr(d, n) befindet
Für den Einsteiger ist es oft problematisch zwischen Eigenschaften und
Methoden zu unterscheiden (insbesondere wenn Methoden die gleichen
Namen tragen wie beispielsweise Auflistungen). So sind beispielsweise
die beiden Anweisungen
Assistant.Visible = true
Assistant.Move 250,275
zumindest optisch sehr ähnlich. Es stellt sich die Frage - sind Visible
und Move Eigenschaften oder Methoden und wenn nicht, welches Element
von beiden ist eine Methode und welches eine Eigenschaft. Die
Antwort ist hier relativ einfach: Bei Zuweisungen von Eigenschaften
wird das Gleichheitszeichen benutzt, bei Methoden benutzt man (optionale)
Parameter ohne Gleichheitszeichen.
13

Füllen Sie den Tabellenbereich "A1:A10" mit beliebigen Zahlen. Markieren
Sie einige Zellen dieses Bereiches mit der Hintergrundfarbe "Rot".
Fügen Sie in der Entwicklungsumgebung ein neues Modul ein, indem
Sie im Projekt-Explorer mit der rechten Maustaste klicken und den
Kontextmenübefehl EINFÜGEN/MODUL wählen.
Übung 2
Benutzerdefinierte Funktion
schreiben
Schreiben Sie eine Funktion Function SummeRoteZellen(Zelle
As Range), die nur die Zellen mit roter Hintergrundfarbe addiert.
Hinweise:
1) Setzen Sie als erstes die Anweisung Application.Volatile.
Hierdurch wird bewirkt, dass die Funktion immer neu berechnet
wird, wenn in einer beliebigen Zelle des Tabellenblattes eine Berechnung
durchgeführt wird
2) Um jede Zelle eines Bereiches zu erreichen, verwenden Sie die
for-Schleife: For Each Zelle In Zelle.Cells
3) Addieren Sie nur dann, wenn die Zelle einen numerischen Wert
enthält: If IsNumeric(Zelle)
4) Abfrage der Hintergrundfarbe einer Zelle des Bereiches auf die
Farbe "Rot" mit If Zelle.Interior.ColorIndex = 3
5) Addition der Funktionswerte: SummeRoteZellen = Summe-
RoteZellen + Zelle.Value
6) Prüfen Sie die Funktion, indem Sie in Zelle "A11" die Formel eingeben
"=SummeRoteZellen(A1:A10)"
2.2 Die Gäste kommen
Nun wieder zurück zu unserem Doppelkopfturnierprogramm. Die Teilnehmer
melden sich größtenteils vor dem Turnier telefonisch oder per
Mail, so dass sie bereits vorab in einer Liste im Programm (in Spalte
"A") aufgenommen werden können (das gesamte Excel-Sheet besteht zu
diesem Zeitpunkt lediglich aus einem Tabellenblatt). Es genügt dann
am Turnierabend nur ein Klick, um die betreffende Person real am Turnier
teilnehmen zu lassen.
14

Abbildung 3
Die Teilnehmerliste in Spalte
"F"
Rechtsklick oder Doppelklick in
eine Zelle der Spalte "B" oder
"C" aktiviert das ereignisgesteuerte
Makro
Sub
Worksheet_BeforeRightClick
bzw.
Sub
Worksheet_BeforeRightClick (s.
2.4)
Hinweis 5
Die "Häkchen" in Spalte B und
C werden erzeugt mit dem
Zeichen "ü" (= Chr (252)) in der
Schriftart Wingdings (siehe
auch Listing 2)
Dieser Tabellenausschnitt macht deutlich, wie die Teilnehmerliste realisiert
wird. In Spalte "A" können bereits vor Turnierbeginn die Namen
der möglichen Teilnehmer, sofern bekannt, eingetragen werden. Es genügt
dann nur noch ein Doppelklick (oder Rechtsklick) in Spalte "B" (=
bezahlt) oder "C" (= anwesend), um die betreffende Person in die tatsächliche
Teilnehmerliste (Spalte "F") aufzunehmen. Die Teilnehmer
werden mit einer Spieler-Nummer (Spalte "E") versehen, welche aber
im weiteren Verlauf des Turniers seitens des Teilnehmers nicht benötigt
wird; die Spieler-Nr dient lediglich programminternen Zwecken (s. 2.4
Ereignisse in VBA).
Die programmtechnische Umsetzung dieses Vorgangs - die Erstellung
der Spielerliste in Spalte "F" - muss noch ein wenig warten (2.4 Ereignisse
in VBA).
Vielmehr soll für all diejenigen, die bisher noch keinerlei VBA-
Erfahrung besitzen, im Folgenden eine weitere kurze Einführung in
VBA und der Entwicklungsumgebung gegeben werden.
15

Der Projekt-Explorer: er enthält – hierarchisch gegliedert – alle Objekte,
die zum VBA-Projekt "DokoTurnier.xlsx" gehören.
Das Eigenschaftenfenster: in ihm werden alle Eigenschaften des ausgewählten
Steuerelements angezeigt - in obiger Abbildung die Eigenschaften
der Tabelle3. In der linken Spalte dieses Fensters steht der Name
der Eigenschaft und in der rechten Spalte der zugehörige aktuelle Wert.
Diese Werte können, wie wir bei den Steuerelementen von Formularen
noch sehen werden, den eigenen Bedürfnissen angepasst werden, und
zwar entweder durch das Überschreiben im Eigenschaftenfenster selbst
oder aber per Quellcode-Programmierung.
Das Code-Fenster: in diesem Fenster (meistens werden mehrere gleichzeitig
bearbeitet) befindet sich der Quelltext des Programms aus dem
betreffenden Modul. Wie bereits in obigem Beispiel gesehen, ist der
Makro-Recorder - insbesondere für den VBA-Neuling - eine sehr gute
Hilfe bei der Generierung des Listings. Ohne jegliche VB-Kenntnisse zu
besitzen, kann man sich so auf einfache und schnelle Art und Weise einen
ersten Überblick über die gängigen Befehle verschaffen.
Für darüber hinausgehende Anpassungen sind dann natürlich tiefergehende
VB/VBA-Kenntnisse notwendig. Die wichtigsten Elemente hatte
ich bereits in Kapitel 2.1 Grundsätzliches zur Programmierung in VBA
vorgestellt. Ich halte es allerdings für unverhältnismäßig, im Rahmen
dieses Workshops noch tiefer in diese Materie einzusteigen. Für formale
Elemente wie Datentypen, Variablen sowie sprachliche Konstrukte wie
Schleifen, Verzweigungen etc. verweise ich zum einen auf Online-
Recherchen im Internet sowie natürlich auf die in ausreichendem Maße
vorhandene Literatur zur Excel-VBA-Programmierung an. Nicht zuletzt
können auch die Listings hierzu einen guten Beitrag leisten.
2.4 Ereignisse in VBA
Nun aber wie versprochen zur Realisierung der Teilnehmerliste in VBA.
Benötigt wird zu diesem Zweck ein bstimmtes technisches Hilfsmittel,
und zwar die ereignisgesteuerte Eingabemöglichkeit, z.B. per Rechtsklick
(Sub Worksheet_BeforeRightClick) oder per Doppelklick (Sub
Worksheet_BeforeDoubleClick). Diese beiden Funktionen überwachen
die betreffenden Mausklicks und es lassen sich die gewünschten Aktionen
mit ihnen verbinden. Schauen wir uns beispielhaft einmal den
Worksheet_BeforeDoubleClick an (die Tastenkombination für die Entwicklungsumgebung
ist uns nun bereits geläufig: < F11>):
17

Private Sub Worksheet_BeforeDoubleClick(ByVal Target As Range, Cancel
As Boolean)
Cancel = True
Dim rng As Range
If Intersect(Target, Worksheets(1).Range("B:C")) Is Nothing Then
Exit Sub
If Target.Row = 1 Then Exit Sub
If Target.Column = 2 Then
If Target.Interior.ColorIndex = 4 Then
'Color 4 = Farbe Grün
Cells(Target.Offset(0, 2) + 1, 6) = "" 'Sp-Name löschen
Cells(Target.Offset(0, 2) + 1, 5) = "" 'Sp-Nr löschen
Target.Offset(0, 2).Value = ""
'Nr in Spalte D löschen
Target.Interior.ColorIndex = 0
'Farbe zurücksetzen
Target.Offset(0, 1).Interior.ColorIndex = 0
Target.Offset(0, 1).Value = ""
Target.Value = ""
Range("I8").Value = Range("I8").Value - 1 'Anzahl Spieler
Range("I9").Value = Range("I8").Value \ 4 'Anzahl Tische
Range("I10").Value = Range("I8").Value Mod 4 'Anzahl 5er-Tische
Else
'in Liste aufnehmen
If Target.Offset(0, 2) "" Then
Target.Interior.ColorIndex = 4
Target.Value = Chr(252)
Exit Sub
Else
If Target.Offset(0, -1).Value = "" Then
Exit Sub
End If
End If
For Each rng In Worksheets(1).Range("F:F").Cells
If IsEmpty(rng) Then
lz = rng.Row
rng = Target.Offset(0, -1).Value
Target.Offset(0, 2).Value = lz - 1
Cells(lz, 5).Value = lz - 1
Target.Value = Chr(252)
Target.Offset(0, 1).Value = Chr(252)
Target.Interior.ColorIndex = 4
Target.Offset(0, 1).Interior.ColorIndex = 4
Range("I8").Value = Range("I8").Value + 1
'erste freie Zelle in
Spalte "F"
'Anzahl Spieler
'Anzahl Tische
Range("I9").Value = Range("I8").Value \ 4
Range("I10").Value = Range("I8").Value Mod 4 'Anzahl
5er-Tische
End
End If
Next rng
End If
Listing 2
Sub
Worksheet_BeforeDouble
Click(ByVal Target As
Range, Cancel As
Boolean)
Abfrage einer angeklickten
Zelle in Spalte "B" auf Farbhintergrund:
falls grün (ColorIndex=4),
dann Teilnehmer aus Liste in
Spalte "F"
löschen, sonst
Spieler neu in Spalte "F"
aufnehmen
Zu diesem Listing bedarf es nun einiger Erläuterungen.
Mit der Methode Intersect wird sichergestellt, dass nur dann weitere
Aktionen stattfinden, wenn sich die aktuell markierte Zelle im Zielbereich
Range("B:C") befindet. Auch der Doppelklick in die 1. Zeile Target.Row
= 1 soll keine weitere Aktion nach sich ziehen.
Was passiert nun aber, wenn in Spalte "B" oder "C" eine Zelle angeklickt
wird? Der Einfachheit halber soll hier nur das Vorgehen für die Spalte
"B" (= bezahlt) erläutert werden: If Target.Column = 2 . Die Codierung
für Spalte "C" (= anwesend") kann als Übung (s. Übung 3) dienen.
18

Wird nun beispielsweise die Zelle "B88" rechtsgeklickt und ist die Zelle
"A88" leer, so ist wiederum nichts zu tun: If Target.Offset(0, -1).Value =
"" Then Exit Sub. Gibt es aber in Zelle "A88" einen Teilnehmereintrag,
so müssen zwei Fälle unterschieden werden: entweder die Zelle "B88"
ist bereits mit einem Häkchen markiert und mit grüner Hintergrundfarbe
versehen, d.h. der Teilnehmer ist bereits aufgenommen und soll
jetzt wieder gelöscht werden, oder die Zelle ist nicht markiert und der
Teilnehmer aus "A88" muss noch in die Teilnehmerliste, also in Spalte
"F" aufgenommen werden.
Fall A: Ein Teilnehmer wird neu aufgenommen, Beispiel "Tanja Evers"
durch Doppelklick in "B13"
Es wird zunächst nach der ersten freien Zelle in Spalte "F" Ausschau
gehalten For Each rng In Worksheets(1).Range("F:F").Cells If IsEmpty(rng)
und die entsprechende Zeilennummer in der Variablen lz (steht
für leerzelle) gespeichert lz = rng.Row. Der Spielername "Tanja Evers"
wird aus "A13" in der Variablen rng zwischengespeichert rng = Target.Offset(0,
-1).Value, und die - nur intern vorgehaltene - Spielernummer
in der Zelle "D13" (nicht sichtbar im Tabellenblatt, da für den Anwender
ohne Belang) gemerkt (Target.Offset(0, 2).Value = lz - 1), um
die Möglichkeit eines Löschvorgangs nicht zu verbauen. Anschließend
werden lediglich noch die Zellen "B13" und "C13" mit einem Häkchen
Target.Value = Chr(252) sowie der grünen Füllfarbe Target.Interior.ColorIndex
= 4 versehen und es werden einige weitere Zellen
("I8", "I9" und "I10" für die spätere Auslosung bereits mit Werten
gefüllt, und zwar enthalten
‣ "I8" die Anzahl der Spieler (bisherigen Wert um 1 erhöhen)
Range("I8").Value = Range("I8").Value + 1
‣ "I9" die Anzahl der benötigten Tische (= Anzahl der Spieler dividiert
durch 4 als Integer-Wert)
Range("I9").Value = Range("I8").Value \ 4
‣ "I10" die Anzahl der benötigten 5er Tische (als Restwert der Division
durch 4)
Range("I10").Value = Range("I8").Value Mod 4
Hinweis 6
Chr (252) entspricht dem
Zeichen "ü" und liefert in der
Schriftart Wingdings das
Häkchen
Fall B: Ein bereits aufgenommener Teilnehmer wird wieder aus der
Liste entfernt, Beispiel "Gerd Förster" (etwa weil man sich "verklickt"
hat)
In diesem Fall ist die Zelle "B18" grün markiert: If Target.Interior.ColorIndex
= 4. Der Spieler muss nun wieder aus der Liste
in Spalte "F" gelöscht werden.
19

Die Zeile, in der er in Spalte "F" eingetragen wurde, ist leicht wieder
auffindbar, da die Spieler-Nummer in "D13" zwischengespeichert wurde:
Offset(0, 2). Der Löschvorgang wird ausgelöst über die Anweisung
Cells(Target.Offset(0, 2) + 1, 6) = "", also das Löschen derjenigen Zelle,
dessen Zeile um den Wert 1 erhöht in "D13" steht und dessen Spalte
gleich 6 ist. Ebenso muss die in "C13" vorgenommene Markierung wieder
entfernt werden, und es muss die Anzahl der Spieler, die Anzahl der
Tische und die Anzahl der 5er-Tische korrigiert werden.
Vervollständigen Sie den Quellcode für den Doppelklick auf ein Zelle
in Spalte "C".
Übung 3
Ereignissteuerung
2.5 Der Kern des Programms: die Auslosung
Nachdem sich die Teilnehmer angemeldet haben und in die Spielerliste
in Spalte "F" aufgenommen wurden, erfolgt die
Auslosung, d.h. die Zuordnung der einzelnen
Spieler zu den Spieltischen. Hierfür steht im
Tabellenblatt Auslosung ein Button mit dem Text Auslosung starten
bereit (erstellen lässt er sich über die Menüleiste mit
ENTWICKLERTOOLS, EINFÜGEN aus der Gruppe
STEUERELEMENTE, Element BEFEHLSSCHALTFLÄCHE). Ein
Klick auf diesen Button startet das Main-Programm Sub Auslosung() im
Modul des Tabellenblattes Auslosung.
An dieser Stelle ist nun der Zeitpunkt gekommen, den Aufbau und die
wesentlichen Bestandteile des Auslosungsprogramms zunächst einmal
in groben Zügen vorzustellen, um anschließend in den Kapiteln 2.5.1 bis
2.5.3 auf die einzelnen Teile näher einzugehen.
Zu Beginn des Programms Sub Auslosung() sollen vom Anwender über
einen Dialog (s. Abbildung 5, Seite 22) die Startparameter "Anzahl der
Durchgänge" und "Anzahl der Runden pro Durchgang" festgelegt werden.
Anschließend besteht die wesentliche Aufgabe des Programms darin
‣ ein Tabellenblatt Liste zu erstellen, aus der hervorgeht, wer in welchem
Durchgang an welchem Tisch mit welcher Platz-Nr teilnimmt
(s. 2.5.2.1 Das Tabellenblatt "Liste")
‣ pro Durchgang ein Tabellenblatt für die Eingabe der erreichten
Punkte zu erstellen (s. 2.5.2.2 Pro Durchgang je ein Tabellenblatt)
20

‣ den Teilnehmern per Mischprogramm einen Platz an einem Tisch
zuzuweisen: Sub Tischzuweisung() (s. 2.5.3 Das Mischprogramm)
‣ ein Tabellenblatt Ergebnis mit einer sortierten Rangfolge der Teilnehmer
zu erzeugen: Sub ergebnis() (s. 2.5.2.3 Das Tabellenblatt "Ergebnis")
Diese vier Aspekte werden – wie erwähnt - ausführlich als Einzelthemen
in den genannten Abschnitten gesondert behandelt.
Um mit dem Main-Programm vertraut zu werden, werfen wir zunächst
einen Blick
a) auf die global definierten Variablen und
b) auf die Eingabemaske für die Startparameter
Zu a) Die global definierten Variablen und Konstanten stehen ganz am
Anfang des Moduls (Modul des Tabellenblattes Auslosung) und sind
für alle in diesem Modul eingesetzten Prozeduren verfügbar.
Const MaxAnzDg = 10
Const MaxAnzRd = 10
Const ZeilBeg = 3
Const SpBeg = 2
Const HGrFaSp = 6
Const HGrFaTi = 32
Const list = "Liste"
Const dg = "Durchgang"
Const erg = "Ergebnis"
Const wf4e = "Wert-Form4e"
Const wf4v = "Wert-Form4v"
Const wf5e = "Wert-Form5e"
Const wf5v = "Wert-Form5v"
Const AnzTiProBlock = 4
'maximale Anzahl Durchgänge
'maximale Anzahl Runden pro Durchgang
'in den Durchgangsblättern beginnen
die Tischüberschriften ab Zeile 3
'und Spalte B
'Hintergrundfarbe in SpielerZelle
(Durchgangs-Tabelle)
'Hintergrundfarbe in TischüberschriftZelle
(Durchgangs-Tabelle)
'Name des Tabellenblattes "Liste"
'Name für Durchgangs-Tabellenblätter
'Name des Tabellenblattes "Ergebnis"
'Name der Tabellenblätter für die
Standard-Spielzettel mit 4 Spielern
'Name der Tabellenblätter für die
DDV-Spielzettel mit 4 Spielern
'Name der Tabellenblätter für die
Standard-Spielzettel mit 5 Spielern
'Name der Tabellenblätter für die
DDV-Spielzettel mit 5 Spielern
'Anzahl Tische im 16-er Block
Listing 3
Globale Programm-Variable
des Auslosungsprogramms
Public Anz_Dg As Integer 'Anzahl Durchgänge
Public DurchBeg As Integer 'Bei welchem Durchgang soll begonnen
werden
Dim Zuf_Nr() As Integer '2-dimensionale Tabelle, enthält
Zufalls-Nr und Durchgangs-Nr
Dim Anz_Sp() As Integer 'eindimensionale Tabelle mit Anzahl
Spielern pro Durchgang
Dim Max_AnzSp As Variant 'maximale Anzahl an Spielern
(alle Durchgänge)
Dim Anz_5erTi() As Integer 'Anzahl der 5-er Tische pro Durchgang
Dim Max_Anz_5erTi() As Integer 'max. Anzahl an möglichen 5-er Tischen
pro Durchgang
Dim Anz_16Bl() As Integer 'Anzahl 16-er Blöcke
Dim Anz_Tische() As Integer 'Anzahl benötigter Tische
...
21

Leicht zu erkennen an der Variablen-Deklaration Const MaxAnzDg = 10
sowie Const MaxAnzRd = 10 ist die Festlegung auf maximal 10 Durchgänge
sowie 10 Runden pro Durchgang. Bei einem "normalen" Turnier
sind i.A. nicht mehr als 4 Durchgänge und 4 Runden pro Durchgang
üblich, so dass diese Werte allemal ausreichend sind.
Alle weiteren Deklarationen sind hinsichtlich ihrer Funktion anhand
der Kommentierung zu erkennen bzw. werden noch im weiteren Verlauf
im jeweiligen Zusammenhang erläutert.
Zu b) Nun wieder zurück zum Auslosungsprogramm. Wie bereits erwähnt,
erscheint nach dem Start für den Anwender eine Eingabemaske
mit der Abfrage nach der gewünschten Anzahl der Durchgänge und der
Anzahl der Runden pro Durchgang (s. Abbildung 5).
Hinweis 7
Im Listing 3 wird deutlich,
wie Kommentare im Queltext
innerhalb einer Zeile
gesetzt werden: durch einen
Apostroph
Abbildung 5
Die Userform Startparameter
Auslosung
Zusätzlich lässt sich, falls die Voreinstellung nicht übernommen werden
soll, die Anzahl der insgesamt benötigten Tische durch eine Erhöhung
der 5er-Tische verringern (s. 2.5.4 Zusatzfunktionen, Punkt (2)).
Aktiviert wird diese selbst erstellte Eingabemaske, eine sogenannte
UserForm, im Programm durch den Befehl StartAuslosung.Show.
StartAuslosung ist hierbei der Name dieser Dialogmaske. Dieser Name
findet sich wieder im Eigenschaftenfenster dieser UserForm in der Entwicklungsumgebung
(s. Abbildung 9).
Das ist ja nun soweit alles gut und schön, wirft aber viele neue Fragen
auf, wie z.B. "womit und wie lässt sich so eine Dialog-Box erstellen",
"wie lässt sie sich im Programm anzeigen/aktivieren", "wie kann man
22

sie programmieren", "wie werden Daten entgegengenommen und wieder
zurückgegeben", usw.
Diesem Thema wollen wir uns nun in 2.5.1 Schritt für Schritt nähern.
2.5.1 Eigene Dialoge entwerfen und programmieren
Zunächst einmal muss eine sogenannte Userform erzeugt und anschließend
den eigenen Bedürfnissen entsprechend angepasst werden. Hierfür
wechselt man wieder in die Entwicklungsumgebung (Tastenkombination
wie gehabt ).
Abbildung 6
Der Projekt-Explorer
Im Projekt-Explorer (wird standardmäßig in der Entwicklunksumgebung
oben links eingeblendet, siehe auch 2.3 Die Entwicklungsumgebung
von VBA sowie Abbildung 2) werden die Objekte und Dateien angezeigt,
die zum Projekt gehören. Man sieht, dass die Arbeitsmappe zurzeit nur
aus einer Tabelle (mit dem Namen Auslosung) und zwei Formularen
(DruckenSpielzettel und StartAuslosung) besteht. Der Doppelklick
auf ein Objekt öffnet die Möglichkeit zu ihrer Bearbeitung, beispielsweise
öffnet sich beim Tabellenmodul Tabelle1(Auslosung) der Editor mit
dem Quellcode des Hauptprogramms.
Hier in diesen Bereich des Projekt-Explorers klickt man mit der rechten
Maustaste; falls der Projekt-Explorer nicht erscheint, muss er noch über
den Menüpunkt ANSICHT aufgerufen werden (alternativ Tastenkombination
).
23

In dem darauffolgenden Kontextmenü wählt man den Befehl
EINFÜGEN/USERFORM (Abbildung 7).
Abbildung 7
UserForm einfügen
Nun bekommt man ein leeres Formular namens UserForm1 zur Verfügung
gestellt, zusammen mit einer Werkzeugsammlung, die die wichtigsten
Steuerelemente enthält (Abbildung 8). Über das Menü
EXTRAS/ZUSÄTZLICHE STEUERELEMENTE können bei Bedarf
weitere Elemente hinzugefügt werden. Damit steht dem Entwickler ein
großes Repertoire an Hilfsmitteln zur Verfügung, mit denen er sich seine
Dialogmaske den eigenen Vorstellungen entsprechend zusammenbasteln
kann.
Abbildung 8
UserForm mit
Werkzeugsammlung
Für unsere Userform StartAuslosung (die derzeit noch UserForm1
heißt), werden folgende Steuerelemente benötigt:
24

‣ sechs Bezeichnungsfelder (Label) für die Beschriftungen "Wieviel
Durchgänge insgesamt", "Tische gesamt", etc.
‣ fünf Textfelder (TextBox) für die Anzeige und Eingabe von Daten
wie z.B. Anzahl der Durchgänge
‣ für drei der fünf Textfelder (s. Abbildung 5) jeweils ein Drehfeld
(SpinButton) für das schrittweise Hochzählen der Werte in den
Textfeldern
‣ zwei Befehlsschaltflächen
(CommandButton) für die Ausführung
von Befehlen (z.B. )
Ein einzelnes Steuerelement kann, nachdem es in der Werkzeugsammlung
ausgewählt wurde, in der Userform platziert und den eigenen Bedürfnissen
angepasst werden. Die Anpassungen erfolgen zum einen
über die Mausoperationen, um etwa das Element zu vergrößern oder zu
verkleinern und an die richtige Stelle zu setzen, zum anderen aber auch
über das Editieren im zugehörigen Eigenschaften-Fenster (sichtbar unterhalb
des Projektexplorers per oder Menü ANSICHT/
EIGENSCHAFTENFENSTER).
Die beiden folgenden Abbildungen 9 und 10 zeigen in Ausschnitten zwei
Beispiele von Eigenschaften-Fenstern.
Beispiel 1: Das Eigenschaften-Fenster StartAuslosung
Abbildung 9
Eigenschaftenfenster
StartAuslosung
Hier handelt es sich um die Userform selbst. Der von VBA bei der Erstellung
der UserForm vorgeschlagene Name UserForm1 wurde inzwischen
in StartAuslosung geändert.
25

Beispiel 2: Das Eigenschaften-Fenster TextBox3
Abbildung 10
Eigenschaftenfenster
TextBox3
Diese TextBox enthält das Steuerelement zur Eingabe der Tischanzahl.
In diesem Fall wurde der von VBA vorgeschlagene Name Text-
Box3 beibehalten.
Kommen wir nun zur Makro-Programmierung dieser Steuerelemente,
also der Möglichkeit, sie per Quellcode zu bearbeiten/"steuern".
Um das Formular StartAuslosung zu initialisieren bzw. zu ändern,
führen wir zunächst einen Doppelklick innerhalb des Formulars (oder
Kontextmenü CODE ANZEIGEN) aus. Excel generiert automatisch
einen leeren Programmrahmen zum Editieren(Abbildung 11).
Abbildung 11
Programmrahmen einer User-
Form
Am oberen Rand sieht man
zwei Listenfelder. Im rechten
Listenfeld hat man neben dem
(ereignisgesteuerten) Click
u.a. auch die Möglichkeit einer
Initialisierung. Die Auswahl
dieses Elementes erzeugt
automatisch den Text
Private Sub userform_initialize()
Die Textboxen der in Abbildung 5 (Seite 22) dargestellten UserForm
(TextBox1 = Anzahl der Durchgänge, TextBox2 = Anzahl der Runden
und TextBox3 = Anzahl der Tische) sollten nun mit Standard-Werten
initialisiert werden. Während die Textboxen 1 und 2 bereits im jeweiligen
Eigenschaftenfenster mit den Anfangswerten 3 (= Anzahl Durch-
End Sub
26

gänge) und 4 (= Anzahl Runden) versehen werden können, ist dies bei
der Anzahl der Tische nicht möglich; die Anzahl der Tische ist abhängig
von der Anzahl der Teilnehmer und muss daher per Quellcode-
Programmierung berechnet werden:
Private Sub userform_initialize()
Dim AnzSp As Integer
Dim MaxAnzTi As Integer
...
If Worksheets(1).Range("M1").Value = "" Then
AnzSp = 0
Else
AnzSp = Range Worksheets(1).Range("I8").Value 'Anzahl Spieler
End If
Listing 4
Sub
userform_initialize()
Vorbelegung Anzahl der
Tische in TextBox3 mit dem
maximal möglichen Wert
MaxAnzTi = AnzSp \ 4
SpinButton3.Value = MaxAnzTi
TextBox3.Value = SpinButton3.Value
SpinButton1.Min = Worksheets(1).Range("I11").Value + 1
End Sub
Im nächsten Schritt geht es darum, ein Makro für die Änderung der
Tischanzahl zu schreiben. Da die Änderung über das nebenstehende
Drehfeld SpinButton3 erfolgen soll, ist für die TextBox3 selber keine
Codierung notwendig, wohl aber für das nebenstehende Drehfeld. Führen
wir zunächst einen Doppelklick auf die Schaltfläche SpinButton3 in
der Userform StartAuslosung aus, generiert Excel wiederum automatisch
einen leeren Programmrahmen, diesmal mit der Option Change:
Private Sub SpinButton3_Change()
End Sub
In diesem Rahmen werden nun die gewünschten Anpassungen bzw.
Berechnungen vorgenommen (s. auch Listing 16, Seite 43):
Private Sub SpinButton3_Change()
Dim Max_AnzSp As Integer
Dim AnzSp As Integer
Dim i As Integer
Dim MaxAnzTi As Integer
Dim MinAnzTi As Integer
Dim Anz5erTi() As Integer
Dim Anz4erTi() As Integer
Dim Anz_Tische() As Integer
'Max-Anzahl Spieler alle Durchgänge
'Anzahl Spieler in einem Durchgang
'Anzahl Tische Maximum
'Anzahl Tische Minimum
'Anzahl 5er-Tische
'Anzahl 4er-Tische
'Anzahl benötigter Tische insgesamt
Listing 5
Sub
SpinButton3_Change()
If Worksheets(1).Range("M1").Value = "" Then
AnzSp = 0
Else
AnzSp = Worksheets(1).Range("I8").Value 'Anzahl Spieler
End If
27

If AnzSp > Max_AnzSp Then
Max_AnzSp = AnzSp
Worksheets(1).Range("H3").Value = Max_AnzSp
End If
MaxAnzTi = AnzSp \ 4
If AnzSp Mod 5 = 0 Then
MinAnzTi = AnzSp \ 5
Else
MinAnzTi = AnzSp \ 5 + 1
End If
SpinButton3.Min = MinAnzTi
SpinButton3.Max = MaxAnzTi
TextBox3.Text = SpinButton3.Value
ReDim Preserve Anz5erTi(MinAnzTi To MaxAnzTi)
ReDim Preserve Anz4erTi(MinAnzTi To MaxAnzTi)
For i = MinAnzTi To MaxAnzTi
Anz4erTi(i) = 5 * i - AnzSp
Anz5erTi(i) = i - Anz4erTi(i)
Next i
TextBox4.Value = Anz5erTi(SpinButton3.Value)
TextBox5.Value = Anz4erTi(SpinButton3.Value)
End Sub
Durch die Variablen Max_AnzSp und AnzSp soll man sich nicht irritieren
lassen. Sie dienen im Programm nur zur Differenzierung nach Anzahl
der Spieler pro Durchgang, falls mal jemand nach einem Durchgang
aussteigt oder neu dazu kommt (s. 2.5.4 Zusatzfunktionen). Es soll
hier eigentlich nur deutlich werden, wie die Eigenschaften dieses Elementes
durch die Makro-Programmierung gesteuert werden können.
Zunächst einmal werden die maximale und minimale Anzahl an benötigten
Tischen berechnet (MaxAnzTi und MinAnzTi) und ihre Werte
den Variablen SpinButton3.Min und SpinButton3.Max zugewiesen.
Damit hat das Drehfeld SpinButton3 die Eigenschaften maximal möglicher
Wert und minimal möglicher Wert zugewiesen bekommen. Da
über die Anweisung TextBox3.Text = SpinButton3.Value die TextBox3
mit dem Drehfeld SpinButton3 verbunden ist, kann somit die Text-
Box3 jetzt nur noch Werte innerhalb dieses Intervalls annehmen. Aus
diesen Ausführungen wird auch deutlich, dass in diesem Fall eine
Quellcode-Programmierung unumgänglich ist, da Maximal- und Minimal-Wert
jeweils variabel sind. Ein Eintrag im Eigenschaften-Fenster
macht somit keinen Sinn, auch wenn diese Optionen im Eigenschaftenfenster
von SpinButton3 mit Max bzw. Min vorgesehen sind und somit
auch möglich wären.
Aus dem Quelltext geht ferner hervor, dass für jeden möglichen Wert
zwischen der minimalen und maximalen Anzahl an Tischen eine Aufteilung
in Anzahl 4er-Tische (= TextBox4) und Anzahl 5er-Tische (=
28

2.5.2 Die neuen Tabellenblätter
Zu Beginn des Programms existiert lediglich das Tabellenblatt mit dem
Namen Auslosung. Es besteht i.w. aus der Teilnehmerliste (s. Abbildung
3) und dem Button Auslosung starten. Mit dem Klick auf diesen
Button wird das Programm Sub Auslosung() ausgeführt. Es ist das
Haupt-Programm. Es sorgt zunächst einmal dafür, dass jeder Teilnehmer
für jeden einzelnen Durchgang einen zufällig ausgewählten Tisch-
Platz zugewiesen bekommt. Nachdem das erfolgt ist, können neue zusätzliche
Tabellenblätter generiert werden, und zwar
‣ ein Tabellenblatt Liste als Übersicht
‣ je ein Tabellenblatt pro Durchgang zur Eingabe der erreichten
Punktzahl pro Spieler
‣ ein Tabellenblatt Ergebnis, in dem die Punktzahlen eines jeden
Teilnehmers übersichtlich dargestellt werden
Ein neues Tabellenblatt wird in VBA mit der Funktion Worksheets.Add
erzeugt.
2.5.2.1 Das Tabellenblatt "Liste"
Dieses Tabellenblatt enthält eine übersichtliche Liste aller Teilnehmer,
aus der hervorgeht, welcher Spieler in welchem Durchgang an welchem
Tisch mit welcher Tisch-Nr spielt.
Mit der Anweisung Worksheets.Add
After:=Worksheets(Worksheets.Count) wird hinter dem letzten Tabellenblatt
ein neues angehängt. Es bekommt den Namen Liste. list ist
eine globale Konstante: Const list = "Liste".
Worksheets(1).Cells(2, 9).Value = Anz_Dg
Worksheets(1).Cells(1, 9).Value = Worksheets(1).Cells(11, 9).Value
Worksheets.Add After:=Worksheets(Worksheets.Count)
Worksheets(Worksheets.Count).Name = list 'Erstellung des Tabellenblattes
"Liste"
Worksheets(1).Range("M:M").Copy
Destination:=Worksheets(list).Range("A:A")
Worksheets(list).Range("A1").Insert
Worksheets(list).Range("A1").EntireColumn.ColumnWidth = 22
Dieses Tabellenblatt dient dazu, eine übersichtliche, alphabetisch sortierte
Liste zu erstellen, aus der für jeden Spieler hervorgeht, in welchem
Durchgang er an welchem Tisch spielt. Aus dieser Liste kann z.B.
die Teilnehmerin Marlies Bäumer erkennen, dass sie im ersten Durchgang
am Tisch 4 spielt mit der Tisch-Nr 2 (s. Abbildung 13).
Listing 7
Tabellenblatt Liste hinzufügen
Hinweis 10
Die Spielerliste wurde in der
Zwischenzeit im Tabellenblatt
Auslosung
(=Worksheets(1) von Spalte
"F" nach Spalte "M" kopiert.
32

Durch einen Klick auf den Button Liste drucken kann die Liste (evtl.
mehrfach) ausgedruckt werden und als Aushang (an evtl. verschiedenen
Örtlichkeiten) angebracht werden.
Abbildung 13
Tabellenblatt Liste
bereits vorformatiert und
nach Namen sortiert
2.5.2.2 Pro Durchgang je ein Tabellenblatt
Im Anschluss an das Listentabellenblatt folgt pro Durchgang je ein weiteres
Tabellenblatt für die Eingabe der erreichten Punkte jedes einzelnen
Spielers.
For d = DurchBeg To Anz_Dg
'Erstellung der
Durchgangstabellenblätter
Worksheets.Add After:=Worksheets(Worksheets.Count)
Worksheets(d + 2).Name = d & ". " & dg 'Name des Durchgangs-
Tabellenblattes: const dg = Durchgang
Sheets(d + 2).Range("A1").EntireColumn.ColumnWidth = 5 'es folgen
weitere Formatierungen
Sheets(d + 2).Range("B1").EntireColumn.ColumnWidth = 22
...
...
Next d
Listing 8
Je ein Tabellenblatt pro
Durchgang hinzufügen
Ein komplett durchformatiertes Tabellenblatt hat dann folgendes Aussehen
(Abbildung 14):
Abbildung 14
Tabellenblatt 1. Durchgang
33

Aus der Abbildung lässt sich schon mal grob erkennen, was bei der Codierung
alles zu beachten ist:
‣ Spaltenbreiten festlegen
‣ Überschriften berücksichtigen
‣ Unterscheidung zwischen 5er- und 4er-Tischen
‣ Werden alle Tische nebeneinander auf dem Bildschirm platziert,
wird die spätere Eingabe der Punkte umständlich; übersichtlicher
wird es, wenn jeweils 4 Tische zu einem Block zusammengefasst
werden, und die Blöcke jeweils untereinander zu stehen
‣ Neben den Formatierungen der einzelnen Zellen erfolgt die Zuweisung
der Teilnehmer zu den einzelnen Tischen. Auf die Implementierung
dieses Vorganges, dem Mischvorgang, wird im
Abschnitt "2.5.3 Wer kommt in welchem Durchgang an welchem
Platz?" näher eingegangen.
‣ Die Zellen mit dem Wert 0 enthalten als Formel die Summe aller
Punkte pro Tisch
Worksheets(d + 2).Cells(zeile, spalte + 1).FormulaR1C1 =
"=SUM(R[-5]C:R[-1]C)"
Sie muss in jedem Falle als Ergebnis den Wert 0 ergeben (sofern
an den Tischen die Punkte mit Plus/Minus notiert werden). Der
Nutzen dieser Summenformel liegt darin, dass direkt bei Eingabe
der Punktzahl ersichtlich wird, ob an dem betreffenden Tisch
korrekt gezählt wurde.
Hinweis 11
Anzahl der Tische pro Block
s. Listing 3 (Glob. Variable)
Const AnzTiProBlock=4
'Anzahl Tische im 16-er Block
Listing 9
Summenformel pro Tisch
2.5.2.3 Das Tabellenblatt "Ergebnis"
Nachdem der Anwender die Punktzahlen der Spieler in die Durchgangs-
Tabellenblätter eingetragen hat, möchte er sich natürlich die Gesamtergebnisse
in einer Übersicht anschauen können. Hierzu dient das Tabellenblatt
Ergebnis, welches als letztes vom Haupt-Programm Sub Auslosung
erzeugt wird (s. Abbildung 15).
Worksheets.Add After:=Worksheets(Worksheets.Count)
Worksheets(Worksheets.Count).Name = erg
'Tabellenblatt "Ergebnis"
ganz am Ende
Worksheets(erg).Range("A1").EntireColumn.ColumnWidth = 4.43
Worksheets(1).Range("M:M").Copy
Destination:=Worksheets(erg).Range("B:B")
...
Listing 10
Tabellenblatt Ergebnis hinzufügen
34

Abbildung 15
Tabellenblatt Ergebnis
Die Formatierung der Zellen hält sich hier in Grenzen. Es werden i.w.
lediglich die Teilnehmer nach Spalte "B" kopiert und es wird ein Button
Punkte aus allen Durchgängen generiert. Hinter diesem Button verbirgt
sich das Unterprogramm Sub Ergebnis. Dieser Programmteil sorgt
dafür, dass die Punktzahlen eines jeden Spielers aus den einzelnen
Durchgängen in die Ergebnisliste übernommen werden. Die Spalte "B"
in dem Ergebnis-Tabellenblatt mit den Spielernamen wird Zeile für Zeile
abgearbeitet, wobei für jeden Durchgang nach dem entsprechenden
Namen in der Spalte "K" der Durchgangstabelle (s. auch "2.5.3 Wer
kommt in welchem Durchgang an welchem Platz?") gesucht wird; wurde
er gefunden, wird die betreffende Punktzahl für den Spieler in die Ergebnisliste
übernommen.
Hinweis 12
Spalte "A" ist reserviert für
die Rangfolge (s. Abbildung
16, Seite 36)
Außerdem werden noch zwei weitere Buttons generiert:
ErgSortRangButtonErstellen
ErgDruckButtonErstellen
'Ergebnisliste nach Punktzahl sortieren
'Ergebnisliste ausdrucken
Die sich hinter ihnen verbergenden Makros sind selbsterklärend und
recht einfach zu implemetieren.
Der Quellcode der Ergebnis-Prozedur sieht nun wie folgt aus:
Sub ergebnis()
ErgSortNameButtonErstellen
ErgSortRangButtonErstellen
ErgDruckButtonErstellen
Listing 11
Quellcode Sub Ergebnis()
Anz_Dg = Worksheets(1).Range("I6")
Max_AnzSp = Worksheets(1).Range("H3").Value
Sheets(list).Range("A:A").Copy Destination:=Sheets(erg).Range("B:B")
For n = 1 To Anz_Dg + 3
'und noch ein bisschen die
Tabelle formatieren
Worksheets(erg).Cells(1, n).Interior.ColorIndex = HGrFaSp
Worksheets(erg).Cells(1, n).Font.Bold = True
35

For m = 1 To Worksheets(erg).Range("B" &
Rows.Count).End(xlUp).Row
Worksheets(erg).Cells(m, n).Borders.LineStyle = xlContinuous
Next m
Next n
Worksheets(erg).Cells(1, 2).Value = "Name Vorname"
With Worksheets(erg)
Set bereich = .Range(.Cells(2, 3), .Cells(Max_AnzSp + 1, Anz_Dg
+ 2))
bereich.Value = ""
End With
Sheets(erg).Range("A2:A" & Max_AnzSp + 1).Value = ""
Dim Mat As Variant
For d = 1 To Anz_Dg
For n = 2 To Max_AnzSp + 1
Mat = Application.Match(Sheets(erg).Range("B" & n), Sheets(d &
". " & dg).Range("K:K"), 0)
If Not IsError(Mat) Then
Sheets(erg).Cells(n, d + 2).Value = Sheets(d & ". " &
dg).Range("L" & Mat).Value
End If
Next n
Next d
Hinweis 13
Übernahme der Punktzahl
aus den Durchgangs-
Tabellenblättern
Die Ergebnis-Tabelle könnte nach der Übernahme der Punktzahl und
anschließender Sortierung etwa folgendes Aussehen haben:
Abbildung 16
Tabellenblatt Ergebnis
komplett durch formatiert
2.5.3 Das Mischprogramm: wer kommt in welchem Durchgang an welchem
Tisch an welchem Platz?
Machen wir nun wieder einen Sprung zurück zum Haupt-Programm
Sub Auslosung() und kommen zum eigentlichen Kern.
Nachdem der Anwender im Start-Dialog StartAuslosung (s. Abbildung
5) seine Eingaben gemacht hat, steht nun für das Turnier fest, wie viel
Durchgänge gespielt werden, wie viel Runden pro Durchgang gespielt
werden und wie viel Personen auf wie viel 4er-Tische und 5er-Tische
verteilt werden müssen. Die eigentliche Auslosung kann nun beginnen.
36

Im Mischprogramm Sub Tischzuweiung bekommt jeder einzelne Teilnehmer
für jeden einzelnen Durchgang per Zufallsgenerator einen Platz
an einem Tisch zugewiesen.
Sub Tischzuweisung()
ReDim Zuf_Nr(1 To Anz_Dg, 1 To Anz_Sp(d))
Dim q As Integer, z As Integer, tmp As Integer
For q = 1 To Anz_Sp(d)
Zuf_Nr(d, q) = q
Next
For q = Anz_Sp(d) To 1 Step -1
Randomize
z = Int(Rnd * q) + 1
'Vorbelegung der Zuf_Nr-Tabelle
mit 1, 2, 3,...,q
'neuer Startwert für Rnd-Funktion
'z = Zufallszahl zwischen 1 und q
tmp = Zuf_Nr(d, z) 'tausche Zuf_Nr(d, z)
Zuf_Nr(d, z) = Zuf_Nr(d, q) 'mit
Zuf_Nr(d, q) = tmp 'Zuf_Nr(d, q)
Next
...
Listing 12
Quellcode Sub Tischzuweisung
Mit der ReDim-Anweisung wird der bereits deklarierte array Zuf_Nr()
zum einen als 2-dimensionale Tabelle deklariert und zum zweiten wird
die array-Länge definiert ( Länge der 1.Dimension = Anz_Dg = Anzahl
der Durchgänge, Länge der 2.Dimension = Anz_Sp(d)= Anzahl Spieler
in Durchgang d).
Der Mischalgorithmus bringt eine Zahlenfolge von 1 bis Anz_Sp(d) in
eine zufällige Anordnung. Dies kann man sich wie folgt vorstellen: man
hat einen Kartenstapel vor sich mit Anz_Sp(d) (=Anzahl Spieler pro
Durchgang) Karten. Nun wird die unterste Karte mit einer zufälligen
anderen über ihr liegenden Karte getauscht, dann die zweit-unterste,
danach die dritt-unterste usw.
Anschließend hat man also pro Durchgang eine Zahlenfolge von 1 bis
Anz_Sp(d) generiert, die per Zufallsgenerator in eine zufällig angeordnete
Reihenfolge gebracht wurde. Jetzt kann man daran gehen, diese
Liste sukzessive von vorne bis hinten abzuarbeiten und dabei die Teilnehmer
(sie sind in der Zwischenzeit nach Spalte "M" kopiert worden)
in dieser zufällig ausgewählten Reihenfolge auf die einzelnen Tische zu
verteilen:
Sp_Name = Worksheets(1).Range("M" & (Zuf_Nr(d, n))).Value (s.
Quellcode in der Unterprozedur Sub ZelleMitNameFuellen() in Listing
13)
In dieser Reihenfolge werden nun die Spieler auf die einzelnen Tische
verteilt, zuerst die 5er-Tische, danach die 4er-Tische.
37

Optisch aufbereitet sollen die Durchgangs-Tabellenblätter das in der
Abbildung 14 (Seite 33) dargestellte Aussehen haben. Vier Tische, nebeneinander
dargestellt – jeder Tisch besteht aus zwei Spalten, nämlich
Name und Punktzahl – bilden dabei jeweils einen Block. Die Blöcke
wiederum werden untereinander platziert, wobei zwischen zwei Blöcken
jeweils zwei Zeilen frei gelassen werden (aus der Abbildung 14 nicht ersichtlich,
da in unserem Beispiel nur ein Block benötigt wurde).
Die Implementierung erfolgt naturgemäß über mehrere Schleifen:
‣ ganz außen die Schleife der Blöcke For i16b = 1 To Anz_16Bl(d)
‣ innerhalb eines Blockes 4 Tische For itb = 1 To AnzTiProBlock
(beachte globale Konstante Const AnzTiProBlock = 4)
‣ innerhalb eines Tisches 7 Zeilen For j = 1 To 7 'bei den
4er-Tischen 6 Zeilen
Es folgt nun der komplette Quellcode für die 5er-Tische in der Prozedur
Sub Tischzuweisung() (= Fortsetzug von Listing 12):
n = 1
'Zähler für Spieler
it = 1
'Laufvariable für Tische
i5t = 1
'Laufvariable für 5er-Tische
(für 4er-Tische nicht erforderlich, da es nur diese beiden Möglichkeiten gibt)
For i16b = 1 To Anz_16Bl(d)
'Abarbeitung blockweise: mehrere Tische
pro Block (Voreinstellung = 4)
For itb = 1 To AnzTiProBlock
'weitere Abarbeitung tischweise
(AnzTiProBlock = 4)
spalte = SpBeg + 2 * (itb - 1) 'Festlegung der Spalte pro Tisch
If it

Case 2 To 6
ZelleMitNameFuellen
'Zeile 2 bis 6 = Befüllung mit Namen
'Eintrag des Teilnehmers in die
entsprechende Zelle
Case 7 '7.Zeile = Summ-formel für Zeilen 2 bis 6
Worksheets(d + 2).Cells(zeile, spalte + 1).FormulaR1C1 =
"=SUM(R[-5]C:R[-1]C)"
Worksheets(d + 2).Cells(zeile, spalte +
1).FormatConditions.Delete
Worksheets(d + 2).Cells(zeile, spalte +
1).FormatConditions.Add _
Type:=xlCellValue, Operator:=xlNotEqual, Formula1:="0"
With Worksheets(d + 2).Cells(zeile, spalte +
1).FormatConditions(1).Font
.Bold = True
.Italic = False
.ColorIndex = 3
End With
Worksheets(d + 2).Cells(zeile, spalte +
1).FormatConditions(1).Interior.ColorIndex = 5
Worksheets(d + 2).Cells(zeile, spalte +
1).HorizontalAlignment = xlCenter
End Select
Next j
i5t = i5t + 1 'nach Abarbeitung 5er-Tisch Zähler um 1
erhöhen
Else ... 'Abarbeitung der 4er-Tische nach dem
gleichen Schema
Sub ZelleMitNameFuellen()
Dim Sp_Name As String
Dim MatchZeile As Variant
Sp_Name = Worksheets(1).Range("M" & (Zuf_Nr(d, n))).Value 'Zeile aus
Spalte "M" entspricht Zufallszahl
Worksheets(d + 2).Cells(zeile, spalte) = Sp_Name
'Eintragung
des Spielers in der Durchgangs-Tabelle
Worksheets(d + 2).Cells(zeile, spalte).Locked = True 'entsprechende
Zelle sperren
Worksheets(d + 2).Cells(zeile, spalte).Borders.LineStyle =
xlContinuous
Worksheets(d + 2).Cells(zeile, spalte).HorizontalAlignment =
xlCenter
Worksheets(d + 2).Cells(zeile, spalte).Interior.ColorIndex = HGrFaSp
Worksheets(d + 2).Cells(zeile, spalte + 1).Borders.LineStyle =
xlContinuous
Worksheets(d + 2).Cells(zeile, spalte + 1).HorizontalAlignment =
xlCenter
Worksheets(d + 2).Cells(zeile, spalte + 1).Interior.ColorIndex =
HGrFaSp
Worksheets(d + 2).Cells(n, 11).Value = Sp_Name 'zusätzlich
den Namen in Spalte "K" der Durchgangstabelle eintragen
Worksheets(d + 2).Cells(n, 11).Locked = True
'und die
betreffende Zelle sperren
Worksheets(d + 2).Cells(n, 12).Formula = "=R" & zeile & "C" & spalte
+ 1 & "" 'außerdem die Punktzahl des Spielers automatisch übernehmen lassen
Worksheets(d + 2).Cells(n, 12).Locked = True 'und auch diese Zelle
(gleiche Zeile, aber Spalte "L"), sperren lassen
MatchZeile = Application.Match(Sp_Name, Sheets(list).Range("A:A"), 0)
'Spielernamen in Tabelle "Liste", Spalte "A" suchen
If IsError(MatchZeile) Then 'falls noch nicht vorhanden
lz = Sheets(list).Range("A" & Rows.Count).End(xlUp).Row + 1
'neue Zeile "aufmachen"
39

Sheets(list).Range("A" & lz).Value = Sp_Name 'und in dieser den Namen
eintragen
Worksheets(list).Cells(lz, d + 1).Value = it & "(" & j - 1 & ")"
'mit Eintrag der Tisch- und Platz-Nr in der betreffenden Durchgangsspalte
Else 'falls schon vorhanden
Worksheets(list).Cells(MatchZeile, d + 1).Value = it & "(" & j - 1
& ")"
'Eintrag der Tisch- und Platz-Nr in der betreffenden Durchgangsspalte
End If
n = n + 1
'Nach Eintragung in Durchgangs-Tabelle
Spierzähler um 1 erhöhen
End Sub
Für jeden Tisch wird zunächst einmal eine Überschrift erzeugt (Case 1),
dann in der Unterprozedur ZelleMitNameFuellen() die Spielernamen
eingetragen (Case 2 To 6) und zum Schluss (Case 7) noch eine Summenformel
notiert, in der die Summe der erreichten Punktzahl pro
Tisch berechnet wird (s. auch Listing 9). Sie dient lediglich als Kontrolle,
da bekanntermaßen bei einer Plus-Minus-Wertung die Gesamtsumme
immer Null sein muss.
Sukzessive holt sich die Unterprozedur ZelleMitNameFuellen() aus dem
1.Tabellenblatt (=Tabellenblatt mit dem Namen Auslosung) eine zuvor
zufällig ausgewählte Zelle der Spalte "M"
Sp_Name = Worksheets(1).Range("M" & (Zuf_Nr(d, n))).Value
und überträgt dessen Inhalt – den Spielernamen – in die dafür vorgesehene
Zelle der Durchgangstabelle:
Worksheets(d + 2).Cells(zeile, spalte) = Sp_Name
Der gleiche Spieler(name) wird zusätzlich noch in Spalte "K" eingetragen,
Worksheets(d + 2).Cells(n, 11).Value = Sp_Name
und mit ihm noch in der Zelle rechts daneben, also in Spalte "L" der
gleichen Zeile eine Formel zur Übernahme der Punkte; somit werden
alle Änderungen in der Punktezahl-Zelle des Spielers mit übernommen:
Worksheets(d + 2).Cells(n, 12).Formula = "=R" & zeile & "C" & spalte +
1 & ""
Die beiden Spalten "K" und "L" spielen später bei Übernahme der
Punktzahl eines Spielers in das Tabellenblatt Ergebnis noch eine wichtige
Rolle.
Hinweis 14
Die Spielerliste wurde bereits
zu Beginn des Main-Programms
Sub Auslosung von
Spalte "F" nach Spalte "M"
kopiert.
Hinweis 15
s. Listing 11 bzw. Hinweis
13, Seite 36
Im weiteren Verlauf wird in dem Tabellenblatt Liste nach dem betreffenden
Spielernamen gesucht:
MatchZeile = Application.Match(Sp_Name, Sheets(list).Range("A:A"),
0)
40

Wurde er nicht gefunden, wird er neu in die Liste mit aufgenommen.
Dies erscheint zunächst einmal umständlich programmiert; es hat lediglich
damit zu tun, dass in diesem Programm die Möglichkeit berücksichtigt
wird, dass in einem Durchgang Spieler neu hinzukommen oder
- aus welchen Gründen auch immer - nicht weiter am Turnier teilnehmen
(s. auch das folgende Kapitel 2.5.4 Zusatzfunktionen, Punkt (1)).
2.5.4 Zusatzfunktionen
Die Schwerpunkte des Programms wurden in allen wichtigen Punkten
vorgestellt. Das Rüstzeug für die Implementierung in VBA steht nunmehr
bereit.
Das komplette Programm bietet allerdings noch einige Sonderfunktionen,
die im Folgenden vorgestellt werden sollen.
(1) Teilnehmer können nach einem gespielten Durchgang ausfallen
oder neu hinzukommen.
Abbildung 17
Die Zellen I6 bis I11 im Tabellenblatt
"Auslosung"
Die Zellen I6 und I7 werden
nach Eingabe der Startparameter
gefüllt, die Zellen I8 bis
I10 bereits vor Beginn des
Auslosungsprogramms (s. 2.4
Ereignisse in VBE)
In diesem Fall bietet das Programm die Möglichkeit, ab einem bestimmten,
selbst gewählten Zeitpunkt einen oder mehrere noch
nicht gespielte Durchgänge neu zu mischen. Hierzu dient im Tabellenblatt
Auslosung die Zelle "I11" (s. Abbildung 17), in dem die Anzahl
der bereits gespielten Durchgänge manuell hochgesetzt werden
kann. Wenn dann erneut die Schaltfläche Auslosung starten gedrückt
wird, werden nur noch die nicht gespielten Durchgänge neu
gemischt.
Zu diesem Zweck wird im Programm eine Variable DurchBeg deklariert,
die aus der Zelle "I11" eingelesen und um 1 erhöht wird:
DurchBeg = Worksheets(1).Range("I11") + 1
41

Außerdem werden bei Spielbeginn (DurchBeg = 1) alle Tabellenblätter
entfernt, jedoch bei einer erneuten Auslosung ab dem zweiten
Durchgang nur die noch nicht benutzten Durchgangstabellenblätter.
Die Tabellenblätter Liste und Ergebnis werden ohnehin in jedem
Fall neu generiert.
Public DurchBeg As Integer 'bei welchem Durchgang soll
begonnen werden
...
DurchBeg = Worksheets(1).Range("I11") + 1
...
If DurchBeg = 1 Then
'bei Spielbeginn alle Tabellenblätter löschen bis auf das
"Auslosung"s-Tabellenblatt
For d = 1 To (ActiveWorkbook.Sheets.Count - 1)
Sheets(2).Delete
Next
End If
...
If DurchBeg > 1 Then
On Error Resume Next
For d = DurchBeg To MaxAnzDg
Sheets(d & ". " & dg).Delete
Next
End If
...
'falls erneute Auslosung (ab
Durchgang 2),
'die Durchgangstabellenblätter
löschen,
'die anschließend per Auslosung
'neu erstellt werden
Listing 14
Nach einem bereits gespielten
Durchgang soll neu gemischt
werden
(2) Die Gesamtanzahl der Tische lässt sich dadurch reduzieren, dass
die Anzahl der 5er-Tische erhöht wird auf das maximal Mögliche
Die Möglichkeit hierzu wurde bereits bei der Erläuterung der Dialogbox
für die Startparameter der Auslosung im Kapitel 2.5 Der
Kern des Programms: die Auslosung erwähnt.
Die Zellen "I9" = Anzahl 4er-Tische und "I10" = Anzahl 5er-Tische
(s. Abbildung 17) werden direkt bereits bei der (ereignisgesteuerten)
Aufnahme eines Spielers in die Teilnehmerliste (s. Kap. "2.4 Ereignisse
in VBE") berechnet. Da es sich um ganzzahlig definierte Zellen
handelt, ist die Berechnung auf recht einfache Weise zu bewerkstelligen:
Hinweis 16
Im Kapitel "2.4 Ereignisse
in VBE" wurden bereits die
in Abbildung 17 zu sehenden
Zellen "I8", "I9" und "I10" im
Tabellenblatt "Auslosung"
vorgestellt.
Private Sub Worksheet_BeforeDoubleClick(ByVal Target As Range, Cancel
As Boolean)
...
Range("I9").Value = Range("I8").Value \ 4
'I8 = Anzahl der
Teilnehmer
Range("I10").Value = Range("I8").Value Mod 4 'Rest bei Division
durch 4
Listing 15
Berechnung der Werte für
Zellen "I9" und "I10"
42

Somit sind die beiden Zellen "I9" und "I10" mit Inhalt gefüllt, bevor
das Hauptprogramm Sub Auslosung startet. Die Sub Auslosung
kann nun diese Zellen einlesen und die entsprechenden Variablen
mit dessen Inhalt initialisieren, z.B.:
Anz_5erTi(d) = Worksheets(1).Cells(10, 9).Value
Für den Anwender besteht nun über die bereits in Kapitel 2.5 (siehe
auch Abbildung 5, Seite 22) erwähnte Dialog-Box Startparameter
Auslosung die Möglichkeit, eine Änderung vorzunehmen und zwar
in der Textbox TextBox3. Dies geschieht – wir erinnern uns – über
das Drehfeld SpinButton3. Die Prozedur zum Ändern lautet Private
Sub SpinButton3_Change(). Sie enthält die Berechnung der 4erund
5er-Tische:
Hinweis 17
Bzgl. TextBox3 und Spin-
Button3 vgl. die Ausführungen
Seite 26/27
Private Sub SpinButton3_Change()
...
MaxAnzTi = AnzSp \ 4
If AnzSp Mod 5 = 0 Then
MinAnzTi = AnzSp \ 5
Else
MinAnzTi = AnzSp \ 5 + 1
End If
Listing 16
Quellcode zur Änderung der
Tischanzahl (s. auch Listing
5)
SpinButton3.Min = MinAnzTi
SpinButton3.Max = MaxAnzTi
TextBox3.Text = SpinButton3.Value
ReDim Preserve Anz5erTi(MinAnzTi To MaxAnzTi)
ReDim Preserve Anz4erTi(MinAnzTi To MaxAnzTi)
For i = MinAnzTi To MaxAnzTi
Anz4erTi(i) = 5 * i - AnzSp
Anz5erTi(i) = i - Anz4erTi(i)
Next i
TextBox4.Value = Anz5erTi(SpinButton3.Value)
TextBox5.Value = Anz4erTi(SpinButton3.Value)
Hier werden zunächst die minimale und maximale Anzahl der Tische
festgelegt (berechnet) und in SpinButton3.Min sowie SpinButton3.Max
als Extremwerte eingetragen, damit der Anwender diese
Grenzen nicht unter-/überschreiten kann. Innerhalb dieses Intervalls
werden in einer Mini-Tabelle für jeden einzelnen Wert die Anzahl
der 4er- und 5er-Tische berechnet und in den beiden folgenden
Textboxen ausgegeben.
(3) Zwei Spielzettelversionen
Wie aus der Abbildung 13 in "2.5.2.1 Das Tabellenblatt Liste" zu ersehen
ist, werden zusammen mit der Generierung des Tabellenblattes
noch zwei Buttons/Makros erzeugt zur Druckausgabe: zum einen die
43

Teilnehmerliste mit Tisch- und Platz-Nr und zum zweiten für jeden
Tisch ein vorgefertigter Spielzettel, der die Namen der Teilnehmer
bereits beinhaltet.
Die Besonderheit dieser Spielzettel liegt nun darin, dass der Anwender
eine Auswahl treffen kann zwischen zwei Varianten, und zwar
zwischen einem recht einfach gehaltenen Spielzettel und dem offiziellen
Spielzettel des DDV (Deutscher Doppelkopf Verband).
Abbildung 18
UserForm Drucken
Eingabemaske für die Auswahl
der Spielzettel
("privat/einfach" oder
"offiziell nach DDV")
Als Gastgeber eines inoffiziellen privaten Turniers empfiehlt sich die
einfachere Variante. Möchte man jedoch streng nach den Turnierspiel-Regeln
des DDV das Turnier ausrichten, so wählt man den offiziellen
DDV-Spielzettel.
Damit man sich eine Vorstellung von den Spielzetteln machen kann,
werden beide Varianten beispielhaft für einen 5er-Tisch (jeweils für
den 1. Durchgang mit vier Runden bzw. – als Extrembeispiel – mit
zehn Runden) auf den Folgeseiten abgebildet.
44

Die programmtechnische Umsetzung dieser Spielzettel ist – insbesondere
beim DDV-Spielzettel – reine Fleißarbeit. Da für jede Variante
je ein Spielzettel für einen 4er- und einen 5er-Tisch benötigt
wird, bedarf es der Generierung von insgesamt 4 Spielzetteln. Auf
die Codierung soll hier in diesem Workshop nicht näher eingegangen
werden; zum einen ist sie zu umfangreich und zum anderen entspricht
dies auch nicht der Intention dieses Workshops, die wesentlichen
Elemente des Programms darzustellen und zu erläutern.
Glücklicherweise muss man auch nicht die VBA-Befehle für die vielfältigen
Formatierungen im Einzelnen kennen, da man sich ja für
diese Arbeit der Hilfe des Makrorekorders bedienen kann.
Die Spielzettel könnte man natürlich auch auf einfache Weise über
das Internet beziehen und es ließe sich dadurch eine Menge Arbeit
sparen. Allerdings wäre man damit nicht so flexibel, denn
a) zum einen ist die Anzahl der Runden pro Durchgang bei einer
Spielzettel-Vorlage festgelegt - i.A. auf vier. Im Programm jedoch
ist die Anzahl der Runden variierbar; wobei natürlich bei einer
Rundenanzahl von beispielsweise zehn die Darstellung auf eine
DIN-A4-Seite relativ stark komprimiert wird (s. Abbildung Seite
47), aber immerhin für den praktischen Einsatz noch brauchbar
ist. Dass allerdings bei einem Turnier so viel Runden gespielt
werden, ist auch wohl eher die große Ausnahme.
b) zum zweiten werden bei dem Programm die Namen der Spieler
bereits eingetragen. Dies hat neben der besseren Lesbarkeit den
Vorteil, dass die Punkte der Spielzettel der einzelnen Spieler in
der Reihenfolge von links nach rechts auf dem Spielzettel der
Reihenfolge im Programm im Durchgangs-Tabellenblatt von
oben nach unten entsprechen. Bei Abgabe der Spielzettel kann
die Übernahme der Punkte vom Spielzettel in das Programm somit
schneller erfolgen, als wenn die Spieler die Eintragungen
selbst vorgenommen hätten, da dann die korrekte Reihenfolge
nicht mehr gewährleistet ist.
c) zum dritten ist man bzgl. der Ausgestaltung der Spielzettel bei
der selbst programmierten Variante flexibler als bei einer Vorlage.
So pflege ich z.B. bei dem bereits im Vorwort erwähnten Turnier,
welches immer zum Jahresende stattfindet, noch zur Auflockerung
ein oder zwei Grafiken mit den besten Wünschen für das
neue Jahr im Fußbereich der Spielzettel ein.
Hinweis 18
Ein Nachteil bei der Generierung
des Quellcodes per
Makrorecorder ist allerdings
die Tatsache, dass immer alle
Optionen eines FormatierungsDialogs
übernommen
werden, auch wenn diese
Optionen zum größten Teil
gar nicht genutzt werden.
Viele überflüssige Informationen
machen den Quellcode
dadurch schnell unübersichtlich.
48

3 Ausblick/Nachbetrachtung
Die mit dem Schreiben dieses Dokumentes zwangsläufige verbundene
Beschäftigung mit dem Programm hat mir gezeigt, dass an einigen Stellen
des Quelltextes doch noch einiges verbesserungsbedürftig ist. Zwar
läuft das Programm fehlerfrei, es sind meines Wissens keine logischen
Fehler vorhanden. Es ist allerdings so, dass man – so war es jedenfalls
bei mir – als Entwickler vielfach zufrieden ist, wenn das Programm genau
das tut, was es soll. Dass man evtl. dabei ein wenig "geschlampt"
hat, kümmert dann gar nicht mehr. Man hat ja, was man wollte.
Um diesbezüglich Abhilfe zu schaffen, habe ich mir vorgenommen, das
komplette Programm einmal (wann auch immer das sein wird) einer
gründlichen "Reinigung" zu unterziehen, insbesondere hinsichtlich Datendeklaration,
logischer (Um)Strukturierung sowie Kommentierung.
3.1 Neuralgische Punkte
An dieser Stelle möchte ich auf einige Punkte für den Anwender hinweisen,
die man bei der Bedienung des Programms beachten sollte.
a) Korrekte Erfassung der Teilnehmer
Wie bereits in Kapitel 2.2 Die Gäste kommen sowie Kapitel 2.4
Ereignisse in VBE) vorgestellt sowie aus Abbildung 3 (Seite 15) ersichtlich,
werden die Teilnehmer an dem Turnier dadurch festgelegt,
dass in Spalte "B" oder "C" neben dem Namen ein Rechtsklick
oder ein Doppelklick ausgeführt wird. Hierbei bedarf es einer
besonderen Achtsamkeit, damit man nicht versehentlich
durch das Klicken in einer falschen Zeile einen anderen Spieler in
die Liste aufnimmt. Wird der Fehler rechtzeitig vor Beginn der
Auslosung bemerkt, so ist das kein Problem: der Zug lässt sich
durch einen erneuten Rechts- oder Doppelklick wieder rückgängig
machen (s. 2.4 Ereignisse in VBA). Wurde aber bereits ausgelost
und die Spieler begeben sich zu ihren Tischen, gilt es zu
überlegen, eine Korrektur des betreffenden Teilnehmers vorzunehmen
und erneut auszulosen oder – alternativ - den Spieler
unter dem nun falschen Namen spielen zu lassen.
Noch ärgerlicher wird die ganze Geschichte, wenn ein Spieler gar
nicht in die Liste aufgenommen wurde. Dann hilft nur noch:
Nachträglich Spieler in die Teilnehmerliste aufnehmen und erneut
auslosen.
Ist man sich nicht sicher, ob alle Spieler korrekt eingetragen sind,
kann man direkt nach der Auslosung und dem Ausdruck der Liste,
noch bevor die ersten beginnen, sich an die Tische zu setzen,
49

die Teilnehmer bitten, zu überprüfen, ob sie in der Liste aufgeführt
sind.
Derartige Anwendungsfehler lassen sich meiner Meinung nach
auch durch Programmänderungen nicht gänzlich vermeiden.
Möchte man hier vorbeugende Maßnahmen treffen, sehe ich die
einzige Möglichkeit, programmtechnische Vorkehrungen zu treffen
darin, dass man nach dem Rechts- oder Doppelklick für den
Anwender ein Meldungsfenster (Funktion MsgBox) aufmacht
mit dem Hinweis: "Möchten Sie wirklich, dass ... in die Liste aufgenommen
wird?"
b) Datensicherung
Um möglichen Datenverlusten vorzubeugen, sollte immer wieder
zwischendurch gesichert werden. Man ist ja nie 100%-ig vor
Stromausfällen, System- oder Programmhängern (letzteres hoffentlich
nicht) geschützt.
Automatische Sicherungen lassen sich natürlich auch programmtechnisch
umsetzen (ActiveWorkbook.SaveAs Filename :=
"Name der Datei"), z.B. direkt nach der Auslosung. Zudem könnte
man dem Anwender einen Button zur Verfügung stellen zur
zwischenzeitlichen Sicherung, evtl. auch mit einer fortlaufenden
Sicherungsnummer im Dateinamen. Dies wäre z.B. sinnvoll in
den Durchgangstabellen.
c) Drucker versagt den Dienst
Dass ein Drucker streikt, die Tinte oder der Toner zur Neige geht,
kommt leider in der Praxis immer wieder vor. Um dem vorzubeugen,
ist es eine Überlegung wert, sich vorab über einen Ersatzdrucker
mit dem bereits eingespielten passenden Druckertreiber
Gedanken zu machen.
Hat man keinen Ersatzdrucker parat, und sollte es beim Ausdruck
der Spielzettel Probleme geben, ist das nicht ganz so tragisch;
entweder hat man vorgesorgt und passende Vordrucke bereits
mitgebracht oder aber die Teilnehmer fertigen die Spielzettel
selber an ihren Tischen an.
Richtig ärgerlich ist eigentlich nur der Fall, dass sich die Liste aus
dem Tabellenblatt Liste nicht ausdrucken lässt.
Programmtechnisch lassen sich diesbezüglich keine geeigneten
vorbeugenden Maßnahmen treffen.
50

3.2 Mögliche Weiterentwicklungen
Neben einer "Grundreinigung" des Quellcodes sind natürlich auch noch
Weiterentwicklungen des Programms eine zusätzliche Option. Folgende
Varianten wären denkbar:
‣ Das vorliegende Programm sieht lediglich eine Einzelwertung der
Spieler vor. Nicht nur bei Vereinsturnieren, sondern auch im privaten
Umfeld sind vielfach auch Mannschaftswertungen von
Interesse. Offen gestanden, habe ich mir diesbezüglich über einen
geeigneten Ansatz bisher noch keine Gedanken gemacht,
würde aber diesen Gesichtspunkt bei einer möglichen Erweiterung
in der Prioritätenliste ganz nach oben setzen.
‣ Die Abbildungen in diesem Skript lassen erkennen/erahnen, dass
an der Excel-Oberfläche keine Veränderungen vorgenommen
worden sind. Der Funktion an sich tut das natürlich keinen Abbruch,
bzgl. der Optik ist es allerdings eine Frage des Geschmacks,
ob man das möchte. VBA stellt zumindest die Mittel
dafür bereit, die Excel-Oberfläche auszublenden, so dass keine
Statusleiste, keine Menüleiste, und auch sonst keine Reste einer
Excel-Oberfläche mehr sichtbar sind.
‣ Vom Doppelkopf bis zum Skat ist der Weg zwar relativ weit, nicht
ganz so weit entfernt ist jedoch die Entwicklung eines Skatturnier-Programms,
wenn man die Vorlage für ein Doppelkopfturnier
bereits besitzt.
‣ Sehr aufwendig hingegen stelle ich mir die Entwicklung des
Programms in einer anderen Programmiersprache wie z.B. Java
vor. Alle Objekte mit ihren Eigenschaften und Methoden, die in
Excel/VBA bereits vorhanden sind und die der Entwickler nur
noch je nach Bedarf einsetzen muss, müssten komplett neu konzipiert
und definiert werden.
51

4 Literatur- und Quellenverzeichnis
Literatur
(1) Bernd Held: Excel-VBA Programmierung, Markt+Technik Verlag,
ISBN-10: 3827261856
Online-Quellen
(1) www.merkwerk.de/files/exvba.pdf
Andreas Klein, Stefanie Friedrich: Excel 2003, Programmierung
mit Visual Basic
(2) www.fernuni-hagen.de/imperia/md/content/zmi 2010/b012.pdf
Johannes Gogolok: VBA-Programmierung mit Excel, Grundlagen
52