/*

 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of "Eclipse Public License v1.0"

 * which accompanies this distribution, and is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description: caitemmodel.cpp

 *

 */

#include <HbIcon>

#include "caitemmodel.h"

#include "caitemmodel_p.h"

#include "canotifier.h"

#include "canotifierfilter.h"

#include "caclienttest_global.h"

// Constants

const QSize defaultIconSize(30, 30);

// ======== MEMBER FUNCTIONS ========

/*!

 *   \class CaItemModel

 *

 *   \brief This class provides model containing CaEntry class objects.

 *

 *   To create instance of CaItemModel object, you need to pass CaQuery

 *   object in constructor. CaQuery should describe items that you want

 *   to have in a model.

 *

 *   \example

 *   \code

 *

 *   CaQuery query;

 *   query.setFlagsOn(VisibleEntryFlag);

 *   query.setParentId(collectionId);

 *   CaItemModel* model = new CaItemModel(query, this);

 *

 *   \endcode

 */

/*!

 Constructor.

 \param query query describing entries that should be present in a model.

 \param parent parent of a model

 */

CaItemModel::CaItemModel(const CaQuery &query, QObject *parent) :

    QAbstractItemModel(parent), m_d(new CaItemModelPrivate(query, this))

{

}

/*!

 Destructor

 */

CaItemModel::~CaItemModel()

{

    delete m_d;

}

/*!

 Returns number of columns

 \param parent not used

 \retval 1

 \code

 ...

 // to get number of columns in a model

 int columns = model->columnCount();

 ...

 \endcode

 */

int CaItemModel::columnCount(const QModelIndex &parent) const

{

    Q_UNUSED(parent);

    //model keeps entries in a column 0 and a parent entry in a column 1

    //parent entry is treated as an invisible root item,

    //so column count is always 1

    return 1;

}

/*!

 Returns number of rows

 \param parent not used

 \retval number of rows

 \code

 ...

 // to get number of rows in a model

 int rows = model->rowCount();

 ...

 \endcode

 */

int CaItemModel::rowCount(const QModelIndex &parent) const

{

    Q_UNUSED(parent);

    return m_d->rowCount();

}

/*!

 Returns QModelIndex of an item

 \param row row in which an item is placed

 \param column not used

 \param parent not used

 \retval index of item in model

 \code

 ...

 // to get model index of an item

 QModelIndex modelIndex = model->index(5);

 ...

 \endcode

 */

QModelIndex CaItemModel::index(int row, int column,

                               const QModelIndex &parent) const

{

    Q_UNUSED(column);

    Q_UNUSED(parent);

    return m_d->index(row);

}

/*!

 Returns parent item

 \param child index (ignored)

 \retval parent index. in case of CaItemModel it is always QModelIndex()

 \code

 ...

 // to get model index of a parent of an item

 QModelIndex parentModelIndex = model->parent(childModelIndex);

 ...

 \endcode

 */

QModelIndex CaItemModel::parent(const QModelIndex &index) const

{

    Q_UNUSED(index);

    return QModelIndex();

}

/*!

 Returns root item model index

 \retval root item model index

 \code

 ...

 // to get model index of a root item

 QModelIndex rootIndex = model->root();

 ...

 \endcode

 */

QModelIndex CaItemModel::root() const

{

    return m_d->root();

}

/*!

 Returns appropiate model's data

 \param index model index

 \param role which data role to return

 \retval models data

 \code

 ...

 // to get data for model item

 QVariant = model->data(itemModelIndex, Qt::DisplayRole);

 ...

 \endcode

 */

QVariant CaItemModel::data(const QModelIndex &index, int role) const

{

    return m_d->data(index, role);

}

/*!

 Disables or enables auto-update feature of the model

 \param autoUpdate true to enable autoupdate, false to disable

 \code

 ...

 // to enable model auto update

 model->setAutoUpdate(true);

 ...

 \endcode

 */

void CaItemModel::setAutoUpdate(bool autoUpdate)

