*

#include <aknViewAppUi.h>

#include <centralrepository.h>

#include <AknQueryDialog.h>

#include <Calendar.rsg>

#include <calencommonui.rsg>

#include <akntoolbar.h>

#include <calendateutils.h>

#include <calencommandhandler.h>

#include <calencommands.hrh>                // Calendar commands

#include <calentoolbar.h>

#include <akntoolbarextension.h>

#include <calenactionuiutils.h>

#include <featmgr.h>

#include "calendarui_debug.h"

#include "CalenUid.h"

#include "calenviewpopulator.h"

#include "calenglobaldata.h"

#include "CalendarPrivateCRKeys.h"          // includes CalendarInternalCRKeys.h

#include "calenmonthview.h"                 // Native month view

#include "calenweekview.h"                  // Native week view

#include "calendayview.h"                   // Native day view

#include "calentodoview.h"                  // Native todo view

#include "caleneventview.h"                 // Event View

#include "calenmissedalarmsview.h"			// Missed alarms view

#include "calenmissedeventview.h"			// Missed event view

#include "calensetting.h"                   // CCalenSetting::TViewType

#include "calencmdlinelauncher.h"           // Command line launcher

#include "CleanupResetAndDestroy.h"

#include "calentoolbarimpl.h"

#include "calencustomisationmanager.h"

#include "calenviewinfo.h"

#include "calentitlepane.h"

#include "calenicons.h"

#include "calendummyview.h"

const TInt KArrayGranularity = 5;

// CCalenViewManager::NewL

// 1st phase of construction

CCalenViewManager* CCalenViewManager::NewL( CAknViewAppUi& aAppUi,

                                            CCalenController& aController )

    {

    TRACE_ENTRY_POINT;

    CCalenViewManager* self = new( ELeave ) CCalenViewManager( aAppUi,aController );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

// CCalenViewManager::CCalenViewManager

// C++ default Constructor.

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

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

//

CCalenViewManager::CCalenViewManager( CAknViewAppUi& aAppUi, 

                                      CCalenController& aController )

    : iAppUi( aAppUi ), iController( aController )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenViewManager::~CCalenViewManager

CCalenViewManager::~CCalenViewManager()

    {

    TRACE_ENTRY_POINT;

    delete iPopulator;

    if(iToolbar)

        {

        delete iToolbar;

        iToolbar = NULL;

        }

    if( iSetting )

        {

        iSetting->Release();

        }

    if( iGlobalData )

        {

        iGlobalData->Release();

        }

    iViewInfoArray.ResetAndDestroy();

    iKnownPlugins.Reset();

    delete iRemovedActiveView;

    delete iViewRemovalCallback;

    delete iIcons;

    TRACE_EXIT_POINT;

    }

// CCalenViewManager::ConstructL

// 2nd phase of construction.

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

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

//

void CCalenViewManager::ConstructL()

    {

    TRACE_ENTRY_POINT;

    iGlobalData = CCalenGlobalData::InstanceL();

    iPopulator = CCalenViewPopulator::NewL( iController );

    // Only create a toolbar impl if touch is enabled and a CAknToolbar exists

    if( AknLayoutUtils::PenEnabled() )

        {

        CAknAppUi* appUi = static_cast<CAknAppUi*>( CEikonEnv::Static()->EikAppUi() );

        if (appUi->CurrentFixedToolbar())

            {

            if ( FeatureManager::FeatureSupported( KFeatureIdFfCalDayView  ) )

                {

                appUi->CurrentFixedToolbar()->SetToolbarVisibility( EFalse );

                }

            else

                {

                iToolbar = CCalenToolbarImpl::NewL( iController );

                }

            }

        }

    iSetting = CCalenSetting::InstanceL();

    iPreviousViewId.iViewUid = KNullUid;

    iAvoidRepopulation = EFalse;

    iStartupComplete = ETrue;

    iFakeExit = EFalse;

    TRACE_EXIT_POINT;

    }

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

// CCalenViewManager::SetCustomisationManagerL

// Creates custom views.

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

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

//

void CCalenViewManager::ConstructCustomViewsL(

                             CCalenCustomisationManager& aCustomisationManager )

    {

    TRACE_ENTRY_POINT;

    iCustomisationManager = &aCustomisationManager;

    ConstructCustomViewsL();

    ConstructNativeViewsL();

    TUid defViewUid = iSetting->DefaultView();

    ActivateDefaultViewL( defViewUid );

    // Register for view activation events

    iAppUi.AddViewActivationObserverL( this );

    TRACE_EXIT_POINT;

    }

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

// CCalenViewManager::ViewInfoArray

// Get info array

RPointerArray<CCalenViewInfo>& CCalenViewManager::ViewInfoArray()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return iViewInfoArray;

    }

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

