
Groupe de commandes "BTCH": Scénario 
====================================
(conçu pour les scénarios)


/BTCH.BEEP.ONE ........: Emet un bip
/BTCH.BEEP.THREE ......: Emet trois bips
/BTCH.BEEP.HOUR .......: Emet le nombre de bips correspondant à l'heure 
------------------------ actuelle

Ces commandes sont utiles à la minuterie, dans laquelle elles émettront 
un signal correspondant à un moment précis.
Voir le fichier-texte "Evénements" (Minuterie).

Exemple: bouton "A ou B" du profil "Démo Taille et Go-Exit"


/BTCH.CR>TAB ..........: Remplace les retours à la ligne par des 
------------------------ tabulations à l'intérieur du scénario

Cette commande est utile pour remplir plus facilement des formulaires. En 
général il faut passer d'un champ à l'autre dans un formulaire (aussi sur 
Internet) avec la touche <Tab>. Ainsi c'est donc plus rapide par exemple 
d'introduire une entête de Word dans le scénario et de l'envoyer dans un 
formulaire, sans devoir passer par la touche Tab.

-> Attention !
Cette commande est en contradiction avec BTCH.EXPLICIT (voir ci-dessous).
Donc il est impossible d'avoir ces 2 commandes dans le même scénario.
Il vaut mieux en cas de nécessité utiliser la commande ME.BUTTON à la fin 
du scénario pour appeler un autre bouton.

Exemple: {/BTCH.CR>TAB}


/BTCH.DDE.BEGIN .......: Inclu un scénario pour un autre bouton
/BTCH.DDE.END .........: Exécute le scénario-DDE inclu
------------------------
Une description de la fonction DDE se trouve dans le fichier-texte 
"Travail en réseau" du sous-dossier "Network connection". 
Une fois que la fonction DDE dans la boîte Préférences et les paramètres 
du matériel (Hardware) sont réglés, on peut envoyer le scénario entre 
l'ordre de début (BEGIN) et de fin (END) soit dans l'ordinateur lui-même, 
soit dans un réseau fermé.

Exemple de scénario (si vous n'avez pas de réseau) :

a) créez un bouton avec la commande : 
   {/BTCH.DDE.BEGIN}{/BTCH.MSG.TEXT Salut !}{/BTCH.DDE.END}
b) démarrez RK une 2ème fois pour avoir un 2ème tableau, et placez-le à 
   l'écran légèrement décalé au 1er
c) contrôlez que la case "Connexion DDE" est cochée
d) maintenant cliquez sur le bouton (l'un des 2) : 
e) le message "Salut !" est exécuté par le 2ème tableau (puisqu'il se met 
   devant le 1er)


/BTCH.DELAY <sec> .......: Ajoute un délai en seconde(s) <sec> avant 
-------------------------- d'envoyer des touches et commandes

Cette commande est très importante, car il arrive souvent que RK travaille 
plus vite que les commandes envoyées à l'application concernée, de sorte 
que cela donnera des résultats non désirés. En plaçant une petite pause 
dans le scénario, on permet au programme de terminer la partie du travail 
avant d'exécuter les commandes suivantes.
Le paramètre-seconde donne la durée de pause en seconde, voir une valeur 
plus petite. Il est important que les décimales soient précédées d'un 
point et non d'une virgule (0.3 ou 1.5 etc.) !
Si vous changez de système (ordinateur plus puissant), vous pouvez 
réduire les secondes, voir supprimer les commandes BTCH.DELAY.
L'enregistreur Macro se sert de ces commandes, lorsqu'on clique sur le 
bouton <Délai + 1 sec.>. Une fois le scénario terminé, on peut changer
les paramètres-seconde : en général en les réduisant.

Exemple: bouton "déplace" du profil "Stock


/BTCH.DIVERT>CLIP.ON ..: Détourne l'envoi dans le presse-papiers, valide 
                         seulement pour le scénario actuel
/BTCH.DIVERT>CLIP.OFF .: Arrête le mode "divert" (détourne)
------------------------

Cette commande permet d'envoyer dans le presse-papiers au lieu d'envoyer
dans l'application active.
La commande OFF n'est nécessaire que lorsque le début du scénario est 
envoyé dans le presse-papiers et l'autre partie est envoyée normalement.

