C++ QDomNodeList::length方法代码示例

int main(int argc, char* argv[])
{
    QString filename("config.xml");
    QFile f(filename);
    QDomDocument doc;

    doc.setContent(dynamic_cast<QIODevice*>(&f), false);

    QDomNodeList nodes = doc.elementsByTagName(QString("pythonpath"));
    for (unsigned int i = 0; i < nodes.length(); ++i) {
        QString s;
        s = nodes.at(i).toElement().text();
        s.replace(QString("$PYTHONHOME"), QString("/usr/bin/python27"));
        s.replace(QString("$PROJECT_PATH"), QString("~/mysample"));
        s.replace(QString("$PYTHON_VERSION"), QString("27"));

        printf("%s\n", s.toAscii().data());
    }
    return 0;
}

QDomElement KWDWriter::formatAttribute(const QDomElement &paragraph,
                                       const QString& name,
                                       const QString& attrName,
                                       const QString& attr)
{
    QDomElement lastformat = currentFormat(paragraph, true);
    QDomNodeList qdnl = lastformat.elementsByTagName(name);
    if (qdnl.length()) {
        QDomElement el;
        el = qdnl.item(0).toElement();
        el.setAttribute(attrName, attr);
        return el;
    } else {
        QDomElement al = _doc->createElement(name);
        lastformat.appendChild(al);
        al.setAttribute(attrName, attr);
        return al;
    }

}

bool QgsAttributeAction::readXML( const QDomNode& layer_node )
{
  mActions.clear();

  QDomNode aaNode = layer_node.namedItem( "attributeactions" );

  if ( !aaNode.isNull() )
  {
    QDomNodeList actionsettings = aaNode.childNodes();
    for ( unsigned int i = 0; i < actionsettings.length(); ++i )
    {
      QDomElement setting = actionsettings.item( i ).toElement();
      addAction(( QgsAction::ActionType ) setting.attributeNode( "type" ).value().toInt(),
                setting.attributeNode( "name" ).value(),
                setting.attributeNode( "action" ).value(),
                setting.attributeNode( "capture" ).value().toInt() != 0 );
    }
  }
  return true;
}

void ConfigLoader::loadIncludes(QDomDocument const &config, QFileInfo const &currentFile)
{
    QDomNodeList includes = config.elementsByTagName("include");
    for (unsigned i = 0; i < includes.length(); i++) {
        QDomElement includeElement = includes.at(i).toElement();
        QString includeName = includeElement.attribute("name");
        QFileInfo included = QFileInfo(currentFile.dir(), includeName);
        if (included.exists()) {
            load(included.canonicalFilePath());
        } else {
            fprintf(stderr, "Error 13 (%s:%d,%d) : Include '%s' is unknown.\n",
                    currentFile.fileName().toLatin1().constData(),
                    includeElement.lineNumber(),
                    includeElement.columnNumber(),
                    includeName.toLatin1().constData()
            );
        }

    }
}

void Uic::registerDatabases( const QDomElement& e ) {
  QDomElement n;
  QDomNodeList nl;
  int i;
  nl = e.parentNode().toElement().elementsByTagName( "widget" );
  for ( i = 0; i < ( int ) nl.length(); ++i ) {
    n = nl.item( i ).toElement();
    QString conn = getDatabaseInfo( n, "connection" );
    QString tab = getDatabaseInfo( n, "table" );
    QString fld = getDatabaseInfo( n, "field" );
    if ( !conn.isNull() ) {
      dbConnections += conn;
      if ( !tab.isNull() ) {
        dbCursors[conn] += tab;
        if ( !fld.isNull() )
          dbForms[conn] += tab;
      }
    }
  }
}

