ResInsight/Fwk/AppFwk/cafTests/cafTestApplication/CustomObjectEditor.cpp

//##################################################################################################
//
//   Custom Visualization Core library
//   Copyright (C) 2017 Ceetron Solutions AS
//
//   This library may be used under the terms of either the GNU General Public License or
//   the GNU Lesser General Public License as follows:
//
//   GNU General Public License Usage
//   This library is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation, either version 3 of the License, or
//   (at your option) any later version.
//
//   This library is distributed in the hope that it will be useful, but WITHOUT ANY
//   WARRANTY; without even the implied warranty of MERCHANTABILITY or
//   FITNESS FOR A PARTICULAR PURPOSE.
//
//   See the GNU General Public License at <<http://www.gnu.org/licenses/gpl.html>>
//   for more details.
//
//   GNU Lesser General Public License Usage
//   This library is free software; you can redistribute it and/or modify
//   it under the terms of the GNU Lesser General Public License as published by
//   the Free Software Foundation; either version 2.1 of the License, or
//   (at your option) any later version.
//
//   This library is distributed in the hope that it will be useful, but WITHOUT ANY
//   WARRANTY; without even the implied warranty of MERCHANTABILITY or
//   FITNESS FOR A PARTICULAR PURPOSE.
//
//   See the GNU Lesser General Public License at <<http://www.gnu.org/licenses/lgpl-2.1.html>>
//   for more details.
//
//##################################################################################################

#include "CustomObjectEditor.h"

#include "cafPdmUiGroup.h"

#include "QMinimizePanel.h"

#include <QFrame>
#include <QGridLayout>

//==================================================================================================
///
//==================================================================================================
class WidgetCellIds
{
public:
    WidgetCellIds( QWidget* w, const std::vector<int>& occupiedCellIds )
        : m_customWidget( w )
        , m_customWidgetCellIds( occupiedCellIds )
    {
    }

    QWidget*         m_customWidget;
    std::vector<int> m_customWidgetCellIds;
};

namespace caf
{
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
CustomObjectEditor::CustomObjectEditor()
{
    m_columnCount   = 3;
    m_rowCount      = 2;
    m_currentCellId = -1;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
CustomObjectEditor::~CustomObjectEditor()
{
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void CustomObjectEditor::defineGridLayout( int rowCount, int columnCount )
{
    m_rowCount    = rowCount;
    m_columnCount = columnCount;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void CustomObjectEditor::addWidget( QWidget* widget, int row, int column, int rowSpan, int columnSpan, Qt::Alignment alignment /*= 0*/ )
{
    CAF_ASSERT( isAreaAvailable( row, column, rowSpan, columnSpan ) );

    m_customWidgetAreas.push_back(
        WidgetCellIds( widget, CustomObjectEditor::cellIds( row, column, rowSpan, columnSpan ) ) );

    // The ownership of item is transferred to the layout, and it's the layout's responsibility to delete it.
    m_layout->addWidget( widget, row, column, rowSpan, columnSpan, alignment );
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void CustomObjectEditor::removeWidget( QWidget* widget )
{
    size_t indexToRemove = size_t( -1 );
    for ( size_t i = 0; i < m_customWidgetAreas.size(); i++ )
    {
        if ( widget == m_customWidgetAreas[i].m_customWidget )
        {
            indexToRemove = i;
            break;
        }
    }

    if ( indexToRemove != size_t( -1 ) )
    {
        m_layout->removeWidget( widget );

        m_customWidgetAreas.erase( m_customWidgetAreas.begin() + indexToRemove );
    }
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void CustomObjectEditor::addBlankCell( int row, int column )
{
    m_customWidgetAreas.push_back( WidgetCellIds( nullptr, CustomObjectEditor::cellIds( row, column, 1, 1 ) ) );
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QWidget* CustomObjectEditor::createWidget( QWidget* parent )
{
    QWidget* widget = new QWidget( parent );

    m_layout = new QGridLayout();
    m_layout->setContentsMargins( 0, 0, 0, 0 );
    widget->setLayout( m_layout );

    return widget;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void CustomObjectEditor::recursivelyConfigureAndUpdateTopLevelUiOrdering( const PdmUiOrdering& topLevelUiOrdering,
                                                                          const QString&       uiConfigName )
{
    resetCellId();

    const std::vector<PdmUiOrdering::FieldAndLayout>& topLevelUiItems = topLevelUiOrdering.uiItemsWithLayout();

    for ( size_t i = 0; i < topLevelUiItems.size(); ++i )
    {
        if ( topLevelUiItems[i].first->isUiHidden( uiConfigName ) ) continue;

        if ( topLevelUiItems[i].first->isUiGroup() )
        {
            PdmUiGroup*     group    = static_cast<PdmUiGroup*>( topLevelUiItems[i].first );
            QMinimizePanel* groupBox = findOrCreateGroupBox( this->widget(), group, uiConfigName );

            /// Insert the group box at the correct position of the parent layout
            int                 nextCellId = getNextAvailableCellId();
            std::pair<int, int> rowCol     = rowAndColumn( nextCellId );
            m_layout->addWidget( groupBox, rowCol.first, rowCol.second, 1, 1 );

            recursivelyConfigureAndUpdateUiOrderingInNewGridLayout( *group, groupBox->contentFrame(), uiConfigName );
        }

        // NB! Only groups at top level are handled, fields at top level are not added to layout
    }
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool CustomObjectEditor::isAreaAvailable( int row, int column, int rowSpan, int columnSpan ) const
{
    auto candidateCells = CustomObjectEditor::cellIds( row, column, rowSpan, columnSpan );
    for ( auto candidateCell : candidateCells )
    {
        if ( !isCellIdAvailable( candidateCell ) )
        {
            return false;
        }
    }

    if ( row + rowSpan > m_rowCount ) return false;
    if ( column + columnSpan > m_columnCount ) return false;

    return true;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool CustomObjectEditor::isCellIdAvailable( int cellId ) const
{
    for ( auto customArea : m_customWidgetAreas )
    {
        for ( auto occupiedCell : customArea.m_customWidgetCellIds )
        {
            if ( cellId == occupiedCell )
            {
                return false;
            }
        }
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void CustomObjectEditor::resetCellId()
{
    m_currentCellId = 0;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<int, int> CustomObjectEditor::rowAndColumn( int cellId ) const
{
    int column = cellId % m_columnCount;
    int row    = cellId / m_columnCount;

    return std::make_pair( row, column );
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
int CustomObjectEditor::cellId( int row, int column ) const
{
    return row * m_columnCount + column;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
int CustomObjectEditor::getNextAvailableCellId()
{
    while ( !isCellIdAvailable( m_currentCellId ) && m_currentCellId < ( m_rowCount * m_columnCount ) )
    {
        m_currentCellId++;
    }

    if ( !isCellIdAvailable( m_currentCellId ) )
    {
        return -1;
    }
    else
    {
        return m_currentCellId++;
    }
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<int> CustomObjectEditor::cellIds( int row, int column, int rowSpan, int columnSpan ) const
{
    std::vector<int> cells;

    for ( auto r = row; r < row + rowSpan; r++ )
    {
        for ( auto c = column; c < column + columnSpan; c++ )
        {
            cells.push_back( cellId( r, c ) );
        }
    }

    return cells;
}

} // end namespace caf