C++ DOMNode::hasAttributes方法代码示例

bool DOMNodeImpl::isDefaultNamespace(const XMLCh* namespaceURI) const{
	DOMNode *thisNode = castToNode(this);
    short type = thisNode->getNodeType();
    switch (type) {
    case DOMNode::ELEMENT_NODE: {
        const XMLCh *prefix = thisNode->getPrefix();

        // REVISIT: is it possible that prefix is empty string?
        if (prefix == 0 || !*prefix) {
            return XMLString::equals(namespaceURI, thisNode->getNamespaceURI());
        }

        if (thisNode->hasAttributes()) {
            DOMElement *elem = (DOMElement *)thisNode;
            DOMNode *attr = elem->getAttributeNodeNS(XMLUni::fgXMLNSURIName, XMLUni::fgXMLNSString);
            if (attr != 0) {
                const XMLCh *value = attr->getNodeValue();
                return XMLString::equals(namespaceURI, value);
            }
        }
        DOMNode *ancestor = getElementAncestor(thisNode);
        if (ancestor != 0) {
            return ancestor->isDefaultNamespace(namespaceURI);
        }

        return false;
    }
    case DOMNode::DOCUMENT_NODE:{
        return ((DOMDocument*)thisNode)->getDocumentElement()->isDefaultNamespace(namespaceURI);
    }

    case DOMNode::ENTITY_NODE :
    case DOMNode::NOTATION_NODE:
    case DOMNode::DOCUMENT_FRAGMENT_NODE:
    case DOMNode::DOCUMENT_TYPE_NODE:
        // type is unknown
        return false;
    case DOMNode::ATTRIBUTE_NODE:{
        if (fOwnerNode->getNodeType() == DOMNode::ELEMENT_NODE) {
            return fOwnerNode->isDefaultNamespace(namespaceURI);

        }
        return false;
    }
    default:{
        DOMNode *ancestor = getElementAncestor(thisNode);
        if (ancestor != 0) {
            return ancestor->isDefaultNamespace(namespaceURI);
        }
        return false;
    }

    }
}

const XMLCh* DOMNodeImpl::lookupNamespacePrefix(const XMLCh* const namespaceURI, bool useDefault, DOMElement *el) const {
    DOMNode *thisNode = castToNode(this);

    const XMLCh* ns = thisNode->getNamespaceURI();
    // REVISIT: if no prefix is available is it null or empty string, or
    //          could be both?
    const XMLCh* prefix = thisNode->getPrefix();

    if (ns != 0 && XMLString::equals(ns,namespaceURI)) {
        if (useDefault || prefix != 0) {
            const XMLCh* foundNamespace =  el->lookupNamespaceURI(prefix);
            if (foundNamespace != 0 && XMLString::equals(foundNamespace, namespaceURI)) {
                return prefix;
            }
        }
    }
    if (thisNode->hasAttributes()) {
        DOMNamedNodeMap *nodeMap = thisNode->getAttributes();

        if(nodeMap != 0) {
            int length = nodeMap->getLength();

            for (int i = 0;i < length;i++) {
                DOMNode *attr = nodeMap->item(i);
                const XMLCh* attrPrefix = attr->getPrefix();
                const XMLCh* value = attr->getNodeValue();

                ns = attr->getNamespaceURI();

                if (ns != 0 && XMLString::equals(ns, XMLUni::fgXMLNSURIName)) {
                    // DOM Level 2 nodes
                    if ((useDefault && XMLString::equals(attr->getNodeName(), XMLUni::fgXMLNSString)) ||
                        (attrPrefix != 0 && XMLString::equals(attrPrefix, XMLUni::fgXMLNSString)) &&
                        XMLString::equals(value, namespaceURI)) {
                        const XMLCh* localname= attr->getLocalName();
                        const XMLCh* foundNamespace = el->lookupNamespaceURI(localname);
                        if (foundNamespace != 0 && XMLString::equals(foundNamespace, namespaceURI)) {
                            return localname;
                        }
                    }
                }
            }
        }
    }
    DOMNode *ancestor = getElementAncestor(thisNode);
    if (ancestor != 0) {
        return castToNodeImpl(ancestor)->lookupNamespacePrefix(namespaceURI, useDefault, el);
    }
    return 0;
}

