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