guiparser.cpp.svn-base

sigmadesign smp8623 gui source code ,bingo

/*****************************************
 Copyright (c) 2001-2003
 Sigma Designs, Inc. All Rights Reserved
 Proprietary and Confidential
 *****************************************/
#ifndef ALLOW_OS_CODE
#define ALLOW_OS_CODE 1
#endif //ALLOW_OS_CODE

#include "../common.h"
#include "guiparser.h"
#include <sys/time.h>
#include <string.h>

// for ascii manipulation ... to be changed
#include "rmcore/include/rmcore.h"
// RMGetCurrentDirectory
#include "rmlibcw/include/rmfile.h"


#define GUIPARSERDBG DISABLE

//#define PARSERDBG_PROFILE

#define RMXML_ROOT	"RMPLAYER_GUI"


RMcuracaoGuiParser::RMcuracaoGuiParser()
	:  m_nbOsdPages(0),
	   m_nbCommands(0),
	   m_nbPopups(0),
	   m_nbIcons(0),
	   m_nbEventBitmaps(0),
	   m_nbSliders(0),
	   m_nbTextTables(0),
	   m_nbMediaFiles(0),
   	   m_nbEvents(0),
	   m_nextButtonId(0),
	   m_nextBitmapId(0),
	   m_nextMenuId(0),
	   m_nextSubMenuButtonId(0),
	   m_nextListId(0),
	   m_nextStringId(0),
	   m_nextChapterId(0)
{
	RMMemset((void*)&m_screenFormat, 0, sizeof(guiScreenFormatType));
	RMMemset((void*)m_osdPages, 0, MAX_GUI_PAGES * sizeof(guiOsdPageType*));
	RMMemset((void*)m_Commands, 0, MAX_GUI_COMMANDS * sizeof(guiCommandType*));
	RMMemset((void*)m_Popups, 0, MAX_GUI_POPUPS * sizeof(guiPopupType*));
	RMMemset((void*)m_Icons, 0, MAX_GUI_ICONS * sizeof(guiIconType*));
	RMMemset((void*)m_EventBitmaps, 0, MAX_GUI_EVENTBITMAPS * sizeof(guiBitmapType*));
	RMMemset((void*)m_Sliders, 0, MAX_GUI_SLIDERS * sizeof(guiSliderType*));
	RMMemset((void*)m_TextTables, 0, MAX_GUI_TEXTTABLES * sizeof(guiTextTableType*));
	RMMemset((void*)m_MediaFiles, 0, MAX_GUI_MEDIA * sizeof(guiMediaType*));
	RMMemset((void*)m_Events, 0, MAX_GUI_EVENTS * sizeof(guiEventType*));
	RMMemset((void*)&m_playerParams, 0, sizeof(guiPlayerParams));
}

RMcuracaoGuiParser::~RMcuracaoGuiParser()
{
	Close();
}

guiOsdPageType* RMcuracaoGuiParser::ParseWEBPage(guiOsdPageType **pages, RMuint8 pageId, RMuint8* buffer, RMuint16 size)
{
	TiXmlElement *pnode;
	TiXmlDocument doc;

	if(doc.LoadFileBuffer((RMascii*)buffer, size) == FALSE){
		fprintf(stderr, "Failed parsing buffer in (row, col) (%d, %d)\n", doc.ErrorRow(), doc.ErrorCol());
		return NULL;
	}

	pnode = doc.FirstChildElement(XMLOSDPAGE_NODE);
	if(pnode == NULL){
		RMDBGLOG((GUIPARSERDBG, "failed to get root element [%s]\n", RMXML_ROOT));
		return NULL;
	}

//	guiOsdPageType* old = (*pages);

	//FreeOsdPage(m_osdPages[pageId]);
	guiOsdPageType* _temp = ParseOsdPage(pnode);

	if(_temp)
	{
		FreeOsdPage(m_osdPages[pageId]);
		m_osdPages[pageId] = _temp;

		m_osdPages[pageId]->id = pageId;
	}

//	(*pages) = m_osdPages[pageId];
//	guiOsdPageType* old = ParseOsdPage(pnode);


	return _temp;
}

guiListItemType* RMcuracaoGuiParser::RefreshListItem(RMuint32 pageId, RMuint16 listId, RMuint16 itemId, RMuint8* buffer, RMuint16 size)
{
	TiXmlElement *pnode;
	TiXmlDocument doc;

	if(doc.LoadFileBuffer((RMascii*)buffer, size) == FALSE){
		fprintf(stderr, "Failed parsing buffer in (row, col) (%d, %d)\n", doc.ErrorRow(), doc.ErrorCol());
		return NULL;
	}

	pnode = doc.FirstChildElement(XMLITEM_NODE);
	if(pnode == NULL){
		RMDBGLOG((GUIPARSERDBG, "failed to get root element [%s]\n", RMXML_ROOT));
		return NULL;
	}

	//guiListType* temp = ParseList(pnode);

	guiListItemType* temp = ParseListItem(pnode, NULL);
	FreeListItem(m_osdPages[pageId]->lists[listId]->items[itemId]);
	m_osdPages[pageId]->lists[listId]->items[itemId] = temp;

	return temp;
}

guiPopupType* RMcuracaoGuiParser::ParseWEBPopup(guiPopupType** popups, RMuint16* nbPopups, RMuint8* buffer, RMuint16 size)
{
	TiXmlElement *pnode;
	TiXmlDocument doc;

	if(doc.LoadFileBuffer((RMascii*)buffer, size) == FALSE){
		fprintf(stderr, "Failed parsing buffer in (row, col) (%d, %d)\n", doc.ErrorRow(), doc.ErrorCol());
		return NULL;
	}

	pnode = doc.FirstChildElement(XMLPOPUP_NODE);
	if(pnode == NULL){
		RMDBGLOG((GUIPARSERDBG, "failed to get root element [%s]\n", RMXML_ROOT));
		return NULL;
	}

	guiPopupType* temp = ParsePopup(pnode);

	for(RMuint16 i = 0; i < m_nbPopups; i ++)
	{
		if(RMCompareAscii(m_Popups[i]->name, temp->name))
		{
			RMuint32 _id = m_Popups[i]->id;
			FreePopup(m_Popups[i]);
			m_Popups[i] = temp;
			popups[i] = temp;
	//		pages[pageId] = temp;
			m_Popups[i]->id = _id;

			return temp;
		}
	}

//	FreeList(m_osdPages[pageId]->lists[listIndex]);
	m_Popups[m_nbPopups++] = temp;
	popups[(*nbPopups)++] = temp;

	return temp;
}

guiListType* RMcuracaoGuiParser::ParseWEBList(guiOsdPageType **pages, RMuint32 pageId, RMuint8* buffer, RMuint16 size)
{
	TiXmlElement *pnode;
	TiXmlDocument doc;

	if(doc.LoadFileBuffer((RMascii*)buffer, size) == FALSE){
		fprintf(stderr, "Failed parsing buffer in (row, col) (%d, %d)\n", doc.ErrorRow(), doc.ErrorCol());
		return NULL;
	}

	pnode = doc.FirstChildElement(XMLLIST_NODE);
	if(pnode == NULL){
		RMDBGLOG((GUIPARSERDBG, "failed to get root element [%s]\n", RMXML_ROOT));
		return NULL;
	}

	guiListType* temp = ParseList(pnode);

	for(RMuint16 i = 0; i < m_osdPages[pageId]->nbLists; i ++)
	{
		if(RMCompareAscii(m_osdPages[pageId]->lists[i]->name, temp->name))
		{
			RMuint32 _id = m_osdPages[pageId]->lists[i]->id;
			FreeList(m_osdPages[pageId]->lists[i]);
			m_osdPages[pageId]->lists[i] = temp;
			pages[pageId]->lists[i] = temp;
			m_osdPages[pageId]->lists[i]->id = _id;
			m_nextListId--;

			return temp;
		}
	}

//	FreeList(m_osdPages[pageId]->lists[listIndex]);
	m_osdPages[pageId]->lists[m_osdPages[pageId]->nbLists++] = temp;
	pages[pageId]->lists[pages[pageId]->nbLists-1] = temp;

	return temp;
}

