FCL/sf/app/photos: comparison ui/uiengine/model/mediamodel/src/glxmediamodel.cpp

equal deleted inserted replaced

-:863223ea6961
+:a0f57508af73
 	itemIconCache.setMaxCost(20);  //Changed While Doing Media Wall
 	itemFsIconCache.setMaxCost(5);
 	itemExternalIconCache.setMaxCost(0);
-	//todo get this Default icon from some generic path and not directly.
 	m_DefaultIcon = new HbIcon(GLXICON_DEFAULT);
+	m_CorruptIcon = new HbIcon( GLXICON_CORRUPT );
 	mExternalItems = NULL;
 	externalDataCount = 0;
 	mFocusIndex = -1;
 	mSubState = -1;
 	mTempVisibleWindowIndex = 0;
 	qDebug("GlxMediaModel::~GlxMediaModel");
 	itemIconCache.clear();
 	itemFsIconCache.clear();
 	delete m_DefaultIcon;
 	m_DefaultIcon = NULL;
+	delete m_CorruptIcon;
+	m_CorruptIcon = NULL;
 	clearExternalItems();
 int err = disconnect(mMLWrapper, SIGNAL(updateItem(int, GlxTBContextType)), this, SLOT(itemUpdated1(int, GlxTBContextType)));
 	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)));
 	err = disconnect(mMLWrapper, SIGNAL(updateAlbumTitle(QString)), this, SLOT(albumTitleUpdated(QString)));
 return QModelIndex();
 }
 //todo refactor this whole function ... too many return statements are not good
