/*
* Copyright (c) 2008 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:  Image processor
*
*/


#ifndef CVIMPSTIMAGEPROCESSOR_H
#define CVIMPSTIMAGEPROCESSOR_H

#include <f32file.h>
#include "mvimpstimageprocessobserver.h"
class CImageDecoder;
class CBitmapScaler;
class CFbsBitmap;
class CImageEncoder;
// CLASS DECLARATION

/**
 *  Image processor
 *
 *  @lib vimpstutils.dll
 */
class CVimpstImageProcessor : public CActive
	{
   public: 
   		/**
	     * Content processing states
	     */
	    enum TContentProcessState
	        {
	        EContentNotProcessed = 0,
	        EConvertImageDatatoBitmap,
	        EScaleBitmap, 
	        EConentFromScaledBitmap,
	        EProcessingComplete
	        };
    public: // Construction
		
		/**
		 * Construction
		 */
		static CVimpstImageProcessor* NewL( MCAImageProcessObserver* aObserver);
		
		/**
		 * Destruction
		 */
		~CVimpstImageProcessor();
		
	private: // Construction
	
		/**
		 * Constructor
		 */
		CVimpstImageProcessor(MCAImageProcessObserver* aObserver);
		
		/**
		 * Constructor
		 */
		void ConstructL();

    private: // From CActive
    
        /**
         * @see CActive
         */
	    void RunL();
	    	    
        /**
         * @see CActive
         */
	    void DoCancel();
	    
        /**
         * @see CActive.
         */
		TInt RunError( TInt aError );	    
		
   public: 
       /**
        * This is used when the image data is ready
        * image data is proceesed and the new content is of the image is given
        * by reducing the image data size
        * 
        * @param  aImageData : Content of the image file
        * @param  aMimeType : Mime type of the file from which the content is passed
        */
       TInt ProcessFromDataL( const TDesC8& aImageData , const TDesC8& aMimeType);
       /**
        * This is used when the image data is ready
        * image data is proceesed and the new content is of the image is given
        * by reducing the image data size
        * 
        * @param  aFileName : image file name
        * @param  aMimeType : Mime type of the file from which the content is passed
        */
       void ProcessFromFileL( const TDesC& aFileName , const TDesC8& aMimeType);
       /**
        * Cancel the image processing operation 
        */ 
       void CancelProcessing();
       /**
        * Register the observer to give callback
        * once the processing is done
        * @param  aObserver : obeserver
        */   
       void RegisterObserver( MCAImageProcessObserver* aObserver );
       /**
        * Retrieve the processed image
        * Ownership of iContent is transferred to caller
        * @return  processed image
        */  
       HBufC8* GetContentData();
       /**
        * Get Bitmap
        * @return bitmap
        */   
       CFbsBitmap& Bitmap();
           
   private: // New helper methods
       
       /**
        * Convert image to bitmap
        */
       void  ConvertImageToBitmapL();
       /**
        * Scale Bit map
        */
       void  ScaleBitmapL();
       /**
        * store scaled bitmap content into iimageencoder
        */
       void  ContentFromScaledBitmapL();
       /**
         * Get new size after decoding.
         * Scale to nearest (larger or equal) size with ratio 1:1, 1:2, 1:4 or 1:8
         * directly when decoding.
         *
         * @param aSize Size of original image
         * @param aTargetSize Size of target image
         * @param aAnyRatio Set this to ETrue if the decoder is cabable of scaling to any          *  ratio
         * @return New size of decoded image
         */
        TSize DecodeSize( const TSize& aSize, const TSize& aTargetSize,
                          TBool aAnyRatio );
        
        /**
         * Get new size after scaling. If scale not needed return EFalse
         * Scaled size will be 40x30 if width > height or 30x40 if 
         * height > width.
         *
         * @param aSize Original size of image
         * @param aNewSize New size of scaled image
         * @return ETrue if scale needed.
         */
        TBool ScaleSize( const TSize& aSize, TSize& aNewSize );
        
        /**
         * Notify observer for completion and remove message from array         
         */
        void CompleteRequestL();
        /**
         * Reset current operation and remove all pending messages from stack.
         * @param aReason reson for reseting
         */
        void ResetProcessingL( TInt aReason );
        
        /**
         * Deletes and cancels all processing units ( decoder, encoder etc ).
         */
        void ClearState();

    
    private: // Data
    
        /// File system access
        RFs iFs;
        
        // Decoder for image.
        CImageDecoder* iImageDecoder;
        CBitmapScaler* iScaler;
        CImageEncoder* iImageEncoder;
        /**
         *  Bitmap. Owns.
         */
        CFbsBitmap* iBitmap;
        /**
         *  Target size for bitmap
         */
        TSize iTargetSize;

        /**
         *  Thumbnail size for bitmap
         */
        TSize iThumbSize;
        /**
         * Doesn't Own
         */ 
        HBufC8* iContent;

        /// Owns.
        HBufC8* iMimeType;
        TContentProcessState iProcessingState;
        HBufC* iFilename;
        
        MCAImageProcessObserver* iObserver;
        TInt iScaleSize;    
        TBool isBitmapReturned;
        };

#endif      // CVIMPSTIMAGEPROCESSOR_H

// End of File