OBS/Makros

Makros werden an vielen Stellen im OBS genutzt, um zur Laufzeit des Programms kunden- oder benutzerbezogene Funktionalitäten auszuführen. Dies beinhaltet u. a. das Verändern (z. B. Kalkulation von Preislisten) oder die Anzeige (z. B. zusätzliche Vorgangsinformationen in Positionserfassung) von Daten innerhalb des Programms. Auch das Drucksystem von OBS arbeitet mit Makros. Die Makros im OBS orientieren sich an der Syntax der Sprache Pascal.

Syntax

Variablen-Typen

string

Variablen des Typs string enthalten Zeichenketten (Text) wie z. B. 'Max Mustermann' oder 'Musterweg 1a'.

integer

Variablen des Typs integer enthalten Ganzzahlen wie 2, 15 oder 1538.

double

Variablen des Typs double enthalten Dezimalzahlen. Hier ist zu beachten, dass das Trennzeichen bei der Angabe von Dezimalstellen immer ein Punkt ist.
Beispiel:

Preis := 10.95;

boolean

Variablen dieses Typs enthalten Wahrheitswerte. Sie können entweder wahr oder falsch sein. Der Wert lässt sich direkt mit true oder false setzen. Es können aber Bedingungen für die Zuweisung verwendet werden. Boolsche Variablen lassen sich in bedingten Anweisungen des Typs if auch ohne Vergleichswert nutzen.
Beispiel:

Vorbelegung:

    Verglichen = false;
    A_ist_kleiner_B = false;

Abfrage:

    if (not Verglichen) then begin
        A_ist_kleiner_B := A < B;
        Verglichen := true;
    end;

Konstanten

Konstanten enthalten wie Variablen bestimmte Werte. Anders als bei Variablen werden Konstanten nicht einfach mit einem Datentyp sondern schon mit dem Wert definiert, der im ganzen Programm(-teil) verfügbar sein soll. Kostanten können nicht verändert werden.

In Makros lassen sich eigene Konstanten definieren. Das kann wie folgt aussehen:

const
    GRUSS = 'Mit freundlichen Grüßen';
    HOMEPAGE_HINWEIS = 'Besuchen Sie uns doch mal auf unserer Homepage unter www.unsere-seite.de und erfahren '+
                       'Sie mehr über die ergonomische Einrichtung von Arbeitsplätzen. Für aktuelle Informationen '+
                       'oder Aktionen könne Sie sich auf unserer Homepage für den Newsletter eintragen.';

Methoden

Es gibt zwei Typen: Prozedur und Funktion. Der Unterschied dabei ist, dass Funktionen einen Rückgabewert haben. Die Definition einer Methode erfolgt in der Reihenfolge Typ-Anweisung, Methodenname, Parameter und bei Funktionen der Typ des Rückgabewerts. Mehrere Parameter sind mit Semikolon zu trennen.

Beispiel Prozedur:

procedure Name(cParameter1: string; nParameter2: integer);

Beispiel Funktion:

function Name(cParameter1: string; nParameter2: integer): boolean;

Bedingte Anweisungen

Bedingte Anweisungen machen es möglich einen Teil des Makros nur ausführen zu lassen, wenn etwas bestimmtes zutrifft. In Pascal gibt es dafür if und case. Die case-Anweisung unterliegt dabei allerdings im Vergleich zur if-Anweisung einiger Einschränkungen.

if

    if Bedingung then begin
        Befehl 1;
        Befehl 2;
        ...
    end;

Es ist auch möglich mehrere Bedingungen zu definieren. Dabei lässt sich bestimmen, ob nur eine, alle oder ein Teil der Bedingung zutreffen muss, um den Teil des Makros auszuführen. Das kann hilfreich sein, wenn in mehreren Fällen das gleiche passieren soll.
Alle Bedingungen sollen zutreffen:

    if Bedingung1 and Bedingung2 then begin

Nur eine Bedingung muss zutreffen:

    if Bedingung1 or Bedingung2 then begin

Nur Bedingung 1 oder Bedingung 2 und 3 (hier sind die Klammern wichtig!):

    if Bedingung1 or (Bedingung2 and Bedingung 3) then begin

case

Die case-Anweisung prüft den Wert einer Variablen ab und und führt dann den - sofern vorhanden - dazu passenden Fall aus. Dies funktioniert jedoch nur mit einem ordinalen Typ (z. B. Ganzzahl oder einzelnes Zeichen).
Struktur:

    case Wert of
        Fall1 : Anweisung;
        Fall2 : Anweisung;
        Fall3 : begin
            Anweisung 1;
            Anweisung 2;
        end;
    else
        Standard-Anweisung
    end;

Es können als Bedingung (Fall) auch mehrere Angaben mit Komma getrennt erfolgen oder Bereiche mit zwei Punkten angegeben werden.
Beispiel:

    case Monat of
        1,3,5,7..8,10,12 : Tage := 31;
        2 : begin
            if IstSchaltjahr then begin
                Tage := 29;
            end else begin
                Tage := 28;
            end;
        end;
    else
        Tage := 30;
    end;

Schleifen

Schleifen ermöglichen die mehrfache Ausführung eines Teils des Makros. Es wird unterschieden in kopfgesteuerten und fußgesteuerten Schleifen. In den Makros können Sie zwei kopfgesteuerte (while und for) und eine fußgesteuerte Schleife (repeat until) verwenden. Der Unterschied besteht darin, dass bei kopfgesteuerten Schleifen der eingefasste Teil nur ausgeführt wird, wenn die Bedingung der Schleife dies zulässt. Bei der fußgesteuerten Schleife wird der eingefasste Teil mindestens einmal ausgeführt. Die weitere Ausführung entscheidet dann die Bedingung am "Fuß" der Schleife.

while

Bei dieser kopfgesteuerten Schleife wird der eingefasste Code solange ausgeführt, bis die Bedingung nicht mehr erfüllt ist. Die Anzahl der Durchläufe kann abhängig von der Bedingung variieren. Es ist möglich Variablen der Bedingung innerhalb der Schleife zu verändern. Es ist möglich eine unendliche Ausführung dieser Schleife zu erzeugen.

for

Schleifen vom Typ for arbeiten mit einem festen Zähler. Es kann dabei hoch sowie runter gezählt werden. Sobald der Startwert und der Endwert bestimmt sind, wird die Schleife entsprechend oft ausgefüht. Auf den Zähler kann dabei innerhalb der Schleife kein Einfluss genommen werden.

repeat until

Die eingefasste Code dieser fußgesteuerten Schleife wird wiederholt, bis die Abbruch-Bedingung erfüllt wird.

Übersicht Konstanten

Eine allgmeine Erklärung zu Konstanten finden Sie hier.

Zeichenketten (string)

CRLF

Erklärung: CRLF steht für "carriage return" und "line feed". Die Konstante kann verwendet werden, um einen Zeilenumbruch in eine Zeichenkette einzufügen.
Beispiel:

    cText := 'Dies ist Zeile 1' + CRLF + 'Und das hier Zeile 2';

HT

Erklärung: HT steht für "horizontal tab". Die Konstante kann verwendet werden, um einen (horizontalen) Tab in eine Zeichenkette einzufügen.
Beispiel:

    cText := HT + 'Ich bin eingerückt';

Übersicht Funktionen

Hier finden Sie einige nützliche Befehle/Funktionen, die Sie in den Makros verwenden können, um das gewünschte Ergebnis zu erzielen.

Empty

Verwendung: Prüft, ob der Wert des Parameters leer bzw. 0 ist. Dies Funktioniert mit Zeichenketten (string) und Zahlen (integer und double)
Parameter: string/integer/double
Rückgabe: boolean
Beispiel:

cText := '';
IstLeer := Empty(cText);
cText := 'Beispiel';
IstLeer := Empty(cText);

