Fix QtLocation documentation

This moves the docs to its proper place and fixes content as well as
broken links.

There are still some warnings left.

Change-Id: Ie83086f4feabab5f3b3d6c92eb6b401a5ff43e29
Reviewed-by: Alex <alexander.blasche@digia.com>

26 files changed, 3363 insertions, 0 deletions

diff --git a/src/location/doc/src/cpp-qml.qdoc b/src/location/doc/src/cpp-qml.qdoc
new file mode 100644
index 00000000..3e38edb0
--- /dev/null
+++ b/src/location/doc/src/cpp-qml.qdoc
@@ -0,0 +1,145 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page location-cpp-qml.html
+\title Interfaces between C++ and QML Code
+
+\brief Some of the location QML types providing interfaces to access and modify properties in C++.
+
+\section2 Category - QPlaceCategory
+\target category
+The \l {Category::category} {Category.category} property is used to provide an interface between C++ and QML code.  First a pointer to a
+Category object must be obtained from C++, then use the \l {QObject::property()}{property()} and
+\l {QObject::setProperty()}{setProperty()} functions to get and set the \c category property.
+The following gets the QPlaceCategory representing this object from C++:
+\snippet cpp/cppqml.cpp Category get
+The following sets the properties of this object based on a QPlaceCategory object from C++:
+\snippet cpp/cppqml.cpp Category set
+
+
+\section2 ContactDetail - QDeclarativeContactDetail
+\target contact_detail
+The \l {ContactDetail::contactDetail} {ContactDetail.contactDetail} property is used to provide an interface between C++ and QML code.  First a pointer to a ContactDetail object must be obtained from C++, then use the
+\l {QObject::property()}{property()} and \l {QObject::setProperty()}{setProperty()} functions
+to get and set the \c contactDetail property.
+The following gets the QPlaceContactDetail representing this object from C++:
+\snippet cpp/cppqml.cpp ContactDetail get
+The following sets the properties of this object based on a QPlaceContactDetail object from
+C++:
+\snippet cpp/cppqml.cpp ContactDetail set
+
+
+\section2  Place - QPlace
+\target place
+The \l {Place::place} {Place.place} property is used to provide an interface between C++ and QML code.  First a pointer to a Place object must be obtained from C++, then use the
+\l {QObject::property()}{property()} and \l {QObject::setProperty()}{setProperty()} functions
+to get and set the \c place property.
+The following gets the QPlace representing this object from C++:
+\snippet cpp/cppqml.cpp Place get
+The following sets the properties of this object based on a QPlace object from C++:
+\snippet cpp/cppqml.cpp Place set
+
+
+
+\section2  PlaceAttribute - QPlaceAttribute
+\target placeattribute
+The \l {PlaceAttribute::attribute} {PlaceAttribute.attribute} property is used to provide an interface between C++ and QML code.  First a pointer to a
+PlaceAttribute object must be obtained from C++, then use the
+\l {QObject::property()}{property()} and \l {QObject::setProperty()}{setProperty()} functions
+to get and set the \c attribute property.
+The following gets the QPlaceAttribute representing this object from C++:
+\snippet cpp/cppqml.cpp PlaceAttribute get
+The following sets the properties of this object based on a QPlaceAttribute object from C++:
+\snippet cpp/cppqml.cpp PlaceAttribute set
+
+
+\section2 Icon - QPlaceIcon
+\target placeicon
+The \l {Icon::icon} {Icon.icon} property is used to provide an interface between C++ and QML code.  First a pointer to a Icon object must be obtained from C++, then use the \l {QObject::property()}{property()} and
+\l {QObject::setProperty()}{setProperty()} functions to get and set the \c icon property.
+The following gets the QPlaceIcon representing this object from C++:
+\snippet cpp/cppqml.cpp Icon get
+The following sets the properties of this object based on a QPlaceIcon object from C++:
+\snippet cpp/cppqml.cpp Icon set
+
+
+\section2 User - QPlaceUser
+\target placeuser
+The \l {User::user} {User.user} property is used to provide an interface between C++ and QML code.  First a pointer to a
+User object must be obtained from C++, then use the \l {QObject::property()}{property()} and
+\l {QObject::setProperty()}{setProperty()} functions to get and set the \c user property.
+The following gets the QPlaceUser representing this object from C++:
+\snippet cpp/cppqml.cpp User get
+The following sets the properties of this object based on a QPlaceUser object from C++:
+\snippet cpp/cppqml.cpp User set
+
+
+\section2 Ratings - QPlaceRatings
+\target placeratings
+The \l {Ratings::ratings} {Ratings.ratings} property is used to provide an interface between C++ and QML code.  First a pointer to a
+Ratings object must be obtained from C++, then use the \l {QObject::property()}{property()} and
+\l {QObject::setProperty()}{setProperty()} functions to get and set the \c ratings property.
+The following gets the QPlaceRating representing this object from C++:
+\snippet cpp/cppqml.cpp Ratings get
+The following sets the properties of this object based on a QPlaceRatings object from C++:
+\snippet cpp/cppqml.cpp Ratings set
+
+
+\section2 Supplier - QPlaceSupplier
+\target placesupplier
+The \l {Supplier::supplier} {Supplier.supplier} property is used to provide an interface between C++ and QML code.  First a pointer to a
+Supplier object must be obtained from C++, then use the \l {QObject::property()}{property()} and
+\l {QObject::setProperty()}{setProperty()} functions to get and set the \c supplier property.
+The following gets the QPlaceSupplier representing this object from C++:
+\snippet cpp/cppqml.cpp Supplier get
+The following sets the properties of this object based on a QPlaceSupplier object from C++:
+\snippet cpp/cppqml.cpp Supplier set
+
+
+\section2 Address - QGeoAddress
+\target geoaddress
+The \l {Address::address} {Address.address} property is used to provide an interface between C++ and QML code.  First a pointer to a
+Address object must be obtained from C++, then use the \l {QObject::property()}{property()} and
+\l {QObject::setProperty()}{setProperty()} functions to get and set the \c address property.
+The following gets the QGeoAddress representing this object from C++:
+\snippet cpp/cppqml.cpp Address get
+The following sets the properties of this object based on a QGeoAddress object from C++:
+\snippet cpp/cppqml.cpp Address set
+
+
+\section2 Location - QGeoLocation
+\target location
+The \l {Location::location} {Location.location} property is used to provide an interface between C++ and QML code.  First a pointer to a
+Location object must be obtained from C++, then use the \l {QObject::property()}{property()} and
+\l {QObject::setProperty()}{setProperty()} functions to get and set the \c location property.
+The following gets the QGeoLocation representing this object from C++:
+\snippet cpp/cppqml.cpp Location get
+The following sets the properties of this object based on a QGeoLocation object from C++:
+\snippet cpp/cppqml.cpp Location set
+
+*/
diff --git a/src/location/doc/src/examples/declarative-flickr.qdoc b/src/location/doc/src/examples/declarative-flickr.qdoc
new file mode 100644
index 00000000..99c2792d
--- /dev/null
+++ b/src/location/doc/src/examples/declarative-flickr.qdoc
@@ -0,0 +1,83 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \example declarative/flickr
+    \title Flickr (QML)
+    \ingroup qtlocation-examples
+
+    \brief The Flickr example shows how to use the user's current location to
+           fetch local content from a web service.
+
+    This is a small example, illustrating one of the very core parts of the
+    Qt Location API: the ability to retrieve and use the user's current
+    geographic location.
+
+    Key QML types shown in this example:
+    \list
+        \li \l{QtLocation5::PositionSource}{PositionSource}
+        \li \l{XmlListModel}{XmlListModel}
+    \endlist
+
+    \image  qml-flickr-1.jpg
+
+    \section2 Retrieving the Current Location
+
+    Retrieving the user's current location is achieved using the PositionSource
+    type. In this example, we instantiate the PositionSource as part of the
+    GeoTab component (the floating "window" describing current location and
+    status).
+
+    \snippet flickr/flickrmobile/GeoTab.qml possrc
+
+    When the "Locate and update" button is pressed, we first interrogate the
+    PositionSource to check if it has an available backend for positioning
+    data. If it does not, we fall back to using a pre-recorded NMEA log
+    for demonstration. We then instruct the PositionSource to update.
+
+    \snippet flickr/flickrmobile/GeoTab.qml locatebutton-top
+    \snippet flickr/flickrmobile/GeoTab.qml locatebutton-clicked
+
+    To share the new position data with the rest of the application, we use
+    properties that we have created on the GeoTab component:
+
+    \snippet flickr/flickrmobile/GeoTab.qml props
+
+    The longitude and latitude values retrieved here are eventually set on
+    in properties on the RestModel component. The RestModel is an XmlListModel,
+    which retrieves XML data from a URL and creates a data model by performing
+    XPath queries on it.
+
+    In this case, it retrieves data from the Flickr REST API online, based on
+    our current location
+
+    \snippet flickr/flickrcommon/RestModel.qml restmodel
+
+    This model data is then shown in a variety of Qt Quick views to produce
+    the example application.
+
+*/
diff --git a/src/location/doc/src/examples/declarative-mapviewer.qdoc b/src/location/doc/src/examples/declarative-mapviewer.qdoc
new file mode 100644
index 00000000..6fbec0e9
--- /dev/null
+++ b/src/location/doc/src/examples/declarative-mapviewer.qdoc
@@ -0,0 +1,193 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \example declarative/mapviewer
+    \title Map Viewer (QML)
+    \ingroup qtlocation-examples
+
+    \brief The Map Viewer example shows how to display and interact with a map,
+           search for an address, and find driving directions.
+
+    This is a large example covering many basic uses of maps, positioning, and
+    navigation services in Qt Location. This page is divided into sections
+    covering each of these areas of functionality with snippets from the code.
+
+    The Map Viewer example can work with any of the available geo services plugins.  However, some
+    plugins may require additional \l {QtLocation5::PluginParameter}{plugin parameters} in order to
+    function correctly.  \l {QtLocation5::PluginParameter}{Plugin parameters} can be passed on the
+    command line using the \c {--plugin} argument, which takes the form:
+
+    \code
+        --plugin.<parameter name> <parameter value>
+    \endcode
+
+    Refer to the documentation for each of the geo services plugins for details on what plugin
+    parameters they support.  The Nokia services plugin supplied with Qt requires an \e app_id and
+    \e token pair.  See "\l {Qt Location Nokia Plugin}" for details.
+
+    QML types shown in this example:
+
+    \list
+    \li Displaying a map
+        \list
+        \li \l{QtLocation5::Map}{Map}
+        \li \l{QtLocation5::MapGestureArea}{MapGestureArea}
+        \li \l{coordinate}
+        \endlist
+    \li Finding an address
+        \list
+        \li \l{QtLocation5::GeocodeModel}{GeocodeModel}
+        \li \l{QtLocation5::MapItemView}{MapItemView}
+        \li \l{QtLocation5::MapCircle}{MapCircle}
+        \endlist
+    \li Directions and travel routes
+        \list
+        \li \l{QtLocation5::RouteModel}{RouteModel}
+        \li \l{QtLocation5::MapRoute}{MapRoute}
+        \endlist
+    \endlist
+
+    \image ../images/example-mapviewer.png
+
+    \section2 Displaying a Map
+
+    Drawing a map on-screen is accomplished using the Map type, as shown
+    below.
+
+    \snippet mapviewer/content/map/MapComponent.qml top
+    \snippet mapviewer/content/map/MapComponent.qml coord
+    \snippet mapviewer/content/map/MapComponent.qml end
+
+    In this example, we give the map an initial center \l {coordinate}
+    with a set latitude and longitude. We also set the initial zoom level to 50% (halfway between
+    the maximum and minimum).
+
+    The calls to "pinch" and "flick" are used to enable gestures on the map.
+    The flick gesture is also sometimes known as "kinetic panning", and provides
+    a more intuitive feel for panning the map both on touch screens and with
+    a mouse.
+
+    As we do not specify a plugin for supplying map data, the platform default
+    will be used. This is typically the "nokia" plugin, which provides data from
+    Nokia services. Additional licensing conditions do apply to the use of this data,
+    please see the documentation for further details.
+
+    \section2 Finding an Address (Geocoding)
+
+    To locate a certain address or place on the map uses a process called
+    geocoding. In order to perform a geocode operation, we first need to adjust
+    our Map object to be able to receive the result.
+
+    Receiving results of geocoding is done through a GeocodeModel, which is
+    typically instantiated as a property of the Map component:
+
+    \snippet mapviewer/content/map/MapComponent.qml geocodemodel0
+    \snippet mapviewer/content/map/MapComponent.qml geocodemodel1
+
+    Then, to display the contents of the GeocodeModel we use a MapItemView:
+
+    \snippet mapviewer/content/map/MapComponent.qml geocodeview
+
+    MapItemView uses an object called a "delegate" to act as a template for the
+    items it creates. This can contain any map object desired, but in this case
+    we show a MapCircle:
+
+    \snippet mapviewer/content/map/MapComponent.qml pointdel0
+    \snippet mapviewer/content/map/MapComponent.qml pointdel1
+
+    With these three objects, we have enough to receive Geocode responses and
+    display them on our Map. The final piece is to send the actual Geocode
+    request.
+
+    In this example, we have a utility component called Dialog which we use
+    to display the user interface requesting geocoding parameters. You can
+    create a similar component yourself using Dialog.qml in this example
+    as a reference, or drive the process using any other UI you wish.
+
+    To send a geocode request, first we create an Address object, and fill it
+    in with the desired parameters. Then we set "map.geocodeModel.query" to
+    the filled in Address, and call update() on the GeocodeModel.
+
+    \snippet mapviewer/mapviewer.qml geocode0
+    \snippet mapviewer/mapviewer.qml geocode1
+    \snippet mapviewer/mapviewer.qml geocode2
+
+    \section2 Directions and Travel Routes
+
+    Similar to the GeocodeModel, Qt Location also features the RouteModel type,
+    which allows information about routes (for example driving directions) between two
+    or more points, to be received and used with a Map.
+
+    Here again, we instantiate the RouteModel as a property of our Map:
+
+    \snippet mapviewer/content/map/MapComponent.qml routemodel0
+    \snippet mapviewer/content/map/MapComponent.qml routemodel3
+
+    To display the contents of a model to the user, we need a view. Once again
+    we will use a MapItemView, to display the Routes as objects on the Map:
+
+    \snippet mapviewer/content/map/MapComponent.qml routeview
+
+    To act as a template for the objects we wish the view to create, we create
+    a delegate component:
+
+    \snippet mapviewer/content/map/MapComponent.qml routedelegate0
+    \snippet mapviewer/content/map/MapComponent.qml routedelegate1
+
+    With the model, view and delegate now complete, the only missing component
+    is some kind of control over the model to begin the Route request process.
+    In the simplest case, we can fill out a Route request using two already
+    available \l {coordinate}{coordinates}, which we store inside the RouteDialog
+    component:
+
+    \snippet mapviewer/mapviewer.qml routedialog0
+    \snippet mapviewer/mapviewer.qml routedialog1
+
+    In the next snippet, we show how to set up the request object and instruct
+    the model to update. We also instruct the map to center on the start
+    coordinate for our routing request.
+
+    \snippet mapviewer/mapviewer.qml routerequest0
+    \snippet mapviewer/mapviewer.qml routerequest1
+
+    This is all that is required to display a Route on the Map. However, it is
+    also useful to be able to retrieve the written directions and explanation
+    of the travel route. In the example, these are displayed in the pull-out
+    on the left-hand side of the map. To create this pull-out's contents, we
+    use a standard \l {Models and Views in Qt Quick#ListModel}{ListModel} and
+    \l {ListView} pair. The data in the \l {Models and Views in Qt Quick#ListModel}{ListModel} is
+    built from the routeModel's output:
+
+    \snippet mapviewer/content/map/MapComponent.qml routeinfomodel
+
+    Inside the RouteModel, we add an
+    \l{QtLocation5::RouteModel::status}{onStatusChanged} handler, which
+    calls the \c{update()} function we defined on the model:
+
+    \snippet mapviewer/content/map/MapComponent.qml routemodel1
+*/
diff --git a/src/location/doc/src/examples/declarative-places.qdoc b/src/location/doc/src/examples/declarative-places.qdoc
new file mode 100644
index 00000000..30848740
--- /dev/null
+++ b/src/location/doc/src/examples/declarative-places.qdoc
@@ -0,0 +1,220 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \example declarative/places
+    \title Places (QML)
+    \ingroup qtlocation-examples
+
+    \brief The Places example demonstrates how to search for Places and access
+           related content.
+
+    \image qml-places.png
+
+    \section1 Overview
+
+    The Places example presents an application window displaying a map.  At the top of the window
+    is a search box, which is used to enter a place search query.  To search for a place enter a
+    search term into the text box and click the magnifying glass icon.  To search for a place by
+    category, click the category icon to display the list of available categories and select the
+    desired category.  The place search query will be for places that are near the current location
+    shown on the map.
+
+    The search box provides search term suggestions when three or more characters are entered.
+    Selecting one of the suggestions will cause a place search to be performed with the selected
+    search text.
+
+    Search results are available from the slide out tab on the left.  Clicking on a search result
+    will display details about the place.  If a places has rich content (editorials, reviews and
+    images), these can be accessed by the buttons on the details page.  To find similar places
+    click the "Find similar" button.  If the current Geo service provider supports it, buttons to
+    edit and remove a place will also be available.
+
+    The geo service provider can be changed by accessing the "Provider" menu at the bottom of the
+    window.  Depending on the features supported by the provider, the "New" menu allows creating
+    new Places and Categories.  To create a new place, select "Place" from the "New" menu and fill
+    in the fields.  Click "Go!" to save the place.  To create a new category, select "Category"
+    from the "New" menu and fill in the fields.  Click "Go!" to save the category.
+
+    The Places example can work with any of the available geo services plugins.  However, some
+    plugins may require additional \l {QtLocation5::PluginParameter}{plugin parameters} in order to
+    function correctly.  \l {QtLocation5::PluginParameter}{Plugin parameters} can be passed on the
+    command line using the \c {--plugin} argument, which takes the form:
+
+    \code
+        --plugin.<parameter name> <parameter value>
+    \endcode
+
+    Refer to the documentation for each of the geo services plugins for details on what plugin
+    parameters they support.  The Nokia services plugin supplied with Qt requires an \e app_id and
+    \e token pair.  See "\l {Qt Location Nokia Plugin}" for details.
+
+    \section1 Displaying Categories
+
+    Before search by category can be performed, the list of available categories needs to be
+    retrieved.  This is achieved by creating a \l CategoryModel.
+
+    \snippet declarative/places/places.qml CategoryModel model
+
+    The \l CategoryModel type provides a model of the available categories.  It can provide
+    either a flat list or a hierarchical tree model.  In this example, we use a hierarchical tree
+    model, by setting the \l {CategoryModel::hierarchical}{hierarchical} property to \e true.  The
+    \l {CategoryModel::plugin}{plugin} property is set to \e placesPlugin which is the \e identifier of the
+    \l Plugin object used for place search throughout the example.
+
+    Next we create a view to display the category model.
+
+    \snippet declarative/places/content/places/CategoryView.qml CategoryModel view 1
+    \codeline
+    \snippet declarative/places/content/places/CategoryView.qml CategoryModel view 2
+    \codeline
+    \snippet declarative/places/content/places/CategoryView.qml CategoryModel view 3
+
+    Because a hierarchical model is being used, a \l VisualDataModel is needed to provide
+    navigation functionality.  If flat list model was being used the view could use the
+    \l CategoryModel directly.
+
+    The view contains a header item that is used as a back button to navigate up the category tree.
+    The \e onClicked handler sets the root index of the \l VisualDataModel to the parent of the
+    current index.  Categories are displayed by the \e CategoryDelegate, which provides four
+    signals.  The \e onArrowClicked handler sets the root index to the current index causing the
+    sub categories of the selected category to be displayed.  The \e onClicked handler emits
+    the \b categoryClicked() signal with a category parameter indicating which specific category
+    has been chosen.  The \e onCrossClicked handler will invoke the
+    categories \l {Category::remove()}{remove()} method.  The \e onEditClicked handler invokes the
+    \b editClicked() signal of the root item, this is used to notify which particular category
+    is to be edited.
+
+    The \e CategoryDelegate displays the category name and emits the \e clicked signal when
+    the text is clicked:
+
+    \snippet declarative/places/content/places/CategoryDelegate.qml CategoryModel delegate text
+
+    The \e CategoryDelegate also displays icons for editing, removing and displaying child
+    categories.  These icons are shown as desired when the \e showSave and \e showRemove
+    and \e showChildren properties are set and only then in cases where the function is
+    supported.
+
+    \snippet declarative/places/content/places/CategoryDelegate.qml CategoryModel delegate icon
+
+
+    \target Presenting-Search-Suggestions
+    \section1 Presenting Search Suggestions
+
+    The \l PlaceSearchSuggestionModel type is used to fetch suggested search terms based on a
+    partially entered search term.
+
+    A new suggestion search is triggered whenever the entered search term is changed.
+
+    \snippet declarative/places/content/places/SearchBox.qml PlaceSearchSuggestionModel search text changed
+
+    The \e suggestionsEnabled property is used to temporarily disable search suggestions when a
+    suggestion is selected (selecting it updates the search term text).  Suggestions are only
+    queried if the length of the search term is three or more characters, otherwise the search
+    boxes state is reset.
+
+    When the status of the \l PlaceSearchSuggestionModel changes, the state of the search box is
+    changed to display the search suggestions.
+
+    \snippet declarative/places/content/places/SearchBox.qml PlaceSearchSuggestionModel model
+
+    The main object in the "SuggestionsShown" state is the \l ListView showing the search
+    suggestions.
+
+    \snippet declarative/places/content/places/SearchBox.qml PlaceSearchSuggestionModel view 1
+    \codeline
+    \snippet declarative/places/content/places/SearchBox.qml PlaceSearchSuggestionModel view 2
+
+    A \l Text object is used as the delegate to display the suggestion text.  Clicking on the
+    suggested search term updates the search term and triggers a place search using the search
+    suggestion.
+
+
+    \section1 Searching for Places
+
+    The \l PlaceSearchModel type is used to search for places.
+
+    \snippet declarative/places/places.qml PlaceSearchModel model
+
+    First some of the model's properties are set, which will be used to form the search request.
+    The \l {PlaceSearchModel::searchArea}{searchArea} property is set to the
+    \e searchRegion object which is a \l GeoCircle with a center that is linked to the current
+    location displayed on the \l Map.
+
+    Finally, we define two helper functions \b searchForCategory() and \b {searchForText()},
+    which set either the \l {PlaceSearchModel::categories}{categories} or
+    \l {PlaceSearchModel::searchTerm}{searchTerm} properties and invokes the
+    \l {PlaceSearchModel::update()}{update()} method to start the place search.  The search
+    results are displayed in a \l ListView.
+
+    \snippet declarative/places/content/places/SearchResultView.qml PlaceSearchModel place list
+
+    The delegate used in the \l ListView, \e SearchResultDelegate, is designed to handle multiple
+    search result types via a \l Loader object.  For results of type \e PlaceResult the delegate
+    is:
+
+    \snippet declarative/places/content/places/SearchResultDelegate.qml PlaceSearchModel place delegate
+
+    \section1 Displaying Place Content
+
+    Places can have additional rich content, including editorials, reviews and images.  Rich
+    content is accessed via a set of models.  Content models are generally not created directly by
+    the application developer, instead models are obtained from the
+    \l {Place::editorialModel}{editorialModel}, \l {Place::reviewModel}{reviewModel} and
+    \l {Place::imageModel}{imageModel} properties of the \l Place type.
+
+    \snippet declarative/places/content/places/PlaceEditorials.qml PlaceEditorialModel view
+
+
+    \section1 Place and Category Creation
+
+    Some backends may support creation and saving of new places and categories.  Plugin support can
+    be checked an run-time with the \l Plugin::supportsPlaces() method.
+
+    To save a new place, first create a new \l Place object, using the
+    \l {Qt::createQmlObject()}{Qt.createQmlObject()} method.  Assign the appropriate plugin and
+    place properties and invoke the \l {Place::save()}{save()} method.
+
+    \snippet declarative/places/content/places/PlaceDialog.qml Place save
+
+    Category creation is similar:
+
+    \snippet declarative/places/content/places/CategoryDialog.qml Category save
+
+    Support for place and category removal can be checked at run-time by using the
+    \l {Plugin::supportsPlaces} method, passing in a \l {Plugin::supportsPlaces}{Plugin::PlacesFeatures} flag and
+    getting back \e true if the feature is supported. For example one would invoke
+    \e {supportsPlaces(Plugin.RemovePlaceFeature)} to check if the \e Plugin.RemovePlaceFeature is supported.
+
+
+    To remove a place, invoke its \l {Place::remove()}{remove()} method.  To remove a category,
+    invoke its \l {Category::remove()}{remove()} method.
+
+    \section1 Running the Example
+    The example detects which plugins are available and has an option to show them in the via
+    the Provider button.
+*/
diff --git a/src/location/doc/src/examples/logfilepositionsource.qdoc b/src/location/doc/src/examples/logfilepositionsource.qdoc
new file mode 100644
index 00000000..0e7ac773
--- /dev/null
+++ b/src/location/doc/src/examples/logfilepositionsource.qdoc
@@ -0,0 +1,87 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\example logfilepositionsource
+\title Log File Position Source (C++)
+\ingroup qtlocation-examples
+
+\brief The Logfile Position Source shows how to create and work with a custom NMEA position source,
+       for platforms without GPS.
+
+The data is read from a file which has positional data in NMEA format. The resulting time and
+position information is then displayed to the screen as simple text in date/time and
+latitude/longitude format.
+
+This example class reads location data from a text file, \e log.txt. The file specifies location
+data using a simple text format: it contains one location update per line, where each line contains
+a date/time, a latitude and a longitude, separated by spaces. The date/time is in ISO 8601 format
+and the latitude and longitude are in degrees decimal format. Here is an excerpt from \e log.txt:
+
+\code
+2009-08-24T22:25:01 -27.576082 153.092415
+2009-08-24T22:25:02 -27.576223 153.092530
+2009-08-24T22:25:03 -27.576364 153.092648
+\endcode
+
+The class reads this data and distributes it via the
+\l{QGeoPositionInfoSource::positionUpdated()}{positionUpdated()} signal.
+
+Here is the definition of the \c LogFilePositionSource class:
+
+\quotefromfile logfilepositionsource/logfilepositionsource.h
+\skipto class LogFilePositionSource
+\printuntil };
+
+The main methods overrided by the subclass are:
+
+\list
+    \li \l{QGeoPositionInfoSource::startUpdates()}{startUpdates()}: called by client applications
+        to start regular position updates.
+    \li \l{QGeoPositionInfoSource::stopUpdates()}{stopUpdates()}: called by client applications to
+        stop regular position updates.
+    \li \l{QGeoPositionInfoSource::requestUpdate()}{requestUpdate()}: called by client applications
+        to request a single update, with a specified timeout.
+\endlist
+
+When a position update is available, the subclass emits the
+\l{QGeoPositionInfoSource::positionUpdated()}{positionUpdated()} signal.
+
+Here are the key methods in the class implementation:
+
+\quotefromfile logfilepositionsource/logfilepositionsource.cpp
+\skipto LogFilePositionSource::LogFilePositionSource
+\printuntil /^\}/
+\skipto LogFilePositionSource::startUpdates
+\printuntil /^\}/
+\skipto LogFilePositionSource::stopUpdates
+\printuntil /^\}/
+\skipto LogFilePositionSource::requestUpdate
+\printuntil /^\}/
+\printuntil LogFilePositionSource::readNextPosition
+\printuntil /^\}/
+*/
diff --git a/src/location/doc/src/examples/places-list.qdoc b/src/location/doc/src/examples/places-list.qdoc
new file mode 100644
index 00000000..79f17f25
--- /dev/null
+++ b/src/location/doc/src/examples/places-list.qdoc
@@ -0,0 +1,65 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \example declarative/places_list
+    \title Places List (QML)
+    \ingroup qtlocation-examples
+
+    \brief The Places List example demonstrates how to search for and display a list of places using a \l ListView.
+    \image places-list.png
+
+    To write a QML application that will show places in a list, we start by
+    making the following import declarations.
+
+    \snippet places_list/places_list.qml Imports
+
+    Instantiate a \l Plugin instance.  The \l Plugin is effectively the backend
+    from where places are sourced from.  Because the \c nokia plugin has been
+    specified, some mandatory parameters need to be filled in, see the \l
+    {Mandatory Parameters} {Nokia Plugin} documentation for details:
+
+    \snippet places_list/places_list.qml Initialize Plugin
+
+    Next we instantiate a \l PlaceSearchModel which we can use to specify
+    search parameters and perform a places search operation.  For illustrative
+    purposes, \l {PlaceSearchModel::update} {update()} is invoked once
+    construction of the model is complete.  Typically \l
+    {PlaceSearchModel::update} {update()} would be invoked in response to a
+    user action such as a button click.
+
+    \snippet places_list/places_list.qml PlaceSearchModel
+
+    Finally we instantiate a \l ListView to show the search results found by
+    the model.  An inline delegate has been used and we have assumed that
+    every search result is of \l {Search Result Types} {type} \c
+    PlaceSearchesult.  Consequently it is assumed that we always have access to
+    the \e place \l {PlaceSearchModel Roles} {role},  other search result types
+    may not have a \e place \l {PlaceSearchModel Roles} {role}.
+
+    \snippet places_list/places_list.qml Places ListView
+*/
diff --git a/src/location/doc/src/examples/places-map.qdoc b/src/location/doc/src/examples/places-map.qdoc
new file mode 100644
index 00000000..1f34597f
--- /dev/null
+++ b/src/location/doc/src/examples/places-map.qdoc
@@ -0,0 +1,67 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \example declarative/places_map
+    \title Places Map (QML)
+    \ingroup qtlocation-examples
+
+    \brief The Places Map example demonstrates how to search for and display a list of places
+           on a map using a MapItemView
+    \image places-map.jpg
+
+    To write a QML application that will show places on a map, we start by
+    making the following import declarations.
+
+    \snippet places_map/places_map.qml Imports
+
+    Instantiate a \l Plugin instance.  The \l Plugin is effectively the backend
+    from where places are sourced from.  Because the \c nokia plugin has been
+    specified, some mandatory parameters need to be filled in, see the \l
+    {Mandatory Parameters} {Nokia Plugin} documentation for details:
+
+    \snippet places_map/places_map.qml Initialize Plugin
+
+    Next we instantiate a \l PlaceSearchModel which we can use to specify
+    search parameters and perform a places search operation.  For illustrative
+    purposes, \l {PlaceSearchModel::update} {update()} is invoked once
+    construction of the model is complete.  Typically \l
+    {PlaceSearchModel::update} {update()} would be invoked in response to a
+    user action such as a button click.
+
+    \snippet places_map/places_map.qml PlaceSearchModel
+
+    The map is displayed by using the \l Map type and inside we declare the \l
+    MapItemView and supply the search model and a delegate.  An inline delegate
+    has been used and we have assumed that every search result is of \l {Search
+    Result Types} {type} \c PlaceSerachesult.  Consequently it is assumed that
+    we always have access to the \e place \l {PlaceSearchModel Roles} {role},
+    other search result types may not have a \e place \l {PlaceSearchModel
+    Roles} {role}.
+
+    \snippet places_map/places_map.qml Places MapItemView
+*/
diff --git a/src/location/doc/src/examples/qtlocation-examples.qdoc b/src/location/doc/src/examples/qtlocation-examples.qdoc
new file mode 100644
index 00000000..8a7fe532
--- /dev/null
+++ b/src/location/doc/src/examples/qtlocation-examples.qdoc
@@ -0,0 +1,39 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \group qtlocation-examples
+    \title Qt Location Examples
+    \brief Examples for the Qt Location module
+    \ingroup all-examples
+    \ingroup qtlocation
+
+    These are the Qt Location examples.
+
+    \generatelist related
+*/
+
diff --git a/src/location/doc/src/examples/weatherinfo.qdoc b/src/location/doc/src/examples/weatherinfo.qdoc
new file mode 100644
index 00000000..ad5ad5d5
--- /dev/null
+++ b/src/location/doc/src/examples/weatherinfo.qdoc
@@ -0,0 +1,109 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \example weatherinfo
+    \title Weather Info (C++/QML)
+
+    \brief The Weather Info example shows how to use the user's current position
+           to retrieve local content from a web service in a C++ plugin for QML.
+
+    \ingroup qtlocation-examples
+
+    Key Qt Location classes used in this example:
+
+    \list
+    \li \l{QGeoPositionInfo}
+    \li \l{QGeoPositionInfoSource}
+    \endlist
+
+    \image ../images/example-weatherinfo.png
+
+    The key part of this example is the application's data model, contained
+    in the WeatherData and AppModel classes. WeatherData represents the weather
+    information taken from the HTTP service. It is a simple data class, but we
+    give it Q_PROPERTies to expose it nicely to QML, later.
+
+    \snippet weatherinfo/appmodel.h 0
+    \snippet weatherinfo/appmodel.h 1
+
+    AppModel models the state of the entire application. At startup, the
+    application first begins by waiting for network connectivity. We do
+    this using the QNetworkConfigurationManager and QNetworkSession family
+    of C++ APIs.
+
+    \snippet weatherinfo/appmodel.cpp 0
+    \snippet weatherinfo/appmodel.cpp 1
+
+    Once the network session is open, we proceed to get the platform's
+    default position source using QGeoPositionInfo::createDefaultSource()
+
+    \snippet weatherinfo/appmodel.cpp 2
+
+    If no default source is available, we take a static location and fetch
+    weather for that. If, however, we do have a position source, we connect
+    its positionUpdated() signal to a slot on the AppModel and call
+    startUpdates(), which begins regular updates of device position.
+
+    When a position update is received, we use the longitude and latitude
+    of the returned coordinate to retrieve the current "city" name for use
+    in the weather lookup.
+
+    \snippet weatherinfo/appmodel.cpp 3
+
+    To inform the UI about this process, the cityChanged() signal is emitted
+    when a new city is used, and the weatherChanged() signal whenever a
+    weather update occurs.
+
+    \snippet weatherinfo/appmodel.h 2
+    \snippet weatherinfo/appmodel.h 3
+    \snippet weatherinfo/appmodel.h 4
+
+    We use a QQmlListProperty for the weather forecast information,
+    which contains the next 4 days of forecast weather. This makes it
+    easy to access from QML.
+
+    To expose these to the QML UI layer, we use the qmlRegisterType()
+    function. We call this once for each type we wish to register, before
+    loading the actual QML file.
+
+    \snippet weatherinfo/main.cpp 0
+    \snippet weatherinfo/main.cpp 1
+
+    Finally, in the actual QML, we instantiate the AppModel.
+
+    \snippet weatherinfo/weatherinfo.qml 0
+    \snippet weatherinfo/weatherinfo.qml 1
+    \snippet weatherinfo/weatherinfo.qml 2
+
+    Once instantiated like this, we can use its properties elsewhere in the
+    QML document:
+
+    \snippet weatherinfo/weatherinfo.qml 3
+    \snippet weatherinfo/weatherinfo.qml 4
+
+*/
diff --git a/src/location/doc/src/maps.qdoc b/src/location/doc/src/maps.qdoc
new file mode 100644
index 00000000..99cc9bca
--- /dev/null
+++ b/src/location/doc/src/maps.qdoc
@@ -0,0 +1,237 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+/*!
+\page location-maps-qml.html
+\title Maps and Navigation (QML)
+
+\brief Provides QtQuick user interfaces for displaying, navigating and
+       interacting with maps, as well as geocoding and navigation.
+
+\b{Maps and Navigation} provides QtQuick user interface types for
+displaying geographic information on a map, as well as allowing user
+interaction with map overlay objects and the display itself. It also
+contains utilities for geocoding (finding a geographic coordinate from a
+street address) and navigation (including driving and walking directions).
+
+It builds upon the API concepts and types in the \l{Positioning (QML)}{QML Positioning API}.
+A more hands-on introduction of the Maps and Navigation types can be found in the
+\l {QML Maps}{Maps and Navigation tutorial}.
+
+\section1 Maps
+
+\section2 Displaying Maps
+
+Displaying a map is done using the \l{QtLocation5::Map}{Map} QML types.  The Map type supports
+user interaction through the \l{QtLocation5::MapGestureArea}{MapGestureArea} QML type. The Map
+object draws the map on-screen using OpenGL (ES), allowing for hardware-accelerated rendering
+where available.
+
+\b{Key Types}
+\table
+    \row
+        \li \l{QtLocation5::Plugin}{Plugin}
+        \li A location-based services plugin provides data including map data which is then displayed in a Map object.
+    \row
+        \li \l{QtLocation5::Map}{Map}
+        \li QtQuick item to display a map on-screen.
+    \row
+        \li \l{QtLocation5::MapGestureArea}{MapGestureArea}
+        \li Interaction helper for panning, flicking and pinch-to-zoom gesture on a Map.
+\endtable
+
+Note that the client must create a \l{QtLocation5::Plugin}{Plugin} object
+prior to using a \l{QtLocation5::Map}{Map} type in order to have access
+to map data to display.
+
+\section2 Putting Objects on a Map (Map Overlay Objects)
+
+Maps can also contain map overlay objects, which are used to display information
+on its surface. There is a set of basic pre-defined map overlay objects, as well
+as the ability to implement custom map overlay objects using the
+\l{QtLocation5::MapQuickItem}{MapQuickItem} type, which can contain any
+standard QtQuick item.
+
+\b{Key Types}
+\table
+    \row
+        \li \l{QtLocation5::MapCircle}{MapCircle}
+        \li A geographic circle (all points at a set distance from a center), optionally with a border.
+    \row
+        \li \l{QtLocation5::MapRectangle}{MapRectangle}
+        \li A rectangle whose top left and bottom right points are specified as
+            \l {coordinate} types, optionally with a border.
+    \row
+        \li \l{QtLocation5::MapPolygon}{MapPolygon}
+        \li A polygon made of an arbitrary list of \l {coordinate}{coordinates}.
+    \row
+        \li \l{QtLocation5::MapPolyline}{MapPolyline}
+        \li A polyline made of an arbitrary list of \l {coordinate}{coordinates}.
+    \row
+        \li \l{QtLocation5::MapQuickItem}{MapQuickItem}
+        \li Turns any arbitrary QtQuick Item into a map overlay object.  MapQuickItem is an enabler for specifying custom map overlay objects.
+\endtable
+
+\section2 Model-View Design with Map Overlay Objects
+
+To automatically generate map overlay objects based on the contents of a QtQuick
+model (for example a ListModel item), the \l{QtLocation5::MapItemView}{MapItemView}
+type is available. It accepts any map overlay object as its delegate, and can
+only be created within a \l{QtLocation5::Map}{Map}.
+
+\b{Key Types}
+\table
+    \row
+        \li \l{QtLocation5::MapItemView}{MapItemView}
+        \li Populates a Map with map overlay objects based on the data provided by a model.
+\endtable
+
+\section2 Interaction with Map Overlay Objects
+
+Interaction with the pre-defined map overlay object types is done using the
+\l{QtLocation5::MapMouseArea}{MapMouseArea} type, which behaves much like a
+normal QtQuick MouseArea. MapQuickItems can also contain MapMouseArea objects,
+but can additionally use normal QtQuick MouseAreas to provide interaction.
+
+Properties of map overlay objects that influence their appearance on the display can
+be changed at any time, and many can also be used in animations. Animating
+coordinate-based map overlay objects, such as MapPolygon and MapPolyline, is not yet
+available.
+
+\b{Key Types}
+\table
+    \row
+        \li \l{QtLocation5::MapMouseArea}{MapMouseArea}
+        \li Accepts mouse events for a pre-defined map overlay object (for example MapCircle).
+    \row
+        \li \l{QtLocation5::MapMouseEvent}{MapMouseEvent}
+        \li Provides additional information unique to mouse events on a Map.
+\endtable
+
+\section1 Geocoding -- Address to Coordinate and Vice Versa
+
+Geocoding is the translation of geographic coordinates into addresses, or vice
+versa.  Such a translation usually involves sending the source data to a server
+which then performs the translation and returns the results, although some
+location-based service provider \l{QtLocation5::Plugin}{plugins} may be able to
+provide some geocoding functionality without sending data to a remote server.
+The availability and accuracy of the translation usually depends on the location
+or address being translated, as different areas of the Earth are mapped to
+varying degrees of accuracy.
+
+A geocoding query in QML is performed using the
+\l{QtLocation5::GeocodeModel}{GeocodeModel} type. For an address-to-coordinate
+query, its \c{query} property may be set to either an
+\l{QtLocation5::Address}{Address} object or a string containing the textual
+form of the address to search for. To perform the reverse, the same property
+can be set to a \l {coordinate} instead. Results are made available in the
+contents of the model.
+
+\b{Key Types}
+\table
+    \row
+        \li \l{QtLocation5::Plugin}{Plugin}
+        \li A location-based services plugin provides data including geocoding translation results which are exposed to clients via a GeocodeModel.
+    \row
+        \li \l{QtLocation5::GeocodeModel}{GeocodeModel}
+        \li Queries the Plugin for geocoding translations and provides access to results via indexes in the model.
+    \row
+        \li \l{QtLocation5::Address}{Address}
+        \li Structured address for use in queries and results of geocoding.
+\endtable
+
+Note that the client must create a \l{QtLocation5::Plugin}{Plugin} object
+prior to using a \l{QtLocation5::GeocodeModel}{GeocodeModel} object. This
+will enable access to geocoding translation services and thus data to display.
+
+\section1 Routing and Navigation
+
+Routing is the determination of a navigable path from one point to another on
+a map. Given a map that is aware of features that aid or hinder navigation, such as
+bridges, waterways and so on, a series of segments that make
+up the journey can be constructed. If these \l {RouteSegment}s are simple then we can
+add navigation information at the connecting points, \l {RouteManeuver}s,
+between the segments.
+
+\b{Key Types}
+\table
+    \row
+        \li \l{QtLocation5::Route}{Routing}
+        \li The entire path to be navigated.
+    \row
+        \li \l{QtLocation5::RouteSegment}{Segments}
+        \li The individual components of a route.
+    \row
+        \li \l{QtLocation5::RouteManeuver}{Maneuvers}
+        \li The navigation information that joins segments.
+    \row
+        \li \l{QtLocation5::RouteModel}{RouteModel}
+        \li The means of making requests on the backend to supply route
+        information.
+\endtable
+
+
+
+
+
+
+*/
+
+
+/*!
+\page location-maps-cpp.html
+\title Maps and Navigation (C++)
+
+\brief Provides C++ classes for Geocoding and Navigation.
+
+\b{Maps and Navigation} provides C++ utilities for geocoding (finding a
+geographic coordinate from a street address) and navigation (including driving
+and walking directions).
+
+\section1 Geocoding
+
+In C++, an address-to-coordinate query is performed using the
+\l{QGeocodingManager::geocode()}{geocode()} method of the QGeocodingManager
+class. For coordinate-to-address queries, the
+\l{QGeocodingManager::reverseGeocode()}{reverseGeocode()} method is available
+on the same class. Instances of QGeocodingManager are available via
+\l{QGeoServiceProvider}.
+
+\b{Key Classes}
+\table
+    \row
+        \li \l{QGeoServiceProvider}
+        \li Provides a QGeocodingManager instance ready for use.
+    \row
+        \li \l{QGeocodingManager}
+        \li Accepts queries and produces QGeocodeReply objects.
+    \row
+        \li \l{QGeocodeReply}
+        \li Contains the results of a geocoding query.
+\endtable
+*/
diff --git a/src/location/doc/src/place-caveats.qdocinc b/src/location/doc/src/place-caveats.qdocinc
new file mode 100644
index 00000000..ce766338
--- /dev/null
+++ b/src/location/doc/src/place-caveats.qdocinc
@@ -0,0 +1,21 @@
+    The Places API is currently designed for only saving \a {core} details.  Saving rich content like
+    images and reviews or details like supplier and rating is not a supported use case.  Typically a manager
+    will generally ignore these fields upon save and may produce a warning message if they are populated.
+
+    The Places API only supports saving of the following \e {core details}:
+    \list
+        \li name
+        \li place id
+        \li location
+        \li contact details
+        \li icon
+        \li categories (tag-like names to describe a place)
+        \li visibility scope
+    \endlist
+
+    It is possible that providers may only support a subset of these.
+    See the \l {Qt Location Module#Plugin References and Parameters}{plugin documentation} for more
+    details.
+
+    Saving of properties such as the rating, extended attributes,
+    images, reviews, editorials and supplier is explicitly not supported by the Places API.
diff --git a/src/location/doc/src/place-crossref.qdocinc b/src/location/doc/src/place-crossref.qdocinc
new file mode 100644
index 00000000..4d9639f1
--- /dev/null
+++ b/src/location/doc/src/place-crossref.qdocinc
@@ -0,0 +1,7 @@
+    \code
+    origin R/O manager(nokia)       destination R/W manager (places_jsondb)
+                            Save
+    Place id: ae246         --->    Place id: 0001
+    Attribute type: x_provider      Attribute type: x_id_nokia
+    Attribute value: nokia          Attribute text value: ae246
+    \endcode
diff --git a/src/location/doc/src/place-definition.qdocinc b/src/location/doc/src/place-definition.qdocinc
new file mode 100644
index 00000000..d9bcc6b7
--- /dev/null
+++ b/src/location/doc/src/place-definition.qdocinc
@@ -0,0 +1,27 @@
+A place is a point of interest, it could be a favorite restaurant, a park or someone's home.
+A QPlace object represents a place by acting as a container for various information about that place.
+
+This information can be divided into 2 broad classifications
+
+\list
+\li Details
+\li Rich content
+\endlist
+
+The place details consist of properties of the place, such as the name,
+location, contact information and so on. When a place is returned during a
+search, these details are filled in. Sometimes in order to save bandwidth,
+there are further details about the place that can be retrieved on an
+individual place by place basis, if the user is interested. The
+QPlace::detailsFetched() function can be queried to see if all available
+details have been fetched, and if not, QPlaceManager::getPlaceDetails() can
+be used to retrieve them. Precisely which details are populated during a
+search and which need to be fetched individually may vary from provider to
+provider.  See \l {Qt Location Module#Plugin References and Parameters}{plugin documentation} for
+more details.
+
+The rich content of a place consists of items such as images, reviews and
+editorials.  Potentially there may be many rich content items, so they are
+treated separately from the place details. They can be retrieved in a paged
+fashion via QPlaceManager::getPlaceContent(). If necessary, the content may
+be assigned to a place so it can act as a convenient container.
diff --git a/src/location/doc/src/places.qdoc b/src/location/doc/src/places.qdoc
new file mode 100644
index 00000000..62a6d0d5
--- /dev/null
+++ b/src/location/doc/src/places.qdoc
@@ -0,0 +1,433 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \page location-places-qml.html
+    \title QML Places API
+
+    \section1 Overview
+
+    The Places API allows users to discover places of interest and view
+    details about them, such as address and contact information.  Some places may have
+    additional content associated with them, such as images and reviews.
+    The Places API also facilitates management of places and
+    categories, allowing users to save and remove them.
+
+    \section1 Introductory concepts
+
+    \section2 Plugin
+    A \l Plugin is an abstraction for a backend. One \l Plugin might access places from a
+    REST server while another may access places from a local database. The following
+    instantiates a \l Plugin object by providing a name of "nokia". The \l Plugin name
+    identifies which backend to choose from. Plugins may also be provided with a set of
+    \l {PluginParameter} {parameters}, which essentially takes the form of a set of
+    key-value pairs. The \l {PluginParameter} {parameters} that can be specified vary
+    among the different \l Plugin backends. For documentation on the possible \l
+    {PluginParameter} {parameters} and nuances of each \l Plugin, see the \l {Plugin
+    references and parameters}{Plugin References}.
+
+    \snippet places_list/places_list.qml Initialize Plugin
+
+    \note The Nokia plugin must be supplied with some mandatory parameters as outlined
+    in the \l {Mandatory Parameters} {Nokia Plugin} documentation.
+
+    \section2 Models, Views and Delegates
+    The QML Places API is built around the notion of models, views and delegates.
+
+    \table
+    \row
+        \li \b Model
+        \li A model holds data items and maintains their structure.
+            The model is also responsible for retrieving the items from a data source.
+    \row
+        \li \b View
+        \li A view is a visual container that displays the data and manages how visual
+            items are shown such as in a list or a grid.  The view may also
+            be responsible for navigating the data, for example, scrolling through
+            the visual items during a flicking motion.
+    \row
+        \li \b Delegate
+        \li A delegate defines how individual data elements should appear
+            as visual items in the view.  The models expose a set of data roles
+            and the delegate uses them to construct  a visual item.  The delegate
+            may also define behaviour such as an operation to invoke when a visual
+            item is clicked.
+    \endtable
+
+    The Common Use Cases section below demonstrates concrete examples of how
+    these concepts fit together.
+
+    \section1 Common Use Cases
+
+    \section2 Searching for Places
+    Searching is accomplished via the \l PlaceSearchModel.  The \l
+    {PlaceSearchModel::plugin} {plugin} property specifies which backend to
+    perform search operations against.  Search parameters may be provided
+    through properties such as the \l {PlaceSearchModel::searchTerm}
+    {searchTerm} and \l {PlaceSearchModel::searchArea} {searchArea}.  A search
+    operation can then be started by invoking the \l {PlaceSearchModel::update}
+    {update()} method.  For simplicity, the snippet below invokes \l
+    {PlaceSearchModel::update} {update()} once construction of the model as
+    been completed, typically \l {PlaceSearchModel::update} {update()} would be
+    invoked in response to a user action such as a button click.  While the
+    search operation is underway the \l {PlaceSearchModel::status} property
+    transitions into the \c Loading state and when successfully completed moves
+    into the \c Ready state.
+
+    \snippet places_list/places_list.qml PlaceSearchModel
+
+    \section2 Display Search Results using a ListView
+    A \l ListView can be used to show the search results found by the model.
+    It defines the visual region for where the results are shown, and in the
+    case below fills the entirety of its parent.  The \l ListView has built in
+    behavior that enables the region to respond to flicking events and to
+    scroll appropriately.
+
+    In the snippet below, the search model has been assigned to the ListView's
+    \l {ListView::model} {model} property.  When the model is updated with new
+    results, the \l ListView is automatically updated to reflect the model's new
+    data items.
+
+    A simple delegate has been bound to the \l {ListView}'s \l
+    {ListView::delegate} {delegate} property.  The \l PlaceSearchModel exposes
+    a set of \l {PlaceSearchModel Roles} {roles} of which the \e title and \e
+    place roles have been used below, these are of type string and \l Place
+    respectively.  Essentially for each data item that should be visible in the
+    view, the view invokes the delegate to create a visual representation of
+    the item.
+
+    \table
+        \row
+            \li
+                \snippet places_list/places_list.qml Places ListView
+            \li
+                \inlineimage places-list.png
+    \endtable
+
+    \note For simplicty's sake we have assumed that every search result is of
+    \l {Search Result Types} {type} \c PlaceSearchResult and so always have
+    access to the \e place role, other search result types may not have a
+    \e place role.
+
+    See the \l {Places List(QML)} {Places List} example for full source code.
+
+    \section2 Display Search Results using a MapItemView
+    Instead of a \l ListView, the \l PlaceSearchModel can be used in
+    conjunction with a \l MapItemView to display markers on a map.  Firstly a
+    \l Map is used to define the visual region occupied by the map, in this
+    case it fills the entirety of its parent.  Other properties are specified
+    such as the \l {Map::plugin} {plugin} providing the maps, and the map's \l
+    {Map::center} {center} and \l {Map::zoomLevel} {zoomLevel}.
+
+    Inside the \l Map, a \l MapItemView is declared, where the \l
+    {MapItemView::model} {model} property has been set to the search model and
+    a \l {MapItemView::delegate} {delegate} consisting of a \l MapQuickItem is
+    used to display a marker image.  A marker is shown for every place that
+    was found by the search model.  The delegate uses the \e place role
+    to position the marker.
+
+    \table
+        \row
+            \li
+                \snippet places_map/places_map.qml Places MapItemView
+            \li
+                \inlineimage places-map.jpg
+    \endtable
+
+    \note For simplicty's sake we have assumed that every search result is of
+    \l {Search Result Types} {type} \c PlaceSearchResult and so always have
+    access to the \e place role, other search result types may not have a
+    \e place role.
+
+    See the \l {Places Map(QML)} {Places Map} example for full source code.
+
+    \section2 Fetching Place Details
+    In order to save bandwidth, sometimes a backend will only return places which
+    are partially populated with details.  This can be checked with the
+    Place::detailsFetched property which indicates whether all availalable details
+    have been fetched or not.  If not, the Place::getDetails() method can be invoked
+    to fetch the remaining details.
+
+    \snippet declarative/places.qml Place fetchDetails
+
+    \section2 Saving and Removing Places
+    Some backends may support saving and removing places.  This can be done by
+    calling the Place::save() and Place::remove() methods respectively.  Note
+    that in order to save a \l Place, a \l Plugin must be assigned to specify
+    which backend we are saving to.  The \l {Place::status} {status} property will
+    transition into the \c Saving state while the save operation is happening and on
+    successful completion will move to the \c Ready state.  The following
+    snippet shows how to save and remove a place using javascript.
+
+    \snippet declarative/places.qml Place createAndSavePlace
+    \codeline
+    \snippet declarative/places.qml Place removePlace
+
+    \section2 Learn More
+    The above snippets only exhibit a small subset of Places functionality.
+    Refer to the \l {Places Types} shown below for richer content such as \l {ImageModel} {images}, \l {ReviewModel} {reviews} etc, as well as more indepth descriptions and explanations.
+
+    See also the \l {Places (QML)}{Places (QML)} example for a more comprehensive demonstration on
+    how to use the API.
+
+    \section1 Places Types
+    \section2 Data Types
+    \annotatedlist qml-QtLocation5-places-data
+
+    \section2 Models
+    \annotatedlist qml-QtLocation5-places-models
+*/
+
+/*!
+    \page location-places-cpp.html
+    \title Places (C++)
+
+    \section1 Overview
+
+    The Places API allows users to discover places/points of interest
+    and view details about them such as address and contact information;
+    some places may even have rich content such as images and reviews.
+    The Places API also facilitates management of places and
+    categories, allowing users to save and remove them.
+
+    \section1 Place Definition
+    \include place-definition.qdocinc
+
+    \section1 Common Operations
+
+    \section2 Initializing a Manager
+    All places functionality is facilitated by a QPlaceManager instance.  One must specify
+    a QGeoServiceProvider in order to create the QPlaceManager
+
+    \snippet places/requesthandler.h Initialize Manager
+
+    \section2 Discovery/Search
+
+    In order to perform a search operation we simply create a QPlaceSearchRequest
+    and set the desired search parameters, such as a search term and search center.
+
+    \snippet places/requesthandler.h Search for places cpp
+
+    The request  is an asynchronous operation so we need a slot to handle the
+    completion of the request. In the handler we check that there are no errors and that our search result
+    type is a place.  If so we can then retrieve some of the core details of the
+    place.  At the end of the slot, we delete the reply since they are for single use only.
+
+    \snippet places/requesthandler.h Search for places handler cpp
+
+    \b {Note:} Depending upon the plugin backend that was chosen, the search results may contain places
+    which have further details that can be fetched on a place by place basis.  To fetch these other details
+    see \l {Fetching Place Details}.
+
+    \section3 Recommendations
+    Recommendations can be retrieved by supplying a place id via QPlaceSearchRequest::setRecommendationId().
+    Any places similar to the given place are retrieved.
+
+    \section3 Paging
+    If the plugin supports paging, limit and offset parameters may be provided to the search request.
+    \snippet places/requesthandler.h Search paging
+
+    \section2 Fetching Place Details
+    A place that has been returned from a search request may have more details
+    that can be fetched.  The following demonstrates how to check if there
+    are further details and if so how to request them.
+
+    \snippet places/requesthandler.h Details check
+    \dots
+    \dots
+    \snippet places/requesthandler.h Details handler cpp
+
+    \section2 Fetching Rich Content
+    Rich content such as images and reviews is retrieved through the manager and then if required assigned to a place.
+    \snippet places/requesthandler.h Image request
+
+    We can handle the content request as shown below.
+    \snippet places/requesthandler.h Image handler
+
+    It is important to note that the results in the QPlaceContentReply,
+    is a QPlaceContent::Collection which is essentially a QMap<int, QPlaceContent>.  The key \c {int} in this case is the
+    index of the content, and the value is the content itself.  Due to the way Content is implemented
+    it is possible to convert a content type as follows
+    \code
+        QPlaceImage image = content; //provided that 'content' has a type QPlace::ImageType
+    \endcode
+
+    The usage of the QPlaceContent::Collection and the conversion between content and its subtypes means
+    that code for handling the mechanics of paging reviews, images and editorials can be easily shared.
+
+    \section2 Search Suggestions
+    The retrieval of search term suggestions is very similar to performing a place search. A QPlaceSearchRequest
+    is used just like a place search, the only difference being that the search term is set to a
+    partially completed string.
+
+    \snippet places/requesthandler.h Suggestion request
+    And when the request is done, we can use the reply to show the suggestions.
+    \snippet places/requesthandler.h Suggestion handler
+
+    \target Saving a place cpp
+    \section2 Saving a Place
+    The saving of a new place is performed as follows, we create a QPlace instance
+    and populate it with information such as a name, address and coordinate.  Once
+    done we can invoke QPlaceManager::savePlace() to begin a save operation.
+    \snippet places/requesthandler.h Save place pt1
+    \dots
+    \snippet places/requesthandler.h Save place pt2
+
+    Once a place is saved the reply contains the new identifier for that place.
+    \snippet places/requesthandler.h Save place handler
+
+    Note that to save an already \e existing place, the QPlace::placeId() must
+    be filled in with the correct identifier.  Otherwise a new place will be created if empty or the
+    wrong place overwritten if the identifier is incorrect.
+
+    When a place is saved, the QPlaceManager may emit QPlaceManager::placedAdded() or QPlaceManager::placeUpdated()
+    signals.  However whether a manager does so or not is provider specific, managers accessing places
+    from a web service will typically not emit these signals while managers accessing places locally stored generally will.
+
+    \section3 Caveats
+    \input place-caveats.qdocinc
+
+    \section3 Saving Between Managers
+    When saving places between managers, there are a few things to be aware of.
+    Some fields of a place such as the id, categories and icons are manager specific entities
+    for example the categories in one manager may not be recognized in another.
+    Therefore trying to save a place directly from one manager to another is not possible.
+
+    The typical approach is to use the QPlaceManager::compatiblePlace() function,
+    it creates a copy of a place, but only copies data that the manager supports.
+    Manager specific data such as the place identifier is not copied over.  The new
+    copy is now suitable for saving into the manager.  If the manager supports matching by alternative
+    identifiers, an alternative identifier attribute is assigned to the copy (see \l {Matching places between managers})
+
+    \snippet places/requesthandler.h Save to different manager
+
+    \target Removing a place cpp
+    \section2 Removing a Place
+    The removal of a place is performed as follows:
+    \snippet places/requesthandler.h Remove place
+    \dots
+    \dots
+    \snippet places/requesthandler.h Remove place handler
+
+    When a place is removed, the QPlaceManager may emit the QPlaceManager::placeRemoved() signal.  Whether a
+    manager does so is provider specific.  Managers accessing places from a web service will typically not emit
+    these signals, while managers accessing places stored locally generally will.
+
+    \section2 Using Categories
+
+    Categories are keywords that can describe a place. For example, 'park', 'theater',
+    'restaurant'. A place could be described by many categories, it could be a park and a music venue and a ferry or bus stop.
+
+    To use categories they must first be initialized.
+    \snippet places/requesthandler.h Initialize categories
+    \dots
+    \dots
+    \snippet places/requesthandler.h Initialize categories reply
+
+    After the categories have been initialized we can then use these category functions.
+    \list
+        \li QPlaceManager::childCategories()
+        \li QPlaceManager::category()
+        \li QPlaceManager::parentCategoryId()
+        \li QPlaceManager::childCategoryIds();
+    \endlist
+
+    To retrieve the top level categories
+    we use the QPlaceManager::childCategories() function but do not provide
+    a category identifier.
+
+    \snippet places/requesthandler.h Top level categories
+
+    If we did provide an identifier then we could retrieve a category's children.
+
+    \snippet places/requesthandler.h Child categories
+
+    \section2 Saving a Category
+    The following shows how to save a category
+    \snippet places/requesthandler.h Save category
+    \dots
+    \dots
+    \snippet places/requesthandler.h Save category handler
+
+    When a category is saved, the QPlaceManager may emit QPlaceManager::categoryAdded() or QPlaceManager::categoryUpdated()
+    signals.  However whether a manager does so or not is provider specific, managers accessing places
+    from a web service will typically not emit these signals while managers accessing places locally stored generally will.
+
+
+    \section2 Removing a Category
+    Category removal is very similar to removing a place
+    \snippet places/requesthandler.h Remove category
+    \dots
+    \dots
+    \snippet places/requesthandler.h Remove category handler
+
+    When a category is removed, the QPlaceManager may emit the QPlaceManager::categoryRemoved() signal.  Whether a
+    manager does so is provider specific.  Managers accessing places from a web service will typically not emit
+    these signals, while managers accessing places stored locally generally will.
+
+    \section2 Matching Places Between Managers
+    Sometimes you may want to cross reference whether places from one manager match those from another manager.
+    Such a situation may arise where one manager provides read-only access to places (origin manager) while another second r/w
+    manager (destination manager) is used to save selected favorites from the first. During a search
+    of the origin manager we may want to know which ones have been 'favorited' into the destination manager and perhaps display
+    a customized favorite name rather than the original name.
+
+    The matching mechanism can vary between managers, but is typically accomplished through an alternative identifier.
+    As part of the save process, the place identifier from the origin manager is saved as an alternative identifier attribute in the destination manager
+    (which can have its own place identifier scheme).  In the following example, the origin manager is from the 'nokia' QGeoServiceProider, therefore
+    as part of the saving process an alternative identifier attribute, x_id_nokia, is set for the place saved into the destination manager
+    (when QPlaceManager::compatiblePlace() is called)
+
+    \input place-crossref.qdocinc
+
+    In order to perform the matching, we create a QPlaceMatchRequest and assign it the search results from the origin manager.
+    The QPlaceMatchRequest will be used on the destination manager to return corresponding places.  We also specify
+    matching parameters which are key value pairs.  As mentioned previously, this can vary depending on the manager but typically
+    the key is QPlaceMatchRequest::AlternativeId to indicate we are matching by alternative id, the value in this case would be
+    x_id_nokia which specifies which alternative identifier attribute we are using to do the matching.
+
+    \snippet places/requesthandler.h Match places
+    \dots
+    \dots
+    \snippet places/requesthandler.h Match places handler
+
+    \section1 Classes in Places
+
+    \section2 Data Classes
+    \annotatedlist QtLocation-places-data
+
+    \section2 Request Classes
+    \annotatedlist QtLocation-places-requests
+
+    \target Places Reply Classes
+    \section2 Reply classes
+    \annotatedlist QtLocation-places-replies
+
+    \section2 Manager Classes
+    \annotatedlist QtLocation-places-manager
+*/
+
diff --git a/src/location/doc/src/plugins/nokia.qdoc b/src/location/doc/src/plugins/nokia.qdoc
new file mode 100644
index 00000000..f3a8f58d
--- /dev/null
+++ b/src/location/doc/src/plugins/nokia.qdoc
@@ -0,0 +1,314 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page location-plugin-nokia.html
+\title Qt Location Nokia Plugin
+\ingroup QtLocation-plugins
+
+\brief Uses the relevant Nokia services provided by Nokia.
+
+\section1 Overview
+
+Included with Qt Location is a geo services plugin which accesses the relevant Nokia services
+provided by Nokia.  The use of these services is governed by the terms and conditions
+available at \l {Qt Location Nokia Plugin - Nokia Services Terms and Conditions}.
+
+Note that accepting the terms and conditions only applies those terms and conditions to the use of
+the Nokia geo services plugin and does not limit the use of the other geo services plugins that may
+be included with Qt.
+
+The Nokia geo services plugin can be loaded by using the plugin key "nokia".
+
+The online plugin uses the tiled map classes, which caches tile data in heap memory and texture
+memory.
+
+\section1 Parameters
+
+\section2 Mandatory parameters
+The following table lists mandatory parameters that \e must be passed to the Nokia plugin.
+\table
+\header
+    \li Parameter
+    \li Description
+\row
+    \li app_id
+    \li Client \e app_id part of the app_id/token pair used for authentication by all managers.
+\row
+    \li token
+    \li Client \e token part of the app_id/token pair for the service used for authentication by all managers.
+\endtable
+
+The Nokia geo services plugin requires an application id and token pair to authenticate the
+application with the Nokia services.  To obtain an application id and token pair visit
+\l{http://api.developer.nokia.com/}
+
+\section2 Optional parameters
+The following table lists optional parameters that can be passed to the Nokia plugin.
+\table
+\header
+    \li Parameter
+    \li Description
+\row
+    \li proxy
+    \li Proxy server URL used by all managers. For usage of the system proxy just pass "system" as value.
+
+    \note See the notes in \l{QNetworkProxyFactory::systemProxyForQuery()} for further information.
+\row
+    \li mapping.host
+    \li Map tile service URL used by mapping manager.
+\row
+    \li mapping.cache.directory
+    \li Map tile cache directory used as network disk cache.
+
+    Default place for the cache is ".tilecache" directory in \l {QDir::home()}.
+\row
+    \li mapping.cache.disk.size
+    \li Map tile disk cache size in bytes. Default size of the cache is 20MB.
+\row
+    \li mapping.cache.memory.size
+    \li Map tile memory cache size in bytes. Default size of the cache is 3MB.
+\row
+    \li mapping.cache.texture.size
+    \li Map tile texture cache size in bytes. Default size of the cache is 6MB. Note that the texture cache has a hard minimum size which depends on the size of the map viewport (it must contain enough data to display the tiles currently visible on the display). This value is the amount of cache to be used in addition to the bare minimum.
+\row
+    \li geocoding.host
+    \li Geocoding service URL used by geocoding manager.
+\row
+    \li routing.host
+    \li Routing service URL used by routing manager.
+\row
+    \li places.host
+    \li Search service URL used by search manager.
+\row
+    \li places.api_version
+    \li Version of the REST API used by the places manager.  Currently versions 1 and 2 are
+       supported. The version 1 is deprecated and will not be part of the final Qt release.  The default is version 2.
+\row
+    \li places.theme
+    \li Specifies the icon theme to be used for places and categories.  If no theme is
+        explicitly provided then the platform theme is used.  A default non-platform
+        specific theme can be specified using a value of "default".  The supported themes
+        are "wp7_dark" and "default".  On desktop platforms the "default" theme is the
+        platform theme.
+\endtable
+
+\section1 Parameter Usage Example
+
+The following two examples show how to create a Nokia plugin instance with
+parameters supplied for an application id and token, which is required for
+authentication.
+
+\section2 QML
+
+\code
+Plugin {
+    name: "nokia"
+    PluginParameter { name: "app_id"; value: "myapp" }
+    PluginParameter { name: "token"; value: "abcdefg12345" }
+}
+\endcode
+
+\section2 C++
+
+\code
+QMap<QString,QVariant> params;
+params["app_id"] = "myapp";
+params["token"] = "abcdefg12345";
+
+QGeoServiceProvider *gsp = new QGeoServiceProvider("nokia", params);
+\endcode
+
+\section1 Places
+The Nokia provider remotely accesses places (read-only) from a REST based server.  The specific capabilities
+and behaviours are outlined below:
+
+\section2 Capabilities
+\table
+    \row
+        \li Storage
+        \li remote
+    \row
+        \li Read/Write
+        \li read-only
+    \row
+        \li Icons
+        \li yes
+    \row
+        \li Search term suggestions
+        \li yes
+    \row
+        \li Recommendations
+        \li yes
+    \row
+        \li Category structure
+        \li Hierarchical
+    \row
+        \li (Rich) Content images
+        \li yes
+    \row
+        \li (Rich) Content reviews
+        \li yes
+    \row
+        \li (Rich) Content editorials
+        \li yes
+    \row
+        \li All details fetched during search
+        \li no
+    \row
+        \li Paging offset index
+        \li no
+    \row
+        \li Paging limit
+        \li yes
+    \row
+        \li Distance relevance hint
+        \li no
+    \row
+        \li Lexical name relevance hint
+        \li no
+    \row
+        \li Extended Attributes
+        \li yes
+    \row
+        \li Notifications for added/removed places/categories
+        \li no
+    \row
+        \li visibility scopes
+        \li public
+    \row
+        \li favorites matching/(usable as favoritesPlugin)
+        \li no
+\endtable
+
+\section2 Plugin Specific Behaviors and Limitations.
+\section3 Search
+The following list shows what core place data is returned during a place search:
+\list
+\li name
+\li location
+\li contact information
+\li attribution
+\li categories
+\li rating
+\li visibility
+\endlist
+
+The following list shows further details that may be retrieved
+via QPlaceManager::getDetails()
+\list
+\li supplier
+\li extended attributes
+\endlist
+
+\section3 Searching for Places
+\section4 Search Term and Categories
+The \c nokia plugin supports searching with a \e {search term} and \e {category or categories}, however
+both are not supported simultaneously.
+
+\list
+    \li Valid usage: \e {search term} + \e {search center}
+    \li Valid usage: \e {category} + \e {search center}
+    \li Invalid usage: \e {search term} + \e {category} + \e {search center}
+\endlist
+
+This limitation applies when using the \c nokia plugin with \l PlaceSearchModel and QPlaceManager::search().
+
+\section4 Search Area
+The \c nokia plugin only supports provision of a \e {search center} when searching for places via \l PlaceSearchModel
+and QPlaceManager::search().  A search center can be provided via a bounding circle, however the
+radius should be kept at the default value of -1.  Typically a developer should not have to set the radius at all.
+If a developer sets a radius, it is ignored by the plugin and the boundaries are not honored.
+
+In a similar manner only the center of a bounding box is taken into consideration when searching.  The boundaries
+of the box are not honored.
+
+A search center \e {must} be provided for all searches.
+
+\section4 Relevancy Hints
+The \c nokia plugin does not support relevancy hints.  Any relevancy hints supplied to
+a search request are consequently ignored.
+
+\section3 Search Term suggestions
+Only a partial \e {search term} and \e {search center} is supported when retrieving suggestions.
+This limitation applies when using the \c nokia plugin with the \l PlaceSearchSuggestionModel and QPlaceManager::searchSuggestions().
+
+Both search term and search center \e {must} be provided when retrieving search term suggestions.
+
+\section3 Recommendations
+Only a given \e {place identifier} is supported as a parameter for a recommendations.  No other parameters
+such as limit, offset, and  search area are supported.  This limitation applies when using the
+\c nokia plugin with \l PlaceSearchModel and QPlaceManager::search().
+
+\section3 Icons themes, base urls and variants
+Icons are provided in the form of "base urls" which reference valid icon images.
+For example, if the "wp7_dark" theme was specified, then an icon url might look something like
+http://<server>/01.icon.wp7_dark and this references an actual icon image.
+
+However these urls are "base urls" in the sense that they can be appended onto, to provide variants.
+For example, one could add ".list.png" to the above url to get the list variant of the icon,
+http://<server>/01.icon.wp7_dark.list.png.
+
+The following table shows the themes provided by the \c nokia plugin, along with any
+variants supported for those themes:
+
+\table
+    \header
+        \li Theme
+        \li Supported type variants and appendage strings
+    \row
+        \li "default"
+        \li no variants supported
+    \row
+        \li "wp7_dark"
+        \li
+        \list
+        \li list : ".list.png"
+        \li map: ".map.png"
+        \endlist
+        (Note: the default base urls reference a map type icons)
+\endtable
+
+\section3 Extended Attributes
+The supported set of attributes provided by \c nokia plugin are not fixed and
+may grow over time.  Also the attributes provided may vary according to a place
+by place basis, e.g one place may provide opening hours while another does not.
+At the time of writing, it is known that some places provide \c openingHours
+(QPlaceAttribute::OpeningHours) and \c payment (QPlaceAttribute::Payment)
+methods but other attributes may be made available by the backend server.  All
+places provided by the plugin will have the \c x_provider
+(QPlaceAttribute::Provider)  attribute set to \c nokia.
+
+\section3 Restrictions of Usage - ExtendedAttributes and Content
+The extended attributes  and rich content of places are not permitted
+to be saved.  For QML this is related to \l Place::extendedAttributes, \l ImageModel,
+\l ReviewModel, and \l EditorialModel.  For C++ this relates to QPlace::extendedAttribute(),
+QPlace::content() and QPlaceManager::getPlaceContent().
+
+(Note that the \c nokia plugin is a read-only source of places and
+does not support saving functionality at all.)
+*/
diff --git a/src/location/doc/src/plugins/nokia_terms.qdoc b/src/location/doc/src/plugins/nokia_terms.qdoc
new file mode 100644
index 00000000..c10bbbf0
--- /dev/null
+++ b/src/location/doc/src/plugins/nokia_terms.qdoc
@@ -0,0 +1,41 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page location-plugin-nokia-terms.html
+\title Qt Location Nokia Plugin - Nokia Services Terms and Conditions
+\previouspage {Qt Location Nokia Plugin}
+
+Use of the relevant Nokia services provided by Nokia via the \l {Qt Location Nokia Plugin} are
+governed by the terms and conditions available in the file
+src/plugins/geoservices/nokia/NOKIA_TERMS_AND_CONDITIONS.txt in the Qt Location source
+package.  The terms and conditions are reproduced below for convenience.
+
+\legalese
+\include plugins/geoservices/nokia/NOKIA_TERMS_AND_CONDITIONS.txt
+\endlegalese
+*/
diff --git a/src/location/doc/src/plugins/osm.qdoc b/src/location/doc/src/plugins/osm.qdoc
new file mode 100644
index 00000000..752454d4
--- /dev/null
+++ b/src/location/doc/src/plugins/osm.qdoc
@@ -0,0 +1,55 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Aaron McCarthy <mccarthy.aaron@gmail.com>
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page location-plugin-osm.html
+\title Qt Location Open Street Map Plugin
+\ingroup QtLocation-plugins
+
+\brief Uses Open Street Map and related services.
+
+\section1 Overview
+
+This geo services plugin allows applications to access
+\l {http://openstreetmap.org}{Open Street Map} location based services using the Qt Location API.
+
+The Open Street Map geo services plugin can be loaded by using the plugin key "osm".
+
+\section1 Parameters
+
+\section2 Optional parameters
+The following table lists optional parameters that can be passed to the Open Street Map plugin.
+\table
+\header
+    \li Parameter
+    \li Description
+\row
+    \li useragent
+    \li User agent string set when making network requests.  This parameter should be set to a
+        value that uniquely identifies the application.
+\endtable
+*/
diff --git a/src/location/doc/src/plugins/places-backend.qdoc b/src/location/doc/src/plugins/places-backend.qdoc
new file mode 100644
index 00000000..dd7d68f9
--- /dev/null
+++ b/src/location/doc/src/plugins/places-backend.qdoc
@@ -0,0 +1,151 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page location-places-backend.html
+\title Places Backend
+
+\brief The Places backend is responsible for managing a places datastore whether
+       it is located remotely or locally
+
+\section1 Overview
+
+The QPlaceManager interface, provided to clients to allow access to place information,
+depends directly on an implementation of QPlaceManagerEngine.  The engine provides
+the backend function implementations which are called by the manager.
+
+A places backend implementer needs to derive from QPlaceManagerEngine and provide implementations
+for the virtual functions relevant for their backend.  Most of these functions are asynchronous and
+so implementers will also need to derive the appropriate \l {Places Reply Classes}{reply classes}.
+The reply objects are responsible for managing an asynchronous request; they are used to notify
+when a request is complete and hold the results of that request.  QPlaceManagerEngine provides a
+default implementation for all virtual functions.  The default implementations for the asynchronous
+functions return a reply that will emit the error() and finished() signals at the next iteration
+through the event loop.
+
+\section1 Implementing/Inheriting Reply Objects
+A reply object would be inherited as follows:
+\snippet places/requesthandler.h Implement reply pt1
+\dots
+\snippet places/requesthandler.h Implement reply pt2
+
+The implementation of a QPlaceManagerEngine must ensure that any signals emitted by the reply
+objects are delayed until the request functions have returned and the application code has a chance
+to connect those signals to slots.  The typical approach is to use \l {QMetaObject::invokeMethod()}
+with a \l {Qt::QueuedConnection} to emit the signals.
+
+\snippet places/requesthandler.h Trigger done
+
+Note that the \c finished signals should always be emitted when a reply is complete, even if
+an error has been encountered, that is, if there is an error, both the \c error and \c finished signals
+should be emitted while if there is no error, only the \c finished signals are emitted.
+
+The protected functions of QPlaceSearchReply::setResults() and QPlaceSearchReply::setRequest()
+are made publicly accessible so the plugin can assign results and requests.  Because
+these functions are not publically exported, accessibility is not so much of an issue.
+An alternative would have been to declare a friend class in SearchReply.
+
+Typically the engine instance would be made the \c parent of the reply.  If the developer
+fails to discard the replies when finished, the engine can clean those upon destruction.
+Commonly, the reply also has a pointer reference back to the engine, which may be used
+to emit the QPlaceManagerEngine::finished() and QPlaceManagerEngine::error() signals.  This is
+just one of many ways the reply could be implemented.
+
+\section1 Icon URLs
+Icon URLs are provided through the QPlaceManagerEngine::constructIconUrl() function.
+The expected behaviour is that the engine will use the QPlaceIcon::parameters()
+in order to construct an appropriate URL.  When a QPlace object is returned
+from the manager either from a search or a query to get place details,
+it is expected the engine will correctly populate the parameters as necessary.
+
+The backend is free to choose what the parameter key and values are, however
+if a backend only ever has one URL per icon it is recommended that the QPlaceIcon::SingleUrl
+be used as the key.
+
+\section1 Categories
+The categories of a manager engine are relatively static entities; for engines accessing
+remote place datastores it may be desirable to cache the category structure rather than
+querying a server every time QPlaceManagerEngine::initializeCategories() is called.
+Depending on how dynamic the categories are, always downloading the freshest
+set of categories may be more appropriate.
+
+\section1 Saving Places to the Manager
+A place generally cannot be saved directly between managers as is because it contains manager specific data such as icons
+and categories.  In order to facilitate saving to one's own manager, engine implementers should implement
+the QPlaceManagerEngine::compatiblePlace() function.  This function returns a copy of the input place
+with properties pruned or modified as necessary such that the copy can be saved into manager.
+
+Construction of a compatible place may involve ignoring certain properties from the
+original place, for example if contact details are not supported, these are left out of the
+compatible place.  Other times it may involve modifying certain properties, for example
+modifying the icon parameters to facilitate copying or downloading of the original
+place's icon to a location that the backend can access.
+
+\section1 Cross-Referencing Places Between Managers.
+Sometimes a situation may arise where we wish to cross-reference and match places between managers.
+Such a situation may arise where one manager provides read-only access to places (origin manager), while another second r/w
+manager (destination manager) is used to save selected favorites from the first.  During a search of the origin manager, we may want to
+know which ones have been 'favorited' into the destination manager and perhaps display the customized favorite name
+rather than the original name.
+
+\section2 Alternative Identifier Cross-Referencing
+In order to accomplish cross-referencing, there needs to be a link between the original place and the favorited place
+and this is typically handled via an alternative identifier attribute.  The favorited place contains an alternative identifier attribute which has the identifier of the original place.
+
+\include place-crossref.qdocinc
+
+There are 3 prerequisites for implementing cross-referencing by alternative identifier.  The first is that the origin manager must provide the x_provider attribute
+with the value being the name of the manager's QGeoServiceProvider.  The attribute label should be kept empty, indicating the attribute should not
+be displayed to users.  \note It is generally expected that all managers should set the \c x_provider attribute.
+
+The second is that QPlaceManager::compatiblePlace() of the destination manager use the \c x_provider attribute of the initial place
+and set an alternative identifier attribute of the place to be saved.  The key of the alternative identifier attribute is \c x_id_<provider name> and
+the text value is the identifier of the initial place.  The \c x_provider attribute should not be passed to the compatible place.  When
+it is saved, the x_provider of the saved place is considered to be the destination manager.
+
+The third is that QPlaceManager::matchingPlaces() of the destination manager accept the QPlaceMatchRequest::AlternativeId as a parameter key
+and the alternative identifier attribute key as the value, in this case \c x_id_<provider name> would be the expected value.
+This indicates that the identifiers of places in the QPlaceMatchRequest should be matched against the \c x_id_<provider name> alternative identifier attributes.
+
+Note that if the destination manager is to facilitate saving and cross-referencing from any arbitrary manager, it internally must
+accommodate saving of arbitrary key value pairs since we cannot know the provider names before hand, nor can we know what structure the
+ids will be.
+
+\section3 Other Methods of Linking
+If an origin manager does not supply a place id, it may be necessary to provide some other means of cross-referencing/matching.
+One approach might be to do so via the place coordinates, if the coordinate of a place in the origin manager is identical or close
+to a place in the destination manager, there is a high likelihood that they are the same place.
+In this case, the manager might implement QPlaceManager::matchingPlaces() to accept a QPlaceMatchRequest with a parameter key of 'proximity'
+and a parameter value of the distance two places must be in order to detect a match.  for example if an origin place and destination place are within 50m
+of each other, they can be considered the same place.
+
+Generally however it is recommended that cross referencing be implemented via alternative identifiers as mentioned above.
+
+\section3 User Readable vs Non-User Readable Extended Attributes
+If an attribute is not intended to be readable by end users, the label field should be kept
+empty as an indicator of this fact.
+*/
diff --git a/src/location/doc/src/position.qdoc b/src/location/doc/src/position.qdoc
new file mode 100644
index 00000000..75f54c31
--- /dev/null
+++ b/src/location/doc/src/position.qdoc
@@ -0,0 +1,191 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page location-positioning-cpp.html
+
+\title Positioning (C++)
+
+\brief The Location Positioning API enables location positioning by means of
+GPS or an NMEA data source.
+
+\section1 Positioning
+
+The Positioning component of the Qt Location API is about the geographical position, size
+and address of some place. Positioning contains a QGeoCoordinate class, containing latitude, longitude and altitude in meters. QGeoLocation contains a QGeoCoordinate plus address
+and size information (a bounding box) so that positions can be more than mathematical points.
+Movement into or out of the defined bounding box areas can be monitored. The API
+also allows the developer to control the source of the positional information
+as well.
+
+Location data involves a precisely specified position on the Earth's
+surface \unicode {0x2014} as provided by a latitude-longitude coordinate
+\unicode {0x2014} along with associated data, such as:
+
+    \list
+    \li The date and time at which the position was reported
+    \li The velocity of the device that reported the position
+    \li The altitude of the reported position (height above sea level)
+    \li The bearing of the device in degrees, relative to true north
+    \endlist
+
+This data can be extracted through a variety of methods. One of the most
+well known methods of positioning is GPS (Global Positioning System), a
+publicly available system that uses radiowave signals received from
+Earth-orbiting satellites to calculate the precise position and time of
+the receiver. Another popular method is 'Cell Identifier Positioning', which uses
+the cell identifier of the cell site that is currently serving the receiving
+device to calculate its approximate location. These and other positioning
+methods can all be used with the Location API; the only requirement for a
+location data source within the API is that it provides a
+latitude-longitude coordinate with a date/time value, with the option of
+providing the other attributes listed above.
+
+
+Location data sources are created by subclassing QGeoPositionInfoSource and
+providing QGeoPositionInfo objects through the
+QGeoPositionInfoSource::positionUpdated() signal. Clients that require
+location data can connect to the
+\l{QGeoPositionInfoSource::positionUpdated()}{positionUpdated()} signal and
+call \l{QGeoPositionInfoSource::startUpdates()}{startUpdates()} or
+\l{QGeoPositionInfoSource::requestUpdate()}{requestUpdate()} to trigger the
+distribution of location data. The location data distribution can be stopped by
+calling the \l {QGeoPositionInfoSource::stopUpdates()}{stopUpdates()} function.
+
+A default position source may be available on some platforms. Call
+QGeoPositionInfoSource::createDefaultSource() to create an instance of the default
+position source; the method returns 0 if no default source is available for
+the platform.
+
+If a problem occurs with access to the information source then an
+\l {QGeoPositionInfoSource::error()}{error()} signal is emitted.
+
+The QGeoAreaMonitor class enables client applications to be notified when
+the receiving device has moved in or out of a particular area, as specified
+by a coordinate and radius. If the platform provides built-in support for
+area monitoring, QGeoAreaMonitor::createDefaultMonitor() returns an instance of
+the default area monitor.
+
+Satellite information can also be distributed through the
+QGeoSatelliteInfoSource class. Call QGeoSatelliteInfoSource::createDefaultSource() to
+create an instance of the default satellite data source for the platform,
+if one is available. Alternatively, clients can subclass it to provide a
+custom satellite data source.
+
+
+
+\section2 Requesting Location Data from Data Sources
+
+To receive data from a source, connect to its
+\l{QGeoPositionInfoSource::positionUpdated()}{positionUpdated()} signal,
+then call either \l{QGeoPositionInfoSource::startUpdates()}{startUpdates()}
+or \l{QGeoPositionInfoSource::requestUpdate()}{requestUpdate()} to begin.
+
+Here is an example of a client that receives data from the default location
+data source, as returned by QGeoPositionInfoSource::createDefaultSource():
+
+\code
+class MyClass : public QObject
+{
+    Q_OBJECT
+public:
+    MyClass(QObject *parent = 0)
+        : QObject(parent)
+    {
+        QGeoPositionInfoSource *source = QGeoPositionInfoSource::createDefaultSource(this);
+        if (source) {
+            connect(source, SIGNAL(positionUpdated(QGeoPositionInfo)),
+                    this, SLOT(positionUpdated(QGeoPositionInfo)));
+            source->startUpdates();
+        }
+    }
+
+private slots:
+    void positionUpdated(const QGeoPositionInfo &info)
+    {
+        qDebug() << "Position updated:" << info;
+    }
+};
+
+\endcode
+
+\section2 Controlling Aspects of Data Sources
+
+The QGeoPositionInfoSource::setUpdateInterval() method can be used to
+control the rate at which position updates are received. For example, if
+the client application only requires updates once every 30 seconds, it can
+call \c setUpdateInterval(30000). (If no update interval is set, or
+\l {QGeoPositionInfoSource::}{setUpdateInterval()} is called with a value of 0, the source uses a default
+interval or some other internal logic to determine when updates should be
+provided.)
+
+QGeoPositionInfoSource::setPreferredPositioningMethods() enables client
+applications to request that a certain type of positioning method be used.
+For example, if the application prefers to use only satellite positioning,
+which offers fairly precise outdoor positioning but can be a heavy user of
+power resources, it can call this method with the
+QGeoPositionInfoSource::SatellitePositioningMethods value. However, this
+method should only be used in specialized client applications; in most
+cases, the default positioning methods should not be changed, as a source
+may internally use a variety of positioning methods that can be useful to
+the application.
+
+\section2 NMEA Data
+
+\l {http://en.wikipedia.org/wiki/NMEA_0183}{NMEA} is a common text-based
+protocol for specifying navigational data. For convenience, the
+QNmeaPositionInfoSource is provided to enable client applications to read
+and distribute NMEA data in either real-time mode (for example, when
+streaming from a GPS device) or simulation mode (for example, when reading
+from a NMEA log file). In simulation mode, the source will emit updates
+according to the time stamp of each NMEA sentence to produce a "replay"
+of the recorded data.
+
+Generally, the capabilities provided by the default position source as
+returned by QGeoPositionInfoSource::createDefaultSource(), along with the
+QNmeaPositionInfoSource class, are sufficient for retrieving location
+data. However, in some cases developers may wish to write their own custom
+location data source.
+
+The \l {Log File Position Source (C++)} example demonstrates how to subclass QGeoPositionInfoSource
+to create a custom positioning source.
+
+
+\section1 Examples
+
+\section3 \b{Flickr Example}
+
+The \l{Flickr QML}{Flickr Example} uses the Location to download thumbnail
+images from Flickr relevant to the current location.
+
+
+
+\section1 Location Position Classes
+
+\annotatedlist QtLocation-positioning
+
+*/
diff --git a/src/location/doc/src/qml-maps.qdoc b/src/location/doc/src/qml-maps.qdoc
new file mode 100644
index 00000000..45cf82f4
--- /dev/null
+++ b/src/location/doc/src/qml-maps.qdoc
@@ -0,0 +1,216 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \group qml-QtLocation5-maps
+    \title QML Maps Plugin
+    QML Support for the Qt Location API.
+*/
+
+
+/*!
+\page qml-location5-maps.html
+\title QML Maps
+
+\brief Maps deals with maps, their contents and navigation.
+
+\section1 Overview
+
+The \l Map type allows the display of a map and placing objects within the map.
+Various points of interest can be defined and added to the map for display.
+Also the \l Map has features to control how the map is displayed. With the
+Map item you can center the map, zoom, pinch and make the item flickable.
+
+The places to be added to the map are
+\l {Maps and Navigation (QML)#Putting Objects on a Map (Map Overlay Objects)}{MapItems}. The item's
+position is defined by a \l {coordinate}{coordinate} which includes latitude,
+longitude and altitude.  The item is then displayed automatically after it is added to the Map.
+Interaction with the added items, and the \l Map itself, is handled by \l MapMouseArea when items
+are added as children of the
+\l {Maps and Navigation (QML)#Putting Objects on a Map (Map Overlay Objects)}{MapItems} or \l Map.
+
+\section2 Position
+
+The basic piece of position information is the \l {coordinate}.  A
+coordinate encapsulates data for the latitude, longitude and altitude of the location.  Altitude is
+in meters. It also has a method to determine distance to another
+\l {coordinate}.  The \l {coordinate} type may
+also be held within a \l {QtLocation5::Location}{Location} element, this will also have information
+on a bounding box size to determine sufficient proximity to the location and a location address.
+
+\section2 Geocoding
+
+\l {http://en.wikipedia.org/wiki/Geocoding}{Geocoding} is the derivation of
+geographical coordinates (latitude and longitude) from other geographical references
+to the locations. For example, this can be a street address. Reverse geocoding is also possible with
+a street address being used to determine a geographical coordinate. Geocoding
+is performed by using the \l GeoCodeModel type.
+
+The following code examples are a small part of the \c map component in the
+\l {Map Viewer (QML)}{Map Viewer (QML)} example. The snippets
+demonstrate the declaration of the \l GeocodeModel component.
+
+In the snippet we see that the \c geocodeModel property contains the plugin
+and two signal handlers. One for changes in status (\c onStatusChanged ) and
+the other to update the centering of the Map object (\c onLocationsChanged ).
+
+\snippet mapviewer/content/map/MapComponent.qml geocodemodel0
+\snippet mapviewer/content/map/MapComponent.qml geocodemodel0 body
+\snippet mapviewer/content/map/MapComponent.qml geocodemodel1
+\codeline
+\snippet mapviewer/content/map/MapComponent.qml geocodeview
+
+These geocoding features are called from a higher level piece of code. In this
+snippet we see an \c onGoButtonClicked signal handler that extracts the address
+from the user interface and then creates a query for the \l GeocodeModel to
+process and determine the geographical coordinates.
+
+\snippet mapviewer/mapviewer.qml geocode1
+
+
+\section2 Navigation
+
+A very important function of the \l Map type is navigation
+from one place to a destination with possible waypoints along the route. The
+route will be divided up into a series of segments. At the end of each segment
+is a vertex called a \e maneuver. The \e segments contain information about
+the time and distance to the end of the segment. The \e maneuvers contain information
+about what to do next, how to get onto the next segment, if there is one. So
+a \e maneuver contains navigational information, for example "turn right now".
+
+To find a suitable route we will need to use a \l RouteQuery to define the
+selection criteria and adding any required waypoints.
+The \l RouteModel should return a list of \l {RouteSegment}s that defines the
+route to the destination complete with navigation advice at the joins between
+segments, called \l {RouteManeuver}s
+
+There are many options that you can add to the query to narrow the criteria.
+The \l RouteQuery properties can include
+
+\table 60%
+    \row
+        \li \l {RouteQuery::}{numberAlternativeRoutes}
+        \li The number of alternative routes
+    \row
+        \li \l {RouteQuery::}{travelModes}
+        \li Travel modes
+    \row
+        \li \l {RouteQuery::}{routeOptimizations}
+        \li Required route optimizations
+    \row
+        \li \l {RouteQuery::}{segmentDetail}
+        \li Level of detail in segments
+    \row
+        \li \l {RouteQuery::}{maneuverDetail}
+        \li Level of detail in maneuvers between segments
+    \row
+        \li \l {RouteQuery::}{waypoints}
+        \li A list of waypoints
+    \row
+        \li \l {RouteQuery::}{excludedAreas}
+        \li A list of excluded areas that the route must not cross
+    \row
+        \li \l {RouteQuery::}{featureTypes}
+        \li Relevant map features, for example highway, ferry
+\endtable
+
+
+In the following example a default RouteQuery is declared, later to be defined
+by some user input, and used in \c routeModel as the query. The \c routeInfoModel
+is a \l {Models and Views in Qt Quick#ListModel}{ListModel} that can be updated using an
+\c update() function that we will look at later.
+
+\snippet mapviewer/content/map/MapComponent.qml routemodel0
+\codeline
+\snippet mapviewer/content/map/MapComponent.qml routemodel1
+\codeline
+\snippet mapviewer/content/map/MapComponent.qml routemodel2
+\snippet mapviewer/content/map/MapComponent.qml routemodel3
+
+The user enters, via a dialog, some information such as the starting point
+of the route, some waypoints and the destination. All of these locations are
+waypoints so the locations from start to finish will be entered as a sequence
+of waypoints. Then other query properties can be set that may be specific to
+this trip.
+
+\snippet mapviewer/mapviewer.qml routerequest0
+\codeline
+\snippet mapviewer/mapviewer.qml routerequest0 feature weight
+\codeline
+\snippet mapviewer/mapviewer.qml routerequest1
+\snippet mapviewer/mapviewer.qml routedialog1
+
+The \c routeInfoModel \l {Models and Views in Qt Quick#ListModel}{ListModel} is used to grab the
+results of the query and construct a suitable list for display.  The
+\l {Models and Views in Qt Quick#ListModel}{ListModel} \c routeInfoModel contains an \c update()
+function that loops through the segments extracting the segment length, instruction text and
+distance to the next instruction.  The extracted data is formatted for display as it is retrieved.
+
+\snippet mapviewer/content/map/MapComponent.qml routeinfomodel
+\codeline
+\snippet mapviewer/content/map/MapComponent.qml routeview
+
+For more information on the example see the \l {Map Viewer (QML)}{Map Viewer (QML)} example.
+
+
+\section2  Zoom, Pinch and Flickable
+
+The \l Map item also supports user interface interactions with the map using
+tactile and mouse gestures. That is features such as swiping to pan,
+pinching to zoom.
+
+Enabling and configuring pinch and flickable is easy within the \l Map type.
+
+\snippet mapviewer/content/map/MapComponent.qml top
+\snippet mapviewer/content/map/MapComponent.qml end
+
+Zoom can also be controlled by other objects like sliders, as shown in the
+example, by implementing the \c onValueChanged handler to update the Map
+\l {QtLocation5::Map::}{zoomLevel}.
+
+\section1 Types
+
+\section3 Positioning
+\annotatedlist qml-QtLocation5-positioning
+
+\section3 Maps
+\annotatedlist qml-QtLocation5-maps
+
+\section3 Geocoding
+\annotatedlist qml-QtLocation5-geocoding
+
+\section3 Routing
+\annotatedlist qml-QtLocation5-routing
+
+
+
+\section1 Example
+
+The above snippets are taken from the \l {Map Viewer (QML)}{Map Viewer (QML)} example.
+
+*/
+
diff --git a/src/location/doc/src/qml-position.qdoc b/src/location/doc/src/qml-position.qdoc
new file mode 100644
index 00000000..9553f6d2
--- /dev/null
+++ b/src/location/doc/src/qml-position.qdoc
@@ -0,0 +1,136 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page location-positioning-qml.html
+
+\title Positioning (QML)
+
+\brief The Location Positioning API enables location positioning by means of
+GPS or an NMEA data source.
+
+\section1 Location Positioning
+
+Location data involves a precisely specified position on the Earth's
+surface \unicode {0x2014} as provided by a latitude-longitude coordinate
+\unicode {0x2014} along with associated data, such as:
+
+    \list
+    \li The date and time at which the position was reported
+    \li The velocity of the device that reported the position
+    \li The altitude of the reported position (height above sea level)
+    \li The bearing of the device in degrees, relative to true north
+    \endlist
+
+For more information see
+\l {http://en.wikipedia.org/wiki/Geographic_coordinate}{Geographic Coordinate}.
+
+This data can be extracted through a variety of methods. One of the most
+well known methods of positioning is GPS (Global Positioning System), a
+publicly available system that uses radiowave signals received from
+Earth-orbiting satellites to calculate the precise position and time of
+the receiver. Another popular method is 'Cell Identifier Positioning', which uses
+the cell identifier of the cell site that is currently serving the receiving
+device to calculate its approximate location. These and other positioning
+methods can all be used with the Location API; the only requirement for a
+location data source within the API is that it provides a
+latitude-longitude coordinate with a date/time value, with the option of
+providing the other attributes listed above.
+
+\section2 Coordinate
+
+The \l {coordinate} is a basic unit of geographical information. The
+\l {coordinate} type has attributes to hold the \c {latitude},
+\c longitude and \c altitude.
+
+\section2 Position
+
+The three dimensional position of an object such as a mobile device can be specified by giving
+the latitude, longitude and altitude.  That is the values held in the
+l\ {coordinate} type.  Additionally for computation of future
+positions we would like to know if the object is moving, what \l {Position::speed}{speed} it is
+doing and what is the \l {Position::timestamp}{timestamp} of the last position data.  Position
+therefore includes values for the \l {Position::coordinate}{coordinate},
+\l {Position::speed}{speed} and a \l {Position::timestamp}{timestamp}.  \l Position also takes
+responsibility for validation of sensible values for these properties.  These are exposed as
+the \l {Position::latitudeValid}{latitudeValid}, \l {Position::longitudeValid}{longitudeValid},
+\l {Position::altitudeValid}{altitudeValid}, \l {Position::speedValid}{speedValid},
+\l {Position::horizontalAccuracyValid}{horizontalAccuracyValid}, and
+\l {Position::verticalAccuracyValid}{verticalAccuracyValid} properties.
+
+
+\section2 PositionSource
+
+We have a Position type, a \l {coordinate} type but where does the data come from?
+Also it is a good idea to be able to indicate alternative sources.
+Perhaps instead of directly picking up GPS satellites it might be desirable to do
+some testing using a datafile.
+
+The \l PositionSource type provides the developer with control,
+within the limits allowed by the platform, of the source of the
+geographical data. Apart from tradtional sources such as GPS and cell data the positional data can be
+sourced from a logfile which is in NMEA format.
+
+\l {http://en.wikipedia.org/wiki/NMEA}{NMEA} is a common text-based protocol for specifying navigational data. For convenience, the \l {PositionSource::nmeaSource}{nmeaSource} property is provided to enable QML applications to read NMEA data from a log file, the source will emit updates according to the time stamp of each NMEA sentence to produce a "replay" of the recorded data.
+
+
+\section2 Example: Centering the Map on the Current Position
+
+Here is an example of a client that uses a \l{PositionSource}{position source}
+to center a \l{Map}{map} on the current position:
+
+\code
+Rectangle {
+
+    import QtLocation 5.0
+    ...
+
+    map : Map {
+        // initialize map
+        ...
+    }
+
+    PositionSource {
+        onPositionChanged: {
+            // center the map on the current position
+            map.center = position.coordinate
+        }
+    }
+}
+\endcode
+
+
+\section2 \b{Flickr Example}
+
+The \l{Flickr (QML)}{Flickr Example} uses the Location to download thumbnail
+images from Flickr relevant to the current location.
+
+
+\section1 Position QML Components
+
+\annotatedlist qml-QtLocation5-positioning
+*/
diff --git a/src/location/doc/src/qtlocation-cpp.qdoc b/src/location/doc/src/qtlocation-cpp.qdoc
new file mode 100644
index 00000000..c13360b5
--- /dev/null
+++ b/src/location/doc/src/qtlocation-cpp.qdoc
@@ -0,0 +1,96 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qtlocation-cpp.html
+\title Qt Location C++ API
+\brief Information about the Qt Location C++ API
+
+The Location API provides a library for location positioning, mapping and navigation.
+
+\tableofcontents
+
+The Qt Location API provides the developer with a set of functions for determining
+the current location and using that information with maps and places of interest.
+
+Positioning information can be sourced from GPS satellites or a stream of data using
+NMEA formatted text. Once a position is acquired we can monitor the updated
+position to see if it moves into or out of a given region. With the Maps API
+we can associate the position with a map in various formats supplied by a backend.
+Then the Places API could be used to populate places on the Map or even
+specify the current position as a place of interest and associate it with
+an icon, contact details and other information.
+
+The following table provides links to more detailed information on sections of the
+Qt Location C++ API.
+
+\table
+    \row
+        \li \l {Positioning (C++)}{Location Positioning}
+        \li Retrieving information about the current position.
+    \row
+        \li \l {Maps and Navigation (C++)}{Maps and Navigation}
+        \li Displaying maps and finding routes.
+    \row
+        \li \l {Places (C++)} {Places}
+        \li Searching for and managing points of interest.
+    \row
+        \li \l {Qt Location GeoServices}{Geoservices and Positioning Plugin Implementation}
+        \li Implement new geoservices and positioning plugins.
+\endtable
+
+
+\section1 Positioning Classes
+
+    \annotatedlist QtLocation-positioning
+
+
+\section1 Geoservice Provider Classes
+
+    \annotatedlist QtLocation-common
+
+
+\section1 Maps and Navigation Classes
+
+    \annotatedlist QtLocation-maps
+
+    \annotatedlist QtLocation-routing
+
+    \annotatedlist QtLocation-geocoding
+
+
+\section1 Places Classes
+
+    \annotatedlist QtLocation-places
+
+
+\section1 Geoservices and Positioning Plugin Classes
+
+    \annotatedlist QtLocation-impl
+
+*/
+
diff --git a/src/location/doc/src/qtlocation-geoservices.qdoc b/src/location/doc/src/qtlocation-geoservices.qdoc
new file mode 100644
index 00000000..7adb9b18
--- /dev/null
+++ b/src/location/doc/src/qtlocation-geoservices.qdoc
@@ -0,0 +1,62 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+\page qtlocation-geoservices.html
+\title Qt Location GeoServices
+\brief Implementing Qt Location GeoService plugins
+
+The Qt Location provides the majority of its functionality through GeoService plugins. This
+document outlines how to develop a new GeoService plugin.
+
+\section1 Implementing Plugins
+
+A plugin implementer needs to subclass QGeoServiceProviderFactory and as
+many of the ManagerEngine classes as they want to provide implementations for.
+
+Subclassing QGeoServiceProviderFactory will only involve exposing a name and
+a version by overriding QGeoServiceProviderFactory::providerName() and
+QGeoServiceProviderFactory::providerVersion(), and overriding
+QGeoServiceProviderFactory::createSearchManagerEngine(),
+QGeoServiceProviderFactory::createMappingManagerEngine() and
+QGeoServiceProviderFactory::createRoutingManagerEngine() as appropriate.
+
+\section3 Tile-Based Map Convenience Classes
+
+Most of the current tile based mapping APIs are very similar, and so we
+provide a number of classes intended to make writing tile based mapping
+plugins much simpler.
+
+If the Mercator projection and the most common tile addressing scheme is used this will mainly
+involve subclassing QGeoTiledMappingManagerEngine and providing an implementation of
+QGeoTiledMappingManagerEngine::getTileImage().
+
+\section1 GeoService Classes
+
+\annotatedlist QtLocation-impl
+
+*/
diff --git a/src/location/doc/src/qtlocation-qml.qdoc b/src/location/doc/src/qtlocation-qml.qdoc
new file mode 100644
index 00000000..351552de
--- /dev/null
+++ b/src/location/doc/src/qtlocation-qml.qdoc
@@ -0,0 +1,143 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \qmlmodule QtLocation 5.0
+    \title Qt Location QML Types
+    \ingroup qmlmodules
+    \brief Provides QML types for mapping and location information
+
+\section1 Overview
+
+The identifying string for this module is \e QtLocation. To use include the following import
+statement in the QML file.
+
+\snippet declarative/plugin.qml Plugin import
+
+\section2 Location QML Concepts
+
+Position information can come from a variety of sources including satellites,
+wifi, text files and so on. The position is described by the latitude,
+the longitude, and the altitude in meters. For more information see
+\l {http://en.wikipedia.org/wiki/Geographic_coordinate}{Geographic Coordinate}.
+
+The QML position is stored in a \l {coordinate} which contains the
+latitude, longitude and altitude of the device.  The \l {QtLocation5::Location}{Location} contains
+this \l {coordinate} and adds an address, it also has a bounding box which
+defines the recommended viewing region when displaying the location.
+
+Now that the device has a position, with regular updates the API can determine
+the speed and heading of the device. It can also define a box or a circle that can
+produce a notification when the device either leaves or enters that region.
+
+Adding a \l {QtLocation5::Map}{Map} with positions of interest and
+\l {QtLocation5::Place}{Places}, then the device can be made aware of nearby features and related
+information, displayed graphically. Features on the \l Map may be places of business, entertainment
+and so on.  They may include paths, roads, or forms of transport leading so that
+navigation optimization and assistance are possible.
+
+To perform navigation we need \l {Route}s from start to destination. These routes
+are made up of segments. Each \l {QtLocation5::RouteSegment}{RouteSegment}
+can be considered a navigation sub-task: drive 100 meters, turn left. The beginning and
+end of each segment is a \e waypoint, that is, one part of our journey.
+
+A typical use case for the API is a user looking for a particular type of
+place, say a restaurant. The user could enter a search string into the map
+application and respond to a list or display of results for restaurants
+"near" the device. The application could then be used to navigate to the
+restaurant using an optimized route that is aware of features in the
+environment that can help or hinder the journey. The navigation then
+proceeds with the user's progress monitored by means of the current
+\l Location. In the context of this API the map application would be aware
+of the location and size of various places and the location of the user.
+Plugins would supply the data used by the application to determine routes and
+navigation instructions. The \l Place types would hold information about the
+destination and surrounding objects including displayable representations.
+The \l Map type would enable this information to be displayed, panned,
+zoomed and so on. The \l Route would be determined by a plugin with each
+\l RouteSegment holding the navigation instructions guided by the updated
+current \l Location.
+
+\l {Plugin}s are a means of specifying which Location based service to use. For example,
+a plugin may allow connection to a provider's service that handles geocoding and routing
+that the API and application can use. There may be various GeoServices plugins for various tasks
+with some plugins providing more than one service. One QML \l Plugin should be created
+for each required GeoService plugin. Plugins are required for maps, routing and geocoding,
+however the default plugin handles all three of these services. A plugin may
+require online access or may support on-board maps and data. The default "nokia"
+plugin only supports online use. The connection would be managed by QNetworkInfo and
+QNetworkConfigurationManager.
+
+\note: Plugins may not provide various features such as paging or relevance hints.
+Since plugins may be supplied by other providers, support for these aspects is
+dependent on the provider's implementation.
+
+The following table provides links to more detailed information on sections of the Qt Location QML
+API.
+
+\table
+    \row
+        \li \l {Positioning (QML)}{Location Positioning}
+        \li Retrieving information about the current position.
+    \row
+        \li \l {Maps and Navigation (QML)}{Maps and Navigation}
+        \li Displaying maps and finding routes.
+    \row
+        \li \l {QML PLaces API} {Places}
+        \li Searching for and managing points of interest.
+\endtable
+
+\section1 Basic Types
+
+\annotatedlist qml-QtLocation5-basictypes
+
+\section1 Common QML Types
+
+\annotatedlist qml-QtLocation5-common
+
+\section1 Positioning QML Types
+
+\annotatedlist qml-QtLocation5-positioning
+
+\section1 Maps QML Types
+
+\annotatedlist qml-QtLocation5-maps
+
+\section1 Navigation and Routing QML Types
+
+\annotatedlist qml-QtLocation5-routing
+
+\section1 Geocoding QML Types
+
+\annotatedlist qml-QtLocation5-geocoding
+
+\section1 Places QML Types
+
+\annotatedlist qml-QtLocation5-places
+
+\section1 Alphabetical Listing of all QML Types
+*/
diff --git a/src/location/doc/src/qtlocation.qdoc b/src/location/doc/src/qtlocation.qdoc
new file mode 100644
index 00000000..31ed3055
--- /dev/null
+++ b/src/location/doc/src/qtlocation.qdoc
@@ -0,0 +1,216 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+
+
+/*!
+    \module QtLocation
+    \title Qt Location C++ Classes
+    \ingroup modules
+
+    \brief Location module provides positioning, mapping, navigation, and place search
+       via QML and C++ interfaces.
+
+    To load the Qt Location module, add the following statement to your .qml files
+
+    \code
+        import QtLocation 5.0
+    \endcode
+
+    For C++ projects include the header appropriate for the current use case,
+    for example applications using routes may use
+
+    \code #include <QGeoRoute> \endcode
+
+    The .pro file should have the \e location keyword added
+
+    \code
+        QT += location
+    \endcode
+
+
+    See more in the \l{Qt Location}{Qt Location Overview}.
+
+*/
+
+
+
+/*!
+\page qtlocation-index.html
+\title Qt Location
+\brief The Qt Location API provides positioning, mapping, navigation, and place search
+       via QML and C++ interfaces.
+\ingroup technology-apis
+
+The Qt Location API provides positioning, mapping, navigation, and place search via QML
+and C++ interfaces.
+
+\section1 Overview
+
+The Qt Location API gives developers the ability to determine a position by
+using a variety of possible sources, including satellite, or wifi, or text file,
+and so on. That information can then be used to determine a position in a map
+context with appropriate navigation and to embed, in the map, defined places
+with descriptive metadata. These three parts
+allow a device to know where it is and its location with respect to important
+features. Using features such as roads, destinations, routes,
+and other navigation attributes, applications can specify beginning and end-points
+for navigation and awareness of objects that may aid or hinder a journey.
+
+\section1 Getting Started
+
+To load the Qt Location module, add the following statement to your .qml files
+
+\code
+    import QtLocation 5.0
+\endcode
+
+For C++ projects include the header appropriate for the current use case,
+for example applications using routes may use
+
+\code #include <QGeoRoute> \endcode
+
+The .pro file should have the \e location keyword added
+
+\code
+    QT += location
+\endcode
+
+\section2 API Sub-Modules
+The API is split into three core sub-modules, which each have QML and C++
+APIs.
+
+\section3 Positioning
+Positioning includes all the functionality necessary to find and work with geographic
+coordinates. It can use a variety of external sources of information, including GPS. This
+provides us with a coordinate and altitude for the device with additional features
+such as speed and direction. This provides the fundamental location information used in the API.
+\table
+\row
+    \li Positioning introduction:
+    \li \l{Positioning (QML)}{for QML}
+    \li \l{Positioning (C++)}{for C++}
+\endtable
+
+\section3 Places
+Places is
+the natural complement to Positioning, providing a source of geographic
+data about places of interest (POIs). As well as providing the location,
+size and other vitals about a POI, the Places API can also retrieve images,
+reviews and other rich content related to the place.
+
+\table
+\row
+    \li Places introduction:
+    \li \l{QML Places API}{for QML}
+    \li \l{Places (C++)}{for C++}
+\endtable
+
+\section3 Maps and Navigation
+Maps and Navigation provides Qt Quick user
+interface components for displaying geographic information on a map, as
+well as allowing user interaction with map objects and the display itself.
+It also contains utilities for geocoding (finding a geographic coordinate
+from a street address) and navigation (including driving and walking
+directions).
+\table
+\row
+
+\li Maps and Navigation introduction:
+    \li \l{Maps and Navigation (QML)}{for QML}
+    \li \l{Maps and Navigation (C++)}{for C++}
+\endtable
+
+\section1 API References and Examples
+
+Alphabetized lists of all classes and user interface components in the API, as well as detailed
+example applications to demonstrate their usage.
+
+\table
+    \row
+        \li \l {Qt Location QML Types}{QML API Reference}
+        \li Full list of QML components in the Qt Location API
+    \row
+        \li \l {Qt Location C++ API}{C++ API Reference by domain}
+        \li Full list of C++ classes and methods of the Qt Location APIs sorted by domain
+    \row
+        \li \l {Qt Location C++ Classes}{C++ API Reference}
+        \li Full list of C++ classes and methods of the Qt Location APIs
+    \row
+        \li \l {Qt Location Examples}{Example Apps}
+        \li Examples demonstrating use of the Qt Location APIs
+     \row
+        \li \l {QML Maps}{Maps and Navigation Tutorial}
+        \li Tutorial introducing the QML Maps Types
+\endtable
+
+\section1 Plugin References and Parameters
+
+Information about plugins, important notes on their usage, parameters that can
+be provided to influence their behavior.
+
+\annotatedlist QtLocation-plugins
+
+\section2 Implementing New Back-Ends and Porting
+
+For systems integrators and distributors, information relating to making
+Qt Location available for a new platform.
+
+\table
+    \row
+        \li \l {Qt Location GeoServices}{GeoServices}
+        \li Information about the Qt Location GeoServices plugins
+    \row
+        \li \l {Places Backend} {Places}
+        \li Information for places backend implementors
+\endtable
+
+\section1 New Since Qt 4
+
+In Qt 4 Qt Mobility provided some location functionality for Positioning and Maps
+with Landmarks support. The new Qt Location API has had an extensive reworking
+of \l {Map}s and \l {Place}s (formerly Landmarks). Also both C++ and QML APIs have
+been reworked to be simpler to use.
+
+New features of Qt Location includes
+\list
+    \li Maps are now part of the Qt Quick scenegraph, and rendered using hardware-accelerated OpenGL
+    \li Arbitrary Qt Quick items on the map are supported using \l MapQuickItem
+    \li Now possible to create map overlays with a model
+    \li Built-in support for pinch-to-zoom gestures, flicking , and panning (see \l MapGestureArea)
+    \li Vast performance improvements over Qt Mobility 1.2, especially for large map polylines and objects in general
+    \li Full QML API now available for routing and geocoding -- compatible with standard QML model-view design
+    \li Service provider feature detection without having to open all the available plugins
+    \li Unified \l Plugin QML type used by routing/geocoding/maps etc with easy-to-set \l PluginParameter
+    \li Two plugins are supplied with Qt (a Nokia and an OSM plugin for GeoServices).
+    \li Landmarks API is replaced by the Places API
+    \li \l Place supports viewing of richer content such as reviews, images, and editorials
+    \li \l Place supports locale handling, sponsored search results, and supplier attribution
+\endlist
+
+*/
diff --git a/src/location/doc/src/src.pro b/src/location/doc/src/src.pro
new file mode 100644
index 00000000..fe90f135
--- /dev/null
+++ b/src/location/doc/src/src.pro
@@ -0,0 +1,9 @@
+TEMPLATE = subdirs
+SUBDIRS += snippets
+
+OTHER_FILES = \
+    *.qdoc \
+    *.qdocinc \
+    plugins/*.qdoc \
+    examples/*.qdoc \
+    imports/*.qdoc