wmvhdparser.cpp

sigmadesign smp8623 gui source code ,bingo

void RMWmvHDParser::FreeEvent(guiEventType *event)
{
	if(event == NULL)
		return;
		
	if(event->name != (RMascii *)NULL){
		RFREE(event->name);
		event->name = NULL;
	}
	if(event->command != (RMascii *)NULL){
		RFREE(event->command);
		event->command = NULL;
	}
	if(event->link != (RMascii *)NULL){
		RFREE(event->link);
		event->link = NULL;
	}
	if(event->value != (RMascii *)NULL){
		RFREE(event->value);
		event->value = NULL;
	}
	RFREE(event);	
}

////////////////////////////////////////////////////////////////////////////////
// BUTTONS
////////////////////////////////////////////////////////////////////////////////

guiButtonType *RMWmvHDParser::ParseButton(TiXmlElement *pnode)
{
	const RMascii *str;
	guiButtonType *button;
	RMGuiObjectState state;
	RMuint64 color;
	
	button = (guiButtonType*) CALLOC(1, sizeof(guiButtonType));
	RMMemset(&button->object, 0, sizeof(RMButtonObject));
	
	str = pnode->Attribute(XMLID_NODE, true);	// name
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read id of button (ParseButton) ... error\n"));
		goto invalidButton;
	}
	else {
		button->name = STRDUP(str);
	}
	
	str = pnode->Attribute(XMLSRC_NODE, true);	// file
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read src (ParseButton) ... error\n"));
	}
	else {
		button->object.file = RMCatAscii(m_mountPoint, str, NULL);
		if(IsValidPath(button->object.file) == FALSE){
			if(RMFAILED(FindFile(button->object.file))){
				RMDBGLOG((GUIPARSERDBG, "Invalid path given for bitmap (ParseImage) ... error\n"));
				goto invalidButton;
			}
		}
	}

	str = pnode->Attribute(XMLHOVERSRC_NODE, true);	// selectedFile
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read hoversrc (ParseButton) ... error\n"));
	}
	else {
		button->object.selectedFile = RMCatAscii(m_mountPoint, str, NULL);
		if(IsValidPath(button->object.selectedFile) == FALSE){
			if(RMFAILED(FindFile(button->object.selectedFile))){
				RMDBGLOG((GUIPARSERDBG, "Invalid path given for bitmap (ParseImage) ... error\n"));
				goto invalidButton;
			}
		}
	}

	str = pnode->Attribute(XMLLEFT_NODE, true);	// x
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read left of button (ParseButton) ... error\n"));
		goto invalidButton;
	}
	else {
		RMasciiToUInt16 (str, &(button->object.x));
	}

	str = pnode->Attribute(XMLTOP_NODE, true);	// y
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read x of button (ParseButton) ... error\n"));
		goto invalidButton;
	}
	else {
		RMasciiToUInt16 (str, &(button->object.y));
	}

	str = pnode->Attribute(XMLWIDTH_NODE, true);	// width
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read width of button (ParseButton) ... error\n"));
		goto invalidButton;
	}
	else {
		RMasciiToUInt16 (str, &(button->object.width));
	}

	str = pnode->Attribute(XMLHEIGHT_NODE, true);	// height
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read height of button (ParseButton) ... error\n"));
		goto invalidButton;
	}
	else {		
		RMasciiToUInt16 (str, &(button->object.height));
	}

	str = pnode->Attribute(XMLBACKGROUNDCOLOR_NODE, true);
	if (str == (RMascii *)NULL) {
//		RMDBGLOG((GUIPARSERDBG, "Could not read backgroundcolor of button (ParseButton) ... ignoring\n"));
	}
	else {		
		if((str[0] == '0') &&
		   (str[1] == 'x')) {
			// hexa
			RMasciiHexToUint64(str+2, &color);
			button->object.backgroundcolor = (RMuint32)color;
		}
		else {
			RMasciiToUInt32 (str, &(button->object.backgroundcolor));
		}
	}

	str = pnode->Attribute(XMLFOREGROUNDCOLOR_NODE, true);
	if (str == (RMascii *)NULL) {
//		RMDBGLOG((GUIPARSERDBG, "Could not read foregroundcolor of button (ParseButton) ... ignoring\n"));
	}
	else {		
		if((str[0] == '0') &&
		   (str[1] == 'x')) {
			// hexa
			RMasciiHexToUint64(str+2, &color);
			button->object.foregroundcolor = (RMuint32)color;
		}
		else {
			RMasciiToUInt32 (str, &(button->object.foregroundcolor));
		}
	}
	
	str = pnode->Attribute(XMLOUTLINECOLOR_NODE, true);
	if (str == (RMascii *)NULL) {
//		RMDBGLOG((GUIPARSERDBG, "Could not read button outline color (ParseButton) ... optional\n"));
	}
	else {		
		if((str[0] == '0') &&
		   (str[1] == 'x')) {
			// hexa
			RMasciiHexToUint64(str+2, &color);
			button->object.outlinecolor = (RMuint32)color;			
		}
		else {
			RMasciiToUInt32 (str, &(button->object.outlinecolor));
		}
	}
	
	str = pnode->Attribute(XMLTRANSPARENTCOLOR_NODE, true);
	if (str == (RMascii *)NULL) {
//		RMDBGLOG((GUIPARSERDBG, "Could not read button transparent color... error\n"));
	}
	else {		
		if((str[0] == '0') &&
		   (str[1] == 'x')) {
			// hexa
			RMasciiHexToUint64(str+2, &color);
			button->object.transparentcolor = (RMuint32)color;			
		}
		else {
			RMasciiToUInt32 (str, &(button->object.transparentcolor));
		}
	}
	
	str = pnode->Attribute(XMLUSETRANSPARENTCOLOR_NODE, true);
	if (str != (RMascii *)NULL) {
		if (RMCompareAsciiCaseInsensitively (str, "TRUE")) {
			button->object.usetransparentcolor = TRUE;
		}
		else if (RMCompareAsciiCaseInsensitively (str, "FALSE")) {
			button->object.usetransparentcolor = FALSE;
		}
		else {
			RMDBGLOG((GUIPARSERDBG, "Invalid usetransparentcolor value of button ... error\n"));
			goto invalidButton;
		}	
	}
	else
		button->object.usetransparentcolor = FALSE;


	str = pnode->Attribute(XMLFONTFILE_NODE, true);
	if (str == (RMascii *)NULL) {
//		RMDBGLOG((GUIPARSERDBG, "Could not read fontfile of button (ParseButton) ... optional\n"));
		// could be a bitmapped button
	}
	else {
		button->object.fontfile = STRDUP(str);
	}

	str = pnode->Attribute(XMLCHARWIDTH_NODE, true);
	if (str == (RMascii *)NULL) {
//		RMDBGLOG((GUIPARSERDBG, "Could not read charwidth of button (ParseButton) ... optional\n"));
		//no fail here sice we could be using pre-defined fonts
	}
	else {		
		RMasciiToUInt8 (str, &(button->object.charwidth));
	}
	
	str = pnode->Attribute(XMLTEXTALIGN_NODE, true);
	if (str == (RMascii *)NULL) {
//		RMDBGLOG((GUIPARSERDBG, "Could not read button text alignment... (Parse Button) default to ALIGN_CENTER\n"));
	 	button->object.textalign = ALIGN_CENTER;
	}
	else {
		if(RMCompareAsciiCaseInsensitively(str, "ALIGN_LEFT")){
			button->object.textalign = ALIGN_LEFT;
		}
		else if(RMCompareAsciiCaseInsensitively(str, "ALIGN_RIGHT")){
			button->object.textalign = ALIGN_RIGHT;
		}
		else
			button->object.textalign = ALIGN_CENTER;	
	}
	
	str = pnode->Attribute(XMLROUNDED_NODE, true);
	if (str != (RMascii *)NULL) {
		if (RMCompareAsciiCaseInsensitively (str, "TRUE")) {
			button->object.rounded = TRUE;
		}
		else if (RMCompareAsciiCaseInsensitively (str, "FALSE")) {
			button->object.rounded = FALSE;
		}
		else {
			RMDBGLOG((GUIPARSERDBG, "Invalid rounded value of button ... (Parse Button) optional\n"));
		}	
	}
	else
		button->object.rounded = FALSE;

	str = pnode->Attribute(XMLTEXT_NODE, true);
	if (str == (RMascii *)NULL) {
//		RMDBGLOG((GUIPARSERDBG, "Could not read text of button (ParseButton) ... optional\n"));
		// could be a bitmapped button
	}
	else {
		button->object.text = STRDUP(str);
	}

	str = pnode->Attribute(XMLSTATE_NODE, true);
	if (str == (RMascii *)NULL) {
//		RMDBGLOG((GUIPARSERDBG, "Could not read button state (Parse Button)... default to enabled\n"));
		button->object.state = STATE_ENABLED;
	}
	else {
		if(RMCompareAsciiCaseInsensitively(str, "STATE_DISABLED")){
			state = STATE_DISABLED;
		}
		else
			state = STATE_ENABLED;	// cannot have focus from xml
		button->object.state = state;
	}

	str = pnode->Attribute(XMLNAVDOWN_NODE, true);	// keydown
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read navdown of button (ParseButton) ... optional\n"));
	}
	else {
		button->keydown = STRDUP(str);
	}
	
	str = pnode->Attribute(XMLNAVUP_NODE, true);	// keyup
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read navup of button (ParseButton) ... optional\n"));
	}
	else {
		button->keyup = STRDUP(str);
	}

	str = pnode->Attribute(XMLNAVLEFT_NODE, true);	// keyleft
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read navleft of button (ParseButton) ... optional\n"));
	}
	else {
		button->keyleft = STRDUP(str);
	}

	str = pnode->Attribute(XMLNAVRIGHT_NODE, true);	// keyright
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read navright of button (ParseButton) ... optional\n"));
	}
	else {
		button->keyright = STRDUP(str);
	}
	
	str = pnode->Attribute(XMLZINDEX_NODE, true);
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read zIndex of button (ParseButton) ... default to 0\n"));
		button->object.zIndex = 0;
	}
	else {
		RMasciiToUInt8 (str, &(button->object.zIndex));
	}

	// add event
	str = pnode->Attribute(XMLACTION_NODE, true);	// activate event
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read button action (ParseButton) ... error\n"));
		goto invalidButton;
	}
	else {
		if(RMFAILED(SetButtonAction(button, str))){
			RMDBGLOG((GUIPARSERDBG, "Error parsing button action (ParseButton) ... error\n"));
			goto invalidButton;
		}			
	}