Exemple: bouton "différen." du profil "Stock"


/BTCH.EXIT-TAG ........: Sort du scénario à ce point
------------------------

Cette commande travaille avec les commandes GO ci-dessous.

Elle est aussi utile pour tester un long scénario qui ne fonctionne pas. 
En déplaçant cette commande au fur et à mesure à l'intérieur du scénario, 
on découvrira finalement l'erreur.

Exemple: bouton "Ex - Go" du profil "Démo Taille et Go-Exit"


/BTCH.EXITIF.ASK text .: Sort du scénario si "Non" a été cliqué dans la 
                         boîte-message
/BTCH.EXITIF.CLIP text : Sort du scénario si le presse-papiers contient 
                         le <text> (commande au début du scénario)
/BTCH.EXITIF.VAR= v ...: Sort du scénario si VAR = valeur <v>
/BTCH.EXITIF.VAR> v ...: Sort du scénario si VAR > valeur <v>
/BTCH.EXITIF.VAR< v ...: Sort du scénario si VAR < valeur <v>
------------------------

Ces commandes travaillent comme la commande ci-dessous.

Exemples: plusieurs boutons du profil "Démo Taille et Go-Exit"


/BTCH.EXITIF.CANCEL ...: Sort du scénario si "Ferme" a été cliqué dans la 
------------------------ dernière boîte affichée

Cette commande est valide pour les commandes suivantes :

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

Exemple: bouton "Sél. & Envoie" du profil "Exemples de base de données"

         REC.SELECT affiche une liste de choix. Si celle-ci est fermée 
         avec "Ferme", la commande ne sera pas exécutée dans le scénario.

Exemples: bouton "quelle ?" (mémoire droite) du profil "Stock" 
          bouton "Ex - Cancel" du profil "Démo Taille et Go-Exit"


/BTCH.EXPLICIT ........: Inscrit chaque commande dans une ligne unique
------------------------
Un scénario très long paraît d'une façon générale illisible, parce que 
les commandes sont collées les unes aux autres dans une seule ligne.
Pour obtenir des paragraphes lisibles, RK doit envoyer à ces endroits 
des "Retours à la ligne" (ENTER = ASCII 13) non désirés.
La commande EXPLICIT, qui doit être employée en premier dans le 
scénario, lie les Retours (ils ne seront pas utilisés dans le scénario), 
pour pouvoir insérer des lignes vierges. 
Si par contre un Retour est nécessaire pour le scénario, on peut alors 
l'insérer avec la commande KEY.ENTER.
C'est aussi possible d'envoyer directement avec la commande CODE.ASC 
les codes ASCII-13 (SHIFT+ENTER) et/ou ASCII-10 (CTRL+ENTER = saut de 
page).

Exemple: les boutons du profil "Démo Taille et Go-Exit"

>>> Voir aussi l'exemple de scénario 1 à la fin du document.


/BTCH.GO-TAG tag ......: Met un repère de saut <tag>
------------------------
Cette commande est requise pour toutes les commandes GO à définir, où il 
faut sauter.

Exemple: bouton "Go - To #7" du profil "Démo Taille et Go-Exit"


/BTCH.GO.TO tag .......: Saute au repère <tag>
------------------------

Exemple: {/BTCH.GO.TO mon repère}

Le scénario sera continué à la place où {/BTCH.GO-TAG mon repère} sera 
trouvé.

Combinée avec la commande précédente, elle est aussi utile pour tester un 
long scénario. En les déplaçant à l'intérieur du scénario, on sautera des 
commandes qui sont peut-être finalement inutiles.

Exemple: bouton "Go - To #7" du profil "Démo Taille et Go-Exit"


/BTCH.GOIF.ASK txt,tag : Saute au repère <tag> si "Oui" a été cliqué dans 
                         la boîte-message
/BTCH.GOIF.CANCEL tag .: Saute au repère <tag> si "Ferme" a été cliqué 
                         dans la dernière boîte 
/BTCH.GOIF.CLIP txt,tag: Saute au repère <tag> si le presse-papiers 
                         contient le <text> (commande au début du 
                         scénario) 
