/********************************************************************************************************
 * PROGRAM      : essai8
 * DATE - TIME  : mardi 12 février 2008 - 21h44
 * AUTHOR       :  (  )
 * FILENAME     : StandardEtatModel.cpp
 * LICENSE      : GPL
 * COMMENTARY   : 
 ********************************************************************************************************/

#include <QtGui>
#include <QAbstractItemModel>

#include "StandardEtatModel.h"

/********************************************************************************************************
 ********************************************************************************************************/
CStandardEtat::CStandardEtat(CStandardEtat *ptParent)
{
	m_ptParentItem = ptParent;
}

/********************************************************************************************************
 ********************************************************************************************************/
void CStandardEtat::appendChild(CStandardEtat *ptItem)
{
//	qDebug() << "## CStandardEtat::appendChild";
    m_ChildEtats.append(ptItem);
}

/********************************************************************************************************
 ********************************************************************************************************/
CStandardEtat *CStandardEtat::Child(int row)
{
//	qDebug() << "## CStandardEtat::Child";
    return m_ChildEtats.value(row);
}

/********************************************************************************************************
 ********************************************************************************************************/
int CStandardEtat::childCount()
{
//	qDebug() << "## CStandardEtat::childCount : " << m_ChildEtats.count();
    return m_ChildEtats.count();
}

/********************************************************************************************************
 ********************************************************************************************************/
int CStandardEtat::columnCount()
{
	return 1;
}

/********************************************************************************************************
 ********************************************************************************************************/
QVariant CStandardEtat::Data(int role)
{
	switch (role) {
		case TypeEtatRole :
				return m_TypeEtat;
		case Qt::DisplayRole :
				return m_Nom;
		case Qt::FontRole :
				return m_Font;
		case Qt::ForegroundRole :
				return m_TextColor;
	}
	return QVariant();
}

/********************************************************************************************************
 ********************************************************************************************************/
TypeEtat CStandardEtat::typeEtat()
{
	return (TypeEtat)Data(TypeEtatRole).toInt();
}

/********************************************************************************************************
 ********************************************************************************************************/
QString CStandardEtat::Nom()
{
	return Data(Qt::DisplayRole).toString();
}

/********************************************************************************************************
 ********************************************************************************************************/
CStandardEtat *CStandardEtat::Parent()
{
//	qDebug() << "## CStandardEtat::Parent";
	return m_ptParentItem;
}

/********************************************************************************************************
 ********************************************************************************************************/
int CStandardEtat::Row()
{
//	qDebug() << "## CStandardEtat::Row";
	if (m_ptParentItem != 0)
		return m_ptParentItem->m_ChildEtats.indexOf(const_cast<CStandardEtat*>(this));

    return 0;
}

/********************************************************************************************************
 ********************************************************************************************************/
bool CStandardEtat::State()
{
    return m_State;
}

/********************************************************************************************************
 ********************************************************************************************************/
void CStandardEtat::setState(bool newState)
{
    m_State = newState;
}

/********************************************************************************************************
 ********************************************************************************************************/
void CStandardEtat::setupEtat(QString Nom, TypeEtat Type)
{
	m_Nom = Nom;
	m_TypeEtat = Type;
	m_Font = QApplication::font();
	m_State = true;
	if ((Type == Etat) || (Type == Root)) {
		m_TextColor.setColor(Qt::darkYellow);
	}
	else {
		m_TextColor.setColor(Qt::black);
	}
}

/********************************************************************************************************
 ********************************************************************************************************
                                            CStandardEtatModel
 ********************************************************************************************************
 ********************************************************************************************************/

/********************************************************************************************************
 ********************************************************************************************************/
CStandardEtatModel::CStandardEtatModel(CDomEtats *ptDomEtats)
{
	m_ptDomEtats = ptDomEtats;

	m_ptRootEtat = new CStandardEtat();
	
	if (m_ptRootEtat != 0) {
		m_ptRootVisible = new CStandardEtat(m_ptRootEtat);
		if (m_ptRootVisible != 0) {
			m_ptRootVisible->setupEtat(QString("Livre des états"), Root);
			m_ptRootEtat->appendChild(m_ptRootVisible);
			setupModel(m_ptRootVisible);
		}
	}
}

/********************************************************************************************************
 ********************************************************************************************************/
QModelIndex CStandardEtatModel::rootIndex()
{
	return createIndex (0, 0, m_ptRootVisible);
}

/********************************************************************************************************
 ********************************************************************************************************/
void CStandardEtatModel::setupModel(CStandardEtat *ptParentItem, CInfoEtat *ptParentInfo)
{
	bool				 rep;
	CInfoEtat 		*ptInfoEtat;
	CStandardEtat 	*ptItemEtat;

	ptInfoEtat = new CInfoEtat (m_ptDomEtats);
	rep = ptInfoEtat->First(ptParentInfo);
	while (rep) {
		ptItemEtat = new CStandardEtat(ptParentItem);
		ptItemEtat->setupEtat(ptInfoEtat->Nom(), ptInfoEtat->Type());
		ptParentItem->appendChild(ptItemEtat);

		setupModel(ptItemEtat, ptInfoEtat);
		rep = ptInfoEtat->Next(ptParentInfo);
	}
}

/********************************************************************************************************
 ********************************************************************************************************/
