/*

* Copyright (c) 2007 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:  Implementation on scrollbar layout.

*

*/

//<cmail> SF

#include "emailtrace.h"

#include <uiacceltk/hitchcock.h>

//</cmail>

#include <AknUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include "fshuiscrollbarlayout.h"

#include "fslayoutmanager.h"

const TInt KFsScrollbarTextureIdPoolStart = 1000;

// ======== LOCAL FUNCTIONS ========

// ---------------------------------------------------------------------------

// Resolve the greater values from both size arguments.

// ---------------------------------------------------------------------------

//

TSize ExtendSize( const TSize& aSize, const TSize& aSize2 )

    {

    return TSize(

        aSize.iWidth < aSize2.iWidth ? aSize2.iWidth : aSize.iWidth,

        aSize.iHeight < aSize2.iHeight ? aSize2.iHeight : aSize.iHeight );

    }

// ---------------------------------------------------------------------------

// Resolve the greatest size from scrollbar gridlayouts.

// ---------------------------------------------------------------------------

//

TSize GetMaxImageSize(

    CHuiLayout* aLayout1,

    CHuiLayout* aLayout2,

    CHuiLayout* aLayout3 )

    {

    TSize retVal( static_cast<CHuiImageVisual*>(

        &aLayout1->Visual( 0 ) )->Image().Texture().Size() );

    retVal = ExtendSize( retVal, static_cast<CHuiImageVisual*>(

        &aLayout1->Visual( 1 ) )->Image().Texture().Size() );

    retVal = ExtendSize( retVal, static_cast<CHuiImageVisual*>(

        &aLayout1->Visual( 2 ) )->Image().Texture().Size() );

    retVal = ExtendSize( retVal, static_cast<CHuiImageVisual*>(

        &aLayout2->Visual( 0 ) )->Image().Texture().Size() );

    retVal = ExtendSize( retVal, static_cast<CHuiImageVisual*>(

        &aLayout2->Visual( 1 ) )->Image().Texture().Size() );

    retVal = ExtendSize( retVal, static_cast<CHuiImageVisual*>(

        &aLayout2->Visual( 2 ) )->Image().Texture().Size() );

    retVal = ExtendSize( retVal, static_cast<CHuiImageVisual*>(

        &aLayout3->Visual( 0 ) )->Image().Texture().Size() );

    retVal = ExtendSize( retVal, static_cast<CHuiImageVisual*>(

        &aLayout3->Visual( 1 ) )->Image().Texture().Size() );

    retVal = ExtendSize( retVal, static_cast<CHuiImageVisual*>(

        &aLayout3->Visual( 2 ) )->Image().Texture().Size() );

    return retVal;

    }

// ---------------------------------------------------------------------------

// Creates a new bitmap based on the given source bitmap. New bitmap will be

// rotated 90 degrees agains clock direction if wanted.

// ---------------------------------------------------------------------------

//

CFbsBitmap* CreateBitmapL( CFbsBitmap* aSourceBitmap, TBool aRotated )

    {

    FUNC_LOG;

    CFbsBitmap* destinationBitmap( new( ELeave )CFbsBitmap() );

    CleanupStack::PushL( destinationBitmap );

    TSize sourceBitmapSize( aSourceBitmap->SizeInPixels() );

    TSize destinationBitmapSize( 0, 0 );

    if ( aRotated )

        {

        destinationBitmapSize =

            TSize( sourceBitmapSize.iHeight, sourceBitmapSize.iWidth );

        }

    else

        {

        destinationBitmapSize =

            TSize( sourceBitmapSize.iWidth, sourceBitmapSize.iHeight );

        }

    User::LeaveIfError( destinationBitmap->Create(

        destinationBitmapSize, aSourceBitmap->DisplayMode() ) );

    CFbsBitmapDevice* destinationDevice(

        CFbsBitmapDevice::NewL( destinationBitmap ) );

    CleanupStack::PushL( destinationDevice );

    CFbsBitGc* destinationGc;

    User::LeaveIfError( destinationDevice->CreateContext( destinationGc ) );

    if ( aRotated )

        {

        // Assume that bitmaps are small and this is called only at

        // construction. Simply just blit the pixels one by one here.

        TInt destinationX( 0 );

        TInt destinationY( 0 );

        for ( TInt sourceY( 0 ); sourceY < sourceBitmapSize.iHeight;

            sourceY++ )

            {

            for ( TInt sourceX( 0 ); sourceX < sourceBitmapSize.iWidth;

                sourceX++ )

                {

                destinationX = sourceY;

                destinationY = sourceX;

                destinationGc->BitBlt( TPoint( destinationX, destinationY ),

                    aSourceBitmap,

                    TRect( sourceX, sourceY, sourceX + 1, sourceY + 1 ) );

                }

            }

        }

    else

        {

        destinationGc->BitBlt( TPoint( 0, 0 ), aSourceBitmap );

        }

    delete destinationGc;  

    CleanupStack::PopAndDestroy( destinationDevice ); // destinationDevice

    CleanupStack::Pop( destinationBitmap ); // destinationBitmap

    return destinationBitmap;

    }

