//Enable lazy initialization
//Loads the function and arguments
void PythonHandler::init(std::string filename, std::string functionname, PythonArgList arg_list) {
good = true;
loadName(filename);
loadModule();
loadFunction(functionname);
packArgs(arg_list);
}
// High level function to read user name
// Try to load it from the save, or ask him directly
// Returns 0 if fails, 1 else
int readName(char *name, int size)
{
if (loadName(name, size)) return 1;
printf ("Enter your name: ");
if (!readLine(name, size)) return 0;
saveName(name);
return 1;
}
/*
* Constructs a keyDialog as a child of 'parent', with the
* name 'name' and widget flags set to 'f'.
*
* The dialog will by default be modeless, unless you set 'modal' to
* TRUE to construct a modal dialog.
*/
keyDialog::keyDialog( QWidget* parent, Qt::WFlags fl )
: QDialog( parent, fl ),bgKey(this)
{
ui.setupUi(this);
bgKey.addButton(ui.radioButton1,0);
bgKey.addButton(ui.radioButton2,1);
bgKey.addButton(ui.radioButton3,2);
connectSlots();
pConf = Global::instance()->fileCfg();
loadName();
}
static uint64_t loadFromFile(tr_torrent* tor, uint64_t fieldsToLoad)
{
TR_ASSERT(tr_isTorrent(tor));
size_t len;
int64_t i;
char const* str;
char* filename;
tr_variant top;
bool boolVal;
uint64_t fieldsLoaded = 0;
bool const wasDirty = tor->isDirty;
tr_error* error = NULL;
filename = getResumeFilename(tor);
if (!tr_variantFromFile(&top, TR_VARIANT_FMT_BENC, filename, &error))
{
tr_logAddTorDbg(tor, "Couldn't read \"%s\": %s", filename, error->message);
tr_error_free(error);
tr_free(filename);
return fieldsLoaded;
}
tr_logAddTorDbg(tor, "Read resume file \"%s\"", filename);
if ((fieldsToLoad & TR_FR_CORRUPT) != 0 && tr_variantDictFindInt(&top, TR_KEY_corrupt, &i))
{
tor->corruptPrev = i;
fieldsLoaded |= TR_FR_CORRUPT;
}
if ((fieldsToLoad & (TR_FR_PROGRESS | TR_FR_DOWNLOAD_DIR)) != 0 &&
tr_variantDictFindStr(&top, TR_KEY_destination, &str, &len) && str != NULL && *str != '\0')
{
bool const is_current_dir = tor->currentDir == tor->downloadDir;
tr_free(tor->downloadDir);
tor->downloadDir = tr_strndup(str, len);
if (is_current_dir)
{
tor->currentDir = tor->downloadDir;
}
fieldsLoaded |= TR_FR_DOWNLOAD_DIR;
}
if ((fieldsToLoad & (TR_FR_PROGRESS | TR_FR_INCOMPLETE_DIR)) != 0 &&
tr_variantDictFindStr(&top, TR_KEY_incomplete_dir, &str, &len) && str != NULL && *str != '\0')
{
bool const is_current_dir = tor->currentDir == tor->incompleteDir;
tr_free(tor->incompleteDir);
tor->incompleteDir = tr_strndup(str, len);
if (is_current_dir)
{
tor->currentDir = tor->incompleteDir;
}
fieldsLoaded |= TR_FR_INCOMPLETE_DIR;
}
if ((fieldsToLoad & TR_FR_DOWNLOADED) != 0 && tr_variantDictFindInt(&top, TR_KEY_downloaded, &i))
{
tor->downloadedPrev = i;
fieldsLoaded |= TR_FR_DOWNLOADED;
}
if ((fieldsToLoad & TR_FR_UPLOADED) != 0 && tr_variantDictFindInt(&top, TR_KEY_uploaded, &i))
{
tor->uploadedPrev = i;
fieldsLoaded |= TR_FR_UPLOADED;
}
if ((fieldsToLoad & TR_FR_MAX_PEERS) != 0 && tr_variantDictFindInt(&top, TR_KEY_max_peers, &i))
{
tor->maxConnectedPeers = i;
fieldsLoaded |= TR_FR_MAX_PEERS;
}
if ((fieldsToLoad & TR_FR_RUN) != 0 && tr_variantDictFindBool(&top, TR_KEY_paused, &boolVal))
{
tor->isRunning = !boolVal;
fieldsLoaded |= TR_FR_RUN;
}
if ((fieldsToLoad & TR_FR_ADDED_DATE) != 0 && tr_variantDictFindInt(&top, TR_KEY_added_date, &i))
{
tor->addedDate = i;
fieldsLoaded |= TR_FR_ADDED_DATE;
}
if ((fieldsToLoad & TR_FR_DONE_DATE) != 0 && tr_variantDictFindInt(&top, TR_KEY_done_date, &i))
{
tor->doneDate = i;
fieldsLoaded |= TR_FR_DONE_DATE;
}
if ((fieldsToLoad & TR_FR_ACTIVITY_DATE) != 0 && tr_variantDictFindInt(&top, TR_KEY_activity_date, &i))
{
tr_torrentSetActivityDate(tor, i);
fieldsLoaded |= TR_FR_ACTIVITY_DATE;
}
if ((fieldsToLoad & TR_FR_TIME_SEEDING) != 0 && tr_variantDictFindInt(&top, TR_KEY_seeding_time_seconds, &i))
{
tor->secondsSeeding = i;
fieldsLoaded |= TR_FR_TIME_SEEDING;
}
if ((fieldsToLoad & TR_FR_TIME_DOWNLOADING) != 0 && tr_variantDictFindInt(&top, TR_KEY_downloading_time_seconds, &i))
{
tor->secondsDownloading = i;
fieldsLoaded |= TR_FR_TIME_DOWNLOADING;
}
if ((fieldsToLoad & TR_FR_BANDWIDTH_PRIORITY) != 0 &&
tr_variantDictFindInt(&top, TR_KEY_bandwidth_priority, &i) && tr_isPriority(i))
{
tr_torrentSetPriority(tor, i);
fieldsLoaded |= TR_FR_BANDWIDTH_PRIORITY;
}
if ((fieldsToLoad & TR_FR_PEERS) != 0)
{
fieldsLoaded |= loadPeers(&top, tor);
}
if ((fieldsToLoad & TR_FR_FILE_PRIORITIES) != 0)
{
fieldsLoaded |= loadFilePriorities(&top, tor);
}
if ((fieldsToLoad & TR_FR_PROGRESS) != 0)
{
fieldsLoaded |= loadProgress(&top, tor);
}
if ((fieldsToLoad & TR_FR_DND) != 0)
{
fieldsLoaded |= loadDND(&top, tor);
}
if ((fieldsToLoad & TR_FR_SPEEDLIMIT) != 0)
{
fieldsLoaded |= loadSpeedLimits(&top, tor);
}
if ((fieldsToLoad & TR_FR_RATIOLIMIT) != 0)
{
fieldsLoaded |= loadRatioLimits(&top, tor);
}
if ((fieldsToLoad & TR_FR_IDLELIMIT) != 0)
{
fieldsLoaded |= loadIdleLimits(&top, tor);
}
if ((fieldsToLoad & TR_FR_FILENAMES) != 0)
{
fieldsLoaded |= loadFilenames(&top, tor);
}
if ((fieldsToLoad & TR_FR_NAME) != 0)
{
fieldsLoaded |= loadName(&top, tor);
}
/* loading the resume file triggers of a lot of changes,
* but none of them needs to trigger a re-saving of the
* same resume information... */
tor->isDirty = wasDirty;
tr_variantFree(&top);
tr_free(filename);
return fieldsLoaded;
}
static void putHeader (const char* session,
const vector<AuxField*>& u ,
const int_t np ,
const int_t nz ,
const int_t nel ,
const int_t step ,
const real_t time ,
const real_t tstp ,
const real_t kinv ,
const real_t beta )
// ---------------------------------------------------------------------------
// Write header information for semtex/prism/nekton compatible file on cout.
// ---------------------------------------------------------------------------
{
static const char* hdr_fmt[] = {
"%-25s " "Session\n",
"%-25s " "Created\n",
"%-25s " "Nr, Ns, Nz, Elements\n",
"%-25d " "Step\n",
"%-25.6g " "Time\n",
"%-25.6g " "Time step\n",
"%-25.6g " "Kinvis\n",
"%-25.6g " "Beta\n",
"%-25s " "Fields written\n",
"%-25s " "Format\n"
};
char buf[StrMax], fmt[StrMax], fields[StrMax];
time_t tp (::time (0));
sprintf (buf, hdr_fmt[0], session);
cout << buf;
strftime (fmt, 25, "%a %b %d %H:%M:%S %Y", localtime (&tp));
sprintf (buf, hdr_fmt[1], fmt);
cout << buf;
sprintf (fmt, "%1d %1d %1d %1d", np, np, nz, nel);
sprintf (buf, hdr_fmt[2], fmt);
cout << buf;
sprintf (buf, hdr_fmt[3], step);
cout << buf;
sprintf (buf, hdr_fmt[4], time);
cout << buf;
sprintf (buf, hdr_fmt[5], tstp);
cout << buf;
sprintf (buf, hdr_fmt[6], kinv);
cout << buf;
sprintf (buf, hdr_fmt[7], beta);
cout << buf;
loadName (u, fields);
sprintf (buf, hdr_fmt[8], fields);
cout << buf;
sprintf (buf, hdr_fmt[9], "ASCII");
cout << buf;
}
BasicMesh* MeshManager::loadMesh(const std::string& fileName, const std::string meshName)
{
shared_ptr<GameFile> file = GameFile::openFile(fileName, "r");
std::string readLine;
BasicMesh* result = new BasicMesh();
std::string collisionLine;
while(!(file->eof()))
{
readLine = file->readLine();
if(readLine.size() == 0 || readLine == "\n")
{
continue;
}
if(readLine.find(NAME_SECTION) == 0)
{
loadName(result, readLine);
continue;
}
else if(readLine.find(VERTICES_SECTION) == 0)
{
loadVertices(result, readLine, file.get());
continue;
}
else if(readLine.find(UVS_SECTION) == 0)
{
loadUvs(result, readLine, file.get());
continue;
}
else if(readLine.find(NORMALS_SECTION) == 0)
{
loadNormals(result, readLine, file.get());
continue;
}
else if(readLine.find(INDICES_SECTION) == 0)
{
loadIndices(result, readLine, file.get());
continue;
}
else if(readLine.find(COLLISION_SECTION) == 0)
{
collisionLine = readLine; // it has to be calculated after all the geometry
continue;
}
else
{
Log("Skipping unknown line in mesh file - %s", readLine.c_str());
}
}
if(collisionLine.size() != 0)
{
setCollision(result, collisionLine);
}
else
{
// by default create box collision
result->setCollisionType(CS_BOX);
result->m_collisionShape = createCollisionShape(result);
}
return result;
}
