Tasten & Command Beschreibung
=============================


Command-Gruppe "BTCH": konzipiert für RK-Skripte
================================================


/BTCH.BEEP.ONE ........: Macht einmal "Beep"
/BTCH.BEEP.THREE ......: Macht dreimal "Beep"
/BTCH.BEEP.HOUR .......: Macht eine der Uhrzeit entsprechende Anzahl "Beeps"
------------------------
Diese Commands sind für die Verwendung des RK-eigenen Timers gedacht, indem
zu einem vorbestimmten Zeitpunkt entsprechende Signale ausgegeben werden.

Beispiel: {/BTCH.BEEP.ONE}


/BTCH.CR>TAB ..........: Ersetzt CR´s (Enter) durch Tabs innerhalb des Skriptes
------------------------
Dieser Command soll dazu dienen, Skripte, die darauf ausgelegt sind, Formulare
zu füllen, einfacher herzustellen. Die einzelnen Felder in Formularen (auch im
Internet) werden allgemein durch die Tab-Taste angesprungen. So ist es z.B.
schneller möglich, einen Adresskopf von z.B. Word in das Skript einzusetzen und
in eine andere formular-orientierte Anwendung zu senden, ohne die vielen Tabs
nachträglich erzeugen zu müssen.

-> Achtung!
Dieser Command steht im Widerspruch zu BTCH.EXPLICIT (s.dort). D.h. je nach dem
welcher dieser beiden Commands zuerst ausgeführt wird, ist wirksam.
Ist ja auch klar: wird einer dieser beiden Commands durchgeführt, gibt es keine
CR´s mehr, die ein anderer Command löschen oder ersetzen könnte.

-> Beachte!
Es ist sicher nicht sinnvoll, weitere Anweisungen in einem solchen Script unter-
zubringen. Besser bei Bedarf mit dem ME.BUTTON Command am Skript-Ende einen anderen
Knopf aufrufen.

Beispiel: {/BTCH.CR_TO_TAB}


/BTCH.DDE.BEGIN .......: Fügt ein Skript für eine andere RK-Instanz ein
/BTCH.DDE.END .........: Markiert das Ende des eingefügten DDE-Skripts
------------------------
Eine Beschreibung der DDE-Funktion (in englisch) findet man im Kapitel
"Netzwerk". Je nach Einstellung im "Einstellungen"-Fenster und verfügbarer
Hardware kann der Skript-Bereich zwischen der BEGIN- und END-Anweisung
entweder an eine laufende RK-Instanz innerhalb des Rechners oder an eine
externe, eines im Netzwerk angeschlossenen Rechners laufende Instanz
gesendet werden.


/BTCH.DELAY sec .......: Fügt eine Pause im Skript ein
------------------------
Dieser Command ist ein sehr wichtiger, denn oft kommt es vor, daß RK beim
Senden der Commands die Abarbeitung der Commands von der angesprochenen
Anwendung sozusagen "überholt". Dadurch können Commands verschluckt oder
ungewollte Resultate auslösen werden. Durch Plazierung einiger kleinen
Pausen im Skript gestattet man dem anderen Programm, den Part seines Jobs
erstmal zu Ende zu bearbeiten, bevor die nächsten Befehle kommen.
Der sec-Parameter gibt die Pausenlänge in Sekunden an, wobei Werte kleiner
als 1 möglich sind. Wichtig ist, daß als Dezimalzeichen der Punkt und nicht
das Komma verwendet wird (0.3 oder 1.5 etc.)!
Beim Systemwechsel auf einen schnelleren Rechner mit schnellerem Disk-Zugriff
können die sec-Parameter sicher weiter verringert werden.
Der Makro-Rekorder bedient sich auch dieses Commands, wenn während der
Aufzeichnug auf den Pause-Knopf geklickt wird. Im fertig generierten Skript
kann man den sec-Parameter nachträglich ändern, d.h. i.d.R. wohl verringern.

Beispiel: {/BTCH.DELAY 0.1}


/BTCH.DIVERT>CLIP.ON ..: Lenkt das Senden in die Zw´ablage um, nur gültig für das aktuelle Skript
/BTCH.DIVERT>CLIP.OFF .: Hebt den Divert-Modus wieder auf (erfolgt auch autom. am Skript-Ende)
------------------------
Gestattet das Senden in die Zw´ablage anstatt an die aktive Anwendung.
Der OFF-Comand ist nur nötig, wenn z.B. der Skript-Anfang in die Zw´ablage und der untere Teil
normal gesendet werden soll, da der Divert-Modus am Skript-Ende in jedem Falle deaktiviert wird.

