Marble.MarbleWidget

KDE 4.2 PyKDE API Reference for Marble

- KDE's Python API

# MarbleWidget Class Reference

`from PyKDE4.marble import *`

Inherits: QWidget → QObject
Namespace: Marble

## Detailed Description

A widget class that displays a view of the earth.

This widget displays a view of the earth or any other globe, depending on which dataset is used. The user can navigate the globe using either a control widget, e.g. the MarbleControlBox, or the mouse. The mouse and keyboard control is done through a MarbleWidgetInputHandler. Only some aspects of the widget can be controlled by the mouse and/or keyboard.

By clicking on the globe and moving the mouse, the position can be changed. The user can also zoom by using the scroll wheel of the mouse in the widget. The zoom value is not tied to any units, but is an abstract value without any physical meaning. A value around 1000 shows the full globe in a normal-sized window. Higher zoom values give a more zoomed-in view.

The MarbleWidget needs to be provided with a data model to work. This model is contained in the MarbleModel class, and it is painted by using a MarbleMap. The widget can also construct its own map and model if none is given to the constructor. A MarbleModel contains 3 separate datatypes: tiles which provide the background, vectors which provide things like country borders and coastlines and placemarks which can show points of interest, such as cities, mountain tops or the poles.

In addition to navigating with the mouse, you can also use it to get information about items on the map. You can either click on a placemark with the left mouse button or with the right mouse button anywhere on the map.

The left mouse button opens up a menu with all the placemarks within a certain distance from the mouse pointer. When you choose one item from the menu, Marble will open up a dialog window with some information about the placemark and also try to connect to Wikipedia to retrieve an article about it. If there is such an article, you will get a mini-browser window with the article in a tab.

The right mouse button controls a distance tool. The distance tool is implemented as a menu where you can choose to either create or remove so called Measure Points. Marble will keep track of the Measure Points and show the total distance in the upper left of the widget. Measure Points are shown on the map as a little white cross.

See also:
  MarbleControlBox

See also:
  MarbleMap

See also:
  MarbleModel

