loader_svg_sani.c

一个用于智能手机的多媒体库适合S60 WinCE的跨平台开发库

			field->field_ptr = nf.far_ptr = gf_svg_create_attribute_value(info.fieldType);
			gf_svg_parse_attribute(parser->command->node, &nf, atValue, (u8) info.fieldType);
			if (info.eventType) {
				field->fieldIndex = (u32) -2;
				field->fieldType = info.eventType;
			}
		} else if (opNode) {
			GF_FieldInfo op_field;
			if (gf_node_get_field_by_name(opNode, atOperandAtt, &op_field) != GF_OK)
				return svg_sani_report(parser, GF_BAD_PARAM, "Attribute %s does not belong to node %s", atOperandAtt, atOperandNode);
			parser->command->fromNodeID = gf_node_get_id(opNode);
			parser->command->fromFieldIndex = op_field.fieldIndex;
		}
		gf_node_register(parser->command->node, NULL);
		return GF_OK;
	default:
		return GF_OK;
	}
}


static u32 lsr2_get_command_by_name(const char *name)
{
	if (!strcmp(name, "NewScene")) return GF_SG_LSR_NEW_SCENE;
	else if (!strcmp(name, "RefreshScene")) return GF_SG_LSR_REFRESH_SCENE;
	else if (!strcmp(name, "Add")) return GF_SG_LSR_ADD;
	else if (!strcmp(name, "Clean")) return GF_SG_LSR_CLEAN;
	else if (!strcmp(name, "Replace")) return GF_SG_LSR_REPLACE;
	else if (!strcmp(name, "Delete")) return GF_SG_LSR_DELETE;
	else if (!strcmp(name, "Insert")) return GF_SG_LSR_INSERT;
	else if (!strcmp(name, "Restore")) return GF_SG_LSR_RESTORE;
	else if (!strcmp(name, "Save")) return GF_SG_LSR_SAVE;
	else if (!strcmp(name, "SendEvent")) return GF_SG_LSR_SEND_EVENT;
	return GF_SG_UNDEFINED;
}
static void svg_sani_node_start(void *sax_cbck, const char *name, const char *name_space, const GF_XMLAttribute *attributes, u32 nb_attributes)
{
	SVG_SANI_NodeStack *stack, *parent;
	SVG_SANI_Element *elt;
	GF_SVG_SANI_Parser *parser = (GF_SVG_SANI_Parser *)sax_cbck;

	parent = (SVG_SANI_NodeStack *)gf_list_last(parser->node_stack);

	if (parser->has_root) {
		assert(parent || parser->command);
	}
	elt = svg_sani_parse_element(parser, name, name_space, attributes, nb_attributes, parent);
	if (!elt) {
		if (parent) parent->unknown_depth++;
		return;
	}
	GF_SAFEALLOC(stack, SVG_SANI_NodeStack);
	stack->node = elt;
	gf_list_add(parser->node_stack, stack);

	if (!strcmp(name, "svg") && !parser->has_root) 
		svg_sani_init_root_element(parser, (SVG_SANI_svgElement *)elt);
}

static void svg_sani_node_end(void *sax_cbck, const char *name, const char *name_space)
{
	GF_SVG_SANI_Parser *parser = (GF_SVG_SANI_Parser *)sax_cbck;
	SVG_SANI_NodeStack *top = (SVG_SANI_NodeStack *)gf_list_last(parser->node_stack);

	if (!top) {
		if (parser->laser_au && !strcmp(name, "sceneUnit")) {
			parser->laser_au = NULL;
			return;
		}
		if (parser->command) {
			u32 com_type = lsr2_get_command_by_name(name);
			if (com_type == parser->command->tag) {
				parser->command = NULL;
				return;
			}
		}
	}
	/*only remove created nodes ... */
	if (gf_svg_sa_node_type_by_class_name(name) != TAG_UndefinedNode) {
		const char *the_name;
		SVG_SANI_Element *node = top->node;
		/*check node name...*/
		the_name = gf_node_get_class_name((GF_Node*)node);
		if (strcmp(the_name, name)) {
			if (top->unknown_depth) {
				top->unknown_depth--;
				return;
			} else {
				svg_sani_report(parser, GF_BAD_PARAM, "SVG depth mismatch");
				return;
			}
		}
		free(top);
		gf_list_rem_last(parser->node_stack);

		if (parser->load->flags & GF_SM_LOAD_FOR_PLAYBACK) {
			GF_DOM_Event evt;
			memset(&evt, 0, sizeof(GF_DOM_Event));
			evt.type = GF_EVENT_LOAD;
			gf_dom_event_fire((GF_Node*)node, NULL, &evt);

			/*init animateMotion once all children have been parsed tomake sure we get the mpath child if any*/
			if (node->sgprivate->tag == TAG_SVG_SANI_animateMotion) {
				gf_node_init((GF_Node*)node);
			}
		}
	} else if (top) {
		if (top->unknown_depth) {
			top->unknown_depth--;
			if (!top->unknown_depth) parser->command_depth --;
		} else {
			svg_sani_report(parser, GF_BAD_PARAM, "SVG depth mismatch");
		}
	}
}

