VariableType ScilabJavaEnvironmentWrapper::isunwrappable(int id) const
{
    JavaVM * vm = getScilabJavaVM();
    int type = ScilabJavaObject::isUnwrappable(vm, id);

    return (VariableType)type;
}
Example #2
0
/*
** Register ScilabView to Controller.
** Must be done after Graphics models are created.
*/
void ScilabView::registerToController(void)
{
    org_scilab_modules_graphic_objects::CallGraphicController::registerScilabView(getScilabJavaVM());
    m_figureList.get_allocator().allocate(4096);
    m_handleList.get_allocator().allocate(4096);
    m_uidList.get_allocator().allocate(4096);
}
Example #3
0
/*--------------------------------------------------------------------------*/
BOOL ExecuteInitialHooks(void)
{
    JNIEnv * currentENV = getScilabJNIEnv();
    JavaVM * currentJVM = getScilabJavaVM();

    jint result = (*currentJVM)->AttachCurrentThread(currentJVM, (void **) &currentENV, NULL) ;
    if (result == 0)
    {
        jclass cls = NULL;
        cls = (*currentENV)->FindClass(currentENV, "org/scilab/modules/core/Scilab");
        catchIfJavaException(_("Could not access to the Main Scilab Class:\n"));
        if (cls)
        {
            jmethodID mid = NULL;
            mid = (*currentENV)->GetStaticMethodID(currentENV, cls, "executeInitialHooks", "()V");
            if (mid)
            {
                (*currentENV)->CallStaticVoidMethod(currentENV, cls, mid);
            }
            catchIfJavaException(_("Cannot execute initial hooks. Error:\n"));

            return TRUE;
        }
    }
    return FALSE;
}
Example #4
0
/*--------------------------------------------------------------------------*/
int sci_getlookandfeel(char *fname, void* pvApiCtx)
{
    CheckInputArgument(pvApiCtx, 0, 0);
    CheckOutputArgument(pvApiCtx, 1, 1);

    org_scilab_modules_gui_utils::LookAndFeelManager * lnf = 0;
    try
    {
        lnf = new org_scilab_modules_gui_utils::LookAndFeelManager(getScilabJavaVM());
    }
    catch (const GiwsException::JniException & e)
    {
        Scierror(999, _("%s: A Java exception arisen:\n%s"), fname, e.whatStr().c_str());
        return 1;
    }

    if (lnf)
    {
        static int n1 = 0, m1 = 0;
        char *look = lnf->getCurrentLookAndFeel();

        if (look)
        {
            m1 = (int)strlen(look);
            n1 = 1;

            if (createSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, look))
            {
                Scierror(999, _("%s: Memory allocation error.\n"), fname);
                return 1;
            }

            if (look)
            {
                delete[]look;
                look = NULL;
            }
            delete lnf;

            AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
            ReturnArguments(pvApiCtx);
        }
        else
        {
            delete lnf;
            Scierror(999, _("%s: An error occurred: %s.\n"), fname, _("Impossible to get current look and feel"));
            return 1;
        }
    }
    else
    {
        Scierror(999, _("%s: No more memory.\n"), fname);
        return 1;
    }

    return 0;
}
int ScilabJavaEnvironmentWrapper::wrap(char * x, const bool isRef) const
{
    JavaVM * vm = getScilabJavaVM();
    if (isRef)
    {
        return wrapAsDirectBuffer(vm, x, 1);
    }

    return wrap(vm, (byte *)x);
}
int ScilabJavaEnvironmentWrapper::wrap(double * x, int xSize, int xSizeCol, const bool isRef) const
{
    JavaVM * vm = getScilabJavaVM();
    if (isRef)
    {
        return wrapAsDirectBuffer(vm, x, xSize * xSizeCol);
    }

    return wrap(vm, x, xSize, xSizeCol);
}
int ScilabJavaEnvironmentWrapper::wrapBool(int * x, int xSize, const bool isRef) const
{
    JavaVM * vm = getScilabJavaVM();
    if (isRef)
    {
        return wrapAsDirectBuffer(vm, x, xSize);
    }

    return wrap<int, bool>(vm, x, xSize);
}
int ScilabJavaEnvironmentWrapper::wrap(unsigned long long * x, int xSize, const bool isRef) const
{
    JavaVM * vm = getScilabJavaVM();
    if (isRef)
    {
        return wrapAsDirectBuffer(vm, (long long *)x, xSize);
    }

    return wrap(vm, (long long *)x, xSize);
}
int ScilabJavaEnvironmentWrapper::wrap(unsigned char * x, int xSize, int xSizeCol, const bool isRef) const
{
    JavaVM * vm = getScilabJavaVM();
    if (isRef)
    {
        return wrapAsDirectBuffer(vm, (char *)x, xSize * xSizeCol);
    }

    return wrap(vm, (byte *)x, xSize, xSizeCol);
}
int ScilabJavaEnvironmentWrapper::wrap(unsigned int * x, const bool isRef) const
{
    JavaVM * vm = getScilabJavaVM();
    if (isRef)
    {
        return wrapAsDirectBuffer(vm, (int *)x, 1);
    }

    return wrap(vm, (int *)x);
}
Example #11
0
/*---------------------------------------------------------------------------------*/
char * exportToFile(char * figureUID,
                    const char * fileName,
                    ExportFileType fileType,
                    const float jpegCompressionQuality,
                    ExportOrientation orientation)
{
    return org_scilab_modules_graphic_export::FileExporter::fileExport(getScilabJavaVM(),
            figureUID,
            (char *)fileName,
            fileType,
            jpegCompressionQuality,
            orientation);
}
Example #12
0
/*--------------------------------------------------------------------------*/
int sci_xinit(char * fname, void *pvApiCtx)
{
    SciErr err;
    int * addr = 0;
    char * path = 0;
    char * realPath = 0;

    CheckInputArgument(pvApiCtx, 1, 1);

    err = getVarAddressFromPosition(pvApiCtx, 1, &addr);
    if (err.iErr)
    {
        printError(&err, 0);
        Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
        return 0;
    }

    if (!isStringType(pvApiCtx, addr) || !checkVarDimension(pvApiCtx, addr, 1, 1))
    {
        Scierror(999, gettext("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1);
        return 0;
    }

    if (getAllocatedSingleString(pvApiCtx, addr, &path) != 0)
    {
        Scierror(999, _("%s: No more memory.\n"), fname);
        return 0;
    }

    realPath = expandPathVariable(path);

    if (realPath)
    {
        org_scilab_modules_graphic_export::Driver::setPath(getScilabJavaVM(), realPath);
        FREE(realPath);
    }
    else
    {
        Scierror(999, _("%s: Invalid path: %s.\n"), fname, path);
        return 0;
    }

    freeAllocatedSingleString(path);

    LhsVar(1) = 0;
    PutLhsVar();

    return 0;
}
void ScilabJavaEnvironmentWrapper::unwrapstring(int id, const ScilabStringStackAllocator & allocator) const
{
    JNIEnv * curEnv = NULL;
    JavaVM * vm = getScilabJavaVM();
    vm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);

    jstring res = static_cast<jstring>(curEnv->CallStaticObjectMethod(ScilabJavaObjectClass_, unwrapStringID_ , id));
    char * addr = const_cast<char *>(curEnv->GetStringUTFChars(res, 0));

    allocator.allocate(1, 1, &addr);

    curEnv->ReleaseStringUTFChars(res, addr);
    curEnv->DeleteLocalRef(res);
    if (curEnv->ExceptionCheck())
    {
        throw GiwsException::JniCallMethodException(curEnv);
    }
}
void ScilabJavaEnvironmentWrapper::unwraprowstring(int id, const ScilabStringStackAllocator & allocator) const
{
    JNIEnv * curEnv = NULL;
    JavaVM * vm = getScilabJavaVM();
    vm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);

    jobjectArray res = static_cast<jobjectArray>(curEnv->CallStaticObjectMethod(ScilabJavaObjectClass_, unwrapRowStringID_ , id));
    if (curEnv->ExceptionCheck())
    {
        throw GiwsException::JniCallMethodException(curEnv);
    }

    jint lenRow = curEnv->GetArrayLength(res);
    jboolean isCopy = JNI_FALSE;
    char ** addr = new char*[lenRow];
    jstring * resString = new jstring[lenRow];

    for (jsize i = 0; i < lenRow; i++)
    {
        resString[i] = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
        addr[i] = const_cast<char *>(curEnv->GetStringUTFChars(resString[i], &isCopy));
    }

    allocator.allocate(1, lenRow, addr);

    for (jsize i = 0; i < lenRow; i++)
    {
        curEnv->ReleaseStringUTFChars(resString[i], addr[i]);
        curEnv->DeleteLocalRef(resString[i]);
    }
    delete[] addr;
    delete[] resString;

    curEnv->DeleteLocalRef(res);
    if (curEnv->ExceptionCheck())
    {
        throw GiwsException::JniCallMethodException(curEnv);
    }
}
Example #15
0
/*--------------------------------------------------------------------------*/
types::Function::ReturnValue sci_notify(types::typed_list &in, int _iRetCount, types::typed_list &out)
{
    types::String* pString  = NULL;
    wchar_t* wcsInput       = NULL;

    if (in.size() != 1)
    {
        Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), "notify" , 1);
        return types::Function::Error;
    }
    if (in[0]->isString() == false)
    {
        Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), "notify", 1);
        return types::Function::Error;
    }
    pString = in[0]->getAs<types::String>();

    if (pString->isScalar() == FALSE)
    {
        Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), "notify" , 1);
        return types::Function::Error;
    }
    wcsInput = pString->get(0);

    char* strInput = wide_string_to_UTF8(wcsInput);
    try
    {
        org_scilab_modules_action_binding_utils::Signal::notify(getScilabJavaVM(), strInput);
    }
    catch (const GiwsException::JniException & e)
    {
        Scierror(999, _("%s: A Java exception arisen:\n%s"), "notify", e.whatStr().c_str());
        FREE(strInput);
        return types::Function::Error;
    }
    FREE(strInput);

    return types::Function::OK;
}
void ScilabJavaEnvironmentWrapper::unwrapmatshort(int id, const ScilabShortStackAllocator & allocator) const
{
    JavaVM * vm = getScilabJavaVM();
    unwrapMat<jshort, short>(vm, id, allocator);
}
int ScilabJavaEnvironmentWrapper::wrap(char ** x, int xSize, int xSizeCol, const bool isRef) const
{
    JavaVM * vm = getScilabJavaVM();
    return wrap(vm, (char const**)x, xSize, xSizeCol);
}
Example #18
0
    /*--------------------------------------------------------------------------*/
    int sci_buildDoc(char *fname, void* pvApiCtx)
    {
        std::string exportFormat;
        std::string SciPath = getSCI(); /* Scilab path */
        std::string masterXML; /* Which file contains all the doc stuff */
        std::string masterXMLTMP;
        std::string outputDirectory;    /* Working directory */
        std::string outputDirectoryTMP;
        std::string language;
        std::string styleSheet; /* the CSS */
        char * fileToExec = NULL;
        SciErr sciErr;
        int *piAddr = NULL;
        int iRet = 0;

        CheckRhs(0, 4);
        CheckLhs(1, 1);

        styleSheet = SciPath + PATHTOCSS;

        if (Rhs < 1)
        {
            exportFormat = DEFAULTEXPORT;
        }
        else
        {
            char* pstData = NULL;
            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);

            if (sciErr.iErr)
            {
                printError(&sciErr, 0);
                Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
                return 0;
            }

            if (!isStringType(pvApiCtx, piAddr))
            {
                Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1);
                return 0;
                // Wrong type string
            }

            iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
            if (iRet)
            {
                freeAllocatedSingleString(pstData);
                return iRet;
            }
            exportFormat = std::string(pstData);
            freeAllocatedSingleString(pstData);


        }

        if (Rhs < 3)            /* Language not provided */
        {
            wchar_t* l = getlanguage();
            language = wide_string_to_UTF8(l);
            free(l);
        }
        else
        {
            char* pstData = NULL;
            sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr);

            if (sciErr.iErr)
            {
                printError(&sciErr, 0);
                Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
                return 0;
            }

            if (!isStringType(pvApiCtx, piAddr))
            {
                Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 3);
                return 0;
                // Wrong type string
            }

            if (!isScalar(pvApiCtx, piAddr))
            {
                wchar_t* pwstLang = getlanguage();
                language = wide_string_to_UTF8(pwstLang);
                free(pwstLang);
            }
            else
            {
                iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
                if (iRet)
                {
                    freeAllocatedSingleString(pstData);
                    return iRet;
                }
                language = std::string(pstData);
                freeAllocatedSingleString(pstData);

            }

        }

        if (Rhs < 2)
        {
            /* Update the path with the localization */
            masterXMLTMP = std::string("/modules/helptools/master_") + language + std::string("_help.xml");
            masterXML = SciPath + masterXMLTMP;
        }
        else
        {
            char* pstData = NULL;
            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);

            if (sciErr.iErr)
            {
                printError(&sciErr, 0);
                Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
                return 0;
            }
            if (!isStringType(pvApiCtx, piAddr))
            {
                Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 2);
                return 0;
                // Wrong type string
            }


            iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
            if (iRet)
            {
                freeAllocatedSingleString(pstData);
                return iRet;
            }
            masterXML = std::string(pstData);
            freeAllocatedSingleString(pstData);
        }

        if (Rhs == 4)
        {
            char* pstData = NULL;
            sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr);

            if (sciErr.iErr)
            {
                printError(&sciErr, 0);
                Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
                return 0;
            }
            if (!isStringType(pvApiCtx, piAddr))
            {
                Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 4);
                return 0;
                // Wrong type string
            }

            iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
            if (iRet)
            {
                freeAllocatedSingleString(pstData);
                return iRet;
            }
            outputDirectory = std::string(pstData) + std::string("/scilab_") + language + std::string("_help/");
            freeAllocatedSingleString(pstData);

        }
        else                    /* Scilab help */
        {
            /* Update the path with the localization */
            if (exportFormat != "jar-only")
            {
                outputDirectoryTMP =
                    std::string("/modules/helptools/") + std::string(exportFormat) + std::string("/scilab_") + language + std::string("_help/");
            }
            else
            {
                outputDirectoryTMP =
                    std::string("/modules/helptools/") + std::string("javaHelp") + std::string("/scilab_") + language + std::string("_help/");
            }

            outputDirectory = SciPath + outputDirectoryTMP;
        }