RMstatus RMcuracaoGuiParser::DoParsing(RMnonAscii *xmlFile)
{
	const RMascii *str;
	TiXmlElement *pnode, *ptempNode;
	TiXmlDocument doc;
#ifdef PARSERDBG_PROFILE
	struct timeval begin, end;
	RMuint32 elapsed;
	gettimeofday(&begin, NULL);
#endif

	if(doc.LoadFile((RMascii*)xmlFile) == FALSE){
		fprintf(stderr, "Failed parsing %s in (row, col) (%d, %d)\n", (RMascii*)xmlFile, doc.ErrorRow(), doc.ErrorCol());
		return RM_ERROR;
	}
#ifdef PARSERDBG_PROFILE
	gettimeofday(&end, NULL);
	elapsed = (end.tv_sec - begin.tv_sec) * 1000 + (end.tv_usec / 1000 - begin.tv_usec / 1000);
	printf("++++++++++++++++++++++++++++LOAD FILE: %ld ms\n", elapsed);
#endif

	pnode = doc.FirstChildElement(RMXML_ROOT);
	if(pnode == NULL){
		RMDBGLOG((GUIPARSERDBG, "failed to get root element [%s]\n", RMXML_ROOT));
		return RM_ERROR;
	}

	str = pnode->Attribute(XMLMAINPAGE_NODE, true);
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read main page name ... error\n"));
		m_playerParams.mainPage = NULL;
		return RM_ERROR;
	}
	else {
		m_playerParams.mainPage = STRDUP(str);
	}

	str = pnode->Attribute(XMLSKIN_NODE, true);
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read the path to bitmaps (DoParsing) ... error\n"));
		m_bitmapsPath = NULL;
		return RM_ERROR;
	}
	else {
//		m_bitmapsPath = STRDUP(str);
		RMnonAscii * cwd = (RMnonAscii *) MALLOC(_MAX_PATH);
		if(RMGetCurrentDirectory(cwd, _MAX_PATH) != RM_OK) {
			cwd = (RMnonAscii *) STRDUP((RMascii *) "");
		}
		if(str[0] != '/')
			m_bitmapsPath = RMCatAscii((RMascii *) cwd, "/", str, NULL);

		if(cwd != NULL) RFREE(cwd);
	}

	str = pnode->Attribute(XMLURL_NODE, true);
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read the path to bitmaps (DoParsing) ... error\n"));
		m_url = NULL;
		return RM_ERROR;
	}
	else {
		m_url = STRDUP(str);
//		RMnonAscii * cwd = (RMnonAscii *) MALLOC(_MAX_PATH);
//		if(RMGetCurrentDirectory(cwd, _MAX_PATH) != RM_OK) {
//			cwd = (RMnonAscii *) STRDUP((RMascii *) "");
//		}
//		if(str[0] != '/')
//			m_bitmapsPath = RMCatAscii((RMascii *) cwd, "/", str, NULL);
//
//		if(cwd != NULL) RFREE(cwd);
	}

	str = pnode->Attribute(XMLMESSAGEPOPUP_NODE, true);
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read message popup ...no errors outside xml will be shown\n"));
		m_playerParams.messagePopup = NULL;
	}
	else {
		m_playerParams.messagePopup = STRDUP(str);
	}

	RMDBGLOG((GUIPARSERDBG, "Path to bitmaps : %s\n", m_bitmapsPath));

	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, (RMascii *)XMLSCREENFORMAT_NODE)) {
			ParseScreenFormat(ptempNode);
		}
		else if (RMCompareAsciiCaseInsensitively (str, (RMascii *)XMLMEDIACONTROL_NODE)) {
			ParseMediaControls(ptempNode);
		}
		else if (RMCompareAsciiCaseInsensitively (str, (RMascii *)XMLOSDPAGELIST_NODE)) {
			ParsePageList(ptempNode);
		}
		else if (RMCompareAsciiCaseInsensitively (str, (RMascii *)XMLCOMMANDLIST_NODE)) {
			ParseCommandList(ptempNode);
		}
		else if (RMCompareAsciiCaseInsensitively (str, (RMascii *)XMLPOPUPLIST_NODE)) {
			ParsePopupList(ptempNode);
		}
		else if (RMCompareAsciiCaseInsensitively (str, (RMascii *)XMLICONLIST_NODE)) {
			ParseIconList(ptempNode);
		}
		else if (RMCompareAsciiCaseInsensitively (str, (RMascii *)XMLEVENTBITMAPLIST_NODE)) {
			ParseEventBitmapList(ptempNode);
		}
		else if (RMCompareAsciiCaseInsensitively (str, (RMascii *)XMLSLIDERLIST_NODE)) {
			ParseSliderList(ptempNode);
		}
		else if (RMCompareAsciiCaseInsensitively (str, (RMascii *)XMLTEXTTABLELIST_NODE)) {
			ParseTextTableList(ptempNode);
		}
		else if (RMCompareAsciiCaseInsensitively (str, (RMascii *)XMLMEDIALIST_NODE)) {
			ParseMediaList(ptempNode);
		}
		else if (RMCompareAsciiCaseInsensitively (str, (RMascii *)XMLEVENTLIST_NODE)) {
			ParseEventList(ptempNode);
		}
		else {
			RMDBGLOG((GUIPARSERDBG, "unknown node [%s] in xml\n", str));
		}
	}
	return RM_OK;
}


