C++ QDomNode::attributes方法代码示例

QDomNamedNodeMap QDomNodeProto:: attributes() const
{
  QDomNode *item = qscriptvalue_cast<QDomNode*>(thisObject());
  if (item)
    return item->attributes();
  return QDomNamedNodeMap();
}

void InternetServerPlatform::readVariables( QDomNode node )
{
	Logging::logInfo( this, "readVariables()" );

	if( node.isNull() )
		return;

	QDomNode variable = node.firstChild();
	while( false == variable.isNull() )
	{
		if( QDomNode::CommentNode != variable.nodeType() )
		{
			QString variableName = variable.nodeName();

			if( _variableList.contains(variableName) )
				continue;

			QString variableValue = variable.attributes().namedItem("value").nodeValue();

			replaceVariables( variableValue );

			_variableList.insert( variableName, variableValue );

			Logging::logInfo( this, QString("%1 = %2").arg(variableName).arg(variableValue) );

			variable = variable.nextSibling();
		}	
	}	
}

QVariant MetricDomModel::data(const QModelIndex &index, int role) const
{
    if (!index.isValid())
        return QVariant();

    if (role != Qt::DisplayRole)
        return QVariant();

    DomItem *item = static_cast<DomItem*>(index.internalPointer());

    QDomNode node = item->node();

    QStringList attributes;
    QDomNamedNodeMap attributeMap = node.attributes();

    switch (index.column()) {
        case 0:
            return node.nodeName();
        case 1:
        	if( !attributeMap.contains("Type") ) {
        		return QVariant();
        	}
        	return attributeMap.namedItem("Type").nodeValue();
        case 2:
        	if( !attributeMap.contains("Format") ) {
        		return QVariant();
        	}
        	return attributeMap.namedItem("Format").nodeValue();
        default:
            return QVariant();
    }
}

//copyright : (C) 2002-2004 InfoSiAL S.L.
//email     : [email protected]
void MReportEngine::drawDetailHeader( MPageCollection * pages, int level ) {
  MReportSection * header = findDetailHeader( level );

  if ( header ) {
    QDomNode record = records.item( currRecord_ );

    if ( !header->mustBeDrawed( &record ) )
      return ;

    header->setPageNumber( currPage );

    header->setReportDate( currDate );

    if (( currY + header->getHeight() ) > currHeight )
      newPage( pages );

    QString value;

    QDomNamedNodeMap fields = record.attributes();

    for ( int i = 0; i < header->getFieldCount(); i++ ) {
      value = fields.namedItem( header->getFieldName( i ) ).nodeValue();
      header->setFieldData( i, value );
    }

    header->setCalcFieldData( 0, 0, &record );

    int sectionHeight = header->getHeight();
    header->draw( p, leftMargin, currY, sectionHeight );
    header->setLastPageIndex( pages->getCurrentIndex() );
    header->setOnPage(( QPicture * ) p->painter()->device() );
    currY += sectionHeight;
  }
}

//! [3]
QVariant DomModel::data(const QModelIndex &index, int role) const
{
    if (!index.isValid())
        return QVariant();

    if (role != Qt::DisplayRole)
        return QVariant();

    DomItem *item = static_cast<DomItem*>(index.internalPointer());

    QDomNode node = item->node();
//! [3] //! [4]
    QStringList attributes;
    QDomNamedNodeMap attributeMap = node.attributes();

    switch (index.column()) {
        case 0:
            return node.nodeName();
        case 1:
            for (int i = 0; i < attributeMap.count(); ++i) {
                QDomNode attribute = attributeMap.item(i);
                attributes << attribute.nodeName() + "=\""
                              +attribute.nodeValue() + "\"";
            }
            return attributes.join(" ");
        case 2:
            return node.nodeValue().split("\n").join(" ");
        default:
            return QVariant();
    }
}