// ---------------------------------------------------------------------------

// Creates a new bitmap and a mask based on the given skin item id.  New

// bitmap will be rotated 90 degrees agains clock direction if wanted.

// ---------------------------------------------------------------------------

//

void CreateSkinnedBitmapAndMaskL( MAknsSkinInstance* aInstance, 

    const TAknsItemID& aID,

    CFbsBitmap*& aBitmap,

    CFbsBitmap*& aMask,

    TBool aRotated )

    {

    FUNC_LOG;

    CFbsBitmap* skinnedBitmap( NULL );

    CFbsBitmap* skinnedMask( NULL );

    // note, real fallback icons are not (yet) available in avkon icon file.

    TRAP_IGNORE( AknsUtils::CreateIconL(

        aInstance, aID, skinnedBitmap, skinnedMask, KNullDesC, -1, -1 ) );

    if ( !skinnedBitmap )

        {

        AknsUtils::CreateIconL(

            aInstance, aID, skinnedBitmap, KNullDesC, -1 );

        }

    TRect screenRect;     

    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, screenRect );

    TAknWindowComponentLayout l(

        AknLayoutScalable_Avkon::scroll_bg_pane_g1() );

    TAknLayoutRect layoutRect;

    layoutRect.LayoutRect( screenRect, l.LayoutLine() );

    TSize itemSize( layoutRect.Rect().Size() );

    if ( itemSize.iHeight > itemSize.iWidth )

        {

        itemSize.iHeight = itemSize.iWidth; // make sure item is square

        }

    else

        {

        itemSize.iWidth = itemSize.iHeight; // make sure item is square

        }

    User::LeaveIfError( AknIconUtils::SetSize( skinnedBitmap, itemSize ) );

    if ( aRotated )

        {

        // now create rotated copy of the original bitmaps

        CFbsBitmap* bitmap( CreateBitmapL( skinnedBitmap, aRotated ) );

        CleanupStack::PushL( bitmap );

        CFbsBitmap* mask( NULL );

        if ( skinnedMask )

            {

            mask = CreateBitmapL( skinnedMask, aRotated );

            CleanupStack::PushL( mask );

            }

        if ( mask )

            {

            CAknIcon* icon( CAknIcon::NewL() );

            icon->SetBitmap( bitmap );

            icon->SetMask( mask );

            CAknIcon* resultIcon( AknIconUtils::CreateIconL( icon ) );

            CleanupStack::Pop( mask ); // mask

            aBitmap = resultIcon->Bitmap();

            aMask = resultIcon->Mask();

            resultIcon->SetBitmap( NULL );

            resultIcon->SetMask( NULL );

            delete resultIcon;

            }

        else

            {

            CFbsBitmap* resultBitmap( AknIconUtils::CreateIconL( bitmap ) );

            aBitmap = resultBitmap;

            }            

        CleanupStack::Pop( bitmap ); // bitmap

        // delete originals

        delete skinnedBitmap;

        delete skinnedMask;

        }

    else

        {

        aBitmap = skinnedBitmap;

        aMask = skinnedMask;

        }

    }

// ---------------------------------------------------------------------------

// Add s specific skin image to visual.

// ---------------------------------------------------------------------------

//

void CFsHuiScrollbarLayout::SetImageL(

    CHuiImageVisual* aVisual,

    const TAknsItemID& aID,

    TFsScrollbar aOrientation )

    {

    CFsScrollbarBitmapProvider* provider = new (ELeave) CFsScrollbarBitmapProvider( aID, aOrientation );

    iBitmapProviderStack.AppendL( provider );

    while ( iOwnerControl->Env().TextureManager().IsLoaded( iTextureCounter ) )

    	{

    	++iTextureCounter;

    	}

    CHuiTexture& texture = iOwnerControl->Env().TextureManager().CreateTextureL( iTextureCounter, provider, EHuiTextureUploadFlagDefault );

    iTextureStack.AppendL( &texture );

    texture.SetSkinContent( ETrue );

    aVisual->SetImage( texture );

    aVisual->SetScaleMode( CHuiImageVisual::EScaleFit );

    }

CFsScrollbarBitmapProvider::CFsScrollbarBitmapProvider( TAknsItemID aID, TFsScrollbar aOrientation )

	: iID( aID ), iOrientation( aOrientation )

	{

	}

