Root properties added
[scilab.git] / scilab / routines / tksci / TK_uicontrol.c
1 /* UI generator main module  */
2 /* Bertrand Guiheneuf, INRIA 1997 */
3
4 #include "C-LAB_Interf.h"
5 #include "TK_uicontrol.h"
6 #include "TK_ScilabCallback.h"
7 #include "tksci.h"
8 /*#include "x_data.h" /* To get screen properties */
9
10
11 /***/
12 /* forward declarations */
13 char *Mat2Str();
14
15 int Str2MatReal();
16
17 int Str2ListStr();
18
19 char *ListStr2Str();
20
21 char *UiStyleName[] = {"button", "checkbutton", "checkbutton", "entry", "label",
22                        "scale", "frame", "scrolllistbox", "popupmenu"};
23
24
25
26
27
28
29 /***/
30 int GetStyle(StyleStr)
31      char *StyleStr;
32
33 {
34   if (! strcmp(StyleStr,"pushbutton"           )) return 0;
35   else if (! strcmp(StyleStr,"radiobutton"     )) return 1;
36   else if (! strcmp(StyleStr,"checkbox"        )) return 2;
37   else if (! strcmp(StyleStr,"edit"            )) return 3;
38   else if (! strcmp(StyleStr,"text"            )) return 4;
39   else if (! strcmp(StyleStr,"slider"          )) return 5;
40   else if (! strcmp(StyleStr,"frame"           )) return 6;
41   else if (! strcmp(StyleStr,"listbox"         )) return 7;
42   else if (! strcmp(StyleStr,"popupmenu"       )) return 8;
43   else return(-1);
44
45 }
46
47
48
49 /***/
50 int TK_UiSet( int  Handle,Matrix * Mfield,Matrix * Mvalue)
51 {
52   char *StrField,  *StrValue;
53   char MyCommand[2000];
54   int mem_siz;
55     
56   StrField = MatrixReadString(Mfield);
57   nocase(StrField);
58   if (MatrixIsString(Mvalue))
59     {
60       StrValue = MatrixReadString(Mvalue);
61       /* nocase(StrValue);  (modif Bruno 14/1/2001) */
62     }
63   else if (MatrixIsReal(Mvalue))
64     StrValue = Mat2Str(Mvalue);
65   else if (MatrixIsList(Mvalue))
66     StrValue = ListStr2Str(Mvalue);
67   else 
68     {
69       return(-1);
70     }
71   
72   if (!strcmp(StrField,"userdata")) 
73     {
74       mem_siz = MatrixMemSize(Mvalue);
75       UserData[Handle]=(Matrix *)malloc(mem_siz);
76       MatrixCopy(Mvalue,UserData[Handle]);
77     }
78   else
79     {
80       sprintf(MyCommand,"SetField %d \"%s\" \"%s\"",Handle,StrField,StrValue);
81       Tcl_Eval(TKinterp,MyCommand);
82     }
83   free(StrField);
84   free(StrValue);
85   return(0);
86
87 }
88     
89  
90
91
92 /***/
93 int TK_UiGet(int Handle,Matrix * Mfield,Matrix ** Mvalue)
94 {
95   char *StrField;
96   
97   char MyCommand[2000];
98   char *MyAnswer;
99   Matrix * TmpMat;
100   int mem_siz;
101
102   StrField = MatrixReadString(Mfield);
103   nocase(StrField);
104
105   sprintf(MyCommand,"set MyTmpBertrand [GetField %d \"%s\"]", Handle, StrField);
106
107   if(Handle==0) /* Screen properties */
108     {
109       if(!GetScreenProperty(StrField,&MyAnswer))
110         {
111           Str2MatReal(MyAnswer, Mvalue);
112           free(MyAnswer);
113         }
114       else
115         {
116           *Mvalue = MatrixCreate(0,0,"real");
117         }
118       goto fin;
119     }
120   else
121     {
122       Tcl_Eval(TKinterp,MyCommand);
123       MyAnswer = (char*)Tcl_GetVar(TKinterp, "MyTmpBertrand", 0);
124
125       if ( MyAnswer == NULL) 
126         {
127           *Mvalue = MatrixCreate(0,0,"real");
128           return(0);
129         }
130       
131       
132       if (!strcmp(StrField,"position")) {Str2MatReal(MyAnswer, Mvalue); goto fin; }
133       if (!strcmp(StrField,"value"))    {Str2MatReal(MyAnswer, Mvalue); goto fin; }
134       if (!strcmp(StrField,"min"))      {Str2MatReal(MyAnswer, Mvalue); goto fin; }
135       if (!strcmp(StrField,"max"))      {Str2MatReal(MyAnswer, Mvalue); goto fin; }
136       if (!strcmp(StrField,"userdata")) 
137         {
138           if (UserData[Handle]!=NULL) 
139             {
140               mem_siz = MatrixMemSize(UserData[Handle]);
141               TmpMat=(Matrix *)malloc(mem_siz);
142               MatrixCopy(UserData[Handle],TmpMat);
143               *Mvalue = TmpMat;
144             }
145           else
146             *Mvalue = MatrixCreate(0,0,"real");
147           goto fin;
148         }
149       
150       Str2ListStr(MyAnswer, Mvalue);
151     }
152  fin:
153   free(StrField);
154   return(0);
155     
156 }
157  
158
159
160
161
162
163 /***/
164 char *Mat2Str(Min)
165      Matrix *Min;
166 {
167 #define ENT 10
168 #define MANT 5
169
170   double *in;
171   int n,m,sz;
172   int i,strl;
173
174   char *retstr;
175   char *tmpstr;
176
177   in = MatrixGetPr(Min);
178   m=MatrixGetHeight(Min);
179   n=MatrixGetWidth(Min);
180   sz=m*n;
181
182   if (sz>0) 
183     {
184       strl = sz * (ENT * MANT + 2);
185       /* the before the dot, after the dot, the dot and a space */
186       
187       retstr = malloc( (1+strl) * sizeof(char));
188       tmpstr = malloc( (ENT * MANT + 2) * sizeof(char));
189       
190       strcpy(retstr,"");
191       
192       for (i=0; i<(sz-1); i++)
193         {
194           sprintf(tmpstr,"%.10lf|", in[i]);
195           strcat( retstr,tmpstr );
196         }
197       
198       sprintf(tmpstr,"%.10lf", in[i]);
199       strcat( retstr,tmpstr );
200       
201       free(tmpstr);
202     }
203   else
204     { 
205       retstr = malloc( sizeof(char) );
206       strcpy(retstr,"");
207     }
208   
209   return(retstr);
210   
211 }
212   
213   
214
215
216
217 /***/
218 int Str2MatReal(str, Mat)
219      char *str;
220      Matrix **Mat;
221      /* Split a string (str) which contains float numbers  separated by '|' */
222      /* and return a vector formed with those numbers.                      */
223
224 {
225   int 
226     lgth,
227     nbelem,
228     i,
229     begin_elem,
230     end_elem,
231     elem;
232   char *tmpstr;
233   double *MatPr;
234   
235
236   lgth = strlen(str);
237   nbelem=1;
238
239   if (lgth>0)
240     {
241       tmpstr = (char *)malloc((lgth+1) * sizeof(char));
242       
243       /* How many elements in the string ? */
244       for (i=0; i<(lgth-1); i++)
245         if (str[i]=='|')        nbelem++;
246       
247       /* Let's ask for some mem. */
248       *Mat=(Matrix *)MatrixCreate(1, nbelem, "real");
249       MatPr=MatrixGetPr(*Mat);
250
251       
252       begin_elem=0;
253       end_elem=0;
254
255       for (elem=0; elem<nbelem; elem++)
256         {
257           
258           while ( (end_elem<lgth) && (str[end_elem] != '|') )
259             {
260               
261               end_elem++;
262             }
263           
264           strncpy(tmpstr, str+begin_elem, end_elem-begin_elem);
265           *(MatPr++)=atof(tmpstr);
266           begin_elem = end_elem+1;
267           end_elem = begin_elem;
268         }
269       free(tmpstr);
270     }
271   
272   /* string was empty */
273   else *Mat = MatrixCreate(0,0,"real");
274
275   return 1;
276
277
278
279 }
280           
281               
282   
283 /***/
284 int Str2ListStr(str, Mat)
285      char *str;
286      Matrix **Mat;
287      /* Split a string (str) which contains substrings separated by '|' */
288      /* and return a scilab list  formed with those substrings          */
289
290 {
291   int 
292     lgth,
293     nbelem,
294     i,
295     begin_elem,
296     end_elem,
297     elem;
298   char *tmpstr;
299
300   Matrix *MTmpStr;
301   
302
303   lgth = strlen(str);
304   nbelem=1;
305
306   if (lgth>0)
307     {
308       tmpstr = (char *)malloc((lgth+1) * sizeof(char));
309       
310       /* How many elements in the string ? */
311       for (i=0; i<(lgth-1); i++)
312         if (str[i]=='|')        nbelem++;
313       
314       /* Let's ask for some mem. */
315       *Mat=(Matrix *)ListCreate();
316       
317
318       
319       begin_elem=0;
320       end_elem=0;
321       if (nbelem>1)
322         /* there is more than one substring  in the string */
323         /* so we create a scilab list of strings           */
324         {
325           for (elem=0; elem<nbelem; elem++)
326             {
327               
328               while ( (end_elem<lgth) && (str[end_elem] != '|') )
329                 {
330                   
331                   end_elem++;
332                 }
333               
334               strncpy(tmpstr, str+begin_elem, end_elem-begin_elem);
335               tmpstr[end_elem-begin_elem]='\0';
336               MTmpStr = MatrixCreateString(tmpstr);
337               *Mat=AppendList(*Mat, MTmpStr);
338               free(MTmpStr);
339               begin_elem = end_elem+1;
340               end_elem = begin_elem;
341             }
342         }
343       else
344         /* the string contains no separator, so we return a scilab string */
345         {
346           *Mat = MatrixCreateString(str);
347         }
348     }
349   /* string was empty */
350   else *Mat = MatrixCreateString("");
351       
352       
353   return 1;
354 }
355   
356               
357   
358         
359
360 char *ListStr2Str(l)
361      Matrix *l;
362      /* concat. a list of strings into a single string */
363      /* the substrings are saprated by a '|'           */
364 {
365   Matrix *Mtmp;
366   int bigsize=0;
367   char *tmpstr;
368   char *bigstr;
369   int sz;
370   char *begin;
371   int nbelem, i;
372
373   if (!MatrixIsList(l)) { InterfError("Input parameter must be a list"); return(NULL);}
374   nbelem = ListGetSize(l);
375   
376   for (i=0; i<nbelem; i++) 
377     {
378       Mtmp = ListGetCell(i, l);
379       if (!MatrixIsString(Mtmp) ) 
380         { 
381           InterfError("One element of the list is not a string");
382           return(NULL);
383         }
384       
385       tmpstr = MatrixReadString(Mtmp);
386       bigsize += strlen(tmpstr);
387       free(tmpstr);
388     }
389
390   bigstr = (char *)malloc( (bigsize + nbelem) *sizeof(char));
391
392   /* set the first string into the result */
393   begin = bigstr;
394
395   Mtmp = ListGetCell(0, l);
396   tmpstr = MatrixReadString(Mtmp);
397   sz=strlen(tmpstr);
398   strncpy(begin, tmpstr, sz);
399   free(tmpstr);
400   begin += sz;
401
402   for (i=1; i<nbelem; i++)
403     {
404       /* now set all the other */
405       *(begin++)='|';
406       Mtmp = ListGetCell(i , l);
407       tmpstr = MatrixReadString(Mtmp);
408       sz=strlen(tmpstr);
409       strncpy(begin, tmpstr, sz);
410       free(tmpstr);
411       begin += sz;
412   
413     }
414   /* add EOL mark */
415   *begin='\0';
416
417   return(bigstr);
418
419
420 }