0d76eb28931a9393b1d58adbe92151b9bbe7eeff
[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
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   Tcl_Eval(TKinterp,MyCommand);
108   MyAnswer = (char*)Tcl_GetVar(TKinterp, "MyTmpBertrand", 0);
109
110   if ( MyAnswer == NULL) 
111     {
112       *Mvalue = MatrixCreate(0,0,"real");
113       return(0);
114     }
115
116     
117   if (!strcmp(StrField,"position")) {Str2MatReal(MyAnswer, Mvalue); goto fin; }
118   if (!strcmp(StrField,"value"))    {Str2MatReal(MyAnswer, Mvalue); goto fin; }
119   if (!strcmp(StrField,"min"))      {Str2MatReal(MyAnswer, Mvalue); goto fin; }
120   if (!strcmp(StrField,"max"))      {Str2MatReal(MyAnswer, Mvalue); goto fin; }
121   if (!strcmp(StrField,"userdata")) 
122     {
123       if (UserData[Handle]!=NULL) 
124         {
125           mem_siz = MatrixMemSize(UserData[Handle]);
126           TmpMat=(Matrix *)malloc(mem_siz);
127           MatrixCopy(UserData[Handle],TmpMat);
128           *Mvalue = TmpMat;
129         }
130       else
131         *Mvalue = MatrixCreate(0,0,"real");
132       goto fin;
133     }
134     
135   Str2ListStr(MyAnswer, Mvalue);
136  fin:
137   free(StrField);
138   return(0);
139     
140 }
141  
142
143
144
145
146
147 /***/
148 char *Mat2Str(Min)
149      Matrix *Min;
150 {
151 #define ENT 10
152 #define MANT 5
153
154   double *in;
155   int n,m,sz;
156   int i,strl;
157
158   char *retstr;
159   char *tmpstr;
160
161   in = MatrixGetPr(Min);
162   m=MatrixGetHeight(Min);
163   n=MatrixGetWidth(Min);
164   sz=m*n;
165
166   if (sz>0) 
167     {
168       strl = sz * (ENT * MANT + 2);
169       /* the before the dot, after the dot, the dot and a space */
170       
171       retstr = malloc( (1+strl) * sizeof(char));
172       tmpstr = malloc( (ENT * MANT + 2) * sizeof(char));
173       
174       strcpy(retstr,"");
175       
176       for (i=0; i<(sz-1); i++)
177         {
178           sprintf(tmpstr,"%.10lf|", in[i]);
179           strcat( retstr,tmpstr );
180         }
181       
182       sprintf(tmpstr,"%.10lf", in[i]);
183       strcat( retstr,tmpstr );
184       
185       free(tmpstr);
186     }
187   else
188     { 
189       retstr = malloc( sizeof(char) );
190       strcpy(retstr,"");
191     }
192   
193   return(retstr);
194   
195 }
196   
197   
198
199
200
201 /***/
202 int Str2MatReal(str, Mat)
203      char *str;
204      Matrix **Mat;
205      /* Split a string (str) which contains float numbers  separated by '|' */
206      /* and return a vector formed with those numbers.                      */
207
208 {
209   int 
210     lgth,
211     nbelem,
212     i,
213     begin_elem,
214     end_elem,
215     elem;
216   char *tmpstr;
217   double *MatPr;
218   
219
220   lgth = strlen(str);
221   nbelem=1;
222
223   if (lgth>0)
224     {
225       tmpstr = (char *)malloc((lgth+1) * sizeof(char));
226       
227       /* How many elements in the string ? */
228       for (i=0; i<(lgth-1); i++)
229         if (str[i]=='|')        nbelem++;
230       
231       /* Let's ask for some mem. */
232       *Mat=(Matrix *)MatrixCreate(1, nbelem, "real");
233       MatPr=MatrixGetPr(*Mat);
234
235       
236       begin_elem=0;
237       end_elem=0;
238
239       for (elem=0; elem<nbelem; elem++)
240         {
241           
242           while ( (end_elem<lgth) && (str[end_elem] != '|') )
243             {
244               
245               end_elem++;
246             }
247           
248           strncpy(tmpstr, str+begin_elem, end_elem-begin_elem);
249           *(MatPr++)=atof(tmpstr);
250           begin_elem = end_elem+1;
251           end_elem = begin_elem;
252         }
253       free(tmpstr);
254     }
255   
256   /* string was empty */
257   else *Mat = MatrixCreate(0,0,"real");
258
259   return 1;
260
261
262
263 }
264           
265               
266   
267 /***/
268 int Str2ListStr(str, Mat)
269      char *str;
270      Matrix **Mat;
271      /* Split a string (str) which contains substrings separated by '|' */
272      /* and return a scilab list  formed with those substrings          */
273
274 {
275   int 
276     lgth,
277     nbelem,
278     i,
279     begin_elem,
280     end_elem,
281     elem;
282   char *tmpstr;
283
284   Matrix *MTmpStr;
285   
286
287   lgth = strlen(str);
288   nbelem=1;
289
290   if (lgth>0)
291     {
292       tmpstr = (char *)malloc((lgth+1) * sizeof(char));
293       
294       /* How many elements in the string ? */
295       for (i=0; i<(lgth-1); i++)
296         if (str[i]=='|')        nbelem++;
297       
298       /* Let's ask for some mem. */
299       *Mat=(Matrix *)ListCreate();
300       
301
302       
303       begin_elem=0;
304       end_elem=0;
305       if (nbelem>1)
306         /* there is more than one substring  in the string */
307         /* so we create a scilab list of strings           */
308         {
309           for (elem=0; elem<nbelem; elem++)
310             {
311               
312               while ( (end_elem<lgth) && (str[end_elem] != '|') )
313                 {
314                   
315                   end_elem++;
316                 }
317               
318               strncpy(tmpstr, str+begin_elem, end_elem-begin_elem);
319               tmpstr[end_elem-begin_elem]='\0';
320               MTmpStr = MatrixCreateString(tmpstr);
321               *Mat=AppendList(*Mat, MTmpStr);
322               free(MTmpStr);
323               begin_elem = end_elem+1;
324               end_elem = begin_elem;
325             }
326         }
327       else
328         /* the string contains no separator, so we return a scilab string */
329         {
330           *Mat = MatrixCreateString(str);
331         }
332     }
333   /* string was empty */
334   else *Mat = MatrixCreateString("");
335       
336       
337   return 1;
338 }
339   
340               
341   
342         
343
344 char *ListStr2Str(l)
345      Matrix *l;
346      /* concat. a list of strings into a single string */
347      /* the substrings are saprated by a '|'           */
348 {
349   Matrix *Mtmp;
350   int bigsize=0;
351   char *tmpstr;
352   char *bigstr;
353   int sz;
354   char *begin;
355   int nbelem, i;
356
357   if (!MatrixIsList(l)) { InterfError("Input parameter must be a list"); return(NULL);}
358   nbelem = ListGetSize(l);
359   
360   for (i=0; i<nbelem; i++) 
361     {
362       Mtmp = ListGetCell(i, l);
363       if (!MatrixIsString(Mtmp) ) 
364         { 
365           InterfError("One element of the list is not a string");
366           return(NULL);
367         }
368       
369       tmpstr = MatrixReadString(Mtmp);
370       bigsize += strlen(tmpstr);
371       free(tmpstr);
372     }
373
374   bigstr = (char *)malloc( (bigsize + nbelem) *sizeof(char));
375
376   /* set the first string into the result */
377   begin = bigstr;
378
379   Mtmp = ListGetCell(0, l);
380   tmpstr = MatrixReadString(Mtmp);
381   sz=strlen(tmpstr);
382   strncpy(begin, tmpstr, sz);
383   free(tmpstr);
384   begin += sz;
385
386   for (i=1; i<nbelem; i++)
387     {
388       /* now set all the other */
389       *(begin++)='|';
390       Mtmp = ListGetCell(i , l);
391       tmpstr = MatrixReadString(Mtmp);
392       sz=strlen(tmpstr);
393       strncpy(begin, tmpstr, sz);
394       free(tmpstr);
395       begin += sz;
396   
397     }
398   /* add EOL mark */
399   *begin='\0';
400
401   return(bigstr);
402
403
404 }