## Signals
| distanceChanged (QString distanceString)
| framesPerSecond (float fps)
| mouseClickGeoPosition (float lon, float lat, Marble.GeoDataCoordinates.Unit a0)
| mouseMoveGeoPosition (QString a0)
| projectionChanged (Marble.Projection a0)
| regionSelected ([float] a0)
| themeChanged (QString theme)
| timeout ()
| zoomChanged (int zoom)
## Methods
| __init__ (self, QWidget parent=0)
| __init__ (self, Marble.MarbleMap map, QWidget parent=0)
| __init__ (self, Marble.MarbleWidget a0)
QRegion | activeRegion (self)
| addPlaceMarkData (self, QString data)
| addPlaceMarkFile (self, QString filename)
bool | animationsEnabled (self)
float | centerLatitude (self)
float | centerLongitude (self)
| centerOn (self, float lon, float lat, bool animated=0)
| centerOn (self, QModelIndex index, bool animated=0)
| centerOn (self, Marble.GeoDataCoordinates point, bool animated=0)
| centerSun (self)
| changeCurrentPosition (self, float lon, float lat)
| clearPersistentTileCache (self)
| clearVolatileTileCache (self)
| connectNotify (self, QString signal)
| creatingTilesStart (self, Marble.TileCreator creator, QString name, QString description)
| customPaint (self, Marble.GeoPainter painter)
Marble.AngleUnit | defaultAngleUnit (self)
Marble.DistanceUnit | defaultDistanceUnit (self)
QFont | defaultFont (self)
| disableInput (self)
| disconnectNotify (self, QString signal)
float | distance (self)
| distanceChanged (self, QString distanceString)
QString | distanceString (self)
| enableInput (self)
FileViewModel | fileViewModel (self)
[Marble::MarbleAbstractFloatIte] | floatItems (self)
| framesPerSecond (self, float fps)
bool | geoCoordinates (self, int x, int y, float lon, float lat, Marble.GeoDataCoordinates.Unit a0=GeoDataCoordinates.Degree)
bool | globalQuaternion (self, int x, int y, Marble.Quaternion q)
| goHome (self)
GpxFileModel | gpxFileModel (self)
| home (self, float lon, float lat, int zoom)
| leaveEvent (self, QEvent event)
Marble.MarbleMap | map (self)
Marble.MapQuality | mapQuality (self, Marble.ViewContext a0=Marble.Still)
QPixmap | mapScreenShot (self)
Marble.GeoSceneDocument | mapTheme (self)
QString | mapThemeId (self)
int | maximumZoom (self)
int | minimumZoom (self)
Marble.MarbleModel | model (self)
| mouseClickGeoPosition (self, float lon, float lat, Marble.GeoDataCoordinates.Unit a0)
| mouseMoveGeoPosition (self, QString a0)
| moveDown (self)
| moveLeft (self)
| moveRight (self)
float | moveStep (self)
| moveUp (self)
bool | needsUpdate (self)
int | northPoleY (self)
| notifyMouseClick (self, int x, int y)
| openGpxFile (self, QString filename)
| paintEvent (self, QPaintEvent event)
quint64 | persistentTileCacheLimit (self)
QAbstractItemModel | placeMarkModel (self)
QItemSelectionModel | placeMarkSelectionModel (self)
Marble.Quaternion | planetAxis (self)
QRegion | projectedRegion (self)
Marble.Projection | projection (self)
| projectionChanged (self, Marble.Projection a0)
QString | proxyHost (self)
int | proxyPort (self)
int | radius (self)
| regionSelected (self, [float] a0)
[Marble::MarbleRenderPlugi] | renderPlugins (self)
| resizeEvent (self, QResizeEvent a0)
| rotateBy (self, float deltaLon, float deltaLat)
| rotateBy (self, Marble.Quaternion incRot)
bool | screenCoordinates (self, float lon, float lat, int x, int y)
| setAnimationsEnabled (self, bool enabled)
| setCenterLatitude (self, float lat)
| setCenterLongitude (self, float lon)
| setDefaultAngleUnit (self, Marble.AngleUnit angleUnit)
| setDefaultDistanceUnit (self, Marble.DistanceUnit distanceUnit)
| setDefaultFont (self, QFont font)
| setDistance (self, float distance)
| setDownloadManager (self, HttpDownloadManager downloadManager)
| setDownloadUrl (self, QString url)
| setDownloadUrl (self, QUrl url)
| setHome (self, float lon, float lat, int zoom=1050)
| setHome (self, Marble.GeoDataCoordinates homePoint, int zoom=1050)
| setInputHandler (self, MarbleWidgetInputHandler handler)
| setMapQuality (self, Marble.MapQuality a0, Marble.ViewContext a1=Marble.Still)
| setMapThemeId (self, QString maptheme)
| setNeedsUpdate (self)
| setPersistentTileCacheLimit (self, quint64 kiloBytes)
| setProjection (self, int projection)
| setProjection (self, Marble.Projection projection)
| setPropertyValue (self, QString name, bool value)
| setProxy (self, QString proxyHost, int proxyPort)
| setRadius (self, int radius)
| setSelection (self, QRect region)
| setShowAtmosphere (self, bool visible)
| setShowBorders (self, bool visible)
| setShowCities (self, bool visible)
| setShowClouds (self, bool visible)
| setShowCompass (self, bool visible)
| setShowCrosshairs (self, bool visible)
| setShowElevationModel (self, bool visible)
| setShowFrameRate (self, bool visible)
| setShowGps (self, bool visible)
| setShowGrid (self, bool visible)
| setShowIceLayer (self, bool visible)
| setShowLakes (self, bool visible)
| setShowOtherPlaces (self, bool visible)
| setShowOverviewMap (self, bool visible)
| setShowPlaces (self, bool visible)
| setShowRelief (self, bool visible)
| setShowRivers (self, bool visible)
| setShowScaleBar (self, bool visible)
| setShowTerrain (self, bool visible)
| setViewContext (self, Marble.ViewContext viewContext)
| setVolatileTileCacheLimit (self, quint64 kiloBytes)
bool | showAtmosphere (self)
bool | showBorders (self)
bool | showCities (self)
bool | showClouds (self)
bool | showCompass (self)
bool | showCrosshairs (self)
bool | showElevationModel (self)
bool | showFrameRate (self)
bool | showGps (self)
bool | showGrid (self)
bool | showIceLayer (self)
bool | showLakes (self)
bool | showOtherPlaces (self)
bool | showOverviewMap (self)
bool | showPlaces (self)
bool | showRelief (self)
bool | showRivers (self)
bool | showScaleBar (self)
bool | showTerrain (self)
Marble.SunLocator | sunLocator (self)
| themeChanged (self, QString theme)
| timeout (self)
| updateChangedMap (self)
| updateGps (self)
| updateRegion (self, BoundingBox a0)
| updateSun (self)
Marble.ViewContext | viewContext (self)
quint64 | volatileTileCacheLimit (self)
int | zoom (self)
| zoomChanged (self, int zoom)
| zoomIn (self)
| zoomOut (self)
| zoomView (self, int zoom)
| zoomViewBy (self, int zoomStep)