#ifdef _MSC_VER
        __slashToAntislash(&outputDirectory);
        __slashToAntislash(&styleSheet);
        __slashToAntislash(&masterXML);
#endif

        try
        {
            org_scilab_modules_helptools::SciDocMain * doc = new org_scilab_modules_helptools::SciDocMain(getScilabJavaVM());

            if (doc->setOutputDirectory((char *)outputDirectory.c_str()))
            {
                doc->setWorkingLanguage((char *)language.c_str());
                doc->setExportFormat((char *)exportFormat.c_str());
                doc->setIsToolbox(Rhs == 4);
                fileToExec = doc->process((char *)masterXML.c_str(), (char *)styleSheet.c_str());
            }
            else
            {
                Scierror(999, _("%s: Could find or create the working directory %s.\n"), fname, outputDirectory.c_str());
                return FALSE;
            }
            if (doc != NULL)
            {
                delete doc;
            }
        }
        catch (GiwsException::JniException ex)
        {
            Scierror(999, _("%s: Error while building documentation: %s.\n"), fname, ex.getJavaDescription().c_str());
            Scierror(999, _("%s: Execution Java stack: %s.\n"), fname, ex.getJavaStackTrace().c_str());
            Scierror(999,
                     _
                     ("If Scilab is started in a chroot, you might want to try to set the two environment variables: SCI_DISABLE_TK=1 SCI_JAVA_ENABLE_HEADLESS=1\n"));
            return FALSE;
        }

        if (fileToExec)
        {
            createMatrixOfString(pvApiCtx, Rhs + 1, 1, 1, &fileToExec);
            delete [] fileToExec;
        }
        else
        {
            createEmptyMatrix(pvApiCtx, Rhs + 1);
        }

        LhsVar(1) = Rhs + 1;
        PutLhsVar();

        return 0;
    }