Beispiel: {/BTCH.DIVERT>CLIP.ON}


/BTCH.EXIT-TAG ........: Beendet die Skript-Abarbeitung an dieser Stelle
------------------------

Beispiel: {/BTCH.EXIT-TAG}


/BTCH.EXITIF.ASK text .: Beendet Skript, wenn "Abbrechen" dieses Dialogs geklickt wurde
/BTCH.EXITIF.CLIP text : Beendet Skript, wenn Zw´ablage und <text> übereinstimmen
/BTCH.EXITIF.VAR= v ...: Beendet Skript, wenn VAR den Wert <v> aufweist (siehe VAR-Commands)
/BTCH.EXITIF.VAR> v ...: Beendet Skript, wenn VAR größer ist als der Wert <v>
/BTCH.EXITIF.VAR< v ...: Beendet Skript, wenn VAR kleiner ist als der Wert <v>
------------------------

Diese Commands bewirken das selbe wie der folgende Command, nur eben bezogen auf einen
Abfrage-Dialog (ASK), den Inhalt der Zw´ablage und den Inhalt der Variablen VAR (siehe
VAR-Commands).


/BTCH.EXITIF.CANCEL ...: Beendet Skript, wenn zuvor "Abbrechen" eines RK-Skript-Dialogs geklickt wurde
------------------------
Dieser Command wirkt z.Zt. auf folgende Commands:

- BTCH.TEXT.ASK
- BTCH.TEXT.LIST.CLIP
- BTCH.TEXT.LIST.SEND
- CLIP.TXT.ASK
- CLIP.TXT.BEHND.ASK
- DAT.TEMP.ASK
- DB.OPEN (Combo-table-selection)
- DB.REC.SELECT
- DB.TABLE.ASK-S
- DB.TABLE.SELECT
- STR.ASK
- VAR.FLD.ASK

Beispiel:

{/BTCH.EXPLICIT}
{/DB.REC.SELECT}
{/BTCH.EXITIF.CANCEL}
{/DB.FIELD.SET 4}
{/DB.FIELD.SEND}

REC.SELECT zeigt eine Auswahl-Liste an. Wird diese mit "Abbrechen" geschlossen,
so werden die im Skript nachfolgenden Commands nicht ausgeführt.


/BTCH.EXPLICIT ........: Gestattet es Commands untereinander zu listen
------------------------
Ein längeres Skript sieht normalerweise recht unübersichtlich aus, denn es
ist eine Folge von Commands, die hintereinander weg in einer Zeile stehen.
Würde man es übersichtlich mit entsprechenden Zeilenumbrüchen gestalten,
würde RK an diesen Stellen ungewollte Zeilenumbruch-Steuerzeichen
(Carriage Return = CR = ASCII 13) senden.
Der Explicit-Command, den man als ersten Command in einem Script benutzen
sollte, unterbindet die CR´s, so daß man sogar Leerzeilen zur Übersicht
einfügen kann. Wird aber dennoch einmal ein CR benötigt, so kann man
das Senden eines CR´s immer noch mit dem KEY.ENTER-Command erzwingen.
Möglich wäre auch das direkte Senden des ASCII-13 oder/und ASCII-10
(Line Feed = LF) Steuerzeichens mit Hilfe des CODE.ASC-Commands (s. dort).

Beispiel: {/BTCH.EXPLICIT}

>>> Siehe auch Beispiel-Skript 1 am Ende dieses Textes.


/BTCH.GO-TAG tag ......: Definiert die Sprung-Marke <tag> (=goto-tag)
------------------------
Dieser Command ist erforderlich für sämtliche folgenden GO-Commands, um die
Marke zu definieren, wohin gesprungen werden soll.

Beispiel: {/BTCH.GO-TAG mytag}

Durch die Angabe von <tag> sind beliebig viele Sprung-Marken innerhalb eines
Skriptes definierbar.


/BTCH.GO.TO tag .......: Setzt die Skript-Abarbeitung an der Sprung-Marke <tag> fort
------------------------

Beispiel: {/BTCH.GO.TO mytag}

Das Skript wird nach der Stelle fortgesetzt, wo sich der {/BTCH.GO-TAG mytag}-Command
befindet.


