GeoDataDocument *VectorClipper::clipTo(const GeoDataLatLonBox &tileBoundary, int zoomLevel)
{
bool const useBaseClipper = false;
if (useBaseClipper) {
return clipToBaseClipper(tileBoundary);
}
bool const filterSmallAreas = zoomLevel > 10 && zoomLevel < 17;
GeoDataDocument* tile = new GeoDataDocument();
auto const clip = clipPath(tileBoundary, zoomLevel);
GeoDataLinearRing ring;
ring << GeoDataCoordinates(tileBoundary.west(), tileBoundary.north());
ring << GeoDataCoordinates(tileBoundary.east(), tileBoundary.north());
ring << GeoDataCoordinates(tileBoundary.east(), tileBoundary.south());
ring << GeoDataCoordinates(tileBoundary.west(), tileBoundary.south());
qreal const minArea = filterSmallAreas ? 0.01 * area(ring) : 0.0;
foreach (GeoDataPlacemark const * placemark, potentialIntersections(tileBoundary)) {
GeoDataGeometry const * const geometry = placemark ? placemark->geometry() : nullptr;
if (geometry && tileBoundary.intersects(geometry->latLonAltBox())) {
if(geometry->nodeType() == GeoDataTypes::GeoDataPolygonType) {
clipPolygon(placemark, clip, minArea, tile);
} else if (geometry->nodeType() == GeoDataTypes::GeoDataLineStringType) {
clipString<GeoDataLineString>(placemark, clip, minArea, tile);
} else if (geometry->nodeType() == GeoDataTypes::GeoDataLinearRingType) {
clipString<GeoDataLinearRing>(placemark, clip, minArea, tile);
} else {
tile->append(new GeoDataPlacemark(*placemark));
}
}
}
void GeoGraphicsScene::removeItem( GeoGraphicsItem* item )
{
int zoomLevel;
qreal north, south, east, west;
item->latLonAltBox().boundaries( north, south, east, west );
for(zoomLevel = s_tileZoomLevel; zoomLevel >= 0; zoomLevel--)
{
if( d->coordToTileId( GeoDataCoordinates(west, north, 0), zoomLevel ) ==
d->coordToTileId( GeoDataCoordinates(east, south, 0), zoomLevel ) )
break;
}
int tnorth, tsouth, teast, twest;
TileId key;
key = d->coordToTileId( GeoDataCoordinates(west, north, 0), zoomLevel );
twest = key.x();
tnorth = key.y();
key = d->coordToTileId( GeoDataCoordinates(east, south, 0), zoomLevel );
teast = key.x();
tsouth = key.y();
for( int i = twest; i <= teast; i++ )
{
for( int j = tsouth; j <= tnorth; j++ )
{
QList< GeoGraphicsItem* >& tileList = d->m_items[TileId( "", zoomLevel, i, j )];
tileList.removeOne( item );
}
}
}
void GeoDataLatLonAltBoxTest::fromLineStringTest()
{
qreal west = randomLon();
qreal east = randomLon();
qreal lat1 = randomLat();
qreal lat2 = randomLat();
GeoDataLatLonAltBox sourceBox;
if ( lat1 >= lat2 ) {
sourceBox = GeoDataLatLonBox( lat1, lat2, east, west, GeoDataCoordinates::Degree );
}
else {
sourceBox = GeoDataLatLonBox( lat2, lat1, east, west, GeoDataCoordinates::Degree );
}
GeoDataLinearRing ring;
// SouthWest
ring << GeoDataCoordinates( sourceBox.west(), sourceBox.south() );
// SouthEast
ring << GeoDataCoordinates( sourceBox.east(), sourceBox.south() );
// NorthEast
ring << GeoDataCoordinates( sourceBox.east(), sourceBox.north() );
// NorthWest
ring << GeoDataCoordinates( sourceBox.west(), sourceBox.north() );
QCOMPARE( GeoDataLatLonAltBox::fromLineString( ring ).toString(), sourceBox.toString() );
}
void GeoGraphicsScene::addIdem( GeoGraphicsItem* item )
{
// Select zoom level so that the object fit in single tile
int zoomLevel;
qreal north, south, east, west;
item->latLonAltBox().boundaries( north, south, east, west );
for(zoomLevel = s_tileZoomLevel; zoomLevel >= 0; zoomLevel--)
{
if( d->coordToTileId( GeoDataCoordinates(west, north, 0), zoomLevel ) ==
d->coordToTileId( GeoDataCoordinates(east, south, 0), zoomLevel ) )
break;
}
int tnorth, tsouth, teast, twest;
TileId key;
key = d->coordToTileId( GeoDataCoordinates(west, north, 0), zoomLevel );
twest = key.x();
tnorth = key.y();
key = d->coordToTileId( GeoDataCoordinates(east, south, 0), zoomLevel );
teast = key.x();
tsouth = key.y();
for( int i = twest; i <= teast; i++ )
{
for( int j = tsouth; j <= tnorth; j++ )
{
QList< GeoGraphicsItem* >& tileList = d->m_items[TileId( "", zoomLevel, i, j )];
QList< GeoGraphicsItem* >::iterator position = qLowerBound( tileList.begin(), tileList.end(), item, zValueLessThan );
tileList.insert( position, item );
}
}
}
GeoDataCoordinates GeoDataLatLonAltBox::center() const
{
if ( isEmpty() )
return GeoDataCoordinates();
if( crossesDateLine() )
return GeoDataCoordinates( GeoDataCoordinates::normalizeLon(east() + 2 * M_PI - (east() + 2 * M_PI - west()) / 2),
north() - (north() - south()) / 2,
d->m_maxAltitude - (d->m_maxAltitude - d->m_minAltitude) / 2);
else
return GeoDataCoordinates( east() - (east() - west()) / 2,
north() - (north() - south()) / 2,
d->m_maxAltitude - (d->m_maxAltitude - d->m_minAltitude) / 2);
}
QSet<TileId> PlacemarkLayout::visibleTiles( const ViewportParams *viewport )
{
int zoomLevel = qLn( viewport->radius() *4 / 256 ) / qLn( 2.0 );
/*
* rely on m_placemarkCache to find the placemarks for the tiles which
* matter. The top level tiles have the more popular placemarks,
* the bottom level tiles have the smaller ones, and we only get the ones
* matching our latLonAltBox.
*/
qreal north, south, east, west;
viewport->viewLatLonAltBox().boundaries(north, south, east, west);
QSet<TileId> tileIdSet;
QVector<QRectF> geoRects;
if( west <= east ) {
geoRects << QRectF(west, north, east - west, south - north);
} else {
geoRects << QRectF(west, north, M_PI - west, south - north);
geoRects << QRectF(-M_PI, north, east + M_PI, south - north);
}
foreach( const QRectF &geoRect, geoRects ) {
TileId key;
QRect rect;
key = TileId::fromCoordinates( GeoDataCoordinates(geoRect.left(), north, 0), zoomLevel);
rect.setLeft( key.x() );
rect.setTop( key.y() );
key = TileId::fromCoordinates( GeoDataCoordinates(geoRect.right(), south, 0), zoomLevel);
rect.setRight( key.x() );
rect.setBottom( key.y() );
TileCoordsPyramid pyramid(0, zoomLevel );
pyramid.setBottomLevelCoords( rect );
for ( int level = pyramid.topLevel(); level <= pyramid.bottomLevel(); ++level ) {
QRect const coords = pyramid.coords( level );
int x1, y1, x2, y2;
coords.getCoords( &x1, &y1, &x2, &y2 );
for ( int x = x1; x <= x2; ++x ) {
for ( int y = y1; y <= y2; ++y ) {
TileId const tileId( 0, level, x, y );
tileIdSet.insert(tileId);
}
}
}
}
void EditPlacemarkDialog::updateTextAnnotation()
{
d->m_placemark->setDescription( d->m_formattedTextWidget->text() );
//allow for HTML in the description
d->m_placemark->setDescriptionCDATA( true );
d->m_placemark->setName( d->m_header->name() );
d->m_placemark->setCoordinate( GeoDataCoordinates( d->m_header->longitude(),
d->m_header->latitude(),
0,
GeoDataCoordinates::Degree ) );
d->m_placemark->setVisible( d->m_isPlacemarkVisible->isChecked() );
d->m_placemark->setBalloonVisible( d->m_isBalloonVisible->isChecked() );
d->m_placemark->setId( d->m_header->id() );
d->m_placemark->setTargetId( d->m_header->targetId() );
GeoDataStyle *newStyle = new GeoDataStyle( *d->m_placemark->style() );
QFileInfo fileInfo( d->m_header->iconLink() );
if ( fileInfo.exists() ) {
newStyle->iconStyle().setIconPath( d->m_header->iconLink() );
}
newStyle->iconStyle().setScale( d->m_iconScale->value() );
newStyle->labelStyle().setScale( d->m_labelScale->value() );
newStyle->iconStyle().setColor( d->m_iconColorDialog->currentColor() );
newStyle->labelStyle().setColor( d->m_labelColorDialog->currentColor() );
d->m_placemark->setStyle( newStyle );
emit textAnnotationUpdated( d->m_placemark );
}
void OpenCachingComModel::updateHome()
{
qreal lon, lat;
int zoom;
marbleModel()->home( lon, lat, zoom );
m_homeCoordinates = GeoDataCoordinates(lon, lat, 0, GeoDataCoordinates::Degree);
}
void FlyToEditWidget::save()
{
if (flyToElement()->view() != nullptr && m_coord != GeoDataCoordinates()) {
GeoDataCoordinates coords = m_coord;
if (auto camera = geodata_cast<GeoDataCamera>(flyToElement()->view())) {
camera->setCoordinates( coords );
} else if (auto lookAt = geodata_cast<GeoDataLookAt>(flyToElement()->view())) {
lookAt->setCoordinates( coords );
} else{
lookAt = new GeoDataLookAt;
lookAt->setCoordinates( coords );
flyToElement()->setView( lookAt );
}
}
flyToElement()->setDuration(m_durationSpin->value());
if (m_modeCombo->currentIndex() == 0) {
flyToElement()->setFlyToMode( GeoDataFlyTo::Smooth );
} else if (m_modeCombo->currentIndex() == 1) {
flyToElement()->setFlyToMode( GeoDataFlyTo::Bounce );
}
emit editingDone(m_index);
}
QList< GeoGraphicsItem* > GeoGraphicsScene::items( const Marble::GeoDataLatLonAltBox& box, int maxZoomLevel ) const
{
QList< GeoGraphicsItem* > result;
QRect rect;
qreal north, south, east, west;
box.boundaries( north, south, east, west );
TileId key;
int zoomLevel = maxZoomLevel < s_tileZoomLevel ? maxZoomLevel : s_tileZoomLevel;
key = d->coordToTileId( GeoDataCoordinates(west, north, 0), zoomLevel );
rect.setLeft( key.x() );
rect.setTop( key.y() );
key = d->coordToTileId( GeoDataCoordinates(east, south, 0), zoomLevel );
rect.setRight( key.x() );
rect.setBottom( key.y() );
TileCoordsPyramid pyramid( 0, zoomLevel );
pyramid.setBottomLevelCoords( rect );
for ( int level = pyramid.topLevel(); level <= pyramid.bottomLevel(); ++level ) {
QRect const coords = pyramid.coords( level );
int x1, y1, x2, y2;
coords.getCoords( &x1, &y1, &x2, &y2 );
for ( int x = x1; x <= x2; ++x ) {
for ( int y = y1; y <= y2; ++y ) {
TileId const tileId( "", level, x, y );
const QList< GeoGraphicsItem* > &objects = d->m_items.value(tileId);
QList< GeoGraphicsItem* >::iterator before = result.begin();
QList< GeoGraphicsItem* >::const_iterator currentItem = objects.constBegin();
while( currentItem != objects.end() )
{
while( ( currentItem != objects.end() )
&& ( ( before == result.end() ) || ( (*currentItem)->zValue() < (*before)->zValue() ) ) )
{
if( (*currentItem)->minZoomLevel() <= maxZoomLevel )
before = result.insert( before, *currentItem );
currentItem++;
}
if ( before != result.end() )
before++;
}
}
}
}
return result;
}
void RoutingInputWidget::clear()
{
d->m_nominatimTimer.stop();
d->m_lineEdit->setBusy(false);
d->m_route->setPosition( d->m_index, GeoDataCoordinates() );
d->m_lineEdit->clear();
emit targetValidityChanged( false );
}
GeoDataCoordinates AlternativeRoutesModelPrivate::coordinates( const GeoDataCoordinates &start, qreal distance, qreal bearing )
{
qreal lat1 = start.latitude();
qreal lon1 = start.longitude();
qreal lat2 = asin( sin( lat1 ) * cos( distance ) + cos( lat1 ) * sin( distance ) * cos( bearing ) );
qreal lon2 = lon1 + atan2( sin( bearing ) * sin( distance ) * cos( lat1 ), cos( distance ) - sin( lat1 ) * sin( lat2 ) );
return GeoDataCoordinates( lon2, lat2 );
}
GeoDataCoordinates RoutingInputWidget::targetPosition() const
{
if ( d->m_index < d->m_route->size() ) {
return d->m_route->at( d->m_index );
} else {
return GeoDataCoordinates();
}
}
GeoDataPoint::GeoDataPoint( qreal lon, qreal lat, qreal alt,
GeoDataCoordinates::Unit unit )
: GeoDataGeometry( new GeoDataPointPrivate )
{
Q_D(GeoDataPoint);
d->m_coordinates = GeoDataCoordinates(lon, lat, alt, unit);
d->m_latLonAltBox = GeoDataLatLonAltBox(d->m_coordinates);
}
GeoDataCoordinates ViewportParams::focusPoint() const
{
if (d->m_focusPoint.isValid()) {
return d->m_focusPoint;
}
else {
const qreal lon = d->m_centerLongitude;
const qreal lat = d->m_centerLatitude;
return GeoDataCoordinates(lon, lat, 0.0, GeoDataCoordinates::Radian);
}
}
void TileIdTest::testFromCoordinates()
{
QFETCH( qreal, lon );
QFETCH( qreal, lat );
QFETCH( int, zoom);
QFETCH( int, x);
QFETCH( int, y);
const TileId tile = TileId::fromCoordinates(GeoDataCoordinates( lon , lat, 0, GeoDataCoordinates::Degree), zoom );
QCOMPARE( tile.x(), x );
QCOMPARE( tile.y(), y );
}
GeoDataCoordinates GeoDataAbstractView::coordinates() const
{
if ( nodeType() == GeoDataTypes::GeoDataLookAtType) {
const GeoDataLookAt *lookAt = static_cast<const GeoDataLookAt*>( this );
if( lookAt ){
return lookAt->coordinates();
}
}
else if( nodeType() == GeoDataTypes::GeoDataCameraType ){
const GeoDataCamera *camera = static_cast<const GeoDataCamera*>( this );
if ( camera ){
return camera->coordinates();
}
}
return GeoDataCoordinates();
}
QVariant TargetModel::homeData ( int role ) const
{
switch( role ) {
case Qt::DisplayRole: return tr( "Home" );
case Qt::DecorationRole: return QIcon( ":/icons/go-home.png" );
case MarblePlacemarkModel::CoordinateRole: {
qreal lon( 0.0 ), lat( 0.0 );
int zoom( 0 );
m_marbleModel->home( lon, lat, zoom );
const GeoDataCoordinates coordinates = GeoDataCoordinates( lon, lat, 0, GeoDataCoordinates::Degree );
return qVariantFromValue( coordinates );
}
}
return QVariant();
}
bool RoutingLayerPrivate::handleMouseButtonRelease( QMouseEvent *e )
{
if ( e->button() != Qt::LeftButton ) {
return false;
}
if ( m_pointSelection ) {
if ( e->button() == Qt::LeftButton ) {
qreal lon( 0.0 ), lat( 0.0 );
if ( m_marbleWidget->geoCoordinates( e->pos().x(), e->pos().y(),
lon, lat, GeoDataCoordinates::Radian ) ) {
emit q->pointSelected( GeoDataCoordinates( lon, lat ) );
return true;
}
} else {
return false;
}
}
if ( m_movingIndex >= 0 ) {
m_movingIndex = -1;
clearStopOver();
emit q->routeDirty();
return true;
}
if ( !m_dropStopOver.isNull() && !m_dragStopOver.isNull() ) {
QPoint moved = e->pos() - m_dragStopOver;
if ( moved.manhattanLength() < 10 ) {
return false;
}
qreal lon( 0.0 ), lat( 0.0 );
if ( m_dragStopOverRightIndex >= 0 && m_dragStopOverRightIndex <= m_routeRequest->size()
&& m_marbleWidget->geoCoordinates( m_dropStopOver.x(), m_dropStopOver.y(), lon, lat, GeoDataCoordinates::Radian ) ) {
GeoDataCoordinates position( lon, lat );
m_dragStopOverRightIndex = viaInsertPosition( e->modifiers() );
m_routeRequest->insert( m_dragStopOverRightIndex, position );
clearStopOver();
emit q->routeDirty();
return true;
}
}
return false;
}
bool AbstractGeoPolygonGraphicsItem::contains(const QPoint &screenPosition, const ViewportParams *viewport) const
{
auto const visualCategory = static_cast<const GeoDataPlacemark*>(feature())->visualCategory();
if (visualCategory == GeoDataPlacemark::Landmass ||
visualCategory == GeoDataPlacemark::UrbanArea ||
(visualCategory >= GeoDataPlacemark::LanduseAllotments && visualCategory <= GeoDataPlacemark::LanduseVineyard)) {
return false;
}
double lon, lat;
viewport->geoCoordinates(screenPosition.x(), screenPosition.y(), lon, lat, GeoDataCoordinates::Radian);
auto const coordinates = GeoDataCoordinates(lon, lat);
if (m_polygon) {
return m_polygon->contains(coordinates);
} else if (m_ring) {
return m_ring->contains(coordinates);
}
return false;
}
void SatellitesMSCItem::addTrackPointAt( const QDateTime &dateTime )
{
double lng = 0.;
double lat = 0.;
double height = 0.;
QDateTime dt = dateTime.toUTC();
QDate date = dt.date();
QTime time = dt.time();
m_planSat->setMJD( date.year(), date.month(), date.day(),
time.hour(), time.minute(), time.second() );
m_planSat->currentPos();
m_planSat->getPlanetographic( lng, lat, height );
m_track->addPoint( dateTime,
GeoDataCoordinates( lng, lat, height * 1000,
GeoDataCoordinates::Degree) );
}
void EditPlacemarkDialog::updateTextAnnotation()
{
d->m_placemark->setDescription( d->m_formattedTextWidget->text() );
//allow for HTML in the description
d->m_placemark->setDescriptionCDATA( true );
d->m_placemark->setName( d->m_header->name() );
d->m_placemark->setCoordinate( GeoDataCoordinates( d->m_header->longitude(),
d->m_header->latitude(),
0,
GeoDataCoordinates::Degree ) );
d->m_placemark->setVisible( d->m_isPlacemarkVisible->isChecked() );
d->m_placemark->setBalloonVisible( d->m_isBalloonVisible->isChecked() );
d->m_placemark->setId( d->m_header->id() );
d->m_placemark->setTargetId( d->m_header->targetId() );
if ( !d->m_header->iconLink().isEmpty() ) {
QFileInfo fileInfo( d->m_header->iconLink() );
GeoDataStyle *newStyle = new GeoDataStyle( *d->m_placemark->style() );
if ( fileInfo.exists() ) {
newStyle->iconStyle().setIconPath( d->m_header->iconLink() );
}
newStyle->iconStyle().setScale( d->m_iconScale->value() );
newStyle->labelStyle().setScale( d->m_labelScale->value() );
newStyle->iconStyle().setColor( d->m_iconColorDialog->currentColor() );
newStyle->labelStyle().setColor( d->m_labelColorDialog->currentColor() );
d->m_placemark->setStyle( newStyle );
}
else {
QString suitableTag = d->m_osmTagEditorWidget->suitableTag();
if ( !suitableTag.isEmpty() ) {
GeoDataFeature::GeoDataVisualCategory category = OsmPresetLibrary::osmVisualCategory( suitableTag );
d->m_placemark->setVisualCategory( category );
d->m_placemark->setStyle( 0 );
}
}
emit textAnnotationUpdated( d->m_placemark );
}
void EditPlacemarkDialog::updateTextAnnotation()
{
d->m_placemark->setDescription( d->m_formattedTextWidget->text() );
//allow for HTML in the description
d->m_placemark->setDescriptionCDATA( true );
d->m_placemark->setName( d->m_header->name() );
d->m_placemark->setCoordinate( GeoDataCoordinates( d->m_header->longitude(),
d->m_header->latitude(),
0,
GeoDataCoordinates::Degree ) );
d->m_placemark->setVisible( d->m_isPlacemarkVisible->isChecked() );
d->m_placemark->setBalloonVisible( d->m_isBalloonVisible->isChecked() );
d->m_placemark->setId( d->m_header->id() );
d->m_placemark->setTargetId( d->m_header->targetId() );
if ( !d->m_header->iconLink().isEmpty() ) {
QFileInfo fileInfo( d->m_header->iconLink() );
GeoDataStyle::Ptr newStyle(new GeoDataStyle( *d->m_placemark->style() ));
if ( fileInfo.exists() ) {
newStyle->iconStyle().setIconPath( d->m_header->iconLink() );
}
newStyle->iconStyle().setScale( d->m_iconScale->value() );
newStyle->labelStyle().setScale( d->m_labelScale->value() );
newStyle->iconStyle().setColor( d->m_iconColorDialog->currentColor() );
newStyle->labelStyle().setColor( d->m_labelColorDialog->currentColor() );
d->m_placemark->setStyle( newStyle );
}
else {
const OsmPlacemarkData osmData = d->m_osmTagEditorWidget->placemarkData();
const GeoDataPlacemark::GeoDataVisualCategory category = StyleBuilder::determineVisualCategory(osmData);
if (category != GeoDataPlacemark::None) {
d->m_placemark->setStyle(GeoDataStyle::Ptr());
d->m_placemark->setVisualCategory( category );
}
}
emit textAnnotationUpdated( d->m_placemark );
}
QVector<GeoDataCoordinates> ElevationModel::heightProfile( qreal fromLon, qreal fromLat, qreal toLon, qreal toLat ) const
{
if ( !d->m_textureLayer ) {
return QVector<GeoDataCoordinates>();
}
const int tileZoomLevel = TileLoader::maximumTileLevel( *( d->m_textureLayer ) );
const int width = d->m_textureLayer->tileSize().width();
const int numTilesX = TileLoaderHelper::levelToColumn( d->m_textureLayer->levelZeroColumns(), tileZoomLevel );
qreal distPerPixel = ( qreal )360 / ( width * numTilesX );
//mDebug() << "heightProfile" << fromLat << fromLon << toLat << toLon << "distPerPixel" << distPerPixel;
qreal lat = fromLat;
qreal lon = fromLon;
char dirLat = fromLat < toLat ? 1 : -1;
char dirLon = fromLon < toLon ? 1 : -1;
qreal k = qAbs( ( fromLat - toLat ) / ( fromLon - toLon ) );
//mDebug() << "fromLon" << fromLon << "fromLat" << fromLat;
//mDebug() << "diff lon" << ( fromLon - toLon ) << "diff lat" << ( fromLat - toLat );
//mDebug() << "dirLon" << QString::number(dirLon) << "dirLat" << QString::number(dirLat) << "k" << k;
QVector<GeoDataCoordinates> ret;
while ( lat*dirLat <= toLat*dirLat && lon*dirLon <= toLon * dirLon ) {
//mDebug() << lat << lon;
qreal h = height( lon, lat );
if ( h < 32000 ) {
ret << GeoDataCoordinates( lon, lat, h, GeoDataCoordinates::Degree );
}
if ( k < 0.5 ) {
//mDebug() << "lon(x) += distPerPixel";
lat += distPerPixel * k * dirLat;
lon += distPerPixel * dirLon;
} else {
//mDebug() << "lat(y) += distPerPixel";
lat += distPerPixel * dirLat;
lon += distPerPixel / k * dirLon;
}
}
//mDebug() << ret;
return ret;
}
void FlyToEditWidget::save()
{
if (flyToElement()->view() != 0 && m_coord != GeoDataCoordinates()) {
GeoDataCoordinates coords = m_coord;
if ( flyToElement()->view()->nodeType() == GeoDataTypes::GeoDataCameraType ) {
GeoDataCamera* camera = dynamic_cast<GeoDataCamera*>( flyToElement()->view() );
camera->setCoordinates( coords );
} else if ( flyToElement()->view()->nodeType() == GeoDataTypes::GeoDataLookAtType ) {
GeoDataLookAt* lookAt = dynamic_cast<GeoDataLookAt*>( flyToElement()->view() );
lookAt->setCoordinates( coords );
} else{
GeoDataLookAt* lookAt = new GeoDataLookAt;
lookAt->setCoordinates( coords );
flyToElement()->setView( lookAt );
}
}
flyToElement()->setDuration(m_waitSpin->value());
emit editingDone(m_index);
}
GeoNode* OsmNdTagHandler::parse( GeoParser &geoParser ) const
{
Q_ASSERT( dynamic_cast<OsmParser *>( &geoParser ) != 0 );
OsmParser &parser = static_cast<OsmParser &>( geoParser );
Q_ASSERT( parser.isStartElement() );
GeoStackItem parentItem = parser.parentElement();
if ( parentItem.represents( osmTag_way ) )
{
GeoDataLineString *s = parentItem.nodeAs<GeoDataLineString>();
Q_ASSERT( s );
quint64 id = parser.attribute( "ref" ).toULongLong();
if ( GeoDataPoint *p = parser.node( id ) ) {
s->append( GeoDataCoordinates( p->coordinates().longitude(), p->coordinates().latitude() ) );
}
return 0;
}
return 0;
}
EditPlacemarkDialog::EditPlacemarkDialog( GeoDataPlacemark *placemark,
const QHash<qint64, OsmPlacemarkData> *relations,
QWidget *parent ) :
QDialog( parent ),
d( new Private( placemark ) )
{
d->setupUi( this );
// Store initial style so that it can be restored if the 'Cancel' button is pressed.
d->m_initialStyle = *placemark->style();
d->m_initialVisualCategory = placemark->visualCategory();
d->m_hadInitialOsmData = placemark->hasOsmData();
if ( d->m_hadInitialOsmData ) {
d->m_initialOsmData = placemark->osmData();
}
// If the placemark has just been created, assign it a default name.
if ( placemark->name().isNull() ) {
placemark->setName( tr("Untitled Placemark") );
}
// Setup id, name, icon link and latitude/longitude values.
d->m_header->setId( placemark->id() );
d->m_initialId = placemark->id();
d->m_header->setName( placemark->name() );
d->m_initialName = placemark->name();
d->m_isPlacemarkVisible->setChecked( placemark->isVisible() );
d->m_initialIsPlacemarkVisible = placemark->isVisible();
d->m_header->setIconLink( placemark->style()->iconStyle().iconPath() );
d->m_header->setTargetId( placemark->targetId() );
d->m_initialTargetId = placemark->targetId();
MarbleWidget* marbleWidget = dynamic_cast<MarbleWidget*>( parent );
if( marbleWidget != 0 ) {
const AngleUnit defaultAngleUnit = marbleWidget->defaultAngleUnit();
const GeoDataCoordinates::Notation notation =
(defaultAngleUnit == DecimalDegree) ? GeoDataCoordinates::Decimal :
(defaultAngleUnit == DMSDegree) ? GeoDataCoordinates::DMS :
/* else, UTM */ GeoDataCoordinates::DMS;
d->m_header->setNotation( notation );
}
connect( d->m_header, SIGNAL(valueChanged()), this, SLOT(
updateTextAnnotation()) );
d->m_formattedTextWidget->setText( placemark->description() );
d->m_initialDescription = placemark->description();
d->m_initialDescriptionIsCDATA = placemark->descriptionIsCDATA();
d->m_isBalloonVisible->setChecked( placemark->isBalloonVisible() );
d->m_initialIsBaloonVisible = placemark->isBalloonVisible();
d->m_header->setLatitude( placemark->coordinate().latitude( GeoDataCoordinates::Degree ) );
d->m_header->setLongitude( placemark->coordinate().longitude( GeoDataCoordinates::Degree ) );
d->m_initialCoords = GeoDataCoordinates( d->m_header->longitude(),
d->m_header->latitude(),
0,
GeoDataCoordinates::Degree );
// There's no point showing Relations and Tags tabs if the editor was not
// loaded from the annotate plugin ( loaded from tourWidget.. )
if ( relations ) {
// Adding the osm tag editor widget tab
d->m_osmTagEditorWidget = new OsmTagEditorWidget( placemark, this );
d->tabWidget->addTab( d->m_osmTagEditorWidget, tr( "Tags" ) );
QObject::connect( d->m_osmTagEditorWidget, SIGNAL( placemarkChanged( GeoDataFeature* ) ),
this, SLOT( updateTextAnnotation() ) );
// Adding the osm relation editor widget tab
d->m_osmRelationManagerWidget = new OsmRelationManagerWidget( placemark, relations, this );
d->tabWidget->addTab( d->m_osmRelationManagerWidget, tr( "Relations" ) );
QObject::connect( d->m_osmRelationManagerWidget, SIGNAL( relationCreated( const OsmPlacemarkData& ) ),
this, SIGNAL( relationCreated( const OsmPlacemarkData& ) ) );
}
// Adding the elevation widget tab
d->m_elevationWidget = new Ui::ElevationWidget;
QWidget *elevationTab = new QWidget;
d->m_elevationWidget->setupUi( elevationTab );
d->tabWidget->addTab( elevationTab, tr("Elevation") );
qreal altitude = d->m_placemark->coordinate().altitude();
MarbleLocale *locale = MarbleGlobal::getInstance()->locale();
if ( altitude == 0.0 ) {
switch ( locale->measurementSystem() ) {
case MarbleLocale::MetricSystem:
d->m_elevationUnit = MarbleLocale::Meter;
break;
case MarbleLocale::ImperialSystem:
d->m_elevationUnit = MarbleLocale::Foot;
break;
case MarbleLocale::NauticalSystem:
d->m_elevationUnit = MarbleLocale::NauticalMile;
break;
}
d->m_elevationWidget->elevationSpinBox->setSuffix( locale->unitAbbreviation((d->m_elevationUnit)) );
} else {
qreal convertedAltitude;
const MarbleLocale::MeasurementSystem currentSystem = locale->measurementSystem();
locale->meterToTargetUnit( altitude, currentSystem, convertedAltitude, d->m_elevationUnit );
d->m_elevationWidget->elevationSpinBox->setValue( convertedAltitude );
d->m_elevationWidget->elevationSpinBox->setSuffix( locale->unitAbbreviation(d->m_elevationUnit) );
}
// Adjust icon and label scales.
d->m_iconScale->setValue( placemark->style()->iconStyle().scale() );
connect( d->m_iconScale, SIGNAL(valueChanged(double)), this, SLOT(updateTextAnnotation()) );
d->m_labelScale->setValue( placemark->style()->labelStyle().scale() );
connect( d->m_labelScale, SIGNAL(valueChanged(double)), this, SLOT(updateTextAnnotation()) );
// Adjust the current color of the two push buttons' pixmap to resemble the label and icon colors.
const GeoDataLabelStyle labelStyle = placemark->style()->labelStyle();
const GeoDataIconStyle iconStyle = placemark->style()->iconStyle();
QPixmap labelPixmap( d->m_labelButton->iconSize().width(),
d->m_labelButton->iconSize().height() );
labelPixmap.fill( labelStyle.color() );
d->m_labelButton->setIcon( QIcon( labelPixmap ) );
QPixmap iconPixmap( d->m_iconButton->iconSize().width(),
d->m_iconButton->iconSize().height() );
iconPixmap.fill( iconStyle.color() );
d->m_iconButton->setIcon( QIcon( iconPixmap ) );
// Setup the color dialogs.
d->m_labelColorDialog = new QColorDialog( this );
d->m_labelColorDialog->setOption( QColorDialog::ShowAlphaChannel );
d->m_labelColorDialog->setCurrentColor( labelStyle.color() );
connect( d->m_labelButton, SIGNAL(clicked()), d->m_labelColorDialog, SLOT(exec()) );
connect( d->m_labelColorDialog, SIGNAL(colorSelected(QColor)), this, SLOT(updateLabelDialog(QColor)) );
connect( d->m_labelColorDialog, SIGNAL(colorSelected(QColor)), this, SLOT(updateTextAnnotation()) );
d->m_iconColorDialog = new QColorDialog( this );
d->m_iconColorDialog->setOption( QColorDialog::ShowAlphaChannel );
d->m_iconColorDialog->setCurrentColor( iconStyle.color() );
connect( d->m_iconButton, SIGNAL(clicked()), d->m_iconColorDialog, SLOT(exec()) );
connect( d->m_iconColorDialog, SIGNAL(colorSelected(QColor)), this, SLOT(updateIconDialog(QColor)) );
connect( d->m_iconColorDialog, SIGNAL(colorSelected(QColor)), this, SLOT(updateTextAnnotation()) );
connect( d->m_isBalloonVisible, SIGNAL(toggled(bool)), this, SLOT(updateTextAnnotation()) );
// Promote "Ok" button to default button.
d->buttonBox->button( QDialogButtonBox::Ok )->setDefault( true );
connect( d->buttonBox->button( QDialogButtonBox::Ok ), SIGNAL(pressed()), this, SLOT(checkFields()) );
connect( this, SIGNAL(accepted()), SLOT(updateTextAnnotation()) );
connect( this, SIGNAL(accepted()), SLOT(updatePlacemarkAltitude()) );
connect( this, SIGNAL(finished(int)), SLOT(restoreInitial(int)) );
// Ensure that the dialog gets deleted when closing it (either when clicking OK or
// Close).
connect( this, SIGNAL(finished(int)), SLOT(deleteLater()) );
}
void ViewportParams::resetFocusPoint()
{
d->m_focusPoint = GeoDataCoordinates();
}
void OsmNode::parseCoordinates(const QXmlStreamAttributes &attributes)
{
qreal const lon = attributes.value( "lon" ).toDouble();
qreal const lat = attributes.value( "lat" ).toDouble();
m_coordinates = GeoDataCoordinates(lon, lat, 0, GeoDataCoordinates::Degree);
}
void RoutingInputWidget::setInvalid()
{
d->m_route->setPosition( d->m_index, GeoDataCoordinates() );
emit targetValidityChanged( false );
}