{

    m_d->setAutoUpdate(autoUpdate);

}

/*!

 Disables or enables secondline feature of the model

 \param secondLine enable or disable second line

 \code

 ...

 // to enable model second line visibility

 model->setSecondLineVisibility(true);

 ...

 \endcode

 */

void CaItemModel::setSecondLineVisibility(bool secondLineVisible)

{

    m_d->setSecondLineVisibility(secondLineVisible);

}

/*!

 Gets second line visibility attribute

 \retrun second line visibility attribute

 \code

 ...

 // to check second line visibility attribute

 bool visibility = model->secondLineVisibility();

 ...

 \endcode

 */

bool CaItemModel::secondLineVisibility() const

{

    return m_d->secondLineVisibility();

}

/*!

 Returns auto update status

 \retval true if autoupdate is on, false if not

 \code

 ...

 // to check auto update attribute

 bool autoUpdate = model->isAutoUpdate();

 ...

 \endcode

 */

bool CaItemModel::isAutoUpdate() const

{

    return m_d->notifierExists();

}

/*!

 Method for setting sorting order on model

 \param sortAttribute sort attribute (by name, timestamp, ect...)

 \param sortOrder sort order (ascending, descending)

 \code

 ...

 // to set sort order in a model

 model->setSort(NameSortAttribute, Qt::Ascending);

 ...

 \endcode

 */

void CaItemModel::setSort(SortAttribute sortAttribute,

                          Qt::SortOrder sortOrder)

{

    m_d->setSort(sortAttribute, sortOrder);

}

/*!

 Method for setting icon size

 \param  size icon size to display

 \code

 ...

 // to set an icon size in a model

 QSize iconSize(50,50);

 model->setIconSize(iconSize);

 ...

 \endcode

 */

void CaItemModel::setIconSize(const QSize &size)

{

    m_d->setIconSize(size);

}

/*!

 Method for getting icon size

 \param  size icon size to display

 */

QSize CaItemModel::getIconSize() const

{

    return m_d->getIconSize();

}

/*!

 Updates model with fresh entries

 \code

 ...

 // to refresh a model

 model->updateModel();

 ...

 \endcode

 */

void CaItemModel::updateModel()

{

    m_d->updateModel();

}

/*!

 Sets parent and fetch children items from a storage

 \param parentId id of a collection

 \code

 ...

 // to set a new parent id

 int newParentId = 10;

 model->setParentId(newParentId);

 ...

 \endcode

 */

void CaItemModel::setParentId(int parentId)

{

    m_d->setParentId(parentId);

}

/*!

 Sets flags to mQuery which should be enabled.

 This method does not update current model - only mQuery member.

 Now to do this setParentId have to be invoke.

 \param onFlags flags.

 \code

 ...

 // to set a flags enabled

 model->setFlagsOn(RemovableEntryFlag);

 ...

 \endcode

 */

void CaItemModel::setFlagsOn(const EntryFlags &onFlags)

{

    m_d->setFlagsOn(onFlags);

}

/*!

 Sets flags to mQuery which should be disabled.

 This method does not update current model - only mQuery member.

 Now to do this setParentId have to be invoke.

 \param offFlags flags.

 \code

 ...

 // to set a flags disabled

 model->setFlagsOff(RemovableEntryFlag);

 ...

 \endcode

 */

void CaItemModel::setFlagsOff(const EntryFlags &offFlags)

{

    m_d->setFlagsOff(offFlags);

}

/*!

 Returns an entry from model

 \param index of entry in model

 \retval pointer to an entry

 \code

 ...

 // to get an entry from a model

 CaEntry* entry = model->entry(entryModelIndex);

 ...

 delete entry;

 \endcode

 */

QSharedPointer<CaEntry> CaItemModel::entry(const QModelIndex &index) const

{

    return m_d->entry(index);

}

/*!

 Constructor

 \param query needed to create model

 \param pointer to public implementation object connected

 */

