|
|
In diesem Abschnitt werden (in alphabetischer Reihenfolge) die in der
Bartels User Language definierten Standard-Systemfunktionen beschrieben. Beachten Sie bitte die Konventionen zur Funktionsbeschreibung in
Anhang C.1.
abs - Absolutwert eines Ganzzahlwertes (STD)
Synopsis
int abs( // Berechnungsergebnis
int; // Eingabewert
);
Beschreibung
Der Rückgabewert der Funktion
abs entspricht dem Absolutwert des übergebenen Ganzzahlwertes.
acos - Arcuscosinus berechnen (STD)
Synopsis
double acos( // Berechnungsergebnis (STD3)
double [-1.0,1.0]; // Cosinus-Wert
);
Beschreibung
Der Rückgabewert der Funktion
acos entspricht dem Arcuscosinus des übergebenen Gleitkommawertes. Der Winkel wird in Bogenmaßeinheiten angegeben.
angclass - Winkelklassifizierung (STD)
Synopsis
int angclass( // Winkelklasse
double; // Winkel (STD3)
);
Beschreibung
Der Rückgabewert der Funktion
angclass gibt die Winkelklasse eines Winkels an. Mögliche Klassenwerte sind 0 für 0 Grad Winkel, 1 für einen 90 Grad Winkel, 2 für einen 180 Grad Winkel, 3 für einen 270 Grad Winkel und (-1) für andere Winkel. Der übergebene Gleitkommawert wird als Bogenmaßangabe interpretiert.
arylength - Arraylänge bestimmen (STD)
Synopsis
int arylength( // Feldlänge
void; // Array beliebigen Typs
);
Beschreibung
Der Rückgabewert der Funktion
arylength entspricht der Länge des übergebenen Arrays.
asin - Arcussinus berechnen (STD)
Synopsis
double asin( // Berechnungsergebnis (STD3)
double [-1.0,1.0]; // Sinus-Wert
);
Beschreibung
Der Rückgabewert der Funktion
asin entspricht dem Arcussinus des übergebenen Gleitkommawertes. Der Winkel wird in Bogenmaßeinheiten angegeben.
askcoord - Benutzereingabe X-/Y-Koordinatenwerte (STD)
Synopsis
int askcoord( // Status
& double; // Rückgabe X-Koordinate (STD2)
& double; // Rückgabe Y-Koordinate (STD2)
int [0,1]; // Eingabemodus:
// 0 = Koordinaten relativ zu letzter Position
// 1 = Koordinaten absolut
);
Beschreibung
Die Funktion
askcoord aktiviert einen Dialog zur Abfrage von X- und Y-Koordinatenwerten. Der Eingabemodus gibt an, ob Relativkoordinaten
() oder Absolutkoordinaten
() abgefragt werden sollen. Die eingegebenen Koordinatenwerte werden über die ersten beiden Funktionsparameter an den Aufrufer zurückgegeben. Bei der Abfrage von Absolutkoordinaten fungieren diese Parameter auch als Eingabeparameter für voreingestellte Koordinatenwerte. Der Funktionsrückgabewert ist Null bei erfolgreicher Koordinateneingabe oder ungleich Null wenn die Koordinateneingabe abgebrochen wurde.
askdbl - Benutzereingabe Gleitkommazahlwert (STD)
Synopsis
int askdbl( // Status
& double; // Rückgabe Gleitkommawert
string; // Eingabeaufforderung
int; // Maximale Eingabelänge
);
Beschreibung
Die Funktion
askdbl fordert den Benutzer in der Eingabezeile mit der übergebenen Promptzeichenkette zur Eingabe eines Gleitkommawertes auf. Der vom Benutzer eingegebene Wert wird im Rückgabeparameter zurückgegeben. Ein Funktionsrückgabewert ungleich Null gibt an, dass kein gültiger Gleitkommawert eingegeben wurde.
askdist - Benutzereingabe Distanzwert (STD)
Synopsis
int askdist( // Status:
// -1 = Eingabe ungültig/abgebrochen
// 0 = Gültige Distanzwerteingabe
// 1 = Gültige Distanzwerteingabe,
// Eckpunktschaltfläche gedrückt
& double; // Rückgabe Distanzwert
string; // Eingabeaufforderung
int [0,15]; // Eingabekontrolle:
// 1 = Negative Werte zulässig
// 2 = Kreisbögen zulässig
// 4 = Eingabeaufferdoerung für Zeichenketten
// 8 = Schaltfläche für runde Ecken
);
Beschreibung
Die Funktion
askdist fordert den Benutzer in der Eingabezeile mit der übergebenen Promptzeichenkette zur Eingabe eines Distanzwertes auf. Der vom Benutzer eingegebene Wert wird im Default-User-Einheitensystem interpretiert und im Rückgabeparameter in der Einheit Meter zurückgegeben. Der dritte Parameter dient der Konfiguration der zulässigen Eingaben. Der Funktionsrückgabewert ergibt sich zu Null wenn ein gültiger Distanzwert eingegeben wurde, 1 bei erfolgreicher Distanzwerteingabe mit gedrückter Eckpunktschaltfläche, oder (-1) wenn die kein gütiger Wert eingegeben bzw. die Eingabe abgebrochen wurde.
askint - Benutzereingabe Ganzzahlwert (STD)
Synopsis
int askint( // Status
& int; // Rückgabe Ganzzahlwert
string; // Eingabeaufforderung
int; // Maximale Eingabelänge
);
Beschreibung
Die Funktion
askint fordert den Benutzer in der Eingabezeile mit der übergebenen Promptzeichenkette zur Eingabe eines Ganzzahlwertes auf. Der vom Benutzer eingegebene Wert wird im Rückgabeparameter zurückgegeben. Ein Funktionsrückgabewert ungleich Null gibt an, dass keine gültiger Ganzzahlwert eingegeben wurde.
askstr - Benutzereingabe Zeichenkette (STD)
Synopsis
string askstr( // Zeichenkette
string; // Eingabeaufforderung
int; // Maximale Eingabelänge
);
Beschreibung
Die Funktion
askstr fordert den Benutzer in der Eingabezeile mit der übergebenen Promptzeichenkette zur Eingabe einer Zeichenkette auf. Der Rückgabewert dieser Funktion entspricht der vom Benutzer eingegebenen Zeichenkette.
atan - Arcustangens berechnen (STD)
Synopsis
double atan( // Berechnungsergebnis
double; // Winkel (STD3)
);
Beschreibung
Der Rückgabewert der Funktion
atan entspricht dem Arcustangens des übergebenen Gleitkommawertes. Der Winkel wird in Bogenmaßeinheiten angegeben.
atan2 - Arcustangens eines punktbestimmten Winkels (STD)
Synopsis
double atan2( // Berechnungsergebnis (STD3)
double; // Y-Koordinate
double; // X-Koordinate
);
Beschreibung
Der Rückgabewert der Funktion
atan2 entspricht dem Winkel, den die Ursprungshalbgerade durch den angegebenen Punkt mit der positiven X-Achse einschließt. Der Winkel wird in Bogenmaßeinheiten angegeben.
atof - Umwandlung Zeichenkette in Gleitkommazahlwert (STD)
Synopsis
double atof( // Gleitkommawert
string; // Zeichenkette
);
Beschreibung
Der Rückgabewert der Funktion
atof entspricht dem Gleitkommawert, der in der übergebenen Zeichenkette in ASCII-Darstellung angegeben ist.
atoi - Umwandlung Zeichenkette in Ganzzahlwert (STD)
Synopsis
int atoi( // Ganzzahlwert
string; // Zeichenkette
);
Beschreibung
Der Rückgabewert der Funktion
atoi entspricht dem Ganzzahlwert, der in der übergebenen Zeichenkette in ASCII-Darstellung angegeben ist.
bae_askddbename - DDB-Elementnamensabfrage (STD)
! prefix save else load, empty if std. message
Synopsis
int bae_askddbename( // Status
& string; // Rückgabe Elementname
string; // Dateiname
int ]0,[; // Elementklasse (STD1)
string; // Eingabeaufforderung
// Leerstring: Standarddateidialog
// !-Präfix: Dateisicherungsdialog
// sonst: Dateiladedialog
);
Beschreibung
Die Funktion
bae_askddbename erlaubt dem Benutzer einen DDB-Datei Elementnamen wahlweise mit der Maus in einem Popupauswahlfenster aus der Liste der vorhandenen Elemente zu selektieren oder per Tastatur in der Eingabezeile einzugeben. Wird für die Eingabeaufforderung ein Leerstring angegeben, so wird der Standardprompt für DDB-Elementnamensabfragen verwendet. Über den ersten Parameter kann ein Name übergeben werden, der in der Abfrage als Vorauswahl erscheint, d.h. wenn keine Vorauswahl möglich bzw. erlaubt ist, dann ist ein Leerstring zu übergeben. Der Rückgabewert ist ungleich Null, wenn kein gültiges Element gewählt wurde.
bae_askddbfname - DDB-Dateinamensabfrage (STD)
Synopsis
int bae_askddbfname( // Status
& string; // Rückgabe Dateiname
int [0,3]; // Modus Dateinamensdialog (Bitmuster):
// 1 = Prüfen, ob Datei existiert
// 2 = angegebener Dateiname ist Default
string; // Eingabeaufforderung
// Leerstring: Standarddateidialog
// !-Präfix: Dateisicherungsdialog
// sonst: Dateiladedialog
);
Beschreibung
Die Funktion
bae_askddbfname erlaubt dem Benutzer einen DDB-Dateinamen wahlweise mit der Maus in einem Popupauswahlfenster aus der Liste der vorhandenen DDB-Dateien zu selektieren oder per Tastatur in der Eingabezeile einzugeben. Wird für die Eingabeaufforderung ein Leerstring angegeben, dann wird der BAE-Standardprompt für DDB-Dateinamensabfragen verwendet. Ist das erste Zeichen der Eingabeaufforderung ein Ausrufezeichen
(!), dann wird dieses ausgeblendet, und unter Windows wird im Dateiabfragedialog anstelle des Bestätigungsbuttons
der Button
angezeigt. Der Rückgabewert ist ungleich Null, wenn kein gültiger DDB-Dateiname gewählt wurde bzw. die Existenzprüfung auf eins gesetzt ist und die angegebene Datei nicht existiert.
bae_askdirname - Dateiverzeichnisnamensabfrage (STD)
Synopsis
int bae_askdirname( // Status
& string; // Rückgabe Dateiverzeichnisname
string; // Startverzeichnispfad
string; // Eingabeaufforderung
);
Beschreibung
Die Funktion
bae_askdirname erlaubt dem Benutzer einen Dateiverzeichnisnamen wahlweise mit der Maus in einem Popupauswahlfenster aus der Liste der vorhandenen Verzeichnisse zu selektieren oder per Tastatur in der Eingabezeile einzugeben. Der Startverzeichnispfad gibt das Verzeichnis an ab dem im Popupauswahlfenster Unterverzeichnisse angezeigt werden. Wird für die Eingabeaufforderung ein Leerstring angegeben, so wird der Standardprompt für Dateiverzeichnisabfragen verwendet. Der Rückgabewert ist ungleich Null, wenn kein gültiger Verzeichnisname gewählt wurde.
bae_askfilename - Dateinamensabfrage (STD)
Synopsis
int bae_askfilename( // Status
& string; // Rückgabe Dateiname
string; // Dateinamensendung
string; // Eingabeaufforderung
// Leerstring: Standarddateidialog
// !-Präfix: Dateisicherungsdialog
// sonst: Dateiladedialog
);
Beschreibung
Die Funktion
bae_askfilename aktiviert einen Dialog zur Dateinamensabfrage. Über den Parameter für die Dateinamensendung kann ein Dateinamensfilter gesetzt werden. Ein Leerstring bewirkt die Anzeige aller verfügbaren Dateien. Bei Angabe einer Dateinamenserweiterung (z.B.
.ddb,
.dat,
.txt,
.,
.*, usw.) werden nur die Dateien mit der angegebenen Endung angezeigt. Bei Eingabe eines Minuszeichens
(-) für die Dateinamenserweiterung werden alle Dateien mit BAE-System- bzw. Datendateiendungen
(.ass,
.con,
.ddb,
.def,
.exe,
.fre,
.ulc und
.usf) aus dem Dateinamensmenü ausgeblendet (dieser Mechanismus eignet sich insbesondere für Ausgabe- bzw. Plotdateiabfragen, bei welchen keine System-, Bibliotheks- oder Projektdateien selektiert werden dürfen). Wird für die Eingabeaufforderung ein Leerstring angegeben, dann wird der BAE-Standardprompt für Dateinamensabfragen verwendet. Ist das erste Zeichen der Eingabeaufforderung ein Ausrufezeichen
(!), dann wird dieses ausgeblendet, und unter Windows wird im Dateiabfragedialog anstelle des Bestätigungsbuttons
der Button
angezeigt. Der Rückgabewert ist ungleich Null, wenn kein gültiger Dateiname gewählt wurde.
bae_askmenu - BAE Menüabfrage (STD)
Synopsis
int bae_askmenu( // Rückgabe selektierter Menüeintrag, (0..49)
// oder (-1) bei Abbruch der Menüauswahl
int [1,50]; // Anzahl Menüeinträge
string; // Menütext erster Menüeintrag
[] // Weitere Menütexte
);
Beschreibung
Die Funktion
bae_askmenu ermöglicht die Definition und Aktivierung eines anwenderspezifischen Menüs mit mausselektierbaren Menüeinträgen. Der Rückgabewert gibt den vom Benutzer gewählten Menüeintrag an oder ergibt sich zu (-1), wenn die Menüauswahl abgebrochen wurde. Die Nummerierung der Menüeinträge beginnt bei Null.
Siehe auch
Funktion bae_defmenusel.
bae_askname - BAE Dialog zur Namensauswahl aktivieren (STD)
Synopsis
int bae_askname( // Status
& string; // Rückgabe selektierter Name
string; // Eingabeaufforderung (oder Leerstring)
int; // Maximale Eingabestringlänge
);
Beschreibung
Die Funktion
bae_askname aktiviert einen Dialog zur Selektion eines Namens aus der aktuell mit
bae_nameadd definierten Namensliste.
Über den zweiten Funktionsparameter kann eine anwendungsspezifische Eingabeaufforderung angegeben werden. Wird hierfür ein Leerstring angegeben, dann benutzt
bae_askname einen vordefinierten Standardprompt.
Der dritte Funktionsparameter definiert die maximal zulässige Stringlänge für die Benutzereingabe.
Bei erfolgter Namensauswahl wird der selektierte Name im ersten Funktionsparameter zurückgegeben.
Der Funktionsrückgabewert ergibt ist Null bei erfolgreicher Namensselektion oder ungleich Null wenn die Funktion ohne Namensselektion abgebrochen wurde.
Siehe auch
Funktionen bae_nameadd,
bae_nameclr,
bae_nameget.
bae_asksymname - BAE DDB-Bibliothekselementabfrage (STD)
Synopsis
int bae_asksymname( // Status
& string; // Rückgabe Elementname
& string; // Rückgabe DDB-Bibliotheksdateiname
int ]0,[; // Datenbankklasse (STD1)
string; // Bibliotheksverzeichnis
string; // Standard-Bibliotheksdateiname
string; // Standard-Symbol-/Elementname
);
Beschreibung
Die Funktion
bae_asksymname aktiviert einen Dialog zur Auswahl eines Bibliothekselements der angegeben Datenbankklasse aus einer selektierbaren Bibliotheksdatei. Der Funktionsrückgabewert ist Null bei erfolgreicher Auswahl oder ungleich Null wenn der Anwender den Dialog ohne gültige Elementauswahl beendet.
bae_callmenu - BAE Menüfunktion aufrufen (STD)
Synopsis
int bae_callmenu( // Status
int [0,9999]; // Menüfunktion (STD4)
);
Beschreibung
Die Funktion
bae_callmenu aktiviert die angegebene Menüfunktion. Der Rückgabewert ist ungleich Null, wenn bei der Ausführung der Menüfunktion ein Fehler aufgetreten ist oder eine ungültige bzw. unbekannte Menüfunktion spezifiziert wurde.
bae_charsize - BAE Text-/Zeichengröße abfragen (STD)
Synopsis
void bae_charsize(
& double; // Rückgabe Zeichenbreite (Pixelanzahl)
& double; // Rückgabe Zeichenhöhe (Pixelanzahl)
);
Beschreibung
Die Funktion
bae_charsize gibt in den beiden Parametern die aktuell im
AutoEngineer eingestellte Text- bzw. Zeichengröße, d.h. die Pixelanzahl pro Zeichen in X- bzw. Y-Richtung zurück.
bae_cleardistpoly - Internes BAE Distanzabfragepolygon löschen (STD)
Synopsis
void bae_cleardistpoly(
);
Beschreibung
Die Funktion
bae_cleardistpoly löscht das mit
bae_storedistpoly erzeugte Distanzabfragepolygon.
Siehe auch
Funktion
bae_storedistpoly.
bae_clearpoints - BAE Polygonpunktliste löschen (STD)
Synopsis
void bae_clearpoints(
);
Beschreibung
Die Funktion
bae_clearpoints löscht die zum Aufbau von Polygonen verwendete interne Punktliste. Dies ist prinzipiell vor dem ersten Aufruf von
bae_storepoint zum Aufbau einer Punktliste notwendig um evtl. vorhandene alte Punkte zu löschen.
Siehe auch
Funktionen
bae_getpolyrange,
bae_storedistpoly,
bae_storepoint.
bae_clriactqueue - BAE Interaktionsvorgaben löschen (STD)
Synopsis
void bae_clriactqueue(
);
Beschreibung
Die Funktion
bae_clriactqueue löscht die in der Interaktionsqueue gespeicherten Vorgaben. Die Interaktionsqueue dient dazu, die Benutzereingaben für die über die Funktion
bae_callmenu aufgerufenen Menüfunktionen ganz oder teilweise vorzugeben.
bae_crossarcarc - Schnittpunkt(e) zwischen Kreisbögen bestimmen (STD)
Synopsis
int bae_crossarcarc( // Anzahl Schnittpunkte
double; // Kreisbogen 1 Start X-Koordinate (STD2)
double; // Kreisbogen 1 Start Y-Koordinate (STD2)
double; // Kreisbogen 1 Mittelpunkt X-Koordinate (STD2)
double; // Kreisbogen 1 Mittelpunkt Y-Koordinate (STD2)
int [1,2]; // Kreisbogen 1 Mittelpunkt Typ (STD15)
double; // Kreisbogen 1 Endpunkt X-Koordinate (STD2)
double; // Kreisbogen 1 Endpunkt Y-Koordinate (STD2)
double; // Kreisbogen 2 Startpunkt X-Koordinate (STD2)
double; // Kreisbogen 2 Startpunkt Y-Koordinate (STD2)
double; // Kreisbogen 2 Mittelpunkt X-Koordinate (STD2)
double; // Kreisbogen 2 Mittelpunkt Y-Koordinate (STD2)
int [1,2]; // Kreisbogen 2 Mittelpunkt Typ (STD15)
double; // Kreisbogen 2 Endpunkt X-Koordinate (STD2)
double; // Kreisbogen 2 Endpunkt Y-Koordinate (STD2)
& double; // Schnittpunkt 1 X-Koordinate (STD2)
& double; // Schnittpunkt 1 Y-Koordinate (STD2)
& double; // Schnittpunkt 2 X-Koordinate (STD2)
& double; // Schnittpunkt 2 Y-Koordinate (STD2)
);
Beschreibung
Die Funktion
bae_crossarcarc führt eine Schnittpunktbestimmung für die beiden angegebenen Kreisbögen durch. Der Funktionsrückgabewert gibt die Anzahl der Schnittpunkte an (0, 1 oder 2). Die ermittelten Schnittpunktkoordinaten werden ggf. in den entsprechenden Funktionsparametern zurückgegeben.
Siehe auch
Funktionen bae_crosslineline,
bae_crosslinepoly,
bae_crosssegarc,
bae_crosssegseg.
bae_crosslineline - Schnittpunkt zwischen Liniensegmenten mit Breite bestimmen (STD)
Synopsis
int bae_crosslineline( // Schnittflag
double; // Linie 1 Start X-Koordinate (STD2)
double; // Linie 1 Start Y-Koordinate (STD2)
double; // Linie 1 Endpunkt X-Koordinate (STD2)
double; // Linie 1 Endpunkt Y-Koordinate (STD2)
double ]0.0,[; // Linie 1 Breite (STD2)
double; // Linie 2 Start X-Koordinate (STD2)
double; // Linie 2 Start Y-Koordinate (STD2)
double; // Linie 2 Endpunkt X-Koordinate (STD2)
double; // Linie 2 Endpunkt Y-Koordinate (STD2)
double ]0.0,[; // Linie 2 Breite (STD2)
);
Beschreibung
Die Funktion
bae_crosslineline prüft ob sich die beiden angegebenen Liniensegmente schneiden. Der Funktionsrückgabewert ist 1 wenn sich die Segmente schneiden oder Null andernfalls.
Siehe auch
Funktionen bae_crossarcarc,
bae_crosslinepoly,
bae_crosssegarc,
bae_crosssegseg.
bae_crosslinepoly - Schnittpunkt zwischen Liniensegment mit Breite und Polygon bestimmen (STD)
Synopsis
int bae_crosslinepoly( // Schnittflag
double; // Linie Start X-Koordinate (STD2)
double; // Linie Start Y-Koordinate (STD2)
double; // Linie Endpunkt X-Koordinate (STD2)
double; // Linie Endpunkt Y-Koordinate (STD2)
double ]0.0,[; // Linie Breite (STD2)
);
Beschreibung
Die Funktion
bae_crosslinepoly prüft ob das angegebene Liniensegmente das mit
bae_storepoint aktuell erzeugte Polygon schneidet.
schneiden. Der Funktionsrückgabewert ist 1 wenn sich das Liniensegmente mit dem Polygon schneidet oder Null andernfalls.
Siehe auch
Funktionen bae_crossarcarc,
bae_crosslineline,
bae_crosssegarc,
bae_crosssegseg,
bae_storepoint.
bae_crosssegarc - Schnittpunkt zwischen Liniensegment und Kreisbogen bestimmen (STD)
Synopsis
int bae_crosssegarc( // Anzahl Schnittpunkte
double; // Segment Start X-Koordinate (STD2)
double; // Segment Start Y-Koordinate (STD2)
double; // Segment Endpunkt X-Koordinate (STD2)
double; // Segment Endpunkt Y-Koordinate (STD2)
double; // Kreisbogen Start X-Koordinate (STD2)
double; // Kreisbogen Start Y-Koordinate (STD2)
double; // Kreisbogen Mittelpunkt X-Koordinate (STD2)
double; // Kreisbogen Mittelpunkt Y-Koordinate (STD2)
int [1,2]; // Kreisbogen Mittelpunkt Typ (STD15)
double; // Kreisbogen Endpunkt X-Koordinate (STD2)
double; // Kreisbogen Endpunkt Y-Koordinate (STD2)
int [0,1]; // Schnittpunktprioritätsflag
& double; // Schnittpunkt 1 X-Koordinate (STD2)
& double; // Schnittpunkt 1 Y-Koordinate (STD2)
& double; // Schnittpunkt 2 X-Koordinate (STD2)
& double; // Schnittpunkt 2 Y-Koordinate (STD2)
);
Beschreibung
Die Funktion
bae_crosssegarc führt eine Schnittpunktbestimmung für das angegebene Segment und den angegebenen Kreisbogen durch. Der Funktionsrückgabewert gibt die Anzahl der Schnittpunkte an (0, 1 oder 2). Die ermittelten Schnittpunktkoordinaten werden ggf. in den entsprechenden Funktionsparametern zurückgegeben.
Siehe auch
Funktionen bae_crossarcarc,
bae_crosslineline,
bae_crosslinepoly,
bae_crosssegseg.
bae_crosssegseg - Schnittpunkt zwischen Liniensegmenten/Linien bestimmen (STD)
Synopsis
int bae_crosssegseg( // Schnittflag
int [0,1]; // Geradenvergleichsflag
double; // Linie 1 Start X-Koordinate (STD2)
double; // Linie 1 Start Y-Koordinate (STD2)
double; // Linie 1 Endpunkt X-Koordinate (STD2)
double; // Linie 1 Endpunkt Y-Koordinate (STD2)
double; // Linie 2 Start X-Koordinate (STD2)
double; // Linie 2 Start Y-Koordinate (STD2)
double; // Linie 2 Endpunkt X-Koordinate (STD2)
double; // Linie 2 Endpunkt Y-Koordinate (STD2)
& double; // Schnittpunkt X-Koordinate (STD2)
& double; // Schnittpunkt Y-Koordinate (STD2)
);
Beschreibung
Die Funktion
bae_crosssegseg prüft ob sich die beiden angegebenen Segmente bzw. Geraden schneiden. Der erste Funktionsparameter gibt an ob ein Geraden- oder ein Streckenvergleich durchgeführt werden soll. Der Funktionsrückgabewert ist 1 wenn ein Schnittpunkt ermittelt wurde oder Null andernfalls. Wenn ein Schnittpunkt ermittelt werden konnte, dann werden dessen Koordinaten über die letzten beiden Funktionsparameter zurückgegeben.
Siehe auch
Funktionen bae_crossarcarc,
bae_crosslineline,
bae_crosslinepoly,
bae_crosssegarc.
bae_dashpolyline - Gestricheltes BAE Polygon vektorisieren (STD)
Synopsis
int bae_dashpolyline( // Status
int; // Polygonstrichelungsmodus:
// 0 = durchgezogene Linie (keine Strichelung)
// 1 = gestrichelte Linie
// 2 = gepunktete Linie
// 3 = gestrichelte/gepunktete Linie
double ]0.0,[; // Polygonbasisstrichlänge (STD2)
double ]-0.5,0.5[; // Relativer Polygonstrichabstand
* int; // Polygonlinienscanfunktion
* int; // Polygonbogenscanfunktion
);
Beschreibung
Die Funktion
bae_dashpolyline vektorisiert das zuvor mit
bae_storepoint gespeicherte interne Polygon unter Berücksichtigung der spezifizierten Strichelungsparameter. Die Polygonlinienscanfunktion und die Polygonbogenscanfunktion werden jeweils automatisch für die im Polygon enthaltenen Linien bzw. Bögen aufgerufen. Der Funktionsrückgabewert ist Null bei erfolgreicher Vektorisierung oder ungleich Null im Fehlerfall bzw. wenn die Vektorisierung abgebrochen wurde.
Polygonlinienscanfunktion
int polylinescanfuncname(
double xs, // Linienstartpunkt X-Koordinate (STD2)
double ys, // Linienstartpunkt Y-Koordinate (STD2)
double xe, // Linienendpunkt X-Koordinate (STD2)
double ye // Linienendpunkt Y-Koordinate (STD2)
)
{
// Polygon line scan function statements
:
return(status);
}
Die Polygonlinienscanfunktion sollte den Wert Null zurückgeben wenn die Abarbeitung erfolgreich war. Im anderen Fall (bei Fehlern bzw. zum Abbruch des Scans) sollte ein Wert ungleich Null zurückgegeben werden.
Polygonbogenscanfunktion
int polylinescanfuncname(
double xs, // Bogenstartpunkt X-Koordinate (STD2)
double ys, // Bogenstartpunkt Y-Koordinate (STD2)
double xe, // Bogenendpunkt X-Koordinate (STD2)
double ye // Bogenendpunkt Y-Koordinate (STD2)
double xc, // Bogenmittelpunkt X-Koordinate (STD2)
double yc // Bogenmittelpunkt Y-Koordinate (STD2)
int cwflag; // Bogendrehrichtung:
// 0 = Bogen im Gegenuhrzeigersinn
// sonst = Bogen im Uhrzeigersinn
)
{
// Polygon arc scan function statements
:
return(status);
}
Die Polygonbogenscanfunktion sollte den Wert Null zurückgeben wenn die Abarbeitung erfolgreich war. Im anderen Fall (bei Fehlern bzw. zum Abbruch des Scans) sollte ein Wert ungleich Null zurückgegeben werden.
Siehe auch
Funktionen
bae_clearpoints,
bae_storepoint.
bae_deffuncprog - BAE Funktionstaste programmieren (STD)
Synopsis
int bae_deffuncprog( // Status
int [1,128]; // Funktionstastennummer
string; // User Language-Programmname oder
// # gefolgt von Menünummer (STD4)
);
Beschreibung
Die Funktion
bae_deffuncprog ordnet einer Funktionstaste das namentlich angegebene
User Language-Programm bzw. die numerisch spezifizierte BAE-Menüfunktion zu. Durch die Spezifikation eines Leerstrings für den Programmnamen kann die aktuelle Zuordnung zurückgesetzt werden. Der Rückgabewert ist ungleich Null, wenn ungültige Parameter übergeben wurden, oder wenn die zurückzusetzende Funktionstaste nicht belegt ist.
Siehe auch
Funktionen
bae_getfuncprog,
bae_resetmenuprog.
bae_defkeyprog - BAE Standardtaste programmieren (STD)
Synopsis
int bae_defkeyprog( // Status
int; // Tastenzeichen
string; // User Language-Programmname oder
// # gefolgt von Menünummer (STD4)
);
Beschreibung
Die Funktion
bae_defkeyprog ordnet einer Standardtaste das namentlich angegebene
User Language-Programm bzw. die numerisch spezifizierte BAE-Menüfunktion zu. Durch die Spezifikation eines Leerstrings für den Programmnamen kann die aktuelle Zuordnung zurückgesetzt werden. Der Rückgabewert ist ungleich Null, wenn ungültige Parameter übergeben wurden, oder wenn die zurückzusetzende Standardtaste nicht belegt ist.
Siehe auch
Funktionen
bae_getkeyprog,
bae_resetmenuprog.
bae_defmenu - BAE Menüdefinition starten (STD)
Synopsis
int bae_defmenu( // Status
int [0,999]; // Menücode
int [0,999]; // Menübereichscode:
// 1 = Hauptmenü
// 101 = erstes Untermenü
// 102 = zweites Untermenü
// : = : Untermenü
);
Beschreibung
Die Funktion
bae_defmenu startet die Definition eines Standardmenüs im aktuell aktiven BAE-Modul. Der Rückgabewert der Funktion
bae_defmenu ist (-1), wenn ein Fehler aufgetreten ist oder Null andernfalls. Im Anschluss an den Aufruf der Funktion
bae_defmenu sollten durch wiederholten Aufruf der Funktion
bae_defmenutext die einzelnen Menüeinträge definiert werden. Die mit
bae_defmenu eingeleitete Menüdefinition muss durch einen Aufruf der Funktion
bae_endmenu beendet werden. Mit der Funktion
bae_resetmenuprog können sämtliche Menübelegungen wieder zurückgesetzt werden.
Siehe auch
Funktionen
bae_defmenuprog,
bae_defmenutext,
bae_endmenu,
bae_redefmenu,
bae_resetmenuprog.
bae_defmenuprog - BAE Menüfunktion programmieren (STD)
Synopsis
int bae_defmenuprog( // Selectionscode or (-1) on error
int [0,999]; // Menünummer
int [0,99]; // Menüzeile
string; // Menütext
string; // User Language-Programmname oder
// # gefolgt von Menünummer (STD4)
int; // Menüeintrag Bearbeitungsschlüssel:
// 8000000h = immer aktivierbar
// 7FFFFFFh = für jeden Elementtyp
// aktivierbar
// sonstige = (kombinierter)
// DDB-Klassen-Schlüssel
);
Beschreibung
Die Funktion
bae_defmenuprog ordnet einem Menüeintrag den spezifizierten Menütext sowie das namentlich angegebene
User Language-Programm bzw. die numerisch spezifizierte BAE-Menüfunktion zu. Die Menünummer gibt die Nummer des Hauptmenüs an, die Menüzeile die Position im zugehörigen Submenü. Durch die Spezifikation eines Leerstrings für den Programmnamen kann die aktuelle Zuordnung zurückgesetzt werden. Der Bearbeitungsschlüssel dient der Konfiguration von sogenannten Ghostmenüs. Hierfür ist ein kodierter Integerwert einzutragen, wie er mit den Funktionen
bae_getclassbitfield oder
bae_getmenubitfield ermittelt bzw. definiert werden kann (im Zweifelsfall empfiehlt sich die Verwendung des Hexadezimalwertes 80000000h, um sicherzustellen, dass die Funktion immer aktivierbar ist). Der Rückgabewert der Funktion
bae_defmenuprog ist ungleich Null, wenn ungültige Parameter übergeben wurden, oder wenn der zurückzusetzende Menüeintrag nicht belegt ist.
Siehe auch
Funktionen
bae_getclassbitfield,
bae_getmenubitfield,
bae_getmenuprog,
bae_getmenutext,
bae_redefmenu,
bae_resetmenuprog.
bae_defmenusel - BAE Menüabfrage Vorauswahl (STD)
Synopsis
void bae_defmenusel(
int [-1,29]; // Menüindex
// oder (-1) für Selektionstextspeicher
);
Beschreibung
Die Funktion
bae_defmenusel setzt die Vorauswahl bzw. Selektionsanzeige für den nächsten Aufruf von
bae_askmenu. Damit lässt sich in Auswahlmenüs die aktuell selektierte Option kennzeichnen. In den BAE-Windowsversionen erfolgt die Selektionsmarkierung durch ein Häkchen, in den Motifversionen durch Grauunterlegung und in den DOS-Versionen bzw. Seitenmenükonfigurationen durch Vorauswahl des über den Funktionsparameter spezifizierten Menüpunkts. Die Anzeige bzw. Auswahl ist nur für den nächsten
bae_askmenu-Aufruf gültig, d.h. nach dem
bae_askmenu-Aufruf ist die Vorauswahl zurügesetzt und ist nach Bedarf mit
bae_defmenusel neu zu setzen.
Siehe auch
Funktion
bae_askmenu.
bae_defmenutext - BAE Menütext definieren (STD)
Synopsis
int bae_defmenutext( // Status
int [0,99]; // Menüzeile
string; // Menütext
int; // Menüeintrag Bearbeitungsschlüssel:
// 8000000h = immer aktivierbar
// 7FFFFFFh = für jeden Elementtyp
// aktivierbar
// sonstige = (kombinierter)
// DDB-Klassen-Schlüssel
);
Beschreibung
Die Funktion
bae_defmenutext kann im Anschluss an den Aufruf einer der Funktionen
bae_defmenu oder
bae_defselmenu wiederholt ausgeführt werden, um an der jeweils angegebenen Menüzeile der aktuellen Menüdefinition den spezifizierten Menütext einzutragen. Ist das erste Zeichen des Menütexts ein Prozentzeichen
(%), dann wird vor dem zu definierenden Pulldownmenüeintrag eine Menütrennzeile eingefügt. Das kommerzielle Und-Zeichen
& dient der Definition von sogenannten Menübeschleunigern in Pulldownmenüs. Das auf das
&-Zeichen folgende Zeichen definiert dabei eine Taste zur schnellen Selektion des Menüeintrags über die Tastatur. Der Bearbeitungsschlüssel dient der Konfiguration von sogenannten Ghostmenüs. Hierfür ist ein kodierter Integerwert einzutragen, wie er mit den Funktionen
bae_getclassbitfield oder
bae_getmenubitfield ermittelt bzw. definiert werden kann (im Zweifelsfall empfiehlt sich die Verwendung des Hexadezimalwertes 80000000h, um sicherzustellen, dass die Funktion immer aktivierbar ist). Der Funktionsrückgabewert ergibt sich zu (-1), wenn ein Fehler aufgetreten ist oder zu Null andernfalls. Mit der Funktion
bae_resetmenuprog können sämtliche Menübelegungen wieder zurückgesetzt werden.
Siehe auch
Funktionen
bae_defmenu,
bae_defselmenu,
bae_getclassbitfield,
bae_getmenubitfield,
bae_plainmenutext,
bae_redefmenu,
bae_resetmenuprog.
bae_defselmenu - BAE Submenüdefinition starten (STD)
Synopsis
int bae_defselmenu( // Status
int [0,999]; // Menücode
int [0,999]; // Menübereichscode:
// 1 = Hauptmenü
// 101 = erstes Untermenü
// 102 = zweites Untermenü
// : = : Untermenü
int [0,99]; // Menüstartzeilennummer
);
Beschreibung
Die Funktion
bae_defselmenu startet die Definition eines Untermenüs im aktuell aktiven BAE-Modul. Der Rückgabewert der Funktion
bae_defselmenu ist (-1), wenn ein Fehler aufgetreten ist oder Null andernfalls. Im Anschluss an den Aufruf der Funktion
bae_defselmenu sollten durch wiederholten Aufruf der Funktion
bae_defmenutext die einzelnen Menüeinträge definiert werden. Die mit
bae_defselmenu eingeleitete Menüdefinition muss durch einen Aufruf der Funktion
bae_endmenu beendet werden. Mit der Funktion
bae_resetmenuprog können sämtliche Menübelegungen wieder zurückgesetzt werden.
Siehe auch
Funktionen
bae_defmenuprog,
bae_defmenutext,
bae_endmenu,
bae_redefmenu,
bae_resetmenuprog.
bae_dialaddcontrol - BAE Dialogelement definieren (STD)
Synopsis
int bae_dialaddcontrol( // Dialogelementindex oder (-1) im Fehlerfall
int [0,[; // Parametertyp (STD5)
int; // Minimum int-Parameterwert
int; // Maximum int-Parameterwert
int; // Vorgabe int-Parameterwert
double; // Minimum double-Parameterwert
double; // Maximum double-Parameterwert
double; // Vorgabe double-Parameterwert
string; // Vorgabe string-Parameterwert
int [0,[; // Maximallänge string-Parameterwert
double; // Dialogelement X-Position [character-Einheiten]
double; // Dialogelement Y-Position [character-Einheiten]
double; // Dialogelement Dimension [character-Einheiten]
string; // Parameterbezeichnung/Eingabeaufforderung
);
Beschreibung
Die Funktion
bae_dialaddcontrol definiert ein Dialogelement für den angegebenen Parametertyp. Das Dialogelement wird im nachfolgend mit der Funktion
bae_dialaskparams aktivierten Dialog an den angegebenen Koordinaten und in der angegebenen Größe angezeigt und mit dem über den Funktionsparameter für die Parameterbezeichnung spezifierten Text nach Bedarf beschriftet. Die Parameterwertvorgaben für das neue Dialogelement sind über die dem angegebenen Parametertyp entsprechenden Funktionsparameter zu übergeben. Das Funktioneergebnis ergibt sich zu (-1) wenn die Generierung des Dialogelements fehlschlägt. Bei erfolgreicher Generierung des Dialogelements wird ein nichtnegativer Dialogelementindex als Funktionsergebnis zurückgeliefert. Dieser Index ist als Selektionsparameter zur Auswahl des Dialogelements bei nachfolgenden Aufrufen der Funktionen
bae_dialgetdata und
bae_dialsetdata zu verwenden. Mit
bae_dialaddcontrol erzeugte Dialogelemente sind bis zum nächsten Aufruf der Funktion
bae_dialclr gültig bzw. verfügbar.
Siehe auch
Funktionen
bae_dialadvcontrol,
bae_dialaskparams,
bae_dialbmpalloc,
bae_dialboxbufload,
bae_dialboxbufstore,
bae_dialclr,
bae_dialgetdata,
bae_dialsetdata.
bae_dialadvcontrol - Erweitertes BAE-Dialogelement setzen (STD)
Synopsis
int bae_dialadvcontrol( // Returns new dialog control index or (-1) on error
int [0,[; // Parametertyp (STD5)
int; // Minimum int-Parameterwert
int; // Maximum int-Parameterwert
int; // Vorgabe int-Parameterwert
double; // Minimum double-Parameterwert
double; // Maximum double-Parameterwert
double; // Vorgabe double-Parameterwert
string; // Vorgabe string-Parameterwert
int [0,[; // Maximallänge string-Parameterwert
double; // Dialogelement X-Position [character-Einheiten]
double; // Dialogelement Y-Position [character-Einheiten]
double; // Dialogelement Breite [character-Einheiten]
double; // Dialogelement Höhe [character-Einheiten]
string; // Parameterbezeichnung/Eingabeaufforderung
);
Beschreibung
Die Funktion
bae_dialadvcontrol definiert ein erweitertes Dialogelement (mit Elementhöhenangabe) für den angegebenen Parametertyp. Das Dialogelement wird im nachfolgend mit der Funktion
bae_dialaskparams aktivierten Dialog an den angegebenen Koordinaten und in der angegebenen Breite und Höhe angezeigt und mit dem über den Funktionsparameter für die Parameterbezeichnung spezifierten Text nach Bedarf beschriftet. Die Parameterwertvorgaben für das neue Dialogelement sind über die dem angegebenen Parametertyp entsprechenden Funktionsparameter zu übergeben. Das Funktioneergebnis ergibt sich zu (-1) wenn die Generierung des Dialogelements fehlschlägt. Bei erfolgreicher Generierung des Dialogelements wird ein nichtnegativer Dialogelementindex als Funktionsergebnis zurückgeliefert. Dieser Index ist als Selektionsparameter zur Auswahl des Dialogelements bei nachfolgenden Aufrufen der Funktionen
bae_dialgetdata und
bae_dialsetdata zu verwenden. Mit
bae_dialaddcontrol erzeugte Dialogelemente sind bis zum nächsten Aufruf der Funktion
bae_dialclr gültig bzw. verfügbar.
Siehe auch
Funktionen
bae_dialaddcontrol,
bae_dialaskparams,
bae_dialbmpalloc,
bae_dialboxbufload,
bae_dialboxbufstore,
bae_dialclr,
bae_dialgetdata,
bae_dialsetdata.
bae_dialaskcall - BAE Dialog mit Listenboxelement-Callbackfunktion aktivieren (STD)
Synopsis
int bae_dialaskcall( // Positiver Aktionscode, oder
// ( 0) bei Betätigung von , oder
// (-1) bei Betätigung von oder Fehler
string; // Dialogtitel
int [0,3]; // Ausgabeeinheiten für Distanzabfragen:
// 0 = mm
// 1 = Inch
// 2 = mil
// 3 = um
double ]0.0,[; // Dialogbreite [character-Einheiten]
double ]0.0,[; // Dialoghöhe [character-Einheiten]
* int; // Listboxelement-Callbackfunktion
);
Beschreibung
Die Funktion
bae_dialaskcall aktiviert einen Dialog mit den über die Funktion
bae_dialaddcontrol definierten Dialogelementen. In der Titelleiste des Dialogfensters wird der über den ersten Funktionsparameter angegebene Dialogtitel angezeigt. Die Größe des angezeigten Dialogfensters kann über die entsprechenden Funktionsparameter für die Dialogbreite und die Dialoghöhe gesteuert werden. Der Funktionsrückgabewert ergibt sich zu Null wenn die Dialogeingaben über den
-Button bestätigt wurden. Bei Betätigung einer Schaltlfäche mit einem zugewiesenen positiven Aktionscode gibt
bae_dialaskcall den entsprechenden Aktionscode zurück. Im Fehlerfall bzw. bei Betätigung des Buttons
wird der Wert (-1) zurückgegeben. Im Anschluss an einen erfolgreichen Aufruf der Funktion
bae_dialaskcall können die im Dialog gesetzten Parameterwerte mit der Funktion
bae_dialgetdata abgefragt werden. Distanz- bzw. Längenangaben werden dabei automatisch entsprechend dem für die Ausgabeeinheiten spezifizierten Parameter der Funktion
bae_dialaskcall angezeigt bzw. umgerechnet. Der letzte Parameter gestattet die Angabe einer Callbackfunktion die automatisch bei Selektion eines Elements einer im Dialog mit dem Typ
PA_MCALLBACK definierten Listbox aufgerufen wird.
Listboxelement-Callbackfunktion
int callbackfuncname(
int reason, // Grund für Callbackfunktionsaufruf
int boxidx, // Dialog Index
int itemidx, // Listenelement Index
int itemid, // Listenelement Id
string itemstr // Listenelement Text
)
{
// Verarbeitungsprogramm
:
return(errstat);
}
Der Rückgabewert der Callbackfunktion sollte Null sein bei erfolgreicher Abarbeitung. Im Fehlerfall sollte ein Wert ungleich Null zurückgegeben werden.
Siehe auch
Funktionen bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialaskparams,
bae_dialbmpalloc,
bae_dialboxparam,
bae_dialboxperm,
bae_dialclr,
bae_dialgetdata,
bae_dialsetdata.
bae_dialaskparams - BAE Dialog aktivieren (STD)
Synopsis
int bae_dialaskparams( // Positiver Aktionscode, oder
// ( 0) bei Betätigung von , oder
// (-1) bei Betätigung von oder Fehler
// (-2) bei Dialogdimensionsänderung
string; // Dialogtitel
int [0,3]; // Ausgabeeinheiten für Distanzabfragen:
// 0 = mm
// 1 = Inch
// 2 = mil
// 3 = um
double ]0.0,[; // Dialogbreite [character-Einheiten]
double ]0.0,[; // Dialoghöhe [character-Einheiten]
);
Beschreibung
Die Funktion
bae_dialaskparams aktiviert einen Dialog mit den über die Funktion
bae_dialaddcontrol definierten Dialogelementen. In der Titelleiste des Dialogfensters wird der über den ersten Funktionsparameter angegebene Dialogtitel angezeigt. Die Größe des angezeigten Dialogfensters kann über die entsprechenden Funktionsparameter für die Dialogbreite und die Dialoghöhe gesteuert werden. Der Funktionsrückgabewert ergibt sich zu Null wenn die Dialogeingaben über den
-Button bestätigt wurden. Bei Betätigung einer Schaltlfäche mit einem zugewiesenen positiven Aktionscode gibt
bae_dialaskparams den entsprechenden Aktionscode zurück. Im Fehlerfall bzw. bei Betätigung des Buttons
wird der Wert (-1) zurückgegeben. Bei einer Änderung der Dialoggröße; wird der Wert (-2) zurückgegeben. Im Anschluss an einen erfolgreichen Aufruf der Funktion
bae_dialaskparams können die im Dialog gesetzten Parameterwerte mit der Funktion
bae_dialgetdata abgefragt werden. Distanz- bzw. Längenangaben werden dabei automatisch entsprechend dem für die Ausgabeeinheiten spezifizierten Parameter der Funktion
bae_dialaskparams angezeigt bzw. umgerechnet.
Siehe auch
Funktionen bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialaskcall,
bae_dialbmpalloc,
bae_dialboxperm,
bae_dialclr,
bae_dialgetdata,
bae_dialsetdata.
bae_dialbmpalloc - BAE Dialogbitmap erzeugen (STD)
Synopsis
int bae_dialbmpalloc( // Nicht-negative Bitmap-Id oder (-1) im Fehlerfall
double ]0.0,[; // Gewünschte Bitmapbreite [character-Einheiten]
double ]0.0,[; // Gewünschte Bitmaphöhe [character-Einheiten]
int [2,31]; // Bitmap-Id
& int; // Erzeugte Bitmapbreite [Pixel]
& int; // Erzeugte Bitmaphöhe [Pixel]
);
Beschreibung
Mit der Funktion
bae_dialbmpalloc können Bitmaps mit den angegebenen Parametern in einer nachfolgend mit
bae_dialaskparams zu aktivierenden Dialogbox angelegt werden. Der Funktionsrückgabewert ist (-1) bei fehlgeschlagener Bitmapgenerierung oder eine nicht-negative Bitmapidentifikationsnummer bei erfolgreicher Bitmapgenerierung (wobei dann auch die tatsächlich erzeugten Bitmapdimensionen über die entsprechenden Parameter zurückgegeben werden). Nach erfolgreicher Generierung der Bitmap kann diese mit der Funktion
bae_popsetarea als Grafikausgabeeinheit für die Funktionen
bae_popdrawtext und
bae_popdrawpoly selektiert werden.
Siehe auch
Funktionen
bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialaskcall,
bae_dialaskparams,
bae_dialboxperm,
bae_dialclr,
bae_popdrawpoly,
bae_popdrawtext,
bae_popsetarea.
bae_dialboxbufload - BAE Dialogboxdaten aus Buffer holen (STD)
Synopsis
int bae_dialboxbufload( // Status
int [1,[; // Dialogbox Buffer-Id
);
Beschreibung
Die Funktion
bae_dialboxbufload dient dazu, zuvor mit
bae_dialboxbufstore gespeicherte Dialogboxdefinition zu laden. Der Funktionsrückgabewert ist Null wenn der Ladevorgang erfolgreich war oder ungleich Null im Fehlerfall.
Siehe auch
Funktionen bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialboxbufstore,
bae_dialclr.
bae_dialboxbufstore - BAE Dialogboxdaten in Buffer sichern (STD)
Synopsis
int bae_dialboxbufstore( // Dialogbox Id (>0) oder (-1) im Fehlerfall
);
Beschreibung
Die Funktion
bae_dialboxbufstore sichert die aktuellen Dialogboxdefinitionen in einem temporären Speicher. Der Funktionsrückgabewert ist ein positiver Integerwert zur Identifikation des benutzten Zwischenspeichers oder (-1) im Fehlerfall. Diese Identifikationsnummer ist in nachfolgenden
bae_dialboxbufload zum Laden der Dialogboxdaten anzugeben.
Siehe auch
Funktionen bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialboxbufload,
bae_dialclr.
bae_dialboxperm - Eigenständigen BAE Dialog aktivieren (STD)
Synopsis
int bae_dialboxperm( // Positive Dialog-Id, oder
// (-1) wenn Dialoganzeige fehlgeschlagen, oder
// (-2) wenn maximale Dialoganzahl erreicht
string; // Dialogtitel
int [0,3]; // Ausgabeeinheiten für Distanzabfragen:
// 0 = mm
// 1 = Inch
// 2 = mil
// 3 = um
double ]0.0,[; // Dialogbreite [character-Einheiten]
double ]0.0,[; // Dialoghöhe [character-Einheiten]
);
Beschreibung
Die Funktion
bae_dialboxperm aktiviert einen eigenständigen ("modeless") Dialog mit den über die Funktion
bae_dialaddcontrol definierten Dialogelementen. In der Titelleiste des Dialogfensters wird der über den ersten Funktionsparameter angegebene Dialogtitel angezeigt. Die Größe des angezeigten Dialogfensters kann über die entsprechenden Funktionsparameter für die Dialogbreite und die Dialoghöhe gesteuert werden. Bei erfolgreicher Generierung der Dialogbox gibt die Funktion die positive Identifikationsnummer für diesen Dialog zurück.
Im Fehlerfall wird ein negativer Wert zurückgegeben.
Im Anschluss an einen erfolgreichen Aufruf der Funktion
bae_dialboxperm können (nach Aktivierung dieses Dialogs mit
bae_dialsetcurrent) die im Dialog gesetzten Parameterwerte mit der Funktion
bae_dialgetdata abgefragt werden. Distanz- bzw. Längenangaben werden dabei automatisch entsprechend dem für die Ausgabeeinheiten spezifizierten Parameter der Funktion
bae_dialboxperm angezeigt bzw. umgerechnet.
Siehe auch
Funktionen bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialaskcall,
bae_dialaskparams,
bae_dialbmpalloc,
bae_dialclr,
bae_dialgetdata,
bae_dialsetcurrent,
bae_dialsetdata.
bae_dialclr - BAE Dialogelemente löschen (STD)
Synopsis
int bae_dialclr( // Status
);
Beschreibung
Die Funktion
bae_dialclr löscht alle zuvor mit
bae_dialaddcontrol erzeugten Dialogelemente. Der Funktionsrückgabewert ist ungleich Null, wenn Dialoge in der aktuellen BAE-Benutzeroberfläche nicht unterstützt werden. Es empfiehlt sich, diese Funktion vor der Neudefinition eines Dialogs auszuführen, um eventuell vorhandene Dialogelemente aus zuvor definierten Dialogen zuverlässig zu löschen. Das Funktionsergebnis sollte ebenfalls geprüft werden, damit bei fehlendem Dialogsupport auf andere interaktive Abfragemechanismen ausgewichen werden kann.
Siehe auch
Funktionen
bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialaskcall,
bae_dialaskparams,
bae_dialbmpalloc,
bae_dialboxbufload,
bae_dialboxbufstore,
bae_dialboxperm,
bae_dialgetdata,
bae_dialsetdata.
bae_dialgetdata - BAE Dialogelementdaten abfragen (STD)
Synopsis
int bae_dialgetdata( // Status
int [0,[; // Dialogelementindex
& int; // Dialogelement integer-Wert
& double; // Dialogelement double-Wert
& string; // Dialogelement string-Wert
);
Beschreibung
Mit der Funktion
bae_dialgetdata können nach einem erfolgreichen Aufruf der Funktion
bae_dialaskparams, die vom Anwender gesetzten Dialogparameterwerte abgefragt werden. Die Auswahl des abzufragenden Dialogelements erfolgt durch Spezifikation des von
bae_dialaddcontrol, gelieferten Dialogelementindex. Die Rückgabe des ermittelten Parameterwertes erfolgt über den Funktionsparameter, der dem Datentyp des abgefragten Dialogelements entspricht. Der Funktionsrückgabewert ist Null bei erfolgreicher Parameterabfrage bzw. ungleich Null bei fehlgeschlagener Abfrage.
Siehe auch
Funktionen
bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialaskparams,
bae_dialclr,
bae_dialsetdata.
bae_dialgettextlen - BAE Dialogtextlänge abfragen (STD)
Synopsis
double bae_dialgettextlen( // Rückgabe Textlänge [character-Einheiten]
int [0,[; // Dialogtexttyp bzw. Zeichensatztyp
string; // Dialogtextzeichenkette
);
Beschreibung
Die Funktion
bae_dialgettextlen ermittelt den Platzbedarf für den angegebenen Dialogtext.
bae_dialsetcurrent - Aktuelle BAE-Dialogbox setzen (STD)
Synopsis
int bae_dialsetcurrent( // Status
int [0,[; // Dialogbox-Id
);
Beschreibung
Die Funktion
bae_dialsetcurrent aktiviert die über die Identifikationsnummer angebebene (eigenständige) Dialogbox für nachfolgende Dialogboxfunktionen. Bei erfolgreicher Dialogauswahl ergibt sich der Funktionsrückgabewert zu Null. Bei fehlgeschlagener Dialogauswahl wird ein Wert ungleich Null zurückgegeben.#
Siehe auch
Funktionen bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialaskcall,
bae_dialaskparams,
bae_dialbmpalloc,
bae_dialboxperm,
bae_dialclr,
bae_dialgetdata,
bae_dialsetdata.
bae_dialsetdata - BAE Dialogelementdaten setzen (STD)
Synopsis
int bae_dialsetdata( // Status
int [0,[; // Dialogelement Index
int [0,[; // Dialogelement Parametertyp (STD5)
int; // Dialogelement integer-Wert
double; // Dialogelement double-Wert
string; // Dialogelement string-Wert
);
Beschreibung
Die Funktion
bae_dialsetdata dient dazu, Parametertypen bzw. Parameterwerte für zuvor mit
bae_dialaddcontrol definierte Dialogelemente zu setzen. Die Auswahl des zu ändernden Dialogelements erfolgt durch Spezifikation des von
bae_dialaddcontrol, gelieferten Dialogelementindex. Der neue Parameterwert ist über den dem angegebenen Parametertyp entsprechenden Funktionsparameter zu übergeben. Der Funktionsrückgabewert ist Null bei erfolgreicher Änderung des Dialogelements bzw. ungleich Null im Fehlerfall.
Siehe auch
Funktionen
bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialaskparams,
bae_dialclr,
bae_dialgetdata.
bae_endmainmenu - BAE Hauptmenüdefinition beenden (STD)
Synopsis
int bae_endmainmenu( // Status
);
Beschreibung
Die Funktion
bae_endmainmenu beendet die im aktuell aktiven BAE-Modul mit der Funktion
bae_redefmainmenu eingeleitete Neudefinition des Hauptmenüs. Der Rückgabewert der Funktion
bae_endmainmenu ist (-1), wenn ein Fehler aufgetreten ist oder Null andernfalls. Mit der Funktion
bae_resetmenuprog können sämtliche Menübelegungen wieder zurückgesetzt werden.
Siehe auch
Funktionen
bae_redefmainmenu,
bae_resetmenuprog.
bae_endmenu - BAE Menüdefinition beenden (STD)
Synopsis
int bae_endmenu( // Status
);
Beschreibung
Die Funktion
bae_endmenu beendet die im aktuellen BAE-Modul mit einer der Funktionen
bae_defmenu oder
bae_defselmenu eingeleitete Menüdefinition. Der Rückgabewert der Funktion
bae_endmenu ist (-1), wenn ein Fehler aufgetreten ist oder Null andernfalls. Mit der Funktion
bae_resetmenuprog können sämtliche Menübelegungen wieder zurückgesetzt werden.
Siehe auch
Funktionen
bae_defmenu,
bae_defselmenu,
bae_resetmenuprog.
bae_fontcharcnt - BAE Anzahl Zeichensatzzeichen (STD)
Synopsis
int bae_fontcharcnt( // Zeichenanzahl
);
Beschreibung
Der Rückgabewert der Funktion
bae_fontcharcnt entspricht der Anzahl der im aktuell geladenen Zeichensatz definierten Zeichen.
bae_fontname - BAE Zeichensatzname abfragen (STD)
Synopsis
string bae_fontname( // Zeichensatzname
);
Beschreibung
Der Rückgabewert der Funktion
bae_fontname entspricht dem Namen des für das aktuell geladene
AutoEngineer Planelement gültigen Zeichensatzes.
bae_getactmenu - BAE aktives Menü abfragen (STD)
Synopsis
int bae_getactmenu( // Menüfunktion (STD4)
);
Beschreibung
Der Rückgabewert der Funktion
bae_getactmenu entspricht der im
AutoEngineer aktuell aktiven Menüfunktion
(STD4) oder (-1) wenn keine Menüfunktion abgearbeitet wird. Diese Funktion wird benötigt für Programme, die auf Tasten gelegt werden.
bae_getanglelock - BAE Winkelfreigabeflag abfragen (STD)
Synopsis
int bae_getanglelock( // Winkelfreigabe Flag (STD9)
);
Beschreibung
Der Rückgabewert der Funktion
bae_getanglelock entspricht dem im
AutoEngineer aktuell eingestellten Wert des Winkelfreigabeflags
(0=Winkel freigeben, 1=Winkel einhalten).
Siehe auch
Funktion
bae_setanglelock.
bae_getbackgrid - BAE Hintergrundraster abfragen (STD)
Synopsis
void bae_getbackgrid(
& double; // X-Hintergrundraster (STD2)
& double; // Y-Hintergrundraster (STD2)
);
Beschreibung
Die Funktion
bae_getbackgrid gibt in den beiden Parametern die Werte des aktuell im
AutoEngineer eingestellten Hintergrundrasters für X- und Y-Richtung zurück. Werte von Null spezifizieren, dass kein Hintergrundraster angezeigt wird.
Siehe auch
Funktion
bae_setbackgrid.
bae_getcasstime - Zeitpunkt des letzten Projektnetzlistenupdates durch Packager/Backannotation ermitteln (STD)
Synopsis
string bae_getcasstime( // Rückgabe Packager-Netzlistenname
& int; // Rückgabe Zeitangabe Sekunde
& int; // Rückgabe Zeitangabe Minute
& int; // Rückgabe Zeitangabe Stunde
& int; // Rückgabe Datumsangabe Tag
& int; // Rückgabe Datumsangabe Monat
& int; // Rückgabe Datumsangabe Jahr
);
Beschreibung
Mit der Funktion
bae_getcasstime kann der Zeitpunkt des zuletzt durch
Packager bzw.
erfolgten Projektnetzlistenupdates ermittelt werden.
Siehe auch
Funktionen bae_getpackdata,
bae_getpacktime.
bae_getclassbitfield - BAE DDB-Klasse Bearbeitungsschlüssel abfragen (STD)
Synopsis
int bae_getclassbitfield( // Rückgabe Bearbeitungsschlüssel
int ]0,[; // DDB-Datenbankklasse (STD1)
);
Beschreibung
Die Funktion
bae_getclassbitfield ermittelt den Bearbeitungsschlüssel, der der spezifizierten DDB-Datenbankklasse zugewiesen ist. Der Rückgabewert der Funktion
bae_getclassbitfield ist (-1) bei Spezifikation einer ungültigen bzw. unbekannten Datenbankklasse.
Der Bearbeitungsschlüssel ist ein kodierter Integerwert, der innerhalb eines BAE-Moduls für jede bearbeitbare DDB-Klasse eindeutig ist. Durch bitweises Verodern dieser Kodierungen können weitere Bearbeitungsschlüssel generiert und anschließend mit einer der Funktionen
bae_defmenutext,
bae_defmenuprog oder
bae_redefmenu selektiv an Menüeinträge zugewiesen werden. Damit können Menüfunktionen so konfiguriert werden, dass sie nur auf bestimmte Datenbankklassen anwendbar sind.
Siehe auch
Funktionen
bae_defmenuprog,
bae_defmenutext,
bae_getmenubitfield,
bae_redefmenu.
bae_getcmdbuf - BAE Kommandohistorie abfragen (STD)
Synopsis
int bae_getcmdbuf( // Status
int [-50,2099]; // Kommandospeicherindex 0 bis 49
// oder 1000 bis 1099 für Undo-Einträge 1 bis 100
// oder 2000 bis 2099 für Redo-Einträge 1 bis 100
// oder negativer Wert für Meldungshistorie
& string; // Kommando- bzw. Kommandosequenzzeichenkette
& string; // Kommandoanzeigetext
);
Beschreibung
Die Funktion
bae_getcmdbuf dient dazu, die Kommandohistorie für das aktuelle Kontextmenü abzufragen. Dies ist die Liste der zuletzt über die rechte Maustaste aktivierten Kommandos. Der Kommandospeicherindex gibt die Position des abzufragenden Kommandos an (Null ist das zuletzt ausgeführte Kommando). Die Kommando- bzw. Kommandosequenzzeichenkette und der Kommandoanzeigetext (entsprechend der Titelleistenanzeige) werden über den zweiten und dritten Funktionsparameter an den Aufrufer zurückgegeben. Der Funktionsrückgabewert ist 1 wenn die Abfrage erfolgreich war oder Null wenn ein ungültiger Kommandospeicherindex angegeben wurde.
Siehe auch
Funktion bae_storecmdbuf.
bae_getcolor - BAE Farbwert abfragen (STD)
Synopsis
int bae_getcolor( // Farbwert (STD18)
int; // Anzeigeelementtyp (SCM1|LAY9|ICD9)
);
Beschreibung
Die Funktion
bae_getcolor ermittelt den Farbwert für den angegebenen Anzeigeelementtyp. Der Wert für den Anzeigeelementtyp muss entsprechend der aktuellen Interpreterumgebung gesetzt sein.
Siehe auch
Funktion
bae_setcolor.
bae_getcoorddisp - BAE Koordinatenanzeige abfragen (STD)
Synopsis
int bae_getcoorddisp( // Koordinatenanzeigemodus (STD7)
);
Beschreibung
Der Rückgabewert der Funktion
bae_getcoorddisp entspricht dem im AutoEngineer aktuell eingestellten Koordinatenanzeigemodus, wobei der Wert 0 für mm-Einheiten (bzw. Mikrometer-Einheiten im
IC-Design System) und der Wert 1 für Inch-Einheiten (bzw. mil-Einheiten im
IC-Design System) steht.
Siehe auch
Funktion
bae_setcoorddisp.
bae_getdblpar - BAE Doubleparameter abfragen (STD)
Synopsis
int bae_getdblpar( // Status
int [0,[; // Parametertyp/-nummer:
// 0 = maximale Dialogboxbreite
// 1 = maximale Dialogboxhöhe
// 2 = Grafikanzeige Zoomfaktor
// 3 = Gummibandeckradius (STD2)
// 4 = Gummiband X-Vektorkoordinate (STD2)
// 5 = Gummiband Y-Vektorkoordinate (STD2)
// 6 = Fixierte X-Pickkoordinate (STD2)
// 7 = Fixierte Y-Pickkoordinate (STD2)
// 8 = Dialogboxbreite
// 9 = Dialogboxhöhe
// 10 = Bildschirmpickbereich (STD2)
// 11 = Elementauswahl relativer Vorschaubereich [0.05, 0.95]
// 12 = Dialogbox X-Einheiten Pixel
// 13 = Dialogbox Y-Einheiten Pixel
& double; // Rückgabe Parameterwert
);
Beschreibung
Die Funktion
bae_getdblpar dient der Abfrage von im
Bartels AutoEngineer gesetzten Parametern vom Typ
double. Der Funktionsrückgabewert ist Null bei erfolgreicher Abfrage oder (-1) im Fehlerfall.
Siehe auch
Funktionen bae_getintpar,
bae_getstrpar,
bae_setdblpar,
bae_setintpar,
bae_setstrpar.
bae_getfuncprog - BAE Funktionstastenprogrammierung abfragen (STD)
Synopsis
string bae_getfuncprog( // Programmname
int [1,128]; // Funktionstastennummer
);
Beschreibung
Die Funktion
bae_getfuncprog ermittelt den Namen des
User Language-Programms, welches der angegebenen Standardtaste zugewiesen ist. Ist der Taste eine BAE-Menüfunktion zugewiesen, dann wird die entsprechende BAE-Menüfunktionsnummer mit einem vorangestellten Hashzeichen
(#) zurückgegeben. Der Funktionsrückgabewert ist ein Leerstring, wenn keine Zuweisung für die Funktionstaste definiert ist bzw. wenn eine ungültige Funktionstastennummer spezifiziert wurde.
Siehe auch
Funktionen
bae_deffuncprog,
bae_resetmenuprog.
bae_getgridlock - BAE Rasterfreigabeflag abfragen (STD)
Synopsis
int bae_getgridlock( // Rasterfreigabe Flag (STD8)
);
Beschreibung
Der Rückgabewert der Funktion
bae_getgridlock entspricht dem im
AutoEngineer aktuell eingestellten Wert des Rasterfreigabeflags (0=Raster freigeben, 1=Raster einhalten).
Siehe auch
Funktion
bae_setgridlock.
bae_getgridmode - BAE Rasterabhängigkeitsmodus abfragen (STD)
Synopsis
int bae_getgridmode( // Rückgabe Modus für automatische Rastereinstellung:
// 0x01: Eingaberaster = 0.25 × Hintergrundraster
// 0x02: Eingaberaster = 0.50 × Hintergrundraster
// 0x04: Eingaberaster = 1.00 × Hintergrundraster
// 0x08: Eingaberaster = 2.00 × Hintergrundraster
// 0x10: Hintergrundraster = 0.25 × Eingaberaster
// 0x20: Hintergrundraster = 0.50 × Eingaberaster
// 0x40: Hintergrundraster = 1.00 × Eingaberaster
// 0x80: Hintergrundraster = 2.00 × Eingaberaster
);
Beschreibung
Die Funktion
bae_getgridmode dient der Abfrage des aktuell aktiven BAE Rasterabhängigkeitsmodus.
Siehe auch
Funktion
bae_setgridmode.
bae_getinpgrid - BAE Eingaberaster abfragen (STD)
Synopsis
void bae_getinpgrid(
& double; // X-Eingaberaster (STD2)
& double; // Y-Eingaberaster (STD2)
);
Beschreibung
Die Funktion
bae_getinpgrid gibt in den beiden Parametern die Werte des aktuell im
AutoEngineer eingestellten Eingaberasters für X- und Y-Richtung zurück.
Siehe auch
Funktion
bae_setinpgrid.
bae_getintpar - BAE Integerparameter abfragen (STD)
Synopsis
int bae_getintpar( // Status
int [0,[; // Parametertyp/-nummer:
// 0 = Koordinateneingaben Bereichsprüfung:
// 0 = Bereichsprüfung aktiviert
// 1 = Bereichsprüfung deaktiviert
// 1 = Modulwechsel Autosavemodus:
// 0 = Autosave ohne Benutzerabfrage
// 1 = Benutzerabfrage vor Autosave
// 2 = Anzeigedeaktivierungsmodus:
// 0 = Anzeige aktiviert
// 1 = Anzeige deaktiviert
// 3 = Benutzeroberfläche Menü-/Mausmodus:
// 0 = Seitenmenü-Konfiguration
// 1 = Pulldownmenü, LMB-Kontext
// 2 = Pulldwonmenü, RMB-Kontext
// 4 = Arbeitsbereichstext Farbauswahl:
// 0 = Standardfarben
// 1 = invertierte Standardfarben
// 2 = arbeitsbereichsspezifische Farben
// 5 = Element Laden Anzeigemodus:
// 0 = Übersichtsanzeige nach Laden
// 1 = Anzeige aktiviert durch bae_load
// 6 = Dateiauswahl Dialogmodus:
// 0 = alte BAE-Dateiauswahl
// 1 = Explorer Standardansicht
// 2 = Explorer Listenansicht
// 3 = Explorer Detailansicht
// 4 = Exploreransicht kleine Piktogramme
// 5 = Exploreransicht große Piktogramme
// 6 = Standard-Stil und Standard-Größe benutzen
// 7 = Elementauswahl Dialogmodus:
// 0 = nur Name anzeigen
// 1 = Name und Datum anzeigen
// 8 = Elementauswahl Sortierfunktion:
// 0|1 = Sortierung nach Name
// 2 = Sortierung numerisch
// 3 = Sortierung nach Datum
// 9 = Anzeigemodus Platzierung:
// 0 = platzierte Elemente sichtbar
// 1 = unplatzierte Elemente sichtbar
// 10 = Letzter Dateisystemfehler
// 11 = Kommandohistorie Modus:
// 0 = Kommandohistorie aktiviert
// 1 = Kommandohistorie deaktiviert
// 12 = Popupmenü Mauswarpmodus:
// 0 = Kein Popupmenü Mauswarp
// 1 = Popupmenü Mauswarp erstes Element
// 2 = Popupmenü Mauswarp vorselektiertes Element
// +4 = Mauspositionsrestore-Warp
// +8 = Elementpickpositions-Warp
// 13 = Sicherungsmodus:
// 0 = Sicherung aktiviert
// 1 = Sicherung deaktiviert
// 14 = Minimalgröße Mausrechteck:
// ]0,[ = minimale Mausrechteckgröße
// 15 = Mausinfo-Anzeigemodus:
// 0 = Tooltip-Infoanzeige
// 1 = Kontinuierliche Fadenkreuz-Infoanzeige
// 2 = Fadenkreuz-Infoanzeige mit Strg
// 16 = Nächste Dialogbox-Identifikationsnummer
// 17 = Zuletzt erzeugte Tooltipidentifikationsnummer
// 18 = Polygonverwurfsanzahl
// 19 = Polygonprüfungsabschaltung:
// 0 = Polygonprüfung aktiv
// 1 = Polygonprüfung abgeschaltet
// 20 = Kursortastenrastermodus:
// 0 = Eingaberaster
// 1 = Pixelraster
// 21 = Flag - Element nicht gesichert
// 22 = Elementbatchlademodus:
// 0 = keinen Batch laden
// 1 = Batch laden
// 2 = Batch laden, Zoomfenster restaurieren
// 23 = Rasterlinienanzeige:
// 0 = Punktraster
// 1 = Linienraster
// 24 = Flag - Spiegelungsanzeige
// 25 = Flag - Eingaberasteranzeige
// 26 = Mausfunktionswiederholungsmodus:
// 0 = Menüfunktion wiederholen
// +1 = Tastenfunktion wiederholen
// +2 = Kontextmenüfunktion wiederholen
// 27 = Maximale Undo-Redo-Anzahl
// 28 = Menübaumansichtsmodus:
// 0 = Kein Menübaumfenster
// 1 = Menübaumfenster links
// 2 = Menübaumfenster rechts
// 29 = Menübaumansicht Pixelbreite
// 30 = Flag - Meldungshistorie deaktiviert
// 31 = Elementlademeldungsmodus:
// 0 = Standardmeldung
// 1 = Benutzerspezifische Meldung
// 2 = Benutzerspezifische Fehlermeldung
// 32 = Pickmarkeranzeigemodus:
// 0 = Kreismarker
// 1 = Diamantmarker
// 33 = Mausdrag-Status:
// 0 = Kein Mausdrag
// 1 = Mausdragangeforderung
// 2 = Mausdrag durchgeführt
// 3 = Mausdragfreigabeanforderung
// 34 = Flag - Menüfunktionswiederholung angefordert
// 35 = Flag - Funktion abgebrochen
// 36 = Flag - Planauswahlvorschau
// 37 = Dateizugriffsfehler-Anzeigemodus:
// 0 = Nur Statuszeilenanzeige
// 1 = Bestätigungsabfrage
// 38 = Elementauswahl-Referenzanzeigemodus:
// 0 = Projektdatei-Referenzen anzeigen
// 1 = Bibliotheksdatei-Referenzen anzeigen
// 39 = Maus-Doppelklick-Modus:
// 0 = Doppelklick und Selektion von 0 an rechte Maustaste zuweisen
// 1 = Doppelklick ignorieren
// 2 = Doppelklick an rechte Maustaste zuweisen
// 40 = Mauspick-Doppelklick-Modus:
// 0 = Doppelklick an rechte Maustaste zuweisen
// 1 = Doppelklick ignorieren
// 41 = Flags - Dialogelementunterstützung:
// 0 = Keine Dialogelemente unterstützt
// |1 = Dialogbasiselemente unterstützt
// |2 = Listenanzeige unterstützt
// |4 = Fortschittsanzeige unterstützt
// |8 = Werkzeugleistenschaltfläche unterstützt
// 42 = Fortschrittsanzeigemodus:
// 0 = Keine Fortschrittsanzeige
// 1 = Fortschrittsanzeige
// 43 = Abbruchanforderungsflag für Fortschrittsanzeige
// 44 = Flag - Mittlere Maustaste deaktiviert
// 45 = Anzahl aktueller Undo-Elemente
// 46 = Flag - Datei Drag-und-Drop Operation
// 47 = Flag - Automatische BAE-Fensteraktivierung
// 48 = Anzahl aktive Menüfunktionen
// 49 = Anzahl Punkte in interner Polygonliste
// 50 = Priorit&auuml;t alternative Konfigurationsdatei
// 51 = Sicherungsmodus für Dialogposition:
// 0 = Absolutkoordinaten specihern
// 1 = Hauptfenster-Relativkoordinaten speichern
// 2 = Hauptfenster-Monitorabsolutkoordinaten speichern
// 52 = Message-Box Default-Button-Index:
// (-1) = Kein Default (Abbruch oder No
// 0-2 = Default-Button-Index
& int; // Rückgabe Parameterwert
);
Beschreibung
Die Funktion
bae_getintpar dient der Abfrage von im
Bartels AutoEngineer gesetzten Integerparametern. Der Funktionsrückgabewert ist Null bei erfolgreicher Abfrage oder (-1) im Fehlerfall.
Siehe auch
Funktionen bae_getdblpar,
bae_getstrpar,
bae_setdblpar,
bae_setintpar,
bae_setstrpar.
bae_getinvcolor - BAE Farbinvertierungsmodus abfragen (STD)
Synopsis
int bae_getinvcolor( // Rückgabe Farbeinvertierungsmodus
);
Beschreibung
Die Funktion
bae_getinvcolor überprüft, ob die BAE-Systemfarbpalette "invertiert" ist. Die Systemfarbpalette wird als invertiert betrachtet, wenn die dunkelste Farbe in der aktuell (über die Datei
bae.col im BAE-Programmverzeichnis) definierten Systemfarbpalette nicht schwarz ist. Die Funktion gibt einen Wert ungleich Null zurück, wenn die BAE-Systemfarbpalette invertiert ist; andernfalls ist der Funktionsrückgabewert Null.
bae_getmenubitfield - BAE Menüfunktion Bearbeitungschlüssel abfragen (STD)
Synopsis
int bae_getmenubitfield( // Rückgabe Bearbeitungsschlüssel
int [0,999]; // Menücode
int [0,99]; // Menüzeile
);
Beschreibung
Die Funktion
bae_getmenubitfield ermittelt den Bearbeitungsschlüssel, der dem angegebenen Menüeintrag zugewiesen ist. Die Spezifikation des Menüeintrags erfolgt durch die Angabe der Hauptmenünummer über den Parameter für den Menücode sowie durch die Angabe der Menüzeile im zugehörigen Untermenü. Der Rückgabewert der Funktion
bae_getmenubitfield ist (-1), wenn die Spezifikation des Menüeintrags ig ist.
Der Bearbeitungsschlüssel ist ein kodierter Integerwert, der angibt, für welche aktuell geladenen Elemente die Menüfunktion aufgerufen werden kann. Mit Hilfe dieses Schlüssels können Menüeinträge im
Bartels AutoEngineer in Abhängigkeit vom Typ des aktuell geladenen Elements wahlweise aktiviert bzw. deaktiviert werden. Dieser Mechanismus kommt insbesondere bei der Konfiguration der sogenannten Ghostmenüs in den Windows-Versionen der BAE-Software zur Anwendung. Ist der Bearbeitungschlüssel mit dem Hexadezimalwert 80000000h kodiert, dann kann die entsprechende Funktion immer (d.h. auch wenn kein Element geladen ist) aktiviert werden. Der Hexadezimalwert 7FFFFFFFh gibt an, dass die Funktion für jeden beliebigen geladenen Elementtyp aufgerufen werden kann. Weitere Kodierungen sind in den einzelnen BAE-Modulen in Abhängigkeit von den bearbeitbaren DDB-Datenbankklassen definiert. Die Kodierung für jede einzelne Datenbankklasse kann mit der Funktion
bae_getclassbitfield ermittelt werden. Durch bitweises Verodern dieser Kodierungen können weitere Bearbeitungsschlüssel generiert und anschließend mit einer der Funktionen
bae_defmenutext,
bae_defmenuprog oder
bae_redefmenu selektiv an Menüeinträge zugewiesen werden. Damit ist die Konfiguration benutzerdefinierter Ghostmenüs möglich.
Siehe auch
Funktionen
bae_defmenuprog,
bae_defmenutext,
bae_getclassbitfield,
bae_redefmenu.
bae_getkeyprog - BAE Standardtastenprogrammierung abfragen (STD)
Synopsis
string bae_getkeyprog( // Programmname
int; // Tastenzeichen
);
Beschreibung
Die Funktion
bae_getkeyprog ermittelt den Namen des
User Language-Programms, welches der angegebenen Standardtaste zugewiesen ist. Ist der Taste eine BAE-Menüfunktion zugewiesen, dann wird die entsprechende BAE-Menüfunktionsnummer mit einem vorangestellten Hashzeichen
(#) zurückgegeben. Der Funktionsrückgabewert ist ein Leerstring, wenn keine Zuweisung für die Standardtaste definiert ist bzw. wenn ein iges Tastenzeichen spezifiziert wurde.
Siehe auch
Funktionen
bae_defkeyprog,
bae_resetmenuprog.
bae_getmenuitem - BAE Menüeintrag abfragen (STD)
Synopsis
int bae_getmenuitem( // Status
& int; // Menücode
& string; // Menütext(e)
& string; // Menükommando
);
Beschreibung
Die Funktion
bae_getmenuitem ermöglicht die Anwahl einer BAE-Menüfunktion zur Abfrage der Eigenschaften des selektierten Menüeintrags. Im Menücodeparameter wird der Aufrufcode für den selektierten Menüeintrag zurückgeliefert. Im Parameter für den Menütext werden getrennt durch
-> die zur Selektion des Menüeintrags angewählten Menütext(e) der hierarchischen Menüstruktur zurückgeliefert. Im Parameter für das Menükommando wird die dem Menüeintrag zugewiesene Menükommandosequenz zurückgeliefert. Der Funktionsrückgabewert ist Null bei erfolgreicher Abfrage, oder ungleich Null bei fehlgeschlagener bzw. abgebrochener Abfrage.
Siehe auch
Funktionen
bae_callmenu,
bae_defmenuprog,
bae_getmenuprog,
bae_getmenutext.
bae_getmenuprog - BAE Menüprogrammierung abfragen (STD)
Synopsis
string bae_getmenuprog( // Programmname
int [0,999]; // Menücode
int [0,99]; // Menüzeile
);
Beschreibung
Die Funktion
bae_getmenuprog ermittelt den Namen des
User Language-Programms, welches dem angegebenen Menüeintrag zugewiesen ist. Ist dem Menüeintrag eine BAE-Menüfunktion zugewiesen, dann wird die entsprechende BAE-Menüfunktionsnummer mit einem vorangestellten Hashzeichen
(#) zurückgegeben. Der Menücode gibt die Nummer des Hauptmenüs an, die Menüzeile die Position im zugehörigen Submenü. Der Funktionsrückgabewert ist ein Leerstring, wenn keine Zuweisung für den Menüeintrag definiert ist bzw. wenn die Spezifikation des Menüeintrags ig ist.
Siehe auch
Funktionen
bae_defmenuprog,
bae_getmenuitem,
bae_getmenutext,
bae_resetmenuprog.
bae_getmenutext - BAE Menütext abfragen (STD)
Synopsis
string bae_getmenutext( // Menütext
int [0,999]; // Menücode
int [0,99]; // Menüzeile
);
Beschreibung
Die Funktion
bae_getmenutext ermittelt den Anzeigetext, der dem angegebenen Menüeintrag zugewiesen ist. Der Menücode gibt die Nummer des Hauptmenüs an, die Menüzeile die Position im zugehörigen Submenü. Der Funktionsrückgabewert ist ein Leerstring, wenn die Spezifikation des Menüeintrags ig ist bzw. der spezifizierte Menüeintrag nicht existiert.
Siehe auch
Funktionen
bae_defmenuprog,
bae_getmenuitem,
bae_getmenuprog,
bae_plainmenutext,
bae_resetmenuprog.
bae_getmoduleid - BAE Modulbezeichnung abfragen (STD)
Synopsis
string bae_getmoduleid( // Modulbezeichnung
);
Beschreibung
Die Funktion
bae_getmoduleid ermittelt die (mit
bae_setmoduleid gesetzte) Bezeichnung des aktuell aktiven BAE-Programmmoduls.
Siehe auch
Funktion
bae_setmoduleid.
bae_getmsg - BAE HighEnd Message empfangen (STD/HighEnd)
Synopsis
string bae_getmsg( // Rückgabe Messagestring
);
Beschreibung
Die Funktion
bae_getmsg ist nur in
BAE HighEnd verfügbar. Mit
bae_getmsg können Nachrichten empfangen werden, die zuvor mit der Funktion
bae_sendmsg an die anderen Module eine
BAE HighEnd-Sitzung abgesendet wurden. Zu einer Sitzung gehören alle Programminstanzen, die ausgehend von einem BAE-Aufruf über die Funktion
aus dem BAE-Hauptmenü oder dem
Schaltplaneditor gestartet wurden. In den addressierten Modulen wird bei Ankunft einer Nachricht automatisch das
User Language-Programm bae_msg gestartet. Ist
bae_msg nicht verfügbar, dann erfolgt der Aufruf eines
User Language-Programms mit modulspezifischem Namen
(scm_msg im Schaltplaneditor,
ged_msg im Layouteditor,
ar_msg im Autorouter, etc.). Das automatisch gestartete
User Language-Programm muss die Nachrichtmit der Funktion
bae_getmsg entgegennehmen. Die Nachricht steht nur während der Dauer dieses Programmaufrufs zur Verfügung. Wird die Nachricht von dem
*_msg-Programm nicht angenommen, dann geht sie verloren. Der Inhalt der Nachricht kann dazu benutzt werden, eine spezielle Aktion im empfangenden Modul auszulösen.
Siehe auch
Funktion
bae_sendmsg.
bae_getpackdata - Daten des letzten Projekt-Packagerlaufs abfragen (STD)
Synopsis
int bae_getpackdata( // Status
string; // Projektdateiname
& string; // Rückgabe Layoutbibliotheksdatei
& string; // Rückgabe Netzlistenname
);
Beschreibung
Die Funktion
bae_getpackdata ermittelt die Parameter Layoutbibliotheksdateiname und Netzlistename des für die angebene Projektdatei zuletzt durchgeführten
Packager-Laufs. Der Funktionsrückgabewert ist Null bei erfolgreicher Abfrage oder ungleich Null wenn die Parameterdaten nicht gefunden werden konnten.
Siehe auch
Funktionen bae_getcasstime,
bae_getpacktime.
bae_getpacktime - Datum/Uhrzeit des letzten Projekt-Packagerlaufs abfragen (STD)
Synopsis
int bae_getpacktime( // Status
string; // Projektdateiname
& int; // Rückgabe Zeitangabe Sekunde
& int; // Rückgabe Zeitangabe Minute
& int; // Rückgabe Zeitangabe Stunde
& int; // Rückgabe Datumsangabe Tag
& int; // Rückgabe Datumsangabe Monat
& int; // Rückgabe Datumsangabe Jahr
);
Beschreibung
Die Funktion
bae_getpacktime ermittelt das Datum und die Uhrzeit des für die angebene Projektdatei zuletzt durchgeführten
Packager-Laufs. Der Funktionsrückgabewert ist Null bei erfolgreicher Abfrage oder ungleich Null wenn die Zeitangaben nicht ermittelt werden konnten.
Siehe auch
Funktionen bae_getcasstime,
bae_getpackdata.
bae_getpolyrange - Bereich der internen BAE-Polygonpunktliste abfragen (STD)
Synopsis
int bae_getpolyrange( // Status
& double; // Rückgabe linke Polygongrenze
& double; // Rückgabe untere Polygongrenze
& double; // Rückgabe rechte Polygongrenze
& double; // Rückgabe obere Polygongrenze
);
Beschreibung
Die Funktion
bae_getpolyrange dient der Abfrage der Ausdehnung bzw. Begrenzung des mit
bae_storepoint definierten internen Polypons. Der Funktionsrückgabewert ist Null bei erfolgreicher Abfrage oder ungleich Null im Fehlerfall.
Siehe auch
Funktionen
bae_clearpoints,
bae_storepoint.
bae_getstrpar - BAE Stringparameter abfragen (STD)
Synopsis
int bae_getstrpar( // Status
int [0,[; // Parametertyp/-nummer:
// 0 = Aktueller Element-Kommentartext
// 1 = Aktuelle Element-Spezifikation
// 2 = Letzte Dateizugriffsfehler-Datei
// 3 = Letztes Dateizugriffsfehler-Element
// [ 4 = Systemparameter - kein Lesezugriff ]
// [ 5 = Systemparameter - kein Lesezugriff ]
// 6 = zuletzt geladene Farbtabelle
// 7 = Menütext der zuletzt aufgerufenen Funktion
// 8 = Aktueller Menüitemelementtext
// 9 = Aktuelle benutzerspezifische Elementlademeldung
// 10 = Zwischenablage-Textstring
// 11 = Modulaufruf nächstes Dateiargument
// 12 = Modulaufruf nächstes Elementargument
// 13 = Modulaufruf nächstes Kommando-/Typargument
// 14 = Letzter Ausgabedateiname
// 15 = Hostname
// [ 16 = Systemparameter - kein Lesezugriff ]
// 17 = Datenverzeichnis für alle Benutzer
// 18 = Datenverzeichnis für aktuellen Benutzer
// 19 = Alternatives Verzeichnis für Konfigrationsdaten
// 20 = Spalte lokale Daten
// 21 = Spalt globale Daten
& string; // Rückgabe Parameterwert
);
Beschreibung
Die Funktion
bae_getstrpar dient der Abfrage von im
Bartels AutoEngineer gesetzten Stringparametern. Der Funktionsrückgabewert ist Null bei erfolgreicher Abfrage oder (-1) im Fehlerfall.
Siehe auch
Funktionen bae_getdblpar,
bae_getintpar,
bae_setdblpar,
bae_setintpar,
bae_setstrpar.
bae_inittextscreen - BAE Textbildschirm initialisieren/löschen (STD)
Synopsis
void bae_inittextscreen(
);
Beschreibung
Die Funktion
bae_inittextscreen löscht den Grafikarbeitsbereich für die Textausgabe. Der Textausgabecursor wird auf die linke obere Ecke gesetzt.
bae_inpoint - BAE Eingabe Punkt mit Maus (STD)
Synopsis
int bae_inpoint( // Status
double; // Start X-Koordinate (STD2)
double; // Start Y-Koordinate (STD2)
& double; // Rückgabe X-Koordinate (STD2)
& double; // Rückgabe Y-Koordinate (STD2)
int; // Zeichenmodus:
// 0 = keine Anzeige
// 1 = dynamische Rahmenanzeige
// 2 = dynamische Linienanzeige
// 3 = dynamische Kreisanzeige
// 4 = Gummibandabstandsanzeige
// 5 = Gummibandzoomfensteranzeige
// 6 = Gummibandquadratanzeige
// 7 = Gummibandquadratanzeige zentriert
// 8 = Gummibandfensteranzeige zentriert
// 9 = Gummibandpolygonlinienanzeige
// 10 = Gummibandumrandungspolygonanzeigey
// 11 = Gummibandkreisanzeige zentriert
// 12 = Gummiband fixiert
// 13 = Gummiband zentriertes Zoomfenster
// 14 = Keine Fensteranzeige, RMB unmittelbarer Abbruch
// 15 = Anzeige mit festem Offset
);
Beschreibung
Die Funktion
bae_inpoint dient zur Wahl von Koordinaten mit der Maus. Die beiden Startkoordinaten definieren den Ausgangspunkt für
Kommandos. In den beiden Rückgabeparametern wird das mit Maustastendruck gewählte Koordinatenpaar zurückgegeben. Ist der Zeichenmodus 1, dann wird bei der Koordinatenwahl dynamisch ein Rahmen von den Startkoordinaten zu den aktuellen Mauskoordinaten gezeichnet.
Ist der Zeichenmodus 2, dann wird während der Koordinatenwahl dynamisch eine Linie von den Startkoordinaten zu den aktuellen Mauskoordinaten gezeichnet. Der Rückgabewert ist (-1) beim Abbruch der Eingabe oder Null wenn ein Koordinatenpaar gewählt wurde.
Siehe auch
Funktion
bae_inpointmenu.
bae_inpointmenu - BAE Eingabe Punkt mit Maus und Callbackfunktion für rechte Maustaste (STD)
Synopsis
int bae_inpointmenu( // Status
double; // Start X-Koordinate (STD2)
double; // Start Y-Koordinate (STD2)
& double; // Rückgabe X-Koordinate (STD2)
& double; // Rückgabe Y-Koordinate (STD2)
int; // Zeichenmodus:
// 0 = keine Anzeige
// 1 = dynamische Rahmenanzeige
// 2 = dynamische Linienanzeige
// 3 = dynamische Kreisanzeige
// 4 = Gummibandabstandsanzeige
// 5 = Gummibandzoomfensteranzeige
// 6 = Gummibandquadratanzeige
// 7 = Gummibandquadratanzeige zentriert
// 8 = Gummibandfensteranzeige zentriert
// 9 = Gummibandpolygonlinienanzeige
// 10 = Gummibandumrandungspolygonanzeigey
// 11 = Gummibandkreisanzeige zentriert
// 12 = Gummiband fixiert
// 13 = Gummiband zentriertes Zoomfenster
// 14 = nicht benutzt
// 15 = Anzeige mit festem Offset
* int; // Callbackfunktion für rechte Maustaste
);
Beschreibung
Die Funktion
bae_inpointmenu dient zur Wahl von Koordinaten mit der Maus. Die beiden Startkoordinaten definieren den Ausgangspunkt für
Kommandos. In den beiden Rückgabeparametern wird das mit Maustastendruck gewählte Koordinatenpaar zurückgegeben. Ist der Zeichenmodus 1, dann wird während der Koordinatenwahl dynamisch ein Rahmen von den Startkoordinaten zu den aktuellen Mauskoordinaten gezeichnet. Ist der Zeichenmodus 2, dann wird während der Koordinatenwahl dynamisch eine Linie von den Startkoordinaten zu den aktuellen Mauskoordinaten gezeichnet. Der letzte Funktionsparameter ermöglicht die Spezifikation einer Callbackfunktion zur Aktivierung beim Drücken der rechten Maustasten (z.B. zur Anzeige spezifischer Optionsmenüs). Der Rückgabewert ist (-1) beim Abbruch der Eingabe oder Null wenn ein Koordinatenpaar gewählt wurde.
Definition der Callkbackfunktion für die rechte Maustaste
int callbackfunction( // Status
double x // Aktuelle Eingabe-X-Koordinate
double y // Aktuelle Eingabe-Y-Koordinate
)
{
// Verarbeitungsprogramm
:
return(status);
}
Der Rückgabewert der Callbackfunktion sollte 0 sein zur Signalisierung der Komplettierung der Eingabe, 1 wenn die Eingabe fortzusetzen ist, oder ein beliebiger anderer Wert bei Abbruch der Eingabe. Bei Komplettierung der Eingabe (Rückgabewert 0) können geänderte Parameterwerte für die X- und Y-Koordinaten zurückgegeben werden.
Siehe auch
Funktion
bae_inpoint.
bae_language - BAE Benutzeroberfläche Landessprache abfragen (STD)
Synopsis
string bae_language( // Rückgabe Landessprachencode:
// DE = deutsch
// EN = englisch
// für künftige Anwendungen
// FR = französisch
// IT = italienisch
// SP = spanisch
// SV = schwedisch
);
Beschreibung
Die Funktion
bae_language gibt einen Code zur Identifikation der in der BAE-Benutzeroberfläche verwendeten Landessprache zurück. Diese Information kann dazu verwendet werden, Meldungen und Menüs dynamisch an die jeweilige Landessprache anzupassen.
bae_loadcoltab - BAE Farbtabelle laden (STD)
Synopsis
int bae_loadcoltab( // Status
string; // Farbtabellenname
);
Beschreibung
Mit der Funktion
bae_loadcoltab wird die in der übergebenen Zeichenkette angegebene Farbtabelle geladen. Der Rückgabewert ist ungleich Null, wenn der Ladevorgang nicht erfolgreich war.
bae_loadelem - BAE Element laden (STD)
Synopsis
int bae_loadelem( // Status
string; // Elementdateiname
string; // Elementname
int [100,[; // Elementklasse (STD1)
);
Beschreibung
Die Funktion
bae_loadelem lädt im
AutoEngineerr ein Planelement in den Speicher. Im
Schaltplaneditor sind die möglichen Werte für die Klassenangabe gegeben durch 800, 801, 802 oder 803 für SCM Stromlaufblatt, SCM Symbol, SCM Marker oder SCM Label. In den Layoutmodulen sind die zulässigen Werte für die Klassenangabe gegeben durch 100, 101, 102 oder 103 für Layout, Layout Bauteil, Layout Padstack oder Layout Pad. Im
IC-Design System sind die zulässigen Werte für die Klassenangabe gegeben durch 1000, 1001 oder 1002 für IC-Layout, IC-Zelle oder IC-Pin. Der Rückgabewert ist Null, wenn keine Fehler aufgetreten sind, (-2) bei ungültiger Elementklassenangabe, (-1) bei Dateizugriffsfehlern, 1 wenn der Zeichensatz nicht geladen werden konnte, 2 wenn einzelne referenzierte Makros (Bibliothekselemente) nicht geladen werden konnten, oder 3 bei unplatzierten Bauteilen bzw. fehlenden Pins, d.h. wenn auf einem Layoutplan platzierte Gehäusetypen nicht mit den in der Netzliste eingetragenen Typen übereinstimmen.
Bei Angabe der Elementklasse 100 für Layouts kann wahlweise ein Leerstring für den Elementnamen übergeben werden. In diesem Fall wird automatisch das Layoutelement mit dem im System eingestellten Default-Layoutelementnamen geladen (siehe hierzu Kommando
LAYDEFELEMENT für
bsetup).
Beim Laden von Stromlaufblättern in den
Schaltplaneditor führt
bae_loadelem automatisch eine
Backannotation durch sofern dies aufgrund vorheriger Netzlistenmodifikationen im Layout erforderlich ist.
Warnung
Diese Funktion ändert sämtliche im Speicher vorhandenen Elementdaten und damit die Gültigkeit der Indexvariablen und sollte daher nur außerhalb jeglicher Programmblöcke mit Zugriff auf Indexvariablen (forall-Schleifen) aufgerufen werden. Vor Aufruf dieser Funktion sollte auf jeden Fall mit
bae_plannotsaved nachgeprüft werden, ob das aktuelle Element mit allen Änderungen gesichert ist, da ein
nach
bae_loadelem nicht möglich ist.
bae_loadfont - BAE Zeichensatz laden (STD)
Synopsis
int bae_loadfont( // Status
string; // Zeichensatzname
);
Beschreibung
Mit der Funktion
bae_loadfont wird der Zeichensatz mit dem in der übergebenen Zeichenkette spezifizierten Namen geladen. Der Rückgabewert ist ungleich Null, wenn der Ladevorgang nicht erfolgreich war.
bae_menuitemhelp - Onlinehilfe zu BAE-Menüelement anzeigen (STD)
Synopsis
int bae_menuitemhelp( // Status
int [0,9999]; // Menücode (STD4)
string; // Help-Dateiname (Windows .hlp-Datei)
);
Beschreibung
Die Funktion
bae_menuitemhelp zeigt die Onlinehilfe zu dem über den Menücode angegebenen Topic an. Der Rückgabewert ist ungleich Null, wenn ungültige Parameter spezifiziert wurden.
Einschränkungen
bae_menuitemhelp ist nur unter Windows funktionsfähig.
bae_msgbox - BAE Info-Popup aktivieren (STD)
Synopsis
void bae_msgbox(
int; // Info-Popup Stil/Piktogramm:
// 0 = Info (Information)
// 1 = Warnung (Ausrufezeichen)
// 2 = Fehler (Fragezeichen)
// 3 = Fataler Fehler (Stoppzeichen)
// sonst = kein Piktogramm
string; // Info-Popup Text
string; // Info-Popup Titel
);
Beschreibung
Die Funktion
bae_msgbox aktiviert ein Info-Popupfenster mit einer Bestätigungsabfrage (Schaltfläche
). Auf das Erscheinungsbild des Info-Fensters kann über den ersten Parameter Einfluss genommen werden. Der angegeben Text wird innerhalb des Popupfensters angezeigt. Der Titel erscheint als Überschrift in der Titelleiste des Popupfensters. Das Erscheinungsbild bzw. das Layout des Popupfensters (Fensterposition, Titelanzeige, Schaltflächensymbole, Textausrichtung, Zeilenumbruch, usw.) kann je nach Betriebssystemplattform variieren.
Siehe auch
Funktionen
bae_msgboxverify,
bae_msgboxverifyquit.
bae_msgboxverify - BAE Info-Popup Ja/Nein-Abfrage aktivieren (STD)
Synopsis
int bae_msgboxverify( // Rückgabe Antwortcode:
// 1 = Ja
// 0 = Nein (Default)
string; // Info-Popup Text
string; // Info-Popup Titel
);
Beschreibung
Die Funktion
bae_msgboxverify aktiviert ein Info-Popupfenster mit einer Ja/Nein-Abfrage. Der Funktionsrückgabewert ergibt sich zu 1 bei Eingabe bzw. Selektion von "Ja" und zu Null bei allen anderen Eingaben. Der angegeben Text wird innerhalb des Popupfensters angezeigt. Der Titel erscheint als Überschrift in der Titelleiste des Popupfensters. Das Erscheinungsbild bzw. das Layout des Popupfensters (Fensterposition, Titelanzeige, Schaltflächensymbole, Textausrichtung, Zeilenumbruch, usw.) kann je nach Betriebssystemplattform variieren.
Siehe auch
Funktionen
bae_msgbox,
bae_msgboxverifyquit.
bae_msgboxverifyquit - BAE Info-Popup mit Ja/Nein/Abbruch-Abfrage aktivieren (STD)
Synopsis
int bae_msgboxverifyquit( // Rückgabe Antwortcode:
// 1 = Ja
// 0 = Nein
// sonst = Abbruch (Default)
string; // Info-Popup Text
string; // Info-Popup Titel
);
Beschreibung
Die Funktion
bae_msgboxverifyquit aktiviert ein Info-Popupfenster mit einer Ja/Nein/Abbruch-Abfrage. Der Funktionsrückgabewert ergibt sich zu 1 bei Eingabe bzw. Selektion von
und zu Null bei Eingabe bzw. Selektion von
. Alle anderen Eingaben werden als Abbruchanforderung interpretiert. Der angegeben Text wird innerhalb des Popupfensters angezeigt. Der Titel erscheint als Überschrift in der Titelleiste des Popupfensters. Das Erscheinungsbild bzw. das Layout des Popupfensters (Fensterposition, Titelanzeige, Schaltflächensymbole, Textausrichtung, Zeilenumbruch, usw.) kann je nach Betriebssystemplattform variieren.
Siehe auch
Funktionen
bae_msgbox,
bae_msgboxverify.
bae_msgprogressrep - BAE-Fortschrittsanzeige aktivieren/aktualisieren (STD)
Synopsis
int bae_msgprogressrep( // Rückgabe Status
string; // Fortschrittsanzeige Text
int [0,258]; // Fortschrittsanzeige Typ:
// 1 : Prozentualer Fortschritt
// 2 : Fortschrittsschiebebalken
// |256 : Abbruchschaltfläche anzeigen
int [0,10000]; // Fortschrittsanzeige Komplettierungsstatus [%*100]
int [0,[; // Fortschrittsanzeige Minimalbreite [in Zeichen]
);
Beschreibung
Die Funktion bae_msgprogressrep aktiviert bzw. aktualisiert die BAE-Fortschrittsanzeige mit den angegebenen Parametern. Der Funktionsrückgabewert ist Null, wenn die Funktion erfolgreich ausgeführt wurde, oder ungleich Null im Fehlerfall (bei Spezifikation ungültiger Parameter). Eine mit bae_msgprogressrep kann mit bae_msgprogressterm wieder beendet werden.
Siehe auch
Funktion bae_msgprogressterm.
bae_msgprogressterm - BAE-Fortschrittsanzeige beenden (STD)
Synopsis
void bae_msgprogressterm(
);
Beschreibung
Die Funktion bae_msgprogressterm beendet die mit bae_msgprogressrep aktivierte BAE-Fortschrittsanzeige.
Siehe auch
Funktion bae_msgprogressrep.
bae_mtpsize - BAE Popup Anzeigebereichsdimensionen abfragen (STD)
Synopsis
void bae_mtpsize(
& int; // Rückgabe Popupmenü Textspaltenanzahl
& int; // Rückgabe Popupmenü Textzeilenanzahl
);
Beschreibung
Die Funktion
bae_mtpsize ermittelt die Größe des maximal verfügbaren Anzeigebereichs zur Definition von Popupmenüs oder Toolbars mit Hilfe der Funktionen
bae_popshow und
bae_settbsize. Die Breite des Anzeigebereichs wird im Parameter für die Textspaltenanzahl zurückgegeben, während die Höhe des Anzeigebereichs im Parameter für die Textzeilenanzahl zurückgegeben wird. Mit Hilfe der Funktion
bae_charsize können diese Werte in Standardlängeneinheiten umgerechnet werden.
Siehe auch
Funktionen
bae_charsize,
bae_popshow,
bae_settbsize,
bae_twsize.
bae_nameadd - BAE Namensauswahlliste Element hinzufügen (STD)
Synopsis
int bae_nameadd( // Namenslistenindex/ID oder (-1) im Fehlerfall
string; // Name
string; // Datumsstring
string; // Datumssortierstring
int; // Sortiermodus:
// 0 = anfügen (keine Sortierung)
// 1 = Sortierung alphanumerisch
// 2 = Sortierung numerisch
// 3 = Sortierung nach Datum
// 4 = Sortierung für ID-Generierung
);
Beschreibung
Die Funktion
bae_nameadd fügt einen Eintrag in die interne BAE-Namensauswahlliste ein. Diese Liste wird von der Funktion
bae_askname zur Aktivierung von Namensauswahldialogen benutzt. Die Funktion
bae_nameclr kann bzw. sollte vor dem ersten Aufruf von
bae_nameadd benutzt werden, um eventuell von vorhergehenden Applikationen vorhandene Namenseinträge aus der Namensauswahlliste zu entfernen. Die Funktion gibt den ermittelten Namenslistenindex bzw. eine ID zurück wenn die Operation erfolgreich oder (-1) im Fehlerfall.
Siehe auch
Funktionen bae_askname,
bae_nameclr,
bae_nameget.
bae_nameclr - BAE Namensauswahlliste löschen (STD)
Synopsis
void bae_nameclr(
);
Beschreibung
Die Funktion
bae_nameclr löscht die aktuell mit
bae_nameadd definierte Namensliste aus dem Arbeitsspeicher.
Siehe auch
Funktionen bae_askname,
bae_nameadd,
bae_nameget.
bae_nameget - BAE Namensauswahlliste Element abfragen (STD)
Synopsis
int bae_nameget( // Status
int; // Namenslistenindex
& string; // Rückgabe Name
& string; // Rückgabe Datumsstring
& string; // Rückgabe Datumssortierstring
& string; // Rückgabe Kommentar
& int; // Rückgabe Namenseintraganzahl oder Namens-ID
);
Beschreibung
Die Funktion
bae_nameget dient der Abfrage von zuvor mit
bae_nameadd definierten Einträgen in der BAE-Namensauswahlliste. Der Funktionsrückgabewert ist Null bei erfolgreicher Abfrage oder ungleich Null im Fehlerfall.
Siehe auch
Funktionen bae_askname,
bae_nameadd,
bae_nameclr.
bae_numstring - Numerische Zeichenkette erzeugen (STD)
Synopsis
string bae_numstring( // Rückgabe numerische Zeichenkette
double; // Eingabewert
int [0,[; // Maximale Genauigkeit/Nachkommastellen
);
Beschreibung
Die Funktion
bae_numstring konvertiert den Eingabewert in eine numerische Zeichenkette mit der über die maximale Genauigkeit angegebenen Zahl von Nachkommastellen.
bae_peekiact - BAE Interaktionsvorgaben abfragen (STD)
Synopsis
int bae_peekiact( // Rückgabe Interaktionsstatus/-modus:
// 0 = Keine automatische Interaktion anstehend
// 1 = Mausinteraktion anstehend
// 2 = Textinteraktion anstehend
// 3 = Menüinteraktion anstehend
// 4 = Tastaturinteraktion anstehen
);
Beschreibung
Mit der Funktion
bae_peekiact können die aktuellen Interaktionsvorgaben überprüft werden.
Der Funktionsrückgabewert ist der Typcode der nächsten anstehenden automatischen Interaktion oder Null wenn keine automatisch Interaktion ansteht.
Siehe auch
Funktionen
bae_storekeyiact,
bae_storemenuiact,
bae_storemouseiact,
bae_storetextiact.
bae_plainmenutext - BAE Menütext konvertieren (STD)
Synopsis
string bae_plainmenutext( // Zeichenkette
string; // Menütext
);
Beschreibung
Die Funktion
bae_plainmenutext wandelt den über den Funktionsparameter übergebenen Menütext in normalen Text ohne Sonderzeichen für Menütrennzeilen
(%), Beschleuniger
(&), usw. um. Die resultierende Zeichenkette wird als Funktionsergebnis an den Aufrufer zurückgegeben.
Siehe auch
Funktionen
bae_defmenutext,
bae_getmenutext.
bae_planddbclass - BAE Elementklasse abfragen (STD)
Synopsis
int bae_planddbclass( // Elementklasse (STD1)
);
Beschreibung
Der Rückgabewert der Funktion
bae_planddbclass entspricht der Datenbankklasse des aktuell geladenen Elements. Die im
Schaltplaneditor möglichen Rückgabewerte 800, 801, 802 und 803 stehen für SCM Stromlaufblatt, SCM Symbol, SCM Marker und SCM Label. Die in den Layoutmodulen möglichen Rückgabewerte 100, 101, 102 und 103 stehen für Layout, Layout Bauteil, Layout Padstack und Layout Pad. Die im
IC-Design möglichen Rückgabewerte 1000, 1001 und 1002 stehen für IC-Layout, IC-Zelle und IC-Pin. Der Rückgabewert (-1) gibt an, dass kein Element geladen ist.
bae_planename - BAE Elementname abfragen (STD)
Synopsis
string bae_planename( // Elementname
);
Beschreibung
Der Rückgabewert der Funktion
bae_planename entspricht dem Elementnamen des aktuell geladenen Elements oder der Nullzeichenkette, wenn kein Element geladen ist.
Siehe auch
Funktion
bae_plansename.
bae_planfname - BAE Dateiname abfragen (STD)
Synopsis
string bae_planfname( // Element Dateiname
);
Beschreibung
Der Rückgabewert der Funktion
bae_planfname entspricht dem Dateinamen des aktuell geladenen Elements oder der Nullzeichenkette, wenn kein Element geladen ist.
Siehe auch
Funktionen
bae_plansfname,
bae_setplanfname.
bae_plannotsaved - BAE Element ungesichert Flag abfragen (STD)
Synopsis
int bae_plannotsaved( // Element ungesichert Flag:
// 0 = Element gesichert
// 1 = Element nicht gesichert
);
Beschreibung
Der Rückgabewert der Funktion
bae_plannotsaved gibt an, ob das aktuell geladene Element gesichert ist. Der Wert ist ungleich Null, wenn seit dem letzten Speichern des aktuellen Elements Änderungen an diesem vorgenommen wurden.
bae_plansename - BAE Zielelementname abfragen (STD)
Synopsis
string bae_plansename( // Zielelementname
);
Beschreibung
Der Rückgabewert der Funktion
bae_plansename entspricht dem Zielelementnamen des aktuell geladenen Elements oder der Nullzeichenkette, wenn kein Element geladen ist. Diese Funktion kann für Elementnamensabfragen während der Ausführung der Funktion
benutzt werden.
Siehe auch
Funktion
bae_planename.
bae_plansfname - BAE Zieldateiname abfragen (STD)
Synopsis
string bae_plansfname( // Zieldateiname
);
Beschreibung
Der Rückgabewert der Funktion
bae_plansfname entspricht dem Zieldateinamen des aktuell geladenen Elements oder der Nullzeichenkette, wenn kein Element geladen ist. Diese Funktion kann für Elementdateinamensabfragen während der Ausführung der Funktion
benutzt werden.
Siehe auch
Funktion
bae_planfname.
bae_planwslx - BAE Element linke Elementgrenze abfragen (STD)
Synopsis
double bae_planwslx( // Koordinatenwert (STD2)
);
Beschreibung
Der Rückgabewert der Funktion
bae_planwslx entspricht der linken Begrenzungskoordinate des aktuell geladenen Elements.
bae_planwsly - BAE Element untere Elementgrenze abfragen (STD)
Synopsis
double bae_planwsly( // Koordinatenwert (STD2)
);
Beschreibung
Der Rückgabewert der Funktion
bae_planwsly entspricht der untereb Begrenzungskoordinate des aktuell geladenen Elements.
bae_planwsnx - BAE Element X-Bezugskoordinate abfragen (STD)
Synopsis
double bae_planwsnx( // Koordinatenwert (STD2)
);
Beschreibung
Der Rückgabewert der Funktion
bae_planwsnx entspricht dem X-Koordinatenbezugspunkt des aktuell geladenen Elements.
bae_planwsny - BAE Element Y-Bezugskoordinate abfragen (STD)
Synopsis
double bae_planwsny( // Koordinatenwert (STD2)
);
Beschreibung
Der Rückgabewert der Funktion
bae_planwsny entspricht dem Y-Koordinatenbezugspunkt des aktuell geladenen Elements.
bae_planwsux - BAE Element rechte Elementgrenze abfragen (STD)
Synopsis
double bae_planwsux( // Koordinatenwert (STD2)
);
Beschreibung
Der Rückgabewert der Funktion
bae_planwsux entspricht der rechten Begrenzungskoordinate des aktuell des aktuell geladenen Elements.
bae_planwsuy - BAE Element obere Elementgrenze abfragen (STD)
Synopsis
double bae_planwsuy( // Koordinatenwert (STD2)
);
Beschreibung
Der Rückgabewert der Funktion
bae_planwsuy entspricht der oberen Begrenzungskoordinate des aktuell geladenen Elements.
bae_popareachoice - BAE Popupmenü Selektionsbereich definieren (STD)
Synopsis
int bae_popareachoice( // Status
double [0.0,[; // Startzeilennummer
double [0.0,[; // Startspaltennummer
double [0.0,[; // Endzeilennummer
double [0.0,[; // Endspaltennummer
string; // Antwort-Zeichenkette
);
Beschreibung
Die Funktion
bae_popareachoice definiert einen rechteckförmigen Selektionsbereich innerhalb des aktuell aktiven Popupmenübereichs. Der aktive Popupmenübereich wird mit der Funktion
bae_popsetarea selektiert und ist entweder der mit
bae_popshow definierte Popupmenübereich oder der mit
bae_settbsize definierte Toolbarbereich. Der Selektionsbereich wird mit den Funktionsparametern für die Zeilen- bzw. Spaltenbereiche definiert, wobei Zeilen von oben nach unten und Spalten von links nach rechts gezählt werden. Mit der Funktion
bae_tbsize kann die aktuelle Toolbargröße ermittelt werden. Mit Hilfe der Funktion
bae_charsize können Textkoordinaten in Standardlängeneinheiten konvertiert werden. Der Parameter für die Anwort-Zeichenkette definiert den Text, der später bei Selektionen im definierten Selektionsbereich durch die Funktion
bae_readtext zurückzugeben ist. Der Rückgabewert der Funktion
bae_popareachoice ist (-1) im Fehlerfall, 1 bei erfolgreicher Generierung einer Schaltfläche, oder Null bei erfolgreicher Definition des Selektionsbereichs.
Siehe auch
Funktionen bae_charsize,
bae_popcolbar,
bae_popcolchoice,
bae_popsetarea,
bae_popshow,
bae_poptext,
bae_poptextchoice,
bae_readtext,
bae_settbsize,
bae_tbsize.
bae_popcliparea - BAE Popupmenü Clippingbereich definieren (STD)
Synopsis
void bae_popcliparea(
int [0,1]; // Clippingmodus:
// 0 = Clipping deaktivieren
// 1 = Clipping aktivieren
double [0.0,[; // Startzeilennummer
double [0.0,[; // Startspaltennummer
double [0.0,[; // Endzeilennummer
double [0.0,[; // Endspaltennummer
);
Beschreibung
Die Funktion
bae_popcliparea aktiviert (Clippingmodus 1) bzw. deaktiviert (Clippingmodus 0) das sogenannte Clipping innerhalb des aktuell aktiven Popupmenübereichs. Der aktive Popupmenübereich wird mit der Funktion
bae_popsetarea selektiert und ist entweder der mit
bae_popshow definierte Popupmenübereich oder der mit
bae_settbsize definierte Toolbarbereich. Mit dem Clippingverfahren können Grafikausgaben in den Popupmenüs bzw. Toolbars automatisch auf spezielle Teilbereiche der Anzeige beschränkt werden, was insbesondere bei der Generierung von Ausschnittszeichnungen mit Hilfe der Funktion
bae_popdrawpoly von besonderem Nutzen ist. Der Clippingbereich wird mit den Funktionsparametern für die Zeilen- bzw. Spaltenbereiche definiert, wobei Zeilen von oben nach unten und Spalten von links nach rechts gezählt werden. Mit Hilfe der Funktion
bae_charsize können Textkoordinaten in Standardlängeneinheiten konvertiert werden.
Siehe auch
Funktionen
bae_charsize,
bae_popdrawpoly,
bae_popsetarea,
bae_popshow,
bae_settbsize.
bae_popclrtool - BAE Toolbar-Popupmenübereich löschen (STD)
Synopsis
void bae_popclrtool(
);
Beschreibung
Mit der Funktion
bae_popclrtool können sämtliche Anzeigen im aktuellen Toolbarbereich gelöscht bzw. deaktiviert werden.
Siehe auch
Funktionen
bae_popsetarea,
bae_settbsize.
bae_popcolbar - BAE Popupmenü Farbbalkenanzeige definieren (STD)
Synopsis
int bae_popcolbar( // Status
double [0.0,[; // Startzeilennummer
double [0.0,[; // Startspaltennummer
double [0.0,[; // Endzeilennummer
double [0.0,[; // Endspaltennummer
int [0,[; // Farbwert (STD18)
);
Beschreibung
Die Funktion
bae_popcolbar definiert einen nicht selektierbaren Farbbalken innerhalb des zuvor mit
bae_popshow aktivierten Popupmenüs. Die Größe und die Position für die Anzeige des Farbbalkens ergeben sich aus den übergebenen Zeilen- und Spaltenparametern; die Koordinate [0,0] bezieht sich dabei auf die linke obere Ecke des Popupbereiches. Der Farbwert-Parameter definiert die Farbe des Farbbalkens. Der Rückgabewert der Funktion ist ungleich Null, wenn fehlerhafte Parameter übergeben wurden.
Siehe auch
Funktionen
bae_popareachoice,
bae_popcolchoice,
bae_popshow,
bae_poptext,
bae_poptextchoice.
bae_popcolchoice - BAE Popupmenü Farbbalkenselektion definieren (STD)
Synopsis
int bae_popcolchoice( // Status
double [0.0,[; // Startzeilennummer
double [0.0,[; // Startspaltennummer
double [0.0,[; // Endzeilennummer
double [0.0,[; // Endspaltennummer
int [0,[; // Farbwert (STD18)
string; // Antwort-Zeichenkette
);
Beschreibung
Die Funktion
bae_popcolchoice definiert einen maus-selektierbaren Farbbalken innerhalb des zuvor mit
bae_popshow aktivierten Popupmenüs. Die Größe und die Position für die Anzeige des Farbbalkens ergeben sich aus den übergebenen Zeilen- und Spaltenparametern; die Koordinate [0,0] bezieht sich dabei auf die linke obere Ecke des Popupbereiches. Der Farbwert-Parameter definiert die Farbe des Farbbalkens. Der Rückgabewert der Funktion ist ungleich Null, wenn fehlerhafte Parameter übergeben wurden. Die Selektion des mit
bae_popcolchoice definierten Farbbalkens ist nach einer Aktivierung der Funktion
bae_readtext möglich. Durch die Selektion des Farbbalkens wird die Funktion
bae_readtext beendet; der Rückgabewert von
bae_readtext ergibt sich dabei automatisch aus der Antwort-Zeichenkette, die beim Aufruf der Funktion
bae_popcolchoice angegeben wurde.
Siehe auch
Funktionen
bae_popareachoice,
bae_popcolbar,
bae_popshow,
bae_poptext,
bae_poptextchoice,
bae_readtext.
bae_popdrawpoly - BAE Popupmenü Polygon-/Grafikanzeige (STD)
Synopsis
int bae_popdrawpoly( // Status
int [0,[; // Polygon Farbe (STD18)
int [0,3]; // Polygon Zeichenmodus (STD19)
int [0,15]; // Polygon Füllmodus (STD20)
);
Beschreibung
Die Funktion
bae_popdrawpoly bildet das mit
bae_storepoint generierte interne Polygon in der angegebenen Farbe und unter Berücksichtigung der spezifizierten Parameter für den Zeichen- und Füllmodus im aktuell aktiven Popupmenübereich ab. Der aktive Popupmenübereich wird mit der Funktion
bae_popsetarea selektiert und ist entweder der mit
bae_popshow definierte Popupmenübereich oder der mit
bae_settbsize definierte Toolbarbereich. Die Polygonanzeige kann mit Hilfe der Funktion
bae_popcliparea auf einen speziellen Teilbereich des Popupmenüs beschränkt werden. Mit Hilfe der Funktion
bae_popareachoice können ein oder mehrere Teilbereiche der Polygonanzeige für eine spätere Selektion durch die Funktion
bae_readtext vorgesehen werden. Zur Vorbereitung der Definition neuer Polygone kann das aktuell generierte, interne Polygon mit der Funktion
bae_clearpoints gelöscht werden. Die Basislänge für die Ausgabe gestrichelter Linienzüge kann mit Hilfe der Funktion
bae_setpopdash gesetzt werden. Der Rückgabewert der Funktion
bae_popdrawpoly ist Null, wenn die Polygongenerierung erfolgreich durchgeführt wurde, oder ungleich Null im Fehlerfall.
Siehe auch
Funktionen
bae_clearpoints,
bae_dialbmpalloc,
bae_popareachoice,
bae_popcliparea,
bae_popcolbar,
bae_popcolchoice,
bae_popdrawtext,
bae_popsetarea,
bae_popshow,
bae_readtext,
bae_setpopdash,
bae_settbsize,
bae_storepoint.
bae_popdrawtext - BAE Popupmenü Textanzeige (STD)
Synopsis
int bae_popdrawtext( // Status
int; // Text Zeile
int; // Text Spalte
int [0,[; // Text Farbe (STD18)
int [0,[; // Text Hintergrundfarbe (STD18)
string; // Text String
);
Beschreibung
Die Funktion
bae_popdrawtext zeigt den angegebenen Text an den spezifizierten Zeilen- und Spaltenkoordinaten im aktuell aktiven Popupmenübereich an, wobei zur Darstellung die angegebenen Farben für den Text bzw. den Texthintergrund verwendet werden. Der aktive Popupmenübereich wird mit der Funktion
bae_popsetarea selektiert und ist entweder der mit
bae_popshow definierte Popupmenübereich oder der mit
bae_settbsize definierte Toolbarbereich. Mit Hilfe der Funktion
bae_charsize können Textkoordinaten in Standardlängeneinheiten konvertiert werden. Mit Hilfe der Funktion
bae_popareachoice können ein oder mehrere Teilbereiche der Textanzeige für eine spätere Selektion durch die Funktion
bae_readtext vorgesehen werden. Der Rückgabewert der Funktion
bae_popdrawtext ist Null, wenn die Textgenerierung erfolgreich durchgeführt wurde, oder ungleich Null im Fehlerfall.
Siehe auch
Funktionen
bae_charsize,
bae_dialbmpalloc,
bae_popareachoice,
bae_popdrawpoly,
bae_popsetarea,
bae_popshow,
bae_readtext,
bae_settbsize.
bae_popmouse - BAE Popup/Toolbar Mausposition abfragen (STD)
Synopsis
void bae_popmouse(
& double; // Rückgabe Maus-X-Koordinate/Spalte
& double; // Rückgabe Maus-Y-Koordinate/Reihe
& int; // Rückgabe Mausstatus:
// Bit 1 : linke Maustaste gedrückt
// Bit 2 : rechte Maustaste gedrückt
// Bit 3 : mittlere Maustaste gedrückt
);
Beschreibung
Mit der Funktion
bae_popmouse können die aktuellen Mauskoordinaten (Spalte und Reihe) innerhalb des Popup- bzw. Toolbarbereichs ermittelt werden. Der Parameter zur Rückgabe des Mausstatus gibt an, welche Maustasten gerade gedrückt sind.
Siehe auch
Funktion
bae_wsmouse.
bae_poprestore - BAE Popupmenübereich reaktivieren (STD)
Synopsis
void bae_poprestore(
);
Beschreibung
Die Funktion
bae_poprestore deaktiviert das zuvor mit
bae_popshow aktivierte Popupmenü und reaktiviert ggf. wieder die Anzeige des durch das Popupmenü überdeckten Grafikarbeitsbereiches.
Siehe auch
Funktion
bae_popshow.
bae_popsetarea - BAE Toolbar-Popupmenübereich löschen (STD)
Synopsis
void bae_popsetarea(
int // Popupbereich:
// 0 = Popupmenübereich
// 1 = Toolbarbereich
// 2..31 = Dialogbitmapbereich
);
Beschreibung
Die Funktion
bae_popsetarea dient dazu, wahlweise das Standard-Popupmenü (Popupbereich 0), die Toolbar (Popupbereich 1) oder eine Dialogbitmap (Popupbereich bzw. Popupbitmapnummer 2 bis 31) für nachfolgende Popupoperationen wie z.B.
bae_popareachoice,
bae_popcliparea,
bae_popdrawpoly oder
bae_popdrawtext zu aktivieren. Die Definition bzw. Anzeige des Standard-Popupmenübereichs erfolgt mit Hilfe der Funktion
bae_popshow. Die Definition bzw. Anzeige des Toolbar-Popupmenübereichs erfolgt mit Hilfe der Funktion
bae_settbsize. Wenn mit
bae_popsetarea kein Popupmenübereich explizit aktiviert wurde, dann ist zunächst das Standard-Popupmenü für Popupoperationen selektiert.
Siehe auch
Funktionen
bae_dialbmpalloc,
bae_popareachoice,
bae_popcliparea,
bae_popdrawpoly,
bae_popdrawtext,
bae_popshow,
bae_settbsize.
bae_popshow - BAE Popupmenü aktivieren (STD)
Synopsis
int bae_popshow( // Status
& double [0.0,[; // Popup-Zeilenanzahl
& double [0.0,[; // Popup-Spaltenanzahl
& double [0,1.0]; // Linke Popup-Begrenzung
& double [0,1.0]; // Untere Popup-Begrenzung
& double [0,1.0]; // Rechte Popup-Begrenzung
& double [0,1.0]; // Obere Popup-Begrenzung
);
Beschreibung
Die Funktion
bae_popshow erzeugt ein Popupmenü in der angegebenen Größe. Die Position sowie die maximale Ausdehnung des Popupmenüs ergeben sich aus den Popup-Begrenzungsparametern; die angegebenen Werte verstehen sich dabei als Relativwerte in Bezug auf die Größe des zur Verfügung stehenden Grafikarbeitsbereiches; der Wert 0.0 steht dabei für Minimalgröße, der Wert 1.0 für Maximalgröße. Die Anzahl der maximal anzeigbaren Spalten und Zeilen kann mit der Funktion
bae_mtpsize ermittelt werden. Die Parameter für die Popupzeilen- und Popupspaltenanzahl definieren als Eingabeparameter die gewünschte Größe des Popupmenüs. Die innerhalb der angegebenen Popupbegrenzung tatsächlich darstellbaren Zeilen und Spalten werden durch die Funktion
bae_popshow automatisch berechnet und in den entsprechenden Parametern an den Aufrufer wieder zurückgegeben. Der Rückgabewert der Funktion
bae_popshow ist ungleich Null, wenn ungültige oder sich widersprechende Parameter übergeben wurden. Die Menüfarben für Texte, Hintergrund und Rahmen des Popups ergeben sich aus den mit dem Utilityprogramm
bsetup im BAE Setup entsprechend eingetragenen Farbwerten. Nach dem Aufruf der Funktion
bae_popshow können mit den Funktionen
bae_popareachoice,
bae_popcolbar,
bae_popcolchoice,
bae_popdrawpoly,
bae_popdrawtext,
bae_poptext und
bae_poptextchoice selektierbare und nicht selektierbare Farbbalken, Anzeigetexte, Grafiken und Selektionsbereiche definiert werden. Die Popupmenüauswahl kann anschließend mit der Funktion
bae_readtext aktiviert werden.
Warnung
Zur Freigabe eines durch ein Popupmenü belegten Grafikarbeitsbereiches ist die Funktion
bae_poprestore zu benutzen.
Siehe auch
Funktionen
bae_mtpsize,
bae_popareachoice,
bae_popcliparea,
bae_popcolbar,
bae_popcolchoice,
bae_popdrawpoly,
bae_popdrawtext,
bae_poprestore,
bae_popsetarea,
bae_poptext,
bae_poptextchoice,
bae_readtext,
bae_settbsize sowie BAE Utilityprogramm
bsetup.
bae_poptext - BAE Popupmenü Textanzeige definieren (STD)
Synopsis
int bae_poptext( // Status
double [0.0,[; // Zeilennummer
double [0.0,[; // Spaltennummer
string; // Anzeige-Zeichenkette
);
Beschreibung
Die Funktion
bae_poptext definiert einen nicht selektierbaren Text innerhalb des zuvor mit
bae_popshow aktivierten Popupmenüs. Die Position für die Anzeige des Textes ergibt sich aus den übergebenen Zeilen- und Spaltenparametern; die Koordinate [0,0] bezieht sich dabei auf die linke obere Ecke des Popupbereiches. Der im Popupmenü anzuzeigende Text wird durch die Anzeige-Zeichenkette definiert. Der Rückgabewert der Funktion ist ungleich Null, wenn fehlerhafte Parameter übergeben wurden.
Siehe auch
Funktionen
bae_popcolbar,
bae_popcolchoice,
bae_popshow,
bae_poptextchoice.
bae_poptextchoice - BAE Popupmenü Textselektion definieren (STD)
Synopsis
int bae_poptextchoice( // Status
double [0.0,[; // Zeilennummer
double [0.0,[; // Spaltennummer
string; // Anzeige-Zeichenkette
string; // Antwort-Zeichenkette
);
Beschreibung
Die Funktion
bae_poptextchoice definiert einen maus-selektierbaren Text innerhalb des zuvor mit
bae_popshow aktivierten Popupmenüs. Die Position für die Anzeige des Textes ergibt sich aus den übergebenen Zeilen- und Spaltenparametern; die Koordinate [0,0] bezieht sich dabei auf die linke obere Ecke des Popupbereiches. Der im Popupmenü anzuzeigende Text wird durch die Anzeige-Zeichenkette definiert. Der Rückgabewert der Funktion ist ungleich Null, wenn fehlerhafte Parameter übergeben wurden. Die Selektion der mit
bae_poptextchoice definierten Textanzeige ist nach einer Aktivierung der Funktion
bae_readtext möglich. Durch die Selektion des Anzeigetextes wird die Funktion
bae_readtext beendet; der Rückgabewert von
bae_readtext ergibt sich dabei automatisch aus der Antwort-Zeichenkette, die beim Aufruf der Funktion
bae_poptextchoice angegeben wurde.
Siehe auch
Funktionen
bae_popcolbar,
bae_popcolchoice,
bae_popshow,
bae_poptext,
bae_readtext.
bae_postprocess - BAE Postprozessorlauf (STD)
Synopsis
void bae_postprocess(
);
Beschreibung
Die Funktion
bae_postprocess führt einen BAE-Prostprozesslauf für das aktuell geladene Element durch. Auf Layoutebene wird damit die eine Aktualisierung der Connectivity und eine Prüfung der Designregeln erzwungen.
bae_progdir - BAE Programmverzeichnis ermitteln (STD)
Synopsis
string bae_progdir( // BAE-Programmverzeichnis-Name
);
Beschreibung
Der Rückgabewert der Funktion
bae_progdir entspricht dem aktuell gültigen Namen für das BAE-Programmverzeichnis. Diese Information ist insbesondere dann von Nutzen, wenn auf spezielle Daten aus dem BAE-Programmverzeichnis zugegriffen werden soll (z.B. zum Laden von Farbtabellen, für den Zugriff auf Blendentabellen, usw.).
bae_prtdialog - BAE Dialogtextausgabe in Statuszeile (STD)
Synopsis
void bae_prtdialog(
string; // Anzeige-Zeichenkette
);
Beschreibung
Die Funktion
bae_prtdialog gibt die übergebene Anzeige-Zeichenkette in der Statuszeile der BAE-Benutzeroberfläche aus.
Siehe auch
Funktion
perror.
bae_querydist - BAE Punkt-zu-Polgygon Distanzabfrage (STD)
Synopsis
int bae_querydist( // Status
double; // Abfrage X-Koordinate (STD2)
double; // Abfrage Y=Koordinate (STD2)
& double; // Rückgabe Distanz (STD2)
);
Beschreibung
Mit der Funktion
bae_querydist kann der Abstand zwischen dem über die Parameter für die X- und Y-Koordinaten gegebenen Punkt und das zuvor mit
bae_storedistpoly gespeicherte interne Distanzabfragepolygon ermittelt werden. Die ermittelte Distanz wird im letzten Funktionsparameter zurückgegeben. Positive Werte geben dabei Abstände zu Punkten außerhalb des Distanzabfragepolygons an, negative Werte werden für Abstände zu Punkten innerhalb des Polygons zurückgegeben. Der Funktionsrückgabewert ist Null bei erfolgreicher Distanzabfrage oder ungleich Null wenn ein Fehler aufgetreten ist (fehlendes Distanzabfragepolygon).
Siehe auch
Funktion
bae_storedistpoly.
bae_readedittext - BAE Texteingabe/-anzeige (STD)
Synopsis
string bae_readedittext( // Zeichenkette
string; // Eingabeaufforderung
// !-Präfix: Mehrzeilentexteingabe
// sonst: Einzelzeilentexteingabe
string; // Default-Rückgabezeichenkette
int [0,[; // Maximale Eingabelänge
);
Beschreibung
Die Funktion
bae_readedittext aktiviert einen Dialog zum Anzeigen und Editieren von Texten. Die über den ersten Funktionsparameter angegebene Eingabeaufforderung wird in der Titelleiste des Dialogs angezeigt. Ist das erste Zeichen der Eingabeaufforderung ein Ausrufungszeichen
(!), dann wird ein Dialog mit einem mehrzeiligem Editierfenster aktiviert, ansonsten erfolgt die Eingabe über einen Dialog mit einem einzeiligen Editierfenster.
Das Dialogfenster für mehrzeilige Texteingaben ist in der Größe veränderbar.
Nach dem Aufruf der Funktion wird im Editierfenster die angegebene Rückgabezeichenkette angezeigt. Der Dialog enthält Schaltflächen zur Bestätigung
() und zum Abbruch
() der Texteingabe. Im Dialog für die mehrzeilige Texteingabe werden außerdem Schaltflächen zum Laden des Inhalts einer selektierbaren Datei
() und zum Speichern des aktuell editierten Texts in eine Ausgabedatei
() angeboten. Der Rückgabewert dieser Funktion entspricht der vom Benutzer editierten Zeichenkette wenn die Eingabe mit
bestätigt wurde. Dabei ist die eingebbare maximale Länge der Antwortzeichenkette durch den entsprechenden Funktionsparameter festgelegt. Bei Betätigung von
wird die Default-Rückgabezeichenkette an den Aufrufer zurückgegeben.
Warnung
Unter
BAE Demo steht die Option zum Speichern des aktuell bearbeiteten Texts nicht zur Verfügung, und die üblicherweise über die rechte Maustaste unter Windows verfügbare Funktion zum Kopieren des aktuell bearbeiteten Texts in das Clipboard ist ebenfalls deaktiviert.
Siehe auch
Funktion
bae_readtext.
bae_readtext - BAE Texteingabe mit optionalem Popupmenü (STD)
Synopsis
string bae_readtext( // Zeichenkette
string; // Eingabeaufforderung
int; // Maximale Eingabelänge
);
Beschreibung
Die Funktion
bae_readtext fordert den Benutzer in der Eingabezeile mit der übergebenen Promptzeichenkette zur Eingabe einer Zeichenkette auf. Der Rückgabewert dieser Funktion entspricht der vom Benutzer eingegebenen Zeichenkette, wobei die über Tastatur eingebbare maximale Länge der Antwortzeichenkette durch den entsprechenden Funktionsparameter definiert wird. Wurde vor dem
bae_readtext-Aufruf mit
bae_setmousetext die Möglichkeit der Textübergabe per Mausklick aktiviert, dann ist parallel zur Tastatureingabe die Betätigung einer Maustaste möglich; der Rückgabewert der Funktion
bae_readtext ergibt sich dann aus der mit
bae_setmousetext definierten Antwortzeichenkette. Nach Ablauf der Funktion
bae_readtext wird die mit
bae_setmousetext definierte Möglichkeit der Mausklickeingabe wieder deaktiviert. Wurde vor dem
bae_readtext-Aufruf mit
bae_popshow ein Popupmenü aktiviert (ohne dass eine Mausklickeingabe mit
bae_setmousetext aktiviert wurde), dann ist parallel zur Tastatureingabe die Mausselektion eines der innerhalb des Popupmenüs mit
bae_popcolchoice bzw. mit
bae_poptextchoice definierten Selektionselemente (Farbbalken bzw. Texte) möglich, wobei sich dann die entsprechend definierten Zeichenketten-Rückgabewerte ergeben.
Warnung
Die Funktion
bae_readtext deaktiviert alle zuvor mit
bae_popcolchoice,
bae_poptextchoice und
bae_setmousetext aktivierten Selektionsalternativen.
Siehe auch
Funktionen
bae_popcolchoice,
bae_popshow,
bae_poptextchoice,
bae_readedittext,
bae_setmousetext.
bae_redefmainmenu - BAE Hauptmenüdefinition starten (STD)
Synopsis
int bae_redefmainmenu( // Status
);
Beschreibung
Die Funktion
bae_redefmainmenu startet die (Neu-)Definition des Hauptmenüs im aktuell aktiven BAE-Modul. Der Rückgabewert der Funktion
bae_redefmainmenu ist (-1), wenn ein Fehler aufgetreten ist oder Null andernfalls. Im Anschluss an den Aufruf der Funktion
bae_redefmainmenu sollten über die Funktion
bae_defmenu (zu beenden mit
bae_endmenu) zumindest die Hauptmenüeinträge definiert werden. Wahlweise können anschließend auch die Untermenüs über die Funktion
bae_defselmenu (zu beenden mit
bae_endmenu) konfiguriert werden. Zwischen den Funktionsaufrufen für
bae_defmenu bzw.
bae_defselmenu einerseits und der Funktion
bae_endmenu sind mit durch wiederholten Aufruf der Funktion
bae_defmenutext die einzelnen Menüeinträge zu definieren. Die Definition des Hauptmenüs muss mit der Funktion
bae_endmainmenu beendet werden. Mit der Funktion
bae_resetmenuprog können sämtliche Menübelegungen wieder zurückgesetzt werden.
Siehe auch
Funktionen
bae_defmenu,
bae_defmenuprog,
bae_defmenutext,
bae_defselmenu,
bae_endmainmenu,
bae_endmenu,
bae_redefmenu,
bae_resetmenuprog.
bae_redefmenu - BAE Menüfunktion umprogrammieren (STD)
Synopsis
int bae_redefmenu( // Status
int [0,999]; // Menünummer
int [0,99]; // Menüzeile
string; // Menütext
int; // BAE-Menüfunktion (STD4)
int; // Menüeintrag Bearbeitungsschlüssel:
// 8000000h = immer aktivierbar
// 7FFFFFFh = für jeden Elementtyp
// aktivierbar
// sonstige = (kombinierter)
// DDB-Klassen-Schlüssel
);
Beschreibung
Die Funktion
bae_redefmenu ordnet einem Menüeintrag den angegebenen Menütext sowie die numerisch spezifizierte BAE-Menüfunktion zu. Die Menünummer gibt die Nummer des Hauptmenüs an, die Menüzeile die Position im zugehörigen Submenü. Der Bearbeitungsschlüssel dient der Konfiguration von sogenannten Ghostmenüs. Hierfür ist ein kodierter Integerwert einzutragen, wie er mit den Funktionen
bae_getclassbitfield oder
bae_getmenubitfield ermittelt bzw. definiert werden kann (im Zweifelsfall empfiehlt sich die Verwendung des Hexadezimalwertes 80000000h, um sicherzustellen, dass die Funktion immer aktivierbar ist). Der Rückgabewert der Funktion
bae_redefmenu ist (-1), wenn ein Fehler aufgetreten ist oder Null andernfalls. Mit der Funktion
bae_resetmenuprog können sämtliche Menübelegungen wieder zurückgesetzt werden.
Siehe auch
Funktionen
bae_defmenuprog,
bae_getclassbitfield,
bae_getmenubitfield,
bae_resetmenuprog.
bae_resetmenuprog - BAE Menüprogrammierung zurücksetzen (STD)
Synopsis
void bae_resetmenuprog(
);
Beschreibung
Die Funktion
bae_resetmenuprog setzt sämtliche mit
bae_deffuncprog,
bae_defkeyprog,
bae_defmenuprog,
bae_redefmainmenu,
bae_defmenu,
bae_defselmenu,
bae_defmenutext,
bae_redefmenu vorgenommenen Tasten- und Menüdefinitionen zurück und versetzt das System so in den Default Anfangszustand.
Siehe auch
Funktionen
bae_deffuncprog,
bae_defkeyprog,
bae_defmenu,
bae_defmenuprog,
bae_defmenutext,
bae_defselmenu,
bae_redefmainmenu,
bae_redefmenu.
bae_sendmsg - BAE HighEnd Message senden (STD/HighEnd)
Synopsis
int bae_sendmsg( // Status
string; // Meldung Textstring
int [0,1]; // Flag - projektspezifische Nachricht
);
Beschreibung
Die Funktion
bae_sendmsg ist nur in
BAE HighEnd verfügbar. Wenn die Funktion nicht in
BAE HighEnd aufgerufen wird, oder wenn Parameterangaben ungültig oder unvollständig sind, dann wird ein Wert ungleich Null zurückgegeben. Mit
bae_sendmsg wird ein Messagestring an die anderen Module eine
BAE HighEnd-Sitzung übermittelt. Dabei kann über den zweiten Funktionsparameter angegeben werden, ob alle Module die Nachricht erhalten sollen, oder ob die Nachricht nur an die Module geschickt werden soll, in denen gerade Elemente derselben DDB-Datei bearbeitet werden. Zu einer Sitzung gehören alle Programminstanzen, die ausgehend von einem BAE-Aufruf über die Funktion
aus dem BAE-Hauptmenü oder dem
Schaltplaneditor gestartet wurden. In den addressierten Modulen wird bei Ankunft einer Nachricht automatisch das
User Language-Programm
bae_msg gestartet. Ist
bae_msg nicht verfügbar, dann erfolgt der Aufruf eines
User Language-Programms mit modulspezifischem Namen
(scm_msg im Schaltplaneditor,
ged_msg im Layouteditor,
ar_msg im Autorouter, etc.). Das automatisch gestartete
User Language-Programm muss die Nachricht mit der Funktion
bae_getmsg entgegennehmen. Die Nachricht steht nur während der Dauer dieses Programmaufrufs zur Verfügung. Wird die Nachricht von dem
*_msg-Programm nicht angenommen, dann geht sie verloren. Der Inhalt der Nachricht kann dazu benutzt werden, eine spezielle Aktion im empfangenden Modul auszulösen.
Siehe auch
Funktion
bae_getmsg.
bae_setanglelock - BAE Winkelfreigabeflag setzen (STD)
Synopsis
int bae_setanglelock( // Status
int [0,1]; // Winkelfreigabe Flag (STD9)
);
Beschreibung
Die Funktion
bae_setanglelock setzt den Wert des Winkelfreigabeflags im
AutoEngineer (0=Winkel freigeben, 1=Winkel einhalten). Es wird ein Wert ungleich Null zurückgegeben, wenn ein ungültiger Flagwert angegeben wurde.
Siehe auch
Funktion
bae_getanglelock.
bae_setbackgrid - BAE Hintergrundraster setzen (STD)
Synopsis
int bae_setbackgrid( // Status
double [0.0,[; // X-Hintergrundraster (STD2)
double [0.0,[; // Y-Hintergrundraster (STD2)
);
Beschreibung
Die Funktion
bae_setbackgrid setzt die Werte für das Hintergrundraster im
AutoEngineer. Werte von Null spezifizieren, dass kein Hintergrundraster angezeigt werden soll. Es wird ein Wert ungleich Null zurückgegeben, wenn ungültige Rasterwerte spezifiziert wurden.
Siehe auch
Funktion
bae_getbackgrid.
bae_setclipboard - Textstring in (Windows-)Zwischenablage speichern (STD)
Synopsis
int bae_setclipboard( // Status
string; // Textstring
);
Beschreibung
Die Funktion
bae_setclipboard speichert den ügergebenen Textstring in der Windows-Zwischenablage. Der Funktionsrückgabewert ist Null bei erfolgreicher Ausführung der Funktion oder ungleich Null im Fehlerfall.
bae_setcolor - BAE Farbwert setzen (STD)
Synopsis
int bae_setcolor( // Status
int; // Anzeigeelementtyp (SCM1|LAY9|ICD9)
int; // Farbwert (STD18)
);
Beschreibung
Die Funktion
bae_setcolor setzt den Farbwert für den angegebenen Anzeigeelementtyp. Der Wert für den Anzeigeelementtyp muss entsprechend der aktuellen Interpreterumgebung gesetzt sein. Der Rückgabewert ist ungleich Null, wenn der Farbwert nicht gesetzt werden konnte.
Warnung
Um beim Umdefinieren von Farbtabellen unnötige Bildneuaufbauten zu vermeiden, führt die Funktion
bae_setcolor keinen automatischen Bildneuaufbau durch. Es liegt somit in der Verantwortung des Aufrufers, den erforderlichen Bildneuaufbau nach einer mit
bae_setcolor durchgeführten Farbtabellendefinitionssequenz auszulösen.
Siehe auch
Funktion
bae_getcolor.
bae_setcoorddisp - BAE Koordinatenanzeige setzen (STD)
Synopsis
int bae_setcoorddisp( // Status
int [0,1]; // Koordinatenanzeigemodus (STD7)
);
Beschreibung
Die Funktion
bae_setcoorddisp setzt den Koordinatenanzeigemodus im
AutoEngineer, wobei der Wert 0 für mm-Einheiten (bzw. Mikrometer-Einheiten im
IC-Design System) und der Wert 1 für Inch-Einheiten (bzw. mil-Einheiten im
IC-Design System) anzugeben ist. Es wird ein Wert ungleich Null zurückgegeben, wenn ein ungültiger Modus angegeben wurde.
Siehe auch
Funktion
bae_getcoorddisp.
bae_setdblpar - BAE Doubleparameter setzen (STD)
Synopsis
int bae_setdblpar( // Status
int [0,[; // Parametertyp/-nummer:
// 0 = maximale Dialogboxbreite
// 1 = maximale Dialogboxhöhe
// 2 = Grafikanzeige Zoomfaktor
// 3 = Gummibandeckradius (STD2)
// 4 = Gummiband X-Vektorkoordinate (STD2)
// 5 = Gummiband Y-Vektorkoordinate (STD2)
// 6 = Fixierte X-Pickkoordinate (STD2)
// 7 = Fixierte Y-Pickkoordinate (STD2)
// [ 8 = Systemparameter - kein Schreibzugriff ]
// [ 9 = Systemparameter - kein Schreibzugriff ]
// 10 = Bildschirmpickbereich (STD2)
// 11 = Elementauswahl relativer Vorschaubereich [0.05, 0.95]
// [ 12 = Systemparameter - kein Schreibzugriff ]
// [ 13 = Systemparameter - kein Schreibzugriff ]
double; // Parameterwert
);
Beschreibung
Die Funktion
bae_setdblpar dient dazu, Systemparameter vom Typ
double im
Bartels AutoEngineer zu setzen. Der Funktionsrückgabewert ist Null bei erfolgreicher Parameterzuweisung oder (-1) im Fehlerfall. Die Werte von mit
bae_setdblpar gesetzten Systemparametern können mit der Funktion
bae_getdblpar abgefragt werden.
Siehe auch
Funktionen
bae_getdblpar,
bae_getintpar,
bae_getstrpar,
bae_setintpar,
bae_setstrpar.
bae_setgridlock - BAE Rasterfreigabeflag setzen (STD)
Synopsis
int bae_setgridlock( // Status
int [0,1]; // Rasterfreigabe Flag (STD8)
);
Beschreibung
Die Funktion
bae_setgridlock setzt den Wert des Rasterfreigabeflags im
AutoEngineer (0=Raster freigeben, 1=Raster einhalten). Es wird ein Wert ungleich Null zurückgegeben, wenn ein ungültiger Flagwert angegeben wurde.
Siehe auch
Funktion
bae_getgridlock.
bae_setgridmode - BAE Rasterabhängigkeitsmodus setzen (STD)
Synopsis
int bae_setgridmode( // Status
int [0,255]; // Modus für automatische Rastereinstellung:
// 0x01: Eingaberaster = 0.25 × Hintergrundraster
// 0x02: Eingaberaster = 0.50 × Hintergrundraster
// 0x04: Eingaberaster = 1.00 × Hintergrundraster
// 0x08: Eingaberaster = 2.00 × Hintergrundraster
// 0x10: Hintergrundraster = 0.25 × Eingaberaster
// 0x20: Hintergrundraster = 0.50 × Eingaberaster
// 0x40: Hintergrundraster = 1.00 × Eingaberaster
// 0x80: Hintergrundraster = 2.00 × Eingaberaster
);
Beschreibung
Die Funktion
bae_setgridmode setzt den BAE Rasterabhängigkeitsmodus. Der Funktionsrückgabewert ist ungleich Null wenn ein ungültiger Rasterabhängigkeitsmodus spezifiziert wurde.
Siehe auch
Funktion
bae_getgridmode.
bae_setinpgrid - BAE Eingaberaster setzen (STD)
Synopsis
int bae_setinpgrid( // Status
double [0.0,[; // X-Eingaberaster (STD2)
double [0.0,[; // Y-Eingaberaster (STD2)
);
Beschreibung
Die Funktion
bae_setinpgrid setzt die Werte für das Eingaberaster im
AutoEngineer. Es wird ein Wert ungleich Null zurückgegeben, wenn ungültige Rasterwerte spezifiziert wurden.
Siehe auch
Funktion
bae_getinpgrid.
bae_setintpar - BAE Integerparameter setzen (STD)
Synopsis
int bae_setintpar( // Status
int [0,[; // Parametertyp/-nummer:
// 0 = Koordinateneingaben Bereichsprüfung:
// 0 = Bereichsprüfung aktivieren
// 1 = Bereichsprüfung deaktivieren
// 1 = Modulwechsel Autosavemodus:
// 0 = Autosave ohne Benutzerabfrage
// 1 = Benutzerabfrage vor Autosave
// 2 = Anzeigedeaktivierungsmodus:
// 0 = Anzeige aktiviert Prüfung
// 1 = Anzeige deaktivieren
// [ 3 = Benutzeroberfläche Menü-/Mausmodus: ]
// [ Systemparameter schreibgeschützt ]
// 4 = Arbeitsbereichstext Farbauswahl:
// 0 = Standardfarben
// 1 = invertierte Standardfarben
// 2 = arbeitsbereichsspezifische Farben
// 5 = Element Laden Anzeigemodus:
// 0 = Übersichtsanzeige nach Laden
// 1 = Anzeige aktiviert durch bae_load
// 6 = Dateiauswahl Dialogmodus:
// 0 = alte BAE-Dateiauswahl
// 1 = Explorer Standardansicht
// 2 = Explorer Listenansicht
// 3 = Explorer Detailansicht
// 4 = Exploreransicht kleine Piktogramme
// 5 = Exploreransicht große Piktogramme
// 6 = Standard-Stil und Standard-Größe benutzen
// 7 = Elementauswahl Dialogmodus:
// 0 = nur Name anzeigen
// 1 = Name und Datum anzeigen
// 8 = Elementauswahl Sortierfunktion:
// 0|1 = Sortierung nach Name
// 2 = Sortierung numerisch
// 3 = Sortierung nach Datum
// 9 = Anzeigemodus Platzierung:
// 0 = platzierte Elemente sichtbar
// 1 = unplatzierte Elemente sichtbar
// [ 10 = Letzter Dateisystemfehler: ]
// [ Systemparameter schreibgeschützt ]
// 11 = Kommandohistorie Modus:
// 0 = Kommandohistorie aktiviert
// 1 = Kommandohistorie deaktiviert
// 12 = Popupmenü Mauswarpmodus:
// 0 = Kein Popupmenü Mauswarp
// 1 = Popupmenü Mauswarp erstes Element
// 2 = Popupmenü Mauswarp vorselektiertes Element
// +4 = Mauspositionsrestore-Warp
// +8 = Elementpickpositions-Warp
// 13 = Sicherungsmodus:
// 0 = Sicherung aktiviert
// 1 = Sicherung deaktiviert
// 14 = Minimalgröße Mausrechteck:
// ]0,[ = minimale Mausrechteckgröße
// 15 = Anzeigemodus Mausinfo:
// 0 = keine kontinuierliche Infoanzeige
// 1 = kontinuierliche Infoanzeige
// 16 = Nächste Dialogbox-Identifikationsnummer
// 17 = Zuletzt erzeugte Tooltipidentifikationsnummer
// 18 = Polygonverwurfsanzahl
// 19 = Polygonprüfungsabschaltung:
// 0 = Polygonprüfung aktivieren
// 1 = Polygonprüfung abschalten
// 20 = Kursortastenrastermodus:
// 0 = Eingaberaster
// 1 = Pixelraster
// 21 = Flag - Element nicht gesichert
// 22 = Elementbatchlademodus:
// 0 = keinen Batch laden
// 1 = Batch laden
// 2 = Batch laden, Zoomfenster restaurieren
// 23 = Rasterlinienanzeige:
// 0 = Punktraster
// 1 = Linienraster
// 24 = Flag - Spiegelungsanzeige
// 25 = Flag - Eingaberasteranzeige
// 26 = Mausfunktionswiederholungsmodus:
// 0 = Menüfunktion wiederholen
// +1 = Tastenfunktion wiederholen
// +2 = Kontextmenüfunktion wiederholen
// [ 27 = Maximale Undo-Redo-Anzahl: ]
// [ Systemparameter schreibgeschützt ]
// 28 = Menübaumansichtsmodus:
// 0 = Kein Menübaumfenster
// 1 = Menübaumfenster links
// 2 = Menübaumfenster rechts
// 29 = Menübaumansicht Pixelbreite
// 30 = Flag - Meldungshistorie deaktiviert
// 31 = Elementlademeldungsmodus:
// 0 = Standardmeldung
// 1 = Benutzerspezifische Meldung
// 2 = Benutzerspezifische Fehlermeldung
// 32 = Pickmarkeranzeigemodus:
// 0 = Kreismarker
// 1 = Diamantmarker
// 33 = Mausdrag-Status:
// 0 = Kein Mausdrag
// 1 = Mausdragangeforderung
// 2 = Mausdrag durchgeführt
// 3 = Mausdragfreigabeanforderung
// 34 = Flag - Menüfunktionswiederholung angefordert
// 35 = Flag - Funktion abgebrochen
// 36 = Flag - Planauswahlvorschau
// 37 = Dateizugriffsfehler-Anzeigemodus:
// 0 = Nur Statuszeilenanzeige
// 1 = Bestätigungsabfrage
// 38 = Elementauswahl-Referenzanzeigemodus:
// 0 = Projektdatei-Referenzen anzeigen
// 1 = Bibliotheksdatei-Referenzen anzeigen
// 39 = Maus-Doppelklick-Modus:
// 0 = Doppelklick und Selektion von 0 an rechte Maustaste zuweisen
// 1 = Doppelklick ignorieren
// 2 = Doppelklick an rechte Maustaste zuweisen
// 40 = Mauspick-Doppelklick-Modus:
// 0 = Doppelklick an rechte Maustaste zuweisen
// 1 = Doppelklick ignorieren
// [ 41 = Flags - Dialogelementunterstützung: ]
// [ Systemparameter schreibgeschützt ]
// 42 = Fortschrittsanzeigemodus:
// 0 = Keine Fortschrittsanzeige
// 1 = Fortschrittsanzeige
// 43 = Abbruchanforderungsflag für Fortschrittsanzeige:
// 44 = Flag - Mittlere Maustaste deaktiviert:
// [ 45 = Anzahl aktueller Undo-Elemente: ]
// [ Systemparameter schreibgeschützt ]
// [ 46 = Flag - Datei Drag-und-Drop Operation: ]
// [ Systemparameter schreibgeschützt ]
// 47 = Flag - Automatische BAE-Fensteraktivierung
// [ 48 = Anzahl aktive Menüfunktionen ]
// [ Systemparameter schreibgeschützt ]
// [ 49 = Anzahl Punkte in interner Polygonliste ]
// [ Systemparameter schreibgeschützt ]
// 50 = Priorit&auuml;t alternative Konfigurationsdatei
// 51 = Sicherungsmodus für Dialogposition:
// 0 = Absolutkoordinaten specihern
// 1 = Hauptfenster-Relativkoordinaten speichern
// 2 = Hauptfenster-Monitorabsolutkoordinaten speichern
// 52 = Message-Box Default-Button-Index:
// (-1) = Kein Default (Abbruch oder No
// 0-2 = Default-Button-Index
int; // Parameterwert
);
Beschreibung
Die Funktion
bae_setintpar dient dazu, Systemparameter vom Typ
int im
Bartels AutoEngineer zu setzen. Der Funktionsrückgabewert ist Null bei erfolgreicher Parameterzuweisung oder (-1) im Fehlerfall. Die Werte von mit
bae_setintpar gesetzten Systemparametern können mit der Funktion
bae_getintpar abgefragt werden.
Siehe auch
Funktionen
bae_getdblpar,
bae_getintpar,
bae_getstrpar,
bae_setdblpar,
bae_setstrpar.
bae_setmoduleid - BAE Modulbezeichnung setzen (STD)
Synopsis
int bae_setmoduleid( // Rückgabe Status
string; // Modulbezeichnung
);
Beschreibung
Die Funktion
bae_setmoduleid setzt die Bezeichnung des aktuell aktiven BAE-Programmmoduls. Der Funktionsrückgabewert ist Null bei erfolgreicher Zuweisung der Modulbezeichnung oder ungleich NUll im Fehlerfall.
Siehe auch
Funktion
bae_getmoduleid.
bae_setmousetext - BAE Mausklick-Eingabetext definieren (STD)
Synopsis
int bae_setmousetext( // Status
string; // Antwort-Zeichenkette
);
Beschreibung
Die Funktion
bae_setmousetext definiert die übergebene Antwort-Zeichenkette als Default-Rückgabewert bei Aktivierung einer Maustaste für einen nachfolgenden Aufruf der Funktion
bae_readtext. Ein Aufruf der Funktion
bae_readtext deaktiviert gleichzeitig auch wieder die zuvor mit
bae_setmousetext definierte Möglichkeit der Mausklick-Eingabe.
Siehe auch
Funktion
bae_readtext.
bae_setplanfname - BAE Projekdateiname setzen (STD)
Synopsis
int bae_setplanfname( // Status
string; // BAE-Projektdateiname
);
Beschreibung
Die Funktion
bae_setplanfname setzt den BAE-Projektdateinamen. Die Dateinamenserweiterung
.ddb wird automatisch angefügt, wenn ein BAE-Projektdateiname ohne Dateinamenserweiterung spezifiziert wurde. Der Rückgabewert der Funktion ergibt sich zu Null, wenn der BAE-Projektdateiname erfolgreich gesetzt wurde, zu 1 bei fehlendem bzw. falschem Funktionsparameter oder zu 2, wenn durch ein geladenes Element bereits ein BAE-Projektdateiname definiert ist.
Siehe auch
Funktion
bae_planfname.
bae_setpopdash - BAE Popup/Toolbar Parameter für gestrichelte Linien setzen (STD)
Synopsis
void bae_setpopdash(
double ]0.0,[; // Basisstrichlinie (STD2)
double ]-0.5,0.5[; // Relativer Strichabstand
);
Beschreibung
Die Funktion
bae_setpopdash setzt die Basislänge und den relativen Strichabstand für die Ausgabe gestrichelter Linien in Popupmenüs bzw. Toolbars.
Siehe auch
Funktion
bae_popdrawpoly.
bae_setstrpar - BAE Stringparameter setzen (STD)
Synopsis
int bae_setstrpar( // Status
int [0,[; // Parametertyp/-nummer:
// 0 = Aktueller Element-Kommentartext
// 1 = Aktuelle Element-Spezifikation
// [ 2 = Systemparameter - kein Schreibzugriff ]
// [ 3 = Systemparameter - kein Schreibzugriff ]
// 4 = Fadenkreuz-Infotext
// 5 = Tooltip text
// [ 6 = Systemparameter - kein Schreibzugriff ]
// 7 = Menütext der aktuell aktiven Funktion
// 8 = Aktueller Menüitemelementtext
// 9 = Aktuelle benutzerspezifische Elementlademeldung
// 10 = Zwischenablage-Textstring
// 11 = Modulaufruf nächstes Dateiargument
// 12 = Modulaufruf nächstes Elementargument
// 13 = Modulaufruf nächstes Kommando-/Typargument
// 14 = Letzter Ausgabedateiname
// [ 15 = Systemparameter - kein Schreibzugriff ]
// 16 = Werkzeugleistenschaltfläche Zeichen/Resourceelement
// [ 17 = Systemparameter - kein Schreibzugriff ]
// [ 18 = Systemparameter - kein Schreibzugriff ]
// 19 = Alternatives Verzeichnis für Konfigrationsdaten
// 20 = Spalte lokale Daten
// 21 = Spalt globale Daten
string; // Parameterwert
);
Beschreibung
Die Funktion
bae_setstrpar dient dazu, Systemparameter vom Typ im
string im
Bartels AutoEngineer zu setzen. Der Funktionsrückgabewert ist Null bei erfolgreicher Parameterzuweisung oder (-1) im Fehlerfall. Die Werte von mit
bae_setstrpar gesetzten Systemparametern können mit der Funktion
bae_getstrpar abgefragt werden.
Siehe auch
Funktionen
bae_getdblpar,
bae_getintpar,
bae_getstrpar,
bae_setdblpar,
bae_setintpar.
bae_settbsize - BAE Toolbarbereich definieren/anzeigen (STD)
Synopsis
void bae_settbsize(
double [0.0,[; // Toolbargröße
int [0,3]; // Toolbar Anordnung/Ausrichtung:
// 0 = horizontal an unterer
// Arbeitsbereichsbegrenzung
// 1 = vertikal an rechter
// Arbeitsbereichsbegrenzung
// 2 = horizontal an oberer
// Arbeitsbereichsbegrenzung
// 3 = vertikal an linker
// Arbeitsbereichsbegrenzung
);
Beschreibung
Mit der Funktion
bae_settbsize kann eine Werkzeugleiste definiert bzw. angezeigt werden. Der erste Parameter gibt dabei in Abhängigkeit vom zweiten Parameter die gewünschte Größe des Toolbarbereichs an. Bei vertikaler Ausrichtung der Toolbar wird dieser Wert als Spaltenanzahl interpretiert, bei horizontaler Ausrichtung hingegen als Zeilenanzahl. Durch die Angabe des Wertes Null für die Toolbargröße kann eine bereits definierte Toolbar wieder ausgeblendet werden. Die Dimension des verfügbaren Grafikarbeitsbereichs zur Anzeige von Toolbars kann mit der Funktion
bae_mtpsize ermittelt werden. Mit der Funktion
bae_tbsize kann die tatsächliche Größe einer mit
bae_settbsize definierten Toolbar nachträglich abgefragt werden. Die Funktion
bae_popsetarea dient dazu, wahlweise die Toolbar oder das Standard-Popupmenü für nachfolgende Popupoperationen zu aktivieren. Mit der Funktion
bae_popclrtool können sämtliche Anzeigen der aktuellen Toolbar gelöscht bzw. deaktiviert werden.
Siehe auch
Funktionen
bae_mtpsize,
bae_popclrtool,
bae_popsetarea,
bae_tbsize.
bae_storecmdbuf - BAE Kommando in Kommandohistorie speichern (STD)
Synopsis
int bae_storecmdbuf( // Status
int [0,[; // Kommandospeichermodus
// 0 : Kommando an Historie anfügen
string; // Kommando- bzw. Kommandosequenzzeichenkette
string; // Kommandoanzeigetext
);
Beschreibung
Die Funktion
bae_storecmdbuf trägt das angegebene Kommando in die aktuelle Kommandohistorie ein. Über den Kommandospeichermodus wird angegeben wo das Kommando in der Historie einzufügen ist und ob bzw. wie die Kommandohistorie umzuorganisieren ist. Die Kommando- bzw. Kommandosequenzzeichenkette und der Kommandoanzeigetext (entsprechend der Titelleistenanzeige) werden über den zweiten und dritten Funktionsparameter angegeben. Der Funktionsrückgabewert ist Null wenn die Zuweisung erfolgreich war oder ungleich Null im anderen Fall.
Siehe auch
Funktion bae_getcmdbuf.
bae_storedistpoly - Internes BAE Distanzabfragepolygon speichern (STD)
Synopsis
int bae_storedistpoly( // Status
);
Beschreibung
Die Funktion
bae_storedistpoly speichert das aktuell mit
bae_clearpoints und
bae_storepoint erzeugte Polygon als Distanzabfragepolygon. Anschließend kann die Funktion
bae_querydist zur Bestimmung des Abstands eines gegebenen Punktes zum Distanzabfragepolygon verwendet werden. Das mit
bae_storedistpoly gespeicherte Distanzabfragepolygon kann mit der Funktion
bae_cleardistpoly wieder gelöscht werden. Der Rückgabewert der Funktion ist Null, wenn kein Fehler aufgetreten ist, (-1) wenn das interne Distanzabfragepolygon bereits definiert ist oder (-2) bei ungültigen Polygondaten.
Siehe auch
Funktionen
bae_cleardistpoly,
bae_clearpoints,
bae_querydist,
bae_storepoint.
bae_storeelem - BAE Element speichern (STD)
Synopsis
int bae_storeelem( // Status
string; // Dateiname
string; // Elementname
);
Beschreibung
Die Funktion
bae_storeelem speichert das aktuell im
AutoEngineer geladene Element unter dem angegebenen Namen in die Zieldatei. Diese Funktion entspricht der Menüfunktion
, d.h. falls in eine andere Datei geschrieben wird, muss gegebenenfalls
aufgerufen werden. Der Rückgabewert ist Null, wenn keine Fehler aufgetreten sind, (-1) bei Dateizugriffsfehlern, 1 bei ungültigen Parametern und 2 wenn kein Element im Speicher vorhanden ist.
bae_storekeyiact - BAE Tasteneingabe vorgeben (STD)
Synopsis
void bae_storekeyiact(
int [0,3]; // Automatischer Interaktionsmodus (STD21)
int; // Tastenzeichencode (ASCII)
);
Beschreibung
Die Funktion
bae_storekeyiact ermöglicht die Steuerung von Tasteneingaben bei der Ausführung von Menüfunktionen über die Funktion
bae_callmenu. Ist der Interaktionsmodus auf Null gesetzt, so wird die Tasteneingabe vom Benutzer erwartet, ansonsten wird der übergebene Tastencode als Eingabe übernommen. Die Vorgaben werden in einer Queue gespeichert, d.h. es sind mehrere Vorgaben zur Steuerung ganzer Eingabeabläufe möglich.
Siehe auch
Funktionen
bae_peekiact,
bae_storemenuiact,
bae_storemouseiact,
bae_storetextiact.
bae_storemenuiact - BAE Menüwahl vorgeben (STD)
Synopsis
void bae_storemenuiact(
int [0,3]; // Automatischer Interaktionsmodus (STD21)
int; // Menüzeile (0..n-1)
int [1,3]; // Maustaste (STD17)
);
Beschreibung
Die Funktion
bae_storemenuiact ermöglicht die Steuerung von Menüeingaben bei der Ausführung von Menüfunktionen über die Funktion
bae_callmenu. Ist der Interaktionsmodus auf Null gesetzt, so wird die entsprechende Menüwahl vom Benutzer erwartet, ansonsten wird die übergebene Menüzeile als Menüwahl mit der entsprechenden Maustaste übernommen. Die Vorgaben werden in einer Queue gespeichert, d.h. es sind mehrere Vorgaben zur Steuerung ganzer Eingabeabläufe möglich.
Siehe auch
Funktionen
bae_peekiact,
bae_storekeyiact,
bae_storemouseiact,
bae_storetextiact.
bae_storemouseiact - BAE Mauseingabe vorgeben (STD)
Synopsis
void bae_storemouseiact(
int [0,3]; // Automatischer Interaktionsmodus (STD21)
double; // Maus X-Koordinate (STD2)
double; // Maus Y-Koordinate (STD2)
int [0,15]; // Mauskoordinatenmodus:
// 0 = angegebene Koordinaten mit Rasterfang benutzen
// 1 = alte Mauskoordinaten benutzen
// 2 = angegebene Koordinaten rasterfrei benutzen
// +4 = Mauszeiger auf angegebene Position setzen
// +8 = BAE-Fenster aktivieren
int [0,3]; // Maustastencode (STD17)
[]; // Tastatureingabe
);
Beschreibung
Die Funktion
bae_storemouseiact ermöglicht die Steuerung von Mauseingaben bei der Ausführung von Menüfunktionen über die Funktion
bae_callmenu. Ist der Interaktionsmodus auf Null gesetzt, so wird die entsprechende Mauseingabe vom Benutzer erwartet, ansonsten werden die übergebenen Mausdaten als Eingabe übernommen. Bei Übergabe des Maustastencodes Null ist über den Tastatureingabeparameter ein Zeichen zu übergeben. Die Vorgaben werden in einer Queue gespeichert, d.h. es sind mehrere Vorgaben zur Steuerung ganzer Eingabeabläufe möglich.
Siehe auch
Funktionen bae_callmenu,
bae_peekiact,
bae_storekeyiact,
bae_storemenuiact,
bae_storetextiact.
bae_storepoint - Punkt in BAE-Punktliste eintragen (STD)
Synopsis
int bae_storepoint( // Status
double; // X-Koordinate (STD2)
double; // Y-Koordinate (STD2)
int [0,2]; // Punkttyp (STD15)
);
Beschreibung
Die Funktion
bae_storepoint trägt den übergebenen Punkt in die interne Punktliste ein. Der Rückgabewert ist ungleich Null, wenn ungültige Punktdaten spezifiziert wurden. Die interne Punktliste wird von den modulspezifischen Funktionen
*_storepoly bzw.
*_storepath oder der Funktion
bae_storedistpoly zur Generierung von Polygonen und Leiterbahnen benötigt und kann mit der Funktion
bae_clearpoints wieder gelöscht werden.
Siehe auch
Funktionen
bae_clearpoints,
bae_getpolyrange,
bae_storedistpoly.
bae_storetextiact - BAE Texteingabe vorgeben (STD)
Synopsis
void bae_storetextiact(
int [0,3]; // Automatischer Interaktionsmodus (STD21)
string; // Eingabetext
);
Beschreibung
Die Funktion
bae_storetextiact ermöglicht die Steuerung von Texteingaben bei der Ausführung von Menüfunktionen über die Funktion
bae_callmenu. Ist der Interaktionsmodus auf Null gesetzt, so wird die entsprechende Texteingabe vom Benutzer erwartet, ansonsten wird die übergebene Zeichenkette als Texteingabe übernommen. Die Vorgaben werden in einer Queue gespeichert, d.h. es sind mehrere Vorgaben zur Steuerung ganzer Eingabeabläufe möglich.
Siehe auch
Funktionen
bae_peekiact,
bae_storekeyiact,
bae_storemenuiact,
bae_storemouseiact.
bae_swconfig - BAE Softwarekonfiguration abfragen (STD)
Synopsis
int bae_swconfig( // Software-Konfigurationscode:
// (-1) = ungültige Konfigurationsklasse,
// für Konfigurationsklasse 0:
// 0 = unbekanntes System
// 1 = Bartels ACAD-PCB
// 2 = BAE Professional
// 3 = BAE HighEnd
// für Konfigurationsklasse 1:
// 0 = nicht BAE Demo
// 1 = BAE Demo
// 2 = BAE FabView
// für Konfigurationsklasse 2:
// ungleich Null = BAE Economy
// für Konfigurationsklasse 3:
// 0 = BAE-Standardmenü-Interface
// 1 = BAE-Standardmenü unter Windows
// 2 = BAE-Pulldownmenü unter Windows
// 3 = BAE-Standardmenü unter Motif
// 4 = BAE-Pulldownmenü unter Motif
// für Konfigurationsklasse 4:
// ungleich Null = BAE Light
// für Konfigurationsklasse 5:
// 0 = keine BAE Schematics Software
// 1 = BAE Schematics
// 2 = BAE HighEnd Schematics
// für Konfigurationsklasse 6:
// Versionsgenerierungsnummer (Build-Nummer)
int; // Software-Konfigurationsklasse:
// 0 = Abfrage BAE Software-System
// 1 = Abfrage BAE Demo
// 2 = Abfrage BAE HighEnd
// 3 = Abfrage BAE User Interface
// 4 = Abfrage BAE Light
// 5 = Abfrage BAE Schematics
// 6 = Abfrage Versionsgenerierungsnummer (Build-Nummer)
);
Beschreibung
Die Funktion
bae_swconfig ermittelt die aktuell aktivierte BAE-Softwarekonfiguration. Diese Information wird z.B. für die Funktionen
bae_defmenuprog,
bae_callmenu und
bae_store*iact zur richtigen Behandlung unterschiedlicher Auswahlmenüs in
BAE Professional,
BAE HighEnd,
BAE Economy und
BAE Light mit den verschiedenen Benutzeroberflächen (BAE-Standard, Windows- bzw. Motif-Pulldownmenüs) benötigt.
Siehe auch
Funktion
bae_swversion.
bae_swversion - BAE Softwareversion abfragen (STD)
Synopsis
string bae_swversion( // Softwareversionsangabe oder Betriebssystemeinstellung
int; // Softwareversionsabfragemodus:
// 0 = Abfrage BAE Versionsnummer
// 1 = Abfrage BAE Freigabejahr (Format YY)
// 2 = Abfrage BAE Freigabejahr (Format YYYY)
// 3 = Abfrage betriebssystemspezifisches
// Muster zur Erkennung beliebiger Zeichenketten
// (z.B. * unter Linux, .* unter MS-DOS)
// 4 = Abfrage betriebssystemspezifisches
// Directorytrennzeichen
// (z.B. / unter Linux, \ unter MS-DOS)
);
Beschreibung
Mit der Funktion
bae_swversion können Angaben zur BAE-Softwareversion oder betriebssystemspezifische BAE-Einstellungen entsprechend dem spezifizierten Abfragemodus abgefragt werden.
Siehe auch
Funktion
bae_swconfig.
bae_tbsize - BAE Toolbardimensionen abfragen (STD)
Synopsis
void bae_tbsize(
& double; // Rückgabe Toolbar Textspaltenanzahl
& double; // Rückgabe Toolbar Textzeilenanzahl
);
Beschreibung
Die Funktion
bae_tbsize ermittelt die Größe der mit
bae_settbsize definierten bzw. angezeigten Werkzeugleiste. Die Toolbarbreite wird im Parameter für die Textspaltenanzahl zurückgegeben, während die Toolbarhöhe im Parameter für die Textzeilenanzahl zurückgegeben wird. Mit Hilfe der Funktion
bae_charsize können diese Werte in Standardlängeneinheiten umgerechnet werden.
Siehe auch
Funktionen
bae_charsize,
bae_mtpsize,
bae_settbsize.
bae_twsize - BAE Textarbeitsbereichsgröße abfragen (STD)
Synopsis
void bae_twsize(
& int; // Rückgabe Anzahl Spalten
& int; // Rückgabe Anzahl Zeilen
);
Beschreibung
Die Funktion
bae_twsize ermittelt die aktuelle Größe des Arbeitsbereiches für Textausgaben. Die Größenangaben werden in den beiden Funktionsparametern zurückgegeben und sind als die Anzahl der Spalten bzw. Zeilen des Arbeitsbereiches zu interpretieren. Mit Hilfe dieser Informationen lassen sich Art und Form der Ausgabe auf den Textausgabebereich dynamisch an die BAE-Grafikumgebung anpassen.
Siehe auch
Funktion
bae_mtpsize.
bae_wswinlx - BAE Arbeitsbereich linke Grenze abfragen (STD)
Synopsis
double bae_wswinlx( // Koordinatenwert (STD2)
);
Beschreibung
Der Rückgabewert der Funktion
bae_wswinlx entspricht der linken Begrenzungskoordinate des aktuell sichtbaren grafischen Arbeitsbereichsfensters.
bae_wswinly - BAE Arbeitsbereich untere Grenze abfragen (STD)
Synopsis
double bae_wswinly( // Koordinatenwert (STD2)
);
Beschreibung
Der Rückgabewert der Funktion
bae_wswinly entspricht der unteren Begrenzungskoordinate des aktuell sichtbaren grafischen Arbeitsbereichsfensters.
bae_wswinux - BAE Arbeitsbereich rechte Grenze abfragen (STD)
Synopsis
double bae_wswinux( // Koordinatenwert (STD2)
);
Beschreibung
Der Rückgabewert der Funktion
bae_wswinux entspricht der rechten Begrenzungskoordinate des aktuell sichtbaren grafischen Arbeitsbereichsfensters.
bae_wswinuy - BAE Arbeitsbereich obere Grenze abfragen (STD)
Synopsis
double bae_wswinuy( // Koordinatenwert (STD2)
);
Beschreibung
Der Rückgabewert der Funktion
bae_wswinuy entspricht der oberen Begrenzungskoordinate des aktuell sichtbaren grafischen Arbeitsbereichsfensters.
bae_wsmouse - BAE Arbeitsbereich Mausposition abfragen (STD)
Synopsis
void bae_wsmouse(
& double; // Rückgabe Maus-X-Koordinate (STD2)
& double; // Rückgabe Maus-Y-Koordinate (STD2)
& int; // Rückgabe Mausstatus:
// Bit 0 : jenseits linker
// Arbeitsbereichsbegrenzung
// Bit 1 : jenseits rechter
// Arbeitsbereichsbegrenzung
// Bit 2 : jenseits unterer
// Arbeitsbereichsbegrenzung
// Bit 3 : jenseits oberer
// Arbeitsbereichsbegrenzung
// Bit 4 : linke Maustaste gedrückt
// Bit 5 : rechte Maustaste gedrückt
// Bit 6 : mittlere Maustaste gedrückt
);
Beschreibung
Mit der Funktion
bae_wsmouse können die aktuellen Mauskoordinaten innerhalb des Grafikarbeitsbereichs ermittelt werden. Der Parameter zur Rückgabe des Mausstatus gibt an, welche Maustasten gerade gedrückt sind bzw. ob sich die Mausposition im Augenblick außerhalb der aktuellen Arbeitsbereichsbegrenzung befindet.
Siehe auch
Funktion
bae_popmouse.
catext - Dateinamenserweiterung an Dateiname anhängen (STD)
Synopsis
void catext(
& string; // Dateiname
string; // Dateinamenserweiterung
);
Beschreibung
Die Funktion
catext hängt die angegebene Dateinamenserweiterung an den über den ersten Funktionsparameter spezifierten Dateinamen an sofern dieser nicht bereits mit dieser Dateinamenserweiterung endet.
Siehe auch
Funktion catextadv.
catextadv - Dateinamenserweiterung optional an Dateiname anhängen (STD)
Synopsis
void catextadv(
& string; // Dateiname
string; // Dateinamenserweiterung
int; // Bearbeitungsmodus:
// 0 = Erweiterung nur wenn Dateiname
// keine Erweiterung besitzt
// 1 = Annahme Dateiname besitzt keine
// oder spezifizierte Erweiterung
// 2 = Spezifizierte Erweiterung erzwingen
);
Beschreibung
Die Funktion
catextadv hängt die angegebene Dateinamenserweiterung optional entsprechend des angegebenen Bearbeitungsmodus an den über den ersten Funktionsparameter spezifierten Dateinamen an.
Siehe auch
Funktion catext.
ceil - Gleitkommazahl aufrunden (STD)
Synopsis
double ceil( // Berechnungsergebnis
double; // Eingabewert
);
Beschreibung
Der Rückgabewert der Funktion
ceil entspricht dem nächsten ganzzahligen Gleitkommawert, dessen Wert größer oder gleich dem des übergebenen Gleitkommawertes ist.
clock - Verbrauchte CPU-Zeit ermitteln (STD)
Synopsis
double clock( // Verbrauchte CPU-Zeit (Sekunden)
);
Beschreibung
Der Rückgabewert der Funktion
clock entspricht der seit dem Start des aktuellen BAE-Programmoduls verbrauchten CPU-Zeit in Sekunden.
con_clear - Interne Logische Netzliste löschen (STD)
Synopsis
void con_clear(
);
Beschreibung
Die Funktion
con_clear löscht die mit den Funktionen
con_storepart und
con_storepin erzeugte Logische Netzliste aus dem Hauptspeicher. Dies ist prinzipiell vor dem ersten Aufruf von
con_storepart notwendig um evtl. vorhandene alte Netzlistendaten zu löschen. Diese Funktion sollte in jedem Fall aber auch dann aktiviert werden, wenn die im Speicher befindliche Netzliste nicht mehr benötigt wird, da andernfalls u.U. später ein Speicherüberlauf auftreten kann.
Siehe auch
Funktionen
con_storepart,
con_storepin,
con_write.
con_compileloglib - Logische Bibliotheksdefinition kompilieren (STD)
Synopsis
int con_compileloglib( // Status
string; // DDB-Zieldateiname
string; // Logische Bibliotheksdefinitionsdatei
string; // Logische Bibliotheksdefinition
);
Beschreibung
Die Funktion
con_compileloglib kompiliert die angegebene(n) logischen Bibliotheksdefinitionen und speichert die kompilierten Loglib-Definitionen in der über den ersten Funktionsparameter spezifizierten DDB-Datei. Die logischen Bibliotheksdefinitionen sind in dem für das Utilityprogramm
loglib festglegten Eingabeformat bereitzustellen. Es kann entweder der Inhalt der über den zweiten Funktionsparameter spezifizierten Loglib-Definitionsdatei oder eine im dritten Funktionsparameter angegebene logische Bibliotheksdefinition kompiliert werden. Wird für einen dieser Parameter das Schlüsselwort
NULL angegeben, dann wird der entsprechende Umsetzungsmodus deaktiviert. Der Funktionsrückgabewert ist Null bei erfolgreicher Umsetzung; im Fehlerfall wird ein Wert ungleich Null zurückgegeben.
Siehe auch
Funktionen
con_deflogpart,
con_getlogpart,
lay_deflibname,
scm_defloglname;
BAE Utilityprogramm
loglib.
con_deflogpart - Logische Bauteildefinition in Bibliothek (STD)
Synopsis
int con_deflogpart( // Status
string; // DDB-Zieldateiname
string; // Logischer Bibliotheksteilname
string[]; // Physikalischer Bibliotheksteilname
int [0,1]; // Flag Defaultzuweisung
);
Beschreibung
Die Funktion
con_deflogpart trägt die übergebene logische Bauteildefinition in die angegebene DDB-Zieldatei ein. Die hiermit definierte Zuweisung eines physikalischen Bibliotheksteils an ein Logikbauteil wird vom
Packager des
AutoEngineers zur Umsetzung logischer in physikalische Netzlisten benötigt. Der mit
con_deflogpart definierte Bibliothekseintrag stellt eine 1:1-Zuweisung dar, d.h. der
Packager wird bei einem derartig definierten Bauteil keine Pinnamensumsetzung vornehmen. Auch können mit
con_deflogpart keine Gatterzuweisungen, Pin/Gate-Swaps, Stromversorgungsanschlüsse oder Attributwertzuweisungen definiert werden. Ist für den physikalischen Bibliotheksteilnamen ein Leerstring angegeben, dann erfolgt die Zuweisung an ein virtuelles Bauteil. Wird eine Liste von Namen für das physikalischen Bibliotheksteil übergeben, dann werden entsprechend dieser Namensliste zulässige Alternativbauformen für die Funktionen zum Gehäusewechsel im Layout eingetragen. Ist das Flag für die Defaultzuweisung gesetzt, dann ist eine explizite Gehäusezuweisung über das Attribut
$plname erlaubt. Der Funktionsrückgabewert ist Null bei erfolgreicher Bauteildefinition, (-1) bei fehlenden bzw. ungültigen Parametern, oder (-2) wenn ein Fehler bei der Bauteildefinition aufgetreten ist.
Siehe auch
Funktionen
con_compileloglib,
con_getlogpart; BAE-Utilityprogramm
loglib.
con_getddbpattrib - Bauteil-/Pinattribut in DDB-Datei abfragen (STD)
Synopsis
int con_getddbpattrib( // Status
string; // DDB-Dateiname
string; // Bauteilname
string; // Pinname
& string; // Attributname
// oder Leerstring für Planname
// oder ! für erstes Attribut
// oder !$attrname für nächstes Attribut
& string; // Attributwert Rückgabe
);
Beschreibung
Die Funktion
con_getddbpattrib ermittelt einen Bauteil- oder Pinattributwert in einer DDB-Datei. Der Funktionsrückgabewert ist 1, wenn der Attributwert gefunden wurde, Null wenn das angegebene Attribut nicht existiert, oder (-1) bei Dateizugriffsfehlern. Wird für den Pinnamen ein Leerstring angegeben, dann erfolgt eine Bauteilattributabfrage, ansonsten wird der Pinattributwert ermittelt.
Bei der Spezifikation von Platzhaltern für den Attributnamen (! bzw. !$attrname) wird der darüber adressierte Attributname im entsprechenden Funktionsparamter zurückgegeben.
Siehe auch
Funktion
con_setddbpattrib.
con_getlogpart - Logische Bauteildefinition abfragen (STD)
Synopsis
int con_getlogpart( // Status
string; // LOGLIB-Dateiname
string; // Elementname
int; // Anzahl Ausgabespalten
& string; // Definitionsrückgabestring
);
Beschreibung
Die Funktion
con_getlogpart schreibt die logische Bauteildefinition für das angegebene Element formatiert in den Rückgabestring. Der Rückgabewert ist gleich Null, wenn die Loglib-Information erfolgreich gespeichert wurde, (-1) bei fehlenden bzw. ungültigen Parametern, (-2) wenn die Datei nicht gefunden wurde, (-3) wenn das Element nicht in der Datei gefunden wurde oder (-4) wenn die Loglib-Information nicht erfolgreich geladen werden konnte. Für den LOGLIB-Dateinamen wird üblicherweise ein Projektdateiname oder der mit
scm_defloglname abfragbare default Layoutbibliotheksname für den
Packager-Lauf angegeben.
Siehe auch
Funktionen
con_compileloglib,
con_deflogpart,
lay_deflibname,
scm_defloglname; BAE Utilityprogramm
loglib.
con_setddbpattrib - Bauteil-/Pinattribut in DDB-Datei setzen (STD)
Synopsis
int con_setddbpattrib( // Status
string; // DDB-Dateiname
string; // Bauteilname
string; // Pinname
string; // Attributname
string; // Attributwert
);
Beschreibung
Mit der Funktion
con_setddbpattrib kann ein Bauteil- oder Pin-Attributwert in einer DDB-Datei gesetzt werden. Der Rückgabewert der Funktion ist ungleich Null, wenn ein Fehler aufgetreten ist. Die Angabe des Bauteilnamens ist zwingend, das darüber spezifizierte Bauteil muss in der Netzliste der DDB-Datei definiert sein. Die Angabe des Pinnamens ist optional; wird für den Pinnamen ein Leerstring angegeben, dann wird der Attributwert als Bauteilattribut interpretiert, ansonsten erfolgt der Eintrag eines Pinattributs. Weder Bauteil- noch Pinname dürfen Großbuchstaben enthalten. Der Attributname muss mit dem Zeichen
$ beginnen und darf ebenfalls keine Großbuchstaben enthalten. Für den Attributwert darf ein Leerstring zum Zurücksetzen des Wertes angegeben werden; die maximal speicherbare Länge des Attributwert-Strings beträgt 40 Zeichen.
Bei Spezifikation des konstanten Attributwerts
PA_NILVAL wird das Attribut (entsprechend der Schaltfläche
im
Schaltplaneditor) komplett zurückgesetzt.
Siehe auch
Funktion
con_getddbpattrib.
con_storepart - Interne Logische Netzliste Bauteil speichern (STD)
Synopsis
int con_storepart( // Status
string; // Logischer Bauteilname
string; // Logischer Bauteilbibliotheksname
);
Beschreibung
Die Funktion
con_storepart trägt das übergebene Logische Bauteil in die Bauteilliste der aktuell im Hauptspeicher befindlichen internen Logischen Netzliste ein. Der Rückgabewert ist gleich Null, wenn das Bauteil erfolgreich gespeichert wurde, (-1) bei fehlenden bzw. ungültigen Parametern, oder (-2) wenn das Bauteil bereits in der Netzliste definiert ist. Die interne Logische Netzliste kann mit
con_write in einer DDB-Datei abgelegt werden oder mit
con_clear wieder aus dem Hauptspeicher gelöscht werden.
Warnung
Durch die Verwendung der
con_store*-Funktionen wird Hauptspeicher belegt. Wenn die mit diesen Funktionen erzeugten Netzlistendaten nicht mehr benötigt werden, dann sollte in jedem Fall die im Speicher befindliche Netzliste mit
con_write oder mit
con_clear wieder gelöscht werden, um Speicherplatzproblemen vorzubeugen.
Siehe auch
Funktionen
con_clear,
con_storepin,
con_write.
con_storepin - Interne Logische Netzliste Pin speichern (STD)
Synopsis
int con_storepin( // Status
string; // Logischer Bauteilname
string; // Logischer Bauteilpinname
string; // Netzname
);
Beschreibung
Die Funktion
con_storepin trägt den übergebenen Logischen Bauteilpin in die aktuell im Hauptspeicher befindliche Logische Netzliste ein. Voraussetzung hierfür ist, dass ein Bauteil mit dem angegebenen Namen bereits vorher mit
con_storepart definiert wurde. Ist für den Netznamen ein Leerstring angegeben, dann wird der Pin an kein Netz der Netzliste angeschlossen; im anderen Fall wird der angegebene Pin an das entsprechende Netz angeschlossen. Ist in der Netzliste noch kein Netz mit dem angegebenen Name definiert, dann wird dieses automatisch erzeugt. Der Rückgabewert ist gleich Null, wenn der Bauteilpin erfolgreich gespeichert wurde, (-1) bei fehlenden bzw. ungültigen Parametern, (-2) wenn das Bauteil noch nicht definiert ist, (-3) wenn der Pin bereits angeschlossen ist, oder (-4) wenn zu viele Netze definiert wurden.
Warnung
Durch die Verwendung der
con_store*-Funktionen wird Hauptspeicher belegt. Wenn die mit diesen Funktionen erzeugten Netzlistendaten nicht mehr benötigt werden, dann sollte in jedem Fall die im Speicher befindliche Netzliste mit
con_write oder mit
con_clear wieder gelöscht werden, um Speicherplatzproblemen vorzubeugen.
Siehe auch
Funktionen
con_clear,
con_storepart,
con_write.
con_write - Interne Logische Netzliste auf Datei ausgeben (STD)
Synopsis
int con_write( // Status
string; // DDB-Dateiname
string; // Netzlisten-Elementname
);
Beschreibung
Die Funktion
con_write dient dazu, die mit den
con_store*-Funktionen erzeugte, aktuell im Hauptspeicher befindliche Logische Netzliste in der angegebenen DDB-Datei unter dem spezifizierten Elementnamen abzulegen. Darüber hinaus löscht
con_write die interne Netzliste wieder aus dem Hauptspeicher. Der Rückgabewert ist gleich Null, wenn die Netzliste erfolgreich gespeichert wurde, (-1) bei fehlenden bzw. ungültigen Parametern, (-2) wenn keine Netzlistendaten definiert sind, oder (-3) wenn ein Fehler bei der Ausgabe auf die DDB-Datei aufgetreten ist. Das Format der durch
con_write in der DDB-Datei abgelegten Logischen Netzliste entspricht dem Netzlistenformat, wie es durch den
Schaltplaneditor des
Bartels AutoEngineer erzeugt wird, d.h. die mit
con_write generierte Netzliste kann anschließend durch einen
Packager-Lauf in das Layoutsystem des
Bartels AutoEngineer übernommen werden.
Warnung
Die
con_*-Funktionen stellen ein sehr mächtiges Hilfsmittel zur Übernahme von Fremdnetzlisten in den
Bartels AutoEngineer dar. Dennoch bleibt zu beachten, dass eine unsachgerechter Anwendung dieser Funktionen unter Umständen eine inkonsistente und kaum mehr korrigierbare Vermischung von Netzlistendaten verursachen kann. Es wird daher nachdrücklich empfohlen, stets durch eine vorherige Prüfung der in der Zieldatei abgelegten Daten eine kontrollierte, d.h. konfliktfreie Netzlistenübernahme sicherzustellen.
Siehe auch
Funktionen
con_clear,
con_storepart,
con_storepin.
convstring - Zeichenkette konvertieren (STD)
Synopsis
string convstring( // Rückgabe konvertierte Zeichenkette
string; // Eingabezeichenkette
int; // Konvertierungsmodus:
// 0 = Dateiname ohne Namenserweiterung ermitteln
// 1 = Dateiname ohne Verzeichnispfad ermitteln
// 2 = Dateiname ohne Namenserweiterung
// und Verzeichnispfad ermitteln
);
Beschreibung
Die Funktion
convstring wandelt die Eingabezeichenkette entsprechend dem angegebenen Konvertierungsmodus um und gibt das Ergebnis der Zeichenkettenumwandlung als Rückgabewert zuück.
cos - Cosinus berechnen (STD)
Synopsis
double cos( // Berechnungsergebnis
double; // Winkel (STD3)
);
Beschreibung
Der Rückgabewert der Funktion
cos entspricht dem Cosinus des übergebenen Winkels. Der übergebene Gleitkommawert wird als Bogenmaßangabe interpretiert.
cosh - Hyperbolischen Cosinus berechnen (STD)
Synopsis
double cosh( // Berechnungsergebnis
double; // Winkel (STD3)
);
Beschreibung
Der Rückgabewert der Funktion
cosh entspricht dem hyperbolischen Cosinus des übergebenen Winkels. Der übergebene Gleitkommawert wird als Bogenmaßangabe interpretiert.
cvtangle - Winkel in andere Einheit umwandeln (STD)
Synopsis
double cvtangle( // Winkel (in Ausgabemaßeinheiten)
double; // Winkel (in Eingabemaßeinheiten)
int [0,3]; // Eingabemaßeinheit
int [0,3]; // Ausgabemaßeinheit
);
Beschreibung
Der Rückgabewert der Funktion
cvtangle entspricht der Konvertierung des übergebenen Winkels von der Eingabe- in die Ausgabemaßeinheit. Mögliche Werte für die Maßeinheiten sind 0 für interne Winkel (Bogenmaß, STD3), 1 für Gradmaß, 2 für Bogenmaß
(STD3) und 3 für Neugrad Winkel.
cvtlength - Länge in andere Einheit umwandeln (STD)
Synopsis
double cvtlength( // Länge (in Ausgabemaßeinheiten)
double; // Länge (in Eingabemaßeinheiten)
int [0,4]; // Eingabemaßeinheit
int [0,4]; // Ausgabemaßeinheit
);
Beschreibung
Der Rückgabewert der Funktion
cvtlength entspricht der Konvertierung der übergebenen Länge von der Eingabe- in die Ausgabemaßeinheit. Mögliche Werte für die Maßeinheiten sind 0 für Meter
(STD2), 1 für Inch, 2 für mm, 3 für mil und 4 für Mikrometer.
ddbcheck - DDB-Element auf verfügbarkeit prüfen (STD)
Synopsis
int ddbcheck( // Rückgabe Abfragestatus
string; // DDB-Dateiname
int; // DDB-Datenbankklasse (STD1)
// bzw. (-1) bei gültiger DDB-Dateiprüfung
string; // Elementname bzw. Leerstring bei Prüfung auf beliebige Klassenelemente
);
Beschreibung
Die Funktion
ddbcheck prüft, ob ein Element der spezifizierten Datenbankklasse mit dem angegebenen Namen in der über den Dateinamen spezifizierten DDB-Datei existiert. Wird anstelle einer gültigen Datenbankklasse der Wert (-1) übergeben, dann prüft
ddbcheck lediglich, ob die angegebene Datei verfügbar und eine DDB-Datei ist. Wird ein Leerstring für den Elementnamen übergeben, dann prüft
ddbcheck lediglich, ob überhaupt Elemente der spezifizierten Datenbankklasse in der angegebenen Datei existieren. Der Funktionsrückgabewert is Null, wenn das spezifizierte DDB-Objekt existiert bzw. gefunden wurde oder (-1) im anderen Fall.
Siehe auch
Funktionen
ddbclassscan,
ddbelemrefcount,
ddbelemrefentry.
ddbclassid - DDB-Elementklasse Bezeichnung abfragen (STD)
Synopsis
string ddbclassid( // Rückgabe DDB-Klassenbezeichnung oder Leerstring
int ]0,[; // DDB-Datenbankklasse (STD1)
);
Beschreibung
Die Funktion
ddbclassid ermittelt die Bezeichnung der spezifizierten Datenbankklasse und übergibt diese mit dem Funktionsrückgabewert. Bei Spezifikation unbekannter bzw. ungültiger DDB-Datenbankklassen wird ein Leerstring zurückgegeben.
ddbclassscan - DDB-Elementklasse abarbeiten (STD)
Synopsis
int ddbclassscan( // Abarbeitungsstatus
string; // DDB-Dateiname
int ]0,[; // Element Datenbankklasse (STD1)
* int; // Elementname Abarbeitungsfunktion
);
Beschreibung
Die Funktion
ddbclassscan arbeitet alle Elemente der spezifizierten Datenbankklasse aus der angegebenen DDB-Datei ab. Dabei wird für jedes Element automatisch eine benutzerdefinierte Abarbeitungsfunktion aufgerufen sofern für den entsprechenden Parameter nicht das Schlüsselwort
NULL eingetragen ist. Der Funktionsrückgabewert gibt entweder die Anzahl der abgearbeiteten bzw. gefundenen Elemente an, oder ergibt sich zu (-1) bei ungültigen Parameterangaben oder bei einem Fehlerstatus aus der Abarbeitungsfunktion.
Abarbeitungsfunktion
int callbackfunction( // Abarbeitungsstatus
string ename // Elementname
)
{
// Verarbeitungsprogramm
:
return(scanstatus);
}
Der Rückgabewert der Abarbeitungsfunktion sollte 1 sein, wenn die Abarbeitung fortgesetzt werden soll, 0 wenn die Abarbeitung beendet werden soll, oder (-1) bei einem (benutzerdefinierten) Fehler.
Siehe auch
Funktionen
ddbcheck,
ddbelemrefcount,
ddbelemrefentry.
ddbcopyelem - DDB-Dateielement kopieren (STD)
Synopsis
int ddbcopyelem( // Status
string; // DDB-Quelldateiname
string; // DDB-Zieldateiname
int ]0,[; // DDB-Datenbankklasse (STD1)
string; // DDB-Elementname
int [0,1]; // Merge Source Flag:
// 0 = existierende Zieldateielemente
// werden nicht überschrieben
// 1 = existierende Zieldateielemente
// werden überschrieben
);
Beschreibung
Die Funktion
ddbcopyelem kopiert das angegebene DDB-Element der spezifizierten DDB-Datenbankklasse mit allen abhängigen bzw. referenzierten Elementen von der DDB-Quelldatei in die DDB-Zieldatei. Der Elementname bleibt beim Kopiervorgang erhalten, d.h. die Quell- und Zieldateien müssen unterschiedlich sein. Der letzte Funktionsparameter gibt an, ob existierende Elemente in der Zieldatei überschrieben werden dürfen (Merge Source; Quelldatei ist Master) oder nicht (Merge Destination; Zieldatei ist Master). Der Funktionsrückgabewert ergibt sich zu Null, wenn der Kopiervorgang erfolgreich war; im anderen Fall (ungültige bzw. unvollständige Parameterangaben oder DDB-Dateizugriff fehlgeschlagen) wird der Wert (-1) zurückgegeben.
Warnungen
Die Funktion
ddbcopyelem unterliegt nicht dem
-Mechanismus, da sie auf DDB-Dateiebene arbeitet. Daher sollte diese Funktion mit größter Vorsicht benutzt werden, um ein versehentliches Überschreiben von BAE-Design- bzw. BAE-Systemdaten zu vermeiden.
Siehe auch
Funktionen ddbdelelem,
ddbrenameelem.
ddbdelelem - DDB-Dateielement löschen (STD)
Synopsis
int ddbdelelem( // Status
string; // DDB-Dateiname
int ]0,[; // DDB-Datenbankklasse (STD1)
string; // DDB-Elementname
);
Beschreibung
Die Funktion
ddbdelelem löscht das angegebene DDB-Element der spezifizierten DDB-Datenbankklasse aus der angegebenen DDB-Datei. Der Funktionsrückgabewert ergibt sich zu Null, wenn der Löschvorgang erfolgreich war; im anderen Fall (ungültige bzw. unvollständige Parameterangaben oder DDB-Dateizugriff fehlgeschlagen) wird der Wert (-1) zurückgegeben.
Warnungen
Die Funktion
ddbdelelem unterliegt nicht dem
-Mechanismus, da sie auf DDB-Dateiebene arbeitet. Daher sollte diese Funktion mit größter Vorsicht benutzt werden, um ein versehentliches Löschen von BAE-Design- bzw. BAE-Systemdaten zu vermeiden.
Siehe auch
Funktionen ddbcopyelem,
ddbrenameelem.
ddbelemrefcount - DDB-Dateielement Referenzanzahl abfragen (STD)
Synopsis
int ddbelemrefcount( // Rückgabe Referenzanzahl oder (-1)
string; // DDB-Dateiname
int ]0,[; // DDB-Datenbankklasse (STD1)
string; // DDB-Elementname
);
Beschreibung
Die Funktion
ddbelemrefcount ermittelt die Anzahl der Bibliothekselemente, die von dem angegebenen DDB-Element referenziert werden. Die Angabe des DDB-Elements erfolgt durch die Spezifikation von DDB-Dateiname, DDB-Datenbankklasse sowie Elementname über die entsprechenden Funktionsparameter. Der Funktionsrückgabewert gibt die Anzahl der referenzierten Bibliothekselemente an bzw. ergibt sich zu (-1), wenn das angegebene DDB-Element nicht existiert bzw. nicht verfügbar ist. Zur selektiven Ermittlung der DDB-Datenbankklassen und der Elementnamen einzelner Bibliotheksreferenzeinträge eines DDB-Elements kann die Funktion
ddbelemrefentry benutzt werden.
Siehe auch
Funktionen
ddbcheck,
ddbclassscan,
ddbelemrefentry.
ddbelemrefentry - DDB-Dateielement Referenzeintrag abfragen (STD)
Synopsis
int ddbelemrefentry( // Rückgabe Abfragestatus
string; // DDB-Dateiname
int ]0,[; // DDB-Datenbankklasse (STD1)
string; // DDB-Elementname
int ]0,[; // Referenzeintrag Index
& int ]0,[; // Referenzeintrag DDB-Klasse (STD1)
& string; // Referenzeintrag Elementname
);
Beschreibung
Die Funktion
ddbelemrefentry ermittelt die Datenbankklasse und den Elementnamen eines durch das angegebene DDB-Element referenzierten Bibliothekselements. Die Angabe des abzufragenden Referenzeintrags erfolgt durch die Spezifikation des DDB-Dateinamens, der DDB-Datenbankklasse und des Namens des DDB-Elements sowie durch die Spezifikation eines Index in die Liste der zu diesem DDB-Element definierten Bibliotheksreferenzen. Die Anzahl der Bibliotheksreferenzen des DDB-Elements kann mit der Funktion
ddbelemrefcount ermittelt werden und bestimmt zugleich die Obergrenze für gültige Indizes in die Referenzliste an. Der Funktionsrückgabewert ergibt sich zu Null, wenn die Abfrage erfolgreich war bzw. zu (-1) im anderen Fall.
Siehe auch
Funktionen
ddbcheck,
ddbclassscan,
ddbelemrefcount.
ddbgetelemcomment - DDB-Dateielement Kommentartext abfragen (STD)
Synopsis
int ddbgetelemcomment( // Status
string; // DDB-Dateiname
int ]0,[, // DDB-Datenbankklasse (STD1)
string; // DDB-Elementname
& string; // Rückgabe Kommentartext
);
Beschreibung
Die Funktion
ddbgetelemcomment dient der Abfrage von mit
ddbsetelemcomment gesetzten Kommentartexten für DDB-Dateielemente.
Der Funktionsrückgabewert ist Null bei erfolgreicher Abfrage oder (-1) bei fehlenden oder ungütigen Parametern oder wenn das DDB-Dateielement bzw. der Kommentartext nicht gefunden wurde.
Siehe auch
Funktion ddbsetelemcomment.
ddbgetlaypartpin - DDB-Dateielement Layoutbauteilpindaten abfragen (STD)
Synopsis
int ddbgetlaypartpin( // Rückgabe Abfragestatus:
// ( 0) = kein Fehler, Abfrageergebnis gültig
// (-1) = DDB-Dateizugriffsfehler
// (-2) = Ungültige Parameter
// (-3) = Bauteilsymbol nicht gefunden
// (-4) = Pin nicht definiert
string; // DDB-Dateiname
string; // Layoutbauteilsymbolname
int [0,[; // Pinindex
& string; // Pinname
& string; // Pinsymbolname
& double; // Pin-X-Position (STD2)
& double; // Pin-Y-Position (STD2)
& double; // Pin-Drehwinkel (STD3)
& int; // Pin-Spiegelungsmodus (STD14)
);
Beschreibung
Mit der Funktion
ddbgetlaypartpin können in der angegebenen DDB-Datei Informationen über die auf dem angegebenen Layoutbauteilsymbol definierten Pins abgefragt werden. Zur Abfrage aller Pins eines existierenden Layoutbauteilsymbols kann die Funktion solange mit aufsteigendem Pinindex aufgerufen werden, bis der Funktionsrückgabewert einen nicht definierten Pin signalisiert.
Siehe auch
Funktionen
ddbcheck,
ddbclassscan,
ddbelemrefcount,
ddbelemrefentry.
ddbrenameelem - DDB-Dateielement umbenennen (STD)
Synopsis
int ddbrenameelem( // Status
string; // DDB-Dateiname
int ]0,[, // DDB-Datenbankklasse (STD1)
string; // Alter DDB-Elementname
string; // Neuer DDB-Elementname
);
Beschreibung
Die Funktion
ddbrenameelem ändert den Elementnamen des angegebenen DDB-Dateielements. Der Funktionsrückgabewert ergibt sich zu Null bei erfolgreicher Umbenennung; im anderen Fall (ungültige bzw. unvollständige Parameterangaben oder DDB-Dateizugriff fehlgeschlagen) wird der Wert (-1) zurückgegeben.
Warnungen
Die Funktion
ddbrenameelem unterliegt nicht dem
-Mechanismus, da sie auf DDB-Dateiebene arbeitet. Daher sollte diese Funktion mit größter Vorsicht benutzt werden, um ein versehentliches Umbenennen von BAE-Design- bzw. BAE-Systemdaten zu vermeiden.
Siehe auch
Funktionen ddbcopyelem,
ddbdelelem.
ddbsetelemcomment - DDB-Dateielement Kommentartext setzen (STD)
Synopsis
int ddbsetelemcomment( // Status
string; // DDB-Dateiname
int ]0,[, // DDB-Datenbankklasse (STD1)
string; // DDB-Elementname
string; // Kommentartext
);
Beschreibung
Mit der Funktion
ddbsetelemcomment können Kommentartexte zur späteren Abfrage mit der Funktion
ddbgetelemcomment an DDB-Dateielemente zugewiesen werden.
Der Funktionsrückgabewert ist Null bei erfolgreicher Zuweisung oder (-1) bei fehlenden oder ungütigen Parametern oder wenn das DDB-Dateielement bzw. der Kommentartext nicht gefunden wurde.
Befindet sich das bearbeitete DDB-Element gerade im Arbeitsspeicher, dann wird die Kommentarzuweisung auch dort durchgeführt.
Siehe auch
Funktion ddbgetelemcomment.
ddbupdtime - DDB-Dateielement Änderungsdatum abfragen (STD)
Synopsis
int ddbupdtime( // Status
string; // Dateiname
int [100,[; // Elementklasse (STD1)
string; // Elementname
& int; // Rückgabe Sekunden nach Minutenanfang
& int; // Rückgabe Minuten nach Stundenanfang
& int; // Rückgabe Stunden nach Mitternacht
& int; // Rückgabe Tage nach Monatsanfang
& int; // Rückgabe Monate nach Jahresanfang
& int; // Rückgabe Jahr
);
Beschreibung
Die Funktion
ddbupdtime gibt in den Rückgabeparametern Datum und Zeit der letzten Änderung, die an dem angegebenen Datanbankelement durchgeführt wurde, zurück. Der Rückgabewert ist 1 wenn keine Fehler aufgetreten sind, 0 wenn das angegebene Element nicht in der Datenbankdatei vorhanden ist und (-1) wenn beim Dateizugriff Fehler aufgetreten sind oder die übergebenen Parameter ungültig sind.
dirscan - Dateiverzeichniseinträge abarbeiten (STD)
Synopsis
int dirscan( // Abarbeitungsstatus
string; // Verzeichnispfadname
string; // Dateinamenserweiterung:
// .EXT = Namensendung .EXT
// .* = alle Dateien/Verzeichnisse
* int; // Dateiname Abarbeitungsfunktion
);
Beschreibung
Die Funktion
dirscan arbeitet alle Dateinamen mit der spezifizierten Dateinamenserweiterung aus dem angegebenen Verzeichnis ab. Dabei wird für jeden Dateinamen automatisch eine benutzerdefinierte Abarbeitungsfunktion aufgerufen sofern für den entsprechenden Parameter nicht das Schlüsselwort NULL eingetragen ist. Der Funktionsrückgabewert gibt entweder die Anzahl der abgearbeiteten bzw. gefundenen Dateinamen an, oder ergibt sich zu (-1) bei ungültigen Parameterangaben oder bei einem Fehlerstatus aus der Abarbeitungsfunktion.
Abarbeitungsfunktion
int callbackfunction( // Abarbeitungsstatus
string fname // Dateiname
)
{
// Verarbeitungsprogramm
:
return(scanstatus);
}
Der Rückgabewert der Abarbeitungsfunktion sollte 1 sein, wenn die Abarbeitung fortgesetzt werden soll, 0 wenn die Abarbeitung beendet werden soll, oder (-1) bei einem (benutzerdefinierten) Fehler.
existddbelem - DDB-Dateielement Existenz prüfen (STD)
Synopsis
int existddbelem( // Status
string; // Dateiname
int [100,[; // Elementklasse (STD1)
string; // Elementname
);
Beschreibung
Der Rückgabewert der Funktion
existddbelem gibt an, ob das angegebene Element nicht in der Datenbankdatei vorhanden ist. Der Rückgabewert ist 1 wenn das Element gefunden wurde, 0 wenn das angegebene Element nicht in der Datenbankdatei vorhanden ist und (-1) wenn beim Dateizugriff Fehler aufgetreten sind oder die übergebenen Parameter ungültig sind.
exit - Programm verlassen (STD)
Synopsis
void exit(
int; // Rückgabe Status
);
Beschreibung
Die Funktion
exit beendet das aktuelle
User Language-Programm mit dem übergebenen Status.
Warnung
Der Rückgabestatus wird derzeit nicht von der Interpreterumgebung ausgewertet.
Siehe auch
Funktion ulsystem_exit.
exp - Exponentialfunktion (STD)
Synopsis
double exp( // Berechnungsergebnis
double; // Eingabewert
);
Beschreibung
Der Rückgabewert der Funktion
exp entspricht dem Wert der Exponentialfunktion für den übergebenen Gleitkommawert.
fabs - Absolutwert eines Gleitkommawertes (STD)
Synopsis
double fabs( // Berechnungsergebnis
double; // Eingabewert
);
Beschreibung
Der Rückgabewert der Funktion
fabs entspricht dem Absolutwert des übergebenen Gleitkommawertes.
fclose - Datei schließen (STD)
Synopsis
int fclose( // Status
int; // Dateideskriptor
);
Beschreibung
Die Funktion
fclose schließt die durch den Dateideskriptor beschriebene Datei. Der Rückgabewert ist ungleich Null, wenn beim Schließen der Datei ein Fehler aufgetreten ist.
fcloseall - Alle offenen Dateien schließen (STD)
Synopsis
int fcloseall( // Status
);
Beschreibung
Die Funktion
fcloseall schließt alle durch das aktuelle
User Language-Programm geöffneten Dateien. Der Rückgabewert ist ungleich Null, wenn beim Schließen der Dateien ein Fehler aufgetreten ist.
feof - Prüfen ob Dateiende erreicht (STD)
Synopsis
int feof( // Status
int; // Dateideskriptor
);
Beschreibung
Der Rückgabewert der Funktion
feof ist ungleich Null, wenn das Ende der durch den Dateideskriptor beschriebenen Datei erreicht ist.
fgetc - Zeichen aus Datei einlesen (STD)
Synopsis
int fgetc( // Zeichencode (oder -1 bei EOF)
int; // Dateideskriptor
);
Beschreibung
Die Funktion
fgetc liest ein Zeichen aus der durch den Dateideskriptor beschriebenen Datei. Der Rückgabewert der Funktion entspricht dem gelesenen Zeichen oder (-1), wenn beim Lesen ein Fehler aufgetreten ist, oder wenn das Dateiende erreicht ist. Bei einem Rückgabewert von (-1) sollte also in jedem Fall (mit der Funktion
feof) überprüft werden, ob das Dateiende erreicht ist. Hierzu ist vorher der Fehlerbehandlungsmodus für die Dateizugriffsfunktionen entsprechend zu setzen (siehe Funktion
fseterrmode).
fgets - Zeichenkette aus Datei einlesen (STD)
Synopsis
int fgets( // Status
& string; // Rückgabe Zeichenkette
int; // Maximale Einleselänge
int; // Dateideskriptor
);
Beschreibung
Die Funktion
fgets liest eine Zeichenkette aus der durch den Dateideskriptor beschriebenen Datei. Der Rückgabewert der Funktion ist ungleich Null, wenn beim Lesen ein Fehler aufgetreten ist, oder wenn das Dateiende erreicht ist. Bei einem Rückgabewert von (-1) sollte also in jedem Fall (mit der Funktion
feof) überprüft werden, ob das Dateiende erreicht ist. Hierzu ist vorher der Fehlerbehandlungsmodus für die Dateizugriffsfunktionen entsprechend zu setzen (siehe Funktion
fseterrmode).
filemode - Dateimodus abfragen (STD)
Synopsis
int filemode( // Dateimodus
string; // Dateiname
);
Beschreibung
Die Funktion
filemode ermittelt den Dateimodus bzw. die Zugriffsberechtigung für die angegebene Datei. Der Funktionsrückgabewert ist 0 bei Schreibzugriff, 1 bei Lesezugriff oder (-1), wenn der Zugriff auf die Datei fehlgeschlagen ist.
Siehe auch
Funktionen filesize,
filetype.
filesize - Dateigröße abfragen (STD)
Synopsis
int filesize( // Dateigröße in Bytes oder (-1) bei Fehler
string; // Dateiname
);
Beschreibung
Die Funktion
filesize ermittelt die Dateigröße der angegebenen Datei. Der Funktionsrückgabewert gibt entweder die ermittelte Dateigröße in Bytes an oder ergibt sich zu (-1), wenn der Zugriff auf die Datei fehlgeschlagen ist.
Siehe auch
Funktionen filemode,
filetype.
filetype - Dateityp abfragen (STD)
Synopsis
int filetype( // Rückgabe Dateityp:
// (-1) = Dateizugriff fehlgeschlagen
// ( 0) = Verzeichnis
// ( 1) = Reguläre Datei
// ( 2) = Textdatei
string; // Dateiname
);
Beschreibung
Die Funktion
filetype ermittelt den Typ der angegebenen Datei. Der Funktionsrückgabewert gibt entweder den ermittelten Dateityp an oder ergibt sich zu (-1), wenn der Zugriff auf die Datei fehlgeschlagen ist.
Siehe auch
Funktionen filemode,
filesize.
floor - Gleitkommawert abrunden (STD)
Synopsis
double floor( // Berechnungsergebnis
double; // Eingabewert
);
Beschreibung
Der Rückgabewert der Funktion
floor entspricht dem nächsten ganzzahligen Gleitkommawert, dessen Wert kleiner oder gleich dem des übergebenen Gleitkommawertes ist.
fmod - Gleitkommadivision Rest berechnen (STD)
Synopsis
double fmod( // Berechnungsergebnis
double; // Dividend
double; // Divisor
);
Beschreibung
Der Rückgabewert der Funktion
fmod entspricht dem Rest der Division von Dividend und Divisor.
fopen - Datei öffnen (STD)
Synopsis
int fopen( // Status
string; // Dateiname
int [0,14]; // Zugriffsmodus:
// 0 = r Lesen (einzig gültiger BAE Demo Zugriffsmodues ohne |8)
// 1 = w Schreiben
// 2 = a Anfügen
// 3 = rb Lesen binär
// 4 = wb Schreiben binär
// 5 = ab Anfügen binär
// |8 = Datei automatisch schließen (für BAE Demo Schreibtests)
);
Beschreibung
Die Funktion
fopen öffnet die angegebene Datei zur Bearbeitung mit dem gewünschten Zugriffsmodus. Bei Schreibzugriff wird die Datei gegebenenfalls neu erzeugt. Der Rückgabewert der Funktion beträgt (-1), wenn beim Öffnen/Erzeugen der Datei ein Fehler aufgetreten ist, oder entspricht dem zur weiteren Bearbeitung benötigten Dateideskriptor.
Einschränkung
In den Demo-Konfigurationen der BAE-Software kann mit
fopen nur lesend auf Dateien zugegriffen werden.
fprintf - Formatierte Ausgabe auf Datei (STD)
Synopsis
int fprintf( // Status
int; // Dateideskriptor
string; // Formatzeichenkette
[] // Parameterliste
);
Beschreibung
Die Funktion
fprintf schreibt die in der Parameterliste enthaltenen Daten formatiert in die durch den Dateideskriptor beschriebene Datei. Die Formatzeichenkette enthält Informationen, wie die Formatierung stattzufinden hat. Der Rückgabewert der Funktion ist ungleich Null, wenn beim Schreiben ein Fehler aufgetreten ist.
Formatzeichenkette
Mit Hilfe der Formatzeichenkette wandelt die Funktion nachfolgende Parameterwerte um und gibt sie entsprechend formatiert aus. Die Formatzeichenkette kann gewöhnliche Zeichen und Formatelemente enthalten. Gewöhnliche Zeichen werden unverändert ausgegeben, während Formatelemente jeweils die Umwandlung und formatierte Ausgabe des nächstfolgenden Parameterwertes veranlassen. Jedes Formatelement beginnt mit dem Prozentzeichen
% und wird durch ein Formatkontrollzeichen abgeschlossen. Gültige Formatkontrollzeichen sind:
| Zeichen | Ausgabedatentyp |
|---|
d | Dezimal-Darstellung |
o | Oktal-Darstellung |
x | Hexadezimal-Darstellung (Kleinschreibung) |
X | Hexadezimal-Darstellung (Großschreibung) |
u | Vorzeichenlose Dezimal-Darstellung |
c | Zeichen |
s | Zeichenkette |
e | Fließkomma-Darstellung (Kleinschreibung) |
E | Fließkomma-Darstellung (Großschreibung) |
f | Festkomma-Darstellung |
g | e oder f, jeweils kürzere Darstellungsform |
G | E oder f, jeweils kürzere Darstellungsform |
% | Ausgabe des Prozentzeichens % |
Zwischen dem Prozentzeichen und dem Formatkontrollzeichen können der Reihe nach noch folgende Angaben eingetragen sein (n = Zahlenwert):
| Zeichen | Ausgabeformat |
|---|
- | Linksbündigkeit (default: rechtsbündig) |
+ | Vorzeichenausgabe auch bei positivem numerischen Wert |
SPACE | Ausgabe eines Leerzeichens bei positivem Wert |
# | oktale Ausgabe mit führender 0
bzw. hexadezimale Ausgabe mit führendem 0x oder 0X
bzw. Ausgabe mit Dezimalpunkt bei e, E, f, g, G
bzw. Nachkommanullen bei g, G |
0 | Ausgabe führender Nullen bei numerischen Werten |
n | Feldlänge; d.h. minimale Ausgabelänge |
.n | Genauigkeit; d.h. Anzahl anzuzeigender Zeichen (bei s)
bzw. Anzahl Nachkommastellen (bei f, g, G) |
l | long int Dezimal-Darstellung (bei d, o, X, X) |
Bei
e,
E,
f,
g und
G werden per Default sechs Nachkommastellen ausgegeben. Ist anstelle der numerischen Angabe für die Feldlänge bzw. für die Genauigkeit das Zeichen
* angegeben, dann wird der entsprechende Wert aus dem nächsten noch nicht abgearbeiteten Funktionsparameter übernommen. Die Ausgabe eines Prozentzeichens kann durch die Angabe
%% veranlasst werden. Durch Backslash
\ gekennzeichnete Steuerzeichen werden wie gewöhnliche Zeichen behandelt.
Warnung
Die Anzahl und der Typ der dem Formatstring nachfolgenden Parameterwerte muss mit der Anzahl der Paare der Prozent- und Formatkontrollzeichen im Formatstring übereinstimmen. Andernfalls wird "Speichermüll" ausgegeben.
Siehe auch
Funktionen
printf,
sprintf.
fputc - Zeichen in Datei schreiben (STD)
Synopsis
int fputc( // Status
char; // Zeichen
int; // Dateideskriptor
);
Beschreibung
Die Funktion
fputc schreibt das übergebene Zeichen in die durch den Dateideskriptor beschriebene Datei. Der Rückgabewert der Funktion ist ungleich Null, wenn beim Schreiben ein Fehler aufgetreten ist.
fputs - Zeichenkette in Datei schreiben (STD)
Synopsis
int fputs( // Status
string; // Zeichenkette
int; // Dateideskriptor
);
Beschreibung
Die Funktion
fputs schreibt die übergebene Zeichenkette in die durch den Dateideskriptor beschriebene Datei. Der Rückgabewert der Funktion ist ungleich Null, wenn beim Schreiben ein Fehler aufgetreten ist.
frexp - Exponentialdarstellung ermitteln (STD)
Synopsis
double frexp( // Berechnungsergebnis
double; // Eingabewert
& int; // Exponentrückgabe
);
Beschreibung
Der Rückgabewert der Funktion
frexp ist die Mantisse der Exponentialdarstellung der übergebenen Gleitkommazahl. Der Exponent wird über Parameter zurückgegeben.
fseterrmode - Dateifehler-Behandlungsmodus setzen (STD)
Synopsis
int fseterrmode( // Status
int [0,1]; // Fehlermodus
);
Beschreibung
Die Funktion
fseterrmode setzt den Fehlerbehandlungsmodus für Dateizugriffsfehler. Wenn der Modus auf eins gesetzt ist, wird bei Dateizugriffsfehlern das
User Language-Programm von der aktuellen Interpreterumgebung mit einer entsprechenden Fehlermeldung abgebrochen. Bei einem Modus von Null geben die Dateizugriffsfunktionen einen entsprechenden Fehlercode zurück; die Fehlerbehandlung ist in diesem Fall durch das
User Language-Programm selbst durchzuführen. Die Defaulteinstellung für den Fehlerbehandlungsmodus ist eins.
Warnung
Bei der Verwendung von Dateizugriffsfunktionen, deren Rückgabestatus entweder als Dateizugriffs-Fehler oder z.B. als Dateiende interpretiert werden kann (siehe Funktionen
fgetc,
fgets), sollte in jedem Fall der Fehlerbehandlungsmodus auf Null gesetzt werden, um zu verhindern, dass die Interpreterumgebung das
User Language-Programm beim Erreichen des Dateiendes mit einem Fehler abbricht.
get_date - Systemdatum ermitteln (STD)
Synopsis
void get_date(
& int; // Tag (1..31)
& int; // Monat (0..11)
& int; // Jahre seit 1900
);
Beschreibung
Die Funktion
get_date gibt in den Parametern das aktuelle Systemdatum zurück.
get_time - Systemuhrzeit ermitteln (STD)
Synopsis
void get_time(
& int; // Stunden seit Mitternacht (0..23)
& int; // Minuten seit Stundenanfang (0..59)
& int; // Sekunden seit Minutenanfang (0..59)
);
Beschreibung
Die Funktion
get_time gibt in den Parametern die aktuelle Systemuhrzeit zurück.
getchr - Zeichen einlesen (STD)
Synopsis
char getchr( // Zeichen
);
Beschreibung
Die Funktion
getchr liest ein Zeichen von der Tastatur ein. Der Rückgabewert der Funktion entspricht dem gelesenen Zeichen.
getcwd - Pfadname des Arbeitsverzeichnisses abfragen (STD)
Synopsis
string getcwd( // Rückgabe Pfadname
);
Beschreibung
Die Funktion
getcwd ermittelt den Pfadnamen des Arbeitsverzeichnisses übergibt diesen als Funktionsrückgabewert.
getenv - Umgebungsvariable abfragen (STD)
Synopsis
int getenv( // Status
string; // Variablenname
& string; // Variablenwert
);
Beschreibung
Die Funktion
getenv durchsucht die Liste der Betriebssystemumgebungsvariablen nach dem angegebenen Variablennamen und übergibt den zugehörigen Variablenwert im entsprechenden Parameter. Der Funktionsrückgabewert ist Null, wenn die Variable gefunden wurde bzw. ungleich Null, wenn keine Umgebungsvariable mit dem angegebenen Namen definiert ist (in diesem Fall bleibt der Parameter für den Variablenwert unverändert).
Siehe auch
Funktion putenv.
getextprog - Dateitypspezifische Applikation ermitteln (STD)
Synopsis
int getextprog( // Status
string; // Dateinamenserweiterung
& string; // Kommandozeichenkette
);
Beschreibung
Die Funktion
getextprog ermittelt die Applikation bzw. das Kommando zum Öffnen des durch die angegene Dateinamenserweiterung spezifizierten Dateityps. Der Funktionsrückgabewert ist Null bei erfolgreicher Abfrage oder (-1) wenn keine Applikation für die angegebene Dateinamenserweiterung ermittelt werden konnte.
getstr - Zeichenkette einlesen (STD)
Synopsis
int getstr( // Status
& string; // Rückgabe Zeichenkette
int; // Maximale Zeichenkettenlänge
);
Beschreibung
Die Funktion
getstr liest Zeichen von der Tastatur in die übergebene Zeichenkette ein, bis die Return- bzw. Eingabetaste gedrückt wird oder die maximale Anzahl Zeichen erreicht ist. Der Rückgabewert ist ungleich Null, wenn ungültige Parameter übergeben wurden.
isalnum - Prüfen ob Zeichen alphanumerisch (STD)
Synopsis
int isalnum( // Bool'sches Prüfergebnis
char; // Eingabezeichen
);
Beschreibung
Der Rückgabewert der Funktion
isalnum gibt an, ob es sich bei dem übergebenen Zeichen um ein alphanumerisches Zeichen (Buchstabe oder Ziffer) handelt. Der Wert ist ungleich Null, wenn die Bedingung erfüllt ist und Null wenn nicht.
isalpha - Prüfen ob Zeichen Buchstabe (STD)
Synopsis
int isalpha( // Bool'sches Prüfergebnis
char; // Eingabezeichen
);
Beschreibung
Der Rückgabewert der Funktion
isalpha gibt an, ob es sich bei dem übergebenen Zeichen um einen Buchstaben handelt. Der Wert ist ungleich Null, wenn die Bedingung erfüllt ist und Null wenn nicht.
iscntrl - Prüfen ob Zeichen Kontrollzeichen (STD)
Synopsis
int iscntrl( // Bool'sches Prüfergebnis
char; // Eingabezeichen
);
Beschreibung
Der Rückgabewert der Funktion
iscntrl gibt an, ob es sich bei dem übergebenen Zeichen um ein Kontrollzeichen handelt. Der Wert ist ungleich Null, wenn die Bedingung erfüllt ist und Null wenn nicht.
isdigit - Prüfen ob Zeichen Ziffer (STD)
Synopsis
int isdigit( // Bool'sches Prüfergebnis
char; // Eingabezeichen
);
Beschreibung
Der Rückgabewert der Funktion
isdigit gibt an, ob es sich bei dem übergebenen Zeichen um eine Ziffer handelt. Der Wert ist ungleich Null, wenn die Bedingung erfüllt ist und Null wenn nicht.
isgraph - Prüfen ob Zeichen sichtbares Zeichen (STD)
Synopsis
int isgraph( // Bool'sches Prüfergebnis
char; // Eingabezeichen
);
Beschreibung
Der Rückgabewert der Funktion
isgraph gibt an, ob es sich bei dem übergebenen Zeichen um ein Zeichen mit sichtbarer Bilddarstellung handelt. Der Wert ist ungleich Null, wenn die Bedingung erfüllt ist und Null wenn nicht.
islower - Prüfen ob Zeichen Kleinbuchstabe (STD)
Synopsis
int islower( // Bool'sches Prüfergebnis
char; // Eingabezeichen
);
Beschreibung
Der Rückgabewert der Funktion
islower gibt an, ob es sich bei dem übergebenen Zeichen um einen Kleinbuchstaben handelt. Der Wert ist ungleich Null, wenn die Bedingung erfüllt ist und Null wenn nicht.
isprint - Prüfen ob Zeichen druckbares Zeichen (STD)
Synopsis
int isprint( // Bool'sches Prüfergebnis
char; // Eingabezeichen
);
Beschreibung
Der Rückgabewert der Funktion
isprint gibt an, ob es sich bei dem übergebenen Zeichen um ein druckbares Zeichen handelt. Der Wert ist ungleich Null, wenn die Bedingung erfüllt ist und Null wenn nicht.
ispunct - Prüfen ob Zeichen Satzzeichen (STD)
Synopsis
int ispunct( // Bool'sches Prüfergebnis
char; // Eingabezeichen
);
Beschreibung
Der Rückgabewert der Funktion
ispunct gibt an, ob es sich bei dem übergebenen Zeichen um ein Satzzeichen handelt. Der Wert ist ungleich Null, wenn die Bedingung erfüllt ist und Null wenn nicht.
isspace - Prüfen ob Zeichen Zwischenraumzeichen (STD)
Synopsis
int isspace( // Bool'sches Prüfergebnis
char; // Eingabezeichen
);
Beschreibung
Der Rückgabewert der Funktion
isspace gibt an, ob es sich bei dem übergebenen Zeichen um ein Zwischenraumzeichen handelt. Der Wert ist ungleich Null, wenn die Bedingung erfüllt ist und Null wenn nicht.
isupper - Prüfen ob Zeichen Großbuchstabe (STD)
Synopsis
int isupper( // Bool'sches Prüfergebnis
char; // Eingabezeichen
);
Beschreibung
Der Rückgabewert der Funktion
isupper gibt an, ob es sich bei dem übergebenen Zeichen um einen Großbuchstaben handelt. Der Wert ist ungleich Null, wenn die Bedingung erfüllt ist und Null wenn nicht.
isxdigit - Prüfen ob Zeichen Hex-Ziffer (STD)
Synopsis
int isxdigit( // Bool'sches Prüfergebnis
char; // Eingabezeichen
);
Beschreibung
Der Rückgabewert der Funktion
isxdigit gibt an, ob es sich bei dem übergebenen Zeichen um eine Hexadezimalziffer handelt. Der Wert ist ungleich Null, wenn die Bedingung erfüllt ist und Null wenn nicht.
kbhit - Prüfen ob Taste betätigt (STD)
Synopsis
int kbhit( // Tastaturstatus
);
Beschreibung
Der Rückgabewert der Funktion
kbhit gibt den aktuellen Status der Tastatureingabe an. Ein Rückgabewert von 0 bedeutet es wurde keine Taste gedrückt. Eine 1 bedeutet, dass ein Taste gedrückt wurde. Der Tastencode verbleibt dabei im Tastaturpuffer und kann mit
getchr oder anderen Tastatureingabefunktionen eingelesen werden.
Siehe auch
Funktion kbstate.
kbstate - Umschalt-/Steuerungs-Tastenstatus abfragen (STD)
Synopsis
int kbstate( // Tastaturstatus (Bitwerte):
// 0x***1 = Umschalttaste gedrückt
// 0x***2 = Steuerungstaste gedrückt
// 0x**1* = Linke Alt-Taste gedrückt
// 0x**2* = Rechte Alt-Taste gedrückt
);
Beschreibung
Mit der Funktion
kbstate kann abgefragt werden, ob die Umschalttaste
Shift, die Steuerungstaste
Ctrl bzw. die
Alt-Tasten gerade gedrückt sind.
Siehe auch
Funktion kbhit.
launch - Betriebssystemkommando absetzen ohne die Ausführung abzuwarten (STD)
Synopsis
int launch( // Status
string; // Kommando
);
Beschreibung
Die Funktion
launch aktiviert das als Zeichenkette übergebene Kommando auf Betriebssystemebene. Das übergebene Kommando wird als Aufruf zum Start bzw. zur Ausführung einer Applikation bzw. eines Programms interpretiert, und die Ablaufkontrolle wird unmittelbar nach Absetzen des Kommandos wieder an BAE zurückgegeben (die aktivierte Applikation läuft dann unabhängig von BAE). Der Rückgabewert der Funktion ergibt sich zu Null, wenn das Kommando erfolgreich abgesetzt wurde; andernfalls wird ein Wert ungleich Null zurückgegeben.
Einschränkungen
Die Funktion
launch kann nicht in der
BAE Demo-Software angewendet werden.
Unter MS-DOS benötigt der
Phar Lap 386|DOS Extender ausreichend konventionellen Speicher zur Ausführung von (Child-)Prozessen. Die Größe des zur Verfügung stehenden konventionellen Speichers wird mit den Optionen
-MINREAL und
-MAXREAL des
Phar Lap 386|DOS Extenders festgelegt. Zur Ausführung von
User Language-Programmen, die die
launch-Funktion benutzen, sind die
User Language-Interpreterumgebungen mit Hilfe des mit der BAE-Software ausgelieferten CFIG386-Tools von Phar Lap wie folgt umzukonfigurieren:
> cfig386 <EXEFILE> -maxreal 0ffffh 
Für
<EXEFILE> ist jeweils der Name des
User Language Interpreters
(scm.exe,
ged.exe,
neurrut.exe,
cam.exe,
gerview.exe bzw.
ced.exe) einzusetzen.
Warnungen
Beachten Sie, dass die
launch-Funktion grundlegende Mehrprozess- bzw. Multitasking-Techniken voraussetzt, die auf PC-basierenden Systemen u.U. nicht ausreichend unterstützt werden, oder die in Rechnernetzwerken (abhängig vom auszuführenden Kommando) Probleme bereiten können.
Es wird dringend empfohlen, die Standardausgabe von DOS-Kommandos auf temporäre Dateien umzulenken und zur Anzeige eine
User Language-Funktion zur Dateibetrachtung zu verwenden, da andernfalls die BAE-Grafikoberfläche von der Standardausgabe der mit
launch abgesetzten DOS-Kommandos überschrieben wird.
Die Fehlerausgabe von DOS-Kommandos erfolgt grundsätzlich auf den Bildschirm, wodurch die BAE-Grafikoberfläche überschrieben wird. Da unter DOS prinzipiell keine Möglichkeit zur Umlenkung der Fehlerausgabe besteht, ist dieses Problem nur dadurch zu umgehen, dass z.B. durch eine Konsistenzprüfung vor dem Aufruf der
launch-Funktion die Aktivierung fehlerhafter DOS-Kommandos unterdrückt wird.
Da von der BAE-Grafikoberfläche keine Benutzereingaben an DOS-Kommandos übergeben werden können, ist dringend davon abzuraten, interaktive DOS-Kommandos bzw. Grafikapplikationen mit der
launch-Funktion abzusetzen (andernfalls "hängt sich das System auf"). Unter UNIX lässt sich dieses Problem u.U. dadurch umgehen, dass interaktive Kommandos wie z.B.
more oder
vi in Hintergrundprozessen (&) aktiviert werden (was allerdings im Remote Login zu Problemen beim Terminalzugriff führen kann).
Siehe auch
Funktion
system.
ldexp - Gleitkommamultiplikation mit 2^n (STD)
Synopsis
double ldexp( // Berechnungsergebnis
double; // Eingabewert
& int; // Exponent
);
Beschreibung
Der Rückgabewert der Funktion
ldexp entspricht dem Produkt von Eingabewert und der durch den Exponenten spezifizierten Potenz von zwei.
localtime - Systemdatum und Systemzeit abfragen (STD)
Synopsis
double localtime( // CPU-Zeit (Sekunden)
& int; // Sekunden seit Minutenanfang (0..59)
& int; // Minuten seit Stundenanfang (0..59)
& int; // Stunden seit Mitternacht (0..23)
& int; // Tag (1..31)
& int; // Monat (0..11)
& int; // Jahre seit 1900
& int; // Tage seit Sonntag (0..6)
& int; // Tage seit Jahresanfang (0..365)
);
Beschreibung
Die Funktion
localtime gibt in den Parametern die aktuelle Systemzeit mit Datumsangabe zurück. Der Rückgabewert der Funktion entspricht der verbrauchten CPU-Zeit in Sekunden.
log - Logarithmus zur Basis e (STD)
Synopsis
double log( // Berechnungsergebnis
double ]0.0,[; // Eingabewert
);
Beschreibung
Der Rückgabewert der Funktion
log entspricht dem natürlichen Logarithmus (Basis e) des übergebenen Gleitkommawertes.
log10 - Logarithmus zur Basis 10 (STD)
Synopsis
double log10( // Berechnungsergebnis
double ]0.0,[; // Eingabewert
);
Beschreibung
Der Rückgabewert der Funktion
log10 entspricht dem dekadischen Logarithmus (Basis 10) des übergebenen Gleitkommawertes.
mkdir - Dateiverzeichnis anlegen (STD)
Synopsis
int mkdir( // Status
string; // Verzeichnispfadname
);
Beschreibung
Die Funktion
mkdir legt ein Dateiverzeichnis mit dem angegebenen Verzeichnispfadnamen an. Der Funktionsrückgabewert ist Null wenn das Verzeichnis erfolgreich erzeugt wurde oder (-1) bei fehlenden oder falschen Parametern oder bei Verzeichniszugriffsfehlern.
modf - Gleitkommazahl Vor- und Nachkommastellen (STD)
Synopsis
double modf( // Rückgabe Nachkommawert
double; // Eingabewert
& double; // Rückgabe Vorkommawert
);
Beschreibung
Die Funktion
modf teilt eine Gleitkommazahl in Vor- und Nachkommastellen auf. Der Rückgabewert der Funktion entspricht den Nachkommastellen. Die Vorkommastellen werden im entsprechenden Parameter zurückgegeben.
namestrcmp - Namensvergleich (STD)
Synopsis
int namestrcmp( // Vergleichsergebnis
string; // Erster Name
string; // Zweiter Name
);
Beschreibung
Die Funktion
namestrcmp vergleicht die beiden übergebenen Zeichenketten. Der Vergleich wird Zeicehn für Zeichen und ohne Unterscheidung von Groß- und Kleinschreibung vorgenommen. Der Rückgabewert ist Null bei Gleichheit, (-1) wenn die erste Zeichenkette kleiner als die zweite Zeichenkette ist und 1 wenn die erste Zeichenkette größer als die zweite Zeichenkette ist.
Siehe auch
Funktionen numstrcmp,
strcmp.
numstrcmp - Numerischer Zeichenkettenvergleich (STD)
Synopsis
int numstrcmp( // Vergleichsergebnis
string; // Erste Zeichenkette
string; // Zweite Zeichenkette
);
Beschreibung
Die Funktion
numstrcmp vergleicht die beiden übergebenen Zeichenketten. Der Rückgabewert beträgt Null bei Gleichheit, (-1) wenn die erste Zeichenkette kleiner als die zweite Zeichenkette ist und ansonsten eins. Die Berechnung erfolgt für nicht Ziffern Zeichen für Zeichen durch numerischen Vergleich des ASCII-Wertes der verglichenen Zeichen. Bei Ziffern werden Zifferngruppen zu Zahlen zusammengefasst und diese Zahlen miteinander verglichen. Dadurch wird bei Sortierungen eine Reihenfolge von z.B. R1, R2, .. R10, R11 erreicht.
Siehe auch
Funktionen namestrcmp,
strcmp.
perror - Fehlermeldung in Statuszeile ausgeben (STD)
Synopsis
void perror(
string; // Zeichenkette
);
Beschreibung
Die Funktion
perror zeigt die übergebene Zeichenkette in der Statuszeile der BAE-Benutzeroberfläche an. Es erfolgt hierbei eine kurzzeitig invertierte Darstellung (einfaches Blinken), um den Anwender auf die Dringlichkeit der Meldung aufmerksam zu macheb. Bei Übergabe eines Leerstrings wird der Inhalt der Statuszeile gelöscht.
Siehe auch
Funktion
bae_prtdialog.
pow - Potenzfunktion x^y (STD)
Synopsis
double pow( // Berechnungsergebnis
double; // Basis
double; // Exponent
);
Beschreibung
Der Rückgabewert der Funktion
pow entspricht dem Wert der mit dem Exponenten potenzierten Basis.
printf - Formatierte Ausgabe (STD)
Synopsis
void printf(
string; // Formatzeichenkette
[] // Parameterliste
);
Beschreibung
Die Funktion
printf gibt die in der Parameterliste enthaltenen Daten formatiert im Arbeitsbereich des Bildschirms aus. Die Formatzeichenkette enthält Informationen, wie die Formatierung stattzufinden hat (siehe hierzu Beschreibung der Funktion
fprintf).
Siehe auch
Funktionen
fprintf,
sprintf.
programid - Programmname abfragen (STD)
Synopsis
string programid( // Programmname
);
Beschreibung
Der Rückgabewert der Funktion
programid entspricht dem Namen des gerade abgearbeiteten Programmes.
putchr - Zeichen ausgeben (STD)
Synopsis
int putchr( // Status
char; // Zeichen
);
Beschreibung
Die Funktion
putchr gibt das übergebene Zeichen im Arbeitsbereich des Bildschirms aus. Der Rückgabewert der Funktion ist ungleich Null, wenn bei der Ausgabe ein Fehler aufgetreten ist.
putenv - Umgebungsvariable setzen (STD)
Synopsis
int putenv( // Status
string; // Variablenname
string; // Variablenwert
);
Beschreibung
Die Funktion
putenv weist der angegebenen Betriebssystemumgebungsvariablen einen Wert zu. Der Funktionsrückgabewert ist Null, wenn die Zuweisung erfolgreich war bzw. (-1) wenn die angegebene Variable nicht gefunden wurde.
Siehe auch
Funktion getenv.
puts - Zeichenkette mit Zeilenabschluss ausgeben (STD)
Synopsis
int puts( // Status
string; // Zeichenkette
);
Beschreibung
Die Funktion
puts gibt die übergebene Zeichenkette im Arbeitsbereich des Bildschirms mit anschließendem Zeilenvorschub aus. Der Rückgabewert der Funktion ist ungleich Null, wenn bei der Ausgabe ein Fehler aufgetreten ist.
putstr - Zeichenkette ausgeben (STD)
Synopsis
int putstr( // Status
string; // Zeichenkette
);
Beschreibung
Die Funktion
putstr gibt die übergebene Zeichenkette im Arbeitsbereich des Bildschirms aus. Der Rückgabewert der Funktion ist ungleich Null, wenn bei der Ausgabe ein Fehler aufgetreten ist.
quicksort - Indexliste sortieren (STD)
Synopsis
int quicksort( // Status
& void; // Indexliste (Integer-Array)
int; // Indexanzahl
* int; // Elementvergleichsfunktion
);
Beschreibung
Die Funktion
quicksort sortiert die übergebene Indexliste nach dem Quicksortverfahren. Der Rückgabewert ergibt sich zu Null bei erfolgreicher Sortierung oder zu (-1) im Fehlerfall.
Elementvergleichsfunktion
int sortfuncname(
int idx1, // Index 1
int idx2, // Index 2
)
{
// Compare index 1 to index 2
:
return(compareresult);
}
Der Rückgabewert der Elementvergleichsfunktion sollte (-1) sein wenn der erste Indexwert kleiner ist als der zweite Indexwert, 1 wenn der erste Indexwert größer als der zweite ist, oder Null wenn beide Indexwerte gleich sind.
remove - Datei oder Verzeichnis löschen (STD)
Synopsis
int remove( // Status
string; // Pfadname
);
Beschreibung
Die Funktion
remove löscht die Datei oder das Verzeichnis mit dem spezifizierten Pfadnamen. Der Rückgabewert der Funktion ist ungleich Null, wenn beim Löschen ein Fehler aufgetreten ist.
rename - Datei umbenennen (STD)
Synopsis
int rename( // Status
string; // Alter Name
string; // Neuer Name
);
Beschreibung
Die Funktion
rename ändert den Namen einer Datei. Der Rückgabewert der Funktion ist ungleich Null, wenn bei der Namensänderung ein Fehler aufgetreten ist.
rewind - Auf Dateianfang positionieren (STD)
Synopsis
void rewind(
int; // Dateideskriptor
);
Beschreibung
Die Funktion
rewind positioniert den Dateizeiger der durch den Dateideskriptor beschriebenen Datei auf den Dateianfang.
rulecompile - Regeldefinition kompilieren (STD)
Synopsis
int rulecompile( // Status
string; // Zieldateiname
string; // Regelname
string; // Regelcode
);
Beschreibung
Die Funktion
rulecompile kompiliert den übergebenen Regelcode und speichert die kompilierte Regel unter dem angegebenen Regelnamen in der Zieldatei ab. Der Rückgabewert ist Null bei erfolgreicher Kompilierung oder ungleich Null wenn ein Fehler aufgetreten ist.
Siehe auch
Funktion
rulesource.
rulesource - Regeldefinitionsquellcode abfragen (STD)
Synopsis
int rulesource( // Returns status
string; // Regeldatenbankdateiname
string; // Regelname
& string; // Regelquellcode
);
Beschreibung
Die Funktion
rulesource ermittelt den Quellcode der durch Regeldatenbankdateiname und Regelname angegebenen Regeldefinition. Der Quellcode der Regeldefinition wird über einen entsprechenden Parameter als Zeichenkette an den Aufrufer zurückgegeben. Der Funktionsrückgabewert ist Null wenn die Abfrage erfolgreich war, (-1) bei fehlenden oder ungültigen Parametern, (-2) wenn die Regeldatenbank nicht gefunden/geöffnet werden konnte, (-3) wenn die Regeldefinition nicht gefunden wurde oder (-5) wenn die Regeldefinition nicht geladen werden konnte.
Siehe auch
Funktion
rulecompile.
scanddbenames - Inhalt Datenbank abfragen (STD)
Synopsis
int scanddbenames( // Scan Status
string; // Dateiname
int [100,[; // Elementklasse (STD1)
int [0,[; // Elementklasse (STD1) oder Null zum Auslesen des Cache
& string; // Elementname Ein-/Ausgabe
);
Beschreibung
Die Funktion
scanddbenames sucht den dem übergebenen Feldnamen folgenden Elementeintrag der gegebenen Klasse in der Datenbankdatei und übergibt den Namen im Namensparameter. Bei Eingabe einer Leerzeichenkette wird das erste Element aus der Datenbank zurückgegeben. Der Rückgabewert ist 1 wenn ein Element gefunden wurde, 0 wenn kein weiteres Element in der Datenbankdatei vorhanden ist und (-1) wenn beim Dateizugriff Fehler aufgetreten sind oder die übergebenen Parameter ungültig sind.
scandirfnames - Inhalt Dateiverzeichnis abfragen (STD)
Synopsis
int scandirfnames( // Scan Status
string; // Verzeichnispfadname
string; // Dateinamenserweiterung:
// .EXT = Namensendung .EXT
// .* = alle Dateien/Verzeichnisse
& string; // Datei-/Verzeichnisname Ein-/Ausgabe
);
Beschreibung
Die Funktion
scandirfnames sucht den auf den übergebenen Namen folgenden Namenseintrag mit der gegebenen Endung im angegebenen Verzeichnis und übergibt den Namen im Namensparameter. Bei Eingabe einer Leerzeichenkette wird der erste Verzeichniseintrag zurückgegeben. Der Rückgabewert ist 1 wenn eine Datei bzw. ein Unterverzeichnis gefunden wurde, 0 wenn kein weiterer Eintrag im Verzeichnis vorhanden ist und (-1) wenn beim Verzeichniszugriff Fehler aufgetreten sind oder die übergebenen Parameter ungültig sind.
setprio - BAE Prozesspriorität setzen (STD)
Synopsis
void setprio(
int; // Prozessprioritätswert
// - Unix/Linux:
// nice-Prioritätswert
// - Windows:
// <0 = HIGH_PRIORITY_CLASS
// 0 = NORMAL_PRIORITY_CLASS
// >0 = IDLE_PRIORITY_CLASS
// - andernfalls ignoriert
);
Beschreibung
Die Funktion
setprio setzt die Priorität des aktuellen BAE-Prozesses entsprechend dem angegebenen Prozessprioritätswert.
sin - Sinus berechnen (STD)
Synopsis
double sin( // Berechnungsergebnis
double; // Eingabewert (STD3)
);
Beschreibung
Der Rückgabewert der Funktion
sin entspricht dem Sinus des übergebenen Winkels. Der übergebene Gleitkommawert wird als Bogenmaßangabe interpretiert.
sinh - Hyperbolischen Sinus berechnen (STD)
Synopsis
double sinh( // Berechnungsergebnis
double; // Eingabewert (STD3)
);
Beschreibung
Der Rückgabewert der Funktion
sinh entspricht dem hyperbolischen Sinus des übergebenen Winkels. Der übergebene Gleitkommawert wird als Bogenmaßangabe interpretiert.
sprintf - Formatierte Ausgabe auf String (STD)
Synopsis
int sprintf( // Anzahl dekodierte Zeichen
& string; // Ausgabezeichenkette
string; // Formatzeichenkette
[] // Parameterliste
);
Beschreibung
Die Funktion
sprintf gibt die in der Parameterliste enthaltenen Daten formatiert auf die Ausgabezeichenkette aus, d.h. mit dieser Funktion lässt sich eine Formatumwandlung im Speicher durchführen. Die Formatzeichenkette enthält Informationen, wie die Formatierung stattzufinden hat (siehe hierzu Beschreibung der Funktion
fprintf). Der Rückgabewert der Funktion entspricht der Anzahl der umgewandelten Zeichen, d.h. die resultierende Länge der Ausgabezeichenkette.
Siehe auch
Funktionen
fprintf,
printf.
sqlcmd - SQL Kommando ausführen (STD)
Synopsis
int sqlcmd( // Status
string; // Datenbankdateiname
string; // SQL-Kommando
* int; // Datenrückgabefunktion
);
Beschreibung
Über die Funktion
sqlcmd kann mit Hilfe einer Zugriffsprache der Datentransfer von und zu einer mit
sqlinit initialisierten relationalen Datenbank gesteuert werden. Der erste Parameter der Funktion
sqlcmd gibt den Namen der Datenbankdatei an, die für die Bearbeitung geöffnet werden soll. Im zweiten Parameter ist das auszuführende SQL-Kommando für den Datenzugriff zu spezifizieren. Die selektierten Datenfelder werden dem Aufrufer über die im dritten Parameter referenzierte Datenrückgabefunktion übergeben. Soll keine Datenrückgabefunktion aktiviert werden, dann ist für den entsprechenden Funktionsparameter das Schlüsselwort
NULL einzutragen. Der Rückgabewert der Funktion
sqlcmd ist ungleich Null bei fehlenden oder ungültigen Parametern oder wenn ein SQL-Datenbankfehler aufgetreten ist; die genaue Fehlerursache lässt sich im Falle eines SQL-Datenbankfehlers anschließend mit Hilfe der Funktion
sqlerr bestimmen.
SQL-Kommandos
Die durch
sqlcmd interpretierbare Datenbank-Zugriffssprache lehnt sich in ihrer Befehlssyntax an die Structured Query Language (SQL) für relationale Datenbanken an. Es werden die folgenden Grundbefehle angeboten:
create table |
drop table |
insert into table values |
quickinsert into table values |
index table |
select from table |
delete from table |
help |
Zur Repräsentation von Daten stehen die folgenden Datentypen zur Verfügung:
| Schlüsselwort | Datentyp |
integer | Ganze Zahlen im Bereich [-2147483648, 2147483647] |
float | Fließpunktzahlen im Bereich [-10^308, 10^308] mit einer Genauigkeit von ca. 15 führenden Stellen |
string | Zeichenketten (in einfachen Anführungszeichen) |
boolean | Logical value (FALSE oder TRUE) |
date | Datum; Eingabe dd/mm/yyyy, Ausgabe yyyymmdd |
Kommando create table
Mit dem
create-Kommando wird eine Tabellenstruktur in der Datenbank hinterlegt. Dazu ist neben dem Tabellennamen eine Liste der Feldnamen mit den entsprechenden Datentypen der Feldelemente aufzuführen. Die in der Auflistung verwendete Reihenfolge wird auch bei der Datenausgabe verwendet, sofern keine explizite Angabe von Ausgabefeldern erfolgt. Die Syntax des
create-Kommandos lautet:
create table tablename ( name1 type1, ..., namen typen ) ;
Für jedes Datenfeld einer Tabelle wird automatisch ein Index erstellt. Die Indizes werden bei der Bearbeitung von Datenbankabfragen - soweit dies sinnvoll ist - automatisch herangezogen. Der Benutzer braucht sich daher über deren optimale Verwendung keine Gedanken zu machen. Bei Stringvariablen werden nur die ersten 39 Zeichen für den Index berücksichtigt.
Kommando drop table
Mit dem
drop-Kommando wird eine Tabellenstruktur aus der Datenbankdatei entfernt. Dabei werden die Struktur der Tabelle sowie alle in der Tabelle gespeicherten Einträge gelöscht. Die Syntax des
drop-Kommandos lautet:
drop table tablename ;
Kommando insert into
Mit dem
insert-Kommando wird ein Datensatz in eine Tabelle eingetragen. Die angegebenen Werte müssen in Anzahl und Typabfolge mit der Tabellendefinition übereinstimmen. Die Syntax des
insert-Kommandos lautet:
insert into tablename values ( val1, ..., valn ) ;
Kommando quickinsert insert into
Das Kommando
quickinsert entspricht dem Kommando
insert mit dem Unterschied, dass
quickinsert im Gegensatz zu
insert nach der Eintragung der Daten keinen automatischen Update der Feldindizes durchführt.
Zur Aktualisierung der Feldindizes ist nach der (wiederholten) Anwendung des Kommandos
quickinsert das Kommando
index table auszuführen.
quickinsert und
index table eignen sich insbesondere zum schnellen Eintragen zahlreicher Datensätze in einer Tabelle, da die
der einmalige Indizierungsprozess mit
index table sehr viel schneller ist als die wiederholte Indizierung mit
insert.
Zu beachten ist dabei allerdings, dass mit
quickinsert eingefügte Datensätze solange nicht in Abfrageergebnissen aufscheinen bis ein
index table-Aufruf durchgeführt wurde.
Kommando index table
Das Kommando
index table dient dazu, zuvor mit
quickinsert (siehe oben) in eine Tabelle eingespielten Datensätze zu indizieren. Die Syntax des
index-Kommandos lautet:
index table tablename ;
Kommando select from
Mit dem
select-Kommando können Datenbankinhalte abgefragt werden. Dabei kann über einen optional angebbaren
where-Ausdruck die Ausgabemenge auf Datensätze beschränkt werden, für die die in diesem Ausdruck angegebenen Bedingungen erfüllt sind. Ist kein
where-Ausdruck angegeben, dann erfolgt die Ausgabe sämtlicher Datensätze. Die Syntax des
select-Kommandos lautet:
select [ field1, ..., fieldn ] from table1, ..., tablen
[ where ... ] ;
Die Spezifikation der Ausgabefelder ist optional. Sind keine Ausgabefelder spezifiziert, dann werden sämtliche Ausgabefelder entsprechend der Reihenfolge ihrer Definition ausgegeben. Ist ein Ausgabefeldname in mehreren der angegebenen Tabellen definiert, so muss diese Mehrdeutigkeit durch eine Angabe des Feldnamens in der Form
table.field aufgelöst werden. Dies gilt in gleicher Weise für die Referenzierung von Feldern innerhalb des
where-Ausdrucks. Der
where-Ausdruck setzt sich aus Vergleichen zusammen, die mit den logischen Operatoren
AND (logisch Und),
OR (logisch oder) und
NOT (logisch nicht) verknüpft werden können. Die Vergleichsoperatoren
= (gleich),
<> (ungleich),
> (größer),
>= (größer gleich),
< (kleiner) und
<= (kleiner gleich) stehen für alle Datentypen zur Verfügung. Für den Stringdatentyp stehen darüber hinaus noch die Operatoren
PREVTO (selektieren vorherigen Eintrag),
NEXTTO (selektieren nächsten Eintrag) und
LIKE (Stringmustervergleich) zur Verfügung; auf der rechten Seite dieser Operatoren kann ein Testpatternstring angegeben werden, der die Wildcardzeichen
% (für beliebige Zeichenkette) und
? (für beliebiges Einzelzeichen) enthalten darf. Bei Vergleichen müssen die Terme links und rechts der Vergleichsoperatoren typkompatibel, d.h. vom gleichen Datentyp sein; eine Ausnahme hiervon bildet lediglich die Datentypkombination
integer-float. Terme können aus Operatoren und dadurch verknüpften Datenfeldreferenzen und Konstanten aufgebaut werden. Hierfür stehen die Operatoren
+ (Addition),
- (Subtraktion),
* (Multiplikation),
/ (Division),
% (Rest nach Division),
UPPER (Umwandlung in Großschreibung) und
LOWER (Umwandlung in Kleinschreibung) zur Verfügung. Die Zulässigkeit der verwendbaren Operatoren hängt gemäß folgender Auflistung von den Datentypen der referenzierten Feldelemente bzw. Konstanten ab:
| Operator | Datentyp |
|---|
+ | integer, float, string |
- | integer, float |
* | integer, float |
/ | integer, float |
% | integer, float |
UPPER() | string |
LOWER() | string |
Auf die Datentypen
date und
boolean kann keiner der definierten Operatoren angewendet werden.
Kommando delete from
Mit dem
delete-Kommando werden Datensätze aus einer Tabellenstruktur entfernt. Die Syntax des
delete-Kommandos lautet:
delete from tablename [ where ... ] ;
Die optional angebbare
where-Bedingung entspricht in ihrer Syntax der
where-Bedingung des
select-Kommandos. Das
delete-Kommando entfernt diejenigen Datensätze aus der angegebenen Tabelle, die der angegebenen
where-Bedingung entsprechen; ist keine
where-Bedingung angegeben, dann werden alle Datensätze aus der Tabelle entfernt.
Kommando cache
Das
cache-Kommando dient dazu, die SQL-Datenbankdatei über mehrere Kommandos hinweg zum Lesen oder Schreiben geöffnet zu halten. Das Öffnen und Schliessen von SQL-Datenbankdateien ist insbesondere beim Zugriff auf Netzlaufwerke der zeitintensivste Teil bei Abfragen. Anwendungen die eine Vielzahl von Einzelkommandozugriffen auf eine SQL-Datenbank durchführen, können bei Verwendung dieser neuen Kommandos auf Netzlaufwerken um mehrere Größenordnungen schneller ablaufen. Die Syntax des
cache-Kommandos unterstützt die folgenden Befehle:
cache read on ;
cache write on ;
cache off ;
Kommando help
Das
help-Kommando dient dazu, Informationen über die in einer Datenbank definierten Tabellenstrukturen einzuholen. Die Syntax des
help-Kommandos lautet:
help [ tablename ] ;
Die durch das
help-Kommando ermittelten Daten werden über die Datenrückgabefunktion an den Aufrufer zurückgegeben. Die Angabe des Tabellennamens ist optional. Wird kein Tabellenname spezifiziert, dann liefert das
help-Kommando die Namen der in der Datenbank definierten Tabellen im entsprechenden Parameter der Datenrückgabefunktion zurück, d.h. pro Tabellendefinition erfolgt ein Aufruf der Datenrückgabefunktion. Ist ein Tabellenname angegeben, dann liefert das
help-Kommando die Namen der in dieser Tabelle definierten Datenfelder mit den entsprechenden Datentypangaben in den korrespondierenden Parametern der Datenrückgabefunktion zurück, d.h. pro Datenfeld der spezifizierten Tabelle erfolgt ein Aufruf der Datenrückgabefunktion.
Datenrückgabefunktion
int datafunc(
string dstr, // Zeichenkette oder Datum
int dint, // Ganzzahliger oder Logischer Wert
double ddbl, // Fließkommazahl
int dval, // Datengültigkeitskennzeichen:
// 0 = ungültige Daten
// 1 = gültige Daten
int dtype, // Datenfeld Typ:
// 2 = Ganzzahliger Wert
// 3 = Fließkommazahl
// 4 = Zeichenkette
// 5 = Datum (Format "yyyymmdd")
// 6 = Logischer Wert (0=FALSE,1=TRUE)
string dtable, // Tabellenname
string dfield, // Datenfeld Name
int didx // Datenausgabefeld Index
)
{
// Verarbeitungsprogramm
:
return(errstat);
}
Die Datenrückgabefunktion dient dazu, dem Aufrufer die selektierten Datenfelder zu übergeben. Die Funktion wird für jedes selektierte Datenfeld einzeln aufgerufen. Diese Funktion wird demnach bei z.B. 10 selektierten Datensätzen mit je 5 Datenfeldern 50 mal aufgerufen. Der Index des Datenausgabefeldes gibt an, das wievielte Datenfeld des aktuellen Datensatzes übergeben wird. Er nimmt Werte von 1 bis zur Anzahl der aktuell definierten Datenausgabefelder an. Der Rückgabewert der Datenrückgabefunktion sollte Null sein, wenn kein (semantischer) Fehler im Verarbeitungsprogramm der Funktion aufgetreten ist; im Fehlerfall sollte ein Wert ungleich Null zurückgegeben werden, um die Datenbankabfrage abzubrechen.
Warnung
Da die Funktion
sqlcmd direkt auf den Datenbankdateiebene arbeitet, unterliegt sie - ebenso wie alle Dateizugriffsfunktionen des
AutoEngineers - nicht dem -Mechanismus.
Siehe auch
Funktionen
sqlerr,
sqlinit.
Beispiel
Erzeugen der Tabelle
partdata mit den Datenfelddefinitionen
symname (String),
val (String) und
partno (String) in der Datenbankdatei
partdata.dat:
if (sqlinit("partdata.dat",1)!=0)
{
perror("SQL Init error!");
exit(0);
}
if (sqlcmd("partdata.dat",
"create table partdata (symname string,val string,partno string);",
NULL)!=0)
{
perror("SQL Query error!");
exit(0);
}
Eintragen von Daten in die Datenbank:
if (sqlcmd("partdata.dat",
"insert into partdata values ('r','470','STK100470');",
NULL)!=0)
{
perror("SQL Data input error!");
exit(0);
}
Abfragen von Daten:
if (sqlcmd("partdata.dat",
"select partno from partdata where symname='r' AND val='470';",
datafunc)!=0)
{
perror("SQL Query error!");
exit(0);
}
:
int datafunc(dstr,dint,ddbl,dval,dtype,dtable,dfield,didx)
string dstr;
int dint;
double ddbl;
int dval,dtype;
string dtable,dfield;
int didx;
{
printf("Part Number : %s\n");
}
Löschen von Daten:
if (sqlcmd("partdata.dat",
"delete from partdata where symname='r';",NULL)!=0)
{
perror("SQL Delete error!");
exit(0);
}
sqlerr - SQL Fehlerstatus abfragen (STD)
Synopsis
void sqlerr(
& int; // Fehlercode
& string; // Fehlerstring
);
Beschreibung
Die Funktion
sqlerr dient der genauen Bestimmung der Fehlerursache nach einem erfolglosen Aufruf der Funktion
sqlcmd.
Diagnose
Zur Bestimmung der Fehlerursache sind die durch
sqlerr zurückgegebenen Parameterwerte heranzuziehen. Der zurückgegebene Fehlerstring identifiziert ggf. das fehlerverursachende Element. Die möglichen Werte, die der Fehlercode durch die Ausführung eines SQL-Kommandos annehmen kann, haben folgende Bedeutung:
| Fehlercode | Bedeutung |
|---|
| 0 | SQL-Kommando fehlerfrei ausgeführt |
| 1 | SQL-Kommando Lesefehler (intern) |
| 2 | SQL-Kommando zu komplex (über 200 Terme) |
| 3 | Ungültiger numerischer Ausdruck |
| 4 | SQL-Kommandodatei nicht gefunden (intern) |
| 5 | SQL-Kommandoelement zu lang (über 200 Zeichen) |
| 6 | SQL-Kommando Syntaxfehler bei <c> |
| 7 | Allgemeiner SQL-Kommando-Parserfehler |
| 8 | Fehler beim Erzeugen der Datenbank |
| 9 | Dateizugriffsfehler |
| 10 | Zu viele offene Dateien |
| 11 | Datei <d> ist keine Datenbank |
| 12 | Datenbankstruktur beschädigt |
| 13 | Datenbankdateiaufbau fehlerhaft |
| 14 | Schlüsselbegriff <k> nicht gefunden |
| 15 | Schlüsselbegriff <k> existiert bereits |
| 16 | Datei <d> nicht gefunden |
| 17 | Ungültiger Datentyp für Tabellenelement <t>.<f> |
| 18 | Zu viele Tabellenelemente |
| 19 | Dateneintrag zu lang |
| 20 | Bedingte Löschung nur für eine Tabelle erlaubt |
| 21 | Term/Vergleich enthält unzulässige Typkombination |
| 22 | Ausgabefeld <f> undefiniert/in keiner Tabelle |
| 23 | Ausgabefeld <f> in mehreren Tabellen definiert |
| 24 | Ausgabetabelle <t> nicht in from-Tabellenliste |
| 25 | Tabelle <t> bereits definiert |
| 26 | Datenbankklassenanzahl überschreitet Datenbanklimit |
| 27 | Tabelle <t> nicht gefunden |
| 28 | Fehler von Datenrückgabefunktion |
| 29 | Kein delete-Record gefunden |
| 30 | Unbekanntes/neueres Datenbankformat |
| 31 | Abfragefeld nicht in Tabelle(n) enthalten |
| 32 | Abfragefeld in mehreren Tabellen enthalten |
| 33 | Dateilesezugriff verweigert |
| 34 | Dateischreibzugriff verweigert |
| 35 | Allgemeiner Datenbankfehler |
Der Fehlerstring kann je nach Fehlerfall ein Kommandoelement
<c>, eine Datei
<d>, einen Schlüsselbegriff
<k>, eine Tabelle
<t> oder ein Datenfeld
<f> bezeichnen.
Siehe auch
Funktionen
sqlcmd,
sqlinit.
sqlinit - SQL Datenbank initialisieren (STD)
Synopsis
int sqlinit( // Status
string; // Datenbankdateiname
int; // Initialisierungsmodus
);
Beschreibung
Die Funktion
sqlinit dient der Initialisierung eines mit den
sql*-Funktionen bearbeitbaren relationalen Datenbankssystems. Für den Initialisierungsmodus kann entweder 0 zur Benutzung einer existierenden Datenbankdatei, oder 1 zur Erzeugung einer neuen Datenbankdatei angegeben werden. Der Rückgabewert ist Null bei erfolgreicher Datenbankinitialisierung, oder 1 wenn die Datenbank bereits initialisiert ist; jeder andere Rückgabewert weist auf einen Fehler bei der Initialisierung bzw. Erzeugung der Datenbank hin. Das Format der mit den
sql*-Funktionen bearbeitbaren Dateien ist das DDB-Format des
Bartels AutoEngineer. Das bedeutet, dass die mit den
sql*-Funktionen speicherbaren Daten in einer DDB-Datei zusammen mit AutoEngineer-Jobdaten oder in einer separaten DDB-Datei abgelegt werden können. Damit ist es z.B. möglich, projektrelevante PPS-Daten in der entsprechenden Designdatei abzulegen, oder spezielle Bauteilattribute automatisch mit entsprechenden Einträgen einer separaten Datenbank zu initialisieren. Für die relationale Datenbank sind im DDB-Format die Datenbankklassen 4096 bis 8191 reserviert. Dabei werden in der Datenbankklasse 4096 die Strukturen der einzelnen Tabellen hinterlegt. Die Datenbankklasse 4097 dient der Verwaltung der freien Datenbankklassen und enthält lediglich einen Eintrag mit dem Namen
info, der bei der Initialisierung mit der Funktion
sqlinit angelegt wird. Die Existenz dieses Eintrages ist ein eindeutiges Kriterium für die Abfrage, ob eine Datenbank für die Verwendung als relationale Datenbankdatei initialisiert ist. Die dynamisch verwalteten Datenbankklassen 4352 bis 8192 dienen der Speicherung der Tabelleneinträge und Indizes. Die Anzahl der für jede Tabelle benötigten Datenbankklassen ergibt sich aus der Anzahl der Tabellenfelder plus 1.
Siehe auch
Funktionen
sqlcmd,
sqlerr.
sqrt - Quadratwurzel berechnen (STD)
Synopsis
double sqrt( // Berechnungsergebnis
double [0.0,[; // Eingabewert
);
Beschreibung
Der Rückgabewert der Funktion
sqrt entspricht der Quadratwurzel des übergebenen Gleitkommawertes.
strcmp - ASCII-Zeichenkettenvergleich (STD)
Synopsis
int strcmp ( // Vergleichsergebnis
string; // Erste Zeichenkette
string; // Zweite Zeichenkette
);
Beschreibung
Die Funktion
strcmp vergleicht die beiden übergebenen Zeichenketten. Der Rückgabewert beträgt Null bei Gleichheit, (-1) wenn die erste Zeichenkette kleiner als die zweite Zeichenkette ist und 1 ansonsten. Die Berechnung erfolgt Zeichen für Zeichen durch numerischen Vergleich der ASCII-Werte der beiden verglichenen Zeichen.
Siehe auch
Funktionen namestrcmp,
numstrcmp.
strcspn - Zeichenkette Länge Startmuster berechnen (STD)
Synopsis
int strcspn( // Match Position
string; // Eingabezeichenkette
string; // Suchzeichenkette
);
Beschreibung
Der Rückgabewert der Funktion
strcspn entspricht der Anzahl der Zeichen am Beginn der Eingabezeichenkette die nicht in der übergebenen Suchzeichenkette vorhanden sind.
strdelchr - Zeichenkette Zeichenmenge entfernen (STD)
Synopsis
void strdelchr(
& string; // Zeichenkette
string; // Zu löschende Zeichen
int; // Startposition
int; // Endposition
);
Beschreibung
Die Funktion
strdelchr löscht in der übergebenen Zeichenkette von der Startposition bis zur Endposition alle Zeichen, die in der Zeichenkette der zu löschenden Zeichen aufgeführt sind.
strextract - Zeichenkette Sub-Zeichenkette extrahieren (STD)
Synopsis
string strextract( // Extrahierte Zeichenkette
string; // Zeichenkette
int; // Startposition (0 - strlen-1)
int; // Endposition (0 - strlen-1)
);
Beschreibung
Die Funktion
strextract gibt die bei der Startposition (Zählung beginnt bei 0) beginnende und bei der Endposition endende Sub-Zeichenkette der übergebenen Zeichenkette zurück. Start- und Endposition werden wenn nötig auf die Stringgrenzen justiert. Ist die Startposition größer als die Endposition, dann dreht sich auch die Extraktionsrichtung entsprechend um.
strextractfilepath - Verzeichnisname aus Dateipfadname extrahieren (STD)
Synopsis
string strextractfilepath( // Rückgabe Verzeichnisname
string; // Pfadname
);
Beschreibung
Die Funktion
strextractfilepath extrahiert den Verzeichnisnamen aus dem angegebenen Pfadnamen.
Siehe auch
Funktion
strgetpurefilename.
strgetconffilename - Konfigurationsdateiname mit optionaler Umgebungsvariable bestimmen (STD)
Synopsis
string strgetconffilename( // Rückgabe Konfigurationsdateipfadname
string; // Bezeichnung Umgebungsvariable
string; // Dateiname
int; // Verzeichnisabfragemodus:
// 0 : Programmverzeichnis bevorzugen
// 1 : Datenverzeichnis für alle Benutzer bevorzugen
// 2 : Datenverzeichnis für aktuellen Benutzer bevorzugen
);
Beschreibung
Die Funktion strgetconffilename gibt den über die angegebene Umgebungsvariable definierten Konfigurationsdateinamen zurück. Die Konfigurationsdateisuche wird dabei in verschiedenen Verzeichnissen entsprechend dem spezifierten Verzeichnisabfragemodus durchgeführt.
Siehe auch
Funktion strgetvarfilename.
strgetvarfilename - Dateiname aus Umgebungsvariable ableiten (STD)
Synopsis
string strgetvarfilename( // Rückgabe Dateiname
string; // Bezeichnung Umgebungsvariable
);
Beschreibung
Die Funktion strgetvarfilename gibt den über die angegebene Umgebungsvariable definierten Datei- bzw. Dateipfadnamen zurück.
Siehe auch
Funktion strgetconffilename.
strgetpurefilename - Dateiname aus Dateipfadname extrahieren (STD)
Synopsis
string strgetpurefilename( // Rückgabe Dateiname
string; // Pfadname
);
Beschreibung
Die Funktion
strgetpurefilename extrahiert den Dateinamen aus dem angegebenen Pfadnamen.
Siehe auch
Funktion
strextractfilepath.
strlen - Zeichenkette Länge ermitteln (STD)
Synopsis
int strlen( // Zeichenkettenlänge
string; // Zeichenkette
);
Beschreibung
Der Rückgabewert der Funktion
strlen entspricht der Länge der übergebenen Zeichenkette (ohne abschließendes NUL-Zeichen).
strlistitemadd - String in Stringliste eintragen (STD)
Synopsis
void strlistitemadd(
& string; // Durch Komma getrennte Stringliste
string; // String
);
Beschreibung
Die Funktion strlistitemadd trägt den spezifizierten String in die durch Komma getrennte Liste von Strings ein.
Siehe auch
Funktion strlistitemchk.
strlistitemchk - String in Stringliste suchen (STD)
Synopsis
int strlistitemchk( // Suchergebnis
string; // Durch Komma getrennte Stringliste
string; // Suchstring
);
Beschreibung
Die Funktion strlistitemchk sucht den spezifizierten Suchstring in der durch Komma getrennten Liste von Strings. Der Funktionsrückgabewert ist Null wenn der Suchstring nicht in der Stringliste enthalten ist, 1 wenn der Suchstring in der Stringliste enthalten ist oder 2 wenn der Suchstring mit der kompletten Stringliste identisch ist.
Siehe auch
Funktion strlistitemadd.
strlower - Zeichenkette in Kleinbuchstaben umwandeln (STD)
Synopsis
void strlower(
& string; // Ein-/Ausgabezeichenkette
);
Beschreibung
Die Funktion
strlower wandelt die in der übergebenen Zeichenkette vorhandenen Buchstaben in Kleinbuchstaben um.
strmatch - Zeichenkette Musterabfrage (STD)
Synopsis
int strmatch( // Match Flag
string; // Eingabezeichenkette
string; // Testpatternzeichenkette
);
Beschreibung
Die Funktion
strmatch überprüft, ob die Eingabezeichenkette dem übergebenen Testpattern entspricht. Dabei sind in dem Testpattern die Sonderzeichen
* für eine beliebige Zeichenfolge und
? für ein beliebiges Zeichen in jeder Kombination mit normalen Zeichen erlaubt. Der Rückgabewert ist ungleich Null, wenn die Eingabezeichenkette dem Testpattern entspricht und Null wenn nicht.
strnset - Zeichenkette mit n Zeichen füllen (STD)
Synopsis
void strnset(
& string; // Zeichenkette
char; // Füllzeichen
int; // Füllanzahl
);
Beschreibung
Die Funktion
strnset ersetzt die ersten Füllanzahl Zeichen der übergebenen Zeichenkette mit dem Füllzeichen. Ist die Länge der Zeichenkette kleiner als die Füllanzahl, so werden nur die vorhandenen Zeichen, d.h. alle, ersetzt.
strreverse - Zeichenkette Zeichenreihenfolge umkehren (STD)
Synopsis
void strreverse(
& string; // Ein-/Ausgabezeichenkette
);
Beschreibung
Die Funktion
strreverse kehrt die Reihenfolge der Zeichen in der übergebenen Zeichenkette um.
strscannext - Zeichen in Zeichenkette vorwärts suchen (STD)
Synopsis
int strscannext( // Match Position
string; // Zeichenkette
string; // Suchzeichenkette
int; // Startposition (1 - strlen)
int; // Stop-on-match Flag:
// 0 = Continue-on-match
// 1 = Stop-on-match
);
Beschreibung
Die Funktion
strscannext sucht in der übergebenen Zeichenkette ab der Startposition (Zählung beginnt bei 1) aufsteigend nach Zeichen, die in der Suchzeichenkette aufgeführt sind. Das Suchflag gibt an, ob die erste Position, die ein gesuchtes Zeichen enthält, zurückgegeben wird oder die erste Position, die kein gesuchtes Zeichen enthält. Der Rückgabewert gibt die gefundene Position an oder entspricht der Zeichenkettenlänge plus 1, wenn die Suche erfolglos war. Die Startposition wird wenn nötig auf die Stringgrenzen justiert.
strscanprior - Zeichen in Zeichenkette rückwärts suchen (STD)
Synopsis
int strscanprior( // Match Position
string; // Zeichenkette
string; // Suchzeichenkette
int; // Startposition
int; // Stop-on-match Flag:
// 0 = Continue-on-match
// 1 = Stop-on-match
);
Beschreibung
Die Funktion
strscanprior sucht in der übergebenen Zeichenkette ab der Startposition absteigend nach Zeichen, die in der Suchzeichenkette aufgeführt sind. Das Suchflag gibt an, ob die erste Position, die ein gesuchtes Zeichen enthält, zurückgegeben wird oder die erste Position, die kein gesuchtes Zeichen enthält. Der Rückgabewert gibt die gefundene Position an oder Null wenn die Suche erfolglos war. Die Startposition wird wenn nötig auf die Stringgrenzen justiert.
strset - Zeichenkette mit Zeichen füllen (STD)
Synopsis
void strset(
& string; // Ein-/Ausgabezeichenkette
char; // Füllzeichen
);
Beschreibung
Die Funktion
strset ersetzt alle Zeichen der übergebenen Zeichenkette mit dem Füllzeichen.
strspn - Zeichenkette Länge bis Endmuster ermitteln (STD)
Synopsis
int strspn( // Mismatch Position
string; // Eingabezeichenkette
string; // Suchzeichenkette
);
Beschreibung
Der Rückgabewert der Funktion
strspn entspricht der Anzahl der Zeichen am Beginn der Eingabezeichenkette die in der übergebenen Suchzeichenkette vorhanden sind.
strupper - Zeichenkette in Großbuchstaben umwandeln (STD)
Synopsis
void strupper(
& string; // Ein-/Ausgabezeichenkette
);
Beschreibung
Die Funktion
strupper wandelt die in der übergebenen Zeichenkette vorhandenen Buchstaben in Großbuchstaben um.
syngetintpar - BNF/Scanner Integerparameter abfragen (STD)
Synopsis
int syngetintpar( // Status
int [0,[; // Parametertyp/-nummer:
// 0 = String-Kontrollzeichenauswertungsmodus
// 1 = Callback-Funktion für Kommentartexte aktivieren
// 2 = Flag - beliebige Identifierzeichen
& int; // Rückgabe Parameterwert
);
Beschreibung
Die Funktion
syngetintpar dient der Abfrage von mit
synsetintpar im
User Language-BNF-/Syntaxscanner gesetzten Integerparametern. Der Funktionsrückgabewert ist Null bei erfolgreicher Abfrage oder (-1) im Fehlerfall.
Siehe auch
Funktionen synparsefile,
synparseincfile,
synparsestring,
synsetintpar.
synparsefile - BNF/Parser Datei einlesen (STD)
Synopsis
synparsefile( // Scan Status
string; // Eingabedateiname
[]; // Optionale Callback-Funktion für Kommentare
);
Beschreibung
Die Funktion
synparsefile aktiviert einen Parser zur Abarbeitung der durch Dateinamen spezifizierten Eingabedatei. Dabei erfolgt die Abarbeitung entsprechend der im
User Language-Programm festgelegten BNF-Beschreibung des Eingabedatenformats. Nach Bedarf werden automatisch die in der BNF definierten Aktionen bzw. Anwenderfunktionen ausgelöst. Innerhalb dieser Anwenderfunktionen kann mit
synscanline die aktuelle Zeilennummer der Eingabedatei und mit
synscanstring die aktuell eingelesene Zeichenkette ermittelt werden, wobei die aktuelle Zeichenkette nach Bedarf auch einer semantischen Prüfung unterzogen werden kann. Die Funktion
synparsefile wird beendet, sobald das Ende der Eingabedatei erreicht ist oder ein Syntaxfehler bzw. ein durch eine Anwenderfunktion erkannter semantischer Fehler aufgetreten ist.
Callback-Funktion für Kommentare
Über den zweiten Funktionsparameter kann eine Callback-Funktion für Kommentartexte spezifiziert werden.
Diese Callback-Funktion wird aktiviert, wenn zusätzlich der entsprechende Parameter über die Funktion
synsetintpar gesetzt wurde.
Die Callback-Funktion ist wie folgt zu definieren.
int commentfuncname(
string commentstring, // Kommentartext ohne Kommentarbegrenzer
)
{
// Verarbeitungsprogramm
:
return(stat);
}
Der Parserlauf wird abgebrochen, wenn die Callback-Funktion einen Wert ungleich Null zurückgibt. Andernfalls wird er Parserlauf forstgesetzt.
Diagnose
Die möglichen Rückgabewerte der Funktion
synparsefile haben folgende Bedeutung:
| Rückgabewert | Bedeutung |
0 | Parserlauf fehlerfrei beendet |
1 | Keine BNF-Definition verfügbar |
2 | Parser (synparsefile) ist bereits aktiv |
3 | Datei kann nicht geöffnet werden |
4 | Zu viele offene Dateien |
5 | Fataler Schreib-/Lesefehler |
6 | Scanelement zu lang |
7 | Syntaxfehler |
8 | Unerwartetes Dateiende |
9 | Stacküberlauf (BNF zu komplex) |
10 | Stackunterlauf (BNF fehlerhaft) |
11 | Fehler von Parser-Aktion/referenzierter Funktion |
Siehe auch
Funktionen
syngetintpar,
synparseincfile,
synparsestring,
synscaneoln,
synscanigncase,
synscanline,
synscanstring,
synsetintpar, sowie Kapitel 2.6.4 dieses Handbuchs.
synparseincfile - BNF/Parser Includedatei einlesen (STD)
Synopsis
int synparseincfile( // Status
string; // Includedateiname
);
Beschreibung
Mit der Parser-Funktion
synparseincfile wird die Bearbeitung einer eingebundenen Datei (Includedatei) aktiviert, d.h. der Parser setzt bei Aufruf dieser Funktion den Einlesevorgang unmittelbar am Beginn der namentlich spezifizierten Includedatei fort. Sobald das Ende der Includedatei erreicht ist, wird das Terminalsymbol
EOFINC als erkannt gemeldet, und der Einlesevorgang wird and der in der übergeordneten Datei unterbrochenen Stelle fortgesetzt. Der Rückgabewert von
synparseincfile ist Null, wenn kein Fehler festgestellt wurde, (-1) wenn die Includedatei nicht geöffnet werden konnte, oder (-2) wenn der Parser, d.h. die Funktion
synparsefile nicht aktiv ist.
Warnung
Bei Verwendung der Funktion
synparseincfile ist eine entsprechende Einbindung des Terminalsymbols
EOFINC in die BNF-Definition erforderlich, da der Parser sonst immer einen Syntaxfehler meldet, sobald das Ende der Includedatei erreicht ist.
Siehe auch
Funktionen
syngetintpar,
synparsefile,
synparsestring,
synscaneoln,
synscanigncase,
synscanline,
synscanstring,
synsetintpar, sowie Kapitel 2.6.4 dieses Handbuchs.
synparsestring - BNF/Parser Zeichenkette einlesen (STD)
Synopsis
synparsestring( // Scan Status
string; // Eingabestring
[]; // Optionale Callback-Funktion für Kommentare
);
Beschreibung
Die Funktion
synparsestring aktiviert einen Parser zur Abarbeitung der übergebenen Zeichenkette. Dabei erfolgt die Abarbeitung entsprechend der im
User Language-Programm festgelegten BNF-Beschreibung des Eingabedatenformats. Nach Bedarf werden automatisch die in der BNF definierten Aktionen bzw. Anwenderfunktionen ausgelöst. Innerhalb dieser Anwenderfunktionen kann mit
synscanline die aktuelle Zeilennummer der Eingabedatei und mit
synscanstring die aktuell eingelesene Zeichenkette ermittelt werden, wobei die aktuelle Zeichenkette nach Bedarf auch einer semantischen Prüfung unterzogen werden kann. Die Funktion
synparsestring wird beendet, sobald das Ende der abzuarbeitenden Zeichenkette erreicht ist oder ein Syntaxfehler bzw. ein durch eine Anwenderfunktion erkannter semantischer Fehler aufgetreten ist.
Callback-Funktion für Kommentare
Über den zweiten Funktionsparameter kann eine Callback-Funktion für Kommentartexte spezifiziert werden.
Diese Callback-Funktion wird aktiviert, wenn zusätzlich der entsprechende Parameter über die Funktion
synsetintpar gesetzt wurde.
Die Callback-Funktion ist wie folgt zu definieren.
int commentfuncname(
string commentstring, // Kommentartext ohne Kommentarbegrenzer
)
{
// Verarbeitungsprogramm
:
return(stat);
}
Der Parserlauf wird abgebrochen, wenn die Callback-Funktion einen Wert ungleich Null zurückgibt. Andernfalls wird er Parserlauf forstgesetzt.
Diagnose
Die möglichen Rückgabewerte der Funktion
synparsestring haben folgende Bedeutung:
| Rückgabewert | Bedeutung |
0 | Parserlauf fehlerfrei beendet |
1 | Keine BNF-Definition verfügbar |
2 | Parser (synparsestring) ist bereits aktiv |
3 | Datei kann nicht geöffnet werden |
4 | Zu viele offene Dateien |
5 | Fataler Schreib-/Lesefehler |
6 | Scanelement zu lang |
7 | Syntaxfehler |
8 | Unerwartetes Ende der Zeichenkette |
9 | Stacküberlauf (BNF zu komplex) |
10 | Stackunterlauf (BNF fehlerhaft) |
11 | Fehler von Parser-Aktion/referenzierter Funktion |
Siehe auch
Funktionen
syngetintpar,
synparsefile,
synparseincfile,
synscaneoln,
synscanigncase,
synscanline,
synscanstring,
synsetintpar, sowie Kapitel 2.6.4 dieses Handbuchs.
synscaneoln - BNF/Scanner Zeilenendeerkennung setzen (STD)
Synopsis
int synscaneoln( // Status
int [0,1]; // Scanner Zeilenendeerkennung Modus:
// 0 = Deaktivieren EOLN-Erkennung
// 1 = Aktivieren EOLN-Erkennung
);
Beschreibung
Mit der Funktion
synscaneoln kann die Zeilenendeerkennung des durch
synparsefile aktivierbaren BNF-Parsers wahlweise aktiviert oder deaktiviert werden. Per Default ist die Zeilenendeerkennung deaktiviert. Der Rückgabewert der Funktion ist ungleich Null bei Spezifikation ungültiger Parameter.
Warnung
Die Verwendung des Terminalsymbols
EOLN in der BNF-Definition ist nur zulässig bzw. sinnvoll, wenn für die Dateibearbeitung auch die Zeilenendeerkennung aktiviert ist.
Siehe auch
Funktionen
synparsefile,
synparseincfile,
synparsestring,
synscanigncase,
synscanline,
synscanstring, sowie Kapitel 2.6.4 dieses Handbuchs.
synscanigncase - BNF/Scanner Schlüsselworterkennungsmodus setzen (STD)
Synopsis
int synscanigncase( // Status
int [0,1]; // Scanner Schlüsselworterkennungsmodus:
// 0 = Groß-/Kleinschreibung unterscheiden
// 1 = Groß-/Kleinschreibung ignorieren
);
Beschreibung
Mit der Funktion
synscanigncase kann die Unterscheidung zwischen Groß- und Kleinschreibung beim Einlesen von Schlüsselwörtern in dem durch
synparsefile aktivierten BNF-Parser wahlweise deaktiviert oder aktiviert werden. Per Default unterscheidet der Parser zwischen Groß- und Kleinschreibung. Der Rückgabewert der Funktion ist ungleich Null bei Spezifikation ungültiger Parameter.
Siehe auch
Funktionen
synparsefile,
synparseincfile,
synparsestring,
synscaneoln,
synscanline,
synscanstring, sowie Kapitel 2.6.4 dieses Handbuchs.
synscanline - BNF/Scanner Eingabezeilennummer abfragen (STD)
Synopsis
int synscanline( // Eingabezeilennummer
);
Beschreibung
Der Rückgabewert der Funktion
synscanline ist die Nummer der aktuell während des durch
synparsefile aktivierten Parservorgangs eingelesene Eingabedateizeile.
Siehe auch
Funktionen
synparsefile,
synparseincfile,
synparsestring,
synscaneoln,
synscanigncase,
synscanstring, sowie Kapitel 2.6.4 dieses Handbuchs.
synscanstring - BNF/Scanner Eingabestring abfragen (STD)
Synopsis
string synscanstring( // Scanner-Eingabestring
);
Beschreibung
Der Rückgabewert der Funktion
synscanstring ist die zuletzt während des durch
synparsefile aktivierten Parservorgangs eingelesene Zeichenkette.
Siehe auch
Funktionen
synparsefile,
synparseincfile,
synparsestring,
synscaneoln,
synscanigncase,
synscanline, sowie Kapitel 2.6.4 dieses Handbuchs.
synsetintpar - BNF/Scanner Integerparameter setzen (STD)
Synopsis
int synsetintpar( // Status
int [0,[; // Parametertyp/-nummer:
// 0 = String-Kontrollzeichenauswertungsmodus
// 1 = Callback-Funktion für Kommentartexte aktivieren
// 2 = Flag - beliebige Identifierzeichen
int; // Parameterwert
);
Beschreibung
Die Funktion
synsetintpar dient dazu, Systemparameter vom Typ im
int im
User Language-BNF-/Syntaxscanner zu setzen. Der Funktionsrückgabewert ist Null bei erfolgreicher Parameterzuweisung oder (-1) im Fehlerfall. Die Werte von mit
synsetintpar gesetzten Systemparametern können mit der Funktion
syngetintpar abgefragt werden.
Siehe auch
Funktionen syngetintpar,
synparsefile,
synparseincfile,
synparsestring.
system - Betriebssystemkommando absetzen und Ausführung abwarten (STD)
Synopsis
int system( // Status
string; // Kommando
);
Beschreibung
Die Funktion
system aktiviert das als Zeichenkette übergebene Kommando auf Betriebssystemebene.
Das Kommando bzw. der Programmaufruf wird an den Kommandointerpreter des Betriebssystems, d.h. an die Betriebssystemshell übergeben, und die Ablaufkontrolle wird erst nach Ausführung des Kommandos wieder an BAE zurückgegeben. Der Rückgabewert der Funktion ergibt sich zu dem vom Betriebssystem, dem Kommandointerpreter bzw. dem aufgerufenen Programm zurückgegebenen Status. Ein Wert von Null deutet dabei in der Regel auf eine fehlerfreie Ausführung hin, während andere Werte üblicherweise Fehler oder Warnungen kennzeichnen.
Einschränkungen
Die Funktion
system kann nicht in der
BAE Demo-Software angewendet werden.
Unter MS-DOS benötigt der Phar Lap DOS-Extender ausreichend konventionellen Speicher zur Ausführung von (Child-)Prozessen. Die Größe des zur Verfügung stehenden konventionellen Speichers wird mit den Optionen
-MINREAL und
-MAXREAL des Phar Lap DOS Extenders festgelegt. Zur Ausführung von
User Language-Programmen, die die
system-Funktion benutzen, sind die
User Language-Interpreterumgebungen mit Hilfe des mit der BAE-Software ausgelieferten CFIG386-Tools von Phar Lap wie folgt umzukonfigurieren:
> cfig386 <EXEFILE> -maxreal 0ffffh
Für
<EXEFILE> ist jeweils der Name des
User Language Interpreters
(scm.exe,
ged.exe,
neurrut.exe,
cam.exe,
gerview.exe bzw.
ced.exe) einzusetzen.
Warnungen
Beachten Sie, dass die
system-Funktion grundlegende Mehrprozess- bzw. Multitasking-Techniken voraussetzt, die auf PC-basierenden Systemen u.U. nicht ausreichend unterstützt werden, oder die in Rechnernetzwerken (abhängig vom auszuführenden Kommando) Probleme bereiten können.
Es wird dringend empfohlen, die Standardausgabe von DOS-Kommandos auf temporäre Dateien umzulenken und zur Anzeige eine
User Language-Funktion zur Dateibetrachtung zu verwenden, da andernfalls die BAE-Grafikoberfläche von der Standardausgabe der mit
system abgesetzten DOS-Kommandos überschrieben wird.
Die Fehlerausgabe von DOS-Kommandos erfolgt grundsätzlich auf den Bildschirm, wodurch die BAE-Grafikoberfläche überschrieben wird. Da unter DOS prinzipiell keine Möglichkeit zur Umlenkung der Fehlerausgabe besteht, ist dieses Problem nur dadurch zu umgehen, dass z.B. durch eine Konsistenzprüfung vor dem Aufruf der
system-Funktion die Aktivierung fehlerhafter DOS-Kommandos unterdrückt wird.
Da von der BAE-Grafikoberfläche keine Benutzereingaben an DOS-Kommandos übergeben werden können, ist dringend davon abzuraten, interaktive DOS-Kommandos bzw. Grafikapplikationen mit der
system-Funktion abzusetzen (andernfalls "hängt sich das System auf"). Unter UNIX lässt sich dieses Problem u.U. dadurch umgehen, dass interaktive Kommandos wie z.B.
more oder
vi in Hintergrundprozessen (&) aktiviert werden (was allerdings im Remote Login zu Problemen beim Terminalzugriff führen kann).
Siehe auch
Funktion
launch.
tan - Tangens berechnen (STD)
Synopsis
double tan( // Berechnungsergebnis
double; // Winkelwert (STD3)
);
Beschreibung
Der Rückgabewert der Funktion
tan entspricht dem Tangens des übergebenen Winkels. Der übergebene Gleitkommawert wird als Bogenmaßangabe interpretiert.
tanh - Hyperbolischen Tangens berechnen (STD)
Synopsis
double tanh( // Berechnungsergebnis
double; // Winkelwert (STD3)
);
Beschreibung
Der Rückgabewert der Funktion
tanh entspricht dem hyperbolischen Tangens des übergebenen Winkels. Der übergebene Gleitkommawert wird als Bogenmaßangabe interpretiert.
tolower - Zeichen in Kleinbuchstaben umwandeln (STD)
Synopsis
char tolower( // Ausgabezeichen
char; // Eingabezeichen
);
Beschreibung
Der Rückgabewert der Funktion
tolower ist der Großbuchstabe zu dem übergebenen Eingabezeichen. Bei Eingabezeichen, die keinen Buchstaben darstellen, wird der Eingabewert unverändert zurückgegeben.
toupper - Zeichen in Großbuchstaben umwandeln (STD)
Synopsis
char toupper( // Ausgabezeichen
char; // Eingabezeichen
);
Beschreibung
Der Rückgabewert der Funktion
toupper ist der Kleinbuchstabe zu dem übergebenen Eingabezeichen. Bei Eingabezeichen, die keinen Buchstaben darstellen, wird der Eingabewert unverändert zurückgegeben.
uliptype - User Language Interpreterumgebung abfragen (STD)
Synopsis
int uliptype( // Interpretertyp:
// 0x0000 = Ungültig/unbekannt
// 0x0080 = SCM - Schaltplaneditor
// 0x0040 = GED - Layouteditor
// 0x0010 = AR - Autorouter
// 0x0008 = CAM - CAM-Prozessor
// 0x0004 = CED - Chipeditor
// 0x1000 = CV - CAM-View
);
Beschreibung
Die Funktion
uliptype gibt den Typ des aktuell aktiven
User Language Interpreter zurück.
ulipversion - User Language Interpreter Version abfragen (STD)
Synopsis
int ulipversion( // Interpreterversion
);
Beschreibung
Die Funktion
ulipversion gibt die interne Versionsnummer des aktuellen
User Language Interpreter zurück.
ulproginfo - User Language-Programminfo abfragen (STD)
Synopsis
int ulproginfo( // Status
string; // Programmname
& int; // Programmversion
& int; // Programmaufruftyp
);
Beschreibung
Die Funktion
ulproginfo ermittelt die Version und die zulässigen Interpreterumgebungen des angegebenen
User Language-Programms. Die Programmversion ist dabei die interne Versionsnummer des zur Kompilierung verwendeten
User Language Compilers. Der Programmaufruftyp ist ein bit-maskierter Wert, über den sich die zur Programmausführung berechtigten
User Language-Interpreterumgebungen abfragen lassen. Diese Angaben werden benötigt, um mit Hilfe der
ulip*-Funktionen zu entscheiden, ob ein spezielles
User Language-Programm in der aktuell aktiven Interpreterumgebung ablauffähig ist. Der Rückgabewert der Funktion ist ungleich Null, wenn das angegebene Programm nicht gefunden wurde.
Siehe auch
Funktionen
uliptype,
ulipversion.
ulsystem - User Language-Programm aufrufen (STD)
Synopsis
int ulsystem( // Status
string; // Programmname
& int; // Programmzähler
);
Beschreibung
Die Funktion
ulsystem startet das angegebene
User Language-Programm. Ein Rückgabewert ungleich Null gibt an, dass bei dem Laden oder Abarbeiten des Programmes ein Fehler aufgetreten ist. In dem Parameter Programmzähler wird im Fehlerfall die Adresse der zuletzt ausgeführten Anweisung des
User Language=Programmes zurückgegeben (siehe Einträge in dem vom Compiler erzeugten Listingfile).
Diagnose
Die möglichen Rückgabewerte der Funktion
ulsystem haben folgende Bedeutung:
| Rückgabewert | Bedeutung |
0 | Programmlauf fehlerfrei beendet |
1 | DDB/Datenbank-Zugriffsfehler |
2 | Programm bereits geladen |
3 | Programm nicht gefunden |
4 | Inkompatible User Language Programm Version |
5 | Inkompatible Index-/Funktions-Referenzen |
6 | Stack Unterlauf |
7 | Stack Überlauf |
8 | Division durch Null |
9 | Fehler bei System-Funktions-Aufruf |
10 | System-Funktion nicht verfügbar |
11 | System-Funktion nicht implementiert |
12 | Anwender-Funktion nicht gefunden |
13 | Ungültiger Datentyp für referenzierte Funktion |
14 | Ungültige Parameterliste für referenzierte Funktion |
15 | Fehler beim Array-Zugriff |
16 | Ungültiger Array-Index |
17 | Allgemeiner Dateizugriffsfehler |
18 | Allgemeiner Dateilesefehler |
19 | Allgemeiner Dateischreibfehler |
Siehe auch
Funktion ulsystem_exit.
ulsystem_exit - User Language-Programm nach Beendigung des aktuellen User Language-Programms aufrufen (STD)
Synopsis
void ulsystem_exit(
string; // Programmname
);
Beschreibung
Die Funktion
ulsystem startet das angegebene
User Language-Programm nach Beendigung des aktuellen
User Language-Programms.
Siehe auch
Funktionen exit,
ulsystem.
vardelete - Globale User Language-Variable löschen (STD)
Synopsis
int vardelete( // Status
string; // Variablenname
);
Beschreibung
Mit der Funktion
vardelete kann eine zuvor mit
varset definierte globale
User Language-Variable gelöscht werden. Der Funktionsrückgabewert ist Null, wenn der Löschvorgang erfolgreich war oder (-1) wenn keine globale
User Language-Variable mit dem spezifizierten Variablennamen definiert ist.
Siehe auch
Funktionen
varget,
varset.
varget - Globale User Language-Variable abfragen (STD)
Synopsis
int varget( // Status
string; // Variablenname
& void; // Variablenwert
);
Beschreibung
Mit der Funktion
varget kann der Wert einer zuvor mit
varset definierten globalen
User Language-Variablen ermittelt werden. Der Funktionsrückgabewert ist Null, wenn die Abfrage erfolgreich war, (-1) wenn keine globale
User Language-Variable mit dem spezifizierten Variablennamen definiert ist oder
(-2) wenn der Datentyp des Parameters für die Rückgabe des Variablenwertes nicht kompatibel zum aktuell definierten Datentyp der Variable ist.
Siehe auch
Funktionen
vardelete,
varset.
varset - Globale User Language-Variable setzen (STD)
Synopsis
int varset( // Status
string; // Variablenname
void; // Variablenwert
);
Beschreibung
Die Funktion
varset definiert eine globale
User Language-Variable mit dem angegebenen Variablennamen und ordnet dieser Variable den spezifizierten Variablenwert zu. Der Variablenwert muss einen Basisdatentyp
(int,
double,
char oder
string) repräsentieren, d.h. es sind keine komplexen bzw. zusammengesetzten Datentypen wie etwa Arrays, Strukturen oder
index-Typen zulässig. Der Funktionsrückgabewert ist Null bei erfolgreicher Variablendefinition, (-1) bei ungültigem Variablennamen oder (-2) bei unzulässigem Datentyp für den Variablenwert. Eine mit
varset definierte Variable bleibt auch nach Beendigung des aktuell aktiven
User Language-Programms definiert bis sie mit der Funktion
vardelete wieder gelöscht werden oder bis das aktuell aktive BAE-Programm-Modul verlassen wird. Mit der Funktion
varget können die Werte der mit
varset definierten Variablen abgefragt werden. Da die mit
varset definierten globalen Variablen auch nach Beendigung des definierenden
User Language-Programms erhalten bleiben, ist über diese Variablen ein Datenaustausch zwischen zeitlich unabhängig voneinander ablaufenden
User Language-Programmen möglich.
Siehe auch
Funktionen
vardelete,
varget.
Standard-Systemfunktionen
© 1985-2024 Oliver Bartels F+E • Aktualisiert: 19. October 2013, 08:37 [UTC]
|
