Array erstellen / verwenden
Auskommentieren von Zeilen im Sourcecode
Bilder anzeigen
Buttons und Bilder als Button verwenden
CPU Auslastung ermitteln
Datei Zeilenweise auslesen
Datum ermitteln und verwenden
CSV Dateien auslesen
Dateiname des laufenden Programms ermitteln
Ermittlung des Standortes Ihres Programmverzeichnisses im System
Fenstermenü erstellen
Fenster in Bildschirmmitte anzeigen
Fenster ohne TAB anzeigen
Fenstergrößenoption "Zoom" im TAB deaktivieren
Fenstergrößenoption "Resize" vom Fenster deaktivieren
Fenstergröße nur in eine Richtung ändern lassen
Import / Export Funktion
Kontrollausgabe von Werten und Texten
Leerzeichen entfernen bei Ausgabe eines Strings
Lokalisierung - Programm in anderen Sprachen anbieten (Zeta)
Maus abfragen
People Datei erstellen
Shell Tools verwenden
Strings in YAB bearbeiten
Strings mit Leerzeichen verwenden
Subroutine - Programmcodes an mehren Stellen verwenden
Sound abspielen
Systeminformationen ermitteln
Tastatur abfragen
Text in die Mitte eines Views setzen
Textcontrol auslesen und in Textdatei speichern
Treebox erstellen
Tooltips erstellen
Uhrzeit ermitteln und verwenden
Vorhandensein eines Ordners oder Datei ermitteln
Vorhandensein eines Ordners oder Datei ermitteln (Variante 2)
Stichwortverzeichnis
Array erstellen / verwenden
Ein Array ist eine Sammlung von verschiedenen Werten in einer Variablen. Die Werte die Sie in das Array speichern können wiederum aus Variablen bestehen.
Ein Stringarray (Strings sind Zeichenketten) erstellen Sie wie folgt:
dim Name_des_Arrays$(2)
Zuerst dimensionieren Sie das Array mit dem Befehl dim Name_des_Arrays$(2) . Dieses Array hat den Namen Name_des_Arrays$.
Das Dollarzeichen hinter den Namen bewirkt, dass das Array nur Strings (Zeichenketten) enthält. Mit der 2 in Klammer (2) geben Sie an wie Groß das Array sein soll, d.h. wie viele Werte sie in dem Array speichern wollen.
Um nun die Werte bzw. Variablen dem Array zuzuweisen gehen Sie wie folgt vor:
Name_des_Arrays$(0)="Inhalt1"
Name_des_Arrays$(1)="Inhalt2"
oder wenn Sie Variablen zuweisen möchten
Name_des_Arrays$(0)=Inhalt1$
Name_des_Arrays$(1)=Inhalt2$Sie schreiben zuerst den Namen des Arrays Name_des_Arrays$, dahinter kommt in Klammern, die Nummer des ersten, zweiten.... (0) Eintrags.
Die Besonderheit bei der Zählweise ist, das man bei 0 Anfängt und nicht wie man es gewohnt ist bei 1. Mit dem Gleichheitszeichen übergeben Sie die Werte an das Array.
Wenn Sie nun Strings an das Array übergeben möchten, müssen Sie diese Strings in Anführungszeichen setzen "Inhalt1".
Möchten Sie lieber Variablen an das Array übergeben, so schreiben Sie hinter dem Gleichheitszeichen den Variablennamen.
 |