## Method Documentation

__init__ | ( | self, |
|  | QWidget | parent=0
| ) |  |  |

Construct a new MarbleWidget.

Parameters:

  | parent | the parent widget

This constructor should be used when you will only use one MarbleWidget. The widget will create its own MarbleModel when created.

__init__ | ( | self, |
|  | Marble.MarbleMap | map,
|  | QWidget | parent=0
| ) |  |  |

Construct a new MarbleWidget.

Parameters:

  | model | the data model for the widget.
  | parent | the parent widget

This constructor should be used when you plan to use more than one MarbleWidget for the same MarbleModel (not yet supported, but will be soon).

__init__ | ( | self, |
|  | Marble.MarbleWidget | a0
| ) |  |  |

QRegion activeRegion | ( |  | self ) |

Return the active region in which it's possible to drag the view using the mouse.

addPlaceMarkData | ( | self, |
|  | QString | data
| ) |  |  |

Add GeoDataPlacemark data as string to the model.

Parameters:

  |  | data the string containing the PlaceMarks.

addPlaceMarkFile | ( | self, |
|  | QString | filename
| ) |  |  |

Add a GeoDataPlacemark file to the model.

Parameters:

  |  | filename the filename of the file containing the PlaceMarks.

bool animationsEnabled | ( |  | self ) |

Retrieve whether travels to a point should get animated

float centerLatitude | ( |  | self ) |

Return the latitude of the center point.

float centerLongitude | ( |  | self ) |

Return the longitude of the center point.

centerOn | ( | self, |
|  | float | lon,
|  | float | lat,
|  | bool | animated=0
| ) |  |  |

Center the view on a geographical point

Parameters:

  |  | lat an angle parallel to the latitude lines +90(N) - -90(S)
  |  | lon an angle parallel to the longitude lines +180(W) - -180(E)

centerOn | ( | self, |
|  | QModelIndex | index,
|  | bool | animated=0
| ) |  |  |

Center the view on a point

Parameters:

  |  | index an index for a QModel, indicating a city

centerOn | ( | self, |
|  | Marble.GeoDataCoordinates | point,
|  | bool | animated=0
| ) |  |  |

Center the view on a point

Parameters:

  |  | point the point above earth from which the view can be seen by looking vertically down.

centerSun | ( |  | self ) |

changeCurrentPosition | ( | self, |
|  | float | lon,
|  | float | lat
| ) |  |  |

Set the current Gps position

Parameters:

  | lat | the new latitude value
  | lon | the new longitude value

clearPersistentTileCache | ( |  | self ) |

clearVolatileTileCache | ( |  | self ) |

connectNotify | ( | self, |
|  | QString | signal
| ) |  |  |

creatingTilesStart | ( | self, |
|  | Marble.TileCreator | creator,
|  | QString | name,
|  | QString | description
| ) |  |  |

A slot that is called when the model starts to create new tiles.