CFsScrollbarBitmapProvider::~CFsScrollbarBitmapProvider()

	{

	}

void CFsScrollbarBitmapProvider::ProvideBitmapL (TInt /*aId*/, CFbsBitmap *& aBitmap, CFbsBitmap *& aMaskBitmap)

	{

	MAknsSkinInstance* skin( AknsUtils::SkinInstance() );

	CreateSkinnedBitmapAndMaskL(

		skin, iID, aBitmap, aMaskBitmap, EFsScrollbarHorizontal == iOrientation );

	}

// ======== MEMBER FUNCTIONS ========

CFsHuiScrollbarLayout::CFsHuiScrollbarLayout( MHuiVisualOwner& aOwner )

    : CHuiLayout( aOwner )

    {

    FUNC_LOG;

    }

void CFsHuiScrollbarLayout::ConstructL( CHuiControl& aOwnerControl )

    {

    FUNC_LOG;

    CHuiLayout::ConstructL();

    iHorScroll.SetHorizontal( ETrue );

    iOwnerControl = &aOwnerControl;

    iTextureCounter = KFsScrollbarTextureIdPoolStart;

    }

// ---------------------------------------------------------------------------

// Construct a new scrollbar layout and give its ownership to a control.

// ---------------------------------------------------------------------------

//

EXPORT_C CFsHuiScrollbarLayout* CFsHuiScrollbarLayout::AddNewL(

    CHuiControl& aOwnerControl,

    CHuiLayout* aParentLayout )

    {

    FUNC_LOG;

    CFsHuiScrollbarLayout* scrollbar(

        new (ELeave) CFsHuiScrollbarLayout( aOwnerControl ) );

    CleanupStack::PushL( scrollbar );

    scrollbar->ConstructL( aOwnerControl );

    if ( aParentLayout )

        {

        aParentLayout->AppendL( scrollbar );

        }

    // Give ownership to specified owner.

    aOwnerControl.AppendL( scrollbar );

    CleanupStack::Pop( scrollbar );

    return scrollbar;

    }

CFsHuiScrollbarLayout::~CFsHuiScrollbarLayout()

    {

    FUNC_LOG;

    delete iVBarBrush;

    delete iHBarBrush;

    delete iVThumbBrush;

    delete iHThumbBrush;

    iTextureStack.ResetAndDestroy();

    iBitmapProviderStack.ResetAndDestroy();

    }

// ---------------------------------------------------------------------------

// Set the range of the scrollbar. Will not actually move the scrollbar until

// Update() is called.

// ---------------------------------------------------------------------------

//

EXPORT_C void CFsHuiScrollbarLayout::SetRange(

    TInt aStart,

    TInt aEnd,

    TFsScrollbar aScrollbar )

    {

    FUNC_LOG;

    // Perform the operation on selected scrollbar.

    EFsScrollbarVertical == aScrollbar

        ? iVertScroll.SetRange( aStart, aEnd )

        : iHorScroll.SetRange( aStart, aEnd );

    }

// ---------------------------------------------------------------------------

// Get scrollbars minimum range value.

// ---------------------------------------------------------------------------

//

EXPORT_C TInt CFsHuiScrollbarLayout::RangeStart( TFsScrollbar aScrollbar )

    {

    FUNC_LOG;

    // Perform the operation on selected scrollbar.

    return EFsScrollbarVertical == aScrollbar

        ? iVertScroll.RangeStart() : iHorScroll.RangeStart();

    }

// ---------------------------------------------------------------------------

// Get scrollbars maximum range value.

// ---------------------------------------------------------------------------

//

EXPORT_C TInt CFsHuiScrollbarLayout::RangeEnd( TFsScrollbar aScrollbar )

    {

    FUNC_LOG;

    // Perform the operation on selected scrollbar.

    return EFsScrollbarVertical == aScrollbar

        ? iVertScroll.RangeEnd() : iHorScroll.RangeEnd();

    }

// ---------------------------------------------------------------------------

// Set the count of visible units at the time.

// ---------------------------------------------------------------------------

//

EXPORT_C void CFsHuiScrollbarLayout::SetThumbSpan(

    TInt aThumbSpan,

    TFsScrollbar aScrollbar )

    {

    FUNC_LOG;

    // Perform the operation on selected scrollbar.

    EFsScrollbarVertical == aScrollbar

        ? iVertScroll.SetThumbSpan( aThumbSpan )

        : iHorScroll.SetThumbSpan( aThumbSpan );

    }

// ---------------------------------------------------------------------------

// Get the set value for visible units.

// ---------------------------------------------------------------------------

//

