/*

* 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:  Popup toolbar extension

*

*/

#include <barsread.h>

#include <AknsFrameBackgroundControlContext.h>

#include <AknsDrawUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.cdl.h>

#include <aknbutton.h>

#include <eikedwin.h>

#include <akntoolbarextension.h>

#include <touchfeedback.h>

#include <eikcolib.h>

#include "akntoolbaritem.h"

#include "akntoolbarextensionview.h"

#include "aknresourceprovider.h"

const TInt KNoItemSelected = -1; 

const TUint32 KToolbarExtensionBgColor = 0x00000000;

const TInt KToolBarExtensionBgAlpha = 0x7F;

const TInt KToolbarButtonBeforeTimeout = 300; 

enum TDirection

    {

    EDirectionLeft = 0,  

    EDirectionRight, 

    EDirectionUp,

    EDirectionDown, 

    ENoDirection

    }; 

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

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

// CAknToolbarExtensionView::NewL

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

//

CAknToolbarExtensionView* CAknToolbarExtensionView::NewL( TResourceReader& aReader,

    CAknToolbarExtension* aExtension )

    {

    CAknToolbarExtensionView* self = new ( ELeave ) CAknToolbarExtensionView( aExtension);

    CleanupStack::PushL( self );

    self->ConstructL(); 

    self->ConstructFromResourceL( aReader );

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CAknToolbarExtensionView::~CAknToolbarExtensionView()

    {

    SetFocus( EFalse );

    CEikonEnv::Static()->EikAppUi()->RemoveFromStack( this );

    if ( iSelectedItem >= 0 && iSelectedItem < iItems.Count() ) 

        {

        TRAP_IGNORE( iItems[iSelectedItem]->SetIsSelectedL(EFalse) ); 

        }

    iVisibleItems.Reset();

    iItems.ResetAndDestroy(); 

    delete iFrameContext; 

    delete iResourceProvider;

    }

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

// From class CCoeControl.

// Constructs extension view

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

//

void CAknToolbarExtensionView::ConstructFromResourceL( TResourceReader& aReader )

    {

    TInt numberOfItems = aReader.ReadInt16();

    TBool noFrame(EFalse); 

    for ( TInt i = 0; i < numberOfItems; ++i )

        {

        CAknToolbarItem* item = ConstructControlLC( aReader ); 

        if ( item->Control() )

            {

            iItems.AppendL( item ); 

            item->Control()->SetContainerWindowL( *this );

            item->Control()->SetObserver( iExtension );

            if ( item->ControlType() == EAknCtButton )

                {

                CAknButton* button = static_cast<CAknButton*>(item->Control() ); 

                TInt flags = button->ButtonFlags(); 

                if ( !noFrame && ( !( flags & KAknButtonNoFrame ) ||  

                    !( flags & KAknButtonPressedDownFrame ) ) ) 

                    {

                    // Set flag KAknButtonNoFrame for all buttons except the one

                    // after an editor

                    flags |= KAknButtonNoFrame; 

                    flags |= KAknButtonPressedDownFrame;

                    button->RegisterResourceProvider( iResourceProvider );

                    button->SetButtonFlags( flags ); 

                    }

                else if ( noFrame )

                    {

                    // Setting frames for the button that comes after an editor

                    if ( flags & KAknButtonNoFrame )

                        {

                        flags &= ~KAknButtonNoFrame;

                        flags &= ~KAknButtonPressedDownFrame;  

                        button->SetButtonFlags( flags ); 

                        }

                    noFrame = EFalse; 

                    }

                AdjustButtonL( *button ); 

                }

            else 

                {

                if ( Editor( item->ControlType() ) ) 

                    {

                    noFrame = ETrue; 

                    }

                }

            CleanupStack::Pop( item ); 

            }

        else

            {

            CleanupStack::PopAndDestroy( item );

            item = NULL;

            }

        }

    if ( iExtension->ExtensionFlags() & KAknTbExtensionDsaMode )

        {

        iFrameContext->SetFrame( KAknsIIDQgnGrafPopupTrans ); 

        }

    ActivateL(); 

    // Activating here the items, because ActivateL uses CountComponentControls

    // which is currently 0 since iVisibleItems is still empty

    for ( TInt i = 0; i < iItems.Count(); i++ )

        {

        iItems[i]->Control()->ActivateL(); 

        }

    SetComponentsToInheritVisibility( ETrue );

    }

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

// From class CCoeControl.

// Shows or hides extension view

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

//

void CAknToolbarExtensionView::MakeVisible( TBool aVisible )

    {

    TBool isVisible = IsVisible(); 

    if ( aVisible && !isVisible )

        {

            // the toolbar extension is shown, this happens only with pointer event? 

            MTouchFeedback* feedback = MTouchFeedback::Instance();

            if ( feedback )

                {

                feedback->InstantFeedback( ETouchFeedbackPopUp );

                }

        TRect rect; 

        TRAP_IGNORE( rect = CalculateSizeL() ); 

        CEikonEnv::Static()->EikAppUi()->UpdateStackedControlFlags( this, 

            0, ECoeStackFlagRefusesFocus | ECoeStackFlagRefusesAllKeys );

        CEikonEnv::Static()->EikAppUi()->HandleStackChanged();

        // Calling this here, so that iVisibleItems array has been updated and

        // all items visible in extension get call makevisible

        CAknControl::MakeVisible( aVisible );

        SetRect( rect );     

        DrawableWindow()->SetOrdinalPosition( 0, ECoeWinPriorityNormal );    

        TBool floating = !IsNonFocusing(); 

        for ( TInt i = 0; i < iItems.Count(); i++ )

            {

            if ( !floating && Editor( iItems[i]->ControlType() ) )

                {

                TRAP_IGNORE( SelectItemL( i, ETrue ) ); 

                break; 

                }

            if ( floating && iItems[i]->ControlType() == EAknCtButton )

                {

                CAknButton* button = static_cast<CAknButton*>( iItems[i]->Control() ); 

                TInt j = 0; 

                while( button->State( j ) )

                    {

                    //Setting the texts empty

                    TRAP_IGNORE( button->State( j++ )->SetTextL( KNullDesC ) ); 

                    }

                }

            }

        if ( floating && iVisibleItems.Count() )

            {

            iSelectedItem = NextFocusable( 1 ); 

            TRAP_IGNORE( iVisibleItems[iSelectedItem]->SetFocusL( 

                ETrue, EFalse, ENoDrawNow, this ) ); 

            }

        if ( iPreviousItem >= 0 && IsNonFocusing() )

            {            

            CAknToolbarItem* prevItem = iVisibleItems[iPreviousItem];

            if ( prevItem->Control() )

                {

                if ( prevItem->ControlType() == EAknCtButton ||

                        prevItem->ControlType() == EAknCtToolbarExtension )

                   {

                   CAknButton* button = static_cast<CAknButton*>( prevItem->Control() );

                   button->ResetState();

                   }

                }

            iPreviousItem = KNoItemSelected;

            }

        DrawNow(); 

        }

    else if ( !aVisible && isVisible )

        {

        CEikonEnv::Static()->EikAppUi()->UpdateStackedControlFlags( this, 

            ~0, ECoeStackFlagRefusesFocus | ECoeStackFlagRefusesAllKeys );

        CEikonEnv::Static()->EikAppUi()->HandleStackChanged();

        CAknControl::MakeVisible( aVisible );

        TRAP_IGNORE( SelectItemL( iSelectedItem, EFalse ) ); 

        DrawableWindow()->SetOrdinalPosition( 0, ECoeWinPriorityNeverAtFront );

        }

    else 

        {

        CAknControl::MakeVisible( aVisible );

        }

    }

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

// From class OfferKeyEventL.

// Consumes key events if floating toolbar extension

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

//

TKeyResponse CAknToolbarExtensionView::OfferKeyEventL( 

    const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    if ( aKeyEvent.iCode == EKeyYes || !IsVisible() )

        {

        return EKeyWasNotConsumed; 

        }

    //LSK, RSK, KeyOk

    else if ( IsNonFocusing() && aType == EEventKey 

            && ( aKeyEvent.iCode == EKeyDevice0 

                    || aKeyEvent.iCode == EKeyDevice1 

                    || aKeyEvent.iCode == EKeyDevice3 ) )

        {

        if( IsVisible()&& ( aKeyEvent.iCode == EKeyDevice0 ||

                            aKeyEvent.iCode == EKeyDevice1 ))

            {

            iExtension->SetShown(EFalse);

            return EKeyWasConsumed; 

            }

        return EKeyWasNotConsumed;

        }

    // When this is visible and without focus, nothing to do 

    //

    // Exception for key filter: Image capture key (not a complete solution:

    //       the key map may change corrding to the products)

    else if ( IsNonFocusing()&& aType == EEventKey 

            &&(!( aKeyEvent.iScanCode == EStdKeyDevice3

                  || aKeyEvent.iScanCode == EStdKeyEnter )) )

        {

        return EKeyWasConsumed;

        }

    else if( IsVisible() && aType == EEventKey )

        {

        switch ( aKeyEvent.iCode )

            {

            case EKeyRightArrow:

                MoveHighlightL( EDirectionRight, 0 ); 

                break; 

            case EKeyLeftArrow:

                MoveHighlightL( EDirectionLeft, 0 ); 

                break; 

            case EKeyUpArrow:

                MoveHighlightL( EDirectionUp, 0 ); 

                break; 

            case EKeyDownArrow:

                MoveHighlightL( EDirectionDown, 0 ); 

                break; 

            default: 

                break;     

            }

        return EKeyWasConsumed;

        }

    else

        {

        CAknToolbarItem* item = NULL; 

        if ( iSelectedItem >= 0 && iSelectedItem < iVisibleItems.Count() )

            {

            item = iVisibleItems[iSelectedItem]; 

            }

        // All key events can be given to buttons, other toolbar items must 

        // be seleceted to get events

        if ( item && item->Control() )

            {

            if ( ( item->ControlType() == EAknCtButton ) || 

               ( item->ControlType() == EAknCtToolbarExtension )  || item->IsSelected() )

                {

                if ( aKeyEvent.iScanCode == EStdKeyDevice0 )

                    {

                    TKeyEvent keyEvent = aKeyEvent; 

                    // Button does not accept key events if the code is EStdKeyDevice0

                    // so changing the key event to EStdKeyDevice3    

                    keyEvent.iScanCode = EStdKeyDevice3; 

                    item->Control()->OfferKeyEventL( keyEvent, aType );

                    }

                else if ( aKeyEvent.iScanCode == EStdKeyDevice1 )

                    {

                    MakeVisible( EFalse ); 

                    // Close extension view and let also extension know about it

                    // so it can change state

                    iExtension->ViewClosed(); 

                    // Toolbar should perhaps be closed too! 

                    }

                else

                    {

                    item->Control()->OfferKeyEventL( aKeyEvent, aType );

                    }

                }

            }

        return EKeyWasNotConsumed; 

        }

    }

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

// CAknToolbarExtensionView::CountComponentControls

// Gets the number of controls contained in a compound control.

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

//

TInt CAknToolbarExtensionView::CountComponentControls() const

    {

    return iVisibleItems.Count(); 

    }

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

// CAknToolbarExtensionView::ComponentControl

// Gets the specified component of a compound control.

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

//    

CCoeControl* CAknToolbarExtensionView::ComponentControl( TInt aIndex ) const

    {

    if ( aIndex < 0 || aIndex >= iVisibleItems.Count() )

        {

        return NULL; 

        }

    return iVisibleItems[aIndex]->Control(); 

    }

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

// CAknToolbarExtensionView::HandleResourceChange

// Handles resource changes

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

//

void CAknToolbarExtensionView::HandleResourceChange( TInt aType )

    {

    iResourceProvider->HandleResourceChange( aType );

    // Hide extension, if non-focusing, and no pen support. Later...

    if ( aType == KEikDynamicLayoutVariantSwitch )

        {

        if ( IsVisible() )

            {

            TRect rect; 

            TRAP_IGNORE( rect = CalculateSizeL() ); 

            SetRect( rect ); 

            }

        }

    // Not calling base class function here, because only visible controls would 

    // be returned by ComponentControl, and thus the font would not be updated

    // for all controls

    for ( TInt i = 0; i < iItems.Count(); ++i )

        {

        iItems[i]->Control()->HandleResourceChange( aType );

        if ( iItems[i]->ControlType() == EAknCtButton )

            {

            CAknButton* button = static_cast<CAknButton*>( iItems[i]->Control() ); 

            if ( aType == KEikDynamicLayoutVariantSwitch )

                {

                TBool useOutline = iExtension->ExtensionFlags() & KAknTbExtensionDsaMode;  

                const CFont* font = AknLayoutUtils::FontFromId( AknLayoutScalable_Avkon::

                    cell_tb_ext_pane_t1( useOutline ? 0 : 1 ).LayoutLine().FontId() );

                button->SetTextFont( font ); 

                }

            if ( aType == KAknsMessageSkinChange )

                {

                if ( iExtension->ExtensionFlags() & KAknTbExtensionDsaMode )

                    {

                    TRAP_IGNORE( AknLayoutUtils::OverrideControlColorL(

                        *button, EColorControlBackground, KRgbWhite ) );

                    TRAP_IGNORE( AknLayoutUtils::OverrideControlColorL( 

                        *button, EColorButtonText, KRgbBlack ) );

                    }

                }

            }

        }

    // Remember to check here if iSelectedItem still is in iVisibleItems, and if 

    // not then do something. 

    if ( ( aType == KAknsMessageSkinChange || 

        aType == KEikDynamicLayoutVariantSwitch ) && IsVisible() )

        {

        DrawDeferred(); 

        }

    }

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

// CAknToolbarExtensionView::HandlePointerEventL

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

//

void CAknToolbarExtensionView::HandlePointerEventL( 

    const TPointerEvent& aPointerEvent )

    {

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

        {

        if ( !Rect().Contains( aPointerEvent.iPosition) )

            {

            iIsDownOutside = ETrue;

            }

        else

            {

            iIsDownOutside = EFalse;

            }

        }

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

        {

        if ( !Rect().Contains( aPointerEvent.iPosition) && iIsDownOutside )

            {

            // tapped outside view, 

            MTouchFeedback* feedback = MTouchFeedback::Instance();

            if ( feedback )

                {

                feedback->InstantFeedback( ETouchFeedbackPopUp );

                }

            MakeVisible( EFalse ); 

            // Close extension view and let also extension know about it

            // so it can change state

            iExtension->ViewClosed(); 

            iIsDownOutside = EFalse;

            return; 

            }

        }

    TPointerEvent event( aPointerEvent );

    TBool override ( EFalse );

    if ( aPointerEvent.iType == TPointerEvent::EButton1Down && IsNonFocusing() && iPreviousItem >=0 )

        {

        CAknToolbarItem* prevItem = iVisibleItems[iPreviousItem];

        if ( prevItem->Control() &&

             !prevItem->Control()->Rect().Contains( aPointerEvent.iPosition ) )

            {

            if ( prevItem->ControlType() == EAknCtButton ||

                    prevItem->ControlType() == EAknCtToolbarExtension )

               {

               CAknButton* button = static_cast<CAknButton*>( prevItem->Control() );

               event.iType = TPointerEvent::EButton1Up;

               button->HandlePointerEventL ( event );

               }

            }            

        }

    // Cancel previous button

    if ( iPreviousItem >=0 && ( aPointerEvent.iType == TPointerEvent::EDrag || 

        aPointerEvent.iType == TPointerEvent::EButtonRepeat ) )

        {

        CAknToolbarItem* prevItem = iVisibleItems[iPreviousItem];

        if ( prevItem->Control() &&

             !prevItem->Control()->Rect().Contains( aPointerEvent.iPosition ) )

                {

                if ( prevItem->ControlType() == EAknCtButton ||

                     prevItem->ControlType() == EAknCtToolbarExtension )

                    {

                    CAknButton* button = static_cast<CAknButton*>( prevItem->Control() );

                    event.iType = TPointerEvent::EButton1Up;

                    button->HandlePointerEventL ( event );

                    override = ETrue;

                    iPreviousItem = KNoItemSelected;

                    }

                }        

        }

    CAknToolbarItem* item = NULL;

    for ( TInt ii = 0; ii < iVisibleItems.Count(); ++ii )

        {

        item = iVisibleItems[ii];

        if ( item->Control() && 

             item->Control()->Rect().Contains( aPointerEvent.iPosition ) )

            {

            if ( item->ControlType() == EAknCtButton || 

                 item->ControlType() == EAknCtToolbarExtension )

                {

                CAknButton* button = static_cast<CAknButton*>( item->Control() ); 

                if ( ii != iPreviousItem )

                    {

                    if ( !button->IsDimmed() && !IsNonFocusing() )

                        {

                        MoveHighlightL( ENoDirection, ii );