Template group manager

src/Core/Geom/CommandCreateGeom.cpp

@@ -10,10 +10,6 @@
 #include "Geom/Vertex.h"
 #include "Geom/GeomSplitImplementation.h"
 #include "Group/GroupManager.h"
-#include "Group/Group3D.h"
-#include "Group/Group2D.h"
-#include "Group/Group1D.h"
-#include "Group/Group0D.h"
 /*----------------------------------------------------------------------------*/
 #include <TkUtil/TraceLog.h>
 #include <TkUtil/UTF8String.h>

src/Core/Geom/CommandEditGeom.cpp

@@ -10,10 +10,7 @@
 #include "Geom/Curve.h"
 #include "Geom/Vertex.h"
 #include "Group/GroupManager.h"
-#include "Group/Group3D.h"
-#include "Group/Group2D.h"
-#include "Group/Group1D.h"
-#include "Group/Group0D.h"
+#include "Group/GroupEntity.h"
 /*----------------------------------------------------------------------------*/
 #include <TkUtil/TraceLog.h>
 #include <TkUtil/UTF8String.h>
@@ -73,7 +70,6 @@ void CommandEditGeom::internalExecute()
     std::vector<GeomEntity*>  mod_entities  = getKeepedEntities();
     std::vector<GeomEntity*>  mov_entities  = getMovedEntities();
     std::vector<GeomEntity*>& rem_entities = getRemovedEntities();
-    std::map<GeomEntity*,std::vector<GeomEntity*> >& rep_entities = getReplacedEntities();
 
     for(int i=0;i<new_entities.size();i++){
         GeomEntity* ge = new_entities[i];
@@ -106,6 +102,7 @@ void CommandEditGeom::internalExecute()
     }
 
 #ifdef _DEBUG2
+    std::map<GeomEntity*,std::vector<GeomEntity*> >& rep_entities = getReplacedEntities();
     for (std::map<GeomEntity*,std::vector<GeomEntity*> >::iterator iter1 = rep_entities.begin();
     		iter1!=rep_entities.end(); ++iter1){
     	std::cerr<<"Remplace "<<iter1->first->getName()<<" par";
@@ -166,8 +163,7 @@ void CommandEditGeom::internalUndo()
     // les entités détruites sont dites créées et inversement
     getInfoCommand().permCreatedDeleted();
 
-    // Annulation de la commande pour les entités dont l'état n'est pas mémorisé (cas des FcetedSurface)
-    internalSpecificUndo();
+    if (m_impl) m_impl->performUndo();
 
     log (TkUtil::TraceLog (message, TkUtil::Log::TRACE_1));
 }
@@ -188,8 +184,7 @@ void CommandEditGeom::internalRedo()
     // les entités détruites sont dites créées et inversement
     getInfoCommand().permCreatedDeleted();
 
-    // Rejoue la commande pour les entités dont l'état n'est pas mémorisé (cas des FcetedSurface)
-    internalSpecificRedo();
+    if (m_impl) m_impl->performRedo();
 
     startingOrcompletionLog (false);
 
