add some Scierror after printError to create an error in Scilab
[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-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 "stack-c.h"
25 #include "api_scilab.h"
26 #include "localization.h"
27 #include "Scierror.h"
28 #include "MALLOC.h"
29 #include "freeArrayOfString.h"
30 #include "sciprint.h"
31 #include "getScilabJavaVM.h"
32 #include "localization.h"
33 #include <time.h>
34 }
35
36 using namespace org_scilab_modules_ui_data;
37 /*--------------------------------------------------------------------------*/
38 template <typename T, typename U>
39 T** wrap(U * x, int r, int c)
40 {
41     T ** xx = new T*[r];
42     for (int i = 0; i < r; i++)
43     {
44         xx[i] = new T[c];
45         for (int j = 0; j < c; j++)
46         {
47             xx[i][j] = static_cast<T>(x[j * r + i]);
48         }
49     }
50
51     return xx;
52 }
53 /*--------------------------------------------------------------------------*/
54 /* 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
55    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] */
56 double ** wrapSparse(int nbItem, int * nbItemRow, int * colPos, int r, int c, double * x)
57 {
58     double ** xx = new double*[r];
59     int prev = 0;
60     for (int i = 0; i < r; i++)
61     {
62         xx[i] = new double[c];
63         memset(xx[i], 0, c * sizeof(double));
64         for (int j = 0; j < nbItemRow[i]; j++) {
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             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, unsigned long fname_len)
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     int * piLen = NULL;
145     char *** ppstData = NULL;
146
147     int * piAddressVarOne = NULL;
148     char * pStVarOne = NULL;
149     int lenStVarOne = 0;
150
151     int * addr = NULL;
152     double * rowsIndex = NULL;
153     int nbRowsIndex = 0;
154     double * colsIndex = NULL;
155     int nbColsIndex = 0;
156
157     int piNbItem = 0;
158     int * piNbItemRow = NULL;
159     int * piColPos = NULL;
160
161     if (Rhs == 3)
162     {
163         Scierror(999,_("%s: Wrong number of input argument(s): 1, 2 or 4 expected.\n"), fname);
164         return 0;
165     }
166
167     /* get address */
168     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
169     if (sciErr.iErr)
170     {
171         printError(&sciErr, 0);
172         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
173         return 0;
174     }
175
176     sciErr = getVarType(pvApiCtx, piAddressVarOne, &iType);
177     if (sciErr.iErr)
178     {
179         printError(&sciErr, 0);
180         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
181         return 0;
182     }
183
184     if (iType != sci_strings)
185     {
186         Scierror(999,_("%s: Wrong type for input argument #%d: A String expected.\n"), fname, 1);
187         return 0;
188     }
189
190     /* get dimensions */
191     sciErr = getMatrixOfString(pvApiCtx, piAddressVarOne, &m1, &n1, NULL, NULL);
192     if (sciErr.iErr)
193     {
194         printError(&sciErr, 0);
195         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
196         return 0;
197     }
198
199     /* TODO maybe allow vectors in case someone wants to edit several variables in the same time? */
200     if (m1 != 1 || n1 != 1)
201     {
202         Scierror(999,_("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
203         return 0;
204     }
205
206     /* get lengths */
207     sciErr = getMatrixOfString(pvApiCtx, piAddressVarOne, &m1, &n1, &lenStVarOne, NULL);
208     if (sciErr.iErr)
209     {
210         printError(&sciErr, 0);
211         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
212         return 0;
213     }
214
215     pStVarOne = (char*)MALLOC(sizeof(char*) * (lenStVarOne + 1));
216
217     /* get variable name to edit */
218     sciErr = getMatrixOfString(pvApiCtx, piAddressVarOne, &m1, &n1, &lenStVarOne, &pStVarOne);
219     if (sciErr.iErr)
220     {
221         FREE(pStVarOne);
222         printError(&sciErr, 0);
223         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
224         return 0;
225     }
226
227     if (strcmp(pStVarOne, "ans") == 0)
228     {
229         Scierror(999, _("%s: ans cannot be edited.\n"), fname);
230         FREE(pStVarOne);
231         return 0;
232     }
233
234     /* get address of the variable*/
235     sciErr = getVarAddressFromName(pvApiCtx, pStVarOne, &piAddr);
236     if (sciErr.iErr)
237     {
238         Scierror(4, _("%s: Undefined variable %s.\n"), fname, pStVarOne);
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         //fisrt call to retrieve dimensions
438         sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
439         if (sciErr.iErr)
440         {
441             FREE(pStVarOne);
442             printError(&sciErr, 0);
443             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
444             return 0;
445         }
446
447         piLen = (int*)malloc(sizeof(int) * iRows * iCols);
448
449         //second call to retrieve length of each string
450         sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, NULL);
451         if (sciErr.iErr)
452         {
453             FREE(pStVarOne);
454             FREE(piLen);
455             printError(&sciErr, 0);
456             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
457             return 0;
458         }
459
460         pstData = (char**)calloc(iRows * iCols, sizeof(char*));
461         for(int i = 0 ; i < iRows * iCols ; i++)
462         {
463             pstData[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
464         }
465         //third call to retrieve data
466         sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData);
467         if (sciErr.iErr)
468         {
469             FREE(pStVarOne);
470             FREE(piLen);
471             freeArrayOfString(pstData, iRows * iCols);
472             printError(&sciErr, 0);
473             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
474             return 0;
475         }
476
477         /*
478          * we need this to make the links between the API (which return a char**)
479          * and the JNI which needs a char***
480          */
481         ppstData = wrap<char *, char *>(pstData, iRows, iCols);
482
483         /* Launch Java Variable Editor through JNI */
484         try
485         {
486             if (nbRowsIndex == 0 || nbColsIndex == 0)
487             {
488                 EditVar::openVariableEditorString(getScilabJavaVM(), ppstData, iRows, iCols, pStVarOne);
489             }
490             else
491             {
492                 EditVar::refreshVariableEditorString(getScilabJavaVM(), ppstData, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
493             }
494         }
495         catch (const GiwsException::JniException & e)
496         {
497             Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
498         }
499
500         FREE(piLen);
501         freeArrayOfString(pstData, iRows * iCols);
502
503         clearWrap<char *>(ppstData, iRows);
504
505         break;
506
507     case sci_boolean :
508         //get size and data from Scilab memory
509         sciErr = getMatrixOfBoolean(pvApiCtx, piAddr, &iRows, &iCols, &piBool);
510         if (sciErr.iErr)
511         {
512             FREE(pStVarOne);
513             printError(&sciErr, 0);
514             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
515             return 0;
516         }
517
518         /*
519          * we need this to make the links between the API (which return a int*)
520          * and the JNI which needs a int**
521          */
522         ppiBool = wrap<int, int>(piBool, iRows, iCols);
523
524         /* Launch Java Variable Editor through JNI */
525         try
526         {
527             if (nbRowsIndex == 0 || nbColsIndex == 0)
528             {
529                 EditVar::openVariableEditorBoolean(getScilabJavaVM(), ppiBool, iRows, iCols, pStVarOne);
530             }
531             else
532             {
533                 EditVar::refreshVariableEditorBoolean(getScilabJavaVM(), ppiBool, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
534             }
535         }
536         catch (const GiwsException::JniException & e)
537         {
538             Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
539         }
540
541         clearWrap<int>(ppiBool, iRows);
542
543         break;
544
545     case sci_ints :
546         //get size and data from Scilab memory
547         int prec;
548         sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr, &prec);
549         if (sciErr.iErr)
550         {
551             FREE(pStVarOne);
552             printError(&sciErr, 0);
553             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
554             return 0;
555         }
556
557         switch (prec)
558         {
559         case SCI_INT8 :
560             sciErr = getMatrixOfInteger8(pvApiCtx, piAddr, &iRows, &iCols, &piInt8);
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             ppiInt8 = wrap<char, char>(piInt8, iRows, iCols);
569
570             /* Launch Java Variable Editor through JNI */
571             try
572             {
573                 if (nbRowsIndex == 0 || nbColsIndex == 0)
574                 {
575                     EditVar::openVariableEditorInteger8(getScilabJavaVM(), reinterpret_cast<byte**>(ppiInt8), iRows, iCols, pStVarOne);
576                 }
577                 else
578                 {
579                     EditVar::refreshVariableEditorInteger8(getScilabJavaVM(), reinterpret_cast<byte**>(ppiInt8), 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<char>(ppiInt8, iRows);
588
589             break;
590
591         case SCI_UINT8 :
592             sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddr, &iRows, &iCols, &piUInt8);
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             ppiUInt8 = wrap<short, unsigned char>(piUInt8, iRows, iCols);
601
602             /* Launch Java Variable Editor through JNI */
603             try
604             {
605                 if (nbRowsIndex == 0 || nbColsIndex == 0)
606                 {
607                     EditVar::openVariableEditorUInteger8(getScilabJavaVM(), ppiUInt8, iRows, iCols, pStVarOne);
608                 }
609                 else
610                 {
611                     EditVar::refreshVariableEditorUInteger8(getScilabJavaVM(), ppiUInt8, 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>(ppiUInt8, iRows);
620
621             break;
622
623         case SCI_INT16 :
624             sciErr = getMatrixOfInteger16(pvApiCtx, piAddr, &iRows, &iCols, &piInt16);
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             ppiInt16 = wrap<short, short>(piInt16, iRows, iCols);
633
634             /* Launch Java Variable Editor through JNI */
635             try
636             {
637                 if (nbRowsIndex == 0 || nbColsIndex == 0)
638                 {
639                     EditVar::openVariableEditorInteger16(getScilabJavaVM(), ppiInt16, iRows, iCols, pStVarOne);
640                 }
641                 else
642                 {
643                     EditVar::refreshVariableEditorInteger16(getScilabJavaVM(), ppiInt16, 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>(ppiInt16, iRows);
652
653             break;
654
655         case SCI_UINT16 :
656             sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddr, &iRows, &iCols, &piUInt16);
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             ppiUInt16 = wrap<int, unsigned short>(piUInt16, iRows, iCols);
665
666             /* Launch Java Variable Editor through JNI */
667             try
668             {
669                 if (nbRowsIndex == 0 || nbColsIndex == 0)
670                 {
671                     EditVar::openVariableEditorUInteger16(getScilabJavaVM(), ppiUInt16, iRows, iCols, pStVarOne);
672                 }
673                 else
674                 {
675                     EditVar::refreshVariableEditorUInteger16(getScilabJavaVM(), ppiUInt16, 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>(ppiUInt16, iRows);
684
685             break;
686
687         case SCI_INT32 :
688             sciErr = getMatrixOfInteger32(pvApiCtx, piAddr, &iRows, &iCols, &piInt32);
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             ppiInt32 = wrap<int>(piInt32, iRows, iCols);
697
698             /* Launch Java Variable Editor through JNI */
699             try
700             {
701                 if (nbRowsIndex == 0 || nbColsIndex == 0)
702                 {
703                     EditVar::openVariableEditorInteger32(getScilabJavaVM(), ppiInt32, iRows, iCols, pStVarOne);
704                 }
705                 else
706                 {
707                     EditVar::refreshVariableEditorInteger32(getScilabJavaVM(), ppiInt32, 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>(ppiInt32, iRows);
716
717             break;
718
719         case SCI_UINT32 :
720             sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddr, &iRows, &iCols, &piUInt32);
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             ppiUInt32 = wrap<long long int, unsigned int>(piUInt32, iRows, iCols);
729
730             /* Launch Java Variable Editor through JNI */
731             try
732             {
733                 if (nbRowsIndex == 0 || nbColsIndex == 0)
734                 {
735                     EditVar::openVariableEditorUInteger32(getScilabJavaVM(), ppiUInt32, iRows, iCols, pStVarOne);
736                 }
737                 else
738                 {
739                     EditVar::refreshVariableEditorUInteger32(getScilabJavaVM(), ppiUInt32, 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<long long int>(ppiUInt32, iRows);
748
749             break;
750
751         default :
752
753             Scierror(42, _("%s: Type not handle yet"), fname);
754             return 0;
755         }
756
757         break;
758
759     case sci_boolean_sparse :
760         sciErr = getBooleanSparseMatrix(pvApiCtx, piAddr, &iRows, &iCols, &piNbItem, &piNbItemRow, &piColPos);
761         if (sciErr.iErr)
762         {
763             FREE(pStVarOne);
764             printError(&sciErr, 0);
765             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
766             return 0;
767         }
768
769         ppiBool = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols);
770
771         /* Launch Java Variable Editor through JNI */
772         try
773         {
774             if (nbRowsIndex == 0 || nbColsIndex == 0)
775             {
776                 EditVar::openVariableEditorBooleanSparse(getScilabJavaVM(), ppiBool, iRows, iCols, pStVarOne);
777             }
778             else
779             {
780                 EditVar::refreshVariableEditorBooleanSparse(getScilabJavaVM(), ppiBool, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
781             }
782         }
783         catch (const GiwsException::JniException & e)
784         {
785             Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
786         }
787
788         clearWrap<int>(ppiBool, iRows);
789         break;
790     case sci_sparse :
791         if (isVarComplex(pvApiCtx, piAddr))
792         {
793             sciErr = getComplexSparseMatrix(pvApiCtx, piAddr, &iRows, &iCols, &piNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg);
794             if (sciErr.iErr)
795             {
796                 FREE(pStVarOne);
797                 printError(&sciErr, 0);
798                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
799                 return 0;
800             }
801
802             ppdblRealMatrix = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols, pdblReal);
803             ppdblImgMatrix = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols, pdblImg);
804
805             /* Launch Java Variable Editor through JNI */
806             try
807             {
808                 if (nbRowsIndex == 0 || nbColsIndex == 0)
809                 {
810                     EditVar::openVariableEditorComplexSparse(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, ppdblImgMatrix, iRows, iCols, pStVarOne);
811                 }
812                 else
813                 {
814                     EditVar::refreshVariableEditorComplexSparse(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, ppdblImgMatrix, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
815                 }
816             }
817             catch (const GiwsException::JniException & e)
818             {
819                 Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
820             }
821
822             clearWrap<double>(ppdblRealMatrix, iRows);
823             clearWrap<double>(ppdblImgMatrix, iRows);
824         }
825         else
826         {
827             sciErr = getSparseMatrix(pvApiCtx, piAddr, &iRows, &iCols, &piNbItem, &piNbItemRow, &piColPos, &pdblReal);
828             if (sciErr.iErr)
829             {
830                 FREE(pStVarOne);
831                 printError(&sciErr, 0);
832                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
833                 return 0;
834             }
835
836             ppdblRealMatrix = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols, pdblReal);
837
838             /* Launch Java Variable Editor through JNI */
839             try
840             {
841                 if (nbRowsIndex == 0 || nbColsIndex == 0)
842                 {
843                     EditVar::openVariableEditorSparse(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, pStVarOne);
844                 }
845                 else
846                 {
847                     EditVar::refreshVariableEditorSparse(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
848                 }
849             }
850             catch (const GiwsException::JniException & e)
851             {
852                 Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
853             }
854
855             clearWrap<double>(ppdblRealMatrix, iRows);
856         }
857         break;
858     default:
859
860         Scierror(42, _("%s: Type not handle yet"), fname);
861         return 0;
862     }
863
864     FREE(pStVarOne);
865
866     LhsVar(1) = 0;
867     PutLhsVar();
868     return 0;
869 }
870 /*--------------------------------------------------------------------------*/