/*--------------------------------------------------------------------------*/
SCILAB_WINDOWS_IMPEXP void setFocusOnConsole(void)
{
if ( (getScilabMode() == SCILAB_NW) || (getScilabMode() == SCILAB_NWNI) )
{
HWND hWndConsole = GetConsoleWindow();
if (hWndConsole)
{
SetForegroundWindow(hWndConsole);
SetActiveWindow(hWndConsole);
}
}
}
/*
** This function is threaded and watch for a signal.
** sent when StoreCommand is performed.
*/
static void initAll(void)
{
/* Set console mode to raw */
#ifndef _MSC_VER
if (getScilabMode() == SCILAB_NWNI || getScilabMode() == SCILAB_NW)
{
initConsoleMode(RAW);
}
#endif
initialized = TRUE;
pReadyForLaunch = mmap(0, sizeof(__threadSignalLock), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
atexit(release);
__InitSignal(&TimeToWork);
__InitSignalLock(pReadyForLaunch);
}
/*--------------------------------------------------------------------------*/
BOOL TerminateWindows_tools(void)
{
BOOL bOK = FALSE;
int scilabMode = getScilabMode();
switch (scilabMode)
{
case SCILAB_STD:
{
//Since Scilab 6 All scilab mode are launch in console mode
//So we cannot close owner console
//CloseScilabConsole();
closeInnosetupMutex();
bOK = TRUE;
}
break;
case SCILAB_NW:
{
RestoreConsoleColors();
RestoreExitButton();
bOK = TRUE;
}
break;
default:
break;
}
return bOK;
}
/*--------------------------------------------------------------------------*/
int sci_iswaitingforinput(char *fname, unsigned long fname_len)
{
BOOL res = FALSE;
int un = 1, outIndex = 0;
Rhs = Max(Rhs, 0);
CheckRhs(0, 1);
CheckLhs(0, 1);
if (getScilabMode() == SCILAB_STD)
{
res = ConsoleIsWaitingForInput();
}
else
{
sciprint(_("%s: Not implemented in this mode.\n"), fname);
}
CreateVar(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &un, &un, &outIndex);
*istk(outIndex) = res;
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
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;
}
/***********************************************************************
* line editor
**********************************************************************/
static void getCommandLine(void)
{
tmpPrompt = GetTemporaryPrompt();
GetCurrentPrompt(Sci_Prompt);
if (__CommandLine)
{
FREE(__CommandLine);
__CommandLine = NULL;
}
if (getScilabMode() == SCILAB_STD)
{
/* Send new prompt to Java Console, do not display it */
if (tmpPrompt != NULL)
{
SetConsolePrompt(tmpPrompt);
}
else
{
SetConsolePrompt(Sci_Prompt);
}
setSearchedTokenInScilabHistory(NULL);
/* Call Java Console to get a string */
__CommandLine = strdup(ConsoleRead());
}
else
{
/* Call Term Management for NW and NWNI to get a string */
__CommandLine = getCmdLine();
}
}
/*--------------------------------------------------------------------------*/
int gw_ui_data(void)
{
Rhs = Max(0, Rhs);
if ( getScilabMode() == SCILAB_NWNI)
{
Scierror(999,_("Scilab '%s' module disabled in -nogui or -nwni mode.\n"), "ui_data");
return 0;
}
/* if (!loadedDep)
{
loadOnUseClassPath("ui_data");
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;
}
/*--------------------------------------------------------------------------*/
static void printf_scilab(char *buffer)
{
if (buffer)
{
wchar_t *wcBuffer = NULL;
if (getScilabMode() == SCILAB_STD)
{
ConsolePrintf(buffer);
}
else
{
#ifdef _MSC_VER
TermPrintf_Windows(buffer);
#else
printf("%s",buffer);
#endif
}
wcBuffer = to_wide_string(buffer);
if (wcBuffer)
{
diaryWrite(wcBuffer, FALSE);
FREE(wcBuffer);
wcBuffer = NULL;
}
}
}
/*--------------------------------------------------------------------------*/
int C2F(sci_havewindow)(char *fname, unsigned long fname_len)
{
static int n1, m1;
int *Status = NULL;
CheckRhs(0, 1);
CheckLhs(1, 1);
Status = (int*)MALLOC(sizeof(int));
*Status = (int) ( getScilabMode() == SCILAB_STD );
m1 = 1;
n1 = 1;
CreateVarFromPtr(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &Status);
LhsVar(1) = Rhs + 1;
if (Status)
{
FREE(Status);
Status = NULL;
}
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
int scilinesdefault(void)
{
#ifndef _MSC_VER
char tc_buf[1024]; /* holds termcap buffer */
if (tgetent(tc_buf, getenv("TERM")) == 1)
{
setConsoleLines(tgetnum("li")); /* retrieve from the term info the number
of lines */
setConsoleWidth(tgetnum("co")); /* And the number of columns */
}
else
{
/* Haven't been able to detect the terminal */
setConsoleLines(DEFAULT_NUMBERS_LINES);
setConsoleWidth(DEFAULT_NUMBERS_COLUMNS);
}
#else
if ( (getScilabMode() != SCILAB_STD) && (getScilabMode() != SCILAB_API) )
{
/* -NW or -NWNI mode */
int X = getXConsoleScreenSize();
int Y = getYConsoleScreenSize();
if (X < DEFAULT_NUMBERS_COLUMNS)
{
X = DEFAULT_NUMBERS_COLUMNS;
}
if (Y < DEFAULT_NUMBERS_LINES)
{
Y = DEFAULT_NUMBERS_LINES;
}
setConsoleWidth(X);
setConsoleLines(Y);
}
else
{
setConsoleLines(DEFAULT_NUMBERS_LINES);
setConsoleWidth(DEFAULT_NUMBERS_COLUMNS);
}
#endif
return 0;
}
/*--------------------------------------------------------------------------*/
BOOL InitializeTclTk(void)
{
if ( getScilabMode() != SCILAB_NWNI )
{
setTkStarted(TRUE);
if ( OpenTCLsci() != 0 )
{
setTkStarted(FALSE);
}
}
return isTkStarted();
}
/*--------------------------------------------------------------------------*/
void disp_scilab_version(void)
{
if ( (getScilabMode() == SCILAB_NWNI) || (getScilabMode() == SCILAB_NW) || (getScilabMode() == SCILAB_API) )
{
printf(_("Scilab version \"%d.%d.%d.%d\"\n"), SCI_VERSION_MAJOR, SCI_VERSION_MINOR, SCI_VERSION_MAINTENANCE, SCI_VERSION_TIMESTAMP);
printf("%s\n\n", SCI_VERSION_STRING);
}
else
{
#ifdef _MSC_VER
{
char msg[1024];
wsprintf(msg, gettext("Scilab version \"%d.%d.%d.%d\"\n%s\n"), SCI_VERSION_MAJOR, SCI_VERSION_MINOR, SCI_VERSION_MAINTENANCE, SCI_VERSION_TIMESTAMP, SCI_VERSION_STRING);
MessageBox(NULL, msg, gettext("Scilab Version Info."), MB_ICONINFORMATION);
}
#else
printf(_("Scilab version \"%d.%d.%d.%d\"\n"), SCI_VERSION_MAJOR, SCI_VERSION_MINOR, SCI_VERSION_MAINTENANCE, SCI_VERSION_TIMESTAMP);
printf("%s\n\n", SCI_VERSION_STRING);
#endif
}
}
/*--------------------------------------------------------------------------*/
int gw_xcos(void)
{
if (getScilabMode() == SCILAB_NWNI)
{
Scierror(999, _("Scilab '%s' module disabled in -nogui or -nwni mode.\n"), "xcos");
}
else
{
Scierror(999, _("Scilab '%s' module not installed.\n"), "xcos");
}
return 0;
}
/*--------------------------------------------------------------------------*/
int gw_graphic_objects(void)
{
Rhs = Max(0, Rhs);
if ( getScilabMode() == SCILAB_NWNI)
{
Scierror(999,_("Scilab '%s' module disabled in -nogui or -nwni mode.\n"), "graphic_objects");
return 0;
}
callFunctionFromGateway(Tab, SIZE_CURRENT_GENERIC_TABLE(Tab));
return 0;
}
/*--------------------------------------------------------------------------*/
int gw_graphic_export(void)
{
#ifndef _MSC_VER
if (getScilabMode() == SCILAB_NWNI)
{
Scierror(999, _("Scilab '%s' module disabled in -nogui or -nwni mode.\n"), "graphic_export");
}
else
#endif
{
Scierror(999, _("Scilab '%s' module not installed.\n"), "graphic_export");
}
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_oemtochar(char *fname, unsigned long l)
{
int l1 = 0, n1 = 0, m1 = 0;
char *Output = NULL;
if (getWarningMode())
{
sciprint(_("%s: Feature %s is obsolete.\n"), _("Warning"), fname);
sciprint(_("%s: This feature will be permanently removed in Scilab %s\n\n"), _("Warning"), "5.4.1");
}
CheckRhs(1, 1);
CheckLhs(0, 1);
if (GetType(1) == sci_strings)
{
char *OEMstring = NULL;
GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);
OEMstring = cstk(l1);
Output = (char*)MALLOC((strlen(OEMstring) + 1) * sizeof(char));
if (getScilabMode() == SCILAB_STD)
{
OemToChar(OEMstring, Output);
}
else
{
wsprintf(Output, "%s", OEMstring);
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 1);
return 0;
}
n1 = 1;
m1 = (int)strlen(Output);
CreateVarFromPtr(Rhs + 1, STRING_DATATYPE, &m1, &n1, &Output);
if (Output)
{
FREE(Output);
Output = NULL;
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
BOOL CloseTCLsci(void)
{
if ( getScilabMode() != SCILAB_NWNI )
{
if (isTkStarted())
{
setTkStarted(FALSE);
__WaitThreadDie(TclThread);
deleteTclInterp();
TKmainWindow = NULL;
return TRUE;
}
}
return FALSE;
}
/*--------------------------------------------------------------------------*/
BOOL InitializeGUI(void)
{
if (getScilabMode() == SCILAB_STD)
{
// TODO why this line since already done above
// createSwingView();
#ifdef _MSC_VER
WindowShow();
#endif
}
else
{
return TRUE;
}
return FALSE;
}
/*--------------------------------------------------------------------------*/
int gw_jvm(void)
{
Rhs = Max(0, Rhs);
if(pvApiCtx == NULL)
{
pvApiCtx = (StrCtx*)MALLOC(sizeof(StrCtx));
}
pvApiCtx->pstName = (char*)Tab[Fin-1].name;
if ( (getScilabMode() != SCILAB_NWNI) )
{
callFunctionFromGateway(Tab, SIZE_CURRENT_GENERIC_TABLE(Tab));
}
else
{
Scierror(999,_("JVM interface disabled in -nogui or -nwni modes.\n"));
}
return 0;
}
/*--------------------------------------------------------------------------*/
int C2F(sci_getscilabmode)(char *fname, unsigned long fname_len)
{
int n1 = 0, m1 = 0;
char *output = NULL ;
int iRet = 0;
SciErr sciErr;
CheckInputArgument(pvApiCtx, 0, 0) ;
CheckOutputArgument(pvApiCtx, 1, 1) ;
switch (getScilabMode())
{
case SCILAB_API:
default :
output = strdup("API");
break;
case SCILAB_STD:
output = strdup("STD");
break;
case SCILAB_NW:
output = strdup("NW");
break;
case SCILAB_NWNI:
output = strdup("NWNI");
break;
}
/* Create the string matrix as return of the function */
iRet = createSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, output);
free(output); // Data have been copied into Scilab memory
if (iRet)
{
freeAllocatedSingleString(output);
return 1;
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return 0;
}
const char * getScilabModeString(void)
{
scilabMode smMode = getScilabMode();
switch (smMode)
{
case SCILAB_API:
return "API";
break;
case SCILAB_STD:
return "STD";
break;
case SCILAB_NW:
return "NW";
break;
case SCILAB_NWNI:
return "NWNI";
break;
default:
return "STD";
break;
}
}
int ScicosModule::Load()
{
std::wstring wstModuleName = L"scicos";
const wchar_t* wstLibName = wstModuleName.c_str();
if (getScilabMode() == SCILAB_NWNI)
{
wstLibName = L"scicos-cli";
}
#ifdef _MSC_VER
wchar_t* pwstLibName = buildModuleDynLibraryNameW(wstLibName, DYNLIB_NAME_FORMAT_1);
#else
wchar_t* pwstLibName = buildModuleDynLibraryNameW(wstLibName, DYNLIB_NAME_FORMAT_3);
#endif
vectGateway vect = loadGatewaysName(wstModuleName);
for (int i = 0 ; i < (int)vect.size() ; i++)
{
symbol::Context::getInstance()->addFunction(types::Function::createFunction(vect[i].wstFunction, vect[i].wstName, pwstLibName, vect[i].iType, NULL, wstModuleName));
}
FREE(pwstLibName);
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 StaticRunner::launch()
{
//set execution thread in java
if (!initialJavaHooks && getScilabMode() != SCILAB_NWNI)
{
initialJavaHooks = true;
// Execute the initial hooks registered in Scilab.java
ExecuteInitialHooks();
}
int iRet = 0;
// get the runner to execute
std::unique_ptr<Runner> runMe(getRunner());
// set if the current comment is interruptible
setInterruptibleCommand(runMe->isInterruptible());
debugger::DebuggerMagager* manager = debugger::DebuggerMagager::getInstance();
ConfigVariable::resetExecutionBreak();
int oldMode = ConfigVariable::getPromptMode();
symbol::Context* pCtx = symbol::Context::getInstance();
int scope = pCtx->getScopeLevel();
// a TCL command display nothing
int iOldPromptMode = 0;
if (runMe->getCommandOrigin() == TCLSCI)
{
iOldPromptMode = ConfigVariable::getPromptMode();
ConfigVariable::setPromptMode(-1);
}
try
{
int level = ConfigVariable::getRecursionLevel();
try
{
runMe->getProgram()->accept(*(runMe->getVisitor()));
}
catch (const ast::RecursionException& re)
{
// management of pause
if (ConfigVariable::getPauseLevel())
{
ConfigVariable::DecreasePauseLevel();
throw re;
}
//close opened scope during try
while (pCtx->getScopeLevel() > scope)
{
pCtx->scope_end();
}
//decrease recursion to init value and close where
while (ConfigVariable::getRecursionLevel() > level)
{
ConfigVariable::where_end();
ConfigVariable::decreaseRecursion();
}
ConfigVariable::resetWhereError();
ConfigVariable::setPromptMode(oldMode);
//print msg about recursion limit and trigger an error
wchar_t sz[1024];
os_swprintf(sz, 1024, _W("Recursion limit reached (%d).\n").data(), ConfigVariable::getRecursionLimit());
throw ast::InternalError(sz);
}
}
catch (const ast::InternalError& se)
{
if (runMe->getCommandOrigin() == TCLSCI)
{
ConfigVariable::setPromptMode(iOldPromptMode);
}
std::wostringstream ostr;
ConfigVariable::whereErrorToString(ostr);
scilabErrorW(ostr.str().c_str());
scilabErrorW(se.GetErrorMessage().c_str());
ConfigVariable::resetWhereError();
iRet = 1;
}
catch (const ast::InternalAbort& ia)
{
if (runMe->getCommandOrigin() == TCLSCI)
{
ConfigVariable::setPromptMode(iOldPromptMode);
}
// management of pause
if (ConfigVariable::getPauseLevel())
{
ConfigVariable::DecreasePauseLevel();
throw ia;
}
// close all scope before return to console scope
symbol::Context* pCtx = symbol::Context::getInstance();
while (pCtx->getScopeLevel() > scope)
{
pCtx->scope_end();
}
// send the good signal about the end of execution
sendExecDoneSignal(runMe.get());
//clean debugger step flag if debugger is not interrupted ( end of debug )
manager->resetStep();
throw ia;
}
if (runMe->getCommandOrigin() == TCLSCI)
{
ConfigVariable::setPromptMode(iOldPromptMode);
}
if (getScilabMode() != SCILAB_NWNI && getScilabMode() != SCILAB_API)
{
char *cwd = NULL;
int err = 0;
UpdateBrowseVar();
cwd = scigetcwd(&err);
if (cwd)
{
FileBrowserChDir(cwd);
FREE(cwd);
}
}
// reset error state when new prompt occurs
ConfigVariable::resetError();
// send the good signal about the end of execution
sendExecDoneSignal(runMe.get());
//clean debugger step flag if debugger is not interrupted ( end of debug )
manager->resetStep();
return iRet;
}
/*--------------------------------------------------------------------------*/
int sci_toolbar(char *fname, unsigned long l)
{
SciErr sciErr;
int* piAddr1 = NULL;
int* piStkAdr = NULL;
int* piAddrstkAdr = NULL;
long long* stkAdr = NULL;
int* piAddrparam = NULL;
int nbCol = 0;
int nbRow = 0;
char *Output = NULL;
char **param = NULL;
int figNum = -2;
int iIsVisible = 0;
int *piIsVisible = NULL;
int iParentUID = 0;
int iParentType = -1;
int *piParentType = &iParentType;
CheckInputArgument(pvApiCtx, 1, 2);
CheckOutputArgument(pvApiCtx, 0, 1);
/* Figure number */
if (checkInputArgumentType(pvApiCtx, 1, sci_matrix))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 1.
sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr1, &nbRow, &nbCol, &piStkAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, 1);
return 1;
}
if (nbRow * nbCol != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 1);
return FALSE;
}
figNum = *piStkAdr;
if (figNum < -1)
{
Scierror(999, _("%s: Wrong value for input argument #%d: Must be > %d expected.\n"), fname, 1, -1);
return FALSE;
}
if (figNum != -1) /* Check that the figure exists */
{
if (getFigureFromIndex(figNum) == 0)
{
Scierror(999, _("%s: Wrong value for input argument #%d: 'Graphic Window Number %d' does not exist.\n"), fname, 1, figNum);
return FALSE;
}
}
if (figNum == -1)
{
iParentUID = getConsoleIdentifier();
}
else
{
iParentUID = getFigureFromIndex(figNum);
}
}
else if (checkInputArgumentType(pvApiCtx, 1, sci_handles))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrstkAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of handle at position 1.
sciErr = getMatrixOfHandle(pvApiCtx, piAddrstkAdr, &nbRow, &nbCol, &stkAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, 1);
return 1;
}
if (nbRow * nbCol != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
return FALSE;
}
iParentUID = getObjectFromHandle((long) * stkAdr);
if (iParentUID == 0)
{
Scierror(999, _("%s: Wrong value for input argument #%d: this handle does not exist.\n"), fname, 1);
return FALSE;
}
getGraphicObjectProperty(iParentUID, __GO_TYPE__, jni_int, (void **)&piParentType);
if (iParentType != __GO_FIGURE__)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A real or a Figure handle expected.\n"), fname, 1);
return FALSE;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A real or a Figure handle expected.\n"), fname, 1);
return FALSE;
}
if (nbInputArgument(pvApiCtx) == 2) /* New status */
{
if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrparam);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 2.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrparam, &nbRow, &nbCol, ¶m))
{
Scierror(202, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
return 1;
}
if (nbRow * nbCol != 1)
{
freeAllocatedMatrixOfString(nbRow, nbCol, param);
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
return FALSE;
}
if ((strcmp(param[0], "off") == 0) || (strcmp(param[0], "on") == 0))
{
iIsVisible = strcmp(param[0], "on") == 0;
if (iParentUID != getConsoleIdentifier() || getScilabMode() == SCILAB_STD)
{
setGraphicObjectProperty(iParentUID, __GO_TOOLBAR_VISIBLE__, &iIsVisible, jni_bool, 1);
}
freeAllocatedMatrixOfString(nbRow, nbCol, param);
}
else
{
freeAllocatedMatrixOfString(nbRow, nbCol, param);
Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 2, "on", "off");
return FALSE;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
return FALSE;
}
}
/* Returned value */
piIsVisible = &iIsVisible;
getGraphicObjectProperty(iParentUID, __GO_TOOLBAR_VISIBLE__, jni_bool, (void **)&piIsVisible);
if (iIsVisible)
{
Output = strdup("on");
}
else
{
Output = strdup("off");
}
nbCol = 1;
nbRow = (int)strlen(Output);
if (createSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, Output))
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
if (Output)
{
FREE(Output);
Output = NULL;
}
ReturnArguments(pvApiCtx);
return TRUE;
}
types::Function::ReturnValue sci_consolebox(types::typed_list &in, int _iRetCount, types::typed_list &out)
{
if (in.size() < 0 || in.size() > 1)
{
Scierror(77, _("%s: Wrong number of input argument(s): %d or %d expected.\n"), "consolebox", 0, 1);
return types::Function::Error;
}
if (getScilabMode() != SCILAB_STD)
{
sciprint(_("Only on Windows Mode, not in Console Mode.\n"));
out.push_back(new types::String(L"off"));
return types::Function::OK;
}
//request mode
if (in.size() == 0)
{
if (GetConsoleState())
{
out.push_back(new types::String(L"on"));
}
else
{
out.push_back(new types::String(L"off"));
}
return types::Function::OK;
}
types::InternalType* pIT1 = in[0];
if (pIT1->isString() == false)
{
Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), "consolebox", 1);
return types::Function::Error;
}
types::String* pS1 = pIT1->getAs<types::String>();
if (pS1->isScalar() == false)
{
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), "consolebox", 1);
return types::Function::Error;
}
std::wstring wcsAction(pS1->get(0));
if (wcsAction == L"on")
{
SetConsoleState(1);
ShowScilex();
}
else if (wcsAction == L"off")
{
SetConsoleState(0);
HideScilex();
}
else if (wcsAction == L"toggle")
{
SwitchConsole();
}
else
{
Scierror(999, ("%s: Wrong input argument: '%s', '%s' or '%s' expected.\n"), "consolebox", "on", "off", "toggle");
return types::Function::Error;
}
if (GetConsoleState())
{
out.push_back(new types::String(L"on"));
}
else
{
out.push_back(new types::String(L"off"));
}
return types::Function::OK;
}
/*--------------------------------------------------------------------------*/
int sci_consolebox(char *fname,unsigned long l)
{
static int l1,n1,m1;
char *Output=NULL;
Rhs=Max(Rhs,0);
CheckRhs(0,1);
CheckLhs(0,1);
Output=(char*)MALLOC(4*sizeof(char));
if (Rhs==0)
{
if (getScilabMode() == SCILAB_STD)
{
if (GetConsoleState()) strcpy(Output,"on");
else strcpy(Output,"off");
}
else
{
sciprint(_("Only on Windows Mode, not in Console Mode.\n"));
strcpy(Output,"off");
}
}
else
if (GetType(1) == sci_strings)
{
char *param=NULL;
GetRhsVar(1,STRING_DATATYPE,&m1,&n1,&l1);
param=cstk(l1);
if ( (strcmp(param,"off")==0) || (strcmp(param,"on")==0) || (strcmp(param,"toggle")==0) )
{
if (getScilabMode() == SCILAB_STD)
{
if (strcmp(param,"on")==0)
{
SetConsoleState(1);
ShowScilex();
strcpy(Output,"on");
}
else if (strcmp(param,"off")==0)
{
SetConsoleState(0);
HideScilex();
strcpy(Output,"off");
}
else /* toggle */
{
SwitchConsole();
if (GetConsoleState()) strcpy(Output,"on");
else strcpy(Output,"off");
}
}
else
{
sciprint(_("Only on Windows Mode, not in Console Mode.\n"));
strcpy(Output,"off");
}
}
else
{
Scierror(999,("%s: Wrong input argument: '%s', '%s' or '%s' expected.\n"),fname,"on", "off", "toggle");
return 0;
}
}
else
{
Scierror(999,("%s: Wrong input argument: '%s', '%s' or '%s' expected.\n"),fname,"on", "off", "toggle");
return 0;
}
n1=1;
CreateVarFromPtr(Rhs+ 1,STRING_DATATYPE,(m1=(int)strlen(Output), &m1),&n1,&Output);
if (Output) {FREE(Output);Output=NULL;}
LhsVar(1) = Rhs+1;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
int C2F(getscilabmode)(scilabMode *mode)
{
*mode = getScilabMode();
return 0;
}
/*--------------------------------------------------------------------------*/
int C2F(sci_exit)(char *fname, unsigned long fname_len)
{
SciErr sciErr;
BOOL shouldExit;
CheckLhs(1, 1);
CheckRhs(0, 1);
if (Rhs == 0)
{
setExitCodeValue(0);
}
else
{
int iExit = 0;
int m1 = 0, n1 = 0;
int iType1 = 0;
int *piAddressVarOne = NULL;
double *pdVarOne = NULL;
/* get Address of inputs */
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarOne, &iType1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
/* check input type */
if ( iType1 != sci_matrix )
{
Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), fname, 1);
return 0;
}
sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarOne, &m1, &n1, &pdVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
if ( n1 != 1 || m1 != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), fname, 1);
return 0;
}
iExit = (int) * pdVarOne;
if (*pdVarOne != (double)iExit)
{
Scierror(999, _("%s: Wrong value for input argument #%d: An integer expected.\n"), fname, 1);
return 0;
}
setExitCodeValue(iExit);
}
shouldExit = TRUE;
if (getScilabMode() != SCILAB_NWNI)
{
if (Rhs == 0)
{
shouldExit = canCloseMainScilabObject();
}
else
{
forceCloseMainScilabObject();
}
}
// this value do quit in scirun
if (shouldExit)
{
C2F(com).fun = -999;
}
LhsVar(1) = 0;
PutLhsVar();
return 0;
}
/*
* Previously called zzledt... Called by Fortran...
* Now renamed to EventLoopPrompt
* @TODO remove unused arg buf_size, menusflag, modex & dummy1
*/
void C2F(eventloopprompt) (char *buffer, int *buf_size, int *len_line, int *eof)
{
if (getScilabMode() == SCILAB_API)
{
return;
}
if (!initialJavaHooks && getScilabMode() != SCILAB_NWNI)
{
initialJavaHooks = TRUE;
// Execute the initial hooks registered in Scilab.java
ExecuteInitialHooks();
}
/* if not an interactive terminal */
#ifdef _MSC_VER
/* if file descriptor returned is -2 stdin is not associated with an input stream */
/* example : echo plot3d | scilex -nw -e */
if (!isatty(fileno(stdin)) && (fileno(stdin) != -2) && getScilabMode() != SCILAB_STD)
#else
if (!isatty(fileno(stdin)) && getScilabMode() != SCILAB_STD)
#endif
{
/* remove newline character if there */
if (__CommandLine != NULL)
{
/* read a line into the buffer, but not too
* big */
*eof = (fgets(__CommandLine, *buf_size, stdin) == NULL);
*len_line = (int)strlen(__CommandLine);
/* remove newline character if there */
if (__CommandLine[*len_line - 1] == '\n')
{
(*len_line)--;
}
return;
}
}
if (!initialized)
{
initAll();
}
__LockSignal(pReadyForLaunch);
if (__CommandLine)
{
FREE(__CommandLine);
__CommandLine = NULL;
}
__CommandLine = strdup("");
if (ismenu() == 0)
{
if (!WatchGetCmdLineThreadAlive)
{
if (WatchGetCmdLineThread)
{
__WaitThreadDie(WatchGetCmdLineThread);
}
if (getScilabMode() != SCILAB_NWNI)
{
char *cwd = NULL;
int err = 0;
UpdateBrowseVar(TRUE);
cwd = scigetcwd(&err);
if (cwd)
{
FileBrowserChDir(cwd);
FREE(cwd);
}
}
__CreateThread(&WatchGetCmdLineThread, &watchGetCommandLine);
WatchGetCmdLineThreadAlive = TRUE;
}
if (!WatchStoreCmdThreadAlive)
{
if (WatchStoreCmdThread)
{
__WaitThreadDie(WatchStoreCmdThread);
}
__CreateThread(&WatchStoreCmdThread, &watchStoreCommand);
WatchStoreCmdThreadAlive = TRUE;
}
__Wait(&TimeToWork, pReadyForLaunch);
}
__UnLockSignal(pReadyForLaunch);
/*
** WARNING : Old crappy f.... code
** do not change reference to buffer
** or fortran will be lost !!!!
*/
if (__CommandLine)
{
strcpy(buffer, __CommandLine);
}
else
{
strcpy(buffer, "");
}
*len_line = (int)strlen(buffer);
*eof = FALSE;
}