Erklärung: Der String-Variable cText wird ein leerer Text zugewiesen. Mit Empty wird der Wert nun geprüft. Die boolsche Variable IstLeer ist dann true (wahr). Als nächstes wird cText der Wert "Beispiel" zugewiesen und eine erneute Prüfung mit Empty durchgeführt. Da cText jetzt einen Text enthält, ist der Wert der Variablen IstLeer nun false (falsch).

Length

Verwendung: Ermittelt die Länge einer Zeichenkette (string).
Parameter: string
Rückgabe: integer
Beispiel:

cText   := 'Dies ist ein Beispiel.';
nLaenge := Length(cText);

Erklärung: Der String-Variable cText wird der Wert Dies ist ein Beispiel. zugewiesen. Mit Length wird die Länge ermittelt. Der Satz "Dies ist ein Beispiel." hat 22 Zeichen. nLaenge hat also den Wert 22.

AllTrim

Verwendung: Entfernt Umbrüche und Leerzeichen am Anfang und Ende einer Zeichenkette.
Parameter: string
Rückgabe: string
Beispiel:

cText := '  Dies ist ein Beispiel.       ';
cText := AllTrim(cText);

Erklärung: Der String-Variable cText wird der Wert " Dies ist ein Beispiel. " zugewiesen. Mit AllTrim werden die unnötigen Leerzeichen am Anfang und Ende der Zeichenkette entfernt. Die Variable cText entspricht also dem Wert "Dies ist ein Beispiel.".

UpperCase/LowerCase

Verwendung: Umwandeln einer Zeichenkette in Großbuchstaben/Kleinbuchstaben.
Parameter: string
Rückgabe: string
Beispiel:

cText  := 'Beispiel';
cUpper := UpperCase(cText);
cLower := LowerCase(cText);

Erklärung: Der String-Variable cText wird der Wert Beispiel zugewiesen. Mit UpperCase und LowerCase wird die Zeichenkette umgewandelt. cUpper enthält danach den Wert BEISPIEL und cLower den Wert beispiel.

ExtractFileName

Verwendung: Dateinamen aus Dateipfad auslesen.
Parameter: string
Rückgabe: string
Beispiel:

cDatei := 'c:\\Ordner\Datei.txt';
cDatei := ExtractFileName(cDatei);

Erklärung: Der String-Variable cDatei wird der Wert c:\\Ordner\Datei.txt zugewiesen. Mit ExtractFileName wird der Dateiname herausgesucht und zurückgegeben. Danach enthält cDatei nur noch den Wert Datei.txt.

StrTran

Verwendung: Sucht einen Text innerhalb eines Textes und ersetzte diesen durch einen andren Text (Suchen und ersetzen).
Parameter: string, string, string
Rückgabe: string
Beispiel:

cDatei := 'Datei.txt';
cName  := StrTran(cDatei ,'.txt','');

Erklärung: Der String-Variable cDatei wird der Wert Datei.txt zugewiesen. Mit StrTran wird im Text der Variable cDatei nach .txt gesucht. Der gefundene Teil wird mit einer leeren Zeichenkette ersetzt. Danach enthält cDatei nur noch den Wert Datei.

LeftStr/RightStr

Verwendung: Gibt den linken/rechten Teil einer Zeichenketten zurück. Es werden dabei maximal soviele Zeichen zurückgegeben, wie im zweiten Parameter angegeben.
Parameter: string, integer
Rückgabe: string
Beispiel:

cText  := 'Dies ist ein Beispiel';
cLeft  := LeftStr(cText,2);
cRight := RightStr(cText,5);

Erklärung: Der String-Variable cText wird der Wert Dies ist ein Beispiel zugewiesen. Mit LeftStr und RightStr werden jeweils die ersten zwei Zeichen von Links und Rechts zurückgegeben. cLeft enthält danach den Wert Di und cRight den Wert spiel.

HINWEIS: Sollten mehr Zeichen ermittelt werden, als der ursprüngliche Wert Zeichen hat, so ist das Ergbenis gleich dem Ursprung. LeftStr(cDatei,50) hätte z. B. dazu geführt, dass cLeft ebenfalls Dies ist ein Beispiel enthält.

