diff --git a/src/lib/marble/geodata/data/GeoDataSchemaData.cpp b/src/lib/marble/geodata/data/GeoDataSchemaData.cpp
index 7183989af..9ad211b1c 100644
--- a/src/lib/marble/geodata/data/GeoDataSchemaData.cpp
+++ b/src/lib/marble/geodata/data/GeoDataSchemaData.cpp
@@ -1,157 +1,157 @@
 //
 // This file is part of the Marble Virtual Globe.
 //
 // This program is free software licensed under the GNU LGPL. You can
 // find a copy of this license in LICENSE.txt in the top directory of
 // the source code.
 //
 // Copyright 2014 Abhinav Gangwar <abhgang@gmail.com>
 //
 
 #include "GeoDataSchemaData.h"
 
 // Qt
 #include <QDataStream>
 #include <QString>
 #include <QHash>
 
 // Marble
 #include "GeoDataSimpleData.h"
 #include "GeoDataTypes.h"
 
 namespace Marble
 {
 
 class GeoDataSchemaDataPrivate
 {
 public:
     GeoDataSchemaDataPrivate()
     : m_parent( nullptr )
     {
         // nothing to do
     }
 
     QString m_schemaUrl;
     QHash<QString, GeoDataSimpleData> m_simpleData;   // Map for name and SimpleData
-    GeoNode *m_parent;
+    GeoDataExtendedData *m_parent;
 };
 
 GeoDataSchemaData::GeoDataSchemaData()
     : d( new GeoDataSchemaDataPrivate )
 {
 }
 
 GeoDataSchemaData::GeoDataSchemaData( const GeoDataSchemaData &other )
     : d( new GeoDataSchemaDataPrivate( *other.d ) )
 {
 }
 
 GeoDataSchemaData &GeoDataSchemaData::operator=( const GeoDataSchemaData &rhs )
 {
     *d = *rhs.d;
     return *this;
 }
 
 bool GeoDataSchemaData::operator==( const GeoDataSchemaData &other ) const
 {
     if ( d->m_schemaUrl != other.d->m_schemaUrl ||
          d->m_simpleData.size() != other.d->m_simpleData.size() )
     {
         return false;
     }
 
     QHash<QString, GeoDataSimpleData>::iterator begin = d->m_simpleData.begin();
     QHash<QString, GeoDataSimpleData>::iterator end = d->m_simpleData.end();
     QHash<QString, GeoDataSimpleData>::iterator beginOther = other.d->m_simpleData.begin();
 
     for( ; begin != end; ++begin, ++beginOther ) {
         if ( *begin != *beginOther ) {
             return false;
         }
     }
 
     return true;
 }
 
 bool GeoDataSchemaData::operator!=( const GeoDataSchemaData &other ) const
 {
     return !this->operator==(other);
 }
 
 GeoDataSchemaData::~GeoDataSchemaData()
 {
     delete d;
 }
 
 QString GeoDataSchemaData::schemaUrl() const
 {
     return d->m_schemaUrl;
 }
 
 void GeoDataSchemaData::setSchemaUrl( const QString &schemaUrl )
 {
     d->m_schemaUrl = schemaUrl;
 }
 
 GeoDataSimpleData &GeoDataSchemaData::simpleData( const QString &name ) const
 {
     return d->m_simpleData[ name ];
 }
 
 void GeoDataSchemaData::addSimpleData( const GeoDataSimpleData &data )
 {
     d->m_simpleData.insert( data.name(), data );
 }
 
 QList<GeoDataSimpleData> GeoDataSchemaData::simpleDataList() const
 {
     return d->m_simpleData.values();
 }
 
-void GeoDataSchemaData::setParent( GeoNode *parent )
+void GeoDataSchemaData::setParent(GeoDataExtendedData *parent)
 {
     d->m_parent = parent;
 }
 
-const GeoNode *GeoDataSchemaData::parent() const
+const GeoDataExtendedData *GeoDataSchemaData::parent() const
 {
     return d->m_parent;
 }
 
-GeoNode *GeoDataSchemaData::parent()
+GeoDataExtendedData *GeoDataSchemaData::parent()
 {
     return d->m_parent;
 }
 
 const char* GeoDataSchemaData::nodeType() const
 {
     return GeoDataTypes::GeoDataSchemaDataType;
 }
 
 void GeoDataSchemaData::pack( QDataStream &stream ) const
 {
     stream << d->m_schemaUrl;
     stream << d->m_simpleData.size();
 
     QHash<QString, GeoDataSimpleData>::const_iterator iter = d->m_simpleData.constBegin();
     QHash<QString, GeoDataSimpleData>::const_iterator end = d->m_simpleData.constEnd();
 
     for( ; iter != end; ++iter ) {
         iter.value().pack( stream );
     }
 }
 
 void GeoDataSchemaData::unpack( QDataStream &stream )
 {
     stream >> d->m_schemaUrl;
     int size = 0;
     stream >> size;
 
     for( int i = 0; i < size; i++ ) {
         GeoDataSimpleData simpleData;
         simpleData.unpack( stream );
         d->m_simpleData.insert( simpleData.name(), simpleData );
     }
 }
 
 }   // namespace Marble
