FCL/sf/app/organizer: comparison calendarui/controller/src/calenviewmanager.cpp

equal deleted inserted replaced

-:5aadd1120515
+:b57382753122
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description:  Calendar view manager
 *
 */
-//system includes
+#include <aknViewAppUi.h>
-#include <hbmainwindow.h>
+#include <centralrepository.h>
-#include <hbinstance.h>
+#include <AknQueryDialog.h>
-#include <hbapplication.h> // hbapplication
+#include <Calendar.rsg>
-#include <xqserviceutil.h> // service utils
+#include <calencommonui.rsg>
-#include <afactivation.h>
+#include <akntoolbar.h>
-#include <AfActivityStorage.h>
+#include <calendateutils.h>
-//user includes
+#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 "calenviewmanager.h"
+#include "CalenUid.h"
 #include "calencontroller.h"
-#include "hb_calencommands.hrh"
+#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 "calenservicesimpl.h"
-#include "calenmonthview.h"
+#include "CleanupResetAndDestroy.h"
-#include "calenagendaview.h"
+#include "calentoolbarimpl.h"
-#include "calenmonthview.h"
+#include "calencustomisationmanager.h"
-#include "agendaeventviewer.h"
+#include "calenviewinfo.h"
-#include "calennotificationhandler.h"
+#include "calentitlepane.h"
-#include "CalenUid.h"
+#include "calenicons.h"
-#include "calenactionuiutils.h"
+#include "calendummyview.h"
-#include "calensettingsview.h"
-#include "calendocloader.h"
+const TInt KArrayGranularity = 5;
-#include "calendarui_debug.h"
-#include "calencommon.h"
+// ----------------------------------------------------------------------------
-#include "calendayview.h"
+// CCalenViewManager::NewL
-#include <agendautil.h>
+// 1st phase of construction
-#include "OstTraceDefinitions.h"
+// (other items were commented in a header).
-#ifdef OST_TRACE_COMPILER_IN_USE
+// ----------------------------------------------------------------------------
-#include "calenviewmanagerTraces.h"
+//
-#endif
+CCalenViewManager* CCalenViewManager::NewL( CAknViewAppUi& aAppUi,
+CCalenController& aController )
-// ----------------------------------------------------------------------------
+{
-// CalenViewManager::CalenViewManager
+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
+// Destructor.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+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).
 // ----------------------------------------------------------------------------
 //
-CalenViewManager::CalenViewManager( CCalenController& aController)
+void CCalenViewManager::ConstructL()
-: mController(aController)
+{
-{
+TRACE_ENTRY_POINT;
-	OstTraceFunctionEntry0( CALENVIEWMANAGER_CALENVIEWMANAGER_ENTRY );
+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
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+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.
+}
-	// Following block intializes member variables
+	if( CreateNativeViewL(KUidCalenEventView))
-	mCalenEventViewer = NULL;
+		{
-	mMonthViewDocLoader = NULL;
+// Views take ownership of services object instantly.
-	mAgendaViewDocLoader = NULL;
+		// No need for cleanup stack.
-	mAgendaViewAltDocLoader = NULL;
+CCalenEventView* eventView = CCalenEventView::NewL(services);
-	mCalenAgendaView = NULL;
+AddNativeViewL(eventView); // takes ownership immediately.
-	mCalenMonthView = NULL;
+		}
-	mCalenAgendaViewAlt = NULL;
-	mSettingsView = NULL;
+	if( CreateNativeViewL(KUidCalenMissedAlarmsView))
-	mCalenDayView = NULL;
+		{
-	mInstanceViewCreated = false;
+// 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.
+		}
-	// Connect to instance view and entry view creation signals from agenda
+	if(CreateNativeViewL(KUidCalenDummyView))
-	// interface
+	    {
-	connect(mController.agendaInterface(), SIGNAL(instanceViewCreationCompleted(int)),
+	    CCalenDummyView* dummyView = CCalenDummyView::NewL(services);
-	        this, SLOT(handleInstanceViewCreation(int)));
+	    AddNativeViewL(dummyView);
-	connect(mController.agendaInterface(), SIGNAL(entryViewCreationCompleted(int)),
+	    }
-		        this, SLOT(handleEntryViewCreation(int)));
+TRACE_EXIT_POINT;
-	connect(mController.agendaInterface(), SIGNAL(entriesChanged(QList<ulong>)),
+}
-								this, SLOT(handleEntriesChanged(QList<ulong>)));
-connect(mController.agendaInterface(), SIGNAL(entryUpdated(ulong)),
+// ----------------------------------------------------------------------------
-this, SLOT(handleEntryUpdation(ulong)));
+// CCalenViewManager::CreateNativeViewL
-connect(mController.agendaInterface(), SIGNAL(entryAdded(ulong)),
+// Checks to see if the native view needs to created.
-this, SLOT(handleEntryUpdation(ulong)));
+// (other items were commented in a header).
-	OstTraceFunctionExit0( CALENVIEWMANAGER_CALENVIEWMANAGER_EXIT );
+// ----------------------------------------------------------------------------
-}
+//
+TBool CCalenViewManager::CreateNativeViewL(TUid aViewUid)
-void CalenViewManager::SecondPhaseConstruction()
+{
-{
+TRACE_ENTRY_POINT;
-OstTraceFunctionEntry0( CALENVIEWMANAGER_SECONDPHASECONSTRUCTION_ENTRY );
+TBool createNativeView = ETrue;
-// Check if calendar is launched thru XQService framework
+TBool (*compareFn)(const TUid*, const CCalenViewInfo&)
-bool isFromServiceFrmWrk = XQServiceUtil::isService(); // Since activateReason
+= CCalenViewInfo::ViewInfoIdentifier;
-//of hbapplication is not returning right value if the activity is started
-//as services so using the above line temporarily untill a fix is available in
+TInt position = iViewInfoArray.Find( aViewUid, compareFn );
-// hbappliac
+if ( position != KErrNotFound )
-AfActivation *activation = new AfActivation();
+{
-if(Af::ActivationReasonActivity == activation->reason())
+// A plugin is trying to replace a native view, find if it is rom
-// as an activity
+// based or not
-{
+TBool romBased = CustomisationManager().IsViewRomBased( aViewUid );
-// Application is started from an activity
+if ( romBased )
-// Extract activity data
+{
-AfActivityStorage *activitystorage = new AfActivityStorage();
+createNativeView = EFalse;
-QVariant data = activitystorage->activityData(activation->name());
+}
-delete activitystorage;
+else
+{
-// Restore state from activity data
+// A non-rom plugin cannot replace the native views, so the view is
-QByteArray serializedModel = data.toByteArray();
+// removed
-QDataStream stream(&serializedModel, QIODevice::ReadOnly);
+iAppUi.RemoveView( aViewUid );
-int viewId; // int declared for debugging purpose
-stream >> viewId; // read stream into an int
+// Remove the entry from the view info array
+iViewInfoArray.Remove( position );
+createNativeView = ETrue;
+}
+}
-mFirstView = viewId;
+TRACE_EXIT_POINT;
-if (ECalenMonthView == viewId) // Check if Activity was stored for month view
+return createNativeView;
-{
+}
-loadMonthView(); // Load month view
-}
+// ----------------------------------------------------------------------------
-else if (ECalenAgendaView == viewId) // Check if Activity was stored for agenda view
+// CCalenViewManager::ConstructCustomViewsL
-{
+// Constructs any custom views from all the plugins and registers them
-	loadAgendaView(); // Load agenda view
+// 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
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+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 );
+iAppUi.AddViewL( aView );
+CleanupStack::Pop( aView );
+const TDesC& menuName = aView->LocalisedViewNameL( CCalenView::EMenuName );
+const TDesC& settingsName = aView->LocalisedViewNameL( CCalenView::ESettingsName );
+TUid viewUid = aView->Id();
+CCalenViewInfo* viewInfo = CCalenViewInfo::NewL( aView->Id(),
+KUidCalendar,
+menuName,
+settingsName,
+aView->CyclePosition() );
-ActivateDefaultViewL(viewId);
+// Discover if a native view has been hidden by a plugin.
-// Connect to the view ready signal so that we can construct other views
+TBool hidden = iCustomisationManager->HiddenView( viewUid );
-// once this view is ready
+viewInfo->Hide( hidden );
-connect(&mController.MainWindow(), SIGNAL(viewReady()),
-this, SLOT(handleMainViewReady()));
+// Append to view info array
+iViewInfoArray.InsertInOrderAllowRepeatsL( viewInfo,
-if (ECalenMonthView == viewId) // Check if Activity was stored for month view
+CCalenViewInfo::CyclePositionComparison );
-{
-mController.MainWindow().addView(mCalenMonthView); // Add month view to main window
+TRACE_EXIT_POINT;
-mController.MainWindow().setCurrentView(mCalenMonthView); // Set month view as current view
+}
-}
-else if (ECalenAgendaView == viewId) // Check if Activity was stored for agenda view
+// ----------------------------------------------------------------------------
-{
+// CCalenViewManager::HandleCommandL
-mController.MainWindow().addView(mCalenAgendaView); // Add agenda view to main window
+// Handles view manager commands.
-mController.MainWindow().setCurrentView(mCalenAgendaView); // Set agenda view as current view
+// (other items were commented in a header).
-}
+// ----------------------------------------------------------------------------
-} else if (isFromServiceFrmWrk/*Hb::ActivationReasonService == activityReason*/) {
+//
-// Dont load any views until our remote slot gets called in
+TBool  CCalenViewManager::HandleCommandL( const TCalenCommand& aCommand )
-// calenserviceprovider.cpp
+{
-// Just have an empty mainwindow
+TRACE_ENTRY_POINT;
-} else {
-// Do the normal startup
+TBool commandUsed(EFalse);
-// Load the month view and active it and add it to main window
-mFirstView = ECalenMonthView;
+switch( aCommand.Command() )
-loadMonthView();
+{
-ActivateDefaultViewL(ECalenMonthView);
+case ECalenMonthView:
-// Connect to the view ready signal so that we construct other view
+{
-// once this view is shown
+RequestActivationL( KUidCalenMonthView );
-connect(&mController.MainWindow(), SIGNAL(viewReady()),
+}
-this, SLOT(handleMainViewReady()));
+break;
+case ECalenWeekView:
+{
+RequestActivationL( KUidCalenWeekView );
+}
+break;
+case ECalenDayView:
+{
+// reset the flag iForwardedToDayView as view switching is active
+if(iPreviousToDayView.iViewUid!=KNullUid)
+{
+iPreviousToDayView.iViewUid = KNullUid;
+}
+TUid viewUid;
+if ( !iController.IsLaunchFromExternalApp() && FeatureManager::FeatureSupported( KFeatureIdFfCalDayView ) )
+{
+viewUid = KUidCalenBCDayViewPlugin;
+}
+else
+{
+viewUid = KUidCalenDayView;
+}
+RequestActivationL( viewUid, KCalenDummyUid, KNullDesC8() );
+if(iController.IsLaunchFromExternalApp())
+{
+iAvoidRepopulation = ETrue;
+}
+}
+break;
+case ECalenTodoView:
+{
+if (iAvoidRepopulation)
+{
+iAvoidRepopulation = EFalse;
+}
+RequestActivationL( KUidCalenTodoView );
+}
+break;
+case ECalenEventView:
+{
+// Fix for EJCU-7LKC2C :: to prevent the display of blank view,
+// just set the iAvoidRepopulation to EFalse,
+// so that view is populated properly
+if (iAvoidRepopulation)
+{
+iAvoidRepopulation = EFalse;
+}
+	RequestActivationL( KUidCalenEventView );
+}
+	break;
+case ECalenForwardsToDayView:
+{
+// set the view iPreviousToDayView to handle the day view's cba
+// when returning from event view.
+// From month/week view -> day view -> event view -> day view
+iPreviousToDayView = iCurrentViewId;
+TUid viewUid;
+if ( FeatureManager::FeatureSupported( KFeatureIdFfCalDayView  ) )
+	{
+				viewUid = KUidCalenBCDayViewPlugin;
+	}
+else
+	{
+				viewUid = KUidCalenDayView;
+	}
+			if(iAvoidRepopulation)
+				{
+				iAvoidRepopulation = EFalse;
+				}
+RequestActivationL( viewUid, KUidCalenShowBackCba );
+}
+break;
+case ECalenForwardsToWeekView:
+{
+// set the view iPreviousToWeekView to handle the week view's cba
+// From month view -> week view
+iPreviousToWeekView = iCurrentViewId;
+if(iAvoidRepopulation)
+{
+iAvoidRepopulation = EFalse;
+}
+RequestActivationL( KUidCalenWeekView, KUidCalenShowBackCba );
+}
+break;
+case ECalenNextView:
+{
+CycleNextViewL();
+}
+break;
+case ECalenPrevView:
+{
+CyclePrevViewL();
+}
+break;
+case ECalenSwitchView:
+{
+ShowSwitchViewQueryL();
+}
+break;
+case ECalenStartActiveStep:
+{
+StartActiveStepL();
+}
+break;
+case ECalenFasterAppExit:
+	{
+	HandleFasterAppExitCommandL();
+	}
+break;
+case ECalenGotoToday:
+{
+// get today's date
+TTime today = CalenDateUtils::Today();
+// get the context
+MCalenContext& context = iController.Services().Context();
+TCalTime todayCalTime;
+todayCalTime.SetTimeLocalL( today );
+// set today's date to the context
+context.SetFocusDateAndTimeL( todayCalTime, iCurrentViewId  );
+SetRepopulation(EFalse);
+// reactivate the current view
+//RequestActivationL(iCurrentViewId.iViewUid);
+RequestActivationL(KUidCalenDayView);
+			// dim "today" toolbar item since focus is on today
+//iToolbar->Toolbar().SetItemDimmed( ECalenGotoToday, ETrue, ETrue);
+}
+break;
+case ECalenGotoNextDay:
+{
+ChangeDayL( ETrue );
+// reactivate the current view
+RequestActivationL(iCurrentViewId.iViewUid);
+}
+break;
+case ECalenGotoPrevDay:
+{
+ChangeDayL( EFalse );
+// reactivate the current view
+RequestActivationL(iCurrentViewId.iViewUid);
+}
+break;
+default:
+break;
+}
+TRACE_EXIT_POINT;
+return commandUsed;
+}
+// ----------------------------------------------------------------------------
+// CCalenViewManager::CalenCommandHandlerExtensionL
+// Dummy implementation.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+TAny* CCalenViewManager::CalenCommandHandlerExtensionL( TUid /*aExtensionUid*/ )
+{
+TRACE_ENTRY_POINT;
+TRACE_EXIT_POINT;
+return NULL;
+}
+// ----------------------------------------------------------------------------
+// CCalenViewManager::CurrentView
+// Returns the current view's view uid.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+TUid CCalenViewManager::CurrentView() const
+{
+TRACE_ENTRY_POINT;
+TRACE_EXIT_POINT;
+return iCurrentViewId.iViewUid;
+}
+// ----------------------------------------------------------------------------
+// CCalenViewManager::HandleViewActivation
+// From MCoeViewActivationObserver
+// Called just before a view in this application is activated by the view server
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenViewManager::HandleViewActivation( const TVwsViewId& aNewlyActivatedViewId,
+const TVwsViewId& aViewIdToBeDeactivated )
+{
+TRACE_ENTRY_POINT;
+TBool externalViewSwitch( EFalse );
+// See if this is an internal or external view switch request
+if( aViewIdToBeDeactivated.iAppUid != KUidCalendar )
+{
+externalViewSwitch = ETrue;
+}
+// If this is an internal view switch (view cycling from the '*' key)
+// then ActivateLocalViewL will handle any necessary state changes.
+// If this is an external view switch then we need to find out if Calendar was already
+// running or if it is being launched to a specific view by another application
+// calling ActivateViewL with Calendars UID and the UID of one of the standard views.
+// In this case we need to set the current view in the state or we would get the
+// default view (from the settings) activated instead of the requested view.
+if( externalViewSwitch )
+{
+// Check that the view being activated belongs to Calendar.  Although I don't see
+// how this would be called if this was false anyway.
+if( aNewlyActivatedViewId.iAppUid == KUidCalendar )
+{
+// Make sure that any when any open dialogs are closed Calendar will not close as well.
+// This could be true if Calendar was originally launched directly to the editor, and
+// so should be closed when the dialog is closed.  If an external view switch request
+// arrives, we want the dialog to close but Calendar to remain open.
+// Otherwise we get a CONE 44 panic.
+//iIsExitOnDlgClose = EFalse;
+if( iFakeExit )
+{
+iCurrentViewId.iViewUid = iSetting->DefaultView();
+}
+else
+{
+iCurrentViewId = aNewlyActivatedViewId;
+}
+}
+}
+iFakeExit = EFalse;
+iViewsActivated = ETrue;
+// check for iAvoidRepopulation to avoid repopulation whenever
+// 1) Application comes to foreground
+// 2) Applictaion is opened after fake exit
+if(!iAvoidRepopulation || iController.IsLaunchFromExternalApp() )
+{
+TRAPD(error,StartActiveStepL());
+if(error!=KErrNone)
+{
+// do avoid warning
+}
+}
+// Reset the flag iAvoidRepopulation
+if (iAvoidRepopulation)
+{
+iAvoidRepopulation = EFalse;
+}
+TRACE_EXIT_POINT;
+}
+// ----------------------------------------------------------------------------
+// CCalenViewManager::RemoveDeActivatedView
+// Asyncronous callback function to remove the current view after it has been
+// disabled.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+TInt CCalenViewManager::RemoveDeActivatedView( TAny* aObject )
+{
+TRACE_ENTRY_POINT;
+CCalenViewManager* thisPtr( static_cast<CCalenViewManager*>( aObject ) );
+TRAP_IGNORE( thisPtr->RemoveDeActivatedViewL() );
+TRACE_EXIT_POINT;
+return 0;
+}
+// ----------------------------------------------------------------------------
+// CCalenViewManager::RemoveDeActivatedViewL.
+// (Leaving version)
+// Asyncronous callback function to remove the current view after it has been
+// disabled.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenViewManager::RemoveDeActivatedViewL()
+{
+TRACE_ENTRY_POINT;
+TUid removedViewUid = iRemovedActiveView->ViewUid();
+TUid removedPluginUid = iRemovedActiveView->PluginUid();
+// The view isn't the current view, so we
+// can remove it directly from the view server
+iAppUi.RemoveView( removedViewUid );
+// Delete the view info
+delete iRemovedActiveView;;
+iRemovedActiveView = NULL;
+// Unload the plugin.
+RArray<TUid> pluginArray;
+CleanupClosePushL( pluginArray );
+pluginArray.AppendL( removedPluginUid );
+iCustomisationManager->UnloadPluginsL( pluginArray );
+CleanupStack::PopAndDestroy(); // pluginArray
+if(!iController.IsFasterAppFlagEnabled())
+{
+// Refresh the current view by simulating a settings close
+iController.BroadcastNotification( ECalenNotifySettingsClosed );
+}
+else
+{
+iController.BroadcastNotification( ECalenNotifyCheckPluginUnloading );
+}
+TRACE_EXIT_POINT;
+}
+// ----------------------------------------------------------------------------
+// CCalenViewManager::CycleNextViewL
+// Requests activation for the next view in the view cycle
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenViewManager::CycleNextViewL()
+{
+TRACE_ENTRY_POINT;
+// Increment until we get to a valid view.
+do{
+++iViewCycleIndex;
+if( iViewCycleIndex >= iViewInfoArray.Count() )
+{
+iViewCycleIndex = 0;
+}
+}
+while( iViewInfoArray[iViewCycleIndex]->CyclePosition() == CCalenView::ENoCyclePosition );
+RequestActivationL( iViewInfoArray[iViewCycleIndex]->ViewUid() );
+TRACE_EXIT_POINT;
+}
+// ----------------------------------------------------------------------------
+// CCalenViewManager::CyclePrevViewL
+// Requests activation for the previous view in the view cycle
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenViewManager::CyclePrevViewL()
+{
+TRACE_ENTRY_POINT;
+// Decrement until we get to a valid view.
+do{
+--iViewCycleIndex;
+if( iViewCycleIndex < 0 )
+{
+iViewCycleIndex = iViewInfoArray.Count()-1;
+}
+}
+while ( iViewInfoArray[iViewCycleIndex]->CyclePosition() == CCalenView::ENoCyclePosition );
+RequestActivationL( iViewInfoArray[iViewCycleIndex]->ViewUid() );
+TRACE_EXIT_POINT;
+}
+// ----------------------------------------------------------------------------
+// CCalenViewManager::RequestActivationL
+// Request activation of a specific view.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenViewManager::RequestActivationL( const TVwsViewId& aViewId )
+{
+TRACE_ENTRY_POINT;
+RequestActivationL( aViewId.iViewUid );
+TRACE_EXIT_POINT;
+}
+// ----------------------------------------------------------------------------
+// CCalenViewManager::RequestActivationL
+// Call this to try to activate a view
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenViewManager::RequestActivationL( const TUid& aViewUid,
+const TUid& aMessageId,
+const TDesC8& aMessage )
+{
+TRACE_ENTRY_POINT;
+// Cancel population of current view, if it's ongoing.
+iPopulator->InterruptPopulationL();
+// We start population of the newly activated view in HandleViewActivationL.
+// cache the previousviewid as we are getting aViewUid as reference.
+TUid cachePreviousViewId = iCurrentViewId.iViewUid;
+iCurrentViewId.iViewUid = aViewUid;
+// Update the view cycle index as iViewInfoArray would have changed
+	iViewCycleIndex = iViewInfoArray.Find( iCurrentViewId.iViewUid,
+CCalenViewInfo::ViewInfoIdentifier );
+	if( iController.IsFasterAppFlagEnabled() )
+		{
+	    // Leave the application in background
+	    iAppUi.HideInBackground();
+	    // Disable bring-to-foreground on view activation
+		iAppUi.SetCustomControl(1);
+		// activate the view
+		iAppUi.ActivateLocalViewL( aViewUid, KCalenHideInBackGround, KNullDesC8() );
+		// Enable bring-to-foreground on view activation.
+		iAppUi.SetCustomControl(0);
+		}
+	else
+		{
+		iAppUi.ActivateLocalViewL( aViewUid, aMessageId, aMessage );
+		}
+	// set the previous view id
+	if(cachePreviousViewId != KUidCalenEventView || cachePreviousViewId != iCurrentViewId.iViewUid)
+	    {
+iPreviousViewId.iViewUid = cachePreviousViewId;
+	    }
+	TRACE_EXIT_POINT;
+}
+// ----------------------------------------------------------------------------
+// CCalenViewManager::StartActiveStepL
+// Starts population of the current view.
+// ----------------------------------------------------------------------------
+//
+void CCalenViewManager::StartActiveStepL()
+{
+TRACE_ENTRY_POINT;
+// check for current viewid
+// populate the view only if iCurrentViewId is set
+if(iCurrentViewId.iViewUid != KNullUid)
+{
+iPopulator->InterruptPopulationL();
+iPopulator->BeginPopulationL(reinterpret_cast<CCalenView*>(iAppUi.View(CurrentView())));
+}
+TRACE_EXIT_POINT;
+}
+// ----------------------------------------------------------------------------
+// CCalenViewManager::ShowSwitchViewQueryL
+// Prompts the user to chose a view to switch to. If cancelled, returns
+// KErrCancel, otherwise one of ECalen*view.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenViewManager::ShowSwitchViewQueryL()
+{
+TRACE_ENTRY_POINT;
+// Create list of view names and uids
+CDesCArrayFlat* viewNames = new( ELeave ) CDesCArrayFlat( KArrayGranularity );
+CleanupStack::PushL( viewNames );
+RArray<TUid> viewUids;
+CleanupClosePushL( viewUids );
+	const RArray<TUid>& activePlugins = CustomisationManager().ActivePlugins();
+for( TInt index( 0 ); index < iViewInfoArray.Count(); ++index )
+{
+CCalenViewInfo& viewInfo = *( iViewInfoArray[index] );
+if( index != iViewCycleIndex )
+{
+TUid pluginUid = viewInfo.PluginUid();
+TInt position = activePlugins.Find( pluginUid );
+// If the view is from plugin or native view with cycle position,
+// then add it to the switch view list
+if(( position != KErrNotFound ) ||
+( viewInfo.CyclePosition() != CCalenView::ENoCyclePosition ))
+{
+// Fetch the view name
+TUid viewUid = viewInfo.ViewUid();
+const TDesC& viewName = viewInfo.MenuName();
+viewNames->AppendL( viewName );
+viewUids.AppendL(viewUid );
+}
+}
+}
-mController.MainWindow().addView(mCalenMonthView);
+// Show list query.
-mController.MainWindow().setCurrentView(mCalenMonthView);
+TInt choice = KErrCancel; //KErrNotFound;
-}
+CAknListQueryDialog* dlg = new( ELeave ) CAknListQueryDialog( &choice );
-//delete the activity intsance
+dlg->PrepareLC( R_CALENDAR_SWITCH_VIEW_QUERY ); // pushes dlg to CS
-delete activation;
+dlg->SetItemTextArray( viewNames );
-OstTraceFunctionExit0( CALENVIEWMANAGER_SECONDPHASECONSTRUCTION_EXIT );
+dlg->SetOwnershipType( ELbmDoesNotOwnItemArray );
-}
+// Set title
-// ----------------------------------------------------------------------------
+CAknPopupHeadingPane* heading = dlg->Heading();
-// CalenViewManager::~CalenViewManager
+HBufC* title = NULL;
-// Destructor.
+title = CCoeEnv::Static()->AllocReadResourceLC( R_CALENDAR_SWITCH_VIEW_QUERY_TITLE );
-// (other items were commented in a header).
+heading->SetTextL( *title );
-// ----------------------------------------------------------------------------
+CleanupStack::PopAndDestroy( title );
-//
-CalenViewManager::~CalenViewManager()
+if( dlg->RunLD() )
 {
-OstTraceFunctionEntry0( DUP1_CALENVIEWMANAGER_CALENVIEWMANAGER_ENTRY );
+// user made a choice
+TUid viewUid = viewUids[choice];
-	if (mSettingsView) {
+iAvoidRepopulation = EFalse;
-		delete mSettingsView;
+RequestActivationL( viewUid );
-		mSettingsView = 0;
+}
-	}
-	if (mAgendaViewDocLoader) {
+CleanupStack::PopAndDestroy(); // viewUids
-		delete mAgendaViewDocLoader;
+CleanupStack::PopAndDestroy( viewNames );
-		mAgendaViewDocLoader = 0;
-	}
+TRACE_EXIT_POINT;
-	if (mAgendaViewAltDocLoader) {
+}
-		delete mAgendaViewAltDocLoader;
-		mAgendaViewAltDocLoader = 0;
+// ----------------------------------------------------------------------------
-	}
+// CCalenViewManager::HandleNotification
-	if (mMonthViewDocLoader) {
+// Calls back when notifications that it has been registered for are broadcast
-		delete mMonthViewDocLoader;
+// (other items were commented in a header).
-		mMonthViewDocLoader = 0;
+// ----------------------------------------------------------------------------
-	}
+//
+void CCalenViewManager::HandleNotification(const TCalenNotification aNotification )
-	OstTraceFunctionExit0( DUP1_CALENVIEWMANAGER_CALENVIEWMANAGER_EXIT );
+{
-}
+TRACE_ENTRY_POINT;
-// ----------------------------------------------------------------------------
+PIM_TRAPD_HANDLE( HandleNotificationL( aNotification ) );
-// CalenViewManager::constructAndActivateView
-// Constructs and activates the requested view
+TRACE_EXIT_POINT;
-// (other items were commented in a header).
+}
-// ----------------------------------------------------------------------------
-//
+// ----------------------------------------------------------------------------
-void CalenViewManager::constructAndActivateView(int view)
+// CCalenViewManager::HandleNotificationL
-{
+// Called from HandleNotification() when notifications that it has been
-	OstTraceFunctionEntry0( CALENVIEWMANAGER_CONSTRUCTANDACTIVATEVIEW_ENTRY );
+//  registered for are broadcast
+// (other items were commented in a header).
-// We are here because, some other application is launching calendar with
+// ----------------------------------------------------------------------------
-	// the view, hence connect to viewReady() signal to do any lazy loading
+//
-	// in the slot
+void CCalenViewManager::HandleNotificationL( TCalenNotification aNotification )
+{
-	// Connect to the view ready signal so that we construct other view
+TRACE_ENTRY_POINT;
-	// once this view is shown
-	connect(&mController.MainWindow(), SIGNAL(viewReady()),
+switch( aNotification )
-					this, SLOT(handleMainViewReady()));
+{
-	if (view == ECalenMonthView) {
+case ECalenNotifyPluginEnabledDisabled:
-		mFirstView = ECalenMonthView;
+{
-		loadMonthView();
+UpdatePluginListL();
-		ActivateDefaultViewL(ECalenMonthView);
+}
-		// Add month view to mainwindow.
+break;
-		mController.MainWindow().addView(mCalenMonthView);
+case ECalenNotifySettingsClosed:
-		mController.MainWindow().setCurrentView(mCalenMonthView);
+{
-	} else if (view == ECalenAgendaView) {
+// Nothing has changed, refresh statuspane only.
-		mFirstView = ECalenAgendaView;
+iAppUi.StatusPane()->DrawNow();
-		loadAgendaView();
+}
-		ActivateDefaultViewL(ECalenAgendaView);
+break;
-		// Add agenda view to mainwindow.
+case ECalenNotifySettingsChanged:
-		mController.MainWindow().addView(mCalenAgendaView);
+{
-		mController.MainWindow().setCurrentView(mCalenAgendaView);
+HandleSettingsChangeNotificationL();
-		mController.MainWindow().addView(mCalenAgendaViewAlt);
+}
-	} else if (view == ECalenDayView) {
+break;
-	    mFirstView = ECalenDayView;
+case ECalenNotifyEntryDeleted:
-	    loadDayView();
+case ECalenNotifyInstanceDeleted:
-	    ActivateDefaultViewL(ECalenDayView);
+			{
-	    // Add day view to mainwindow.
+			iAvoidRepopulation = EFalse;
-mController.MainWindow().addView(mCalenDayView);
+			HandleEntryDeleteNotificationL();
-mController.MainWindow().setCurrentView(mCalenDayView);
-	}
-	OstTraceFunctionExit0( CALENVIEWMANAGER_CONSTRUCTANDACTIVATEVIEW_EXIT );
-}
-// ----------------------------------------------------------------------------
-// CalenViewManager::loadMonthView
-// Loads month view frm the docml
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
-//
-void CalenViewManager::loadMonthView()
-{
-OstTraceFunctionEntry0( CALENVIEWMANAGER_LOADMONTHVIEW_ENTRY );
-	bool loadSuccess = false;
-	Qt::Orientation currentOrienation = mController.MainWindow().orientation();
-	// Create the month view docloader object.
-	mMonthViewDocLoader = new CalenDocLoader(mController);
-	mMonthViewDocLoader->load(CALEN_MONTHVIEW_XML_FILE, &loadSuccess);
-	Q_ASSERT_X(loadSuccess, "calenviewmanager.cpp",
-											"Unable to load month view XML");
-	// Based on the current orientation, load the appropriate section
-	if (Qt::Vertical == currentOrienation) {
-		mMonthViewDocLoader->load(CALEN_MONTHVIEW_XML_FILE,
-											CALEN_PORTRAIT, &loadSuccess);
-		} else {
-			mMonthViewDocLoader->load(CALEN_MONTHVIEW_XML_FILE,
-											CALEN_LANDSCAPE, &loadSuccess);
-		}
-	Q_ASSERT_X(loadSuccess, "calenviewmanager.cpp", "Unable to load XML");
-	// Get the calenmonth view from the loader.
-	mCalenMonthView = static_cast<CalenMonthView *>
-							(mMonthViewDocLoader->findWidget(CALEN_MONTHVIEW));
-	Q_ASSERT_X(mCalenMonthView, "calenviewmanager.cpp",
-											"Unable to load calenMonth view");
-	// Set the parent to delete the view once will exit the application
-	mCalenMonthView->setParent(this);
-	// Setup the month view.
-	mCalenMonthView->setupView(mMonthViewDocLoader);
-	OstTraceFunctionExit0( CALENVIEWMANAGER_LOADMONTHVIEW_EXIT );
-}
-// ----------------------------------------------------------------------------
-// CalenViewManager::loadAgendaView
-// Loads the agenda view frm the docml
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
-//
-void CalenViewManager::loadAgendaView()
-{
-OstTraceFunctionEntry0( CALENVIEWMANAGER_LOADAGENDAVIEW_ENTRY );
-	bool loadSuccess = false;
-	// Create the agenda view docloader object.
-	mAgendaViewDocLoader = new CalenDocLoader(mController);
-	// Load default section
-	mAgendaViewDocLoader->load(CALEN_AGENDAVIEW_XML_FILE, &loadSuccess);
-	if (!loadSuccess) {
-		qFatal("calenviewmanager.cpp : Unable to load XML");
-	}
-	// Get the calenagenda view from the loader
-	mCalenAgendaView = static_cast<CalenAgendaView *> (mAgendaViewDocLoader->findWidget(CALEN_AGENDAVIEW));
-	if (!mCalenAgendaView) {
-		qFatal("calenviewmanager.cpp : Unable to find agenda view");
-	}
-	// Set the parent to delete the view once will exit the application
-	mCalenAgendaView->setParent(this);
-	// Setup the agenda view
-	mCalenAgendaView->setupView(mAgendaViewDocLoader);
-	// The following code is done to provide swipe support
-	// in agenda view. Idea is to create two views and keep
-	// switiching between these two using view switch effects
-	// to provide an illusion of flow to the user
-	loadAlternateAgendaView();
-	OstTraceFunctionExit0( CALENVIEWMANAGER_LOADAGENDAVIEW_EXIT );
-}
-// ----------------------------------------------------------------------------
-// CalenViewManager::loadDayView
-// Loads day view from the docml
-// ----------------------------------------------------------------------------
-void CalenViewManager::loadDayView()
-{
-bool loadSuccess = false;
-// Create the docloader object
-CalenDocLoader *docLoader = new CalenDocLoader(mController);
-if (docLoader) {
-docLoader->load(CALEN_DAYVIEW_DOCML, &loadSuccess);
-if (!loadSuccess) {
-qFatal("calenviewmanager.cpp : Unable to load day view XML");
-}
-// Get the CalenDayView object from the loader
-mCalenDayView = static_cast<CalenDayView *>
-(docLoader->findWidget(CALEN_DAYVIEW));
-if (!mCalenDayView) {
-qFatal("calenviewmanager.cpp : Unable to find day view");
-}
-// Set the parent to delete the view once will exit the application
-mCalenDayView->setParent(this);
-// Set up the day view - day view takes the ownership
-mCalenDayView->setupView(docLoader);
-}
-}
-// ----------------------------------------------------------------------------
-// CalenViewManager::handleMainViewReady
-// Slot to handle viewReady() signal from mainwindow
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
-//
-void CalenViewManager::handleMainViewReady()
-{
-OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEMAINVIEWREADY_ENTRY );
-	// Construct the month view part that is kept for lazy loading
-if (mCalenMonthView) {
-		mCalenMonthView->doLazyLoading();
-		if (mInstanceViewCreated) {
-			// populate entries for the month view if the month view is launched
-			// from the service APIs. Otherwise the month view is not populated with
-			// the entries as CalenViewManager::handleInstanceViewCreation is called
-			// before the month view creation so the model array is not populated.
-			mCalenMonthView->fetchEntriesAndUpdateModel();
-		}
-	}
-	// Construct other views
-	constructOtherViews();
-// Install the event filter for the controller once the view is ready
-// so that system language/locale changes can be handled
-	//hbInstance->allMainWindows().first()->installEventFilter(&mController);
-	// disconnect the view ready signal as we dont need it anymore
-	disconnect(&mController.MainWindow(), SIGNAL(viewReady()),
-			   this, SLOT(handleMainViewReady()));
-	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLEMAINVIEWREADY_EXIT );
-}
-// ----------------------------------------------------------------------------
-// CalenViewManager::constructOtherViews
-// Constructs the other views apart frm firstview and adds them to main window
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
-//
-void CalenViewManager::constructOtherViews()
-{
-OstTraceFunctionEntry0( CALENVIEWMANAGER_CONSTRUCTOTHERVIEWS_ENTRY );
-	// Load all other views except mFirstView
-	// NOTE: Right now, since Calendar has three views, month view, day view
-	// and agenda view, when client launches agenda view, then there is no need
-	// to construct the month view as per UI REQ., but tomorrow if new views
-	// come after agenda view, then we need to construct those views if they are
-	// native views. Right now, day view will be constructed as we need to
-// provide an option in options menu to switch between day view and agenda view
-// There is a event viewer but its not a native view, so no need to constrcut it
-// It will be constrcuted on demand.
-	// Hence, if agenda view is launched, constrcut the day vuew but dont construct month view.
-// Vice-versa for when day view is maunched as first view
-	if (mFirstView == ECalenMonthView) {
-		// Load all other views
-		loadAgendaView();
-		if (!mCalenDayView) {
-		    loadDayView();
-		}
-	} else if (mFirstView == ECalenAgendaView) { //agenda view was launched as first view
-	    // Load day view
-	    if (!mCalenDayView) {
-loadDayView();
-}
-} else if (mFirstView == ECalenDayView) { // Day view was launched as first view
-// Load agenda view
-loadAgendaView();
-}
-	// Setup the settings view
-	mSettingsView = new CalenSettingsView(mController.Services());
-	OstTraceFunctionExit0( CALENVIEWMANAGER_CONSTRUCTOTHERVIEWS_EXIT );
-}
-// ----------------------------------------------------------------------------
-// CalenViewManager::getFirstView
-// Returns the first view
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
-//
-int CalenViewManager::getFirstView()
-{
-OstTraceFunctionEntry0( CALENVIEWMANAGER_GETFIRSTVIEW_ENTRY );
-	OstTraceFunctionExit0( CALENVIEWMANAGER_GETFIRSTVIEW_EXIT );
-	return mFirstView;
-}
-// ----------------------------------------------------------------------------
-// CalenViewManager::showNextDay
-// other items were commented in a header
-// ----------------------------------------------------------------------------
-//
-void CalenViewManager::showNextDay()
-{
-OstTraceFunctionEntry0( CALENVIEWMANAGER_SHOWNEXTDAY_ENTRY );
-// Set the context for the next day
-QDateTime currentDay = mController.Services().Context().focusDateAndTime();
-currentDay = currentDay.addDays(1);
-mController.Services().Context().setFocusDate(currentDay);
-mCurrentViewId = ECalenAgendaView;
-// Check which is the currently activated view
-if (mController.MainWindow().currentView() == mCalenAgendaView) {
-mCalenAgendaView->disconnectAboutToQuitEvent(); // disconnect mCalenAgendaView to get aboutToQuit Events
-HbEffect::add(mCalenAgendaView,
-":/fxml/view_hide",
-"hide");
-HbEffect::add(mCalenAgendaViewAlt,
-":/fxml/view_show",
-"show");
-// Set the other agenda view as the current view
-// and animate to provide illusion of swipe
-		// It would also connect for aboutToQuit events
-mCalenAgendaViewAlt->doPopulation();
-mController.MainWindow().setCurrentView(mCalenAgendaViewAlt, true, Hb::ViewSwitchUseNormalAnim);
-} else {
-mCalenAgendaViewAlt->disconnectAboutToQuitEvent(); // disconnect mCalenAgendaViewAlt to get aboutToQuit Events
-HbEffect::add(mCalenAgendaViewAlt,
-":/fxml/view_hide",
-"hide");
-HbEffect::add(mCalenAgendaView,
-":/fxml/view_show",
-"show");
-		// It would also connect for aboutToQuit events
-mCalenAgendaView->doPopulation();
-mController.MainWindow().setCurrentView(mCalenAgendaView, true, Hb::ViewSwitchUseNormalAnim);
-}
-OstTraceFunctionExit0( CALENVIEWMANAGER_SHOWNEXTDAY_EXIT );
-}
-// ----------------------------------------------------------------------------
-// CalenViewManager::showPrevDay
-// other items were commented in a header
-// ----------------------------------------------------------------------------
-//
-void CalenViewManager::showPrevDay()
-{
-OstTraceFunctionEntry0( CALENVIEWMANAGER_SHOWPREVDAY_ENTRY );
-QDateTime currentDay = mController.Services().Context().focusDateAndTime();
-currentDay = currentDay.addDays(-1);
-mController.Services().Context().setFocusDate(currentDay);
-mCurrentViewId = ECalenAgendaView;
-if (mController.MainWindow().currentView() == mCalenAgendaView) {
-mCalenAgendaView->disconnectAboutToQuitEvent(); // disconnect mCalenAgendaView to get aboutToQuit Events
-HbEffect::add(mCalenAgendaView,
-":/fxml/view_hide_back",
-"hide");
-HbEffect::add(mCalenAgendaViewAlt,
-":/fxml/view_show_back",
-"show");
-		// It would also connect for aboutToQuit events
-mCalenAgendaViewAlt->doPopulation();
-mController.MainWindow().setCurrentView(mCalenAgendaViewAlt, true, Hb::ViewSwitchUseNormalAnim);
-} else {
-mCalenAgendaViewAlt->disconnectAboutToQuitEvent(); // disconnect mCalenAgendaViewAlt to get aboutToQuit Events
-HbEffect::add(mCalenAgendaViewAlt,
-":/fxml/view_hide_back",
-"hide");
-HbEffect::add(mCalenAgendaView,
-":/fxml/view_show_back",
-"show");
-		// It would also connect for aboutToQuit events
-mCalenAgendaView->doPopulation();
-mController.MainWindow().setCurrentView(mCalenAgendaView, true, Hb::ViewSwitchUseNormalAnim);
-}
-OstTraceFunctionExit0( CALENVIEWMANAGER_SHOWPREVDAY_EXIT );
-}
-// ----------------------------------------------------------------------------
-// CalenViewManager::removePreviousView
-// Remove the previous view from main window
-// ----------------------------------------------------------------------------
-//
-void CalenViewManager::removePreviousView()
-{
-OstTraceFunctionEntry0( CALENVIEWMANAGER_REMOVEPREVIOUSVIEW_ENTRY );
-	if (ECalenAgendaView == mCurrentViewId) {
-		mCalenAgendaView->clearListModel();
-		mCalenAgendaViewAlt->clearListModel();
-		mController.MainWindow().removeView(mCalenAgendaView);
-		mController.MainWindow().removeView(mCalenAgendaViewAlt);
-	} else if (ECalenDayView == mCurrentViewId) {
-		mController.MainWindow().removeView(mCalenDayView);
-	} else {
-		if (ECalenMonthView == mCurrentViewId) {
-			mController.MainWindow().removeView(mCalenMonthView);
-		}
-	}
-	OstTraceFunctionExit0( CALENVIEWMANAGER_REMOVEPREVIOUSVIEW_EXIT );
-}
-// ----------------------------------------------------------------------------
-// CalenViewManager::~ActivateDefaultViewL
-//  Activates the default view, as retrieved from settings.
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
-//
-void CalenViewManager::ActivateDefaultViewL(int defaultView)
-{
-OstTraceFunctionEntry0( CALENVIEWMANAGER_ACTIVATEDEFAULTVIEWL_ENTRY );
-	mCurrentViewId = defaultView;
-	if (ECalenMonthView == defaultView) {
-		mCalenMonthView->doPopulation();
-	} else if (ECalenAgendaView == defaultView) {
-		mCalenAgendaView->doPopulation();
-	} else if (ECalenDayView == defaultView) {
-mCalenDayView->doPopulation();
-}
-	OstTraceFunctionExit0( CALENVIEWMANAGER_ACTIVATEDEFAULTVIEWL_EXIT );
-}
-// ----------------------------------------------------------------------------
-// Refresh current view.
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
-void CalenViewManager::refreshCurrentViewL()
-{
-OstTraceFunctionEntry0( CALENVIEWMANAGER_REFRESHCURRENTVIEWL_ENTRY );
-	activateCurrentView();
-	OstTraceFunctionExit0( CALENVIEWMANAGER_REFRESHCURRENTVIEWL_EXIT );
-}
-// ----------------------------------------------------------------------------
-// Activate current view.
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
-void CalenViewManager::activateCurrentView()
-{
-OstTraceFunctionEntry0( CALENVIEWMANAGER_ACTIVATECURRENTVIEW_ENTRY );
-	switch (mCurrentViewId) {
-		case ECalenMonthView:
-		    mCalenMonthView->doPopulation();
-		    mController.MainWindow().setCurrentView(mCalenMonthView);
-			break;
-		case ECalenAgendaView:
-		    if (mController.MainWindow().currentView() == mCalenAgendaView) {
-		        // This happens when settings view or event viewer is opened
-		        // from the agenda view. Simply repopulate the view
-		    	if (mCalenAgendaView) {
-		    		mCalenAgendaView->doPopulation();
-					mController.MainWindow().setCurrentView(mCalenAgendaView);
-		    	}
-		    } else if (mController.MainWindow().currentView() == mCalenAgendaViewAlt){
-		        // This happens when settings view or event viewer is opened
-		        // from the agenda view. Simply repopulate the view
-		    	if (mCalenAgendaViewAlt) {
-		    		mCalenAgendaViewAlt->doPopulation();
-		    		mController.MainWindow().setCurrentView(mCalenAgendaViewAlt);
-		    	}
-		    } else {
-		        // This is called whenever the agenda view is opened from the month
-		        // view. Since the agenda view is not added to the mainwindow,
-		        // add the agenda views to mainwindow and set any one of them as
-		        // current view
-		    	if (mCalenAgendaView) {
-		    		mCalenAgendaView->doPopulation();
-		    		mController.MainWindow().addView(mCalenAgendaView);
-		    		mController.MainWindow().setCurrentView(mCalenAgendaView);
-		    		mController.MainWindow().addView(mCalenAgendaViewAlt);
-		    	}
-		    }
-			break;
-		case ECalenShowSettings:
-		    mSettingsView->refreshView();
-			break;
-		case ECalenDayView:
-			mCalenDayView->doPopulation();
-			mController.MainWindow().setCurrentView(mCalenDayView);
-			break;
-	}
-	OstTraceFunctionExit0( CALENVIEWMANAGER_ACTIVATECURRENTVIEW_EXIT );
-}
-// ----------------------------------------------------------------------------
-// CalenViewManager::launchEventView
-// Launch event view.
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
-//
-void CalenViewManager::launchEventView()
-{
-OstTraceFunctionEntry0( CALENVIEWMANAGER_LAUNCHEVENTVIEW_ENTRY );
-// capture cureent view in case app closed/quits from AgendaEventViewer
-if (mCalenMonthView) {
-mCalenMonthView->captureScreenshot(true);
-}
-else if (mCalenAgendaView) {
-	mCalenAgendaView->captureScreenshot(true);
-}
-	MCalenContext& context = mController.Services().Context();
-	AgendaEntry viewEntry= mController.Services().agendaInterface()->fetchById(
-			context.instanceId().mEntryLocalUid );
-	if (viewEntry.isRepeating()
-			&& viewEntry.type() != AgendaEntry::TypeTodo) {
-		QDateTime startDateTime = context.focusDateAndTime();
-		viewEntry.setStartAndEndTime(startDateTime,
-		                     startDateTime.addSecs(viewEntry.durationInSecs()));
-	}
-	mCalenEventViewer = new AgendaEventViewer(
-			mController.Services().agendaInterface(), this);
-	connect(mCalenEventViewer, SIGNAL(viewingCompleted(const QDate)),
-	        this, SLOT(handleViewingCompleted(const QDate)));
-	connect(mCalenEventViewer, SIGNAL(editingStarted()),
-	        this, SLOT(handleEditingStarted()));
-	connect(mCalenEventViewer, SIGNAL(editingCompleted()),
-	        this, SLOT(handleEditingCompleted()));
-	connect(mCalenEventViewer, SIGNAL(deletingStarted()),
-		        this, SLOT(handleDeletingStarted()));
-	connect(mCalenEventViewer, SIGNAL(deletingCompleted()),
-			        this, SLOT(handleDeletingCompleted()));
-	// Launch agenda event viewer
-	mCalenEventViewer->view(viewEntry, AgendaEventViewer::ActionEditDelete);
-	OstTraceFunctionExit0( CALENVIEWMANAGER_LAUNCHEVENTVIEW_EXIT );
-}
-// ----------------------------------------------------------------------------
-// CalenViewManager::loadAlternateAgendaView
-// other items were commented in a header
-// ----------------------------------------------------------------------------
-//
-void CalenViewManager::loadAlternateAgendaView()
-{
-OstTraceFunctionEntry0( CALENVIEWMANAGER_LOADALTERNATEAGENDAVIEW_ENTRY );
-bool loadSuccess = false;
-// Create the agenda view docloader object.
-mAgendaViewAltDocLoader = new CalenDocLoader(mController);
-// Load default section
-mAgendaViewAltDocLoader->load(CALEN_AGENDAVIEW_XML_FILE, &loadSuccess);
-if (!loadSuccess) {
-qFatal("calenviewmanager.cpp : Unable to load XML");
-}
-// Get the calenagenda view from the loader
-mCalenAgendaViewAlt = static_cast<CalenAgendaView *> (mAgendaViewAltDocLoader->findWidget(CALEN_AGENDAVIEW));
-if (!mCalenAgendaViewAlt) {
-qFatal("calenviewmanager.cpp : Unable to find alternate agenda view");
-}
-// Set the parent to delete the view once will exit the application
-mCalenAgendaViewAlt->setParent(this);
-// Setup the agenda view
-mCalenAgendaViewAlt->setupView(mAgendaViewAltDocLoader);
-OstTraceFunctionExit0( CALENVIEWMANAGER_LOADALTERNATEAGENDAVIEW_EXIT );
-}
-// ----------------------------------------------------------------------------
-// CalenViewManager::HandleCommandL
-// Handles view manager commands.
-// @return ETrue if command is handled, EFalse otherwise
-// ----------------------------------------------------------------------------
-//
-TBool CalenViewManager::HandleCommandL(const TCalenCommand& command)
-{
-OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLECOMMANDL_ENTRY );
-	TBool commandUsed(EFalse);
-	switch (command.Command()) {
-		case ECalenMonthView:
-			// First remove the previous native view before
-			// we set the mCurrentViewId with the current view
-			removePreviousView();
-			// Add month view to mainwindow.
-			mController.MainWindow().addView(mCalenMonthView);
-			mCurrentViewId = ECalenMonthView;
-			activateCurrentView();
-			break;
-		case ECalenAgendaView:
-			// First remove the previous native view before
-			// we set the mCurrentViewId with the current view
-			removePreviousView();
-			mCurrentViewId = ECalenAgendaView;
-			activateCurrentView();
-			break;
-		case ECalenDayView:
-{
-// First add new view
-			mController.MainWindow().addView(mCalenDayView);
-			// Removes current view
-		    // Notice: removing view should be done after new view is set as current to
-		    // avoid situation that there is no current view in application
-		    removePreviousView();
-		    // Sets and activates day view
-		    mCurrentViewId = ECalenDayView;
-		    activateCurrentView();
 			}
 			break;
-		case ECalenEventView:
+case ECalenNotifySystemLocaleChanged:
-			launchEventView();
+case ECalenNotifyEntrySaved:
-			break;
+case ECalenNotifyMultipleEntriesDeleted:
-		case ECalenStartActiveStep:
+case ECalenNotifyExternalDatabaseChanged:
-			activateCurrentView();
+case ECalenNotifyCancelDelete:
-			break;
+case ECalenNotifyCalendarFieldChanged:
-		case ECalenShowNextDay:
+case ECalenNotifyMarkedEntryCompleted:
-		    showNextDay();
+case ECalenNotifyCalendarInfoCreated:
-		    break;
+case ECalenNotifyCalendarInfoUpdated:
-		case ECalenShowPrevDay:
+{
-showPrevDay();
+StartActiveStepL();
-		    break;
+}
+break;
+case ECalenNotifyCalendarFileDeleted:
+{
+if(iCurrentViewId.iViewUid==KUidCalenEventView)
+{
+//If the entry which is being viewed belongs to a calendar
+//that is deleted we check for collection ids of entry and
+//calendar session if they are same return to previous view
+TPtrC calFileName = iGlobalData->Context().GetCalendarFileNameL();
+TPtrC calFileNameForColId =
+iGlobalData->GetCalFileNameForCollectionId(iGlobalData->Context().InstanceId().iColId);
+if(!calFileNameForColId.CompareF(calFileName))
+{
+ActivateDefaultViewL(iPreviousToDayView.iViewUid);
+}
+}
+else
+{
+// refresh the current view
+StartActiveStepL();
+}
+}
+break;
+case ECalenNotifyEntryClosed:
+{
+HandleEntryClosedNotificationL();
+}
+break;
+case ECalenNotifySystemTimeChanged:
+{
+HandleSystemTimeChangeNotificationL();
+}
+break;
+case ECalenNotifyAppForegrounded:
+	{
+	// check for system time change whenever fake exit is done
+	// or application comes to foreground
+if(!iStartupComplete)
+{
+iController.CheckSystemTimeAtStartUpL();
+}
+if( iController.IsFasterAppFlagEnabled() )
+			    {
+			    iAppUi.HideApplicationFromFSW(EFalse);
+			    iController.SetFasterAppFlag( EFalse );
+			    ReloadAllPluginsL();
+			    }
+else
+{
+iAvoidRepopulation = EFalse;
+}
+	}
+	break;
+case ECalenNotifyDayViewClosed:
+{
+if(iPreviousToDayView.iViewUid!= KNullUid)
+{
+// activate the previous view from where day view is launched
+// From month/week view -> day view
+RequestActivationL(iPreviousToDayView.iViewUid);
+}
+}
+break;
+case ECalenNotifyWeekViewClosed:
+{
+if(iPreviousToWeekView.iViewUid!= KNullUid)
+{
+// activate the previous view from where day view is launched
+// From month/week view -> day view
+RequestActivationL(iPreviousToWeekView.iViewUid);
+}
+}
+break;
+case ECalenNotifyAppBackgrounded:
+{
+// set the flag iAvoidRepopulation to prevent repopulation
+// whenever application is brought to foreground
+iAvoidRepopulation = ETrue;
+if( iController.IsFasterAppFlagEnabled() )
+{
+TRAP_IGNORE(iController.RemoveDeadCalendarsL());
+}
+}
+break;
+case ECalenNotifyViewPopulationComplete:
+{
+if(iStartupComplete)
+{
+iController.CheckSystemTimeAtStartUpL();
+iStartupComplete = EFalse;
+}
+break;
+}
+case ECalenNotifyAttachmentViewerClosed:
+		{
+if( iCurrentViewId.iViewUid==KUidCalenEventView)
+{
+StartActiveStepL();
+}
+}
+case ECalenNotifyAttachmentRemoved:
+case ECalenNotifyAttachmentAdded:
+{
+if( iCurrentViewId.iViewUid==KUidCalenEventView &&
+!iAvoidRepopulation    )
+{
+StartActiveStepL();
+}
+}
+case ECalenNotifyDeleteFailed:
+// Do nothing on deletion failed
+default:
+break;
+}
+TRACE_EXIT_POINT;
+}
+// ----------------------------------------------------------------------------
+// CCalenViewManager::UpdatePluginListL
+// Discovers if a plugin has been enabled or disabled
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenViewManager::UpdatePluginListL()
+{
+TRACE_ENTRY_POINT;
+const RArray<TUid>& activePlugins = CustomisationManager().ActivePlugins();
+// Check for any new plugins
+TInt activeCount = activePlugins.Count();
+for( TInt index( 0 ); index < activeCount; ++index )
+{
+// For every active plugin, check to see if it is in the known list,
+// if it isn't construct any custom views.
+TUid pluginUid = activePlugins[index];
+TInt position = iKnownPlugins.Find( pluginUid );
+if( position == KErrNotFound )
+{
+ConstructCustomViewL( pluginUid );
+}
+}
+RArray<TUid> disabledPlugins;
+CleanupClosePushL( disabledPlugins );
+// Check for any disabled plugins
+TInt knownCount = iKnownPlugins.Count();
+for( TInt index( knownCount - 1 ); index >= 0; --index )
+{
+// For every known plugin, check to see if it is in the active list,
+// if it isn't add to the disable plugin list, and remove from the
+// known list.
+TUid pluginUid = iKnownPlugins[index];
+TInt position = activePlugins.Find( pluginUid );
+if ( position == KErrNotFound )
+{
+disabledPlugins.AppendL( pluginUid );
+iKnownPlugins.Remove( index );
+}
+}
+TInt disabledPluginCount = disabledPlugins.Count();
+if( disabledPluginCount != 0 )
+{
+RemoveDisabledPluginsViewsL( disabledPlugins );
+// Re sort the view info array
+iViewInfoArray.Sort(  CCalenViewInfo::CyclePositionComparison );
+}
+else
+{
+// Update the view cycle index as iViewInfoArray would have changed
+iViewCycleIndex = iViewInfoArray.Find( iCurrentViewId.iViewUid, CCalenViewInfo::ViewInfoIdentifier );
+}
+UpdateToolbarNextViewIconL(iCurrentViewId.iViewUid);
+CleanupStack::PopAndDestroy(); // disabledPlugins
+TRACE_EXIT_POINT;
+}
+// ----------------------------------------------------------------------------
+// CCalenViewManager::RemoveDisabledPluginsViewsL
+// Removes any custom views provided by disabled plugins
+// from the view server.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenViewManager::RemoveDisabledPluginsViewsL( RArray<TUid>& aDisabledPlugins )
+{
+TRACE_ENTRY_POINT;
+// Find what views are provided by the disabled plugins
+TInt disabledPluginCount = aDisabledPlugins.Count();
+RArray<TUid> removedViews;
+CleanupClosePushL( removedViews );
+TUid activeViewUid = CurrentView();
+for( TInt index( disabledPluginCount - 1 ); index >= 0; --index )
+{
+TUid pluginUid = aDisabledPlugins[index];
+// Does this plugin offer any views
+TInt position = iViewInfoArray.Find( pluginUid,
+CCalenViewInfo::ViewPluginIdentifier );
+TBool alreadySet = EFalse;
+while( position != KErrNotFound )
+{
+CCalenViewInfo* view = iViewInfoArray[position];
+TUid viewUid = view->ViewUid();
+// Remove from the view cycle list
+iViewInfoArray.Remove( position );
+RArray<TInt> hiddenViews;
+iCustomisationManager->GetHiddenViewIdL(pluginUid, hiddenViews);
+if( viewUid == activeViewUid )
+{
+// Removing the active view is done in three parts
+// 1) It is removed from the viewInfo list
+// 2) When settings is closed, the view is switched
+// to the next view in the view cycle list.
+// 3) When the view is deactivated it can be deleted.
+// Store the information about the current view.
+iRemovedActiveView = view;
+// Update the view cycle index so that hidden view is launched while cycling next view
+if(hiddenViews.Count())
+{
+// Find the index of teh hidden view
+TInt viewInfoIndex = iViewInfoArray.Find(TUid::Uid(hiddenViews[0]), CCalenViewInfo::ViewInfoIdentifier);
+iViewCycleIndex = viewInfoIndex - 1;  // Decrementing it as CycleNextView() funciton will increment it
+}
+else if(!alreadySet)
+{
+TInt nextViewCycleIndex = iViewCycleIndex - 1; // To update the view cycle index in plugin disable case
+// Update the view cycle index as iViewInfoArray would have changed
+iViewCycleIndex = iViewInfoArray.Find( iCurrentViewId.iViewUid, CCalenViewInfo::ViewInfoIdentifier );
+// If the current active view has been removed,
+if(iViewCycleIndex == -1)
+{
+iViewCycleIndex = nextViewCycleIndex;
+}
+alreadySet = ETrue;
+}
+hiddenViews.Reset();
+// Remove the plugin from the disabled plugin list
+// to stop the plugin being deleted.
+aDisabledPlugins.Remove( index );
+}
+else
+{
+// The view isn't the current view, so we
+// can remove it directly from the view server
+iAppUi.RemoveView( viewUid );
+// Delete the view info
+delete view;
+if(!alreadySet)
+{
+	                TInt nextViewCycleIndex = iViewCycleIndex - 1; // To update the view cycle index in plugin disable case
+	                // Update the view cycle index as iViewInfoArray would have changed
+	                iViewCycleIndex = iViewInfoArray.Find( iCurrentViewId.iViewUid, CCalenViewInfo::ViewInfoIdentifier );
+	                // If the current active view has been removed,
+	                if(iViewCycleIndex == -1)
+	                    {
+	                        iViewCycleIndex = nextViewCycleIndex;
+	                    }
+	                alreadySet = ETrue;
+}
+}
+position = iViewInfoArray.Find( pluginUid,
+CCalenViewInfo::ViewPluginIdentifier );
+}
+}
+// Unload the disabled plugins
+iCustomisationManager->UnloadPluginsL( aDisabledPlugins );
+CleanupStack::PopAndDestroy(); // removedViews
+TRACE_EXIT_POINT;
+}
+// ----------------------------------------------------------------------------
+// CCalenViewManager::ToolbarOrNull
+// Provides access to the calendar toolbar if one is available
+// ----------------------------------------------------------------------------
+MCalenToolbar* CCalenViewManager::ToolbarOrNull()
+{
+TRACE_ENTRY_POINT;
+TRACE_EXIT_POINT;
+if (iToolbar)
+{
+if (iToolbar->IsICalenToolBar())
+{
+return iToolbar;
+}
+}
+return NULL;
+}
+// ----------------------------------------------------------------------------
+// CCalenViewManager::ViewsActivated
+// Returns if the first view activation on start-up has taken place
+// ----------------------------------------------------------------------------
+TBool CCalenViewManager::ViewsActivated() const
+{
+TRACE_ENTRY_POINT;
+TRACE_EXIT_POINT;
+return iViewsActivated;
+}
+// ----------------------------------------------------------------------------
+// CCalenViewManager::UpdateToolbarNextViewIconL
+// Updates the nextview icon on the toolbar when default view is not month view
+// ----------------------------------------------------------------------------
+void CCalenViewManager::UpdateToolbarNextViewIconL(TUid aViewUid)
+	{
+	// Set the view cycle index based on the newly activated view,
+// if the view is in the cycle array.
+TInt index = iViewInfoArray.Find( aViewUid, CCalenViewInfo::ViewInfoIdentifier );
+if( index != KErrNotFound )
+{
+iViewCycleIndex = index;
+if( iToolbar )
+{
+TInt nextVwIndex = iViewCycleIndex;
+do{
+nextVwIndex = ( nextVwIndex + 1 )%(iViewInfoArray.Count());
+}
+while( iViewInfoArray[nextVwIndex]->CyclePosition() == CCalenView::ENoCyclePosition );
+CCalenView* nextview = static_cast<CCalenView*>(
+iAppUi.View( iViewInfoArray[nextVwIndex]->ViewUid() ) );
+iToolbar->SetNextViewIcon( nextview->ViewIconL() );
+}
+}
 	}