string InputHandler::getAttributeValueByName(const XMLCh* elementNode, const XMLCh* attribute, const XMLCh* name)
{

     crusde_debug("%s, line: %d, InputHandler::getAttributeValueByName(%s) name = %s ", __FILE__, __LINE__, XMLString::transcode(elementNode),
     XMLString::transcode(name));
     assert(doc);

     DOMElement *root = doc->getDocumentElement();
     DOMNode *child = root->getFirstChild();
     DOMNamedNodeMap *attributes = NULL;
		
     while (child)
     {
          if(child != NULL)
               if( child->getNodeType() == DOMNode::ELEMENT_NODE )
               {
                    if(child->hasAttributes())
                    {
                         attributes = child->getAttributes();

                         if( XMLString::compareIString( child->getNodeName(), elementNode) == 0 && 
                             XMLString::compareIString( attributes->getNamedItem(ATTR_name.xmlStr())->getNodeValue(), name) == 0 )
                         {
                              char *val = XMLString::transcode(attributes->getNamedItem(attribute)->getNodeValue());
                              string value(val);
                              XMLString::release(&val);
                              return value;
                         }
                    }
               }

          child = child->getNextSibling();
     }
	
     return string();
}

bool CConfigParser::ParseButtons(DOMNode* node, TActionByNameMap actions, CDeviceContext* device)
{
	if(node->hasChildNodes())
	{
		DOMNodeList* buttonNodes = node->getChildNodes();
		unsigned long length = buttonNodes->getLength();
		for(unsigned long idx = 0; idx < length; idx++)
		{
			DOMNode* buttonNode = buttonNodes->item(idx);
			wstring nodeName = buttonNode->getNodeName();
			if(buttonNode->hasAttributes())
			{
				DOMNode* mouseSim = buttonNode->getAttributes()->getNamedItem(L"simulateMouseButton");
				if(mouseSim != NULL)
				{
					wstring mouseSimBtn = mouseSim->getNodeValue();
					if(mouseSimBtn.compare(L"left") == 0)
						device->AddButton(new CLeftMouseButtonAction());
					if(mouseSimBtn.compare(L"right") == 0)
						device->AddButton(new CRightMouseButtonAction());
				}
				else
				{
					wstring downAction = buttonNode->getAttributes()->getNamedItem(L"downAction")->getNodeValue();
					wstring upAction = buttonNode->getAttributes()->getNamedItem(L"upAction")->getNodeValue();
					device->AddButton(new CActionButton(actions[downAction], actions[upAction]));
				}
			}
			else if (nodeName.compare(L"button") == 0)
			{
				device->AddButton((IButton*)NULL);
			}
		}
	}
	return false;
}

const XMLCh* DOMNodeImpl::lookupNamespaceURI(const XMLCh* specifiedPrefix) const  {
    DOMNode *thisNode = castToNode(this);

    short type = thisNode->getNodeType();
    switch (type) {
    case DOMNode::ELEMENT_NODE : {
        const XMLCh* ns = thisNode->getNamespaceURI();
        const XMLCh* prefix = thisNode->getPrefix();
        if (ns != 0) {
            // REVISIT: is it possible that prefix is empty string?
            if (specifiedPrefix == 0 && prefix == specifiedPrefix) {
                // looking for default namespace
                return ns;
            } else if (prefix != 0 && XMLString::equals(prefix, specifiedPrefix)) {
                // non default namespace
                return ns;
            }
        }
        if (thisNode->hasAttributes()) {
            DOMNamedNodeMap *nodeMap = thisNode->getAttributes();
            if(nodeMap != 0) {
                int length = nodeMap->getLength();
                for (int i = 0;i < length;i++) {
                    DOMNode *attr = nodeMap->item(i);
                    const XMLCh *attrPrefix = attr->getPrefix();
                    const XMLCh *value = attr->getNodeValue();
                    ns = attr->getNamespaceURI();

                    if (ns != 0 && XMLString::equals(ns, XMLUni::fgXMLNSURIName)) {
                        // at this point we are dealing with DOM Level 2 nodes only
                        if (specifiedPrefix == 0 &&
                            XMLString::equals(attr->getNodeName(), XMLUni::fgXMLNSString)) {
                            // default namespace
                            return value;
                        } else if (attrPrefix != 0 &&
                                   XMLString::equals(attrPrefix, XMLUni::fgXMLNSString) &&
                                   XMLString::equals(attr->getLocalName(), specifiedPrefix)) {
                            // non default namespace
                            return value;
                        }
                    }
                }
            }
        }
        DOMNode *ancestor = getElementAncestor(thisNode);
        if (ancestor != 0) {
            return ancestor->lookupNamespaceURI(specifiedPrefix);
        }
        return 0;
    }
    case DOMNode::DOCUMENT_NODE : {
        return((DOMDocument*)thisNode)->getDocumentElement()->lookupNamespaceURI(specifiedPrefix);
    }
    case DOMNode::ENTITY_NODE :
    case DOMNode::NOTATION_NODE:
    case DOMNode::DOCUMENT_FRAGMENT_NODE:
    case DOMNode::DOCUMENT_TYPE_NODE:
        // type is unknown
        return 0;
    case DOMNode::ATTRIBUTE_NODE:{
        if (fOwnerNode->getNodeType() == DOMNode::ELEMENT_NODE) {
            return fOwnerNode->lookupNamespaceURI(specifiedPrefix);
        }
        return 0;
    }
    default:{
        DOMNode *ancestor = getElementAncestor(castToNode(this));
        if (ancestor != 0) {
            return ancestor->lookupNamespaceURI(specifiedPrefix);
        }
        return 0;
    }
    }
}

