Group fixes

src/App/Document.h

@@ -230,7 +230,8 @@ class AppExport Document : public App::PropertyContainer
     /// Returns a list of all Objects
     std::vector<DocumentObject*> getObjects() const;
     std::vector<DocumentObject*> getObjectsOfType(const Base::Type& typeId) const;
-    std::vector<DocumentObject*> getObjectsWithExtension(const Base::Type& typeId) const;
+    /// Returns all object with given extensions. If derived=true also all objects with extenions derived from the given one
+    std::vector<DocumentObject*> getObjectsWithExtension(const Base::Type& typeId, bool derived = true) const;
     std::vector<DocumentObject*> findObjects(const Base::Type& typeId, const char* objname) const;
     /// Returns an array with the correct types already.
     template<typename T> inline std::vector<T*> getObjectsOfType() const;
@@ -305,6 +306,8 @@ class AppExport Document : public App::PropertyContainer
     std::vector<std::string> getAvailableRedoNames() const;
     /// Will REDO  one step, returns  False if no redo was done (Redos == 0).
     bool redo() ;
+    /// returns true if the document is in an Transaction phase, e.g. currently performing a redo/undo or rollback
+    bool performsTransactionOperation();
     //@}
 
     /** @name dependency stuff */

src/App/DocumentObject.cpp

@@ -422,10 +422,12 @@ void DocumentObject::onChanged(const Property* prop)
     if (prop == &Label && _pDoc && oldLabel != Label.getStrValue())
         _pDoc->signalRelabelObject(*this);
 
-    if (prop->getType() & Prop_Output)
-        return;
-    // set object touched
-    StatusBits.set(ObjectStatus::Touch);
+    // set object touched if it is a input ptoperty
+    if (!(prop->getType() & Prop_Output))
+        StatusBits.set(0);
+
+    //call the parent for appropriate handling
+    TransactionalObject::onChanged(prop);
 }
 
 PyObject *DocumentObject::getPyObject(void)

src/App/DocumentObjectPy.xml

@@ -55,6 +55,20 @@
                 <UserDocu>Recomputes this object</UserDocu>
             </Documentation>
         </Methode>
+        <Methode Name="getParentGroup">
+            <Documentation>
+                <UserDocu>Returns the group the object is in or None if it is not part of a group. 
+                          Note that an object can only be in a single group, hence only a single return 
+                          value.</UserDocu>
+            </Documentation>
+        </Methode>
+        <Methode Name="getParentGeoFeatureGroup">
+            <Documentation>
+                <UserDocu>Returns the GeoFeatureGroup, and hence the local coorinate system, the object 
+                          is in or None if it is not part of a group. Note that an object can only be 
+                          in a single group, hence only a single return value.</UserDocu>
+            </Documentation>
+        </Methode>
     <Attribute Name="OutList" ReadOnly="true">
       <Documentation>
         <UserDocu>A list of all objects this object links to.</UserDocu>

src/App/DocumentObjectPyImp.cpp

@@ -25,6 +25,8 @@
 #include "DocumentObject.h"
 #include "Document.h"
 #include "Expression.h"
+#include "GroupExtension.h"
+#include "GeoFeatureGroupExtension.h"
 
 // inclusion of the generated files (generated out of DocumentObjectPy.xml)
 #include <App/DocumentObjectPy.h>
@@ -315,6 +317,42 @@ PyObject*  DocumentObjectPy::recompute(PyObject *args)
     }
 }
 