Parameters:

  | creator | the tile creator object.
  | name | the name of the created theme.
  | description | a descriptive text that can be shown in a dialog.

See also:
  creatingTilesProgress

This function is connected to the models signal with the same name. When the model needs to create a cache of tiles in several different resolutions, it will emit creatingTilesStart once with a name of the theme and a descriptive text. The widget can then pop up a dialog to explain why there is a delay. The model will then call creatingTilesProgress several times until the parameter reaches 100 (100%), after which the creation process is finished. After this there will be no more calls to creatingTilesProgress, and the poup dialog can then be closed.

customPaint | ( | self, |
|  | Marble.GeoPainter | painter
| ) |  |  |

Enables custom drawing onto the MarbleWidget straight after the globe and before all other layers has been rendered.

Parameters:

  | painter |

Marble.AngleUnit defaultAngleUnit | ( |  | self ) |

Marble.DistanceUnit defaultDistanceUnit | ( |  | self ) |

QFont defaultFont | ( |  | self ) |

disableInput | ( |  | self ) |

disconnectNotify | ( | self, |
|  | QString | signal
| ) |  |  |

float distance | ( |  | self ) |

Return the current distance.

distanceChanged | ( | self, |
|  | QString | distanceString
| ) |  |  |

Signal syntax:
  `QObject.connect(source, SIGNAL("distanceChanged(const QString&)"), target_slot)`

QString distanceString | ( |  | self ) |

Return the current distance string.

enableInput | ( |  | self ) |

FileViewModel fileViewModel | ( |  | self ) |

Return a QAbstractItemModel containing files.

[Marble::MarbleAbstractFloatIte] floatItems | ( |  | self ) |

framesPerSecond | ( | self, |
|  | float | fps
| ) |  |  |

Signal syntax:
  `QObject.connect(source, SIGNAL("framesPerSecond(qreal)"), target_slot)`

bool geoCoordinates | ( | self, |
|  | int | x,
|  | int | y,
|  | float | lon,
|  | float | lat,
|  | Marble.GeoDataCoordinates.Unit | a0=GeoDataCoordinates.Degree
| ) |  |  |

Get the earth coordinates corresponding to a pixel in the widget.

Parameters:

  | x | the x coordinate of the pixel
  | y | the y coordinate of the pixel
  | lon | the longitude angle is returned through this parameter
  | lat | the latitude angle is returned through this parameter

Returns:
  true if the pixel (x, y) is within the globe

false if the pixel (x, y) is outside the globe, i.e. in space.

bool globalQuaternion | ( | self, |
|  | int | x,
|  | int | y,
|  | Marble.Quaternion | q
| ) |  |  |

Get a quaternion representing a point on the earth corresponding to a pixel in the widget.

Parameters:

  | x | the x coordinate of the pixel
  | y | the y coordinate of the pixel
  | q | the out parameter where the result is returned

Returns:
  true if the pixel (x, y) is within the globe

false if the pixel (x, y) is outside the globe, i.e. in space

goHome | ( |  | self ) |

Center the view on the default start point with the default zoom.

GpxFileModel gpxFileModel | ( |  | self ) |

Return a QAbstractItemModel containing GPX files.

home | ( | self, |
|  | float | lon,
|  | float | lat,
|  | int | zoom
| ) |  |  |

Get the home point

Parameters:

  |  | lon the longitude of the home point.
  |  | lat the latitude of the home point.
  |  | zoom the default zoom level of the home point.

leaveEvent | ( | self, |
|  | QEvent | event
| ) |  |  |

Reimplementation of the leaveEvent() function in QWidget.

Marble.MarbleMap map | ( |  | self ) |

Return the map that this view shows.

Marble.MapQuality mapQuality | ( | self, |
|  | Marble.ViewContext | a0=Marble.Still
| ) |  |  |

Retrieve the map quality depending on the view context

QPixmap mapScreenShot | ( |  | self ) |

Return a QPixmap with the current contents of the widget.

Marble.GeoSceneDocument mapTheme | ( |  | self ) |

Get the GeoSceneDocument object of the current map theme

