C++ QDomElement::insertAfter方法代码示例

void QgsConfigParser::appendCRSElementsToLayer( QDomElement& layerElement, QDomDocument& doc, const QStringList &crsList ) const
{
  if ( layerElement.isNull() )
  {
    return;
  }

  //insert the CRS elements after the title element to be in accordance with the WMS 1.3 specification
  QDomElement titleElement = layerElement.firstChildElement( "Title" );

  //In case the number of advertised CRS is constrained
  QSet<QString> crsSet = supportedOutputCrsSet();

  QStringList::const_iterator crsIt = crsList.constBegin();
  for ( ; crsIt != crsList.constEnd(); ++crsIt )
  {
    if ( !crsSet.isEmpty() && !crsSet.contains( *crsIt ) ) //consider epsg output constraint
    {
      continue;
    }
    QDomElement crsElement = doc.createElement( "CRS" );
    QDomText crsText = doc.createTextNode( *crsIt );
    crsElement.appendChild( crsText );
    layerElement.insertAfter( crsElement, titleElement );
  }
}

void QgsConfigParser::appendExGeographicBoundingBox( QDomElement& layerElem,
    QDomDocument& doc,
    const QgsRectangle& layerExtent,
    const QgsCoordinateReferenceSystem& layerCRS ) const
{
  if ( layerElem.isNull() )
  {
    return;
  }

  QgsCoordinateReferenceSystem wgs84;
  wgs84.createFromOgcWmsCrs( GEO_EPSG_CRS_AUTHID );

  //Ex_GeographicBoundingBox
  //transform the layers native CRS into WGS84
  QgsCoordinateTransform exGeoTransform( layerCRS, wgs84 );
  QgsRectangle wgs84BoundingRect = exGeoTransform.transformBoundingBox( layerExtent );

  QDomElement ExGeoBBoxElement = doc.createElement( "EX_GeographicBoundingBox" );
  QDomElement wBoundLongitudeElement = doc.createElement( "westBoundLongitude" );
  QDomText wBoundLongitudeText = doc.createTextNode( QString::number( wgs84BoundingRect.xMinimum() ) );
  wBoundLongitudeElement.appendChild( wBoundLongitudeText );
  ExGeoBBoxElement.appendChild( wBoundLongitudeElement );
  QDomElement eBoundLongitudeElement = doc.createElement( "eastBoundLongitude" );
  QDomText eBoundLongitudeText = doc.createTextNode( QString::number( wgs84BoundingRect.xMaximum() ) );
  eBoundLongitudeElement.appendChild( eBoundLongitudeText );
  ExGeoBBoxElement.appendChild( eBoundLongitudeElement );
  QDomElement sBoundLatitudeElement = doc.createElement( "southBoundLatitude" );
  QDomText sBoundLatitudeText = doc.createTextNode( QString::number( wgs84BoundingRect.yMinimum() ) );
  sBoundLatitudeElement.appendChild( sBoundLatitudeText );
  ExGeoBBoxElement.appendChild( sBoundLatitudeElement );
  QDomElement nBoundLatitudeElement = doc.createElement( "northBoundLatitude" );
  QDomText nBoundLatitudeText = doc.createTextNode( QString::number( wgs84BoundingRect.yMaximum() ) );
  nBoundLatitudeElement.appendChild( nBoundLatitudeText );
  ExGeoBBoxElement.appendChild( nBoundLatitudeElement );

  //BoundingBox element
  QDomElement bBoxElement = doc.createElement( "BoundingBox" );
  if ( layerCRS.isValid() )
  {
    bBoxElement.setAttribute( "CRS", layerCRS.authid() );
  }

  bBoxElement.setAttribute( "minx", QString::number( layerExtent.xMinimum() ) );
  bBoxElement.setAttribute( "miny", QString::number( layerExtent.yMinimum() ) );
  bBoxElement.setAttribute( "maxx", QString::number( layerExtent.xMaximum() ) );
  bBoxElement.setAttribute( "maxy", QString::number( layerExtent.yMaximum() ) );

  QDomElement lastCRSElem = layerElem.lastChildElement( "CRS" );
  if ( !lastCRSElem.isNull() )
  {
    layerElem.insertAfter( ExGeoBBoxElement, lastCRSElem );
    layerElem.insertAfter( bBoxElement, ExGeoBBoxElement );
  }
  else
  {
    layerElem.appendChild( ExGeoBBoxElement );
    layerElem.appendChild( bBoxElement );
  }
}