diff --git a/src/lib/marble/geodata/data/GeoDataSchemaData.h b/src/lib/marble/geodata/data/GeoDataSchemaData.h
index 93863636b..6e04fe2d5 100644
--- a/src/lib/marble/geodata/data/GeoDataSchemaData.h
+++ b/src/lib/marble/geodata/data/GeoDataSchemaData.h
@@ -1,97 +1,98 @@
 //
 // This file is part of the Marble Virtual Globe.
 //
 // This program is free software licensed under the GNU LGPL. You can
 // find a copy of this license in LICENSE.txt in the top directory of
 // the source code.
 //
 // Copyright 2014 Abhinav Gangwar <abhgang@gmail.com>
 //
 
 #ifndef MARBLE_GEODATASCHEMADATA_H
 #define MARBLE_GEODATASCHEMADATA_H
 
 // Qt
 #include <QList>
 
 // Marble
 #include "GeoDocument.h"
 
 #include "geodata_export.h"
 
 namespace Marble
 {
 
+class GeoDataExtendedData;
 class GeoDataSchemaDataPrivate;
 class GeoDataSimpleData;
 
 /**
  */
 class GEODATA_EXPORT GeoDataSchemaData : public GeoNode
 {
 public:
     GeoDataSchemaData();
     GeoDataSchemaData( const GeoDataSchemaData& other );
     GeoDataSchemaData& operator=( const GeoDataSchemaData& rhs );
     bool operator==( const GeoDataSchemaData &other ) const;
     bool operator!=( const GeoDataSchemaData &other ) const;
     ~GeoDataSchemaData() override;
 
     /*
      * @brief Returns the id for schema which defines custom data
      */
     QString schemaUrl() const;
 
     /*
      * @brief Set the schemaUrl attribute of SchemaData to @p schemaUrl
      */
     void setSchemaUrl( const QString& schemaUrl );
 
     /*
      * @brief Returns the SimpleData having name attribute @p name
      */
     GeoDataSimpleData& simpleData( const QString& name ) const;
 
     /*
      * @brief Adds a SimpleData @p simpleData to schemaDataHash
      */
     void addSimpleData( const GeoDataSimpleData& simpleData );
 
     /*
      * @brief Dump a list containing all SimpleData values stored in schemaDataHash
      */
     QList<GeoDataSimpleData> simpleDataList() const;
 
     /*
      * @brief Set the parent @parent
      */
-    void setParent( GeoNode *parent );
+    void setParent(GeoDataExtendedData *parent);
 
     /*
      * @brief Get the parent
      */
-    const GeoNode *parent() const;
-    GeoNode *parent();
+    const GeoDataExtendedData *parent() const;
+    GeoDataExtendedData *parent();
 
     /*
      * @brief Provides information for downcasting a GeoNode
      */
     const char* nodeType() const override;
 
     /*
      * @brief Serialize SchemaData to a stream @p stream
      */
     virtual void pack( QDataStream& stream ) const;
 
     /*
      * @brief Unserialize SchemaData from a stream @p stream
      */
     virtual void unpack( QDataStream& stream );
 
 private:
     GeoDataSchemaDataPrivate * const d;
 };
 
 }   // namespace Marble
 
 #endif  // MARBLE_GEODATASCHEMADATA_H
diff --git a/src/lib/marble/geodata/handlers/kml/KmlSimpleArrayDataTagHandler.cpp b/src/lib/marble/geodata/handlers/kml/KmlSimpleArrayDataTagHandler.cpp
index 4abfa620a..d46544db3 100644
--- a/src/lib/marble/geodata/handlers/kml/KmlSimpleArrayDataTagHandler.cpp
+++ b/src/lib/marble/geodata/handlers/kml/KmlSimpleArrayDataTagHandler.cpp
@@ -1,58 +1,56 @@
 //
 // This file is part of the Marble Virtual Globe.
 //
 // This program is free software licensed under the GNU LGPL. You can
 // find a copy of this license in LICENSE.txt in the top directory of
 // the source code.
 //
 // Copyright 2011 Niko Sams <niko.sams@gmail.com>
 //
 
 #include "KmlSimpleArrayDataTagHandler.h"
 
 #include "MarbleDebug.h"
 
 #include "KmlElementDictionary.h"
 
 #include "GeoDataExtendedData.h"
 #include "GeoDataSimpleArrayData.h"
 #include "GeoDataSchemaData.h"
 #include "GeoDataTypes.h"
 
 #include "GeoParser.h"
 #include "GeoDocument.h"
 
 namespace Marble
 {
 namespace kml
 {
 KML_DEFINE_TAG_HANDLER_GX22( SimpleArrayData )
 
 GeoNode* KmlSimpleArrayDataTagHandler::parse( GeoParser& parser ) const
 {
     Q_ASSERT(parser.isStartElement() && parser.isValidElement(QLatin1String(kmlTag_SimpleArrayData)));
 
     GeoStackItem parentItem = parser.parentElement();
 
     if ( parentItem.is<GeoDataExtendedData>() ) {
         GeoDataSimpleArrayData *arrayData = new GeoDataSimpleArrayData();
         QString name = parser.attribute( "name" ).trimmed();
         parentItem.nodeAs<GeoDataExtendedData>()->setSimpleArrayData( name, arrayData );
         return arrayData;
     }
 
     if ( parentItem.is<GeoDataSchemaData>() ) {
-        GeoNode *parent = parentItem.nodeAs<GeoDataSchemaData>()->parent();
-        if (GeoDataExtendedData *extendedData = geodata_cast<GeoDataExtendedData>(parent)) {
-            GeoDataSimpleArrayData *arrayData = new GeoDataSimpleArrayData;
-            const QString name = parser.attribute("name").trimmed();
-            extendedData->setSimpleArrayData(name, arrayData);
-            return arrayData;
-        }
+        GeoDataExtendedData *extendedData = parentItem.nodeAs<GeoDataSchemaData>()->parent();
+        GeoDataSimpleArrayData *arrayData = new GeoDataSimpleArrayData;
+        const QString name = parser.attribute("name").trimmed();
+        extendedData->setSimpleArrayData(name, arrayData);
+        return arrayData;
     }
 
     return nullptr;
 }
 
 }
 }