Extensions: Introduce classes and port App groups

src/App/DocumentObjectGroup.cpp

@@ -33,26 +33,27 @@
 
 using namespace App;
 
-PROPERTY_SOURCE(App::DocumentObjectGroup, App::DocumentObject)
+PROPERTY_SOURCE(App::GroupExtension, App::Extension)
 
-
-DocumentObjectGroup::DocumentObjectGroup()
+GroupExtension::GroupExtension()
 {
+    m_extensionType = GroupExtension::getClassTypeId();
+    
     ADD_PROPERTY_TYPE(Group,(0),"Base",(App::PropertyType)(Prop_Output),"List of referenced objects");
 }
 
-DocumentObjectGroup::~DocumentObjectGroup()
+GroupExtension::~GroupExtension()
 {
 }
 
-DocumentObject* DocumentObjectGroup::addObject(const char* sType, const char* pObjectName)
+DocumentObject* GroupExtension::addObject(const char* sType, const char* pObjectName)
 {
-    DocumentObject* obj = getDocument()->addObject(sType, pObjectName);
+    DocumentObject* obj = getExtendedObject()->getDocument()->addObject(sType, pObjectName);
     if (obj) addObject(obj);
     return obj;
 }
 
-void DocumentObjectGroup::addObject(DocumentObject* obj)
+void GroupExtension::addObject(DocumentObject* obj)
 {
     if (!hasObject(obj)) {
         std::vector<DocumentObject*> grp = Group.getValues();
@@ -61,7 +62,7 @@ void DocumentObjectGroup::addObject(DocumentObject* obj)
     }
 }
 
-void DocumentObjectGroup::removeObject(DocumentObject* obj)
+void GroupExtension::removeObject(DocumentObject* obj)
 {
     const std::vector<DocumentObject*> & grp = Group.getValues();
     std::vector<DocumentObject*> newGrp;
@@ -72,7 +73,7 @@ void DocumentObjectGroup::removeObject(DocumentObject* obj)
     }
 }
 
-void DocumentObjectGroup::removeObjectsFromDocument()
+void GroupExtension::removeObjectsFromDocument()
 {
     const std::vector<DocumentObject*> & grp = Group.getValues();
     // Use set so iterate on each linked object exactly one time (in case of multiple links to the same document)
@@ -83,34 +84,34 @@ void DocumentObjectGroup::removeObjectsFromDocument()
     }
 }
 