-QVariant GlxMediaModel::data(const QModelIndex &index, int role) const
+QVariant GlxMediaModel::data( const QModelIndex &index, int role ) const
 {
-if (role == GlxViewTitle)
+if (role == GlxViewTitle) {
-{
 return mMLWrapper->retrieveViewTitle();
 }
 if(role == GlxPopulated) {
 return mMLWrapper->IsPopulated();
 }
 if ( role == GlxDefaultImage ) {
 if(!m_DefaultIcon->isNull()) {
 // this image Creation is Slow.
 // But what to do, Q class's Does not undersatnd our Localised File names
 return m_DefaultIcon->pixmap().toImage().convertToFormat(QImage::Format_ARGB32_Premultiplied);
 }
 else {
 return QImage();
 }
 }
 HbIcon* itemIcon = NULL;
 QImage itemImage;
 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
+//retrieve Data from Media List
-//Check if the index can be mapped to the external data
+if ( role == Qt::DecorationRole ) {
-//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) {
 itemIcon = GetGridIconItem(itemIndex,GlxTBContextGrid);
-if(itemIcon == NULL || itemIcon->isNull() ){
+if( itemIcon == NULL || itemIcon->isNull() ) {
-itemIcon = m_DefaultIcon;
+itemIcon = getCorruptDefaultIcon( index );
 }
 return *itemIcon;
 }
-if (role == GlxQImageSmall)
+if (role == GlxQImageSmall) {
-{
 return mMLWrapper->retrieveItemImage(itemIndex, GlxTBContextGrid);
 }
 if (role == GlxFsImageRole){
 if(mContextMode == GlxContextLsFs){
 itemIcon = GetFsIconItem(itemIndex,GlxTBContextLsFs);
 }
 else if (mContextMode == GlxContextPtFs){
 itemIcon = GetFsIconItem(itemIndex,GlxTBContextPtFs);
 }
-if ( itemIcon == NULL) {
+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 itemSize = mMLWrapper->retrieveItemDimension(itemIndex);
 QSize sz = ( mContextMode == GlxContextLsFs ) ? QSize ( 640, 360) : QSize ( 360, 640 );
-tempPixmap = tempPixmap.scaled(sz, Qt::KeepAspectRatio );
+if(!((itemSize.width() < sz.width()) && (itemSize.height() < sz.height()))); {
+itemSize.scale(sz, Qt::KeepAspectRatio);
+}
+tempPixmap = tempPixmap.scaled(itemSize, Qt::IgnoreAspectRatio );
 HbIcon tmp = HbIcon( QIcon(tempPixmap)) ;
 				if(!tmp.isNull()){
 					return tmp;
 				}
 }
 }
 if ( itemIcon == NULL || itemIcon->isNull() ) {
-itemIcon = m_DefaultIcon;
+itemIcon = getCorruptDefaultIcon( index ) ;
 }
 return *itemIcon;
 }
-if (role == GlxQImageLarge)
+if (role == GlxQImageLarge) {
-{
+if(mContextMode == GlxContextLsFs) {
-if(mContextMode == GlxContextLsFs)
-{
 itemImage = mMLWrapper->retrieveItemImage(itemIndex, GlxTBContextLsFs);
 }
-else
+else {
-{
 itemImage = mMLWrapper->retrieveItemImage(itemIndex, GlxTBContextPtFs);
 }
-if(!itemImage.isNull())
+if(!itemImage.isNull()) {
-{
 return itemImage;
 }
-else
+else {
-{
 itemImage =  mMLWrapper->retrieveItemImage(itemIndex, GlxTBContextGrid);
-if (!itemImage.isNull())
+if (!itemImage.isNull()) {
-{
 QSize sz = ( mContextMode == GlxContextLsFs ) ? QSize ( 640, 360) : QSize ( 360, 640 );
 itemImage = itemImage.scaled(sz,Qt::KeepAspectRatio);
-}
-return itemImage;
 }
-}
+return itemImage;
+}
-if (role == GlxVisualWindowIndex)
+}
-{
+if (role == GlxVisualWindowIndex) {
 return mMLWrapper->getVisibleWindowIndex();
 }
 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 (mMLWrapper->retrieveItemFrameCount(itemIndex));
 }
 if (role == GlxHdmiBitmap) {
 return mMLWrapper->RetrieveBitmap(itemIndex);
 }
+if ( role == GlxImageCorruptRole ) {
+return mMLWrapper->isCorruptedImage( itemIndex );
+}
 if (role == GlxTimeRole) {
 return mMLWrapper->retrieveItemTime(itemIndex);
 }
 if (role == GlxSizeRole) {
 return mMLWrapper->retrieveItemSize(itemIndex);
 }
 if (role == GlxDescRole) {
 return mMLWrapper->retrieveListDesc(itemIndex);
 }
 return QVariant();
 }
 //GetGridIconItem
 HbIcon* GlxMediaModel::GetGridIconItem(int itemIndex, GlxTBContextType tbContextType) const
 }
 void GlxMediaModel::modelpopulated()
 {
 if ( mTempVisibleWindowIndex!=-1) {
-mMLWrapper->setVisibleWindowIndex(mTempVisibleWindowIndex);
+//Set the visible Window index only ff the index stored in the activity manager is not out of range
+if( rowCount() > mTempVisibleWindowIndex && mTempVisibleWindowIndex > 0 ) {
+mMLWrapper->setVisibleWindowIndex(mTempVisibleWindowIndex);
+}
+else {
+mMLWrapper->setVisibleWindowIndex(0);
+}
 mTempVisibleWindowIndex = -1;
-	}
+}
 emit populated();
 }
 //------------------------------------------------------------------------------------------------------------
 //updateDetailItems
 int itemIndex = index.row();
 qDebug("GlxMediaModel::setSelectedIndex()%d", itemIndex);
 mMLWrapper->setSelectedIndex(itemIndex);
 }
+HbIcon * GlxMediaModel::getCorruptDefaultIcon( const QModelIndex &index ) const
+{
+if ( mMLWrapper->isCorruptedImage( index.row() ) ) {
+return m_CorruptIcon ;
+}
+return m_DefaultIcon ;
+}
 bool GlxMediaModel::setData ( const QModelIndex & idx, const QVariant & value, int role )
 {
 Q_UNUSED( idx )
 if ( GlxContextRole == role ) {

changeset 50	a0f57508af73
parent 45	863223ea6961
child 54	0f0f3f26f787