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

marble

  • sources
  • kde-4.14
  • kdeedu
  • marble
  • src
  • lib
  • marble
FileLoader.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 2008 Patrick Spendrin <ps_ml@gmx.de>
9 //
10 
11 #include "FileLoader.h"
12 
13 #include <QBuffer>
14 #include <QDataStream>
15 #include <QDateTime>
16 #include <QFile>
17 #include <QThread>
18 
19 #include "GeoDataParser.h"
20 #include "GeoDataDocument.h"
21 #include "GeoDataFolder.h"
22 #include "GeoDataPlacemark.h"
23 #include "GeoDataData.h"
24 #include "GeoDataExtendedData.h"
25 #include "GeoDataStyleMap.h"
26 #include "GeoDataPolyStyle.h"
27 #include "GeoDataLineStyle.h"
28 #include "GeoDataStyle.h"
29 #include "GeoDataTypes.h"
30 #include "MarbleClock.h"
31 #include "MarbleDirs.h"
32 #include "MarbleDebug.h"
33 #include "MarbleModel.h"
34 #include "ParsingRunnerManager.h"
35 
36 namespace Marble
37 {
38 
39 class FileLoaderPrivate
40 {
41 public:
42  FileLoaderPrivate( FileLoader* parent, MarbleModel *model, bool recenter,
43  const QString& file, const QString& property, const GeoDataStyle* style, DocumentRole role )
44  : q( parent),
45  m_runner( model->pluginManager() ),
46  m_recenter( recenter ),
47  m_filepath ( file ),
48  m_property( property ),
49  m_style( style ),
50  m_documentRole ( role ),
51  m_styleMap( new GeoDataStyleMap ),
52  m_document( 0 ),
53  m_clock( model->clock() )
54  {
55  if( m_style ) {
56  m_styleMap->setId("default-map");
57  m_styleMap->insert("normal", QString("#").append(m_style->id()));
58  }
59  }
60 
61  FileLoaderPrivate( FileLoader* parent, MarbleModel *model,
62  const QString& contents, const QString& file, DocumentRole role )
63  : q( parent ),
64  m_runner( model->pluginManager() ),
65  m_recenter( false ),
66  m_filepath ( file ),
67  m_contents ( contents ),
68  m_style( 0 ),
69  m_documentRole ( role ),
70  m_styleMap( 0 ),
71  m_document( 0 ),
72  m_clock( model->clock() )
73  {
74  }
75 
76  ~FileLoaderPrivate()
77  {
78  delete m_style;
79  delete m_styleMap;
80  }
81 
82  void createFilterProperties( GeoDataContainer *container );
83  static int cityPopIdx( qint64 population );
84  static int spacePopIdx( qint64 population );
85  static int areaPopIdx( qreal area );
86 
87  void documentParsed( GeoDataDocument *doc, const QString& error);
88 
89  FileLoader *q;
90  ParsingRunnerManager m_runner;
91  bool m_recenter;
92  QString m_filepath;
93  QString m_contents;
94  QString m_property;
95  const GeoDataStyle *const m_style;
96  DocumentRole m_documentRole;
97  GeoDataStyleMap* m_styleMap;
98  GeoDataDocument *m_document;
99  QString m_error;
100 
101  const MarbleClock *m_clock;
102 };
103 
104 FileLoader::FileLoader( QObject* parent, MarbleModel *model, bool recenter,
105  const QString& file, const QString& property, const GeoDataStyle* style, DocumentRole role )
106  : QThread( parent ),
107  d( new FileLoaderPrivate( this, model, recenter, file, property, style, role ) )
108 {
109 }
110 
111 FileLoader::FileLoader( QObject* parent, MarbleModel *model,
112  const QString& contents, const QString& file, DocumentRole role )
113  : QThread( parent ),
114  d( new FileLoaderPrivate( this, model, contents, file, role ) )
115 {
116 }
117 
118 FileLoader::~FileLoader()
119 {
120  delete d;
121 }
122 
123 QString FileLoader::path() const
124 {
125  return d->m_filepath;
126 }
127 
128 GeoDataDocument* FileLoader::document()
129 {
130  return d->m_document;
131 }
132 
133 QString FileLoader::error() const
134 {
135  return d->m_error;
136 }
137 
138 void FileLoader::run()
139 {
140  if ( d->m_contents.isEmpty() ) {
141  QString defaultSourceName;
142 
143  mDebug() << "starting parser for" << d->m_filepath;
144 
145  QFileInfo fileinfo( d->m_filepath );
146  QString path = fileinfo.path();
147  if ( path == "." ) path.clear();
148  QString name = fileinfo.completeBaseName();
149  QString suffix = fileinfo.suffix();
150 
151  // determine source, cache names
152  if ( fileinfo.isAbsolute() ) {
153  // We got an _absolute_ path now: e.g. "/patrick.kml"
154  defaultSourceName = path + '/' + name + '.' + suffix;
155  }
156  else if ( d->m_filepath.contains( '/' ) ) {
157  // _relative_ path: "maps/mars/viking/patrick.kml"
158  defaultSourceName = MarbleDirs::path( path + '/' + name + '.' + suffix );
159  if ( !QFile::exists( defaultSourceName ) ) {
160  defaultSourceName = MarbleDirs::path( path + '/' + name + ".cache" );
161  }
162  }
163  else {
164  // _standard_ shared placemarks: "placemarks/patrick.kml"
165  defaultSourceName = MarbleDirs::path( "placemarks/" + path + name + '.' + suffix );
166  if ( !QFile::exists( defaultSourceName ) ) {
167  defaultSourceName = MarbleDirs::path( "placemarks/" + path + name + ".cache" );
168  }
169  }
170 
171  if ( QFile::exists( defaultSourceName ) ) {
172  mDebug() << "No recent Default Placemark Cache File available!";
173 
174  // use runners: pnt, gpx, osm
175  connect( &d->m_runner, SIGNAL(parsingFinished(GeoDataDocument*,QString)),
176  this, SLOT(documentParsed(GeoDataDocument*,QString)) );
177  d->m_runner.parseFile( defaultSourceName, d->m_documentRole );
178  }
179  else {
180  mDebug() << "No Default Placemark Source File for " << name;
181  }
182  // content is not empty, we load from data
183  } else {
184  // Read the KML Data
185  GeoDataParser parser( GeoData_KML );
186 
187  QByteArray ba( d->m_contents.toUtf8() );
188  QBuffer buffer( &ba );
189  buffer.open( QIODevice::ReadOnly );
190 
191  if ( !parser.read( &buffer ) ) {
192  qWarning( "Could not import kml buffer!" );
193  emit loaderFinished( this );
194  return;
195  }
196 
197  GeoDocument* document = parser.releaseDocument();
198  Q_ASSERT( document );
199 
200  d->m_document = static_cast<GeoDataDocument*>( document );
201  d->m_document->setProperty( d->m_property );
202  d->m_document->setDocumentRole( d->m_documentRole );
203  d->createFilterProperties( d->m_document );
204  buffer.close();
205 
206  mDebug() << "newGeoDataDocumentAdded" << d->m_filepath;
207 
208  emit newGeoDataDocumentAdded( d->m_document );
209  emit loaderFinished( this );
210  }
211 
212 }
213 
214 bool FileLoader::recenter() const
215 {
216  return d->m_recenter;
217 }
218 
219 void FileLoaderPrivate::documentParsed( GeoDataDocument* doc, const QString& error )
220 {
221  m_error = error;
222  if ( doc ) {
223  m_document = doc;
224  doc->setProperty( m_property );
225  if( m_style ) {
226  doc->addStyleMap( *m_styleMap );
227  doc->addStyle( *m_style );
228  }
229 
230  createFilterProperties( doc );
231  emit q->newGeoDataDocumentAdded( m_document );
232  }
233  emit q->loaderFinished( q );
234 }
235 
236 void FileLoaderPrivate::createFilterProperties( GeoDataContainer *container )
237 {
238  QVector<GeoDataFeature*>::Iterator i = container->begin();
239  QVector<GeoDataFeature*>::Iterator const end = container->end();
240  for (; i != end; ++i ) {
241  if ( (*i)->nodeType() == GeoDataTypes::GeoDataFolderType
242  || (*i)->nodeType() == GeoDataTypes::GeoDataDocumentType ) {
243  GeoDataContainer *child = static_cast<GeoDataContainer*>( *i );
244  createFilterProperties( child );
245  } else if ( (*i)->nodeType() == GeoDataTypes::GeoDataTourType
246  || (*i)->nodeType() == GeoDataTypes::GeoDataGroundOverlayType
247  || (*i)->nodeType() == GeoDataTypes::GeoDataPhotoOverlayType
248  || (*i)->nodeType() == GeoDataTypes::GeoDataScreenOverlayType ) {
250  } else if ( (*i)->nodeType() == GeoDataTypes::GeoDataPlacemarkType ) {
251  Q_ASSERT( dynamic_cast<GeoDataPlacemark*>( *i ) );
252 
253  GeoDataPlacemark* placemark = static_cast<GeoDataPlacemark*>( *i );
254  Q_ASSERT( placemark->geometry() );
255 
256  bool hasPopularity = false;
257 
258  if ( placemark->geometry()->nodeType() != GeoDataTypes::GeoDataTrackType &&
259  placemark->geometry()->nodeType() != GeoDataTypes::GeoDataPointType
260  && m_documentRole == MapDocument
261  && m_style ) {
262  placemark->setStyleUrl( QString("#").append( m_styleMap->id() ) );
263  }
264 
265  // Mountain (H), Volcano (V), Shipwreck (W)
266  if ( placemark->role() == "H" || placemark->role() == "V" || placemark->role() == "W" )
267  {
268  qreal altitude = placemark->coordinate().altitude();
269  if ( altitude != 0.0 )
270  {
271  hasPopularity = true;
272  placemark->setPopularity( (qint64)(altitude * 1000.0) );
273  placemark->setZoomLevel( cityPopIdx( qAbs( (qint64)(altitude * 1000.0) ) ) );
274  }
275  }
276  // Continent (K), Ocean (O), Nation (S)
277  else if ( placemark->role() == "K" || placemark->role() == "O" || placemark->role() == "S" )
278  {
279  qreal area = placemark->area();
280  if ( area >= 0.0 )
281  {
282  hasPopularity = true;
283  // mDebug() << placemark->name() << " " << (qint64)(area);
284  placemark->setPopularity( (qint64)(area * 100) );
285  placemark->setZoomLevel( areaPopIdx( area ) );
286  }
287  }
288  // Pole (P)
289  else if ( placemark->role() == "P" )
290  {
291  placemark->setPopularity( 1000000000 );
292  placemark->setZoomLevel( 1 );
293  }
294  // Magnetic Pole (M)
295  else if ( placemark->role() == "M" )
296  {
297  placemark->setPopularity( 10000000 );
298  placemark->setZoomLevel( 3 );
299  }
300  // MannedLandingSite (h)
301  else if ( placemark->role() == "h" )
302  {
303  placemark->setPopularity( 1000000000 );
304  placemark->setZoomLevel( 1 );
305  }
306  // RoboticRover (r)
307  else if ( placemark->role() == "r" )
308  {
309  placemark->setPopularity( 10000000 );
310  placemark->setZoomLevel( 2 );
311  }
312  // UnmannedSoftLandingSite (u)
313  else if ( placemark->role() == "u" )
314  {
315  placemark->setPopularity( 1000000 );
316  placemark->setZoomLevel( 3 );
317  }
318  // UnmannedSoftLandingSite (i)
319  else if ( placemark->role() == "i" )
320  {
321  placemark->setPopularity( 1000000 );
322  placemark->setZoomLevel( 3 );
323  }
324  // Space Terrain: Craters, Maria, Montes, Valleys, etc.
325  else if ( placemark->role() == "m" || placemark->role() == "v"
326  || placemark->role() == "o" || placemark->role() == "c"
327  || placemark->role() == "a" )
328  {
329  qint64 diameter = placemark->population();
330  if ( diameter >= 0 )
331  {
332  hasPopularity = true;
333  placemark->setPopularity( diameter );
334  if ( placemark->role() == "c" ) {
335  placemark->setZoomLevel( spacePopIdx( diameter ) );
336  if ( placemark->name() == "Tycho" || placemark->name() == "Copernicus" ) {
337  placemark->setZoomLevel( 1 );
338  }
339  }
340  else {
341  placemark->setZoomLevel( spacePopIdx( diameter ) );
342  }
343 
344  if ( placemark->role() == "a" && diameter == 0 ) {
345  placemark->setPopularity( 1000000000 );
346  placemark->setZoomLevel( 1 );
347  }
348  }
349  }
350  else
351  {
352  qint64 population = placemark->population();
353  if ( population >= 0 )
354  {
355  hasPopularity = true;
356  placemark->setPopularity( population );
357  placemark->setZoomLevel( cityPopIdx( population ) );
358  }
359  }
360 
361  // Then we set the visual category:
362 
363  if ( placemark->role() == "H" ) placemark->setVisualCategory( GeoDataPlacemark::Mountain );
364  else if ( placemark->role() == "V" ) placemark->setVisualCategory( GeoDataPlacemark::Volcano );
365 
366  else if ( placemark->role() == "m" ) placemark->setVisualCategory( GeoDataPlacemark::Mons );
367  else if ( placemark->role() == "v" ) placemark->setVisualCategory( GeoDataPlacemark::Valley );
368  else if ( placemark->role() == "o" ) placemark->setVisualCategory( GeoDataPlacemark::OtherTerrain );
369  else if ( placemark->role() == "c" ) placemark->setVisualCategory( GeoDataPlacemark::Crater );
370  else if ( placemark->role() == "a" ) placemark->setVisualCategory( GeoDataPlacemark::Mare );
371 
372  else if ( placemark->role() == "P" ) placemark->setVisualCategory( GeoDataPlacemark::GeographicPole );
373  else if ( placemark->role() == "M" ) placemark->setVisualCategory( GeoDataPlacemark::MagneticPole );
374  else if ( placemark->role() == "W" ) placemark->setVisualCategory( GeoDataPlacemark::ShipWreck );
375  else if ( placemark->role() == "F" ) placemark->setVisualCategory( GeoDataPlacemark::AirPort );
376  else if ( placemark->role() == "A" ) placemark->setVisualCategory( GeoDataPlacemark::Observatory );
377  else if ( placemark->role() == "K" ) placemark->setVisualCategory( GeoDataPlacemark::Continent );
378  else if ( placemark->role() == "O" ) placemark->setVisualCategory( GeoDataPlacemark::Ocean );
379  else if ( placemark->role() == "S" ) placemark->setVisualCategory( GeoDataPlacemark::Nation );
380  else
381  if ( placemark->role()=="PPL"
382  || placemark->role()=="PPLF"
383  || placemark->role()=="PPLG"
384  || placemark->role()=="PPLL"
385  || placemark->role()=="PPLQ"
386  || placemark->role()=="PPLR"
387  || placemark->role()=="PPLS"
388  || placemark->role()=="PPLW" ) placemark->setVisualCategory(
389  ( GeoDataPlacemark::GeoDataVisualCategory )( GeoDataPlacemark::SmallCity
390  + (( 20- ( 2*placemark->zoomLevel()) ) / 4 * 4 ) ) );
391  else if ( placemark->role() == "PPLA" ) placemark->setVisualCategory(
392  ( GeoDataPlacemark::GeoDataVisualCategory )( GeoDataPlacemark::SmallStateCapital
393  + (( 20- ( 2*placemark->zoomLevel()) ) / 4 * 4 ) ) );
394  else if ( placemark->role()=="PPLC" ) placemark->setVisualCategory(
395  ( GeoDataPlacemark::GeoDataVisualCategory )( GeoDataPlacemark::SmallNationCapital
396  + (( 20- ( 2*placemark->zoomLevel()) ) / 4 * 4 ) ) );
397  else if ( placemark->role()=="PPLA2" || placemark->role()=="PPLA3" ) placemark->setVisualCategory(
398  ( GeoDataPlacemark::GeoDataVisualCategory )( GeoDataPlacemark::SmallCountyCapital
399  + (( 20- ( 2*placemark->zoomLevel()) ) / 4 * 4 ) ) );
400  else if ( placemark->role()==" " && !hasPopularity && placemark->visualCategory() == GeoDataPlacemark::Unknown ) {
401  placemark->setVisualCategory( GeoDataPlacemark::Unknown ); // default location
402  placemark->setZoomLevel(0);
403  }
404  else if ( placemark->role() == "h" ) placemark->setVisualCategory( GeoDataPlacemark::MannedLandingSite );
405  else if ( placemark->role() == "r" ) placemark->setVisualCategory( GeoDataPlacemark::RoboticRover );
406  else if ( placemark->role() == "u" ) placemark->setVisualCategory( GeoDataPlacemark::UnmannedSoftLandingSite );
407  else if ( placemark->role() == "i" ) placemark->setVisualCategory( GeoDataPlacemark::UnmannedHardLandingSite );
408 
409  if ( placemark->role() == "W" && placemark->zoomLevel() < 4 )
410  placemark->setZoomLevel( 4 );
411  if ( placemark->role() == "O" )
412  placemark->setZoomLevel( 2 );
413  if ( placemark->role() == "K" )
414  placemark->setZoomLevel( 0 );
415  if ( !placemark->isVisible() ) {
416  placemark->setZoomLevel( 18 );
417  }
418  // Workaround: Emulate missing "setVisible" serialization by allowing for population
419  // values smaller than -1 which are considered invisible.
420  if ( placemark->population() < -1 ) {
421  placemark->setZoomLevel( 18 );
422  }
423  } else {
424  qWarning() << Q_FUNC_INFO << "Unknown feature" << (*i)->nodeType() << ". Skipping.";
425  }
426  }
427 }
428 
429 int FileLoaderPrivate::cityPopIdx( qint64 population )
430 {
431  int popidx = 3;
432 
433  if ( population < 2500 ) popidx=10;
434  else if ( population < 5000) popidx=9;
435  else if ( population < 25000) popidx=8;
436  else if ( population < 75000) popidx=7;
437  else if ( population < 250000) popidx=6;
438  else if ( population < 750000) popidx=5;
439  else if ( population < 2500000) popidx=4;
440 
441  return popidx;
442 }
443 
444 int FileLoaderPrivate::spacePopIdx( qint64 population )
445 {
446  int popidx = 1;
447 
448  if ( population < 1000 ) popidx=10;
449  else if ( population < 2000) popidx=9;
450  else if ( population < 8000) popidx=8;
451  else if ( population < 20000) popidx=7;
452  else if ( population < 60000) popidx=6;
453  else if ( population < 100000) popidx=5;
454  else if ( population < 200000 ) popidx=4;
455  else if ( population < 400000 ) popidx=2;
456  else if ( population < 600000 ) popidx=1;
457 
458  return popidx;
459 }
460 
461 int FileLoaderPrivate::areaPopIdx( qreal area )
462 {
463  int popidx = 1;
464  if ( area < 200000 ) popidx=5;
465  else if ( area < 1000000 ) popidx=4;
466  else if ( area < 2500000 ) popidx=3;
467  else if ( area < 5000000 ) popidx=2;
468 
469  return popidx;
470 }
471 
472 
473 
474 #include "FileLoader.moc"
475 } // namespace Marble
GeoDataDocument.h
Marble::GeoDataDocument::addStyleMap
void addStyleMap(const GeoDataStyleMap &map)
Add a stylemap to the stylemap storage.
Definition: GeoDataDocument.cpp:166
Marble::FileLoader::path
QString path() const
Definition: FileLoader.cpp:123
Marble::GeoDataDocument
A container for Features, Styles and in the future Schemas.
Definition: GeoDataDocument.h:65
Marble::GeoDataTypes::GeoDataPointType
const char * GeoDataPointType
Definition: GeoDataTypes.cpp:68
QFileInfo::path
QString path() const
Marble::GeoDataParser
Definition: GeoDataParser.h:40
Marble::MarbleDirs::path
static QString path(const QString &relativePath)
Definition: MarbleDirs.cpp:59
Marble::FileLoader::newGeoDataDocumentAdded
void newGeoDataDocumentAdded(GeoDataDocument *)
Marble::GeoDataFeature::Continent
Definition: GeoDataFeature.h:107
QVector::begin
iterator begin()
Marble::FileLoader::document
GeoDataDocument * document()
Definition: FileLoader.cpp:128
QByteArray
Marble::GeoDataFeature::Unknown
Definition: GeoDataFeature.h:80
Marble::GeoDataFeature::Mons
Definition: GeoDataFeature.h:105
Marble::GeoDataFeature::SmallNationCapital
Definition: GeoDataFeature.h:87
QFileInfo::isAbsolute
bool isAbsolute() const
MarbleModel.h
This file contains the headers for MarbleModel.
Marble::GeoDataFeature::Mountain
Definition: GeoDataFeature.h:103
Marble::GeoDataTypes::GeoDataPlacemarkType
const char * GeoDataPlacemarkType
Definition: GeoDataTypes.cpp:66
Marble::GeoDataTypes::GeoDataDocumentType
const char * GeoDataDocumentType
Definition: GeoDataTypes.cpp:38
GeoDataStyle.h
Marble::GeoDataFeature::Crater
Definition: GeoDataFeature.h:112
QBuffer
Marble::GeoDataTypes::GeoDataGroundOverlayType
const char * GeoDataGroundOverlayType
Definition: GeoDataTypes.cpp:44
GeoDataParser.h
Marble::GeoDataFeature::OtherTerrain
Definition: GeoDataFeature.h:109
GeoDataExtendedData.h
Marble::GeoDataFeature::Valley
Definition: GeoDataFeature.h:106
QFile::exists
bool exists() const
FileLoader.h
Marble::GeoDataFeature::AirPort
Definition: GeoDataFeature.h:119
GeoDataLineStyle.h
Marble::GeoDataFeature::Nation
Definition: GeoDataFeature.h:100
MarbleDebug.h
Marble::FileLoader::error
QString error() const
Definition: FileLoader.cpp:133
ParsingRunnerManager.h
Marble::GeoData_KML
Definition: GeoDataParser.h:36
QString::clear
void clear()
Marble::GeoDataFeature::SmallStateCapital
Definition: GeoDataFeature.h:86
QObject::name
const char * name() const
Marble::GeoDataStyle
an addressable style group
Definition: GeoDataStyle.h:55
Marble::GeoDataTypes::GeoDataScreenOverlayType
const char * GeoDataScreenOverlayType
Definition: GeoDataTypes.cpp:88
Marble::GeoParser::read
bool read(QIODevice *)
Main API for reading the XML document.
Definition: GeoParser.cpp:74
Marble::GeoDataFeature::MannedLandingSite
Definition: GeoDataFeature.h:128
Marble::GeoDataFeature::Volcano
Definition: GeoDataFeature.h:104
QObject
Marble::FileLoader::loaderFinished
void loaderFinished(FileLoader *)
Marble::GeoDataFeature::Ocean
Definition: GeoDataFeature.h:108
MarbleDirs.h
Marble::FileLoader::FileLoader
FileLoader(QObject *parent, MarbleModel *model, bool recenter, const QString &file, const QString &property, const GeoDataStyle *style, DocumentRole role)
Definition: FileLoader.cpp:104
Marble::GeoDataTypes::GeoDataFolderType
const char * GeoDataFolderType
Definition: GeoDataTypes.cpp:42
Marble::GeoDataDocument::addStyle
void addStyle(const GeoDataStyle &style)
Add a style to the style storage.
Definition: GeoDataDocument.cpp:134
QString
Marble::GeoDataTypes::GeoDataTourType
const char * GeoDataTourType
Definition: GeoDataTypes.cpp:83
GeoDataPlacemark.h
GeoDataStyleMap.h
QFileInfo
Marble::FileLoader::recenter
bool recenter() const
Definition: FileLoader.cpp:214
Marble::GeoDataFeature::MagneticPole
Definition: GeoDataFeature.h:117
MarbleClock.h
Marble::FileLoader::~FileLoader
virtual ~FileLoader()
Definition: FileLoader.cpp:118
Marble::FileLoader::run
void run()
Definition: FileLoader.cpp:138
Marble::MapDocument
Definition: GeoDataDocument.h:41
GeoDataFolder.h
Marble::MarbleModel
The data model (not based on QAbstractModel) for a MarbleWidget.
Definition: MarbleModel.h:97
GeoDataData.h
Marble::GeoDataFeature::RoboticRover
Definition: GeoDataFeature.h:129
Marble::GeoDataDocument::setProperty
void setProperty(QString property)
Definition: GeoDataDocument.cpp:96
QVector
QFileInfo::suffix
QString suffix() const
Marble::GeoDataFeature::UnmannedHardLandingSite
Definition: GeoDataFeature.h:131
Marble::GeoDocument
A shared base class between GeoDataDocument/GeoSourceDocument.
Definition: GeoDocument.h:42
Marble::GeoDataFeature::GeographicPole
Definition: GeoDataFeature.h:116
Marble::GeoDataFeature::SmallCountyCapital
Definition: GeoDataFeature.h:85
QFileInfo::completeBaseName
QString completeBaseName() const
Marble::GeoDataFeature::UnmannedSoftLandingSite
Definition: GeoDataFeature.h:130
Marble::GeoDataFeature::GeoDataVisualCategory
GeoDataVisualCategory
A categorization of a placemark as defined by ...FIXME.
Definition: GeoDataFeature.h:77
Marble::GeoDataFeature::Observatory
Definition: GeoDataFeature.h:120
GeoDataTypes.h
Marble::GeoDataTypes::GeoDataTrackType
const char * GeoDataTrackType
Definition: GeoDataTypes.cpp:86
QThread
QObject::connect
bool connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type)
QVector::end
iterator end()
Marble::mDebug
QDebug mDebug()
a function to replace qDebug() in Marble library code
Definition: MarbleDebug.cpp:36
Marble::DocumentRole
DocumentRole
Definition: GeoDataDocument.h:39
GeoDataPolyStyle.h
Marble::GeoDataFeature::ShipWreck
Definition: GeoDataFeature.h:118
Marble::GeoDataFeature::Mare
Definition: GeoDataFeature.h:113
Marble::GeoDataTypes::GeoDataPhotoOverlayType
const char * GeoDataPhotoOverlayType
Definition: GeoDataTypes.cpp:65
Marble::GeoParser::releaseDocument
GeoDocument * releaseDocument()
retrieve the parsed document and reset the parser If parsing was successful, retrieve the resulting d...
Definition: GeoParser.cpp:205
Marble::GeoDataFeature::SmallCity
Definition: GeoDataFeature.h:84
This file is part of the KDE documentation.
Documentation copyright © 1996-2020 The KDE developers.
Generated on Mon Jun 22 2020 13:13:39 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
  • 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