home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
OS/2 Shareware BBS: InfoMgt
/
InfoMgt.zip
/
kim21.zip
/
KIM21.INF
(
.txt
)
< prev
next >
Wrap
OS/2 Help File
|
1995-11-01
|
360KB
|
14,449 lines
═══ 1. Info Ъber.. ═══
Online-Handbuch fБr Datenbankbefehle
1. KIM/2 Handuch 1.2
ΓòÉΓòÉΓòÉ 2. Updates ab Version 2.1 ΓòÉΓòÉΓòÉ
Update Info
Sehr geehrter Anwender,
KIM wird stetig weiterentwickelt. An dieser Stelle werden Оnderungen, die
noch nicht in der Hauptbeschreibung fixiert sind, in Kurzform beschrieben.
Оnderungen werden nach einen halben Jahr aus dieser Ъbersicht entfernt,
und in die HauptБbersicht Бbernommen.
Darstellung der Variablen :
test,zeile (numerisch)
text$,test$ (zeichen)
-----------------------------------------------------------------------------
September 1995
-----------------------------------------------------------------------------
LДnge des Inhalts einer Zeichenkettenvariable von 256 Zeichen auf
512 Zeichen erhФht.
-----------------------------------------------------------------------------
BildschirmauflФsung ermitteln :
-------------------------------
get_display spalten,zeilen
-----------------------------------------------------------------------------
VerschlБsseln von Daten :
-------------------------
<Key> ist die Grundlage der VerschlБsselung und EntschlБsselung
Zeichenkette :
crypt key$,text$
Zeichenketten-Array :
crypt_array key$,arr$,start,ende
z.B. VerschlБsseln
text$="Dies ist ein Test" : key$="Mary"
crypt key$,text$
FБr die EntschlБsselung benutzen Sie den gleichen <key$>
crypt key$,text$
-----------------------------------------------------------------------------
Zahlenvariablen werden bei Stringaddition in Strings umgewandelt !
a=5
b=4
text= a + "und" + b
-----------------------------------------------------------------------------
Bestimmen der Mausposition
get_mouse_pos x,y
-----------------------------------------------------------------------------
Multitasking mit KIM !
Sehen Sie hierfБr das Beispiel : NEW21A1.KIM
-----------------------------------------------------------------------------
Die rechte Maustaste abfragen und ein Popup-MenБ an der Mausposition
zeigen :
modul mouse_right()
deffloat x,y,dx,dy
get_mouse_pos x,y
rem "Pixel" eine neue Eigenschaft !!!
def_popup_menu "pop",x,y;"pixel"
def_popup_item "p1"," Programm beenden"
def_popup_item "p2"," Beep "
def_popup_item "p3"," Multitasking"
add_item "pop","p1","p2","p3"
win_paint "pop"
endmod
-----------------------------------------------------------------------------
Oktober 1995
-----------------------------------------------------------------------------
Neue Befehlsparameter fБr IGETREC_ARRAY
igetrec_array dbnr,flag,trenn$,_felder$,_arr$,start,ende,index1,... ;len1,...
;_pos,op,indexnr,verglwert$
Eingabeparameter :
dbnr Datenbank-Nr.
flag 0=vorwДrts / 1=rБckwДrts blДttern
trenn$ Trennzeichen
_felder$ Datenbankstruktur
index1..n Felder (Index)
len1..n LДngenangaben
op Operator 0 entspricht =
1 entspricht >
-1 entspricht <
indexnr Entspricht dem Feld auf dem die Indexdatei existiert
fБr den Vergleichswert <verglwert$>
Wird die Indexnr als negativer Wert angegeben, erfolgt
ein numerischer Vergleich.
verglwert$ Vergleichswert fБr Auswertung
Ausgabeparameter :
_arr$ DatensДtze von <start> bis <ende>
_pos Array muss gleiche GrФсe haben wie _arr$
Positionen in der Datenbank fБr IGO_NR,..
Nun was kann man machen ? Mit IGETREC_ARRAY - Funktionen kФnnen Sie eine
selektive Auswahl von DatensДtze aus einer Datenbank holen.
Zum Beispiel Sie mФchten aus einer Kundendatenbank alle Kunden selektieren
deren Kundennummer grФсer, kleiner oder gleich 10000 ist.
DafБr ist es wichtig, daс auf der Kundennummer ein Index besteht und
der Index der aktive Index ist.
Weiterhin mБssen Sie mit IREAD eine Positionierung durchfБhren, bevor
Sie IGETREC_ARRAY benutzen.
Beispiel : Kunden < 20000
istart 1,_felder
iread 1,ok," 20000",_felder
igetrec 1,_felder
igetrec_array 1,0,"-",_felder,_arr,0,100,1,4,5,6 ;10,20,30,20;_pos,-1,-1,"20000"
Beispiel : Kunden > 10000
istart 1,_felder
iread 1,ok," 10001",_felder
igetrec 1,_felder
igetrec_array 1,0,"-",_felder,_arr,0,100,1,4,5,6 ;10,20,30,20;_pos, 1,-1,"10000"
Beispiel : Kunden = 10000
istart 1,_felder
iread 1,ok," 10000",_felder
igetrec 1,_felder
igetrec_array 1,0,"-",_felder,_arr,0,100,1,4,5,6 ;10,20,30,20;_pos, 0,-1,"10000"
Bei diesen Vergleichen ist folgendes zu beachten : In der Datenbank ist das
Indexfeld ein Charakterfeld. FБr den Vergleich werden die Werte in Zahlen
gewandelt, da die Indexnr. als negativer Wert angegeben ist.
-----------------------------------------------------------------------------
LФschen einer Zeile in einer Tabelle :
DEL_TABLE_REC "table_id"
LФscht eine Zeile aus einer Tabelle, dabei wird das verknБpfte Datenarray
auch korrigiert.
-----------------------------------------------------------------------------
ΓòÉΓòÉΓòÉ 3. Hinweise zur Probierversion ΓòÉΓòÉΓòÉ
Probierversion
Allgemeines
Falls Sie die KIM Testversion bestellt haben, ist der folgende Abschnitt fБr Sie.
Sehr geehrter Tester,
KIM ist eine leistungsfДhige Programmiersprache fБr OS/2, DOS und Windows.
In der Orginalversion wird ein 400 seitiges deutsches Handbuch mitgeliefert.
Das Handbuch fБhrt anhand mehrerer Beispiele in die Programmierung von KIM ein.
FБr den erfahrenen Programmierer steht ein ausfБhrlicher Referenzteil
zu VerfБgung. Weiterhin erhalten Sie ein lizenzfreies Runtime-Kit um ihre
Programme an Dritte weiterzugeben.
FБr den elektronischen Support bieten wir eine Mailbox an.
Der Preis fБr die Testversion wird auf den Preis der Orginalversion angerechnet.
KIM erhalten Sie bei :
EDV-BБro Kohlenbach
Hauptstr. 5
90547 Stein
Tel. 0911 - 68894-01 (10 - 15 Uhr)
Fax. 0911 - 68894-03
oder
Software Gibson
Tel. 09183 - 40052
Fax. 09183 - 242
ΓòÉΓòÉΓòÉ 4. Der Editor ΓòÉΓòÉΓòÉ
Der Editor
Allgemeine Hinweise
Der KIM-Editor ist ein kleines Textverabeitungsprogramm, mit
dessen Hilfe Sie den Code fБr Ihre KIM-Programme entwickeln,
schreiben und speichern kФnnen. SelbstverstДndlich besitzt er
nicht die umfangreichen Optionen eines Systems wie Word oder
Star Writer. Vielmehr ist dieser Editor speziell auf die bei
der Programmierung mit KIM auftretenden BedБrfnisse
zugeschnitten. Neben normalen Funktionen wie Ausschneiden,
Kopieren und EinfБgen von Text stehen besondere Optionen wie
die Aktivierung des KIM-Debuggers oder der Aufruf einer
Labeltabelle zur VerfБgung.
Der KIM-Editor entspricht in seiner Bedienung den Standard-
Editoren der entsprechenden Betriebssysteme (also MS-Write oder
OS/2-Systemeditor) und sollte Ihnen deshalb gelДufig sein. Wir
wollen hier nur auf die notwendigsten Grundlagen eingehen und
verweisen Sie auf die HandbБcher zu Ihren Betriebssystemen.
Aufruf
Unter OS/2 :
Щffnen Sie den Ordner "KIM Datenbanksystem" und klicken Sie
auf das Symbol : KIM-Editor.
Unter DOS :
Wechseln Sie in das Verzeichnis KIMxx mit:
cd KIMxx (dann Enter-Taste drБcken)
Dies ist nicht notwendig, falls Sie in der Datei "Autoexec.bat"
eine Pfadzuweisung PATH=\KIMxx angegeben wurde. Rufen Sie nun
den Editor auf:
KE (dann Enter-Taste drБcken)
Es erscheint der KIM-Editor auf Ihrem Monitor:
Bereits vom Дuсerlichen her gleicht dieser Editor ziemlich den
Standardeditoren der jeweiligen Betriebssysteme. Mit Hilfe des
Systembuttons links oben kФnnen Sie die GrФсe der
ProgrammoberflДche verДndern, zu anderen Programmen wechseln
oder das Programm beenden (vgl. auch das Kapitel Бber Fenster
und ProgrammoberflДchen). Der Maximierungs- und der
Minimierungsbutton rechts oben erlauben die Vollbild- bzw. die
Symboldarstellung des Programmes. Ъber die Scrollbars kann im
Eingabefenster vorhandener Text durch das Fenster gerollt und
somit vollstДndig eingesehen werden. In der Meldezeile wird der
Name der jeweils geladenen Datei angezeigt. Haben Sie bei einer
Neuerstellung einer Datei noch keine Speicherung vorgenommen,
erscheint hier der Name "Noname.kim".
Texteingabe
Sie geben den Text in das Eingabefenster ein. Bewegen Sie dazu
den Mauscursor in dieses Fenster und klicken Sie mit der linken
Maustaste einmal. Es erscheint ein Eingabezeichen links oben im
Fenster. Nun kФnnen Sie ganz normal Text Бber die Tastatur
eingeben.
Um einen geschriebenen Text zu bearbeiten, muс er zuvor
markiert werden. Dies gelingt durch DrБcken der linken
Maustaste und Hinwegbewegen des Mauscursors Бber den
gewБnschten Text oder durch DrБcken der SHIFT-Taste und Bewegen
des Cursors mittels der Cursortasten (Pfeiltasten).
Ein markierter Text kann durch BetДtigen der Tastenkombination
STRG+X ausgeschnitten werden. Mit STRG+V fБgen Sie einen Text
aus dem Zwischenspeicher wieder an der Cursorposition in den
Text ein. Mit STRG+C wird ein markierter Text kopiert.
MenБ Datei
Im MenБ Datei finden Sie Optionen zur Neuerstellung,
Speicherung und zum Laden von Dateien. ZusДtzlich ist hier eine
Option zum Beenden des Programmes enthalten.
Durch Aktivieren des MenБpunktes NEU wird eine eventuell im
Editierfenster vorhandene Datei entfernt und somit eine
Neuerstellung einer Datei mФglich. Daher erfolgt zunДchst eine
Abfrage, ob Sie die alte Datei speichern mФchten, bevor der
Inhalt des Editierfensters gelФscht wird.
Mit dem Befehl LADEN kФnnen Sie eine bereits vorhandene KIM-
Datei in den Editor holen. Es erscheint ein Auswahlfenster, in
welchem Sie den Namen und den Pfad der gewБnschten Datei
angeben kФnnen. Durch BestДtigung (Klick auf den OK-Button)
wird die Datei geladen.
Sie besitzen zwei MФglichkeiten der Textspeicherung. Mit
SPEICHERN fБhren Sie eine Schnellspeicherung durch. KIM
verwendet hierbei als Dateinamen den im Meldefenster
vorgegebenen. Haben Sie die Datei zuvor noch nie gespeichert,
erhДlt sie dadurch den Namen "Noname.kim". Einen neuen Namen
kФnnen Sie einer Datei beim Aufruf von SPEICHERN UNTER
verleihen. In diesem Falle Фffnet sich wieder ein
Auswahlfenster, in welchem Sie Pfad und Verzeichnis der Datei
selektieren kФnnen.
Wenn Sie den Editor verlassen mФchten, rufen Sie QUIT auf. Es
erscheint noch eine Abfrage, ob Sie den Editor verlassen
mФchten. Durch BetДtigen des OK-Buttons wird das Programm
beendet.
MenБ Bearbeiten
In diesem MenБ finden Sie Optionen zum Suchen und Tauschen von
Textbegriffen.
Wenn Sie den Befehl SUCHEN aktivieren, Фffnet sich ein
Abfragefenster.
Dort geben Sie den zu suchenden Begriff ein und bestДtigen Ihre
Wahl durch DrБcken des OK-Buttons. KIM springt dann im
Editierfenster zu der Position, an welcher sich der gesuchte
Begriff befindet.
Bei der Wahl der Option TAUSCHEN Фffnet sich ein Дhnliches
Fenster, welches aber zusДtzlich noch ein Feld mit der
Bezeichnung "Ersetzen durch" beinhaltet.
Geben Sie im Feld "Suchtext" den zu tauschenden Begriff vor und
im Feld "Ersetzen durch" den Begriff, welcher dafБr eingesetzt
werden soll. Nach DrБcken des OK-Buttons wird im gesamten Text
der entsprechende Tausch vorgenommen.
MenБ Start
Wenn Sie mit der Maus diesen Punkt anwДhlen, wird der im
Editierfenster vorhandene Quellcode vom KIM-Interpreter
verarbeitet und das Бber diesen Sourcecode erstellte Programm
ausgefБhrt. Vor Aufruf dieses Befehls sollten Sie ihre Datei
sichern, da es bei Programmfehlern zu einem Absturz des Editors
und damit zu einem Datenverlust kommen kann. Ist das Бber
diesen Befehl gestartete Programm beendet, kehren Sie
automatisch zum Editor zurБck.
MenБ Optionen
In diesem MenБ finden Sie eine Anweisung, welche Ihnen bei der
AufspБrung von Fehlern in Ihrem Programmcode hilft. Wenn Sie
die Option FEHLERANALYSE wДhlen, untersucht KIM den im
Editierfenster vorhandenen Code selbstДndig auf
Verschachtelungsfehler bei IF-ENDIF- und FOR-NEXT-Schleifen. Es
wird БberprБft, ob zu jedem IF das zugehФrige ENDIF und zu
jedem FOR das entsprechende NEXT vorhanden ist. Entdeckt das
Programm dabei einen Fehler, werden Sie mit genauer
Zeilenangabe darauf hingewiesen.
Labeltabelle
Mit diesem Befehl ist es Ihnen mФglich, sich schnell in einem
Programmcode zu bewegen. Bei Aktivierung erscheint ein
AuswahlmenБ mit allen im Text definierten Modulen. Sie kФnnen
durch Selektieren eines gewБnschten Modulnamens Бber Mausklick
sofort zur Position im Programmcode springen, an welcher das
Modul definiert ist. Das Auswahlfenster schlieсt sich dabei
automatisch.
ΓòÉΓòÉΓòÉ 5. Der Maskengenerator ΓòÉΓòÉΓòÉ
Der Maskengenerator
Mit dem bisher in diesem Kapitel erlernten sind Sie jederzeit
in der Lage, ProgrammoberflДchen mit vollstДndigen
Eingabefeldern auszustatten. Sicher sind Ihnen dabei aber
einige Dinge aufgefallen, die die Erzeugung dieser OberflДchen
alles andere als bedienerfreundlich machen. So mБssen Sie bei
der Definition der einzelnen Objekte im Programmcode
bekanntlich die genaue Position derselben im zugewiesenen
Fenster festlegen. Dies ist aber gar nicht so einfach, da Sie
hierfБr mit einer recht unanschaulichen Maсeinheit (Zeichen pro
Zeile) jonglieren mБssen. Bis das Ergebnis auf dem Bildschirm
zu Ihrer Zufriedenheit ausfДllt, dБrften mehrere AnlДufe
notwendig sein.
Eine MФglichkeit, die einzelnen Objekte graphisch auf dem
Monitor zu definieren wДre dabei natБrlich sehr hilfreich.
Deswegen steht Ihnen im KIM-Editor ein Дuсerst mДchtiges
Utensil zur VerfБgung, der Maskengenerator. Mit Ihm kФnnen Sie
auf graphischen Wege eine ProgrammoberflДche mit Eingabefeldern
und zusДtzlichen Objekten definieren und automatisch den
entsprechenden Programmcode dafБr erzeugen lassen.
Starten
Um den Maskengenerator zu starten, geben Sie auf der DOS- oder
OS/2-Ebene nach dem Promptzeichen ein:
KIM KMASK
oder
Starten Sie den Editor und wДhlen den MenБpunkt Maskengenerator.
Die MenБleiste
Im oberen Teil des Bildschirms erkennen Sie die MenБleiste des
Maskengenerators. Sie kФnnen zwischen den Punkten "Datei",
"Objekt_neu", "Bearbeiten" und "Code" wДhlen. Einen MenБpunkt
wДhlen Sie aus, indem Sie den Mauszeiger auf den gewБnschten
Befehl bewegen und die linke Maustaste drБcken. Es Фffnet sich
dann ein Pull-Down-MenБ bzw. wird der Befehl Code ausgefБhrt.
Optional gelingt die Aktivierung Бber die Tastatur, wenn Sie
die ALT-Taste gleichzeitig mit dem im Befehl unterstrichenen
Buchstaben drБcken, also z.B. ALT + D, um das MenБ "Datei" zu
Фffnen.
Das MenБ Datei
Im MenБ Datei befinden sich folgende Befehle: "Neu", "Laden",
"Speichern", "Speichern unter" und "Quit". Diese Befehle lassen
sich durch Klick mit der linken Maustaste auf die gewБnschte
Anweisung aktivieren. Mit der Tastatur fБhren Sie die Befehle
durch gleichzeitiges DrБcken der SHIFT-Taste und des jeweils
unterstrichenen Buchstaben im Befehlswort aus, z.B. beenden Sie
den Maskengenerator durch DrБcken von SHIFT + Q.
Neu :
Wenn sie den Befehl "Neu" aktivieren, wird der Inhalt des
Editors gelФscht, und Sie kФnnen eine neue Programmaske
erstellen. Falls Sie gerade eine andere Maske bearbeitet haben,
fragt das Programm vor dem LФschen, ob die alte Maske
gespeichert werden soll oder nicht.
Laden:
Sie bekommen als mФgliche ladbare Dateien alle Files angeboten,
die die Endung *.msk besitzen und im Startverzeichnis
C Es ist aber
selbstverstДndlich mФglich, Dateien aus anderen Verzeichnissen
zu laden. Sie kФnnen das aktuelle Verzeichnis durch Klick auf
die beiden Punkte (entspricht dem DOS-Befehl cd..) im Feld
"Dateien" wechseln. Klicken Sie auf die gewБnschte Datei. Diese
erscheint dann im Feld "Datei/Pfad" und ist somit selektiert.
Durch Klick auf die OK-Taste wird sie in den Maskengenerator
geladen. Ein Klick auf den ABBRUCH-Button bringt Sie in das
HauptmenБ zurБck, ohne daс eine Datei geladen wurde.
Speichern:
Eine bearbeitete Datei kann mit Hilfe dieser Option
schnellgespeichert werden. Wenn Sie den Befehl Бber Mausklick
oder durch DrБcken von SHIFT + S aktivieren, erfolgt sofort
eine Speicherung der Datei ohne weitere RБckfrage. Als
Dateiname wird derjenige verwendet, der in der Meldezeile
unterhalb der MenБleiste aufgefБhrt ist. Haben Sie noch keine
Speicherung vorher durchgefБhrt, erhДlt die Datei den Namen
"Noname.kim".
Speichern unter:
Mit dieser Option kФnnen Sie eine Datei mit einem beliebigen
Namen in einem beliebigen Verzeichnis speichern. Der Befehl
lДсt sich durch Mausklick darauf oder mit Hilfe der
Tastenkombination SHIFT + U aufrufen. Es erscheint ein
Meldungsfenster.
BestДtigen Sie die Meldung mit OK (Mausklick darauf, ENTER-
Taste oder "O" drБcken), dann erscheint das bereits von dem
Befehl "Laden" bekannte UntermenБ. WДhlen Sie wie dort
beschrieben das gewБnschte Zielverzeichnis aus und geben Sie in
das Feld Datei/Pfad den zukБnftigen Dateinamen ein. Sind alle
Eingaben zu Ihrer Zufriedenheit getДtigt, bestДtigen Sie mit
"OK". Sie kФnnen das UntermenБ jederzeit mit ABBRUCH (Mausklick
darauf oder ESC-Taste drБcken) verlassen. Dann wird allerdings
keine Speicherung vorgenommen.
Quit:
Wenn Sie den Maskengenerator verlassen mФchten, klicken Sie mit
der Maus den Befehl QUIT an. Optional lДсt die Anweisung sich
mit der Tastenkombination SHIFT + Q aktivieren. Es wird dann
nachgefragt, ob Sie tatsДchlich den Maskengenerator verlassen
wollen.
Wenn Sie den Maskengenerator noch nicht verlassen mФchten,
bringt Sie der Button "ABBRUCH" ohne weitere Konsequenzen in
das Programm zurБck. BestДtigen Sie Ihre Entscheidung mit "OK",
so verlassen Sie den Maskengenerator.
Erstellen von Objekten
Beim Aufruf des Maskengenerators erscheint das eigentliche
Editierfeld vФllig leer und bereit fБr Ihre Eingaben. Das
Editierfeld wird spДter bei der Codeerstellung als
Programmfenster verwendet, in welches alle anderen zu
definierenden Objekte eingefБgt werden.
Ein Aufruf des MenБs OBJEKT_NEU zeigt Ihnen eine Liste aller
OberflДchenobjekte, die mit Hilfe des Maskengenerators
definiert werden kФnnen:
Feldname:
Es wird eine Feldbezeichnung erstellt (entspricht dem Befehl
DEF_PROMPT).
String:
Es wird ein allgemeines Eingabefeld erstellt (entspricht
dem Befehl DEF_STRING).
Datum:
Es wird ein Datumsfeld erstellt (entspricht
DEF_INPUT_DATE).
Zeit:
Es wird ein Zeitfeld erstellt (entspricht DEF_INPUT_TIME).
Text:
Es wird ein Textfeld erstellt (entspricht DEF_TEXT).
Gruppe:
Ein Gruppenobjekt wird definiert (analog zu der bei Fenster
und ProgrammoberflДchen besprochenen.
Push-Button:
Ein Push-Button wird erzeugt (entspricht DEF_BUTTON).
Radio-Button:
Ein Radiobutton wird definiert (dies entspricht dem Befehl
DEF_BUTTON mit dem FLAG "RADIO").
Checkbox:
Ein Checkbox-Button wird erzeugt (dies entspricht dem Befehl
DEF_BUTTON mit dem FLAG "CHECKBOX").
Wenn Sie eines dieser Objekte durch Mausklick darauf (oder mit
der ENTER-Taste nach Positionierung des Aktivierungsbalkens auf
das Objekt) auswДhlen, erscheint dieses links unten im
Editierfenster des Maskengenerators:
Bearbeiten von Objekten
NatБrlich ist die Erzeugung eines Maskenobjektes nur der erste
Schritt. Die Objekte mБssen nun an die richtige Position im
Fenster gesetzt und gegebenenfalls verДndert werden.
Verschieben eines Objekts
Ein Objekt lДсt sich verschieben, indem Sie mit der linken
Maustaste in das Objekt klicken, diese gedrБckt halten und das
Objekt zum neuen Standort auf dem Bildschirm ziehen. Wenn Sie
die linke Maustaste loslassen, rastet das Objekt an der neuen
Position ein. Um das Objekt endgБltig an einer Position zu
fixieren und versehentliches Verschieben zu vermeiden, wДhlen
Sie aus dem MenБ BEARBEITEN den Befehl "Fixieren" aus
(Mausklick darauf oder durch DrБcken der Tasten SHIFT + F). Das
Objekt kann dann nicht mehr bearbeitet werden.
Diese Fixierung lДсt sich durch die Anweisung "Position neu" im
MenБ BEARBEITEN wieder rБckgДngig machen. Haben Sie diese
Option mittels Mausklick oder Tastenkombination SHIFT + P
aktiviert, lДсt sich das Objekt wieder verschieben und
bearbeiten.
GrФсenДnderung eines Objekts
Sie klicken den Rand des Objekts mit der linken Maustaste an,
halten diese gedrБckt und ziehen den Rand in die gewБnschte
Richtung. Das Objekt beginnt sich nun zu vergrФсern oder zu
verkleinern.
LФschen eines Objekts
WДhlen Sie das entsprechende Objekt durch einen Doppelklick mit
der linken Maustaste darauf aus. Anschlieсend aktivieren Sie
die Option "LФschen" aus dem MenБ BEARBEITEN (durch Mausklick
darauf oder mit SHIFT + L). Haben Sie das Objekt zuvor nicht
aktiviert, erhalten Sie eine Fehlermeldung mit der Mitteilung,
daс der Befehl nicht durchfБhrbar ist.
Оnderung der Objekteigenschaften
Das mit OBJEKT_NEU definierte Objekt wird standardmДсig
erstellt. NatБrlich kФnnen Sie dieses Objekt im Maskengenerator
noch individuell gestalten.
Sobald Sie ein Objekt erstellt haben, erscheint es als
rechteckiger Kasten links unten im Editierfenster. Innerhalb
des Objekts befindet sich die ID-Kennung, die vom
Maskengenerator routinemДсig aus der Art des Objekts und der
aktuellen Objektzahl gebildet wird. Haben Sie z.B. als drittes
Objekt ein Datumsfeld definiert, so erhДlt dieses die Kennung
"Datum3".
Betrachten Sie die Combobox rechts in der Meldezeile. Dort
finden Sie nun ebenfalls die ID-Kennung des neu erstellten
Objekts. Dieser Combobox kommt nun eine besondere Bedeutung bei
der Оnderung von Objekteigenschaften zu. MФchten Sie an einem
Objekt VerДnderungen vornehmen, so Фffnen Sie die Combobox
durch einen Mausklick auf den Pfeil rechts von der Box. In der
Combobox finden Sie die ID-Kennungen aller definierten Objekte.
Klicken Sie auf die Kennung des entsprechenden Objekts. Diese
erscheint nun auf als aktives Objekt oben in der Combobox.
Gleichzeitig Фffnet sich ein UntermenБ, das Оnderungen dieses
Objekts erlaubt.
Im Feld "ID-Kennung" finden Sie die vom Maskengenerator
routinemДсig erstellte Bezeichnung fБr das definierte Objekt.
Sie kФnnen diese Дndern, indem Sie den alten Text markieren und
durch DrБcken der ENTF-Taste lФschen. Nun ist das Feld fБr die
Eingabe einer neuen Bezeichnung frei. Beachten Sie aber bitte,
daс Sie unbedingt eine ID-Kennung fБr das Objekt angeben
mБssen, sonst kann der Programmcode fБr die Maske nicht korrekt
erstellt werden.
Im nДchsten Feld "Inhalt" kФnnen Sie nach Wahl dem Objekt eine
zusДtzliche Bezeichnung bzw. einen Vorgabetext verleihen (je
nach Art des Objekts; Buttons und Gruppen erhalten eine
Zusatzbezeichnung, Felder einen Vorgabetext). Eine Eintragung
in dieses Feld ist aber nicht zwingend erforderlich. Geben Sie
nichts an, wird im Programmcode an der entsprechenden Position
ein Leerstring Бbergeben. Im Editierfeld des Maskengenerators
erscheint nun im entsprechenden Objekt statt der ID-Kennung der
hier eingegebene Inhalt.
Die beiden langen freien Felder sind fБr die Definition von
zusДtzlichen Eigenschaften des Objekts vorgesehen. Diese kФnnen
Sie wie bereits besprochen Бber FLAGS definieren. Einige FLAGS
sind bereits in diesem UntermenБ aufgefБhrt. Eine vollstДndige
Liste aller in KIM verfБgbaren FLAGS finden Sie im Abschnitt
"Fenster und ProgrammoberflДchen".
Geben Sie die gewБnschten FLAGS wie gezeigt in AnfБhrungs- und
Schluсzeichen ein. MФchten Sie mehrere FLAGS definieren,
trennen Sie diese voneinander durch Kommata.
Haben Sie die Objekteigenschaften zu Ihrer Zufriedenheit
verДndert, beenden Sie das UntermenБ "Eigenschaften" durch
Mausklick auf den Button "Schlieсen".
Erstellen des Programmcodes
Wenn Sie die vollstДndige Programmaske mit Hilfe des
Maskengenerators erstellt haben, besteht der letzte Schritt
darin, den dazugehФrigen Programmcode zu erzeugen. Auch dies
Бbernimmt der Maskengenerator selbstДndig fБr Sie.
Klicken Sie in der MenБleiste den Befehl CODE an. Analog kФnnen
Sie durch DrБcken der Tastenkombination ALT + C diese Anweisung
aktivieren. Es Фffnet sich das bereits vom Befehl Laden her
bekannte UntermenБ, in welchem Sie den Namen der zu
speichernden Datei sowie das Verzeichnis, in das die Datei
geschrieben werden soll, angeben kФnnen. Sind Sie mit Ihren
Angaben zufrieden, klicken Sie auf den OK-Button. Der die Maske
beschreibende Code wird daraufhin erstellt. Ist der Vorgang
beendet, kehren Sie zum Maskengenerator zurБck, wo Sie weitere
Eingaben tДtigen oder mit QUIT das Programm beenden kФnnen.
Bearbeiten des Codes
NatБrlich kann der Maskengenerator nicht einen vollstДndigen
Code fБr eine ganze ProgrammoberflДche erzeugen. So besitzen
Sie keine MФglichkeit, MenБleisten, Toolbars oder Дhnliches mit
dem Maskengenerator zu definieren. Diese Оnderungen mБssen
nachtrДglich "per Hand" eingegeben werden. Des weiteren werden
die zu den Feldern gehФrenden Variablen nicht selbstДndig
generiert. Diese mБssen nachtrДglich in den Code eingefБgt
werden.
Laden Sie hierzu die mit dem Maskengenerator erstellte Datei in
den normalen KIM-Editor und Дndern Sie den Programmcode
entsprechend.
Individuelle Gestaltung
Der Maskengenerator wird Ihnen unverschlБsselt mitgeliefert.
Dadurch erhalten Sie die MФglichkeit, dieses Utility nach Ihren
WБnschen individuell umzugestalten. Gehen Sie aber bitte mit
Оnderungen im Quellcode des Maskengenerators sorgfДltig und
vorsichtig um und variieren Sie nur die hier besprochenen
Teile, wenn Sie sich noch nicht so sicher im KIM-Programmcode
fБhlen. Denken Sie daran, daс ein einziger gravierender Fehler
im Code das Programm zum Absturz bringt.
Wir empfehlen Ihnen deshalb, den ursprБnglichen Programmcode
des Maskengenerators vor Оnderungen in eine neue Datei zu
kopieren, so daс Sie im Falle eines durch Ihre Оnderungen
verursachten Programmabsturzes immer noch im Besitz eines
funktionsfДhigen Programms sind.
GrФсe des Editierfensters
Wie bereits besprochen stellt das Editierfenster des
Maskengenerators die OberflДche Ihres zukБnftigen Programms
dar. In dieses Fenster positionieren Sie Ihre Maskenobjekte
graphisch an die gewБnschten Stellen.
Wenn Sie die GrФсe dieses Fensters Дndern mФchten, mБssen Sie
sich in den Quellcode des Maskengenerators begeben. Laden Sie
dazu die Datei KMASK.KIM in den KIM-Editor.
Bewegen Sie nun den Cursor in die Codezeile 28. Dort werden die
Variablen _x, _y, _breite und _hoehe definiert. Ъber diese
Variablen wird die GrФсe des Editierfensters gesteuert. In den
Codezeilen 29 bis 32 finden Sie als Voreinstellungen, daс das
Fenster von der Position 2,2 aus 75 Zeichen breit und 15
Zeichen hoch sein soll. Die Position der linken oberen
Fensterecke sollten Sie nach MФglichkeit nicht Дndern, da
hiermit das Fenster so in den Maskengenerator eingefБgt wird,
daс man die MenБ- und Meldeleiste gut erkennen kann. Nach
Belieben verДndern kФnnen Sie jedoch die Breite (Бber _breite)
und HФhe (Бber _hoehe) des Editierfensters. Оndern Sie dazu
entsprechend den Variableninhalt in den Codezeilen 31 und 32.
Vorgabe fБr Dateinamen
Wenn Sie den Maskengenerator neu starten oder die MenБoption
"Neu" wДhlen, wird der Inhalt des Editierfensters gelФscht und
die neue Datei erhДlt den Vorgabenamen "Noname.Kim". Wenn Sie
einen anderen Dateinamen als Vorgabe wДhlen mФchten, laden Sie
wie beschrieben mit KE KMASK.KIM den Quellcode in den KIM-
Editor und setzen den Cursor in die Zeile 35. Dort finden Sie
die Wertzuweisung _dateiname = "Noname.Kim". Оndern Sie diese
Codezeile, indem Sie der Variablen als Inhalt einen Namen Ihrer
Wahl zuweisen.
Farbeinstellungen des Maskengenerators
Die Farbvorgaben des Maskengenerators lassen sich auf
unterschiedliche Weise Дndern, entweder Бber das Betriebssystem
oder durch Manipulation des Quellcodes.
Оnderung Бber Windows:
Wenn Sie die Windows-Version von KIM besitzen, so Дndern Sie
die Farbeinstellungen wie folgt. Rufen Sie das Fenster
Hauptgruppe auf. Dort klicken Sie das MenБ Systemsteuerung an.
In diesem MenБ rufen Sie den Punkt Farben auf. Dort kФnnen Sie
alle Farben des Programmfensters Дndern. Bedenken Sie aber, daс
so vorgenommene Оnderungen fБr alle Windows-Programme sowie fБr
Windows selbst gБltig sind.
Оnderung Бber OS/2:
Rufen Sie den Maskengenerator auf und gehen Sie in die Ansicht
Desktop - Icon View. Von dort starten Sie das Utility Color
Palette. Bewegen Sie den Mauszeiger auf die gewБnschte Farbe,
drБcken die rechte Maustaste, halten diese gedrБckt und ziehen
Sie den Cursor in den Fensterbereich des Maskengenerators, dem
Sie die neue Farbe zuweisen wollen. Lassen Sie dann die rechte
Maustaste los. Der entsprechende Fensterbereich besitzt nun die
neue Farbe. Im Gegensatz zu Windows ist eine solche
FarbverДnderung bei OS/2 nur fБr das bearbeitete Programm
gБltig.
Оnderung Бber den Quellcode:
Laden Sie mit KE KMASK.KIM den Quellcode in den KIM-Editor.
Bewegen Sie den Cursor in die Zeilen 39 und 40. Dort befinden
sich die Definitionen von Farbpaletten. Оndern Sie die hier die
Vordergrund- und Hintergrundfarben nach Ihren Vorstellungen.
Die entsprechenden Farbcodes finden Sie in der Farbtabelle im
Anhang.
Beachten Sie bitte, daс sich diese Farbpaletten im Originalcode
nur auf die mit dem Maskengenerator neu erstellten
Maskenobjekte beziehen. MФchten Sie auch andere Bestandteile
des Programmfensters beeinflussen, mБssen Sie den
entsprechenden Definitionsbefehl fБr dieses Objekt im Code
suchen, dort das FLAG "COLOR ON" anfБgen und anschlieсend mit
COLOR ITEM diesem Objekt die gewБnschte Farbpalette zuweisen.
NДheres Бber dieses Vorgehen finden Sie im Abschnitt 4.3. des
Kapitels Бber ProgrammoberflДchen und Fenster.
Ein Hinweis hierzu: Die meisten Definitionsbefehle fБr die
Programmbestandteile finden Sie im Modul fenster_inhalt. Das
eigentliche Programmfenster wird in der Codezeile 44 definiert.
ΓòÉΓòÉΓòÉ 6. Der Debugger ΓòÉΓòÉΓòÉ
Der Debugger
Um Ihren Programmcode auf etwaige Fehler hin zu БberprБfen,
steht Ihnen nicht der MenБpunkt Fehleranalyse zur VerfБgung,
sondern ein noch mДchtigeres Hilfsmittel, der KIM-Debugger. Mit
dessen Hilfe kФnnen Sie ihren Programmcode zeilenweise auf
Unstimmigkeiten БberprБfen. Geben Sie dazu an der Position, von
der aus Sie die ЪberprБfung durchfБhren wollen, den Befehl
START in Ihren Code ein. Es wird der gesamte Quellcode bis zum
Schluс БberprБft, es sei denn, Sie beenden diesen Test
vorzeitig, indem Sie an einer anderen Stelle den Befehl ENDE
einfБgen. Wenn Sie nach EinfБgen von START nun das Programm
aufrufen, erhalten Sie abwechselnd die OberflДche Ihres
Programms und ein Debuggerfenster.
Der KIM-Debugger arbeitet den Programmcode befehlsgemДс ab.
Dies bedeutet, daс der Quellcode nicht zeilenweise vom Debugger
БberprБft wird, sondern in der Reihenfolge der AusfБhrung der
Befehle. Wird beispielsweise ein Label angesprungen, БberprБft
der Debugger am Label weiter.
Jeder einzelne Programmschritt wird Ihnen im oberen Feld. Auf
diese Weise kФnnen Sie den Ablauf eines Programms exakt
nachvollziehen.
Es ist Ihnen auch mФglich, den Inhalt bestimmter Variablen an
unterschiedlichen Positionen im Programmcode einzusehen. Auf
der linken Seite im Debuggerfenster sind fБnf Felder mit der
Bezeichnung Variable vorgesehen. Geben Sie dort nach Erscheinen
des Debuggerfensters die Namen der zu БberprБfenden Variablen
an. Der Debugger ermittelt dann selbstДndig bei jeder Codezeile
den Inhalt dieser Variablen. Sie kФnnen auch an irgendeiner
Position wДhrend des Debugvorgangs einen neuen Variablennamen
angeben und durch BetДtigen des Buttons "Aktual." den
Variableninhalt БberprБfen.
Eine Codezeile bleibt so lange im oberen Informationsfeld, bis
Sie durch BetДtigen des Buttons "Weiter" die ЪberprБfung
fortsetzen. Sie kФnnen den Debugger jederzeit mit Hilfe des
Buttons "Deb.Ende" verlassen. Es wurde dann aber nicht der
gesamte ursprБnglich zur ЪberprБfung vorgesehene Codeabschnitt
durchgesehen.
Vergessen Sie nicht, nach Beendigung der ЪberprБfung die
Befehle START und ENDE wieder aus dem Programmcode zu
entfernen, um das Programm normal betriebsfДhig zu machen.
ΓòÉΓòÉΓòÉ 7. Grundbegriffe ΓòÉΓòÉΓòÉ
Grundbegriffe
Datenbank
Die erstellten Datenbanken sind dBASE-kompatibel. Als Index wird der dBASE-IV
Index unterstБtzt. (Andere Indexformate : FOXPRO und CLIPPER kФnnen bestellt
werden )
SystemkapazitДt : (dBASE IV - Index)
GrФсe der Datendatei : 1,000,000,000 Bytes
Feldbreite : 256 Bytes
Memofeld : 64 KB
Anzahl der Felder : 128
Offene Datenbanken : 100
Anzahl Subindizes pro Index : 47
Datensatzbreite : 64 KB
0) Befehle
Befehle sind reservierte WФrter und dБrfen nicht als Variablennamen verwendet werden.
Ein Befehl besteht aus einem Kommandowort und einem Parameterblock.
Mehrere Befehle in einer Zeile mБssen mit einem Doppelpunkt getrennt werden.
1) Variablen
Daten, die wir aus einer Datenbank lesen oder schreiben, stellen wir am Bildschirm dar.
FБr so einen Vorgang mБssen Daten in sogenannten Variablen gespeichert werden.
Variablen mБssen in KIM deklariert werden, bevor man Sie nutzt.
Es gibt lokale und globale Variablen. Globale Variablen habe eine GБltigkeit
in allen Modulen eines Programms. Eine globale Variable wird mit dem
Unterstrich am Anfang des Variablennamens gekennzeichnet, (z.B. _test).
Ein Variablenname kann 32 Zeichen lang sein. Deklarationen in Modulen gelten
in der Regel als lokal. Mehrere Variablen kФnnen mit Kommas getrennt
deklariert werden.
In KIM gibt es zwei Variablentypen : TEXT- und NUMERISCHE VARIABLEN.
a) Numerische Variable
Eine numerische Variable wird mit dem Befehl DEFFLOAT oder DIMFLOAT deklariert.
KIM speichert einen numerische Werte als Flieсkommazahl.
Mit DIMFLOAT wird ein Array von numerischen Variablen deklariert.
Beispiel DEFFLOAT a,b,c,d
DIMFLOAT test,1,100
Mit DIMFLOAT wird test1,test2,test3,...test100 deklariert.
b) Stringvariable
String- oder Textvariablen dienen zum Speichern von alphanumerischen Zeichenketten.
FБr die Deklaration gibt es 4 Befehle : DEFSTRING, DIM,DEFINE,DIMMEMO
Der Inhalt einer Stringvariablen kann bis zu 512 Zeichen beinhalten.
Eine Stringvariable, die mit DIMMEMO deklariert wird, kann bis zu 64000 Zeichen
lang sein. In KIM wird diese Form der Variable als MEMOVARIABLE bezeichnet.
Beispiel DEFSTRING eingabe,text,ausgabe,datei
DIM feld,1,100
DEFINE kunde1,20 as Name
DEFINE kunde2,15 as Vorname
DIMMEMO memo,10000 (Memovariable mit 10000 Bytes)
MIT DIM werden die Variablen feld1,feld2,feld3,.. feld100 deklariert.
Die Definition von Variablen mit DEFINE dient den Datenbankbefehlen.
DEFINE-Variablen sind immer globale Variablen und mБssen durchgehend nummeriert sein.
(kunde1,kunde2,kunde3...)
Einer DEFINE-Variable kann ein Zusatzname mit AS zugeteilt werden.
Im Programm kann die Variable mit einem Punkt und Zusatznamen angesprochen werden.
Beispiel DEFINE kunde1,20 as Name
DEFINE kunde2,15 as Vorname
DEFSTRING text
text=kunde.Vorname + " " + kunde.Name
Der Wert 20 und 15 ist eine LДngenangabe der Variablen und fБr die Nutzung mit einer
DBASE-kompatiblen Datenbank belanglos, da die LДngen der Datenbankfelder Бber die
Datenbankstruktur festgelegt werden.
2.) Die Zuweisung =
Anweisung text1="Hallo" bedeutet, daс der Stringvariablen namens text1 der Inhalt
"Hallo" zugewiesen wird. Allgemein gesprochen werden die Zeichen oder der Inhalt
einer Variablen rechts vom Gleichheitszeichen der Variablen links davon zugewiesen.
Die mathematische Bedeutung des Gleichheitszeichen (linke Seite = rechte Seite) muс
hierbei nicht erfБllt sein. Mit dem Gleichheitszeichen kann man auch Variablen den
Wert anderer Variablen zuweisen, aber nur zwischen Variablen gleichen Typs!
3) Operatoren
a)Mathematische Operatoren
Oftmals ist es notwendig, in einem Programm Rechenoperationen auszufБhren.
In KIM sind folgende mathematischen Operatoren anwendbar :
+ Addieren
- Subtrahieren
/ Dividieren
* Multiplizieren
^ Potenzieren
Was die Anwendbarkeit und GБltigkeit dieser Operatoren angeht, so orientiert sich
KIM an die gДngigen Rechenregeln. Zur Erinerung seien Ihnen an dieser Stelle die
wichtigsten mathematischen Gebote noch einmal dargelegt :
Punkt vor Strich
Addieren und Subtrahieren sowie Multiplizieren und Dividieren sind
untereinander gleichberechtigt und werden von links nach rechts
abgehandelt.
Division durch die Zahl Null ist verboten
Potenzierung hat die hФchste PrioritДt
KlammerausdrБcke werden von innen nach auсen gerechnet.
b) Vergleichsoperatoren
Vergleiche sind ein wichtiger Bestandteil einer jeden Computersprache.
Sie werden bei Erstellung eines Programms hДufig an einen Punkt kommen,
wo Sie vom Computer fordern mΓäûssen, auf eine Entscheidung des Anwenders
zu reagieren. GrundsДtzlich hat der Computer bei einem Vergleich zu
entscheiden, ob eine Aussage wahr oder falsch ist, um entsprechend zu reagieren.
Der Vergleich selbst wird mit einem Operator durchgefБhrt.
In KIM kФnnen Sie folgende Vergleichsoperatoren einsetzen :
= ist gleich
<= ist kleiner oder gleich
>= ist grФсer oder gleich
<> ist ungleich
< ist kleiner
> ist grФсer
Alle Vergleichsoperatoren sind gleichberechtigt. Es steht Ihnen frei, welchen
Operator Sie fБr ein bestimmtes Problem verwenden. Manchmal gibt es auch mehrere
logische LФsungen fБr eine Aufgabe. Bitte beachten Sie unbedingt, daс Sie nur
gleiche Variablentypen (und damit Datentypen) miteinander vergleichen, also nur
Zahlenvariablen mit Zahlenvariablen und Stringvariablen mit Stringvariablen.
Es ist sicher unsinnig, danach zu fragen, ob 3 grФсer als "hallo" ist.
c.) Logische Operatoren
KIM unterstБtzt die logischen Operatoren OR und AND, um mehrere Vergleiche miteinander
zu verknБpfen. Logische Operatoren kЎnnen nur in Verbindung mit IF/ENDIF
und WHILE/WEND genutzt werden.
Beispiel IF name="MEIER" AND ort="MЪNCHEN" THEN
....
....
ENDIF
d) Stringoperatoren
KIM unterstБtzt die MФglichkeit mehrere Strings (Zeichenketten) miteinander zu
verknБpfen. DafБr dient der der Operator "+".
Beispiel test = "Hallo " + "Franz"
test2=test1+","+test2+","+test3
4) Typumwandlungen
In KIM besteht die MФglichkeit einer Typumwandlung, daс Sie einen String in eine
Zahl und eine Zahl in einen String umwandeln.
a) FORM
FORM zahl,stringvariable,stellen,lДnge
Mit dem Befehl FORM wird das Ergebnis eines numerischen Ausdrucks in einen
alphanumerischen Text umgewandelt und in <stringvariable> gespeichert.
Dabei kann man das Ergebnis auf Nachkommastellen formatieren und die LДnge
der Zeichenkette bestimmen (Weitere Infos siehe im Referenzteil).
b)VAL
VAL string,numerische Variable
Hiermit kФnnen Sie den Inhalt einer Stringvariable in eine Zahl umwandeln.
(Dabei ist zu beachten : "hallo" -> 0
(Weitere Infos siehe Referenzteil)
5) Verzweigungen
Verzweigungen sind einer der wichtigsten Bestandteile eines Programms.
Mit Ihrer Hilfe ermФglicht man dem Rechner, auf verschiedene Entscheidungen
unterschiedlich zu reagieren. FБr das Programmieren von Verzweigungen benutzt
man die Befehlskombination IF/THEN/ELSE/ENDIF.
Beispiel IF a > b THEN
....
....
ELSE
....
....
ENDIF
Ist der Ausdruck nach der IF-Anweisung erfБllt,
werden die Anweisungen nach der THEN-Anweisung ausgefБhrt, bis die ELSE
Anweisung erreicht ist. Dann wird der Programmteil bis zum ENDIF Бbersprungen.
Ist der Ausdruck nach der IF-Anweisung nicht erfБllt, wird der Programmblock zwischen
THEN und ELSE Бbersprungen und die Anweisungen nach dem ELSE-Befehl ausgefБhrt.
Die Verschachtelung von IF/ENDIF Befehlen ist mФglich.
Der Befehl ELSE ist optional. Wird er weggelassen gilt fБr ENDIF das Gleiche
wie fБr ELSE. Wichtig! Zu jedem IF gehФrt ein ENDIF.
6) Schleifen
Schleifen sind Programmabschnitte, in denen eine bestimmte Befehlsfolge mehrmals
hintereinander durchlaufen werden kann.
In KIM gibt es zwei Befehle fБr Schleifen : FOR/NEXT und WHILE/WEND
a) FOR/NEXT
Beispiel : FOR i=1 TO 10
[Anweisungsblock]
....
....
NEXT
Der Anweisungsblock wird 10 mal ausgefБhrt. Die Variable i ist die Laufvariable und
wird um den Wert 1 erhФht, bis der Endwert nach dem TO-Befehl erreicht wird.
MФchte man eine FOR/NEXT Schleife vorzeitig beenden, darf man die Schleife nicht mit
einen Sprungbefehl verlassen, sondern muс die Laufvariable auf den Endwert +1 setzen.
Beispiel : FOR i=1 TO 10
IF i=5 THEN I=11 : ENDIF
NEXT
b) WHILE/WEND
Beispiel : WHILE a=0 and b=0
[Anweisungsblock]
WEND
Der Anweisungsblock wird so oft wiederholt, bis der Ausdruck nach dem
WHILE-Befehl falsch ist.
Schleifen kФnnen bis auf 20 Ebenen verschachtelt werden.
7) Labels und unbedingte SprБnge
Begriffdefinition : GOTO (ital. Spaghetti)
Labels sind Sprungmarkierungen in Programmen. Ein Label besteht aus dem
Zeichen # und einem Labelnamen. Der Labelname darf 32 Zeichen lang sein.
Beispiel #TEST
Mit dem Befehl GOTO kФnnen Sie einen unbedingten Sprung zu einem Label auslФsen.
Beispiel GOTO #test
....
....
#test
....
....
8) Unterprogramme und Module
a) Unterprogramme
Im Gegensatz zu den unbedingten SprБngen, die durch den Befehl GOTO ausgelФst
werden, sind SprБnge zu Unterprgrammen ein beliebtes und hДufig angewandtes
Programmierungsutensil.
Beispiel GOSUB #teilen
....
....
END
REM *** Unterprogramme ***
#teilen
....
....
....
RETURN
Aktiviert wird das Unterprogramm mit GOSUB #teilen. Die Anweisungen zwischen dem
Label #teilen und RETURN werden abgearbeitet und das Programm kehrt wieder zur
GOSUB-Anweisung zurБck. In Unterprogrammen, die mit GOSUB aufgerufen werden,
kФnnen keine lokalen Variablen definiert werden.
b) Module
Ein Modul ist ein abgekapselter Programmteil mit lokalen Variablendefinitionen und einer
Schnittstelle zur ParameterБbergabe. Das klingt komplizierter als es in Wirklichkeit ist.
Die Befehle von KIM sind vordefinierte Module. Diese Module bestehen aus einem
Befehlswort und einem Parameterblock. Die Befehle von KIM werden durch den Aufruf
des Namens erreicht. Module, die vom Programmierer erstellt wurden, werden mit
dem Befehl CALL und Modulnamen aufgerufen.
Mit eigenen Modulen kann man den Befehlsvorrat erweitern.
UEin Modulname darf aus 32 alphanumerischen Zeichen bestehen.FБr die Kapselung von
Modulen gelten folgende Ausnahmen: Globale Variablen, geФffnete Datenbanken und
definierte Oberflфchenobjekte gelten fБr das gesamte Programm.
Wurde eine Datenbank im Modul x geФffnet und beim Verlassen des Moduls nicht
geschlossen, ist Sie im Modul y nutzbar. (Weitere Infos siehe Referenzteil)
Beispiel CALL addiere (a,b,c)
END
REM *** Module ****
MODUL addiere (float a, float b, float c)
deffloat d
d=a+b
c=d
ENDMOD
9) Include und Importdateien
MФchte man ein Programm aus ergonomischen GrБnden in mehrere physikalische
Dateien aufteilen und bei der AusfБhrung wieder zusammenfБgen, geschieht
dies mit sogenannten INCLUDE- und IMPORT-Dateien.
Eine Includedatei wird beim Start des Programms in das Programm eingebunden.
EingefБgt in das Hauptprogramm wird eine Include-Datei durch den Befehl
@Dateiname
Beachten Sie, daс zwischen dem Zeichen @ und dem Dateinamen kein Leerzeichen
vorhanden ist. Importdateien werden zur Laufzeit des Programms geladen und
benФtigen beim Start noch keinen Speicherplatz. Eine Importdatei darf 64 KB
groс sein.
Am Ende einer Importdatei befindet sich der Befehl IMPORTEND. Er veranlasst,
die Importdatei aus dem Speicher zu entfernen.
In Importdateien dБrfen keine weiteren Importdateien aufgerufen werden, keine
Labels gesetzt werden, die vom Hauptprogramm genutzt werden und keine Module
definiert werden. In Include-Dateien ist dies zulДssig.
(Info Бber die Syntax finden Sie im Referenzteil.)
10) Parametereingabe
Parametereingaben lassen sich in KIM Бber mehrere Textzeilen eingeben.
Dies macht ein Programm Бberschaubarer. Als Zeilentrennzeichen werden zwei
Punkte ".." benutzt.
Beispiel deffloat a,..
b,..
c,..
10) Aliasvariablen
In manchen FДllen ist es notwendig sehr allgemein gБltige Module zu schreiben.
Mit einigen Befehlen ist dies aber nicht ohne weiteres mФglich.
Als Beispiel mФchte ich hier den Befehl <INEXT> nennen.
MФchte man eine Routine schreiben, die es ermФglicht in mehreren
Datenbanken mit unterschiedlicher Recordstruktur zu blДttern, wird es
schwierig.
Beispiel : INEXT 1,ok,kunden
INEXT 2,ok,artikel
INEXT 3,ok,lager
In KIM gibt es eine MФglichkeit diese Problem zu lФsen :
modul blaettern (float dbnr , float ok , char struktur )
inext dbnr,ok,(1)struktur(1)
endmod
(1)=KaufmДnnische UND - Zeichen (SHIFT-6)
Was geschieht ? Der Inhalt von <struktur> wird ersetzt mit (1)struktur(1).
call blaettern(1,ok,"kunden")
call blaettern(2,ok,"artikel")
call blaettern(3,ok,"lager")
ΓòÉΓòÉΓòÉ 8. Eventfunktionen ΓòÉΓòÉΓòÉ
Eventfunktionen
Allgemeines
Neu in KIM 2.1 sind die sogenannten Userfunktionen.(Eventfunktionen)
Beispiel der alten Funktionsweise :
Sie haben einen Button definiert und an ein Fensterobjekt addiert.
DrБcken Sie den Button, haben Sie bis jetzt Бber die Funktion
"get_item_pos" festgestellt ob die linke Maustaste oder die ENTER-
Taste gedrБckt wurde. Nun musste man noch prБfen welches Objekt
angesprochen wurde und hat dann einen entsprechenden
Programmcode gestartet.
Neu :
Der Userfunktionsname besteht aus dem Namen des Objekts und einen
Ergeignis. ( z.B. "Button1_select()"
Wird z.B. ein Button "Button1" angeklickt, wird die Funktion
Button1_select() aufgerufen.
Die alte Programmierweise kann beibehalten werden. Eine Userfunktion muс nicht definiert sein. Ist aber fБr die Zukunft aber der schnellere Weg.
VerfБgbare Events
Userfunktion Ereignis
-------------------------------------------------------------------
Button1_select() -> Objekt wird angeklickt oder mit ENTER
ausgewДhlt, entspricht taste=13
Button1_getfocus() -> Objekt erhДlt den Fokus
Button1_lostfocus() -> Objekt verliert den Fokus
Button1_doubleclick() -> Nur wenn Objekt bei Definition die Eigenschaft :
"double_click" erhДlt.
Button1_validate() -> Bei Eingabefehler, z.B. Eingabe auсerhalb
des gБltigen Bereichs.
Button1_changed() -> User hat Feldeintrag geДndert
// Funktioniert nur bei def_string momentan
WinID_timer() -> s. DEF_WINDOW
Beispiel
def_window "window",...
def_button "button1",..
add_item "window","button1"
win_paint "window"
while i<>1000
win_ev i
wend
end
rem ****************************************
rem Eventfunktion
rem ****************************************
modul button1_select()
rem Wenn Button gedrБckt wurde, dann soll ein Ton erklingen
beep
endmod
Tastaturevents
Eventfunktion um die Tastatureingaben abzufangen :
Vorher muс die entsprechende Taste mit SET_KEYMAP definiert sein.
MODUL SYSTEM_KEYPRESS()
if system.keypress=10005 then
beep
endif
ENDMOD
Innerhalb der Funktion SYSTEM_KEYPRESS wird ein logischer Tastenevent an
die Variable <system.keypress> Бbergeben.
Diese Variable muс nicht deklariert werden. Dies Бbernimmt KIM.
Die Variable <system.keypress> liefert nur gemappte Tasten zurБck !
Userfunction-Arrays
Nehmen wir an, Sie haben eine Maske mit 30 Datumseingaben.
Nun mФchten wir bei allen 30 Feldern prБfen ob die Eingabe korrekt war.
Die Datumseingabeobjekte tragen die Kennung : inp1,inp2,...,inp30.
In der oben beschriebenen Weise sieht das so aus :
modul inp1_validate()
deffloat flag
msgbox "Datumseingabeformat falsch ! ( TT.MM.YYYY ) ",0,flag,""
setfocus "inp1"
endmod
modul inp2_validate()
deffloat flag
msgbox "Datumseingabeformat falsch ! ( TT.MM.YYYY ) ",0,flag,""
setfocus "inp2"
endmod
u.s.w ( 27 x )
modul inp30_validate()
deffloat flag
msgbox "Datumseingabeformat falsch ! ( TT.MM.YYYY ) ",0,flag,""
setfocus "inp30"
endmod
KIM unterstБtzt folgende MФglichkeit :
Das Modul wird ohne "Index" deklariert und erhДlt als Platzhalter
das Zeichen # :
modul inp#_validate()
deffloat flag,taste
def_string obj$,alt$
get_item_pos obj$,taste,alt$
msgbox "Datumseingabeformat falsch ! ( TT.MM.YYYY ) ",0,flag,""
setfocus alt$
endmod
GET_ITEM_POS wird benutzt, um eine Positionierung des Cursors fБr
die Neueingabe durchzufБhren. GET_ITEM_POS liefert das aktive und
das zuletzt aktive Objekt zurБck.
Beim Aufruf einer Userfunction wird zuerst nach einer eindeutigen Kennung
geprБft ( z.B. inp1_validate ). Wird keine eindeutige Kennung gefunden,
prБft KIM auf eine Array-Variante (z.b. inp#_validate. ).
Wenn "inp1_validate" und "inp#_validate" existieren, dann erfolgt nur der
Aufruf von "inp1_validate". Wenn im gleichen Programm "inp2_validate"
nicht definiert wurde, prБft KIM wieder auf eine Array-Variante.
So ist es mФglich beide Funktionstypen in einem Programm zu nutzen.
ΓòÉΓòÉΓòÉ 9. Datenbankbeschreibung ΓòÉΓòÉΓòÉ
Datenbank
Ъbersicht
In diesem Kapitel lernen Sie das HerzstБck eines KIM-Programms
kennen, die Datenbank. Mit ihr werden alle ins Programm
eingegebenen Informationen gespeichert und verwaltet.
Wir werden den Aufbau von Datenbanken und den zugehЎrigen
Indexdateien besprechen. Anschlieсend wird gezeigt, wie mit
Datenbanken gearbeitet wird, wie DatensДtze eingefБgt,
gelФscht, herausgesucht und gelФscht werden kФnnen.
Ein wichtiger Abschnitt befaсt sich mit der VerknБpfung von
Datenbanken zu Relationen. Es werden die Kriterien fБr den
erfolgreichen Aufbau einer Relation vorgestellt. Anschlieсend
wird der Aufbau und das Arbeiten mit Relationen besprochen,
wobei unter anderem die MФglichkeiten zur Umorganisation der
relationalen Datenbanken und der Definition von Abfragefiltern
im Mittelpunkt stehen.
Zum Schluс wird die Datenbank in einem Netzwerk vorgestellt.
Hier sind vor allem die diversen Sperrvorrichtungen von
Interesse, welche KIM fБr die Besonderheiten des
Netzwerkbetriebs bereithДlt. Sie erfahren, wie man DatensДtze
und Datenbanken vor VerДnderungen schБtzen kann.
EinfБhrung
Datenbanken stellen das HerzstБck eines jeden KIM-Programmes
dar. Die gesamte Programmiersprache ist darauf spezialisiert,
die Probleme bei der Erstellung von Datenbanken mФglichst gut
und elegant zu meistern.
Unter einer Datenbank versteht man allgemein ein System, das
Informationen nach einer festgelegten Ordnung ablegt. Aus
diesem System kann man Informationen abfragen ("Daten abheben")
oder Informationen in das System einfБgen ("Daten einzahlen").
Diese kleine ErklДrung zeigt bereits, daс der Vergleich mit
einer Bank bei diesem System gar nicht so abwegig ist.
Nun darf man sich eine Datenbank aber nicht so vorstellen, als
ob Daten dort wahllos in eine Datei gesteckt werden wie Socken
in eine Schublade. Vielmehr werden darin Daten nach einem
vorgegebenem System geordnet. Die einfachste MФglichkeit, Daten
zu ordnen, bestБnde beispielsweise darin, alle Daten bezБglich
Ihres Anfangsbuchstabens alphabetisch zu ordnen.
Damit wДre bereits eine deutlich bessere Datenverwaltung
realisiert als bei einem einfachen Hineinstopfen aller Daten in
eine Datei. Aber auch damit wollen wir es nicht bewenden
lassen. Oft mФchte man erreichen, daс verschiedene
Dateneingaben, die miteinander verbunden sind, auch so in einer
Datenbank aufbewahrt werden, daс Sie gemeinsam abrufbar sind.
Ein Beispiel dafБr wДre, daс man beim Abfragen eines Namens
auch gleichzeitig den zugehФrigen Vornamen aus der Datenbank
hervorholen kann.
NatБrlich sind moderne Datenbanken dazu in der Lage. Das
Geheimnis besteht darin, daс zueinander gehФrende Daten
gemeinsam als ein Datensatz abgespeichert werden. Wird nach
einer bestimmten Information gefragt, zeigt die Datenbank
sofort den gesamten Datensatz an. Die Ordnung der DatensДtze
zueinander erfolgt Бber eine Indexdatei, in welcher das
Kriterium vorgegeben ist, nach welchem die Ordnung erfolgen
soll.
Dieses Ordnungssystem funktioniert aber nur dann, wenn das
Format aller DatensДtze identisch ist. Was damit gemeint ist,
sei in folgendem Beispiel erlДutert:
Ein Datensatz ist aus mehreren verschiedenen Feldern aufgebaut,
wobei jedes Feld eine andere Information beinhaltet. Wenn wir
beispielsweise mit einem Namen gleichzeitig den zugehФrigen
Vornamen und die entsprechende Adresse speichern wollen,
benФtigen wir einen Datensatz, der aus drei Feldern besteht.
Das erste Feld enthДlt die Daten, die den Namen betreffen, das
zweite und das dritte Feld entsprechend diejenigen fБr den
Vornamen und die Anschrift.
Symbolisch gesehen stellt die Datenbank den einen Aktenschrank
dar. Sie sehen, daс in der Datenbank bereits die
Struktur der DatensДtze vorgegeben ist. Bildlich gesprochen
"passen" nДmlich nur Schubladen (sprich DatensДtze) in den
Schrank (die Datenbank), die das entsprechende Format besitzen,
also die Aufteilung in drei FДcher mit der gewБnschten LДnge.
WБrde man versuchen, eine Schublade mit zwei oder vier FДchern
in den Schrank zu schieben, wБrde man keinen Erfolg haben.
Das heute als Standard geltende Datenbankformat ist das xBASE-
Format. Dies bedeutet, daс praktisch alle gДngigen
Datenbanksysteme auf dem oben geschilderten Datensatzsystem zur
DatenverknБpfung und den daraus folgenden Konsequenzen
basieren. Sie unterscheiden sich lediglich in der Art der
Datensatzverwaltung Бber Indizes und programmtechnischen
Details (beispielsweise ist dBASE eine Interpretersprache,
wДhrend Clipper compiliert wird).
KIM unterstБtzt ebenfalls das xBASE-Format. Sie kФnnen bei
der Installation von KIM wДhlen, welche Art von Indexverwaltung
Sie benБtzen wollen. Es wird standardmДсig das dBASE-System
mitgeliefert. Optional kФnnen Sie jedoch auch Foxpro- oder
Clipper-Indexsysteme erwerben.
Die Recordstruktur
Zu einem Datenbankprogramm gehФren folgende Komponenten: a) die
Datenbank selbst; b) die Eingabefelder, Бber welche die
Kommunikation zwischen Bediener und Datenbank erfolgt; c) die
Feldvariablen, welche die Verbindung zwischen Datenfeld und
Datenbank herstellen:
Diese drei Komponenten sind untrennbar miteinander verbunden.
Eingaben in die Datenbank kФnnen nur Бber Eingabefelder
getДtigt werden. In das Programm gelangen diese Eingaben dann
Бber die den Feldern zugrunde liegenden Variablen, von wo sie
in die Datenbank Бbernommen werden kФnnen. Andererseits werden
DatensДtze aus der Datenbank Бber diese Feldvariablen in die
Eingabefelder geladen.
Die Gesamtheit aller den Eingabefeldern zugrunde liegenden
Variablen, Бber die DatensДtze in eine Datenbank eingelesen
werden, bezeichnet man als RECORDSTRUKTUR. Wie man eine
Recordstruktur erstellt, haben wir im Prinzip bereits im
Kapitel Бber Eingabefelder erfahren.
Der erste Schritt bei der Erzeugung von Datenbanken besteht
also in der Definition der erforderlichen Feldvariablen. Dies
geschieht unter Verwendung von Define-Variablen bzw. Memo-
Variablen, wobei Sie unbedingt Gebrauch von der Option machen
sollten, den Define-Variablen Бber AS eine Zusatzbezeichnung
zuzuordnen. Dies erleichtert das Auffinden der einem bestimmten
Feld zugrunde liegenden Variablen im Quellcode bei weitem.
Aber Sie kФnnen auch ein globales Array benutzen.
Anschlieсend erstellen Sie die benФtigten Eingabefelder. Sie
kФnnen hierbei selbstverstДndlich vom Maskengenerator Gebrauch
machen. Details hierzu sowie Informationen Бber MФglichkeiten
der Formatierung von Eingaben in Eingabefeldern entnehmen Sie
bitte dem Kapitel Бber Eingabefelder.
Damit ist das GerБst des Datenbankprogramms erstellt. Nun
mБssen wir uns der Definition der eigentlichen Datenbank
zuwenden.
Die Feldstruktur
KIM orientiert sich beim Feldformat von DatensДtzen an den
von xBASE vorgegebenen Richtlinien. Wir wollen an dieser Stelle
keine EinfБhrung in das xBASE-Sprachsystem geben, sondern uns
nur auf die ErklДrung auch fБr KIM wichtiger AusdrБcke und
Details beschrДnken.
Auch bei der Erstellung der Datenbankfeldstruktur gilt es
zunДchst, die erforderlichen Feldvariablen zu definieren.
Hierbei kФnnte man natБrlich auf die bereits fБr die
Recordstruktur verwendeten Define-Variablen zurБckgreifen. Ihr
Programm wird aber flexibler, wenn Sie der Feldstruktur andere
Variablen zuordnen. Dann kФnnten Sie die Datenbank auch Бber
andere Recordstrukturen ansprechen (dies wДre beispielsweise
bei MDI-Systemen nБtzlich).
Auсerdem ist es nicht notwendig, Define-Variablen fБr die
Erzeugung der Datenbankfelder zu benutzen. Im von KIM
unterstБtzten xBASE-Format wird die LДnge der einzelnen
Datenbankfelder intern gesteuert und muс nicht bei der
Definition der Feldvariablen angegeben werden. Darum besteht
kein Grund mehr, dieses Variablenfeld mit DEFINE zu erzeugen,
zumal dies mit dem Befehl DIM weitaus schneller zu
bewerkstelligen ist. Nehmen wir an, wir wollen eine Datenbank
erstellen, die folgende Datensatzstruktur besitzen soll: Feld1
zur Speicherung von Namen mit einer LДnge von 20 Zeichen; Feld2
zur Speicherung von Vornamen mit einer LДnge von 20 Zeichen;
Feld3 zur Speicherung der Adressen mit einer LДnge von 50
Zeichen; Feld4 zur Speicherung von Kommentaren mit einer LДnge
von 255 Zeichen. Die Definition der Feldvariablen erfolgt
Бber DIM, wobei zu beachten gilt, daс in Datenbanken mit xBASE-
Format das letzte Feld als Datensatz-Endkennung leer bleiben
muс. Es ist daher ein Feld mehr als notwendig zu definieren:
DIM feld 1, 5
Eine Datenbank darf maximal 255 Felder besitzen. Nun mБssen die
einzelnen Felder des Datensatzes nДher definiert werden. Zur
Verdeutlichung der Vorgehensweise haben wir dem eine
Kommentarzeile vorangestellt, in der die Bedeutung der
einzelnen Eingaben erklДrt wird. Wir empfehlen ihnen, in jedem
Programm bei der Datenbankdefinition aus
ЪbersichtlichkeitsgrБnden diese Kommentarzeile zu verwenden.
Vergessen Sie aber nicht, die Anweisung REM voranzustellen,
damit KIM diese Zeile als Kommentar erkennt.
REM Bezeichnung Typ LДnge Nachkommastellen
feld1=" Name, C, 20, 0"
feld2=" Vorname, C, 20, 0"
feld3=" Adresse, C, 50, 0"
feld4=" Kommentar, M, 10, 0"
feld5=" "
Sie erkennen, daс ein Feld mehr als zur Beschreibung des
Datensatzes definiert wird. Diesem wird aber kein Inhalt
zugewiesen. Wie bereits erlДutert dient dieses Feld dazu, das
Ende einer Datensatzstruktur anzuzeigen. Es ist unbedingt
notwendig, eine Datensatzstruktur mit einem Leerfeld
abzuschlieсen, ansonsten kann die Datenbank nicht geФffnet
werden.
Noch eine weitere Vorbemerkung: Aus GrБnden der
Ъbersichtlichkeit wurden die einzelnen Feldbeschreibungen
tabulatorisch eingegeben. Es ist aber nicht erlaubt, bei der
Feldbeschreibung im Quellcode Tabulatoren zu verwenden. Die
Datenbank kann sonst nicht erstellt werden.
Die einzelnen FeldeintrДge mБssen jeweils durch ein Komma
voneinander getrennt werden. Der erste Feldeintrag legt die
Feldbezeichnung fest, also welcher Inhalt in der Variablen
erwartet wird. Dies hat nicht nur ЪbersichtlichkeitsgrБnde,
sondern ist wichtig fБr die Datenbankverwaltung Бber Indizes.
Indizes orientieren sich nДmlich an den Feldbezeichnungen.
Der zweite Eintrag legt den Variablentyp fest. Auch dies wird
nДmlich Datenbankintern gesteuert. Obwohl Бber DIM eigentlich
nur Arrays von Stringvariablen erstellt werden kФnnen, kФnnen
die so erzeugten Variablen innerhalb der Datenbank
umfunktioniert werden. Folgende Variablentypen stehen Ihnen
innerhalb der Datenbank zur VerfБgung:
C Stringvariable (c=character)
N Zahlenvariable (n=numerisch)
M Memo-Variable (m=memo)
D Datums-Variable (d=Datum)
L/F Logischer Operator (Boolescher Operator, True
/False)
Geben Sie das Zeichen fБr den gewБnschten Variablentyp an, und
innerhalb der Datenbank verhДlt sich die Variable
dementsprechend. Auсerhalb der Datenbank handelt es allerdings
immer um eine Stringvariable, da sie ja mit DIM erstellt wurde.
Neu ist die in KIM nicht vorhandene Variable des L-Typs. Diese
Variablen dБrfen nur einen der beiden logischen Operatoren
".TRUE." oder ".FALSE." bzw. ".YES." oder ".NO." als Inhalt
besitzen. An Ihrer Statt kФnnen die AbkБrzungen ".T." und ".F."
bzw. ".Y." oder ".N." verwendet werden.
Der dritte Eintrag in der Feldvariablen definiert die
FeldlДnge. Die letzte Angabe schlieсlich bezieht sich auf die
Anzahl der erlaubten Nachkommastellen in der Variablen. Hier
etwas anderes als eine Null einzugeben ist nur sinnvoll, wenn
Sie Dezimalzahlen als Eingabe in dieses Feld erwarten.
Die Indexstruktur
Ohne Indexverwaltung ist eine Datenbank nicht besonders
funktionsfДhig, da es dann unmФglich wДre, Daten
herauszusuchen. Die Daten wБrden einfach in der Reihenfolge
ihrer Abspeicherung in die Datenbank eingeordnet. Der nДchste
Schritt nach der Definition der Datensatzstruktur muс also
darin bestehen, eine Indexstruktur fБr die Datenbank
aufzubauen.
FБr jede gewБnschte Verwaltungsoperation muс eine gesondertes
Indexfeld definiert werden. MФchten Sie beispielsweise alle
DatensДtze nach dem Namen ordnen, mБssen Sie hierfБr ein
Indexfeld generieren. MФchten Sie sich aber zusДtzlich die
Option offenhalten, alle Daten gesondert nach der Adresse zu
sortieren, mБssen Sie dafБr ein zweites Indexfeld erzeugen.
Beachten Sie aber bitte, daс sich der Umfang der
(physikalischen) Indexdatei mit jedem neuen Indexfeld
vergrФсert und damit die Laufgeschwindigkeit des Programms
herabsetzt. Um dies zu vermeiden, sollten Sie bei der
Verwendung von mehreren Indexfeldern diese in verschiedenen
Indexdateien erzeugen. Wie wir spДter sehen, wird beim ╓ffnen
der Datenbank jeweils nur eine Indexdatei geФffnet. Andere
Indexdateien werden nur auf Bedarf geФffnet und verlangsamen
daher die Laufgeschwindigkeit des Programms nicht.
Jedes Indexfeld wird durch eine Feldvariable beschrieben. Es
gilt also zunДchst wieder die erforderlichen Feldvariablen zu
definieren, wobei wie bei der Datensatzstruktur eine Variable
mehr als notwendig fБr die Endkennung der Indexdatei erstellt
werden muс:
DIM index, 1, 3
Eine Indexdatei darf maximal 255 Indexfelder beinhalten.
Dann erfolgt die nДhere Beschreibung der Indexfelder. Auch hier
wollen wir zur Verdeutlichung eine Kommentarzeile voranstellen:
REM Indexname Ausdruck Filter Unique Absteigend
Index1=" name_tag , Name , Name='Meier', 0, 0"
Index2=" adresse_tag, Adresse , , 0, 0"
Index3=" "
Der erste Eintrag in der Variablen legt die ID-Kennung fБr den
entsprechenden Index fest. Ъber diesen Indexnamen kann der
Index angesprochen werden.
Der Eintrag in der Rubrik "Ausdruck" bestimmt, auf welches Feld
des Datensatzes der entsprechende Index zeigt. Ist dieser Index
aktiviert, dann werden alle Daten in der Bank anhand der
Eintragungen in diesem Datensatzfeld geordnet. Des weiteren
kann nur nach Daten in diesem Feld gesucht werden.
Es steht Ihnen aber frei, den Index gleichzeitig auf mehrere
Datensatzfelder zu setzen. MФchten Sie beispielsweise, daс die
Daten sowohl nach Namen als auch nach Vornamen sortiert werden,
geben Sie in dieser Spalte "Name+Vorname" an. Die PrioritДt
besitzt jeweils der erste Eintrag, also hier Name. Es kann dann
auch nach Daten in beiden Feldern gesucht werden. Dies ist
besonders dann wБnschenswert, wenn der gesuchte Begriff
mehrfach in der Datenbank erscheint. Es kann dann anhand der
Daten im zweiten selektierten Feld eine Unterscheidung
getroffen werden.
Eine zusДtzliche Option bei Suchaktionen stellt die Rubrik
"Filter" dar. Hier kФnnen Sie Voreinstellungen definieren, an
denen sich die Suche orientiert. Als Beispiel ist im ersten
Feld ein Filter auf den Namen "Meier" gesetzt. Bei einer Suche
werden dann nur DatensДtze berБcksichtigt, die im Feld "Name"
den Eintrag "Meier" besitzen. Filter werden Бber AusdrБcke der
dBASE-Sprache und nicht mit KIM-Befehlen erzeugt. Aufgrund
Ihrer Bedeutung und Ihres Umfanges sollen diese
Filteroperationen im anschlieсenden Unterkapitel behandelt
werden.
Der vierte Feldeintrag "Unique" legt fest, ob ein Feldeintrag
in der Datenbank mehrmals vorkommen darf oder nicht. Dies kann
beispielsweise dann der Fall sein, wenn mehrere DatensДtze mit
dem Namen "Meier" eingefБgt werden sollen oder nicht.
UnabhДngig davon, ob sich die Бbrigen FeldeintrДge voneinander
unterscheiden oder nicht, kФnnen Sie eine Mehrfacheintragung
Бber Unique generell unterbinden. Setzen Sie fБr Unique eine
Null, so sind MehrfacheintrДge in dem Feld erlaubt, auf welches
der entsprechende Index zeigt. Der Wert 1 fБr Unique hingegen
verbietet jegliche Mehrfacheintragung in dem entsprechenden
Feld.
Sinnvoll ist die Unterbindung von Mehrfacheintragungen
sicherlich in Datenfeldern, in denen jeder Wert immer nur
einmal vorkommen darf (z.B. Kundennummern). Unsinnig hingegen
ist dieses Verbot bei Feldern wie z.B. einer Datumseingabe, da
hier Mehrfacheintragungen praktisch unvermeidlich sind.
Ъber "Aufsteigend" schlieсlich regulieren Sie den
Sortiervorgang in der Datenbank. Geben Sie hier eine Null ein,
so werden alle Daten aufsteigend, also von a nach z geordnet,
falls dieser Index aktiviert ist. Eine 1 in dieser Rubrik fБhrt
hingegen zum absteigenden Sortieren, also von z nach a.
Filter
Wie bereits erwДhnt besitzen Sie die MФglichkeit, Suchaktionen
innerhalb einer Datenbank zu beeinflussen, indem Sie fБr den
entsprechenden Index einen Filter setzen. Diese Filter werden
nicht Бber KIM-Befehle gesteuert, sondern Бber AusdrБcke aus
der diesen Datenbanken zugrunde liegenden dBASE-Sprache. Es
soll hier nicht ein vollstДndiger Einblick in dBASE gegeben
werden, sondern lediglich eine Ъbersicht Бber die dBASE-
Anweisungen, die Sie zur Filterdefinition von Indizes brauchen.
Beachten Sie bitte, daс dBASE-AusdrБcke nur innerhalb der
Datenbank GБltigkeit besitzen. Im normalen KIM-Programmcode
sind Sie unwirksam und verursachen als unbekannte Eingaben
Fehlermeldungen. Bei der Erstellung von KIM-Programmen
benФtigen Sie deshalb dBASE-Anweisungen nur bei der Erstellung
von Indexfiltern und interaktiven Abfragen bei Relationen
(siehe spДter). Im Anhang finden Sie eine kurze EinfБhrung in
die dBASE-Sprache. Sehen Sie dort bitte nach, wenn Sie nicht
alles verstehen, was in diesem Kapitel verwendet wird.
Setzen des Filters auf einen bestimmten Datenwert:
Wenn Sie mФchten, daс nur DatensДtze angezeigt werden, die
einen bestimmten Eintrag im vom Index ausgezeichneten Feld
besitzen, setzen Sie einen Filter mit diesem Wert in das
Indexfeld. MФchten Sie beispielsweise, daс stets nur alle
DatensДtze angezeigt werden, die den Namen "Meier" beinhalten,
so gehen Sie in das auf "Name" zeigende Indexfeld und setzen
dort den Filter Name="Meier" . Dieser Filter hat nur einen
Sinn, wenn er im richtigen Indexfeld steht. Setzen Sie den
Filter beispielsweise in das Indexfeld, welches als
Suchausdruck "Vorname" enthДlt, wird kein Datensatz bei einer
Suchoperation gefunden werden, da natБrlich kein Datensatz im
Feld Vorname den Eintrag "Meier" enthДlt.
Sinnvoll wird dieser Filter vor allem, wenn Sie beispielsweise
nach allen DatensДtzen suchen wollen, die an einem bestimmten
Tag gespeichert wurden. Dies gelingt mit dem Filter
Datum=Date(), den Sie in das Indexfeld setzen, welches auf das
Feld "Datum" zeigt. In die runde Klammer geben Sie das
gewБnschte Datum ein. Geben Sie dort kein Datum vor, wird das
aktuelle Systemdatum fБr diese Anweisung herangezogen. Sie
kФnnen auch nach DatensДtzen suchen lassen, die an einem
bestimmten Tag, in einem bestimmten Monat oder Jahr erstellt
wurden. Hierzu dienen die Filter Datum=Day(), Datum=month(),
Datum=year(). Geben Sie jeweils das gewБnschte Datum in die
runden Klammern ein. Der Ausdruck sucht sich selbstДndig Tag,
Monat oder Jahr heraus und wandelt dies in einen numerischen
Zahlenwert um. Es ist auch mФglich, hierbei das Systemdatum
vorzugeben. Setzen Sie dann einfach den Ausdruck date() in die
runden Klammern, also z.B. Datum=Day(date()).
Beachten Sie bitte, daс diese Filter PrioritДt vor allen
anderen KIM-Befehlen besitzen. GleichgБltig welche
Suchkriterien Sie auf der ProgrammoberflДche eingeben, werden
nur die DatensДtze berБcksichtigt, die dem Filterausdruck
entsprechen.
Vergleichsfilter
SelbstverstДndlich ist es mФglich. Filter nicht nur auf
bestimmte Werte zu setzen, sondern beispielsweise alle
DatensДtze herauszufiltern, die nach einem bestimmten Datum
eingegeben wurden. Sie gehen dabei genauso wie gerade
beschrieben vor, nur verwenden Sie statt des
Gleichheitszeichens einen der folgenden Operatoren:
<> (oder #) Ungleich
< Kleiner als
> GrФсer als
<= Kleiner oder gleich
>= GrФсer oder gleich
$ enthДlt das folgende Zeichen
Mit Hilfe dieser dBASE-Vergleichsoperatoren ist es mФglich,
Filter zu erstellen, die bestimmte DatensДtze bei Suchaktionen
nicht berБcksichtigen.
Sie kФnnen auch mehrere Vergleiche durch logische d-BASE-
Operatoren miteinander verknБpfen. MФchten Sie z.B., daс nur
DatensДtze berБcksichtigt werden sollen, die zwischen dem 12.
Tag und 25.Tag eines Monats eingegeben wurden, so setzen Sie
den Filter "Datum<=25 .AND. Datum<=12". dBASE kennt drei
logische Operatoren:
.NOT. Nicht
.AND. Und
.OR. Oder
Beachten Sie bitte, daс diese logischen Operatoren in dBASE von
Punkten eingerahmt sein mБssen.
Neuerstellung und Щffnen einer DB
Der Definitionsteil bei der Erstellung der Datenbank ist damit
abgeschlossen. Wir kФnnen nun daran gehen, die neue Datenbank
aufzurufen. Dies geschieht mit
ICREATE id_string, def_felder$, def_index$
FБr id_string geben Sie die Bezeichnung der Datenbank an. Ъber
die Variable def_felder$ legen Sie fest, welches Array die
Definition der Datensatzstruktur (Feldstruktur) der Datenbank
enthДlt. Letztendlich bestimmt def_index$, welches Array die
Definition der Indexstruktur enthДlt.
Durch diesen Befehl werden die Dateien "id_string.dbf" und
id_string.mdx (cdx/ndx)" erstellt, wobei fБr id_string jeweils
die Bezeichnung der gerade erstellten Datenbank eingesetzt wird.
In diesen Dateien werden alle DatensДtze im dBASE-Format und
eine Informationsdatei, welche die Indexstruktur der Datenbank
enthДlt, gespeichert.
Deshalb muс der Inhalt dieser Dateien unbedingt mit dem Aufbau
der erstellten Datenbank im Einklang stehen. Um Fehler zu
vermeiden (wenn beispielsweise zufДllig bereits gleichnamige
Dateien vorhanden sind), mБssen Sie alle Dateien mit diesen
Namen vor der Erstellung der Datenbank lФschen. Dies erreichen
Sie mit
KILL "id_string.dbf"
KILL "id_string.mdx"
Der Befehl KILL lФscht eine nachstehend angegebene Datei. Auch
hier geben Sie fБr id_string die Bezeichnung der zu
erstellenden Datenbank an.
Beachten Sie unbedingt, daс die LФschung dieser Dateien nur
dann erfolgen darf, wenn Sie eine Datenbank neu erstellen.
WБrden Sie diese Prozedur vor dem Щffnen einer bereits
bestehenden Datenbank durchfБhren, wБrden Sie damit den
gesamten Inhalt der Datenbank lФschen!
Der letzte Schritt besteht nun darin, die erstellte Datenbank
zu Фffnen. Gleichzeitig mБssen Sie die zugehФrige Indexdatei
Фffnen (Indexdateien werden nicht automatisch mit der Datenbank
geФffnet!!) und eines der darin enthaltenen Indexfelder zum
aktiven Index machen. Dazu benФtigen Sie drei Befehle:
IOPEN nr, id_string
IOPEN_INDEX nr, id_string
ISET nr, index$, expr$
Beim Щffnen mit IOPEN erhДlt die Datenbank eine Kennummer (Бber
nr), Бber die sie mit allen folgenden Befehlen angesprochen
werden kann. FБr id_string geben Sie die Bezeichnung der
Datenbank ein. Dieselbe Bedeutung besitzen diese Variablen beim
╓ffnungsbefehl IOPEN_INDEX fБr die Indexdatei. Es ist Бbrigens
erlaubt, mehrere Indexdateien gleichzeitig zu Фffnen, die sich
auf eine Datenbank beziehen. ISET legt schlieсlich den aktiven
Index fest. Geben Sie hier zunДchst die Nummer der Datenbank
an, auf die sich der Index beziehen soll. FБr index$ geben Sie
die Bezeichnung des Indexfeldes in der Indexdatei an, welches
aktiv sein soll. Expr$ ist eine RБckgabevariable. Hier wird an
das Programm zurБckgegeben, auf welches Feld im Datensatz der
aktive Index zeigt.
Wir wollen als Zusammenfassung eine neue Datenbank erstellen,
bzw. falls es diese bereits geben sollte, einfach nur Фffnen.
Im letzteren Fall ist es nicht nФtig, Datensatzstruktur und
Indexstruktur neu zu definieren und sogar verboten, die Dateien
"id_string.dbf" und "id_string.mdx" zu lФschen.
Programmtechnisch stellt dieses Problem eine Verzweigung dar.
Wir fragen zu Beginn, ob es die Datenbankdatei "id_string.dbf"
schon gibt. Dies erreichen wir mit dem Befehl EXIST (siehe
Referenzteil). Ist die Datei bereits vorhanden, springen wir
gleich zur ╓ffnungsanweisung fБr die Datenbank. Andernfalls muс
zunДchst der Definitionsteil durchgefБhrt werden:
REM ZunДchst werden die benФtigten lokalen Variablen definiert
DEFSTRING expr
DEFFLOAT a
REM Jetzt die Abfrage, ob die Datenbank schon existiert
EXIST "test.dbf", a
IF a<>1 THEN
REM Falls nein, dann muс Sie neu definiert werden
dim feld,1,5
dim index, 1, 3
REM ZunДchst wird die Datensatzfeldstruktur definiert
REM Bezeichnung Typ LДnge Nachkommastellen
feld1=" NAME, C, 20, 0"
feld2=" VORNAME, C, 20, 0"
feld3=" ADRESSE, C, 50, 0"
feld4=" KOMMENTAR, M, 10, 0"
feld5=" "
REM Die Definition der Indexstruktur
REM Bezeichnung Ausdruck Filter Unique Aufst.
Index1=" NAME_TAG , NAME , DEL()<>"*" , 0, 0"
Index2= ADRESSE_TAG, ADRESSE, , 0, 0"
Index3=" "
REM Eventuelle alte Datenbankdateien lФschen
KILL "test.dbf"
KILL "test.cdx"
ICREATE "test", feld, index
ENDIF
REM Die Datenbank wird mitsamt Indexdatei geФffnet, das Feld
REM Name_tag als aktiver Index ausgewДhlt.
IOPEN 1, "test"
IOPEN_INDEX 1, "test"
ISET 1, "NAME_TAG", expr
Diese Codesequenz kФnnen Sie als Modul zur Erstellung einer
Datenbank in ein Programm einbauen. FБr sich alleine ist es
aber selbstverstДndlich nicht lauffДhig, da das ganze Ambiente
wie ProgrammoberflДche usw. noch fehlt.
ZusДtzliche Indexdatei und Reorg.
Wie bereits bemerkt wurde, muс fБr das Setzen eines neuen Index
ein Indexfeld in der Indexdatei erstellt werden. Da
Indexdateien physikalische Dateien sind, wird die
Laufgeschwindigkeit des Programms um so mehr herabgesetzt, je
grФсer die zugehФrige Indexdatei ist. Falls Sie sich mehrere
Indexoptionen offenhalten wollen, ist es daher ratsam, die dazu
erforderlichen Indexfelder in verschiedenen Indexdateien zu
definieren. Es ist nДmlich erlaubt, mehrere Indexdateien
gleichzeitig zu Фffnen, die sich auf dieselbe Datenbank
beziehen. Ein zusДtzliche Indexdatei lДсt sich jederzeit
innerhalb des Programms erstellen. Gehen Sie dabei zunДchst
genauso vor wie bei der Basisindexdatei. Definieren Sie die
gewБnschten Indexfelder:
DIM ZINDEX 1,2
REM Bezeichnung Ausdruck Filter Unique Aufst.
ZIndex1= "VORNAME_TAG , VORNAME , , 0 , 0"
ZIndex2=""
Beachten Sie bitte, daс Sie fБr die neue Indexdatei andere
Feldbezeichnungen verwenden mБssen als fБr die Basisindexdatei.
Des weiteren muс die neue Indexdatei einen anderen Namen
erhalten als die Basisindexdatei, die ja denselben Namen trДgt
wie die Datenbank. Damit wird aber bei der Erstellung der neuen
Indexdatei eine zusДtzliche Datei "*.mdx" erzeugt (wobei fБr
den Platzhalter * der Name der neuen Indexdatei eingefБgt
wird). Analog zu unserem Vorgehen bei der Neuerstellung der
Datenbank muс vor der Neuerstellung dieser Datei "*.mdx" jede
Datei desselben Namens gelФscht werden. Nehmen wir an, daс die
neue Indexdatei den Namen "testx" erhalten soll, dann mБssen
Sie eingeben:
KILL "testx.mdx"
Nun kФnnen wir die neue Indexdatei generieren:
IMAKEINDEX nr, indexname, indexfeld
FБr nr geben Sie die Kennung der zugehФrigen Datenbank ein.
Anstelle der Variablen indexname geben Sie die Bezeichnung der
neuen Indexdatei an, hier "testx". Wie gesagt darf dieser Name
nicht identisch sein mit demjenigen der Basisindexdatei.
Keinesfalls darf eine Endung (z.B. cdx/mdx) an den Indexnamen
angefБgt werden! FБr indexfeld schlieсlich geben Sie den Namen
der Feldvariablen an, Бber die die neuen Indexfelder erzeugt
wurden, also in unserem Beispiel "zindex".
Diese Indexdatei kann danach wie gewohnt mit IOPEN_INDEX
geФffnet werden. Mit ISET sind Sie dann in der Lage, einen
Index der neuen Datei zu aktivieren. Es steht Ihnen frei,
innerhalb eines Programms beliebig viele Indexdateien zu
erzeugen. Sollten wider Erwarten wДhrend des Programmablaufs
Fehler in einer Indexdatei auftreten, so haben Sie die
MФglichkeit, eine Reorganisation der Indexdatei durchzufБhren:
IREINDEX nr
Damit werden alle geФffneten Indexdateien reorganisiert, die
zur entsprechenden Datenbank (Бber nr angesprochen) gehФren.
Schlieсen von Datenbanken und Indizes
Sie kФnnen mit Hilfe eines Befehles alle geФffneten
Indexdateien einer Datenbank schlieсen:
ICLOSE_INDEX nr
Es werden alle Indexdateien der Datenbank geschlossen, deren
Kennummer Sie fБr nr eingegeben haben. Die Datenbank selbst
bleibt aber geФffnet!!
Am Ende eines Programmes muс die geФffnete Datenbank
geschlossen werden, um alle Inhalt darin auf die Festplatte in
der .dbf-Datei zu speichern. Dies geschieht mit
ICLOSE nr
Auch hier geben Sie fБr nr die Bezeichnung der entsprechenden
Datenbank an. Auсer der Datenbank werden alle zugehФrigen
Indexdateien mit dieser Anweisung geschlossen und die aktuellen
Inhalte der Datenbank- und Indexdateien gespeichert. FБhren Sie
diesen Befehl unbedingt am Programmende aus, sonst kann es zu
Datenverlusten kommen!
Haben Sie mehrere Datenbanken geФffnet, kФnnen Sie diese alle
mit ICLOSE schlieсen, wenn Sie als Kennummer fБr die zu
schlieсende Datenbank 99 eingeben. Daraufhin werden alle
offenen Datenbanken und Indexdateien geschlossen.
HinzufБgen und Entfernen
Wir wollen uns nun der Bearbeitung von DatensДtzen einer
Datenbank zuwenden. DafБr muс eine Datenbank aber zunДchst
DatensДtze enthalten. Ein neuer Datensatz muс zunДchst einmal
in die Eingabefelder auf der ProgrammoberflДche eingegeben
werden. Anschlieсend werden die Daten in die den Eingabefeldern
zugrunde liegenden Variablen, welche die Recordstruktur bilden,
Бbergeben. Dies ist uns alles bereits aus dem Kapitel Бber
Eingabefelder bekannt. Jetzt mБssen die Daten aus der
Recordstruktur der Datenbank angefБgt werden. Dies gelingt mit
IADD nr, s$
ZunДchst muс wieder die Kennummer der entsprechenden Datenbank
aufgefБhrt werden. Anschlieсend ist fБr s$ der Feldname der
Recordstruktur anzugeben, aus der ein Datensatz der Datenbank
angefБgt werden soll.
Der neue Datensatz wird automatisch von der Indexdatei
entsprechend des aktiven Index einsortiert. Gleichzeitig wird
der neue Datensatz zum aktuellen Datensatz gemacht. In einer
Datenbank ist immer ein Datensatz der aktuelle Datensatz. Nur
der aktuelle Datensatz kann mit Befehlen bearbeitet werden.
Man muс sich dabei vorstellen, daс ein Datenbank intern mit
einer Markierung versehen wird, dem sogenannten
Datenbanksatzzeiger. Der Datensatz, auf den dieser Zeiger
deutet, ist der aktuelle Datensatz:
Datenbankzeiger
Der jeweils aktuelle Datensatz kann aus der Datenbank entfernt
werden. Dies geschieht bei Datenbanken im dBASE-Format in zwei
Etappen. ZunДchst wird der aktuelle Datensatz als gelФscht
markiert. Dies erreicht man mit dem Befehl:
IDEL nr
FБr nr mБssen Sie wie Бblich die Bezeichnung der Datenbank
angeben, aus der ein Datensatz entfernt werden soll. Der
Datenbanksatzzeiger wird automatisch auf den nДchsten Datensatz
gestellt, der dadurch aktueller Satz wird.
Damit ist der Datensatz aber noch nicht endgБltig gelФscht,
sondern nur als zum LФschen markiert. Die Operation kann
rБckgДngig gemacht werden mit
IUNDEL nr
Auch hier steht nr fБr die Datenbankbezeichnung. Es wird die
LФschmarkierung vom aktuellen Datensatz entfernt und dieser
damit zu einem ganz normalen Datensatz.
Wenn Sie genau aufgepaсt haben, ist Ihnen nicht entgangen, daс
mit IDEL der Datenbanksatzzeiger automatisch weiterbewegt wird.
IUNDEL wirkt aber seinerseits nur auf den aktuellen Datensatz.
Bevor die LФschung mit IUNDEL wieder rБckgДngig gemacht werden
kann, muс der Datenbanksatzzeiger auf den markierten Datensatz
bewegt werden. Wie dies mФglich ist, erfahren Sie im nДchsten
Kapitel. Wenn Sie die LФschung unmittelbar danach wieder
rБckgДngig machen wollen, ist dies relativ einfach, da der
Datenbanksatzzeiger einfach wieder um einen Satz zurБckgesetzt
werden muс (mit IPREV). Viel schwieriger ist es, die LФschung
zu einem spДteren Zeitpunkt rБckgДngig zu machen. Der
Datenbanksatzzeiger kann natБrlich mittlerweile sehr weit
entfernt vom gelФschten Datensatz sein. Die LФsung besteht
darin, den Datenbanksatzzeiger Schritt fБr Schritt durch die
Datenbank zu bewegen und bei jedem Datensatz nachzufragen, ob
dieser als gelФscht markiert ist. Diese Nachfrage fБhrt man mit
folgender Anweisung durch:
IDELCHECK nr, ok
Der aktuelle Datensatz der Бber nr gekennzeichneten Datenbank
wird daraufhin БberprБft, ob er zur LФschung markiert ist. Ъber
ok liefert der Befehl dem Programm das Resultat der ЪberprБfung
zurБck. ErhДlt ok den Wert 0, ist der Datensatz als gelФscht
markiert. Ansonsten handelt es sich um einen ganz normalen
Datensatz.
Zur Verdeutlichung wollen wir ein kleines Suchprogramm
vorstellen, das einen als gelФscht markierten Datensatz
aufspБren soll. Die Befehle ISTART und INEXT wollen wir
unkommentiert verwenden, sie werden im nДchsten Abschnitt
vorgestellt:
REM Der aktuelle Datensatz wird БberprБft
IDELCHECK nr, ok
WHILE ok<>0
REM Ist dieser nicht markiert, wird der nДchste Satz kontrolliert
INEXT nr, pos, s$
IDELCHECK nr, ok
REM Ist das Datenbankende erreicht,kehrt man
REM zum Datenbankanfang zurБck
IF pos=3 AND ok<>0 THEN
ISTART nr, s$
ENDIF
WEND
SelbstverstДndlich ist dieses Beispielprogramm fБr sich alleine
nicht lauffДhig. Es muс in ein vollstДndiges Programm eingebaut
werden. Zum Abschluс sei noch eine MФglichkeit erwДhnt, wie ein
als gelФscht markierter Datensatz in einer geФffneten Datenbank
unwiederbringlich entfernt werden kann. Geben Sie hierzu ein:
IPACK nr
Es werden dann alle markierten DatensДtze aus der
entsprechenden Datenbank irreversibel gelФscht. Die Anzahl
aller in einer Datenbank vorhandenen DatensДtze lДсt sich mit
ILEN nr, laenge
ermitteln. Mit nr legen Sie entsprechende Datenbank Бber ihr
Handle fest. Ъber die Variable laenge wird Ihnen dann
mitgeteilt, wieviele DatensДtze dort enthalten sind.
Bewegen des Datenbankzeigers
Im vorhergehenden Abschnitt haben wir bereits einige
MФglichkeiten kennengelernt, den Datenbanksatzzeiger innerhalb
der Datenbank von einem Datensatz zu einem anderen zu bewegen.
Hier sollen alle diesbezБglichen Anweisungen zusammengestellt
werden.
Will man den Datenbanksatzzeiger um einen Datensatz gemДс des
aktuellen Index weiter bewegen, verwendet man INEXT:
INEXT nr, pos, s$
In der mit nr angesprochenen Datenbank wird der Zeiger um eine
Position weiter bewegt. Die Variable pos dient zur RБckgabe der
Information, ob der Datenbankanfang oder das Datenbankende
erreicht worden sind. Im ersteren Fall erhДlt pos den Wert
pos=4, im andern Fall den Wert pos=3. Ist das Dateiende
erreicht, wird der Datenbanksatzzeiger nicht weiter verstellt,
der letzte Satz bleibt aktiviert.
Mit s$ geben Sie die Recordstruktur an, in die der neue
aktuelle Datensatz geladen werden soll. Von dort aus kann er
den Eingabefeldern zur Bildschirmausgabe Бbergeben werden.
Der Zeiger wird mit IPREV um einen Datensatz zurБckgesetzt:
IPREV nr, pos, s$
Die Variablen haben dieselbe Bedeutung wie bei INEXT. Ist der
Datenbankanfang erreicht, wird der Zeiger nicht mehr verstellt.
Der erste Datensatz bleibt aktuell.
Diese beiden Befehle eignen sich hervorragend zum BlДttern in
einer Datenbank. Wir werden spДter in den Beispielprogrammen
viel von diesen Befehlen Gebrauch machen.
Sie haben auch die MФglichkeit, den Zeiger zum Anfang oder Ende
der Datenbank zu bewegen. Ersteres gelingt mit ISTART, letzeres
mit IENDE:
ISTART nr, s$
IENDE nr, s$
Ъber nr sprechen Sie die Datenbank an, s$ legt die
Recordstruktur fest, der der neue Datensatz zugewiesen werden
soll.
Eine zusДtzliche Bewegung nБtzt die Nummern aus, die DatensДtze
bei ihrer Aufnahme in eine Datenbank automatisch erhalten.
Diese Nummern sind unverДnderlich und unabhДngig davon, nach
welchem Kriterium die Datenbank sortiert wird.
Die Nummer des aktuellen Datensatzes erfahren sie mit
IGET_NR nr, pos
Ъber die Variable pos wird die entsprechende Nummer
zurБckgegeben. Sie kФnnen diese vermerken und den Datensatz
dann wie folgt ansprechen:
IGO_NR nr, pos
Der Datensatzzeiger wird nun auf den Datensatz mit der in pos
vermerkten Nummer gesetzt und damit zum aktuellen Datensatz.
Wenden Sie die Befehle zum Bewegen des Datenbanksatzzeigers in
einer Datenbank an, die keine DatensДtze enthДlt, so bekommen
Sie als Quittung eine Fehlermeldung, daс keine Daten in der
Datenbank gespeichert sind.
Suchen und Laden
Wir wollen nun versuchen, einen bestimmten Datensatz aus der
Datenbank herauszusuchen und auf dem Bildschirm anzeigen zu
lassen. Der erste Schritt muс natБrlich darin bestehen, dem
Anwender die Eingabe einer Suchvorgabe zu ermФglichen. Wie dies
programmtechnisch realisiert wird, werden wir spДter in
Beispielprogrammen kennenlernen. Uns soll hier nur
interessieren, daс der zu suchende Begriff (der SchlБsselwert)
letztendlich in einem Eingabefeld erscheinen muс, von wo er in
die entsprechende Variable der Recordstruktur eingelesen werden
kann.
Aus der Recordstruktur kann die Suchvorgabe leicht der
Datenbank Бbergeben werden, nДmlich mit
IREAD nr, ok, suchstring$, s$
Aus der Variable suchstring$ der Recordstruktur s$ wird der
entsprechende Begriff in die Datenbank mit bei nr angegebenen
Bezeichnung eingelesen. Es beginnt automatisch die Suche nach
diesem Begriff. Das Ergebnis wird Бber die Variable ok
mitgeteilt. Kann der Begriff gefunden werden, erhДlt ok den
Wert 0, ansonsten wird ein Wert ungleich Null Бbergeben.
Der Datenbanksatzzeiger wird nun auf den Datensatz gestellt,
der den Suchbegriff enthДlt. Beachten Sie aber bitte, daс das
Suchkriterium mit dem aktiven Index Бbereinstimmen muс. Sie
kФnnen beispielsweise nicht nach einer Adresse suchen, wenn der
Index auf das Feld "Name" gesetzt ist.
Um den aktuellen Datensatz in die Variablen der Recordstruktur
einzulesen, bedienen Sie sich der Anweisung IGETREC:
IGETREC nr, s$
FБr nr geben Sie wie Бblich die Bezeichnung der Datenbank an,
aus der der aktuelle Datensatz herausgeholt werden soll. Mit s$
legen Sie die Recordstruktur fest, in welche die Inhalte der
Datenbank Бbergeben werden sollen.
Um den herausgesuchten Datensatz auf dem Monitor anzuzeigen,
muс nur noch der Inhalt der Recordstruktur in Eingabefeldern
angezeigt werden. Wie dies mit SET_ITEM_ARRAY funktioniert,
haben wir bereits im Kapitel Бber Eingabefelder kennengelernt.
Es ist auch mФglich, mehrere DatensДtze gleichzeitig in ein
Array einzulesen. Dies ist besonders bei der Erstellung von
Listen vorteilhaft. Eine Liste sollte ja nach MФglichkeit alle
DatensДtze einer Datenbank anzeigen kФnnen. Damit dazu nicht
viele Male nacheinander IGETREC eingesetzt werden muс, steht
Ihnen folgendes zur VerfБgung:
IGETREC_ARRAY nr, flag, trenn$, dbstruct$, array$, start, ende,
feld1, feld2, ..
Der etwas ausfБhrlichere Parameterblock lДсt Ihnen einigen
Spielraum bei der Listenerstellung. ZunДchst muс die Kennummer
der Datenbank (nr) angegeben werden. Anschlieсend legen Sie
Бber flag fest, welche DatensДtze auсer dem aktuellen in die
Liste hineingenommen werden sollen. Mit flag=0 erreichen Sie,
daс vom aktuellen Datensatz aus die folgenden DatensДtze
angesprochen werden, wДhrend flag=1 die DatensДtze vor dem
aktuellen aktiviert.
In einer Liste wird der Inhalt einer Datenbank normalerweise so
angezeigt, daс die EintrДge in den einzelnen Variablen feld1 ,
feld2 usw. untereinander angeordnet werden.
Um dies zu erreichen, mБssen die Felder eines Datensatzes
wieder voneinander getrennt werden. Dies wird
programmtechnisch dadurch erreicht, daс ein Trennzeichen
zwischen die einzelnen Datensatzfelder eingefБgt wird. Dieses
Trennzeichen kФnnen Sie Бber trenn$ selektieren.
Als nДchstes gilt es, die Feldvariablen anzugeben, die die
Datenbankstruktur aufbauen. In unserem obigen Beispiel handelte
es sich um die Variablen feld1 bis feld4. Ъber array$ wird das
Array bestimmt, in das die entsprechenden Inhalte der Datenbank
eingelesen werden sollen. Hierbei legen Sie mit start und ende
die erste und die letzte zu benutzende Variable in diesem Array
fest.
Letztendlich geben Sie diejenigen Datenbankfeldvariablen an,
deren Inhalte in die Liste Бbergeben werden sollen. Sie haben
also die MФglichkeit, gezielt nur Teile von DatensДtzen
anzeigen zu lassen. MФchten Sie in unserem obigen graphischen
Beispiel nur jeweils den Namen und den Vornamen in der Liste
auffБhren, so geben Sie nur feld1 und feld2 an und lassen feld3
unberБcksichtigt.
Оndern
NatБrlich muс es eine MФglichkeit geben, in der Datenbank
bereits vorhandene DatensДtze nachtrДglich wieder zu Дndern.
Hierzu sucht man zunДchst den gewБnschten Datensatz aus der
Datenbank heraus, damit er zum aktuellen Datensatz wird und
lДсt sich diesen am Bildschirm anzeigen.
Nun fБhren Sie in den Datenfeldern der Eingabemaske die
gewБnschten ─nderungen durch. Der neue Inhalt muс in die
Variablen der Recordstruktur Бbergeben werden. Anschlieсend
wird die folgende Anweisung aufgerufen:
IMODREC nr, s$
Der aktuelle Datensatz in der mit nr bezeichneten Datenbank
wird mit dem Inhalt der Recordstruktur s$ Бberschrieben.
Wir wollen zur Verdeutlichung ein kleines Modul erstellen, daс
eine Speicherung der am Monitor in den Datenfeldern
vorgenommenen ─nderungen ermФglicht. FБr sich alleine ist es
natБrlich nicht lauffДhig. Wir wollen davon ausgehen, daс
bereits der aktuelle Datensatz in der Recordstruktur geladen
und am Monitor angezeigt ist. Es existieren drei Datenfelder
"Name", "Vorname" und "Adresse". Analog sind in der
Recordstruktur drei Variablen s1 bis s3 enthalten. Die
─nderungen werden jetzt am Bildschirm vorgenommen, anschlieсend
mit Aktivierung eines MenБbefehls folgendes Modul aufgerufen:
MODUL Daten_speichern ()
GET_ITEM "Name", s1
GET_ITEM "Vorname", s2
GET_ITEM "Adresse", s3
IMODREC 1, s
Mehr ist nicht notwendig, da der aktuelle Datensatz je bereits
am Monitor angezeigt ist. Es erfolgt lediglich ein Umschreiben
der Daten in der Datenbank. Die Anweisung GET_ITEM wurde im
Kapitel Бber Datenfelder erlДutert. Hiermit wird der Inhalt
eines Datenfeldes in eine Variable Бbergeben.
Ermitteln der Feldstruktur
Sollte aus irgendeinem Grund der Fall eintreten, daс Sie mit
einer Datenbank arbeiten mБssen, deren Aufbau Ihnen nicht
bekannt ist, brauchen Sie nicht zu verzweifeln. KIM hДlt einen
Befehl bereit, der die Feldstruktur einer Datenbank und der
zugehФrigen Indexdatei selbstДndig ermittelt. Es handelt sich
dabei um
IGETSTRUCT nr, def_felder, def_index, zahl
Sie mБssen lediglich die Kennummer der gewБnschten Datenbank
vorgeben. ZurБckgegeben wird Ihnen dann Бber def_felder die
Feldstruktur der Datenbank, Бber def_index die Feldstruktur der
Indexdatei und Бber zahl die Gesamtanzahl der Feldnamen in der
Datenbank.
Somit entspricht der Aufbau der RБckgabewerte denen im Befehl
ICREATE. Zur Verdeutlichung wollen wir ein kleines Programmodul
entwickeln, welches den Aufbau einer Datenbank ermittelt.
ZunДchst mБssen die benФtigten Variablen definiert werden,
wobei sinnvollerweise bei def_felder und def_index die
Maximalzahl an mФglichen Feldvariablen in Datenbank- und
Indexdatei, nДmlich 255, angegeben werden sollten. Anschlieсend
wird die Datenbank geФffnet und die Struktur ermittelt:
REM Ermittlung der Feldstruktur einer Datenbank
deffloat zahl, i
dim felder, 1, 255
dim index, 1, 255
dim def_felder, 1, 255
dim def_index, 1, 255
iopen 1, datei
istart 1, felder
igetstruct 1, def_felder, def_index, zahl
ΓòÉΓòÉΓòÉ 10. Eingabefelder ΓòÉΓòÉΓòÉ
Eingabefelder
Ъbersicht
In diesem Kapitel werden Sie alles Бber Eingabefelder erfahren.
Eingabefelder besitzen eine essentielle Bedeutung bei der
Kommunikation zwischen Anwender und Datenbankprogramm. Ъber sie
verlДuft Dateiein- und ausgabe.
KIM hДlt vier unterschiedliche Typen von Eingabefelder fБr Sie
bereit, die der Reihe nach behandelt werden. Es soll aufgezeigt
werden, wie die Felder Бber bestimmte Variablen mit dem
eigentlichen Programm verknБpft sind.
Den Abschluс des ersten Teils dieses Kapitels bilden die
verschiedenen Optionen, mit denen der eingegebene Feldinhalt
nachtrДglich formatiert, bearbeitet und verДndert werden kann.
Im zweiten Abschnitt werden Sie eine MФglichkeit kennenlernen,
wie Eingabefelder und sogar ganze Feldmasken auf viel
einfachere Art und Weise als Бber die Definition "per Hand"
erzeugt werden kФnnen. Hierzu dient der Maskengenerator. Es
wird die Handhabung dieses Utility-Programmes erklДrt, wie man
neue Feldobjekte erstellt und diese nachtrДglich modifizieren
kann.
Zum Schluс folgt ein Ausblick fБr professionellere KIM-
Anwender. Es wird erlДutert, wie einige Voreinstellungen des
Maskengenerators Бber den Quellcode bzw. die Betriebssysteme
modifiziert werden kФnnen. Dazu wird der Quellcode des
Maskengenerators absichtlich unverschlБsselt mitgeliefert. Von
dieser MФglichkeit sollten aber nur geБbte KIM-Programmierer
Gebrauch machen, da Manipulationen im Quellcode leicht zu
ProgrammabstБrzen fБhren kФnnen.
Erstellen von Eingabefeldern
Eingabefelder stellen das Verbindungsglied zwischen dem
Programm und der OberflДche dar. Ъber diese Felder kФnnen Sie
Eingaben tДtigen, die das Programm speichern und bearbeiten
kann. Andererseits ist das Programm aber auch in der Lage, Бber
solche Eingabefelder DatenbankeintrДge oder Werte von Variablen
an den Benutzer auszugeben.
Eingabefelder erscheinen im Normalfall als rechteckige Kasten
auf Ihrer ProgrammoberflДche. Wenn Eingaben in die Felder
getДtigt werden kФnnen, befindet sich ein blinkender Cursor im
Feld. Im Normalfall ist in KIM-Programmen jedem Eingabefeld
eine Variable (meist eine Бber DEFINE erstellte Feldvariable)
zugeordnet. Eingabefelder unterscheiden sich daher oft in der
Art der Eingabe, die sie akzeptieren, und sind nur selten
identisch.
Sie besitzen zwei MФglichkeiten, um Eingabefelder zu erzeugen.
Zum einen kФnnen Sie den dafБr erforderlichen Programmcode per
Hand erstellen, was wir in den ersten Abschnitten dieses
Kapitels aus didaktischen GrБnden vorfБhren werden. Die andere,
weitaus effizientere Methode besteht in der Verwendung des
Maskengenerators. Im zweiten Teil dieses Kapitels werden wir
dieses mДchtige Utensil des KIM-Editors im Detail kennenlernen
und mit ihm Eingabefelder erstellen.
Im Prinzip kann man vier unterschiedliche Arten von
Eingabefeldern unterscheiden. Die wichtigsten Felder sind
sicherlich diejenigen, die eindeutige Texteingaben wie Namen,
Vornamen, Adressen usw. erwarten und diese in die
entsprechenden Feldvariablen Бbergeben. Wir wollen diese Felder
als allgemeine Eingabefelder bezeichnen. Oft enthДlt ein
Datenbankprogramm mindestens ein Feld, in dem irgendein Text
ohne EinschrДnkung eingegeben werden kann. Da diese Felder oft
zur Angabe von Kommentaren verwendet werden, wollen wir sie
Kommentarfelder nennen.
Die letzten beiden Feldarten dienen speziell zur Eingabe bzw.
Ausgabe von Datum und Uhrzeit. Sie sollen daher als Datums- und
Zeitfelder bezeichnet werden.
Allgemeine Eingabefelder
Die wichtigsten Felder eines Datenbankprogramms sind sicherlich
die allgemeinen Eingabefelder. Hier werden die Daten
eingegeben, die eigentlich als Informationen in der Datenbank
gespeichert werden sollen. Gleichzeitig werden Бber diese
Felder die Daten aus der Datenbank wieder auf dem Bildschirm
ausgegeben.
Ein kennzeichnendes Merkmal allgemeiner Eingabefelder ist Ihre
definierte LДnge und Ihre Bedeutung fБr die Eingabe und Anzeige
Datenbankrelevanter Informationen. Hinter jedem allgemeinen
Eingabefeld steht eine Feldvariable, der der Inhalt des Feldes
zugewiesen wird und anschlieсend in die Datenbank Бbergeben
werden kann.
FБr die Aufgabe einer Feldvariable eignen sich am besten DEFINE-
Variablen. Diese kФnnen bekanntlich mit einer Zusatzbezeichnung
vordefiniert werden, was fБr dieses Programmierungsproblem das
beste ist. Durch die Zusatzbezeichnung erkennen Sie im
Quellcode Ihres Programmes sofort, welche Variable welchem Feld
zugeordnet ist. Unerheblich ist hingegen die Festlegung einer
bestimmten VariablenlДnge. Wie wir spДter kennenlernen werden,
wird die FeldgrФсe in DatensДtzen innerhalb der Datenbank
festgelegt. Darum ist es unerheblich, wie groс die hier
definierten Feldvariablen sind.
Der erste Schritt bei der Erstellung allgemeiner Eingabefelder
besteht also in der Definition der entsprechenden
Feldvariablen. Beispielsweise sollte eine Variable mit der
LДnge von 10 Zeichen, die dem Eingabefeld "Name" zugewiesen
ist, so erzeugt werden:
DEFINE feld1, 10 AS Name
Nun kФnnen wir daran gehen, das eigentliche Eingabefeld zu
definieren. Diese geschieht mit der Anweisung:
DEF_STRING id_string, x, y, len, text$, wert
Anstelle der Variablen id_string geben Sie wie Бblich die
Kennung des Objekts an, Бber die es angesprochen werden kann.
Ъber x und y legen Sie die Position des linken oberen Ecks des
Feldes in dem Fenster fest, dem es zugewiesen wird (wie wir
bereits im Kapitel Бber ProgrammoberflДchen kennengelernt
haben, mБssen alle OberflДchenobjekte einem Fenster zugewiesen
werden). Mit len legen Sie die LДnge des Eingabefeldes fest.
Aus logischen ErwДgungen sollte das Eingabefeld genauso lang
sein wie die zugehФrige Feldvariable, dies ist aber nicht
zwingend notwendig.
Weiterhin besitzen Sie die MФglichkeit, einen Vorgabetext zu
definieren, der im Eingabefeld jedesmal beim Programmstart
erscheinen soll. Hierzu weisen Sie der Variablen text$ den
entsprechenden Vorgabetext zu. Normalerweise sollten Sie als
Vorgabetext den aktuellen Feldinhalt der Variable aus der
Datenbank im Feld anzeigen lassen. Wie wir noch erfahren
werden, wird beim Щffnen einer Datenbank ein Datensatz zum
aktuellen Datensatz erhoben. Ъber wert legen Sie fest, wie lang
das Objekt auf dem Monitor erscheint. Ist len grФсer als wert,
kФnnen mehr Zeichen Бbergeben als angezeigt werden. Der Inhalt
wird dann durch das Objekt gescrollt.
Dieses Eingabefeld erscheint aber praktisch unsichtbar im
entsprechenden Fenster, da keine Umrandung vorhanden ist. Wenn
Sie ein Eingabefeld im Fenster sichtbar machen wollen, mБssen
Sie das FLAG "BORDER" der Definitionsanweisung hintanstellen
(bezБglich zu FLAGS siehe den entsprechenden Abschnitt im
Kapitel "Fenster und ProgrammoberflДchen"). Des weiteren kФnnen
Sie ein speziell fБr diesen Befehl vorhandenes FLAG einsetzen.
Setzen Sie das FLAG "PASS", so wird dieses Eingabefeld als
Eingabefeld fБr ein Passwort umfunktioniert. Der hier
eingegebene Text erscheint dann unsichtbar im Feld.
In das so erstellte Eingabefeld kФnnen Sie jetzt neue Eingaben
tДtigen. Der letzte Schritt besteht dann darin, den neuen
Inhalt des Eingabefeldes in die entsprechende Feldvariable zu
Бbergeben. Dies gelingt durch den Befehl:
GET_ITEM id_string, feld1
FБr id_string geben Sie die Kennung des Eingabefeldes an, feld1
bezeichnet die Feldvariable, der der neue Inhalt zugewiesen
werden soll.
Das eigentliche Eingabefeld mitsamt Verbindung zum Programm
wДre damit erstellt. Das Programm wird natБrlich
anwenderfreundlicher, wenn Sie auf der ProgrammoberflДche vor
jedem Eingabefeld eine Bezeichnung anfБhren, die dem Benutzer
erklДrt, welcher Inhalt in dem Eingabefeld plaziert werden
soll. Diese ErklДrung erstellen mittels des Befehls:
DEF_PROMPT id_string, x, y, "Text"
Auch dieses neue Textobjekt erhДlt eine Kennung Бber id_string.
Die Werte in den Variablen x und y legen fest, an welcher
Position der Text im zugewiesenem Fenster erscheinen soll.
Berechnen Sie diese Werte genau, damit der Text auch bei dem
Eingabefeld steht, zu dem er gehФrt. Anstelle von "Text" geben
Sie die gewБnschte Bezeichnung ein.
Ein in ein allgemeines Eingabefeld eingegebener Inhalt kann,
wie spДter in diesem Kapitel erlДutert, nachtrДglich bearbeitet
und formatiert werden. Sie kФnnen dies in gewissem Umfang aber
bereits bei der Definition des Eingabefeldes tun. Hierzu dient
die Anweisung DEF_INPUT (im Gegensatz zur oben vorgestellten
allgemeineren Form DEF _STRING):
DEF_INPUT id_string, x, y, len, text$, maske, schablone
Die ersten fБnf Variablen id_string, x, y, len und text$
entsprechen in Ihrer Bedeutung dem Parameterblock des bereits
bekannten Befehls DEF_STRING. Neu sind die Formatieroptionen
Бber die Variablen maske und schablone. Hier kФnnen Sie
vorgeben, welche Zeichen Бberhaupt als Eingabe zugelassen
werden und diese sofort in Groсbuchstaben verwandeln. Eine
Liste an Vorgaben in der Variable maske soll Ihre MФglichkeiten
verdeutlichen:
maske=c Alle alphanumerische Zeichen kФnnen eingegeben
werden.
maske=C Alle alphanumerische Zeichen kФnnen eingegeben
werden,es erfolgt aber sofort Umwandlung in
Groсbuchstaben.
maske=a Nur die Buchstaben von a-z ohne Zahlen und
Sonderzeichen kФnnen eingegeben werden.
maske=A Analog wie bei maske=a, aber alle Zeichen werden
sofort in Groсbuchstaben umgewandelt.
maske=N Nur Zahlen kФnnen eingegeben werden.
maske=x Es kФnnen nur druckbare Zeichen eingegeben werden.
maske=X Analog wie bei maske=x, aber alle Zeichen werden
sofort in Groсbuchstaben umgewandelt.
maske=L Es kФnnen alle Zeichen eingegeben werden, die in der
Variablenschablone vorgegeben werden. Nur bei
dieser Option ist es notwendig, der Variablenschablone
einen Inhalt zuzuweisen. Bis zu 255 beliebige Zeichen
sind so als Eingabe vorgebbar.
Kommentarfelder
Neben den allgemeinen Eingabefeldern, Бber die die eigentlichen
DatensДtze definierter LДnge Бbergeben werden, findet man oft
in Datenbankprogrammen ein zusДtzliches, meist grФсeres
Eingabefeld, welches eine beliebige Texteingabe erlaubt. Ein
solches Eingabefeld ermФglicht dem Anwender die Angabe von
Kommentaren beliebige LДnge, um seinen DatensДtzen zusДtzliche
Informationen mitzugeben. Ein solches Kommentarfeld ist daher
extrem benutzerfreundlich und sollte nach MФglichkeit in jedem
Programm vorhanden sein.
Damit die Kommentare den entsprechenden DatensДtzen in der
Datenbank angefБgt werden kФnnen, muс das Kommentarfeld
ebenfalls Бber eine Feldvariable mit dem Programm verknБpft
werden. HierfБr sind DEFINE-Variablen natБrlich geeignet, aber
auf 255 Zeichen LДnge beschrДnkt. Wenn man lДngere
Kommentareintragungen zulassen mФchte, muс als Variable im
Hintergrund eine MEMO-Variable eingesetzt werden. Wie bereits
besprochen kФnnen MEMO-Variablen bis zu 64000 Zeichen Inhalt
aufnehmen.
Das eigentliche Kommentarfeld sollte dann ebenfalls unabhДngig
von irgendwelchen ZeichenbeschrДnkungen sein. Ein mit
DEF_STRING erstelltes Eingabefeld kann aber nur maximal eine
Zeile lang sein. Deshalb gibt es den anderen Befehl:
DEF_TEXT id_string, x, y, breite, hoehe, anzahl, array
Ъber id_string vergeben Sie wie Бblich die Objektkennung. x und
y legen die Position der linken oberen Ecke des Feldes in dem
Fenster fest, dem das Feld zugewiesen wird. Ъber breite und
hoehe wird bestimmt, wie breit und hoch das Kommentarfeld
werden soll.
NatБrlich kФnnen Sie auch diesem Feld einen Vorgabetext
zuweisen, der jedesmal beim Programmstart darin erscheint.
Hierzu Бbergeben Sie der Variablen array den entsprechenden
Vorgabetext, wobei es sich dabei natБrlich wieder um eine
Variable mit Datenbankinhalt handeln kann.
Letztendlich legen Sie mit der Variablen anzahl fest, wie viele
Zeichen in das Eingabefeld eingefБgt werden dБrfen. Beachten
Sie dabei, daс der Maximalinhalt durch die Natur der zugrunde
liegenden Feldvariablen determiniert ist. Im gБnstigsten Falle,
wenn es sich um eine MEMO-Variable handelt, sind dies 64000
Zeichen.
Das so erzeugte Kommentarfeld geht aber Бber den Status einer
einfachen Eingabebox hinaus. Sie kФnnen hier auf einfache
Editierfunktionen zurБckgreifen, die denen der Zwischenablage
unter Windows bzw. dem Systemeditor unter OS/2 entsprechen.
NДheres erfahren Sie in den HandbБchern Ihrer Betriebssysteme.
Zeitfelder
KIM erlaubt Ihnen auch, Eingabefelder zu erstellen, die
speziell fБr die Eingabe einer Uhrzeit gedacht sind. Das
Zeitfeld wird dann wie folgt definiert:
DEF_INPUT_TIME id_string, x, y, len, vorgabe$, intervall$
Wie Бblich wird eine Objektkennung Бber id_string zugewiesen, x
und y legen die Position der linken oberen Ecke des Feldes in
dem Fenster fest, dem es zugewiesen wird. Mit len bestimmen Sie
die LДnge des Eingabefeldes, wobei Sie wie immer an die LДnge
der Feldvariablen gebunden sind.
Auch in diesem Feld kФnnen Sie eine Vorgabe erzeugen, die
jedesmal beim Programmstart darin erscheint. Geben Sie hierzu
Бber die Variable vorgabe$ den gewБnschten Eintrag ein. Wenn
Sie keine Vorgabe festlegen, sucht sich der Rechner automatisch
aus dem ROM-BIOS die aktuelle Uhrzeit und schreibt sie in das
Eingabefeld. Das hierfБr verwendete Format ist das Бbliche
deutsche, also z.B. 19
Letztendlich kФnnen Sie festlegen, daс nur eine Uhrzeit
eingetragen werden kann, die in einem bestimmten Intervall
liegt. Dieses Zeitintervall bestimmen Sie Бber intervall$.
MФchten Sie beispielsweise, daс nur eine Uhrzeit zwischen 12.00
Uhr und 14.00 Uhr in das Eingabefeld eingegeben werden darf, so
geben Sie in die Variable folgendes ein: "12.00..14.00".
Beachten Sie bitte, daс auch hier das deutsche Format fБr die
Zeitangabe vorgeschrieben ist. MФchten Sie kein
Vorgabeintervall festlegen, Бbergeben Sie einfach einen
Leerstring " ".
Es stehen Ihnen zahlreiche FLAGS zur VerfБgung, um das Format
dieses Eingabefeldes zu beeinflussen
(siehe Objekteigenschaften).
Um die Eingaben in die Datenbank zu Бbergeben, verknБpfen Sie
das Eingabefeld wie bereits besprochen Бber GET_ITEM mit der
Feldvariablen. Eine Feldbezeichnung auf der ProgrammoberflДche
erstellen Sie auf bekannte Weise Бber DEF_PROMPT.
Datumsfelder
Zuletzt kФnnen Sie auch Eingabefelder definieren, die speziell
zur Eingabe von Datumsangaben konzipiert sind. Diesen Feldern
liegt ebenfalls eine zuvor zu erzeugende DEFINE-Variable
zugrunde. Die eigentliche Definition erfolgt dann Бber
DEF_INPUT_DATE id_string, x, y, len, vorgabe$, range
Die Variablen id_string, x, y, len und vorgabe$ entsprechen in
Ihrer Bedeutung exakt den Variablen aus dem Parameterblock des
Befehls DEF_INPUT_TIME.
Geben Sie keinen Vorgabetext Бber vorgabe$ ein, sucht der
Computer aus dem ROM-BIOS das aktuelle Tagesdatum und schreibt
dieses in die Variable. Das hierbei verwendete Format sieht so
aus: TT/MM/YY, also z.B. 12/06/1993. Ъber range kФnnen Sie auch
hier ein Vorgabeintervall festlegen, in welchem das
einzutragende Datum liegen muс, z.B. "01/01/1988..01/10/1988".
Das als Eingabe akzeptierte Datum muс dann in diesem Intervall
liegen. Wird keine Vorgabe gewБnscht, Бbergeben Sie den
Leerstring " ". Beachten Sie bitte, daс bei Eingabe eines
Datums immer das Jahrhundert bei der Jahreszahl stehen muс,
also 1991 und nicht 91.
Bearbeiten von Dateneingaben
HinzufБgen und Entfernen von Leerzeichen
Oft werden die in die Felder eingegebenen Inhalte nicht den
vollen Platz der zugehФrigen Feldvariablen beanspruchen. Wenn
beispielsweise ein aus fБnf Buchstaben bestehendes Wort in eine
Feld von zehn Zeichen GrФсe eingegeben wird, hДngt KIM
zusДtzlich fБnf Leerzeichen an das Wort an. Dies kann im
Einzelfall unerwБnscht sein, da dadurch die GrФсe der
DatensДtze steigt. Abhilfe schafft hier der Befehl:
COMPRESS string$
Geben Sie einfach den Namen der zu bearbeitenden
Stringvariablen an. Es werden aus dieser Variablen alle
Leerzeichen nach dem eigentlichen Inhalt entfernt.
Es wДre allerdings mБhselig, auf diese Art ein ganzes
Variablenarray zu bearbeiten. Deshalb steht Ihnen ein kleine
Abart von COMPRESS zur VerfБgung, der speziell auf Arrays
zugeschnitten ist. Nehmen wir an, Sie mФchten die Variablen 1
bis 3 des Arrays Feld von БberschБssigen Leerzeichen befreien,
so geben Sie ein:
COMPRESS2 feld,1,3
Bereits kennengelernt haben wir ja die Anweisung CLEAR, die den
gesamten Inhalt von Variablen eines Arrays lФscht.
Es kann aber auch vorkommen, daс links vor dem Inhalt in einer
Stringvariablen Leerzeichen vorhanden sind (z.B. wenn bei der
Eingabe in ein Feld nicht beim ersten Zeichen ganz links
begonnen wurde). Diese Leerzeichen lassen sich mit LTRIM wieder
entfernen:
LTRIM string$
Damit werden alle Leerzeichen links vom Variableninhalt
gelФscht.
Manchmal kann es aber geradezu erwБnscht sein, an den Inhalt
einer Stringvariablen Leerzeichen anzufБgen, um z.B. mehrere
Variablen auf eine bestimmte LДnge zu formatieren. Um
Leerzeichen links vom Inhalt einzufБgen, bedienen Sie sich der
Anweisung RSET:
RSET laenge, string$
FБr die Variable laenge geben Sie die Anzahl der Zeichen an,
die die zu bearbeitende Variable string$ nach der Operation
besitzen soll. Wenn Sie z.B. die Variable text="Hallo" mit fБnf
Leerzeichen links vom Inhalt fБllen mФchten, geben Sie ein:
RSET 10, text
Das Ergebnis sieht dann so aus: text=" Hallo".
Analog kФnnen Sie mit SET Leerzeichen nach dem Inhalt einer
Variablen anfБgen, wobei Sie bei RSET verfahren:
SET laenge, string$
Die GrФсe des Inhalts einer Stringvariablen ermitteln Sie mit
dem Befehl LEN:
LEN string$, zahl
Es wird dann ermittelt, wieviel Zeichen sich in der Variablen
string$ befinden, wobei Leer- und Satzzeichen mitgezДhlt
werden. Das Ergebnis wird in die Zahlenvariable zahl Бbergeben,
aus der es abgerufen werden kann.
Beachten Sie, daс all diese Operationen nur mit String-(bzw.
Define- oder Memo-)- variablen durchgefБhrt werden kФnnen,
nicht aber mit Zahlenvariablen.
Umwandlung von Groс- und Kleinbuchstaben
KIM erlaubt Ihnen, den Inhalt von Stringvariablen gesamt in
Groс- oder Kleinbuchstaben zu verwandeln. Um Groсbuchstaben in
Kleinbuchstaben umzuwandeln, bedienen Sie sich des Befehls
LCASE:
LCASE string$
Analog lassen sich mit UCASE alle Kleinbuchstaben in
Groсbuchstaben modifizieren:
UCASE string$
SelbstverstДndlich ergeben diese Anweisungen nur einen Sinn bei
Stringvariablen, nicht aber bei Zahlenvariablen.
Suchen
KIM ermФglicht Ihnen auch, in Variablen nach einem bestimmten
Inhalt zu suchen. Wenn Sie beispielsweise wissen mФchten, ob in
der Variablen name der Begriff "Meier" zu finden ist, so geben
Sie den Suchbegriff in eine Variable suchen ein:
IN name, suchen, gefunden
Das Programm sucht nun in der Variablen name nach dem in der
Variablen suchen vorgegebenen Inhalt. Das Resultat des Suche
wird in der Variablen gefunden gespeichert. War die Aktion
erfolgreich, so wird die Position des Begriffs im String als
Zahl Бbergeben. War die Suche negativ, erhДlt gefunden den Wert
-1. SelbstverstДndlich kФnnen Sie auch nur nach einem einzigen
Zeichen suchen.
Speziell fБr die Suche in Arrays vorgesehen ist der Befehl
FIND:
FIND array$, start, ende, suchen, gefunden
Geben Sie das zu durchsuchende Array und anschlieсend die
Kennummern der Feldvariablen an, bei denen die Suche begonnen
bzw. beendet werden soll. Der zu suchende Begriff wird in der
Variablen suchen vorgegeben, das Ergebnis analog zu IN in der
Variablen gefunden gespeichert.
VerДndern
SelbstverstДndlich sollten Sie in der Lage sein, den Inhalt von
Variablen nach der Eingabe zu manipulieren. KIM stellt Ihnen
hierfБr mehrere MФglichkeiten zur Auswahl.
Ein bestimmtes Zeichen einfБgen kФnnen Sie mit FILLSTR. Wenn
Sie beispielsweise fБnfmal das Zeichen "A" in die Variable
Zeichen eingeben mФchten, gehen Sie so vor:
FILLSTR 5, Zeichen, "A"
Beachten Sie bitte, daс damit nur ein Zeichen auf einmal
(allerdings in beliebiger Anzahl) in eine Variable eingefБgt
werden kann.
Ganze TextstБcke bzw. der Inhalt anderer Variablen lassen sich
mittels STRADD einfБgen:
STRADD string$, "Text"
Der Variablen string$ wird so ein Text zugefБgt. Setzen Sie
anstelle von text den Namen einer Variablen ein, so wird deren
Inhalt in string$ eingefБgt.
Im Gegensatz dazu kФnnen Sie mit STRDEL wieder StБcke aus dem
Inhalt einer Variablen entfernen. Nehmen wir an, Sie haben eine
Variable Name mit dem Inhalt "Meisinger", mФchten diesen Inhalt
aber in "Meier" Дndern. Sie geben ein:
STRDEL Name, 4,4
Die erste Zahl nach dem Variablennamen gibt die Position im
Inhalt an, ab der Zeichen gelФscht werden sollen. Die zweite
Zahl legt fest, wieviele Zeichen ab dieser Position entfernt
werden. In unserem Falle waren das vier Zeichen ab der Position
vier, also die Zeichen "sing".
Es ist Ihnen auch mФglich, nur Teile des Inhalts einer
Stringvariablen in eine andere Variable zu kopieren. Hierzu
dient die Anweisung MID:
MID string$, neu$, anfang, anzahl
Hiermit werden Teile aus der Variablen string$ in die Variable
neu$ eingefБgt. Mit anfang legen Sie die Position im Inhalt der
Variablen string$ fest, ab der Zeichen kopiert werden sollen.
Anzahl bestimmt die Zahl der Zeichen ab der selektierten
Position, welche in neu$ eingefБgt werden.
Der Inhalt einer Stringvariablen lДсt sich zerlegen und auf
mehrere andere Variablen eines Arrays verteilen. Hierbei
orientiert sich KIM an ein von Ihnen festzulegendes
Trennzeichen:
SELECT string$, ord, s$, m, n
Der Inhalt der Variablen string$ wird geteilt und in die
Variablen m bis n des Arrays s$ Бbergeben. Die Teilung erfolgt
an dem Trennzeichen, dessen ASCII-Codewert (vgl. Tabelle im
Anhang dieses Buches) Sie in die Variable ord schreiben mБssen.
Sie kФnnen auch den Inhalt einer Stringvariablen ganz oder
teilweise austauschen. Rufen Sie hierzu auf:
REPLACE text$, alt$, neu$
In der Variablen text$ wird dann die in alt$ aufgefБhrte
Zeichenkette gegen den Inhalt von neu$ ausgetauscht.
Eine Besonderheit stellen letztendlich Stringvariablen dar,
deren Inhalt aus einem mathematischen Ausdruck wie z.B. "2+3"
besteht. Ist dies der Fall, haben Sie die MФglichkeit, diese
Berechnung durchfБhren zu lassen:
EVAL string$, erg
Die mathematische Rechnung in der Variablen string$ wird
durchgefБhrt, das Ergebnis in der Variablen erg gespeichert.
Alle bisherigen Befehle haben sich auf Stringvariablen bezogen.
Zuletzt wollen wir noch eine Anweisung Zahlenvariablen
betreffend kennenlernen. Will man den Inhalt einer
Zahlenvariablen teilen, so kann das eigentlich nur an einer
logischen Position geschehen, nДmlich am Komma in einer
Dezimalzahl. Der Befehl FRAC erledigt dies:
FRAC zahl, vor nach
Der Inhalt der Variable zahl (bei dem es sich nur um eine
einzige Zahl handeln kann) wird geteilt. Die Vorkommastellen
werden der Variablen vor Бbergeben, die Nachkommastellen der
Variablen nach. Somit entspricht FRAC der String-Anweisung
SELECT, ist aber naturgemДс weniger flexibel in Bezug auf die
Teilungsposition.
ΓòÉΓòÉΓòÉ 11. Programmieren mit KIM ΓòÉΓòÉΓòÉ
Programmieren mit KIM
EinfБhrung
In diesem Kapitel wollen wir das bisherige theoretische Wissen
anwenden und funktionstБchtige Programme mit KIM erstellen.
Dazu benФtigen wir aber noch einige weitere Informationen.
So wurde zwar bisher vorgestellt, wie ProgrammoberflДchen,
Fenster, Eingabemasken oder Datenbanken erzeugt werden kФnnen,
aber gewissermaсen blieben all diese Programmelemente ohne "Leben",
da bisher nicht darauf eingegangen wurde, wie sie angesprochen und
aktiviert werden kФnnen. In diesem Abschnitt wollen wir den bereits
bekannten Rohbau zu lauffДhigen Programmen verknБpfen.
Events
Programme, welche unter graphischen BenutzeroberflДchen wie Windows
oder OS/2 laufen, benutzen praktisch immer einen eventorientierten
Programmablauf. Darunter versteht man, daс ein solches Programm
solange "untДtig" wartet, bis der Anwender ein Ereignis (ein Event)
auslФst, auf welches das Programm dann reagiert.
Ein solches Event kann ein Mausklick auf einen Funktionsbutton
oder einen MenБpunkt sein, aber auch das AuslФsen eines Hotkeys.
Alle auftretenden Ereignisse werden von einem sogenannten
Event-Manager gesteuert. Dieser ist kein KIM-spezifisches Element,
sondern ist Bestandteil des Betriebssystems. Das ist natБrlich
auch notwendig, damit beispielsweise die Befehle des SystemmenБs,
welche nicht auf KIM bezogene Aktionen auslФsen, ordnungsgemДс
durchgefБhrt werden kФnnen. Des weiteren kann nur so das
Multitasking, also das gleichzeitige Bearbeiten mehrerer Programme
zur gleichen Zeit, vom Betriebssystem gewДhrleistet werden.
Der Event-Manager des Betriebssystems (egal, um welches es sich dabei
handelt)wird von KIM aus durch folgenden Befehl angesprochen:
WIN_EV i
Hierdurch wird die Kontrolle Бber alle Computeraktionen an den
Event-Manager Бbergeben. Dieser БberprБft nun alle vom Anwender
ausgelФsten Ereignisse und gibt entsprechend einen numerischen Wert
Бber die Variable i an das Programm zurБck. Es ist fБr Sie nicht
relevant, welche Werte bei bestimmten Ereignissen genau Бbergeben
werden. Wichtig ist lediglich, daс beim Beenden des Programmes
(wenn also alle Fenster geschlossen werden) vom Event-Manager
der Wert 1000 an das KIM-Programm zurБckgegeben wird.
Wie lДсt sich nun die Event-orientierte Steuerung programmtechnisch
durchfБhren? Es ist einsichtig, daс die LФsung dieser Aufgabe im
Erstellen einer Schleife besteht.
Innerhalb dieser Schleife wird der Event-Manager mittels WIN_EV
aufgerufen. Sobald der Benutzer ein Ereignis auslФst, teilt der
Event-Manager dies dem Programm mit und gibt die Kontrolle an
das KIM-Programm zurБck, damit dieses geeignet auf das Event
reagieren kann. Ist dies geschehen, kehrt das Programm zum
Schleifenbeginn zurБck, um auf ein neues Ereignis zu warten.
Diese Schleife wird erst dann beendet, wenn der Event-Manager
den Wert 1000 zurБckgibt. Dann ist das Programm vom Benutzer
fБr beendet erklДrt worden. Nach der Schleife wird
dementsprechend auch das KIM-Programm abgeschlossen.
GeФffnete Datenbanken mБssen hierzu mit ICLOSE geschlossen werden,
ehe der Befehl END den Programmcode abschlieсt. Denken Sie unbedingt
daran, mit END das Programm zu beenden, da sonst Fehlfunktionen
auftreten kФnnen.
Wie erreicht man, daс ein KIM-Programm entsprechend der vom Anwender
ausgelФsten Ereignisse reagiert? Im Normalfall werden bei graphischen
BenutzeroberflДchen alle Events mit Hilfe einer Maus aktiviert.
Der Event-Manager registriert, welches OberflДchenobjekt selektiert
(auf welches Objekt der Mauscursor zeigt) und
welche Maustaste gedrБckt wurde. Im Normalfall steht dabei die
linke Maustaste fБr die Enter-Taste, also die BestДtigung der Auswahl.
Diese Informationen kФnnen Sie mit folgender Anweisung in Ihr
KIM-Programm einlesen:
GET_ITEM_POS id_string, taste
Ъber die Variable id_string wird die Kennung des ausgewДhlten
Objekts zurБckgegeben. In der Variablen <taste> wird der
ASCII-Codewert der zuletzt gedrБckten Taste gespeichert.
Handelt es sich dabei um die linke Maustaste, wird der Wert 13
Бbergeben.
Nun muс natБrlich eine Programmverzweigung folgen, da
unterschiedliche Events verschiedene Aktionen auslФsen sollen.
Wir wollen dabei beachten, daс der Quellcode eines Programmes so
Бbersichtlich wie mФglich aufgebaut sein sollte.
Deshalb sollten die einzelnen IF-Anweisungen nicht in der
gerade beschriebenen Event-Schleife (die Schleife, in welcher
der Event-Manager angesprochen wird) aufgefБhrt sein, sondern
mФglichst in einem gesonderten Modul angefБgt werden. Dieses Modul
wird aus der Event-Schleife heraus bei entsprechenden Ereignissen
aktiviert, arbeitet die entsprechenden Aktionen ab und fБhrt danach
das Programm in die Event-Schleife zurБck.
Wir wollen als Beispiel eine typische Event-Schleife erstellen.
Am geeignetsten ist hierfБr eine WHILE-WEND-Schleife, die dann
abgebrochen wird, wenn die Variable _i vom Event-Manager den
Wert 1000 zugewiesen bekommt.
Innerhalb der Schleife wird der Event-Manager aktiviert.
Die von diesem zurБckgegebenen Resultate eines ausgelФsten
Ereignisses werden mit GET_ITEM_POS in das Programm eingelesen.
Daraufhin wird ein Modul namens <auswerten> aktiviert, daс die
Auswertung der entsprechenden Events Бbernimmt. In unserem Beispiel
wird dieses Modul aufgerufen, wenn die linke Maustaste
(oder Enter-Taste) gedrБckt wurde. Mit WEND kehrt man anschlieсend
zum Schleifenbeginn zurБck. Nach Schleifenabbruch (bei _i=1000)
werden Datenbanken geschlossen und das Programm beendet.
REM Event-Schleife fБr ein beliebiges Programm
DEFFLOAT _i, taste
DEFSTRING objekt
WHILE _i<>1000
WIN_EV i
GET_ITEM_POS objekt, taste
IF taste=13 THEN
CALL auswerten (objekt, i)
ENDIF
WEND
ICLOSE
END
Diese Event-Schleife ist natБrlich fБr sich allein kein vollstДndiges
Programm und somit nicht lauffДhig.
Um auf ein Event zu reagieren, bietet KIM noch eine weitere elegante
MФglichkeit : die Eventfunktionen.
Wir haben gelernt, daс jedes Objekt eine ID-Kennung besitzt.
FБr eine ID-Kennung sollte ein sprechender Name genommen werden.
(z.B die ID-Kennung "BUTTON1" fБr ein Buttonobjekt )
Eine Eventfunktion ist ein Modul mit einem zusammengesetzten
Modulnamen. Der erste Teil des Modulnamens entspricht der
ID-Kennung und der zweite Teil der Eventidentifizierung.
MODUL BUTTON1_SELECT()
ENDMOD
Sobald ein Event erzeugt wird, prБft KIM ob ein entsprechendes Modul
definiert ist. Ist dies der Fall, wird das Modul ausgefБhrt.
Die Nutzung von Eventfunktionen fБhrt zu geringfБgig mehr Code,
aber ist in den meisten FДllen die Бbersichtlichere Variante.
REM Event-Schleife fБr ein beliebiges Programm
DEFFLOAT _i
WHILE _i<>1000
WIN_EV i
WEND
ICLOSE
END
REM **** Programm beenden wenn Button gedrБckt ****
MODUL BUTTON1_SELECT()
_i=1000
ENDMOD
Eine Kombination aus der ersten und zweitern Version ist erlaubt.
Aufbau eines KIM-Programmes
Wir haben nunmehr alle notwendigen Bestandteile eines KIM-Programmes
kennengelernt. Diese sollen hier rekapituliert und in der richtigen
Reihenfolge angeordnet werden.
Am Anfang eines Programmcodes hat immer die Definition der
ProgrammoberflДche zu stehen. Definieren Sie also zunДchst ein
Hauptfenster. Anschlieсend erzeugen Sie alle weiteren OberflДchenobjekte
und weisen diese dem Hauptfenster mittels ADD_ITEM oder
ADD_ITEM_ARRAY zu. Beachten Sie dabei, daс das Hauptfenster als
erstes Fenster geФffnet wird.
Der nДchste Schritt besteht im Definieren und Щffnen einer
zugehФrigen Datenbank.
Halten Sie sich dabei an die im Kapitel Programmieren von
Datenbanken beschriebene Vorgehensweise. Danach kann das
Hauptfenster und damit die ProgrammoberflДche aufgerufen werden.
Dies geschieht bekanntlicherweise mit WIN_PAINT.
Das eigentliche Programm folgt im Anschluс daran.
Programmieren Sie eine Eventschleife, in welcher die
Programmsteuerung an den Event-Manager des Betriebssystems
Бbergeben wird.
Bei entsprechenden Ereignissen muс eine Verzweigung
aktiviert werden, in der die Events ausgewertet werden.
Wird der Wert 1000 zurБckgegeben, ist das Programm als beendet
anzusehen.
Alle geФffneten Datenbanken mБssen dann geschlossen und der
Quellcode mit END terminiert werden.
Im Einzelfall kann natБrlich der eine oder andere Teil im Programm
nicht vorhanden sein. Bei unseren Beispielprogrammen wird dies
manchmal auftreten. So ist es mФglich, ein Programm auch ohne
Eventschleife funktionsfДhig zu machen. Hierzu muс der Befehl
DUMMY_EVENT
eingebaut werden. Auch dadurch wird der Event-Manager aktiviert.
Es erfolgt aber keine RБckgabe von Events an das Programm.
Folgerichtig kФnnen keine Aktionen in einem solchen Programm
ausgefБhrt werden. Vielmehr dienen solche Werke lediglich zum
Erzeugen von ProgrammoberflДchen. Mit dem Schlieсen des letzten
Fensters beendet der Event-Manager automatisch das Programm.
Aus GrБnden der Ъbersichtlichkeit sollten mФglichst viele
Programmteile aus dem Hauptprogramm ausgelagert werden.
Dies erreicht man durch die Erzeugung von Modulen, in denen
alle wichtigen Teile enthalten sind und welche vom Hauptprogramm
aus aktiviert werden. Des weiteren haben Module den Vorteil, daс sie nicht
nur in einem einzigen Programm benutzt werden kФnnen,
sondern beliebig oft verwendbar sind.
Ein typischer Programmablauf unter KIM kФnnte dann schematisch
wie folgt aussehen:
- Variablendefinition
- Definition des Hauptfensters und Objekte (OberflДche)
- Definition und Щffnung einer Datenbank
- Darstellen der OberflДche mit WIN_PAINT
- Eventschleife (Aufruf verschiedener Eventfunktionen)
- Schlieсen der Datenbanken
- Programmende (END)
Beispiele
ProgrammoberflДchen
In diesem Abschnitt wollen wir beispielhaft einige verschiedene
ProgrammoberflДchen erstellen. Dabei soll die KomplexitДt derselben
schrittweise gesteigert werden.
ZunДchst wird ein Hauptfenster mit dem notwendigsten Inhalt erzeugt.
Im Anschluс daran werden zusДtzliche Objekte definiert und dem
Hauptfenster hinzugefБgt.
Einfaches Hauptfenster
Grundlage jeder noch so komplexen ProgrammoberflДche ist ein
Hauptfenster. Wie bereits im entsprechenden Kapitel erlДutert
sollte ein Hauptfenster zumindest folgende Objekte besitzen:
- Eine Begrenzung ist unbedingt notwendig, da sonst beim HinzufБgen
weiterer Objekte Fehler auftreten.
- Einen Systembutton zur Kommunikation mit dem Betriebssystem (wahlweise)
- Maximierungs- und Minimierungsbuttons (wahlweise)
Wie hat das Programm auszusehen, welches dieses Fenster erzeugt?
Halten wir uns an den typischen Programmablauf. ZunДchst wird der
Befehl das Modul zur Erzeugung des Fensters aufgerufen, anschlieсend
wird das Fenster mit WIN_PAINT auf dem Monitor angezeigt.
Da noch keine Datenbank bzw. weitere Objekte definiert werden sollen,
kommen wir gleich zur Eventschleife. Es geht uns jetzt nur um die
OberflДche, nicht um irgendwelche Programmfunktionen.
Deshalb werden wir statt einer Eventschleife den Befehl DUMMY_EVENT
verwenden (siehe vorhergehenden Abschnitt).
Damit ist das Programm auch schon fertig:
REM Programm zur Erzeugung eines einfachen Hauptfensters
REM ZunДchst das Hauptprogramm
CALL fenster()
WIN_PAINT "window"
DUMMY_EVENT
END
REM Nun das Modul mit der Definition des Fensters
MODUL fenster()
def_window_st "window",1,1,20,10,"Testfenster"
ENDMOD
Wichtig !
Objekt-IDs kФnnen global angesprochen werden.
Beenden lДсt sich das Programm, indem sie mit der linken
Maustaste den Systembutton (links oben) anklicken.
Es Фffnet sich dann das SystemmenБ. WДhlen Sie dort die Option
"Schlieсen" (bzw. "Close") aus. Das Hauptfenster wird geschlossen,
woraufhin der Event-Manger sofort das Programm fБr beendet erklДrt.
Sie kehren zu Ihrem Betriebssystem zurБck.
Hauptfenster mit Toolbar
Als nДchste wollen wir unsere ProgrammoberflДche um eine Toolbar
erweitern. Diese soll aus fБnf Buttons mit den Aufschriften "Neu",
"Speichern", "LФschen", "Finde" und "Beenden" bestehen.
Es geht uns hier wohlgemerkt nur um den Aufbau der OberflДche.
Die entsprechenden Aktionen sollen und kФnnen noch nicht ausgefБhrt
werden, da weder Eingabefelder noch Datenbanken im Programm
vorhanden sind.
Vom Programmablauf her gibt es kaum Neuerungen. Wir bleiben unserer
Linie treu.Beachten Sie bitte, daс hier die Positionierung der Toolbar
Бber das FLAG "REGION OFF" erfolgt, wodurch das Objekt so weit wie
mФglich an den oberen Fensterrand gesetzt wird.
MФchten Sie Ihre Toolbar anders plazieren, mБssen Sie die
entsprechenden Positionswerte angeben und das FLAG weglassen.
Der Programmcode lautet dann:
REM Programm zur Erzeugung eines Hauptfensters mit Toolbar
REM ZunДchst das Hauptprogramm
CALL fenster()
WIN_PAINT "window"
DUMMY_EVENT
END
REM Nun das Modul mit der Definition des Fensters
MODUL fenster()
def_window_st "window",1,1,50,10,"Testfenster"
def_toolbar "toolbar", 0, 0, 60, 5,;"region off"
def_button "b0", 0, 0, 10, " ", "Neu"
def_button "b1", 0, 0, 10, " ", "Speichern"
def_button "b2", 0, 0, 10, " ", "Loeschen"
def_button "b3", 0, 0, 10, " ", "Finde"
def_button "b4", 0, 0, 10, " ", "Beenden"
add_item "toolbar",..
"b0",..
"b1",..
"b2",..
"b3",..
"b4"
add_item "window", "toolbar"
ENDMOD
Die Arbeitsweise von KIM ist einfach. Es werden Objekte mit bestimmten
ID-Kennungen (z.B b0,b1,...) definiert. Nun muс man die Einzelobjekte
(childobjects)einem Бbergeordneten Objekt (parentobject) zuordnen.
Dies geschieht Бber den Befehl IADD. Also, die Buttons addiert man
(zuweisen) an das Toolbar-Objekt, und anschlieсend addiert man das
Toolbarobjekt an das Fenster.
Wichtig !
Ein Objekt kann nur an ein Бbergeordnetes Objekt addiert werden.
Bei der Benutzung von Objekt-IDs wird Klein- und Groсschrift
unterschieden. ( "bu" <> "Bu" )
Hauptfenster mit Toolbar und Meldungsfenster
Nun soll eine Verfeinerung der eben erstellten ProgrammoberflДche
realisiert werden. Einem der Buttons der Toolbar, nДmlich demjenigen
zum Beenden des Programms, soll Leben eingehaucht werden.
Wir wollen auf Klick mit der linken Maustaste auf diesen Button
erreichen, daс sich ein Meldefenster mit der Frage
"Programm beenden ?" Фffnet. Ein Klick auf den OK-Button soll
das Programm dann tatsДchlich abbrechen.
Es reicht dann natБrlich nicht mehr aus, dem Event-Manager lediglich
Бber DUMMY_EVENT die Kontrolle zu Бbergeben, da jetzt auf eine Aktion
des Anwenders reagiert werden muс. Der Aufbau der Event-Schleife
wurde bereits in der Einleitung besprochen. Sie wird so lange vom
Programm durchlaufen, bis die Laufvariable i den Wert 1000 erhДlt.
Der Code sieht dementsprechend so aus:
DEFFLOAT _i
CALL fenster()
WIN_PAINT "window"
WHILE _i<>1000
WIN_EV _i
WEND
END
REM Nun das Modul mit der Definition des Fensters
MODUL fenster()
def_window_st "window",1,1,50,10,"Testfenster"
def_toolbar "toolbar", 0, 0, 60, 5,;"region off"
def_button "b0", 0, 0, 10, " ", "Neu"
def_button "b1", 0, 0, 10, " ", "Speichern"
def_button "b2", 0, 0, 10, " ", "Loeschen"
def_button "b3", 0, 0, 10, " ", "Finde"
def_button "b4", 0, 0, 10, " ", "Beenden"
add_item "toolbar",..
"b0",..
"b1",..
"b2",..
"b3",..
"b4"
add_item "window", "toolbar"
ENDMOD
rem Eventfunktion wird aufgerufen wenn BUTTON gedrБckt
MODUL b4_select()
DEFFLOAT flag
MSGBOX "Programm beenden ?", 1, flag, " "
IF flag=1 THEN
_i=1000
ENDIF
ENDMOD
Die Variable _I ist global.( siehe Variablendefinitionen mit
angehenden Unterstrich "_").
Wichtig !
Eventfuktionen besitzen keine Ъbergabeparameter. Ъbergaben
mБssen Бber globale Variablen erfolgen.
Damit sind wir bereits Бber den Status einer einfachen
ProgrammoberflДche hinausgegangen. Das Programm ist in der Lage,
dem Wunsch des Anwenders auf Abbruch zu entsprechen und das Programm
zu beenden. Wir wollen weitere Programmaktionen nun aber noch eine
Weile zurБckstellen und uns zunДchst der Erstellung weiterer
OberflДchenobjekte zuwenden.
Hauptfenster mit Pulldown-MenБ
Als nДchstes Element einer ProgrammoberflДche wollen wir ein
funktionsfДhiges Pulldown-MenБ erzeugen. Um den Programmcode kurz
zu halten, wollen bei diesem Beispiel keine Toolbar einbauen.
Prinzipiell kФnnen aber beide Elemente gleichzeitig in einem
Hauptfenster definiert werden.
Ein Pulldown-MenБ wird automatisch immer so weit oben wie mФglich
im Hauptfenster erzeugt. Dies hat PrioritДt vor dem FLAG "Region off",
das wir bei der Toolbar gesetzt haben.
Ein Pulldown-MenБ wБrde deshalb immer oberhalb einer Toolbar im
Fenster erzeugt.
Wir wollen ein Pulldown-MenБ mit folgendem Aufbau erstellen:
Datei Bearbeiten Hilfe Info
Neu Loeschen Index
Speichern Suchen ... Grundbegriffe
Beenden ... Allgemeines
Tasten
Die HauptmenБpunkte werden als Pulldown-Items definiert, die Unter-
punkte als Pop-Up-Items. Wir wollen die Abbruchsaktion beim
Selektieren von "Beenden" beibehalten (analog zum vorhergehenden
Beispiel), nur soll dies jetzt beim AuswДhlen des
Pulldown-MenБpunktes geschehen.
Die einzelnen MenБpunkte sollen auch Бber Hot-Keys aktivierbar sein.
Deswegen setzen wir bei der Definition der MenБpunkte das
Zeichen " vor den Buchstaben, der in Verbindung mit der ALT-Taste
den Befehl aktivieren soll. Der Hot-Key-Buchstabe erscheint
dann unterstrichen.
DEFFLOAT _i
CALL fenster()
WIN_PAINT "window"
WHILE _i<>1000
WIN_EV _i
WEND
END
REM Nun das Modul mit der Definition des Fensters
MODUL fenster()
def_window_st "window",1,1,50,10,"Testfenster"
DEF_PULLDOWN_ITEM "p1", " 1
DEF_PULLDOWN_ITEM "p2", " 1
DEF_PULLDOWN_ITEM "p3", " 1
DEF_PULLDOWN_ITEM "p4", "Info", 0
DEF_PULLDOWN_ITEM "p31","Index",1
DEF_POPUP_ITEM "a1","
DEF_POPUP_ITEM "a2","
DEF_POPUP_ITEM "a3","B "
DEF_POPUP_ITEM "b1","
DEF_POPUP_ITEM "b2","Su "
DEF_POPUP_ITEM "c1","
DEF_POPUP_ITEM "c2","
DEF_POPUP_ITEM "c3","
ADD_ITEM "p1",..
"a1",..
"a2",..
"a3"
ADD_ITEM "p2",..
"b1",..
"b2"
ADD_ITEM "p31",..
"c1",..
"c2"
ADD_ITEM "p3",..
"p31",..
"c3"
DEF_PULLDOWN_MENU "menu", 0; "border"
ADD_ITEM "menu",..
"p1",..
"p2",..
"p3",..
"p4"
ADD_ITEM "window", "menu"
ENDMOD
rem Eventfunktion wird aufgerufen wenn MenБpunkt selektiert wird
MODUL a3_select()
DEFFLOAT flag
MSGBOX "Programm beenden ?", 1, flag, " "
IF flag=1 THEN
_i=1000
ENDIF
ENDMOD
Wichtig !
Die Definition eines Pulldown-MenБs ist simpel, wenn man einmal
die Vorgehensweise verstanden hat. Wir haben 4 HauptmenБpunkte.
Diese werden mit DEF_PULLDOWN_ITEM definiert. Besitzt ein
HauptmenБpunkt weitere Unterpunkte, erhДlt es als Flag den Wert 1.
Gibt es keine weiteren Unterpunkte dann erhДlt der MenБpunkt den
Wert 0 (siehe MenБpunkt : Info ).
UntermenБpunkte werden mit DEF_POPUP_ITEM definiert, solange Sie
keine weiteren UntermenБpunkte haben. Ist dies nicht der Fall, gilt
die Regelung der HauptmenБpunkte (siehe MenБpunkt : Index).
Hauptfenster mit Toolbar und Eingabemaske
Das letzte Beispielprogramm zu den OberflДchen soll zusДtzlich zu
einem BedienungsmenБ eine Eingabemaske besitzen, Бber welche ein
Datentransfer zu einer (noch nicht vorhandenen) Datenbank mФglich
wДre. Damit nДhern wir uns endgБltig vollstДndigen
ProgrammoberflДchen an.
Es sollen drei allgemeine Datenfelder fБr die Angabe von Namen,
Vornamen und Wohnort sowie ein Memofeld fБr die Angabe lДngerer
Texte wie Kommentare erstellt werden. Der Programmcode dafБr lДсt
sich natБrlich mit Hilfe des Maskengenerators generieren.
Wir wollen aber aus didaktischen GrБnden eine Programmierung
"zu Fuс" durchfБhren.
Es soll hier auch auf die Erstellung einer den Datenfeldern
zugrundeliegenden Recordstruktur nicht verzichtet werden, obwohl
diese nur in Verbindung mit einer Datenbank sinnvoll wДre.
Will man eine Eingabemaske per Hand erzeugen, kommt man nicht
um das sorgfДltige Positionieren der Objekte im Hauptfenster herum.
Es bedarf gerade am Anfang einiger AnlДufe, bis man ein GefБhl fБr
die Distanzen auf dem Monitor entwickelt hat.
Die in KIM gБltige Einheit sind Zeichen. Setzt man beispielsweise
die Feldbezeichnung "Name" auf die Position 1,0, so bedeutet dies,
daс das Objekt ein Zeichen vom linken Fensterrand sowie ein Zeichen
unterhalb des oberen Fensterrands beginnt.
Hierbei wird der obere Fensterrand durch Toolbars oder
Pulldown-MenБs entsprechend zum unteren Ende dieser Objekte hin
verlagert.
Bedenken Sie bei der Positionierung mehrerer Objekte in einer
Zeile (gleicher x-Wert) immer die LДnge der Objekte.
Lassen Sie das zweite Objekt zu frБh in der Zeile beginnen,
kommt es zu Ъberschneidungen.
Wir wollen alle Felder mit einer Begrenzung versehen
(FLAG "border" setzen) und im Kommentarfeld keinen Zeilenumbruch
erlauben (FLAG "wrap off" setzen).
Um obiges Programm zu realisieren, mБssen wir im Hauptprogramm
die Recordstruktur definieren und das Modul <fenster> um den Code
fБr die Eingabefelder und die Feldbezeichnungen erweitern.
ZusДtzlich soll das Kommentarfeld Scrollbars erhalten, die durch
Angabe von Nullen an den rechten und unteren Feldrand gesetzt
werden (vgl. Kapitel Fenster und ProgrammoberflДchen).
Beibehalten wollen wir unseren Programmabbruch Бber Aktivierung
des "Beenden"-Buttons. Deshalb muс die Event-Schleife und das
Modul auswerten im Programm erhalten sein.
Unser Code besitzt dann folgendes Gesicht:
DEFFLOAT _i
DEFINE soft1, 40 AS Name
DEFINE soft2, 40 AS Vorname
DEFINE soft3, 40 AS Wohnort
DIMMEMO soft4, 10000
CALL fenster()
WIN_PAINT "window"
WHILE _i<>1000
WIN_EV _i
WEND
END
REM Nun das Modul mit der Definition des Fensters
MODUL fenster()
def_window_st "window",1,1,65,15,"Testfenster"
def_toolbar "toolbar", 0, 0, 60, 5;"region off"
def_button "b0", 0, 0, 10, " ", "Neu"
def_button "b1", 0, 0, 10, " ", "Speichern"
def_button "b2", 0, 0, 10, " ", "Loeschen"
def_button "b3", 0, 0, 10, " ", "Finde"
def_button "b4", 0, 0, 10, " ", "Beenden"
add_item "toolbar",..
"b0",..
"b1",..
"b2",..
"b3",..
"b4"
add_item "window", "toolbar"
DEF_PROMPT "aus1", 1, 0, "Name"
DEF_PROMPT "aus2", 1, 1, "Vorname"
DEF_PROMPT "aus3", 1, 2, "Wohnort"
DEF_PROMPT "aus4", 1, 3, "Kommentar"
DEF_STRING "inp1", 10, 0, 40, soft1; "border"
DEF_STRING "inp2", 10, 1, 40, soft2; "border"
DEF_STRING "inp3", 10, 2, 40, soft3; "border"
DEF_TEXT "inp4", 1, 4, 49, 5, 10000, soft4; "border", "wrap off"
DEF_SCROLLBAR "scroll1", 0, 0, 0, 0, 0
DEF_SCROLLBAR "scroll2", 1, 0, 0, 0, 0
ADD_ITEM "inp4",..
"scroll1",..
"scroll2"
ADD_ITEM_ARRAY "window", "aus",1,4
ADD_ITEM_ARRAY "window", "inp",1,4
ENDMOD
rem Eventfunktion wird aufgerufen wenn BUTTON gedrБckt
MODUL b4_select()
DEFFLOAT flag
MSGBOX "Programm beenden ?", 1, flag, " "
IF flag=1 THEN
_i=1000
ENDIF
ENDMOD
Wichtig !
Objekte mit einer fortlaufenden Kennung kФnnen mit ADD_ITEM_ARRAY
an das Parentobjekt addiert werden.
Eine DEFINE-Variable ist eine globale Variable.
Eine einfache Terminverwaltung
Nachdem wir durch die Programmierung von OberflДchen bereits einen
Einblick in die Technik der Erstellung eines Programms mit KIM
gewonnen haben, wollen wir uns nun der hohen Schule der
Datenbankprogrammierung zuwenden.
Im Gegensatz zu den bisherigen Programmen mБssen wir ein Modul
hinzufБgen, in welchem eine Datenbank definiert und erstellt wird.
Des weiteren mБssen entsprechende Datenbankbefehle im
Hauptprogramm aufgenommen werden.
Wir wollen aber gleich einen Schritt weitergehen. Da man eine
Datenbank auf dem Monitor nicht sehen kann, wДre es eine reine
Spielerei, lediglich eine Datenbank zu definieren, ohne mit
dieser zu arbeiten. Wir werden also unseren Funktionsbuttons
und MenБpunkten Leben einhauchen und entsprechende
Programmfunktionen erstellen. Nach diesem Abschnitt sollten
Sie in der Lage sein, mit jedem programmtechnischen Problem
unter KIM fertig zu werden.
Unser erstes vollstДndiges Programm soll ein elektronischer
Terminkalender sein. Es soll die Eingabe von Datum und Uhrzeit
eines Termins ebenso wie des Namen desjenigen, auf den sich der
Termin bezieht mФglich sein. ZusДtzlich soll ein lДngeres Textfeld
erstellt werden, daс die Angabe zusДtzlicher Informationen zu dem
betreffenden Termin erlaubt.
NatБrlich mБssen dem Benutzer gewisse Bedienungsfunktionen zu dem
Programm angeboten werden. Deshalb soll eine Toolbar definiert
werden, die Бber Buttons die Neueingabe von Terminen sowie deren
Speicherung und LФschung ermФglicht. Auсerdem soll ein Vor- und
ZurБckblДttern in der Datendatei analog zum UmblДttern von
Buchseiten zur VerfБgung gestellt werden. Ein wichtiger Bestandteil
ist natБrlich eine Suchfunktion zum Finden bestimmter Termine.
Schlieсlich darf eine Funktion zur Programmbeendigung natБrlich
nicht fehlen.
a) Die ProgrammoberflДche der Terminverwaltung
FБr die OberflДche kФnnen wir praktisch unverДndert das Module <fenster>
des letzten Beispiels zu ProgrammoberflДchen Бbernehmen.
Die graduellen Unterschiede sollten kein Problem darstellen.
b) Datenbank
Neu ist fБr uns die Erstellung der Datenbank. Wir werden ein neues
Modul <db_oeffnen> schreiben, in welchem die Datensatz- und
Indexstruktur der Datenbank sowie die Recordstruktur festgelegt sind. Die Recordstruktur besteht aus Define-
Variablen fБr die Zeit-, Datums- und Datenfelder sowie einer
Memo-Variablen fБr das Kommentarfeld. Erinnern Sie sich daran,
daс die Verwendung von Define-Variablen nicht zwingend notwendig ist,
und ich an dieser Stelle ein normales Stringarray benutzen werde.
Die eigentlichen DatensatzfeldlДngen werden bekanntlich innerhalb
der Datenbank festgelegt. Falls Ihnen die Feldstruktur unklar ist,
sehen Sie bitte im Kapitel Бber Datenbankprogrammierung nach.
Die Neudefinition der Datenbank- und Indexstruktur soll nur
vorgenommen werden, wenn keine Datenbank vorhanden ist
(sonst wБrden alte Daten gelФscht). Wir werden daher eine
Abfrage Бber EXIST einbauen, die ermittelt, ob die Datei
"termin.dbf" bereits vorhanden ist (diese Datei wird ja
bei Erstellung der Datenbank angelegt).
Ist dies der Fall, wird die bestehende Datenbank und die
Indexdatei sofort mit IOPEN bzw. IOPEN_INDEX geФffnet.
Ansonsten erfolgt die Definition der Feldstrukturen
und die vorsichtshalber eingebaute LФschung eventuell
vorhandener .dbf- und .cdx-Dateien, bevor mit ICREATE
eine Datenbank neu erstellt wird.
c) Suchfunktion
Essentiell bei einer Terminverwaltung ist natБrlich eine Suchfunktion.
Die Realisierung derselben erstreckt sich Бber mehrere Programmebenen.
Zuerst muс in der Indexstruktur festgelegt werden, nach welchen
Daten Бberhaupt gesucht werden darf.
Wir wollen hier mФglichst einfach vorgehen und alle Datenfelder
mit Ausnahme des Kommentar- und des Zeitfeldes als Indexfelder
auszeichnen. In spДteren Programmen werden Verfeinerungen
(z.B. Бber Filter) vornehmen. Damit ist die Grundlage gelegt.
d) Suchfenster
Die Definition fБr dieses Fenster befindet sich im Modul
<erstelle_suchfenster>. Beachten Sie, daс nur die Zusatzobjekte
neu definiert werden. Das eigentliche Fenster wird analog zum
Hauptfenster erzeugt.
Der eigentliche Suchvorgang wird im Modul <fenster_suchen>
durchgefБhrt. Wie Sie erkennen kФnnen, ist dort eine zweite
Event-Schleife programmiert, welche die Aktionen des Anwenders
im Suchfenster auswertet.
e) Weitere Operationen
Als letzte Funktion soll neben dem bereits bekannten Abbruch des
Programms eine Datenspeicherung ermФglicht werden.
Hierzu wird der Inhalt aller Datenfelder in die Recordstruktur
eingelesen (dies ist aus ЪbersichtlichkeitsgrБnden in einem Modul
Daten_schreiben mit GET_ITEM realisiert) und anschlieсend mit
IMODREC der aktuelle Datensatz umgeschrieben und gleichzeitig
gespeichert.
Das LФschen eines Datensatzes ist gar nicht so einfach,
da IDEL nur einen Datensatz als gelФscht markiert, aber nicht
wirklich entfernt. Dies wБrde erst der Befehl IPACK bewirken,
dessen AusfБhrung aber beim Vorhandensein vieler Daten einige
Zeit erfordert. Wir wollen deshalb einen anderen Weg wДhlen und
in der Indexstruktur einen Filter einbauen, welcher die Anzeige
aller als gelФscht markierter DatensДtze unterdrБckt.
Diese sind wohlgemerkt noch vorhanden, aber nicht mehr
einsehbar. Der entsprechende dBASE-Ausdruck lautet DEL()<>"*".
Der Befehl DEL gibt ein * fБr alle als gelФscht markierten DatensДtze
zurБck. Die folgende Anweisung filtert dann genau diese DatensДtze
heraus. Beachten Sie bitte, daс Zeilen, in welchen
AnfБhrungszeichen zur Ъbergabe von dBASE-AusdrБcken verwendet werden
(dies ist Vorschrift), zwischen Hochkommas ' gesetzt werden mБssen,
da es verboten ist, zweimal AnfБhrungszeichen zu verwenden.
Vergessen Sie nicht, zum Schluс des Programms die Datenbank mit
ICLOSE zu schlieсen.
Hier nun der vollstДndige Programmcode:
rem Datum : MДrz 1995
rem Version : 1.0
rem Programm : Terminverwaltung mit DBASE-Datenbank
rem Datei : TERMIN.KIM
rem Programmierer : EDV-Kohlenbach
rem ZunДchst die Definition einiger Variablen und das Laden der Icondatei
deffloat a,_i
rem Definition der Felder 1-4 fБr die Datenbank
dim _felder,1,3
DIMMEMO _felder4, 10000
rem Hilfetaste definieren
SET_KEYMAP "F12",10001,1
call db_oeffnen()
call fenster()
win_paint "window"
while _i<>1000
win_ev _i
wend
iclose 1
end
rem ---------------------------------------------------------------------
rem U N T E R P R O G R A M M E
rem ---------------------------------------------------------------------
rem Modul zur Definition und Erstellung einer Datenbank mit Recordstruktur
modul db_oeffnen()
DEFFLOAT a
DEFSTRING expr
rem Nun eine Abfrage, ob die Datenbank schon existiert; falls nicht: Neuerstellung
exist "termin.dbf",a
IF a<>1 THEN
dim feld,1,10
dim index,1,10
feld1=" TIME , C , 10 , 0"
feld2=" DATUM , D , 10 , 0"
feld3=" NAME , C , 40 , 0"
feld4=" MEMO , M , 10 , 0"
feld5=""
rem In Variable <feld5> kein Leerzeichen !!!
index1=' NAME_TAG , NAME , DEL()<>"*", 0, 0'
index2=' DATUM_TAG , DATUM , DEL()<>"*", 0, 0'
index3=""
rem Eventuell bereits existierende Dateien werden gelФscht
kill "termin.dbf"
kill "termin.cdx"
kill "termin.fpt"
kill "termin.dpt"
rem Die Datenbank wird neu erstellt
icreate "termin",feld,index
rem Mindestens ein Leersatz, sonst funktionieren die
rem Datenbankbefehle nicht !
iopen 1,"termin"
iopen_index 1,"termin"
iadd 1,_felder
iclose 1
ENDIF
rem Die Datenbank und die Indexdatei werden geФffnet
IOPEN 1,"termin"
IOPEN_INDEX 1,"termin"
rem Felder kФnnen Бber Namen aus der DBASE-DB angesprochen werden
rem z.B. _FELDER.NAME oder _FELDER.DATUM
dbfields 1,_felder
rem Der aktuelle Index wird ausgewДhlt und der erste Datensatz geladen
iset 1,"DATUM_TAG",expr
istart 1,_felder
ENDMOD
rem Definition des Hauptfensters
MODUL fenster()
def_window_st "window",1,1,62,15,"Testfenster"
def_toolbar "toolbar", 0, 0, 60, 5;"region off"
def_button "b0", 0, 0, 10, " ", "
def_button "b1", 0, 0, 10, " ", "
def_button "b2", 0, 0, 10, " ", ">>>"
def_button "b3", 0, 0, 10, " ", "<<<"
def_button "b4", 0, 0, 10, " ", "
def_button "b5", 0, 0, 10, " ", "
def_button "b6", 0, 0, 10, " ", "S
add_item "toolbar",..
"b0",..
"b1",..
"b2",..
"b3",..
"b4",..
"b5",..
"b6"
rem Alternative : ADD_ITEM_ARRAY
rem ADD_ITEM_ARRAY "toolbar","b",0,6
add_item "window", "toolbar"
DEF_PROMPT "aus1", 1, 0, "Zeit "
DEF_PROMPT "aus2", 1, 1, "Datum "
DEF_PROMPT "aus3", 1, 2, "Name "
DEF_PROMPT "aus4", 1, 3, "Kommentar "
DEF_INPUT_TIME "inp1", 10, 0, 10, "",""; "border"
DEF_INPUT_DATE "inp2",10,1,14," . . ","" ;"border"
DEF_STRING "inp3", 10, 2, 40, ""; "border"
DEF_TEXT "inp4", 1, 4, 49, 5, 10000, ""; "border", "wrap off"
DEF_SCROLLBAR "scroll1", 0, 0, 0, 0, 0
DEF_SCROLLBAR "scroll2", 1, 0, 0, 0, 0
ADD_ITEM "inp4",..
"scroll1",..
"scroll2"
ADD_ITEM_ARRAY "window", "aus",1,4
ADD_ITEM_ARRAY "window", "inp",1,4
rem Statuszeile am unteren Fensterrand
DEF_STATUSBAR "status",1
DEF_PROMPT "statustext",1,0,"F12=Hilfe ";"color on"
DEF_PALETTE 1,0,7
COLOR_ITEM "statustext",1
ADD_ITEM "status","statustext"
ADD_ITEM "window","status"
ENDMOD
rem Daten aus den Eingabefeldern werden gespeichert
modul b0_select()
call daten_schreiben()
imodrec 1,_felder
endmod
rem Aktueller Datensatz wird gelФscht
modul b1_select()
idel 1
igetrec 1,_felder
call daten_ausgeben()
endmod
rem Der nДchste Datensatz wird herausgesucht und angezeigt
modul b2_select()
deffloat a
inext 1,a,_felder
call daten_ausgeben()
endmod
rem Der vorhergehende Datensatz wird herausgesucht und angezeigt
modul b3_select()
deffloat a
iprev 1,a,_felder
call daten_ausgeben()
endmod
rem Programm beenden
MODUL b4_select()
DEFFLOAT flag
MSGBOX "Programm beenden ?", 1, flag, " "
IF flag=1 THEN
_i=1000
ENDIF
ENDMOD
rem Die Eingabefelder werden fБr eine Neueingabe geleert
modul b5_select()
clear _felder,1,4
iadd 1,_felder
call daten_ausgeben()
setfocus "inp1"
endmod
rem Die Suchfunktion wird aufgerufen
modul b6_select()
call fenster_suchen()
igetrec 1,_felder
call daten_ausgeben()
endmod
rem Ausgabe von Daten auf dem Bildschirm
modul daten_ausgeben()
set_item_array "inp",_felder,1,4
endmod
rem Einlesen von Daten aus den Eingabefeldern in die Recordstruktur
modul daten_schreiben()
get_item_array "inp",_felder,1,4
endmod
rem Suchfunktion
MODUL fenster_suchen()
defstring obj
deffloat ii,taste
call erstelle_suchfenster()
win_paint "suche"
while ii<>1000
win_ev ii
get_item_pos obj,taste
if taste=13 then
if obj="bx1" then
call such_auswerten()
ii=1000
endif
if obj="bx2" then
ii=1000
endif
endif
wend
event_on_item "suche","end"
endmod
rem Suchen von DatensДtzen
MODUL such_auswerten()
DEFSTRING expr
deffloat ok
DIM dat,1,3
get_item "kr2",_felder.name
compress _felder.name
if _felder.name<>"" then
iset 1, "Name_Tag", expr
iread 1, ok, _felder.name, soft
exitmod
endif
get_item "kr1", _felder.datum
if _felder.datum<>"" then
iset 1, "Datum_Tag",expr
select _felder.datum,46,dat,1,3
_felder.datum=dat3+dat2+dat1
iread 1, ok, _felder.datum, _felder
endif
endmod
rem Definition des Suchfensters
MODUL erstelle_suchfenster()
def_window_st "suche", 3, 2, 50, 12, "Suchen";"modal","move off"
rem ZusДtzliche Objekte werden definiert und dem Fenster angefБgt
def_prompt "such1",10,0,"Geben Sie einen Suchbegriff"
def_prompt "such2",10,1,"im entsprechenden Feld an"
def_prompt "such3",1,3,"Name "
def_prompt "such4",1,4,"Datum "
def_input_date "kr1",10,4,14," . . ","" ;"border"
def_string "kr2",10,3,20,"";"border"
def_button "bx1",3,8,20,""," beginnen"
def_button "bx2",25,8,20,"","
add_item "suche",..
"such1",..
"such2",..
"such3",..
"such4",..
"kr1",..
"kr2",..
"bx1",..
"bx2"
endmod
rem PrБfen ob Datumkorrekt eingegeben
modul inp2_validate()
deffloat flag
msgbox "Datum muс in der Form TT.MM.YYYY eingegeben werden",0,flag,""
setfocus "inp2"
endmod
modul inp2_lostfocus()
defstring date
deffloat flag
get_item "inp2",date
if date=""
msgbox "Datum muс in der Form TT.MM.YYYY eingegeben werden",0,flag,""
setfocus "inp2"
endif
endmod
rem Auf Taste F1 reagieren
modul system_keypress()
if system.keypress=10001 then
call hilfe(system.object)
endif
endmod
rem Hilfefenster
modul hilfe(char o)
deffloat flag
if o="inp1" then
msgbox "Hilfe fБr Feld INP1",0,flag,""
else
msgbox "Hier kФnnte eine allgemeine Hilfe stehen !",0,flag,""
endif
endmod
rem ************** Ende des Programms *******************
Zum Schluс
Ъber das Programmieren wurden schon tonnenweise BБcher geschrieben.
Ich glaube eine Tonne liegt in meinen Keller!
Die vorgestellten Programme werden nicht alle ihre Fragen beantworten
kФnnen. FБr das Umsetzen einer Idee zu einen Programm braucht es
Erfahrung. Wenn man die Befehle einer Sprache beherrscht, heiсt dies
noch nicht das man Programmieren kann !
Als Einsteiger empfehle ich kleine Programme zu entwickeln,
wie z.B. einen einfachen Taschenrechner oder eine WДhrungsumrechnung.
Steigern Sie den Schwierigkeitsgrad ihrer Programme.
Versuchen Sie Routinen allgemein zu halten, damit diese in anderen
Programmen genutzt werden kФnnen.
Ich werde in Zukunft diese elektronische Hilfe erweitern, und
weitere Erfahrungswerte einbringen.
Kohle
ΓòÉΓòÉΓòÉ 12. Objekteigenschaften ΓòÉΓòÉΓòÉ
FLAGS
Objekteigenschaften
Ob ein Eingabefeld eine Umrandung besitzt oder nur Groсbuchstaben eingeben
werden dБrfen, bestimmen Sie Бber die Objekteigenschaften (OE).
OEs sind wie Schalter, die eine Eigenschaft aktivieren oder deaktivieren.
In den meisten FДllen werden die OEs schon bei der Definition eines Objekts
Бbergeben : DEF_STRING "id",x,y,len,text ; "oe1","oe2",...
Nach einem Strichpunkt erfolgt mit Komma getrennt, die Ъbergabe der OEs.
OEs werden im in Kleinbuchstaben angegeben.
VerfБgbare OEs :
Allgemein :
"color on" Farbwerte eines Objekt kФnnen verДndert werden
"border" Ein Rand wird um das Objekt gezeichnet
"current off" Kann nicht das akt. Objekt werden
"select off" Schaltet die MФglichkeit einer Selektion des Objekts aus
"region off" Das Objekt erhДlt die komplette FensterflДche
"view only" Schaltet den Editiermodus aus
"bitmap" Hiermit teilen Sie mit, daс das Objekt ein Bitmap beinhaltet
"editmode" Objekt lДsst sich am Bildschrim bewegen und Дndern.
"redisplay" Objekt wieder zeichnen
"minicell" Koordinaten auf 1/10 Schritte setzen
"pixel" Koordinaten Pixelorientiert
"no_status" Kein Status
"current" Objekt erhДlt den Status "aktuelles" Objekt
"changed" Objekt erhДlt den Status "geДndertes" Objekt
"invalid" Objekt erhДlt den Status "falsche Eingabe"
"select" Objekt erhДlt den Status "selektiertes" Objekt
"destroy off" LФschen und entfernen des Objekts nicht mФglich
"normal hotkey" Der Hotkey kann ohne die ALT-Taste angesprochen werden
"repeat" Objekt reagiert auf gedrБckten Tastendruck
Eingabefelder :
"right" Texteingabe wird rechtsbБndig gesetzt
"clear" Feldinhalt wir bei Eingabe gelФscht
"center" Texteingabe erfolgt zentriert
"lcase" Umwandlung in Kleinbuchstaben
"ucase" Umwandlung in Groсbuchstaben
"wrap off" Zeilenumbruch wird ausgeschaltet
"pass" Passworteingabe bei DEF_STRING
Liste, Combobox :
"sort" Elemente einer Liste werden sortiert
"multi" Mehrfachauswahl aus einer Liste
"auto select" Selektiert in einer Gruppe von Radiobuttons den ersten
Button, wenn die Gruppe selektiert wird
Fenster :
"lock" Fenster kann nicht geschlossen werden
"mdi" Fenster wird als MDI-Objekt behandelt
"dialog" Fenster wird als Dialogbox behandelt
"modal" Verhindert, daс andere Fenster Events erhalten, bis das
Fenster geschlossen wird
"move off" Verhindert die Оnderung der Position
"size off" Verhindert die Оnderung der GrФсe
"current off" Das Objekt kann nicht selektiert werden
"temp" Das Fenster wird geschlossen, wenn ein anderes Fenster
selektiert wird
"maximized" Darstellung des Fensters mit max. GrФсe
"minimized" Symboldarstellung (DEF_WINDOW mit Iconangabe)
MenБs :
"checkmark" Objekt erhДlt bei Auswahl einen Hacken
"sep" Objekt dient als Trennstrich
Buttons :
"double_click" Button kann Бber einen Doppelklick aktiviert werden
"down_click" Button wird beim HerunterdrБcken aktiviert
"toggle off" Klickbewegung wird ausgeschaltet
"auto size" HФhe und Breite werden automatisch berechnet
"checkbox" Button wird als Checkbox dargestellt
"3d_off" Darstellung ohne Schatten
"radio" Darstellung als Radiobutton
"set" Ein Radiobutton oder eine Checkbox als gesetzt setzen
Icons :
"icon minimize" Definiert dieses Objekt als Symbol
"icon double_click" Icon kann durch Doppelklick selektiert werden
Zeiteingabe :
"time : " Trennzeichen ist der Doppelpunkt
"time 100" Eingabe als Millisekunden
"time hours off" Eingabe ohne Stunden
"time seconds on" Sekunden kФnnen eingegeben werden
"time minutes off" Minuteneingabe deaktivieren
"time sep off" Kein Trennzeichen
"time lcase" Eingabe in Kleinbuchstaben
"time ucase" Eingabe in Groсbuchstaben
"time system" Vorbelegung mit Systemzeit
"time 12" 12 Stunden Uhrzeit
"time 24" 24 Stunden Uhrzeit
"time fill" Zahlen kleiner als 10 werden auf zwei Stellen mit
einer fБhrenden Null aufgefБllt.
Numerische Eingabe ( DEF_NUMBER)
"scientific" Wissenschaftliche Schreibweise aktiviert (z.B. 2E-2)
"decimal 0" Keine Nachkommastelle
"decimal 1" Eine Nachkommastelle
"decimal 2" ...
"decimal 3" ...
"decimal 4" ...
"decimal 5" ...
"decimal 6" Sechs Nachkommastellen
"currency" WДhrung
"commas" Komma statt Punkt (Automatisch)
"percent" Prozenteingabe (%)
Drag und Drop fБr Objekte in einer Liste oder Eingabefeld
"drag move" Objekt kann verschoben werden
"drag copy" Objekt kann kopiert werden
"drop accept Objekt erlaubt Drag Drop
NachtrДgliches Оndern von Eigenschaften :
FБr diesen Zweck steht folgende Funktion zur VerfБgung :
SET_ITEM_STATUS "id",flag,"oe1",...
Ermitteln von Eigenschaften eines Objekts :
GET_ITEM_STATUS "id","status",ok
ΓòÉΓòÉΓòÉ 13. Datenbankfilter / Fehlercodes ΓòÉΓòÉΓòÉ
DBASE-AusdrБcke
Allgemeine Hinweise
dBASE-AusdrБcke werden oft zur Definition von SchlБsseln und Filtern
einer Indexdatei gebraucht.
Sie kФnnen aber aber auch fБr andere Zwecke, z.B. interaktiven
Abfragen bei Relationen, benutzt werden.
Alle dBASE-AusdrБcke geben den Wert eines bestimmten Typs zurБck.
Dieser Typ kann "Numerisch", "Zeichen", "Datum" oder "Logisch" sein.
Feldnamen, Konstanten und Funktionen kФnnen als Teile von
dBASE-AusdrБcken benutzt werden. Diese Teile lassen sich
mit anderen Funktionen oder mit Operatoren kombinieren.
Feldnamen
Es ist mФglich, einen Feldnamen in einem dBASE-Ausdruck durch die
Angabe der Datendatei zu kennzeichnen. Beispiel fБr einen
dBASE-Ausdruck "DATENDATEI->FELD_NAME.
Der erste Teil, der Kennzeichner, bezeichnet eine Datendatei,
dem nach dem "->" der Feldname folgt.
dBASE-Ausdruckskonstanten
dBASE-AusdrБcke kФnnen aus einer numerischen, logischen oder
Zeichenkonstante bestehen. Konstanten werden gewФhnlich in
komplizierten dBASE-AusdrБcken benutzt.
Eine numerische Konstante ist eine Zahl. Zum Beispiel sind "5",
"7.3" und "18" dBASE-AusdrБcke mit numerischen Konstanten.
Zeichenkonstanten sind in AnfБhrungszeichen eingeschlossene
Buchstaben. Die Konstanten ".TRUE." und ".FALSE." sind die einzigen
gБltigen logischen Konstanten. Die Konstanten ".T." und ".F."
sind die gБltige AbkБrzung dafБr.
Operatoren der dBASE-AusdrБcke
Mit Operatoren wie "+","*" oder "<" werden Konstanten und Felder
bearbeitet. "3+2" ist ein Beispiel fБr einen dBASE-Ausdruck, bei
dem der Additionsoperator auf zwei numerischen Konstanten wirkt,
um den numerischen Wert "11" zurБckzugeben.
Als Regel gilt Punkt vor Strich.
Zeichenoperatoren
Es gibt zwei Zeichenoperatoren, die zwei Zeichenwerte verbinden.
"Hans "+"Schmidt" wird zu "Hans Schmidt"
"AAA "-"CCCC " wird zu "AAACCCC "
Bei der zweiten Variante werden alle endstДndigen Leerzeichen
der ersten Zeichenkette an das Ende des Gesamtausdrucks angefБgt.
Vergleichsoperatoren
VOs geben ein logisches Ergebnis (entweder wahr oder falsch)
zurБck. Alle Operatoren mit der Ausnahme von "Beinhalten"
arbeiten mit numerischen, Zeichen- oder Datumswerten.
"Beinhalten" arbeitet mit Zeichenketten.
Gleich =
Ungleich <> oder #
Kleiner als <
GrФсer als >
Kleiner oder gleich <=
GrФсer oder gleich >=
Beinhalten $
Beispiel : "AB"$"ABCD" wahr
8<7 falsch
Logische Operatoren
Nicht .NOT.
Und .AND.
Oder .OR.
Beispiel :
Name="Meier" .AND. Ort="MБnchen"
DEL()="*" .AND. UPPER(Ort)="NЪRNBERG"
dBASE-Ausdruckskonstanten
Befehle fБr die Indexdefinition
CTOD()
Die Funktion Character TO Date wandelt einen Zeichenwert in einen
Datumswert um, wobei die Ausgabe im Format MM/DD/YY erfolgt
(M=Monat, D=Tag, Y=Jahr) Bsp: CTOD("110288") wird zu 11/02/88.
DATE()
Diese Funktion gibt das aktuelle Datum aus dem ROM-BIOS zurБck.
DAY()
Hier wird der Tag des in den Klammern anzugebenden Datums ausgewДhlt
und zurБckgegeben. Soll das vorgegebene Datum das aktuelle
Systemdatum sein, geben Sie an: DAY(DATE).
DEL()
ЪberprБft, ob der aktuelle Datensatz als gelФscht markiert ist.
Soll dies der Fall sein, wird "*" zurБckgegeben, ansonsten " ".
DELETED()
ЪberprБft, ob der aktuelle Datensatz als gelФscht markiert ist.
Ist dies der Fall, wird .TRUE. zurБckgegeben.
DESCEND()
Diese Funktion ist nur bei Systemen mit Clipper-UnterstБtzung
verfБgbar. Es wir die Komplementversion des in Klammern vorgegebenen
Ausdrucks zurБckgegeben.
DTOC()
Das in der Klammer vorgegebene Datum wird in eine Zeichenkonstante
konvertiert. Das resultierende Format ist MM/DD/YY (s.o.).
DTOS()
Das in der Klammer vorgegebene Datum wird in eine Zeichenkonstante
БberfБhrt. Das resultierende Format ist CCYYMMDD (C=Jahrhundert).
IIF(Log_Wert, Wahr_Result, Falsch_Result)
Bei dieser Funktion mБssen Sie fБr Log_Wert einen Ausdruck angeben,
der dann von IIF БberprБft wird. Erweist sich der Ausdruck als wahr,
wird der in Wahr_Result vorgegebene Wert zurБckgegeben,
ansonsten wird der in Falsch_Result vorgegebene Wert Бbergeben.
TRIMM()
Mit dieser Funktion werden aus dem Ausdruck in der Klammer eventuelle
Leerzeichen links vom Inhalt entfernt.
MONTH()
Der Monat des in der Klammer angegebene Datum wird als numerische
Konstante zurБckgegeben.
RECCOUNT()
Die Funktion"Record Count" liefert die Zahl aller verfБgbaren
DatensДtze in der Datenbank.
RECNO()
Die Funktion "Record Number" ermittelt die Nummer des aktuellen
Datensatzes (analog zu IGET_NR).
STOD()
Diese Funktion wandelt den in der Klammer angegebenen Zeichenwert
in einen Datumswert um. Das resultierende Format ist CCYYMMDD.
STR (Zahl, LДnge, Nachkomma)
Die in Zahl vorgegebene Zahl wird in eine Zeichenkonstante umgewandelt.
Diese besitzt die in LДnge angegebene Zeichenzahl und die in
Nachkomma angegebene Zahl an Nachkommastellen.
Bsp.: STR(5.7, 4, 2) wird zu "5.70" (der Punkt zДhlt mit).
SUBSTR(Zeichen, Start, Anzahl)
Ein Teil der in Zeichen vorgegebene Zeichenkonstante wird
zurБckgegeben. Der selektierte Teilbereich beginnt ab dem in Start
ausgewДhlten Zeichen und enthДlt die in Anzahl angegebene Zeichenzahl.
Bsp: SUBSTR("ABCDE",2,3) ergibt "BCD".
TIME()
Es wird die Systemzeit aus dem ROM-BIOS als Zeichen zurБckgegeben.
Das resultierende Format ist HH
TRIM()
Dem in der Klammer angegebenem Ausdruck werden alle endstДndigen
Leerzeichen entfernt.
UPPER()
Alle Zeichen des in der Klammer angegebenen Ausdrucks werden in
Groсbuchstaben umgewandelt.
VAL()
Eine Zeichenkonstante wird in eine numerische konvertiert.
YEAR()
Das Jahr des in der Klammer vorgegebenen Datums wird als numerische
Konstante zurБckgegeben.
Fehlercodes
Bei den aufgefБhrten Datenbankbefehlen kann (muс nicht) ein weiterer numerischer
Parameter (Variable) mit angegeben werden.
Beispiel : IOPEN 1,"test" [,fehlercode]
Tritt ein Fehler auf, so kann der Fehlercode ermittelt werden.
KIM Фffnet dann keine Fehlerbox.
Gehen Sie vorsichtig hiermit um !
Befehle :
ISTART, IENDE, IOPEN, INEXT, IPREV, IMAKEINDEX, IOPEN_INDEX,
ICLOSE_INDEX, IREINDEX, ICREATE, ILOCK, IULOCK, ISET, IREAD,
ICLOSE, IGO_NR
---------------------------------------------------------------------------
F E H L E R C O D E S
Code Fehler
---------------------------------------------------------------------------
Allgemein...
-10 Fehler beim Schlieсen einer Datei
-20 Fehler beim Erstellen einer Datei (Dateiname,Platte voll,..)
-30 Fehler beim bestimmen der DateilДnge
-40 Fehler beim Einstellen der DateilДnge
-50 Fehler beim Sperren einer Datei
-60 Fehler beim Щffnen einer Datei (nicht vorh.,..)
-70 Fehler beim lesen in einer Datei
-80 Fehler beim LФschen
-90 Fehler beim Umbenennen
-100 Fehler beim Positionieren des Dateizeigers
-110 Fehler beim Entsprerren einer Datei
-120 Platte voll beim schreiben in eine Datei
-200 Datei ist keine Datendatei
-210 Unbekannter Feldname
-220 Unbekannter Feldtyp
-230 DatensatzlДnge zu groс
Index...
-300 Subindex fehlt (Datensatz hat keinen Eintrag im Index)
-310 Keine richtige Indexdatei
-330 Subindex nicht gefunden (Name nicht gefunden)
-340 Kein eindeutiger SchlБssel
AusdrБcke...
-400 Komma oder Klammer erwartet
-410 Ausdruck nicht vollstДndig
-420 Name der Datendatei nicht ermittelt
-422 IIF() erfordert Parameter von gleicher LДnge
-425 SUBSTR() und STR() erfordert Konstanten als Parameter
-430 Anzahl der Parameter sind falsch
-440 Ъberlauf bei der Auswertung eines Ausdrucks
-450 Rechte Klammer fehlt
-460 Typ der Unterausdrucks ist falsch
-470 Unbekannte Funktion
-480 Unbekannter Operator
-490 Unbekannter Wert
-500 Unbeendeter String
Optimierungsfehler ...
-610 Allgemeiner Optimierungsfehler
-620 Fehler bei der Aufhebung der Opt.
-630 Fehler beim Herausschreiben der Datei
Relationen...
-710 Allgemeiner Relationsfehler
-720 Ъbereinstimmender Slave-Datensatz nicht gefunden
Schwere Fehler...
-910 Interner Fehler
-920 Nicht genug Speicher
-930 Unerwarteter Parameter
-950 Unerwartetes Ergebnis
R Ъ C K M E L D U N G E N
-------------------------
0 Aufruf erfolgreich
1 SuchschlБssel gefunden
2 Suchaufruf nicht erfolgreich, Positionierung erfolgt
hinter den abgefragten SuchschlБssel.
3 Dateiende
4 Dateianfang
5 Datensatz oder SubindexschlБssel fehlt
10 Index in absteigender Reihenfolge sortiert
20 Subindex nur eindeutigen SchlБssel und es wurde
versucht einen gleichen Key anzufБgen.
40 Datensatz wird ignoriert
45 Datensatz wird beibehalten
50 Teil der Datendatei gesperrt
60 Datei konnte nicht angelegt werden
70 Datei konnte nicht geФffnet werden
80 Subindexname nicht gefunden
90 Slave-Datensatz wurde nicht gefunden
----------------------------------------------------------------------------
ΓòÉΓòÉΓòÉ 14. Relationen ΓòÉΓòÉΓòÉ
Relationen
EinfБhrung
Bisher haben wir unsere Betrachtungen auf lediglich eine
Datenbank beschrДnkt. Es ist aber durchaus mФglich, KIM-
Programme mit mehreren Datenbanken auszustatten. Dies ist
beispielsweise dann vorteilhaft, wenn Sie eine frБher erstellte
Datenbank mitsamt ihren Daten zusДtzlich zur neuen Datenbank in
das Programm einfБgen wollen. Dabei kann die zusДtzliche
Datenbank auch mit anderen Programmen wie dBASE generiert
worden sein.
Einfach ist natБrlich der Fall, daс Sie jeweils nur eine
Datenbank zur gleichen Zeit benutzen wollen. Dann schlieсen Sie
jeweils eine Datenbank, wenn die andere geФffnet wird, und
arbeiten ganz normal wie zuvor erlДutert mit einer Datenbank.
Viel interessanter ist aber natБrlich die MФglichkeit, mit zwei
Datenbanken zur selben Zeit zu arbeiten. Die DatensДtze beider
Datenbanken kФnnen dann miteinander verknБpft und so gemeinsam
verwertet werden. Eine VerknБpfung von Datenbanken bezeichnet
man allgemein als Relation.
Wollen wir uns an einem Beispiel verdeutlichen, wie eine
Relation zwischen Datenbanken aufgebaut ist. Nehmen wir an, es
existiert eine Datenbank 1 mit DatensДtzen, in denen der Name
und der Vorname eines Kunden gespeichert ist. In einer zweiten
Datenbank sollen hingegen der Name und der Wohnort verzeichnet
sein:
Datenbank 1 Datenbank2
Name Vorname Name Wohnort
---------------------------------------------------------------
MБller Karl-Heinz MБller NБrnberg
Schulz Roland Schulz MБnchen
Weiс Norbert Weiс Frankfurt
Wir mФchten nun die beiden Datenbanken verknБpfen, um zu
erreichen, daс uns die DatensДtze beider Datenbanken
gleichzeitig zur VerfБgung stehen. Wenn wir also beispielsweise
nach allen Informationen zum Kunden MБller suchen, soll uns
nicht nur der Vorname, sondern gleichzeitig auch der Wohnort
angegeben werden.
Dies kann man erreichen, indem man eine Relation zwischen den
beiden Datenbanken aufbaut. Das ist aber nur dann mФglich, wenn
mindestens ein Datensatzfeld in beiden Datenbanken gleichzeitig
vorhanden ist. Diese EinschrДnkung wird sofort klar, wenn man
sich vor Augen fБhrt, welche Aktionen das Programm beim
Arbeiten mit einer Datenbankrelation durchfБhren muс.
Aktivieren Sie in der Datenbank 1 den Datensatz mit dem Namen
"MБller", dann muс in diesem Datensatz mindestens eine
Information enthalten sein, die auch in der Datenbank 2 vom
Programm gefunden werden kann. Ansonsten ist es dem Computer
nicht mФglich, eine VerknБpfung zwischen DatensДtzen
herzustellen, da er nicht weiс, welcher Datensatz der Datenbank
2 zu dem aktivierten Datensatz der Datenbank 1 gehФrt.
Dieses verknБpfende Feld wird LOOKUP-SchlБssel genannt. Anhand
des Lookup-SchlБssels wird die Datenbank 2 nach passenden Daten
zu einem in der Datenbank 1 aktivierten Datensatz durchsucht.
Die Datenbank 1 wird auch als MASTER-Datenbank bezeichnet, die
damit verknБpfte Datenbank 2 als SLAVE-Datenbank (engl. Master
and slave = Herr und Sklave).
Wichtig: Der Lookup-SchlБssel muс ein Datensatzfeld sein,
welches in der Slave-Datenbank als Indexfeld ausgezeichnet ist.
Nur dann ist gewДhrleistet, daс die Relation zwischen den
Datenbanken in einer vernБnftigen Zeit durchgefБhrt werden
kann. Immerhin muс ja die zweite Datenbank anhand eines aus der
Master-Datenbank vorgegebenen Suchkriteriums (dem
Masterausdruck) nach passenden DatensДtzen durchsucht werden.
Dies ist nur dann mФglich, wenn dieses Suchkriterium in der
Slave-Datenbank als Indexfeld ausgewДhlt ist, die Slave-
Datenbank also nach diesem Datensatzfeld geordnet ist.
Erstellen von Relationen
Der erste Schritt beim Aufbau einer Relation besteht natБrlich
in der Definition der benФtigten Datenbanken. Dabei geht man
genauso vor wie beim Generieren einer einzelnen Datenbank,
weshalb der folgende Programmcode kommentarlos wiedergegeben
werden soll. Beachten Sie aber bitte, daс die Variablen, welche
die Datensatzfelder bilden, in Master- und Slave-Datenbank
unterschiedliche Bezeichnungen besitzen mБssen:
REM Definition zweier Datenbanken
DIM feld, 1, 3
DIM index, 1, 3
DIM feld_s, 1, 3
DIM index_s, 1, 3
DEFSTRING expr
REM Feldaufbau der Masterdatenbank
feld1=" Name , C, 10, 0"
feld2=" Vorname , C, 20, 0"
feld3=" "
REM Indexaufbau der Masterdatenbank
index1=" Name , Name, , 0, 0"
index2=" "
REM Feldaufbau der Slavedatenbank
feld_s1=" Name, C, 10, 0"
feld_s2=" Wohnort , C, 20, 0"
feld_s3=" "
REM Indexaufbau der Slavedatenbank
index_s1=" Name_s, Name, , 0, 0"
index_s2=" "
REM LФschen evtl. vorhandener Dateien
KILL "master.dbf"
KILL "master.cdx"
KILL "slave.dbf"
KILL "slave.cdx"
REM Erstellen und Γòôffnen der neuen Datenbanken
ICREATE "master", feld, index
ICREATE "slave", feld_s, index_s
IOPEN 1, "master"
IOPEN 2, "slave"
Somit wurden zwei Datenbanken mit den Kennummern 1 und 2
erzeugt. Beachten Sie bitte, daс zwei wichtige Grundkriterien
fБr das Zustandekommen einer Relation erfБllt worden sind:
Beide Datenbanken besitzen in Ihrer Datensatzstruktur ein
gemeinsames Feld, welches als Lookup-SchlБssel verwendet werden
kann (nДmlich "Name", und dieses Feld ist in der Slavedatenbank
als Indexfeld selektiert. Um die Datenbanken jetzt miteinander
zu verknБpfen, rufen Sie folgenden Befehl auf:
ISETREL relnr, dbnr_m, dbnr_s, lookup
Eine Relation erhДlt analog zu einer Datenbank eine Kennummer
(Handle) durch die Variable relnr, Бber welche sie angesprochen
werden kann. Das Handle einer Relation ist als Platzhalter fБr
die Kennummern der verknБpften Datenbanken aufzufassen, da beim
Aufruf der Relation gleichzeitig die se Datenbanken
angesprochen werden. Anstelle der Variablen dbnr_m und dbnr_s
geben Sie die Kennummern der zu verknБpfenden Datenbanken an,
wobei die zuerst genannte Datenbank immer zur Masterdatenbank
wird. Die letzte Variable lookup definiert das
VerknБpfungskriterium zwischen beiden Datenbanken, den Lookup-
SchlБssel. Geben Sie dort die Bezeichnung des Datensatzfeldes
an, welches in beiden Datenbanken enthalten sein muс und anhand
dessen die Relation aufgebaut werden soll. Erinnern Sie sich
bitte daran, daс dieses Feld in der Slavedatenbank ein
Indexfeld sein muс.
Prinzipiell lassen sich beliebig viele Relationen aufbauen.
Eine Masterdatenbank kann unbegrenzt viele Slavedatenbanken
besitzen. Diese kФnnen wiederum Masterdatenbanken weiterer
Slavedatenbanken sein. FБr jede VerknБpfung zweier neuer
Datenbanken muс dann eine Relation mit ISETREL aufgebaut
werden.
Die einzelnen Lookup-SchlБssel auf diese Art verknБpfter
Datenbanken mБssen nicht identisch sein. Nehmen wir an, wir
wollen unserer obigen Relation (mit dem Lookup-SchlБssel
"Name") eine weitere Datenbank mit den Feldern "Wohnort" und
"Straсe" hinzufБgen, so gelingt dies durch Aufbau einer
Relation zwischen der obigen Slavedatenbank und der neuen,
wobei diese Relation den Lookup-SchlБssel "Wohnort" besitzen
wird (dieses Feld ist in den entsprechenden Datenbanken
gemeinsam vorhanden). Alle drei Datenbanken sind dann in
Relation zueinander. Egal welche von beiden Relationen (die
zwischen Master und Slave oder die zwischen Slave und Neu) Sie
aufrufen, Sie erhalten jeweils die zueinander in Beziehung
stehenden DatensДtze aller drei Datenbanken.
Datensatzzeiger innerhalb einer Relation
Auch innerhalb einer Relation gelten fБr die Organisation und
Auswahl von DatensДtzen dieselben Regeln wie bei einer
einzelnen Datenbank. Die DatensДtze werden in jeder Datenbank
separat nach dem aktuellen Index geordnet (welcher fБr Master-
und Slavedatenbank nicht identisch sein muс).
Auch in einer Relation existiert ein Datensatzzeiger, welcher
den aktuellen Datensatz festlegt. Dieser Datensatzzeiger
befindet sich in der Masterdatenbank und kann auch nur dort
bewegt werden. Bei jeder Bewegung des Datensatzzeigers wird die
Relation zwischen den beiden Datenbanken neu aufgebaut, wie
folgendes Schema verdeutlichen soll:
Datenbank 1 Datenbank2
Name Vorname Name Wohnort
---------------------------------------------------------------
MБller Karl-Heinz MБller NБrnberg
Schulz Roland Schulz MБnchen
Weiс Norbert Weiс Frankfurt
Der Datensatzzeiger befindet sich in der Masterdatenbank auf
dem Datensatz mit dem Namen "MБller". Das Feld "Name" ist der
Lookup-SchlБssel der Relation. Der Inhalt des Felds "Name" im
aktuellen Datensatz der Masterdatenbank ist demnach der
Masterausdruck (das Suchkriterium), mit dem die Slavedatenbank
nach zugehФrigen DatensДtzen durchsucht wird. Sobald dort ein
Datensatz mit Inhalt "MБller" im Feld "Name" gefunden wird,
erstellt das Programm die Relation (gekennzeichnet durch den
Doppelpfeil). WБrde der Datensatzzeiger zum nДchsten Datensatz
bewegt, mБсte die Slavedatenbank nach dem neuen Masterausdruck
(in unserem Beispiel wДre das "Schulz") durchsucht werden. Ist
der entsprechende Datensatz gefunden, wird die neue Relation
zwischen den zugehФrigen DatensДtzen aufgebaut.
Was ist nun, wenn zu einem Datensatz in der Masterdatenbank
mehrere DatensДtze in der Slavedatenbank existieren? In KIM
stellt dies kein Problem dar, da eine sogenannte 1 Dies bedeutet, daс das Programm
selbstДndig erkennt, ob mehrere passende DatensДtze der
Slavedatenbank dem Masterausdruck entsprechen. Wird dann
versucht, den Datensatzzeiger in der Masterdatenbank um eine
Position zu verstellen, reagiert das Programm zunДchst so
darauf, daс der nДchste passende Datensatz in der
Slavedatenbank ausgewДhlt wird. Erst wenn es keinen Datensatz
in der Slavedatenbank mehr gibt, der dem Masterausdruck
entspricht, wird der Datensatzzeiger in der Masterdatenbank
weiter bewegt.
Folgende Anweisungen stehen Ihnen zur VerfБgung, um den
Datensatzzeiger in einer Relation zu bewegen. Die Befehle
entsprechen in ihrer Funktion den angegebenen auf eine einzelne
Datenbank bezogenen Anweisungen:
Relationsbefehl Funktion entspricht
---------------------------------------------------------------
IENDEREL relnr, sm,ss Bewegt den Datensatzzeiger
IENDE zum Ende der Masterdatenbank
INEXTREL relnr,ok,sm,ss Bewegt den Datensatzzeiger zum
INEXT nДchsten Datensatz der Masterdatei
IPREVREL relnr,ok,sm,ss Bewegt den Datensatzzeiger zum
IPREV vorherigen Datensatz der Masterdatei
ISTARTREL relnr, sm,ss Bewegt den Datensatzzeiger zum
ISTART Anfang der Masterdatenbank
FБr relnr geben Sie jedesmal die entsprechende Kennummer der
gewБnschten Relation an. Ъber sm legen Sie die Recordstruktur
der Masterdatenbank und Бber ss diejemige der Slavedatenbank
fest, in welche die Бber die aktuelle Relation selektierten
DatensДtze beider Datenbanken geladen werden sollen. Die
Variable ok bei INEXTREL und IPREVREL besitzt die identische
Bedeutung wie bei INEXT und IPREV. Bei Erreichen des Endes der
Masterdatenbank wird also der Wert ok=3 Бbergeben, bei
Erreichen des Beginns der Masterdatenbank der Wert ok=4.
Sortierung
Neben der Organisation von Datenbanken Бber den aktuellen Index
besteht die MФglichkeit, die Sortieren von Datenbanken
innerhalb einer Relation zur Laufzeit des Programms, also
wДhrend des Programmablaufs, zu Дndern. Dazu dient der Befehl
ISETRELSORT relnr, sort_expression
Nach Angabe der Relationsnummer mit relnr ist das neue
Sortierkriterium anzugeben. Dazu bedient man sich des dBASE-
Ausdrucks "->". Mit diesem dBASE-Zeiger wird ein Feld in einer
Datei ausgewДhlt. Links vom Zeiger hat der Name der
ausgewДhlten Datei zu stehen, rechts davon der Name des
ausgewДhlten Feldes. MФchten Sie beispielsweise, daс die oben
definierte Slavedatenbank nach dem Datensatzfeld "Wohnort"
sortiert wird, so geben Sie fБr die Variable sort_expression
folgendes an:
"slave->Wohnort". Nach Aufruf der Anweisung ISETRELSORT wird
die Slavedatenbank unabhДngig vom zuvor aktivierten Index von
nun an nach dem Datensatzfeld "Wohnort" sortiert.
Eine Ъbersicht Бber die wichtigsten dBASE-AusdrБcke finden Sie
im Anhang dieses Buches.
Abfragen
Bei der Definition von Indizes fБr eine einzelne Datenbank
haben wir kennengelernt, daс es mФglich ist, fБr einen Index
einen Filter zu definieren, mit dessen Hilfe die Suche nach
DatensДtzen entsprechend eingeschrДnkt und konzentriert werden
kann. Diese Filter wurden Бber dBASE-AusdrБcke festgelegt.
Sie haben die MФglichkeit, zur Laufzeit des Programms, also
mitten im Programmablauf, auch fБr Relationen Дhnliche Filter
zu setzen, die dann Abfragen entsprechend vorbearbeiten. Die
Anweisung lautet:
ISETRELQUERY relnr, expression
FБr relnr geben Sie wie gewohnt die Kennummer der
entsprechenden Relation an. Anstelle von expression hat dann
der gewБnschte Abfragefilter zu stehen.
Auch diese Filter mБssen mit Hilfe von dBASE-AusdrБcken
festgelegt werden. Eine Ъbersicht Бber die wichtigsten dBASE-
AusdrБcke finden Sie Anhang dieses Buches. Wir wollen an dieser
Stelle nicht nДher darauf eingehen.
Die Vorgehensweise ist identisch zu der im vorherigen Abschnitt
bei der Erstellung von Indexfiltern beschriebenen. Ein kurzes
Beispiel soll dies noch einmal verdeutlichen. Wenn Sie mФchten,
daс ab einer bestimmten Position im Programm nur noch solche
DatensДtze aus der Relation herausgesucht werden kФnnen, bei
denen im Feld "Name" ein Name aufgefБhrt ist, der mit einem
Buchstaben im Intervall von N bis Z beginnt, so geben Sie den
Abfragefilter ' Name>"M" ' fБr die Variable expression an. Ab
dem Aufruf des Befehls ISETRELQUERY sind dann nur noch solche
DatensДtze in der Relation erreichbar, die einen Namen
beinhalten, dessen Anfangsbuchstabe im Alphabet nach M kommt.
Soll dieser Filter im Programm dann an einer anderen Stelle
wieder geДndert werden, rufen Sie noch einmal ISETRELQUERY auf
und geben einen neuen Abfragefilter an.
Beenden einer Relation
Eine Relation zwischen zwei Datenbanken kann jederzeit im
Programm wieder beendet werden. Rufen Sie dazu auf:
IEXITREL relnr
FБr relnr geben Sie das Handle der Relation an. Welche beendet
werden soll. Die verknБpften Datenbanken verhalten sich von da
an wieder wie zwei einzelne Datenbanken. Beachten Sie bitte,
daс die Datenbanken durch die Beendigung der Relation nicht
geschlossen werden! Dies gelingt nur mit dem Befehl ICLOSE.
ΓòÉΓòÉΓòÉ 15. KIM im Netz ΓòÉΓòÉΓòÉ
Datenbanken im Netz
SelbstverstДndlich kann KIM auch in einem Netzwerk betrieben
werden. Mehrere Anwender besitzen dann die MФglichkeit,
gleichzeitig mit einer Datenbank zu arbeiten. Dies kann so
aussehen, daс z.B. mehrere Benutzer gleichzeitig Daten in eine
geФffnete Datei schreiben. Es existiert aber auch die
MФglichkeit, daс nur ein Benutzer (ein Super-User) Daten
verДndern kann, wДhrend die anderen Netzwerkanwender lediglich
Einblick in die Daten haben, diese aber nicht modifizieren
kФnnen. Ein Netzwerksystem sieht meist in der Praxis so aus,
daс an einem leistungsstarken Rechner (meistens eine UNIX-
Workstation oder ein Groсrechner) eine grФсere Anzahl an
Terminals angeschlossen sind, Бber welche der Rechner
angesprochen werden kann. Daraus ergeben sich viele Vorteile,
aber auch einige Schwierigkeiten, die bei der Erstellung eines
im Netzwerk betriebsfДhigen Programms berБcksichtigt werden
mБssen.
Ein Hauptproblem einer jeden Netzwerkanwendung ist der
gleichzeitige Zugriff mehrerer Anwender auf den gleichen
Datensatz. Es kann dann beispielsweise vorkommen, daс der eine
Anwender einen Datensatz gerade bearbeiten will, den der andere
im Moment lФscht. Um solche MiсverstДndnisse zu vermeiden,
besitzen KIM-Datenbanken gewisse Sperrvorrichtungen. Es werden
die Sperrprotokolle der Datenbanksysteme FoxPro 2.0, dBASE 5
sowie Clipper 5.1 unterstБtzt.
Das Sperren
KIM bietet die MФglichkeit, einzelne DatensДtze innerhalb einer
Datenbank vor einem Zugriff zu sperren. Der Datensatz kann dann
lediglich gelesen, aber nicht verДndert werden. Teilweise wird
eine Sperrung auch in Datenbanken vorgenommen, die nicht in
einem Netzwerk betrieben werden. So wird eine automatische
Datensatzsperre von allen Befehlen durchgefБhrt, die eine
Modifizierung eines Datensatzes bewirken (z.B. IMODREC, IADD,
IDEL). Dies soll eine mФglichst reibungslose Funktion dieser
Anweisungen gewДhrleisten. Eigentlich ist diese Datensatzsperre
nur fБr den Zeitraum notwendig, in welcher die obengenannte
Aktion durchgefБhrt wird. Da aber der Sperr- und auch der
Entsperrvorgang vergleichsweise zeitaufwendig sind, verzichtet
KIM darauf, die einmal gesperrten DatensДtze wieder zu
entsperren. Die Sperrung wird ohnehin ebenfalls automatisch
aufgehoben, wenn der Datensatzzeiger durch einen entsprechenden
Befehl auf den gesperrten Datensatz gestellt wird. Gerade in
einem Netzwerk kann es jedoch notwendig sein, einen Datensatz
zu sperren bzw. zu entsperren, ohne daс obige Aktionen
durchgefБhrt werden. Hierzu sind zwei Befehle vorgesehen
(welche aber nur im Netzwerk verwendet werden kФnnen). Eine
Sperrung eines Datensatzes erreicht man mit
ILOCK nr, ok
Der aktuelle Datensatz der mit ihrem Handle selektierten
Datenbank wird gesperrt. Ъber ok wird der Erfolg dieser Aktion
mitgeteilt. Konnte der Datensatz gesperrt werden, wird ein Wert
ok<>50 zurБckgegeben. Gelang die Sperrung aus irgendeinem
Grunde nicht, liefert das Programm ok=50 und eine entsprechende
Meldung zurБck. Meist ist der entsprechende Datensatz dann
bereits gesperrt.
Eine Entsperrung erreicht man mit der Anweisung
IUNLOCK nr, ok
Die Befehlssyntax entspricht der von ILOCK. Konnte der aktuelle
Datensatz entsperrt werden, erhДlt ok einen Wert ungleich 50.
Bei negativem Erfolg wird ok=50 zurБckgegeben. Bei der Sperrung
eines Datensatzes handelt es sich um die niedrigste MФglichkeit
einer Sperre in KIM. Kleinere Informationseinheiten wie Felder
kФnnen nicht gesperrt werden.
Sperren von Dateien
SelbstverstДndlich kФnnen nicht nur einzelne DatensДtze,
sondern auch gesamte Datendateien (also gesamte Datenbanken)
gesperrt werden. Ist eine Datenbank gesperrt, ist es nicht
mФglich, DatensДtze zu verДndern oder zusДtzliche DatensДtze
neu anzufБgen.
KIM verfБgt Бber Aktionen, bei denen automatisch fБr den
Zeitraum der Aktion Datenbanken gesperrt werden, gleichgБltig,
ob diese sich im Netzwerk befinden oder nicht. Es handelt es
dabei um die Befehle IPACK, IMAKEINDEX und IREINDEX.
Im Gegensatz zur automatischen Datensatzsperre erfolgt bei der
automatischen Datenbanksperre sofort eine selbsttДtige
Entsperrung, um einen weiteren Zugriff auf die Datenbank nach
Abarbeiten des obigen Befehls zu ermФglichen.
In einem Netzwerk wird die Sperrung von Datenbanken Бber FLAGS
gesteuert, welche im БbernДchsten Abschnitt nДher erlДutert
werden.
Sperren von Indexdateien
Wird eine Aktualisierung einer Datenbank oder eines Indizes
vorgenommen, sperrt KIM automatisch die Index- und Memodateien,
die an diesem Vorgang beteiligt sind, um einen reibungslosen
Ablauf der Aktion zu gewДhrleisten. Nach Beendigung der
Aktualisierung werden die entsprechenden Dateien automatisch
wieder entsperrt, da sie zum Funktionieren des Programms
benФtigt werden. Ein Benutzer hat auf diesen Sperrmechanismus
keinen Einfluс.
Flags
Sie kФnnen die Sperrmechanismen Ihres Programms durch FLAGS
bestimmen. Diese FLAGS besitzen dann fБr alle Datenbanken in
diesem Programm GБltigkeit. Beachten Sie bitte, daс diese FLAGS
im Gegensatz zu den FLAGS, die sich auf Objekte beziehen, zu
Beginn des Programms als Zahlenvariablen definiert werden
mБssen, also z.B. DEFFLOAT _DB_EXCLUSIVE. Des weiteren mБssen
diese FLAGS unbedingt vor dem Γòôffnen der Datenbank, also vor
der IOPEN-Anweisung gesetzt werden, da sie sonst keine Wirkung
zeigen.
Die Sperrung eines Datensatzes wird Бber _DB_READ_LOCK
geregelt:
_DB_READ_LOCK = 1 Der Datensatz wird beim Lesen automatisch
gesperrt.
_DB_READ_LOCK = 0 Der Datensatz wird nicht automatisch
gesperrt. (default)
Die Sperrung einer ganzen Datenbank wird Бber _DB_READ_ONLY
gesteuert:
_DB_READ_ONLY=1 Die Datenbank wird im Lesemodus geФffnet,
Оnderungen und HinzufБgen von DatensДtzen
wird nicht gestattet
_DB_READ_ONLY=0 Die Datenbank wird normal mit allen
BearbeitungsmФglichkeiten geФffnet.
Sie haben auch die MФglichkeit zu entscheiden, ob nur ein oder
mehrere Benutzer auf die Datenbank zugreifen dБrfen. Dazu dient
_DB_EXCLUSIVE:
_DB_EXCLUSIVE=1 Die Datenbank kann nur von einem Benutzer
zur selben Zeit bearbeitet werden.
_DB_EXCLUSIVE=0 Die Datenbank wird fБr den Netzwerkbetrieb
geФffnet, es kФnnen also mehrere Benutzer
damit gleichzeitig arbeiten. (default)
Setzen Sie das FLAG nicht, wird als Vorgabe _DB_EXCLUSIVE=0
aufgerufen. Wir empfehlen, bei Aktionen wie IPACK, IMAKEINDEX
oder IREINDEX die Datenbank grundsДtzlich als Single-User-
System zu Фffnen (_DB_EXCLUSIVE=1), um Fehlfunktionen zu
vermeiden.
KIM bietet zusДtzlich Optionen, die die Zugriffsgeschwindigkeit
auf eine Datenbank erhФhen. Dies geschieht Бber eine sogenannte
Bit-Optimierung. Sie kФnnen entscheiden, ob Sie diese
Optimierung Бberhaupt oder nur im Lese- oder Schreibmodus
verwenden wollen. Problematisch ist die Bitoptimierung in jedem
Fall im Netzwerkbetrieb, da hierbei durch falsche Zugriffe
veraltete Pufferdaten herangezogen werden kФnnen und
Fehlinformationen geliefert werden. Wir empfehlen daher, auf
die Optimierung im Netzwerkbetrieb zu verzichten. Sie steuern
die Optimierung mit:
_DB_OPTIMIZE=-1 Es wird eine Leseoptimierung im
Single-User-Modus durchgefБhrt.(default)
_DB_OPTIMIZE=1 Es wird eine Leseoptimierung im Multi-
User-Modus durchgefБhrt
(Netzwerkbetrieb, Vorsicht)
_DB_OPTIMIZE=0 Es wird keine Leseoptimierung
durchgefБhrt
_DB_OPTIMIZE_WRITE=-1 Es wird eine Schreiboptimierung im
Single-User-Modus durchgefБhrt.(default)
_DB_OPTIMIZE_WRITE=1 Es wird eine Schreiboptimierung im
Multi-User-Modus durchgefБhrt
_DB_OPTIMIZE_WRITE=0 Es wird keine Schreiboptimierung
durchgefБhrt
Das letzte FLAG dient dazu, ein AbstБrzen des Programms im
Netzwerk mФglichst zu verhindern. Es kann vorkommen, daс ein
Sperren von Daten dazu fБhrt, daс ein Anwender keine Verbindung
zu der gewБnschten Datenbank erhДlt. Das Programm versucht in
diesem Fall unendlich lange, durch wiederholtes Abfragen die
Verbindung herzustellen. Das Programm "hДngt" sich auf, es
kommt zu einem DEADLOCK.
Um dies zu vermeiden, kФnnen Sie ein FLAG setzen, welches die
Anzahl der Versuche zur Herstellung einer Verbindung in solchen
FДlllen begrenzt. Ist nach der vorgegebenen Anzahl an Versuchen
noch immer keine Verbindung zustandegekommen, wird das Programm
abgebrochen:
_DB_LOCK_ATTEMPTS=-1 Es wird unendlich lange versucht,
eine Verbindung herzustellen
(DEADLOCK-Gefahr) (default)
_DB_LOCK_ATTEMPTS>0 Geben Sie eine beliebige ganze Zahl
grФсer 0 an. Es wird genauso oft wie
angegeben versucht, eine Verbindung
herzustellen, dann wird das Programm
abgebrochen.
Wir empfehlen folgende FLAG-Einstellung fБr den Betrieb von KIM
im Netzwerk:
_DB_LOCK_ATTEMPTS = 3
_DB_EXCLUSIVE = 0
_DB_READ_ONLY = 0
_DB_READ_LOCK = 0
ΓòÉΓòÉΓòÉ 16. Fragen und Antworten ΓòÉΓòÉΓòÉ
Fragen und Antworten
---------------------------------------------------------------------------
Wie bekommt ein Objekt den Eingabefokus ?
Version 2.0
Addieren Sie das Objekt mit ADD_ITEM nochmals an das Fenster.
Version 2.1
Benutzen Sie den Befehl SETFOCUS.
---------------------------------------------------------------------------
Wie bestimme ich die Eingabereihenfolge ?
Die Reihenfolge wird durch die Reihenfolge bestimmt, wie die Objekte
an ein Fenster mit ADD_ITEM oder ADD_ITEM_ARRAY addiert werden.
---------------------------------------------------------------------------
Ich addiere weitere Objekte an eine Listbox oder Combobox nachdem
diese am Bildschirm ausgegeben wurde. Die Objekte werden
am Bildschirm nicht dargestellt. Was muс ich tun ?
Nachdem die Objekte addiert wurden, verwenden Sie den Befehl :
EVENT_ON_ITEM id$,"create" und EVENT_ON_ITEM id$,"redisplay"
---------------------------------------------------------------------------
Wie Дndere ich die Hintergrundfarbe eines Fensters ?
Definiere mit DEF_PALETTE eine Farbe fБr den Hintergrund und
setzte bei DEF_WINDOW die Eigenschaft "color on".
Anschlieсend weise dem Fenster mit "COLOR_ITEM" die Farbpalette zu.
---------------------------------------------------------------------------
Wie kann ich ein KIM Programm mit Kommandozeilenparameter starten ?
Siehe die Beschreibung fБr "COMMANDLINE"
---------------------------------------------------------------------------
Was habe ich zu beachten bei Dateioperationen ?
1. Textdatei neu erstellen und Daten hineinschreiben
KILL datei
OPEN 1,datei
PUTS 1,zeile
CLOSE 1
2. An eine bestehende Datei etwas am Schluс anhДngen.
OPEN 1,datei
PUTS 1,zeile
CLOSE 1
3. Aus einer bestehenden Datei etwas Lesen
OPEN 1,datei,"r"
GETS 1,zeile
CLOSE 1
oder
LOADARRAY datei,arr,1,max,anzahl
---------------------------------------------------------------------------
Was muс ich beachten bei Fenster mit einem NOTEBOOK-Element ?
Das Fenster kann nicht auf Ganzbildschirm mit dem Befehl
EVENT_ON_ITEM id$,"maximized" vergrФсert werden.
---------------------------------------------------------------------------
Was muс ich beachten wenn ich mehrere BUTTONS in einem Fenster habe ?
Es kann nur ein Button als aktives Objekt dargestellt werden, auсer
man fasst mehrere Buttons zu einer Gruppe zusammen.
---------------------------------------------------------------------------
Wie kann ich mehrere Elemente in einer Gruppe als selektiert
kennzeichnen ?
Geben Sie der Gruppe die Eigenschaft "multi"
---------------------------------------------------------------------------
Wie kann ich feststellen, ob ein Radiobutton oder Checkboxbutton
gesetzt ist ?
Benutzen Sie den Befehl GET_ITEM_STATUS mit "set".
---------------------------------------------------------------------------
Ich versuche eine Datei mit OPEN 9,"test" zu Фffnen und erhalte immer
die Fehlermeldung, daс die Datei schon geФffnet ist.
Es besteht ein Subverzeichnis mit dem Namen "Test" im Verzeichnis.
---------------------------------------------------------------------------
Ich habe einen Index auf ein Textfeld erstellt. Wenn ich
Datenbankfunktionen benutzte erhalte ich eine Fehlermeldung.
MФgliche Ursache :
Das Textfeld ist zu lang fБr eine Indexbeschreibung.
Benutzen Sie den Befehl SUBSTR in der Indexdefinition um die
Indexbeschreibung auf einen Teil des Textfeldes zu beschrДnken.
---------------------------------------------------------------------------
Ich habe eine neue Datenbank erstellt. Bei den Befehlen IPREV oder
INEXT erhalte ich eine Fehlermeldung.
Es muс mindestens ein Datensatz in der Datenbank vorhanden sein,
sonst funktionieren die DB-Befehle nicht.
---------------------------------------------------------------------------
ΓòÉΓòÉΓòÉ 17. Das Runtime-Kit ΓòÉΓòÉΓòÉ
Das Runtime-Kit
KRUN
Das Runtime-Kit liegt nur in der KIM-Vollversion bei.
Wenn Sie mit Hilfe von KIM Programme nicht nur zu Ihrer eigenen
Verwendung erstellen wollen, sondern auch kommerziell
vertreiben mФchten, ergibt sich ein rechtliches Problem. Wie
bereits erwДhnt ist KIM eine Interpretersprache. Der einem
Produkt zugrundeliegende Code muс also bei jedem Programmstart
aufs Neue fБr den Computer Бbersetzt werden. Wenn Sie ein
Programm verkaufen wollen, mБssen Sie daher den KIM-Interpreter
mitliefern.
Es ist aber aus urheberlichen GrБnden nicht gestattet, den
normalen KIM-Interpreter KIM.EXE in solchen FДllen an Ihre
Kunden weiterzugeben. Dennoch benФtigt Ihr Kunde zusДtzlich zum
Programm einen KIM-Interpreter. Es ist deshalb dem KIM-
Programmpaket ein zweiter Interpreter beigelegt, KRUN.EXE.
KRUN.EXE darf jederzeit im Verbund mit einem KIM-Programm an
Dritte weitergegeben werden. Im Gegensatz zum normalen
Interpreter KIM.EXE kann KRUN.EXE nur Programme verarbeiten,
deren Programmcode zuvor mit KCRYPT verschlБsselt wurde.
KRUN.EXE kann daher nicht zur Entwicklung neuer KIM-Programme
herangezogen werden.
Der Aufruf von Programmen mittels KRUN gelingt wie folgt:
KRUN datei (Enter-Taste drБcken)
Anstelle von datei geben Sie bitte den Namen des zu startenden
Programms an.
KCRYPT
Wie erwДhnt mБssen Programme, welche mit dem Interpreter KRUN
betrieben werden sollen, zuvor verschlБsselt werden. Hierzu
dient das VerschlБsselungsprogramm KCRYPT.EXE. Dabei wird ein
Programm in einen P-Code umgewandelt, Leerzeichen und Bemerkungen
entfernt und anschlieсend verschlБsselt.
Aufruf:
KCRYPT (Entertaste drБcken)
FБr datei geben Sie bitte den Namen des zu verschlБsselnden
Programmes an, fБr dateineu den Namen, den das Programm nach
der VerschlБsselung erhalten soll.
Es ist nebenbei gesagt sehr sinnvoll, der verschlБsselten Datei
einen anderen Namen zu geben als der unverschlБsselten.
Ansonsten wБrde bei diesem Vorgang der unverschlБsselte
Programmcode Бberschrieben und kФnnte von Ihnen nicht mehr
bearbeitet werden.
Es kommt natБrlich vor, daс Sie ein Produkt erstellen, daс
nicht nur aus einer Hauptdatei, sondern auch aus Include- und
Importdateien besteht. In diesem Fall besteht die MФglichkeit,
alle zusammengehФrenden Dateien in einem Schritt zu
verschlБsseln. Legen Sie hierzu eine neue Datei mit der Endung
angeben, beispielsweise:
Zu verschlБsselnde Datei Inhalt
KUNDEN.PRO Kunden.kim
Define.inc
Biblio.inc
Liste.imp
In der Datei Kunden.pro sind also das Hauptprogramm Kunden.kim,
die Includedateien Define.inc und Biblio.inc sowie die
Importdatei Liste.imp vorhanden.
Geben Sie nun ein:
KCRYPT kunden.pro (Entertaste drБcken)
Alle in kunden.pro aufgefБhrten Dateien werden dann unter
Beibehaltung ihres Dateinamens verschlБsselt. Gleichzeitig wird
aber ein Verzeichnis "Kunden" angelegt, in welches die
unverschlБsselten Dateien kopiert werden, so daс diese nach wie
vor verfБgbar sind.
Wenn Sie KIM-Programme kommerziell vertreiben mФchten, dБrfen
Sie nicht den normalen Interpreter KIM.EXE mitliefern. Zu
diesem Zweck ist der Zusatzinterpreter KRUN.EXE im
Programmpaket von KIM enthalten. Dieser Interpreter kann nur in
Verbindung mit verschlБsselten Programmen eingesetzt werden.
Zur VerschlБsselung von Programmcodes dient das Programm
KCRYPT.EXE. Auf einfache Weise kФnnen Sie damit Ihren Code fБr
jedermann unleserlich machen.
ΓòÉΓòÉΓòÉ 18. #LABEL ΓòÉΓòÉΓòÉ
Funktion
Markiert eine Position in einem Programm, welche ueber Sprungbefehle
aufgerufen werden kann.
Syntax
#LABEL
Eingabe
Label Von Ihnen festgelegte Bezeichnung der Sprungmarke
Ausgabe
Keine
Beschreibung
Zwischen dem Labelzeichen # und dem Namen der Sprungmarkierung darf
kein Leerzeichen sein. Der Labelname darf maximal aus 32 Zeichen be-
stehen, wobei Sie auch Zahlen verwenden koennen. Insgesamt duerfen in
einem Programm bis zu 500 Labels gesetzt werden. Labels koennen mit den
Sprungbefehlen GOTO und GOSUB aufgerufen werden.
Bespiel #LABEL
Siehe
GOSUB
GOTO
ΓòÉΓòÉΓòÉ 19. BEEP ΓòÉΓòÉΓòÉ
Funktion
Der Rechner piepst kurz.
Syntax
BEEP
Eingabe
Keine
Ausgabe
Keine
Beschreibung
Bitte nicht in Endlosschleifen verwenden, der Computer piepst sonst
unaufhoerlich.
Bespiel BEEP
Siehe
SOUND
ΓòÉΓòÉΓòÉ 20. CHDIR ΓòÉΓòÉΓòÉ
Funktion
Wechselt das aktuelle Verzeichnis.
Syntax
CHDIR pfad$, ok
Eingabe
pfad$ Der Pfad des gewuenschten Verzeichnisses
Ausgabe
ok Gibt das Ergebnis der Operation zurueck:
ok=1: Aktion wurde erfolgreich durchgefuehrt
ok=-1: Aktion konnte nicht durchgefuehrt werden
Beschreibung
entfaellt
Bespiel CHDIR
Siehe
MKDIR
ΓòÉΓòÉΓòÉ 21. CLOSE ΓòÉΓòÉΓòÉ
Funktion
Schliesst eine geoeffnete Textdatei.
Syntax
CLOSE nr.
Eingabe
nr Nummer der zu schliessenden Textdatei
Ausgabe
Keine
Beschreibung
Jede Textdatei erhaelt bei der Erstellung mit OPEN eine Nummer,
mit der Sie eindeutig bezeichnet ist. Deshalb genuegt einfach
die Angabe der entsprechenden Nummer zum Loeschen mit CLOSE, da
dieser Befehl nur fuer Textdateien anwendbar ist.
Bespiel CLOSE
Siehe
OPEN
PUTS
GETS
ΓòÉΓòÉΓòÉ 22. COMMANDLINE ΓòÉΓòÉΓòÉ
Funktion
Liest das Kommandozeilenargument beim Start von KIM in
das Programm ein.
Syntax
COMMANDLINE var$
Eingabe
keine
Ausgabe
var$ Variable mit dem entsprechenden Komandozeilenargument
Beschreibung
Mit diesem Befehl koennen Sie das beim Start des KIM-Programms hinter
dem DOS-Prompt eingegebene Kommandozeilenargument zur weiteren Ver-
wendung in das Programm einlesen.
Bespiel COMMANDLINE
Siehe
ΓòÉΓòÉΓòÉ 23. DATEFORMAT ΓòÉΓòÉΓòÉ
Funktion
Anzeigeformat Дndern.
Syntax
dateformat flag,"DD.MM.YY", date1, date2
Eingabe
flag Maskennr
maske Vorgabemaske der Anzeige
date1 Eingabestring
Ausgabe
date2 Ausgabestring
Beschreibung
keine
Bespiel DATEFORMAT
Siehe
DATETOJU
DATETOW
DATUM
TIME
ΓòÉΓòÉΓòÉ 24. DATETOJU ΓòÉΓòÉΓòÉ
Funktion
Wandelt Dbase-Datum (CCYYMMTT) in Julianische Zahl
Syntax
datetoju datum1, datum_zahl1
Eingabe
datum1 Dbase-Datum "19940402"
Ausgabe
datum_zahl1 Julianische Zhal
Beschreibung
Umwandeln eines Datum in eine Zahl.
Bespiel DATETOJU
Siehe
DATEFORMAT
DATETOW
DATUM
TIME
ΓòÉΓòÉΓòÉ 25. DATETOW ΓòÉΓòÉΓòÉ
Funktion
Ermittelt Wochentag 1=Sonntag ... 7=Samstag
Syntax
datetow datum1, Wochentag
Eingabe
datum1
Ausgabe
Wochentag 1=Sonntag
2=Montag
3=Dienstag
4=Mittwoch
5=Donnerstag
6=Freitag
7=Samstag
Beschreibung
Bespiel DATETOW
Siehe
DATEFORMAT
DATETOJU
DATUM
TIME
ΓòÉΓòÉΓòÉ 26. DATUM ΓòÉΓòÉΓòÉ
Funktion
Ermittelt das Tagesdatum aus dem ROM-BIOS des Computers.
Syntax
DATUM date$
Eingabe
Keine
Ausgabe
date$ Datum in deutschem Format
Beschreibung
Das Programm holt sich das aktuelle Datum aus dem Computer und
konvertiert selbstaendig das dort in englischem Format vorhandene
Datum in deutsches Format (Ausgabe: tt.mm.jj [t=Tag, m=Monat, j=Jahr],
z.B. 12.01.93).
Bespiel DATUM
Siehe
DATUMDIFF
TIME
ΓòÉΓòÉΓòÉ 27. DATUMDIFF ΓòÉΓòÉΓòÉ
Funktion
Ermittelt die Anzahl der Tage zwischen zwei vorgegebenen Datumsangaben.
Syntax
DATUMDIFF startdatum$,enddatum$,tage
Eingabe
startdatum$ Variable mit dem Datum, von dem aus gezaehlt wird
enddatum$ Variable mit dem Datum, bei welchem der Vorgang beendet wird
Ausgabe
tage Anzahl der Tage zwischen den beiden Daten
Beschreibung
Die Datumsangaben muessen in deutschem Format erfolgen. Ein ueber DATUM
ermitteltes Datum muss nicht konvertiert werden (s.dort). Erlaubt sind
folgende Eingabeformate: 19.1.1991; 19.1.91;19.01.91; 19.01.1991. Falls
die Angabe in "startdatum" groesser ist als diejenige in "zieldatum",
erhaelt die Variable "tage" einen negativen Wert.
Bespiel DATUMDIFF
Siehe
DATUM
TIME
ΓòÉΓòÉΓòÉ 28. DEF_BITMAP ΓòÉΓòÉΓòÉ
Funktion
Liest eine externe Bitmap-Datei in ein Programm ein.
Syntax
DEF_BITMAP id_string, x, y, xr, yr, "Name"
Eingabe
id_string Kennung des Objekts
x,y X- und y-Position der linken oberen Ecke des Bildes
xr, yr Breite und Hoehe des Objekts
"Name" Name der Bitmap-Datei
Ausgabe
keine
Beschreibung
Mit diesem Befehl wird eine extern erstellte Bitmap-Datei in ein
KIM-Programm eingelesen und als Objekt definiert.
Bespiel DEF_BITMAP
Siehe
ΓòÉΓòÉΓòÉ 29. END ΓòÉΓòÉΓòÉ
Funktion
Markiert das Ende eines Programms.
Syntax
END
Eingabe
Keine
Ausgabe
Keine
Beschreibung
Diese Anweisung muessen Sie unbedingt an das Ende Ihres Programms
setzen, sonst kann es zu Fehlfunktionen kommen. Dabei duerfen Sie
END aber mehrmals im Programm verwenden, wenn Sie beispielsweise
verschiedene Moeglichkeiten zur Programmbeendigung anbieten wollen.
Bespiel END
Siehe
ΓòÉΓòÉΓòÉ 30. ENDE ΓòÉΓòÉΓòÉ
Funktion
Schaltet den Debugger ab.
Syntax
ENDE
Eingabe
Keine
Ausgabe
Keine
Beschreibung
Die Anweisung ENDE muss an der Position in Ihrem Programm eingefuegt
werden, an welcher der Debugger seine ueberpruefung des Programmcodes
beenden soll.
Bespiel ENDE
Siehe
START
ΓòÉΓòÉΓòÉ 31. EXIST ΓòÉΓòÉΓòÉ
Funktion
Ermittelt, ob eine bestimmte Datei bereits existiert.
Syntax
EXIST datei$,flag
Eingabe
datei$ Name der zu ueberpruefenden Datei
Ausgabe
flag Variable, ueber die das Programm dem Anwender anzeigt,
ob die Datei existiert:
flag = 1: Datei existiert
flag = -1: Datei existiert nicht.
Beschreibung
Um zu erfahren, ob eine Datei existiert, muessen Sie nach dieser
Anweisung den Wert der Variablen flag abfragen.
Bespiel EXIST
Siehe
OPEN
IOPEN
ΓòÉΓòÉΓòÉ 32. FILECOPY ΓòÉΓòÉΓòÉ
Funktion
Kopiert den Inhalt einer Datei in eine andere Datei.
Syntax
FILECOPY quell$, ziel$
Eingabe
quell$ Datei, deren Inhalt kopiert werden soll
ziel$ Datei, in die der Inhalt der Quelldatei kopiert wird
Ausgabe
keine
Beschreibung
Der Inhalt der Zieldatei wird bei diesem Vorgang ueberschrieben.
Bespiel FILECOPY
Siehe
KILL
RENAME
ΓòÉΓòÉΓòÉ 33. FILELEN ΓòÉΓòÉΓòÉ
Funktion
Anzeigen der Dateigroeсe
Syntax
FILELEN, file, laenge
Eingabe
file Dateiname
Ausgabe
laenge Groeсe der Datei
Beschreibung
Bespiel FILELEN
Siehe
ΓòÉΓòÉΓòÉ 34. GETDIR ΓòÉΓòÉΓòÉ
Funktion
Ermittelt das aktuelle Verzeichnis.
Syntax
GETDIR verz$
Eingabe
keine
Ausgabe
verz$ Variable mit dem Namen des aktuellen Verzeichnisses
Beschreibung
Mit diesem Befehl koennen Sie aus einem KIM-Programm heraus das
aktuelle Verzeichnis Ihres Systems ermitteln.
Bespiel GETDIR
Siehe
GETDRIVE
SETDRIVE
ΓòÉΓòÉΓòÉ 35. GETDRIVE ΓòÉΓòÉΓòÉ
Funktion
Ermittelt das aktuelle Laufwerk.
Syntax
GETDRIVE nr
Eingabe
Keine
Ausgabe
nr Variable mit der Codezahl des aktuellen Laufwerkes
Beschreibung
Mit dieser Anweisung koennen Sie aus einem laufenden KIM-Programm
heraus das aktuelle Laufwerk ermitteln. Dieses wird als Codezahl
an KIM zurueckgegeben:
nr=1: Das aktuelle Laufwerk ist A
nr=2: Das aktuelle Laufwerk ist B
nr=3: Das aktuelle Laufwerk ist C usw.
Bespiel GETDRIVE
Siehe
SETDRIVE
ΓòÉΓòÉΓòÉ 36. GETFILES ΓòÉΓòÉΓòÉ
Funktion
Liest Datei- und Unterverzeichnisnamen eines Verzeichnisses
in ein Array ein.
Syntax
GETFILES vorgabe$, array$, start, ende, flag
Eingabe
vorgabe$ Variable mit vorgegebenem Auswahlkriterium
array$ Name des Arrays, in das die Namen eingelesen werden sollen
start Kennummer der ersten zu verwendenen Arrayvariablen in Feld
ende Kennummer der letzten zu verwendenen Arrayvariablen im Feld
flag Auswahl, ob auch Unterverzeichnisse eingelesen werden sollen:
flag=1: Unterverzeichnisse einlesen;
flag<>1: Unterverzeichnisse nicht einlesen.
Ausgabe
flag Variable mit der Anzahl der eingelesenen Datei- und
Verzeichnisnamen
Beschreibung
Es koennen gemaess einer Vorgabe bestimmte Dateien eines Verzeichnisses
in ein Array eingelesen werden. Beispielsweise lassen sich alle
EXE-Dateien im Verzeichnis Cexe ein-
lesen. Mit Hilfe der Variablen flag koennen Sie entscheiden, ob bei
diesem Vorgang auch eventuell vorhandene Unterverzeichnisse berueck-
sichtigt werden sollen.
Bespiel GETFILES
Siehe
FILELEN
ΓòÉΓòÉΓòÉ 37. GETS ΓòÉΓòÉΓòÉ
Funktion
Liest eine Zeile aus einer Textdatei in das Programm ein.
Syntax
GETS nr,string$ oder GETS nr, zahl
Eingabe
nr Kennziffer der zu oeffnenden Datei
Ausgabe
string$ String mit der eingelesenen Zeile aus der
entsprechenden Datei
zahl Zahlenvariable mit der eingelesenen Zahl aus der Datei
Beschreibung
Die Textdatei muss zuvor mit der Anweisung OPEN geoeffnet werden. Falls
das Textende erreicht wird, wird der Variablen string$ der Wert "EOF"
(End Of File) zugewiesen. Die maximale Laenge der zu lesenden Zeile
darf 255 Zeichen betragen.
Bespiel GETS
Siehe
GETS_SELECT
SELECT
ΓòÉΓòÉΓòÉ 38. GETS_SELECT ΓòÉΓòÉΓòÉ
Funktion
Einlesen einer Textdateizeile mit automatischer Aufsplittung einer Zeile
Syntax
GETS_SELECT datei_nr,trennzeichen,Array,von,bis
Eingabe
datei_nr
trennzeichen
array
von
bis
Ausgabe
array Array mit Inhalt
Beschreibung
Der Befehl wurde geschaffen um Dateien mit Zeilenlaenge > 255 Zeichen
einzulesen. (ASCII-Import aus anderen Datenbanken)
Der Befehl ist vergleichbar mit dem Befehl SELECT. Mit dem Unterschied,
dass direkt aus einer Textdatei gelesen wird und nach dem Trennzeichen in
ein Array zerlegt wird. Die Zeile kann bis zu 3000 Bytes lang sein. Die
ermittelten Teilstrings duerfen aber max. 255 Zeichen lang sein.
Bespiel GETS_SELECT
Siehe
SELECT
ΓòÉΓòÉΓòÉ 39. IMPORT ΓòÉΓòÉΓòÉ
Funktion
Laedt ausgelagerte Programmteile in das Programm und entfernt Sie sofort
nach der Abarbeitung wieder aus dem Speicher.
Syntax
IMPORT datei
Eingabe
datei Name der zu ladenden Importdatei
Ausgabe
Beschreibung
IMPORT laedt einen Programmteil vom aktuellen Laufwerk, welcher bis zum
Programmendekennzeichen IMPORTEND abgearbeitet und danach wieder aus
dem Speicher entfernt wird. Somit duerfen Haupt- und Importdatei zusammen
groesser als 64 KB sein. Die Importdatei selbst darf aber nur maximal
64 KB Speicherkapazitaet beanspruchen. In eine Importdatei selbst darf
nicht importiert werden. In der Importdatei definierte Variablen ver-
bleiben jedoch im Speicher. Achten Sie deshalb darauf, keine Variablen
oder Labels doppelt zu verwenden. Wenn Sie eine Importdatei mehrfach
in ein Programm laden moechten, sollten Sie auf Variablendefinitionen in
der Importdatei verzichten, da sonst jedesmal die Definition durchge-
fuehrt wuerde. Andererseits koennen Sie alle Variablen des Programms in
einer Importdatei definieren und diese einmal zu Beginn laden. Achten
Sie bei Sprungbefehlen darauf, dass die Sprungmarke auch gerade
importiert ist. Sie koennen von der Importdatei aus andere Unterpro-
gramme anspringen.
Bespiel IMPORT
Siehe
IMPORTEND
ΓòÉΓòÉΓòÉ 40. IMPORTEND ΓòÉΓòÉΓòÉ
Funktion
Programmendezeichen in Importdateien.
Syntax
IMPORTEND
Eingabe
Keine
Ausgabe
Keine
Beschreibung
Jede Importdatei muss mit IMPORTEND beendet werden. Erst dann erfolgt
der Ruecksprung in das Hauptprogramm und die Entfernung der Importdatei
aus dem Speicher.
Bespiel IMPORTEND
Siehe
IMPORT
ΓòÉΓòÉΓòÉ 41. INT ΓòÉΓòÉΓòÉ
Funktion
Wandel eine numerische Zahl in einen Integer-Wert
Syntax
INT, alt neu
Eingabe
alt Numerische Zahl
Ausgabe
neu Interger Zahl
Beschreibung
Wird benФtigt um eine Zahlenvariable in ein ganze Zahl
umzuwandeln
Bespiel INT
Siehe
ΓòÉΓòÉΓòÉ 42. ISOMAP ΓòÉΓòÉΓòÉ
Funktion
Anzeigen des Zeichensatz in gleicher Form.
Syntax
ISOMAP wert
Eingabe
wert 0=Iso-Zeichensatz mapping wird nicht durchgefБhrt
wert 1=Iso-Zeichensatz mapping wird durchgefБhrt
Ausgabe
Beschreibung
Betrifft alle anzeigen von Umlauten.
Bespiel ISOMAP
Siehe
ΓòÉΓòÉΓòÉ 43. JUTODATE ΓòÉΓòÉΓòÉ
Funktion
Wandelt Julianische Zahl in DbaseDatum (CCYYMMTT)
Syntax
jutodate datum_zahl1, datum1
Eingabe
datum_zahl1
Ausgabe
datum1
Beschreibung
Bespiel JUTODATE
Siehe
DATETOJU
DATETOW
DATEFORMAT
DATUM
TIME
ΓòÉΓòÉΓòÉ 44. KILL ΓòÉΓòÉΓòÉ
Funktion
Loescht eine Datei.
Syntax
KILL datei$
Eingabe
datei$ Zu loeschende Datei (ggf. mit Pfadangabe)
Ausgabe
Keine
Beschreibung
Durch diese Anweisung wird eine gesamte Datei geloescht. Fuer den Namen
der zu loeschenden Datei duerfen keine WILDCARDS *.* verwendet werden.
Bespiel KILL
Siehe
EXIST
ΓòÉΓòÉΓòÉ 45. LOAD ΓòÉΓòÉΓòÉ
Funktion
Erstellt ein Auswahlmenue zur Selektierung einer Datei.
Syntax
LOAD parentwindow_id, such$,datei$ [ueberschrift]
Eingabe
parentwindow_id Kennummer des Fensters, in dem die Auswahlbox als
Unterfenster erscheinen soll
such$ Pfadangabe fuer die gesuchte Datei
ueberschrift Titel des Auswahlfensters
Ausgabe
datei$ Name der gesuchten Datei inklusive Pfad
Beschreibung
Mit diesem Befehl koennen Sie eine beliebige Datei laden. Geben Sie
zunaechst einen Suchpfad an (wobei Sie auch die Wildcard *.* verwenden
koennen). Es erscheint dann im angegebenem Fenster ein Menuefenster mit
allen unter diesen Suchpfad zur Auswahl stehenden Dateien. Optional
koennen Sie dem Menuefenster eine ueberschrift verleihen. Sie koennen
sich innerhalb des Menuefensters mit den Pfeiltasten sowie POS1 (HOME)
und ENDE (END) bewegen. Mit der ENTER-Taste waehlen Sie eine Datei aus,
mit ESC brechen Sie den Vorgang ab. Beachten Sie bitte, dass im Menue-
fenster Dateinamen klein und Verzeichnisnamen gross geschrieben sind.
Bespiel LOAD
Siehe
OPEN
ΓòÉΓòÉΓòÉ 46. MKDIR ΓòÉΓòÉΓòÉ
Funktion
Erstellt aus einem KIM-Programm heraus ein neues Verzeichnis.
Syntax
MKDIR dirname$, ok
Eingabe
dirname$ Variable mit dem Namen des zu erstellenden Verzeichnisses
Ausgabe
ok Variable mit dem Ergebnis der Aktion:
ok=1: Verzeichnis konnte erstellt werden
ok=-1: Verzeichnis konnte nicht erstellt werden
Beschreibung
Hiermit koennen Sie von KIM aus ein neues Verzeichnis erstellen. Es
wird in das aktuelle Verzeichnis als Unterverzeichnis eingefuegt.
Bespiel MKDIR
Siehe
ΓòÉΓòÉΓòÉ 47. OPEN ΓòÉΓòÉΓòÉ
Funktion
oeffnet eine bestimmte Textdatei.
Syntax
OPEN nr,datei$ [,"status"]
Eingabe
nr Nummer der zu oeffnenden Datei
datei$ Name der zu oeffnenden Datei (evtl. mit Pfad)
status Gibt den Arbeitsmodus des Befehls an
Ausgabe
Beschreibung
Beim oeffnen der Datei ohne Angabe des Status des Befehls wird die Datei
als Textdatei betrachtet. Es wird der Status "oeffnen und Schreiben"
vorgegeben. Falls die Textdatei datei$ nicht vorhanden ist, wird Sie
durch diesen Befehl angelegt. Es kann Text an eine bestehende Datei
angefuegt werden. Die Angabe der Nummer dient zum Verwalten evtl.
mehrerer gleichzeitig geoeffneter Dateien. Die Nummer muss aber auch
angegeben werden, wenn nur eine Datei geoeffnet ist, da die sich auf
die Datei beziehenden Befehle ueber die Dateinummer angesprochen werden.
Sie koennen optional folgende Arbeitsmodi des Befehls verwenden:
"r" Datei oeffnen zum Lesen (keine Schreibmoeglichkeit, d.h.
die Datei kann nur eingesehen, aber nicht veraendert
werden),
"w" Datei oeffnen zum Schreiben; Neuerstellung, falls Datei
nicht vorhanden (Dateiinhalt kann veraendert, aber nicht
eingesehen werden)
"r+" Datei oeffnen zum Lesen und Schreiben (veraenderbar)
Geben Sie den entsprechenden Status in die Befehlssyntax ein, wenn Sie
nicht den normalen Modus verwenden moechten.
Bespiel OPEN
Siehe
CLOSE
GETS
PUTS
ΓòÉΓòÉΓòÉ 48. OS_TYPE ΓòÉΓòÉΓòÉ
Funktion
Ermittelt die Version des KIM-Interpreters.
Syntax
OS_TYPE os$
Eingabe
keine
Ausgabe
os$ Variable mit dem Namen des verwendeten KIM-Interpreters.
Beschreibung
Mit diesem Befehl koennen Sie ermitteln, welche Version des
KIM-Interpreters ("OS/2", "WIN", "MSDOS") gerade aktiv ist.
Bespiel OS_TYPE
Siehe
ΓòÉΓòÉΓòÉ 49. PUTS ΓòÉΓòÉΓòÉ
Funktion
Schreibt eine oder mehrere Variablen in eine Ausgabedatei.
Syntax
PUTS nr,string$ (," ";a$,zahl)
Eingabe
nr Nummer, mit der die anzusprechende Textdatei
gekennzeichnet wurde.
string$ In die Ausgabedatei zu schreibende Zeichen (" "),
Stringvariablen
a$ (string$) oder Zahlenvariablen (zahl)
zahl
Ausgabe
Keine
Beschreibung
Die Ausgabeeinheit muss vor Anwendung dieser Anweisung mittels OPEN
eroeffnet worden sein. Die entsprechende Datei wird ueber die dabei
vergebene Nummer angesprochen.
Bespiel PUTS
Siehe
CLOSE
GETS
OPEN
SELECT
ΓòÉΓòÉΓòÉ 50. REM ΓòÉΓòÉΓòÉ
Funktion
Leitet einen Kommentar "Kommentar" \t ein, der von KIM nicht als
Befehl bearbeitet wird.
Syntax
REM
Eingabe
Keine
Ausgabe
Keine
Beschreibung
Alle Anweisungen, die in der Programmzeile nach dem REM folgen, werden
von KIM als Kommentar angesehen und nicht bearbeitet. Falls in der
Programmzeile vor dem REM bereits eine Anweisung steht, muss dem REM
ein Doppelpunkt vorangestellt werden.
Bespiel REM
Siehe
ΓòÉΓòÉΓòÉ 51. RENAME ΓòÉΓòÉΓòÉ
Funktion
Benennt eine Datei um.
Syntax
RENAME name_alt$, name_neu$, ok
Eingabe
name_alt$ Variable mit dem alten Dateinamen
name_neu$ Variable mit dem neuen Dateinamen
Ausgabe
ok Variable mit dem Ergebnis der Aktion:
ok=1: Aktion war erfolgreich
ok=-1: Aktion war nicht erfolgreich
Beschreibung
Hiermit koennen Sie aus KIM heraus eine Datei umbenennen.
Bespiel RENAME
Siehe
KILL
FILECOPY
ΓòÉΓòÉΓòÉ 52. RMDIR ΓòÉΓòÉΓòÉ
Funktion
Loescht aus KIM heraus ein Verzeichnis.
Syntax
RMDIR dirname$, ok
Eingabe
dirname$ Variable mit dem Namen des zu loeschenden Verzeichnisses
Ausgabe
ok Variable mit dem Ergebnis der Aktion:
ok=1: Aktion war erfolgreich
ok=-1: Aktion war nicht erfolgreich
Beschreibung
Sie koennen hiermit aus KIM heraus ein Verzeichnis loeschen.
Bespiel RMDIR
Siehe
MKDIR
GETDIR
ΓòÉΓòÉΓòÉ 53. RUN ΓòÉΓòÉΓòÉ
Funktion
Startet aus einem Programm ein anderes KIM-Programm.
Syntax
RUN programm
Eingabe
programm Name des zu startenden Programms.
Ausgabe
Keine
Beschreibung
nil
Bespiel RUN
Siehe
ΓòÉΓòÉΓòÉ 54. SETDRIVE ΓòÉΓòÉΓòÉ
Funktion
Wechselt das aktuelle Laufwerk.
Syntax
SETDRIVE nr, anzahl
Eingabe
nr Variable mit der Codezahl des gewuenschten Laufwerkes
(1=A,2=B,3=C, usw.)
Ausgabe
anzahl Variable mit der Anzahl der zur Verfuegung stehenden Laufwerke
Beschreibung
keine
Bespiel SETDRIVE
Siehe
GETDRIVE
ΓòÉΓòÉΓòÉ 55. SHELL ΓòÉΓòÉΓòÉ
Funktion
Erlaubt die Ausfuehrung von OS/2 / DOS-Befehlen oder
OS/2 / DOS-Programmen waehrend eines KIM-Programmablaufs.
Syntax
SHELL string$ [Pfad, Parameter, x, y, breite, hoehe, visible, titel]
Eingabe
string$ Variable mit dem Namen des auszufuehrenden Befehls/Programms
Pfad Suchpfad zum gewuenschten Programm (z.B."CKIM")
Parameter Zusaetzliche Befehle in der Kommandozeile des Betriebssystems
(vgl. hierzu das Handbuch des Betriebssystem)
x,y x- und y-Position der linken oberen Ecke des Child-Windows
breite Breite des Child-Windows
hoehe Hoehe des Child-Windows
visible Regelt den Arbeitsmodus des externen Programms:
visible=1: Das externe Programm laeuft im Vordergrund
visible=0: Das externe Programm laeuft im Hintergrund
titel Titel des Child-Windows
Ausgabe
Keine
Beschreibung
Mit diesem Befehl wird der DOS-Interpreter COMMAND.COM geladen. Danach
ist das Programm in der Lage, jede beliebige DOS-Anweisung zu verstehen
und zu bearbeiten. Moechten Sie ein externes Program starten, so geben
sie die in eckigen Klammern gesetzten optionalen Angaben ein. Es oeffnet
sich dann ein Child-Window, in dem das externe Programm ablaeuft. Der
Modus (Vordergrund- oder Hintergrundbetrieb) wird ueber visible gesteuert.
Die Rueckkehr von der DOS-Ebene zum KIM-Programm erfolgt durch Eingabe
der Anweisung EXIT in der DOS-Ebene. Sie koennen den auf der DOS-Ebene
verfuegbaren Speicher von ca. 100 KB durch das sogenanuete Speicher-
swapping auf ca. 400 KB erhoehen. Dies wird durch die Anweisung
_SHELL_FLAG = 1 ausgefuehrt, welche Sie vor der eigentlichen SHELL-
Anweisung aktivieren muessen. Bei _SHELL_FLAG = 0 wird kein Swappvorgang
durchgefuehrt.
Bespiel SHELL
Siehe
RUN
ΓòÉΓòÉΓòÉ 56. SOUND ΓòÉΓòÉΓòÉ
Funktion
Steuert den internen Lautsprecher des Computers an.
Syntax
SOUND freq, dur
Eingabe
freq Frequenz des zu erzeugenden Tons in Hertz
dur Laenge des Tons in Millisekunden
Ausgabe
keine
Beschreibung
Mit diesem Befehl koennen Sie den Lautsprecher des Computers zur
Erzeugung eines Tones ansteuern. Dabei koennen Sie Tonhoehe und
-dauer festlegen.
Bespiel SOUND
Siehe
BEEP
ΓòÉΓòÉΓòÉ 57. START ΓòÉΓòÉΓòÉ
Funktion
Aktiviert den KIM-Debugger.
Syntax
START
Eingabe
Keine
Ausgabe
Keine
Beschreibung
Fuegen Sie diesen Befehl an der Stelle in Ihrem Programm ein, von der aus
Sie Ihr Programm ueberpruefen lassen wollen. Der Debugger wird durch den
Befehl ENDE wieder abgeschaltet.
Bespiel START
Siehe
ENDE
ΓòÉΓòÉΓòÉ 58. TIME ΓòÉΓòÉΓòÉ
Funktion
Ermittelt Tagesdatum und Uhrzeit aus dem ROM-BIOS des Rechners.
Syntax
TIME zeit$
Eingabe
Keine
Ausgabe
zeit$ Variable mit dem Aktuellen Datum und der aktuellen Uhrzeit
Beschreibung
Mit diesem Befehl koennen Sie das Tagesdatum und die aktuelle Uhrzeit in
das Programm einlesen. Sie erhalten folgende Anzeige: ttt mmm tt hh
Bespiel TIME
Siehe
DATUM
DATUMDIFF
ΓòÉΓòÉΓòÉ 59. DECLARE ΓòÉΓòÉΓòÉ
Funktion
Beschleunigt den Ladevorgang der Variablendeklarationen
beim Programmstart.
Syntax
DECLARE_END
Eingabe
Keine
Ausgabe
Keine
Beschreibung
Diese Anweisung beschleunigt den Ablauf eines Programms, da sie die
erforderliche Zeit zum Laden der deklarierten Variablen verkuerzt.
Dies gelingt durch ein teilweises Deaktivieren von Sicherheits-
ueberpruefungen beim Laden des Programmes. Der Befehl darf deshalb
nur verwendet werden, wenn sichergestellt ist, dass das Programm
keinerlei Fehler enthaelt, da sonst gleichnamig definierte Variablen
nicht mehr als Fehler erkannt werden koennen. Zwischen DECLARE und
DECLARE_END duerfen keine anderen Anweisungen als Variablen-
deklarationen stehen.
Bespiel DECLARE
Siehe
DEFINE
DEFSTRING
DEFFLOAT
DIM
DIMFLOAT
ΓòÉΓòÉΓòÉ 60. DECLARE_END ΓòÉΓòÉΓòÉ
Funktion
Markiert das Ende von DECLARE.
Syntax
DECLARE_END
Eingabe
Keine
Ausgabe
Keine
Beschreibung
Diese Anweisung beschleunigt den Ablauf eines Programms, da sie die
erforderliche Zeit zum Laden der deklarierten Variablen verkuerzt.
Dies gelingt durch ein teilweises Deaktivieren von Sicherheits-
ueberpruefungen beim Laden des Programmes. Der Befehl darf deshalb
nur verwendet werden, wenn sichergestellt ist, dass das Programm
keinerlei Fehler enthaelt, da sonst gleichnamig definierte Variablen
nicht mehr als Fehler erkannt werden koennen. Zwischen DECLARE und
DECLARE_END duerfen keine anderen Anweisungen als Variablen-
deklarationen stehen.
Bespiel DECLARE_END
Siehe
DEFINE
DEFSTRING
DEFFLOAT
DIM
DIMFLOAT
ΓòÉΓòÉΓòÉ 61. DEFFLOAT ΓòÉΓòÉΓòÉ
Funktion
Definiert eine oder mehrere Zahlenvariablen.
Syntax
DEFFLOAT var
Eingabe
var Name der zu definierenden Variablen (es koennen mehrere mit
einer Anweisung erstellt werden)
Ausgabe
Keine
Beschreibung
Die Variablennamen duerfen bis zu 32 Zeichen lang sein. Die verfuegbaren
Eingabezeichen fuer Zahlenvariablen reichen von -1 E38 bis 1 E 38 und
arbeiten auf zwoelf Stellen genau (es koennen somit alle rationalen
Zahlen als Variablenwerte verwendet werden). Es duerfen bis zu 255
Zeichen in eine Variable eingegeben werden. Beachten Sie bei der
Zahleneingabe bitte, dass Sie bei Dezimalzahlen statt eines Kommas
einen Punkt verwenden muessen (also nicht 3,28, sondern 3.28).
Bespiel DEFFLOAT
Siehe
DEFINE
DEFSTRING
DIM
DIMFLOAT
ΓòÉΓòÉΓòÉ 62. DEFINE ΓòÉΓòÉΓòÉ
Funktion
Definiert eine Feldvariable fuer eine Record-Struktur.
Syntax
DEFINE varname1,varlaenge1,...
Eingabe
varname1 Name der zu definierenden Feldvariablen mit Kennummer
varlaenge1 Laenge der entsprechenden zu definierenden Define-Variablen
Ausgabe
Keine
Beschreibung
Die erste definierte Variable muss die Kennziffer1 besitzen, z.B.
string1. Danach hat die Numerierung fortlaufend aufsteigend zu
erfolgen (2,3..). Der Variablenname darf maximal 32 Zeichen lang
sein. Der Inhalt einer Define-Variablen darf normalerweise bis zu
255 Zeichen betragen. Nur bei Datenbank- oder Maskenbefehlen aendert
sich die Variablenlaenge auf den unter varlaenge definierten Wert.
Bespiel DEFINE
Siehe
DEFFLOAT
DEFSTRING
DIM
DIMFLOAT
ΓòÉΓòÉΓòÉ 63. DEFSTRING ΓòÉΓòÉΓòÉ
Funktion
Definiert eine oder mehrere Stringvariablen.
Syntax
DEFSTRING var1$,..
Eingabe
var1$ Name der zu definierenden Stringvariablen (es koennen
mehrere mit einer Anweisung definiert werden)
Ausgabe
Keine
Beschreibung
Die Variablennamen duerfen maximal 32 Zeichen lang sein. Der Inhalt
einer Stringvariablen kann bis zu 255 Zeichen betragen und muss mit
Anfuehrungs- und Schlusszeichen " " begrenzt werden. Als Eingabe sind
alle alphanumerischen Zeichen ausser Anfuehrungs- und Schlusszeichen
erlaubt.
Bespiel DEFSTRING
Siehe
DEFFLOAT
DEFINE
DIM
DIMFLOAT
ΓòÉΓòÉΓòÉ 64. DIM ΓòÉΓòÉΓòÉ
Funktion
Definiert mehrere Stringvariablen in Form eines Arrays.
Syntax
DIM s$,n,m
Eingabe
s$ Name des zu erstellenden String-Arrays
n Nummer des ersten Strings im Feld
m Nummer des letzten Strings im Feld
Ausgabe
Keine
Beschreibung
Jeder Variablenname darf bis zu 32 Zeichen lang sein. Der Inhalt der
Variablen darf jeweils maximal 255 Zeichen betragen (wie bei normalen
Stringvariablen). Sie koennen jede Variable des Arrays sowohl direkt
ueber den vollstaendigen Namen (st1) als auch nur ueber ihre Nummer an-
sprechen.
Bespiel DIM
Siehe
DEFFLOAT
DEFINE
DEFSTRING
DIMFLOAT
FORM
STR
VAL
ΓòÉΓòÉΓòÉ 65. DIMFLOAT ΓòÉΓòÉΓòÉ
Funktion
Definiert mehrere Zahlenvariablen in Form eines Arrays.
Syntax
DIMFLOAT zahl,n,m
Eingabe
zahl Name des zu erstellenden Zahlenvariablen-Arrays
n Nummer der ersten Variablen im Feld
m Nummer der letzten Variablen im Feld
Ausgabe
Keine
Beschreibung
Jeder Variablenname darf bis zu 32 Zeichen lang sein. Der Inhalt der
Variablen darf maximal 255 Zeichen betragen. Sie koennen jede Variable
des Array sowohl direkt ueber den vollstaendigen Namen(st1) als auch nur
ueber ihre Nummer ansprechen.
Bespiel DIMFLOAT
Siehe
DEFFLOAT
DEFINE
DEFSTRING
DIM
FORM
STR
VAL
ΓòÉΓòÉΓòÉ 66. DIMMEMO ΓòÉΓòÉΓòÉ
Funktion
Es wird eine Stringvariable definiert, die bis zu
64000 Zeichen Inhalt besitzen darf.
Syntax
DIMMEMO varname,laenge
Eingabe
varname Name der Variablen
laenge Gewuenschter maximaler Inhalt der Variablen
Ausgabe
Beschreibung
Memovariablen muessen immer als globale Variablen definiert werden!
Bei der Definition muss deshalb entweder vor dem Variablennamen ein
Underslash gesetzt oder dem Namen der Variablen als letztes Zeichen
eine Zahl eingefuegt werden.
Bespiel DIMMEMO
Siehe
DEFSTRING
DEFINE
ΓòÉΓòÉΓòÉ 67. ASC ΓòÉΓòÉΓòÉ
Funktion
Wandelt einen Buchstaben in seinen entsprechenden ASCII-Wert um.
Syntax
ASC zeichen,zahl
Eingabe
zeichen String mit einem Zeichen
Ausgabe
zahl Zahlenvarible die den ASCII-Wert des Zeichen als Inhalt zuge-
wiesen bekommt.
Beschreibung
keine
Bespiel ASC
Siehe
CHR
PUTS
STRADD
ΓòÉΓòÉΓòÉ 68. CHANGE ΓòÉΓòÉΓòÉ
Funktion
Tauscht zwei Zeichen innerhalb einer Stringvariablen gegeneinander aus.
Syntax
CHANGE string$,alt,neu
Eingabe
string$ Stringvariable, in der der Austausch erfolgt
alt Altes Zeichen (ASCII-Code angeben)
neu Neues Zeichen (ASCII-Code angeben)
Ausgabe
string$ (in geaenderter Form)
Beschreibung
Es wird das angegebene Zeichen gegen das vorgegebene neue Zeichen aus-
getauscht. Das angegebene Zeichen wird so oft ausgetauscht, wie es in
der Stringvariable vorhanden ist.
Bespiel CHANGE
Siehe
IN
LEN
STRDEL
REPLACE
ΓòÉΓòÉΓòÉ 69. CHR ΓòÉΓòÉΓòÉ
Funktion
Wandelt einen ASCII-Codewert in ein entsprechendes Zeichen um.
Dieser Befehl wird bei der Druckersteuerung dazu verwendet, um
bestimmte Druckvorgaenge ueber spezielle Codezeichen vom Programm
aus zu initiieren.
Syntax
CHR(zahl)
Eingabe
zahl Es muss eine ganze Zahl eingegeben werden, ASCII-Codewert
fuer ein bestimmtes Zeichen fungiert (vgl. ASCII-Tabelle
im Anhang).
Ausgabe
Keine
Beschreibung
Als Wert fuer die Variable zahl darf nur eine ganze Zahl zwischen
0 und 255 eingegeben werden (nur diese Zahlen codieren ASCII-Zeichen).
Der Befehl funktioniert nur im Zusammenhang mit den Anweisungen LPRINT
und PUTS.
Bespiel CHR
Siehe
LPRINT
PUTS
ΓòÉΓòÉΓòÉ 70. CLEAR ΓòÉΓòÉΓòÉ
Funktion
Loescht den Inhalt eines Arrays.
Syntax
CLEAR var$,start,ende
Eingabe
var$ Name des zu loeschenden Arrays
start Nummer der ersten zu loeschenden Variablen im Array
ende Nummer der letzten zu Loeschenden Variablen im Array
Ausgabe
var$ Alle Variablen des Arrays mit Kennummern zwischen start
und ende
werden mit neuem Inhalt an das Programm zurueckgegeben.
Beschreibung
Mit diesem Befehl koennen schnell und unkompliziert Teile eines Arrays
oder das gesamte Array geloescht werden. Die Variablen haben dann den
Wert " " (Leerstring). Fuer einzelne, nicht in einem Array zusammenge-
fasste Variablen ist der Befehl nicht gedacht. Diese koennen ja einfach
durch die Zuweisung st=" " geleert werden.
Bespiel CLEAR
Siehe
COMPRESS
COMPRESS2
LTRIM
SET
RSET
ΓòÉΓòÉΓòÉ 71. COMPRESS ΓòÉΓòÉΓòÉ
Funktion
Entfernt Leerzeichen am Ende eines Strings. Dies ist wuenschenswert,
wenn einer Variablen ueber eine Maske ein Wert eingegeben wurde, der
kleiner als die Laenge des Eingabefeldes ist, da dabei automatisch
Leerzeichen angefuegt werden.
Syntax
COMPRESS string$
Eingabe
string$ Zu bearbeitende Stringvariable
Ausgabe
string$ Geaenderte Stringvariable
Beschreibung
Arrays werden besser mit der Anweisung COMPRESS2 bearbeitet.
Bespiel COMPRESS
Siehe
COMPRESS2
LEN
MID
SET
RSET
ΓòÉΓòÉΓòÉ 72. COMPRESS2 ΓòÉΓòÉΓòÉ
Funktion
Entfernt Leerzeichen am Ende von Strings in Arrays.
Syntax
COMPRESS2 array$,start,ende
Eingabe
array$ Name des Arrays
start Nummer der ersten zu behandelnden Variablen im Array
ende Nummer der letzten zu behandelnden Variablen im Array
Ausgabe
array$ Veraendertes Array
Beschreibung
Diese ist eine Version von COMPRESS zur schnellen Bearbeitung
von Arrays.
Bespiel COMPRESS2
Siehe
COMPRESS
LEN
MID
SET
RSET
ΓòÉΓòÉΓòÉ 73. FILLSTR ΓòÉΓòÉΓòÉ
Funktion
Fuellt eine Stringvariable mit einem bestimmten Zeichen.
Syntax
FILLSTR anzahl,var$,zeichen$
Eingabe
anzahl Anzahl der einzufuellenden Zeichen
var$ Aufzufuellende Variable
zeichen$ Fuellzeichen (maximal 1 Zeichen)
Ausgabe
var$ Gefuellte Variable
Beschreibung
Es wird ein Zeichen beliebig oft in die Variable geschrieben. Die
durch diese Anweisung gefuellte Variable darf aber danach nur maximal
255 Zeichen Inhalt besitzen.
Bespiel FILLSTR
Siehe
CHANGE
REPLACE
ΓòÉΓòÉΓòÉ 74. FIND ΓòÉΓòÉΓòÉ
Funktion
Durchsucht einen Array-Bereich nach einem Begriff.
Syntax
FIND array$,start,ende,such$,erg
Eingabe
array$ Name des zu durchsuchenden Arrays
start Variable, ab der die Suche durchgefuehrt werden soll.
ende Variable, bis zu der die Suche durchgefuehrt werden soll.
such$ Als Inhalt einer Stringvariablen vorgegebener Suchbegriff
Ausgabe
erg Variable mit der Position des Suchbegriffs im Array als
Inhalt
Beschreibung
Mit dem Befehl koennen Sie ein Array nach einem eindeutigen Suchbegriff
durchsuchen. Den Suchbegriff muessen Sie in Form einer Stringvariablen
vorgeben. Das Ergebnis wird in der Zahlenvariablen erg abgespeichert.
Falls der Rechner bei der Suche keinen Erfolg hat, bekommt die Variable
erg den Wert Null zugewiesen.
Bespiel FIND
Siehe
IN
ΓòÉΓòÉΓòÉ 75. FORM ΓòÉΓòÉΓòÉ
Funktion
Wandelt eine Zahlenvariable in eine Stringvariable um, wobei eine
bestimmte Anzahl von Nachkommastellen in der Stringvariablen fest-
gelegt werden kann, oder formatiert eine bestehende Stringvariable
in Bezug auf die Nachkommastellen.
Syntax
FORM zahl,string$,komma,zeichenzahl
Eingabe
zahl Die zu konvertierende Zahlenvariable
komma Anzahl der Nachkommastellen in der neuen Stringvariablen
zeichenzahl Gesamtzahl der Zeichen in der neuen Stringvariable
Ausgabe
string$ Die Stringvariable mit dem neuen Inhalt
Beschreibung
Die Zeichen aus der Zahlenvariablen werden in der Stringvariable
rechtsbuendig ausgerichtet und noetigenfalls mit Leerzeichen von
links her aufgefuellt (Beispiel: Die Umwandlung der Zahl 10.80 in
einen String mit einer Gesamtzeichenzahl von 7 fuehrt dazu, dass die
neue Stringvariable den Inhalt "00010.80" erhaelt). Es erfolgt auto-
matisch eine Rundung auf die angegebene Zahl von Nachkommastellen.
Beachten Sie bitte, dass mit diesem Befehl nur Zahlen mit maximal acht
Vorkommastellen und zehn Nachkommastellen formatiert werden koennen.
Bespiel FORM
Siehe
VAL
STR
ΓòÉΓòÉΓòÉ 76. FRAC ΓòÉΓòÉΓòÉ
Funktion
Zerlegt eine Zahl in Vor- und Nachkommastellen.
Syntax
FRAC zahl,vor,nach
Eingabe
zahl Variable mit der zu bearbeitenden Zahl
Ausgabe
vor Variable mit den Vorkommastellen als Inhalt
nach Variable mit den Nachkommastellen als Inhalt
Beschreibung
Diese Anweisung zerlegt eine beliebige Zahl in Vor- und
Nachkommastellen. Diese Werte werden getrennt und verschiedenen
Variablen zugewiesen.
Bespiel FRAC
Siehe
ΓòÉΓòÉΓòÉ 77. GANZ ΓòÉΓòÉΓòÉ
Funktion
Wandel eine numerische Zahl in einen Integer-Wert
Syntax
GANZ, alt neu
Eingabe
alt Numerische Zahl
Ausgabe
neu Ganze Zahl ohne Kommastellen
Beschreibung
Wird benФtigt um eine Zahlenvariable in ein ganze Zahl
umzuwandeln
Bespiel GANZ
Siehe
ΓòÉΓòÉΓòÉ 78. GLOBALREAD ΓòÉΓòÉΓòÉ
Funktion
Programm Бbergreifende Variablenverwaltung
Syntax
GLOBALREAD zahl (string)
Eingabe
Ausgabe
Beschreibung
keine
Bespiel GLOBALREAD
Siehe
RUN
ΓòÉΓòÉΓòÉ 79. GLOBALWRITE ΓòÉΓòÉΓòÉ
Funktion
Programm Бbergreifende Variablenverwaltung
Syntax
GLOBALWRITE zahl (string)
Eingabe
Ausgabe
Beschreibung
keine
Bespiel GLOBALWRITE
Siehe
GLOBALREAD
ΓòÉΓòÉΓòÉ 80. IGETREC_ARRAY ΓòÉΓòÉΓòÉ
Funktion
Mehrere Datensaetze werden in ein Array eingelesen.
Syntax
IGETREC_ARRAY nr,flag,trenn$,dbstruct$,array$,start,ende,feldnr1,...
Eingabe
nr Nummer der entsprechenden Datenbank
flag Arbeitsmodus des Befehls:
flag = 0: Es werden die Datensaetze vom aktuellen Datensatz aus
eingelesen, die auf den aktuellen Datensatz folgen.
flag = 1: Es werden die Datensaetze vom aktuellen Datensatz aus
eingelesen, die vor dem aktuellen Datensatz stehen.
trenn$ Trennzeichen fuer einzelne Felder innerhalb eines Datensatzes
dbstruct$ Recordstruktur der DB
array$ Array, in die die Datenbanksaetze eingelesen werden sollen
start erste zu fuellende Variable im Array
ende letzte zu fuellende Variable im Array
feldnrx Felder, die mit Trennzeichen <trenn> in das Array
geschrieben werden.
Ausgabe
Beschreibung
Es koennen mehrere Datensaetze schnell eingelesen werden. Dieser Befehl
wurde fuer Ausgabelisten geschaffen.
Bespiel IGETREC_ARRAY
Siehe
IGETREC
ΓòÉΓòÉΓòÉ 81. IN ΓòÉΓòÉΓòÉ
Funktion
Ermittelt, ob ein Zeichen bzw. eine Zeichenkette in einer
Stringvariablen vorhanden ist. Das Ergebnis wird als Zahl
verfuegbar.
Syntax
IN string$,suchstring$,gefunden
Eingabe
string Stringvariable, in der nach dem Zeichen gesucht wird
suchstring$ Stringvariable, in der das zu suchende Zeichen vorge-
geben ist.
Ausgabe
gefunden Zahlenvariable, in der das Ergebnis der Suche vermerkt
wird.
Beschreibung
Wurde das gesuchte Zeichen gefunden, so wird ueber die Variable
gefunden die Position des Zeichens im String an das Programm
zurueckgegeben. Wurde das Zeichen nicht gefunden, erhaelt die
Variable gefunden den Wert -1.
Bespiel IN
Siehe
CHANGE
LEN
STRDEL
ΓòÉΓòÉΓòÉ 82. INT ΓòÉΓòÉΓòÉ
Funktion
Wandelt eine Dezimalzahl in eine ganze Zahl um.
Syntax
INT zahl,erg
Eingabe
zahl Umzuwandelnde Zahlenvariable
Ausgabe
erg Umgewandelte Zahlenvariable
Beschreibung
Dieser Befehl wandelt eine Dezimalzahl in eine ganze Zahl um, indem er
die Nachkommastellen entfernt. Es wird hierbei keine Rundung durchge-
fuehrt.
Bespiel INT
Siehe
FORM
FRAC
VAL
ΓòÉΓòÉΓòÉ 83. LCASE ΓòÉΓòÉΓòÉ
Funktion
Verwandelt Grossbuchstaben einer Stringvariablen in Kleinbuchstaben.
Syntax
LCASE string$
Eingabe
string$ Zu veraendernde Stringvariable
Ausgabe
string$ Veraenderte Stringvariable mit Kleinbuchstaben als Inhalt
Beschreibung
Mit diesem Befehl werden in einem Schritt alle Grossbuchstaben einer
Stringvariable in Kleinbuchstaben umgewandelt. Auf Zahlenvariablen ist
diese Anweisung natnrlich nicht anwendbar.
Bespiel LCASE
Siehe
IN
UCASE
ΓòÉΓòÉΓòÉ 84. LEN ΓòÉΓòÉΓòÉ
Funktion
Ermittelt die Laenge des Inhalts einer Stringvariablen.
Syntax
LEN string$,zahl
Eingabe
string$ Zu pruefende Stringvariable
Ausgabe
zahl Variable, an die die ermittelte Stringlaenge zurueck-
gegeben wird
Beschreibung
Es kann nur die Laenge von Stringvariablen geprueft werden, nicht aber
die Laenge von Zahlenvariablen. Leer- und Satzzeichen werden bei der
Laengenermittlung mitgezaehlt.
Bespiel LEN
Siehe
STRDEL
ΓòÉΓòÉΓòÉ 85. LOADARRAY ΓòÉΓòÉΓòÉ
Funktion
Liest eine Textdatei in ein definiertes Feld.
Syntax
LOADARRAY datei, feld, start,ende, anzahl
Eingabe
datei Dateiname
feld Name des Arrays, in das die Datei geladen wird.
start Erstes Feld, in das die Datei geladen wird.
ende Letztes Feld, in das die Datei geladen wird.
Ausgabe
anzahl Anzahl der eingelesenen Zeilen.
Beschreibung
Falls die Anzahl der einzulesenden Zeilen grФсer wДre als das Array,
dann werden nur soviele Zeilen eingelesen, wie das Array aufnehmen
kann.
Bespiel LOADARRAY
Siehe
SAVEARRAY
OPEN
CLOSE
GETS_SELECT
SELECT
ΓòÉΓòÉΓòÉ 86. LOADMEMO ΓòÉΓòÉΓòÉ
Funktion
Laedt den Inhalt einer Datei in eine Memovariable.
Syntax
LOADMEMO datei, memovariable, ok
Eingabe
datei Datei mit zu ladendem Inhalt
memovriable Memovariable, in die der Dateiinhalt eingefuegt
werden soll
Ausgabe
memovariable Memovariable mit neuem Inhalt
ok Variable mit dem Ergebnis der Operation:
ok=1: Dateiinhalt wurde geladen
ok=-1: Dateiinhalt konnte nicht geladen werden
Beschreibung
keine
Bespiel LOADMEMO
Siehe
SAVEMEMO
ΓòÉΓòÉΓòÉ 87. LTRIM ΓòÉΓòÉΓòÉ
Funktion
Entfernt linksbuendige Leerzeichen aus einer Stringvariablen.
Syntax
LTRIM string$
Eingabe
string$ Zu veraendernde Variable
Ausgabe
string$ Veraenderte Variable
Beschreibung
Nur Stringvariablen koennen auf diese Weise formatiert werden,
nicht jedoch Zahlenvariablen.
Bespiel LTRIM
Siehe
COMPRESS
COMPRESS2
SET
RSET
ΓòÉΓòÉΓòÉ 88. MID ΓòÉΓòÉΓòÉ
Funktion
Kopiert einen Teil einer Stringvariable in eine andere Stringvariable.
Syntax
MID string$,neu$,anfang,anzahl
Eingabe
string$ Zu kopierender String
anfang Position im String, ab der kopiert werden soll
anzahl Anzahl der zu kopierenden Zeichen
Ausgabe
neu$ String, in den der Inhalt kopiert wird
Beschreibung
Es kann nur der Inhalt von Stringvariablen kopiert werden, nicht
jedoch der von Zahlenvariablen.
Bespiel MID
Siehe
CHANGE
IN
LEN
STRDEL
ΓòÉΓòÉΓòÉ 89. REPLACE ΓòÉΓòÉΓòÉ
Funktion
Tauscht Teile des Inhalts einer Stringvariablen.
Syntax
REPLACE text$, alt$, neu$
Eingabe
text$ Name der Stringvariablen, deren Inhalt veraendert werden soll.
alt$ Zeichenkette aus text$, die ausgetauscht werden soll
neu$ Zeichenkette, die anstelle von alt$ in text$ eingefuegt
werden soll
Ausgabe
text$ Stringvariable mit neuem Inhalt
Beschreibung
Mit dieser Funktion koennen Sie Teile oder den gesamten Inhalt einer
Stringvariable austauschen. Geben Sie dazu in der Variablen alt$ den
Teil des Inhalts der zu veraendernden Variablen text$ vor, der ausge-
tauscht werden soll. Diese Zeichen werden dann gegen den Inhalt der
Variablen neu$ getauscht.
Bespiel REPLACE
Siehe
CHANGE
ΓòÉΓòÉΓòÉ 90. REVERSE ΓòÉΓòÉΓòÉ
Funktion
Dreht den Inhalt einer Variablen
Syntax
REVERSE eingabe, ausgabe
Eingabe
eingabe Variable deren Inhalt gedreht werden soll.
Ausgabe
ausgabe Variable mit neuem Inhalt
Beschreibung
keine
Bespiel REVERSE
Siehe
ΓòÉΓòÉΓòÉ 91. RSET ΓòÉΓòÉΓòÉ
Funktion
Formatiert den Inhalt einer Stringvariablen rechtsbuendig.
Syntax
RSET laenge,string$
Eingabe
laenge Laenge der Stringvariablen nach der Modifikation
string$ Eingabestringvariable
Ausgabe
string$ Formatierte Stringvariable
Beschreibung
Mit diesem Befehl wird der Inhalt einer Stringvariablen rechtsbuendig
mit Leerzeichen aufgefuellt (d.h. links vom urspruenglichen Inhalt
werden entsprechend viele Leerzeichen angefuegt). Die Laenge des
formatierten Strings richtet sich nach dem Wert in der Variablen
laenge. Ist der Inhalt der urspruenglichen Stringvariable kleiner
oder gleich der so festgelegten Laenge fuer die auszugebende String-
variable, so wird keine Formatierung durchgefuehrt.
Bespiel RSET
Siehe
SET
COMPRESS
COMPRESS2
LTRIM
ΓòÉΓòÉΓòÉ 92. SAVEARRAY ΓòÉΓòÉΓòÉ
Funktion
Speichert den Inhalt eines Array in eine Datei.
Syntax
SAVEARRAY datei, feld, start,ende
Eingabe
datei Dateiname
feld Name des zu speichernden Feldes
start Erstes Feld, das gespeichert wird.
ende Letztes Feld, das gespeichert wird.
Ausgabe
keine
Beschreibung
nil
Bespiel SAVEARRAY
Siehe
LOADARRAY
OPEN
CLOSE
GETS_SELECT
SELECT
ΓòÉΓòÉΓòÉ 93. SAVEMEMO ΓòÉΓòÉΓòÉ
Funktion
Speichert den Inhalt einer Memovariablen wird in eine Datei gespeichert.
Syntax
SAVEMEMO datei, memovariable, ok
Eingabe
datei Datei, in welcher der Variableninhalt gespeichert
werden soll.
memovariable Zu speichernde Memovariable
Ausgabe
ok Variable mit dem Ergebnis des Vorgangs:
ok=1: Variableninhalt konnte gespeichert werden
ok=-1: Variableninhalt konnte nicht gespeichert werden
Beschreibung
Mit dieser Anweisung kann der Inhalt einer Variablen in eine Datei
uebergeben werden. Somit entspricht dieser innerhalb eines Programmes
vorgenommene Vorgang dem Speichern des Variableninhalts auf Diskette
oder Festplatte.
Dieser Befehl kann auch zum Ausdruck von Daten herangezogen werden.
Wird anstelle eines Dateinamens der Ausdruck "LPT1" (fuer Linear Port 1,
dem ueblichen Druckerkanal) eingesetzt, so wird der Inhalt der
Memovariablen direkt zum Drucker umgeleitet und dort ausgegeben.
Bespiel SAVEMEMO
Siehe
LOADMEMO
ΓòÉΓòÉΓòÉ 94. SELECT ΓòÉΓòÉΓòÉ
Funktion
Zerlegt eine Stringvariable in Teilvariablen bezueglich zu einem
beliebigen Trennzeichen.
Syntax
SELECT ganz$,ord,s$,n,m
Eingabe
ganz$ Zu zerlegende Stringvariable
ord ASCII-Codewert des Trennzeichens, an welchem der Inhalt
geteilt wird
s$ Name der Teilvariablen (Array)
n Erste Teilvariable im Array, in die ein Teil des Inhalts
geschrieben wird
m Letzte Teilvariable im Array, in die ein Teil des Inhalts
geschrieben wird.
Ausgabe
sn,...,sm Teilvariablen
Beschreibung
SELECT teilt den Inhalt einer Stringvariablen auf verschiedene
Teilvariablen auf. Bei der Teilung richtet sich der Befehl nach
einem von Ihnen vorgegebenen Trennzeichen. Haben Sie mehr Teil-
variablen definiert als durch den Vorgang mit Inhalt gefuellt werden
koennen, so bleiben die ueberzaehligen Teilvariablen leer.
Bespiel SELECT
Siehe
CLEAR
IN
MID
LEN
ΓòÉΓòÉΓòÉ 95. SET ΓòÉΓòÉΓòÉ
Funktion
Formatiert eine Stringvariable durch Anfuegen von Leerzeichen.
Syntax
SET anzahl,string$
Eingabe
anzahl Gewuenschte Laenge der formatierten Variablen
string$ Name der zu formatierenden Variablen
Ausgabe
string$ Formatierte Variable
Beschreibung
Es wird an den Inhalt einer Stringvariablen die notwendige Anzahl von
Leerstellen angefuegt, um auf die in anzahl vorgegebene Variablenlaenge
zu kommen (linksbuendige Formatierung im Gegensatz zur rechtsbuendigen
Formatierung mit RSET). Ist dieser Wert kleiner als die ursprnuegliche
Laenge der Stringvariablen, so wird der Befehl nicht ausgefuehrt. Die
Anweisung dient u.a. zur buendigen Anordnung von Variablen in Tabellen.
Bespiel SET
Siehe
COMPRESS
MID
LEN
LPRINT
RSET
ΓòÉΓòÉΓòÉ 96. STR ΓòÉΓòÉΓòÉ
Funktion
Wandelt eine Zahlenvariable in eine Stringvariable um.
Syntax
STR string$,zahl,stellen
Eingabe
zahl Name der umzuwandelnden Zahlenvariablen
stellen Laenge des Inhalts der zu erstellenden Stringvariablen
Ausgabe
string$ Name der zu erstellenden Stringvariablen
Beschreibung
Mit diesem Befehl wandeln Sie den Inhalt einer Zahlenvariablen in den
Inhalt einer Stringvariablen um. Dabei koennen Sie die Laenge der zu er-
stellenden Stringvariablen festlegen und auf diese Weise zusaetzliche
Leerzeichen von links her einfuegen oder abtrennen. Im Gegensatz zu FORM
koennen Sie aber keinen Einfluss auf die Zahl der Nachkommastellen nehmen.
Bespiel STR
Siehe
FORM
VAL
ΓòÉΓòÉΓòÉ 97. STRADD ΓòÉΓòÉΓòÉ
Funktion
Verknuepft Textstuecke bzw. den Inhalt von Stringvariablen.
Syntax
STRADD string1$,"Text",string2$,chr(12),...
Eingabe
string1$,... Namen der zu verknuepfenden Stringvariablen
text,... Zu verknuepfender Text
Ausgabe
string$ Name der Stringvariablen mit verknuepftem Inhalt
Beschreibung
Sie koennen beliebig viele Textstuecke bzw. den Inhalt beliebig vieler
Stringvariablen miteinander verknuepfen. Beachten Sie aber bitte, dass
der Inhalt der durch die Verknuepfung erzeugten Variable maximal 255
Zeichen betragen darf. Es koennen auch einzelne Steuerzeichen mit chr()
angefuegt werden.
Bespiel STRADD
Siehe
LEN
MID
STRDEL
ΓòÉΓòÉΓòÉ 98. STRDEL ΓòÉΓòÉΓòÉ
Funktion
Loescht Teile einer Stringvariablen ab einer beliebigen Stelle.
Syntax
STRDEL string$,anfang,laenge
Eingabe
string$ Name der zu bearbeitenden Stringvariablen
anfang Position, ab der geloescht werden soll
laenge Laenge des zu loeschenden Teils der Variablen
Ausgabe
string$ Name der Stringvariablen mit gekuerztem Inhalt
Beschreibung
Sie sind hiermit in der Lage, beliebig grosse Teile des Inhalts einer
Stringvariablen von einer beliebigen Position ab zu loeschen.
Bespiel STRDEL
Siehe
CHANGE
IN
LEN
STRADD
ΓòÉΓòÉΓòÉ 99. UCASE ΓòÉΓòÉΓòÉ
Funktion
Verwandelt alle Kleinbuchstaben einer Stringvariablen in Grossbuchstaben.
Syntax
UCASE string$
Eingabe
string$ Umzu_ndernde Stringvariable
Ausgabe
string$ Umgewandelte Stringvariable
Beschreibung
Diese Anweisung dient zur Editierung des Inhalts von Stringvariablen.
Es werden alle Kleinbuchstaben in Grossbuchstaben umgewandelt.
Bespiel UCASE
Siehe
IN
LCASE
ΓòÉΓòÉΓòÉ 100. VAL ΓòÉΓòÉΓòÉ
Funktion
Verwandelt eine Stringvariable in eine Zahlenvariable.
Syntax
VAL string$,zahl
Eingabe
string$ Umzuwandelnde Stringvariable
Ausgabe
zahl Neu erstellte Zahlenvariable
Beschreibung
Sie koennen hiermit Stringvariablen in Zahlenvariablen umwandeln,
aber nur, wenn der Inhalt der Stringvariablen eindeutig einer Zahl
zugeordnet werden kann (also bereits eine Zahl ist). Ist der Inhalt
des Strings z.B. "Hallo", so kann das Programm diesem keine Zahl
zuordnen. Der Zahlenvariablen wird dann der Wert 0 uebergeben.
Bespiel VAL
Siehe
FORM
STR
ΓòÉΓòÉΓòÉ 101. VARNR ΓòÉΓòÉΓòÉ
Funktion
Ermittelt die Interne Variblennr jeder Variable.
Syntax
VARNR variable, zahl
Eingabe
variable Variable deren Nr. ermittelt werden soll.
Ausgabe
zahl Nr. der Variable
Beschreibung
keine
Bespiel VARNR
Siehe
ΓòÉΓòÉΓòÉ 102. CALL ΓòÉΓòÉΓòÉ
Funktion
Aktiviert ein zuvor definiertes Modul.
Syntax
CALL name (varein,varaus)
Eingabe
name Name des zu aktivierenden Moduls
varein Name der Eingabevariablen
varaus Name der Ausgabevariablen
Ausgabe
varaus Ausgabevariable
Beschreibung
Mit diesem Befehl aktivieren Sie ein zuvor mit MODUL erstelltes Modul.
Da Module mit lokalen Variablen arbeiten, muessen Sie eine lokale Ein-
gabevariable definieren, in die mit CALL ein externer Wert uebergeben
wird. Das Programm arbeitet intern mit diesem Wert und gibt ihn dann
gegebenenfalls an eine externe Ausgabevariable zurueck. Sie muessen
gleichfalls die Art dieser Variablen festlegen. Einer Stringvariablen
muessen Sie das Kuerzel CHAR voranstellen, einer Zahlenvariablen ein
FLOAT.
Nach Abarbeitung des Moduls wird mit dem nach CALL folgenden Befehl
fortgefahren.
Bespiel CALL
Siehe
ΓòÉΓòÉΓòÉ 103. ENDIF ΓòÉΓòÉΓòÉ
Funktion
Beendet eine Programmverzweigung ueber eine IF-Anweisung.
Syntax
ENDIF
Eingabe
Keine
Ausgabe
Keine
Beschreibung
Jede IF-Anweisung in Ihrem Programm muss mit dem Befehl ENDIF beendet
werden, sonst kommt es zu Fehlfunktionen.
Bespiel ENDIF
Siehe
ΓòÉΓòÉΓòÉ 104. FOR..TO..NEXT ΓòÉΓòÉΓòÉ
Funktion
Schleife mit einer von vornherein durch einen Endwert festgelegten
Zahl von Durchlaeufen.
Syntax
NEXT
Eingabe
x Laufvariable
y Wert fuer x, ab der die Schleife durchlaufen wird
(Anfangsbedingung)
z Wert fuer x, bei der die Schleife zum letzten Mal
durchlaufen wird (x=z+1 ist die Abbruchsbedingung)
Ausgabe
Keine
Beschreibung
Die Anweisungen zwischen FOR..TO und NEXT werden z-y-mal durchgefuehrt.
Bei jedem Durchlaufen der Schleife wird der Wert der Laufvariablen x
um Eins erhoeht. Sobald x den Wert z+1 erreicht hat, wird die Schleife
abgebrochen (bei x=z erfolgt der letzte Schleifendurchlauf). Vor der
Schleife muessen Sie x den Startwert y zuweisen. Sollte x bereits zu
Beginn den Wert z+1 besitzen, wird die Schleife ueberhaupt nicht
durchlaufen.
Bespiel .TO..NEXT reftype=fn. FOR..TO..NEXT
Siehe
WHILE__WEND
ΓòÉΓòÉΓòÉ 105. GOSUB ΓòÉΓòÉΓòÉ
Funktion
Veranlasst einen Sprung in ein Unterprogramm.
Syntax
GOSUB #label
Eingabe
#label Sprungmarkierung am Anfang des Unterprogramms
Ausgabe
Keine
Beschreibung
Mit GOSUB wird ein Unterprogramm aufgerufen, das sich an der Position
der Sprungmarke #label befindet. Zwischen dem Labelzeichen # und dem
Labelnamen darf kein Leerzeichen sein. In einem Programm darf kein
Labelname zweimal verwendet werden. Ein so angesprungenes Unterprogramm
wird mit dem Befehl RETURN abgeschlossen, der gewaehrleistet, dass das
Programm zu seinem Absprungort zurueckkehrt. Oft ist es sinnvoll, Unter-
programme in INCLUDE-Dateien auszulagern, um eine ungewollte Akti-
vierung zu vermeiden.
Bespiel GOSUB
Siehe
GOTO
ΓòÉΓòÉΓòÉ 106. GOTO ΓòÉΓòÉΓòÉ
Funktion
Unbedingter Sprung zu einem Label.
Syntax
GOTO #Label
Eingabe
#Label Sprungmarke
Ausgabe
Keine
Beschreibung
Es gelten prinzipiell die gleichen Regeln wie bei der Anweisung GOSUB.
Allerdings veranlasst GOTO einen unbedingten Sprung zu einem anderen
Programmteil, d.h. es ist keine Rueckkehr zum Ausgangsort ueber ein
RETURN moeglich. Es wird kein Unterprogramm aktiviert.
Bespiel GOTO
Siehe
GOSUB
ΓòÉΓòÉΓòÉ 107. IF..THEN..ELSE..ENDIF ΓòÉΓòÉΓòÉ
Funktion
Steuert ueber einen Vergleich die Ausfuehrung bestimmter Befehle
(Verzweigung).
Syntax
ENDIF
Eingabe
[Vergleich] Ergebnis des Vergleichs einer Variablen mit einem
bestimmten Vorgabewert.
[Anweisungsblock] Alle Befehle, die zwischen THEN und ENDIF
ausgefuehrt werden sollen.
Ausgabe
Keine
Beschreibung
Liefert der Vergleich ein wahres Ergebnis, werden alle Befehle zwischen
THEN und ENDIF ausgefuehrt. Ist das Ergebnis eine Falschaussage, so wird
als naechster Befehl die Anweisung nach dem ENDIF ausgefuehrt, oder,
falls eine ELSE-Anweisung vorhanden ist, der Anweisungsblock nach dem
ELSE. Beachten Sie bitte, die Anweisung mit ENDIF zu beenden. Es koennen
mehrere Vergleiche mit Hilfe der logischen Operatoren AND oder OR ver-
knuepft werden.
Bespiel .THEN..ELSE..ENDIF reftype=fn. IF..THEN..ELSE..ENDIF
Siehe
WHILE__WEND
ΓòÉΓòÉΓòÉ 108. MODUL..ENDMOD ΓòÉΓòÉΓòÉ
Funktion
Definiert ein Modul.
Syntax
MODUL name (char/float varein, char/float varaus)
Eingabe
name Name des zu definierenden Moduls
char/float Art der Variable (char: String, float: Zahlenvariable)
varein Name der Eingabevariablen (oder Platzhalter
varaus Name der Ausgabevariablen (oder Platzhalter
Ausgabe
varaus Ausgabevariable
Beschreibung
Module sind kleine abgekapselte Programme, die intern beliebige
Anweisungen durchfuehren und das Ergebnis an das Hauptprogramm
zurueckgeben. Sie eignen sich daher zur Erstellung eigener
High-Level-Befehle. Module arbeiten mit lokalen Variablen, welche
nur im Bereich des Moduls Gueltigkeit besitzen, wenn Sie im Modul
definiert wurden. Es muessen daher Werte von externen, im gesamten
Programm gueltigen Variablen an interne, im Modul gueltige Variablen
uebergeben werden. Sie muessen dabei gleichzeitig die Art der ent-
sprechenden uebergabevariablen festlegen:
char string Stringvariable des Namens string
float zahl Zahlenvariable des Namens zahl
Define- und MEMO-Variablen sind immer global (im gesamten Programm
gueltig) und koennen daher nicht als Uebergabevariablentyp eingesetzt
werden. Sie koennen aber den Namen eines als uebergabevariable ver-
wendeten Strings zwischen die Platzhalter . setzen. Im Modul wird
die Stringvariable dann wie eine Feldvariable behandelt. Im Modul
definierte Variablen werden dann global, wenn Sie mit einem Under-
slash definiert wurden, also z.B. DEFFLOAT _zahl.
Ein Modul muss immer mit der Anweisung ENDMOD beendet werden. Alle
lokalen
dem Befehl CALL aufgerufen.
Bespiel .ENDMOD reftype=fn. MODUL..ENDMOD
Siehe
CALL
ΓòÉΓòÉΓòÉ 109. WHILE..WEND ΓòÉΓòÉΓòÉ
Funktion
Erstellt eine Schleife, die erst durch ein bestimmtes Ereignis
abgebrochen wird.
Syntax
WEND
Eingabe
a Laufvariable
vergl Vergleichsoperator (=,<,>,<>,<=,>=)
x Zahlenvariable bzw. Rechenoperation
Ausgabe
Keine
Beschreibung
Mit WHILE..WEND koennen Schleifen programmiert werden, die bis zum
Eintreten einer bestimmten Abbruchsbedingung durchlaufen werden.
Hierbei ist im Gegensatz zu IF..THEN kein Sprungbefehl notwendig.
Die Schleife wird solange durchlaufen, wie die auf WHILE folgende
Bedingung erfuellt ist. Ist dies nicht mehr der Fall, fuehrt das
Programm mit der auf WEND folgenden Anweisung fort. Beachten Sie
unbedingt, dass innerhalb der Schleife eine Abbruchsmoeglichkeit
bestehen muss, da sonst eine Endlosschleife entsteht.
Bespiel .WEND reftype=fn. WHILE..WEND
Siehe
ΓòÉΓòÉΓòÉ 110. ACOS ΓòÉΓòÉΓòÉ
Funktion
Berechnet den ArcusCosinus eines vorgegebenen Winkels.
Syntax
ACOS eingabe, ausgabe
Eingabe
Variable mit dem Wert des zu berechnenden Winkels
Ausgabe
Variable mit dem ArcusCosinus des vorgegebenen Winkels
Beschreibung
Mit dieser Funktion berechnen Sie den ArcusCosinus eines Winkels.
Geben Sie hierzu den numerischen Wert des Winkels ohne Einheit vor.
Bespiel ACOS
Siehe
ASIN
ATAN
COS
SIN
TAN
ΓòÉΓòÉΓòÉ 111. ASIN ΓòÉΓòÉΓòÉ
Funktion
Berechnet den ArcusSinus eines vorgegebenen Winkels.
Syntax
ASIN eingabe, ausgabe
Eingabe
eingabe Variable mit dem Wert des zu berechnenden Winkels
Ausgabe
ausgabe Variable mit dem ArcusSinus des vorgegebenen Winkels
Beschreibung
Mit dieser Funktion berechnen Sie den ArcusSinus eines Winkels. Geben
Sie hierzu den numerischen Wert des Winkels ohne Einheit vor.
Bespiel ASIN
Siehe
ACOS
ATAN
COS
SIN
ΓòÉΓòÉΓòÉ 112. ATAN ΓòÉΓòÉΓòÉ
Funktion
Berechnet den ArcusTangens eines vorgegebenen Winkels.
Syntax
ATAN eingabe, ausgabe
Eingabe
eingabe Variable mit dem Wert des zu berechnenden Winkels
Ausgabe
ausgabe Variable mit dem ArcusTangens des vorgegebenen Winkels
Beschreibung
Mit dieser Funktion berechnen Sie den ArcusTangens erines Winkels.
Geben Sie hierzu den numerischen Wert des Winkels ohne Einheit vor.
Bespiel ATAN
Siehe
ACOS
ASIN
COS
SIN
ΓòÉΓòÉΓòÉ 113. CALC ΓòÉΓòÉΓòÉ
Funktion
Ermittelt das Ergebnis einer Berechnung mit den Werten
von zwei Stringvariablen.
Syntax
CALC op$,werta$,wertb$,erg$
Eingabe
op$ Benoetigter Rechenoperator (+,-)
werta$,wertb$ Strings, deren Inhalte addiert oder
subtrahiert werden sollen.
Ausgabe
erg$ String mit dem Ergebnis der Rechnung
Beschreibung
Der Befehl ermittelt das Ergebnis einer Addition zweier String-
variablen oder Subtraktion auf zwei Kommastellen genau. Es
erfolgt keine Rundung des Ergebnisses.
Bespiel CALC
Siehe
SIN
COS
TAN
ΓòÉΓòÉΓòÉ 114. COS ΓòÉΓòÉΓòÉ
Funktion
Berechnet den Cosinus des angegebenen Winkels.
Syntax
COS eingabe, ausgabe
Eingabe
eingabe Variable mit dem Wert des zu berechnenden Winkels
Ausgabe
ausgabe Variable mit dem Cosinus des angegebenen Winkels
Beschreibung
Mit dieser Funktion koennen Sie den Cosinus eines Winkels errechnen.
Geben Sie hierzu den numerischen Wert des Winkels ohne Einheit an.
Bespiel COS
Siehe
ACOS
ASIN
ATAN
SIN
TAN
ΓòÉΓòÉΓòÉ 115. EVAL ΓòÉΓòÉΓòÉ
Funktion
Errechnet den Inhalt einer in einer Stringvariablen
enthaltenen Rechenoperation.
Syntax
EVAL express$,erg
Eingabe
express$ String mit mathematischen Ausdruck
Ausgabe
erg Variable, in die das Ergebnis der Berechnung uebergeben wird
Beschreibung
Der Befehl berechnet die in der Variable vorgesehene Rechenoperation.
Das Ergebnis wird in der Variable erg gespeichert und kann auf Wunsch
angezeigt werden. Folgende Rechenoperationen koennen mit diesem Befehl
durchgefuehrt werden: Multiplikation, Division, Addition, Subtraktion.
Bespiel EVAL
Siehe
ΓòÉΓòÉΓòÉ 116. SIN ΓòÉΓòÉΓòÉ
Funktion
Berechnet den Sinus eines vorgegebenen Winkels.
Syntax
SIN eingabe, ausgabe
Eingabe
eingabe Variable mit dem Wert des zu berechnenden Winkels
Ausgabe
ausgabe Variable mit dem Sinus des vorgegebenen Winkels
Beschreibung
Mit dieser Funktion berechnen Sie den Sinus eines Winkels. Geben Sie
hierzu den numerischen Wert des Winkels ohne Einheit vor.
Bespiel SIN
Siehe
ACOS
ASIN
ATAN
COS
ΓòÉΓòÉΓòÉ 117. SQRT ΓòÉΓòÉΓòÉ
Funktion
Gibt Wurzel aus Zahl zurБck.
Syntax
SQRT zahl, erg
Eingabe
zahl
Ausgabe
erg
Beschreibung
keine
Bespiel SQRT
Siehe
ΓòÉΓòÉΓòÉ 118. TAN ΓòÉΓòÉΓòÉ
Funktion
Berechnet den Tangens eines vorgegebenen Winkels.
Syntax
TAN eingabe, ausgabe
Eingabe
eingabe Variable mit dem Wert des zu berechnenden Winkels
Ausgabe
ausgabe Variable mit dem Tangens des vorgegebenen Winkels
Beschreibung
Mit dieser Funktion berechnen Sie den Tangens eines Winkels. Geben Sie
hierzu den numerischen Wert des Winkels ohne Einheit vor.
Bespiel TAN
Siehe
ACOS
ASIN
ATAN
COS
ΓòÉΓòÉΓòÉ 119. LPRINT ΓòÉΓòÉΓòÉ
Funktion
Gibt Variablen bzw. Zeichenketten auf dem Drucker aus.
Syntax
LPRINT "Text",zahl,string$
Eingabe
"Text",zahl,string$ Auszudruckender Text bzw. Variablen
Ausgabe
Keine
Beschreibung
Mit der LPRINT-Anweisung koennen Sie beliebigen Text oder Inhalt von
Zahlen- oder Stringvariablen ausdrucken lassen. Reihenfolge und An-
zahl der Parameter sind beliebig. Die Trenueung der einzelnen Ausgabe-
werte erfolgt durch Komma oder Strichpunkt. Bei Verwendung des Strich-
punkts als Trennzeichen fuegt LPRINT zwischen den beiden Parametern
8 Leerzeichen ein. Zwischen dem LPRINT-Befehl und dem ersten Anfuehrungs-
zeichen muss unbedingt ein Leerzeichen stehen. Steuerzeichen werden mit
dem Befehl CHR an den Drucker uebergeben.
Bespiel LPRINT
Siehe
CHR
FORM
STR
ΓòÉΓòÉΓòÉ 120. PRNCHANGE ΓòÉΓòÉΓòÉ
Funktion
Tauscht Zeichen aus einer Tabelle aus (Druckertreiber).
Syntax
PRNCHANGE array,start,ende
Eingabe
array Name des Feldes, in welchem Zeichen ausgetauscht werden sollen
start Startvariable im Feld, von der aus der Tausch beginueen soll
ende Schlussvaribale im Feld, bei der der Tausch beendet werden soll
Ausgabe
Keine
Beschreibung
Mit diesem Befehl koennen Sie Zeichen aus der ASCII-Tabelle austauschen.
Die Anweisung wirkt nur auf die Befehle PRINT und LPRINT. PRNCHANGE
wird zur Erstellung von Druckertreibern fuer Drucker herangezogen, deren
interne Zeichentabelle nicht mit dem IBM-ASCII-Code identisch ist.
Bespiel PRNCHANGE
Siehe
LPRINT
ΓòÉΓòÉΓòÉ 121. DBFIELDS ΓòÉΓòÉΓòÉ
Funktion
************************ UNBEKANNT **********************
Syntax
Eingabe
Ausgabe
Beschreibung
************************ UNBEKANNT **********************
Bespiel DBFIELDS
Siehe
ΓòÉΓòÉΓòÉ 122. IADD ΓòÉΓòÉΓòÉ
Funktion
fuegt einer Datenbank einen Datensatz hinzu.
Syntax
IADD nr,s$
Eingabe
nr Nummer der entsprechenden Datenbank
s$ Recordstruktur, ueber die die Daten eingegeben werden sollen
Ausgabe
Keine
Beschreibung
Der angefuegte Datensatz wird intern sofort durch die Indexdateien
richtig in die Datenbank einsortiert. Der neue Datensatz wird also
in Abhaengigkeit vom aktivierten Index an unterschiedlichen Stellen
in die Datenbank eingefuegt. Durch IADD wird der Datenbankanzeiger
automatisch auf den hinzugefuegten Datensatz gestellt, dieser wird
also der aktuelle Datensatz.
Bespiel IADD
Siehe
ΓòÉΓòÉΓòÉ 123. ICLOSE ΓòÉΓòÉΓòÉ
Funktion
Schliesst eine geoeffnete Datenbank.
Syntax
ICLOSE nr
Eingabe
nr Nummer der entsprechenden Datenbank
Ausgabe
Keine
Beschreibung
Ausser der entsprechenden Datenbank werden alle zugehoerigen
Indexdateien geschlossen. Dabei werden alle Pufferinhalte
auf eine Festplatte oder eine Diskette geschrieben. Wenn Sie
als Datenbanknummer die Zahl 99 angeben, werden alle geoeffneten
Datenbank- und Indexdateien geschlossen.
Bespiel ICLOSE
Siehe
ΓòÉΓòÉΓòÉ 124. ICLOSE_INDEX ΓòÉΓòÉΓòÉ
Funktion
Indexdateien einer Datenbank werden geschlossen.
Syntax
ICLOSE_INDEX nr
Eingabe
nr Nummer der entsprechenden Datenbank
Ausgabe
Keine
Beschreibung
Dieser Befehl schliesst alle Indexdateien einer geoeffneten Datenbank.
Bespiel ICLOSE_INDEX
Siehe
ΓòÉΓòÉΓòÉ 125. ICREATE ΓòÉΓòÉΓòÉ
Funktion
Erstellt eine neue Datenbank.
Syntax
ICREATE name$,def_felder$,def_index$
Eingabe
name$ Name der Datenbank (ohne DOS-Endung), darf maximal
8 Zeichen betragen (auch Pfadangabe moeglich)
def_felder$ Array mit der Definition der Feldstruktur der Datenbank
def_index$ Array mit der Definition der Indexstruktur des
Basisindizes
Ausgabe
Keine
Beschreibung
Durch diesen Befehl wird eine bestehende Datenbank gleichen Namens
ueberschrieben! Die Datenbank muss anschliessend mit IOPEN geoeffnet
werden. Der Basisindex traegt den gleichen Namen wie die Datenbank.
Zusaetzlich muessen Sie die Arrays angeben, in denen die Feld- und
die Indexstruktur der Datenbank verzeichnet sind. Beispiel (es duerfen
keine Tabulatoren verwendet werden!!!):
Datenbank erstellen mit ICREATE
DIM feld,1,4
DIM index,1,3
rem Name Typ Laenge Dezimalstellen
feld1=" NAME , C , 20 , 0"
feld2=" STRASSE , C , 50 , 0"
feld3=" ORT , C , 30 , 0"
feld4=""
rem Name Ausdruck Filter Unique Auf/Abst.
index1="Name_tag, NAME, .NOT.DELETED, 0 , 0"
index2="Ort_tag, ORT, .NOT.DELETED, 0 , 0"
index3=""
icreate "dateiname",feld,index
Bespiel ICREATE
Siehe
ΓòÉΓòÉΓòÉ 126. IDEL ΓòÉΓòÉΓòÉ
Funktion
Loescht einen Datensatz aus der aktuellen Datenbank.
Syntax
IDEL nr
Eingabe
nr Nummer der entsprechenden Datenbank
Ausgabe
Keine
Beschreibung
Loescht den aktuellen Datensatz und setzt den Datenbanksatzzeiger auf
den naechsten Datensatz (Der Datensatz wird analog zu dBASE nur als
geloescht markiert und kann mit IUNDEL wieder zurueckgeholt werden).
Bespiel IDEL
Siehe
IDELCHECK
IUNDEL
ΓòÉΓòÉΓòÉ 127. IDELCHECK ΓòÉΓòÉΓòÉ
Funktion
Prueft, ob ein Datensatz als geloescht markiert wurde.
Syntax
IDELCHECK nr, ok
Eingabe
nr Nummer der entsprechenden Datenbank
ok Variable, in die das Ergebnis der Suche uebergeben wird:
ok=0 = Datensatz ist als geloescht markiert
ok <>0 = Datensatz ist als nicht geloescht markiert
Ausgabe
Beschreibung
Datensatzmarkierung kann mit IUNDEL aufgehoben werden.
Bespiel IDELCHECK
Siehe
ΓòÉΓòÉΓòÉ 128. IENDE ΓòÉΓòÉΓòÉ
Funktion
Setzt den Datenbanksatzzeiger der entsprechenden Datenbank auf den
letzten Datensatz bezueglich des aktuellen Index.
Syntax
IENDE nr,s$
Eingabe
nr Nummer der entsprechenden Datenbank
Ausgabe
s$ Recordstruktur, in der der aktuelle Datensatz
angezeigt werden soll
Beschreibung
Hiermit wird der letzte Datensatz zum aktuellen Datensatz und in der
Recordstruktur angezeigt. Falls sich kein Datensatz in der Datenbank
befindet, erhalten Sie eine entsprechende Fehlermeldung.
Bespiel IENDE
Siehe
ISTART
IPREV
INEXT
ΓòÉΓòÉΓòÉ 129. IENDEREL ΓòÉΓòÉΓòÉ
Funktion
Der Datensatzzeiger wird auf das Ende der Masterdatenbank gesetzt.
Syntax
IENDEREL relnr, structmaster, structslave
Eingabe
relnr Kennummer (Handle) der Relation
(Master- und Slave-Datenbank)
Ausgabe
structmaster Datensatzinhalt (aus Masterdatenbank)
structslave Datensatzinhalt (aus Slavedatenbank)
Beschreibung
Der Befehl entspricht dem Befehl IENDE, nur dass er allgemeiner auf
Relationen verknuepfter Datenbanken angewandt werden kann.
Bespiel IENDEREL
Siehe
ΓòÉΓòÉΓòÉ 130. IEXITREL ΓòÉΓòÉΓòÉ
Funktion
Eine Relation wird beendet.
Syntax
IEXITREL relnr
Eingabe
relnr Kennummer (Handle) der Relation (Master- und Slave-Datenbank)
Ausgabe
keine
Beschreibung
Eine mit ISETREL definierte Relation wird wieder aufgehoben.
Bespiel IEXITREL
Siehe
ΓòÉΓòÉΓòÉ 131. IGET_NR ΓòÉΓòÉΓòÉ
Funktion
Ermittelt die Nummer des aktuellen Datensatzes.
Syntax
IGET_NR dbnr, pos
Eingabe
dbnr Kennummer der entsprechenden Datenbank
Ausgabe
pos Variable mit Nummer des aktuellen Datensatzes
Beschreibung
Bei der Einfuegung in eine Datenbank erhaelt jeder Datensatz automatisch
eine interne Nummer, welche er fuer immer behaelt, gleichgueltig, nach
welchem Index die Datenbank sortiert ist. ueber diese Nummer laesst sich
ein Datensatz mit IGO_NR heraussuchen. Der Befehl IGET_NR ermittelt
die Nummer des aktuellen Datensatzes.
Bespiel IGET_NR
Siehe
IGO_NR
ΓòÉΓòÉΓòÉ 132. IGETREC ΓòÉΓòÉΓòÉ
Funktion
Liest einen Datensatz aus einer geoeffneten Datenbank
in eine Recordstruktur.
Syntax
IGETREC nr,s$
Eingabe
nr Nummer der entsprechenden Datenbank
Ausgabe
s$ Recordstruktur, in der der Datensatz angezeigt werden soll.
Beschreibung
Mit dieser Anweisung werden die Werte des aktuellen Datensatzes in die
entsprechenden Feldvariablen der Recordstruktur geladen.
Bespiel IGETREC
Siehe
IGETREC_ARRAY
ΓòÉΓòÉΓòÉ 133. IGETSTRUCT ΓòÉΓòÉΓòÉ
Funktion
Der Aufbau einer Datenbank wird ermittelt.
Syntax
IGETSTRUCT nr,def_felder$,def_index$,zahl
Eingabe
nr Nummer der entsprechenden Datenbank
Ausgabe
def_felder$ Array mit der Feldstruktur
def_index$ Array mit der Basisindex-Struktur
zahl Anzahl der Feldnamen
Beschreibung
Der Aufbau der Rueckgabewerte entspricht denen, die bei der Erstellung
einer Datenbank mit ICREATE vorgegeben wurden. Somit laesst sich die
Struktur der Datenbank genau nachvollziehen.
Bespiel IGETSTRUCT
Siehe
ΓòÉΓòÉΓòÉ 134. IGO_NR ΓòÉΓòÉΓòÉ
Funktion
Bewegt den Datensatzzeiger zum Datensatz mit der angegebenen Nummer.
Syntax
IGO_NR dbnr, pos
Eingabe
dbnr Kennummer der entsprechenden Datenbank
pos Variable mit Nummer des gewuenschten Datensatzes
Ausgabe
Keine
Beschreibung
Bei der Einfuegung in eine Datenbank erhaelt jeder Datensatz automatisch
eine interne Nummer, welche er behaelt, gleichgueltig, nach welchem Index
die Datenbank sortiert ist. ueber diese Nummer laesst sich ein Datensatz
mit IGO_NR heraussuchen.
Bespiel IGO_NR
Siehe
IGET_NR
ΓòÉΓòÉΓòÉ 135. ILEN ΓòÉΓòÉΓòÉ
Funktion
Ermittelt die Anzahl der Datensaetze in einer geoeffneten Datenbank.
Syntax
ILEN nr,laenge
Eingabe
nr Nummer der entsprechenden Datenbank
Ausgabe
laenge Variable, in die die Anzahl der Datensaetze uebergeben wird
Beschreibung
Nichts
Bespiel ILEN
Siehe
ΓòÉΓòÉΓòÉ 136. ILOCK ΓòÉΓòÉΓòÉ
Funktion
Sperrt den aktuellen Datensatz fuer den Zugriff anderer Anwender.
Syntax
ILOCK nr,ok
Eingabe
nr Nummer der entsprechenden Datenbank
Ausgabe
ok Rueckgabemeldung, ob der Datensatz bereits gesperrt ist:
ok<>50 Der Datensatz kann gesperrt werden
ok=-50 Der Datensatz ist bereits gesperrt
Beschreibung
Dieser Befehl ist nur in der Netzwerkversion von KIM verfuegbar.
Er sperrt den aktuellen Datensatz einer geoeffneten Datenbank fuer
den gleichzeitigen Zugriff durch andere Netzwerkteilnehmer. Falls
der Datensatz bereits gesperrt ist, wird der Variablen ok intern
der Wert 50 zugewiesen. Es erscheint dann ein Meldungsfenster mit
der entsprechenden Mitteilung.
Bespiel ILOCK
Siehe
IUNLOCK
ΓòÉΓòÉΓòÉ 137. IMAKEINDEX ΓòÉΓòÉΓòÉ
Funktion
Erstellt nachtraeglich einen Index zu einer Datenbank.
Syntax
IMAKEINDEX nr,datei$,index$
Eingabe
nr Nummer der entsprechenden Datenbank
datei$ Name der neuen Indexdatei (Bitte ohne Endung)
index$ Array mit der neuen Indexstruktur
Ausgabe
Keine
Beschreibung
Dieser Befehl bietet die Option, einen Index nicht nur bei der
Erstellung der Datenbank mit ICREATE zu definieren, sondern auch
nachtraeglich zu jedem beliebigen Zeitpunkt. Eine bestehende Index-
datei mit gleichen Namen muss zuerst geloescht werden ( mit KILL).
Es koennen je Indexdatei mehrere Subindizes definiert werden.
Bespiel IMAKEINDEX
Siehe
ΓòÉΓòÉΓòÉ 138. IMODREC ΓòÉΓòÉΓòÉ
Funktion
Aendert den aktuellen Datensatz einer Datenbank.
Syntax
IMODREC nr, s$
Eingabe
nr Kennummer der entsprechenden Datenbank
Ausgabe
s$ Recordstruktur, in der der geaenderte Datensatz angezeigt wird
Beschreibung
Der aktuelle Datensatz wird mit dieser Anweisung ueberschrieben.
Bespiel IMODREC
Siehe
IADD
ΓòÉΓòÉΓòÉ 139. INEXT ΓòÉΓòÉΓòÉ
Funktion
Setzt den Datenbanksatzzeiger auf den naechsten Datensatz
bezueglich des aktuellen Index.
Syntax
INEXT nr,pos,s$
Eingabe
nr Nummer der entsprechenden Datenbank
Ausgabe
pos Rueckgabevariable fuer die neue Position des Datenbanksatz-
zeigers. Ist der Dateianfang erreicht, wird pos=4 ans Programm
zurueckgegeben. Ist das Dateiende erreicht, wird pos der Wert 3
zugewiesen.
s$ Recordstruktur, in die der neue Datensatz geladen wird.
Beschreibung
Mit INEXT wird der naechste Datensatz nach dem aktuellen Satz aktiviert,
wobei sich KIM an dem aktuellen Index orientiert. Falls das Dateiende
erreicht ist, wird der Datenbanksatzzeiger nicht weiter verstellt, der
letzte Datensatz bleibt aktiviert.
Bespiel INEXT
Siehe
ISTART
IENDE
IPREV
ISKIP
ΓòÉΓòÉΓòÉ 140. INEXTREL ΓòÉΓòÉΓòÉ
Funktion
Der Datensatzzeiger auf den naechsten
Datensatz der Masterdatenbank gesetzt
Syntax
INEXTREL relnr,ok, structmaster, structslave
Eingabe
relnr Kennummer (Handle) der Relation
(Master- und Slavedatenbank)
Ausgabe
ok Werte entsprechen der Variablen pos bei dem Befehl INEXT.
structmaster Datensatzinhalt der Masterdatenbank
structslave Datensatzinhalt der Slavedatenbank
Beschreibung
Der Befehl entspricht dem Befehl INEXT, nur ist er allgemeiner auf
Relationen anwendbar.
Bespiel INEXTREL
Siehe
ΓòÉΓòÉΓòÉ 141. IOPEN ΓòÉΓòÉΓòÉ
Funktion
oeffnet eine bestehende Datenbank.
Syntax
IOPEN nr,datei
Eingabe
nr Nummer der entsprechenden Datenbank
datei Name der entsprechenden Datenbank
Ausgabe
Keine
Beschreibung
Voraussetzung fuer diesen Befehls ist das Vorhandensein einer Daten-
bank. Mit IOPEN wird die Datenbank fuer den Zugriff durch andere Daten-
bankbefehle aktiviert. Eine geoeffnete Datei sollte am Ende des Pro-
gramms mit ICLOSE wieder geschlossen werden. Die Indexdateien muessen
mit IOPEN_INDEX geoeffnet werden.
Bespiel IOPEN
Siehe
ΓòÉΓòÉΓòÉ 142. IOPEN_INDEX ΓòÉΓòÉΓòÉ
Funktion
Eine Indexdatei wird geoeffnet.
Syntax
IOPEN_INDEX nr,datei$
Eingabe
nr Nummer der entsprechenden Datenbank
datei$ Zu oeffnende Indexdatei
Ausgabe
Beschreibung
Neben einer geoeffneten Indexdatei koennen noch weitere Indexdateien
geoeffnet werden.
Bespiel IOPEN_INDEX
Siehe
ICLOSE_INDEX
ΓòÉΓòÉΓòÉ 143. IPACK ΓòÉΓòÉΓòÉ
Funktion
Geloeschte Datensaetze werden aus der Datenbank entfernt.
Syntax
IPACK nr
Eingabe
nr Nummer der entsprechenden Datenbank
Ausgabe
Keine
Beschreibung
Mit diesem Befehl werden alle als geloescht markierten Datensaetze aus
der Datenbank entfernt. Danach koennen sie nicht mehr mit IUNDEL zurueck-
geholt werden.
Bespiel IPACK
Siehe
IREINDEX
ΓòÉΓòÉΓòÉ 144. IPREV ΓòÉΓòÉΓòÉ
Funktion
Setzt den Datenbanksatzzeiger auf den vorhergehenden
Datensatz bezueglich des aktuellen Index.
Syntax
IPREV nr,pos,s$
Eingabe
nr Nummer der entsprechenden Datenbank
Ausgabe
s$ Recordstruktur, in die der neue Datensatz geladen wird
pos Variable, in die die neue Position des Datenbanksatzzeigers
zurueckgegeben wird. Am Dateianfang wird der Wert 4 ueber-
geben, am Ende der Datei erfolgt die uebergabe des Wertes 3.
Beschreibung
Mit diesem Befehl wird der vorhergehende Datensatz aktiviert.
Am Dateianfang und -ende erfolgt keine Veraenderung des aktuellen
Datensatzes mehr.
Bespiel IPREV
Siehe
ISTART
IENDE
INEXT
ISKIP
ΓòÉΓòÉΓòÉ 145. IPREVREL ΓòÉΓòÉΓòÉ
Funktion
Der Datensatzzeiger auf den vorherigen
Datensatz der Masterdatenbank gesetzt.
Syntax
IPREVREL relnr,ok, structmaster, structslave
Eingabe
relnr Kennummer (Handle) der Relation
Ausgabe
ok Werte entsprechen der Variablen pos bei dem Befehl IPREV
structmaster Datensatzinhalt (Masterdatenbank)
structslave Datensatzinhalt (Slavedatenbank)
Beschreibung
Der Befehl entspricht dem Befehl IPREV, ist aber allgemeiner fuer
Relationen gueltig.
Bespiel IPREVREL
Siehe
INEXTREL
ΓòÉΓòÉΓòÉ 146. IREAD ΓòÉΓòÉΓòÉ
Funktion
Sucht einen Datensatz in einer geoeffneten Datenbank bezueglich
des aktuellen Index.
Syntax
IREAD nr,ok,suchstring$,s$
Eingabe
nr Nummer der entsprechenden Datenbank
s$ Recordstruktur, in der der Datensatz gesucht wird
suchstring$ Zu suchender Feldinhalt
Ausgabe
ok Variable, in die das Ergebnis der Suche uebergeben wird:
ok=0: Datensatz gefunden
ok<>0: Datensatz nicht gefunden
Beschreibung
Es wird nach dem Feldwert in der Datenbank gesucht, auf den der aktuelle
Index zeigt (Schluesselwert). Es koennen aber auch alle weiteren Felder
der Recordstruktur als Index ausgezeichnet werden. Dies ist besonders
dann wichtig, wenn mehrere Datensaetze mit dem gleichen Schluesselwert
gefunden werden. Dann werden zur Unterscheidung weitere Indexkriterien
betrachtet.
Bespiel IREAD
Siehe
IADD
IMODREC
ΓòÉΓòÉΓòÉ 147. IREINDEX ΓòÉΓòÉΓòÉ
Funktion
Reorganisiert einen bestehenden Index.
Syntax
IREINDEX nr
Eingabe
nr Nummer der entsprechenden Datenbank
Ausgabe
keine
Beschreibung
Es werden alle offenen Indexdateien einer Datenbank reorganisiert.
Bespiel IREINDEX
Siehe
IPACK
ΓòÉΓòÉΓòÉ 148. ISET ΓòÉΓòÉΓòÉ
Funktion
Wechselt den aktuellen Index.
Syntax
ISET nr,index$,expr$
Eingabe
nr Nummer der entsprechenden Datenbank
index$ Neuer Indexname (Nicht der Name der physikal. Indexdatei)
Ausgabe
expr$ Aktueller Inhalt aufgrund des neuen Indexes.
Beschreibung
Der aktuelle Index wird gewechselt. Voraussetzung hierfuer ist, dass eine
Indexdatei geoeffnet ist.
Bespiel ISET
Siehe
IOPEN
IOPEN_INDEX
ΓòÉΓòÉΓòÉ 149. ISETREL ΓòÉΓòÉΓòÉ
Funktion
Eine Relation zwischen einer Master- und
einer Slave-Datenbank wird definiert.
Syntax
ISETREL relnr, dbnr_master,dbnr_slave,slave_ausdruck
Eingabe
relnr Kennummer (Handle) der Relation
dbnr_master Kennummer (Handle) der Masterdatenbank
dbnr_slave Kennummer (Handle) der Slavedatenbank
slave_ausdruck Verknuepfung zwischen Master- und Slave-Datenbank
Ausgabe
keine
Beschreibung
Es wird eine Relation zwischen zwei Datenbanken geknuepft. Dabei ist
die Verbindung zwischen beiden Datenbanken der Inhalt der Variablen
slave_ausdruck. Hier wird der gemeinsame Index der beteiligten Daten-
banken festgelegt, nach der saemtliche Daten angeordnet werden sollen.
Bespiel ISETREL
Siehe
ΓòÉΓòÉΓòÉ 150. ISETRELQUERY ΓòÉΓòÉΓòÉ
Funktion
Ein dBASE-Ausdruck wird fuer eine Relation eingesetzt.
Syntax
ISETRELQUERY relnr,expression
Eingabe
relnr Kennummer (Handle) der Relation
expression Ausdruck, der fuer die Relation eingesetzt werden soll
Ausgabe
Keine
Beschreibung
Es wird ein DBASE-Ausdruck fuer eine Relation eingesetzt. Die
Beschreib
Kapitel ueber Datenbanken.
Bespiel ISETRELQUERY
Siehe
ΓòÉΓòÉΓòÉ 151. ISETRELSORT ΓòÉΓòÉΓòÉ
Funktion
Es wird ein Sortierausdruck fuer eine Relation bestimmt.
Syntax
ISETRELSORT relnr, sort_expression
Eingabe
relnr Kennummer (Handle) der Relation
sort_expression Sortierausdruck
Ausgabe
Keine
Beschreibung
Befehle fuer die Sortierung werden im Kapitel ueber Datenbanken
beschrieben.
Bespiel ISETRELSORT
Siehe
ΓòÉΓòÉΓòÉ 152. ISKIP ΓòÉΓòÉΓòÉ
Funktion
Datenbankzeiger vor- bzw. rБckwДrts bewegen
Syntax
ISKIP db_nr, anzahl
Eingabe
db_nr Nr der Datanbank
anzahl 10 SДtze weiter
anzahl -10 SДtze zurБck
Ausgabe
Beschreibung
Bewegt den Datenbankzeiger bei einen positiven Wert um
<anzahl> vorwДrts in der Datenbank oder bei einen nega-
tiven Wert um <Anzahl> zurБck in der Datenbank. Werden
dabei die Datenbankgrenzen (Anfang,Ende) Бberschritten,
wird der Datenbankzeiger entsprechend auf den Anfang
oder das Ende gesetzt.
Bespiel ISKIP
Siehe
INEXT
IPREV
ΓòÉΓòÉΓòÉ 153. ISTART ΓòÉΓòÉΓòÉ
Funktion
Setzt den Datenbanksatzzeiger auf den ersten Datensatz bezueglich
des aktuellen Index.
Syntax
ISTART nr,s$
Eingabe
nr Nummer der entsprechenden Datenbank
Ausgabe
s$ Recordstruktur, in der der neue Datensatz erscheinen soll.
Beschreibung
Falls kein Datensatz in der Datenbank vorhanden ist, wird eine ent-
sprechende Meldung ausgegeben.
Bespiel ISTART
Siehe
IENDE
IPREV
INEXT
ΓòÉΓòÉΓòÉ 154. ISTARTREL ΓòÉΓòÉΓòÉ
Funktion
Der Datensatzzeiger wird auf den Anfang der Masterdatenbank gesetzt
Syntax
ISTARTREL relnr, structmaster, structslave
Eingabe
relnr Kennummer (Handle) der Relation
Ausgabe
structmaster Datensatzinhalt (Masterdatenbank)
structslave Datensatzinhalt (Slavedatenbank)
Beschreibung
Der Befehl entspricht dem Befehl ISTART, ist aber allgemeiner fuer
Relationen gueltig.
Bespiel ISTARTREL
Siehe
ΓòÉΓòÉΓòÉ 155. IUNDEL ΓòÉΓòÉΓòÉ
Funktion
Loeschmarkierung eines Datensatzes wird aufgehoben.
Syntax
IUNDEL nr
Eingabe
nr Nummer der entsprechenden Datenbank
Ausgabe
keine
Beschreibung
Der aktuelle Datensatz wird wieder zurueckgeholt und kann weiter ver-
wendet werden. Dieser Befehl ist nur anwendbar, wenn die Anweisung
IPACK noch nicht durchgefuehrt wurde.
Bespiel IUNDEL
Siehe
IDEL
IDELCHECK
ΓòÉΓòÉΓòÉ 156. IUNLOCK ΓòÉΓòÉΓòÉ
Funktion
Entsperrt den aktuellen Datensatz einer geoeffneten Datenbank.
Syntax
IUNLOCK nr,ok
Eingabe
nr Nummer der entsprechenden Datenbank
Ausgabe
ok Variable, in die das Ergebnis des Vorgangs an das Programm
zurueck gegeben wird:
ok<>50 Datensatz wurde entsperrt
ok=50 Datensatz konnte nicht entsperrt werden
Beschreibung
Dieser Befehl ist nur in der Netzwerkversion von KIM gueltig. Er ent-
sperrt einen mit ILOCK fuer den Zugriff anderer Anwender gesperrten
Datensatz wieder. Somit ist der aktuelle Datensatz fuer jeden Benutzer
des Netzwerks ansprechbar und bearbeitbar.
Bespiel IUNLOCK
Siehe
ILOCK
ΓòÉΓòÉΓòÉ 157. RND ΓòÉΓòÉΓòÉ
Funktion
Ermittelt eine willkuerliche Zahl mittels eines Zufallsgenerators.
Syntax
RND startpos,zahl
Eingabe
startpos Startposition fuer den Zufallsgenerator (0-255)
Ausgabe
zahl Variable, in die die zuf_llig ausgewaehlte Zahl
uebergeben wird (0-32000).
Beschreibung
Mit diesem Befehl koennen Sie einen Zufallsgenerator aktivieren, der
Ihnen beliebig viele Zahlen in zuf_lliger Reihenfolge ausgibt. Um
unterschiedliche Zufallszahlen zu erhalten, koennen Sie verschiedene
Startpositionen zur Ermittlung der Zahlen festlegen.
Bespiel RND
Siehe
ΓòÉΓòÉΓòÉ 158. SETLANG ΓòÉΓòÉΓòÉ
Funktion
Umwandlung beim lesen von numerischen Feldern.
Syntax
SETLANG flag
Eingabe
flag 1=Umwandlung Punkt nach Komma (Vorgabe)
0=Punkt bleibt
Ausgabe
keine
Beschreibung
(Standard) Bei Zahlenfelder aus Datenbank einer
Datenbank wird der Punkt in ein Komma gewandelt
(Deutschland)
Bespiel SETLANG
Siehe
ΓòÉΓòÉΓòÉ 159. ADD_ITEM ΓòÉΓòÉΓòÉ
Funktion
Ein Objekt wird an ein anderes Objekt angefuegt.
Syntax
ADD_ITEM Haupt_id String, Unter_id,..
Eingabe
Haupt_id String Mutterobjekt
Unter_id String Kindobjekt
Ausgabe
keine
Beschreibung
Mit diesem Befehl fuegen Sie an ein Objekt ein anderes Objekt an.
Beispiel:
Sie haben ein Listenobjekt, z.B. eine Combobox, definiert. In dieser
Combobox brauchen wir einige Elemente. Diese Elemente, z.B. String-
objekte, werden mit dem Befehl ADD_ITEM an die Combobox "angefuegt".
Dann fuegen wir das Objekt Combobox an das Fensterobjekt an. In einigen
Fuellen ist die Reihenfolge der Objekte, die an ein anderes Objekt
angefuegt werden, wichtig (bei Fenstern sollte zunaechst der Rahmen
vor anderen Objekte hinzugefuegt werden, vgl. Kapitel Oberflaechen-
erstellung). Ein Objekt darf nicht gleichzeitig zwei verschiedenen
Objekten als Element zugewiesen werden. Das Betriebssystem meldet
sonst einen allgemeinen Speicherschutzfehler.
Bespiel ADD_ITEM
Siehe
ADD_ITEM_ARRAY
SUB_ITEM
SUB_ITEM_ARRAY
ΓòÉΓòÉΓòÉ 160. ADD_ITEM_ARRAY ΓòÉΓòÉΓòÉ
Funktion
Berechnet den ArcusCosinus eines vorgegebenen Winkels.
Ein Objekt wird an ein anderes Objekt angefuegt.
Syntax
ADD_ITEM_ARRAY Haupt_id String, Unter_id, von$, bis$
Eingabe
Variable mit dem Wert des zu berechnenden Winkels
Haupt_id String Mutterobjekt
Unter_id String Kindobjekt
von$ Erstes Objekt (Zahl)
bis$ Letztes Objekt (Zahl)
Ausgabe
Variable mit dem ArcusCosinus des vorgegebenen Winkels
keine
Beschreibung
Mit dieser Funktion berechnen Sie den ArcusCosinus eines Winkels.
Geben Sie hierzu den numerischen Wert des Winkels ohne Einheit vor.
Mit diesem Befehl fuegen Sie an ein Objekt mehrere Objekt an.
Bespiel ADD_ITEM_ARRAY
Siehe
ADD_ITEM
SUB_ITEM
SUB_ITEM_ARRAY
ΓòÉΓòÉΓòÉ 161. COLOR_ITEM ΓòÉΓòÉΓòÉ
Funktion
Aendert die Farbe eines Objekts
Syntax
COLOR_ITEM id_string,pnr
Eingabe
id_string Objektkennung
pnr Bezeichnung der Palette, in der die zu verwendenden
Farben definiert wurden
Ausgabe
keine
Beschreibung
Hiermit wird die Farbe eines Objekts ge_ndert. Dies hat nur einen Er-
folg unter WINDOWS/OS2, wenn das Flag "color on" fuer das entsprechende
Objekt gesetzt und die entsprechende Farbpalette definiert ist.
Bespiel COLOR_ITEM
Siehe
DEF_PALETTE
ΓòÉΓòÉΓòÉ 162. DEF_BORDER ΓòÉΓòÉΓòÉ
Funktion
Definition eines Rands
Syntax
DEF_BORDER id_string
Eingabe
id_string Objektbezeichnung
Ausgabe
keine
Beschreibung
Ein Border-Objekt wird definiert und kann dann mit ADD_ITEM addiert
werden.
Bespiel DEF_BORDER
Siehe
ΓòÉΓòÉΓòÉ 163. DEF_BUTTON ΓòÉΓòÉΓòÉ
Funktion
Definiert einen Button (dt. Knopf)
Syntax
DEF_BUTTON id_string, x, y, len, bitmap$, text$
Eingabe
id_string Objektkennung
x,y x/y-Position des Buttons im zugewiesenen Fenster
len Laenge des Buttons
bitmap$ Name eines Bitmaps aus einer DAT-Datei (wenn vorhanden)
text$ Titel des Buttons
Ausgabe
keine
Beschreibung
Dadurch wird ein Button (Druckknopf) erstellt. Die Art eines Buttons
(PUSH, RADIO, RING) wird ueber die Flags gesteuert. Optional kann auf
den Button ein Bild (Bitmap, Icon) gelegt werden. Wird dies nicht ge-
wuenscht, weisen Sie der Variablen bitmap$ einen Leerstring " " zu.
Bespiel DEF_BUTTON
Siehe
ΓòÉΓòÉΓòÉ 164. DEF_COMBO ΓòÉΓòÉΓòÉ
Funktion
Definiert eine Auswahlbox.
Syntax
DEF_COMBO id_string,x,y,len,height
Eingabe
id_string Objektkennung
x,y x/y-Position der Box im zugewiesenen Fenster
len Laenge der Box
height Hoehe der Box
Ausgabe
keine
Beschreibung
Einer Auswahlbox koennen verschiedenartige Objekte zugewiesen werden.
Bespiel DEF_COMBO
Siehe
DEF_LIST
ΓòÉΓòÉΓòÉ 165. DEF_GROUP ΓòÉΓòÉΓòÉ
Funktion
Definiert ein Gruppenobjekt.
Syntax
DEF_GROUP Id_string, x, y, xr, yr,"ueberschrift"
Eingabe
Id_string Kennung des Objekts
x, y Position des Gruppenfensters im zugewiesenen Fenster
xr, yr Laenge und Breite der Gruppe
"ueberschrift" Ueberschrift der Gruppe
Ausgabe
Beschreibung
Mit diesem Befehl wird ein Gruppenobjekt definiert. In erster
Linie dient ein Gruppenobjekt dazu, mehrere Fensterobjekte zu
einer physikalischen Gruppe zusammenzufassen und von anderen
Objekten zu separieren.
Bespiel DEF_GROUP
Siehe
ΓòÉΓòÉΓòÉ 166. DEF_ICON ΓòÉΓòÉΓòÉ
Funktion
Ein Icon aus der Objektbibliothek wird naeher definiert.
Syntax
DEF_ICON Id_string, x, y, "Iconname","Titel"
Eingabe
Id_string Kennung des Objekts
x, y x-y Position des Icons im zugewiesenen Objekt
"Iconname" Name des ICONS in einer geladenen DAT-Datei.
"Titel" Zusatzbezeichnung des Icons
Ausgabe
keine
Beschreibung
Icons sind kleine Grafiken im Pixelformat auf einer 32 x 32 Matrix.
Fuer die Systemunabhaengigkeit wird ein eigenes Format unterstuetzt.
Icons koennen nur aus systemunabhaengigen DAT-Files genutzt werden.
Ein entsprechender ICON-Designer wird an anderer Stelle beschrieben.
ueber ein Flag kann man entscheiden, ob das ICON nur bei Symbolgroesse
eines Fensterobjekts oder als normales ICON eingesetzt wird. Das FLAG
"ICON MINIMIZE" bewirkt die Aktivierung des Icons bei Verkleinerung
des Objekts auf Symbolgroesse. "ICON DOUBLE_CLICK" hat zur Folge, dass
das Icon nur bei einem Doppelklick selektiert wird.
Der "Iconname" ist die Bezeichnung des ICONS aus einem DAT-File, ueber
den es aus dieser Datei eingelesen werden. ueber die Zusatzbezeichnung
koennen Sie das Icon nach diesem Befehl mit anderen Anweisungen an-
sprechen.
Bespiel DEF_ICON
Siehe
LOAD_DAT
ΓòÉΓòÉΓòÉ 167. DEF_INPUT ΓòÉΓòÉΓòÉ
Funktion
Definition einer formatierbaren Eingabemaske.
Syntax
DEF_INPUT id_string, x,y,breite,text,maske,schablone
Eingabe
id_string Objektkennung
x,y x,y-Position der Maske im Fenster
breite Breite der Eingabezone
text Vorgabetext (erscheint bei Aufruf der Maske)
maske Zulaessige Eingabe, die in der Maske getaetigt werden kann:
c: Alphanumerische Eingabezeichen
C: Alphanumerische Eingabeparameter. z, A.. Z
(keine Sonderzeichen und Zahlen)
A: Wie bei a, aber mit sofortiger Umwandlung in
Grossbuchstaben
L: Benuetzen Sie dieses Zeichen fuer Schablonenvorgabe
N: Numerische Eingabeparameter:
x: Eingabeparameter: von druckbaren Zeichen
X: Wie x, aber mit Umwandlung in Grossbuchstaben
schablone Eingabeschablone
Ausgabe
Beschreibung
Es wird eine Eingabemaske erstellt, die die getaetigte Eingabe gemaess
der unter maske definierten Vorgaben automatisch formatiert.
Ein Beispiel fuer den Befehl:
DEF_INPUT "id",2,2,10," ","LLLcccLNNN","GUT - ".
Die ersten drei Felder der Maske enthalten eine Vorgabe, welche ueber
die Schablone als GUT bestimmt wird. Danach koennen drei alphanumerische
Zeichen eingegeben werden, ehe ein weiteres Zeichen (-) vorgegeben ist.
Schliesslich koennen drei Zahlen eingegeben werden. Maske und Schablone
entsprechen sich in Zeichenanzahl und -folge.
Bespiel DEF_INPUT
Siehe
DEF_INPUT_DATE
DEF_INPUT_TIME
DEF_NUMBER
ΓòÉΓòÉΓòÉ 168. DEF_INPUT_DATE ΓòÉΓòÉΓòÉ
Funktion
Definition einer Datumseingabemaske
Syntax
DEF_INPUT_DATE id_string, x, y, len,vorgabe, range
Eingabe
id_string Objektkennung
x, y Position der Maske
len Laenge der Maske
vorgabe Datumsvorgabe (erscheint bei Aufruf der Maske)
range Einschraenkung des Datumszeitraums
Ausgabe
keine
Beschreibung
Dieses Objekt ermoeglicht die Eingabe eines Datums in der Form
TT/MM/YY oder TT.MM.JJ. Ist die Vorgabe leer, wird das aktuelle
Tagesdatum eingetragen. Mit dem Inhalt der Variablen "range"
koennen Sie einen Eingabezeitraum festlegen (z.B. 03/09/93..03/12/93).
Bespiel DEF_INPUT_DATE
Siehe
DEF_INPUT
DEF_INPUT_TIME
DEF_NUMBER
ΓòÉΓòÉΓòÉ 169. DEF_INPUT_TIME ΓòÉΓòÉΓòÉ
Funktion
Definiert Eingabemaske fuer Zeitangaben.
Syntax
DEF_INPUT_TIME id_string,x,y,len,vorgabe$,intervall$
Eingabe
id_string Objektkennung
x,y x,y-Position der Maske im zugewiesenen Fenster
len Laenge der Eingabezone
vorgabe$ Vorgabe im Eingabefeld (erscheint bei Aufruf der Maske)
intervall$ Zeitintervall, das eingegeben werden kann.
(z.B. 12.00..14.45)
Ausgabe
keine
Beschreibung
Dieses Objekt ermoeglicht die Eingabe einer Zeitangabe.
Bespiel DEF_INPUT_TIME
Siehe
DEF_INPUT_DATE
DEF_INPUT
ΓòÉΓòÉΓòÉ 170. DEF_LIST ΓòÉΓòÉΓòÉ
Funktion
Definiert ein Listenobjekt
Syntax
DEF_LIST id_string,flag,x,y,xl,yl,cellwidth,cellheight
Eingabe
id_string Objektkennung
flag Definiert den Listentyp:
flag=0: Vertikale Liste
flag=1: Horizontale Liste
x,y x/y-Position der Liste im zugewiesenen Fenster
xl,yl Relative Breite/Hoehe der Liste
cellwidth Zellenbreite (nur bei horizontalen Listen)
cellheight Zellenhoehe (nur bei horizontalen Listen)
Ausgabe
keine
Beschreibung
Die Zellenbreite/hoehe ist nur bei einer horizontalen Listbox wichtig.
Bei einer vertikalen Listbox geben Sie fuer die beiden Variablen je-
weils den Wert Null vor.
Bespiel DEF_LIST
Siehe
DEF_COMBO
ΓòÉΓòÉΓòÉ 171. DEF_MAX_BUTTON ΓòÉΓòÉΓòÉ
Funktion
Definition eines Vergroesserungsdruckknopfs.
Syntax
DEF_MAX_BUTTON id_string
Eingabe
id_string Kennung des Objekts
Ausgabe
keine
Beschreibung
Dieses Objekt stellt ein Fenster auf Klick als Vollbild dar.
Bespiel DEF_MAX_BUTTON
Siehe
DEF_MIN_BUTTON
ΓòÉΓòÉΓòÉ 172. DEF_MIN_BUTTON ΓòÉΓòÉΓòÉ
Funktion
Definition eines Verkleinerungsdruckknopfs.
Syntax
DEF_MIN_BUTTON id_string
Eingabe
id_string Kennung des Objekts
Ausgabe
keine
Beschreibung
Dieses Objekt reduziert ein Fenster durch Klick auf ICON-Groesse.
Bespiel DEF_MIN_BUTTON
Siehe
DEF_MAX_BUTTON
ΓòÉΓòÉΓòÉ 173. DEF_NUMBER ΓòÉΓòÉΓòÉ
Funktion
Erstellt eine Eingabemaske fuer eine Zahl.
Syntax
DEF_NUMBER id_zahl ,x,y,len,vorgabe$, bereich ; flags
Eingabe
id_zahl Objektkennung
x,y x/y-Position der Maske im zugewiesenen Fenster
len maximale Eingabelaenge fuer das Objekt
vorgabe Vorgabezahl (erscheint bei Aufruf der Maske)
bereich Auf dem Bildschirm angezeigte Objektlaenge
Ausgabe
keine
Beschreibung
Hiermit wird eine Numerische-Eingabemaske erstellt.
Es wird ein Objekt mit der in wert vorgegebenen Laenge erstellt.
commas Es werden Kommas und Punkt fБr Trennung
von Dezimal und Tausender-Stellen verwendet
(Verwendung wie Einstellung des Systems)
currency WДhrungssymbol wird mit angezeigt.
decimal x x=0..6 Anzahl der Nachkommastellen
percent Zeigt Zahl mit Prozentzeichen
scientific Zeigt Zahl in wissenschaftlicher Form (z.B. 10 E+10)
Bespiel DEF_NUMBER
Siehe
DEF_INPUT_DATE
DEF_INPUT_TIME
DEF_INPUT
ΓòÉΓòÉΓòÉ 174. DEF_PALETTE ΓòÉΓòÉΓòÉ
Funktion
Eine Farbpalette"Farbpalette" ~ wird definiert.
Syntax
DEF_PALETTE nr, fv, fh
Eingabe
nr Kennummer der Farbpalette
fv Codenummer der gewuenschten Vordergrundfarbe
fh Codenummer der gewuenschten Hintergrundfarbe
Ausgabe
keine
Beschreibung
Mit diesem Befehl definieren Sie eine Farbpalette mit je einer
selektierten Vordergrund- und Hintergrundfarbe. Die Codenummern
fuer die entsprechenden Farben entnehmen Sie bitte der Farbtabelle
im Anhang dieses Buches. ueber Farbpaletten koennen Sie die Farbge-
bung von Objekten direkt von KIM aus steuern (normalerweise ueber-
nimmt diese Aufgabe das jeweilige Betriebssystem). Damit Objekte
mit den Farben der entsprechenden Palette versehen werden koennen,
muss ihnen das FLAG "COLOR ON" angefuegt werden.
Bespiel DEF_PALETTE
Siehe
COLOR_ITEM
ΓòÉΓòÉΓòÉ 175. DEF_POPUP_ITEM ΓòÉΓòÉΓòÉ
Funktion
Eine Popup-Element wird definiert.
Syntax
DEF_POPUP_ITEM id_string,text$
Eingabe
id_string Objektkennung
text$ Im Objekt zu erscheinender Text
Ausgabe
keine
Beschreibung
Ein Popup-Element kann nur einem Pulldown- oder Popupmenue
zugeordnet werden.
Bespiel DEF_POPUP_ITEM
Siehe
DEF_PULLDOWN_ITEM
ΓòÉΓòÉΓòÉ 176. DEF_POPUP_MENU ΓòÉΓòÉΓòÉ
Funktion
Eine Popup-Menue wird definiert.
Syntax
DEF_POPUP_MENU id_string,x,y
Eingabe
id_string Objektkennung
x,y Position des Objekts im zugewiesenen Fenster
Ausgabe
keine
Beschreibung
Hiermit erstellen Sie ein Pop-Up-Menue mit den ueber Pop-Up-item
zugewiesenen Menuepunkten (durch ADD_ITEM anzufuegen).
Bespiel DEF_POPUP_MENU
Siehe
DEF_POPUP_ITEM
ΓòÉΓòÉΓòÉ 177. DEF_PROMPT ΓòÉΓòÉΓòÉ
Funktion
Definition einer Ausgabemarke
Syntax
DEF_PROMPT id_string, x, y, "Text A",...
Eingabe
id_string Kennung des Objekts
x, y Position der Marke im zugewiesenen Fenster
"Text A" Ausgabetext
Ausgabe
keine
Beschreibung
Mit diesem Objekttyp wird ein Textobjekt definiert, das nicht
selektierbar ist. Dieser Befehl wird benutzt, um Text im Fenster
darzustellen (z.B. als Feldbezeichnung).
Es gibt nun die MФglichkeit an einen DEF_PROMPT Ausgabe eine bestimmte
Menge von Leerzeichen anzuhДngen.
Definieren Sie die numerische Variable DEF_PROMPT_LEN.
Weisen Sie dieser Variable die Anzahl der Leerzeichen zu.
Der Wert -1 bedeutet, daс die DEF_PROMPT Routine vom Betriebssystem
genutzt wird.
Bespiel DEF_PROMPT
Siehe
ΓòÉΓòÉΓòÉ 178. DEF_PULLDOWN_ITEM ΓòÉΓòÉΓòÉ
Funktion
Eine Pulldown-Element wird definiert.
Syntax
DEF_PULLDOWN_ITEM id_string,text$[,flag]
Eingabe
id_string Objektkennung
text$ Im Objekt zu erscheinender Text
flag Gilt nur unter DOS. Besitzt das Menue noch Unterpunkte,
muss flag=1 sein. Ansonsten geben Sie flag=0 ein.
Ausgabe
keine
Beschreibung
Ein Pulldown-Element wird nur einem Pulldown- oder Popupmenue zugeordnet.
Bespiel DEF_PULLDOWN_ITEM
Siehe
DEF_POPUP_ITEM
ΓòÉΓòÉΓòÉ 179. DEF_PULLDOWN_MENU ΓòÉΓòÉΓòÉ
Funktion
Eine Pulldown-Menue wird definiert.
Syntax
DEF_PULLDOWN_MENU id_string,level
Eingabe
id_string Objektkennung
level Position des Menues im Menuebalken beim Start
Ausgabe
keine
Beschreibung
Ein Pulldown-Menue erscheint in der Regel am oberen Fensterrand.
Es enthaelt als Menuepunkte die definierten und ueber ADD_ITEM
zugefuegten Pulldown-Items.
Bespiel DEF_PULLDOWN_MENU
Siehe
DEF_PULLDOWN_ITEM
ΓòÉΓòÉΓòÉ 180. DEF_SCROLLBAR ΓòÉΓòÉΓòÉ
Funktion
Definiert einen Schieberegler zum schnellen Durchlaufen eines
Textfensters.
Syntax
DEF_SCROLLBAR id_string,flag,x,y,len,height
Eingabe
id_string Objektkennung
flag Legt den Typ des Scrollbars"Scrollbars" ~ fest:
flag = 0: Horizontaler Balken
flag = 1: Vertikaler Balken
flag = 2: Balkenecke
x,y x/y-Position des Balkens im zugewiesenen Fenster
len Laenge des Balkens
height Hoehe des Balkens
Ausgabe
keine
Beschreibung
Wenn Sie die Balken an den raendern des zugewiesenen Fensters anzeigen
moechten, geben sie einfach fuer die Variablen x, y, len und height
jeweils den Wert Null an.
Bespiel DEF_SCROLLBAR
Siehe
ΓòÉΓòÉΓòÉ 181. DEF_SLIDER ΓòÉΓòÉΓòÉ
Funktion
Es wir ein Sliderobjekt definiert. (dt. SLIDER = bewegender Balken)
Syntax
DEF_SLIDER id_string,x,y,len,update
Eingabe
id_string Objektkennung
x,y x/y-Position des Objekts im zugewiesenen Fenster
len Laenge des Objekts
update Anzahl der Prozentschritte, bis der Balken auf 100% ist
Ausgabe
keine
Beschreibung
Dieses Objekt wird genutzt, um eine fortschreitende Taetigkeit am
Bildschirm graphisch darzustellen (z.B. Formatieren von Disketten).
Bespiel DEF_SLIDER
Siehe
ΓòÉΓòÉΓòÉ 182. DEF_SPIN ΓòÉΓòÉΓòÉ
Funktion
************************ UNBEKANNT **********************
Syntax
Eingabe
Ausgabe
Beschreibung
************************ UNBEKANNT **********************
Bespiel DEF_SPIN
Siehe
ΓòÉΓòÉΓòÉ 183. DEF_STATUSBAR ΓòÉΓòÉΓòÉ
Funktion
Syntax
DEF_STATUSBAR "id" , hoehe
Eingabe
"id" Objektkennung
hoehe Zeilenzahl fuer die Statusbar
Ausgabe
Beschreibung
Definiert eine Statuszeile am unteren Fensterrand.
An die Statuszeile kФnnen folgende Objekte addiert
werden:
String-, Datums-, Zeit- und Nummernfelder.
Weiterhin kФnnen Buttons und Icons addiert werden.
Die Statuszeile dient als Meldefenster und liefert
keine RБckgabewerte.
Bespiel DEF_STATUSBAR
Siehe
DEF_TOOLBAR
DEF_WINDOW
DEF_WINDOW_ST
ΓòÉΓòÉΓòÉ 184. DEF_STRING ΓòÉΓòÉΓòÉ
Funktion
Erstellt eine Eingabemaske fuer einen Text.
Syntax
DEF_STRING id_string,x,y,eingabelaenge, text, anzeigelaenge
Eingabe
id_string Objektkennung
x,y x/y-Position der Maske im zugewiesenen Fenster
eingabelaenge maximale Eingabelaenge fuer das Objekt
text Vorgabetext (erscheint bei Aufruf der Maske)
anzeigelaenge Auf dem Bildschirm angezeigte Objektlaenge, und
muс kleiner als {eingabelaenge} sein.
Ausgabe
keine
Beschreibung
Hiermit wird eine Text-Eingabemaske erstellt. Es erfolgt aber keine
automatische Formatierung wie bei DEF_INPUT. Es wird nur ein Objekt
mit der in wert vorgegebenen Laenge erstellt. Sollte die maximale
Eingabelaenge (ueber LEN definiert) laenger sein als dieser Wert, so
wird der Objektinhalt gegebenenfallls durch das Eingabefeld gescrollt.
Bespiel DEF_STRING
Siehe
DEF_INPUT_DATE
DEF_INPUT_TIME
DEF_INPUT
DEF_NUMBER
ΓòÉΓòÉΓòÉ 185. DEF_SYSTEM_BUTTON ΓòÉΓòÉΓòÉ
Funktion
Definition eines Systemdruckknopfs.
Syntax
DEF_SYSTEM_BUTTON id_string, Flag
Eingabe
id_string Kennung des Objekts
Flag Art des Systemmenues:
flag = 0: Automatische Definition der Menuepunkte.
flag <>0: Menuepunkte sind noch nicht definiert.
Ausgabe
keine
Beschreibung
Das Objekt Systembutton dient dazu, die Operationen fuer ein Fenster
(z.B. Groesse, Verschieben, Verkleinern, Schlie_en) ueber ein Popup-
Menue aufzurufen. Das Objekt befindet sich immer in der linken oberen
Ecke eines Fensters. Mit einen Doppelklick auf dem Systembutton
schliesst man das Fenster.
Bespiel DEF_SYSTEM_BUTTON
Siehe
ΓòÉΓòÉΓòÉ 186. DEF_TABLE ΓòÉΓòÉΓòÉ
Funktion
************************ UNBEKANNT **********************
Syntax
Eingabe
Ausgabe
Beschreibung
************************ UNBEKANNT **********************
Bespiel DEF_TABLE
Siehe
ΓòÉΓòÉΓòÉ 187. DEF_TABLE_REC ΓòÉΓòÉΓòÉ
Funktion
************************ UNBEKANNT **********************
Syntax
Eingabe
Ausgabe
Beschreibung
************************ UNBEKANNT **********************
Bespiel DEF_TABLE_REC
Siehe
ΓòÉΓòÉΓòÉ 188. DEF_TEXT ΓòÉΓòÉΓòÉ
Funktion
Eingabe mehrerer Zeilen Text.
Syntax
DEF_TEXT id_string, x,y,breite,hoehe,anzahl,array
Eingabe
id_string Objektidentifikation
x,y x-y Position des Objektes
breite,hoehe Breite/Hoehe des Objekts
anzahl Anzahl der Bytes der Eingabe
array Zeichenketten array mit Vorgabe fuer den Inhalt
Ausgabe
keine
Beschreibung
Mit diesem Befehl definieren Sie eine Texteingabebox. Die max.
zulaessigen Eingabezeichen betragen 64 KB pro Textbox. Die Editier-
funktionen in der Textbox entsprechen den Funktionen der Zwischen-
ablage unter Windows oder dem Systemeditor unter OS/2.
Bespiel DEF_TEXT
Siehe
ΓòÉΓòÉΓòÉ 189. DEF_TITEL ΓòÉΓòÉΓòÉ
Funktion
Definition eines Titels fuer ein Fenster etc.
Syntax
DEF_TITEL Id_string, "Titel"
Eingabe
Id_string Kennung fuer Objekt
"Titel" ueberschrift
Ausgabe
keine
Beschreibung
Es wird ein Objekt definiert, welches einem anderen Objekt
eine Ueberschrift hinzufuegt.
Bespiel DEF_TITEL
Siehe
DEF_WINDOW
ΓòÉΓòÉΓòÉ 190. DEF_TOOLBAR ΓòÉΓòÉΓòÉ
Funktion
Definition einer Objektleiste fuer Push-Buttons
Syntax
DEF_TOOLBAR Id_string, x, y, xr, yr
Eingabe
Id_string Kennung des Objekts
x, y Position des linken oberen Ecks des Objekts im Fenster
xr, yr Laenge und Breite der Toolbar
Ausgabe
Beschreibung
Eine Toolbar wird direkt unter dem oberen Fensterrand angeordnet.
Es koennen mehrere Toolbar-Objekte an ein Fenster angefuegt werden.
Objekte, die an ein Toolbar-Objekt angefuegt werden, werden auto-
matisch in das Toolbar-Objekt eingepasst.
Bespiel DEF_TOOLBAR
Siehe
DEF_STATUSBAR
ΓòÉΓòÉΓòÉ 191. DEF_WINDOW ΓòÉΓòÉΓòÉ
Funktion
Definition eines Fensters
Syntax
def_window id_string, x, y, xr, yr [,icon,icontext,timerwert]
Eingabe
id_string Kennung des Objekts (max. 50 Zeichen)
x, y linke x, y Position des Fensters auf dem Monitor
xr, yr Relative Groesse des Fensters (Laenge/Breite)
icon Name eines aus einer Dat-Datei
icontext Text des Fensters bei SymbolgrФсe.
timerwert Anzahl Ticks, wann Timerevent aufgerufen wird.
Ausgabe
keine
Beschreibung
Definiert ein Fensterobjekt. Diesem Objekt muessen aber noch weitere
Objekte wie Fensterrand, Systembutton und Titel zugeordnet werden,
um ein funktionsfaehiges Fenster zu erhalten. Dabei ist die Reihenfolge
der Unterobjekte wichtig.
TIMER-Funktion :
Als Beispiel siehe TIMER.KIM.
Unter KIM ist es nun mФglich in einen bestimmten Intervall auf ein
Ereignis zu reagieren. HierfБr wurde der Befehl DEF_WINDOW erweitert.
Als Zeitintervall dient ein Tick. (18.2 Ticks in der Sekunde)
Wird der Zeitwert erreicht, wird die Funktion id_string_timer()
aufgerufen. Die Timerfunktion kann man Бber
EVENT_ON_ITEM id_string,"timer off" ausschalten und Бber
EVENT_ON_ITEM id_string,"timer on" anschalten.
ICON-Funktion :
Wenn ein Fenster auf SymbolgrФсe verkleinert wird, kann man ein Icon aus
einer DAT-Datei angeben. Dieses wird mit dem entsprechenden <iconText>
dargestellt.
Bespiel DEF_WINDOW
Siehe
DEF_WINDOW_ST
ΓòÉΓòÉΓòÉ 192. DEF_WINDOW_ST ΓòÉΓòÉΓòÉ
Funktion
Erstellt ein Standardfenster mit System-, Maximierungs-,
Minimierungsbutton und Rahmen sowie Fensterueberschrift.
Syntax
DEF_WINDOW_ST id_string, x, y, xr, yr, titel$
Eingabe
id_string Bezeichnung des Fensters
x, y linke x, y Position des Fensters auf dem Monitor
xr, yr Relative Groesse des Fensters (Laenge/Breite)
titel$ ueberschrift des Fensters
Ausgabe
keine
Beschreibung
Es wird ein Fenster mit obigen Objekten erstellt, ohne dass diese
gesondert hinzugefuegt werden muessen. Dadurch verlieren Sie aber
die Moeglichkeit der individuellen Erstellung eines Fensters.
Bespiel DEF_WINDOW_ST
Siehe
DEF_WINDOW
ΓòÉΓòÉΓòÉ 193. DESTROY ΓòÉΓòÉΓòÉ
Funktion
Loescht allle Elemente eines Objekts.
Syntax
DESTROY "id"
Eingabe
"id" Objekt
Ausgabe
nil
Beschreibung
Alle Objekte einer Liste werden gelФscht. Dabei ist "id" die
Objekt-ID der Liste.
Achtung !
---------
Wenn Elemente eines Objekts (z.B. Liste) gelФscht werden,
dann kФnnen diese Elemente nicht mehr an ein Objekt addiert
werden, ohne das Sie vorher neu deklariert wurden. (DEF_...)
Wird dies trotzdem versucht, erhalten Sie eine Systemfehler-
meldung.
Bespiel DESTROY
Siehe
ΓòÉΓòÉΓòÉ 194. DRAWTEXT ΓòÉΓòÉΓòÉ
Funktion
Erstellt einen Text im Graphikmodus.
Syntax
DRAWTEXT id_string, x, y, fcolor, hcolor, fill, width, xor, fontname
Eingabe
id_string Kennung des Objekts
x,y Position der linken oberen Objektecke auf dem Bildschirm
fcolor Nummer der Farbe der Textlinien (aus Farbpalette)
hcolor Nummer der Fnllfarbe fuer das Objekt (aus Farbpalette)
fill Angabe, ob das Objekt ausgefuellt werden soll:
fill=1: Objekt wird gefuellt
fill=0: Objekt bleibt leer
width Strichdicke der Objektlinien
xor Angabe, ob sich das Objekt von gleichfabrigem
Hintergrund abheben soll:
xor=1: ja
xor=0: nein
fontname Name des zu verwendenen Textfonts (""=Systemfont)
Ausgabe
keine
Beschreibung
Es kann ein Text im Graphikmodus erstellt werden. Dieser ist flexibler
zu bearbeiten und kann daher zur optischen Verschoenerung Ihrer Ober-
flaeche herangezogen werden. Unter OS/2 besitzen Sie die Moeglichkeit,
einen zuvor ueber LOADFONT geladenenen Textfont anstelle des System-
fonts des Betriebssystemes zu verwenden. Das Graphikobjekt verschwindet
bei einer Fensteraktualisierung (Repositionierung, Neuzeichnung) und
muss dann manuell neu erstellt werden.
Bespiel DRAWTEXT
Siehe
ΓòÉΓòÉΓòÉ 195. ELLIPSE ΓòÉΓòÉΓòÉ
Funktion
Zeichnet eine Ellipse auf dem Bildschirm.
Syntax
ELLIPSE id,x,y, sW, eW, xR, yR, fcolor, hcolor, fill, width, xor
Eingabe
id Kennung des Objekts
x,y Position der linken oberen Objektecke auf dem Bildschirm
sW Winkelwert, bei dem das Objekt beginnen soll
eW Winkelwert, bei dem das Objekt enden soll
xR Objektradius in Richtung der x-Koordinate
yR Objektradius in Richtung der y-Koordinate
fcolor Nummer der Farbe der Objektlinien (aus Farbpalette)
hcolor Nummer der Fuellfarbe fuer das Objekt (aus Farbpalette)
fill Angabe, ob das Objekt ausgefuellt werden soll:
fill=1: Objekt wird gefuellt;
fill=0: Objekt bleibt leer
width Strichdicke der Objektlinien
xor Angabe, ob sich das Objekt von gleichfabrigem Hintergrund
abheben soll: xor=1: ja; xor=0: nein
Ausgabe
keine
Beschreibung
Es kann eine Ellipse, ein Kreis oder ein Teil von diesen Objekten
erstellt werden:
xRadius=yRadius, startAngle=0, endAngle=360: Vollkreis
xRadius<>yRadius, startAngle=0, endAngle=360: Vollellipse
xRadius=yRadius, startAngle=0, endAngle<>360: Teil eines Kreises
xRadius<>yRadius, startAngle=0, endAngle<>360: Teil einer Ellipse
Das Graphikobjekt verschwindet bei einer Fensteraktualisierung
(Repositionierung, Neuzeichnung) und muss dann manuell neu erstellt
werden.
Bespiel ELLIPSE
Siehe
ΓòÉΓòÉΓòÉ 196. FIND_ITEM ΓòÉΓòÉΓòÉ
Funktion
Such nach Objekten
Syntax
FIND_ITEM
Eingabe
Ausgabe
Beschreibung
************************ UNBEKANNT **********************
Bespiel FIND_ITEM
Siehe
ΓòÉΓòÉΓòÉ 197. GET_COUNT ΓòÉΓòÉΓòÉ
Funktion
Anzahl von Objekten ermitteln.
Syntax
GET_COUNT id_string,anzahl
Eingabe
id_string Objektkennung
Ausgabe
anzahl Anzahl der Objekte
Beschreibung
Ermittelt die Anzahl der Elemente in einem Fenster, Listbox oder Combobox.
Wird die Funktion auf ein Objekt ohne Listeigenschaft angewendet,
erhДlt man den Wert -1 als RБckgabe.
Bespiel GET_COUNT
Siehe
ADD_ITEM_ARRAY
GET_ITEM_ARRAY
SUB_ITEM
SUB_ITEM_ARRAY
ΓòÉΓòÉΓòÉ 198. GET_ITEM ΓòÉΓòÉΓòÉ
Funktion
Inhalt eines Objekts wird gelesen.
Syntax
GET_ITEM id_string,inhalt$ [,index]
Eingabe
id_string Objektkennung
index Position in einer Combobox oder Liste
Ausgabe
inhalt$ Variable, welcher der Inhalt des Objekts uebergeben wird
Beschreibung
Sie koennen hiermit den Inhalt eines Objekts ermitteln.
Es ist mФglich den Inhalt des n-ten Element einer Listbox oder Combox
zu ermitteln. ( Ab Basis 1 )
Bespiel GET_ITEM
Siehe
ADD_ITEM_ARRAY
GET_ITEM_ARRAY
SUB_ITEM
SUB_ITEM_ARRAY
ΓòÉΓòÉΓòÉ 199. GET_ITEM_ARRAY ΓòÉΓòÉΓòÉ
Funktion
Aus Gruppe von Objekten wird der Inhalt ausgelesen.
Syntax
GET_ITEM_ARRAY id_string,array,start,ende
Eingabe
id_string Objektkennung(gilt hier fuer IDstart bis IDende)
array Feldarray mit Werten fuer IDstart...IDende
start Erstes zu fuellendes Feld im Array
ende Letztes zu fuellendes Feld im Array
Ausgabe
keine
Beschreibung
Wird genutzt, um mehrere Werte schnell aus einem Objektarray auszulesen.
Bespiel GET_ITEM_ARRAY
Siehe
SET_ITEM_ARRAY
ΓòÉΓòÉΓòÉ 200. GET_ITEM_XY ΓòÉΓòÉΓòÉ
Funktion
Ermittelt die exakte Position eines Objekts auf der Oberflaeche.
Syntax
GET_ITEM_XY id_string$, x, y, breite, hoehe
Eingabe
id_string$ Kennung des zu ueberpruefenden Objekts
Ausgabe
x,y Variablen mit x- und y-Werten fuer die linke
obere Objektecke
breite Variable mit der Objektbreite
hoehe Variable mit der Objekthoehe
Beschreibung
Die Anweisung dient zur exakten Bestimmung der Position eines Objektes.
Die Werte werden in normalen Koordinaten zurueckgegeben (nicht in Pixel-
koordinaten).
Bespiel GET_ITEM_XY
Siehe
ΓòÉΓòÉΓòÉ 201. GETCLIP ΓòÉΓòÉΓòÉ
Funktion
GETCLIP liest den Inhalt des Clipboards
Syntax
GETCLIP var$
Eingabe
Ausgabe
var$ Variable in die, der Inhalt geschrieben wird.
Beschreibung
FБr das Lesen des Clipboardinhalts sollten Sie
eine Memovariable benutzen, da andere Variablen
auf 255 Zeichen beschrДnkt sind !
Bespiel GETCLIP
Siehe
SETCLIP
ΓòÉΓòÉΓòÉ 202. LINE ΓòÉΓòÉΓòÉ
Funktion
Zeichnet eine Linie auf dem Bildschirm.
Syntax
LINE id,x,y, xr, yr, color, width
Eingabe
id Kennung des Objekts
x,y Position des Anfangspunktes der Linie
xr, yr Position des Endpunktes der Linie
color Nummer der Fnllfarbe fuer das Objekt (aus Farbpalette)
width Strichdicke der Objektlinie
Ausgabe
keine
Beschreibung
Es kann eine Linie erstellt werden. Das Graphikobjekt geht bei
jeder Fensteraktualisierung (Repositionierung, Neuzeichnung)
verloren und muss dann manuell neu definiert werden.
Bespiel LINE
Siehe
ELLIPSE
ΓòÉΓòÉΓòÉ 203. LOAD_DAT ΓòÉΓòÉΓòÉ
Funktion
Es wird eine Objekt-Bibliothek geladen.
Syntax
LOAD_DAT datei, a
Eingabe
datei Name der zu ladenden Datei, Pfadangabe moeglich.
Ausgabe
a Variable, die das Ergebnis des Vorgangs enthaelt:
a=1: ok
a=-1: Datei nicht gefunden.
Beschreibung
Es wird eine Objekt-Bibliothek geladen. Eine Objekt-Bibliothek
beinhaltet mehrere Objekte wie Comboboxen, ICONS, STRINGEINGABEN usw..
Bespiel LOAD_DAT
Siehe
ΓòÉΓòÉΓòÉ 204. LOAD_FROM_DAT ΓòÉΓòÉΓòÉ
Funktion
************************ UNBEKANNT **********************
Syntax
LOAD_FROM_DAT datei, ???
Eingabe
datei Name der zu ladenden Datei, Pfadangabe moeglich.
Ausgabe
Beschreibung
************************ UNBEKANNT **********************
Bespiel LOAD_FROM_DAT
Siehe
STORE_IN_DAT
ΓòÉΓòÉΓòÉ 205. LOADFONT ΓòÉΓòÉΓòÉ
Funktion
Definiert einen neuen Textfont.
Syntax
LOADFONT id_string$, fontname$, size
Eingabe
id_string$ Kennung des Fontobjekts
fontname$ Name des gewuenschten Textfonts
size Groesse des gewuenschten Textfonts
Ausgabe
keine
Beschreibung
Mit diesem Befehl wird ein neuer Textfont definiert.
Zur Auswahl stehen beispielsweise unter OS/2 folgende
Fonts in folgenden Groessen:
TMS RMN 8,10,12,14,18,24
HELV 8,10,12,14,18,24
COURIER 8,10,12
SYSTEM MONOSPACE 10
Weitere zur Verfuegung stehende Fonts entnehmen Sie bitte
ihren Handbuechern zum entsprechenden Betriebssystem.
Um einen Objekt den so definierten Textfont zuzuweisen,
muessen Sie die id-Kennung des Fontobjekts als FLAG an den
Definitionsbefehl fuer das entsprechende Objekt anfuegen.
Bespiel LOADFONT
Siehe
ΓòÉΓòÉΓòÉ 206. MSGBOX ΓòÉΓòÉΓòÉ
Funktion
Erstellt ein MeldungsfensterMeldungsfenster mit entsprechenden Buttons.
Syntax
MSGBOX text$, flag, rueck, Iconname
Eingabe
text$ Text, der im MeldungsfensterMeldungsfenster erscheinen soll
flag Definiert die Art und Anzahl der Kontrollschalter:
flag=1: Es werden sowohl ein OK- als auch ein ABBRUCH- Button automatisch erstellt
flag=0: Es wird nur ein OK-Button definiert
Iconname Name des Icons aus der DAT-Datei, welches in das Fenster
eingefuegt werden soll.
Ausgabe
rueck Gibt dem Programm zurueck, welcher Button gedrueckt wurde:
rueck=1: Der OK-Button wurde gedrueckt
rueck=2 DER ABBRUCH-Button wurde betaetigt
Beschreibung
Mit diesem Befehl erstellen Sie ein Meldungsfenster. Dieses ist bereits
vorgefertigt. Sie fuegen lediglich den entsprechenden Meldungstext ueber
text$ sowie falls gewnuescht ueber Iconname ein Icon aus einer DAT-Datei
ein. Des weiteren koennen Sie festlegen, ob nur ein OK-Button oder ein
OK- und ein ABBRUCH-Button erzeugt werden soll.
Bespiel MSGBOX
Siehe
ΓòÉΓòÉΓòÉ 207. RECTANGLE ΓòÉΓòÉΓòÉ
Funktion
Zeichnet ein Viereck auf dem Bildschirm.
Syntax
RECTANGLE id,x,y, xr, yr, fcolor, hcolor, fill, width, xor
Eingabe
id Kennung des Objekts
x,y Position der linken oberen Objektecke auf dem Bildschirm
xr Breite des Vierecks
yr Hoehe des Vierecks
fcolor Nummer der Farbe der Objektlinien (aus Farbpalette)
hcolor Nummer der Fnllfarbe fuer das Objekt (aus Farbpalette)
fill Angabe, ob das Objekt ausgefuellt werden soll:
fill=1: Objekt wird gefuellt;
fill=0: Objekt bleibt leer
width Strichdicke der Objektlinien
xor Angabe, ob sich das Objekt von gleichfabrigem
Hintergrundabheben soll:
xor=1: ja
xor=0: nein
Ausgabe
keine
Beschreibung
Es kann ein Rechteck oder ein Quadrat erstellt werden:
xr=yr: Quadrat
xr<>yr: Rechteck
Das Graphikobjekt geht bei jeder Fensteraktualisierung (Repositionierung,
Neuzeichnung) verloren und muss dann manuell neu definiert werden.
Bespiel RECTANGLE
Siehe
ΓòÉΓòÉΓòÉ 208. SEARCH_MLE ΓòÉΓòÉΓòÉ
Funktion
Syntax
SEARCH_MLE id$,suchtext$,mark,case,start,zeile$,pos
Eingabe
id$ ID eines DEF_TEXT Objekts
suchtext$ Text der gesucht wird
mark 0 = gefundenen Text markieren
1 = Text nicht markieren
case 0 = Groс/Kleinschreibung beachten
1 = nicht beachten
start -1 = aktuelle Cursorposition
sonst Position
zeile$ Aktuelle Zeile nach Suche
pos Aktuelle Position nach Suche
wird -1 Бbergeben vor Suchbeginn, dann erfolgt
nur eine Suche ohne jeweilige Textpositionierung
Ausgabe
keine
Beschreibung
keine
Bespiel SEARCH_MLE
Siehe
ΓòÉΓòÉΓòÉ 209. SET_ITEM ΓòÉΓòÉΓòÉ
Funktion
Ein Text /Wert wird einem Objekt zugeordnet.
Syntax
SET_ITEM id_string,text$
Eingabe
id_string Objektkennung
text$ Zuzuordnender Text
Ausgabe
keine
Beschreibung
Ein beliebiger Text kann einem geeigneten Objekt zugewiesen werden.
Bespiel SET_ITEM
Siehe
SET_ITEM_ARRAY
SET_ITEM_STATUS
ΓòÉΓòÉΓòÉ 210. SET_ITEM_ARRAY ΓòÉΓòÉΓòÉ
Funktion
Einer Gruppe von Objekten wird ein Inhalt zugewiesen.
Syntax
SET_ITEM_ARRAY id_string,array,start,ende
Eingabe
id_string Objektkennung(gilt hier fuer IDstart bis IDende)
array Feldarray mit Werten fuer IDstart...IDende
start Erstes zu fuellendes Feld im Array
ende Letztes zu fuellendes Feld im Array
Ausgabe
keine
Beschreibung
Wird genutzt, um mehrere Werte schnell einem Objektarray zuzuordnen.
Bespiel SET_ITEM_ARRAY
Siehe
SET_ITEM
SET_ITEM_STATUS
ΓòÉΓòÉΓòÉ 211. SET_ITEM_STATUS ΓòÉΓòÉΓòÉ
Funktion
Der Status eines Objekts wird veraendert.
Syntax
SET_ITEM_STATUS id_string, status,...
Eingabe
id_string Objektkennung
status Variable mit zuzuweisendem Statusflag
Ausgabe
keine
Beschreibung
Veraendert oder setzt den Status eines Objekts durch Hinzufuegen oder
Entfernen eines FLAGS.
Bespiel SET_ITEM_STATUS
Siehe
SET_ITEM
SET_ITEM_ARRAY
ΓòÉΓòÉΓòÉ 212. SETCLIP ΓòÉΓòÉΓòÉ
Funktion
SETCLIP schreibt den Inhalt von var$ in das Clipboard
Syntax
SETCLIP var$
Eingabe
var$ Variable aus der, der Inhalt gelesen wird.
Ausgabe
Beschreibung
Bespiel SETCLIP
Siehe
GETCLIP
ΓòÉΓòÉΓòÉ 213. SETFOCUS ΓòÉΓòÉΓòÉ
Funktion
Steuert die Reihenfolge von Eingabefeldern.
Syntax
SETFOCUS "id"
Eingabe
"id" Objektkennung
Ausgabe
Beschreibung
Mit diesem Befehl kann der Cursor auf ein Eingabefeld
gesetzt werden.
Beispiel: Ein Datensatz wurde geДndert, der Benutzer
speichert die Оnderung, hat jedoch in einem Feld einen
falschen Wert eingetragen. Nun wird der Cursor auf das
Objekt gestellt.
Bespiel SETFOCUS
Siehe
ΓòÉΓòÉΓòÉ 214. STORE_IN_DAT ΓòÉΓòÉΓòÉ
Funktion
************************ UNBEKANNT **********************
Syntax
STORE_IN_DAT
Eingabe
Ausgabe
************************ UNBEKANNT **********************
Beschreibung
Bespiel STORE_IN_DAT
Siehe
LOAD_FROM_DAT
ΓòÉΓòÉΓòÉ 215. SUB_ITEM ΓòÉΓòÉΓòÉ
Funktion
Ein Element wird von einem Objekt entfernt.
Syntax
SUB_ITEM "id1","id2"
Eingabe
"id1" Master-Objektkennung
"id2" Slave-Objektkennung
Ausgabe
keine
Beschreibung
Umgekehrte Funktion von ADD_ITEM !
Bespiel SUB_ITEM
Siehe
ADD_ITEM
ADD_ITEM_ARRAY
SUB_ITEM_ARRAY
ΓòÉΓòÉΓòÉ 216. SUB_ITEM_ARRAY ΓòÉΓòÉΓòÉ
Funktion
Entfernt ein Array von Elementen von einen Objekt
Syntax
SUB_ITEM_ARRAY "id","entfernen",von,bis
Eingabe
"id" Mutterobjekt
"entfernen Kindobjekt
von Erstes Objekt (Zahl)
bis Letztes Objekt (Zahl)
Ausgabe
keine
Beschreibung
Mit diesem Befehl entfernen Sie schnell mehrere Objekt
von einem Objekt.
Bespiel SUB_ITEM_ARRAY
Siehe
ΓòÉΓòÉΓòÉ 217. TEXTHEIGHT ΓòÉΓòÉΓòÉ
Funktion
Ermittelt die maximale Hoehe eines in ein Objekt passendes Textfonts.
Syntax
TEXTHEIGHT id_string$, text$, hoehe
Eingabe
id_string$ Kennung des zu ueberpruefenden Objekts
text$ Variable mit der zur ueberpruefung verwendeten Zeichenkette
Ausgabe
hoehe Variable mit dem ermittelten Fontwert
Beschreibung
Dieser Befehl dient zur Ermittlung des maximal in ein Objekt passenden
Textfonts. Als Ueberpruefungszeichenkette gibt man in text$ am besten
"Tyg" vor.
Bespiel TEXTHEIGHT
Siehe
TEXTWIDTH
ΓòÉΓòÉΓòÉ 218. TEXTWIDTH ΓòÉΓòÉΓòÉ
Funktion
Ermittelt die maximale Breite eines in ein Objekt passendes Textfonts.
Syntax
TEXTWIDTH id_string$, text$, breite
Eingabe
id_string$ Kennung des zu ueberpruefenden Objekts
text$ Variable mit der zur ueberpruefung verwendeten
Zeichenkette.
Ausgabe
breite Variable mit dem ermittelten Fontwert
Beschreibung
Dieser Befehl dient zur Ermittlung des maximal in ein Objekt passenden
Textfonts. Als Ueberpruefungszeichenkette gibt man in text$ am besten
"Tyg" vor.
Bespiel TEXTWIDTH
Siehe
TEXTHEIGHT
ΓòÉΓòÉΓòÉ 219. WINSENTMSG ΓòÉΓòÉΓòÉ
Funktion
Alle Funktionen unter OS/2 werden Бber Nachrichten gesteuert.
Mit diesem Befehl besteht die MФglichkeit eine Nachricht an ein
Objekt zu schicken.
Syntax
WINSENTMSG id$,MessageID,param1,param2,rueck
Eingabe
id$ Objekt-ID$
MessageID Beispiel : MLM_SETBACKCOLOR = 468
param1/param2 Parameter, kФnnen Zahlen oder Strings sein.
Bei Zahlen sollte man den Wert in einer Variablen
Бbergeben, wenn er negativ ist z.b -1
Ausgabe
rueck RБckgabewert
Beschreibung
Verschiedene Nachrichten liefern als RБckgabewert, Zeiger auf
Stringfelder. So ein RБckgabetyp kann noch nicht verarbeitet
werden. Wichtig ! Nachrichten kФnnen nur empfangen werden,
wenn das Objekt am Bildschirm ist (also Бber WIN_PAINT)
Bespiel WINSENTMSG
Siehe
ΓòÉΓòÉΓòÉ 220. XCONV ΓòÉΓòÉΓòÉ
Funktion
Umwandlung in Pixelkordinaten
Syntax
XCONV xpos, xpixelpos
Eingabe
xpos
Ausgabe
xpixelpos
Beschreibung
Ermittelt X-Position 0-80 als Pixelkoordinaten
Graphische Befehle
------------------
Koordinaten sind Pixelkoordinaten und kФnnen
Бber die Funktionen XCONV und YCON von normalen
Koordinaten in Pixelkoordinaten ermittelt werden.
werden. Ausgangssystem fБr das Pixelkoordinaten-
system ist die linke obere Ecke eines Fensters.
Diese Befehle haben den Nachteil, daс beim Neu-
zeichnen des Fensters, z.B durch eine VerДnderung
der GrФсe des Fensters, die Zeichnung nicht mehr
am Bildschirm ist. Ein Neuzeichnen muс manuell
durchgefБhrt werden.
Bespiel XCONV
Siehe
YCONV
ΓòÉΓòÉΓòÉ 221. YCONV ΓòÉΓòÉΓòÉ
Funktion
Umwandlung in Pixelkordinaten
Syntax
YCONV ypos, ypixelpos
Eingabe
ypos
Ausgabe
ypixelpos
Beschreibung
Ermittelt Y-Position 0-24 als Pixelkoordinaten
Bespiel YCONV
Siehe
XCONV
ΓòÉΓòÉΓòÉ 222. DEF_HEADER ΓòÉΓòÉΓòÉ
Funktion
************************ UNBEKANNT **********************
Syntax
Eingabe
Ausgabe
Beschreibung
************************ UNBEKANNT **********************
Bespiel DEF_HEADER
Siehe
ΓòÉΓòÉΓòÉ 223. DEF_NOTEBOOK ΓòÉΓòÉΓòÉ
Funktion
Mit dieser Funktion kann ein Notebook-Objekt definiert werden.
An ein Notebook-Objekt werden Fensterobjekte addiert.
Diese ergeben mit Ihren Ъberschriften die Notebook-Seiten.
Ein Notebook-Objekt wird dann zum Hauptfenster addiert.
Syntax
DEF_NOTEBOOK <id>
Eingabe
"id" Objektkennung
Ausgabe
Beschreibung
Ein Notebook-Objekt passt sich in das Hauptfenster
ein. Wechseln der Ordnerseiten erfolgt Бber die
Tastatur mit den Tasten am Zehnerblock: Bild hoch
und Bild runter. Wird die NUM-LOCK Taste einge-
schaltet, werden die Zahlen 9 und 3 wiedergegeben.
Bespiel DEF_NOTEBOOK
Siehe
DEF_WINDOW
DEF_WINDOW_ST
ΓòÉΓòÉΓòÉ 224. DUMMY_EVENT ΓòÉΓòÉΓòÉ
Funktion
Ein Eventmanager ohne Rueckgabewerte wird gestartet.
Syntax
Dummy_event
Eingabe
keine
Ausgabe
keine
Beschreibung
Diese Funktion kann zum Testen von Bildschirmausgaben dienen. Der
Befehl uebergibt die Steuerung an den WINDOW-MANAGER. Sobald das
letzte Fenster geschlossen ist, wird das Programm beendet.
Bespiel DUMMY_EVENT
Siehe
ΓòÉΓòÉΓòÉ 225. EVENT_ON_ITEM ΓòÉΓòÉΓòÉ
Funktion
Aendert den Zustand eines Objekts
Syntax
EVENT_ON_ITEM id_string,event$
Eingabe
id_string Objektkennung
event$ Event, welches ausgefuehrt werden soll.
Ausgabe
keine
Beschreibung
Ein Beispiel fuer einen Event ist das Neuzeichnen eines Objekts.
Events muessen klein geschrieben werden.
Beispiele fuer Events:
"current" Objekt wird aktuelles Objekt
"not_current" Gegenteil von "current"
"redisplay" Objekt wird neu gezeichnet
"select" Objekt erhaelt den Eingabefokus
"slider update",prozent Slider wird mit Prozentzahl neugezeichnet
"end" Fensterobjekt wird fuer beendet erklaert
"create" Mit diesem Event wird veranlasst, das ein
Objekt neu erstellt wird. Als Beispiel
mФchte ich die Combo-Box nennen. Es werden
Elemente an das Combo-Box-Objekt addiert
und entfernt. Damit das Objekt aktualisiert
wird, kann es Бber den Event "create" neu
erstellt werden.
Bespiel EVENT_ON_ITEM
Siehe
ADD_ITEM
SUB_ITEM
ΓòÉΓòÉΓòÉ 226. GET_ITEM_POS ΓòÉΓòÉΓòÉ
Funktion
Liefert aktuelles Objekt und Tastatur/Maus-Status zurueck.
Syntax
GET_ITEM_POS objektid_neu$,taste [,objektid_alt$]
Eingabe
keine
Ausgabe
objektid_neu$ Variable mit der Objektkennungdes neu selektierten
Elements
taste ASCII-Wert der gedrueckten Taste
objektid_alt$ Variable mit der Kennung des zuvor selektierten
Objekts
Beschreibung
Wenn ein Objekt mit der linken Maustaste selektiert wird, liefert der
Befehl die ID-Kennung des gewaehlten Objekts zurueck. Falls die linke
Maustaste gedrueckt wurde, wird in der Variablen <taste> der Wert 13
zurueckgegeben. Optional kann auch die Kennung des davor ausgewaehlten
Objekts abgefragt werden (z.B. um dieses nach vollzogener Operation
zu aktualisieren oder zu formatieren = LOST FOCUS). Wird in diesem
Fall der Wert taste=1 zurueckgegeben, so bedeutet dies, dass das alte
Objekt verlassen wurde und nicht mehr aktiviert ist.
Bespiel GET_ITEM_POS
Siehe
WIN_EV
ΓòÉΓòÉΓòÉ 227. GET_ITEM_STATUS ΓòÉΓòÉΓòÉ
Funktion
Ermittelt, ob ein Objekt einen bestimmten Status besitzt.
Syntax
GET_ITEM_STATUS id_string$, status$, ok
Eingabe
id_string$ Kennung des zu ueberpruefenden Objekts
status$ Variable mit dem Status, dessen Existenz ueberprueft
werden soll
Ausgabe
ok Flag mit dem Ergebnis der ueberpruefung:
ok=1: Der Status ist bei dem Objekt gesetzt
ok=-1: Der Status ist bei dem Objekt nicht gesetzt
Beschreibung
Es wird ueberprueft, ob ein Objekt einen bestimmten Status besitzt.
Wird bei Checkbox- oder Radiobuttons der Status "SET" angegeben,
so wird ueberprueft, ob der Button aktiviert ist.
Bespiel GET_ITEM_STATUS
Siehe
ΓòÉΓòÉΓòÉ 228. SET_KEYMAP ΓòÉΓòÉΓòÉ
Funktion
Liest eine Tastenkombination zur weiteren Verwendung in KIM ein.
Syntax
SET_KEYMAP key$, rueckgabenr,pos
Eingabe
key$ Einzulesende Tastenkombination
rueckgabenr Kennzahl der Tastenkombination (zwischen 10000 und 10010)
Ausgabe
pos Position der Tastenkombination in der Key-Tabelle
Beschreibung
Mit diesem Befehl koennen Sie zusaetzlich zu den in KIM vordefinierten
Tasten weitere Tasten oder Tastenkombinationen in eine Key-Tabelle
eintragen, von wo aus diese zur Verwendung in KIM (sie sind dann von
allen selektierbaren Objekten ansprechbar) zur Verfuegung stehen. Im
Anhang (Abs. 9.2.) finden Sie eine Liste aller einlesbaren Tasten und
genauere Erlaeuterungen zu diesem Befehl.
Bespiel SET_KEYMAP
Siehe
ΓòÉΓòÉΓòÉ 229. WAIT ΓòÉΓòÉΓòÉ
Funktion
Haelt das Programm fuer einen beliebigen Zeitraum an.
Syntax
WAIT anzahl
Eingabe
anzahl Anzahl der Sekunden, die das Programm warten soll
Ausgabe
Keine
Beschreibung
Sie koennen das Programm veranlassen, an der betreffenden Position im
Programmcode eine von Ihnen bestimmte Zeitspanne anzuhalten, ehe der
naechste Befehl bearbeitet wird. Diese Zeitspanne muessen Sie in
Sekunden angeben.
Bespiel WAIT
Siehe
ΓòÉΓòÉΓòÉ 230. WIN_EV ΓòÉΓòÉΓòÉ
Funktion
Aufruf des Event-Managers.
Syntax
WIN_EV event
Eingabe
keine
Ausgabe
event Numerischer Wert (z.B. 1000 = Applikation beendet)
Beschreibung
Der Event-Manager knmmert sich um die Steuerung der Oberflaechenelemente.
Falls ein Event eintritt, wird er von diesem Befehl in Form eines
numerischen Werts an das Programm uebergeben. Der Event-Manager ist nur
funktionell in einer Schleife. Wird eine Applikation beendet, d.h alle
Fenster der Applikation wurden geschlossen, steht in der Variablen
<event> der Wert 1000.
Bespiel WIN_EV
Siehe
DUMMY_EVENT
ΓòÉΓòÉΓòÉ 231. WIN_PAINT ΓòÉΓòÉΓòÉ
Funktion
Ein Fenster wird an die Steuerung des Systems uebergeben.
Syntax
win_paint "Fenster _id"
Eingabe
"Fenster _id" Kennung des Fensterobjekts
Ausgabe
keine
Beschreibung
Das Fensterobjekt wird am Bildschirm dargestellt. Wird dieser Befehl
mehrmals aufgerufen, erfolgt ein Neuzeichnen des Fensters. Um einzelne
Elemente eines Fensters neu zu zeichnen, verwenden Sie den Befehl
event_on_item "id$", "redisplay".
Bereich, in dem Variablen definiert werden (z.B. mit DEFFLOAT, DEFSTRING,
DEFINE, DIM usw.)
Bespiel WIN_PAINT
Siehe
DEF_WINDOW
DEF_WINDOW_ST
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
*** siehe DATUM ****
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
*** siehe DATUM ****
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
*** siehe DATUM ****
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
defstring date1,date2
deffloat zeit1,zeit2
deffloat tag
DIM text,1,8
rem Wandelt CCYYMMTT ---> Julianische Zahl
date1="19940402"
datetoju date1, zeit1
zeit1=zeit1+10
text1=date1
form zeit1, text2, 0, 12
rem Wandelt Julianische Zahl ---> CCYYMMTT
jutodate zeit1, date1
text3=date1
rem Ermittelt Wochentag 1=Sonntag ... 7=Samstag
datetow date1,tag
form tag,text4, 0, 2
text4=" TAG: " + text4
rem Wandelt 10.12.94 --> 19941210
date1="10.12.94"
rem {Datum lesen}
datum date1
dateformat 0,"DD.MM.YY", date1, date2
mid date2, date2, 1, 8
text5=date2
rem {Datum in Deutsches Format umwandeln}
rem {Wandelt 19941210 ---> 10.12.94 }
dateformat 1,"DD.MM.YY", date2, date1
text6=date1
rem {Datum lesen und 14 Tage hinzu und }
rem {in Deutsches Format umwandeln }
datum date1
dateformat 0,"DD.MM.YY", date1, date2
mid date2, date2, 1, 8
datetoju date2, zeit1
zeit1=zeit1+30
text7="+ 30 Tage"
jutodate zeit1, date2
dateformat 1,"DD.MM.YY", date2, date1
text8=date1
def_window_st "window", 001,001,098, 10, "Beispiel: DATUMSFUNKTIONEN "
def_string "status_Info1", 000,0,012,Text1, 012; "border","select off"
def_string "status_Info2", 012,0,012,Text2, 012; "border","select off"
def_string "status_Info3", 024,0,012,Text3, 012; "border","select off"
def_string "status_Info4", 036,0,012,Text4, 012; "border","select off"
def_string "status_Info5", 048,0,012,Text5, 012; "border","select off"
def_string "status_Info6", 060,0,012,Text6, 012; "border","select off"
def_string "status_Info7", 072,0,012,Text7, 012; "border","select off"
def_string "status_Info8", 084,0,012,Text8, 012; "border","select off"
def_statusbar "status", 2
add_item_array "status", "status_Info", 1,8
add_item "window", "status"
win_paint "window"
dummy_event
end
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
deffloat zahl
defstring text1
filelen "Dkim", zahl
form zahl, text1, 0, 16
def_window_st "window", 001,001,095, 10, "Beispiel: FILELEN "
def_string "status_Info1", 000,0,016, Text1, 016; "border","select off"
def_string "status_Info2", 016,0,016,"Text2", 016; "border","select off"
def_statusbar "status", 2
add_item_array "status", "status_Info", 1,2
add_item "window", "status"
win_paint "window"
dummy_event
end
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
deffloat alt
deffloat neu
neu=999.9990000
int alt, neu
rem neu enthaelt 999
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
*** siehe DATUM ****
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
defstring zeichen
deffloat zahl
zeichen="K"
ASC zeichen,zahl
print zahl rem zahl=075
end
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
deffloat alt
deffloat neu
neu=999.9990000
ganz alt, neu
rem neu enthaelt 1000
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
DEFSTRING eingabe, ausgabe
eingabe="1234567890"
REVERS eingabe, ausgabe
<inhalt von ausgabe> "0987654321"
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
NIL
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
NIL
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
def_pulldown_item "p_db", "
def_popup_item "db_2" , "F2"
def_popup_item "db_3" , "F3"
def_popup_item "db_4" , "F4"
def_popup_item "db_5" , "F5"
def_popup_item "db_6" , "F6"
def_popup_item "db_7" , "F7"
def_popup_item "db_8" , "F8"
def_popup_item "db_9" , "F9"
add_item_array "p_db", "db_", 2, 9
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
Zahleneingabe rechtsbБndig, zwei Stellen nach dem Komma und
MФglichkeit Feldinhalt zu Бberschreiben.
DEF_NUMBER "num1",2,2,10,"200.50","100..3000";
"decimal 2","right","clear"
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
def_window_st "window", 001,001,095, 10, "ProgrammInfo"
def_string "status_Info1", 000,0,010,"Text",10;"border", "select off"
def_string "status_Info2", 010,0,010,"Text",10;"border", "select off"
def_statusbar "status", 2
add_item_array "status", "status_Info", 1, 2
add_item "window", "status"
win_paint "window"
dummy_event
end
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
NIL
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
def_pulldown_item "p_db", "
def_popup_item "db_2" , "F2"
def_popup_item "db_3" , "F3"
def_popup_item "db_4" , "F4"
def_popup_item "db_5" , "F5"
def_popup_item "db_6" , "F6"
def_popup_item "db_7" , "F7"
def_popup_item "db_8" , "F8"
def_popup_item "db_9" , "F9"
add_item_array "p_db", "db_", 2, 9
rem {Objekte db_6, db_7 und db_8 werden entfernt}
sub_item_array "p_db", "db_", 6, 8
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
NIL
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
nil
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
def_window "haupt",...
def_notebook "note"
def_window "Seite 1",..
def_window "Seite 2",..
def_window "Seite 3",..
rem {Windows an das Notebook addieren ...}
add_item "note","Seite 1","Seite 2","Seite 3"
rem {Notebook an das Hauptfenster addieren ...}
add_item "haupt","note"
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}
ΓòÉΓòÉΓòÉ <hidden> ΓòÉΓòÉΓòÉ
rem {******************************************}
rem {MCD (c) 1994-1995 Beispiel }
rem { }
rem {Version: KIM2 ab 1.0 }
rem {******************************************}