/*

* Copyright (c) 2005-2006 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:  Shortcut plug-in shortcut extensions

*

*/

#include <aicontentobserver.h>

#include <gulicon.h>

#include <fbs.h>

#include <e32property.h>

#include "caiscutshortcutext.h"

#include "aiscutcontentmodel.h"

#include "caiscuttarget.h"

#include "caiscutengineext.h"

#include "PopupFSM.h"

#include "cpopupeventhandler.h"

#include "maiscutextdata.h"

#include "activeidle2domainpskeys.h"

#include "debug.h"

// P&S access policies

_LIT_SECURITY_POLICY_C1( KAiScutReadPolicy, ECapabilityReadDeviceData );

_LIT_SECURITY_POLICY_C1( KAiScutWritePolicy, ECapabilityWriteDeviceData );

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

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

//

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

//

CAiScutShortcutExt* CAiScutShortcutExt::NewL(

    TInt aId, const TDesC& aTarget, CAiScutEngine& aEngine )

    {

    CAiScutShortcutExt* self = CAiScutShortcutExt::NewLC(

        aId, aTarget, aEngine );

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

CAiScutShortcutExt* CAiScutShortcutExt::NewLC(

    TInt aId, const TDesC& aTarget, CAiScutEngine& aEngine )

    {

    CAiScutShortcutExt* self = new( ELeave ) CAiScutShortcutExt(

        aId, aEngine );

    CleanupStack::PushL( self );

    self->ConstructL( aTarget );

    return self;

    }

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

//

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

//

CAiScutShortcutExt::~CAiScutShortcutExt()

    {

    delete iPopupEventHandler;

    }

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

//

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

//

CAiScutShortcutExt::CAiScutShortcutExt( TInt aId, CAiScutEngine& aEngine )

    : CAiScutShortcut( aId, aEngine )//,

    //iPublishLineArray( EFalse )

    {

    }

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

//

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

//

void CAiScutShortcutExt::ConstructL( const TDesC& aTarget )

    {

    iPopupEventHandler = CPopupEventHandler::NewL( *this );

    CAiScutShortcut::ConstructL( aTarget );

    RProperty::Define(

        KPSUidAiInformation,

        KActiveIdleThemeSupportsXsp,

        RProperty::EInt,

        KAiScutReadPolicy,

        KAiScutWritePolicy );

    RProperty::Set( KPSUidAiInformation, KActiveIdleThemeSupportsXsp, EPSAiXspNotSupported );

    }

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

//

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

//

TPtrC CAiScutShortcutExt::ActiveTargetDefinition() const

    {

    if( iActiveTarget )

        {

        return iActiveTarget->Definition();

        }

    return KNullDesC();

    }

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

//

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

//

void CAiScutShortcutExt::HandleAIEventL( TInt aEvent )

    {

    switch ( aEvent )

        {

        case EAiScutEventLoseFocus:

            {

            iPopupEventHandler->PopupFSM().HandleLostFocus();

            break;

            }

        case EAiScutEventGainFocus:

            {

            iPopupEventHandler->PopupFSM().HandleGotFocus();

            break;

            }

        default:

            {

            break;

            }

        }

    }

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

//

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

//

void CAiScutShortcutExt::HandleResumed( TAiTransitionReason aResumeReason )

    {

    switch( aResumeReason )

        {

        case EAiIdleBackground:

            {

            iPopupEventHandler->PopupFSM().HandleBackground();

            break;

            }

        case EAiIdleForeground:

            {

            // Handleforeground() calls unnecessary publishes in case nothing

            // has changed. 

            if ( iTextChanged || iIconChanged )

                {

                iPopupEventHandler->PopupFSM().HandleForeground();

                }

            break;

            }

        default:

            {

            break;

            }

        }

    }

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

//

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

//

void CAiScutShortcutExt::SetAiScutExtData(

    const MAiScutExtData* aAiScutExtData )

    {

    iAiScutExtData = aAiScutExtData;

    const MDesCArray* newPopupLineArray =

        aAiScutExtData ? aAiScutExtData->PopupLineArray() : NULL;

    const CGulIcon* newIcon =

        aAiScutExtData ? aAiScutExtData->Icon() : NULL;

    if( iPreviousPopupLineArray != newPopupLineArray &&

        newPopupLineArray )

        {

        iTextChanged = ETrue;

        iPopupEventHandler->PopupFSM().HandleUpdate();        

        }

    else if( iPreviousPopupLineArray && !newPopupLineArray )

        {

        iTextChanged = ETrue;

        iPopupEventHandler->PopupFSM().HandleReset();

        }

    if( iPreviousIcon != newIcon )

        {

        iIconChanged = ETrue;

        CAiScutEngineExt& engine = static_cast< CAiScutEngineExt& > ( iEngine );

        engine.CheckAccessAndPublish( *this );

        }

    iPreviousPopupLineArray = newPopupLineArray;

    iPreviousIcon = newIcon;

    }

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

//

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

//

void CAiScutShortcutExt::PublishL(

    MAiPropertyExtension& aPlugin, MAiContentObserver& aObserver )

    {

    if( iLastPublishedTarget && iActiveTarget &&

        iLastPublishedTarget->Definition() != iActiveTarget->Definition() )

        {

        iAiScutExtData = NULL;

        iPopupEventHandler->PopupFSM().HandleReset();

        }

    if( aObserver.CanPublish(

        aPlugin, KAiScutContent[EAiScutContentPopupTextFirstLine].id, iId) &&

        aObserver.CanPublish(

        aPlugin, KAiScutContent[EAiScutContentPopupTextSecondLine].id, iId) &&

        aObserver.CanPublish(

        aPlugin, KAiScutContent[EAiScutContentPopupTextThirdLine].id, iId) )

        {

        PublishPopupText( aPlugin, aObserver );

        RProperty::Set( KPSUidAiInformation, KActiveIdleThemeSupportsXsp, EPSAiXspIsSupported );

        }

    CAiScutShortcut::PublishL( aPlugin, aObserver );

    iTextChanged = EFalse;

    }

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

//

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

//

TInt CAiScutShortcutExt::PublishCaption(

    MAiPropertyExtension& aPlugin, MAiContentObserver& aObserver,

    TInt aCaptionContentId ) const

    {

    if( iPopupEventHandler->PublishCaption() )

        {

        if( !iPopupEventHandler->CaptionVisible() )

            {

            return aObserver.Clean( aPlugin, aCaptionContentId, iId );

            }

        else

            {

            return CAiScutShortcut::PublishCaption(

                aPlugin, aObserver, aCaptionContentId );

            }

        }

    else

        {

        return CAiScutShortcut::PublishCaption(

            aPlugin, aObserver, aCaptionContentId );

        }

    }

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

//

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

//

void CAiScutShortcutExt::PublishPopupText(

    MAiPropertyExtension& aPlugin, MAiContentObserver& aObserver ) const

    {

    if( iPopupEventHandler->PublishPopup() )

        {

        TAiScutContentIds popupTextContentIds[] =

            {

            EAiScutContentPopupTextFirstLine,

            EAiScutContentPopupTextSecondLine,

            EAiScutContentPopupTextThirdLine

            };

        const TInt idCount =

            sizeof( popupTextContentIds ) / sizeof( TAiScutContentIds );

        TInt err = KErrNone;

        //iLineArray is set or reset via xSP API. iPublishLineArray is controlled

        //by state machine in iPopupEventHandler

        if( iAiScutExtData && iAiScutExtData->PopupLineArray() &&

            iPopupEventHandler->PopupVisible() )

            {

            //Publish caption line in popup text box

            TPtrC captionDes;

            TInt captionResId = iActiveTarget->GetCaption( captionDes, EAiScutLongTitle );

            if ( captionResId == 0 )

                {

                // Publish descriptor

                err = aObserver.Publish( aPlugin,

                    KAiScutContent[ EAiScutContentPopupTextCaptionLine ].id,

                    captionDes, iId );

                if( err != KErrNone )

                    {

                    __PRINT( __DBG_FORMAT( "XAI:   publish Popup caption text err = %d" ), err );

                    }

                }

            else if ( captionResId > 0 )

                {

                // Publish resource

                err = aObserver.Publish( aPlugin,

                    KAiScutContent[ EAiScutContentPopupTextCaptionLine ].id,

                    captionResId, iId );

                if( err != KErrNone )

                    {

                    __PRINT( __DBG_FORMAT( "XAI:   publish Popup caption text (resource) err = %d" ), err );

                    }

                }

            const MDesCArray& lineArray = *iAiScutExtData->PopupLineArray();

            TInt numberOfLines = lineArray.MdcaCount();

            //Iterate each popup text content and either publish or clean it

            //depending on the number or lines in iLineArray

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

                {

                if( numberOfLines > i )

                    {

                    err = aObserver.Publish( aPlugin,

                        KAiScutContent[ popupTextContentIds[ i ] ].id,

                        lineArray.MdcaPoint( i ), iId );

                    if( err != KErrNone )

                        {

                        __PRINT( __DBG_FORMAT( "XAI:   publish Popup text err = %d" ), err );

                        }

                    }

                else

                    {

                    err = aObserver.Clean( aPlugin,

                        KAiScutContent[ popupTextContentIds[ i ] ].id, iId );

                    if( err != KErrNone )

                        {

                        __PRINT( __DBG_FORMAT( "XAI:   clean Popup text err = %d" ), err );

                        }

                    }

                }

            }

        else

            {

            //Clean each popup text content

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

                {

                err = aObserver.Clean( aPlugin,

                    KAiScutContent[ popupTextContentIds[ i ] ].id, iId );

                if ( err != KErrNone )

                    {

                    __PRINT( __DBG_FORMAT( "XAI:   clean Popup text err = %d" ), err );

                    }

                }

            }

        }

    }

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

//

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

//

TInt CAiScutShortcutExt::PublishIcon( MAiPropertyExtension& aPlugin,

    MAiContentObserver& aObserver, TInt aIconContentId )

    {

    if( aIconContentId == KAiScutContent[EAiScutContentShortcutIcon].id && 

		iAiScutExtData && iAiScutExtData->Icon() )

        {

        const CGulIcon& icon = *iAiScutExtData->Icon();

        CGulIcon* duplicatedIcon = NULL;

        TRAP_IGNORE(

            CFbsBitmap* bitmap = new( ELeave ) CFbsBitmap();

            CleanupStack::PushL( bitmap );

            CFbsBitmap* mask   = new( ELeave ) CFbsBitmap();

            CleanupStack::PushL( mask );

            User::LeaveIfError( bitmap->Duplicate( icon.Bitmap()->Handle() ) );

            User::LeaveIfError( mask->Duplicate( icon.Mask()->Handle() ) );

            duplicatedIcon = CGulIcon::NewL( bitmap, mask );

            CleanupStack::Pop( 2, bitmap );

            );

        if( duplicatedIcon )

            {

            TInt err = aObserver.PublishPtr( aPlugin,

                aIconContentId, duplicatedIcon, iId );

            if( err != KErrNone )

                {

                delete duplicatedIcon;

                }

            return err;

            }

        }

    TInt err = CAiScutShortcut::PublishIcon( aPlugin, aObserver, aIconContentId );

    iIconChanged = EFalse;

    return err;

    }

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

//

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

//

void CAiScutShortcutExt::IssuePublishShortcut()

    {

//    iPublishLineArray = aVisiblePopup;

    CAiScutEngineExt& engine = static_cast< CAiScutEngineExt& >( iEngine );

    engine.CheckAccessAndPublish( *this );

    }

// End of File.