Token

Verwendung: Teilt eine Zeichenkette anhand eines Zeichens auf und gibt den engebenen Teil zurück.
Parameter: string, string, integer
Rückgabe: string
Beispiel:

cDatei := 'Datei_Name_Mit_Unterstrichen.txt';
cTeil  := Token(cDatei,'_',2);

Erklärung: Der String-Variable cDatei wird der Wert Datei_Name_Mit_Unterstrichen.txt zugewiesen. Mit Token wird die Zeichenkette aufgeteilt. Als Teiler ist ein Unterstrich angeben. Dies führt im angegebenen Beispiel zu vier Teilen: Datei, Name, Mit und Unterstrichen.txt. Es wird der zweite Teil gefordert. Die Variable cTeil enthält demnach den Wert Name.

NumToken

Verwendung: Ermittelt die Anzahl der Teile einer Zeichenketten, wenn diese an den Stelle mit dem Zeichen, das als Parameter übergeben wird, geteilt wird.
Parameter: string, string
Rückgabe: integer
Beispiel:

cDatei := 'Datei_Name_Mit_Unterstrichen.txt';
nTeile := NumToken('_',cDatei);

Erklärung: Der String-Variable cDatei wird der Wert Datei_Name_Mit_Unterstrichen.txt zugewiesen. Mit NumToken wird die Anzahl der Teil-Zeichenketten der Zeichenkette cDatei ermittelt. Als Trennzeichen wurde ein Unterstrich angegeben. Dies führt im angegebenen Beispiel zu vier Teilen: Datei, Name, Mit und Unterstrichen.txt. Die Variable nTeile entspricht also dem Wert 4.

iVal

Verwendung: Wandelt die angegebene Zeichenkette in einen Ganzzahlwert um.
Parameter: string
Rückgabe: integer
Beispiel:

cZahl := '4';
nZahl := iVal(cZahl);

Erklärung: Der String-Variable cZahl wird der Wert 4 zugewiesen. Mit iVal wird die Zeichenkette in die entsprechende Ganzzahl umgewandelt. Die Variable nZahl entspricht also dem Wert 4.

fVal

Verwendung: Wandelt die angegebene Zeichenkette in eine Dezimalzahl um.
Parameter: string
Rückgabe: double
Beispiel:

cZahl := '1234,56';
nZahl := fVal(cZahl);

Erklärung: Der String-Variable cZahl wird der Wert 1234,56 zugewiesen. Mit fVal wird die Zeichenkette in die entsprechende Dezimalzahl umgewandelt. Die Variable nZahl entspricht also dem Wert 1234,56.

Roundy

Verwendung: Runden eines Dezimalwerts (Typ: Double)
Parameter: double, integer
Rückgabe: double
Aufruf:

nDezimalwert := 1234.5678;
nGerundeterWert := Roundy(nDezimalwert,2);

Erklärung: Der zu rundende Wert wird mit Parameter 1 übergeben. Die gewünschte Anzahl an Nachkommastellen wird in Parameter 2 angegeben. Die Funktion rundet dann den Wert auf die angegebene Anzahl an Dezimalstellen und gibt das Ergebnis wieder zurück. Die Variable nDezimalwert wird auf den Wert 1234,5678 gesetzt. Anschließend wird der Wert auf zwei Nachkommastellen gerundet. Die Variable nGerundeterWert entspricht also 1234,57.

Trunc

Verwendung: Abschneiden der Nachkommastellen eines Dezimalwerts
Parameter: double
Rückgabe: integer
Aufruf:

nDezimalwert := 1234.5678;
nWert := Trunc(nDezimalwert);

Erklärung: Der Dezimalwert ist als Parameter zu übergeben. Als Ergbnis werden die Vorkommastellen zurückgegeben. Die Variable nDezimalwert wird auf den Wert 1234,5678 gesetzt. Anschließend wird der Wert auf zwei Nachkommastellen gerundet. Die Variable nWert entspricht also 1234.