Marble

MarbleMap.h
Go to the documentation of this file.
1 // SPDX-License-Identifier: LGPL-2.1-or-later
2 //
3 // SPDX-FileCopyrightText: 2006-2008 Torsten Rahn <[email protected]>
4 // SPDX-FileCopyrightText: 2007 Inge Wallin <[email protected]>
5 // SPDX-FileCopyrightText: 2009 Jens-Michael Hoffmann <[email protected]>
6 //
7 
8 #ifndef MARBLE_MARBLEMAP_H
9 #define MARBLE_MARBLEMAP_H
10 
11 
12 /** @file
13  * This file contains the headers for MarbleMap.
14  *
15  * @author Torsten Rahn <[email protected]>
16  * @author Inge Wallin <[email protected]>
17  */
18 
19 
20 #include "marble_export.h"
21 #include "GeoDataCoordinates.h" // In geodata/data/
22 #include "GeoDataRelation.h"
23 
24 // Qt
25 #include <QObject>
26 #include <QRegion>
27 
28 class QFont;
29 class QString;
30 
31 namespace Marble
32 {
33 
34 // MarbleMap
35 class MarbleMapPrivate;
36 
37 // Marble
38 class GeoDataLatLonAltBox;
39 class GeoDataFeature;
40 class MarbleModel;
41 class ViewportParams;
42 class GeoPainter;
43 class LayerInterface;
44 class RenderPlugin;
45 class RenderState;
46 class AbstractDataPlugin;
47 class AbstractDataPluginItem;
48 class AbstractFloatItem;
49 class TextureLayer;
50 class VectorTileLayer;
51 class TileCoordsPyramid;
52 class GeoSceneTextureTileDataset;
53 class StyleBuilder;
54 
55 /**
56  * @short A class that can paint a view of the earth.
57  *
58  * FIXME: Change this description when we are done.
59  *
60  * This class can paint a view of the earth or any other globe,
61  * depending on which dataset is used. It can be used to show the
62  * globe in a widget like MarbleWidget does, or on any other
63  * QPaintDevice.
64  *
65  * The projection and other view parameters that control how MarbleMap
66  * paints the map is given through the class ViewParams. If the
67  * programmer wants to allow the user to control the map, he/she has
68  * to provide a way for the user to interact with it. An example of
69  * this can be seen in the class MarbleWidgetInputHandler, that lets
70  * the user control a MarbleWidget that uses MarbleMap internally.
71  *
72  * The MarbleMap needs to be provided with a data model to
73  * work. This model is contained in the MarbleModel class. The widget
74  * can also construct its own model if none is given to the
75  * constructor. This data model contains 3 separate datatypes:
76  * <b>tiles</b> which provide the background, <b>vectors</b> which
77  * provide things like country borders and coastlines and
78  * <b>placemarks</b> which can show points of interest, such as
79  * cities, mountain tops or the poles.
80  *
81  * @see MarbleWidget
82  * @see MarbleModel
83  */
84 
85 class MARBLE_EXPORT MarbleMap : public QObject
86 {
87  Q_OBJECT
88  Q_CLASSINFO("D-Bus Interface", "org.kde.MarbleMap")
89 
90  public:
91 
92  friend class MarbleWidget;
93 
94  /**
95  * @brief Construct a new MarbleMap.
96  *
97  * This constructor should be used when you will only use one
98  * MarbleMap. The widget will create its own MarbleModel when
99  * created.
100  */
101  MarbleMap();
102 
103  /**
104  * @brief Construct a new MarbleMap.
105  * @param model the data model for the widget.
106  *
107  * This constructor should be used when you plan to use more than
108  * one MarbleMap for the same MarbleModel (not yet supported,
109  * but will be soon).
110  */
111  explicit MarbleMap( MarbleModel *model );
112 
113  ~MarbleMap() override;
114 
115  /**
116  * @brief Return the model that this view shows.
117  */
118  MarbleModel *model() const;
119 
120  // Accessors to internal objects;
121  ViewportParams *viewport();
122  const ViewportParams *viewport() const;
123 
124  /**
125  * @brief Get the Projection used for the map
126  * @return @c Spherical a Globe
127  * @return @c Equirectangular a flat map
128  * @return @c Mercator another flat map
129  */
130  Projection projection() const;
131 
132  /**
133  * @brief Get the ID of the current map theme
134  * To ensure that a unique identifier is being used the theme does NOT
135  * get represented by its name but the by relative location of the file
136  * that specifies the theme:
137  *
138  * Example:
139  * maptheme = "earth/bluemarble/bluemarble.dgml"
140  */
141  QString mapThemeId() const;
142 
143  void setMapQualityForViewContext( MapQuality qualityForViewContext, ViewContext viewContext );
144  MapQuality mapQuality( ViewContext viewContext ) const;
145 
146  /**
147  * @brief Return the current map quality.
148  */
149  MapQuality mapQuality() const;
150 
151  void setViewContext( ViewContext viewContext );
152  ViewContext viewContext() const;
153 
154  void setSize( int width, int height );
155  void setSize( const QSize& size );
156  QSize size() const;
157  int width() const;
158  int height() const;
159 
160  /**
161  * @brief Return the radius of the globe in pixels.
162  */
163  int radius() const;
164 
165  int preferredRadiusCeil(int radius) const;
166  int preferredRadiusFloor(int radius) const;
167 
168  int tileZoomLevel() const;
169 
170  /**
171  * @brief return the minimum zoom value for the current map theme.
172  */
173  int minimumZoom() const;
174 
175  /**
176  * @brief return the minimum zoom value for the current map theme.
177  */
178  int maximumZoom() const;
179 
180  bool discreteZoom() const;
181 
182  /**
183  * @brief Get the screen coordinates corresponding to geographical coordinates in the map.
184  * @param lon the lon coordinate of the requested pixel position
185  * @param lat the lat coordinate of the requested pixel position
186  * @param x the x coordinate of the pixel is returned through this parameter
187  * @param y the y coordinate of the pixel is returned through this parameter
188  * @return @c true if the geographical coordinates are visible on the screen
189  * @c false if the geographical coordinates are not visible on the screen
190  */
191  bool screenCoordinates( qreal lon, qreal lat,
192  qreal& x, qreal& y ) const;
193 
194  /**
195  * @brief Get the earth coordinates corresponding to a pixel in the map.
196  * @param x the x coordinate of the pixel
197  * @param y the y coordinate of the pixel
198  * @param lon the longitude angle is returned through this parameter
199  * @param lat the latitude angle is returned through this parameter
200  * @param unit the angle units
201  * @return @c true if the pixel (x, y) is within the globe
202  * @c false if the pixel (x, y) is outside the globe, i.e. in space.
203  */
204  bool geoCoordinates( int x, int y,
205  qreal& lon, qreal& lat,
206  GeoDataCoordinates::Unit = GeoDataCoordinates::Degree ) const;
207 
208  /**
209  * @brief Return the longitude of the center point.
210  * @return The longitude of the center point in degree.
211  */
212  qreal centerLongitude() const;
213 
214  /**
215  * @brief Return the latitude of the center point.
216  * @return The latitude of the center point in degree.
217  */
218  qreal centerLatitude() const;
219 
220  qreal heading() const;
221 
222  /**
223  * @since 0.26.0
224  */
225  bool hasFeatureAt(const QPoint&) const;
226 
227  QVector<const GeoDataFeature *> whichFeatureAt( const QPoint& ) const;
228 
229  /**
230  * @brief Return the property value by name.
231  * @return The property value (usually: visibility).
232  */
233  bool propertyValue( const QString& name ) const;
234 
235  /**
236  * @brief Return whether the overview map is visible.
237  * @return The overview map visibility.
238  */
239  bool showOverviewMap() const;
240 
241  /**
242  * @brief Return whether the scale bar is visible.
243  * @return The scale bar visibility.
244  */
245  bool showScaleBar() const;
246 
247  /**
248  * @brief Return whether the compass bar is visible.
249  * @return The compass visibility.
250  */
251  bool showCompass() const;
252 
253  /**
254  * @brief Return whether the cloud cover is visible.
255  * @return The cloud cover visibility.
256  */
257  bool showClouds() const;
258 
259  /**
260  * @brief Return whether the night shadow is visible.
261  * @return visibility of night shadow
262  */
263  bool showSunShading() const;
264 
265  /**
266  * @brief Return whether the city lights are shown instead of the night shadow.
267  * @return visibility of city lights
268  */
269  bool showCityLights() const;
270 
271  /**
272  * @brief Return whether the globe is locked to the sub solar point
273  * @return if globe is locked to sub solar point
274  */
275  bool isLockedToSubSolarPoint() const;
276 
277  /**
278  * @brief Return whether the sun icon is shown in the sub solar point.
279  * @return visibility of the sun icon in the sub solar point
280  */
281  bool isSubSolarPointIconVisible() const;
282 
283  /**
284  * @brief Return whether the atmospheric glow is visible.
285  * @return The cloud cover visibility.
286  */
287  bool showAtmosphere() const;
288 
289  /**
290  * @brief Return whether the crosshairs are visible.
291  * @return The crosshairs' visibility.
292  */
293  bool showCrosshairs() const;
294 
295  /**
296  * @brief Return whether the coordinate grid is visible.
297  * @return The coordinate grid visibility.
298  */
299  bool showGrid() const;
300 
301  /**
302  * @brief Return whether the place marks are visible.
303  * @return The place mark visibility.
304  */
305  bool showPlaces() const;
306 
307  /**
308  * @brief Return whether the city place marks are visible.
309  * @return The city place mark visibility.
310  */
311  bool showCities() const;
312 
313  /**
314  * @brief Return whether the terrain place marks are visible.
315  * @return The terrain place mark visibility.
316  */
317  bool showTerrain() const;
318 
319  /**
320  * @brief Return whether other places are visible.
321  * @return The visibility of other places.
322  */
323  bool showOtherPlaces() const;
324 
325  /**
326  * @brief Return whether the relief is visible.
327  * @return The relief visibility.
328  */
329  bool showRelief() const;
330 
331  /**
332  * @brief Return whether the ice layer is visible.
333  * @return The ice layer visibility.
334  */
335  bool showIceLayer() const;
336 
337  /**
338  * @brief Return whether the borders are visible.
339  * @return The border visibility.
340  */
341  bool showBorders() const;
342 
343  /**
344  * @brief Return whether the rivers are visible.
345  * @return The rivers' visibility.
346  */
347  bool showRivers() const;
348 
349  /**
350  * @brief Return whether the lakes are visible.
351  * @return The lakes' visibility.
352  */
353  bool showLakes() const;
354 
355  /**
356  * @brief Return whether the frame rate gets displayed.
357  * @return the frame rates visibility
358  */
359  bool showFrameRate() const;
360 
361  bool showBackground() const;
362 
363  GeoDataRelation::RelationTypes visibleRelationTypes() const;
364 
365  /**
366  * @brief Returns the limit in kilobytes of the volatile (in RAM) tile cache.
367  * @return the limit of volatile tile cache in kilobytes.
368  */
369  quint64 volatileTileCacheLimit() const;
370 
371  /**
372  * @brief Returns a list of all RenderPlugins in the model, this includes float items
373  * @return the list of RenderPlugins
374  */
375  QList<RenderPlugin *> renderPlugins() const;
376  QList<AbstractFloatItem *> floatItems() const;
377 
378  /**
379  * @brief Returns a list of all FloatItems in the model
380  * @return the list of the floatItems
381  */
382  AbstractFloatItem * floatItem( const QString &nameId ) const;
383 
384  /**
385  * @brief Returns a list of all DataPlugins on the layer
386  * @return the list of DataPlugins
387  */
388  QList<AbstractDataPlugin *> dataPlugins() const;
389 
390  /**
391  * @brief Returns all widgets of dataPlugins on the position curpos
392  */
393  QList<AbstractDataPluginItem *> whichItemAt( const QPoint& curpos ) const;
394 
395  AngleUnit defaultAngleUnit() const;
396 
397  QFont defaultFont() const;
398 
399  TextureLayer *textureLayer() const;
400  VectorTileLayer * vectorTileLayer() const;
401 
402  /**
403  * @brief Add a layer to be included in rendering.
404  */
405  void addLayer( LayerInterface *layer );
406 
407  /**
408  * @brief Adds a texture sublayer
409  * @return Returns a key that identifies the texture sublayer
410  */
411  QString addTextureLayer(GeoSceneTextureTileDataset *texture);
412 
413  /**
414  * @brief Removes a texture sublayer
415  * @param key a key that was returned from corresponding addTextureLayer
416  */
417  void removeTextureLayer(const QString &key);
418 
419  /**
420  * @brief Remove a layer from being included in rendering.
421  */
422  void removeLayer( LayerInterface *layer );
423 
424  RenderStatus renderStatus() const;
425 
426  RenderState renderState() const;
427 
428  /**
429  * @since 0.26.0
430  */
431  const StyleBuilder* styleBuilder() const;
432 
433  public Q_SLOTS:
434 
435  /**
436  * @brief Paint the map using a give painter.
437  * @param painter The painter to use.
438  * @param dirtyRect the rectangle that actually needs repainting.
439  */
440  void paint( GeoPainter &painter, const QRect &dirtyRect );
441 
442  /**
443  * @brief Set the radius of the globe in pixels.
444  * @param radius The new globe radius value in pixels.
445  */
446  void setRadius( int radius );
447 
448  void setHeading( qreal heading );
449 
450  /**
451  * @brief Rotate the view by the two angles phi and theta.
452  * @param deltaLon an angle that specifies the change in terms of longitude
453  * @param deltaLat an angle that specifies the change in terms of latitude
454  *
455  * This function rotates the view by two angles,
456  * deltaLon ("theta") and deltaLat ("phi").
457  * If we start at (0, 0), the result will be the exact equivalent
458  * of (lon, lat), otherwise the resulting angle will be the sum of
459  * the previous position and the two offsets.
460  */
461  void rotateBy(qreal deltaLon, qreal deltaLat);
462 
463  /**
464  * @brief Center the view on a geographical point
465  * @param lat an angle parallel to the latitude lines
466  * +90(N) - -90(S)
467  * @param lon an angle parallel to the longitude lines
468  * +180(W) - -180(E)
469  */
470  void centerOn( const qreal lon, const qreal lat );
471 
472  /**
473  * @brief Set the latitude for the center point
474  * @param lat the new value for the latitude in degree
475  */
476  void setCenterLatitude( qreal lat );
477 
478  /**
479  * @brief Set the longitude for the center point
480  * @param lon the new value for the longitude in degree
481  */
482  void setCenterLongitude( qreal lon );
483 
484  /**
485  * @brief Set the Projection used for the map
486  * @param projection projection type (e.g. Spherical, Equirectangular, Mercator)
487  */
488  void setProjection( Projection projection );
489 
490  /**
491  * @brief Set a new map theme
492  * @param maptheme The ID of the new maptheme. To ensure that a unique
493  * identifier is being used the theme does NOT get represented by its
494  * name but the by relative location of the file that specifies the theme:
495  *
496  * Example:
497  * maptheme = "earth/bluemarble/bluemarble.dgml"
498  */
499  void setMapThemeId( const QString& maptheme );
500 
501  /**
502  * @brief Sets the value of a map theme property
503  * @param name name of the property
504  * @param value value of the property (usually: visibility)
505  *
506  * Later on we might add a "setPropertyType and a QVariant
507  * if needed.
508  */
509  void setPropertyValue( const QString& name, bool value );
510 
511  /**
512  * @brief Set whether the overview map overlay is visible
513  * @param visible visibility of the overview map
514  */
515  void setShowOverviewMap( bool visible );
516 
517  /**
518  * @brief Set whether the scale bar overlay is visible
519  * @param visible visibility of the scale bar
520  */
521  void setShowScaleBar( bool visible );
522 
523  /**
524  * @brief Set whether the compass overlay is visible
525  * @param visible visibility of the compass
526  */
527  void setShowCompass( bool visible );
528 
529  /**
530  * @brief Set whether the cloud cover is visible
531  * @param visible visibility of the cloud cover
532  */
533  void setShowClouds( bool visible );
534 
535  /**
536  * @brief Set whether the night shadow is visible.
537  * @param visible visibility of shadow
538  */
539  void setShowSunShading( bool visible );
540 
541  /**
542  * @brief Set whether city lights instead of night shadow are visible.
543  * @param visible visibility of city lights
544  */
545  void setShowCityLights( bool visible );
546 
547  /**
548  * @brief Set the globe locked to the sub solar point
549  * @param visible if globe is locked to the sub solar point
550  */
551  void setLockToSubSolarPoint( bool visible );
552 
553  /**
554  * @brief Set whether the sun icon is shown in the sub solar point
555  * @param visible if the sun icon is shown in the sub solar point
556  */
557  void setSubSolarPointIconVisible( bool visible );
558 
559  /**
560  * @brief Set whether the is tile is visible
561  * NOTE: This is part of the transitional debug API
562  * and might be subject to changes until Marble 0.8
563  * @param visible visibility of the tile
564  */
565  void setShowTileId( bool visible );
566 
567  /**
568  * @brief Set whether the atmospheric glow is visible
569  * @param visible visibility of the atmospheric glow
570  */
571  void setShowAtmosphere( bool visible );
572 
573  /**
574  * @brief Set whether the crosshairs are visible
575  * @param visible visibility of the crosshairs
576  */
577  void setShowCrosshairs( bool visible );
578 
579  /**
580  * @brief Set whether the coordinate grid overlay is visible
581  * @param visible visibility of the coordinate grid
582  */
583  void setShowGrid( bool visible );
584 
585  /**
586  * @brief Set whether the place mark overlay is visible
587  * @param visible visibility of the place marks
588  */
589  void setShowPlaces( bool visible );
590 
591  /**
592  * @brief Set whether the city place mark overlay is visible
593  * @param visible visibility of the city place marks
594  */
595  void setShowCities( bool visible );
596 
597  /**
598  * @brief Set whether the terrain place mark overlay is visible
599  * @param visible visibility of the terrain place marks
600  */
601  void setShowTerrain( bool visible );
602 
603  /**
604  * @brief Set whether the other places overlay is visible
605  * @param visible visibility of other places
606  */
607  void setShowOtherPlaces( bool visible );
608 
609  /**
610  * @brief Set whether the relief is visible
611  * @param visible visibility of the relief
612  */
613  void setShowRelief( bool visible );
614 
615  /**
616  * @brief Set whether the ice layer is visible
617  * @param visible visibility of the ice layer
618  */
619  void setShowIceLayer( bool visible );
620 
621  /**
622  * @brief Set whether the borders visible
623  * @param visible visibility of the borders
624  */
625  void setShowBorders( bool visible );
626 
627  /**
628  * @brief Set whether the rivers are visible
629  * @param visible visibility of the rivers
630  */
631  void setShowRivers( bool visible );
632 
633  /**
634  * @brief Set whether the lakes are visible
635  * @param visible visibility of the lakes
636  */
637  void setShowLakes( bool visible );
638 
639  /**
640  * @brief Set whether the frame rate gets shown
641  * @param visible visibility of the frame rate
642  */
643  void setShowFrameRate( bool visible );
644 
645  void setShowRuntimeTrace( bool visible );
646 
647  bool showRuntimeTrace() const;
648 
649  /**
650  * @brief Set whether to enter the debug mode for
651  * polygon node drawing
652  * @param visible visibility of the node debug mode
653  */
654  void setShowDebugPolygons( bool visible);
655 
656  bool showDebugPolygons() const;
657 
658  /**
659  * @brief Set whether to enter the debug mode for
660  * visualizing batch rendering
661  * @param visible visibility of the batch rendering
662  */
663  void setShowDebugBatchRender( bool visible);
664 
665  bool showDebugBatchRender() const;
666 
667 
668  /**
669  * @brief Set whether to enter the debug mode for
670  * placemark drawing
671  * @param visible visibility of the node debug mode
672  */
673  void setShowDebugPlacemarks(bool visible);
674 
675  bool showDebugPlacemarks() const;
676 
677 
678  /**
679  * @brief Set whether to enter the debug mode for
680  * level tags
681  * @param visible visibility according to OSM level tags
682  */
683  void setLevelTagDebugModeEnabled(bool visible);
684 
685  bool levelTagDebugModeEnabled() const;
686 
687  void setDebugLevelTag(int level);
688 
689  int debugLevelTag() const;
690 
691 
692  void setShowBackground( bool visible );
693 
694  void setVisibleRelationTypes(GeoDataRelation::RelationTypes relationTypes);
695 
696  /**
697  * @brief used to notify about the position of the mouse click
698  */
699  void notifyMouseClick( int x, int y );
700 
701  void clearVolatileTileCache();
702  /**
703  * @brief Set the limit of the volatile (in RAM) tile cache.
704  * @param kiloBytes The limit in kilobytes.
705  */
706  void setVolatileTileCacheLimit( quint64 kiloBytes );
707 
708  void setDefaultAngleUnit( AngleUnit angleUnit );
709 
710  void setDefaultFont( const QFont& font );
711 
712  /**
713  * @brief Reload the currently displayed map by reloading texture tiles
714  * from the Internet. In the future this should be extended to all
715  * kinds of data which is used in the map.
716  */
717  void reload();
718 
719  void downloadRegion( QVector<TileCoordsPyramid> const & );
720 
721  void highlightRouteRelation(qint64 osmId, bool enabled);
722 
723  Q_SIGNALS:
724  void tileLevelChanged( int level );
725 
726  /**
727  * @brief Signal that the theme has changed
728  * @param theme Name of the new theme.
729  */
730  void themeChanged( const QString& theme );
731 
732  void projectionChanged( Projection );
733 
734  void radiusChanged( int radius );
735 
736  void mouseMoveGeoPosition( const QString& geoPositionString);
737 
738  void mouseClickGeoPosition( qreal lon, qreal lat, GeoDataCoordinates::Unit );
739 
740  void framesPerSecond( qreal fps );
741 
742  /**
743  * This signal is emitted when the repaint of the view was requested.
744  * If available with the @p dirtyRegion which is the region the view will change in.
745  * If dirtyRegion.isEmpty() returns true, the whole viewport has to be repainted.
746  */
747  void repaintNeeded( const QRegion& dirtyRegion = QRegion() );
748 
749  /**
750  * This signal is emitted when the visible region of the map changes. This typically happens
751  * when the user moves the map around or zooms.
752  */
753  void visibleLatLonAltBoxChanged( const GeoDataLatLonAltBox& visibleLatLonAltBox );
754 
755  /**
756  * @brief This signal is emit when the settings of a plugin changed.
757  */
758  void pluginSettingsChanged();
759 
760  /**
761  * @brief Signal that a render item has been initialized
762  */
763  void renderPluginInitialized( RenderPlugin *renderPlugin );
764 
765  /**
766  * @brief Emitted when the layer rendering status has changed
767  * @param status New render status
768  */
769  void renderStatusChanged( RenderStatus status );
770 
771  void renderStateChanged( const RenderState &state );
772 
773  void highlightedPlacemarksChanged( qreal, qreal, GeoDataCoordinates::Unit );
774 
775  void viewContextChanged(ViewContext viewContext);
776 
777  void visibleRelationTypesChanged(GeoDataRelation::RelationTypes relationTypes);
778 
779  void propertyValueChanged( const QString& name, bool value );
780 
781  protected:
782 
783  /**
784  * @brief Enables custom drawing onto the MarbleMap straight after
785  * @brief the globe and before all other layers have been rendered.
786  * @param painter
787  *
788  * @deprecated implement LayerInterface and add it using @p addLayer()
789  */
790  virtual void customPaint( GeoPainter *painter );
791 
792  private:
793  Q_PRIVATE_SLOT( d, void updateMapTheme() )
794  Q_PRIVATE_SLOT( d, void updateProperty( const QString &, bool ) )
795  Q_PRIVATE_SLOT( d, void setDocument(QString) )
796  Q_PRIVATE_SLOT( d, void updateTileLevel() )
797  Q_PRIVATE_SLOT(d, void addPlugins())
798 
799  private:
800  Q_DISABLE_COPY( MarbleMap )
801  MarbleMapPrivate * const d;
802  friend class MarbleMapPrivate;
803 
804  class CustomPaintLayer;
805  friend class CustomPaintLayer;
806 };
807 
808 }
809 
810 #endif
ViewContext
This enum is used to choose context in which map quality gets used.
Definition: MarbleGlobal.h:66
The abstract class that creates a renderable item.
Definition: RenderPlugin.h:38
A class that defines a 3D bounding box for geographic data.
A widget class that displays a view of the earth.
Definition: MarbleWidget.h:98
The abstract class for float item plugins.
A public class that controls what is visible in the viewport of a Marble map.
MapQuality
This enum is used to choose the map quality shown in the view.
Definition: MarbleGlobal.h:74
Q_SCRIPTABLE CaptureState status()
Binds a QML item to a specific geodetic location in screen coordinates.
A painter that allows to draw geometric primitives on the map.
Definition: GeoPainter.h:88
Projection
This enum is used to choose the projection shown in the view.
Definition: MarbleGlobal.h:41
A class that can paint a view of the earth.
Definition: MarbleMap.h:85
AngleUnit
This enum is used to choose the unit chosen to measure angles.
Definition: MarbleGlobal.h:57
Unit
enum used constructor to specify the units used
The data model (not based on QAbstractModel) for a MarbleWidget.
Definition: MarbleModel.h:86
Q_INVOKABLE void setProjection(uint proj)
This file is part of the KDE documentation.
Documentation copyright © 1996-2023 The KDE developers.
Generated on Thu Sep 21 2023 04:12:27 by doxygen 1.8.17 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.