bool CStandardEtatModel::insertRows(int row, int count, const QModelIndex &indexParent)
{
	CStandardEtat *ptParent;

	ptParent = static_cast<CStandardEtat*>(indexParent.internalPointer());

	beginInsertRows(indexParent, rowCount(indexParent), rowCount(indexParent));
	ptParent->appendChild(m_ptChildAdded);
	endInsertRows();
	return true;
}

/********************************************************************************************************
 ********************************************************************************************************/
bool CStandardEtatModel::addRow(const QModelIndex &indexParent, QString Nom, TypeEtat Type)
{
	CStandardEtat *ptParent;

	ptParent = static_cast<CStandardEtat*>(indexParent.internalPointer());

	m_ptChildAdded = new CStandardEtat(ptParent);
	if (m_ptChildAdded != 0) {
		m_ptChildAdded->setupEtat(Nom, Type);
		return insertRows (0, 1, indexParent);
	}
	return false;
}

/********************************************************************************************************
 ********************************************************************************************************/
bool CStandardEtatModel::setData(const QModelIndex &Index, const QVariant &Value, int role)
{
	CStandardEtat *ptIndex;

	if (!Index.isValid()) {
		qDebug() << "## CStandardEtatModel::setData invalide";
		return false;
	}

	ptIndex = static_cast<CStandardEtat*>(Index.internalPointer());

	// Qt::Unchecked = 0, Qt::Checked = 2
	if (ptIndex->typeEtat() != Root) {
		ptIndex->setState(((Qt::CheckState)Value.toInt() == Qt::Unchecked) ? false : true);
		qDebug() << "## CStandardEtatModel::setData : valeur =" << Value.toInt() << " text = " << ptIndex->Nom();
		emit dataChanged (Index, Index);
		return true;
	}
	return false;
}

/********************************************************************************************************
 ********************************************************************************************************/
int CStandardEtatModel::columnCount(const QModelIndex &Parent) const
{
	return 1;
}

/********************************************************************************************************
 ********************************************************************************************************/
QVariant CStandardEtatModel::data(const QModelIndex &index, int role) const
{
	CStandardEtat *ptItem;

	if (!index.isValid())
		return QVariant();

	if ((role != Qt::DisplayRole) && (role != TypeEtatRole) && (role != Qt::FontRole) && (role !=Qt::ForegroundRole) && (role != Qt::CheckStateRole))
		return QVariant();

	ptItem = static_cast<CStandardEtat*>(index.internalPointer());

	if (ptItem != 0) {
		if (role == Qt::CheckStateRole) {
			qDebug() << "## CStandardEtatModel::data = " << ptItem->State() << "text = " << ptItem->Nom();
			return (ptItem->State() == false) ? Qt::Unchecked : Qt::Checked;
		}
		return ptItem->Data(role);
	}

	return QVariant();
}

/********************************************************************************************************
 ********************************************************************************************************/
Qt::ItemFlags CStandardEtatModel::flags(const QModelIndex &index) const
{
	if (!index.isValid()) {
//		qDebug() << "## CStandardEtatModel::flags invalid";
//		return 0;
	return Qt::ItemIsEnabled | Qt::ItemIsUserCheckable | Qt::ItemIsSelectable;
	}
//	qDebug() << "## CStandardEtatModel::flags valid";
	return Qt::ItemIsEnabled | Qt::ItemIsUserCheckable | Qt::ItemIsSelectable;
}

/********************************************************************************************************
 ********************************************************************************************************/
QVariant CStandardEtatModel::headerData(int section, Qt::Orientation orientation, int role) const
{
	return QVariant();
}

/********************************************************************************************************
 ********************************************************************************************************/
QModelIndex CStandardEtatModel::index(int row, int column, const QModelIndex &parent) const
{
	CStandardEtat *ptParentItem, *ptChildItem;

	if (!hasIndex(row, column, parent))
		return QModelIndex();

	if (!parent.isValid())
		ptParentItem = m_ptRootEtat;
	else
		ptParentItem = static_cast<CStandardEtat*>(parent.internalPointer());

	ptChildItem = ptParentItem->Child(row);
	if (ptChildItem)
		return createIndex(row, column, ptChildItem);
	else
		return QModelIndex();
}

/********************************************************************************************************
 ********************************************************************************************************/
QModelIndex CStandardEtatModel::parent(const QModelIndex &index) const
{
	CStandardEtat *ptParentItem, *ptChildItem;

//	qDebug() << "## CStandardEtatModel::parent";

	if (!index.isValid())
		return QModelIndex();

	ptChildItem = static_cast<CStandardEtat*>(index.internalPointer());
	ptParentItem = ptChildItem->Parent();

	if (ptParentItem == m_ptRootEtat)
		return QModelIndex();

	return createIndex(ptParentItem->Row(), 0, ptParentItem);
}

/********************************************************************************************************
 ********************************************************************************************************/
int CStandardEtatModel::rowCount(const QModelIndex &parent) const
{
	CStandardEtat *ptParentItem;

	if (parent.column() > 0)
		return 0;

	if (!parent.isValid())
		ptParentItem = m_ptRootEtat;
	else
		ptParentItem = static_cast<CStandardEtat*>(parent.internalPointer());

	return ptParentItem->childCount();
}