Skies::Skies(const char* basename, bool force)
{
char fn[256];
sprintf(fn,"World\\Maps\\%s\\lights.lit",basename);
numSkies = 0;
cs = -1;
stars = 0;
bool succ = loadFrom(fn, false);
if (!succ && force) loadFrom("World\\Maps\\Kalimdor\\lights.lit", true);
}
bool loadFrom(BinStore *s, StoredPowerCategory &target)
{
bool ok = true;
s->prepare();
ok &= s->read(target.name);
ok &= s->read(target.disp_name);
ok &= s->read(target.disp_help);
ok &= s->read(target.disp_short_help);
// Unused/unset field 'Available'
ok &= s->prepare_nested(); // will update the file size left
assert(ok);
if(s->end_encountered())
return ok;
QString _name;
while(s->nesting_name(_name))
{
s->nest_in();
if(_name.compare("PowerSet")==0) {
target.m_PowerSets.emplace_back();
ok &= loadFrom(s,target.m_PowerSets.back());
} else
assert(!"unknown field referenced.");
s->nest_out();
}
return ok;
}
bool loadFrom(BinStore *s, Parse_PowerSet &target)
{
bool ok = true;
s->prepare();
ok &= s->read(target.Name);
ok &= s->read(target.DisplayName);
ok &= s->read(target.DisplayHelp);
ok &= s->read(target.DisplayShortHelp);
ok &= s->read(target.IconName);
ok &= s->read(target.Available);
ok &= s->prepare_nested(); // will update the file size left
assert(ok);
if(s->end_encountered())
return ok;
QString _name;
while(s->nesting_name(_name))
{
s->nest_in();
if(_name.compare("Power")==0) {
target.m_Powers.emplace_back();
ok &= loadFrom(s,target.m_Powers.back());
} else
assert(!"unknown field referenced.");
s->nest_out();
}
return ok;
}
KCFleet::KCFleet(const QVariantMap &data, int loadId, KCClient *parent) :
KCGameObject(parent) {
connect(this, SIGNAL(missionCompleted()), parent, SLOT(onMissionCompleted()));
connect(&missionTimer, SIGNAL(timeout()), this, SLOT(onMissionTimeout()));
missionTimer.setSingleShot(true);
loadFrom(data, loadId);
}
Sprite::Sprite(const string& path_) :
sdlTexture(nullptr),
width(0),
height(0)
{
loadFrom(path_);
}
bool OsmAnd::MapStylesPresets::loadFrom(const QString& fileName)
{
QFile file(fileName);
if(!file.open(QIODevice::ReadOnly | QIODevice::Text))
return false;
const auto success = loadFrom(file);
file.close();
return success;
}
bool SettingsManager::load(const ArgumentParser * args) {
if(args != NULL) {
QString altSettingsFileName = args->getValue("f");
if(altSettingsFileName.length() > 0) {
QByteArray fileNameBytes = altSettingsFileName.toLocal8Bit();
printf("Loading settings from alternate file: %s\n", fileNameBytes.data());
bool loadedSettings = loadFrom(altSettingsFileName);
if(!loadedSettings) {
printf("Failed to load settings from alt settings file: %s\n", fileNameBytes.data());
}
return loadedSettings;
}
}
return loadFrom(defaultSettingsFileName);
}
Image ImageFileFormat::loadFrom (const void* rawData, const size_t numBytes)
{
if (rawData != nullptr && numBytes > 4)
{
MemoryInputStream stream (rawData, numBytes, false);
return loadFrom (stream);
}
return Image::null;
}
Result FileBasedDocument::loadFromUserSpecifiedFile (const bool showMessageOnFailure)
{
FileChooser fc (openFileDialogTitle,
getLastDocumentOpened(),
fileWildcard);
if (fc.browseForFileToOpen())
return loadFrom (fc.getResult(), showMessageOnFailure);
return Result::fail (TRANS("User cancelled"));
}
Image ImageFileFormat::loadFrom (const File& file)
{
FileInputStream stream (file);
if (stream.openedOk())
{
BufferedInputStream b (stream, 8192);
return loadFrom (b);
}
return Image::null;
}
rulesSystem::rulesSystem(string filename)
{
loadFrom(filename);
/*if (m_filename.error()) {
throw Exception(30,"Unable to open file " + m_filename.get_filename() + ". (class rulesSystem, rulesSystem(string))");
}*/
}
Sprite::Sprite(const std::string& path_) :
sdlTexture(nullptr),
width(0),
height(0),
path(path_),
flipHorizontal(false)
{
loadFrom(this->path);
setBlendMode(SDL_BLENDMODE_BLEND);
setAlpha(255);
}
bool OsmAnd::FavoriteLocationsGpxCollection_P::loadFrom(const QString& filename)
{
QFile file(filename);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
return false;
QXmlStreamReader reader(&file);
const bool ok = loadFrom(reader);
file.close();
return ok;
}
bool SLAVLogic::needToOverwriteBaseInstall() {
// case 1: we run from temp installation and CurrentChannel != BaseChannel || CurrentVersion>=BaseVersion
QString apppath = qApp->applicationDirPath();
QString workdir = QDir::currentPath();
if(workdir.endsWith("install_temp")) {
QDir parent_dir(workdir);
if(!parent_dir.cdUp()) {
qDebug() << "Cd up from temp install dir fails";
return false;
}
AppVersionManifest parent_dir_manifest;
if(QFile::exists(parent_dir.filePath("project.manifest"))) {
QFile manifest_contents(parent_dir.filePath("project.manifest"));
if(!manifest_contents.open(QFile::ReadOnly)) {
qDebug() << "Cannot open parent dir manifest";
return false;
}
if(!loadFrom(parent_dir_manifest,manifest_contents.readAll())) {
qDebug() << "Failed to parse manifest contents";
parent_dir_manifest.buildFromFileSystem(parent_dir.path());
}
}
}
AppVersionManifest current_manifest;
QString manifest_path = workdir + "/project.manifest";
if(QFile::exists(manifest_path)) {
QFile manifest_contents(manifest_path);
if(!manifest_contents.open(QFile::ReadOnly)) {
qDebug() << "Cannot open parent dir manifest";
return false;
}
if(!loadFrom(current_manifest,manifest_contents.readAll())) {
qDebug() << "Failed to parse manifest contents";
}
}
current_manifest.buildFromFileSystem(workdir);
return false;
}
void SLAVLogic::onManifestReceived(const QString &manifest_url,const QString &manifestData)
{
AppVersionManifest pm;
bool load_res = loadFrom(pm,manifestData);
Q_UNUSED(load_res);
// we've got a project manifest, perform work based on the manifest type.
if(manifest_url.contains("slav.manifest"))
{
// Check if we need to update ourselves
if(*m_current_manifest!=pm)
{
emit needUpdate(new AppVersionManifest(pm),"Changed stuff");
}
}
}
// Initializes the nav data with a GalEphemeris
Rinex3NavData::Rinex3NavData(const GalEphemeris& galeph)
{
loadFrom(dynamic_cast<const OrbitEph*>(&galeph));
Toc = static_cast<GALWeekSecond>(galeph.ctToc).getSOW();
Toe = static_cast<GALWeekSecond>(galeph.ctToe).getSOW();
HOWtime = galeph.HOWtime;
weeknum = static_cast<GPSWeekSecond>(galeph.transmitTime).getWeek();
IODnav = galeph.IODnav;
health = galeph.health;
accuracy = galeph.accuracy;
Tgd = galeph.Tgda;
Tgd2 = galeph.Tgdb;
datasources = galeph.datasources;
}
void SLAVLogic::start()
{
if(needToOverwriteBaseInstall())
{
createBackupIfNeeded();
copyFilesOverBase();
//restartBaseInstall();
}
QFile slav_manifest_file("./slav.manifest");
if(slav_manifest_file.open(QFile::ReadOnly))
{
loadFrom(slav_manifest,slav_manifest_file.readAll());
}
m_ui_impl->show();
m_serv_conn->onRequestAppData();
}
bool GraphWidget::loadQuestion()
{
//box: do you want to load a file?
int reponse = QMessageBox::question(this, "Map", "Do you want to load an existing map ?", QMessageBox ::Yes | QMessageBox::No);
if (reponse == QMessageBox::No)
{
initializeCells(scene());
return false;
}
//choose file
QString fichier = QFileDialog::getOpenFileName(this, "Open an existing map", QString(), "Text (*.txt)");
//if success
if(loadFrom(fichier))
return true;
return false;
}
EXPORT(sqInt) primitiveSynthesizeFrameIntoStartingAt(void) {
float * aKlattFrame;
short * buffer;
sqInt bufferOop;
sqInt rcvr;
sqInt startIndex;
sqInt oop;
sqInt oop1;
/* begin checkedFloatPtrOf: */
oop = interpreterProxy->stackValue(2);
interpreterProxy->success(interpreterProxy->isWords(oop));
if (interpreterProxy->failed()) {
aKlattFrame = 0;
goto l1;
}
aKlattFrame = ((float *) (interpreterProxy->firstIndexableField(oop)));
l1: /* end checkedFloatPtrOf: */;
/* begin checkedShortPtrOf: */
oop1 = (bufferOop = interpreterProxy->stackValue(1));
interpreterProxy->success(interpreterProxy->isWords(oop1));
if (interpreterProxy->failed()) {
buffer = 0;
goto l2;
}
buffer = ((short *) (interpreterProxy->firstIndexableField(oop1)));
l2: /* end checkedShortPtrOf: */;
startIndex = interpreterProxy->stackIntegerValue(0);
if (interpreterProxy->failed()) {
return null;
}
rcvr = interpreterProxy->stackObjectValue(3);
if (!(loadFrom(rcvr))) {
return null;
}
interpreterProxy->success(((interpreterProxy->stSizeOf(bufferOop)) * 2) >= samplesPerFrame);
if (interpreterProxy->failed()) {
return null;
}
synthesizeFrameintostartingAt(aKlattFrame, buffer, startIndex);
if (!(saveTo(rcvr))) {
return null;
}
interpreterProxy->pop(3);
return null;
}
// Initializes the nav data with a BDSEphemeris
Rinex3NavData::Rinex3NavData(const BDSEphemeris& bdseph)
{
loadFrom(dynamic_cast<const OrbitEph*>(&bdseph));
Toc = static_cast<BDSWeekSecond>(bdseph.ctToc).getSOW();
Toe = static_cast<BDSWeekSecond>(bdseph.ctToe).getSOW();
HOWtime = bdseph.HOWtime;
weeknum = static_cast<BDSWeekSecond>(bdseph.transmitTime).getWeek();
//Cis = -Cis; // really? Rinex3.02 A13 misprint?
IODC = bdseph.IODC;
IODE = bdseph.IODE;
health = bdseph.health;
accuracy = bdseph.accuracy;
Tgd = bdseph.Tgd13;
Tgd2 = bdseph.Tgd23;
}
bool loadFrom(BinStore *s, AllNpcs_Data &target)
{
s->prepare();
bool ok = s->prepare_nested();
if(s->end_encountered())
return ok;
QByteArray _name;
while(s->nesting_name(_name))
{
s->nest_in();
if("NPC"==_name) {
target.emplace_back();
ok &= loadFrom(s,target.back());
} else
assert(!"unknown field referenced.");
s->nest_out();
}
assert(ok);
return ok;
}
bool loadFrom(BinStore *s, AllPowerCategories &target)
{
bool ok = true;
s->prepare();
ok &= s->prepare_nested(); // will update the file size left
assert(ok);
if(s->end_encountered())
return ok;
QString _name;
while(s->nesting_name(_name))
{
s->nest_in();
if(_name.compare("PowerCategory")==0) {
target.m_categories.emplace_back();
ok &= loadFrom(s,target.m_categories.back());
} else
assert(!"unknown field referenced.");
s->nest_out();
}
return ok;
}
// Initializes the nav data with a GPSEphemeris
Rinex3NavData::Rinex3NavData(const GPSEphemeris& gpseph)
{
loadFrom(dynamic_cast<const OrbitEph*>(&gpseph));
Toc = static_cast<GPSWeekSecond>(gpseph.ctToc).getSOW();
Toe = static_cast<GPSWeekSecond>(gpseph.ctToe).getSOW();
HOWtime = gpseph.HOWtime;
weeknum = static_cast<GPSWeekSecond>(gpseph.transmitTime).getWeek();
accuracy = gpseph.accuracyFlag;
health = gpseph.health;
codeflgs = gpseph.codeflags;
L2Pdata = gpseph.L2Pdata;
IODC = gpseph.IODC;
IODE = gpseph.IODE;
Tgd = gpseph.Tgd;
Tgd2 = 0.0;
fitint = gpseph.fitint;
}
// Initializes the nav data with a QZSEphemeris
Rinex3NavData::Rinex3NavData(const QZSEphemeris& qzseph)
{
loadFrom(dynamic_cast<const OrbitEph*>(&qzseph));
Toc = static_cast<QZSWeekSecond>(qzseph.ctToc).getSOW();
Toe = static_cast<QZSWeekSecond>(qzseph.ctToe).getSOW();
HOWtime = qzseph.HOWtime;
weeknum = static_cast<QZSWeekSecond>(qzseph.transmitTime).getWeek();
PRNID -= 192; // RINEX stores PRN minus 192
sat = RinexSatID(PRNID,SatID::systemQZSS);
IODC = qzseph.IODC;
IODE = qzseph.IODE;
health = qzseph.health;
accuracy = qzseph.accuracy;
Tgd = qzseph.Tgd;
codeflgs = qzseph.codeflags;
L2Pdata = qzseph.L2Pdata;
fitint = qzseph.fitint;
}
void ofxWFrame::onLoad(int & pressed){
if(!pressed){
loadFrom(filename,xml_root);
}
}
bool Model::loadFrom(const QString &filePath)
{
return !m_reader ? false : loadFrom(filePath, *m_reader);
}
bool SettingsManager::loadFrom(const QString & fileName) {
QByteArray fileNameBytes = fileName.toLocal8Bit();
return loadFrom(fileNameBytes.data());
}
void ofxBaseGui::loadFromFile(string filename) {
serializer->load(filename);
loadFrom(*serializer);
}
KCDock::KCDock(const QVariantMap &data, int loadId, KCClient *parent) :
KCGameObject(parent) {
connect(this, SIGNAL(completed()), parent, SLOT(onDockCompleted()));
loadFrom(data, loadId);
}
KCShipType::KCShipType(const QVariantMap &data, int loadId, QObject *parent) :
KCGameObject(parent) {
loadFrom(data, loadId);
}
