// INCLUDE FILES

#include <apgcli.h>

#include <apgicnfl.h> 

#include <bautils.H> 

// CWrtData::ConfigureL

// CWrtData::HasMenuItem

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

//

TBool CWrtData::HasMenuItem(const TDesC16& aMenuItem )

    {

    TBool found = EFalse;

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

        {

        if( aMenuItem == iMenuItems[i] )

            {

            found =  ETrue;

            break;

            }

        }

    return found;

    }

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

// CWrtData::RegisterL

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

//

void CWrtData::RegisterL()

    {

    CLiwDefaultMap* filter = CreateFilterLC();

    filter->InsertL( KOperation, TLiwVariant( KAddUpdateDelete ) );

    iObserver->RegisterL(filter);

    CleanupStack::PopAndDestroy( filter );

    }

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

// CWrtData::UpdatePublisherStatusL

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

//

void CWrtData::UpdatePublisherStatusL()

    {

     // Resent the plugin status to publisher

     ActivateL();

     if ( iPlugin->IsActive() )

         {

         ResumeL();

         }

     else

         {

         SuspendL();

         }

      // forward the network status if it uses.

    if ( iPlugin->NetworkStatus() == CWrtDataPlugin::EOnline )

        {

        OnLineL();

        }

    else if ( iPlugin->NetworkStatus() == CWrtDataPlugin::EOffline )

        {

        OffLineL();

        }

    }

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

// CWrtData::PublishDefaultImageL

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

//

void CWrtData::PublishDefaultImageL( MAiContentObserver* aObserver )

    {

    TBuf<KWRTAppUidLenth> appUidStr;

    TBuf<KWRTContentValueMaxLength> appName;

    GetWidgetNameAndUidL( appName, appUidStr );

    TUid appUid;

    if ( ResolveUid (appUidStr, appUid ) )

        {

#ifdef WRT_PREDEFINED_IMAGE         

        RFs rfs;

        User::LeaveIfError( rfs.Connect() );

        TFileName privatePath;

        rfs.PrivatePath(privatePath);

        privatePath.Insert(0,KDrive);

        privatePath.Append( KImgFolder );

        appUidStr.Copy( appUid.Name());

        appUidStr.Delete(0,1);

        appUidStr.Delete( appUidStr.Length() -1, 1);

        privatePath.Append (appUidStr );

        privatePath.Append ( KJPEG );

        if ( BaflUtils::FileExists(rfs,privatePath) )

            {

            // Publish predefined jpeg image

            iPlugin->PublishImageL( aObserver, CWrtDataPlugin::EImage1,privatePath);

            }

        else

            {

            privatePath.Delete( privatePath.Length() - 4 , 4);

            privatePath.Append( KPNG );

            if ( BaflUtils::FileExists(rfs,privatePath) )

               {

               // Publish predefined image

               iPlugin->PublishImageL( aObserver, CWrtDataPlugin::EImage1,privatePath);

               }

            else

                {

#endif                 

                TInt handle = KErrNotFound;

                TInt mask = KErrNotFound;

                CreateIconFromUidL( handle, mask, appUid );

                // Publish widget apparc image

                iPlugin->PublishImageL( aObserver, CWrtDataPlugin::EDefaultImage,handle,mask);

                if ( appName.Length() > 0)

                   {

                   // Publish Widget Name

                   iPlugin->PublishTextL( aObserver, CWrtDataPlugin::EDefaultText, appName);

                   }

#ifdef WRT_PREDEFINED_IMAGE                

                }

            }

        rfs.Close();

#endif        

        }

    // Show loading animation

    iPlugin->ShowLoadingIcon(aObserver);

    }

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

// CWrtData::PublishL

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

//

