/*

* 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:

*

*/

#include <e32base.h>

#include <e32const.h>

#include <coecntrl.h>

#include <coemain.h>

#include <AknUtils.h>

#include "xnwidgetextensionadapter.h"

#include "xncontroladapter.h"

#include "xncomponentnodeimpl.h"

#include "xncomponent.h"

#include "xnuiengine.h"

#include "xnhittest.h"

#include "xnnode.h"

#include "xnnodepluginif.h"

#include "xnviewnodeimpl.h"

#include "xnnodepluginif.h"

#include "xndomdocument.h"

#include "xnproperty.h"

#include "xnodt.h"  

#include "xntype.h"

#include "xndomnode.h"

#include "xndomstringpool.h"

#include "xnappuiadapter.h"

#include "xnviewmanager.h"

#include "xnviewdata.h"

#include "xnplugindata.h"

_LIT8( KPopUpText, "popup" );

_LIT8( KPositionHint, "_s60-position-hint" );

_LIT8( KWidgetNodeName, "widget" );

_LIT8( KParentIdName, "parentid" );

_LIT8( KDisplay, "display" );

_LIT8( KNone, "none" );

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

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

// CXnWidgetExtensionAdapter::NewL

// Two-phased constructor. Can leave.

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

//

CXnWidgetExtensionAdapter* CXnWidgetExtensionAdapter::NewL( 

    CXnNodePluginIf& aNode )

    {

    CXnWidgetExtensionAdapter* self = 

        new ( ELeave ) CXnWidgetExtensionAdapter( aNode );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CXnWidgetExtensionAdapter::~CXnWidgetExtensionAdapter

// Destructor.

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

//

CXnWidgetExtensionAdapter::~CXnWidgetExtensionAdapter()

    {

    }

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

// CXnWidgetExtensionAdapter::CXnWidgetExtensionAdapter

// C++ default constructor. Must not leave.

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

//

CXnWidgetExtensionAdapter::CXnWidgetExtensionAdapter( CXnNodePluginIf& aNode )

    : iNode( aNode ), iPositionHint( ENone )

    {

    }

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

// CXnWidgetExtensionAdapter::ConstructL

// 2nd phase constructor. Can leave.

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

//    

void CXnWidgetExtensionAdapter::ConstructL()

    {

    CreateWindowL();

    Window().SetRequiredDisplayMode( EColor16MA );

    // this adapter handles both widgetextension and popup nodes

    // we have to decide which one of them is the recent one    

    CXnType* typeInfo = iNode.Node().Type();

    const TDesC8& type = typeInfo->Type();

    if ( type == KPopUpText )

        {

        // popup element does not capture pointer events

        SetPointerCapture( ETrue );      

        }

    else

        {

        // widget extension node

        SetPointerCapture( ETrue );

        if ( Window().SetTransparencyAlphaChannel() == KErrNone )

            {

            Window().SetBackgroundColor( ~0 );

            }     

        }

    iUiEngine = iNode.Node().UiEngine();

    CXnControlAdapter::ConstructL( iNode );

    EnableDragEvents();   

    iAppUiAdapter = static_cast< CXnAppUiAdapter* >( iAvkonAppUi );

    }

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

// CXnWidgetExtensionAdapter::MakeVisible

// 

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

// 

void CXnWidgetExtensionAdapter::MakeVisible( TBool aVisible )

    {

    TBool visible( IsVisible() ? ETrue : EFalse );

    if ( visible == aVisible )

        {

        return;

        }

    CXnPluginData& plugin( 

            iAppUiAdapter->ViewManager().ActiveViewData().Plugin( &iNode.Node() ) );

    plugin.SetIsDisplayingPopup( aVisible, &iNode.Node() );

    if ( aVisible )

        {

        CXnType* typeInfo = iNode.Node().Type();

        const TDesC8& type = typeInfo->Type();

        if ( type == KPopUpText )

            {            

            // read position-hint property and set-up its variable

            CXnProperty* positionHintProp = NULL;

            TRAP_IGNORE( positionHintProp = iNode.Node().GetPropertyL( KPositionHint ) );

            if ( positionHintProp )

                {

                const TDesC8& displayHintVal = positionHintProp->StringValue();

                if ( displayHintVal == XnPropertyNames::tooltip::positionhint::KAboveLeft )

                    {

                    iPositionHint = EAboveLeft;

                    }

                else if ( displayHintVal == XnPropertyNames::tooltip::positionhint::KAboveRight )

                    {

                    iPositionHint = EAboveRight;

                    }

                else if ( displayHintVal == XnPropertyNames::tooltip::positionhint::KBelowLeft )

                    {

                    iPositionHint = EBelowLeft;

                    }

                else if ( displayHintVal == XnPropertyNames::tooltip::positionhint::KBelowRight )

                    {

                    iPositionHint = EBelowRight;

                    }

                else if ( displayHintVal == XnPropertyNames::tooltip::positionhint::KRight )

                    {

                    iPositionHint = ERight;

                    }

                else if ( displayHintVal == XnPropertyNames::tooltip::positionhint::KLeft )

                    {

                    iPositionHint = ELeft;

                    }

                else 

                    {

                     // if the value if of unknown type, use default one

                     if ( AknLayoutUtils::LayoutMirrored() )

                         {

                         iPositionHint = EAboveRight;

                         }

                         else

                         {

                         iPositionHint = EAboveLeft; 

                         }

                     }

                if ( iPositionHint != ENone )

                    {    

                    // the popup is going visible and position-hind is available

                    // calculate its position

                    CalculatePosition();

                    }

                }

            }       

        DrawableWindow()->FadeBehind( ETrue );

        }

    else

        {

        DrawableWindow()->FadeBehind( EFalse );

        }

    CCoeControl::MakeVisible( aVisible );            

    }

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

// CXnWidgetExtensionAdapter::HandlePointerEventL

// 

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

//    

void CXnWidgetExtensionAdapter::HandlePointerEventL( 

    const TPointerEvent& aPointerEvent )

    {    

    CXnType* typeInfo = iNode.Node().Type();

    const TDesC8& type = typeInfo->Type();

    // in case of popup, we have to make sure that 

    // it will be closed after tapping outside of the

    // area of itself and its parent

    if ( type == KPopUpText )

        {

        // check if the tap was inside of popup

        TRect popupRect = this->Rect();

        popupRect.Move(this->Position() );

        TBool isInPopupWindow = popupRect.Contains(

                aPointerEvent.iParentPosition );

        if ( !isInPopupWindow )

            {

            // if tap was outside of window, check if tap was 

            // inside of the parrent

            CXnProperty* parentIdProp = iNode.Node().GetPropertyL(

                    KParentIdName );

            if ( parentIdProp )

                {                

                const TDesC8& parentIdVal = parentIdProp->StringValue();

                CXnNode* parentN(iUiEngine->FindNodeByIdL( parentIdVal,

                        iNode.Node().Namespace() ) );

                TRect clientRect =

                        static_cast<CEikAppUi&> ( *iAppUiAdapter ).ClientRect();

                TRect parentRect = parentN->Rect();

                parentRect.Move( clientRect.iTl );

                if ( !parentRect.Contains( aPointerEvent.iParentPosition ) )

                    {

                    // tap was neither in popup nor in its parent -

                    // we can close it

                    if ( aPointerEvent.iType == TPointerEvent::EButton1Down )

                        {

                            iNode.Node().DomNode()->StringPool();

                        CXnProperty* prop = CXnProperty::NewL( KDisplay, KNone,

                        CleanupStack::PushL( prop );

                        iNode.Node().SetPropertyL( prop );

                        CleanupStack::Pop( prop );

                        return;

                        }

                    }

                else

                    {

                    // tap was made inside of popup parent

                    // we pass the event to it after

                    // recalculating the taping point

                    TPointerEvent newPointerEvent;

                    newPointerEvent.Copy( aPointerEvent );

                    newPointerEvent.iPosition = TPoint(

                             aPointerEvent.iParentPosition - clientRect.iTl );

                    parentN->Control()->HandlePointerEventL( newPointerEvent );

                    return;

                    }

                }

            }

        }

    CXnControlAdapter::HandlePointerEventL( aPointerEvent );

    }

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

// CXnWidgetExtensionAdapter::Draw

// 

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

//    

void CXnWidgetExtensionAdapter::Draw( const TRect& aRect ) const

    {

        CXnControlAdapter::Draw( aRect );

    }

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

// CalculatePosition

// This is used only for popup element with position hint

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

void CXnWidgetExtensionAdapter::CalculatePosition() 

    {

    // widget's rectangle

    TRect controlRect;

    // get popup's window size

    TRect popupRect = this->Rect();

    TRect clientRect = static_cast<CEikAppUi&>( *iAppUiAdapter ).ClientRect();

    // get entire screen except control pane

    TRect contentRect( 0, 0, clientRect.iBr.iX, clientRect.iBr.iY ); 

    // resulting rectangle

    TRect rect;

    TPoint offset( clientRect.iTl );

    // parent widget's rectangle ( first predecesscor which is "widget" )

    CXnNode* parent = iNode.Node().Parent();

    while ( parent )

        {

        const TDesC8& type( parent->DomNode()->Name() );

        if ( type == KWidgetNodeName )

            {

            break;

            }

        parent = parent->Parent();

        }

    // if predecesscor widget was not found, use parent's rectangle

    if ( parent == NULL )

        { 

        controlRect = iNode.Node().Parent()->Rect();

        }

    else

        {

        controlRect = parent->BorderRect();

        }

    // calculate available space for placing the popup

    TInt spaceAbove = controlRect.iTl.iY + offset.iY;

    TInt spaceBelow = contentRect.iBr.iY - controlRect.iBr.iY - offset.iY;

    TInt spaceLeft = controlRect.iTl.iX + offset.iX;

    TInt spaceRight = contentRect.iBr.iX - controlRect.iBr.iX - offset.iX;

    switch ( iPositionHint )

        {

        case EAboveLeft:

            // if this position does not fit the screen,

            // and if below left is more suitable, use it

            if ( spaceAbove < popupRect.Height() && spaceBelow > spaceAbove )

                {

                rect = TRect( TPoint( controlRect.iTl.iX, controlRect.iBr.iY ), 

                              TPoint( controlRect.iTl.iX + popupRect.Width(), controlRect.iBr.iY + popupRect.Height() ) );

                }

            else

                {

                // use the above-left position

                rect = TRect( TPoint( controlRect.iTl.iX, controlRect.iTl.iY - popupRect.Height() ), 

                              TPoint( controlRect.iTl.iX + popupRect.Width(), controlRect.iTl.iY ) );

                }

            break;

        case EAboveRight:

            // if this position does not fit the screen,

            // and if below right is more suitable, use it

            if ( spaceAbove < popupRect.Height() && spaceBelow > spaceAbove )

                {

                rect = TRect( TPoint( controlRect.iBr.iX - popupRect.Width(), controlRect.iBr.iY ), 

                              TPoint( controlRect.iBr.iX, controlRect.iBr.iY + popupRect.Height() ) );

                }

            else

                {

                // use the above-right position

                rect = TRect( TPoint( controlRect.iBr.iX - popupRect.Width(), controlRect.iTl.iY - popupRect.Height() ), 

                              TPoint( controlRect.iBr.iX,  controlRect.iTl.iY ) );

                }

            break;

        case EBelowLeft:

            // if this position does not fit the screen,

            // and if above left is more suitable, use it

            if ( spaceBelow < popupRect.Height() && spaceBelow < spaceAbove )

                {

                rect = TRect( TPoint( controlRect.iTl.iX, controlRect.iTl.iY - popupRect.Height() ), 

                              TPoint( controlRect.iTl.iX + popupRect.Width(), controlRect.iTl.iY ) );

                }

            else

                {

                // use the below-left position

                rect = TRect( TPoint( controlRect.iTl.iX, controlRect.iBr.iY ), 

                              TPoint( controlRect.iTl.iX + popupRect.Width(), controlRect.iBr.iY + popupRect.Height() ) );

                }

            break;

        case EBelowRight:

              // if this position does not fit the screen,

              // and if above right is more suitable, use it

              if ( spaceBelow < popupRect.Height() && spaceBelow < spaceAbove )

                  {

                  rect = TRect( TPoint( controlRect.iBr.iX - popupRect.Width(), controlRect.iTl.iY - popupRect.Height() ), 

                                TPoint( controlRect.iBr.iX,  controlRect.iTl.iY ) );

                  }

              else

                  {

                  // use the below-right position

                  rect = TRect( TPoint( controlRect.iBr.iX - popupRect.Width(), controlRect.iBr.iY ), 

                                TPoint( controlRect.iBr.iX, controlRect.iBr.iY + popupRect.Height() ) );

                  }

            break;

        case ERight:

            // if this position does not fit the screen,

            // and if left or above-left is more suitable, use it

            if ( spaceRight < popupRect.Width() )

                {

                // use the left position if the space is big enough

                if ( spaceLeft >= popupRect.Width() )

                    {

                    // use left position

                    rect = TRect( TPoint( controlRect.iTl.iX - popupRect.Width(), controlRect.iTl.iY ), 

                                  TPoint( controlRect.iTl.iX, controlRect.iTl.iY + popupRect.Height() ) );

                    }

                else if ( spaceAbove >= popupRect.Height() )

                    {

                    // use the above-right position

                    rect = TRect( TPoint( controlRect.iBr.iX - popupRect.Width(), controlRect.iTl.iY - popupRect.Height() ), 

                                  TPoint( controlRect.iBr.iX,  controlRect.iTl.iY ) );  

                    }

                else

                    {

                    // use the below-right position

                    rect = TRect( TPoint( controlRect.iBr.iX - popupRect.Width(), controlRect.iBr.iY ), 

                                  TPoint( controlRect.iBr.iX, controlRect.iBr.iY + popupRect.Height() ) );

                    }

                }

            else

                {

                // use the right position

                rect = TRect( TPoint( controlRect.iBr.iX, controlRect.iTl.iY ), 

                              TPoint( controlRect.iBr.iX + popupRect.Width(), controlRect.iTl.iY + popupRect.Height() ) );

                }

            break;

        case ELeft:

            // if this position does not fit the screen,

            // and if right is more suitable, use it

            if ( spaceLeft < popupRect.Width() )

                {

                // use the right position, if it the space is big enough

                if ( spaceRight >= popupRect.Width() )

                    {    

                    rect = TRect( TPoint( controlRect.iBr.iX, controlRect.iTl.iY ), 

                                  TPoint( controlRect.iBr.iX + popupRect.Width(), controlRect.iTl.iY + popupRect.Height() ) );

                    }

                else if ( spaceAbove >= popupRect.Height() )

                    {

                    // use the above-left position

                    rect = TRect( TPoint( controlRect.iTl.iX, controlRect.iTl.iY - popupRect.Height() ), 

                                  TPoint( controlRect.iTl.iX + popupRect.Width(), controlRect.iTl.iY ) );

                    }

                else

                    {

                    // use the below-left position

                    rect = TRect( TPoint( controlRect.iTl.iX, controlRect.iBr.iY ), 

                                  TPoint( controlRect.iTl.iX + popupRect.Width(), controlRect.iBr.iY + popupRect.Height() ) );

                    }

                }

            else

                {

                // use the left position  

                rect = TRect( TPoint( controlRect.iTl.iX - popupRect.Width(), controlRect.iTl.iY ), 

                              TPoint( controlRect.iTl.iX, controlRect.iTl.iY + popupRect.Height() ) );

                }

            break;

        default:

            break;

        }

    rect.Move( offset );

    // if the popup rectangle exceeds the borders of content rectangle, move it.

    if ( rect.iTl.iY < contentRect.iTl.iY )

        {

        rect.Move( 0, contentRect.iTl.iY - rect.iTl.iY );

        }

    if ( rect.iTl.iX < contentRect.iTl.iX )

        {

        rect.Move( contentRect.iTl.iX - rect.iTl.iX, 0 );

        }

    if ( rect.iBr.iY > contentRect.iBr.iY )

        {

        rect.Move( 0, contentRect.iBr.iY - rect.iBr.iY );

        }

    if ( rect.iBr.iX > contentRect.iBr.iX )

        {

        rect.Move( contentRect.iBr.iX - rect.iBr.iX, 0 );

        }

    this->SetRect( rect );

    }

//  End of File