- Adding easier access to float items
[marble:akssps011s-marble.git] / src / lib / MarbleMap.h
1 //
2 // This file is part of the Marble Desktop 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 2006-2008 Torsten Rahn <tackat@kde.org>
9 // Copyright 2007      Inge Wallin  <ingwa@kde.org>
10 // Copyright 2009      Jens-Michael Hoffmann <jensmh@gmx.de>
11 //
12
13 #ifndef MARBLE_MARBLEMAP_H
14 #define MARBLE_MARBLEMAP_H
15
16
17 /** @file
18  * This file contains the headers for MarbleMap.
19  *
20  * @author Torsten Rahn <tackat@kde.org>
21  * @author Inge Wallin  <inge@lysator.liu.se>
22  */
23
24
25 #include <QtCore/QSize>
26 #include <QtCore/QString>
27 #include <QtCore/QObject>
28 #include <QtGui/QFont>
29 #include <QtGui/QPixmap>
30
31 #include "marble_export.h"
32 #include "GeoDataCoordinates.h"       // In geodata/data/
33 #include "GeoDataLookAt.h"
34 #include "Quaternion.h"
35 #include "global.h"             // types needed in all of marble.
36
37 // Qt
38 class QAbstractItemModel;
39 class QModelIndex;
40 class QItemSelectionModel;
41
42 namespace Marble
43 {
44
45 // MarbleMap 
46 //class MarbleWidgetInputHandler;
47 //class MarbleWidgetPopupMenu;
48 class MarbleMapPrivate;
49
50 // Marble
51 class GeoDataLatLonAltBox;
52 class MarbleModel;
53 class ViewParams;
54 class MeasureTool;
55 class SunLocator;
56 class FileViewModel;
57 class GeoPainter;
58 class RenderPlugin;
59 class AbstractFloatItem;
60
61 /**
62  * @short A class that can paint a view of the earth.
63  *
64  * FIXME: Change this description when we are done.
65  *
66  * This class can paint a view of the earth or any other globe,
67  * depending on which dataset is used. It can be used to show the
68  * globe in a widget like MarbleWidget does, or on any other
69  * QPaintDevice.
70  *
71  * The projection and other view parameters that control how MarbleMap
72  * paints the map is given through the class ViewParams. If the
73  * programmer wants to allow the user to control the map, he/she has
74  * to provide a way for the user to interact with it.  An example of
75  * this can be seen in the class MarbleWidgetInputHandler, that lets
76  * the user control a MarbleWidget that uses MarbleMap internally.
77  *
78  * The MarbleMap needs to be provided with a data model to
79  * work. This model is contained in the MarbleModel class. The widget
80  * can also construct its own model if none is given to the
81  * constructor.  This data model contains 3 separate datatypes:
82  * <b>tiles</b> which provide the background, <b>vectors</b> which
83  * provide things like country borders and coastlines and
84  * <b>placemarks</b> which can show points of interest, such as
85  * cities, mountain tops or the poles.
86  *
87  * @see MarbleWidget
88  * @see MarbleControlBox
89  * @see MarbleModel
90  */
91
92 class MARBLE_EXPORT MarbleMap : public QObject
93 {
94     Q_OBJECT
95     Q_CLASSINFO("D-Bus Interface", "org.kde.MarbleMap")
96
97  public:
98
99     friend class MarbleWidget;
100
101     /**
102      * @brief Construct a new MarbleMap.
103      *
104      * This constructor should be used when you will only use one
105      * MarbleMap.  The widget will create its own MarbleModel when
106      * created.
107      */
108     MarbleMap();
109
110     /**
111      * @brief Construct a new MarbleMap.
112      * @param model  the data model for the widget.
113      *
114      * This constructor should be used when you plan to use more than
115      * one MarbleMap for the same MarbleModel (not yet supported,
116      * but will be soon).
117      */
118     explicit MarbleMap( MarbleModel *model );
119
120     virtual ~MarbleMap();
121
122     /**
123      * @brief Return the model that this view shows.
124      */
125     MarbleModel *model() const;
126
127     // Accessors to internal objects;
128     ViewParams *viewParams();
129     MeasureTool *measureTool();
130
131     void setSize( int width, int height );
132     void setSize( const QSize& size );
133     QSize size() const;
134     int width() const;
135     int height() const;
136
137     /**
138      * @brief  Return the radius of the globe in pixels.
139      */
140     int radius() const;
141
142     /**
143      * @brief  Set the radius of the globe in pixels.
144      * @param  radius  The new globe radius value in pixels.
145      */
146     void setRadius( int radius );
147
148     /**
149      * @brief Return the current zoom level.
150      */
151     int zoom() const;
152
153     /**
154      * @brief Return the current distance. Convenience function calling distance(radius())
155      * @see distance(qreal) radius
156      */
157     qreal distance() const;
158
159     /**
160      * @brief  Set the distance of the observer to the globe in km.
161      * @param  distance  The new distance in km.
162      */
163     void setDistance( qreal distance );
164
165     /**
166      * @brief Return the current distance string.
167      */
168     QString distanceString() 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     /**
181      * @brief return if the map needs to be updated.
182      */
183     bool needsUpdate() const;
184
185     /**
186      * @brief Mark the map as needing an update.
187      */
188     void setNeedsUpdate();
189
190     /**
191      * @brief Get the screen coordinates corresponding to geographical coordinates in the map.
192      * @param lon    the lon coordinate of the requested pixel position
193      * @param lat    the lat coordinate of the requested pixel position
194      * @param x      the x coordinate of the pixel is returned through this parameter
195      * @param y      the y coordinate of the pixel is returned through this parameter
196      * @return @c true  if the geographical coordinates are visible on the screen
197      *         @c false if the geographical coordinates are not visible on the screen
198      */
199     bool screenCoordinates( qreal lon, qreal lat,
200                             qreal& x, qreal& y );
201
202     /**
203      * @brief Get the Y coordinate of the North Pole.
204      * @return the pixel address of the geographical north pole relative to the center of the widget.
205      * This method is deprecated because it returns an unintuitive result.
206      * Use @see northPolePosition()
207      * or @see southPolePosition()
208      */
209     MARBLE_DEPRECATED(int northPoleY());
210
211     /**
212      * @brief Get the pixel position of the North Pole.
213      * @return The pixel position of the geographical north pole.
214      */
215     QPoint northPolePosition();
216
217     /**
218      * @brief Get the pixel position of the South Pole.
219      * @return The pixel position of the geographical south pole.
220      */
221     QPoint southPolePosition();
222
223     /**
224      * @brief Get the earth coordinates corresponding to a pixel in the map.
225      * @param x      the x coordinate of the pixel
226      * @param y      the y coordinate of the pixel
227      * @param lon    the longitude angle is returned through this parameter
228      * @param lat    the latitude angle is returned through this parameter
229      * @return @c true  if the pixel (x, y) is within the globe
230      *         @c false if the pixel (x, y) is outside the globe, i.e. in space.
231      */
232     bool geoCoordinates( int x, int y,
233                          qreal& lon, qreal& lat,
234                          GeoDataCoordinates::Unit = GeoDataCoordinates::Degree );
235
236     /**
237      * @brief Return the longitude of the center point.
238      * @return The longitude of the center point in degree.
239      */
240     qreal centerLongitude() const;
241
242     /**
243      * @brief Return the latitude of the center point.
244      * @return The latitude of the center point in degree.
245      */
246     qreal centerLatitude() const;
247
248     /**
249      * @brief returns the model for all the placemarks on the globe.
250      */
251     QAbstractItemModel *placemarkModel() const;
252
253     /**
254      * @brief returns the selection model for all the placemarks on the globe.
255      */
256     QItemSelectionModel *placemarkSelectionModel() const;
257
258     /**
259      * @brief  Return how much the map will move if one of the move slots are called.
260      * @return The move step.
261      */
262     qreal moveStep();
263
264     /**
265      * @brief  Add a GeoDataPlacemark file to the model.
266      * @param  filename  the filename of the file containing the Placemarks.
267      */
268     void addPlacemarkFile( const QString &filename );
269
270     /**
271      * @brief  Add GeoDataPlacemark data as string to the model.
272      * @param  data  the string containing the Placemarks.
273      * @param key  the string needed to identify the data
274      */
275     void addPlacemarkData( const QString& data, const QString& key = "data" );
276     
277     /**
278      * @brief  remove data or files from the model.
279      * @param key  either the filename or the string used to identify the data in addPlacemarkFile and addPlacemarkData
280      */
281     void removePlacemarkKey( const QString& key );
282
283     /**
284      * @brief  Return the quaternion that specifies the rotation of the globe.
285      * @return The quaternion that describes the rotation of the globe.
286      */
287     Quaternion planetAxis() const;
288
289     /**
290      * @brief  Return a QPixmap with the current contents of the map.
291      */
292     QPixmap mapScreenShot();
293
294     /**
295      * @brief  Return the property value by name.
296      * @return The property value (usually: visibility).
297      */
298     bool propertyValue( const QString& name ) const;
299
300     /**
301      * @brief  Return whether the overview map is visible.
302      * @return The overview map visibility.
303      */
304     bool showOverviewMap() const;
305
306     /**
307      * @brief  Return whether the scale bar is visible.
308      * @return The scale bar visibility.
309      */
310     bool showScaleBar() const;
311
312     /**
313      * @brief  Return whether the compass bar is visible.
314      * @return The compass visibility.
315      */
316     bool showCompass() const;
317
318     /**
319      * @brief  Return whether the cloud cover is visible.
320      * @return The cloud cover visibility.
321      */
322     bool showClouds() const;
323
324     /**
325      * @brief  Return whether the atmospheric glow is visible.
326      * @return The cloud cover visibility.
327      */
328     bool showAtmosphere() const;
329
330     /**
331      * @brief  Return whether the crosshairs are visible.
332      * @return The crosshairs' visibility.
333      */
334     bool showCrosshairs() const;
335
336     /**
337      * @brief  Return whether the coordinate grid is visible.
338      * @return The coordinate grid visibility.
339      */
340     bool showGrid() const;
341
342     /**
343      * @brief  Return whether the place marks are visible.
344      * @return The place mark visibility.
345      */
346     bool showPlaces() const;
347
348     /**
349      * @brief  Return whether the city place marks are visible.
350      * @return The city place mark visibility.
351      */
352     bool showCities() const;
353
354     /**
355      * @brief  Return whether the terrain place marks are visible.
356      * @return The terrain place mark visibility.
357      */
358     bool showTerrain() const;
359
360     /**
361      * @brief  Return whether other places are visible.
362      * @return The visibility of other places.
363      */
364     bool showOtherPlaces() const;
365
366     /**
367      * @brief  Return whether the relief is visible.
368      * @return The relief visibility.
369      */
370     bool showRelief() const;
371
372     /**
373      * @brief  Return whether the elevation model is visible.
374      * @return The elevation model visibility.
375      */
376     bool showElevationModel() const;
377
378     /**
379      * @brief  Return whether the ice layer is visible.
380      * @return The ice layer visibility.
381      */
382     bool showIceLayer() const;
383
384     /**
385      * @brief  Return whether the borders are visible.
386      * @return The border visibility.
387      */
388     bool showBorders() const;
389
390     /**
391      * @brief  Return whether the rivers are visible.
392      * @return The rivers' visibility.
393      */
394     bool showRivers() const;
395
396     /**
397      * @brief  Return whether the lakes are visible.
398      * @return The lakes' visibility.
399      */
400     bool showLakes() const;
401
402     /**
403      * @brief Return whether Gps Data is visible.
404      * @return The Gps Data's visibility.
405      */
406     bool showGps() const;
407
408     /**
409      * @brief  Return whether the frame rate gets displayed.
410      * @return the frame rates visibility
411      */
412     bool showFrameRate() const;
413
414     /**
415      * @brief  Returns the limit in kilobytes of the persistent (on hard disc) tile cache.
416      * @return the limit of persistent tile cache in kilobytes.
417      */
418     quint64 persistentTileCacheLimit() const;
419
420     /**
421      * @brief  Returns the limit in kilobytes of the volatile (in RAM) tile cache.
422      * @return the limit of volatile tile cache in kilobytes.
423      */
424     quint64 volatileTileCacheLimit() const;
425
426     /**
427      * @brief  Return the sun locator object.
428      * @return the sun locator object
429      */
430     SunLocator* sunLocator();
431
432     QList<RenderPlugin *> renderPlugins() const;
433     QList<AbstractFloatItem *> floatItems() const;
434     AbstractFloatItem * floatItem( const QString &nameId ) const;
435
436     /**
437       * @brief Move camera to the given position. This can change
438       * both the zoom value and the position
439       */
440     void flyTo( const GeoDataLookAt &lookAt );
441
442     /**
443       * @brief Return the current camera position
444       */
445     GeoDataLookAt lookAt() const;
446
447     /**
448       * @brief Return the globe radius (pixel) for the given distance (km)
449       */
450     qreal radiusFromDistance( qreal distance ) const;
451
452     /**
453       * @brief Return the distance (km) at the given globe radius (pixel)
454       */
455     qreal distanceFromRadius( qreal radius ) const;
456
457     /**
458       * Returns the zoom value (no unit) corresponding to the given camera distance (km)
459       */
460     qreal zoomFromDistance( qreal distance ) const;
461
462     /**
463       * Returns the distance (km) corresponding to the given zoom value
464       */
465     qreal distanceFromZoom( qreal zoom ) const;
466
467  public Q_SLOTS:
468
469     void updateSun();
470     void centerSun();
471
472     /**
473      * @brief Paint the map using a give painter.
474      * @param painter  The painter to use.
475      * @param dirtyRect the rectangle that actually needs repainting.
476      */
477     void paint( GeoPainter &painter, QRect &dirtyRect );
478
479     /**
480      * @brief  Zoom the view to a certain zoomlevel
481      * @param  zoom  the new zoom level.
482      *
483      * The zoom level is an abstract value without physical
484      * interpretation.  A zoom value around 1000 lets the viewer see
485      * all of the earth in the default window.
486      */
487     void zoomView( int zoom );
488
489     /**
490      * @brief  Zoom the view by a certain step
491      * @param  zoomStep  the difference between the old zoom and the new
492      */
493     void zoomViewBy( int zoomStep );
494
495     /**
496      * @brief  Zoom in by the amount zoomStep.
497      */
498     void zoomIn();
499     /**
500      * @brief  Zoom out by the amount zoomStep.
501      */
502     void zoomOut();
503
504     /**
505      * @brief  Rotate the view by the two angles phi and theta.
506      * @param  deltaLon  an angle that specifies the change in terms of longitude
507      * @param  deltaLat  an angle that specifies the change in terms of latitude
508      *
509      * This function rotates the view by two angles,
510      * deltaLon ("theta") and deltaLat ("phi").
511      * If we start at (0, 0), the result will be the exact equivalent
512      * of (lon, lat), otherwise the resulting angle will be the sum of
513      * the previous position and the two offsets.
514      */
515     void rotateBy( const qreal &deltaLon, const qreal &deltaLat );
516
517     /**
518      * @brief  Rotate the view by the angle specified by a Quaternion.
519      * @param  incRot a quaternion specifying the rotation
520      */
521     void rotateBy( const Quaternion& incRot );
522
523     /**
524      * @brief  Center the view on a geographical point
525      * @param  lat  an angle parallel to the latitude lines
526      *              +90(N) - -90(S)
527      * @param  lon  an angle parallel to the longitude lines
528      *              +180(W) - -180(E)
529      */
530     void centerOn( const qreal lon, const qreal lat );
531
532     /**
533      * @brief  Center the view on a point
534      * @param  index  an index for a QModel, indicating a city
535      */
536     void centerOn( const QModelIndex& index );
537
538     /**
539      * @brief  Set the latitude for the center point
540      * @param  lat  the new value for the latitude in degree
541      */
542     void setCenterLatitude( qreal lat );
543
544     /**
545      * @brief  Set the longitude for the center point
546      * @param  lon  the new value for the longitude in degree
547      */
548     void setCenterLongitude( qreal lon );
549
550     /**
551      * @brief  Get the Projection used for the map
552      * @return @c Spherical         a Globe
553      * @return @c Equirectangular   a flat map
554      * @return @c Mercator          another flat map
555      */
556     Projection projection() const;
557
558     /**
559      * @brief  Set the Projection used for the map
560      * @param  projection projection type (e.g. Spherical, Equirectangular, Mercator)
561      */
562     void setProjection( Projection projection );
563
564     /**
565      * @brief  get the home point
566      * @param  lon  the longitude of the home point.
567      * @param  lat  the latitude of the home point.
568      * @param  zoom the default zoom level of the home point.
569      */
570     void home( qreal &lon, qreal &lat, int& zoom );
571     /**
572      * @brief  Set the home point
573      * @param  lon  the longitude of the new home point.
574      * @param  lat  the latitude of the new home point.
575      * @param  zoom the default zoom level for the new home point.
576      */
577     void setHome( qreal lon, qreal lat, int zoom = 1050 );
578     /**
579      * @brief  Set the home point
580      * @param  homePoint  the new home point.
581      * @param  zoom       the default zoom level for the new home point.
582      */
583     void setHome( const GeoDataCoordinates& homePoint, int zoom = 1050 );
584
585     /**
586      * @brief  Move left by the moveStep.
587      */
588     void moveLeft();
589     /**
590      * @brief  Move right by the moveStep.
591      */
592     void moveRight();
593     /**
594      * @brief  Move up by the moveStep.
595      */
596     void moveUp();
597     /**
598      * @brief  Move down by the moveStep.
599      */
600     void moveDown();
601
602     /**
603      * @brief Center the view on the default start point with the default zoom.
604      */
605     void goHome();
606
607     /**
608      * @brief Get the ID of the current map theme
609      * To ensure that a unique identifier is being used the theme does NOT 
610      * get represented by its name but the by relative location of the file 
611      * that specifies the theme:
612      *
613      * Example: 
614      *    maptheme = "earth/bluemarble/bluemarble.dgml"
615      */
616     QString mapThemeId() const;
617     /**
618      * @brief Set a new map theme
619      * @param maptheme  The ID of the new maptheme. To ensure that a unique 
620      * identifier is being used the theme does NOT get represented by its 
621      * name but the by relative location of the file that specifies the theme:
622      *
623      * Example: 
624      *    maptheme = "earth/bluemarble/bluemarble.dgml" 
625      */
626     void setMapThemeId( const QString& maptheme );
627
628     /**
629      * @brief  Sets the value of a map theme property
630      * @param  value  value of the property (usually: visibility)
631      * 
632      * Later on we might add a "setPropertyType and a QVariant
633      * if needed.
634      */
635     void setPropertyValue( const QString& name, bool value );
636
637     /**
638      * @brief  Set whether the overview map overlay is visible
639      * @param  visible  visibility of the overview map
640      */
641     void setShowOverviewMap( bool visible );
642
643     /**
644      * @brief  Set whether the scale bar overlay is visible
645      * @param  visible  visibility of the scale bar
646      */
647     void setShowScaleBar( bool visible );
648
649     /**
650      * @brief  Set whether the compass overlay is visible
651      * @param  visible  visibility of the compass
652      */
653     void setShowCompass( bool visible );
654
655     /**
656      * @brief  Set whether the cloud cover is visible
657      * @param  visible  visibility of the cloud cover
658      */
659     void setShowClouds( bool visible );
660
661     /**
662      * @brief Set whether the is tile is visible
663      * NOTE: This is part of the transitional debug API
664      *       and might be subject to changes until Marble 0.8
665      * @param visible visibility of the tile
666      */ 
667     void setShowTileId( bool visible );
668
669     /**
670      * @brief  Set whether the atmospheric glow is visible
671      * @param  visible  visibility of the atmospheric glow
672      */
673     void setShowAtmosphere( bool visible );
674
675     /**
676      * @brief  Set whether the crosshairs are visible
677      * @param  visible  visibility of the crosshairs
678      */
679     void setShowCrosshairs( bool visible );
680
681     /**
682      * @brief  Set whether the coordinate grid overlay is visible
683      * @param  visible  visibility of the coordinate grid
684      */
685     void setShowGrid( bool visible );
686
687     /**
688      * @brief  Set whether the place mark overlay is visible
689      * @param  visible  visibility of the place marks
690      */
691     void setShowPlaces( bool visible );
692
693     /**
694      * @brief  Set whether the city place mark overlay is visible
695      * @param  visible  visibility of the city place marks
696      */
697     void setShowCities( bool visible );
698
699     /**
700      * @brief  Set whether the terrain place mark overlay is visible
701      * @param  visible  visibility of the terrain place marks
702      */
703     void setShowTerrain( bool visible );
704
705     /**
706      * @brief  Set whether the other places overlay is visible
707      * @param  visible  visibility of other places
708      */
709     void setShowOtherPlaces( bool visible );
710
711     /**
712      * @brief  Set whether the relief is visible
713      * @param  visible  visibility of the relief
714      */
715     void setShowRelief( bool visible );
716
717     /**
718      * @brief  Set whether the elevation model is visible
719      * @param  visible  visibility of the elevation model
720      */
721     void setShowElevationModel( bool visible );
722
723     /**
724      * @brief  Set whether the ice layer is visible
725      * @param  visible  visibility of the ice layer
726      */
727     void setShowIceLayer( bool visible );
728
729     /**
730      * @brief  Set whether the borders visible
731      * @param  visible  visibility of the borders
732      */
733     void setShowBorders( bool visible );
734
735     /**
736      * @brief  Set whether the rivers are visible
737      * @param  visible  visibility of the rivers
738      */
739     void setShowRivers( bool visible );
740
741     /**
742      * @brief  Set whether the lakes are visible
743      * @param  visible  visibility of the lakes
744      */
745     void setShowLakes( bool visible );
746
747     /**
748      * @brief Set whether Gps Data is visible
749      * @param visible  visibility of the Gps Data
750      */
751     void setShowGps( bool visible );
752
753     /**
754      * @brief Set whether the frame rate gets shown
755      * @param visible  visibility of the frame rate
756      */
757     void setShowFrameRate( bool visible );
758
759      /**
760      * @brief used to notify about the position of the mouse click
761       */
762     void notifyMouseClick( int x, int y );
763
764     /**
765      * @brief Opens a gpx file for viewing on the Marble Map
766      */
767     void openGpxFile( const QString &filename );
768
769     /**
770      * @brief Return a QAbstractItemModel containing files.
771      */
772     FileViewModel* fileViewModel() const;
773
774     void clearPersistentTileCache();
775     /**
776      * @brief  Set the limit of the persistent (on hard disc) tile cache.
777      * @param  bytes The limit in kilobytes, 0 means no limit.
778      */
779     void setPersistentTileCacheLimit( quint64 kiloBytes );
780
781     void clearVolatileTileCache();
782     /**
783      * @brief  Set the limit of the volatile (in RAM) tile cache.
784      * @param  bytes The limit in kilobytes.
785      */
786     void setVolatileTileCacheLimit( quint64 kiloBytes );
787
788     /**
789      * @brief Update the map because the model changed.
790      */
791     void updateChangedMap();
792
793     bool mapCoversViewport();
794
795     AngleUnit defaultAngleUnit() const;
796     void setDefaultAngleUnit( AngleUnit angleUnit );
797
798     QFont defaultFont() const;
799     void setDefaultFont( const QFont& font );
800     
801     /**
802      * @brief Reload the currently displayed map by reloading texture tiles
803      *        from the Internet. In the future this should be extended to all
804      *        kinds of data which is used in the map.
805      */
806     void reload() const;
807     
808  Q_SIGNALS:
809     /**
810      * @brief Signal that the zoom has changed, and to what.
811      * @param zoom  The new zoom value.
812      * @see  zoomView()
813      */
814     void zoomChanged( int zoom );
815     void distanceChanged( const QString& distanceString );
816
817     /**
818      * @brief Signal that the theme has changed
819      * @param theme  Name of the new theme.
820      */
821     void themeChanged( const QString& theme );
822
823     void projectionChanged( Projection );
824
825     void mouseMoveGeoPosition( const QString& );
826
827     void mouseClickGeoPosition( qreal lon, qreal lat, GeoDataCoordinates::Unit );
828
829     void framesPerSecond( qreal fps );
830
831     /**
832      * This signal is emitted when the repaint of the view was requested.
833      * If available with the @p dirtyRegion which is the region the view will change in.
834      * If dirtyRegion.isEmpty() returns true, the whole viewport has to be repainted.
835      */
836     void repaintNeeded( const QRegion& dirtyRegion );
837
838     /**
839      * This signal is emitted when the visible region of the map changes. This typically happens
840      * when the user moves the map around or zooms.
841      */
842     void visibleLatLonAltBoxChanged( const GeoDataLatLonAltBox& visibleLatLonAltBox );
843
844  protected:
845
846     /**
847      * @brief Enables custom drawing onto the MarbleMap straight after
848      * @brief the globe and before all other layers have been rendered.
849      * @param painter 
850      */
851     virtual void customPaint( GeoPainter *painter );
852
853  private:
854     Q_DISABLE_COPY( MarbleMap )
855     MarbleMapPrivate * const d;
856 };
857
858 }
859
860 #endif