Changeset 448 for cafu/trunk

Timestamp:

12/22/11 11:46:09 (5 months ago)

Author:

Carsten

Message:

CaWE: Revised the semantics of the Morph tool to finally integrate properly with the Undo/Redo history.

Location:

cafu/trunk/CaWE

Files:

• MapCommands/AddPrim.cpp (modified) (5 diffs)
• MapCommands/AddPrim.hpp (modified) (1 diff)
• ToolMorph.cpp (modified) (13 diffs)
• ToolMorph.hpp (modified) (2 diffs)

cafu/trunk/CaWE/MapCommands/AddPrim.cpp

@@ -26 +26 @@
 
 
-CommandAddPrimT::CommandAddPrimT(MapDocumentT& MapDoc, MapPrimitiveT* AddPrim, MapEntityBaseT* Parent, wxString Name)
+CommandAddPrimT::CommandAddPrimT(MapDocumentT& MapDoc, MapPrimitiveT* AddPrim, MapEntityBaseT* Parent, wxString Name, bool SetSel)
     : m_MapDoc(MapDoc),
       m_AddPrims(),
@@ -37 +37 @@
     m_AddElems.PushBack(AddPrim);
 
-    m_CommandSelect=CommandSelectT::Set(&m_MapDoc, m_AddElems);
+    if (SetSel)
+        m_CommandSelect=CommandSelectT::Set(&m_MapDoc, m_AddElems);
 }
 
 
-CommandAddPrimT::CommandAddPrimT(MapDocumentT& MapDoc, const ArrayT<MapPrimitiveT*>& AddPrims, MapEntityBaseT* Parent, wxString Name)
+CommandAddPrimT::CommandAddPrimT(MapDocumentT& MapDoc, const ArrayT<MapPrimitiveT*>& AddPrims, MapEntityBaseT* Parent, wxString Name, bool SetSel)
     : m_MapDoc(MapDoc),
       m_AddPrims(AddPrims),
@@ -52 +53 @@
         m_AddElems.PushBack(m_AddPrims[PrimNr]);
 
-    m_CommandSelect=CommandSelectT::Set(&m_MapDoc, m_AddElems);
+    if (SetSel)
+        m_CommandSelect=CommandSelectT::Set(&m_MapDoc, m_AddElems);
 }
 
@@ -81 +83 @@
     m_MapDoc.UpdateAllObservers_Created(m_AddElems);
 
-    m_CommandSelect->Do();
+    if (m_CommandSelect)
+        m_CommandSelect->Do();
 
     m_Done=true;
@@ -93 +96 @@
     if (!m_Done) return;
 
-    m_CommandSelect->Undo();
+    if (m_CommandSelect)
+        m_CommandSelect->Undo();
 
     for (unsigned long PrimNr=0; PrimNr<m_AddPrims.Size(); PrimNr++)

cafu/trunk/CaWE/MapCommands/AddPrim.hpp

@@ -44 +44 @@
     /// @param Parent    The parent entity that the primitive becomes a part of and which it is added to. Can be the world or a custom entity.
     /// @param Name      The name of this command for the undo history.
-    CommandAddPrimT(MapDocumentT& MapDoc, MapPrimitiveT* AddPrim, MapEntityBaseT* Parent, wxString Name="new primitive");
+    /// @param SetSel    Whether the selection should be set to the newly added map primitive(s).
+    CommandAddPrimT(MapDocumentT& MapDoc, MapPrimitiveT* AddPrim, MapEntityBaseT* Parent, wxString Name="new primitive", bool SetSel=true);
 
     /// The constructor for creating a command for adding multiple primitives into the map.
     /// Analogous to the constructor for adding a single primitive above.
-    CommandAddPrimT(MapDocumentT& MapDoc, const ArrayT<MapPrimitiveT*>& AddPrims, MapEntityBaseT* Parent, wxString Name="new primitives");
+    CommandAddPrimT(MapDocumentT& MapDoc, const ArrayT<MapPrimitiveT*>& AddPrims, MapEntityBaseT* Parent, wxString Name="new primitives", bool SetSel=true);
 
     /// The destructor.

cafu/trunk/CaWE/ToolMorph.cpp