//	RMDBGLOG((GUIPARSERDBG, "Button : name : %s, x=%d, y=%d, width=%d, height=%d, backgroundcolor=0x%lX, foregroundcolor=0x%lX, fontfile : %s, charwidth : %d, rounded=%d, text : %s, state : %d, visible : %s, keydown : %s\n",
//		  button->name, button->object.x, button->object.y, button->object.width, button->object.height, button->object.backgroundcolor,
//		  button->object.foregroundcolor, button->object.fontfile, button->object.charwidth, button->object.rounded, button->object.text, button->object.state, button->object.visible ? "TRUE":"FALSE", button->keydown));

	// set id + visibility
	button->object.visible = TRUE;
	button->id = BUTTON_IDMASK | m_nextButtonId++;
	
	return button;
 invalidButton:
	FreeButton(button);
	return (guiButtonType*)NULL;
}


RMstatus RMWmvHDParser::SetButtonAction(guiButtonType *button, const RMascii *actionstr)
{
	RMascii temp[128];
	RMbool getvalue = TRUE;
	RMbool done;
	
	// allocate event
	button->events[button->nbEvents] = (guiEventType*) CALLOC(1, sizeof(guiEventType));
	if(button->events[button->nbEvents] == NULL)
		return RM_ERROR;
		
	// set name
	button->events[button->nbEvents]->name = STRDUP(ACTIVATE_EVENT);

	// determine command
	memset(temp, 0, sizeof(temp));
	RMasciiToLower(actionstr, temp);
	if(strstr(temp, DISC_SETSUBTITLE) != NULL){
		button->events[button->nbEvents]->command = STRDUP("SET_SUBTITLE_COMMAND");
	}
	else if(strstr(temp, DISC_SETAUDIOTRACK) != NULL){
		button->events[button->nbEvents]->command = STRDUP("SET_AUDIO_TRACK_COMMAND");
		// get link
		RMuint8 k = 0;
		done = FALSE;
		memset(temp, 0, sizeof(temp));
		for(RMuint8 i = 0; i < RMasciiLength(actionstr); i++){
			if(actionstr[i] == '.'){
				for(RMuint8 j = i + 1; j < RMasciiLength(actionstr); j++){
					if(actionstr[j] != 0x20){
						if(actionstr[j] == '.'){
							done = TRUE;
							break;	
						}
						else
							temp[k++] = actionstr[j];
					}
				}
				if(done) break;
			}
		}
		if(done){
			button->events[button->nbEvents]->link = STRDUP(temp);
		}
	}
	else if(strstr(temp, DISC_SETMAINMENU) != NULL){
		button->events[button->nbEvents]->command = STRDUP("SET_MAIN_MENU_COMMAND");
	}
	else{	// assume OnActivate action
		button->events[button->nbEvents]->command = STRDUP("ACTIVATE_OBJECT_COMMAND");
		button->events[button->nbEvents]->link = STRDUP(actionstr);
		getvalue = FALSE;
	}

	// set value (if required)
	done = FALSE;
	if(getvalue){
		RMuint8 k = 0;
		memset(temp, 0, sizeof(temp));
		for(RMuint8 i = 0; i < RMasciiLength(actionstr); i++){
			if(actionstr[i] == '('){
				for(RMuint8 j = i + 1; j < RMasciiLength(actionstr); j++){
					if(actionstr[j] != 0x20){
						if(actionstr[j] == ')'){
							done = TRUE;
							break;	
						}
						else
							temp[k++] = actionstr[j];
					}
				}
				if(done) break;
			}
		
		}
		if(done){
			button->events[button->nbEvents]->value = STRDUP(temp);
		}
	}
	
	// button action
//	printf("name: %s, command: %s, link: %s\n", button->events[button->nbEvents]->name,
//			button->events[button->nbEvents]->command,
//			button->events[button->nbEvents]->link);
	button->nbEvents++;
	return RM_OK;
}