EXPORT_C TInt CFsHuiScrollbarLayout::ThumbSpan( TFsScrollbar aScrollbar )

    {

    FUNC_LOG;

    // Perform the operation on selected scrollbar.

    return EFsScrollbarVertical == aScrollbar

        ? iVertScroll.ThumbSpan() : iHorScroll.ThumbSpan();

    }

// ---------------------------------------------------------------------------

// Adjust the vertical scrollbar's width.

// ---------------------------------------------------------------------------

//

EXPORT_C void CFsHuiScrollbarLayout::SetVerticalScrollbarWidth(

    TInt aWidth,

    TInt aLayoutTransitionTime )

    {

    FUNC_LOG;

    iScrollbarSize.iWidth = aWidth;

    if ( iVScrollbarLayout )

        {

        iVertScroll.SetThumbSize(

            TSize( aWidth, iVertScroll.ThumbSize().iHeight ) );

        UpdateChildrenLayout( aLayoutTransitionTime );

        }

    }

// ---------------------------------------------------------------------------

// Adjust the horizontal scrollbar's height.

// ---------------------------------------------------------------------------

//

EXPORT_C void CFsHuiScrollbarLayout::SetHorizontalScrollbarHeight(

    TInt aHeight,

    TInt aLayoutTransitionTime )

    {

    FUNC_LOG;

    iScrollbarSize.iHeight = aHeight;

    if ( iHScrollbarLayout )

        {

        iHorScroll.SetThumbSize(

            TSize( iHorScroll.ThumbSize().iWidth, aHeight ) );

        UpdateChildrenLayout( aLayoutTransitionTime );

        }

    }

// ---------------------------------------------------------------------------

// Set the position of the scrollbar.

// ---------------------------------------------------------------------------

//

EXPORT_C void CFsHuiScrollbarLayout::SetScrollbarPos(

    const TInt aPos,

    TFsScrollbar aScrollbar )

    {

    FUNC_LOG;

    // Perform the operation on selected scrollbar.

    EFsScrollbarVertical == aScrollbar

        ? iVertScroll.SetPos( aPos ) : iHorScroll.SetPos( aPos );

    }

// ---------------------------------------------------------------------------

// Resolve the position of the scrollbar.

// ---------------------------------------------------------------------------

//

EXPORT_C TInt CFsHuiScrollbarLayout::ScrollbarPos( TFsScrollbar aScrollbar )

    {

    FUNC_LOG;

    // Perform the operation on selected scrollbar.

    return EFsScrollbarVertical == aScrollbar

        ? iVertScroll.Pos() : iHorScroll.Pos();

    }

// ---------------------------------------------------------------------------

// Set the scrollbar visibility.

// ---------------------------------------------------------------------------

//

EXPORT_C void CFsHuiScrollbarLayout::SetVisibilityMode(

    TFsScrollbarVisibility aVisibility,

    TFsScrollbar aScrollbar )

    {

    FUNC_LOG;

    // Perform the operation on selected scrollbar.

    EFsScrollbarVertical == aScrollbar

        ? iVertScroll.SetVisibleMode( aVisibility )

        : iHorScroll.SetVisibleMode( aVisibility );

    }

// ---------------------------------------------------------------------------

// Resolve the scrollbar visibility mode.

// ---------------------------------------------------------------------------

//

EXPORT_C TFsScrollbarVisibility CFsHuiScrollbarLayout::VisibilityMode(

    TFsScrollbar aScrollbar )

    {

    FUNC_LOG;

    // Perform the operation on selected scrollbar.

    return EFsScrollbarVertical == aScrollbar

        ? iVertScroll.VisibilityMode() : iHorScroll.VisibilityMode();

    }

// ---------------------------------------------------------------------------

// Resolve if the specified scrollbar is visible.

// ---------------------------------------------------------------------------

//

EXPORT_C TBool CFsHuiScrollbarLayout::IsScrollbarVisible(

    TFsScrollbar aScrollbar )

    {

    FUNC_LOG;

    // Perform the operation on selected scrollbar.

    return EFsScrollbarVertical == aScrollbar

        ? iVertScroll.IsVisible() : iHorScroll.IsVisible();

    }

// ---------------------------------------------------------------------------

// Change the scrollbar images to custom images.

// ---------------------------------------------------------------------------

//

EXPORT_C void CFsHuiScrollbarLayout::SetScrollbarImagesL(

    CHuiImageBrush* aBarBrush,

    CHuiImageBrush* aThumbBrush,

    TFsScrollbar aScrollbar )

    {

    FUNC_LOG;

    SetCustomImageL( aBarBrush, aScrollbar, EFalse );

    SetCustomImageL( aThumbBrush, aScrollbar, ETrue );