//***************************************************************************** //* _zModif.hpp * //***************************************************************************** //* * //* This file contains the definitions of the modif classes * //* * //***************************************************************************** //* Author : Alexis Vaisse * //***************************************************************************** // "standard" include #include "stdafx.h" #include "ACP_Base.h" #include "TFA.h" // Family dll include #include "..\Main\Inc\_EditID.h" #include "ITF.h" // personal include #include "_zModif.hpp" #include "_zObject.hpp" #include "_zInterf.hpp" #include "_zWList1.hpp" #include "_zWList2.hpp" #include "_zWEdit.hpp" #include "OGD.h" // 3dGeom dll include #include "OAC.h" // Actors dll include //----------------------------------------------------------------------------- // class ZDx_Modif - constructor //----------------------------------------------------------------------------- ZDx_Modif::ZDx_Modif (ZDx_Object * _pZDxObject , char * ModifName) : CPA_Modif (0 , ModifName , FALSE) { m_BackupName = NULL; m_pBackupData = NULL; m_bIsDoingUndo = FALSE; SetZDxObject (_pZDxObject); m_bFirstTime = TRUE; } //----------------------------------------------------------------------------- // class ZDx_Modif - destructor //----------------------------------------------------------------------------- ZDx_Modif::~ZDx_Modif () { if (m_BackupName) free (m_BackupName); if (m_pBackupData) delete m_pBackupData; } //----------------------------------------------------------------------------- // class ZDx_Modif - BackupSphereData // Make a copy of all the parameters of a sphere ZDx object //----------------------------------------------------------------------------- void ZDx_Modif::BackupSphereData () { tdstBackupDataForSphere * pBackupData = new tdstBackupDataForSphere; //ROMTEAM WorldEditor (Cristi Petrescu 12/97) Sphere3D * pSphere = (Sphere3D *)((ZDx_Shape *) m_pZDxObject -> GetZDxShape ()) -> GetGeometric3dObject (); pBackupData -> stCenter = pSphere -> GetCenter (); pBackupData -> Radius = pSphere -> GetRadius (); //ENDROMTEAM WorldEditor (Cristi Petrescu) m_pBackupData = pBackupData; } //----------------------------------------------------------------------------- // class ZDx_Modif - BackupBoxData // Make a copy of all the parameters of a box ZDx object //----------------------------------------------------------------------------- void ZDx_Modif::BackupBoxData () { tdstBackupDataForBox * pBackupData = new tdstBackupDataForBox; //ROMTEAM WorldEditor (Cristi Petrescu 12/97) Box3D * pBox = (Box3D *)((ZDx_Shape *) m_pZDxObject -> GetZDxShape ()) -> GetGeometric3dObject (); pBackupData -> stMinPoint = pBox -> GetMinPoint (); pBackupData -> stMaxPoint = pBox -> GetMaxPoint (); //ENDROMTEAM WorldEditor (Cristi Petrescu) m_pBackupData = pBackupData; } //----------------------------------------------------------------------------- // class ZDx_Modif - BackupPointData // Make a copy of all the parameters of a point ZDx object //----------------------------------------------------------------------------- void ZDx_Modif::BackupPointData () { tdstBackupDataForPoint * pBackupData = new tdstBackupDataForPoint; //ROMTEAM WorldEditor (Cristi Petrescu 12/97) Point3D * pPoint = (Point3D *)((ZDx_Point *) m_pZDxObject -> GetZDxShape ()) -> GetGeometric3dObject (); pBackupData -> stPoint = pPoint -> GetPoint (); //ENDROMTEAM WorldEditor (Cristi Petrescu) m_pBackupData = pBackupData; } //----------------------------------------------------------------------------- // class ZDx_Modif - BackupConeData // Make a copy of all the parameters of a cone ZDx object //----------------------------------------------------------------------------- void ZDx_Modif::BackupConeData () { tdstBackupDataForCone * pBackupData = new tdstBackupDataForCone; //ROMTEAM WorldEditor (Cristi Petrescu 12/97) Cone3D * pCone = (Cone3D *)((ZDx_Shape *) m_pZDxObject -> GetZDxShape ()) -> GetGeometric3dObject (); pBackupData -> stTopPoint = pCone -> GetTopPoint (); pBackupData -> stBasePoint = pCone -> GetBasePoint (); pBackupData -> Radius = pCone -> GetRadius (); //ENDROMTEAM WorldEditor (Cristi Petrescu) m_pBackupData = pBackupData; } //----------------------------------------------------------------------------- // class ZDx_Modif - Set_ZDx_Object // set the ZDx object which will be modified and make a copy of its // actual parameters for the Undo //----------------------------------------------------------------------------- void ZDx_Modif::SetZDxObject (ZDx_Object * _pZDxObject) { if (m_bIsDoingUndo) return; m_pZDxObject = _pZDxObject; // we keep a pointer to the ZDx object which will be modified if (m_BackupName) free (m_BackupName); m_BackupName = strdup (_pZDxObject -> GetZDxName ()); // we make a copy of the ZDx name if (m_pBackupData) delete (m_pBackupData); switch (_pZDxObject -> GetZDxGeometricType ()) // we make a copy of the data, depending of the type of the ZDx { case eSphere : BackupSphereData (); break; case eBox : BackupBoxData (); break; case ePoint : BackupPointData (); break; case eCone : BackupConeData (); break; default : ASSERT (0); break; } } //----------------------------------------------------------------------------- // class ZDx_Modif - ExchangeBackupSphereData // exchange the actual and backuped data for a ZDx of type sphere //----------------------------------------------------------------------------- void ZDx_Modif::ExchangeBackupSphereData () { //ROMTEAM WorldEditor (Cristi Petrescu 12/97) Sphere3D * pSphere = (Sphere3D *)((ZDx_Shape *) m_pZDxObject -> GetZDxShape ()) -> GetGeometric3dObject (); //ENDROMTEAM WorldEditor (Cristi Petrescu) tdstBackupDataForSphere * pBackupData = (tdstBackupDataForSphere *) m_pBackupData; // exchange the center MTH3D_tdstVector Center = pSphere -> GetCenter (); //ROMTEAM WorldEditor (Cristi Petrescu 12/97) pSphere -> SetCenter (& pBackupData -> stCenter); //ENDROMTEAM WorldEditor (Cristi Petrescu) pBackupData -> stCenter = Center; // exchange the radius GLI_tdxValue Radius = pSphere -> GetRadius (); //ROMTEAM WorldEditor (Cristi Petrescu 12/97) pSphere -> SetRadius (& pBackupData -> Radius); //ENDROMTEAM WorldEditor (Cristi Petrescu) pBackupData -> Radius = Radius; } //----------------------------------------------------------------------------- // class ZDx_Modif - ExchangeBackupBoxData // exchange the actual and backuped data for a ZDx of type box //----------------------------------------------------------------------------- void ZDx_Modif::ExchangeBackupBoxData () { //ROMTEAM WorldEditor (Cristi Petrescu 12/97) Box3D * pBox = (Box3D *)((ZDx_Shape *) m_pZDxObject -> GetZDxShape ()) -> GetGeometric3dObject (); //ENDROMTEAM WorldEditor (Cristi Petrescu) tdstBackupDataForBox * pBackupData = (tdstBackupDataForBox *) m_pBackupData; // exchange the min and the max point MTH3D_tdstVector MinPoint = pBox -> GetMinPoint (); MTH3D_tdstVector MaxPoint = pBox -> GetMaxPoint (); MTH3D_tdstVector Dummy = pBackupData -> stMinPoint; pBox -> SetMinPoint (& Dummy); Dummy = pBackupData -> stMaxPoint; pBox -> SetMaxPoint (& Dummy); Dummy = pBackupData -> stMinPoint; pBox -> SetMinPoint (& Dummy); pBackupData -> stMinPoint = MinPoint; pBackupData -> stMaxPoint = MaxPoint; } //----------------------------------------------------------------------------- // class ZDx_Modif - ExchangeBackupPointData // exchange the actual and backuped data for a ZDx of type point //----------------------------------------------------------------------------- void ZDx_Modif::ExchangeBackupPointData () { //ROMTEAM WorldEditor (Cristi Petrescu 12/97) Point3D * pPoint = (Point3D *)((ZDx_Point *) m_pZDxObject -> GetZDxShape ()) -> GetGeometric3dObject (); //ENDROMTEAM WorldEditor (Cristi Petrescu) tdstBackupDataForPoint * pBackupData = (tdstBackupDataForPoint *) m_pBackupData; // exchange the position of the point MTH3D_tdstVector Point = pPoint -> GetPoint (); pPoint -> SetPoint (& pBackupData -> stPoint); //ROMTEAM WorldEditor (Cristi Petrescu 12/97) // if (m_pZDxObject -> GetZDxType () == eTestPoint) // ANNECY AV CLEAN_MEC { // ((ZDx_Point *) m_pZDxObject -> GetZDxShape ()) -> UpdateTestPointPosition (); // END ANNECY AV } //ENDROMTEAM WorldEditor (Cristi Petrescu) pBackupData -> stPoint = Point; } //----------------------------------------------------------------------------- // class ZDx_Modif - ExchangeBackupConeData // exchange the actual and backuped data for a ZDx of type cone //----------------------------------------------------------------------------- void ZDx_Modif::ExchangeBackupConeData () { //ROMTEAM WorldEditor (Cristi Petrescu 12/97) Cone3D * pCone = (Cone3D *)((ZDx_Shape *) m_pZDxObject -> GetZDxShape ()) -> GetGeometric3dObject (); //ENDROMTEAM WorldEditor (Cristi Petrescu) tdstBackupDataForCone * pBackupData = (tdstBackupDataForCone *) m_pBackupData; // exchange the top and base point MTH3D_tdstVector BasePoint = pCone -> GetBasePoint (); MTH3D_tdstVector TopPoint = pCone -> GetTopPoint (); MTH3D_tdstVector Dummy = pBackupData -> stBasePoint; pCone -> SetBasePoint (& Dummy); Dummy = pBackupData -> stTopPoint; pCone -> SetTopPoint (& Dummy); Dummy = pBackupData -> stBasePoint; pCone -> SetBasePoint (& Dummy); pBackupData -> stBasePoint = BasePoint; pBackupData -> stTopPoint = TopPoint; } //----------------------------------------------------------------------------- // class ZDx_Modif - Undo // we cancel the modification by taking the previous datas which were saved // in fact, we exchange the old and the actual datas (for the Redo) //----------------------------------------------------------------------------- ZDx_Modif::Undo (BOOL _bRefreshWindow) { m_bIsDoingUndo = TRUE; ZDx_Interface * pZDxInterface = (ZDx_Interface *) m_pZDxObject -> GetEditor (); pZDxInterface -> IWillRefreshDisplay (C_lModifZDx); // we exchange old and actual ZDx names if they are different if (strcmp (m_pZDxObject -> GetZDxName () , m_BackupName) != 0) { char TempString [255]; strcpy (TempString , m_BackupName); free (m_BackupName); m_BackupName = strdup (m_pZDxObject -> GetZDxName ()); m_pZDxObject -> SetZDxName (TempString); } switch (m_pZDxObject -> GetZDxGeometricType ()) { case eSphere : ExchangeBackupSphereData (); break; case eBox : ExchangeBackupBoxData (); break; case ePoint : ExchangeBackupPointData (); break; case eCone : ExchangeBackupConeData (); break; default: ASSERT (0); break; } // Refresh the edit window if needed if (_bRefreshWindow) { /* if (m_pZDxObject -> GetZDxType () == eBoundingVolume) pZDxInterface -> GetList2Window () -> CreateBoundingVolume (pZDxInterface -> GetList2Window () -> GetActorSuperObject () , m_pZDxObject); else */ // ANNECY AV CLEAN_MEC { /* if (m_pZDxObject -> GetZDxType () == eTestPoint) pZDxInterface -> GetList2Window () -> CreateListOfTestPoint (pZDxInterface -> GetList2Window () -> GetActorSuperObject () , pZDxInterface -> GetList2Window () -> GetListOfTestPoint () , TRUE); else */ pZDxInterface -> GetList2Window () -> ReCreateListOfZDx (TRUE , FALSE); // END ANNECY AV } } pZDxInterface -> RefreshDisplay (C_lModifZDx , _bRefreshWindow); // We will have to save the geometric object // ANNECY AV CLEAN_MEC { /* if (m_pZDxObject -> GetZDxType () == eTestPoint) pZDxInterface -> GetList2Window () -> GetListOfTestPoint () -> fn_vNotifySave (); else */ m_pZDxObject -> fn_vNotifySave (); // END ANNECY AV } m_bIsDoingUndo = FALSE; return TRUE; } //----------------------------------------------------------------------------- // class ZDx_Modif - Undo // The standard Undo : we refresh the window by default //----------------------------------------------------------------------------- ZDx_Modif::Undo () { return Undo (TRUE); } //----------------------------------------------------------------------------- // class ZDx_Modif - Do // Do and Undo are exactly the same thing in this case, so we just call the Undo method //----------------------------------------------------------------------------- ZDx_Modif::Do () { if (m_bFirstTime) { m_bFirstTime = FALSE; return Undo (!((ZDx_Interface *) m_pZDxObject->GetEditor())->GetList1Window()->IsEditingBoundingVolume()); } else return Undo (TRUE); } //----------------------------------------------------------------------------- // class ZDx_Modif_Exchange - constructor //----------------------------------------------------------------------------- ZDx_Modif_Exchange::ZDx_Modif_Exchange (ZDx_Object * _pZDxObject1 , long _lIndexInList1 , EdtList * _pZDxList1 , CPA_SuperObject * _pActorSuperObject1 , ZDx_Object * _pZDxObject2 , long _lIndexInList2 , EdtList * _pZDxList2 , CPA_SuperObject * _pActorSuperObject2 , ZDx_Interface * _pZDxInterface) : CPA_Modif (0 , "Exchange zones" , FALSE) { m_pZDxInterface = _pZDxInterface; m_pZDxObject1 = _pZDxObject1; m_pZDxObject2 = _pZDxObject2; m_lIndexInList1 = _lIndexInList1; m_lIndexInList2 = _lIndexInList2; m_pZDxList1 = _pZDxList1; m_pZDxList2 = _pZDxList2; m_eTypeOfList1 = m_pZDxInterface -> ConvertListTypeToZDxType (m_pZDxList1 -> fn_csGetListType ()); m_eTypeOfList2 = m_pZDxInterface -> ConvertListTypeToZDxType (m_pZDxList2 -> fn_csGetListType ()); m_pActorSuperObject1 = _pActorSuperObject1; m_pActorSuperObject2 = _pActorSuperObject2; m_pActor1 = _pActorSuperObject1 -> GetObject (); m_pActor2 = _pActorSuperObject2 -> GetObject (); } //----------------------------------------------------------------------------- // class ZDx_Modif_Exchange - Do // We exchange the two ZDx //----------------------------------------------------------------------------- BOOL ZDx_Modif_Exchange::Do () { // Exchange the type of the ZDx objects if (m_pZDxObject1) m_pZDxObject1 -> SetZDxType (m_eTypeOfList2); if (m_pZDxObject2) m_pZDxObject2 -> SetZDxType (m_eTypeOfList1); // Put the second object into the first list m_pZDxInterface -> SetZDxObjectInList (m_pActor1 , m_eTypeOfList1 , m_lIndexInList1 , m_pZDxObject2); // Now, look if the list has changed. If so, the list has been duplicated, so we must do the modification // into the old and the new list. EdtList * pNewList1 = m_pZDxInterface -> GetZDxList (m_pActor1 , m_eTypeOfList1); if (pNewList1 != m_pZDxList1) { CPA_BaseObject * pActorUsingThisList = (CPA_BaseObject *) m_pActor1 -> GetEditor () -> OnQueryAction (m_pZDxInterface , C_uiActor_GetFirstActorUsingThisList , (long) pNewList1); m_pZDxInterface -> SetZDxObjectInList (pActorUsingThisList , m_eTypeOfList2 , m_lIndexInList2 , m_pZDxObject1 , eZDxModifyAllActors); } // Put the first object into the second list m_pZDxInterface -> SetZDxObjectInList (m_pActor2 , m_eTypeOfList2 , m_lIndexInList2 , m_pZDxObject1 , eZDxModifyAllActors); // Refresh the lists m_pZDxInterface -> GetList1Window () -> ReCreateCurrentList (); if (m_pZDxObject1) m_pZDxInterface -> GetList2Window () -> SelectZDx (m_pZDxObject1); return TRUE; } //----------------------------------------------------------------------------- // class ZDx_Modif_Exchange - Undo // We exchange the two ZDx //----------------------------------------------------------------------------- BOOL ZDx_Modif_Exchange::Undo () { // Exchange the type of the ZDx objects if (m_pZDxObject1) m_pZDxObject1 -> SetZDxType (m_eTypeOfList1); if (m_pZDxObject2) m_pZDxObject2 -> SetZDxType (m_eTypeOfList2); // Look if the list has changed. If so, we must delete the new list and put the old one EdtList * pNewList1 = m_pZDxInterface -> GetZDxList (m_pActor1 , m_eTypeOfList1); if (pNewList1 != m_pZDxList1) { m_pZDxInterface -> DeleteZDxList (m_pActor1 , m_eTypeOfList1); m_pZDxInterface -> SetZDxList (m_pActor1 , m_eTypeOfList1 , m_pZDxList1); } EdtList * pNewList2 = m_pZDxInterface -> GetZDxList (m_pActor2 , m_eTypeOfList2); if (pNewList2 != m_pZDxList2) { m_pZDxInterface -> DeleteZDxList (m_pActor2 , m_eTypeOfList2); m_pZDxInterface -> SetZDxList (m_pActor2 , m_eTypeOfList2 , m_pZDxList2); } // Exchange the two ZDx objects m_pZDxInterface -> SetZDxObjectInList (m_pActor1 , m_eTypeOfList1 , m_lIndexInList1 , m_pZDxObject1 , eZDxModifyAllActors); m_pZDxInterface -> SetZDxObjectInList (m_pActor2 , m_eTypeOfList2 , m_lIndexInList2 , m_pZDxObject2 , eZDxModifyAllActors); // Refresh the list m_pZDxInterface -> GetList1Window () -> ReCreateCurrentList (); if (m_pZDxObject1) m_pZDxInterface -> GetList2Window () -> SelectZDx (m_pZDxObject1); return TRUE; } //----------------------------------------------------------------------------- // class ZDx_Modif_Delete - constructor //----------------------------------------------------------------------------- ZDx_Modif_Delete::ZDx_Modif_Delete (CPA_SuperObject * _pZDxSuperObject , long _lIndexInList , EdtList * _pZDxList , CPA_SuperObject * _pModuleSuperObject , CPA_SuperObject * _pActorSuperObject , ZDx_Interface * _pZDxInterface) : CPA_Modif (0 , "Delete zone" , FALSE) { // One and only one of the two pointers must be defined ASSERT ((_pActorSuperObject != NULL) ^ (_pModuleSuperObject != NULL)); m_pZDxInterface = _pZDxInterface; m_pZDxSuperObject = _pZDxSuperObject; m_pZDxObject = (ZDx_Object *) _pZDxSuperObject -> GetObject (); m_lIndexInList = _lIndexInList; m_pZDxList = _pZDxList; m_pActorSuperObject = _pActorSuperObject; m_pActor = _pActorSuperObject ? _pActorSuperObject -> GetObject () : NULL; m_pModuleSuperObject = _pModuleSuperObject; m_pModule = (EditorPO *) (_pModuleSuperObject ? _pModuleSuperObject -> GetObject () : NULL); } //----------------------------------------------------------------------------- // class ZDx_Modif_Delete - destructor //----------------------------------------------------------------------------- ZDx_Modif_Delete::~ZDx_Modif_Delete () { // We do not delete the ZDx object, because it can be shared by several modules } //----------------------------------------------------------------------------- // class ZDx_Modif_Delete - Do // We delete the ZDx //----------------------------------------------------------------------------- BOOL ZDx_Modif_Delete::Do () { m_pZDxInterface -> IWillRefreshDisplay (C_lModifDeleteDo); if (m_pZDxObject -> GetZDxType () == eBoundingVolume) { // We get the family of the actor CPA_Family * pFamily = (CPA_Family *) m_pActor -> GetOwner () -> GetOwner (); // We set the reference of the bounding volume to NULL pFamily -> mfn_vSetBoundingVolume (NULL); // Remove the bounding volume from the hierarchy m_pZDxInterface -> DeleteZDxObjectFromHierarchy (m_pZDxSuperObject); m_pZDxInterface -> GetList2Window () -> CreateBoundingVolume (m_pActorSuperObject , NULL); } else // ANNECY AV CLEAN_MEC { /* if (m_pZDxObject -> GetZDxType () == eTestPoint) { // We get the current list of test points CPA_TestPointsList * pListOfTestPoint = m_pZDxInterface -> GetList2Window () -> GetListOfTestPoint (); ASSERT (pListOfTestPoint); // We find the test point of the list that have this ZDx object POSITION PosTestPoint = pListOfTestPoint -> m_oListOfTestPoints . GetHeadPosition (); CPA_TestPointNode * pTestPoint; while (PosTestPoint) { pTestPoint = pListOfTestPoint -> m_oListOfTestPoints . GetAt (PosTestPoint); if (pTestPoint -> mfn_p_oGetZdxObject () == m_pZDxObject) break; pListOfTestPoint -> m_oListOfTestPoints . GetNext (PosTestPoint); } ASSERT (PosTestPoint); // PosTestPoint == NULL --> not found -> error // Remove the test point from the list but do not delete it pListOfTestPoint -> m_oListOfTestPoints . RemoveAt (PosTestPoint); m_pZDxInterface -> GetList2Window () -> CreateListOfTestPoint (m_pActorSuperObject , pListOfTestPoint); pListOfTestPoint -> fn_vNotifySave (); } else */ // END ANNECY AV } { // Remove the ZDx object from the list or from the physical object if (m_pActor) m_pZDxInterface -> RemoveZDxFromList (m_pZDxList , m_pZDxObject , m_pActor , TRUE); else m_pZDxInterface -> SetZDxOfPhysicalObject (m_pModule , NULL ,m_pZDxObject -> GetZDxType ()); // Delete the ZDx object from the hierarchy m_pZDxInterface -> DeleteZDxObjectFromHierarchy (m_pZDxSuperObject); // Refresh the list m_pZDxInterface -> GetList2Window () -> ReCreateListOfZDx (TRUE , FALSE); // We show the ZDx again if (m_pActor) m_pZDxInterface -> ShowZDxOfActor (m_pActorSuperObject , m_pZDxInterface -> GetList2Window () -> GetZDxTypeToShow ()); else m_pZDxInterface -> ShowZDxOfModule (m_pModuleSuperObject , m_pZDxInterface -> GetList2Window () -> GetZDxTypeToShow ()); } // Say that the section of the graphic object must be deleted // ANNECY AV CLEAN_MEC { /* if (m_pZDxObject -> GetZDxType () == eTestPoint) m_pZDxInterface -> GetList2Window () -> GetListOfTestPoint () -> fn_vNotifySave (); else */ m_pZDxObject -> fn_vNotifyUnSave (); // END ANNECY AV } m_pZDxInterface -> RefreshDisplay (C_lModifDeleteDo); Done (); return TRUE; } //----------------------------------------------------------------------------- // class ZDx_Modif_Delete - Undo // We reinsert the ZDx //----------------------------------------------------------------------------- BOOL ZDx_Modif_Delete::Undo () { m_pZDxInterface -> IWillRefreshDisplay (C_lModifDeleteUndo); // Say that the section of the graphic object must not be deleted (must be done before it is inserted into the hierarchy) // ANNECY AV CLEAN_MEC { /* if (m_pZDxObject -> GetZDxType () == eTestPoint) m_pZDxInterface -> GetList2Window () -> GetListOfTestPoint () -> fn_vNotifySave (); else */ m_pZDxObject -> fn_vNotifyRestore (); // END ANNECY AV } if (m_pZDxObject -> GetZDxType () == eBoundingVolume) { // We get the family of the actor CPA_Family * pFamily = (CPA_Family *) m_pActor -> GetOwner () -> GetOwner (); // We set the reference to the new bounding volume pFamily -> mfn_vSetBoundingVolume (m_pZDxObject); // Show the bounding volume // m_pZDxInterface -> ShowBoundingVolume (m_pActorSuperObject , m_pZDxObject , TRUE); m_pZDxInterface -> GetList2Window () -> CreateBoundingVolume (m_pActorSuperObject , m_pZDxObject); } else // ANNECY AV CLEAN_MEC { /* if (m_pZDxObject -> GetZDxType () == eTestPoint) { CPA_TestPointNode * pTestPoint = m_pZDxObject -> GetTestPoint (); ASSERT (pTestPoint); CPA_TestPointsList * pListOfTestPoint = pTestPoint -> mfn_p_oGetList (); // Reinsert the test point into the list of test points pListOfTestPoint -> m_oListOfTestPoints . AddTail (pTestPoint); m_pZDxInterface -> GetList2Window () -> CreateListOfTestPoint (m_pActorSuperObject , pListOfTestPoint); pListOfTestPoint -> fn_vNotifySave (); } else */ // END ANNECY AV } { // Reinsert the ZDx object into the hierarchy (must be done before it is inserted into the list (because of fn_bAcceptAsParent)) m_pZDxInterface -> InsertZDxObjectIntoHierarchy (m_pZDxSuperObject , m_pActorSuperObject ? m_pActorSuperObject : m_pModuleSuperObject); // Reinsert the ZDx object into the list or into the physical object if (m_pActor) m_pZDxInterface -> InsertZDxIntoList (m_pZDxList , m_pZDxObject , & m_lIndexInList , m_pActor , eZDxModifyAllActors); else m_pZDxInterface -> SetZDxOfPhysicalObject (m_pModule , m_pZDxObject , m_pZDxObject -> GetZDxType ()); // Refresh the list m_pZDxInterface -> GetList2Window () -> ReCreateListOfZDx (TRUE , FALSE); // We show the ZDx again if (m_pActorSuperObject) m_pZDxInterface -> ShowZDxOfActor (m_pActorSuperObject , m_pZDxInterface -> GetList2Window () -> GetZDxTypeToShow ()); else m_pZDxInterface -> ShowZDxOfModule (m_pModuleSuperObject , m_pZDxInterface -> GetList2Window () -> GetZDxTypeToShow ()); } m_pZDxInterface -> RefreshDisplay (C_lModifDeleteUndo); Undone (); return TRUE; } //----------------------------------------------------------------------------- // class ZDx_Modif_Change_ZDx_List - constructor //----------------------------------------------------------------------------- ZDx_Modif_Change_ZDx_List::ZDx_Modif_Change_ZDx_List (ZDx_Interface * _pZDxInterface , CPA_SuperObject * _pActorSuperObject , tdeZDxType _eTypeOfList , EdtList * _pZDxList) : CPA_Modif (0 , "Change list of zones" , FALSE) { m_pZDxInterface = _pZDxInterface; m_pActorSuperObject = _pActorSuperObject; m_pActor = _pActorSuperObject -> GetObject (); m_eTypeOfList = _eTypeOfList; m_pZDxList = _pZDxList; } //----------------------------------------------------------------------------- // class ZDx_Modif_Change_ZDx_List - Undo // We exchange m_pZDxList and the current list //----------------------------------------------------------------------------- BOOL ZDx_Modif_Change_ZDx_List::Undo () { // Hide the zone of the actor m_pZDxInterface -> ShowZDxOfActor (m_pActorSuperObject , C_ucHideAllZDx); // Exchange current and backuped ZDx list EdtList * pCurrentList = m_pZDxInterface -> GetZDxList (m_pActor , m_eTypeOfList); m_pZDxInterface -> SetZDxList (m_pActor , m_eTypeOfList , m_pZDxList); m_pZDxList = pCurrentList; // Refresh the lists m_pZDxInterface -> GetList1Window () -> ReCreateCurrentList (); m_pZDxInterface -> GetList2Window () -> SelectZDx (m_eTypeOfList , 0); // Select the first ZDx object of the same type as the list return TRUE; } //----------------------------------------------------------------------------- // class ZDx_Modif_Change_ZDx_List - Do // Do and Undo are the same in this case, so we just call the Undo method //----------------------------------------------------------------------------- BOOL ZDx_Modif_Change_ZDx_List::Do () { return Undo (); }