/BTCH.GOIF.VAR= v,tag .: Saute au repère <tag> si VAR = valeur <v>
/BTCH.GOIF.VAR> v,tag .: Saute au repère <tag> si VAR > valeur <v>
/BTCH.GOIF.VAR< v,tag .: Saute au repère <tag> si VAR < valeur <v>
------------------------

Exemple:

{/BTCH.EXPLICIT}
{/BTCH.GOIF.ASK Voulez-vous le scénario B ?,essai}
{/ME.BUTTON Mon profil,Date}
{/BTCH.EXIT-TAG}
{/BTCH.GO-TAG essai}
{/ME.BUTTON Mon profil,Date,1}

En cliquant sur OK, la mémoire gauche du bouton Date sera exécutée.
En cliquant sur Ferme, la mémoire droite du bouton Date sera exécutée.

Exemples: plusieurs boutons du profil "Démo Taille et Go-Exit"


/BTCH.INSTMODE.ON .....: Colle un texte avec CTRL+v directement au lieu 
                         de l'envoyer dans le presse-papiers
/BTCH.INSTMODE.OFF ....: Désactive la fonction INSTMODE
------------------------ 
C'est une alternative très rapide au mode de collage de Windows (CTRL+v) 
pour l'envoi normal de textes, particulièrement recommandée pour des 
passages très longs.
On active la fonction INSTMODE au début du scénario et on la désactive 
après avoir collé le texte. 
Dans la boîte "Préférences" on peut voir si elle est activée (ON) ou non 
(OFF), mais elle ne peut être réglée dans celle-ci.


/BTCH.LOOP.START.VAL no: Répète la partie du scénario jusqu'à la commande 
                         LOOP.END pour le nb. <no> de fois
/BTCH.LOOP.END ........: Marque la fin de la boucle
------------------------

Grâce à la boucle le scénario qui se trouve entre la commande de départ 
et de fin peut être répété.
Le paramètre <no> indique le nombre de boucles.

Exemple: bouton "heure 2" du profil "Stock"


/BTCH.LOOP.START.VAR no: Répète la partie du scénario jusqu'à la commande 
                         LOOP.END, le nb. <no> étant plus petit que la 
------------------------ variable <VAR>

Malgré la variable (VAR) la fin de la boucle est définie par l'ordre de 
fin. Mais la commande Variable offre la possibilité de choisir le nombre 
de boucles à l'aide d'une petite boîte qui s'ouvre. 
La boucle est conçue pour des nombres croissants.

>>> Voir l'exemple de scénario 1 à la fin du document :