void CWrtData::PublishL( MAiContentObserver* aObserver, CLiwDefaultMap* aDataMap ) 

    {

    TLiwVariant variant;

    iPlugin->HideLoadingIcon(aObserver);

    if ( aDataMap->FindL( KImage1, variant ) )

        {

        TInt handle = KErrBadHandle;

        TUint uintHandle = 0;

        TPtrC16 valPtr;

        if ( variant.Get( uintHandle ) )

            {

            handle = uintHandle;

            }

        else if ( !variant.Get( handle ) )

            {

            handle = KErrBadHandle;

            }

        // read as a image handle

        if( handle == KErrBadHandle )

            {

            // no handle, so read as image path

            variant.Get( valPtr );

            iPlugin->PublishImageL(aObserver, CWrtDataPlugin::EImage1, valPtr );

            }

        else

            {

            TInt maskHandle = KErrBadHandle;

            //Look for image mask

            if ( aDataMap->FindL( KImageMask, variant ) )

               {

               variant.Get( maskHandle );                           

               }

            iPlugin->PublishImageL(aObserver, CWrtDataPlugin::EImage1, handle, maskHandle );

            }

        }

    variant.Reset();

    }

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

// CWrtData::RefreshL

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

//

void CWrtData::RefreshL( TDesC& aContentId, TDesC& aOperation, 

        CLiwDefaultMap* aDataMap )

    {

     if ( aContentId == iContentId )

         {

         iPlugin->RefreshL( aOperation, aDataMap);

         }

    }

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

// CWrtData::ExecuteActionL

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

//

void CWrtData::ExecuteActionL(const TDesC& aObjectId, const TDesC& aTrigger )

   {

   HBufC8* triggerName = HBufC8::NewLC( KWRTContentNameMaxLength );

   CLiwGenericParamList* inParamList  = &iServiceHandler->InParamListL();

   CLiwGenericParamList* outParamList = &iServiceHandler->OutParamListL();

   CLiwDefaultMap* filter = NULL;

   triggerName->Des().Copy(aTrigger);

   if ( aObjectId == KPubData )

       {

       // this trigger belongs to publisher registery.

       // in such case it is assumed that all the items in the widgets

       // belongs to same publisher, type and id.

       TLiwGenericParam cptype( KType, TLiwVariant( KPubData ) );

       inParamList->AppendL( cptype );

       cptype.Reset();

       // use the first item configuration to create the filter

       filter = CreateFilterLC();

       }

   else

       {

       if ( aObjectId == KMenuItem16 )

           {

           TInt pos = KErrNotFound;

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

               {

               if ( aTrigger == iMenuItems[i] )

                   {

                   pos = i;

                   break;

                   }

               }

           if( pos == KErrNotFound )

               {

               // No such menu items

               CleanupStack::PopAndDestroy( triggerName );

               return; 

               }

              triggerName->Des().Copy( iMenuTriggers[pos]->Des() );

              filter = CreateFilterLC();

           }

       else

           {

           //Create filter criteria for requested entries in form of LIW map:

           filter = CreateFilterLC();

           }

       //append type to inparam list

       TLiwGenericParam cptype( KType, TLiwVariant( KCpData ) );

       inParamList->AppendL( cptype );

       cptype.Reset();

       }

    filter->InsertL( KActionTrigger, TLiwVariant( triggerName->Des() ) );

   //append filter to input param

    TLiwGenericParam item( KFilter, TLiwVariant( filter ) );

    inParamList->AppendL( item );

    iInterface->ExecuteCmdL( KExecuteAction,  *inParamList, *outParamList );

    CleanupStack::PopAndDestroy( filter );

    CleanupStack::PopAndDestroy( triggerName );

    item.Reset();

    inParamList->Reset();

    outParamList->Reset();  

    }

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

// CWrtData::IsPluginActive

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

//

TBool CWrtData::IsPluginActive()

    {

    return iPlugin->IsActive();

    }

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

// CWrtData::ActivateL

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

//

void CWrtData::ActivateL()

    {

    ChangePublisherStatusL( KActive );

    }

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

// CWrtData::ResumeL

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

//

void CWrtData::ResumeL()

    {

    ChangePublisherStatusL( KResume );

    }

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

// CWrtData::SuspendL

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

//

void CWrtData::SuspendL()

    {

    ChangePublisherStatusL( KSuspend );

    }

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

// CWrtData::DeActivateL

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

//

void CWrtData::DeActivateL()

    {

    ChangePublisherStatusL( KDeActive );

    }

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

// CWrtData::InActiveL

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

//

void CWrtData::InActiveL()

    {

    ChangePublisherStatusL( KInActive );

    }

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

// CWrtData::OnLineL

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

//

void CWrtData::OnLineL()

    {