--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ui/uiengine/model/mediamodel/src/glxmediamodel.cpp Fri Mar 19 09:28:59 2010 +0200
@@ -0,0 +1,434 @@
+/*
+* 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: ?Description
+*
+*/
+
+
+
+#include <glxmediamodel.h>
+#include <hbicon.h>
+#include <glxmodelparm.h>
+#include <QCache>
+#include <QDebug>
+#include <hal.h>
+#include <hal_data.h>
+
+#include <glxfiltergeneraldefs.h>
+
+//#define GLXPERFORMANCE_LOG
+#include <glxperformancemacro.h>
+
+GlxMediaModel::GlxMediaModel(GlxModelParm & modelParm)
+{
+ qDebug("GlxMediaModel::GlxMediaModel");
+ mMLWrapper = new GlxMLWrapper(modelParm.collection(),0,EGlxFilterImage);
+ mMLWrapper->setContextMode(GlxContextGrid);
+ mContextMode = GlxContextGrid;
+ int err = connect(mMLWrapper, SIGNAL(updateItem(int, GlxTBContextType)), this, SLOT(itemUpdated1(int, GlxTBContextType)));
+ qDebug("updateItem() connection status %d", err);
+ err = connect(mMLWrapper, SIGNAL(itemCorrupted(int)), this, SLOT(itemCorrupted(int)));
+ qDebug("itemCorrupted() connection status %d", err);
+ err = connect(mMLWrapper, SIGNAL(insertItems(int, int)), this, SLOT(itemsAdded(int, int)));
+ qDebug("updateItem() connection status %d", err);
+ err = connect(mMLWrapper, SIGNAL(removeItems(int, int)), this, SLOT(itemsRemoved(int, int)));
+ qDebug("updateItem() connection status %d", err);
+ err = connect(this, SIGNAL(iconAvailable(int, HbIcon*, GlxTBContextType)), this, SLOT(updateItemIcon(int, HbIcon*, GlxTBContextType)));
+ qDebug("iconAvailable() connection status %d", err);
+ //itemadded.resize(mMLWrapper->getItemCount());
+ itemIconCache.setMaxCost(50);
+ itemFsIconCache.setMaxCost(5);
+ itemExternalIconCache.setMaxCost(0);
+ //todo get this Default icon from some generic path and not directly.
+ m_DefaultIcon = new HbIcon(":/data/All_default.png");
+ mExternalItems = NULL;
+ externalDataCount = 0;
+ mFocusIndex = -1;
+}
+
+GlxMediaModel::~GlxMediaModel()
+{
+ //itemadded.clear();
+ qDebug("GlxMediaModel::~GlxMediaModel");
+ int freeMemory = 0;
+ int err1 = HAL::Get( HALData::EMemoryRAMFree, freeMemory );
+ qDebug("####mediaModel : Memory available before cache cleanup = %d and error is = %d ", freeMemory , err1 );
+ itemIconCache.clear();
+ itemFsIconCache.clear();
+ delete m_DefaultIcon;
+ m_DefaultIcon = NULL;
+ clearExternalItems();
+ err1 = HAL::Get( HALData::EMemoryRAMFree, freeMemory );
+ qDebug("####mediaModel : Memory available after cache cleanup = %d and error is = %d ", freeMemory , err1 );
+ int err = disconnect(mMLWrapper, SIGNAL(updateIcon(int, HbIcon*)), this, SLOT(itemUpdated1(int, HbIcon*)));
+ err = disconnect(mMLWrapper, SIGNAL(itemCorrupted(int)), this, SLOT(itemCorrupted(int)));
+ err = disconnect(mMLWrapper, SIGNAL(insertItems(int, int)), this, SLOT(itemsAdded(int, int)));
+ err = disconnect(mMLWrapper, SIGNAL(removeItems(int, int)), this, SLOT(itemsRemoved(int, int)));
+ err = disconnect(this, SIGNAL(iconAvailable(int, HbIcon*, GlxTBContextType)), this, SLOT(updateItemIcon(int, HbIcon*, GlxTBContextType)));
+ delete mMLWrapper;
+
+}
+
+void GlxMediaModel::setContextMode(GlxContextMode contextMode)
+{
+ if(mContextMode != contextMode) {
+ itemFsIconCache.clear();
+ mMLWrapper->setContextMode(contextMode);
+ mContextMode = contextMode;
+ }
+}
+
+//to add external data to the model
+void GlxMediaModel::addExternalItems(GlxExternalData* externalItems)
+{
+ externalDataCount = externalItems->count();
+ beginInsertRows(QModelIndex(), 0, externalDataCount);
+ mExternalItems = externalItems;
+ itemExternalIconCache.setMaxCost(15);
+ endInsertRows();
+ setFocusIndex(index(0,0));
+}
+
+
+/*
+*for removing all external image data from the model.
+*/
+void GlxMediaModel::clearExternalItems()
+{
+ beginRemoveRows(QModelIndex(), 0, externalDataCount);
+ if(mExternalItems) {
+ delete mExternalItems;
+ mExternalItems = NULL;
+ externalDataCount = 0;
+ }
+ itemExternalIconCache.clear();
+ endRemoveRows();
+}
+
+int GlxMediaModel::rowCount(const QModelIndex &parent ) const
+{
+ Q_UNUSED(parent);
+ qDebug("GlxMediaModel::rowCount %d", mMLWrapper->getItemCount());
+ return (mMLWrapper->getItemCount() + externalDataCount);
+}
+
+int GlxMediaModel::columnCount(const QModelIndex &parent ) const
+{
+ Q_UNUSED(parent);
+ return 1;
+}
+
+QModelIndex GlxMediaModel::parent(const QModelIndex &child) const
+{
+ Q_UNUSED(child);
+
+ //returns always invalid model index
+ return QModelIndex();
+}
+
+
+//todo refactor this whole function ... too many return statements are not good
+QVariant GlxMediaModel::data(const QModelIndex &index, int role) const
+{
+ HbIcon* itemIcon = NULL;
+ int itemIndex = index.row();
+ qDebug("GlxMediaModel::data buffer concept index %d role %d", index.row(), role);
+ if ((!index.isValid()) || (index.row() > rowCount()-1)) {
+ return QVariant();
+ }
+
+//external data are always placed at the beginning of the Media List
+//Check if the index can be mapped to the external data
+//if not then map the index to Ml Index
+ if(itemIndex < externalDataCount) {
+ if(role == Qt::DecorationRole || role == GlxFsImageRole){
+ return *(GetExternalIconItem(itemIndex,GlxTBContextExternal));
+ }
+ }
+ else {
+ itemIndex -= externalDataCount;
+ }
+
+//retrieve Data from Media List
+ if (role == Qt::DecorationRole) {
+ // char temp[100];
+ // sprintf(temp, "Thumbnail %d requiest time ", index.row());
+ // WRITE_TIMESTAMP(temp)
+ // sprintf(temp, "Response time of Thumbnail Request %d", index.row());
+ // PERFORMANCE_ADV( d1, temp) {
+ itemIcon = GetGridIconItem(itemIndex,GlxTBContextGrid);
+ if(itemIcon == NULL || itemIcon->isNull() ){
+ itemIcon = m_DefaultIcon;
+ // }
+ }
+ return *itemIcon;
+ }
+
+ if (role == GlxFsImageRole){
+ if(mContextMode == GlxContextLsFs){
+ itemIcon = GetFsIconItem(itemIndex,GlxTBContextLsFs);
+ }
+ else if (mContextMode == GlxContextPtFs){
+ itemIcon = GetFsIconItem(itemIndex,GlxTBContextPtFs);
+ }
+
+ if ( itemIcon == NULL) {
+ //itemIcon = GetGridIconItem(itemIndex,GlxTBContextGrid);
+ HbIcon* tempIcon = GetGridIconItem( itemIndex, GlxTBContextGrid );
+ if (tempIcon && !tempIcon->isNull()) {
+ qDebug("GlxMediaModel::scaling thumbnail");
+ QPixmap tempPixmap = tempIcon->qicon().pixmap(128, 128);
+ QSize sz = ( mContextMode == GlxContextLsFs ) ? QSize ( 640, 360) : QSize ( 360, 640 );
+ tempPixmap = tempPixmap.scaled(sz, Qt::KeepAspectRatio );
+ HbIcon tmp = HbIcon( QIcon(tempPixmap)) ;
+ if(!tmp.isNull()){
+ return tmp;
+ }
+ }
+ }
+
+ if ( itemIcon == NULL || itemIcon->isNull() ) {
+ itemIcon = m_DefaultIcon;
+ }
+ return *itemIcon;
+ }
+
+ QModelIndex idx;
+ if ( GlxFocusIndexRole == role ) {
+ idx = getFocusIndex();
+ return idx.row();
+ }
+ if(role == GlxUriRole) {
+ return (mMLWrapper->retrieveItemUri(itemIndex));
+ }
+ if(role == GlxDimensionsRole) {
+ return (mMLWrapper->retrieveItemDimension(itemIndex));
+ }
+
+ if(role == GlxDateRole ) {
+ qDebug("GlxMediaModel::data GlxDateRole ");
+ return (mMLWrapper->retrieveItemDate(itemIndex));
+ }
+
+ if (role == GlxFrameCount) {
+ qDebug("GlxMediaModel:: GlxFrameCount ");
+ return (mMLWrapper->retrieveItemFrameCount(itemIndex));
+ }
+
+ return QVariant();
+}
+
+//GetGridIconItem
+HbIcon* GlxMediaModel::GetGridIconItem(int itemIndex, GlxTBContextType tbContextType) const
+{
+ HbIcon* itemIcon = itemIconCache[itemIndex]; //Initialize icon from the Cache will be NULL if Item not present
+ if (!itemIcon)
+ {
+ itemIcon = mMLWrapper->retrieveItemIcon(itemIndex, tbContextType);
+ if(itemIcon){
+ emit iconAvailable(itemIndex,itemIcon, GlxTBContextGrid);
+ }
+ itemIcon = itemIconCache[itemIndex];
+ }
+ return itemIcon;
+
+}
+
+HbIcon* GlxMediaModel::GetFsIconItem(int itemIndex, GlxTBContextType tbContextType) const
+{
+ HbIcon* itemIcon = itemFsIconCache[itemIndex]; //Initialize icon from the Cache will be NULL if Item not present
+ if (!itemIcon) {
+ itemIcon = mMLWrapper->retrieveItemIcon(itemIndex, tbContextType);
+ if(itemIcon){
+ emit iconAvailable(itemIndex,itemIcon, tbContextType);
+ }
+ itemIcon = itemFsIconCache[itemIndex];
+ /*if(!itemIcon){
+ itemIcon = GetGridIconItem(itemIndex, GlxTBContextGrid);
+ }*/
+ }
+ return itemIcon;
+
+}
+
+HbIcon* GlxMediaModel::GetExternalIconItem(int itemIndex,GlxTBContextType tbContextType) const
+{
+ //todo add asserts here as the cache and the array is not preinitialized
+ HbIcon* itemIcon = itemExternalIconCache[itemIndex]; //Initialize icon from the Cache will be NULL if Item not present
+ if (!itemIcon) {
+ QPixmap* itemPixmap = mExternalItems->at(itemIndex).image;
+ itemIcon = new HbIcon(QIcon(*itemPixmap));
+ emit iconAvailable(itemIndex,itemIcon, tbContextType);
+ }
+ return itemIcon;
+}
+
+
+void GlxMediaModel::itemUpdated1(int mlIndex,GlxTBContextType tbContextType )
+{
+ qDebug("GlxMediaModel::itemUpdated %d", mlIndex);
+ //clear the grid and FS cache if they have any icons with them for that index
+ if(tbContextType == GlxTBContextGrid) {
+ itemIconCache.remove(mlIndex);
+ }
+ if(tbContextType == GlxTBContextLsFs || tbContextType == GlxTBContextPtFs) {
+ itemFsIconCache.remove(mlIndex);
+ }
+ emit dataChanged(index(mlIndex+externalDataCount,0),index(mlIndex+externalDataCount,0));
+
+}
+
+void GlxMediaModel::itemCorrupted(int itemIndex)
+{
+ qDebug("GlxMediaModel::itemCorrupted %d", itemIndex);
+ emit dataChanged(index(itemIndex+externalDataCount,0),index(itemIndex+externalDataCount,0));
+}
+
+void GlxMediaModel::itemsAdded(int startIndex, int endIndex)
+{
+ qDebug("GlxMediaModel::itemsAdded %d %d", startIndex, endIndex);
+ mFocusIndex = -1;
+ //emit rowsAboutToBeInserted(index(startIndex,0), startIndex, endIndex );
+ beginInsertRows(QModelIndex(), startIndex+externalDataCount, endIndex+externalDataCount);
+ //itemadded.insert(startIndex,(endIndex - startIndex),NULL );
+ itemIconCache.clear();
+ itemFsIconCache.clear();
+ endInsertRows();
+ //emit rowsInserted(index(startIndex,0), startIndex, endIndex );
+
+}
+
+void GlxMediaModel::itemsRemoved(int startIndex, int endIndex)
+{
+ qDebug("GlxMediaModel::itemsRemoved %d %d", startIndex, endIndex);
+ mFocusIndex = -1;
+ //emit rowsAboutToBeRemoved(index(startIndex,0), startIndex, endIndex );
+ beginRemoveRows(QModelIndex(), startIndex+externalDataCount, endIndex+externalDataCount);
+ //itemadded.remove(startIndex,(endIndex - startIndex) );
+ itemIconCache.clear();
+ itemFsIconCache.clear();
+ endRemoveRows();
+ //emit rowsRemoved(index(startIndex,0), startIndex, endIndex );
+
+}
+
+void GlxMediaModel::updateItemIcon(int itemIndex, HbIcon* itemIcon, GlxTBContextType tbContextType)
+{
+ qDebug("GlxMediaModel::updateItemIcon %d", itemIndex);
+ if(tbContextType == GlxTBContextGrid){
+ itemIconCache.insert(itemIndex, itemIcon);
+ }
+ else if(tbContextType == GlxTBContextLsFs || tbContextType == GlxTBContextPtFs){
+ itemFsIconCache.insert(itemIndex, itemIcon);
+ }
+ else if (tbContextType == GlxTBContextExternal){
+ itemExternalIconCache.insert(itemIndex, itemIcon);
+ }
+}
+
+
+void GlxMediaModel::setFocusIndex(const QModelIndex &index)
+{
+ qDebug("GlxMediaModel::setFocusIndex%d", index.row());
+ int itemIndex = index.row();
+
+ if(itemIndex >=externalDataCount)
+ {
+ int mlIndex = itemIndex - externalDataCount;
+ mMLWrapper->setFocusIndex(mlIndex);
+ mFocusIndex = -1;
+ }
+ else{
+ mFocusIndex = itemIndex;
+ if(rowCount() > externalDataCount) {
+ mMLWrapper->setFocusIndex(0);
+ }
+
+ }
+
+}
+
+QModelIndex GlxMediaModel::getFocusIndex() const
+{
+ int itemIndex = 0;
+ //return index(itemIndex+externalDataCount,0);
+ if(mFocusIndex == -1){
+ int mlIndex = mMLWrapper->getFocusIndex();
+ itemIndex = mlIndex + externalDataCount;
+ }
+ else {
+ itemIndex = mFocusIndex;
+ }
+ return index(itemIndex,0);
+}
+
+void GlxMediaModel::setSelectedIndex(const QModelIndex &index)
+{
+ int itemIndex = index.row();
+ qDebug("GlxMediaModel::setSelectedIndex()%d", itemIndex);
+ mMLWrapper->setSelectedIndex(itemIndex);
+}
+
+bool GlxMediaModel::setData ( const QModelIndex & idx, const QVariant & value, int role )
+{
+ Q_UNUSED( idx )
+
+ if ( GlxContextRole == role ) {
+ if ( value.isValid() && value.canConvert <int> () ) {
+ setContextMode( (GlxContextMode) value.value <int> () );
+ return TRUE;
+ }
+ }
+
+ if ( GlxFocusIndexRole == role ) {
+ if ( value.isValid() && value.canConvert <int> () ) {
+ setFocusIndex( index( value.value <int> (), 0) );
+ return TRUE;
+ }
+ }
+
+ if ( GlxVisualWindowIndex == role ) {
+ if ( value.isValid() && value.canConvert <int> () ) {
+ mMLWrapper->setVisibleWindowIndex( value.value <int> () );
+ return TRUE;
+ }
+ }
+
+ if ( GlxSelectedIndexRole == role ) {
+ qDebug("GlxMediaModel::setData::GlxSelectedIndexRole()::BEFORE%d", idx.row());
+ if ( value.isValid() && value.canConvert <int> () ) {
+ qDebug("GlxMediaModel::setData()::GlxSelectedIndexRole%d", idx.row());
+ setSelectedIndex( index( value.value <int> (), 0) );
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+QModelIndex GlxMediaModel::index(int row, int column, const QModelIndex &parent) const
+{
+ Q_UNUSED(parent)
+ qDebug("GlxMediaModel::index row %d column %d", row, column);
+
+ if ( ( row < 0 )
+ || ( row >= rowCount() )
+ || ( column < 0 )
+ || ( column >= columnCount() ) ) {
+ return QModelIndex();
+ }
+
+ return QAbstractItemModel::createIndex(row, column);
+}
+