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

marble

  • sources
  • kde-4.12
  • kdeedu
  • marble
  • src
  • plugins
  • render
  • positionmarker
PositionMarker.cpp
Go to the documentation of this file.
1 //
2 // This file is part of the Marble Virtual Globe.
3 //
4 // This program is free software licensed under the GNU LGPL. You can
5 // find a copy of this license in LICENSE.txt in the top directory of
6 // the source code.
7 //
8 // Copyright 2007 Andrew Manson <g.real.ate@gmail.com>
9 // Copyright 2009 Eckhart Wörner <ewoerner@kde.org>
10 // Copyright 2010 Thibaut Gridel <tgridel@free.fr>
11 // Copyright 2010 Daniel Marth <danielmarth@gmx.at>
12 //
13 
14 #include "PositionMarker.h"
15 
16 #include "MarbleDebug.h"
17 #include <QRect>
18 #include <qmath.h>
19 #include <QFileDialog>
20 #include <QPushButton>
21 #include <QColorDialog>
22 #include <QTransform>
23 
24 #include <cmath>
25 
26 #include "ui_PositionMarkerConfigWidget.h"
27 #include "MarbleModel.h"
28 #include "MarbleDirs.h"
29 #include "GeoPainter.h"
30 #include "PositionTracking.h"
31 #include "ViewportParams.h"
32 
33 namespace Marble
34 {
35 
36 const int PositionMarker::sm_defaultSizeStep = 2;
37 const float PositionMarker::sm_resizeSteps[] = { 0.25, 0.5, 1.0, 2.0, 4.0 };
38 const int PositionMarker::sm_numResizeSteps = sizeof( sm_resizeSteps ) / sizeof( sm_resizeSteps[0] );
39 
40 PositionMarker::PositionMarker ()
41  : RenderPlugin( 0 ),
42  ui_configWidget( 0 ),
43  m_configDialog( 0 )
44 {
45 }
46 
47 PositionMarker::PositionMarker( const MarbleModel *marbleModel )
48  : RenderPlugin( marbleModel ),
49  m_isInitialized( false ),
50  m_useCustomCursor( false ),
51  m_defaultCursorPath( MarbleDirs::path( "svg/track_turtle.svg" ) ),
52  m_lastBoundingBox(),
53  ui_configWidget( 0 ),
54  m_configDialog( 0 ),
55  m_cursorPath( m_defaultCursorPath ),
56  m_cursorSize( 1.0 ),
57  m_accuracyColor( Oxygen::brickRed4 ),
58  m_trailColor( 0, 0, 255 ),
59  m_heading( 0.0 ),
60  m_showTrail ( false )
61 {
62  const bool smallScreen = MarbleGlobal::getInstance()->profiles() & MarbleGlobal::SmallScreen;
63  m_accuracyColor.setAlpha( smallScreen ? 80 : 40 );
64 }
65 
66 PositionMarker::~PositionMarker ()
67 {
68  delete ui_configWidget;
69  delete m_configDialog;
70 }
71 
72 QStringList PositionMarker::renderPosition() const
73 {
74  return QStringList( "HOVERS_ABOVE_SURFACE" );
75 }
76 
77 QString PositionMarker::renderPolicy() const
78 {
79  return "ALWAYS";
80 }
81 
82 QStringList PositionMarker::backendTypes() const
83 {
84  return QStringList( "positionmarker" );
85 }
86 
87 QString PositionMarker::name() const
88 {
89  return tr( "Position Marker" );
90 }
91 
92 QString PositionMarker::guiString() const
93 {
94  return tr( "&Position Marker" );
95 }
96 
97 QString PositionMarker::nameId() const
98 {
99  return QString( "positionMarker" );
100 }
101 
102 QString PositionMarker::version() const
103 {
104  return "1.0";
105 }
106 
107 QString PositionMarker::description() const
108 {
109  return tr( "draws a marker at the current position" );
110 }
111 
112 QString PositionMarker::copyrightYears() const
113 {
114  return "2009, 2010";
115 }
116 
117 QList<PluginAuthor> PositionMarker::pluginAuthors() const
118 {
119  return QList<PluginAuthor>()
120  << PluginAuthor( "Andrew Manson", "g.real.ate@gmail.com" )
121  << PluginAuthor( "Eckhart Woerner", "ewoerner@kde.org" )
122  << PluginAuthor( "Thibaut Gridel", "tgridel@free.fr" )
123  << PluginAuthor( "Daniel Marth", "danielmarth@gmx.at" );
124 }
125 
126 QIcon PositionMarker::icon() const
127 {
128  return QIcon(":/icons/positionmarker.png");
129 }
130 
131 QDialog *PositionMarker::configDialog()
132 {
133  if ( !m_configDialog ) {
134  // Initializing configuration dialog
135  m_configDialog = new QDialog();
136  ui_configWidget = new Ui::PositionMarkerConfigWidget;
137  ui_configWidget->setupUi( m_configDialog );
138  ui_configWidget->m_resizeSlider->setMaximum( sm_numResizeSteps - 1 );
139  readSettings();
140  connect( ui_configWidget->m_buttonBox, SIGNAL(accepted()),
141  SLOT(writeSettings()) );
142  connect( ui_configWidget->m_buttonBox, SIGNAL(rejected()),
143  SLOT(readSettings()) );
144  connect( ui_configWidget->m_buttonBox->button( QDialogButtonBox::RestoreDefaults ), SIGNAL(clicked()),
145  SLOT(restoreDefaultSettings()) );
146  QPushButton *applyButton = ui_configWidget->m_buttonBox->button( QDialogButtonBox::Apply );
147  connect( applyButton, SIGNAL(clicked()),
148  SLOT(writeSettings()) );
149  connect( ui_configWidget->m_fileChooserButton, SIGNAL(clicked()),
150  SLOT(chooseCustomCursor()) );
151  connect( ui_configWidget->m_resizeSlider, SIGNAL(valueChanged(int)),
152  SLOT(resizeCursor(int)) );
153  connect( ui_configWidget->m_acColorChooserButton, SIGNAL(clicked()),
154  SLOT(chooseColor()) );
155  connect( ui_configWidget->m_trailColorChooserButton, SIGNAL(clicked()),
156  SLOT(chooseColor()) );
157  }
158  return m_configDialog;
159 }
160 
161 void PositionMarker::initialize()
162 {
163  if ( marbleModel() ) {
164  connect( marbleModel()->positionTracking(), SIGNAL(gpsLocation(GeoDataCoordinates,qreal)),
165  this, SLOT(setPosition(GeoDataCoordinates)) );
166  m_isInitialized = true;
167  }
168  loadDefaultCursor();
169 }
170 
171 bool PositionMarker::isInitialized() const
172 {
173  return m_isInitialized;
174 }
175 
176 bool PositionMarker::render( GeoPainter *painter,
177  ViewportParams *viewport,
178  const QString& renderPos,
179  GeoSceneLayer * layer )
180 {
181  Q_UNUSED( renderPos )
182  Q_UNUSED( layer )
183 
184  bool const gpsActive = marbleModel()->positionTracking()->positionProviderPlugin() != 0;
185  if ( gpsActive ) {
186  m_lastBoundingBox = viewport->viewLatLonAltBox();
187 
188  if( m_currentPosition != m_previousPosition ) {
189  qreal screenPositionX, screenPositionY;
190  viewport->screenCoordinates( m_currentPosition, screenPositionX, screenPositionY );
191  const GeoDataCoordinates top( m_currentPosition.longitude(), m_currentPosition.latitude()+0.1 );
192  qreal screenTopX, screenTopY;
193  viewport->screenCoordinates( top, screenTopX, screenTopY );
194  qreal const correction = -90.0 + RAD2DEG * atan2( screenPositionY -screenTopY, screenPositionX - screenTopX );
195  const qreal rotation = m_heading + correction;
196 
197  if ( m_useCustomCursor ) {
198  QTransform transform;
199  transform.rotate( rotation );
200  bool const highQuality = painter->mapQuality() == HighQuality || painter->mapQuality() == PrintQuality;
201  Qt::TransformationMode const mode = highQuality ? Qt::SmoothTransformation : Qt::FastTransformation;
202  m_customCursorTransformed = m_customCursor.transformed( transform, mode );
203  } else {
204  // Calculate the scaled arrow shape
205  const QPointF baseX( m_cursorSize, 0.0 );
206  const QPointF baseY( 0.0, m_cursorSize );
207  const QPointF relativeLeft = - ( baseX * 9 ) + ( baseY * 9 );
208  const QPointF relativeRight = ( baseX * 9 ) + ( baseY * 9 );
209  const QPointF relativeTip = - ( baseY * 19.0 );
210  m_arrow = QPolygonF() << QPointF( 0.0, 0.0 ) << relativeLeft << relativeTip << relativeRight;
211 
212  // Rotate the shape according to the current direction and move it to the screen center
213  QMatrix transformation;
214  transformation.translate( screenPositionX, screenPositionY );
215  transformation.rotate( rotation );
216  m_arrow = m_arrow * transformation;
217 
218  m_dirtyRegion = QRegion();
219  m_dirtyRegion += ( m_arrow.boundingRect().toRect() );
220  m_dirtyRegion += ( m_previousArrow.boundingRect().toRect() );
221  }
222 
223  }
224 
225  painter->save();
226 
227  GeoDataAccuracy accuracy = marbleModel()->positionTracking()->accuracy();
228  if ( accuracy.horizontal > 0 && accuracy.horizontal < 1000 ) {
229  // Paint a circle indicating the position accuracy
230  painter->setPen( Qt::transparent );
231  int width = qRound( accuracy.horizontal * viewport->radius() / EARTH_RADIUS );
232  if ( MarbleGlobal::getInstance()->profiles() & MarbleGlobal::SmallScreen ) {
233  int arrowSize = qMax<int>( m_arrow.boundingRect().width(), m_arrow.boundingRect().height() );
234  width = qMax<int>( width, arrowSize + 10 );
235  }
236 
237  painter->setBrush( m_accuracyColor );
238  painter->drawEllipse( m_currentPosition, width, width );
239  }
240 
241  // Draw trail if requested.
242  if( m_showTrail ) {
243  painter->save();
244 
245  // Use selected color to draw trail.
246  painter->setBrush( m_trailColor );
247  painter->setPen( m_trailColor );
248 
249  // we don't draw m_trail[0] which is current position
250  for( int i = 1; i < m_trail.size(); ++i ) {
251  // Get screen coordinates from coordinates on the map.
252  qreal trailPointX, trailPointY;
253  viewport->screenCoordinates( m_trail[i], trailPointX, trailPointY );
254 
255  const int size = ( sm_numTrailPoints - i ) * 3;
256  QRectF trailRect;
257  trailRect.setX( trailPointX - size / 2.0 );
258  trailRect.setY( trailPointY - size / 2.0 );
259  trailRect.setWidth( size );
260  trailRect.setHeight( size );
261 
262  const qreal opacity = 1.0 - 0.15 * ( i - 1 );
263  painter->setOpacity( opacity );
264  painter->drawEllipse( trailRect );
265  }
266 
267  painter->restore();
268  }
269 
270  if( m_useCustomCursor)
271  {
272  painter->drawPixmap( m_currentPosition, m_customCursorTransformed );
273  }
274  else
275  {
276  painter->setPen( Qt::black );
277  painter->setBrush( Qt::white );
278  painter->drawPolygon( m_arrow );
279  }
280 
281  painter->restore();
282  m_previousArrow = m_arrow;
283  }
284  return true;
285 }
286 
287 QHash<QString,QVariant> PositionMarker::settings() const
288 {
289  QHash<QString, QVariant> settings = RenderPlugin::settings();
290 
291  settings.insert( "useCustomCursor", m_useCustomCursor );
292  settings.insert( "cursorPath", m_cursorPath );
293  settings.insert( "cursorSize", m_cursorSize );
294  settings.insert( "acColor", m_accuracyColor );
295  settings.insert( "trailColor", m_trailColor );
296  settings.insert( "showTrail", m_showTrail );
297 
298  return settings;
299 }
300 
301 void PositionMarker::setSettings( const QHash<QString, QVariant> &settings )
302 {
303  RenderPlugin::setSettings( settings );
304 
305  const bool smallScreen = MarbleGlobal::getInstance()->profiles() & MarbleGlobal::SmallScreen;
306  QColor defaultColor = Oxygen::brickRed4;
307  defaultColor.setAlpha( smallScreen ? 80 : 40 );
308 
309  m_useCustomCursor = settings.value( "useCustomCursor", false ).toBool();
310  m_cursorPath = settings.value( "cursorPath", m_defaultCursorPath ).toString();
311  m_cursorSize = settings.value( "cursorSize", 1.0 ).toFloat();
312  loadCustomCursor( m_cursorPath, m_useCustomCursor );
313 
314  m_accuracyColor = settings.value( "acColor", defaultColor ).value<QColor>();
315  m_trailColor = settings.value( "trailColor", QColor( 0, 0, 255 ) ).value<QColor>();
316  m_showTrail = settings.value( "showTrail", false ).toBool();
317 
318  readSettings();
319 }
320 
321 void PositionMarker::readSettings()
322 {
323  if ( !m_configDialog ) {
324  return;
325  }
326 
327  if( m_useCustomCursor )
328  ui_configWidget->m_customCursor->click();
329  else
330  ui_configWidget->m_originalCursor->click();
331 
332  bool found = false;
333  float cursorSize = m_cursorSize;
334  for( int i = 0; i < sm_numResizeSteps && !found; i++ )
335  {
336  if( sm_resizeSteps[i] == cursorSize )
337  {
338  ui_configWidget->m_resizeSlider->setValue( i );
339  found = true;
340  }
341  }
342  if( !found )
343  {
344  ui_configWidget->m_resizeSlider->setValue( sm_defaultSizeStep );
345  cursorSize = sm_resizeSteps[sm_defaultSizeStep];
346  }
347 
348  ui_configWidget->m_sizeLabel->setText( tr( "Cursor Size: %1" ).arg( cursorSize ) );
349  QPalette palette = ui_configWidget->m_acColorChooserButton->palette();
350  palette.setColor( QPalette::Button, m_accuracyColor );
351  ui_configWidget->m_acColorChooserButton->setPalette( palette );
352  palette = ui_configWidget->m_trailColorChooserButton->palette();
353  palette.setColor( QPalette::Button, m_trailColor );
354  ui_configWidget->m_trailColorChooserButton->setPalette( palette );
355  ui_configWidget->m_trailCheckBox->setChecked( m_showTrail );
356 }
357 
358 void PositionMarker::writeSettings()
359 {
360  if ( !m_configDialog ) {
361  return;
362  }
363 
364  m_useCustomCursor = ui_configWidget->m_customCursor->isChecked();
365  m_cursorPath = m_cursorPath;
366  m_cursorSize = sm_resizeSteps[ui_configWidget->m_resizeSlider->value()];
367  m_accuracyColor = m_accuracyColor;
368  m_trailColor = m_trailColor;
369  m_showTrail = ui_configWidget->m_trailCheckBox->isChecked();
370 
371  emit settingsChanged( nameId() );
372 }
373 
374 void PositionMarker::setPosition( const GeoDataCoordinates &position )
375 {
376  m_previousPosition = m_currentPosition;
377  m_currentPosition = position;
378  m_heading = marbleModel()->positionTracking()->direction();
379  // Update the trail
380  m_trail.push_front( m_currentPosition );
381  for( int i = sm_numTrailPoints + 1; i< m_trail.size(); ++i ) {
382  m_trail.pop_back();
383  }
384  if ( m_lastBoundingBox.contains( m_currentPosition ) )
385  {
386  emit repaintNeeded( m_dirtyRegion );
387  }
388 }
389 
390 void PositionMarker::chooseCustomCursor()
391 {
392  QString filename = QFileDialog::getOpenFileName( NULL, tr( "Choose Custom Cursor" ) );
393  if( !filename.isEmpty() )
394  loadCustomCursor( filename, true );
395 }
396 
397 void PositionMarker::loadCustomCursor( const QString& filename, bool useCursor )
398 {
399  m_customCursor = QPixmap( filename ).scaled( 22 * m_cursorSize, 22 * m_cursorSize, Qt::KeepAspectRatio, Qt::SmoothTransformation );
400  if( !m_customCursor.isNull() )
401  {
402  if( m_configDialog )
403  {
404  if( useCursor )
405  ui_configWidget->m_customCursor->click();
406  ui_configWidget->m_fileChooserButton->setIconSize( QSize( m_customCursor.width(), m_customCursor.height() ) );
407  ui_configWidget->m_fileChooserButton->setIcon( QIcon( m_customCursor ) );
408  }
409  m_cursorPath = filename;
410  }
411  else
412  {
413  mDebug() << "Unable to load custom cursor from " << filename << ". "
414  << "The default cursor will be used instead";
415  if ( m_configDialog )
416  ui_configWidget->m_fileChooserButton->setIcon( QIcon( m_defaultCursor ) );
417  m_customCursor = m_defaultCursor;
418  m_cursorPath = m_defaultCursorPath;
419  }
420 }
421 
422 void PositionMarker::loadDefaultCursor()
423 {
424  m_defaultCursor = QPixmap( m_defaultCursorPath ).scaled( 22 * m_cursorSize, 22 * m_cursorSize, Qt::KeepAspectRatio, Qt::SmoothTransformation );
425 }
426 
427 void PositionMarker::chooseColor()
428 {
429  QColor initialColor;
430  if( sender() == ui_configWidget->m_acColorChooserButton ) {
431  initialColor = m_accuracyColor;
432  }
433  else if( sender() == ui_configWidget->m_trailColorChooserButton ) {
434  initialColor = m_trailColor;
435  }
436  QColor color = QColorDialog::getColor( initialColor, NULL,
437  tr( "Please choose a color" ),
438  QColorDialog::ShowAlphaChannel );
439  if( color.isValid() )
440  {
441  QPalette palette;
442  if( sender() == ui_configWidget->m_acColorChooserButton ) {
443  m_accuracyColor = color;
444  palette = ui_configWidget->m_acColorChooserButton->palette();
445  palette.setColor( QPalette::Button, m_accuracyColor );
446  ui_configWidget->m_acColorChooserButton->setPalette( palette );
447  }
448  else if( sender() == ui_configWidget->m_trailColorChooserButton ) {
449  m_trailColor = color;
450  palette = ui_configWidget->m_trailColorChooserButton->palette();
451  palette.setColor( QPalette::Button, m_trailColor );
452  ui_configWidget->m_trailColorChooserButton->setPalette( palette );
453  }
454  }
455 }
456 
457 void PositionMarker::resizeCursor( int step )
458 {
459  m_cursorSize = sm_resizeSteps[step];
460  float newSize = 22 * m_cursorSize;
461  m_customCursor = QPixmap( m_cursorPath ).scaled( newSize, newSize, Qt::KeepAspectRatio, Qt::SmoothTransformation );
462  ui_configWidget->m_sizeLabel->setText( tr( "Cursor Size: %1" ).arg( m_cursorSize ) );
463  if( !m_customCursor.isNull() )
464  {
465  ui_configWidget->m_fileChooserButton->setIconSize( QSize( m_customCursor.width(), m_customCursor.height() ) );
466  ui_configWidget->m_fileChooserButton->setIcon( QIcon( m_customCursor ) );
467  }
468  loadDefaultCursor();
469 }
470 
471 qreal PositionMarker::zValue() const
472 {
473  return 1.0;
474 }
475 
476 }
477 
478 Q_EXPORT_PLUGIN2( PositionMarker, Marble::PositionMarker )
479 
480 #include "PositionMarker.moc"
Marble::PositionTracking::positionProviderPlugin
PositionProviderPlugin positionProviderPlugin
Definition: PositionTracking.h:35
Marble::RAD2DEG
const qreal RAD2DEG
Definition: MarbleGlobal.h:201
Marble::PositionTracking::direction
qreal direction() const
provides direction of the gps device in degrees with geographical north
Definition: PositionTracking.cpp:233
Marble::PositionMarker::resizeCursor
void resizeCursor(int step)
Definition: PositionMarker.cpp:457
Marble::GeoDataCoordinates
A 3d point representation.
Definition: GeoDataCoordinates.h:52
Marble::GeoPainter::drawPolygon
void drawPolygon(const GeoDataLinearRing &linearRing, Qt::FillRule fillRule=Qt::OddEvenFill)
Draws a given linear ring (a "polygon without holes").
Definition: GeoPainter.cpp:560
Marble::PositionMarker::backendTypes
QStringList backendTypes() const
Returns the name(s) of the backend that the plugin can render This method should return the name of t...
Definition: PositionMarker.cpp:82
Marble::RenderPlugin::repaintNeeded
void repaintNeeded(QRegion dirtyRegion=QRegion())
This signal is emitted if an update of the view is needed.
QDialog
Marble::PositionMarker::settings
virtual QHash< QString, QVariant > settings() const
Definition: PositionMarker.cpp:287
Marble::GeoPainter
A painter that allows to draw geometric primitives on the map.
Definition: GeoPainter.h:98
MarbleModel.h
This file contains the headers for MarbleModel.
Marble::PluginAuthor
Definition: PluginInterface.h:28
Marble::PositionMarker::configDialog
QDialog * configDialog()
Returns a pointer to the configuration dialog of the plugin.
Definition: PositionMarker.cpp:131
Marble::PositionMarker
Definition: PositionMarker.h:35
Marble::PositionMarker::PositionMarker
PositionMarker()
Definition: PositionMarker.cpp:40
Marble::ViewportParams::viewLatLonAltBox
const GeoDataLatLonAltBox & viewLatLonAltBox() const
Definition: ViewportParams.cpp:305
Marble::RenderPlugin::restoreDefaultSettings
void restoreDefaultSettings()
Passes an empty set of settings to the plugin.
Definition: RenderPlugin.cpp:214
Marble::PrintQuality
Print quality.
Definition: MarbleGlobal.h:85
Marble::GeoDataCoordinates::latitude
qreal latitude(GeoDataCoordinates::Unit unit=GeoDataCoordinates::Radian) const
retrieves the latitude of the GeoDataCoordinates object use the unit parameter to switch between Radi...
Definition: GeoDataCoordinates.cpp:751
Marble::GeoPainter::drawEllipse
void drawEllipse(const GeoDataCoordinates &centerPosition, qreal width, qreal height, bool isGeoProjected=false)
Draws an ellipse at the given position. The ellipse is placed with its center located at the given ce...
Definition: GeoPainter.cpp:289
Marble::GeoDataLatLonAltBox::contains
virtual bool contains(const GeoDataCoordinates &) const
Definition: GeoDataLatLonAltBox.cpp:171
MarbleDebug.h
Marble::PositionMarker::chooseCustomCursor
void chooseCustomCursor()
Definition: PositionMarker.cpp:390
Marble::PositionMarker::pluginAuthors
QList< PluginAuthor > pluginAuthors() const
Definition: PositionMarker.cpp:117
Marble::PositionTracking::accuracy
GeoDataAccuracy accuracy() const
Returns the estimated accuracy of the current position.
Definition: PositionTracking.cpp:383
Marble::PositionMarker::copyrightYears
QString copyrightYears() const
Definition: PositionMarker.cpp:112
Marble::PositionMarker::setSettings
virtual void setSettings(const QHash< QString, QVariant > &settings)
Set the settings of the item.
Definition: PositionMarker.cpp:301
Marble::GeoSceneLayer
Layer of a GeoScene document.
Definition: GeoSceneLayer.h:43
Marble::EARTH_RADIUS
const qreal EARTH_RADIUS
Definition: MarbleGlobal.h:238
Marble::PositionMarker::nameId
QString nameId() const
Returns the unique name of the plugin.
Definition: PositionMarker.cpp:97
Marble::RenderPlugin::settingsChanged
void settingsChanged(QString nameId)
This signal is emitted if the settings of the RenderPlugin changed.
Marble::PositionMarker::renderPosition
QStringList renderPosition() const
Preferred level in the layer stack for the rendering.
Definition: PositionMarker.cpp:72
MarbleDirs.h
Marble::MarbleModel::positionTracking
PositionTracking * positionTracking() const
Definition: MarbleModel.cpp:442
Marble::MarbleDirs
A class that manages data look-up for Marble.
Definition: MarbleDirs.h:79
Marble::GeoDataAccuracy::horizontal
qreal horizontal
Horizontal accuracy in meters.
Definition: GeoDataAccuracy.h:47
Marble::PositionMarker::guiString
QString guiString() const
String that should be displayed in GUI.
Definition: PositionMarker.cpp:92
Marble::PositionMarker::render
bool render(GeoPainter *painter, ViewportParams *viewport, const QString &renderPos, GeoSceneLayer *layer=0)
Renders the content provided by the layer on the viewport.
Definition: PositionMarker.cpp:176
Marble::ViewportParams::screenCoordinates
bool screenCoordinates(const qreal lon, const qreal lat, qreal &x, qreal &y) const
Get the screen coordinates corresponding to geographical coordinates in the map.
Definition: ViewportParams.cpp:357
GeoPainter.h
PositionMarker.h
Marble::ViewportParams
A public class that controls what is visible in the viewport of a Marble map.
Definition: ViewportParams.h:44
Q_EXPORT_PLUGIN2
#define Q_EXPORT_PLUGIN2(a, b)
Definition: marble_export.h:34
Marble::PositionMarker::writeSettings
void writeSettings()
Definition: PositionMarker.cpp:358
Marble::PositionMarker::readSettings
void readSettings()
Definition: PositionMarker.cpp:321
Marble::PositionMarker::description
QString description() const
Returns a user description of the plugin.
Definition: PositionMarker.cpp:107
Marble::GeoDataCoordinates::longitude
qreal longitude(GeoDataCoordinates::Unit unit=GeoDataCoordinates::Radian) const
retrieves the longitude of the GeoDataCoordinates object use the unit parameter to switch between Rad...
Definition: GeoDataCoordinates.cpp:739
ViewportParams.h
This file contains the headers for ViewportParams.
Marble::MarbleGlobal::SmallScreen
Definition: MarbleGlobal.h:268
Marble::MarbleGlobal::getInstance
static MarbleGlobal * getInstance()
Definition: MarbleGlobal.cpp:37
Marble::PositionMarker::chooseColor
void chooseColor()
Definition: PositionMarker.cpp:427
Marble::PositionMarker::isInitialized
bool isInitialized() const
Definition: PositionMarker.cpp:171
Marble::Oxygen::brickRed4
QColor const brickRed4
Definition: MarbleColors.h:32
Marble::MarbleModel
The data model (not based on QAbstractModel) for a MarbleWidget.
Definition: MarbleModel.h:96
Marble::PositionMarker::icon
QIcon icon() const
Returns an icon for the plugin.
Definition: PositionMarker.cpp:126
Marble::ViewportParams::radius
int radius() const
Definition: ViewportParams.cpp:195
Marble::HighQuality
High quality (e.g. antialiasing for lines)
Definition: MarbleGlobal.h:84
Marble::PositionMarker::zValue
virtual qreal zValue() const
Returns the z value of the layer (default: 0.0).
Definition: PositionMarker.cpp:471
Marble::PositionMarker::version
QString version() const
Definition: PositionMarker.cpp:102
Marble::MarbleGlobal::profiles
Profiles profiles() const
Definition: MarbleGlobal.cpp:48
Marble::PositionMarker::name
QString name() const
Returns the user-visible name of the plugin.
Definition: PositionMarker.cpp:87
Marble::GeoPainter::mapQuality
MapQuality mapQuality() const
Returns the map quality.
Definition: GeoPainter.cpp:191
PositionTracking.h
Marble::PositionMarker::~PositionMarker
~PositionMarker()
Definition: PositionMarker.cpp:66
Marble::RenderPlugin::marbleModel
const MarbleModel * marbleModel() const
Access to the MarbleModel.
Definition: RenderPlugin.cpp:81
Marble::GeoDataAccuracy
Definition: GeoDataAccuracy.h:22
Marble::RenderPlugin::settings
virtual QHash< QString, QVariant > settings() const
Settings of the plugin.
Definition: RenderPlugin.cpp:183
Marble::PositionMarker::renderPolicy
QString renderPolicy() const
Return how the plugin settings should be used.
Definition: PositionMarker.cpp:77
Marble::PositionMarker::initialize
void initialize()
Definition: PositionMarker.cpp:161
Marble::mDebug
QDebug mDebug()
a function to replace qDebug() in Marble library code
Definition: MarbleDebug.cpp:31
Marble::PositionMarker::setPosition
void setPosition(const GeoDataCoordinates &position)
Definition: PositionMarker.cpp:374
Marble::GeoPainter::drawPixmap
void drawPixmap(const GeoDataCoordinates &centerPosition, const QPixmap &pixmap)
Draws a pixmap at the given position. The pixmap is placed with its center located at the given cente...
Definition: GeoPainter.cpp:452
Marble::RenderPlugin
The abstract class that creates a renderable item.
Definition: RenderPlugin.h:43
Marble::RenderPlugin::setSettings
virtual void setSettings(const QHash< QString, QVariant > &settings)
Set the settings of the plugin.
Definition: RenderPlugin.cpp:193
This file is part of the KDE documentation.
Documentation copyright © 1996-2014 The KDE developers.
Generated on Tue Oct 14 2014 22:38:52 by doxygen 1.8.7 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

marble

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

kdeedu API Reference

Skip menu "kdeedu API Reference"
  • Analitza
  •     lib
  • kalgebra
  • kalzium
  •   libscience
  • kanagram
  • kig
  •   lib
  • klettres
  • kstars
  • libkdeedu
  •   keduvocdocument
  • marble
  • parley
  • rocs
  •   App
  •   RocsCore
  •   VisualEditor
  •   stepcore

Search



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

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