/BTCH.GOIF.ASK txt,tag : Springt zur Sprung-Marke <tag>, wenn "Abbrechen" dieses Dialogs geklickt wurde 
/BTCH.GOIF.CANCEL tag .: Springt zur Sprung-Marke <tag>, wenn "Abbrechen" eines Dialogs geklickt wurde
/BTCH.GOIF.CLIP txt,tag: Springt zur Sprung-Marke <tag>, wenn die Zw´ablage und <text> übereinstimmen
/BTCH.GOIF.VAR= v,tag .: Springt zur Sprung-Marke <tag>, wenn VAR den Wert <v> aufweist (s. VAR-Commands)
/BTCH.GOIF.VAR> v,tag .: Springt zur Sprung-Marke <tag>, wenn VAR größer ist als der Wert <v>
/BTCH.GOIF.VAR< v,tag .: Springt zur Sprung-Marke <tag>, wenn VAR kleiner ist als der Wert <v>
------------------------

Beispiel:

{/BTCH.EXPLICIT}
{/BTCH.GOIF.ASK Möchten Sie Skript B?,test-tag}
{/ME.BUTTON AProfile,ButS1}
{/BTCH.EXIT-TAG}
{/BTCH.GO-TAG test-tag}
{/ME.BUTTON AProfile,ButS1,1}

Beim Klick auf OK wird die linke Knopf-Ebene des Knopfes ButS1 ausgeführt.
Beim Klick auf Abbrechen wird die rechte Knopf-Ebene des Knopfes ButS1 ausgeführt.


/BTCH.INSTMODE.ON .....: Fügt Text per Strg-v ein, anstatt ihn zu senden
/BTCH.INSTMODE.OFF ....: Schaltet den INSTMODE wieder aus
------------------------
Sofern es sich beim zu sendenen Material um Text handelt und die
angesprochene Anwendung den Windows-Einfüge-Modus (Strg+v) unterstützt,
ist dies eine sehr schnelle Alternative zum normalen Senden von Text,
besonders für längere Textpassagen empfohlen.
Hierzu schaltet man den INSTMODE am besten am Skript-Anfang ein und nach
dem Einfügen des Textes am Skript-Ende wieder aus. Im Einstellen-Dialog
kann man den derzeitigen Zustand (ein/aus) ablesen, geändert werden kann
er dort aber nicht.


/BTCH.LOOP.START.VAL no: Wiederholt Skriptbereich bis LOOP.END, fix
/BTCH.LOOP.END ........: Markiert das Ende einer Schleife
------------------------
Mit Hilfe der Schleifen-Konstuktion kann der Skriptbereich, der sich zwischen
der Start- und End-Anweisung befindet, wiederholt werden.
Der Parameter <no> (number) gibt die Anzahl der Schleifendurchläufe an.


/BTCH.LOOP.START.VAR no: Wiederholt Skriptbereich bis LOOP.END, solange <no> kleiner als VAR
------------------------
Auch bei der VAR-Varianten wird das Schleifen-Ende durch die o.g. END-Anweisung
festgelegt. Die VAR-Variante bietet aber die Möglichkeit, die Anzahl der
Durchläufe variabel zu halten, indem sie vor Eintritt in die Schleife abgefragt
wird. Die Schleife ist für Aufwärts-Zählungen konzipiert.

>>> Siehe Beispiel-Skript 1 am Ende dieses Textes.

In diesem Beispiel kann der Anwender die gewünsche Anzahl der Schleifen-
Durchläufe mittels des ASK-Commands während der Abarbeitung des Skripts
festlegen.
Da ein Abwärtszählen bis 0 nicht funktioniert (die Schleife fragt >= ab),
wird hier ein Trick angewandt, indem der Wert zunächst negativiert wird
(MUL -1) um ihn dann bis 0 raufzuzählen.


/BTCH.MSG.AUTO sec ....: Zeigt ein Fenster mit Datum und Zeit für <sec> Sekunden an
/BTCH.MSG.TEXT text ...: Zeigt ein Fenster, das die Meldung <text> anzeigt
/BTCH.MSG.TIME [text] .: Zeigt ein Fenster mit Datum, Zeit, KW und Meldung <text> (text=optional)
------------------------
Diese Commands sind vorwiegend für die Nutzung des RK-internen Timers
konzipiert, können aber auch anderwärtig eingesetzt werden.
Der sec-Parameter steuert die Zeit, die das Fenster geöffnet bleibt.
Mit den text-Parametern gibt man einen Text vor, der ausgegeben wird
(im 3. Fall optional).

Beispiele:

{/BTCH.MSG.AUTO 3}
{/BTCH.MSG.TEXT Columbo fängt gleich an}
{/BTCH.MSG.TIME}
{/BTCH.MSG.TIME Daggi wartet!}


/BTCH.MSG.CLIP ........: Zeigt ein Fenster, das den Inhalt der Zw´ablage anzeigt
------------------------

