void SimulationExperimentViewInformationParametersWidget::updateParameters(double pCurrentPoint)
{
// Update our data
for (auto property : allProperties()) {
CellMLSupport::CellmlFileRuntimeParameter *parameter = mParameters.value(property);
if (parameter != nullptr) {
CellMLSupport::CellmlFileRuntimeParameter::Type parameterType = parameter->type();
if (parameterType == CellMLSupport::CellmlFileRuntimeParameter::Type::Voi) {
property->setDoubleValue(pCurrentPoint, false);
} else if ( (parameterType == CellMLSupport::CellmlFileRuntimeParameter::Type::Constant)
|| (parameterType == CellMLSupport::CellmlFileRuntimeParameter::Type::ComputedConstant)) {
property->setDoubleValue(mSimulation->data()->constants()[parameter->index()], false);
} else if (parameterType == CellMLSupport::CellmlFileRuntimeParameter::Type::Rate) {
property->setDoubleValue(mSimulation->data()->rates()[parameter->index()], false);
} else if (parameterType == CellMLSupport::CellmlFileRuntimeParameter::Type::State) {
property->setDoubleValue(mSimulation->data()->states()[parameter->index()], false);
} else if (parameterType == CellMLSupport::CellmlFileRuntimeParameter::Type::Algebraic) {
property->setDoubleValue(mSimulation->data()->algebraic()[parameter->index()], false);
} else if (parameterType == CellMLSupport::CellmlFileRuntimeParameter::Type::Data) {
property->setDoubleValue(parameter->data()[parameter->index()], false);
}
}
}
// Check whether any of our properties has actually been modified
mSimulation->data()->checkForModifications();
}
void SimulationExperimentViewInformationParametersWidget::updateExtraInfos()
{
// Update the extra info of all our properties
for (auto property : allProperties()) {
CellMLSupport::CellmlFileRuntimeParameter *parameter = mParameters.value(property);
if (parameter != nullptr) {
QString extraInfo = QString();
CellMLSupport::CellmlFileRuntimeParameter::Type parameterType = parameter->type();
if (parameterType == CellMLSupport::CellmlFileRuntimeParameter::Type::Voi) {
extraInfo = tr("variable of integration");
} else if (parameterType == CellMLSupport::CellmlFileRuntimeParameter::Type::Constant) {
extraInfo = tr("constant");
} else if (parameterType == CellMLSupport::CellmlFileRuntimeParameter::Type::ComputedConstant) {
extraInfo = tr("computed constant");
} else if (parameterType == CellMLSupport::CellmlFileRuntimeParameter::Type::Rate) {
extraInfo = tr("rate");
} else if (parameterType == CellMLSupport::CellmlFileRuntimeParameter::Type::State) {
extraInfo = tr("state");
} else if (parameterType == CellMLSupport::CellmlFileRuntimeParameter::Type::Algebraic) {
extraInfo = tr("algebraic");
} else if (parameterType == CellMLSupport::CellmlFileRuntimeParameter::Type::Data) {
extraInfo = tr("data");
}
property->setExtraInfo(extraInfo);
}
}
}
Data(Data& data)
: checked_(data.checked_), text_(data.text_), slider_(data.slider_), vector_(nullptr), color_(data.color_),
context_(data.context_)
{
auto& definitionManager = *context_.queryInterface<IDefinitionManager>();
vector_ = GenericObject::create(definitionManager);
auto definition = data.vector_.getDefinition(definitionManager);
for (auto property : definition->allProperties())
{
const char* name = property->getName();
vector_->set(name, definition->bindProperty(name, data.vector_).getValue());
}
}
void SimulationExperimentViewInformationSolversWidget::retranslateUi()
{
// Update our property names
mOdeSolverData->solversProperty()->setName(tr("ODE solver"));
mOdeSolverData->solversListProperty()->setName(tr("Name"));
mOdeSolverData->solversListProperty()->setEmptyListValue(tr("None available"));
if (mNlaSolverData != nullptr) {
mNlaSolverData->solversProperty()->setName(tr("NLA solver"));
mNlaSolverData->solversListProperty()->setName(tr("Name"));
mNlaSolverData->solversListProperty()->setEmptyListValue(tr("None available"));
}
// Update the name of our various properties, should they have a description
// associated with them
// Note: this is effectively to have the description of our solvers'
// properties properly updated...
for (auto property : allProperties()) {
if (mDescriptions.contains(property)) {
// The property has a description associated with it, so retrieve
// the version, if any, which corresponds to our current locale
Descriptions descriptions = mDescriptions.value(property);
QString description = descriptions.value(Core::locale());
if (description.isEmpty()) {
// No description exists for the current locale, so retrieve the
// English description (which, hopefully, exists)
description = descriptions.value("en");
}
// Set the name of the property to the description
property->setName(description);
}
}
// Default retranslation
// Note: we must do it last since we set the empty list value of some
// properties above...
PropertyEditorWidget::retranslateUi();
}
nsresult
GRE_GetGREPathWithProperties(const GREVersionRange *versions,
PRUint32 versionsLength,
const GREProperty *properties,
PRUint32 propertiesLength,
char *aBuffer, PRUint32 aBufLen)
{
#ifdef TARGET_XPCOM_ABI
// append the ABI to the properties to match only binary
// compatible GREs
static const GREProperty kExtraProperty =
{ "abi", TARGET_XPCOM_ABI };
nsAutoArrayPtr<GREProperty> allProperties(new GREProperty[propertiesLength + 1]);
if (!allProperties)
return NS_ERROR_OUT_OF_MEMORY;
for (PRUint32 i=0; i<propertiesLength; i++) {
allProperties[i].property = properties[i].property;
allProperties[i].value = properties[i].value;
}
allProperties[propertiesLength].property = kExtraProperty.property;
allProperties[propertiesLength].value = kExtraProperty.value;
PRUint32 allPropertiesLength = propertiesLength + 1;
#else
const GREProperty *allProperties = properties;
PRUint32 allPropertiesLength = propertiesLength;
#endif
// if GRE_HOME is in the environment, use that GRE
const char* env = getenv("GRE_HOME");
if (env && *env) {
char p[MAXPATHLEN];
snprintf(p, sizeof(p), "%s" XPCOM_FILE_PATH_SEPARATOR XPCOM_DLL, env);
p[sizeof(p) - 1] = '\0';
#if XP_UNIX
if (realpath(p, aBuffer))
return NS_OK;
#elif WINCE
if (p[0] != '\\')
{
WCHAR dir[MAX_PATH];
WCHAR path[MAX_PATH];
MultiByteToWideChar(CP_ACP, 0, p, -1, path, MAX_PATH);
_wfullpath(dir,path,MAX_PATH);
WideCharToMultiByte(CP_ACP, 0, dir, -1, aBuffer, MAX_PATH, NULL, NULL);
}
else {
strcpy(aBuffer, p);
}
return NS_OK;
#elif XP_WIN
if (_fullpath(aBuffer, p, aBufLen))
return NS_OK;
#elif XP_OS2
// realpath on OS/2 returns a unix-ized path, so re-native-ize
if (realpath(p, aBuffer)) {
for (char* ptr = strchr(aBuffer, '/'); ptr; ptr = strchr(ptr, '/'))
*ptr = '\\';
return NS_OK;
}
#elif XP_BEOS
BPath path;
status_t result;
result = path.SetTo(p,0,true);
if (result == B_OK)
{
sprintf(aBuffer, path.Path());
return NS_OK;
}
#else
// hope for the best
// xxxbsmedberg: other platforms should have a "make absolute" function
#endif
if (strlen(p) >= aBufLen)
return NS_ERROR_FILE_NAME_TOO_LONG;
strcpy(aBuffer, p);
return NS_OK;
}
// the Gecko bits that sit next to the application or in the LD_LIBRARY_PATH
env = getenv("USE_LOCAL_GRE");
if (env && *env) {
*aBuffer = nsnull;
return NS_OK;
}
#ifdef XP_MACOSX
aBuffer[0] = '\0';
// Check the bundle first, for <bundle>/Contents/Frameworks/XUL.framework/libxpcom.dylib
CFBundleRef appBundle = CFBundleGetMainBundle();
if (appBundle) {
CFURLRef fwurl = CFBundleCopyPrivateFrameworksURL(appBundle);
CFURLRef absfwurl = nsnull;
if (fwurl) {
absfwurl = CFURLCopyAbsoluteURL(fwurl);
CFRelease(fwurl);
}
if (absfwurl) {
CFURLRef xulurl =
CFURLCreateCopyAppendingPathComponent(NULL, absfwurl,
CFSTR(GRE_FRAMEWORK_NAME),
PR_TRUE);
if (xulurl) {
CFURLRef xpcomurl =
CFURLCreateCopyAppendingPathComponent(NULL, xulurl,
CFSTR("libxpcom.dylib"),
PR_FALSE);
if (xpcomurl) {
char tbuffer[MAXPATHLEN];
if (CFURLGetFileSystemRepresentation(xpcomurl, PR_TRUE,
(UInt8*) tbuffer,
sizeof(tbuffer)) &&
access(tbuffer, R_OK | X_OK) == 0) {
if (!realpath(tbuffer, aBuffer)) {
aBuffer[0] = '\0';
}
}
CFRelease(xpcomurl);
}
CFRelease(xulurl);
}
CFRelease(absfwurl);
}
}
if (aBuffer[0])
return NS_OK;
// Check ~/Library/Frameworks/XUL.framework/Versions/<version>/libxpcom.dylib
const char *home = getenv("HOME");
if (home && *home && GRE_FindGREFramework(home,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
// Check /Library/Frameworks/XUL.framework/Versions/<version>/libxpcom.dylib
if (GRE_FindGREFramework("",
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
#elif defined(XP_UNIX)
env = getenv("MOZ_GRE_CONF");
if (env && GRE_GetPathFromConfigFile(env,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
env = getenv("HOME");
if (env && *env) {
char buffer[MAXPATHLEN];
// Look in ~/.gre.config
snprintf(buffer, sizeof(buffer),
"%s" XPCOM_FILE_PATH_SEPARATOR GRE_CONF_NAME, env);
if (GRE_GetPathFromConfigFile(buffer,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
// Look in ~/.gre.d/*.conf
snprintf(buffer, sizeof(buffer),
"%s" XPCOM_FILE_PATH_SEPARATOR GRE_USER_CONF_DIR, env);
if (GRE_GetPathFromConfigDir(buffer,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
}
// Look for a global /etc/gre.conf file
if (GRE_GetPathFromConfigFile(GRE_CONF_PATH,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
// Look for a group of config files in /etc/gre.d/
if (GRE_GetPathFromConfigDir(GRE_CONF_DIR,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
#elif defined(XP_BEOS)
env = getenv("MOZ_GRE_CONF");
if (env && GRE_GetPathFromConfigFile(env,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
char p[MAXPATHLEN];
if (find_directory(B_USER_SETTINGS_DIRECTORY, 0, 0, p, MAXPATHLEN)) {
char buffer[MAXPATHLEN];
// Look in B_USER_SETTINGS_DIRECTORY/gre.config
snprintf(buffer, sizeof(buffer),
"%s" XPCOM_FILE_PATH_SEPARATOR GRE_CONF_NAME, p);
if (GRE_GetPathFromConfigFile(buffer,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
// Look in B_USER_SETTINGS_DIRECTORY/gre.d/*.conf
snprintf(buffer, sizeof(buffer),
"%s" XPCOM_FILE_PATH_SEPARATOR GRE_CONF_DIR, p);
if (GRE_GetPathFromConfigDir(buffer,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
}
// Hope Zeta OS and Haiku OS multiuser versions will respect BeBook,
// for BeOS R5 COMMON and USER are equal
if (find_directory(B_COMMON_SETTINGS_DIRECTORY, 0, 0, p, MAXPATHLEN)) {
char buffer[MAXPATHLEN];
// Look for a B_COMMON_SETTINGS_DIRECTORY/gre.conf file
snprintf(buffer, sizeof(buffer),
"%s" XPCOM_FILE_PATH_SEPARATOR GRE_CONF_PATH, p);
if (GRE_GetPathFromConfigFile(buffer,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
// Look for a group of config files in B_COMMON_SETTINGS_DIRECTORY/gre.d/
snprintf(buffer, sizeof(buffer),
"%s" XPCOM_FILE_PATH_SEPARATOR GRE_CONF_DIR, p);
if (GRE_GetPathFromConfigDir(buffer,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
}
#elif defined(XP_WIN)
HKEY hRegKey = NULL;
// A couple of key points here:
// 1. Note the usage of the "Software\\mozilla.org\\GRE" subkey - this allows
// us to have multiple versions of GREs on the same machine by having
// subkeys such as 1.0, 1.1, 2.0 etc. under it.
// 2. In this sample below we're looking for the location of GRE version 1.2
// i.e. we're compatible with GRE 1.2 and we're trying to find it's install
// location.
//
// Please see http://www.mozilla.org/projects/embedding/GRE.html for
// more info.
//
if (::RegOpenKeyExW(HKEY_CURRENT_USER, GRE_WIN_REG_LOC, 0,
KEY_READ, &hRegKey) == ERROR_SUCCESS) {
PRBool ok = GRE_GetPathFromRegKey(hRegKey,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen);
::RegCloseKey(hRegKey);
if (ok)
return NS_OK;
}
if (::RegOpenKeyExW(HKEY_LOCAL_MACHINE, GRE_WIN_REG_LOC, 0,
KEY_ENUMERATE_SUB_KEYS, &hRegKey) == ERROR_SUCCESS) {
PRBool ok = GRE_GetPathFromRegKey(hRegKey,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen);
::RegCloseKey(hRegKey);
if (ok)
return NS_OK;
}
#endif
return NS_ERROR_FAILURE;
}
