videocollection/videocollectionwrapper/tsrc/testvideosortfilterproxymodel/stub/src/videolistdatamodel.cpp
/**
* 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: Stub model to be used when unit testing videocollectionsortfilterproxy
*
*/
// INCLUDES
#include "videocollectionclient.h"
#include "videolistdatamodel.h"
bool VideoListDataModel::mInitFails = false;
bool VideoListDataModel::mRemoveRowsFails = false;
bool VideoListDataModel::mGetMediaIdAtIndexFails = false;
bool VideoListDataModel::mBelongsToAlbum = false;
bool VideoListDataModel::mReturnInvalid = false;
int VideoListDataModel::mRemoveFrAlbumReturn = -1;
int VideoListDataModel::mLastDeletedIndexRow = -1;
QString VideoListDataModel::mMediaFilePathReturnValue = "";
// ---------------------------------------------------------------------------
// VideoListDataModel
// ---------------------------------------------------------------------------
//
VideoListDataModel::VideoListDataModel(QObject *parent) :
QAbstractItemModel(parent),
mCollectionClient(0)
{
}
// ---------------------------------------------------------------------------
// ~VideoListDataModel
// ---------------------------------------------------------------------------
//
VideoListDataModel::~VideoListDataModel()
{
removeAll();
delete mCollectionClient;
}
// -----------------------------------------------------------------------------
// initialize
// -----------------------------------------------------------------------------
//
int VideoListDataModel::initialize()
{
if(mInitFails)
{
return -1;
}
return 0;
}
// ---------------------------------------------------------------------------
// mediaIdAtIndex
// ---------------------------------------------------------------------------
//
TMPXItemId VideoListDataModel::mediaIdAtIndex(int index) const
{
TMPXItemId id = TMPXItemId::InvalidId();
if( mGetMediaIdAtIndexFails || index < 0 || index >= mData.count())
{
return id;
}
id = mData.at(index)->mId;
return id;
}
// ---------------------------------------------------------------------------
// mediaFilePathForId
// ---------------------------------------------------------------------------
//
QString VideoListDataModel::mediaFilePathForId(int mediaId) const
{
Q_UNUSED(mediaId);
return mMediaFilePathReturnValue;
}
// ---------------------------------------------------------------------------
// removeRows
// ---------------------------------------------------------------------------
//
bool VideoListDataModel::removeRows(const QModelIndexList &indexList)
{
mLastDeletedIndexRow = -1;
if( mRemoveRowsFails )
return false;
else
{
if(indexList.count() > 0)
{
mLastDeletedIndexRow = indexList.at(indexList.count() - 1).row();
}
QModelIndexList sortable(indexList);
qSort(sortable);
QModelIndexList::const_iterator iter = sortable.constEnd();
QModelIndex index;
while(iter != sortable.constBegin())
{
iter--;
index = (*iter);
beginRemoveRows(QModelIndex(), index.row(), index.row());
delete mData.at(index.row());
mData.removeAt(index.row());
endRemoveRows();
}
return true;
}
}
// ---------------------------------------------------------------------------
// getCollectionClient
// ---------------------------------------------------------------------------
//
VideoCollectionClient* VideoListDataModel::getCollectionClient()
{
if(!this->mCollectionClient)
{
mCollectionClient = new VideoCollectionClient();
}
return mCollectionClient;
}
// ---------------------------------------------------------------------------
// rowCount
// ---------------------------------------------------------------------------
//
int VideoListDataModel::rowCount(const QModelIndex &parent) const
{
if (parent.isValid())
{
return 0;
}
return mData.count();
}
// ---------------------------------------------------------------------------
// itemData
// ---------------------------------------------------------------------------
//
QMap<int, QVariant> VideoListDataModel::itemData(const QModelIndex &index) const
{
Q_UNUSED(index);
QMap<int, QVariant> itemData;
return itemData;
}
// ---------------------------------------------------------------------------
// data
// ---------------------------------------------------------------------------
//
QVariant VideoListDataModel::data(const QModelIndex & index, int role) const
{
QVariant returnValue = QVariant();
if(!index.isValid())
{
return returnValue;
}
if(mReturnInvalid)
{
return returnValue;
}
int row = index.row();
if(role == VideoCollectionCommon::KeyTitle)
{
if(row >= 0 && row < mData.count())
{
returnValue = mData.at(row)->mName;
}
}
else if(role == VideoCollectionCommon::KeySizeValue ||
role == VideoCollectionCommon::KeyNumberOfItems)
{
if(row >= 0 && row < mData.count())
{
returnValue = mData.at(row)->mSize;
}
}
else if(role == VideoCollectionCommon::KeyDateTime)
{
if(row >= 0 && row < mData.count())
{
returnValue = mData.at(row)->mDate;
}
}
else if(role == VideoCollectionCommon::KeyStatus)
{
if(row >= 0 && row < mData.count())
{
returnValue = mData.at(row)->mStatus;
}
}
else if(role == INVALID_ROLE_FOR_SORTING)
{
if(row >= 0 && row < mData.count())
{
returnValue = mData.at(row)->mName;
}
}
return returnValue;
}
// ---------------------------------------------------------------------------
// columnCount
// ---------------------------------------------------------------------------
//
int VideoListDataModel::columnCount(const QModelIndex & parent) const
{
if (parent.isValid())
{
return 0;
}
else
{
return 1;
}
}
// ---------------------------------------------------------------------------
// index
// ---------------------------------------------------------------------------
//
QModelIndex VideoListDataModel::index(int row, int column, const QModelIndex & parent) const
{
Q_UNUSED(parent);
if(row >= 0 && row < mData.count())
{
return createIndex(row, column);
}
return QModelIndex();
}
// ---------------------------------------------------------------------------
// parent
// ---------------------------------------------------------------------------
//
QModelIndex VideoListDataModel::parent(const QModelIndex & index) const
{
Q_UNUSED(index);
return QModelIndex();
}
void VideoListDataModel::removeAll()
{
beginRemoveRows(QModelIndex(), 0,0);
QList<DummyData*>::iterator iter = mData.begin();
while(iter != mData.end())
{
delete *iter;
++iter;
}
mData.clear();
endRemoveRows();
}
// ---------------------------------------------------------------------------
// emitAlbumChanged
// ---------------------------------------------------------------------------
//
void VideoListDataModel::emitAlbumChanged()
{
emit albumChanged();
}
// ---------------------------------------------------------------------------
// appendData
// ---------------------------------------------------------------------------
//
void VideoListDataModel::appendData(TMPXItemId data)
{
DummyData* obj;
for(int i = 0; i < mData.count(); ++i)
{
obj = mData.at(i);
if(obj->mId == TMPXItemId::InvalidId() || obj->mId.iId1 == data.iId1)
{
obj->mId = data;
QModelIndex change = index(i,0);
emit dataChanged(change, change);
return;
}
}
beginInsertRows(QModelIndex(), mData.count(), mData.count());
obj = new DummyData;
obj->mId = data;
mData.append(obj);
endInsertRows();
}
// ---------------------------------------------------------------------------
// appendData
// ---------------------------------------------------------------------------
//
void VideoListDataModel::appendData(QString data)
{
DummyData* obj;
for(int i = 0; i < mData.count(); ++i)
{
obj = mData.at(i);
if(!obj->mName.length())
{
obj->mName = data;
QModelIndex change = index(i,0);
emit dataChanged(change, change);
return;
}
}
beginInsertRows(QModelIndex(), mData.count(), mData.count());
obj = new DummyData;
obj->mId = TMPXItemId( mData.count(), 0);
obj->mName = data;
mData.append(obj);
endInsertRows();
}
// ---------------------------------------------------------------------------
// appendData
// ---------------------------------------------------------------------------
//
void VideoListDataModel::appendData(uint data)
{
DummyData* obj;
for(int i = 0; i < mData.count(); ++i)
{
obj = mData.at(i);
if(obj->mSize == 666)
{
obj->mSize = data;
QModelIndex change = index(i,0);
emit dataChanged(change, change);
return;
}
}
beginInsertRows(QModelIndex(), mData.count(), mData.count());
obj = new DummyData;
obj->mId = TMPXItemId( mData.count(), 0);
obj->mSize = data;
mData.append(obj);
endInsertRows();
}
// ---------------------------------------------------------------------------
// appendData
// ---------------------------------------------------------------------------
//
void VideoListDataModel::appendData(QDateTime data)
{
DummyData* obj;
for(int i = 0; i < mData.count(); ++i)
{
obj = mData.at(i);
if(!obj->mDate.isValid())
{
obj->mDate = data;
QModelIndex change = index(i,0);
emit dataChanged(change, change);
return;
}
}
beginInsertRows(QModelIndex(), mData.count(), mData.count());
obj = new DummyData;
obj->mId = TMPXItemId( mData.count(), 0);
obj->mDate = data;
mData.append(obj);
endInsertRows();
}
// ---------------------------------------------------------------------------
// appendStatus
// ---------------------------------------------------------------------------
//
void VideoListDataModel::appendStatus(int status)
{
DummyData* obj;
for(int i = 0; i < mData.count(); ++i)
{
obj = mData.at(i);
if(obj->mStatus == -1)
{
obj->mStatus = status;
QModelIndex change = index(i,0);
emit dataChanged(change, change);
return;
}
}
beginInsertRows(QModelIndex(), mData.count(), mData.count());
obj = new DummyData;
obj->mId = TMPXItemId( mData.count(), 0);
obj->mStatus = status;
mData.append(obj);
endInsertRows();
}
// ---------------------------------------------------------------------------
// setAlbumInUse
// ---------------------------------------------------------------------------
//
void VideoListDataModel::setAlbumInUse(TMPXItemId itemId)
{
mAlbumInUse = itemId;
}
// ---------------------------------------------------------------------------
// albumInUse
// ---------------------------------------------------------------------------
//
TMPXItemId VideoListDataModel::albumInUse()
{
return mAlbumInUse;
}
// ---------------------------------------------------------------------------
// belongsToAlbum
// ---------------------------------------------------------------------------
//
bool VideoListDataModel::belongsToAlbum(TMPXItemId itemId, TMPXItemId albumId )
{
Q_UNUSED(itemId);
Q_UNUSED(albumId);
return mBelongsToAlbum;
}
// ---------------------------------------------------------------------------
// removeItemsFromAlbum
// ---------------------------------------------------------------------------
//
int VideoListDataModel::removeItemsFromAlbum(TMPXItemId &albumId, const QList<TMPXItemId> &items)
{
Q_UNUSED(albumId);
Q_UNUSED(items);
return mRemoveFrAlbumReturn;
}
// ---------------------------------------------------------------------------
// indexOfId
// ---------------------------------------------------------------------------
//
QModelIndex VideoListDataModel::indexOfId(TMPXItemId id)
{
QModelIndex itemIndex;
DummyData* obj;
for(int i = 0; i < mData.count(); ++i)
{
obj = mData.at(i);
if(obj->mId == id)
{
itemIndex = index(i,0,QModelIndex());
break;
}
}
return itemIndex;
}
// End of file