configurationwidget.cpp

/***************************************************************************
 *   Copyright (C) 2008 by Tomassino Ferrauto                              *
 *   t_ferrauto@yahoo.it                                                   *
 *                                                                         *
 *   This program 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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "ui/configurationwidget.h"
#include <QVBoxLayout>
#include <QHeaderView>

namespace farsa {

ConfigurationWidget::ConfigurationWidget(QWidget *parent) :
    QSplitter(Qt::Horizontal, parent),
    m_configurationParameters(NULL),
    m_tmpParameters(),
    m_readOnly(true),
    m_valuesChanged(false),
    m_treeWidget(NULL),
    m_tableWidget(NULL)
{
    // Creating a tree widget and adding it to the splitter
    m_treeWidget = new QTreeWidget(this);
    addWidget(m_treeWidget);
    // Only one column
    m_treeWidget->setColumnCount(1);
    m_treeWidget->setSelectionMode(QAbstractItemView::SingleSelection);
    m_treeWidget->setHeaderLabel("Groups");
    m_treeWidget->header()->setClickable(false);
    setStretchFactor(0, 1);

    // Creating a table widget and adding it to the splitter
    m_tableWidget = new QTableWidget(this);
    addWidget(m_tableWidget);
    // Two columns, parameter name and value
    m_tableWidget->setColumnCount(2);
    m_tableWidget->setHorizontalHeaderLabels(QStringList() << "Parameters" << "Value");
    m_tableWidget->horizontalHeader()->setClickable(false);
    m_tableWidget->verticalHeader()->setClickable(false);
    setStretchFactor(1, 2);

    // Connecting tree and table signals
    connect(m_treeWidget, SIGNAL(itemClicked(QTreeWidgetItem *, int)), this, SLOT(changeTableContent(QTreeWidgetItem *, int)));
    connect(m_tableWidget, SIGNAL(itemChanged(QTableWidgetItem *)), this, SLOT(storeChangedItem(QTableWidgetItem *)));
}

ConfigurationWidget::~ConfigurationWidget()
{
    // Nothing to do
}

void ConfigurationWidget::setConfigurationParameters(ConfigurationParameters *conf)
{
    m_configurationParameters = conf;

    updateParameters();
}

void ConfigurationWidget::fillWidgetTree( QString groupName, QString groupFullPath, QTreeWidgetItem* root) {
    // Creating the item in the tree widget
    QTreeWidgetItem *widgetRoot = new QTreeWidgetItem(root, QStringList() << groupName);
    // Store the full group path for a fast retrieval of it
    widgetRoot->setData( 0, Qt::UserRole, groupFullPath );
    QStringList groupList = m_tmpParameters.getGroupsList( groupFullPath );
    foreach( QString group, groupList ) {
        fillWidgetTree( group, groupFullPath + ConfigurationParameters::GroupSeparator() + group, widgetRoot );
    }
}

void ConfigurationWidget::updateParameters()
{
    if (m_configurationParameters == NULL) {
        return;
    }

    // Resetting m_valuesChanged
    m_valuesChanged = false;

    // Copying configuration parameters to m_tmpParameters
    m_tmpParameters = *m_configurationParameters;

    // Removing everything from the tree
    m_treeWidget->clear();

    // Create the root node
    QTreeWidgetItem *widgetRoot = new QTreeWidgetItem(QStringList() << "root");
    widgetRoot->setData(0, Qt::UserRole, "");
    m_treeWidget->insertTopLevelItem(0, widgetRoot);
    // Filling the tree
    QStringList groupList = m_tmpParameters.getGroupsList( "" );
    foreach( QString group, groupList ) {
        fillWidgetTree( group, group, widgetRoot );
    }
    // Setting the current item to tree root
    m_treeWidget->setCurrentItem(m_treeWidget->topLevelItem(0));
    // Updating tree
    m_treeWidget->update();
    // Now filling table with root's properties
    changeTableContent(m_treeWidget->currentItem(), 0);
}

void ConfigurationWidget::setReadOnly(bool readOnly)
{
    m_readOnly = readOnly;

    // Changing the read-only flag of all items in the table
    for (int r = 0; r < m_tableWidget->rowCount(); r++) {
        QTableWidgetItem *const item = m_tableWidget->item(r, 1);
        if (m_readOnly) {
            item->setFlags(item->flags() & ~Qt::ItemIsEditable);
        } else {
            item->setFlags(item->flags() | Qt::ItemIsEditable);
        }
    }

    // Updating table
    m_tableWidget->update();
}

void ConfigurationWidget::store()
{
    if (m_configurationParameters == NULL) {
        return;
    }

    *m_configurationParameters = m_tmpParameters;

    // Resetting m_valuesChanged
    m_valuesChanged = false;
}

void ConfigurationWidget::restore()
{
    if (m_configurationParameters == NULL) {
        return;
    }

    m_tmpParameters = *m_configurationParameters;

    // Also resets m_valuesChanged
    updateParameters();
}

void ConfigurationWidget::changeTableContent(QTreeWidgetItem *item, int)
{
    // Blocking signals for the table until we finish modifications
    m_tableWidget->blockSignals(true);

    // Clearing the table
    m_tableWidget->clearContents();

    // Getting the group full path corresponding to item
    QString groupFullPath = item->data(0, Qt::UserRole).toString();

    // Now filling the table taking all parameters in node.
    QStringList paramList = m_tmpParameters.getParametersList( groupFullPath );
    m_tableWidget->setRowCount( paramList.size() );
    for (int i = 0; i < paramList.size(); i++) {
        // Parameter
        QTableWidgetItem *parameter = new QTableWidgetItem( paramList[i] );
        parameter->setFlags(Qt::ItemIsEnabled);
        m_tableWidget->setItem(i, 0, parameter);
        // Value
        QString fullName = groupFullPath + ConfigurationParameters::GroupSeparator() + paramList[i];
        QTableWidgetItem *value = new QTableWidgetItem( m_tmpParameters.getValue( fullName ) );
        value->setData( Qt::UserRole, fullName );
        if (m_readOnly) {
            value->setFlags(Qt::ItemIsEnabled);
        } else {
            value->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable);
        }
        m_tableWidget->setItem(i, 1, value);
    }

    // Re-enabling signals for the table
    m_tableWidget->blockSignals(false);

    // Updatig table
    m_tableWidget->update();
}

void ConfigurationWidget::storeChangedItem(QTableWidgetItem *item)
{
    // Only taking items in the second column into consideration
    if (item->column() != 1) {
        return;
    }

    // Getting the full name of parameter of corresponding to item
    QString paramFullName = item->data( Qt::UserRole ).toString();

    // Taking the parameter, its old and new value
    QString parameter = m_tableWidget->item(item->row(), 0)->text();
    QString oldValue = m_tmpParameters.getValue( paramFullName );
    QString newValue = item->text();

    // Changing parameter
    m_tmpParameters.setValue(paramFullName, newValue);

    // Setting m_valuesChanged to true
    m_valuesChanged = true;

    // Signalling the change
    emit valueHasChanged(paramFullName, oldValue, newValue);
}

} // end namespace farsa