/*
* Copyright (c) 2002 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:  
*      GMS picture viewer control which is compatible with Editor Base.
*      It is based very much on the CMmsImageControl.
*  %version: bh1cfmsg#16 %
*
*/



// INCLUDE FILES
#include "CGmsPictureControl.h"

#include <coeutils.h>               // for ConeUtils::FileExists
#include <AknUtils.h>
#include <imageconversion.h>
#include <aknlayoutscalable_apps.cdl.h>
#include <MIHLScaler.h>

// CONSTANTS

// Mime type of the image, required by the decoder.
_LIT8( KGmsOtaMimeType, "image/x-ota-bitmap");

_LIT(KSmEditorGmsPic,"smeditor gmsPic");

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

/**
* Helper class which allows CGmsPictureControl to receive a callback
* to it's callback method when an asynchronous operation has finished.
* CAsyncCallBack needed tweaking since it is ment for callback only, and
* it completes the task immediately.
*/
class CGmsAOCallBack: public CAsyncCallBack
    {
    public:
    
        CGmsAOCallBack( const TCallBack &aCallBack, TInt aPriority )
            : CAsyncCallBack( aCallBack, aPriority )
            {
            }
        
        void SetItActive() 
            {
            SetActive();
            }
        
    protected:         
       
        void RunL()
            {
            iCallBack.CallBack();
            }
    };


//  MEMBER FUNCTIONS

EXPORT_C CGmsPictureControl* CGmsPictureControl::NewL(
    const CCoeControl* aParent)
{
    CGmsPictureControl* self = new(ELeave) CGmsPictureControl();

    CleanupStack::PushL(self);
    self->ConstructL(aParent);
    CleanupStack::Pop(self);

    return self;
}

EXPORT_C CGmsPictureControl::~CGmsPictureControl()
{
    delete iBitmap;
    iBitmap = NULL;
    delete iScaledBitmap;
    iScaledBitmap = NULL;    
        
    delete iConverter;
    iConverter = NULL;
    delete iScaler;
    delete iConversionAO;
    delete iScalingAO;    
    iFs.Close();
}

EXPORT_C void CGmsPictureControl::LoadImageL(
    const TFileName& aImageFile,
    TUint            aMaxHeight /* = 0 */)
{
    __ASSERT_DEBUG((aImageFile.Length() > 0), Panic( ENoImageFile ) );

    if (!ConeUtils::FileExists(aImageFile))
    {
        User::Leave(KErrNotFound);
    }
    if (aMaxHeight)
    {
        iMaxHeight = aMaxHeight;
    }
    
    Reset();
        
    iConverter = CImageDecoder::FileNewL( iFs, aImageFile, KGmsOtaMimeType );
    __ASSERT_ALWAYS( iConverter->FrameCount() == 1, Panic(EBadImageContent) );
    TFrameInfo frameInfo = iConverter->FrameInfo( 0 );
    iBitmap = new( ELeave ) CFbsBitmap;
    User::LeaveIfError( iBitmap->Create( frameInfo.iOverallSizeInPixels,
                                         EGray2 ) );
                                             
    iConverter->Convert( &(iConversionAO->iStatus), *iBitmap );
	iConversionAO->SetItActive();
}

EXPORT_C TSize CGmsPictureControl::OriginalImageResolution() const
{
    TSize size(0,0);
    if ( iConverter )
        {
        size = iConverter->FrameInfo( 0 ).iOverallSizeInPixels;
        }
    return size;
}

TRect CGmsPictureControl::CurrentLineRect()
{
    return Rect();
}

void CGmsPictureControl::SetAndGetSizeL(TSize& aSize)
{
    // Size proposed in aSize parameter is used, only height is
    // proposed by this control.
    
    if (AknLayoutUtils::ScalableLayoutInterfaceAvailable())
    {        
        TAknWindowComponentLayout layout =
            AknLayoutScalable_Apps::mce_image_pane_g3();
        TAknLayoutRect layoutRect;
    	layoutRect.LayoutRect( Rect(), layout.LayoutLine() );
    	aSize.iHeight = layoutRect.Rect().Height();
    	
        // Adjust max height if needed
        if ( iMaxHeight > 0 && (TUint)aSize.iHeight > iMaxHeight )
        {
            aSize.iHeight = iMaxHeight;
        }    	
    }
    
    else
    { // use old sizing functionality if scalable IF isn't available:
        aSize = CalculateControlSize(aSize);
    }

    SetSizeWithoutNotification(aSize);
}

/**
* This internal function is the old version and is used ONLY if scalable
* layout interface is NOT available. This should be removed when it is always
* available.
*/
const TInt KGmsImageHeightMax = 58;
const TInt KBaseLineDelta = 17;