int ScilabJavaEnvironmentWrapper::wrapFloat(double * x, int xSize, int xSizeCol, const bool isRef) const
{
    JavaVM * vm = getScilabJavaVM();
    return wrap<double, float>(vm, x, xSize, xSizeCol);
}
void ScilabJavaEnvironmentWrapper::unwrapmatfloat(int id, const ScilabFloatStackAllocator & allocator) const
{
    JavaVM * vm = getScilabJavaVM();
    unwrapMat<jfloat, double, float>(vm, id, allocator);
}
void ScilabJavaEnvironmentWrapper::unwrapmatstring(int id, const ScilabStringStackAllocator & allocator) const
{
    JNIEnv * curEnv = NULL;
    JavaVM * vm = getScilabJavaVM();
    vm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);

    jobjectArray res = static_cast<jobjectArray>(curEnv->CallStaticObjectMethod(ScilabJavaObjectClass_, unwrapMatStringID_, id));
    if (curEnv->ExceptionCheck())
    {
        throw GiwsException::JniCallMethodException(curEnv);
    }
    jint lenRow = curEnv->GetArrayLength(res);
    jboolean isCopy = JNI_FALSE;

    jobjectArray oneDim = reinterpret_cast<jobjectArray>(curEnv->GetObjectArrayElement(res, 0));
    jint lenCol = curEnv->GetArrayLength(oneDim);
    char ** addr = new char*[lenRow * lenCol];
    jstring * resString = new jstring[lenRow * lenCol];

    for (int i = 0; i < lenRow; i++)
    {
        oneDim = reinterpret_cast<jobjectArray>(curEnv->GetObjectArrayElement(res, i));
        if (helper.getMethodOfConv())
        {
            for (int j = 0; j < lenCol; j++)
            {
                resString[j * lenRow + i] = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(oneDim, j));
                addr[j * lenRow + i] = const_cast<char *>(curEnv->GetStringUTFChars(resString[j * lenRow + i], &isCopy));
            }
        }
        else
        {
            for (int j = 0; j < lenCol; j++)
            {
                resString[i * lenCol + j] = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(oneDim, j));
                addr[i * lenCol + j] = const_cast<char *>(curEnv->GetStringUTFChars(resString[i * lenCol + j], &isCopy));
            }
        }
        curEnv->DeleteLocalRef(oneDim);
    }

    if (helper.getMethodOfConv())
    {
        allocator.allocate(lenRow, lenCol, addr);
    }
    else
    {
        allocator.allocate(lenCol, lenRow, addr);
    }

    for (int i = 0; i < lenRow * lenCol; i++)
    {
        curEnv->ReleaseStringUTFChars(resString[i], addr[i]);
        curEnv->DeleteLocalRef(resString[i]);
    }
    delete[] addr;
    delete[] resString;

    curEnv->DeleteLocalRef(res);
    if (curEnv->ExceptionCheck())
    {
        throw GiwsException::JniCallMethodException(curEnv);
    }
}
void ScilabJavaEnvironmentWrapper::unwrapmatboolean(int id, const ScilabBooleanStackAllocator & allocator) const
{
    JavaVM * vm = getScilabJavaVM();
    unwrapMat<jboolean, int, bool>(vm, id, allocator);
}
void ScilabJavaEnvironmentWrapper::unwrapmatdouble(int id, const ScilabDoubleStackAllocator & allocator) const
{
    JavaVM * vm = getScilabJavaVM();
    unwrapMat<jdouble, double>(vm, id, allocator);
}
void ScilabJavaEnvironmentWrapper::unwrapmatchar(int id, const ScilabCharStackAllocator & allocator) const
{
    JavaVM * vm = getScilabJavaVM();
    unwrapMat<jbyte, char>(vm, id, allocator);
}
Example #25
0
    /*--------------------------------------------------------------------------*/
    int sci_setlookandfeel(char *fname, unsigned long fname_len)
    {
        CheckRhs(0, 1);
        CheckLhs(0, 1);

        org_scilab_modules_gui_utils::LookAndFeelManager * lnf = 0;

        if (Rhs == 0)
        {
            try
            {
                lnf = new org_scilab_modules_gui_utils::LookAndFeelManager(getScilabJavaVM());
            }
            catch (const GiwsException::JniException & e)
            {
                Scierror(999, _("%s: A Java exception arisen:\n%s"), fname, e.whatStr().c_str());
                return FALSE;
            }

            if (lnf)
            {
                int n1 = 1;
                int *paramoutINT = (int *)MALLOC(sizeof(int));

                *paramoutINT = (int)booltoBOOL(lnf->setSystemLookAndFeel());
                delete lnf;

                n1 = 1;
                CreateVarFromPtr(Rhs + 1,
                                 const_cast<char *>(MATRIX_OF_BOOLEAN_DATATYPE),
                                 &n1, &n1, &paramoutINT);
                LhsVar(1) = Rhs + 1;

                if (paramoutINT)
                {
                    FREE(paramoutINT);
                    paramoutINT = NULL;
                }
                PutLhsVar();
            }
            else
            {
                Scierror(999, _("%s: No more memory.\n"), fname);
            }
        }
        else if (GetType(1) == sci_strings)
        {
            int m1, n1 = 0, l1 = 0;

            char *looknfeel = NULL;

            GetRhsVar(1, const_cast<char *>(STRING_DATATYPE), &m1, &n1, &l1);
            looknfeel = cstk(l1);

            try
            {
                lnf = new org_scilab_modules_gui_utils::LookAndFeelManager(getScilabJavaVM());
            }
            catch (const GiwsException::JniException & e)
            {
                Scierror(999, _("%s: A Java exception arisen:\n%s"), fname, e.whatStr().c_str());
                return FALSE;
            }

            if (lnf)
            {
                int *paramoutINT = (int *)MALLOC(sizeof(int));

                *paramoutINT = (int)booltoBOOL(lnf->setLookAndFeel(looknfeel));
                delete lnf;

                n1 = 1;
                CreateVarFromPtr(Rhs + 1,
                                 const_cast<char *>(MATRIX_OF_BOOLEAN_DATATYPE),
                                 &n1, &n1, &paramoutINT);
                LhsVar(1) = Rhs + 1;

                if (paramoutINT)
                {
                    FREE(paramoutINT);
                    paramoutINT = NULL;
                }
                PutLhsVar();
            }
            else
            {
                Scierror(999, _("%s: No more memory.\n"), fname);
            }
        }
        else
        {
            Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
        }
        return 0;
    }
