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         FREE(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         FREE(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         FREE(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             FREE(pStVarOne);
 254             return 0;
 255         }
 256     }
 257     else
 258     {
 259         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
 260         if (sciErr.iErr)
 261         {
 262             FREE(pStVarOne);
 263             printError(&sciErr, 0);
 264             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
 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             FREE(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             FREE(pStVarOne);
 284             return 0;
 285         }
 286
 287         sciErr = getMatrixOfDouble(pvApiCtx, addr, &iRows, &iCols, &rowsIndex);
 288         if (sciErr.iErr)
 289         {
 290             FREE(pStVarOne);
 291             printError(&sciErr, 0);
 292             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
 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             FREE(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             FREE(pStVarOne);
 311             return 0;
 312         }
 313
 314         sciErr = getMatrixOfDouble(pvApiCtx, addr, &iRows, &iCols, &colsIndex);
 315         if (sciErr.iErr)
 316         {
 317             FREE(pStVarOne);
 318             printError(&sciErr, 0);
 319             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
 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         FREE(pStVarOne);
 333         printError(&sciErr, 0);
 334         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 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                     FREE(pStVarOne);
 353                     printError(&sciErr, 0);
 354                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 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                     FREE(pStVarOne);
 407                     printError(&sciErr, 0);
 408                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 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                 FREE(pStVarOne);
 444                 printError(&sciErr, 0);
 445                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 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                 FREE(pStVarOne);
 484                 printError(&sciErr, 0);
 485                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 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                 FREE(pStVarOne);
 523                 printError(&sciErr, 0);
 524                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 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                         return -1;
 537                     }
 538
 539                     ppiInt8 = wrap<char, char>(piInt8, iRows, iCols);
 540
 541                     /* Launch Java Variable Editor through JNI */
 542                     try
 543                     {
 544                         if (nbRowsIndex == 0 || nbColsIndex == 0)
 545                         {
 546                             EditVar::openVariableEditorInteger8(getScilabJavaVM(), reinterpret_cast<byte**>(ppiInt8), iRows, iCols, pStVarOne);
 547                         }
 548                         else
 549                         {
 550                             EditVar::refreshVariableEditorInteger8(getScilabJavaVM(), reinterpret_cast<byte**>(ppiInt8), iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
 551                         }
 552                     }
 553                     catch (const GiwsException::JniException & e)
 554                     {
 555                         Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
 556                     }
 557
 558                     clearWrap<char>(ppiInt8, iRows);
 559
 560                     break;
 561
 562                 case SCI_UINT8 :
 563                     sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddr, &iRows, &iCols, &piUInt8);
 564                     if (sciErr.iErr)
 565                     {
 566                         printError(&sciErr, 0);
 567                         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 568                         return -1;
 569                     }
 570
 571                     ppiUInt8 = wrap<short, unsigned char>(piUInt8, iRows, iCols);
 572
 573                     /* Launch Java Variable Editor through JNI */
 574                     try
 575                     {
 576                         if (nbRowsIndex == 0 || nbColsIndex == 0)
 577                         {
 578                             EditVar::openVariableEditorUInteger8(getScilabJavaVM(), ppiUInt8, iRows, iCols, pStVarOne);
 579                         }
 580                         else
 581                         {
 582                             EditVar::refreshVariableEditorUInteger8(getScilabJavaVM(), ppiUInt8, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
 583                         }
 584                     }
 585                     catch (const GiwsException::JniException & e)
 586                     {
 587                         Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
 588                     }
 589
 590                     clearWrap<short>(ppiUInt8, iRows);
 591
 592                     break;
 593
 594                 case SCI_INT16 :
 595                     sciErr = getMatrixOfInteger16(pvApiCtx, piAddr, &iRows, &iCols, &piInt16);
 596                     if (sciErr.iErr)
 597                     {
 598                         printError(&sciErr, 0);
 599                         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 600                         return -1;
 601                     }
 602
 603                     ppiInt16 = wrap<short, short>(piInt16, iRows, iCols);
 604
 605                     /* Launch Java Variable Editor through JNI */
 606                     try
 607                     {
 608                         if (nbRowsIndex == 0 || nbColsIndex == 0)
 609                         {
 610                             EditVar::openVariableEditorInteger16(getScilabJavaVM(), ppiInt16, iRows, iCols, pStVarOne);
 611                         }
 612                         else
 613                         {
 614                             EditVar::refreshVariableEditorInteger16(getScilabJavaVM(), ppiInt16, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
 615                         }
 616                     }
 617                     catch (const GiwsException::JniException & e)
 618                     {
 619                         Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
 620                     }
 621
 622                     clearWrap<short>(ppiInt16, iRows);
 623
 624                     break;
 625
 626                 case SCI_UINT16 :
 627                     sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddr, &iRows, &iCols, &piUInt16);
 628                     if (sciErr.iErr)
 629                     {
 630                         printError(&sciErr, 0);
 631                         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 632                         return -1;
 633                     }
 634
 635                     ppiUInt16 = wrap<int, unsigned short>(piUInt16, iRows, iCols);
 636
 637                     /* Launch Java Variable Editor through JNI */
 638                     try
 639                     {
 640                         if (nbRowsIndex == 0 || nbColsIndex == 0)
 641                         {
 642                             EditVar::openVariableEditorUInteger16(getScilabJavaVM(), ppiUInt16, iRows, iCols, pStVarOne);
 643                         }
 644                         else
 645                         {
 646                             EditVar::refreshVariableEditorUInteger16(getScilabJavaVM(), ppiUInt16, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
 647                         }
 648                     }
 649                     catch (const GiwsException::JniException & e)
 650                     {
 651                         Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
 652                     }
 653
 654                     clearWrap<int>(ppiUInt16, iRows);
 655
 656                     break;
 657
 658                 case SCI_INT32 :
 659                     sciErr = getMatrixOfInteger32(pvApiCtx, piAddr, &iRows, &iCols, &piInt32);
 660                     if (sciErr.iErr)
 661                     {
 662                         printError(&sciErr, 0);
 663                         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 664                         return -1;
 665                     }
 666
 667                     ppiInt32 = wrap<int>(piInt32, iRows, iCols);
 668
 669                     /* Launch Java Variable Editor through JNI */
 670                     try
 671                     {
 672                         if (nbRowsIndex == 0 || nbColsIndex == 0)
 673                         {
 674                             EditVar::openVariableEditorInteger32(getScilabJavaVM(), ppiInt32, iRows, iCols, pStVarOne);
 675                         }
 676                         else
 677                         {
 678                             EditVar::refreshVariableEditorInteger32(getScilabJavaVM(), ppiInt32, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
 679                         }
 680                     }
 681                     catch (const GiwsException::JniException & e)
 682                     {
 683                         Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
 684                     }
 685
 686                     clearWrap<int>(ppiInt32, iRows);
 687
 688                     break;
 689
 690                 case SCI_UINT32 :
 691                     sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddr, &iRows, &iCols, &piUInt32);
 692                     if (sciErr.iErr)
 693                     {
 694                         printError(&sciErr, 0);
 695                         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 696                         return -1;
 697                     }
 698
 699                     ppiUInt32 = wrap<long long int, unsigned int>(piUInt32, iRows, iCols);
 700
 701                     /* Launch Java Variable Editor through JNI */
 702                     try
 703                     {
 704                         if (nbRowsIndex == 0 || nbColsIndex == 0)
 705                         {
 706                             EditVar::openVariableEditorUInteger32(getScilabJavaVM(), ppiUInt32, iRows, iCols, pStVarOne);
 707                         }
 708                         else
 709                         {
 710                             EditVar::refreshVariableEditorUInteger32(getScilabJavaVM(), ppiUInt32, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
 711                         }
 712                     }
 713                     catch (const GiwsException::JniException & e)
 714                     {
 715                         Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
 716                     }
 717
 718                     clearWrap<long long int>(ppiUInt32, iRows);
 719
 720                     break;
 721
 722                 default :
 723
 724                     Scierror(42, _("%s: Type not handle yet"), fname);
 725                     return 0;
 726             }
 727
 728             break;
 729
 730         case sci_boolean_sparse :
 731             sciErr = getBooleanSparseMatrix(pvApiCtx, piAddr, &iRows, &iCols, &piNbItem, &piNbItemRow, &piColPos);
 732             if (sciErr.iErr)
 733             {
 734                 FREE(pStVarOne);
 735                 printError(&sciErr, 0);
 736                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 737                 return 0;
 738             }
 739
 740             ppiBool = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols);
 741
 742             /* Launch Java Variable Editor through JNI */
 743             try
 744             {
 745                 if (nbRowsIndex == 0 || nbColsIndex == 0)
 746                 {
 747                     EditVar::openVariableEditorBooleanSparse(getScilabJavaVM(), ppiBool, iRows, iCols, pStVarOne);
 748                 }
 749                 else
 750                 {
 751                     EditVar::refreshVariableEditorBooleanSparse(getScilabJavaVM(), ppiBool, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
 752                 }
 753             }
 754             catch (const GiwsException::JniException & e)
 755             {
 756                 Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
 757             }
 758
 759             clearWrap<int>(ppiBool, iRows);
 760             break;
 761         case sci_sparse :
 762             if (isVarComplex(pvApiCtx, piAddr))
 763             {
 764                 sciErr = getComplexSparseMatrix(pvApiCtx, piAddr, &iRows, &iCols, &piNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg);
 765                 if (sciErr.iErr)
 766                 {
 767                     FREE(pStVarOne);
 768                     printError(&sciErr, 0);
 769                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 770                     return 0;
 771                 }
 772
 773                 ppdblRealMatrix = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols, pdblReal);
 774                 ppdblImgMatrix = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols, pdblImg);
 775
 776                 /* Launch Java Variable Editor through JNI */
 777                 try
 778                 {
 779                     if (nbRowsIndex == 0 || nbColsIndex == 0)
 780                     {
 781                         EditVar::openVariableEditorComplexSparse(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, ppdblImgMatrix, iRows, iCols, pStVarOne);
 782                     }
 783                     else
 784                     {
 785                         EditVar::refreshVariableEditorComplexSparse(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, ppdblImgMatrix, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
 786                     }
 787                 }
 788                 catch (const GiwsException::JniException & e)
 789                 {
 790                     Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
 791                 }
 792
 793                 clearWrap<double>(ppdblRealMatrix, iRows);
 794                 clearWrap<double>(ppdblImgMatrix, iRows);
 795             }
 796             else
 797             {
 798                 sciErr = getSparseMatrix(pvApiCtx, piAddr, &iRows, &iCols, &piNbItem, &piNbItemRow, &piColPos, &pdblReal);
 799                 if (sciErr.iErr)
 800                 {
 801                     FREE(pStVarOne);
 802                     printError(&sciErr, 0);
 803                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 804                     return 0;
 805                 }
 806
 807                 ppdblRealMatrix = wrapSparse(piNbItem, piNbItemRow, piColPos, iRows, iCols, pdblReal);
 808
 809                 /* Launch Java Variable Editor through JNI */
 810                 try
 811                 {
 812                     if (nbRowsIndex == 0 || nbColsIndex == 0)
 813                     {
 814                         EditVar::openVariableEditorSparse(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, pStVarOne);
 815                     }
 816                     else
 817                     {
 818                         EditVar::refreshVariableEditorSparse(getScilabJavaVM(), ppdblRealMatrix, iRows, iCols, rowsIndex, nbRowsIndex, colsIndex, nbColsIndex, pStVarOne);
 819                     }
 820                 }
 821                 catch (const GiwsException::JniException & e)
 822                 {
 823                     Scierror(999, _("%s: Java exception arisen:\n%s\n"), fname, e.what());
 824                 }
 825
 826                 clearWrap<double>(ppdblRealMatrix, iRows);
 827             }
 828             break;
 829         default:
 830
 831             Scierror(42, _("%s: Type not handle yet"), fname);
 832             return 0;
 833     }
 834
 835     FREE(pStVarOne);
 836
 837     LhsVar(1) = 0;
 838     PutLhsVar();
 839     return 0;
 840 }
 841 /*--------------------------------------------------------------------------*/