QString mapThemeId | ( |  | self ) |

Get the ID of the current map theme To ensure that a unique identifier is being used the theme does NOT get represented by its name but the by relative location of the file that specifies the theme:

Example: mapThemeId = "earth/bluemarble/bluemarble.dgml"

int maximumZoom | ( |  | self ) |

Return the minimum zoom value for the current map theme.

int minimumZoom | ( |  | self ) |

Return the minimum zoom value for the current map theme.

Marble.MarbleModel model | ( |  | self ) |

Return the model that this view shows.

mouseClickGeoPosition | ( | self, |
|  | float | lon,
|  | float | lat,
|  | Marble.GeoDataCoordinates.Unit | a0
| ) |  |  |

Signal syntax:
  `QObject.connect(source, SIGNAL("mouseClickGeoPosition(qreal, qreal, Unit)"), target_slot)`

mouseMoveGeoPosition | ( | self, |
|  | QString | a0
| ) |  |  |

Signal syntax:
  `QObject.connect(source, SIGNAL("mouseMoveGeoPosition(QString)"), target_slot)`

moveDown | ( |  | self ) |

Move down by the moveStep.

moveLeft | ( |  | self ) |

Move left by the moveStep.

moveRight | ( |  | self ) |

Move right by the moveStep.

float moveStep | ( |  | self ) |

Return how much the map will move if one of the move slots are called.

Returns:
  The move step.

moveUp | ( |  | self ) |

Move up by the moveStep.

bool needsUpdate | ( |  | self ) |

Return if the widget needs to be updated.

int northPoleY | ( |  | self ) |

Get the Y coordinate of the North Pole.

Returns:
  the pixel address of the geographical north pole.

notifyMouseClick | ( | self, |
|  | int | x,
|  | int | y
| ) |  |  |

Used to notify about the position of the mouse click

openGpxFile | ( | self, |
|  | QString | filename
| ) |  |  |

Opens a gpx file for viewing on the Marble Widget

paintEvent | ( | self, |
|  | QPaintEvent | event
| ) |  |  |

Reimplementation of the paintEvent() function in QWidget.

quint64 persistentTileCacheLimit | ( |  | self ) |

Returns the limit in kilobytes of the persistent (on hard disc) tile cache.

Returns:
  the limit of persistent tile cache

QAbstractItemModel placeMarkModel | ( |  | self ) |

Returns the model for all the placemarks on the globe.

QItemSelectionModel placeMarkSelectionModel | ( |  | self ) |

Returns the selection model for all the placemarks on the globe.

Marble.Quaternion planetAxis | ( |  | self ) |

Return the quaternion that specifies the rotation of the globe.

Returns:
  The quaternion that describes the rotation of the globe.

QRegion projectedRegion | ( |  | self ) |

Return the active region in which it's possible to drag the view using the mouse.

Marble.Projection projection | ( |  | self ) |

Get the Projection used for the map

Returns:
  Spherical a Globe

Returns:
  Equirectangular a flat map

Returns:
  Mercator another flat map

projectionChanged | ( | self, |
|  | Marble.Projection | a0
| ) |  |  |

Signal syntax:
  `QObject.connect(source, SIGNAL("projectionChanged(Projection)"), target_slot)`

QString proxyHost | ( |  | self ) |

int proxyPort | ( |  | self ) |

int radius | ( |  | self ) |

Return the radius of the globe in pixels.

regionSelected | ( | self, |
|  | [float] | a0
| ) |  |  |

This signal is emit when a new rectangle region is selected over the map The list of double values include coordinates in degrees using this order: lon1, lat1, lon2, lat2 (or West, North, East, South) as left/top, right/bottom rectangle.

Signal syntax:
  `QObject.connect(source, SIGNAL("regionSelected(const QList&)"), target_slot)`

[Marble::MarbleRenderPlugi] renderPlugins | ( |  | self ) |

resizeEvent | ( | self, |
|  | QResizeEvent | a0
| ) |  |  |

Reimplementation of the resizeEvent() function in QWidget.

