valentina/src/libs/vpropertyexplorer/vpropertymodel.cpp
dismine 9a735b29bf Unix Line Endings.
--HG--
branch : develop
2014-09-10 18:27:45 +03:00

307 lines
8.6 KiB
C++

/************************************************************************
**
** @file vpropertymodel.cpp
** @author hedgeware <internal(at)hedgeware.net>
** @date
**
** @brief
** @copyright
** All rights reserved. This program and the accompanying materials
** are made available under the terms of the GNU Lesser General Public License
** (LGPL) version 2.1 which accompanies this distribution, and is available at
** http://www.gnu.org/licenses/lgpl-2.1.html
**
** 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 for more details.
**
*************************************************************************/
#include "vpropertymodel.h"
#include <QBrush>
#include "vpropertyset.h"
using namespace VPE;
#include "vpropertymodel_p.h"
VPropertyModel::VPropertyModel(VPropertyModelPrivate *d, QObject *parent)
: QAbstractItemModel(parent), d_ptr(d)
{
}
VPropertyModel::VPropertyModel(QObject * parent) :
QAbstractItemModel(parent), d_ptr(new VPropertyModelPrivate())
{
}
VPropertyModel::~VPropertyModel()
{
if(d_ptr->Properties)
delete d_ptr->Properties;
delete d_ptr;
}
//! Adds the property to the model and attaches it to the parentid
bool VPropertyModel::addProperty(VProperty* property, const QString& id, const QString &parentid, bool emitsignals)
{
if(!property)
return false;
if(!d_ptr->Properties) // If not existant, create property set
d_ptr->Properties = new VPropertySet();
if(emitsignals) {
VProperty* tmpParent = getProperty(parentid);
int tmpRow = tmpParent != nullptr ? tmpParent->getRowCount() : d_ptr->Properties->getRootPropertyCount();
beginInsertRows((tmpParent != nullptr ? getIndexFromProperty(tmpParent) : QModelIndex()), tmpRow, tmpRow);
}
d_ptr->Properties->addProperty(property, id, parentid);
if(emitsignals)
endInsertRows();
return true;
}
//! Creates a property and adds it to the model
VProperty* VPropertyModel::createProperty(const QString& id, const QString& name, const QString& parentid, const QVariant& data)
{
VProperty* tmpProp = new VProperty(name);
tmpProp->setValue(data);
if(tmpProp && addProperty(tmpProp, id, parentid))
return tmpProp;
else
return nullptr;
}
//! Gets a property by it's ID
VProperty* VPropertyModel::getProperty(const QString& id)
{
return d_ptr->Properties != nullptr ? d_ptr->Properties->getProperty(id) : nullptr;
}
//! Returns the model index at row/column
QModelIndex VPropertyModel::index(int row, int column, const QModelIndex& parent) const
{
if (d_ptr->Properties == nullptr || (parent.isValid() && parent.column() > 1))
return QModelIndex();
if(parent.isValid()) {
// Get the parent index
VProperty* parentItem = getProperty(parent);
if(parentItem) {
VProperty* childItem = parentItem->getChild(row);
if (childItem)
return createIndex(row, column, childItem);
}
} else if(row >= 0 && row < d_ptr->Properties->count()) {
return createIndex(row, column, d_ptr->Properties->getRootProperty(row));
}
return QModelIndex();
}
//! Returns the parent of one model index
QModelIndex VPropertyModel::parent ( const QModelIndex & index ) const
{
if (!index.isValid())
return QModelIndex();
VProperty* childItem = getProperty(index);
if(childItem) {
VProperty* parentItem = childItem->getParent();
if(parentItem) {
VProperty* grandParentItem = parentItem->getParent();
int parents_row = grandParentItem != nullptr ? grandParentItem->getChildRow(parentItem) : d_ptr->Properties->getRootProperties().indexOf(parentItem);
if(parents_row >= 0)
return createIndex(parents_row, 0, parentItem);
}
}
return QModelIndex();
}
//! Returns the item flags for the given index
Qt::ItemFlags VPropertyModel::flags (const QModelIndex& index) const
{
VProperty* tmpProperty = getProperty(index);
if(!tmpProperty)
return Qt::NoItemFlags;
else
return tmpProperty->flags(index.column());
}
//! Sets the role data for the item at index to value
bool VPropertyModel::setData (const QModelIndex& index, const QVariant& value, int role)
{
VProperty* tmpProperty = getProperty(index);
if(index.column() == 1 && tmpProperty) {
bool tmpHasChanged = tmpProperty->setData(value, role);
if(tmpProperty->getUpdateParent() && tmpHasChanged) { // If neccessary, update the parent as well
QModelIndex tmpParentIndex = parent(index);
emit dataChanged(tmpParentIndex, tmpParentIndex);
}
if(tmpHasChanged)
emit onDataChangedByEditor(tmpProperty);
}
return true;
}
//! Returns the data of an model index
QVariant VPropertyModel::data ( const QModelIndex & index, int role ) const
{
VProperty* tmpProperty = getProperty(index);
if(!tmpProperty)
return QVariant();
else
return tmpProperty->data(index.column(), role);
}
QVariant VPropertyModel::headerData (int section, Qt::Orientation orientation, int role) const
{
if(orientation == Qt::Horizontal && role == Qt::DisplayRole) {
// Header data
if (section == 0) return d_ptr->HeadlineProperty;
else if (section == 1) return d_ptr->HeadlineValue;
}
else if(role == Qt::DisplayRole)
return QVariant(section);
return QVariant();
}
//! Returns the number of rows
int VPropertyModel::rowCount ( const QModelIndex & parent ) const
{
if(parent.isValid()) {
VProperty* tmpParent = getProperty(parent);
if(tmpParent)
return tmpParent->getRowCount();
}
// Return the root property count
if(d_ptr->Properties)
return d_ptr->Properties->getRootPropertyCount();
return 0;
}
//! Returns the number of columns
int VPropertyModel::columnCount ( const QModelIndex & parent) const
{
Q_UNUSED(parent);
return 2;
}
//! Gets a property by its ModelIndex
VProperty* VPropertyModel::getProperty(const QModelIndex &index) const
{
if (index.isValid()) {
VProperty* prop = static_cast<VProperty*>(index.internalPointer());
if (prop)
return prop;
}
return nullptr;
}
QString VPropertyModel::getPropertyID(VProperty *prop) const
{
return d_ptr->Properties != nullptr ? d_ptr->Properties->getPropertyID(prop) : QString();
}
QModelIndex VPropertyModel::getIndexFromProperty(VProperty* property, int column) const
{
if (!property || column > columnCount() || column < 0)
return QModelIndex();
VProperty* parentItem = property->getParent();
int row = 0;
if(parentItem) {
row = parentItem->getChildRow(property);
}
return createIndex(row, column, property);
}
void VPropertyModel::onDataChangedByModel(VProperty* property)
{
QModelIndex tmpIndex = getIndexFromProperty(property, 1);
if(tmpIndex.isValid())
{
emit dataChanged(tmpIndex, tmpIndex);
emit onDataChangedByEditor(property);
}
}
const VPropertySet *VPropertyModel::getPropertySet() const
{
return d_ptr->Properties;
}
void VPropertyModel::clear(bool emit_signals)
{
setPropertySet(nullptr, emit_signals);
}
VPropertySet *VPropertyModel::takePropertySet(VPropertySet *new_property_set, bool emit_signals)
{
VPropertySet* tmpOldPropertySet = d_ptr->Properties;
if(emit_signals) emit beginResetModel();
d_ptr->Properties = new_property_set;
if(emit_signals) emit endResetModel();
return tmpOldPropertySet;
}
void VPropertyModel::setPropertySet(VPropertySet *property_set, bool emit_signals)
{
VPropertySet* tmpOldPropertySet = takePropertySet(property_set, emit_signals);
if(tmpOldPropertySet)
delete tmpOldPropertySet;
}
VProperty *VPropertyModel::takeProperty(const QString &id)
{
QModelIndex tmpIndex = getIndexFromProperty(getProperty(id));
if(d_ptr->Properties && tmpIndex.isValid()) {
beginRemoveRows(tmpIndex.parent(), tmpIndex.row(), tmpIndex.row());
VProperty* tmpProp = d_ptr->Properties->takeProperty(id);
endRemoveRows();
return tmpProp;
}
return nullptr;
}
void VPropertyModel::removeProperty(const QString &id)
{
QModelIndex tmpIndex = getIndexFromProperty(getProperty(id));
if(d_ptr->Properties && tmpIndex.isValid()) {
beginRemoveRows(tmpIndex.parent(), tmpIndex.row(), tmpIndex.row());
d_ptr->Properties->removeProperty(id);
endRemoveRows();
}
}