add property layout_options in figure and uicontrol handles
[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  * This file must be used under the terms of the CeCILL.
9  * This source file is licensed as described in the file COPYING, which
10  * you should have received as part of this distribution.  The terms
11  * are also available at
12  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
13  *
14  */
15
16 #include "gw_gui.h"
17 /*--------------------------------------------------------------------------*/
18 #include "CreateUIControl.h"
19 #include "HandleManagement.h"
20 #include "MALLOC.h"             /* MALLOC */
21 #include "localization.h"
22 #include "stricmp.h"
23 #include "stack-c.h"
24 #include "SetPropertyStatus.h"
25 #include "SetHashTable.h"
26 #include "Scierror.h"
27 #include "FigureList.h"         /* getFigureFromIndex */
28 #include "Widget.h"             /* requestWidgetFocus */
29 #include "freeArrayOfString.h"
30 #include "setGraphicObjectProperty.h"
31 #include "getGraphicObjectProperty.h"
32 #include "graphicObjectProperties.h"
33 #include "CurrentFigure.h"
34 #include "BuildObjects.h"
35 #include "api_scilab.h"
36 #include "createGraphicObject.h"
37 #include "expandPathVariable.h"
38
39 /* DO NOT CHANGE ORDER !! */
40 static const char* propertiesNames[] =
41 {
42     "style",
43     "parent",
44     "backgroundcolor",
45     "foregroundcolor",
46     "string",
47     "units",
48     "fontweight",
49     "min",
50     "max",
51     "tag",
52     "position",
53     "relief",
54     "horizontalalignment",
55     "verticalalignment",
56     "sliderstep",
57     "fontname",
58     "callback",
59     "fontangle",
60     "fontunits",
61     "fontsize",
62     "listboxtop",
63     "user_data",
64     "value",
65     "userdata",
66     "visible",
67     "enable",
68     "callback_type",
69     "tooltipstring",
70     "constraints",
71     "layout",
72     "margins"
73 };
74
75 /*--------------------------------------------------------------------------*/
76 //#define NBPROPERTIES 28
77 //#define MAXPROPERTYNAMELENGTH 20
78 /*--------------------------------------------------------------------------*/
79 // callSetProperty get a stack pointer in input argument.
80 /*--------------------------------------------------------------------------*/
81 int sci_uicontrol(char *fname, unsigned long fname_len)
82 {
83     SciErr sciErr;
84
85     int nbRow = 0, nbCol = 0, k = 0;
86     int setStatus = SET_PROPERTY_SUCCEED;
87     int NOT_FOUND = -1;
88     int inputIndex = 0, beginIndex = 0;
89     char *propertyName = NULL;
90     char *styleProperty = NULL;
91
92     int iPropertiesCount = sizeof(propertiesNames) / sizeof(char**);
93     unsigned long GraphicHandle = 0;
94
95     int found = 0;              /* Does the property exists ? */
96
97     int *propertiesValuesIndices = NULL;
98
99     int iParentType = -1;
100     int *piParentType = &iParentType;
101     int iParentStyle = -1;
102     int *piParentStyle = &iParentStyle;
103
104     int iParentUID      = 0;
105     int iUicontrol      = 0;
106     int iCurrentFigure  = 0;
107
108     CheckOutputArgument(pvApiCtx, 0, 1);
109
110     if (nbInputArgument(pvApiCtx) == 0)
111     {
112         /* Create a pushbutton in current figure */
113
114         /* Create a new pushbutton */
115         GraphicHandle = getHandle(CreateUIControl(NULL));
116
117         /* Set current figure as parent */
118         iCurrentFigure = getCurrentFigure();
119         if (iCurrentFigure == 0)
120         {
121             iCurrentFigure = createNewFigureWithAxes();
122         }
123         setGraphicObjectRelationship(iCurrentFigure, getObjectFromHandle(GraphicHandle));
124         iUicontrol = getObjectFromHandle(GraphicHandle);
125     }
126     else if (nbInputArgument(pvApiCtx) == 1)
127     {
128         /* Create a pushbutton in figure given as parameter */
129         /* Or give focus to the uicontrol given as parameter */
130         int* piAddr = NULL;
131         int iType = 0;
132
133         sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
134         if (sciErr.iErr)
135         {
136             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
137             return 0;
138         }
139
140         if (isHandleType(pvApiCtx, piAddr) == FALSE && isStringType(pvApiCtx, piAddr) == FALSE)
141         {
142             OverLoad(1);
143             return FALSE;
144         }
145         else if (isStringType(pvApiCtx, piAddr))
146         {
147             char* pstXmlfile = NULL;
148             char* pstExpandedPath = NULL;
149
150             if (isScalar(pvApiCtx, piAddr) == 0)
151             {
152                 Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
153                 return FALSE;
154             }
155
156             if (getAllocatedSingleString(pvApiCtx, piAddr, &pstXmlfile))
157             {
158                 freeAllocatedSingleString(pstXmlfile);
159                 Scierror(999, _("%s: No more memory.\n"), fname);
160                 return FALSE;
161             }
162
163             pstExpandedPath = expandPathVariable(pstXmlfile);
164             freeAllocatedSingleString(pstXmlfile);
165             iUicontrol = xmlload(pstExpandedPath);
166             if (iUicontrol < 1)
167             {
168                 Scierror(999, _("%s: can not read file %s.\n"), fname, pstExpandedPath);
169                 FREE(pstExpandedPath);
170                 return 0;
171             }
172             FREE(pstExpandedPath);
173             GraphicHandle = getHandle(iUicontrol);
174
175             /* Create return variable */
176             if (createScalarHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, GraphicHandle))
177             {
178                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
179                 return 1;
180             }
181
182             AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
183             ReturnArguments(pvApiCtx);
184             return TRUE;
185
186
187         }
188         else /* Get parent ID */
189         {
190             int* piAddr = NULL;
191             long long hParent = 0;
192             sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
193             if (sciErr.iErr)
194             {
195                 printError(&sciErr, 0);
196                 return 1;
197             }
198
199             if (isScalar(pvApiCtx, piAddr) == 0)
200             {
201                 Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
202                 return FALSE;
203             }
204
205             if (getScalarHandle(pvApiCtx, piAddr, &hParent))
206             {
207                 Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, 1);
208                 return 1;
209             }
210
211             iParentUID = getObjectFromHandle((long)hParent);
212             if (iParentUID != 0)
213             {
214                 getGraphicObjectProperty(iParentUID, __GO_TYPE__, jni_int, (void **)&piParentType);
215                 if (iParentType == __GO_UICONTROL__)  /* Focus management */
216                 {
217                     GraphicHandle = (unsigned long)hParent;
218                     requestFocus(iParentUID);
219                 }
220                 else if (iParentType == __GO_FIGURE__ || iParentType == __GO_UIMENU__)  /* PushButton creation */
221                 {
222                     /* Create a new pushbutton */
223                     GraphicHandle = getHandle(CreateUIControl(NULL));
224
225                     /* First parameter is the parent */
226                     setGraphicObjectRelationship(iParentUID, getObjectFromHandle(GraphicHandle));
227                     setStatus = callSetProperty(pvApiCtx, getObjectFromHandle(GraphicHandle), &hParent, sci_handles, 1, 1, (char*)propertiesNames[1]);
228                     if (setStatus == SET_PROPERTY_ERROR)
229                     {
230                         Scierror(999, _("%s: Could not set property '%s'.\n"), fname, propertyName);
231                         return FALSE;
232                     }
233                 }
234                 else
235                 {
236                     Scierror(999, _("%s: Wrong type for input argument #%d: A '%s', '%s' or '%s' handle expected.\n"), fname, 1, "Uicontrol",
237                              "Figure", "Uimenu");
238                     return FALSE;
239                 }
240             }
241             else
242             {
243                 Scierror(999, _("%s: Wrong type for input argument #%d: A '%s', '%s' or '%s' handle expected.\n"), fname, 1, "Uicontrol", "Figure",
244                          "Uimenu");
245                 return FALSE;
246             }
247             iUicontrol = getObjectFromHandle(GraphicHandle);
248         }
249     }
250     else
251     {
252         if (!checkInputArgumentType(pvApiCtx, 1, sci_handles) && !checkInputArgumentType(pvApiCtx, 1, sci_strings))
253         {
254             OverLoad(1);
255             return FALSE;
256         }
257
258         /* Allocate memory to store the position of properties in uicontrol call */
259         if ((propertiesValuesIndices = (int*)MALLOC(sizeof(int) * iPropertiesCount)) == NULL)
260         {
261             Scierror(999, _("%s: No more memory.\n"), fname);
262             return FALSE;
263         }
264
265         /* Init all positions to NOT_FOUND */
266         for (inputIndex = 0; inputIndex < iPropertiesCount; inputIndex++)
267         {
268             propertiesValuesIndices[inputIndex] = NOT_FOUND;    /* Property initialized as not found */
269         }
270
271         /**
272          * Odd number of input arguments
273          * First input is the parent ID
274          * All event inputs are property names
275          * All odd (except first) inputs are property values
276          */
277         if (nbInputArgument(pvApiCtx) % 2 == 1)
278         {
279             if ((!checkInputArgumentType(pvApiCtx, 1, sci_handles)))
280             {
281                 if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix)))
282                 {
283                     int* piAddr = NULL;
284                     double dblValue = 0;
285
286                     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
287                     if (sciErr.iErr)
288                     {
289                         printError(&sciErr, 0);
290                         return 1;
291                     }
292
293                     if (isScalar(pvApiCtx, piAddr) == 0)
294                     {
295                         Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
296                         return FALSE;
297                     }
298
299                     if (getScalarDouble(pvApiCtx, piAddr, &dblValue))
300                     {
301                         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
302                         return 1;
303                     }
304
305                     iParentUID = getFigureFromIndex((int)dblValue);
306
307                     if (iParentUID == 0)
308                     {
309                         Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
310                                  "Frame uicontrol");
311                         return FALSE;
312                     }
313
314                     getGraphicObjectProperty(iParentUID, __GO_TYPE__, jni_int, (void **)&piParentType);
315                     if (iParentType != __GO_FIGURE__)
316                     {
317                         getGraphicObjectProperty(iParentUID, __GO_STYLE__, jni_int, (void **)&piParentStyle);
318                         if (iParentType != __GO_UICONTROL__ || iParentStyle != __GO_UI_FRAME__)
319                         {
320                             Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
321                                      "Frame uicontrol");
322                             return FALSE;
323                         }
324                     }
325                     /* First parameter is the parent */
326                     propertiesValuesIndices[1] = 1;
327                 }
328                 else
329                 {
330                     Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
331                              "Frame uicontrol");
332                     return FALSE;
333                 }
334             }
335             else /* Get parent ID */
336             {
337                 int* piAddr = NULL;
338                 long long hParent = 0;
339                 sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
340                 if (sciErr.iErr)
341                 {
342                     printError(&sciErr, 0);
343                     return 1;
344                 }
345
346                 if (isScalar(pvApiCtx, piAddr) == 0)
347                 {
348                     Scierror(999, _("%s: Wrong size for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
349                              "Frame uicontrol");
350                     return FALSE;
351                 }
352
353                 if (getScalarHandle(pvApiCtx, piAddr, &hParent))
354                 {
355                     Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, 1);
356                     return 1;
357                 }
358
359                 iParentUID = getObjectFromHandle((long)hParent);
360                 if (iParentUID == 0)
361                 {
362                     Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
363                              "Frame uicontrol");
364                     return FALSE;
365                 }
366                 getGraphicObjectProperty(iParentUID, __GO_TYPE__, jni_int, (void **)&piParentType);
367                 if (iParentType != __GO_FIGURE__)
368                 {
369                     getGraphicObjectProperty(iParentUID, __GO_STYLE__, jni_int, (void **)&piParentStyle);
370                     if (iParentType != __GO_UICONTROL__ || (iParentStyle != __GO_UI_FRAME__ && iParentStyle != __GO_UI_TAB__))
371                     {
372                         Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
373                                  "Frame uicontrol");
374                         return FALSE;
375                     }
376                 }
377                 /* First parameter is the parent */
378                 propertiesValuesIndices[1] = 1;
379             }
380
381             // First input parameter which is a property name
382             beginIndex = 2;
383         }
384         /**
385          * Even number of input arguments
386          * All odd inputs are property names
387          * All even inputs are property values
388          */
389         else
390         {
391             // First input parameter which is a property name
392             beginIndex = 1;
393         }
394
395         /* Get all properties positions */
396         for (inputIndex = beginIndex; inputIndex < Rhs; inputIndex = inputIndex + 2)
397         {
398             /* Read property name */
399             if ((!checkInputArgumentType(pvApiCtx, inputIndex, sci_strings)))
400             {
401                 Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, inputIndex);
402                 return FALSE;
403             }
404             else
405             {
406                 int* piAddr = NULL;
407                 sciErr = getVarAddressFromPosition(pvApiCtx, inputIndex, &piAddr);
408                 if (sciErr.iErr)
409                 {
410                     printError(&sciErr, 0);
411                     return 1;
412                 }
413
414                 if (getAllocatedSingleString(pvApiCtx, piAddr, &propertyName))
415                 {
416                     Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, inputIndex);
417                     return 1;
418                 }
419
420
421                 /* Bug 3031 */
422                 /* We only want to compare propertyName along its length */
423                 /* 'posi' must be matched to 'position' */
424                 found = 0;
425                 for (k = 0; k < iPropertiesCount ; k++)
426                 {
427                     if (strlen(propertyName) <= strlen(propertiesNames[k]))
428                     {
429                         if (strnicmp(propertyName, propertiesNames[k], strlen(propertyName)) == 0)
430                         {
431                             propertiesValuesIndices[k] = inputIndex + 1;    /* Position of value for property */
432                             found = 1;
433                             break;
434                         }
435                     }
436                 }
437
438                 if (found == 0)
439                 {
440                     Scierror(999, _("%s: Unknown property: %s for '%s' handles.\n"), fname, propertyName, "Uicontrol");
441                     return FALSE;
442                 }
443             }
444         }
445
446         if (propertiesValuesIndices[0] != NOT_FOUND)    /* Style found */
447         {
448             if ((checkInputArgumentType(pvApiCtx, propertiesValuesIndices[0], sci_strings)))
449             {
450                 int* piAddr = NULL;
451                 sciErr = getVarAddressFromPosition(pvApiCtx, propertiesValuesIndices[0], &piAddr);
452                 if (sciErr.iErr)
453                 {
454                     printError(&sciErr, 0);
455                     return 1;
456                 }
457
458                 if (getAllocatedSingleString(pvApiCtx, piAddr, &styleProperty))
459                 {
460                     Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, propertiesValuesIndices[0]);
461                     return 1;
462                 }
463             }
464             else
465             {
466                 Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, propertiesValuesIndices[0]);
467                 return FALSE;
468             }
469         }
470
471         /* Create a new uicontrol */
472         iUicontrol = CreateUIControl(styleProperty);
473         freeAllocatedSingleString(styleProperty);
474         if (iUicontrol == 0) /* Error in creation */
475         {
476             Scierror(999, _("%s: Could not create 'Uicontrol' handle.\n"), fname);
477             return FALSE;
478         }
479         GraphicHandle = getHandle(iUicontrol);
480
481         /* Set Constraints before going further */
482         if (propertiesValuesIndices[28] != NOT_FOUND)
483         {
484             int* piAddr = NULL;
485             int iType = 0;
486
487             sciErr = getVarAddressFromPosition(pvApiCtx, propertiesValuesIndices[28], &piAddr);
488             if (sciErr.iErr != 0)
489             {
490                 printError(&sciErr, 0);
491                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
492                 return 0;
493             }
494
495             sciErr = getVarType(pvApiCtx, piAddr, &iType);
496             if (sciErr.iErr != 0)
497             {
498                 printError(&sciErr, 0);
499                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
500                 return 0;
501             }
502
503             if (iType != sci_tlist && isEmptyMatrix(pvApiCtx, piAddr) == FALSE)
504             {
505                 Scierror(202, _("%s: Wrong type for argument #%d: A tlist expected.\n"), fname, propertiesValuesIndices[inputIndex]);
506                 return 1;
507             }
508
509             setStatus = callSetProperty(pvApiCtx, getObjectFromHandle(GraphicHandle), piAddr, iType, 0, 0, (char*)propertiesNames[28]);
510             if (setStatus == SET_PROPERTY_ERROR)
511             {
512                 Scierror(999, _("%s: Could not set property '%s'.\n"), fname, (char*)propertiesNames[28]);
513                 return FALSE;
514             }
515
516             propertiesValuesIndices[28] = NOT_FOUND;
517         }
518
519         /* If no parent given then the current figure is the parent */
520         if (propertiesValuesIndices[1] == NOT_FOUND)
521         {
522             int iGraphicObjectUID = getObjectFromHandle(GraphicHandle);
523
524             /* Set the parent */
525             iCurrentFigure = getCurrentFigure();
526
527             if (iCurrentFigure == 0)
528             {
529                 iCurrentFigure = createNewFigureWithAxes();
530             }
531             setGraphicObjectRelationship(iCurrentFigure, iGraphicObjectUID);
532         }
533
534         /* Read and set all properties */
535         for (inputIndex = 1; inputIndex < iPropertiesCount; inputIndex++)   /* Style has already been set */
536         {
537             if (propertiesValuesIndices[inputIndex] != NOT_FOUND)
538             {
539                 int* piAddr = NULL;
540                 sciErr = getVarAddressFromPosition(pvApiCtx, propertiesValuesIndices[inputIndex], &piAddr);
541                 if (sciErr.iErr)
542                 {
543                     printError(&sciErr, 0);
544                     return 1;
545                 }
546
547                 if (inputIndex == 21 || inputIndex == 23)   /* User data settings */
548                 {
549                     nbRow = -1;
550                     nbCol = -1;
551                     setStatus = callSetProperty(pvApiCtx, getObjectFromHandle(GraphicHandle), piAddr, 0, 0, 0, (char*)propertiesNames[inputIndex]);
552                 }
553                 else            /* All other properties */
554                 {
555                     /* Read property value */
556                     switch (getInputArgumentType(pvApiCtx, propertiesValuesIndices[inputIndex]))
557                     {
558                         case sci_matrix:
559                         {
560                             double* pdblValue = NULL;
561                             sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &nbRow, &nbCol, &pdblValue);
562                             if (sciErr.iErr)
563                             {
564                                 printError(&sciErr, 0);
565                                 Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, propertiesValuesIndices[inputIndex]);
566                                 return 1;
567                             }
568
569                             setStatus = callSetProperty(pvApiCtx, getObjectFromHandle(GraphicHandle), pdblValue, sci_matrix, nbRow, nbCol, (char*)propertiesNames[inputIndex]);
570                             break;
571                         }
572                         case sci_strings:
573                             /* Index for String & TooltipString properties: Can be more than one character string */
574                             if ((inputIndex == 4) || (inputIndex == 27))
575                             {
576                                 char** pstValue = NULL;
577                                 if (getAllocatedMatrixOfString(pvApiCtx, piAddr, &nbRow, &nbCol, &pstValue))
578                                 {
579                                     Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, propertiesValuesIndices[inputIndex]);
580                                     return 1;
581                                 }
582
583                                 setStatus = callSetProperty(pvApiCtx, getObjectFromHandle(GraphicHandle), pstValue, sci_strings, nbRow, nbCol, (char*)propertiesNames[inputIndex]);
584                                 freeAllocatedMatrixOfString(nbRow, nbCol, pstValue);
585                             }
586                             else
587                             {
588                                 char* pstValue = NULL;
589                                 if (getAllocatedSingleString(pvApiCtx, piAddr, &pstValue))
590                                 {
591                                     Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, propertiesValuesIndices[inputIndex]);
592                                     return 1;
593                                 }
594
595                                 nbRow = (int)strlen(pstValue);
596                                 nbCol = 1;
597                                 setStatus = callSetProperty(pvApiCtx, getObjectFromHandle(GraphicHandle), pstValue, sci_strings, nbRow, nbCol, (char*)propertiesNames[inputIndex]);
598                                 freeAllocatedSingleString(pstValue);
599                             }
600                             break;
601                         case sci_handles:
602                         {
603                             long long* pHandles = NULL;
604                             sciErr = getMatrixOfHandle(pvApiCtx, piAddr, &nbRow, &nbCol, &pHandles);
605                             if (sciErr.iErr)
606                             {
607                                 printError(&sciErr, 0);
608                                 Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, propertiesValuesIndices[inputIndex]);
609                                 return 1;
610                             }
611
612                             setStatus = callSetProperty(pvApiCtx, getObjectFromHandle(GraphicHandle), pHandles, sci_handles, nbRow, nbCol, (char*)propertiesNames[inputIndex]);
613                             break;
614                         }
615                         default:
616                             setStatus = SET_PROPERTY_ERROR;
617                             break;
618                     }
619                 }
620                 if (setStatus == SET_PROPERTY_ERROR)
621                 {
622                     Scierror(999, _("%s: Could not set property '%s'.\n"), fname, (char*)propertiesNames[inputIndex]);
623                     return FALSE;
624                 }
625             }
626         }
627     }
628
629     if (propertiesValuesIndices != NULL
630             && (propertiesValuesIndices[14] == NOT_FOUND &&
631                 (propertiesValuesIndices[7] != NOT_FOUND || propertiesValuesIndices[8] != NOT_FOUND)))    /* SliderStep property not set */
632     {
633         /* Set SliderStep property to [1/100*(Max-Min) 1/10*(Max-Min)] */
634         double maxValue = 0;
635         double* pdblMaxValue = &maxValue;
636         double minValue = 0;
637         double* pdblMinValue = &minValue;
638         double pdblStep[2];
639
640         getGraphicObjectProperty(iUicontrol, __GO_UI_MIN__, jni_double, (void**) &pdblMinValue);
641         getGraphicObjectProperty(iUicontrol, __GO_UI_MAX__, jni_double, (void**) &pdblMaxValue);
642
643         pdblStep[0] = 0.01 * (maxValue - minValue);
644         pdblStep[1] = 0.1 * (maxValue - minValue);
645
646         setGraphicObjectProperty(iUicontrol, __GO_UI_SLIDERSTEP__, pdblStep, jni_double_vector, 2);
647     }
648
649     if ((nbInputArgument(pvApiCtx) < 2) || (propertiesValuesIndices[10] == NOT_FOUND))    /* Position property not set */
650     {
651         double* pdblPosition = NULL;
652
653         getGraphicObjectProperty(iUicontrol, __GO_POSITION__, jni_double_vector, (void**) &pdblPosition);
654         setGraphicObjectProperty(iUicontrol, __GO_POSITION__, pdblPosition, jni_double_vector, 4);
655     }
656
657     if ((nbInputArgument(pvApiCtx) < 2) || (propertiesValuesIndices[24] == NOT_FOUND))    /* Visible property not set */
658     {
659         /* Force the uicontrol to be visible because is invisible by default in the model (See bug #10346) */
660         int b = (int)TRUE;
661         setGraphicObjectProperty(iUicontrol, __GO_VISIBLE__, &b, jni_bool, 1);
662     }
663
664     FREE(propertiesValuesIndices);
665
666     /* Create return variable */
667     if (createScalarHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, GraphicHandle))
668     {
669         Scierror(999, _("%s: Memory allocation error.\n"), fname);
670         return 1;
671     }
672
673     AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
674     ReturnArguments(pvApiCtx);
675     return TRUE;
676 }
677
678 /*--------------------------------------------------------------------------*/