Beispiel: {/BTCH.MSG.CLIP}


/BTCH.POP.OWN .........: Erzeugt und zeigt ein individuelles Popmenu
------------------------
Dieser Command gestattet es, ein individuelles Popmenü zu kreieren.
Bei Anwahl eines Menü-Punktes wird dann ein dem Menü-Punkt zugeordneter
Command ausgeführt, Definition und Ausführung also kompakt in einem Skript.
Dem POP.OWN-Command kommt hierbei eine doppelte Funktion zu:

1. Er leitet die Definition des Menüs im Skript ein.
2. Er bewirkt, daß das Menü beim Klick auf den Knopf angezeigt wird.

Das Skript ist so aufgebaut, daß Menüpunkt-Titel und auszulösender Command
abwechselnd deklariert werden.
Auf den EXPLICIT-Command kann verzichtet werden, denn das Skript ist
- wie im folgenden Beispiel gezeigt - stets untereinander zu listen.


Beispiel:

{/BTCH.POP.OWN}

Play a song
{/ME.BUTTON Store,TimMsg}
Profiles
{/ME.POP.PROF}

Dieses Skript erzeugt ein aus 2 Einträgen bestehendes Popmenü mit den Menü-
Punkten "Play a song" und "Profiles". Bei Anwahl eines Menü-Punktes wird
sodann der im Skript unter dem Menü-Punkt stehende Command ausgeführt.

Ein Beispiel für ein eigenes Popmenü befindet sich im "OwnPop"-Knopf des
"Store"-Profils.

Übrigens kann ein solches Popmenü auch über die Ereignis > Tasten Funktion
aufgerufen werden, und das sogar, wenn das RK-Fenster sich gar nicht auf
dem Bildschirm befindet (Versteckt im Systray).

--> Hinweis
Ab v8.1 können je Menü-Eintrag mehrere Commands definiert werden.
Als Trennung der einzelnen Einträge dient nicht mehr die geschweifte Klammer,
sondern der Zeilenumbruch.

Beispiel:

{/BTCH.POP.OWN}
Play a song
{/ME.BUTTON Store,TimMsg}{/BTCH.BEEP.ONE}
Profiles
{/ME.POP.PROF}


/BTCH.REM text ........: Gestattet es eine Bemerkung in das Skript aufzunehmen
------------------------

Beispiel: {/BTCH.REM Skript noch nicht fertig}

Beispiel: 
{/BTCH.REM
Skript ist noch nicht fertig!
}

--> Tip
Dieser Command kann auch dazu verwendet werden, den Fokus an die letzte aktive
Anwendung zurückzugeben, sofern RK oder der Profil-Explorer den Fokus gerade
besitzt.

Beispiel (alleinstehend im Skript):
{/BTCH.REM}

Dieses Skript setzt also den Automatismus von RK in Gang, die letzte aktive
Anwendung nach einem Knopf-Klick zu aktivieren, verhindert aber zugleich
(im Gegensatz zum KLick auf einen unbelegten Knopf), daß das "Bearbeiten >
Knöpfe"-Fenster automatisch geöffnet wird.


/BTCH.RETRIEVEFOCUS ...: Aktives Fenster für folgende Sendungen neu ermitteln
------------------------
In längeren Skripts, in denen mehrere Fenster geöffnet werden, kann RK nicht
verfolgen, welches Fenster am Ende aktiv ist, um die automatische Aktivierung
aufrecht zu erhalten.
Dieser Command veranlaßt RK dazu, das aktive Fenster neu zu ermitteln.
Ein Beispiel, in dem dieser Command erforderlich war, findet sich im RK-
Profil "Store" unter dem grafischen Explorer-Knopf, der sich in der rechten,
unteren Ecke befindet.


/BTCH.SLOW msec .......: Verlangsamt das Senden
------------------------
Wenn ein Skript mit zahlreichen Delay-Commands untersetzt ist, kann es
sinnvoller sein, den Ablauf des Skriptes generell zu verlangsamen,
um schließlich auf die Delay-Commands verzichten zu können.
Mit dem msec-Parameter legt man die Verzögerung in Milli-Sekunden fest.
Spätestens am Ende des Skriptes sollte die Verzögerung mit {/BTCH.SLOW 0}
wieder aufgehoben werden. Im Einstellen-Dialog kann man den derzeitigen
Status ablesen, geändert werden kann er dort aber nicht.


