KDE TechBase - User contributions [en]

Projects/Marble/Runners/VehicleTracking

2013-01-14T13:02:49Z

Mayankmadan:

{{TutorialBrowser|

series=Marble C++ Tutorial|

name=Search|

pre=[[Projects/Marble/Runners/DisplayGeoDataPlacemark|Tutorial 6 - Displaying Places the proper way (via GeoDataDocuments)]]|

next=[[Projects/Marble/OnlineServices|Tutorial 8 - Creating new online services]]|
}}

We want to present you another C++ example of Marble Runnable usage, here on KDE TechBase. It's about the cars. Imagine that there are two flying cars in the air. They are driving around ukranian city Kiev (EURO-2012). They are driving circles around it with set radius and speed. At the end of tutorial you will have an application with smth like:

[[File:Marble-VehicleTracking-1.png]]

Let's think about implementation a bit:

# Init [http://api.kde.org/stable/kdeedu-apidocs/marble/html/classMarbleWidget.html MarbleWidget]
# Implement [http://api.kde.org/stable/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataPlacemark.html placemarks] for cars "Bus" and "Car"
# Change their [http://api.kde.org/stable/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataCoordinates.html coordinates] using trigonometry functions
# Apply new [http://api.kde.org/stable/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataCoordinates.html coordinates]

We need to change coordinates with really small interval (~10 ms). In this way, to not block GUI thread we need to use multi-threading. For that we suggest that model:

# Create [http://qt-project.org/doc/qt-5.0/qtcore/qthread.html QThread] #1
# Create CarWorker #1 (= worker for cars' coordinates)
# Move CarWorker #1 into thread #1
# The same for Car #2 (1-3)

Then we will have three threads - GUI, Calculations #1, Calculations #2. To connect calc. threads with GUI we should use Qt S/S (Signal/Slot) connection.

{{Warning|2=Important|1=Use here connection type Qt::BlockingQueuedConnection, another way GUI thread will be blocked}}

Now we have a nice implementation plan. Let's start coding.

# main() creates an object of the Window (our main QWidget-based window)
# Window creates the [http://api.kde.org/stable/kdeedu-apidocs/marble/html/classMarbleWidget.html MarbleWidget] and sets two GeoDataPlacemarks there
# main() calls Window::startCars()
# Window creates two [http://qt-project.org/doc/qt-5.0/qtcore/qthread.html QThreads]
# Window creates two CarWorkers
# Window moves car workers into their threads
# Threads are started

