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 );
}