Denken Sie daran dass Sie nur Stringvariablen in einem Stringarray speichern können. Möchten Sie eine Zahlvariable in einem Stringarray speichern, so müssen diese vorher mit der Funktion str$() konvertieren. |
Das gleiche können Sie auch mit Numero Variablen machen, indem Sie überall das Dollarzeichen weglassen. Bedenken Sie dabei dass Sie in nur Zahlen im Array speichern können.
Wenn Sie versuchen Texte in einem Numero Array zu speichern, so ergibt es Fehler in der Programmausführung.
Ein Array lesen sie wie folgt aus:
Sie schreiben z.b.
draw text 5, 38, ""+Name_des_Arrays$(0), "View1"Mit dem Befehl draw text geben Sie einen Text an bestimmten Koordinaten auf dem Bildschirm aus (hier 5, 38). Dahinter kommt eigentlich in den Anführungszeichen ein Text (Sie können hier zusätzlich auch noch etwas eingeben). Hinter dem Text kommt ein +, somit weiß YAB, das hinter dem String "" noch etwas kommt. Hier kommt nun das Array zum Einsatz.
Es wird der Name_des_Arrays notiert und in den Klammern (0) dahinter den Eintrag des Arrays. Hier ist es der Eintrag Null und somit der erste Wert in dem Array.
Wenn Sie zum Beispiel ein Array mit 10 dimensoniert haben und mönnen den fünften Wert ausgeben, so müssen Sie Name_des_Arrays(4) schreiben.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Bild anzeigen
Das anzeigen eines Bildes ist eine einfache Sache.
Ein Bild fügen Sie wie folgt ein:
err = draw image 10,20 to 100, 120,"Pfad und Name des Bildes", "View"
Mit err = draw image 10,20 to 100, 120, geben wir an, daß wir eine Bilddatei anzeigen möchten, welche 10 Pixel vom linken Rand und 20 Pixel vom oberen Rand beginnt und 100 Pixel vom linken Rand und 120 Pixel vom oberen Rand endet.
Sie müssen nicht die Endpositionen des Bildes angeben, dazu brauchen Sie hier nur jeweils eine -1 angeben, oder lassen den Bereich to 100, 120 weg.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Buttons und Bilder als Button verwenden
Ein Button ist eine Schaltfläche, über welche man eine Funktion im Programm aufrufen kann. Dies kann beispielsweise das speichern einer Texteingabe sein, oder das öffnen eines neuen Fensters.
Ein Button fügen Sie wie folgt ein:
button 50, 30 to 150, 60, "Name des Buttons", "Angezeigter Name des Buttons", "View"
Mit button 50,30 to 150, 60, geben wir einen Button an, der bei 50 Pixel von der linken Außenkante (Programmfenster) und 30 Pixel von der Oberkante beginnt. Der Button geht dann 100 Pixel nach rechts, also auf 150 Pixel und 30 Pixel nach unten, also auf 60 Pixel.
Bei "Name des Buttons" geben Sie einen Namen an, über welchen Sie diesen im Programmcode ansprechen möchten. Der Name kommt dann zwischen die Ausrufezeichen und kann dann z.B. über eine case Abfrage verwendet werden.
Bei "Angezeigter Name des Buttons" tragen Sie den Namen ein, welcher der Button im Programm haben soll. Auch hier muss; der Name zwischen den Ausrufezeichen stehen.
Mit "View" geben Sie an, in welcher Ansicht der Button angezeigt werden soll. Heißt Ihre Ansicht z.B. MainView oder Peter, muss dieser Name dort angegeben werden.
Buttons und Bilder als Button verwenden
Es gibt auch die Möglichkeit, Grafiken als Button zu nutzen. Der Programmcode sieht wie folgt dafür aus:
button image 50,100, "Name des Buttons", "Bild 2", " Bild 1", " ", "View"
Wie beim normalen Button geben wir mit button 50, 100 die Startpunkte, ausgehend von der linken und oberen Außenkante des Programmfensters, an. Unterschied ist, daß es nicht nötig ist die untere und rechte Kante anzugeben, da diese von der Grafik vorgegeben ist.
Bei "Name des Buttons" geben Sie auch hier einen Namen an, über welchen Sie diesen im Programmcode ansprechen möchten.
Bei "Bild 2" gebe Sie die zweite Grafik für Ihren Button an und bei "Bild 1" die erste. Nun fragen Sie sich sicherlich warum zwei Bilder? Das verwenden von zwei Bildern ermöglicht ein dynamisches aussehen des Buttons. Dies könnte zum Beispiel so aussehen, dass der Button im Ruhezustand (Bild 1) oben ist und im gedrückten Zustand (Bild 2) unten. Möchten Sie nur eine Grafik verwenden, dann geben Sie einfach bei beiden Positionen dieselbe Grafik an.
Auch hier gebne Sie mit "View" an, in welcher Ansicht der Button angezeigt werden soll.
Ausführen eines Buttons Beispiel: case Abfrage
Um nun Ihre Buttons zu verwenden, fügen Sie in ihre Mailloop folgende case Abfrage ein:
case "Name des Buttons|":
Hier der Programmcode
break
Bei "Name des Buttons|" geben Sie den Namen an, welchen Sie für den Button, zur Verwendung im Programmcode, angegeben haben.
Bei Hier der Programmcode fügen Sie den Programmcode ein, welcher beim betätigen des Buttons ausgeführt werden soll.
Mit break wird die case Abfrage beendet.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Ermitteln der CPU- Auslastung
Beitrag von René Passier Oktober 2010
Nachdem das Ermitteln verschiedener Systeminformationen, siehe Systeminformationen ermitteln, an und für sich kein großes Problem mehr darstellt, hier nun eine weitere kleine Routine mit welcher es möglich ist, die aktuelle CPU- Auslastung zu ermitteln.
Passenderweise trägt die neue "Sub" den Namen _GetCPUUtilization und erledigt auch genau diese Aufgabe.
export sub _GetCPUUtilization()
// Variablen definieren
local SystemInput$
local NumberOfTokens
local Line$
dim Lines$(1) dim Position$(1)
// den Befehl "TOP" ausführen und Ausgabe in SystemInput$ speichern
SystemInput$ = system$("top -d -n 1 -i 1")
// SystemInput$ in einzelne Zeilen zerlegen
NumberOfTokens = token(SystemInput$, Lines$(), chr$(10))
// aus der letzten Zeile die gewünschte Information extrahieren
NumberOfTokens = token(Lines$(NumberOfTokens), Position$(), chr$(32))
// Ergebnis zurückliefern
return val(Position$(5))
end subDer Aufruf der Sub- Routine erfolgt dabei ohne Parameterübergabe, in der Form:
Variable = _GetCPUUtilization()
oder:
print _GetCPUUtilization()
Der dabei ausgegebene Wert entspricht der aktuellen CPU- Auslastung in % und wird als Gleitkommazahl zurückgegeben.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Datei Zeilenweise auslesen
Die Einträge in der Datei, die ausgelesen werden soll, müssen untereinander geschrieben sein.
Der Code zum zeilenweise Auslesen einer Datei sieht wie folgt aus:
fileload$="/boot/home/auslesen.txt" auslesen=open(fileload$, "r") while (not EOF(auslesen)) x=x+1 dim d$(x) line input #auslesen b$ d$(x)=b$ wend close(auslesen) draw text 5, 38, "Eintrag 1: "+d$(1), "View1" draw text 5, 58, "Eintrag 2: "+d$(2), "View1" draw text 5, 78, "Eintrag 3: "+d$(3), "View1"
Als erstes wird eine Variable fileload$ erzeugt, welche den Standort der auszulesenden Datei beinhaltet.
Da das Programm momentan nicht weiß, wie die auszulesende Datei heißt, müssen wir für diese eine weitere Variable vergeben. Diese wird hier als auslesen bezeichnet. Diese Datei wird dann über den Befehl open(fileload$, "r") geöffnet. Dabei geben wir die Variable an in der die auszulesende Datei gespeichert ist. Mit der der Angabe "r", sagen wir dem Open- Befehl, das diese Datei zum "lesen" (read) geöffnet wird.
Hiernach wird eine while Schleife geöffnet mit dem Zusatz, das in der Datei vom Anfang bis zum Ende gelesen werden soll (EOF = End of File).
Über x=x+1 wird die Größe des Arrays ermittelt. Hierbei wird bei jedem Durchlauf der Schleife, der Werk x um einen erhöht. Man kann es so verstehen, dass hier ermittelt wird, wie viele Zeilen die Datei hat.
Mit dim d$(x) erstellen wir ein Array, in dem die vorher ermittelten Daten gespeichert werden.
Durch line input #auslesen b$ lesen wir nun die Einträge der Datei aus und speichern diese in die Variable b$.
Nun werden die Variable b$ in den Array d$(x) eingebunden. Das bedeutet, das wir nun in dem Array d$ nicht nur die Zeilennummer, sondern auch den Zeileneintrag gespeichert haben.
Mit wend gehen wir an den Anfang der Schleife zurück.
Jetzt könne wir die Ausgelesenen Daten ausgeben, indem wir zum Beispiel einen draw text erstellen und in diese Textausgabe den Array mit einbinden. Mit "Eintrag 1: "+d$(1) fügen wir hinter der Textausgabe "Eintrag 1: ", das ausgelesene Wort aus der ersten Zeile des Array d$ ein.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Datum ermitteln und verwenden
Das Datum zu ermitteln ist eine ganz einfache Sache, da yab dafür eine feste Variable besitzt, die diese beim Aufrufen ausgibt.
Die Variable heißt date$ und kann wie jede andere Variable intrigiert werden.
Darstellung: Monat-Tag-Jahr
Wer nur einen Teil der Ausgabe verwenden oder diese anderes Darstellen möchte, kann diese Variable aufrufen und in einem Array dimensionieren. Dann den Inhalt des Array Splitten und deren Ergebnis neuen Variablen zuweisen:
dim CurrentDate$(1) time = split(date$, CurrentDate$(), "-") Monat$ = CurrentDate$(2) Tag$ = CurrentDate$(3) Jahr$ = CurrentDate$(4)
Wir dimensionieren den Array CurrentDate$(1) mit dem Mindestwert 1.
Dann Splitten wir die Variable date$ an jedem Bindestich (-) und fügen das Ergebnis in den Array CurrentDate$() ein.
Danach weisen wir die ermittelten Daten neuen Variablen zu, den Monat in die Variable Monat$, den Tag in die Variable Tag$ und das Jahr in die Variable Jahr$. Werte die Sie nicht benötigen, können sie natürlich auch weglassen.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Auskommentieren von Zeilen im Sourcecode
Das Auskommentieren von Zeilen ist eine sehr praktische Sache, denn zum einen muss man so nicht immer gleich Programmkodes, die nicht gleich so funktionieren wie man es gerne hätte entfernen sondern man kann parallel dazu andere Variationen ausprobieren. Außerdem kann man mit auskommentierten Zeilen seine Programmteilbereiche Dokumentieren.
Es gibt zwei Zeichen, die ein Auskommentieren bezeichnen:
# Text oder Programmcode REM # Text oder Programmcode // Text oder Programmcode
Das Zeichen # funktioniert nur außerhalb eines Loops, sollte man dieses Zeichen auch dort verwenden wollen, muss diesem ein REM vorgesetzt werden.
Das Zeichen // funktioniert in allen Programmkode Bereichen.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
CSV Dateien auslesen
Die Einträge in der Datei, die ausgelesen werden sollen, müssen mit dem ";" getrennt sein. Hinter dem letzten Eintrag braucht kein Semikolon stehen.
Der Code zum Auslesen einer CSV-Datei sieht wie folgt aus:
d=0sub laden(d) fileload$="taballe.csv" auslesen=open(fileload$, "r") x=0 while (not EOF(auslesen)) line input #auslesen b$ dim elements$(1) numElements = split(b$, elements$(),";") for i = 1 to numElements x=x+1 dim d$(x) d$(x) = elements$(i) next i wend close(auslesen) draw text 5, 38, "Eintrag 1: "+d$(1), "View1" draw text 5, 58, "Eintrag 2: "+d$(2), "View1" draw text 5, 78, "Eintrag 3: "+d$(3), "View1" end sub
Wir rufen eine Subroutine (laden) auf und übergeben ihr die Variable d mit dem Wert 0. Das übergeben dieser Variablen ist wichtig, da sonst die Subroutine die Werte bei jedem neuen Aufruf der Subroutine an das Ausgabearray anhängen und es nicht aktualisieren würde.
Nachdem wir die Subroutine aufgerufen haben wird eine Variable fileload$ erzeugt, welche den Standort der auszulesenden Datei beinhaltet.
Da das Programm momentan nicht weiß wie die auszulesende Datei heißt, müssen wir für diese eine weitere Variable (Die Variable ist der Filehandle) vergeben. Diese wird hier als auslesen bezeichnet. Diese Datei wird dann über den Befehl open(fileload$, "r") geöffnet. Dabei geben wir die Variable an in der die auszulesende Datei gespeichert ist. Mit der der Angabe "r", sagen wir dem Open- Befehl, das diese Datei zum "lesen" (read) geöffnet wird.
Dann wird eine Zählervariable (x) erstellt. Diese hat den Wert 0.
Hiernach wird eine while Schleife geöffnet mit dem Zusatz, das in der Datei vom Anfang bis zum Ende gelesen werden soll (EOF = End of File).
Durch line input #auslesen b$ lesen wir nun die Einträge der Datei aus und speichern diese in die Variable b$. Wir erzeugen danach ein Array elements$ mit der Größe 1.
Mit numElements = split(b$, elements$();";") wird nun jeder Eintrag in dem Array elements$ und die Anzahl der Einträge in der Variablen numElements gespeichert.
Die nächste Schleife dient dazu, die Werte in ein Array d$ für die Ausgabe zu speichern. Die Schleife läuft solange bis sie den Wert von numElements erreicht hat. In der Schleife wird über x=x+1 die Größe des Arrays ermittelt. Hierbei wird bei jedem Durchlauf der Schleife, der Werk x um einen erhöht
Mit dim d$(x) erstellen wir ein Array, in dem die vorher ermittelten Daten gespeichert werden.
Nun wird aus dem Array elements$ jeder Eintrag in das Array d$(x) gespeichert.
Mit wend gehen wir an den Anfang der Schleife zurück
Jetzt können wir die ausgelesenen Daten ausgeben, indem wir zum Beispiel einen draw text erstellen und in diese Textausgabe den Array mit einbinden. Mit "Eintrag 1: "+d$(1) fügen wir hinter der Textausgabe "Eintrag 1: ", das ausgelesene Wort aus der ersten Zeile des Array d$ ein. Zu guter letzt wird nun noch die Subroutine beendet.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Dateiname des laufenden Programms ermitteln
Beitrag von René Passier Oktober 2010
Manchmal kann es notwendig und hilfreich sein, den Namen des eigenen Programms zur Laufzeit herauszufinden. Leider bietet yab dafür keine Funktion an. Dennoch ist es möglich dies mit yab zu lösen. In folgende, kleine Routine übernimmt diese Arbeit für uns.
Der Befehl "ps" gibt uns, richtig benutzt, alle Informationen die wir benötigen um den Namen des Programms herauszufinden. Ruft man nun im Terminal den Befehl "ps -a" auf erscheint eine mehr oder weniger lange Liste mit allen laufenden Programmen und Tasks. Aus diesem Wust an Informationen müssen wir nun die gewünschte Information herausfiltern. Die Liste sieht dabei so, oder ähnlich, aus:
Der Code zum Auslesen einer CSV-Datei sieht wie folgt aus:
... --------------------------------------------------------------------------- Team Id #Threads Gid Uid /boot/system/apps/Terminal 184 4 0 0 Thread Id State Prio UTime KTime Terminal 184 wait 10 40 529 PtyReader 189 wait 10 1 22 EscParse 190 wait 15 3 11 w>Terminal 1 191 wait 15 154 753 --------------------------------------------------------------------------- Team Id #Threads Gid Uid /bin/bash --login 188 1 0 0 Thread Id State Prio UTime KTime bash 188 wait 10 139 837 --------------------------------------------------------------------------- ...
Zuerst suchen wir uns aus der Liste den Namen unseres Fenster (z.B. "Terminal 1"). Fenster- Titel sind dabei immer mit "w>" am Anfang gekennzeichnet. Haben wir nun diese Zeile gefunden, lesen wir in der Liste rückwärts bis zur Zeile "Thread". Ist auch diese gefunden, steht unmittelbar in der nächsten Zeile der Name der Applikation, in diesem Fall "Terminal". Dieser muß nun noch ausgelesen werden und fertig.
Ein paar Einschränkungen gibt es bei dieser Vorgehensweise allerdings doch. Ein Programm- Name darf nicht länger als 31 Zeichen sein, da er sonst, an dieser Stelle in der Liste abgeschnitten wird, sprich, der "ps"- Befehl gibt nur die ersten 31 Zeichen eines Programm- Namens aus.
Folgende Sub- Routine übernimmt die beschrieben Arbeit und wird folgendermaßen aufgerufen, als Parameter muß der Titel des Fensters übergeben werden:
_GetApplicationFilename($FenterTitel) REM--------------------------------------------------------------------------------------------------- REM Autor: René Passier REM Datum: August 2010 REM Name: _GetApplicationFilename$ REM Funktion: Ermittelt den Dateinamen des laufenden Programms durch Übergabe des Fenster- Titels. REM Parameter: WindowTitle$ REM ---------------------------------------------------------------------------------------------------- export sub _GetApplicationFilename$(WindowTitle$) REM variablen definieren REM ------------------------------------------------------------------------------------------------ local SystemInput$ // speichert die Ausgabe von system$ local NumberOfTokens // enthält die Anzahl gefilterter Zeilen aus SystemInput$ local Counter // Hilfsvariable für die FOR- Schleifen local LineFound // speichert die Zeile in der der Fenster- Titel gefunden wurde local AppFilename$ // speichert den Datei- Name des laufenden Programms dim SystemLines$(1) // speichert die einzelnen, gefilterten Zeilen aus system$ REM Liste aller Threads mit Hilfe des Befehls "ps -a " einlesen. REM ------------------------------------------------------------------------------------------------ SystemInput$ = system$("ps -a") REM Den Inhalt aus SystemInput$ in einzelne Zeilen zerlegen (chr$(10) = Line Feed) REM und die Anzahl der erhaltenen Zeilen in NumberOfTokens speichern. REM ------------------------------------------------------------------------------------------------ NumberOfTokens = token(SystemInput$, SystemLines$(), chr$(10)) REM Alle, in SystemLines$() gespeicherten Zeilen nach dem Fenster- Titel durchsuchen. REM Vor dem Fenster- Titel muß "w>" angehängt werden, da "ps" dies so zurückliefert. REM ------------------------------------------------------------------------------------------------ for Counter = 0 to NumberOfTokens if instr(SystemLines$(Counter), "w>" + WindowTitle$) then REM Fenster- Titel gefunden REM ---------------------------------------------------------------------------------------- LineFound = Counter break // Schleife beenden und nicht mehr weiter suchen endif next Counter REM Jetzt von der ermittelten Position rückwärts den Eintrag "Thread" suchen. REM ------------------------------------------------------------------------------------------------ for Counter = LineFound to 0 step - 1 if instr(SystemLines$(Counter), "Thread") then REM "Thread" gefunden REM ---------------------------------------------------------------------------------------- AppFilename$ = SystemLines$(Counter + 1) // in der Zeile nach "Thread" steht der //zu suchende Datei- Name AppFilename$ = left$(AppFilename$, 32) // nur die ersten 32 Zeichen lesen, da der // nicht benötigt wird und "ps" nur maximal // 31 Zeichen zurückliefert AppFilename$ = ltrim$(AppFilename$) // alle eventuellen Leerzeichen links ent- // fernen AppFilename$ = rtrim$(AppFilename$) // alle eventuellen Leerzeichen rechts ent- // fernen break // Schleife abbrechen endif next Counter REM Den ermittelten Datei- Namen zurückgeben. REM ------------------------------------------------------------------------------------------------ return AppFilename$ end sub
Zusätzlich kann mit dem Beispiel "Ermittlung des Standortes Ihres Programmverzeichnisses im System", aus der "yab Programmierhilfe" noch der Pfad zur Applikation ermittelt werden. Kombiniert man Beides, bekommt man sowohl den Pfad als auch den Namen der Applikation und kann diese Informationen beliebig weiter verwenden.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Ermittlung des Standortes Ihres Programmverzeichnisses im System
Um zu ermitteln, an welchen Standort im System der Benutzer Ihr Programm installiert hat, ermitteln wir Über den Befehl "pwd" (Print working directory) wo sich Ihr Programmordner befindet. Diesen Dateipfad speichern wir in eine Variable mit dem Namen "WorkDir$". Diese Variable lässt sich dann einfach an den Stellen einbinden, an welchen der Dateipfad zu einer Datei oder Standort wichtig ist (z.B. eine Grafik).
Fügen Sie dazu folgenden Code am Anfang Ihres Programmcodes ein:
if (peek("isbound")) then WorkDir$ = peek$("directory") else WorkDir$ = system$("pwd") WorkDir$ = left$(ThisDir$, len(ThisDir$)-1) fi
Beispiel zur Verwendung der Variablen.
Wir nehmen mal an Sie haben ein Verzeichnis für Grafiken in Ihrem Programmordner mit dem Namen "Grafik", aus diesem Ordner möchten Sie gerne die Grafik "Logo.png" bestimmen und anzeigen. Erstellen Sie den Code so wie sie es gewohnt sind eine Grafik einzubinden und geben Sie beim Dateipfad für die Grafik das oder die Verzeichnisse an, ausgehend von dem Programmordner, zu der anzuzeigenden Grafik. Dies wäre also "/grafik/Logo.png". Nun fügen Sie vor diesen Pfad die Variable WorkDir$ein und schreiben zwischen Variable und dem Pfad ein "+", damit der gespeicherte Pfad aus der Variablen mit dem dahinterstehenden Pfad verbunden wird.
err = draw image 90,35, WorkDir$+"/grafik/Logo.png", "MainView"
 |
Wichtig! Diese Angabe sollten Sie erst am Ende ihrer Arbeit an ihrem Programm einfügen, da diese nur im Gebundenen Zustand funktioniert. |
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Fenstermenü erstellen
Das einrichten eines Fenstermenüs ist einfach. Hierzu geben Sie folgenden Code für jeden Menüeintrag ein:
menu "File", "Open", "O", "View"
Mit dem Befehl "menu" wird die Menüleiste aktiviert.
Die erste Namensangabe ("File"") ist der Name des Menüs.
Die zweite Namensangabe ("Open"") ist die Bezeichnung des ersten Menüeintrages im Bereich "File".
Die dritte Angabe ("O"") ist die Angabe für ein Tastaturkürzel in Verbindung mit der Alt Taste. Hier also "Alt + O" für "Open".
Mit der letzen Angabe, wird die Ansicht ( "View"") angegeben, in welcher das Menü angezeigt wird. Hierbei ist zu beachten, dass Sie den obersten "View" verwenden. Wenn Sie also in der Hauptansicht eine View erzeugen, welche am Punkt 0 der linken und oberen Kante beginnt, muss das Menü hier eingebaut werden, da dieses sonst nicht angezeigt wird.
Submenu erstellen
Es ist auch möglich ein Untermenüpunkt (Submenu) zu erstellen, also eine Menüauswahl in einer Menüauswahl.
Dies sieht wie folgt aus:
submenu "Datei", "Speichern", "Speichern als", "SA", "View"
Der Aufbau ist im Grunde genauso wie der des normalen Fenstermenüs, der Unterschied ist nur eine weitere Angabe eines Menüpunktes.
Im Beispiel erzeugen wir ein Untermenü "Speichern" im Fenstermenüpunkt " Datei. Im Untermenüpunkt Speichern, definieren wir den Menüpunkt Speichern als.
Funktion zuweisen
Wenn Sie jetzt einem Menüpunkt eine Funktion zuweisen möchten, beziehen Sie die Ausführung auf den Namen des Menübereiches (hier "Speichern als").
In einer "case" Abfrage würde das dann so aussehen:
case "Name des Menüpunktes|": Hier der Programmcode break
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Fenster in Bildschirmmitte platzieren
Um ein Fenster in Bildschirmmitte zu platzieren, müssen Sie zuerst herausfinden, wie groß die Bildschirmauflösung ist.
Um dies zu erfahren, platzieren Sie folgenden Code am Anfang ihres Programmcodes (vor den Loop). Wieso so weit oben? Nun auf diese Weise können Sie jederzeit an jeder beliebigen Stelle im Programmcode, diese ermittelten Werte, für die Platzierung von Fenstern heranziehen.
ScreenWidth = peek("desktopwidth") ScreenHeight = peek("desktopheight")
Über peek("desktopwidth") ermitteln Sie die Breite der Bildschirmauflösung und speichern diese in der Variable ScreenWidth.
Über peek("desktopheight") ermitteln Sie die Höhe der Bildschirmauflösung und speichern diese in die Variable ScreenHeight.
Nachdem sie diese Werte ermittelt haben, können Sie diese in die Größenangabe ihres Programmfensters intrigieren.
window open ((ScreenWidth/2)-300), (( ScreenHeight/2)-300) to ((ScreenWidth /2)+300), ((ScreenHeight/2) +300), "Angezeigter Name des Views", "View"
Die Angabe für das Fenster öffnen weicht etwas von dem normalen Code ab. Dies liegt daran, dass in den Angaben für die Start und Endposition des Fensters noch neue Werte ermittelt werden müssen.
Wir öffnen wie gewohnt ein neues Fenster mit window open. Da der nächste Wert ermittelt wird und daher nicht nur die Positionszahl angegeben wird, muss dieser in Klammern gesetzt werden. Hier wird der Wert der ermittelten Bildschirmbreite durch zwei geteilt (ScreenWidth/2), damit wir die Mitte des Bildschirmes erfahren. Außerdem reduzieren wir den neu ermittelten Wert um die Zahl, die die Mitte des gewünschten Fensters ergibt. Wenn Sie also ein Fenster mit einer Breite von 600 Pixeln haben möchten, muss der Wert um 300 Pixel reduziert werden um den linken Rand des Fensters anzugeben ((ScreenWidth/2)-300).
Dasselbe wird daraufhin mit der Fensterhöhe durchgeführt, um den oberen Rand des Fensters zu ermitteln. Hier gehen wir auch davon aus, dass das Programm eine Fensterhöhe von 600 Pixeln haben soll.
Genauso wie bei dem normalen Fensterangaben folgt das to und die Angaben für den rechten und unteren Rand des Fensters, die genauso ermittelt werden, wie zuvor die anderen. Einzige Ausnahme ist, dass Sie diesmal nicht die 300 Pixel abziehen, sondern draufzählen müssen ((ScreenWidth/2)+300), (( ScreenHeight/2)+300).
Der Rest ist wie gehabt, bei "Angezeigter Name des Views" kommt der Name rein, welchen das Fenster haben soll und bei "View" der Name des View, den Sie intern im Programmcode dazu verwenden, diesen anzusprechen.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Fenster ohne TAB anzeigen
Ab und an sieht es besser aus, wenn das neu geöffnete Fenster keinen TAB besitzt. Dies kann zum Beispiel dann sein, wenn Sie über ein kleines Fenster eine Statusanzeige einbringen möchten.
Dies einzustellen ist sehr einfach, fügen Sie dazu einfach folgenden Code zu den Fenstereinstellungen hinzu: window open 175,250 to 525,450 , "Interner Viewname", "Angezeigter Viewname"
window set ***
window set "View", "Look", "modal"
Mit window set geben wir an, dass wir eine Einstellung (Setting) für das Fenster vornehmen möchten. Die Angabe "View" definiert den internen Namen des Fensters. Mit "Look", geben wir an, dass wir etwas an dem Aussehen verändern möchten und dass der nächste Wert eine Einstellung des Aussehens darstellt. Durch die Angabe modal, wird das Fenster ohne TAB dargestellt.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Fenstergrößenoption Zoom im TAB deaktivieren
Ein Fenster kann bekanntlich über die beiden Desktopdarstellungen im TAB auf minimal- oder Vollbildgröße eingestellt werden. Wenn man eine feste Fenstergröße verwenden möchte und eine solche Funktion dadurch nicht ausgeführt werden kann, macht es Sinn, diese Schaltfläche im TAB zu deaktivieren. window open 175,250 to 525,450 , "Interner Viewname", "Angezeigter Viewname"
window set ***
window set "View", "flags", "not-zoomable"
Mit window set geben wir an, dass wir eine Einstellung (Setting) für das Fenster vornehmen möchten. Die Angabe "View" definiert den internen Namen des Fensters. Mit "flags", geben wir an, dass wir etwas an den Fensteroptionen verändern möchten und dass der nächste Wert die zu ändernde Option ist. Durch die Angabe not-zoomable, wird die Zoomfunktion des Fensters deaktiviert, wodurch automatisch das dazugehörige Symbol aus dem TAB verschwindet.
 |
Wenn man mehrere Fensteroptionen auf einmal ändern möchte, kann man diese einfach hintereinander, getrennt durch ein Komma eintragen. Dies macht zum Beispiel Sinn, wenn Sie auch die Resize Option des Fensters deaktivieren möchten. |
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Fenstergrößenoption "Resize" vom Fenster deaktivieren
Durch die Resize Funktion am unteren Rand des Fensters, ist es möglich, dass Fenster auf eine gewünschte Größe zu verkleinern, bzw. zu vergrößern. Verwendet man eine feste, nicht zum verändern vorgesehenes Fenstergröße, so ist es schon aus optischen Gründen schöner, diese Option zu deaktivieren. window open 175,250 to 525,450 , "Interner Viewname", "Angezeigter Viewname"
window set ***
window set "View", "flags", "not-resizable"
Mit window set geben wir an, dass wir eine Einstellung (Setting) für das Fenster vornehmen möchten. Die Angabe "View" definiert den internen Namen des Fensters. Mit "flags", geben wir an, dass wir etwas an den Fensteroptionen verändern möchten und dass der nächste Wert die zu ändernde Option ist. Durch die Angabe not-resizable, wird die Resize- Funktion des Fensters deaktiviert, wodurch automatisch die dazugehörige Schaltfläche deaktiviert wird.
|
Unter Umständen kann es dazu kommen, das daß deaktivieren der Resize Option auf diese weise nicht funktioniert (der Fall bei älteren yab Versionen). Sollte dies so sein, so ersetzen sie "not-resizable" durch "not-h-resizable, not-v-resizable". Dadurch deaktivieren sie die horizontale und die vertikale Resize Möglichkeit. |
|
Wenn man mehrere Fensteroptionen auf einmal ändern möchte, kann man diese einfach hintereinander, getrennt durch ein Komma eintragen. Dies macht zum Beispiel Sinn, wenn Sie auch die Zoom Option vom TAB deaktivieren möchten. |
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Fenstergröße nur in eine Richtung ändern lassen
Möchten Sie Ihr Fenster so konfigurieren, dass der Benutzer nur in eine Richtung die Fenstergröße verändern kann?
window open 175,250 to 525,450 , "Interner Viewname", "Angezeigter Viewname"
window set ***
window set "View", "flags", "not-h-resizable"
Mit window set geben wir an, dass wir eine Einstellung (Setting) für das Fenster vornehmen möchten. Die Angabe "View" definiert den internen Namen des Fensters. Mit "flags", geben wir an, dass wir etwas an den Fensteroptionen verändern möchten und dass der nächste Wert die zu ändernde Option ist. Durch die Angabe not-h-resizable, wird die horizontale Resize- Funktion des Fensters deaktiviert. Dadurch kann das Fenster nur noch in vertikaler Richtung verändert werden.
window set "View", "flags", "not-v-resizable"
Mit window set geben wir an, dass wir eine Einstellung (Setting) für das Fenster vornehmen möchten. Die Angabe "View" definiert den internen Namen des Fensters. Mit "flags", geben wir an, dass wir etwas an den Fensteroptionen verändern möchten und dass der nächste Wert die zu ändernde Option ist. Durch die Angabe not-v-resizable, wird die vertikale Resize- Funktion des Fensters deaktiviert. Dadurch kann das Fenster nur noch in horizontaler Richtung verändert werden.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
left$
Der Befehl left$() liefert den linken Teil eines Strings zurück. Der Befehl left$() benötigt zwei Informationen, den String der bearbeitet werden soll und eine Zahl. Die Zahl gibt an wieviele Zeichen vom String zurückgeben werden sollen.
print left$("Dies ist der Beispielstring",9)
a$="Dies ist der Beispielstring"
print left$(a$,9)
In der oberen Zeile des grauen Kastens geben sie einen Teil des Strings über den Print Befehl aus. Das Ergebnis sieht so aus:
Dies ist
Im unteren Teil des grauen Fenster geben Sie auch einen Teil eines Strings aus, der aber in einer Variablen gespeichert ist. Das Ergebnis ist identisch mit den oberen. Nur das Sie den Vorteil haben, den String variabel zu halten.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Leerzeichen entfernen bei Ausgabe eines Strings
Sollte nach dem Auslesen einer Datei ein oder mehre Leerzeichen vor und/oder hinter einer Ausgabe eines Strings sein, kann man diese mit yab- internen Befehlen entfernen.
Dazu bedienen wir uns den Befehlen: trim$(), ltrim$(), rtrim$()
Mit trim$() entfernt man alle Leerzeichen die sich vor und hinter dem Stringeintrag befinden:
trim$(Stringname$)
Mit ltrim$() entfernt man alle Leerzeichen die sich vor (links) dem Stringeintrag befinden:
ltrim$(Stringname$)
Mit rtrim$() entfernt man alle Leerzeichen die sich hinter (rechts) dem Stringeintrag befinden:
rltrim$(Stringname$)
Beispiel:
Stringname$=" Hallo Haiku "
rltrim$(Stringname$)
print Stringname$
Ausgabe="Hallo Haiku "
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Lokalisieren (Zeta)
Wenn Sie ihr Programm lokalisieren möchten, also die Möglichkeit geben möchten das andere Ihr Programm übersetzen, dann fügen Sie folgenden Befehl in Ihre Programm ein. Positionieren sie diesen Befehl im oberen Bereich des Programms.
Localize
Mit dem einfachen Befehl "Localize", werden einige Namen vom System automatisch über das LocalKit übersetzt (z.B. Quit in Beenden. oder Help in Hilfe).
Um eine vollständige Übersetzung zu erhalten, müssen Sie jedoch "Dictionary" Dateien erstellen. Dies sind Textdateien, in denen einmal die im Programm benutzen Wörter und Sätze (in der bei der Programmierung verwendeten Sprache) aufgelistet werden, denen dann die übersetzte Form gegenübergestellt wird.
Die sieht zum Beispiel wie folgt aus:
"File" "Datei"
"Open" "Öffnen"
"Save" "Speichern"
"Quit" "Beenden"
"Welcome to my Application" "Willkommen in meiner Anwendung"
Wichtig bei den Dictionaries ist, daß Sie auf die genaue Wortwahl und Satzform achten. Schreiben Sie nur einen Buchstaben falsch oder verwenden ein anderes Wort, wird der Satz oder das Wort nicht übersetzt. Die Übersetzte Form hingegen kann frei definiert werden.
Die Dictionary Dateien müßen an einem bestimmten Platzt abgelegt sein, damit die Lokalisierung funktioniert. Erstellen Sie dafür in Ihrem Programmordner, also das Verzeichnis in dem Sie ihr Programm abgelegt haben ein neues Verzeichnis mit dem Namen Language und erstellen sie dann in diesem Verzeichnis ein Ordner mit dem Namen Dictionaries. In deises Verzeichnis werden alle Dictionary Dateien abgelegt.
Die Dictionary Dateien haben außerdem noch eine bestimmte Schreibweise, die sich folgendermaßen zusammensetzt:
- Die Dictionary Datei muss exakt den Namen des Programms Tragen (Groß und Kleinschreibung beachten)
- Die Datei muß eine Sprachspezifische Dateiendung erhalten damit die jeweilige Sprache erkannt wird.
- Für deutsch muß die Dateiendung .deDE heißen.
- Für englsich muß die Dateiendung .enUK heißen.
- Für französisch muß die Dateiendung .frFR heißen.
Folglich wäre die Dateiendung der deutschen Übersetzung für das Programm MeinProgramm wie folgt aussehen:
MeinProgramm.deDE.
Bestimmte Breiche im Programmcode werden allein mit Localize nicht übersetzt. Hier muss dann noch ein weiterer Befehl eingepflegt werden. Hierbei handelt es sich um die Variable Translate$ die von YAB vorgegeben ist. Mit diesem Befehl sagen Sie YAB, dass der nach dieser Variablen folgende Bereich übersetzt werden soll.
Ein paar Beispiele, wie Sie Translate$ in Ihrem Programmcode intrigieren müssen:
Translate$ in einer case Abfrage - Beispiel Menüleiste:
case translate$("MainView:Help:Documentation")+"|"
Normalerweise würde die case Abfrage so aussehen: case "View:Help:Documentation|". Die translate$ Variable muss am Anfang der case Abfrage gesetzt werden. Die Ortsangabe im Menü "View:Help:Documentation|" muss in Klammern gesetzt werden und der Trenner | wird hinter die Klammer gesetzt. Der Trenner wird, in Ausrufezeichen gesetzt, und mit dem + am Code rangehängt.
Translate$ in einer if Abfrage - Beispiel Menüleiste:
if msg$(i)=translate$("Mainview:Program:Quit") then
Normalerweise würde die if Abfrage so aussehen: if msg$(i)="Mainview:Program:Quit" then. Die translate$ Variable muss wie bei der case Abfrage am Anfang gesetzt werden. Durch den Zusatz der Variable muss auch hier die Ortsangabe in Klammern gesetzt werden.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Maus abfragen
Die Maus kann man in YAB recht einfach abfragen:
Man fügt vor seiner bisherigen WHILE Schleife (Grau) die folgenden Zeile ein.
dim mouse$(1)
while(not instr(message$, "Quit"))
mmsg$ = mouse message$("MainView")
if (not mmsg$ = Fmmsg$) then
Fmmsg$ = mmsg$
nx = split(mmsg$, mouse$(), ":")
Xmouse = val(mouse$(1))
Ymouse = val(mouse$(2))
BLmouse = val(mouse$(3))
BCmouse = val(mouse$(4))
BRmouse = val(mouse$(5))
fi
wend
Mit der Zeile mmsg$ = mouse message$("MainView") werden die Mausaktivitäten vom MainView abgefragt.
Mit der If Abfrage wird abgefragt, ob der Mauswert dem neuen entspricht, wenn dies nicht der Fall sein sollte wird
die If Schleife fortgesetzt. Danach wird mit dem Split Befehl die Maus Message in ihre Bestandteile aufgeteilt und in das Array
mouse$() gespeichert. Danach liegen ihnen die Werte in den 5 Variablen vor.
Sie können jetzt auf die einzelnen Werte mit IF oder Switch Case abfragen.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
mid$
Der Befehl mid$() liefert einen Teil eines Strings zurück. Der Befehl mid$() benötigt drei Informationen, den String der bearbeitet werden soll und zwei Zahlen. Die erste Zahl gibt an, ab welcher Stelle im String gezählt werden soll. Die zweite Zahl gibt an wie viele Zeichen vom String zurückgeben werden sollen.
Als Beispiel:
Sie haben einen String "Testen" und daraus möchten Sie das st haben. Dann schreiben Sie mid$(testen,3,2).
print mid$("Dies ist der Beispielstring",6,7)
a$="Dies ist der Beispielstring"
print mid$(a$,6,7)
In der oberen Zeile des grauen Kastens geben sie einen Teil des Strings über den Print Befehl aus. Das Ergebnis sieht so aus:
ist der
Im unteren Teil des grauen Fenster geben Sie auch einen Teil eines Strings aus, der aber in einer Variablen gespeichert ist. Das Ergebnis ist identisch mit den oberen. Nur das Sie den Vorteil haben, den String variabel zu halten.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
People Datei erstellen
Wie man eine People Datei über den Terminal erstellt, haben wir bereits auf der BeSly unter Sonstiges/ People Datei über Terminal erstellen beschrieben. Das erstellen einer People Datei über yab ist im Grunde genommen derselbe Vorgang, denn auch hier muss eine Datei erstellt und dann die zugehörigen Attribute vergeben werden.
Wir gehen davon aus, dass die nötigen Informationen der Person bereits in Variablen$ enthalten sind:
| Name$ = Vor und Zuname der Person Nickname$ = Spitzname der Person Geburtsdatum$ = Geburtsdatum der Person Strasse$ = Adresse der Person Stadt$ = Wohnort der Person Bundesland$ = Bundesland in welchen die Person wohnt. Land$ = Das Land in welchen die Person lebt. Postleitzahl$ = Die Postleitzahl des Wohnortes Email$ = E- Mail Adresse der Person Telefonummer$ = Telefonnummer der Person Handynummer$ = Handynummer der Person Gruppe$ = Definition einer Kontaktgruppe (Familie, Freunde...) |
Zuerst erstellen wir eine Roh- Datei, welche wir dann durch die Vergabe von Attributen zu einer People Datei umwandeln. Um der Datei den Namen der Person zu geben, definieren wir den Dateinamen mit der Variablen Name$.
| anlegen=open("/boot/home/people/"+Name$, "w") close(anlegen) |
Nun sollte eine Datei mit dem Namen Name$ in Ihrem People Verzeichnis liegen.
Als nächstes machen wir aus der Roh- Datei eine People Datei.
| Output$=system$("addattr -t string BEOS:TYPE application/x-person /boot/home/people/"+"\""+Name$+"\"") |
Wir verwenden das Shell Tool addattr um einen String BeOS:TYPE mit dem Mimetype application/x-person als Attribut der Datei zu definieren.
Da die Namen der People Dateien oftmals mit einem Leerzeichen versehen sind, muss der Name der Datei in Anführungszeichen gesetzt sein, dies bewirkt man in yab mit den Zeichen "\""+Dateiname$+"\"".
Jetzt besitzt die Datei in People Verzeichnis das People Symbol.
Nun müssen noch die Person- Informationen in der Datei gespeichert werden. Auch hier verwenden wir das Shell Tool addattr:
| Output$=system$("addattr -t string META:name "+"\""+Name$+"\""+" /boot/home/people/"+"\""+Name$+"\"") |
Im Beispiel vergeben wir den Namen der Person mit dem String META:name und dem Namen der Person in Form der dafür erstellten Variable Name$.
 |
Lassen Sie sich jetzt nicht irritieren, weil die Variable Name$ gleich zweimal vorkommt. Einmal definieren Sie über den String META:name den Name$ der Person und dann geben Sie den Name$ der Datei an, welcher den Namen der Person trägt. |
Nun folgen die anderen vorher definierten Person- Informationen, die auf dieselbe Weise der Datei zugefügt werden. Verändern Sie dazu nur die META:Angabe und die Variable für die Information.
| META Angaben: META:name = Name und Nachname der Person (Name$) META:nickname = Spitzname der Person (Nickname$) META:birthday = Geburtsdatum der Person (Geburtsdatum$) META:address = Adresse der Person (Strasse$) META:city = Wohnort der Person (Stadt$) META:country = Bundesland in welchen die Person wohnt (Bundesland$) META:state = Das Land in welchen die Person lebt (Land$) META:zip = Postleitzahl des Wohnortes der Person (Postleitzahl$) META:email = E- Mail Adresse der Person (Email$) META:hphone = Telefonnummer der Person (Telefonummer$) META:cphone = Handynummer der Person (Handynummer$) META:group = Definition einer Kontaktgruppe (Familie, Freunde...) (Gruppe$) |
Es gibt noch mehr Informationen, die in einer People Datei definiert werden können, dies liegt an der Software, welche diese Informationen vergibt, bzw. verwendet.
Sollte eine der Informationen, welche Sie gerne einer People Datei anfügen möchten, nicht hier beschrieben sein, öffnen Sie eine People Datei, bei der diese Information vergeben wurde mit dem Programm QuickRes (ZETA unter ZETA Menü/Entwicklung/QuickRes) und sehen nach mit welchen META:Name diese definiert wird.
QuickRes sollte auch über das rechte Maustasten Menü auswählbar sein.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Print
Mit dem Befehl Print können Sie Texte, Zahlen in dem Terminal ausgeben. Sie können auch Variable anstatt fester Werte ausgeben.
Print "Hallo"
Print 6
d$="Ich bin eine Variable"
x=123
Print d$
Print x
In diesem Beispiel wird im Terminal zuerst Hallo und dann die Zahl 6 ausgegeben.
In den nächsten Zeilen wird jeweils eine Variable erstellt und ihr einen Wert zugewiesen. Diese werden dann ebenfalls mit dem Print Befehl im Terminal ausgegeben.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
right$
Der Befehl right$() liefert den rechten Teil eines Strings zurück. Der Befehl right$() benötigt zwei Informationen, den String der bearbeitet werden soll und eine Zahl. Die Zahl gibt an wie viele Zeichen vom String zurückgeben werden sollen.
print right$("Dies ist der Beispielstring",9)
a$="Dies ist der Beispielstring"
print right$(a$,9)
In der oberen Zeile des grauen Kastens geben sie einen Teil des Strings über den Print Befehl aus. Das Ergebnis sieht so aus:
ielstring
Im unteren Teil des grauen Fenster geben Sie auch einen Teil eines Strings aus, der aber in einer Variablen gespeichert ist. Das Ergebnis ist identisch mit den oberen. Nur das Sie den Vorteil haben, den String variabel zu halten.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Verwenden von Shell Tools
Bei der YAB Programmierung wird für die Ausführung von Aktionen in den meisten Fällen auf die Shell Tools (Terminal Anwendungen) zurückgegriffen. Die Shell Tools liefern alle möglichen Funktionen um gewünschte Aktionen durchzuführen. Dies kann zum Beispiel das kopieren von Dateien, das ermitteln von Informationen oder das öffnen einer Datei sein. Wer also schon mal mit der Shell gearbeitet hat wird mit YAB leichter an sein Ziel kommen.
Ein Shell Programm führt man wie folgt aus:
Output$=System$("open /boot/home")
Über die YAB- internen Variablen Output$ und System$ wird der Shell Befehl open ausgeführt. Hier wird genau dieselbe Befehlsgebung verwendet wie im Terminal. Die Befehle werden in Klammern und Ausrufezeichen gesetzt.
("open /boot/home")
Es können aber nicht nur Shell Programme ausgeführt werden. Genauso gut können Sie hier zum Beispiel den Browser NetPositive mit einer speziellen Html Seite aufrufen (z.B. eine Anleitung).
Output$=System$("/boot/beos/apps/NetPositive Anleitung.html")
Sicherlich werden Sie irgendwann an den Punkt gelangen, an dem Sie eine vorher definierte Variable mit in eine Befehlskette einbinden möchten. Dies wird zum Beispiel dann der Fall sein, wenn Sie immer wiederkehrende Dateipfade angeben möchten oder zuvor ermittelte Daten mit einbringen müssen.
Dateipfad$="/boot/home/myprogram/"
Output$=System$("/boot/beos/apps/NetPositive "+Dateipfad$ + "Dokumentation/Anleitung.html")
In unseren Beispiel füllen wir die Variable Dateipfad$ mit dem Standort unseres Programms: /boot/home/myprogram/.
Danach wurde das Beispiel mit dem öffnen einer Html Seite mit dem NetPositve mit dieser Variablen erweitert. Hierzu wurde die Befehlskette für den Terminalbefehl unterbrochen und die Variable durch ein + eingefügt. Wichtig ist, dass die Befehlskette vor dem + Zeichen mit einem Ausrufezeichen versehen wird. Wird ein Leerzeichen benötigt, muss dieses noch vor dem Ausrufezeichen gesetzt werden. Nach dem + Zeichen folgt die Variable und dann ein weiteres + Zeichen, da die Befehlskette fortgesetzt wird (Endet die Befehlskette mit der Variablen, entfällt dieses Zeichen). Hier ist wiederum zu beachten, dass die Befehlskette nach der Variablen wieder mit einem Ausrufezeichen beginnt.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Strings in YAB bearbeiten
Um in Yab Strings zu bearbeiten gibt es mehrere Befehle. Manche von denen Verändern einen String, andere wiederum vergleichen diese mit einem Anderen. An dieser Stelle werden ein paar Befehle beschrieben:
left$()
mid$()
right$()
str$()
token()
val()
Hier ein paar Möglichkeiten Strings zu bearbeiten:
Strings umdrehen
Strings rotieren
Zeichen in Strings austauschen
Zeichen in Strings löschen
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Strings umdrehen
Da es in YAB leider keinen Befehl gibt mit welchem man einen String umdrehen kann, bilden wir diesen mit Hilfe der vorhandenen Befehle nach.
export sub yStrRevert$(StringToRevert$)
local i
local StrRevert$
StrRevert$ = ""
REM revert the string
for i = 1 to len(StringToRevert$)
StrRevert$ = StrRevert$ + mid$(StringToRevert$, (len(StringToRevert$) + 1) - i, 1)
next i
return StrRevert$
end sub
Aufruf der Subroutine:
yStrRevert(<STRING>)
<STRING> = Beinhaltet den Text/String welcher umgedreht werden soll.
Beispiel:
print yStrRevert$("Franz jagt im komplett verwahrlosten Taxi quer durch Bayern.")
Im Beispiel soll der Text/String "Franz jagt im komplett verwahrlosten Taxi quer durch Bayern." umgedreht, sprich rückwärts, geschrieben werden.
Ergebnis:
.nreyaB hcrud reuq ixaT netsolrhawrev ttelpmok mi tgaj znarF
 |
Das "export" am Anfang der Subroutine kann auch weggelassen werden, es dient lediglich dazu die Routine zu exportieren und in anderen Programmen wiederverwenden zu können. Somit kann man sich eigene Libraries erstellen und muss den Code nicht in jedem Programm neu schreiben. |
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Strings rotieren
Da es in YAB leider keinen Befehl gibt mit welchem man einen String nach Links oder Rechts verschieben kann, bilden wir diesen mit den vorhandenen String- Befehlen nach.
export sub yStrRotate$(StringToRotate$, Retries, Direction$)
local i
REM rotate the string to the left
if (upper$(Direction$) = "LEFT") or (upper$(Direction$) = "L") then
for i=1 to Retries
StringToRotate$ = right$(StringToRotate$, len(StringToRotate$) - 1) + left$(StringToRotate$, 1)
next i
end if
REM rotate the string to the right
if (upper$(Direction$) = "RIGHT") or (upper$(Direction$) = "R") then
for i=1 to Retries
StringToRotate$ = right$(StringToRotate$, 1) + left$(StringToRotate$, len(StringToRotate$) - 1)
next i
return StringToRotate$
end sub
Aufruf der Subroutine:
yStrRotate$(<STRING>, <RETRIES>, <DIRECTION>)
<STRING> = Beinhaltet den Text/String welcher rotiert werden soll.
<RETRIES> = Gibt an um wie viele Stellen der Text/String rotiert werden soll.
<DIRECTION> = Gibt an in welche Richtung der Text rotiert werden soll. Dabei stehen "right", "RIGHT", "r" und "R" für rechts, und "left", "LEFT", "l" und "L" für links.
Beispiel:
print yStrRotate$("Franz jagt im komplett verwahrlosten Taxi quer durch Bayern.", 12, "l")
Im Beispiel wird der Text/String "Franz jagt im komplett verwahrlosten Taxi quer durch Bayern." um 12 Stellen nach links verschoben, wobei die wegfallenden Zeichen am Ende des String wieder angehängt werden.
Ergebnis:
m komplett verwahrlosten Taxi quer durch Bayern.Franz jagt i
|
Das "export" am Anfang der Subroutine kann auch weggelassen werden, es dient lediglich dazu die Routine zu exportieren und in anderen Programmen wiederverwenden zu können. Somit kann man sich eigene Libraries erstellen und muß den Code nicht in jedem Programm neu schreiben. |
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Zeichen in Strings austauschen
Da es in YAB leider keinen Befehl gibt mit welchem man einzelne Zeichen in einem String austauschen kann, bilden wir diesen mit Bordmitteln nach.
export sub yStrChrReplace$(StringToReplace$, Character1$, Character2$)
local i
for i = 1 to len(StringToReplace$)
if mid$(StringToReplace$, i, 1) = Character1$ then
mid$(StringToReplace$, i, 1) = Character2$
end if
next i
StringToReplace$
end sub
Aufruf der Subroutine:
yStrChrReplace$(<STRING>, <CHARACTER1>, <CHARACTER2>)
<STRING> = Beinhaltet den String welcher manipuliert werden soll.
<CHARACTER1> = Gibt das Zeichen an welches ersetzt werden soll.
<CHARACTER2> = Gibt das Zeichen an mit dem ersetzt werden soll.
Beispiel:
print yStrChrReplace$("Franz jagt im komplett verwahrlosten Taxi quer durch Bayern.", "a", "x")
Im Beispiel werden alle Buchstaben "a" im Text/String "Franz jagt im komplett verwahrlosten Taxi quer durch Bayern." durch das Zeichen "x" ersetzt.
Ergebnis:
Frxnz jxgt im komplett verwxhrlosten Txxi quer durch Bxyern.
|
Das "export" am Anfang der Subroutine kann auch weggelassen werden, es dient lediglich dazu die Routine zu exportieren und in anderen Programmen wiederverwenden zu können. Somit kann man sich eigene Libraries erstellen und muss den Code nicht in jedem Programm neu schreiben. |
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Zeichen in Strings löschen
Da es in YAB leider keinen Befehl gibt mit welchem man einzelne Zeichen in einem String löschen kann, bilden wir diesen mit Bordmitteln nach.
export sub yStrChrDelete$(StrToDelete$, Character$)
local StrChrDelete$
local Tile$
local StrCountTiles
local i
dim Tile$(1)
StrChrDelete$ = ""
StrCountTiles = token(StrToDelete$, Tile$(), Character$)
for i = 1 to StrCountTiles
StrChrDelete$ = StrChrDelete$ + Tile$(i)
next i
StrChrDelete$
end sub
Aufruf der Subroutine:
yStrChrDelete$(<STRING>, <CHARACTER>)
<STRING> = Beinhaltet den Text/String aus welchem Zeichen gelöscht werden sollen.
<CHARACTER> = Gibt das Zeichen an welches aus dem Text/String gelöscht werden soll.
Beispiel:
print yStrChrDelete$("Franz jagt im komplett verwahrlosten Taxi quer durch Bayern.", "a")
Im Beispiel werden alle "a" aus dem Text/String "Franz jagt im komplett verwahrlosten Taxi quer durch Bayern." entfernt.
Ergebnis:
Frnz jgt im komplett verwhrlosten Txi quer durch Byern.
|
Das "export" am Anfang der Subroutine kann auch weggelassen werden, es dient lediglich dazu die Routine zu exportieren und in anderen Programmen wiederverwenden zu können. Somit kann man sich eigene Libraries erstellen und muss den Code nicht in jedem Programm neu schreiben. |
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Strings mit Leerzeichen verwenden
Es kommt des öfteren vor, dass man Strings mit Leerzeichen auswerten muss. Dies kann zum Beispiel dann sein, wenn vom Benutzer eingegebene Wörter angefordert werden (z.B. Name einer Datei).
Das speichern der mit Leerzeichen eingegebenen Eingabe des Benutzers ist dabei nicht das Problem, denn dies wird ausgelesen und beispielsweise in einer Variable gespeichert. Beim Auswerten dieser Eingabe, durch verwenden der Variablen, wird jedoch ohne zusätzliche Definierung nur der erste Teil ausgegeben.
Um den gesamten Wert (String) zu erhalten, muss dieser zwischen zwei Ausrufezeichen gesetzt werden. Da yab allerdings diese auch als Befehlszeichen verwendet, muss diese Angabe von dieser getrennt werden. Dies macht man mit folgender Zusatzangabe:
"\""+Variable$+"\""
zurück zur Übersicht
zurück zum Stichwortverzeichnis
str$()
Mit dem Befehl str$() können Sie eine Zahlvariable in einen String umwandeln.
a=5
print str$(a)
Als erstes wird eine Zahlvariable erstellt mit dem Wert 5. In der nächsten Zeile geben wir diese als String aus.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Subroutine - Programmcodes an mehren Stellen verwenden
Mit Hilfe von Subroutinen, ist es möglich, bestimmte Programmcodes an mehreren Stellen einzubinden. Ein gutes Beispiel dafür ist das schließen von "Views". Jedes Mal wenn sie Views öffnen und dann zum Beispiel nach einer Auswahl (Button, Menü usw.) einen neuen View laden, müssen Sie den vorherigen schließen um Überlagerungen zu vermeiden. Hier kann eine Subroutine eine große Hilfe sein, denn diese können Sie vor dem öffnen eines neuen Views einbinden um alle im Programm möglichen Views zu schließen, ohne darauf achten zu müssen ob alle dort eingetragenen Views derzeit in Verwendung sind.
Eine Subroutine fügen Sie wie folgt außerhalb der Mainloop ein:
sub Name der Subroutine()
Programmcode
end sub
Mit sub Name der Subroutine(), erstellen Sie eine Subroutine mit einem Namen Ihrer Wahl. Dies könnte zum Beispiel RemoveViews() sein. Mit end sub beenden Sie den Subroutinenbereich. Zwischen diese beiden Befehle, schreiben Sie den Programmcode, welchen Sie durchführen möchten.
Bei dem Beispiel mit den Views würde der Programmcode dann zum Beispiel so aussehen:
sub RemoveViews()
view remove "View1"
view remove "View2"
view remove "View3"
end sub
Nachdem Sie die Subroutine erstellt haben, müssen Sie diese noch an der Stelle im Programmcode einbinden, an welcher Sie diese ausführen möchten.
Dies erfolgt mit der einfachen Angabe der Subroutine:
Name der Subroutine()
Sie werden schnell feststellen, dass dies nicht nur eine Erleichterung beim schreiben von wiederkehrenden Abfragen oder Aktionen darstellt, sondern auch den Programmcode ordentlicher und übersichtlicher macht. Es kann auch hilfreich sein, einfach ausgeführte Aufgabenstellungen in Subroutinen zu verlagern, da so der Mainloop leichter zu überblicken ist.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Soundplay verwenden
Um einen Soundfile mit YAB abzuspielen verwenden Sie die Funktion Soundplay.
soundplay "Dateiname", isloop
Mit dem Befehl Soundplay spielen Sie einen Soundfile ab. In den Anführungszeichen tragen Sie den Dateinamen ein.
isloop ist eine boolsche Variable, d.h. sie sollte entweder true oder false sein.
soundplay "Dateiname", true
Hinweis: In Yab (im Gegensatz zu z.B. C++) sind Boolsche Variablen Zahlen, d.h. false ist äquivalent zu 0 und true ist aequivalent zu 1.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Systeminformationen ermitteln
Beitrag von Chaotic Oktober 2009
Leider bietet yab, auch in der aktuellen Version 1.5, nur wenige Informationen zum Computer-System an (Diese wird/will Jan aber noch einbauen). Bis es jedoch soweit ist, muss trotzdem niemand auf solche Informationen verzichten, denn mit ein paar Zeilen Code lassen sich diese selbst ermitteln.
Im Folgenden möchte ich zeigen wie man z.B. die Größe bzw. den freien oder bereits belegten Speicher ermitteln kann, die Anzahl der Prozessoren ermittelt oder herausbekommt auf welche MAC- bzw. IP- Adresse der Rechner hört.
All die kleinen, im Folgenden aufgeführten Beispiele sind auch als solche zu verstehen. Sie sollen lediglich Anregung sein das Eine oder Andere selbst einmal auszuprobieren. Dabei sind Erweiterungen und Verbesserungen selbstverständlich gern gesehen und willkommen.
Die Anzahl der Prozessoren ermitteln
Mit der nachstehenden kleinen Routine kann man auf sehr einfache Weise die Anzahl der Prozessoren im System ermitteln:
<----- Quellcode ----->
export sub yGetCPUCount()
return val(left$(system$("sysinfo -cpu"), 1))
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetCPUCount()
print yGetCPUCount()
Über den Befehl "print yGetCPUCount()" bekommen wir die Anzahl der CPUs im Terminal ausgegeben. Möchte man dies anderweitig machen, muss dieser Bereich dementsprechend angepasst werden. Die Ausgabe erfolgt hier als einfache Zahl, der Wert der Zahl ist gleich die Anzahl der CPUs.
Die Prozessor- Beschreibung ermitteln
Um die Beschreibung des Prozessors zu ermitteln verwenden wir die folgende Sub- Routine:
<----- Quellcode ----->
export sub yGetCPUDescription$()
local counter
local lines$
dim lines$(1)
counter = token(system$("sysinfo -cpu"), lines$(), chr$(10))
return mid$(lines$(2), 10, len(lines$(2)) - 10)
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetCPUDescription$()
print yGetCPUDescription$()
Über den Befehl "print yGetCPUDescription$()" bekommen wir die Beschreibung des Prozessors im Terminal ausgegeben. Dies kann wie folgt aussehen: "Intel® Core 2 Quad CPU @ 2.66GHz". Dies würde also bedeuten, das in abgefragten Rechner ein "Intel® Core 2 Quad" mit 2,66 GHz seine Arbeit verrichtet.
Die Prozessor- Familie ermitteln
Jeder Prozessor verfügt weiterhin über Informationen wie Family, Model und Stepping. Mit der folgenden, kleinen Routine kann man die Prozessor- Familie ermitteln.
<----- Quellcode ----->
export sub yGetCPUFamily()
local counter
local counter2
local lines$
local lines2$
local result
dim lines$(1)
dim lines2$(1)
counter = token(system$("sysinfo -cpu"), lines$(), chr$(10))
counter2 = token(lines$(3), lines2$(), ",")
for i = 1 to counter2
if (instr(lines2$(i), "family")) then
result = val(mid$(lines2$(i), instr(trim$(lines2$(i)), " ") + 2, len(trim$(lines2$(i))) - instr(trim$(lines2$(i)), " ")))
end if
next i
return result
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetCPUFamily()
print yGetCPUFamily()
Über den Befehl "print yGetCPUFamily()" bekommen wir die Prozessor- Familie ermittelt und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "6". Dieses Ergebnis ordnet den Prozessor der Intel internen Familie 6 zu. Was diese Information im Einzelnen zu bedeuten hat, erfährt man sicher bei Intel.
Das Prozessor- Modell ermitteln
Wie bereits im oberen Beispiel erwähnt, hier nun die Funktion um auch das Prozessor- Modell zu ermitteln:
<----- Quellcode ----->
export sub yGetCPUModel()
local counter
local counter2
local lines$
local lines2$
local result
dim lines$(1)
dim lines2$(1)
counter = token(system$("sysinfo -cpu"), lines$(), chr$(10))
counter2 = token(lines$(3), lines2$(), ",")
for i = 1 to counter2
if (instr(lines2$(i), "model")) then
result = val(mid$(lines2$(i), instr(trim$(lines2$(i)), " ") + 2, len(trim$(lines2$(i))) - instr(trim$(lines2$(i)), " ")))
end if
next i
return result
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetCPUModel()
print yGetCPUModel()
Über den Befehl "print yGetCPUModel()" bekommen wir das Prozessor- Modell ermitteln und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "15". Dieses Ergebnis ordnet dem Prozessor das Intel interne Modell 15 zu. Was diese Information im Einzelnen zu bedeuten hat, erfährt man sicher bei Intel.
Das Prozessor- Stepping ermitteln
Ebenfalls wie bereits im oberen Beispiel erwähnt, hier nun die Funktion um auch das Prozessor- Stepping zu ermitteln:
<----- Quellcode ----->
export sub yGetCPUModel()
local counter
local counter2
local lines$
local lines2$
local result
dim lines$(1)
dim lines2$(1)
counter = token(system$("sysinfo -cpu"), lines$(), chr$(10))
counter2 = token(lines$(3), lines2$(), ",")
for i = 1 to counter2
if (instr(lines2$(i), "stepping")) then
result = val(mid$(lines2$(i), instr(trim$(lines2$(i)), " ") + 2, len(trim$(lines2$(i))) - instr(trim$(lines2$(i)), " ")))
end if
next i
return result
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetCPUStepping()
print yGetCPUStepping()
Über den Befehl "print yGetCPUStepping()" bekommen wir das Prozessor- Stepping ermitteln und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "7". Dieses Ergebnis ordnet dem Prozessor dem Intel interne, Stepping 7 zu. Was diese Information im Einzelnen zu bedeuten hat, erfährt man sicher bei Intel.
Die aktuelle Prozessor- Geschwindigkeit ermitteln
Warum die aktuelle Prozessor- Geschwindigkeit? Weil diese von der in der Prozessor- Beschreibung angegebenen Taktfrequenz abweicht und sich während des Betriebes, bei modernen Prozessoren, ändern kann. Die nachstehende Routine liefert das gewünschte Ergebnis.
<----- Quellcode ----->
export sub yGetCPUActualSpeed()
local i
local sys$
sys$ = system$("sysinfo -cpu")
for i = instr(sys$, "MHz") - 1 to 1 step -1
if mid$(sys$, i, 1) = chr$(32) then
break
end if
next i
return val(mid$(sys$, i + 1, instr(sys$, "MHz") - 1 - i))
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetCPUActualSpeed()
print yGetCPUActualSpeed()
Über den Befehl "print yGetCPUActualSpeed()" bekommen wir die aktuelle Prozessor- Geschwindigkeit ermitteln und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "2668". Dies bedeutet also, dass der Rechner im Moment mit 2668 MHz arbeitet.
Die Gesamt- Größe des Arbeitsspeichers ermitteln
Die folgende Routine ermittelt die Größe des gesamten verfügbaren Arbeitsspeichers im System:
<----- Quellcode ----->
export sub yGetMemoryTotal()
local counter
local lines$
dim lines$(1)
counter = token(system$("sysinfo -mem"), lines$(), " )")
return val(lines$(7))
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetMemoryTotal()
print yGetMemoryTotal()
Über den Befehl "print yGetMemoryTotal()" bekommen wir die Gesamt- Größe des Arbeitsspeichers ermittelt und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "650051584". Die Angabe erfolgt in Byte. Dies würde also bedeuten, dass in meinem Rechner 620 MB Arbeitsspeicher vorhanden sind.
Die Größe des noch freien Arbeitsspeichers ermitteln
Ebenso wie die gesamte Größe des Arbeitsspeichers lässt sich auch der noch freie Arbeitsspeicher ermitteln. Die folgende Routine übernimmt diese Aufgabe:
<----- Quellcode ----->
export sub yGetMemoryFree()
local counter
local lines$
dim lines$(1)
counter = token(system$("sysinfo -mem"), lines$(), " )")
return val(lines$(1))
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetMemoryFree()
print yGetMemoryFree()
Über den Befehl "print yGetMemoryFree()" bekommen wir die Größe des noch freien Arbeitsspeichers ermittelt und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "546045952". Auch in diesem Fall sind die Angaben wieder in Bytes. So sind im Moment ca. 520 MB des Arbeitsspeichers noch frei.
Die Größe des bereits verwendeten Arbeitsspeichers ermitteln
Auch die Größe/Menge des bereits belegten Arbeitspeichers kann mit Hilfe einer kleinen Routine ermittelt werden:
<----- Quellcode ----->
export sub yGetMemoryUsed()
local counter
local lines$
dim lines$(1)
counter = token(system$("sysinfo -mem"), lines$(), " )")
return val(lines$(5)) end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetMemoryUsed()
print yGetMemoryFree()
Über den Befehl "print yGetMemoryUsed()" bekommen wir die Größe des bereits verwendeten Arbeitsspeichers ermittelt und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "104005632". Auch hier sind die Angaben wieder in Bytes. Gut, irgendein Schlauberger könnte jetzt sagen, warum so eine Routine. Man kann doch einfach den noch freien vom gesamten Arbeitsspeicher abziehen und erhält dasselbe Ergebnis. Ja, aber warum einfach wenn es auch umständlich auch geht, und schließlich wollen wir doch programmieren lernen ^^.
Die Größe des Cache- Speichers ermitteln
Ja, auch die Größe des verwendeten Cache- Speichers lässt sich ermitteln, und zwar mit der folgenden kleinen Routine:
<----- Quellcode ----->
export sub yGetMemoryCached()
local counter
local lines$
dim lines$(1)
counter = token(system$("sysinfo -mem"), lines$(), " )")
return val(lines$(10))
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetMemoryUsed()
print yGetMemoryUsed()
Über den Befehl "print yGetMemoryUsed()" bekommen wir die Größe des Cache- Speichers ermittelt und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "32636928". Wie bereits bei den vorangegangenen Beispielen sind auch hier die Angaben wieder in Bytes. Das System belegt in diesem Fall also ca. 31 MB für den Cache-Speicher.
Die horizontale Bildschirmauflösung ermitteln
Diese Information bekommt man prinzipiell über den PEEK()- Befehl, aber wie im folgenden Beispiel zu sehen, kann man dies auch über das System abfragen:
<----- Quellcode ----->
export sub yGetScreenWidth()
local counter
local lines$
dim lines$(1)
counter = token(system$("screenmode"), lines$(), " ")
return val(lines$(2))
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetScreenWidth()
print yGetScreenWidth()
Über den Befehl "print yGetScreenWidth()" bekommen wir die horizontale Bildschirmauflösung ermittelt und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "1152". Die Bildschirmauflösung beträgt horizontal also eine Größe von 1152 Pixeln.
Die vertikale Bildschirmauflösung ermitteln
Auch diese Information bekommt man prinzipiell über den PEEK()- Befehl, aber wie im folgenden Beispiel zu sehen, kann man dies auch über das System abfragen:
<----- Quellcode ----->
export sub yGetScreenHeight()
local counter
local lines$
dim lines$(1)
counter = token(system$("screenmode"), lines$(), " ")
return val(lines$(3))
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetScreenHeight()
print yGetScreenHeight()
Über den Befehl "print yGetScreenHeight()" bekommen wir die vertikale Bildschirmauflösung ermittelt und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "864". Die Bildschirmauflösung beträgt vertikal also eine Größe von 864 Pixeln.
Die eingestellte Farbtiefe ermitteln
Ebenso wie die horizontale und vertikale Bildschirmauflösung lässt sich auch die eingestellte Farbtiefe ermitteln:
<----- Quellcode ----->
export sub yGetColorDepth()
local counter
local lines$
dim lines$(1)
counter = token(system$("screenmode"), lines$(), " ")
return val(lines$(4))
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetColorDepth()
print yGetColorDepth()
Über den Befehl "print yGetScreenHeight()" bekommen wir die eingestellt Farbtiefe ermittelt und im Terminal ausgegeben. Der für diese Abfrage verwendeten Rechner ergab einen Zahlenwert von "32". Die eingestellte Farbtiefe auf dem Rechner beträgt demnach 32 Bit = 4294967296 Farben (sofern darstellbar).
Die Bildwiederholfrequenz ermitteln
Und auch die eingestellte Bildwiederholfrequenz lässt sich über folgende kleine Routine ermitteln:
<----- Quellcode ----->
export sub yGetScreenRefreshRate()
local counter
local lines$
dim lines$(1)
counter = token(system$("screenmode"), lines$(), " ")
return val(lines$(6))
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetScreenRefreshRate()
print yGetScreenRefreshRate()
Über den Befehl "print yGetScreenRefreshRate()" bekommen wir die Bildwiederholfrequenz ermittelt und im Terminal ausgegeben. Der für diese Abfrage verwendeten Rechner ergab einen Zahlenwert von "60". Die eingestellte Bildwiederholrate in dem System liegt dem zu folge bei 60 Hz.
Den Namen des Betriebssystems ermitteln
Nun ja, hier ist der Name Programm und folgende kleine Routine nimmt uns die Arbeit ab:
<----- Quellcode ----->
export sub yGetOSName$()
return system$("uname -o")
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetOSName$()
print yGetOSName$()
Über den Befehl "print yGetOSName$()" bekommen wir den Namen des Systems ermittelt und im Terminal ausgegeben. Die Ausgabe bei dem für diese Abfrage verwendeten Rechners ergab "Haiku". Dies sagt uns also, das der Name unseres Betriebssystems ist "Haiku".
Die Version des Betriebssystems ermitteln
Und natürlich lässt sich auch die Version des Betriebssystems mit Hilfe folgender, kleiner Routine ermitteln:
<----- Quellcode ----->
export sub yGetOSVersion$()
local counter
local lines$
dim lines$(1)
counter = token(system$("uname -v"), lines$(), " ")
return lines$(1)
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetOSVersion$()
print yGetOSVersion$()
Über den Befehl "print yGetOSVersion$()" bekommen wir die Version des Betriebssystems ermittelt und im Terminal ausgegeben. Die Ausgabe bei dem für diese Abfrage verwendete Rechners ergab "r33109". Die verwendete Version des Betriebssystems ist also r33109.
Den Rechner- Namen (Hostnamen) ermitteln
Mit einer weiteren, recht einfachen Funktion ermitteln wir der Namen unseres Rechners:
<----- Quellcode ----->
export sub yGetHostname$()
return system$("hostname")
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetHostname$()
print yGetHostname$()
Über den Befehl "print yGetHostname$()" bekommen wir den Rechner- Namen (Hostname) ermittelt und im Terminal ausgegeben. Die Ausgabe bei dem für diese Abfrage verwendete Rechners ergab "shredder". Wie wir sehen heißt der Rechner shredder. Wer auch immer ihm diesen Namen verpasst hat, er heißt seit der Installation so, und ich schwöre, ich war es nicht.
Die IP- Adresse ermitteln
Folgende kleine Routine ermittelt die IP- Adresse des Rechners. Wobei hier der "loop"- Adapter nicht berücksichtigt wird, und auch nur die IP- Adresse der ersten Netzwerkkarte ermittelt wird. Wer will kann diese Funktion gern erweitern, sodass eventuell auch mehrere Netzwerkkarten berücksichtigt werden.
<----- Quellcode ----->
export sub yGetIPAddress$()
local counter
local counter2
local lines$
local lines2$
local result
dim lines$(1)
dim lines2$(1)
counter = token(system$("ifconfig"), lines$(), chr$(10))
for i = 1 to counter
if (instr(lines$(i), "inet addr:")) and (instr(lines$(i), "Bcast:")) then
counter2 = token(lines$(i), lines2$(), ", ")
end if
next i
return lines2$(3)
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetIPAddress$()
print yGetIPAddress$()
Über den Befehl "print yGetIPAddress$()" bekommen wir die IP Adresse des Rechners ermittelt und im Terminal ausgegeben. Die Ausgabe bei dem für diese Abfrage verwendeten Rechners ergab "10.0.2.15". Die IP- Adresse des Rechners ist also 10.0.2.15.
Die MAC- Adresse ermitteln
Mit folgender kleiner Routine ermittelt man die MAC- Adresse des Rechners. Wobei auch hier der "loop"- Adapter nicht berücksichtigt wird, und auch nur die MAC-Adresse der ersten Netzwerkkarte ermittelt wird. Wer will kann auch diese Funktion gern erweitern, sodass eventuell auch mehrere Netzwerkkarten berücksichtigt werden.
<----- Quellcode ----->
export sub yGetMACAddress$()
local counter
local counter2
local lines$
local lines2$
local result
dim lines$(1)
dim lines2$(1)
counter = token(system$("ifconfig"), lines$(), chr$(10))
for i = 1 to counter
if (instr(lines$(i), "Hardware Type: Ethernet, Address:")) then
counter2 = token(lines$(i), lines2$(), " ")
end if
next i
return lines2$(5)
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetMACAddress$()
print yGetMACAddress$()
Über den Befehl "print yGetMACAddress$()" bekommen wir die MAC Adresse des Rechners ermittelt und im Terminal ausgegeben. Die Ausgabe bei dem für diese Abfrage verwendeten Rechners ergab "08:00:27:9e:26:4d". Die MAC- Adresse des Rechners ist also 08:00:27:9e:26:4d.
Die SubNet- Mask ermitteln
Auch das Ermitteln der SubNet- Mask lässt sich über eine kleine Funktion bewerkstelligen:
<----- Quellcode ----->
export sub yGetSubNetMask$()
local counter
local counter2
local lines$
local lines2$
local result
dim lines$(1)
dim lines2$(1)
counter = token(system$("ifconfig"), lines$(), chr$(10))
for i = 1 to counter
if (instr(lines$(i), "inet addr:")) and (instr(lines$(i), "Bcast:")) then
counter2 = token(lines$(i), lines2$(), ", ")
end if
next i
return lines2$(7)
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetSubNetMask$()
print yGetSubNetMask$()
Über den Befehl "print yGetSubNetMask$()" bekommen wir die SubNet- Mask des Rechners ermittelt und im Terminal ausgegeben. Die Ausgabe bei dem für diese Abfrage verwendeten Rechners ergab "255.255.255.0". Die SubNet- Mask des Rechners ist also 255.255.255.0.
Das Standard- Gateway ermitteln
Und zum Schluss ermitteln wir nun noch mit Hilfe der nachstehenden Routine das Standard- Gateway:
<----- Quellcode ----->
export sub yGetDefaultGateway$()
local counter
local counter2
local lines$
local lines2$
local result
dim lines$(1)
dim lines2$(1)
counter = token(system$("route"), lines$(), chr$(10))
for i = 1 to counter
if (instr(lines$(i), "gateway")) and (instr(lines$(i), "default")) then
counter2 = token(lines$(i), lines2$(), ", ")
&nnbsp;end if
next i
return lines2$(5)
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetDefaultGateway$()
print yGetDefaultGateway$()
Über den Befehl "print yGetSubNetMask$()" bekommen wir das Standard- Gateway des Rechners ermittelt und im Terminal ausgegeben. Die Ausgabe bei dem für diese Abfrage verwendete Rechners ergab "10.0.2.2". Das Standard- Gateway des Rechners ist also 10.0.2.2.
Nachwort
Alle hier gezeigten Routinen sind selbstverständlich getestet und geprüft. Trotzdem kann ich Fehler, welche eventuell durch Tippfehler entstanden sind, nicht gänzlich ausschließen. Dies bitte ich gegebenen Falls zu entschuldigen. Alle Routinen wurden mit der yab- Version 1.5 erstellt und unter der HAIKU- Version R1 / Alpha1 Revision 33109 getestet.
Tastatur abfrage
Die Tastatur kann man in YAB recht einfach abfragen:
Man fügt in seiner bisherigen WHILE Schleife (Grau) die folgenden Zeilen ein.
while(not instr(message$, "Quit"))
keymsg$ = keyboard message$("MainView")
if(keymsg$<>"" and keymsg$<>old_keymsg$) then
print "You pressed "+keymsg$
old_keymsg$ = keymsg$
endif
Mit der If Abfrage können Sie erstmal feststellen wie jede einzelne Taste heißt,
z.B. wenn sie auf die Pfeiltaste nach links drücken wird left im Terminal bzw. in der IDE ausgegeben.
Das ganze bezieht sich auf den HauptView den sie beim erstellen des Programm angegeben haben, d.h. Sie müssen
eventuell das MainView gegen ihren Namen austauschen.
Die IF Abfrage prüft ob eine Eingabe stattgefunden hat und ob diese Eingabe großer/kleiner als die alte Eingabe war.
Danach wird der Text ausgegeben und des Weiteren die Variable old_keymsg$ mit dem Wert der aktuellen Eingabe belegt. Im unteren Teil wird gezeigt, wie sie auf diese Information eine Switch-Case Abfrage programmieren könnten. Damit sind Sie im Stande auf beliebige Tasten abfragen zu programmieren.
switch(keymsg$)
case "left"
print "Sie haben die Taste links gedrückt"
break
case "ö"
print "Sie haben die Taste ö gedrückt"
break
default:
break
end switch
sleep 0.10
wend
Weiteres zu Switch Case Abfragen finden Sie hier
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Treebox
Wie erstellt man eine Treebox? Um eine Treebox zu erstellen benötigen Sie mehrere Befehle.
- Treebox x1,y1 to x2,y2, name_der_Treebox$, Scrollbartype, View$
- Treebox add name_der_Treebox$, Rootitem$
- Treebox add name_der_Treebox$, Headitem$, Listitem$, isExpanded
Der 1. Befehl dient dazu den Platz für die Treebox zu erstellen. Dazu geben sie die Koordinaten x1,y1 (für die linke obere Ecke) und x2,y2 (für die rechte untere Ecke) an. Hinter den Koordinaten notieren Sie den Namen der Treebox. Danach können Sie die Scrollbar definieren.
- 0 steht für keine Scrollleisten
- 1 steht für Verticale Scrollleiste
- 2 steht für Horizontale Scrollleiste
- 3 steht für beide Scrollleisten
Nachdem Sie die Scrollbar definiert haben, brauchen Sie nur noch den View angegeben, auf dem die Treebox angezeigt werden soll.
Mit dem 2. Befehl tragen Sie in der Treebox den ersten Eintrag, auf dem die anderen Einträge verweisen, ein. Hinter dem Namen der Treebox steht Rootitem$. Fü Rootitem$ schreiben Sie ihren ersten Eintrag (siehe Beispiel).
Um weitere Punkte einzutragen wird praktisch der 2. Befehl erweitert (siehe oben, 3. Befehlszeile). Dabei entspricht Headitem$ in diesem Fall dem Rootitem$. Nach dem Headitem$ schreiben Sie das Listitem (welches eingentlich den Menupunkt darstellt). Am Ende der Befehlszeile steht noch isExpanded. isExpanded steht für ausgeklappt oder nicht ausgeklappt. Für ausgeklappt schreiben Sie true, für nicht ausgeklappt schreiben Sie false.
Um ein Unterpunkt von einem Listitem zu erstellen, brauchen Sie nur die 3. Befehlszeile zu duplizieren und an stelle des Headitems den Namen des vorherigen Listitems zu schreiben (im Beispiel entspricht das der 4 Code Zeile). Wie Sie da sehen können schreiben Sie an die Stelle des Listitems, nur noch ihren nächsten Punkt.
name_der_Treebox$="Hilfe"
Treebox 10,10 to 300,300, name_der_Treebox$, 3, "View1"
Treebox add name_der_Treebox$, "TAG"
Treebox add name_der_Treebox$, "TAG", "Tag", false
Treebox add name_der_Treebox$, "Tag", "Neuer Tag", false
Treebox add name_der_Treebox$, "Neuer Tag", "alter Tag", false
Wenn Sie das Beispiel so in ihrer Applikation eingebunden haben, sollten sie das Ergebnis bekommen.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Text in die Mitte eines Views setzen
Es ist schön das man so gut wie alle Befehle in den yab Commands erklärt bekommt, jedoch ist es oftmals nötig mehr zu wissen, als man zum verwenden eines Befehls oder Aufgabestellung benötigt.
Wie zum Beispiel beim anzeigen eines Textes in der Mitte eines Views. Hier werden mehrere Informationen benötigt. Zum einen benötigt man die Länge des Textes, welcher angezeigt werden soll und dann sollte man die Größe der Schrift ermitteln (die Größe in Pixel), damit egal welche Schrift verwendet wird der Text immer mittig vom View ist.
View_Hoehe=200
View_Breite=200
Text$="Dies ist der Text"
Buchstabe_Breite = DRAW GET "Text-Width", "W", View$
Buchstabe_Hoehe = DRAW GET "Max-Text-Height", "W", View$
Text_Laenge = len(Text$)
Text_Breite = Buchstabe_Breite*Text_Laenge
DRAW TEXT View_Breite/2-Text_Breite/2 ,View_Hoehe/2-Buchstabe_Hoehe/2, Text$, View$
Wir geben im Beispiel die Höhe und Breite des Views in dafür erstellte Variablen vor. Wir definieren View_Hoehe und View_Breite der einfach halt halber mit je 200 Pixeln.
Dann erstellen wir eine Variable Text$ in welcher wir unseren Ausgabetext speichern.
Bevor wir die Breite des Textes ermitteln können, müssen wir herausfinden, wie groß ein einzelner Buchstabe der Schrift, welche auf dem View$ verwendet wird, ist. Hierzu verwenden wir zwei Befehle, der eine ermittelt die Breite und der andere die Höhe der Schrift. Die Werte werden in den Variablen Buchstabe_Breite und Buchstabe_Hoehe gespeichert. Um den besten Wert zu erlangen, sollte man hier einen der großen Buchstaben verwenden, in diesem Fall ist es das "W".
Danach ermitteln wir die Länge des Textes, bzw. die Anzahl von Buchstaben, die der Text besitzt. Dazu erstellen wir eine Variable Text_Laenge und ermitteln über den Befehl len( ) die Länge des Textes, der in der Variablen Text$ definiert ist.
Um nun die wirkliche Länge des Textes zu ermitteln, erstellen wir eine Variable Text_Breite und speichern in dieser das Ergebnis aus Buchstabe_Breite mal Text_Laenge.
Jetzt können Sie den Text zum Beispiel über DRAW TEXT auf dem View anzeigen lassen. Um die vertikale Anfangsposition des Textes auf dem View$ anzugeben, Teilen wir die View_Breite durch 2 und ziehen von Ihr die Hälte von der Textlänge (Text_Breite/2) ab.
Das gleiche machen wir mit der horizontalen Position, wir teilen View_Hoehe durch 2 und ziehen die Hälfte von der Texthöhe (Buchstabe_Hoehe/2) ab.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Textcontrol auslesen und in Textdatei speichern
Um einen Textcontrol Eintrag in einer Textdatei zu speichern, erstellen Sie als erstes den Eingabebereich.
textcontrol 10,20 to 110,100, "Texteintrag", "Eintrag 1:", "Dies steht nachher in der Textdatei", "View"
Mit textcontrol 10,20 to 110,100 geben Sie den Position und Größe des Texteingabefeldes an.
Die Bezeichnung Texteintrag ist der Name von der Textcontrol.
Das was hier mit Eintrag 1: angegeben ist, ist ein text, der vor der Textcontrol geschrieben steht. Sollten Sie hier keine Angabe benötigen, lassen Sie diese einfach weg und schrieben nur die beiden Ausrufezeichen.
Die nachfolgende Angabe, Dies steht nachher in der Textdatei, ist der Text, der in die Textdatei gespeichert wird. Möchten Sie hier keinen Text anzeigen, also den Textcontrol leer darstellen, schreiben Sie nur die beiden Ausrufezeichen.
Mit View geben Sie die View an, in welcher Sie den Textcontrol anzeigen möchten. Heißt diese MainView oder Paul muß hier der richtige Name angegeben werden.
Nun öffnen wir eine Textdatei, um in diese zu schreiben.
eintrag = open("Mustertext.txt", "w")
Mit eintrag erstellen wir eine Variable mit dem Namen "eintrag".
Der Befehl open öffnet nachfolgende Datei.
Mustertext.txt ist die zu öffnende Textdatei, in welche gespeichert werden soll. Hierbei ist zu beachten, dass der Dateipfad mit angegeben wird, also zum Beilspiel: /boot/home/MyProgramm/Mustertext.txt.
Die Angabe w, steht für schreiben, also das in diese Datei geschrieben werden soll.
Nun lesen wir die Textcontrol Eingabe aus:
Texteintrag$=textcontrol get$ "Texteintrag"
Wir legen eine Variable an mit dem Namen Texteintrag$.
In diese Variable tragen wir den Inhalt vom Textcontrol Texteintrag ein. Hier wird also angegeben das wir eine Textcontrol abfragen möchten durch textcontrol get$. Und dahinter der Name des auszulesenden Textcontrols: Texteintrag.
Nun müssen noch die abgefragten Inhalte in die Textdatei gespeichert werden:
print #eintrag Texteintrag$
Mit print #eintrag geben Sie an, daß sie die Variable eintrag, den Inhalt der Variablen Texteintrag$, speichern möchten.
Die Variable eintrag verweist auf die zum schreiben geöffnete Datei Mustertext.txt, daher wird in diese der Inhalt der Variablen Texteintrag$ geschrieben.
Als letztes schließen Sie die Datei wieder, welche sie zum schreiben geöffnet haben durch:
close(eintrag)
zurück zur Übersicht
zurück zum Stichwortverzeichnis
token()
Der Befehl token() teilt einen String, aufgrund eines von ihnen bestimmten Zeichens (delimiters), auf. Der Befehl token() benötigt 3 Informationen.
- Die erste Information ist der String, den Sie Splitten möchten.
- Die zweite Information ist das Array in dem Sie die einzelnen Stringteile speichern möchten.
- Die dritte Information ist das Trennzeichen (delimiter)
Die einzelnen Informationen werden in der Klammer geschrieben und sind voneinander mit einem Komma getrennt. Das untenstehende Beispiel zeigt ihnen, wie Sie token verwenden können.
b$ = "1 Test Tree"
dim d$(1)
n = token(b$,d$(), " ")
for i = 1 to n
print d$(i)
next i
In diesem Beispiel wurde eine Stringvariable b$ erzeugt. Diese Variable hat den Inhalt "1 Test Tree" und der Inhalt soll jetzt anhand des Leerzeichens in Einzelteile geteilt werden.
Um die Einzelteile zu speichern erzeugen wir ein Array mit dem Befehl dim d$(1). Darunter wird jetzt der String anhand des Leerzeichens aufgeteilt und die Anzahl der Teile in die Variable n geschrieben. Die einzelnen Teile des Strings selber, speichern wir in d$(). Danach wird eine Schleife aufgerufen, die die einzelnen Teile des Arrays d$() ausgibt. <
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Tooltips erstellen
Ein Tooltip ist ein Informationstext, der zum Beispiel beim anwählen eines Buttons angezeigt wird. Dies hat den Vorteil dass man eine bestimmte vorgehensweise oder Funktion besser erklären kann.
Ein Beispiel dafür wäre, Sie wollen grafische Buttons verwendet, in denen nur Symbole sind, aber kein Name der Funktion die man damit ausführt. Setzt man nun für diesen Button ein Tooltip ein, wird dieser angezeigt wenn man einen Augenblick mit dem Mauszeiger auf dem Button verweilt. Somit kann man dann dem Benutzer mitteilen, was man mit diesem Button machen kann.
Um Tooltips einzurichten, fügen Sie folgenden Code in Ihr Programm ein:
tooltip "Button Name", "Hilfetext"
Bei Button Name geben Sie den Namen des Buttons an, für welchen dieser Tooltip gedacht ist. Bei Hilfetext geben Sie den Text an, welcher als Tooltip ausgegeben werden soll.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Uhrzeit ermitteln und verwenden
Die Uhrzeit zu ermitteln ist eine ganz einfache Sache, da yab dafür eine feste Variable besitzt, die diese beim Aufrufen ausgibt.
Die Variable heißt time$ und kann wie jede andere Variable intrigiert werden.
Darstellung: Stunde-Minute-Sekunde-Zählwert
Wer nur einen Teil der Ausgabe verwenden oder diese anderes Darstellen möchte, kann diese Variable aufrufen und in einem Array dimensionieren. Dann den Inhalt des Array Splitten und deren Ergebnis neuen Variablen zuweisen:
dim CurrentTime$(1)
time = split(time$, CurrentTime$(), "-")
Stunde$ = CurrentTime$(1)
Minute$ = CurrentTime$(2)
Sekond$ = CurrentTime$(3)
Zaehlwert$ = CurrentTime$(4)
Wir dimensionieren den Array CurrentTime$(1) mit dem Mindestwert 1.
Dann Splitten wir die Variable time$ an jedem Bindestich (-) und fügen das Ergebnis in den Array CurrentTime$() ein.
Danach weisen wir die ermittelten Daten neuen Variablen zu, die Stunde in die Variable Stunde$, die Minute in die Variable Minute$, die Sekunde in die Variable Sekond$ und den Zählwert in die Variable Zaehlwert$. Werte die Sie nicht benötigen, können sie natürlich auch weglassen.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
val
Mit dem Befehl val können Sie einen String in eine Zahlvariable umwandeln. Die Funktion prüft vorher, ob der String einer Zahl (floating point number) entspricht.
a$="5"
print val(a$)
Als erstes wird eine Stringvariable erstellt mit dem Wert 5. In der nächsten Zeile geben wir diese als Zahlvariable aus.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Vorhandensein eines Ordners oder Datei ermitteln
Oftmals ist es sinnvoll, das vorhanden sein eines Ordners oder einer Datei zu ermitteln, da diese für die einwandfreie Funktion der Anwendung notwendig sind. Sollte dieser wichtige Ordner oder die Datei nicht vorhanden sein, könnte man nach deren Überprüfung, diese erstellen.
Für dieses Beispiel verwenden wir die Shell Programme find und basename:
Ordnername$="MeinApp\n"
OrdnernameCheck$=system$("find /boot/apps/Programmkategorie/MeinApp\n")
OrdnernameReady$=system$("basename "+OrdnernameCheck$+"\n")
Wir erstellen eine Variable Ordnername$ mit dem Inhalt "MeinApp" (Hierbei ist es egal ob dieser Name nun ein Ordner oder eine Datei ist).
Danach erstellen wir eine Variable OrdnernameCheck$, in welcher wir die Ausgabe des Shell Programms find speichern. Der Befehl arbeitet auf eine recht einfache Weise, es werden einfach nur der Befehl und dahinter das zu findende Ziel angegeben. Sollte dieses gefunden werden, wird dieses mit dessen Programmpfad ausgegeben und in diesem Fall in der Variablen gespeichert.
|
Sollten Sie einen Ordner suchen, in dem andere Ordner oder Dateien liegen, müssen Sie angeben, wie tief der Befehl find suchen soll. Dazu müssen Sie den Sourcecode wie folgt anpassen: OrdnernameCheck$=system$ ("find /boot/apps/Programmkategorie/MeinApp\n -maxdepth 0") Hiermit geben Sie an das find nicht tiefer als zu dem Angegebenen Ornder suchen soll. |
Da wir bei Ordnername$ nur den Namen des gesuchten Ziels angegeben haben, müssen wir noch die Ausgabe in Variable OrdnernameCheck$ so beschneiden, dass wir nur den Namen des gefundenen Ziels erhalten. Dazu verwenden wir den Shell Befehl basename.
Wir erstellen eine weitere Variable OrdnernameReady$, in welcher wir die Ausgabe des Befehls basename speichern und erhalten wenn das Ziel gefunden wurde, den gleichen Eintrag wie wir in der Variablen Ordnername$ angegeben haben.
Das ganze kann man dann wie folgt mit einer if- Abfrage überprüfen:
| if(Ordnername$=OrdnernameReady$)then Programmablauf wird fortgesetzt else Datei oder Ordner wird erstellt endif |
|
Die verwendeten \n sind deshalb nötig, da viele Ausgaben von Shell Programmen, einen automatischen Zeilenumbruch durchführen. Verwenden Sie also ein Shell Programm, welches bei der Ausgabe einen Zeilenumbruch durchführt, so müssen Sie diesen auch bei dem Suchnamen (Ordnername$) mit berücksichtigen. |
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Vorhandensein eines Ordners oder Datei ermitteln (Variante 2)
Wer sich mal den Sourcecode der yabIDE angesehen hat, hat vielleicht schon diese Variante gesehen. Hier wird eine if Abfrage dazu verwendet, das gesuchte Objekt zu suchen und eine sub Routine dazu verwendet, über das Shell Tool test, dieses zu prüfen.
if(IfExists(filename$)) then
print "ja existiert"
else
print "exisitiert nicht"
fi
Und die dazugehörige Sub Routine:
sub IfExists(filename$)
return not system("test -e "+filename$)
end sub
Im Grunde genommen wird das gesuchte Objekt in der Variablen filename$ gespeichert und eine Abfrage gemacht, bei der gefragt wird ob die Sub Routine IfExists() mit der dazu angegebenen, vorher definierten, Variablen filename$ möglich ist. Da beides vorhanden ist, wird die Sub Routine aufgerufen und in ihr über das Shell Tool Test geprüft ob die Angabe in der Variablen filename$ existiert.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
wait
Mit dem Befehl wait können Sie das Programm, eine von ihnen bestimmte Zeit, anhalten.
print "Test"
wait 5
print "Nach 5 sekunden"
Yab wird an dieser Stelle des Programms 5 sekunden warten, bis es den nächsten Code ausführt.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Window Open
Mit dem Befehl WINDOW OPEN x1,y1 TO x2,y2, ID$, Title$ können Sie ein Fenster erstellen. Sie benötigen dazu die Anfangskoordinaten und Endkoordinaten des Fensters. Die Anfangskoordinaten tragen sie bei x1,y1 und die Endkoordinaten bei x2,y2 ein. Dabei entspricht x1,y1 die linkere obere Ecke und x2,y2 die rechte untere Ecke des Fenster.
Danach tragen Sie einen Namen für die nachfolgenden View's ein. Auf diesen Namen referenzieren Sie zum Beispiel einen Draw Text Befehl. Zu guter Letzt vergeben Sie noch einen Namen für das Fenster.
WINDOW OPEN 100,100 TO 300,300, "Mainview", "Hauptfenster"
In diesem Beispiel wird das Fenster an der Position 100,100 auf den Bildschirm erstellt und das Fenster ist dann 200 Pixel in x und y groß.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Window Close
Mit dem Befehl WINDOW Close ID$ können Sie ein Fenster schließen. Dazu benötigen Sie nur den Namen des Fensters (nicht den Titel). Mit dem unten stehenden Befehl wird das Fenster aus dem Beispiel Window open geschlossen.
WINDOW close "Mainview"
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Import / Export verwenden
Die Import- / Export-Funktion in yab soll ihnen das Programmierleben erleichtern, indem Sie Subroutinen aus ihrem Programmcode in andere Dateien auslagern und so später besser bearbeiten können.
Importieren von Subroutinen:
import ausgelagerte_sub
Variable=10
Variable2=20
ausgelagerte_sub()
Der Dateiname der zu importieren Datei muss gleich dem Dateinamen sein, d.h. die Datei für die obengenannte Subroutine muss wir folgt lauten:
ausgelagerte_sub.yab
In der Datei ausgelagerte_sub.yab können Sie jetzt die Subroutine beschreiben.
export sub ausgelagerte_sub()
print "Hallo zusammen"
end sub
Damit yab weiß das Sie die Subroutine exportieren und in einem anderen yab Programm importieren und ausführen möchten müssen Sie vor der Subroutine noch export, wie im obigen Beispiel, vorschreiben. Der zuvor gezeigte Quellcode gibt nach dem Import Hallo zusammen aus.
Wenn Sie jetzt Variable in der ausgelagerten Subroutine verwenden möchten, so müssen Sie die Variablen bekannt machen und aus dem Hauptprogramm übergeben.
Hauptprogramm.yab
import ausgelagerte_sub
Variable=10
Variable2=20
ausgelagerte_sub(Variable, Variable2)
ausgelagerte_sub.yab
export sub ausgelagerte_sub(Variable, Variable2)
print Variable
print Variable2
end sub
Erst jetzt kann die Subroutine mit den Variablen umgehen. Sie können jetzt Berechnungen oder sonstige Dinge mit den Variablen machen. Sie können auch in der Datei ausgelagerte_sub.yab auch noch weitere Subroutinen erstellen und verwenden. Die weiteren Subroutinen müssen dann aber von der ersten Subroutine, die Exportiert worden ist, aufgerufen werden.
zurück zur Übersicht
zurück zum Stichwortverzeichnis
Stichwortverzeichnis
zurück zur Übersicht |
Bereitgestellt durch BeSly, der BeOS & Zeta Wissensbasis. |