Extensions: Show up in the python interface

src/App/Extension.cpp

@@ -31,29 +31,69 @@
 #include "Extension.h"
 #include "DocumentObject.h"
 #include "Base/Exception.h"
+#include <Base/Console.h>
  
-TYPESYSTEM_SOURCE(App::Extension, App::PropertyContainer);
+/* We do not use a standart property macro for type initiation. The reason is that we want to expose all property functions, 
+ * to allow the derived classes to access the private property data, but we do not want to have our
+ * property data a reference to the parent data. That is because the extension is used in  a multi 
+ * inheritance way, and hence our propertydata partent data would point to the same property data
+ * as any other parent of the inherited class. It makes more sense to create a total unrelated line
+ * of property datas which are added as additional parent to the extended class.
+ */
+TYPESYSTEM_SOURCE_P(App::Extension);
+const App::PropertyData * App::Extension::getPropertyDataPtr(void){return &propertyData;}
+const App::PropertyData & App::Extension::getPropertyData(void) const{return propertyData;}
+App::PropertyData App::Extension::propertyData;
+void App::Extension::init(void){
+  initSubclass(App::Extension::classTypeId, "App::Extension" , "App::PropertyContainer", &(App::Extension::create) );
+}
 
 using namespace App;
 
-//**************************************************************************
-// Construction/Destruction
-
-// here the implemataion! description should take place in the header file!
-Extension::Extension() {}
+Extension::Extension() 
+{
+    
+}
 
 Extension::~Extension()
 {
 
 }
 
-void Extension::setExtendedObject(DocumentObject* obj) {
+void Extension::initExtension(Base::Type type) {
 
+    m_extensionType = type;
+    if(m_extensionType.isBad())
+        throw Base::Exception("Extension: Extension type not set");
+}
+
+void Extension::initExtension(DocumentObject* obj) {
+
+    if(m_extensionType.isBad())
+        throw Base::Exception("Extension: Extension type not set");
+ 
+    m_base = obj;
+    m_base->registerExtension( m_extensionType, this );
+}
+
+
+PyObject* Extension::getExtensionPyObject(void) {
+
+    return nullptr;
+}
+
+const char* Extension::name() {
+    
     if(m_extensionType.isBad())
         throw Base::Exception("Extension::setExtendedObject: Extension type not set");
     
-    m_base = obj;
-    obj->registerExtension( m_extensionType, this );
+    std::string temp(m_extensionType.getName());
+    std::string::size_type pos = temp.find_last_of(":");
+
+    if(pos != std::string::npos)
+        return temp.substr(pos+1).c_str();
+    else
+        return std::string().c_str();
 }
 
 
@@ -70,12 +110,19 @@ ExtensionContainer::~ExtensionContainer() {
 
 void ExtensionContainer::registerExtension(Base::Type extension, Extension* ext) {
 
-    if(hasExtension(extension))
-        throw Base::Exception("ExtensionContainer::registerExtension: Such a extension is already registered");
-    
     if(ext->getExtendedObject() != this)
         throw Base::Exception("ExtensionContainer::registerExtension: Extension has not this as base object");
-    
+       
+    //no duplicate extensions (including base classes)
+    if(hasExtension(extension)) {
+        for(auto entry : _extensions) {            
+            if(entry.first == extension || entry.first.isDerivedFrom(extension)) {
+                _extensions.erase(entry.first);
+                break;
+            }
+        }
+    }
+        
     _extensions[extension] = ext;
 }
 
@@ -94,6 +141,17 @@ bool ExtensionContainer::hasExtension(Base::Type t) const {
     return true;
 }
 
+bool ExtensionContainer::hasExtension(const char* name) const {
+
+    //and for types derived from it, as they can be cast to the extension
+    for(auto entry : _extensions) {            
+        if(strcmp(entry.second->name(), name) == 0)
+            return true;
+    }
+    return false;
+}
+
+
 Extension* ExtensionContainer::getExtension(Base::Type t) {
    
     auto result = _extensions.find(t);
@@ -109,3 +167,13 @@ Extension* ExtensionContainer::getExtension(Base::Type t) {
     
     return result->second;
 }
+
+Extension* ExtensionContainer::getExtension(const char* name) {
+
+    //and for types derived from it, as they can be cast to the extension
+    for(auto entry : _extensions) {            
+        if(strcmp(entry.second->name(), name) == 0)
+            return entry.second;
+    }
+    return nullptr;
+}