// the constructor
ComponentGenerator::ComponentGenerator(QDomNode &generatorNode):
    Generator(generatorNode),
    scope_(ComponentGenerator::INSTANCE),
    groups_() {

    QDomNamedNodeMap attributeMap = generatorNode.attributes();

    // get the spirit scope attribute
    QString scope = attributeMap.namedItem(QString("spirit:scope")).nodeValue();
    if (scope == QString("entity")) {
        scope_ = ComponentGenerator::ENTITY;
    }
    else {
        scope_ = ComponentGenerator::INSTANCE;
    }

    // go through all the child nodes of the component generator
    for (int i = 0; i < generatorNode.childNodes().count(); ++i) {
        QDomNode tempNode = generatorNode.childNodes().at(i);

        if (tempNode.nodeName() == QString("spirit:group")) {
            QString groupName = tempNode.childNodes().at(0).nodeValue();
            groupName = XmlUtils::removeWhiteSpace(groupName);
            groups_.append(groupName);
        }
    }
}

IntParameter::IntParameter(QDomNode node, QObject *parent)
  : AbstractParameter(parent),
    _node(node),
    _label(0),
    _slider(0),
    _spinBox(0)
{
  _name = node.attributes().namedItem( "name" ).nodeValue();
  QString min = node.attributes().namedItem( "min" ).nodeValue();
  QString max = node.attributes().namedItem( "max" ).nodeValue();
  QString def = node.attributes().namedItem( "default" ).nodeValue();
  QString value = node.toElement().attribute("savedValue",def);
  _min = min.toInt();
  _max = max.toInt();
  _default = def.toInt();
  _value = value.toInt();
}

void Parser3::ParseVideoFeed( QDomNode Node, VideoFeedPtr Info ) {
    QDomNode Child = Node.firstChild();

    while( !Child.isNull() )
    {
        QString NodeName = Child.nodeName();
        if( NodeName == "title" )
        {
            Info->Title = Child.namedItem("#text").nodeValue();
        }
        else if( NodeName == "link" && ( Child.attributes().namedItem("rel").nodeValue() == "next" ) )
        {
            Info->NextPageInFeed = QUrl( Child.attributes().namedItem("href").nodeValue() );
        }
        else if( NodeName == "author" )
        {
            Info->Author = Child.namedItem("name").namedItem("#text").nodeValue();
            Info->UrlAuthor = QUrl( Child.namedItem("uri").namedItem("#text").nodeValue() );
        }
        else if( NodeName == "openSearch:totalResults" )
        {
            Info->Size = Child.namedItem("#text").nodeValue().toInt();
        }
        else if( NodeName == "media:group" )
        {
            Info->Description = Child.namedItem("media:description").namedItem("#text").nodeValue();
            if( !Child.namedItem("media:thumbnail").isNull() )
            {/*If we allready has a thumbnail we don't want to erase it*/
                Info->UrlThumbnail = QUrl( Child.namedItem("media:thumbnail").namedItem("#text").nodeValue() );
            }
        }
        else if( NodeName == "entry" )
        {
            VideoInfo *Video = new VideoInfo;
            ParseVideoEntry(Child,Video);
            Info->Content.push_back( Video );
        }

        Child = Child.nextSibling();
    }

    Info->ParsedPages++;
    Info->FixInfo();
    return;
}

QDomNode
vleSmDT::nodeOutPort(const QString& portName)
{
    QDomNode outNode =
            mDocSm->elementsByTagName("out").item(0);
    QDomNodeList outList =
        outNode.toElement().elementsByTagName("port");
    for (int i = 0; i< outList.length(); i++) {
        QDomNode out = outList.at(i);
        for (int j=0; j< out.attributes().size(); j++) {
            if ((out.attributes().item(j).nodeName() == "name") and
                    (out.attributes().item(j).nodeValue() == portName))  {
                return out;
            }
        }
    }
    return QDomNode() ;
}

