/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "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:

* Ixonos Plc

*

* Description:  

*

*/

//  INCLUDES

#include <eikenv.h>

#include <bautils.h>

#include <e32math.h>

#include "ImageEditorError.h"

#include "ImageEditorImageController.h"

#include "ImageEditorPluginManager.h"

#include "ImageEditorImageHandler.h"

#include "ResolutionUtil.h"

#include "ImageEditorPanics.h"

#include "SystemParameters.h"

#include "imageeditordebugutils.h"

#include "editorversion.h"

#include "commondefs.h"

//  CONSTANTS

//  Panic category

_LIT(KComponentName, "CImageController");

//=============================================================================

CImageController * CImageController::NewL (

	MImageControllerObserver *		aObserver,

	CImageEditorPluginManager *		aManager

	)

{

	CImageController * self = new (ELeave) CImageController;

	CleanupStack::PushL (self);

	self->ConstructL (aObserver, aManager);

	CleanupStack::Pop(); // self

	return self;

}

//=============================================================================

CImageController::~CImageController ()

{

    LOG(KImageEditorLogFile, "CImageController::~CImageController() starting...");

	Cancel();

	DeletePreviewBitmap();

	delete iImageHandler;

    iManager = NULL;

    iObserver = NULL;

    LOG(KImageEditorLogFile, "CImageController::~CImageController() finished.");

}

//=============================================================================

void CImageController::ConstructL (

	MImageControllerObserver *		aObserver,

	CImageEditorPluginManager *		aManager

	)

    {

	CActiveScheduler::Add (this);

	iObserver = aObserver;

	iManager = aManager;

	iImageHandler = CImageEditorImageHandler::NewL ();	

    iQuality = KDefaultSavedJpegQuality;

    iJpegImage = EFalse;

    iIsCancelled = EFalse;

    LOG(KImageEditorLogFile, "CImageController: Image controller created");

    }	

//=============================================================================

void CImageController::LoadImageL (const TDesC & aFileName)

    {

	LOGFMT(KImageEditorLogFile, "CImageController: Loading image %S", &aFileName);

    iOperation = MImageControllerObserver::EOperationCodeLoad;

    iIsCancelled = EFalse;

    //	If active, cancel

    if ( IsActive() )

        {

        Cancel();

        }

    //	Create new CFbsBitmap

    DeletePreviewBitmap();

    CreatePreviewBitmapL();

    TBool useIPECodec = EFalse;

    // try open first with IPE ICL codec

	LOG (KImageEditorLogFile, "CImageController::LoadImageL() -- try open image with ICL");

    //	Create new TFileName and store it

    iManager->SetImageName (aFileName);

    //	Load RAJPEG image

	TRAPD ( err, iManager->LoadImageL( useIPECodec ) );

    if ( KErrNone == err )

        {

        LOG (KImageEditorLogFile, "CImageController::LoadImageL() -- image opened with ICL");

        //  Force RunL()

        CompleteRequest();

        }

    else

        {

        LOG (KImageEditorLogFile, "CImageController::LoadImageL() -- failed open image with ICL");

        // Try with IPE codec

        useIPECodec = ETrue;        

        }

    if ( useIPECodec )

        {

        //	If JPEG source image, try opening with IPE JPEG filter

        iJpegImage = iImageHandler->IsRajpegImageL (aFileName);

        if ( !iJpegImage )

            {

            iObserver->OperationReadyL ( iOperation, KSIEEIncompatibleImage );

            }

        else

            {            

    		LOG(KImageEditorLogFile, "CImageController::LoadImageL() -- open JPEG image with IPE");

            //	Create new TFileName and store it

            iManager->SetImageName (aFileName);

            //	Load RAJPEG image

    		TRAPD (err, iManager->LoadImageL( useIPECodec ));

            if (KErrNone == err)

                {

                //  Force RunL()

                CompleteRequest();

                }

            else if ((KSIEEIncompatibleImage == err) || (KErrNotSupported == err))

                {

    			LOG (KImageEditorLogFile, "CImageController::LoadImageL() -- JPEG not supported");

    			iObserver->OperationReadyL ( iOperation, err ); 

                }

            // Added because system runs out of memory if jpeg size is too big 

            // (around 5 Mb)

            else if ( KErrNoMemory == err ) 

                {

    			LOG (KImageEditorLogFile, "CImageController::LoadImageL() -- Not enough memory to use IPE");

    			iObserver->OperationReadyL ( iOperation, err );

                }

            else

                {

                User::Leave (err);

                }

            }

        }

}

//=============================================================================

void CImageController::SaveImageL (const TDesC & /*aFileName*/)

{

    LOG(KImageEditorLogFile, "CImageController: Saving image");

    // Start saving operation

	iOperation = MImageControllerObserver::EOperationCodeBlockSave;

    iSavedPercentage = 1;

    iSavedPercentageOld = 1;

    iIsCancelled = EFalse;

	iManager->PrepareAsyncSaveL (iQuality);

    //  Force RunL()

    CompleteRequest();

}

//=============================================================================