@@ -39 +39 @@
 #include "MapCommands/AddPrim.hpp"
 #include "MapCommands/Delete.hpp"
+#include "MapCommands/Select.hpp"
 
 
@@ -140 +141 @@
     else
     {
-        MorphPrims_CommitAndClear();
-
-        // For each brush or bezier patch in the documents selection, create a related instance here.
-        for (unsigned long SelNr=0; SelNr<m_MapDoc.GetSelection().Size(); SelNr++)
-        {
-            MapPrimitiveT* MapPrim=dynamic_cast<MapPrimitiveT*>(m_MapDoc.GetSelection()[SelNr]);
-
-            if (MapPrim)
-                MorphPrims_TogglePrim(MapPrim);
-        }
+        MorphPrims_SyncTo(m_MapDoc.GetSelection());
+        m_DragState=DragNothing;
     }
 }
@@ -162 +155 @@
 void ToolMorphT::OnDeactivate(ToolT* NewTool)
 {
-    MorphPrims_CommitAndClear();
+    const ArrayT<MapElementT*> Empty;
+
+    // Clear/reset the morph tool.
+    MorphPrims_SyncTo(Empty);
+    m_DragState=DragNothing;
 }
 
@@ -176 +173 @@
 
 
-void ToolMorphT::MorphPrims_CommitAndClear()
-{
-    // Set the map elements of all morph primitives back to "visible"
-    // and remove all unmodified morph primitives from our list.
-
-    // TODO: Doing it like this is not particularly efficient, but this is going to be refactored anyway.
-    while (m_MorphPrims.Size()>0)
-    {
-        MorphPrims_TogglePrim(m_MorphPrims[0]->GetMapPrim());
-    }
-}
-
-
-void ToolMorphT::MorphPrims_TogglePrim(const MapPrimitiveT* MapPrim)
-{
-    // Only needed for observer message.
-    ArrayT<MapElementT*> MapElements;
-    MapElements.PushBack(const_cast<MapPrimitiveT*>(MapPrim));
-
-    const int MP_Index=MorphPrims_Find(MapPrim);
-
-    if (MP_Index>=0)
-    {
-        MorphPrimT* MorphPrim=m_MorphPrims[MP_Index];
-
-        m_MorphPrims.RemoveAtAndKeepOrder(MP_Index);
-        wxASSERT(MapPrim == MorphPrim->GetMapPrim());
-
-        if (MorphPrim->IsModified())
-        {
-            MapPrimitiveT* MorphedMapPrim=MorphPrim->GetMorphedMapPrim();
-
-            if (MorphedMapPrim)
-            {
-                m_IsRecursiveSelfNotify=true;
-
-                ArrayT<CommandT*> Commands;
-                Commands.PushBack(new CommandDeleteT(m_MapDoc, const_cast<MapPrimitiveT*>(MorphPrim->GetMapPrim())));
-                Commands.PushBack(new CommandAddPrimT(m_MapDoc, MorphedMapPrim, MorphPrim->GetMapPrim()->GetParent()));
-
-                m_MapDoc.GetHistory().SubmitCommand(new CommandMacroT(Commands, "Edit Vertices"));
-
-                m_IsRecursiveSelfNotify=false;
-            }
-        }
-
-        delete MorphPrim;
-
-        // Elem is now no longer mentioned in the m_MorphPrims list, and thus no longer affected by IsHiddenByTool().
+void ToolMorphT::MorphPrims_SyncTo(const ArrayT<MapElementT*>& Elems)
+{
+    ArrayT<MapElementT*> VisChanged;
+
+    // Remove all entries from m_MorphPrims that are not in NewSelection.
+    for (unsigned long MPNr=0; MPNr<m_MorphPrims.Size(); MPNr++)
+    {
+        MapPrimitiveT* MapPrim=const_cast<MapPrimitiveT*>(m_MorphPrims[MPNr]->GetMapPrim());
+
+        if (Elems.Find(MapPrim) < 0)
+        {
+            delete m_MorphPrims[MPNr];
+            m_MorphPrims.RemoveAt(MPNr);
+            MPNr--;
+
+            VisChanged.PushBack(MapPrim);
+        }
+    }
+
+    // Add all entries that are in Elems but not yet in m_MorphPrims to m_MorphPrims.
+    for (unsigned long ElemNr=0; ElemNr<Elems.Size(); ElemNr++)
+    {
+        MapPrimitiveT* MapPrim=dynamic_cast<MapPrimitiveT*>(Elems[ElemNr]);
+
+        if (!MapPrim) continue;
+        if (MapPrim->GetType()!=&MapBrushT::TypeInfo && MapPrim->GetType()!=&MapBezierPatchT::TypeInfo) continue;
+        if (MorphPrims_Find(MapPrim) >= 0) continue;
+
+        m_MorphPrims.PushBack(new MorphPrimT(MapPrim));
+        VisChanged.PushBack(MapPrim);
+    }
+
+    // If any changes were made, notify the observers.
+    if (VisChanged.Size() > 0)
+    {
         m_IsRecursiveSelfNotify=true;
-        m_MapDoc.UpdateAllObservers_Modified(MapElements, MEMD_VISIBILITY);     // TODO: Is this still needed? The element was *deleted* above, after all (but only if modified, mind'ya).
+        m_MapDoc.UpdateAllObservers_Modified(VisChanged, MEMD_VISIBILITY);
         m_IsRecursiveSelfNotify=false;
-        return;
-    }
-
-    if (dynamic_cast<const MapBrushT*>(MapPrim)==NULL && dynamic_cast<const MapBezierPatchT*>(MapPrim)==NULL) return;
-
-    MorphPrimT* MorphPrim=new MorphPrimT(MapPrim);
-    m_MorphPrims.PushBack(MorphPrim);
-
-    // Elem is now mentioned in the m_MorphPrims list, and thus affected by IsHiddenByTool().
-    m_IsRecursiveSelfNotify=true;
-    m_MapDoc.UpdateAllObservers_Modified(MapElements, MEMD_VISIBILITY);
-    m_IsRecursiveSelfNotify=false;
-}
-
-
-ArrayT<MorphHandleT> ToolMorphT::GetMorphHandlesAt(ViewWindow2DT& ViewWindow, const wxPoint& Point)
+
+        m_ToolMan.UpdateAllObservers(this, UPDATE_SOON);
+    }
+}
+
+
+ArrayT<MorphHandleT> ToolMorphT::GetMorphHandlesAt(ViewWindow2DT& ViewWindow, const wxPoint& Point) const
 {
     ArrayT<MorphHandleT> MorphHandles;
@@ -294 +268 @@
 
 
-bool ToolMorphT::GetMorphHandleAt(ViewWindow3DT& ViewWindow, const wxPoint& Point, MorphHandleT& FoundMH)
+bool ToolMorphT::GetMorphHandleAt(ViewWindow3DT& ViewWindow, const wxPoint& Point, MorphHandleT& FoundMH) const
 {
     float BestDist=1000000.0f;
@@ -428 +402 @@
 
 
+void ToolMorphT::FinishDragMorphHandles()
+{
+    ArrayT<CommandT*> Commands;
+
+    for (unsigned long MPNr=0; MPNr<m_MorphPrims.Size(); MPNr++)
+    {
+        if (!m_MorphPrims[MPNr]->IsModified()) continue;
+
+        MapPrimitiveT*  MapPrim       =const_cast<MapPrimitiveT*>(m_MorphPrims[MPNr]->GetMapPrim());
+        MapEntityBaseT* ParentEntity  =MapPrim->GetParent();
+        MapPrimitiveT*  MorphedMapPrim=m_MorphPrims[MPNr]->GetMorphedMapPrim();
+
+        if (!MorphedMapPrim) continue;
+        wxASSERT(MapPrim->IsSelected());
+
+        // The delete command also unselects the MapPrim, calling NotifySubjectChanged_Selection(),
+        // followed by NotifySubjectChanged_Deleted().
+        // Thus our m_MorphPrims[MPNr] will be deleted and a new one created for MorphedMapPrim by
+        // the implicit calls to the NotifySubjectChanged_*() functions.
+        CommandDeleteT* DelCmd=new CommandDeleteT(m_MapDoc, MapPrim);
+        DelCmd->Do();
+        Commands.PushBack(DelCmd);
+
+        CommandAddPrimT* AddPrimCmd=new CommandAddPrimT(m_MapDoc, MorphedMapPrim, ParentEntity, "new prim", false /*don't set the selection*/);
+        AddPrimCmd->Do();
+        Commands.PushBack(AddPrimCmd);
+
+        CommandSelectT* SelCmd=CommandSelectT::Add(&m_MapDoc, MorphedMapPrim);
+        SelCmd->Do();
+        Commands.PushBack(SelCmd);
+    }
+
+    m_MapDoc.GetHistory().SubmitCommand(new CommandMacroT(Commands, "Edit Vertices"));
+
+    // This is somewhat redundant, but have it anyway here for clarity.
+    m_DragState=DragNothing;
+}
+
+
 void ToolMorphT::NoteEditModeChanged()
 {
-    // TODO: Clear the selection!!?!
-
     m_ToolMan.UpdateAllObservers(this, UPDATE_SOON);
 }
@@ -469 +480 @@
     m_MorphPrims[0]->m_Vertices[m_MorphPrims[0]->m_Vertices.Size()-1]->pos=Center;
 
-    // I *don't* bother to update the m_MorphPrims[0] geometry e.g. by a dummy-call to MoveSelectedHandles(),
+    // *Don't* bother to update the m_MorphPrims[0] geometry e.g. by a dummy-call to MoveSelectedHandles(),
     // because firstly the convex hull should not have been affected anyway, and secondly, the user is supposed
     // to trigger the update himself by dragging the new vertex.
@@ -608 +619 @@
         if (HitPrim && (HitPrim->GetType()==&MapBrushT::TypeInfo || HitPrim->GetType()==&MapBezierPatchT::TypeInfo))
         {
-            if (!ME.ControlDown()) MorphPrims_CommitAndClear();
-            MorphPrims_TogglePrim(HitPrim);
-
-            m_ToolMan.UpdateAllObservers(this, UPDATE_NOW);
+            // The handling of the Control key is not ideal: it would possibly be better to
+            // not account for it at all, or to route this through the selection tool somehow.
+            //
+            // The implied call to NotifySubjectChanged_Selection() will update our tool state.
+            m_MapDoc.GetHistory().SubmitCommand(ME.ControlDown()
+                ? CommandSelectT::Add(&m_MapDoc, HitPrim)
+                : CommandSelectT::Set(&m_MapDoc, HitPrim));
+
             return true;
         }
@@ -666 +681 @@
 
         case DragMorphHandles:
+            FinishDragMorphHandles();
             break;
 
@@ -878 +894 @@
         if (HitPrim && (HitPrim->GetType()==&MapBrushT::TypeInfo || HitPrim->GetType()==&MapBezierPatchT::TypeInfo))
         {
-            if (!ME.ControlDown()) MorphPrims_CommitAndClear();
-            MorphPrims_TogglePrim(HitPrim);
-
-            m_ToolMan.UpdateAllObservers(this, UPDATE_NOW);
+            // The handling of the Control key is not ideal: it would possibly be better to
+            // not account for it at all, or to route this through the selection tool somehow.
+            //
+            // The implied call to NotifySubjectChanged_Selection() will update our tool state.
+            m_MapDoc.GetHistory().SubmitCommand(ME.ControlDown()
+                ? CommandSelectT::Add(&m_MapDoc, HitPrim)
+                : CommandSelectT::Set(&m_MapDoc, HitPrim));
+
             return true;
         }
@@ -975 +995 @@
 
         case DragMorphHandles:
-            m_ToolMan.UpdateAllObservers(this, UPDATE_SOON);
+            FinishDragMorphHandles();
             break;
 
@@ -995 +1015 @@
     if (!IsActiveTool() || m_IsRecursiveSelfNotify) return;
 
-    // An external event caused a selection change, such as the user clicking "Undo".
-    //
-    //   - What we can *not* do is calling MorphPrims_CommitAndClear(), because that
-    //     would attempt to submit another command to the command history while the
-    //     command history is attempting to run the "Undo".
-    //
-    //   - Technically, it would be possible to do nothing: A change in selection
-    //     does not require any alterations of our tool state, the user can continue
-    //     to morph the objects that he previously begun to morph.
-    //
-    //   - Although the user might lose some morph work, probably the least confusion
-    //     action is to just discard and clear the tool state.
-    //
-    for (unsigned long MPNr=0; MPNr<m_MorphPrims.Size(); MPNr++)
+    MorphPrims_SyncTo(NewSelection);
+}
+
+
+void ToolMorphT::NotifySubjectChanged_Deleted(SubjectT* Subject, const ArrayT<MapElementT*>& MapElements)
+{
+    if (!IsActiveTool() || m_IsRecursiveSelfNotify) return;
+
+    // Remove all entries that are in MapElements and m_MorphPrims from m_MorphPrims.
+    for (unsigned long ElemNr=0; ElemNr<MapElements.Size(); ElemNr++)
+    {
+        MapPrimitiveT* MapPrim=dynamic_cast<MapPrimitiveT*>(MapElements[ElemNr]);
+        if (!MapPrim) continue;
+
+        const int MPNr=MorphPrims_Find(MapPrim);
+        if (MPNr < 0) continue;
+
         delete m_MorphPrims[MPNr];
-    m_MorphPrims.Overwrite();
+        m_MorphPrims.RemoveAt(MPNr);
+    }
+
+    // No need for this, the elements have been deleted after all.
+    // m_IsRecursiveSelfNotify=true;
+    // m_MapDoc.UpdateAllObservers_Modified(VisChanged, MEMD_VISIBILITY);
+    // m_IsRecursiveSelfNotify=false;
 
     m_ToolMan.UpdateAllObservers(this, UPDATE_SOON);
-    m_DragState=DragNothing;
-}
-
-
-void ToolMorphT::NotifySubjectChanged_Deleted(SubjectT* Subject, const ArrayT<MapElementT*>& MapElements)
+}
+
+
+void ToolMorphT::NotifySubjectChanged_Modified(SubjectT* Subject, const ArrayT<MapElementT*>& MapElements, MapElemModDetailE Detail)
 {
     if (!IsActiveTool() || m_IsRecursiveSelfNotify) return;
 
-    for (unsigned long i=0; i<MapElements.Size(); i++)
-    {
-        MapPrimitiveT* MapPrim=dynamic_cast<MapPrimitiveT*>(MapElements[i]);
-
+    // If only the visibility changed, do nothing. In all other cases,
+    // don't further examine Detail, but just do the update.
+    if (Detail==MEMD_VISIBILITY) return;
+
+    // Update all entries that are in MapElements and m_MorphPrims.
+    for (unsigned long ElemNr=0; ElemNr<MapElements.Size(); ElemNr++)
+    {
+        MapPrimitiveT* MapPrim=dynamic_cast<MapPrimitiveT*>(MapElements[ElemNr]);
         if (!MapPrim) continue;
 
-        for (unsigned long j=0; j<m_MorphPrims.Size(); j++)
-        {
-            if (MapPrim==m_MorphPrims[j]->GetMapPrim())
-            {
-                // Remove this morph primitive from our list.
-                delete m_MorphPrims[j];
-                m_MorphPrims.RemoveAtAndKeepOrder(j);
-
-                // The element has been found so we can safely break the inner loop and check the next.
-                break;
-            }
-        }
+        const int MPNr=MorphPrims_Find(MapPrim);
+        if (MPNr < 0) continue;
+
+        delete m_MorphPrims[MPNr];
+        m_MorphPrims[MPNr]=new MorphPrimT(MapPrim);
     }
 
@@ -1045 +1070 @@
 
 
-void ToolMorphT::NotifySubjectChanged_Modified(SubjectT* Subject, const ArrayT<MapElementT*>& MapElements, MapElemModDetailE Detail)
-{
-    if (!IsActiveTool() || m_IsRecursiveSelfNotify) return;
-    if (Detail!=MEMD_GENERIC && Detail!=MEMD_VISIBILITY) return;
-
-    for (unsigned long i=0; i<MapElements.Size(); i++)
-    {
-        MapPrimitiveT* MapPrim=dynamic_cast<MapPrimitiveT*>(MapElements[i]);
-
-        if (!MapPrim) continue;
-
-        for (unsigned long j=0; j<m_MorphPrims.Size(); j++)
-        {
-            if (MapPrim==m_MorphPrims[j]->GetMapPrim())
-            {
-                // Update the morph primitive of this map element, discarding all prior changes, if any.
-                delete m_MorphPrims[j];
-                m_MorphPrims[j]=new MorphPrimT(MapPrim);
-
-                // Object has been found so we can safely break the inner loop and check the next object.
-                break;
-            }
-        }
-    }
-
-    m_ToolMan.UpdateAllObservers(this, UPDATE_SOON);
-}
-
-
 void ToolMorphT::NotifySubjectChanged_Modified(SubjectT* Subject, const ArrayT<MapElementT*>& MapElements, MapElemModDetailE Detail, const ArrayT<BoundingBox3fT>& OldBounds)
 {
-    if (!IsActiveTool() || m_IsRecursiveSelfNotify) return;
-    if (Detail!=MEMD_GENERIC && Detail!=MEMD_TRANSFORM && Detail!=MEMD_PRIMITIVE_PROPS_CHANGED && Detail!=MEMD_MORPH) return;
-
-    for (unsigned long i=0; i<MapElements.Size(); i++)
-    {
-        MapPrimitiveT* MapPrim=dynamic_cast<MapPrimitiveT*>(MapElements[i]);
-
-        if (!MapPrim) continue;
-
-        for (unsigned long j=0; j<m_MorphPrims.Size(); j++)
-        {
-            if (MapPrim==m_MorphPrims[j]->GetMapPrim())
-            {
-                // Update the morph primitive of this map element, discarding all prior changes, if any.
-                delete m_MorphPrims[j];
-                m_MorphPrims[j]=new MorphPrimT(MapPrim);
-
-                // Object has been found so we can safely break the inner loop and check the next object.
-                break;
-            }
-        }
-    }
-
-    m_ToolMan.UpdateAllObservers(this, UPDATE_SOON);
+    NotifySubjectChanged_Modified(Subject, MapElements, Detail);
 }
 

cafu/trunk/CaWE/ToolMorph.hpp

@@ -105 +105 @@
     /// @param Point        The coordinate of interest in ViewWindow, given in Tool(!) Space.
     /// @returns the array of all morph handles "under" Point in ViewWindow.
-    ArrayT<MorphHandleT> GetMorphHandlesAt(ViewWindow2DT& ViewWindow, const wxPoint& Point);
+    ArrayT<MorphHandleT> GetMorphHandlesAt(ViewWindow2DT& ViewWindow, const wxPoint& Point) const;
 
     /// Finds the morph handle that is in ViewWindow along the ray through Point.
@@ -113 +113 @@
     ///    If there is more than one morph handle along the ray through Point, the morph handle that is closest to the viewer is returned.
     /// @returns true if a morph handle was found in ViewWindow along the ray through Point, false if no such handle exists.
-    bool GetMorphHandleAt(ViewWindow3DT& ViewWindow, const wxPoint& Point, MorphHandleT& FoundMH);
+    bool GetMorphHandleAt(ViewWindow3DT& ViewWindow, const wxPoint& Point, MorphHandleT& FoundMH) const;
 
     int  MorphPrims_Find(const MapElementT* Elem) const;        ///< Returns the array index number of the MorphPrimT for the given Elem, -1 if there is none.
-    void MorphPrims_CommitAndClear();                           ///< Commits all morphs in m_MorphPrims to their true map elements and resets the morph tool back to empty.
-    void MorphPrims_TogglePrim(const MapPrimitiveT* MapPrim);   ///< Toggles the membership of MapPrim in the m_MorphPrims array.
+    void MorphPrims_SyncTo(const ArrayT<MapElementT*>& Elems);  ///< Sync's our m_MorphPrims to the given Elems, so that they correspond 1:1 to each other.
     void MoveSelectedHandles(const Vector3fT& Delta);           ///< WARNING: This method *DESTROYS* all handle pointers into any of the m_MorphPrims!!
     void NudgeSelectedHandles(const AxesInfoT& AxesInfo, const wxKeyEvent& KE);
+    void FinishDragMorphHandles();                              ///< Called from the 2D or 3D views, for morph-modified items, this function replaces the original primitives with the morphed ones in the map.
     void OnEscape(ViewWindowT& ViewWindow);