QDomElement BookmarkWidget::findElementbyUUID(QDomDocument& doc, QString uuid, int type, const QString xmlPath)
{
    QString path;
    if (xmlPath == QString())
        path = getBookmarkFilepath();
    else
        path = xmlPath;
    QFile file(path);
    if(!file.open(QIODevice::ReadWrite | QIODevice::Text)) {
        qDebug()<<"File cannot be opened.";
        showFileOpenError();
        file.close();
        return doc.createElement(QString());
    }

    doc.setContent(&file);
    QDomNodeList list = doc.elementsByTagName(BOOKMARK_XML_ROOT);
    if(list.isEmpty()) {
        showInvalidFileError();
        file.close();
        return doc.createElement(QString());
    }

    QDomElement root = list.at(0).toElement();
    QDomNodeList nodes;
    if(type == BOOKMARK) nodes = root.elementsByTagName(BOOKMARK_NAME);
    else if(type == FOLDER) nodes = root.elementsByTagName(FOLDER_NAME);

    QDomElement elt;
    QString value;
    for(int i = 0; i < nodes.length(); i++) {
        elt = nodes.at(i).toElement();
        value = elt.attribute(UUID_NAME);

        if(value == uuid) break;
        value.clear();
    }
    file.close();
    if(!value.isEmpty()) return elt;
    else return doc.createElement(QString());
}

void WargearList::fromXml(const QDomElement& ele) throw(XmlParseException)
{
    QDomNodeList list = ele.childNodes();
    int len = list.length();
    QDomElement current;
    
    for(int i = 0; i < len; i++)
    {
        current = list.item(i).toElement();
        if(!current.isNull())
        {
            if(current.nodeName() == "wargear")
            {
                Wargear wg(current, race());
                m_wargears.insert(wg.id(), wg);
            }
            else
                throw XmlParseException("invalid wargear list node", current);
        }
    }
}

QDomElement findPackageElement(
	const QDomDocument &list, QString packageType, QString packageName, QString mapName )
{
	QDomNodeList packageNodeList = list.elementsByTagName( packageType );

	for( unsigned int i=0; i < packageNodeList.length(); i++ )
	{
		QDomElement package = packageNodeList.at( i ).toElement();

		if( packageType == "map" && package.attribute( "name" ) == packageName )
				return package;

		if( packageType == "module" && package.attribute( "name" ) == packageName )
		{
			if( package.parentNode().parentNode().toElement().attribute( "name" ) == mapName )
				return package;
		}
	}

	return QDomElement();
}

void XmlLoader::readStylus(QDomElement const &stylus)
{
    QDomNodeList stylusAttributes = stylus.childNodes();

    Stylus* stylusItem = new Stylus(0, 0, NULL);
    for (unsigned i = 0; i < stylusAttributes.length(); ++i) {
        QDomElement type = stylusAttributes.at(i).toElement();
        if (type.tagName() == "line") {
            QRectF rect = readRectOfXandY(type);
            Line* item = new Line(rect.left(), rect.top(), rect.right(), rect.bottom(), NULL);
            item->readPenBrush(type);
            stylusItem->mListLine.push_back(item);
            stylusItem->setPen(item->pen());
            stylusItem->setBrush(item->brush());
        }
        else
            qDebug() << "Incorrect stylus tag";
    }
    mScene->addItem(stylusItem);
    mScene->setZValue(stylusItem);
}

QString TextFormatter::getFormattedVacancy(QDomNode vacancyNode)
{
    QDomNodeList itemChildNodes = vacancyNode.childNodes();
    QString formattedVacancy = "";

    for(int i = 0; i < itemChildNodes.length(); i++)
    {
        QDomNode currentNode = itemChildNodes.at(i);
        QString nodeName = currentNode.nodeName();

        if(nodeName.compare("title") == 0)
        {
            formattedVacancy += getFormattedTitle(currentNode);
        }
        else if(nodeName.compare("section") == 0)
        {
            formattedVacancy += getFormattedSection(currentNode);
        }
    }
    return formattedVacancy;
}

QString TextFormatter::getFormattedItem(QDomNode itemNode)
{
    QDomNodeList itemChildNodes = itemNode.childNodes();
    QString formattedItem = "";

    for(int i = 0; i < itemChildNodes.length(); i++)
    {
        QDomNode currentNode = itemChildNodes.at(i);
        QString nodeName = currentNode.nodeName();

        if(nodeName.compare("title") == 0)
        {
            formattedItem += getFormattedTitle(currentNode);
        }
        else if(nodeName.compare("description") == 0)
        {
            formattedItem += getFormattedDescription(currentNode);
        }
    }
    return formattedItem;
}

