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