C++ DomNode类代码示例

	bool DomNode::operator ==(const DomNode &other) const
	{
		if (is_null() || other.is_null())
			return is_null() == other.is_null();
		else
			return impl->node_index == other.impl->node_index;
	}

	DomElement DomElement::get_next_sibling_element() const
	{
		DomNode node = get_next_sibling();
		while (!node.is_null() && !node.is_element())
			node = node.get_next_sibling();
		return node.to_element();
	}

void TexturePacker::process_resource(Canvas &canvas, Resource &item_resource, std::vector<Subtexture> &packed_sub_textures, std::map<Texture, std::string> &generated_texture_filenames, int &generated_texture_index, const std::string &image_pathname )
{
	// Found a sprite resource, lets modify its content!
	Resource resource = item_resource;

	// Iterate through all nodes, and remove all previous image tags
	DomElement &element = resource.get_element();
	DomNode cur = element.get_first_child();
	while (!cur.is_null())
	{
		DomNode next = cur.get_next_sibling();
		DomNode::NodeType nodeType = (DomNode::NodeType)cur.get_node_type();

		// Only remove the <image> tag, as we want to keep the other sprite attributes
		if (cur.get_node_name() == "image")
			element.remove_child(cur);

		cur = next;
	}

	// Add new image tag to resource DOM
	std::vector<Subtexture>::size_type index, size;
	size = packed_sub_textures.size();
	for(index = 0; index < size; ++index)
	{
		Subtexture subtexture = packed_sub_textures[index];

		// Try to find out if we already have created a texture-on-disk for this subtexture
		std::string texture_filename;
		Texture2D texture = subtexture.get_texture();
		std::map<Texture, std::string>::iterator it;
		it = generated_texture_filenames.find(texture);
		if(it == generated_texture_filenames.end())
		{
			// Texture not found, generate a filename and dump texture to disk
			texture_filename = string_format("texture%1.png", ++generated_texture_index);
			PNGProvider::save(texture.get_pixeldata(canvas), image_pathname + texture_filename);
			generated_texture_filenames[texture] = texture_filename;
		}
		else
		{
			// Previously dumped textures, lets reuse the filename
			texture_filename = (*it).second;
		}

		// Add <grid> DOM element
		DomElement new_grid_element = element.get_owner_document().create_element("grid");
		new_grid_element.set_attribute("pos", string_format("%1,%2", subtexture.get_geometry().left + last_border_size, subtexture.get_geometry().top + last_border_size));
		new_grid_element.set_attribute("size", string_format("%1,%2", subtexture.get_geometry().get_width()- last_border_size*2, subtexture.get_geometry().get_height()- last_border_size*2));

		// Add <image> DOM element
		DomElement new_image_element = element.get_owner_document().create_element("image");
		new_image_element.set_attribute("file", texture_filename);
		new_image_element.append_child(new_grid_element);

		// Add <image> element under <sprite> element
		element.append_child(new_image_element);
	}
}

	std::string DomNode::select_string(const DomString &xpath_expression) const
	{
		DomNode node = select_node(xpath_expression);
		if (node.is_element())
			return node.to_element().get_text();
		else
			return node.get_node_value();
	}

DomNode DomNamedNodeMap::set_named_item_ns(const DomNode &node)
{
	if (!impl)
		return DomNode();
	DomDocument_Impl *doc_impl = (DomDocument_Impl *) impl->owner_document.lock().get();
	DomString namespace_uri = node.get_namespace_uri();
	DomString local_name = node.get_local_name();
	DomTreeNode *new_tree_node = (DomTreeNode *) node.impl->get_tree_node();
	DomTreeNode *tree_node = impl->get_tree_node();
	if (new_tree_node == tree_node)
		return node;
	unsigned int cur_index = tree_node->first_attribute;
	unsigned int last_index = cl_null_node_index;
	DomTreeNode *cur_attribute = tree_node->get_first_attribute(doc_impl);
	while (cur_attribute)
	{
		std::string lname = cur_attribute->get_node_name();
		std::string::size_type lpos = lname.find_first_of(':');
		if (lpos != std::string::npos)
			lname = lname.substr(lpos + 1);

		if (cur_attribute->get_namespace_uri() == namespace_uri && lname == local_name)
		{
			new_tree_node->parent = cur_attribute->parent;
			new_tree_node->previous_sibling = cur_attribute->previous_sibling;
			new_tree_node->next_sibling = cur_attribute->next_sibling;
			if (cur_attribute->previous_sibling == cl_null_node_index)
				tree_node->first_attribute = node.impl->node_index;
			else
				cur_attribute->get_previous_sibling(doc_impl)->next_sibling = node.impl->node_index;
			if (cur_attribute->next_sibling != cl_null_node_index)
				cur_attribute->get_next_sibling(doc_impl)->previous_sibling = node.impl->node_index;
			cur_attribute->parent = cl_null_node_index;
			cur_attribute->previous_sibling = cl_null_node_index;
			cur_attribute->next_sibling = cl_null_node_index;
			return node;
		}
		last_index = cur_index;
		cur_index = cur_attribute->next_sibling;
		cur_attribute = cur_attribute->get_next_sibling(doc_impl);
	}
	if (last_index == cl_null_node_index)
	{
		tree_node->first_attribute = node.impl->node_index;
		new_tree_node->parent = impl->node_index;
		new_tree_node->previous_sibling = cl_null_node_index;
		new_tree_node->next_sibling = cl_null_node_index;
	}
	else
	{
		new_tree_node->parent = impl->node_index;
		new_tree_node->previous_sibling = last_index;
		new_tree_node->next_sibling = cl_null_node_index;
		doc_impl->nodes[last_index]->next_sibling = node.impl->node_index;
	}
	return node;
}

	DomNode DomNode::named_item(const DomString &name) const
	{
		DomNode node = get_first_child();
		while (node.is_null() == false)
		{
			if (node.get_node_name() == name) return node;
			node = node.get_next_sibling();
		}
		return DomNode();
	}

	bool DomElement::has_attribute_ns(
		const DomString &namespace_uri,
		const DomString &local_name) const
	{
		if (impl)
		{
			DomNode attribute = get_attributes().get_named_item_ns(namespace_uri, local_name);
			return attribute.is_attr();
		}
		return false;
	}

	DomElement DomDocument::get_document_element()
	{
		DomNode cur = get_first_child();
		while (!cur.is_null())
		{
			if (cur.is_element())
				return cur.to_element();
			cur = cur.get_next_sibling();
		}
		return DomElement();
	}

	DomNodeList::DomNodeList(
		DomNode &node,
		const DomString &namespace_uri,
		const DomString &name,
		bool local_name)
	{
		DomNode current_child = node.get_first_child();
		while (!current_child.is_null())
		{
			if (local_name)
			{
				if (current_child.get_namespace_uri() == namespace_uri &&
					current_child.get_local_name() == name)
				{
					add_item(current_child);
				}
			}
			else
			{
				if (current_child.get_namespace_uri() == namespace_uri &&
					current_child.get_node_name() == name)
				{
					add_item(current_child);
				}
			}
			current_child = current_child.get_next_sibling();
		}
	}

