- Adding easier access to float items
[marble:akssps011s-marble.git] / src / lib / MarbleWidget.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 //
11
12 #ifndef MARBLE_MARBLEWIDGET_H
13 #define MARBLE_MARBLEWIDGET_H
14
15
16 /** @file
17  * This file contains the headers for MarbleWidget.
18  *
19  * @author Torsten Rahn <tackat@kde.org>
20  * @author Inge Wallin  <inge@lysator.liu.se>
21  */
22
23 #include <QtGui/QPixmap>
24 #include <QtGui/QWidget>
25
26 #include "GeoDataCoordinates.h"
27 #include "GeoDataLookAt.h"
28 #include "Quaternion.h"
29 #include "global.h"             // types needed in all of marble.
30 #include "marble_export.h"
31 #include "GeoDataFolder.h"
32 // Qt
33 class QAbstractItemModel;
34 class QModelIndex;
35 class QItemSelectionModel;
36 class QSettings;
37
38 namespace Marble
39 {
40
41 class AbstractFloatItem;
42 class FileViewModel;
43 class GeoDataLatLonAltBox;
44 class GeoDataLatLonBox;
45 class GeoPainter;
46 class GeoSceneDocument;
47 class MarbleMap;
48 class MarbleModel;
49 class MarbleWidgetInputHandler;
50 class MarbleWidgetPrivate;
51 class RenderPlugin;
52 class SunLocator;
53 class TileCreator;
54 class GeoDataPlacemark;
55
56 /**
57  * @short A widget class that displays a view of the earth.
58  *
59  * This widget displays a view of the earth or any other globe,
60  * depending on which dataset is used.  The user can navigate the
61  * globe using either a control widget, e.g. the MarbleControlBox, or
62  * the mouse.  The mouse and keyboard control is done through a
63  * MarbleWidgetInputHandler. Only some aspects of the widget can be
64  * controlled by the mouse and/or keyboard.
65  *
66  * By clicking on the globe and moving the mouse, the position can be
67  * changed.  The user can also zoom by using the scroll wheel of the
68  * mouse in the widget. The zoom value is not tied to any units, but
69  * is an abstract value without any physical meaning. A value around
70  * 1000 shows the full globe in a normal-sized window. Higher zoom
71  * values give a more zoomed-in view.
72  *
73  * The MarbleWidget needs to be provided with a data model to
74  * work. This model is contained in the MarbleModel class, and it is
75  * painted by using a MarbleMap. The widget can also construct its own
76  * map and model if none is given to the constructor.  A MarbleModel
77  * contains 3 separate datatypes: <b>tiles</b> which provide the
78  * background, <b>vectors</b> which provide things like country
79  * borders and coastlines and <b>placemarks</b> which can show points
80  * of interest, such as cities, mountain tops or the poles.
81  *
82  * In addition to navigating with the mouse, you can also use it to
83  * get information about items on the map. You can either click on a
84  * placemark with the left mouse button or with the right mouse button
85  * anywhere on the map.
86  *
87  * The left mouse button opens up a menu with all the placemarks
88  * within a certain distance from the mouse pointer. When you choose
89  * one item from the menu, Marble will open up a dialog window with
90  * some information about the placemark and also try to connect to
91  * Wikipedia to retrieve an article about it. If there is such an
92  * article, you will get a mini-browser window with the article in a tab.
93  *
94  * The right mouse button controls a distance tool.  The distance tool
95  * is implemented as a menu where you can choose to either create or
96  * remove so called Measure Points. Marble will keep track of the
97  * Measure Points and show the total distance in the upper left of the
98  * widget.  Measure Points are shown on the map as a little white
99  * cross.
100  *
101  * @see MarbleControlBox
102  * @see MarbleMap
103  * @see MarbleModel
104  */
105
106 class MARBLE_EXPORT MarbleWidget : public QWidget
107 {
108     Q_OBJECT
109 #ifdef MARBLE_DBUS
110     Q_CLASSINFO("D-Bus Interface", "org.kde.MarbleWidget")
111 #endif
112
113     Q_PROPERTY(int zoom          READ zoom            WRITE zoomView)
114
115     Q_PROPERTY(QString mapThemeId  READ mapThemeId    WRITE setMapThemeId)
116     Q_PROPERTY(int projection    READ projection      WRITE setProjection)
117
118     Q_PROPERTY(qreal longitude  READ centerLongitude WRITE setCenterLongitude)
119     Q_PROPERTY(qreal latitude   READ centerLatitude  WRITE setCenterLatitude)
120
121     Q_PROPERTY(bool showOverviewMap READ showOverviewMap    WRITE setShowOverviewMap)
122     Q_PROPERTY(bool showScaleBar READ showScaleBar    WRITE setShowScaleBar)
123     Q_PROPERTY(bool showCompass  READ showCompass     WRITE setShowCompass)
124     Q_PROPERTY(bool showGrid     READ showGrid        WRITE setShowGrid)
125
126     Q_PROPERTY(bool showClouds   READ showClouds      WRITE setShowClouds)
127     Q_PROPERTY(bool showAtmosphere READ showAtmosphere WRITE setShowAtmosphere)
128     Q_PROPERTY(bool showCrosshairs READ showCrosshairs WRITE setShowCrosshairs)
129
130     Q_PROPERTY(bool showPlaces   READ showPlaces      WRITE setShowPlaces)
131     Q_PROPERTY(bool showCities   READ showCities      WRITE setShowCities)
132     Q_PROPERTY(bool showTerrain  READ showTerrain     WRITE setShowTerrain)
133     Q_PROPERTY(bool showOtherPlaces READ showOtherPlaces WRITE setShowOtherPlaces)
134
135     Q_PROPERTY(bool showRelief   READ showRelief      WRITE setShowRelief)
136     Q_PROPERTY(bool showElevationModel READ showElevationModel WRITE setShowElevationModel)
137
138     Q_PROPERTY(bool showIceLayer READ showIceLayer    WRITE setShowIceLayer)
139     Q_PROPERTY(bool showBorders  READ showBorders     WRITE setShowBorders)
140     Q_PROPERTY(bool showRivers   READ showRivers      WRITE setShowRivers)
141     Q_PROPERTY(bool showLakes    READ showLakes       WRITE setShowLakes)
142
143     Q_PROPERTY(quint64 persistentTileCacheLimit  READ persistentTileCacheLimit  WRITE setPersistentTileCacheLimit)
144     Q_PROPERTY(quint64 volatileTileCacheLimit    READ volatileTileCacheLimit    WRITE setVolatileTileCacheLimit)
145
146  public:
147
148     /**
149      * @brief Construct a new MarbleWidget.
150      * @param parent the parent widget
151      *
152      * This constructor should be used when you will only use one
153      * MarbleWidget.  The widget will create its own MarbleModel when
154      * created.
155      */
156     explicit MarbleWidget( QWidget *parent = 0 );
157
158     /**
159      * @brief Construct a new MarbleWidget.
160      * @param model  the data model for the widget.
161      * @param parent the parent widget
162      *
163      * This constructor should be used when you plan to use more than
164      * one MarbleWidget for the same MarbleModel (not yet supported,
165      * but will be soon).
166      */
167     explicit MarbleWidget( MarbleMap *map, QWidget *parent = 0 );
168
169     virtual ~MarbleWidget();
170
171     /**
172      * @brief Return the map that this view shows.
173      */
174     MarbleMap *map() const;
175
176     /**
177      * @brief Return the model that this view shows.
178      */
179     MarbleModel *model() const;
180
181     /**
182      * Returns the current input handler
183      */
184     MarbleWidgetInputHandler *inputHandler() const;
185
186     /**
187      * @brief Set the input handler
188      */
189     void setInputHandler( MarbleWidgetInputHandler *handler );
190
191     /**
192      * @brief Return the active region in which it's possible to drag the view using the mouse.
193      */
194     QRegion activeRegion();
195
196     /**
197      * @brief Return the projected region which describes the (shape of the) projected surface.
198      */
199     QRegion mapRegion();
200
201     /**
202      * @brief  Return the radius of the globe in pixels.
203      */
204     int radius() const;
205
206     /**
207      * @brief  Set the radius of the globe in pixels.
208      * @param  radius  The new globe radius value in pixels.
209      */
210     void setRadius( int radius );
211
212     /**
213      * @brief Return the current zoom amount.
214      */
215     int zoom() const;
216
217     /**
218      * @brief Return the current distance.
219      */
220     qreal distance() const;
221
222     /**
223      * @brief  Set the distance of the observer to the globe in km.
224      * @param  distance  The new distance in km.
225      */
226     void setDistance( qreal distance );
227
228     /**
229      * @brief Return the current distance string.
230      */
231     QString distanceString() const;
232
233     /**
234      * @brief Return the minimum zoom value for the current map theme.
235      */
236     int minimumZoom() const;
237
238     /**
239      * @brief Return the minimum zoom value for the current map theme.
240      */
241     int maximumZoom() const;
242
243     /**
244      * @brief Return if the widget needs to be updated.
245      */
246     bool needsUpdate() const;
247     /**
248      * @brief Mark the widget as needing an update.
249      */
250     void setNeedsUpdate();
251
252     /**
253      * @brief Get the screen coordinates corresponding to geographical coordinates in the widget.
254      * @param lon    the lon coordinate of the requested pixel position
255      * @param lat    the lat coordinate of the requested pixel position
256      * @param x      the x coordinate of the pixel is returned through this parameter
257      * @param y      the y coordinate of the pixel is returned through this parameter
258      * @return @c true  if the geographical coordinates are visible on the screen
259      *         @c false if the geographical coordinates are not visible on the screen
260      */
261     bool screenCoordinates( qreal lon, qreal lat,
262                             qreal& x, qreal& y );
263
264     /**
265      * @brief Get the Y coordinate of the North Pole.
266      * @return the pixel address of the geographical north pole relative to the center of the widget.
267      * This method is deprecated because it returns an unintuitive result.
268      */
269     MARBLE_DEPRECATED(int northPoleY());
270
271     /**
272      * @brief Get the pixel position of the North Pole.
273      * @return The pixel position of the geographical north pole.
274      */
275     QPoint northPolePosition();
276
277     /**
278      * @brief Get the pixel position of the South Pole.
279      * @return The pixel position of the geographical south pole.
280      */
281     QPoint southPolePosition();
282
283     /**
284      * @brief Get the earth coordinates corresponding to a pixel in the widget.
285      * @param x      the x coordinate of the pixel
286      * @param y      the y coordinate of the pixel
287      * @param lon    the longitude angle is returned through this parameter
288      * @param lat    the latitude angle is returned through this parameter
289      * @return @c true  if the pixel (x, y) is within the globe
290      *         @c false if the pixel (x, y) is outside the globe, i.e. in space.
291      */
292     bool geoCoordinates( int x, int y,
293                          qreal& lon, qreal& lat,
294                          GeoDataCoordinates::Unit = GeoDataCoordinates::Degree );
295
296     /**
297      * @brief Return the longitude of the center point.
298      * @return The longitude of the center point in degree.
299      */
300     qreal centerLongitude() const;
301
302     /**
303      * @brief Return the latitude of the center point.
304      * @return The latitude of the center point in degree.
305      */
306     qreal centerLatitude() const;
307     /**
308     * @brief Return the lookAt
309     */
310     GeoDataLookAt lookAt() const;
311     /**
312      * @brief Returns the model for all the placemarks on the globe.
313      */
314     QAbstractItemModel *placemarkModel() const;
315
316     /**
317      * @brief Returns the selection model for all the placemarks on the globe.
318      */
319     QItemSelectionModel *placemarkSelectionModel() const;
320
321     /**
322      * @brief  Return how much the map will move if one of the move slots are called.
323      * @return The move step.
324      */
325     qreal moveStep();
326
327     /**
328      * @brief  Add a GeoDataPlacemark file to the model.
329      * @param  filename  the filename of the file containing the Placemarks.
330      */
331     void addPlacemarkFile( const QString &filename );
332
333     /**
334      * @brief  Add GeoDataPlacemark data as string to the model.
335      * @param  data  the string containing the Placemarks.
336      * @param key  the string needed to identify the data
337      */
338     void addPlacemarkData( const QString& data, const QString& key = "data" );
339     
340     /**
341      * @brief  remove data or files from the model.
342      * @param key  either the filename or the string used to identify the data in addPlacemarkFile and addPlacemarkData
343      */
344     void removePlacemarkKey( const QString& key );
345
346     /**
347      * @brief  Return the quaternion that specifies the rotation of the globe.
348      * @return The quaternion that describes the rotation of the globe.
349      */
350     Quaternion planetAxis() const;
351
352     /**
353      * @brief  Return a QPixmap with the current contents of the widget.
354      */
355     QPixmap mapScreenShot();
356
357     /**
358      * @brief  Return whether the overview map is visible.
359      * @return The overview map visibility.
360      */
361     bool showOverviewMap() const;
362
363     /**
364      * @brief  Return whether the scale bar is visible.
365      * @return The scale bar visibility.
366      */
367     bool showScaleBar() const;
368
369     /**
370      * @brief  Return whether the compass bar is visible.
371      * @return The compass visibility.
372      */
373     bool showCompass() const;
374
375     /**
376      * @brief  Return whether the cloud cover is visible.
377      * @return The cloud cover visibility.
378      */
379     bool showClouds() const;
380
381     /**
382      * @brief  Return whether the atmospheric glow is visible.
383      * @return The cloud cover visibility.
384      */
385     bool showAtmosphere() const;
386
387     /**
388      * @brief  Return whether the crosshairs are visible.
389      * @return The crosshairs' visibility.
390      */
391     bool showCrosshairs() const;
392
393     /**
394      * @brief  Return whether the coordinate grid is visible.
395      * @return The coordinate grid visibility.
396      */
397     bool showGrid() const;
398
399     /**
400      * @brief  Return whether the place marks are visible.
401      * @return The place mark visibility.
402      */
403     bool showPlaces() const;
404
405     /**
406      * @brief  Return whether the city place marks are visible.
407      * @return The city place mark visibility.
408      */
409     bool showCities() const;
410
411     /**
412      * @brief  Return whether the terrain place marks are visible.
413      * @return The terrain place mark visibility.
414      */
415     bool showTerrain() const;
416
417     /**
418      * @brief  Return whether other places are visible.
419      * @return The visibility of other places.
420      */
421     bool showOtherPlaces() const;
422
423     /**
424      * @brief  Return whether the relief is visible.
425      * @return The relief visibility.
426      */
427     bool showRelief() const;
428
429     /**
430      * @brief  Return whether the elevation model is visible.
431      * @return The elevation model visibility.
432      */
433     bool showElevationModel() const;
434
435     /**
436      * @brief  Return whether the ice layer is visible.
437      * @return The ice layer visibility.
438      */
439     bool showIceLayer() const;
440
441     /**
442      * @brief  Return whether the borders are visible.
443      * @return The border visibility.
444      */
445     bool showBorders() const;
446
447     /**
448      * @brief  Return whether the rivers are visible.
449      * @return The rivers' visibility.
450      */
451     bool showRivers() const;
452
453     /**
454      * @brief  Return whether the lakes are visible.
455      * @return The lakes' visibility.
456      */
457     bool showLakes() const;
458
459     /**
460      * @brief Return whether Gps Data is visible.
461      * @return The Gps Data's visibility.
462      */
463     bool showGps() const;
464
465     /**
466      * @brief  Return whether the frame rate gets displayed.
467      * @return the frame rates visibility
468      */
469     bool showFrameRate() const;
470
471     /**
472      * @brief  Returns the limit in kilobytes of the persistent (on hard disc) tile cache.
473      * @return the limit of persistent tile cache
474      */
475     quint64 persistentTileCacheLimit() const;
476
477     /**
478      * @brief  Returns the limit in kilobytes of the volatile (in RAM) tile cache.
479      * @return the limit of volatile tile cache
480      */
481     quint64 volatileTileCacheLimit() const;
482
483     SunLocator* sunLocator();
484
485     //These methods should all be removed
486     // what does this do to binary compatibility?
487     void setProxy( const QString& proxyHost, const quint16 proxyPort, const QString& user, const QString& password );
488     QString proxyHost() const;
489     quint16 proxyPort() const;
490     QString user() const;
491     QString password() const;
492
493     /**
494      * @brief Returns a list of all RenderPlugins on the widget, this includes float items
495      * @return the list of RenderPlugins
496      */
497     QList<RenderPlugin *> renderPlugins() const;
498     /**
499      * @brief Returns a list of all FloatItems on the widget
500      * @return the list of the floatItems
501      */
502     QList<AbstractFloatItem *> floatItems() const;
503     /**
504      * @brief Returns the FloatItem with the given id
505      * @return The pointer to the requested floatItem,
506      *
507      * If no item is found the null pointer is returned.
508      */
509     AbstractFloatItem * floatItem( const QString &nameId ) const;
510
511     /**
512      * Reads the plugin settings from the passed QSettings.
513      * You shouldn't use this in a KDE application as these use KConfig. Here you could
514      * use MarblePart which is handling this automatically.
515      * @param settings The QSettings object to be used.
516      */
517     void readPluginSettings( QSettings& settings );
518
519     /**
520      * Writes the plugin settings in the passed QSettings.
521      * You shouldn't use this in a KDE application as these use KConfig. Here you could
522      * use MarblePart which is handling this automatically.
523      * @param settings The QSettings object to be used.
524      */
525     void writePluginSettings( QSettings& settings ) const;
526
527     /**
528      * @brief  Get the Projection used for the map
529      * @return @c Spherical         a Globe
530      * @return @c Equirectangular   a flat map
531      * @return @c Mercator          another flat map
532      */
533     Projection projection() const;
534 //    int projection() const;
535
536     /**
537      * @brief Get the ID of the current map theme
538      * To ensure that a unique identifier is being used the theme does NOT 
539      * get represented by its name but the by relative location of the file 
540      * that specifies the theme:
541      *
542      * Example: 
543      *    mapThemeId = "earth/bluemarble/bluemarble.dgml"
544      */
545     QString mapThemeId() const;
546
547     /**
548      * @brief Get the GeoSceneDocument object of the current map theme
549      */
550     GeoSceneDocument * mapTheme() const;
551
552     /**
553      * @brief Return a QAbstractItemModel containing files.
554      */
555     FileViewModel * fileViewModel() const;
556
557     /**
558      * @brief Retrieve the map quality depending on the view context 
559      */
560     MapQuality mapQuality( ViewContext = Still );
561
562     /**
563      * @brief Retrieve the view context (i.e. still or animated map) 
564      */
565     ViewContext viewContext() const;
566
567     /**
568      * @brief Retrieve whether travels to a point should get animated 
569      */
570     bool animationsEnabled() const;
571
572     AngleUnit defaultAngleUnit() const;
573     void setDefaultAngleUnit( AngleUnit angleUnit );
574
575     QFont defaultFont() const;
576     void setDefaultFont( const QFont& font );
577     
578     void addBookmark( const GeoDataPlacemark &bookmark, const QString &folderName ) const;
579  
580     bool loadBookmarkFile( const QString& relativeFileName);
581
582     QVector<GeoDataFolder*> folders();
583     
584     void removeAllBookmarks();
585
586     void addNewBookmarkFolder( const QString& name ) const;
587
588  public Q_SLOTS:
589
590     void updateSun();
591     void centerSun();
592     void setInputEnabled( bool );
593 //    void repaintMap();
594     
595     /**
596      * @brief  Zoom the view to a certain zoomlevel
597      * @param  zoom  the new zoom level.
598      *
599      * The zoom level is an abstract value without physical
600      * interpretation.  A zoom value around 1000 lets the viewer see
601      * all of the earth in the default window.
602      */
603     void zoomView( int zoom, FlyToMode mode = Instant );
604
605     /**
606      * @brief  Zoom the view by a certain step
607      * @param  zoomStep  the difference between the old zoom and the new
608      */
609     void zoomViewBy( int zoomStep, FlyToMode mode = Instant );
610
611     /**
612      * @brief  Zoom in by the amount zoomStep.
613      */
614     void zoomIn( FlyToMode mode = Automatic );
615     /**
616      * @brief  Zoom out by the amount zoomStep.
617      */
618     void zoomOut( FlyToMode mode = Automatic );
619
620     /**
621      * @brief  Rotate the view by the two angles phi and theta.
622      * @param  deltaLon  an angle that specifies the change in terms of longitude
623      * @param  deltaLat  an angle that specifies the change in terms of latitude
624      *
625      * This function rotates the view by two angles,
626      * deltaLon ("theta") and deltaLat ("phi").
627      * If we start at (0, 0), the result will be the exact equivalent
628      * of (lon, lat), otherwise the resulting angle will be the sum of
629      * the previous position and the two offsets.
630      */
631     void rotateBy( const qreal deltaLon, const qreal deltaLat, FlyToMode mode = Instant );
632
633     /**
634      * @brief  Rotate the view by the angle specified by a Quaternion.
635      * @param  incRot a quaternion specifying the rotation
636      */
637     void rotateBy( const Quaternion& incRot );
638
639     /**
640      * @brief  Center the view on a geographical point
641      * @param  lat  an angle in degrees parallel to the latitude lines
642      *              +90(N) - -90(S)
643      * @param  lon  an angle in degrees parallel to the longitude lines
644      *              +180(W) - -180(E)
645      */
646     void centerOn( const qreal lon, const qreal lat, bool animated = false );
647
648     /**
649      * @brief  Center the view on a point
650      * @param  index  an index for a QModel, indicating a city
651      */
652     void centerOn( const QModelIndex& index, bool animated = false );
653
654     /**
655      * @brief  Center the view on a point
656      * This method centers the Marble map on the point described by the latitude
657      * and longitude in the GeoDataCoordinate parameter @c point. It also zooms
658      * the map to be at the elevation described by the altitude. If this is
659      * not the desired functionality or you do not have an accurate altitude
660      * then use @see centerOn(qreal, qreal, bool)
661      * @param point the point in 3 dimensions above the globe to move the view
662      *              to. It will always be looking vertically down.
663      */
664     void centerOn( const GeoDataCoordinates &point, bool animated = false );
665
666     /**
667      * @brief Center the view on a bounding box so that it completely fills the viewport
668      * This method not only centers on the center of the GeoDataLatLon box but it also
669      * adjusts the zoom of the marble widget so that the LatLon box provided fills
670      * the viewport.
671      * @param box The GeoDataLatLonBox to zoom and move the MarbleWidget to.
672      */
673     void centerOn( const GeoDataLatLonBox& box, bool animated = false );
674
675     /**
676      * @brief  Set the latitude for the center point
677      * @param  lat  the new value for the latitude in degree.
678      * @param  mode the FlyToMode that will be used.
679      */
680     void setCenterLatitude( qreal lat, FlyToMode mode = Instant );
681
682     /**
683      * @brief  Set the longitude for the center point
684      * @param  lon  the new value for the longitude in degree.
685      * @param  mode the FlyToMode that will be used.
686      */
687     void setCenterLongitude( qreal lon, FlyToMode mode = Instant );
688
689     /**
690      * @brief  Set the Projection used for the map
691      * @param  projection projection type (e.g. Spherical, Equirectangular, Mercator)
692      */
693     void setProjection( int        projection );
694     void setProjection( Projection projection );
695
696     /**
697      * @brief  Get the home point
698      * @param  lon  the longitude of the home point.
699      * @param  lat  the latitude of the home point.
700      * @param  zoom the default zoom level of the home point.
701      */
702     void home( qreal &lon, qreal &lat, int& zoom );
703     /**
704      * @brief  Set the home point
705      * @param  lon  the longitude of the new home point.
706      * @param  lat  the latitude of the new home point.
707      * @param  zoom the default zoom level for the new home point.
708      */
709     void setHome( qreal lon, qreal lat, int zoom = 1050 );
710     /**
711      * @brief  Set the home point
712      * @param  homePoint  the new home point.
713      * @param  zoom       the default zoom level for the new home point.
714      */
715     void setHome( const GeoDataCoordinates& homePoint, int zoom = 1050 );
716
717     /**
718      * @brief  Move left by the moveStep.
719      */
720     void moveLeft( FlyToMode mode = Automatic );
721     /**
722      * @brief  Move right by the moveStep.
723      */
724     void moveRight( FlyToMode mode = Automatic );
725     /**
726      * @brief  Move up by the moveStep.
727      */
728     void moveUp( FlyToMode mode = Automatic );
729     /**
730      * @brief  Move down by the moveStep.
731      */
732     void moveDown( FlyToMode mode = Automatic );
733
734     /**
735      * @brief Center the view on the default start point with the default zoom.
736      */
737     void goHome( FlyToMode mode = Automatic );
738
739     /**
740      * @brief Set a new map theme
741      * @param maptheme  The ID of the new maptheme. To ensure that a unique 
742      * identifier is being used the theme does NOT get represented by its 
743      * name but the by relative location of the file that specifies the theme:
744      *
745      * Example: 
746      *    maptheme = "earth/bluemarble/bluemarble.dgml" 
747      */
748     void setMapThemeId( const QString& maptheme );
749
750     /**
751      * @brief  Sets the value of a map theme property
752      * @param  value  value of the property (usually: visibility)
753      * 
754      * Later on we might add a "setPropertyType and a QVariant
755      * if needed.
756      */
757     void setPropertyValue( const QString& name, bool value );
758
759     /**
760      * @brief  Set whether the overview map overlay is visible
761      * @param  visible  visibility of the overview map
762      */
763     void setShowOverviewMap( bool visible );
764
765     /**
766      * @brief  Set whether the scale bar overlay is visible
767      * @param  visible  visibility of the scale bar
768      */
769     void setShowScaleBar( bool visible );
770
771     /**
772      * @brief  Set whether the compass overlay is visible
773      * @param  visible  visibility of the compass
774      */
775     void setShowCompass( bool visible );
776
777     /**
778      * @brief  Set whether the cloud cover is visible
779      * @param  visible  visibility of the cloud cover
780      */
781     void setShowClouds( bool visible );
782
783     /**
784      * @brief  Set whether the atmospheric glow is visible
785      * @param  visible  visibility of the atmospheric glow
786      */
787     void setShowAtmosphere( bool visible );
788
789     /**
790      * @brief  Set whether the crosshairs are visible
791      * @param  visible  visibility of the crosshairs
792      */
793     void setShowCrosshairs( bool visible );
794
795     /**
796      * @brief  Set whether the coordinate grid overlay is visible
797      * @param  visible  visibility of the coordinate grid
798      */
799     void setShowGrid( bool visible );
800
801     /**
802      * @brief  Set whether the place mark overlay is visible
803      * @param  visible  visibility of the place marks
804      */
805     void setShowPlaces( bool visible );
806
807     /**
808      * @brief  Set whether the city place mark overlay is visible
809      * @param  visible  visibility of the city place marks
810      */
811     void setShowCities( bool visible );
812
813     /**
814      * @brief  Set whether the terrain place mark overlay is visible
815      * @param  visible  visibility of the terrain place marks
816      */
817     void setShowTerrain( bool visible );
818
819     /**
820      * @brief  Set whether the other places overlay is visible
821      * @param  visible  visibility of other places
822      */
823     void setShowOtherPlaces( bool visible );
824
825     /**
826      * @brief  Set whether the relief is visible
827      * @param  visible  visibility of the relief
828      */
829     void setShowRelief( bool visible );
830
831     /**
832      * @brief  Set whether the elevation model is visible
833      * @param  visible  visibility of the elevation model
834      */
835     void setShowElevationModel( bool visible );
836
837     /**
838      * @brief  Set whether the ice layer is visible
839      * @param  visible  visibility of the ice layer
840      */
841     void setShowIceLayer( bool visible );
842
843     /**
844      * @brief  Set whether the borders visible
845      * @param  visible  visibility of the borders
846      */
847     void setShowBorders( bool visible );
848
849     /**
850      * @brief  Set whether the rivers are visible
851      * @param  visible  visibility of the rivers
852      */
853     void setShowRivers( bool visible );
854
855     /**
856      * @brief  Set whether the lakes are visible
857      * @param  visible  visibility of the lakes
858      */
859     void setShowLakes( bool visible );
860
861     /**
862      * @brief Set whether Gps Data is visible
863      * @param visible  visibility of the Gps Data
864      */
865     void setShowGps( bool visible );
866
867     /**
868      * @brief Set whether the frame rate gets shown
869      * @param visible  visibility of the frame rate
870      */
871     void setShowFrameRate( bool visible );
872
873     /**
874      * @brief Set whether the is tile is visible
875      * NOTE: This is part of the transitional debug API
876      *       and might be subject to changes until Marble 0.8
877      * @param visible visibility of the tile
878      */
879     void setShowTileId( bool visible );
880
881      /**
882      * @brief Used to notify about the position of the mouse click
883       */
884     void notifyMouseClick( int x, int y );
885
886     /**
887      * @brief Opens a gpx file for viewing on the Marble Widget
888      */
889     void openGpxFile( const QString &filename );
890
891     void clearPersistentTileCache();
892     /**
893      * @brief  Set the limit of the persistent (on hard disc) tile cache.
894      * @param  kilobytes The limit in kilobytes, 0 means no limit.
895      */
896     void setPersistentTileCacheLimit( quint64 kiloBytes );
897
898     void clearVolatileTileCache();
899     /**
900      * @brief  Set the limit of the volatile (in RAM) tile cache.
901      * @param  kilobytes The limit in kilobytes.
902      */
903     void setVolatileTileCacheLimit( quint64 kiloBytes );
904
905     /**
906      * @brief A slot that is called when the model starts to create new tiles.
907      * @param creator the tile creator object.
908      * @param name  the name of the created theme.
909      * @param description  a descriptive text that can be shown in a dialog.
910      * @see    creatingTilesProgress
911      *
912      * This function is connected to the models signal with the same
913      * name.  When the model needs to create a cache of tiles in
914      * several different resolutions, it will emit creatingTilesStart
915      * once with a name of the theme and a descriptive text.  The
916      * widget can then pop up a dialog to explain why there is a
917      * delay.  The model will then call creatingTilesProgress several
918      * times until the parameter reaches 100 (100%), after which the
919      * creation process is finished.  After this there will be no more
920      * calls to creatingTilesProgress, and the poup dialog can then be
921      * closed.
922      */
923     void creatingTilesStart( TileCreator *creator, const QString& name, const QString& description );
924
925     /**
926      * @brief Update the widget because the model changed.
927      */
928     void updateChangedMap();
929
930     /**
931      * Schedule repaint
932      */
933     void scheduleRepaint( const QRegion& dirtyRegion );
934
935     /**
936      * @brief Set the map quality depending on the view context 
937      */
938     void setMapQuality( MapQuality, ViewContext = Still );
939
940     /**
941      * @brief Set the view context (i.e. still or animated map) 
942      */
943     void setViewContext( ViewContext viewContext );
944
945     /**
946      * @brief Set whether travels to a point should get animated 
947      */
948     void setAnimationsEnabled( bool enabled );
949
950     void setSelection( const QRect& region );
951     
952     /**
953       * @brief Change the camera position to the given position.
954       * @param lookAt New camera position. Changing the camera position means
955       * that both the current center position as well as the zoom value may change
956       * @param mode Interpolation type for intermediate camera positions. Automatic
957       * (default) chooses a suitable interpolation among Instant, Lenar and Jump.
958       * Instant will directly set the new zoom and position values, while
959       * Linear results in a linear interpolation of intermediate center coordinates
960       * along the sphere and a linear interpolation of changes in the camera distance
961       * to the ground. Finally, Jump will behave the same as Linear with regard to
962       * the center position interpolation, but use a parabolic height increase 
963       * towards the middle point of the intermediate positions. This appears
964       * like a jump of the camera.
965       */
966     void flyTo( const GeoDataLookAt &lookAt, FlyToMode mode = Automatic );
967
968  Q_SIGNALS:
969     /**
970      * @brief Signal that the zoom has changed, and to what.
971      * @param zoom  The new zoom value.
972      * @see  zoomView()
973      */
974     void zoomChanged( int zoom );
975     void distanceChanged( const QString& distanceString );
976
977     /**
978      * @brief Signal that the theme has changed
979      * @param theme  Name of the new theme.
980      */
981     void themeChanged( const QString& theme );
982
983     void projectionChanged( Projection );
984
985     void mouseMoveGeoPosition( const QString& );
986
987     void mouseClickGeoPosition( qreal lon, qreal lat, GeoDataCoordinates::Unit );
988
989     void framesPerSecond( qreal fps );
990
991     /** This signal is emit when a new rectangle region is selected over the map 
992      *  The list of double values include coordinates in degrees using this order:
993      *  lon1, lat1, lon2, lat2 (or West, North, East, South) as left/top, right/bottom rectangle.
994      */
995     void regionSelected( const QList<double>& );
996
997     /**
998      * This signal is emit when the settings of a plugin changed.
999      */
1000     void pluginSettingsChanged();
1001     
1002     /**
1003      * @brief Signal that a render item has been initialized
1004      */
1005     void renderPluginInitialized( RenderPlugin *renderPlugin );
1006
1007     /**
1008      * This signal is emitted when the visible region of the map changes. This typically happens
1009      * when the user moves the map around or zooms.
1010      */
1011     void visibleLatLonAltBoxChanged( const GeoDataLatLonAltBox& visibleLatLonAltBox );
1012
1013  protected:
1014     /**
1015      * @brief Reimplementation of the leaveEvent() function in QWidget.
1016      */
1017     void leaveEvent( QEvent *event );
1018
1019     /**
1020      * @brief Reimplementation of the paintEvent() function in QWidget.
1021      */
1022     void paintEvent( QPaintEvent *event );
1023
1024     /**
1025      * @brief Enables custom drawing onto the MarbleWidget straight after
1026      * @brief the globe and before all other layers has been rendered.
1027      * @param painter 
1028      */
1029     virtual void customPaint( GeoPainter *painter );
1030
1031     /**
1032      * @brief Reimplementation of the resizeEvent() function in QWidget.
1033      */
1034     void resizeEvent( QResizeEvent* );
1035
1036     void connectNotify( const char * signal );
1037     void disconnectNotify( const char * signal );
1038
1039     /**
1040       * @brief Reimplementation of the changeEvent() function in QWidget to
1041       * react to changes of the enabled state
1042       */
1043     void changeEvent( QEvent * event );
1044
1045 private Q_SLOTS:
1046     /**
1047       * @brief Switch to still mode when an animation is finished
1048       */
1049     void startStillMode();
1050
1051     /**
1052       * @brief Updates zoom and position during animations
1053       * @see flyTo
1054       */
1055     void updateAnimation( const GeoDataLookAt &lookAt );
1056
1057  private:
1058     Q_DISABLE_COPY( MarbleWidget )
1059     MarbleWidgetPrivate  * const d;
1060 };
1061
1062 }
1063
1064 #endif