void RMWmvHDParser::FreeButton(guiButtonType *button)
{
	if(button == NULL)
		return;
	
	if(button->name != (RMascii *)NULL){
		RFREE(button->name);
		button->name = NULL;
	}
	if(button->object.file != (RMascii *)NULL){
		RFREE(button->object.file);
		button->object.file = NULL;
	}
	if(button->object.fontfile != (RMascii *)NULL){
		RFREE(button->object.fontfile);
		button->object.fontfile = NULL;
	}
	if(button->object.selectedFile != (RMascii *)NULL){
		RFREE(button->object.selectedFile);
		button->object.selectedFile = NULL;
	}

	if(button->object.text != (RMascii *)NULL){
		RFREE(button->object.text);
		button->object.text = NULL;
	}		
	if(button->keydown != (RMascii *)NULL){
		RFREE(button->keydown);
		button->keydown = NULL;
	}
	if(button->keyup != (RMascii *)NULL){
		RFREE(button->keyup);
		button->keyup = NULL;
	}
	if(button->keyleft != (RMascii *)NULL){
		RFREE(button->keyleft);
		button->keyleft = NULL;
	}
	if(button->keyright != (RMascii *)NULL){
		RFREE(button->keyright);
		button->keyright = NULL;
	}
	for(RMuint16 i = 0; i < button->nbEvents; i++){
		FreeEvent(button->events[i]);
		button->events[i] = NULL;
	}

	RFREE(button);	
}