RMstatus RMcuracaoGuiParser::GetPlayerParams(guiPlayerParams *params)
{
	RMMemcpy(params, &m_playerParams, sizeof(guiPlayerParams));
	return RM_OK;
}


void RMcuracaoGuiParser::FreePlayerParams()
{
	if(m_playerParams.mainPage != (RMascii*)NULL){
		RFREE(m_playerParams.mainPage);
		m_playerParams.mainPage = NULL;
	}

	if(m_playerParams.messagePopup != (RMascii*)NULL){
		RFREE(m_playerParams.messagePopup);
		m_playerParams.messagePopup = NULL;
	}
}

RMstatus RMcuracaoGuiParser::Close()
{
	RMuint16 i;

	FreePlayerParams();

	if(m_bitmapsPath != (RMascii*)NULL){
		RFREE(m_bitmapsPath);
		m_bitmapsPath = NULL;
	}

	if(m_url != (RMascii*) NULL)
	{
		RFREE(m_url);
		m_url = NULL;
	}

	for(i = 0; i < m_nbOsdPages; i++){
		FreeOsdPage(m_osdPages[i]);
		m_osdPages[i] = NULL;
	}

	FreeMediaControls(m_mediaControls);

	for(i = 0; i < m_nbCommands; i++){
		FreeCommand(m_Commands[i]);
		m_Commands[i] = NULL;
	}

	for(i = 0; i < m_nbPopups; i++){
		FreePopup(m_Popups[i]);
		m_Popups[i] = NULL;
	}

	for(i = 0; i < m_nbIcons; i++){
		FreeIcon(m_Icons[i]);
		m_Icons[i] = NULL;
	}

	for(i = 0; i < m_nbEventBitmaps; i++){
		FreeBitmap(m_EventBitmaps[i]);
		m_EventBitmaps[i] = NULL;
	}

	for(i = 0; i < m_nbSliders; i++){
		FreeSlider(m_Sliders[i]);
		m_Sliders[i] = NULL;
	}

	for(i = 0; i < m_nbTextTables; i++){
		FreeTextTable(m_TextTables[i]);
		m_TextTables[i] = NULL;
	}

	for(i = 0; i < m_nbMediaFiles; i++){
		FreeMediaFile(m_MediaFiles[i]);
		m_MediaFiles[i] = NULL;
	}

	for(i = 0; i < m_nbEvents; i++){
		FreeEvent(m_Events[i]);
		m_Events[i] = NULL;
	}

	return RM_OK;
}


////////////////////////////////////////////////////////////////////////////////
// SCREEN FORMAT
////////////////////////////////////////////////////////////////////////////////


RMstatus RMcuracaoGuiParser::ParseScreenFormat(TiXmlElement *pnode)
{
	const RMascii *str;

	str = pnode->Attribute(XMLWIDTH_NODE, true);
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read width (ParseScreenFormat)... error\n"));
		return RM_ERROR;
	}
	else {
		RMasciiToUInt16 (str, &(m_screenFormat.width));
	}

	str = pnode->Attribute(XMLHEIGHT_NODE, true);
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read height (ParseScreenFormat)... error\n"));
		return RM_ERROR;
	}
	else {
		RMasciiToUInt16 (str, &(m_screenFormat.height));
	}

	str = pnode->Attribute(XMLDEFAULT_NODE, true);
	if (str != (RMascii *)NULL) {
		if (RMCompareAsciiCaseInsensitively (str, "TRUE")) {
			m_screenFormat.isDefault = TRUE;
		}
		else if (RMCompareAsciiCaseInsensitively (str, "FALSE")) {
			m_screenFormat.isDefault = FALSE;
		}
		else {
			RMDBGLOG((GUIPARSERDBG, "Invalid default value (ParseScreenFormat)... error\n"));
			return RM_ERROR;
		}
	}
	else
		m_screenFormat.isDefault = FALSE;

	RMDBGLOG((GUIPARSERDBG, "Screen format : wdth=%d, height=%d, default=%s\n",
		  m_screenFormat.width,
		  m_screenFormat.height,
		  m_screenFormat.isDefault?"TRUE":"FALSE"));

	return RM_OK;
}




RMstatus RMcuracaoGuiParser::GetScreenFormat(guiScreenFormatType* screenFormat)
{
	RMMemcpy(screenFormat, &m_screenFormat, sizeof(guiScreenFormatType));
	return RM_OK;
}