void SoXipSegmentationOverlayManager::handleEvent( SoHandleEventAction* action )
{
int numShapes = 0 ;
SoXipShapeList* list = getCurrentList ( ) ;
if (list != NULL) numShapes = list->getNumChildren ( ) ;
//if (numShapes > 0)
//{
// SoXipShape *pshape = (SoXipShape*)list->getChild(numShapes-1) ;
// if (pshape != NULL) SetupOverlayAction ( action, pshape ) ;
//}
if( action->isHandled() ) return ;
SoXipOverlayManager::handleEvent( action );
if (list != NULL)
{
int nnumShapes = list->getNumChildren ( ) ;
//! A shape created
if (nnumShapes > numShapes)
{
// Returns pointer to nth child node
SoXipShape *pshape = (SoXipShape*)list->getChild(numShapes) ;
if (pshape != NULL) SetupOverlayOption ( pshape, OverlayOption ) ;
}
}
}
static int openList(ListItem *list, char *outFilename) {
int ret;
char filename[FILE_LENGTH];
char filepath[PATH_LENGTH];
stop();
if (list->filename[0])
strcpy(filename,list->filename);
else {
strcpy(filename,getCurrentList(&context.package->lists[list->idxListWithFilename]));
list->posListWithFilename = context.package->lists[list->idxListWithFilename].currentFilePosition;
}
strcat(filename,".txt"); //todo: move to config file
cpyListPath(filepath,filename);
ret = tbChdir((LPSTR)filepath);
if (ret == -1) {
logException(5,filepath,RESET); //todo: package name or path does not exist
}
if (outFilename)
strcpy(outFilename,filename);
ret = tbOpen((LPSTR)(filename),O_RDONLY);
if (ret == -1) {
ret = replaceFromBackup(filename);
if (ret != -1)
ret = tbOpen((LPSTR)(filename),O_RDONLY);
if (ret == -1)
ret = tbOpen((LPSTR)(filename), O_CREAT|O_RDWR);
// logException(5,filename,RESET); //todo: package name or path does not exist
}
return ret;
}
void KFFWin_Flightplan::saveSettings()
{
QStringList list;
getCurrentList( list );
Settings::setFlightplan_list( list );
Settings::self()->writeConfig();
}
char *getPreviousList(ListItem *list) {
char *ret;
char buffer[READ_LENGTH+1];
int fileHandle;
char *line, *tempCursor;
int attempt,goodPass;
const int MAX_ATTEMPTS = 3;
if (list->currentFilePosition == -1)
ret = getCurrentList(list);
else {
for (attempt=0,goodPass=0;attempt < MAX_ATTEMPTS && !goodPass;attempt++) {
fileHandle = openList(list,NULL);
lseek(fileHandle,list->currentFilePosition,SEEK_SET);
buffer[READ_LENGTH] = '\0'; //prevents readLine from searching for \n past buffer
getLine(-1,0); // resets DONE
line = getLine(fileHandle,buffer);
if (!line)
line[0] = 0; //empty list
else {
do {
line = getLine(fileHandle,buffer);
} while (line && strspn(line," \x0a\x0d\x00"));
if (!line) {
// end of file -- move to start
line = getLine(fileHandle,0); // to reset DONE and move to BOF
list->currentFilePosition = 0;
line = getLine(fileHandle,buffer);
if (!line)
logException(9,0,RESET); //todo: format problem with list
}
list->currentFilePosition += getFilePosition();
}
close(fileHandle);
for (tempCursor = line;*tempCursor != 0x0a && *tempCursor != 0x0d && *tempCursor != 0x00;tempCursor++);
*tempCursor = 0x00;
strcpy(list->currentString,line);
ret = list->currentString;
if ((goodPass = goodString(ret,1)))
break;
else
logException(30,0,0);
}
if (!goodPass)
logException(30,0,RESET);
}
return ret;
}
void packageRecording(char * pkgName, char *listName) {
// adds name to current subject list
ListItem *tempList;
char *cursor;
char filePath[PATH_LENGTH];
cpyListPath(filePath,listName);
strcat(filePath,listName);
strcat(filePath,".txt");
insertStringInFile(filePath,pkgName,0);
cursor = getCurrentList(&pkgSystem.lists[context.package->idxMasterList]);
if (!strcmp(cursor,listName)) {
// list assigned to the recording is the current list (e.g. not user feedback on another category)
tempList = &context.package->lists[1]; // todo: this is a hack -- I shouldn't know it is list[1]
tempList->currentFilePosition = 0;
strcpy(tempList->currentString,pkgName);
}
}
int getListFilename(char * filename, int idList, BOOL addExtension) {
ListItem *tempList, *listMaster;
int i;
char *cursor;
tempList = &context.package->lists[idList];
if (tempList->filename[0])
strcpy(filename,tempList->filename);
else {
i = tempList->idxListWithFilename;
listMaster = &context.package->lists[i];
cursor = (char *)getCurrentList(listMaster);
strcpy(filename,cursor);
tempList->posListWithFilename = listMaster->currentFilePosition;
}
if (addExtension)
strcat(filename,".txt"); //todo: move to config file
return 0;
}
void
SoXipImageOverlayManager::clearOverlays()
{
SoXipShapeList* saveCurrentList = getCurrentList();
if( saveCurrentList )
{
// Remove all shapes from the current slice
saveCurrentList->removeAllChildren();
// Reference the shape list before removing all the slices
saveCurrentList->ref();
mShapeSwitch->removeAllChildren();
// Add the saved shape list, and remove the extra-reference
mShapeSwitch->addChild( saveCurrentList );
mShapeSwitch->whichChild.setValue(0);
saveCurrentList->unref();
}
updateSliceMap();
}
static void takeAction (Action *action, EnumAction actionCode) {
unsigned int newTime, oldTime;
unsigned long longNewTime, longOldTime;
int newIdxTimeframe, tempTime;
CtnrFile *newFile;
CtnrBlock *newBlock, *soundInsertBlock;
int newIdxAction;
EnumAction newActionCode;
EnumBorderCrossing direction;
signed long l;
int destination, aux, i, ret;
int status;
BOOL reposition = FALSE;
BOOL isTooFar = FALSE;
ListItem *list, *tempList;
char filename[PATH_LENGTH];
char *cursor, *cursor2;
CtnrFile *replayFile;
replayFile = NULL;
list = NULL;
oldTime = compressTime(Snd_A1800_GetCurrentTime(),context.package->timePrecision);
newFile = 0;
newTime = -1;
newBlock = 0;
if (actionCode == -1)
actionCode = getActionCode(action);
if (action) {
aux = action->aux;
destination = action->destination;
}
switch (actionCode) {
case JUMP_LIST:
stop();
list = &context.package->lists[destination];
context.idxActiveList = destination;
switch (getListRotation(aux)) {
case 0:
cursor = getCurrentList(list);
strcpy(filename,cursor);
break;
case 1:
strcpy(filename,getNextList(list,TRUE));
break;
case -1:
strcpy(filename,getPreviousList(list));
break;
}
if (!filename[0]) {
// empty list
insertSound(&pkgSystem.files[EMPTY_LIST_FILE_IDX],NULL,FALSE);
// empty list of packages; redirect to current point in list of lists
list = &context.package->lists[0];
context.idxActiveList = 0;
cursor = getCurrentList(list);
strcpy(filename,cursor);
}
if (list->listType == LIST_OF_PACKAGES) {
// load package
switch (filename[0]) {
case SYS_PKG_CHAR:
context.queuedPackageType = PKG_SYS;
destination = replaceStack(filename+1,&pkgSystem);
break;
case APP_PKG_CHAR:
context.queuedPackageType = PKG_APP;
destination = replaceStack(filename+1,&pkgSystem);
break;
default:
context.queuedPackageType = PKG_MSG;
destination = replaceStack(filename,&pkgSystem);
break;
}
context.queuedPackageNameIndex = destination;
} else { // list->listType != LIST_OF_PACKAGES
// play sound of subject
newFile = getListFile(filename);
newTime = 0;
reposition = TRUE;
}
break;
case JUMP_PACKAGE:
if (aux == PKG_VARIABLE) {
strcpy(filename,getCurrentList(&pkgSystem.lists[destination]));
switch (filename[0]) {
case SYS_PKG_CHAR:
aux = PKG_SYS;
destination = replaceStack(filename+1,&pkgSystem);
break;
case APP_PKG_CHAR:
aux = PKG_APP;
destination = replaceStack(filename+1,&pkgSystem);
break;
default:
aux = PKG_MSG;
destination = replaceStack(filename,&pkgSystem);
break;
}
}
context.queuedPackageType = aux;
context.queuedPackageNameIndex = destination;
break; // sets up main loop to handle this, rather than building up a stack overflow
case COPY:
stop();
tempList = &context.package->lists[destination];
getListFilename(filename,destination,FALSE);
cursor = getCurrentList(tempList);
if (PRE_COPY_FILE_IDX)
insertSound(&pkgSystem.files[PRE_COPY_FILE_IDX],NULL,TRUE);
ret = d2dCopy((const char *)filename,(const char *)cursor);
if (ret == 0 && POST_COPY_FILE_IDX)
insertSound(&pkgSystem.files[POST_COPY_FILE_IDX],NULL,TRUE);
// newBlock = &context.package->blocks[aux];
// newTime = newBlock->startTime;
// reposition = TRUE;
break;
case DELETE:
stop();
tempList = &context.package->lists[destination];
getListFilename(filename,destination,TRUE);
cursor = getCurrentList(tempList);
ret = findDeleteStringFromFile(LIST_PATH,filename,cursor,TRUE);
tempList->currentFilePosition = -1; // forces next list action to reload
if (ret != -1)
ret = deletePackage(cursor);
else
logException(29,cursor,0);
list = &context.package->lists[aux];
context.idxActiveList = aux;
newFile = getListFile(getCurrentList(list));
newTime = 0;
reposition = TRUE;
// newBlock = &context.package->blocks[aux];
// newTime = newBlock->startTime;
// reposition = TRUE;
break;
case TRIM:
stop();
tempList = &context.package->lists[destination];
cursor = getCurrentList(tempList);
strcpy(filename,USER_PATH);
strcat(filename,cursor); //todo: address application packages
strcat(filename,AUDIO_FILE_EXT);
edit(filename);
context.queuedPackageType = PKG_MSG;
destination = replaceStack(cursor,context.package);
context.queuedPackageNameIndex = destination;
break;
case SPEED_UP:
adjustSpeed(SPEED_INCREMENT,TRUE);
break;
case SPEED_DOWN:
adjustSpeed(-SPEED_INCREMENT,TRUE);
break;
case SPEED_NORMAL:
adjustSpeed(NORMAL_SPEED,FALSE);
break;
case VOLUME_UP:
adjustVolume(VOLUME_INCREMENT,TRUE,FALSE);
break;
case VOLUME_DOWN:
adjustVolume(-VOLUME_INCREMENT,TRUE,FALSE);
break;
case VOLUME_NORMAL:
adjustVolume(NORMAL_VOLUME,FALSE,FALSE);
break;
case LED_RED_ON:
setLED(LED_RED,TRUE);
break;
case LED_RED_OFF:
setLED(LED_RED,FALSE);
break;
case LED_GREEN_ON:
setLED(LED_GREEN,TRUE);
break;
case LED_GREEN_OFF:
setLED(LED_GREEN,FALSE);
break;
case LED_ALL_ON:
setLED(LED_ALL,TRUE);
break;
case LED_ALL_OFF:
setLED(LED_ALL,TRUE);
break;
case USB_DEVICE_ON:
setUSBDevice(TRUE);
newBlock = &context.package->blocks[destination];
newTime = newBlock->startTime;
reposition = TRUE;
break;
case USB_HOST_ON:
/* stop();
setUSBDevice(TRUE);
newBlock = &context.package->blocks[destination];
newTime = newBlock->startTime;
reposition = TRUE;
*/ break;
case STOP:
stop();
enterOrExitAllBlocks(context.idxTimeframe,EXITING);
break;
case PLAY_PAUSE:
status = SACM_Status();
switch (status) {
case 0:
// if (context.package->pkg_type != PKG_SYS)
markStartPlay(Snd_A1800_GetCurrentTime(),context.package->strHeapStack+context.package->idxName);
if (context.idxActiveList == -1) {
enterOrExitAllBlocks(context.idxTimeframe,ENTERING);
i = getStartingBlockIdxFromTimeline(context.idxTimeframe);
if (i != -1)
processStartBlock(i);
play(context.file,getCurrentTimeframeStart());
} else
play(context.file,0);
break;
case C_SACM_RECORD:
case C_SACM_PLAY:
context.isPaused = TRUE;
pause();
break;
case C_SACM_PAUSE:
context.isPaused = FALSE;
resume();
break;
default:
if (context.isPaused) {
context.isPaused = FALSE;
resume();
} else {
context.isPaused = TRUE;
pause();
}
break;
}
break;
case PAUSE:
pause();
context.isPaused = TRUE;
break;
case RECORD_TITLE: // deprecated
case RECORD_MSG:
stop();
/* // Not currently allowing sound inserts before record commands since aux is used for recording from another headphone jack
// Although the SPINS part of the headphone jack thing isn't currently working.
if (action && hasSoundInsert(action)) {
soundInsertBlock = &pkgSystem.blocks[getSoundInsertIdxFromAux(aux)];
insertSound(getFileFromBlock(soundInsertBlock),soundInsertBlock,TRUE);
wait(500);
}
*/
if(vCur_1 < V_MIN_RECORD_VOLTAGE) {
refuse_lowvoltage(0);
break;
}
cursor = getCurrentList(&pkgSystem.lists[context.package->idxMasterList]);
do {
strcpy(filename,USER_PATH);
getPkgNumber(filename+strlen(USER_PATH),TRUE);
strcat(filename,(const char *)CATEGORY_DELIM_STR);
strcat(filename,cursor); // adds current listname to new recording name
cursor2 = filename + strlen(filename);
strcat(filename,AUDIO_FILE_EXT);
ret = fileExists((LPSTR)filename); // this causes approx 1 sec delay!
} while (ret);
*cursor2 = 0; // remove extension
strcpy(filename,filename+strlen(USER_PATH)); //remove path
ret = createRecording(filename,aux,cursor);
if (ret != -1) {
destination = replaceStack(filename,context.package);
context.queuedPackageNameIndex = destination;
context.queuedPackageType = PKG_MSG;
} else
logException(28,"recording failed",RESET); //todo: add voice error msg?
break;
case CALL_BLOCK:
// TODO: handle error (return of -1) if stack is full
stackPush(context.package,context.file,oldTime - getRewind(aux)); // times are compressed
// this is designed to fall through
case JUMP_BLOCK:
newBlock = &context.package->blocks[destination];
newTime = newBlock->startTime;
reposition = TRUE;
break;
case RETURN:
if (stackPop(&context.package,&newFile,&newTime)) // times are compressed
reposition = TRUE;
break;
case FWD:
newActionCode = getStartEndCodeFromTimeframe(context.idxTimeframe,FORWARD_JUMPING, &newTime, &newIdxAction);
switch (newActionCode) {
case NOP:
case PAUSE:
break;
case STOP:
//rewind to give context before stopping
newTime -= compressTime(BLOCK_END_LEADER,context.package->timePrecision);
break;
case JUMP_BLOCK:
//follow this link
newBlock = &context.package->blocks[context.package->actions[newIdxAction].destination];
newTime = newBlock->startTime;
break;
case RETURN:
stackPop(&context.package,&newFile,&newTime); //todo: double verify there was something on stack (shouldn't have gotten RETURN if not)
break;
default:
//no action needed
break;
}
reposition = TRUE;
break;
case BACK:
// test whether within the start leader to determine whether to go to last start or to previous start before that
if ((oldTime - getCurrentTimeframeStart()) > compressTime(BLOCK_START_LEADER, context.package->timePrecision)) {
// just move to start time of same timeframe
newTime = getCurrentTimeframeStart(); // must make sure we call the Start event
} else {
newActionCode = getStartEndCodeFromTimeframe(context.idxTimeframe,BACKWARD_JUMPING, &newTime, &newIdxAction);
switch (newActionCode) {
case NOP:
case PAUSE:
case STOP:
break;
case JUMP_BLOCK:
//follow this link
newBlock = &context.package->blocks[context.package->actions[newIdxAction].destination];
newTime = newBlock->startTime;
break;
case RETURN:
stackPop(&context.package,&newFile,&newTime); //todo: double verify there was something on stack (shouldn't have gotten RETURN if not)
break;
default:
//no action needed
break;
}
}
reposition = TRUE;
break;
case JUMP_TIME:
// skip forward/back from relative position
// observe block boundary when they exist, but leap beyond them
// todo:do not leap over newFile boundaries
// if system package action, reset context to user package for this action
if (context.returnPackage)
context.package = context.returnPackage;
if (context.package != &pkgSystem) {
longOldTime = Snd_A1800_GetCurrentTime();
l = (signed long)extractSignedTime(destination,context.package->timePrecision); // hoping this brings back an originally negative number
longNewTime = longOldTime + l;
if (l >= 0)
direction = FORWARD_JUMPING;
else {
direction = BACKWARD_JUMPING;
if (abs(l) > longOldTime)
longNewTime = 0;
}
newTime = compressTime(longNewTime,context.package->timePrecision);
// check for interfering block events
newIdxTimeframe = context.idxTimeframe;
do {
newActionCode = getStartEndCodeFromTimeframe(newIdxTimeframe,direction, &tempTime, &newIdxAction);
if (direction == FORWARD_JUMPING)
isTooFar = blockTimeline[++newIdxTimeframe].time > newTime;
else
isTooFar = blockTimeline[--newIdxTimeframe].time < newTime;
} while (!isTooFar && newActionCode == NOP);
switch (newActionCode) {
case JUMP_BLOCK:
newBlock = &context.package->blocks[context.package->actions[newIdxAction].destination];
newTime = newBlock->startTime;
newFile = getFileFromBlock(newBlock);
break;
case RETURN:
stackPop(&context.package,&newFile,&newTime); //todo: double verify there was something on stack (shouldn't have gotten RETURN if not)
break;
default:
//no action needed
break;
}
playActionSound(JUMP_TIME);
reposition = TRUE;
} // context is not system file
break;
case SLEEP:
// call sleep function
setOperationalMode((int)P_SLEEP);
break;
case HALT:
// call sleep function
setOperationalMode((int)P_HALT);
break;
case NOP:
// no operation
break;
default:
//nothing should default here
logException(1,0,USB_MODE);
break;
}
if (reposition) {
//todo: am i catching every possible change in file?
if (newBlock && !newFile)
newFile = getFileFromBlock(newBlock);
if (newFile && newFile != context.file) {
enterOrExitAllBlocks(context.idxTimeframe,EXITING);
context.file = newFile;
if (!list)
buildBlockTimelines(newFile);
context.idxTimeframe = -1; // to signal it hasn't been set yet
context.timeNextTimeframe = -1; // resets this -- necessary for lists that dont go to processTimelineJump
}
if (!list) {
context.idxActiveList = -1;
newIdxTimeframe = getIdxTimeline(newTime);
if (newIdxTimeframe != context.idxTimeframe)
processTimelineJump(context.idxTimeframe, newIdxTimeframe); // this resets context.idxTimeframe and context.timeNextTimeframe
}
}
// now that context.idxTimeframe has been set for repositions, we can insert sounds
if (action && hasSoundInsert(action)) {
if (reposition)
stop(); // stop currently playing audio first or insertSound() will return to it
if (actionCode == JUMP_TIME) {
if (context.returnPackage)
context.package = &pkgSystem;
soundInsertBlock = &context.package->blocks[getSoundInsertIdxFromAux(aux)];
insertSound(getFileFromBlock(soundInsertBlock),soundInsertBlock,TRUE);
}
else {
soundInsertBlock = &context.package->blocks[getSoundInsertIdxFromAux(aux)];
insertSound(getFileFromBlock(soundInsertBlock),soundInsertBlock,FALSE);
}
}
// process start block action if landing on the start of a new block
if (reposition && newBlock && newTime == newBlock->startTime)
processStartBlock(newBlock - context.package->blocks);
if (list) {
soundInsertBlock = getStartInsert(list->actionStartEnd, list->idxFirstAction);
if (soundInsertBlock)
insertSound(getFileFromBlock(soundInsertBlock),soundInsertBlock,FALSE);
}
if (actionCode == JUMP_TIME && context.returnPackage) { // returning to user package after possibly inserting a system sound above
context.package = context.returnPackage;
context.returnPackage = NULL;
}
if (actionCode == SPEED_UP || actionCode == SPEED_DOWN) {
context.isPaused = FALSE;
resume();
}
if (reposition)
play(context.file,newTime); //todo: chg to seek if same file
//todo: maybe for JUMP_BLOCK (not CALL_BLOCK) , allow offsets within a block (stored in first 13 bits of aux)
}