Dans cet exemple l'utilisateur peut choisir le nombre désiré de boucles 
avec la commande ASK (une petite boîte s'ouvre) durant l'exécution du 
scénario.
Comme un chiffre supérieur à 0 ne fonctionne pas, on utilise une astuce 
dans laquelle le nombre d'abord négatif (MUL -1) sera compté depuis 
lui-même jusqu'à 0.

Exemple: bouton "boucle 2" du profil "Stock"


/BTCH.MSG.AUTO sec ....: Ouvre une boîte qui montre la date et l'heure 
                         pendant le nb de secondes choisi <sec>
/BTCH.MSG.TEXT text ...: Ouvre une boîte qui montre le message <text>
/BTCH.MSG.TIME [text] .: Ouvre une boîte qui montre le jour, la date, 
                         (n° de semaine), l'heure, et un message 
------------------------ facultatif (les signes [] peuvent être suppr.)

Ces commandes ont été conçues pour être utilisées avec la minuterie, mais 
elles peuvent aussi l'être autrement.
Le paramètre-seconde commande la durée qui gardera la fenêtre ouverte.
Le paramètre-texte affiche un texte; dans la 3ème commande il est 
facultatif.

Exemple: bouton "heure 2" du profil "Stock"
Exemple: bouton "A ou B" du profil "Démo Taille et Go-Exit"
Exemple: bouton "heure 1" du profil "Stock"

Exemple de scénario:

{/BTCH.MSG.AUTO 5}
{/BTCH.DELAY 4}
{/BTCH.MSG.TEXT Columbo est là...}
{/BTCH.MSG.TIME Le crime ne paie pas !}

--> Note
Essayez ce scénario de préférence dans le Bureau (sans applications 
actives)


/BTCH.MSG.CLIP ........: Ouvre une petite boîte qui affiche le texte
------------------------ inclu dans le presse-papiers

Exemple: {/BTCH.MSG.CLIP}


/BTCH.POP.OWN .........: Crée et affiche un menu contextuel personnel
------------------------
Cette commande permet de créer un menu contextuel personnel.
Elle possède une double fonction :

1. Elle crée la définition du menu dans le scénario.
2. Elle affiche le menu par un clic sur le bouton.

Dans le scénario on doit inscrire la commande d'exécution immédiatement 
après le titre qui sera affiché dans le menu contextuel.
On peut renoncer à la commande EXPLICIT car les commandes du scénario, 
comme dans l'exemple ci-dessous, sont écrites les unes en dessous des 
autres.

Exemple de scénario:

{/BTCH.POP.OWN}

Affiche l'heure
{/ME.BUTTON Stock,heure 2}{/BTCH.BEEP.ONE}
Profils
{/ME.POP.PROF}

Ce scénario comprend 2 titres affichés dans le menu contextuel, 
"Affiche l'heure" et "Profils" qui sont suivis de leurs commandes.

Un autre exemple se trouve dans le bouton "me. pers" du profil "Stock".

En outre on peut faire apparaître un tel menu avec la fonction 
"Evénements > Raccourcis", et même lorsque RK est caché dans la barre- 
système.

--> Remarque
Depuis la version 8.1, chaque entrée du menu peut être définie avec 
plusieurs commandes.


/BTCH.REM text ........: 1. Inclu une remarque dans le scénario (n'est pas
                            exécutée) ou
                         2. Redonne l'activation à la dernière application 
------------------------    active (employée seule)

1. C'est donc utile pour ajouter une info dans le scénario.

   Exemple: {/BTCH.REM Le scénario n'est pas encore terminé}
   Autre exemple : bouton "heure 2" du profil "Stock" 

ou

2. Cette commande peut aussi être utilisée pour redonner l'activation de 
   la fenêtre à la dernière application active, pour autant que RK ou 
   l'Explorateur du profil soit actif.

   Exemple: {/BTCH.REM text} 

   = seul dans le scénario


/BTCH.RETRIEVEFOCUS ...: Force RK à trouver la fenêtre active avant 
------------------------ d'envoyer la commande suivante

Dans des longs scénarios avec plusieurs fenêtres ouvertes, RK ne reconnait 
pas la fenêtre active actuelle, de sorte qu'il envoye la commande suivante 
de façon aléatoire.
Cette commande force RK à trouver à nouveau la fenêtre active.

Un exemple, dans lequel cette commande est nécessaire, se trouve dans le 
profil "Stock" : bouton "Explorateur" (image).


/BTCH.SLOW <msec> .......: Ralentit en 1/1000 sec. l'exécution du 
                           scénario (= Slow-Mode) / la fonction est 
-------------------------- désactivée à la fin avec <msec> = 0 

Lorsqu'il y a un nombre important de commandes BTCH.DELAY, le déroulement 
du scénario est en général ralenti au point qu'il faut pouvoir réduire 
la durée des délais.
De même lorsqu'il y a beaucoup de situations critiques qui apparaissent 
tout le temps, on peut grâce à cette commande ralentir tout le processus 
du scénario (mieux dans ce cas qu'avec BTCH.DELAY).
Avec le paramètre "msec" on règle le retard en millièmes de seconde.
A la fin du scénario on désactive la fonction Slow-Mode en réglant le 
paramètre sur 0 (= {/BTCH.SLOW 0}). 
Dans la boîte "Préférences" on peut voir si la fonction est activée (ON) 
ou non (OFF), mais elle ne peut être réglée dans celle-ci.

Exemple: bouton "vitesse" du profil "Stock"  


/BTCH.STOP ............: Stoppe l'exécution par un clic sur le bouton 
------------------------ STOP (= 1ère commande du scénario !)

L'exécution d'un scénario peut être stoppé avec cette commande. Elle est 
en particulier très utile dans un scénario en boucle. 
Voir /BTCH.LOOP.START...(plus haut).
La commande doit être placée tout en haut du scénario !


Exemple: bouton "STOP" dans le profil "Stock"

>>> Voir aussi l'exemple de scénario 1 à la fin du document : mais dans 
    ce cas le scénario est trop court pour avoir le temps de cliquer sur 
    le bouton STOP.


/BTCH.TEXT.ASK [qu,pre]: Colle un texte variable (à entrez dans une boîte) 
------------------------ dans un module-texte envoyé à une application
                         qu=question, pre=pré-réglage
4 possibilités :

{/BTCH.TEXT.ASK}
{/BTCH.TEXT.ASK Année en cours}
{/BTCH.TEXT.ASK Année en cours,2002}
{/BTCH.TEXT.ASK ,2002}

Exemple de scénario :

{/BTCH.EXPLICIT}
Je vous demande une réponse jusqu'au {/BTCH.TEXT.ASK S.v.p. entrez la 
date avec le format :,??.??.2002} et vous prie d'agréer...

Dans ce scénario une date (avec format requis) sera introduite au texte 
"Je vous demande..." envoyé dans une application.
Quand cette commande arrive RK interrompt l'envoi et ouvre une boîte, 
dans laquelle on entre la date (dans cet exemple). En cliquant sur OK 
(ou en pressant ENTER) elle est ajoutée au texte puis finalement le 
reste du texte est envoyé.

Bien sûr cette commande peut être répétée plusieurs fois dans un même 
texte.
Les paramètres facultatifs <qu> et <pre> sont utilisés pour afficher dans 
une boîte une requête (question) et/ou un texte préparé (pré-réglage).

Autre exemple: bouton "à entrer" du profil "Stock"

--> Conseil
L'exécution du scénario peut être interrompue à l'aide de la commande 
"BTCH.EXITIF.CANCEL" si la boîte est fermée avec le bouton "Ferme". 
(voir plus haut).


/BTCH.TEXT.LIST.CLIP ..: Copie un texte dans le presse-papiers, 
                         sélectionné dans une liste qui est définie dans 
                         la mémoire 2 (bouton droit)
/BTCH.TEXT.LIST.SEND ..: Envoie un texte, sélectionné dans une liste qui 
                         est définie dans la mémoire 2 (bouton droit)
------------------------
Ces commandes affichent une boîte, dans laquelle l'utilisateur peut faire 
un choix, qui sera envoyé (.SEND) ou copié dans le presse-papiers (.CLIP).
Elles ne peuvent être assignées qu'avec la mémoire gauche du bouton, 
puisque dans la mémoire droite se trouve la liste de choix.

Exemple: bouton "env./liste" du profil "Stock"

--> Conseil
L'exécution du scénario peut être modifiée à l'aide de la commande 
"BTCH.EXITIF.CANCEL" si la boîte est fermée avec le bouton "Ferme". 
(voir plus haut).


/BTCH.WAIT.TOP title[,t] : Attend jusqu'à ce que le titre <title> de la 
                           fenêtre vienne au premier-plan, <t> = pause en 
                           secondes 
/BTCH.WAIT.BACK title[,t]: Attend jusqu'à ce que le titre <title> de la 
                           fenêtre aille à l'arrière-plan, <t> = pause en 
-------------------------- secondes
 
Ces commandes permettent de stopper l'exécution d'un scénario jusqu'à ce 
que la fenêtre spécifiée apparaisse ou disparaisse. Avec le paramètre <t> 
(facultatif) on peut régler la pause en secondes (si on ne choisit rien : 
<t> = 10 sec., valeur par défaut).
Le paramètre empêche peut-être que RK tourne indéfiniment.
Des jokers ("*") sont automatiquement ajoutés au titre de la fenêtre et 
ainsi, il n'est pas utile de faire attention aux majuscules et minuscules.

Exemple: bouton "Explorateur" (image) du profil "Stock"


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

Exemple de scénario 1
=====================

{/BTCH.EXPLICIT}

{/BTCH.STOP}

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

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