1c9173dd91535d036a8b0f4b0cba3ce136720500
[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         return 0;
173     }
174
175     sciErr = getVarType(pvApiCtx, piAddressVarOne, &iType);
176     if (sciErr.iErr)
177     {
178         printError(&sciErr, 0);
179         return 0;
180     }
181
182     if (iType != sci_strings)
183     {
184         Scierror(999,_("%s: Wrong type for input argument #%d: A String expected.\n"), fname, 1);
185         return 0;
186     }
187
188     /* get dimensions */
189     sciErr = getMatrixOfString(pvApiCtx, piAddressVarOne, &m1, &n1, NULL, NULL);
190     if (sciErr.iErr)
191     {
192         printError(&sciErr, 0);
193         return 0;
194     }
195
196     /* TODO maybe allow vectors in case someone wants to edit several variables in the same time? */
197     if (m1 != 1 || n1 != 1)
198     {
199         Scierror(999,_("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
200         return 0;
201     }
202
203     /* get lengths */
204     sciErr = getMatrixOfString(pvApiCtx, piAddressVarOne, &m1, &n1, &lenStVarOne, NULL);
205     if (sciErr.iErr)
206     {
207         printError(&sciErr, 0);
208         return 0;
209     }
210
211     pStVarOne = (char*)MALLOC(sizeof(char*) * (lenStVarOne + 1));
212
213     /* get variable name to edit */
214     sciErr = getMatrixOfString(pvApiCtx, piAddressVarOne, &m1, &n1, &lenStVarOne, &pStVarOne);
215     if (sciErr.iErr)
216     {
217         FREE(pStVarOne);
218         printError(&sciErr, 0);
219         return 0;
220     }
221
222     if (strcmp(pStVarOne, "ans") == 0)
223     {
224         Scierror(999, _("%s: ans cannot be edited.\n"), fname);
225         FREE(pStVarOne);
226         return 0;
227     }
228
229     /* get address of the variable*/
230     sciErr = getVarAddressFromName(pvApiCtx, pStVarOne, &piAddr);
231     if (sciErr.iErr)
232     {
233         Scierror(4, _("%s: Undefined variable %s.\n"), fname, pStVarOne);
234         FREE(pStVarOne);
235         return 0;
236     }
237
238     if (Rhs == 1)
239     {
240         /* get address of the variable*/
241         sciErr = getVarAddressFromName(pvApiCtx, pStVarOne, &piAddr);
242         if(sciErr.iErr)
243         {
244             Scierror(4, _("%s: Undefined variable %s.\n"), fname, pStVarOne);
245             FREE(pStVarOne);
246             return 0;
247         }
248     }
249     else
250     {
251         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
252         if(sciErr.iErr)
253         {
254             FREE(pStVarOne);
255             printError(&sciErr, 0);
256             return 0;
257         }
258     }
259
260     if (Rhs == 4)
261     {
262         sciErr = getVarAddressFromPosition(pvApiCtx, 3, &addr);
263         if (sciErr.iErr)
264         {
265             printError(&sciErr, 0);
266             FREE(pStVarOne);
267             return 0;
268         }
269
270         if (!isDoubleType(pvApiCtx, addr))
271         {
272             Scierror(999,_("%s: Wrong type for input argument #%d: Double expected.\n"), fname, 3);
273             FREE(pStVarOne);
274             return 0;
275         }
276
277         sciErr = getMatrixOfDouble(pvApiCtx, addr, &iRows, &iCols, &rowsIndex);
278         if (sciErr.iErr)
279         {
280             FREE(pStVarOne);
281             printError(&sciErr, 0);
282             return 0;
283         }
284
285         nbRowsIndex = iRows * iCols;
286
287         sciErr = getVarAddressFromPosition(pvApiCtx, 4, &addr);
288         if (sciErr.iErr)
289         {
290             printError(&sciErr, 0);
291             FREE(pStVarOne);
292             return 0;
293         }
294
295         if (!isDoubleType(pvApiCtx, addr))
296         {
297             Scierror(999,_("%s: Wrong type for input argument #%d: Double expected.\n"), fname, 4);
298             FREE(pStVarOne);
299             return 0;
300         }
301
302         sciErr = getMatrixOfDouble(pvApiCtx, addr, &iRows, &iCols, &colsIndex);
303         if (sciErr.iErr)
304         {
305             FREE(pStVarOne);
306             printError(&sciErr, 0);
307             return 0;
308         }
309
310         nbColsIndex = iRows * iCols;
311     }
312
313     //org_modules_commons::ScilabToJava::sendVariable(std::string(pStVarOne), true, pvApiCtx);
314
315     /* get type of the named variable */
316     sciErr = getVarType(pvApiCtx, piAddr, &iType);
317     if (sciErr.iErr)
318     {
319         FREE(pStVarOne);
320         printError(&sciErr, 0);
321         return 0;
322     }
323
324     switch(iType)
325     {
326     case sci_matrix :
327
328         /* get complexity */
329         iComplex    = isVarComplex(pvApiCtx, piAddr);
330
331         /* check complexity */
332         if (iComplex)
333         {
334             /* get size and data from Scilab memory */
335             sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal, &pdblImg);
336             if (sciErr.iErr)
337             {
338                 FREE(pStVarOne);
339                 printError(&sciErr, 0);
340                 return 0;
341             }
342
343             ppdblRealMatrix = wrap<double, double>(pdblReal, iRows, iCols);
344             ppdblImgMatrix = wrap<double, double>(pdblImg, iRows, iCols);
345
346             try
347             {
348                 if (nbRowsIndex == 0 || nbColsIndex == 0)
349                 {
350                     /* Launch Java Variable Editor through JNI */
351                     EditVar::openVariableEditorComplex(getScilabJavaVM(),
352                                                        ppdblRealMatrix,
353                                                        iRows,
354                                                        iCols,
355                                                        ppdblImgMatrix,
356                                                        iRows,
357                                                        iCols,
358                                                        pStVarOne);
359                 }
360                 else
361                 {
362                     /* Launch Java Variable Editor through JNI */
363                     EditVar::refreshVariableEditorComplex(getScilabJavaVM(),
364                                                           ppdblRealMatrix,
365                                                           iRows,
366                                                           iCols,
367                                                           ppdblImgMatrix,
368                                                           iRows,
369                                                           iCols,
370                                                           rowsIndex,
371                                                           nbRowsIndex,
372                                                           colsIndex,
373                                                           nbColsIndex,
374                                                           pStVarOne);
375                 }
376             }
377             catch (const GiwsException::JniException & e)
378             {
379                 Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
380             }
381
382             clearWrap<double>(ppdblRealMatrix, iRows);
383             clearWrap<double>(ppdblImgMatrix, iRows);
384         }
385         else
386         {
387             /* get size and data from Scilab memory */
388             sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal);
389             if (sciErr.iErr)
390             {
391                 FREE(pStVarOne);
392                 printError(&sciErr, 0);
393                 return 0;
394             }
395             /*
396              * we need this to make the links between the API (which return a double*)
397              * and the JNI which needs a double**
398              */
399             ppdblRealMatrix = wrap<double, double>(pdblReal, iRows, iCols);
400
401             /* Launch Java Variable Editor through JNI */
402             try
403             {
404                 if (nbRowsIndex == 0 || nbColsIndex == 0)
405                 {
406                     EditVar::openVariableEditorDouble(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, pStVarOne);
407                 }
408                 else
409                 {
410                     EditVar::refreshVariableEditorDouble(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
411                 }
412             }
413             catch (const GiwsException::JniException & e)
414             {
415                 Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
416             }
417
418             clearWrap<double>(ppdblRealMatrix, iRows);
419         }
420         break;
421
422     case sci_strings :
423
424         //fisrt call to retrieve dimensions
425         sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
426         if (sciErr.iErr)
427         {
428             FREE(pStVarOne);
429             printError(&sciErr, 0);
430             return 0;
431         }
432
433         piLen = (int*)malloc(sizeof(int) * iRows * iCols);
434
435         //second call to retrieve length of each string
436         sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, NULL);
437         if (sciErr.iErr)
438         {
439             FREE(pStVarOne);
440             FREE(piLen);
441             printError(&sciErr, 0);
442             return 0;
443         }
444
445         pstData = (char**)calloc(iRows * iCols, sizeof(char*));
446         for(int i = 0 ; i < iRows * iCols ; i++)
447         {
448             pstData[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
449         }
450         //third call to retrieve data
451         sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData);
452         if (sciErr.iErr)
453         {
454             FREE(pStVarOne);
455             FREE(piLen);
456             freeArrayOfString(pstData, iRows * iCols);
457             printError(&sciErr, 0);
458             return 0;
459         }
460
461         /*
462          * we need this to make the links between the API (which return a char**)
463          * and the JNI which needs a char***
464          */
465         ppstData = wrap<char *, char *>(pstData, iRows, iCols);
466
467         /* Launch Java Variable Editor through JNI */
468         try
469         {
470             if (nbRowsIndex == 0 || nbColsIndex == 0)
471             {
472                 EditVar::openVariableEditorString(getScilabJavaVM(), ppstData, iRows, iCols, pStVarOne);
473             }
474             else
475             {
476                 EditVar::refreshVariableEditorString(getScilabJavaVM(), ppstData, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
477             }
478         }
479         catch (const GiwsException::JniException & e)
480         {
481             Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
482         }
483
484         FREE(piLen);
485         freeArrayOfString(pstData, iRows * iCols);
486
487         clearWrap<char *>(ppstData, iRows);
488
489         break;
490
491     case sci_boolean :
492         //get size and data from Scilab memory
493         sciErr = getMatrixOfBoolean(pvApiCtx, piAddr, &iRows, &iCols, &piBool);
494         if (sciErr.iErr)
495         {
496             FREE(pStVarOne);
497             printError(&sciErr, 0);
498             return 0;
499         }
500
501         /*
502          * we need this to make the links between the API (which return a int*)
503          * and the JNI which needs a int**
504          */
505         ppiBool = wrap<int, int>(piBool, iRows, iCols);
506
507         /* Launch Java Variable Editor through JNI */
508         try
509         {
510             if (nbRowsIndex == 0 || nbColsIndex == 0)
511             {
512                 EditVar::openVariableEditorBoolean(getScilabJavaVM(), ppiBool, iRows, iCols, pStVarOne);
513             }
514             else
515             {
516                 EditVar::refreshVariableEditorBoolean(getScilabJavaVM(), ppiBool, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
517             }
518         }
519         catch (const GiwsException::JniException & e)
520         {
521             Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
522         }
523
524         clearWrap<int>(ppiBool, iRows);
525
526         break;
527
528     case sci_ints :
529         //get size and data from Scilab memory
530         int prec;
531         sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr, &prec);
532         if (sciErr.iErr)
533         {
534             FREE(pStVarOne);
535             printError(&sciErr, 0);
536             return 0;
537         }
538
539         switch (prec)
540         {
541         case SCI_INT8 :
542             sciErr = getMatrixOfInteger8(pvApiCtx, piAddr, &iRows, &iCols, &piInt8);
543             if (sciErr.iErr)
544             {
545                 printError(&sciErr, 0);
546                 return -1;
547             }
548
549             ppiInt8 = wrap<char, char>(piInt8, iRows, iCols);
550
551             /* Launch Java Variable Editor through JNI */
552             try
553             {
554                 if (nbRowsIndex == 0 || nbColsIndex == 0)
555                 {
556                     EditVar::openVariableEditorInteger8(getScilabJavaVM(), reinterpret_cast<byte**>(ppiInt8), iRows, iCols, pStVarOne);
557                 }
558                 else
559                 {
560                     EditVar::refreshVariableEditorInteger8(getScilabJavaVM(), reinterpret_cast<byte**>(ppiInt8), iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
561                 }
562             }
563             catch (const GiwsException::JniException & e)
564             {
565                 Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
566             }
567
568             clearWrap<char>(ppiInt8, iRows);
569
570             break;
571
572         case SCI_UINT8 :
573             sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddr, &iRows, &iCols, &piUInt8);
574             if (sciErr.iErr)
575             {
576                 printError(&sciErr, 0);
577                 return -1;
578             }
579
580             ppiUInt8 = wrap<short, unsigned char>(piUInt8, iRows, iCols);
581
582             /* Launch Java Variable Editor through JNI */
583             try
584             {
585                 if (nbRowsIndex == 0 || nbColsIndex == 0)
586                 {
587                     EditVar::openVariableEditorUInteger8(getScilabJavaVM(), ppiUInt8, iRows, iCols, pStVarOne);
588                 }
589                 else
590                 {
591                     EditVar::refreshVariableEditorUInteger8(getScilabJavaVM(), ppiUInt8, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
592                 }
593             }
594             catch (const GiwsException::JniException & e)
595             {
596                 Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
597             }
598
599             clearWrap<short>(ppiUInt8, iRows);
600
601             break;
602
603         case SCI_INT16 :
604             sciErr = getMatrixOfInteger16(pvApiCtx, piAddr, &iRows, &iCols, &piInt16);
605             if (sciErr.iErr)
606             {
607                 printError(&sciErr, 0);
608                 return -1;
609             }
610
611             ppiInt16 = wrap<short, short>(piInt16, iRows, iCols);
612
613             /* Launch Java Variable Editor through JNI */
614             try
615             {
616                 if (nbRowsIndex == 0 || nbColsIndex == 0)
617                 {
618                     EditVar::openVariableEditorInteger16(getScilabJavaVM(), ppiInt16, iRows, iCols, pStVarOne);
619                 }
620                 else
621                 {
622                     EditVar::refreshVariableEditorInteger16(getScilabJavaVM(), ppiInt16, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
623                 }
624             }
625             catch (const GiwsException::JniException & e)
626             {
627                 Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
628             }
629
630             clearWrap<short>(ppiInt16, iRows);
631
632             break;
633
634         case SCI_UINT16 :
635             sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddr, &iRows, &iCols, &piUInt16);
636             if (sciErr.iErr)
637             {
638                 printError(&sciErr, 0);
639                 return -1;
640             }
641
642             ppiUInt16 = wrap<int, unsigned short>(piUInt16, iRows, iCols);
643
644             /* Launch Java Variable Editor through JNI */
645             try
646             {
647                 if (nbRowsIndex == 0 || nbColsIndex == 0)
648                 {
649                     EditVar::openVariableEditorUInteger16(getScilabJavaVM(), ppiUInt16, iRows, iCols, pStVarOne);
650                 }
651                 else
652                 {
653                     EditVar::refreshVariableEditorUInteger16(getScilabJavaVM(), ppiUInt16, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
654                 }
655             }
656             catch (const GiwsException::JniException & e)
657             {
658                 Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
659             }
660
661             clearWrap<int>(ppiUInt16, iRows);
662
663             break;
664
665         case SCI_INT32 :
666             sciErr = getMatrixOfInteger32(pvApiCtx, piAddr, &iRows, &iCols, &piInt32);
667             if (sciErr.iErr)
668             {
669                 printError(&sciErr, 0);
670                 return -1;
671             }
672
673             ppiInt32 = wrap<int>(piInt32, iRows, iCols);
674
675             /* Launch Java Variable Editor through JNI */
676             try
677             {
678                 if (nbRowsIndex == 0 || nbColsIndex == 0)
679                 {
680                     EditVar::openVariableEditorInteger32(getScilabJavaVM(), ppiInt32, iRows, iCols, pStVarOne);
681                 }
682                 else
683                 {
684                     EditVar::refreshVariableEditorInteger32(getScilabJavaVM(), ppiInt32, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
685                 }
686             }
687             catch (const GiwsException::JniException & e)
688             {
689                 Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
690             }
691
692             clearWrap<int>(ppiInt32, iRows);
693
694             break;
695
696         case SCI_UINT32 :
697             sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddr, &iRows, &iCols, &piUInt32);
698             if (sciErr.iErr)
699             {
700                 printError(&sciErr, 0);
701                 return -1;
702             }
703
704             ppiUInt32 = wrap<long long int, unsigned int>(piUInt32, iRows, iCols);
705
706             /* Launch Java Variable Editor through JNI */
707             try
708             {
709                 if (nbRowsIndex == 0 || nbColsIndex == 0)
710                 {
711                     EditVar::openVariableEditorUInteger32(getScilabJavaVM(), ppiUInt32, iRows, iCols, pStVarOne);
712                 }
713                 else
714                 {
715                     EditVar::refreshVariableEditorUInteger32(getScilabJavaVM(), ppiUInt32, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
716                 }
717             }
718             catch (const GiwsException::JniException & e)
719             {
720                 Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
721             }
722
723             clearWrap<long long int>(ppiUInt32, iRows);
724
725             break;
726
727         default :
728
729             Scierror(42, _("%s: Type not handle yet"), fname);
730             return 0;
731         }
732
733         break;
734
735     case sci_boolean_sparse :
736         sciErr = getBooleanSparseMatrix(pvApiCtx, piAddr, &iRows, &iCols, &piNbItem, &piNbItemRow, &piColPos);
737         if (sciErr.iErr)
738         {
739             FREE(pStVarOne);
740             printError(&sciErr, 0);
741             return 0;
742         }
743
744         ppiBool = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols);
745
746         /* Launch Java Variable Editor through JNI */
747         try
748         {
749             if (nbRowsIndex == 0 || nbColsIndex == 0)
750             {
751                 EditVar::openVariableEditorBooleanSparse(getScilabJavaVM(), ppiBool, iRows, iCols, pStVarOne);
752             }
753             else
754             {
755                 EditVar::refreshVariableEditorBooleanSparse(getScilabJavaVM(), ppiBool, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
756             }
757         }
758         catch (const GiwsException::JniException & e)
759         {
760             Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
761         }
762
763         clearWrap<int>(ppiBool, iRows);
764         break;
765     case sci_sparse :
766         if (isVarComplex(pvApiCtx, piAddr))
767         {
768             sciErr = getComplexSparseMatrix(pvApiCtx, piAddr, &iRows, &iCols, &piNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg);
769             if (sciErr.iErr)
770             {
771                 FREE(pStVarOne);
772                 printError(&sciErr, 0);
773                 return 0;
774             }
775
776             ppdblRealMatrix = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols, pdblReal);
777             ppdblImgMatrix = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols, pdblImg);
778
779             /* Launch Java Variable Editor through JNI */
780             try
781             {
782                 if (nbRowsIndex == 0 || nbColsIndex == 0)
783                 {
784                     EditVar::openVariableEditorComplexSparse(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, ppdblImgMatrix, iRows, iCols, pStVarOne);
785                 }
786                 else
787                 {
788                     EditVar::refreshVariableEditorComplexSparse(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, ppdblImgMatrix, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
789                 }
790             }
791             catch (const GiwsException::JniException & e)
792             {
793                 Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
794             }
795
796             clearWrap<double>(ppdblRealMatrix, iRows);
797             clearWrap<double>(ppdblImgMatrix, iRows);
798         }
799         else
800         {
801             sciErr = getSparseMatrix(pvApiCtx, piAddr, &iRows, &iCols, &piNbItem, &piNbItemRow, &piColPos, &pdblReal);
802             if (sciErr.iErr)
803             {
804                 FREE(pStVarOne);
805                 printError(&sciErr, 0);
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
833         Scierror(42, _("%s: Type not handle yet"), fname);
834         return 0;
835     }
836
837     FREE(pStVarOne);
838
839     LhsVar(1) = 0;
840     PutLhsVar();
841     return 0;
842 }
843 /*--------------------------------------------------------------------------*/