CaItemModelPrivate::CaItemModelPrivate(const CaQuery &query,

                                       CaItemModel *itemModelPublic) :

    QObject(), m_q(itemModelPublic), mParentEntry(), mQuery(query),

    mService(CaService::instance()), mEntries(mService), mNotifier(NULL),

    mSize(defaultIconSize), mSecondLineVisibility(true)

{

    updateModel();

    setAutoUpdate(true);

}

/*!

 Destructor

 */

CaItemModelPrivate::~CaItemModelPrivate()

{

    mEntries.clear();

    delete mNotifier;

}

/*!

 Returns count of rows in model

 \retval number of rows

 */

int CaItemModelPrivate::rowCount() const

{

    return mEntries.count();

}

/*!

 Returns QModelIndex of an item

 \param row row

 \retval QModelIndex of item in model

 */

QModelIndex CaItemModelPrivate::index(int row)

{

    if ((row >= 0) && (row < mEntries.count())) {

        return m_q->createIndex(row, 0);

    } else {

        return QModelIndex();

    }

}

/*!

 Returns appropiate model's data

 \param modelIndex model index

 \param role which data role to return

 \retval models data as QVariant

 */

QVariant CaItemModelPrivate::data(const QModelIndex &modelIndex,

                                  int role) const

{

    CACLIENTTEST_FUNC_ENTRY("CaItemModelPrivate::data");

    QVariant variant;

    if (modelIndex.isValid()) {

        switch (role) {

        case Qt::DisplayRole:

            variant = displayRole(modelIndex);

            break;

        case Qt::DecorationRole:

            variant = QVariant(HbIcon(entry(modelIndex)->makeIcon(mSize)));

            break;

        case CaItemModel::IdRole:

            variant = QVariant(entry(modelIndex)->id());

            break;

        case CaItemModel::TypeRole:

            variant = QVariant(entry(modelIndex)->entryTypeName());

            break;

        case CaItemModel::FlagsRole:

            variant = qVariantFromValue(entry(modelIndex)->flags());

            break;

        case CaItemModel::TextRole:

            variant = QVariant(entry(modelIndex)->text());

            break;

        case CaItemModel::FullTextRole:

            variant = QVariant(entry(modelIndex)->text() + QString(" ")

                + entry(modelIndex)->description());

            break;

        default:

            variant = QVariant(QVariant::Invalid);

        }

    }

    CACLIENTTEST_FUNC_EXIT("CaItemModelPrivate::data");

    return variant;

}

/*!

 Disables or enables auto-update feature of the model

 \param autoUpdate (HsMenuAutoUpdate)

 */

void CaItemModelPrivate::setAutoUpdate(bool autoUpdate)

{

    CACLIENTTEST_FUNC_ENTRY("CaItemModelPrivate::setAutoUpdate");

    if (autoUpdate) {

        if (!mNotifier) {

            CaNotifierFilter filter(mQuery);

            mNotifier = mService->createNotifier(filter);

            connectSlots();

        }

    } else {

        disconnectSlots();

        delete mNotifier;

        mNotifier = NULL;

    }

    CACLIENTTEST_FUNC_EXIT("CaItemModelPrivate::setAutoUpdate");

}

/*!

 Method for setting sorting order on model

 (probably will be moved to MenuService)

 \param  sortOrder sorting order (SortAttribute)

 */

void CaItemModelPrivate::setSort(SortAttribute sortAttribute,

                                 Qt::SortOrder sortOrder)

{

    CACLIENTTEST_FUNC_ENTRY("CaItemModelPrivate::setSort");

    mQuery.setSort(sortAttribute, sortOrder);

    updateLayout();

    CACLIENTTEST_FUNC_EXIT("CaItemModelPrivate::setSort");

}

/*!

 Method for setting icon size

 \param size icon size to display

 */

void CaItemModelPrivate::setIconSize(const QSize &size)

{

    if (mSize == size)

        return;

    m_q->layoutAboutToBeChanged();

    mSize = size;

    m_q->layoutChanged();

}