static void svg_sani_text_content(void *sax_cbck, const char *text_content, Bool is_cdata)
{
	char *result;
	u32 len;
	Bool space_preserve = 0;
	GF_SVG_SANI_Parser *parser = (GF_SVG_SANI_Parser *)sax_cbck;
	SVG_SANI_Element *node_core, *node;
	SVG_SANI_NodeStack *top = (SVG_SANI_NodeStack *)gf_list_last(parser->node_stack);
	node = top ? (SVG_SANI_Element *) top->node : NULL;
	if (!node && !parser->command) return;
	if (top && top->unknown_depth) return;

	node_core = node;
	if (!node) node_core = (SVG_SANI_Element *)parser->command->node;
	if (!node_core) return;

	result = strdup(text_content);
	len = strlen(text_content);

	if (is_cdata) goto skip_xml_space;

	if (node_core->core->space != XML_SPACE_PRESERVE) {
		u32 j, i, state;
		i = j = 0;
		state = 0;
		for (i=0; i<len; i++) {
			switch (text_content[i]) {
			case '\n': 
			case '\r': 
				break;
			case '\t': 
			case ' ':
				if (j && !state) {
					state = 1;
					result[j] = ' ';
					j++;
				}
				break;
			default:
				result[j] = text_content[i];
				j++;
				state = 0;
				break;
			}
		}
		result[j] = 0;
		len = j;
	}
	else {
		u32 j, i;
		i = j = 0;
		space_preserve = 1;
		for (i=0; i<len; i++) {
			switch (text_content[i]) {
			case '\r': 
				break;
			case '\n': 
			case '\t': 
				result[j] = ' ';
				j++;
				break;
			default:
				result[j] = text_content[i];
				j++;
				break;
			}
		}
		result[j] = 0;
		len = j;
	}

skip_xml_space:
	if (!len) {
		free(result);
		return;
	}

	if (!node) {
		GF_CommandField *field = (GF_CommandField *)gf_list_get(parser->command->command_fields, 0);

		free(result);
		return;
		
		
		if (!field) {
			field = gf_sg_command_field_new(parser->command);
			field->pos = -1;
			field->fieldIndex = (u32) -1;
			field->fieldType = SVG_String_datatype;
		} 
		if (field->fieldType != SVG_String_datatype) return;
		if (!field->field_ptr) 
			field->field_ptr = gf_svg_create_attribute_value(field->fieldType);
		if (*(SVG_String *)field->field_ptr) free(*(SVG_String *)field->field_ptr);

		*(SVG_String *)field->field_ptr = result;
		return;
	}

	switch (gf_node_get_tag((GF_Node *)node)) {
	case TAG_SVG_SANI_text:
	{
		SVG_SANI_textElement *text = (SVG_SANI_textElement *)node;
		u32 baselen = 0;
		if (text->textContent) baselen = strlen(text->textContent);
		if (baselen && space_preserve) {
			text->textContent = (char *)realloc(text->textContent,baselen+len+2);
			strcat(text->textContent, " ");
			strncpy(text->textContent + baselen + 1, result, len);
			text->textContent[baselen+len+1] = 0;
		} else {
			text->textContent = (char *)realloc(text->textContent,baselen+len+1);
			strncpy(text->textContent + baselen, result, len);
			text->textContent[baselen+len] = 0;
		}
		gf_node_changed((GF_Node *)node, NULL);
		free(result);
		return;
	}
	case TAG_SVG_SANI_script:
	{
		SVG_SANI_scriptElement *sc = (SVG_SANI_scriptElement*)node;
		if (sc->textContent) free(sc->textContent);
		sc->textContent = result;
		gf_node_init((GF_Node *)node);
		return;
	}
	case TAG_SVG_SANI_handler:
	{
		SVG_SANI_handlerElement *h = (SVG_SANI_handlerElement*)node;
		if (h->textContent) free(h->textContent);
		h->textContent = result;
		gf_node_init((GF_Node *)node);
		return;
	}
	default:
		if (node->textContent) free(node->textContent);
		node->textContent = result;
		break;
	}
}