rotateBy | ( | self, |
|  | float | deltaLon,
|  | float | deltaLat
| ) |  |  |

Rotate the view by the two angles phi and theta.

Parameters:

  |  | deltaLon an angle that specifies the change in terms of longitude
  |  | deltaLat an angle that specifies the change in terms of latitude

This function rotates the view by two angles, deltaLon ("theta") and deltaLat ("phi"). If we start at (0, 0), the result will be the exact equivalent of (lon, lat), otherwise the resulting angle will be the sum of the previous position and the two offsets.

rotateBy | ( | self, |
|  | Marble.Quaternion | incRot
| ) |  |  |

Rotate the view by the angle specified by a Quaternion.

Parameters:

  |  | incRot a quaternion specifying the rotation

bool screenCoordinates | ( | self, |
|  | float | lon,
|  | float | lat,
|  | int | x,
|  | int | y
| ) |  |  |

Get the screen coordinates corresponding to geographical coordinates in the widget.

Parameters:

  | lon | the lon coordinate of the requested pixel position
  | lat | the lat coordinate of the requested pixel position
  | x | the x coordinate of the pixel is returned through this parameter
  | y | the y coordinate of the pixel is returned through this parameter

Returns:
  true if the geographical coordinates are visible on the screen

false if the geographical coordinates are not visible on the screen

setAnimationsEnabled | ( | self, |
|  | bool | enabled
| ) |  |  |

Set whether travels to a point should get animated

setCenterLatitude | ( | self, |
|  | float | lat
| ) |  |  |

Set the latitude for the center point

Parameters:

  |  | lat the new value for the latitude

setCenterLongitude | ( | self, |
|  | float | lon
| ) |  |  |

Set the longitude for the center point

Parameters:

  |  | lon the new value for the longitude

setDefaultAngleUnit | ( | self, |
|  | Marble.AngleUnit | angleUnit
| ) |  |  |

setDefaultDistanceUnit | ( | self, |
|  | Marble.DistanceUnit | distanceUnit
| ) |  |  |

setDefaultFont | ( | self, |
|  | QFont | font
| ) |  |  |

setDistance | ( | self, |
|  | float | distance
| ) |  |  |

Set the distance of the observer to the globe in km.

Parameters:

  |  | distance The new distance in km.

setDownloadManager | ( | self, |
|  | HttpDownloadManager | downloadManager
| ) |  |  |

Set the download manager to load missing tiles

Parameters:

  | manager | the manager instance

The instance will be destructed by MarbleWidget when not used any longer.

setDownloadUrl | ( | self, |
|  | QString | url
| ) |  |  |

Set the download url to load missing tiles

Parameters:

  | url | the url string

setDownloadUrl | ( | self, |
|  | QUrl | url
| ) |  |  |

Set the download url to load missing tiles

Parameters:

  | url | the url objects

setHome | ( | self, |
|  | float | lon,
|  | float | lat,
|  | int | zoom=1050
| ) |  |  |

Set the home point

Parameters:

  |  | lon the longitude of the new home point.
  |  | lat the latitude of the new home point.
  |  | zoom the default zoom level for the new home point.

setHome | ( | self, |
|  | Marble.GeoDataCoordinates | homePoint,
|  | int | zoom=1050
| ) |  |  |

Set the home point

Parameters:

  |  | homePoint the new home point.
  |  | zoom the default zoom level for the new home point.

setInputHandler | ( | self, |
|  | MarbleWidgetInputHandler | handler
| ) |  |  |

Set the input handler

setMapQuality | ( | self, |
|  | Marble.MapQuality | a0,
|  | Marble.ViewContext | a1=Marble.Still
| ) |  |  |

Set the map quality depending on the view context

setMapThemeId | ( | self, |
|  | QString | maptheme
| ) |  |  |

Set a new map theme

Parameters:

  | maptheme | The ID of the new maptheme. To ensure that a unique identifier is being used the theme does NOT get represented by its name but the by relative location of the file that specifies the theme:

Example: maptheme = "earth/bluemarble/bluemarble.dgml"