////////////////////////////////////////////////////////////////////////////////
// BITMAPS -- aka IMAGES
////////////////////////////////////////////////////////////////////////////////

guiBitmapType *RMWmvHDParser::ParseBitmap(TiXmlElement *pnode)
{
	const RMascii *str;
	guiBitmapType *bitmap;
	RMuint64 color;

	bitmap = (guiBitmapType*) CALLOC(1, sizeof(guiBitmapType));
	RMMemset(&bitmap->object, 0, sizeof(RMBitmapObject));
	
	str = pnode->Attribute(XMLID_NODE, true);		// name
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read id of image (ParseImage) ... error\n"));
		goto invalidBitmap;
	}
	else {
		bitmap->name = STRDUP(str);
	}
	
	str = pnode->Attribute(XMLSRC_NODE, true);	// file
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read src of image (ParseImage) ... error\n"));
		goto invalidBitmap;
	}
	else {
		bitmap->object.file = RMCatAscii(m_mountPoint, str, NULL);
		if(IsValidPath(bitmap->object.file) == FALSE){
			if(RMFAILED(FindFile(bitmap->object.file))){
				RMDBGLOG((GUIPARSERDBG, "Invalid path given for bitmap (ParseImage) ... error\n"));
				goto invalidBitmap;
			}
		}
	}
	
	str = pnode->Attribute(XMLLEFT_NODE, true);	// x
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read left of image (ParseImage) ... error\n"));
		goto invalidBitmap;
	}
	else {
		RMasciiToUInt16 (str, &(bitmap->object.x));
	}

	str = pnode->Attribute(XMLTOP_NODE, true);	// y
	if (str == (RMascii *)NULL) {