TSize CGmsPictureControl::CalculateControlSize(TSize& aProposedSize)
    {
    // These lines below, although they look a bit strange, are required to
    // conform with old sizing functionality when scalable layout IF is
    // not available:
    if ( iMaxHeight == 0 )
        { // max height hasn't been set by the client:
        iMaxHeight = KGmsImageHeightMax;
        }
    if ( (TUint)aProposedSize.iHeight > iMaxHeight )
        { // proposed size is greater than max size -> adjust:
        aProposedSize.iHeight = iMaxHeight;
        }    
    
    TSize trgSize(aProposedSize.iWidth, 0);
    
    if (!iConverter)
        {
        return trgSize;
        }
    
    TSize bmpSize = OriginalImageResolution();
    
    bmpSize.SetSize(bmpSize.iWidth*2, bmpSize.iHeight*2);
    
    if (bmpSize.iHeight < aProposedSize.iHeight)
        {
        trgSize.iHeight = bmpSize.iHeight;
        }
    else
        {
        trgSize.iHeight = aProposedSize.iHeight;
        }
    
    // For "wide" images height may be too big - check aspect ratio
    TReal widthRatio  = (TReal)bmpSize.iWidth  / (TReal)trgSize.iWidth;
    TReal heightRatio = (TReal)bmpSize.iHeight / (TReal)trgSize.iHeight;
    
    if (widthRatio > heightRatio)
        {
        // image must be scaled more in vertical size
        trgSize.iHeight = (TInt)(bmpSize.iHeight / widthRatio);
        }
    
    if (trgSize.iHeight%KBaseLineDelta)
        {
        trgSize.iHeight = trgSize.iHeight-trgSize.iHeight%KBaseLineDelta+KBaseLineDelta;
        }    
    return trgSize;
    }

void CGmsPictureControl::ClipboardL(TMsgClipboardFunc /*aFunc*/)
{
    User::Leave(KErrNotSupported);  // Image control does not support clipboard
}

void CGmsPictureControl::EditL(TMsgEditFunc /*aFunc*/)
{
    User::Leave(KErrNotSupported);  // Image control is not editable
}

TBool CGmsPictureControl::IsFocusChangePossible(TMsgFocusDirection /*aDirection*/) const
{
    return ETrue;
}

TBool CGmsPictureControl::IsCursorLocation(TMsgCursorLocation /*aLocation*/) const
{
    return ETrue;
}

TUint32 CGmsPictureControl::EditPermission() const
{
    return EMsgEditNone;
}

void CGmsPictureControl::Reset()
{
    delete iBitmap;
    iBitmap = NULL;
    delete iScaledBitmap;
    iScaledBitmap = NULL;    
        
    delete iConverter;
    iConverter = NULL;
            
    SetModified( ETrue );    
}

void CGmsPictureControl::NotifyViewEvent(TMsgViewEvent /*aEvent*/,
    TInt /*aParam*/)
{
}

TInt CGmsPictureControl::ConversionReady( TAny* aPtr )
{
	__ASSERT_ALWAYS(aPtr, User::Panic(KSmEditorGmsPic, ENullPtr) );
    static_cast<CGmsPictureControl*>( aPtr )->DoConversionReady();
    return 0;
}    

TInt CGmsPictureControl::ScalingReady( TAny* aPtr )
{
	__ASSERT_ALWAYS(aPtr, User::Panic(KSmEditorGmsPic, ENullPtr) );
    static_cast<CGmsPictureControl*>( aPtr )->DoScalingReady();
    return 0;
}    

void CGmsPictureControl::PrepareForReadOnly(TBool /*aReadOnly*/)
{
}

TInt CGmsPictureControl::CountComponentControls() const
    {
    // This method is required by the base class
    return 0;
    }

CCoeControl* CGmsPictureControl::ComponentControl(TInt /*aIndex*/) const
    {
    // This method is required by the base class
    return NULL;
    }
    
void CGmsPictureControl::FocusChanged( TDrawNow /*aDrawNow*/ )
    {
    // This method is required by the base class
    }

void CGmsPictureControl::SizeChanged()
{
    iBitmapRect = Rect();
    
    if (AknLayoutUtils::ScalableLayoutInterfaceAvailable())
    {        
        TAknWindowComponentLayout layout =
            AknLayoutScalable_Apps::mce_image_pane_g3();
        TAknLayoutRect layoutRect;
    	layoutRect.LayoutRect( Rect(), layout.LayoutLine() );
    	iBitmapRect = layoutRect.Rect();
    
        // Adjust max height if needed, this is not the usual case but
        // implemented here just because of supporting the existing
        // public LoadImageL() method. Usually the size of imageRect
        // should be fully determined by avkon layout!
        if ( iMaxHeight > 0 && (TUint)iBitmapRect.Size().iHeight > iMaxHeight )
        {
            iBitmapRect.SetHeight(iMaxHeight);
        }
        TInt yAxisOffset = Rect().iTl.iY - iBitmapRect.iTl.iY;
        iBitmapRect.Move(0,yAxisOffset);
        
        // If leave occurs then scaling is not performed
        TRAP_IGNORE( ScaleIfPossibleL( iBitmapRect.Size() ) );
    }
    
    else
    { // Use old sizing functionality if scalable IF isn't available:
      // Note that usage of image size and image rect is not identical
      // to scalable version!
        TSize imageSize(CalculateImageSize());
        
        // If leave occurs then scaling is not performed
        TRAP_IGNORE( ScaleIfPossibleL( imageSize ) );                
    }
}

