Fahrtenbuch muster.sxc - Akademie für Management und Technik ...

Akademie für Management und Technik GmbH http://www.amt-wiesbaden.de 

Dokumentation des Basic-Codes im Dokument 

„Fahrtenbuch_Muster.sxc“ 

Inhaltsverzeichnis 

Ooo Basic-Beispiel: Fahrtenbuch......................................................................................... 2 

Vorbereitung:.................................................................................................................... 2 

Makro-Programmierung................................................................................................... 4 

Erste Eingaben:........................................................................................................... 7 

Sub „Main“................................................................................................................... 8 

Sub initMaske............................................................................................................ 11 

Sub FuellListe().......................................................................................................... 13 

sub heute................................................................................................................... 13 

sub standard.............................................................................................................. 14 

Spin-Buttons Datumsfelder........................................................................................ 15 

Function NeuDat()...................................................................................................... 16 

Function DatWert().................................................................................................... 17 

Spinbutton Zeitfeldern................................................................................................ 17 

Function ZeitAnd()..................................................................................................... 18 

Function Zwert()......................................................................................................... 19 

Function ZWertF()...................................................................................................... 19 

Sub AnkDat_Enter..................................................................................................... 20 

Sub AnkZeit_Enter..................................................................................................... 20 

Sub kmAnkVorgabe................................................................................................... 21 

Sub kmBerech........................................................................................................... 21 

Sub DatenBereich...................................................................................................... 22 

Function dat_adr()...................................................................................................... 23 

sub AddSatz............................................................................................................... 24 

sub SatzSpeichern..................................................................................................... 25 

Nachsatz.................................................................................................................... 26 

Der Code komplett:.................................................................................................... 27 

© T. Krumbein, 2003 Seite 1 / 34


Ooo Basic-Beispiel: Fahrtenbuch 

Wer sein Fahrzeug sowohl beruflich als auch privat nutzt, ist oft gehalten, ein Fahrtenbuch zu 

führen. Dies kann am PC geschehen, soweit die Daten zeitnah eingetragen werden. Ein solches 

Fahrtenbuch, eigentlich eine Liste, benötigt verschiedene Einträge, damit es den entsprechenden 

Vorschriften genügt. Ein solches soll jetzt erzeugen werden, und damit die Eingabe bequem 

durchgeführt werden kann, wird eine entsprechende Eingabemaske mit programmiert und mit den 

Daten verbunden. Die fertige Datei (Fahrtenbuch_Muster.sxc) können Sie herunterladen 

(www.amt-wiesbaden.de) und auch nach Bedarf anpassen. 

Vorbereitung: 

Öffnen Sie ein neues Tabellendokument und speichern Sie es unter dem Namen 

„Fahrtenbuch_Muster.sxc“ ab. Sie benötigen drei Tabellenblätter, die Sie wie folgt benennen: 

„Main“, „Liste“ und „Daten“, dabei sollte „Main“ das erste Blatt sein, welches sowohl die 

Steuertasten erhält als auch eine Übersicht und eine Statistik erhält. 

Die „Liste“ erhält die eigentliche Datenbank und somit das Fahrtenbuch als Liste. 

Die Tabelle „Daten“ schließlich nimmt alle sonstigen Daten auf, die insbesondere für die 

Eingabemaske benötigt werden. 

Beginnen Sie jetzt mit der „Liste“ und geben Sie eine Datenbank mit folgender Kopfzeile (pro 

Zelle ein Name, Spalte A-M) in Zeile 2 ein: lfdNr, Datum Abfahrt, Km-Abfahrt, Uhrzeit-Abfahrt, Ort- 

Abfahrt, Ziel-Ort, Grund der Fahrt, Km-Ankunft, Dat-Ankunft, Uhr-Ankunft, gefahrene Km, Fahrer, 

Art der Fahrt. 

Diese Felder werden für ein ordnungsgemäßes Fahrtenbuch gefordert, und zwar für 

jede Fahrt. Bei der Auswahl der Feldnamen können Sie auch andere Bezeichnungen 

wählen, achten Sie aber darauf, dass die Datenfeldbezeichnungen für OOo eindeutig 

sind, dh. keine Sonderzeichen, keine Umlaute, keine Leerzeichen etc. OOo akzeptiert 

auch “falsche” Feldbezeichnungen (im Beispiel: “Grund der Fahrt” - zwei Leerzeichen!), 

kürzt diese jedoch intern bei dem ersten verbotenen Zeichen! Ist die Eindeutigkeit dann 

nicht mehr gegeben, funktionieren Formeln mit der Datenbank nicht! 

Markieren Sie die gesamte Zeile, wählen Sie aus dem Kontextmenu „Zellen formatieren...“ und 

stellen Sie im Register „Schrift“ „Automatischen Zeilenumbruch“ ein. 

Jetzt formatieren Sie die Spalten entsprechend ihrer Bestimmung, also z.B. Spalte B und Spalte I 

erhalten ein Datumsformat (tt.mm.jj), Spalte C, H und K ein Zahlenformat ohne Dezimalstellen etc. 

Kopieren Sie jetzt die Zeile und fügen Sie diese an Zeile 10 neu ein. Füllen sie jetzt Zeile 11 mit 

Daten. Sie sollten die erste Fahrt im Jahr eintragen, also am 01.01.??. Der Startkilometerstand ist 

dabei der Kilometerstand am Jahreswechsel. 

Zum Hintergrund: Die Zeile 2 wird zukünftig der Kriterienbereich, ab Zeile 10 entsteht die 

Datenbank. Das Auffüllen der ersten Reihe dient überwiegend Übungszwecken, Sie sehen dann, 

ob Ihre Formeln funktionieren. 



Markieren Sie jetzt den Bereich A10 bis M11 und geben Sie diesem Bereich den Namen 

„Datenbank“ (Einfügen – Namen – Festlegen). 

Speichern Sie Ihr Dokument, und wechseln jetzt auf die Tabelle „Main“. 

Dort geben Sie die Übersichtsdaten und begleitende Texte ein sowie die ersten Formeln. 

Während die Kilometer gesamt sowie die Aufteilung auf die jeweiligen Fahrtzwecke über Formeln 

aus der Datenbank ermittelt werden, wird die Jahresübersicht zu Kontrollzwecken manuell 

eingegeben. Die gefahrenen Km und die Summe müssen am Jahresende übereinstimmen. 

Die Formel in D26 lautet: =wenn(d24, d24-d22;""), also eine einfache Subtraktion. 

Die Gesamtkilometer werden berechnet aus der Datenbank, und zwar aus dem maximalen Wert 

der Spalte Km-Ankunft (Spalte H) abzüglich dem ersten Wert in Km-Abfahrt (Zelle C11). 

Formel: =DBMAX(Datenbank;Liste.H10;Liste.H2:H3)-Liste.C11 

Ähnlich werden die Formeln für die jeweiligen Fahrtarten zusammengestellt. Hierfür erstellen Sie 

jedoch noch weitere Kriterienbereiche, in dem Sie die Zelle M2 in der Tabelle „Liste“ kopieren auf 

die Zellen M4, M6 und M8 der Tabelle Liste und dann in M3 „Dienstfahrt“, in M5 „Fahrt zur Arbeit“, 

in M7 “sonstige Fahrt“ und in M9 „Privatfahrt“ eintragen. 

Die Formel für Dienstfahrt (in Zelle main.c12) lautet dann: 

=DBSUMME(Datenbank; Liste.$K$10; Liste.M2:M3) 

Die anderen sind gleich aufgebaut, nur der Kriterienbereich ändert sich entsprechend. 

Fügen Sie noch die Summenformel und die Prozentformeln hinzu, die Struktur steht. 