@@ -211,52 +206,10 @@ saveMementos(std::map<GeomEntity*,Services::Memento> & candidates)
 /*----------------------------------------------------------------------------*/
 void CommandEditGeom::copyGroups(GeomEntity* ge1, GeomEntity* ge2)
 {
-    if (ge1->getDim() == 3 && ge2->getDim() == 3){
-    std::vector<Group::GroupEntity*> grp;
-        ge1->getGroups(grp);
-        Volume* res = dynamic_cast<Volume*>(ge2);
-        for (std::vector<Group::GroupEntity*>::iterator iter = grp.begin();
-                iter != grp.end(); ++iter){
-            Group::Group3D* grp = dynamic_cast<Group::Group3D*>(*iter);
-            if (res && grp && !res->find(grp)){
-                m_group_helper.addToGroup(grp->getName(), res);
-            }
-        }
-    }
-    else if (ge1->getDim() == 2 && ge2->getDim() == 2){
-    std::vector<Group::GroupEntity*> grp;
-        ge1->getGroups(grp);
-        Surface* res = dynamic_cast<Surface*>(ge2);
-        for (std::vector<Group::GroupEntity*>::iterator iter = grp.begin();
-                iter != grp.end(); ++iter){
-            Group::Group2D* grp = dynamic_cast<Group::Group2D*>(*iter);
-            if (res && grp && !res->find(grp)){
-                m_group_helper.addToGroup(grp->getName(), res);
-            }
-        }
-    }
-    else if (ge1->getDim() == 1 && ge2->getDim() == 1){
-    std::vector<Group::GroupEntity*> grp;
-        ge1->getGroups(grp);
-        Curve* res = dynamic_cast<Curve*>(ge2);
-        for (std::vector<Group::GroupEntity*>::iterator iter = grp.begin();
-                iter != grp.end(); ++iter){
-            Group::Group1D* grp = dynamic_cast<Group::Group1D*>(*iter);
-            if (res && grp && !res->find(grp)){
-                m_group_helper.addToGroup(grp->getName(), res);
-            }
-        }
-    }
-    else if (ge1->getDim() == 0 && ge2->getDim() == 0){
-        Vertex* res = dynamic_cast<Vertex*>(ge2);
-        for (Group::Group0D* grp : res->getGroups()) {
-            if (res && grp && !res->find(grp)){
-                m_group_helper.addToGroup(grp->getName(), res);
-            }
-        }
-    }
-    else {
-        throw TkUtil::Exception(TkUtil::UTF8String ("Copie des groupes pour une dimension non prévue", TkUtil::Charset::UTF_8));
+    Group::GroupManager& gm = getContext().getGroupManager();
+    for (Group::GroupEntity* grp : gm.getGroupsFor(ge1)) {
+        if (!gm.hasGroupFor(ge2, grp))
+            m_group_helper.addToGroup(grp->getName(), ge2);
     }
 }
 /*----------------------------------------------------------------------------*/

src/Core/Geom/CommandExtrudeDirection.cpp

@@ -6,7 +6,6 @@
 #include "Geom/Surface.h"
 #include "Geom/Curve.h"
 #include "Geom/Vertex.h"
-#include "Group/Group3D.h"
 /*----------------------------------------------------------------------------*/
 #include <TkUtil/Exception.h>
 #include <TkUtil/ReferencedMutex.h>

src/Core/Geom/CommandExtrudeRevolution.cpp

@@ -4,8 +4,6 @@
 #include "Geom/GeomRevolImplementation.h"
 #include "Geom/Curve.h"
 #include "Geom/Vertex.h"
-#include "Group/Group3D.h"
-#include "Group/Group1D.h"
 #include "Group/GroupManager.h"
 #include "Utils/Rotation.h"
 /*----------------------------------------------------------------------------*/

src/Core/Geom/CommandExtrusion.cpp

@@ -5,10 +5,7 @@
 #include "Geom/Surface.h"
 #include "Geom/Curve.h"
 #include "Geom/Vertex.h"
-#include "Group/Group3D.h"
-#include "Group/Group2D.h"
-#include "Group/Group1D.h"
-#include "Group/Group0D.h"
+#include "Group/GroupEntity.h"
 #include "Group/GroupManager.h"
 /*----------------------------------------------------------------------------*/
 #include <TkUtil/MemoryError.h>
@@ -154,54 +151,48 @@ groups2DTo3D()
     // Les nouveaux objets ont été mis "hors groupe" à la création
     // On se sert de la correspondance entre les entités initiales et finales
     // pour transmetre les groupes de la dimension N à la dimension N+1
+    Group::GroupManager& gm = getContext().getGroupManager();
 
-    for (std::map<Geom::Surface*,Geom::Volume*>::iterator iter = m_s2v.begin();
+    for (std::map<Geom::Surface*, Geom::Volume*>::iterator iter = m_s2v.begin();
             iter != m_s2v.end(); ++iter){
         Geom::Surface* surf = iter->first;
         Geom::Volume*  vol  = iter->second;
         if (vol){
-        	std::vector<Group::GroupEntity*> grp;
-            surf->getGroups(grp);
-
-            for (uint i=0; i<grp.size(); i++){
-                std::string nom = grp[i]->getName();
-                if (nom != getContext().getGroupManager().getDefaultName(2)) {
-                    Group::Group3D* new_grp = m_group_helper.addToGroup(nom, vol);
-                    new_grp->setLevel(grp[i]->getLevel());
+            for (Group::GroupEntity* grp : gm.getGroupsFor(surf)) {
+                std::string nom = grp->getName();
+                if (nom != gm.getDefaultName(2)) {
+                    Group::GroupEntity* new_grp = m_group_helper.addToGroup(nom, vol);
+                    new_grp->setLevel(grp->getLevel());
                 }
             }
         }
     }
 
-    for (std::map<Geom::Curve*  ,Geom::Surface*>::iterator iter = m_c2s.begin();
+    for (std::map<Geom::Curve*, Geom::Surface*>::iterator iter = m_c2s.begin();
             iter != m_c2s.end(); ++iter){
         Geom::Curve*    curve = iter->first;
         Geom::Surface*  surf  = iter->second;
         if (surf){
-            std::vector<Group::GroupEntity*> grp;
-            curve->getGroups(grp);
-            for (uint i=0; i<grp.size(); i++){
-            	std::string nom = grp[i]->getName();
-            	if (nom != getContext().getGroupManager().getDefaultName(1)) {
-                    Group::Group2D* new_grp = m_group_helper.addToGroup(nom, surf);
-                    new_grp->setLevel(grp[i]->getLevel());
+            for (Group::GroupEntity* grp : gm.getGroupsFor(curve)) {
+            	std::string nom = grp->getName();
+            	if (nom != gm.getDefaultName(1)) {
+                    Group::GroupEntity* new_grp = m_group_helper.addToGroup(nom, surf);
+                    new_grp->setLevel(grp->getLevel());
                 }
             }
         }
     }
 
-    for (std::map<Geom::Vertex* ,Geom::Curve*>::iterator iter = m_v2c.begin();
+    for (std::map<Geom::Vertex*, Geom::Curve*>::iterator iter = m_v2c.begin();
             iter != m_v2c.end(); ++iter){
         Geom::Vertex*  vtx  = iter->first;
         Geom::Curve*  curve = iter->second;
         if (curve){
-        	std::vector<Group::GroupEntity*> grp;
-            vtx->getGroups(grp);
-            for (uint i=0; i<grp.size(); i++){
-            	std::string nom = grp[i]->getName();
-            	if (nom != getContext().getGroupManager().getDefaultName(0)) {
-                    Group::Group1D* new_grp = m_group_helper.addToGroup(nom, curve);
-                    new_grp->setLevel(grp[i]->getLevel());
+            for (Group::GroupEntity* grp : gm.getGroupsFor(vtx)) {
+            	std::string nom = grp->getName();
+            	if (nom != gm.getDefaultName(0)) {
+                    Group::GroupEntity* new_grp = m_group_helper.addToGroup(nom, curve);
+                    new_grp->setLevel(grp->getLevel());
                 }
             }
         }
@@ -213,17 +204,17 @@ void CommandExtrusion::prefixGroupsName(const std::string& pre,
         std::map<Geom::Curve*  ,Geom::Curve*>&   c2c,
         std::map<Geom::Surface*,Geom::Surface*>& s2s)
 {
+    Group::GroupManager& gm = getContext().getGroupManager();
+
     // le groupe commun pour toutes les surfaces
     for (std::map<Geom::Surface*,Geom::Surface*>::iterator iter = s2s.begin();
             iter != s2s.end(); ++iter){
         Geom::Surface* surf1 = iter->first;
         Geom::Surface* surf2 = iter->second;
 
         if (surf2){
-            std::vector<std::string> gn;
-            surf1->getGroupsName(gn);
-            for (uint i=0; i<gn.size(); i++){
-                std::string& nom = gn[i];
+            for (Group::GroupEntity* grp : gm.getGroupsFor(surf1)) {
+                std::string nom = grp->getName();
                 m_group_helper.addToGroup(pre + "_" + nom, surf2);
             }
 
@@ -238,10 +229,8 @@ void CommandExtrusion::prefixGroupsName(const std::string& pre,
         Geom::Curve* crv2 = iter->second;
 
         if (crv2){
-            std::vector<std::string> gn;
-            crv1->getGroupsName(gn);
-            for (uint i=0; i<gn.size(); i++){
-                std::string& nom = gn[i];
+            for (Group::GroupEntity* grp : gm.getGroupsFor(crv1)) {
+                std::string nom = grp->getName();
                 m_group_helper.addToGroup(pre + "_" + nom, crv2);
             }
         }
@@ -253,10 +242,8 @@ void CommandExtrusion::prefixGroupsName(const std::string& pre,
         Geom::Vertex* vtx2 = iter->second;
 
         if (vtx2){
-            std::vector<std::string> gn;
-            vtx1->getGroupsName(gn);
-            for (uint i=0; i<gn.size(); i++){
-                std::string& nom = gn[i];
+            for (Group::GroupEntity* grp : gm.getGroupsFor(vtx1)) {
+                std::string nom = grp->getName();
                 m_group_helper.addToGroup(pre + "_" + nom, vtx2);
             }
         }

src/Core/Geom/CommandJoinCurves.cpp

@@ -4,7 +4,7 @@
 #include "Geom/Curve.h"
 #include "Geom/Surface.h"
 #include "Geom/CommandJoinCurves.h"
-#include "Group/Group1D.h"
+#include "Group/GroupEntity.h"
 /*----------------------------------------------------------------------------*/
 #include <TkUtil/Exception.h>
 #include <TkUtil/UTF8String.h>
@@ -142,10 +142,9 @@ internalSpecificExecute()
 	m_newEntities.push_back(newCurve);
 
 	// reprise des groupes de la première courbe
-	std::vector<Group::GroupEntity*> grp;
-	m_entities[0]->getGroups(grp);
-	for (uint i=0; i<grp.size(); i++){
-		m_group_helper.addToGroup(grp[i]->getName(), newCurve);
+	Group::GroupManager& gm = getContext().getGroupManager();
+	for (Group::GroupEntity* grp : gm.getGroupsFor(m_entities[0])) {
+		m_group_helper.addToGroup(grp->getName(), newCurve);
 	}
 
 	// destruction des anciennes courbes

src/Core/Geom/CommandJoinSurfaces.cpp

@@ -4,7 +4,7 @@
 #include "Geom/Surface.h"
 #include "Geom/Volume.h"
 #include "Geom/CommandJoinSurfaces.h"
-#include "Group/Group2D.h"
+#include "Group/GroupEntity.h"
 /*----------------------------------------------------------------------------*/
 #include <TkUtil/Exception.h>
 #include <TkUtil/UTF8String.h>
@@ -107,10 +107,9 @@ void CommandJoinSurfaces::internalSpecificExecute()
 	m_newEntities.push_back(newSurface);
 
 	// reprise des groupes de la première surface
-	std::vector<Group::GroupEntity*> grp;
-	m_entities[0]->getGroups(grp);
-	for (uint i=0; i<grp.size(); i++){
-		m_group_helper.addToGroup(grp[i]->getName(), newSurface);
+	Group::GroupManager& gm = getContext().getGroupManager();
+	for (Group::GroupEntity* grp : gm.getGroupsFor(m_entities[0])) {
+		m_group_helper.addToGroup(grp->getName(), newSurface);
 	}
 
 	// destruction des anciennes surfaces

src/Core/Geom/CommandMirroring.cpp

@@ -51,16 +51,6 @@ void CommandMirroring::internalSpecificPreExecute() {
 	m_impl->prePerform();
 }
 /*----------------------------------------------------------------------------*/
-void CommandMirroring::internalSpecificUndo()
-{
-    m_impl->performUndo();
-}
-/*----------------------------------------------------------------------------*/
-void CommandMirroring::internalSpecificRedo()
-{
-    m_impl->performRedo();
-}
-/*----------------------------------------------------------------------------*/
 } // end namespace Geom
 /*----------------------------------------------------------------------------*/
 } // end namespace Mgx3D

src/Core/Geom/CommandNewArcCircleWithAngles.cpp

@@ -1,6 +1,7 @@
 /*----------------------------------------------------------------------------*/
 #include "Geom/CommandNewArcCircleWithAngles.h"
 #include "Geom/EntityFactory.h"
+#include "SysCoord/SysCoord.h"
 /*----------------------------------------------------------------------------*/
 #include <TkUtil/TraceLog.h>
 #include <TkUtil/UTF8String.h>

src/Core/Geom/CommandRemove.cpp

@@ -33,12 +33,12 @@ CommandRemove::~CommandRemove()
     if(m_impl)
         delete m_impl;
 }
-
 /*----------------------------------------------------------------------------*/
 void CommandRemove::internalSpecificPreExecute()
 {
     m_impl->prePerform();
-}/*----------------------------------------------------------------------------*/
+}
+/*----------------------------------------------------------------------------*/
 void CommandRemove::
 internalSpecificExecute()
 {

src/Core/Geom/CommandRotation.cpp

@@ -83,16 +83,6 @@ void CommandRotation::internalSpecificPreExecute()
     m_impl->prePerform();
 }
 /*----------------------------------------------------------------------------*/
-void CommandRotation::internalSpecificUndo()
-{
-    m_impl->performUndo();
-}
-/*----------------------------------------------------------------------------*/
-void CommandRotation::internalSpecificRedo()
-{
-    m_impl->performRedo();
-}
-/*----------------------------------------------------------------------------*/
 } // end namespace Geom
 /*----------------------------------------------------------------------------*/
 } // end namespace Mgx3D

src/Core/Geom/CommandScaling.cpp

@@ -173,16 +173,6 @@ void CommandScaling::internalSpecificPreExecute() {
 	m_impl->prePerform();
 }
 /*----------------------------------------------------------------------------*/
-void CommandScaling::internalSpecificUndo()
-{
-    m_impl->performUndo();
-}
-/*----------------------------------------------------------------------------*/
-void CommandScaling::internalSpecificRedo()
-{
-    m_impl->performRedo();
-}
-/*----------------------------------------------------------------------------*/
 } // end namespace Geom
 /*----------------------------------------------------------------------------*/
 } // end namespace Mgx3D

src/Core/Geom/CommandSectionByPlane.cpp

@@ -6,10 +6,7 @@
 #include "Geom/Curve.h"
 #include "Geom/Vertex.h"
 #include "Group/GroupManager.h"
-#include "Group/Group3D.h"
-#include "Group/Group2D.h"
-#include "Group/Group1D.h"
-#include "Group/Group0D.h"
+#include "Group/GroupEntity.h"
 /*----------------------------------------------------------------------------*/
 #include <TkUtil/Exception.h>
 #include <TkUtil/ReferencedMutex.h>