setNeedsUpdate | ( |  | self ) |

Mark the widget as needing an update.

setPersistentTileCacheLimit | ( | self, |
|  | quint64 | kiloBytes
| ) |  |  |

Set the limit of the persistent (on hard disc) tile cache.

Parameters:

  |  | kilobytes The limit in kilobytes.

setProjection | ( | self, |
|  | int | projection
| ) |  |  |

Set the Projection used for the map

Parameters:

  |  | projection projection type (e.g. Spherical, Equirectangular, Mercator)

setProjection | ( | self, |
|  | Marble.Projection | projection
| ) |  |  |

setPropertyValue | ( | self, |
|  | QString | name,
|  | bool | value
| ) |  |  |

Sets the value of a map theme property

Parameters:

  |  | value value of the property (usually: visibility)

Later on we might add a "setPropertyType and a QVariant if needed.

setProxy | ( | self, |
|  | QString | proxyHost,
|  | int | proxyPort
| ) |  |  |

setRadius | ( | self, |
|  | int | radius
| ) |  |  |

Set the radius of the globe in pixels.

Parameters:

  |  | radius The new globe radius value in pixels.

setSelection | ( | self, |
|  | QRect | region
| ) |  |  |

setShowAtmosphere | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether the atmospheric glow is visible

Parameters:

  |  | visible visibility of the atmospheric glow

setShowBorders | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether the borders visible

Parameters:

  |  | visible visibility of the borders

setShowCities | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether the city place mark overlay is visible

Parameters:

  |  | visible visibility of the city place marks

setShowClouds | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether the cloud cover is visible

Parameters:

  |  | visible visibility of the cloud cover

setShowCompass | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether the compass overlay is visible

Parameters:

  |  | visible visibility of the compass

setShowCrosshairs | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether the crosshairs are visible

Parameters:

  |  | visible visibility of the crosshairs

setShowElevationModel | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether the elevation model is visible

Parameters:

  |  | visible visibility of the elevation model

setShowFrameRate | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether the frame rate gets shown

Parameters:

  | visible | visibility of the frame rate

setShowGps | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether Gps Data is visible

Parameters:

  | visible | visibility of the Gps Data

setShowGrid | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether the coordinate grid overlay is visible

Parameters:

  |  | visible visibility of the coordinate grid

setShowIceLayer | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether the ice layer is visible

Parameters:

  |  | visible visibility of the ice layer

setShowLakes | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether the lakes are visible

Parameters:

  |  | visible visibility of the lakes

setShowOtherPlaces | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether the other places overlay is visible

Parameters:

  |  | visible visibility of other places

setShowOverviewMap | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether the overview map overlay is visible

Parameters:

  |  | visible visibility of the overview map

setShowPlaces | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether the place mark overlay is visible

Parameters:

  |  | visible visibility of the place marks

setShowRelief | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether the relief is visible

Parameters:

  |  | visible visibility of the relief

setShowRivers | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether the rivers are visible

Parameters:

  |  | visible visibility of the rivers

setShowScaleBar | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether the scale bar overlay is visible

Parameters:

  |  | visible visibility of the scale bar

setShowTerrain | ( | self, |
|  | bool | visible
| ) |  |  |

Set whether the terrain place mark overlay is visible

Parameters:

  |  | visible visibility of the terrain place marks

setViewContext | ( | self, |
|  | Marble.ViewContext | viewContext
| ) |  |  |

Set the view context (i.e. still or animated map)

setVolatileTileCacheLimit | ( | self, |
|  | quint64 | kiloBytes
| ) |  |  |

Set the limit of the volatile (in RAM) tile cache.

Parameters:

  |  | kilobytes The limit in kilobytes.

bool showAtmosphere | ( |  | self ) |

Return whether the atmospheric glow is visible.

Returns:
  The cloud cover visibility.

bool showBorders | ( |  | self ) |

Return whether the borders are visible.

Returns:
  The border visibility.

bool showCities | ( |  | self ) |

Return whether the city place marks are visible.

Returns:
  The city place mark visibility.