TInt CImageController::RenameImage (

	const TDesC	&		aFileNameSrc,

	const TDesC	&		aFileNameDst

	) const

{

	return iImageHandler->RenameImage (aFileNameSrc, aFileNameDst);

}

//=============================================================================

TInt CImageController::DeleteImage (const TDesC & aFileName) const

{

	return iImageHandler->DeleteImage (aFileName);

}

//=============================================================================

void CImageController::DoCancel()

{

    LOG(KImageEditorLogFile, "CImageController::DoCancel");

    if( IsActive() )

    {

        iImageHandler->CleanupConverters();

    }

}

//=============================================================================

void CImageController::CancelOperation (TBool aForce)

{

    LOGFMT(KImageEditorLogFile, "CImageController::CancelImageController: iOperation == %d", iOperation);

    iIsCancelled = ETrue;

	// Handle cancelling block save

	if (aForce)

	{

		CompleteRequest();

	}

}

//=============================================================================

void CImageController::RunL ()

{

    switch (iOperation)

    {

        /// Loading images

        case MImageControllerObserver::EOperationCodeLoad:

        {

            LOG(KImageEditorLogFile, "CImageController: Loading completed");

            iObserver->OperationReadyL ( iOperation, iStatus.Int() );

            break;

        }

        case MImageControllerObserver::EOperationCodeBlockLoad:

        {

            LOG(KImageEditorLogFile, "CImageController: Loading completed");

            iObserver->OperationReadyL ( iOperation, iStatus.Int() );

            break;

        }

        /// Block saving images

        case MImageControllerObserver::EOperationCodeBlockSave:

        {

            // Handle cancelling block save

            if (iIsCancelled)

            {

                LOG(KImageEditorLogFile, "CImageController: Saving cancelled");

				iManager->SaveAbortL();

                iObserver->OperationReadyL ( iOperation, KErrCancel );

            }

            else

            {

                // Increment progress bar

                if ( iSavedPercentage > iSavedPercentageOld )

                {

                    iObserver->IncrementProgressBarL (iSavedPercentage - iSavedPercentageOld);

                  	iSavedPercentageOld = iSavedPercentage;

                }

                // 	Save next block

                iSavedPercentage = iManager->SaveBlockL();

                //	Complete?

                if (iSavedPercentage == 100)

                {

                    // Save completed

                    LOG(KImageEditorLogFile, "CImageController: Saving completed");

                    iManager->FinishAsyncSaveL();

                    iObserver->OperationReadyL ( iOperation, iStatus.Int() );

                }

                //	Save next block

                else

                {

                    CompleteRequest();

                }

            }

            break;

        }

        /// Saving images

        case MImageControllerObserver::EOperationCodeSave:

        {

            iObserver->OperationReadyL ( iOperation, iStatus.Int() );

            break;

        }

        /// Deleting images

        case MImageControllerObserver::EOperationCodeDelete:

        /// Renaming images

        case MImageControllerObserver::EOperationCodeRename:

        /// Searching images

        case MImageControllerObserver::EOperationCodeSearch:

        default:

        {

            User::Panic(KComponentName, EImageEditorPanicUnexpectedCommand);

            break;

        }

    }

}

//=============================================================================

CImageController::CImageController () : 

CActive (CActive::EPriorityStandard)

{

}

//=============================================================================

void CImageController::CreatePreviewBitmapL () 

{

	LOG(KImageEditorLogFile, "CImageController: Creating preview bitmap");

    // Get current screen rect

    TRect rect;

    CResolutionUtil::Self()->GetClientRect(rect);

    TSize size = rect.Size();

	LOG(KImageEditorLogFile, "CImageController: Resolution read");

	LOGFMT(KImageEditorLogFile, "  Width: %d", size.iWidth);

    LOGFMT(KImageEditorLogFile, "  Height: %d", size.iHeight);

    //	Create bitmap

    if (iPreview)

    {

        delete iPreview;

        iPreview = NULL;

    }

    iPreview = new (ELeave) CFbsBitmap;

	User::LeaveIfError ( iPreview->Create ( size, EColor16M) );

    // Set bitmap

    iManager->SetPreviewImage (iPreview);

}

//=============================================================================

void CImageController::DeletePreviewBitmap() 

{

    LOG(KImageEditorLogFile, "CImageController: Deleting preview bitmap");

	delete iPreview;

    iPreview = NULL;

	iManager->SetPreviewImage (NULL);

}

//=============================================================================

void CImageController::CompleteRequest()

{

	if ( IsActive() )

	{

		Cancel();

	}

	TRequestStatus * p = &iStatus;

	SetActive();

	User::RequestComplete (p, KErrNone);

}

//=============================================================================

void CImageController::CalculateProgressInterval (TInt aBlockCount)

{

    const TInt KMaxProgressSteps = 25;

    iProgressBarInterval = 1;

    while( (aBlockCount / iProgressBarInterval) > KMaxProgressSteps )

    {

        iProgressBarInterval++;

    }

    LOGFMT(KImageEditorLogFile, "CImageController: Progress bar interval: %d", iProgressBarInterval);

}

// End of File