void RoutingManagerPrivate::saveRoute(const QString &filename) { GeoWriter writer; writer.setDocumentType( kml::kmlTag_nameSpaceOgc22 ); QMutexLocker locker( &m_fileMutex ); QFile file( filename ); if ( !file.open( QIODevice::WriteOnly | QIODevice::Truncate ) ) { mDebug() << "Cannot write to " << file.fileName(); return; } GeoDataDocument container; container.setName(QStringLiteral("Route")); GeoDataFolder* request = routeRequest(); if ( request ) { container.append( request ); } GeoDataDocument *route = m_alternativeRoutesModel.currentRoute(); if ( route ) { container.append( new GeoDataDocument( *route ) ); } if ( !writer.write( &file, &container ) ) { mDebug() << "Can not write route state to " << file.fileName(); } file.close(); }
void OsmRelationTagWriter::writeMultipolygon( const GeoDataPolygon& polygon, const OsmPlacemarkData& osmData, GeoWriter& writer ) { writer.writeStartElement( osm::osmTag_relation ); OsmObjectAttributeWriter::writeAttributes( osmData, writer ); OsmTagTagWriter::writeTags( osmData, writer ); writer.writeStartElement( osm::osmTag_member ); QString memberId = QString::number( osmData.memberReference( -1 ).id() ); writer.writeAttribute( "type", "way" ); writer.writeAttribute( "ref", memberId ); writer.writeAttribute( "role", "outer" ); writer.writeEndElement(); for ( int index = 0; index < polygon.innerBoundaries().size(); ++index ) { writer.writeStartElement( osm::osmTag_member ); QString memberId = QString::number( osmData.memberReference( index ).id() ); writer.writeAttribute( "type", "way" ); writer.writeAttribute( "ref", memberId ); writer.writeAttribute( "role", "inner" ); writer.writeEndElement(); } writer.writeEndElement(); }
bool KmlPointTagWriter::write( const GeoNode *node, GeoWriter& writer ) const { const GeoDataPoint *point = static_cast<const GeoDataPoint*>(node); writer.writeStartElement( kml::kmlTag_Point ); writer.writeStartElement("coordinates"); QString coordinateString; //FIXME: this should be using the GeoDataCoordinates::toString but currently // it is not including the altitude and is adding an extra space after commas coordinateString += QString::number( point->coordinates().longitude( GeoDataCoordinates::Degree ), 'f', 10 ); coordinateString += ',' ; coordinateString += QString::number( point->coordinates().latitude( GeoDataCoordinates::Degree ) , 'f', 10 ); if( point->coordinates().altitude() ) { coordinateString += ','; coordinateString += QString::number( point->coordinates().altitude() , 'f' , 10); } writer.writeCharacters( coordinateString ); writer.writeEndElement(); writer.writeEndElement(); return true; }
bool PositionTracking::saveTrack( const QString& fileName ) { if ( fileName.isEmpty() ) { return false; } GeoWriter writer; //FIXME: a better way to do this? writer.setDocumentType( kml::kmlTag_nameSpaceOgc22 ); GeoDataDocument *document = new GeoDataDocument; QFileInfo fileInfo( fileName ); QString name = fileInfo.baseName(); document->setName( name ); foreach( const GeoDataStyle &style, d->m_document.styles() ) { document->addStyle( style ); } foreach( const GeoDataStyleMap &map, d->m_document.styleMaps() ) { document->addStyleMap( map ); } GeoDataPlacemark *track = new GeoDataPlacemark( *d->m_currentTrackPlacemark ); track->setName( "Track " + name ); document->append( track ); QFile file( fileName ); file.open( QIODevice::WriteOnly ); bool const result = writer.write( &file, document ); file.close(); delete document; return result; }
bool KmlLinkTagWriter::write( const GeoNode *node, GeoWriter& writer ) const { const GeoDataLink *link = static_cast<const GeoDataLink*>( node ); writer.writeStartElement( kml::kmlTag_Link ); KmlObjectTagWriter::writeIdentifiers( writer, link ); writer.writeElement( kml::kmlTag_href, link->href() ); QString const refreshMode = refreshModeToString( link->refreshMode() ); writer.writeOptionalElement( kml::kmlTag_refreshMode, refreshMode, "onChange" ); writer.writeElement( kml::kmlTag_refreshInterval, QString::number( link->refreshInterval() ) ); QString const viewRefreshMode = viewRefreshModeToString( link->viewRefreshMode() ); writer.writeOptionalElement( kml::kmlTag_viewRefreshMode, viewRefreshMode, "never" ); writer.writeElement( kml::kmlTag_viewRefreshTime, QString::number( link->viewRefreshTime() ) ); writer.writeElement( kml::kmlTag_viewBoundScale, QString::number( link->viewBoundScale() ) ); writer.writeOptionalElement( kml::kmlTag_viewFormat, link->viewFormat()); writer.writeOptionalElement( kml::kmlTag_httpQuery, link->httpQuery()); writer.writeEndElement(); return true; }
bool OsmTagWriter::write( const GeoNode *node, GeoWriter& writer ) const { Q_UNUSED( node ); writer.writeStartElement( "osm" ); writer.writeAttribute( "version", osm::osmTag_version06 ); writer.writeAttribute( "generator", "Marble " + Marble::MARBLE_VERSION_STRING ); return true; }
bool KmlFlyToTagWriter::write( const GeoNode *node, GeoWriter& writer ) const { const GeoDataFlyTo *flyTo = static_cast<const GeoDataFlyTo*>( node ); writer.writeStartElement( kml::kmlTag_nameSpaceGx22, kml::kmlTag_FlyTo ); writer.writeElement( kml::kmlTag_nameSpaceGx22, kml::kmlTag_duration, QString::number( flyTo->duration()) ); QString const flyToModeString = flyTo->flyToMode() == GeoDataFlyTo::Smooth ? "smooth" : "bounce"; writer.writeElement( kml::kmlTag_nameSpaceGx22, kml::kmlTag_flyToMode, flyToModeString ); writeElement( flyTo->view(), writer ); writer.writeEndElement(); return true; }
bool KmlDataTagWriter::write( const GeoNode *node, GeoWriter& writer ) const { const GeoDataData *data = static_cast<const GeoDataData*>( node ); writer.writeStartElement( kml::kmlTag_Data ); writer.writeAttribute( "name", data->name() ); writer.writeOptionalElement( kml::kmlTag_displayName, data->displayName() ); writer.writeElement( "value", data->value().toString() ); writer.writeEndElement(); return true; }
bool KmlPhotoOverlayWriter::writeMid( const GeoNode *node, GeoWriter &writer ) const { KmlOverlayTagWriter::writeMid( node, writer ); const GeoDataPhotoOverlay *photo_overlay = static_cast<const GeoDataPhotoOverlay*>( node ); // rotation QString const rotation = QString::number( photo_overlay->rotation(), 'f', 3 ); writer.writeOptionalElement( kml::kmlTag_rotation, rotation, "0.000" ); // ViewVolume writer.writeStartElement( kml::kmlTag_ViewVolume ); writer.writeOptionalElement<qreal>( kml::kmlTag_leftFov, photo_overlay->viewVolume().leftFov(), 0 ); writer.writeOptionalElement<qreal>( kml::kmlTag_rightFov, photo_overlay->viewVolume().rightFov(), 0 ); writer.writeOptionalElement<qreal>( kml::kmlTag_bottomFov, photo_overlay->viewVolume().bottomFov(), 0 ); writer.writeOptionalElement<qreal>( kml::kmlTag_topFov, photo_overlay->viewVolume().topFov(), 0 ); writer.writeOptionalElement<qreal>( kml::kmlTag_near, photo_overlay->viewVolume().near(), 0 ); writer.writeEndElement(); // ImagePyramid writer.writeStartElement( kml::kmlTag_ImagePyramid ); writer.writeOptionalElement<int>( kml::kmlTag_tileSize, photo_overlay->imagePyramid().tileSize(), 256 ); writer.writeOptionalElement<int>( kml::kmlTag_maxWidth, photo_overlay->imagePyramid().maxWidth() ); writer.writeOptionalElement<int>( kml::kmlTag_maxHeight, photo_overlay->imagePyramid().maxHeight() ); switch ( photo_overlay->imagePyramid().gridOrigin() ) { case GeoDataImagePyramid::LowerLeft: writer.writeElement( kml::kmlTag_gridOrigin, "lowerLeft" ); break; case GeoDataImagePyramid::UpperLeft: writer.writeElement( kml::kmlTag_gridOrigin, "upperLeft" ); break; } writer.writeEndElement(); // Point writeElement( &photo_overlay->point(), writer ); // shape switch ( photo_overlay->shape() ) { case GeoDataPhotoOverlay::Rectangle: break; case GeoDataPhotoOverlay::Cylinder: writer.writeElement( kml::kmlTag_shape, "cylinder" ); break; case GeoDataPhotoOverlay::Sphere: writer.writeElement( kml::kmlTag_shape, "sphere" ); break; } return true; }
bool KmlLatLonAltBoxWriter::write( const GeoNode *node, GeoWriter& writer ) const { const GeoDataLatLonAltBox *latLonAltBox = static_cast<const GeoDataLatLonAltBox*>( node ); writer.writeStartElement(kml::kmlTag_LatLonAltBox); KmlObjectTagWriter::writeIdentifiers( writer, latLonAltBox ); writer.writeTextElement( kml::kmlTag_north, QString::number(latLonAltBox->north( GeoDataCoordinates::Degree )) ); writer.writeTextElement( kml::kmlTag_south, QString::number(latLonAltBox->south( GeoDataCoordinates::Degree )) ); writer.writeTextElement( kml::kmlTag_east, QString::number(latLonAltBox->east( GeoDataCoordinates::Degree )) ); writer.writeTextElement( kml::kmlTag_west, QString::number(latLonAltBox->west( GeoDataCoordinates::Degree )) ); writer.writeTextElement( kml::kmlTag_minAltitude, QString::number(latLonAltBox->minAltitude()) ); writer.writeTextElement( kml::kmlTag_maxAltitude, QString::number(latLonAltBox->maxAltitude()) ); KmlGroundOverlayWriter::writeAltitudeMode( writer, latLonAltBox->altitudeMode()); writer.writeEndElement(); return true; }
void KmlGroundOverlayWriter::writeAltitudeMode(GeoWriter& writer, AltitudeMode altMode) { if ( altMode == ClampToGround ) { // clampToGround is always the default value, so we never have to write it return; } const QString altitudeMode = KmlGroundOverlayWriter::altitudeModeToString( altMode ); bool const isGoogleExtension = ( altMode == ClampToSeaFloor || altMode == RelativeToSeaFloor ); if ( isGoogleExtension ) { // clampToSeaFloor and relativeToSeaFloor are Google extensions that need a gx: tag namespace writer.writeElement( kml::kmlTag_nameSpaceGx22, kml::kmlTag_altitudeMode, altitudeMode); } else { writer.writeElement( kml::kmlTag_altitudeMode, altitudeMode ); } }
bool KmlPolygonTagWriter::write( const GeoNode *node, GeoWriter& writer ) const { const GeoDataPolygon *polygon = static_cast<const GeoDataPolygon*>( node ); writer.writeStartElement( kml::kmlTag_Polygon ); KmlObjectTagWriter::writeIdentifiers( writer, polygon ); writer.writeOptionalElement( kml::kmlTag_extrude, QString::number( polygon->extrude() ), "0" ); writer.writeStartElement( "outerBoundaryIs" ); writeElement( &polygon->outerBoundary(), writer ); writer.writeEndElement(); const QVector<GeoDataLinearRing>& linearRings = polygon->innerBoundaries(); if (linearRings.size() > 0) { writer.writeStartElement( "innerBoundaryIs" ); for ( int i = 0; i < linearRings.size(); ++i ) { const GeoDataLinearRing& ring = linearRings[i]; writeElement( &ring, writer ); } writer.writeEndElement(); } writer.writeEndElement(); return true; }
bool KmlStyleTagWriter::write( const GeoNode *node, GeoWriter& writer ) const { const GeoDataStyle *style = static_cast<const GeoDataStyle*>( node ); writer.writeStartElement( kml::kmlTag_Style ); KmlObjectTagWriter::writeIdentifiers( writer, style ); writeElement( &style->iconStyle(), writer ); writeElement( &style->labelStyle(), writer ); writeElement( &style->lineStyle(), writer ); writeElement( &style->polyStyle(), writer ); writeElement( &style->balloonStyle(), writer ); writeElement( &style->listStyle(), writer ); writer.writeEndElement(); return true; }
bool KmlLineStringTagWriter::write( const GeoNode *node, GeoWriter& writer ) const { const GeoDataLineString *lineString = static_cast<const GeoDataLineString*>( node ); if ( lineString->size() > 1 ) { writer.writeStartElement( kml::kmlTag_LineString ); writer.writeStartElement( "coordinates" ); // Write altitude for *all* elements, if *any* element // has altitude information (!= 0.0) bool hasAltitude = false; for ( int i = 0; i < lineString->size(); ++i ) { if ( lineString->at( i ).altitude() ) { hasAltitude = true; break; } } for ( int i = 0; i < lineString->size(); ++i ) { GeoDataCoordinates coordinates = lineString->at( i ); if ( i > 0 ) { writer.writeCharacters( " " ); } qreal lon = coordinates.longitude( GeoDataCoordinates::Degree ); writer.writeCharacters( QString::number( lon, 'f', 10 ) ); writer.writeCharacters( "," ); qreal lat = coordinates.latitude( GeoDataCoordinates::Degree ); writer.writeCharacters( QString::number( lat, 'f', 10 ) ); if ( hasAltitude ) { qreal alt = coordinates.altitude(); writer.writeCharacters( "," ); writer.writeCharacters( QString::number( alt, 'f', 2 ) ); } } writer.writeEndElement(); writer.writeEndElement(); return true; } return false; }
bool KmlPlacemarkTagWriter::writeMid( const GeoNode *node, GeoWriter& writer ) const { const GeoDataPlacemark *placemark = static_cast<const GeoDataPlacemark*>(node); writer.writeOptionalElement( kml::kmlTag_styleUrl, placemark->styleUrl() ); if ( placemark->styleUrl().isEmpty() && placemark->customStyle() ) { writeElement( placemark->customStyle().data(), writer ); } if( placemark->geometry() ) { writeElement( placemark->geometry(), writer ); } if( placemark->isBalloonVisible() ){ QString string; string.setNum( 1 ); writer.writeElement( kml::kmlTag_nameSpaceGx22, kml::kmlTag_balloonVisibility, string ); } return true; }
bool DgmlDocumentTagWriter::write( const GeoNode *node, GeoWriter& writer ) const { const GeoSceneDocument *document = static_cast<const GeoSceneDocument*>( node ); writer.writeStartElement( dgml::dgmlTag_Document ); const GeoSceneHead *head = document->head(); writeElement( head, writer ); const GeoSceneMap *map = document->map() ; writeElement( map, writer ); const GeoSceneSettings *settings = document->settings(); writeElement( settings, writer ); const GeoSceneLegend *legend = document->legend(); writeElement( legend, writer ); writer.writeEndDocument(); return true; }
void OsmObjectAttributeWriter::writeAttributes( const OsmPlacemarkData& osmData, GeoWriter &writer ) { writer.writeAttribute( "id", QString::number( osmData.id() ) ); writer.writeOptionalAttribute( "action", osmData.action() ); writer.writeOptionalAttribute( "changeset", osmData.changeset() ); writer.writeOptionalAttribute( "timestamp", osmData.timestamp() ); writer.writeOptionalAttribute( "uid", osmData.uid() ); writer.writeOptionalAttribute( "user", osmData.user() ); writer.writeOptionalAttribute( "version", osmData.version() ); writer.writeOptionalAttribute( "visible", osmData.isVisible() ); }
bool KmlColorStyleTagWriter::write( const Marble::GeoNode *node, GeoWriter &writer ) const { GeoDataColorStyle const *colorStyle = static_cast<const GeoDataColorStyle*>(node); if ( colorStyle->id().isEmpty() && colorStyle->targetId().isEmpty() && colorStyle->color() == defaultColor() && colorStyle->colorMode() == GeoDataColorStyle::Normal && isEmpty( node ) ) { return true; } writer.writeStartElement( m_elementName ); KmlObjectTagWriter::writeIdentifiers( writer, colorStyle); writer.writeOptionalElement( kml::kmlTag_color, formatColor( colorStyle->color() ), formatColor( defaultColor() ) ); QString const colorMode = colorStyle->colorMode() == GeoDataColorStyle::Random ? "random" : "normal"; writer.writeOptionalElement( kml::kmlTag_colorMode, colorMode, "normal" ); bool const result = writeMid( node, writer ); writer.writeEndElement(); return result; }
bool TourWidgetPrivate::saveTourAs(const QString &filename) { if ( !filename.isEmpty() ) { QFile file( filename ); if ( file.open( QIODevice::WriteOnly ) ) { GeoWriter writer; writer.setDocumentType( kml::kmlTag_nameSpaceOgc22 ); if ( writer.write( &file, m_document ) ) { file.close(); m_tourUi.m_actionSaveTour->setEnabled( false ); m_isChanged = false; GeoDataDocument* document = m_document; if ( !document->fileName().isNull() ) { m_widget->model()->removeGeoData( document->fileName() ); } m_widget->model()->addGeoDataFile( filename ); m_document->setFileName( filename ); return true; } } } return false; }
bool KmlUpdateTagWriter::write( const GeoNode *node, GeoWriter& writer ) const { const GeoDataUpdate *update = static_cast<const GeoDataUpdate*>( node ); KmlObjectTagWriter::writeIdentifiers( writer, update ); writer.writeStartElement( kml::kmlTag_Update ); writer.writeElement( kml::kmlTag_targetHref, update->targetHref() ); if( update->change() && update->change()->size() > 0 ) { writer.writeStartElement( kml::kmlTag_Change ); QVector<GeoDataFeature*>::ConstIterator it = update->change()->constBegin(); QVector<GeoDataFeature*>::ConstIterator const end = update->change()->constEnd(); for ( ; it != end; ++it ) { writeElement( *it, writer ); } writer.writeEndElement(); } else if( update->create() && update->create()->size() > 0 ) { writer.writeStartElement( kml::kmlTag_Create ); QVector<GeoDataFeature*>::ConstIterator it = update->create()->constBegin(); QVector<GeoDataFeature*>::ConstIterator const end = update->create()->constEnd(); for ( ; it != end; ++it ) { writeElement( *it, writer ); } writer.writeEndElement(); } else if( update->getDelete() && update->getDelete()->size() > 0 ) { writer.writeStartElement( kml::kmlTag_Delete ); QVector<GeoDataFeature*>::ConstIterator it = update->getDelete()->constBegin(); QVector<GeoDataFeature*>::ConstIterator const end = update->getDelete()->constEnd(); for ( ; it != end; ++it ) { writeElement( *it, writer ); } writer.writeEndElement(); } writer.writeEndElement(); return true; }
bool KmlPlacemarkTagWriter::write( const GeoNode *node, GeoWriter& writer ) const { const GeoDataPlacemark *placemark = static_cast<const GeoDataPlacemark*>(node); writer.writeStartElement( kml::kmlTag_Placemark ); writer.writeOptionalElement( "name", placemark->name() ); writer.writeElement( kml::kmlTag_visibility, QString::number( placemark->isVisible() ) ); writer.writeOptionalElement( kml::kmlTag_styleUrl, placemark->styleUrl() ); if( !placemark->description().isEmpty() ) { writer.writeStartElement( "description" ); if( placemark->descriptionIsCDATA() ) { writer.writeCDATA( placemark->description() ); } else { writer.writeCharacters( placemark->description() ); } writer.writeEndElement(); } if( !placemark->extendedData().isEmpty() ){ writeElement( &placemark->extendedData(), writer ); } if( placemark->geometry() ) { writeElement( placemark->geometry(), writer ); } if( placemark->lookAt() ){ writeElement( placemark->lookAt(), writer ); } if( placemark->timeStamp().when().isValid() ) writeElement( &placemark->timeStamp(), writer ); writer.writeEndElement(); return true; }
bool KmlBalloonStyleTagWriter::write( const GeoNode *node, GeoWriter& writer ) const { const GeoDataBalloonStyle *balloonStyle = static_cast<const GeoDataBalloonStyle*>( node ); bool const isEmpty = balloonStyle->backgroundColor() == QColor( Qt::white ) && balloonStyle->textColor() == QColor( Qt::black ) && balloonStyle->text().isEmpty() && balloonStyle->displayMode() == GeoDataBalloonStyle::Default; if ( isEmpty ) { return true; } writer.writeStartElement( kml::kmlTag_BalloonStyle ); KmlObjectTagWriter::writeIdentifiers( writer, balloonStyle ); QString const backgroundColor = KmlColorStyleTagWriter::formatColor( balloonStyle->backgroundColor() ); writer.writeOptionalElement( kml::kmlTag_bgColor, backgroundColor, "ffffffff" ); QString const textColor = KmlColorStyleTagWriter::formatColor( balloonStyle->textColor() ); writer.writeOptionalElement( kml::kmlTag_textColor, textColor, "ff000000" ); QString const textString = balloonStyle->text(); if ( textString.contains( QRegExp( "[<>&]" ) ) ) { writer.writeStartElement( kml::kmlTag_text ); writer.writeCDATA( textString ); writer.writeEndElement(); } else { writer.writeOptionalElement( kml::kmlTag_text, textString ); } if ( balloonStyle->displayMode() == GeoDataBalloonStyle::Hide ) { writer.writeElement( kml::kmlTag_displayMode, "hide" ); } writer.writeEndElement(); return true; }
bool DgmlMapTagWriter::write(const GeoNode *node, GeoWriter& writer) const { const GeoSceneMap *map = static_cast<const GeoSceneMap*>( node ); writer.writeStartElement( dgml::dgmlTag_Map ); writer.writeAttribute( "bgcolor", map->backgroundColor().name() ); writer.writeAttribute( "labelColor", map->labelColor().name() ); writer.writeStartElement( "canvas" ); writer.writeEndElement(); writer.writeStartElement( "target" ); writer.writeEndElement(); for( int i = 0; i < map->layers().count(); ++i ) { writeElement( map->layers().at( i ), writer ); } writer.writeEndElement(); return true; }
bool KmlGroundOverlayWriter::writeMid(const GeoNode *node, GeoWriter &writer) const { KmlOverlayTagWriter::writeMid( node, writer ); const GeoDataGroundOverlay *ground_overlay = static_cast<const GeoDataGroundOverlay*>( node ); writer.writeOptionalElement( kml::kmlTag_altitude, QString::number(ground_overlay->altitude()), "0" ); KmlGroundOverlayWriter::writeAltitudeMode( writer, ground_overlay->altitudeMode() ); if ( !ground_overlay->latLonBox().isEmpty() ) { writeElement( &ground_overlay->latLonBox(), writer ); } if ( ground_overlay->latLonQuad().isValid() ) { writeElement( &ground_overlay->latLonQuad(), writer ); } return true; }
bool KmlLookAtTagWriter::write( const GeoNode *node, GeoWriter& writer ) const { const GeoDataLookAt *lookAt = static_cast<const GeoDataLookAt*>(node); writer.writeStartElement( kml::kmlTag_LookAt ); writer.writeElement( "longitude", QString::number( lookAt->longitude( GeoDataCoordinates::Degree ), 'f', 10 ) ); writer.writeElement( "latitude", QString::number( lookAt->latitude( GeoDataCoordinates::Degree ), 'f', 10 ) ); writer.writeElement( "altitude", QString::number( lookAt->altitude(), 'f', 10 ) ); writer.writeElement( "range", QString::number( lookAt->range(), 'f', 10 ) ); writer.writeEndElement(); return true; }
bool KmlLatLonBoxWriter::write( const GeoNode *node, GeoWriter& writer ) const { const GeoDataLatLonBox *lat_lon_box = static_cast<const GeoDataLatLonBox*>( node ); writer.writeStartElement( kml::kmlTag_LatLonBox ); writer.writeTextElement( "north", QString::number(lat_lon_box->north()) ); writer.writeTextElement( "south", QString::number(lat_lon_box->south()) ); writer.writeTextElement( "east", QString::number(lat_lon_box->east()) ); writer.writeTextElement( "west", QString::number(lat_lon_box->west()) ); writer.writeTextElement( "rotation", QString::number(lat_lon_box->rotation()) ); writer.writeEndElement(); return true; }
bool KmlStyleMapTagWriter::write( const GeoNode *node, GeoWriter& writer ) const { const GeoDataStyleMap *map = static_cast<const GeoDataStyleMap*>( node ); writer.writeStartElement( kml::kmlTag_StyleMap ); KmlObjectTagWriter::writeIdentifiers( writer, map ); QMapIterator<QString, QString> iter( *map ); while ( iter.hasNext() ) { iter.next(); writer.writeStartElement( kml::kmlTag_Pair ); writer.writeElement( kml::kmlTag_key, iter.key() ); writer.writeElement( kml::kmlTag_styleUrl, iter.value() ); writer.writeEndElement(); } writer.writeEndElement(); return true; }
bool KmlNetworkLinkTagWriter::write( const GeoNode *node, GeoWriter& writer ) const { const GeoDataNetworkLink *networkLink = static_cast<const GeoDataNetworkLink*>( node ); writer.writeStartElement( kml::kmlTag_NetworkLink ); writer.writeOptionalElement( kml::kmlTag_name, networkLink->name() ); writer.writeOptionalElement( kml::kmlTag_visibility, QString::number( networkLink->isVisible() ), "1"); writer.writeOptionalElement( kml::kmlTag_refreshVisibility, QString::number( networkLink->refreshVisibility() ), "0" ); writer.writeOptionalElement( kml::kmlTag_flyToView, QString::number( networkLink->flyToView() ), "0" ); writeElement( &networkLink->link(), writer); writer.writeEndElement(); return true; }
bool KmlLatLonQuadWriter::write( const GeoNode *node, GeoWriter& writer ) const { const GeoDataLatLonQuad *latLonQuad = static_cast<const GeoDataLatLonQuad*>( node ); if ( latLonQuad->isValid() ) { writer.writeStartElement( kml::kmlTag_nameSpaceGx22, kml::kmlTag_LatLonQuad ); writer.writeStartElement( kml::kmlTag_coordinates ); writer.writeCharacters( QString::number( latLonQuad->bottomLeftLongitude( GeoDataCoordinates::Degree ) ) ); writer.writeCharacters( QString( ',' ) ); writer.writeCharacters( QString::number( latLonQuad->bottomLeftLatitude( GeoDataCoordinates::Degree ) ) ); writer.writeCharacters( QString( ' ' ) ); writer.writeCharacters( QString::number( latLonQuad->bottomRightLongitude( GeoDataCoordinates::Degree ) ) ); writer.writeCharacters( QString( ',' ) ); writer.writeCharacters( QString::number( latLonQuad->bottomRightLatitude( GeoDataCoordinates::Degree ) ) ); writer.writeCharacters( QString( ' ' ) ); writer.writeCharacters( QString::number( latLonQuad->topRightLongitude( GeoDataCoordinates::Degree ) ) ); writer.writeCharacters( QString( ',' ) ); writer.writeCharacters( QString::number( latLonQuad->topRightLatitude( GeoDataCoordinates::Degree ) ) ); writer.writeCharacters( QString( ' ' ) ); writer.writeCharacters( QString::number( latLonQuad->topLeftLongitude( GeoDataCoordinates::Degree ) ) ); writer.writeCharacters( QString( ',' ) ); writer.writeCharacters( QString::number( latLonQuad->topLeftLatitude( GeoDataCoordinates::Degree ) ) ); writer.writeEndElement(); writer.writeEndElement(); } return true; }
bool GeoTagWriter::writeElement( const GeoNode *object, GeoWriter &writer) const { return writer.writeElement( object ); }