static GF_SVG_SANI_Parser *svg_sani_new_parser(GF_SceneLoader *load)
{
	GF_SVG_SANI_Parser *parser;
	if ((load->type==GF_SM_LOAD_XSR) && !load->ctx) return NULL;
	GF_SAFEALLOC(parser, GF_SVG_SANI_Parser);
	parser->node_stack = gf_list_new();
	parser->defered_hrefs = gf_list_new();
	parser->defered_animations = gf_list_new();
	parser->defered_listeners = gf_list_new();

	parser->sax_parser = gf_xml_sax_new(svg_sani_node_start, svg_sani_node_end, svg_sani_text_content, parser);
	parser->load = load;
	load->loader_priv = parser;
	if (load->ctx) load->ctx->is_pixel_metrics = 1;

	return parser;
}

GF_Err gf_sm_load_init_svg_sani(GF_SceneLoader *load)
{
	GF_Err e;
	GF_SVG_SANI_Parser *parser;

	if (!load->fileName) return GF_BAD_PARAM;
	parser = svg_sani_new_parser(load);

	GF_LOG(GF_LOG_INFO, GF_LOG_PARSER, ("SVG_SANI_ Scene Parsing\n"));

	e = gf_xml_sax_parse_file(parser->sax_parser, (const char *)load->fileName, svg_sani_progress);
	if (e<0) return svg_sani_report(parser, e, "Unable to parse file %s: %s", load->fileName, gf_xml_sax_get_error(parser->sax_parser) );
	return parser->last_error;
}

GF_Err gf_sm_load_init_svg_sani_string(GF_SceneLoader *load, char *str_data)
{
	GF_Err e;
	GF_SVG_SANI_Parser *parser = (GF_SVG_SANI_Parser *)load->loader_priv;

	if (!parser) {
		char BOM[6];
		BOM[0] = str_data[0];
		BOM[1] = str_data[1];
		BOM[2] = str_data[2];
		BOM[3] = str_data[3];
		BOM[4] = BOM[5] = 0;
		parser = svg_sani_new_parser(load);
		e = gf_xml_sax_init(parser->sax_parser, (unsigned char*)BOM);
		if (e) {
			svg_sani_report(parser, e, "Error initializing SAX parser: %s", gf_xml_sax_get_error(parser->sax_parser) );
			return e;
		}
		str_data += 4;
	}
	return gf_xml_sax_parse(parser->sax_parser, str_data);
}


GF_Err gf_sm_load_run_svg_sani(GF_SceneLoader *load)
{
	return GF_OK;
}

GF_Err gf_sm_load_done_svg_sani(GF_SceneLoader *load)
{
	GF_SVG_SANI_Parser *parser = (GF_SVG_SANI_Parser *)load->loader_priv;
	if (!parser) return GF_OK;
	while (gf_list_count(parser->node_stack)) {
		SVG_SANI_NodeStack *st = (SVG_SANI_NodeStack *)gf_list_last(parser->node_stack);
		gf_list_rem_last(parser->node_stack);
		free(st);
	}
	gf_list_del(parser->node_stack);
	gf_list_del(parser->defered_hrefs);
	gf_list_del(parser->defered_listeners);
	svg_sani_reset_defered_animations(parser->defered_animations);
	gf_list_del(parser->defered_animations);
	gf_xml_sax_del(parser->sax_parser);
	free(parser);
	load->loader_priv = NULL;
	return GF_OK;
}

#endif	/*GPAC_ENABLE_SVG_SANI*/


#endif