+PyObject*  DocumentObjectPy::getParentGroup(PyObject *args)
+{
+    if (!PyArg_ParseTuple(args, ""))
+        return NULL;
+
+    try {
+        auto grp = GroupExtension::getGroupOfObject(getDocumentObjectPtr());
+        if(!grp) {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+        return grp->getPyObject();
+    }
+    catch (const Base::Exception& e) {
+        throw Py::RuntimeError(e.what());
+    }
+}
+
+PyObject*  DocumentObjectPy::getParentGeoFeatureGroup(PyObject *args)
+{
+    if (!PyArg_ParseTuple(args, ""))
+        return NULL;
+
+    try {
+        auto grp = GeoFeatureGroupExtension::getGroupOfObject(getDocumentObjectPtr());
+        if(!grp) {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+        return grp->getPyObject();
+    }
+    catch (const Base::Exception& e) {
+        throw Py::RuntimeError(e.what());
+    }
+}
+
 PyObject *DocumentObjectPy::getCustomAttributes(const char* attr) const
 {
     // search for dynamic property

src/App/ExtensionContainer.cpp

@@ -68,19 +68,19 @@ void ExtensionContainer::registerExtension(Base::Type extension, Extension* ext)
     _extensions[extension] = ext;
 }
 
-bool ExtensionContainer::hasExtension(Base::Type t) const {
+bool ExtensionContainer::hasExtension(Base::Type t, bool derived) const {
 
     //check for the exact type
     bool found = _extensions.find(t) != _extensions.end();
-    if(!found) {
+    if(!found && derived) {
         //and for types derived from it, as they can be cast to the extension
         for(auto entry : _extensions) {            
             if(entry.first.isDerivedFrom(t))
                 return true;
         }
         return false;
     }
-    return true;
+    return found;
 }
 
 bool ExtensionContainer::hasExtension(const std::string& name) const {
@@ -94,10 +94,10 @@ bool ExtensionContainer::hasExtension(const std::string& name) const {
 }
 
 
-Extension* ExtensionContainer::getExtension(Base::Type t) {
+Extension* ExtensionContainer::getExtension(Base::Type t, bool derived) const {
 
     auto result = _extensions.find(t);
-    if(result == _extensions.end()) {
+    if((result == _extensions.end()) && derived) {
         //we need to check for derived types
         for(auto entry : _extensions) {            
             if(entry.first.isDerivedFrom(t))
@@ -115,7 +115,7 @@ bool ExtensionContainer::hasExtensions() const {
     return !_extensions.empty();
 }
 
-Extension* ExtensionContainer::getExtension(const std::string& name) {
+Extension* ExtensionContainer::getExtension(const std::string& name) const {
 
     //and for types derived from it, as they can be cast to the extension
     for(auto entry : _extensions) {            

src/App/ExtensionContainer.h

@@ -124,15 +124,15 @@ class AppExport ExtensionContainer : public App::PropertyContainer
     virtual ~ExtensionContainer();
 
     void registerExtension(Base::Type extension, App::Extension* ext);
-    bool hasExtension(Base::Type) const; //returns first of type (or derived from) and throws otherwise
+    bool hasExtension(Base::Type, bool derived=true) const; //returns first of type (or derived from if set to true) and throws otherwise
     bool hasExtension(const std::string& name) const; //this version does not check derived classes
     bool hasExtensions() const;
-    App::Extension* getExtension(Base::Type);  //returns first of type (or derived from) and throws otherwise
-    App::Extension* getExtension(const std::string& name); //this version does not check derived classes
+    App::Extension* getExtension(Base::Type, bool derived = true) const; 
+    App::Extension* getExtension(const std::string& name) const; //this version does not check derived classes
 
     //returns first of type (or derived from) and throws otherwise
     template<typename ExtensionT>
-    ExtensionT* getExtensionByType() {
+    ExtensionT* getExtensionByType() const {
         return dynamic_cast<ExtensionT*>(getExtension(ExtensionT::getExtensionClassTypeId()));
     };
 

src/App/GeoFeature.cpp

@@ -27,6 +27,7 @@
 #endif
 
 #include "GeoFeature.h"
+#include "GeoFeatureGroupExtension.h"
 #include <App/GeoFeaturePy.h>
 
 using namespace App;
@@ -55,6 +56,16 @@ void GeoFeature::transformPlacement(const Base::Placement &transform)
     this->Placement.setValue(plm);
 }
 
+Base::Placement GeoFeature::globalPlacement()
+{
+    auto* group = GeoFeatureGroupExtension::getGroupOfObject(this);
+    if(group) {
+        auto ext = group->getExtensionByType<GeoFeatureGroupExtension>();
+        return ext->globalGroupPlacement() * Placement.getValue();
+    }
+    return Placement.getValue();    
+}
+
 const PropertyComplexGeoData* GeoFeature::getPropertyOfGeometry() const
 {
     return nullptr;

src/App/GeoFeature.h

@@ -66,6 +66,20 @@ class AppExport GeoFeature : public App::DocumentObject
      * @return the Python binding object
      */
     virtual PyObject* getPyObject(void);
+
+    /**
+     * @brief Calculates the placement in the global reference coordinate system
+     * 
+     * In FreeCAD the GeoFeature placement describes the local placement of the object in its parent
+     * coordinate system. This is however not always the same as the global reference system. If the
+     * object is in a GeoFeatureGroup, hence in annother local coordinate system, the Placement 
+     * property does only give the local transformation. This function can be used to calculate the 
+     * placement of the object in the global reference coordinate system taking all stacked local 
+     * system into account.
+     * 
+     * @return Base::Placement The transformation from the global reference coordinate system
+     */
+    Base::Placement globalPlacement();
 };
 
 } //namespace App