-	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLECOMMANDL_EXIT );
-	return commandUsed;
+// ----------------------------------------------------------------------------
-}
+// CCalenViewManager::HandleFasterAppExitCommandL
+// Handles ECalenFasterAppExit command
 // ----------------------------------------------------------------------------
-// CalenViewManager::HandleNotification
+void CCalenViewManager::HandleFasterAppExitCommandL()
-//  Handles notifications.
+{
-// (other items were commented in a header).
+TRACE_ENTRY_POINT;
-// ----------------------------------------------------------------------------
-//
+if(iToolbar)
-void CalenViewManager::HandleNotification(
+{
-const TCalenNotification notification)
+iToolbar->SetToolbarExtensionFocus(EFalse);
-{
+}
-OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLENOTIFICATION_ENTRY );
+// For Handling : When the default view is changed keeping that view open,
-	switch (notification) {
+// from day view changing the default view from month view to day view,
-		case ECalenNotifyExternalDatabaseChanged:
+// we need to reset the previous view id.
-		case ECalenNotifyDialogClosed:
+if(iPreviousToDayView.iViewUid!=KNullUid)
-		case ECalenNotifyMultipleEntriesDeleted:
+{
-		case ECalenNotifyEntrySaved:
+iPreviousToDayView.iViewUid = KNullUid;
-		case ECalenNotifyEntryDeleted:
+}
-		case ECalenNotifyInstanceDeleted:
-		case ECalenNotifyEntryClosed:
+// For handling specific case::Calendar exited from FSW
-		case ECalenNotifySystemLocaleChanged:
+// iAvoidRepopulation is set when app backgrounded.
-		case ECalenNotifySystemTimeChanged:
+// Reset the flag for activating the view in background
-		case ECalenNotifySystemLanguageChanged: {
+if(iAvoidRepopulation)
+{
-			if (notification == ECalenNotifySystemTimeChanged) {
+iAvoidRepopulation = EFalse;
-				MCalenContext &context = mController.context();
+}
-				QDateTime defaultTime = context.defaultCalTimeForViewsL();
-				context.setFocusDateAndTime(defaultTime);
+// In case of fasterapp exit, first activate the dummy view before deleting the plugin views
-			}
+// Get the default view before we remove plugins
-			activateCurrentView();
+iPreviousViewId.iViewUid = KNullUid;
-			if (mCalenMonthView) {
-				mCalenMonthView->captureScreenshot();
+iController.SetExitOnDialogFlag( EFalse ); // for making iisexitondialogclose EFalse.
-			} else if (mCalenAgendaView) {
-				mCalenAgendaView->captureScreenshot();
+TUid defView = iSetting->DefaultView();
-			}
-		}
+// unload all plugins
-		    break;
+iCustomisationManager->DisableAllPluginsL();
-		case ECalenNotifySettingsClosed: {
+ActivateViewOnFakeExitL(defView);
-		    //when setting view closed , switch to the previous view
+// Though the current view is active view, there is no need to issue a callback as we are exiting the whole application.
-		    mCurrentViewId = mPreviousViewsId ;
+if( iRemovedActiveView )
-			mController.Services().IssueCommandL(ECalenStartActiveStep);
+{
-			 // invalidate captured screenshots as either agenda view is activated now
+if( !iViewRemovalCallback )
-			if (mCalenMonthView) {
+{
-			mCalenMonthView->captureScreenshot();
+TCallBack callback( RemoveDeActivatedView, this );
-			} else if (mCalenAgendaView) {
+iViewRemovalCallback = new( ELeave ) CAsyncCallBack( callback,
-				mCalenAgendaView->captureScreenshot();
+CActive::EPriorityStandard );
-			}
+}
+iViewRemovalCallback->CallBack();
-		    }
+}
-			break;
-		default:
+TRACE_EXIT_POINT;
-			break;
+}
-	}
+// ----------------------------------------------------------------------------
-	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLENOTIFICATION_EXIT );
+// CCalenViewManager::HandleSettingsChangeNotificationL
-}
+// Handles ECalenNotifySettingsChanged notification
+// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
+void CCalenViewManager::HandleSettingsChangeNotificationL()
-// CalenViewManager::settingsView
+{
-//  Returns the settings view
+TRACE_ENTRY_POINT;
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
+if( iController.IsFasterAppFlagEnabled() )
-//
+{
-CalenSettingsView* CalenViewManager::settingsView()
+TUid newViewUid = iSetting->DefaultView();
-{
+if(IsNativeView(newViewUid))
-OstTraceFunctionEntry0( CALENVIEWMANAGER_SETTINGSVIEW_ENTRY );
+{
+TUid oldViewUid = CurrentView();
-	OstTraceFunctionExit0( CALENVIEWMANAGER_SETTINGSVIEW_EXIT );
+if( newViewUid.iUid != oldViewUid.iUid )
-	return mSettingsView;
+{
-}
+RequestActivationL( newViewUid );
+}
-// ----------------------------------------------------------------------------
+}
-// CalenViewManager::handleViewingCompleted
-//  Slot to handle signal viewingCompleted by the agenda event viewer
+// If the plugins are activated using general settings.
-// (other items were commented in a header).
+// unload all plugins.Only load the plugins when application
-// ----------------------------------------------------------------------------
+// comes to foreground
-//
+const RArray<TUid>& plugins = CustomisationManager().ActivePlugins();
-void CalenViewManager::handleViewingCompleted(const QDate date)
+if(plugins.Count())
 {
-	Q_UNUSED(date);
+// unload all plugins
-	OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEVIEWINGCOMPLETED_ENTRY );
+iCustomisationManager->DisableAllPluginsL();
+}
+}
+if( iRemovedActiveView )
+{
+// If the active view has been disabled, the next view in
+// the view cycle list is activated and the current view
+// is removed asyncronously.
+CycleNextViewL();
+if( !iViewRemovalCallback )
+{
+TCallBack callback( RemoveDeActivatedView, this );
+iViewRemovalCallback = new( ELeave ) CAsyncCallBack( callback,
+CActive::EPriorityStandard );
+}
+iViewRemovalCallback->CallBack();
+}
+else if(iCustomisationManager->HiddenView(iCurrentViewId.iViewUid))
+{
+// Get the uid of the plugin view that is hiding the current view
+TUid viewUid = iCustomisationManager->GetReplacePluginViewIdL(iCurrentViewId.iViewUid);
+// update the view cycle index before activating the plugin view
+iViewCycleIndex = iViewInfoArray.Find( viewUid,
+CCalenViewInfo::ViewInfoIdentifier );
+RequestActivationL(viewUid);
+}
+else
+{
+StartActiveStepL();
+}
+TRACE_EXIT_POINT;
+}
+// ----------------------------------------------------------------------------
+// CCalenViewManager::HandleEntryDeleteNotificationL
+// Handles ECalenNotifyEntryDeleted and ECalenNotifyInstanceDeleted
+// notifications
+// ----------------------------------------------------------------------------
+void CCalenViewManager::HandleEntryDeleteNotificationL()
+{
+TRACE_ENTRY_POINT;
+if(iCurrentViewId.iViewUid == KUidCalenEventView)
+{
+// Activate the previous view when an event is deleted from
+// the event view
+if(iPreviousViewId.iViewUid != KNullUid)
+{
+if(iPreviousToDayView.iViewUid != KNullUid)
+{
+RequestActivationL(iPreviousViewId.iViewUid, KUidCalenShowBackCba);
+}
+else
+{
+RequestActivationL(iPreviousViewId.iViewUid);
+}
+}
+}
+else
+{
+// refresh the current view
+StartActiveStepL();
+}
+TRACE_EXIT_POINT;
+}
+// ----------------------------------------------------------------------------
+// CCalenViewManager::HandleEntryClosedNotificationL
+// Handles ECalenNotifyEntryClosed notification
+// ----------------------------------------------------------------------------
+void CCalenViewManager::HandleEntryClosedNotificationL()
+{
+TRACE_ENTRY_POINT;
-	// Cleanup.
+	// reset tha flag iAvoidRepopulation to refresh the view.
-	mCalenEventViewer->deleteLater();
+	iAvoidRepopulation = EFalse;
-	if (!date.isNull() && date.isValid()) {
-	    mController.Services().Context().setFocusDate(QDateTime(date));
+// if previous view is native view activate that view
-	}
+// otherwise commandlauncher will handle
-	mController.Services().IssueNotificationL(ECalenNotifyEntryClosed);
+if(iPreviousViewId.iViewUid != KNullUid)
+{
-	// invalidate captured screenshots as either agenda view is activated now
+// if iPreviousToDayView is active activate the day view with "Back" cba.
-	if (mCalenMonthView) {
+if(iPreviousToDayView.iViewUid!=KNullUid)
-	mCalenMonthView->captureScreenshot();
+{
-	} else if (mCalenAgendaView) {
+RequestActivationL(iPreviousViewId.iViewUid, KUidCalenShowBackCba);
-		mCalenAgendaView->captureScreenshot();
+}
-	}
+else
-	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLEVIEWINGCOMPLETED_EXIT );
+{
-}
+if( !iController.GetExitOnDialogFlag() )
+{
-// ----------------------------------------------------------------------------
+RequestActivationL(iPreviousViewId.iViewUid);
-// CalenViewManager::handleEditingStarted
+}
-//  Slot to handle signal editingStarted by the agenda event viewer
+}
-// (other items were commented in a header).
+}
-// ----------------------------------------------------------------------------
-//
+	// reset tha flag iAvoidRepopulation to avoid the repopulation.
-void CalenViewManager::handleEditingStarted()
+	iAvoidRepopulation = ETrue;
-{
-	OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEEDITINGSTARTED_ENTRY );
+TRACE_EXIT_POINT;
+}
-	mController.IssueCommandL(ECalenEditEntryFromViewer);
+// ----------------------------------------------------------------------------
-	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLEEDITINGSTARTED_EXIT );
+// CCalenViewManager::HandleSystemTimeChangeNotificationL
-}
+// Handles ECalenNotifySystemTimeChanged notification
+// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
+void CCalenViewManager::HandleSystemTimeChangeNotificationL()
-// CalenViewManager::handleEditingCompleted
+{
-//  Slot to handle signal editingCompleted by the agenda event viewer
+TRACE_ENTRY_POINT;
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
+//Set the context whenever system time is changed
-//
+TUid newViewUid = iSetting->DefaultView();
-void CalenViewManager::handleEditingCompleted()
+MCalenContext& context = iController.Services().Context();
-{
+TCalTime focusTime = context.DefaultCalTimeForViewsL();
-	OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEEDITINGCOMPLETED_ENTRY );
+context.SetFocusDateAndTimeL( focusTime,
+TVwsViewId( KUidCalendar, newViewUid ));
-	mController.Services().IssueNotificationL(ECalenNotifyEditorClosedFromViewer);
+if( iController.IsFasterAppFlagEnabled() )
+{
-	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLEEDITINGCOMPLETED_EXIT );
+// reset tha flag iAvoidRepopulation to refresh the view whenever
-}
+// system time is changed
+iAvoidRepopulation = EFalse;
-// ----------------------------------------------------------------------------
-// CalenViewManager::handleDeletingStarted
+if(IsNativeView(newViewUid))
-//  Slot to handle signal deletingStarted by the agenda event viewer
+{
-// (other items were commented in a header).
+// activate the default view in background
-// ----------------------------------------------------------------------------
+RequestActivationL( newViewUid );
-//
+}
-void CalenViewManager::handleDeletingStarted()
-{
+// set the flag iAvoidRepopulation to avoid repopulation
-	OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEDELETINGSTARTED_ENTRY );
+iAvoidRepopulation = ETrue;
+}
-	mController.IssueCommandL(ECalenDeleteEntryFromViewer);
+else
+{
-	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLEDELETINGSTARTED_EXIT );
+// refresh the current view
-}
+StartActiveStepL();
+}
-// ----------------------------------------------------------------------------
-// CalenViewManager::handleDeletingCompleted
+TRACE_EXIT_POINT;
-//  Slot to handle signal deletingCompleted by the agenda event viewer
+}
-// (other items were commented in a header).
-// ----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
-//
+// CCalenViewManager::IconsL
-void CalenViewManager::handleDeletingCompleted()
+// Create a CCalenIcons object if neccessary and return a reference
-{
+// (other items were commented in a header).
-	OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEDELETINGCOMPLETED_ENTRY );
+// -----------------------------------------------------------------------------
+CCalenIcons& CCalenViewManager::IconsL()
-	mController.Services().IssueNotificationL(ECalenNotifyEntryDeleted);
+{
+TRACE_ENTRY_POINT;
-	// invalidate captured screenshots as either month view or agenda view is activated now
-if (mCalenMonthView) {
+if (!iIcons)
-mCalenMonthView->captureScreenshot();
+{
-} else if (mCalenAgendaView) {
+// Icons
-	mCalenAgendaView->captureScreenshot();
+iIcons = CCalenIcons::NewL();
 }
-OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLEDELETINGCOMPLETED_EXIT );
+TRACE_EXIT_POINT;
-}
+return *iIcons;
+}
-// ----------------------------------------------------------------------------
-// CalenViewManager::handleInstanceViewCreation
+// -----------------------------------------------------------------------------
-//  Slot to handle completion of instance view creation
+// CCalenViewManager::GetNextViewIconL
-// (other items were commented in a header).
+// Gets next view icon
-// ----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
-//
+CGulIcon* CCalenViewManager::GetNextViewIconL()
-void CalenViewManager::handleInstanceViewCreation(int status)
+{
-{
+TRACE_ENTRY_POINT;
-OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEINSTANCEVIEWCREATION_ENTRY );
+// Set the view cycle index based on the newly activated view,
-	Q_UNUSED(status);
+// if the view is in the cycle array.
+TInt index = iViewInfoArray.Find( iCurrentViewId.iViewUid, CCalenViewInfo::ViewInfoIdentifier );
-	// This flag is needed if mCalenMonthView and mCalenAgendaview is not created
+if( index != KErrNotFound )
-	// and before that this slot is getting called.
+{
-	// if we launch views through services then this slot is getting called
+iViewCycleIndex = index;
-	// before the view construction.
+TInt nextVwIndex = iViewCycleIndex;
-	mInstanceViewCreated = true;
+do
+{
-	// handleInstanceViewCreation function is called only once. Now that the instance
+nextVwIndex = ( nextVwIndex + 1 )%(iViewInfoArray.Count());
-	// view creation is successfull. Events need to be populated on screen
+}while( iViewInfoArray[nextVwIndex]->CyclePosition() == CCalenView::ENoCyclePosition );
-	// Ideal colution should be to call a uniform function, e.g. PopulateEvents
-	// where PopulateEvents should be implemeted by all views. Since the current
+// Get the next view icon
-	// solution for the month view implements the construction in two phases so
+CCalenView* nextview = static_cast<CCalenView*>( iAppUi.View( iViewInfoArray[nextVwIndex]->ViewUid() ) );
-	// it needs to be refactored and a common solution needs to be put here. So
+return( nextview->ViewIconL() );
-	// that code doesn't break if another view is added tomorow
+}
-	HbView *currentview = mController.MainWindow().currentView();
+TRACE_EXIT_POINT;
-	if (mCalenMonthView && currentview == mCalenMonthView) {
+return NULL;
-		mCalenMonthView->fetchEntriesAndUpdateModel();
+}
-	}
-	else if (mCalenAgendaView && currentview == mCalenAgendaView) {
+// -----------------------------------------------------------------------------
-		mCalenAgendaView->doPopulation();
+// CCalenViewManager::SetRepopulation
-	}
+// Resets the flag iAvoidRepopulation to activate the view.
-else if (mCalenDayView && currentview == mCalenDayView) {
+// -----------------------------------------------------------------------------
-mCalenDayView->doPopulation();
+void CCalenViewManager::SetRepopulation(TBool aRePopulate)
-}
+{
-	// Calls the emitAppReady function of CalenController. Need to emit this
+TRACE_ENTRY_POINT;
-	// signal after the view is fully constructed & populated
+// to prevent the display of blank view,
-	// with actual data and ready to be used. So entry view & instance view
+// set the iAvoidRepopulation to EFalse,
-	// needs to be created so that a new entry can also be created. Finally
+// so that view is populated properly
-	// NotesApplication object needs to emit applicationReady Signal.
-	mController.emitAppReady();
+iAvoidRepopulation = aRePopulate;
-	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLEINSTANCEVIEWCREATION_EXIT );
+TRACE_EXIT_POINT;
 }
-// ----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
-// CalenViewManager::handleDeletingCompleted
+// CCalenViewManager::CalenToolbar
-//  Slot to handle completion of entry view creation
+// Returns calendar toolbar
-// (other items were commented in a header).
+// -----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
+CCalenToolbarImpl* CCalenViewManager::CalenToolbar()
-//
+{
-void CalenViewManager::handleEntryViewCreation(int status)
+TRACE_ENTRY_POINT;
-{
+TRACE_EXIT_POINT;
-OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEENTRYVIEWCREATION_ENTRY );
+return iToolbar;
+}
-	// Nothing Yet
-	Q_UNUSED(status);
+// -----------------------------------------------------------------------------
+// CCalenViewManager::ReloadAllPluginsL
-	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLEENTRYVIEWCREATION_EXIT );
+// Reload all plugins
-}
+// -----------------------------------------------------------------------------
+void CCalenViewManager::ReloadAllPluginsL()
-// ----------------------------------------------------------------------------
+{
-// CalenViewManager::handleEntriesChanged
+TRACE_ENTRY_POINT;
-// this function will be called when someone else has changed the database
-// ----------------------------------------------------------------------------
+// load all plugins
-//
+iCustomisationManager->DoPluginLoadingL();
-void CalenViewManager::handleEntriesChanged(QList<ulong> ids)
+UpdatePluginListL();
-{
-	Q_UNUSED(ids);
+// only activate plugin view if it is default view
-	HbView *currentview = mController.MainWindow().currentView();
+TUid defaultViewUid = iSetting->DefaultView();
-	if((mCalenMonthView == currentview)||(mCalenDayView == currentview)||
+if(!IsNativeView(defaultViewUid))
-(mCalenAgendaView == currentview )||(mCalenAgendaViewAlt == currentview))
+{
-	    {
+iAvoidRepopulation = EFalse;
-activateCurrentView();
-	    }
+// Find the default view in the view cycle list
-	delete currentview;
+TInt position = iViewInfoArray.Find(
-}
+defaultViewUid, CCalenViewInfo::ViewInfoIdentifier );
+if( position != KErrNotFound )
-// ----------------------------------------------------------------------------
+{
-// CalenViewManager::handleEntryUpdation
+TVwsViewId targetViewId( KUidCalendar, defaultViewUid);
-// this function will be called when any entry is updated or added into database
+RequestActivationL(targetViewId);
-// Here we need to set the context to the entry updated or added.
+iViewCycleIndex = position;
-// ----------------------------------------------------------------------------
+}
-//
+else
-void CalenViewManager::handleEntryUpdation(ulong id)
+{
-{
+// if plugin providing default view is already uninstalled
-AgendaEntry updatedEntry = mController.agendaInterface()->fetchById(id);
+// activate month view as default view
+CRepository* repository = CRepository::NewL( KCRUidCalendar );
-// Agenda entry is not null then refresh the view else close event viewer
+CleanupStack::PushL(repository);
-if (!updatedEntry.isNull()) {
+TInt tmp( static_cast<TInt>( KUidCalenMonthView.iUid ) );
-if (AgendaEntry::TypeTodo != updatedEntry.type()) {
+TInt position = iViewInfoArray.Find( KUidCalenMonthView, CCalenViewInfo::ViewInfoIdentifier );
-QDate date = updatedEntry.startTime().date();
+User::LeaveIfError( repository->Set( KCalendarDefaultStartView, tmp ) );
-if (!date.isNull() && date.isValid()) {
+iAppUi.SetDefaultViewL( *iAppUi.View( KUidCalenMonthView ) );
-mController.Services().Context().setFocusDate(QDateTime(date));
+TVwsViewId targetViewId( KUidCalendar, KUidCalenMonthView);
-}
+RequestActivationL(targetViewId);
-}
+iViewCycleIndex = position;
-}
+CleanupStack::PopAndDestroy(repository);
+}
 }
-// ----------------------------------------------------------------------------
+TRACE_EXIT_POINT;
-// CalenViewManager::launchSettingsView
+}
-// Launches settings view
-// (other items were commented in a header).
+// -----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
+// CCalenViewManager::GetPreviousViewUid
-//
+// Rest of the details are commented in header.
-void CalenViewManager::launchSettingsView()
+// -----------------------------------------------------------------------------
-{
+TUid CCalenViewManager::GetPreviousViewUid()
-OstTraceFunctionEntry0( CALENVIEWMANAGER_LAUNCHSETTINGSVIEW_ENTRY );
+{
+return iPreviousViewId.iViewUid;
-mPreviousViewsId = mCurrentViewId ;
+}
-mCurrentViewId = ECalenShowSettings;
-mSettingsView->initializeForm();
+// -----------------------------------------------------------------------------
-mController.Services().MainWindow().setCurrentView(mSettingsView);
+// CCalenViewManager::SetPreviousViewUid
+// Rest of the details are commented in header.
-// capture cureent view in case app closed/quits from settings view
+// -----------------------------------------------------------------------------
-if (mCalenMonthView){
+void CCalenViewManager::SetPreviousViewUid(TUid aPreviousUid)
-mCalenMonthView->captureScreenshot(true);
+{
-} else if(mCalenAgendaView){
+iPreviousViewId.iViewUid = aPreviousUid;
-	mCalenAgendaView->captureScreenshot(true);
+}
-}
+// -----------------------------------------------------------------------------
+// CCalenViewManager::IsNativeView
-OstTraceFunctionExit0( CALENVIEWMANAGER_LAUNCHSETTINGSVIEW_EXIT );
+// Check for native view
-}
+// -----------------------------------------------------------------------------
+TBool CCalenViewManager::IsNativeView(TUid aViewUid)
+{
-// ----------------------------------------------------------------------------
+TRACE_ENTRY_POINT;
-// CalenViewManager::removeSettingsView
-// remove settings view
+if( (aViewUid == KUidCalenMonthView)||
-// ----------------------------------------------------------------------------
+(aViewUid == KUidCalenWeekView) ||
-//
+(aViewUid == KUidCalenDayView) ||
-void CalenViewManager::removeSettingsView()
+(aViewUid == KUidCalenTodoView) )
 {
-if(mSettingsView){
+TRACE_EXIT_POINT;
-mController.Services().MainWindow().removeView(mSettingsView);
+return ETrue;
 }
-}
+TRACE_EXIT_POINT;
+return EFalse;
-// ----------------------------------------------------------------------------
+}
-// CalenViewManager::isEventViewerActive
-// check if Agenda Event Viewer is active
+// -----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
+// CCalenViewManager::ActivateViewOnFakeExitL
-//
+// Check for native view
-bool CalenViewManager::isEventViewerActive()
+// -----------------------------------------------------------------------------
-{
+void CCalenViewManager::ActivateViewOnFakeExitL(TUid aDefView)
-if(mCalenEventViewer)
+{
-return true;
+TRACE_ENTRY_POINT;
-else
+iFakeExit = ETrue;
-return false;
+if(IsNativeView(aDefView))
-}
+{
+// activate the view in background
-// ----------------------------------------------------------------------------
+RequestActivationL( aDefView, KCalenHideInBackGround, KNullDesC8() );
-// CalenViewManager::saveAndCloseEditor
+}
-// save the entry and close the editor
+else
-// isEventViewerActive() should be called before this function
+{
-// ----------------------------------------------------------------------------
+RequestActivationL( KUidCalenDummyView, KCalenHideInBackGround, KNullDesC8() );
-//
+}
-void CalenViewManager::saveAndCloseEditor()
-{
+// set the flag to avoid repopulation when application is
-mCalenEventViewer->saveAndCloseEditor();
+// opened after faster exit
-}
+iAvoidRepopulation = ETrue;
-// ----------------------------------------------------------------------------
+// set the context
-// CalenViewManager::closeAgendaEventView
+MCalenContext& context = iController.Services().Context();
-// close the agenda event view
+TCalTime focusTime = context.DefaultCalTimeForViewsL();
-// isEventViewerActive() should be called before this function
+context.SetFocusDateAndTimeL( focusTime,
-// ----------------------------------------------------------------------------
+TVwsViewId( KUidCalendar, aDefView) );
-//
-void CalenViewManager::closeAgendaEventView()
+TRACE_EXIT_POINT;
-{
+}
-mCalenEventViewer->closeAgendaEventView();
-}
+// -----------------------------------------------------------------------------
+// CCalenViewManager::ActivateLocalViewL
+// Activate the local view if application already in back ground
-// End of file	--Don't remove this.
+// -----------------------------------------------------------------------------
+void CCalenViewManager::ActivateLocalViewL(TUid aDefView)
+{
+iAppUi.ActivateLocalViewL( aDefView );
+}
+// -----------------------------------------------------------------------------
+// CCalenViewManager::ChangeDayL
+// Change day when preview pane swipped
+// -----------------------------------------------------------------------------
+void CCalenViewManager::ChangeDayL( TBool aNextDay )
+{
+TInt aInterval(1);
+MCalenContext& context = iController.Services().Context();
+TCalTime focusedTime = context.FocusDateAndTimeL();
+TTime newDay(0);
+if ( aNextDay )
+{
+newDay = focusedTime.TimeLocalL() + TTimeIntervalDays( aInterval );
+}
+else
+{
+newDay = focusedTime.TimeLocalL() - TTimeIntervalDays( aInterval );
+}
+focusedTime.SetTimeLocalL( newDay );
+context.SetFocusDateAndTimeL( focusedTime,
+iCurrentViewId );
+}
+// End of file

changeset 89	b57382753122
parent 81	ce92091cbd61