Willkommen bei Bartels
Standard-Systemfunktionen - Deutsche Version Standard System Functions - English Version
Bartels

Bartels System GmbH
Bartels
Bartels AutoEngineer
BAE Produktinfo
BAE Preisliste
BAE Downloads
BAE Dokumentation
BAE Installationsanleitung
BAE Benutzerhandbuch
BAE Bibliotheken
User Language Programmierhandbuch
Vorwort
1 Einleitung
2 Sprachbeschreibung
3 Programmiersystem
4 BAE User Language-Programme
A Konventionen und Definitionen
B Index-Variablen-Typen
C Systemfunktionen
C.1 Funktionsübersicht
C.2 Standard-Systemfunktionen
C.3 SCM-Systemfunktionen
C.4 PCB-Design-Systemfunktionen
C.5 IC-Design-Systemfunktionen
BAE Update-Historie
BAE Nächste Version Freigabemitteilungen Vorabinfo
BAE V8.0 Freigabemitteilungen
BAE V7.8 Freigabemitteilungen
BAE V7.6 Freigabemitteilungen
BAE V7.4 Freigabemitteilungen
BAE V7.2 Freigabemitteilungen
BAE V7.0 Freigabemitteilungen
BAE V6.8 Freigabemitteilungen
BAE V6.6 Freigabemitteilungen
BAE V6.4 Freigabemitteilungen
BAE V6.2 Freigabemitteilungen
BAE V6.0 Freigabemitteilungen
BAE V5.4 Freigabemitteilungen
BAE V5.0 Freigabemitteilungen
BAE V4.6 Freigabemitteilungen
BAE V4.4 Freigabemitteilungen
BAE V4.2 Freigabemitteilungen
BAE V4.0 Freigabemitteilungen
BAE V3.4 Freigabemitteilungen
BAE Support
BAE Contrib
BAE Entwickler und Dienstleister
Elektronikentwicklung
Sport
Firmenprofil
Impressum
Bartels :: Bartels AutoEngineer :: BAE Dokumentation :: User Language Programmierhandbuch :: Systemfunktionen :: Standard-Systemfunktionen
Bartels User Language - Programmierhandbuch

C.2 Standard-Systemfunktionen

Bartels AutoEngineer® Dokumentation

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 (Sprung relativ) oder Absolutkoordinaten (Sprung absolut) 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 Oeffnen der Button Speichern 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 Oeffnen der Button Speichern 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 OK, oder 
                              //    (-1) bei Betätigung von Abbruch 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 OK-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 Abbruch 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 OK, oder 
                              //    (-1) bei Betätigung von Abbruch 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 OK-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 Abbruch 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. Backannotation 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 Weiteres Fenster 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 Sprung relativ 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 Sprung relativ 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 Undo 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 OK). 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 Ja und zu Null bei Eingabe bzw. Selektion von Nein. 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 Speichern unter 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 Speichern unter 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 (OK) und zum Abbruch (Abbruch) der Texteingabe. Im Dialog für die mehrzeilige Texteingabe werden außerdem Schaltflächen zum Laden des Inhalts einer selektierbaren Datei (Laden) und zum Speichern des aktuell editierten Texts in eine Ausgabedatei (Speichern) angeboten. Der Rückgabewert dieser Funktion entspricht der vom Benutzer editierten Zeichenkette wenn die Eingabe mit OK bestätigt wurde. Dabei ist die eingebbare maximale Länge der Antwortzeichenkette durch den entsprechenden Funktionsparameter festgelegt. Bei Betätigung von Abbruch 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 Weiteres Fenster 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 Ablegen auf Namen, d.h. falls in eine andere Datei geschrieben wird, muss gegebenenfalls Update Bibliothek 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 Kein Wert 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 Undo/Redo-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 Undo/Redo-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 Undo/Redo-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:

ZeichenAusgabedatentyp
dDezimal-Darstellung
oOktal-Darstellung
xHexadezimal-Darstellung (Kleinschreibung)
XHexadezimal-Darstellung (Großschreibung)
uVorzeichenlose Dezimal-Darstellung
cZeichen
sZeichenkette
eFließkomma-Darstellung (Kleinschreibung)
EFließkomma-Darstellung (Großschreibung)
fFestkomma-Darstellung
ge oder f, jeweils kürzere Darstellungsform
GE 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):

ZeichenAusgabeformat
- 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 Return-/Eingabetaste (CR)

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üsselwortDatentyp
integerGanze 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)
booleanLogical 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:

