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