/*

* 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:   Calendar settings container

*

*/

//debug

#include "calendarui_debug.h"

// INCLUDES

#include "calensettingsuicontainer.h"

#include "CalenFileListSettingItem.h"

#include "calenglobaldata.h"

#include "CalenInterimUtils2.h"

#include "CalenSliderSettingItem.h"

#include "CalenUid.h"

#include "RImplInfoPtrArrayOwn.inl"

#include "CleanupResetAndDestroy.h"

#include "calencheckboxsettingitem.h"

#include "calennestedsettingitem.h"

#include "calenbooleansettingitem.h"

#include "calenviewinfo.h"

#include <Calendar.rsg>

#include <csxhelp/cale.hlp.hrh>

#include "calencustomisationmanager.h"

//#include <CalenUiPluginInterface.h>

#include <utf.h>

#include <aknlists.h>               // for CAknSettingStyleListBox

#include <eikclbd.h>                // CColumnListBoxData

#include <StringLoader.h>

#include <bacntf.h>                 // CEnvironmentChangeNotifier

#include <centralrepository.h>      // CRepository

#include <CalendarInternalCRKeys.h> // KCRUidCalendar

#ifdef RD_CALEN_EXTERNAL_CAL

#include <aiwservicehandler.h>

// MIME types

_LIT8(KContentTypeCalendar, "text/calendar");

#endif //RD_CALEN_EXTERNAL_CAL

#include <AknUtils.h>

const TInt KDisablePluginEnablement = 2;

void ListMailboxesL( 

		CMRMailboxUtils& aMbUtils,

		RArray<CMRMailboxUtils::TMailboxInfo>& aMailBoxes )

	{

	aMbUtils.ListMailBoxesL( aMailBoxes );

    // Get MR Viewer implementations

	RImplInfoPtrArrayOwn implArray;

    CleanupClosePushL( implArray );

    const TUid mrViewersIface = {KMRViewersInterfaceUID};

    REComSession::ListImplementationsL( mrViewersIface, implArray );

    TBuf16<KMaxUidName> mbName;

    TInt index(0);

    while (index < aMailBoxes.Count() )

    	{

    	TBool matchingMRViewerFound( EFalse );

    	TInt mrviewerImplCount( implArray.Count() );

        for( TInt j=0; j < mrviewerImplCount && !matchingMRViewerFound; ++j )

            {

            CnvUtfConverter::ConvertToUnicodeFromUtf8( mbName, implArray[j]->DataType() );

            if( aMailBoxes[index].iMtmUid.Name().CompareF(mbName) == 0 )

                {

                // Found a match. This mailbox would have been shown in the settings list.

                matchingMRViewerFound = ETrue;

                }

            }

        if ( !matchingMRViewerFound )

        	{

        	aMailBoxes.Remove( index );        	

        	}

        else

        	{

        	++index;

        	}

    	}

    CleanupStack::PopAndDestroy(); // implArray

	}

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

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

// CCalenSettingsUiContainer::NewL

// Symbian two-phased constructor.

// Two-phased constructor. Does NOT take ownership of aParentControl or aListBox.

// (other items were commented in a header).

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

//

