void loadTextRenderingAPI(char const* const* text, int nbRow, int nbCol)
{
int i = 0;
/* We already loaded both, don't need to check again */
if (loadedDepLatex && loadedDepMathML)
{
return;
}
/* For each element in the array, look if the text starts by:
* '$' for latex
* '<' for MathML
*/
for (i = 0 ; i < nbRow * nbCol ; i++)
{
if (text[i][0] == '$' && !loadedDepLatex) /* One of the string starts by a $. This might be a Latex expression */
{
loadOnUseClassPath("graphics_latex_textrendering");
loadedDepLatex = TRUE;
}
if (text[i][0] == '<' && !loadedDepMathML) /* One of the string starts by a <. This might be a MathML expression */
{
loadOnUseClassPath("graphics_mathml_textrendering");
loadedDepMathML = TRUE;
}
}
}
/*--------------------------------------------------------------------------*/
int gw_xcos(void)
{
Rhs = Max(0, Rhs);
if (getScilabMode() == SCILAB_NWNI)
{
Scierror(999, _("Scilab '%s' module disabled in -nogui or -nwni mode.\n"), "xcos");
return 0;
}
if (!loadedDep // never reload
&& Tab[Fin - 1].f != sci_closeXcosFromScilab) // do not load on close
{
loadOnUseClassPath("Xcos");
loadedDep = TRUE;
}
if (pvApiCtx == NULL)
{
pvApiCtx = (StrCtx*)MALLOC(sizeof(StrCtx));
}
pvApiCtx->pstName = (char*)Tab[Fin - 1].name;
callFunctionFromGateway(Tab, SIZE_CURRENT_GENERIC_TABLE(Tab));
return 0;
}
int GraphicsModule::LoadDeps(const std::wstring& /*_functionName*/)
{
if (loadedDep == false)
{
loadOnUseClassPath("graphics");
loadedDep = true;
}
return 1;
}
int XcosModule::LoadDeps(const std::wstring& _functionName)
{
if (loadedDep == false && _functionName != L"closeXcos")
{
loadOnUseClassPath("Xcos");
loadedDep = true;
}
return 1;
};
int HelptoolsModule::LoadDeps(const std::wstring& /*_functionName*/)
{
if (loadedDep == false)
{
loadOnUseClassPath("documentationGeneration");
loadedDep = true;
}
return 1;
}
int ScinotesModule::LoadDeps(const std::wstring& /*_functionName*/)
{
if (loadedDep == false)
{
loadOnUseClassPath("SciNotes");
loadedDep = true;
}
return 1;
}
int GuiModule::LoadDeps(const std::wstring& _functionName)
{
if (loadedDep == false &&
(_functionName == L"uicontrol" ||
_functionName == L"uimenu" ||
_functionName == L"usecanvas" ||
_functionName == L"loadGui" ||
_functionName == L"figure"))
{
loadOnUseClassPath("graphics");
loadedDep = true;
}
return 1;
}
/* interface for the previous function Table */
int gw_graphics(void)
{
nbInputArgument(pvApiCtx) = Max(0, nbInputArgument(pvApiCtx));
if (pvApiCtx == NULL)
{
pvApiCtx = (StrCtx*)MALLOC(sizeof(StrCtx));
}
pvApiCtx->pstName = (char*)Tab[Fin - 1].name;
if (getScilabMode() != SCILAB_NWNI)
{
if (!loadedDep)
{
loadOnUseClassPath("graphics");
loadedDep = TRUE;
}
callFunctionFromGateway(Tab, SIZE_CURRENT_GENERIC_TABLE(Tab));
}
else
{
if ((strcmp(Tab[Fin - 1].name, "set") == 0 ||
strcmp(Tab[Fin - 1].name, "delete") == 0 ||
strcmp(Tab[Fin - 1].name, "get") == 0) &&
(getInputArgumentType(pvApiCtx, 1) == sci_tlist || getInputArgumentType(pvApiCtx, 1) == sci_mlist))
{
callFunctionFromGateway(Tab, SIZE_CURRENT_GENERIC_TABLE(Tab));
return 0;
}
else
{
Scierror(999, _("Scilab '%s' module disabled in -nogui or -nwni mode.\n"), "graphics");
}
}
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_helpbrowser(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int* piAddrhelpAdr = NULL;
int* piAddrkeywordAdr = NULL;
int* piAddrfullTextAdr = NULL;
int* fullTextAdr = NULL;
int nbRow = 0;
int nbCol = 0;
char** keywordAdr = NULL;
int nbRowHelp = 0;
int nbColHelp = 0;
char** helpAdr = NULL;
char** languageAdr = NULL;
int ret = 1;
CheckInputArgument(pvApiCtx, 2, 4);
CheckOutputArgument(pvApiCtx, 0, 1);
/* We load SciNotes when calling javahelp because we have no way to know
* to load it when using Javahelp because it can call SciNotes directly */
if (!loadedDep)
{
loadOnUseClassPath("SciNotes");
loadedDep = TRUE;
}
if (checkInputArgumentType(pvApiCtx, 1, sci_strings))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrhelpAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 1.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrhelpAdr, &nbRowHelp, &nbColHelp, &helpAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1);
return 1;
}
}
else if (checkInputArgumentType(pvApiCtx, 1, sci_matrix))
{
helpAdr = NULL; /* No toolboxes installed */
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), fname, 1);
return FALSE;
}
if (nbInputArgument(pvApiCtx) == 2)
{
if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
{
int* piAddrlanguageAdr = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrlanguageAdr);
if (sciErr.iErr)
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 2.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrlanguageAdr, &nbRow, &nbCol, &languageAdr))
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
return 1;
}
if (nbRow*nbCol != 1)
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedMatrixOfString(nbRow, nbCol, languageAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
return FALSE;
}
}
else
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
return FALSE;
}
ret = launchHelpBrowser(helpAdr, nbRowHelp * nbColHelp, languageAdr[0]);
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedMatrixOfString(nbRow, nbCol, languageAdr);
}
else if (nbInputArgument(pvApiCtx) == 4)
{
if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrkeywordAdr);
if (sciErr.iErr)
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 2.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrkeywordAdr, &nbRow, &nbCol, &keywordAdr))
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
return 1;
}
if (nbRow*nbCol != 1)
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedMatrixOfString(nbRow, nbCol, keywordAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
return FALSE;
}
}
else
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
return FALSE;
}
if ((checkInputArgumentType(pvApiCtx, 3, sci_strings)))
{
int* piAddrlanguageAdr = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrlanguageAdr);
if (sciErr.iErr)
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedSingleString(*keywordAdr);
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 3.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrlanguageAdr, &nbRow, &nbCol, &languageAdr))
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedSingleString(*keywordAdr);
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3);
return 1;
}
if (nbRow*nbCol != 1)
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedSingleString(*keywordAdr);
freeAllocatedMatrixOfString(nbRow, nbCol, languageAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 3);
return FALSE;
}
}
else
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedSingleString(*keywordAdr);
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 3);
return FALSE;
}
if ((checkInputArgumentType(pvApiCtx, 4, sci_boolean)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrfullTextAdr);
if (sciErr.iErr)
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedSingleString(*keywordAdr);
freeAllocatedSingleString(*languageAdr);
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of boolean at position 4.
sciErr = getMatrixOfBoolean(pvApiCtx, piAddrfullTextAdr, &nbRow, &nbCol, &fullTextAdr);
if (sciErr.iErr)
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedSingleString(*keywordAdr);
freeAllocatedSingleString(*languageAdr);
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: Boolean matrix expected.\n"), fname, 4);
return 1;
}
if (nbRow*nbCol != 1)
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedSingleString(*keywordAdr);
freeAllocatedSingleString(*languageAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 4);
return FALSE;
}
}
else
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedSingleString(*keywordAdr);
freeAllocatedSingleString(*languageAdr);
Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 4);
return FALSE;
}
ret = searchKeyword(helpAdr, nbRowHelp * nbColHelp, keywordAdr[0], languageAdr[0], *fullTextAdr == 1);
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedSingleString(*keywordAdr);
freeAllocatedSingleString(*languageAdr);
}
else
{
Scierror(999, _("%s: Wrong number of input arguments: %d or %d expected.\n"), fname, 2, 4);
return FALSE;
}
if (ret == 0)
{
return FALSE;
}
AssignOutputVariable(pvApiCtx, 1) = 0;
ReturnArguments(pvApiCtx);
return TRUE;
}
types::Function::ReturnValue sci_helpbrowser(types::typed_list &in, int _iRetCount, types::typed_list& out)
{
int iHelpAdrSize = 0;
char **helpAdr = NULL;
char **languageAdr = NULL;
if (_iRetCount > 1)
{
Scierror(78, _("%s: Wrong number of output argument(s): %d to %d expected."), "helpbrowser", 0, 1);
return types::Function::Error;
}
switch (in.size())
{
case 4:
if (!(in[3]->isBool() == true && in[3]->getAs<types::Bool>()->isScalar() == true))
{
Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected."), "helpbrowser", 4);
return types::Function::Error;
}
if (!(in[2]->isString() == true && in[2]->getAs<types::String>()->isScalar() == true))
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected."), "helpbrowser", 3);
return types::Function::Error;
}
case 2:
// Second argument must be String or at least [].
if (!(in[1]->isString() == true && in[1]->getAs<types::String>()->isScalar() == true))
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected."), "helpbrowser", 2);
return types::Function::Error;
}
// Matrix of String or [] allowed.
if ( !( (in[0]->isString() == true)
|| (in[0]->isDouble() == true && in[0]->getAs<types::Double>()->isEmpty() == true)))
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected."), "helpbrowser", 1);
return types::Function::Error;
}
break;
default:
Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected."), "helpbrowser", 2, 4);
return types::Function::Error;
}
/* We load SciNotes when calling javahelp because we have no way to know
* to load it when using Javahelp because it can call SciNotes directly */
if (!loadedDep)
{
loadOnUseClassPath("SciNotes");
loadedDep = TRUE;
}
if (in[0]->isString() == true)
{
types::String *pInHelpAdr = in[0]->getAs<types::String>();
helpAdr = new char*[pInHelpAdr->getSize()];
iHelpAdrSize = pInHelpAdr->getSize();
for (int i = 0 ; i < pInHelpAdr->getSize() ; ++i)
{
helpAdr[i] = wide_string_to_UTF8(pInHelpAdr->get(i));
}
}
char* pstLang = NULL;
char* pstKey = NULL;
if (in.size() == 2)
{
pstLang = wide_string_to_UTF8(in[1]->getAs<types::String>()->get(0));
launchHelpBrowser(helpAdr, iHelpAdrSize, pstLang);
}
if (in.size() == 4)
{
pstLang = wide_string_to_UTF8(in[2]->getAs<types::String>()->get(0));
pstKey = wide_string_to_UTF8(in[1]->getAs<types::String>()->get(0));
int iFullText = in[3]->getAs<types::Bool>()->get(0);
searchKeyword(helpAdr, iHelpAdrSize, pstKey, pstLang, (BOOL) iFullText);
}
if (pstLang != NULL)
{
FREE(pstLang);
}
if (pstKey != NULL)
{
FREE(pstKey);
}
if (helpAdr != NULL) /* No toolboxes loaded */
{
for (int i = 0 ; i < iHelpAdrSize ; i++)
{
FREE(helpAdr[i]);
}
delete[] helpAdr;
}
return types::Function::OK;
}