QString
vleSmDT::getNamespace()
{
    QDomElement docElem = mDocSm->documentElement();

    QDomNode srcPluginNode =
        mDocSm->elementsByTagName("srcPlugin").item(0);
    return srcPluginNode.attributes().namedItem("namespace").nodeValue();
}

QVariant XUPProjectModel::data( const QModelIndex& index, int role ) const
{
    if ( !index.isValid() ) {
        return QVariant();
    }
    
    XUPItem* item = static_cast<XUPItem*>( index.internalPointer() );

    switch ( role ) {
        case Qt::DecorationRole:
            return item->displayIcon();
        case Qt::DisplayRole:
            return item->displayText();
        case XUPProjectModel::TypeRole:
            return item->type();
        case Qt::ToolTipRole:
        {
            const QDomNode node = item->node();
            const QDomNamedNodeMap attributeMap = node.attributes();
            QStringList attributes;
            
            if ( item->type() == XUPItem::Project ) {
                attributes << QString( "Project: %1" ).arg( item->project()->fileName() );
            }
            
            for ( int i = 0; i < attributeMap.count(); i++ ) {
                const QDomNode attribute = attributeMap.item( i );
                const QString name = attribute.nodeName();
                const QString value = attribute.nodeValue();
                
                attributes << QString( "%1=\"%2\"" ).arg( name ).arg( value );
            }
            
            switch ( item->type() ) {
                case XUPItem::Value:
                    attributes << QString( "Value=\"%1\"" ).arg( item->content() );
                    break;
                case XUPItem::File:
                    attributes << QString( "File=\"%1\"" ).arg( item->content() );
                    break;
                case XUPItem::Path:
                    attributes << QString( "Path=\"%1\"" ).arg( item->content() );
                    break;
                default:
                    break;
            }
            
            return attributes.join( "\n" );
        }
        case Qt::SizeHintRole:
            return QSize( -1, 18 );
        default:
            break;
    }
    
    return QVariant();
}

bool EpochModel::Init(QDomNode &node)
{
 if(!node.hasAttributes()) return false;
 QDomNamedNodeMap attr= node.attributes();
 QString indexString = (attr.namedItem("index")).nodeValue() ;
 qDebug("reading Model with index %i ",indexString.toInt());
        for(QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling())
              {
                if(n.nodeName() == QString("camera"))  cameraName = n.attributes().namedItem("filename").nodeValue();
                if(n.nodeName() == QString("texture")) textureName= n.attributes().namedItem("filename").nodeValue();
                if(n.nodeName() == QString("depth"))   depthName  = n.attributes().namedItem("filename").nodeValue();
                if(n.nodeName() == QString("count"))   countName  = n.attributes().namedItem("filename").nodeValue();
            }

  QString tmpName=textureName.left(textureName.length()-4);
  maskName = tmpName.append(".mask.png");
  return true;
}

bool InternetServerPlatform::readSockets( QDomNode node )
{
	Logging::logInfo( this, "readSockets()" );

	if( node.isNull() )
		return false;

    QString applicationPath = QCoreApplication::applicationDirPath();
	
	QDomNode socket = IspComponents::Dom::getChildNodeByName( node, "socket" );
	while( false == socket.isNull() )
	{
		if( QDomNode::CommentNode != socket.nodeType() )
		{
			SocketSettings* socketSettings = new SocketSettings();

            // read the logfile read on
			socketSettings->_on = socket.attributes().namedItem( "on" ).nodeValue();

            // read the daemon
			socketSettings->_daemon	= socket.attributes().namedItem( "daemon" ).nodeValue();
		    socketSettings->_daemon = socketSettings->_daemon.startsWith("/")
                ? socketSettings->_daemon
                : QString( "%1/%2" ).arg( applicationPath ).arg( socketSettings->_daemon );

			// read the logfile
			QDomNode logFile = IspComponents::Dom::getChildNodeByName( socket, "logFile" );	
			socketSettings->_logFile = logFile.attributes().namedItem("value").nodeValue();
		    socketSettings->_logFile = socketSettings->_logFile.startsWith("/")
                ? socketSettings->_logFile
                : QString( "%1/%2" ).arg( applicationPath ).arg( socketSettings->_logFile );

			// read the block-from
			QDomNode blockFrom = IspComponents::Dom::getChildNodeByName( socket, "blockFrom" );
			readBlockFrom( blockFrom, socketSettings->_blockFrom );

			_socketSettingsList.append( socketSettings );
		}

		socket = socket.nextSibling();
	}

	return true;
}

