IKnown * xContainer::AddService(QString id)
{
QListIterator<QString> ipath(pluginsPaths);
XServiceInfo* sinfo = NULL;
while (sinfo== NULL && ipath.hasNext())
{
sinfo = pluginMng.GetPlugin(ipath.next(),id);
}
if(sinfo == NULL)
{
return NULL;
}
QString sid = xPluginMng::GetSID(id);
IKnown* sv= NULL;
sv= sinfo->GetPluginService(sid);
RunningServices[sid] =sv;
return RunningServices[sid];
}
QModelIndex FileItemModel::indexOf(const File& file, const QModelIndex& start)
{
int rc = rowCount(start);
QString ipath(file.getPath().toString().get());
for (int i = 0 ; i < rc ; i++) {
QModelIndex child = index(i, 0, start);
StaticFile* sf = static_cast<StaticFile*>(child.internalPointer());
if (sf->getFile() == file) {
return child;
} else {
if (file.isChildOf(sf->getFile(), true)) {
return indexOf(file, child);
}
}
}
return QModelIndex();
}
const fs::path&
module_runtime_path(const std::string& dtype)
{
path_map& paths(module_paths());
path_map::iterator ipath(paths.find(dtype));
// Is this a valid dtype?
if (ipath == paths.end())
{
boost::format fmt("Invalid runtime path type “%1%”");
fmt % dtype;
throw std::logic_error(fmt.str());
}
Module& module = ipath->second;
// Return cached result if previously determined.
if(!module.realpath.empty())
return module.realpath;
// dtype set explicitly in environment.
if (getenv(module.envvar.c_str()))
{
fs::path dir(getenv(module.envvar.c_str()));
if (validate_path(dir))
{
module.realpath = boost::filesystem::canonical(dir);
return module.realpath;
}
}
// Full module path in environment + relative component
if (getenv(module.module_envvar.c_str()))
{
fs::path home(getenv(module.module_envvar.c_str()));
home /= module.relpath;
if (validate_path(home))
{
module.realpath = boost::filesystem::canonical(home);
return module.realpath;
}
}
// Full root path in environment + relative component
if (getenv(module.root_envvar.c_str()))
{
fs::path home(getenv(module.root_envvar.c_str()));
home /= module.relpath;
if (validate_path(home))
{
module.realpath = boost::filesystem::canonical(home);
return module.realpath;
}
}
// Full prefix is available only when configured explicitly.
if (validate_path(module.install_prefix))
{
// Full specific path.
if (validate_path(module.abspath))
{
module.realpath = boost::filesystem::canonical(module.abspath);
return module.realpath;
}
// Full root path + relative component
fs::path home(module.install_prefix);
home /= module.relpath;
if (validate_path(home))
{
module.realpath = boost::filesystem::canonical(home);
return module.realpath;
}
}
else
{
fs::path module_lib_path;
if (module.module_path)
{
module_lib_path = module.module_path();
}
if (module_lib_path.has_parent_path())
{
fs::path moduledir(module_lib_path.parent_path());
bool match = true;
fs::path libdir(module.shlibpath);
while(!libdir.empty())
{
if (libdir.filename() == moduledir.filename())
{
libdir = libdir.parent_path();
moduledir = moduledir.parent_path();
}
else
{
match = false;
break;
}
}
if (match && validate_path(moduledir))
{
moduledir /= module.relpath;
if (validate_path(moduledir))
{
module.realpath = boost::filesystem::canonical(moduledir);
return module.realpath;
}
}
}
}
boost::format fmt("Could not determine Bio-Formats runtime path for “%1%” directory");
fmt % dtype;
throw std::runtime_error(fmt.str());
}
void saveSettingsFile (const std::string& file, CategorySettingValueMap& settings)
{
// No options have been written to the file yet.
CategorySettingStatusMap written;
for (CategorySettingValueMap::iterator it = settings.begin(); it != settings.end(); ++it) {
written[it->first] = false;
}
// Have we substantively changed the settings file?
bool changed = false;
// Were there any lines at all in the file?
bool existing = false;
// The category/section we're currently in.
std::string currentCategory;
// Open the existing settings.cfg file to copy comments. This might not be the same file
// as the output file if we're copying the setting from the default settings.cfg for the
// first time. A minor change in API to pass the source file might be in order here.
boost::filesystem::ifstream istream;
boost::filesystem::path ipath(file);
istream.open(ipath);
// Create a new string stream to write the current settings to. It's likely that the
// input file and the output file are the same, so this stream serves as a temporary file
// of sorts. The setting files aren't very large so there's no performance issue.
std::stringstream ostream;
// For every line in the input file...
while (!istream.eof() && !istream.fail()) {
std::string line;
std::getline(istream, line);
// The current character position in the line.
size_t i = 0;
// Don't add additional newlines at the end of the file.
if (istream.eof()) continue;
// Copy entirely blank lines.
if (!skipWhiteSpace(i, line)) {
ostream << line << std::endl;
continue;
}
// There were at least some comments in the input file.
existing = true;
// Copy comments.
if (line[i] == '#') {
ostream << line << std::endl;
continue;
}
// Category heading.
if (line[i] == '[') {
size_t end = line.find(']', i);
// This should never happen unless the player edited the file while playing.
if (end == std::string::npos) {
ostream << "# unterminated category: " << line << std::endl;
changed = true;
continue;
}
// Ensure that all options in the current category have been written.
for (CategorySettingStatusMap::iterator mit = written.begin(); mit != written.end(); ++mit) {
if (mit->second == false && mit->first.first == currentCategory) {
std::cout << "Added new setting: [" << currentCategory << "] "
<< mit->first.second << " = " << settings[mit->first] << std::endl;
ostream << mit->first.second << " = " << settings[mit->first] << std::endl;
mit->second = true;
changed = true;
}
}
// Update the current category.
currentCategory = line.substr(i+1, end - (i+1));
boost::algorithm::trim(currentCategory);
// Write the (new) current category to the file.
ostream << "[" << currentCategory << "]" << std::endl;
//std::cout << "Wrote category: " << currentCategory << std::endl;
// A setting can apparently follow the category on an input line. That's rather
// inconvenient, since it makes it more likely to have duplicative sections,
// which our algorithm doesn't like. Do the best we can.
i = end+1;
}
// Truncate trailing whitespace, since we're changing the file anayway.
if (!skipWhiteSpace(i, line))
continue;
// If we've found settings before the first category, something's wrong. This
// should never happen unless the player edited the file while playing, since
// the loadSettingsFile() logic rejects it.
if (currentCategory.empty()) {
ostream << "# empty category name: " << line << std::endl;
changed = true;
continue;
}
// Which setting was at this location in the input file?
size_t settingEnd = line.find('=', i);
// This should never happen unless the player edited the file while playing.
if (settingEnd == std::string::npos) {
ostream << "# unterminated setting name: " << line << std::endl;
changed = true;
continue;
}
std::string setting = line.substr(i, (settingEnd-i));
boost::algorithm::trim(setting);
// Get the existing value so we can see if we've changed it.
size_t valueBegin = settingEnd+1;
std::string value = line.substr(valueBegin);
boost::algorithm::trim(value);
// Construct the setting map key to determine whether the setting has already been
// written to the file.
CategorySetting key = std::make_pair(currentCategory, setting);
CategorySettingStatusMap::iterator finder = written.find(key);
// Settings not in the written map are definitely invalid. Currently, this can only
// happen if the player edited the file while playing, because loadSettingsFile()
// will accept anything and pass it along in the map, but in the future, we might
// want to handle invalid settings more gracefully here.
if (finder == written.end()) {
ostream << "# invalid setting: " << line << std::endl;
changed = true;
continue;
}
// Write the current value of the setting to the file. The key must exist in the
// settings map because of how written was initialized and finder != end().
ostream << setting << " = " << settings[key] << std::endl;
// Mark that setting as written.
finder->second = true;
// Did we really change it?
if (value != settings[key]) {
std::cout << "Changed setting: [" << currentCategory << "] "
<< setting << " = " << settings[key] << std::endl;
changed = true;
}
// No need to write the current line, because we just emitted a replacement.
// Curiously, it appears that comments at the ends of lines with settings are not
// allowed, and the comment becomes part of the value. Was that intended?
}
// We're done with the input stream file.
istream.close();
// Ensure that all options in the current category have been written. We must complete
// the current category at the end of the file before moving on to any new categories.
for (CategorySettingStatusMap::iterator mit = written.begin(); mit != written.end(); ++mit) {
if (mit->second == false && mit->first.first == currentCategory) {
std::cout << "Added new setting: [" << mit->first.first << "] "
<< mit->first.second << " = " << settings[mit->first] << std::endl;
ostream << mit->first.second << " = " << settings[mit->first] << std::endl;
mit->second = true;
changed = true;
}
}
// If there was absolutely nothing in the file (or more likely the file didn't
// exist), start the newly created file with a helpful comment.
if (!existing) {
ostream << "# This is the OpenMW user 'settings.cfg' file. This file only contains" << std::endl;
ostream << "# explicitly changed settings. If you would like to revert a setting" << std::endl;
ostream << "# to its default, simply remove it from this file. For available" << std::endl;
ostream << "# settings, see the file 'settings-default.cfg' or the documentation at:" << std::endl;
ostream << "#" << std::endl;
ostream << "# https://wiki.openmw.org/index.php?title=Settings" << std::endl;
}
// We still have one more thing to do before we're completely done writing the file.
// It's possible that there are entirely new categories, or that the input file had
// disappeared completely, so we need ensure that all settings are written to the file
// regardless of those issues.
for (CategorySettingStatusMap::iterator mit = written.begin(); mit != written.end(); ++mit) {
// If the setting hasn't been written yet.
if (mit->second == false) {
// If the catgory has changed, write a new category header.
if (mit->first.first != currentCategory) {
currentCategory = mit->first.first;
std::cout << "Created new setting section: " << mit->first.first << std::endl;
ostream << std::endl;
ostream << "[" << currentCategory << "]" << std::endl;
}
std::cout << "Added new setting: [" << mit->first.first << "] "
<< mit->first.second << " = " << settings[mit->first] << std::endl;
// Then write the setting. No need to mark it as written because we're done.
ostream << mit->first.second << " = " << settings[mit->first] << std::endl;
changed = true;
}
}
// Now install the newly written file in the requested place.
if (changed) {
std::cout << "Updating settings file: " << ipath << std::endl;
boost::filesystem::ofstream ofstream;
ofstream.open(ipath);
ofstream << ostream.rdbuf();
ofstream.close();
}
}