void CGmsPictureControl::Draw(const TRect& /*aRect*/) const
{   
    // Ensure that scaled bitmap exists and that no scaling is
    // currently ongoing.    
    if ( iScaledBitmap &&
         iScaledBitmap->Handle() &&
         ! iScalingAO->IsActive() )
    {            
        CWindowGc& gc = SystemGc();
		gc.DrawBitmap(iBitmapRect,iScaledBitmap);
    }
}

/**
* This internal function is the old version and is used ONLY if scalable
* layout interface is NOT available. This should be removed when it is always
* available.
*/
TSize CGmsPictureControl::CalculateImageSize() const
{
    TSize trgSize(0,0);

    TSize bmpSize = OriginalImageResolution();
    bmpSize.SetSize(bmpSize.iWidth*2, bmpSize.iHeight*2);

    TRect rect(Rect());

    // Width is basically static during the session, but it's always
    // calculated anyway.
    if (bmpSize.iWidth < rect.Width())
    {
        // "narrow" image - request only what is needed.
        trgSize.iWidth = bmpSize.iWidth;
    }
    else
    {
        // "wide" image - request all we can get.
        trgSize.iWidth = rect.Width();
    }

    // Height is dynamic, i.e. changes when moving up&down in the message.
    // Request maximum height possible.
    // Note: Either max size allowed by spec or the size of the image itself
    // is considered here, i.e. not the given rect.
    if ( iMaxHeight > 0 && (TUint)bmpSize.iHeight > iMaxHeight )
    {
        trgSize.iHeight = iMaxHeight;
    }
    else
    {
        trgSize.iHeight = bmpSize.iHeight;
    }
    return trgSize;
}

TBool CGmsPictureControl::ScaleIfPossibleL( TSize aSize )
{
	if ( !iBitmap )    	     
    { 
        // Image hasn't been loaded, cannot scale
        return EFalse;
    }
	else if ( iConversionAO->IsActive() )
    { 
        // Conversion is ongoing, but not ready yet,
        // image will be scaled after conversion finishes.
        return EFalse;
    }
    
    else
    {
        if ( !iScalingAO->IsActive() )
        {
        	// Scaling is possible, it is done asynchronously
        	delete iScaledBitmap;
        	iScaledBitmap = NULL;        
        	iScaledBitmap = new( ELeave ) CFbsBitmap;
                    
	        User::LeaveIfError( iScaler->Scale( iScalingAO->iStatus, 
    	                                        *iBitmap, 
        	                                    TRect(iBitmap->SizeInPixels()),
            	                                *iScaledBitmap,
                	                            TRect(aSize) ) );
        	iScalingAO->SetItActive();            
        	return ETrue;
        }
    }
    return EFalse;            
}

void CGmsPictureControl::DoConversionReady()
{    
    __ASSERT_DEBUG( iConversionAO->iStatus == KErrNone,
                    Panic(EConversionError) );
                    
    if ( iConversionAO->iStatus == KErrNone )
    	{        
        SetModified( ETrue );
        // We want to scale the image now:       
        SetRect( Rect() );
        
    	//we must delete the converter here because it is holding the
    	//converted imagefile so that it cant be replaced when FORWARD:ing
    	delete iConverter;
    	iConverter = NULL;
    	}
}

void CGmsPictureControl::DoScalingReady()
{    
    __ASSERT_DEBUG( iScalingAO->iStatus == KErrNone,
                    Panic(EScalingError) );
                    
    if ( iScalingAO->iStatus == KErrNone )
    {        
        SetModified( ETrue );
        // We want to draw the image now:       
        DrawNow();
    }
}


void CGmsPictureControl::Panic(TGmsPicControlPanic aCode)
    {
    User::Panic(KSmEditorGmsPic, aCode);
    }

void CGmsPictureControl::ConstructL(const CCoeControl* aParent)
{
    __ASSERT_DEBUG( aParent, Panic(ENoParent) );
    
    User::LeaveIfError( iFs.Connect() );

    iControlType = EMsgImageControl;    

    SetContainerWindowL(*aParent);
    
    TRect rect(aParent->Rect());
    if (rect.Height() == 0 || rect.Width() == 0)
    {
        // We have been called before view construction.
        // Set rect to screen size.
        rect.SetRect (
            TPoint(0,0),
            iEikonEnv->EikAppUi()->ClientRect().Size());
    }
    SetPosition(rect.iTl);
    SetSizeWithoutNotification(rect.Size());
    
    iConversionAO = new( ELeave ) CGmsAOCallBack(
        TCallBack( ConversionReady, this ), CActive::EPriorityStandard );    
    iScaler = IHLScaler::CreateL();
    iScalingAO = new( ELeave ) CGmsAOCallBack(
        TCallBack( ScalingReady, this ), CActive::EPriorityStandard );    
}

CGmsPictureControl::CGmsPictureControl()
{
    // By default iMaxHeight is not used:
    iMaxHeight = 0;
}

//  End of File