/*

* Copyright (c) 2002-2004 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:  Xuikon control adapter source file

*

*/

// System includes

#include <utf.h>

#include <SVGEngineInterfaceImpl.h>

#include <s32file.h>

#include <mifconvdefs.h>

#include <AknsFrameBackgroundControlContext.h>

#include <AknsDrawUtils.h>

#include <aknconsts.h>

#include <AknUtils.h>

#include <AknsListBoxBackgroundControlContext.h>

#include <gulicon.h>

#ifdef RD_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif // RD_TACTILE_FEEDBACK

// User includes

#include "xnappuiadapter.h"

#include "xnviewadapter.h"

#include "xnviewmanager.h"

#include "xncontroladapterimpl.h"

#include "xncontroladapter.h"

#include "xnmenuadapter.h"

#include "xncomponentnodeimpl.h"

#include "xntype.h"

#include "xnnodepluginif.h"

#include "xnuiengine.h"

#include "xnviewnodeimpl.h"

#include "c_xnutils.h"

#include "xndomdocument.h"

#include "xndomattribute.h"

#include "xndomnode.h"

#include "xnproperty.h"

#include "xndomlist.h"

#include "xnodt.h"

#include "xnresource.h"

#include "xnhittest.h"

#include "xnplugindata.h"

#include "xnnode.h"

#include "xnpanic.h"

#include "xnviewdata.h"

#include "xnscrollablecontroladapter.h"

#include "xnfocuscontrol.h"

#include "xneditmode.h"

_LIT8(KScrollableBoxNodeName, "scrollablebox");

using namespace XnGestureHelper;

#include "xngesture.h"

// Constants

const TInt KSkinGfxInnerRectShrink = 5;

const TInt KFocusGrowValue = 3;

const TInt KLongTapStartShortDelay( 150000 ); // 0.15s for Sk

const TInt KLongTapStartLongDelay( 500000 ); // 0.5s

const TInt KLongTapTimeShortDelay( 600000 ); // 0.6s for SK

const TInt KLongTapTimeLongDelay( 1500000 ); // 1.5s 

// LOCAL FUNCTION PROTOTYPES

static TRgb ConvertHslToRgb( TInt aHue, TInt aSaturation, TInt aLightness );

static void ConvertRgbToHsl( TRgb aRGB, TUint& aHue, TUint& aSaturation,

    TUint& aLightness );

static void LoadFbsBitmapL(

    CXnResource& aResource, CFbsBitmap*& aTarget, RFs& aFsSession );

static void LoadMbmBitmapL( CXnResource& aResource,

    TInt aBitmapIndex, CFbsBitmap*& aTarget, RFs& aFsSession );

static void LoadSVGBitmapL( CXnResource& aResource,

    CFbsBitmap*& aBitmap, CFbsBitmap*& aBitmapMask,

    TRect aRect, RFs& aFsSession );

static TBool GetBitmapL( CXnUiEngine& aEngine, CXnNode& aNode,

    const TDesC& aResourceFileName, TInt& aBitmapIndex,

    CFbsBitmap*& aTarget, CFbsBitmap*& aBitmapMask,

    CXnControlAdapterImpl::TIconProvider*& aIconProvider,

    TRect aRect, RFs& aFsSession );

static void LimitRectToPaddingRect( CXnNode& aNode, TRect& aRect );

static void DrawSpaceBackgroundY( CWindowGc& aGc, TInt aYRepeatCount,

    CXnNode& aNode, TRect& aRect, CFbsBitmap* aBitmap, TRect aBitmapRect,

    TRect aImageRect, TInt& aYOffset );

static void DrawRepeatBackgroundY( CWindowGc& aGc, TInt aYRepeatCount,

    CXnNode& aNode, TRect& aRect, CFbsBitmap* aBitmap, TRect aBitmapRect,

    TRect aImageRect, TInt& aYOffset );

static void StripQuotes( HBufC*& aString );

static void DrawBackgroundColorL(

    const TRect& /*aRect*/, CXnNode& aNode, CWindowGc& aGc );

static void GetBackroundRepeatValuesL( CXnNode& aNode, TBool& aRepeatX,

    TBool& aRepeatY, TBool& aSpaceX, TBool& aSpaceY );

static void DrawRepeatedBackgroundImage( CWindowGc& aGc, CXnNode& aNode,

    TRect& aRect, TRect aImageRect, TRect aBitmapRect,

    CFbsBitmap* aBitmap, TBool aRepeatX, TBool aRepeatY, TBool aSpaceX,

    TBool aSpaceY, TInt aXRepeatCount, TInt aYRepeatCount );

static TBool GetBackgroundPositionFromPropertyL(

    CXnNode& aNode, TBool aScaleImage, TRect& aRect,

    TRect aImageRect, CFbsBitmap* aBitmap, TBool& aHeightSet );

static TBool GetBackgroundSizeFromPropertyL( TRect& aRect, CXnNode& aNode,

    CFbsBitmap* aBitmap, TBool& aScaleImage );

static TRgb LighterColor( const TRgb& aRgb );

static TRgb DarkerColor( const TRgb& aRgb );

static void DrawSolidTopBorder( CArrayFix< TPoint >* aArray, CWindowGc& aGc );

static void SplitTopBorderPolygonL( CArrayFix< TPoint >* aArray,

    CArrayFix< TPoint >*& aUpperPart, CArrayFix< TPoint >*& aLowerPart );