Then each CarWorker creates a [http://qt-project.org/doc/qt-5.0/qtcore/qtimer.html QTimer] with interval x. On timeout() it calls the CarWorker::iterate() - function to calculate new position of placemark and notify Window (another thread) about it.

Everything is going on until the application finishes.

'''The code with comments:'''

<source lang="cpp">
//
// This file is part of the Marble Virtual Globe.
//
// This program is free software licensed under the GNU LGPL. You can
// find a copy of this license in LICENSE.txt in the top directory of
// the source code.
//
// Copyright 2012 Illya Kovalevskyy <illya.kovalevskyy@gmail.com>
// Copyright 2012 Torsten Rahn <tackat@kde.org>
//

#include <QtGui/QApplication>
#include <QtCore/QThread>
#include <QtCore/QTimer>
#include <QtCore/QHash>
#include <QtCore/qmath.h>
#include <QtCore/QDebug>
#include <QtGui/QVBoxLayout>

#include <marble/MarbleWidget.h>
#include <marble/MarbleGlobal.h>
#include <marble/GeoDataDocument.h>
#include <marble/GeoDataPlacemark.h>
#include <marble/GeoDataLineString.h>
#include <marble/GeoDataTreeModel.h>
#include <marble/MarbleModel.h>

using namespace Marble;

// CarWorker Class
class CarWorker : public QObject
{
Q_OBJECT
public:
CarWorker(const GeoDataCoordinates& city, qreal radius, qreal speed);

signals:
/// This signal will be emitted when we need to
/// move the placemark.
void coordinatesChanged(GeoDataCoordinates coord);

public slots:
void startWork();
void finishWork();

private slots:
void iterate();

private:
QTimer *m_timer;
GeoDataCoordinates m_city;
qreal m_radius;
qreal m_speed;
qreal m_alpha;
};

CarWorker::CarWorker(const GeoDataCoordinates &city, qreal radius, qreal speed) :
QObject(),
m_timer(new QTimer(this)),
m_city(city),
m_radius(radius),
m_speed(speed),
m_alpha(0.0)
{}

void CarWorker::startWork()
{
m_timer->setInterval(0);
connect(m_timer, SIGNAL(timeout()), this, SLOT(iterate()));
m_timer->start();
}

/// Single timer loop iteration:
/// Calculates new coordinates for the car
void CarWorker::iterate()
{
/// A bit of math
qreal lon = m_city.longitude(GeoDataCoordinates::Degree) + m_radius * qCos(m_alpha * DEG2RAD);
qreal lat = m_city.latitude(GeoDataCoordinates::Degree) + m_radius * qSin(m_alpha * DEG2RAD);

GeoDataCoordinates coord(lon, lat, 0.0, GeoDataCoordinates::Degree);
emit coordinatesChanged(coord);

/// Iteration is finished. We need to increase angle
m_alpha += m_speed;
}

void CarWorker::finishWork()
{
m_timer->stop();
}

// Window Class
class Window : public QWidget
{
Q_OBJECT
public:
Window(QWidget *parent = 0);
void startCars();

public slots:
void setCarCoordinates(const GeoDataCoordinates &coord);

private:
MarbleWidget *m_marbleWidget;
CarWorker *m_firstWorker;
CarWorker *m_secondWorker;
GeoDataPlacemark *m_carFirst;
GeoDataPlacemark *m_carSecond;
QThread *m_threadFirst;
QThread *m_threadSecond;
};

Window::Window(QWidget *parent) :
QWidget(parent),
m_marbleWidget(new MarbleWidget)
{
QVBoxLayout *layout = new QVBoxLayout(this);
layout->addWidget(m_marbleWidget);
setLayout(layout);

// Load the OpenStreetMap map
m_marbleWidget->setMapThemeId("earth/openstreetmap/openstreetmap.dgml");
m_marbleWidget->setProjection( Mercator );
setGeometry(80, 60, 1000, 800);
GeoDataCoordinates Kiev(30.523333, 50.45, 0.0, GeoDataCoordinates::Degree);
m_marbleWidget->centerOn(Kiev);
m_marbleWidget->setZoom(2300);

m_carFirst = new GeoDataPlacemark("Bus");
m_carSecond = new GeoDataPlacemark("Car");

GeoDataDocument *document = new GeoDataDocument;

document->append(m_carFirst);
document->append(m_carSecond);

m_marbleWidget->model()->treeModel()->addDocument(document);

show();
}

void Window::startCars()
{
GeoDataCoordinates Kiev(30.523333, 50.45, 0.0, GeoDataCoordinates::Degree);

m_threadFirst = new QThread;
m_firstWorker = new CarWorker(Kiev, (qreal)0.1, (qreal)0.7);
m_firstWorker->moveToThread(m_threadFirst);

connect(m_firstWorker, SIGNAL(coordinatesChanged(GeoDataCoordinates)),
this, SLOT(setCarCoordinates(GeoDataCoordinates)), Qt::BlockingQueuedConnection);

m_threadSecond = new QThread;
m_secondWorker = new CarWorker(Kiev, (qreal)0.2, (qreal)-0.5);
m_secondWorker->moveToThread(m_threadSecond);

connect(m_secondWorker, SIGNAL(coordinatesChanged(GeoDataCoordinates)),
this, SLOT(setCarCoordinates(GeoDataCoordinates)), Qt::BlockingQueuedConnection);

connect(m_threadFirst, SIGNAL(started()), m_firstWorker, SLOT(startWork()));
connect(m_threadFirst, SIGNAL(finished()), m_firstWorker, SLOT(finishWork()));

connect(m_threadSecond, SIGNAL(started()), m_secondWorker, SLOT(startWork()));
connect(m_threadSecond, SIGNAL(finished()), m_secondWorker, SLOT(finishWork()));

m_threadFirst->start();
m_threadSecond->start();
}

void Window::setCarCoordinates(const GeoDataCoordinates &coord)
{
CarWorker *worker = qobject_cast<CarWorker*>(sender());
if (worker == m_firstWorker) {
m_carFirst->setCoordinate(coord);
m_marbleWidget->model()->treeModel()->updateFeature(m_carFirst);
} else if (worker == m_secondWorker) {
m_carSecond->setCoordinate(coord);
m_marbleWidget->model()->treeModel()->updateFeature(m_carSecond);
}
}

// Main
int main(int argc, char** argv)
{
QApplication app(argc,argv);

Window window;
window.startCars();

return app.exec();
}

#include "vehicletracking.moc"
</source>

Before running qmake, create a [http://doc.trolltech.com/qmake-tutorial.html qmake project file]
<syntaxhighlight lang="text">
TEMPLATE = app
TARGET = vehicletracking
DEPENDPATH += .
INCLUDEPATH += .
SOURCES += vehicletracking.cpp
LIBS += -lmarblewidget
</syntaxhighlight>
Save this file as "vehicletracking.pro" in the same directory and run
<source lang = "bash">
qmake
make
</source>
then execute <tt>./vehicletracking</tt>. If everything goes fine, marble widget will appear as shown in the screenshot at the start of the tutorial.

'''Find your way and explore the world! ;)'''

Projects/Marble/Runners/PaintingGeoDataLineString

2013-01-13T17:18:40Z

Mayankmadan:

{{TutorialBrowser|

series=Marble C++ Tutorial|

name=Painting GeoDataLineString: Using the GeoPainter in order to paint a GeoDataLineString object|

pre=[[Projects/Marble/LayerInterface|Tutorial 14 - Drawing in Custom Layers]]|
}}

The previous tutorial proved how GeoPainter can be used in order to paint shapes and text at different coordinates of the map (through a GeoDataCoordinates parameter) in a [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1MarbleWidget.html MarbleWidget]. Now, we'll show a new way of adding extra content to the globe: by painting GeoDataLineString's using our GeoPainter.

Briefly, [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataLineString.html GeoDataLineString] is a tool class which implements LineStrings (also referred to as "polylines"), allowing us to store a contiguous set of line segments. As you will see in the example, it consists of several nodes (GeoDataCoordinates points), which are connected through line segments.

GeoDataLineString allows LineStrings to be tessellated in order to make them follow the terrain and the curvature of the Earth. The tessellation options allow different ways of visualization:

* Not tessellated, connects each two nodes directly

* A tessellated line, each segment is bent such that the LineString follows the curvature of the Earth and its terrain. A tessellated line segment connects each two nodes at the shortest possible distance ("along great circles").

* A tessellated line which follows latitude circles whenever possible: in this case latitude circles are followed as soon as two subsequent nodes have exactly the same amount of latitude. In all other places the line segments follow great circles.

<source lang="cpp">
#include <QtGui/QApplication>
#include <marble/MarbleWidget.h>
#include <marble/GeoPainter.h>
#include <marble/GeoDataLineString.h>

using namespace Marble;

class MyMarbleWidget : public MarbleWidget
{
public:
virtual void customPaint(GeoPainter* painter);
};

void MyMarbleWidget::customPaint(GeoPainter* painter) {

GeoDataCoordinates France( 2.2, 48.52, 0.0, GeoDataCoordinates::Degree );
painter->setPen( QColor( 0, 0, 0 ) );
painter->drawText( France, "France" );

GeoDataCoordinates Canada( -77.02, 48.52, 0.0, GeoDataCoordinates::Degree );
painter->setPen( QColor( 0, 0, 0 ) );
painter->drawText( Canada, "Canada" );

//A line from France to Canada without tessellation

GeoDataLineString shapeNoTessellation( NoTessellation );
shapeNoTessellation << France << Canada;

painter->setPen( oxygenSkyBlue4 );
painter->drawPolyline( shapeNoTessellation );

//The same line, but with tessellation

GeoDataLineString shapeTessellate( Tessellate );
shapeTessellate << France << Canada;

painter->setPen( oxygenBrickRed4 );
painter->drawPolyline( shapeTessellate );

//Now following the latitude circles

GeoDataLineString shapeLatitudeCircle( RespectLatitudeCircle | Tessellate );
shapeLatitudeCircle << France << Canada;

painter->setPen( oxygenForestGreen4 );
painter->drawPolyline( shapeLatitudeCircle );
}

int main(int argc, char** argv) {

QApplication app(argc,argv);

// Create a Marble QWidget without a parent
MarbleWidget *mapWidget = new MyMarbleWidget();

// Load the OpenStreetMap map
mapWidget->setMapThemeId("earth/plain/plain.dgml");

mapWidget->show();

return app.exec();
}
</source>

Save the code above as <tt>my_marble.cpp</tt> and compile it:

<source lang="bash">
g++ -I /usr/include/qt4/ -o my_marble my_marble.cpp -lmarblewidget -lQtGui
</source>

If things go fine, execute <tt>./my_marble</tt> and you end up with a globe view similar to this:

[[Image:GeoDataLineStringTutorial.png]]

As you can see, the blue line corresponds to the straight-no-tessellation way of visualization, the red one follows the great circles, and the green one sticks to the latitude circles, since the two endpoints have the same latitude.

Projects/Marble/LayerInterface

2013-01-13T17:17:38Z

Mayankmadan:

{{TutorialBrowser|

series=Marble C++ Tutorial|

name=Drawing in Custom Layers|

pre=[[Projects/Marble/MarbleGeoPainter|Tutorial 13 - Painting onto the map]]|

next=[[Projects/Marble/Runners/PaintingGeoDataLineString|Tutorial 15 - Painting GeoDataLineString: Using the GeoPainter in order to paint a GeoDataLineString object]]|
}}

The previous tutorial showed how to override the customPaint() method in MarbleWidget to paint on top of the map. It is also possible to paint at different layer positions. This is similar to providing a z-order of elements being painted.

To achieve this, we'll take a look at an example. Instead of deriving from MarbleWidget, we create our own Marble::LayerInterface class. After passing it to Marble, it will be included in painting similar to how customPaint() was called. This time however we are able to specify at which layer to paint.

To illustrate the painting in different layers, the code below paints a clock and implements the ability to dynamically switch its layer position by pressing '+'. Notice how the current layer position is indicated in the window title. When painting in the "STARS" layer, you won't see anything -- we'll paint behind the map. In the "SURFACE" layer, city names and other placemarks will be painted on top of us. In contrast, "ORBIT" will make us paint over placemarks, while float items (info boxes) still paint above us. This will change when we paint in the "USER TOOLS" layer.

<source lang="cpp">
#include <marble/MarbleWidget.h>
#include <marble/MarbleMap.h>
#include <marble/MarbleModel.h>
#include <marble/GeoPainter.h>
#include <marble/LayerInterface.h>

#include <QtCore/QTime>
#include <QtCore/QTimer>
#include <QtGui/QApplication>
#include <QtGui/QKeyEvent>

using namespace Marble;

class MyPaintLayer : public QObject, public LayerInterface
{
public:
// Constructor
MyPaintLayer(MarbleWidget* widget);

// Implemented from LayerInterface
virtual QStringList renderPosition() const;

// Implemented from LayerInterface
virtual bool render( GeoPainter *painter, ViewportParams *viewport,
const QString& renderPos = "NONE", GeoSceneLayer * layer = 0 );

// Overriding QObject
virtual bool eventFilter(QObject *obj, QEvent *event);

GeoDataCoordinates approximate(const GeoDataCoordinates &base, qreal angle, qreal dist) const;

private:
MarbleWidget* m_widget;

int m_index;
};

MyPaintLayer::MyPaintLayer(MarbleWidget* widget) : m_widget(widget), m_index(0)
{
// nothing to do
}

QStringList MyPaintLayer::renderPosition() const
{
// We will paint in exactly one of the following layers.
// The current one can be changed by pressing the '+' key
QStringList layers = QStringList() << "SURFACE" << "HOVERS_ABOVE_SURFACE";
layers << "ORBIT" << "USER_TOOLS" << "STARS";

int index = m_index % layers.size();
return QStringList() << layers.at(index);
}

bool MyPaintLayer::eventFilter(QObject *obj, QEvent *event)
{
// Adjust the current layer when '+' is pressed
if (event->type() == QEvent::KeyPress)
{
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
if (keyEvent->key() == Qt::Key_Plus) {
++m_index;
return true;
}
}

return false;
}

GeoDataCoordinates MyPaintLayer::approximate(const GeoDataCoordinates &base, qreal angle, qreal dist) const
{
// This is just a rough estimation that ignores projections.
// It only works for short distances. Don't use in real code.
GeoDataCoordinates::Unit deg = GeoDataCoordinates::Degree;
return GeoDataCoordinates ( base.longitude(deg) + 1.5 * dist * sin(angle),
base.latitude(deg) + dist * cos(angle), 0.0, deg);
}

bool MyPaintLayer::render( GeoPainter *painter, ViewportParams *viewport,
const QString& renderPos, GeoSceneLayer * layer )
{
// Have window title reflect the current paint layer
m_widget->setWindowTitle(renderPosition().first());
GeoDataCoordinates home(8.4, 48.0, 0.0, GeoDataCoordinates::Degree);
QTime now = QTime::currentTime();

painter->setRenderHint(QPainter::Antialiasing, true);

// Large circle built by 60 small circles
painter->setPen( QPen(QBrush(QColor::fromRgb(255,255,255,200)), 3.0, Qt::SolidLine, Qt::RoundCap ) );
for (int i=0; i<60; ++i)
painter->drawEllipse(approximate(home, M_PI * i / 30.0, 1.0), 5, 5);

// hour, minute, second hand
painter->drawLine(home, approximate(home, M_PI * now.minute() / 30.0, 0.75));
painter->drawLine(home, approximate(home, M_PI * now.hour() / 6.0, 0.5));
painter->setPen(QPen(QBrush(Qt::red), 4.0, Qt::SolidLine, Qt::RoundCap ));
painter->drawLine(home, approximate(home, M_PI * now.second() / 30.0, 1.0));

return true;
}

int main(int argc, char** argv)
{
QApplication app(argc,argv);
MarbleWidget *mapWidget = new MarbleWidget;

// Create and register our paint layer
MyPaintLayer* layer = new MyPaintLayer(mapWidget);
// Uncomment for older versions of Marble:
// mapWidget->map()->model()->addLayer(layer);
mapWidget->addLayer(layer);

// Install an event handler: Pressing + will change the layer we paint at
mapWidget->installEventFilter(layer);

// Finish widget creation.
mapWidget->setMapThemeId("earth/bluemarble/bluemarble.dgml");
mapWidget->show();

// Update each second to give the clock second resolution
QTimer seconds;
seconds.setInterval(1000);
QObject::connect(&seconds, SIGNAL(timeout()), mapWidget, SLOT(update()));
seconds.start();

return app.exec();
}
</source>

Save the code above as <tt>my_marble.cpp</tt> and compile it:

<source lang="bash">
g++ -I /usr/include/qt4/ -o my_marble my_marble.cpp -lmarblewidget -lQtGui
</source>

If things go fine, execute <tt>./my_marble</tt> and you end up with a globe view painting a little different interpretation of a world clock:

[[Image:Marble-paintlayer.png]]

Projects/Marble/LayerInterface

2013-01-13T17:15:19Z

Mayankmadan:

{{TutorialBrowser|

series=Marble C++ Tutorial|

name=Drawing in Custom Layers|

pre=[[Projects/Marble/MarbleGeoPainter|Tutorial 13 - Painting onto the map]]|

next=[[Projects/Marble/Runners/PaintingGeoDataLineString|Tutorial 14 - Painting GeoDataLineString: Using the GeoPainter in order to paint a GeoDataLineString object]]|
}}

The previous tutorial showed how to override the customPaint() method in MarbleWidget to paint on top of the map. It is also possible to paint at different layer positions. This is similar to providing a z-order of elements being painted.

To achieve this, we'll take a look at an example. Instead of deriving from MarbleWidget, we create our own Marble::LayerInterface class. After passing it to Marble, it will be included in painting similar to how customPaint() was called. This time however we are able to specify at which layer to paint.

To illustrate the painting in different layers, the code below paints a clock and implements the ability to dynamically switch its layer position by pressing '+'. Notice how the current layer position is indicated in the window title. When painting in the "STARS" layer, you won't see anything -- we'll paint behind the map. In the "SURFACE" layer, city names and other placemarks will be painted on top of us. In contrast, "ORBIT" will make us paint over placemarks, while float items (info boxes) still paint above us. This will change when we paint in the "USER TOOLS" layer.

<source lang="cpp">
#include <marble/MarbleWidget.h>
#include <marble/MarbleMap.h>
#include <marble/MarbleModel.h>
#include <marble/GeoPainter.h>
#include <marble/LayerInterface.h>

#include <QtCore/QTime>
#include <QtCore/QTimer>
#include <QtGui/QApplication>
#include <QtGui/QKeyEvent>

using namespace Marble;

class MyPaintLayer : public QObject, public LayerInterface
{
public:
// Constructor
MyPaintLayer(MarbleWidget* widget);

// Implemented from LayerInterface
virtual QStringList renderPosition() const;

// Implemented from LayerInterface
virtual bool render( GeoPainter *painter, ViewportParams *viewport,
const QString& renderPos = "NONE", GeoSceneLayer * layer = 0 );

// Overriding QObject
virtual bool eventFilter(QObject *obj, QEvent *event);

GeoDataCoordinates approximate(const GeoDataCoordinates &base, qreal angle, qreal dist) const;

private:
MarbleWidget* m_widget;

int m_index;
};

MyPaintLayer::MyPaintLayer(MarbleWidget* widget) : m_widget(widget), m_index(0)
{
// nothing to do
}

QStringList MyPaintLayer::renderPosition() const
{
// We will paint in exactly one of the following layers.
// The current one can be changed by pressing the '+' key
QStringList layers = QStringList() << "SURFACE" << "HOVERS_ABOVE_SURFACE";
layers << "ORBIT" << "USER_TOOLS" << "STARS";

int index = m_index % layers.size();
return QStringList() << layers.at(index);
}

bool MyPaintLayer::eventFilter(QObject *obj, QEvent *event)
{
// Adjust the current layer when '+' is pressed
if (event->type() == QEvent::KeyPress)
{
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
if (keyEvent->key() == Qt::Key_Plus) {
++m_index;
return true;
}
}

return false;
}

GeoDataCoordinates MyPaintLayer::approximate(const GeoDataCoordinates &base, qreal angle, qreal dist) const
{
// This is just a rough estimation that ignores projections.
// It only works for short distances. Don't use in real code.
GeoDataCoordinates::Unit deg = GeoDataCoordinates::Degree;
return GeoDataCoordinates ( base.longitude(deg) + 1.5 * dist * sin(angle),
base.latitude(deg) + dist * cos(angle), 0.0, deg);
}

bool MyPaintLayer::render( GeoPainter *painter, ViewportParams *viewport,
const QString& renderPos, GeoSceneLayer * layer )
{
// Have window title reflect the current paint layer
m_widget->setWindowTitle(renderPosition().first());
GeoDataCoordinates home(8.4, 48.0, 0.0, GeoDataCoordinates::Degree);
QTime now = QTime::currentTime();

painter->setRenderHint(QPainter::Antialiasing, true);

// Large circle built by 60 small circles
painter->setPen( QPen(QBrush(QColor::fromRgb(255,255,255,200)), 3.0, Qt::SolidLine, Qt::RoundCap ) );
for (int i=0; i<60; ++i)
painter->drawEllipse(approximate(home, M_PI * i / 30.0, 1.0), 5, 5);

// hour, minute, second hand
painter->drawLine(home, approximate(home, M_PI * now.minute() / 30.0, 0.75));
painter->drawLine(home, approximate(home, M_PI * now.hour() / 6.0, 0.5));
painter->setPen(QPen(QBrush(Qt::red), 4.0, Qt::SolidLine, Qt::RoundCap ));
painter->drawLine(home, approximate(home, M_PI * now.second() / 30.0, 1.0));

return true;
}

int main(int argc, char** argv)
{
QApplication app(argc,argv);
MarbleWidget *mapWidget = new MarbleWidget;

// Create and register our paint layer
MyPaintLayer* layer = new MyPaintLayer(mapWidget);
// Uncomment for older versions of Marble:
// mapWidget->map()->model()->addLayer(layer);
mapWidget->addLayer(layer);

// Install an event handler: Pressing + will change the layer we paint at
mapWidget->installEventFilter(layer);

// Finish widget creation.
mapWidget->setMapThemeId("earth/bluemarble/bluemarble.dgml");
mapWidget->show();

// Update each second to give the clock second resolution
QTimer seconds;
seconds.setInterval(1000);
QObject::connect(&seconds, SIGNAL(timeout()), mapWidget, SLOT(update()));
seconds.start();

return app.exec();
}
</source>

Save the code above as <tt>my_marble.cpp</tt> and compile it:

<source lang="bash">
g++ -I /usr/include/qt4/ -o my_marble my_marble.cpp -lmarblewidget -lQtGui
</source>

If things go fine, execute <tt>./my_marble</tt> and you end up with a globe view painting a little different interpretation of a world clock:

[[Image:Marble-paintlayer.png]]

Projects/Marble/MarbleGeoPainter

2013-01-13T17:13:41Z

Mayankmadan:

{{TutorialBrowser|

series=Marble C++ Tutorial|

name=GeoPainter: Painting onto the map|

pre=[[Projects/Marble/Runners/Parse|Tutorial 12 - Opening .kml, .gpx... files]]|

next=[[Projects/Marble/LayerInterface|Tutorial 14 - Drawing in Custom Layers]]|
}}

In the previous tutorial you've seen how easy it is to embed a [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1MarbleWidget.html MarbleWidget] into a Qt application: Just create a MarbleWidget, set a map theme on it and ... you're done already.

Next we'll extend that example a bit and write our own little paint method to add some extra content to the globe. To facilitate this, Marble provides a painting hook called [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1MarbleWidget.html#47e87a8639f38e9da380923453a6f35f MarbleWidget::customPaint]. It is called in between of the normal paint operations: After the background and tiles are painted, but before the top layers like float items (info boxes).

The customPaint operation is called with a [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1GeoPainter.html GeoPainter]: An extended [http://doc.trolltech.com/qpainter.html QPainter] which not only is able to paint at certain screen (pixel) positions, but also at certain geo (lat,lon) positions. We'll make use of that feature now. To keep things simple again, we just add a little 'Hello World' message indicated by a green circle.

<source lang="cpp">
#include <QtGui/QApplication>
#include <marble/MarbleWidget.h>
#include <marble/GeoPainter.h>

using namespace Marble;

class MyMarbleWidget : public MarbleWidget
{
public:
virtual void customPaint(GeoPainter* painter);
};

void MyMarbleWidget::customPaint(GeoPainter* painter)
{
GeoDataCoordinates home(8.4, 49.0, 0.0, GeoDataCoordinates::Degree);
painter->setPen(Qt::green);
painter->drawEllipse(home, 7, 7);
painter->setPen(Qt::black);
painter->drawText(home, "Hello Marble!");
}

int main(int argc, char** argv)
{
QApplication app(argc,argv);
MyMarbleWidget *mapWidget = new MyMarbleWidget;
mapWidget->setMapThemeId("earth/openstreetmap/openstreetmap.dgml");
mapWidget->show();
return app.exec();
}
</source>

Save the code above as <tt>my_marble.cpp</tt> and compile it:

<source lang="bash">
g++ -I /usr/include/qt4/ -o my_marble my_marble.cpp -lmarblewidget -lQtGui
</source>

If things go fine, execute <tt>./my_marble</tt> and you end up with a globe view similar to this:

[[Image:Marble-geopainter.png]]

There may be situations where MarbleWidget::customPaint() does not suit your needs. This can be the case when you don't want to paint at the very top position (above all other items), or when subclassing MarbleWidget is not possible for some reason. In that case, have a look at the next chapter [[Projects/Marble/LayerInterface|Drawing in Custom Layers]]

Projects/Marble/Runners/Parse

2013-01-13T17:01:28Z

Mayankmadan:

{{TutorialBrowser|

series=Marble C++ Tutorial|

name=Search|

pre=[[Projects/Marble/Runners/ReverseGeocoding|Tutorial 11 - Reverse Geocoding]]|

next=[[Projects/Marble/MarbleGeoPainter|Tutorial 13 - Painting onto the map]]|
}}

== KML Inspector ==
As we have seen in the previous tutorial, Marble employs runners to when dealing with .kml (or .gpx, .osm, etc) files. This tutorial shows how to use the <tt>MarbleRunnerManager</tt> class to open a .kml (or .gpx, ...) file and display its structure in a tree view.

<source lang="cpp-qt">
#include <QtCore/QDebug>
#include <QtCore/QFileInfo>
#include <QtGui/QApplication>
#include <QtGui/QTreeView>

#include <marble/MarbleWidget.h>
#include <marble/MarbleModel.h>
#include <marble/MarbleRunnerManager.h>
#include <marble/GeoDataTreeModel.h>

using namespace Marble;

int main(int argc, char** argv)
{
QApplication app(argc,argv);

QFileInfo inputFile( app.arguments().last() );
if ( app.arguments().size() < 2 || !inputFile.exists() ) {
qWarning() << "Usage: " << app.arguments().first() << "file.kml";
return 1;
}

MarbleModel *model = new MarbleModel;
MarbleRunnerManager* manager = new MarbleRunnerManager( model->pluginManager() );

GeoDataDocument* document = manager->openFile( inputFile.absoluteFilePath() );
if ( document ) {
GeoDataTreeModel* treeModel = new GeoDataTreeModel;
treeModel->addDocument( document );
QTreeView* treeView = new QTreeView;
treeView->setModel( treeModel );
treeView->show();
} else {
qDebug() << "Unable to open " << inputFile.absoluteFilePath();
}

return app.exec();
}
</source>

Copy and paste the code above into a text editor. Then save it as <tt>my_marble.cpp</tt> and compile it by entering the following command on the command line:

<source lang="bash">
g++ -I /usr/include/qt4/ -o my_marble my_marble.cpp -lmarblewidget -lQtGui -lQtCore
</source>

If things go fine, execute <tt>./my_marble some-file.kml</tt> and you get a tree view of its structure similar to this screenshot (showing the structure of a route calculated with Marble):

[[Image:Marble-kml-inspector.png]]

{{tip|
Here's a little checklist to tackle some problems that might arise when compiling the code above:

* You need Qt and '''Marble development packages''' (or comparable git installations), version 1.3 (Marble library 0.13), shipped post KDE 4.8
* If ''Qt headers'' are not installed in '''/usr/include/qt4''' on your system, change the path in the g++ call above accordingly.
* Likewise, '''add -I /path/to/marble/headers''' if they're not to be found in /usr/include
}}
{{note|
If you provide maps in your application please check the '''Terms of Use''' of the map material. The map material that is shipped with Marble is licensed ''in the spirit of Free Software''. This usually means at least that the authors should be credited and that the license is mentioned.
E.g. for ''OpenStreetMap'' the license is [http://creativecommons.org/license/by-sa/2.0 CC-BY-SA]. Other map data shipped with Marble is either public domain or licensed in the spirit of the BSD license.
}}

Projects/Marble/Runners/ReverseGeocoding

2013-01-13T16:58:19Z

Mayankmadan:

{{TutorialBrowser|

series=Marble C++ Tutorial|

name=Basic Routing|

pre=[[Projects/Marble/Runners/Search|Tutorial 10 - Searching]]|

next=[[Projects/Marble/Runners/Parse|Tutorial 12 - Opening .kml, .gpx... files]]|
}}

== Reverse geocoding ==
Marble uses so-called runners to calculate routes, do reverse geocoding, parse files and search for placemarks (cities, addresses, points of interest, ...). This tutorial shows how to use the <tt>MarbleRunnerManager</tt> class to get a textual description of a given coordinate.

<source lang="cpp-qt">
#include <QtGui/QApplication>
#include <QtCore/QDebug>

#include <marble/MarbleWidget.h>
#include <marble/MarbleModel.h>
#include <marble/MarbleRunnerManager.h>
#include <marble/GeoDataPlacemark.h>

using namespace Marble;

int main(int argc, char** argv)
{
QApplication app(argc,argv);
MarbleModel *model = new MarbleModel;

MarbleRunnerManager* manager = new MarbleRunnerManager( model->pluginManager() );
manager->setModel( model );

GeoDataCoordinates position( -0.15845, 51.52380, 0.0, GeoDataCoordinates::Degree );
qDebug() << position.toString() << "is" << manager->searchReverseGeocoding( position );
}
</source>

Copy and paste the code above into a text editor. Then save it as <tt>my_marble.cpp</tt> and compile it by entering the following command on the command line:

<source lang="bash">
g++ -I /usr/include/qt4/ -o my_marble my_marble.cpp -lmarblewidget -lQtGui -lQtCore
</source>

If things go fine, execute <tt>./my_marble</tt> and the output looks similar to this:
<source lang="text">
" 0° 09' 30.4"W, 51° 31' 25.7"N" is "Sherlock Holmes Museum, "221b", Baker Street, Marylebone, City of Westminster, Greater London, England, NW1 6AX, United Kingdom"
</source>

{{tip|
Here's a little checklist to tackle some problems that might arise when compiling the code above:

* You need Qt and '''Marble development packages''' (or comparable git installations), version 1.3 (Marble library 0.13), shipped post KDE 4.8
* If ''Qt headers'' are not installed in '''/usr/include/qt4''' on your system, change the path in the g++ call above accordingly.
* Likewise, '''add -I /path/to/marble/headers''' if they're not to be found in /usr/include
}}
{{note|
If you provide maps in your application please check the '''Terms of Use''' of the map material. The map material that is shipped with Marble is licensed ''in the spirit of Free Software''. This usually means at least that the authors should be credited and that the license is mentioned.
E.g. for ''OpenStreetMap'' the license is [http://creativecommons.org/license/by-sa/2.0 CC-BY-SA]. Other map data shipped with Marble is either public domain or licensed in the spirit of the BSD license.
}}

Projects/Marble/Runners/Search

2013-01-13T16:55:48Z

Mayankmadan:

{{TutorialBrowser|

series=Marble C++ Tutorial|

name=Search|

pre=[[Projects/Marble/Routing/BasicRouting|Tutorial 9 - Basic Routing]]|

next=[[Projects/Marble/Runners/ReverseGeocoding|Tutorial 11 - Reverse Geocoding]]|
}}

== Searching for cities, addresses, points of interest ==
Marble uses so-called runners to calculate routes, do reverse geocoding, parse files and search for placemarks (cities, addresses, points of interest, ...). This tutorial shows how to use the <tt>MarbleRunnerManager</tt> class to search for an arbitrary string (<i>Karlsruhe</i> in the example below, see [http://userbase.kde.org/Marble/Search Userbase] for more information on search terms).

<source lang="cpp-qt">
#include <QtGui/QApplication>
#include <QtCore/QDebug>

#include <marble/MarbleWidget.h>
#include <marble/MarbleModel.h>
#include <marble/MarbleRunnerManager.h>
#include <marble/GeoDataPlacemark.h>

using namespace Marble;

int main(int argc, char** argv)
{
QApplication app(argc,argv);
MarbleModel *model = new MarbleModel;

MarbleRunnerManager* manager = new MarbleRunnerManager( model->pluginManager() );
manager->setModel( model );

QVector<GeoDataPlacemark*> searchResult = manager->searchPlacemarks( "Karlsruhe" );
foreach( GeoDataPlacemark* placemark, searchResult ) {
qDebug() << "Found " << placemark->name() << "at" << placemark->coordinate().toString();
}
}
</source>

Copy and paste the code above into a text editor. Then save it as <tt>my_marble.cpp</tt> and compile it by entering the following command on the command line:

<source lang="bash">
g++ -I /usr/include/qt4/ -o my_marble my_marble.cpp -lmarblewidget -lQtGui -lQtCore
</source>

If things go fine, execute <tt>./my_marble</tt> and the output looks similar to this:
<source lang="text">
Found "Karlsruhe, Germany" at " 8° 33' 48.7"E, 49° 05' 38.4"N"
Found "Karlsruhe, McLean" at "100° 36' 58.4"W, 48° 05' 27.7"N"
Found "Karlsruhe, Karlsruhe, Stadt" at " 8° 24' 16.0"E, 49° 00' 50.6"N"
Found "Karlsruhe, Remscheid" at " 7° 17' 35.3"E, 51° 09' 09.4"N"
Found "Karlsruhe, Austria" at " 15° 19' 53.6"E, 47° 21' 33.4"N"
Found "Karlsruhe, McLean" at "100° 37' 13.5"W, 48° 05' 24.0"N"
Found "Karlsruhe, Sohland a.d. Spree" at " 14° 27' 36.5"E, 51° 02' 28.5"N"
Found "Parkstraße, Bad Elster" at " 12° 14' 08.0"E, 50° 16' 57.9"N"
Found "Karlsruhe (Bruchsal)" at " 8° 33' 48.7"E, 49° 05' 38.4"N"
Found "Karlsruhe (Innenstadt-West)" at " 8° 24' 16.0"E, 49° 00' 50.6"N"
</source>

{{tip|
Here's a little checklist to tackle some problems that might arise when compiling the code above:

* You need Qt and '''Marble development packages''' (or comparable git installations), version 1.3 (Marble library 0.13), shipped post KDE 4.8
* If ''Qt headers'' are not installed in '''/usr/include/qt4''' on your system, change the path in the g++ call above accordingly.
* Likewise, '''add -I /path/to/marble/headers''' if they're not to be found in /usr/include
}}
{{note|
If you provide maps in your application please check the '''Terms of Use''' of the map material. The map material that is shipped with Marble is licensed ''in the spirit of Free Software''. This usually means at least that the authors should be credited and that the license is mentioned.
E.g. for ''OpenStreetMap'' the license is [http://creativecommons.org/license/by-sa/2.0 CC-BY-SA]. Other map data shipped with Marble is either public domain or licensed in the spirit of the BSD license.
}}

Projects/Marble/Routing/BasicRouting

2013-01-13T16:48:13Z

Mayankmadan:

{{TutorialBrowser|

series=Marble C++ Tutorial|

name=Basic Routing|

pre=[[Projects/Marble/OnlineServices|Tutorial 8 - OnlineServices]]|

next=[[Projects/Marble/Runners/Search|Tutorial 10 - Searching]]|
}}

== Basic Routing ==
The Marble library 0.13 and later (KDE 4.8, Marble 1.3) has an API to calculate and manage routes. Let's start with a brief overview of the important classes and their interaction. The class <tt>RouteRequest</tt> holds parameters that are constraints for the route to be calculated: Start and destination, optional via points and further parameters (e.g. transport type). The <tt>RoutingManager</tt> passes such a request to backends (routing plugins) that calculate possible routes from it. The best route is chosen and displayed in a special layer in the <tt>MarbleWidget</tt>. Additionally you can access the route data via the <tt>RoutingModel</tt>. This model can be passed directly to e.g. a QListView to show the turn instructions, but also exposes further data like the waypoints of the route via the <tt>Route</tt> class. This one consists of a set of <tt>RouteSegment</tt> instances, each representing a number of waypoints and an optional turn instruction (<tt>Maneuver</tt>) at the end.

<source lang="cpp-qt">
#include <QtGui/QApplication>
#include <marble/MarbleWidget.h>
#include <marble/MarbleModel.h>
#include <marble/RouteRequest.h>
#include <marble/RoutingManager.h>

using namespace Marble;

int main(int argc, char** argv)
{
QApplication app(argc,argv);

// Create a Marble QWidget without a parent
MarbleWidget *mapWidget = new MarbleWidget();

// Load the OpenStreetMap map
mapWidget->setMapThemeId( "earth/openstreetmap/openstreetmap.dgml" );
mapWidget->setProjection( Mercator );

// Access the shared route request (start, destination and parameters)
RoutingManager* manager = mapWidget->model()->routingManager();
RouteRequest* request = manager->routeRequest();

// Use default routing settings for cars
request->setRoutingProfile( manager->defaultProfile( RoutingProfile::Motorcar ) );

// Set start and destination
request->append( GeoDataCoordinates( 8.38942, 48.99738, 0.0, GeoDataCoordinates::Degree ) );
request->append( GeoDataCoordinates( 8.42002, 49.0058, 0.0, GeoDataCoordinates::Degree ) );

// Calculate the route
manager->retrieveRoute();

// Center the map on the route start point and show it
mapWidget->centerOn( request->at( 0 ) );
mapWidget->setDistance( 0.75 );
mapWidget->show();

return app.exec();
}
</source>

Copy and paste the code above into a text editor. Then save it as <tt>my_marble.cpp</tt> and compile it by entering the following command on the command line:

<source lang="bash">
g++ -I /usr/include/qt4/ -o my_marble my_marble.cpp -lmarblewidget -lQtGui -lQtCore
</source>

If things go fine, execute <tt>./my_marble</tt> and you end up with a fully usable OpenStreetMap application:

[[Image:Marble-basic-routing.png]]

{{tip|
Here's a little checklist to tackle some problems that might arise when compiling the code above:

* You need Qt and '''Marble development packages''' (or comparable git installations), version 1.3 (Marble library 0.13), shipped e.g. with KDE 4.8
* If ''Qt headers'' are not installed in '''/usr/include/qt4''' on your system, change the path in the g++ call above accordingly.
* Likewise, '''add -I /path/to/marble/headers''' if they're not to be found in /usr/include
}}
{{note|
If you provide maps in your application please check the '''Terms of Use''' of the map material. The map material that is shipped with Marble is licensed ''in the spirit of Free Software''. This usually means at least that the authors should be credited and that the license is mentioned.
E.g. for ''OpenStreetMap'' the license is [http://creativecommons.org/license/by-sa/2.0 CC-BY-SA]. Other map data shipped with Marble is either public domain or licensed in the spirit of the BSD license.
}}

Projects/Marble/OnlineServices

2013-01-13T16:45:29Z

Mayankmadan:

{{TutorialBrowser|

series=Marble Tutorial|

name=Creating your first Marble Online Services Plugin|

pre=[[Projects/Marble/Runners/VehicleTracking|Tutorial 7 -Vehicle Tracking]]|

next=[[Projects/Marble/Routing/BasicRouting|Tutorial 9 - Basic Routing]]|

reading=[[Development/Tutorials/CMake|CMake]]
}}

== Abstract ==
You will here learn to create your own online service plugins. If you don't know what is meant by online service, you will see these in the Marble menu at "View"->"Online Services".
You'll need KDE 4.3 to build this tutorial.
If you want to write plugins for Marble, it could be useful to do this in KDE's subversion. Please contact the Marble developers for this (IRC, E-Mail).

== Structure ==
An online services plugin or data plugin consist of three classes at least. The class to display the information is the Data Item (the base class is AbstractDataPluginItem). It stores the information for single places on the map and displays them.

The Model (base class AbstractDataPluginModel) stores all items. Storing the items will be done by AbstractDataPluginModel itself. Your only job is to get information for new items when the displayed part of the earth changes. This can include downloading so called "Description files" from the servers of an online service and parsing them. These "Description files" contain lists of items in a specific part of the earth (specified by a LatLonAltBox).

The class based on AbstractDataPlugin is the representation class of our plugin. It provides the name and the idea of the plugin. You also have to set your model there.

== Item ==
We will write our item first as it depends on nothing else. As you should already know the item stores the data and paints it on the screen. One item has an exact position on the globe as longitude, latitude and altitude.
The item we will write shows a text at the specific position.

We will now look at the header file to see what functions we have to implement.
'''TutorialItem.h'''
<syntaxhighlight lang="cpp-qt">
#ifndef TUTORIALITEM_H
#define TUTORIALITEM_H

#include "AbstractDataPluginItem.h"

class QFont;

namespace Marble
{

class TutorialItem : public AbstractDataPluginItem
{
Q_OBJECT

public:
TutorialItem( QObject *parent );

~TutorialItem();

// Returns the item type of the item.
QString itemType() const;

// Returns true if the item is paintable
bool initialized();

// Here the item gets painted
void paint( GeoPainter *painter, ViewportParams *viewport,
const QString& renderPos, GeoSceneLayer * layer = 0 );

bool operator<( const AbstractDataPluginItem *other ) const;

// The text we want to show on the map
QString text() const;
void setText( const QString& text );

private:
QString m_text;

static QFont s_font;
};

}
#endif // TUTORIALITEM_H
</syntaxhighlight>

As you have probably seen, it will be very easy to implement this as we have only one function (paint()) besides some getters and setters.

Let's have a look at the implementation.
'''TutorialItem.cpp'''
<syntaxhighlight lang="cpp-qt">
// Self
#include "TutorialItem.h"

// Marble
#include "GeoPainter.h"
#include "ViewportParams.h"

// Qt
#include <QtCore/QDebug>
#include <QtGui/QFontMetrics>

using namespace Marble;

// That's the font we will use to paint.
QFont TutorialItem::s_font = QFont( "Sans Serif", 8 );

TutorialItem::TutorialItem( QObject *parent )
: AbstractDataPluginItem( parent )
{
// The size of an item without a text is 0
setSize( QSize( 0, 0 ) );
}

TutorialItem::~TutorialItem()
{
}

QString TutorialItem::itemType() const
{
// Our itemType:
return "tutorialItem";
}

bool TutorialItem::initialized()
{
// The item is initialized if it has a text
if ( m_text.isEmpty() )
return false;
else
return true;
}

bool TutorialItem::operator<( const AbstractDataPluginItem *other ) const
{
// That's not a very nice priority estimation, you'll hopefully find
// a better one for your plugin.
return this->id() < other->id();
}

QString TutorialItem::text() const
{
return m_text;
}

void TutorialItem::setText( const QString& text )
{
// On a text change our size may also change, so we have to set the new
// item size. Marble needs to know how large an item is to find the correct
// bounding rect. The given position will always be in the middle of the
// item for now.
QFontMetrics metrics( s_font );
setSize( metrics.size( 0, text ) );
m_text = text;
}

void TutorialItem::paint( GeoPainter *painter, ViewportParams *viewport,
const QString& renderPos, GeoSceneLayer * layer )
{
Q_UNUSED( renderPos )
Q_UNUSED( layer )

// Save the old painter state.
painter->save();
// We want to paint a black string.
painter->setPen( QPen( QColor( Qt::black ) ) );
// We will use our standard font.
painter->setFont( s_font );
// Draw the text into the given rect.
painter->drawText( QRect( QPoint( 0, 0 ), size().toSize() ), 0, m_text );
// Restore the old painter state.
painter->restore();
}

// This is needed for all QObjects (see MOC)
#include "TutorialItem.moc"
</syntaxhighlight>

Wasn't that easy? Continue with the next section.

== Model ==
We will continue developing the core component, the model. Let's first look at the header file:
'''TutorialModel.h'''
<syntaxhighlight lang="cpp-qt">
#ifndef TUTORIALMODEL_H
#define TUTORIALMODEL_H

#include "AbstractDataPluginModel.h"

namespace Marble {

class MarbleDataFacade;

// The maximum number of items we want to show on the screen.
const quint32 numberOfItemsOnScreen = 20;

class TutorialModel : public AbstractDataPluginModel
{
Q_OBJECT

public:
TutorialModel( PluginManager *pluginManager,
QObject *parent = 0 );
~TutorialModel();

protected:
/**
* Generates the download url for the description file from the web service depending on
* the @p box surrounding the view and the @p number of files to show.
**/
void getAdditionalItems( const GeoDataLatLonAltBox& box,
MarbleDataFacade *facade,
qint32 number = 10 );
};

}

#endif // TUTORIALMODEL_H
</syntaxhighlight>

You see that we have to implement the function getAdditionalItems(). getAdditionalItems() is called when the viewport has been changed significantly, so new items have to be generated.
For getAdditionalItems() we will go the easy way for now. We will simply add one item with a static position. That's a very simple method to test your painting code.

'''TutorialModel.cpp'''
<syntaxhighlight lang="cpp-qt">
// Self
#include "TutorialModel.h"

// Plugin
#include "TutorialItem.h"

// Marble
#include "global.h"
#include "MarbleDataFacade.h"
#include "GeoDataCoordinates.h"

// Qt
#include <QtCore/QDebug>
#include <QtCore/QString>

using namespace Marble;

TutorialModel::TutorialModel( PluginManager *pluginManager,
QObject *parent )
: AbstractDataPluginModel( "tutorial", pluginManager, parent )
{
}

TutorialModel::~TutorialModel() {
}

void TutorialModel::getAdditionalItems( const GeoDataLatLonAltBox& box,
MarbleDataFacade *facade,
qint32 number )
{
// This plugin only supports Tutorial items for earth
if( facade->target() != "earth" ) {
return;
}

// We will only create one item in our first tutorial.
// Every item has to get an id. We have to check if the item already exists.
if ( !itemExists( "tutorial1" ) ) {
// If it does not exists, create it
GeoDataCoordinates coor( 10.22 * DEG2RAD, 54.4 * DEG2RAD );
// The parent of the new item is this object
TutorialItem *item = new TutorialItem( this );
item->setCoordinate( coor );
item->setTarget( "earth" );
item->setId( "tutorial1" );
// The text we want to show, of course "Hello World!"
item->setText( "Hello Marble!" );
// Add the item to the list of items, so it will be displayed.
addItemToList( item );
}
}

#include "TutorialModel.moc"
</syntaxhighlight>

If you want to download files from a web server to get lists of items, you will want to use '''void downloadDescriptionFile( const QUrl& url )''' and you have to reimplement '''void parseFile( const QByteArray& file )''', which parses the downloaded description file and adds new items to the list.

If you want to download files per item (for example if you want to display images), you can use '''void downloadItemData( const QUrl& url, const QString& type, AbstractDataPluginItem *item )'''. This will also add the items to the list of items. The type is something you have to invent yourself. It has to be unique in your plugin. The function '''void addDownloadedFile( const QString& url, const QString& type )''' of our item is called when the download has been finished. This is what you need to implement.

To see examples of the usage of these functions, look at wikipedia-plugin and photo-plugin.

== Main Plugin Class ==
Now to the boring part of the tutorial: The main class.

'''TutorialPlugin.h'''
<syntaxhighlight lang="cpp-qt">
#ifndef TUTORIALPLUGIN_H
#define TUTORIALPLUGIN_H

#include "AbstractDataPlugin.h"
#include "RenderPlugin.h"
#include "RenderPluginInterface.h"

#include <QtGui/QIcon>

namespace Marble {

class TutorialPlugin : public AbstractDataPlugin {
Q_OBJECT
Q_INTERFACES( Marble::RenderPluginInterface )
MARBLE_PLUGIN( TutorialPlugin )

public:
TutorialPlugin();

virtual void initialize();

virtual bool isInitialized() const;

QString name() const;

QString guiString() const;

QString description() const;

QIcon icon() const;

private:
bool m_isInitialized;
};

}

#endif
</syntaxhighlight>

And the implementation:
'''TutorialPlugin.cpp'''
<syntaxhighlight lang="cpp-qt">
// Self
#include "TutorialPlugin.h"

#include "TutorialModel.h"

// Qt
#include <QtCore/QDebug>

using namespace Marble;

TutorialPlugin::TutorialPlugin()
: m_isInitialized( false )
{
setNameId( "tutorial" );

// Plugin is enabled by default
setEnabled( true );
// Plugin is invisible by default
setVisible( false );
}

void TutorialPlugin::initialize() {
setModel( new TutorialModel( pluginManager(), this ) );
// Setting the number of items on the screen.
setNumberOfItems( numberOfItemsOnScreen );

m_isInitialized = true;
}

bool TutorialPlugin::isInitialized() const {
return m_isInitialized;
}

QString TutorialPlugin::name() const {
return tr( "Tutorial Items" );
}

QString TutorialPlugin::guiString() const {
return tr( "&Tutorial" );
}

QString TutorialPlugin::description() const {
return tr( "Shows tutorial items on the map." );
}

QIcon TutorialPlugin::icon() const {
return QIcon();
}
// Because we want to create a plugin, we have to do the following line.
Q_EXPORT_PLUGIN2(TutorialPlugin, Marble::TutorialPlugin)

#include "TutorialPlugin.moc"
</syntaxhighlight>

== CMake ==
You can build the plugin anywhere. This needs the following file:
'''CMakeLists.txt'''
<syntaxhighlight lang="bash">
PROJECT( TutorialPlugin )

cmake_minimum_required( VERSION 2.4.8 )

find_package(Qt4 REQUIRED)
find_package(Marble REQUIRED)

INCLUDE_DIRECTORIES(
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_BINARY_DIR}
${QT_INCLUDE_DIR}
${MARBLE_INCLUDE_DIR}
)

set( tutorial_SRCS TutorialPlugin.cpp
TutorialModel.cpp
TutorialItem.cpp )

qt4_automoc( ${tutorial_SRCS} )
add_library( Tutorial MODULE ${tutorial_SRCS} )
target_link_libraries( Tutorial ${QT_QTCORE_LIBRARY}
${QT_QTGUI_LIBRARY}
${${_target_name}_LIBS}
${MARBLE_LIBRARIES} )
install( TARGETS Tutorial DESTINATION ${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}/kde4/plugins/marble/ )

set_target_properties( ${_target_name} PROPERTIES
INSTALL_RPATH_USE_LINK_PATH TRUE
SKIP_BUILD_RPATH TRUE
BUILD_WITH_INSTALL_RPATH TRUE
)
</syntaxhighlight>

The following commands will build the plugin then.

<syntaxhighlight lang="bash">
mkdir build
cd build
cmake ../
make
sudo make install
</syntaxhighlight>

If you use the qt-only version, you'll probably need to change the install path. We are currently working on a solution for that problem.

Projects/Marble/OnlineServices

2013-01-13T16:44:37Z

Mayankmadan:

{{TutorialBrowser|

series=Marble Tutorial|

name=Creating your first Marble Online Services Plugin|

pre=[[Projects/Marble/Runners/VehicleTracking|Tutorial 7 -Vehicle Tracking]]|

next=[[Projects/Marble/Routing/BasicRouting|Tutorial 9 - Searching]]|

reading=[[Development/Tutorials/CMake|CMake]]
}}

== Abstract ==
You will here learn to create your own online service plugins. If you don't know what is meant by online service, you will see these in the Marble menu at "View"->"Online Services".
You'll need KDE 4.3 to build this tutorial.
If you want to write plugins for Marble, it could be useful to do this in KDE's subversion. Please contact the Marble developers for this (IRC, E-Mail).

== Structure ==
An online services plugin or data plugin consist of three classes at least. The class to display the information is the Data Item (the base class is AbstractDataPluginItem). It stores the information for single places on the map and displays them.

The Model (base class AbstractDataPluginModel) stores all items. Storing the items will be done by AbstractDataPluginModel itself. Your only job is to get information for new items when the displayed part of the earth changes. This can include downloading so called "Description files" from the servers of an online service and parsing them. These "Description files" contain lists of items in a specific part of the earth (specified by a LatLonAltBox).

The class based on AbstractDataPlugin is the representation class of our plugin. It provides the name and the idea of the plugin. You also have to set your model there.

== Item ==
We will write our item first as it depends on nothing else. As you should already know the item stores the data and paints it on the screen. One item has an exact position on the globe as longitude, latitude and altitude.
The item we will write shows a text at the specific position.

We will now look at the header file to see what functions we have to implement.
'''TutorialItem.h'''
<syntaxhighlight lang="cpp-qt">
#ifndef TUTORIALITEM_H
#define TUTORIALITEM_H

#include "AbstractDataPluginItem.h"

class QFont;

namespace Marble
{

class TutorialItem : public AbstractDataPluginItem
{
Q_OBJECT

public:
TutorialItem( QObject *parent );

~TutorialItem();

// Returns the item type of the item.
QString itemType() const;

// Returns true if the item is paintable
bool initialized();

// Here the item gets painted
void paint( GeoPainter *painter, ViewportParams *viewport,
const QString& renderPos, GeoSceneLayer * layer = 0 );

bool operator<( const AbstractDataPluginItem *other ) const;

// The text we want to show on the map
QString text() const;
void setText( const QString& text );

private:
QString m_text;

static QFont s_font;
};

}
#endif // TUTORIALITEM_H
</syntaxhighlight>

As you have probably seen, it will be very easy to implement this as we have only one function (paint()) besides some getters and setters.

Let's have a look at the implementation.
'''TutorialItem.cpp'''
<syntaxhighlight lang="cpp-qt">
// Self
#include "TutorialItem.h"

// Marble
#include "GeoPainter.h"
#include "ViewportParams.h"

// Qt
#include <QtCore/QDebug>
#include <QtGui/QFontMetrics>

using namespace Marble;

// That's the font we will use to paint.
QFont TutorialItem::s_font = QFont( "Sans Serif", 8 );

TutorialItem::TutorialItem( QObject *parent )
: AbstractDataPluginItem( parent )
{
// The size of an item without a text is 0
setSize( QSize( 0, 0 ) );
}

TutorialItem::~TutorialItem()
{
}

QString TutorialItem::itemType() const
{
// Our itemType:
return "tutorialItem";
}

bool TutorialItem::initialized()
{
// The item is initialized if it has a text
if ( m_text.isEmpty() )
return false;
else
return true;
}

bool TutorialItem::operator<( const AbstractDataPluginItem *other ) const
{
// That's not a very nice priority estimation, you'll hopefully find
// a better one for your plugin.
return this->id() < other->id();
}

QString TutorialItem::text() const
{
return m_text;
}

void TutorialItem::setText( const QString& text )
{
// On a text change our size may also change, so we have to set the new
// item size. Marble needs to know how large an item is to find the correct
// bounding rect. The given position will always be in the middle of the
// item for now.
QFontMetrics metrics( s_font );
setSize( metrics.size( 0, text ) );
m_text = text;
}

void TutorialItem::paint( GeoPainter *painter, ViewportParams *viewport,
const QString& renderPos, GeoSceneLayer * layer )
{
Q_UNUSED( renderPos )
Q_UNUSED( layer )

// Save the old painter state.
painter->save();
// We want to paint a black string.
painter->setPen( QPen( QColor( Qt::black ) ) );
// We will use our standard font.
painter->setFont( s_font );
// Draw the text into the given rect.
painter->drawText( QRect( QPoint( 0, 0 ), size().toSize() ), 0, m_text );
// Restore the old painter state.
painter->restore();
}

// This is needed for all QObjects (see MOC)
#include "TutorialItem.moc"
</syntaxhighlight>

Wasn't that easy? Continue with the next section.

== Model ==
We will continue developing the core component, the model. Let's first look at the header file:
'''TutorialModel.h'''
<syntaxhighlight lang="cpp-qt">
#ifndef TUTORIALMODEL_H
#define TUTORIALMODEL_H

#include "AbstractDataPluginModel.h"

namespace Marble {

class MarbleDataFacade;

// The maximum number of items we want to show on the screen.
const quint32 numberOfItemsOnScreen = 20;

class TutorialModel : public AbstractDataPluginModel
{
Q_OBJECT

public:
TutorialModel( PluginManager *pluginManager,
QObject *parent = 0 );
~TutorialModel();

protected:
/**
* Generates the download url for the description file from the web service depending on
* the @p box surrounding the view and the @p number of files to show.
**/
void getAdditionalItems( const GeoDataLatLonAltBox& box,
MarbleDataFacade *facade,
qint32 number = 10 );
};

}

#endif // TUTORIALMODEL_H
</syntaxhighlight>

You see that we have to implement the function getAdditionalItems(). getAdditionalItems() is called when the viewport has been changed significantly, so new items have to be generated.
For getAdditionalItems() we will go the easy way for now. We will simply add one item with a static position. That's a very simple method to test your painting code.

'''TutorialModel.cpp'''
<syntaxhighlight lang="cpp-qt">
// Self
#include "TutorialModel.h"

// Plugin
#include "TutorialItem.h"

// Marble
#include "global.h"
#include "MarbleDataFacade.h"
#include "GeoDataCoordinates.h"

// Qt
#include <QtCore/QDebug>
#include <QtCore/QString>

using namespace Marble;

TutorialModel::TutorialModel( PluginManager *pluginManager,
QObject *parent )
: AbstractDataPluginModel( "tutorial", pluginManager, parent )
{
}

TutorialModel::~TutorialModel() {
}

void TutorialModel::getAdditionalItems( const GeoDataLatLonAltBox& box,
MarbleDataFacade *facade,
qint32 number )
{
// This plugin only supports Tutorial items for earth
if( facade->target() != "earth" ) {
return;
}

// We will only create one item in our first tutorial.
// Every item has to get an id. We have to check if the item already exists.
if ( !itemExists( "tutorial1" ) ) {
// If it does not exists, create it
GeoDataCoordinates coor( 10.22 * DEG2RAD, 54.4 * DEG2RAD );
// The parent of the new item is this object
TutorialItem *item = new TutorialItem( this );
item->setCoordinate( coor );
item->setTarget( "earth" );
item->setId( "tutorial1" );
// The text we want to show, of course "Hello World!"
item->setText( "Hello Marble!" );
// Add the item to the list of items, so it will be displayed.
addItemToList( item );
}
}

#include "TutorialModel.moc"
</syntaxhighlight>

If you want to download files from a web server to get lists of items, you will want to use '''void downloadDescriptionFile( const QUrl& url )''' and you have to reimplement '''void parseFile( const QByteArray& file )''', which parses the downloaded description file and adds new items to the list.

If you want to download files per item (for example if you want to display images), you can use '''void downloadItemData( const QUrl& url, const QString& type, AbstractDataPluginItem *item )'''. This will also add the items to the list of items. The type is something you have to invent yourself. It has to be unique in your plugin. The function '''void addDownloadedFile( const QString& url, const QString& type )''' of our item is called when the download has been finished. This is what you need to implement.

To see examples of the usage of these functions, look at wikipedia-plugin and photo-plugin.

== Main Plugin Class ==
Now to the boring part of the tutorial: The main class.

'''TutorialPlugin.h'''
<syntaxhighlight lang="cpp-qt">
#ifndef TUTORIALPLUGIN_H
#define TUTORIALPLUGIN_H

#include "AbstractDataPlugin.h"
#include "RenderPlugin.h"
#include "RenderPluginInterface.h"

#include <QtGui/QIcon>

namespace Marble {

class TutorialPlugin : public AbstractDataPlugin {
Q_OBJECT
Q_INTERFACES( Marble::RenderPluginInterface )
MARBLE_PLUGIN( TutorialPlugin )

public:
TutorialPlugin();

virtual void initialize();

virtual bool isInitialized() const;

QString name() const;

QString guiString() const;

QString description() const;

QIcon icon() const;

private:
bool m_isInitialized;
};

}

#endif
</syntaxhighlight>

And the implementation:
'''TutorialPlugin.cpp'''
<syntaxhighlight lang="cpp-qt">
// Self
#include "TutorialPlugin.h"

#include "TutorialModel.h"

// Qt
#include <QtCore/QDebug>

using namespace Marble;

TutorialPlugin::TutorialPlugin()
: m_isInitialized( false )
{
setNameId( "tutorial" );

// Plugin is enabled by default
setEnabled( true );
// Plugin is invisible by default
setVisible( false );
}

void TutorialPlugin::initialize() {
setModel( new TutorialModel( pluginManager(), this ) );
// Setting the number of items on the screen.
setNumberOfItems( numberOfItemsOnScreen );

m_isInitialized = true;
}

bool TutorialPlugin::isInitialized() const {
return m_isInitialized;
}

QString TutorialPlugin::name() const {
return tr( "Tutorial Items" );
}

QString TutorialPlugin::guiString() const {
return tr( "&Tutorial" );
}

QString TutorialPlugin::description() const {
return tr( "Shows tutorial items on the map." );
}

QIcon TutorialPlugin::icon() const {
return QIcon();
}
// Because we want to create a plugin, we have to do the following line.
Q_EXPORT_PLUGIN2(TutorialPlugin, Marble::TutorialPlugin)

#include "TutorialPlugin.moc"
</syntaxhighlight>

== CMake ==
You can build the plugin anywhere. This needs the following file:
'''CMakeLists.txt'''
<syntaxhighlight lang="bash">
PROJECT( TutorialPlugin )

cmake_minimum_required( VERSION 2.4.8 )

find_package(Qt4 REQUIRED)
find_package(Marble REQUIRED)

INCLUDE_DIRECTORIES(
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_BINARY_DIR}
${QT_INCLUDE_DIR}
${MARBLE_INCLUDE_DIR}
)

set( tutorial_SRCS TutorialPlugin.cpp
TutorialModel.cpp
TutorialItem.cpp )

qt4_automoc( ${tutorial_SRCS} )
add_library( Tutorial MODULE ${tutorial_SRCS} )
target_link_libraries( Tutorial ${QT_QTCORE_LIBRARY}
${QT_QTGUI_LIBRARY}
${${_target_name}_LIBS}
${MARBLE_LIBRARIES} )
install( TARGETS Tutorial DESTINATION ${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}/kde4/plugins/marble/ )

set_target_properties( ${_target_name} PROPERTIES
INSTALL_RPATH_USE_LINK_PATH TRUE
SKIP_BUILD_RPATH TRUE
BUILD_WITH_INSTALL_RPATH TRUE
)
</syntaxhighlight>

The following commands will build the plugin then.

<syntaxhighlight lang="bash">
mkdir build
cd build
cmake ../
make
sudo make install
</syntaxhighlight>

If you use the qt-only version, you'll probably need to change the install path. We are currently working on a solution for that problem.

Projects/Marble/OnlineServices

2013-01-13T16:21:46Z

Mayankmadan:

{{TutorialBrowser|

series=Marble Tutorial|

name=Creating your first Marble Online Services Plugin|

pre=[[Projects/Marble/Runners/VehicleTracking | Tutorial 7 - Vehicle Tracking]]|

next=[[Projects/Marble/Routing/BasicRouting| Tutorial 9 - Basic Routing|

reading=[[Development/Tutorials/CMake|CMake]]
}}

== Abstract ==
You will here learn to create your own online service plugins. If you don't know what is meant by online service, you will see these in the Marble menu at "View"->"Online Services".
You'll need KDE 4.3 to build this tutorial.
If you want to write plugins for Marble, it could be useful to do this in KDE's subversion. Please contact the Marble developers for this (IRC, E-Mail).

== Structure ==
An online services plugin or data plugin consist of three classes at least. The class to display the information is the Data Item (the base class is AbstractDataPluginItem). It stores the information for single places on the map and displays them.

The Model (base class AbstractDataPluginModel) stores all items. Storing the items will be done by AbstractDataPluginModel itself. Your only job is to get information for new items when the displayed part of the earth changes. This can include downloading so called "Description files" from the servers of an online service and parsing them. These "Description files" contain lists of items in a specific part of the earth (specified by a LatLonAltBox).

The class based on AbstractDataPlugin is the representation class of our plugin. It provides the name and the idea of the plugin. You also have to set your model there.

== Item ==
We will write our item first as it depends on nothing else. As you should already know the item stores the data and paints it on the screen. One item has an exact position on the globe as longitude, latitude and altitude.
The item we will write shows a text at the specific position.

We will now look at the header file to see what functions we have to implement.
'''TutorialItem.h'''
<syntaxhighlight lang="cpp-qt">
#ifndef TUTORIALITEM_H
#define TUTORIALITEM_H

#include "AbstractDataPluginItem.h"

class QFont;

namespace Marble
{

class TutorialItem : public AbstractDataPluginItem
{
Q_OBJECT

public:
TutorialItem( QObject *parent );

~TutorialItem();

// Returns the item type of the item.
QString itemType() const;

// Returns true if the item is paintable
bool initialized();

// Here the item gets painted
void paint( GeoPainter *painter, ViewportParams *viewport,
const QString& renderPos, GeoSceneLayer * layer = 0 );

bool operator<( const AbstractDataPluginItem *other ) const;

// The text we want to show on the map
QString text() const;
void setText( const QString& text );

private:
QString m_text;

static QFont s_font;
};

}
#endif // TUTORIALITEM_H
</syntaxhighlight>

As you have probably seen, it will be very easy to implement this as we have only one function (paint()) besides some getters and setters.

Let's have a look at the implementation.
'''TutorialItem.cpp'''
<syntaxhighlight lang="cpp-qt">
// Self
#include "TutorialItem.h"

// Marble
#include "GeoPainter.h"
#include "ViewportParams.h"

// Qt
#include <QtCore/QDebug>
#include <QtGui/QFontMetrics>

using namespace Marble;

// That's the font we will use to paint.
QFont TutorialItem::s_font = QFont( "Sans Serif", 8 );

TutorialItem::TutorialItem( QObject *parent )
: AbstractDataPluginItem( parent )
{
// The size of an item without a text is 0
setSize( QSize( 0, 0 ) );
}

TutorialItem::~TutorialItem()
{
}

QString TutorialItem::itemType() const
{
// Our itemType:
return "tutorialItem";
}

bool TutorialItem::initialized()
{
// The item is initialized if it has a text
if ( m_text.isEmpty() )
return false;
else
return true;
}

bool TutorialItem::operator<( const AbstractDataPluginItem *other ) const
{
// That's not a very nice priority estimation, you'll hopefully find
// a better one for your plugin.
return this->id() < other->id();
}

QString TutorialItem::text() const
{
return m_text;
}

void TutorialItem::setText( const QString& text )
{
// On a text change our size may also change, so we have to set the new
// item size. Marble needs to know how large an item is to find the correct
// bounding rect. The given position will always be in the middle of the
// item for now.
QFontMetrics metrics( s_font );
setSize( metrics.size( 0, text ) );
m_text = text;
}

void TutorialItem::paint( GeoPainter *painter, ViewportParams *viewport,
const QString& renderPos, GeoSceneLayer * layer )
{
Q_UNUSED( renderPos )
Q_UNUSED( layer )

// Save the old painter state.
painter->save();
// We want to paint a black string.
painter->setPen( QPen( QColor( Qt::black ) ) );
// We will use our standard font.
painter->setFont( s_font );
// Draw the text into the given rect.
painter->drawText( QRect( QPoint( 0, 0 ), size().toSize() ), 0, m_text );
// Restore the old painter state.
painter->restore();
}

// This is needed for all QObjects (see MOC)
#include "TutorialItem.moc"
</syntaxhighlight>

Wasn't that easy? Continue with the next section.

== Model ==
We will continue developing the core component, the model. Let's first look at the header file:
'''TutorialModel.h'''
<syntaxhighlight lang="cpp-qt">
#ifndef TUTORIALMODEL_H
#define TUTORIALMODEL_H

#include "AbstractDataPluginModel.h"

namespace Marble {

class MarbleDataFacade;

// The maximum number of items we want to show on the screen.
const quint32 numberOfItemsOnScreen = 20;

class TutorialModel : public AbstractDataPluginModel
{
Q_OBJECT

public:
TutorialModel( PluginManager *pluginManager,
QObject *parent = 0 );
~TutorialModel();

protected:
/**
* Generates the download url for the description file from the web service depending on
* the @p box surrounding the view and the @p number of files to show.
**/
void getAdditionalItems( const GeoDataLatLonAltBox& box,
MarbleDataFacade *facade,
qint32 number = 10 );
};

}

#endif // TUTORIALMODEL_H
</syntaxhighlight>

You see that we have to implement the function getAdditionalItems(). getAdditionalItems() is called when the viewport has been changed significantly, so new items have to be generated.
For getAdditionalItems() we will go the easy way for now. We will simply add one item with a static position. That's a very simple method to test your painting code.

'''TutorialModel.cpp'''
<syntaxhighlight lang="cpp-qt">
// Self
#include "TutorialModel.h"

// Plugin
#include "TutorialItem.h"

// Marble
#include "global.h"
#include "MarbleDataFacade.h"
#include "GeoDataCoordinates.h"

// Qt
#include <QtCore/QDebug>
#include <QtCore/QString>

using namespace Marble;

TutorialModel::TutorialModel( PluginManager *pluginManager,
QObject *parent )
: AbstractDataPluginModel( "tutorial", pluginManager, parent )
{
}

TutorialModel::~TutorialModel() {
}

void TutorialModel::getAdditionalItems( const GeoDataLatLonAltBox& box,
MarbleDataFacade *facade,
qint32 number )
{
// This plugin only supports Tutorial items for earth
if( facade->target() != "earth" ) {
return;
}

// We will only create one item in our first tutorial.
// Every item has to get an id. We have to check if the item already exists.
if ( !itemExists( "tutorial1" ) ) {
// If it does not exists, create it
GeoDataCoordinates coor( 10.22 * DEG2RAD, 54.4 * DEG2RAD );
// The parent of the new item is this object
TutorialItem *item = new TutorialItem( this );
item->setCoordinate( coor );
item->setTarget( "earth" );
item->setId( "tutorial1" );
// The text we want to show, of course "Hello World!"
item->setText( "Hello Marble!" );
// Add the item to the list of items, so it will be displayed.
addItemToList( item );
}
}

#include "TutorialModel.moc"
</syntaxhighlight>

If you want to download files from a web server to get lists of items, you will want to use '''void downloadDescriptionFile( const QUrl& url )''' and you have to reimplement '''void parseFile( const QByteArray& file )''', which parses the downloaded description file and adds new items to the list.

If you want to download files per item (for example if you want to display images), you can use '''void downloadItemData( const QUrl& url, const QString& type, AbstractDataPluginItem *item )'''. This will also add the items to the list of items. The type is something you have to invent yourself. It has to be unique in your plugin. The function '''void addDownloadedFile( const QString& url, const QString& type )''' of our item is called when the download has been finished. This is what you need to implement.

To see examples of the usage of these functions, look at wikipedia-plugin and photo-plugin.

== Main Plugin Class ==
Now to the boring part of the tutorial: The main class.

'''TutorialPlugin.h'''
<syntaxhighlight lang="cpp-qt">
#ifndef TUTORIALPLUGIN_H
#define TUTORIALPLUGIN_H

#include "AbstractDataPlugin.h"
#include "RenderPlugin.h"
#include "RenderPluginInterface.h"

#include <QtGui/QIcon>

namespace Marble {

class TutorialPlugin : public AbstractDataPlugin {
Q_OBJECT
Q_INTERFACES( Marble::RenderPluginInterface )
MARBLE_PLUGIN( TutorialPlugin )

public:
TutorialPlugin();

virtual void initialize();

virtual bool isInitialized() const;

QString name() const;

QString guiString() const;

QString description() const;

QIcon icon() const;

private:
bool m_isInitialized;
};

}

#endif
</syntaxhighlight>

And the implementation:
'''TutorialPlugin.cpp'''
<syntaxhighlight lang="cpp-qt">
// Self
#include "TutorialPlugin.h"

#include "TutorialModel.h"

// Qt
#include <QtCore/QDebug>

using namespace Marble;

TutorialPlugin::TutorialPlugin()
: m_isInitialized( false )
{
setNameId( "tutorial" );

// Plugin is enabled by default
setEnabled( true );
// Plugin is invisible by default
setVisible( false );
}

void TutorialPlugin::initialize() {
setModel( new TutorialModel( pluginManager(), this ) );
// Setting the number of items on the screen.
setNumberOfItems( numberOfItemsOnScreen );

m_isInitialized = true;
}

bool TutorialPlugin::isInitialized() const {
return m_isInitialized;
}

QString TutorialPlugin::name() const {
return tr( "Tutorial Items" );
}

QString TutorialPlugin::guiString() const {
return tr( "&Tutorial" );
}

QString TutorialPlugin::description() const {
return tr( "Shows tutorial items on the map." );
}

QIcon TutorialPlugin::icon() const {
return QIcon();
}
// Because we want to create a plugin, we have to do the following line.
Q_EXPORT_PLUGIN2(TutorialPlugin, Marble::TutorialPlugin)

#include "TutorialPlugin.moc"
</syntaxhighlight>

== CMake ==
You can build the plugin anywhere. This needs the following file:
'''CMakeLists.txt'''
<syntaxhighlight lang="bash">
PROJECT( TutorialPlugin )

cmake_minimum_required( VERSION 2.4.8 )

find_package(Qt4 REQUIRED)
find_package(Marble REQUIRED)

INCLUDE_DIRECTORIES(
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_BINARY_DIR}
${QT_INCLUDE_DIR}
${MARBLE_INCLUDE_DIR}
)

set( tutorial_SRCS TutorialPlugin.cpp
TutorialModel.cpp
TutorialItem.cpp )

qt4_automoc( ${tutorial_SRCS} )
add_library( Tutorial MODULE ${tutorial_SRCS} )
target_link_libraries( Tutorial ${QT_QTCORE_LIBRARY}
${QT_QTGUI_LIBRARY}
${${_target_name}_LIBS}
${MARBLE_LIBRARIES} )
install( TARGETS Tutorial DESTINATION ${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}/kde4/plugins/marble/ )

set_target_properties( ${_target_name} PROPERTIES
INSTALL_RPATH_USE_LINK_PATH TRUE
SKIP_BUILD_RPATH TRUE
BUILD_WITH_INSTALL_RPATH TRUE
)
</syntaxhighlight>

The following commands will build the plugin then.

<syntaxhighlight lang="bash">
mkdir build
cd build
cmake ../
make
sudo make install
</syntaxhighlight>

If you use the qt-only version, you'll probably need to change the install path. We are currently working on a solution for that problem.

Projects/Marble/Runners/VehicleTracking

2013-01-13T16:15:20Z

Mayankmadan:

Projects/Marble/Runners/DisplayGeoDataPlacemark

2013-01-13T16:11:56Z

Mayankmadan:

{{TutorialBrowser|

series=Marble C++ Tutorial|

name=Search|

pre=[[Projects/Marble/Runners/LoadingOSM|Tutorial 5 - Loading OSM files in MarbleWidget]]|

next=[[Projects/Marble/Runners/VehicleTracking|Tutorial 7 - Vehicle Tracking]]|
}}

In this tutorial we'll show how you can create a nice shiny '''placemark''' with an ''icon'' and associated '''geometries''' (such as ''LineStrings, LinearRings, Polygons or MultiGeometries''). We also cover basic '''styling''' of placemarks and geometries.

[https://developers.google.com/kml/documentation/kmlreference#placemark GeoDataPlacemark] is a class which implements the features of [https://developers.google.com/kml/documentation/kmlreference#placemark KML's Placemark]. Basically, it represents an interest point (a simple point or a more complex geometry) on the map, with some information attached.

In order to add a GeoDataPlacemark to our widget, we will use the [https://developers.google.com/kml/documentation/kmlreference#document GeoDataDocument] class, which is a container for [https://developers.google.com/kml/documentation/kmlreference#feature features] (including placemarks) and [https://developers.google.com/kml/documentation/kmlreference#feature styles]. To make the Document visible, we need to add it to Marble's TreeModel, as shown in the first example below:

<source lang="cpp-qt">
#include <QtGui/QApplication>
#include <QtGui/QTreeView>
#include <QtCore/QDataStream>
#include <QtCore/QFile>
#include <QtCore/QIODevice>

#include <marble/MarbleWidget.h>
#include <marble/GeoDataDocument.h>
#include <marble/GeoDataPlacemark.h>
#include <marble/GeoDataLineString.h>
#include <marble/GeoDataTreeModel.h>
#include <marble/MarbleModel.h>

#include <cstdio>

using namespace Marble;

int main(int argc, char** argv) {

QApplication app(argc,argv);

// Create a Marble QWidget without a parent
MarbleWidget *mapWidget = new MarbleWidget();

// Load the OpenStreetMap map
mapWidget->setMapThemeId("earth/plain/plain.dgml");

GeoDataPlacemark *place = new GeoDataPlacemark( "Bucharest" );
place->setCoordinate( 25.97, 44.43, 0.0, GeoDataCoordinates::Degree );
place->setPopulation( 1877155 );
place->setCountryCode ( "Romania" );

GeoDataDocument *document = new GeoDataDocument;
document->append( place );

// Add the document to MarbleWidget's tree model
mapWidget->model()->treeModel()->addDocument( document );

mapWidget->show();

return app.exec();
}
</source>

Copy and paste the code above into a text editor. Then save it as <tt>my_marble.cpp</tt> and compile it by entering the following command on the command line:

<source lang="bash">
g++ -I /usr/include/qt4/ -o my_marble my_marble.cpp -lmarblewidget -lQtGui -lQtCore
</source>

If things go fine, execute <tt>./my_marble</tt> and you are going to see the placemark of our newly created Bucharest point.

[[Image:PlacemarkTask_bis.png]]

The data we have set for our city (Population and Country) also appear, when clicking on the placemark.

[[Image:PlacemarkTask2.png]]

As we said earlier in this tutorial, it is possible to add more complex geometry to a placemark, meaning objects belonging to [https://developers.google.com/kml/documentation/kmlreference#geometry GeoDataGeometry] or to one of the classes which inherit it.

[https://developers.google.com/kml/documentation/kmlreference#style Styles] are another important property of placemarks. They are used in order to customize the appearance of the placemark on the map (e.g. by adding an icon). Geometries such as LineStrings, LinearRings or Polygons can be styled as well: You can change properties such as the pen color, the brush color and the line width.

The next example shows how more complex geometry and styles can be added, by creating Bucharest's city boundary, and by adding an interest point (touristic objective) with a photo replacing the regular placemark icon. (in order for the example to work properly you will need to download the [http://techbase.kde.org/File:Bucharest_small.jpg icon] and place it in the same folder as the source code)

<source lang="cpp-qt">
#include <QtGui/QApplication>
#include <QtGui/QTreeView>

#include <marble/MarbleWidget.h>
#include <marble/MarbleModel.h>

#include <marble/GeoDataDocument.h>
#include <marble/GeoDataCoordinates.h>
#include <marble/GeoDataPlacemark.h>
#include <marble/GeoDataLineString.h>
#include <marble/GeoDataLinearRing.h>
#include <marble/GeoDataTreeModel.h>
#include <marble/GeoDataStyle.h>
#include <marble/GeoDataIconStyle.h>
#include <marble/GeoDataLineStyle.h>
#include <marble/GeoDataPolyStyle.h>

#include <cstdio>

using namespace Marble;

void addPoints( GeoDataLinearRing &linearRing ) {

linearRing << GeoDataCoordinates(25.97226722704463, 44.43497647488007, 0, GeoDataCoordinates::Degree )
<< GeoDataCoordinates(26.04711276456992, 44.4420741223712, 0, GeoDataCoordinates::Degree )
<< GeoDataCoordinates(25.99712510557899, 44.48015825036597, 0, GeoDataCoordinates::Degree )
<< GeoDataCoordinates(26.11268978668501, 44.53902366720936, 0, GeoDataCoordinates::Degree )
<< GeoDataCoordinates(26.12777496065434, 44.48972441010599, 0, GeoDataCoordinates::Degree )
<< GeoDataCoordinates(26.17769825773425, 44.47685689461117, 0, GeoDataCoordinates::Degree )
<< GeoDataCoordinates(26.16489863910029, 44.45366647920105, 0, GeoDataCoordinates::Degree )
<< GeoDataCoordinates(26.23394105442375, 44.43247765101769, 0, GeoDataCoordinates::Degree )
<< GeoDataCoordinates(26.23388161223319, 44.40720014793351, 0, GeoDataCoordinates::Degree )
<< GeoDataCoordinates(26.18689640043445, 44.40683215952335, 0, GeoDataCoordinates::Degree )
<< GeoDataCoordinates(26.1462530009004, 44.36252655873379, 0, GeoDataCoordinates::Degree )
<< GeoDataCoordinates(25.97226722704463, 44.43497647488007, 0, GeoDataCoordinates::Degree );

}

void createStyleBucharest( GeoDataStyle &style ) {
GeoDataLineStyle lineStyle( QColor( 255, 0, 0, 90 ) );
lineStyle.setWidth ( 8 );

GeoDataPolyStyle polyStyle( QColor( 255, 0, 0, 40 ) );
polyStyle.setFill( true );

style.setLineStyle( lineStyle );
style.setPolyStyle( polyStyle );
}

void createStyleArch( GeoDataStyle &style ) {
GeoDataIconStyle iconStyle;
iconStyle.setIconPath( "bucharest_small.jpg" );
style.setIconStyle( iconStyle );
}

int main(int argc, char** argv) {

QApplication app(argc,argv);

// Create a Marble QWidget without a parent
MarbleWidget *mapWidget = new MarbleWidget();

// Load the OpenStreetMap map
mapWidget->setMapThemeId("earth/openstreetmap/openstreetmap.dgml");

//Create the Linear Ring (polygon) representing Bucharest's boundaries and include it in a placemark
GeoDataLinearRing Bucharest;
addPoints( Bucharest );

GeoDataPlacemark placemarkBucharest;
placemarkBucharest.setGeometry( &Bucharest );

//Create the placemark representing the Arch of Triumph
GeoDataPlacemark placemarkArch( "Arch of Triumph" );
placemarkArch.setCoordinate( 26.0783, 44.4671, 0, GeoDataCoordinates::Degree );

//Add styles (icons, colors, etc.) to the two placemarks
GeoDataStyle styleBucharest, styleArch;

createStyleBucharest( styleBucharest );
placemarkBucharest.setStyle( &styleBucharest );

createStyleArch ( styleArch );
placemarkArch.setStyle( &styleArch );

//Create the document and add the two placemarks (the point representing the Arch of Triumph and the polygon with Bucharest's boundaries)
GeoDataDocument *document = new GeoDataDocument;
document->append( &placemarkBucharest );
document->append( &placemarkArch );

// Add the document to MarbleWidget's tree model
mapWidget->model()->treeModel()->addDocument( document );

// Center the map on Bucharest and set the zoom
mapWidget->centerOn( GeoDataCoordinates( 26.0783, 44.4671, 0, GeoDataCoordinates::Degree ) );
mapWidget->zoomView( 2400 );

mapWidget->show();

return app.exec();
}
</source>

This is the expected outcome after compiling, running and zooming into Bucharest:

[[Image:Bucharest.png]]

Projects/Marble/Runners/LoadingOSM

2013-01-13T16:05:13Z

Mayankmadan:

{{TutorialBrowser|

series=Marble C++ Tutorial|

name=Loading OSM files in MarbleWidget|

pre=[[Projects/Marble/Runners/LoadingKML|Tutorial 4 - Changing basic map properties]]|

next=[[Projects/Marble/Runners/DisplayGeoDataPlacemark|Tutorial 6 - Displaying places the proper way(via GeoDataDocument)]]|
}}

= Exporting OSM =
Osm files can be used for creating small street maps or can be scaled to store streets worldwide. OSM files can be exported from [http://openstreetmap.org OpenStreetMaps] by clicking the export button as shown below.

[[File:OsmTutorial.png| 500px| center]]

= Loading OSM files into a Marble Widget =

Marble uses so-called runners to calculate routes, do reverse geocoding, parse files and search for placemarks (cities, addresses, points of interest, ...). This tutorial shows how to open a .osm file and display it into the Marble Widget.

<source lang="cpp-qt">
#include <QtCore/QDebug>
#include <QtCore/QFileInfo>
#include <QtGui/QApplication>

#include <marble/MarbleWidget.h>
#include <marble/MarbleModel.h>

using namespace Marble;

int main(int argc, char** argv)
{
QApplication app(argc,argv);

QFileInfo inputFile( app.arguments().last() );
if ( app.arguments().size() < 2 || !inputFile.exists() ) {
qWarning() << "Usage: " << app.arguments().first() << "file.osm";
return 1;
}

MarbleWidget *mapWidget = new MarbleWidget();
mapWidget->setMapThemeId("earth/openstreetmap/openstreetmap.dgml");

mapWidget->centerOn( GeoDataCoordinates( 77.5674, 12.9782, 0, GeoDataCoordinates::Degree ) );
mapWidget->zoomView( 3000 );

mapWidget->model()->addGeoDataFile( inputFile.absoluteFilePath() );

mapWidget->show();

return app.exec();
}</source>

Copy and paste the code above into a text editor. Then save it as <tt>my_marble.cpp</tt> and compile it by entering the following command on the command line:

<source lang="bash">
g++ -I /usr/include/qt4/ -o my_marble my_marble.cpp -lmarblewidget -lQtGui -lQtCore
</source>
If things go fine, execute <tt>./my_marble some-file.osm</tt> and you get a Marble Widget which displays your OSM file. For example, download and unpack [http://techbase.kde.org/images.techbase/5/51/Map.tar.gz Map.osm] (a [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataLinearRing.html LinearRing] representing Bangalore city junction), place it in the same folder as your <tt>my_marble.cpp</tt> file and run <tt>./my_marble map.osm</tt>. The result should be similar to this:

[[Image:OsmTutorial1.png]]

The placemarks on the map are clickable and trigger a dialog. The screenshot below is of the dialog of Bangalore City Station triggered by clicking it on the map.

[[File:OsmTutorial2.png|600px]]

{{note|
If you provide maps in your application please check the '''Terms of Use''' of the map material. The map material that is shipped with Marble is licensed ''in the spirit of Free Software''. This usually means at least that the authors should be credited and that the license is mentioned.
E.g. for ''OpenStreetMap'' the license is [http://creativecommons.org/license/by-sa/2.0 CC-BY-SA]. Other map data shipped with Marble is either public domain or licensed in the spirit of the BSD license.
}}

[[Category:Tutorial]]

Projects/Marble/Runners/LoadingOSM

2013-01-13T16:02:22Z

Mayankmadan:

{{TutorialBrowser|

series=Marble C++ Tutorial|

name=Loading OSM files in MarbleWidget|

pre=[[Projects/Marble/Runners/LoadingKML|Tutorial 4 - Changing basic map properties]]|

next=[[Projects/Marble/Runners/DisplayGeoDataPlacemarks|Tutorial 6 - Displaying places the proper way(via GeoDataDocument)]]|
}}

= Exporting OSM =
Osm files can be used for creating small street maps or can be scaled to store streets worldwide. OSM files can be exported from [http://openstreetmap.org OpenStreetMaps] by clicking the export button as shown below.

[[File:OsmTutorial.png| 500px| center]]

= Loading OSM files into a Marble Widget =

Marble uses so-called runners to calculate routes, do reverse geocoding, parse files and search for placemarks (cities, addresses, points of interest, ...). This tutorial shows how to open a .osm file and display it into the Marble Widget.

<source lang="cpp-qt">
#include <QtCore/QDebug>
#include <QtCore/QFileInfo>
#include <QtGui/QApplication>

#include <marble/MarbleWidget.h>
#include <marble/MarbleModel.h>

using namespace Marble;

int main(int argc, char** argv)
{
QApplication app(argc,argv);

QFileInfo inputFile( app.arguments().last() );
if ( app.arguments().size() < 2 || !inputFile.exists() ) {
qWarning() << "Usage: " << app.arguments().first() << "file.osm";
return 1;
}

MarbleWidget *mapWidget = new MarbleWidget();
mapWidget->setMapThemeId("earth/openstreetmap/openstreetmap.dgml");

mapWidget->centerOn( GeoDataCoordinates( 77.5674, 12.9782, 0, GeoDataCoordinates::Degree ) );
mapWidget->zoomView( 3000 );

mapWidget->model()->addGeoDataFile( inputFile.absoluteFilePath() );

mapWidget->show();

return app.exec();
}</source>

Copy and paste the code above into a text editor. Then save it as <tt>my_marble.cpp</tt> and compile it by entering the following command on the command line:

<source lang="bash">
g++ -I /usr/include/qt4/ -o my_marble my_marble.cpp -lmarblewidget -lQtGui -lQtCore
</source>
If things go fine, execute <tt>./my_marble some-file.osm</tt> and you get a Marble Widget which displays your OSM file. For example, download and unpack [http://techbase.kde.org/images.techbase/5/51/Map.tar.gz Map.osm] (a [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataLinearRing.html LinearRing] representing Bangalore city junction), place it in the same folder as your <tt>my_marble.cpp</tt> file and run <tt>./my_marble map.osm</tt>. The result should be similar to this:

[[Image:OsmTutorial1.png]]

The placemarks on the map are clickable and trigger a dialog. The screenshot below is of the dialog of Bangalore City Station triggered by clicking it on the map.

[[File:OsmTutorial2.png|600px]]

{{note|
If you provide maps in your application please check the '''Terms of Use''' of the map material. The map material that is shipped with Marble is licensed ''in the spirit of Free Software''. This usually means at least that the authors should be credited and that the license is mentioned.
E.g. for ''OpenStreetMap'' the license is [http://creativecommons.org/license/by-sa/2.0 CC-BY-SA]. Other map data shipped with Marble is either public domain or licensed in the spirit of the BSD license.
}}

[[Category:Tutorial]]

Projects/Marble/Runners/LoadingKML

2013-01-13T16:00:03Z

Mayankmadan:

{{TutorialBrowser|

series=Marble C++ Tutorial|

name=Search|

pre=[[Projects/Marble/MarbleSignalsSlots|Tutorial 3 - Basic Interactions with MarbleWidget]]|

next=[[Projects/Marble/Runners/LoadingOSM|Tutorial 5 - Loading OSM files into MarbleWidget]]|}}

== Loading KML files into a Marble Widget ==

Marble uses so-called runners to calculate routes, do reverse geocoding, parse files and search for placemarks (cities, addresses, points of interest, ...). This tutorial shows how to open a .kml (or .gpx, .osm, ...) file and display it into the Marble Widget.

<source lang="cpp-qt">
#include <QtCore/QDebug>
#include <QtCore/QFileInfo>
#include <QtGui/QApplication>

#include <marble/MarbleWidget.h>
#include <marble/MarbleModel.h>

using namespace Marble;

int main(int argc, char** argv)
{
QApplication app(argc,argv);

QFileInfo inputFile( app.arguments().last() );
if ( app.arguments().size() < 2 || !inputFile.exists() ) {
qWarning() << "Usage: " << app.arguments().first() << "file.kml";
return 1;
}

MarbleWidget *mapWidget = new MarbleWidget();
mapWidget->setMapThemeId("earth/openstreetmap/openstreetmap.dgml");

mapWidget->centerOn( GeoDataCoordinates( 26.0783, 44.4671, 0, GeoDataCoordinates::Degree ) );
mapWidget->zoomView( 2200 );

mapWidget->model()->addGeoDataFile( inputFile.absoluteFilePath() );

mapWidget->show();

return app.exec();
}</source>

Copy and paste the code above into a text editor. Then save it as <tt>my_marble.cpp</tt> and compile it by entering the following command on the command line:

<source lang="bash">
g++ -I /usr/include/qt4/ -o my_marble my_marble.cpp -lmarblewidget -lQtGui -lQtCore
</source>

If things go fine, execute <tt>./my_marble some-file.kml</tt> and you get a Marble Widget which displays your KML file. For example, download and unpack [http://techbase.kde.org/images.techbase/b/bd/Bucharest.kml.gz Bucharest.kml] (a [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataLinearRing.html LinearRing] representing Bucharest's city boundaries), place it in the same folder as your <tt>my_marble.cpp</tt> file and run <tt>./my_marble bucharest.kml</tt>. The result should be similar to this:

[[Image:LoadKML.png]]

{{
note|
The same method works for loading other file types too, like OpenStreetMap (.osm), GPX and Shapefiles (.shp).
}}

{{note|
If you provide maps in your application please check the '''Terms of Use''' of the map material. The map material that is shipped with Marble is licensed ''in the spirit of Free Software''. This usually means at least that the authors should be credited and that the license is mentioned.
E.g. for ''OpenStreetMap'' the license is [http://creativecommons.org/license/by-sa/2.0 CC-BY-SA]. Other map data shipped with Marble is either public domain or licensed in the spirit of the BSD license.
}}

Projects/Marble/Runners/LoadingKML

2013-01-13T15:59:33Z

Mayankmadan:

{{TutorialBrowser|

series=Marble C++ Tutorial|

name=Search|

pre=[[Projects/Marble/MarbleSignalSlots|Tutorial 3 - Basic Interactions with MarbleWidget]]|

next=[[Projects/Marble/Runners/LoadingOSM|Tutorial 5 - Loading OSM files into MarbleWidget]]|}}

== Loading KML files into a Marble Widget ==

Marble uses so-called runners to calculate routes, do reverse geocoding, parse files and search for placemarks (cities, addresses, points of interest, ...). This tutorial shows how to open a .kml (or .gpx, .osm, ...) file and display it into the Marble Widget.

<source lang="cpp-qt">
#include <QtCore/QDebug>
#include <QtCore/QFileInfo>
#include <QtGui/QApplication>

#include <marble/MarbleWidget.h>
#include <marble/MarbleModel.h>

using namespace Marble;

int main(int argc, char** argv)
{
QApplication app(argc,argv);

QFileInfo inputFile( app.arguments().last() );
if ( app.arguments().size() < 2 || !inputFile.exists() ) {
qWarning() << "Usage: " << app.arguments().first() << "file.kml";
return 1;
}

MarbleWidget *mapWidget = new MarbleWidget();
mapWidget->setMapThemeId("earth/openstreetmap/openstreetmap.dgml");

mapWidget->centerOn( GeoDataCoordinates( 26.0783, 44.4671, 0, GeoDataCoordinates::Degree ) );
mapWidget->zoomView( 2200 );

mapWidget->model()->addGeoDataFile( inputFile.absoluteFilePath() );

mapWidget->show();

return app.exec();
}</source>

Copy and paste the code above into a text editor. Then save it as <tt>my_marble.cpp</tt> and compile it by entering the following command on the command line:

<source lang="bash">
g++ -I /usr/include/qt4/ -o my_marble my_marble.cpp -lmarblewidget -lQtGui -lQtCore
</source>

If things go fine, execute <tt>./my_marble some-file.kml</tt> and you get a Marble Widget which displays your KML file. For example, download and unpack [http://techbase.kde.org/images.techbase/b/bd/Bucharest.kml.gz Bucharest.kml] (a [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataLinearRing.html LinearRing] representing Bucharest's city boundaries), place it in the same folder as your <tt>my_marble.cpp</tt> file and run <tt>./my_marble bucharest.kml</tt>. The result should be similar to this:

[[Image:LoadKML.png]]

{{
note|
The same method works for loading other file types too, like OpenStreetMap (.osm), GPX and Shapefiles (.shp).
}}

{{note|
If you provide maps in your application please check the '''Terms of Use''' of the map material. The map material that is shipped with Marble is licensed ''in the spirit of Free Software''. This usually means at least that the authors should be credited and that the license is mentioned.
E.g. for ''OpenStreetMap'' the license is [http://creativecommons.org/license/by-sa/2.0 CC-BY-SA]. Other map data shipped with Marble is either public domain or licensed in the spirit of the BSD license.
}}

Template:TutorialBrowser

2013-01-13T15:57:22Z

Mayankmadan:

<div class="rbroundbox" style="width:100%;">
<div class="rbtopwrap">
<div class="rbtop"><div></div></div>{{{name}}}</div>
<div class="rbcontent">
{|style="width:100%; background:#dadde0;"
|-
| width=10% align=right valign=top | '''Tutorial Series'''  
| {{{series|n/a}}}
|-
| align=right valign=top | '''Previous'''  
| {{{pre|None}}}
|-
| align=right valign=top | '''What's Next'''  
| {{{next|n/a}}}
|-
| align=right valign=top | '''Further Reading'''  
|{{{reading|n/a}}}
|}
</div>
<div class="rbbot"><div></div></div>
</div>
[[Category:Tutorial]]<noinclude>

==Recommended Usage==
To keep some sort of consistency to our wiki: if you're going to use this template, put it at the very top of the page, above any ==headers== (that will also place it above the page contents section) so readers can find the relevant info as quickly as possible.

Also note that this template will automatically add the page to the [[:Category:Tutorial|tutorial category]] so there's no need to do that yourself.

==Parameters==

{| class="wikitable"
|-
! Parameter !! Function
|-
| '''series''' || The name of the tutorial series this belongs to.
|-
| '''name''' || Verbose(ish) name of this tutorial. Kind of a super short abstract.
|-
| '''pre''' || Previous tutorial (try to order them sensibly and make sure they're links!).
|-
| '''next''' || A tutorial or two which logically follow on from this (in the same series). Or a tutorial or two which make sense to move onto next.
|-
| '''reading''' || Further reading about the subject matter covered in the tutorial
|-
|}

[[Category:Template]]
</noinclude>

Projects/Marble/MarbleSignalsSlots

2013-01-13T15:56:33Z

Mayankmadan:

{{TutorialBrowser|

series=Marble C++ Tutorial|

name=Basic interaction with MarbleWidget|

pre=[[Projects/Marble/MarbleMarbleWidget|Tutorial 2 - Changing basic map properties]]|

next=[[Projects/Marble/Runners/LoadingKML|Tutorial 4 - Loading KML files into MarbleWidget]]|
}}

== Creating a window with controls ==
We'd like to add other widgets to our Marble window: A '''zoom slider''' and a '''label''' that shows the current mouse position in '''geodetic''' coordinates: ''longitude'' and ''latitude''.

In order to achieve this we need to create a vertical layout. Once we are done we add the slider and the label that we created to the layout. Also we zoom the globe to the slider's default value using the [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1MarbleWidget.html#d49d8ab0be0721c579bb511bdda45829 MarbleWidget::zoomView(int)] method.

We want to center our globe onto South America. So we create a new [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataCoordinates.html GeoDataCoordinates] object that takes the longitude and the latitude as a parameter and we call [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1MarbleWidget.html#7cda9942ead26d60c89a7b54a073a2fd MarbleWidget::centerOn].

As you might have realized already GeoDataCoordinates is the geodetic "sister" of [http://doc.trolltech.com/qapplication.html QPoint]. They share a very similar API. Additionally GeoDataCoordinates features a nice set of string conversion methods ([http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataCoordinates.html#ce27e6f714e21be067995c2cf96544d6 GeoDataCoordinates::fromString()], [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataCoordinates.html#558b72384563190dc2ce119a1f75de86 GeoDataCoordinates::lonToString()] and [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataCoordinates.html#558b72384563190dc2ce119a1f75de86 GeoDataCoordinates::latToString()]). They are used in various places inside Marble such as the signal [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1MarbleWidget.html#0869df8f4666014aff93d9ba1c130bc3 MarbleWidget::mouseMoveGeoPosition(const QString&) ].

Finally we connect the [http://doc.trolltech.com/signalsandslots.html signals and slots] that MarbleWidget offers to the signals and slots of the slider and the label:

<source lang="cpp">
#include <QtGui/QApplication>

#include <QtGui/QLayout>
#include <QtGui/QSlider>
#include <QtGui/QLabel>

#include <marble/MarbleWidget.h>

using namespace Marble;

int main(int argc, char** argv)
{
QApplication app(argc,argv);
QWidget *window = new QWidget;

// Create a Marble QWidget without a parent
MarbleWidget *mapWidget = new MarbleWidget();

// Load the Plain map
mapWidget->setMapThemeId("earth/plain/plain.dgml");

// Hide the FloatItems: OverviewMap, ScaleBar and Compass
mapWidget->setShowOverviewMap(false);
mapWidget->setShowScaleBar(false);
mapWidget->setShowCompass(false);

// Create a horizontal zoom slider and set the default zoom
QSlider * zoomSlider = new QSlider(Qt::Horizontal);
zoomSlider->setMinimum( 1000 );
zoomSlider->setMaximum( 2400 );

mapWidget->zoomView( zoomSlider->value() );

// Create a label to show the geodetic position
QLabel * positionLabel = new QLabel();
positionLabel->setSizePolicy( QSizePolicy::Preferred, QSizePolicy::Fixed );

// Add all widgets to the vertical layout.
QVBoxLayout *layout = new QVBoxLayout;
layout->addWidget(mapWidget);
layout->addWidget(zoomSlider);
layout->addWidget(positionLabel);

// Center the map onto a given position
GeoDataCoordinates home(-60.0, -10.0, 0.0, GeoDataCoordinates::Degree);
mapWidget->centerOn(home);

// Connect the map widget to the position label.
QObject::connect( mapWidget, SIGNAL( mouseMoveGeoPosition( QString ) ),
positionLabel, SLOT( setText( QString ) ) );

// Connect the zoom slider to the map widget and vice versa.
QObject::connect( zoomSlider, SIGNAL( valueChanged(int) ),
mapWidget, SLOT( zoomView(int) ) );
QObject::connect( mapWidget, SIGNAL( zoomChanged(int) ),
zoomSlider, SLOT( setValue(int) ) );

window->setLayout(layout);
window->resize( 400, 300 );

window->show();

return app.exec();
}
</source>

Save the code above as <tt>marble_control.cpp</tt> and compile it:

<source lang="bash">
g++ -I /usr/include/qt4/ -o marble_control marble_control.cpp -lmarblewidget -lQtGui
</source>

If things go fine, execute <tt>./marble_control</tt> and you end up with a map application that displays our globe with a zoom slider below:

[[Image:Marble_control.png]]

Projects/Marble/MarbleSignalsSlots

2013-01-13T15:54:38Z

Mayankmadan:

{{TutorialBrowser|

series=Marble C++ Tutorial|

name=Basic interaction with MarbleWidget|

pre=[[Projects/Marble/MarbleMarbleWidget|Tutorial 2 - Changing basic map properties]]|

next=[[Projects/Marble/Runner/LoadingKML|Tutorial 4 - Loading KML files into MarbleWidget]]|
}}

== Creating a window with controls ==
We'd like to add other widgets to our Marble window: A '''zoom slider''' and a '''label''' that shows the current mouse position in '''geodetic''' coordinates: ''longitude'' and ''latitude''.

In order to achieve this we need to create a vertical layout. Once we are done we add the slider and the label that we created to the layout. Also we zoom the globe to the slider's default value using the [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1MarbleWidget.html#d49d8ab0be0721c579bb511bdda45829 MarbleWidget::zoomView(int)] method.

We want to center our globe onto South America. So we create a new [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataCoordinates.html GeoDataCoordinates] object that takes the longitude and the latitude as a parameter and we call [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1MarbleWidget.html#7cda9942ead26d60c89a7b54a073a2fd MarbleWidget::centerOn].

As you might have realized already GeoDataCoordinates is the geodetic "sister" of [http://doc.trolltech.com/qapplication.html QPoint]. They share a very similar API. Additionally GeoDataCoordinates features a nice set of string conversion methods ([http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataCoordinates.html#ce27e6f714e21be067995c2cf96544d6 GeoDataCoordinates::fromString()], [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataCoordinates.html#558b72384563190dc2ce119a1f75de86 GeoDataCoordinates::lonToString()] and [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataCoordinates.html#558b72384563190dc2ce119a1f75de86 GeoDataCoordinates::latToString()]). They are used in various places inside Marble such as the signal [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1MarbleWidget.html#0869df8f4666014aff93d9ba1c130bc3 MarbleWidget::mouseMoveGeoPosition(const QString&) ].

Finally we connect the [http://doc.trolltech.com/signalsandslots.html signals and slots] that MarbleWidget offers to the signals and slots of the slider and the label:

<source lang="cpp">
#include <QtGui/QApplication>

#include <QtGui/QLayout>
#include <QtGui/QSlider>
#include <QtGui/QLabel>

#include <marble/MarbleWidget.h>

using namespace Marble;

int main(int argc, char** argv)
{
QApplication app(argc,argv);
QWidget *window = new QWidget;

// Create a Marble QWidget without a parent
MarbleWidget *mapWidget = new MarbleWidget();

// Load the Plain map
mapWidget->setMapThemeId("earth/plain/plain.dgml");

// Hide the FloatItems: OverviewMap, ScaleBar and Compass
mapWidget->setShowOverviewMap(false);
mapWidget->setShowScaleBar(false);
mapWidget->setShowCompass(false);

// Create a horizontal zoom slider and set the default zoom
QSlider * zoomSlider = new QSlider(Qt::Horizontal);
zoomSlider->setMinimum( 1000 );
zoomSlider->setMaximum( 2400 );

mapWidget->zoomView( zoomSlider->value() );

// Create a label to show the geodetic position
QLabel * positionLabel = new QLabel();
positionLabel->setSizePolicy( QSizePolicy::Preferred, QSizePolicy::Fixed );

// Add all widgets to the vertical layout.
QVBoxLayout *layout = new QVBoxLayout;
layout->addWidget(mapWidget);
layout->addWidget(zoomSlider);
layout->addWidget(positionLabel);

// Center the map onto a given position
GeoDataCoordinates home(-60.0, -10.0, 0.0, GeoDataCoordinates::Degree);
mapWidget->centerOn(home);

// Connect the map widget to the position label.
QObject::connect( mapWidget, SIGNAL( mouseMoveGeoPosition( QString ) ),
positionLabel, SLOT( setText( QString ) ) );

// Connect the zoom slider to the map widget and vice versa.
QObject::connect( zoomSlider, SIGNAL( valueChanged(int) ),
mapWidget, SLOT( zoomView(int) ) );
QObject::connect( mapWidget, SIGNAL( zoomChanged(int) ),
zoomSlider, SLOT( setValue(int) ) );

window->setLayout(layout);
window->resize( 400, 300 );

window->show();

return app.exec();
}
</source>

Save the code above as <tt>marble_control.cpp</tt> and compile it:

<source lang="bash">
g++ -I /usr/include/qt4/ -o marble_control marble_control.cpp -lmarblewidget -lQtGui
</source>

If things go fine, execute <tt>./marble_control</tt> and you end up with a map application that displays our globe with a zoom slider below:

[[Image:Marble_control.png]]

Projects/Marble/Runners/LoadingOSM

2013-01-08T22:45:24Z

Mayankmadan: /* Loading OSM files into a Marble Widget */

= Exporting OSM =
Osm files can be used for creating small street maps or can be scaled to store streets worldwide. OSM files can be exported from [http://openstreetmap.org OpenStreetMaps] by clicking the export button as shown below.

[[File:OsmTutorial.png| 500px| center]]

= Loading OSM files into a Marble Widget =

Marble uses so-called runners to calculate routes, do reverse geocoding, parse files and search for placemarks (cities, addresses, points of interest, ...). This tutorial shows how to open a .osm file and display it into the Marble Widget.

<source lang="cpp-qt">
#include <QtCore/QDebug>
#include <QtCore/QFileInfo>
#include <QtGui/QApplication>

#include <marble/MarbleWidget.h>
#include <marble/MarbleModel.h>

using namespace Marble;

int main(int argc, char** argv)
{
QApplication app(argc,argv);

QFileInfo inputFile( app.arguments().last() );
if ( app.arguments().size() < 2 || !inputFile.exists() ) {
qWarning() << "Usage: " << app.arguments().first() << "file.osm";
return 1;
}

MarbleWidget *mapWidget = new MarbleWidget();
mapWidget->setMapThemeId("earth/openstreetmap/openstreetmap.dgml");

mapWidget->centerOn( GeoDataCoordinates( 77.5674, 12.9782, 0, GeoDataCoordinates::Degree ) );
mapWidget->zoomView( 3000 );

mapWidget->model()->addGeoDataFile( inputFile.absoluteFilePath() );

mapWidget->show();

return app.exec();
}</source>

Copy and paste the code above into a text editor. Then save it as <tt>my_marble.cpp</tt> and compile it by entering the following command on the command line:

<source lang="bash">
g++ -I /usr/include/qt4/ -o my_marble my_marble.cpp -lmarblewidget -lQtGui -lQtCore
</source>
If things go fine, execute <tt>./my_marble some-file.osm</tt> and you get a Marble Widget which displays your OSM file. For example, download and unpack [http://techbase.kde.org/images.techbase/5/51/Map.tar.gz Map.osm] (a [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataLinearRing.html LinearRing] representing Bangalore city junction), place it in the same folder as your <tt>my_marble.cpp</tt> file and run <tt>./my_marble map.osm</tt>. The result should be similar to this:

[[Image:OsmTutorial1.png]]

The placemarks on the map are clickable and trigger a dialog. The screenshot below is of the dialog of Bangalore City Station triggered by clicking it on the map.

[[File:OsmTutorial2.png|600px]]

{{note|
If you provide maps in your application please check the '''Terms of Use''' of the map material. The map material that is shipped with Marble is licensed ''in the spirit of Free Software''. This usually means at least that the authors should be credited and that the license is mentioned.
E.g. for ''OpenStreetMap'' the license is [http://creativecommons.org/license/by-sa/2.0 CC-BY-SA]. Other map data shipped with Marble is either public domain or licensed in the spirit of the BSD license.
}}

[[Category:Tutorial]]

Projects/Marble/Runners/LoadingOSM

2013-01-08T22:40:02Z

Mayankmadan: /* Loading OSM files into a Marble Widget */

= Exporting OSM =
Osm files can be used for creating small street maps or can be scaled to store streets worldwide. OSM files can be exported from [http://openstreetmap.org OpenStreetMaps] by clicking the export button as shown below.

[[File:OsmTutorial.png| 500px| center]]

= Loading OSM files into a Marble Widget =

Marble uses so-called runners to calculate routes, do reverse geocoding, parse files and search for placemarks (cities, addresses, points of interest, ...). This tutorial shows how to open a .osm file and display it into the Marble Widget.

<source lang="cpp-qt">
#include <QtCore/QDebug>
#include <QtCore/QFileInfo>
#include <QtGui/QApplication>

#include <marble/MarbleWidget.h>
#include <marble/MarbleModel.h>

using namespace Marble;

int main(int argc, char** argv)
{
QApplication app(argc,argv);

QFileInfo inputFile( app.arguments().last() );
if ( app.arguments().size() < 2 || !inputFile.exists() ) {
qWarning() << "Usage: " << app.arguments().first() << "file.osm";
return 1;
}

MarbleWidget *mapWidget = new MarbleWidget();
mapWidget->setMapThemeId("earth/openstreetmap/openstreetmap.dgml");

mapWidget->centerOn( GeoDataCoordinates( 77.5674, 12.9782, 0, GeoDataCoordinates::Degree ) );
mapWidget->zoomView( 3000 );

mapWidget->model()->addGeoDataFile( inputFile.absoluteFilePath() );

mapWidget->show();

return app.exec();
}</source>

Copy and paste the code above into a text editor. Then save it as <tt>my_marble.cpp</tt> and compile it by entering the following command on the command line:

<source lang="bash">
g++ -I /usr/include/qt4/ -o my_marble my_marble.cpp -lmarblewidget -lQtGui -lQtCore
</source>
If things go fine, execute <tt>./my_marble some-file.osm</tt> and you get a Marble Widget which displays your OSM file. For example, download and unpack [http://techbase.kde.org/images.techbase/5/51/Map.tar.gz Map.osm] (a [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataLinearRing.html LinearRing] representing Bangalore city junction), place it in the same folder as your <tt>my_marble.cpp</tt> file and run <tt>./my_marble map.osm</tt>. The result should be similar to this:

[[Image:OsmTutorial1.png]]

The placemarks on the map are clickable and triggers a dialog. The Screenshot below is of the dialog of Bangalore City Station triggered by clicking it on the map.

[[File:OsmTutorial2.png|600px]]

{{note|
If you provide maps in your application please check the '''Terms of Use''' of the map material. The map material that is shipped with Marble is licensed ''in the spirit of Free Software''. This usually means at least that the authors should be credited and that the license is mentioned.
E.g. for ''OpenStreetMap'' the license is [http://creativecommons.org/license/by-sa/2.0 CC-BY-SA]. Other map data shipped with Marble is either public domain or licensed in the spirit of the BSD license.
}}

[[Category:Tutorial]]

Projects/Marble/Runners/LoadingOSM

2013-01-08T22:36:24Z

Mayankmadan:

= Exporting OSM =
Osm files can be used for creating small street maps or can be scaled to store streets worldwide. OSM files can be exported from [http://openstreetmap.org OpenStreetMaps] by clicking the export button as shown below.

[[File:OsmTutorial.png| 500px| center]]

= Loading OSM files into a Marble Widget =

Marble uses so-called runners to calculate routes, do reverse geocoding, parse files and search for placemarks (cities, addresses, points of interest, ...). This tutorial shows how to open a .osm file and display it into the Marble Widget.

<source lang="cpp-qt">
#include <QtCore/QDebug>
#include <QtCore/QFileInfo>
#include <QtGui/QApplication>

#include <marble/MarbleWidget.h>
#include <marble/MarbleModel.h>

using namespace Marble;

int main(int argc, char** argv)
{
QApplication app(argc,argv);

QFileInfo inputFile( app.arguments().last() );
if ( app.arguments().size() < 2 || !inputFile.exists() ) {
qWarning() << "Usage: " << app.arguments().first() << "file.osm";
return 1;
}

MarbleWidget *mapWidget = new MarbleWidget();
mapWidget->setMapThemeId("earth/openstreetmap/openstreetmap.dgml");

mapWidget->centerOn( GeoDataCoordinates( 77.5674, 12.9782, 0, GeoDataCoordinates::Degree ) );
mapWidget->zoomView( 3000 );

mapWidget->model()->addGeoDataFile( inputFile.absoluteFilePath() );

mapWidget->show();

return app.exec();
}</source>

Copy and paste the code above into a text editor. Then save it as <tt>my_marble.cpp</tt> and compile it by entering the following command on the command line:

<source lang="bash">
g++ -I /usr/include/qt4/ -o my_marble my_marble.cpp -lmarblewidget -lQtGui -lQtCore
</source>
If things go fine, execute <tt>./my_marble some-file.osm</tt> and you get a Marble Widget which displays your OSM file. For example, download and unpack [http://techbase.kde.org/images.techbase/5/51/Map.tar.gz Map.osm] (a [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataLinearRing.html LinearRing] representing Bangalore city junction), place it in the same folder as your <tt>my_marble.cpp</tt> file and run <tt>./my_marble map.osm</tt>. The result should be similar to this:

[[Image:OsmTutorial1.png]]

The placemarks on the map are clickable and triggers a dialog. The Screenshot below is of the dialog for Bangalore City Station triggered by clicking it on the map.

[[File:OsmTutorial2.png|600px]]

{{note|
If you provide maps in your application please check the '''Terms of Use''' of the map material. The map material that is shipped with Marble is licensed ''in the spirit of Free Software''. This usually means at least that the authors should be credited and that the license is mentioned.
E.g. for ''OpenStreetMap'' the license is [http://creativecommons.org/license/by-sa/2.0 CC-BY-SA]. Other map data shipped with Marble is either public domain or licensed in the spirit of the BSD license.
}}

[[Category:Tutorial]]

Projects/Marble/Runners/LoadingOSM

2013-01-08T22:34:35Z

Mayankmadan: Created page with "= Exporting OSM = Osm files can be used for creating small street maps or can be scaled to store streets worldwide. OSM files can be exported from [http://openstreetmap.org Op..."

= Exporting OSM =
Osm files can be used for creating small street maps or can be scaled to store streets worldwide. OSM files can be exported from [http://openstreetmap.org OpenStreetMaps] by clicking the export button as shown below.

[[File:OsmTutorial.png| 500px| center]]

= Loading OSM files into a Marble Widget =

Marble uses so-called runners to calculate routes, do reverse geocoding, parse files and search for placemarks (cities, addresses, points of interest, ...). This tutorial shows how to open a .osm file and display it into the Marble Widget.

<source lang="cpp-qt">
#include <QtCore/QDebug>
#include <QtCore/QFileInfo>
#include <QtGui/QApplication>

#include <marble/MarbleWidget.h>
#include <marble/MarbleModel.h>

using namespace Marble;

int main(int argc, char** argv)
{
QApplication app(argc,argv);

QFileInfo inputFile( app.arguments().last() );
if ( app.arguments().size() < 2 || !inputFile.exists() ) {
qWarning() << "Usage: " << app.arguments().first() << "file.osm";
return 1;
}

MarbleWidget *mapWidget = new MarbleWidget();
mapWidget->setMapThemeId("earth/openstreetmap/openstreetmap.dgml");

mapWidget->centerOn( GeoDataCoordinates( 77.5674, 12.9782, 0, GeoDataCoordinates::Degree ) );
mapWidget->zoomView( 3000 );

mapWidget->model()->addGeoDataFile( inputFile.absoluteFilePath() );

mapWidget->show();

return app.exec();
}</source>

Copy and paste the code above into a text editor. Then save it as <tt>my_marble.cpp</tt> and compile it by entering the following command on the command line:

<source lang="bash">
g++ -I /usr/include/qt4/ -o my_marble my_marble.cpp -lmarblewidget -lQtGui -lQtCore
</source>
If things go fine, execute <tt>./my_marble some-file.osm</tt> and you get a Marble Widget which displays your OSM file. For example, download and unpack [http://techbase.kde.org/images.techbase/5/51/Map.tar.gz Map.osm] (a [http://api.kde.org/4.x-api/kdeedu-apidocs/marble/html/classMarble_1_1GeoDataLinearRing.html LinearRing] representing Bangalore city junction), place it in the same folder as your <tt>my_marble.cpp</tt> file and run <tt>./my_marble map.osm</tt>. The result should be similar to this:

[[Image:OsmTutorial1.png]]

The placemarks are clickable and triggers a dialog. The Screenshot below is of the dialog for Bangalore City Station triggered by clicking it on the map.

[[File:OsmTutorial2.png|600px]]

{{note|
If you provide maps in your application please check the '''Terms of Use''' of the map material. The map material that is shipped with Marble is licensed ''in the spirit of Free Software''. This usually means at least that the authors should be credited and that the license is mentioned.
E.g. for ''OpenStreetMap'' the license is [http://creativecommons.org/license/by-sa/2.0 CC-BY-SA]. Other map data shipped with Marble is either public domain or licensed in the spirit of the BSD license.
}}

File:OsmTutorial2.png

2013-01-08T22:30:03Z

Mayankmadan:

File:OsmTutorial.png

2013-01-08T22:18:10Z

Mayankmadan:

File:OsmTutorial1.png

2013-01-08T22:07:15Z

Mayankmadan:

File:Map.tar.gz

2013-01-08T21:07:46Z

Mayankmadan: