Bartels User Language - Programmierhandbuch Anhang C Systemfunktionen

Inhalt

C.1.1

Standard Systemfunktionen (STD)

C.1.2

Schematic Capture Systemfunktionen (CAP)

C.1.3

Schematic Editor Systemfunktionen (SCM)

C.1.4

Layout Systemfunktionen (LAY)

C.1.5

Layouteditor Systemfunktionen (GED)

C.1.6

Autorouter Systemfunktionen (AR)

C.1.7

CAM-Prozessor Systemfunktionen (CAM)

C.1.8

CAM-View Systemfunktionen (CV)

C.1.9

IC Design Systemfunktionen (ICD)

C.1.10

Chip Editor Systemfunktionen (CED)

C.3.1

Schaltplan-Datenzugriffsfunktionen

C.3.2

Schaltplaneditor-Funktionen

C.4.1

Layout-Datenzugriffsfunktionen

C.4.2

Layouteditor-Funktionen

C.4.3

Autorouter-Funktionen

C.4.4

CAM-Prozessor-Funktionen

C.4.5

CAM-View-Funktionen

C.5.1

IC-Design-Datenzugriffsfunktionen

C.5.2

Chipeditor-Funktionen

C.1 Funktionsübersicht

Jede in der Bartels User Language definierte Systemfunktion ist genau einem der Aufruftypen STD, CAP, LAY, SCM, GED, AR, CAM, CV, ICD oder CED zugeordnet. Dieser Abschnitt enthält eine Übersicht über die zum jeweiligen Aufruftyp definierten Systemfunktionen.

Konventionen zur Funktionsbeschreibung

Für in den nachfolgenden Kapiteln dieses Anhangs beschriebene Funktion ist der zu dieser Funktion definierte Aufruftyp sowie eine formale Deklaration der Funktion und ihrer Parameter angegeben. Mit dem Datentyp der Systemfunktion ist auch der jeweilige Datentyp des zugehörigen Rückgabewertes definiert; ist der Datentyp einer Funktion void, dann gibt diese Funktion keinen Wert an den Aufrufer zurück. Wo nötig wird die Arbeitsweise einer Funktion durch nähere Angaben erläutert bzw. durch Beispiele veranschaulicht.

Bei der Deklaration der Parameter wird wenn nötig ein Wertebereich angegeben. Die Angabe erfolgt dabei mit unterer und oberer Grenze des Parameterbereichs. Für die untere Grenze sind folgende Angaben möglich:

Für die obere Grenze sind entsprechend folgende Angaben möglich:

Die Wertebereichsgrenzen werden durch , getrennt. Die Parameterdeklaration