static void DrawRidgeTopBorderL(

    CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

static void DrawGrooveTopBorderL(

    CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

static void DrawInsetTopBorder(

    CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

static void DrawOutsetTopBorder(

    CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

static TBool GetBorderColorL(

    const TDesC8& aPropertyName, CXnNode& aNode, CWindowGc& aGc, TRgb& aRgb );

static void DrawTopBorderL(

    const TRect& /*aRect*/, CXnNode& aNode, CWindowGc& aGc );

static void DrawBottomBorderL(

    const TRect& /*aRect*/, CXnNode& aNode, CWindowGc& aGc );

static void DrawSolidBottomBorder( CArrayFix< TPoint >* aArray, CWindowGc& aGc );

static void SplitBottomBorderPolygonL( CArrayFix< TPoint >* aArray,

    CArrayFix< TPoint >*& aUpperPart, CArrayFix< TPoint >*& aLowerPart );

static void DrawRidgeBottomBorderL(

    CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

static void DrawGrooveBottomBorderL(

    CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

static void DrawInsetBottomBorder(

    CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

static void DrawOutsetBottomBorder(

    CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

static void DrawSolidLeftBorder(

    CArrayFix< TPoint >* aArray, CWindowGc& aGc );

static void SplitLeftBorderPolygonL( CArrayFix< TPoint >* aArray,

    CArrayFix< TPoint >*& aLeftPart, CArrayFix< TPoint >*& aRightPart );

static void DrawRidgeLeftBorderL(

    CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

static void DrawGrooveLeftBorderL(

    CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

static void DrawInsetLeftBorder(

    CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

static void DrawOutsetLeftBorder(

    CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

static void DrawLeftBorderL(

    const TRect& /*aRect*/, CXnNode& aNode, CWindowGc& aGc );

static void DrawRightBorderL(

    const TRect& /*aRect*/, CXnNode& aNode, CWindowGc& aGc );

static void DrawSolidRightBorder(

    CArrayFix< TPoint >* aArray, CWindowGc& aGc );

static void SplitRightBorderPolygonL( CArrayFix< TPoint >* aArray,

    CArrayFix< TPoint >*& aLeftPart, CArrayFix< TPoint >*& aRightPart );

static void DrawRidgeRightBorderL(

    CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

static void DrawGrooveRightBorderL(

    CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

static void DrawInsetRightBorder(

    CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

static void DrawOutsetRightBorder(

    CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb );

static void DrawBorderImagesL(

    const TRect& /*aRect*/, CXnNode& aNode, CWindowGc& aGc,

    CFbsBitmap* aBitmap, TInt aBorderBitmapDividerTop,

    TInt aBorderBitmapDividerRight,

    TInt aBorderBitmapDividerBottom, TInt aBorderBitmapDividerLeft );

static TBool IsPropertyNone( CXnProperty& aProperty );

static void DrawBordersL( const TRect& aRect, CXnNode& aNode, CWindowGc& aGc );

static void SwapChildArrays( RPointerArray< CXnControlAdapter >& originalArray,

    RPointerArray< CXnControlAdapter >& sortedArray );

static CXnProperty* GetZIndexL( CXnControlAdapter* aAdapter );

static void InsertChildToSortedArrayL(

    RPointerArray< CXnControlAdapter >& aTargetArray,

    CXnControlAdapter* aChild );

static void InitializeBackgroundBitmapL( CXnUiEngine& aEngine, CXnNode& aNode,

    TInt& aBitmapIndex, CFbsBitmap*& aBitmap, CFbsBitmap*& aMask,

    CXnControlAdapterImpl::TIconProvider*& aIconProvider, RFs& aFsSession );

static HBufC* GetBackgroundImagePathLC( CXnNode& aNode );

static CFbsBitmap* InitializeBorderBitmapL(

    CXnUiEngine& aEngine, CXnNode& aNode,

    TInt& aBitmapIndex, TInt& aBorderBitmapDividerTop,

    TInt& aBorderBitmapDividerRight, TInt& aBorderBitmapDividerBottom,

    TInt& aBorderBitmapDividerLeft,

    CXnControlAdapterImpl::TIconProvider*& aIconProvider, RFs& aFsSession );

static void DrawDottedBorder(

    TRect aBorderRect, CWindowGc& aGc, TRgb& aRgb, TBool aHorizontal );

static HBufC* GetBackgroundImageMaskPathLC( CXnNode& aNode );

static CFbsBitmap* CreateBitmapFromColorL( TSize aSize, TRgb aColor );

static TBool CreateGestureHelperL( CXnNode& aNode );

static TInt AccessResourceFileL(

    CXnResource& aResource, RFile& aFile, RFs& aFsSession );

static void DrawFocusAppearance( CXnNode& aNode, CWindowGc& aGc );

static CXnDomNode* HasHoldTrigger( CXnDomNode* aNode );

static void CancelFocusRefusalL( CXnUiEngine& aUiEngine );

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

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

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

// 

static CXnScrollableControlAdapter* IsChildOfScrollableControl( CXnNode& aNode )

    {

    CXnNode* parent = aNode.Parent();

    while( parent )

        {

        if( parent->Type()->Type() == KScrollableBoxNodeName )

            {

            CXnScrollableControlAdapter* ret = static_cast<CXnScrollableControlAdapter*>(parent->Control());

            return ret;

            }

        parent = parent->Parent();

        }

    return NULL;

    }

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

// SetControlContext

// 

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

// 

static void SetControlContext(CXnControlAdapter& aChild, CXnNode& aNode)

    {

    CXnScrollableControlAdapter* scrollableControl = IsChildOfScrollableControl( aNode );

    if(scrollableControl)

        {

        aNode.SetScrollableControl(scrollableControl);

        aChild.CopyControlContextFrom(scrollableControl);

        }        

    }

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

// AccessResourceFileL

// Opens a resource file for accessing. The caller must close the file.

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

//

static TInt AccessResourceFileL(

    CXnResource& aResource,

    RFile& aFile,

    RFs& aFsSession )

    {

    TInt err = KErrNone;

    // parse file name and extension

    const TDesC& fileName = aResource.FileName();

    TParsePtrC fileParser( fileName );

    TPtrC filepath = fileParser.DriveAndPath();

    // open resource file

    aFsSession.SetSessionPath( filepath );

    aFsSession.ShareProtected();

    err = aFile.Open( aFsSession, fileName, EFileShareReadersOnly );

    if ( err != KErrNone )

        {

        aFile.Close();

        }

    return err;

    }

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

// LoadFbsBitmapL

// Loads a bitmap file from the theme server and creates a CFbsBitmap

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

//

static void LoadFbsBitmapL(

    CXnResource& aResource,

    CFbsBitmap*& aTarget,

    RFs& aFsSession )

    {

     RFile file;

     TInt ret = AccessResourceFileL( aResource, file, aFsSession );

     if ( ret == KErrNone )

        {

        CleanupClosePushL( file );

        aTarget = new ( ELeave ) CFbsBitmap;

        if ( !aTarget )

            {

            CleanupStack::PopAndDestroy();

            return;

            }

        RFileReadStream readStream( file );

        CleanupClosePushL( readStream );

        aTarget->InternalizeL( readStream );

        CleanupStack::PopAndDestroy( &readStream );

        CleanupStack::PopAndDestroy( &file );

        }

    }

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

// LoadMifBitmapL

// Loads a bitmap file from the theme server and creates a CFbsBitmap

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

//

static void LoadMifBitmapL(

    CXnResource& aResource,

    TInt aBitmapIndex,

    CFbsBitmap*& aBitmap,

    CFbsBitmap*& aMask,

    CXnControlAdapterImpl::TIconProvider*& aIconProvider,

    RFs& aFsSession,

    const TRect& aRect )

    {

    RFile file;

    TInt ret = AccessResourceFileL( aResource, file, aFsSession );

    if ( ret == KErrNone )

        {

        aIconProvider = new ( ELeave ) CXnControlAdapterImpl::TIconProvider( file );

        }

    if ( ret == KErrNone )

        {

        // Mask is next after bitmap

        AknIconUtils::CreateIconL( aBitmap, aMask, *aIconProvider,

            aBitmapIndex + KMifIdFirst, aBitmapIndex + KMifIdFirst + 1 );

        AknIconUtils::SetSize( aBitmap, aRect.Size(), EAspectRatioNotPreserved );

        }

    }

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

// LoadMbmBitmapL

// Loads a bitmap file from the theme server and creates a CFbsBitmap

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

//

static void LoadMbmBitmapL(

    CXnResource& aResource,

    TInt aBitmapIndex,

    CFbsBitmap*& aTarget,

    RFs& aFsSession )

    {

    RFile file;

    TInt ret = AccessResourceFileL( aResource, file, aFsSession );

    if ( ret == KErrNone )

        {

        CleanupClosePushL( file );

        aTarget = new ( ELeave ) CFbsBitmap;

        aTarget->Load( file, aBitmapIndex );

        CleanupStack::PopAndDestroy();

        }

    }

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

// LoadSVGBitmapL

// Loads an SVG file from the theme server and creates a CFbsBitmap.

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

//

static void LoadSVGBitmapL(

    CXnResource& aResource,

    CFbsBitmap*& aBitmap,

    CFbsBitmap*& aBitmapMask,

    TRect aRect,

    RFs& aFsSession )

    {

    RFile file;

    TInt ret = AccessResourceFileL( aResource, file, aFsSession );

    if ( ret == KErrNone )

        {

        CleanupClosePushL( file );

        CFbsBitmap* frameBuffer = new ( ELeave ) CFbsBitmap;

        CleanupStack::PushL( frameBuffer );

        TSize contentSize( aRect.Size() );

        frameBuffer->Create( contentSize, EColor16M );

        TFontSpec fontSpec;

        CSvgEngineInterfaceImpl* svgEngine =

            CSvgEngineInterfaceImpl::NewL( frameBuffer, NULL, fontSpec );

        CleanupStack::PushL( svgEngine );

        svgEngine->Load( file );

        TInt domHandle;

        svgEngine->PrepareDom( file, domHandle );

        CFbsBitmap* target = new ( ELeave ) CFbsBitmap;

        target->Create( contentSize, EColor16M );

        svgEngine->RenderDom( domHandle, target );

        aBitmap = target;

        CFbsBitmap* mask = new ( ELeave ) CFbsBitmap;

        mask->Create( contentSize, EGray256 );

        svgEngine->GenerateMask( mask );

        aBitmapMask = mask;

        CleanupStack::PopAndDestroy( 3, &file ); // frameBuffer, svgEngine, file

        }

    }

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

// ResolveMifIDL

// Resolves a mif id from a given string.

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

//

static TBool ResolveMifIDL(

    const TDesC& aMifId,

    TInt& aMifID )

    {

    HBufC* str = aMifId.AllocL();

    TPtr ptrMif = str->Des();

    ptrMif.TrimAll();

    TInt pos( ptrMif.FindF( KMif ) );

    if ( KErrNotFound != pos )

        {

        pos += KMif().Length();

        TPtr ptr = ptrMif.MidTPtr( pos, ( ptrMif.Length() - pos ) );

        ptr.TrimAll();

        TInt offset( ptr.Locate( KRightParenthesis ) );

        if ( KErrNotFound != offset )

            {

            TLex lex( ptr.Left( offset ) );

            lex.SkipSpace();

            lex.Val( aMifID );

            delete str;

            return ETrue;

            }

        }

    delete str;

    return EFalse;

    }

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

// LoadSkinBitmapL

// Loads a skin bitmap and creates a CFbsBitmap from it.

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

//

static TBool LoadSkinBitmapL(

    const TDesC& aSkinId,

    CFbsBitmap*& aBitmap,

    CFbsBitmap*& aBitmapMask,

    TRect aRect )

    {

    TAknsItemID itemID;

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

    TInt mifId( 0 );

    TInt mifFound( ResolveMifIDL( aSkinId, mifId ) );

    TInt colorIndex( KErrNotFound );

    if ( skin && CXnUtils::ResolveSkinItemIDL( aSkinId, itemID, colorIndex ) )

        {

        if ( itemID.iMajor == EAknsMajorAppIcon ) // Check if appl. icon request

            {

            TUid applUid;

            applUid = TUid::Uid( itemID.iMinor );

            AknsUtils::CreateAppIconLC(

                skin, applUid, EAknsAppIconTypeList, aBitmap, aBitmapMask );

            AknIconUtils::SetSize(

                aBitmap, aRect.Size(), EAspectRatioNotPreserved );

            CleanupStack::Pop( 2 ); //aBitmap, aBitmapMask

            return ETrue;

            }

        else

            {

            TInt error( KErrNone );

            // if we have a color index, then we create a colored icon

            if ( colorIndex != KErrNotFound )

                {

                TRgb defaultColor( 0, 0, 0 );

                TRAP( error, AknsUtils::CreateColorIconL(

                    skin, itemID, KAknsIIDQsnTextColors,

                    colorIndex, aBitmap, aBitmapMask,

                    KNullDesC, mifId, mifId + 1, defaultColor ) );

                }

            else

                {

                TRAP( error, AknsUtils::CreateIconL(

                    skin, itemID, aBitmap, aBitmapMask, KNullDesC,

                    mifId, mifId + 1 ) );

                }

            if ( error != KErrNone )

                {

                error = KErrNone;

                TRAP( error, AknsUtils::CreateIconL(

                    skin, itemID, aBitmap, KNullDesC, mifId ) );

                }

            if ( error == KErrNone )

                {

                AknIconUtils::SetSize(

                    aBitmap, aRect.Size(), EAspectRatioNotPreserved );

                return ETrue;

                }

            }

        }

    if ( mifFound )

        {

        AknIconUtils::CreateIconL(

            aBitmap, aBitmapMask, KAvkonBitmapFile, mifId, mifId + 1 );

        AknIconUtils::SetSize(

            aBitmap, aRect.Size(), EAspectRatioNotPreserved );

        return ETrue;

        }

    return EFalse;

    }