[graphics] fix bug_13441.tst
[scilab.git] / scilab / modules / gui / sci_gateway / c / sci_uicontrol.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2007 - INRIA - Allan CORNET
4  * Copyright (C) 2007 - INRIA - Vincent COUVERT
5  * Copyright (C) 2010 - DIGITEO - Yann COLLETTE
6  * Copyright (C) 2011 - DIGITEO - Vincent COUVERT
7  *
8  * Copyright (C) 2012 - 2016 - Scilab Enterprises
9  *
10  * This file is hereby licensed under the terms of the GNU GPL v2.0,
11  * pursuant to article 5.3.4 of the CeCILL v.2.1.
12  * This file was originally licensed under the terms of the CeCILL v2.1,
13  * and continues to be available under such terms.
14  * For more information, see the COPYING file which you should have received
15  * along with this program.
16  *
17  */
18
19 #include <stdio.h>
20 #include "gw_gui.h"
21 /*--------------------------------------------------------------------------*/
22 #include "CreateUIControl.h"
23 #include "HandleManagement.h"
24 #include "sci_malloc.h"             /* MALLOC */
25 #include "localization.h"
26 #include "SetPropertyStatus.h"
27 #include "SetHashTable.h"
28 #include "Scierror.h"
29 #include "FigureList.h"         /* getFigureFromIndex */
30 #include "Widget.h"             /* requestWidgetFocus */
31 #include "freeArrayOfString.h"
32 #include "setGraphicObjectProperty.h"
33 #include "getGraphicObjectProperty.h"
34 #include "graphicObjectProperties.h"
35 #include "CurrentFigure.h"
36 #include "BuildObjects.h"
37 #include "api_scilab.h"
38 #include "createGraphicObject.h"
39 #include "expandPathVariable.h"
40 #include "os_string.h"
41
42 static const char* propertiesNames[] =
43 {
44     "style",
45     "constraints",
46     "margins",
47     "parent",
48     "backgroundcolor",
49     "foregroundcolor",
50     "string",
51     "units",
52     "fontweight",
53     "min",
54     "max",
55     "tag",
56     "position",
57     "relief",
58     "horizontalalignment",
59     "verticalalignment",
60     "sliderstep",
61     "fontname",
62     "callback",
63     "fontangle",
64     "fontunits",
65     "fontsize",
66     "listboxtop",
67     "user_data",
68     "value",
69     "userdata",
70     "visible",
71     "enable",
72     "callback_type",
73     "tooltipstring",
74     "layout",
75     "layout_options",
76     "border",
77     "groupname",
78     "title_position",
79     "title_scroll",
80     "scrollable",
81     "icon"
82 };
83 /*--------------------------------------------------------------------------*/
84 static int style_property = -1;
85 static int parent_property = -1;
86 static int user_data_property = -1;
87 static int userdata_property = -1;
88 static int sliderstep_property = -1;
89 static int min_property = -1;
90 static int max_property = -1;
91 static int visible_property = -1;
92 static int position_property = -1;
93 static int scrollable_property = -1;
94 static int string_property = -1;
95 static int tooltipstring_property = -1;
96 /*--------------------------------------------------------------------------*/
97 void init_property_index();
98 /*--------------------------------------------------------------------------*/
99 int sci_uicontrol(char *fname, void* pvApiCtx)
100 {
101     SciErr sciErr;
102
103     int nbRow = 0, nbCol = 0, k = 0;
104     int setStatus = SET_PROPERTY_SUCCEED;
105     int PARENT_NOT_FOUND = -2;
106     int NOT_FOUND = -1;
107     int inputIndex = 0, beginIndex = 0;
108     char *propertyName = NULL;
109     char *styleProperty = NULL;
110
111     int iPropertiesCount = sizeof(propertiesNames) / sizeof(char**);
112     unsigned long GraphicHandle = 0;
113
114     int found = 0;              /* Does the property exists ? */
115
116     int *propertiesValuesIndices = NULL;
117
118     int iParentType = -1;
119     int *piParentType = &iParentType;
120     int iParentStyle = -1;
121     int *piParentStyle = &iParentStyle;
122
123     int iParentUID      = 0;
124     int iUicontrol      = 0;
125     int iCurrentFigure  = 0;
126
127     CheckOutputArgument(pvApiCtx, 0, 1);
128
129     //init properties index
130     init_property_index();
131
132     if (nbInputArgument(pvApiCtx) == 0)
133     {
134         /* Create a pushbutton in current figure */
135
136         /* Create a new pushbutton */
137         GraphicHandle = getHandle(CreateUIControl(NULL));
138
139         /* Set current figure as parent */
140         iCurrentFigure = getCurrentFigure();
141         if (iCurrentFigure == 0)
142         {
143             iCurrentFigure = createNewFigureWithAxes();
144         }
145
146         iUicontrol = getObjectFromHandle(GraphicHandle);
147         setGraphicObjectRelationship(iCurrentFigure, iUicontrol);
148     }
149     else if (nbInputArgument(pvApiCtx) == 1)
150     {
151         /* Create a pushbutton in figure given as parameter */
152         /* Or give focus to the uicontrol given as parameter */
153         int* piAddr = NULL;
154         int iType = 0;
155
156         sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
157         if (sciErr.iErr)
158         {
159             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
160             return 0;
161         }
162
163         if (isHandleType(pvApiCtx, piAddr) == FALSE && isStringType(pvApiCtx, piAddr) == FALSE)
164         {
165             OverLoad(1);
166             return FALSE;
167         }
168 #if 0 // Allow XML loading
169         else if (isStringType(pvApiCtx, piAddr))
170         {
171             char* pstXmlfile = NULL;
172             char* pstExpandedPath = NULL;
173
174             if (isScalar(pvApiCtx, piAddr) == 0)
175             {
176                 Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1);
177                 return FALSE;
178             }
179
180             if (getAllocatedSingleString(pvApiCtx, piAddr, &pstXmlfile))
181             {
182                 freeAllocatedSingleString(pstXmlfile);
183                 Scierror(999, _("%s: No more memory.\n"), fname);
184                 return FALSE;
185             }
186
187             pstExpandedPath = expandPathVariable(pstXmlfile);
188             freeAllocatedSingleString(pstXmlfile);
189             iUicontrol = xmlload(pstExpandedPath);
190             if (iUicontrol < 1)
191             {
192                 Scierror(999, _("%s: can not read file %s.\n"), fname, pstExpandedPath);
193                 FREE(pstExpandedPath);
194                 return 0;
195             }
196             FREE(pstExpandedPath);
197             GraphicHandle = getHandle(iUicontrol);
198
199             /* Create return variable */
200             if (createScalarHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, GraphicHandle))
201             {
202                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
203                 return 1;
204             }
205
206             AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
207             ReturnArguments(pvApiCtx);
208             return TRUE;
209         }
210 #endif // Allow XML loading
211         else /* Get parent ID */
212         {
213             int* piAddr = NULL;
214             long long hParent = 0;
215             sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
216             if (sciErr.iErr)
217             {
218                 printError(&sciErr, 0);
219                 return 1;
220             }
221
222             if (isScalar(pvApiCtx, piAddr) == 0)
223             {
224                 Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
225                 return FALSE;
226             }
227
228             if (getScalarHandle(pvApiCtx, piAddr, &hParent))
229             {
230                 Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, 1);
231                 return 1;
232             }
233
234             iParentUID = getObjectFromHandle((long)hParent);
235             if (iParentUID != 0)
236             {
237                 getGraphicObjectProperty(iParentUID, __GO_TYPE__, jni_int, (void **)&piParentType);
238                 if (iParentType == __GO_UICONTROL__)  /* Focus management */
239                 {
240                     GraphicHandle = (unsigned long)hParent;
241                     requestFocus(iParentUID);
242                 }
243                 else if (iParentType == __GO_FIGURE__ || iParentType == __GO_UIMENU__)  /* PushButton creation */
244                 {
245                     /* Create a new pushbutton */
246                     GraphicHandle = getHandle(CreateUIControl(NULL));
247                     iUicontrol = getObjectFromHandle(GraphicHandle);
248
249                     /* First parameter is the parent */
250                     setGraphicObjectRelationship(iParentUID, iUicontrol);
251                     setStatus = callSetProperty(pvApiCtx, iUicontrol, &hParent, sci_handles, 1, 1, (char*)propertiesNames[parent_property]);
252                     if (setStatus == SET_PROPERTY_ERROR)
253                     {
254                         Scierror(999, _("%s: Could not set property '%s'.\n"), fname, propertyName);
255                         return FALSE;
256                     }
257                 }
258                 else
259                 {
260                     Scierror(999, _("%s: Wrong type for input argument #%d: A '%s', '%s' or '%s' handle expected.\n"), fname, 1, "Uicontrol",
261                              "Figure", "Uimenu");
262                     return FALSE;
263                 }
264             }
265             else
266             {
267                 Scierror(999, _("%s: Wrong type for input argument #%d: A '%s', '%s' or '%s' handle expected.\n"), fname, 1, "Uicontrol", "Figure",
268                          "Uimenu");
269                 return FALSE;
270             }
271         }
272     }
273     else
274     {
275         if (!checkInputArgumentType(pvApiCtx, 1, sci_handles) && !checkInputArgumentType(pvApiCtx, 1, sci_strings))
276         {
277             OverLoad(1);
278             return FALSE;
279         }
280
281         /* Allocate memory to store the position of properties in uicontrol call */
282         if ((propertiesValuesIndices = (int*)MALLOC(sizeof(int) * iPropertiesCount)) == NULL)
283         {
284             Scierror(999, _("%s: No more memory.\n"), fname);
285             return FALSE;
286         }
287
288         /* Init all positions to NOT_FOUND */
289         for (inputIndex = 0; inputIndex < iPropertiesCount; inputIndex++)
290         {
291             propertiesValuesIndices[inputIndex] = NOT_FOUND;    /* Property initialized as not found */
292         }
293
294         /**
295          * Odd number of input arguments
296          * First input is the parent ID
297          * All event inputs are property names
298          * All odd (except first) inputs are property values
299          */
300         if (nbInputArgument(pvApiCtx) % 2 == 1)
301         {
302             if ((!checkInputArgumentType(pvApiCtx, 1, sci_handles)))
303             {
304                 if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix)))
305                 {
306                     int* piAddr = NULL;
307                     double dblValue = 0;
308
309                     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
310                     if (sciErr.iErr)
311                     {
312                         printError(&sciErr, 0);
313                         FREE(propertiesValuesIndices);
314                         return 1;
315                     }
316
317                     if (isScalar(pvApiCtx, piAddr) == 0)
318                     {
319                         Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
320                         FREE(propertiesValuesIndices);
321                         return FALSE;
322                     }
323
324                     if (getScalarDouble(pvApiCtx, piAddr, &dblValue))
325                     {
326                         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
327                         FREE(propertiesValuesIndices);
328                         return 1;
329                     }
330
331                     iParentUID = getFigureFromIndex((int)dblValue);
332                 }
333                 else
334                 {
335                     Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
336                              "Frame uicontrol");
337                     FREE(propertiesValuesIndices);
338                     return FALSE;
339                 }
340             }
341             else /* Get parent ID */
342             {
343                 int* piAddr = NULL;
344                 long long hParent = 0;
345                 sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
346                 if (sciErr.iErr)
347                 {
348                     printError(&sciErr, 0);
349                     FREE(propertiesValuesIndices);
350                     return 1;
351                 }
352
353                 if (isScalar(pvApiCtx, piAddr) == 0)
354                 {
355                     Scierror(999, _("%s: Wrong size for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
356                              "Frame uicontrol");
357                     FREE(propertiesValuesIndices);
358                     return FALSE;
359                 }
360
361                 if (getScalarHandle(pvApiCtx, piAddr, &hParent))
362                 {
363                     Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, 1);
364                     FREE(propertiesValuesIndices);
365                     return 1;
366                 }
367
368                 iParentUID = getObjectFromHandle((long)hParent);
369             }
370
371             if (iParentUID == 0)
372             {
373                 Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
374                          "Frame uicontrol");
375                 FREE(propertiesValuesIndices);
376                 return FALSE;
377             }
378
379             getGraphicObjectProperty(iParentUID, __GO_TYPE__, jni_int, (void **)&piParentType);
380             if (iParentType != __GO_FIGURE__)
381             {
382                 getGraphicObjectProperty(iParentUID, __GO_STYLE__, jni_int, (void **)&piParentStyle);
383                 if (iParentType != __GO_UICONTROL__ ||
384                         (iParentStyle != __GO_UI_FRAME__ && iParentStyle != __GO_UI_TAB__ && iParentStyle != __GO_UI_LAYER__))
385                 {
386                     Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
387                              "Frame uicontrol");
388                     FREE(propertiesValuesIndices);
389                     return FALSE;
390                 }
391             }
392             /* First parameter is the parent */
393             propertiesValuesIndices[parent_property] = 1;
394             // First input parameter which is a property name
395             beginIndex = 2;
396         }
397         /**
398          * Even number of input arguments
399          * All odd inputs are property names
400          * All even inputs are property values
401          */
402         else
403         {
404             // First input parameter which is a property name
405             beginIndex = 1;
406         }
407
408         /* Get all properties positions */
409         for (inputIndex = beginIndex; inputIndex < Rhs; inputIndex = inputIndex + 2)
410         {
411             /* Read property name */
412             if ((!checkInputArgumentType(pvApiCtx, inputIndex, sci_strings)))
413             {
414                 Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, inputIndex);
415                 FREE(propertiesValuesIndices);
416                 return FALSE;
417             }
418             else
419             {
420                 int* piAddr = NULL;
421                 sciErr = getVarAddressFromPosition(pvApiCtx, inputIndex, &piAddr);
422                 if (sciErr.iErr)
423                 {
424                     printError(&sciErr, 0);
425                     FREE(propertiesValuesIndices);
426                     return 1;
427                 }
428
429                 if (getAllocatedSingleString(pvApiCtx, piAddr, &propertyName))
430                 {
431                     Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, inputIndex);
432                     FREE(propertiesValuesIndices);
433                     return 1;
434                 }
435
436
437                 /* Bug 3031 */
438                 /* We only want to compare propertyName along its length */
439                 /* 'posi' must be matched to 'position' */
440                 found = 0;
441                 for (k = 0; k < iPropertiesCount ; k++)
442                 {
443                     if (strlen(propertyName) <= strlen(propertiesNames[k]))
444                     {
445                         if (strnicmp(propertyName, propertiesNames[k], strlen(propertyName)) == 0)
446                         {
447                             propertiesValuesIndices[k] = inputIndex + 1;    /* Position of value for property */
448                             found = 1;
449                             break;
450                         }
451                     }
452                 }
453
454                 if (found == 0)
455                 {
456                     Scierror(999, _("%s: Unknown property: %s for '%s' handles.\n"), fname, propertyName, "Uicontrol");
457                     freeAllocatedSingleString(propertyName);
458                     FREE(propertiesValuesIndices);
459                     return FALSE;
460                 }
461                 freeAllocatedSingleString(propertyName);
462             }
463         }
464
465         if (propertiesValuesIndices[style_property] != NOT_FOUND)    /* Style found */
466         {
467             if ((checkInputArgumentType(pvApiCtx, propertiesValuesIndices[style_property], sci_strings)))
468             {
469                 int* piAddr = NULL;
470                 sciErr = getVarAddressFromPosition(pvApiCtx, propertiesValuesIndices[style_property], &piAddr);
471                 if (sciErr.iErr)
472                 {
473                     printError(&sciErr, 0);
474                     FREE(propertiesValuesIndices);
475                     return 1;
476                 }
477
478                 if (getAllocatedSingleString(pvApiCtx, piAddr, &styleProperty))
479                 {
480                     Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, propertiesValuesIndices[style_property]);
481                     FREE(propertiesValuesIndices);
482                     return 1;
483                 }
484
485                 if (strcmp(styleProperty, "frame") == 0)
486                 {
487                     //check scrollable property to create a scroll frame instead of normal frame
488                     if (propertiesValuesIndices[scrollable_property] != NOT_FOUND)
489                     {
490                         char* pstScroll = NULL;
491                         int iScroll = 0;
492                         sciErr = getVarAddressFromPosition(pvApiCtx, propertiesValuesIndices[scrollable_property], &piAddr);
493                         if (sciErr.iErr)
494                         {
495                             printError(&sciErr, 0);
496                             FREE(propertiesValuesIndices);
497                             freeAllocatedSingleString(styleProperty);
498                             return 1;
499                         }
500
501                         if (isStringType(pvApiCtx, piAddr) == 0 && isBooleanType(pvApiCtx, piAddr) == 0 && isScalar(pvApiCtx, piAddr) == 0)
502                         {
503                             Scierror(202, _("%s: Wrong type for argument #%d: string or boolean expected.\n"), fname, propertiesValuesIndices[scrollable_property]);
504                             FREE(propertiesValuesIndices);
505                             freeAllocatedSingleString(styleProperty);
506                             return 1;
507                         }
508
509                         if (isStringType(pvApiCtx, piAddr))
510                         {
511                             if (getAllocatedSingleString(pvApiCtx, piAddr, &pstScroll))
512                             {
513                                 Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, propertiesValuesIndices[scrollable_property]);
514                                 FREE(propertiesValuesIndices);
515                                 freeAllocatedSingleString(styleProperty);
516                                 return 1;
517                             }
518
519                             if (strcmp(pstScroll, "on") == 0)
520                             {
521                                 iScroll = 1;
522                             }
523
524                             freeAllocatedSingleString(pstScroll);
525                         }
526                         else
527                         {
528                             if (getScalarBoolean(pvApiCtx, piAddr, &iScroll))
529                             {
530                                 Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, propertiesValuesIndices[scrollable_property]);
531                                 freeAllocatedSingleString(styleProperty);
532                                 FREE(propertiesValuesIndices);
533                                 return 1;
534                             }
535                         }
536
537                         if (iScroll)
538                         {
539                             freeAllocatedSingleString(styleProperty);
540                             styleProperty = os_strdup("framescrollable");
541                         }
542
543                         propertiesValuesIndices[scrollable_property] = NOT_FOUND;
544                     }
545                 }
546             }
547             else
548             {
549                 Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, propertiesValuesIndices[style_property]);
550                 FREE(propertiesValuesIndices);
551                 return FALSE;
552             }
553         }
554
555         /* Create a new uicontrol */
556         iUicontrol = CreateUIControl(styleProperty);
557         freeAllocatedSingleString(styleProperty);
558         if (iUicontrol == 0) /* Error in creation */
559         {
560             Scierror(999, _("%s: Could not create 'Uicontrol' handle.\n"), fname);
561             FREE(propertiesValuesIndices);
562             return FALSE;
563         }
564         GraphicHandle = getHandle(iUicontrol);
565
566         /* If no parent given then the current figure is the parent */
567         if (propertiesValuesIndices[parent_property] == NOT_FOUND)
568         {
569             /* Set the parent */
570             iCurrentFigure = getCurrentFigure();
571
572             if (iCurrentFigure == 0)
573             {
574                 iCurrentFigure = createNewFigureWithAxes();
575             }
576
577             propertiesValuesIndices[parent_property] = PARENT_NOT_FOUND;
578         }
579
580         /* Read and set all properties */
581         for (inputIndex = 1; inputIndex < iPropertiesCount; inputIndex++)   /* Style has already been set */
582         {
583             if (propertiesValuesIndices[inputIndex] == PARENT_NOT_FOUND)
584             {
585                 //special case for not specified parent
586                 //but set relationship at the good moment.
587                 setGraphicObjectRelationship(iCurrentFigure, iUicontrol);
588             }
589             else if (propertiesValuesIndices[inputIndex] != NOT_FOUND)
590             {
591                 int* piAddr = NULL;
592                 sciErr = getVarAddressFromPosition(pvApiCtx, propertiesValuesIndices[inputIndex], &piAddr);
593                 if (sciErr.iErr)
594                 {
595                     printError(&sciErr, 0);
596                     FREE(propertiesValuesIndices);
597                     return 1;
598                 }
599
600                 if (inputIndex == user_data_property || inputIndex == userdata_property)   /* User data settings */
601                 {
602                     nbRow = -1;
603                     nbCol = -1;
604                     setStatus = callSetProperty(pvApiCtx, iUicontrol, piAddr, 0, 0, 0, (char*)propertiesNames[inputIndex]);
605                 }
606                 else            /* All other properties */
607                 {
608                     /* Read property value */
609                     switch (getInputArgumentType(pvApiCtx, propertiesValuesIndices[inputIndex]))
610                     {
611                         case sci_matrix:
612                         {
613                             double* pdblValue = NULL;
614                             sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &nbRow, &nbCol, &pdblValue);
615                             if (sciErr.iErr)
616                             {
617                                 printError(&sciErr, 0);
618                                 Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, propertiesValuesIndices[inputIndex]);
619                                 FREE(propertiesValuesIndices);
620                                 return 1;
621                             }
622
623                             setStatus = callSetProperty(pvApiCtx, iUicontrol, pdblValue, sci_matrix, nbRow, nbCol, (char*)propertiesNames[inputIndex]);
624                             break;
625                         }
626                         case sci_strings:
627                             /* Index for String & TooltipString properties: Can be more than one character string */
628                             if ((inputIndex == string_property) || (inputIndex == tooltipstring_property))
629                             {
630                                 char** pstValue = NULL;
631                                 if (getAllocatedMatrixOfString(pvApiCtx, piAddr, &nbRow, &nbCol, &pstValue))
632                                 {
633                                     Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, propertiesValuesIndices[inputIndex]);
634                                     FREE(propertiesValuesIndices);
635                                     return 1;
636                                 }
637
638                                 setStatus = callSetProperty(pvApiCtx, iUicontrol, pstValue, sci_strings, nbRow, nbCol, (char*)propertiesNames[inputIndex]);
639                                 freeAllocatedMatrixOfString(nbRow, nbCol, pstValue);
640                             }
641                             else
642                             {
643                                 char* pstValue = NULL;
644                                 if (getAllocatedSingleString(pvApiCtx, piAddr, &pstValue))
645                                 {
646                                     Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, propertiesValuesIndices[inputIndex]);
647                                     FREE(propertiesValuesIndices);
648                                     return 1;
649                                 }
650
651                                 nbRow = (int)strlen(pstValue);
652                                 nbCol = 1;
653                                 setStatus = callSetProperty(pvApiCtx, iUicontrol, pstValue, sci_strings, nbRow, nbCol, (char*)propertiesNames[inputIndex]);
654                                 freeAllocatedSingleString(pstValue);
655                             }
656                             break;
657                         case sci_handles:
658                         {
659                             long long* pHandles = NULL;
660                             sciErr = getMatrixOfHandle(pvApiCtx, piAddr, &nbRow, &nbCol, &pHandles);
661                             if (sciErr.iErr)
662                             {
663                                 printError(&sciErr, 0);
664                                 Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, propertiesValuesIndices[inputIndex]);
665                                 FREE(propertiesValuesIndices);
666                                 return 1;
667                             }
668
669                             setStatus = callSetProperty(pvApiCtx, iUicontrol, pHandles, sci_handles, nbRow, nbCol, (char*)propertiesNames[inputIndex]);
670                             break;
671                         }
672                         case sci_tlist: //constraints and border
673                         {
674                             setStatus = callSetProperty(pvApiCtx, iUicontrol, piAddr, sci_tlist, 1, 1, (char*)propertiesNames[inputIndex]);
675                             break;
676                         }
677                         default:
678                             Scierror(999, _("%s: Could not set property '%s'.\n"), fname, (char*)propertiesNames[inputIndex]);
679                             setStatus = SET_PROPERTY_ERROR;
680                             break;
681                     }
682                 }
683                 if (setStatus == SET_PROPERTY_ERROR)
684                 {
685                     // comment error because the 'set_propertiesNames[inputIndex]_property' functions already returns an error.
686                     //Scierror(999, _("%s: Could not set property '%s'.\n"), fname, (char*)propertiesNames[inputIndex]);
687                     FREE(propertiesValuesIndices);
688                     return FALSE;
689                 }
690             }
691         }
692     }
693
694     if (propertiesValuesIndices != NULL
695             && (propertiesValuesIndices[sliderstep_property] == NOT_FOUND &&
696                 (propertiesValuesIndices[min_property] != NOT_FOUND || propertiesValuesIndices[max_property] != NOT_FOUND)))    /* SliderStep property not set */
697     {
698         /* Set SliderStep property to [1/100*(Max-Min) 1/10*(Max-Min)] */
699         double maxValue = 0;
700         double* pdblMaxValue = &maxValue;
701         double minValue = 0;
702         double* pdblMinValue = &minValue;
703         double pdblStep[2];
704
705         getGraphicObjectProperty(iUicontrol, __GO_UI_MIN__, jni_double, (void**) &pdblMinValue);
706         getGraphicObjectProperty(iUicontrol, __GO_UI_MAX__, jni_double, (void**) &pdblMaxValue);
707
708         pdblStep[0] = 0.01 * (maxValue - minValue);
709         pdblStep[1] = 0.1 * (maxValue - minValue);
710
711         setGraphicObjectProperty(iUicontrol, __GO_UI_SLIDERSTEP__, pdblStep, jni_double_vector, 2);
712     }
713
714     if ((nbInputArgument(pvApiCtx) < 2) || (propertiesValuesIndices[position_property] == NOT_FOUND))    /* Position property not set */
715     {
716         double* pdblPosition = NULL;
717
718         getGraphicObjectProperty(iUicontrol, __GO_POSITION__, jni_double_vector, (void**) &pdblPosition);
719         setGraphicObjectProperty(iUicontrol, __GO_POSITION__, pdblPosition, jni_double_vector, 4);
720         releaseGraphicObjectProperty(__GO_POSITION__, pdblPosition, jni_double_vector, 4);
721     }
722
723     if ((nbInputArgument(pvApiCtx) < 2) || (propertiesValuesIndices[visible_property] == NOT_FOUND))    /* Visible property not set */
724     {
725         /* Force the uicontrol to be visible because is invisible by default in the model (See bug #10346) */
726         int b = (int)TRUE;
727         setGraphicObjectProperty(iUicontrol, __GO_VISIBLE__, &b, jni_bool, 1);
728     }
729
730     FREE(propertiesValuesIndices);
731
732     /* Create return variable */
733     if (createScalarHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, GraphicHandle))
734     {
735         Scierror(999, _("%s: Memory allocation error.\n"), fname);
736         return 1;
737     }
738
739     AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
740     ReturnArguments(pvApiCtx);
741     return TRUE;
742 }
743 /*--------------------------------------------------------------------------*/
744 void init_property_index()
745 {
746     if (style_property == -1)
747     {
748         int iPropertiesCount = sizeof(propertiesNames) / sizeof(char**);
749         int i = 0;
750         for (i = 0 ; i < iPropertiesCount ; i++)
751         {
752             if (style_property == -1 && strcmp(propertiesNames[i], "style") == 0)
753             {
754                 style_property = i;
755                 continue;
756             }
757
758             if (parent_property == -1 && strcmp(propertiesNames[i], "parent") == 0)
759             {
760                 parent_property = i;
761                 continue;
762             }
763
764             if (user_data_property == -1 && strcmp(propertiesNames[i], "user_data") == 0)
765             {
766                 user_data_property = i;
767                 continue;
768             }
769
770             if (userdata_property == -1 && strcmp(propertiesNames[i], "userdata") == 0)
771             {
772                 userdata_property = i;
773                 continue;
774             }
775
776             if (sliderstep_property == -1 && strcmp(propertiesNames[i], "sliderstep") == 0)
777             {
778                 sliderstep_property = i;
779                 continue;
780             }
781
782             if (min_property == -1 && strcmp(propertiesNames[i], "min") == 0)
783             {
784                 min_property = i;
785                 continue;
786             }
787
788             if (max_property == -1 && strcmp(propertiesNames[i], "max") == 0)
789             {
790                 max_property = i;
791                 continue;
792             }
793
794             if (visible_property == -1 && strcmp(propertiesNames[i], "visible") == 0)
795             {
796                 visible_property = i;
797                 continue;
798             }
799
800             if (position_property == -1 && strcmp(propertiesNames[i], "position") == 0)
801             {
802                 position_property = i;
803                 continue;
804             }
805
806             if (scrollable_property == -1 && strcmp(propertiesNames[i], "scrollable") == 0)
807             {
808                 scrollable_property = i;
809                 continue;
810             }
811
812             if (tooltipstring_property == -1 && strcmp(propertiesNames[i], "tooltipstring") == 0)
813             {
814                 tooltipstring_property = i;
815                 continue;
816             }
817
818             if (string_property == -1 && strcmp(propertiesNames[i], "string") == 0)
819             {
820                 string_property = i;
821                 continue;
822             }
823         }
824     }
825 }
826 /*--------------------------------------------------------------------------*/