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