//static
QDomElement RKComponentMap::findOrCreateElement (QDomElement& parent, const QString& tagname, const QString& name, const QString& label, int index) {
	RK_TRACE (PLUGIN);

	XMLHelper* xml = XMLHelper::getStaticHelper ();
	XMLChildList list = xml->getChildElements (parent, QString::null, DL_INFO);		// we need to look at all children, so we get the order right
	QDomElement insert_after_element;
	for (XMLChildList::const_iterator it=list.begin (); it != list.end (); ++it) {
		if ((tagname == (*it).tagName ()) && (name == xml->getStringAttribute ((*it), "name", "", DL_ERROR))) {
			return (*it);
		} else {
			if (index >= 0) {
				if (index > xml->getIntAttribute ((*it), "index", -1, DL_INFO)) {
					insert_after_element = *it;
				}
			}
		}
	}

	// element not found. Create a new one instead
	QDomElement ret = xmlguiBuildDocument ().createElement (tagname);
	ret.setAttribute ("name", name);
	ret.setAttribute ("index", index);
	if (!label.isEmpty ()) {
		QDomElement text = xmlguiBuildDocument ().createElement ("text");
		text.appendChild (xmlguiBuildDocument ().createTextNode (label));
		ret.appendChild (text);
	}
	parent.insertAfter (ret, insert_after_element);	// if index_after_element.isNull, this add the new element as the last child of parent!

	return ret;
}

static void replaceNode(QDomElement &docElem, QDomNode &n, const QStringList &list, const QString &tag)
{
    for(QStringList::ConstIterator it = list.begin();
            it != list.end(); ++it)
    {
        QDomElement e = docElem.ownerDocument().createElement(tag);
        QDomText txt = docElem.ownerDocument().createTextNode(*it);
        e.appendChild(txt);
        docElem.insertAfter(e, n);
    }

    QDomNode next = n.nextSibling();
    docElem.removeChild(n);
    n = next;
//   kDebug(7021) << "Next tag = " << n.toElement().tagName();
}

void MainWindow::on_actionPage_forward_activated()
{
    QDomElement root = document->documentElement();
    QDomElement picture = album.toElement();
    root.insertAfter( picture, picture.nextSiblingElement("photo") );

    if(album.nextSibling().isNull())
    {
        ui->actionMove_forward->setEnabled(false);
        ui->actionPage_forward->setEnabled(false);
    }

    if(!album.previousSibling().isNull())
    {
        ui->actionMove_backward->setEnabled(true);
        ui->actionPage_backward->setEnabled(true);
    }
    ui->statusBar->showMessage("Moved photo forward one in album");
}

