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 /*--------------------------------------------------------------------------*/