void DMessageBox::showInformationWidget(QMessageBox::Icon icon, QWidget* const parent, const QString& caption, const QString& text, QWidget* const listWidget, const QString& dontShowAgainName) { if (!readMsgBoxShouldBeShown(dontShowAgainName)) { return; } QDialog* const dialog = new QDialog(parent, Qt::Dialog); dialog->setWindowTitle(caption); dialog->setObjectName(QLatin1String("showInformation")); dialog->setModal(true); QDialogButtonBox* const buttons = new QDialogButtonBox(QDialogButtonBox::Ok, dialog); buttons->button(QDialogButtonBox::Ok)->setDefault(true); buttons->button(QDialogButtonBox::Ok)->setShortcut(Qt::Key_Escape); QObject::connect(buttons->button(QDialogButtonBox::Ok), SIGNAL(clicked()), dialog, SLOT(accept())); bool checkboxResult = false; createMessageBox(dialog, buttons, createIcon(icon), text, listWidget, dontShowAgainName.isEmpty() ? QString() : i18n("Do not show this message again"), &checkboxResult); saveMsgBoxShouldBeShown(dontShowAgainName, checkboxResult); }
void CommandDlg::handleOKClicked() { name = nameBox->getText(); if((type != 0) && (name.empty() || commandBox->getText().empty())) { createMessageBox().show(T_("Name and command must not be empty"), _T(APPNAME) _T(" ") _T(VERSIONSTRING), MessageBox::BOX_OK, MessageBox::BOX_ICONEXCLAMATION); return; } ctx = 0; if(hubMenu->getChecked()) ctx |= UserCommand::CONTEXT_HUB; if(userMenu->getChecked()) ctx |= UserCommand::CONTEXT_CHAT; if(searchMenu->getChecked()) ctx |= UserCommand::CONTEXT_SEARCH; if(fileListMenu->getChecked()) ctx |= UserCommand::CONTEXT_FILELIST; hub = hubBox->getText(); if(type != 0) type = once->getChecked() ? 2 : 1; SettingsManager::getInstance()->set(SettingsManager::OPEN_USER_CMD_HELP, openHelp->getChecked()); endDialog(IDOK); }
void Bookmarks::bookmarkLocation() { bool ok = false; auto bookmarkName = OffscreenUi::getText(OffscreenUi::ICON_PLACEMARK, "Bookmark Location", "Name", QString(), &ok); if (!ok) { return; } bookmarkName = bookmarkName.trimmed().replace(QRegExp("(\r\n|[\r\n\t\v ])+"), " "); if (bookmarkName.length() == 0) { return; } auto addressManager = DependencyManager::get<AddressManager>(); QString bookmarkAddress = addressManager->currentAddress().toString(); Menu* menubar = Menu::getInstance(); if (contains(bookmarkName)) { auto offscreenUi = DependencyManager::get<OffscreenUi>(); auto duplicateBookmarkMessage = offscreenUi->createMessageBox(OffscreenUi::ICON_WARNING, "Duplicate Bookmark", "The bookmark name you entered already exists in your list.", QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes); duplicateBookmarkMessage->setProperty("informativeText", "Would you like to overwrite it?"); auto result = offscreenUi->waitForMessageBoxResult(duplicateBookmarkMessage); if (result != QMessageBox::Yes) { return; } removeLocationFromMenu(menubar, bookmarkName); } addLocationToMenu(menubar, bookmarkName, bookmarkAddress); insert(bookmarkName, bookmarkAddress); // Overwrites any item with the same bookmarkName. enableMenuItems(true); }
int DMessageBox::showYesNoWidget(QMessageBox::Icon icon, QWidget* const parent, const QString& caption, const QString& text, QWidget* const listWidget, const QString& dontAskAgainName) { if (!readMsgBoxShouldBeShown(dontAskAgainName)) { return QMessageBox::Yes; } QDialog* const dialog = new QDialog(parent, Qt::Dialog); dialog->setWindowTitle(caption); dialog->setObjectName(QLatin1String("showYesNo")); dialog->setModal(true); QDialogButtonBox* const buttons = new QDialogButtonBox(QDialogButtonBox::Yes | QDialogButtonBox::No, dialog); buttons->button(QDialogButtonBox::No)->setDefault(true); buttons->button(QDialogButtonBox::No)->setShortcut(Qt::Key_Escape); QSignalMapper* const signalMapper = new QSignalMapper(buttons); signalMapper->setMapping(buttons->button(QDialogButtonBox::Yes), QDialogButtonBox::Yes); signalMapper->setMapping(buttons->button(QDialogButtonBox::No), QDialogButtonBox::No); QObject::connect(buttons->button(QDialogButtonBox::Yes), SIGNAL(clicked()), signalMapper, SLOT(map())); QObject::connect(buttons->button(QDialogButtonBox::No), SIGNAL(clicked()), signalMapper, SLOT(map())); QObject::connect(signalMapper, SIGNAL(mapped(int)), dialog, SLOT(done(int))); bool checkboxResult = false; int result = createMessageBox(dialog, buttons, createIcon(icon), text, listWidget, dontAskAgainName.isEmpty() ? QString() : i18n("Do not ask again"), &checkboxResult); if (result == QDialogButtonBox::Yes) { saveMsgBoxShouldBeShown(dontAskAgainName, checkboxResult); return QMessageBox::Yes; } else if (result == QDialogButtonBox::No) { saveMsgBoxShouldBeShown(dontAskAgainName, checkboxResult); return QMessageBox::No; } return QMessageBox::Cancel; }
void FavoriteDirsPage::handleRenameClicked() { int i = -1; while((i = directories->getNext(i, LVNI_SELECTED)) != -1) { tstring old = directories->getText(i, 0); LineDlg dlg(this, T_("Favorite name"), T_("Under what name you see the directory"), old); if(dlg.run() == IDOK) { tstring line = dlg.getLine(); if (FavoriteManager::getInstance()->renameFavoriteDir(Text::fromT(old), Text::fromT(line))) { directories->setText(i, 0, line); } else { createMessageBox().show(T_("Directory or directory name already exists"), _T(APPNAME) _T(" ") _T(VERSIONSTRING), MessageBox::BOX_OK, MessageBox::BOX_ICONSTOP); } } } }
void FavoriteDirsPage::addDirectory(const tstring& aPath) { tstring path = aPath; if( path[ path.length() -1 ] != PATH_SEPARATOR ) path += PATH_SEPARATOR; LineDlg dlg(this, T_("Favorite name"), T_("Under what name you see the directory"), Util::getLastDir(path)); if(dlg.run() == IDOK) { tstring line = dlg.getLine(); if (FavoriteManager::getInstance()->addFavoriteDir(Text::fromT(path), Text::fromT(line))) { TStringList row; row.push_back(line); row.push_back(path); directories->insert(row); } else { createMessageBox().show(T_("Directory or directory name already exists"), _T(APPNAME) _T(" ") _T(VERSIONSTRING), MessageBox::BOX_OK, MessageBox::BOX_ICONSTOP); } } }
void Bookmarks::addBookmarkToFile(const QString& bookmarkName, const QVariant& bookmark) { Menu* menubar = Menu::getInstance(); if (contains(bookmarkName)) { auto offscreenUi = DependencyManager::get<OffscreenUi>(); auto duplicateBookmarkMessage = offscreenUi->createMessageBox(OffscreenUi::ICON_WARNING, "Duplicate Bookmark", "The bookmark name you entered already exists in your list.", QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes); duplicateBookmarkMessage->setProperty("informativeText", "Would you like to overwrite it?"); auto result = offscreenUi->waitForMessageBoxResult(duplicateBookmarkMessage); if (result != QMessageBox::Yes) { return; } removeBookmarkFromMenu(menubar, bookmarkName); } addBookmarkToMenu(menubar, bookmarkName, bookmark); insert(bookmarkName, bookmark); // Overwrites any item with the same bookmarkName. enableMenuItems(true); }
int DMessageBox::showContinueCancelWidget(QMessageBox::Icon icon, QWidget* const parent, const QString& caption, const QString& text, QWidget* const listWidget, const QString& dontAskAgainName) { if (!readMsgBoxShouldBeShown(dontAskAgainName)) { return QMessageBox::Yes; } QDialog* const dialog = new QDialog(parent, Qt::Dialog); dialog->setWindowTitle(caption); dialog->setObjectName(QLatin1String("showContinueCancel")); dialog->setModal(true); QDialogButtonBox* const buttons = new QDialogButtonBox(QDialogButtonBox::Yes | QDialogButtonBox::Cancel, dialog); buttons->button(QDialogButtonBox::Yes)->setDefault(true); buttons->button(QDialogButtonBox::Yes)->setText(i18n("Continue")); buttons->button(QDialogButtonBox::Cancel)->setShortcut(Qt::Key_Escape); QObject::connect(buttons->button(QDialogButtonBox::Yes), SIGNAL(clicked()), dialog, SLOT(accept())); QObject::connect(buttons->button(QDialogButtonBox::Cancel), SIGNAL(clicked()), dialog, SLOT(reject())); bool checkboxResult = false; const int result = createMessageBox(dialog, buttons, createIcon(icon), text, listWidget, dontAskAgainName.isEmpty() ? QString() : i18n("Do not ask again"), &checkboxResult); if (result != QDialog::Accepted) { return QMessageBox::Cancel; } saveMsgBoxShouldBeShown(dontAskAgainName, checkboxResult); return QMessageBox::Yes; }
/*--------------------------------------------------------------------------*/ int sci_x_choice(char *fname, void* pvApiCtx) { SciErr sciErr; int* piAddrdefaultValuesAdr = NULL; int* piAddrlabelsAdr = NULL; int* piAddrlineLabelsAdr = NULL; double* emptyMatrixAdr = NULL; int nbRow = 0, nbCol = 0; int nbRowDefaultValues = 0, nbColDefaultValues = 0; int nbRowLineLabels = 0, nbColLineLabels = 0; int messageBoxID = 0; char **labelsAdr = NULL; char **lineLabelsAdr = NULL; double *defaultValues = NULL; int *defaultValuesInt = NULL; int userValueSize = 0; int *userValue = NULL; double *userValueDouble = NULL; int K = 0; CheckInputArgument(pvApiCtx, 3, 3); CheckOutputArgument(pvApiCtx, 0, 1); /* READ THE DEFAULT VALUES */ if (checkInputArgumentType(pvApiCtx, 1, sci_matrix)) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrdefaultValuesAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDouble(pvApiCtx, piAddrdefaultValuesAdr, &nbRowDefaultValues, &nbColDefaultValues, &defaultValues); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1); return 1; } defaultValuesInt = (int *)MALLOC(nbRowDefaultValues * nbColDefaultValues * sizeof(int)); for (K = 0; K < nbRowDefaultValues * nbColDefaultValues; K++) { defaultValuesInt[K] = (int)defaultValues[K]; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: Real or complex vector expected.\n"), fname, 1); return FALSE; } /* READ THE MESSAGE */ if ((checkInputArgumentType(pvApiCtx, 2, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrlabelsAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 2. if (getAllocatedMatrixOfString(pvApiCtx, piAddrlabelsAdr, &nbRow, &nbCol, &labelsAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2); return 1; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 2); FREE(defaultValuesInt); return FALSE; } /* Create the Java Object */ messageBoxID = createMessageBox(); /* Title is a default title */ setMessageBoxTitle(messageBoxID, _("Scilab Choices Request")); /* Message */ setMessageBoxMultiLineMessage(messageBoxID, labelsAdr, nbCol * nbRow); freeAllocatedMatrixOfString(nbRow, nbCol, labelsAdr); /* READ THE LABELS */ if (checkInputArgumentType(pvApiCtx, 3, sci_strings)) { sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrlineLabelsAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 3. if (getAllocatedMatrixOfString(pvApiCtx, piAddrlineLabelsAdr, &nbRowLineLabels, &nbColLineLabels, &lineLabelsAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3); return 1; } if (nbRow != 1 && nbCol != 1) { freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr); Scierror(999, _("%s: Wrong size for input argument #%d: Vector of strings expected.\n"), fname, 3); return FALSE; } setMessageBoxLineLabels(messageBoxID, lineLabelsAdr, nbColLineLabels * nbRowLineLabels); freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr); } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 3); return FALSE; } /* Default selected buttons */ setMessageBoxDefaultSelectedButtons(messageBoxID, defaultValuesInt, nbRowDefaultValues * nbColDefaultValues); /* Display it and wait for a user input */ messageBoxDisplayAndWait(messageBoxID); /* Read the user answer */ userValueSize = getMessageBoxValueSize(messageBoxID); if (userValueSize == 0) { nbRow = 0; nbCol = 0; sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &emptyMatrixAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } } else { userValue = (int*)getMessageBoxUserSelectedButtons(messageBoxID); userValueDouble = (double *)MALLOC(nbRowDefaultValues * nbColDefaultValues * sizeof(double)); for (K = 0; K < nbRowDefaultValues * nbColDefaultValues; K++) { userValueDouble[K] = userValue[K]; } sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRowDefaultValues, nbColDefaultValues, userValueDouble); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } /* TO DO : do a delete [] getMessageBoxUserSelectedButtons */ } FREE(defaultValuesInt); AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return TRUE; }
/*--------------------------------------------------------------------------*/ int sci_x_dialog(char *fname, unsigned long fname_len) { SciErr sciErr; int* piAddrlabelsAdr = NULL; int* piAddrinitialValueAdr = NULL; double* emptyMatrixAdr = NULL; int nbRow = 0, nbCol = 0; int messageBoxID = 0; char **initialValueAdr = 0; char **labelsAdr = 0; int userValueSize = 0; char **userValue = NULL; CheckInputArgument(pvApiCtx, 1, 2); CheckOutputArgument(pvApiCtx, 0, 1); if ((checkInputArgumentType(pvApiCtx, 1, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrlabelsAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 1. if (getAllocatedMatrixOfString(pvApiCtx, piAddrlabelsAdr, &nbRow, &nbCol, &labelsAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1); return 1; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 1); return FALSE; } /* Create the Java Object */ messageBoxID = createMessageBox(); /* Title is a default title */ setMessageBoxTitle(messageBoxID, _("Scilab Input Value Request")); /* Message */ setMessageBoxMultiLineMessage(messageBoxID, labelsAdr, nbCol * nbRow); freeAllocatedMatrixOfString(nbRow, nbCol, labelsAdr); if (nbInputArgument(pvApiCtx) == 2) { if (VarType(2) == sci_strings) { sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrinitialValueAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 2. if (getAllocatedMatrixOfString(pvApiCtx, piAddrinitialValueAdr, &nbRow, &nbCol, &initialValueAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2); return 1; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 2); return FALSE; } setMessageBoxInitialValue(messageBoxID, initialValueAdr, nbCol * nbRow); freeAllocatedMatrixOfString(nbRow, nbCol, initialValueAdr); } /* Display it and wait for a user input */ messageBoxDisplayAndWait(messageBoxID); /* Read the user answer */ userValueSize = getMessageBoxValueSize(messageBoxID); if (userValueSize == 0) { nbRow = 0; nbCol = 0; sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &emptyMatrixAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } } else { userValue = getMessageBoxValue(messageBoxID); nbCol = 1; CreateVarFromPtr(nbInputArgument(pvApiCtx) + 1, MATRIX_OF_STRING_DATATYPE, &userValueSize, &nbCol, userValue); /* TO DO : delete of userValue */ } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return TRUE; }
/*--------------------------------------------------------------------------*/ int sci_x_dialog(char *fname,unsigned long fname_len) { int nbRow = 0, nbCol = 0; int messageBoxID = 0; char **initialValueAdr = 0; char **labelsAdr = 0; int userValueSize = 0; char **userValue = NULL; int emptyMatrixAdr = 0; CheckRhs(1,2); CheckLhs(0,1); if (VarType(1) == sci_strings) { GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &labelsAdr); } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 1); return FALSE; } /* Create the Java Object */ messageBoxID = createMessageBox(); /* Title is a default title */ setMessageBoxTitle(messageBoxID, _("Scilab Input Value Request")); /* Message */ setMessageBoxMultiLineMessage(messageBoxID, getStringMatrixFromStack((size_t)labelsAdr), nbCol*nbRow); freeArrayOfString(labelsAdr, nbCol*nbRow); if (Rhs == 2) { if (VarType(2) == sci_strings) { GetRhsVar(2,MATRIX_OF_STRING_DATATYPE,&nbRow,&nbCol,&initialValueAdr); } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 2); return FALSE; } setMessageBoxInitialValue(messageBoxID, getStringMatrixFromStack((size_t)initialValueAdr), nbCol*nbRow); freeArrayOfString(initialValueAdr, nbCol*nbRow); } /* Display it and wait for a user input */ messageBoxDisplayAndWait(messageBoxID); /* Read the user answer */ userValueSize = getMessageBoxValueSize(messageBoxID); if (userValueSize == 0) { nbRow = 0;nbCol = 0; CreateVar(Rhs+1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &emptyMatrixAdr); } else { userValue = getMessageBoxValue(messageBoxID); nbCol = 1; CreateVarFromPtr(Rhs+1, MATRIX_OF_STRING_DATATYPE, &userValueSize, &nbCol, userValue); /* TO DO : delete of userValue */ } LhsVar(1) = Rhs+1; PutLhsVar(); return TRUE; }
/*--------------------------------------------------------------------------*/ int sci_messagebox(char *fname, void* pvApiCtx) { SciErr sciErr; int* piAddrmessageAdr = NULL; int* piAddrtitleAdr = NULL; int* piAddriconAdr = NULL; int* piAddrbuttonsTextAdr = NULL; int* piAddrmodalOptionAdr = NULL; double* buttonNumberAdr = NULL; int messageBoxID = 0; /* Used to read input arguments */ int nbRow = 0, nbCol = 0; int nbRowButtons = 0, nbColButtons = 0; int nbRowMessage = 0, nbColMessage = 0; char **buttonsTextAdr = 0; char **messageAdr = 0; char **titleAdr = 0; char **modalOptionAdr = 0; char **iconAdr = 0; /* Used to write output argument */ int buttonNumber = 0; CheckInputArgument(pvApiCtx, 1, 5); CheckOutputArgument(pvApiCtx, 0, 1); /* Message to be displayed */ if ((checkInputArgumentType(pvApiCtx, 1, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrmessageAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 1. if (getAllocatedMatrixOfString(pvApiCtx, piAddrmessageAdr, &nbRowMessage, &nbColMessage, &messageAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1); return 1; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1); return FALSE; } /* Title to be displayed */ if (nbInputArgument(pvApiCtx) >= 2) { if (checkInputArgumentType(pvApiCtx, 2, sci_strings)) { sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrtitleAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 2. if (getAllocatedMatrixOfString(pvApiCtx, piAddrtitleAdr, &nbRow, &nbCol, &titleAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2); return 1; } if (nbRow * nbCol != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname, 2); return FALSE; } /* The title argument can be used to give the modal option */ if (isModalOption(titleAdr[0])) { modalOptionAdr = titleAdr; titleAdr = NULL; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 2); return FALSE; } } /* Icon to be displayed */ if (nbInputArgument(pvApiCtx) >= 3) { if ((checkInputArgumentType(pvApiCtx, 3, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddriconAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 3. if (getAllocatedMatrixOfString(pvApiCtx, piAddriconAdr, &nbRow, &nbCol, &iconAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 3); return 1; } if (nbRow * nbCol == 1) { /* The icon argument can be used to give the modal option or the buttons names */ if (isModalOption(iconAdr[0])) { modalOptionAdr = (char **)iconAdr; iconAdr = NULL; } else if (!isIconName(iconAdr[0])) { buttonsTextAdr = (char **)iconAdr; nbRowButtons = nbRow; nbColButtons = nbCol; iconAdr = NULL; } } else /* More than one string --> buttons names */ { buttonsTextAdr = (char **)iconAdr; nbRowButtons = nbRow; nbColButtons = nbCol; iconAdr = NULL; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: string or string vector expected.\n"), fname, 3); return FALSE; } } /* Buttons names */ if (nbInputArgument(pvApiCtx) >= 4) { if ((checkInputArgumentType(pvApiCtx, 4, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrbuttonsTextAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 4. if (getAllocatedMatrixOfString(pvApiCtx, piAddrbuttonsTextAdr, &nbRowButtons, &nbColButtons, &buttonsTextAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 4); return 1; } if (nbRow * nbCol == 1) { /* The buttons names argument can be used to give the modal option */ if (isModalOption(buttonsTextAdr[0])) { modalOptionAdr = buttonsTextAdr; buttonsTextAdr = NULL; } } } else { Scierror(999, _("%s: Wrong type for input argument #%d: string or string vector expected.\n"), fname, 3); return FALSE; } } /* Modal option */ if (nbInputArgument(pvApiCtx) == 5) { if ((checkInputArgumentType(pvApiCtx, 5, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddrmodalOptionAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 5. if (getAllocatedMatrixOfString(pvApiCtx, piAddrmodalOptionAdr, &nbRow, &nbCol, &modalOptionAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 5); return 1; } if (nbRow * nbCol != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname, 5); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 5); return FALSE; } } /* Create the Java Object */ messageBoxID = createMessageBox(); /* Message */ setMessageBoxMultiLineMessage(messageBoxID, messageAdr, nbColMessage * nbRowMessage); freeAllocatedMatrixOfString(nbRowMessage, nbColMessage, messageAdr); /* Title */ if (titleAdr != NULL) { setMessageBoxTitle(messageBoxID, titleAdr[0]); freeAllocatedMatrixOfString(nbRow, nbCol, titleAdr); } else { setMessageBoxTitle(messageBoxID, _("Scilab Message")); } /* Icon */ if (iconAdr != NULL) { setMessageBoxIcon(messageBoxID, iconAdr[0]); freeAllocatedMatrixOfString(nbRow, nbCol, iconAdr); } /* Buttons */ if (buttonsTextAdr != NULL) { setMessageBoxButtonsLabels(messageBoxID, buttonsTextAdr, nbColButtons * nbRowButtons); freeAllocatedMatrixOfString(nbRowButtons, nbColButtons, buttonsTextAdr); } /* Modal ? */ if (modalOptionAdr != NULL) { setMessageBoxModal(messageBoxID, !stricmp(modalOptionAdr[0], "modal")); freeAllocatedMatrixOfString(nbRow, nbCol, modalOptionAdr); } else { setMessageBoxModal(messageBoxID, FALSE); } /* Display it and wait for a user input */ messageBoxDisplayAndWait(messageBoxID); /* Return the index of the button selected */ if (nbOutputArgument(pvApiCtx) == 1) { /* Read the user answer */ buttonNumber = getMessageBoxSelectedButton(messageBoxID); nbRow = 1; nbCol = 1; sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &buttonNumberAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } buttonNumberAdr[0] = buttonNumber; AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; } else { AssignOutputVariable(pvApiCtx, 1) = 0; } ReturnArguments(pvApiCtx); return TRUE; }
/*--------------------------------------------------------------------------*/ int sci_x_choose_modeless(char *fname, unsigned long fname_len) { SciErr sciErr; int* piAddritemsAdr = NULL; int* piAddrmessageAdr = NULL; int* piAddrbuttonLabelAdr = NULL; double* userValueAdr = NULL; int nbRow = 0, nbCol = 0; int nbRowItems = 0, nbColItems = 0; int messageBoxID = 0; char **itemsAdr = NULL; char **buttonLabelAdr = NULL; char **messageAdr = NULL; int userValue = 0; CheckInputArgument(pvApiCtx, 2, 3); CheckOutputArgument(pvApiCtx, 0, 1); if ((checkInputArgumentType(pvApiCtx, 1, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddritemsAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 1. if (getAllocatedMatrixOfString(pvApiCtx, piAddritemsAdr, &nbRowItems, &nbColItems, &itemsAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1); return 1; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 1); return FALSE; } if ((checkInputArgumentType(pvApiCtx, 2, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrmessageAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 2. if (getAllocatedMatrixOfString(pvApiCtx, piAddrmessageAdr, &nbRow, &nbCol, &messageAdr)) { freeAllocatedMatrixOfString(nbRowItems, nbColItems, itemsAdr); Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2); return 1; } } else { freeAllocatedMatrixOfString(nbRowItems, nbColItems, itemsAdr); Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 2); return FALSE; } /* Create the Java Object */ messageBoxID = createMessageBox(); /* Title is a default title */ setMessageBoxTitle(messageBoxID, _("Scilab Choose Message")); /* Message */ setMessageBoxMultiLineMessage(messageBoxID, messageAdr, nbCol * nbRow); /* ListBox Items */ setMessageBoxListBoxItems(messageBoxID, itemsAdr, nbColItems * nbRowItems); /* Modality */ setMessageBoxModal(messageBoxID, FALSE); freeAllocatedMatrixOfString(nbRowItems, nbColItems, itemsAdr); freeAllocatedMatrixOfString(nbRow, nbCol, messageAdr); if (nbInputArgument(pvApiCtx) == 3) { if (VarType(3) == sci_strings) { sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrbuttonLabelAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 3. if (getAllocatedMatrixOfString(pvApiCtx, piAddrbuttonLabelAdr, &nbRow, &nbCol, &buttonLabelAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3); return 1; } if (nbRow*nbCol != 1) { freeAllocatedMatrixOfString(nbRow, nbCol, buttonLabelAdr); Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 3); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 3); return FALSE; } setMessageBoxButtonsLabels(messageBoxID, buttonLabelAdr, nbCol * nbRow); freeAllocatedMatrixOfString(nbRow, nbCol, buttonLabelAdr); } /* Display it and wait for a user input */ messageBoxDisplayAndWait(messageBoxID); /* Read the user answer */ userValue = getMessageBoxSelectedItem(messageBoxID); nbRow = 1; nbCol = 1; sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &userValueAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } *userValueAdr = userValue; AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return TRUE; }
/*--------------------------------------------------------------------------*/ int sci_messagebox(char *fname,unsigned long fname_len) { int messageBoxID = 0; /* Used to read input arguments */ int nbRow = 0, nbCol = 0; int nbRowButtons = 0, nbColButtons = 0; int nbRowMessage = 0, nbColMessage = 0; char **buttonsTextAdr = 0; char **messageAdr = 0; char **titleAdr = 0; char **modalOptionAdr = 0; char **iconAdr = 0; /* Used to write output argument */ int buttonNumberAdr = 0; int buttonNumber = 0; CheckRhs(1,5); CheckLhs(0,1); /* Message to be displayed */ if (VarType(1) == sci_strings) { GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &nbRowMessage, &nbColMessage, &messageAdr); } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1); return FALSE; } /* Title to be displayed */ if (Rhs >= 2) { if (VarType(2) == sci_strings) { GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &titleAdr); if (nbRow*nbCol!=1) { Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2); return FALSE; } /* The title argument can be used to give the modal option */ if (isModalOption(getStringMatrixFromStack((size_t)titleAdr)[0])) { modalOptionAdr = titleAdr; titleAdr = NULL; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2); return FALSE; } } /* Icon to be displayed */ if (Rhs >= 3) { if (VarType(3) == sci_strings) { GetRhsVar(3,MATRIX_OF_STRING_DATATYPE,&nbRow,&nbCol,&iconAdr); if (nbRow*nbCol == 1) { /* The icon argument can be used to give the modal option or the buttons names */ if (isModalOption(getStringMatrixFromStack((size_t)iconAdr)[0])) { modalOptionAdr = (char **)iconAdr; iconAdr = NULL; } else if(!isIconName(getStringMatrixFromStack((size_t)iconAdr)[0])) { buttonsTextAdr = (char **)iconAdr; nbRowButtons = nbRow; nbColButtons = nbCol; iconAdr = NULL; } } else /* More than one string --> buttons names */ { buttonsTextAdr = (char **)iconAdr; nbRowButtons = nbRow; nbColButtons = nbCol; iconAdr = NULL; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string or a string vector expected.\n"), fname, 3); return FALSE; } } /* Buttons names */ if (Rhs >= 4) { if (VarType(4) == sci_strings) { GetRhsVar(4,MATRIX_OF_STRING_DATATYPE,&nbRowButtons,&nbColButtons,&buttonsTextAdr); if (nbRow*nbCol == 1) { /* The buttons names argument can be used to give the modal option */ if (isModalOption(getStringMatrixFromStack((size_t)buttonsTextAdr)[0])) { modalOptionAdr = buttonsTextAdr; buttonsTextAdr = NULL; } } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string or a string vector expected.\n"), fname, 3); return FALSE; } } /* Modal option */ if (Rhs == 5) { if (VarType(5) == sci_strings) { GetRhsVar(5,MATRIX_OF_STRING_DATATYPE,&nbRow,&nbCol,&modalOptionAdr); if (nbRow*nbCol != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 5); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 5); return FALSE; } } /* Create the Java Object */ messageBoxID = createMessageBox(); /* Message */ setMessageBoxMultiLineMessage(messageBoxID, getStringMatrixFromStack((size_t)messageAdr), nbColMessage*nbRowMessage); /* Title */ if (titleAdr != NULL) { setMessageBoxTitle(messageBoxID, getStringMatrixFromStack((size_t)titleAdr)[0]); } else { setMessageBoxTitle(messageBoxID, _("Scilab Message")); } /* Icon */ if (iconAdr != NULL) { setMessageBoxIcon(messageBoxID, getStringMatrixFromStack((size_t)iconAdr)[0]); } /* Buttons */ if (buttonsTextAdr != NULL) { setMessageBoxButtonsLabels(messageBoxID, getStringMatrixFromStack((size_t)buttonsTextAdr), nbColButtons*nbRowButtons); } /* Modal ? */ if (modalOptionAdr != NULL) { setMessageBoxModal(messageBoxID, !stricmp(getStringMatrixFromStack((size_t)modalOptionAdr)[0],"modal")); } else { setMessageBoxModal(messageBoxID, FALSE); } /* Display it and wait for a user input */ messageBoxDisplayAndWait(messageBoxID); /* Return the index of the button selected */ if (Lhs == 1) { /* Read the user answer */ buttonNumber = getMessageBoxSelectedButton(messageBoxID); nbRow = 1; nbCol = 1; CreateVar(Rhs+1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &buttonNumberAdr); *stk(buttonNumberAdr) = buttonNumber; LhsVar(1) = Rhs+1; } else { LhsVar(1) = 0; } PutLhsVar(); return TRUE; }
/*--------------------------------------------------------------------------*/ int sci_x_mdialog(char *fname, void* pvApiCtx) { SciErr sciErr; int* piAddrlabelsAdr = NULL; int* piAddrlineLabelsAdr = NULL; int* piAddrdefaultValuesAdr = NULL; int* piAddrcolumnLabelsAdr = NULL; double* emptyMatrixAdr = NULL; int nbRow = 0, nbCol = 0; int nbRowDefaultValues = 0, nbColDefaultValues = 0; int nbRowLineLabels = 0, nbColLineLabels = 0; int nbRowColumnLabels = 0, nbColColumnLabels = 0; int messageBoxID = 0; char **labelsAdr = NULL; char **lineLabelsAdr = NULL; char **columnLabelsAdr = NULL; char **defaultValuesAdr = NULL; int userValueSize = 0; char **userValue = NULL; CheckInputArgument(pvApiCtx, 3, 4); CheckOutputArgument(pvApiCtx, 0, 1); /* READ THE LABELS */ if ((checkInputArgumentType(pvApiCtx, 1, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrlabelsAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 1. if (getAllocatedMatrixOfString(pvApiCtx, piAddrlabelsAdr, &nbRow, &nbCol, &labelsAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1); return 1; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 1); return FALSE; } /* Create the Java Object */ messageBoxID = createMessageBox(); /* Title is a default title */ setMessageBoxTitle(messageBoxID, _("Scilab Multiple Values Request")); /* Message */ setMessageBoxMultiLineMessage(messageBoxID, labelsAdr, nbCol * nbRow); freeAllocatedMatrixOfString(nbRow, nbCol, labelsAdr); /* READ THE LINE LABELS */ if (checkInputArgumentType(pvApiCtx, 2, sci_strings)) { sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrlineLabelsAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 2. if (getAllocatedMatrixOfString(pvApiCtx, piAddrlineLabelsAdr, &nbRowLineLabels, &nbColLineLabels, &lineLabelsAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2); return 1; } if (nbRowLineLabels != 1 && nbColLineLabels != 1) { freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr); Scierror(999, _("%s: Wrong size for input argument #%d: Vector of strings expected.\n"), fname, 2); return FALSE; } setMessageBoxLineLabels(messageBoxID, lineLabelsAdr, nbColLineLabels * nbRowLineLabels); freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr); } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 2); return FALSE; } /* READ THE COLUMN LABELS or DEFAULT VALUES */ if (checkInputArgumentType(pvApiCtx, 3, sci_strings)) { if (nbInputArgument(pvApiCtx) == 3) { sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrdefaultValuesAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 3. if (getAllocatedMatrixOfString(pvApiCtx, piAddrdefaultValuesAdr, &nbRowDefaultValues, &nbColDefaultValues, &defaultValuesAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 3); return 1; } if ((nbRowDefaultValues != nbRowLineLabels) || (nbColDefaultValues != nbColLineLabels)) { freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr); Scierror(999, _("%s: Wrong size for input argument #%d: It must have same dimensions as argument #%d.\n"), fname, 3, 2); return FALSE; } setMessageBoxDefaultInput(messageBoxID, defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues); freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr); } else { sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrcolumnLabelsAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 3. if (getAllocatedMatrixOfString(pvApiCtx, piAddrcolumnLabelsAdr, &nbRowColumnLabels, &nbColColumnLabels, &columnLabelsAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 3); return 1; } if (nbRowColumnLabels != 1 && nbColColumnLabels != 1) { freeAllocatedMatrixOfString(nbRowColumnLabels, nbColColumnLabels, columnLabelsAdr); Scierror(999, _("%s: Wrong size for input argument #%d: Vector of strings expected.\n"), fname, 3); return FALSE; } setMessageBoxColumnLabels(messageBoxID, columnLabelsAdr, nbColColumnLabels * nbRowColumnLabels); freeAllocatedMatrixOfString(nbRowColumnLabels, nbColColumnLabels, columnLabelsAdr); } } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 3); return FALSE; } if (nbInputArgument(pvApiCtx) == 4) { /* READ DEFAULT VALUES */ if (checkInputArgumentType(pvApiCtx, 4, sci_strings)) { sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrdefaultValuesAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 4. // DO NOT FORGET TO RELEASE MEMORY via freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr). if (getAllocatedMatrixOfString(pvApiCtx, piAddrdefaultValuesAdr, &nbRowDefaultValues, &nbColDefaultValues, &defaultValuesAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 4); return 1; } if ((nbRowDefaultValues != nbRowLineLabels * nbColLineLabels) || (nbColDefaultValues != nbRowColumnLabels * nbColColumnLabels)) { Scierror(999, _("%s: Wrong size for input argument #%d: %d x %d matrix of strings expected.\n"), fname, 4, nbRowLineLabels * nbColLineLabels, nbRowColumnLabels * nbColColumnLabels); freeArrayOfString(defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues); return FALSE; } setMessageBoxDefaultInput(messageBoxID, defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues); freeArrayOfString(defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues); } else { Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), fname, 4); return FALSE; } } /* Display it and wait for a user input */ messageBoxDisplayAndWait(messageBoxID); /* Read the user answer */ userValueSize = getMessageBoxValueSize(messageBoxID); if (userValueSize == 0) { nbRow = 0; nbCol = 0; // YOU MUST REMOVE YOUR VARIABLE DECLARATION "int emptyMatrixAdr". sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &emptyMatrixAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } } else { userValue = getMessageBoxValue(messageBoxID); nbCol = 1; nbRowDefaultValues = nbColLineLabels * nbRowLineLabels; nbColDefaultValues = 1; if (nbInputArgument(pvApiCtx) == 4) { nbColDefaultValues = nbColColumnLabels * nbRowColumnLabels; } createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRowDefaultValues, nbColDefaultValues, userValue); delete[] userValue; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return TRUE; }
/*--------------------------------------------------------------------------*/ int sci_x_choose(char *fname, unsigned long fname_len) { int nbRow = 0, nbCol = 0; int nbRowItems = 0, nbColItems = 0; int messageBoxID = 0; char **itemsAdr = NULL; char **buttonLabelAdr = NULL; char **messageAdr = NULL; int userValueAdr = 0; int userValue = 0; CheckRhs(2, 3); CheckLhs(0, 1); if (VarType(1) == sci_strings) { GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &nbRowItems, &nbColItems, &itemsAdr); } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname); return FALSE; } if (VarType(2) == sci_strings) { GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &messageAdr); } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 2); return FALSE; } /* Create the Java Object */ messageBoxID = createMessageBox(); /* Title is a default title */ setMessageBoxTitle(messageBoxID, _("Scilab Choose Message")); /* Message */ setMessageBoxMultiLineMessage(messageBoxID, getStringMatrixFromStack((size_t)messageAdr), nbCol * nbRow); /* ListBox Items */ setMessageBoxListBoxItems(messageBoxID, getStringMatrixFromStack((size_t)itemsAdr), nbColItems * nbRowItems); /* Modality */ setMessageBoxModal(messageBoxID, TRUE); if (Rhs == 3) { if (VarType(3) == sci_strings) { GetRhsVar(3, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &buttonLabelAdr); if (nbRow * nbCol != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 3); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 3); return FALSE; } setMessageBoxButtonsLabels(messageBoxID, getStringMatrixFromStack((size_t)buttonLabelAdr), nbCol * nbRow); } /* Display it and wait for a user input */ messageBoxDisplayAndWait(messageBoxID); /* Read the user answer */ userValue = getMessageBoxSelectedItem(messageBoxID); nbRow = 1; nbCol = 1; CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &userValueAdr); *stk(userValueAdr) = (double)userValue; LhsVar(1) = Rhs + 1; PutLhsVar(); return TRUE; }