bool CConfigParser::ParseActions(DOMNodeList* actionNodeList, ADeviceListener& configClass)
{
	USES_CONVERSION;
	// Parse all the actions	
	if(actionNodeList != NULL && actionNodeList->getLength() > 0)
	{
		DOMNodeList* actionNodes = actionNodeList->item(0)->getChildNodes();
		for(unsigned long i = 0; i < actionNodes->getLength(); i++)
		{
			DOMNode* actionNode = actionNodes->item(i);
			wstring actionType = actionNode->getNodeName();
			if(actionType.compare(L"#text") == 0)
				continue;
			XMLCh* xmlChNameTxt = L"name";
			wstring actionName;
			if(actionNode->hasAttributes())
			{
				DOMNode* nameAttribute = actionNode->getAttributes()->getNamedItem(xmlChNameTxt);
				actionName = nameAttribute->getNodeValue();
			}			
			if(actionType.compare(L"sendCopyDataWindowMessage") == 0 || actionType.compare(L"sendCommandWindowMessage") == 0)
			{
				wstring message = actionNode->getAttributes()->getNamedItem(L"message")->getNodeValue();
				bool findByClass = FALSE;
				wstring windowAttributeName = L"window";
				if(actionNode->getAttributes()->getNamedItem(L"window") == NULL)
				{
					findByClass = TRUE;
					windowAttributeName = L"windowClass";
				}
				wstring window = actionNode->getAttributes()->getNamedItem(windowAttributeName.c_str())->getNodeValue();

				CSendWindowMessageAction* messageActionToAdd = NULL;
				if(actionType.compare(L"sendCommandWindowMessage") == 0)
				{
					messageActionToAdd = new CSendWindowMessageAction(_wtol(message.c_str()), OLE2T(window.c_str()), findByClass);
				}
				if(actionType.compare(L"sendCopyDataWindowMessage") == 0)
				{
					messageActionToAdd = new CSendWindowMessageAction(OLE2T(message.c_str()), OLE2T(window.c_str()), findByClass);
				}

				if(messageActionToAdd != NULL)
					configClass.AddAction(actionName, messageActionToAdd);
			}
			if(actionType.compare(L"execute") == 0)
			{
				char* executable = XMLString::transcode(
					actionNode->getAttributes()->getNamedItem(L"executable")->getNodeValue());
				char* commandline = XMLString::transcode(
					actionNode->getAttributes()->getNamedItem(L"commandline")->getNodeValue());
				configClass.AddAction(actionName, new CExecuteAction(executable, commandline));
				XMLString::release(&executable);
				XMLString::release(&commandline);
			}
			if(actionType.compare(L"keyPress") == 0)
			{
				TKeyList keys;

				DOMNodeList* keyNodes = actionNode->getChildNodes();
				unsigned long count = keyNodes->getLength();
				for(unsigned long keyIdx=0; keyIdx < keyNodes->getLength(); keyIdx++)
				{
					DOMNode* keyNode = keyNodes->item(keyIdx);
					if(wcscmp(keyNode->getNodeName(), L"#text") == 0)
						continue;
					
					const XMLCh* keyValue = keyNode->getFirstChild()->getNodeValue();
					if(keyValue == NULL)
						continue;

					int test = VK_CONTROL;
					keys.push_back(_wtoi(keyValue));					
				}
				configClass.AddAction(actionName, new CKeyboardAction(keys));
			}
			if(actionType.compare(L"winampPlayPause") == 0)
			{
				configClass.AddAction(actionName, new CWinampPlayPause());
			}
			if(actionType.compare(L"winampMute") == 0)
			{
				configClass.AddAction(actionName, new CWinampMute());
			}
			// We make the assumption that the macros were put at the end of the
			// config file, otherwise the actions they execute may not exist!
			if(actionType.compare(L"macro") == 0)
			{
				wstring type = actionNode->getAttributes()->getNamedItem(L"type")->getNodeValue();
				CMacroAction* actionToAdd = new CMacroAction(type.compare(L"all") == 0 ? true : false);
				DOMNodeList* macroActions = actionNode->getChildNodes();
				unsigned long count = macroActions->getLength();
				for(unsigned long actionIdx=0; actionIdx < count; actionIdx++)
				{
					DOMNode* macroActionNode = macroActions->item(actionIdx);
					if(wcscmp(macroActionNode->getNodeName(), L"#text") == 0)
						continue;

					wstring macroActionName = macroActionNode->getAttributes()->getNamedItem(L"name")->getNodeValue();
					actionToAdd->AddAction(configClass.GetActions()[macroActionName]);
//.........这里部分代码省略.........

void GeomAttributesBuilder::getParameters()
{
	// First set default parameters.
	// The parameters are dependent on the type of geom
	//	box:			length, width, height (all doubles)
	//	ccylinder:	radius, length (all doubles)
	//	sphere:		radius (all doubles)
	//	plane:		normal_x, normal_y, normal_z, d (all doubles)
	//	mesh:		filname (std::string)	
	std::string type = attrib_->getValAsStr("type");
	
	if (!type.compare("box")) {
		attrib_->add("length", "1");
		attrib_->add("width", "1");
		attrib_->add("height", "1");
	} else if (!type.compare("ccylinder")) {
		attrib_->add("radius", "1");
		attrib_->add("length", "3");
	} else if (!type.compare("cylinder")) {
		attrib_->add("radius", "1");
		attrib_->add("length", "3");
	} else if (!type.compare("sphere")) {
		attrib_->add("radius", "1");
	} else if (!type.compare("plane")) {
		attrib_->add("normal_x", "0");
		attrib_->add("normal_y", "0");
		attrib_->add("normal_z", "1");
		attrib_->add("d", "0");
	} else if (!type.compare("mesh")) {
		attrib_->add("filename", "_NODATA_");
	} else {
		return;
	}
	
	DOMNodeList* allChildNodes = node_->getChildNodes();

	// Loop over all of the parameters
	for (unsigned int c = 0; c < allChildNodes->getLength(); ++c) {
		DOMNode* thisChildItem = allChildNodes->item(c);
			    			
		if (thisChildItem->getNodeType() == DOMNode::ELEMENT_NODE) {
		
			char* pChildTagName = XMLString::transcode(thisChildItem->getNodeName());
			
			if ( strcmp(pChildTagName, "parameter") == 0 ) {
     			
				if ( thisChildItem->hasAttributes() ) 
				{
					DOMNamedNodeMap* theAttributes = thisChildItem->getAttributes();
					int numAttributes = theAttributes->getLength();
			
					if (numAttributes == 2) { // Parameters can only 1 Name/Value pair
						DOMNode* nodeName = theAttributes->item(0);
						DOMNode* nodeValue = theAttributes->item(1);

						const XMLCh* xmlch_Name = nodeName->getNodeValue();
						char* attrName = XMLString::transcode(xmlch_Name);

						const XMLCh* xmlch_Value = nodeValue->getNodeValue();
						char* attrValue = XMLString::transcode(xmlch_Value);
						
						try {
							attrib_->update(attrName, attrValue);
						} catch (std::runtime_error &ex) {
							std::cerr << ex.what() << std::endl
									<< builderType_ << "::getParameters() - "
									<< "In geom \"" << attrib_->getValAsStr("name")
									<< "\", parameter \"" << attrName << "=" << attrValue
									<< "\" is illegal for this geom type ("
									<< attrib_->getValAsStr("type")
									<< "). Ignoring it." << std::endl;
						};
						
						XMLString::release( &attrName );
						XMLString::release( &attrValue );		
					}
				}
			}
			
			delete [] pChildTagName;
		}
	}
}