EXPORT_C CCalenSettingsUiContainer* CCalenSettingsUiContainer::NewL(

                                                CCoeControl* aParentControl,

                                                CAknSettingStyleListBox& aListBox,

                                                CCalenGlobalData& aGlobalData,

                                                CCalenCustomisationManager& aCustomisationManager )

    {

    TRACE_ENTRY_POINT;

    CCalenSettingsUiContainer* self = new(ELeave) CCalenSettingsUiContainer( aParentControl,

                                                                             aListBox,

                                                                             aGlobalData,

                                                                             aCustomisationManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenSettingsUiContainer::ConstructL

// Symbian OS default constructor

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

//

void CCalenSettingsUiContainer::ConstructL()

    {

    TRACE_ENTRY_POINT;

    iSetting = CCalenSetting::InstanceL();

    // Initialize TLocale watcher

    TCallBack callback( LocaleCallbackL, this );

    iLocaleChangeNotifier =

        CEnvironmentChangeNotifier::NewL( EActivePriorityLogonA, callback );

    // Initialize Central Repository watcher

    iRepository = CRepository::NewL( KCRUidCalendar );

    iCenRepNotifyHandler = CCenRepNotifyHandler::NewL( *this, *iRepository );

    iSettingItemArray = new( ELeave )CAknSettingItemArray( 2, 0, 0 );

    if( iGlobalData.InterimUtilsL().MRViewersEnabledL() )

        {

        LoadMailboxSettingsL();

        }

    iLocaleChangeNotifier->Start();

    iCenRepNotifyHandler->StartListeningL();

    iPageStatus = EFalse;

    TRACE_EXIT_POINT;

    }

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

// CCalenSettingsUiContainer::~CCalenSettingsUiContainer

// Destructor

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

//

CCalenSettingsUiContainer::~CCalenSettingsUiContainer()

    {

    TRACE_ENTRY_POINT;

    delete iLocaleChangeNotifier;

    if( iCenRepNotifyHandler )

        {

        iCenRepNotifyHandler->StopListening();

        delete iCenRepNotifyHandler;

        }

    delete iRepository;

    iMailBoxes.Close();

    if( iSettingItemArray )

        {

        iSettingItemArray->ResetAndDestroy();

        delete iSettingItemArray;

        }

    if ( iSetting )

        {

        iSetting->Release();

        }

#ifdef RD_CALEN_EXTERNAL_CAL

    delete iServiceHandler;

#endif //RD_CALEN_EXTERNAL_CAL

    TRACE_EXIT_POINT;

    }

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

// CCalenSettingsUiContainer::CCalenSettingsUiContainer

// Default constructor

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

//

CCalenSettingsUiContainer::CCalenSettingsUiContainer( CCoeControl* aParentControl,

                                                      CAknSettingStyleListBox& aListBox,

                                                      CCalenGlobalData& aGlobalData,

                                                      CCalenCustomisationManager& aCustomisationManager )

    : iGlobalData( aGlobalData ),

      iParentControl( aParentControl ),

      iListBox( aListBox ),

      iCustomisationManager( aCustomisationManager ),

      iIgnoreNextSettingsNotification( EFalse ),

      iIgnoreFirstLocaleChange( ETrue )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenSettingsUiContainer::AddCustomSettingsWithLinkL

// Adds all settings from customisations. This will get a link from the front

// settings page. Removes items from the array when ownership transferred

// away from the array.

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

//

void CCalenSettingsUiContainer::AddCustomSettingsWithLinkL( RPointerArray<CAknSettingItem>& aSettings,

                                                            const TDesC& aName,

                                                            TInt aOrdinal )

    {

    TRACE_ENTRY_POINT;

    // CCalenNestedSettingItem will take items out of aSettings array and

    // take ownership of removed items.

    CCalenNestedSettingItem* item = new( ELeave )CCalenNestedSettingItem( 0,

                                                                          aSettings,

                                                                          aName );

    CleanupStack::PushL( item );

    // The followng text should never actually be displayed on screen

    item->SetEmptyItemTextL( KNullDesC );

    // Construct setting item with parametrized values

    item->ConstructL( EFalse, aOrdinal, aName, NULL,

                      R_CALEN_EMPTY_SETTING_PAGE, EAknSetListBox,

                      NULL, R_CALEN_EMPTY_POPUP_SETTING_TEXTS );

    iSettingItemArray->InsertL( aOrdinal, item );

    CleanupStack::Pop( item );

    TRACE_EXIT_POINT;

    }

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

// CCalenSettingsUiContainer::AddSingleCustomSettingL

// Adds a setting from customisations. This will go directly into the front

// settings page. Takes ownership of aSetting when the function completes.

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

//

void CCalenSettingsUiContainer::AddSingleCustomSettingL( CAknSettingItem* aSetting,

                                                         TInt aOrdinal )

    {

    TRACE_ENTRY_POINT;

    iSettingItemArray->InsertL( aOrdinal, aSetting ); // Takes ownership of aSetting.

    TRACE_EXIT_POINT;

    }

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

// CCalenSettingsUiContainer::AddCustomSettingsItemsL

// Adds all settings from customisations.

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

//

void CCalenSettingsUiContainer::AddCustomSettingsItemsL( TInt& aOrdinal )

    {

    TRACE_ENTRY_POINT;

    const RArray<TUid>& plugins = iCustomisationManager.ActivePlugins();

    RPointerArray<CAknSettingItem> settings;

    CleanupResetAndDestroyPushL( settings );

    for ( TInt i( 0 ); i<plugins.Count(); ++i )

        {

        iCustomisationManager.GetPluginSettingsL( plugins[i],

                                                  settings );

        // We have ownership of settings items now.

        // If there is more than one setting per plugin, it gets a link in the main

        // setting page. If there is only one, it goes directly into the main page.

        if ( settings.Count() > 1 )

            {

            const RImplInfoPtrArray& pluginInfo = iCustomisationManager.PluginInfoArray();

            TInt pluginIndex = KErrNotFound;

            for ( TInt j( 0 ); j<pluginInfo.Count(); ++j )

                {

                if ( pluginInfo[j]->ImplementationUid() == plugins[i] )

                    {

                    pluginIndex = j;

                    break;

                    }

                }

            ASSERT( pluginIndex != KErrNotFound );

            const TDesC& pluginName = pluginInfo[pluginIndex]->DisplayName();

            AddCustomSettingsWithLinkL( settings, pluginName, aOrdinal++ );

            }

        else if ( settings.Count() == 1 )

            {

            // This function takes ownership of the setting item we pass it,

            // when the function completes.

            AddSingleCustomSettingL( settings[0], aOrdinal++ );

            settings.Remove( 0 );

            }

        ASSERT( settings.Count() == 0 );

        }

    CleanupStack::PopAndDestroy( &settings );

    TRACE_EXIT_POINT;

    }

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

// CCalenSettingsUiContainer::AddPluginSettingItemL

// Adds a settings item allowing the user to enable/disable plugins and

// change their priority.

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

//

void CCalenSettingsUiContainer::AddPluginSettingItemL( TInt& aOrdinal )

    {

    TRACE_ENTRY_POINT;

    const RImplInfoPtrArray& plugins = iCustomisationManager.PluginInfoArray();

    TInt pluginCount = plugins.Count();

    if ( pluginCount > 0 )

        {

        // Check to see if any of the plugins are able to be be enable or 

        // disabled

        TBool pluginFound( EFalse );

        TBuf<100> displayName;

        for ( TInt index(0); index < pluginCount && !pluginFound; ++index )

            {

            // if the display name is empty and the plugin is in ROM the

            // plugin can  not be disabled

            TInt version = plugins[index]->Version();

            TBool romBased = plugins[index]->RomBased();

            displayName = plugins[index]->DisplayName();

            if ( ( version != KDisablePluginEnablement ) || !romBased )

                {

                pluginFound = ETrue;

                }

            } 

        if ( pluginFound )

            {

            //There will not be any sort of settings item for plugins which are not part of settings 

            TInt countOfAvailability =  iSetting->PluginAvailability().Count();

            if(countOfAvailability)

                {

                //If available plugins(which has settings) count is > 1 its check box or toggle button.  

                if(countOfAvailability > 1 )

                    {

                    CCalenCheckboxSettingItem* settingItem

                        = new( ELeave )CCalenCheckboxSettingItem( ECalenPluginListItemId,

                                                                  iCustomisationManager );

                    CleanupStack::PushL( settingItem );

                    // The followng text should never actually be displayed on screen

                    settingItem->SetEmptyItemTextL( KNullDesC );

                    // Construct setting item with parametrized values

                    HBufC* itemTitle = StringLoader::LoadLC( R_CALEN_SETTING_PLUGINLIST_TITLE );

                    settingItem->ConstructL( EFalse, aOrdinal, *itemTitle, NULL,

                                             R_CALEN_SETTING_PLUGINLIST, EAknSetListBox,

                                             NULL, R_CALEN_EMPTY_POPUP_SETTING_TEXTS );

                    iSettingItemArray->InsertL( aOrdinal, settingItem );

                    CleanupStack::PopAndDestroy( itemTitle );

                    CleanupStack::Pop( settingItem );

                    aOrdinal++;

                    }

                else

                    {

                    CCalenBooleanSettingItem* settingItem =

                            CCalenBooleanSettingItem::NewLC(ECalenPluginListItemId,aOrdinal,iCustomisationManager);

                    iSettingItemArray->InsertL( aOrdinal, settingItem );

                    CleanupStack::Pop( settingItem );

                    aOrdinal++;

                    }

                }

            }

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenSettingsUiContainer::AddDefaultViewItemL

// Adds a setting item to allow selection of the default view. Includes custom

// views in the view cycle array.

// (other items were commented in a header).

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

//

void CCalenSettingsUiContainer::AddDefaultViewItemL( TInt& aBuffer,

                                                     TInt aId,

                                                     TInt aTitleResource,

                                                     TInt aSettingPageResource,

                                                     TInt aOrdinal )

    {

    TRACE_ENTRY_POINT;

    // Create new setting item

    CAknEnumeratedTextPopupSettingItem* settingItem =

        new( ELeave )CAknEnumeratedTextPopupSettingItem( aId, aBuffer );

    CleanupStack::PushL( settingItem );

    // The followng text should never actually be displayed on screen

    _LIT( KNone, "None" );

    settingItem->SetEmptyItemTextL( KNone );

    // Construct setting item with parametrized values

    HBufC* itemTitle = StringLoader::LoadLC( aTitleResource );

    settingItem->ConstructL( EFalse, aOrdinal, *itemTitle, NULL,

                             aSettingPageResource, EAknCtPopupSettingList,

                             NULL, R_CALEN_EMPTY_POPUP_SETTING_TEXTS );

    CArrayPtr<CAknEnumeratedText>* items = settingItem->EnumeratedTextArray();

    const RPointerArray<CCalenViewInfo>& views = iCustomisationManager.Views();

    const RArray<TUid>& activePlugins = iCustomisationManager.ActivePlugins();

    TBool isDefViewValid( EFalse );

    TInt numViews = views.Count();

    for ( TInt i( 0 ); i<numViews; ++i )

        {

        CCalenViewInfo* view = views[i];

        TUid pluginUid = view->PluginUid();

	    TInt position = activePlugins.Find( pluginUid );

		// If the view is from plugin or native view with cycle position,

        // then add it to the default view list

        if((position != KErrNotFound) ||

        	( view->CyclePosition() != CCalenView::ENoCyclePosition ))

            {

            TInt viewUidInt = view->ViewUid().iUid;

            if ( viewUidInt == iDefView )

                {

                isDefViewValid = ETrue;

                }

            CAknEnumeratedText* item = new( ELeave )CAknEnumeratedText( viewUidInt,

                                                                        view->SettingsName().AllocL() );

            items->AppendL( item );

            }

        }

    if ( !isDefViewValid )

        {

        // Default view is no longer valid (could be first ever load, or could be

        // a 3rd party plugin's view used to be the default but is not removed).

        // Set default to the first in the view cycle array. 

        TInt defViewIndex( 0 );

        while ( views[defViewIndex]->CyclePosition() == CCalenView::ENoCyclePosition )

            {

            defViewIndex++;

            }

        iDefView = views[defViewIndex]->ViewUid().iUid;

        iSetting->SetDefaultView( TUid::Uid( iDefView ) );

        }

    settingItem->HandleTextArrayUpdateL();

    // Append item to settingitem-array

    iSettingItemArray->InsertL( aOrdinal, settingItem );

    CleanupStack::PopAndDestroy( itemTitle );

    CleanupStack::Pop( settingItem );

    TRACE_EXIT_POINT;

    }

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

// CCalenSettingsUiContainer::AddSnoozeTimeItemL

// Adds an alarm snooze time item

// (other items were commented in a header).

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

//

void CCalenSettingsUiContainer::AddSnoozeTimeItemL( TInt aOrdinal,

                                                    CArrayPtr<CGulIcon>* aIconArray,

                                                    TInt& aSnoozeTime)

    {

    TRACE_ENTRY_POINT;

    CCalenSliderSettingItem* settingItem =

                new( ELeave )CCalenSliderSettingItem( ECalenSnoozeTimeItemId,

                                                      aSnoozeTime,

                                                      R_SNOOZE_TIME_SLIDER );

    CleanupStack::PushL( settingItem );

    HBufC* itemTitle = StringLoader::LoadLC( R_QTN_CALE_SET_SNOOZE_TIME );

    settingItem->ConstructL( EFalse,

                             aOrdinal,

                             *itemTitle,

                             aIconArray,