double ]0.0,[;

gibt z.B. an, dass der Parameter vom Datentyp double und größer als 0.0 sein muss. Dem User Language Compiler sind die so definierten Parameterwertebereiche bekannt; er gibt ggf. eine Fehlermeldung aus, wenn er erkennt, dass ein Parameterwert außerhalb des gültigen Wertebereichs liegt.

Ist einem Parameter das Zeichen & vorangestellt, dann bedeutet dies, dass der Wert dieses Parameters durch die Systemfunktion gesetzt bzw. verändert wird. Dem User Language Compiler ist diese Parametereigenschaft bekannt; er gibt ggf. eine Warnmeldung aus, wenn er erkennt, dass ein konstanter Wert oder ein Berechnungsergebnis an einen solchen Parameter übergeben wird.

Ist einem Parameter das Zeichen * vorangestellt, dann handelt es sich bei diesem Parameter um die Referenz auf eine Anwenderfunktion; in diesem Fall wird zusätzlich die vorgeschriebene Deklaration dieser Anwenderfunktion mit aufgeführt. Die Systemfunktion aktiviert von sich aus die entsprechende Anwenderfunktion, sofern diese im User Language-Programm definiert ist. Unter Umständen ist die Referenzierung von Anwenderfunktionen optional; wenn in diesem Fall eine entsprechende Anwenderfunktion nicht aktiviert werden soll, dann ist für den entsprechenden Parameter das Schlüsselwort NULL einzutragen. Bei der Deklaration referenzierter Anwenderfunktionen sollte mit größter Sorgfalt vorgegangen werden, da erst zur Laufzeit (also durch den User Language Interpreter) festgestellt werden kann, ob die Konventionen hinsichtlich des Datentyps und der Parameterdeklarationen für die Anwenderfunktion eingehalten wurden (ist dies nicht der Fall, dann kommt es zu einem Laufzeitfehler); auch das Setzen des Rückgabewertes der referenzierten Anwenderfunktion sollte unbedingt entsprechend den vorgegebenen Konventionen erfolgen, da sich sonst u.U. fatale Nebeneffekte ergeben, die man auf Anhieb gar nicht erkennen (geschweige denn abfangen) kann.

Einen weiteren Spezialfall für die Parameter von Systemfunktionen stellt schließlich der Datentyp void dar, der angibt, dass der betreffende Parameter von einem beliebigen Datentyp sein kann. Die Spezifikation des Parametertyps [] schließlich gibt an, dass die Funktion an dieser Stelle optional eine beliebige Anzahl von Parametern vom Datentyp void erwartet.

C.1.1 Standard Systemfunktionen (STD)

Die nachfolgend aufgelisteten Systemfunktionen sind dem Aufruftyp STD zugeordnet, d.h. diese Funktionen können in allen definierten Interpreterumgebungen aufgerufen werden:

C.1.2 Schematic Capture Systemfunktionen (CAP)

Die nachfolgend aufgelisteten Systemfunktionen sind dem Aufruftyp CAP zugeordnet, d.h. diese Funktionen können im Schaltplaneditor aufgerufen werden:

C.1.3 Schematic Editor Systemfunktionen (SCM)

Die nachfolgend aufgelisteten Systemfunktionen sind dem Aufruftyp SCM zugeordnet, d.h. diese Funktionen können im Schaltplaneditor aufgerufen werden:

C.1.4 Layout Systemfunktionen (LAY)

Die nachfolgend aufgelisteten Systemfunktionen sind dem Aufruftyp LAY zugeordnet, d.h. diese Funktionen können im Layouteditor, im Autorouter und im CAM-Prozessor aufgerufen werden:

C.1.5 Layouteditor Systemfunktionen (GED)

Die nachfolgend aufgelisteten Systemfunktionen sind dem Aufruftyp GED zugeordnet, d.h. diese Funktionen können im Layouteditor aufgerufen werden:

C.1.6 Autorouter Systemfunktionen (AR)

Die nachfolgend aufgelisteten Systemfunktionen sind dem Aufruftyp AR zugeordnet, d.h. diese Funktionen können im Autorouter aufgerufen werden:

C.1.7 CAM-Prozessor Systemfunktionen (CAM)

Die nachfolgend aufgelisteten Systemfunktionen sind dem Aufruftyp CAM zugeordnet, d.h. diese Funktionen können im CAM-Prozessor aufgerufen werden:

C.1.8 CAM-View Systemfunktionen (CV)

Die nachfolgend aufgelisteten Systemfunktionen sind dem Aufruftyp CV zugeordnet, d.h. diese Funktionen können im CAM-View-Modul aufgerufen werden:

C.1.9 IC Design Systemfunktionen (ICD)

Die nachfolgend aufgelisteten Systemfunktionen sind dem Aufruftyp ICD zugeordnet, d.h. diese Funktionen können im Chipeditor aufgerufen werden:

C.1.10 Chip Editor Systemfunktionen (CED)

Die nachfolgend aufgelisteten Systemfunktionen sind dem Aufruftyp CED zugeordnet, d.h. diese Funktionen können im Chipeditor aufgerufen werden:

C.2 Standard-Systemfunktionen

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)

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.