Surface: Support for folders, copy and drag'n'drop (#6335)

* Enable surface reordering support. Automatically update surface in view ordering based on surface collection ordering

* Remove obsolete code

* Enable drag'n'drop support for surfaces within a surface collection. Still missing the collection update part.

* Bring back code lost in prev. commit

* Add code to accept drops in surface collections. Keep view  in sync.

* Add command for adding additional surface folders.

* Make sure we use the current surface collection as our parent when importing

* Enable name editing.
Make sure we use the correct surface collection when importing/creating surfaces

* More work on getting surface collections working.

* Clean up naming

* Make sure name for surfaceinviewcollection is read only

* Support drawing surfaces from subcollections, too

* Allow deleting subfolders.
Fix legends in view

* Refactor topmost flag for surface collections.

* Fix reload surface to work in all subfolders, too
Add copy surface skeleton. Actual copy operation is still missing

* Add support for copying surfaces

* Remove possibility to choose I and J slice directions for grid case surfaces.

* Fix warnings.

* Make sure we create the surface folder at the correct level

* More warning fix

* Use XML serialization for copy operation

* Fix missing delete

* Fix typo

* Remove unnecessary method.

ApplicationCode/ProjectDataModel/Surfaces/RimSurfaceCollection.cpp

@@ -28,6 +28,8 @@
 #include "RimSurface.h"
 #include "RimSurfaceInView.h"
 
+#include "cafPdmFieldReorderCapability.h"
+
 CAF_PDM_SOURCE_INIT( RimSurfaceCollection, "SurfaceCollection" );
 
 //--------------------------------------------------------------------------------------------------
@@ -37,8 +39,18 @@ RimSurfaceCollection::RimSurfaceCollection()
 {
     CAF_PDM_InitObject( "Surfaces", ":/ReservoirSurfaces16x16.png", "", "" );
 
+    CAF_PDM_InitFieldNoDefault( &m_collectionname, "SurfaceUserDecription", "Name", "", "", "" );
+    m_collectionname = "Surfaces";
+
+    CAF_PDM_InitFieldNoDefault( &m_subcollections, "SubCollections", "Surfaces", "", "", "" );
+    m_subcollections.uiCapability()->setUiTreeHidden( true );
+    auto reorderability = caf::PdmFieldReorderCapability::addToField( &m_subcollections );
+    reorderability->orderChanged.connect( this, &RimSurfaceCollection::orderChanged );
+
     CAF_PDM_InitFieldNoDefault( &m_surfaces, "SurfacesField", "Surfaces", "", "", "" );
     m_surfaces.uiCapability()->setUiTreeHidden( true );
+
+    setDeletable( true );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -48,6 +60,31 @@ RimSurfaceCollection::~RimSurfaceCollection()
 {
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimSurfaceCollection::setAsTopmostFolder()
+{
+    m_collectionname.uiCapability()->setUiHidden( true );
+    setDeletable( false );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+QString RimSurfaceCollection::collectionname() const
+{
+    return m_collectionname.value();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+caf::PdmFieldHandle* RimSurfaceCollection::userDescriptionField()
+{
+    return &m_collectionname;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -124,6 +161,39 @@ void RimSurfaceCollection::reloadSurfaces( std::vector<RimSurface*> surfaces )
     updateViews( surfaces );
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimSurface* RimSurfaceCollection::copySurfaces( std::vector<RimSurface*> surfaces )
+{
+    std::vector<RimSurface*> newsurfaces;
+
+    // create a copy of each surface given
+    for ( RimSurface* surface : surfaces )
+    {
+        RimSurface* copy = surface->createCopy();
+        if ( copy )
+        {
+            newsurfaces.push_back( copy );
+        }
+        else
+        {
+            RiaLogging::warning( "Create Surface Copy: Could not create a copy of the surface " + surface->fullName() );
+        }
+    }
+
+    RimSurface* retsurf = nullptr;
+    for ( RimSurface* surface : newsurfaces )
+    {
+        m_surfaces.push_back( surface );
+        retsurf = surface;
+    }
+
+    this->updateConnectedEditors();
+
+    return retsurf;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -132,15 +202,14 @@ RimSurface* RimSurfaceCollection::addGridCaseSurface( RimCase* sourceCase )
     auto s = new RimGridCaseSurface;
     s->setCase( sourceCase );
 
-    int  oneBasedSliceIndex = 1;
-    auto sliceType          = RiaDefines::GridCaseAxis::AXIS_K;
+    int oneBasedSliceIndex = 1;
 
-    s->setSliceTypeAndOneBasedIndex( sliceType, oneBasedSliceIndex );
+    s->setOneBasedIndex( oneBasedSliceIndex );
     s->setUserDescription( "Surface" );
 
     if ( !s->onLoadData() )
     {
-        RiaLogging::warning( "Add Grid Case Surface : Could not create the grid case surface. Don't know why." );
+        RiaLogging::warning( "Add Grid Case Surface : Could not create the grid case surface." );
         return nullptr;
     }
 
@@ -163,6 +232,14 @@ std::vector<RimSurface*> RimSurfaceCollection::surfaces() const
     return m_surfaces.childObjects();
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::vector<RimSurfaceCollection*> RimSurfaceCollection::subcollections() const
+{
+    return m_subcollections.childObjects();
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -246,3 +323,88 @@ void RimSurfaceCollection::onChildDeleted( caf::PdmChildArrayFieldHandle*      c
 {
     updateViews();
 }
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimSurfaceCollection::orderChanged( const caf::SignalEmitter* emitter )
+{
+    updateViews();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimSurfaceCollection::removeSurface( RimSurface* surface )
+{
+    m_surfaces.removeChildObject( surface );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimSurface* RimSurfaceCollection::addSurfacesAtIndex( int position, std::vector<RimSurface*> surfaces )
+{
+    // adjust index for number of folders we have
+    position = position - static_cast<int>( m_subcollections.size() );
+
+    RimSurface* returnSurface = nullptr;
+    if ( !surfaces.empty() ) returnSurface = surfaces[0];
+
+    // insert position at end?
+    if ( ( position >= static_cast<int>( m_surfaces.size() ) ) || ( position < 0 ) )
+    {
+        for ( auto surf : surfaces )
+        {
+            m_surfaces.push_back( surf );
+        }
+    }
+    else
+    {
+        // build the new surface order
+        std::vector<RimSurface*> orderedSurfs;
+
+        int i = 0;
+
+        while ( i < position )
+        {
+            orderedSurfs.push_back( m_surfaces[i++] );
+        }
+
+        for ( auto surf : surfaces )
+        {
+            orderedSurfs.push_back( surf );
+        }
+
+        int surfcount = static_cast<int>( m_surfaces.size() );
+        while ( i < surfcount )
+        {
+            orderedSurfs.push_back( m_surfaces[i++] );
+        }
+
+        // reset the surface collection and use the new order
+        m_surfaces.clear();
+        for ( auto surf : orderedSurfs )
+        {
+            m_surfaces.push_back( surf );
+        }
+    }
+
+    // make sure the views are in sync with the collection order
+    updateViews();
+
+    return returnSurface;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimSurfaceCollection::addSubCollection( RimSurfaceCollection* subcoll )
+{
+    m_subcollections.push_back( subcoll );
+    this->updateConnectedEditors();
+
+    updateViews();
+
+    return;
+}