int LuaDomElement2::getChildren(lua_State *L)
{
	DomElement* obj = DomElementValue::check2( L, 1 );
	DomNode* n = obj->getFirst();
	lua_newtable( L );
	int t = lua_gettop( L );
	int j = 1;
	while( n )
	{
		if( pushNode( L, n ) )	// Wir wollen nur Text und Element
		{
			lua_rawseti( L, t, j );
			j++;
		}
		n = n->getNext();
	}
	return 1;
}

ProgramObject ProgramObject::load(
    GraphicContext &gc,
    const std::string &resource_id,
    const XMLResourceDocument &resources)
{
    ProgramObject program_object(gc);

    XMLResourceNode resource = resources.get_resource(resource_id);

    DomNode node = resource.get_element().get_first_child();

    while (!node.is_null())
    {
        if (node.is_element())
        {
            DomElement element = node.to_element();
            if (element.get_tag_name() == "shader")
            {
                ShaderObject shader = ShaderObject::load(gc, element.get_attribute("name"), resources);
                program_object.attach(shader);
            }
            else if (element.get_tag_name() == "bind-attribute")
            {
                program_object.bind_attribute_location(
                    StringHelp::text_to_int(element.get_attribute("index")),
                    element.get_attribute("name"));
            }
        }
        node = node.get_next_sibling();
    }

    if (!resource.get_element().get_attribute("shader").empty())
    {
        ShaderObject shader = ShaderObject::load(gc, resource.get_element().get_attribute("shader"), resources);
        program_object.attach(shader);
    }

    if (resource.get_element().get_attribute("link", "true") == "true")
        if(!program_object.link())
            throw Exception(string_format("Unable to link program object: %1", program_object.get_info_log()));

    return program_object;
}

	DomString DomNode::find_prefix(const DomString &namespace_uri) const
	{
		DomElement cur = to_element();
		while (!cur.is_null())
		{
			DomNamedNodeMap attributes = cur.get_attributes();
			int size = attributes.get_length();
			for (int index = 0; index < size; index++)
			{
				DomNode attribute = attributes.item(index);
				if (attribute.get_prefix() == "xmlns" &&
					attribute.get_node_value() == namespace_uri)
				{
					return attribute.get_local_name();
				}
			}
			cur = cur.get_parent_node().to_element();
		}
		return DomString();
	}

ResourceItem *TexturePacker::load_resource(Canvas &canvas, std::string &resource_id, Resource &resource, ResourceManager &resources)
{
	ResourceItem *item = 0;

	try
	{
		std::string type = resource.get_type();
		if(type == "sprite")
		{
			item = load_sprite(canvas, resource_id, resource, resources);
		}
		else if(type == "image")
		{
			item = load_image(canvas, resource_id, resource, resources);
		}
		else
		{
			throw Exception(string_format("Resourcetype %1 is not supported", type));
		}
	}
	catch(Exception ex)
	{
		item = new NotSupportedResourceItem(resource, ex.message);
	}

	// Find resource path by traversing parents
	DomElement &dom_element = resource.get_element();
	DomNode parent = dom_element.get_parent_node();
	while (!parent.is_null())
	{
		DomElement parent_element = parent.to_element();
		std::string parent_name = parent_element.get_attribute("name");
		if(parent_name.length() > 0)
			item->resource_path = string_format("%1/%2", parent_name, item->resource_path);
		parent = parent.get_parent_node();
	}

	return item;
}

	std::string DomElement::get_text() const
	{
		std::string str;
		if (has_child_nodes() == false)
			return str;

		DomNode cur = get_first_child();
		while (!cur.is_null())
		{
			if (cur.is_text() || cur.is_cdata_section())
				str.append(cur.get_node_value());
			if (cur.is_element())
				str.append(cur.to_element().get_text());
			cur = cur.get_next_sibling();
		}
		return str;
	}

void XMLResourceDocument::destroy_resource(const std::string &resource_id)
{
	std::map<std::string, XMLResourceNode>::iterator it;
	it = impl->resources.find(resource_id);
	if (it == impl->resources.end())
		return;
	DomNode cur = it->second.get_element();
	impl->resources.erase(it);
	DomNode parent = cur.get_parent_node();
	while (!parent.is_null())
	{
		parent.remove_child(cur);
		if (parent.has_child_nodes())
			break;
		cur = parent;
		parent = parent.get_parent_node();
	}
}