/BTCH.STOP ............: Ermöglicht das Skript durch einen Stop-Knopf zu beenden
------------------------
Auf das Material, das bereits durch RK abgeschickt wurde, kann RK keinen
Einfluß mehr nehmen. Aber die Abarbeitung eines Skriptes kann mit Hilfe
dieses Commands gestoppt werden. Dies ist fast nur in Skripts sinnvoll,
die Schleifen beinhalten.
Der STOP-Command sollte möglichst weit oben im Skript plaziert werden.

>>> Siehe auch das Beispiel-Skript 1 am Ende dieses Textes.


/BTCH.TEXT.ASK [qu,pre]: Sendet Text, der während Ausführung deklariert wird, qu=Frage, pre=Preset
------------------------

Beispiele:

{/BTCH.TEXT.ASK}
{/BTCH.TEXT.ASK Aktuelles Jahr}
{/BTCH.TEXT.ASK Aktuelles Jahr,2002}
{/BTCH.TEXT.ASK ,2002}

Ich bitte um Rückantwort bis zum {/BTCH.TEXT.ASK Bitte Datum eingeben,??.??.2002}.
MfG

In diesem Beispiel kann das Datum während des Sendens des Textes an eine
Anwendung eingegeben werden. Trifft RK nun auf diesen Command, unterbricht es
das Senden und öffnet ein Eingabe-Fenster, in dem das Datum (in diesem
Beispiel) eingegeben wird. Nach dem Schließen des Fensters wird das Datum in
den Text eingefügt und der restliche Text gesendet.
Selbstverständlich kann dieser Command mehrfach in einem Text implementiert
werden. 

Die Parameter <qu> und <pre> sind optional, um im Eingabe-Requester einen Aufforderungs-Text
(Frage) und/oder einen Vorgabe-Text (Preset) anzuzeigen.

Ein Beispiel für den Einsazt dieses Commands findet sich im "input"-Knopf
des "Store"-Profils.

--> Tip
Wird der Dialog durch "Abbrechen" geschlossen, so kann die Skript-Abarbeitung
an dieser Stelle durch den Commands "BTCH.EXIT-ON-CANCEL" (siehe dort) beendet
werden.


/BTCH.TEXT.LIST.CLIP ..: Kopiert einen aus einer Ausw´box gewählten Text in die Zw´ablage
/BTCH.TEXT.LIST.SEND ..: Sendet einen aus einer Ausw´box gewählten Text an die aktive Anwendung
------------------------
Diese Commands stellen eine Auswahlbox dar, aus der der Anwender einen Eintrag auswählen kann,
der entweder gesendet (.SEND) oder in die Zw´ablage kopiert wird (.CLIP).
Diese Commands können nur in der 1. Ebene eines Knopfes (für die linke Maustaste) eingesetzt werden,
weil in der 2. Ebene (rechte Maustaste) die Liste definiert wird.
Für diesen Zweck werden die Einträge einfach untereinander gelistet.

Beispiel:

Ebene 1 (linke Maustaste):

Hello {/BTCH.TEXT.LIST.SEND}, how are you?

Ebene 2 (rechte Maustaste):

Robin
Paul
Martha

Wird nun der Knopf angeklickt, so erscheint eine Auswahlbox mit den 3 aufgeführten Namen.
Nach Bestätigung durch "OK" wird der Satz mit dem ausgewählten Namen an die aktive Anwendung
gesendet.

--> Tip
Im Store-Profil veranschaulicht der Knopf "send list" die Funktionsweise


/BTCH.WAIT.TOP title[,t]  Wartet bis Fenster <title> erscheint, <t> = sec timeout
/BTCH.WAIT.BACK title[,t] Wartet bis Fenster <title> verschwindet
-------------------------
Diese Commnds ermöglichen die Abarbeitung eines Skriptes anzuhalten, bis ein
spezifiziertes Fenster erscheint bzw. verschwindet. Mit dem Timeout-Parameter
<t> (optional) kann man die auf 10 Sek. vorgegebene Timeout-Zeit verändern.
Die Timeout-Option verhindert, daß RK möglicherweise in eine Endlos-Schleife
fällt.
Joker ("*") werden bei der Fenstertitel-Angabe automatisch gesetzt und sind
nicht mit anzugeben, auf Groß- und Kleinschreibung ist allerdings zu achten.

Beispiel: {/BTCH.WAIT.TOP Editor,2}


-----------------

Beispiel-Skript 1
=================

{/BTCH.EXPLICIT}
{/BTCH.STOP}

{/VAR.ASK}
{/VAR.MUL -1}

{/BTCH.LOOP.START.VAR 0}
Test{KEY.ENTER}
{/VAR.ADD 1}
{/BTCH.LOOP.END}