-void DocumentObjectGroup::removeObjectFromDocument(DocumentObject* obj)
+void GroupExtension::removeObjectFromDocument(DocumentObject* obj)
 {
     // remove all children
-    if (obj->getTypeId().isDerivedFrom(DocumentObjectGroup::getClassTypeId())) {
-        DocumentObjectGroup *grp = static_cast<DocumentObjectGroup*>(obj);
+    if (obj->hasExtension(GroupExtension::getClassTypeId())) {
+        GroupExtension *grp = static_cast<GroupExtension*>(obj->getExtension(GroupExtension::getClassTypeId()));
         // recursive call to remove all subgroups
         grp->removeObjectsFromDocument();
     }
 
-    this->getDocument()->remObject(obj->getNameInDocument());
+    getExtendedObject()->getDocument()->remObject(obj->getNameInDocument());
 }
 
-DocumentObject *DocumentObjectGroup::getObject(const char *Name) const
+DocumentObject *GroupExtension::getObject(const char *Name) const
 {
-    DocumentObject* obj = getDocument()->getObject(Name);
+    DocumentObject* obj = getExtendedObject()->getDocument()->getObject(Name);
     if (obj && hasObject(obj))
         return obj;
     return 0;
 }
 
-bool DocumentObjectGroup::hasObject(const DocumentObject* obj, bool recursive) const
+bool GroupExtension::hasObject(const DocumentObject* obj, bool recursive) const
 {
     const std::vector<DocumentObject*>& grp = Group.getValues();
     for (std::vector<DocumentObject*>::const_iterator it = grp.begin(); it != grp.end(); ++it) {
         if (*it == obj) {
             return true;
-        } else if ( recursive && (*it)->isDerivedFrom (App::DocumentObjectGroup::getTypeId()) ) {
-            App::DocumentObjectGroup *subGroup = static_cast<App::DocumentObjectGroup *> (*it);
+        } else if ( recursive && (*it)->hasExtension(GroupExtension::getClassTypeId()) ) {
+            App::GroupExtension *subGroup = static_cast<App::GroupExtension *> ((*it)->getExtension(GroupExtension::getClassTypeId()));
             if (subGroup->hasObject (obj, recursive)) {
                 return true;
             }
@@ -120,14 +121,14 @@ bool DocumentObjectGroup::hasObject(const DocumentObject* obj, bool recursive) c
     return false;
 }
 
-bool DocumentObjectGroup::isChildOf(const DocumentObjectGroup* group) const
+bool GroupExtension::isChildOf(const GroupExtension* group) const
 {
     const std::vector<DocumentObject*>& grp = group->Group.getValues();
     for (std::vector<DocumentObject*>::const_iterator it = grp.begin(); it != grp.end(); ++it) {
-        if (*it == this)
+        if (*it == getExtendedObject())
             return true;
-        if ((*it)->getTypeId().isDerivedFrom(DocumentObjectGroup::getClassTypeId())) {
-            if (this->isChildOf(static_cast<DocumentObjectGroup*>(*it)))
+        if ((*it)->hasExtension(GroupExtension::getClassTypeId())) {
+            if (this->isChildOf(static_cast<GroupExtension*>((*it)->getExtension(GroupExtension::getClassTypeId()))))
                 return true;
         }
     }
@@ -135,12 +136,12 @@ bool DocumentObjectGroup::isChildOf(const DocumentObjectGroup* group) const
     return false;
 }
 
-std::vector<DocumentObject*> DocumentObjectGroup::getObjects() const
+std::vector<DocumentObject*> GroupExtension::getObjects() const
 {
     return Group.getValues();
 }
 
-std::vector<DocumentObject*> DocumentObjectGroup::getObjectsOfType(const Base::Type& typeId) const
+std::vector<DocumentObject*> GroupExtension::getObjectsOfType(const Base::Type& typeId) const
 {
     std::vector<DocumentObject*> type;
     const std::vector<DocumentObject*>& grp = Group.getValues();
@@ -152,7 +153,7 @@ std::vector<DocumentObject*> DocumentObjectGroup::getObjectsOfType(const Base::T
     return type;
 }
 
-int DocumentObjectGroup::countObjectsOfType(const Base::Type& typeId) const
+int GroupExtension::countObjectsOfType(const Base::Type& typeId) const
 {
     int type=0;
     const std::vector<DocumentObject*>& grp = Group.getValues();
@@ -164,35 +165,42 @@ int DocumentObjectGroup::countObjectsOfType(const Base::Type& typeId) const
     return type;
 }
 
-DocumentObjectGroup* DocumentObjectGroup::getGroupOfObject(const DocumentObject* obj)
+DocumentObject* GroupExtension::getGroupOfObject(const DocumentObject* obj)
 {
     const Document* doc = obj->getDocument();
-    std::vector<DocumentObject*> grps = doc->getObjectsOfType(DocumentObjectGroup::getClassTypeId());
+    std::vector<DocumentObject*> grps = doc->getObjectsOfType(GroupExtension::getClassTypeId());
     for (std::vector<DocumentObject*>::const_iterator it = grps.begin(); it != grps.end(); ++it) {
-        DocumentObjectGroup* grp = (DocumentObjectGroup*)(*it);
+        GroupExtension* grp = (GroupExtension*)(*it);
         if (grp->hasObject(obj))
-            return grp;
+            return *it;
     }
 
     return 0;
 }
 
-PyObject *DocumentObjectGroup::getPyObject()
-{
-    if (PythonObject.is(Py::_None())){
-        // ref counter is set to 1
-        PythonObject = Py::Object(new DocumentObjectGroupPy(this),true);
-    }
-    return Py::new_reference_to(PythonObject);
+
+PROPERTY_SOURCE(App::DocumentObjectGroup, App::DocumentObject)
+
+DocumentObjectGroup::DocumentObjectGroup(void): DocumentObject(), GroupExtension() {
+
+    setExtendedObject(this);
 }
 
+DocumentObjectGroup::~DocumentObjectGroup() {
+
+}
+
+
+
 // Python feature ---------------------------------------------------------
 
 namespace App {
+PROPERTY_SOURCE_TEMPLATE(App::GroupExtensionPython, App::GroupExtension)
+    
 /// @cond DOXERR
 PROPERTY_SOURCE_TEMPLATE(App::DocumentObjectGroupPython, App::DocumentObjectGroup)
 template<> const char* App::DocumentObjectGroupPython::getViewProviderName(void) const {
-    return "Gui::ViewProviderDocumentObjectGroupPython";
+    return "Gui::ViewProviderGroupExtensionPython";
 }
 template<> PyObject* App::DocumentObjectGroupPython::getPyObject(void) {
     if (PythonObject.is(Py::_None())) {