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

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