d3165cae382355db632a67ebe305b0568047c60e
[scilab.git] / scilab / modules / ui_data / sci_gateway / cpp / sci_editvar.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2010 - DIGITEO - Allan CORNET
4  * Copyright (C) 2010 - DIGITEO - Allan SIMON
5  * Copyright (C) 2010 - DIGITEO - Bruno JOFRET
6  * Copyright (C) 2011 - DIGITEO - Calixte DENIZET
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 <iostream>
17 #include "EditVar.hxx"
18 #include "GiwsException.hxx"
19 //#include "ScilabToJava.hxx"
20
21 extern "C"
22 {
23 #include "gw_ui_data.h"
24 #include "api_scilab.h"
25 #include "localization.h"
26 #include "Scierror.h"
27 #include "sci_malloc.h"
28 #include "freeArrayOfString.h"
29 #include "sciprint.h"
30 #include "getScilabJavaVM.h"
31 #include "localization.h"
32 #include <time.h>
33 }
34
35 using namespace org_scilab_modules_ui_data;
36 /*--------------------------------------------------------------------------*/
37 template <typename T, typename U>
38 T** wrap(U * x, int r, int c)
39 {
40     T ** xx = new T*[r];
41     for (int i = 0; i < r; i++)
42     {
43         xx[i] = new T[c];
44         for (int j = 0; j < c; j++)
45         {
46             xx[i][j] = static_cast<T>(x[j * r + i]);
47         }
48     }
49
50     return xx;
51 }
52 /*--------------------------------------------------------------------------*/
53 /* For example if the matrix is [1 2 0 0 0;0 1 2 0 0;0 2 1 3 0 0;0 0 0 0 0;0 0 0 0 1], then
54    r=5, c=5, nbItem=8, nbItemRow=[2 2 3 0 1], colPos=[1 2 2 3 2 3 4 5] and x=[1 2 1 2 2 1 3 1] */
55 double ** wrapSparse(int nbItem, int * nbItemRow, int * colPos, int r, int c, double * x)
56 {
57     double ** xx = new double*[r];
58     int prev = 0;
59     for (int i = 0; i < r; i++)
60     {
61         xx[i] = new double[c];
62         memset(xx[i], 0, c * sizeof(double));
63         for (int j = 0; j < nbItemRow[i]; j++)
64         {
65             xx[i][colPos[prev + j] - 1] = x[prev + j];
66         }
67         prev += nbItemRow[i];
68     }
69
70     return xx;
71 }
72 /*--------------------------------------------------------------------------*/
73 /* boolean version */
74 int ** wrapSparse(int nbItem, int * nbItemRow, int * colPos, int r, int c)
75 {
76     int ** xx = new int*[r];
77     int prev = 0;
78     for (int i = 0; i < r; i++)
79     {
80         xx[i] = new int[c];
81         memset(xx[i], 0, c * sizeof(int));
82         for (int j = 0; j < nbItemRow[i]; j++)
83         {
84             xx[i][colPos[prev + j] - 1] = 1;
85         }
86         prev += nbItemRow[i];
87     }
88
89     return xx;
90 }
91 /*--------------------------------------------------------------------------*/
92 template <typename T>
93 void clearWrap(T ** x, int r)
94 {
95     for (int i = 0; i < r; i++)
96     {
97         delete [] x[i];
98     }
99
100     delete x;
101 }
102 /*--------------------------------------------------------------------------*/
103 int sci_editvar(char * fname, void* pvApiCtx)
104 {
105     CheckRhs(1, 4); /* TODO change this in the future */
106     CheckLhs(0, 1);
107
108     SciErr sciErr;
109
110     int m1 = 0, n1 = 0;
111
112     int * piAddr = NULL;
113     int iType = 0;
114     int iCols = 0;
115     int iRows = 0;
116
117     int * piBool = NULL;
118     int ** ppiBool = NULL;
119
120     char * piInt8 = NULL;
121     char ** ppiInt8 = NULL;
122
123     unsigned char * piUInt8 = NULL;
124     short ** ppiUInt8 = NULL;
125
126     short * piInt16 = NULL;
127     short ** ppiInt16 = NULL;
128
129     unsigned short * piUInt16 = NULL;
130     int ** ppiUInt16 = NULL;
131
132     int * piInt32 = NULL;
133     int ** ppiInt32 = NULL;
134
135     unsigned int * piUInt32 = NULL;
136     long long int ** ppiUInt32 = NULL;
137
138     int iComplex = 0;
139     double * pdblReal = NULL;
140     double * pdblImg = NULL;
141     double ** ppdblRealMatrix = NULL;
142     double ** ppdblImgMatrix = NULL;
143
144     char ** pstData = NULL;
145     int * piLen = NULL;
146     char *** ppstData = NULL;
147
148     int * piAddressVarOne = NULL;
149     char * pStVarOne = NULL;
150     int lenStVarOne = 0;
151
152     int * addr = NULL;
153     double * rowsIndex = NULL;
154     int nbRowsIndex = 0;
155     double * colsIndex = NULL;
156     int nbColsIndex = 0;
157
158     int piNbItem = 0;
159     int * piNbItemRow = NULL;
160     int * piColPos = NULL;
161
162     if (Rhs == 3)
163     {
164         Scierror(999, _("%s: Wrong number of input argument(s): %d, %d or %d expected.\n"), fname, 1, 2, 4);
165         return 0;
166     }
167
168     /* get address */
169     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
170     if (sciErr.iErr)
171     {
172         printError(&sciErr, 0);
173         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
174         return 0;
175     }
176
177     sciErr = getVarType(pvApiCtx, piAddressVarOne, &iType);
178     if (sciErr.iErr)
179     {
180         printError(&sciErr, 0);
181         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
182         return 0;
183     }
184
185     if (iType != sci_strings)
186     {
187         Scierror(999, _("%s: Wrong type for input argument #%d: A String expected.\n"), fname, 1);
188         return 0;
189     }
190
191     /* get dimensions */
192     sciErr = getMatrixOfString(pvApiCtx, piAddressVarOne, &m1, &n1, NULL, NULL);
193     if (sciErr.iErr)
194     {
195         printError(&sciErr, 0);
196         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
197         return 0;
198     }
199
200     /* TODO maybe allow vectors in case someone wants to edit several variables in the same time? */
201     if (m1 != 1 || n1 != 1)
202     {
203         Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
204         return 0;
205     }
206
207     /* get lengths */
208     sciErr = getMatrixOfString(pvApiCtx, piAddressVarOne, &m1, &n1, &lenStVarOne, NULL);
209     if (sciErr.iErr)
210     {
211         printError(&sciErr, 0);
212         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
213         return 0;
214     }
215
216     pStVarOne = (char*)MALLOC(sizeof(char*) * (lenStVarOne + 1));
217
218     /* get variable name to edit */
219     sciErr = getMatrixOfString(pvApiCtx, piAddressVarOne, &m1, &n1, &lenStVarOne, &pStVarOne);
220     if (sciErr.iErr)
221     {
222         FREE(pStVarOne);
223         printError(&sciErr, 0);
224         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
225         return 0;
226     }
227
228     if (strcmp(pStVarOne, "ans") == 0)
229     {
230         Scierror(999, _("%s: ans cannot be edited.\n"), fname);
231         FREE(pStVarOne);
232         return 0;
233     }
234
235     /* get address of the variable*/
236     sciErr = getVarAddressFromName(pvApiCtx, pStVarOne, &piAddr);
237     if (sciErr.iErr)
238     {
239         Scierror(4, _("%s: Undefined variable: %s.\n"), fname, pStVarOne);
240         FREE(pStVarOne);
241         return 0;
242     }
243
244     /* Workaround to check for permanent variable.
245      * TODO: in Scilab 6.0, use an API specific function for write protection. */
246     if (strcmp(pStVarOne, "$")                      == 0 ||
247             strcmp(pStVarOne, "%e")             == 0 ||
248             strcmp(pStVarOne, "%eps")           == 0 ||
249             strcmp(pStVarOne, "%fftw")  == 0 ||
250             strcmp(pStVarOne, "%f")             == 0 ||
251             strcmp(pStVarOne, "%F")             == 0 ||
252             strcmp(pStVarOne, "%gui")           == 0 ||
253             strcmp(pStVarOne, "%i")             == 0 ||
254             strcmp(pStVarOne, "%io")            == 0 ||
255             strcmp(pStVarOne, "%inf")           == 0 ||
256             strcmp(pStVarOne, "%nan")           == 0 ||
257             strcmp(pStVarOne, "%pi")            == 0 ||
258             strcmp(pStVarOne, "%s")             == 0 ||
259             strcmp(pStVarOne, "%tk")            == 0 ||
260             strcmp(pStVarOne, "%t")             == 0 ||
261             strcmp(pStVarOne, "%T")             == 0 ||
262             strcmp(pStVarOne, "%z")             == 0 ||
263             strcmp(pStVarOne, "evoid")      == 0 ||
264             strcmp(pStVarOne, "home")           == 0 ||
265             strcmp(pStVarOne, "PWD")            == 0 ||
266             strcmp(pStVarOne, "SCI")            == 0 ||
267             strcmp(pStVarOne, "SCIHOME")        == 0 ||
268             strcmp(pStVarOne, "TMPDIR") == 0 )
269     {
270         Scierror(13, _("Redefining permanent variable.\n"), fname);
271         FREE(pStVarOne);
272         return 0;
273     }
274
275     if (Rhs == 1)
276     {
277         /* get address of the variable*/
278         sciErr = getVarAddressFromName(pvApiCtx, pStVarOne, &piAddr);
279         if (sciErr.iErr)
280         {
281             Scierror(4, _("%s: Undefined variable: %s.\n"), fname, pStVarOne);
282             FREE(pStVarOne);
283             return 0;
284         }
285     }
286     else
287     {
288         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
289         if (sciErr.iErr)
290         {
291             FREE(pStVarOne);
292             printError(&sciErr, 0);
293             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
294             return 0;
295         }
296     }
297
298     if (Rhs == 4)
299     {
300         sciErr = getVarAddressFromPosition(pvApiCtx, 3, &addr);
301         if (sciErr.iErr)
302         {
303             printError(&sciErr, 0);
304             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
305             FREE(pStVarOne);
306             return 0;
307         }
308
309         if (!isDoubleType(pvApiCtx, addr))
310         {
311             Scierror(999, _("%s: Wrong type for input argument #%d: Double expected.\n"), fname, 3);
312             FREE(pStVarOne);
313             return 0;
314         }
315
316         sciErr = getMatrixOfDouble(pvApiCtx, addr, &iRows, &iCols, &rowsIndex);
317         if (sciErr.iErr)
318         {
319             FREE(pStVarOne);
320             printError(&sciErr, 0);
321             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
322             return 0;
323         }
324
325         nbRowsIndex = iRows * iCols;
326
327         sciErr = getVarAddressFromPosition(pvApiCtx, 4, &addr);
328         if (sciErr.iErr)
329         {
330             printError(&sciErr, 0);
331             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
332             FREE(pStVarOne);
333             return 0;
334         }
335
336         if (!isDoubleType(pvApiCtx, addr))
337         {
338             Scierror(999, _("%s: Wrong type for input argument #%d: Double expected.\n"), fname, 4);
339             FREE(pStVarOne);
340             return 0;
341         }
342
343         sciErr = getMatrixOfDouble(pvApiCtx, addr, &iRows, &iCols, &colsIndex);
344         if (sciErr.iErr)
345         {
346             FREE(pStVarOne);
347             printError(&sciErr, 0);
348             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
349             return 0;
350         }
351
352         nbColsIndex = iRows * iCols;
353     }
354
355     //org_modules_commons::ScilabToJava::sendVariable(std::string(pStVarOne), true, pvApiCtx);
356
357     /* get type of the named variable */
358     sciErr = getVarType(pvApiCtx, piAddr, &iType);
359     if (sciErr.iErr)
360     {
361         FREE(pStVarOne);
362         printError(&sciErr, 0);
363         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
364         return 0;
365     }
366
367     switch (iType)
368     {
369         case sci_matrix :
370
371             /* get complexity */
372             iComplex    = isVarComplex(pvApiCtx, piAddr);
373
374             /* check complexity */
375             if (iComplex)
376             {
377                 /* get size and data from Scilab memory */
378                 sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal, &pdblImg);
379                 if (sciErr.iErr)
380                 {
381                     FREE(pStVarOne);
382                     printError(&sciErr, 0);
383                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
384                     return 0;
385                 }
386
387                 ppdblRealMatrix = wrap<double, double>(pdblReal, iRows, iCols);
388                 ppdblImgMatrix = wrap<double, double>(pdblImg, iRows, iCols);
389
390                 try
391                 {
392                     if (nbRowsIndex == 0 || nbColsIndex == 0)
393                     {
394                         /* Launch Java Variable Editor through JNI */
395                         EditVar::openVariableEditorComplex(getScilabJavaVM(),
396                                                            ppdblRealMatrix,
397                                                            iRows,
398                                                            iCols,
399                                                            ppdblImgMatrix,
400                                                            iRows,
401                                                            iCols,
402                                                            pStVarOne);
403                     }
404                     else
405                     {
406                         /* Launch Java Variable Editor through JNI */
407                         EditVar::refreshVariableEditorComplex(getScilabJavaVM(),
408                                                               ppdblRealMatrix,
409                                                               iRows,
410                                                               iCols,
411                                                               ppdblImgMatrix,
412                                                               iRows,
413                                                               iCols,
414                                                               rowsIndex,
415                                                               nbRowsIndex,
416                                                               colsIndex,
417                                                               nbColsIndex,
418                                                               pStVarOne);
419                     }
420                 }
421                 catch (const GiwsException::JniException & e)
422                 {
423                     Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
424                 }
425
426                 clearWrap<double>(ppdblRealMatrix, iRows);
427                 clearWrap<double>(ppdblImgMatrix, iRows);
428             }
429             else
430             {
431                 /* get size and data from Scilab memory */
432                 sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal);
433                 if (sciErr.iErr)
434                 {
435                     FREE(pStVarOne);
436                     printError(&sciErr, 0);
437                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
438                     return 0;
439                 }
440                 /*
441                  * we need this to make the links between the API (which return a double*)
442                  * and the JNI which needs a double**
443                  */
444                 ppdblRealMatrix = wrap<double, double>(pdblReal, iRows, iCols);
445
446                 /* Launch Java Variable Editor through JNI */
447                 try
448                 {
449                     if (nbRowsIndex == 0 || nbColsIndex == 0)
450                     {
451                         EditVar::openVariableEditorDouble(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, pStVarOne);
452                     }
453                     else
454                     {
455                         EditVar::refreshVariableEditorDouble(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
456                     }
457                 }
458                 catch (const GiwsException::JniException & e)
459                 {
460                     Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
461                 }
462
463                 clearWrap<double>(ppdblRealMatrix, iRows);
464             }
465             break;
466
467         case sci_strings :
468
469             //first call to retrieve dimensions
470             sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
471             if (sciErr.iErr)
472             {
473                 FREE(pStVarOne);
474                 printError(&sciErr, 0);
475                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
476                 return 0;
477             }
478
479             piLen = (int*)malloc(sizeof(int) * iRows * iCols);
480
481             //second call to retrieve length of each string
482             sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, NULL);
483             if (sciErr.iErr)
484             {
485                 FREE(pStVarOne);
486                 FREE(piLen);
487                 printError(&sciErr, 0);
488                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
489                 return 0;
490             }
491
492             pstData = (char**)calloc(iRows * iCols, sizeof(char*));
493             for (int i = 0 ; i < iRows * iCols ; i++)
494             {
495                 pstData[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
496             }
497             //third call to retrieve data
498             sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData);
499             if (sciErr.iErr)
500             {
501                 FREE(pStVarOne);
502                 FREE(piLen);
503                 freeArrayOfString(pstData, iRows * iCols);
504                 printError(&sciErr, 0);
505                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
506                 return 0;
507             }
508
509             /*
510              * we need this to make the links between the API (which return a char**)
511              * and the JNI which needs a char***
512              */
513             ppstData = wrap<char *, char *>(pstData, iRows, iCols);
514
515             /* Launch Java Variable Editor through JNI */
516             try
517             {
518                 if (nbRowsIndex == 0 || nbColsIndex == 0)
519                 {
520                     EditVar::openVariableEditorString(getScilabJavaVM(), ppstData, iRows, iCols, pStVarOne);
521                 }
522                 else
523                 {
524                     EditVar::refreshVariableEditorString(getScilabJavaVM(), ppstData, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
525                 }
526             }
527             catch (const GiwsException::JniException & e)
528             {
529                 Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
530             }
531
532             FREE(piLen);
533             freeArrayOfString(pstData, iRows * iCols);
534
535             clearWrap<char *>(ppstData, iRows);
536
537             break;
538
539         case sci_boolean :
540             //get size and data from Scilab memory
541             sciErr = getMatrixOfBoolean(pvApiCtx, piAddr, &iRows, &iCols, &piBool);
542             if (sciErr.iErr)
543             {
544                 FREE(pStVarOne);
545                 printError(&sciErr, 0);
546                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
547                 return 0;
548             }
549
550             /*
551              * we need this to make the links between the API (which return a int*)
552              * and the JNI which needs a int**
553              */
554             ppiBool = wrap<int, int>(piBool, iRows, iCols);
555
556             /* Launch Java Variable Editor through JNI */
557             try
558             {
559                 if (nbRowsIndex == 0 || nbColsIndex == 0)
560                 {
561                     EditVar::openVariableEditorBoolean(getScilabJavaVM(), ppiBool, iRows, iCols, pStVarOne);
562                 }
563                 else
564                 {
565                     EditVar::refreshVariableEditorBoolean(getScilabJavaVM(), ppiBool, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
566                 }
567             }
568             catch (const GiwsException::JniException & e)
569             {
570                 Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
571             }
572
573             clearWrap<int>(ppiBool, iRows);
574
575             break;
576
577         case sci_ints :
578             //get size and data from Scilab memory
579             int prec;
580             sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr, &prec);
581             if (sciErr.iErr)
582             {
583                 FREE(pStVarOne);
584                 printError(&sciErr, 0);
585                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
586                 return 0;
587             }
588
589             switch (prec)
590             {
591                 case SCI_INT8 :
592                     sciErr = getMatrixOfInteger8(pvApiCtx, piAddr, &iRows, &iCols, &piInt8);
593                     if (sciErr.iErr)
594                     {
595                         printError(&sciErr, 0);
596                         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
597                         return -1;
598                     }
599
600                     ppiInt8 = wrap<char, char>(piInt8, iRows, iCols);
601
602                     /* Launch Java Variable Editor through JNI */
603                     try
604                     {
605                         if (nbRowsIndex == 0 || nbColsIndex == 0)
606                         {
607                             EditVar::openVariableEditorInteger8(getScilabJavaVM(), reinterpret_cast<byte**>(ppiInt8), iRows, iCols, pStVarOne);
608                         }
609                         else
610                         {
611                             EditVar::refreshVariableEditorInteger8(getScilabJavaVM(), reinterpret_cast<byte**>(ppiInt8), iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
612                         }
613                     }
614                     catch (const GiwsException::JniException & e)
615                     {
616                         Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
617                     }
618
619                     clearWrap<char>(ppiInt8, iRows);
620
621                     break;
622
623                 case SCI_UINT8 :
624                     sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddr, &iRows, &iCols, &piUInt8);
625                     if (sciErr.iErr)
626                     {
627                         printError(&sciErr, 0);
628                         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
629                         return -1;
630                     }
631
632                     ppiUInt8 = wrap<short, unsigned char>(piUInt8, iRows, iCols);
633
634                     /* Launch Java Variable Editor through JNI */
635                     try
636                     {
637                         if (nbRowsIndex == 0 || nbColsIndex == 0)
638                         {
639                             EditVar::openVariableEditorUInteger8(getScilabJavaVM(), ppiUInt8, iRows, iCols, pStVarOne);
640                         }
641                         else
642                         {
643                             EditVar::refreshVariableEditorUInteger8(getScilabJavaVM(), ppiUInt8, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
644                         }
645                     }
646                     catch (const GiwsException::JniException & e)
647                     {
648                         Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
649                     }
650
651                     clearWrap<short>(ppiUInt8, iRows);
652
653                     break;
654
655                 case SCI_INT16 :
656                     sciErr = getMatrixOfInteger16(pvApiCtx, piAddr, &iRows, &iCols, &piInt16);
657                     if (sciErr.iErr)
658                     {
659                         printError(&sciErr, 0);
660                         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
661                         return -1;
662                     }
663
664                     ppiInt16 = wrap<short, short>(piInt16, iRows, iCols);
665
666                     /* Launch Java Variable Editor through JNI */
667                     try
668                     {
669                         if (nbRowsIndex == 0 || nbColsIndex == 0)
670                         {
671                             EditVar::openVariableEditorInteger16(getScilabJavaVM(), ppiInt16, iRows, iCols, pStVarOne);
672                         }
673                         else
674                         {
675                             EditVar::refreshVariableEditorInteger16(getScilabJavaVM(), ppiInt16, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
676                         }
677                     }
678                     catch (const GiwsException::JniException & e)
679                     {
680                         Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
681                     }
682
683                     clearWrap<short>(ppiInt16, iRows);
684
685                     break;
686
687                 case SCI_UINT16 :
688                     sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddr, &iRows, &iCols, &piUInt16);
689                     if (sciErr.iErr)
690                     {
691                         printError(&sciErr, 0);
692                         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
693                         return -1;
694                     }
695
696                     ppiUInt16 = wrap<int, unsigned short>(piUInt16, iRows, iCols);
697
698                     /* Launch Java Variable Editor through JNI */
699                     try
700                     {
701                         if (nbRowsIndex == 0 || nbColsIndex == 0)
702                         {
703                             EditVar::openVariableEditorUInteger16(getScilabJavaVM(), ppiUInt16, iRows, iCols, pStVarOne);
704                         }
705                         else
706                         {
707                             EditVar::refreshVariableEditorUInteger16(getScilabJavaVM(), ppiUInt16, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
708                         }
709                     }
710                     catch (const GiwsException::JniException & e)
711                     {
712                         Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
713                     }
714
715                     clearWrap<int>(ppiUInt16, iRows);
716
717                     break;
718
719                 case SCI_INT32 :
720                     sciErr = getMatrixOfInteger32(pvApiCtx, piAddr, &iRows, &iCols, &piInt32);
721                     if (sciErr.iErr)
722                     {
723                         printError(&sciErr, 0);
724                         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
725                         return -1;
726                     }
727
728                     ppiInt32 = wrap<int>(piInt32, iRows, iCols);
729
730                     /* Launch Java Variable Editor through JNI */
731                     try
732                     {
733                         if (nbRowsIndex == 0 || nbColsIndex == 0)
734                         {
735                             EditVar::openVariableEditorInteger32(getScilabJavaVM(), ppiInt32, iRows, iCols, pStVarOne);
736                         }
737                         else
738                         {
739                             EditVar::refreshVariableEditorInteger32(getScilabJavaVM(), ppiInt32, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
740                         }
741                     }
742                     catch (const GiwsException::JniException & e)
743                     {
744                         Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
745                     }
746
747                     clearWrap<int>(ppiInt32, iRows);
748
749                     break;
750
751                 case SCI_UINT32 :
752                     sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddr, &iRows, &iCols, &piUInt32);
753                     if (sciErr.iErr)
754                     {
755                         printError(&sciErr, 0);
756                         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
757                         return -1;
758                     }
759
760                     ppiUInt32 = wrap<long long int, unsigned int>(piUInt32, iRows, iCols);
761
762                     /* Launch Java Variable Editor through JNI */
763                     try
764                     {
765                         if (nbRowsIndex == 0 || nbColsIndex == 0)
766                         {
767                             EditVar::openVariableEditorUInteger32(getScilabJavaVM(), ppiUInt32, iRows, iCols, pStVarOne);
768                         }
769                         else
770                         {
771                             EditVar::refreshVariableEditorUInteger32(getScilabJavaVM(), ppiUInt32, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
772                         }
773                     }
774                     catch (const GiwsException::JniException & e)
775                     {
776                         Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
777                     }
778
779                     clearWrap<long long int>(ppiUInt32, iRows);
780
781                     break;
782
783                 default :
784
785                     Scierror(42, _("%s: Type not handle yet"), fname);
786                     return 0;
787             }
788
789             break;
790
791         case sci_boolean_sparse :
792             sciErr = getBooleanSparseMatrix(pvApiCtx, piAddr, &iRows, &iCols, &piNbItem, &piNbItemRow, &piColPos);
793             if (sciErr.iErr)
794             {
795                 FREE(pStVarOne);
796                 printError(&sciErr, 0);
797                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
798                 return 0;
799             }
800
801             ppiBool = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols);
802
803             /* Launch Java Variable Editor through JNI */
804             try
805             {
806                 if (nbRowsIndex == 0 || nbColsIndex == 0)
807                 {
808                     EditVar::openVariableEditorBooleanSparse(getScilabJavaVM(), ppiBool, iRows, iCols, pStVarOne);
809                 }
810                 else
811                 {
812                     EditVar::refreshVariableEditorBooleanSparse(getScilabJavaVM(), ppiBool, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
813                 }
814             }
815             catch (const GiwsException::JniException & e)
816             {
817                 Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
818             }
819
820             clearWrap<int>(ppiBool, iRows);
821             break;
822         case sci_sparse :
823             if (isVarComplex(pvApiCtx, piAddr))
824             {
825                 sciErr = getComplexSparseMatrix(pvApiCtx, piAddr, &iRows, &iCols, &piNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg);
826                 if (sciErr.iErr)
827                 {
828                     FREE(pStVarOne);
829                     printError(&sciErr, 0);
830                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
831                     return 0;
832                 }
833
834                 ppdblRealMatrix = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols, pdblReal);
835                 ppdblImgMatrix = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols, pdblImg);
836
837                 /* Launch Java Variable Editor through JNI */
838                 try
839                 {
840                     if (nbRowsIndex == 0 || nbColsIndex == 0)
841                     {
842                         EditVar::openVariableEditorComplexSparse(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, ppdblImgMatrix, iRows, iCols, pStVarOne);
843                     }
844                     else
845                     {
846                         EditVar::refreshVariableEditorComplexSparse(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, ppdblImgMatrix, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
847                     }
848                 }
849                 catch (const GiwsException::JniException & e)
850                 {
851                     Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
852                 }
853
854                 clearWrap<double>(ppdblRealMatrix, iRows);
855                 clearWrap<double>(ppdblImgMatrix, iRows);
856             }
857             else
858             {
859                 sciErr = getSparseMatrix(pvApiCtx, piAddr, &iRows, &iCols, &piNbItem, &piNbItemRow, &piColPos, &pdblReal);
860                 if (sciErr.iErr)
861                 {
862                     FREE(pStVarOne);
863                     printError(&sciErr, 0);
864                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
865                     return 0;
866                 }
867
868                 ppdblRealMatrix = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols, pdblReal);
869
870                 /* Launch Java Variable Editor through JNI */
871                 try
872                 {
873                     if (nbRowsIndex == 0 || nbColsIndex == 0)
874                     {
875                         EditVar::openVariableEditorSparse(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, pStVarOne);
876                     }
877                     else
878                     {
879                         EditVar::refreshVariableEditorSparse(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
880                     }
881                 }
882                 catch (const GiwsException::JniException & e)
883                 {
884                     Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
885                 }
886
887                 clearWrap<double>(ppdblRealMatrix, iRows);
888             }
889             break;
890         default:
891
892             Scierror(42, _("%s: Type not handle yet"), fname);
893             return 0;
894     }
895
896     FREE(pStVarOne);
897
898     LhsVar(1) = 0;
899     PutLhsVar();
900     return 0;
901 }
902 /*--------------------------------------------------------------------------*/