1 #include "types.h"
2 
3 extern int fd[2];
4 extern Window ref;
5 
6 void (*TabCom[30]) (int NbArg, long *TabArg);
7 char *(*TabFunc[20]) (int *NbArg, long *TabArg);
8 int (*TabComp[15]) (char *arg1, char *arg2);
9 
10 extern X11base *x11base;
11 extern int grab_serve;
12 extern struct XObj *tabxobj[100];
13 extern void LoadIcon (struct XObj *xobj);
14 
15 extern int nbobj;
16 extern char **TabVVar;
17 extern int TabIdObj[101];
18 extern char *ScriptName;
19 extern char *MyName;
20 extern TypeBuffSend BuffSend;
21 extern Atom propriete;
22 
23 char *BufCom;
24 char Command[255] = "None";
25 time_t TimeCom = 0;
26 
27 /*************************************************************/
28 /* Ensemble de fonction de comparaison de deux entiers       */
29 /*************************************************************/
30 int
Inf(char * arg1,char * arg2)31 Inf (char *arg1, char *arg2)
32 {
33   int an1, an2;
34   an1 = atoi (arg1);
35   an2 = atoi (arg2);
36   return (an1 < an2);
37 }
38 
39 int
InfEq(char * arg1,char * arg2)40 InfEq (char *arg1, char *arg2)
41 {
42   int an1, an2;
43   an1 = atoi (arg1);
44   an2 = atoi (arg2);
45   return (an1 <= an2);
46 }
47 
48 int
Equal(char * arg1,char * arg2)49 Equal (char *arg1, char *arg2)
50 {
51   int an1, an2;
52   an1 = atoi (arg1);
53   an2 = atoi (arg2);
54   return (strcmp (arg1, arg2) == 0);
55 }
56 
57 int
SupEq(char * arg1,char * arg2)58 SupEq (char *arg1, char *arg2)
59 {
60   int an1, an2;
61   an1 = atoi (arg1);
62   an2 = atoi (arg2);
63   return (an1 >= an2);
64 }
65 
66 int
Sup(char * arg1,char * arg2)67 Sup (char *arg1, char *arg2)
68 {
69   int an1, an2;
70   an1 = atoi (arg1);
71   an2 = atoi (arg2);
72   return (an1 > an2);
73 }
74 
75 int
Diff(char * arg1,char * arg2)76 Diff (char *arg1, char *arg2)
77 {
78   int an1, an2;
79   an1 = atoi (arg1);
80   an2 = atoi (arg2);
81   return (strcmp (arg1, arg2) != 0);
82 }
83 
84 /*****************************************************/
85 /* Fonction qui retourne la valeur d'un argument     */
86 /*****************************************************/
87 char *
CalcArg(long * TabArg,int * Ix)88 CalcArg (long *TabArg, int *Ix)
89 {
90   char *TmpStr;
91   int i;
92 
93   if (TabArg[*Ix] > 100000)
94     {				/* Cas du codage d'un nombre */
95       i = (int) TabArg[*Ix] - 200000;
96       TmpStr = (char *) calloc (1, sizeof (char) * 10);
97       sprintf (TmpStr, "%d", i);
98     }
99   else if (TabArg[*Ix] < -200000)
100     {				/* Cas d'un id de fonction de comparaison */
101       i = TabArg[*Ix] + 250000;
102       TmpStr = (char *) calloc (1, sizeof (char) * 10);
103       sprintf (TmpStr, "%d", i);
104     }
105   else if (TabArg[*Ix] < -100000)
106     {				/* Cas d'un id de fonction */
107       TmpStr = TabFunc[TabArg[*Ix] + 150000] (Ix, TabArg);
108     }
109   else
110     {				/* Cas d'une variable */
111       TmpStr = strdup (TabVVar[TabArg[*Ix]]);
112     }
113   return (TmpStr);
114 }
115 
116 /*************************************************************/
117 /* Ensemble des fonctions pour recuperer les prop d'un objet */
118 /*************************************************************/
119 char *
FuncGetValue(int * NbArg,long * TabArg)120 FuncGetValue (int *NbArg, long *TabArg)
121 {
122   char *tmp;
123   long Id;
124 
125   (*NbArg)++;			/* La fonction GetValue n'a qu'un seul argument */
126   tmp = CalcArg (TabArg, NbArg);
127   Id = atoi (tmp);
128   free (tmp);
129   tmp = (char *) calloc (1, sizeof (char) * 10);
130   sprintf (tmp, "%d", tabxobj[TabIdObj[Id]]->value);
131   return tmp;
132 }
133 
134 /* Fonction qui retourne le titre d'un objet */
135 char *
FuncGetTitle(int * NbArg,long * TabArg)136 FuncGetTitle (int *NbArg, long *TabArg)
137 {
138   char *tmp;
139   long Id;
140 
141   (*NbArg)++;
142   tmp = CalcArg (TabArg, NbArg);
143   Id = atoi (tmp);
144   free (tmp);
145   if (TabIdObj[Id] != -1)
146     tmp = strdup (tabxobj[TabIdObj[Id]]->title);
147   else
148     {
149       fprintf (stderr, "Widget %d doesn't exist\n", (int) Id);
150       tmp = (char *) calloc (1, sizeof (char));
151       tmp[0] = '\0';
152     }
153   return tmp;
154 }
155 
156 /* Read an option value in an afterstep file */
157 char *
FuncGetASoption(int * NbArg,long * TabArg)158 FuncGetASoption (int *NbArg, long *TabArg)
159 {
160   int index, i = 2, k = 0, NewWord;
161   int maxsize = MAXLINELENGTH * (MAXLINELENGTH / 2);
162   int found = 0, size;
163   char *cmndbuf, *wordtofind, *str;
164   FILE *f;
165 
166   (*NbArg)++;
167   cmndbuf = CalcArg (TabArg, NbArg);
168   (*NbArg)++;
169   wordtofind = CalcArg (TabArg, NbArg);
170   (*NbArg)++;
171   str = CalcArg (TabArg, NbArg);
172   index = atoi (str);
173   free (str);
174 
175   printf ("\n �� command: %s\n", cmndbuf);
176   printf ("\n �� word to find: %s\n", wordtofind);
177   printf ("\n �� #argument to read: %d\n", index);
178 
179 /* Read command output */
180   if ((strcmp (Command, cmndbuf)) || ((time (NULL) - TimeCom) > 1) || (TimeCom == 0))
181     {
182       if ((f = popen (cmndbuf, "r")) == NULL)
183 	{
184 	  fprintf (stderr, "%s: can't run %s\n", ScriptName, cmndbuf);
185 	  str = (char *) calloc (sizeof (char), 10);
186 	  free (cmndbuf);
187 	  return str;
188 	}
189       else
190 	{
191 	  if (strcmp (Command, "None"))
192 	    free (BufCom);
193 	  BufCom = (char *) calloc (sizeof (char), maxsize);
194 	  size = fread (BufCom, 1, maxsize, f);
195 	  pclose (f);
196 	  strcpy (Command, cmndbuf);
197 	  TimeCom = time (NULL);
198 	}
199     }
200 /* Function differs, depending on whether index >= 0 or index < 0 */
201 
202   if (index < 0)
203     {
204 /* should return the whole abs(index) line */
205       index = abs (index);
206     }
207 /* Now seek for wordtofind in &BufCom[int] */
208   while ((&BufCom[k] != (char *) 0) && (BufCom[k] != '\0') && (found == 0))
209     {
210       while (isspace (*&BufCom[k]))
211 	BufCom[k]++;
212 
213       if (mystrncasecmp (&BufCom[k], wordtofind, strlen (wordtofind)) == 0)
214 	found = k;
215       else
216 	k++;
217     }
218 
219   printf ("\n �� good line: %d", found);
220 
221 /* Return the #(index) argument, if 0, whole line */
222   if (index != 0)
223     {
224       i = 1;
225       NewWord = 0;
226       while ((i < index) && (BufCom[found] != '\n') && (BufCom[found] != '\0'))
227 	{
228 	  if (BufCom[found++] == ' ')
229 	    {
230 	      if (NewWord)
231 		{
232 		  i++;
233 		  NewWord = 0;
234 		}
235 	    }
236 	  else if (!NewWord)
237 	    NewWord = 1;
238 	}
239       str = (char *) calloc (sizeof (char), 255);
240       sscanf (&BufCom[found], "%s", str);
241     }
242   else
243     {
244       if (i != 2)
245 	found++;
246       k = found;
247       while ((BufCom[k] != '\n') && (BufCom[k] != '\0'))
248 	k++;
249       str = (char *) calloc (sizeof (char), k - found + 1);
250       memmove (str, &BufCom[found], k - found);
251       str[k - found] = '\0';
252     }
253   free (cmndbuf);
254   return str;
255 }
256 
257 /* Read an option value in an afterstep file */
258 char *
FuncSetASoption(int * NbArg,long * TabArg)259 FuncSetASoption (int *NbArg, long *TabArg)
260 {
261 #if 0
262   TO
263     BE
264     DONE
265 #endif
266     return NULL;
267 }
268 
269 /* Fonction qui retourne la sortie d'une commande */
270 char *
FuncGetOutput(int * NbArg,long * TabArg)271 FuncGetOutput (int *NbArg, long *TabArg)
272 {
273   char *cmndbuf;
274   char *str;
275   int line, index, i = 2, j = 0, k, NewWord;
276   FILE *f;
277   int maxsize = 32000;
278   int size;
279 
280   (*NbArg)++;
281   cmndbuf = CalcArg (TabArg, NbArg);
282   (*NbArg)++;
283   str = CalcArg (TabArg, NbArg);
284   line = atoi (str);
285   free (str);
286   (*NbArg)++;
287   str = CalcArg (TabArg, NbArg);
288   index = atoi (str);
289   free (str);
290 
291   if ((strcmp (Command, cmndbuf)) || ((time (NULL) - TimeCom) > 1) || (TimeCom
292 								       == 0))
293     {
294       if ((f = popen (cmndbuf, "r")) == NULL)
295 	{
296 	  fprintf (stderr, "%s: can't run %s\n", ScriptName, cmndbuf);
297 	  str = (char *) calloc (sizeof (char), 10);
298 	  free (cmndbuf);
299 	  return str;
300 	}
301       else
302 	{
303 	  if (strcmp (Command, "None"))
304 	    free (BufCom);
305 	  BufCom = (char *) calloc (sizeof (char), maxsize);
306 	  size = fread (BufCom, 1, maxsize, f);
307 	  pclose (f);
308 	  strcpy (Command, cmndbuf);
309 	  TimeCom = time (NULL);
310 	}
311     }
312   /* Recherche de la ligne */
313   while ((i <= line) && (BufCom[j] != '\0'))
314     {
315       j++;
316       if (BufCom[j] == '\n')
317 	i++;
318     }
319 
320   /* Recherche du mot */
321   if (index != -1)
322     {
323       if (i != 2)
324 	j++;
325       i = 1;
326       NewWord = 0;
327       while ((i < index) && (BufCom[j] != '\n') && (BufCom[j] != '\0'))
328 	{
329 	  j++;
330 	  if (BufCom[j] == ' ')
331 	    {
332 	      if (NewWord)
333 		{
334 		  i++;
335 		  NewWord = 0;
336 		}
337 	    }
338 	  else if (!NewWord)
339 	    NewWord = 1;
340 	}
341       str = (char *) calloc (sizeof (char), 255);
342       sscanf (&BufCom[j], "%s", str);
343     }
344   else
345     {				/* Lecture de la ligne complete */
346       if (i != 2)
347 	j++;
348       k = j;
349       while ((BufCom[k] != '\n') && (BufCom[k] != '\0'))
350 	k++;
351       str = (char *) calloc (sizeof (char), k - j + 1);
352       memmove (str, &BufCom[j], k - j);
353       str[k - j] = '\0';
354     }
355 
356   free (cmndbuf);
357   return str;
358 }
359 
360 /* Convertion decimal vers hexadecimal */
361 char *
FuncNumToHex(int * NbArg,long * TabArg)362 FuncNumToHex (int *NbArg, long *TabArg)
363 {
364   char *str;
365   int value, nbchar;
366   int i, j;
367 
368   (*NbArg)++;
369   str = CalcArg (TabArg, NbArg);
370   value = atoi (str);
371   free (str);
372   (*NbArg)++;
373   str = CalcArg (TabArg, NbArg);
374   nbchar = atoi (str);
375   free (str);
376 
377   str = (char *) calloc (1, nbchar + 10);
378   sprintf (str, "%X", value);
379   j = strlen (str);
380   if (j < nbchar)
381     {
382       memmove (&str[nbchar - j], str, j);
383       for (i = 0; i < (nbchar - j); i++)
384 	str[i] = '0';
385     }
386   return str;
387 }
388 
389 /* Convertion hexadecimal vers decimal */
390 char *
FuncHexToNum(int * NbArg,long * TabArg)391 FuncHexToNum (int *NbArg, long *TabArg)
392 {
393   char *str, *str2;
394   int k;
395 
396   (*NbArg)++;
397   str = CalcArg (TabArg, NbArg);
398   if (str[0] == '#')
399     memmove (str, &str[1], strlen (str));
400   k = (int) strtol (str, NULL, 16);
401   free (str);
402 
403   str2 = (char *) calloc (1, 20);
404   sprintf (str2, "%d", k);
405   return str2;
406 }
407 char *
FuncAdd(int * NbArg,long * TabArg)408 FuncAdd (int *NbArg, long *TabArg)
409 {
410   char *str;
411   int val1, val2;
412 
413   (*NbArg)++;
414   str = CalcArg (TabArg, NbArg);
415   val1 = atoi (str);
416   free (str);
417   (*NbArg)++;
418   str = CalcArg (TabArg, NbArg);
419   val2 = atoi (str);
420   free (str);
421   str = (char *) calloc (1, 20);
422   sprintf (str, "%d", val1 + val2);
423   return str;
424 }
425 char *
FuncMult(int * NbArg,long * TabArg)426 FuncMult (int *NbArg, long *TabArg)
427 {
428   char *str;
429   int val1, val2;
430 
431   (*NbArg)++;
432   str = CalcArg (TabArg, NbArg);
433   val1 = atoi (str);
434   free (str);
435   (*NbArg)++;
436   str = CalcArg (TabArg, NbArg);
437   val2 = atoi (str);
438   free (str);
439   str = (char *) calloc (1, 20);
440   sprintf (str, "%d", val1 * val2);
441   return str;
442 }
443 char *
FuncDiv(int * NbArg,long * TabArg)444 FuncDiv (int *NbArg, long *TabArg)
445 {
446   char *str;
447   int val1, val2;
448 
449   (*NbArg)++;
450   str = CalcArg (TabArg, NbArg);
451   val1 = atoi (str);
452   free (str);
453   (*NbArg)++;
454   str = CalcArg (TabArg, NbArg);
455   val2 = atoi (str);
456   free (str);
457   str = (char *) calloc (1, 20);
458   sprintf (str, "%d", val1 / val2);
459   return str;
460 }
461 char *
RemainderOfDiv(int * NbArg,long * TabArg)462 RemainderOfDiv (int *NbArg, long *TabArg)
463 {
464   char *str;
465   int val1, val2;
466   div_t res;
467 
468   (*NbArg)++;
469   str = CalcArg (TabArg, NbArg);
470   val1 = atoi (str);
471   free (str);
472   (*NbArg)++;
473   str = CalcArg (TabArg, NbArg);
474   val2 = atoi (str);
475   free (str);
476   str = (char *) calloc (1, 20);
477   res = div (val1, val2);
478   sprintf (str, "%d", res.rem);
479   return str;
480 }
481 char *
FuncStrCopy(int * NbArg,long * TabArg)482 FuncStrCopy (int *NbArg, long *TabArg)
483 {
484   char *str, *strsrc;
485   int i1, i2;
486 
487   (*NbArg)++;
488   strsrc = CalcArg (TabArg, NbArg);
489   (*NbArg)++;
490   str = CalcArg (TabArg, NbArg);
491   i1 = atoi (str);
492   if (i1 < 1)
493     i1 = 1;
494   free (str);
495   (*NbArg)++;
496   str = CalcArg (TabArg, NbArg);
497   i2 = atoi (str);
498   if (i2 < 1)
499     i2 = 1;
500   free (str);
501 
502   if ((i1 <= i2) && (i1 <= strlen (strsrc)))
503     {
504       if (i2 > strlen (strsrc))
505 	i2 = strlen (strsrc);
506       str = (char *) calloc (1, i2 - i1 + 2);
507       memmove (str, &strsrc[i1 - 1], i2 - i1 + 1);
508     }
509   else
510     {
511       str = (char *) calloc (1, 1);
512     }
513 
514   free (strsrc);
515   return str;
516 }
517 
518 /* Lancement d'un script avec pipe */
519 char *
LaunchScript(int * NbArg,long * TabArg)520 LaunchScript (int *NbArg, long *TabArg)
521 {
522   char *arg, *execstr, *str, *scriptarg, *scriptname;
523   int leng, i;
524   Atom MyAtom;
525 
526   /* Lecture des arguments */
527   (*NbArg)++;
528   arg = CalcArg (TabArg, NbArg);
529 
530   str = (char *) calloc (100, sizeof (char));
531 
532   /* Calcul du nom du script fils */
533   x11base->TabScriptId[x11base->NbChild + 2] = (char *) calloc (strlen (x11base->TabScriptId[1]) + 4, sizeof (char));
534 
535   if (x11base->NbChild < 98)
536     {
537       i = 16;
538       do
539 	{
540 	  sprintf (x11base->TabScriptId[x11base->NbChild + 2], "%s%x", x11base->TabScriptId[1], i);
541 	  MyAtom = XInternAtom (x11base->display, x11base->TabScriptId[x11base->NbChild + 2], False);
542 	  i++;
543 	}
544       while (XGetSelectionOwner (x11base->display, MyAtom) != None);
545     }
546   else
547     {
548       fprintf (stderr, "Too many launched script\n");
549       sprintf (str, "-1");
550       return str;
551     }
552 
553   /* Construction de la commande */
554   execstr = (char *) calloc (strlen (MyName) + strlen (arg) +
555     strlen (x11base->TabScriptId[x11base->NbChild + 2]) + 5, sizeof (char));
556   scriptname = (char *) calloc (sizeof (char), 100);
557   sscanf (arg, "%s", scriptname);
558   scriptarg = (char *) calloc (sizeof (char), strlen (arg));
559   scriptarg = (char *) strncpy (scriptarg, &arg[strlen (scriptname)], strlen (arg) - strlen (scriptname));
560   sprintf (execstr, "%s %s %s %s", MyName, scriptname,
561 	   x11base->TabScriptId[x11base->NbChild + 2], scriptarg);
562   free (scriptname);
563   free (scriptarg);
564   free (arg);
565 
566   /* Envoi de la commande */
567   write (fd[0], &ref, sizeof (Window));
568   leng = strlen (execstr);
569   write (fd[0], &leng, sizeof (int));
570   write (fd[0], execstr, leng);
571   leng = 1;
572   write (fd[0], &leng, sizeof (int));
573   free (execstr);
574 
575   /* Retourne l'id du fils */
576   sprintf (str, "%d", x11base->NbChild + 2);
577   x11base->NbChild++;
578   return str;
579 }
580 
581 char *
GetScriptFather(int * NbArg,long * TabArg)582 GetScriptFather (int *NbArg, long *TabArg)
583 {
584   char *str;
585 
586   str = (char *) calloc (10, sizeof (char));
587   sprintf (str, "0");
588   return str;
589 }
590 char *
GetTime(int * NbArg,long * TabArg)591 GetTime (int *NbArg, long *TabArg)
592 {
593   char *str;
594   time_t t;
595 
596   str = (char *) calloc (20, sizeof (char));
597   t = time (NULL);
598   sprintf (str, "%ld", (long) t - x11base->BeginTime);
599   return str;
600 }
601 char *
GetScriptArg(int * NbArg,long * TabArg)602 GetScriptArg (int *NbArg, long *TabArg)
603 {
604   char *str;
605   int val1;
606 
607   (*NbArg)++;
608   str = CalcArg (TabArg, NbArg);
609   val1 = atoi (str);
610   free (str);
611 
612   str = (char *) calloc (strlen (x11base->TabArg[val1]) + 1, sizeof (char));
613   str = strcpy (str, x11base->TabArg[val1]);
614 
615   return str;
616 }
617 char *
ReceivFromScript(int * NbArg,long * TabArg)618 ReceivFromScript (int *NbArg, long *TabArg)
619 {
620   char *arg, *msg;
621   int send;
622   Atom AReceiv, ASend, type;
623   static XEvent event;
624   unsigned long longueur, octets_restant;
625   unsigned char *donnees = "";
626   int format;
627   int NbEssai = 0;
628 
629   (*NbArg)++;
630   arg = CalcArg (TabArg, NbArg);
631   send = (int) atoi (arg);
632   free (arg);
633 
634   msg = (char *) calloc (256, sizeof (char));
635   sprintf (msg, "No message");
636 
637   /* Recuperation des atomes */
638   AReceiv = XInternAtom (x11base->display, x11base->TabScriptId[1], True);
639   if (AReceiv == None)
640     {
641       fprintf (stderr, "Error with atome\n");
642       return msg;
643     }
644   if ((send >= 0) && (send < 99))
645     if (x11base->TabScriptId[send] != NULL)
646       {
647 	ASend = XInternAtom (x11base->display, x11base->TabScriptId[send], True);
648 	if (ASend == None)
649 	  fprintf (stderr, "Error with atome\n");
650       }
651     else
652       return msg;
653   else
654     return msg;
655 
656   /* Recuperation du message */
657   XConvertSelection (x11base->display, ASend, AReceiv, propriete, x11base->win, CurrentTime);
658   while ((!XCheckTypedEvent (x11base->display, SelectionNotify, &event)) && (NbEssai < 25000))
659     NbEssai++;
660   if (event.xselection.property != None)
661     if (event.xselection.selection == ASend)
662       {
663 	XGetWindowProperty (x11base->display, event.xselection.requestor, event.xselection.property, 0,
664 			    8192, False, event.xselection.target, &type, &format, &longueur, &octets_restant,
665 			    &donnees);
666 	if (longueur > 0)
667 	  {
668 	    msg = (char *) realloc ((void *) msg, (longueur + 1) * sizeof (char));
669 	    msg = strcpy (msg, donnees);
670 	    XDeleteProperty (x11base->display, event.xselection.requestor, event.xselection.property);
671 	    XFree (donnees);
672 	  }
673       }
674   return msg;
675 }
676 
677 
678 /***********************************************/
679 /* Ensemble des commandes possible pour un obj */
680 /***********************************************/
681 
682 void
Exec(int NbArg,long * TabArg)683 Exec (int NbArg, long *TabArg)
684 {
685   int leng;
686   char *execstr;
687   char *tempstr;
688   int i;
689 
690   execstr = (char *) calloc (1, 256);
691   for (i = 0; i < NbArg; i++)
692     {
693       tempstr = CalcArg (TabArg, &i);
694       execstr = strcat (execstr, tempstr);
695       free (tempstr);
696     }
697   write (fd[0], &ref, sizeof (Window));
698   leng = strlen (execstr);
699   write (fd[0], &leng, sizeof (int));
700   write (fd[0], execstr, leng);
701   leng = 1;
702   write (fd[0], &leng, sizeof (int));
703 
704 
705   free (execstr);
706 }
707 
708 void
HideObj(int NbArg,long * TabArg)709 HideObj (int NbArg, long *TabArg)
710 {
711   char *arg[1];
712   int IdItem;
713   int i = 0;
714 
715   arg[0] = CalcArg (TabArg, &i);
716   IdItem = TabIdObj[atoi (arg[0])];
717 
718   tabxobj[IdItem]->flags[0] = True;
719   /* On cache la fentre pour la faire disparaitre */
720   XUnmapWindow (x11base->display, tabxobj[IdItem]->win);
721   free (arg[0]);
722 }
723 void
ShowObj(int NbArg,long * TabArg)724 ShowObj (int NbArg, long *TabArg)
725 {
726   char *arg[1];
727   int IdItem;
728   int i = 0;
729 
730   arg[0] = CalcArg (TabArg, &i);
731   IdItem = TabIdObj[atoi (arg[0])];
732 
733   tabxobj[IdItem]->flags[0] = False;
734   XMapWindow (x11base->display, tabxobj[IdItem]->win);
735   tabxobj[IdItem]->DrawObj (tabxobj[IdItem]);
736   free (arg[0]);
737 }
738 void
ChangeValue(int NbArg,long * TabArg)739 ChangeValue (int NbArg, long *TabArg)
740 {
741   int i = 0;
742   char *arg[2];
743 
744   arg[0] = CalcArg (TabArg, &i);
745   i++;
746   arg[1] = CalcArg (TabArg, &i);
747 
748   tabxobj[TabIdObj[atoi (arg[0])]]->value = atoi (arg[1]);
749   /* On redessine l'objet pour le mettre a jour */
750   tabxobj[TabIdObj[atoi (arg[0])]]->DrawObj (tabxobj[TabIdObj[atoi (arg[0])]]);
751   free (arg[0]);
752   free (arg[1]);
753 }
754 void
ChangeValueMax(int NbArg,long * TabArg)755 ChangeValueMax (int NbArg, long *TabArg)
756 {
757   int i = 0;
758   char *arg[2];
759   int j;
760 
761   arg[0] = CalcArg (TabArg, &i);
762   j = atoi (arg[0]);
763   i++;
764   arg[1] = CalcArg (TabArg, &i);
765 
766   tabxobj[TabIdObj[j]]->value3 = atoi (arg[1]);
767   /* On redessine l'objet pour le mettre a jour */
768   if (tabxobj[TabIdObj[j]]->value > tabxobj[TabIdObj[j]]->value3)
769     {
770       tabxobj[TabIdObj[j]]->value = atoi (arg[1]);
771       tabxobj[TabIdObj[j]]->DrawObj (tabxobj[TabIdObj[j]]);
772     }
773   free (arg[0]);
774   free (arg[1]);
775 }
776 
777 void
ChangeValueMin(int NbArg,long * TabArg)778 ChangeValueMin (int NbArg, long *TabArg)
779 {
780   int i = 0;
781   char *arg[2];
782   int j;
783 
784   arg[0] = CalcArg (TabArg, &i);
785   i++;
786   arg[1] = CalcArg (TabArg, &i);
787   j = atoi (arg[0]);
788 
789   tabxobj[TabIdObj[j]]->value2 = atoi (arg[1]);
790   /* On redessine l'objet pour le mettre a jour */
791   if (tabxobj[TabIdObj[j]]->value < tabxobj[TabIdObj[j]]->value2)
792     {
793       tabxobj[TabIdObj[j]]->value = atoi (arg[1]);
794       tabxobj[TabIdObj[j]]->DrawObj (tabxobj[TabIdObj[j]]);
795     }
796   free (arg[0]);
797   free (arg[1]);
798 }
799 
800 void
ChangePos(int NbArg,long * TabArg)801 ChangePos (int NbArg, long *TabArg)
802 {
803   int i = 0;
804   char *arg[3];
805   int an[3];
806   int IdItem;
807 
808   arg[0] = CalcArg (TabArg, &i);
809   i++;
810   arg[1] = CalcArg (TabArg, &i);
811   i++;
812   arg[2] = CalcArg (TabArg, &i);
813 
814   IdItem = TabIdObj[atoi (arg[0])];
815   for (i = 1; i < 3; i++)
816     an[i] = atoi (arg[i]);
817   tabxobj[IdItem]->x = an[1];
818   tabxobj[IdItem]->y = an[2];
819   XMoveWindow (x11base->display, tabxobj[IdItem]->win, an[1], an[2]);
820 
821   free (arg[0]);
822   free (arg[1]);
823   free (arg[2]);
824 
825 }
826 void
ChangeFont(int NbArg,long * TabArg)827 ChangeFont (int NbArg, long *TabArg)
828 {
829   int i = 0;
830   char *arg[2];
831   int IdItem;
832   MyFont xfont;
833 
834   arg[0] = CalcArg (TabArg, &i);
835   i++;
836   arg[1] = CalcArg (TabArg, &i);
837   IdItem = TabIdObj[atoi (arg[0])];
838 
839   tabxobj[IdItem]->font = strdup (arg[1]);
840   if (!load_font (tabxobj[IdItem]->font, &xfont))
841     {
842       fprintf (stderr, "Can't load font %s\n", tabxobj[IdItem]->font);
843     }
844   else
845     {
846       unload_font (&tabxobj[IdItem]->xfont);
847       tabxobj[IdItem]->xfont = xfont;
848       XSetFont (tabxobj[IdItem]->display, tabxobj[IdItem]->gc, tabxobj[IdItem]->xfont.font->fid);
849     }
850   tabxobj[IdItem]->DrawObj (tabxobj[IdItem]);
851   free (arg[0]);
852   free (arg[1]);
853 }
854 
855 void
ChangeSize(int NbArg,long * TabArg)856 ChangeSize (int NbArg, long *TabArg)
857 {
858   int i = 0;
859   char *arg[3];
860   int an[3];
861   int IdItem;
862 
863   arg[0] = CalcArg (TabArg, &i);
864   i++;
865   arg[1] = CalcArg (TabArg, &i);
866   i++;
867   arg[2] = CalcArg (TabArg, &i);
868 
869   IdItem = TabIdObj[atoi (arg[0])];
870   for (i = 1; i < 3; i++)
871     an[i] = atoi (arg[i]);
872   tabxobj[IdItem]->width = an[1];
873   tabxobj[IdItem]->height = an[2];
874   XResizeWindow (x11base->display, tabxobj[IdItem]->win, an[1], an[2]);
875   tabxobj[IdItem]->DrawObj (tabxobj[IdItem]);
876   free (arg[0]);
877   free (arg[1]);
878   free (arg[2]);
879 }
880 void
ChangeTitle(int NbArg,long * TabArg)881 ChangeTitle (int NbArg, long *TabArg)
882 {
883   int i = 0;
884   char *arg[2];
885   int IdItem;
886 
887   arg[0] = CalcArg (TabArg, &i);
888   i++;
889   arg[1] = CalcArg (TabArg, &i);
890   IdItem = TabIdObj[atoi (arg[0])];
891 
892   tabxobj[IdItem]->title = strdup (arg[1]);
893   tabxobj[IdItem]->DrawObj (tabxobj[IdItem]);
894   free (arg[0]);
895   free (arg[1]);
896 }
897 void
ChangeIcon(int NbArg,long * TabArg)898 ChangeIcon (int NbArg, long *TabArg)
899 {
900   int i = 0;
901   char *arg[2];
902   int IdItem;
903 
904   arg[0] = CalcArg (TabArg, &i);
905   i++;
906   arg[1] = CalcArg (TabArg, &i);
907   IdItem = TabIdObj[atoi (arg[0])];
908 
909 /* if (tabxobj[IdItem]->icon!=NULL)
910    {
911    free(tabxobj[IdItem]->icon);
912    if (tabxobj[IdItem]->iconPixmap!=None)
913    XFreePixmap(tabxobj[IdItem]->display,tabxobj[IdItem]->iconPixmap);
914    if (tabxobj[IdItem]->icon_maskPixmap!=None)
915    XFreePixmap(tabxobj[IdItem]->display,tabxobj[IdItem]->icon_maskPixmap);
916    }
917  */
918   tabxobj[IdItem]->icon = strdup (arg[1]);
919   LoadIcon (tabxobj[IdItem]);
920   tabxobj[IdItem]->DrawObj (tabxobj[IdItem]);
921   free (arg[0]);
922   free (arg[1]);
923 }
924 void
ChangeForeColor(int NbArg,long * TabArg)925 ChangeForeColor (int NbArg, long *TabArg)
926 {
927   int i = 0;
928   char *arg[2];
929   int IdItem;
930 
931   arg[0] = CalcArg (TabArg, &i);
932   i++;
933   arg[1] = CalcArg (TabArg, &i);
934   IdItem = TabIdObj[atoi (arg[0])];
935 
936   /* Liberation de la couleur */
937   XFreeColors (tabxobj[IdItem]->display, *(tabxobj[IdItem])->colormap,
938 	       (void *) (&(tabxobj[IdItem])->TabColor[fore]), 1, 0);
939 
940   tabxobj[IdItem]->forecolor = (char *) calloc (100, sizeof (char));
941   sprintf (tabxobj[IdItem]->forecolor, "%s", arg[1]);
942 
943   MyAllocNamedColor (tabxobj[IdItem]->forecolor, &(tabxobj[IdItem])->TabColor[fore]);
944 
945   tabxobj[IdItem]->DrawObj (tabxobj[IdItem]);
946 
947   free (arg[0]);
948   free (arg[1]);
949 
950 }
951 void
ChangeBackColor(int NbArg,long * TabArg)952 ChangeBackColor (int NbArg, long *TabArg)
953 {
954   int i = 0;
955   char *arg[2];
956   int IdItem;
957 
958   arg[0] = CalcArg (TabArg, &i);
959   i++;
960   arg[1] = CalcArg (TabArg, &i);
961   IdItem = TabIdObj[atoi (arg[0])];
962 
963   /* Liberation de la couleur */
964   XFreeColors (tabxobj[IdItem]->display, *(tabxobj[IdItem])->colormap,
965 	       (void *) (&(tabxobj[IdItem])->TabColor[back]), 1, 0);
966 
967   tabxobj[IdItem]->backcolor = (char *) calloc (100, sizeof (char));
968   sprintf (tabxobj[IdItem]->backcolor, "%s", arg[1]);
969 
970   MyAllocNamedColor (tabxobj[IdItem]->backcolor, &(tabxobj[IdItem])->TabColor[back]);
971 
972   tabxobj[IdItem]->DrawObj (tabxobj[IdItem]);
973 
974   free (arg[0]);
975   free (arg[1]);
976 }
977 void
SetVar(int NbArg,long * TabArg)978 SetVar (int NbArg, long *TabArg)
979 {
980   int i;
981   char *str, *tempstr;
982 
983   str = (char *) calloc (sizeof (char), 1);
984   for (i = 1; i < NbArg; i++)
985     {
986       tempstr = CalcArg (TabArg, &i);
987       str = (char *) realloc ((void *) str, sizeof (char) * (1 + strlen (str) + strlen (tempstr)));
988       str = strcat (str, tempstr);
989       free (tempstr);
990     }
991   free (TabVVar[TabArg[0]]);
992   TabVVar[TabArg[0]] = str;
993 }
994 
995 void
SendSign(int NbArg,long * TabArg)996 SendSign (int NbArg, long *TabArg)
997 {
998   int i = 0;
999   char *arg[2];
1000   int IdItem;
1001   int TypeMsg;
1002 
1003   arg[0] = CalcArg (TabArg, &i);
1004   i++;
1005   arg[1] = CalcArg (TabArg, &i);
1006   IdItem = TabIdObj[atoi (arg[0])];
1007   TypeMsg = atoi (arg[1]);
1008   SendMsg (tabxobj[IdItem], TypeMsg);
1009   free (arg[0]);
1010   free (arg[1]);
1011 }
1012 void
WarpPointer(int NbArg,long * TabArg)1013 WarpPointer (int NbArg, long *TabArg)
1014 {
1015   int i = 0;
1016   char *arg;
1017   int IdItem;
1018 
1019   arg = CalcArg (TabArg, &i);
1020   IdItem = TabIdObj[atoi (arg)];
1021   /* Deplacement du pointeur sur l'objet */
1022   XWarpPointer (x11base->display, None, tabxobj[IdItem]->win, 0, 0, 0, 0,
1023 		tabxobj[IdItem]->width / 2, tabxobj[IdItem]->height + 10);
1024   free (arg);
1025 }
1026 void
Quit(int NbArg,long * TabArg)1027 Quit (int NbArg, long *TabArg)
1028 {
1029   int i;
1030   static XEvent event;
1031   fd_set in_fdset;
1032   extern int x_fd;
1033   Atom MyAtom;
1034   int NbEssai = 0;
1035   struct timeval tv;
1036 
1037 #ifdef DEBUG			/* For debugging */
1038   XSync (x11base->display, 0);
1039 #endif
1040 
1041   /* On cache la fenetre */
1042   XUnmapWindow (x11base->display, x11base->win);
1043   XFlush (x11base->display);
1044 
1045   /* Le script ne possede plus la propriete */
1046   MyAtom = XInternAtom (x11base->display, x11base->TabScriptId[1], False);
1047   XSetSelectionOwner (x11base->display, MyAtom, x11base->root, CurrentTime);
1048 
1049   /* On verifie si tous les messages ont ete envoyes */
1050   while ((BuffSend.NbMsg > 0) && (NbEssai < 10000))
1051     {
1052       tv.tv_sec = 1;
1053       tv.tv_usec = 0;
1054       FD_ZERO (&in_fdset);
1055       FD_SET (x_fd, &in_fdset);
1056       select (32, &in_fdset, NULL, NULL, &tv);
1057       if (FD_ISSET (x_fd, &in_fdset))
1058 	{
1059 	  if (XCheckTypedEvent (x11base->display, SelectionRequest, &event))
1060 	    SendMsgToScript (event);
1061 	  else
1062 	    NbEssai++;
1063 	}
1064     }
1065   XFlush (x11base->display);
1066 
1067   /* Attente de deux secondes afin d'etre sur que tous */
1068   /* les messages soient arrives a destination         */
1069   /* On quitte proprement le serveur X */
1070   for (i = 0; i < nbobj; i++)
1071     tabxobj[i]->DestroyObj (tabxobj[i]);
1072   XFlush (x11base->display);
1073 /* XSync(x11base->display,True); */
1074   sleep (2);
1075   XFreeGC (x11base->display, x11base->gc);
1076   XFreeColormap (x11base->display, x11base->colormap);
1077   XDestroyWindow (x11base->display, x11base->win);
1078   XCloseDisplay (x11base->display);
1079   exit (0);
1080 }
1081 
1082 void
IfThen(int NbArg,long * TabArg)1083 IfThen (int NbArg, long *TabArg)
1084 {
1085   char *arg[10];
1086   int i, j;
1087   int CurrArg = 0;
1088   int IdFuncComp = 0;
1089 
1090   /* Verification de la condition */
1091   for (j = 0; j < NbArg - 2; j++)
1092     {
1093       if (TabArg[j] > 100000)
1094 	{			/* Cas du codage d'un nombre */
1095 	  i = (int) TabArg[j] - 200000;
1096 	  arg[CurrArg] = (char *) calloc (1, sizeof (char) * 10);
1097 	  sprintf (arg[CurrArg], "%d", i);
1098 	  CurrArg++;
1099 	}
1100       else if (TabArg[j] < -200000)
1101 	{			/* Cas d'un id de fonction de comparaison */
1102 	  IdFuncComp = TabArg[j] + 250000;
1103 	}
1104       else if (TabArg[j] < -100000)
1105 	{			/* Cas d'un id de fonction */
1106 	  arg[CurrArg] = TabFunc[TabArg[j] + 150000] (&j, TabArg);
1107 	  CurrArg++;
1108 	}
1109       else
1110 	{			/* Cas d'une variable */
1111 	  arg[CurrArg] = strdup (TabVVar[TabArg[j]]);
1112 	  CurrArg++;
1113 	}
1114     }
1115 
1116   /* Comparaison des arguments */
1117   if (TabComp[IdFuncComp] (arg[0], arg[1]))
1118     ExecBloc ((Bloc *) TabArg[NbArg - 2]);
1119   else if (TabArg[NbArg - 1] != 0)
1120     ExecBloc ((Bloc *) TabArg[NbArg - 1]);
1121 
1122   free (arg[0]);
1123   free (arg[1]);
1124 }
1125 
1126 /* Instruction boucle */
1127 void
Loop(int NbArg,long * TabArg)1128 Loop (int NbArg, long *TabArg)
1129 {
1130   int IdVar;
1131   char *arg[2];
1132   int limit[2];
1133   int i;
1134   int CurrArg = 0;
1135 
1136   /* le premier argument est une variable */
1137   IdVar = TabArg[0];
1138   /*On ajuste la taille de la var pour contenir un nombre */
1139   TabVVar[TabArg[0]] = (char *) realloc (TabVVar[TabArg[0]], sizeof (char) * 10);
1140   /* Calcul des 2 autres arguments */
1141   for (i = 1; i < NbArg - 1; i++)
1142     {
1143       if (TabArg[i] > 100000)
1144 	{			/* Cas du codage d'un nombre */
1145 	  i = (int) TabArg[i] - 200000;
1146 	  arg[CurrArg] = (char *) calloc (1, sizeof (char) * 10);
1147 	  sprintf (arg[CurrArg], "%d", i);
1148 	}
1149       else if (TabArg[i] < -100000)
1150 	{			/* Cas d'un id de fonction */
1151 	  arg[CurrArg] = TabFunc[TabArg[i] + 150000] (&i, TabArg);
1152 	}
1153       else			/* Cas d'une variable */
1154 	arg[CurrArg] = strdup (TabVVar[TabArg[i]]);
1155       CurrArg++;
1156     }
1157   limit[0] = atoi (arg[0]);
1158   limit[1] = atoi (arg[1]);
1159   if (limit[0] < limit[1])
1160     for (i = limit[0]; i <= limit[1]; i++)
1161       {
1162 	/* On met a jour la variable */
1163 	sprintf (TabVVar[TabArg[0]], "%d", i);
1164 	ExecBloc ((Bloc *) TabArg[NbArg - 1]);
1165       }
1166   else
1167     for (i = limit[0]; i <= limit[1]; i++)
1168       {
1169 	sprintf (TabVVar[TabArg[0]], "%d", i);
1170 	ExecBloc ((Bloc *) TabArg[NbArg - 1]);
1171       }
1172 
1173   free (arg[0]);
1174   free (arg[1]);
1175 }
1176 
1177 /* Instruction While */
1178 void
While(int NbArg,long * TabArg)1179 While (int NbArg, long *TabArg)
1180 {
1181   char *arg[3], *str;
1182   int i;
1183   int Loop = 1;
1184   int IdFuncComp;
1185 
1186   while (Loop)
1187     {
1188       i = 0;
1189       arg[0] = CalcArg (TabArg, &i);
1190       i++;
1191       str = CalcArg (TabArg, &i);
1192       IdFuncComp = atoi (str);
1193       free (str);
1194       i++;
1195       arg[1] = CalcArg (TabArg, &i);
1196 
1197       Loop = TabComp[IdFuncComp] (arg[0], arg[1]);
1198       if (Loop)
1199 	ExecBloc ((Bloc *) TabArg[NbArg - 1]);
1200       free (arg[0]);
1201       free (arg[1]);
1202     }
1203 }
1204 void
WriteToFile(int NbArg,long * TabArg)1205 WriteToFile (int NbArg, long *TabArg)
1206 {
1207   int i = 0;
1208   char *arg[2], str[50], *tempstr, *home, *file;
1209   FILE *f;
1210   char StrBegin[100];
1211   char StrEnd[10];
1212   size_t size;
1213   char *buf;
1214   int maxsize = 32000;
1215   int CurrPos = 0, CurrPos2;
1216   int OldPID;
1217 
1218   arg[0] = CalcArg (TabArg, &i);
1219   arg[1] = (char *) calloc (1, 256);
1220   for (i = 1; i < NbArg; i++)
1221     {
1222       tempstr = CalcArg (TabArg, &i);
1223       arg[1] = strcat (arg[1], tempstr);
1224       free (tempstr);
1225     }
1226   if (arg[1][strlen (arg[1]) - 1] != '\n')
1227     {
1228       i = strlen (arg[1]);
1229       arg[1] = (char *) realloc (arg[1], strlen (arg[1]) + 2);
1230       arg[1][i] = '\n';
1231       arg[1][i + 1] = '\0';
1232     }
1233   sprintf (StrEnd, "#end\n");
1234   sprintf (StrBegin, "#%s,", ScriptName);
1235 
1236   buf = (char *) calloc (1, maxsize);
1237 
1238   if (arg[0][0] != '/')
1239     {
1240       file = strdup (arg[0]);
1241       home = getenv ("HOME");
1242       arg[0] = (char *) realloc (arg[0], sizeof (char) * (strlen (arg[0]) + 4 + strlen (home)));
1243       sprintf (arg[0], "%s/%s", home, file);
1244       /*  free(home);  BUG */
1245       free (file);
1246     }
1247   f = fopen (arg[0], "a+");
1248   fseek (f, 0, SEEK_SET);
1249   size = fread (buf, 1, maxsize, f);
1250   while (((strncmp (StrBegin, &buf[CurrPos], strlen (StrBegin))) != 0) && (CurrPos < size))
1251     CurrPos++;
1252   if (CurrPos == size)
1253     {
1254       sprintf (buf, "%s\n%s%d\n", buf, StrBegin, getpid ());
1255       sprintf (buf, "%s%s", buf, arg[1]);
1256       sprintf (buf, "%s%s\n", buf, StrEnd);
1257     }
1258   else
1259     {
1260       sscanf (&buf[CurrPos + strlen (StrBegin)], "%d", &OldPID);
1261       if (OldPID == getpid ())
1262 	{
1263 	  sprintf (str, "%d\n", OldPID);
1264 	  while (((strncmp (StrEnd, &buf[CurrPos], strlen (StrEnd))) != 0) && (CurrPos < size))
1265 	    CurrPos++;
1266 	  memmove (&buf[CurrPos + strlen (arg[1])], &buf[CurrPos], strlen (buf) - CurrPos);
1267 	  memmove (&buf[CurrPos], arg[1], strlen (arg[1]));
1268 	}
1269       else
1270 	{			/* Remplacement des anciennes commandes */
1271 	  CurrPos = CurrPos + strlen (StrBegin);
1272 	  CurrPos2 = CurrPos;
1273 	  while (((strncmp (StrEnd, &buf[CurrPos2], strlen (StrEnd))) != 0) && (CurrPos2 < size))
1274 	    CurrPos2++;
1275 	  sprintf (str, "%d\n%s", getpid (), arg[1]);
1276 	  memmove (&buf[CurrPos + strlen (str)], &buf[CurrPos2], strlen (buf) - CurrPos2);
1277 	  buf[strlen (buf) - ((CurrPos2 - CurrPos) - strlen (str))] = '\0';
1278 	  memmove (&buf[CurrPos], str, strlen (str));
1279 	}
1280     }
1281 
1282   fclose (f);
1283   f = fopen (arg[0], "w");
1284   if (f == NULL)
1285     {
1286       fprintf (stderr, "Enable to open file %s\n", arg[0]);
1287       return;
1288     }
1289   fwrite (buf, 1, strlen (buf), f);
1290   fclose (f);
1291 
1292   free (arg[0]);
1293   free (arg[1]);
1294 }
1295 
1296 void
SendToScript(int NbArg,long * TabArg)1297 SendToScript (int NbArg, long *TabArg)
1298 {
1299   char *tempstr, *Msg, *R;
1300   int dest;
1301   int j = 0;
1302   Atom myatom;
1303 
1304   /* Calcul destinataire */
1305   tempstr = CalcArg (TabArg, &j);
1306   dest = (int) atoi (tempstr);
1307   free (tempstr);
1308 
1309   /* Calcul contenu */
1310   Msg = (char *) calloc (256, sizeof (char));
1311   for (j = 1; j < NbArg; j++)
1312     {
1313       tempstr = CalcArg (TabArg, &j);
1314       Msg = (char *) realloc ((void *) Msg, strlen (Msg) + strlen (tempstr) + 1);
1315       Msg = strcat (Msg, tempstr);
1316       free (tempstr);
1317     }				/* Calcul recepteur */
1318   R = (char *) calloc (strlen (x11base->TabScriptId[dest]) + 1, sizeof (char));
1319   sprintf (R, "%s", x11base->TabScriptId[dest]);
1320   myatom = XInternAtom (x11base->display, R, True);
1321 
1322   if ((BuffSend.NbMsg < 40) && (XGetSelectionOwner (x11base->display, myatom) != None))
1323     {
1324       /* Enregistrement dans le buffer du message */
1325       BuffSend.TabMsg[BuffSend.NbMsg].Msg = Msg;
1326       /* Enregistrement dans le buffer du destinataire */
1327       BuffSend.TabMsg[BuffSend.NbMsg].R = R;
1328       /* Enregistrement du message */
1329       BuffSend.NbMsg++;
1330 
1331       /* Reveil du destinataire */
1332       XConvertSelection (x11base->display, XInternAtom (x11base->display, x11base->TabScriptId[dest], True)
1333 			 ,propriete, propriete, x11base->win, CurrentTime);
1334     }
1335   else
1336     {
1337       fprintf (stderr, "Too many messages sended\n");
1338       free (Msg);
1339     }
1340 }
1341 
1342 /****************************************************/
1343 /* Fonction d'initialisation de TabCom et TabFunc   */
1344 /****************************************************/
1345 void
InitCom()1346 InitCom ()
1347 {
1348   /* commande */
1349   TabCom[1] = Exec;
1350   TabCom[2] = HideObj;
1351   TabCom[3] = ShowObj;
1352   TabCom[4] = ChangeValue;
1353   TabCom[5] = ChangePos;
1354   TabCom[6] = ChangeSize;
1355   TabCom[7] = ChangeIcon;
1356   TabCom[8] = ChangeTitle;
1357   TabCom[9] = ChangeFont;
1358   TabCom[10] = ChangeForeColor;
1359   TabCom[11] = SetVar;
1360   TabCom[12] = SendSign;
1361   TabCom[13] = Quit;
1362   TabCom[14] = IfThen;
1363   TabCom[15] = Loop;
1364   TabCom[16] = While;
1365   TabCom[17] = WarpPointer;
1366   TabCom[18] = WriteToFile;
1367   TabCom[19] = ChangeBackColor;
1368   TabCom[21] = ChangeValueMax;
1369   TabCom[22] = ChangeValueMin;
1370   TabCom[23] = SendToScript;
1371 
1372   /* Fonction */
1373   TabFunc[1] = FuncGetValue;
1374   TabFunc[2] = FuncGetTitle;
1375   TabFunc[3] = FuncGetOutput;
1376   TabFunc[4] = FuncGetASoption;
1377   TabFunc[5] = FuncSetASoption;
1378   TabFunc[6] = FuncNumToHex;
1379   TabFunc[7] = FuncHexToNum;
1380   TabFunc[8] = FuncAdd;
1381   TabFunc[9] = FuncMult;
1382   TabFunc[10] = FuncDiv;
1383   TabFunc[11] = FuncStrCopy;
1384   TabFunc[12] = LaunchScript;
1385   TabFunc[13] = GetScriptFather;
1386   TabFunc[14] = ReceivFromScript;
1387   TabFunc[15] = RemainderOfDiv;
1388   TabFunc[16] = GetTime;
1389   TabFunc[17] = GetScriptArg;
1390 
1391   /* Fonction de comparaison */
1392   TabComp[1] = Inf;
1393   TabComp[2] = InfEq;
1394   TabComp[3] = Equal;
1395   TabComp[4] = SupEq;
1396   TabComp[5] = Sup;
1397   TabComp[6] = Diff;
1398 
1399 }
1400