Zum Schluss fügen Sie noch einen Button hinzu (Abreißfenster „Formularfunktionen“ aus der 

Werkzeugleiste, dort „Button“) und geben Sie ihm den Titel (angezeigter Name) „Eingabemaske“ 

(Kontrollfeld – Register Allgemein) und, wenn Sie schon im Kontrollfeld sind, den Namen 

„Bmaske“. 

Makro-Programmierung 

Die Struktur steht, damit neue Daten aber einfacher eingeben werden können, soll eine 

entsprechende Maske erschaffen werden. Folgende Aufgaben soll diese Schnittstelle erfüllen: 

• Komfortabel Eingabemaske mit allen benötigten Feldern. 

• Automatischer Eintrag der Abfahrtskilometer (= Ankunftskilometer aus dem letzten Datensatz ) 

• Datumsvorgaben 

• Anzeige der gefahrenen KM (berechnet) 

• Häufige Orte und Fahrtgründe als Listenfeld-Auswahl anbieten. Vordefinition zulassen 

• Abbruch-Button 

Die benötigte Programmierung muss darüber hinaus die Felder in die Datenbank eintragen und 



diese entsprechend vergrößern (der Name „Datenbank“ ist ja einem bestimmten Bereich 

zugeordnet und diese Zuordnung muss neu bestimmt werden, damit die Formel, die auf den 

Namen „Datenbank“ zugreifen, auch alle Datensätze erfassen). 

Die Maske soll wie folgt aussehen: 

Um die Programme nur an diese Datei zu binden, erstellen Sie zunächst ein neues Modul mit dem 

Namen „Fahrtenbuch“ (Extras – Makros – Makro...; dann im linken Listenfeld nach unten gehen, 

bis zum Dokument „Fahrtenbuch_Muster.sxc“, dort „Standard“ markieren und Schaltfläche Neu 

betätigen). 

Fügen Sie anschließend unter Fahrtenbuch_Muster.sxc – Standard noch ein neues Modul ein, und 

zwar einen neuen Dialog. Nennen Sie diesen „Maske“. 

Erzeugen Sie jetzt ein Formular mit allen benötigten Feldern. Nutzen Sie zur genauen Platzierung 

die Eigenschaften-Dialoge der jeweiligen Felder. Sie können dort unter Höhe / Breite sowie 

PositionX und PositionY exakte Maße eingeben. Das Eingabeformular selbst besitzt ebenfalls 

Eigenschaften, dort können Sie die gesamte Größe fixieren. Das Beispiel hat eine Formulargröße 

von 300*270 (B*H). 

Achten Sie auf die richtige Anlage der jeweiligen Felder. Ein numerisches Feld kann nachträglich 

nicht in ein Textfeld oder ein Datumsfeld umgeändert werden. Sie können ein falsches Feld nur 

löschen und neu anlegen. 



Gehen Sie im ersten Schritt einzig und alleine nach dem Layout und der Optik vor. 

Achten Sie auf die richtigen Feldtypen, Reihenfolge oder Funktionen spielt zunächst 

noch keine Rolle. Aber – überlegen Sie sich schon vorher, welche Felder und 

Funktionen Sie überhaupt brauchen und wie das Layout aussehen soll. Je genauer Sie 

davon eine Vorstellung haben, um so geringer sind die Nacharbeiten. Am ärgerlichsten 

ist es immer, wenn Sie ganz am Schluss feststellen, dass ein Feld fehlt oder ein Button 

noch eingefügt werden soll. Dies wirft meist das gesamte Layout über den Haufen und 

schon zugeordnete Funktionalitäten müssen völlig neu geordnet werden. 

Sie sehen in der Maske die selbst erstellten Buttons + bzw. - , die zum Durchlaufen der 

Datums- bzw. Zeitfelder dienen werden. Statt der aufwendigen Programmierung der 

Buttons und der Funktion, die dahinterstehen, hätten Sie auch in den Eigenschaften der 

vorstehenden Felder die Option „Drehfeld“ auf „Ja“ setzen können. Dann ist eine 

automatische Funktionalität eingebaut. Leider wird dabei nur die letzte Stelle um jeweils 

1 verändert(in dem Fall die Jahre), so dass hier Handarbeit erforderlich ist. 

Haben Sie die Maske soweit erstellt, beginnt die eigentliche Programmiertätigkeit. 

In den Eigenschaftsfeldern aller Felder legen Sie zunächst die „Tabstop“-Funktion sowie die 

Reihenfolge fest. Die Tabstop – Funktion bedeutet, dass der Nutzer durch Betätigung der Tab- 

Taste zum nächsten Feld springen kann. Normalerweise steht die Tabstop-Funktion immer auf 

Standard, was nicht sinnvoll ist. Normalerweise sind nur die Eingabefelder wichtig sowie die 

Hauptbuttons (im Beispiel „Satz hinzufügen“ und „Abbrechen“). Die Reihenfolge bestimmt die 

abfolgenden Tabstops. 

Da Sie für diese Aufgabe sowieso die Eigenschaften jedes Feldes aufrufen, geben Sie den 

wichtigen (hiermit sind Buttons, Eingabe und sich ändernde Anzeigefelder gemeint) eindeutige 

Namen, mit denen Sie etwas anfangen können. Alle Felder haben Standardnamen, die 

durchnummeriert sind. So ein Feld finden Sie später nicht mehr. In Datums- und Zeitfeldern geben 

Sie auch noch (sinnvolle) Ober- und Untergrenzen ein sowie das gewünschte Format. 



Bevor Sie jetzt noch den Buttons und Eingabefeldern Aktionen zuweisen, müssen Sie diese 

erstellen. Diese. Aktionen sind quasi Makros, also Subs oder Functions. 

Erste Eingaben: 

Wechseln Sie in der IDE auf das Register „Fahrtenbuch“. Dies dürfte noch leer sein außer einer 

ersten Zeile REM ****** Basic sowie der Hülle zweier Subs. Löschen Sie am Besten alles (die 

erste Zeile – den Kommentar – können Sie stehen lassen). 

Einige Hinweise vorab: 

