RMDBGLOG((GUIPARSERDBG, "Could not read top of image (ParseImage) ... error\n"));		goto invalidBitmap;	}	else {		RMasciiToUInt16 (str, &(bitmap->object.y));	}	str = pnode->Attribute(XMLZINDEX_NODE, true);	if (str == (RMascii *)NULL) {		RMDBGLOG((GUIPARSERDBG, "Could not read zIndex of image (ParseImage) ... default to 0\n"));		bitmap->object.zIndex = 0;	}	else {		RMasciiToUInt8 (str, &(bitmap->object.zIndex));	}	// set visibility -- not defined in WMHD xml	bitmap->object.visible = TRUE;			str = pnode->Attribute(XMLTRANSPARENTCOLOR_NODE, true);	if (str == (RMascii *)NULL) {//		RMDBGLOG((GUIPARSERDBG, "Could not read bitmap transparent color... ignoring\n"));	}	else {				if((str[0] == '0') &&		   (str[1] == 'x')) {			// hexa			RMasciiHexToUint64(str+2, &color);			bitmap->object.transparentcolor = (RMuint32)color;					}		else {			RMasciiToUInt32 (str, &(bitmap->object.transparentcolor));		}	}		str = pnode->Attribute(XMLUSETRANSPARENTCOLOR_NODE, true);	if (str != (RMascii *)NULL) {		if (RMCompareAsciiCaseInsensitively (str, "TRUE")) {			bitmap->object.usetransparentcolor = TRUE;		}		else if (RMCompareAsciiCaseInsensitively (str, "FALSE")) {			bitmap->object.usetransparentcolor = FALSE;		}		else {			RMDBGLOG((GUIPARSERDBG, "Invalid usetransparentcolor value of bitmap ... error\n"));			goto invalidBitmap;		}		}	else		bitmap->object.usetransparentcolor = FALSE;			str = pnode->Attribute(XMLEVENT_NODE, true);	if (str == (RMascii *)NULL) {//		RMDBGLOG((GUIPARSERDBG, "Could not read bitmap event (ParseEventBitmap) ... ignoring\n"));	}	else {		bitmap->event = STRDUP(str);	}		// display param / condition go together	str = pnode->Attribute(XMLDISPLAYCONDITION_NODE, true);	if (str != (RMascii *)NULL) {		RMasciiToUInt16 (str, &(bitmap->displayCondition));			str = pnode->Attribute(XMLDISPLAYPARAMETER_NODE, true);		if (str != (RMascii *)NULL) {			bitmap->displayParameter = STRDUP(str);		}		else{			bitmap->displayCondition = 0;			bitmap->displayParameter = (RMascii*)NULL;		}	}		//	RMDBGLOG((GUIPARSERDBG, "Bitmap : name : %s, x=%d, y=%d, visible : %s\n",//		  bitmap->name, bitmap->object.x, bitmap->object.y, bitmap->object.visible ? "TRUE":"FALSE"));	// set id	bitmap->id = BITMAP_IDMASK | m_nextBitmapId++;		return bitmap; invalidBitmap:	FreeBitmap(bitmap);	return (guiBitmapType*)NULL;}void RMWmvHDParser::FreeBitmap(guiBitmapType *bitmap){	if(bitmap == NULL)		return;		if(bitmap->name != (RMascii *)NULL){		RFREE(bitmap->name);		bitmap->name = NULL;	}	if(bitmap->object.file != (RMascii *)NULL){		RFREE(bitmap->object.file);		bitmap->object.file = NULL;	}	if(bitmap->event != (RMascii *)NULL){		RFREE(bitmap->event);		bitmap->event = NULL;	}		if(bitmap->displayParameter != (RMascii *)NULL){		RFREE(bitmap->displayParameter);		bitmap->displayParameter = NULL;	}	RFREE(bitmap);	}////////////////////////////////////////////////////////////////////////////////// MEDIA OBJECTS////////////////////////////////////////////////////////////////////////////////RMstatus RMWmvHDParser::GetMediaFiles(guiMediaType *media[MAX_GUI_MEDIA], RMuint16 *nMediaFiles){	if(m_nbMediaFiles){		RMMemcpy(media, m_MediaFiles, sizeof(m_MediaFiles));		*nMediaFiles = m_nbMediaFiles;	}	return RM_OK;}guiMediaType *RMWmvHDParser::ParseMediaFile(TiXmlElement *pnode){	const RMascii *str;	guiMediaType *media;	TiXmlElement *ptempNode;	media = (guiMediaType*) CALLOC(1, sizeof(guiMediaType));	str = pnode->Attribute(XMLID_NODE, true);	// name	if (str == (RMascii *)NULL) {		RMDBGLOG((GUIPARSERDBG, "Could not read media id ... error\n"));		goto invalidMedia;	}	else {		media->name = STRDUP(str);	}		str = pnode->Attribute(XMLSRC_NODE, true);	// file	if (str == (RMascii *)NULL) {		RMDBGLOG((GUIPARSERDBG, "Could not read media src ... error\n"));		goto invalidMedia;	}	else {		media->file = RMCatAscii(m_mountPoint, str, NULL);		if(IsValidPath(media->file) == FALSE){			if(RMFAILED(FindFile(media->file))){				RMDBGLOG((GUIPARSERDBG, "Invalid path given for bitmap (ParseImage) ... error\n"));				goto invalidMedia;			}		}	}		str = pnode->Attribute(XMLCANSKIP_NODE, true);	if (str != (RMascii *)NULL) {		if (RMCompareAsciiCaseInsensitively (str, "TRUE")) {			media->canSkip = TRUE;		}		else if (RMCompareAsciiCaseInsensitively (str, "FALSE")) {			media->canSkip = FALSE;		}		else {			RMDBGLOG((GUIPARSERDBG, "Invalid canskip value of media ... (Parse Media)\n"));			goto invalidMedia;		}		}	else		goto invalidMedia;			str = pnode->Attribute(XMLWHENDONE_NODE, true);	if (str == (RMascii *)NULL) {		RMDBGLOG((GUIPARSERDBG, "Could not read whenDone from media object ... error\n"));		goto invalidMedia;	}	else {		media->whenDone = STRDUP(str);	}		str = pnode->Attribute(XMLDURATION_NODE, true);	if (str == (RMascii *)NULL) {		RMDBGLOG((GUIPARSERDBG, "Could not read media object duration... setting to 10 secs\n"));		media->duration = 10;	}	else {		media->duration = ConvertSMPTEtoSecs(str);	}	for(ptempNode = pnode->FirstChildElement(); ptempNode != NULL; ptempNode = ptempNode->NextSiblingElement()) {       		str = ptempNode->Value();		if (str == (RMascii *)NULL)			continue;		RMDBGLOG((GUIPARSERDBG, "node : %s\n", (char*)str));		if (RMCompareAsciiCaseInsensitively (str, XMLCHAPTER_NODE)) {			media->chapters[media->nbChapters] = ParseChapter(ptempNode);			if(media->chapters[media->nbChapters] != (guiChapterType*)NULL){				media->nbChapters++;			}					}		else {			RMDBGLOG((GUIPARSERDBG, "unknown node [%s] in media\n", str));		}	}		RMDBGLOG((GUIPARSERDBG, "Media object: name : %s, file: %s\n", media->name, media->file));		// set id	media->id = MEDIA_IDMASK | m_nbMediaFiles;	       	return media;	 invalidMedia:	FreeMediaFile(media);	return (guiMediaType*)NULL;}void RMWmvHDParser::FreeMediaFile(guiMediaType *media){	if(media == NULL)		return;			if(media->name != (RMascii *)NULL){		RFREE(media->name);		media->name = NULL;	}		if(media->file != (RMascii *)NULL){		RFREE(media->file);		media->file = NULL;	}		if(media->whenDone != (RMascii *)NULL){		RFREE(media->whenDone);		media->whenDone = NULL;	}	for(RMuint16 i = 0; i < media->nbChapters; i++){		FreeChapter(media->chapters[i]);		media->chapters[i] = NULL;	}	RFREE(media);}////////////////////////////////////////////////////////////////////////////////// MEDIA CHAPTERS////////////////////////////////////////////////////////////////////////////////guiChapterType *RMWmvHDParser::ParseChapter(TiXmlElement *pnode){	const RMascii *str;	guiChapterType *chapter;	chapter = (guiChapterType*) CALLOC(1, sizeof(guiChapterType));		str = pnode->Attribute(XMLID_NODE, true);	// name -- case free	if (str == (RMascii *)NULL) {		RMDBGLOG((GUIPARSERDBG, "Could not read name of chapter (ParseChapter) ... error\n"));		goto invalidChapter;	}	else {		chapter->name = STRDUP(str);	}		str = pnode->Attribute(XMLSTARTTIME_NODE, true);	if (str == (RMascii *)NULL) {		RMDBGLOG((GUIPARSERDBG, "Could not read chapter starttime (ParseChapter) ... error\n"));		goto invalidChapter;	}	else {		chapter->startTime = ConvertSMPTEtoSecs(str);		// initialize seekTime as startTime		chapter->seekTime = chapter->startTime;	}			RMDBGLOG((GUIPARSERDBG, "Chapter : name : %s, startTime=%s\n",		  chapter->name, chapter->startTime));	// set id	chapter->id = CHAPTER_IDMASK | m_nextChapterId++;		return chapter;	 invalidChapter:	FreeChapter(chapter);	return (guiChapterType*)NULL;}void RMWmvHDParser::FreeChapter(guiChapterType *chapter){	if(chapter == NULL)		return;		if(chapter->name != (RMascii *)NULL){		RFREE(chapter->name);		chapter->name = NULL;	}		RFREE(chapter);	}////////////////////////////////////////////////////////////////////////////////// COMMANDS////////////////////////////////////////////////////////////////////////////////RMstatus RMWmvHDParser::GetCommands(guiCommandType *commands[MAX_GUI_COMMANDS], RMuint16 *nCommands){	if(m_nbCommands){		RMMemcpy(commands, m_Commands, sizeof(m_Commands));	}	*nCommands = m_nbCommands;				return RM_OK;}guiCommandType *RMWmvHDParser::AddCommand(RMascii* commandName, RMuint32 id){	guiCommandType *cmd;	cmd = (guiCommandType*) CALLOC(1, sizeof(guiCommandType));	cmd->name = STRDUP(commandName);	cmd->id = id;	//	RMDBGLOG((GUIPARSERDBG, "Command : name : %s, value : %ld\n", //		  cmd->name, cmd->value));	return cmd;}void RMWmvHDParser::FreeCommand(guiCommandType *cmd){	if(cmd == NULL)		return;			if(cmd->name != (RMascii *)NULL){		RFREE(cmd->name);		cmd->name = NULL;	}	RFREE(cmd);	}///////////////////////////////////////////////////////////////////////////////RMuint32 RMWmvHDParser::ConvertSMPTEtoSecs(const RMascii* str){	unsigned int hours, mins, secs, frames;		if(RMasciiLength(str) == RMasciiLength("hh:mm:ss.ff"))		sscanf(str, "%02u:%02u:%02u.%02u", &hours, &mins, &secs, &frames);	else if(RMasciiLength(str) == RMasciiLength("hh:mm:ss.f"))		sscanf(str, "%02u:%02u:%02u.%u", &hours, &mins, &secs, &frames);	else		return 0;			return (hours * 3600 + mins * 60 + secs);}RMbool RMWmvHDParser::IsValidPath(const RMascii* path){	FILE *fp;		// Open the prospective BITMAP file	if ((fp = fopen(path, "rb")) != NULL){		fclose(fp);		return TRUE;	}		return FALSE;}RMstatus RMWmvHDParser::FindFile(RMascii* path){	RMascii dir[256];	RMascii name[256];	DIR *d;	struct dirent *c;	RMbool found = FALSE;		RMuint16 length = RMasciiLength(path);	RMuint16 position = 0;	RMuint16 i, j;	RMMemset(name, 0, sizeof(name));	RMMemset(dir, 0, sizeof(dir));		//printf("looking for case insensitive %s\n", path);		// split name and directory to test them individually		// find last slash ('/')	for(i = 0; i < length; i++){		if(path[i] == '/'){			position = i;			continue;		}	}		for(i = position + 1, j = 0; i < length; i++, j++){		name[j] = path[i];	}		if(name[0] == 0)		return RM_ERROR;			RMNCopyAscii(dir, path, position + 1);//length - RMasciiLength(name));		d = opendir(dir);	if(d == NULL){		// directory does not exist, try to find it		RMascii dirs[20][80];	// max 20 levels deep		RMuint16 dirlength = RMasciiLength(dir);		RMuint8 count = 0;		RMascii tempdir[256];					// get all directories in the path		j = 0;		// start after first '/'		for(i = 1; i < dirlength; i++){			if(dir[i] != '/')				dirs[count][j++] = dir[i];			else{				dirs[count][j] = '\0';				count++;				if(count > 20)					return RM_ERROR;				j = 0;			}		}				// build path one by one checking for errors and correcting them		RMCopyAscii(tempdir, "/");		RMAppendAscii(tempdir, dirs[0]);// add mnt and skip it from loop		RMAppendAscii(tempdir, "/");		RMCopyAscii(dir, tempdir);	// backup good directory		for(i = 1; i < count; i++){			RMAppendAscii(tempdir, dirs[i]);			RMAppendAscii(tempdir, "/");			d = opendir(tempdir);			if(d != NULL){				closedir(d);				RMAppendAscii(dir, dirs[i]);				RMAppendAscii(dir, "/");				continue;			}			else{				// current dir not found, open last good dir and look for it				d = opendir(dir);				if(d != NULL){					found = FALSE;					while((c = readdir(d))!= NULL){						if(RMCompareAscii(c->d_name, ".") || RMCompareAscii(c->d_name, ".."))							continue;						else{							// match directory with parent directory entries							if(RMCompareAsciiCaseInsensitively(dirs[i], c->d_name)){								// found a match, save it and stop this search								RMAppendAscii(dir, c->d_name);								RMAppendAscii(dir, "/");								RMCopyAscii(tempdir, dir);								found = TRUE;								break;								}						}					}					closedir(d);					if(found == FALSE){						// did not find directory, quit search completely						return RM_ERROR;										}																						}				else{					// fs error, quit					return RM_ERROR;				}			}		}		d = opendir(dir);		if(d == NULL)			return RM_ERROR;	}				// find file in good directory	found = FALSE;	RMASSERT(d != NULL);	while((c = readdir(d))!= NULL){		if(RMCompareAscii(c->d_name, ".") || RMCompareAscii(c->d_name, ".."))			continue;		else{			// compare file name with directory entries			if(RMCompareAsciiCaseInsensitively(name, c->d_name)){				// bingo, save and jump out				RMCopyAscii(name, c->d_name);				found = TRUE;				break;			}		}					}	closedir(d);			if(found){		RMCopyAscii(path, dir);		RMAppendAscii(path, name);		//printf("found case insensitive %s\n", path);		return RM_OK;	}					return RM_ERROR;}