• Skip to content
  • Skip to link menu
KDE API Reference
  • KDE API Reference
  • kdeedu API Reference
  • KDE Home
  • Contact Us
 

marble

  • kde-4.x
  • kdeedu
  • marble
  • src
  • lib
  • marble
  • declarative
Routing.cpp
Go to the documentation of this file.
1 //
2 // This file is part of the Marble Virtual Globe.
3 //
4 // This program is free software licensed under the GNU LGPL. You can
5 // find a copy of this license in LICENSE.txt in the top directory of
6 // the source code.
7 //
8 // Copyright 2011 Dennis Nienhüser <[email protected]>
9 //
10 
11 #include "Routing.h"
12 
13 #include <MarbleMap.h>
14 #include <MarbleModel.h>
15 #include "MarbleDirs.h"
16 #include "routing/AlternativeRoutesModel.h"
17 #include "routing/RoutingManager.h"
18 #include "routing/RouteRequest.h"
19 #include "routing/RoutingProfilesModel.h"
20 #include <GeoDataLatLonAltBox.h>
21 #include <GeoPainter.h>
22 #include <routing/Route.h>
23 #include <declarative/RouteRequestModel.h>
24 #include <ViewportParams.h>
25 #include <PositionTracking.h>
26 
27 #include <QDebug>
28 #include <QQmlContext>
29 #include <QOpenGLPaintDevice>
30 #include <QSGGeometryNode>
31 #include <QSGFlatColorMaterial>
32 
33 namespace Marble {
34 
35 class RoutingPrivate
36 {
37 public:
38  explicit RoutingPrivate(QObject * parent = nullptr);
39 
40  MarbleMap* m_marbleMap;
41  QMap<QString, Marble::RoutingProfile> m_profiles;
42  QString m_routingProfile;
43  QQmlComponent * m_waypointDelegate;
44  QMap<int,QQuickItem*> m_waypointItems;
45  RouteRequestModel* m_routeRequestModel;
46  QObject * m_parent;
47  QVector<Placemark *> m_searchResultPlacemarks;
48  QMap<int, QQuickItem*> m_searchResultItems;
49 };
50 
51 RoutingPrivate::RoutingPrivate(QObject *parent) :
52  m_marbleMap( nullptr ),
53  m_waypointDelegate( nullptr ),
54  m_routeRequestModel( new RouteRequestModel(parent) ),
55  m_parent( parent )
56 {
57  // nothing to do
58 }
59 
60 Routing::Routing( QQuickItem *parent) :
61  QQuickItem( parent ), d( new RoutingPrivate(this) )
62 {
63  setFlag(ItemHasContents, true);
64  d->m_routeRequestModel->setRouting(this);
65  connect(d->m_routeRequestModel, SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(updateWaypointItems()));
66  connect(d->m_routeRequestModel, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)), this, SLOT(updateWaypointItems()));
67  connect(d->m_routeRequestModel, SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SLOT(updateWaypointItems()));
68 
69  emit routeRequestModelChanged(d->m_routeRequestModel);
70 }
71 
72 Routing::~Routing()
73 {
74  delete d;
75 }
76 
77 QSGNode * Routing::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *) {
78  if (!d->m_marbleMap) {
79  return nullptr;
80  }
81 
82  QOpenGLPaintDevice paintDevice(QSize(width(), height()));
83  Marble::GeoPainter geoPainter(&paintDevice, d->m_marbleMap->viewport(), d->m_marbleMap->mapQuality());
84 
85  RoutingManager const * const routingManager = d->m_marbleMap->model()->routingManager();
86  GeoDataLineString const & waypoints = routingManager->routingModel()->route().path();
87 
88  if (waypoints.isEmpty()) {
89  return nullptr;
90  }
91 
92  int const dpi = qMax(paintDevice.logicalDpiX(), paintDevice.logicalDpiY());
93  qreal const halfWidth = 0.5 * 2.5 * MM2M * M2IN * dpi;
94 
95  QColor standardRouteColor = routingManager->state() == RoutingManager::Downloading ?
96  routingManager->routeColorStandard() :
97  routingManager->routeColorStandard().darker( 200 );
98 
99  QVector<QPolygonF*> polygons;
100  geoPainter.polygonsFromLineString( waypoints, polygons);
101 
102  if (!polygons.isEmpty()) {
103  delete oldNode;
104  oldNode = new QSGNode;
105  for(const QPolygonF* itPolygon: polygons) {
106  QPolygonF const & polygon = *itPolygon;
107  QVector<QVector2D> normals;
108  int segmentCount = itPolygon->size() - 1;
109  normals.reserve(segmentCount);
110  for(int i = 0; i < segmentCount; ++i) {
111  normals << QVector2D(polygon[i+1] - polygon[i]).normalized();
112  }
113  QSGGeometryNode* lineNode = new QSGGeometryNode;
114 
115  QSGGeometry * lineNodeGeo = new QSGGeometry(QSGGeometry::defaultAttributes_Point2D(), segmentCount*4);
116  lineNodeGeo->setDrawingMode(GL_TRIANGLE_STRIP);
117  lineNodeGeo->allocate(segmentCount*4);
118 
119  QSGFlatColorMaterial *material = new QSGFlatColorMaterial;
120  material->setColor(standardRouteColor);
121 
122  lineNode->setGeometry(lineNodeGeo);
123  lineNode->setFlag(QSGNode::OwnsGeometry);
124  lineNode->setMaterial(material);
125  lineNode->setFlag(QSGNode::OwnsMaterial);
126 
127  auto points = lineNodeGeo->vertexDataAsPoint2D();
128  int k = -1;
129  for(int i = 0; i < segmentCount; ++i) {
130  auto const & a = polygon[i];
131  auto const & b = polygon[i+1];
132  auto const & n = normals[i];
133  points[++k].set(a.x() - halfWidth * n.y(), a.y() + halfWidth * n.x());
134  points[++k].set(a.x() + halfWidth * n.y(), a.y() - halfWidth * n.x());
135  points[++k].set(b.x() - halfWidth * n.y(), b.y() + halfWidth * n.x());
136  points[++k].set(b.x() + halfWidth * n.y(), b.y() - halfWidth * n.x());
137  }
138 
139  oldNode->appendChildNode(lineNode);
140  }
141  } else {
142  if (oldNode && oldNode->childCount() > 0) {
143  delete oldNode;
144  oldNode = new QSGNode;
145  }
146  }
147 
148  qDeleteAll(polygons);
149  return oldNode;
150 }
151 
152 QObject* Routing::waypointModel()
153 {
154  return d->m_marbleMap ? d->m_marbleMap->model()->routingManager()->routingModel() : nullptr;
155 }
156 
157 void Routing::setWaypointDelegate(QQmlComponent *waypointDelegate)
158 {
159  if (d->m_waypointDelegate == waypointDelegate) {
160  return;
161  }
162 
163  d->m_waypointDelegate = waypointDelegate;
164  emit waypointDelegateChanged(waypointDelegate);
165 }
166 
167 void Routing::updateWaypointItems()
168 {
169  if ( d->m_marbleMap && d->m_routeRequestModel ) {
170  for (int i = d->m_waypointItems.keys().size(); i < d->m_routeRequestModel->rowCount(); i++ ) {
171  QQmlContext * context = new QQmlContext( qmlContext( d->m_waypointDelegate ) );
172  QObject * component = d->m_waypointDelegate->create(context);
173  QQuickItem* item = qobject_cast<QQuickItem*>( component );
174  if ( item ) {
175  item->setParentItem( this );
176  item->setProperty("index", i);
177  d->m_waypointItems[i] = item;
178  } else {
179  delete component;
180  }
181  }
182 
183  for (int i = d->m_waypointItems.keys().size()-1; i >= d->m_routeRequestModel->rowCount(); i--) {
184  QQuickItem* item = d->m_waypointItems[i];
185  item->setProperty("visible", QVariant(false) );
186  d->m_waypointItems.erase(d->m_waypointItems.find(i));
187  item->deleteLater();
188  }
189 
190  QMap<int, QQuickItem*>::iterator iter = d->m_waypointItems.begin();
191  while ( iter != d->m_waypointItems.end() ) {
192  qreal x = 0;
193  qreal y = 0;
194  const qreal lon = d->m_routeRequestModel->data(d->m_routeRequestModel->index( iter.key() ), RouteRequestModel::LongitudeRole).toFloat();
195  const qreal lat = d->m_routeRequestModel->data(d->m_routeRequestModel->index( iter.key() ), RouteRequestModel::LatitudeRole).toFloat();
196  const bool visible = d->m_marbleMap->viewport()->screenCoordinates(lon * DEG2RAD, lat * DEG2RAD, x, y);
197 
198  QQuickItem * item = iter.value();
199  if ( item ) {
200  item->setVisible( visible );
201  if ( visible ) {
202  item->setProperty("xPos", QVariant(x));
203  item->setProperty("yPos", QVariant(y));
204  if (iter.key() == 0 && waypointCount() == 1) {
205  item->setProperty("type", QVariant(QStringLiteral("departure")));
206  }
207  else if (iter.key() == d->m_waypointItems.keys().size()-1) {
208  item->setProperty("type", QVariant(QStringLiteral("destination")));
209  }
210  else if (iter.key() > 0) {
211  item->setProperty("type", QVariant(QStringLiteral("waypoint")));
212  }
213  else {
214  item->setProperty("type", QVariant(QStringLiteral("departure")));
215  }
216  }
217  }
218  ++iter;
219  }
220  }
221 }
222 
223 int Routing::addSearchResultPlacemark(Placemark *placemark)
224 {
225  if ( d->m_marbleMap ) {
226  for (int i = 0; i < d->m_searchResultItems.size(); i++) {
227  if (d->m_searchResultPlacemarks[i]->placemark().coordinate() == placemark->placemark().coordinate()) {
228  return i;
229  }
230  }
231  Placemark * newPlacemark = new Placemark(this);
232  newPlacemark->setGeoDataPlacemark(placemark->placemark());
233  d->m_searchResultPlacemarks.push_back(newPlacemark);
234  }
235 
236  updateSearchResultPlacemarks();
237  return d->m_searchResultPlacemarks.size()-1;
238 }
239 
240 void Routing::clearSearchResultPlacemarks()
241 {
242  for(Placemark* placemark: d->m_searchResultPlacemarks) {
243  placemark->deleteLater();
244  }
245  d->m_searchResultPlacemarks.clear();
246 
247  for(QQuickItem* item: d->m_searchResultItems) {
248  item->deleteLater();
249  }
250  d->m_searchResultItems.clear();
251 }
252 
253 void Routing::updateSearchResultPlacemarks()
254 {
255  for (int i = d->m_searchResultItems.keys().size(); i < d->m_searchResultPlacemarks.size(); i++ ) {
256  QQmlContext * context = new QQmlContext( qmlContext( d->m_waypointDelegate ) );
257  QObject * component = d->m_waypointDelegate->create(context);
258  QQuickItem* item = qobject_cast<QQuickItem*>( component );
259  if ( item ) {
260  item->setParentItem( this );
261  item->setProperty("index", i);
262  item->setProperty("type", QVariant(QStringLiteral("searchResult")));
263  item->setProperty("placemark", QVariant::fromValue(d->m_searchResultPlacemarks[i]));
264  d->m_searchResultItems[i] = item;
265  } else {
266  delete component;
267  }
268  }
269 
270  for (int i = d->m_searchResultItems.keys().size()-1; i >= d->m_searchResultPlacemarks.size(); i--) {
271  QQuickItem* item = d->m_searchResultItems[i];
272  item->setProperty("visible", QVariant(false) );
273  d->m_searchResultItems.erase(d->m_searchResultItems.find(i));
274  item->deleteLater();
275  }
276 
277  for (int i = 0; i < d->m_searchResultItems.keys().size() && i < d->m_searchResultPlacemarks.size(); i++) {
278  qreal x = 0;
279  qreal y = 0;
280  const qreal lon = d->m_searchResultPlacemarks[i]->placemark().coordinate().longitude();
281  const qreal lat = d->m_searchResultPlacemarks[i]->placemark().coordinate().latitude();
282  const bool visible = d->m_marbleMap->viewport()->screenCoordinates(lon, lat, x, y);
283 
284  QQuickItem * item = d->m_searchResultItems[i];
285  if ( item ) {
286  item->setVisible( visible );
287  if ( visible ) {
288  item->setProperty("xPos", QVariant(x));
289  item->setProperty("yPos", QVariant(y));
290  }
291  }
292  }
293 }
294 
295 void Routing::setMarbleMap( MarbleMap* marbleMap )
296 {
297  d->m_marbleMap = marbleMap;
298 
299  if ( d->m_marbleMap ) {
300  connect(d->m_marbleMap, SIGNAL(repaintNeeded(QRegion)), this, SLOT(update()));
301  RoutingManager* routingManager = d->m_marbleMap->model()->routingManager();
302  if (routingManager->profilesModel()->rowCount() == 0) {
303  routingManager->profilesModel()->loadDefaultProfiles();
304  routingManager->readSettings();
305  }
306 
307  connect( routingManager, SIGNAL(stateChanged(RoutingManager::State)), this, SLOT(update()));
308  connect( routingManager, SIGNAL(routeRetrieved(GeoDataDocument*)), this, SLOT(update()));
309  connect( routingManager, SIGNAL(stateChanged(RoutingManager::State)),
310  this, SIGNAL(hasRouteChanged()) );
311  connect( routingModel(), SIGNAL(currentRouteChanged()),
312  this, SIGNAL(hasRouteChanged()) );
313  connect( routingManager, SIGNAL(stateChanged(RoutingManager::State)),
314  this, SIGNAL(hasWaypointsChanged()) );
315  connect( routingModel(), SIGNAL(currentRouteChanged()),
316  this, SIGNAL(hasWaypointsChanged()) );
317  connect( routingModel(), SIGNAL(currentRouteChanged()),
318  this, SLOT(update()) );
319  connect( d->m_marbleMap, SIGNAL(visibleLatLonAltBoxChanged(GeoDataLatLonAltBox)),
320  this, SLOT(updateWaypointItems()) );
321  connect( d->m_marbleMap, SIGNAL(visibleLatLonAltBoxChanged(GeoDataLatLonAltBox)),
322  this, SLOT(updateSearchResultPlacemarks()) );
323 
324  emit routingModelChanged();
325 
326  QList<Marble::RoutingProfile> profiles = routingManager->profilesModel()->profiles();
327  if ( profiles.size() == 4 ) {
329  d->m_profiles[QStringLiteral("Motorcar")] = profiles.at( 0 );
330  d->m_profiles[QStringLiteral("Bicycle")] = profiles.at( 2 );
331  d->m_profiles[QStringLiteral("Pedestrian")] = profiles.at( 3 );
332  } else {
333  qDebug() << "Unexpected size of default routing profiles: " << profiles.size();
334  }
335  }
336 
337  emit marbleMapChanged();
338  emit routingProfileChanged();
339  emit hasRouteChanged();
340  emit hasWaypointsChanged();
341 }
342 
343 MarbleMap *Routing::marbleMap()
344 {
345  return d->m_marbleMap;
346 }
347 
348 QString Routing::routingProfile() const
349 {
350  return d->m_routingProfile;
351 }
352 
353 void Routing::setRoutingProfile( const QString & profile )
354 {
355  if ( d->m_routingProfile != profile ) {
356  d->m_routingProfile = profile;
357  if ( d->m_marbleMap ) {
358  d->m_marbleMap->model()->routingManager()->routeRequest()->setRoutingProfile( d->m_profiles[profile] );
359  }
360  emit routingProfileChanged();
361  }
362 }
363 
364 bool Routing::hasRoute() const
365 {
366  return d->m_marbleMap && !d->m_marbleMap->model()->routingManager()->routingModel()->route().path().isEmpty();
367 }
368 
369 bool Routing::hasWaypoints() const
370 {
371  return d->m_marbleMap && d->m_marbleMap->model()->routingManager()->routingModel()->rowCount() > 0;
372 }
373 
374 RoutingModel *Routing::routingModel()
375 {
376  return d->m_marbleMap == nullptr ? nullptr : d->m_marbleMap->model()->routingManager()->routingModel();
377 }
378 
379 QQmlComponent *Routing::waypointDelegate() const
380 {
381  return d->m_waypointDelegate;
382 }
383 
384 int Routing::waypointCount() const
385 {
386  return d->m_routeRequestModel ? d->m_routeRequestModel->rowCount() : 0;
387 }
388 
389 RouteRequestModel *Routing::routeRequestModel()
390 {
391  return d->m_routeRequestModel;
392 }
393 
394 void Routing::addVia( qreal lon, qreal lat )
395 {
396  if ( d->m_marbleMap ) {
397  Marble::RouteRequest* request = d->m_marbleMap->model()->routingManager()->routeRequest();
398  request->addVia( Marble::GeoDataCoordinates( lon, lat, 0.0, Marble::GeoDataCoordinates::Degree ) );
399  updateRoute();
400  }
401 }
402 
403 void Routing::addViaAtIndex(int index, qreal lon, qreal lat)
404 {
405  if ( d->m_marbleMap ) {
406  Marble::RouteRequest * request = d->m_marbleMap->model()->routingManager()->routeRequest();
407  request->insert(index, Marble::GeoDataCoordinates( lon, lat, 0.0, Marble::GeoDataCoordinates::Degree) );
408  updateRoute();
409  }
410 }
411 
412 void Routing::addViaByPlacemark(Placemark *placemark)
413 {
414  if (d->m_marbleMap && placemark) {
415  Marble::RouteRequest * request = d->m_marbleMap->model()->routingManager()->routeRequest();
416  request->addVia(placemark->placemark());
417  updateRoute();
418  }
419 }
420 
421 void Routing::addViaByPlacemarkAtIndex(int index, Placemark *placemark)
422 {
423  if (d->m_marbleMap && placemark) {
424  Marble::RouteRequest * request = d->m_marbleMap->model()->routingManager()->routeRequest();
425  request->insert(index, placemark->placemark());
426  updateRoute();
427  }
428 }
429 
430 void Routing::setVia( int index, qreal lon, qreal lat )
431 {
432  if ( index < 0 || index > 200 || !d->m_marbleMap ) {
433  return;
434  }
435 
436  Marble::RouteRequest* request = d->m_marbleMap->model()->routingManager()->routeRequest();
437  Q_ASSERT( request );
438  if ( index < request->size() ) {
439  request->setPosition( index, Marble::GeoDataCoordinates( lon, lat, 0.0, Marble::GeoDataCoordinates::Degree ) );
440  } else {
441  for ( int i=request->size(); i<index; ++i ) {
442  request->append( Marble::GeoDataCoordinates( 0.0, 0.0 ) );
443  }
444  request->append( Marble::GeoDataCoordinates( lon, lat, 0.0, Marble::GeoDataCoordinates::Degree ) );
445  }
446 
447  updateRoute();
448 }
449 
450 void Routing::removeVia( int index )
451 {
452  if ( index < 0 || !d->m_marbleMap ) {
453  return;
454  }
455 
456  Marble::RouteRequest* request = d->m_marbleMap->model()->routingManager()->routeRequest();
457  if ( index < request->size() ) {
458  d->m_marbleMap->model()->routingManager()->routeRequest()->remove( index );
459  }
460 
461  updateRoute();
462 }
463 
464 void Routing::swapVias(int index1, int index2)
465 {
466  if ( !d->m_marbleMap || !d->m_routeRequestModel ) {
467  return;
468  }
469 
470  Marble::RouteRequest* request = d->m_marbleMap->model()->routingManager()->routeRequest();
471  request->swap(index1, index2);
472  updateRoute();
473  updateWaypointItems();
474 }
475 
476 void Routing::reverseRoute()
477 {
478  if ( d->m_marbleMap ) {
479  d->m_marbleMap->model()->routingManager()->reverseRoute();
480  }
481 }
482 
483 void Routing::clearRoute()
484 {
485  if ( d->m_marbleMap ) {
486  d->m_marbleMap->model()->routingManager()->clearRoute();
487  }
488 }
489 
490 void Routing::updateRoute()
491 {
492  if ( d->m_marbleMap ) {
493  d->m_marbleMap->model()->routingManager()->retrieveRoute();
494  }
495 }
496 
497 void Routing::openRoute( const QString &fileName )
498 {
499  if ( d->m_marbleMap ) {
500  Marble::RoutingManager * const routingManager = d->m_marbleMap->model()->routingManager();
502  routingManager->clearRoute();
503  QString target = fileName.startsWith( QLatin1String( "file://" ) ) ? fileName.mid( 7 ) : fileName;
504  routingManager->loadRoute( target );
505  const Marble::GeoDataDocument *route = routingManager->alternativeRoutesModel()->currentRoute();
506  if ( route ) {
507  const Marble::GeoDataLineString* waypoints = Marble::AlternativeRoutesModel::waypoints( route );
508  if ( waypoints ) {
509  GeoDataCoordinates const center = waypoints->latLonAltBox().center();
510  GeoDataCoordinates::Unit const inDegree = GeoDataCoordinates::Degree;
511  d->m_marbleMap->centerOn( center.longitude(inDegree), center.latitude(inDegree) );
512  }
513  }
514  }
515 }
516 
517 void Routing::saveRoute( const QString &fileName )
518 {
519  if ( d->m_marbleMap ) {
521  QString target = fileName.startsWith( QLatin1String( "file://" ) ) ? fileName.mid( 7 ) : fileName;
522  d->m_marbleMap->model()->routingManager()->saveRoute( target );
523  }
524 }
525 
526 }
527 
528 #include "moc_Routing.cpp"
Marble::GeoDataCoordinates::Unit
Unit
enum used constructor to specify the units used
Definition: GeoDataCoordinates.h:57
Marble::RouteRequest::size
int size() const
Number of points in the route.
Definition: RouteRequest.cpp:128
QModelIndex
Marble::Routing::routingModelChanged
void routingModelChanged()
Marble::Routing::waypointModel
QObject * waypointModel()
Definition: Routing.cpp:152
Marble::GeoDataCoordinates
A 3d point representation.
Definition: GeoDataCoordinates.h:45
Marble::Routing::~Routing
~Routing() override
Definition: Routing.cpp:72
Marble::Routing::routeRequestModelChanged
void routeRequestModelChanged(RouteRequestModel *routeRequestModel)
Marble::Routing::openRoute
void openRoute(const QString &filename)
Definition: Routing.cpp:497
Marble::GeoDataDocument
A container for Features, Styles and in the future Schemas.
Definition: GeoDataDocument.h:63
Marble::Routing::waypointDelegate
QQmlComponent * waypointDelegate() const
Marble::RoutingProfilesModel::profiles
QList< RoutingProfile > profiles() const
Definition: RoutingProfilesModel.cpp:60
Marble::Routing::setWaypointDelegate
void setWaypointDelegate(QQmlComponent *waypointDelegate)
Definition: Routing.cpp:157
Marble::Routing::addVia
void addVia(qreal lon, qreal lat)
Definition: Routing.cpp:394
Marble::Placemark
Wraps a GeoDataPlacemark for QML access.
Definition: Placemark.h:26
Marble::MM2M
const qreal MM2M
Definition: MarbleGlobal.h:215
Marble::Routing::setRoutingProfile
void setRoutingProfile(const QString &profile)
Definition: Routing.cpp:353
Marble::GeoPainter
A painter that allows to draw geometric primitives on the map.
Definition: GeoPainter.h:93
MarbleModel.h
This file contains the headers for MarbleModel.
QList::at
const T & at(int i) const
QMap
Marble::RouteRequest::insert
void insert(int index, const GeoDataCoordinates &coordinates, const QString &name=QString())
Add the given element at the given position.
Definition: RouteRequest.cpp:211
Marble::Routing::reverseRoute
void reverseRoute()
Definition: Routing.cpp:476
Marble::RoutingProfilesModel::rowCount
int rowCount(const QModelIndex &parent=QModelIndex()) const override
Definition: RoutingProfilesModel.cpp:35
Marble::Routing::marbleMap
MarbleMap * marbleMap()
Marble::RouteRequest::append
void append(const GeoDataCoordinates &coordinates, const QString &name=QString())
Add the given element to the end.
Definition: RouteRequest.cpp:237
Marble::GeoDataLineString::latLonAltBox
const GeoDataLatLonAltBox & latLonAltBox() const override
Returns the smallest latLonAltBox that contains the LineString.
Definition: GeoDataLineString.cpp:806
Marble::Placemark::placemark
Marble::GeoDataPlacemark & placemark()
Definition: Placemark.cpp:57
Route.h
Marble::GeoDataCoordinates::Degree
Definition: GeoDataCoordinates.h:59
Marble::Routing::clearSearchResultPlacemarks
void clearSearchResultPlacemarks()
Definition: Routing.cpp:240
QList::size
int size() const
Marble::RoutingManager::profilesModel
RoutingProfilesModel * profilesModel()
Provides access to the model which contains all possible routing profiles.
Definition: RoutingManager.cpp:282
Marble::Routing::hasWaypoints
bool hasWaypoints() const
RouteRequestModel
Definition: RouteRequestModel.h:21
RouteRequestModel::LongitudeRole
Definition: RouteRequestModel.h:30
Marble::RouteRequest
Points to be included in a route.
Definition: RouteRequest.h:31
MarbleMap.h
This file contains the headers for MarbleMap.
RoutingManager.h
Routing.h
Marble::Routing::clearRoute
void clearRoute()
Definition: Routing.cpp:483
Marble::Routing::addViaByPlacemarkAtIndex
void addViaByPlacemarkAtIndex(int index, Placemark *placemark)
Definition: Routing.cpp:421
Marble::Routing::setVia
void setVia(int index, qreal lon, qreal lat)
Definition: Routing.cpp:430
QObject
Marble::Routing::hasRouteChanged
void hasRouteChanged()
Marble::GeoDataLatLonAltBox::center
GeoDataCoordinates center() const override
returns the center of this box
Definition: GeoDataLatLonAltBox.cpp:148
RouteRequestModel.h
MarbleDirs.h
Marble::RoutingManager::clearRoute
void clearRoute()
Clear all via points.
Definition: RoutingManager.cpp:580
QString::startsWith
bool startsWith(const QString &s, Qt::CaseSensitivity cs) const
Marble::Routing::addSearchResultPlacemark
int addSearchResultPlacemark(Placemark *placemark)
Definition: Routing.cpp:223
Marble::RoutingManager::readSettings
void readSettings()
Restores a previously saved route request and route from disk, if any.
Definition: RoutingManager.cpp:501
Marble::Routing::hasWaypointsChanged
void hasWaypointsChanged()
Marble::Routing::routingProfileChanged
void routingProfileChanged()
QObject::deleteLater
void deleteLater()
QString
QList< Marble::RoutingProfile >
QColor
GeoPainter.h
Marble::DEG2RAD
const qreal DEG2RAD
Definition: MarbleGlobal.h:222
Marble::Placemark::setGeoDataPlacemark
void setGeoDataPlacemark(const Marble::GeoDataPlacemark &placemark)
Definition: Placemark.cpp:31
Marble::GeoDataLineString
A LineString that allows to store a contiguous set of line segments.
Definition: GeoDataLineString.h:72
Marble::Routing::hasRoute
bool hasRoute() const
Marble::Routing::setMarbleMap
void setMarbleMap(MarbleMap *marbleMap)
Definition: Routing.cpp:295
Marble::MarbleMap
A class that can paint a view of the earth.
Definition: MarbleMap.h:89
Marble::Routing::swapVias
void swapVias(int index1, int index2)
Definition: Routing.cpp:464
Marble::RoutingProfilesModel::loadDefaultProfiles
void loadDefaultProfiles()
Definition: RoutingProfilesModel.cpp:126
Marble::RoutingManager
Delegates data retrieval and model updates to the appropriate routing provider.
Definition: RoutingManager.h:32
QVector::reserve
void reserve(int size)
QSize
Marble::Routing::waypointCount
Q_INVOKABLE int waypointCount() const
Definition: Routing.cpp:384
Marble::Routing::addViaAtIndex
void addViaAtIndex(int index, qreal lon, qreal lat)
Definition: Routing.cpp:403
ViewportParams.h
This file contains the headers for ViewportParams.
QVariant::fromValue
QVariant fromValue(const T &value)
Marble::Routing::marbleMapChanged
void marbleMapChanged()
Marble::GeoDataPlacemark::coordinate
GeoDataCoordinates coordinate(const QDateTime &dateTime=QDateTime(), bool *iconAtCoordinates=nullptr) const
Return the coordinates of the placemark at time dateTime as a GeoDataCoordinates. ...
Definition: GeoDataPlacemark.cpp:220
QMap::key
const Key key(const T &value) const
Marble::Routing::saveRoute
void saveRoute(const QString &filename)
Definition: Routing.cpp:517
Marble::RoutingManager::State
State
Definition: RoutingManager.h:39
QString::mid
QString mid(int position, int n) const
Marble::Routing::routingModel
RoutingModel * routingModel()
QVector
Marble::GeoDataLineString::isEmpty
bool isEmpty() const
Returns whether the LineString has no nodes at all.
Definition: GeoDataLineString.cpp:258
QLatin1String
QVector::isEmpty
bool isEmpty() const
QVector2D
GeoDataLatLonAltBox.h
Marble::RouteRequest::swap
void swap(int index1, int index2)
Swaps the given elements at the given positions.
Definition: RouteRequest.cpp:225
Marble::Routing::updateRoute
void updateRoute()
Definition: Routing.cpp:490
Marble::Routing::routeRequestModel
RouteRequestModel * routeRequestModel()
Marble::RoutingManager::loadRoute
void loadRoute(const QString &filename)
Opens the given filename (kml format) and loads the route contained in it.
Definition: RoutingManager.cpp:465
Marble::M2IN
const qreal M2IN
Definition: MarbleGlobal.h:203
Marble::Routing::addViaByPlacemark
void addViaByPlacemark(Placemark *placemark)
Definition: Routing.cpp:412
Marble::Routing::updatePaintNode
QSGNode * updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *) override
Definition: Routing.cpp:77
AlternativeRoutesModel.h
Marble::Routing::removeVia
void removeVia(int index)
Definition: Routing.cpp:450
QQuickItem
Marble::Routing::waypointDelegateChanged
void waypointDelegateChanged(QQmlComponent *waypointDelegate)
RouteRequest.h
QVector2D::normalized
QVector2D normalized() const
Marble::GeoDataCoordinates::longitude
qreal longitude(GeoDataCoordinates::Unit unit) const
retrieves the longitude of the GeoDataCoordinates object use the unit parameter to switch between Rad...
Definition: GeoDataCoordinates.cpp:204
Marble::RoutingManager::Downloading
Definition: RoutingManager.h:40
Marble::RouteRequest::setPosition
void setPosition(int index, const GeoDataCoordinates &position, const QString &name=QString())
Change the value of the element at the given position.
Definition: RouteRequest.cpp:273
Marble::RouteRequest::addVia
void addVia(const GeoDataCoordinates &position)
Insert a via point.
Definition: RouteRequest.cpp:259
PositionTracking.h
Marble::GeoDataCoordinates::latitude
qreal latitude(GeoDataCoordinates::Unit unit) const
retrieves the latitude of the GeoDataCoordinates object use the unit parameter to switch between Radi...
Definition: GeoDataCoordinates.cpp:221
QVector::size
int size() const
Marble::Routing::routingProfile
QString routingProfile() const
Marble::GeoDataLatLonAltBox
A class that defines a 3D bounding box for geographic data.
Definition: GeoDataLatLonAltBox.h:47
RoutingProfilesModel.h
QRegion
RouteRequestModel::LatitudeRole
Definition: RouteRequestModel.h:31
Marble::RoutingManager::alternativeRoutesModel
AlternativeRoutesModel * alternativeRoutesModel()
Provides access to the model which contains a list of alternative routes.
Definition: RoutingManager.cpp:450
QMap::value
const T value(const Key &key) const
QVariant
QPolygonF
This file is part of the KDE documentation.
Documentation copyright © 1996-2019 The KDE developers.
Generated on Thu Dec 12 2019 01:47:24 by doxygen 1.8.7 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

marble

Skip menu "marble"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Related Pages

kdeedu API Reference

Skip menu "kdeedu API Reference"
  • Analitza
  •     lib
  • kalgebra
  • kalzium
  •   libscience
  • kanagram
  • kig
  •   lib
  • klettres
  •   KmPlot
  • libkeduvocdocument
  •   keduvocdocument
  • marble
  • parley
  • rocs
  •   src
  •   stepcore

Search



Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal