diff -r e1e28b0273b0 -r 93fff7023be8 EngSrc/IEBgpsController.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/EngSrc/IEBgpsController.cpp	Fri Oct 15 10:18:29 2010 +0900
@@ -0,0 +1,793 @@
+/*
+* 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 <BAUTILS.H>
+
+#include "IEBgpsController.h"
+#include "debug.h"
+#include "ImagicConsts.h"
+
+// ====================== MEMBER FUNCTION ================================== //
+
+CIEBgpsController* CIEBgpsController::NewL(RFs& aFileServer,
+                                        MIEBgpsControllerObserver& aIEBgpsControllerObserver, 
+                                        CIEEngineUtils& aEngineUtils,
+                                        RCriticalSection* aCritical)
+    {
+    CIEBgpsController* self = new (ELeave) CIEBgpsController(aFileServer,
+                                                            aIEBgpsControllerObserver, 
+                                                            aEngineUtils,
+                                                            aCritical);
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    CleanupStack::Pop();
+    return self;
+    }
+
+CIEBgpsController::CIEBgpsController(RFs& aFileServer, MIEBgpsControllerObserver& aIEBgpsControllerObserver, 
+                                     CIEEngineUtils& aEngineUtils, RCriticalSection* aCritical)
+    :iFileServer(aFileServer),
+    iIEBgpsControllerObserver(aIEBgpsControllerObserver),
+    iFileLoader(NULL),
+    iIEEngineUtils(aEngineUtils),
+    iCritical(aCritical)
+    {
+    
+    }
+
+CIEBgpsController::~CIEBgpsController()
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::~CIEBgpsController++"));
+    
+    if(iIEBgpsClient)
+        {
+        delete iIEBgpsClient;
+        iIEBgpsClient = NULL;    
+        }
+    
+    iFaceCropImageDataArray.Close();
+    iFBCoordinateArray.Close();
+    
+    DP0_IMAGIC(_L("CIEBgpsController::~CIEBgpsController--"));
+    }
+
+void CIEBgpsController::ConstructL()
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::ConstructL++"));
+    
+    iImageIndex = 0;
+    iSingleTNGeneration = EFalse;
+    iTnCreationCancelled = EFalse;
+    iAllTNsDone = EFalse;
+    
+    //iIEBgpsClient = CIEImageProcessing::NewL(*this);
+    
+    DP0_IMAGIC(_L("CIEBgpsController::ConstructL--"));
+    }
+
+
+void CIEBgpsController::SetFileLoader(CIEFileLoader* aFileLoader)
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::SetFileLoader"));
+    
+    iFileLoader = aFileLoader;
+    }
+
+
+void CIEBgpsController::CreateImageProcessing()
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::CreateImageProcessing"));
+    
+    iIEBgpsClient = CIEImageProcessing::NewL(*this);
+    
+    }
+
+
+void CIEBgpsController::ThumbnailGenerationCompleted(TInt aErrorCode)
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted++"));
+    
+    if (aErrorCode == KErrCancel)
+        return;
+    
+    /*CImageData* imageData = iIEBgpsControllerObserver.GetImageData(iTnCreationIndex, EImages);
+    TFileName filename;
+    imageData->GetFileName(filename, ESize512x512);
+    DP1_IMAGIC(_L("CFaceBrowser::BrowseFacesL 512x512TNFile = %S ++"), &filename);*/
+        
+    //Single TN generation ----------->
+    if(aErrorCode != KErrNone)
+        {
+        DP1_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted - Error in TN creation: %d"), aErrorCode);
+        
+        CImageData* imageData = iIEBgpsControllerObserver.GetImageData(iTnCreationIndex);
+        //Mark image as corrupted so we do not try to generate TN or load it
+        imageData->iGridData.iCorrupted = ETrue;
+            
+        //In Error case any way delete the iCorrupted Thumbnail + file we were trying to generate TN(if it is not original)
+        if(!iSingleFaceDetectionOn)
+            {
+            DeleteCorruptedThumbNailFile(iTNFilename);
+            if(iJpegFilename.Find(KPAlbTNFilePath) != KErrNotFound)
+                {
+                DeleteCorruptedThumbNailFile(iJpegFilename);
+                }
+            }
+        }
+
+    iSingleFaceDetectionOn = EFalse;
+    
+    //If no error mark that TN was created
+    if(aErrorCode == KErrNone)
+        {
+        if(i512x512TNCreationOn)
+            {
+            DP0_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted - i512x512TNCreationOn"));
+            iImageDataArray[iTnCreationIndex]->iGridData.iCorrupted = EFalse;
+            iImageDataArray[iTnCreationIndex]->SetImageReady(ESize512x512, ETrue);
+            iIEBgpsControllerObserver.SingleTNGenerationComplete(iTnCreationIndex, ESize512x512);
+
+/*#ifdef FACE_DETECTION
+            TInt count = iFBCoordinateArray.Count();
+            for(TInt i=0; i<count; i++)
+                iFBCoordinateArray.Remove(0);
+                
+            iSingleFBCoordinateArray = &iFBCoordinateArray;
+            iImageData = iIEBgpsControllerObserver.GetImageData(iTnCreationIndex, EImages);
+            
+            iIEBgpsClient->StartSingleFaceDetection(iTnCreationIndex, *iSingleFBCoordinateArray, iImageData);
+            iSingleFaceDetectionOn = ETrue;
+#endif*/
+            }
+        if(i128x128TNCreationOn)
+            {
+            DP0_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted - i128x128TNCreationOn"));
+            iImageDataArray[iTnCreationIndex]->SetImageReady(ESize128x128, ETrue);
+            iIEBgpsControllerObserver.SingleTNGenerationComplete(iTnCreationIndex, ESize128x128);
+            }
+        if(i32x32TNCreationOn)
+            {
+            DP0_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted - i32x32TNCreationOn"));
+            iImageDataArray[iTnCreationIndex]->SetImageReady(ESize32x32, ETrue);
+            iIEBgpsControllerObserver.SingleTNGenerationComplete(iTnCreationIndex, ESize32x32);
+            
+#ifdef FACE_DETECTION
+            TInt count = iFBCoordinateArray.Count();
+            for(TInt i=0; i<count; i++)
+                iFBCoordinateArray.Remove(0);
+                
+            iSingleFBCoordinateArray = &iFBCoordinateArray;
+            iImageData = iIEBgpsControllerObserver.GetImageData(iTnCreationIndex);
+            
+            //iIEBgpsClient->StartSingleFaceDetection(iTnCreationIndex, *iSingleFBCoordinateArray, iImageData);
+            iSingleFaceDetectionOn = ETrue;
+#endif
+            }
+        }
+
+    if(aErrorCode != KErrNone || !iSingleFaceDetectionOn)
+        {
+        TThumbSize res;
+        iTnCreationIndex = FindMissingTN(res);
+        
+        iAllTNsDone = ETrue;
+        //Check if all TN images are done
+        for(TInt i=0; i<iImageDataArray.Count(); i++)
+            {
+            if((!iImageDataArray[i]->IsImageReady(ESize512x512) || 
+               !iImageDataArray[i]->IsImageReady(ESize128x128) ||
+               !iImageDataArray[i]->IsImageReady(ESize32x32)) &&
+               !iImageDataArray[i]->iGridData.iCorrupted )
+                {
+                iAllTNsDone = EFalse;
+                DP1_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted - Continue TN creation from index: %d"), i);
+                break;
+                }
+            }
+                        
+        if(!iAllTNsDone && iTnCreationIndex >= 0)
+            {
+            //Start creating thumbnails by calling TN creator
+            if(res == ESize512x512)
+                {
+                DP1_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted - Res: ESize512x512, Index: %d"),iTnCreationIndex);
+                i512x512TNCreationOn = ETrue;
+                i128x128TNCreationOn = EFalse;
+                i32x32TNCreationOn = EFalse;
+                Generate512x512Thumbnails(iTnCreationIndex);
+                }
+            else if(res == ESize128x128)
+                {
+                DP1_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted - Res: ESize128x128, Index: %d"),iTnCreationIndex);
+                i128x128TNCreationOn = ETrue;
+                i512x512TNCreationOn = EFalse;
+                i32x32TNCreationOn = EFalse;
+                Generate128x128Thumbnails(iTnCreationIndex);
+                }
+            else if(res == ESize32x32)
+                {
+                DP1_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted - Res: ESize32x32, Index: %d"),iTnCreationIndex);
+                i32x32TNCreationOn = ETrue;
+                i512x512TNCreationOn = EFalse;
+                i128x128TNCreationOn = EFalse;
+                Generate32x32Thumbnails(iTnCreationIndex);
+                }
+            }
+        
+        // Callback after completion of all TNs 
+        if(iAllTNsDone)
+            {
+            i32x32TNCreationOn = EFalse;
+            i128x128TNCreationOn = EFalse;
+            i512x512TNCreationOn = EFalse;
+            DP0_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted - All thumbnails are created, start face Detection"));
+            //iIEBgpsClient->StartFaceDetection(iImageDataArray);
+            //iBackGroundFaceDetectionOn = ETrue;
+            iIEBgpsControllerObserver.TNGenerationComplete(ENotDefined);
+            }
+        }
+
+    DP0_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted --"));    
+    }
+
+
+void CIEBgpsController::HandleError(TInt aError)
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::HandleError"));
+    //Handle BGPS errors here
+    
+    //Cancel UI frame blinking, we can not do anythign else if BGPS is jammed??
+    //iIEBgpsControllerObserver.TNGenerationComplete(ENotDefined);
+    if(i32x32TNCreationOn || i128x128TNCreationOn || i512x512TNCreationOn)
+        {
+        DP0_IMAGIC(_L("CIEBgpsController::HandleError - Error on TN generation, try to continue"));
+        ThumbnailGenerationCompleted(aError);
+        }
+    else
+        {
+        iIEBgpsControllerObserver.TNGenerationComplete(ENotDefined);
+        }
+    }
+
+void CIEBgpsController::ThumbnailGenerationCancelled(TInt /*aErrorCode*/)
+    {
+    //Start TN generation again if it was stopped
+    if(iTnCreationCancelled)
+        ;//StartSingleFaceDetection();
+    }
+
+void CIEBgpsController::GenerateThumbNailL(const TDes &aOrgFile, TThumbSize /*aTNResolution*/)
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::GenerateThumbNailL ++"));
+    
+    iSavedFileName.Copy(aOrgFile);
+          
+    /*Generating Thumbnail path for 320x320 */
+    iIEEngineUtils.GenerateThumbnailFileName(ESize32x32,iSavedFileName,iTNFilename);
+    
+    /*Creating folder if not exists */
+    TParse parser;
+    parser.Set(iTNFilename, NULL, NULL );
+    TFileName name = parser.NameAndExt();//image file name
+    TFileName tnPath = parser.DriveAndPath();
+       
+    CIEEngineUtils::CreateTNFolder(iFileServer, tnPath);
+    
+    /*Generating TN file with absolute path */
+    tnPath.Append(name);
+     
+    /* TN file name with absolute path*/
+    iTNFilename.Copy(tnPath);
+    
+    /*Set Single Thumbnail generation flag on */
+    iSingleTNGeneration = ETrue; 
+    
+    /*Generate TN for 320x320 resolution */
+    iLatestCreatedTNSize = ESize32x32;
+    iTmpImageData = CImageData::NewL();
+    
+    TSize originalSize;
+    iIEEngineUtils.GetImageSizeL(iSavedFileName, originalSize);
+    
+    DP1_IMAGIC(_L("iTNFilename: %S"), &iTNFilename);
+    
+    TSize size(320, 320);
+    if (originalSize.iWidth && originalSize.iHeight)
+        {
+        if(originalSize.iWidth > originalSize.iHeight)
+            { // Landscape
+            size.iHeight = 320 * originalSize.iHeight / originalSize.iWidth;
+            if(size.iHeight%2 != 0)
+                size.iHeight++;
+            }
+        else // Portrait
+            {
+            size.iWidth = 320 * originalSize.iWidth / originalSize.iHeight;
+            if(size.iWidth%2 != 0)
+                size.iWidth++;
+            }
+        }
+    
+    iTmpImageData->SetSize(size);
+    iIEBgpsClient->GenerateTN(iSavedFileName, iTNFilename, size);
+
+    
+    DP0_IMAGIC(_L("CIEBgpsController::GenerateThumbNailL--"));
+    }
+
+
+//Filename array has been filled(completetely) when this function is called
+void CIEBgpsController::AllFilesAddedToFilenameArrayL()
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::AllFilesAddedToFilenameArrayL++"));
+    
+    //Get filename array
+    iImageDataArray = iFileLoader->GetFileNameArray();
+    
+    // Start TN generation
+    if(iImageDataArray.Count() > 0)
+        {
+        StartTNCreatorL();
+        }
+    
+    DP0_IMAGIC(_L("CIEBgpsController::AllFilesAddedToFilenameArrayL--"));
+    }
+
+TReal CIEBgpsController::GetAspectRatio(TInt aIndex)
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::GetAspectRatio"));
+    
+    iImageDataArray = iFileLoader->GetFileNameArray();
+    
+    if(aIndex < iImageDataArray.Count())
+        {
+        return iImageDataArray[aIndex]->GetAspectRatio();
+        }
+    else
+        {
+        return 0;
+        }
+    }
+
+TReal CIEBgpsController::GetFacesAspectRatio(TInt aIndex)
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::GetAspectRatio"));
+    
+    iImageDataArray = iFileLoader->GetFacesFileNameArray();
+    
+    if(aIndex < iImageDataArray.Count())
+        {
+        return iImageDataArray[aIndex]->GetAspectRatio();
+        }
+    else
+        return 0;
+    }
+
+void CIEBgpsController::GenerateTNForEditedImage(const TFileName aEditedFileName, const TReal aAspectRatio)
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::GenerateTNForEditedImage++"));
+
+    iSavedFileName.Copy(aEditedFileName);
+    
+    //set iSingleTNGeneration mode on
+    iSingleTNGeneration = ETrue; 
+    iAspectRatio = aAspectRatio;
+     
+    /*Generating 128x128 Thumbnail path */
+    iIEEngineUtils.GenerateThumbnailFileName(ESize128x128, aEditedFileName, iTNFilename);
+ 
+    //Create new imagedata instance to be appended to filename array
+    iTmpImageData = CImageData::NewL();
+    iTmpImageData->SetSize(TSize(128 * iAspectRatio, 128)); // TODO no size info
+    
+    iLatestCreatedTNSize = ESize128x128;
+    iIEBgpsClient->GenerateTN(aEditedFileName, iTNFilename, TSize(128,128));
+    //iIEBgpsClient->GenerateTN(aEditedFileName, iTNFilename, TSize(32,32));//mikares32
+    
+    DP0_IMAGIC(_L("CIEBgpsController::GenerateTNForEditedImage--"));
+    }
+
+void CIEBgpsController::FilenameArrayCountChanged(const RArray<CImageData*>& aImageDataArray)
+    {
+    iImageDataArray = aImageDataArray;
+    //iIEBgpsControllerObserver.TotalNumberOfImagesChanged(iImageDataArray.Count());
+    }
+
+CImageData* CIEBgpsController::GetImageData(const TInt aIndex)
+    {
+    DP1_IMAGIC(_L("CIEBgpsController::GetImageData %d"), aIndex);
+    
+    return (aIndex <= iImageDataArray.Count()) ? iImageDataArray[aIndex] : NULL;
+    }
+
+void CIEBgpsController::GetFaceCoordinates(const TFileName aTNFileName, RArray<TRect>& aFaceCoordinateArray)
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::GetFaceCoordinates"));
+    aFaceCoordinateArray.Reset();
+    //iIEBgpsClient->FindFaces(aTNFileName, aFaceCoordinateArray);
+    }
+
+//If background face Detection is still continuing, we have to use GetSingleFaceCoordinates() function to get face coordinates
+void CIEBgpsController::GetSingleFaceCoordinates(TInt aIndex, const TFileName /*aTNFileName*/, RArray<TRect>& aFaceCoordinateArray)
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::GetSingleFaceCoordinates++"));
+    
+    if(i128x128TNCreationOn || i512x512TNCreationOn || i32x32TNCreationOn)
+        {
+        iTnCreationCancelled = ETrue;
+        CancelTNGeneration();
+        i128x128TNCreationOn = EFalse;
+        i512x512TNCreationOn = EFalse;
+        i32x32TNCreationOn = EFalse;
+        }
+
+    iSingleFBIndex = aIndex;
+    iSingleFBCoordinateArray = &aFaceCoordinateArray;
+    
+    //If BGPS face Detection was on, we have to stop it first. Othervice we can contiue directly to StartSingleFaceDetection() 
+    if(iBackGroundFaceDetectionOn)
+        {//We just cancel background face Detection, when cancel is complete we get callback to StartSingleFaceDetection()
+        //iIEBgpsClient->CancelFaceDetection();
+        iBackGroundFaceDetectionOn = EFalse;
+        }
+    else
+        {
+        //StartSingleFaceDetection();
+        }
+    
+    DP0_IMAGIC(_L("CIEBgpsController::GetSingleFaceCoordinates--"));
+    }
+
+/* Creating Single Thumbnails for Editing. After editing the image we are 
+ * genereating the thumbnails 128x128 & 640x480 resolution*/
+void CIEBgpsController::CreateSingleTNL()
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::CreateSingleTN++"));
+    
+    if(iLatestCreatedTNSize == ESize128x128)  
+        {
+        //Create and set data to image data item
+        iTmpImageData->SetFileNameL(iSavedFileName);
+        iImageDataArray[iImageIndex]->SetImageReady(EFullSize, ETrue);
+        iImageDataArray[iImageIndex]->SetImageReady(ESize32x32, EFalse);
+        iImageDataArray[iImageIndex]->SetImageReady(ESize512x512, EFalse);
+        iImageDataArray[iImageIndex]->SetImageReady(ESize128x128, ETrue);
+                
+        //Insert new image data to filename array
+        iFileLoader->AddNewImage(iTmpImageData, iImageIndex);
+        iImageDataArray = iFileLoader->GetFileNameArray();
+        //iIEBgpsControllerObserver.TotalNumberOfImagesChanged(iImageDataArray.Count());
+        
+        /*Generating 320x320 Tumbnail path */
+        iIEEngineUtils.GenerateThumbnailFileName(ESize32x32,iSavedFileName,iTNFilename);
+        iIEBgpsControllerObserver.TNGenerationComplete(ESize128x128);
+        
+        iLatestCreatedTNSize = ESize32x32;
+        TSize size;
+
+        TInt w, h;
+        if(iImageDataArray[iImageIndex]->GetAspectRatio() > 1)
+            {//Landscape
+            w=320;
+            h = 320/iImageDataArray[iImageIndex]->GetAspectRatio();
+            if(h%2 != 0)
+                h++;
+            }
+        else//Portrait
+            {
+            h = 320;
+            w = 320 * iImageDataArray[iImageIndex]->GetAspectRatio();
+            if(w%2 != 0)
+                w++;
+            }
+        size.iHeight = h;
+        size.iWidth = w;
+        
+        iTNSize = size;
+        iIEBgpsClient->GenerateTN(iSavedFileName, iTNFilename, size);
+        }
+    
+    else if(iLatestCreatedTNSize == ESize32x32)
+        {
+        iImageDataArray = iFileLoader->GetFileNameArray();
+        iImageDataArray[iImageIndex]->SetImageReady(ESize32x32, ETrue);
+        //iSingleTNGeneration = EFalse;
+        
+        iIEBgpsControllerObserver.TNGenerationComplete(ESize32x32);
+        
+        TSize size;
+        size.iHeight = 512;
+        size.iWidth = 512;
+        
+        iIEEngineUtils.GenerateThumbnailFileName(ESize512x512, iSavedFileName, iTNFilename);
+        
+        iTNSize = size;
+        iIEBgpsClient->GenerateTN(iSavedFileName, iTNFilename, size);
+        
+        iLatestCreatedTNSize = ESize512x512;
+        }
+    
+    //TN creation complete
+    else
+        {
+        iSingleTNGeneration = EFalse;
+        
+        iImageDataArray[iImageIndex]->SetImageReady(ESize512x512, ETrue);
+        
+        //Insert new image data to filename array
+        iFileLoader->ModifyImageData(iTmpImageData, iImageIndex);
+                
+        //Call observer/AppUI class about completing TN creation
+        iIEBgpsControllerObserver.TNGenerationComplete(ENotDefined);
+        }
+    
+    DP0_IMAGIC(_L("CIEBgpsController::CreateSingleTN--"));
+    }
+
+void CIEBgpsController::DeleteCorruptedThumbNailFile(TFileName aFileName)
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::DeleteCorruptedThumbNailFile++"));
+    
+    //Checking for if we generated Imgaic TN already from iCorrupted file and delete it
+    //if(aFileName.Find(KPAlbTNFilePath) != KErrNotFound)
+        if(BaflUtils::FileExists(iFileServer, aFileName))
+            {
+            TInt err = BaflUtils::DeleteFile(iFileServer, aFileName);
+            DP2_IMAGIC(_L("CIEBgpsController::DeleteCorruptedThumbNailFile - file found: %S, err:%d"), &aFileName, err);
+            }
+    
+    DP0_IMAGIC(_L("CIEBgpsController::DeleteCorruptedThumbNailFile--"));
+    }
+
+//Finds optimal size for 128x128 TN creation
+void CIEBgpsController::CheckOptimalFileFor128x128TnCreation(TInt aIndex, TFileName& aFileName)
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::CheckOptimalFileForTnCreation++"));
+
+    //TFileName tmpName;
+    //iImageDataArray[aIndex]->GetFileName(tmpName, E512x512Thumbnail);
+    if(iImageDataArray[aIndex]->IsImageReady(ESize512x512))
+    //if(BaflUtils::FileExists(iFileServer, tmpName))
+        {
+        iImageDataArray[aIndex]->GetFileName(aFileName, ESize512x512);
+        DP1_IMAGIC(_L("CIEBgpsController::CheckFileNmaesExitst - filename exits: %S"), &aFileName);
+        }
+    else//(iFileNameData[aIndex]->IsImageReady(EOriginalImage))
+        {
+        iImageDataArray[aIndex]->GetFileName(aFileName, EFullSize);
+        DP1_IMAGIC(_L("CIEBgpsController::CheckFileNmaesExitst - filename exits: %S"), &aFileName);
+        }
+    
+    DP0_IMAGIC(_L("CIEBgpsController::CheckOptimalFileForTnCreation--")); 
+    }
+
+//Finds optimal size for 32x32 TN creation
+void CIEBgpsController::CheckOptimalFileFor32x32TnCreation(TInt aIndex, TFileName& aFileName)
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::CheckOptimalFileForTnCreation++"));
+    if(iImageDataArray[aIndex]->IsImageReady(ESize128x128))
+        {
+        iImageDataArray[aIndex]->GetFileName(aFileName, ESize128x128);
+        DP1_IMAGIC(_L("CIEBgpsController::CheckFileNmaesExitst - filename exits: %S"), &aFileName);
+        }
+
+/*    else if(iImageDataArray[aIndex]->IsImageReady(E128x96Thumbnail))
+        {
+        iImageDataArray[aIndex]->GetFileName(aFileName, E128x96Thumbnail);
+        DP1_IMAGIC(_L("CIEBgpsController::CheckFileNmaesExitst - filename did not exits: %S"), &aFileName);
+        }*/
+    else if(iImageDataArray[aIndex]->IsImageReady(ESize512x512))
+
+        {
+        iImageDataArray[aIndex]->GetFileName(aFileName, ESize512x512);
+        DP1_IMAGIC(_L("CIEBgpsController::CheckFileNmaesExitst - filename exits: %S"), &aFileName);
+        }
+    else//(iFileNameData[aIndex]->iMG_FileExist)
+        {
+        //DP1_IMAGIC(_L("CIEBgpsController::CheckFileNmaesExitst - filename OK: %S"), &aFilename);
+        iImageDataArray[aIndex]->GetFileName(aFileName, EFullSize);
+        DP1_IMAGIC(_L("CIEBgpsController::CheckFileNmaesExitst - filename exits: %S"), &aFileName);
+        }
+    
+    DP0_IMAGIC(_L("CIEBgpsController::CheckOptimalFileForTnCreation--")); 
+    }
+
+void CIEBgpsController::Generate128x128Thumbnails(TInt aIndex)
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::Generate128x128Thumbnails++"));
+    //DP1_IMAGIC(_L("CIEBgpsController::Generate128x128Thumbnails - New TN to be created: %S"), &iImageDataArray[aIndex]->iIETN_128x128_Filename);
+    iImageDataArray[aIndex]->GetFileName(iTNFilename, ESize128x128);
+    iImageDataArray[aIndex]->GetFileName(iJpegFilename, EFullSize);
+    CheckOptimalFileFor128x128TnCreation(aIndex,iJpegFilename);
+#ifdef USE_64X64_BITMAP_TN
+    TSize size(64,64);
+#else
+    TSize size(128,128);
+#endif
+    
+    iIEBgpsClient->GenerateTN(iJpegFilename, iTNFilename, size);
+    
+    DP0_IMAGIC(_L("CIEBgpsController::Generate128x128Thumbnails--"));
+    }
+
+void CIEBgpsController::Generate32x32Thumbnails(TInt aIndex)
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::Generate32x32Thumbnails++"));
+//    DP1_IMAGIC(_L("CIEBgpsController::Generate320x320Thumbnails - New TN to be created: %S"), &iImageDataArray[aIndex]->iIETN_32x32_Filename);
+    iImageDataArray[aIndex]->GetFileName(iTNFilename, ESize32x32);
+    iImageDataArray[aIndex]->GetFileName(iJpegFilename, EFullSize);
+    CheckOptimalFileFor32x32TnCreation(aIndex,iJpegFilename);
+    TSize size(32,32);
+    iIEBgpsClient->GenerateTN(iJpegFilename, iTNFilename, size);
+    
+    DP0_IMAGIC(_L("CIEBgpsController::Generate32x32Thumbnails--"));
+    }
+
+void CIEBgpsController::Generate512x512Thumbnails(TInt aIndex)
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::Generate512x512Thumbnails++"));
+    //DP1_IMAGIC(_L("CIEBgpsController::Generate640x480Thumbnails - New TN to be created: %S"), &iImageDataArray[aIndex]->iIETN_512x512_Filename);
+    
+    iImageDataArray[aIndex]->GetFileName(iTNFilename, ESize512x512); 
+    iImageDataArray[aIndex]->GetFileName(iJpegFilename, EFullSize);
+    TSize size(512,512);
+    iIEBgpsClient->GenerateTN(iJpegFilename, iTNFilename, size);
+    
+    DP0_IMAGIC(_L("CIEBgpsController::Generate512x512Thumbnails--"));
+    }
+
+
+/*TReal CIEBgpsController::ReadAspectRatioL(TFileName& aFileName)
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::ReadAspectRatio++"));
+
+    CImageDecoder* imageDecoder = NULL;
+    imageDecoder = CImageDecoder::FileNewL(iFileServer, aFileName);
+ 
+    TFrameInfo frameInfo = imageDecoder->FrameInfo();
+    TSize size = frameInfo.iFrameCoordsInPixels.Size();
+    
+    if(imageDecoder)
+        {
+        delete imageDecoder;
+        imageDecoder = NULL;   
+        }
+    
+    DP0_IMAGIC(_L("CIEBgpsController::ReadAspectRatio--"));
+    
+    return (TReal)size.iWidth/(TReal)size.iHeight; 
+
+    }*/
+
+void CIEBgpsController::StartTNCreatorL()
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::StartTNCreator++"));
+    
+    TThumbSize res;
+    if((iTnCreationIndex = FindMissingTN(res)) < 0) {
+        iIEBgpsControllerObserver.TNGenerationComplete(ENotDefined);
+        return;
+    }
+    
+    //start creating thumbnails by calling TN creator
+    //callback when one TN is created is done to CIEBgpsController::ThumbnailGenerationCompleted function
+    if(res == ESize512x512)
+        {
+        i512x512TNCreationOn = ETrue;
+        i128x128TNCreationOn = EFalse;
+        i32x32TNCreationOn = EFalse;
+        Generate512x512Thumbnails(iTnCreationIndex);
+        }
+    else if(res == ESize128x128)
+        {
+        i512x512TNCreationOn = EFalse;
+        i128x128TNCreationOn = ETrue;
+        i32x32TNCreationOn = EFalse;
+        Generate128x128Thumbnails(iTnCreationIndex);
+        }
+    else if(res == ESize32x32)
+        {
+        i512x512TNCreationOn = EFalse;
+        i128x128TNCreationOn = EFalse;
+        i32x32TNCreationOn = ETrue;
+        Generate32x32Thumbnails(iTnCreationIndex);
+        }
+    else
+        {
+        //All TNs were already done
+        iIEBgpsControllerObserver.TNGenerationComplete(ENotDefined);
+        //We complete face Detection here also because if there was no new images added -> no need to start face Detection in BGPS
+        iIEBgpsControllerObserver.FaceDetectionComplete();
+        }
+    
+    DP0_IMAGIC(_L("CIEBgpsController::StartTNCreator--"));
+    }
+
+//Returns index of first missing TN from any TN size
+TInt CIEBgpsController::FindMissingTN(TThumbSize& aRes)
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::FindMissingTN++"));
+    
+    TInt currentIndex = iIEBgpsControllerObserver.GetSelectedImageIndex();
+    CImageData* gridData = iIEBgpsControllerObserver.GetImageData(currentIndex);
+    
+    TInt tnIndex = -1;
+    
+    for(TInt i = 0; i<iImageDataArray.Count(); i++)
+        {
+        // Check to positive and negative direction from current picture
+        for (TInt j=0; j<2; j++)
+            {
+            // Calculate image index
+            tnIndex = currentIndex + (j ? i : -i);
+            
+            // Check that index is valid
+            if (tnIndex < 0 || tnIndex >= iImageDataArray.Count())
+                continue;
+            
+        CImageData* imageData = iIEBgpsControllerObserver.GetImageData(tnIndex);
+        
+        //Mark image as corrupted so we do not try to generate TN or load it
+        if(imageData->iGridData.iCorrupted)
+            {
+            tnIndex = -20/*KErrCorrupt*/;
+            continue;
+            }
+    
+        if(!iImageDataArray[tnIndex]->IsImageReady(ESize512x512))
+            {
+            TFileName filename;
+            iImageDataArray[tnIndex]->GetFileName(filename,ESize512x512);
+            DP1_IMAGIC(_L("CIEBgpsController::FindMissingTN - Filename to be crated: %S"), &filename);
+            aRes = ESize512x512;
+            //break;
+            return tnIndex;
+            }
+        if(!iImageDataArray[tnIndex]->IsImageReady(ESize128x128))
+            {
+            TFileName filename;
+            iImageDataArray[tnIndex]->GetFileName(filename,ESize128x128);
+            DP1_IMAGIC(_L("CIEBgpsController::FindMissingTN - Filename to be crated: %S"), &filename);
+            aRes = ESize128x128;
+            //break;
+            return tnIndex;
+            }
+        if(!iImageDataArray[tnIndex]->IsImageReady(ESize32x32))
+            {
+            TFileName filename;
+            iImageDataArray[tnIndex]->GetFileName(filename,ESize32x32);
+            DP1_IMAGIC(_L("CIEBgpsController::FindMissingTN - Filename to be crated: %S"), &filename);
+            aRes = ESize32x32;
+            //break;
+            return tnIndex;
+            }
+        }
+    }
+    DP0_IMAGIC(_L("CIEBgpsController::FindMissingTN--"));
+    return -1;    
+    }
+
+void CIEBgpsController::CancelTNGeneration()
+    {
+    DP0_IMAGIC(_L("CIEBgpsController::CancelTNGeneration"));
+    
+    iIEBgpsClient->CancelTNGeneration();    
+    }
+
+
+// EOF