// CCalenViewManager::CustomiszationManager

// Return reference to the customisation manager

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

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

//

CCalenCustomisationManager& CCalenViewManager::CustomisationManager()

    {

    TRACE_ENTRY_POINT;

    ASSERT( iCustomisationManager );

    TRACE_EXIT_POINT;

    return *iCustomisationManager;

    }

// CCalenViewManager::ConstructNativeViewsL

// Constructs the S60 native views and registers them with the view server

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

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

//

void CCalenViewManager::ConstructNativeViewsL()

    {

    TRACE_ENTRY_POINT;

    CCalenTitlePane::NewAndSwapL(iAppUi.StatusPane());

    MCalenServices& services = iController.Services();

    // Add the native views for the todo view, week view, day view , month

    // view and event view unless they are already provided by custom views 

    // in ROM.This is enforced by the customisation manager rejecting any 

    // views that try to replace the native views but are not in ROM.

    if (CreateNativeViewL(KUidCalenMonthView))

        {

        // Views take ownership of services object instantly. 

        // No need for cleanup stack.

        CCalenMonthView* monthView = CCalenMonthView::NewL(services);

        AddNativeViewL(monthView); // takes ownership immediately.

        }

    if (CreateNativeViewL(KUidCalenWeekView))

        {

        // Views take ownership of services object instantly. 

        // No need for cleanup stack.

        CCalenWeekView* weekView = CCalenWeekView::NewL(services);

        AddNativeViewL(weekView); // takes ownership immediately.

        }

    if (CreateNativeViewL(KUidCalenDayView))

        {  

        // Views take ownership of services object instantly. 

        // No need for cleanup stack.

        CCalenDayView* dayView = CCalenDayView::NewL(services);

        AddNativeViewL(dayView); // takes ownership immediately.

        }

    if (CreateNativeViewL(KUidCalenTodoView))

        {

        // Views take ownership of services object instantly. 

        // No need for cleanup stack.

        CCalenTodoView* todoView = CCalenTodoView::NewL(services);

        AddNativeViewL(todoView); // takes ownership immediately.

        }

	if( CreateNativeViewL(KUidCalenEventView))

		{

        // Views take ownership of services object instantly. 

		// No need for cleanup stack.

        CCalenEventView* eventView = CCalenEventView::NewL(services);

        AddNativeViewL(eventView); // takes ownership immediately.

		}

	if( CreateNativeViewL(KUidCalenMissedAlarmsView))

		{

        // Views take ownership of services object instantly. 

		// No need for cleanup stack.

        CCalenMissedAlarmsView* missedAlarmsView = CCalenMissedAlarmsView::NewL(services);

        AddNativeViewL(missedAlarmsView); // takes ownership immediately.

		}

	if( CreateNativeViewL(KUidCalenMissedEventView))

		{

        // Views take ownership of services object instantly. 

		// No need for cleanup stack.

        CCalenMissedEventView* missedEventView = CCalenMissedEventView::NewL(services);

        AddNativeViewL(missedEventView); // takes ownership immediately.

		}

	if(CreateNativeViewL(KUidCalenDummyView))

	    {

	    CCalenDummyView* dummyView = CCalenDummyView::NewL(services);

	    AddNativeViewL(dummyView);

	    }

    TRACE_EXIT_POINT;

    }

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

// CCalenViewManager::CreateNativeViewL

// Checks to see if the native view needs to created.

TBool CCalenViewManager::CreateNativeViewL(TUid aViewUid)

    {

    TRACE_ENTRY_POINT;

    TBool createNativeView = ETrue;

    TBool (*compareFn)(const TUid*, const CCalenViewInfo&) 

                                         = CCalenViewInfo::ViewInfoIdentifier;

    TInt position = iViewInfoArray.Find( aViewUid, compareFn );

    if ( position != KErrNotFound )

        {

        // A plugin is trying to replace a native view, find if it is rom

        // based or not

        TBool romBased = CustomisationManager().IsViewRomBased( aViewUid );

        if ( romBased )

            {

            createNativeView = EFalse;

            }

        else

            {

            // A non-rom plugin cannot replace the native views, so the view is

            // removed

            iAppUi.RemoveView( aViewUid );

            // Remove the entry from the view info array

            iViewInfoArray.Remove( position );

            createNativeView = ETrue;

            }

        }

    TRACE_EXIT_POINT;

    return createNativeView;

    }

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