QString TextFormatter::getFormattedChannel(QDomNode channelNode)
{
    QDomNodeList itemChildNodes = channelNode.childNodes();
    QString formattedChannel = "";

    for(int i = 0; i < itemChildNodes.length(); i++)
    {
        QDomNode currentNode = itemChildNodes.at(i);
        QString nodeName = currentNode.nodeName();

        if(nodeName.compare("item") == 0)
        {
            formattedChannel += getFormattedItem(currentNode);
        }
    }

    formattedChannel.append("<br/>");
    formattedChannel.append("<br/>");

    return formattedChannel;
}

void
WidgetVpzPropertyObservables::refresh()
{

    bool oldBlock = QComboBox::blockSignals(true);
    QComboBox::clear();
    QString dyn = mVpz->modelDynFromDoc(mModQuery);
    QDomNodeList obss = mVpz->obssListFromObss(mVpz->obsFromDoc());
    QComboBox::addItem("<none>");
    int selectIndex = 0;
    for (int i = 0; i < obss.length(); i++) {
        QDomNode obs = obss.at(i);
        QString obsName = DomFunctions::attributeValue(obs, "name");
        QComboBox::addItem(obsName);
        if (mVpz->modelObsFromDoc(mModQuery) == obsName) {
            selectIndex = i + 1;
        }
    }
    QComboBox::setCurrentIndex(selectIndex);
    QComboBox::blockSignals(oldBlock);
}

// Index any resources
void IndexRunner::indexRecognition(qint32 lid, Resource &r) {

    if (!keepRunning || pauseIndexing) {
        indexTimer->start();
        return;
    }

    // Make sure we have something to look through.
    Data recognition;
    if (r.recognition.isSet())
        recognition = r.recognition;
    if (!recognition.body.isSet())
        return;

    QDomDocument doc;
    QString emsg;
    doc.setContent(recognition.body, &emsg);

    // look for text tags
    QDomNodeList anchors = doc.documentElement().elementsByTagName("t");

    for (unsigned int i=0; keepRunning && !pauseIndexing && i<anchors.length(); i++) {
        QApplication::processEvents();
        QDomElement enmedia = anchors.at(i).toElement();
        QString weight = enmedia.attribute("w");
        QString text = enmedia.text();
        if (text != "") {
            IndexRecord *rec = new IndexRecord();
            rec->weight = weight.toInt();
            rec->lid = lid;
            rec->content = text;
            rec->source = "recognition";
            if (indexHash->contains(lid)) {
                delete indexHash->value(lid);
                indexHash->remove(lid);
            }
            indexHash->insert(lid, rec);
        }
    }
}

//NOTE: This task watch for pre-JEP session.
bool JingleWatchSessionTask::take(const QDomElement &element)
{
	if(element.tagName() != "iq")
		return false;
	
	QString sessionType, initiator;
	
	QDomElement first = element.firstChild().toElement();
	if( !first.isNull() && first.attribute("xmlns") == JINGLE_NS && first.tagName() == "session" ) 
	{
		kdDebug(JABBER_DEBUG_GLOBAL) << k_funcinfo << "Checking for incoming sesssion." << endl;
		initiator = first.attribute("initiator");
	
		// Only proceed initiate type Jingle XMPP call.
		if( first.attribute("type") != QString::fromUtf8("initiate") )
			return false;
		
		int nodeIndex;

		QDomNodeList nodeList = first.childNodes();
		// Do not check first child
		for(nodeIndex = 0; nodeIndex < nodeList.length(); nodeIndex++)
		{
			QDomElement nodeElement = nodeList.item(nodeIndex).toElement();
			if(nodeElement.tagName() == "description")
			{
				sessionType = nodeElement.attribute("xmlns");
			}
		}

		if( !initiator.isEmpty() && !sessionType.isEmpty() )
		{
			kdDebug(JABBER_DEBUG_GLOBAL) << k_funcinfo << "Emmiting incoming sesssion." << endl;
			emit watchSession(sessionType, initiator);
			return true;
		}
	}
	
	return false;
}