OrderedTask*
TaskFileXCSoar::GetTask(const TaskBehaviour &task_behaviour,
const Waypoints *waypoints, unsigned index) const
{
assert(index == 0);
return LoadTask(path, task_behaviour, waypoints);
}
static bool
DeclareInner(Port &port, const Declaration &declaration,
gcc_unused OperationEnvironment &env)
{
env.SetProgressRange(5);
env.SetProgressPosition(0);
if (!LX::CommandMode(port))
return false;
if (env.IsCancelled())
return false;
env.SetProgressPosition(1);
LX::Pilot pilot;
LoadPilotInfo(pilot, declaration);
LX::Declaration lxDevice_Declaration;
if (!LoadTask(lxDevice_Declaration, declaration))
return false;
LX::ContestClass contest_class;
LoadContestClass(contest_class, declaration);
if (env.IsCancelled())
return false;
env.SetProgressPosition(2);
LX::SendCommand(port, LX::WRITE_FLIGHT_INFO); // start declaration
LX::CRCWriter writer(port);
writer.Write(&pilot, sizeof(pilot));
env.SetProgressPosition(3);
if (env.IsCancelled())
return false;
writer.Write(&lxDevice_Declaration, sizeof(lxDevice_Declaration));
writer.Flush();
if (!LX::ExpectACK(port))
return false;
if (env.IsCancelled())
return false;
env.SetProgressPosition(4);
LX::SendCommand(port, LX::WRITE_CONTEST_CLASS);
writer.Write(&contest_class, sizeof(contest_class));
env.SetProgressPosition(5);
writer.Flush();
return LX::ExpectACK(port);
}
static OrderedTask *
task_load(const TaskBehaviour &task_behaviour)
{
auto *task = LoadTask(task_file, task_behaviour);
if (task != nullptr) {
task->UpdateStatsGeometry();
if (!task->CheckTask()) {
delete task;
return nullptr;
}
}
return task;
}
OrderedTask *
LoadDefaultTask(const TaskBehaviour &task_behaviour,
const Waypoints *waypoints)
{
TCHAR path[MAX_PATH];
LocalPath(path, default_task_path);
OrderedTask *task = LoadTask(path, task_behaviour, waypoints);
if (!task) {
task = new OrderedTask(task_behaviour);
assert(task);
task->SetFactory(task_behaviour.task_type_default);
}
return task;
}
//
// Load
//
// Load a list of tasks
//
void LoadTasks(GameObj *subject, FScope *fScope, NList<Task> &tasks)
{
// Iterate the scope
FScope *sScope;
while ((sScope = fScope->NextFunction()) != NULL)
{
switch (sScope->NameCrc())
{
case 0x40B71B7D: // "Task"
tasks.Append(LoadTask(subject, sScope));
break;
}
}
}
void LoadTasks() { // modif quand CMD.wd
char tasks[512];
char line[64];
FILE* f;
sprintf(tasks, "ls -1 %s/", PATH_TO_TASKS);
f = popen(tasks, "r");
if (f!=NULL) {
while (fgets(line, 64, f)!=NULL && sha->loaded < MAXTASK) {
CleanLineFeed(line);
LoadTask(line);
}
pclose(f);
}
else fprintf(stderr, "*** impossible to load tasks\n");
}
static OrderedTask *
LoadTask2(const TCHAR *path, const TaskBehaviour &task_behaviour)
{
OrderedTask *task = LoadTask(path, task_behaviour);
if (task == nullptr) {
fprintf(stderr, "Failed to parse XML\n");
return nullptr;
}
task->UpdateGeometry();
if (!task->CheckTask()) {
fprintf(stderr, "Failed to load task from XML\n");
delete task;
return NULL;
}
return task;
}
int
main(int argc, char **argv)
{
Args args(argc, argv, "FILE.tsk");
tstring path = args.ExpectNextT();
args.ExpectEnd();
TaskBehaviour task_behaviour;
task_behaviour.SetDefaults();
OrderedTask *task = LoadTask(path.c_str(), task_behaviour);
if (task == NULL)
return EXIT_FAILURE;
Print(*task);
delete task;
return EXIT_SUCCESS;
}
void
TaskListPanel::OnAction(int id)
{
switch (id) {
case LOAD:
LoadTask();
break;
case RENAME:
RenameTask();
break;
case DELETE:
DeleteTask();
break;
case MORE:
OnMoreClicked();
break;
}
}
OrderedTask *
LoadTask(Path path, const TaskBehaviour &task_behaviour,
const Waypoints *waypoints)
{
// Load root node
std::unique_ptr<XMLNode> xml_root(XML::ParseFile(path));
if (!xml_root)
return nullptr;
const ConstDataNodeXML root(*xml_root);
// Check if root node is a <Task> node
if (!StringIsEqual(root.GetName(), _T("Task")))
return nullptr;
// Create a blank task
OrderedTask *task = new OrderedTask(task_behaviour);
// Read the task from the XML file
LoadTask(*task, root, waypoints);
// Return the parsed task
return task;
}
void Begin(int argc, char* argv[]) {
char task[64],
buffer[1024];
int i,
cmdLength=0,
cmdBegin=1,
function;
Task* workingtask = NULL;
// vérification arguments
function = CheckArgument(argv[1]);
int AcceptNull = (function==_H||function==_CF||function==_R||function==_I||function==_LT||function==_LD);
// début de traitement
switch (AcceptNull)
{
// cas des commandes qui n'ont pas besoin d'une tache valide
case true :
{
switch (function)
{
case _R : printf("-- number of running task"); TaskFunction = Running; break;
case _CF : printf("-- open configuration file\n"); TaskFunction = OpenConfig; break;
case _H : printf("-- help of the program\n"); TaskFunction = Help; break;
case _I : printf("-- number of running instances"); TaskFunction = Instances; break;
case _LT : printf("-- list all tasks\n"); TaskFunction = ListAllTasks; break;
case _LD : printf("-- list loaded tasks\n"); TaskFunction = ListLoadedTasks; break;
}
break;
}
// cas des commandes nécessitant une tache valide
default :
{
// nom de la tache
if (function != _A && argc > 2) sprintf(task, "%s", argv[2]);
else sprintf(task, "%s", DEFAULT_TASK);
// pointeur sur celle-ci
workingtask=GetTask(task);
if (workingtask==NULL) {
workingtask=LoadTask(task);
if (workingtask==NULL) {
workingtask=AddTask(task);
if (workingtask==NULL) {
// tache introuvable, plus de place
fprintf(stderr, "*** unable to work on task %s, exit\n", task);
exit(2);
}
}
}
// tache valide
switch (function)
{
case _L : printf("-- list %s task\n", task); TaskFunction = ListTask; break;
case _S : printf("-- start %s task\n", task); TaskFunction = StartTask; break;
case _D : printf("-- delete last command in %s task\n", task); TaskFunction = DeleteLastCommand; break;
case _X : printf("-- stop %s task\n", task); TaskFunction = StopTask; break;
case _C : printf("-- clean %s task\n", task); TaskFunction = CleanTask; break;
case _M : {
if (argc > 3) sprintf(DEFAULT_EDITOR, "%s", argv[3]);
printf("-- modify %s task\n", task);
TaskFunction = ModifyTask;
break;
}
case _T : cmdBegin+=2;
case _A : {
GetEnv("$PWD", addedCommand.wd);
sprintf(addedCommand.cmd, "%s", argv[cmdBegin]);
cmdLength = strlen(addedCommand.cmd);
for (i=cmdBegin+1; i<argc; i++) {
cmdLength += strlen(argv[i]);
if (cmdLength >= 1023) {
fprintf(stderr, "*** attention : command is too long (max. size 1024)\n");
fprintf(stderr, " possible unexpected behavior\n");
break;
}
sprintf(buffer, " %s", argv[i]);
strncat(addedCommand.cmd, buffer, 1024);
}
printf("-- add '%s' to %s task\n", addedCommand.cmd, task);
TaskFunction = AddToTask;
break;
}
default : fprintf(stderr, "*** error while interpreting arguments : returning value %d\n", function); break;
}
break;
}
}
TaskFunction(workingtask);
if (workingtask!=NULL) {
if ((!workingtask->exec) && (!workingtask->demand))
workingtask->inuse=0;
}
}
virtual void OnActivateItem(unsigned index) override {
LoadTask();
}
