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 }