scilab/modules/ui_data/sci_gateway/cpp/sci_editvar.cpp

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