diff -r e1e28b0273b0 -r 93fff7023be8 EngSrc/IEEngineImp.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/EngSrc/IEEngineImp.cpp	Fri Oct 15 10:18:29 2010 +0900
@@ -0,0 +1,616 @@
+/*
+* 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: Juha Kauppinen, Mika Hokkanen
+* 
+* Description: Photo Browser
+*
+*/
+
+// Include files
+#include <e32uid.h>
+#include <BAUTILS.H>
+#include <IEImageProcessing.h>//thumbnail client
+#include "IEEngineImp.h"
+#ifdef IMAGE_EDITOR
+#include "IEEditor.h"
+#endif
+#include "IEFileLoader.h"
+#include "IEImageList.h"
+#include "ImageMonitorAO.h"
+#include "IEImageList.h"
+#include "IEEngineUtils.h"
+
+
+// ============================ MEMBER FUNCTIONS =========================== //
+
+EXPORT_C CIEEngine* CIEEngine::NewL(MIEEngineObserver& aObserver)
+{
+    DP0_IMAGIC(_L("CIEEngine::NewL"));
+	return CIEEngineImp::NewL(aObserver);
+}
+
+EXPORT_C CIEEngine::~CIEEngine()
+    {
+    
+    }
+
+CIEEngineImp* CIEEngineImp::NewL(MIEEngineObserver& aObserver)
+{
+    DP0_IMAGIC(_L("CIEEngine::NewL"));
+	CIEEngineImp* self = new (ELeave) CIEEngineImp(aObserver);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop();
+	return self;
+}
+
+CIEEngineImp::~CIEEngineImp()
+    {
+    DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp++"));
+
+#if 0
+   if(iIEImageProcessing)
+       {
+       delete iIEImageProcessing;
+       iIEImageProcessing = NULL;
+       }
+#endif
+
+#ifdef IMAGE_EDITOR
+     if(iImageEditor)
+	 {
+         DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iImageEditor"));
+         delete iImageEditor;
+         iImageEditor = NULL;
+	 }
+#endif
+   
+	 if(iFileLoader)
+	     {
+	     DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iFileLoader"));
+	     delete iFileLoader;
+	     iFileLoader = NULL;
+	     }
+	
+	 if(iBitmapLoader)
+	     {
+	     DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iBitmapLoader"));
+	     iBitmapLoader->CancelFullSizeLoading();
+	     DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iBitmapLoader 2"));
+	     delete iBitmapLoader;
+	     iBitmapLoader = NULL;
+	     }
+	
+	 if(iIEBgpsController)
+	     {
+	     DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iIEBgpsController"));
+	     delete iIEBgpsController;
+	     iIEBgpsController = NULL;
+	     }
+#ifdef _ACCELEROMETER_SUPPORTED_
+	 if(iSensorMonitor)
+	     {
+	     iSensorMonitor->StopMonitoring();
+	     delete iSensorMonitor;
+	     iSensorMonitor = NULL;
+	     }
+#endif //_ACCELEROMETER_SUPPORTED_
+
+	iFileServer.Close();
+	iCritical.Close();
+	
+	DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp--"));
+    }
+
+CIEEngineImp::CIEEngineImp(MIEEngineObserver& aObserver) :
+    iEngineObserver(aObserver),
+    iIEEngineUtils(iFileServer)
+    {
+    }
+
+void CIEEngineImp::ConstructL()
+    {
+    DP0_IMAGIC(_L("CIEEngine::ConstructL++"));
+    
+    iCritical.CreateLocal();
+    
+    User::LeaveIfError(iFileServer.Connect());
+	
+	/*Creating Engine Utility class pointer */
+	iCurrentEditingMode = EEditModeNone;
+	iEditingMode = EEditModeNone;
+	iImageEdited = EFalse;
+	iImageArrayMode = EImages;
+	iAllFilesScanned = EFalse;
+	iPrevDeviceOrientation = EOrientationDisplayLeftUp;
+	
+
+	TInt err = KErrNone;
+	//Create Bitmap loader
+	iBitmapLoader = CIEBitmapLoader::NewL(iFileServer, *this, &iCritical);
+	//Create BGPS controller
+	iIEBgpsController = CIEBgpsController::NewL(iFileServer, *this, iIEEngineUtils, &iCritical);
+	//Create Fileloader
+	TRAP(err, iFileLoader = CIEFileLoader::NewL(iFileServer, this, &iCritical));
+    if(err != KErrNone)
+        {
+        DP1_IMAGIC(_L("CIEEngine::ConstructL - Error creating file loader, err: %d"),err);
+        User::Leave(err);
+        }
+    
+#ifdef _ACCELEROMETER_SUPPORTED_
+    iDeviceOrientation = EOrientationDisplayLeftUp;
+    err = KErrNone;
+    TRAP(err, iSensorMonitor = CIESensorMonitor::NewL(*this));
+    DP1_IMAGIC(_L("CIEEngine::ConstructL - iSensorMonitor error: %d"), err);
+    if(err == KErrNone)
+        {
+        DP0_IMAGIC(_L("CIEEngine::ConstructL - iSensorMonitor->StartMonitoring()"));
+        iSensorMonitor->StartMonitoring();
+        }
+    else
+        {
+        iSensorMonitor = NULL;
+        }
+
+#endif
+
+    iIEBgpsController->SetFileLoader(iFileLoader); 
+   
+    DP0_IMAGIC(_L("CIEEngine::ConstructL--"));
+}
+
+void CIEEngineImp::SetDBChanged(CImageData* aImageData)
+    {
+    TFileName filename;
+    aImageData->GetFileName(filename, EFullSize);
+    iFileLoader->GetImageList().SetChanged(filename); 
+    }
+
+CIEImageList& CIEEngineImp::GetImageList()
+    {
+    return iFileLoader->GetImageList();
+    }
+
+void CIEEngineImp::AppUIReady()
+    {
+    DP0_IMAGIC(_L("CIEEngine::AppUIReady"));
+    
+    //Create ImageProcessing
+    iIEBgpsController->CreateImageProcessing();
+    }
+
+void CIEEngineImp::CancelFullSizeLoading()
+    {
+    DP0_IMAGIC(_L("CIEEngine::CancelLoading"));
+    
+    iBitmapLoader->CancelFullSizeLoading();
+    }
+
+
+void CIEEngineImp::SetImageDataMode(TImageArrayMode aMode)
+    {
+    iImageArrayMode = aMode;
+    
+    iBitmapLoader->SetImageDataMode(aMode);
+    }
+
+MIEEngineObserver& CIEEngineImp::GetObserver() 
+    {
+    return iEngineObserver;
+    }
+
+void CIEEngineImp::TNGenerationComplete(TThumbSize aTNRes)
+    {
+    DP0_IMAGIC(_L("CIEEngine::TNGenerationComplete++"));
+    
+    iEngineObserver.TNCreationCompleteL(aTNRes);
+    
+    DP0_IMAGIC(_L("CIEEngine::TNGenerationComplete--"));
+    }
+
+void CIEEngineImp::SingleTNGenerationComplete(TInt aIndex, TThumbSize aTNRes)
+    {
+    DP0_IMAGIC(_L("CIEEngine::TNGenerationComplete++"));
+    
+    iEngineObserver.SingleTNCreationCompletedL(aIndex, aTNRes);
+    
+    DP0_IMAGIC(_L("CIEEngine::TNGenerationComplete--"));
+    }
+
+void CIEEngineImp::FaceDetectionComplete()
+    {
+    DP0_IMAGIC(_L("CIEEngine::FaceDetectionComplete"));
+    iEngineObserver.FaceDetectionComplete();
+    }
+
+void CIEEngineImp::SingleFaceDetectionComplete()
+    {
+    DP0_IMAGIC(_L("CIEEngine::SingleFaceDetectionComplete"));
+    
+    iEngineObserver.SingleFaceDetectionComplete();
+    }
+
+void CIEEngineImp::AllFilesAddedToFilenameArrayL()
+    {
+    DP0_IMAGIC(_L("CIEEngine::AllFilesAddedToFilenameArrayL"));
+    
+    iIEBgpsController->AllFilesAddedToFilenameArrayL();
+    iEngineObserver.AllFilesScanned();
+    iAllFilesScanned = ETrue;
+    }
+
+CIEEngineUtils * CIEEngineImp::GetEngineUtils()
+    {
+    DP0_IMAGIC(_L("CIEEngine::GetEngineUtils"));
+    
+    return &iIEEngineUtils;
+    }
+
+CIEFileLoader* CIEEngineImp::GetFileLoader()
+    {
+    DP0_IMAGIC(_L("CIEEngineImp::GetFileLoader"));
+    
+    return iFileLoader;
+    }
+
+void CIEEngineImp::BitmapsLoadedL(TInt aError)
+{
+    DP0_IMAGIC(_L("CIEEngineImp::BitmapsLoaded"));
+    
+	iEngineObserver.ImagesLoadedL(aError);
+}
+
+TBool CIEEngineImp::IsScanningFiles() const
+    {
+    return !iAllFilesScanned;
+    }
+
+void CIEEngineImp::GetTotalNumOfImages(TInt& aNumOfImages, TInt& aNumOfFaces)
+    {
+    //DP0_IMAGIC(_L("CIEEngineImp::GetTotalNumOfImages"));
+    
+    iFileLoader->GetTotalNumOfImages(aNumOfImages, aNumOfFaces);
+    }
+
+TInt CIEEngineImp::GetTotalNumOfImages()
+    {
+    //DP0_IMAGIC(_L("CIEEngineImp::GetTotalNumOfImages"));
+    //return iFileLoader->GetTotalNumOfImages();
+    
+    TInt numOfImages, numOfFaces;
+    if(iImageArrayMode == EImages)
+        {
+        iFileLoader->GetTotalNumOfImages(numOfImages, numOfFaces);
+        return numOfImages;
+        }
+        
+    else if(iImageArrayMode == EFaces)
+        {
+        iFileLoader->GetTotalNumOfImages(numOfImages, numOfFaces);
+        return numOfFaces;
+        }
+    else
+        return 0;
+    
+    }
+
+TInt CIEEngineImp::DeleteFile(TInt aIndex)
+    {  
+    DP0_IMAGIC(_L("CIEEngineImp::DeleteFile++"));
+    TInt err;
+    if(iImageArrayMode == EImages)
+        {
+        err = iFileLoader->DeleteFile(aIndex);
+        iIEBgpsController->FilenameArrayCountChanged(iFileLoader->GetFileNameArray());
+        }
+    else//EFaces
+        {
+        err = iFileLoader->DeleteFaceFile(aIndex);
+        TInt numOfImages = 0;
+        TInt numOfFaces = 0;
+        iFileLoader->GetUpdatedNumOfImages(numOfImages, numOfFaces);
+        }
+    DP1_IMAGIC(_L("CIEEngineImp::DeleteFile-- %d"), err);
+    return err;
+    }
+
+TInt CIEEngineImp::GetImageName(const TInt aIndex, TFileName& aFileName, TThumbSize aThumbRes)
+    {
+    DP0_IMAGIC(_L("CIEEngineImp::GetImageName"));
+    
+    TInt error = KErrNone;
+    TRAP(error, iFileLoader->GetFileNameL(aIndex, aFileName, aThumbRes));
+    return error;
+    }
+
+void CIEEngineImp::GetBitmapL(CImageData* aImageData, CFbsBitmap* aBitmap, TThumbSize aThumbRes)
+    {
+    DP0_IMAGIC(_L("CIEEngineImp::GetBitmapL"));
+    
+    iBitmapLoader->GetOneBitmapL(aImageData, aBitmap, aThumbRes);
+    }
+
+void CIEEngineImp::GetFileNameL(const TInt aIndex, TThumbSize aThumbRes, TFileName& aFilename)
+    {
+    iFileLoader->GetFileNameL(aIndex, aFilename, aThumbRes);
+    }
+
+void CIEEngineImp::StopTNGeneration(TInt& /*aValue*/)
+    {
+    //iIEBgpsController->StopTNGeneration(aValue);
+    iIEBgpsController->CancelTNGeneration();
+    }
+
+TReal CIEEngineImp::GetAspectRatio(TInt aIndex)
+    {
+    return iIEBgpsController->GetAspectRatio(aIndex);
+    }
+
+TReal CIEEngineImp::GetFacesAspectRatio(TInt aIndex)
+    {
+    return iIEBgpsController->GetFacesAspectRatio(aIndex);
+    }
+
+//This function is called in editing mode only when we did not have 320x320 TN ready
+void CIEEngineImp::GenerateThumbNailL(const TDes &aOrgFile, TThumbSize aTNResolution)
+    {
+    DP0_IMAGIC(_L("CIEEngineImp::GenerateThumbNail++"));
+    
+    iIEBgpsController->GenerateThumbNailL(aOrgFile, aTNResolution);
+
+    DP0_IMAGIC(_L("CIEEngineImp::GenerateThumbNail--"));
+    }
+
+//This is used to get face coords from already processed image
+void CIEEngineImp::GetFaceCoordinates(const TFileName aTNFileName, RArray<TRect>& aFaceCoordinateArray)
+    {
+    DP0_IMAGIC(_L("CIEEngineImp::GetFaceCoordinates"));
+    aFaceCoordinateArray.Reset();
+    //iIEBgpsController->GetFaceCoordinates(aTNFileName, aFaceCoordinateArray);
+    }
+
+void CIEEngineImp::AddImageToFaceNameArray()
+    {
+    DP0_IMAGIC(_L("CIEEngineImp::AddImageToFaceNameArray++"));
+    
+    //Tarkista etta jos kuva on jo olemassa sita ei lisata enaa uudelleen 
+    
+    for(TInt i=0; i<iCroppedFilenames.Count(); i++)
+        {
+        //Add newly cropped filenames to filename array
+        CImageData* tmpImageData = CImageData::NewL(EFullSize);
+        
+        TRAP_IGNORE(tmpImageData->SetFileNameL(iCroppedFilenames[i]));
+        
+        DP1_IMAGIC(_L("CIEEngineImp::FaceCroppingComplete - Add face, Filename: %S"), &iCroppedFilenames[i] );
+        
+        TSize size;
+        TRAPD(err, iIEEngineUtils.GetImageSizeL(iCroppedFilenames[i], size));
+        if (err == KErrNone)
+            tmpImageData->SetSize(size);
+        
+        iFileLoader->AddNewFaceCropImage(tmpImageData, 0);    
+        }
+    
+    TInt numOfImages, numOfFaces;
+    iFileLoader->GetUpdatedNumOfImages(numOfImages, numOfFaces);
+    
+    //TotalNumberOfFaceImagesChanged(numOfFaces);
+    
+    //Empty data from array after using it
+    TInt count = iCroppedFilenames.Count();
+    for(TInt i=0; i<count; i++)
+        {
+        iCroppedFilenames.Remove(0);
+        }
+    //iFileLoader->StopFileSystemMonitoring();
+    
+    DP0_IMAGIC(_L("CIEEngineImp::AddImageToFaceNameArray--"));
+    }
+
+//If background face Detection is still continuing, we have to use GetSingleFaceCoordinates() function to get face coordinates
+void CIEEngineImp::GetSingleFaceCoordinates(TInt aIndex, const TFileName aTNFileName, RArray<TRect>& aFaceCoordinateArray)
+    {
+    DP0_IMAGIC(_L("CIEEngineImp::GetSingleFaceCoordinates"));
+    
+    iIEBgpsController->GetSingleFaceCoordinates(aIndex, aTNFileName, aFaceCoordinateArray);
+    }
+
+
+CImageData* CIEEngineImp::GetImageData(TInt aIndex/*, TImageArrayMode aMode*/)
+    {
+    return iFileLoader->GetImageData(aIndex/*, aMode*/);
+    }
+
+void CIEEngineImp::SetImageData(TInt aIndex, CImageData* aGridData)
+    {
+    iFileLoader->SetImageData(aIndex, aGridData);
+    }
+
+TInt CIEEngineImp::GetSelectedImageIndex()
+    {
+    return iEngineObserver.GetImageIndex();
+    }
+    
+
+
+#ifdef _ACCELEROMETER_SUPPORTED_
+
+void CIEEngineImp::SensorDataAvailable(TImagicDeviceOrientation aOrientation, TBool aValue)
+    {
+    //DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable++"));
+    
+    if(iPrevDeviceOrientation == aOrientation)
+        {
+        //DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable - Orientation not changed--"));
+        return;
+        }
+
+    iPrevDeviceOrientation = aOrientation;
+    
+    CImageData* currentImage = NULL ; //GetGridData(GetSelectedImageIndex(), EImages);
+    TInt totalImages = GetTotalNumOfImages();
+    
+    switch ( aOrientation )
+        {
+#ifdef _S60_3x_ACCELEROMETER_
+        case EOrientationDisplayDown: // Portrait Up
+#else if _S60_5x_ACCELEROMETER_
+        case TSensrvOrientationData::EOrientationDisplayUp: // Portrait Up
+        //case TSensrvOrientationData::EOrientationDisplayDown: // Portrait Up
+#endif            
+            {               
+            DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable - EOrientationDisplayUp"));
+            
+            for ( TInt imageIndex = 0 ; imageIndex < totalImages ; imageIndex++ )
+                {
+                currentImage = GetImageData(imageIndex); 
+                currentImage->iGridData.iTargetRotationAngle = (currentImage->GetOrientation() + 90)%360;
+                
+                TReal targetA = currentImage->iGridData.iTargetRotationAngle;
+                TReal currentA = currentImage->iGridData.iRotationAngle;
+                
+                currentImage->iGridData.iTargetRotationAngle = targetA;
+                
+                }
+            
+            iPrevDeviceOrientation = iDeviceOrientation = EOrientationDisplayDown;
+            break;
+            }
+
+#ifdef _S60_3x_ACCELEROMETER_
+        case EOrientationDisplayLeftUp: // Landscape Up
+#else if _S60_5x_ACCELEROMETER_
+        case TSensrvOrientationData::EOrientationDisplayRightUp: // Landscape Up
+        //case TSensrvOrientationData::EOrientationDisplayLeftUp: // Landscape Up
+#endif            
+                {
+            DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable - EOrientationDisplayLeftUp"));
+            
+            for ( TInt imageIndex = 0 ; imageIndex < totalImages ; imageIndex++ )
+                {
+                currentImage = GetImageData(imageIndex); 
+                if ( currentImage->iGridData.iRotationAngle == 270 )
+                    {
+                    currentImage->iGridData.iRotationAngle = -90; // Rotate
+                    }
+                currentImage->iGridData.iTargetRotationAngle = (currentImage->GetOrientation() )%360;
+                
+                TReal targetA = currentImage->iGridData.iTargetRotationAngle;
+                TReal currentA = currentImage->iGridData.iRotationAngle;
+                
+                currentImage->iGridData.iTargetRotationAngle = targetA;
+                }              
+  
+            iPrevDeviceOrientation = iDeviceOrientation = EOrientationDisplayLeftUp;
+            break;
+            }
+
+            default:
+                {
+                DP1_IMAGIC(_L("CIEEngineImp::SensorDataAvailable - Ignored orientation: %d"),aOrientation);
+                //progressBuf.Append( _L( "Unknown orientation" ) );
+                break;
+                }
+            }
+    iEngineObserver.ImageRotated(iDeviceOrientation);
+    
+    DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable--"));
+   }
+
+void CIEEngineImp::SetImageRotation(TInt aIndex)
+    {
+    CImageData* currentImage = NULL ; //GetGridData(GetSelectedImageIndex(), EImages);
+    //TInt totalImages = GetTotalNumOfImages();
+    
+    currentImage = GetImageData(aIndex); 
+    
+    TReal targetAngle = (currentImage->GetOrientation())%360;
+    //TReal currentAngle = currentImage->iGridData.iRotationAngle;
+    
+    currentImage->iGridData.iTargetRotationAngle = targetAngle;
+    
+    }
+    
+
+TImagicDeviceOrientation CIEEngineImp::GetDeviceOrientation()
+    {
+    DP1_IMAGIC(_L("CIEEngineImp::GetDeviceOrientation: %d"),iDeviceOrientation);
+    return iDeviceOrientation;
+   }
+
+void CIEEngineImp::SetDeviceOrientation(TImagicDeviceOrientation aOrientation)
+    {
+    DP1_IMAGIC(_L("CIEEngineImp::SetDeviceOrientation: %d"),aOrientation);
+    
+    SensorDataAvailable(aOrientation, EFalse);
+   }
+
+void CIEEngineImp::StartAccSensorMonitoring()
+    {
+    if(iSensorMonitor)
+        {
+        DP0_IMAGIC(_L("CIEEngineImp::StartAccSensorMonitoring"));
+        iSensorMonitor->StartMonitoring();
+        }
+        
+    }
+
+void CIEEngineImp::StopAccSensorMonitoring()
+    {
+    if(iSensorMonitor)
+        {
+        DP0_IMAGIC(_L("CIEEngineImp::StopAccSensorMonitoring"));
+        iSensorMonitor->StopMonitoring();
+        }
+    }
+
+#endif
+
+void CIEEngineImp::Stop()
+    {
+    /*TInt err = KErrNone;
+    StopTNGeneration(err); 
+    StopFaceDetection(err);*/
+    iFileLoader->StopImageFinder();
+    }
+
+TBool CIEEngineImp::IsRunning()
+    {
+    //iIEBgpsController->
+    return (iFileLoader->ImageFinderState() != CIEFileLoader::EImageFinderStopped);
+    //return ETrue;
+    }
+ 
+TBool CIEEngineImp::IsAccelerometerExists()
+    {
+    DP0_IMAGIC(_L("CIEEngineImp::IsAccelerometerExists"));
+    
+#ifdef _S60_3x_ACCELEROMETER_
+#ifdef SENSOR_API_LOAD_DYNAMICALLY
+    DP1_IMAGIC(_L("CIEEngineImp::IsAccelerometerExists - iSensorMonitor exists: %d"),iSensorMonitor);
+    return (iSensorMonitor != NULL);
+#endif
+#endif
+    DP0_IMAGIC(_L("CIEEngineImp::IsAccelerometerExists - iSensorMonitor not exists"));
+    return EFalse;
+    }
+
+TInt CIEEngineImp::GetGleMaxRes()
+    {
+    return iEngineObserver.GetGleMaxRes();
+    }
+
+    
+// EOF
+