--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/calendarui/controller/src/calenviewmanager.cpp Tue Feb 02 10:12:19 2010 +0200
@@ -0,0 +1,1803 @@
+/*
+* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Calendar view manager
+*
+*/
+
+
+#include <aknViewAppUi.h>
+#include <centralrepository.h>
+#include <AknQueryDialog.h>
+#include <Calendar.rsg>
+#include <calencommonui.rsg>
+#include <akntoolbar.h>
+#include <calendateutils.h>
+#include <calencommandhandler.h>
+#include <calencommands.hrh> // Calendar commands
+#include <calentoolbar.h>
+#include <akntoolbarextension.h>
+#include <calenactionuiutils.h>
+
+#include "calendarui_debug.h"
+#include "calenviewmanager.h"
+#include "CalenUid.h"
+#include "calencontroller.h"
+#include "calenviewpopulator.h"
+#include "calenglobaldata.h"
+#include "CalendarPrivateCRKeys.h" // includes CalendarInternalCRKeys.h
+#include "calenmonthview.h" // Native month view
+#include "calenweekview.h" // Native week view
+#include "calendayview.h" // Native day view
+#include "calentodoview.h" // Native todo view
+#include "caleneventview.h" // Event View
+#include "calenmissedalarmsview.h" // Missed alarms view
+#include "calenmissedeventview.h" // Missed event view
+#include "calensetting.h" // CCalenSetting::TViewType
+#include "calencmdlinelauncher.h" // Command line launcher
+#include "calenservicesimpl.h"
+#include "CleanupResetAndDestroy.h"
+#include "calentoolbarimpl.h"
+#include "calencustomisationmanager.h"
+#include "calenviewinfo.h"
+#include "calentitlepane.h"
+#include "calenicons.h"
+#include "calendummyview.h"
+
+const TInt KArrayGranularity = 5;
+
+// ----------------------------------------------------------------------------
+// CCalenViewManager::NewL
+// 1st phase of construction
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+CCalenViewManager* CCalenViewManager::NewL( CAknViewAppUi& aAppUi,
+ CCalenController& aController )
+ {
+ TRACE_ENTRY_POINT;
+
+ CCalenViewManager* self = new( ELeave ) CCalenViewManager( aAppUi,aController );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+
+ TRACE_EXIT_POINT;
+ return self;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenViewManager::CCalenViewManager
+// C++ default Constructor.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+CCalenViewManager::CCalenViewManager( CAknViewAppUi& aAppUi,
+ CCalenController& aController )
+ : iAppUi( aAppUi ), iController( aController )
+ {
+ TRACE_ENTRY_POINT;
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenViewManager::~CCalenViewManager
+// Destructor.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+CCalenViewManager::~CCalenViewManager()
+ {
+ TRACE_ENTRY_POINT;
+
+ delete iPopulator;
+ delete iToolbar;
+
+ if( iSetting )
+ {
+ iSetting->Release();
+ }
+
+ if( iGlobalData )
+ {
+ iGlobalData->Release();
+ }
+
+ iViewInfoArray.ResetAndDestroy();
+ iKnownPlugins.Reset();
+
+ delete iRemovedActiveView;
+ delete iViewRemovalCallback;
+ delete iIcons;
+
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenViewManager::ConstructL
+// 2nd phase of construction.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenViewManager::ConstructL()
+ {
+ TRACE_ENTRY_POINT;
+
+ iGlobalData = CCalenGlobalData::InstanceL();
+ iPopulator = CCalenViewPopulator::NewL( iController );
+
+ // Only create a toolbar impl if touch is enabled and a CAknToolbar exists
+ if( AknLayoutUtils::PenEnabled() )
+ {
+ CAknAppUi* appUi = static_cast<CAknAppUi*>( CEikonEnv::Static()->EikAppUi() );
+ if (appUi->CurrentFixedToolbar())
+ {
+ iToolbar = CCalenToolbarImpl::NewL( iController );
+ }
+ }
+
+ iSetting = CCalenSetting::InstanceL();
+ iPreviousViewId.iViewUid = KNullUid;
+ iAvoidRepopulation = EFalse;
+ iStartupComplete = ETrue;
+
+ 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.
+ }
+
+ if( CreateNativeViewL(KUidCalenEventView))
+ {
+ // Views take ownership of services object instantly.
+ // No need for cleanup stack.
+ CCalenEventView* eventView = CCalenEventView::NewL(services);
+ AddNativeViewL(eventView); // takes ownership immediately.
+ }
+
+ if( CreateNativeViewL(KUidCalenMissedAlarmsView))
+ {
+ // Views take ownership of services object instantly.
+ // No need for cleanup stack.
+ CCalenMissedAlarmsView* missedAlarmsView = CCalenMissedAlarmsView::NewL(services);
+ AddNativeViewL(missedAlarmsView); // takes ownership immediately.
+ }
+
+ if( CreateNativeViewL(KUidCalenMissedEventView))
+ {
+ // Views take ownership of services object instantly.
+ // No need for cleanup stack.
+ CCalenMissedEventView* missedEventView = CCalenMissedEventView::NewL(services);
+ AddNativeViewL(missedEventView); // takes ownership immediately.
+ }
+
+ if(CreateNativeViewL(KUidCalenDummyView))
+ {
+ CCalenDummyView* dummyView = CCalenDummyView::NewL(services);
+ AddNativeViewL(dummyView);
+ }
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenViewManager::CreateNativeViewL
+// Checks to see if the native view needs to created.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+TBool CCalenViewManager::CreateNativeViewL(TUid aViewUid)
+ {
+ TRACE_ENTRY_POINT;
+
+ TBool createNativeView = ETrue;
+ TBool (*compareFn)(const TUid*, const CCalenViewInfo&)
+ = CCalenViewInfo::ViewInfoIdentifier;
+
+ TInt position = iViewInfoArray.Find( aViewUid, compareFn );
+ if ( position != KErrNotFound )
+ {
+ // A plugin is trying to replace a native view, find if it is rom
+ // based or not
+ TBool romBased = CustomisationManager().IsViewRomBased( aViewUid );
+ if ( romBased )
+ {
+ createNativeView = EFalse;
+ }
+ else
+ {
+ // A non-rom plugin cannot replace the native views, so the view is
+ // removed
+ iAppUi.RemoveView( aViewUid );
+
+ // Remove the entry from the view info array
+ iViewInfoArray.Remove( position );
+
+ createNativeView = ETrue;
+ }
+ }
+
+ TRACE_EXIT_POINT;
+ return createNativeView;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenViewManager::ConstructCustomViewsL
+// Constructs any custom views from all the plugins and registers them
+// with the view server
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenViewManager::ConstructCustomViewsL()
+ {
+ TRACE_ENTRY_POINT;
+
+ // Get the array of active plugins
+ const RArray<TUid>& plugins = CustomisationManager().ActivePlugins();
+
+ // For every active plugin, discover if it offers any customised views
+ // and adds them to the view server.
+ TInt numPlugins = plugins.Count();
+ for( TInt pluginIndex( 0 ); pluginIndex < numPlugins; ++pluginIndex )
+ {
+ TUid pluginUid = plugins[pluginIndex];
+ ConstructCustomViewL( pluginUid );
+ }
+
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenViewManager::ConstructCustomViewsL
+// Constructs the custom views from a particular plugin and registers them
+// with the view server
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenViewManager::ConstructCustomViewL( TUid aPluginUid )
+ {
+ TRACE_ENTRY_POINT;
+
+ iKnownPlugins.AppendL( aPluginUid );
+
+ RPointerArray<CCalenView> customViews;
+ CleanupResetAndDestroyPushL( customViews );
+
+ 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() );
+
+ // Discover if a native view has been hidden by a plugin.
+ TBool hidden = iCustomisationManager->HiddenView( viewUid );
+ viewInfo->Hide( hidden );
+
+ // Append to view info array
+ iViewInfoArray.InsertInOrderAllowRepeatsL( viewInfo,
+ CCalenViewInfo::CyclePositionComparison );
+
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenViewManager::HandleCommandL
+// Handles view manager commands.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+TBool CCalenViewManager::HandleCommandL( const TCalenCommand& aCommand )
+ {
+ TRACE_ENTRY_POINT;
+
+ TBool commandUsed(EFalse);
+
+ switch( aCommand.Command() )
+ {
+ case ECalenMonthView:
+ {
+ RequestActivationL( KUidCalenMonthView );
+ }
+ break;
+ case ECalenWeekView:
+ {
+ RequestActivationL( KUidCalenWeekView );
+ }
+ break;
+ case ECalenDayView:
+ {
+ // reset the flag iForwardedToDayView as view switching is active
+ if(iPreviousToDayView.iViewUid!=KNullUid)
+ {
+ iPreviousToDayView.iViewUid = KNullUid;
+ }
+ RequestActivationL( KUidCalenDayView, KCalenDummyUid, KNullDesC8() );
+ }
+ 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;
+ RequestActivationL( KUidCalenDayView, 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);
+
+ // dim "today" toolbar item since focus is on today
+ iToolbar->Toolbar().SetItemDimmed( ECalenGotoToday, ETrue, ETrue);
+ }
+ 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;
+
+ iCurrentViewId = aNewlyActivatedViewId;
+ }
+ }
+
+ iViewsActivated = ETrue;
+
+ // check for iAvoidRepopulation to avoid repopulation whenever
+ // 1) Application comes to foreground
+ // 2) Applictaion is opened after fake exit
+ if(!iAvoidRepopulation)
+ {
+ 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
+ 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 );
+ }
+ }
+ }
+
+ // Show list query.
+ TInt choice = KErrCancel; //KErrNotFound;
+ CAknListQueryDialog* dlg = new( ELeave ) CAknListQueryDialog( &choice );
+ dlg->PrepareLC( R_CALENDAR_SWITCH_VIEW_QUERY ); // pushes dlg to CS
+ dlg->SetItemTextArray( viewNames );
+ dlg->SetOwnershipType( ELbmDoesNotOwnItemArray );
+
+ // Set title
+ CAknPopupHeadingPane* heading = dlg->Heading();
+ HBufC* title = NULL;
+ title = CCoeEnv::Static()->AllocReadResourceLC( R_CALENDAR_SWITCH_VIEW_QUERY_TITLE );
+ heading->SetTextL( *title );
+ CleanupStack::PopAndDestroy( title );
+
+ if( dlg->RunLD() )
+ {
+ // user made a choice
+ TUid viewUid = viewUids[choice];
+ RequestActivationL( viewUid );
+ }
+
+ CleanupStack::PopAndDestroy(); // viewUids
+ CleanupStack::PopAndDestroy( viewNames );
+
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenViewManager::HandleNotification
+// Calls back when notifications that it has been registered for are broadcast
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenViewManager::HandleNotification(const TCalenNotification aNotification )
+ {
+ TRACE_ENTRY_POINT;
+
+ PIM_TRAPD_HANDLE( HandleNotificationL( aNotification ) );
+
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenViewManager::HandleNotificationL
+// Called from HandleNotification() when notifications that it has been
+// registered for are broadcast
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenViewManager::HandleNotificationL( TCalenNotification aNotification )
+ {
+ TRACE_ENTRY_POINT;
+
+ switch( aNotification )
+ {
+ case ECalenNotifyPluginEnabledDisabled:
+ {
+ UpdatePluginListL();
+ }
+ break;
+ case ECalenNotifySettingsClosed:
+ {
+ // Nothing has changed, refresh statuspane only.
+ iAppUi.StatusPane()->DrawNow();
+ }
+ break;
+ case ECalenNotifySettingsChanged:
+ {
+ HandleSettingsChangeNotificationL();
+ }
+ break;
+ case ECalenNotifyEntryDeleted:
+ case ECalenNotifyInstanceDeleted:
+ {
+ HandleEntryDeleteNotificationL();
+ }
+ break;
+ case ECalenNotifySystemLocaleChanged:
+ case ECalenNotifyEntrySaved:
+ case ECalenNotifyMultipleEntriesDeleted:
+ case ECalenNotifyExternalDatabaseChanged:
+ case ECalenNotifyCancelDelete:
+ case ECalenNotifyCalendarFieldChanged:
+ case ECalenNotifyMarkedEntryCompleted:
+ case ECalenNotifyCalendarInfoCreated:
+ case ECalenNotifyCalendarInfoUpdated:
+ {
+ StartActiveStepL();
+ }
+ 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();
+ }
+ }
+ 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 ECalenNotifyAppBackgrounded:
+ {
+ // set the flag iAvoidRepopulation to prevent repopulation
+ // whenever application is brought to foreground
+ iAvoidRepopulation = ETrue;
+
+ if( iController.IsFasterAppFlagEnabled() )
+ {
+ 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;
+ return iToolbar;
+ }
+
+// ----------------------------------------------------------------------------
+// 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() );
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenViewManager::HandleFasterAppExitCommandL
+// Handles ECalenFasterAppExit command
+// ----------------------------------------------------------------------------
+void CCalenViewManager::HandleFasterAppExitCommandL()
+ {
+ TRACE_ENTRY_POINT;
+
+ if(iToolbar)
+ {
+ iToolbar->SetToolbarExtensionFocus(EFalse);
+ }
+
+ // For Handling : When the default view is changed keeping that view open,
+ // from day view changing the default view from month view to day view,
+ // we need to reset the previous view id.
+ if(iPreviousToDayView.iViewUid!=KNullUid)
+ {
+ iPreviousToDayView.iViewUid = KNullUid;
+ }
+
+ // For handling specific case::Calendar exited from FSW
+ // iAvoidRepopulation is set when app backgrounded.
+ // Reset the flag for activating the view in background
+ if(iAvoidRepopulation)
+ {
+ iAvoidRepopulation = EFalse;
+ }
+
+ // In case of fasterapp exit, first activate the dummy view before deleting the plugin views
+ // Get the default view before we remove plugins
+ iPreviousViewId.iViewUid = KNullUid;
+
+ iController.SetExitOnDialogFlag( EFalse ); // for making iisexitondialogclose EFalse.
+
+ TUid defView = iSetting->DefaultView();
+
+ // unload all plugins
+ iCustomisationManager->DisableAllPluginsL();
+ ActivateViewOnFakeExitL(defView);
+ // Though the current view is active view, there is no need to issue a callback as we are exiting the whole application.
+ if( iRemovedActiveView )
+ {
+
+ if( !iViewRemovalCallback )
+ {
+ TCallBack callback( RemoveDeActivatedView, this );
+ iViewRemovalCallback = new( ELeave ) CAsyncCallBack( callback,
+ CActive::EPriorityStandard );
+ }
+ iViewRemovalCallback->CallBack();
+ }
+
+ TRACE_EXIT_POINT;
+ }
+// ----------------------------------------------------------------------------
+// CCalenViewManager::HandleSettingsChangeNotificationL
+// Handles ECalenNotifySettingsChanged notification
+// ----------------------------------------------------------------------------
+void CCalenViewManager::HandleSettingsChangeNotificationL()
+ {
+ TRACE_ENTRY_POINT;
+
+ if( iController.IsFasterAppFlagEnabled() )
+ {
+ TUid newViewUid = iSetting->DefaultView();
+ if(IsNativeView(newViewUid))
+ {
+ TUid oldViewUid = CurrentView();
+ if( newViewUid.iUid != oldViewUid.iUid )
+ {
+ RequestActivationL( newViewUid );
+ }
+ }
+
+ // If the plugins are activated using general settings.
+ // unload all plugins.Only load the plugins when application
+ // comes to foreground
+ const RArray<TUid>& plugins = CustomisationManager().ActivePlugins();
+ if(plugins.Count())
+ {
+ // unload all plugins
+ 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)
+ {
+ RequestActivationL(iPreviousViewId.iViewUid);
+ }
+ }
+ else
+ {
+ // refresh the current view
+ StartActiveStepL();
+ }
+
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenViewManager::HandleEntryClosedNotificationL
+// Handles ECalenNotifyEntryClosed notification
+// ----------------------------------------------------------------------------
+void CCalenViewManager::HandleEntryClosedNotificationL()
+ {
+ TRACE_ENTRY_POINT;
+
+ // reset tha flag iAvoidRepopulation to refresh the view.
+ iAvoidRepopulation = EFalse;
+
+ // if previous view is native view activate that view
+ // otherwise commandlauncher will handle
+ if(iPreviousViewId.iViewUid != KNullUid)
+ {
+ // if iPreviousToDayView is active activate the day view with "Back" cba.
+ if(iPreviousToDayView.iViewUid!=KNullUid)
+ {
+ RequestActivationL(iPreviousViewId.iViewUid, KUidCalenShowBackCba);
+ }
+ else
+ {
+ if( !iController.GetExitOnDialogFlag() )
+ {
+ RequestActivationL(iPreviousViewId.iViewUid);
+ }
+ }
+ }
+
+ // reset tha flag iAvoidRepopulation to avoid the repopulation.
+ iAvoidRepopulation = ETrue;
+
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenViewManager::HandleSystemTimeChangeNotificationL
+// Handles ECalenNotifySystemTimeChanged notification
+// ----------------------------------------------------------------------------
+void CCalenViewManager::HandleSystemTimeChangeNotificationL()
+ {
+ TRACE_ENTRY_POINT;
+
+ if( iController.IsFasterAppFlagEnabled() )
+ {
+ //Set the context whenever system time is changed
+ TUid newViewUid = iSetting->DefaultView();
+ MCalenContext& context = iController.Services().Context();
+ TCalTime focusTime = context.DefaultCalTimeForViewsL();
+ context.SetFocusDateAndTimeL( focusTime,
+ TVwsViewId( KUidCalendar, newViewUid ));
+
+ // reset tha flag iAvoidRepopulation to refresh the view whenever
+ // system time is changed
+ iAvoidRepopulation = EFalse;
+
+ if(IsNativeView(newViewUid))
+ {
+ // activate the default view in background
+ RequestActivationL( newViewUid );
+ }
+
+ // set the flag iAvoidRepopulation to avoid repopulation
+ iAvoidRepopulation = ETrue;
+ }
+ else
+ {
+ // refresh the current view
+ StartActiveStepL();
+ }
+
+ TRACE_EXIT_POINT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenViewManager::IconsL
+// Create a CCalenIcons object if neccessary and return a reference
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+CCalenIcons& CCalenViewManager::IconsL()
+ {
+ TRACE_ENTRY_POINT;
+
+ if (!iIcons)
+ {
+ // Icons
+ iIcons = CCalenIcons::NewL();
+ }
+
+ TRACE_EXIT_POINT;
+ return *iIcons;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenViewManager::GetNextViewIconL
+// Gets next view icon
+// -----------------------------------------------------------------------------
+CGulIcon* CCalenViewManager::GetNextViewIconL()
+ {
+ TRACE_ENTRY_POINT;
+
+ // Set the view cycle index based on the newly activated view,
+ // if the view is in the cycle array.
+ TInt index = iViewInfoArray.Find( iCurrentViewId.iViewUid, CCalenViewInfo::ViewInfoIdentifier );
+ if( index != KErrNotFound )
+ {
+ iViewCycleIndex = index;
+ TInt nextVwIndex = iViewCycleIndex;
+ do
+ {
+ nextVwIndex = ( nextVwIndex + 1 )%(iViewInfoArray.Count());
+ }while( iViewInfoArray[nextVwIndex]->CyclePosition() == CCalenView::ENoCyclePosition );
+
+ // Get the next view icon
+ CCalenView* nextview = static_cast<CCalenView*>( iAppUi.View( iViewInfoArray[nextVwIndex]->ViewUid() ) );
+ return( nextview->ViewIconL() );
+ }
+
+ TRACE_EXIT_POINT;
+ return NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenViewManager::SetRepopulation
+// Resets the flag iAvoidRepopulation to activate the view.
+// -----------------------------------------------------------------------------
+void CCalenViewManager::SetRepopulation(TBool aRePopulate)
+ {
+ TRACE_ENTRY_POINT;
+ // to prevent the display of blank view,
+ // set the iAvoidRepopulation to EFalse,
+ // so that view is populated properly
+
+ iAvoidRepopulation = aRePopulate;
+
+ TRACE_EXIT_POINT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenViewManager::CalenToolbar
+// Returns calendar toolbar
+// -----------------------------------------------------------------------------
+CCalenToolbarImpl* CCalenViewManager::CalenToolbar()
+ {
+ TRACE_ENTRY_POINT;
+ TRACE_EXIT_POINT;
+ return iToolbar;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenViewManager::ReloadAllPluginsL
+// Reload all plugins
+// -----------------------------------------------------------------------------
+void CCalenViewManager::ReloadAllPluginsL()
+ {
+ TRACE_ENTRY_POINT;
+
+ // load all plugins
+ iCustomisationManager->DoPluginLoadingL();
+ UpdatePluginListL();
+
+ // only activate plugin view if it is default view
+ TUid defaultViewUid = iSetting->DefaultView();
+ if(!IsNativeView(defaultViewUid))
+ {
+ iAvoidRepopulation = EFalse;
+
+ // Find the default view in the view cycle list
+ TInt position = iViewInfoArray.Find(
+ defaultViewUid, CCalenViewInfo::ViewInfoIdentifier );
+ if( position != KErrNotFound )
+ {
+ TVwsViewId targetViewId( KUidCalendar, defaultViewUid);
+ RequestActivationL(targetViewId);
+ iViewCycleIndex = position;
+ }
+ else
+ {
+ // if plugin providing default view is already uninstalled
+ // activate month view as default view
+ 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 ) );
+ TVwsViewId targetViewId( KUidCalendar, KUidCalenMonthView);
+ RequestActivationL(targetViewId);
+ iViewCycleIndex = position;
+ CleanupStack::PopAndDestroy(repository);
+ }
+ }
+ else // If default view is native view, then activate it
+ {
+ iAvoidRepopulation = EFalse;
+ // In case of launching missed event view or missed alarms view, there
+ // is no need to activate default view.
+ if( ( iCurrentViewId.iViewUid.iUid != KCalenMissedEventViewUidValue ) &&
+ ( iCurrentViewId.iViewUid.iUid != KCalenMissedAlarmsViewUidValue ) )
+ {
+ // Find the default view in the view cycle list
+ TInt position = iViewInfoArray.Find(
+ defaultViewUid, CCalenViewInfo::ViewInfoIdentifier );
+ if( position != KErrNotFound )
+ {
+ TVwsViewId targetViewId( KUidCalendar, defaultViewUid);
+ RequestActivationL(targetViewId);
+ iViewCycleIndex = position;
+ }
+ }
+ }
+
+ TRACE_EXIT_POINT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenViewManager::GetPreviousViewUid
+// Rest of the details are commented in header.
+// -----------------------------------------------------------------------------
+TUid CCalenViewManager::GetPreviousViewUid()
+ {
+ return iPreviousViewId.iViewUid;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenViewManager::IsNativeView
+// Check for native view
+// -----------------------------------------------------------------------------
+TBool CCalenViewManager::IsNativeView(TUid aViewUid)
+ {
+ TRACE_ENTRY_POINT;
+
+ if( (aViewUid == KUidCalenMonthView)||
+ (aViewUid == KUidCalenWeekView) ||
+ (aViewUid == KUidCalenDayView) ||
+ (aViewUid == KUidCalenTodoView) )
+ {
+ TRACE_EXIT_POINT;
+ return ETrue;
+ }
+ TRACE_EXIT_POINT;
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenViewManager::ActivateViewOnFakeExitL
+// Check for native view
+// -----------------------------------------------------------------------------
+void CCalenViewManager::ActivateViewOnFakeExitL(TUid aDefView)
+ {
+ TRACE_ENTRY_POINT;
+
+ if(IsNativeView(aDefView))
+ {
+ // activate the view in background
+ RequestActivationL( aDefView, KCalenHideInBackGround, KNullDesC8() );
+ }
+ else
+ {
+ RequestActivationL( KUidCalenDummyView, KCalenHideInBackGround, KNullDesC8() );
+ }
+
+ // set the flag to avoid repopulation when application is
+ // opened after faster exit
+ iAvoidRepopulation = ETrue;
+
+ // set the context
+ MCalenContext& context = iController.Services().Context();
+ TCalTime focusTime = context.DefaultCalTimeForViewsL();
+ context.SetFocusDateAndTimeL( focusTime,
+ TVwsViewId( KUidCalendar, aDefView) );
+
+ TRACE_EXIT_POINT;
+ }
+// End of file