Example #26
0
/*
** Reove ScilabView from Controller.
*/
void ScilabView::unregisterToController(void)
{
    org_scilab_modules_graphic_objects::CallGraphicController::unregisterScilabView(getScilabJavaVM());
}
void ScilabJavaEnvironmentWrapper::unwrapmatint(int id, const ScilabIntStackAllocator & allocator) const
{
    JavaVM * vm = getScilabJavaVM();
    unwrapMat<jint, int>(vm, id, allocator);
}
    /*--------------------------------------------------------------------------*/
    int sci_getinstalledlookandfeels(char *fname, unsigned long fname_len)
    {
        SciErr sciErr;
        CheckInputArgument(pvApiCtx, 0, 0);
        CheckOutputArgument(pvApiCtx, 1, 1);

        org_scilab_modules_gui_utils::LookAndFeelManager * lnf = 0;
        try
        {
            lnf = new org_scilab_modules_gui_utils::LookAndFeelManager(getScilabJavaVM());
        }
        catch (const GiwsException::JniException & e)
        {
            Scierror(999, _("%s: A Java exception arisen:\n%s"), fname, e.whatStr().c_str());
            return 1;
        }

        if (lnf)
        {
            char **lookandfeels = NULL;
            int nbElems = 0;
            int nbCol = 0;

            lookandfeels = lnf->getInstalledLookAndFeels();
            nbElems = lnf->numbersOfInstalledLookAndFeels();

            nbCol = 1;

            sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbElems, nbCol, lookandfeels);
            if (sciErr.iErr)
            {
                printError(&sciErr, 0);
                Scierror(999, _("%s: Memory allocation error.\n"), fname);
                return 1;
            }

            if (lookandfeels)
            {
                int i = 0;

                for (i = 0; i < nbElems; i++)
                {
                    if (lookandfeels[i])
                    {
                        delete[]lookandfeels[i];
                    }
                }
                delete[]lookandfeels;
                lookandfeels = NULL;
            }
            delete lnf;

            AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
            returnArguments(pvApiCtx);
        }
        else
        {
            Scierror(999, _("%s: No more memory.\n"), fname);
        }
        return 0;
    }
void ScilabJavaEnvironmentWrapper::unwrapmatlong(int id, const ScilabLongStackAllocator & allocator) const
{
    JavaVM * vm = getScilabJavaVM();
    unwrapMat<jlong, int, long long>(vm, id, allocator);
}