OperatorDatentyp
+ 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 Undo/Redo-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:

FehlercodeBedeutung
0SQL-Kommando fehlerfrei ausgeführt
1SQL-Kommando Lesefehler (intern)
2SQL-Kommando zu komplex (über 200 Terme)
3Ungültiger numerischer Ausdruck
4SQL-Kommandodatei nicht gefunden (intern)
5SQL-Kommandoelement zu lang (über 200 Zeichen)
6SQL-Kommando Syntaxfehler bei <c>
7Allgemeiner SQL-Kommando-Parserfehler
8Fehler beim Erzeugen der Datenbank
9Dateizugriffsfehler
10Zu viele offene Dateien
11Datei <d> ist keine Datenbank
12Datenbankstruktur beschädigt
13Datenbankdateiaufbau fehlerhaft
14Schlüsselbegriff <k> nicht gefunden
15Schlüsselbegriff <k> existiert bereits
16Datei <d> nicht gefunden
17Ungültiger Datentyp für Tabellenelement <t>.<f>
18Zu viele Tabellenelemente
19Dateneintrag zu lang
20Bedingte Löschung nur für eine Tabelle erlaubt
21Term/Vergleich enthält unzulässige Typkombination
22Ausgabefeld <f> undefiniert/in keiner Tabelle
23Ausgabefeld <f> in mehreren Tabellen definiert
24Ausgabetabelle <t> nicht in from-Tabellenliste
25Tabelle <t> bereits definiert
26Datenbankklassenanzahl überschreitet Datenbanklimit
27Tabelle <t> nicht gefunden
28Fehler von Datenrückgabefunktion
29Kein delete-Record gefunden
30Unbekanntes/neueres Datenbankformat
31Abfragefeld nicht in Tabelle(n) enthalten
32Abfragefeld in mehreren Tabellen enthalten
33Dateilesezugriff verweigert
34Dateischreibzugriff verweigert
35Allgemeiner 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ückgabewertBedeutung
0Parserlauf fehlerfrei beendet
1Keine BNF-Definition verfügbar
2Parser (synparsefile) ist bereits aktiv
3Datei kann nicht geöffnet werden
4Zu viele offene Dateien
5Fataler Schreib-/Lesefehler
6Scanelement zu lang
7Syntaxfehler
8Unerwartetes Dateiende
9Stacküberlauf (BNF zu komplex)
10Stackunterlauf (BNF fehlerhaft)
11Fehler 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ückgabewertBedeutung
0Parserlauf fehlerfrei beendet
1Keine BNF-Definition verfügbar
2Parser (synparsestring) ist bereits aktiv
3Datei kann nicht geöffnet werden
4Zu viele offene Dateien
5Fataler Schreib-/Lesefehler
6Scanelement zu lang
7Syntaxfehler
8Unerwartetes Ende der Zeichenkette
9Stacküberlauf (BNF zu komplex)
10Stackunterlauf (BNF fehlerhaft)
11Fehler 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 Return-/Eingabetaste (CR)

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ückgabewertBedeutung
0Programmlauf fehlerfrei beendet
1DDB/Datenbank-Zugriffsfehler
2Programm bereits geladen
3Programm nicht gefunden
4Inkompatible User Language Programm Version
5Inkompatible Index-/Funktions-Referenzen
6Stack Unterlauf
7Stack Überlauf
8Division durch Null
9Fehler bei System-Funktions-Aufruf
10System-Funktion nicht verfügbar
11System-Funktion nicht implementiert
12Anwender-Funktion nicht gefunden
13Ungültiger Datentyp für referenzierte Funktion
14Ungültige Parameterliste für referenzierte Funktion
15Fehler beim Array-Zugriff
16Ungültiger Array-Index
17Allgemeiner Dateizugriffsfehler
18Allgemeiner Dateilesefehler
19Allgemeiner 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.
Bartels :: Bartels AutoEngineer :: BAE Dokumentation :: User Language Programmierhandbuch :: Systemfunktionen :: Standard-Systemfunktionen

Standard-Systemfunktionen
© 1985-2017 Oliver Bartels F+E • Aktualisiert: 19. October 2013, 08:37 [UTC]

© 1985-2017 Oliver Bartels F+E Bartels Startseite Kontakt und Impressum

Webentwicklung Baumeister Mediasoft Engineering

Standard-Systemfunktionen - Deutsche Version Standard System Functions - English Version