bool showClouds | ( |  | self ) |

Return whether the cloud cover is visible.

Returns:
  The cloud cover visibility.

bool showCompass | ( |  | self ) |

Return whether the compass bar is visible.

Returns:
  The compass visibility.

bool showCrosshairs | ( |  | self ) |

Return whether the crosshairs are visible.

Returns:
  The crosshairs' visibility.

bool showElevationModel | ( |  | self ) |

Return whether the elevation model is visible.

Returns:
  The elevation model visibility.

bool showFrameRate | ( |  | self ) |

Return whether the frame rate gets displayed.

Returns:
  the frame rates visibility

bool showGps | ( |  | self ) |

Return whether Gps Data is visible.

Returns:
  The Gps Data's visibility.

bool showGrid | ( |  | self ) |

Return whether the coordinate grid is visible.

Returns:
  The coordinate grid visibility.

bool showIceLayer | ( |  | self ) |

Return whether the ice layer is visible.

Returns:
  The ice layer visibility.

bool showLakes | ( |  | self ) |

Return whether the lakes are visible.

Returns:
  The lakes' visibility.

bool showOtherPlaces | ( |  | self ) |

Return whether other places are visible.

Returns:
  The visibility of other places.

bool showOverviewMap | ( |  | self ) |

Return whether the overview map is visible.

Returns:
  The overview map visibility.

bool showPlaces | ( |  | self ) |

Return whether the place marks are visible.

Returns:
  The place mark visibility.

bool showRelief | ( |  | self ) |

Return whether the relief is visible.

Returns:
  The relief visibility.

bool showRivers | ( |  | self ) |

Return whether the rivers are visible.

Returns:
  The rivers' visibility.

bool showScaleBar | ( |  | self ) |

Return whether the scale bar is visible.

Returns:
  The scale bar visibility.

bool showTerrain | ( |  | self ) |

Return whether the terrain place marks are visible.

Returns:
  The terrain place mark visibility.

Marble.SunLocator sunLocator | ( |  | self ) |

themeChanged | ( | self, |
|  | QString | theme
| ) |  |  |

Signal that the theme has changed

Parameters:

  | theme | Name of the new theme.

Signal syntax:
  `QObject.connect(source, SIGNAL("themeChanged(QString)"), target_slot)`

timeout | ( |  | self ) |

Signal syntax:
  `QObject.connect(source, SIGNAL("timeout()"), target_slot)`

updateChangedMap | ( |  | self ) |

Update the widget because the model changed.

updateGps | ( |  | self ) |

Updates the gps tracking point by polling

updateRegion | ( | self, |
|  | BoundingBox | a0
| ) |  |  |

Update part of the map as defined in the BoundingBox

updateSun | ( |  | self ) |

Marble.ViewContext viewContext | ( |  | self ) |

Retrieve the view context (i.e. still or animated map)

quint64 volatileTileCacheLimit | ( |  | self ) |

Returns the limit in kilobytes of the volatile (in RAM) tile cache.

Returns:
  the limit of volatile tile cache

int zoom | ( |  | self ) |

Return the current zoom level.

zoomChanged | ( | self, |
|  | int | zoom
| ) |  |  |

Signal that the zoom has changed, and to what.

Parameters:

  | zoom | The new zoom value.

See also:
  zoomView()

Signal syntax:
  `QObject.connect(source, SIGNAL("zoomChanged(int)"), target_slot)`

zoomIn | ( |  | self ) |

Zoom in by the amount zoomStep.

zoomOut | ( |  | self ) |

Zoom out by the amount zoomStep.

zoomView | ( | self, |
|  | int | zoom
| ) |  |  |

Zoom the view to a certain zoomlevel

Parameters:

  |  | zoom the new zoom level.

The zoom level is an abstract value without physical interpretation. A zoom value around 1000 lets the viewer see all of the earth in the default window.

zoomViewBy | ( | self, |
|  | int | zoomStep
| ) |  |  |

Zoom the view by a certain step

Parameters:

  |  | zoomStep the difference between the old zoom and the new