// CCalenViewManager::ConstructCustomViewsL

// Constructs any custom views from all the plugins and registers them 

// with the view server

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

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

//

void CCalenViewManager::ConstructCustomViewsL()

    {

    TRACE_ENTRY_POINT;

    // Get the array of active plugins

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

    // For every active plugin, discover if it offers any customised views

    // and adds them to the view server.

    TInt numPlugins = plugins.Count();

    for( TInt pluginIndex( 0 ); pluginIndex < numPlugins; ++pluginIndex )

        {

        TUid pluginUid = plugins[pluginIndex];

        ConstructCustomViewL( pluginUid );

        }

    TRACE_EXIT_POINT;

    }

// CCalenViewManager::ConstructCustomViewsL

// Constructs the custom views from a particular plugin and registers them

//  with the view server

void CCalenViewManager::ConstructCustomViewL( TUid aPluginUid )

    {

    TRACE_ENTRY_POINT;

    iKnownPlugins.AppendL( aPluginUid );

    RPointerArray<CCalenView> customViews;

    CleanupResetAndDestroyPushL( customViews );

    TRAP_IGNORE(CustomisationManager().GetCustomViewsL( aPluginUid, customViews ));

    for( TInt viewIndex( customViews.Count()-1 ); viewIndex >= 0; --viewIndex )

        {

        CCalenView* customView = customViews[viewIndex];

        iAppUi.AddViewL( customView );

        customViews.Remove( viewIndex );

        }

    CleanupStack::PopAndDestroy(); // customViews

    TRACE_EXIT_POINT;

    }    

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

// CCalenViewManager::ActivateDefaultViewL

// Activates the default view (retrieved from settings).

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

//

void CCalenViewManager::ActivateDefaultViewL( TUid aDefaultView )

    {

    TRACE_ENTRY_POINT;

    // Find the default view in the view cycle list

    TInt position = iViewInfoArray.Find(

                            aDefaultView, CCalenViewInfo::ViewInfoIdentifier );

    if( position != KErrNotFound )

        {

        iAppUi.SetDefaultViewL( *iAppUi.View( aDefaultView ) );

        iViewCycleIndex = position;

        }

	else

	    {

	    CRepository* repository = CRepository::NewL( KCRUidCalendar );

	    CleanupStack::PushL(repository);

	    TInt tmp( static_cast<TInt>( KUidCalenMonthView.iUid ) );

	    TInt position = iViewInfoArray.Find( KUidCalenMonthView, CCalenViewInfo::ViewInfoIdentifier );

	    User::LeaveIfError( repository->Set( KCalendarDefaultStartView, tmp ) );

	    iAppUi.SetDefaultViewL( *iAppUi.View( KUidCalenMonthView ) );

	    iViewCycleIndex = position;

	    CleanupStack::PopAndDestroy(repository);  

	    }

    TRACE_EXIT_POINT;

    }

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

// CCalenViewManager::InterruptPopulationL

// Interrupts the population of the current view. When the editors are launched

// the view population is interrupted as it will be repopulated when the

// the editor closes.

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

//

void CCalenViewManager::InterruptPopulationL()

    {

    TRACE_ENTRY_POINT;

    // Cancel population of current view, if it's ongoing.

    iPopulator->InterruptPopulationL();

    TRACE_EXIT_POINT;

    }

// CCalenViewManager::RemoveCurrentViewFromMenu

// Removes the current view from the cascading view switch menu

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

//

void CCalenViewManager::RemoveCurrentViewFromMenu( CEikMenuPane* aMenuPane )

    {

    TRACE_ENTRY_POINT;

    TUid uid = CurrentView();

    if( uid == KUidCalenMonthView )

        {

        aMenuPane->DeleteMenuItem( ECalenMonthView );

    else if( uid == KUidCalenWeekView )

        {

        aMenuPane->DeleteMenuItem( ECalenWeekView );

        }

    else if( uid == KUidCalenDayView )

        {

        aMenuPane->DeleteMenuItem( ECalenDayView );

    else if( uid == KUidCalenTodoView )

        {

        aMenuPane->DeleteMenuItem( ECalenTodoView );

        }

    else

        {

        // Assert as this point should never be reached

        ASSERT( 0 );

        }

    TRACE_EXIT_POINT;

// CCalenViewManager::AddNativeViewL

// Adds a view to the array.

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

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

//

void CCalenViewManager::AddNativeViewL( CCalenView* aView )

    {

    TRACE_ENTRY_POINT;

    CleanupStack::PushL( aView );