/*
* Copyright (c) 2008-2009 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:  Avkon pointer event modifier.
*
*/


#include <aknpointereventmodifier.h>
#include <coecntrl.h>

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

// ---------------------------------------------------------------------------
// CAknPointerEventModifier::NewL
// ---------------------------------------------------------------------------
//
CAknPointerEventModifier* CAknPointerEventModifier::NewL()
    {
    CAknPointerEventModifier* self = new ( ELeave ) CAknPointerEventModifier;
    return self;
    }
    
// ---------------------------------------------------------------------------
// CAknPointerEventModifier::~CAknPointerEventModifier()
// ---------------------------------------------------------------------------
//
CAknPointerEventModifier::~CAknPointerEventModifier()
    {
    iStack.Close();
    }
    
// ---------------------------------------------------------------------------
// CAknPointerEventModifier::CAknPointerEventModifier
// ---------------------------------------------------------------------------
//
CAknPointerEventModifier::CAknPointerEventModifier()
    {
    }

// ---------------------------------------------------------------------------
// CAknPointerEventModifier::Push
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknPointerEventModifier::Push( CCoeControl& aControl, 
    const TRect& aRect )
    {
    // Figure out aControl's window-owning parent. This will also work as a
    // sanity check for the aControl argument.
    CCoeControl* parent = aControl.Parent();
    
    while ( parent && !parent->OwnsWindow() )
        {
        parent = parent->Parent();
        }
        
    if ( !parent )
        {
        return;
        }
    
    if ( !ControlIsInStack( aControl ) )
        {
        TStackItem item;
        item.iControl = &aControl;
        item.iParent = parent;
        item.iExtensionArea = aRect;
        
        if ( iStack.Insert( item, 0 ) == KErrNone )
            {
            iIsValid = EFalse;
            }
        }
    }

// ---------------------------------------------------------------------------
// CAknPointerEventModifier::Pop
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknPointerEventModifier::Pop( const CCoeControl& aControl )
    {
    for ( TInt i = 0; i < iStack.Count(); ++i )
        {
        if ( iStack[i].iControl == &aControl )
            {
            iStack.Remove( i );
            iIsValid = EFalse;
            return;
            }
        }
    }

// ---------------------------------------------------------------------------
// CAknPointerEventModifier::Update
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknPointerEventModifier::Update( const CCoeControl& aControl, 
    const TRect& aRect )
    {
    for ( TInt i = 0; i < iStack.Count(); ++i )
        {
        if ( iStack[i].iControl == &aControl )
            {
            iStack[i].iExtensionArea = aRect;
            break;
            }
        }
    }
    
// ---------------------------------------------------------------------------
// CAknPointerEventModifier::HandlePointerEvent
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknPointerEventModifier::HandlePointerEvent( TPointerEvent& aEvent, 
    CCoeControl*& aDestination )
    {
    if ( iStack.Count() > 0 && aEvent.iType == TPointerEvent::EButton1Down )
        {
        if ( !iIsValid )
            {
            iStack.Sort( CAknPointerEventModifier::Compare );
            }
            
        for ( TInt i = 0; i < iStack.Count(); ++i )
            {
            if ( ModifyEvent( iStack[i], aEvent, aDestination ) )
                {
                break;
                }
            }
        }
    }
    
// ---------------------------------------------------------------------------
// CAknPointerEventModifier::Invalidate
// ---------------------------------------------------------------------------
//
void CAknPointerEventModifier::Invalidate()
    {
    iIsValid = ETrue;
    }

// ---------------------------------------------------------------------------
// CAknPointerEventModifier::ControlIsInStack
// ---------------------------------------------------------------------------
//
TBool CAknPointerEventModifier::ControlIsInStack( const CCoeControl& aControl )
    {
    for ( TInt i = 0; i < iStack.Count(); ++i )
        {
        if ( iStack[i].iControl == &aControl )
            {
            return ETrue;
            }
        }
    
    return EFalse;
    }

// ---------------------------------------------------------------------------
// CAknPointerEventModifier::ModifyEvent
// ---------------------------------------------------------------------------
//
TBool CAknPointerEventModifier::ModifyEvent( TStackItem& aItem, 
    TPointerEvent& aEvent, CCoeControl*& aDestination )
    {
    TBool wasModified = EFalse;
    
    // Control window's existence has been checked already in 
    // CAknPointerEventModifier::Push.
    if ( !aItem.iControl->DrawableWindow()->IsFaded() )
        {
        TBool isVertical = ( aItem.iControl->Size().iHeight > aItem.iControl->Size().iWidth );
        
        if ( aDestination == aItem.iParent )
            {
            // calculate hit area
            TRect hitArea( aItem.iControl->Position() + 
                aItem.iExtensionArea.iTl, aItem.iExtensionArea.Size() );
            TSize controlSize( aItem.iControl->Size() );

            if ( hitArea.Contains( aEvent.iPosition ) )
                {
                if ( aItem.iControl->OwnsWindow() )
                    {
                    aDestination = aItem.iControl;
                    
                    if ( isVertical )
                        {
                        aEvent.iPosition.iX = controlSize.iWidth >> 1;
                        aEvent.iPosition.iY -= aItem.iControl->Position().iY;
                        }
                    else
                        {
                        aEvent.iPosition.iX -= aItem.iControl->Position().iX;
                        aEvent.iPosition.iY = controlSize.iHeight >> 1;
                        }
                    }
                else
                    {
                    if ( isVertical )
                        {
                        aEvent.iPosition.iX = aItem.iControl->Position().iX + 
                            ( controlSize.iWidth >> 1 );
                        }
                    else
                        {
                        aEvent.iPosition.iY = aItem.iControl->Position().iY +
                            ( controlSize.iHeight >> 1 );
                        }
                    }
                    
                wasModified = ETrue;
                }
            }
        else if ( aDestination->Parent() && 
            aDestination->Parent()->DrawableWindow() == aItem.iParent->DrawableWindow() &&
             ( aDestination->Parent() != aItem.iParent ))
            {
            // This branch handles external scrollbars. It should be checked
            // via MOP chain if the aItem.iControl really is a scrollbar before
            // this API is taken into use with other controls.
            TPoint topLeft( aItem.iControl->Position().iX - 
                aDestination->Position().iX, 
                aItem.iControl->Position().iY - aDestination->Position().iY );
            TRect hitArea( topLeft + 
                aItem.iExtensionArea.iTl, aItem.iExtensionArea.Size() );

            if ( hitArea.Contains( aEvent.iPosition ) )
                {
                TInt controlPosition = aItem.iControl->Position().iY;
                TInt positionInParent = aEvent.iPosition.iY + aDestination->Position().iY;
                
                if ( isVertical )
                    {
                    aEvent.iPosition.iX = aItem.iControl->Size().iWidth >> 1;
                    aEvent.iPosition.iY = positionInParent - controlPosition;
                    }
                else
                    {
                    aEvent.iPosition.iX = aEvent.iPosition.iX + 
                        aDestination->Position().iX - aItem.iControl->Position().iX;
                    aEvent.iPosition.iY = aItem.iControl->Size().iHeight >> 1;
                    }
                    
                aDestination = aItem.iControl;
                
                wasModified = ETrue;
                }
            }
        }
        
    return wasModified;
    }
    
// ---------------------------------------------------------------------------
// CAknPointerEventModifier::Compare
// ---------------------------------------------------------------------------
//
TInt CAknPointerEventModifier::Compare( const TStackItem& aFirst, 
    const TStackItem& aSecond )
    {
    TInt retval = -1; // aFirst is in front of aSecond
    TInt firstPosition = aFirst.iParent->DrawableWindow()->OrdinalPosition();
    TInt secondPosition = aSecond.iParent->DrawableWindow()->OrdinalPosition();
    
    if ( secondPosition < firstPosition && secondPosition >= 0 )
        {
        // aSecond is in front of aFirst in z-order
        retval = 1;
        }
    else if ( firstPosition == secondPosition )
        {
        // aFirst and aSecond have the same parent window
        retval = 0;
        }
    
    return retval;
    }