Kommentarzeilen beginnen mit „REM“ oder dem einfachen Hochkomma ( ' ). Nutzen Sie diese 

häufig. 

OOo Basic beginnt den Programmcode von der ersten Zeile an zu interpretieren. Dabei sucht es 

nach dem Schlüsselwort „Sub“ oder „Function“. Die erste Routine mit einem dieser 

Schlüsselwörter wird abgearbeitet. Das Programm stoppt und beendet sich immer mit Erreichen 

der ersten „End“ Marke, die zu der ersten Funktion („sub“ oder „function“) gehört. Dies ist ganz 

wichtig, wenn Sie Testroutinen einprogrammieren wollen und diese ablaufen lassen. 

Ansonsten können Sie jede beliebige Routine an ein Ereignis oder Button binden. 

Globale Variablen werden am Anfang vor der ersten Routine definiert. Sie stehen dann in allen 

Funktionen zur Verfügung. 

Für die anstehende Aufgabe beachten Sie bitte folgendes: Sie benötigen Zugriff auf zwei völlig 

unterschiedliche Objekte, einmal auf Ihr OOo Tabellendokument mit seinen verschiedenen 

Tabellen und seinen ganzen Zellen, auf der anderen Seite benötigen Sie Zugriff auf Ihre Maske, 

ebenfalls ein Objekt, das allerdings im Basic-Code initialisiert wird. 

Da beide Objekte häufig und von nahezu allen Routinen benötigt werden, definieren Sie diese 

Variablen global: 

Dim oD1 as Object 'Eingabemaske 

Dim myDoc as Object 'Das Tabellendokument 

Dim oT1 as Object, oT2 as Object 'Die Tabellenblätter „Liste“ und „Daten“ 

Weiterhin benötigen Sie die folgenden globalen Variablen, Erläuterung folgt später: 

Dim nNeueDatSatz as integer ' Neue Datensatz-Zeilennummer 

Dim nLastKm as integer ' Ankunftskilometer letzter Datensatz 

Dim dZeitCh as date ' Zeitspanne bei Änderung 

Leider stellt die OOo IDE keine Zeilennummern dar. Die folgenden Abbildungen stammen 

daher aus dem Code-Editor „SciTE“, ein hervorragendes Tool zum Programmieren. SciTE 

steht unter GPL und ist in Python geschrieben (und setzt Pyhton voraus!). Die Abbildungen 

mit Zeilennummern erleichtern die Beschreibung. 



Variablennamen sind frei wählbar, solange Sie keine Schlüsselwörter oder schon belegte 

Begriffe repräsentieren. Es hat sich aber bewährt, folgende Konventionen einzuhalten: 

Variabel beginnen mit einem kleinen Buchstaben und sollten am Anfang den Typ der 

Variable widerspiegeln (oAbc für Objekt, iEineNummer für eine Zahl – oder eben 

nEineNummer – sString für eine Zeichenkette etc), gefolgt von einem Großbuchstaben 

und weiteren Zeichen. Manchmal wird auch der Begriff „my“ als erste Buchstaben gewählt, 

um die Zugehörigkeit der Variablen von Schlüsselwörtern oder vordefinierten Begriffen 

abzugrenzen. 

Sub „Main“ 

Ihr Basic-Code im Modul „Fahrtenbuch“ beginnt also wie folgt: 

Den Platz zwischen den beiden Strichen in Zeile 15 / 17 benutze ich normalerweise zum Einfügen 

von Testroutinen während der Entwicklung. 

Das Hauptmakro, das den Zugriff auf die Objekte herstellt und die Maske initialisiert, steht am 

Anfang und bekam den Namen „main“. („main“ ist kein Schlüsselwort, die Bezeichnungen der 

„Subs“ und „Functions“ ist ziemlich frei) 

Zeile 19: „ThisComponent“ bietet Zugriff auf das aktuell geöffnete Dokumenten-Objekt und wird 

„myDoc“ zugewiesen. 



Zeile 20, 21: Die Tabellen des Dokumentes werden als Array gespeichert, beginnend mit der 

Index-Nummer 0. Wir brauchen nur Zugriff auf die Tabellen 2 - „Liste“ (Index 1) und Tabelle 3 - 

„Daten“ (Index 2). 

Zeile 23, 24: Die „Maske“ wird initialisiert. Dies geschieht über einen „Service“ in der Bibliothek 

„Standard“, die zunächst geladen wird. Zeile 23 könnte auch weggelassen werden, da die 

Standard-Bibliothek meist sowieso geladen wird, es dient aber der Vollständigkeit. 

Zeile 25: Hier wird eine Funktion aufgerufen, die später besprochen wird und die Maske 

initialisieren wird, d.h. mit Vorgabe-Daten füllen.(--> Sub initMaske) 

Zeile 26: Dieser Befehl ruft die Maske tatsächlich auf öffnet Sie auf dem Bildschirm. Die Maske 

bleibt solange als Fenster bestehen, bis Sie explizit wieder geschlossen wird. Entweder durch 

einen von Ihnen definierten Befehl (sieh weiter unten- Button „Abbrechen“) oder durch einen 

vordefinierten „Ende“ Befehl, dem Kreuz oben rechts im Fensterrahmen, der „Schliessen“-Befehl 

des Fenstermanagers. 

Objekte haben vordefinierte Eigenschaften und Methoden. Leider sind diese nirgends 

ausreichend dokumentiert. Sie können sich aber alle Eigenschaften eines Objektes mit 

dem Befehl „MsgBox oObj.dbg_properties“ (oObj steht für das zu untersuchende Objekt) 

und alle Methoden mit dem Befehl „MsgBox oObj.dbg_methods“ auf dem Bildschirm 

anzeigen lassen (Subroutine). Teilweise sehen Sie später noch einige dieser 

Bildschirmausdrucke. 

Das Makro “Main” wird nun dem Button „Eingabemaske“ im Tabellendokument „Main“zugewiesen. 

Und damit wir die Maske wieder ordnungsgemäß schliessen können, zunächst die hierfür nötige 

Routine: 

Zeile 183: Mit der Funktion „EndExecute()“ wird die Maske wieder geschlossen. Die Sub 

„Abbrechen“ wird dem Button „Abbrechen“ zugeordnet. 

Wie finden Sie solche Funktionen? Wie gesagt, rufen Sie die dbg_methods für das Objekt (hier 

die Maske oD1) auf. Sie erhalten folgenden Bildschirmausdruck: 



Hier sehen Sie alle vordefinierten Funktionen, unter anderem auch die benutzte Funktion 

„endExecute()“. Zugegeben, die Methode, diese Funktionen herauszubekommen, ist etwas 

umständlich, aber sie funktioniert. 

Beachten sie jedoch, dass Sie Ihr gewünschtes Objekt zunächst erzeugen müssen, sonst gibt es 

einen Fehler. 



Sub initMaske 

Diese Funktion dient zur Initialisierung der Maske für die Bildschirmdarstellung sowie für das 

Eintragen der angezeigten Werte und das Auffüllen der Listenfelder. 

Zeile 31: Mit der Funktion „getCellRangeByName()“ erhält man Zugriff auf ein Zellbereichsobjekt, 

dies kann über die Zelladresse („b1“ - mit oder ohne Dollarzeichen) bzw. Zelladressen (z.B. 

„$B$1:$C$4“) oder durch einen benannten Bereich über den Namen erfolgen. 

Da die Zelle B1 im Tabellenblatt 3 (oT2) eine Zahl enthält, kann der Wert über „value“ abgefragt 

oder gesetzt werden. Der Rückgabewert ist nummerisch (integer), und dieser wird der Variablen 

„nNeueDatSatz“ zugewiesen. Der in „B1“ gespeicherte Wert gibt die Anzahl der bereits 

vorhandenen Datensätze im Fahrtenbuch wieder. Er dient erstens zur Bestimmung des 

Speicherortes und zweitens zur Definition des Bereiches der Datenbank. Vorsicht beim manuellen 

Ändern! 

Da die Datenbank ab Zeile 10 (Tabelle „Daten“) beginnt (Kopfzeile), wird der Datensatzzahl 11 

hinzuaddiert, um die aktuelle neue Zeilennummer zu erhalten. 

Zeile 32: In der Zelle „B3“ des selben Tabellenblattes steht eine Zeitspanne. Diese bestimmt die 

„Spin-Eigenschaft“ der +/- Buttons bei Zeitfeldern (siehe sub ZeitPlusAbf oder sub ZeitMinusAbf). 

Beachte: dZeitCH war als Date-Feld definiert. das gleiche gilt für die Zelle „B3“. Der Wert (value) 

wiederum ist eine numerische Zahl (bei Zeiten zwischen 0 und 1). 



Zeile 35: Mit der Funktion „getcontrol()“ können die Felder der Maske angesprochen werden. 

„GetControl()“ erwartet einen String, der den Namen des Feldes wiedergibt, so wie er im 

Eigenschafsfeld der Felder erscheint. OOo vergibt beim Erstellen eines Feldes automatisch einen 

Namen, jedoch einen wenig aussagekräftigen. Benennen Sie die Felder um, die sie nutzen! 

Das Feld neben dem Label „Datensatz Nr“ war als numerisches Feld definiert, mit grauem 

Hintergrund belegt und die Eigenschaft „nur lesen“ aktiviert. Dadurch kann das Feld in der Maske 

nicht editiert werden. Als Name wurde „DatSatzNr“ gewählt. 

Mit „getControl()“ erhalten Sie Zugriff auf das Objekt, welches verschiedene Eigenschaften hat. 

Die „Text“ - Eigenschaft beschreibt die aktuell angezeigte Zeichenfolgekette des Feldes. 

Neben der „Text“-Eigenschaft eines Feldes haben fast alle Felder auch noch eine 

„Wert“-Eigenschaft, die vom Text unabhängig sein kann. Der „Wert“ wird über die Art des 

Feldes bestimmt und kann numerisch (value), Datum (date), Zeit (time), oder 

Zeichenketten (string) sein. Ändert sich der Wert, kann sich auch die Anzeige (Text) 

ändern, umgekehrt ist das nicht immer der Fall! Eine typische und beliebte Fehlerquelle! 

Zeile 37: Der Ankunfts-Kilometerstand des letzten Datensatzes (gespeichert in Spalte „H“) wird 

ausgelesen und im Feld Abfahrtskilometer der Maske eingetragen. 

Zeile 39 bis 41: Das Datum der Ankunft des letzten Datensatzes wird ausgelesen. Datumwerte 

werden in OOo als fortlaufende ganze Zahl gespeichert, wobei „1“ einem Tag entspricht. 

Zum Ankunftsdatum wird ein Tag hinzugezählt und in das Feld „databf“ (Datum der Abfahrt) 

eingetragen. Hier wird schon mit einem kleinem Trick gearbeitet: Die value-Eigenschaft der Zelle 

liefert eine fortlaufende Zahl, anders als in der Datenbank dargestellt (dort steht ein Datum!). Mit 

der Zahl kann gerechnet werden. Die neu definierte Variabel „dTagAnk“ wurde ebenfalls als „date“ 

definiert. dadurch besitzt auch Sie zwei Eigenschaften: den Wert (value) als Zahl und den 

Anzeigetext (string) als Datumsdarstellung (z.B. „10.03.03“). Wird also dem Maskenfeld diese 

Variabe als „String“ („text“) übergeben, so wird die Datumsdarstellung eingetragen. Aber Achtung! 

Die „value“-Eigenschaft des Feldes ist deswegen noch nicht gesetzt und nach wie vor leer! 

Leider sind die Feldtypen „date“ und „time“ in der Maske und in „Basic“ bzw. in „Calc“ von 

Ihrer value-Eigenschaft grundverschieden und nicht miteinander kompatibel. Sie können 

die Werte also nicht so einfach zuweisen. Doch dazu später. 

Zeile 43 – 46: Hier wird die sub “FuellListe()” aufgerufen und die Listenfelder mit Inhalten gefüllt. 

Die Funktion erwartet vier Parameter: 

1. den Namen des Feldes, dessen Drop-Down-Liste mit Inhalt gefüllt werden soll. 

2. Die Spalte, in der sich die Einträge befinden 

3. Die Zeilennummer des ersten Eintrages 

4. Die Anzahl der Elemente, die eingetragen werden soll. 

Spalte und Zeile beziehen sich auf Tabelle 3 („Daten“), die die Listen beherbergt. 

Sie könnten die Auswahlliste auch direkt im Eigenschaftsfeld der Felder editieren, so aber 

ist dies flexibler. Die Liste ist merkfähig! Bevor Sie also neue Werte hinzufügen, sollten Sie 

die alten löschen oder zumindest vergleichen, ob diese nicht schon vorhanden sind. 

Zeile 48-54: Die Funktion „initMaske” wird auch nach Eingabe jedes Datensatzes aufgerufen. Es 



ist also notwendig, die Anzeige der Felder wieder zurückzusetzen. Dies geschieht hier. 

Zeile 55: Die Funktion „setFocus()“ setzt den Eingabecursor in das entsprechende Feld, so dass 

der Benutzer stets im ersten Feld beginnt. 

Sub FuellListe() 

Die Funktion erwartet vier Parameter in der folgenden Syntax: 

„FuellListe(sListe as String, sSpalte as String, nZeile as Integer, nAnzahl as Integer)“ 

Zeile 60: Das anzusprechenden Objekt (das Listenfeld in der Maske) wird initialisiert. 

Zeile 61: Vorhandene Einträge auf den Positionen 1 bis nAnzahl werden gelöscht. Alle Einträge 

sind in einem Array untergebracht, beginnend mit der Indexposition 0. Würden Sie vorhandene 

Einträge nicht löschen, so würden diese nach hinten verschoben und die neuen davor 

eingeschrieben. 

Zeile 62 bis 66: Die Schleife liest die einzelnen Einträge aus der Liste in Tabelle 2 („Daten“) aus 

und schreibt sie in die Drop-Down Liste des entsprechenden Feldes. 

Zeile 67: Fügt einen leeren Eintrag an Position 0 (erster Eintrag) in der Liste hinzu. Dadurch wird 

der Cursor wieder auf die erste Zeile gesetzt. 

Auf diese Weise wird leider ein Leereintrag in die erste Zeile geschrieben. Geschickter 

wäre es gewesen, in Zeile 65 statt der aktuellen Position „i“ eine „0“ einzutragen. Dann 

wird jeder neue Eintrag an Position „0“ geschrieben und vorhandene Einträge nach hinten 

geschoben. Im aktuellen Fall allerdings kann es zu unschönen Effekten dann kommen, 

wenn die Liste (in der Tabelle) gar nicht völlig gefüllt ist. Dann werden nämlich einige 

Leerzeilen eingefügt, und das ist nicht sehr schön. 

Verbesserungsmöglichkeit wäre: Zunächst die Anzahl der Einträge ermitteln, dann die 

Zählnummer entsprechend anpassen und dann erst die Eintragungen vornehmen, jetzt 

immer an Position „0“. 

sub heute 

Diese Funktion ist dem Button „Heute“ in der Maske zugeordnet. Die Funktion ermittelt das 

aktuelle Datum (aus dem Systemdatum) und trägt diesen Wert als Vorgabe in das Feld „Datum 

der Abfahrt“ - „databf“ ein. 



Der Button dient eigentlich der Arbeitserleichterung bei taggenauer Führung des Fahrtenbuches 

und bei vorhandenen Ruhezeiten des Fahrzeugs (Tage, an denen das Fahrzeug gar nicht benutzt 

wurde) 

Zeile 72: die Funktion „date“ liefert das aktuelle Systemdatum zurück. 

Zeile 73: Das Systemdatum wird als „String“ in das Feld eingetragen. Achtung: Der Wert des 

Feldes ist noch nicht gesetzt! 

Zeile 74: Der Fokus (Eingabecursor) wird auf das nächste Feld gesetzt. 

sub standard 

Der Button „Standard“ soll sowohl in das Feld für die Abfahrtszeit als auch in das Feld für die 

Ankunftszeit eine feste Zeit eintragen. 

Dies macht immer dann Sinn, wenn das Fahrzeug nicht regelmäßig dienstlich genutzt wird und die 

Zeiten dazwischen für private Fahrten genutzt werden. Unter steuerlichen Gesichtspunkten reicht 

eine Erfassung als Privatfahrt ohne Details aus. D.h., wer morgens um 8.00Uhr Brötchen holen 

fährt (20 min, 5 km), mittags ein wenig Obst einkauft (30 min, 5 km) und abends in die Kneipe 

fährt (2 Std, 8 km), kann dies durchaus zu einer Privatfahrt zusammenfassen, dann zum Beispiel 

mit fixierten Abfahrts- und Ankunftszeiten. 

Ein polizeilich verordnetes Fahrtenbuch oder ein anderes, amtlich verordnetes 

Fahrtenbuch muss jede Fahrt erfassen, und zwar detailliert. Nutzen Sie das Fahrtenbuch 

hierfür oder für beide Zwecke, dann müssen Sie jede einzelne Fahrt exakt dokumentieren! 

Zeile 78: Die Variablen werden als „date“ definiert. 

Zeile 79, 80: Abfahrtszeit und Ankunftszeit werden zugewiesen. Die Funktion „TimeValue()“ 

wandelt dabei einen Zeit-String in die entsprechende Zeit-Zahl (zwischen 1 und 0) um. 

Zeile 81, 82: Den beiden Feldern werden die Zeiten zugewiesen. Auch hier wird mit einem Trick 

gearbeitet. Die „date“-Variablen haben als „value“ den Zeitwert, die Zahl zwischen 0 und 1. Wird 



die „date“-Variable einer String-Variablen zugewiesen, gibt sie die Zeit als „Sting“ aus, als lesbaren 

„Sting“. Insofern wird die Variable der „Text“-Eigenschaft der Felder zugewiesen. 

Zeile 83: Der Fokus (Eingabecursor) wird auf das nächste Feld gesetzt. 

Spin-Buttons Datumsfelder 

Sub DatPlusAbfahrt – Sub DatMinusAbfahrt 

Die Spin-Button sollen dazu dienen, die jeweiligen Datumswerte um 1 Tag zu ändern, entweder 

nach „Plus“ oder nach „Minus“. Entscheidend dabei ist auch, dass die Monatswechsel automatisch 

mitberücksichtigt werden. 

Im Grunde genommen ist dies eine einfache Aufgabe. OOo Tabellendokumente (und OOo Basic, 

in „Date“-Variablen) speichern Datumswerte als ganze Zahl, wobei 1 einem Tag entspricht. Leider 

speichert das Date-Feld der Maske ein Datum (Wert) in einer völlig anderen Form, nämlich als 8stellige, 

ganze Zahl (long) mit dem folgenden Format: JJJJMMTT . Mit diesen Zahlen kann man 

rechnen, sie um eins erhöhen oder erniedrigen, und so weiter. Als Zahl kann sie aber auch 

unsinnige Werte annehmen. Beispiel: 30.01.2003 wird abgebildet als 20030130, hierzu addiere 

ich 10 Tage ( +10) so ist der Wert nun: 20030140 und das angezeigte Datum im Feld: 40.01.2003. 

Um zu entsprechenden Ergebnissen zu kommen, muss also der „Long“-Wert erst in ein echtes 

Datum umgewandelt werden und anschließend wieder zurück. 

Zeile 88, Zeile 96: Der Wert des Eingabefeldes wird abgeholt und in einer „long“-Variablen 

gespeichert. Das Eingabefeld „Datum“ besitzt sowohl eine „text“ Eigenschaft (angezeigter String- 

Text) als auch eine Wert-Eigenschaft, hier „date“ (Datumsfeld), die 8-stellige Zahl. 

Zeile 89, Zeile 97: Es wird die selbstdefinierte Funktion „NeuDat()“ aufgerufen. Diese erwartet 

zwei Parameter, eine 8-stellige Zahl (long) als Datum sowie eine Änderungszahl in Tagen 

(integer). Zurückgeliefert wird eine 8-stellige Datumszahl („long“) mit dem entsprechend 

geänderten Datum. Siehe auch -> function NeuDat(). 

Zeile 90, Zeile 98: das geänderte Datum wird an das Datefeld zurückgegeben, als Wert. Die 

Anzeige wird dem neuen Wert automatisch angepasst. 

Zeile 91, Zeile 99: Der Fokus wird auf das Eingabefeld gesetzt. Da die Buttons nicht in der 

Tabreihenfolge aktiv sind, würde der Fokus auf das nächste erzeugte Feld gesetzt, auf jeden Fall 



dorthin, wo er nicht passend ist. 

Gleiche Funktionen wie eben beschrieben existieren auch für das Feld Ankunftsdatum. 

Sub DatPlusAnk und Sub DatMinusAnk. 

Die Wiederholung der Funktionen liegt überwiegend an dem Umstand, dass den Feldern bei 

Aktionen nur ein Makro direkt zugeordnet werden kann, ohne Möglichkeit einer 

Parameterübergabe. Also müssen die jeweiligen Parameter (z.B. auf welches Feld überhaupt 

zugegriffen werden soll) in der Funktion hinterlegt werden. 

Es gäbe allerdings auch die Möglichkeit, entsprechende Flags oder Zustände der Buttons 

abzufragen, im Ergebnis ist dies dann jedoch deutlich umständlicher als der hier gewählte und 

offensichtlich redundante Weg nahezu gleicher Funktionen. 

Function NeuDat() 

Die Funktion „NeuDat()“ berechnet das neue Datum beim Betätigen der Spin-Buttons. 

NeuDat() erwartet zwei Parameter. Syntax: NeuDat(nZahl as long, nTage as Integer) 

nZahl ist dabei eine 8-stellige Datumszahl des Formates JJJJMMTT, nTage eine ganze Zahl 

eventuell mit negativen Vorzeichen, das die Änderung des Datums in Tagen beschreibt. 

Zeile 189: Die Funktion DateValue ermittelt aus einem übergebenen Datumsstring im einem 

bekannten Format den entsprechenden Datumswert (fortlaufende Zahl). Zu diesem Datums wert 

wird die gewünschte Differenz (ganze Zahl) in Tagen addiert (bzw. subtrahiert, wenn eine negative 

Zahl übergeben wird). 

Die Funktion DatWert() ermittelt dabei aus einer 8-stelligen Zahl einen Datums-Textstring. Siehe 

-->function DatWert() 

Zeile 190: Aus dem Datumswert wird wieder eine 8-Stellige Zahl (long) erzeugt. Dies erfolgt durch 

Verkettung von Zahlen zu einem reinem Zahlenstring. Durch Zuweisung dieses Zahlenstrings an 

eine numerische Variable (hier: long) wird aus dem String eine Zahl. Die Verkettung erfolgt durch 

Auslesen der jeweiligen Daten mit den vordefinierten Funktionen „Year()“ - gibt das Jahr 4-stellig 

zurück, „Month()“ - gibt den Monat einoder zweistellig zurück -, und „Day()“ - gibt den Tag einoder 

zweistellig zurück - .Aus diesem Grund wird bei Tag und Monat zusätzlich noch die Funktion 

„Format()“ genutzt, die die Zahlen entsprechend formatiert und somit auch führende Nullen 

einträgt. Dadurch wird das 8-stellige Zahlenformat gewährleistet. 

Zeile 191: Der Rückgabewert der Funktion wird zugewiesen. 



Function DatWert() 

Die Funktion DatWert() ermittelt aus einer 8-stelligen Zahl einen Datums-Textstring. Die Funktion 

erwartet einen Parameter. 

Syntax: DatWert(nZahl as long) 

Zeile 195: Über die Formatfunktion wird sichergestellt, dass tatsächlich eine 8-stellige Zahl 

vorliegt. 

Zeile 196: Mit Hilfe der Stringfunktionen right(), mid() und left() wird aus der Zahl ein 

entsprechender Datumsstring generiert. Beispiel: Übergebene Zahl: 20030620 -> daraus wird: 

20.06.2003. 

Zeile 197: Der Rückgabewert der Funktion wird zugewiesen. 

Spinbutton Zeitfeldern 

sub ZeitPlusAbf, sub ZeitMinusAbf 

Die Spin-Button sollen dazu dienen, die jeweiligen Zeitwerte um einen vorgegebenen Zeitraum 

(gespeichert in „Zelle B3“ des Tabellenblattes „Daten“) zu ändern, entweder nach „Plus“ oder nach 

„Minus“. Entscheidend dabei ist auch, dass die Tageswechsel automatisch mitberücksichtigt wird. 

Auch hier wird leider für die Zeit in Masken-Zeitfeldern ein sonderbarer Wert benutzt. Der Wert der 

Zeit wird dabei erneut als 8-stellige Zahl (Long) dargestellt, und zwar im Format: HHMMSS00, H 

für Stunde, M für Minute, S- für Sekunde, gefolgt von 2 Nullen (Funktion ??). Nutzt man die 

möglichen automatischen Spinbuttons, wird die Zeit jeweils um eine Sekunde verändert. Dies ist 

für die Praxis kaum tragbar. 



Zeile 121, Zeile 129: Der aktuelle Zeitwert des Zeiteingabefeldes wird abgefragt und in der 

Variablen gespeichert. 

Der Zeitwert (8-stellige Zahl) muss nicht identisch sein mit dem angezeigten Text im 

Eingabefeld. Der Text kann separat gesetzt werden und hat keinen einfluss auf den 

„Wert“. Wird allerdings der „Wert“ gesetzt bzw. geändert, ändert OOo auch die Anzeige, 

den Textstring, entsprechend. 

Zeile 122, Zeile 130:Es wird die selbst definierte Funktion „ZeitAnd()“ aufgerufen. Diese erwartet 

zwei Parameter, eine 8-stellige Zahl (long) als Zeit sowie eine Änderungszahl als +1 oder -1. 

Zurückgeliefert wird eine 8-stellige Zeitzahl („long“) mit der entsprechend geänderten Zeit. Siehe 

auch -> function ZeitAnd(). 

Zeile 123, Zeile 131: die geänderte Zeit wird an das Zeitfeld zurückgegeben, als Wert. Die 

Anzeige wird dem neuen Wert automatisch angepasst. 

Zeile 124, Zeile 132: Der Fokus wird auf das Eingabefeld gesetzt. Da die Buttons nicht in der 

Tabreihenfolge aktiv sind, würde der Fokus auf das nächste erzeugte Feld gesetzt, auf jeden Fall 

dorthin, wo er nicht passend ist. 

Gleiche Funktionen wie eben beschrieben existieren auch für das Feld Ankunftszeit. 

Sub ZeitPlusAnk und Sub ZeitMinusAnk. 

Einziger Unterschied: Es erfolgt eine Prüfung, ob überhaupt schon ein Wert dem Eingabefeld 

zugeordnet ist. Wenn nicht, wird der Zeitwert auf 12000000 gesetzt, dies entspricht 12:00 Uhr. 

Function ZeitAnd() 

Die Funktion „ZeitAnd()“ ändert die im Eingabefeld stehende Zeit entsprechend einer Zeitspanne, 

die im Feld „B3“ der Tabelle „Daten“ hinterlegt ist, und zwar entweder nach + oder nach -. 

Die Funktion ZeitAnd() erwartet 2 Parameter: 

Syntax: ZeitAnd(nZeitzahl as long, iVorzeichen as integer) iVorzeichen darf dabei nur die Werte 

-1 oder +1 annehmen. Eine Fehlerkontrolle erfolgt jedoch nicht. 

Zeile 216: Die 8-stellige Zeitzahl wird der Funktion „Zwert()“ übergeben. Diese wandelt die 

Zeitzahl eines Formularfeldes in einen typischen, lesbaren Zeitstring um (Beispiel: Zeitzahl 

12300000 -> Zeitstring 12:30:00 ). Siehe auch --> function Zwert(). 

Der Zeitstring wiederum wird durch die Funktion „Timevalue()“ in eine OOo Zeitzahl umgewandelt 

(Zahl zwischen 0 und 1). 

Zeile 217: Die definierte Zeitspanne (abgelegt in der globalen Variablen dZeitCH) wird mit dem 

übergebenen Vorzeichen multipliziert und zu der Zeit addiert (bei negativen Vorzeichen 



subtrahiert). 

Zeile 218: Der Rückgabewert wird zugewiesen. Dabei wird die selbst definierte Funktion zWertF() 

aufgerufen, die einen übergeben Zeitwert im OOo-Format in einen Zeitwert des Formulars (8stellige 

Zahl, long) umwandelt. Siehe --> Function zWertF() 

Function Zwert() 

Die Funktion „Zwert()“ wandelt eine Zeitzahl eines Formularfeldes (8-stellige Zahl as long) in einen 

typischen, lesbaren Zeitstring um (Beispiel: Zeitzahl 12300000 -> Zeitstring 12:30:00 ). 

„Zwert()“ erwartet einen Parameter. Syntax: Zwert(lZeitzahl as long) 

Auch bei dieser Funktion gilt wie bei allen anderen selbst geschriebenen „Subs“ und 

„Functions“ dieses Skriptes, es findet keine Fehlerprüfung statt. Möchten Sie ein perfektes 

Skript, so können Sie jeweils noch Fehlerkontrollen einbauen. beispielsweise zuerst 

überprüfen, ob der übergebene Parameter tatsächlich vom Typ „Long“ ist. 

Zeile 207 bis 209: Hier findet zunächst eine Fehlerprüfung statt. Sollte nämlich der Zeitwert 0 

sein, so würde die Funktion den Wert „00:00:00“ zurückliefern. Dieser Wert wiederum würde bei 

der Funktion „TimeValue()“ einen Fehler auslösen (00:00:00 entspricht 24:00:00, ist aber ein 

ungültiger Zeitwert). Insofern wird im Falle, dass der Zeitwert „0“ ist, dieser auf „100“ (entspricht 

„00:00:01“ geändert. Der angesprochene Fehler kann dann nicht auftreten. 

Zeile 210: Der Zeitwert wird formatiert als String ausgegeben (8-stellig). 

Zeile 211: Der Rückgabewert wird als Stringverkettung entsprechend zusammengesetzt. 

Function ZWertF() 

Die Funktion „ZWertF()“ wandelt einen übergebenen Zeitstring in eine 8-stellige Zahl im Format 

der Zeitfelder eines Formulars um. Erwartet wird ein Parameter. 

Syntax: ZwertF(sZeit as String) 



Zeile 202: Die Zeitzahl entsteht aus Verkettung der Einzelwerte des Zeitstrings. Da dies nur zu 6- 

Stellen führt, werden zwei Nullen am Ende eingefügt. Das Ergebnis ist die 8-stellige Zahl. Beispiel: 

Text-Zeitstring: 12:30:00 --> Umwandlung in Zahl: 12300000 

Zeile 203: Der Rückgabewert wird zugewiesen. 

Sub AnkDat_Enter 

Diese Funktion wird aufgerufen, wenn das Feld „Ankunftsdatum“ den Fokus erhält, sei es durch 

die „Tab“-Taste oder durch einen Mausklick in das Feld. 

Die Funktion wird dem Ereignis „Bei Fokuserhalt“ des Eingabefeldes zugeordnet. 

Sinn der Funktion ist es, Vorgabewerte einzutragen. Dabei ist entscheidend, dass zunächst 

geprüft wird, ob schon Daten vorhanden sind. In diesem Fall dürfen keine Eintragungen 

vorgenommen werden. Sie könnten nämlich noch einmal zurückkehren um Ihren Wert zu 

korrigieren und wären dann sicher nicht erfreut, würde Ihr Wert wieder durch die Vorgabe 

überschrieben. 

Zeile 158: Die „if-Schleife“ prüft zunächst, ob der Wert des Eingabefeldes „Datum Ankunft“ noch 

Null ist. Wenn ja, wird ein Vorgabewert eingefügt, wenn nein, passiert gar nichts. 

Zeile 159: Als Vorgabe-Datum wird der Wert des Eingabefeldes „Abfahrts-Datum“ übernommen. 

Sub AnkZeit_Enter 

Ähnlich wie die Funktion „AnkDat_Enter“ schreibt diese Funktion einen Vorgabewert in das Feld 

„Ankunftszeit“, und zwar dann, wenn der Wert des Eingabefeldes noch Null ist. Der Wert wird 

dabei dem Wert des Eingabefeldes „Abfahrtszeit“ gleichgesetzt. 



Sub kmAnkVorgabe 

Auch das Feld „Kilometer Ankunft“ soll bei erstmaligen Fokuserhalt einen Vorgabewert erhalten. 

Hierfür ist diese „Sub“ verknüpft mit den Ereigniss „bei Fokuserhalt“ des Feldes „Kilometer 

Ankunft“ („kmank“). 

Zeile 170: Die „if-Schleife“ prüft, ob schon ein Wert vorhanden ist. Wenn ja, passiert gar nichts. 

Zeile 171: In Zelle „B5“ des Tabellenblattes „Daten“ ist eine Kilometervorgabe gespeichert, die zu 

dem Abfahrtskilometerstand hinzuaddiert werden soll und dann die Vorgabe bildet. Diese wird hier 

abgerufen. 

Zeile 172: Die Vorgaben wird berechnet und zugewiesen 

Zeile 173: Die Funktion „kmBerech“ wird aufgerufen. diese Funktion berechnet die gefahrenen 

Kilometer und trägt diesen Wert in das Feld „gefahrene Kilometer“ ein. Siehe auch --> sub 

kmBerech. 

Sub kmBerech 

Diese Funktion berechnet die gefahrenen Kilometer indem sie die Werte der Felder Kilometer 

Ankunft und Kilometer Abfahrt voneinander subtrahiert. 

Um eine sichere Funktion und eine entsprechende Anzeige zu erhalten, wird diese 

Funktion zusätzlich mit dem Feld „KMAnk“ (also dem Kilometerstand bei Ankunft) 

verbunden, und zwar zum Ereignis „Bei Textänderungen“. Sobald also eine Ziffer geändert 

wird, tritt die Funktion in Aktion. 

Zeile 178: Subtraktion der Werte der Kilometerfelder 

Zeile 179: Zuweisung der Anzeige des Ergebnisses. 



Das Feld „gefahrenen Kilometer“ ist ein numerisches Feld, das jedoch nicht editierbar ist. 

Sie können keinen Text hineinschreiben, den Wert aber ohne Schwierigkeiten durch 

Zuweisung ändern. Dieser Wert wird angezeigt. In der Maske bekam dieses Feld noch 

einen dunkleren Hintergrund, um sich so von editierbaren Feldern abzuheben. 

Sub DatenBereich 

Diese Funktion wird aufgerufen beim Speichern eines Datensatzes und dient zur neuen 

Festlegung des Datenbereiches. 

Sie erinnern sich: Die Datenbank des Fahrtenbuchs ist ein benannter Bereich („Datenbank“), auf 

den sich verschiedenen Formeln zur Auswertung beziehen. Wird ein Datensatz hinzugefügt, 

ändert sich der gesamte Datenbereich (er wird größer). OOo passt die Zuordnung der 

Zelladressen zu einem Bereich nicht automatisch an. Dies müssen Sie manuell erledigen, oder 

eben, wie hier, durch ein Makro. 

Zeile 222: Erzeugen eines neuen Objektes, und zwar eines Zellenobjektes. 

Zeile 223: Zugriff auf das Objekt der benannten Bereiche des Dokumentes. Benannte Bereiche 

sind Zellbereiche, denen ein Name zugeordnet wurde. 

Zeile 224: Der Bereich „Datenbank“ wird gelöscht. Hierbei wird die Verbindung des Zellbereiches 

zu dem Namen gelöscht, die Inhalte der Zellen ändern sich nicht! Notwendig, um in einem 

nächsten Schritt den Zellbereich neu zu definieren. Gleiche Namen sind nicht erlaubt, also 

zunächst löschen des vorhandenen Namens „Datenbank“. 

Die Funktion „removebyName()“ erwartet einen Parameter, den Namen als String. 

Zeile 225: Ein neuer Bereich wird erstellt. Die Funktion addNewByName() erwartet vier Parameter 

Syntax: addNewbyName(sBereichsname as String, sBereich as String, oPos as object, lFlag as 

long) 

Der Bereich wird konstruiert mit Hilfe der neuen Datensatznummer, die Zeilennummer ist in der 

globalen Varaiblen „nNeueDatSatz“ gespeichert. Durch Verwendung der „$“-Zeichen wird der 

Bereich fixiert. 

Der letzte Parameter sollte „0“ sein. es gibt andere Flags, die spielen hier jedoch keine Rolle. 

Hier noch einmal ein Beispiel, wie Sie die Methoden (Funktionen) eines Objektes erhalten. 



Das Ergebnis des Aufrufes: msgbox oBereich.dbg_methods (oBereich muss natürlich vorher 

definiert werden – siehe oben). 

Links ist der Rückgabewert-Typ beschrieben, in den Klammern der erwartete Parameter-Typ. 

Im Übrigen heißt es einfach: Ausprobieren. 

Function dat_adr() 

Die Funktion „dat_adr()“ bestimmt die Speicheradresse, an der die neuen Daten im Tabellenblatt 

gespeichert werden sollen. Dabei gelten folgende Bedingungen: Alle Daten eines neuen 

Datensatzes werden in der selben Zeile gespeichert. Die Zeilennummer ist dabei in der globalen 

Variablen „nNeueDatSatz“ gespeichert. Die Spalte, in der die Daten gespeichert werden sollen, 

wird als Parameter übergeben. 

Syntax der Funktion: dat_adr(sSpalte as string). Der Rückgabewert ist die Speicheradresse als 

String ohne Tabellenblatt. 

Die Funktion wird im Rahmen der „Sub SatzSpeichern“ aufgerufen. 



sub AddSatz 

Die Funktion „AddSatz“ ist dem Button „Satz Hinzufügen“ zugeordnet und speichert die 

eingegebenen Daten in einem neuen Datensatz. Dabei übernimmt die Sub „AddSatz“ zunächst 

eine Fehlerkontrolle derart, als dass sie die Inhalte der notwendigen Felder überprüft und bei 

fehlender Eingabe eine Meldung ausgibt. Die Speicherung wird nicht durchgeführt. 

Es erfolgt lediglich eine Prüfung, ob die Felder ausgefüllt wurden (also ob der Inhalt 

ungleich Null ist), es erfolgt keine inhaltliche Plausibilitätskontrolle! So könnte zum Beispiel 

der Ankunftskilometerstand niedriger als der Abfahrtskilometerstand sein, dies würde nicht 

beanstandet. 

Erst wenn die Fehlerprüfung keine Beanstandung ergibt, wird die Funktion “SatzSpeichern” 

aufgerufen, die die eigentliche Datenspeicherung vornimmt. 

Zeile 235: Die „if“-Schleife prüft, ob Inhalt im Feld vorhanden ist. 

Zeile 236: Entspricht der Wert des Feldes gleich Null, (der Wert ist wichtig, nicht der angezeigte 

Text!), dann wird eine entsprechende Nachricht ausgegeben 

Zeile 237: Nach Bestätigung der Nachricht wird der Fokus auf das entsprechende Feld gesetzt. 

Zeile 257: Erst wenn alle Felder mit Inhalt gefüllt sind wird die Funktion „SatzSpeichern“ 

aufgerufen. 



sub SatzSpeichern 

Die Funktion „SatzSpeichern“ schließlich speichert die eingegebenen Daten in der Maske in die 

Datenbank der Tabelle „Liste“. 

Wiederholungen wurden hier abgeschnitten, das Vorgehen ist stets gleich! 

Zeile 264: Das Eingabefeld (in diesem Fall „Datum Abfahrt“) wird ausgelesen und der Wert auf ein 

entsprechendes Format für OOo-Tabellenkalkulation konvertiert. Aufruf der --> Function DatWert. 

Zeile 265: Die Speicher-Zelladresse wird ermittelt, Übergabe der Spalte „B“. --> function dat_adr() 

Zeile 266: Der Wert wird in die entsprechenden Zelladresse des Tabellenblattes „Liste“ (oT1) 

geschrieben. 

Diese Schritte werden für alle weiteren Felder ähnlich durchgeführt. Auf eine detaillierte 

Darstellung jedes einzelnen Feldes wird verzichtet, Sie können dieses recht einfach anhand des 

Codes selbst herausfinden. 

Interessant wird es erst wieder bei dem Optionsfeld. Optionsfelder können nur einen von 

mehreren Auswahlmöglichkeiten annehmen. Die Gruppe wird durch den Sie umgebenden 

Rahmen bestimmt und von OOo automatisch gruppiert. 

Optionsfelder können einen Status annehmen: „True“ für markiert, „False“ für nicht markiert. 

Dieser Status kann direkt abgefragt (und auch gesetzt ) werden. Im Optionsfeld werden die 

einzelnen „Fahrtarten“ noch explizit angegeben. Besser wäre allerdings auch hier eine 

Verknüpfung mit den entsprechenden Feldern in der Tabelle „Liste“. Die Namen der Fahrten 

kommen dort im Kriterienbereich als Filterkriterien zum Einsatz. Beide Begriffe müssen exakt 

gleich geschrieben werden, um Fehler zu vermeiden. Insofern wäre eine Verknüpfung der bessere 

Weg (-> vorgesehen für eine spätere Version!). 



Zeile 311-322: Die „if“-Schleife überprüft den Status der Optionsfelder und definiert den Inhalt des 

Speicherwertes. 

Zeile 324, 325: Die Datensatznummer wird um 1 erhöht und in die Tabelle „Daten“ 

zurückgeschrieben. (Schließlich wurde ein Datensatz neu hinzugefügt) 

Zeile 326: Aufruf der Funktion „DatenBereich“. Diese Funktion definiert den benannten Bereich 

„Datenbank“ in Tabelle „Liste“ neu. --> sub DatenBereich 

Zeile 327: Die Funktion „store()“ speichert die Datei unter ihrem bereits vorhandene Namen und 

Speicherort. Entspricht der Funktion „Datei - Speichern“ im Tabellendokument. 

Zeile 328: Die Maske wird neu initialisiert, d. h. die Eingaben werden gelöscht und die 

Vorgabewerte neu errechnet. --> sub initMaske 

Nachsatz 

Für Perfektionisten kann die Funktion des Fahrtenbuches noch ergänzt werden. Vorstellbar sind 

folgende Zusätze: 

Feste Datensätze mit Fahrkilometer, Ankunftskilometer, Fahrtgrund etc definieren und auf 

zusätzliche Tasten belegen. 

Schnelltasten für bestimmte, vordefinierte Zeiten. 

Fehler- und Plausibililitätskontrolle der eingegebenen Werte. 

Automatisierte Ausdrucke und weiter Auswertungen. 

..... 

Alle Hinweise und (Code-) Ergänzungen werden dankbar angenommen. 



Der Code komplett: 















Stichwortverzeichnis 

„Datenbank“......................................................... 3 

„End“ Marke......................................................... 7 

addNewByName() .............................................22 

Array.....................................................................9 

Benannte Bereiche.............................................22 

dat_adr().............................................................23 

date....................................................3, 7, 12, 14f. 

Date............................... 1ff., 7, 9, 11ff., 15ff., 20ff. 

Date-Feld........................................................... 11 

Date-Feld der Maske..........................................15 

DateValue...........................................................16 

Datumsfeld...........................................................5 

Datumsstring......................................................17 

Datumswerte......................................................15 

DatWert()......................................................... 16f. 

Day()...................................................................16 

Eigenschaften...................................................... 9 

Eigenschaftsfeldern..............................................6 

EndExecute()....................................................... 9 

Fahrtenbuch.........................................................2 

Feldnamen...........................................................2 

Fokuserhalt........................................................ 21 

Formel.................................................................... 

=DBMAX(d1;d2;d3) 3 

=DBSUMME(d1;d2;d3) 3 

=wenn(p1;p2;p3) 3 

Makro-Programmierung 4 

Formulargröße..................................................... 5 

FuellListe()......................................................... 12 

Function dat_adr()..............................................23 

Function DatWert().............................................17 

Function NeuDat()..............................................16 

Function ZeitAnd()..............................................18 

Function Zwert().................................................19 

Function ZWertF()..............................................19 

Functions..............................................................7 

getCellRangeByName()..................................... 11 

getcontrol().........................................................12 

GetControl()....................................................... 12 

Globale Variablen.................................................7 

IDE.......................................................................7 

Kommentarzeilen.................................................7 

Kriterienbereich....................................................2 

left()....................................................................17 

Listenfelder.........................................................11 

long“-Variablen...................................................15 

Makro-Programmierung.......................................4 

Maske.........................................................5, 9, 11 

Maske inizialisieren..............................................9 

Masken-Zeitfeldern............................................ 17 

Methoden.............................................................9 

mid() ..................................................................17 

Modul....................................................................5 

Month()...............................................................16 

NeuDat()...........................................................15f. 

numerisches Feld.................................................5 

oObj.dbg_methods...............................................9 

oObj.dbg_properties.............................................9 

Optionsfeld.........................................................25 

Optionsfelder......................................................25 

removebyName()............................................... 22 

right()..................................................................17 

SatzSpeichern....................................................24 

Schlüsselwort.......................................................7 

Service.................................................................9 

setFocus()..........................................................13 

Spin-Buttons Datumsfelder............................1, 15 

Spinbutton Zeitfeldern........................................17 

Spinbuttons........................................................17 

Sub „Main“............................................................8 

sub AddSatz.......................................................24 

Sub AnkDat_Enter............................................. 20 

Sub AnkZeit_Enter.............................................20 

Sub DatenBereich..............................................22 

Sub FuellListe()..............................................1, 13 

sub heute....................................................... 1, 13 

Sub initMaske.....................................................11 

Sub kmAnkVorgabe...........................................21 

Sub kmBerech....................................................21 

sub SatzSpeichern.............................................25 

sub standard.................................................. 1, 14 

sub ZeitMinusAbf............................................... 17 

Sub ZeitMinusAnk..............................................18 

sub ZeitPlusAbf..................................................17 

Sub ZeitPlusAnk.................................................18 

Subs.....................................................................7 

Tabellendokument................................................2 

Tabreihenfolge...................................................15 

ThisComponent....................................................8 

Timevalue()........................................................18 

value...................................................................11 

Variablennamen...................................................8 

www.amt-wiesbaden.de.......................................2 

Year().................................................................16 

ZeitAnd().............................................................18 

Zellbereiche........................................................22 

Zwert()..............................................................18f. 

ZWertF().............................................................19

Fahrtenbuch muster.sxc - Akademie für Management und Technik ...

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?