QString XmlRelationCheckerCoreImpl::CheckIsSubNodeFrom(const QDomNode& nodeToCheck, XmlRelation* xmlRelation) const
{
    //Precondition: the passed node is an element

    //For debug
    //const QString& nodeName = nodeToCheck.nodeName();

    //List of the key of the referenced value
    QString key = "";

    //If the relation is a SUB_TAG relation, otherwise is not supported and always return false
    if(xmlRelation->GetRelationType() == SUB_TAG)
    {
        //For debug
        //QString subTagName = xmlRelation->GetSubTagNameOfTagFrom();

        //Check the tag name corresponds with the subtag from name
        if(nodeToCheck.nodeName() == xmlRelation->GetSubTagNameOfTagFrom())
        {
            //Now it has to search all the child node with the given tag name with the right attribute

            //Obtain the parent node
            const QDomNode& parentNode = nodeToCheck.parentNode();

            //If the node is the correct child of the right node from
            if(parentNode.isElement() && parentNode.nodeName() == xmlRelation->GetTagFromName())
            {
                //Check the presence of the right attribute

                const QDomNamedNodeMap& attributeNodesList = nodeToCheck.attributes();

                //For exit when the fist match is found
                bool attributeFound = false;

                //Flow the list searching the
                for(int i=0; i<attributeNodesList.size() && !attributeFound; ++i)
                {
                    const QDomAttr& attritubeNode = attributeNodesList.item(i).toAttr();
                    const QString& attributeName = attritubeNode.name();

                    //If the attribute match set to display the value
                    if( attributeName == xmlRelation->GetAttributeNameofTagFrom() )
                    {
                        //Attribute found exit the cycle
                        attributeFound = true;

                        //Add the key in the list
                        key = attritubeNode.value();
                    }
                }
            }
        }
    }

    return key;
}

void DefinitionParser::parseAssetNodes (QDomNode& node, const Content::Class clazz)
{
	bool sprite = false;
	QString nodeName;
	switch (clazz) {
	case Content::MOVIECLIP:
		nodeName = NODE_MOVIECLIP;
		sprite = true;
		break;
	case Content::SPRITE:
		sprite = true;
		nodeName = NODE_SPRITE;
		break;
	case Content::BITMAPDATA:
		nodeName = NODE_BITMAP;
		break;
	case Content::SOUND:
		nodeName = NODE_SOUND;
		break;
	case Content::BYTEARRAY:
		nodeName = NODE_BINARY;
		break;
	default:
		error("invalid class type " + QString::number(clazz));
		return;
	}
	while (!node.isNull()) {
		QDomElement elem = node.toElement();
		QDomNode parseNode = node;
		QDomNamedNodeMap attributes = node.attributes();
		QDomNode frame = node.firstChild();
		checkAttributes(node);
		node = node.nextSibling();

		if (elem.isNull()) {
			continue;
		}

		const QString tag = elem.tagName();
		if (nodeName != tag) {
			warnInvalidTag(tag, parseNode.parentNode().nodeName());
			continue;
		}

		if (attributes.isEmpty() || attributes.namedItem(ATTR_CLASS).nodeValue().isEmpty()) {
			warnMissingAttr(ATTR_CLASS, tag);
			continue;
		}

		if (frame.isNull() || !sprite) {
			createSingleFrameAsset(parseNode, clazz, nodeName);
		} else {
			createMultiFrameSprite(frame, clazz);
		}
	}
}