void QgsSingleBandGrayRenderer::toSld( QDomDocument &doc, QDomElement &element, const QgsStringMap &props ) const
{
  QgsStringMap newProps = props;

  // create base structure
  QgsRasterRenderer::toSld( doc, element, props );

  // look for RasterSymbolizer tag
  QDomNodeList elements = element.elementsByTagName( QStringLiteral( "sld:RasterSymbolizer" ) );
  if ( elements.size() == 0 )
    return;

  // there SHOULD be only one
  QDomElement rasterSymbolizerElem = elements.at( 0 ).toElement();

  // add Channel Selection tags
  // Need to insert channelSelection in the correct sequence as in SLD standard e.g.
  // after opacity or geometry or as first element after sld:RasterSymbolizer
  QDomElement channelSelectionElem = doc.createElement( QStringLiteral( "sld:ChannelSelection" ) );
  elements = rasterSymbolizerElem.elementsByTagName( QStringLiteral( "sld:Opacity" ) );
  if ( elements.size() != 0 )
  {
    rasterSymbolizerElem.insertAfter( channelSelectionElem, elements.at( 0 ) );
  }
  else
  {
    elements = rasterSymbolizerElem.elementsByTagName( QStringLiteral( "sld:Geometry" ) );
    if ( elements.size() != 0 )
    {
      rasterSymbolizerElem.insertAfter( channelSelectionElem, elements.at( 0 ) );
    }
    else
    {
      rasterSymbolizerElem.insertBefore( channelSelectionElem, rasterSymbolizerElem.firstChild() );
    }
  }

  // for gray band
  QDomElement channelElem = doc.createElement( QStringLiteral( "sld:GrayChannel" ) );
  channelSelectionElem.appendChild( channelElem );

  // set band
  QDomElement sourceChannelNameElem = doc.createElement( QStringLiteral( "sld:SourceChannelName" ) );
  sourceChannelNameElem.appendChild( doc.createTextNode( QString::number( grayBand() ) ) );
  channelElem.appendChild( sourceChannelNameElem );

  // set ContrastEnhancement
  if ( contrastEnhancement() )
  {
    QDomElement contrastEnhancementElem = doc.createElement( QStringLiteral( "sld:ContrastEnhancement" ) );
    contrastEnhancement()->toSld( doc, contrastEnhancementElem );

    // do changes to minValue/maxValues depending on stretching algorithm. This is necessary because
    // geoserver do a first stretch on min/max, then apply colo map rules. In some combination is necessary
    // to use real min/max values and in othere the actual edited min/max values
    switch ( contrastEnhancement()->contrastEnhancementAlgorithm() )
    {
      case QgsContrastEnhancement::StretchAndClipToMinimumMaximum:
      case QgsContrastEnhancement::ClipToMinimumMaximum:
      {
        // with this renderer export have to be check against real min/max values of the raster
        QgsRasterBandStats myRasterBandStats = mInput->bandStatistics( grayBand(), QgsRasterBandStats::Min | QgsRasterBandStats::Max );

        // if minimum range differ from the real minimum => set is in exported SLD vendor option
        if ( !qgsDoubleNear( contrastEnhancement()->minimumValue(), myRasterBandStats.minimumValue ) )
        {
          // look for VendorOption tag to look for that with minValue attribute
          QDomNodeList elements = contrastEnhancementElem.elementsByTagName( QStringLiteral( "sld:VendorOption" ) );
          for ( int i = 0; i < elements.size(); ++i )
          {
            QDomElement vendorOption = elements.at( i ).toElement();
            if ( vendorOption.attribute( QStringLiteral( "name" ) ) != QStringLiteral( "minValue" ) )
              continue;

            // remove old value and add the new one
            vendorOption.removeChild( vendorOption.firstChild() );
            vendorOption.appendChild( doc.createTextNode( QString::number( myRasterBandStats.minimumValue ) ) );
          }
        }
        break;
      }
      case QgsContrastEnhancement::UserDefinedEnhancement:
        break;
      case QgsContrastEnhancement::NoEnhancement:
        break;
      case QgsContrastEnhancement::StretchToMinimumMaximum:
        break;
    }

    channelElem.appendChild( contrastEnhancementElem );
  }

  // for each color set a ColorMapEntry tag nested into "sld:ColorMap" tag
  // e.g. <ColorMapEntry color="#EEBE2F" quantity="-300" label="label" opacity="0"/>
  QList< QPair< QString, QColor > > classes;
  legendSymbologyItems( classes );

  // add ColorMap tag
  QDomElement colorMapElem = doc.createElement( QStringLiteral( "sld:ColorMap" ) );
  rasterSymbolizerElem.appendChild( colorMapElem );
//.........这里部分代码省略.........

void StatusDialog::savePreset(const QString &preset_caption)
{
  QFile presets_file(m_preset_file);

  if ( presets_file.exists() )
  {
    if (presets_file.open(QIODevice::ReadOnly) )
    {
      QDomDocument doc;
      if ( doc.setContent(&presets_file) )
      {
        QDomElement rootElement = doc.documentElement();
        QDomElement preset_element = doc.createElement("preset");
        QDomElement caption_element = doc.createElement("caption");
        QDomText caption_text = doc.createTextNode(preset_caption);
        caption_element.appendChild(caption_text);
        QDomElement message_element = doc.createElement("message");
        QDomText message_text = doc.createTextNode(ui.statusTextEdit->toPlainText());
        message_element.appendChild(message_text);
        preset_element.appendChild(caption_element);
        preset_element.appendChild(message_element);
        rootElement.insertAfter(preset_element, rootElement.lastChild());

        presets_file.close();
        if ( presets_file.open(QIODevice::WriteOnly) )
        {
          QTextStream preset_stream(&presets_file);
          preset_stream.setCodec("UTF-8");
          preset_stream<<doc.toString();
          presets_file.close();
        }
      }
    }
  }
  else
  {
    if ( presets_file.open(QIODevice::WriteOnly) )
    {
      QDomDocument doc("stauspresets");
      QDomProcessingInstruction process = doc.createProcessingInstruction(
                                            "xml", "version=\"1.0\" encoding=\"utf-8\"");
      doc.appendChild(process);
      QDomElement rootElement = doc.createElement("stauspresets");
      doc.appendChild(rootElement);

      QDomElement preset_element = doc.createElement("preset");
      QDomElement caption_element = doc.createElement("caption");
      QDomText caption_text = doc.createTextNode(preset_caption);
      caption_element.appendChild(caption_text);
      QDomElement message_element = doc.createElement("message");
      QDomText message_text = doc.createTextNode(ui.statusTextEdit->toPlainText());
      message_element.appendChild(message_text);

      preset_element.appendChild(caption_element);
      preset_element.appendChild(message_element);
      rootElement.appendChild(preset_element);
      doc.appendChild(rootElement);

      QTextStream presets_stream(&presets_file);
      presets_stream.setCodec("UTF-8");
      presets_stream<<doc.toString();
      presets_file.close();
    }
  }
  ui.presetComboBox->addItem(preset_caption,ui.statusTextEdit->toPlainText());

}

void writeJob::dragModuleName(const QString name, const int index, const int allRow, const QString upOrDown)
{
    qDebug()<<"4.dragModuleName";
    QDomElement root = doc.documentElement();
    QDomElement modEle = root.firstChildElement("Module");
    if(index==0)  //插到头
    {
        while (!modEle.isNull())
        {
            if(modEle.attribute("name")==name && modEle.attribute("id")==moduleID)
            {
                QDomElement firstModEle=root.firstChildElement("Module");
                root.insertBefore(modEle,firstModEle);
                break;
            }
            modEle = modEle.nextSiblingElement("Module");
        }
    }
    else if(index==(allRow-1))  // 插到尾
    {
        while (!modEle.isNull())
        {
            if(modEle.attribute("name")==name && modEle.attribute("id")==moduleID)
            {
                QDomElement lastModEle=root.lastChildElement("Module");
                root.insertAfter(modEle,lastModEle);
                break;
            }
            modEle = modEle.nextSiblingElement("Module");
        }
    }

    else   //其他情况
    {
        QDomElement insertAfterEle;
        QDomElement rightEle;

        insertAfterEle=modEle;
        //难道还要分上到下，下到上??
        if(upOrDown=="up")
        {
            for(int i=0; i<index-1;i++)
            {
                modEle = modEle.nextSiblingElement("Module");
                insertAfterEle=modEle;
                qDebug()<<i<<insertAfterEle.attribute("name");
            }
        }
        if(upOrDown=="down")
        {
            for(int i=0; i<index;i++)
            {
                modEle = modEle.nextSiblingElement("Module");
                insertAfterEle=modEle;
                qDebug()<<i<<insertAfterEle.attribute("name");
            }
        }
        modEle=root.firstChildElement("Module");
        while (!modEle.isNull())
        {
            if(modEle.attribute("name")==name && modEle.attribute("id")==moduleID)
            {
                rightEle=modEle;
                qDebug()<<rightEle.attribute("name")<<insertAfterEle.attribute("name");
                root.insertAfter(rightEle,insertAfterEle);
                break;
            }
            modEle = modEle.nextSiblingElement("Module");
        }
    }

    if(!write())
        qDebug()<<"delete job failed";
}

void saveScene(QWidget *parent, SceneContext *ctx, const QString &targetFile) {
	QDomElement root = ctx->doc.documentElement();

	// ====================================================================
	//   Serialize the sensor configuration
	// ====================================================================

	QList<QDomElement> oldSensors = findAllChildren(root, "sensor");

	const ref_vector<Sensor> sensors = ctx->scene->getSensors();
	ref_vector<Sensor>::const_iterator it = std::find(sensors.begin(),
			sensors.end(), ctx->scene->getSensor());
	if (it == sensors.end())
		SLog(EError, "Number of sensors did not match between loaded scene and XML file!");

	QDomElement sensor, oldSensor;

	if (oldSensors.size() == 0)
		; // ok -- scene did not contain a sensor before
	else if ((size_t) oldSensors.size() != ctx->scene->getSensors().size())
		SLog(EError, "Number of sensors did not match between loaded scene and XML file!");
	else
		oldSensor = oldSensors[it-sensors.begin()];

	if (oldSensor.isNull()) {
		sensor = ctx->doc.createElement("sensor");
		root.insertAfter(sensor, QDomNode());
	} else {
		sensor = ctx->doc.createElement("sensor");
		root.insertAfter(sensor, oldSensor);
		root.removeChild(oldSensor);
	}

	setProperties(ctx->doc, sensor, ctx->scene->getSensor()->getProperties());

	// ====================================================================
	//   Serialize the sampler configuration
	// ====================================================================

	QDomElement sampler = ctx->doc.createElement("sampler");
	sensor.appendChild(sampler);

	setProperties(ctx->doc, sampler,
		ctx->scene->getSampler()->getProperties());

	// ====================================================================
	//   Serialize the film configuration
	// ====================================================================

	QDomElement film = ctx->doc.createElement("film");
	sensor.appendChild(film);

	Properties filmProps(ctx->scene->getFilm()->getProperties());
	if (filmProps.getPluginName() == "ldrfilm") {
		/* Also export the tonemapper settings */
		if (ctx->toneMappingMethod == EGamma) {
			filmProps.setString("tonemapMethod", "gamma", false);
			filmProps.setFloat("exposure", ctx->exposure, false);
			filmProps.removeProperty("key");
			filmProps.removeProperty("burn");
		} else {
			filmProps.setString("tonemapMethod", "reinhard", false);
			filmProps.setFloat("key", ctx->reinhardKey, false);
			filmProps.setFloat("burn", (ctx->reinhardBurn + 10) / 20.0f, false);
			filmProps.removeProperty("exposure");
		}
		filmProps.setFloat("gamma", ctx->srgb ? -1 : ctx->gamma, false);
	}

	setProperties(ctx->doc, film, filmProps);

	// ====================================================================
	//   Serialize the reconstruction filter configuration
	// ====================================================================

	QDomElement rfilter = ctx->doc.createElement("rfilter");
	film.appendChild(rfilter);

	setProperties(ctx->doc, rfilter,
		ctx->scene->getFilm()->getReconstructionFilter()->getProperties());

	// ====================================================================
	//   Serialize medium references of the sensor
	// ====================================================================

	QList<QDomElement> oldSensorReferences = findAllChildren(oldSensor, "ref");
	oldSensorReferences.append(findAllChildren(oldSensor, "medium"));

	for (int i=0; i<oldSensorReferences.size(); ++i)
		sensor.appendChild(ctx->doc.importNode(oldSensorReferences[i], true));

	// ====================================================================
	//   Serialize the integrator configuration
	// ====================================================================

	QDomElement oldIntegratorNode = findUniqueChild(root, "integrator");
	QDomElement newIntegratorNode = ctx->doc.createElement("integrator");

	const Integrator *integrator = ctx->scene->getIntegrator();
	setProperties(ctx->doc, newIntegratorNode, integrator->getProperties());
//.........这里部分代码省略.........